My Project
Loading...
Searching...
No Matches
Macros | Typedefs | Functions | Variables
polys.h File Reference

Compatibility layer for legacy polynomial operations (over currRing) More...

#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
 
#define pGetOrder(p)   p_GetOrder(p, currRing)
 Order.
 
#define pGetComp(p)   (int)__p_GetComp(p, currRing)
 Component.
 
#define pSetComp(p, v)   p_SetComp(p,v, currRing)
 
#define pGetExp(p, i)   p_GetExp(p, i, currRing)
 Exponent.
 
#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 !!!
 
#define pInit()   p_Init(currRing,currRing->PolyBin)
 allocates a new monomial and initializes everything to 0
 
#define pLmInit(p)   p_LmInit(p, currRing)
 like pInit, except that expvector is initialized to that of p, p must be != NULL
 
#define pHead(p)   p_Head(p, currRing)
 returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
 
#define pLmFreeAndNext(p)   p_LmFreeAndNext(p, currRing)
 assumes p != NULL, deletes p, returns pNext(p)
 
#define pLmDelete(p)   p_LmDelete(p, currRing)
 assume p != NULL, deletes Lm(p)->coef and Lm(p)
 
#define pLmDeleteAndNext(p)   p_LmDeleteAndNext(p, currRing)
 like pLmDelete, returns pNext(p)
 
#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.
 
#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
 
#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 ..."
 
#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)))
 
#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;
 
#define pLmDivisibleBy(a, b)   p_LmDivisibleBy(a,b,currRing)
 like pDivisibleBy, except that it is assumed that a!=NULL, b!=NULL
 
#define pLmDivisibleByNoComp(a, b)   p_LmDivisibleByNoComp(a,b,currRing)
 like pLmDivisibleBy, does not check components
 
#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)
 
#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 )
 
#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 *‍/
 
#define pCopy(p)   p_Copy(p, currRing)
 return a copy of the poly
 
#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
 
#define pSort(p)   p_SortMerge(p, currRing)
 
#define pSortAdd(p)   p_SortAdd(p, currRing)
 sorts p, p may have equal monomials
 
#define pSortCompCorrect(p)   pSort(p)
 Assume: If considered 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.
 
#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
 
#define pIsConstant(p)   p_IsConstant(p,currRing)
 like above, except that Comp must be 0
 
#define pIsUnit(p)   p_IsUnit(p,currRing)
 return true if the Lm is a constant <>0
 
#define pLmIsConstantComp(p)   p_LmIsConstantComp(p, currRing)
 like above, except that p must be != NULL
 
#define pLmIsConstant(p)   p_LmIsConstant(p,currRing)
 
#define pIsConstantPoly(p)   p_IsConstantPoly(p, currRing)
 return TRUE if all monomials of p are constant
 
#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:
 
#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
 
#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 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!
 
#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
 
static void pLmFree (poly *p)
 like pLmFree, but advances p
 
poly p_Divide (poly a, poly b, const ring r)
 polynomial division a/b, ignoring the rest via singclap_pdivide resp. idLift destroys a,b
 
poly pp_Divide (poly a, poly b, const ring r)
 polynomial division a/b, ignoring the rest via singclap_pdivide resp. idLift does not destroy a,b
 
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
 
static long pTotaldegree (poly p)
 
