My Project  debian-1:4.1.2-p1+ds-2
Macros | Typedefs | Functions | Variables
polys.h File Reference
#include "polys/monomials/ring.h"
#include "polys/monomials/p_polys.h"
#include "coeffs/numbers.h"

Go to the source code of this file.

Macros

#define pSetCoeff(p, n)   p_SetCoeff(p,n,currRing)
 deletes old coeff before setting the new one More...
 
#define pGetOrder(p)   p_GetOrder(p, currRing)
 Order. More...
 
#define pGetComp(p)   (int)__p_GetComp(p, currRing)
 Component. More...
 
#define pSetComp(p, v)   p_SetComp(p,v, currRing)
 
#define pGetExp(p, i)   p_GetExp(p, i, currRing)
 Exponent. More...
 
#define pSetExp(p, i, v)   p_SetExp(p, i, v, currRing)
 
#define pIncrExp(p, i)   p_IncrExp(p,i, currRing)
 
#define pDecrExp(p, i)   p_DecrExp(p,i, currRing)
 
#define pAddExp(p, i, v)   p_AddExp(p,i,v, currRing)
 
#define pSubExp(p, i, v)   p_SubExp(p,i,v, currRing)
 
#define pMultExp(p, i, v)   p_MultExp(p,i,v, currRing)
 
#define pGetExpSum(p1, p2, i)   p_GetExpSum(p1, p2, i, currRing)
 
#define pGetExpDiff(p1, p2, i)   p_GetExpDiff(p1, p2, i, currRing)
 
#define pNew()   p_New(currRing)
 allocates the space for a new monomial – no initialization !!! More...
 
#define pInit()   p_Init(currRing,currRing->PolyBin)
 allocates a new monomial and initializes everything to 0 More...
 
#define pLmInit(p)   p_LmInit(p, currRing)
 like pInit, except that expvector is initialized to that of p, p must be != NULL More...
 
#define pHead(p)   p_Head(p, currRing)
 returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL More...
 
#define pLmFreeAndNext(p)   p_LmFreeAndNext(p, currRing)
 assumes p != NULL, deletes p, returns pNext(p) More...
 
#define pLmDelete(p)   p_LmDelete(p, currRing)
 assume p != NULL, deletes Lm(p)->coef and Lm(p) More...
 
#define pLmDeleteAndNext(p)   p_LmDeleteAndNext(p, currRing)
 like pLmDelete, returns pNext(p) More...
 
#define pExpVectorCopy(d_p, s_p)   p_ExpVectorCopy(d_p, s_p, currRing)
 
#define pExpVectorAdd(p1, p2)   p_ExpVectorAdd(p1, p2, currRing)
 
#define pExpVectorSub(p1, p2)   p_ExpVectorSub(p1, p2, currRing)
 
#define pExpVectorAddSub(p1, p2, p3)   p_ExpVectorAddSub(p1, p2, p3, currRing)
 
#define pExpVectorSum(pr, p1, p2)   p_ExpVectorSum(pr, p1, p2, currRing)
 
#define pExpVectorDiff(pr, p1, p2)   p_ExpVectorDiff(pr, p1, p2, currRing)
 
#define pGetExpV(p, e)   p_GetExpV(p, e, currRing)
 Gets a copy of (resp. set) the exponent vector, where e is assumed to point to (r->N +1)*sizeof(long) memory. Exponents are filled in as follows: comp, e_1, .., e_n. More...
 
#define pSetExpV(p, e)   p_SetExpV(p, e, currRing)
 
#define pLmCmp(p, q)   p_LmCmp(p,q,currRing)
 returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering More...
 
#define pLmCmpAction(p, q, actionE, actionG, actionS)   _p_LmCmpAction(p,q,currRing, actionE, actionG,actionS)
 executes axtionE|actionG|actionS if p=q|p>q|p<q w.r.t monomial ordering action should be a "goto ..." More...
 
#define pLmEqual(p1, p2)   p_ExpVectorEqual(p1, p2, currRing)
 
#define pCmp(p1, p2)   p_Cmp(p1, p2, currRing)
 pCmp: args may be NULL returns: (p2==NULL ? 1 : (p1 == NULL ? -1 : p_LmCmp(p1, p2))) More...
 
#define pLtCmp(p, q)   p_LtCmp(p,q,currRing)
 
#define pLtCmpNoAbs(p, q)   p_LtCmpNoAbs(p,q,currRing)
 
#define pLtCmpOrdSgnDiffM(p, q)   p_LtCmpOrdSgnDiffM(p,q,currRing)
 
#define pLtCmpOrdSgnDiffP(p, q)   p_LtCmpOrdSgnDiffP(p,q,currRing)
 
#define pLtCmpOrdSgnEqM(p, q)   p_LtCmpOrdSgnEqM(p,q,currRing)
 
#define pLtCmpOrdSgnEqP(p, q)   p_LtCmpOrdSgnEqP(p,q,currRing)
 
#define pDivisibleBy(a, b)   p_DivisibleBy(a,b,currRing)
 returns TRUE, if leading monom of a divides leading monom of b i.e., if there exists a expvector c > 0, s.t. b = a + c; More...
 
#define pLmDivisibleBy(a, b)   p_LmDivisibleBy(a,b,currRing)
 like pDivisibleBy, except that it is assumed that a!=NULL, b!=NULL More...
 
#define pLmDivisibleByNoComp(a, b)   p_LmDivisibleByNoComp(a,b,currRing)
 like pLmDivisibleBy, does not check components More...
 
#define pLmShortDivisibleBy(a, sev_a, b, not_sev_b)   p_LmShortDivisibleBy(a, sev_a, b, not_sev_b, currRing)
 Divisibility tests based on Short Exponent vectors sev_a == pGetShortExpVector(a) not_sev_b == ~ pGetShortExpVector(b) More...
 
#define pLmRingShortDivisibleBy(a, sev_a, b, not_sev_b)   p_LmRingShortDivisibleBy(a, sev_a, b, not_sev_b, currRing)
 
#define pGetShortExpVector(a)   p_GetShortExpVector(a, currRing)
 returns the "Short Exponent Vector" – used to speed up divisibility tests (see polys-impl.cc ) More...
 
#define pDivisibleByRingCase(f, g)   p_DivisibleByRingCase(f,g,currRing)
 divisibility check over ground ring (which may contain zero divisors); TRUE iff LT(f) divides LT(g), i.e., LT(f)*c*m = LT(g), for some coefficient c and some monomial m; does not take components into account *‍/ More...
 
#define pCopy(p)   p_Copy(p, currRing)
 return a copy of the poly More...
 
#define pDelete(p_ptr)   p_Delete(p_ptr, currRing)
 
#define pNeg(p)   p_Neg(p, currRing)
 
#define ppMult_nn(p, n)   pp_Mult_nn(p, n, currRing)
 
#define pMult_nn(p, n)   p_Mult_nn(p, n, currRing)
 
#define ppMult_mm(p, m)   pp_Mult_mm(p, m, currRing)
 
#define pMult_mm(p, m)   p_Mult_mm(p, m, currRing)
 
#define pAdd(p, q)   p_Add_q(p, q, currRing)
 
#define pPower(p, q)   p_Power(p, q, currRing)
 
#define pMinus_mm_Mult_qq(p, m, q)   p_Minus_mm_Mult_qq(p, m, q, currRing)
 
#define pPlus_mm_Mult_qq(p, m, q)   p_Plus_mm_Mult_qq(p, m, q, currRing)
 
#define pMult(p, q)   p_Mult_q(p, q, currRing)
 
