My Project
Loading...
Searching...
No Matches
polys.h File Reference

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

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:

Definition in file polys.h.

Macro Definition Documentation

◆ pAdd

#define pAdd ( p,
q )
Value:
int p
Definition cfModGcd.cc:4086
static poly p_Add_q(poly p, poly q, const ring r)
Definition p_polys.h:938
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:
int i
Definition cfEzgcd.cc:132
const Variable & v
< [in] a sqrfree bivariate poly
Definition facBivar.h:39
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)
static int p_Cmp(poly p1, poly p2, ring r)
Definition p_polys.h:1743

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:
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:
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:
const CanonicalForm & w
Definition facAbsFact.cc:51
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:
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:
int k
Definition cfEzgcd.cc:99
void p_DeleteComp(poly *p, int k, const ring r)
Definition p_polys.cc:3623

Definition at line 361 of file polys.h.

◆ pDiff

#define pDiff ( a,
b )
Value:
CanonicalForm b
Definition cfModGcd.cc:4111
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:
int m
Definition cfEzgcd.cc:128
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:
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:
static BOOLEAN p_DivisibleBy(poly a, poly b, const ring r)
Definition p_polys.h:1916

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:
g
Definition cfModGcd.cc:4098
FILE * f
Definition checklibs.c:9
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:
BOOLEAN p_EqualPolys(poly p1, poly p2, const ring r)
Definition p_polys.cc:4621

Definition at line 400 of file polys.h.

◆ pExpVectorAdd

#define pExpVectorAdd ( p1,
p2 )
Value:
static void p_ExpVectorAdd(poly p1, poly p2, const ring r)
Definition p_polys.h:1427

Definition at line 88 of file polys.h.

◆ pExpVectorAddSub

#define pExpVectorAddSub ( p1,
p2,
p3 )
Value:
static void p_ExpVectorAddSub(poly p1, poly p2, poly p3, const ring r)
Definition p_polys.h:1472

Definition at line 90 of file polys.h.

◆ pExpVectorCopy

#define pExpVectorCopy ( d_p,
s_p )
Value:
static void p_ExpVectorCopy(poly d_p, poly s_p, const ring r)
Definition p_polys.h:1329

Definition at line 87 of file polys.h.

◆ pExpVectorDiff

#define pExpVectorDiff ( pr,
p1,
p2 )
Value:
static void p_ExpVectorDiff(poly pr, poly p1, poly p2, const ring r)
Definition p_polys.h:1490

Definition at line 92 of file polys.h.

◆ pExpVectorSub

#define pExpVectorSub ( p1,
p2 )
Value:
static void p_ExpVectorSub(poly p1, poly p2, const ring r)
Definition p_polys.h:1456

Definition at line 89 of file polys.h.

◆ pExpVectorSum

#define pExpVectorSum ( pr,
p1,
p2 )
Value:
static void p_ExpVectorSum(poly pr, poly p1, poly p2, const ring r)
Definition p_polys.h:1441

Definition at line 91 of file polys.h.

◆ pGetComp

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

Component.

Definition at line 38 of file polys.h.

◆ pGetExp

#define pGetExp ( p,
i )
Value:
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:
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:
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:
static void p_GetExpV(poly p, int *ev, const ring r)
Definition p_polys.h:1536

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:
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:
unsigned long p_GetShortExpVector(const poly p, const ring r)
Definition p_polys.cc:4889

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:
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:
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:
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:
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:
poly p_Homogen(poly p, int varnum, const ring r)
Definition p_polys.cc:3274

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:
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:
static poly p_Init(const ring r, omBin bin)
Definition p_polys.h:1336

allocates a new monomial and initializes everything to 0

Definition at line 62 of file polys.h.

◆ pIsConstant

#define pIsConstant ( p)
Value:
static BOOLEAN p_IsConstant(const poly p, const ring r)
Definition p_polys.h:1980

like above, except that Comp must be 0

Definition at line 239 of file polys.h.

◆ pIsConstantComp