charpString (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.
 
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.
 
void pSetPolyComp (poly p, int comp)
 
void pNorm (poly p)
 
BOOLEAN pCompareChain (poly p, poly p1, poly p2, poly lcm, const ring R=currRing)
 Returns TRUE if.
 
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
 
static poly pLast (poly a)
 

Variables

EXTERN_VAR ring currRing
 

Detailed Description

Compatibility 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 changing routine:

Definition in file polys.h.

Macro Definition Documentation

◆ pAdd

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

Definition at line 203 of file polys.h.

◆ pAddExp

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

Definition at line 45 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 115 of file polys.h.

◆ pCopy

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

return a copy of the poly

Definition at line 185 of file polys.h.

◆ pDecrExp

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

Definition at line 44 of file polys.h.

◆ pDegW

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

Deprecated: only for compatibility with older code!

Definition at line 376 of file polys.h.

◆ pDelete

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

Definition at line 186 of file polys.h.

◆ pDeleteComp

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

Definition at line 360 of file polys.h.

◆ pDiff

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

Definition at line 296 of file polys.h.

◆ pDiffOp

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

Definition at line 297 of file polys.h.

◆ pDivideM

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

Definition at line 294 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 138 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 159 of file polys.h.

◆ pEqualPolys

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

Definition at line 399 of file polys.h.

◆ pExpVectorAdd

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

Definition at line 87 of file polys.h.

◆ pExpVectorAddSub

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

Definition at line 89 of file polys.h.

◆ pExpVectorCopy

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

Definition at line 86 of file polys.h.

◆ pExpVectorDiff

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

Definition at line 91 of file polys.h.

◆ pExpVectorSub

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

Definition at line 88 of file polys.h.

◆ pExpVectorSum

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

Definition at line 90 of file polys.h.

◆ pGetComp

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

Component.

Definition at line 37 of file polys.h.

◆ pGetExp

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

Exponent.

Definition at line 41 of file polys.h.

◆ pGetExpDiff

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

Definition at line 49 of file polys.h.

◆ pGetExpSum

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

Definition at line 48 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 96 of file polys.h.

◆ pGetOrder

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

Order.

Definition at line 34 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 152 of file polys.h.

◆ pGetVariables

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

Definition at line 251 of file polys.h.

◆ pHasNotCF

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

Definition at line 263 of file polys.h.

◆ pHasNotCFRing

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

Definition at line 262 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 67 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 322 of file polys.h.

◆ pIncrExp

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

Definition at line 43 of file polys.h.

◆ pInit

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

allocates a new monomial and initializes everything to 0

Definition at line 61 of file polys.h.

◆ pIsConstant

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

like above, except that Comp must be 0

Definition at line 238 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 236 of file polys.h.

◆ pIsConstantPoly

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

return TRUE if all monomials of p are constant

Definition at line 246 of file polys.h.

◆ pISet

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

Definition at line 312 of file polys.h.

◆ pIsHomogen

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

Definition at line 329 of file polys.h.

◆ pIsPurePower

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

Definition at line 248 of file polys.h.

◆ pIsUnit

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

return true if the Lm is a constant <>0

Definition at line 240 of file polys.h.

◆ pIsUnivariate

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

Definition at line 249 of file polys.h.

◆ pIsVector

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

Definition at line 250 of file polys.h.

◆ pJet

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

Definition at line 367 of file polys.h.

◆ pJetW

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

Definition at line 369 of file polys.h.

◆ pLcm

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

Definition at line 295 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 105 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 108 of file polys.h.

281 { return p_Totaldegree(p,currRing); }
282#define pWTotaldegree(p) p_WTotaldegree(p,currRing)
283#define pWDegree(p) p_WDegree(p,currRing)
284
285/*-------------operations on polynomials:------------*/
286#define pSub(a,b) p_Sub(a,b,currRing)
287
288#define pmInit(a,b) p_mInit(a,b,currRing)
289
290/* ----------------- define to enable new p_procs -----*/
291
292#define pMDivide(a,b) p_MDivide(a,b,currRing)
293#define pDivideM(a,b) p_DivideM(a,b,currRing)
294#define pLcm(a,b,m) p_Lcm(a,b,m,currRing)
295#define pDiff(a,b) p_Diff(a,b,currRing)
296#define pDiffOp(a,b,m) p_DiffOp(a,b,m,currRing)
297
298#define pMaxComp(p) p_MaxComp(p, currRing)
299#define pMinComp(p) p_MinComp(p, currRing)
300
301#define pOneComp(p) p_OneComp(p, currRing)
302#define pSetCompP(a,i) p_SetCompP(a, i, currRing)
303
304// let's inline those, so that we can call them from the debugger
305inline char* pString(poly p) {return p_String(p, currRing, currRing);}
306inline void pString0(poly p) {p_String0(p, currRing, currRing);}
307inline void pWrite(poly p) {p_Write(p, currRing, currRing);}
308inline void pWrite0(poly p) {p_Write0(p, currRing, currRing);}
309inline void wrp(poly p) {p_wrp(p, currRing, currRing);}
310
311#define pISet(i) p_ISet(i,currRing)
312#define pNSet(n) p_NSet(n,currRing)
313
314#define pOne() p_One(currRing)
315
316#define pNormalize(p) p_Normalize(p,currRing)
317#define pSize(p) p_Size(p,currRing)
318
319
320/// homogenizes p by multiplying certain powers of the varnum-th variable
321#define pHomogen(p,varnum) p_Homogen(p,varnum,currRing)
322
324// // replaces the maximal powers of the leading monomial of p2 in p1 by
325// // the same powers of n, utility for dehomogenization
326// #define pDehomogen(p1,p2,n) p_Dehomgen(p1,p2,n,currRing)
327// #define pIsHomogen(p) p_IsHomggen(p,currRing)
328#define pIsHomogen(p) p_IsHomogen(p,currRing)
329
330/*BOOLEAN pVectorHasUnitM(poly p, int * k);*/
331#define pVectorHasUnitB(p,k) p_VectorHasUnitB(p,k,currRing)
332#define pVectorHasUnit(p,k,l) p_VectorHasUnit(p,k,l,currRing)
333
334/// Splits *p into two polys: *q which consists of all monoms with
335/// component == comp and *p of all other monoms *lq == pLength(*q)
336/// On return all components pf *q == 0
337inline void pTakeOutComp(poly *p, long comp, poly *q, int *lq, const ring R = currRing)
338{
339 return p_TakeOutComp(p, comp, q, lq, R);
340}
341
342
343/// This is something weird -- Don't use it, unless you know what you are doing
344inline poly pTakeOutComp(poly * p, int k, const ring R = currRing)
345{
346 return p_TakeOutComp(p, k, R);
347}
348
349/* old spielwiese
350#define pTakeOutComp(p,k,q,lq) p_TakeOutComp(p,k,q,lq,currRing)
351
352// Similar to pTakeOutComp, except that only those components are
353// taken out whose Order == order
354// ASSUME: monomial ordering is Order compatible, i.e., if m1, m2 Monoms then
355// m1 >= m2 ==> pGetOrder(m1) >= pGetOrder(m2)
356#define pDecrOrdTakeOutComp(p,c,o,q,lq) p_DecrOrdTakeOutComp(p,c,o,q,lq,currRing)
357*/
358void pSetPolyComp(poly p, int comp);
359#define pDeleteComp(p,k) p_DeleteComp(p,k,currRing)
360
361inline void pNorm(poly p){ p_Norm(p, currRing); }
362
363
364#define pSubst(p,n,e) p_Subst(p,n,e,currRing)
365#define ppJet(p,m) pp_Jet(p,m,currRing)
366#define pJet(p,m) p_Jet(p,m,currRing)
367#define ppJetW(p,m,iv) pp_JetW(p,m,iv,currRing)
368#define pJetW(p,m,iv) p_JetW(p,m,iv,currRing)
369#define pMinDeg(p,w) p_MinDeg(p,w,currRing)
370#define pSeries(n,p,u,w) p_Series(n,p,u,w,currRing)
371// maximum weighted degree of all monomials of p, w is indexed from
372// 1..pVariables
373
374/// Deprecated: only for compatibility with older code!
375#define pDegW(p,w) p_DegW(p,w,currRing)
376
377/*-----------type conversions ----------------------------*/
378// void pVec2Polys(poly v, polyset *p, int *len);
379#define pVar(m) p_Var(m,currRing)
380
381/*-----------specials for spoly-computations--------------*/
382
383/// Returns TRUE if
384/// * LM(p) | LM(lcm)
385/// * LC(p) | LC(lcm) only if ring
386/// * Exists i, j:
387/// * LE(p, i) != LE(lcm, i)
388/// * LE(p1, i) != LE(lcm, i) ==> LCM(p1, p) != lcm
389/// * LE(p, j) != LE(lcm, j)
390/// * LE(p2, j) != LE(lcm, j) ==> LCM(p2, p) != lcm
391BOOLEAN pCompareChain (poly p, poly p1, poly p2, poly lcm, const ring R = currRing);
392
393#ifdef HAVE_RATGRING
394BOOLEAN pCompareChainPart (poly p, poly p1, poly p2, poly lcm, const ring R = currRing);
395#endif
396
397
398#define pEqualPolys(p1,p2) p_EqualPolys(p1,p2,currRing)
399
400
401
402/// returns the length of a polynomial (numbers of monomials)
403/// respect syzComp
404static inline poly pLast(poly a, int &length) { return p_Last (a, length, currRing); }
405static inline poly pLast(poly a) { int l; return pLast(a, l); }
406
407/***************************************************************
408 *
409 * PDEBUG stuff
410 *
411 ***************************************************************/
412#ifdef PDEBUG
413#define pTest(p) _p_Test(p, currRing, PDEBUG)
414#define pLmTest(p) _p_LmTest(p, currRing, PDEBUG)
415
416#else // ! PDEBUG
417
418#define pTest(p) do {} while (0)
419#define pLmTest(p) do {} while (0)
420#endif
421
422#endif // POLYS_H
int BOOLEAN
Definition auxiliary.h:87
int l
Definition cfEzgcd.cc:100
int k
Definition cfEzgcd.cc:99
int p
Definition cfModGcd.cc:4086
int comp(const CanonicalForm &A, const CanonicalForm &B)
compare polynomials
static BOOLEAN length(leftv result, leftv arg)
Definition interval.cc:257
void p_TakeOutComp(poly *p, long comp, poly *q, int *lq, const ring r)
Definition p_polys.cc:3517
int lcm(unsigned long *l, unsigned long *a, unsigned long *b, unsigned long p, int dega, int degb)
Definition minpoly.cc:709
Definition lq.h:40
void p_Norm(poly p1, const ring r)
Definition p_polys.cc:3741
poly p_Last(const poly p, int &l, const ring r)
Definition p_polys.cc:4671
char * p_String(poly p, ring lmRing, ring tailRing)
Definition polys0.cc:322
void p_String0(poly p, ring lmRing, ring tailRing)
print p according to ShortOut in lmRing & tailRing
Definition polys0.cc:223
void p_Write(poly p, ring lmRing, ring tailRing)
Definition polys0.cc:342
void p_Write0(poly p, ring lmRing, ring tailRing)
Definition polys0.cc:332
static long p_Totaldegree(poly p, const ring r)
Definition p_polys.h:1507
void p_wrp(poly p, ring lmRing, ring tailRing)
Definition polys0.cc:373
void pSetPolyComp(poly p, int comp)
void pNorm(poly p)
Definition polys.h:362
BOOLEAN pCompareChain(poly p, poly p1, poly p2, poly lcm, const ring R=currRing)
Returns TRUE if.
Definition kpolys.cc:17
void pWrite0(poly p)
Definition polys.h:309
BOOLEAN pIsHomogeneous(poly p)
void wrp(poly p)
Definition polys.h:310
void pWrite(poly p)
Definition polys.h:308
BOOLEAN pCompareChainPart(poly p, poly p1, poly p2, poly lcm, const ring R=currRing)
Definition kpolys.cc:71
void pString0(poly p)
Definition polys.h:307
static poly pLast(poly a, int &length)
returns the length of a polynomial (numbers of monomials) respect syzComp
Definition polys.h:405
EXTERN_VAR ring currRing
Definition polys.h:18
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 ...
Definition polys.h:338
char * pString(poly p)
Definition polys.h:306
#define R
Definition sirandom.c:27

◆ pLmDelete

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

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

Definition at line 76 of file polys.h.

◆ pLmDeleteAndNext

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

like pLmDelete, returns pNext(p)

Definition at line 78 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 140 of file polys.h.

◆ pLmDivisibleByNoComp

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

like pLmDivisibleBy, does not check components

Definition at line 142 of file polys.h.

◆ pLmEqual

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

Definition at line 111 of file polys.h.

◆ pLmFreeAndNext

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

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

Definition at line 74 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 64 of file polys.h.

◆ pLmIsConstant

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

Definition at line 243 of file polys.h.

◆ pLmIsConstantComp

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

like above, except that p must be != NULL

Definition at line 242 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 148 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 146 of file polys.h.

◆ pLmTest

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

Definition at line 415 of file polys.h.

◆ pLtCmp

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

Definition at line 123 of file polys.h.

◆ pLtCmpNoAbs

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

Definition at line 124 of file polys.h.

◆ pLtCmpOrdSgnDiffM

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

Definition at line 125 of file polys.h.

◆ pLtCmpOrdSgnDiffP

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

Definition at line 126 of file polys.h.

◆ pLtCmpOrdSgnEqM

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

Definition at line 127 of file polys.h.

◆ pLtCmpOrdSgnEqP

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

Definition at line 128 of file polys.h.

◆ pMaxComp

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

Definition at line 299 of file polys.h.

◆ pMDivide

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

Definition at line 293 of file polys.h.

◆ pMinComp

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

Definition at line 300 of file polys.h.

◆ pMinDeg

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

Definition at line 370 of file polys.h.

◆ pmInit

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

Definition at line 289 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 205 of file polys.h.

◆ pMult

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

Definition at line 207 of file polys.h.

◆ pMult_mm

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

Definition at line 202 of file polys.h.

◆ pMult_nn

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

Definition at line 200 of file polys.h.

◆ pMultExp

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

Definition at line 47 of file polys.h.

◆ pNeg

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

Definition at line 198 of file polys.h.

◆ pNew

#define pNew ( )    p_New(currRing)

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

Definition at line 59 of file polys.h.

◆ pNormalize

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

Definition at line 317 of file polys.h.

◆ pNSet

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

Definition at line 313 of file polys.h.

◆ pOne

#define pOne ( )    p_One(currRing)

Definition at line 315 of file polys.h.

◆ pOneComp

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

Definition at line 302 of file polys.h.

◆ ppJet

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

Definition at line 366 of file polys.h.

◆ ppJetW

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

Definition at line 368 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 206 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 210 of file polys.h.

◆ ppMult_mm

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

Definition at line 201 of file polys.h.

◆ ppMult_nn

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

Definition at line 199 of file polys.h.

◆ ppMult_qq

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

Definition at line 208 of file polys.h.

◆ pPower

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

Definition at line 204 of file polys.h.

◆ pSeries

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

Definition at line 371 of file polys.h.

◆ pSetCoeff

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

deletes old coeff before setting the new one

Definition at line 31 of file polys.h.

◆ pSetComp

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

Definition at line 38 of file polys.h.

◆ pSetCompP

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

Definition at line 303 of file polys.h.

◆ pSetExp

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

Definition at line 42 of file polys.h.

◆ pSetExpV

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

Definition at line 97 of file polys.h.

◆ pSetm

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

Definition at line 271 of file polys.h.

◆ pSetmComp

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

TODO:

Definition at line 273 of file polys.h.

◆ pSize

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

Definition at line 318 of file polys.h.

◆ pSort

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

Definition at line 218 of file polys.h.

◆ pSortAdd

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

sorts p, p may have equal monomials

Definition at line 221 of file polys.h.

◆ pSortCompCorrect

#define pSortCompCorrect (   p)    pSort(p)

Assume: If considered 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 227 of file polys.h.

◆ pSortMerger

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

sorts p, assumes all monomials in p are different

Definition at line 217 of file polys.h.

◆ pSplit

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

Definition at line 265 of file polys.h.

◆ pSub

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

Definition at line 287 of file polys.h.

◆ pSubExp

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

Definition at line 46 of file polys.h.

◆ pSubst

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

Definition at line 365 of file polys.h.

◆ pTest

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

Definition at line 414 of file polys.h.

◆ pVar

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

Definition at line 380 of file polys.h.

◆ pVectorHasUnit

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

Definition at line 333 of file polys.h.

◆ pVectorHasUnitB

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

Definition at line 332 of file polys.h.

◆ pWDegree

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

Definition at line 284 of file polys.h.

◆ pWeight

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

Definition at line 280 of file polys.h.

◆ pWTotaldegree

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

Definition at line 283 of file polys.h.

Typedef Documentation

◆ polyset

Definition at line 259 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 destroys 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)||rIsPluralRing(r))
45 { /* This means that q != 0 consists of at least two terms*/
46 if(p_GetComp(p,r)==0)
47 {
48 if((rFieldType(r)==n_transExt)
49 &&(convSingTrP(p,r))
50 &&(convSingTrP(q,r))
51 &&(!rIsNCRing(r)))
52 {
53 poly res=singclap_pdivide(p, q, r);
54 p_Delete(&p,r);
55 p_Delete(&q,r);
56 return res;
57 }
58 else if ((r->cf->convSingNFactoryN!=ndConvSingNFactoryN)
59 &&(!rField_is_Ring(r))
60 &&(!rIsNCRing(r)))
61 {
62 poly res=singclap_pdivide(p, q, r);
63 p_Delete(&p,r);
64 p_Delete(&q,r);
65 return res;
66 }
67 else
68 {
69 ideal vi=idInit(1,1); vi->m[0]=q;
70 ideal ui=idInit(1,1); ui->m[0]=p;
71 ideal R; matrix U;
73 if (r!=currRing) rChangeCurrRing(r);
74 int save_opt;
80 p=m->m[0]; m->m[0]=NULL;
81 id_Delete(&m,r);
82 p_SetCompP(p,0,r);
83 id_Delete((ideal *)&U,r);
84 id_Delete(&R,r);
85 //vi->m[0]=NULL; ui->m[0]=NULL;
86 id_Delete(&vi,r);
87 id_Delete(&ui,r);
88 return p;
89 }
90 }
91 else
92 {
93 int comps=p_MaxComp(p,r);
95 poly h;
96 int i;
97 // conversion to a list of polys:
98 while (p!=NULL)
99 {
100 i=p_GetComp(p,r)-1;
101 h=pNext(p);
102 pNext(p)=NULL;
103 p_SetComp(p,0,r);
104 I->m[i]=p_Add_q(I->m[i],p,r);
105 p=h;
106 }
107 // division and conversion to vector:
108 h=NULL;
109 p=NULL;
110 for(i=comps-1;i>=0;i--)
111 {
112 if (I->m[i]!=NULL)
113 {
114 if((rFieldType(r)==n_transExt)
115 &&(convSingTrP(I->m[i],r))
116 &&(convSingTrP(q,r))
117 &&(!rIsNCRing(r)))
118 {
119 h=singclap_pdivide(I->m[i],q,r);
120 }
121 else if ((r->cf->convSingNFactoryN!=ndConvSingNFactoryN)
122 &&(!rField_is_Ring(r))
123 &&(!rIsNCRing(r)))
124 h=singclap_pdivide(I->m[i],q,r);
125 else
126 {
127 ideal vi=idInit(1,1); vi->m[0]=q;
128 ideal ui=idInit(1,1); ui->m[0]=I->m[i];
129 ideal R; matrix U;
131 if (r!=currRing) rChangeCurrRing(r);
132 int save_opt;
134 si_opt_1 &= ~(Sy_bit(OPT_PROT));
135 ideal m = idLift(vi,ui,&R, FALSE,TRUE,TRUE,&U);
138 if (idIs0(R))
139 {
141 p=MATELEM(T,1,1); MATELEM(T,1,1)=NULL;
142 id_Delete((ideal *)&T,r);
143 }
144 else p=NULL;
145 id_Delete((ideal*)&U,r);
146 id_Delete(&R,r);
147 vi->m[0]=NULL; ui->m[0]=NULL;
148 id_Delete(&vi,r);
149 id_Delete(&ui,r);
150 }
151 p_SetCompP(h,i+1,r);
152 p=p_Add_q(p,h,r);
153 }
154 }
155 id_Delete(&I,r);
156 p_Delete(&q,r);
157 return p;
158 }
159 }
160 else
161 { /* This means that q != 0 consists of just one term, or LetterPlace */
162#ifdef HAVE_RINGS
163 if (pNext(q)!=NULL)
164 {
165 WerrorS("division over a coefficient domain only implemented for terms");
166 return NULL;
167 }
168#endif
169 return p_DivideM(p,q,r);
170 }
171 return NULL;
172}
#define TRUE
Definition auxiliary.h:100
#define FALSE
Definition auxiliary.h:96
int m
Definition cfEzgcd.cc:128
int i
Definition cfEzgcd.cc:132
BOOLEAN convSingTrP(poly p, const ring r)
Definition clapconv.cc:352
poly singclap_pdivide(poly f, poly g, const ring r)
Definition clapsing.cc:624
@ n_transExt
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
Definition coeffs.h:38
CanonicalForm res
Definition facAbsFact.cc:60
void WerrorS(const char *s)
Definition feFopen.cc:24
ideal idLift(ideal mod, ideal submod, ideal *rest, BOOLEAN goodShape, BOOLEAN isSB, BOOLEAN divide, matrix *unit, GbVariant alg)
represents the generators of submod in terms of the generators of mod (Matrix(SM)*U-Matrix(rest)) = M...
Definition ideals.cc:1105
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
STATIC_VAR jList * T
Definition janet.cc:30
STATIC_VAR Poly * h
Definition janet.cc:971
#define MATELEM(mat, i, j)
1-based access to matrix
Definition matpol.h:29
#define assume(x)
Definition mod2.h:387
#define p_GetComp(p, r)
Definition monomials.h:64
#define pNext(p)
Definition monomials.h:36
CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition numbers.cc:313
#define NULL
Definition omList.c:12
VAR unsigned si_opt_1
Definition options.c:5
#define OPT_PROT
Definition options.h:75
#define SI_SAVE_OPT1(A)
Definition options.h:21
#define SI_RESTORE_OPT1(A)
Definition options.h:24
#define Sy_bit(x)
Definition options.h:31
poly p_DivideM(poly a, poly b, const ring r)
Definition p_polys.cc:1584
static poly p_Add_q(poly p, poly q, const ring r)
Definition p_polys.h:936
static void p_SetCompP(poly p, int i, ring r)
Definition p_polys.h:254
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition p_polys.h:247
static long p_MaxComp(poly p, ring lmRing, ring tailRing)
Definition p_polys.h:292
static void p_Delete(poly *p, const ring r)
Definition p_polys.h:901
void rChangeCurrRing(ring r)
Definition polys.cc:15
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition polys.cc:13
static n_coeffType rFieldType(const ring r)
the type of the coefficient filed of r (n_Zp, n_Q, etc)
Definition ring.h:561
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition ring.h:405
static BOOLEAN rIsNCRing(const ring r)
Definition ring.h:426
#define rField_is_Ring(R)
Definition ring.h:490
ideal idInit(int idsize, int rank)
initialise an ideal / module
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
matrix id_Module2formatedMatrix(ideal mod, int rows, int cols, const ring R)