#define ppMult_qq(p, q)   pp_Mult_qq(p, q, currRing)
 
#define ppMult_Coeff_mm_DivSelect(p, m)   pp_Mult_Coeff_mm_DivSelect(p, m, currRing)
 
#define pSortMerger(p)   p_SortMerge(p, currRing)
 sorts p, assumes all monomials in p are different More...
 
#define pSort(p)   p_SortMerge(p, currRing)
 
#define pSortAdd(p)   p_SortAdd(p, currRing)
 sorts p, p may have equal monomials More...
 
#define pSortCompCorrect(p)   pSort(p)
 Assume: If considerd only as poly in any component of p (say, monomials of other components of p are set to 0), then p is already sorted correctly. More...
 
#define pIsConstantComp(p)   p_IsConstantComp(p, currRing)
 return true if p is either NULL, or if all exponents of p are 0, Comp of p might be != 0 More...
 
#define pIsConstant(p)   p_IsConstant(p,currRing)
 like above, except that Comp must be 0 More...
 
#define pIsUnit(p)   p_IsUnit(p,currRing)
 return true if the Lm is a constant <>0 More...
 
#define pLmIsConstantComp(p)   p_LmIsConstantComp(p, currRing)
 like above, except that p must be != NULL More...
 
#define pLmIsConstant(p)   p_LmIsConstant(p,currRing)
 
#define pIsConstantPoly(p)   p_IsConstantPoly(p, currRing)
 return TRUE if all monomials of p are constant More...
 
#define pIsPurePower(p)   p_IsPurePower(p, currRing)
 
#define pIsUnivariate(p)   p_IsUnivariate(p, currRing)
 
#define pIsVector(p)   (pGetComp(p)>0)
 
#define pGetVariables(p, e)   p_GetVariables(p, e, currRing)
 
#define pHasNotCFRing(p1, p2)   p_HasNotCFRing(p1,p2,currRing)
 
#define pHasNotCF(p1, p2)   p_HasNotCF(p1,p2,currRing)
 
#define pSplit(p, r)   p_Split(p,r)
 
#define pSetm(p)   p_Setm(p, currRing)
 
#define pSetmComp(p)   p_Setm(p, currRing)
 TODO: More...
 
#define pWeight(i)   p_Weight(i,currRing)
 
#define pWTotaldegree(p)   p_WTotaldegree(p,currRing)
 
#define pWDegree(p)   p_WDegree(p,currRing)
 
#define pSub(a, b)   p_Sub(a,b,currRing)
 
#define pmInit(a, b)   p_mInit(a,b,currRing)
 
#define pMDivide(a, b)   p_MDivide(a,b,currRing)
 
#define pDivideM(a, b)   p_DivideM(a,b,currRing)
 
#define pLcm(a, b, m)   p_Lcm(a,b,m,currRing)
 
#define pDiff(a, b)   p_Diff(a,b,currRing)
 
#define pDiffOp(a, b, m)   p_DiffOp(a,b,m,currRing)
 
#define pMaxComp(p)   p_MaxComp(p, currRing)
 
#define pMinComp(p)   p_MinComp(p, currRing)
 
#define pOneComp(p)   p_OneComp(p, currRing)
 
#define pSetCompP(a, i)   p_SetCompP(a, i, currRing)
 
#define pISet(i)   p_ISet(i,currRing)
 
#define pNSet(n)   p_NSet(n,currRing)
 
#define pOne()   p_One(currRing)
 
#define pNormalize(p)   p_Normalize(p,currRing)
 
#define pSize(p)   p_Size(p,currRing)
 
#define pHomogen(p, varnum)   p_Homogen(p,varnum,currRing)
 homogenizes p by multiplying certain powers of the varnum-th variable More...
 
#define pIsHomogen(p)   p_IsHomogen(p,currRing)
 
#define pVectorHasUnitB(p, k)   p_VectorHasUnitB(p,k,currRing)
 
#define pVectorHasUnit(p, k, l)   p_VectorHasUnit(p,k,l,currRing)
 
#define pTakeOutComp1(p, k)   p_TakeOutComp1(p,k,currRing)
 
#define pDeleteComp(p, k)   p_DeleteComp(p,k,currRing)
 
#define pSubst(p, n, e)   p_Subst(p,n,e,currRing)
 
#define ppJet(p, m)   pp_Jet(p,m,currRing)
 
#define pJet(p, m)   p_Jet(p,m,currRing)
 
#define ppJetW(p, m, iv)   pp_JetW(p,m,iv,currRing)
 
#define pJetW(p, m, iv)   p_JetW(p,m,iv,currRing)
 
#define pMinDeg(p, w)   p_MinDeg(p,w,currRing)
 
#define pSeries(n, p, u, w)   p_Series(n,p,u,w,currRing)
 
#define pDegW(p, w)   p_DegW(p,w,currRing)
 Deprecated: only for compatibility with older code! More...
 
#define pVar(m)   p_Var(m,currRing)
 
#define pEqualPolys(p1, p2)   p_EqualPolys(p1,p2,currRing)
 
#define pTest(p)   _p_Test(p, currRing, PDEBUG)
 
#define pLmTest(p)   _p_LmTest(p, currRing, PDEBUG)
 

Typedefs

typedef poly * polyset
 

Functions

void rChangeCurrRing (ring r)
 
static void pLmFree (poly p)
 frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced More...
 
static void pLmFree (poly *p)
 like pLmFree, but advances p More...
 
poly p_Divide (poly a, poly b, const ring r)
 polynomial division a/b, ignoring the rest via singclap_pdivide resp. idLift destroyes a,b More...
 
poly p_DivRem (poly a, poly b, poly &rest, const ring r)
 
poly singclap_gcd (poly f, poly g, const ring r)
 polynomial gcd via singclap_gcd_r resp. idSyzygies destroys f and g More...
 
static long pTotaldegree (poly p)
 
char * pString (poly p)
 
void pString0 (poly p)
 
void pWrite (poly p)
 
void pWrite0 (poly p)
 
void wrp (poly p)
 
BOOLEAN pIsHomogeneous (poly p)
 
void pTakeOutComp (poly *p, long comp, poly *q, int *lq, const ring R=currRing)
 Splits *p into two polys: *q which consists of all monoms with component == comp and *p of all other monoms *lq == pLength(*q) On return all components pf *q == 0. More...
 
poly pTakeOutComp (poly *p, int k, const ring R=currRing)
 This is something weird – Don't use it, unless you know what you are doing. More...
 
void pSetPolyComp (poly p, int comp)
 
void pNorm (poly p, const ring R=currRing)
 
BOOLEAN pCompareChain (poly p, poly p1, poly p2, poly lcm, const ring R=currRing)
 Returns TRUE if. More...
 
BOOLEAN pCompareChainPart (poly p, poly p1, poly p2, poly lcm, const ring R=currRing)
 
static poly pLast (poly a, int &length)
 returns the length of a polynomial (numbers of monomials) respect syzComp More...
 
static poly pLast (poly a)
 

Variables

EXTERN_VAR ring currRing
 

Detailed Description

Compatiblity layer for legacy polynomial operations (over currRing)

Macro defines for legacy polynomial operations used in Several involved mathematical algorithms (kernel) and Singular Interpreter and related functionality. They take no ring argument since they work with currRing by default. Notice that they have different prefix: p instead of p_.

See also related global ring variable and the correct ring changeing routine:

Definition in file polys.h.

Macro Definition Documentation

◆ pAdd

#define pAdd (   p,
 
)    p_Add_q(p, q, currRing)

Definition at line 191 of file polys.h.

◆ pAddExp

