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

Go to the source code of this file.

Macros

#define pIfThen(cond, check)
 
#define p_Test(p, r)
 
#define p_LmTest(p, r)
 
#define pp_Test(p, lmRing, tailRing)
 
#define p_SetmComp   p_Setm
 
#define __p_Mult_nn(p, n, r)
 
#define __pp_Mult_nn(p, n, r)
 
#define _p_LmCmpAction(p, q, r, actionE, actionG, actionS)
 
#define pDivAssume(x)
 
#define p_LmCmpAction(p, q, r, actionE, actionG, actionS)
 
#define p_LmEqual(p1, p2, r)
 

Functions

poly p_Farey (poly p, number N, const ring r)
 
poly p_ChineseRemainder (poly *xx, number *x, number *q, int rl, CFArray &inv_cache, const ring R)
 
unsigned long p_GetShortExpVector (const poly a, const ring r)
 
unsigned long p_GetShortExpVector0 (const poly a, const ring r)
 
unsigned long p_GetShortExpVector1 (const poly a, const ring r)
 
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), i.e., LT(f)*c*m = LT(g), for some coefficient c and some monomial m; does not take components into account
 
poly p_One (const ring r)
 
int p_MinDeg (poly p, intvec *w, const ring R)
 
long p_DegW (poly p, const int *w, const ring R)
 
BOOLEAN p_OneComp (poly p, const ring r)
 return TRUE if all monoms have the same component
 
int p_IsPurePower (const poly p, const ring r)
 return i, if head depends only on var(i)
 
int p_IsUnivariate (poly p, const ring r)
 return i, if poly depends only on var(i)
 
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)
 
poly p_ISet (long i, const ring r)
 returns the poly representing the integer i
 
poly p_NSet (number n, const ring r)
 returns the poly representing the number n, destroys n
 
void p_Vec2Polys (poly v, poly **p, int *len, const ring r)
 
poly p_Vec2Poly (poly v, int k, const ring r)
 
void p_Vec2Array (poly v, poly *p, int len, const ring r)
 julia: vector to already allocated array (len=p_MaxComp(v,r))
 
void p_ShallowDelete (poly *p, const ring r)
 
poly p_Sub (poly a, poly b, const ring r)
 
poly p_Power (poly p, int i, const ring r)
 
BOOLEAN pIsMonomOf (poly p, poly m)
 
BOOLEAN pHaveCommonMonoms (poly p, poly q)
 
BOOLEAN p_LmCheckIsFromRing (poly p, ring r)
 
BOOLEAN p_LmCheckPolyRing (poly p, ring r)
 
BOOLEAN p_CheckIsFromRing (poly p, ring r)
 
BOOLEAN p_CheckPolyRing (poly p, ring r)
 
BOOLEAN p_CheckRing (ring r)
 
BOOLEAN _p_Test (poly p, ring r, int level)
 
BOOLEAN _p_LmTest (poly p, ring r, int level)
 
BOOLEAN _pp_Test (poly p, ring lmRing, ring tailRing, int level)
 
static int pLength (poly a)
 
poly p_Last (const poly a, int &l, const ring r)
 
void p_Norm (poly p1, const ring r)
 
void p_Normalize (poly p, const ring r)
 
void p_ProjectiveUnique (poly p, const ring r)
 
void p_ContentForGB (poly p, const ring r)
 
void p_Content (poly p, const ring r)
 
void p_SimpleContent (poly p, int s, const ring r)
 
number p_InitContent (poly ph, const ring r)
 
poly p_Cleardenom (poly p, const ring r)
 
void p_Cleardenom_n (poly p, const ring r, number &c)
 
int p_Size (poly p, const ring r)
 
poly p_Homogen (poly p, int varnum, const ring r)
 
poly p_HomogenDP (poly p, int varnum, const ring r)
 
BOOLEAN p_IsHomogeneous (poly p, const ring r)
 
BOOLEAN p_IsHomogeneousDP (poly p, const ring r)
 
BOOLEAN p_IsHomogeneousW (poly p, const intvec *w, const ring r)
 
BOOLEAN p_IsHomogeneousW (poly p, const intvec *w, const intvec *module_w, const ring r)
 
static void p_Setm (poly p, const ring r)
 
p_SetmProc p_GetSetmProc (const ring r)
 
poly p_Subst (poly p, int n, poly e, const ring r)
 
static unsigned long p_SetComp (poly p, unsigned long c, ring r)
 
static void p_SetCompP (poly p, int i, ring r)
 
static void p_SetCompP (poly p, int i, ring lmRing, ring tailRing)
 
static long p_MaxComp (poly p, ring lmRing, ring tailRing)
 
static long p_MaxComp (poly p, ring lmRing)
 
static long p_MinComp (poly p, ring lmRing, ring tailRing)
 
static long p_MinComp (poly p, ring lmRing)
 
static poly pReverse (poly p)
 
void pEnlargeSet (poly **p, int length, int increment)
 
void p_String0 (poly p, ring lmRing, ring tailRing)
 print p according to ShortOut in lmRing & tailRing
 
char * p_String (poly p, ring lmRing, ring tailRing)
 
void p_Write (poly p, ring lmRing, ring tailRing)
 
void p_Write0 (poly p, ring lmRing, ring tailRing)
 
void p_wrp (poly p, ring lmRing, ring tailRing)
 
void p_String0Short (const poly p, ring lmRing, ring tailRing)
 print p in a short way, if possible
 
void p_String0Long (const poly p, ring lmRing, ring tailRing)
 print p in a long way
 
static long p_FDeg (const poly p, const ring r)
 
static long p_LDeg (const poly p, int *l, const ring r)
 
long p_WFirstTotalDegree (poly p, ring r)
 
long p_WTotaldegree (poly p, const ring r)
 
long p_WDegree (poly p, const ring r)
 
long pLDeg0 (poly p, int *l, ring r)
 
long pLDeg0c (poly p, int *l, ring r)
 
long pLDegb (poly p, int *l, ring r)
 
long pLDeg1 (poly p, int *l, ring r)
 
long pLDeg1c (poly p, int *l, ring r)
 
long pLDeg1_Deg (poly p, int *l, ring r)
 
long pLDeg1c_Deg (poly p, int *l, ring r)
 
long pLDeg1_Totaldegree (poly p, int *l, ring r)
 
long pLDeg1c_Totaldegree (poly p, int *l, ring r)
 
long pLDeg1_WFirstTotalDegree (poly p, int *l, ring r)
 
long pLDeg1c_WFirstTotalDegree (poly p, int *l, ring r)
 
BOOLEAN p_EqualPolys (poly p1, poly p2, const ring r)
 
BOOLEAN p_EqualPolys (poly p1, poly p2, const ring r1, const ring r2)
 same as the usual p_EqualPolys for polys belonging to equal rings
 
long p_Deg (poly a, const ring r)
 
static number p_SetCoeff (poly p, number n, ring r)
 
static long p_GetOrder (poly p, ring r)
 
static unsigned long p_AddComp (poly p, unsigned long v, ring r)
 
static unsigned long p_SubComp (poly p, unsigned long v, ring r)
 
static long p_GetExp (const poly p, const unsigned long iBitmask, const int VarOffset)
 get a single variable exponent @Note: the integer VarOffset encodes:
 
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
 
static long p_GetExp (const poly p, const ring r, const int VarOffset)
 
static long p_SetExp (poly p, const long e, const ring r, const int VarOffset)
 
static long p_GetExp (const poly p, const int v, const ring r)
 get v^th exponent for a monomial
 
static long p_SetExp (poly p, const int v, const long e, const ring r)
 set v^th exponent for a monomial
 
static long p_IncrExp (poly p, int v, ring r)
 
static long p_DecrExp (poly p, int v, ring r)
 
static long p_AddExp (poly p, int v, long ee, ring r)
 
static long p_SubExp (poly p, int v, long ee, ring r)
 
static long p_MultExp (poly p, int v, long ee, ring r)
 
static long p_GetExpSum (poly p1, poly p2, int i, ring r)
 
static long p_GetExpDiff (poly p1, poly p2, int i, ring r)
 
static int p_Comp_k_n (poly a, poly b, int k, ring r)
 
static poly p_New (const ring, omBin bin)
 
static poly p_New (ring r)
 
static void p_LmFree (poly p, ring)
 
static void p_LmFree (poly *p, ring)
 
static poly p_LmFreeAndNext (poly p, ring)
 
static void p_LmDelete (poly p, const ring r)
 
static void p_LmDelete0 (poly p, const ring r)
 
static void p_LmDelete (poly *p, const ring r)
 
static poly p_LmDeleteAndNext (poly p, const ring r)
 
unsigned long p_GetMaxExpL (poly p, const ring r, unsigned long l_max=0)
 return the maximal exponent of p in form of the maximal long var
 
poly p_GetMaxExpP (poly p, ring r)
 return monomial r such that GetExp(r,i) is maximum of all monomials in p; coeff == 0, next == NULL, ord is not set
 
static unsigned long p_GetMaxExp (const unsigned long l, const ring r)
 
static unsigned long p_GetMaxExp (const poly p, const ring r)
 
static unsigned long p_GetTotalDegree (const unsigned long l, const ring r, const int number_of_exps)
 
static poly p_Copy_noCheck (poly p, const ring r)
 returns a copy of p (without any additional testing)
 
static poly p_Copy (poly p, const ring r)
 returns a copy of p
 
static poly p_Head (const poly p, const ring r)
 copy the (leading) term of p
 
poly p_Head0 (const poly p, const ring r)
 like p_Head, but allow NULL coeff
 
poly p_CopyPowerProduct (const poly p, const ring r)
 like p_Head, but with coefficient 1
 
poly p_CopyPowerProduct0 (const poly p, const number n, const ring r)
 like p_Head, but with coefficient n
 
static poly p_Copy (poly p, const ring lmRing, const ring tailRing)
 returns a copy of p with Lm(p) from lmRing and Tail(p) from tailRing
 
static void p_Delete (poly *p, const ring r)
 
static void p_Delete (poly *p, const ring lmRing, const ring tailRing)
 
static poly p_ShallowCopyDelete (poly p, const ring r, omBin bin)
 
static poly p_Add_q (poly p, poly q, const ring r)
 
static poly p_Add_q (poly p, poly q, int &lp, int lq, const ring r)
 like p_Add_q, except that if lp == pLength(lp) lq == pLength(lq) then lp == pLength(p+q)
 
static poly p_Mult_nn (poly p, number n, const ring r)
 
static poly p_Mult_nn (poly p, number n, const ring lmRing, const ring tailRing)
 
static poly pp_Mult_nn (poly p, number n, const ring r)
 
static BOOLEAN p_LmIsConstantComp (const poly p, const ring r)
 
static BOOLEAN p_LmIsConstant (const poly p, const ring r)
 
static poly pp_Mult_mm (poly p, poly m, const ring r)
 
static poly pp_mm_Mult (poly p, poly m, const ring r)
 
static poly p_Mult_mm (poly p, poly m, const ring r)
 
static poly p_mm_Mult (poly p, poly m, const ring r)
 
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)
 
static poly p_Minus_mm_Mult_qq (poly p, const poly m, const poly q, const ring r)
 
static poly pp_Mult_Coeff_mm_DivSelect (poly p, const poly m, const ring r)
 
static poly pp_Mult_Coeff_mm_DivSelect (poly p, int &lp, const poly m, const ring r)
 
static poly p_Neg (poly p, const ring r)
 
poly _p_Mult_q (poly p, poly q, const int copy, const ring r)
 Returns: p * q, Destroys: if !copy then p, q Assumes: pLength(p) >= 2 pLength(q) >=2, !rIsPluralRing(r), nCoeff_is_Domain.
 
poly _p_Mult_q_Normal_ZeroDiv (poly p, poly q, const int copy, const ring r)
 
static poly p_Mult_q (poly p, poly q, const ring r)
 
static poly pp_Mult_qq (poly p, poly q, const ring r)
 
static poly p_Plus_mm_Mult_qq (poly p, poly m, poly q, int &lp, int lq, const ring r)
 
static poly p_Plus_mm_Mult_qq (poly p, poly m, poly q, const ring r)
 
static poly p_Merge_q (poly p, poly q, const ring r)
 
static poly p_SortAdd (poly p, const ring r, BOOLEAN revert=FALSE)
 
static poly p_SortMerge (poly p, const ring r, BOOLEAN revert=FALSE)
 
static char * p_String (poly p, ring p_ring)
 
static void p_String0 (poly p, ring p_ring)
 
static void p_Write (poly p, ring p_ring)
 
static void p_Write0 (poly p, ring p_ring)
 
static void p_wrp (poly p, ring p_ring)
 
static void p_MemAdd_NegWeightAdjust (poly p, const ring r)
 
static void p_MemSub_NegWeightAdjust (poly p, const ring r)
 
static void p_ExpVectorCopy (poly d_p, poly s_p, const ring r)
 
static poly p_Init (const ring r, omBin bin)
 
static poly p_Init (const ring r)
 
static poly p_LmInit (poly p, const ring r)
 
static poly p_LmInit (poly s_p, const ring s_r, const ring d_r, omBin d_bin)
 
static poly p_LmInit (poly s_p, const ring s_r, const ring d_r)
 
static poly p_GetExp_k_n (poly p, int l, int k, const ring r)
 
static poly p_LmShallowCopyDelete (poly p, const ring r)
 
static void p_ExpVectorAdd (poly p1, poly p2, const ring r)
 
static void p_ExpVectorSum (poly pr, poly p1, poly p2, const ring r)
 
static void p_ExpVectorSub (poly p1, poly p2, const ring r)
 
static void p_ExpVectorAddSub (poly p1, poly p2, poly p3, const ring r)
 
static void p_ExpVectorDiff (poly pr, poly p1, poly p2, const ring r)
 
static BOOLEAN p_ExpVectorEqual (poly p1, poly p2, const ring r)
 
static long p_Totaldegree (poly p, const ring r)
 
static void p_GetExpV (poly p, int *ev, const ring r)
 
static void p_GetExpVL (poly p, int64 *ev, const ring r)
 
static int64 p_GetExpVLV (poly p, int64 *ev, const ring r)
 
static void p_SetExpV (poly p, int *ev, const ring r)
 
static void p_SetExpVL (poly p, int64 *ev, const ring r)
 
static void p_SetExpVLV (poly p, int64 *ev, int64 comp, const ring r)
 
static int p_LmCmp (poly p, poly q, const ring r)
 
static int p_LtCmp (poly p, poly q, const ring r)
 
static int p_LtCmpNoAbs (poly p, poly q, const ring r)
 
static int p_LtCmpOrdSgnDiffM (poly p, poly q, const ring r)
 
static int p_LtCmpOrdSgnDiffP (poly p, poly q, const ring r)
 
static int p_LtCmpOrdSgnEqM (poly p, poly q, const ring r)
 
static int p_LtCmpOrdSgnEqP (poly p, poly q, const ring r)
 
BOOLEAN p_ComparePolys (poly p1, poly p2, const ring r)
 returns TRUE if p1 is a skalar multiple of p2 assume p1 != NULL and p2 != NULL
 
static int p_Cmp (poly p1, poly p2, ring r)
 
static int p_CmpPolys (poly p1, poly p2, ring r)
 
static BOOLEAN _p_LmDivisibleByNoComp (poly a, poly b, const ring r)
 return: FALSE, if there exists i, such that a->exp[i] > b->exp[i] TRUE, otherwise (1) Consider long vars, instead of single exponents (2) Clearly, if la > lb, then FALSE (3) Suppose la <= lb, and consider first bits of single exponents in l: if TRUE, then value of these bits is la ^ lb if FALSE, then la-lb causes an "overflow" into one of those bits, i.e., la ^ lb != la - lb
 
static BOOLEAN _p_LmDivisibleByNoComp (poly a, const ring r_a, poly b, const ring r_b)
 
static BOOLEAN _p_LmDivisibleByNoCompPart (poly a, const ring r_a, poly b, const ring r_b, const int start, const int end)
 
static BOOLEAN _p_LmDivisibleByPart (poly a, const ring r_a, poly b, const ring r_b, const int start, const int end)
 
static BOOLEAN p_LmDivisibleByPart (poly a, poly b, const ring r, const int start, const int end)
 
static BOOLEAN _p_LmDivisibleBy (poly a, poly b, const ring r)
 
static BOOLEAN p_LmDivisibleByNoComp (poly a, poly b, const ring r)
 
static BOOLEAN p_LmDivisibleByNoComp (poly a, const ring ra, poly b, const ring rb)
 
static BOOLEAN p_LmDivisibleBy (poly a, poly b, const ring r)
 
static BOOLEAN p_DivisibleBy (poly a, poly b, const ring r)
 
static BOOLEAN p_LmShortDivisibleBy (poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
 
static BOOLEAN p_LmShortDivisibleByNoComp (poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
 
static BOOLEAN p_IsConstantComp (const poly p, const ring r)
 like the respective p_LmIs* routines, except that p might be empty
 
static BOOLEAN p_IsConstant (const poly p, const ring r)
 
static BOOLEAN p_IsOne (const poly p, const ring R)
 either poly(1) or gen(k)?!
 
static BOOLEAN p_IsConstantPoly (const poly p, const ring r)
 
static BOOLEAN p_IsUnit (const poly p, const ring r)
 
static BOOLEAN p_LmExpVectorAddIsOk (const poly p1, const poly p2, const ring r)
 
void p_Split (poly p, poly *r)
 
BOOLEAN p_HasNotCF (poly p1, poly p2, const ring r)
 
BOOLEAN p_HasNotCFRing (poly p1, poly p2, const ring r)
 
poly p_mInit (const char *s, BOOLEAN &ok, const ring r)
 
const char * p_Read (const char *s, poly &p, const ring r)
 
poly p_MDivide (poly a, poly b, const ring r)
 
poly p_DivideM (poly a, poly b, const ring r)
 
poly pp_DivideM (poly a, poly b, const ring r)
 
poly p_Div_nn (poly p, const number n, const ring r)
 
void p_Lcm (const poly a, const poly b, poly m, const ring r)
 
poly p_Lcm (const poly a, const poly b, const ring r)
 
poly p_LcmRat (const poly a, const poly b, const long lCompM, const ring r)
 
poly p_GetCoeffRat (poly p, int ishift, ring r)
 
void p_LmDeleteAndNextRat (poly *p, int ishift, ring r)
 
void p_ContentRat (poly &ph, const ring r)
 
poly p_Diff (poly a, int k, const ring r)
 
poly p_DiffOp (poly a, poly b, BOOLEAN multiply, const ring r)
 
int p_Weight (int c, const ring r)
 
poly p_PolyDiv (poly &p, const poly divisor, const BOOLEAN needResult, const ring r)
 assumes that p and divisor are univariate polynomials in r, mentioning the same variable; assumes divisor != NULL; p may be NULL; assumes a global monomial ordering in r; performs polynomial division of p by divisor:
 
BOOLEAN p_VectorHasUnitB (poly p, int *k, const ring r)
 
void p_VectorHasUnit (poly p, int *k, int *len, const ring r)
 
void p_TakeOutComp (poly *p, long comp, poly *q, int *lq, const ring r)
 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 p_TakeOutComp (poly *p, int k, const ring r)
 
void p_DeleteComp (poly *p, int k, const ring r)
 
void pSetDegProcs (ring r, pFDegProc new_FDeg, pLDegProc new_lDeg=NULL)
 
void pRestoreDegProcs (ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
 
void p_SetModDeg (intvec *w, ring r)
 
poly pp_Jet (poly p, int m, const ring R)
 
poly pp_Jet0 (poly p, const ring R)
 
poly p_Jet (poly p, int m, const ring R)
 
poly pp_JetW (poly p, int m, int *w, const ring R)
 
poly p_JetW (poly p, int m, int *w, const ring R)
 
poly n_PermNumber (const number z, const int *par_perm, const int OldPar, const ring src, const ring dst)
 
poly p_PermPoly (poly p, const int *perm, const ring OldRing, const ring dst, nMapFunc nMap, const int *par_perm=NULL, int OldPar=0, BOOLEAN use_mult=FALSE)
 
poly p_Series (int n, poly p, poly u, intvec *w, const ring R)
 
int p_Var (poly mi, const ring r)
 
int p_LowVar (poly p, const ring r)
 the minimal index of used variables - 1
 
void p_Shift (poly *p, int i, const ring r)
 shifts components of the vector p by i
 
int p_Compare (const poly a, const poly b, const ring R)
 
poly p_GcdMon (poly f, poly g, const ring r)
 polynomial gcd for f=mon
 
poly p_Div_mm (poly p, const poly m, const ring r)
 divide polynomial by monomial
 
int p_MaxExpPerVar (poly p, int i, const ring r)
 max exponent of variable x_i in p
 

Macro Definition Documentation

◆ __p_Mult_nn

#define __p_Mult_nn ( p,
n,
r )
Value:
r->p_Procs->p_Mult_nn(p, n, r)
int p
Definition cfModGcd.cc:4086

Definition at line 973 of file p_polys.h.

◆ __pp_Mult_nn

#define __pp_Mult_nn ( p,
n,
r )
Value:
r->p_Procs->pp_Mult_nn(p, n, r)

Definition at line 1004 of file p_polys.h.

◆ _p_LmCmpAction

#define _p_LmCmpAction ( p,
q,
r,
actionE,
actionG,
actionS )
Value:
p_MemCmp_LengthGeneral_OrdGeneral(p->exp, q->exp, r->CmpL_Size, r->ordsgn, \
actionE, actionG, actionS)
#define p_MemCmp_LengthGeneral_OrdGeneral(s1, s2, length, ordsgn, actionE, actionG, actionS)
Definition p_MemCmp.h:719

Definition at line 1292 of file p_polys.h.

1292#define _p_LmCmpAction(p, q, r, actionE, actionG, actionS) \
1293 p_MemCmp_LengthGeneral_OrdGeneral(p->exp, q->exp, r->CmpL_Size, r->ordsgn, \
1294 actionE, actionG, actionS)

◆ p_LmCmpAction

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

Definition at line 1735 of file p_polys.h.

1735#define p_LmCmpAction(p, q, r, actionE, actionG, actionS) \
1736 _p_LmCmpAction(p, q, r, actionE, actionG, actionS)

◆ p_LmEqual

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

Definition at line 1739 of file p_polys.h.

◆ p_LmTest

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

Definition at line 162 of file p_polys.h.

◆ p_SetmComp

#define p_SetmComp   p_Setm

Definition at line 246 of file p_polys.h.

◆ p_Test

#define p_Test ( p,
r )
Value:
BOOLEAN _p_Test(poly p, ring r, int level)
Definition pDebug.cc:211

Definition at line 161 of file p_polys.h.

◆ pDivAssume

#define pDivAssume ( x)
Value:
do {} while (0)

Definition at line 1298 of file p_polys.h.

◆ pIfThen

#define pIfThen ( cond,
check )
Value:
do {if (cond) {check;}} while (0)
VAR int check
Definition libparse.cc:1106

Definition at line 155 of file p_polys.h.

◆ pp_Test

#define pp_Test ( p,
lmRing,
tailRing )
Value:
_pp_Test(p, lmRing, tailRing, PDEBUG)
BOOLEAN _pp_Test(poly p, ring lmRing, ring tailRing, int level)
Definition pDebug.cc:332

Definition at line 163 of file p_polys.h.

Function Documentation

◆ _p_LmDivisibleBy()

static BOOLEAN _p_LmDivisibleBy ( poly a,
poly b,
const ring r )
inlinestatic

Definition at line 1887 of file p_polys.h.

1888{
1889 if (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r))
1890 return _p_LmDivisibleByNoComp(a, b, r);
1891 return FALSE;
1892}
#define FALSE
Definition auxiliary.h:97
CanonicalForm b
Definition cfModGcd.cc:4111
#define p_GetComp(p, r)
Definition monomials.h:64
static BOOLEAN _p_LmDivisibleByNoComp(poly a, poly b, const ring r)
return: FALSE, if there exists i, such that a->exp[i] > b->exp[i] TRUE, otherwise (1) Consider long v...
Definition p_polys.h:1781

◆ _p_LmDivisibleByNoComp() [1/2]

static BOOLEAN _p_LmDivisibleByNoComp ( poly a,
const ring r_a,
poly b,
const ring r_b )
inlinestatic

Definition at line 1830 of file p_polys.h.

1831{
1832 int i=r_a->N;
1833 pAssume1(r_a->N == r_b->N);
1834
1835 do
1836 {
1837 if (p_GetExp(a,i,r_a) > p_GetExp(b,i,r_b))
1838 {
1839 return FALSE;
1840 }
1841 i--;
1842 }
1843 while (i);
1844/*#ifdef HAVE_RINGS
1845 return n_DivBy(p_GetCoeff(b, r_b), p_GetCoeff(a, r_a), r_a->cf);
1846#else
1847*/
1848 return TRUE;
1849//#endif
1850}
#define TRUE
Definition auxiliary.h:101
int i
Definition cfEzgcd.cc:132
#define pAssume1(cond)
Definition monomials.h:171
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

◆ _p_LmDivisibleByNoComp() [2/2]

static BOOLEAN _p_LmDivisibleByNoComp ( poly a,
poly b,
const ring r )
inlinestatic

return: FALSE, if there exists i, such that a->exp[i] > b->exp[i] TRUE, otherwise (1) Consider long vars, instead of single exponents (2) Clearly, if la > lb, then FALSE (3) Suppose la <= lb, and consider first bits of single exponents in l: if TRUE, then value of these bits is la ^ lb if FALSE, then la-lb causes an "overflow" into one of those bits, i.e., la ^ lb != la - lb

Definition at line 1781 of file p_polys.h.

1782{
1783 int i=r->VarL_Size - 1;
1784 unsigned long divmask = r->divmask;
1785 unsigned long la, lb;
1786
1787 if (r->VarL_LowIndex >= 0)
1788 {
1789 i += r->VarL_LowIndex;
1790 do
1791 {
1792 la = a->exp[i];
1793 lb = b->exp[i];
1794 if ((la > lb) ||
1795 (((la & divmask) ^ (lb & divmask)) != ((lb - la) & divmask)))
1796 {
1798 return FALSE;
1799 }
1800 i--;
1801 }
1802 while (i>=r->VarL_LowIndex);
1803 }
1804 else
1805 {
1806 do
1807 {
1808 la = a->exp[r->VarL_Offset[i]];
1809 lb = b->exp[r->VarL_Offset[i]];
1810 if ((la > lb) ||
1811 (((la & divmask) ^ (lb & divmask)) != ((lb - la) & divmask)))
1812 {
1814 return FALSE;
1815 }
1816 i--;
1817 }
1818 while (i>=0);
1819 }
1820/*#ifdef HAVE_RINGS
1821 pDivAssume(p_DebugLmDivisibleByNoComp(a, b, r) == n_DivBy(p_GetCoeff(b, r), p_GetCoeff(a, r), r->cf));
1822 return (!rField_is_Ring(r)) || n_DivBy(p_GetCoeff(b, r), p_GetCoeff(a, r), r->cf);
1823#else
1824*/
1826 return TRUE;
1827//#endif
1828}
BOOLEAN p_DebugLmDivisibleByNoComp(poly a, poly b, ring r)
Definition pDebug.cc:144
#define pDivAssume(x)
Definition p_polys.h:1298

◆ _p_LmDivisibleByNoCompPart()

static BOOLEAN _p_LmDivisibleByNoCompPart ( poly a,
const ring r_a,
poly b,
const ring r_b,
const int start,
const int end )
inlinestatic

Definition at line 1853 of file p_polys.h.

1854{
1855 int i=end;
1856 pAssume1(r_a->N == r_b->N);
1857
1858 do
1859 {
1860 if (p_GetExp(a,i,r_a) > p_GetExp(b,i,r_b))
1861 return FALSE;
1862 i--;
1863 }
1864 while (i>=start);
1865/*#ifdef HAVE_RINGS
1866 return n_DivBy(p_GetCoeff(b, r_b), p_GetCoeff(a, r_a), r_a->cf);
1867#else
1868*/
1869 return TRUE;
1870//#endif
1871}

◆ _p_LmDivisibleByPart()

static BOOLEAN _p_LmDivisibleByPart ( poly a,
const ring r_a,
poly b,
const ring r_b,
const int start,
const int end )
inlinestatic

Definition at line 1872 of file p_polys.h.

1873{
1874 if (p_GetComp(a, r_a) == 0 || p_GetComp(a,r_a) == p_GetComp(b,r_b))
1875 return _p_LmDivisibleByNoCompPart(a, r_a, b, r_b,start,end);
1876 return FALSE;
1877}
static BOOLEAN _p_LmDivisibleByNoCompPart(poly a, const ring r_a, poly b, const ring r_b, const int start, const int end)
Definition p_polys.h:1853

◆ _p_LmTest()

BOOLEAN _p_LmTest ( poly p,
ring r,
int level )

Definition at line 322 of file pDebug.cc.

323{
324 if (level < 0 || p == NULL) return TRUE;
325 poly pnext = pNext(p);
326 pNext(p) = NULL;
327 BOOLEAN test_res = _p_Test(p, r, level);
328 pNext(p) = pnext;
329 return test_res;
330}
int BOOLEAN
Definition auxiliary.h:88
int level(const CanonicalForm &f)
#define pNext(p)
Definition monomials.h:36
#define NULL
Definition omList.c:12
BOOLEAN _p_Test(poly p, ring r, int level)
Definition pDebug.cc:211

◆ _p_Mult_q()

poly _p_Mult_q ( poly p,
poly q,
const int copy,
const ring r )

Returns: p * q, Destroys: if !copy then p, q Assumes: pLength(p) >= 2 pLength(q) >=2, !rIsPluralRing(r), nCoeff_is_Domain.

Definition at line 309 of file p_Mult_q.cc.

310{
311 assume(r != NULL);
312 int lp=0, lq=0;
313 poly pt;
314
315 BOOLEAN pure_polys=(p_GetComp(p,r)==0) && (p_GetComp(q,r)==0);
316 #ifdef HAVE_FLINT
317 #if __FLINT_RELEASE >= 20503
318 if (pure_polys)
319 {
321 if (lp < lq)
322 {
323 int l;
324 pt = p;
325 p = q;
326 q = pt;
327 l = lp;
328 lp = lq;
329 lq = l;
330 }
331 if ((lq>MIN_FLINT_QQ) && rField_is_Q(r))
332 {
333 fmpq_mpoly_ctx_t ctx;
334 if (!convSingRFlintR(ctx,r))
335 {
336 // lq is a lower bound for the length of p and q
337 poly res=Flint_Mult_MP(p,lq,q,lq,ctx,r);
338 if (!copy)
339 {
340 p_Delete(&p,r);
341 p_Delete(&q,r);
342 }
343 return res;
344 }
345 }
346 else if ((lq>MIN_FLINT_Zp) && rField_is_Zp(r))
347 {
348 nmod_mpoly_ctx_t ctx;
349 if (!convSingRFlintR(ctx,r))
350 {
351 // lq is a lower bound for the length of p and q
352 poly res=Flint_Mult_MP(p,lq,q,lq,ctx,r);
353 if (!copy)
354 {
355 p_Delete(&p,r);
356 p_Delete(&q,r);
357 }
358 return res;
359 }
360 }
361 else if ((lq>MIN_FLINT_Z) && rField_is_Z(r))
362 {
363 fmpz_mpoly_ctx_t ctx;
364 if (!convSingRFlintR(ctx,r))
365 {
366 // lq is a lower bound for the length of p and q
367 poly res=Flint_Mult_MP(p,lq,q,lq,ctx,r);
368 if (!copy)
369 {
370 p_Delete(&p,r);
371 p_Delete(&q,r);
372 }
373 return res;
374 }
375 }
376 }
377 #endif
378 #endif
379 if (lp==0)
381 if (lp < lq)
382 {
383 int l;
384 pt = p;
385 p = q;
386 q = pt;
387 l = lp;
388 lp = lq;
389 lq = l;
390 }
392 return _p_Mult_q_Normal(p, q, copy, r);
393 #if 0
394 else if (pure_polys
395 && ((r->cf->extRing==NULL)||(r->cf->extRing->qideal!=NULL))
396 /* exclude trans. extensions: may contain rat.funct as cf */
397 && (lq >= MIN_LENGTH_FACTORY)
398 && (r->cf->convSingNFactoryN!=ndConvSingNFactoryN))
399 {
400 poly h=singclap_pmult(p,q,r);
401 if (!copy)
402 {
403 p_Delete(&p,r);
404 p_Delete(&q,r);
405 }
406 return h;
407 }
408 #endif
409 else
410 {
411 lp=pLength(p);
412 lq=pLength(q);
413 if (lp < lq)
414 {
415 int l;
416 pt = p;
417 p = q;
418 q = pt;
419 l = lp;
420 lp = lq;
421 lq = l;
422 }
423 return _p_Mult_q_Bucket(p, lp, q, lq, copy, r);
424 }
425}
int l
Definition cfEzgcd.cc:100
poly singclap_pmult(poly f, poly g, const ring r)
Definition clapsing.cc:577
CanonicalForm res
Definition facAbsFact.cc:60
CFArray copy(const CFList &list)
write elements of list into an array
STATIC_VAR Poly * h
Definition janet.cc:971
#define assume(x)
Definition mod2.h:389
Definition lq.h:40
CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition numbers.cc:307
#define TEST_OPT_NOT_BUCKETS
Definition options.h:107
static void pqLengthApprox(poly p, poly q, int &lp, int &lq, const int min)
Definition p_Mult_q.cc:69
poly _p_Mult_q_Normal(poly p, poly q, const int copy, const ring r)
Definition p_Mult_q.cc:223
#define MIN_FLINT_Z
Definition p_Mult_q.cc:304
poly _p_Mult_q_Bucket(poly p, const int lp, poly q, const int lq, const int copy, const ring r)
Definition p_Mult_q.cc:100
#define MIN_LENGTH_MAX
Definition p_Mult_q.cc:301
#define MIN_FLINT_QQ
Definition p_Mult_q.cc:302
#define MIN_FLINT_Zp
Definition p_Mult_q.cc:303
#define MIN_LENGTH_BUCKET
Definition p_Mult_q.h:21
static int pLength(poly a)
Definition p_polys.h:190
static void p_Delete(poly *p, const ring r)
Definition p_polys.h:903
static BOOLEAN rField_is_Z(const ring r)
Definition ring.h:515
static BOOLEAN rField_is_Zp(const ring r)
Definition ring.h:506
static BOOLEAN rField_is_Q(const ring r)
Definition ring.h:512