#define pIsConstantComp ( p)
Value:
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:1974

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:
static BOOLEAN p_IsConstantPoly(const poly p, const ring r)
Definition p_polys.h:1994

return TRUE if all monomials of p are constant

Definition at line 247 of file polys.h.

◆ pISet

#define pISet ( i)
Value:
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:
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:
static BOOLEAN p_IsUnit(const poly p, const ring r)
Definition p_polys.h:2007

return true if the Lm is a constant <>0

Definition at line 241 of file polys.h.

◆ pIsUnivariate

#define pIsUnivariate ( p)
Value:
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)
#define pGetComp(p)
Component.
Definition polys.h:38

Definition at line 251 of file polys.h.

◆ pJet

#define pJet ( p,
m )
Value:
poly p_Jet(poly p, int m, const ring R)
Definition p_polys.cc:4495

Definition at line 368 of file polys.h.

◆ pJetW

#define pJetW ( p,
m,
iv )
Value:
poly p_JetW(poly p, int m, int *w, const ring R)
Definition p_polys.cc:4539

Definition at line 370 of file polys.h.

◆ pLcm

#define pLcm ( a,
b,
m )
Value:
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:
static int p_LmCmp(poly p, poly q, const ring r)
Definition p_polys.h:1596

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)
#define _p_LmCmpAction(p, q, r, actionE, actionG, actionS)
Definition p_polys.h:1292

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.

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

◆ pLmDelete

#define pLmDelete ( p)
Value:
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:
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:
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
Definition p_polys.h:1907

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:
static BOOLEAN p_LmDivisibleByNoComp(poly a, poly b, const ring r)
Definition p_polys.h:1893

like pLmDivisibleBy, does not check components

Definition at line 143 of file polys.h.

◆ pLmEqual

#define pLmEqual ( p1,
p2 )
Value:
static BOOLEAN p_ExpVectorEqual(poly p1, poly p2, const ring r1, const ring r2)
Definition p_polys.cc:4635

Definition at line 112 of file polys.h.

◆ pLmFreeAndNext

#define pLmFreeAndNext ( p)
Value:
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:
static poly p_LmInit(poly p, const ring r)
Definition p_polys.h:1351

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

149#define pLmRingShortDivisibleBy(a, sev_a, b, not_sev_b) \
150 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)
static BOOLEAN p_LmShortDivisibleBy(poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
Definition p_polys.h:1926

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

Definition at line 147 of file polys.h.

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

◆ pLmTest

#define pLmTest ( p)
Value:
#define PDEBUG
Definition auxiliary.h:171
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:
static int p_LtCmp(poly p, poly q, const ring r)
Definition p_polys.h:1637

Definition at line 124 of file polys.h.

◆ pLtCmpNoAbs

#define pLtCmpNoAbs ( p,
q )
Value:
static int p_LtCmpNoAbs(poly p, poly q, const ring r)
Definition p_polys.h:1663

Definition at line 125 of file polys.h.

◆ pLtCmpOrdSgnDiffM

#define pLtCmpOrdSgnDiffM ( p,
q )
Value:
static int p_LtCmpOrdSgnDiffM(poly p, poly q, const ring r)
Definition p_polys.h:1685

Definition at line 126 of file polys.h.

◆ pLtCmpOrdSgnDiffP

#define pLtCmpOrdSgnDiffP ( p,
q )
Value:
static int p_LtCmpOrdSgnDiffP(poly p, poly q, const ring r)
Definition p_polys.h:1694

Definition at line 127 of file polys.h.

◆ pLtCmpOrdSgnEqM

#define pLtCmpOrdSgnEqM ( p,
q )
Value:
static int p_LtCmpOrdSgnEqM(poly p, poly q, const ring r)
Definition p_polys.h:1710

Definition at line 128 of file polys.h.

◆ pLtCmpOrdSgnEqP

#define pLtCmpOrdSgnEqP ( p,
q )
Value:
static int p_LtCmpOrdSgnEqP(poly p, poly q, const ring r)
Definition p_polys.h:1719