#define pAddExp (   p,
  i,
  v 
)    p_AddExp(p,i,v, currRing)

Definition at line 44 of file polys.h.

◆ pCmp

#define pCmp (   p1,
  p2 
)    p_Cmp(p1, p2, currRing)

pCmp: args may be NULL returns: (p2==NULL ? 1 : (p1 == NULL ? -1 : p_LmCmp(p1, p2)))

Definition at line 111 of file polys.h.

◆ pCopy

#define pCopy (   p)    p_Copy(p, currRing)

return a copy of the poly

Definition at line 174 of file polys.h.

◆ pDecrExp

#define pDecrExp (   p,
  i 
)    p_DecrExp(p,i, currRing)

Definition at line 43 of file polys.h.

◆ pDegW

#define pDegW (   p,
  w 
)    p_DegW(p,w,currRing)

Deprecated: only for compatibility with older code!

Definition at line 361 of file polys.h.

◆ pDelete

#define pDelete (   p_ptr)    p_Delete(p_ptr, currRing)

Definition at line 175 of file polys.h.

◆ pDeleteComp

#define pDeleteComp (   p,
  k 
)    p_DeleteComp(p,k,currRing)

Definition at line 345 of file polys.h.

◆ pDiff

#define pDiff (   a,
  b 
)    p_Diff(a,b,currRing)

Definition at line 280 of file polys.h.

◆ pDiffOp

#define pDiffOp (   a,
  b,
  m 
)    p_DiffOp(a,b,m,currRing)

Definition at line 281 of file polys.h.

◆ pDivideM

#define pDivideM (   a,
  b 
)    p_DivideM(a,b,currRing)

Definition at line 278 of file polys.h.

◆ pDivisibleBy

#define pDivisibleBy (   a,
  b 
)    p_DivisibleBy(a,b,currRing)

returns TRUE, if leading monom of a divides leading monom of b i.e., if there exists a expvector c > 0, s.t. b = a + c;

Definition at line 132 of file polys.h.

◆ pDivisibleByRingCase

#define pDivisibleByRingCase (   f,
  g 
)    p_DivisibleByRingCase(f,g,currRing)

divisibility check over ground ring (which may contain zero divisors); TRUE iff LT(f) divides LT(g), i.e., LT(f)*c*m = LT(g), for some coefficient c and some monomial m; does not take components into account *‍/

Definition at line 153 of file polys.h.

◆ pEqualPolys

#define pEqualPolys (   p1,
  p2 
)    p_EqualPolys(p1,p2,currRing)

Definition at line 384 of file polys.h.

◆ pExpVectorAdd

#define pExpVectorAdd (   p1,
  p2 
)    p_ExpVectorAdd(p1, p2, currRing)

Definition at line 84 of file polys.h.

◆ pExpVectorAddSub

#define pExpVectorAddSub (   p1,
  p2,
  p3 
)    p_ExpVectorAddSub(p1, p2, p3, currRing)

Definition at line 86 of file polys.h.

◆ pExpVectorCopy

#define pExpVectorCopy (   d_p,
  s_p 
)    p_ExpVectorCopy(d_p, s_p, currRing)

Definition at line 83 of file polys.h.

◆ pExpVectorDiff

#define pExpVectorDiff (   pr,
  p1,
  p2 
)    p_ExpVectorDiff(pr, p1, p2, currRing)

Definition at line 88 of file polys.h.

◆ pExpVectorSub

#define pExpVectorSub (   p1,
  p2 
)    p_ExpVectorSub(p1, p2, currRing)

Definition at line 85 of file polys.h.

◆ pExpVectorSum

#define pExpVectorSum (   pr,
  p1,
  p2 
)    p_ExpVectorSum(pr, p1, p2, currRing)

Definition at line 87 of file polys.h.

◆ pGetComp

#define pGetComp (   p)    (int)__p_GetComp(p, currRing)

Component.

Definition at line 36 of file polys.h.

◆ pGetExp

#define pGetExp (   p,
  i 
)    p_GetExp(p, i, currRing)

Exponent.

Definition at line 40 of file polys.h.

◆ pGetExpDiff

#define pGetExpDiff (   p1,
  p2,
  i 
)    p_GetExpDiff(p1, p2, i, currRing)

Definition at line 48 of file polys.h.

◆ pGetExpSum

#define pGetExpSum (   p1,
  p2,
  i 
)    p_GetExpSum(p1, p2, i, currRing)

Definition at line 47 of file polys.h.

◆ pGetExpV

#define pGetExpV (   p,
 
)    p_GetExpV(p, e, currRing)

Gets a copy of (resp. set) the exponent vector, where e is assumed to point to (r->N +1)*sizeof(long) memory. Exponents are filled in as follows: comp, e_1, .., e_n.

Definition at line 93 of file polys.h.

◆ pGetOrder

#define pGetOrder (   p)    p_GetOrder(p, currRing)

Order.

Definition at line 33 of file polys.h.

◆ pGetShortExpVector

#define pGetShortExpVector (   a)    p_GetShortExpVector(a, currRing)

returns the "Short Exponent Vector" – used to speed up divisibility tests (see polys-impl.cc )

Definition at line 146 of file polys.h.

◆ pGetVariables

#define pGetVariables (   p,
 
)    p_GetVariables(p, e, currRing)

Definition at line 237 of file polys.h.

◆ pHasNotCF

#define pHasNotCF (   p1,
  p2 
)    p_HasNotCF(p1,p2,currRing)

Definition at line 248 of file polys.h.

◆ pHasNotCFRing

#define pHasNotCFRing (   p1,
  p2 
)    p_HasNotCFRing(p1,p2,currRing)

Definition at line 247 of file polys.h.

◆ pHead

#define pHead (   p)    p_Head(p, currRing)

returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL

Definition at line 65 of file polys.h.

◆ pHomogen

#define pHomogen (   p,
  varnum 
)    p_Homogen(p,varnum,currRing)

homogenizes p by multiplying certain powers of the varnum-th variable

Definition at line 306 of file polys.h.

◆ pIncrExp

#define pIncrExp (   p,
  i 
)    p_IncrExp(p,i, currRing)

Definition at line 42 of file polys.h.

◆ pInit

#define pInit ( )    p_Init(currRing,currRing->PolyBin)

allocates a new monomial and initializes everything to 0

Definition at line 59 of file polys.h.

◆ pIsConstant

#define pIsConstant (   p)    p_IsConstant(p,currRing)

like above, except that Comp must be 0

Definition at line 224 of file polys.h.

◆ pIsConstantComp

#define pIsConstantComp (   p)    p_IsConstantComp(p, currRing)

return true if p is either NULL, or if all exponents of p are 0, Comp of p might be != 0

Definition at line 222 of file polys.h.

◆ pIsConstantPoly

#define pIsConstantPoly (   p)    p_IsConstantPoly(p, currRing)

return TRUE if all monomials of p are constant

Definition at line 232 of file polys.h.

◆ pISet

#define pISet (   i)    p_ISet(i,currRing)

Definition at line 296 of file polys.h.

◆ pIsHomogen

#define pIsHomogen (   p)    p_IsHomogen(p,currRing)

Definition at line 313 of file polys.h.

◆ pIsPurePower

#define pIsPurePower (   p)    p_IsPurePower(p, currRing)

Definition at line 234 of file polys.h.

◆ pIsUnit

#define pIsUnit (   p)    p_IsUnit(p,currRing)

return true if the Lm is a constant <>0

Definition at line 226 of file polys.h.

◆ pIsUnivariate

#define pIsUnivariate (   p)    p_IsUnivariate(p, currRing)