◆ p_DivRem()

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

Definition at line 314 of file polys.cc.

315{
316 assume(q!=NULL);
317 rest=NULL;
318 if (q==NULL)
319 {
320 WerrorS("div. by 0");
321 return NULL;
322 }
323 if (p==NULL)
324 {
325 p_Delete(&q,r);
326 return NULL;
327 }
328 if(p_GetComp(p,r)==0)
329 {
330 if((rFieldType(r)==n_transExt)
331 &&(convSingTrP(p,r))
332 &&(convSingTrP(q,r))
333 &&(!rIsNCRing(r)))
334 {
335 poly res=singclap_pdivide(p, q, r);
336 rest=singclap_pmod(p,q,r);
337 p_Delete(&p,r);
338 p_Delete(&q,r);
339 return res;
340 }
341 else if ((r->cf->convSingNFactoryN!=ndConvSingNFactoryN)
342 &&(!rField_is_Ring(r))
343 &&(!rIsNCRing(r)))
344 {
345 poly res=singclap_pdivide(p, q, r);
346 rest=singclap_pmod(p,q,r);
347 p_Delete(&p,r);
348 p_Delete(&q,r);
349 return res;
350 }
351 else
352 {
353 ideal vi=idInit(1,1); vi->m[0]=q;
354 ideal ui=idInit(1,1); ui->m[0]=p;
355 ideal R; matrix U;
357 if (r!=currRing) rChangeCurrRing(r);
358 int save_opt;
360 si_opt_1 &= ~(Sy_bit(OPT_PROT));
361 ideal m = idLift(vi,ui,&R, FALSE,TRUE,TRUE,&U);
364 p=m->m[0]; m->m[0]=NULL;
365 id_Delete(&m,r);
366 p_SetCompP(p,0,r);
367 rest=R->m[0]; R->m[0]=NULL;
368 id_Delete(&R,r);
369 p_SetCompP(rest,0,r);
370 id_Delete((ideal *)&U,r);
371 //vi->m[0]=NULL; ui->m[0]=NULL;
372 id_Delete(&vi,r);
373 id_Delete(&ui,r);
374 return p;
375 }
376 }
377 return NULL;
378}
poly singclap_pmod(poly f, poly g, const ring r)
Definition clapsing.cc:702

