Loading...
Searching...
No Matches
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)
| deletes old coeff before setting the new one
#define | pGetOrder(p)
| Order.
#define | pGetComp(p)
| Component.
#define | pSetComp(p, v)
#define | pGetExp(p, i)
| Exponent.
#define | pSetExp(p, i, v)
#define | pIncrExp(p, i)
#define | pDecrExp(p, i)
#define | pAddExp(p, i, v)
#define | pSubExp(p, i, v)
#define | pMultExp(p, i, v)
#define | pGetExpSum(p1, p2, i)
#define | pGetExpDiff(p1, p2, i)
#define | pNew()
| allocates the space for a new monomial – no initialization !!!
#define | pInit()
| allocates a new monomial and initializes everything to 0
#define | pLmInit(p)
| like pInit, except that expvector is initialized to that of p, p must be != NULL
#define | pHead(p)
| returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
#define | pLmFreeAndNext(p)
| assumes p != NULL, deletes p, returns pNext(p)
#define | pLmDelete(p)
| assume p != NULL, deletes Lm(p)->coef and Lm(p)
#define | pLmDeleteAndNext(p)
| like pLmDelete, returns pNext(p)
#define | pExpVectorCopy(d_p, s_p)
#define | pExpVectorAdd(p1, p2)
#define | pExpVectorSub(p1, p2)
#define | pExpVectorAddSub(p1, p2, p3)
#define | pExpVectorSum(pr, p1, p2)
#define | pExpVectorDiff(pr, p1, p2)
#define | pGetExpV(p, e)
| 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)
#define | pLmCmp(p, q)
| returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
#define | pLmCmpAction(p, q, 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)
#define | pCmp(p1, p2)
| pCmp: args may be NULL returns: (p2==NULL ? 1 : (p1 == NULL ? -1 : p_LmCmp(p1, p2)))
#define | pLtCmp(p, q)
#define | pLtCmpNoAbs(p, q)
#define | pLtCmpOrdSgnDiffM(p, q)
#define | pLtCmpOrdSgnDiffP(p, q)
#define | pLtCmpOrdSgnEqM(p, q)
#define | pLtCmpOrdSgnEqP(p, q)
#define | pDivisibleBy(a, b)
| 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)
| like pDivisibleBy, except that it is assumed that a!=NULL, b!=NULL
#define | pLmDivisibleByNoComp(a, b)
| like pLmDivisibleBy, does not check components
#define | pLmShortDivisibleBy(a, sev_a, b, not_sev_b)
| 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)
#define | pGetShortExpVector(a)
| returns the "Short Exponent Vector" – used to speed up divisibility tests (see polys-impl.cc )
#define | pDivisibleByRingCase(f, g)
| 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)
| return a copy of the poly
#define | pDelete(p_ptr)
#define | pNeg(p)
#define | ppMult_nn(p, n)
#define | pMult_nn(p, n)
#define | ppMult_mm(p, m)
#define | pMult_mm(p, m)
#define | pAdd(p, q)
#define | pPower(p, q)
#define | pMinus_mm_Mult_qq(p, m, q)
#define | pPlus_mm_Mult_qq(p, m, q)
#define | pMult(p, q)
#define | ppMult_qq(p, q)
#define | ppMult_Coeff_mm_DivSelect(p, m)
#define | pSortMerger(p)
| sorts p, assumes all monomials in p are different
#define | pSort(p)
#define | pSortAdd(p)
| sorts p, p may have equal monomials
#define | pSortCompCorrect(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)
| return true if p is either NULL, or if all exponents of p are 0, Comp of p might be != 0
#define | pIsConstant(p)
| like above, except that Comp must be 0
#define | pIsUnit(p)
| return true if the Lm is a constant <>0
#define | pLmIsConstantComp(p)
| like above, except that p must be != NULL
#define | pLmIsConstant(p)
#define | pIsConstantPoly(p)
| return TRUE if all monomials of p are constant
#define | pIsPurePower(p)
#define | pIsUnivariate(p)
#define | pIsVector(p)
#define | pGetVariables(p, e)
#define | pHasNotCFRing(p1, p2)
#define | pHasNotCF(p1, p2)
#define | pSplit(p, r)
#define | pSetm(p)
#define | pSetmComp(p)
| TODO:
#define | pWeight(i)
#define | pWTotaldegree(p)
#define | pWDegree(p)
#define | pSub(a, b)
#define | pmInit(a, b)
#define | pMDivide(a, b)
#define | pDivideM(a, b)
#define | pLcm(a, b, m)
#define | pDiff(a, b)
#define | pDiffOp(a, b, m)
#define | pMaxComp(p)
#define | pMinComp(p)
#define | pOneComp(p)
#define | pSetCompP(a, i)
#define | pISet(i)
#define | pNSet(n)
#define | pOne()
#define | pNormalize(p)
#define | pSize(p)
#define | pHomogen(p, varnum)
| homogenizes p by multiplying certain powers of the varnum-th variable
#define | pIsHomogen(p)
#define | pVectorHasUnitB(p, k)
#define | pVectorHasUnit(p, k, l)
#define | pDeleteComp(p, k)
#define | pSubst(p, n, e)
#define | ppJet(p, m)
#define | pJet(p, m)
#define | ppJetW(p, m, iv)
#define | pJetW(p, m, iv)
#define | pMinDeg(p, w)
#define | pSeries(n, p, u, w)
#define | pDegW(p, w)
| Deprecated: only for compatibility with older code!
#define | pVar(m)
#define | pEqualPolys(p1, p2)
#define | pTest(p)
#define | pLmTest(p)

## 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)
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.
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
EXTERN_VAR coeffs | coeffs_BIGINT

## 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:

- currRing
- rChangeCurrRing

Definition in file polys.h.

## Macro Definition Documentation

## pAdd

#define pAdd | ( |  | p,
|  |  | q )

Value:
p_Add_q(p, q, currRing)
p
int p
Definition cfModGcd.cc:4086
p_Add_q
static poly p_Add_q(poly p, poly q, const ring r)
Definition p_polys.h:938
currRing
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition polys.cc:13

Definition at line 204 of file polys.h.

## pAddExp

#define pAddExp | ( |  | p,
|  |  | i,
|  |  | v )

Value:
p_AddExp(p,i,v, currRing)
i
int i
Definition cfEzgcd.cc:132
v
const Variable & v
< [in] a sqrfree bivariate poly
Definition facBivar.h:39
p_AddExp
static long p_AddExp(poly p, int v, long ee, ring r)
Definition p_polys.h:608

Definition at line 46 of file polys.h.

## pCmp

#define pCmp | ( |  | p1,
|  |  | p2 )

Value:
p_Cmp(p1, p2, currRing)
p_Cmp
static int p_Cmp(poly p1, poly p2, ring r)
Definition p_polys.h:1748

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

Definition at line 116 of file polys.h.

## pCopy

#define pCopy | ( |  | p | ) |

Value:
p_Copy(p, currRing)
p_Copy
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition p_polys.h:848

return a copy of the poly

Definition at line 186 of file polys.h.

## pDecrExp

#define pDecrExp | ( |  | p,
|  |  | i )

Value:
p_DecrExp(p,i, currRing)
p_DecrExp
static long p_DecrExp(poly p, int v, ring r)
Definition p_polys.h:600

Definition at line 45 of file polys.h.

## pDegW

#define pDegW | ( |  | p,
|  |  | w )

Value:
p_DegW(p,w,currRing)
w
const CanonicalForm & w
Definition facAbsFact.cc:51
p_DegW
long p_DegW(poly p, const int *w, const ring R)
Definition p_polys.cc:691

Deprecated: only for compatibility with older code!

Definition at line 377 of file polys.h.

## pDelete

#define pDelete | ( |  | p_ptr | ) |

Value:
p_Delete(p_ptr, currRing)
p_Delete
static void p_Delete(poly *p, const ring r)
Definition p_polys.h:903

Definition at line 187 of file polys.h.

## pDeleteComp

#define pDeleteComp | ( |  | p,
|  |  | k )

Value:
p_DeleteComp(p,k,currRing)
k
int k
Definition cfEzgcd.cc:99
p_DeleteComp
void p_DeleteComp(poly *p, int k, const ring r)
Definition p_polys.cc:3668

Definition at line 361 of file polys.h.

## pDiff

#define pDiff | ( |  | a,
|  |  | b )