Definition at line 235 of file polys.h.

◆ pIsVector

#define pIsVector (   p)    (pGetComp(p)>0)

Definition at line 236 of file polys.h.

◆ pJet

#define pJet (   p,
  m 
)    p_Jet(p,m,currRing)

Definition at line 352 of file polys.h.

◆ pJetW

#define pJetW (   p,
  m,
  iv 
)    p_JetW(p,m,iv,currRing)

Definition at line 354 of file polys.h.

◆ pLcm

#define pLcm (   a,
  b,
  m 
)    p_Lcm(a,b,m,currRing)

Definition at line 279 of file polys.h.

◆ pLmCmp

#define pLmCmp (   p,
 
)    p_LmCmp(p,q,currRing)

returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering

Definition at line 101 of file polys.h.

◆ pLmCmpAction

#define pLmCmpAction (   p,
  q,
  actionE,
  actionG,
  actionS 
)    _p_LmCmpAction(p,q,currRing, actionE, actionG,actionS)

executes axtionE|actionG|actionS if p=q|p>q|p<q w.r.t monomial ordering action should be a "goto ..."

Definition at line 104 of file polys.h.

◆ pLmDelete

#define pLmDelete (   p)    p_LmDelete(p, currRing)

assume p != NULL, deletes Lm(p)->coef and Lm(p)

Definition at line 74 of file polys.h.

◆ pLmDeleteAndNext

#define pLmDeleteAndNext (   p)    p_LmDeleteAndNext(p, currRing)

like pLmDelete, returns pNext(p)

Definition at line 76 of file polys.h.

◆ pLmDivisibleBy

#define pLmDivisibleBy (   a,
  b 
)    p_LmDivisibleBy(a,b,currRing)

like pDivisibleBy, except that it is assumed that a!=NULL, b!=NULL

Definition at line 134 of file polys.h.

◆ pLmDivisibleByNoComp

#define pLmDivisibleByNoComp (   a,
  b 
)    p_LmDivisibleByNoComp(a,b,currRing)

like pLmDivisibleBy, does not check components

Definition at line 136 of file polys.h.

◆ pLmEqual

#define pLmEqual (   p1,
  p2 
)    p_ExpVectorEqual(p1, p2, currRing)

Definition at line 107 of file polys.h.

◆ pLmFreeAndNext

#define pLmFreeAndNext (   p)    p_LmFreeAndNext(p, currRing)

assumes p != NULL, deletes p, returns pNext(p)

Definition at line 72 of file polys.h.

◆ pLmInit

#define pLmInit (   p)    p_LmInit(p, currRing)

like pInit, except that expvector is initialized to that of p, p must be != NULL

Definition at line 62 of file polys.h.

◆ pLmIsConstant

#define pLmIsConstant (   p)    p_LmIsConstant(p,currRing)

Definition at line 229 of file polys.h.

◆ pLmIsConstantComp

#define pLmIsConstantComp (   p)    p_LmIsConstantComp(p, currRing)

like above, except that p must be != NULL

Definition at line 228 of file polys.h.

◆ pLmRingShortDivisibleBy

#define pLmRingShortDivisibleBy (   a,
  sev_a,
  b,
  not_sev_b 
)    p_LmRingShortDivisibleBy(a, sev_a, b, not_sev_b, currRing)

Definition at line 142 of file polys.h.

◆ pLmShortDivisibleBy

#define pLmShortDivisibleBy (   a,
  sev_a,
  b,
  not_sev_b 
)    p_LmShortDivisibleBy(a, sev_a, b, not_sev_b, currRing)

Divisibility tests based on Short Exponent vectors sev_a == pGetShortExpVector(a) not_sev_b == ~ pGetShortExpVector(b)

Definition at line 140 of file polys.h.

◆ pLmTest

#define pLmTest (   p)    _p_LmTest(p, currRing, PDEBUG)

Definition at line 399 of file polys.h.

◆ pLtCmp

#define pLtCmp (   p,
 
)    p_LtCmp(p,q,currRing)

Definition at line 118 of file polys.h.

◆ pLtCmpNoAbs

#define pLtCmpNoAbs (   p,
 
)    p_LtCmpNoAbs(p,q,currRing)

Definition at line 119 of file polys.h.

◆ pLtCmpOrdSgnDiffM

#define pLtCmpOrdSgnDiffM (   p,
 
)    p_LtCmpOrdSgnDiffM(p,q,currRing)

Definition at line 120 of file polys.h.

◆ pLtCmpOrdSgnDiffP

#define pLtCmpOrdSgnDiffP (   p,
 
)    p_LtCmpOrdSgnDiffP(p,q,currRing)

Definition at line 121 of file polys.h.

◆ pLtCmpOrdSgnEqM

#define pLtCmpOrdSgnEqM (   p,
 
)    p_LtCmpOrdSgnEqM(p,q,currRing)

Definition at line 122 of file polys.h.

◆ pLtCmpOrdSgnEqP

#define pLtCmpOrdSgnEqP (   p,
 
)    p_LtCmpOrdSgnEqP(p,q,currRing)

Definition at line 123 of file polys.h.

◆ pMaxComp

#define pMaxComp (   p)    p_MaxComp(p, currRing)

Definition at line 283 of file polys.h.

◆ pMDivide

#define pMDivide (   a,
  b 
)    p_MDivide(a,b,currRing)

Definition at line 277 of file polys.h.

◆ pMinComp

#define pMinComp (   p)    p_MinComp(p, currRing)

Definition at line 284 of file polys.h.

◆ pMinDeg

#define pMinDeg (   p,
  w 
)    p_MinDeg(p,w,currRing)

Definition at line 355 of file polys.h.

◆ pmInit

#define pmInit (   a,
  b 
)    p_mInit(a,b,currRing)

Definition at line 273 of file polys.h.

◆ pMinus_mm_Mult_qq

#define pMinus_mm_Mult_qq (   p,
  m,
 
)    p_Minus_mm_Mult_qq(p, m, q, currRing)

Definition at line 193 of file polys.h.

◆ pMult

#define pMult (   p,
 
)    p_Mult_q(p, q, currRing)

Definition at line 195 of file polys.h.

◆ pMult_mm

#define pMult_mm (   p,
  m 
)    p_Mult_mm(p, m, currRing)

Definition at line 190 of file polys.h.

◆ pMult_nn

#define pMult_nn (   p,
 
)    p_Mult_nn(p, n, currRing)

Definition at line 188 of file polys.h.

◆ pMultExp

#define pMultExp (   p,
  i,
  v 
)    p_MultExp(p,i,v, currRing)

Definition at line 46 of file polys.h.

◆ pNeg

#define pNeg (   p)    p_Neg(p, currRing)

Definition at line 186 of file polys.h.

◆ pNew

#define pNew ( )    p_New(currRing)

allocates the space for a new monomial – no initialization !!!

Definition at line 57 of file polys.h.

◆ pNormalize

#define pNormalize (   p)    p_Normalize(p,currRing)

Definition at line 301 of file polys.h.

◆ pNSet

#define pNSet (   n)    p_NSet(n,currRing)

Definition at line 297 of file polys.h.

◆ pOne

#define pOne ( )    p_One(currRing)

Definition at line 299 of file polys.h.

◆ pOneComp

#define pOneComp (   p)    p_OneComp(p, currRing)

Definition at line 286 of file polys.h.

◆ ppJet

#define ppJet (   p,
  m 
)    pp_Jet(p,m,currRing)

Definition at line 351 of file polys.h.

◆ ppJetW

#define ppJetW (   p,
  m,
  iv 
)    pp_JetW(p,m,iv,currRing)