◆ pCompareChain()

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

Returns TRUE if.

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}
int j
Definition facHensel.cc:110
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:469
#define pGetComp(p)
Component.
Definition polys.h:37

◆ 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 406 of file polys.h.

406{ int l; return pLast(a, l); }

◆ 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 405 of file polys.h.

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

◆ pLmFree() [1/2]

static void pLmFree ( poly *  p)
inlinestatic

like pLmFree, but advances p

Definition at line 72 of file polys.h.

static void p_LmFree(poly p, ring)
Definition p_polys.h:683

◆ 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 70 of file polys.h.

◆ pNorm()

void pNorm ( poly  p)
inline

Definition at line 362 of file polys.h.

362{ p_Norm(p, currRing); }

◆ pp_Divide()

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

polynomial division a/b, ignoring the rest via singclap_pdivide resp. idLift does not destroy a,b

Definition at line 174 of file polys.cc.

175{
176 if (q==NULL)
177 {
178 WerrorS("div. by 0");
179 return NULL;
180 }
181 if (p==NULL)
182 {
183 return NULL;
184 }
185 if ((pNext(q)!=NULL)||rIsPluralRing(r))
186 { /* This means that q != 0 consists of at least two terms*/
187 if(p_GetComp(p,r)==0)
188 {
189 if((rFieldType(r)==n_transExt)
190 &&(convSingTrP(p,r))
191 &&(convSingTrP(q,r))
192 &&(!rIsNCRing(r)))
193 {
194 poly res=singclap_pdivide(p, q, r);
195 return res;
196 }
197 else if ((r->cf->convSingNFactoryN!=ndConvSingNFactoryN)
198 &&(!rField_is_Ring(r))
199 &&(!rIsNCRing(r)))
200 {
201 poly res=singclap_pdivide(p, q, r);
202 return res;
203 }
204 else
205 {
206 ideal vi=idInit(1,1); vi->m[0]=p_Copy(q,r);
207 ideal ui=idInit(1,1); ui->m[0]=p_Copy(p,r);
208 ideal R; matrix U;
210 if (r!=currRing) rChangeCurrRing(r);
211 int save_opt;
213 si_opt_1 &= ~(Sy_bit(OPT_PROT));
214 ideal m = idLift(vi,ui,&R, FALSE,TRUE,TRUE,&U);
218 p=MATELEM(T,1,1); MATELEM(T,1,1)=NULL;
219 id_Delete((ideal *)&T,r);
220 id_Delete((ideal *)&U,r);
221 id_Delete(&R,r);
222 //vi->m[0]=NULL; ui->m[0]=NULL;
223 id_Delete(&vi,r);
224 id_Delete(&ui,r);
225 return p;
226 }
227 }
228 else
229 {
230 p=p_Copy(p,r);
231 int comps=p_MaxComp(p,r);
232 ideal I=idInit(comps,1);
233 poly h;
234 int i;
235 // conversion to a list of polys:
236 while (p!=NULL)
237 {
238 i=p_GetComp(p,r)-1;
239 h=pNext(p);
240 pNext(p)=NULL;
241 p_SetComp(p,0,r);
242 I->m[i]=p_Add_q(I->m[i],p,r);
243 p=h;
244 }
245 // division and conversion to vector:
246 h=NULL;
247 p=NULL;
248 q=p_Copy(q,r);
249 for(i=comps-1;i>=0;i--)
250 {
251 if (I->m[i]!=NULL)
252 {
253 if((rFieldType(r)==n_transExt)
254 &&(convSingTrP(I->m[i],r))
255 &&(convSingTrP(q,r))
256 &&(!rIsNCRing(r)))
257 {
258 h=singclap_pdivide(I->m[i],q,r);
259 }
260 else if ((r->cf->convSingNFactoryN!=ndConvSingNFactoryN)
261 &&(!rField_is_Ring(r))
262 &&(!rIsNCRing(r)))
263 h=singclap_pdivide(I->m[i],q,r);
264 else
265 {
266 ideal vi=idInit(1,1); vi->m[0]=q;
267 ideal ui=idInit(1,1); ui->m[0]=I->m[i];
268 ideal R; matrix U;
270 if (r!=currRing) rChangeCurrRing(r);
271 int save_opt;
273 si_opt_1 &= ~(Sy_bit(OPT_PROT));
274 ideal m = idLift(vi,ui,&R, FALSE,TRUE,TRUE,&U);
277 if (idIs0(R))
278 {
280 p=MATELEM(T,1,1); MATELEM(T,1,1)=NULL;
281 id_Delete((ideal *)&T,r);
282 }
283 else p=NULL;
284 id_Delete((ideal*)&U,r);
285 id_Delete(&R,r);
286 vi->m[0]=NULL; ui->m[0]=NULL;
287 id_Delete(&vi,r);
288 id_Delete(&ui,r);
289 }
290 p_SetCompP(h,i+1,r);
291 p=p_Add_q(p,h,r);
292 }
293 }
294 id_Delete(&I,r);
295 p_Delete(&q,r);
296 return p;
297 }
298 }
299 else
300 { /* This means that q != 0 consists of just one term,
301 or that r is over a coefficient ring. */
302#ifdef HAVE_RINGS
303 if (pNext(q)!=NULL)
304 {
305 WerrorS("division over a coefficient domain only implemented for terms");
306 return NULL;
307 }
308#endif
309 return pp_DivideM(p,q,r);
310 }
311 return NULL;
312}
poly pp_DivideM(poly a, poly b, const ring r)
Definition p_polys.cc:1639
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition p_polys.h:846