◆ _p_Mult_q_Normal_ZeroDiv()

poly _p_Mult_q_Normal_ZeroDiv ( poly p,
poly q,
const int copy,
const ring r )

Definition at line 195 of file p_Mult_q.cc.

196{
197 assume(p != NULL && pNext(p) != NULL && q != NULL && pNext(q) != NULL);
199 p_Test(p, r);
200 p_Test(q, r);
201
202 poly res = pp_Mult_mm(p,q,r); // holds initially q1*p
203 poly qq = pNext(q); // we iter of this
204
205 while (qq != NULL)
206 {
207 res = p_Plus_mm_Mult_qq(res, qq, p, r);
208 pIter(qq);
209 }
210
211 if (!copy)
212 {
213 p_Delete(&p, r);
214 p_Delete(&q, r);
215 }
216
217 p_Test(res, r);
218
219 return res;
220}
#define pIter(p)
Definition monomials.h:37
static poly pp_Mult_mm(poly p, poly m, const ring r)
Definition p_polys.h:1033
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
BOOLEAN pHaveCommonMonoms(poly p, poly q)
Definition pDebug.cc:174
#define p_Test(p, r)
Definition p_polys.h:161

◆ _p_Test()

BOOLEAN _p_Test ( poly p,
ring r,
int level )

Definition at line 211 of file pDebug.cc.

212{
213 assume(r->cf !=NULL);
214
215 if (PDEBUG > level) level = PDEBUG;
216 if (level < 0 || p == NULL) return TRUE;
217
218 poly p_prev = NULL;
219
220 #ifndef OM_NDEBUG
221 #ifndef X_OMALLOC
222 // check addr with level+1 so as to check bin/page of addr
223 _pPolyAssumeReturnMsg(omTestBinAddrSize(p, (omSizeWOfBin(r->PolyBin))*SIZEOF_LONG, level+1)
224 == omError_NoError, "memory error",p,r);
225 #endif
226 #endif
227
229
230 // this checks that p does not contain a loop: rather expensive O(length^2)
231 #ifndef OM_NDEBUG
232 if (level > 1)
234 #endif
235
236 int ismod = p_GetComp(p, r) != 0;
237
238 while (p != NULL)
239 {
240 // ring check
242 #ifndef OM_NDEBUG
243 #ifndef X_OMALLOC
244 // omAddr check
245 _pPolyAssumeReturnMsg(omTestBinAddrSize(p, (omSizeWOfBin(r->PolyBin))*SIZEOF_LONG, 1)
246 == omError_NoError, "memory error",p,r);
247 #endif
248 #endif
249 // number/coef check
250 _pPolyAssumeReturnMsg(p->coef != NULL || (n_GetChar(r->cf) >= 2), "NULL coef",p,r);
251
252 #ifdef LDEBUG
253 _pPolyAssumeReturnMsg(n_Test(p->coef,r->cf),"coeff err",p,r);
254 #endif
255 _pPolyAssumeReturnMsg(!n_IsZero(p->coef, r->cf), "Zero coef",p,r);
256
257 // check for valid comp
258 _pPolyAssumeReturnMsg(p_GetComp(p, r) >= 0 && (p_GetComp(p, r)<65000), "component out of range ?",p,r);
259 // check for mix poly/vec representation
260 _pPolyAssumeReturnMsg(ismod == (p_GetComp(p, r) != 0), "mixed poly/vector",p,r);
261
262 // special check for ringorder_s/S
263 if ((r->typ!=NULL) && (r->typ[0].ord_typ == ro_syzcomp))
264 {
265 long c1, cc1, ccc1, ec1;
266 sro_ord* o = &(r->typ[0]);
267
268 c1 = p_GetComp(p, r);
269 if (o->data.syzcomp.Components!=NULL)
270 {
271 cc1 = o->data.syzcomp.Components[c1];
272 ccc1 = o->data.syzcomp.ShiftedComponents[cc1];
273 }
274 else { cc1=0; ccc1=0; }
275 _pPolyAssumeReturnMsg(c1 == 0 || cc1 != 0, "Component <-> TrueComponent zero mismatch",p,r);
276 _pPolyAssumeReturnMsg(c1 == 0 || ccc1 != 0,"Component <-> ShiftedComponent zero mismatch",p,r);
277 ec1 = p->exp[o->data.syzcomp.place];
278 //pPolyAssumeReturnMsg(ec1 == ccc1, "Shifted comp out of sync. should %d, is %d");
279 if (ec1 != ccc1)
280 {
281 dPolyReportError(p,r,"Shifted comp out of sync. should %d, is %d",ccc1,ec1);
282 return FALSE;
283 }
284 }
285
286 // check that p_Setm works ok
287 if (level > 0)
288 {
289 poly p_should_equal = p_DebugInit(p, r, r);
290 _pPolyAssumeReturnMsg(p_ExpVectorEqual(p, p_should_equal, r), "p_Setm field(s) out of sync",p,r);
291 p_LmFree(p_should_equal, r);
292 }
293
294 // check order
295 if (p_prev != NULL)
296 {
297 int cmp = p_LmCmp(p_prev, p, r);
298 if (cmp == 0)
299 {
300 _pPolyAssumeReturnMsg(0, "monoms p and p->next are equal", p_prev, r);
301 }
302 else
303 _pPolyAssumeReturnMsg(p_LmCmp(p_prev, p, r) == 1, "wrong order", p_prev, r);
304
305 // check that compare worked sensibly
306 if (level > 1 && p_GetComp(p_prev, r) == p_GetComp(p, r))
307 {
308 int i;
309 for (i=r->N; i>0; i--)
310 {
311 if (p_GetExp(p_prev, i, r) != p_GetExp(p, i, r)) break;
312 }
313 _pPolyAssumeReturnMsg(i > 0, "Exponents equal but compare different", p_prev, r);
314 }
315 }
316 p_prev = p;
317 pIter(p);
318 }
319 return TRUE;
320}
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
Definition coeffs.h:713
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
Definition coeffs.h:468
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition coeffs.h:448
#define pFalseReturn(cond)
Definition monomials.h:139
#define _pPolyAssumeReturnMsg(cond, msg, p, r)
Definition monomials.h:124
#define omSizeWOfBin(bin_ptr)
@ omError_NoError
Definition omError.h:18
#define omTestList(ptr, level)
Definition omList.h:81
static poly p_DebugInit(poly p, ring src_ring, ring dest_ring)
Definition pDebug.cc:194
BOOLEAN dPolyReportError(poly p, ring r, const char *fmt,...)
Definition pDebug.cc:43
BOOLEAN p_CheckRing(ring r)
Definition pDebug.cc:131
BOOLEAN p_LmCheckIsFromRing(poly p, ring r)
Definition pDebug.cc:74
static int p_LmCmp(poly p, poly q, const ring r)
Definition p_polys.h:1596
static void p_LmFree(poly p, ring)
Definition p_polys.h:685
@ ro_syzcomp
Definition ring.h:60
union sro_ord::@006200034235045362245112336324125006204215012002 data
#define omTestBinAddrSize(A, B, C)
Definition xalloc.h:272

◆ _pp_Test()

BOOLEAN _pp_Test ( poly p,
ring lmRing,
ring tailRing,
int level )

Definition at line 332 of file pDebug.cc.

333{
334 if (PDEBUG > level) level = PDEBUG;
335 if (level < 0 || p == NULL) return TRUE;
336 if (pNext(p) == NULL || lmRing == tailRing) return _p_Test(p, lmRing, level);
337
338 pFalseReturn(_p_LmTest(p, lmRing, level));
339 pFalseReturn(_p_Test(pNext(p), tailRing, level));
340
341 // check that lm > Lm(tail)
342 if (level > 1)
343 {
344 poly lm = p;
345 poly tail = p_DebugInit(pNext(p), tailRing, lmRing);
346 poly pnext = pNext(lm);
347 pNext(lm) = tail;
348 BOOLEAN cmp = p_LmCmp(lm, tail, lmRing);
349 if (cmp != 1)
350 dPolyReportError(lm, lmRing, "wrong order: lm <= Lm(tail)");
351 p_LmFree(tail, lmRing);
352 pNext(lm) = pnext;
353 return (cmp == 1);
354 }
355 return TRUE;
356}
BOOLEAN _p_LmTest(poly p, ring r, int level)
Definition pDebug.cc:322

◆ n_PermNumber()

poly n_PermNumber ( const number z,
const int * par_perm,
const int OldPar,
const ring src,
const ring dst )

Definition at line 4108 of file p_polys.cc.

4109{
4110#if 0
4111 PrintS("\nSource Ring: \n");
4112 rWrite(src);
4113
4114 if(0)
4115 {
4116 number zz = n_Copy(z, src->cf);
4117 PrintS("z: "); n_Write(zz, src);
4118 n_Delete(&zz, src->cf);
4119 }
4120
4121 PrintS("\nDestination Ring: \n");
4122 rWrite(dst);
4123
4124 /*Print("\nOldPar: %d\n", OldPar);
4125 for( int i = 1; i <= OldPar; i++ )
4126 {
4127 Print("par(%d) -> par/var (%d)\n", i, par_perm[i-1]);
4128 }*/
4129#endif
4130 if( z == NULL )
4131 return NULL;
4132
4133 const coeffs srcCf = src->cf;
4134 assume( srcCf != NULL );
4135
4136 assume( !nCoeff_is_GF(srcCf) );
4137 assume( src->cf->extRing!=NULL );
4138
4139 poly zz = NULL;
4140
4141 const ring srcExtRing = srcCf->extRing;
4142 assume( srcExtRing != NULL );
4143
4144 const coeffs dstCf = dst->cf;
4145 assume( dstCf != NULL );
4146
4147 if( nCoeff_is_algExt(srcCf) ) // nCoeff_is_GF(srcCf)?
4148 {
4149 zz = (poly) z;
4150 if( zz == NULL ) return NULL;
4151 }
4152 else if (nCoeff_is_transExt(srcCf))
4153 {
4154 assume( !IS0(z) );
4155
4156 zz = NUM((fraction)z);
4157 p_Test (zz, srcExtRing);
4158
4159 if( zz == NULL ) return NULL;
4160 if( !DENIS1((fraction)z) )
4161 {
4162 if (!p_IsConstant(DEN((fraction)z),srcExtRing))
4163 WarnS("Not defined: Cannot map a rational fraction and make a polynomial out of it! Ignoring the denominator.");
4164 }
4165 }
4166 else
4167 {
4168 assume (FALSE);
4169 WerrorS("Number permutation is not implemented for this data yet!");
4170 return NULL;
4171 }
4172
4173 assume( zz != NULL );
4174 p_Test (zz, srcExtRing);
4175
4176 nMapFunc nMap = n_SetMap(srcExtRing->cf, dstCf);
4177
4178 assume( nMap != NULL );
4179
4180 poly qq;
4181 if ((par_perm == NULL) && (rPar(dst) != 0 && rVar (srcExtRing) > 0))
4182 {
4183 int* perm;
4184 perm=(int *)omAlloc0((rVar(srcExtRing)+1)*sizeof(int));
4185 for(int i=si_min(rVar(srcExtRing),rPar(dst));i>0;i--)
4186 perm[i]=-i;
4187 qq = p_PermPoly(zz, perm, srcExtRing, dst, nMap, NULL, rVar(srcExtRing)-1);
4188 omFreeSize ((ADDRESS)perm, (rVar(srcExtRing)+1)*sizeof(int));
4189 }
4190 else
4191 qq = p_PermPoly(zz, par_perm-1, srcExtRing, dst, nMap, NULL, rVar (srcExtRing)-1);
4192
4193 if(nCoeff_is_transExt(srcCf)
4194 && (!DENIS1((fraction)z))
4195 && p_IsConstant(DEN((fraction)z),srcExtRing))
4196 {
4197 number n=nMap(pGetCoeff(DEN((fraction)z)),srcExtRing->cf, dstCf);
4198 qq=p_Div_nn(qq,n,dst);
4199 n_Delete(&n,dstCf);
4200 p_Normalize(qq,dst);
4201 }
4202 p_Test (qq, dst);
4203
4204 return qq;
4205}
void * ADDRESS
Definition auxiliary.h:120
static int si_min(const int a, const int b)
Definition auxiliary.h:126
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
Definition coeffs.h:455
static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
Definition coeffs.h:832
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
Definition coeffs.h:701
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition coeffs.h:459
static FORCE_INLINE void n_Write(number n, const coeffs r, const BOOLEAN bShortOut=TRUE)
Definition coeffs.h:592
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
Definition coeffs.h:903
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition coeffs.h:80
static FORCE_INLINE BOOLEAN nCoeff_is_transExt(const coeffs r)
TRUE iff r represents a transcendental extension field.
Definition coeffs.h:911
#define WarnS
Definition emacs.cc:78
void WerrorS(const char *s)
Definition feFopen.cc:24
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition monomials.h:44
The main handler for Singular numbers which are suitable for Singular polynomials.
#define omFreeSize(addr, size)
#define omAlloc0(size)
poly p_PermPoly(poly p, const int *perm, const ring oldRing, const ring dst, nMapFunc nMap, const int *par_perm, int OldPar, BOOLEAN use_mult)
Definition p_polys.cc:4211
poly p_Div_nn(poly p, const number n, const ring r)
Definition p_polys.cc:1506
void p_Normalize(poly p, const ring r)
Definition p_polys.cc:3894
static BOOLEAN p_IsConstant(const poly p, const ring r)
Definition p_polys.h:1980
#define NUM
Definition readcf.cc:180
void PrintS(const char *s)
Definition reporter.cc:284
void rWrite(ring r, BOOLEAN details)
Definition ring.cc:227
static int rPar(const ring r)
(r->cf->P)
Definition ring.h:605
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition ring.h:598

◆ p_Add_q() [1/2]

static poly p_Add_q ( poly p,
poly q,
const ring r )
inlinestatic

Definition at line 938 of file p_polys.h.

939{
940 assume( (p != q) || (p == NULL && q == NULL) );
941 if (q==NULL) return p;
942 if (p==NULL) return q;
943 int shorter;
944 return r->p_Procs->p_Add_q(p, q, shorter, r);
945}

◆ p_Add_q() [2/2]

static poly p_Add_q ( poly p,
poly q,
int & lp,
int lq,
const ring r )
inlinestatic

like p_Add_q, except that if lp == pLength(lp) lq == pLength(lq) then lp == pLength(p+q)

Definition at line 948 of file p_polys.h.

949{
950 assume( (p != q) || (p == NULL && q == NULL) );
951 if (q==NULL) return p;
952 if (p==NULL) { lp=lq; return q; }
953 int shorter;
954 poly res = r->p_Procs->p_Add_q(p, q, shorter, r);
955 lp += lq - shorter;
956 return res;
957}

◆ p_AddComp()

static unsigned long p_AddComp ( poly p,
unsigned long v,
ring r )
inlinestatic

Definition at line 449 of file p_polys.h.

450{
453 return __p_GetComp(p,r) += v;
454}
const Variable & v
< [in] a sqrfree bivariate poly
Definition facBivar.h:39
#define p_LmCheckPolyRing2(p, r)
Definition monomials.h:199
#define pAssume2(cond)
Definition monomials.h:193
#define __p_GetComp(p, r)
Definition monomials.h:63
#define rRing_has_Comp(r)
Definition monomials.h:266

◆ p_AddExp()

static long p_AddExp ( poly p,
int v,
long ee,
ring r )
inlinestatic

Definition at line 608 of file p_polys.h.

609{
611 int e = p_GetExp(p,v,r);
612 e += ee;
613 return p_SetExp(p,v,e,r);
614}
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

◆ p_CheckIsFromRing()

BOOLEAN p_CheckIsFromRing ( poly p,
ring r )

Definition at line 105 of file pDebug.cc.

106{
107 while (p!=NULL)
108 {
110 pIter(p);
111 }
112 return TRUE;
113}

◆ p_CheckPolyRing()

BOOLEAN p_CheckPolyRing ( poly p,
ring r )

Definition at line 115 of file pDebug.cc.

116{
117 #ifndef X_OMALLOC
118 pAssumeReturn(r != NULL && r->PolyBin != NULL);
119 #endif
120 return p_CheckIsFromRing(p, r);
121}
#define pAssumeReturn(cond)
Definition monomials.h:78
BOOLEAN p_CheckIsFromRing(poly p, ring r)
Definition pDebug.cc:105

◆ p_CheckRing()

BOOLEAN p_CheckRing ( ring r)

Definition at line 131 of file pDebug.cc.

132{
133 #ifndef X_OMALLOC
134 pAssumeReturn(r != NULL && r->PolyBin != NULL);
135 #endif
136 return TRUE;
137}

◆ p_ChineseRemainder()

poly p_ChineseRemainder ( poly * xx,
number * x,
number * q,
int rl,
CFArray & inv_cache,
const ring R )

Definition at line 88 of file p_polys.cc.

89{
90 poly r,h,hh;
91 int j;
92 poly res_p=NULL;
93 loop
94 {
95 /* search the lead term */
96 r=NULL;
97 for(j=rl-1;j>=0;j--)
98 {
99 h=xx[j];
100 if ((h!=NULL)
101 &&((r==NULL)||(p_LmCmp(r,h,R)==-1)))
102 r=h;
103 }
104 /* nothing found -> return */
105 if (r==NULL) break;
106 /* create the monomial in h */
107 h=p_Head(r,R);
108 /* collect the coeffs in x[..]*/
109 for(j=rl-1;j>=0;j--)
110 {
111 hh=xx[j];
112 if ((hh!=NULL) && (p_LmCmp(h,hh,R)==0))
113 {
114 x[j]=pGetCoeff(hh);
115 hh=p_LmFreeAndNext(hh,R);
116 xx[j]=hh;
117 }
118 else
119 x[j]=n_Init(0, R->cf);
120 }
121 number n=n_ChineseRemainderSym(x,q,rl,TRUE,inv_cache,R->cf);
122 for(j=rl-1;j>=0;j--)
123 {
124 x[j]=NULL; // n_Init(0...) takes no memory
125 }
126 if (n_IsZero(n,R->cf)) p_Delete(&h,R);
127 else
128 {
129 //Print("new mon:");pWrite(h);
130 p_SetCoeff(h,n,R);
131 pNext(h)=res_p;
132 res_p=h; // building res_p in reverse order!
133 }
134 }
135 res_p=pReverse(res_p);
136 p_Test(res_p, R);
137 return res_p;
138}
Variable x
Definition cfModGcd.cc:4090
static FORCE_INLINE number n_ChineseRemainderSym(number *a, number *b, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs r)
Definition coeffs.h:757
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition coeffs.h:539
int j
Definition facHensel.cc:110
static number p_SetCoeff(poly p, number n, ring r)
Definition p_polys.h:414
static poly pReverse(poly p)
Definition p_polys.h:337
static poly p_Head(const poly p, const ring r)
copy the (leading) term of p
Definition p_polys.h:862
static poly p_LmFreeAndNext(poly p, ring)
Definition p_polys.h:713
#define R
Definition sirandom.c:27
#define loop
Definition structs.h:71

◆ p_Cleardenom()

poly p_Cleardenom ( poly p,
const ring r )

Definition at line 2849 of file p_polys.cc.