Value:
p_Diff(a,b,currRing)
b
CanonicalForm b
Definition cfModGcd.cc:4111
p_Diff
poly p_Diff(poly a, int k, const ring r)
Definition p_polys.cc:1902

Definition at line 297 of file polys.h.

## pDiffOp

#define pDiffOp | ( |  | a,
|  |  | b,
|  |  | m )

Value:
p_DiffOp(a,b,m,currRing)
m
int m
Definition cfEzgcd.cc:128
p_DiffOp
poly p_DiffOp(poly a, poly b, BOOLEAN multiply, const ring r)
Definition p_polys.cc:1977

Definition at line 298 of file polys.h.

## pDivideM

#define pDivideM | ( |  | a,
|  |  | b )

Value:
p_DivideM(a,b,currRing)
p_DivideM
poly p_DivideM(poly a, poly b, const ring r)
Definition p_polys.cc:1582

Definition at line 295 of file polys.h.

## pDivisibleBy

#define pDivisibleBy | ( |  | a,
|  |  | b )

Value:
p_DivisibleBy(a,b,currRing)
p_DivisibleBy
static BOOLEAN p_DivisibleBy(poly a, poly b, const ring r)
Definition p_polys.h:1921

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

## pDivisibleByRingCase

#define pDivisibleByRingCase | ( |  | f,
|  |  | g )

Value:
p_DivisibleByRingCase(f,g,currRing)
g
g
Definition cfModGcd.cc:4098
f
FILE * f
Definition checklibs.c:9
p_DivisibleByRingCase
BOOLEAN p_DivisibleByRingCase(poly f, poly g, const ring r)
divisibility check over ground ring (which may contain zero divisors); TRUE iff LT(f) divides LT(g),...
Definition p_polys.cc:1646

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

## pEqualPolys

#define pEqualPolys | ( |  | p1,
|  |  | p2 )

Value:
p_EqualPolys(p1,p2,currRing)
p_EqualPolys
BOOLEAN p_EqualPolys(poly p1, poly p2, const ring r)
Definition p_polys.cc:4666

Definition at line 400 of file polys.h.

## pExpVectorAdd

#define pExpVectorAdd | ( |  | p1,
|  |  | p2 )

Value:
p_ExpVectorAdd(p1, p2, currRing)
p_ExpVectorAdd
static void p_ExpVectorAdd(poly p1, poly p2, const ring r)
Definition p_polys.h:1432

Definition at line 88 of file polys.h.

## pExpVectorAddSub

#define pExpVectorAddSub | ( |  | p1,
|  |  | p2,
|  |  | p3 )

Value:
p_ExpVectorAddSub(p1, p2, p3, currRing)
p_ExpVectorAddSub
static void p_ExpVectorAddSub(poly p1, poly p2, poly p3, const ring r)
Definition p_polys.h:1477

Definition at line 90 of file polys.h.

## pExpVectorCopy

#define pExpVectorCopy | ( |  | d_p,
|  |  | s_p )

Value:
p_ExpVectorCopy(d_p, s_p, currRing)
p_ExpVectorCopy
static void p_ExpVectorCopy(poly d_p, poly s_p, const ring r)
Definition p_polys.h:1334

Definition at line 87 of file polys.h.

## pExpVectorDiff

#define pExpVectorDiff | ( |  | pr,
|  |  | p1,
|  |  | p2 )

Value:
p_ExpVectorDiff(pr, p1, p2, currRing)
p_ExpVectorDiff
static void p_ExpVectorDiff(poly pr, poly p1, poly p2, const ring r)
Definition p_polys.h:1495

Definition at line 92 of file polys.h.

## pExpVectorSub

#define pExpVectorSub | ( |  | p1,
|  |  | p2 )

Value:
p_ExpVectorSub(p1, p2, currRing)
p_ExpVectorSub
static void p_ExpVectorSub(poly p1, poly p2, const ring r)
Definition p_polys.h:1461

Definition at line 89 of file polys.h.

## pExpVectorSum

#define pExpVectorSum | ( |  | pr,
|  |  | p1,
|  |  | p2 )

Value:
p_ExpVectorSum(pr, p1, p2, currRing)
p_ExpVectorSum
static void p_ExpVectorSum(poly pr, poly p1, poly p2, const ring r)
Definition p_polys.h:1446

Definition at line 91 of file polys.h.

## pGetComp

#define pGetComp | ( |  | p | ) |

Value:
(int)__p_GetComp(p, currRing)
__p_GetComp
#define __p_GetComp(p, r)
Definition monomials.h:63

Component.

Definition at line 38 of file polys.h.

## pGetExp

#define pGetExp | ( |  | p,
|  |  | i )

Value:
p_GetExp(p, i, currRing)
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:471

Exponent.

Definition at line 42 of file polys.h.

## pGetExpDiff

#define pGetExpDiff | ( |  | p1,
|  |  | p2,
|  |  | i )

Value:
p_GetExpDiff(p1, p2, i, currRing)
p_GetExpDiff
static long p_GetExpDiff(poly p1, poly p2, int i, ring r)
Definition p_polys.h:637

Definition at line 50 of file polys.h.

## pGetExpSum

#define pGetExpSum | ( |  | p1,
|  |  | p2,
|  |  | i )

Value:
p_GetExpSum(p1, p2, i, currRing)
p_GetExpSum
static long p_GetExpSum(poly p1, poly p2, int i, ring r)
Definition p_polys.h:631

Definition at line 49 of file polys.h.

## pGetExpV

#define pGetExpV | ( |  | p,
|  |  | e )

Value:
p_GetExpV(p, e, currRing)
p_GetExpV
static void p_GetExpV(poly p, int *ev, const ring r)
Definition p_polys.h:1541

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

## pGetOrder

#define pGetOrder | ( |  | p | ) |

Value:
p_GetOrder(p, currRing)
p_GetOrder
static long p_GetOrder(poly p, ring r)
Definition p_polys.h:423

Order.

Definition at line 35 of file polys.h.

## pGetShortExpVector

#define pGetShortExpVector | ( |  | a | ) |

Value:
p_GetShortExpVector(a, currRing)
p_GetShortExpVector
unsigned long p_GetShortExpVector(const poly p, const ring r)
Definition p_polys.cc:4934

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

Definition at line 153 of file polys.h.

## pGetVariables

#define pGetVariables | ( |  | p,
|  |  | e )

Value:
p_GetVariables(p, e, currRing)
p_GetVariables
int p_GetVariables(poly p, int *e, const ring r)
set entry e[i] to 1 if var(i) occurs in p, ignore var(j) if e[j]>0 return #(e[i]>0)
Definition p_polys.cc:1268

Definition at line 252 of file polys.h.

## pHasNotCF

#define pHasNotCF | ( |  | p1,
|  |  | p2 )

Value:
p_HasNotCF(p1,p2,currRing)
p_HasNotCF
BOOLEAN p_HasNotCF(poly p1, poly p2, const ring r)
Definition p_polys.cc:1330

Definition at line 264 of file polys.h.

## pHasNotCFRing

#define pHasNotCFRing | ( |  | p1,
|  |  | p2 )

Value:
p_HasNotCFRing(p1,p2,currRing)
p_HasNotCFRing
BOOLEAN p_HasNotCFRing(poly p1, poly p2, const ring r)
Definition p_polys.cc:1346

Definition at line 263 of file polys.h.

## pHead

#define pHead | ( |  | p | ) |

Value:
p_Head(p, currRing)
p_Head
static poly p_Head(const poly p, const ring r)
copy the (leading) term of p
Definition p_polys.h:862

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

Definition at line 68 of file polys.h.

## pHomogen

#define pHomogen | ( |  | p,
|  |  | varnum )

Value:
p_Homogen(p,varnum,currRing)
p_Homogen
poly p_Homogen(poly p, int varnum, const ring r)
Definition p_polys.cc:3319

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

Definition at line 323 of file polys.h.

## pIncrExp

#define pIncrExp | ( |  | p,
|  |  | i )

Value:
p_IncrExp(p,i, currRing)
p_IncrExp
static long p_IncrExp(poly p, int v, ring r)
Definition p_polys.h:593

Definition at line 44 of file polys.h.

## pInit

#define pInit | ( |  | ) |

Value:
p_Init(currRing,currRing->PolyBin)
p_Init
static poly p_Init(const ring r, omBin bin)
Definition p_polys.h:1341

allocates a new monomial and initializes everything to 0

Definition at line 62 of file polys.h.

## pIsConstant

#define pIsConstant | ( |  | p | ) |