Definition at line 353 of file polys.h.

◆ pPlus_mm_Mult_qq

#define pPlus_mm_Mult_qq (   p,
  m,
 
)    p_Plus_mm_Mult_qq(p, m, q, currRing)

Definition at line 194 of file polys.h.

◆ ppMult_Coeff_mm_DivSelect

#define ppMult_Coeff_mm_DivSelect (   p,
  m 
)    pp_Mult_Coeff_mm_DivSelect(p, m, currRing)

Definition at line 198 of file polys.h.

◆ ppMult_mm

#define ppMult_mm (   p,
  m 
)    pp_Mult_mm(p, m, currRing)

Definition at line 189 of file polys.h.

◆ ppMult_nn

#define ppMult_nn (   p,
 
)    pp_Mult_nn(p, n, currRing)

Definition at line 187 of file polys.h.

◆ ppMult_qq

#define ppMult_qq (   p,
 
)    pp_Mult_qq(p, q, currRing)

Definition at line 196 of file polys.h.

◆ pPower

#define pPower (   p,
 
)    p_Power(p, q, currRing)

Definition at line 192 of file polys.h.

◆ pSeries

#define pSeries (   n,
  p,
  u,
  w 
)    p_Series(n,p,u,w,currRing)

Definition at line 356 of file polys.h.

◆ pSetCoeff

#define pSetCoeff (   p,
 
)    p_SetCoeff(p,n,currRing)

deletes old coeff before setting the new one

Definition at line 30 of file polys.h.

◆ pSetComp

#define pSetComp (   p,
  v 
)    p_SetComp(p,v, currRing)

Definition at line 37 of file polys.h.

◆ pSetCompP

#define pSetCompP (   a,
  i 
)    p_SetCompP(a, i, currRing)

Definition at line 287 of file polys.h.

◆ pSetExp

#define pSetExp (   p,
  i,
  v 
)    p_SetExp(p, i, v, currRing)

Definition at line 41 of file polys.h.

◆ pSetExpV

#define pSetExpV (   p,
 
)    p_SetExpV(p, e, currRing)

Definition at line 94 of file polys.h.

◆ pSetm

#define pSetm (   p)    p_Setm(p, currRing)

Definition at line 256 of file polys.h.

◆ pSetmComp

#define pSetmComp (   p)    p_Setm(p, currRing)

TODO:

Definition at line 258 of file polys.h.

◆ pSize

#define pSize (   p)    p_Size(p,currRing)

Definition at line 302 of file polys.h.

◆ pSort

#define pSort (   p)    p_SortMerge(p, currRing)

Definition at line 205 of file polys.h.

◆ pSortAdd

#define pSortAdd (   p)    p_SortAdd(p, currRing)

sorts p, p may have equal monomials

Definition at line 208 of file polys.h.

◆ pSortCompCorrect

#define pSortCompCorrect (   p)    pSort(p)

Assume: If considerd only as poly in any component of p (say, monomials of other components of p are set to 0), then p is already sorted correctly.

Definition at line 214 of file polys.h.

◆ pSortMerger

#define pSortMerger (   p)    p_SortMerge(p, currRing)

sorts p, assumes all monomials in p are different

Definition at line 204 of file polys.h.

◆ pSplit

#define pSplit (   p,
 
)    p_Split(p,r)

Definition at line 250 of file polys.h.

◆ pSub

#define pSub (   a,
  b 
)    p_Sub(a,b,currRing)

Definition at line 271 of file polys.h.

◆ pSubExp

#define pSubExp (   p,
  i,
  v 
)    p_SubExp(p,i,v, currRing)

Definition at line 45 of file polys.h.

◆ pSubst

#define pSubst (   p,
  n,
 
)    p_Subst(p,n,e,currRing)

Definition at line 350 of file polys.h.

◆ pTakeOutComp1

#define pTakeOutComp1 (   p,
  k 
)    p_TakeOutComp1(p,k,currRing)

Definition at line 318 of file polys.h.

◆ pTest

#define pTest (   p)    _p_Test(p, currRing, PDEBUG)

Definition at line 398 of file polys.h.

◆ pVar

#define pVar (   m)    p_Var(m,currRing)

Definition at line 365 of file polys.h.

◆ pVectorHasUnit

#define pVectorHasUnit (   p,
  k,
  l 
)    p_VectorHasUnit(p,k,l,currRing)

Definition at line 317 of file polys.h.

◆ pVectorHasUnitB

#define pVectorHasUnitB (   p,
  k 
)    p_VectorHasUnitB(p,k,currRing)

Definition at line 316 of file polys.h.

◆ pWDegree

#define pWDegree (   p)    p_WDegree(p,currRing)

Definition at line 268 of file polys.h.

◆ pWeight

#define pWeight (   i)    p_Weight(i,currRing)

Definition at line 264 of file polys.h.

◆ pWTotaldegree

#define pWTotaldegree (   p)    p_WTotaldegree(p,currRing)

Definition at line 267 of file polys.h.

Typedef Documentation

◆ polyset

typedef poly* polyset

Definition at line 244 of file polys.h.

Function Documentation

◆ p_Divide()

poly p_Divide ( poly  a,
poly  b,
const ring  r 
)

polynomial division a/b, ignoring the rest via singclap_pdivide resp. idLift destroyes a,b

Definition at line 31 of file polys.cc.

