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