2850{
2851 if( p == NULL )
2852 return NULL;
2853
2854 assume( r != NULL );
2855 assume( r->cf != NULL );
2856 const coeffs C = r->cf;
2857
2858#if CLEARENUMERATORS
2859 if( 0 )
2860 {
2862 n_ClearDenominators(itr, C);
2863 n_ClearContent(itr, C); // divide out the content
2864 p_Test(p, r); n_Test(pGetCoeff(p), C);
2865 assume(n_GreaterZero(pGetCoeff(p), C)); // ??
2866// if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
2867 return p;
2868 }
2869#endif
2870
2871 number d, h;
2872
2873 if (rField_is_Ring(r))
2874 {
2875 if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
2876 return p;
2877 }
2878
2880 {
2881 if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
2882 return p;
2883 }
2884
2885 assume(p != NULL);
2886
2887 if(pNext(p)==NULL)
2888 {
2889 if (!TEST_OPT_CONTENTSB)
2890 p_SetCoeff(p,n_Init(1,C),r);
2891 else if(!n_GreaterZero(pGetCoeff(p),C))
2892 p = p_Neg(p,r);
2893 return p;
2894 }
2895
2896 assume(pNext(p)!=NULL);
2897 poly start=p;
2898
2899#if 0 && CLEARENUMERATORS
2900//CF: does not seem to work that well..
2901
2902 if( nCoeff_is_Q(C) || nCoeff_is_Q_a(C) )
2903 {
2905 n_ClearDenominators(itr, C);
2906 n_ClearContent(itr, C); // divide out the content
2907 p_Test(p, r); n_Test(pGetCoeff(p), C);
2908 assume(n_GreaterZero(pGetCoeff(p), C)); // ??
2909// if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
2910 return start;
2911 }
2912#endif
2913
2914 if(1)
2915 {
2916 // get lcm of all denominators ----------------------------------
2917 h = n_Init(1,C);
2918 while (p!=NULL)
2919 {
2922 n_Delete(&h,C);
2923 h=d;
2924 pIter(p);
2925 }
2926 /* h now contains the 1/lcm of all denominators */
2927 if(!n_IsOne(h,C))
2928 {
2929 // multiply by the lcm of all denominators
2930 p = start;
2931 while (p!=NULL)
2932 {
2933 d=n_Mult(h,pGetCoeff(p),C);
2934 n_Normalize(d,C);
2935 p_SetCoeff(p,d,r);
2936 pIter(p);
2937 }
2938 }
2939 n_Delete(&h,C);
2940 p=start;
2941
2942 p_ContentForGB(p,r);
2943#ifdef HAVE_RATGRING
2944 if (rIsRatGRing(r))
2945 {
2946 /* quick unit detection in the rational case is done in gr_nc_bba */
2947 p_ContentRat(p, r);
2948 start=p;
2949 }
2950#endif
2951 }
2952
2953 if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
2954
2955 return start;
2956}
This is a polynomial enumerator for simple iteration over coefficients of polynomials.
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of 'a' and 'b', i.e., a*b
Definition coeffs.h:637
static FORCE_INLINE number n_NormalizeHelper(number a, number b, const coeffs r)
assume that r is a quotient field (otherwise, return 1) for arguments (a1/a2,b1/b2) return (lcm(a1,...
Definition coeffs.h:696
static FORCE_INLINE BOOLEAN n_GreaterZero(number n, const coeffs r)
ordered fields: TRUE iff 'n' is positive; in Z/pZ: TRUE iff 0 < m <= roundedBelow(p/2),...
Definition coeffs.h:498
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
Definition coeffs.h:799
static FORCE_INLINE void n_ClearDenominators(ICoeffsEnumerator &numberCollectionEnumerator, number &d, const coeffs r)
(inplace) Clears denominators on a collection of numbers number d is the LCM of all the coefficient d...
Definition coeffs.h:932
static FORCE_INLINE BOOLEAN nCoeff_is_Q_a(const coeffs r)
Definition coeffs.h:878
static FORCE_INLINE void n_ClearContent(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs r)
Computes the content and (inplace) divides it out on a collection of numbers number c is the content ...
Definition coeffs.h:925
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition coeffs.h:579
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition coeffs.h:472
#define TEST_OPT_INTSTRATEGY
Definition options.h:112
#define TEST_OPT_CONTENTSB
Definition options.h:129
void p_ContentRat(poly &ph, const ring r)
Definition p_polys.cc:1748
void p_ContentForGB(poly ph, const ring r)
Definition p_polys.cc:2359
static poly p_Neg(poly p, const ring r)
Definition p_polys.h:1109
static BOOLEAN rIsRatGRing(const ring r)
Definition ring.h:433
#define rField_is_Ring(R)
Definition ring.h:491

◆ p_Cleardenom_n()

void p_Cleardenom_n ( poly p,
const ring r,
number & c )

Definition at line 2958 of file p_polys.cc.

2959{
2960 const coeffs C = r->cf;
2961 number d, h;
2962
2963 assume( ph != NULL );
2964
2965 poly p = ph;
2966
2967#if CLEARENUMERATORS
2968 if( 0 )
2969 {
2970 CPolyCoeffsEnumerator itr(ph);
2971
2972 n_ClearDenominators(itr, d, C); // multiply with common denom. d
2973 n_ClearContent(itr, h, C); // divide by the content h
2974
2975 c = n_Div(d, h, C); // d/h
2976
2977 n_Delete(&d, C);
2978 n_Delete(&h, C);
2979
2980 n_Test(c, C);
2981
2982 p_Test(ph, r); n_Test(pGetCoeff(ph), C);
2983 assume(n_GreaterZero(pGetCoeff(ph), C)); // ??
2984/*
2985 if(!n_GreaterZero(pGetCoeff(ph),C))
2986 {
2987 ph = p_Neg(ph,r);
2988 c = n_InpNeg(c, C);
2989 }
2990*/
2991 return;
2992 }
2993#endif
2994
2995
2996 if( pNext(p) == NULL )
2997 {
2999 {
3000 c=n_Invers(pGetCoeff(p), C);
3001 p_SetCoeff(p, n_Init(1, C), r);
3002 }
3003 else
3004 {
3005 c=n_Init(1,C);
3006 }
3007
3008 if(!n_GreaterZero(pGetCoeff(ph),C))
3009 {
3010 ph = p_Neg(ph,r);
3011 c = n_InpNeg(c, C);
3012 }
3013
3014 return;
3015 }
3016 if (TEST_OPT_CONTENTSB) { c=n_Init(1,C); return; }
3017
3018 assume( pNext(p) != NULL );
3019
3020#if CLEARENUMERATORS
3021 if( nCoeff_is_Q(C) || nCoeff_is_Q_a(C) )
3022 {
3023 CPolyCoeffsEnumerator itr(ph);
3024
3025 n_ClearDenominators(itr, d, C); // multiply with common denom. d
3026 n_ClearContent(itr, h, C); // divide by the content h
3027
3028 c = n_Div(d, h, C); // d/h
3029
3030 n_Delete(&d, C);
3031 n_Delete(&h, C);
3032
3033 n_Test(c, C);
3034
3035 p_Test(ph, r); n_Test(pGetCoeff(ph), C);
3036 assume(n_GreaterZero(pGetCoeff(ph), C)); // ??
3037/*
3038 if(!n_GreaterZero(pGetCoeff(ph),C))
3039 {
3040 ph = p_Neg(ph,r);
3041 c = n_InpNeg(c, C);
3042 }
3043*/
3044 return;
3045 }
3046#endif
3047
3048
3049
3050
3051 if(1)
3052 {
3053 h = n_Init(1,C);
3054 while (p!=NULL)
3055 {
3058 n_Delete(&h,C);
3059 h=d;
3060 pIter(p);
3061 }
3062 c=h;
3063 /* contains the 1/lcm of all denominators */
3064 if(!n_IsOne(h,C))
3065 {
3066 p = ph;
3067 while (p!=NULL)
3068 {
3069 /* should be: // NOTE: don't use ->coef!!!!
3070 * number hh;
3071 * nGetDenom(p->coef,&hh);
3072 * nMult(&h,&hh,&d);
3073 * nNormalize(d);
3074 * nDelete(&hh);
3075 * nMult(d,p->coef,&hh);
3076 * nDelete(&d);
3077 * nDelete(&(p->coef));
3078 * p->coef =hh;
3079 */
3080 d=n_Mult(h,pGetCoeff(p),C);
3081 n_Normalize(d,C);
3082 p_SetCoeff(p,d,r);
3083 pIter(p);
3084 }
3085 if (rField_is_Q_a(r))
3086 {
3087 loop
3088 {
3089 h = n_Init(1,C);
3090 p=ph;
3091 while (p!=NULL)
3092 {
3094 n_Delete(&h,C);
3095 h=d;
3096 pIter(p);
3097 }
3098 /* contains the 1/lcm of all denominators */
3099 if(!n_IsOne(h,C))
3100 {
3101 p = ph;
3102 while (p!=NULL)
3103 {
3104 /* should be: // NOTE: don't use ->coef!!!!
3105 * number hh;
3106 * nGetDenom(p->coef,&hh);
3107 * nMult(&h,&hh,&d);
3108 * nNormalize(d);
3109 * nDelete(&hh);
3110 * nMult(d,p->coef,&hh);
3111 * nDelete(&d);
3112 * nDelete(&(p->coef));
3113 * p->coef =hh;
3114 */
3115 d=n_Mult(h,pGetCoeff(p),C);
3116 n_Normalize(d,C);
3117 p_SetCoeff(p,d,r);
3118 pIter(p);
3119 }
3120 number t=n_Mult(c,h,C);
3121 n_Delete(&c,C);
3122 c=t;
3123 }
3124 else
3125 {
3126 break;
3127 }
3128 n_Delete(&h,C);
3129 }
3130 }
3131 }
3132 }
3133
3134 if(!n_GreaterZero(pGetCoeff(ph),C))
3135 {
3136 ph = p_Neg(ph,r);
3137 c = n_InpNeg(c, C);
3138 }
3139
3140}
static FORCE_INLINE number n_Invers(number a, const coeffs r)
return the multiplicative inverse of 'a'; raise an error if 'a' is not invertible
Definition coeffs.h:565
static FORCE_INLINE number n_InpNeg(number n, const coeffs r)
in-place negation of n MUST BE USED: n = n_InpNeg(n) (no copy is returned)
Definition coeffs.h:558
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of 'a' and 'b', i.e., a/b; raises an error if 'b' is not invertible in r exceptio...
Definition coeffs.h:616
static BOOLEAN rField_is_Q_a(const ring r)
Definition ring.h:545

◆ p_Cmp()

static int p_Cmp ( poly p1,
poly p2,
ring r )
inlinestatic

Definition at line 1743 of file p_polys.h.

1744{
1745 if (p2==NULL)
1746 {
1747 if (p1==NULL) return 0;
1748 return 1;
1749 }
1750 if (p1==NULL)
1751 return -1;
1752 return p_LmCmp(p1,p2,r);
1753}

◆ p_CmpPolys()

static int p_CmpPolys ( poly p1,
poly p2,
ring r )
inlinestatic

Definition at line 1755 of file p_polys.h.

1756{
1757 if (p2==NULL)
1758 {
1759 if (p1==NULL) return 0;
1760 return 1;
1761 }
1762 if (p1==NULL)
1763 return -1;
1764 return p_ComparePolys(p1,p2,r);
1765}
BOOLEAN p_ComparePolys(poly p1, poly p2, const ring r)
returns TRUE if p1 is a skalar multiple of p2 assume p1 != NULL and p2 != NULL
Definition p_polys.cc:4685

◆ p_Comp_k_n()

static int p_Comp_k_n ( poly a,
poly b,
int k,
ring r )
inlinestatic

Definition at line 642 of file p_polys.h.

643{
644 if ((a==NULL) || (b==NULL) ) return FALSE;
645 p_LmCheckPolyRing2(a, r);
647 pAssume2(k > 0 && k <= r->N);
648 int i=k;
649 for(;i<=r->N;i++)
650 {
651 if (p_GetExp(a,i,r) != p_GetExp(b,i,r)) return FALSE;
652 // if (a->exp[(r->VarOffset[i] & 0xffffff)] != b->exp[(r->VarOffset[i] & 0xffffff)]) return FALSE;
653 }
654 return TRUE;
655}
const CanonicalForm CFMap CFMap & N
Definition cfEzgcd.cc:56
int k
Definition cfEzgcd.cc:99

◆ p_Compare()

int p_Compare ( const poly a,
const poly b,
const ring R )

Definition at line 5005 of file p_polys.cc.

5006{
5007 int r=p_Cmp(a,b,R);
5008 if ((r==0)&&(a!=NULL))
5009 {
5010 number h=n_Sub(pGetCoeff(a),pGetCoeff(b),R->cf);
5011 /* compare lead coeffs */
5012 r = -1+n_IsZero(h,R->cf)+2*n_GreaterZero(h,R->cf); /* -1: <, 0:==, 1: > */
5013 n_Delete(&h,R->cf);
5014 }
5015 else if (a==NULL)
5016 {
5017 if (b==NULL)
5018 {
5019 /* compare 0, 0 */
5020 r=0;
5021 }
5022 else if(p_IsConstant(b,R))
5023 {
5024 /* compare 0, const */
5025 r = 1-2*n_GreaterZero(pGetCoeff(b),R->cf); /* -1: <, 1: > */
5026 }
5027 }
5028 else if (b==NULL)
5029 {
5030 if (p_IsConstant(a,R))
5031 {
5032 /* compare const, 0 */
5033 r = -1+2*n_GreaterZero(pGetCoeff(a),R->cf); /* -1: <, 1: > */
5034 }
5035 }
5036 return(r);
5037}
static FORCE_INLINE number n_Sub(number a, number b, const coeffs r)
return the difference of 'a' and 'b', i.e., a-b
Definition coeffs.h:656
static int p_Cmp(poly p1, poly p2, ring r)
Definition p_polys.h:1743

◆ p_ComparePolys()

BOOLEAN p_ComparePolys ( poly p1,
poly p2,
const ring r )

returns TRUE if p1 is a skalar multiple of p2 assume p1 != NULL and p2 != NULL

Definition at line 4685 of file p_polys.cc.

4686{
4687 number n,nn;
4688 pAssume(p1 != NULL && p2 != NULL);
4689
4690 if (!p_LmEqual(p1,p2,r)) //compare leading mons
4691 return FALSE;
4692 if ((pNext(p1)==NULL) && (pNext(p2)!=NULL))
4693 return FALSE;
4694 if ((pNext(p2)==NULL) && (pNext(p1)!=NULL))
4695 return FALSE;
4696 if (pLength(p1) != pLength(p2))
4697 return FALSE;
4698 #ifdef HAVE_RINGS
4699 if (rField_is_Ring(r))
4700 {
4701 if (!n_DivBy(pGetCoeff(p1), pGetCoeff(p2), r->cf)) return FALSE;
4702 }
4703 #endif
4704 n=n_Div(pGetCoeff(p1),pGetCoeff(p2),r->cf);
4705 while ((p1 != NULL) /*&& (p2 != NULL)*/)
4706 {
4707 if ( ! p_LmEqual(p1, p2,r))
4708 {
4709 n_Delete(&n, r->cf);
4710 return FALSE;
4711 }
4712 if (!n_Equal(pGetCoeff(p1), nn = n_Mult(pGetCoeff(p2),n, r->cf), r->cf))
4713 {
4714 n_Delete(&n, r->cf);
4715 n_Delete(&nn, r->cf);
4716 return FALSE;
4717 }
4718 n_Delete(&nn, r->cf);
4719 pIter(p1);
4720 pIter(p2);
4721 }
4722 n_Delete(&n, r->cf);
4723 return TRUE;
4724}
static FORCE_INLINE BOOLEAN n_DivBy(number a, number b, const coeffs r)
test whether 'a' is divisible 'b'; for r encoding a field: TRUE iff 'b' does not represent zero in Z:...
Definition coeffs.h:748
static FORCE_INLINE BOOLEAN n_Equal(number a, number b, const coeffs r)
TRUE iff 'a' and 'b' represent the same number; they may have different representations.
Definition coeffs.h:464
#define pAssume(cond)
Definition monomials.h:90
#define p_LmEqual(p1, p2, r)
Definition p_polys.h:1739

◆ p_Content()

void p_Content ( poly p,
const ring r )

Definition at line 2299 of file p_polys.cc.

2300{
2301 if (ph==NULL) return;
2302 const coeffs cf=r->cf;
2303 if (pNext(ph)==NULL)
2304 {
2305 p_SetCoeff(ph,n_Init(1,cf),r);
2306 return;
2307 }
2308 if ((cf->cfSubringGcd==ndGcd)
2309 || (cf->cfGcd==ndGcd)) /* trivial gcd*/
2310 return;
2311 number h;
2312 if ((rField_is_Q(r))
2313 || (rField_is_Q_a(r))
2314 || (rField_is_Zp_a)(r)
2315 || (rField_is_Z(r))
2316 )
2317 {
2318 h=p_InitContent(ph,r); /* first guess of a gcd of all coeffs */
2319 }
2320 else
2321 {
2322 h=n_Copy(pGetCoeff(ph),cf);
2323 }
2324 poly p;
2325 if(n_IsOne(h,cf))
2326 {
2327 goto content_finish;
2328 }
2329 p=ph;
2330 // take the SubringGcd of all coeffs
2331 while (p!=NULL)
2332 {
2334 number d=n_SubringGcd(h,pGetCoeff(p),cf);
2335 n_Delete(&h,cf);
2336 h = d;
2337 if(n_IsOne(h,cf))
2338 {
2339 goto content_finish;
2340 }
2341 pIter(p);
2342 }
2343 // if found<>1, divide by it
2344 p = ph;
2345 while (p!=NULL)
2346 {
2347 number d = n_ExactDiv(pGetCoeff(p),h,cf);
2348 p_SetCoeff(p,d,r);
2349 pIter(p);
2350 }
2351content_finish:
2352 n_Delete(&h,r->cf);
2353 // and last: check leading sign:
2354 if(!n_GreaterZero(pGetCoeff(ph),r->cf)) ph = p_Neg(ph,r);
2355}
CanonicalForm cf
Definition cfModGcd.cc:4091
static FORCE_INLINE number n_ExactDiv(number a, number b, const coeffs r)
assume that there is a canonical subring in cf and we know that division is possible for these a and ...
Definition coeffs.h:623
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
Definition coeffs.h:667
number ndGcd(number, number, const coeffs r)
Definition numbers.cc:187
number p_InitContent(poly ph, const ring r)
Definition p_polys.cc:2639
static BOOLEAN rField_is_Zp_a(const ring r)
Definition ring.h:535

◆ p_ContentForGB()

void p_ContentForGB ( poly p,
const ring r )

Definition at line 2359 of file p_polys.cc.

2360{
2361 if(TEST_OPT_CONTENTSB) return;
2362 assume( ph != NULL );
2363
2364 assume( r != NULL ); assume( r->cf != NULL );
2365
2366
2367#if CLEARENUMERATORS
2368 if( 0 )
2369 {
2370 const coeffs C = r->cf;
2371 // experimentall (recursive enumerator treatment) of alg. Ext!
2372 CPolyCoeffsEnumerator itr(ph);
2373 n_ClearContent(itr, r->cf);
2374
2375 p_Test(ph, r); n_Test(pGetCoeff(ph), C);
2376 assume(n_GreaterZero(pGetCoeff(ph), C)); // ??
2377
2378 // if(!n_GreaterZero(pGetCoeff(ph),r->cf)) ph = p_Neg(ph,r);
2379 return;
2380 }
2381#endif
2382
2383
2384#ifdef HAVE_RINGS
2385 if (rField_is_Ring(r))
2386 {
2387 if (rField_has_Units(r))
2388 {
2389 number k = n_GetUnit(pGetCoeff(ph),r->cf);
2390 if (!n_IsOne(k,r->cf))
2391 {
2392 number tmpGMP = k;
2393 k = n_Invers(k,r->cf);
2394 n_Delete(&tmpGMP,r->cf);
2395 poly h = pNext(ph);
2396 p_SetCoeff(ph, n_Mult(pGetCoeff(ph), k,r->cf),r);
2397 while (h != NULL)
2398 {
2399 p_SetCoeff(h, n_Mult(pGetCoeff(h), k,r->cf),r);
2400 pIter(h);
2401 }
2402// assume( n_GreaterZero(pGetCoeff(ph),r->cf) );
2403// if(!n_GreaterZero(pGetCoeff(ph),r->cf)) ph = p_Neg(ph,r);
2404 }
2405 n_Delete(&k,r->cf);
2406 }
2407 return;
2408 }
2409#endif
2410 number h,d;
2411 poly p;
2412
2413 if(pNext(ph)==NULL)
2414 {
2415 p_SetCoeff(ph,n_Init(1,r->cf),r);
2416 }
2417 else
2418 {
2419 assume( pNext(ph) != NULL );
2420#if CLEARENUMERATORS
2421 if( nCoeff_is_Q(r->cf) )
2422 {
2423 // experimentall (recursive enumerator treatment) of alg. Ext!
2424 CPolyCoeffsEnumerator itr(ph);
2425 n_ClearContent(itr, r->cf);
2426
2427 p_Test(ph, r); n_Test(pGetCoeff(ph), r->cf);
2428 assume(n_GreaterZero(pGetCoeff(ph), r->cf)); // ??
2429
2430 // if(!n_GreaterZero(pGetCoeff(ph),r->cf)) ph = p_Neg(ph,r);
2431 return;
2432 }
2433#endif
2434
2435 n_Normalize(pGetCoeff(ph),r->cf);
2436 if(!n_GreaterZero(pGetCoeff(ph),r->cf)) ph = p_Neg(ph,r);
2437 if (rField_is_Q(r)||(getCoeffType(r->cf)==n_transExt)) // should not be used anymore if CLEARENUMERATORS is 1
2438 {
2439 h=p_InitContent(ph,r);
2440 p=ph;
2441 }
2442 else
2443 {
2444 h=n_Copy(pGetCoeff(ph),r->cf);
2445 p = pNext(ph);
2446 }
2447 while (p!=NULL)
2448 {
2449 n_Normalize(pGetCoeff(p),r->cf);
2450 d=n_SubringGcd(h,pGetCoeff(p),r->cf);
2451 n_Delete(&h,r->cf);
2452 h = d;
2453 if(n_IsOne(h,r->cf))
2454 {
2455 break;
2456 }
2457 pIter(p);
2458 }
2459 //number tmp;
2460 if(!n_IsOne(h,r->cf))
2461 {
2462 p = ph;
2463 while (p!=NULL)
2464 {
2465 //d = nDiv(pGetCoeff(p),h);
2466 //tmp = nExactDiv(pGetCoeff(p),h);
2467 //if (!nEqual(d,tmp))
2468 //{
2469 // StringSetS("** div0:");nWrite(pGetCoeff(p));StringAppendS("/");
2470 // nWrite(h);StringAppendS("=");nWrite(d);StringAppendS(" int:");
2471 // nWrite(tmp);Print(StringEndS("\n")); // NOTE/TODO: use StringAppendS("\n"); omFree(s);
2472 //}
2473 //nDelete(&tmp);
2474 d = n_ExactDiv(pGetCoeff(p),h,r->cf);
2475 p_SetCoeff(p,d,r);
2476 pIter(p);
2477 }
2478 }
2479 n_Delete(&h,r->cf);
2480 if (rField_is_Q_a(r))
2481 {
2482 // special handling for alg. ext.:
2483 if (getCoeffType(r->cf)==n_algExt)
2484 {
2485 h = n_Init(1, r->cf->extRing->cf);
2486 p=ph;
2487 while (p!=NULL)
2488 { // each monom: coeff in Q_a
2489 poly c_n_n=(poly)pGetCoeff(p);
2490 poly c_n=c_n_n;
2491 while (c_n!=NULL)
2492 { // each monom: coeff in Q
2493 d=n_NormalizeHelper(h,pGetCoeff(c_n),r->cf->extRing->cf);
2494 n_Delete(&h,r->cf->extRing->cf);
2495 h=d;
2496 pIter(c_n);
2497 }
2498 pIter(p);
2499 }
2500 /* h contains the 1/lcm of all denominators in c_n_n*/
2501 //n_Normalize(h,r->cf->extRing->cf);
2502 if(!n_IsOne(h,r->cf->extRing->cf))
2503 {
2504 p=ph;
2505 while (p!=NULL)
2506 { // each monom: coeff in Q_a
2507 poly c_n=(poly)pGetCoeff(p);
2508 while (c_n!=NULL)
2509 { // each monom: coeff in Q
2510 d=n_Mult(h,pGetCoeff(c_n),r->cf->extRing->cf);
2511 n_Normalize(d,r->cf->extRing->cf);
2512 n_Delete(&pGetCoeff(c_n),r->cf->extRing->cf);
2513 pGetCoeff(c_n)=d;
2514 pIter(c_n);
2515 }
2516 pIter(p);
2517 }
2518 }
2519 n_Delete(&h,r->cf->extRing->cf);
2520 }
2521 /*else
2522 {
2523 // special handling for rat. functions.:
2524 number hzz =NULL;
2525 p=ph;
2526 while (p!=NULL)
2527 { // each monom: coeff in Q_a (Z_a)
2528 fraction f=(fraction)pGetCoeff(p);
2529 poly c_n=NUM(f);
2530 if (hzz==NULL)
2531 {
2532 hzz=n_Copy(pGetCoeff(c_n),r->cf->extRing->cf);
2533 pIter(c_n);
2534 }
2535 while ((c_n!=NULL)&&(!n_IsOne(hzz,r->cf->extRing->cf)))
2536 { // each monom: coeff in Q (Z)
2537 d=n_Gcd(hzz,pGetCoeff(c_n),r->cf->extRing->cf);
2538 n_Delete(&hzz,r->cf->extRing->cf);
2539 hzz=d;
2540 pIter(c_n);
2541 }
2542 pIter(p);
2543 }
2544 // hzz contains the gcd of all numerators in f
2545 h=n_Invers(hzz,r->cf->extRing->cf);
2546 n_Delete(&hzz,r->cf->extRing->cf);
2547 n_Normalize(h,r->cf->extRing->cf);
2548 if(!n_IsOne(h,r->cf->extRing->cf))
2549 {
2550 p=ph;
2551 while (p!=NULL)
2552 { // each monom: coeff in Q_a (Z_a)
2553 fraction f=(fraction)pGetCoeff(p);
2554 NUM(f)=__p_Mult_nn(NUM(f),h,r->cf->extRing);
2555 p_Normalize(NUM(f),r->cf->extRing);
2556 pIter(p);
2557 }
2558 }
2559 n_Delete(&h,r->cf->extRing->cf);
2560 }*/
2561 }
2562 }
2563 if(!n_GreaterZero(pGetCoeff(ph),r->cf)) ph = p_Neg(ph,r);
2564}
@ n_algExt
used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic
Definition coeffs.h:35
@ n_transExt
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
Definition coeffs.h:38
static FORCE_INLINE number n_GetUnit(number n, const coeffs r)
in Z: 1 in Z/kZ (where k is not a prime): largest divisor of n (taken in Z) that is co-prime with k i...
Definition coeffs.h:535
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition coeffs.h:429
static BOOLEAN rField_has_Units(const ring r)
Definition ring.h:496

◆ p_ContentRat()

void p_ContentRat ( poly & ph,
const ring r )

Definition at line 1748 of file p_polys.cc.

1751{
1752 // init array of RatLeadCoeffs
1753 // poly p_GetCoeffRat(poly p, int ishift, ring r);
1754
1755 int len=pLength(ph);
1756 poly *C = (poly *)omAlloc0((len+1)*sizeof(poly)); //rat coeffs
1757 poly *LM = (poly *)omAlloc0((len+1)*sizeof(poly)); // rat lead terms
1758 int *D = (int *)omAlloc0((len+1)*sizeof(int)); //degrees of coeffs
1759 int *L = (int *)omAlloc0((len+1)*sizeof(int)); //lengths of coeffs
1760 int k = 0;
1761 poly p = p_Copy(ph, r); // ph will be needed below
1762 int mintdeg = p_Totaldegree(p, r);
1763 int minlen = len;
1764 int dd = 0; int i;
1765 int HasConstantCoef = 0;
1766 int is = r->real_var_start - 1;
1767 while (p!=NULL)
1768 {
1769 LM[k] = p_GetExp_k_n(p,1,is, r); // need LmRat instead of p_HeadRat(p, is, currRing); !
1770 C[k] = p_GetCoeffRat(p, is, r);
1771 D[k] = p_Totaldegree(C[k], r);
1772 mintdeg = si_min(mintdeg,D[k]);
1773 L[k] = pLength(C[k]);
1774 minlen = si_min(minlen,L[k]);
1775 if (p_IsConstant(C[k], r))
1776 {
1777 // C[k] = const, so the content will be numerical
1778 HasConstantCoef = 1;
1779 // smth like goto cleanup and return(pContent(p));
1780 }
1781 p_LmDeleteAndNextRat(&p, is, r);
1782 k++;
1783 }
1784
1785 // look for 1 element of minimal degree and of minimal length
1786 k--;
1787 poly d;
1788 int mindeglen = len;
1789 if (k<=0) // this poly is not a ratgring poly -> pContent
1790 {
1791 p_Delete(&C[0], r);
1792 p_Delete(&LM[0], r);
1793 p_ContentForGB(ph, r);
1794 goto cleanup;
1795 }
1796
1797 int pmindeglen;
1798 for(i=0; i<=k; i++)
1799 {
1800 if (D[i] == mintdeg)
1801 {
1802 if (L[i] < mindeglen)
1803 {
1804 mindeglen=L[i];
1805 pmindeglen = i;
1806 }
1807 }
1808 }
1809 d = p_Copy(C[pmindeglen], r);
1810 // there are dd>=1 mindeg elements
1811 // and pmideglen is the coordinate of one of the smallest among them
1812
1813 // poly g = singclap_gcd(p_Copy(p,r),p_Copy(q,r));
1814 // return naGcd(d,d2,currRing);
1815
1816 // adjoin pContentRat here?
1817 for(i=0; i<=k; i++)
1818 {
1819 d=singclap_gcd(d,p_Copy(C[i], r), r);
1820 if (p_Totaldegree(d, r)==0)
1821 {
1822 // cleanup, pContent, return
1823 p_Delete(&d, r);
1824 for(;k>=0;k--)
1825 {
1826 p_Delete(&C[k], r);
1827 p_Delete(&LM[k], r);
1828 }
1829 p_ContentForGB(ph, r);
1830 goto cleanup;
1831 }
1832 }
1833 for(i=0; i<=k; i++)
1834 {
1835 poly h=singclap_pdivide(C[i],d, r);
1836 p_Delete(&C[i], r);
1837 C[i]=h;
1838 }
1839
1840 // zusammensetzen,
1841 p=NULL; // just to be sure
1842 for(i=0; i<=k; i++)
1843 {
1844 p = p_Add_q(p, p_Mult_q(C[i],LM[i], r), r);
1845 C[i]=NULL; LM[i]=NULL;
1846 }
1847 p_Delete(&ph, r); // do not need it anymore
1848 ph = p;
1849 // aufraeumen, return
1850cleanup:
1851 omFree(C);
1852 omFree(LM);
1853 omFree(D);
1854 omFree(L);
1855}
poly singclap_pdivide(poly f, poly g, const ring r)
Definition clapsing.cc:624
#define D(A)
Definition gentable.cc:128
#define omFree(addr)
void p_LmDeleteAndNextRat(poly *p, int ishift, ring r)
Definition p_polys.cc:1704
poly p_GetCoeffRat(poly p, int ishift, ring r)
Definition p_polys.cc:1726
static poly p_Add_q(poly p, poly q, const ring r)
Definition p_polys.h:938
static poly p_Mult_q(poly p, poly q, const ring r)
Definition p_polys.h:1120
static poly p_GetExp_k_n(poly p, int l, int k, const ring r)
Definition p_polys.h:1388
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition p_polys.h:848
static long p_Totaldegree(poly p, const ring r)
Definition p_polys.h:1523
poly singclap_gcd(poly f, poly g, const ring r)
polynomial gcd via singclap_gcd_r resp. idSyzygies destroys f and g
Definition polys.cc:383

◆ p_Copy() [1/2]

static poly p_Copy ( poly p,
const ring lmRing,
const ring tailRing )
inlinestatic

returns a copy of p with Lm(p) from lmRing and Tail(p) from tailRing

Definition at line 885 of file p_polys.h.

886{
887 if (p != NULL)
888 {
889#ifndef PDEBUG
890 if (tailRing == lmRing)
891 return p_Copy_noCheck(p, tailRing);
892#endif
893 poly pres = p_Head(p, lmRing);
894 if (pNext(p)!=NULL)
895 pNext(pres) = p_Copy_noCheck(pNext(p), tailRing);
896 return pres;
897 }
898 else
899 return NULL;
900}
static poly p_Copy_noCheck(poly p, const ring r)
returns a copy of p (without any additional testing)
Definition p_polys.h:838

◆ p_Copy() [2/2]

static poly p_Copy ( poly p,
const ring r )
inlinestatic

returns a copy of p

Definition at line 848 of file p_polys.h.

849{
850 if (p!=NULL)
851 {
852 p_Test(p,r);
853 const poly pp = p_Copy_noCheck(p, r);
854 p_Test(pp,r);
855 return pp;
856 }
857 else
858 return NULL;
859}
CanonicalForm FACTORY_PUBLIC pp(const CanonicalForm &)
CanonicalForm pp ( const CanonicalForm & f )
Definition cf_gcd.cc:676

◆ p_Copy_noCheck()

static poly p_Copy_noCheck ( poly p,
const ring r )
inlinestatic

returns a copy of p (without any additional testing)

Definition at line 838 of file p_polys.h.

839{
840 /*assume(p!=NULL);*/
841 assume(r != NULL);
842 assume(r->p_Procs != NULL);
843 assume(r->p_Procs->p_Copy != NULL);
844 return r->p_Procs->p_Copy(p, r);
845}

◆ p_CopyPowerProduct()

poly p_CopyPowerProduct ( const poly p,
const ring r )

like p_Head, but with coefficient 1

Definition at line 5089 of file p_polys.cc.

5090{
5091 if (p == NULL) return NULL;
5092 return p_CopyPowerProduct0(p,n_Init(1,r->cf),r);
5093}
poly p_CopyPowerProduct0(const poly p, number n, const ring r)
like p_Head, but with coefficient n
Definition p_polys.cc:5077

◆ p_CopyPowerProduct0()

poly p_CopyPowerProduct0 ( const poly p,
const number n,
const ring r )

like p_Head, but with coefficient n

Definition at line 5077 of file p_polys.cc.

5078{
5080 poly np;
5081 omTypeAllocBin(poly, np, r->PolyBin);
5082 p_SetRingOfLm(np, r);
5083 memcpy(np->exp, p->exp, r->ExpL_Size*sizeof(long));
5084 pNext(np) = NULL;
5085 pSetCoeff0(np, n);
5086 return np;
5087}
#define p_LmCheckPolyRing1(p, r)
Definition monomials.h:177
#define pSetCoeff0(p, n)
Definition monomials.h:59
#define p_SetRingOfLm(p, r)
Definition monomials.h:144
#define omTypeAllocBin(type, addr, bin)

◆ p_DecrExp()

static long p_DecrExp ( poly p,
int v,
ring r )
inlinestatic

Definition at line 600 of file p_polys.h.

601{
603 int e = p_GetExp(p,v,r);
604 pAssume2(e > 0);
605 e--;
606 return p_SetExp(p,v,e,r);
607}

◆ p_Deg()

long p_Deg ( poly a,
const ring r )

Definition at line 586 of file p_polys.cc.

587{
588 p_LmCheckPolyRing(a, r);
589// assume(p_GetOrder(a, r) == p_WTotaldegree(a, r)); // WRONG assume!
590 return p_GetOrder(a, r);
591}
BOOLEAN p_LmCheckPolyRing(poly p, ring r)
Definition pDebug.cc:123
static long p_GetOrder(poly p, ring r)
Definition p_polys.h:423

◆ p_DegW()

long p_DegW ( poly p,
const int * w,
const ring R )

Definition at line 691 of file p_polys.cc.

692{
693 p_Test(p, R);
694 assume( w != NULL );
695 long r=-LONG_MAX;
696
697 while (p!=NULL)
698 {
699 long t=totaldegreeWecart_IV(p,R,w);
700 if (t>r) r=t;
701 pIter(p);
702 }
703 return r;
704}
const CanonicalForm & w
Definition facAbsFact.cc:51
long totaldegreeWecart_IV(poly p, ring r, const int *w)
Definition weight.cc:231

◆ p_Delete() [1/2]

static void p_Delete ( poly * p,
const ring lmRing,
const ring tailRing )
inlinestatic

Definition at line 910 of file p_polys.h.

911{
912 assume( p!= NULL );
913 if (*p != NULL)
914 {
915#ifndef PDEBUG
916 if (tailRing == lmRing)
917 {
918 p_Delete(p, tailRing);
919 return;
920 }
921#endif
922 if (pNext(*p) != NULL)
923 p_Delete(&pNext(*p), tailRing);
924 p_LmDelete(p, lmRing);
925 }
926}
static void p_LmDelete(poly p, const ring r)
Definition p_polys.h:725

◆ p_Delete() [2/2]

static void p_Delete ( poly * p,
const ring r )
inlinestatic

Definition at line 903 of file p_polys.h.

904{
905 assume( p!= NULL );
906 assume( r!= NULL );
907 if ((*p)!=NULL) r->p_Procs->p_Delete(p, r);
908}

◆ p_DeleteComp()

void p_DeleteComp ( poly * p,
int k,
const ring r )

Definition at line 3623 of file p_polys.cc.

3624{
3625 poly q;
3626 long unsigned kk=k;
3627
3628 while ((*p!=NULL) && (__p_GetComp(*p,r)==kk)) p_LmDelete(p,r);
3629 if (*p==NULL) return;
3630 q = *p;
3631 if (__p_GetComp(q,r)>kk)
3632 {
3633 p_SubComp(q,1,r);
3634 p_SetmComp(q,r);
3635 }
3636 while (pNext(q)!=NULL)
3637 {
3638 unsigned long c=__p_GetComp(pNext(q),r);
3639 if (/*__p_GetComp(pNext(q),r)*/c==kk)
3640 p_LmDelete(&(pNext(q)),r);
3641 else
3642 {
3643 pIter(q);
3644 if (/*__p_GetComp(q,r)*/c>kk)
3645 {
3646 p_SubComp(q,1,r);
3647 p_SetmComp(q,r);
3648 }
3649 }
3650 }
3651}
static unsigned long p_SubComp(poly p, unsigned long v, ring r)
Definition p_polys.h:455
#define p_SetmComp
Definition p_polys.h:246

◆ p_Diff()

poly p_Diff ( poly a,
int k,
const ring r )

Definition at line 1902 of file p_polys.cc.

1903{
1904 poly res, f, last;
1905 number t;
1906
1907 last = res = NULL;
1908 while (a!=NULL)
1909 {
1910 if (p_GetExp(a,k,r)!=0)
1911 {
1912 f = p_LmInit(a,r);
1913 t = n_Init(p_GetExp(a,k,r),r->cf);
1914 pSetCoeff0(f,n_Mult(t,pGetCoeff(a),r->cf));
1915 n_Delete(&t,r->cf);
1916 if (n_IsZero(pGetCoeff(f),r->cf))
1917 p_LmDelete(&f,r);
1918 else
1919 {
1920 p_DecrExp(f,k,r);
1921 p_Setm(f,r);
1922 if (res==NULL)
1923 {
1924 res=last=f;
1925 }
1926 else
1927 {
1928 pNext(last)=f;
1929 last=f;
1930 }
1931 }
1932 }
1933 pIter(a);
1934 }
1935 return res;
1936}
FILE * f
Definition checklibs.c:9
STATIC_VAR poly last
Definition hdegree.cc:1137
static poly p_LmInit(poly p, const ring r)
Definition p_polys.h:1351
static void p_Setm(poly p, const ring r)
Definition p_polys.h:235
static long p_DecrExp(poly p, int v, ring r)
Definition p_polys.h:600

◆ p_DiffOp()

poly p_DiffOp ( poly a,
poly b,
BOOLEAN multiply,
const ring r )

Definition at line 1977 of file p_polys.cc.

1978{
1979 poly result=NULL;
1980 poly h;
1981 for(;a!=NULL;pIter(a))
1982 {
1983 for(h=b;h!=NULL;pIter(h))
1984 {
1985 result=p_Add_q(result,p_DiffOpM(a,h,multiply,r),r);
1986 }
1987 }
1988 return result;
1989}
return result
static poly p_DiffOpM(poly a, poly b, BOOLEAN multiply, const ring r)
Definition p_polys.cc:1938

◆ p_Div_mm()

poly p_Div_mm ( poly p,
const poly m,
const ring r )

divide polynomial by monomial

Definition at line 1542 of file p_polys.cc.

1543{
1544 p_Test(p, r);
1545 p_Test(m, r);
1546 poly result = p;
1547 poly prev = NULL;
1548 number n=pGetCoeff(m);
1549 while (p!=NULL)
1550 {
1551 number nc = n_Div(pGetCoeff(p),n,r->cf);
1552 n_Normalize(nc,r->cf);
1553 if (!n_IsZero(nc,r->cf))
1554 {
1555 p_SetCoeff(p,nc,r);
1556 prev=p;
1557 p_ExpVectorSub(p,m,r);
1558 pIter(p);
1559 }
1560 else
1561 {
1562 if (prev==NULL)
1563 {
1564 p_LmDelete(&result,r);
1565 p=result;
1566 }
1567 else
1568 {
1569 p_LmDelete(&pNext(prev),r);
1570 p=pNext(prev);
1571 }
1572 }
1573 }
1574 p_Test(result,r);
1575 return(result);
1576}
int m
Definition cfEzgcd.cc:128
static void p_ExpVectorSub(poly p1, poly p2, const ring r)
Definition p_polys.h:1456

◆ p_Div_nn()

poly p_Div_nn ( poly p,
const number n,
const ring r )

Definition at line 1506 of file p_polys.cc.

1507{
1508 pAssume(!n_IsZero(n,r->cf));
1509 p_Test(p, r);
1510 poly result = p;
1511 poly prev = NULL;
1512 if (!n_IsOne(n,r->cf))
1513 {
1514 while (p!=NULL)
1515 {
1516 number nc = n_Div(pGetCoeff(p),n,r->cf);
1517 if (!n_IsZero(nc,r->cf))
1518 {
1519 p_SetCoeff(p,nc,r);
1520 prev=p;
1521 pIter(p);
1522 }
1523 else
1524 {
1525 if (prev==NULL)
1526 {
1527 p_LmDelete(&result,r);
1528 p=result;
1529 }
1530 else
1531 {
1532 p_LmDelete(&pNext(prev),r);
1533 p=pNext(prev);
1534 }
1535 }
1536 }
1537 p_Test(result,r);
1538 }
1539 return(result);
1540}

◆ p_DivideM()

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

Definition at line 1582 of file p_polys.cc.

1583{
1584 if (a==NULL) { p_Delete(&b,r); return NULL; }
1585 poly result=a;
1586
1587 if(!p_IsConstant(b,r))
1588 {
1589 if (rIsNCRing(r))
1590 {
1591 WerrorS("p_DivideM not implemented for non-commuative rings");
1592 return NULL;
1593 }
1594 poly prev=NULL;
1595 while (a!=NULL)
1596 {
1597 if (p_DivisibleBy(b,a,r))
1598 {
1599 p_ExpVectorSub(a,b,r);
1600 prev=a;
1601 pIter(a);
1602 }
1603 else
1604 {
1605 if (prev==NULL)
1606 {
1607 p_LmDelete(&result,r);
1608 a=result;
1609 }
1610 else
1611 {
1612 p_LmDelete(&pNext(prev),r);
1613 a=pNext(prev);
1614 }
1615 }
1616 }
1617 }
1618 if (result!=NULL)
1619 {
1620 number inv=pGetCoeff(b);
1621 //if ((!rField_is_Ring(r)) || n_IsUnit(inv,r->cf))
1622 if (rField_is_Zp(r))
1623 {
1624 inv = n_Invers(inv,r->cf);
1625 __p_Mult_nn(result,inv,r);
1626 n_Delete(&inv, r->cf);
1627 }
1628 else
1629 {
1630 result = p_Div_nn(result,inv,r);
1631 }
1632 }
1633 p_Delete(&b, r);
1634 return result;
1635}
static BOOLEAN p_DivisibleBy(poly a, poly b, const ring r)
Definition p_polys.h:1916
#define __p_Mult_nn(p, n, r)
Definition p_polys.h:973
static BOOLEAN rIsNCRing(const ring r)
Definition ring.h:427

◆ p_DivisibleBy()

static BOOLEAN p_DivisibleBy ( poly a,
poly b,
const ring r )
inlinestatic

Definition at line 1916 of file p_polys.h.

1917{
1919 pIfThen1(a!=NULL, p_LmCheckPolyRing1(a, r));
1920
1921 if (a != NULL && (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r)))
1922 return _p_LmDivisibleByNoComp(a,b,r);
1923 return FALSE;
1924}
#define pIfThen1(cond, check)
Definition monomials.h:179

◆ 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), 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 1646 of file p_polys.cc.