32 {
33  assume(q!=NULL);
34  if (q==NULL)
35  {
36  WerrorS("div. by 0");
37  return NULL;
38  }
39  if (p==NULL)
40  {
41  p_Delete(&q,r);
42  return NULL;
43  }
44  if (pNext(q)!=NULL)
45  { /* This means that q != 0 consists of at least two terms*/
46  if (rIsLPRing(r))
47  {
48  WerrorS("not implemented for letterplace rings");
49  return NULL;
50  }
51  if(p_GetComp(p,r)==0)
52  {
53  if((rFieldType(r)==n_transExt)
54  &&(convSingTrP(p,r))
55  &&(convSingTrP(q,r)))
56  {
57  poly res=singclap_pdivide(p, q, r);
58  p_Delete(&p,r);
59  p_Delete(&q,r);
60  return res;
61  }
62  else if ((r->cf->convSingNFactoryN!=ndConvSingNFactoryN)
63  &&(!rField_is_Ring(r)))
64  {
65  poly res=singclap_pdivide(p, q, r);
66  p_Delete(&p,r);
67  p_Delete(&q,r);
68  return res;
69  }
70  else
71  {
72  ideal vi=idInit(1,1); vi->m[0]=q;
73  ideal ui=idInit(1,1); ui->m[0]=p;
74  ideal R; matrix U;
75  ring save_ring=currRing;
76  if (r!=currRing) rChangeCurrRing(r);
77  int save_opt;
78  SI_SAVE_OPT1(save_opt);
79  si_opt_1 &= ~(Sy_bit(OPT_PROT));
80  ideal m = idLift(vi,ui,&R, FALSE,TRUE,TRUE,&U);
81  SI_RESTORE_OPT1(save_opt);
82  if (r!=save_ring) rChangeCurrRing(save_ring);
84  p=MATELEM(T,1,1); MATELEM(T,1,1)=NULL;
85  id_Delete((ideal *)&T,r);
86  id_Delete((ideal *)&U,r);
87  id_Delete(&R,r);
88  //vi->m[0]=NULL; ui->m[0]=NULL;
89  id_Delete(&vi,r);
90  id_Delete(&ui,r);
91  return p;
92  }
93  }
94  else
95  {
96  int comps=p_MaxComp(p,r);
97  ideal I=idInit(comps,1);
98  poly h;
99  int i;
100  // conversion to a list of polys:
101  while (p!=NULL)
102  {
103  i=p_GetComp(p,r)-1;
104  h=pNext(p);
105  pNext(p)=NULL;
106  p_SetComp(p,0,r);
107  I->m[i]=p_Add_q(I->m[i],p,r);
108  p=h;
109  }
110  // division and conversion to vector:
111  h=NULL;
112  p=NULL;
113  for(i=comps-1;i>=0;i--)
114  {
115  if (I->m[i]!=NULL)
116  {
117  if((rFieldType(r)==n_transExt)
118  &&(convSingTrP(I->m[i],r))
119  &&(convSingTrP(q,r)))
120  {
121  h=singclap_pdivide(I->m[i],q,r);
122  }
123  else if ((r->cf->convSingNFactoryN!=ndConvSingNFactoryN)
124  &&(!rField_is_Ring(r)))
125  h=singclap_pdivide(I->m[i],q,r);
126  else
127  {
128  ideal vi=idInit(1,1); vi->m[0]=q;
129  ideal ui=idInit(1,1); ui->m[0]=I->m[i];
130  ideal R; matrix U;
131  ring save_ring=currRing;
132  if (r!=currRing) rChangeCurrRing(r);
133  int save_opt;
134  SI_SAVE_OPT1(save_opt);
135  si_opt_1 &= ~(Sy_bit(OPT_PROT));
136  ideal m = idLift(vi,ui,&R, FALSE,TRUE,TRUE,&U);
137  SI_RESTORE_OPT1(save_opt);
138  if (r!=save_ring) rChangeCurrRing(save_ring);
139  if (idIs0(R))
140  {
142  p=MATELEM(T,1,1); MATELEM(T,1,1)=NULL;
143  id_Delete((ideal *)&T,r);
144  }
145  else p=NULL;
146  id_Delete((ideal*)&U,r);
147  id_Delete(&R,r);
148  vi->m[0]=NULL; ui->m[0]=NULL;
149  id_Delete(&vi,r);
150  id_Delete(&ui,r);
151  }
152  p_SetCompP(h,i+1,r);
153  p=p_Add_q(p,h,r);
154  }
155  }
156  id_Delete(&I,r);
157  p_Delete(&q,r);
158  return p;
159  }
160  }
161  else
162  { /* This means that q != 0 consists of just one term,
163  or that r is over a coefficient ring. */
164 #ifdef HAVE_RINGS
165  if (!rField_is_Domain(r))
166  {
167  WerrorS("division only defined over coefficient domains");
168  return NULL;
169  }
170  if (pNext(q)!=NULL)
171  {
172  WerrorS("division over a coefficient domain only implemented for terms");
173  return NULL;
174  }
175 #endif
176  return p_DivideM(p,q,r);
177  }
178  return NULL;
179 }

◆ p_DivRem()

poly p_DivRem ( poly  a,
poly  b,
poly &  rest,
const ring  r 
)

Definition at line 181 of file polys.cc.

182 {
183  assume(q!=NULL);
184  rest=NULL;
185  if (q==NULL)
186  {
187  WerrorS("div. by 0");
188  return NULL;
189  }
190  if (p==NULL)
191  {
192  p_Delete(&q,r);
193  return NULL;
194  }
195  if (rIsLPRing(r))
196  {
197  WerrorS("not implemented for letterplace rings");
198  return NULL;
199  }
200  if(p_GetComp(p,r)==0)
201  {
202  if((rFieldType(r)==n_transExt)
203  &&(convSingTrP(p,r))
204  &&(convSingTrP(q,r)))
205  {
206  poly res=singclap_pdivide(p, q, r);
207  rest=singclap_pmod(p,q,r);
208  p_Delete(&p,r);
209  p_Delete(&q,r);
210  return res;
211  }
212  else if ((r->cf->convSingNFactoryN!=ndConvSingNFactoryN)
213  &&(!rField_is_Ring(r)))
214  {
215  poly res=singclap_pdivide(p, q, r);
216  rest=singclap_pmod(p,q,r);
217  p_Delete(&p,r);
218  p_Delete(&q,r);
219  return res;
220  }
221  else
222  {
223  ideal vi=idInit(1,1); vi->m[0]=q;
224  ideal ui=idInit(1,1); ui->m[0]=p;
225  ideal R; matrix U;
226  ring save_ring=currRing;
227  if (r!=currRing) rChangeCurrRing(r);
228  int save_opt;
229  SI_SAVE_OPT1(save_opt);
230  si_opt_1 &= ~(Sy_bit(OPT_PROT));
231  ideal m = idLift(vi,ui,&R, FALSE,TRUE,TRUE,&U);
232  SI_RESTORE_OPT1(save_opt);
233  if (r!=save_ring) rChangeCurrRing(save_ring);
235  p=MATELEM(T,1,1); MATELEM(T,1,1)=NULL;
236  id_Delete((ideal *)&T,r);
237  T = id_Module2formatedMatrix(R,1,1,r);
238  rest=MATELEM(T,1,1); MATELEM(T,1,1)=NULL;
239  id_Delete((ideal *)&T,r);
240  id_Delete((ideal *)&U,r);
241  id_Delete(&R,r);
242  //vi->m[0]=NULL; ui->m[0]=NULL;
243  id_Delete(&vi,r);
244  id_Delete(&ui,r);
245  return p;
246  }
247  }
248  return NULL;
249 }

◆ pCompareChain()

BOOLEAN pCompareChain ( poly  p,
poly  p1,
poly  p2,
poly  lcm,
const ring  R = currRing 
)

Returns TRUE if.

  • LM(p) | LM(lcm)
  • LC(p) | LC(lcm) only if ring
  • Exists i, j:
    • LE(p, i) != LE(lcm, i)
    • LE(p1, i) != LE(lcm, i) ==> LCM(p1, p) != lcm
    • LE(p, j) != LE(lcm, j)
    • LE(p2, j) != LE(lcm, j) ==> LCM(p2, p) != lcm

Definition at line 17 of file kpolys.cc.

18 {
19  int k, j;
20 
21  if (lcm==NULL) return FALSE;
22 
23  for (j=(R->N); j; j--)
24  if ( p_GetExp(p,j, R) > p_GetExp(lcm,j, R)) return FALSE;
25  if ( pGetComp(p) != pGetComp(lcm)) return FALSE;
26  for (j=(R->N); j; j--)
27  {
28  if (p_GetExp(p1,j, R)!=p_GetExp(lcm,j, R))
29  {
30  if (p_GetExp(p,j, R)!=p_GetExp(lcm,j, R))
31  {
32  for (k=(R->N); k>j; k--)
33  {
34  if ((p_GetExp(p,k, R)!=p_GetExp(lcm,k, R))
35  && (p_GetExp(p2,k, R)!=p_GetExp(lcm,k, R)))
36  return TRUE;
37  }
38  for (k=j-1; k; k--)
39  {
40  if ((p_GetExp(p,k, R)!=p_GetExp(lcm,k, R))
41  && (p_GetExp(p2,k, R)!=p_GetExp(lcm,k, R)))
42  return TRUE;
43  }
44  return FALSE;
45  }
46  }
47  else if (p_GetExp(p2,j, R)!=p_GetExp(lcm,j, R))
48  {
49  if (p_GetExp(p,j, R)!=p_GetExp(lcm,j, R))
50  {
51  for (k=(R->N); k>j; k--)
52  {
53  if ((p_GetExp(p,k, R)!=p_GetExp(lcm,k, R))
54  && (p_GetExp(p1,k, R)!=p_GetExp(lcm,k, R)))
55  return TRUE;
56  }
57  for (k=j-1; k!=0 ; k--)
58  {
59  if ((p_GetExp(p,k, R)!=p_GetExp(lcm,k, R))
60  && (p_GetExp(p1,k, R)!=p_GetExp(lcm,k, R)))
61  return TRUE;
62  }
63  return FALSE;
64  }
65  }
66  }
67  return FALSE;
68 }