◆ pSetPolyComp()

void pSetPolyComp ( poly  p,
int  comp 
)

◆ pString()

char * pString ( poly  p)
inline

Definition at line 306 of file polys.h.

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

◆ pString0()

void pString0 ( poly  p)
inline

Definition at line 307 of file polys.h.

◆ 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 345 of file polys.h.

346{
347 return p_TakeOutComp(p, k, R);
348}

◆ 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 338 of file polys.h.

339{
340 return p_TakeOutComp(p, comp, q, lq, R);
341}

◆ pTotaldegree()

static long pTotaldegree ( poly  p)
inlinestatic

Definition at line 282 of file polys.h.

282{ return p_Totaldegree(p,currRing); }

◆ pWrite()

void pWrite ( poly  p)
inline

Definition at line 308 of file polys.h.

◆ pWrite0()

void pWrite0 ( poly  p)
inline

Definition at line 309 of file polys.h.

◆ 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}
static FORCE_INLINE void nSetChar(const coeffs r)
initialisations after each ring change
Definition coeffs.h:444
void p_SetGlobals(const ring r, BOOLEAN complete)
set all properties of a new ring - also called by rComplete
Definition ring.cc:3431
#define rTest(r)
Definition ring.h:791

◆ 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 380 of file polys.cc.