Value:
p_IsConstant(p,currRing)
p_IsConstant
static BOOLEAN p_IsConstant(const poly p, const ring r)
Definition p_polys.h:1985

like above, except that Comp must be 0

Definition at line 239 of file polys.h.

## pIsConstantComp

#define pIsConstantComp | ( |  | p | ) |

Value:
p_IsConstantComp(p, currRing)
p_IsConstantComp
static BOOLEAN p_IsConstantComp(const poly p, const ring r)
like the respective p_LmIs* routines, except that p might be empty
Definition p_polys.h:1979

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

Definition at line 237 of file polys.h.

## pIsConstantPoly

#define pIsConstantPoly | ( |  | p | ) |

Value:
p_IsConstantPoly(p, currRing)
p_IsConstantPoly
static BOOLEAN p_IsConstantPoly(const poly p, const ring r)
Definition p_polys.h:1999

return TRUE if all monomials of p are constant

Definition at line 247 of file polys.h.

## pISet

#define pISet | ( |  | i | ) |

Value:
p_ISet(i,currRing)
p_ISet
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
Definition p_polys.cc:1298

Definition at line 313 of file polys.h.

## pIsHomogen

#define pIsHomogen | ( |  | p | ) |

Value:
p_IsHomogen(p,currRing)

Definition at line 330 of file polys.h.

## pIsPurePower

#define pIsPurePower | ( |  | p | ) |

Value:
p_IsPurePower(p, currRing)
p_IsPurePower
int p_IsPurePower(const poly p, const ring r)
return i, if head depends only on var(i)
Definition p_polys.cc:1227

Definition at line 249 of file polys.h.

## pIsUnit

#define pIsUnit | ( |  | p | ) |

Value:
p_IsUnit(p,currRing)
p_IsUnit
static BOOLEAN p_IsUnit(const poly p, const ring r)
Definition p_polys.h:2012

return true if the Lm is a constant <>0

Definition at line 241 of file polys.h.

## pIsUnivariate

#define pIsUnivariate | ( |  | p | ) |

Value:
p_IsUnivariate(p, currRing)
p_IsUnivariate
int p_IsUnivariate(poly p, const ring r)
return i, if poly depends only on var(i)
Definition p_polys.cc:1248

Definition at line 250 of file polys.h.

## pIsVector

#define pIsVector | ( |  | p | ) |

Value:
(pGetComp(p)>0)
pGetComp
#define pGetComp(p)
Component.
Definition polys.h:38

Definition at line 251 of file polys.h.

## pJet

#define pJet | ( |  | p,
|  |  | m )

Value:
p_Jet(p,m,currRing)
p_Jet
poly p_Jet(poly p, int m, const ring R)
Definition p_polys.cc:4540

Definition at line 368 of file polys.h.

## pJetW

#define pJetW | ( |  | p,
|  |  | m,
|  |  | iv )

Value:
p_JetW(p,m,iv,currRing)
p_JetW
poly p_JetW(poly p, int m, int *w, const ring R)
Definition p_polys.cc:4584

Definition at line 370 of file polys.h.

## pLcm

#define pLcm | ( |  | a,
|  |  | b,
|  |  | m )

Value:
p_Lcm(a,b,m,currRing)
p_Lcm
void p_Lcm(const poly a, const poly b, poly m, const ring r)
Definition p_polys.cc:1659

Definition at line 296 of file polys.h.

## pLmCmp

#define pLmCmp | ( |  | p,
|  |  | q )

Value:
p_LmCmp(p,q,currRing)
p_LmCmp
static int p_LmCmp(poly p, poly q, const ring r)
Definition p_polys.h:1601

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

Definition at line 106 of file polys.h.

## pLmCmpAction

#define pLmCmpAction | ( |  | p,
|  |  | q,
|  |  | actionE,
|  |  | actionG,
|  |  | actionS )

Value:
_p_LmCmpAction(p,q,currRing, actionE, actionG,actionS)
_p_LmCmpAction
#define _p_LmCmpAction(p, q, r, actionE, actionG, actionS)
Definition p_polys.h:1297

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

Definition at line 109 of file polys.h.

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

## pLmDelete

#define pLmDelete | ( |  | p | ) |

Value:
p_LmDelete(p, currRing)
p_LmDelete
static void p_LmDelete(poly p, const ring r)
Definition p_polys.h:725

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

Definition at line 77 of file polys.h.

## pLmDeleteAndNext

#define pLmDeleteAndNext | ( |  | p | ) |

Value:
p_LmDeleteAndNext(p, currRing)
p_LmDeleteAndNext
static poly p_LmDeleteAndNext(poly p, const ring r)
Definition p_polys.h:757

like pLmDelete, returns pNext(p)

Definition at line 79 of file polys.h.

## pLmDivisibleBy

#define pLmDivisibleBy | ( |  | a,
|  |  | b )

Value:
p_LmDivisibleBy(a,b,currRing)
p_LmDivisibleBy
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
Definition p_polys.h:1912

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

Definition at line 141 of file polys.h.

## pLmDivisibleByNoComp

#define pLmDivisibleByNoComp | ( |  | a,
|  |  | b )

Value:
p_LmDivisibleByNoComp(a,b,currRing)
p_LmDivisibleByNoComp
static BOOLEAN p_LmDivisibleByNoComp(poly a, poly b, const ring r)
Definition p_polys.h:1898

like pLmDivisibleBy, does not check components

Definition at line 143 of file polys.h.

## pLmEqual

#define pLmEqual | ( |  | p1,
|  |  | p2 )

Value:
p_ExpVectorEqual(p1, p2, currRing)
p_ExpVectorEqual
static BOOLEAN p_ExpVectorEqual(poly p1, poly p2, const ring r1, const ring r2)
Definition p_polys.cc:4680

Definition at line 112 of file polys.h.

## pLmFreeAndNext

#define pLmFreeAndNext | ( |  | p | ) |

Value:
p_LmFreeAndNext(p, currRing)
p_LmFreeAndNext
static poly p_LmFreeAndNext(poly p, ring)
Definition p_polys.h:713

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

Definition at line 75 of file polys.h.

## pLmInit

#define pLmInit | ( |  | p | ) |

Value:
p_LmInit(p, currRing)
p_LmInit
static poly p_LmInit(poly p, const ring r)
Definition p_polys.h:1356

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

Definition at line 65 of file polys.h.

## pLmIsConstant

#define pLmIsConstant | ( |  | p | ) |

Value:
p_LmIsConstant(p,currRing)
p_LmIsConstant
static BOOLEAN p_LmIsConstant(const poly p, const ring r)
Definition p_polys.h:1025

Definition at line 244 of file polys.h.

## pLmIsConstantComp

#define pLmIsConstantComp | ( |  | p | ) |

Value:
p_LmIsConstantComp(p, currRing)
p_LmIsConstantComp
static BOOLEAN p_LmIsConstantComp(const poly p, const ring r)
Definition p_polys.h:1008

like above, except that p must be != NULL

Definition at line 243 of file polys.h.

## pLmRingShortDivisibleBy

#define pLmRingShortDivisibleBy | ( |  | a,
|  |  | sev_a,
|  |  | b,
|  |  | not_sev_b )

Value:
p_LmRingShortDivisibleBy(a, sev_a, b, not_sev_b, currRing)

Definition at line 149 of file polys.h.

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

## pLmShortDivisibleBy

#define pLmShortDivisibleBy | ( |  | a,
|  |  | sev_a,
|  |  | b,
|  |  | not_sev_b )

Value:
p_LmShortDivisibleBy(a, sev_a, b, not_sev_b, currRing)
p_LmShortDivisibleBy
static BOOLEAN p_LmShortDivisibleBy(poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
Definition p_polys.h:1931

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

Definition at line 147 of file polys.h.

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

## pLmTest

#define pLmTest | ( |  | p | ) |

Value:
_p_LmTest(p, currRing, PDEBUG)
PDEBUG
#define PDEBUG
Definition auxiliary.h:171
_p_LmTest
BOOLEAN _p_LmTest(poly p, ring r, int level)
Definition pDebug.cc:322

Definition at line 416 of file polys.h.

## pLtCmp

#define pLtCmp | ( |  | p,
|  |  | q )

Value:
p_LtCmp(p,q,currRing)
p_LtCmp
static int p_LtCmp(poly p, poly q, const ring r)
Definition p_polys.h:1642

Definition at line 124 of file polys.h.

## pLtCmpNoAbs