◆ pCompareChainPart()

BOOLEAN pCompareChainPart ( poly  p,
poly  p1,
poly  p2,
poly  lcm,
const ring  R = currRing 
)

Definition at line 71 of file kpolys.cc.

72 {
73  int k, j;
74 
75  if (lcm==NULL) return FALSE;
76 
77  for (j=R->real_var_end; j>=R->real_var_start; j--)
78  if ( p_GetExp(p,j, R) > p_GetExp(lcm,j, R)) return FALSE;
79  if ( pGetComp(p) != pGetComp(lcm)) return FALSE;
80  for (j=R->real_var_end; j>=R->real_var_start; j--)
81  {
82  if (p_GetExp(p1,j, R)!=p_GetExp(lcm,j, R))
83  {
84  if (p_GetExp(p,j, R)!=p_GetExp(lcm,j, R))
85  {
86  for (k=(R->N); k>j; k--)
87  for (k=R->real_var_end; k>j; k--)
88  {
89  if ((p_GetExp(p,k, R)!=p_GetExp(lcm,k, R))
90  && (p_GetExp(p2,k, R)!=p_GetExp(lcm,k, R)))
91  return TRUE;
92  }
93  for (k=j-1; k>=R->real_var_start; k--)
94  {
95  if ((p_GetExp(p,k, R)!=p_GetExp(lcm,k, R))
96  && (p_GetExp(p2,k, R)!=p_GetExp(lcm,k, R)))
97  return TRUE;
98  }
99  return FALSE;
100  }
101  }
102  else if (p_GetExp(p2,j, R)!=p_GetExp(lcm,j, R))
103  {
104  if (p_GetExp(p,j, R)!=p_GetExp(lcm,j, R))
105  {
106  for (k=R->real_var_end; k>j; k--)
107  {
108  if ((p_GetExp(p,k, R)!=p_GetExp(lcm,k, R))
109  && (p_GetExp(p1,k, R)!=p_GetExp(lcm,k, R)))
110  return TRUE;
111  }
112  for (k=j-1; k>=R->real_var_start; k--)
113  {
114  if ((p_GetExp(p,k, R)!=p_GetExp(lcm,k, R))
115  && (p_GetExp(p1,k, R)!=p_GetExp(lcm,k, R)))
116  return TRUE;
117  }
118  return FALSE;
119  }
120  }
121  }
122  return FALSE;
123 }

◆ pIsHomogeneous()

BOOLEAN pIsHomogeneous ( poly  p)

◆ pLast() [1/2]

static poly pLast ( poly  a)
inlinestatic

Definition at line 391 of file polys.h.

402 { return p_Last (a, length, currRing); }

◆ pLast() [2/2]

static poly pLast ( poly  a,
int &  length 
)
inlinestatic

returns the length of a polynomial (numbers of monomials) respect syzComp

Definition at line 390 of file polys.h.

402 { return p_Last (a, length, currRing); }

◆ pLmFree() [1/2]

static void pLmFree ( poly *  p)
inlinestatic

like pLmFree, but advances p

Definition at line 70 of file polys.h.

70 {p_LmFree(p, currRing);}

◆ pLmFree() [2/2]

static void pLmFree ( poly  p)
inlinestatic

frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced

Definition at line 68 of file polys.h.

70 {p_LmFree(p, currRing);}

◆ pNorm()

void pNorm ( poly  p,
const ring  R = currRing 
)
inline

Definition at line 347 of file polys.h.

359 { p_Norm(p, R); }

◆ pSetPolyComp()

void pSetPolyComp ( poly  p,
int  comp 
)

◆ pString()

char* pString ( poly  p)
inline

Definition at line 290 of file polys.h.

302 {return p_String(p, currRing, currRing);}

◆ pString0()

void pString0 ( poly  p)
inline

Definition at line 291 of file polys.h.

302 {return p_String(p, currRing, currRing);}

◆ pTakeOutComp() [1/2]

poly pTakeOutComp ( poly *  p,
int  k,
const ring  R = currRing 
)
inline

This is something weird – Don't use it, unless you know what you are doing.

Definition at line 330 of file polys.h.