Definition at line 129 of file polys.h.

◆ pMaxComp

#define pMaxComp ( p)
Value:
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:
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:
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:
int p_MinDeg(poly p, intvec *w, const ring R)
Definition p_polys.cc:4557

Definition at line 371 of file polys.h.

◆ pmInit

#define pmInit ( a,
b )
Value:
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:
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:1072

Definition at line 206 of file polys.h.

◆ pMult

#define pMult ( p,
q )
Value:
static poly p_Mult_q(poly p, poly q, const ring r)
Definition p_polys.h:1120

Definition at line 208 of file polys.h.

◆ pMult_mm

#define pMult_mm ( p,
m )
Value:
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:
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:
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:
static poly p_Neg(poly p, const ring r)
Definition p_polys.h:1109

Definition at line 199 of file polys.h.

◆ pNew

#define pNew ( )
Value:
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:
void p_Normalize(poly p, const ring r)
Definition p_polys.cc:3894

Definition at line 318 of file polys.h.

◆ pNSet

#define pNSet ( n)
Value:
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:
poly p_One(const ring r)
Definition p_polys.cc:1314

Definition at line 316 of file polys.h.

◆ pOneComp

#define pOneComp ( p)
Value:
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:
poly pp_Jet(poly p, int m, const ring R)
Definition p_polys.cc:4439

Definition at line 367 of file polys.h.

◆ ppJetW

#define ppJetW ( p,
m,
iv )
Value:
poly pp_JetW(poly p, int m, int *w, const ring R)
Definition p_polys.cc:4512

Definition at line 369 of file polys.h.

◆ pPlus_mm_Mult_qq

#define pPlus_mm_Mult_qq ( p,
m,
q )
Value:
static poly p_Plus_mm_Mult_qq(poly p, poly m, poly q, int &lp, int lq, const ring r)
Definition p_polys.h:1199

Definition at line 207 of file polys.h.

◆ ppMult_Coeff_mm_DivSelect

#define ppMult_Coeff_mm_DivSelect ( p,
m )
Value:
static poly pp_Mult_Coeff_mm_DivSelect(poly p, const poly m, const ring r)
Definition p_polys.h:1092

Definition at line 211 of file polys.h.

◆ ppMult_mm

#define ppMult_mm ( p,
m )
Value:
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:
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:
static poly pp_Mult_qq(poly p, poly q, const ring r)
Definition p_polys.h:1162

Definition at line 209 of file polys.h.

◆ pPower

#define pPower ( p,
q )
Value:
poly p_Power(poly p, int i, const ring r)
Definition p_polys.cc:2201

Definition at line 205 of file polys.h.

◆ pSeries

#define pSeries ( n,
p,
u,
w )
Value:
poly p_Series(int n, poly p, poly u, intvec *w, const ring R)
Definition p_polys.cc:4607

Definition at line 372 of file polys.h.

◆ pSetCoeff

#define pSetCoeff ( p,
n )
Value:
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:
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:
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:
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:
static void p_SetExpV(poly p, int *ev, const ring r)
Definition p_polys.h:1560

Definition at line 98 of file polys.h.

◆ pSetm

#define pSetm ( p)
Value:
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:

TODO:

Definition at line 274 of file polys.h.

◆ pSize

#define pSize ( p)
Value:
int p_Size(poly p, const ring r)
Definition p_polys.cc:3257

Definition at line 319 of file polys.h.

◆ pSort

#define pSort ( p)
Value:
static poly p_SortMerge(poly p, const ring r, BOOLEAN revert=FALSE)
Definition p_polys.h:1245

Definition at line 219 of file polys.h.

◆ pSortAdd

#define pSortAdd ( p)
Value:
static poly p_SortAdd(poly p, const ring r, BOOLEAN revert=FALSE)
Definition p_polys.h:1235

sorts p, p may have equal monomials

Definition at line 222 of file polys.h.