1647{
1648 int exponent;
1649 for(int i = (int)rVar(r); i>0; i--)
1650 {
1651 exponent = p_GetExp(g, i, r) - p_GetExp(f, i, r);
1652 if (exponent < 0) return FALSE;
1653 }
1654 return n_DivBy(pGetCoeff(g), pGetCoeff(f), r->cf);
1655}
g
Definition cfModGcd.cc:4098
#define exponent

◆ p_EqualPolys() [1/2]

BOOLEAN p_EqualPolys ( poly p1,
poly p2,
const ring r )

Definition at line 4621 of file p_polys.cc.

4622{
4623 while ((p1 != NULL) && (p2 != NULL))
4624 {
4625 if (! p_LmEqual(p1, p2,r))
4626 return FALSE;
4627 if (! n_Equal(p_GetCoeff(p1,r), p_GetCoeff(p2,r),r->cf ))
4628 return FALSE;
4629 pIter(p1);
4630 pIter(p2);
4631 }
4632 return (p1==p2);
4633}
#define p_GetCoeff(p, r)
Definition monomials.h:50

◆ p_EqualPolys() [2/2]

BOOLEAN p_EqualPolys ( poly p1,
poly p2,
const ring r1,
const ring r2 )

same as the usual p_EqualPolys for polys belonging to equal rings

Definition at line 4659 of file p_polys.cc.

4660{
4661 assume( r1 == r2 || rSamePolyRep(r1, r2) ); // will be used in rEqual!
4662 assume( r1->cf == r2->cf );
4663
4664 while ((p1 != NULL) && (p2 != NULL))
4665 {
4666 // returns 1 if ExpVector(p)==ExpVector(q): does not compare numbers !!
4667 // #define p_LmEqual(p1, p2, r) p_ExpVectorEqual(p1, p2, r)
4668
4669 if (! p_ExpVectorEqual(p1, p2, r1, r2))
4670 return FALSE;
4671
4672 if (! n_Equal(p_GetCoeff(p1,r1), p_GetCoeff(p2,r2), r1->cf ))
4673 return FALSE;
4674
4675 pIter(p1);
4676 pIter(p2);
4677 }
4678 return (p1==p2);
4679}
BOOLEAN rSamePolyRep(ring r1, ring r2)
returns TRUE, if r1 and r2 represents the monomials in the same way FALSE, otherwise this is an analo...
Definition ring.cc:1804

◆ p_ExpVectorAdd()

static void p_ExpVectorAdd ( poly p1,
poly p2,
const ring r )
inlinestatic

Definition at line 1427 of file p_polys.h.

1428{
1429 p_LmCheckPolyRing1(p1, r);
1430 p_LmCheckPolyRing1(p2, r);
1431#if PDEBUG >= 1
1432 for (int i=1; i<=r->N; i++)
1433 pAssume1((unsigned long) (p_GetExp(p1, i, r) + p_GetExp(p2, i, r)) <= r->bitmask);
1434 pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0);
1435#endif
1436
1437 p_MemAdd_LengthGeneral(p1->exp, p2->exp, r->ExpL_Size);
1439}
#define p_MemAdd_LengthGeneral(r, s, length)
Definition p_MemAdd.h:173
static void p_MemAdd_NegWeightAdjust(poly p, const ring r)
Definition p_polys.h:1308

◆ p_ExpVectorAddSub()

static void p_ExpVectorAddSub ( poly p1,
poly p2,
poly p3,
const ring r )
inlinestatic

Definition at line 1472 of file p_polys.h.

1473{
1474 p_LmCheckPolyRing1(p1, r);
1475 p_LmCheckPolyRing1(p2, r);
1476 p_LmCheckPolyRing1(p3, r);
1477#if PDEBUG >= 1
1478 for (int i=1; i<=r->N; i++)
1479 pAssume1(p_GetExp(p1, i, r) + p_GetExp(p2, i, r) >= p_GetExp(p3, i, r));
1480 pAssume1(p_GetComp(p1, r) == 0 ||
1481 (p_GetComp(p2, r) - p_GetComp(p3, r) == 0) ||
1482 (p_GetComp(p1, r) == p_GetComp(p2, r) - p_GetComp(p3, r)));
1483#endif
1484
1485 p_MemAddSub_LengthGeneral(p1->exp, p2->exp, p3->exp, r->ExpL_Size);
1486 // no need to adjust in case of NegWeights
1487}
#define p_MemAddSub_LengthGeneral(r, s, t, length)
Definition p_MemAdd.h:312

◆ p_ExpVectorCopy()

static void p_ExpVectorCopy ( poly d_p,
poly s_p,
const ring r )
inlinestatic

Definition at line 1329 of file p_polys.h.

1330{
1331 p_LmCheckPolyRing1(d_p, r);
1332 p_LmCheckPolyRing1(s_p, r);
1333 memcpy(d_p->exp, s_p->exp, r->ExpL_Size*sizeof(long));
1334}

◆ p_ExpVectorDiff()

static void p_ExpVectorDiff ( poly pr,
poly p1,
poly p2,
const ring r )
inlinestatic

Definition at line 1490 of file p_polys.h.

1491{
1492 p_LmCheckPolyRing1(p1, r);
1493 p_LmCheckPolyRing1(p2, r);
1494 p_LmCheckPolyRing1(pr, r);
1495#if PDEBUG >= 2
1496 for (int i=1; i<=r->N; i++)
1497 pAssume1(p_GetExp(p1, i, r) >= p_GetExp(p2, i, r));
1498 pAssume1(!rRing_has_Comp(r) || p_GetComp(p1, r) == p_GetComp(p2, r));
1499#endif
1500
1501 p_MemDiff_LengthGeneral(pr->exp, p1->exp, p2->exp, r->ExpL_Size);
1503}
#define p_MemDiff_LengthGeneral(r, s1, s2, length)
Definition p_MemAdd.h:262
static void p_MemSub_NegWeightAdjust(poly p, const ring r)
Definition p_polys.h:1318

◆ p_ExpVectorEqual()

static BOOLEAN p_ExpVectorEqual ( poly p1,
poly p2,
const ring r )
inlinestatic

Definition at line 1505 of file p_polys.h.

1506{
1507 p_LmCheckPolyRing1(p1, r);
1508 p_LmCheckPolyRing1(p2, r);
1509
1510 unsigned i = r->ExpL_Size;
1511 unsigned long *ep = p1->exp;
1512 unsigned long *eq = p2->exp;
1513
1514 do
1515 {
1516 i--;
1517 if (ep[i] != eq[i]) return FALSE;
1518 }
1519 while (i!=0);
1520 return TRUE;
1521}

◆ p_ExpVectorSub()

static void p_ExpVectorSub ( poly p1,
poly p2,
const ring r )
inlinestatic

Definition at line 1456 of file p_polys.h.

1457{
1458 p_LmCheckPolyRing1(p1, r);
1459 p_LmCheckPolyRing1(p2, r);
1460#if PDEBUG >= 1
1461 for (int i=1; i<=r->N; i++)
1462 pAssume1(p_GetExp(p1, i, r) >= p_GetExp(p2, i, r));
1463 pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0 ||
1464 p_GetComp(p1, r) == p_GetComp(p2, r));
1465#endif
1466
1467 p_MemSub_LengthGeneral(p1->exp, p2->exp, r->ExpL_Size);
1469}
#define p_MemSub_LengthGeneral(r, s, length)
Definition p_MemAdd.h:291

◆ p_ExpVectorSum()

static void p_ExpVectorSum ( poly pr,
poly p1,
poly p2,
const ring r )
inlinestatic

Definition at line 1441 of file p_polys.h.

1442{
1443 p_LmCheckPolyRing1(p1, r);
1444 p_LmCheckPolyRing1(p2, r);
1445 p_LmCheckPolyRing1(pr, r);
1446#if PDEBUG >= 1
1447 for (int i=1; i<=r->N; i++)
1448 pAssume1((unsigned long) (p_GetExp(p1, i, r) + p_GetExp(p2, i, r)) <= r->bitmask);
1449 pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0);
1450#endif
1451
1452 p_MemSum_LengthGeneral(pr->exp, p1->exp, p2->exp, r->ExpL_Size);
1454}
#define p_MemSum_LengthGeneral(r, s1, s2, length)
Definition p_MemAdd.h:86

◆ p_Farey()

poly p_Farey ( poly p,
number N,
const ring r )

Definition at line 54 of file p_polys.cc.

55{
56 poly h=p_Copy(p,r);
57 poly hh=h;
58 while(h!=NULL)
59 {
60 number c=pGetCoeff(h);
61 pSetCoeff0(h,n_Farey(c,N,r->cf));
62 n_Delete(&c,r->cf);
63 pIter(h);
64 }
65 while((hh!=NULL)&&(n_IsZero(pGetCoeff(hh),r->cf)))
66 {
67 p_LmDelete(&hh,r);
68 }
69 h=hh;
70 while((h!=NULL) && (pNext(h)!=NULL))
71 {
72 if(n_IsZero(pGetCoeff(pNext(h)),r->cf))
73 {
74 p_LmDelete(&pNext(h),r);
75 }
76 else pIter(h);
77 }
78 return hh;
79}
static FORCE_INLINE number n_Farey(number a, number b, const coeffs r)
Definition coeffs.h:760

◆ p_FDeg()

static long p_FDeg ( const poly p,
const ring r )
inlinestatic

Definition at line 382 of file p_polys.h.

382{ return r->pFDeg(p,r); }

◆ p_GcdMon()

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

polynomial gcd for f=mon

Definition at line 5039 of file p_polys.cc.

5040{
5041 assume(f!=NULL);
5042 assume(g!=NULL);
5043 assume(pNext(f)==NULL);
5044 poly G=p_Head(f,r);
5045 poly h=g;
5046 int *mf=(int*)omAlloc((r->N+1)*sizeof(int));
5047 p_GetExpV(f,mf,r);
5048 int *mh=(int*)omAlloc((r->N+1)*sizeof(int));
5049 BOOLEAN const_mon;
5050 BOOLEAN one_coeff=n_IsOne(pGetCoeff(G),r->cf);
5051 loop
5052 {
5053 if (h==NULL) break;
5054 if(!one_coeff)
5055 {
5056 number n=n_SubringGcd(pGetCoeff(G),pGetCoeff(h),r->cf);
5057 one_coeff=n_IsOne(n,r->cf);
5058 p_SetCoeff(G,n,r);
5059 }
5060 p_GetExpV(h,mh,r);
5061 const_mon=TRUE;
5062 for(unsigned j=r->N;j!=0;j--)
5063 {
5064 if (mh[j]<mf[j]) mf[j]=mh[j];
5065 if (mf[j]>0) const_mon=FALSE;
5066 }
5067 if (one_coeff && const_mon) break;
5068 pIter(h);
5069 }
5070 mf[0]=0;
5071 p_SetExpV(G,mf,r); // included is p_SetComp, p_Setm
5072 omFreeSize(mf,(r->N+1)*sizeof(int));
5073 omFreeSize(mh,(r->N+1)*sizeof(int));
5074 return G;
5075}
STATIC_VAR TreeM * G
Definition janet.cc:31
#define omAlloc(size)
static void p_SetExpV(poly p, int *ev, const ring r)
Definition p_polys.h:1560
static void p_GetExpV(poly p, int *ev, const ring r)
Definition p_polys.h:1536

◆ p_GetCoeffRat()

poly p_GetCoeffRat ( poly p,
int ishift,
ring r )

Definition at line 1726 of file p_polys.cc.

1727{
1728 poly q = pNext(p);
1729 poly res; // = p_Head(p,r);
1730 res = p_GetExp_k_n(p, ishift+1, r->N, r); // does pSetm internally
1731 p_SetCoeff(res,n_Copy(p_GetCoeff(p,r),r),r);
1732 poly s;
1733 long cmp = p_GetComp(p, r);
1734 while ( (q!= NULL) && (p_Comp_k_n(p, q, ishift+1, r)) && (p_GetComp(q, r) == cmp) )
1735 {
1736 s = p_GetExp_k_n(q, ishift+1, r->N, r);
1737 p_SetCoeff(s,n_Copy(p_GetCoeff(q,r),r),r);
1738 res = p_Add_q(res,s,r);
1739 q = pNext(q);
1740 }
1741 cmp = 0;
1742 p_SetCompP(res,cmp,r);
1743 return res;
1744}
const CanonicalForm int s
Definition facAbsFact.cc:51
static int p_Comp_k_n(poly a, poly b, int k, ring r)
Definition p_polys.h:642
static void p_SetCompP(poly p, int i, ring r)
Definition p_polys.h:256

◆ p_GetExp() [1/3]

static long p_GetExp ( const poly p,
const int v,
const ring r )
inlinestatic

get v^th exponent for a monomial

Definition at line 574 of file p_polys.h.

575{
577 pAssume2(v>0 && v <= r->N);
578 pAssume2(r->VarOffset[v] != -1);
579 return p_GetExp(p, r->bitmask, r->VarOffset[v]);
580}

◆ p_GetExp() [2/3]

static long p_GetExp ( const poly p,
const ring r,
const int VarOffset )
inlinestatic

Definition at line 557 of file p_polys.h.

558{
560 pAssume2(VarOffset != -1);
561 return p_GetExp(p, r->bitmask, VarOffset);
562}

◆ p_GetExp() [3/3]

static long p_GetExp ( const poly p,
const unsigned long iBitmask,
const int VarOffset )
inlinestatic

get a single variable exponent @Note: the integer VarOffset encodes:

  1. the position of a variable in the exponent vector p->exp (lower 24 bits)
  2. number of bits to shift to the right in the upper 8 bits (which takes at most 6 bits for 64 bit) Thus VarOffset always has 2 zero higher bits!

Definition at line 471 of file p_polys.h.

472{
473 pAssume2((VarOffset >> (24 + 6)) == 0);
474#if 0
475 int pos=(VarOffset & 0xffffff);
476 int bitpos=(VarOffset >> 24);
477 unsigned long exp=(p->exp[pos] >> bitmask) & iBitmask;
478 return exp;
479#else
480 return (long)
481 ((p->exp[(VarOffset & 0xffffff)] >> (VarOffset >> 24))
482 & iBitmask);
483#endif
484}
gmp_float exp(const gmp_float &a)

◆ p_GetExp_k_n()

static poly p_GetExp_k_n ( poly p,
int l,
int k,
const ring r )
inlinestatic

Definition at line 1388 of file p_polys.h.

1389{
1390 if (p == NULL) return NULL;
1392 poly np;
1393 omTypeAllocBin(poly, np, r->PolyBin);
1394 p_SetRingOfLm(np, r);
1395 memcpy(np->exp, p->exp, r->ExpL_Size*sizeof(long));
1396 pNext(np) = NULL;
1397 pSetCoeff0(np, n_Init(1, r->cf));
1398 int i;
1399 for(i=l;i<=k;i++)
1400 {
1401 //np->exp[(r->VarOffset[i] & 0xffffff)] =0;
1402 p_SetExp(np,i,0,r);
1403 }
1404 p_Setm(np,r);
1405 return np;
1406}

◆ p_GetExpDiff()

static long p_GetExpDiff ( poly p1,
poly p2,
int i,
ring r )
inlinestatic

Definition at line 637 of file p_polys.h.

638{
639 return p_GetExp(p1,i,r) - p_GetExp(p2,i,r);
640}

◆ p_GetExpSum()

static long p_GetExpSum ( poly p1,
poly p2,
int i,
ring r )
inlinestatic

Definition at line 631 of file p_polys.h.

632{
633 p_LmCheckPolyRing2(p1, r);
634 p_LmCheckPolyRing2(p2, r);
635 return p_GetExp(p1,i,r) + p_GetExp(p2,i,r);
636}

◆ p_GetExpV()

static void p_GetExpV ( poly p,
int * ev,
const ring r )
inlinestatic

Definition at line 1536 of file p_polys.h.

1537{
1539 for (unsigned j = r->N; j!=0; j--)
1540 ev[j] = p_GetExp(p, j, r);
1541
1542 ev[0] = p_GetComp(p, r);
1543}

◆ p_GetExpVL()

static void p_GetExpVL ( poly p,
int64 * ev,
const ring r )
inlinestatic

Definition at line 1545 of file p_polys.h.

1546{
1548 for (unsigned j = r->N; j!=0; j--)
1549 ev[j-1] = p_GetExp(p, j, r);
1550}

◆ p_GetExpVLV()

static int64 p_GetExpVLV ( poly p,
int64 * ev,
const ring r )
inlinestatic

Definition at line 1552 of file p_polys.h.

1553{
1555 for (unsigned j = r->N; j!=0; j--)
1556 ev[j-1] = p_GetExp(p, j, r);
1557 return (int64)p_GetComp(p,r);
1558}
long int64
Definition auxiliary.h:68

◆ p_GetMaxExp() [1/2]

static unsigned long p_GetMaxExp ( const poly p,
const ring r )
inlinestatic

Definition at line 806 of file p_polys.h.

807{
808 return p_GetMaxExp(p_GetMaxExpL(p, r), r);
809}
static unsigned long p_GetMaxExp(const unsigned long l, const ring r)
Definition p_polys.h:783
unsigned long p_GetMaxExpL(poly p, const ring r, unsigned long l_max=0)
return the maximal exponent of p in form of the maximal long var
Definition p_polys.cc:1176

◆ p_GetMaxExp() [2/2]

static unsigned long p_GetMaxExp ( const unsigned long l,
const ring r )
inlinestatic

Definition at line 783 of file p_polys.h.

784{
785 unsigned long bitmask = r->bitmask;
786 unsigned long max = (l & bitmask);
787 unsigned long j = r->ExpPerLong - 1;
788
789 if (j > 0)
790 {
791 unsigned long i = r->BitsPerExp;
792 long e;
793 loop
794 {
795 e = ((l >> i) & bitmask);
796 if ((unsigned long) e > max)
797 max = e;
798 j--;
799 if (j==0) break;
800 i += r->BitsPerExp;
801 }
802 }
803 return max;
804}
static int max(int a, int b)
Definition fast_mult.cc:264

◆ p_GetMaxExpL()

unsigned long p_GetMaxExpL ( poly p,
const ring r,
unsigned long l_max = 0 )

return the maximal exponent of p in form of the maximal long var

Definition at line 1176 of file p_polys.cc.

1177{
1178 unsigned long l_p, divmask = r->divmask;
1179 int i;
1180
1181 while (p != NULL)
1182 {
1183 l_p = p->exp[r->VarL_Offset[0]];
1184 if (l_p > l_max ||
1185 (((l_max & divmask) ^ (l_p & divmask)) != ((l_max-l_p) & divmask)))
1186 l_max = p_GetMaxExpL2(l_max, l_p, r);
1187 for (i=1; i<r->VarL_Size; i++)
1188 {
1189 l_p = p->exp[r->VarL_Offset[i]];
1190 // do the divisibility trick to find out whether l has an exponent
1191 if (l_p > l_max ||
1192 (((l_max & divmask) ^ (l_p & divmask)) != ((l_max-l_p) & divmask)))
1193 l_max = p_GetMaxExpL2(l_max, l_p, r);
1194 }
1195 pIter(p);
1196 }
1197 return l_max;
1198}
static unsigned long p_GetMaxExpL2(unsigned long l1, unsigned long l2, const ring r, unsigned long number_of_exp)
Definition p_polys.cc:1108

◆ p_GetMaxExpP()

poly p_GetMaxExpP ( poly p,
ring r )

return monomial r such that GetExp(r,i) is maximum of all monomials in p; coeff == 0, next == NULL, ord is not set

Definition at line 1139 of file p_polys.cc.

1140{
1141 p_CheckPolyRing(p, r);
1142 if (p == NULL) return p_Init(r);
1143 poly max = p_LmInit(p, r);
1144 pIter(p);
1145 if (p == NULL) return max;
1146 int i, offset;
1147 unsigned long l_p, l_max;
1148 unsigned long divmask = r->divmask;
1149
1150 do
1151 {
1152 offset = r->VarL_Offset[0];
1153 l_p = p->exp[offset];
1154 l_max = max->exp[offset];
1155 // do the divisibility trick to find out whether l has an exponent
1156 if (l_p > l_max ||
1157 (((l_max & divmask) ^ (l_p & divmask)) != ((l_max-l_p) & divmask)))
1158 max->exp[offset] = p_GetMaxExpL2(l_max, l_p, r);
1159
1160 for (i=1; i<r->VarL_Size; i++)
1161 {
1162 offset = r->VarL_Offset[i];
1163 l_p = p->exp[offset];
1164 l_max = max->exp[offset];
1165 // do the divisibility trick to find out whether l has an exponent
1166 if (l_p > l_max ||
1167 (((l_max & divmask) ^ (l_p & divmask)) != ((l_max-l_p) & divmask)))
1168 max->exp[offset] = p_GetMaxExpL2(l_max, l_p, r);
1169 }
1170 pIter(p);
1171 }
1172 while (p != NULL);
1173 return max;
1174}
STATIC_VAR int offset
Definition janet.cc:29
BOOLEAN p_CheckPolyRing(poly p, ring r)
Definition pDebug.cc:115
static poly p_Init(const ring r, omBin bin)
Definition p_polys.h:1336

◆ p_GetOrder()

static long p_GetOrder ( poly p,
ring r )
inlinestatic

Definition at line 423 of file p_polys.h.

424{
426 if (r->typ==NULL) return ((p)->exp[r->pOrdIndex]);
427 int i=0;
428 loop
429 {
430 switch(r->typ[i].ord_typ)
431 {
432 case ro_am:
433 case ro_wp_neg:
434 return ((p->exp[r->pOrdIndex])-POLY_NEGWEIGHT_OFFSET);
435 case ro_syzcomp:
436 case ro_syz:
437 case ro_cp:
438 i++;
439 break;
440 //case ro_dp:
441 //case ro_wp:
442 default:
443 return ((p)->exp[r->pOrdIndex]);
444 }
445 }
446}
#define POLY_NEGWEIGHT_OFFSET
Definition monomials.h:236
@ ro_syz
Definition ring.h:61
@ ro_cp
Definition ring.h:59
@ ro_wp_neg
Definition ring.h:57
@ ro_am
Definition ring.h:55

◆ p_GetSetmProc()

p_SetmProc p_GetSetmProc ( const ring r)

Definition at line 559 of file p_polys.cc.

560{
561 // covers lp, rp, ls,
562 if (r->typ == NULL) return p_Setm_Dummy;
563
564 if (r->OrdSize == 1)
565 {
566 if (r->typ[0].ord_typ == ro_dp &&
567 r->typ[0].data.dp.start == 1 &&
568 r->typ[0].data.dp.end == r->N &&
569 r->typ[0].data.dp.place == r->pOrdIndex)
570 return p_Setm_TotalDegree;
571 if (r->typ[0].ord_typ == ro_wp &&
572 r->typ[0].data.wp.start == 1 &&
573 r->typ[0].data.wp.end == r->N &&
574 r->typ[0].data.wp.place == r->pOrdIndex &&
575 r->typ[0].data.wp.weights == r->firstwv)
577 }
578 return p_Setm_General;
579}
void p_Setm_WFirstTotalDegree(poly p, const ring r)
Definition p_polys.cc:553
void p_Setm_Dummy(poly p, const ring r)
Definition p_polys.cc:540
void p_Setm_TotalDegree(poly p, const ring r)
Definition p_polys.cc:546
void p_Setm_General(poly p, const ring r)
Definition p_polys.cc:158
@ ro_dp
Definition ring.h:53
@ ro_wp
Definition ring.h:54

◆ p_GetShortExpVector()

unsigned long p_GetShortExpVector ( const poly a,
const ring r )

Definition at line 4889 of file p_polys.cc.

4890{
4891 assume(p != NULL);
4892 unsigned long ev = 0; // short exponent vector
4893 unsigned int n = BIT_SIZEOF_LONG / r->N; // number of bits per exp
4894 unsigned int m1; // highest bit which is filled with (n+1)
4895 unsigned int i=0;
4896 int j=1;
4897
4898 if (n == 0)
4899 {
4900 if (r->N <2*BIT_SIZEOF_LONG)
4901 {
4902 n=1;
4903 m1=0;
4904 }
4905 else
4906 {
4907 for (; j<=r->N; j++)
4908 {
4909 if (p_GetExp(p,j,r) > 0) i++;
4910 if (i == BIT_SIZEOF_LONG) break;
4911 }
4912 if (i>0)
4913 ev = ~(0UL) >> (BIT_SIZEOF_LONG - i);
4914 return ev;
4915 }
4916 }
4917 else
4918 {
4919 m1 = (n+1)*(BIT_SIZEOF_LONG - n*r->N);
4920 }
4921
4922 n++;
4923 while (i<m1)
4924 {
4925 ev |= GetBitFields(p_GetExp(p, j,r), i, n);
4926 i += n;
4927 j++;
4928 }
4929
4930 n--;
4931 while (i<BIT_SIZEOF_LONG)
4932 {
4933 ev |= GetBitFields(p_GetExp(p, j,r), i, n);
4934 i += n;
4935 j++;
4936 }
4937 return ev;
4938}
#define BIT_SIZEOF_LONG
Definition auxiliary.h:80
static unsigned long GetBitFields(const long e, const unsigned int s, const unsigned int n)
Definition p_polys.cc:4857

◆ p_GetShortExpVector0()

unsigned long p_GetShortExpVector0 ( const poly a,
const ring r )

Definition at line 4940 of file p_polys.cc.

4941{
4942 assume(p != NULL);
4943 assume(r->N >=BIT_SIZEOF_LONG);
4944 unsigned long ev = 0; // short exponent vector
4945
4946 for (int j=BIT_SIZEOF_LONG; j>0; j--)
4947 {
4948 if (p_GetExp(p, j,r)>0)
4949 ev |= Sy_bitL(j-1);
4950 }
4951 return ev;
4952}
#define Sy_bitL(x)
Definition options.h:32

◆ p_GetShortExpVector1()

unsigned long p_GetShortExpVector1 ( const poly a,
const ring r )

Definition at line 4955 of file p_polys.cc.

4956{
4957 assume(p != NULL);
4958 assume(r->N <BIT_SIZEOF_LONG);
4959 assume(2*r->N >=BIT_SIZEOF_LONG);
4960 unsigned long ev = 0; // short exponent vector
4961 int rest=r->N;
4962 int e;
4963 // 2 bits per exp
4964 int j=r->N;
4965 for (; j>BIT_SIZEOF_LONG-r->N; j--)
4966 {
4967 if ((e=p_GetExp(p, j,r))>0)
4968 {
4969 ev |= Sy_bitL(j-1);
4970 if (e>1)
4971 {
4972 ev|=Sy_bitL(rest+j-1);
4973 }
4974 }
4975 }
4976 // 1 bit per exp
4977 for (; j>0; j--)
4978 {
4979 if (p_GetExp(p, j,r)>0)
4980 {
4981 ev |= Sy_bitL(j-1);
4982 }
4983 }
4984 return ev;
4985}

◆ p_GetTotalDegree()

static unsigned long p_GetTotalDegree ( const unsigned long l,
const ring r,
const int number_of_exps )
inlinestatic

Definition at line 812 of file p_polys.h.

813{
814 const unsigned long bitmask = r->bitmask;
815 unsigned long sum = (l & bitmask);
816 unsigned long j = number_of_exps - 1;
817
818 if (j > 0)
819 {
820 unsigned long i = r->BitsPerExp;
821 loop
822 {
823 sum += ((l >> i) & bitmask);
824 j--;
825 if (j==0) break;
826 i += r->BitsPerExp;
827 }
828 }
829 return sum;
830}

◆ 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 at line 1268 of file p_polys.cc.

1269{
1270 int i;
1271 int n=0;
1272 while(p!=NULL)
1273 {
1274 n=0;
1275 for(i=r->N; i>0; i--)
1276 {
1277 if(e[i]==0)
1278 {
1279 if (p_GetExp(p,i,r)>0)
1280 {
1281 e[i]=1;
1282 n++;
1283 }
1284 }
1285 else
1286 n++;
1287 }
1288 if (n==r->N) break;
1289 pIter(p);
1290 }
1291 return n;
1292}

◆ p_HasNotCF()

BOOLEAN p_HasNotCF ( poly p1,
poly p2,
const ring r )

Definition at line 1330 of file p_polys.cc.

1331{
1332
1333 if (p_GetComp(p1,r) > 0 || p_GetComp(p2,r) > 0)
1334 return FALSE;
1335 int i = rVar(r);
1336 loop
1337 {
1338 if ((p_GetExp(p1, i, r) > 0) && (p_GetExp(p2, i, r) > 0))
1339 return FALSE;
1340 i--;
1341 if (i == 0)
1342 return TRUE;
1343 }
1344}

◆ p_HasNotCFRing()

BOOLEAN p_HasNotCFRing ( poly p1,
poly p2,
const ring r )

Definition at line 1346 of file p_polys.cc.

1347{
1348
1349 if (p_GetComp(p1,r) > 0 || p_GetComp(p2,r) > 0)
1350 return FALSE;
1351 int i = rVar(r);
1352 loop
1353 {
1354 if ((p_GetExp(p1, i, r) > 0) && (p_GetExp(p2, i, r) > 0))
1355 return FALSE;
1356 i--;
1357 if (i == 0) {
1358 if (n_DivBy(pGetCoeff(p1), pGetCoeff(p2), r->cf) ||
1359 n_DivBy(pGetCoeff(p2), pGetCoeff(p1), r->cf)) {
1360 return FALSE;
1361 } else {
1362 return TRUE;
1363 }
1364 }
1365 }
1366}

◆ p_Head()

static poly p_Head ( const poly p,
const ring r )
inlinestatic

copy the (leading) term of p

Definition at line 862 of file p_polys.h.

863{
864 if (p == NULL) return NULL;
866 poly np;
867 omTypeAllocBin(poly, np, r->PolyBin);
868 p_SetRingOfLm(np, r);
869 memcpy(np->exp, p->exp, r->ExpL_Size*sizeof(long));
870 pNext(np) = NULL;
871 pSetCoeff0(np, n_Copy(pGetCoeff(p), r->cf));
872 return np;
873}

◆ p_Head0()

poly p_Head0 ( const poly p,
const ring r )

like p_Head, but allow NULL coeff

Definition at line 5095 of file p_polys.cc.

5096{
5097 if (p==NULL) return NULL;
5098 if (pGetCoeff(p)==NULL) return p_CopyPowerProduct0(p,NULL,r);
5099 return p_Head(p,r);
5100}

◆ p_Homogen()

poly p_Homogen ( poly p,
int varnum,
const ring r )

Definition at line 3274 of file p_polys.cc.

3275{
3276 pFDegProc deg;
3277 if (r->pLexOrder && (r->order[0]==ringorder_lp))
3278 deg=p_Totaldegree;
3279 else
3280 deg=r->pFDeg;
3281
3282 poly q=NULL, qn;
3283 int o,ii;
3284 sBucket_pt bp;
3285
3286 if (p!=NULL)
3287 {
3288 if ((varnum < 1) || (varnum > rVar(r)))
3289 {
3290 return NULL;
3291 }
3292 o=deg(p,r);
3293 q=pNext(p);
3294 while (q != NULL)
3295 {
3296 ii=deg(q,r);
3297 if (ii>o) o=ii;
3298 pIter(q);
3299 }
3300 q = p_Copy(p,r);
3301 bp = sBucketCreate(r);
3302 while (q != NULL)
3303 {
3304 ii = o-deg(q,r);
3305 if (ii!=0)
3306 {
3307 p_AddExp(q,varnum, (long)ii,r);
3308 p_Setm(q,r);
3309 }
3310 qn = pNext(q);
3311 pNext(q) = NULL;
3312 sBucket_Add_m(bp, q);
3313 q = qn;
3314 }
3315 sBucketDestroyAdd(bp, &q, &ii);
3316 }
3317 return q;
3318}
static long p_AddExp(poly p, int v, long ee, ring r)
Definition p_polys.h:608
long(* pFDegProc)(poly p, ring r)
Definition ring.h:39
@ ringorder_lp
Definition ring.h:78
void sBucket_Add_m(sBucket_pt bucket, poly p)
Definition sbuckets.cc:173
sBucket_pt sBucketCreate(const ring r)
Definition sbuckets.cc:96
sBucket * sBucket_pt
Definition sbuckets.h:16
void sBucketDestroyAdd(sBucket_pt bucket, poly *p, int *length)
Definition sbuckets.h:68

◆ p_HomogenDP()

poly p_HomogenDP ( poly p,
int varnum,
const ring r )

Definition at line 3320 of file p_polys.cc.