381{
382 poly res=NULL;
383
384 if (f!=NULL)
385 {
386 //if (r->cf->has_simple_Inverse) p_Norm(f,r);
387 if (rField_is_Zp(r)) p_Norm(f,r);
388 else if (!rField_is_Ring(r)) p_Cleardenom(f, r);
389 }
390 if (g!=NULL)
391 {
392 //if (r->cf->has_simple_Inverse) p_Norm(g,r);
393 if (rField_is_Zp(r)) p_Norm(g,r);
394 else if (!rField_is_Ring(r)) p_Cleardenom(g, r);
395 }
396 else return f; // g==0 => gcd=f (but do a p_Cleardenom/pNorm)
397 if (f==NULL) return g; // f==0 => gcd=g (but do a p_Cleardenom/pNorm)
398 if(!rField_is_Ring(r)
399 && (p_IsConstant(f,r)
400 ||p_IsConstant(g,r)))
401 {
402 res=p_One(r);
403 }
404 else if (r->cf->convSingNFactoryN!=ndConvSingNFactoryN)
405 {
407 }
408 else
409 {
410 ideal I=idInit(2,1);
411 I->m[0]=f;
412 I->m[1]=p_Copy(g,r);
413 intvec *w=NULL;
415 if (r!=currRing) rChangeCurrRing(r);
416 int save_opt;
418 si_opt_1 &= ~(Sy_bit(OPT_PROT));
420 if (w!=NULL) delete w;
421 // expect S1->m[0]=(-g/gcd,f/gcd)
422 if (IDELEMS(S1)!=1) WarnS("error in syzygy computation for GCD");
423 int lp;
424 p_TakeOutComp(&S1->m[0],1,&res,&lp,r);
425 p_Delete(&S1->m[0],r);
426 // GCD is g divided iby (-g/gcd):
427 res=p_Divide(g,res,r);
428 // restore, r, opt:
431 // clean the result
433 if (nCoeff_is_Ring(r->cf)) p_Content(res,r);
434 return res;
435 }
436 p_Delete(&f, r);
437 p_Delete(&g, r);
438 return res;
439}
g
Definition cfModGcd.cc:4098
FILE * f
Definition checklibs.c:9
poly singclap_gcd_r(poly f, poly g, const ring r)
Definition clapsing.cc:68
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
Definition coeffs.h:734
#define WarnS
Definition emacs.cc:78
const CanonicalForm & w
Definition facAbsFact.cc:51
ideal idSyzygies(ideal h1, tHomog h, intvec **w, BOOLEAN setSyzComp, BOOLEAN setRegularity, int *deg, GbVariant alg)
Definition ideals.cc:830
void p_Content(poly ph, const ring r)
Definition p_polys.cc:2301
poly p_Cleardenom(poly p, const ring r)
Definition p_polys.cc:2851
poly p_One(const ring r)
Definition p_polys.cc:1316
static BOOLEAN p_IsConstant(const poly p, const ring r)
Definition p_polys.h:1964
poly p_Divide(poly p, poly q, const ring r)
polynomial division a/b, ignoring the rest via singclap_pdivide resp. idLift destroys a,...
Definition polys.cc:31
static BOOLEAN rField_is_Zp(const ring r)
Definition ring.h:505
#define IDELEMS(i)
@ testHomog
Definition structs.h:38

◆ wrp()

void wrp ( poly  p)
inline

Definition at line 310 of file polys.h.

Variable Documentation

◆ currRing

EXTERN_VAR ring currRing

Definition at line 18 of file polys.h.