◆ pSortCompCorrect

#define pSortCompCorrect ( p)
Value:
#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:

sorts p, assumes all monomials in p are different

Definition at line 218 of file polys.h.

◆ pSplit

#define pSplit ( p,
r )
Value:
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:
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:
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:
poly p_Subst(poly p, int n, poly e, const ring r)
Definition p_polys.cc:4039

Definition at line 366 of file polys.h.

◆ pTest

#define pTest ( p)
Value:
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:
int p_Var(poly m, const ring r)
Definition p_polys.cc:4765

Definition at line 381 of file polys.h.

◆ pVectorHasUnit

#define pVectorHasUnit ( p,
k,
l )
Value:
int l
Definition cfEzgcd.cc:100
void p_VectorHasUnit(poly p, int *k, int *len, const ring r)
Definition p_polys.cc:3465

Definition at line 334 of file polys.h.

◆ pVectorHasUnitB

#define pVectorHasUnitB ( p,
k )
Value:
BOOLEAN p_VectorHasUnitB(poly p, int *k, const ring r)
Definition p_polys.cc:3442

Definition at line 333 of file polys.h.

◆ pWDegree

#define pWDegree ( p)
Value:
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:
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:
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.

35{
36 assume(q!=NULL);
37 if (q==NULL)
38 {
39 WerrorS("div. by 0");
40 return NULL;
41 }
42 if (p==NULL)
43 {
44 p_Delete(&q,r);
45 return NULL;
46 }
47 if ((pNext(q)!=NULL)||rIsPluralRing(r))
48 { /* This means that q != 0 consists of at least two terms*/
49 if(p_GetComp(p,r)==0)
50 {
51 if((rFieldType(r)==n_transExt)
52 &&(convSingTrP(p,r))
53 &&(convSingTrP(q,r))
54 &&(!rIsNCRing(r)))
55 {
56 poly res=singclap_pdivide(p, q, r);
57 p_Delete(&p,r);
58 p_Delete(&q,r);
59 return res;
60 }
61 else if ((r->cf->convSingNFactoryN!=ndConvSingNFactoryN)
62 &&(!rField_is_Ring(r))
63 &&(!rIsNCRing(r)))
64 {
65 poly res=singclap_pdivide(p, q, r);
66 p_Delete(&p,r);
67 p_Delete(&q,r);
68 return res;
69 }
70 else
71 {
72 ideal vi=idInit(1,1); vi->m[0]=q;
73 ideal ui=idInit(1,1); ui->m[0]=p;
74 ideal R; matrix U;
75 ring save_ring=currRing;
76 if (r!=currRing) rChangeCurrRing(r);
77 BITSET save_opt;
78 SI_SAVE_OPT1(save_opt);
80 ideal m = idLift(vi,ui,&R, FALSE,TRUE,TRUE,&U);
81 SI_RESTORE_OPT1(save_opt);
82 if (r!=save_ring) rChangeCurrRing(save_ring);
83 p=m->m[0]; m->m[0]=NULL;
84 id_Delete(&m,r);
85 p_SetCompP(p,0,r);
86 id_Delete((ideal *)&U,r);
87 id_Delete(&R,r);
88 //vi->m[0]=NULL; ui->m[0]=NULL;
89 id_Delete(&vi,r);
90 id_Delete(&ui,r);
91 return p;
92 }
93 }
94 else
95 {
96 int comps=p_MaxComp(p,r);
97 ideal I=idInit(comps,1);
98 poly h;
99 int i;
100 // conversion to a list of polys:
101 while (p!=NULL)
102 {
103 i=p_GetComp(p,r)-1;
104 h=pNext(p);
105 pNext(p)=NULL;
106 p_SetComp(p,0,r);
107 I->m[i]=p_Add_q(I->m[i],p,r);
108 p=h;
109 }
110 // division and conversion to vector:
111 h=NULL;
112 p=NULL;
113 for(i=comps-1;i>=0;i--)
114 {
115 if (I->m[i]!=NULL)
116 {
117 if((rFieldType(r)==n_transExt)
118 &&(convSingTrP(I->m[i],r))
119 &&(convSingTrP(q,r))
120 &&(!rIsNCRing(r)))
121 {
122 h=singclap_pdivide(I->m[i],q,r);
123 }
124 else if ((r->cf->convSingNFactoryN!=ndConvSingNFactoryN)
125 &&(!rField_is_Ring(r))
126 &&(!rIsNCRing(r)))
127 h=singclap_pdivide(I->m[i],q,r);
128 else
129 {
130 ideal vi=idInit(1,1); vi->m[0]=q;
131 ideal ui=idInit(1,1); ui->m[0]=I->m[i];
132 ideal R; matrix U;
133 ring save_ring=currRing;
134 if (r!=currRing) rChangeCurrRing(r);
135 BITSET save_opt;
136 SI_SAVE_OPT1(save_opt);
137 si_opt_1 &= ~(Sy_bit(OPT_PROT));
138 ideal m = idLift(vi,ui,&R, FALSE,TRUE,TRUE,&U);
139 SI_RESTORE_OPT1(save_opt);
140 if (r!=save_ring) rChangeCurrRing(save_ring);
141 if (idIs0(R))
142 {
144 p=MATELEM(T,1,1); MATELEM(T,1,1)=NULL;
145 id_Delete((ideal *)&T,r);
146 }
147 else p=NULL;
148 id_Delete((ideal*)&U,r);
149 id_Delete(&R,r);
150 vi->m[0]=NULL; ui->m[0]=NULL;
151 id_Delete(&vi,r);
152 id_Delete(&ui,r);
153 }
154 p_SetCompP(h,i+1,r);
155 p=p_Add_q(p,h,r);
156 }
157 }
158 id_Delete(&I,r);
159 p_Delete(&q,r);
160 return p;
161 }
162 }
163 else
164 { /* This means that q != 0 consists of just one term, or LetterPlace */
165#ifdef HAVE_RINGS
166 if (pNext(q)!=NULL)
167 {
168 WerrorS("division over a coefficient domain only implemented for terms");
169 return NULL;
170 }
171#endif
172 return p_DivideM(p,q,r);
173 }
174 return NULL;
175}
#define BITSET
Definition auxiliary.h:85
#define TRUE
Definition auxiliary.h:101
#define FALSE
Definition auxiliary.h:97
BOOLEAN convSingTrP(poly p, const ring r)
Definition clapconv.cc:375
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:1111
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
ip_smatrix * matrix
Definition matpol.h:43
#define assume(x)
Definition mod2.h:389
#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:307
#define NULL
Definition omList.c:12
VAR unsigned si_opt_1
Definition options.c:5
#define OPT_PROT
Definition options.h:76
#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
void rChangeCurrRing(ring r)
Definition polys.cc:16
static n_coeffType rFieldType(const ring r)
the type of the coefficient filed of r (n_Zp, n_Q, etc)
Definition ring.h:562
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition ring.h:406
static BOOLEAN rIsNCRing(const ring r)
Definition ring.h:427
#define rField_is_Ring(R)
Definition ring.h:491
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)
#define R
Definition sirandom.c:27