3321{
3322 poly q=NULL, qn;
3323 int o,ii;
3324 sBucket_pt bp;
3325
3326 if (p!=NULL)
3327 {
3328 if ((varnum < 1) || (varnum > rVar(r)))
3329 {
3330 return NULL;
3331 }
3332 o=p_Totaldegree(p,r);
3333 q=pNext(p);
3334 while (q != NULL)
3335 {
3336 ii=p_Totaldegree(q,r);
3337 if (ii>o) o=ii;
3338 pIter(q);
3339 }
3340 q = p_Copy(p,r);
3341 bp = sBucketCreate(r);
3342 while (q != NULL)
3343 {
3344 ii = o-p_Totaldegree(q,r);
3345 if (ii!=0)
3346 {
3347 p_AddExp(q,varnum, (long)ii,r);
3348 p_Setm(q,r);
3349 }
3350 qn = pNext(q);
3351 pNext(q) = NULL;
3352 sBucket_Add_m(bp, q);
3353 q = qn;
3354 }
3355 sBucketDestroyAdd(bp, &q, &ii);
3356 }
3357 return q;
3358}

◆ p_IncrExp()

static long p_IncrExp ( poly p,
int v,
ring r )
inlinestatic

Definition at line 593 of file p_polys.h.

594{
596 int e = p_GetExp(p,v,r);
597 e++;
598 return p_SetExp(p,v,e,r);
599}

◆ p_Init() [1/2]

static poly p_Init ( const ring r)
inlinestatic

Definition at line 1346 of file p_polys.h.

1347{
1348 return p_Init(r, r->PolyBin);
1349}

◆ p_Init() [2/2]

static poly p_Init ( const ring r,
omBin bin )
inlinestatic

Definition at line 1336 of file p_polys.h.

1337{
1338 p_CheckRing1(r);
1339 pAssume1(bin != NULL && omSizeWOfBin(r->PolyBin) == omSizeWOfBin(bin));
1340 poly p;
1341 omTypeAlloc0Bin(poly, p, bin);
1343 p_SetRingOfLm(p, r);
1344 return p;
1345}
#define p_CheckRing1(r)
Definition monomials.h:178
#define omTypeAlloc0Bin(type, addr, bin)

◆ p_InitContent()

number p_InitContent ( poly ph,
const ring r )

Definition at line 2639 of file p_polys.cc.

2642{
2644 assume(ph!=NULL);
2645 assume(pNext(ph)!=NULL);
2646 assume(rField_is_Q(r));
2647 if (pNext(pNext(ph))==NULL)
2648 {
2649 return n_GetNumerator(pGetCoeff(pNext(ph)),r->cf);
2650 }
2651 poly p=ph;
2652 number n1=n_GetNumerator(pGetCoeff(p),r->cf);
2653 pIter(p);
2654 number n2=n_GetNumerator(pGetCoeff(p),r->cf);
2655 pIter(p);
2656 number d;
2657 number t;
2658 loop
2659 {
2660 nlNormalize(pGetCoeff(p),r->cf);
2661 t=n_GetNumerator(pGetCoeff(p),r->cf);
2662 if (nlGreaterZero(t,r->cf))
2663 d=nlAdd(n1,t,r->cf);
2664 else
2665 d=nlSub(n1,t,r->cf);
2666 nlDelete(&t,r->cf);
2667 nlDelete(&n1,r->cf);
2668 n1=d;
2669 pIter(p);
2670 if (p==NULL) break;
2671 nlNormalize(pGetCoeff(p),r->cf);
2672 t=n_GetNumerator(pGetCoeff(p),r->cf);
2673 if (nlGreaterZero(t,r->cf))
2674 d=nlAdd(n2,t,r->cf);
2675 else
2676 d=nlSub(n2,t,r->cf);
2677 nlDelete(&t,r->cf);
2678 nlDelete(&n2,r->cf);
2679 n2=d;
2680 pIter(p);
2681 if (p==NULL) break;
2682 }
2683 d=nlGcd(n1,n2,r->cf);
2684 nlDelete(&n1,r->cf);
2685 nlDelete(&n2,r->cf);
2686 return d;
2687}
2688#else
2689{
2690 /* ph has al least 2 terms */
2691 number d=pGetCoeff(ph);
2692 int s=n_Size(d,r->cf);
2693 pIter(ph);
2694 number d2=pGetCoeff(ph);
2695 int s2=n_Size(d2,r->cf);
2696 pIter(ph);
2697 if (ph==NULL)
2698 {
2699 if (s<s2) return n_Copy(d,r->cf);
2700 else return n_Copy(d2,r->cf);
2701 }
2702 do
2703 {
2704 number nd=pGetCoeff(ph);
2705 int ns=n_Size(nd,r->cf);
2706 if (ns<=2)
2707 {
2708 s2=s;
2709 d2=d;
2710 d=nd;
2711 s=ns;
2712 break;
2713 }
2714 else if (ns<s)
2715 {
2716 s2=s;
2717 d2=d;
2718 d=nd;
2719 s=ns;
2720 }
2721 pIter(ph);
2722 }
2723 while(ph!=NULL);
2724 return n_SubringGcd(d,d2,r->cf);
2725}
static FORCE_INLINE int n_Size(number n, const coeffs r)
return a non-negative measure for the complexity of n; return 0 only when n represents zero; (used fo...
Definition coeffs.h:571
static FORCE_INLINE number n_GetNumerator(number &n, const coeffs r)
return the numerator of n (if elements of r are by nature not fractional, result is n)
Definition coeffs.h:609
LINLINE number nlAdd(number la, number li, const coeffs r)
Definition longrat.cc:2693
LINLINE number nlSub(number la, number li, const coeffs r)
Definition longrat.cc:2759
LINLINE void nlDelete(number *a, const coeffs r)
Definition longrat.cc:2658
BOOLEAN nlGreaterZero(number za, const coeffs r)
Definition longrat.cc:1304
number nlGcd(number a, number b, const coeffs r)
Definition longrat.cc:1341
void nlNormalize(number &x, const coeffs r)
Definition longrat.cc:1482

◆ p_IsConstant()

static BOOLEAN p_IsConstant ( const poly p,
const ring r )
inlinestatic

Definition at line 1980 of file p_polys.h.

1981{
1982 if (p == NULL) return TRUE;
1983 return (pNext(p)==NULL) && p_LmIsConstant(p, r);
1984}
static BOOLEAN p_LmIsConstant(const poly p, const ring r)
Definition p_polys.h:1025

◆ p_IsConstantComp()

static BOOLEAN p_IsConstantComp ( const poly p,
const ring r )
inlinestatic

like the respective p_LmIs* routines, except that p might be empty

Definition at line 1974 of file p_polys.h.

1975{
1976 if (p == NULL) return TRUE;
1977 return (pNext(p)==NULL) && p_LmIsConstantComp(p, r);
1978}
static BOOLEAN p_LmIsConstantComp(const poly p, const ring r)
Definition p_polys.h:1008

◆ p_IsConstantPoly()

static BOOLEAN p_IsConstantPoly ( const poly p,
const ring r )
inlinestatic

Definition at line 1994 of file p_polys.h.

1995{
1996 p_Test(p, r);
1997 poly pp=p;
1998 while(pp!=NULL)
1999 {
2000 if (! p_LmIsConstantComp(pp, r))
2001 return FALSE;
2002 pIter(pp);
2003 }
2004 return TRUE;
2005}

◆ p_ISet()

poly p_ISet ( long i,
const ring r )

returns the poly representing the integer i

Definition at line 1298 of file p_polys.cc.

1299{
1300 poly rc = NULL;
1301 if (i!=0)
1302 {
1303 rc = p_Init(r);
1304 pSetCoeff0(rc,n_Init(i,r->cf));
1305 if (n_IsZero(pGetCoeff(rc),r->cf))
1306 p_LmDelete(&rc,r);
1307 }
1308 return rc;
1309}

◆ p_IsHomogeneous()

BOOLEAN p_IsHomogeneous ( poly p,
const ring r )

Definition at line 3363 of file p_polys.cc.

3364{
3365 poly qp=p;
3366 int o;
3367
3368 if ((p == NULL) || (pNext(p) == NULL)) return TRUE;
3369 pFDegProc d;
3370 if (r->pLexOrder && (r->order[0]==ringorder_lp))
3371 d=p_Totaldegree;
3372 else
3373 d=r->pFDeg;
3374 o = d(p,r);
3375 do
3376 {
3377 if (d(qp,r) != o) return FALSE;
3378 pIter(qp);
3379 }
3380 while (qp != NULL);
3381 return TRUE;
3382}

◆ p_IsHomogeneousDP()

BOOLEAN p_IsHomogeneousDP ( poly p,
const ring r )

Definition at line 3387 of file p_polys.cc.

3388{
3389 poly qp=p;
3390 int o;
3391
3392 if ((p == NULL) || (pNext(p) == NULL)) return TRUE;
3393 o = p_Totaldegree(p,r);
3394 do
3395 {
3396 if (p_Totaldegree(qp,r) != o) return FALSE;
3397 pIter(qp);
3398 }
3399 while (qp != NULL);
3400 return TRUE;
3401}

◆ p_IsHomogeneousW() [1/2]

BOOLEAN p_IsHomogeneousW ( poly p,
const intvec * w,
const intvec * module_w,
const ring r )

Definition at line 3423 of file p_polys.cc.

3424{
3425 poly qp=p;
3426 long o;
3427
3428 if ((p == NULL) || (pNext(p) == NULL)) return TRUE;
3429 pIter(qp);
3430 o = totaldegreeWecart_IV(p,r,w->ivGetVec())+(*module_w)[p_GetComp(p,r)];
3431 do
3432 {
3433 long oo=totaldegreeWecart_IV(qp,r,w->ivGetVec())+(*module_w)[p_GetComp(qp,r)];
3434 if (oo != o) return FALSE;
3435 pIter(qp);
3436 }
3437 while (qp != NULL);
3438 return TRUE;
3439}

◆ p_IsHomogeneousW() [2/2]

BOOLEAN p_IsHomogeneousW ( poly p,
const intvec * w,
const ring r )

Definition at line 3406 of file p_polys.cc.

3407{
3408 poly qp=p;
3409 long o;
3410
3411 if ((p == NULL) || (pNext(p) == NULL)) return TRUE;
3412 pIter(qp);
3413 o = totaldegreeWecart_IV(p,r,w->ivGetVec());
3414 do
3415 {
3416 if (totaldegreeWecart_IV(qp,r,w->ivGetVec()) != o) return FALSE;
3417 pIter(qp);
3418 }
3419 while (qp != NULL);
3420 return TRUE;
3421}

◆ p_IsOne()

static BOOLEAN p_IsOne ( const poly p,
const ring R )
inlinestatic

either poly(1) or gen(k)?!

Definition at line 1987 of file p_polys.h.

1988{
1989 if (p == NULL) return FALSE; /* TODO check if 0 == 1 */
1990 p_Test(p, R);
1991 return (p_IsConstant(p, R) && n_IsOne(p_GetCoeff(p, R), R->cf));
1992}

◆ p_IsPurePower()

int p_IsPurePower ( const poly p,
const ring r )

return i, if head depends only on var(i)

Definition at line 1227 of file p_polys.cc.

1228{
1229 int i,k=0;
1230
1231 for (i=r->N;i;i--)
1232 {
1233 if (p_GetExp(p,i, r)!=0)
1234 {
1235 if(k!=0) return 0;
1236 k=i;
1237 }
1238 }
1239 return k;
1240}

◆ p_IsUnit()

static BOOLEAN p_IsUnit ( const poly p,
const ring r )
inlinestatic

Definition at line 2007 of file p_polys.h.

2008{
2009 if (p == NULL) return FALSE;
2010 if (rField_is_Ring(r))
2011 return (p_LmIsConstant(p, r) && n_IsUnit(pGetCoeff(p),r->cf));
2012 return p_LmIsConstant(p, r);
2013}
static FORCE_INLINE BOOLEAN n_IsUnit(number n, const coeffs r)
TRUE iff n has a multiplicative inverse in the given coeff field/ring r.
Definition coeffs.h:519

◆ p_IsUnivariate()

int p_IsUnivariate ( poly p,
const ring r )

return i, if poly depends only on var(i)

Definition at line 1248 of file p_polys.cc.

1249{
1250 int i,k=-1;
1251
1252 while (p!=NULL)
1253 {
1254 for (i=r->N;i;i--)
1255 {
1256 if (p_GetExp(p,i, r)!=0)
1257 {
1258 if((k!=-1)&&(k!=i)) return 0;
1259 k=i;
1260 }
1261 }
1262 pIter(p);
1263 }
1264 return k;
1265}

◆ p_Jet()

poly p_Jet ( poly p,
int m,
const ring R )

Definition at line 4495 of file p_polys.cc.

4496{
4497 while((p!=NULL) && (p_Totaldegree(p,R)>m)) p_LmDelete(&p,R);
4498 if (p==NULL) return NULL;
4499 poly r=p;
4500 while (pNext(p)!=NULL)
4501 {
4502 if (p_Totaldegree(pNext(p),R)>m)
4503 {
4504 p_LmDelete(&pNext(p),R);
4505 }
4506 else
4507 pIter(p);
4508 }
4509 return r;
4510}

◆ p_JetW()

poly p_JetW ( poly p,
int m,
int * w,
const ring R )

Definition at line 4539 of file p_polys.cc.

4540{
4541 while((p!=NULL) && (totaldegreeWecart_IV(p,R,w)>m)) p_LmDelete(&p,R);
4542 if (p==NULL) return NULL;
4543 poly r=p;
4544 while (pNext(p)!=NULL)
4545 {
4547 {
4548 p_LmDelete(&pNext(p),R);
4549 }
4550 else
4551 pIter(p);
4552 }
4553 return r;
4554}

◆ p_Last()

poly p_Last ( const poly a,
int & l,
const ring r )

Definition at line 4730 of file p_polys.cc.

4731{
4732 if (p == NULL)
4733 {
4734 l = 0;
4735 return NULL;
4736 }
4737 l = 1;
4738 poly a = p;
4739 if (! rIsSyzIndexRing(r))
4740 {
4741 poly next = pNext(a);
4742 while (next!=NULL)
4743 {
4744 a = next;
4745 next = pNext(a);
4746 l++;
4747 }
4748 }
4749 else
4750 {
4751 long unsigned curr_limit = rGetCurrSyzLimit(r);
4752 poly pp = a;
4753 while ((a=pNext(a))!=NULL)
4754 {
4755 if (__p_GetComp(a,r)<=curr_limit/*syzComp*/)
4756 l++;
4757 else break;
4758 pp = a;
4759 }
4760 a=pp;
4761 }
4762 return a;
4763}
ListNode * next
Definition janet.h:31
static int rGetCurrSyzLimit(const ring r)
Definition ring.h:729
static BOOLEAN rIsSyzIndexRing(const ring r)
Definition ring.h:726

◆ p_Lcm() [1/2]

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

Definition at line 1668 of file p_polys.cc.

1669{
1670 poly m=p_Init(r);
1671 p_Lcm(a, b, m, r);
1672 p_Setm(m,r);
1673 return(m);
1674}
void p_Lcm(const poly a, const poly b, poly m, const ring r)
Definition p_polys.cc:1659

◆ p_Lcm() [2/2]

void p_Lcm ( const poly a,
const poly b,
poly m,
const ring r )

Definition at line 1659 of file p_polys.cc.

1660{
1661 for (int i=r->N; i; --i)
1662 p_SetExp(m,i, si_max( p_GetExp(a,i,r), p_GetExp(b,i,r)),r);
1663
1664 p_SetComp(m, si_max(p_GetComp(a,r), p_GetComp(b,r)),r);
1665 /* Don't do a pSetm here, otherwise hres/lres chockes */
1666}
static int si_max(const int a, const int b)
Definition auxiliary.h:125
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition p_polys.h:249

◆ p_LcmRat()

poly p_LcmRat ( const poly a,
const poly b,
const long lCompM,
const ring r )

Definition at line 1681 of file p_polys.cc.

1682{
1683 poly m = // p_One( r);
1684 p_Init(r);
1685
1686// const int (currRing->N) = r->N;
1687
1688 // for (int i = (currRing->N); i>=r->real_var_start; i--)
1689 for (int i = r->real_var_end; i>=r->real_var_start; i--)
1690 {
1691 const int lExpA = p_GetExp (a, i, r);
1692 const int lExpB = p_GetExp (b, i, r);
1693
1694 p_SetExp (m, i, si_max(lExpA, lExpB), r);
1695 }
1696
1697 p_SetComp (m, lCompM, r);
1698 p_Setm(m,r);
1699 p_GetCoeff(m, r)=NULL;
1700
1701 return(m);
1702};

◆ p_LDeg()

static long p_LDeg ( const poly p,
int * l,
const ring r )
inlinestatic

Definition at line 383 of file p_polys.h.

383{ return r->pLDeg(p,l,r); }

◆ p_LmCheckIsFromRing()

BOOLEAN p_LmCheckIsFromRing ( poly p,
ring r )

Definition at line 74 of file pDebug.cc.

75{
76 if (p != NULL)
77 {
78 #if (OM_TRACK > 0) && defined(OM_TRACK_CUSTOM)
79 void* custom = omGetCustomOfAddr(p);
80 if (custom != NULL)
81 {
82 pPolyAssumeReturnMsg(custom == r ||
83 // be more sloppy for qrings
84 (r->qideal != NULL &&
86 omSizeWOfAddr(p)==omSizeWOfBin(r->PolyBin)) ||
87 rSamePolyRep((ring) custom, r),
88 "monomial not from specified ring",p,r);
89 return TRUE;
90 }
91 else
92 #endif
93 #ifndef X_OMALLOC
94 {
97 return TRUE;
98 }
99 return FALSE;
100 #endif
101 }
102 return TRUE;
103}
#define pPolyAssumeReturnMsg(cond, msg)
Definition monomials.h:137
#define _pPolyAssumeReturn(cond, p, r)
Definition monomials.h:101
#define omIsBinPageAddr(addr)
Definition omBinPage.h:68
#define omSizeWOfAddr(P)
Definition xalloc.h:223

◆ p_LmCheckPolyRing()

BOOLEAN p_LmCheckPolyRing ( poly p,
ring r )

Definition at line 123 of file pDebug.cc.

124{
125 #ifndef X_OMALLOC
126 pAssumeReturn(r != NULL && r->PolyBin != NULL);
127 #endif
128 pAssumeReturn(p != NULL);
129 return p_LmCheckIsFromRing(p, r);
130}

◆ p_LmCmp()

static int p_LmCmp ( poly p,
poly q,
const ring r )
inlinestatic

Definition at line 1596 of file p_polys.h.

1597{
1599 p_LmCheckPolyRing1(q, r);
1600
1601 const unsigned long* _s1 = ((unsigned long*) p->exp);
1602 const unsigned long* _s2 = ((unsigned long*) q->exp);
1603 REGISTER unsigned long _v1;
1604 REGISTER unsigned long _v2;
1605 const unsigned long _l = r->CmpL_Size;
1606
1607 REGISTER unsigned long _i=0;
1608
1609 LengthGeneral_OrdGeneral_LoopTop:
1610 _v1 = _s1[_i];
1611 _v2 = _s2[_i];
1612 if (_v1 == _v2)
1613 {
1614 _i++;
1615 if (_i == _l) return 0;
1616 goto LengthGeneral_OrdGeneral_LoopTop;
1617 }
1618 const long* _ordsgn = (long*) r->ordsgn;
1619#if 1 /* two variants*/
1620 if (_v1 > _v2)
1621 {
1622 return _ordsgn[_i];
1623 }
1624 return -(_ordsgn[_i]);
1625#else
1626 if (_v1 > _v2)
1627 {
1628 if (_ordsgn[_i] == 1) return 1;
1629 return -1;
1630 }
1631 if (_ordsgn[_i] == 1) return -1;
1632 return 1;
1633#endif
1634}
#define REGISTER
Definition omalloc.h:27

◆ p_LmDelete() [1/2]

static void p_LmDelete ( poly * p,
const ring r )
inlinestatic

Definition at line 745 of file p_polys.h.

746{
748 poly h = *p;
749 *p = pNext(h);
750 n_Delete(&pGetCoeff(h), r->cf);
751 #ifdef XALLOC_BIN
752 omFreeBin(h,r->PolyBin);
753 #else
755 #endif
756}
#define omFreeBin(addr, bin)
#define omFreeBinAddr(addr)

◆ p_LmDelete() [2/2]

static void p_LmDelete ( poly p,
const ring r )
inlinestatic

Definition at line 725 of file p_polys.h.

726{
728 n_Delete(&pGetCoeff(p), r->cf);
729 #ifdef XALLOC_BIN
730 omFreeBin(p,r->PolyBin);
731 #else
733 #endif
734}

◆ p_LmDelete0()

static void p_LmDelete0 ( poly p,
const ring r )
inlinestatic

Definition at line 735 of file p_polys.h.

736{
738 if (pGetCoeff(p)!=NULL) n_Delete(&pGetCoeff(p), r->cf);
739 #ifdef XALLOC_BIN
740 omFreeBin(p,r->PolyBin);
741 #else
743 #endif
744}

◆ p_LmDeleteAndNext()

static poly p_LmDeleteAndNext ( poly p,
const ring r )
inlinestatic

Definition at line 757 of file p_polys.h.

758{
760 poly pnext = pNext(p);
761 n_Delete(&pGetCoeff(p), r->cf);
762 #ifdef XALLOC_BIN
763 omFreeBin(p,r->PolyBin);
764 #else
766 #endif
767 return pnext;
768}

◆ p_LmDeleteAndNextRat()

void p_LmDeleteAndNextRat ( poly * p,
int ishift,
ring r )

Definition at line 1704 of file p_polys.cc.

1705{
1706 /* modifies p*/
1707 // Print("start: "); Print(" "); p_wrp(*p,r);
1708 p_LmCheckPolyRing2(*p, r);
1709 poly q = p_Head(*p,r);
1710 const long cmp = p_GetComp(*p, r);
1711 while ( ( (*p)!=NULL ) && ( p_Comp_k_n(*p, q, ishift+1, r) ) && (p_GetComp(*p, r) == cmp) )
1712 {
1713 p_LmDelete(p,r);
1714 // Print("while: ");p_wrp(*p,r);Print(" ");
1715 }
1716 // p_wrp(*p,r);Print(" ");
1717 // PrintS("end\n");
1718 p_LmDelete(&q,r);
1719}

◆ p_LmDivisibleBy()

static BOOLEAN p_LmDivisibleBy ( poly a,
poly b,
const ring r )
inlinestatic

Definition at line 1907 of file p_polys.h.

1908{
1910 pIfThen1(a != NULL, p_LmCheckPolyRing1(b, r));
1911 if (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r))
1912 return _p_LmDivisibleByNoComp(a, b, r);
1913 return FALSE;
1914}

◆ p_LmDivisibleByNoComp() [1/2]

static BOOLEAN p_LmDivisibleByNoComp ( poly a,
const ring ra,
poly b,
const ring rb )
inlinestatic

Definition at line 1900 of file p_polys.h.

1901{
1902 p_LmCheckPolyRing1(a, ra);
1903 p_LmCheckPolyRing1(b, rb);
1904 return _p_LmDivisibleByNoComp(a, ra, b, rb);
1905}

◆ p_LmDivisibleByNoComp() [2/2]

static BOOLEAN p_LmDivisibleByNoComp ( poly a,
poly b,
const ring r )
inlinestatic

Definition at line 1893 of file p_polys.h.

1894{
1895 p_LmCheckPolyRing1(a, r);
1897 return _p_LmDivisibleByNoComp(a, b, r);
1898}

◆ p_LmDivisibleByPart()

static BOOLEAN p_LmDivisibleByPart ( poly a,
poly b,
const ring r,
const int start,
const int end )
inlinestatic

Definition at line 1878 of file p_polys.h.

1879{
1881 pIfThen1(a != NULL, p_LmCheckPolyRing1(b, r));
1882 if (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r))
1883 return _p_LmDivisibleByNoCompPart(a, r, b, r,start, end);
1884 return FALSE;
1885}

◆ p_LmExpVectorAddIsOk()

static BOOLEAN p_LmExpVectorAddIsOk ( const poly p1,
const poly p2,
const ring r )
inlinestatic

Definition at line 2015 of file p_polys.h.

2017{
2018 p_LmCheckPolyRing(p1, r);
2019 p_LmCheckPolyRing(p2, r);
2020 unsigned long l1, l2, divmask = r->divmask;
2021 int i;
2022
2023 for (i=0; i<r->VarL_Size; i++)
2024 {
2025 l1 = p1->exp[r->VarL_Offset[i]];
2026 l2 = p2->exp[r->VarL_Offset[i]];
2027 // do the divisiblity trick
2028 if ( (l1 > ULONG_MAX - l2) ||
2029 (((l1 & divmask) ^ (l2 & divmask)) != ((l1 + l2) & divmask)))
2030 return FALSE;
2031 }
2032 return TRUE;
2033}

◆ p_LmFree() [1/2]

static void p_LmFree ( poly * p,
ring  )
inlinestatic

Definition at line 698 of file p_polys.h.

700{
702 poly h = *p;
703 *p = pNext(h);
704 #ifdef XALLOC_BIN
705 omFreeBin(h,r->PolyBin);
706 #else
708 #endif
709}

◆ p_LmFree() [2/2]

static void p_LmFree ( poly p,
ring  )
inlinestatic

Definition at line 685 of file p_polys.h.

687{
689 #ifdef XALLOC_BIN
690 omFreeBin(p,r->PolyBin);
691 #else
693 #endif
694}

◆ p_LmFreeAndNext()

static poly p_LmFreeAndNext ( poly p,
ring  )
inlinestatic

Definition at line 713 of file p_polys.h.

715{
717 poly pnext = pNext(p);
718 #ifdef XALLOC_BIN
719 omFreeBin(p,r->PolyBin);
720 #else
722 #endif
723 return pnext;
724}

◆ p_LmInit() [1/3]

static poly p_LmInit ( poly p,
const ring r )
inlinestatic

Definition at line 1351 of file p_polys.h.

1352{
1354 poly np;
1355 omTypeAllocBin(poly, np, r->PolyBin);
1356 p_SetRingOfLm(np, r);
1357 memcpy(np->exp, p->exp, r->ExpL_Size*sizeof(long));
1358 pNext(np) = NULL;
1359 pSetCoeff0(np, NULL);
1360 return np;
1361}

◆ p_LmInit() [2/3]

static poly p_LmInit ( poly s_p,
const ring s_r,
const ring d_r )
inlinestatic

Definition at line 1379 of file p_polys.h.

1380{
1381 pAssume1(d_r != NULL);
1382 return p_LmInit(s_p, s_r, d_r, d_r->PolyBin);
1383}

◆ p_LmInit() [3/3]

static poly p_LmInit ( poly s_p,
const ring s_r,
const ring d_r,
omBin d_bin )
inlinestatic

Definition at line 1362 of file p_polys.h.

1363{
1364 p_LmCheckPolyRing1(s_p, s_r);
1365 p_CheckRing(d_r);
1366 pAssume1(d_r->N <= s_r->N);
1367 poly d_p = p_Init(d_r, d_bin);
1368 for (unsigned i=d_r->N; i!=0; i--)
1369 {
1370 p_SetExp(d_p, i, p_GetExp(s_p, i,s_r), d_r);
1371 }
1372 if (rRing_has_Comp(d_r))
1373 {
1374 p_SetComp(d_p, p_GetComp(s_p,s_r), d_r);
1375 }
1376 p_Setm(d_p, d_r);
1377 return d_p;
1378}
BOOLEAN p_CheckRing(ring r)
Definition pDebug.cc:131

◆ p_LmIsConstant()

static BOOLEAN p_LmIsConstant ( const poly p,
const ring r )
inlinestatic

Definition at line 1025 of file p_polys.h.

1026{
1027 if (p_LmIsConstantComp(p, r))
1028 return (p_GetComp(p, r) == 0);
1029 return FALSE;
1030}

◆ p_LmIsConstantComp()

static BOOLEAN p_LmIsConstantComp ( const poly p,
const ring r )
inlinestatic

Definition at line 1008 of file p_polys.h.

1009{
1010 //p_LmCheckPolyRing(p, r);
1011 int i = r->VarL_Size - 1;
1012
1013 do
1014 {
1015 if (p->exp[r->VarL_Offset[i]] != 0)
1016 return FALSE;
1017 i--;
1018 }
1019 while (i >= 0);
1020 return TRUE;
1021}

◆ p_LmShallowCopyDelete()

static poly p_LmShallowCopyDelete ( poly p,
const ring r )
inlinestatic

Definition at line 1409 of file p_polys.h.

1410{
1412 pAssume1(omSizeWOfBin(bin) == omSizeWOfBin(r->PolyBin));
1413 poly new_p = p_New(r);
1414 memcpy(new_p->exp, p->exp, r->ExpL_Size*sizeof(long));
1415 pSetCoeff0(new_p, pGetCoeff(p));
1416 pNext(new_p) = pNext(p);
1418 return new_p;
1419}
static poly p_New(const ring, omBin bin)
Definition p_polys.h:666

◆ p_LmShortDivisibleBy()

static BOOLEAN p_LmShortDivisibleBy ( poly a,
unsigned long sev_a,
poly b,
unsigned long not_sev_b,
const ring r )
inlinestatic

Definition at line 1926 of file p_polys.h.

1928{
1929 p_LmCheckPolyRing1(a, r);
1931#ifndef PDIV_DEBUG
1932 _pPolyAssume2(p_GetShortExpVector(a, r) == sev_a, a, r);
1933 _pPolyAssume2(p_GetShortExpVector(b, r) == ~ not_sev_b, b, r);
1934
1935 if (sev_a & not_sev_b)
1936 {
1938 return FALSE;
1939 }
1940 return p_LmDivisibleBy(a, b, r);
1941#else
1942 return pDebugLmShortDivisibleBy(a, sev_a, r, b, not_sev_b, r);
1943#endif
1944}
#define _pPolyAssume2(cond, p, r)
Definition monomials.h:195
static BOOLEAN p_LmDivisibleByNoComp(poly a, poly b, const ring r)
Definition p_polys.h:1893
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
Definition p_polys.h:1907
unsigned long p_GetShortExpVector(const poly a, const ring r)
Definition p_polys.cc:4889

◆ p_LmShortDivisibleByNoComp()

static BOOLEAN p_LmShortDivisibleByNoComp ( poly a,
unsigned long sev_a,
poly b,
unsigned long not_sev_b,
const ring r )
inlinestatic

Definition at line 1946 of file p_polys.h.

1948{
1949 p_LmCheckPolyRing1(a, r);
1951#ifndef PDIV_DEBUG
1952 _pPolyAssume2(p_GetShortExpVector(a, r) == sev_a, a, r);
1953 _pPolyAssume2(p_GetShortExpVector(b, r) == ~ not_sev_b, b, r);
1954
1955 if (sev_a & not_sev_b)
1956 {
1958 return FALSE;
1959 }
1960 return p_LmDivisibleByNoComp(a, b, r);
1961#else
1962 return pDebugLmShortDivisibleByNoComp(a, sev_a, r, b, not_sev_b, r);
1963#endif
1964}

◆ p_LowVar()

int p_LowVar ( poly p,
const ring r )

the minimal index of used variables - 1

Definition at line 4789 of file p_polys.cc.

4790{
4791 int k,l,lex;
4792
4793 if (p == NULL) return -1;
4794
4795 k = 32000;/*a very large dummy value*/
4796 while (p != NULL)
4797 {
4798 l = 1;
4799 lex = p_GetExp(p,l,r);
4800 while ((l < (rVar(r))) && (lex == 0))
4801 {
4802 l++;
4803 lex = p_GetExp(p,l,r);
4804 }
4805 l--;
4806 if (l < k) k = l;
4807 pIter(p);
4808 }
4809 return k;
4810}

◆ p_LtCmp()

static int p_LtCmp ( poly p,
poly q,
const ring r )
inlinestatic

Definition at line 1637 of file p_polys.h.

1638{
1639 int res = p_LmCmp(p,q,r);
1640 if(res == 0)
1641 {
1642 if(p_GetCoeff(p,r) == NULL || p_GetCoeff(q,r) == NULL)
1643 return res;
1644 number pc = n_Copy(p_GetCoeff(p,r),r->cf);
1645 number qc = n_Copy(p_GetCoeff(q,r),r->cf);
1646 if(!n_GreaterZero(pc,r->cf))
1647 pc = n_InpNeg(pc,r->cf);
1648 if(!n_GreaterZero(qc,r->cf))
1649 qc = n_InpNeg(qc,r->cf);
1650 if(n_Greater(pc,qc,r->cf))
1651 res = 1;
1652 else if(n_Greater(qc,pc,r->cf))
1653 res = -1;
1654 else if(n_Equal(pc,qc,r->cf))
1655 res = 0;
1656 n_Delete(&pc,r->cf);
1657 n_Delete(&qc,r->cf);
1658 }
1659 return res;
1660}
static FORCE_INLINE BOOLEAN n_Greater(number a, number b, const coeffs r)
ordered fields: TRUE iff 'a' is larger than 'b'; in Z/pZ: TRUE iff la > lb, where la and lb are the l...
Definition coeffs.h:515

◆ p_LtCmpNoAbs()

static int p_LtCmpNoAbs ( poly p,
poly q,
const ring r )
inlinestatic