#define pLtCmpNoAbs | ( |  | p,
|  |  | q )

Value:
p_LtCmpNoAbs(p,q,currRing)
p_LtCmpNoAbs
static int p_LtCmpNoAbs(poly p, poly q, const ring r)
Definition p_polys.h:1668

Definition at line 125 of file polys.h.

## pLtCmpOrdSgnDiffM

#define pLtCmpOrdSgnDiffM | ( |  | p,
|  |  | q )

Value:
p_LtCmpOrdSgnDiffM(p,q,currRing)
p_LtCmpOrdSgnDiffM
static int p_LtCmpOrdSgnDiffM(poly p, poly q, const ring r)
Definition p_polys.h:1690

Definition at line 126 of file polys.h.

## pLtCmpOrdSgnDiffP

#define pLtCmpOrdSgnDiffP | ( |  | p,
|  |  | q )

Value:
p_LtCmpOrdSgnDiffP(p,q,currRing)
p_LtCmpOrdSgnDiffP
static int p_LtCmpOrdSgnDiffP(poly p, poly q, const ring r)
Definition p_polys.h:1699

Definition at line 127 of file polys.h.

## pLtCmpOrdSgnEqM

#define pLtCmpOrdSgnEqM | ( |  | p,
|  |  | q )

Value:
p_LtCmpOrdSgnEqM(p,q,currRing)
p_LtCmpOrdSgnEqM
static int p_LtCmpOrdSgnEqM(poly p, poly q, const ring r)
Definition p_polys.h:1715

Definition at line 128 of file polys.h.

## pLtCmpOrdSgnEqP

#define pLtCmpOrdSgnEqP | ( |  | p,
|  |  | q )

Value:
p_LtCmpOrdSgnEqP(p,q,currRing)
p_LtCmpOrdSgnEqP
static int p_LtCmpOrdSgnEqP(poly p, poly q, const ring r)
Definition p_polys.h:1724

Definition at line 129 of file polys.h.

## pMaxComp

#define pMaxComp | ( |  | p | ) |

Value:
p_MaxComp(p, currRing)
p_MaxComp
static long p_MaxComp(poly p, ring lmRing, ring tailRing)
Definition p_polys.h:294

Definition at line 300 of file polys.h.

## pMDivide

#define pMDivide | ( |  | a,
|  |  | b )

Value:
p_MDivide(a,b,currRing)
p_MDivide
poly p_MDivide(poly a, poly b, const ring r)
Definition p_polys.cc:1493

Definition at line 294 of file polys.h.

## pMinComp

#define pMinComp | ( |  | p | ) |

Value:
p_MinComp(p, currRing)
p_MinComp
static long p_MinComp(poly p, ring lmRing, ring tailRing)
Definition p_polys.h:315

Definition at line 301 of file polys.h.

## pMinDeg

#define pMinDeg | ( |  | p,
|  |  | w )

Value:
p_MinDeg(p,w,currRing)
p_MinDeg
int p_MinDeg(poly p, intvec *w, const ring R)
Definition p_polys.cc:4602

Definition at line 371 of file polys.h.

## pmInit

#define pmInit | ( |  | a,
|  |  | b )

Value:
p_mInit(a,b,currRing)
p_mInit
poly p_mInit(const char *st, BOOLEAN &ok, const ring r)
Definition p_polys.cc:1443

Definition at line 290 of file polys.h.

## pMinus_mm_Mult_qq

#define pMinus_mm_Mult_qq | ( |  | p,
|  |  | m,
|  |  | q )

Value:
p_Minus_mm_Mult_qq(p, m, q, currRing)
p_Minus_mm_Mult_qq
static poly p_Minus_mm_Mult_qq(poly p, const poly m, const poly q, int &lp, int lq, const poly spNoether, const ring r)
Definition p_polys.h:1077

Definition at line 206 of file polys.h.

## pMult

#define pMult | ( |  | p,
|  |  | q )

Value:
p_Mult_q(p, q, currRing)
p_Mult_q
static poly p_Mult_q(poly p, poly q, const ring r)
Definition p_polys.h:1125

Definition at line 208 of file polys.h.

## pMult_mm

#define pMult_mm | ( |  | p,
|  |  | m )

Value:
p_Mult_mm(p, m, currRing)
p_Mult_mm
static poly p_Mult_mm(poly p, poly m, const ring r)
Definition p_polys.h:1053

Definition at line 203 of file polys.h.

## pMult_nn

#define pMult_nn | ( |  | p,
|  |  | n )

Value:
p_Mult_nn(p, n, currRing)
p_Mult_nn
static poly p_Mult_nn(poly p, number n, const ring r)
Definition p_polys.h:960

Definition at line 201 of file polys.h.

## pMultExp

#define pMultExp | ( |  | p,
|  |  | i,
|  |  | v )

Value:
p_MultExp(p,i,v, currRing)
p_MultExp
static long p_MultExp(poly p, int v, long ee, ring r)
Definition p_polys.h:623

Definition at line 48 of file polys.h.

## pNeg

#define pNeg | ( |  | p | ) |

Value:
p_Neg(p, currRing)
p_Neg
static poly p_Neg(poly p, const ring r)
Definition p_polys.h:1114

Definition at line 199 of file polys.h.

## pNew

#define pNew | ( |  | ) |

Value:
p_New(currRing)
p_New
static poly p_New(const ring, omBin bin)
Definition p_polys.h:666

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

Definition at line 60 of file polys.h.

## pNormalize

#define pNormalize | ( |  | p | ) |

Value:
p_Normalize(p,currRing)
p_Normalize
void p_Normalize(poly p, const ring r)
Definition p_polys.cc:3939

Definition at line 318 of file polys.h.

## pNSet

#define pNSet | ( |  | n | ) |

Value:
p_NSet(n,currRing)
p_NSet
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
Definition p_polys.cc:1474

Definition at line 314 of file polys.h.

## pOne

#define pOne | ( |  | ) |

Value:
p_One(currRing)
p_One
poly p_One(const ring r)
Definition p_polys.cc:1314

Definition at line 316 of file polys.h.

## pOneComp

#define pOneComp | ( |  | p | ) |

Value:
p_OneComp(p, currRing)
p_OneComp
BOOLEAN p_OneComp(poly p, const ring r)
return TRUE if all monoms have the same component
Definition p_polys.cc:1209

Definition at line 303 of file polys.h.

## ppJet

#define ppJet | ( |  | p,
|  |  | m )

Value:
pp_Jet(p,m,currRing)
pp_Jet
poly pp_Jet(poly p, int m, const ring R)
Definition p_polys.cc:4484

Definition at line 367 of file polys.h.

## ppJetW

#define ppJetW | ( |  | p,
|  |  | m,
|  |  | iv )

Value:
pp_JetW(p,m,iv,currRing)
pp_JetW
poly pp_JetW(poly p, int m, int *w, const ring R)
Definition p_polys.cc:4557

Definition at line 369 of file polys.h.

## pPlus_mm_Mult_qq

#define pPlus_mm_Mult_qq | ( |  | p,
|  |  | m,
|  |  | q )

Value:
p_Plus_mm_Mult_qq(p, m, q, currRing)
p_Plus_mm_Mult_qq
static poly p_Plus_mm_Mult_qq(poly p, poly m, poly q, int &lp, int lq, const ring r)
Definition p_polys.h:1204

Definition at line 207 of file polys.h.

## ppMult_Coeff_mm_DivSelect

#define ppMult_Coeff_mm_DivSelect | ( |  | p,
|  |  | m )

Value:
pp_Mult_Coeff_mm_DivSelect(p, m, currRing)
pp_Mult_Coeff_mm_DivSelect
static poly pp_Mult_Coeff_mm_DivSelect(poly p, const poly m, const ring r)
Definition p_polys.h:1097

Definition at line 211 of file polys.h.

## ppMult_mm

#define ppMult_mm | ( |  | p,
|  |  | m )

Value:
pp_Mult_mm(p, m, currRing)
pp_Mult_mm
static poly pp_Mult_mm(poly p, poly m, const ring r)
Definition p_polys.h:1033

Definition at line 202 of file polys.h.

## ppMult_nn

#define ppMult_nn | ( |  | p,
|  |  | n )

Value:
pp_Mult_nn(p, n, currRing)
pp_Mult_nn
static poly pp_Mult_nn(poly p, number n, const ring r)
Definition p_polys.h:994

Definition at line 200 of file polys.h.

## ppMult_qq