336 {

◆ pTakeOutComp() [2/2]

void pTakeOutComp ( poly *  p,
long  comp,
poly *  q,
int *  lq,
const ring  R = currRing 
)
inline

Splits *p into two polys: *q which consists of all monoms with component == comp and *p of all other monoms *lq == pLength(*q) On return all components pf *q == 0.

Definition at line 323 of file polys.h.

336 {

◆ pTotaldegree()

static long pTotaldegree ( poly  p)
inlinestatic

Definition at line 266 of file polys.h.

278 { return p_Totaldegree(p,currRing); }

◆ pWrite()

void pWrite ( poly  p)
inline

Definition at line 292 of file polys.h.

302 {return p_String(p, currRing, currRing);}

◆ pWrite0()

void pWrite0 ( poly  p)
inline

Definition at line 293 of file polys.h.

302 {return p_String(p, currRing, currRing);}

◆ rChangeCurrRing()

void rChangeCurrRing ( ring  r)

Definition at line 15 of file polys.cc.

16 {
17  //------------ set global ring vars --------------------------------
18  currRing = r;
19  if( r != NULL )
20  {
21  rTest(r);
22  //------------ global variables related to coefficients ------------
23  assume( r->cf!= NULL );
24  nSetChar(r->cf);
25  //------------ global variables related to polys
26  p_SetGlobals(r); // also setting TEST_RINGDEP_OPTS
27  //------------ global variables related to factory -----------------
28  }
29 }

◆ singclap_gcd()

poly singclap_gcd ( poly  f,
poly  g,
const ring  r 
)

polynomial gcd via singclap_gcd_r resp. idSyzygies destroys f and g

Definition at line 251 of file polys.cc.

252 {
253  poly res=NULL;
254 
255  if (f!=NULL)
256  {
257  //if (r->cf->has_simple_Inverse) p_Norm(f,r);
258  if (rField_is_Zp(r)) p_Norm(f,r);
259  else p_Cleardenom(f, r);
260  }
261  if (g!=NULL)
262  {
263  //if (r->cf->has_simple_Inverse) p_Norm(g,r);
264  if (rField_is_Zp(r)) p_Norm(g,r);
265  else p_Cleardenom(g, r);
266  }
267  else return f; // g==0 => gcd=f (but do a p_Cleardenom/pNorm)
268  if (f==NULL) return g; // f==0 => gcd=g (but do a p_Cleardenom/pNorm)
269  if(!rField_is_Ring(r)
270  && (p_IsConstant(f,r)
271  ||p_IsConstant(g,r)))
272  {
273  res=p_One(r);
274  }
275  else if (r->cf->convSingNFactoryN!=ndConvSingNFactoryN)
276  {
277  res=singclap_gcd_r(f,g,r);
278  }
279  else
280  {
281  ideal I=idInit(2,1);
282  I->m[0]=f;
283  I->m[1]=p_Copy(g,r);
284  intvec *w=NULL;
285  ring save_ring=currRing;
286  if (r!=currRing) rChangeCurrRing(r);
287  int save_opt;
288  SI_SAVE_OPT1(save_opt);
289  si_opt_1 &= ~(Sy_bit(OPT_PROT));
290  ideal S1=idSyzygies(I,testHomog,&w);
291  if (w!=NULL) delete w;
292  // expect S1->m[0]=(-g/gcd,f/gcd)
293  if (IDELEMS(S1)!=1) WarnS("error in syzygy computation for GCD");
294  int lp;
295  p_TakeOutComp(&S1->m[0],1,&res,&lp,r);
296  p_Delete(&S1->m[0],r);
297  // GCD is g divided iby (-g/gcd):
298  res=p_Divide(g,res,r);
299  // restore, r, opt:
300  SI_RESTORE_OPT1(save_opt);
301  if (r!=save_ring) rChangeCurrRing(save_ring);
302  // clean the result
303  res=p_Cleardenom(res,r);
304  p_Content(res,r);
305  return res;
306  }
307  p_Delete(&f, r);
308  p_Delete(&g, r);
309  return res;
310 }

◆ wrp()

void wrp ( poly  p)
inline

Definition at line 294 of file polys.h.

302 {return p_String(p, currRing, currRing);}

Variable Documentation

◆ currRing

EXTERN_VAR ring currRing

Definition at line 18 of file polys.h.

FALSE
#define FALSE
Definition: auxiliary.h:96
p_Divide
poly p_Divide(poly p, poly q, const ring r)
polynomial division a/b, ignoring the rest via singclap_pdivide resp. idLift destroyes a,...
Definition: polys.cc:31
idLift
ideal idLift(ideal mod, ideal submod, ideal *rest, BOOLEAN goodShape, BOOLEAN isSB, BOOLEAN divide, matrix *unit, GbVariant alg)
Definition: ideals.cc:1111
p_GetComp
#define p_GetComp(p, r)
Definition: monomials.h:61
ip_smatrix
Definition: matpol.h:13
nSetChar
static FORCE_INLINE void nSetChar(const coeffs r)
initialisations after each ring change
Definition: coeffs.h:435
pGetComp
#define pGetComp(p)
Component.
Definition: polys.h:36
p_GetExp
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
Definition: p_polys.h:456
j
int j
Definition: facHensel.cc:105
f
FILE * f
Definition: checklibs.c:9
rIsLPRing
static BOOLEAN rIsLPRing(const ring r)
Definition: ring.h:407
k
int k
Definition: cfEzgcd.cc:92
MATELEM
#define MATELEM(mat, i, j)
1-based access to matrix
Definition: matpol.h:29
rField_is_Domain
static BOOLEAN rField_is_Domain(const ring r)
Definition: ring.h:481
rChangeCurrRing
void rChangeCurrRing(ring r)
Definition: polys.cc:15
si_opt_1
VAR unsigned si_opt_1
Definition: options.c:5
h
STATIC_VAR Poly * h
Definition: janet.cc:971
p_SetCompP
static void p_SetCompP(poly p, int i, ring r)
Definition: p_polys.h:244
rFieldType
static n_coeffType rFieldType(const ring r)
the type of the coefficient filed of r (n_Zp, n_Q, etc)
Definition: ring.h:550
length
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:263
singclap_pdivide
poly singclap_pdivide(poly f, poly g, const ring r)
Definition: clapsing.cc:557
SI_SAVE_OPT1
#define SI_SAVE_OPT1(A)
Definition: options.h:20
g
g
Definition: cfModGcd.cc:4031
rTest
#define rTest(r)
Definition: ring.h:779
testHomog
Definition: structs.h:42
idIs0
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
Definition: simpleideals.cc:776
w
const CanonicalForm & w
Definition: facAbsFact.cc:55
currRing
EXTERN_VAR ring currRing
Definition: polys.h:18
p_Copy
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition: p_polys.h:796
TRUE
#define TRUE
Definition: auxiliary.h:100
i
int i
Definition: cfEzgcd.cc:125
id_Delete
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
Definition: simpleideals.cc:122
res
CanonicalForm res
Definition: facAbsFact.cc:64
Sy_bit
#define Sy_bit(x)
Definition: options.h:30
p_SetGlobals
void p_SetGlobals(const ring r, BOOLEAN complete)
set all properties of a new ring - also called by rComplete
Definition: ring.cc:3362
p_String
char * p_String(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:321
rField_is_Ring
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:478
p_DivideM
poly p_DivideM(poly a, poly b, const ring r)
Definition: p_polys.cc:1557
intvec
Definition: intvec.h:18
p_Cleardenom
poly p_Cleardenom(poly p, const ring r)
Definition: p_polys.cc:2788
p_Last
poly p_Last(const poly p, int &l, const ring r)
Definition: p_polys.cc:4523
T
STATIC_VAR jList * T
Definition: janet.cc:30
n_transExt
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
Definition: coeffs.h:38
p_LmFree
static void p_LmFree(poly p, ring)
Definition: p_polys.h:669
p_Content
void p_Content(poly ph, const ring r)
Definition: p_polys.cc:2267
p_Delete
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:845
p_Add_q
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:880
p_One
poly p_One(const ring r)
Definition: p_polys.cc:1300
singclap_pmod
poly singclap_pmod(poly f, poly g, const ring r)
Definition: clapsing.cc:604
singclap_gcd_r
poly singclap_gcd_r(poly f, poly g, const ring r)
Definition: clapsing.cc:41
convSingTrP
BOOLEAN convSingTrP(poly p, const ring r)
Definition: clapconv.cc:319
idInit
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:34
WerrorS
void WerrorS(const char *s)
Definition: feFopen.cc:24
m
int m
Definition: cfEzgcd.cc:121
WarnS
#define WarnS
Definition: emacs.cc:77
assume
#define assume(x)
Definition: mod2.h:384
NULL
#define NULL
Definition: omList.c:11
p_TakeOutComp
void p_TakeOutComp(poly *p, long comp, poly *q, int *lq, const ring r)
Definition: p_polys.cc:3452
idSyzygies
ideal idSyzygies(ideal h1, tHomog h, intvec **w, BOOLEAN setSyzComp, BOOLEAN setRegularity, int *deg, GbVariant alg)
Definition: ideals.cc:728
p_SetComp
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition: p_polys.h:237
lcm
int lcm(unsigned long *l, unsigned long *a, unsigned long *b, unsigned long p, int dega, int degb)
Definition: minpoly.cc:709
R
#define R
Definition: sirandom.c:27
p_Totaldegree
static long p_Totaldegree(poly p, const ring r)
Definition: p_polys.h:1428
p
int p
Definition: cfModGcd.cc:4019
p_IsConstant
static BOOLEAN p_IsConstant(const poly p, const ring r)
Definition: p_polys.h:1909
currRing
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
ndConvSingNFactoryN
CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition: numbers.cc:272
SI_RESTORE_OPT1
#define SI_RESTORE_OPT1(A)
Definition: options.h:23
IDELEMS
#define IDELEMS(i)
Definition: simpleideals.h:23
p_Norm
void p_Norm(poly p1, const ring r)
Definition: p_polys.cc:3676
id_Module2formatedMatrix
matrix id_Module2formatedMatrix(ideal mod, int rows, int cols, const ring R)
Definition: simpleideals.cc:1319
rField_is_Zp
static BOOLEAN rField_is_Zp(const ring r)
Definition: ring.h:494
p_MaxComp
static long p_MaxComp(poly p, ring lmRing, ring tailRing)
Definition: p_polys.h:282
pNext
#define pNext(p)
Definition: monomials.h:33
OPT_PROT
#define OPT_PROT
Definition: options.h:72