Definition at line 1663 of file p_polys.h.

1664{
1665 int res = p_LmCmp(p,q,r);
1666 if(res == 0)
1667 {
1668 if(p_GetCoeff(p,r) == NULL || p_GetCoeff(q,r) == NULL)
1669 return res;
1670 number pc = p_GetCoeff(p,r);
1671 number qc = p_GetCoeff(q,r);
1672 if(n_Greater(pc,qc,r->cf))
1673 res = 1;
1674 if(n_Greater(qc,pc,r->cf))
1675 res = -1;
1676 if(n_Equal(pc,qc,r->cf))
1677 res = 0;
1678 }
1679 return res;
1680}

◆ p_LtCmpOrdSgnDiffM()

static int p_LtCmpOrdSgnDiffM ( poly p,
poly q,
const ring r )
inlinestatic

Definition at line 1685 of file p_polys.h.

1686{
1687 return(p_LtCmp(p,q,r) == r->OrdSgn);
1688}
static int p_LtCmp(poly p, poly q, const ring r)
Definition p_polys.h:1637

◆ p_LtCmpOrdSgnDiffP()

static int p_LtCmpOrdSgnDiffP ( poly p,
poly q,
const ring r )
inlinestatic

Definition at line 1694 of file p_polys.h.

1695{
1696 if(r->OrdSgn == 1)
1697 {
1698 return(p_LmCmp(p,q,r) == -1);
1699 }
1700 else
1701 {
1702 return(p_LtCmp(p,q,r) != -1);
1703 }
1704}

◆ p_LtCmpOrdSgnEqM()

static int p_LtCmpOrdSgnEqM ( poly p,
poly q,
const ring r )
inlinestatic

Definition at line 1710 of file p_polys.h.

1711{
1712 return(p_LtCmp(p,q,r) == -r->OrdSgn);
1713}

◆ p_LtCmpOrdSgnEqP()

static int p_LtCmpOrdSgnEqP ( poly p,
poly q,
const ring r )
inlinestatic

Definition at line 1719 of file p_polys.h.

1720{
1721 return(p_LtCmp(p,q,r) == r->OrdSgn);
1722}

◆ p_MaxComp() [1/2]

static long p_MaxComp ( poly p,
ring lmRing )
inlinestatic

Definition at line 313 of file p_polys.h.

313{return p_MaxComp(p,lmRing,lmRing);}
static long p_MaxComp(poly p, ring lmRing, ring tailRing)
Definition p_polys.h:294

◆ p_MaxComp() [2/2]

static long p_MaxComp ( poly p,
ring lmRing,
ring tailRing )
inlinestatic

Definition at line 294 of file p_polys.h.

295{
296 long result,i;
297
298 if(p==NULL) return 0;
299 result = p_GetComp(p, lmRing);
300 if (result != 0)
301 {
302 loop
303 {
304 pIter(p);
305 if(p==NULL) break;
306 i = p_GetComp(p, tailRing);
307 if (i>result) result = i;
308 }
309 }
310 return result;
311}

◆ p_MaxExpPerVar()

int p_MaxExpPerVar ( poly p,
int i,
const ring r )

max exponent of variable x_i in p

Definition at line 5101 of file p_polys.cc.

5102{
5103 int m=0;
5104 while(p!=NULL)
5105 {
5106 int mm=p_GetExp(p,i,r);
5107 if (mm>m) m=mm;
5108 pIter(p);
5109 }
5110 return m;
5111}

◆ p_MDivide()

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

Definition at line 1493 of file p_polys.cc.

1494{
1495 assume((p_GetComp(a,r)==p_GetComp(b,r)) || (p_GetComp(b,r)==0));
1496 int i;
1497 poly result = p_Init(r);
1498
1499 for(i=(int)r->N; i; i--)
1500 p_SetExp(result,i, p_GetExp(a,i,r)- p_GetExp(b,i,r),r);
1501 p_SetComp(result, p_GetComp(a,r) - p_GetComp(b,r),r);
1502 p_Setm(result,r);
1503 return result;
1504}

◆ p_MemAdd_NegWeightAdjust()

static void p_MemAdd_NegWeightAdjust ( poly p,
const ring r )
inlinestatic

Definition at line 1308 of file p_polys.h.

1309{
1310 if (r->NegWeightL_Offset != NULL)
1311 {
1312 for (int i=r->NegWeightL_Size-1; i>=0; i--)
1313 {
1314 p->exp[r->NegWeightL_Offset[i]] -= POLY_NEGWEIGHT_OFFSET;
1315 }
1316 }
1317}

◆ p_MemSub_NegWeightAdjust()

static void p_MemSub_NegWeightAdjust ( poly p,
const ring r )
inlinestatic

Definition at line 1318 of file p_polys.h.

1319{
1320 if (r->NegWeightL_Offset != NULL)
1321 {
1322 for (int i=r->NegWeightL_Size-1; i>=0; i--)
1323 {
1324 p->exp[r->NegWeightL_Offset[i]] += POLY_NEGWEIGHT_OFFSET;
1325 }
1326 }
1327}

◆ p_Merge_q()

static poly p_Merge_q ( poly p,
poly q,
const ring r )
inlinestatic

Definition at line 1228 of file p_polys.h.

1229{
1230 assume( (p != q) || (p == NULL && q == NULL) );
1231 return r->p_Procs->p_Merge_q(p, q, r);
1232}

◆ p_MinComp() [1/2]

static long p_MinComp ( poly p,
ring lmRing )
inlinestatic

Definition at line 334 of file p_polys.h.

334{return p_MinComp(p,lmRing,lmRing);}
static long p_MinComp(poly p, ring lmRing, ring tailRing)
Definition p_polys.h:315

◆ p_MinComp() [2/2]

static long p_MinComp ( poly p,
ring lmRing,
ring tailRing )
inlinestatic

Definition at line 315 of file p_polys.h.

316{
317 long result,i;
318
319 if(p==NULL) return 0;
320 result = p_GetComp(p,lmRing);
321 if (result != 0)
322 {
323 loop
324 {
325 pIter(p);
326 if(p==NULL) break;
327 i = p_GetComp(p,tailRing);
328 if (i<result) result = i;
329 }
330 }
331 return result;
332}

◆ p_MinDeg()

int p_MinDeg ( poly p,
intvec * w,
const ring R )

Definition at line 4557 of file p_polys.cc.

4558{
4559 if(p==NULL)
4560 return -1;
4561 int d=-1;
4562 while(p!=NULL)
4563 {
4564 int d0=0;
4565 for(int j=0;j<rVar(R);j++)
4566 if(w==NULL||j>=w->length())
4567 d0+=p_GetExp(p,j+1,R);
4568 else
4569 d0+=(*w)[j]*p_GetExp(p,j+1,R);
4570 if(d0<d||d==-1)
4571 d=d0;
4572 pIter(p);
4573 }
4574 return d;
4575}

◆ p_mInit()

poly p_mInit ( const char * s,
BOOLEAN & ok,
const ring r )

Definition at line 1443 of file p_polys.cc.

1444{
1445 poly p;
1446 char *sst=(char*)st;
1447 BOOLEAN neg=FALSE;
1448 if (sst[0]=='-') { neg=TRUE; sst=sst+1; }
1449 const char *s=p_Read(sst,p,r);
1450 if (*s!='\0')
1451 {
1452 if ((s!=sst)&&isdigit(sst[0]))
1453 {
1455 }
1456 ok=FALSE;
1457 if (p!=NULL)
1458 {
1459 if (pGetCoeff(p)==NULL) p_LmFree(p,r);
1460 else p_LmDelete(p,r);
1461 }
1462 return NULL;
1463 }
1464 p_Test(p,r);
1465 ok=!errorreported;
1466 if (neg) p=p_Neg(p,r);
1467 return p;
1468}
VAR short errorreported
Definition feFopen.cc:23
const char * p_Read(const char *st, poly &rc, const ring r)
Definition p_polys.cc:1371

◆ p_Minus_mm_Mult_qq() [1/2]

static poly p_Minus_mm_Mult_qq ( poly p,
const poly m,
const poly q,
const ring r )
inlinestatic

Definition at line 1083 of file p_polys.h.

1084{
1085 int shorter;
1086
1087 return r->p_Procs->p_Minus_mm_Mult_qq(p, m, q, shorter, NULL, r);
1088}

◆ p_Minus_mm_Mult_qq() [2/2]

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 )
inlinestatic

Definition at line 1072 of file p_polys.h.

1074{
1075 int shorter;
1076 const poly res = r->p_Procs->p_Minus_mm_Mult_qq(p, m, q, shorter, spNoether, r);
1077 lp += lq - shorter;
1078// assume( lp == pLength(res) );
1079 return res;
1080}

◆ p_mm_Mult()

static poly p_mm_Mult ( poly p,
poly m,
const ring r )
inlinestatic

Definition at line 1063 of file p_polys.h.

1064{
1065 if (p==NULL) return NULL;
1066 if (p_LmIsConstant(m, r))
1067 return __p_Mult_nn(p, pGetCoeff(m), r);
1068 else
1069 return r->p_Procs->p_mm_Mult(p, m, r);
1070}

◆ p_Mult_mm()

static poly p_Mult_mm ( poly p,
poly m,
const ring r )
inlinestatic

Definition at line 1053 of file p_polys.h.

1054{
1055 if (p==NULL) return NULL;
1056 if (p_LmIsConstant(m, r))
1057 return __p_Mult_nn(p, pGetCoeff(m), r);
1058 else
1059 return r->p_Procs->p_Mult_mm(p, m, r);
1060}

◆ p_Mult_nn() [1/2]

static poly p_Mult_nn ( poly p,
number n,
const ring lmRing,
const ring tailRing )
inlinestatic

Definition at line 975 of file p_polys.h.

977{
978 assume(p!=NULL);
979#ifndef PDEBUG
980 if (lmRing == tailRing)
981 return p_Mult_nn(p, n, tailRing);
982#endif
983 poly pnext = pNext(p);
984 pNext(p) = NULL;
985 p = lmRing->p_Procs->p_Mult_nn(p, n, lmRing);
986 if (pnext!=NULL)
987 {
988 pNext(p) = tailRing->p_Procs->p_Mult_nn(pnext, n, tailRing);
989 }
990 return p;
991}
static poly p_Mult_nn(poly p, number n, const ring r)
Definition p_polys.h:960

◆ p_Mult_nn() [2/2]

static poly p_Mult_nn ( poly p,
number n,
const ring r )
inlinestatic

Definition at line 960 of file p_polys.h.

961{
962 if (p==NULL) return NULL;
963 if (n_IsOne(n, r->cf))
964 return p;
965 else if (n_IsZero(n, r->cf))
966 {
967 p_Delete(&p, r); // NOTE: without p_Delete - memory leak!
968 return NULL;
969 }
970 else
971 return r->p_Procs->p_Mult_nn(p, n, r);
972}

◆ p_Mult_q()

static poly p_Mult_q ( poly p,
poly q,
const ring r )
inlinestatic

Definition at line 1120 of file p_polys.h.

1121{
1122 assume( (p != q) || (p == NULL && q == NULL) );
1123
1124 if (UNLIKELY(p == NULL))
1125 {
1126 p_Delete(&q, r);
1127 return NULL;
1128 }
1129 if (UNLIKELY(q == NULL))
1130 {
1131 p_Delete(&p, r);
1132 return NULL;
1133 }
1134
1135 if (pNext(p) == NULL)
1136 {
1137 q = r->p_Procs->p_mm_Mult(q, p, r);
1138 p_LmDelete(&p, r);
1139 return q;
1140 }
1141
1142 if (pNext(q) == NULL)
1143 {
1144 p = r->p_Procs->p_Mult_mm(p, q, r);
1145 p_LmDelete(&q, r);
1146 return p;
1147 }
1148#if defined(HAVE_PLURAL) || defined(HAVE_SHIFTBBA)
1149 if (UNLIKELY(rIsNCRing(r)))
1150 return _nc_p_Mult_q(p, q, r);
1151 else
1152#endif
1153#ifdef HAVE_RINGS
1154 if (UNLIKELY(!nCoeff_is_Domain(r->cf)))
1155 return _p_Mult_q_Normal_ZeroDiv(p, q, 0, r);
1156 else
1157#endif
1158 return _p_Mult_q(p, q, 0, r);
1159}
#define UNLIKELY(X)
Definition auxiliary.h:405
static FORCE_INLINE BOOLEAN nCoeff_is_Domain(const coeffs r)
returns TRUE, if r is a field or r has no zero divisors (i.e is a domain)
Definition coeffs.h:734
poly _nc_p_Mult_q(poly p, poly q, const ring r)
general NC-multiplication with destruction
Definition old.gring.cc:215
poly _p_Mult_q(poly p, poly q, const int copy, const ring r)
Returns: p * q, Destroys: if !copy then p, q Assumes: pLength(p) >= 2 pLength(q) >=2,...
Definition p_Mult_q.cc:309
poly _p_Mult_q_Normal_ZeroDiv(poly p, poly q, const int copy, const ring r)
Definition p_Mult_q.cc:195

◆ p_MultExp()

static long p_MultExp ( poly p,
int v,
long ee,
ring r )
inlinestatic

Definition at line 623 of file p_polys.h.

624{
626 long e = p_GetExp(p,v,r);
627 e *= ee;
628 return p_SetExp(p,v,e,r);
629}

◆ p_Neg()

static poly p_Neg ( poly p,
const ring r )
inlinestatic

Definition at line 1109 of file p_polys.h.

1110{
1111 return r->p_Procs->p_Neg(p, r);
1112}

◆ p_New() [1/2]

static poly p_New ( const ring ,
omBin bin )
inlinestatic

Definition at line 666 of file p_polys.h.

668{
669 p_CheckRing2(r);
670 pAssume2(bin != NULL && omSizeWOfBin(r->PolyBin) == omSizeWOfBin(bin));
671 poly p;
672 omTypeAllocBin(poly, p, bin);
673 p_SetRingOfLm(p, r);
674 return p;
675}
#define p_CheckRing2(r)
Definition monomials.h:200

◆ p_New() [2/2]

static poly p_New ( ring r)
inlinestatic

Definition at line 677 of file p_polys.h.

678{
679 return p_New(r, r->PolyBin);
680}

◆ p_Norm()

void p_Norm ( poly p1,
const ring r )

Definition at line 3799 of file p_polys.cc.

3800{
3801 if (UNLIKELY(p1==NULL)) return;
3802 if (rField_is_Ring(r))
3803 {
3804 if(!n_GreaterZero(pGetCoeff(p1),r->cf)) p1 = p_Neg(p1,r);
3805 if (!n_IsUnit(pGetCoeff(p1), r->cf)) return;
3806 // Werror("p_Norm not possible in the case of coefficient rings.");
3807 }
3808 else //(p1!=NULL)
3809 {
3810 if (!n_IsOne(pGetCoeff(p1),r->cf))
3811 {
3812 if (UNLIKELY(pNext(p1)==NULL))
3813 {
3814 p_SetCoeff(p1,n_Init(1,r->cf),r);
3815 return;
3816 }
3817 number k = pGetCoeff(p1);
3818 pSetCoeff0(p1,n_Init(1,r->cf));
3819 poly h = pNext(p1);
3820 if (LIKELY(rField_is_Zp(r)))
3821 {
3822 if (r->cf->ch>32003)
3823 {
3824 number inv=n_Invers(k,r->cf);
3825 while (h!=NULL)
3826 {
3827 number c=n_Mult(pGetCoeff(h),inv,r->cf);
3828 // no need to normalize
3829 p_SetCoeff(h,c,r);
3830 pIter(h);
3831 }
3832 // no need for n_Delete for Zp: n_Delete(&inv,r->cf);
3833 }
3834 else
3835 {
3836 while (h!=NULL)
3837 {
3838 number c=n_Div(pGetCoeff(h),k,r->cf);
3839 // no need to normalize
3840 p_SetCoeff(h,c,r);
3841 pIter(h);
3842 }
3843 }
3844 }
3845 else if(getCoeffType(r->cf)==n_algExt)
3846 {
3847 n_Normalize(k,r->cf);
3848 number inv=n_Invers(k,r->cf);
3849 while (h!=NULL)
3850 {
3851 number c=n_Mult(pGetCoeff(h),inv,r->cf);
3852 // no need to normalize
3853 // normalize already in nMult: Zp_a, Q_a
3854 p_SetCoeff(h,c,r);
3855 pIter(h);
3856 }
3857 n_Delete(&inv,r->cf);
3858 n_Delete(&k,r->cf);
3859 }
3860 else
3861 {
3862 n_Normalize(k,r->cf);
3863 while (h!=NULL)
3864 {
3865 number c=n_Div(pGetCoeff(h),k,r->cf);
3866 // no need to normalize: Z/p, R
3867 // remains: Q
3868 if (rField_is_Q(r)) n_Normalize(c,r->cf);
3869 p_SetCoeff(h,c,r);
3870 pIter(h);
3871 }
3872 n_Delete(&k,r->cf);
3873 }
3874 }
3875 else
3876 {
3877 //if (r->cf->cfNormalize != nDummy2) //TODO: OPTIMIZE
3878 if (rField_is_Q(r))
3879 {
3880 poly h = pNext(p1);
3881 while (h!=NULL)
3882 {
3883 n_Normalize(pGetCoeff(h),r->cf);
3884 pIter(h);
3885 }
3886 }
3887 }
3888 }
3889}
#define LIKELY(X)
Definition auxiliary.h:404

◆ p_Normalize()

void p_Normalize ( poly p,
const ring r )

Definition at line 3894 of file p_polys.cc.

3895{
3896 const coeffs cf=r->cf;
3897 /* Z/p, GF(p,n), R, long R/C, Nemo rings */
3898 if (cf->cfNormalize==ndNormalize)
3899 return;
3900 while (p!=NULL)
3901 {
3902 // no test before n_Normalize: n_Normalize should fix problems
3904 pIter(p);
3905 }
3906}
void ndNormalize(number &, const coeffs)
Definition numbers.cc:185

◆ p_NSet()

poly p_NSet ( number n,
const ring r )

returns the poly representing the number n, destroys n

Definition at line 1474 of file p_polys.cc.

1475{
1476 if (n_IsZero(n,r->cf))
1477 {
1478 n_Delete(&n, r->cf);
1479 return NULL;
1480 }
1481 else
1482 {
1483 poly rc = p_Init(r);
1484 pSetCoeff0(rc,n);
1485 return rc;
1486 }
1487}

◆ p_One()

poly p_One ( const ring r)

Definition at line 1314 of file p_polys.cc.

1315{
1316 poly rc = p_Init(r);
1317 pSetCoeff0(rc,n_Init(1,r->cf));
1318 return rc;
1319}

◆ p_OneComp()

BOOLEAN p_OneComp ( poly p,
const ring r )

return TRUE if all monoms have the same component

Definition at line 1209 of file p_polys.cc.

1210{
1211 if(p!=NULL)
1212 {
1213 long i = p_GetComp(p, r);
1214 while (pNext(p)!=NULL)
1215 {
1216 pIter(p);
1217 if(i != p_GetComp(p, r)) return FALSE;
1218 }
1219 }
1220 return TRUE;
1221}

◆ p_PermPoly()

poly p_PermPoly ( poly p,
const int * perm,
const ring OldRing,
const ring dst,
nMapFunc nMap,
const int * par_perm = NULL,
int OldPar = 0,
BOOLEAN use_mult = FALSE )

Definition at line 4211 of file p_polys.cc.

4213{
4214#if 0
4215 p_Test(p, oldRing);
4216 PrintS("p_PermPoly::p: "); p_Write(p, oldRing, oldRing);
4217#endif
4218 const int OldpVariables = rVar(oldRing);
4219 poly result = NULL;
4220 poly result_last = NULL;
4221 poly aq = NULL; /* the map coefficient */
4222 poly qq; /* the mapped monomial */
4223 assume(dst != NULL);
4224 assume(dst->cf != NULL);
4225 #ifdef HAVE_PLURAL
4226 poly tmp_mm=p_One(dst);
4227 #endif
4228 while (p != NULL)
4229 {
4230 // map the coefficient
4231 if ( ((OldPar == 0) || (par_perm == NULL) || rField_is_GF(oldRing) || (nMap==ndCopyMap))
4232 && (nMap != NULL) )
4233 {
4234 qq = p_Init(dst);
4235 assume( nMap != NULL );
4236 number n = nMap(p_GetCoeff(p, oldRing), oldRing->cf, dst->cf);
4237 n_Test (n,dst->cf);
4238 if ( nCoeff_is_algExt(dst->cf) )
4239 n_Normalize(n, dst->cf);
4240 p_GetCoeff(qq, dst) = n;// Note: n can be a ZERO!!!
4241 }
4242 else
4243 {
4244 qq = p_One(dst);
4245// aq = naPermNumber(p_GetCoeff(p, oldRing), par_perm, OldPar, oldRing); // no dst???
4246// poly n_PermNumber(const number z, const int *par_perm, const int P, const ring src, const ring dst)
4247 aq = n_PermNumber(p_GetCoeff(p, oldRing), par_perm, OldPar, oldRing, dst);
4248 p_Test(aq, dst);
4249 if ( nCoeff_is_algExt(dst->cf) )
4250 p_Normalize(aq,dst);
4251 if (aq == NULL)
4252 p_SetCoeff(qq, n_Init(0, dst->cf),dst); // Very dirty trick!!!
4253 p_Test(aq, dst);
4254 }
4255 if (rRing_has_Comp(dst))
4256 p_SetComp(qq, p_GetComp(p, oldRing), dst);
4257 if ( n_IsZero(pGetCoeff(qq), dst->cf) )
4258 {
4259 p_LmDelete(&qq,dst);
4260 qq = NULL;
4261 }
4262 else
4263 {
4264 // map pars:
4265 int mapped_to_par = 0;
4266 for(int i = 1; i <= OldpVariables; i++)
4267 {
4268 int e = p_GetExp(p, i, oldRing);
4269 if (e != 0)
4270 {
4271 if (perm==NULL)
4272 p_SetExp(qq, i, e, dst);
4273 else if (perm[i]>0)
4274 {
4275 #ifdef HAVE_PLURAL
4276 if(use_mult)
4277 {
4278 p_SetExp(tmp_mm,perm[i],e,dst);
4279 p_Setm(tmp_mm,dst);
4280 qq=p_Mult_mm(qq,tmp_mm,dst);
4281 p_SetExp(tmp_mm,perm[i],0,dst);
4282
4283 }
4284 else
4285 #endif
4286 p_AddExp(qq,perm[i], e/*p_GetExp( p,i,oldRing)*/, dst);
4287 }
4288 else if (perm[i]<0)
4289 {
4290 number c = p_GetCoeff(qq, dst);
4291 if (rField_is_GF(dst))
4292 {
4293 assume( dst->cf->extRing == NULL );
4294 number ee = n_Param(1, dst);
4295 number eee;
4296 n_Power(ee, e, &eee, dst->cf); //nfDelete(ee,dst);
4297 ee = n_Mult(c, eee, dst->cf);
4298 //nfDelete(c,dst);nfDelete(eee,dst);
4299 pSetCoeff0(qq,ee);
4300 }
4301 else if (nCoeff_is_Extension(dst->cf))
4302 {
4303 const int par = -perm[i];
4304 assume( par > 0 );
4305// WarnS("longalg missing 3");
4306#if 1
4307 const coeffs C = dst->cf;
4308 assume( C != NULL );
4309 const ring R = C->extRing;
4310 assume( R != NULL );
4311 assume( par <= rVar(R) );
4312 poly pcn; // = (number)c
4313 assume( !n_IsZero(c, C) );
4314 if( nCoeff_is_algExt(C) )
4315 pcn = (poly) c;
4316 else // nCoeff_is_transExt(C)
4317 pcn = NUM((fraction)c);
4318 if (pNext(pcn) == NULL) // c->z
4319 p_AddExp(pcn, -perm[i], e, R);
4320 else /* more difficult: we have really to multiply: */
4321 {
4322 poly mmc = p_ISet(1, R);
4323 p_SetExp(mmc, -perm[i], e, R);
4324 p_Setm(mmc, R);
4325 number nnc;
4326 // convert back to a number: number nnc = mmc;
4327 if( nCoeff_is_algExt(C) )
4328 nnc = (number) mmc;
4329 else // nCoeff_is_transExt(C)
4330 nnc = ntInit(mmc, C);
4331 p_GetCoeff(qq, dst) = n_Mult((number)c, nnc, C);
4332 n_Delete((number *)&c, C);
4333 n_Delete((number *)&nnc, C);
4334 }
4335 mapped_to_par=1;
4336#endif
4337 }
4338 }
4339 else
4340 {
4341 /* this variable maps to 0 !*/
4342 p_LmDelete(&qq, dst);
4343 break;
4344 }
4345 }
4346 }
4347 if ( mapped_to_par && (qq!= NULL) && nCoeff_is_algExt(dst->cf) )
4348 {
4349 number n = p_GetCoeff(qq, dst);
4350 n_Normalize(n, dst->cf);
4351 p_GetCoeff(qq, dst) = n;
4352 }
4353 }
4354 pIter(p);
4355
4356#if 0
4357 p_Test(aq,dst);
4358 PrintS("aq: "); p_Write(aq, dst, dst);
4359#endif
4360
4361
4362#if 1
4363 if (qq!=NULL)
4364 {
4365 p_Setm(qq,dst);
4366
4367 p_Test(aq,dst);
4368 p_Test(qq,dst);
4369
4370#if 0
4371 PrintS("qq: "); p_Write(qq, dst, dst);
4372#endif
4373
4374 if (aq!=NULL)
4375 qq=p_Mult_q(aq,qq,dst);
4376 aq = qq;
4377 while (pNext(aq) != NULL) pIter(aq);
4378 if (result_last==NULL)
4379 {
4380 result=qq;
4381 }
4382 else
4383 {
4384 pNext(result_last)=qq;
4385 }
4386 result_last=aq;
4387 aq = NULL;
4388 }
4389 else if (aq!=NULL)
4390 {
4391 p_Delete(&aq,dst);
4392 }
4393 }
4394 result=p_SortAdd(result,dst);
4395#else
4396 // if (qq!=NULL)
4397 // {
4398 // pSetm(qq);
4399 // pTest(qq);
4400 // pTest(aq);
4401 // if (aq!=NULL) qq=pMult(aq,qq);
4402 // aq = qq;
4403 // while (pNext(aq) != NULL) pIter(aq);
4404 // pNext(aq) = result;
4405 // aq = NULL;
4406 // result = qq;
4407 // }
4408 // else if (aq!=NULL)
4409 // {
4410 // pDelete(&aq);
4411 // }
4412 //}
4413 //p = result;
4414 //result = NULL;
4415 //while (p != NULL)
4416 //{
4417 // qq = p;
4418 // pIter(p);
4419 // qq->next = NULL;
4420 // result = pAdd(result, qq);
4421 //}
4422#endif
4423 p_Test(result,dst);
4424#if 0
4425 p_Test(result,dst);
4426 PrintS("result: "); p_Write(result,dst,dst);
4427#endif
4428 #ifdef HAVE_PLURAL
4429 p_LmDelete(&tmp_mm,dst);
4430 #endif
4431 return result;
4432}
static FORCE_INLINE number n_Param(const int iParameter, const coeffs r)
return the (iParameter^th) parameter as a NEW number NOTE: parameter numbering: 1....
Definition coeffs.h:776
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
Definition coeffs.h:839
number ndCopyMap(number a, const coeffs src, const coeffs dst)
Definition numbers.cc:287
static FORCE_INLINE void n_Power(number a, int b, number *res, const coeffs r)
fill res with the power a^b
Definition coeffs.h:633
poly n_PermNumber(const number z, const int *par_perm, const int, const ring src, const ring dst)
Definition p_polys.cc:4108
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
Definition p_polys.cc:1298
poly p_One(const ring r)
Definition p_polys.cc:1314
void p_Write(poly p, ring lmRing, ring tailRing)
Definition polys0.cc:342
static poly p_Mult_mm(poly p, poly m, const ring r)
Definition p_polys.h:1053
static poly p_SortAdd(poly p, const ring r, BOOLEAN revert=FALSE)
Definition p_polys.h:1235
static BOOLEAN rField_is_GF(const ring r)
Definition ring.h:527
number ntInit(long i, const coeffs cf)
Definition transext.cc:704

◆ p_Plus_mm_Mult_qq() [1/2]

static poly p_Plus_mm_Mult_qq ( poly p,
poly m,
poly q,
const ring r )
inlinestatic

Definition at line 1221 of file p_polys.h.

1222{
1223 int lp = 0, lq = 0;
1224 return p_Plus_mm_Mult_qq(p, m, q, lp, lq, r);
1225}

◆ p_Plus_mm_Mult_qq() [2/2]

static poly p_Plus_mm_Mult_qq ( poly p,
poly m,
poly q,
int & lp,
int lq,
const ring r )
inlinestatic

Definition at line 1199 of file p_polys.h.

1201{
1202#ifdef HAVE_PLURAL
1203 if (rIsPluralRing(r))
1204 return nc_p_Plus_mm_Mult_qq(p, m, q, lp, lq, r);
1205#endif
1206
1207// this should be implemented more efficiently
1208 poly res;
1209 int shorter;
1210 number n_old = pGetCoeff(m);
1211 number n_neg = n_Copy(n_old, r->cf);
1212 n_neg = n_InpNeg(n_neg, r->cf);
1213 pSetCoeff0(m, n_neg);
1214 res = r->p_Procs->p_Minus_mm_Mult_qq(p, m, q, shorter, NULL, r);
1215 lp = (lp + lq) - shorter;
1216 pSetCoeff0(m, n_old);
1217 n_Delete(&n_neg, r->cf);
1218 return res;
1219}
poly nc_p_Plus_mm_Mult_qq(poly p, const poly m, const poly q, int &lp, const int, const ring r)
Definition old.gring.cc:168
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition ring.h:406

◆ p_PolyDiv()

poly p_PolyDiv ( poly & p,
const poly divisor,
const BOOLEAN needResult,
const ring r )

assumes that p and divisor are univariate polynomials in r, mentioning the same variable; assumes divisor != NULL; p may be NULL; assumes a global monomial ordering in r; performs polynomial division of p by divisor:

  • afterwards p contains the remainder of the division, i.e., p_before = result * divisor + p_afterwards;
  • if needResult == TRUE, then the method computes and returns 'result', otherwise NULL is returned (This parametrization can be used when one is only interested in the remainder of the division. In this case, the method will be slightly faster.) leaves divisor unmodified

Definition at line 1874 of file p_polys.cc.

1875{
1876 assume(divisor != NULL);
1877 if (p == NULL) return NULL;
1878
1879 poly result = NULL;
1880 number divisorLC = p_GetCoeff(divisor, r);
1881 int divisorLE = p_GetExp(divisor, 1, r);
1882 while ((p != NULL) && (p_Deg(p, r) >= p_Deg(divisor, r)))
1883 {
1884 /* determine t = LT(p) / LT(divisor) */
1885 poly t = p_ISet(1, r);
1886 number c = n_Div(p_GetCoeff(p, r), divisorLC, r->cf);
1887 n_Normalize(c,r->cf);
1888 p_SetCoeff(t, c, r);
1889 int e = p_GetExp(p, 1, r) - divisorLE;
1890 p_SetExp(t, 1, e, r);
1891 p_Setm(t, r);
1892 if (needResult) result = p_Add_q(result, p_Copy(t, r), r);
1893 p = p_Add_q(p, p_Neg(p_Mult_q(t, p_Copy(divisor, r), r), r), r);
1894 }
1895 return result;
1896}
long p_Deg(poly a, const ring r)
Definition p_polys.cc:586

◆ p_Power()

poly p_Power ( poly p,
int i,
const ring r )

Definition at line 2201 of file p_polys.cc.