#define ppMult_qq | ( |  | p,
|  |  | q )

Value:
pp_Mult_qq(p, q, currRing)
pp_Mult_qq
static poly pp_Mult_qq(poly p, poly q, const ring r)
Definition p_polys.h:1167

Definition at line 209 of file polys.h.

## pPower

#define pPower | ( |  | p,
|  |  | q )

Value:
p_Power(p, q, currRing)
p_Power
poly p_Power(poly p, int i, const ring r)
Definition p_polys.cc:2245

Definition at line 205 of file polys.h.

## pSeries

#define pSeries | ( |  | n,
|  |  | p,
|  |  | u,
|  |  | w )

Value:
p_Series(n,p,u,w,currRing)
p_Series
poly p_Series(int n, poly p, poly u, intvec *w, const ring R)
Definition p_polys.cc:4652

Definition at line 372 of file polys.h.

## pSetCoeff

#define pSetCoeff | ( |  | p,
|  |  | n )

Value:
p_SetCoeff(p,n,currRing)
p_SetCoeff
static number p_SetCoeff(poly p, number n, ring r)
Definition p_polys.h:414

deletes old coeff before setting the new one

Definition at line 32 of file polys.h.

## pSetComp

#define pSetComp | ( |  | p,
|  |  | v )

Value:
p_SetComp(p,v, currRing)
p_SetComp
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition p_polys.h:249

Definition at line 39 of file polys.h.

## pSetCompP

#define pSetCompP | ( |  | a,
|  |  | i )

Value:
p_SetCompP(a, i, currRing)
p_SetCompP
static void p_SetCompP(poly p, int i, ring r)
Definition p_polys.h:256

Definition at line 304 of file polys.h.

## pSetExp

#define pSetExp | ( |  | p,
|  |  | i,
|  |  | v )

Value:
p_SetExp(p, i, v, currRing)
p_SetExp
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent @Note: VarOffset encodes the position in p->exp
Definition p_polys.h:490

Definition at line 43 of file polys.h.

## pSetExpV

#define pSetExpV | ( |  | p,
|  |  | e )

Value:
p_SetExpV(p, e, currRing)
p_SetExpV
static void p_SetExpV(poly p, int *ev, const ring r)
Definition p_polys.h:1565

Definition at line 98 of file polys.h.

## pSetm

#define pSetm | ( |  | p | ) |

Value:
p_Setm(p, currRing)
p_Setm
static void p_Setm(poly p, const ring r)
Definition p_polys.h:235

Definition at line 272 of file polys.h.

## pSetmComp

#define pSetmComp | ( |  | p | ) |

Value:
p_Setm(p, currRing)

TODO:

Definition at line 274 of file polys.h.

## pSize

#define pSize | ( |  | p | ) |

Value:
p_Size(p,currRing)
p_Size
int p_Size(poly p, const ring r)
Definition p_polys.cc:3302

Definition at line 319 of file polys.h.

## pSort

#define pSort | ( |  | p | ) |

Value:
p_SortMerge(p, currRing)
p_SortMerge
static poly p_SortMerge(poly p, const ring r, BOOLEAN revert=FALSE)
Definition p_polys.h:1250

Definition at line 219 of file polys.h.

## pSortAdd

#define pSortAdd | ( |  | p | ) |

Value:
p_SortAdd(p, currRing)
p_SortAdd
static poly p_SortAdd(poly p, const ring r, BOOLEAN revert=FALSE)
Definition p_polys.h:1240

sorts p, p may have equal monomials

Definition at line 222 of file polys.h.

## pSortCompCorrect

#define pSortCompCorrect | ( |  | p | ) |

Value:
pSort(p)
pSort
#define pSort(p)
Definition polys.h:219

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

## pSortMerger

#define pSortMerger | ( |  | p | ) |

Value:
p_SortMerge(p, currRing)

sorts p, assumes all monomials in p are different

Definition at line 218 of file polys.h.

## pSplit

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

Value:
p_Split(p,r)
p_Split
void p_Split(poly p, poly *h)
Definition p_polys.cc:1321

Definition at line 266 of file polys.h.

## pSub

#define pSub | ( |  | a,
|  |  | b )

Value:
p_Sub(a,b,currRing)
p_Sub
poly p_Sub(poly p1, poly p2, const ring r)
Definition p_polys.cc:1994

Definition at line 288 of file polys.h.

## pSubExp

#define pSubExp | ( |  | p,
|  |  | i,
|  |  | v )

Value:
p_SubExp(p,i,v, currRing)
p_SubExp
static long p_SubExp(poly p, int v, long ee, ring r)
Definition p_polys.h:615

Definition at line 47 of file polys.h.

## pSubst

#define pSubst | ( |  | p,
|  |  | n,
|  |  | e )

Value:
p_Subst(p,n,e,currRing)
p_Subst
poly p_Subst(poly p, int n, poly e, const ring r)
Definition p_polys.cc:4084

Definition at line 366 of file polys.h.

## pTest

#define pTest | ( |  | p | ) |

Value:
_p_Test(p, currRing, PDEBUG)
_p_Test
BOOLEAN _p_Test(poly p, ring r, int level)
Definition pDebug.cc:211

Definition at line 415 of file polys.h.

## pVar

#define pVar | ( |  | m | ) |

Value:
p_Var(m,currRing)
p_Var
int p_Var(poly m, const ring r)
Definition p_polys.cc:4810

Definition at line 381 of file polys.h.

## pVectorHasUnit

#define pVectorHasUnit | ( |  | p,
|  |  | k,
|  |  | l )

Value:
p_VectorHasUnit(p,k,l,currRing)
l
int l
Definition cfEzgcd.cc:100
p_VectorHasUnit
void p_VectorHasUnit(poly p, int *k, int *len, const ring r)
Definition p_polys.cc:3510

Definition at line 334 of file polys.h.

## pVectorHasUnitB

#define pVectorHasUnitB | ( |  | p,
|  |  | k )

Value:
p_VectorHasUnitB(p,k,currRing)
p_VectorHasUnitB
BOOLEAN p_VectorHasUnitB(poly p, int *k, const ring r)
Definition p_polys.cc:3487

Definition at line 333 of file polys.h.

## pWDegree

#define pWDegree | ( |  | p | ) |

Value:
p_WDegree(p,currRing)
p_WDegree
long p_WDegree(poly p, const ring r)
Definition p_polys.cc:715

Definition at line 285 of file polys.h.

## pWeight

#define pWeight | ( |  | i | ) |

Value:
p_Weight(i,currRing)
p_Weight
int p_Weight(int i, const ring r)
Definition p_polys.cc:706

Definition at line 281 of file polys.h.

## pWTotaldegree

#define pWTotaldegree | ( |  | p | ) |

Value:
p_WTotaldegree(p,currRing)
p_WTotaldegree
long p_WTotaldegree(poly p, const ring r)
Definition p_polys.cc:612

Definition at line 284 of file polys.h.

## Typedef Documentation

## polyset

typedef poly* polyset

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