◆ p_DivRem()

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

Definition at line 317 of file polys.cc.

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

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

407{ int l; return pLast(a, l); }
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]

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

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

Definition at line 406 of file polys.h.

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

◆ pLmFree() [1/2]

static void pLmFree ( poly * p)
inlinestatic

like pLmFree, but advances p

Definition at line 73 of file polys.h.

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

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

◆ pNorm()

void pNorm ( poly p)
inline

Definition at line 363 of file polys.h.

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

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

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

307{return p_String(p, currRing, currRing);}
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.

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.

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

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

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

◆ pTotaldegree()

static long pTotaldegree ( poly p)
inlinestatic

Definition at line 283 of file polys.h.

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

◆ pWrite()

void pWrite ( poly p)
inline

Definition at line 309 of file polys.h.

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.

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.

17{
18 if (currRing!=NULL)
20 //------------ set global ring vars --------------------------------
21 currRing = r;
22 if( r != NULL )
23 {
24 rTest(r);
25 //------------ global variables related to coefficients ------------
26 assume( r->cf!= NULL );
27 nSetChar(r->cf);
28 //------------ global variables related to polys
29 p_SetGlobals(r); // also setting TEST_RINGDEP_OPTS
30 //------------ global variables related to factory -----------------
31 }
32}
static FORCE_INLINE void nSetChar(const coeffs r)
initialisations after each ring change
Definition coeffs.h:444
#define TEST_RINGDEP_OPTS
Definition options.h:101
void p_SetGlobals(const ring r, BOOLEAN complete)
set all properties of a new ring - also called by rComplete
Definition ring.cc:3493
#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 383 of file polys.cc.

