11 #include <boost/shared_ptr.hpp> 17 #define BOOST_DISABLE_THREADS 26 static const bool handleErrors=
true;
39 static const bool handleErrors=
false;
46 template <poly_variant,
class,
class>
friend class PolyBase;
82 if (
this==&p2)
return *
this;
106 number two=
n_Init(2,
r.get()->cf);
176 this->p=
p_Copy(p,r.get());
210 intrusive_ptr<ip_sring>
r;
260 using namespace boost;
284 public std::iterator<std::input_iterator_tag,T,int, shared_ptr<const T>,ConstTermReference<T> >
325 return shared_ptr<const T>(
new T(
p_Head(t,r),r,0));
329 template<poly_variant variant,
class create_type_input,
class error_handle_traits>
class PolyBase 336 return p_Copy(ptr->p,ptr->getRing());
340 if (error_handle_traits::handleErrors)
342 if (p.getRing()!=this->getRing())
344 error_handle_traits::handleDifferentRing(this->getRing(),
354 int nvars=
rVar(ptr->r.get());
356 for(
int i=0;
i<nvars;
i++)
376 return p_String(ptr->p,ptr->getRing(),ptr->getRing());
383 char* cp=(
char*)
omAlloc((strlen(c)+1)*
sizeof(char));
428 return ptr->getRing();
434 return ptr->leadCoef();
437 create_type erg(*
this);
438 erg*=
Number(-1,ptr->getRing());
447 return ptr->getInternalReference();
455 class Poly:
public PolyBase<POLY_VARIANT_RING, Poly, MyErrorHandler>{
485 for(i=0;i<v.size();i++){
535 for(i=0;i<v.size();i++){
587 template <poly_variant variant,
class create_type,
class error_traits>
611 if (r1!=r2)
return false;
617 if (r1!=r2)
return false;
620 template <poly_variant variant,
class create_type,
class error_traits>
640 template <poly_variant variant,
class create_type,
class error_traits>
PolyImpl & operator*=(const Number &n)
PolyInputIterator< create_type > begin()
Poly(int n, ring r=currRing)
const CanonicalForm int s
Poly(const char *c, ring r=currRing)
PolyImpl & operator=(const PolyImpl &p2)
int lmTotalDegree() const
Vector & operator+=(const Base &p)
poly getInternalReference()
PolyImpl(const PolyImpl &p)
char * p_String(poly p, ring lmRing, ring tailRing)
Compatiblity layer for legacy polynomial operations (over currRing)
PolyImpl & operator-=(const PolyImpl &p2)
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
PolyBase(ring r=currRing)
Vector unitVector(int i, ring r=currRing)
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
static void handleDifferentRing(ring r, ring s)
Poly & operator+=(const Poly &p)
Vector(poly p, ring r, int)
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
static short rVar(const ring r)
#define rVar(r) (r->N)
PolyBase< variant, create_type_input, error_handle_traits > ThisType
static void handleDifferentRing(ring r, ring s)
PolyInputIterator< create_type > end()
intrusive_ptr< ip_sring > r
void WerrorS(const char *s)
PolyImpl operator-(const PolyImpl &p1, const PolyImpl &p2)
static poly p_Copy(poly p, const ring r)
returns a copy of p
PolyImpl & operator+=(const PolyImpl &p2)
intrusive_ptr< ip_sring > r
static BOOLEAN p_LmIsConstant(const poly p, const ring r)
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
const char * p_Read(const char *st, poly &rc, const ring r)
PolyBase & operator+=(const PolyBase &p2)
static poly p_Head(poly p, const ring r)
create_type_input create_type
PolyImpl operator+(const PolyImpl &p1, const PolyImpl &p2)
poly getInternalReference() const
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
static long pTotaldegree(poly p)
PolyBase(const char *c, ring r=currRing)
PolyBase< POLY_VARIANT_MODUL, Vector, MyErrorHandler > Base
PolyImpl & operator=(int n)
Vector(std::vector< int > v, ring r=currRing)
Vector(const char *c, ring r=currRing)
PolyBase & operator*=(Number n)
PolyImpl(const Number &n)
PolyBase(poly p, ring r, int)
void PrintS(const char *s)
static poly p_Mult_nn(poly p, number n, const ring r)
Vector(int n, ring r=currRing)
PolyImpl(poly p, intrusive_ptr< ip_sring > r)
BOOLEAN p_EqualPolys(poly p1, poly p2, const ring r)
static void p_Delete(poly *p, const ring r)
const Variable & v
< [in] a sqrfree bivariate poly
PolyImpl(int n, intrusive_ptr< ip_sring > r)
PolyImpl & operator*=(const PolyImpl &p2)
Vector & operator+=(const Vector &p)
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
PolyBase(const PolyBase &p)
PolyInputIterator< create_type > iterator
PolyImpl(poly p, intrusive_ptr< ip_sring > r, int)
shared_ptr< PolyImpl > ptr
bool operator==(const Poly &p1, const Poly &p2)
ConstTermReference(poly p, ring r)
TrivialErrorHandler MyErrorHandler
PolyBase< POLY_VARIANT_RING, Poly, MyErrorHandler > Base
static poly p_Neg(poly p, const ring r)
void p_Write(poly p, ring lmRing, ring tailRing)
PolyBase & operator*=(const Poly &p2)
Poly(poly p, ring r, int)
static poly p_Add_q(poly p, poly q, const ring r)
Rational operator/(const Rational &a, const Rational &b)
PolyImpl operator*(const PolyImpl &p1, const PolyImpl &p2)
Poly(const std::vector< int > &v, ring r=currRing)
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
static poly p_Mult_q(poly p, poly q, const ring r)
void checkIsSameRing(T &p)
Poly & operator+=(const Base &p)