{
assume(q!=NULL);
if (q==NULL)
{
WerrorS("div. by 0");
return NULL;
}
if (p==NULL)
{
p_Delete(&q,r);
return NULL;
}
if ((pNext(q)!=NULL)||rIsPluralRing(r))
{ /* This means that q != 0 consists of at least two terms*/
if(p_GetComp(p,r)==0)
{
if (!rIsNCRing(r))
{
if ((rFieldType(r)==n_Q)
||(rFieldType(r)==n_Zp)
||(rFieldType(r)==n_algExt))
{
poly res=singclap_pdivide(p, q, r);
p_Delete(&p,r);
p_Delete(&q,r);
return res;
}
if((rFieldType(r)==n_transExt)
&&(convSingTrP(p,r))
&&(convSingTrP(q,r)))
{
poly res=singclap_pdivide(p, q, r);
p_Delete(&p,r);
p_Delete(&q,r);
return res;
}
}
// generic division for poly
{
ideal vi=idInit(1,1); vi->m[0]=q;
ideal ui=idInit(1,1); ui->m[0]=p;
ideal R; matrix U;
ring save_ring=currRing;
if (r!=currRing) rChangeCurrRing(r);
BITSET save_opt;
SI_SAVE_OPT1(save_opt);
si_opt_1 &= ~(Sy_bit(OPT_PROT));
ideal m = idLift(vi,ui,&R, FALSE,TRUE,TRUE,&U);
SI_RESTORE_OPT1(save_opt);
if (r!=save_ring) rChangeCurrRing(save_ring);
matrix T = id_Module2formatedMatrix(m,1,1,r);
p=MATELEM(T,1,1); MATELEM(T,1,1)=NULL;
id_Delete((ideal *)&T,r);
id_Delete((ideal *)&U,r);
id_Delete(&R,r);
//vi->m[0]=NULL; ui->m[0]=NULL;
id_Delete(&vi,r);
id_Delete(&ui,r);
return p;
}
}
else
{
int comps=p_MaxComp(p,r);
ideal I=idInit(comps,1);
poly h;
int i;
// conversion to a list of polys:
while (p!=NULL)
{
i=p_GetComp(p,r)-1;
h=pNext(p);
pNext(p)=NULL;
p_SetComp(p,0,r);
I->m[i]=p_Add_q(I->m[i],p,r);
p=h;
}
// division and conversion to vector:
h=NULL;
p=NULL;
for(i=comps-1;i>=0;i--)
{
if (I->m[i]!=NULL)
{
if((rFieldType(r)==n_transExt)
&&(convSingTrP(I->m[i],r))
&&(convSingTrP(q,r))
&&(!rIsNCRing(r)))
{
h=singclap_pdivide(I->m[i],q,r);
}
else if (((rFieldType(r)==n_Q)
||(rFieldType(r)==n_Zp)
||(rFieldType(r)==n_algExt))
&&(!rIsNCRing(r)))
h=singclap_pdivide(I->m[i],q,r);
else
{
ideal vi=idInit(1,1); vi->m[0]=q;
ideal ui=idInit(1,1); ui->m[0]=I->m[i];
ideal R; matrix U;
ring save_ring=currRing;
if (r!=currRing) rChangeCurrRing(r);
BITSET save_opt;
SI_SAVE_OPT1(save_opt);
si_opt_1 &= ~(Sy_bit(OPT_PROT));
ideal m = idLift(vi,ui,&R, FALSE,TRUE,TRUE,&U);
SI_RESTORE_OPT1(save_opt);
if (r!=save_ring) rChangeCurrRing(save_ring);
if (idIs0(R))
{
matrix T = id_Module2formatedMatrix(m,1,1,r);
p=MATELEM(T,1,1); MATELEM(T,1,1)=NULL;
id_Delete((ideal *)&T,r);
}
else p=NULL;
id_Delete((ideal*)&U,r);
id_Delete(&R,r);
vi->m[0]=NULL; ui->m[0]=NULL;
id_Delete(&vi,r);
id_Delete(&ui,r);
}
p_SetCompP(h,i+1,r);
p=p_Add_q(p,h,r);
}
}
id_Delete(&I,r);
p_Delete(&q,r);
return p;
}
}
else
{ /* This means that q != 0 consists of just one term, or LetterPlace */
if (pNext(q)!=NULL)
{
WerrorS("division over a coefficient domain only implemented for terms");
return NULL;
}
return p_DivideM(p,q,r);
}
return NULL;
}
BITSET
#define BITSET
Definition auxiliary.h:85
TRUE
#define TRUE
Definition auxiliary.h:101
FALSE
#define FALSE
Definition auxiliary.h:97
convSingTrP
BOOLEAN convSingTrP(poly p, const ring r)
Definition clapconv.cc:375
singclap_pdivide
poly singclap_pdivide(poly f, poly g, const ring r)
Definition clapsing.cc:649
n_Q
@ n_Q
rational (GMP) numbers
Definition coeffs.h:30
n_algExt
@ n_algExt
used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic
Definition coeffs.h:35
n_Zp
@ n_Zp
\F{p < 2^31}
Definition coeffs.h:29
n_transExt
@ n_transExt
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
Definition coeffs.h:38
res
CanonicalForm res
Definition facAbsFact.cc:60
WerrorS
void WerrorS(const char *s)
Definition feFopen.cc:24
idLift
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:1111
idIs0
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
Definition simpleideals.cc:960
T
STATIC_VAR jList * T
Definition janet.cc:30
h
STATIC_VAR Poly * h
Definition janet.cc:971
MATELEM
#define MATELEM(mat, i, j)
1-based access to matrix
Definition matpol.h:29
matrix
ip_smatrix * matrix
Definition matpol.h:43
assume
#define assume(x)
Definition mod2.h:389
p_GetComp
#define p_GetComp(p, r)
Definition monomials.h:64
pNext
#define pNext(p)
Definition monomials.h:36
NULL
#define NULL
Definition omList.c:12
si_opt_1
VAR unsigned si_opt_1
Definition options.c:5
OPT_PROT
#define OPT_PROT
Definition options.h:76
SI_SAVE_OPT1
#define SI_SAVE_OPT1(A)
Definition options.h:21
SI_RESTORE_OPT1
#define SI_RESTORE_OPT1(A)
Definition options.h:24
Sy_bit
#define Sy_bit(x)
Definition options.h:31
rChangeCurrRing
void rChangeCurrRing(ring r)
Definition polys.cc:16
rFieldType
static n_coeffType rFieldType(const ring r)
the type of the coefficient filed of r (n_Zp, n_Q, etc)
Definition ring.h:562
rIsPluralRing
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition ring.h:406
rIsNCRing
static BOOLEAN rIsNCRing(const ring r)
Definition ring.h:427
idInit
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition simpleideals.cc:35
id_Delete
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
Definition simpleideals.cc:123
id_Module2formatedMatrix
matrix id_Module2formatedMatrix(ideal mod, int rows, int cols, const ring R)
Definition simpleideals.cc:1640
R
#define R
Definition sirandom.c:27

## p_DivRem()

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

Definition at line 343 of file polys.cc.

{
assume(q!=NULL);
rest=NULL;
if (q==NULL)
{
WerrorS("div. by 0");
return NULL;
}
if (p==NULL)
{
p_Delete(&q,r);
return NULL;
}
if(p_GetComp(p,r)==0)
{
if((rFieldType(r)==n_transExt)
&&(convSingTrP(p,r))
&&(convSingTrP(q,r))
&&(!rIsNCRing(r)))
{
poly res=singclap_pdivide(p, q, r);
rest=singclap_pmod(p,q,r);
p_Delete(&p,r);
p_Delete(&q,r);
return res;
}
else if ((r->cf->convSingNFactoryN!=ndConvSingNFactoryN)
&&(!rField_is_Ring(r))
&&(!rIsNCRing(r)))
{
poly res=singclap_pdivide(p, q, r);
rest=singclap_pmod(p,q,r);
p_Delete(&p,r);
p_Delete(&q,r);
return res;
}
else
{
ideal vi=idInit(1,1); vi->m[0]=q;
ideal ui=idInit(1,1); ui->m[0]=p;
ideal R; matrix U;
ring save_ring=currRing;
if (r!=currRing) rChangeCurrRing(r);
BITSET save_opt;
SI_SAVE_OPT1(save_opt);
si_opt_1 &= ~(Sy_bit(OPT_PROT));
ideal m = idLift(vi,ui,&R, FALSE,TRUE,TRUE,&U);
SI_RESTORE_OPT1(save_opt);
if (r!=save_ring) rChangeCurrRing(save_ring);
p=m->m[0]; m->m[0]=NULL;
id_Delete(&m,r);
p_SetCompP(p,0,r);
rest=R->m[0]; R->m[0]=NULL;
id_Delete(&R,r);
p_SetCompP(rest,0,r);
id_Delete((ideal *)&U,r);
//vi->m[0]=NULL; ui->m[0]=NULL;
id_Delete(&vi,r);
id_Delete(&ui,r);
return p;
}
}
return NULL;
}
singclap_pmod
poly singclap_pmod(poly f, poly g, const ring r)
Definition clapsing.cc:732
ndConvSingNFactoryN
CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition numbers.cc:313
rField_is_Ring
#define rField_is_Ring(R)
Definition ring.h:491

## 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.