2202{
2203 poly rc=NULL;
2204
2205 if (i==0)
2206 {
2207 p_Delete(&p,r);
2208 return p_One(r);
2209 }
2210
2211 if(p!=NULL)
2212 {
2213 if ( (i > 0) && ((unsigned long ) i > (r->bitmask))
2214 #ifdef HAVE_SHIFTBBA
2215 && (!rIsLPRing(r))
2216 #endif
2217 )
2218 {
2219 Werror("exponent %d is too large, max. is %ld",i,r->bitmask);
2220 return NULL;
2221 }
2222 switch (i)
2223 {
2224// cannot happen, see above
2225// case 0:
2226// {
2227// rc=pOne();
2228// pDelete(&p);
2229// break;
2230// }
2231 case 1:
2232 rc=p;
2233 break;
2234 case 2:
2235 rc=p_Mult_q(p_Copy(p,r),p,r);
2236 break;
2237 default:
2238 if (i < 0)
2239 {
2240 p_Delete(&p,r);
2241 return NULL;
2242 }
2243 else
2244 {
2245#ifdef HAVE_PLURAL
2246 if (rIsNCRing(r)) /* in the NC case nothing helps :-( */
2247 {
2248 int j=i;
2249 rc = p_Copy(p,r);
2250 while (j>1)
2251 {
2252 rc = p_Mult_q(p_Copy(p,r),rc,r);
2253 j--;
2254 }
2255 p_Delete(&p,r);
2256 return rc;
2257 }
2258#endif
2259 rc = pNext(p);
2260 if (rc == NULL)
2261 return p_MonPower(p,i,r);
2262 /* else: binom ?*/
2263 int char_p=rInternalChar(r);
2264 if ((char_p>0) && (i>char_p)
2265 && ((rField_is_Zp(r,char_p)
2266 || (rField_is_Zp_a(r,char_p)))))
2267 {
2268 poly h=p_Pow_charp(p_Copy(p,r),char_p,r);
2269 int rest=i-char_p;
2270 while (rest>=char_p)
2271 {
2272 rest-=char_p;
2273 h=p_Mult_q(h,p_Pow_charp(p_Copy(p,r),char_p,r),r);
2274 }
2275 poly res=h;
2276 if (rest>0)
2277 res=p_Mult_q(p_Power(p_Copy(p,r),rest,r),h,r);
2278 p_Delete(&p,r);
2279 return res;
2280 }
2281 if ((pNext(rc) != NULL)
2282 || rField_is_Ring(r)
2283 )
2284 return p_Pow(p,i,r);
2285 if ((char_p==0) || (i<=char_p))
2286 return p_TwoMonPower(p,i,r);
2287 return p_Pow(p,i,r);
2288 }
2289 /*end default:*/
2290 }
2291 }
2292 return rc;
2293}
poly p_Power(poly p, int i, const ring r)
Definition p_polys.cc:2201
static poly p_TwoMonPower(poly p, int exp, const ring r)
Definition p_polys.cc:2110
static poly p_Pow_charp(poly p, int i, const ring r)
Definition p_polys.cc:2189
static poly p_MonPower(poly p, int exp, const ring r)
Definition p_polys.cc:2004
static poly p_Pow(poly p, int i, const ring r)
Definition p_polys.cc:2175
void Werror(const char *fmt,...)
Definition reporter.cc:189
static int rInternalChar(const ring r)
Definition ring.h:695
static BOOLEAN rIsLPRing(const ring r)
Definition ring.h:417

◆ p_ProjectiveUnique()

void p_ProjectiveUnique ( poly p,
const ring r )

Definition at line 3147 of file p_polys.cc.

3148{
3149 if( ph == NULL )
3150 return;
3151
3152 const coeffs C = r->cf;
3153
3154 number h;
3155 poly p;
3156
3157 if (nCoeff_is_Ring(C))
3158 {
3159 p_ContentForGB(ph,r);
3160 if(!n_GreaterZero(pGetCoeff(ph),C)) ph = p_Neg(ph,r);
3161 assume( n_GreaterZero(pGetCoeff(ph),C) );
3162 return;
3163 }
3164
3166 {
3167 if(!n_GreaterZero(pGetCoeff(ph),C)) ph = p_Neg(ph,r);
3168 return;
3169 }
3170 p = ph;
3171
3172 assume(p != NULL);
3173
3174 if(pNext(p)==NULL) // a monomial
3175 {
3176 p_SetCoeff(p, n_Init(1, C), r);
3177 return;
3178 }
3179
3180 assume(pNext(p)!=NULL);
3181
3182 if(!nCoeff_is_Q(C) && !nCoeff_is_transExt(C))
3183 {
3184 h = p_GetCoeff(p, C);
3185 number hInv = n_Invers(h, C);
3186 pIter(p);
3187 while (p!=NULL)
3188 {
3189 p_SetCoeff(p, n_Mult(p_GetCoeff(p, C), hInv, C), r);
3190 pIter(p);
3191 }
3192 n_Delete(&hInv, C);
3193 p = ph;
3194 p_SetCoeff(p, n_Init(1, C), r);
3195 }
3196
3197 p_Cleardenom(ph, r); //removes also Content
3198
3199
3200 /* normalize ph over a transcendental extension s.t.
3201 lead (ph) is > 0 if extRing->cf == Q
3202 or lead (ph) is monic if extRing->cf == Zp*/
3203 if (nCoeff_is_transExt(C))
3204 {
3205 p= ph;
3206 h= p_GetCoeff (p, C);
3207 fraction f = (fraction) h;
3208 number n=p_GetCoeff (NUM (f),C->extRing->cf);
3209 if (rField_is_Q (C->extRing))
3210 {
3211 if (!n_GreaterZero(n,C->extRing->cf))
3212 {
3213 p=p_Neg (p,r);
3214 }
3215 }
3216 else if (rField_is_Zp(C->extRing))
3217 {
3218 if (!n_IsOne (n, C->extRing->cf))
3219 {
3220 n=n_Invers (n,C->extRing->cf);
3221 nMapFunc nMap;
3222 nMap= n_SetMap (C->extRing->cf, C);
3223 number ninv= nMap (n,C->extRing->cf, C);
3224 p=__p_Mult_nn (p, ninv, r);
3225 n_Delete (&ninv, C);
3226 n_Delete (&n, C->extRing->cf);
3227 }
3228 }
3229 p= ph;
3230 }
3231
3232 return;
3233}
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
Definition coeffs.h:730
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition coeffs.h:793
poly p_Cleardenom(poly p, const ring r)
Definition p_polys.cc:2849

◆ p_Read()

const char * p_Read ( const char * s,
poly & p,
const ring r )

Definition at line 1371 of file p_polys.cc.

1372{
1373 if (r==NULL) { rc=NULL;return st;}
1374 int i,j;
1375 rc = p_Init(r);
1376 const char *s = n_Read(st,&(p_GetCoeff(rc, r)),r->cf);
1377 if (s==st)
1378 /* i.e. it does not start with a coeff: test if it is a ringvar*/
1379 {
1380 j = r_IsRingVar(s,r->names,r->N);
1381 if (j >= 0)
1382 {
1383 p_IncrExp(rc,1+j,r);
1384 while (*s!='\0') s++;
1385 goto done;
1386 }
1387 }
1388 while (*s!='\0')
1389 {
1390 char ss[2];
1391 ss[0] = *s++;
1392 ss[1] = '\0';
1393 j = r_IsRingVar(ss,r->names,r->N);
1394 if (j >= 0)
1395 {
1396 const char *s_save=s;
1397 s = eati(s,&i);
1398 if (((unsigned long)i) > r->bitmask/2)
1399 {
1400 // exponent to large: it is not a monomial
1401 p_LmDelete(&rc,r);
1402 return s_save;
1403 }
1404 p_AddExp(rc,1+j, (long)i, r);
1405 }
1406 else
1407 {
1408 // 1st char of is not a varname
1409 // We return the parsed polynomial nevertheless. This is needed when
1410 // we are parsing coefficients in a rational function field.
1411 s--;
1412 break;
1413 }
1414 }
1415done:
1416 if (n_IsZero(pGetCoeff(rc),r->cf)) p_LmDelete(&rc,r);
1417 else
1418 {
1419#ifdef HAVE_PLURAL
1420 // in super-commutative ring
1421 // squares of anti-commutative variables are zeroes!
1422 if(rIsSCA(r))
1423 {
1424 const unsigned int iFirstAltVar = scaFirstAltVar(r);
1425 const unsigned int iLastAltVar = scaLastAltVar(r);
1426
1427 assume(rc != NULL);
1428
1429 for(unsigned int k = iFirstAltVar; k <= iLastAltVar; k++)
1430 if( p_GetExp(rc, k, r) > 1 )
1431 {
1432 p_LmDelete(&rc, r);
1433 goto finish;
1434 }
1435 }
1436#endif
1437
1438 p_Setm(rc,r);
1439 }
1440finish:
1441 return s;
1442}
static FORCE_INLINE const char * n_Read(const char *s, number *a, const coeffs r)
!!! Recommendation: This method is too cryptic to be part of the user- !!! interface....
Definition coeffs.h:599
const char * eati(const char *s, int *i)
Definition reporter.cc:373
static bool rIsSCA(const ring r)
Definition nc.h:190
static long p_IncrExp(poly p, int v, ring r)
Definition p_polys.h:593
int r_IsRingVar(const char *n, char **names, int N)
Definition ring.cc:213
static short scaLastAltVar(ring r)
Definition sca.h:25
static short scaFirstAltVar(ring r)
Definition sca.h:18

◆ p_Series()

poly p_Series ( int n,
poly p,
poly u,
intvec * w,
const ring R )

Definition at line 4607 of file p_polys.cc.

4608{
4609 int *ww=iv2array(w,R);
4610 if(p!=NULL)
4611 {
4612 if(u==NULL)
4613 p=p_JetW(p,n,ww,R);
4614 else
4615 p=p_JetW(p_Mult_q(p,p_Invers(n-p_MinDeg(p,w,R),u,w,R),R),n,ww,R);
4616 }
4617 omFreeSize((ADDRESS)ww,(rVar(R)+1)*sizeof(int));
4618 return p;
4619}
static poly p_Invers(int n, poly u, intvec *w, const ring R)
Definition p_polys.cc:4578
int p_MinDeg(poly p, intvec *w, const ring R)
Definition p_polys.cc:4557
poly p_JetW(poly p, int m, int *w, const ring R)
Definition p_polys.cc:4539
int * iv2array(intvec *iv, const ring R)
Definition weight.cc:200

◆ p_SetCoeff()

static number p_SetCoeff ( poly p,
number n,
ring r )
inlinestatic

Definition at line 414 of file p_polys.h.

415{
417 n_Delete(&(p->coef), r->cf);
418 (p)->coef=n;
419 return n;
420}

◆ p_SetComp()

static unsigned long p_SetComp ( poly p,
unsigned long c,
ring r )
inlinestatic

Definition at line 249 of file p_polys.h.

250{
252 if (r->pCompIndex>=0) __p_GetComp(p,r) = c;
253 return c;
254}

◆ p_SetCompP() [1/2]

static void p_SetCompP ( poly p,
int i,
ring lmRing,
ring tailRing )
inlinestatic

Definition at line 283 of file p_polys.h.

284{
285 if (p != NULL)
286 {
287 p_SetComp(p, i, lmRing);
288 p_SetmComp(p, lmRing);
289 p_SetCompP(pNext(p), i, tailRing);
290 }
291}

◆ p_SetCompP() [2/2]

static void p_SetCompP ( poly p,
int i,
ring r )
inlinestatic

Definition at line 256 of file p_polys.h.

257{
258 if (p != NULL)
259 {
260 p_Test(p, r);
262 {
263 do
264 {
265 p_SetComp(p, i, r);
266 p_SetmComp(p, r);
267 pIter(p);
268 }
269 while (p != NULL);
270 }
271 else
272 {
273 do
274 {
275 p_SetComp(p, i, r);
276 pIter(p);
277 }
278 while(p != NULL);
279 }
280 }
281}
BOOLEAN rOrd_SetCompRequiresSetm(const ring r)
return TRUE if p_SetComp requires p_Setm
Definition ring.cc:2022

◆ p_SetExp() [1/3]

static long p_SetExp ( poly p,
const int v,
const long e,
const ring r )
inlinestatic

set v^th exponent for a monomial

Definition at line 584 of file p_polys.h.

585{
587 pAssume2(v>0 && v <= r->N);
588 pAssume2(r->VarOffset[v] != -1);
589 return p_SetExp(p, e, r->bitmask, r->VarOffset[v]);
590}

◆ p_SetExp() [2/3]

static long p_SetExp ( poly p,
const long e,
const ring r,
const int VarOffset )
inlinestatic

Definition at line 564 of file p_polys.h.

565{
567 pAssume2(VarOffset != -1);
568 return p_SetExp(p, e, r->bitmask, VarOffset);
569}

◆ p_SetExp() [3/3]

static unsigned long p_SetExp ( poly p,
const unsigned long e,
const unsigned long iBitmask,
const int VarOffset )
inlinestatic

set a single variable exponent @Note: VarOffset encodes the position in p->exp

See also
p_GetExp

Definition at line 490 of file p_polys.h.

491{
492 pAssume2(e>=0);
493 pAssume2(e<=iBitmask);
494 pAssume2((VarOffset >> (24 + 6)) == 0);
495
496 // shift e to the left:
497 REGISTER int shift = VarOffset >> 24;
498 unsigned long ee = e << shift /*(VarOffset >> 24)*/;
499 // find the bits in the exponent vector
500 REGISTER int offset = (VarOffset & 0xffffff);
501 // clear the bits in the exponent vector:
502 p->exp[offset] &= ~( iBitmask << shift );
503 // insert e with |
504 p->exp[ offset ] |= ee;
505 return e;
506}

◆ p_SetExpV()

static void p_SetExpV ( poly p,
int * ev,
const ring r )
inlinestatic

Definition at line 1560 of file p_polys.h.

1561{
1563 for (unsigned j = r->N; j!=0; j--)
1564 p_SetExp(p, j, ev[j], r);
1565
1566 if(ev[0]!=0) p_SetComp(p, ev[0],r);
1567 p_Setm(p, r);
1568}

◆ p_SetExpVL()

static void p_SetExpVL ( poly p,
int64 * ev,
const ring r )
inlinestatic

Definition at line 1569 of file p_polys.h.

1570{
1572 for (unsigned j = r->N; j!=0; j--)
1573 p_SetExp(p, j, ev[j-1], r);
1574 p_SetComp(p, 0,r);
1575
1576 p_Setm(p, r);
1577}

◆ p_SetExpVLV()

static void p_SetExpVLV ( poly p,
int64 * ev,
int64 comp,
const ring r )
inlinestatic

Definition at line 1580 of file p_polys.h.

1581{
1583 for (unsigned j = r->N; j!=0; j--)
1584 p_SetExp(p, j, ev[j-1], r);
1585 p_SetComp(p, comp,r);
1586
1587 p_Setm(p, r);
1588}
int comp(const CanonicalForm &A, const CanonicalForm &B)
compare polynomials

◆ p_Setm()

static void p_Setm ( poly p,
const ring r )
inlinestatic

Definition at line 235 of file p_polys.h.

236{
237 p_CheckRing2(r);
238 r->p_Setm(p, r);
239}

◆ p_SetModDeg()

void p_SetModDeg ( intvec * w,
ring r )

Definition at line 3753 of file p_polys.cc.

3754{
3755 if (w!=NULL)
3756 {
3757 r->pModW = w;
3758 pOldFDeg = r->pFDeg;
3759 pOldLDeg = r->pLDeg;
3760 pOldLexOrder = r->pLexOrder;
3762 r->pLexOrder = TRUE;
3763 }
3764 else
3765 {
3766 r->pModW = NULL;
3768 r->pLexOrder = pOldLexOrder;
3769 }
3770}
STATIC_VAR pLDegProc pOldLDeg
Definition p_polys.cc:3741
void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
Definition p_polys.cc:3729
STATIC_VAR BOOLEAN pOldLexOrder
Definition p_polys.cc:3742
STATIC_VAR pFDegProc pOldFDeg
Definition p_polys.cc:3740
void pSetDegProcs(ring r, pFDegProc new_FDeg, pLDegProc new_lDeg)
Definition p_polys.cc:3717
static long pModDeg(poly p, ring r)
Definition p_polys.cc:3744

◆ p_ShallowCopyDelete()

static poly p_ShallowCopyDelete ( poly p,
const ring r,
omBin bin )
inlinestatic

Definition at line 930 of file p_polys.h.

931{
933 pAssume2(omSizeWOfBin(r->PolyBin) == omSizeWOfBin(bin));
934 return r->p_Procs->p_ShallowCopyDelete(p, r, bin);
935}

◆ p_ShallowDelete()

void p_ShallowDelete ( poly * p,
const ring r )

◆ p_Shift()

void p_Shift ( poly * p,
int i,
const ring r )

shifts components of the vector p by i

Definition at line 4815 of file p_polys.cc.

4816{
4817 poly qp1 = *p,qp2 = *p;/*working pointers*/
4818 int j = p_MaxComp(*p,r),k = p_MinComp(*p,r);
4819
4820 if (j+i < 0) return ;
4821 BOOLEAN toPoly= ((j == -i) && (j == k));
4822 while (qp1 != NULL)
4823 {
4824 if (toPoly || (__p_GetComp(qp1,r)+i > 0))
4825 {
4826 p_AddComp(qp1,i,r);
4827 p_SetmComp(qp1,r);
4828 qp2 = qp1;
4829 pIter(qp1);
4830 }
4831 else
4832 {
4833 if (qp2 == *p)
4834 {
4835 pIter(*p);
4836 p_LmDelete(&qp2,r);
4837 qp2 = *p;
4838 qp1 = *p;
4839 }
4840 else
4841 {
4842 qp2->next = qp1->next;
4843 if (qp1!=NULL) p_LmDelete(&qp1,r);
4844 qp1 = qp2->next;
4845 }
4846 }
4847 }
4848}
return
static unsigned long p_AddComp(poly p, unsigned long v, ring r)
Definition p_polys.h:449

◆ p_SimpleContent()

void p_SimpleContent ( poly p,
int s,
const ring r )

Definition at line 2568 of file p_polys.cc.

2569{
2570 if(TEST_OPT_CONTENTSB) return;
2571 if (ph==NULL) return;
2572 if (pNext(ph)==NULL)
2573 {
2574 p_SetCoeff(ph,n_Init(1,r->cf),r);
2575 return;
2576 }
2577 if (pNext(pNext(ph))==NULL)
2578 {
2579 return;
2580 }
2581 if (!(rField_is_Q(r))
2582 && (!rField_is_Q_a(r))
2583 && (!rField_is_Zp_a(r))
2584 && (!rField_is_Z(r))
2585 )
2586 {
2587 return;
2588 }
2589 number d=p_InitContent(ph,r);
2590 number h=d;
2591 if (n_Size(d,r->cf)<=smax)
2592 {
2593 n_Delete(&h,r->cf);
2594 //if (TEST_OPT_PROT) PrintS("G");
2595 return;
2596 }
2597
2598 poly p=ph;
2599 if (smax==1) smax=2;
2600 while (p!=NULL)
2601 {
2602#if 1
2603 d=n_SubringGcd(h,pGetCoeff(p),r->cf);
2604 n_Delete(&h,r->cf);
2605 h = d;
2606#else
2607 n_InpGcd(h,pGetCoeff(p),r->cf);
2608#endif
2609 if(n_Size(h,r->cf)<smax)
2610 {
2611 //if (TEST_OPT_PROT) PrintS("g");
2612 n_Delete(&h,r->cf);
2613 return;
2614 }
2615 pIter(p);
2616 }
2617 p = ph;
2618 if (!n_GreaterZero(pGetCoeff(p),r->cf)) h=n_InpNeg(h,r->cf);
2619 if(n_IsOne(h,r->cf))
2620 {
2621 n_Delete(&h,r->cf);
2622 return;
2623 }
2624 if (TEST_OPT_PROT) PrintS("c");
2625 while (p!=NULL)
2626 {
2627#if 1
2628 d = n_ExactDiv(pGetCoeff(p),h,r->cf);
2629 p_SetCoeff(p,d,r);
2630#else
2631 STATISTIC(n_ExactDiv); nlInpExactDiv(pGetCoeff(p),h,r->cf); // no such function... ?
2632#endif
2633 pIter(p);
2634 }
2635 n_Delete(&h,r->cf);
2636}
#define TEST_OPT_PROT
Definition options.h:105

◆ p_Size()

int p_Size ( poly p,
const ring r )

Definition at line 3257 of file p_polys.cc.

3258{
3259 int count = 0;
3260 if (r->cf->has_simple_Alloc)
3261 return pLength(p);
3262 while ( p != NULL )
3263 {
3264 count+= n_Size( pGetCoeff( p ), r->cf );
3265 pIter( p );
3266 }
3267 return count;
3268}
int status int void size_t count
Definition si_signals.h:69

◆ p_SortAdd()

static poly p_SortAdd ( poly p,
const ring r,
BOOLEAN revert = FALSE )
inlinestatic

Definition at line 1235 of file p_polys.h.

1236{
1237 if (revert) p = pReverse(p);
1238 return sBucketSortAdd(p, r);
1239}
poly sBucketSortAdd(poly p, const ring r)
Sorts p with bucketSort: p may have equal monomials.
Definition sbuckets.cc:368

◆ p_SortMerge()

static poly p_SortMerge ( poly p,
const ring r,
BOOLEAN revert = FALSE )
inlinestatic

Definition at line 1245 of file p_polys.h.

1246{
1247 if (revert) p = pReverse(p);
1248 return sBucketSortMerge(p, r);
1249}
poly sBucketSortMerge(poly p, const ring r)
Sorts p with bucketSort: assumes all monomials of p are different.
Definition sbuckets.cc:332

◆ p_Split()

void p_Split ( poly p,
poly * r )

Definition at line 1321 of file p_polys.cc.

1322{
1323 *h=pNext(p);
1324 pNext(p)=NULL;
1325}

◆ p_String() [1/2]

char * p_String ( poly p,
ring lmRing,
ring tailRing )

Definition at line 322 of file polys0.cc.

323{
324 StringSetS("");
325 p_String0(p, lmRing, tailRing);
326 return StringEndS();
327}
void p_String0(poly p, ring lmRing, ring tailRing)
print p according to ShortOut in lmRing & tailRing
Definition polys0.cc:223
void StringSetS(const char *st)
Definition reporter.cc:128
char * StringEndS()
Definition reporter.cc:151

◆ p_String() [2/2]

static char * p_String ( poly p,
ring p_ring )
inlinestatic

Definition at line 1256 of file p_polys.h.

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

◆ p_String0() [1/2]

void p_String0 ( poly p,
ring lmRing,
ring tailRing )

print p according to ShortOut in lmRing & tailRing

Definition at line 223 of file polys0.cc.

224{
225 if (p == NULL)
226 {
227 StringAppendS("0");
228 return;
229 }
230 p_Normalize(p,lmRing);
231 if ((n_GetChar(lmRing->cf) == 0)
232 && (nCoeff_is_transExt(lmRing->cf)))
233 p_Normalize(p,lmRing); /* Manual/absfact.tst */
234#ifdef HAVE_SHIFTBBA
235 if(lmRing->isLPring)
236 {
237 if ((p_GetComp(p, lmRing) == 0) || (!lmRing->VectorOut))
238 {
239 writemonLP(p,0, lmRing);
240 p = pNext(p);
241 while (p!=NULL)
242 {
243 assume((p->coef==NULL)||(!n_IsZero(p->coef,tailRing->cf)));
244 if ((p->coef==NULL)||n_GreaterZero(p->coef,tailRing->cf))
245 StringAppendS("+");
246 writemonLP(p,0, tailRing);
247 p = pNext(p);
248 }
249 return;
250 }
251 }
252 else
253#endif
254 {
255 if ((p_GetComp(p, lmRing) == 0) || (!lmRing->VectorOut))
256 {
257 writemon(p,0, lmRing);
258 p = pNext(p);
259 while (p!=NULL)
260 {
261 assume((p->coef==NULL)||(!n_IsZero(p->coef,tailRing->cf)));
262 if ((p->coef==NULL)||n_GreaterZero(p->coef,tailRing->cf))
263 StringAppendS("+");
264 writemon(p,0, tailRing);
265 p = pNext(p);
266 }
267 return;
268 }
269 }
270
271 long k = 1;
272 StringAppendS("[");
273#ifdef HAVE_SHIFTBBA
274 if(lmRing->isLPring)
275 {
276 loop
277 {
278 while (k < p_GetComp(p,lmRing))
279 {
280 StringAppendS("0,");
281 k++;
282 }
283 writemonLP(p,k,lmRing);
284 pIter(p);
285 while ((p!=NULL) && (k == p_GetComp(p, tailRing)))
286 {
287 if (n_GreaterZero(p->coef,tailRing->cf)) StringAppendS("+");
288 writemonLP(p,k,tailRing);
289 pIter(p);
290 }
291 if (p == NULL) break;
292 StringAppendS(",");
293 k++;
294 }
295 }
296 else
297#endif
298 {
299 loop
300 {
301 while (k < p_GetComp(p,lmRing))
302 {
303 StringAppendS("0,");
304 k++;
305 }
306 writemon(p,k,lmRing);
307 pIter(p);
308 while ((p!=NULL) && (k == p_GetComp(p, tailRing)))
309 {
310 if (n_GreaterZero(p->coef,tailRing->cf)) StringAppendS("+");
311 writemon(p,k,tailRing);
312 pIter(p);
313 }
314 if (p == NULL) break;
315 StringAppendS(",");
316 k++;
317 }
318 }
319 StringAppendS("]");
320}
static void writemon(poly p, int ko, const ring r)
Definition polys0.cc:24
static void writemonLP(poly p, int ko, const ring r)
Definition polys0.cc:104
void StringAppendS(const char *st)
Definition reporter.cc:107

◆ p_String0() [2/2]

static void p_String0 ( poly p,
ring p_ring )
inlinestatic

Definition at line 1260 of file p_polys.h.

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

◆ p_String0Long()

void p_String0Long ( const poly p,
ring lmRing,
ring tailRing )

print p in a long way

print p in a long way

Definition at line 203 of file polys0.cc.

204{
205 // NOTE: the following (non-thread-safe!) UGLINESS
206 // (changing naRing->ShortOut for a while) is due to Hans!
207 // Just think of other ring using the VERY SAME naRing and possible
208 // side-effects...
209 // but this is not a problem: i/o is not thread-safe anyway.
210 const BOOLEAN bLMShortOut = rShortOut(lmRing);
211 const BOOLEAN bTAILShortOut = rShortOut(tailRing);
212
213 lmRing->ShortOut = FALSE;
214 tailRing->ShortOut = FALSE;
215
216 p_String0(p, lmRing, tailRing);
217
218 lmRing->ShortOut = bLMShortOut;
219 tailRing->ShortOut = bTAILShortOut;
220}
static BOOLEAN rShortOut(const ring r)
Definition ring.h:587

◆ p_String0Short()

void p_String0Short ( const poly p,
ring lmRing,
ring tailRing )

print p in a short way, if possible

print p in a short way, if possible

Definition at line 184 of file polys0.cc.

185{
186 // NOTE: the following (non-thread-safe!) UGLINESS
187 // (changing naRing->ShortOut for a while) is due to Hans!
188 // Just think of other ring using the VERY SAME naRing and possible
189 // side-effects...
190 const BOOLEAN bLMShortOut = rShortOut(lmRing);
191 const BOOLEAN bTAILShortOut = rShortOut(tailRing);
192
193 lmRing->ShortOut = rCanShortOut(lmRing);
194 tailRing->ShortOut = rCanShortOut(tailRing);
195
196 p_String0(p, lmRing, tailRing);
197
198 lmRing->ShortOut = bLMShortOut;
199 tailRing->ShortOut = bTAILShortOut;
200}
static BOOLEAN rCanShortOut(const ring r)
Definition ring.h:592

◆ p_Sub()

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

Definition at line 1994 of file p_polys.cc.

1995{
1996 return p_Add_q(p1, p_Neg(p2,r),r);
1997}

◆ p_SubComp()

static unsigned long p_SubComp ( poly p,
unsigned long v,
ring r )
inlinestatic

Definition at line 455 of file p_polys.h.

456{
459 _pPolyAssume2(__p_GetComp(p,r) >= v,p,r);
460 return __p_GetComp(p,r) -= v;
461}

◆ p_SubExp()

static long p_SubExp ( poly p,
int v,
long ee,
ring r )
inlinestatic

Definition at line 615 of file p_polys.h.

616{
618 long e = p_GetExp(p,v,r);
619 pAssume2(e >= ee);
620 e -= ee;
621 return p_SetExp(p,v,e,r);
622}

◆ p_Subst()

poly p_Subst ( poly p,
int n,
poly e,
const ring r )

Definition at line 4039 of file p_polys.cc.

4040{
4041#ifdef HAVE_SHIFTBBA
4042 // also don't even use p_Subst0 for Letterplace
4043 if (rIsLPRing(r))
4044 {
4045 poly subst = p_LPSubst(p, n, e, r);
4046 p_Delete(&p, r);
4047 return subst;
4048 }
4049#endif
4050
4051 if (e == NULL) return p_Subst0(p, n,r);
4052
4053 if (p_IsConstant(e,r))
4054 {
4055 if (n_IsOne(pGetCoeff(e),r->cf)) return p_Subst1(p,n,r);
4056 else return p_Subst2(p, n, pGetCoeff(e),r);
4057 }
4058
4059#ifdef HAVE_PLURAL
4060 if (rIsPluralRing(r))
4061 {
4062 return nc_pSubst(p,n,e,r);
4063 }
4064#endif
4065
4066 int exponent,i;
4067 poly h, res, m;
4068 int *me,*ee;
4069 number nu,nu1;
4070
4071 me=(int *)omAlloc((rVar(r)+1)*sizeof(int));
4072 ee=(int *)omAlloc((rVar(r)+1)*sizeof(int));
4073 if (e!=NULL) p_GetExpV(e,ee,r);
4074 res=NULL;
4075 h=p;
4076 while (h!=NULL)
4077 {
4078 if ((e!=NULL) || (p_GetExp(h,n,r)==0))
4079 {
4080 m=p_Head(h,r);
4081 p_GetExpV(m,me,r);
4082 exponent=me[n];
4083 me[n]=0;
4084 for(i=rVar(r);i>0;i--)
4085 me[i]+=exponent*ee[i];
4086 p_SetExpV(m,me,r);
4087 if (e!=NULL)
4088 {
4089 n_Power(pGetCoeff(e),exponent,&nu,r->cf);
4090 nu1=n_Mult(pGetCoeff(m),nu,r->cf);
4091 n_Delete(&nu,r->cf);
4092 p_SetCoeff(m,nu1,r);
4093 }
4094 res=p_Add_q(res,m,r);
4095 }
4096 p_LmDelete(&h,r);
4097 }
4098 omFreeSize((ADDRESS)me,(rVar(r)+1)*sizeof(int));
4099 omFreeSize((ADDRESS)ee,(rVar(r)+1)*sizeof(int));
4100 return res;
4101}
CanonicalForm subst(const CanonicalForm &f, const CFList &a, const CFList &b, const CanonicalForm &Rstar, bool isFunctionField)
poly nc_pSubst(poly p, int n, poly e, const ring r)
substitute the n-th variable by e in p destroy p e is not a constant
static poly p_Subst0(poly p, int n, const ring r)
Definition p_polys.cc:4014
static poly p_Subst1(poly p, int n, const ring r)
Definition p_polys.cc:3946
static poly p_Subst2(poly p, int n, number e, const ring r)
Definition p_polys.cc:3973
poly p_LPSubst(poly p, int n, poly e, const ring r)
Definition shiftop.cc:912

◆ p_TakeOutComp() [1/2]

poly p_TakeOutComp ( poly * p,
int k,
const ring r )

Definition at line 3498 of file p_polys.cc.

3499{
3500 poly q = *p,qq=NULL,result = NULL;
3501 unsigned long kk=(unsigned long)k;
3502
3503 if (q==NULL) return NULL;
3504 BOOLEAN use_setmcomp=rOrd_SetCompRequiresSetm(r);
3505 if (__p_GetComp(q,r)==kk)
3506 {
3507 result = q;
3508 if (UNLIKELY(use_setmcomp))
3509 {
3510 do
3511 {
3512 p_SetComp(q,0,r);
3513 p_SetmComp(q,r);
3514 qq = q;
3515 pIter(q);
3516 }
3517 while ((q!=NULL) && (__p_GetComp(q,r)==kk));
3518 }
3519 else
3520 {
3521 do
3522 {
3523 p_SetComp(q,0,r);
3524 qq = q;
3525 pIter(q);
3526 }
3527 while ((q!=NULL) && (__p_GetComp(q,r)==kk));
3528 }
3529
3530 *p = q;
3531 pNext(qq) = NULL;
3532 }
3533 if (q==NULL) return result;
3534 if (__p_GetComp(q,r) > kk)
3535 {
3536 p_SubComp(q,1,r);
3537 if (use_setmcomp) p_SetmComp(q,r);
3538 }
3539 poly pNext_q;
3540 while ((pNext_q=pNext(q))!=NULL)
3541 {
3542 unsigned long c=__p_GetComp(pNext_q,r);
3543 if (/*__p_GetComp(pNext_q,r)*/c==kk)
3544 {
3545 if (result==NULL)
3546 {
3547 result = pNext_q;
3548 qq = result;
3549 }
3550 else
3551 {
3552 pNext(qq) = pNext_q;
3553 pIter(qq);
3554 }
3555 pNext(q) = pNext(pNext_q);
3556 pNext(qq) =NULL;
3557 p_SetComp(qq,0,r);
3558 if (use_setmcomp) p_SetmComp(qq,r);
3559 }
3560 else
3561 {
3562 /*pIter(q);*/ q=pNext_q;
3563 if (/*__p_GetComp(q,r)*/c > kk)
3564 {
3565 p_SubComp(q,1,r);
3566 if (use_setmcomp) p_SetmComp(q,r);
3567 }
3568 }
3569 }
3570 return result;
3571}