384{
385 poly res=NULL;
386
387 if (f!=NULL)
388 {
389 //if (r->cf->has_simple_Inverse) p_Norm(f,r);
390 if (rField_is_Zp(r)) p_Norm(f,r);
391 else if (!rField_is_Ring(r)) p_Cleardenom(f, r);
392 }
393 if (g!=NULL)
394 {
395 //if (r->cf->has_simple_Inverse) p_Norm(g,r);
396 if (rField_is_Zp(r)) p_Norm(g,r);
397 else if (!rField_is_Ring(r)) p_Cleardenom(g, r);
398 }
399 else return f; // g==0 => gcd=f (but do a p_Cleardenom/pNorm)
400 if (f==NULL) return g; // f==0 => gcd=g (but do a p_Cleardenom/pNorm)
401 if(!rField_is_Ring(r)
402 && (p_IsConstant(f,r)
403 ||p_IsConstant(g,r)))
404 {
405 res=p_One(r);
406 }
407 else if (r->cf->convSingNFactoryN!=ndConvSingNFactoryN)
408 {
410 }
411 else
412 {
413 ideal I=idInit(2,1);
414 I->m[0]=f;
415 I->m[1]=p_Copy(g,r);
416 intvec *w=NULL;
417 ring save_ring=currRing;
418 if (r!=currRing) rChangeCurrRing(r);
419 BITSET save_opt;
420 SI_SAVE_OPT1(save_opt);
421 si_opt_1 &= ~(Sy_bit(OPT_PROT));
422 ideal S1=idSyzygies(I,testHomog,&w);
423 if (w!=NULL) delete w;
424 // expect S1->m[0]=(-g/gcd,f/gcd)
425 if (IDELEMS(S1)!=1) WarnS("error in syzygy computation for GCD");
426 int lp;
427 p_TakeOutComp(&S1->m[0],1,&res,&lp,r);
428 p_Delete(&S1->m[0],r);
429 // GCD is g divided iby (-g/gcd):
430 res=p_Divide(g,res,r);
431 // restore, r, opt:
432 SI_RESTORE_OPT1(save_opt);
433 if (r!=save_ring) rChangeCurrRing(save_ring);
434 // clean the result
436 if (nCoeff_is_Ring(r->cf)) p_Content(res,r);
437 return res;
438 }
439 p_Delete(&f, r);
440 p_Delete(&g, r);
441 return res;
442}
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:730
#define WarnS
Definition emacs.cc:78
ideal idSyzygies(ideal h1, tHomog h, intvec **w, BOOLEAN setSyzComp, BOOLEAN setRegularity, int *deg, GbVariant alg)
Definition ideals.cc:836
void p_Content(poly ph, const ring r)
Definition p_polys.cc:2299
poly p_Cleardenom(poly p, const ring r)
Definition p_polys.cc:2849
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
static BOOLEAN rField_is_Zp(const ring r)
Definition ring.h:506
#define IDELEMS(i)
@ testHomog
Definition structs.h:34

◆ wrp()

void wrp ( poly p)
inline

Definition at line 311 of file polys.h.

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.