{
int k, j;
if (lcm==NULL) return FALSE;
for (j=(R->N); j; j--)
if ( p_GetExp(p,j, R) > p_GetExp(lcm,j, R)) return FALSE;
if ( pGetComp(p) != pGetComp(lcm)) return FALSE;
for (j=(R->N); j; j--)
{
if (p_GetExp(p1,j, R)!=p_GetExp(lcm,j, R))
{
if (p_GetExp(p,j, R)!=p_GetExp(lcm,j, R))
{
for (k=(R->N); k>j; k--)
{
if ((p_GetExp(p,k, R)!=p_GetExp(lcm,k, R))
&& (p_GetExp(p2,k, R)!=p_GetExp(lcm,k, R)))
return TRUE;
}
for (k=j-1; k; k--)
{
if ((p_GetExp(p,k, R)!=p_GetExp(lcm,k, R))
&& (p_GetExp(p2,k, R)!=p_GetExp(lcm,k, R)))
return TRUE;
}
return FALSE;
}
}
else if (p_GetExp(p2,j, R)!=p_GetExp(lcm,j, R))
{
if (p_GetExp(p,j, R)!=p_GetExp(lcm,j, R))
{
for (k=(R->N); k>j; k--)
{
if ((p_GetExp(p,k, R)!=p_GetExp(lcm,k, R))
&& (p_GetExp(p1,k, R)!=p_GetExp(lcm,k, R)))
return TRUE;
}
for (k=j-1; k!=0 ; k--)
{
if ((p_GetExp(p,k, R)!=p_GetExp(lcm,k, R))
&& (p_GetExp(p1,k, R)!=p_GetExp(lcm,k, R)))
return TRUE;
}
return FALSE;
}
}
}
return FALSE;
}
j
int j
Definition facHensel.cc:110
lcm
int lcm(unsigned long *l, unsigned long *a, unsigned long *b, unsigned long p, int dega, int degb)
Definition minpoly.cc:709

## pCompareChainPart()

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

Definition at line 71 of file kpolys.cc.

{
int k, j;
if (lcm==NULL) return FALSE;
for (j=R->real_var_end; j>=R->real_var_start; j--)
if ( p_GetExp(p,j, R) > p_GetExp(lcm,j, R)) return FALSE;
if ( pGetComp(p) != pGetComp(lcm)) return FALSE;
for (j=R->real_var_end; j>=R->real_var_start; j--)
{
if (p_GetExp(p1,j, R)!=p_GetExp(lcm,j, R))
{
if (p_GetExp(p,j, R)!=p_GetExp(lcm,j, R))
{
for (k=(R->N); k>j; k--)
for (k=R->real_var_end; k>j; k--)
{
if ((p_GetExp(p,k, R)!=p_GetExp(lcm,k, R))
&& (p_GetExp(p2,k, R)!=p_GetExp(lcm,k, R)))
return TRUE;
}
for (k=j-1; k>=R->real_var_start; k--)
{
if ((p_GetExp(p,k, R)!=p_GetExp(lcm,k, R))
&& (p_GetExp(p2,k, R)!=p_GetExp(lcm,k, R)))
return TRUE;
}
return FALSE;
}
}
else if (p_GetExp(p2,j, R)!=p_GetExp(lcm,j, R))
{
if (p_GetExp(p,j, R)!=p_GetExp(lcm,j, R))
{
for (k=R->real_var_end; k>j; k--)
{
if ((p_GetExp(p,k, R)!=p_GetExp(lcm,k, R))
&& (p_GetExp(p1,k, R)!=p_GetExp(lcm,k, R)))
return TRUE;
}
for (k=j-1; k>=R->real_var_start; k--)
{
if ((p_GetExp(p,k, R)!=p_GetExp(lcm,k, R))
&& (p_GetExp(p1,k, R)!=p_GetExp(lcm,k, R)))
return TRUE;
}
return FALSE;
}
}
}
return FALSE;
}

## pIsHomogeneous()

BOOLEAN pIsHomogeneous | ( | poly | p | ) |

## pLast() [1/2]

poly pLast | ( | poly | a | ) |

inline static

Definition at line 407 of file polys.h.

{ int l; return pLast(a, l); }
pLast
static poly pLast(poly a, int &length)
returns the length of a polynomial (numbers of monomials) respect syzComp
Definition polys.h:406

## pLast() [2/2]

poly pLast | ( | poly | a,
|  | int & | length )

inline static

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

Definition at line 406 of file polys.h.

{ return p_Last (a, length, currRing); }
length
static BOOLEAN length(leftv result, leftv arg)
Definition interval.cc:257
p_Last
poly p_Last(const poly p, int &l, const ring r)
Definition p_polys.cc:4775

## pLmFree() [1/2]

void pLmFree | ( | poly * | p | ) |

inline static

like pLmFree, but advances p

Definition at line 73 of file polys.h.

{p_LmFree(p, currRing);}
p_LmFree
static void p_LmFree(poly p, ring)
Definition p_polys.h:685

## pLmFree() [2/2]

void pLmFree | ( | poly | p | ) |

inline static

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

Definition at line 71 of file polys.h.

{p_LmFree(p, currRing);}

## pNorm()

void pNorm | ( | poly | p | ) |

inline

Definition at line 363 of file polys.h.

{ p_Norm(p, currRing); }
p_Norm
void p_Norm(poly p1, const ring r)
Definition p_polys.cc:3844

## 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 178 of file polys.cc.

{
if (q==NULL)
{
WerrorS("div. by 0");
return NULL;
}
if (p==NULL)
{
return NULL;
}
if ((pNext(q)!=NULL)||rIsPluralRing(r))
{ /* This means that q != 0 consists of at least two terms*/
if(p_GetComp(p,r)==0)
{
if (!rIsNCRing(r))
{
if ((rFieldType(r)==n_Q)
||(rFieldType(r)==n_Zp)
||(rFieldType(r)==n_algExt))
{
poly res=singclap_pdivide(p, q, r);
return res;
}
if((rFieldType(r)==n_transExt)
&&(convSingTrP(p,r))
&&(convSingTrP(q,r)))
{
poly res=singclap_pdivide(p, q, r);
return res;
}
}
// generic division for poly
{
ideal vi=idInit(1,1); vi->m[0]=p_Copy(q,r);
ideal ui=idInit(1,1); ui->m[0]=p_Copy(p,r);
ideal R; matrix U;
ring save_ring=currRing;
if (r!=currRing) rChangeCurrRing(r);
BITSET save_opt;
SI_SAVE_OPT1(save_opt);
si_opt_1 &= ~(Sy_bit(OPT_PROT));
ideal m = idLift(vi,ui,&R, FALSE,TRUE,TRUE,&U);
SI_RESTORE_OPT1(save_opt);
if (r!=save_ring) rChangeCurrRing(save_ring);
matrix T = id_Module2formatedMatrix(m,1,1,r);
p=MATELEM(T,1,1); MATELEM(T,1,1)=NULL;
id_Delete((ideal *)&T,r);
id_Delete((ideal *)&U,r);
id_Delete(&R,r);
//vi->m[0]=NULL; ui->m[0]=NULL;
id_Delete(&vi,r);
id_Delete(&ui,r);
return p;
}
}
else
{
p=p_Copy(p,r);
int comps=p_MaxComp(p,r);
ideal I=idInit(comps,1);
poly h;
int i;
// conversion to a list of polys:
while (p!=NULL)
{
i=p_GetComp(p,r)-1;
h=pNext(p);
pNext(p)=NULL;
p_SetComp(p,0,r);
I->m[i]=p_Add_q(I->m[i],p,r);
p=h;
}
// division and conversion to vector:
h=NULL;
p=NULL;
q=p_Copy(q,r);
for(i=comps-1;i>=0;i--)
{
if (I->m[i]!=NULL)
{
if(!rIsNCRing(r))
{
if((rFieldType(r)==n_transExt)
&&(convSingTrP(I->m[i],r))
&&(convSingTrP(q,r)))
{
h=singclap_pdivide(I->m[i],q,r);
}
else if ((rFieldType(r)==n_Q)
||(rFieldType(r)==n_Zp))
h=singclap_pdivide(I->m[i],q,r);
else
{
ideal vi=idInit(1,1); vi->m[0]=q;
ideal ui=idInit(1,1); ui->m[0]=I->m[i];
ideal R; matrix U;
ring save_ring=currRing;
if (r!=currRing) rChangeCurrRing(r);
BITSET save_opt;
SI_SAVE_OPT1(save_opt);
si_opt_1 &= ~(Sy_bit(OPT_PROT));
ideal m = idLift(vi,ui,&R, FALSE,TRUE,TRUE,&U);
SI_RESTORE_OPT1(save_opt);
if (r!=save_ring) rChangeCurrRing(save_ring);
if (idIs0(R))
{
matrix T = id_Module2formatedMatrix(m,1,1,r);
p=MATELEM(T,1,1); MATELEM(T,1,1)=NULL;
id_Delete((ideal *)&T,r);
}
id_Delete((ideal*)&U,r);
id_Delete(&R,r);
vi->m[0]=NULL; ui->m[0]=NULL;
id_Delete(&vi,r);
id_Delete(&ui,r);
}
}
else
{
ideal vi=idInit(1,1); vi->m[0]=q;
ideal ui=idInit(1,1); ui->m[0]=I->m[i];
ideal R; matrix U;
ring save_ring=currRing;
if (r!=currRing) rChangeCurrRing(r);
BITSET save_opt;
SI_SAVE_OPT1(save_opt);
si_opt_1 &= ~(Sy_bit(OPT_PROT));
ideal m = idLift(vi,ui,&R, FALSE,TRUE,TRUE,&U);
SI_RESTORE_OPT1(save_opt);
if (r!=save_ring) rChangeCurrRing(save_ring);
if (idIs0(R))
{
matrix T = id_Module2formatedMatrix(m,1,1,r);
p=MATELEM(T,1,1); MATELEM(T,1,1)=NULL;
id_Delete((ideal *)&T,r);
}
id_Delete((ideal*)&U,r);
id_Delete(&R,r);
vi->m[0]=NULL; ui->m[0]=NULL;
id_Delete(&vi,r);
id_Delete(&ui,r);
}
p_SetCompP(h,i+1,r);
p=p_Add_q(p,h,r);
}
}
id_Delete(&I,r);
p_Delete(&q,r);
return p;
}
}
else
{ /* This means that q != 0 consists of just one term,
or that r is over a coefficient ring. */
if (pNext(q)!=NULL)
{
WerrorS("division over a coefficient domain only implemented for terms");
return NULL;
}
return pp_DivideM(p,q,r);
}
return NULL;
}
pp_DivideM
poly pp_DivideM(poly a, poly b, const ring r)
Definition p_polys.cc:1637