◆ p_TakeOutComp() [2/2]

void p_TakeOutComp ( poly * p,
long comp,
poly * q,
int * lq,
const ring r )

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 3575 of file p_polys.cc.

3576{
3577 spolyrec pp, qq;
3578 poly p, q, p_prev;
3579 int l = 0;
3580
3581#ifndef SING_NDEBUG
3582 int lp = pLength(*r_p);
3583#endif
3584
3585 pNext(&pp) = *r_p;
3586 p = *r_p;
3587 p_prev = &pp;
3588 q = &qq;
3589
3590 while(p != NULL)
3591 {
3592 while (__p_GetComp(p,r) == (unsigned long)comp)
3593 {
3594 pNext(q) = p;
3595 pIter(q);
3596 p_SetComp(p, 0,r);
3597 p_SetmComp(p,r);
3598 pIter(p);
3599 l++;
3600 if (p == NULL)
3601 {
3602 pNext(p_prev) = NULL;
3603 goto Finish;
3604 }
3605 }
3606 pNext(p_prev) = p;
3607 p_prev = p;
3608 pIter(p);
3609 }
3610
3611 Finish:
3612 pNext(q) = NULL;
3613 *r_p = pNext(&pp);
3614 *r_q = pNext(&qq);
3615 *lq = l;
3616#ifndef SING_NDEBUG
3617 assume(pLength(*r_p) + pLength(*r_q) == lp);
3618#endif
3619 p_Test(*r_p,r);
3620 p_Test(*r_q,r);
3621}

◆ p_Totaldegree()

static long p_Totaldegree ( poly p,
const ring r )
inlinestatic

Definition at line 1523 of file p_polys.h.

1524{
1526 unsigned long s = p_GetTotalDegree(p->exp[r->VarL_Offset[0]],
1527 r,
1528 r->ExpPerLong);
1529 for (unsigned i=r->VarL_Size-1; i!=0; i--)
1530 {
1531 s += p_GetTotalDegree(p->exp[r->VarL_Offset[i]], r,r->ExpPerLong);
1532 }
1533 return (long)s;
1534}
static unsigned long p_GetTotalDegree(const unsigned long l, const ring r, const int number_of_exps)
Definition p_polys.h:812

◆ p_Var()

int p_Var ( poly mi,
const ring r )

Definition at line 4765 of file p_polys.cc.

4766{
4767 if (m==NULL) return 0;
4768 if (pNext(m)!=NULL) return 0;
4769 int i,e=0;
4770 for (i=rVar(r); i>0; i--)
4771 {
4772 int exp=p_GetExp(m,i,r);
4773 if (exp==1)
4774 {
4775 if (e==0) e=i;
4776 else return 0;
4777 }
4778 else if (exp!=0)
4779 {
4780 return 0;
4781 }
4782 }
4783 return e;
4784}

◆ p_Vec2Array()

void p_Vec2Array ( poly v,
poly * p,
int len,
const ring r )

julia: vector to already allocated array (len=p_MaxComp(v,r))

julia: vector to already allocated array (len=p_MaxComp(v,r))

Definition at line 3675 of file p_polys.cc.

3676{
3677 poly h;
3678 int k;
3679
3680 for(int i=len-1;i>=0;i--) p[i]=NULL;
3681 while (v!=NULL)
3682 {
3683 h=p_Head(v,r);
3684 k=__p_GetComp(h,r);
3685 if (k>len) { Werror("wrong rank:%d, should be %d",len,k); }
3686 else
3687 {
3688 p_SetComp(h,0,r);
3689 p_Setm(h,r);
3690 pNext(h)=p[k-1];p[k-1]=h;
3691 }
3692 pIter(v);
3693 }
3694 for(int i=len-1;i>=0;i--)
3695 {
3696 if (p[i]!=NULL) p[i]=pReverse(p[i]);
3697 }
3698}

◆ p_Vec2Poly()

poly p_Vec2Poly ( poly v,
int k,
const ring r )

Definition at line 3653 of file p_polys.cc.

3654{
3655 poly h;
3656 poly res=NULL;
3657 long unsigned kk=k;
3658
3659 while (v!=NULL)
3660 {
3661 if (__p_GetComp(v,r)==kk)
3662 {
3663 h=p_Head(v,r);
3664 p_SetComp(h,0,r);
3665 pNext(h)=res;res=h;
3666 }
3667 pIter(v);
3668 }
3669 if (res!=NULL) res=pReverse(res);
3670 return res;
3671}

◆ p_Vec2Polys()

void p_Vec2Polys ( poly v,
poly ** p,
int * len,
const ring r )

Definition at line 3705 of file p_polys.cc.

3706{
3707 *len=p_MaxComp(v,r);
3708 if (*len==0) *len=1;
3709 *p=(poly*)omAlloc((*len)*sizeof(poly));
3710 p_Vec2Array(v,*p,*len,r);
3711}
void p_Vec2Array(poly v, poly *p, int len, const ring r)
vector to already allocated array (len>=p_MaxComp(v,r))
Definition p_polys.cc:3675

◆ p_VectorHasUnit()

void p_VectorHasUnit ( poly p,
int * k,
int * len,
const ring r )

Definition at line 3465 of file p_polys.cc.

3466{
3467 poly q=p,qq;
3468 int j=0;
3469 long unsigned i;
3470
3471 *len = 0;
3472 while (q!=NULL)
3473 {
3474 if (p_LmIsConstantComp(q,r))
3475 {
3476 i = __p_GetComp(q,r);
3477 qq = p;
3478 while ((qq != q) && (__p_GetComp(qq,r) != i)) pIter(qq);
3479 if (qq == q)
3480 {
3481 j = 0;
3482 while (qq!=NULL)
3483 {
3484 if (__p_GetComp(qq,r)==i) j++;
3485 pIter(qq);
3486 }
3487 if ((*len == 0) || (j<*len))
3488 {
3489 *len = j;
3490 *k = i;
3491 }
3492 }
3493 }
3494 pIter(q);
3495 }
3496}

◆ p_VectorHasUnitB()

BOOLEAN p_VectorHasUnitB ( poly p,
int * k,
const ring r )

Definition at line 3442 of file p_polys.cc.

3443{
3444 poly q=p,qq;
3445 long unsigned i;
3446
3447 while (q!=NULL)
3448 {
3449 if (p_LmIsConstantComp(q,r))
3450 {
3451 i = __p_GetComp(q,r);
3452 qq = p;
3453 while ((qq != q) && (__p_GetComp(qq,r) != i)) pIter(qq);
3454 if (qq == q)
3455 {
3456 *k = i;
3457 return TRUE;
3458 }
3459 }
3460 pIter(q);
3461 }
3462 return FALSE;
3463}

◆ p_WDegree()

long p_WDegree ( poly p,
const ring r )

Definition at line 715 of file p_polys.cc.

716{
717 if (r->firstwv==NULL) return p_Totaldegree(p, r);
719 int i;
720 long j =0;
721
722 for(i=1;i<=r->firstBlockEnds;i++)
723 j+=p_GetExp(p, i, r)*r->firstwv[i-1];
724
725 for (;i<=rVar(r);i++)
726 j+=p_GetExp(p,i, r)*p_Weight(i, r);
727
728 return j;
729}
int p_Weight(int i, const ring r)
Definition p_polys.cc:706

◆ p_Weight()

int p_Weight ( int c,
const ring r )

Definition at line 706 of file p_polys.cc.

707{
708 if ((r->firstwv==NULL) || (i>r->firstBlockEnds))
709 {
710 return 1;
711 }
712 return r->firstwv[i-1];
713}

◆ p_WFirstTotalDegree()

long p_WFirstTotalDegree ( poly p,
ring r )

Definition at line 595 of file p_polys.cc.

596{
597 int i;
598 long sum = 0;
599
600 for (i=1; i<= r->firstBlockEnds; i++)
601 {
602 sum += p_GetExp(p, i, r)*r->firstwv[i-1];
603 }
604 return sum;
605}

◆ p_Write() [1/2]

void p_Write ( poly p,
ring lmRing,
ring tailRing )

Definition at line 342 of file polys0.cc.

343{
344 p_Write0(p, lmRing, tailRing);
345 PrintLn();
346}
void p_Write0(poly p, ring lmRing, ring tailRing)
Definition polys0.cc:332
void PrintLn()
Definition reporter.cc:310

◆ p_Write() [2/2]

static void p_Write ( poly p,
ring p_ring )
inlinestatic

Definition at line 1264 of file p_polys.h.

1265{
1266 p_Write(p, p_ring, p_ring);
1267}

◆ p_Write0() [1/2]

void p_Write0 ( poly p,
ring lmRing,
ring tailRing )

Definition at line 332 of file polys0.cc.

333{
334 char *s=p_String(p, lmRing, tailRing);
335 PrintS(s);
336 omFree(s);
337}
char * p_String(poly p, ring lmRing, ring tailRing)
Definition polys0.cc:322

◆ p_Write0() [2/2]

static void p_Write0 ( poly p,
ring p_ring )
inlinestatic

Definition at line 1268 of file p_polys.h.

1269{
1270 p_Write0(p, p_ring, p_ring);
1271}
void p_Write0(poly p, ring lmRing, ring tailRing)
Definition polys0.cc:332

◆ p_wrp() [1/2]

void p_wrp ( poly p,
ring lmRing,
ring tailRing )

Definition at line 373 of file polys0.cc.

374{
375 poly r;
376
377 if (p==NULL) PrintS("NULL");
378 else if (pNext(p)==NULL) p_Write0(p, lmRing);
379 else
380 {
381 r = pNext(pNext(p));
382 pNext(pNext(p)) = NULL;
383 p_Write0(p, tailRing);
384 if (r!=NULL)
385 {
386 PrintS("+...");
387 pNext(pNext(p)) = r;
388 }
389 }
390}

◆ p_wrp() [2/2]

static void p_wrp ( poly p,
ring p_ring )
inlinestatic

Definition at line 1272 of file p_polys.h.

1273{
1274 p_wrp(p, p_ring, p_ring);
1275}
void p_wrp(poly p, ring lmRing, ring tailRing)
Definition polys0.cc:373

◆ p_WTotaldegree()

long p_WTotaldegree ( poly p,
const ring r )

Definition at line 612 of file p_polys.cc.

613{
615 int i, k;
616 long j =0;
617
618 // iterate through each block:
619 for (i=0;r->order[i]!=0;i++)
620 {
621 int b0=r->block0[i];
622 int b1=r->block1[i];
623 switch(r->order[i])
624 {
625 case ringorder_M:
626 for (k=b0 /*r->block0[i]*/;k<=b1 /*r->block1[i]*/;k++)
627 { // in jedem block:
628 j+= p_GetExp(p,k,r)*r->wvhdl[i][k - b0 /*r->block0[i]*/]*r->OrdSgn;
629 }
630 break;
631 case ringorder_am:
632 b1=si_min(b1,r->N); /* no break, continue as ringorder_a*/
633 case ringorder_a:
634 for (k=b0 /*r->block0[i]*/;k<=b1 /*r->block1[i]*/;k++)
635 { // only one line
636 j+= p_GetExp(p,k,r)*r->wvhdl[i][k - b0 /*r->block0[i]*/];
637 }
638 return j*r->OrdSgn;
639 case ringorder_wp:
640 case ringorder_ws:
641 case ringorder_Wp:
642 case ringorder_Ws:
643 for (k=b0 /*r->block0[i]*/;k<=b1 /*r->block1[i]*/;k++)
644 { // in jedem block:
645 j+= p_GetExp(p,k,r)*r->wvhdl[i][k - b0 /*r->block0[i]*/];
646 }
647 break;
648 case ringorder_lp:
649 case ringorder_ls:
650 case ringorder_rs:
651 case ringorder_dp:
652 case ringorder_ds:
653 case ringorder_Dp:
654 case ringorder_Ds:
655 case ringorder_rp:
656 for (k=b0 /*r->block0[i]*/;k<=b1 /*r->block1[i]*/;k++)
657 {
658 j+= p_GetExp(p,k,r);
659 }
660 break;
661 case ringorder_a64:
662 {
663 int64* w=(int64*)r->wvhdl[i];
664 for (k=0;k<=(b1 /*r->block1[i]*/ - b0 /*r->block0[i]*/);k++)
665 {
666 //there should be added a line which checks if w[k]>2^31
667 j+= p_GetExp(p,k+1, r)*(long)w[k];
668 }
669 //break;
670 return j;
671 }
672 default:
673 #if 0
674 case ringorder_c: /* nothing to do*/
675 case ringorder_C: /* nothing to do*/
676 case ringorder_S: /* nothing to do*/
677 case ringorder_s: /* nothing to do*/
678 case ringorder_IS: /* nothing to do */
679 case ringorder_unspec: /* to make clang happy, does not occur*/
680 case ringorder_no: /* to make clang happy, does not occur*/
681 case ringorder_L: /* to make clang happy, does not occur*/
682 case ringorder_aa: /* ignored by p_WTotaldegree*/
683 #endif
684 break;
685 /* no default: all orderings covered */
686 }
687 }
688 return j;
689}
#define ringorder_rp
Definition ring.h:100
@ ringorder_a
Definition ring.h:71
@ ringorder_am
Definition ring.h:90
@ ringorder_a64
for int64 weights
Definition ring.h:72
@ ringorder_C
Definition ring.h:74
@ ringorder_S
S?
Definition ring.h:76
@ ringorder_ds
Definition ring.h:86
@ ringorder_Dp
Definition ring.h:81
@ ringorder_unspec
Definition ring.h:96
@ ringorder_L
Definition ring.h:91
@ ringorder_Ds
Definition ring.h:87
@ ringorder_dp
Definition ring.h:79
@ ringorder_c
Definition ring.h:73
@ ringorder_aa
for idElimination, like a, except pFDeg, pWeigths ignore it
Definition ring.h:93
@ ringorder_no
Definition ring.h:70
@ ringorder_Wp
Definition ring.h:83
@ ringorder_ws
Definition ring.h:88
@ ringorder_Ws
Definition ring.h:89
@ ringorder_IS
Induced (Schreyer) ordering.
Definition ring.h:95
@ ringorder_ls
degree, ip
Definition ring.h:85
@ ringorder_s
s?
Definition ring.h:77
@ ringorder_wp
Definition ring.h:82
@ ringorder_M
Definition ring.h:75
#define ringorder_rs
Definition ring.h:101

◆ pEnlargeSet()

void pEnlargeSet ( poly ** p,
int length,
int increment )

Definition at line 3776 of file p_polys.cc.

3777{
3778 poly* h;
3779
3780 if (increment==0) return;
3781 if (*p==NULL)
3782 {
3783 h=(poly*)omAlloc0(increment*sizeof(poly));
3784 }
3785 else
3786 {
3787 h=(poly*)omReallocSize((poly*)*p,l*sizeof(poly),(l+increment)*sizeof(poly));
3788 if (increment>0)
3789 {
3790 memset(&(h[l]),0,increment*sizeof(poly));
3791 }
3792 }
3793 *p=h;
3794}
#define omReallocSize(addr, o_size, size)

◆ pHaveCommonMonoms()

BOOLEAN pHaveCommonMonoms ( poly p,
poly q )

Definition at line 174 of file pDebug.cc.

175{
176 while (p != NULL)
177 {
178 if (pIsMonomOf(q, p))
179 {
180 return TRUE;
181 }
182 pIter(p);
183 }
184 return FALSE;
185}
BOOLEAN pIsMonomOf(poly p, poly m)
Definition pDebug.cc:164

◆ pIsMonomOf()

BOOLEAN pIsMonomOf ( poly p,
poly m )

Definition at line 164 of file pDebug.cc.

165{
166 if (m == NULL) return TRUE;
167 while (p != NULL)
168 {
169 if (p == m) return TRUE;
170 pIter(p);
171 }
172 return FALSE;
173}

◆ pLDeg0()

long pLDeg0 ( poly p,
int * l,
ring r )

Definition at line 740 of file p_polys.cc.

741{
742 p_CheckPolyRing(p, r);
743 long unsigned k= p_GetComp(p, r);
744 int ll=1;
745
746 if (k > 0)
747 {
748 while ((pNext(p)!=NULL) && (__p_GetComp(pNext(p), r)==k))
749 {
750 pIter(p);
751 ll++;
752 }
753 }
754 else
755 {
756 while (pNext(p)!=NULL)
757 {
758 pIter(p);
759 ll++;
760 }
761 }
762 *l=ll;
763 return r->pFDeg(p, r);
764}

◆ pLDeg0c()

long pLDeg0c ( poly p,
int * l,
ring r )

Definition at line 771 of file p_polys.cc.

772{
773 assume(p!=NULL);
774 p_Test(p,r);
775 p_CheckPolyRing(p, r);
776 long o;
777 int ll=1;
778
779 if (! rIsSyzIndexRing(r))
780 {
781 while (pNext(p) != NULL)
782 {
783 pIter(p);
784 ll++;
785 }
786 o = r->pFDeg(p, r);
787 }
788 else
789 {
790 long unsigned curr_limit = rGetCurrSyzLimit(r);
791 poly pp = p;
792 while ((p=pNext(p))!=NULL)
793 {
794 if (__p_GetComp(p, r)<=curr_limit/*syzComp*/)
795 ll++;
796 else break;
797 pp = p;
798 }
799 p_Test(pp,r);
800 o = r->pFDeg(pp, r);
801 }
802 *l=ll;
803 return o;
804}

◆ pLDeg1()

long pLDeg1 ( poly p,
int * l,
ring r )

Definition at line 842 of file p_polys.cc.

843{
844 p_CheckPolyRing(p, r);
845 long unsigned k= p_GetComp(p, r);
846 int ll=1;
847 long t,max;
848
849 max=r->pFDeg(p, r);
850 if (k > 0)
851 {
852 while (((p=pNext(p))!=NULL) && (__p_GetComp(p, r)==k))
853 {
854 t=r->pFDeg(p, r);
855 if (t>max) max=t;
856 ll++;
857 }
858 }
859 else
860 {
861 while ((p=pNext(p))!=NULL)
862 {
863 t=r->pFDeg(p, r);
864 if (t>max) max=t;
865 ll++;
866 }
867 }
868 *l=ll;
869 return max;
870}

◆ pLDeg1_Deg()

long pLDeg1_Deg ( poly p,
int * l,
ring r )

Definition at line 911 of file p_polys.cc.

912{
913 assume(r->pFDeg == p_Deg);
914 p_CheckPolyRing(p, r);
915 long unsigned k= p_GetComp(p, r);
916 int ll=1;
917 long t,max;
918
919 max=p_GetOrder(p, r);
920 if (k > 0)
921 {
922 while (((p=pNext(p))!=NULL) && (__p_GetComp(p, r)==k))
923 {
924 t=p_GetOrder(p, r);
925 if (t>max) max=t;
926 ll++;
927 }
928 }
929 else
930 {
931 while ((p=pNext(p))!=NULL)
932 {
933 t=p_GetOrder(p, r);
934 if (t>max) max=t;
935 ll++;
936 }
937 }
938 *l=ll;
939 return max;
940}

◆ pLDeg1_Totaldegree()

long pLDeg1_Totaldegree ( poly p,
int * l,
ring r )

Definition at line 976 of file p_polys.cc.

977{
978 p_CheckPolyRing(p, r);
979 long unsigned k= p_GetComp(p, r);
980 int ll=1;
981 long t,max;
982
983 max=p_Totaldegree(p, r);
984 if (k > 0)
985 {
986 while (((p=pNext(p))!=NULL) && (__p_GetComp(p, r)==k))
987 {
988 t=p_Totaldegree(p, r);
989 if (t>max) max=t;
990 ll++;
991 }
992 }
993 else
994 {
995 while ((p=pNext(p))!=NULL)
996 {
997 t=p_Totaldegree(p, r);
998 if (t>max) max=t;
999 ll++;
1000 }
1001 }
1002 *l=ll;
1003 return max;
1004}

◆ pLDeg1_WFirstTotalDegree()

long pLDeg1_WFirstTotalDegree ( poly p,
int * l,
ring r )

Definition at line 1039 of file p_polys.cc.

1040{
1041 p_CheckPolyRing(p, r);
1042 long unsigned k= p_GetComp(p, r);
1043 int ll=1;
1044 long t,max;
1045
1047 if (k > 0)
1048 {
1049 while (((p=pNext(p))!=NULL) && (__p_GetComp(p, r)==k))
1050 {
1051 t=p_WFirstTotalDegree(p, r);
1052 if (t>max) max=t;
1053 ll++;
1054 }
1055 }
1056 else
1057 {
1058 while ((p=pNext(p))!=NULL)
1059 {
1060 t=p_WFirstTotalDegree(p, r);
1061 if (t>max) max=t;
1062 ll++;
1063 }
1064 }
1065 *l=ll;
1066 return max;
1067}
long p_WFirstTotalDegree(poly p, const ring r)
Definition p_polys.cc:595

◆ pLDeg1c()

long pLDeg1c ( poly p,
int * l,
ring r )

Definition at line 878 of file p_polys.cc.

879{
880 p_CheckPolyRing(p, r);
881 int ll=1;
882 long t,max;
883
884 max=r->pFDeg(p, r);
885 if (rIsSyzIndexRing(r))
886 {
887 long unsigned limit = rGetCurrSyzLimit(r);
888 while ((p=pNext(p))!=NULL)
889 {
890 if (__p_GetComp(p, r)<=limit)
891 {
892 if ((t=r->pFDeg(p, r))>max) max=t;
893 ll++;
894 }
895 else break;
896 }
897 }
898 else
899 {
900 while ((p=pNext(p))!=NULL)
901 {
902 if ((t=r->pFDeg(p, r))>max) max=t;
903 ll++;
904 }
905 }
906 *l=ll;
907 return max;
908}

◆ pLDeg1c_Deg()

long pLDeg1c_Deg ( poly p,
int * l,
ring r )

Definition at line 942 of file p_polys.cc.

943{
944 assume(r->pFDeg == p_Deg);
945 p_CheckPolyRing(p, r);
946 int ll=1;
947 long t,max;
948
949 max=p_GetOrder(p, r);
950 if (rIsSyzIndexRing(r))
951 {
952 long unsigned limit = rGetCurrSyzLimit(r);
953 while ((p=pNext(p))!=NULL)
954 {
955 if (__p_GetComp(p, r)<=limit)
956 {
957 if ((t=p_GetOrder(p, r))>max) max=t;
958 ll++;
959 }
960 else break;
961 }
962 }
963 else
964 {
965 while ((p=pNext(p))!=NULL)
966 {
967 if ((t=p_GetOrder(p, r))>max) max=t;
968 ll++;
969 }
970 }
971 *l=ll;
972 return max;
973}

◆ pLDeg1c_Totaldegree()

long pLDeg1c_Totaldegree ( poly p,
int * l,
ring r )

Definition at line 1006 of file p_polys.cc.

1007{
1008 p_CheckPolyRing(p, r);
1009 int ll=1;
1010 long t,max;
1011
1012 max=p_Totaldegree(p, r);
1013 if (rIsSyzIndexRing(r))
1014 {
1015 long unsigned limit = rGetCurrSyzLimit(r);
1016 while ((p=pNext(p))!=NULL)
1017 {
1018 if (__p_GetComp(p, r)<=limit)
1019 {
1020 if ((t=p_Totaldegree(p, r))>max) max=t;
1021 ll++;
1022 }
1023 else break;
1024 }
1025 }
1026 else
1027 {
1028 while ((p=pNext(p))!=NULL)
1029 {
1030 if ((t=p_Totaldegree(p, r))>max) max=t;
1031 ll++;
1032 }
1033 }
1034 *l=ll;
1035 return max;
1036}

◆ pLDeg1c_WFirstTotalDegree()

long pLDeg1c_WFirstTotalDegree ( poly p,
int * l,
ring r )

Definition at line 1069 of file p_polys.cc.

1070{
1071 p_CheckPolyRing(p, r);
1072 int ll=1;
1073 long t,max;
1074
1076 if (rIsSyzIndexRing(r))
1077 {
1078 long unsigned limit = rGetCurrSyzLimit(r);
1079 while ((p=pNext(p))!=NULL)
1080 {
1081 if (__p_GetComp(p, r)<=limit)
1082 {
1083 if ((t=p_Totaldegree(p, r))>max) max=t;
1084 ll++;
1085 }
1086 else break;
1087 }
1088 }
1089 else
1090 {
1091 while ((p=pNext(p))!=NULL)
1092 {
1093 if ((t=p_Totaldegree(p, r))>max) max=t;
1094 ll++;
1095 }
1096 }
1097 *l=ll;
1098 return max;
1099}

◆ pLDegb()

long pLDegb ( poly p,
int * l,
ring r )

Definition at line 812 of file p_polys.cc.

813{
814 p_CheckPolyRing(p, r);
815 long unsigned k= p_GetComp(p, r);
816 long o = r->pFDeg(p, r);
817 int ll=1;
818
819 if (k != 0)
820 {
821 while (((p=pNext(p))!=NULL) && (__p_GetComp(p, r)==k))
822 {
823 ll++;
824 }
825 }
826 else
827 {
828 while ((p=pNext(p)) !=NULL)
829 {
830 ll++;
831 }
832 }
833 *l=ll;
834 return o;
835}

◆ pLength()

static int pLength ( poly a)
inlinestatic

Definition at line 190 of file p_polys.h.

191{
192 int l = 0;
193 while (a!=NULL)
194 {
195 pIter(a);
196 l++;
197 }
198 return l;
199}

◆ pp_DivideM()

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

Definition at line 1637 of file p_polys.cc.

1638{
1639 if (a==NULL) { return NULL; }
1640 // TODO: better implementation without copying a,b
1641 return p_DivideM(p_Copy(a,r),p_Head(b,r),r);
1642}
poly p_DivideM(poly a, poly b, const ring r)
Definition p_polys.cc:1582

◆ pp_Jet()

poly pp_Jet ( poly p,
int m,
const ring R )

Definition at line 4439 of file p_polys.cc.

4440{
4441 poly r=NULL;
4442 poly t=NULL;
4443
4444 while (p!=NULL)
4445 {
4446 if (p_Totaldegree(p,R)<=m)
4447 {
4448 if (r==NULL)
4449 r=p_Head(p,R);
4450 else
4451 if (t==NULL)
4452 {
4453 pNext(r)=p_Head(p,R);
4454 t=pNext(r);
4455 }
4456 else
4457 {
4458 pNext(t)=p_Head(p,R);
4459 pIter(t);
4460 }
4461 }
4462 pIter(p);
4463 }
4464 return r;
4465}

◆ pp_Jet0()

poly pp_Jet0 ( poly p,
const ring R )

Definition at line 4467 of file p_polys.cc.

4468{
4469 poly r=NULL;
4470 poly t=NULL;
4471
4472 while (p!=NULL)
4473 {
4474 if (p_LmIsConstantComp(p,R))
4475 {
4476 if (r==NULL)
4477 r=p_Head(p,R);
4478 else
4479 if (t==NULL)
4480 {
4481 pNext(r)=p_Head(p,R);
4482 t=pNext(r);
4483 }
4484 else
4485 {
4486 pNext(t)=p_Head(p,R);
4487 pIter(t);
4488 }
4489 }
4490 pIter(p);
4491 }
4492 return r;
4493}

◆ pp_JetW()

poly pp_JetW ( poly p,
int m,
int * w,
const ring R )

Definition at line 4512 of file p_polys.cc.

4513{
4514 poly r=NULL;
4515 poly t=NULL;
4516 while (p!=NULL)
4517 {
4518 if (totaldegreeWecart_IV(p,R,w)<=m)
4519 {
4520 if (r==NULL)
4521 r=p_Head(p,R);
4522 else
4523 if (t==NULL)
4524 {
4525 pNext(r)=p_Head(p,R);
4526 t=pNext(r);
4527 }
4528 else
4529 {
4530 pNext(t)=p_Head(p,R);
4531 pIter(t);
4532 }
4533 }
4534 pIter(p);
4535 }
4536 return r;
4537}

◆ pp_mm_Mult()

static poly pp_mm_Mult ( poly p,
poly m,
const ring r )
inlinestatic

Definition at line 1043 of file p_polys.h.

1044{
1045 if (p==NULL) return NULL;
1046 if (p_LmIsConstant(m, r))
1047 return __pp_Mult_nn(p, pGetCoeff(m), r);
1048 else
1049 return r->p_Procs->pp_mm_Mult(p, m, r);
1050}
#define __pp_Mult_nn(p, n, r)
Definition p_polys.h:1004

◆ pp_Mult_Coeff_mm_DivSelect() [1/2]

static poly pp_Mult_Coeff_mm_DivSelect ( poly p,
const poly m,
const ring r )
inlinestatic

Definition at line 1092 of file p_polys.h.

1093{
1094 int shorter;
1095 return r->p_Procs->pp_Mult_Coeff_mm_DivSelect(p, m, shorter, r);
1096}

◆ pp_Mult_Coeff_mm_DivSelect() [2/2]

static poly pp_Mult_Coeff_mm_DivSelect ( poly p,
int & lp,
const poly m,
const ring r )
inlinestatic

Definition at line 1100 of file p_polys.h.

1101{
1102 int shorter;
1103 poly pp = r->p_Procs->pp_Mult_Coeff_mm_DivSelect(p, m, shorter, r);
1104 lp -= shorter;
1105 return pp;
1106}

◆ pp_Mult_mm()

static poly pp_Mult_mm ( poly p,
poly m,
const ring r )
inlinestatic

Definition at line 1033 of file p_polys.h.

1034{
1035 if (p==NULL) return NULL;
1036 if (p_LmIsConstant(m, r))
1037 return __pp_Mult_nn(p, pGetCoeff(m), r);
1038 else
1039 return r->p_Procs->pp_Mult_mm(p, m, r);
1040}

◆ pp_Mult_nn()

static poly pp_Mult_nn ( poly p,
number n,
const ring r )
inlinestatic

Definition at line 994 of file p_polys.h.

995{
996 if (p==NULL) return NULL;
997 if (n_IsOne(n, r->cf))
998 return p_Copy(p, r);
999 else if (n_IsZero(n, r->cf))
1000 return NULL;
1001 else
1002 return r->p_Procs->pp_Mult_nn(p, n, r);
1003}

◆ pp_Mult_qq()

static poly pp_Mult_qq ( poly p,
poly q,
const ring r )
inlinestatic

Definition at line 1162 of file p_polys.h.

1163{
1164 if (UNLIKELY(p == NULL || q == NULL)) return NULL;
1165
1166 if (pNext(p) == NULL)
1167 {
1168 return r->p_Procs->pp_mm_Mult(q, p, r);
1169 }
1170
1171 if (pNext(q) == NULL)
1172 {
1173 return r->p_Procs->pp_Mult_mm(p, q, r);
1174 }
1175
1176 poly qq = q;
1177 if (UNLIKELY(p == q))
1178 qq = p_Copy(q, r);
1179
1180 poly res;
1181#if defined(HAVE_PLURAL) || defined(HAVE_SHIFTBBA)
1182 if (UNLIKELY(rIsNCRing(r)))
1183 res = _nc_pp_Mult_qq(p, qq, r);
1184 else
1185#endif
1186#ifdef HAVE_RINGS
1187 if (UNLIKELY(!nCoeff_is_Domain(r->cf)))
1188 res = _p_Mult_q_Normal_ZeroDiv(p, qq, 1, r);
1189 else
1190#endif
1191 res = _p_Mult_q(p, qq, 1, r);
1192
1193 if (UNLIKELY(qq != q))
1194 p_Delete(&qq, r);
1195 return res;
1196}
poly _nc_pp_Mult_qq(const poly p, const poly q, const ring r)
general NC-multiplication without destruction
Definition old.gring.cc:254

◆ pRestoreDegProcs()

void pRestoreDegProcs ( ring r,
pFDegProc old_FDeg,
pLDegProc old_lDeg )

Definition at line 3729 of file p_polys.cc.

3730{
3731 assume(old_FDeg != NULL && old_lDeg != NULL);
3732 r->pFDeg = old_FDeg;
3733 r->pLDeg = old_lDeg;
3734}

◆ pReverse()

static poly pReverse ( poly p)
inlinestatic

Definition at line 337 of file p_polys.h.

338{
339 if (p == NULL || pNext(p) == NULL) return p;
340
341 poly q = pNext(p), // == pNext(p)
342 qn;
343 pNext(p) = NULL;
344 do
345 {
346 qn = pNext(q);
347 pNext(q) = p;
348 p = q;
349 q = qn;
350 }
351 while (qn != NULL);
352 return p;
353}

◆ pSetDegProcs()

void pSetDegProcs ( ring r,
pFDegProc new_FDeg,
pLDegProc new_lDeg = NULL )

Definition at line 3717 of file p_polys.cc.

3718{
3719 assume(new_FDeg != NULL);
3720 r->pFDeg = new_FDeg;
3721
3722 if (new_lDeg == NULL)
3723 new_lDeg = r->pLDegOrig;
3724
3725 r->pLDeg = new_lDeg;
3726}