## pSetPolyComp()

void pSetPolyComp | ( | poly | p,
|  | int | comp )

## pString()

char * pString | ( | poly | p | ) |

inline

Definition at line 307 of file polys.h.

{return p_String(p, currRing, currRing);}
p_String
char * p_String(poly p, ring lmRing, ring tailRing)
Definition polys0.cc:322

## pString0()

void pString0 | ( | poly | p | ) |

inline

Definition at line 308 of file polys.h.

{p_String0(p, currRing, currRing);}
p_String0
void p_String0(poly p, ring lmRing, ring tailRing)
print p according to ShortOut in lmRing & tailRing
Definition polys0.cc:223

## 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 346 of file polys.h.

{
return p_TakeOutComp(p, k, R);
}
p_TakeOutComp
void p_TakeOutComp(poly *p, long comp, poly *q, int *lq, const ring r)
Definition p_polys.cc:3620

## 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 339 of file polys.h.

{
return p_TakeOutComp(p, comp, q, lq, R);
}
comp
int comp(const CanonicalForm &A, const CanonicalForm &B)
compare polynomials
Definition facSparseHensel.h:25
lq
Definition lq.h:40

## pTotaldegree()

long pTotaldegree | ( | poly | p | ) |

inline static

Definition at line 283 of file polys.h.

{ return p_Totaldegree(p,currRing); }
p_Totaldegree
static long p_Totaldegree(poly p, const ring r)
Definition p_polys.h:1528

## pWrite()

void pWrite | ( | poly | p | ) |

inline

Definition at line 309 of file polys.h.

{p_Write(p, currRing, currRing);}
p_Write
void p_Write(poly p, ring lmRing, ring tailRing)
Definition polys0.cc:342

## pWrite0()

void pWrite0 | ( | poly | p | ) |

inline

Definition at line 310 of file polys.h.

{p_Write0(p, currRing, currRing);}
p_Write0
void p_Write0(poly p, ring lmRing, ring tailRing)
Definition polys0.cc:332

## rChangeCurrRing()

void rChangeCurrRing | ( | ring | r | ) |

Definition at line 16 of file polys.cc.

{
if (currRing!=NULL)
currRing->options = si_opt_1 & TEST_RINGDEP_OPTS;
//------------ set global ring vars --------------------------------
currRing = r;
if( r != NULL )
{
rTest(r);
//------------ global variables related to coefficients ------------
assume( r->cf!= NULL );
nSetChar(r->cf);
//------------ global variables related to polys
p_SetGlobals(r); // also setting TEST_RINGDEP_OPTS
//------------ global variables related to factory -----------------
}
}
nSetChar
static FORCE_INLINE void nSetChar(const coeffs r)
initialisations after each ring change
Definition coeffs.h:446
TEST_RINGDEP_OPTS
#define TEST_RINGDEP_OPTS
Definition options.h:101
p_SetGlobals
void p_SetGlobals(const ring r, BOOLEAN complete)
set all properties of a new ring - also called by rComplete
Definition ring.cc:3494
rTest
#define rTest(r)
Definition ring.h:794

## 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 409 of file polys.cc.

{
poly res=NULL;
if (f!=NULL)
{
//if (r->cf->has_simple_Inverse) p_Norm(f,r);
if (rField_is_Zp(r)) p_Norm(f,r);
else if (!rField_is_Ring(r)) p_Cleardenom(f, r);
}
if (g!=NULL)
{
//if (r->cf->has_simple_Inverse) p_Norm(g,r);
if (rField_is_Zp(r)) p_Norm(g,r);
else if (!rField_is_Ring(r)) p_Cleardenom(g, r);
}
else return f; // g==0 => gcd=f (but do a p_Cleardenom/pNorm)
if (f==NULL) return g; // f==0 => gcd=g (but do a p_Cleardenom/pNorm)
if(!rField_is_Ring(r)
&& (p_IsConstant(f,r)
||p_IsConstant(g,r)))
{
res=p_One(r);
}
else if (r->cf->convSingNFactoryN!=ndConvSingNFactoryN)
{
res=singclap_gcd_r(f,g,r);
}
else
{
ideal I=idInit(2,1);
I->m[0]=f;
I->m[1]=p_Copy(g,r);
intvec *w=NULL;
ring save_ring=currRing;
if (r!=currRing) rChangeCurrRing(r);
BITSET save_opt;
SI_SAVE_OPT1(save_opt);
si_opt_1 &= ~(Sy_bit(OPT_PROT));
ideal S1=idSyzygies(I,testHomog,&w);
if (w!=NULL) delete w;
// expect S1->m[0]=(-g/gcd,f/gcd)
if (IDELEMS(S1)!=1) WarnS("error in syzygy computation for GCD");
int lp;
p_TakeOutComp(&S1->m[0],1,&res,&lp,r);
p_Delete(&S1->m[0],r);
// GCD is g divided iby (-g/gcd):
res=p_Divide(g,res,r);
// restore, r, opt:
SI_RESTORE_OPT1(save_opt);
if (r!=save_ring) rChangeCurrRing(save_ring);
// clean the result
res=p_Cleardenom(res,r);
if (nCoeff_is_Ring(r->cf)) p_Content(res,r);
return res;
}
p_Delete(&f, r);
p_Delete(&g, r);
return res;
}
singclap_gcd_r
poly singclap_gcd_r(poly f, poly g, const ring r)
Definition clapsing.cc:70
intvec
Definition intvec.h:24
nCoeff_is_Ring
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
Definition coeffs.h:732
WarnS
#define WarnS
Definition emacs.cc:78
idSyzygies
ideal idSyzygies(ideal h1, tHomog h, intvec **w, BOOLEAN setSyzComp, BOOLEAN setRegularity, int *deg, GbVariant alg)
Definition ideals.cc:836
p_Content
void p_Content(poly ph, const ring r)
Definition p_polys.cc:2343
p_Cleardenom
poly p_Cleardenom(poly p, const ring r)
Definition p_polys.cc:2893
p_Divide
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:34
rField_is_Zp
static BOOLEAN rField_is_Zp(const ring r)
Definition ring.h:506
IDELEMS
#define IDELEMS(i)
Definition simpleideals.h:23
testHomog
@ testHomog
Definition structs.h:34

## wrp()

void wrp | ( | poly | p | ) |

inline

Definition at line 311 of file polys.h.

{p_wrp(p, currRing, currRing);}
p_wrp
void p_wrp(poly p, ring lmRing, ring tailRing)
Definition polys0.cc:373

## Variable Documentation

## coeffs_BIGINT

EXTERN_VAR coeffs coeffs_BIGINT

Definition at line 19 of file polys.h.

## currRing

EXTERN_VAR ring currRing

Definition at line 18 of file polys.h.