My Project
Loading...
Searching...
No Matches
Macros | Functions
p_polys.h File Reference
#include "misc/mylimits.h"
#include "misc/intvec.h"
#include "coeffs/coeffs.h"
#include "polys/monomials/monomials.h"
#include "polys/monomials/ring.h"
#include "polys/templates/p_MemAdd.h"
#include "polys/templates/p_MemCmp.h"
#include "polys/templates/p_Procs.h"
#include "polys/sbuckets.h"
#include "polys/nc/nc.h"

Go to the source code of this file.

Macros

#define pIfThen(cond, check)   do {if (cond) {check;}} while (0)
 
#define p_Test(p, r)   _p_Test(p, r, PDEBUG)
 
#define p_LmTest(p, r)   _p_LmTest(p, r, PDEBUG)
 
#define pp_Test(p, lmRing, tailRing)   _pp_Test(p, lmRing, tailRing, PDEBUG)
 
#define p_SetmComp   p_Setm
 
#define __p_Mult_nn(p, n, r)   r->p_Procs->p_Mult_nn(p, n, r)
 
#define __pp_Mult_nn(p, n, r)   r->p_Procs->pp_Mult_nn(p, n, r)
 
#define _p_LmCmpAction(p, q, r, actionE, actionG, actionS)
 
#define pDivAssume(x)   do {} while (0)
 
#define p_LmCmpAction(p, q, r, actionE, actionG, actionS)    _p_LmCmpAction(p, q, r, actionE, actionG, actionS)
 
#define p_LmEqual(p1, p2, r)   p_ExpVectorEqual(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)
 
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
 
charp_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 charp_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 charp_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->p_Procs->p_Mult_nn(p, n, r)

Definition at line 972 of file p_polys.h.

◆ __pp_Mult_nn

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

Definition at line 1003 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, \
int p
Definition cfModGcd.cc:4086
#define p_MemCmp_LengthGeneral_OrdGeneral(s1, s2, length, ordsgn, actionE, actionG, actionS)
Definition p_MemCmp.h:719

Definition at line 1291 of file p_polys.h.

1296 {} while (0)
1297
1298
1299
1300/***************************************************************
1301 *
1302 * Allocation/Initialization/Deletion
1303 *
1304 ***************************************************************/
1305// adjustments for negative weights
1306static inline void p_MemAdd_NegWeightAdjust(poly p, const ring r)
1307{
1308 if (r->NegWeightL_Offset != NULL)
1309 {
1310 for (int i=r->NegWeightL_Size-1; i>=0; i--)
1311 {
1312 p->exp[r->NegWeightL_Offset[i]] -= POLY_NEGWEIGHT_OFFSET;
1313 }
1314 }
1315}
1316static inline void p_MemSub_NegWeightAdjust(poly p, const ring r)
1317{
1318 if (r->NegWeightL_Offset != NULL)
1319 {
1320 for (int i=r->NegWeightL_Size-1; i>=0; i--)
1321 {
1322 p->exp[r->NegWeightL_Offset[i]] += POLY_NEGWEIGHT_OFFSET;
1323 }
1324 }
1325}
1326// ExpVextor(d_p) = ExpVector(s_p)
1327static inline void p_ExpVectorCopy(poly d_p, poly s_p, const ring r)
1328{
1331 memcpy(d_p->exp, s_p->exp, r->ExpL_Size*sizeof(long));
1332}
1333
1334static inline poly p_Init(const ring r, omBin bin)
1335{
1336 p_CheckRing1(r);
1337 pAssume1(bin != NULL && omSizeWOfBin(r->PolyBin) == omSizeWOfBin(bin));
1338 poly p;
1339 omTypeAlloc0Bin(poly, p, bin);
1341 p_SetRingOfLm(p, r);
1342 return p;
1343}
1344static inline poly p_Init(const ring r)
1345{
1346 return p_Init(r, r->PolyBin);
1347}
1348
1349static inline poly p_LmInit(poly p, const ring r)
1350{
1352 poly np;
1353 omTypeAllocBin(poly, np, r->PolyBin);
1354 p_SetRingOfLm(np, r);
1355 memcpy(np->exp, p->exp, r->ExpL_Size*sizeof(long));
1356 pNext(np) = NULL;
1357 pSetCoeff0(np, NULL);
1358 return np;
1359}
1360static inline poly p_LmInit(poly s_p, const ring s_r, const ring d_r, omBin d_bin)
1361{
1364 pAssume1(d_r->N <= s_r->N);
1365 poly d_p = p_Init(d_r, d_bin);
1366 for (unsigned i=d_r->N; i!=0; i--)
1367 {
1368 p_SetExp(d_p, i, p_GetExp(s_p, i,s_r), d_r);
1369 }
1370 if (rRing_has_Comp(d_r))
1371 {
1373 }
1374 p_Setm(d_p, d_r);
1375 return d_p;
1376}
1377static inline poly p_LmInit(poly s_p, const ring s_r, const ring d_r)
1378{
1379 pAssume1(d_r != NULL);
1380 return p_LmInit(s_p, s_r, d_r, d_r->PolyBin);
1381}
1382
1383// set all exponents l..k to 0, assume exp. k+1..n and 1..l-1 are in
1384// different blocks
1385// set coeff to 1
1386static inline poly p_GetExp_k_n(poly p, int l, int k, const ring r)
1387{
1388 if (p == NULL) return NULL;
1390 poly np;
1391 omTypeAllocBin(poly, np, r->PolyBin);
1392 p_SetRingOfLm(np, r);
1393 memcpy(np->exp, p->exp, r->ExpL_Size*sizeof(long));
1394 pNext(np) = NULL;
1395 pSetCoeff0(np, n_Init(1, r->cf));
1396 int i;
1397 for(i=l;i<=k;i++)
1398 {
1399 //np->exp[(r->VarOffset[i] & 0xffffff)] =0;
1400 p_SetExp(np,i,0,r);
1401 }
1402 p_Setm(np,r);
1403 return np;
1404}
1405
1406// simialar to p_ShallowCopyDelete but does it only for leading monomial
1407static inline poly p_LmShallowCopyDelete(poly p, const ring r)
1408{
1410 pAssume1(omSizeWOfBin(bin) == omSizeWOfBin(r->PolyBin));
1411 poly new_p = p_New(r);
1412 memcpy(new_p->exp, p->exp, r->ExpL_Size*sizeof(long));
1414 pNext(new_p) = pNext(p);
1416 return new_p;
1417}
1418
1419/***************************************************************
1420 *
1421 * Operation on ExpVectors
1422 *
1423 ***************************************************************/
1424// ExpVector(p1) += ExpVector(p2)
1425static inline void p_ExpVectorAdd(poly p1, poly p2, const ring r)
1426{
1427 p_LmCheckPolyRing1(p1, r);
1428 p_LmCheckPolyRing1(p2, r);
1429#if PDEBUG >= 1
1430 for (int i=1; i<=r->N; i++)
1431 pAssume1((unsigned long) (p_GetExp(p1, i, r) + p_GetExp(p2, i, r)) <= r->bitmask);
1432 pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0);
1433#endif
1434
1435 p_MemAdd_LengthGeneral(p1->exp, p2->exp, r->ExpL_Size);
1437}
1438// ExpVector(pr) = ExpVector(p1) + ExpVector(p2)
1439static inline void p_ExpVectorSum(poly pr, poly p1, poly p2, const ring r)
1440{
1441 p_LmCheckPolyRing1(p1, r);
1442 p_LmCheckPolyRing1(p2, r);
1444#if PDEBUG >= 1
1445 for (int i=1; i<=r->N; i++)
1446 pAssume1((unsigned long) (p_GetExp(p1, i, r) + p_GetExp(p2, i, r)) <= r->bitmask);
1447 pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0);
1448#endif
1449
1450 p_MemSum_LengthGeneral(pr->exp, p1->exp, p2->exp, r->ExpL_Size);
1452}
1453// ExpVector(p1) -= ExpVector(p2)
1454static inline void p_ExpVectorSub(poly p1, poly p2, const ring r)
1455{
1456 p_LmCheckPolyRing1(p1, r);
1457 p_LmCheckPolyRing1(p2, r);
1458#if PDEBUG >= 1
1459 for (int i=1; i<=r->N; i++)
1460 pAssume1(p_GetExp(p1, i, r) >= p_GetExp(p2, i, r));
1461 pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0 ||
1462 p_GetComp(p1, r) == p_GetComp(p2, r));
1463#endif
1464
1465 p_MemSub_LengthGeneral(p1->exp, p2->exp, r->ExpL_Size);
1467}
1468
1469// ExpVector(p1) += ExpVector(p2) - ExpVector(p3)
1470static inline void p_ExpVectorAddSub(poly p1, poly p2, poly p3, const ring r)
1471{
1472 p_LmCheckPolyRing1(p1, r);
1473 p_LmCheckPolyRing1(p2, r);
1475#if PDEBUG >= 1
1476 for (int i=1; i<=r->N; i++)
1477 pAssume1(p_GetExp(p1, i, r) + p_GetExp(p2, i, r) >= p_GetExp(p3, i, r));
1478 pAssume1(p_GetComp(p1, r) == 0 ||
1479 (p_GetComp(p2, r) - p_GetComp(p3, r) == 0) ||
1480 (p_GetComp(p1, r) == p_GetComp(p2, r) - p_GetComp(p3, r)));
1481#endif
1482
1483 p_MemAddSub_LengthGeneral(p1->exp, p2->exp, p3->exp, r->ExpL_Size);
1484 // no need to adjust in case of NegWeights
1485}
1486
1487// ExpVector(pr) = ExpVector(p1) - ExpVector(p2)
1488static inline void p_ExpVectorDiff(poly pr, poly p1, poly p2, const ring r)
1489{
1490 p_LmCheckPolyRing1(p1, r);
1491 p_LmCheckPolyRing1(p2, r);
1493#if PDEBUG >= 2
1494 for (int i=1; i<=r->N; i++)
1495 pAssume1(p_GetExp(p1, i, r) >= p_GetExp(p2, i, r));
1496 pAssume1(!rRing_has_Comp(r) || p_GetComp(p1, r) == p_GetComp(p2, r));
1497#endif
1498
1499 p_MemDiff_LengthGeneral(pr->exp, p1->exp, p2->exp, r->ExpL_Size);
1501}
1502
1503static inline BOOLEAN p_ExpVectorEqual(poly p1, poly p2, const ring r)
1504{
1505 p_LmCheckPolyRing1(p1, r);
1506 p_LmCheckPolyRing1(p2, r);
1507
1508 unsigned i = r->ExpL_Size;
1509 unsigned long *ep = p1->exp;
1510 unsigned long *eq = p2->exp;
1511
1512 do
1513 {
1514 i--;
1515 if (ep[i] != eq[i]) return FALSE;
1516 }
1517 while (i!=0);
1518 return TRUE;
1519}
1520
1521static inline long p_Totaldegree(poly p, const ring r)
1522{
1524 unsigned long s = p_GetTotalDegree(p->exp[r->VarL_Offset[0]],
1525 r,
1526 r->ExpPerLong);
1527 for (unsigned i=r->VarL_Size-1; i!=0; i--)
1528 {
1529 s += p_GetTotalDegree(p->exp[r->VarL_Offset[i]], r,r->ExpPerLong);
1530 }
1531 return (long)s;
1532}
1533
1534static inline void p_GetExpV(poly p, int *ev, const ring r)
1535{
1537 for (unsigned j = r->N; j!=0; j--)
1538 ev[j] = p_GetExp(p, j, r);
1539
1540 ev[0] = p_GetComp(p, r);
1541}
1542// p_GetExpVL is used in Singular,jl
1543static inline void p_GetExpVL(poly p, int64 *ev, const ring r)
1544{
1546 for (unsigned j = r->N; j!=0; j--)
1547 ev[j-1] = p_GetExp(p, j, r);
1548}
1549// p_GetExpVLV is used in Singular,jl
1550static inline int64 p_GetExpVLV(poly p, int64 *ev, const ring r)
1551{
1553 for (unsigned j = r->N; j!=0; j--)
1554 ev[j-1] = p_GetExp(p, j, r);
1555 return (int64)p_GetComp(p,r);
1556}
1557// p_GetExpVL is used in Singular,jl
1558static inline void p_SetExpV(poly p, int *ev, const ring r)
1559{
1561 for (unsigned j = r->N; j!=0; j--)
1562 p_SetExp(p, j, ev[j], r);
1563
1564 if(ev[0]!=0) p_SetComp(p, ev[0],r);
1565 p_Setm(p, r);
1566}
1567static inline void p_SetExpVL(poly p, int64 *ev, const ring r)
1568{
1570 for (unsigned j = r->N; j!=0; j--)
1571 p_SetExp(p, j, ev[j-1], r);
1572 p_SetComp(p, 0,r);
1573
1574 p_Setm(p, r);
1575}
1576
1577// p_SetExpVLV is used in Singular,jl
1578static inline void p_SetExpVLV(poly p, int64 *ev, int64 comp, const ring r)
1579{
1581 for (unsigned j = r->N; j!=0; j--)
1582 p_SetExp(p, j, ev[j-1], r);
1583 p_SetComp(p, comp,r);
1584
1585 p_Setm(p, r);
1586}
1587
1588/***************************************************************
1589 *
1590 * Comparison w.r.t. monomial ordering
1591 *
1592 ***************************************************************/
1593
1594static inline int p_LmCmp(poly p, poly q, const ring r)
1595{
1597 p_LmCheckPolyRing1(q, r);
1598
1599 const unsigned long* _s1 = ((unsigned long*) p->exp);
1600 const unsigned long* _s2 = ((unsigned long*) q->exp);
1601 REGISTER unsigned long _v1;
1602 REGISTER unsigned long _v2;
1603 const unsigned long _l = r->CmpL_Size;
1604
1605 REGISTER unsigned long _i=0;
1606
1608 _v1 = _s1[_i];
1609 _v2 = _s2[_i];
1610 if (_v1 == _v2)
1611 {
1612 _i++;
1613 if (_i == _l) return 0;
1615 }
1616 const long* _ordsgn = (long*) r->ordsgn;
1617#if 1 /* two variants*/
1618 if (_v1 > _v2)
1619 {
1620 return _ordsgn[_i];
1621 }
1622 return -(_ordsgn[_i]);
1623#else
1624 if (_v1 > _v2)
1625 {
1626 if (_ordsgn[_i] == 1) return 1;
1627 return -1;
1628 }
1629 if (_ordsgn[_i] == 1) return -1;
1630 return 1;
1631#endif
1632}
1633
1634// The coefficient will be compared in absolute value
1635static inline int p_LtCmp(poly p, poly q, const ring r)
1636{
1637 int res = p_LmCmp(p,q,r);
1638 if(res == 0)
1639 {
1640 if(p_GetCoeff(p,r) == NULL || p_GetCoeff(q,r) == NULL)
1641 return res;
1642 number pc = n_Copy(p_GetCoeff(p,r),r->cf);
1643 number qc = n_Copy(p_GetCoeff(q,r),r->cf);
1644 if(!n_GreaterZero(pc,r->cf))
1645 pc = n_InpNeg(pc,r->cf);
1646 if(!n_GreaterZero(qc,r->cf))
1647 qc = n_InpNeg(qc,r->cf);
1648 if(n_Greater(pc,qc,r->cf))
1649 res = 1;
1650 else if(n_Greater(qc,pc,r->cf))
1651 res = -1;
1652 else if(n_Equal(pc,qc,r->cf))
1653 res = 0;
1654 n_Delete(&pc,r->cf);
1655 n_Delete(&qc,r->cf);
1656 }
1657 return res;
1658}
1659
1660// The coefficient will be compared in absolute value
1661static inline int p_LtCmpNoAbs(poly p, poly q, const ring r)
1662{
1663 int res = p_LmCmp(p,q,r);
1664 if(res == 0)
1665 {
1666 if(p_GetCoeff(p,r) == NULL || p_GetCoeff(q,r) == NULL)
1667 return res;
1668 number pc = p_GetCoeff(p,r);
1669 number qc = p_GetCoeff(q,r);
1670 if(n_Greater(pc,qc,r->cf))
1671 res = 1;
1672 if(n_Greater(qc,pc,r->cf))
1673 res = -1;
1674 if(n_Equal(pc,qc,r->cf))
1675 res = 0;
1676 }
1677 return res;
1678}
1679
1680#ifdef HAVE_RINGS
1681// This is the equivalent of pLmCmp(p,q) != -currRing->OrdSgn for rings
1682// It is used in posInTRing
1683static inline int p_LtCmpOrdSgnDiffM(poly p, poly q, const ring r)
1684{
1685 return(p_LtCmp(p,q,r) == r->OrdSgn);
1686}
1687#endif
1688
1689#ifdef HAVE_RINGS
1690// This is the equivalent of pLmCmp(p,q) != currRing->OrdSgn for rings
1691// It is used in posInTRing
1692static inline int p_LtCmpOrdSgnDiffP(poly p, poly q, const ring r)
1693{
1694 if(r->OrdSgn == 1)
1695 {
1696 return(p_LmCmp(p,q,r) == -1);
1697 }
1698 else
1699 {
1700 return(p_LtCmp(p,q,r) != -1);
1701 }
1702}
1703#endif
1704
1705#ifdef HAVE_RINGS
1706// This is the equivalent of pLmCmp(p,q) == -currRing->OrdSgn for rings
1707// It is used in posInTRing
1708static inline int p_LtCmpOrdSgnEqM(poly p, poly q, const ring r)
1709{
1710 return(p_LtCmp(p,q,r) == -r->OrdSgn);
1711}
1712#endif
1713
1714#ifdef HAVE_RINGS
1715// This is the equivalent of pLmCmp(p,q) == currRing->OrdSgn for rings
1716// It is used in posInTRing
1717static inline int p_LtCmpOrdSgnEqP(poly p, poly q, const ring r)
1718{
1719 return(p_LtCmp(p,q,r) == r->OrdSgn);
1720}
1721#endif
1722
1723/// returns TRUE if p1 is a skalar multiple of p2
1724/// assume p1 != NULL and p2 != NULL
1725BOOLEAN p_ComparePolys(poly p1,poly p2, const ring r);
1726
1727
1728/***************************************************************
1729 *
1730 * Comparisons: they are all done without regarding coeffs
1731 *
1732 ***************************************************************/
1733#define p_LmCmpAction(p, q, r, actionE, actionG, actionS) \
1734 _p_LmCmpAction(p, q, r, actionE, actionG, actionS)
1735
1736// returns 1 if ExpVector(p)==ExpVector(q): does not compare numbers !!
1737#define p_LmEqual(p1, p2, r) p_ExpVectorEqual(p1, p2, r)
1738
1739// pCmp: args may be NULL
1740// returns: (p2==NULL ? 1 : (p1 == NULL ? -1 : p_LmCmp(p1, p2)))
1741static inline int p_Cmp(poly p1, poly p2, ring r)
1742{
1743 if (p2==NULL)
1744 {
1745 if (p1==NULL) return 0;
1746 return 1;
1747 }
1748 if (p1==NULL)
1749 return -1;
1750 return p_LmCmp(p1,p2,r);
1751}
1752
1753static inline int p_CmpPolys(poly p1, poly p2, ring r)
1754{
1755 if (p2==NULL)
1756 {
1757 if (p1==NULL) return 0;
1758 return 1;
1759 }
1760 if (p1==NULL)
1761 return -1;
1762 return p_ComparePolys(p1,p2,r);
1763}
1764
1765
1766/***************************************************************
1767 *
1768 * divisibility
1769 *
1770 ***************************************************************/
1771/// return: FALSE, if there exists i, such that a->exp[i] > b->exp[i]
1772/// TRUE, otherwise
1773/// (1) Consider long vars, instead of single exponents
1774/// (2) Clearly, if la > lb, then FALSE
1775/// (3) Suppose la <= lb, and consider first bits of single exponents in l:
1776/// if TRUE, then value of these bits is la ^ lb
1777/// if FALSE, then la-lb causes an "overflow" into one of those bits, i.e.,
1778/// la ^ lb != la - lb
1779static inline BOOLEAN _p_LmDivisibleByNoComp(poly a, poly b, const ring r)
1780{
1781 int i=r->VarL_Size - 1;
1782 unsigned long divmask = r->divmask;
1783 unsigned long la, lb;
1784
1785 if (r->VarL_LowIndex >= 0)
1786 {
1787 i += r->VarL_LowIndex;
1788 do
1789 {
1790 la = a->exp[i];
1791 lb = b->exp[i];
1792 if ((la > lb) ||
1793 (((la & divmask) ^ (lb & divmask)) != ((lb - la) & divmask)))
1794 {
1796 return FALSE;
1797 }
1798 i--;
1799 }
1800 while (i>=r->VarL_LowIndex);
1801 }
1802 else
1803 {
1804 do
1805 {
1806 la = a->exp[r->VarL_Offset[i]];
1807 lb = b->exp[r->VarL_Offset[i]];
1808 if ((la > lb) ||
1809 (((la & divmask) ^ (lb & divmask)) != ((lb - la) & divmask)))
1810 {
1812 return FALSE;
1813 }
1814 i--;
1815 }
1816 while (i>=0);
1817 }
1818/*#ifdef HAVE_RINGS
1819 pDivAssume(p_DebugLmDivisibleByNoComp(a, b, r) == n_DivBy(p_GetCoeff(b, r), p_GetCoeff(a, r), r->cf));
1820 return (!rField_is_Ring(r)) || n_DivBy(p_GetCoeff(b, r), p_GetCoeff(a, r), r->cf);
1821#else
1822*/
1824 return TRUE;
1825//#endif
1826}
1827
1828static inline BOOLEAN _p_LmDivisibleByNoComp(poly a, const ring r_a, poly b, const ring r_b)
1829{
1830 int i=r_a->N;
1831 pAssume1(r_a->N == r_b->N);
1832
1833 do
1834 {
1835 if (p_GetExp(a,i,r_a) > p_GetExp(b,i,r_b))
1836 {
1837 return FALSE;
1838 }
1839 i--;
1840 }
1841 while (i);
1842/*#ifdef HAVE_RINGS
1843 return n_DivBy(p_GetCoeff(b, r_b), p_GetCoeff(a, r_a), r_a->cf);
1844#else
1845*/
1846 return TRUE;
1847//#endif
1848}
1849
1850#ifdef HAVE_RATGRING
1851static inline BOOLEAN _p_LmDivisibleByNoCompPart(poly a, const ring r_a, poly b, const ring r_b,const int start, const int end)
1852{
1853 int i=end;
1854 pAssume1(r_a->N == r_b->N);
1855
1856 do
1857 {
1858 if (p_GetExp(a,i,r_a) > p_GetExp(b,i,r_b))
1859 return FALSE;
1860 i--;
1861 }
1862 while (i>=start);
1863/*#ifdef HAVE_RINGS
1864 return n_DivBy(p_GetCoeff(b, r_b), p_GetCoeff(a, r_a), r_a->cf);
1865#else
1866*/
1867 return TRUE;
1868//#endif
1869}
1870static inline BOOLEAN _p_LmDivisibleByPart(poly a, const ring r_a, poly b, const ring r_b,const int start, const int end)
1871{
1872 if (p_GetComp(a, r_a) == 0 || p_GetComp(a,r_a) == p_GetComp(b,r_b))
1873 return _p_LmDivisibleByNoCompPart(a, r_a, b, r_b,start,end);
1874 return FALSE;
1875}
1876static inline BOOLEAN p_LmDivisibleByPart(poly a, poly b, const ring r,const int start, const int end)
1877{
1879 pIfThen1(a != NULL, p_LmCheckPolyRing1(b, r));
1880 if (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r))
1881 return _p_LmDivisibleByNoCompPart(a, r, b, r,start, end);
1882 return FALSE;
1883}
1884#endif
1885static inline BOOLEAN _p_LmDivisibleBy(poly a, poly b, const ring r)
1886{
1887 if (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r))
1888 return _p_LmDivisibleByNoComp(a, b, r);
1889 return FALSE;
1890}
1891static inline BOOLEAN p_LmDivisibleByNoComp(poly a, poly b, const ring r)
1892{
1893 p_LmCheckPolyRing1(a, r);
1895 return _p_LmDivisibleByNoComp(a, b, r);
1896}
1897
1898static inline BOOLEAN p_LmDivisibleByNoComp(poly a, const ring ra, poly b, const ring rb)
1899{
1902 return _p_LmDivisibleByNoComp(a, ra, b, rb);
1903}
1904
1905static inline BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
1906{
1908 pIfThen1(a != NULL, p_LmCheckPolyRing1(b, r));
1909 if (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r))
1910 return _p_LmDivisibleByNoComp(a, b, r);
1911 return FALSE;
1912}
1913
1914static inline BOOLEAN p_DivisibleBy(poly a, poly b, const ring r)
1915{
1917 pIfThen1(a!=NULL, p_LmCheckPolyRing1(a, r));
1918
1919 if (a != NULL && (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r)))
1920 return _p_LmDivisibleByNoComp(a,b,r);
1921 return FALSE;
1922}
1923
1924static inline BOOLEAN p_LmShortDivisibleBy(poly a, unsigned long sev_a,
1925 poly b, unsigned long not_sev_b, const ring r)
1926{
1927 p_LmCheckPolyRing1(a, r);
1929#ifndef PDIV_DEBUG
1930 _pPolyAssume2(p_GetShortExpVector(a, r) == sev_a, a, r);
1932
1933 if (sev_a & not_sev_b)
1934 {
1936 return FALSE;
1937 }
1938 return p_LmDivisibleBy(a, b, r);
1939#else
1940 return pDebugLmShortDivisibleBy(a, sev_a, r, b, not_sev_b, r);
1941#endif
1942}
1943
1944static inline BOOLEAN p_LmShortDivisibleByNoComp(poly a, unsigned long sev_a,
1945 poly b, unsigned long not_sev_b, const ring r)
1946{
1947 p_LmCheckPolyRing1(a, r);
1949#ifndef PDIV_DEBUG
1950 _pPolyAssume2(p_GetShortExpVector(a, r) == sev_a, a, r);
1952
1953 if (sev_a & not_sev_b)
1954 {
1956 return FALSE;
1957 }
1958 return p_LmDivisibleByNoComp(a, b, r);
1959#else
1961#endif
1962}
1963
1964/***************************************************************
1965 *
1966 * Misc things on Lm
1967 *
1968 ***************************************************************/
1969
1970
1971/// like the respective p_LmIs* routines, except that p might be empty
1972static inline BOOLEAN p_IsConstantComp(const poly p, const ring r)
1973{
1974 if (p == NULL) return TRUE;
1975 return (pNext(p)==NULL) && p_LmIsConstantComp(p, r);
1976}
1977
1978static inline BOOLEAN p_IsConstant(const poly p, const ring r)
1979{
1980 if (p == NULL) return TRUE;
1981 return (pNext(p)==NULL) && p_LmIsConstant(p, r);
1982}
1983
1984/// either poly(1) or gen(k)?!
1985static inline BOOLEAN p_IsOne(const poly p, const ring R)
1986{
1987 if (p == NULL) return FALSE; /* TODO check if 0 == 1 */
1988 p_Test(p, R);
1989 return (p_IsConstant(p, R) && n_IsOne(p_GetCoeff(p, R), R->cf));
1990}
1991
1992static inline BOOLEAN p_IsConstantPoly(const poly p, const ring r)
1993{
1994 p_Test(p, r);
1995 poly pp=p;
1996 while(pp!=NULL)
1997 {
1998 if (! p_LmIsConstantComp(pp, r))
1999 return FALSE;
2000 pIter(pp);
2001 }
2002 return TRUE;
2003}
2004
2005static inline BOOLEAN p_IsUnit(const poly p, const ring r)
2006{
2007 if (p == NULL) return FALSE;
2008 if (rField_is_Ring(r))
2009 return (p_LmIsConstant(p, r) && n_IsUnit(pGetCoeff(p),r->cf));
2010 return p_LmIsConstant(p, r);
2011}
2012
2013static inline BOOLEAN p_LmExpVectorAddIsOk(const poly p1, const poly p2,
2014 const ring r)
2015{
2016 p_LmCheckPolyRing(p1, r);
2017 p_LmCheckPolyRing(p2, r);
2018 unsigned long l1, l2, divmask = r->divmask;
2019 int i;
2020
2021 for (i=0; i<r->VarL_Size; i++)
2022 {
2023 l1 = p1->exp[r->VarL_Offset[i]];
2024 l2 = p2->exp[r->VarL_Offset[i]];
2025 // do the divisiblity trick
2026 if ( (l1 > ULONG_MAX - l2) ||
2027 (((l1 & divmask) ^ (l2 & divmask)) != ((l1 + l2) & divmask)))
2028 return FALSE;
2029 }
2030 return TRUE;
2031}
2032void p_Split(poly p, poly * r); /*p => IN(p), r => REST(p) */
2033BOOLEAN p_HasNotCF(poly p1, poly p2, const ring r);
2034BOOLEAN p_HasNotCFRing(poly p1, poly p2, const ring r);
2035poly p_mInit(const char *s, BOOLEAN &ok, const ring r); /* monom s -> poly, interpreter */
2036const char * p_Read(const char *s, poly &p,const ring r); /* monom -> poly */
2037poly p_MDivide(poly a, poly b, const ring r);
2038poly p_DivideM(poly a, poly b, const ring r);
2039poly pp_DivideM(poly a, poly b, const ring r);
2040poly p_Div_nn(poly p, const number n, const ring r);
2041
2042// returns the LCM of the head terms of a and b in *m, does not p_Setm
2043void p_Lcm(const poly a, const poly b, poly m, const ring r);
2044// returns the LCM of the head terms of a and b, does p_Setm
2045poly p_Lcm(const poly a, const poly b, const ring r);
2046
2047#ifdef HAVE_RATGRING
2048poly p_LcmRat(const poly a, const poly b, const long lCompM, const ring r);
2049poly p_GetCoeffRat(poly p, int ishift, ring r);
2050void p_LmDeleteAndNextRat(poly *p, int ishift, ring r);
2051void p_ContentRat(poly &ph, const ring r);
2052#endif /* ifdef HAVE_RATGRING */
2053
2054
2055poly p_Diff(poly a, int k, const ring r);
2056poly p_DiffOp(poly a, poly b,BOOLEAN multiply, const ring r);
2057int p_Weight(int c, const ring r);
2058
2059/// assumes that p and divisor are univariate polynomials in r,
2060/// mentioning the same variable;
2061/// assumes divisor != NULL;
2062/// p may be NULL;
2063/// assumes a global monomial ordering in r;
2064/// performs polynomial division of p by divisor:
2065/// - afterwards p contains the remainder of the division, i.e.,
2066/// p_before = result * divisor + p_afterwards;
2067/// - if needResult == TRUE, then the method computes and returns 'result',
2068/// otherwise NULL is returned (This parametrization can be used when
2069/// one is only interested in the remainder of the division. In this
2070/// case, the method will be slightly faster.)
2071/// leaves divisor unmodified
2072poly p_PolyDiv(poly &p, const poly divisor, const BOOLEAN needResult, const ring r);
2073
2074/* syszygy stuff */
2075BOOLEAN p_VectorHasUnitB(poly p, int * k, const ring r);
2076void p_VectorHasUnit(poly p, int * k, int * len, const ring r);
2077/// Splits *p into two polys: *q which consists of all monoms with
2078/// component == comp and *p of all other monoms *lq == pLength(*q)
2079/// On return all components pf *q == 0
2080void p_TakeOutComp(poly *p, long comp, poly *q, int *lq, const ring r);
2081
2082// This is something weird -- Don't use it, unless you know what you are doing
2083poly p_TakeOutComp(poly * p, int k, const ring r);
2084
2085void p_DeleteComp(poly * p,int k, const ring r);
2086
2087/*-------------ring management:----------------------*/
2088
2089// resets the pFDeg and pLDeg: if pLDeg is not given, it is
2090// set to currRing->pLDegOrig, i.e. to the respective LDegProc which
2091// only uses pFDeg (and not pDeg, or pTotalDegree, etc).
2092// If you use this, make sure your procs does not make any assumptions
2093// on ordering and/or OrdIndex -- otherwise they might return wrong results
2094// on strat->tailRing
2096// restores pFDeg and pLDeg:
2098
2099/*-------------pComp for syzygies:-------------------*/
2100void p_SetModDeg(intvec *w, ring r);
2101
2102/*------------ Jet ----------------------------------*/
2103poly pp_Jet(poly p, int m, const ring R);
2104poly pp_Jet0(poly p, const ring R); /*pp_Jet(p,0,R)*/
2105poly p_Jet(poly p, int m,const ring R);
2106poly pp_JetW(poly p, int m, int *w, const ring R);
2107poly p_JetW(poly p, int m, int *w, const ring R);
2108
2109poly n_PermNumber(const number z, const int *par_perm, const int OldPar, const ring src, const ring dst);
2110
2111poly p_PermPoly (poly p, const int * perm,const ring OldRing, const ring dst,
2112 nMapFunc nMap, const int *par_perm=NULL, int OldPar=0,
2114
2115/*----------------------------------------------------*/
2116poly p_Series(int n,poly p,poly u, intvec *w, const ring R);
2117
2118/*----------------------------------------------------*/
2119int p_Var(poly mi, const ring r);
2120/// the minimal index of used variables - 1
2121int p_LowVar (poly p, const ring r);
2122
2123/*----------------------------------------------------*/
2124/// shifts components of the vector p by i
2125void p_Shift (poly * p,int i, const ring r);
2126/*----------------------------------------------------*/
2127
2128int p_Compare(const poly a, const poly b, const ring R);
2129
2130/// polynomial gcd for f=mon
2131poly p_GcdMon(poly f, poly g, const ring r);
2132
2133/// divide polynomial by monomial
2134poly p_Div_mm(poly p, const poly m, const ring r);
2135
2136
2137/// max exponent of variable x_i in p
2138int p_MaxExpPerVar(poly p, int i, const ring r);
2139#endif // P_POLYS_H
2140
long int64
Definition auxiliary.h:68
int BOOLEAN
Definition auxiliary.h:88
#define TRUE
Definition auxiliary.h:101
#define FALSE
Definition auxiliary.h:97
CanonicalForm FACTORY_PUBLIC pp(const CanonicalForm &)
CanonicalForm pp ( const CanonicalForm & f )
Definition cf_gcd.cc:676
int l
Definition cfEzgcd.cc:100
int m
Definition cfEzgcd.cc:128
int i
Definition cfEzgcd.cc:132
int k
Definition cfEzgcd.cc:99
g
Definition cfModGcd.cc:4098
CanonicalForm b
Definition cfModGcd.cc:4111
FILE * f
Definition checklibs.c:9
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
Definition coeffs.h:455
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
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 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 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
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition coeffs.h:459
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
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
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 n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition coeffs.h:472
const CanonicalForm int s
Definition facAbsFact.cc:51
CanonicalForm res
Definition facAbsFact.cc:60
const CanonicalForm & w
Definition facAbsFact.cc:51
int j
Definition facHensel.cc:110
int comp(const CanonicalForm &A, const CanonicalForm &B)
compare polynomials
#define p_GetComp(p, r)
Definition monomials.h:64
#define pIfThen1(cond, check)
Definition monomials.h:179
#define pIter(p)
Definition monomials.h:37
#define pNext(p)
Definition monomials.h:36
#define p_LmCheckPolyRing1(p, r)
Definition monomials.h:177
#define pAssume1(cond)
Definition monomials.h:171
#define pSetCoeff0(p, n)
Definition monomials.h:59
#define p_GetCoeff(p, r)
Definition monomials.h:50
#define p_CheckRing1(r)
Definition monomials.h:178
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
#define _pPolyAssume2(cond, p, r)
Definition monomials.h:195
#define POLY_NEGWEIGHT_OFFSET
Definition monomials.h:236
#define p_SetRingOfLm(p, r)
Definition monomials.h:144
#define rRing_has_Comp(r)
Definition monomials.h:266
Definition lq.h:40
#define omTypeAlloc0Bin(type, addr, bin)
#define omTypeAllocBin(type, addr, bin)
#define omFreeBinAddr(addr)
#define omSizeWOfBin(bin_ptr)
#define NULL
Definition omList.c:12
omBin_t * omBin
Definition omStructs.h:12
#define REGISTER
Definition omalloc.h:27
BOOLEAN p_DebugLmDivisibleByNoComp(poly a, poly b, ring r)
Definition pDebug.cc:144
#define p_MemDiff_LengthGeneral(r, s1, s2, length)
Definition p_MemAdd.h:262
#define p_MemSub_LengthGeneral(r, s, length)
Definition p_MemAdd.h:291
#define p_MemAdd_LengthGeneral(r, s, length)
Definition p_MemAdd.h:173
#define p_MemAddSub_LengthGeneral(r, s, t, length)
Definition p_MemAdd.h:312
#define p_MemSum_LengthGeneral(r, s1, s2, length)
Definition p_MemAdd.h:86
poly p_Diff(poly a, int k, const ring r)
Definition p_polys.cc:1902
static int p_CmpPolys(poly p1, poly p2, ring r)
Definition p_polys.h:1754
poly p_DivideM(poly a, poly b, const ring r)
Definition p_polys.cc:1582
static void p_ExpVectorSum(poly pr, poly p1, poly p2, const ring r)
Definition p_polys.h:1440
poly pp_Jet(poly p, int m, const ring R)
Definition p_polys.cc:4399
void pSetDegProcs(ring r, pFDegProc new_FDeg, pLDegProc new_lDeg=NULL)
Definition p_polys.cc:3677
BOOLEAN p_LmCheckPolyRing(poly p, ring r)
Definition pDebug.cc:123
static void p_MemAdd_NegWeightAdjust(poly p, const ring r)
Definition p_polys.h:1307
static void p_ExpVectorAdd(poly p1, poly p2, const ring r)
Definition p_polys.h:1426
void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
Definition p_polys.cc:3689
static BOOLEAN _p_LmDivisibleByPart(poly a, const ring r_a, poly b, const ring r_b, const int start, const int end)
Definition p_polys.h:1871
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 div...
Definition p_polys.cc:1874
static BOOLEAN p_IsConstantComp(const poly p, const ring r)
like the respective p_LmIs* routines, except that p might be empty
Definition p_polys.h:1973
static poly p_LmInit(poly p, const ring r)
Definition p_polys.h:1350
poly p_GcdMon(poly f, poly g, const ring r)
polynomial gcd for f=mon
Definition p_polys.cc:4999
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:4645
int p_LowVar(poly p, const ring r)
the minimal index of used variables - 1
Definition p_polys.cc:4749
static void p_ExpVectorCopy(poly d_p, poly s_p, const ring r)
Definition p_polys.h:1328
static int p_Cmp(poly p1, poly p2, ring r)
Definition p_polys.h:1742
static void p_SetExpVL(poly p, int64 *ev, const ring r)
Definition p_polys.h:1568
BOOLEAN p_HasNotCF(poly p1, poly p2, const ring r)
Definition p_polys.cc:1330
static void p_SetExpV(poly p, int *ev, const ring r)
Definition p_polys.h:1559
static int p_LtCmpNoAbs(poly p, poly q, const ring r)
Definition p_polys.h:1662
static void p_MemSub_NegWeightAdjust(poly p, const ring r)
Definition p_polys.h:1317
poly pp_DivideM(poly a, poly b, const ring r)
Definition p_polys.cc:1637
int p_Weight(int c, const ring r)
Definition p_polys.cc:706
static int p_LtCmpOrdSgnEqP(poly p, poly q, const ring r)
Definition p_polys.h:1718
poly p_DiffOp(poly a, poly b, BOOLEAN multiply, const ring r)
Definition p_polys.cc:1977
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:489
poly p_Jet(poly p, int m, const ring R)
Definition p_polys.cc:4455
static void p_ExpVectorDiff(poly pr, poly p1, poly p2, const ring r)
Definition p_polys.h:1489
const char * p_Read(const char *s, poly &p, const ring r)
Definition p_polys.cc:1371
void p_Shift(poly *p, int i, const ring r)
shifts components of the vector p by i
Definition p_polys.cc:4775
poly p_Div_nn(poly p, const number n, const ring r)
Definition p_polys.cc:1506
void p_DeleteComp(poly *p, int k, const ring r)
Definition p_polys.cc:3583
poly p_MDivide(poly a, poly b, const ring r)
Definition p_polys.cc:1493
void p_ContentRat(poly &ph, const ring r)
Definition p_polys.cc:1748
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition p_polys.h:248
poly p_Div_mm(poly p, const poly m, const ring r)
divide polynomial by monomial
Definition p_polys.cc:1542
poly pp_Jet0(poly p, const ring R)
Definition p_polys.cc:4427
static void p_ExpVectorSub(poly p1, poly p2, const ring r)
Definition p_polys.h:1455
int p_MaxExpPerVar(poly p, int i, const ring r)
max exponent of variable x_i in p
Definition p_polys.cc:5061
int p_Var(poly mi, const ring r)
Definition p_polys.cc:4725
int p_Compare(const poly a, const poly b, const ring R)
Definition p_polys.cc:4965
static void p_Setm(poly p, const ring r)
Definition p_polys.h:234
poly p_mInit(const char *s, BOOLEAN &ok, const ring r)
Definition p_polys.cc:1443
void p_LmDeleteAndNextRat(poly *p, int ishift, ring r)
Definition p_polys.cc:1704
static poly p_LmShallowCopyDelete(poly p, const ring r)
Definition p_polys.h:1408
static void p_GetExpVL(poly p, int64 *ev, const ring r)
Definition p_polys.h:1544
static int p_LtCmp(poly p, poly q, const ring r)
Definition p_polys.h:1636
static BOOLEAN p_LmIsConstantComp(const poly p, const ring r)
Definition p_polys.h:1007
static int p_LmCmp(poly p, poly q, const ring r)
Definition p_polys.h:1595
poly p_Series(int n, poly p, poly u, intvec *w, const ring R)
Definition p_polys.cc:4567
static BOOLEAN p_LmShortDivisibleBy(poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
Definition p_polys.h:1925
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:470
static BOOLEAN p_LmIsConstant(const poly p, const ring r)
Definition p_polys.h:1024
static BOOLEAN p_LmDivisibleByNoComp(poly a, poly b, const ring r)
Definition p_polys.h:1892
static BOOLEAN p_IsOne(const poly p, const ring R)
either poly(1) or gen(k)?!
Definition p_polys.h:1986
static BOOLEAN p_IsConstant(const poly p, const ring r)
Definition p_polys.h:1979
static void p_SetExpVLV(poly p, int64 *ev, int64 comp, const ring r)
Definition p_polys.h:1579
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:1852
BOOLEAN p_CheckRing(ring r)
Definition pDebug.cc:131
static BOOLEAN _p_LmDivisibleBy(poly a, poly b, const ring r)
Definition p_polys.h:1886
static unsigned long p_GetTotalDegree(const unsigned long l, const ring r, const int number_of_exps)
Definition p_polys.h:811
static poly p_New(const ring, omBin bin)
Definition p_polys.h:665
void p_Split(poly p, poly *r)
Definition p_polys.cc:1321
poly n_PermNumber(const number z, const int *par_perm, const int OldPar, const ring src, const ring dst)
Definition p_polys.cc:4068
static poly p_GetExp_k_n(poly p, int l, int k, const ring r)
Definition p_polys.h:1387
static BOOLEAN p_LmShortDivisibleByNoComp(poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
Definition p_polys.h:1945
poly p_GetCoeffRat(poly p, int ishift, ring r)
Definition p_polys.cc:1726
BOOLEAN p_VectorHasUnitB(poly p, int *k, const ring r)
Definition p_polys.cc:3402
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
Definition p_polys.h:1906
poly p_LcmRat(const poly a, const poly b, const long lCompM, const ring r)
Definition p_polys.cc:1681
static BOOLEAN p_DivisibleBy(poly a, poly b, const ring r)
Definition p_polys.h:1915
static BOOLEAN p_ExpVectorEqual(poly p1, poly p2, const ring r)
Definition p_polys.h:1504
void p_SetModDeg(intvec *w, ring r)
Definition p_polys.cc:3713
static int64 p_GetExpVLV(poly p, int64 *ev, const ring r)
Definition p_polys.h:1551
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 ...
Definition p_polys.cc:3535
BOOLEAN p_HasNotCFRing(poly p1, poly p2, const ring r)
Definition p_polys.cc:1346
static int p_LtCmpOrdSgnDiffM(poly p, poly q, const ring r)
Definition p_polys.h:1684
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:1780
void p_VectorHasUnit(poly p, int *k, int *len, const ring r)
Definition p_polys.cc:3425
static void p_GetExpV(poly p, int *ev, const ring r)
Definition p_polys.h:1535
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 p_polys.cc:4171
static int p_LtCmpOrdSgnEqM(poly p, poly q, const ring r)
Definition p_polys.h:1709
#define pDivAssume(x)
Definition p_polys.h:1297
static BOOLEAN p_IsUnit(const poly p, const ring r)
Definition p_polys.h:2006
static poly p_Init(const ring r, omBin bin)
Definition p_polys.h:1335
unsigned long p_GetShortExpVector(const poly a, const ring r)
Definition p_polys.cc:4849
poly pp_JetW(poly p, int m, int *w, const ring R)
Definition p_polys.cc:4472
static BOOLEAN p_LmDivisibleByPart(poly a, poly b, const ring r, const int start, const int end)
Definition p_polys.h:1877
static long p_Totaldegree(poly p, const ring r)
Definition p_polys.h:1522
static BOOLEAN p_LmExpVectorAddIsOk(const poly p1, const poly p2, const ring r)
Definition p_polys.h:2014
static int p_LtCmpOrdSgnDiffP(poly p, poly q, const ring r)
Definition p_polys.h:1693
void p_Lcm(const poly a, const poly b, poly m, const ring r)
Definition p_polys.cc:1659
#define p_Test(p, r)
Definition p_polys.h:161
poly p_JetW(poly p, int m, int *w, const ring R)
Definition p_polys.cc:4499
static BOOLEAN p_IsConstantPoly(const poly p, const ring r)
Definition p_polys.h:1993
static void p_ExpVectorAddSub(poly p1, poly p2, poly p3, const ring r)
Definition p_polys.h:1471
long(* pFDegProc)(poly p, ring r)
Definition ring.h:38
long(* pLDegProc)(poly p, int *length, ring r)
Definition ring.h:37
#define rField_is_Ring(R)
Definition ring.h:490
#define R
Definition sirandom.c:27

◆ p_LmCmpAction

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

Definition at line 1734 of file p_polys.h.

◆ p_LmEqual

#define p_LmEqual (   p1,
  p2,
 
)    p_ExpVectorEqual(p1, p2, r)

Definition at line 1738 of file p_polys.h.

◆ p_LmTest

#define p_LmTest (   p,
 
)    _p_LmTest(p, r, PDEBUG)

Definition at line 162 of file p_polys.h.

◆ p_SetmComp

#define p_SetmComp   p_Setm

Definition at line 245 of file p_polys.h.

◆ p_Test

#define p_Test (   p,
 
)    _p_Test(p, r, PDEBUG)

Definition at line 161 of file p_polys.h.

◆ pDivAssume

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

Definition at line 1297 of file p_polys.h.

◆ pIfThen

#define pIfThen (   cond,
  check 
)    do {if (cond) {check;}} while (0)

Definition at line 155 of file p_polys.h.

◆ pp_Test

#define pp_Test (   p,
  lmRing,
  tailRing 
)    _pp_Test(p, lmRing, tailRing, PDEBUG)

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 1886 of file p_polys.h.

1887{
1888 if (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r))
1889 return _p_LmDivisibleByNoComp(a, b, r);
1890 return FALSE;
1891}

◆ _p_LmDivisibleByNoComp() [1/2]

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

Definition at line 1829 of file p_polys.h.

1830{
1831 int i=r_a->N;
1832 pAssume1(r_a->N == r_b->N);
1833
1834 do
1835 {
1836 if (p_GetExp(a,i,r_a) > p_GetExp(b,i,r_b))
1837 {
1838 return FALSE;
1839 }
1840 i--;
1841 }
1842 while (i);
1843/*#ifdef HAVE_RINGS
1844 return n_DivBy(p_GetCoeff(b, r_b), p_GetCoeff(a, r_a), r_a->cf);
1845#else
1846*/
1847 return TRUE;
1848//#endif
1849}

◆ _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 1780 of file p_polys.h.

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

◆ _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 1852 of file p_polys.h.

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

◆ _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 1871 of file p_polys.h.

1872{
1873 if (p_GetComp(a, r_a) == 0 || p_GetComp(a,r_a) == p_GetComp(b,r_b))
1874 return _p_LmDivisibleByNoCompPart(a, r_a, b, r_b,start,end);
1875 return FALSE;
1876}

◆ _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;
328 pNext(p) = pnext;
329 return test_res;
330}
int level(const CanonicalForm &f)
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 {
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 {
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 {
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}
poly singclap_pmult(poly f, poly g, const ring r)
Definition clapsing.cc:577
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
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:902
static BOOLEAN rField_is_Z(const ring r)
Definition ring.h:514
static BOOLEAN rField_is_Zp(const ring r)
Definition ring.h:505
static BOOLEAN rField_is_Q(const ring r)
Definition ring.h:511

◆ _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}
static poly pp_Mult_mm(poly p, poly m, const ring r)
Definition p_polys.h:1032
static poly p_Plus_mm_Mult_qq(poly p, poly m, poly q, int &lp, int lq, const ring r)
Definition p_polys.h:1198
BOOLEAN pHaveCommonMonoms(poly p, poly q)
Definition pDebug.cc:174

◆ _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
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
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);
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 PDEBUG
Definition auxiliary.h:171
#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
@ 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 BOOLEAN p_ExpVectorEqual(poly p1, poly p2, const ring r1, const ring r2)
Definition p_polys.cc:4595
static void p_LmFree(poly p, ring)
Definition p_polys.h:684
@ ro_syzcomp
Definition ring.h:59
union sro_ord::@1 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
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 4068 of file p_polys.cc.

4069{
4070#if 0
4071 PrintS("\nSource Ring: \n");
4072 rWrite(src);
4073
4074 if(0)
4075 {
4076 number zz = n_Copy(z, src->cf);
4077 PrintS("z: "); n_Write(zz, src);
4078 n_Delete(&zz, src->cf);
4079 }
4080
4081 PrintS("\nDestination Ring: \n");
4082 rWrite(dst);
4083
4084 /*Print("\nOldPar: %d\n", OldPar);
4085 for( int i = 1; i <= OldPar; i++ )
4086 {
4087 Print("par(%d) -> par/var (%d)\n", i, par_perm[i-1]);
4088 }*/
4089#endif
4090 if( z == NULL )
4091 return NULL;
4092
4093 const coeffs srcCf = src->cf;
4094 assume( srcCf != NULL );
4095
4097 assume( src->cf->extRing!=NULL );
4098
4099 poly zz = NULL;
4100
4101 const ring srcExtRing = srcCf->extRing;
4102 assume( srcExtRing != NULL );
4103
4104 const coeffs dstCf = dst->cf;
4105 assume( dstCf != NULL );
4106
4107 if( nCoeff_is_algExt(srcCf) ) // nCoeff_is_GF(srcCf)?
4108 {
4109 zz = (poly) z;
4110 if( zz == NULL ) return NULL;
4111 }
4112 else if (nCoeff_is_transExt(srcCf))
4113 {
4114 assume( !IS0(z) );
4115
4116 zz = NUM((fraction)z);
4117 p_Test (zz, srcExtRing);
4118
4119 if( zz == NULL ) return NULL;
4120 if( !DENIS1((fraction)z) )
4121 {
4123 WarnS("Not defined: Cannot map a rational fraction and make a polynomial out of it! Ignoring the denominator.");
4124 }
4125 }
4126 else
4127 {
4128 assume (FALSE);
4129 WerrorS("Number permutation is not implemented for this data yet!");
4130 return NULL;
4131 }
4132
4133 assume( zz != NULL );
4134 p_Test (zz, srcExtRing);
4135
4137
4138 assume( nMap != NULL );
4139
4140 poly qq;
4141 if ((par_perm == NULL) && (rPar(dst) != 0 && rVar (srcExtRing) > 0))
4142 {
4143 int* perm;
4144 perm=(int *)omAlloc0((rVar(srcExtRing)+1)*sizeof(int));
4145 for(int i=si_min(rVar(srcExtRing),rPar(dst));i>0;i--)
4146 perm[i]=-i;
4148 omFreeSize ((ADDRESS)perm, (rVar(srcExtRing)+1)*sizeof(int));
4149 }
4150 else
4152
4154 && (!DENIS1((fraction)z))
4156 {
4158 qq=p_Div_nn(qq,n,dst);
4159 n_Delete(&n,dstCf);
4161 }
4162 p_Test (qq, dst);
4163
4164 return qq;
4165}
static int si_min(const int a, const int b)
Definition auxiliary.h:126
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_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
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
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:4171
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:3854
#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:604
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition ring.h:597

◆ p_Add_q() [1/2]

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

Definition at line 937 of file p_polys.h.

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

◆ 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 947 of file p_polys.h.

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

◆ p_AddComp()

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

Definition at line 448 of file p_polys.h.

449{
452 return __p_GetComp(p,r) += v;
453}
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

◆ p_AddExp()

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

Definition at line 607 of file p_polys.h.

608{
610 int e = p_GetExp(p,v,r);
611 e += ee;
612 return p_SetExp(p,v,e,r);
613}

◆ 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);
116 xx[j]=hh;
117 }
118 else
119 x[j]=n_Init(0, R->cf);
120 }
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 }
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 number p_SetCoeff(poly p, number n, ring r)
Definition p_polys.h:413
static poly pReverse(poly p)
Definition p_polys.h:336
static poly p_Head(const poly p, const ring r)
copy the (leading) term of p
Definition p_polys.h:861
static poly p_LmFreeAndNext(poly p, ring)
Definition p_polys.h:712
#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 {
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 {
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 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
#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:1108
static BOOLEAN rIsRatGRing(const ring r)
Definition ring.h:432

◆ 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 {
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 {
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_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:544

◆ p_Cmp()

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

Definition at line 1742 of file p_polys.h.

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

◆ p_CmpPolys()

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

Definition at line 1754 of file p_polys.h.

1755{
1756 if (p2==NULL)
1757 {
1758 if (p1==NULL) return 0;
1759 return 1;
1760 }
1761 if (p1==NULL)
1762 return -1;
1763 return p_ComparePolys(p1,p2,r);
1764}

◆ p_Comp_k_n()

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

Definition at line 641 of file p_polys.h.

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

◆ p_Compare()

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

Definition at line 4965 of file p_polys.cc.

4966{
4967 int r=p_Cmp(a,b,R);
4968 if ((r==0)&&(a!=NULL))
4969 {
4970 number h=n_Sub(pGetCoeff(a),pGetCoeff(b),R->cf);
4971 /* compare lead coeffs */
4972 r = -1+n_IsZero(h,R->cf)+2*n_GreaterZero(h,R->cf); /* -1: <, 0:==, 1: > */
4973 n_Delete(&h,R->cf);
4974 }
4975 else if (a==NULL)
4976 {
4977 if (b==NULL)
4978 {
4979 /* compare 0, 0 */
4980 r=0;
4981 }
4982 else if(p_IsConstant(b,R))
4983 {
4984 /* compare 0, const */
4985 r = 1-2*n_GreaterZero(pGetCoeff(b),R->cf); /* -1: <, 1: > */
4986 }
4987 }
4988 else if (b==NULL)
4989 {
4990 if (p_IsConstant(a,R))
4991 {
4992 /* compare const, 0 */
4993 r = -1+2*n_GreaterZero(pGetCoeff(a),R->cf); /* -1: <, 1: > */
4994 }
4995 }
4996 return(r);
4997}
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

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

4646{
4647 number n,nn;
4648 pAssume(p1 != NULL && p2 != NULL);
4649
4650 if (!p_LmEqual(p1,p2,r)) //compare leading mons
4651 return FALSE;
4652 if ((pNext(p1)==NULL) && (pNext(p2)!=NULL))
4653 return FALSE;
4654 if ((pNext(p2)==NULL) && (pNext(p1)!=NULL))
4655 return FALSE;
4656 if (pLength(p1) != pLength(p2))
4657 return FALSE;
4658 #ifdef HAVE_RINGS
4659 if (rField_is_Ring(r))
4660 {
4661 if (!n_DivBy(pGetCoeff(p1), pGetCoeff(p2), r->cf)) return FALSE;
4662 }
4663 #endif
4664 n=n_Div(pGetCoeff(p1),pGetCoeff(p2),r->cf);
4665 while ((p1 != NULL) /*&& (p2 != NULL)*/)
4666 {
4667 if ( ! p_LmEqual(p1, p2,r))
4668 {
4669 n_Delete(&n, r->cf);
4670 return FALSE;
4671 }
4672 if (!n_Equal(pGetCoeff(p1), nn = n_Mult(pGetCoeff(p2),n, r->cf), r->cf))
4673 {
4674 n_Delete(&n, r->cf);
4675 n_Delete(&nn, r->cf);
4676 return FALSE;
4677 }
4678 n_Delete(&nn, r->cf);
4679 pIter(p1);
4680 pIter(p2);
4681 }
4682 n_Delete(&n, r->cf);
4683 return TRUE;
4684}
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
#define pAssume(cond)
Definition monomials.h:90
#define p_LmEqual(p1, p2, r)
Definition p_polys.h:1738

◆ 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 {
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 {
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 {
2348 p_SetCoeff(p,d,r);
2349 pIter(p);
2350 }
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:534

◆ 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!
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!
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:495

◆ 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:937
static poly p_Mult_q(poly p, poly q, const ring r)
Definition p_polys.h:1119
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition p_polys.h:847
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:382

◆ 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 884 of file p_polys.h.

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

◆ p_Copy() [2/2]

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

returns a copy of p

Definition at line 847 of file p_polys.h.

848{
849 if (p!=NULL)
850 {
851 p_Test(p,r);
852 const poly pp = p_Copy_noCheck(p, r);
853 p_Test(pp,r);
854 return pp;
855 }
856 else
857 return NULL;
858}

◆ 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 837 of file p_polys.h.

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

◆ p_CopyPowerProduct()

poly p_CopyPowerProduct ( const poly  p,
const ring  r 
)

like p_Head, but with coefficient 1

Definition at line 5049 of file p_polys.cc.

5050{
5051 if (p == NULL) return NULL;
5052 return p_CopyPowerProduct0(p,n_Init(1,r->cf),r);
5053}
poly p_CopyPowerProduct0(const poly p, number n, const ring r)
like p_Head, but with coefficient n
Definition p_polys.cc:5037

◆ p_CopyPowerProduct0()

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

like p_Head, but with coefficient n

Definition at line 5037 of file p_polys.cc.

5038{
5040 poly np;
5041 omTypeAllocBin(poly, np, r->PolyBin);
5042 p_SetRingOfLm(np, r);
5043 memcpy(np->exp, p->exp, r->ExpL_Size*sizeof(long));
5044 pNext(np) = NULL;
5045 pSetCoeff0(np, n);
5046 return np;
5047}

◆ p_DecrExp()

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

Definition at line 599 of file p_polys.h.

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

◆ 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}
static long p_GetOrder(poly p, ring r)
Definition p_polys.h:422

◆ 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}
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 909 of file p_polys.h.

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

◆ p_Delete() [2/2]

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

Definition at line 902 of file p_polys.h.

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

◆ p_DeleteComp()

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

Definition at line 3583 of file p_polys.cc.

3584{
3585 poly q;
3586 long unsigned kk=k;
3587
3588 while ((*p!=NULL) && (__p_GetComp(*p,r)==kk)) p_LmDelete(p,r);
3589 if (*p==NULL) return;
3590 q = *p;
3591 if (__p_GetComp(q,r)>kk)
3592 {
3593 p_SubComp(q,1,r);
3594 p_SetmComp(q,r);
3595 }
3596 while (pNext(q)!=NULL)
3597 {
3598 unsigned long c=__p_GetComp(pNext(q),r);
3599 if (/*__p_GetComp(pNext(q),r)*/c==kk)
3600 p_LmDelete(&(pNext(q)),r);
3601 else
3602 {
3603 pIter(q);
3604 if (/*__p_GetComp(q,r)*/c>kk)
3605 {
3606 p_SubComp(q,1,r);
3607 p_SetmComp(q,r);
3608 }
3609 }
3610 }
3611}
static unsigned long p_SubComp(poly p, unsigned long v, ring r)
Definition p_polys.h:454
#define p_SetmComp
Definition p_polys.h:245

◆ 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}
STATIC_VAR poly last
Definition hdegree.cc:1137
static long p_DecrExp(poly p, int v, ring r)
Definition p_polys.h:599

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

◆ 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 {
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);
1626 n_Delete(&inv, r->cf);
1627 }
1628 else
1629 {
1631 }
1632 }
1633 p_Delete(&b, r);
1634 return result;
1635}
#define __p_Mult_nn(p, n, r)
Definition p_polys.h:972
static BOOLEAN rIsNCRing(const ring r)
Definition ring.h:426

◆ p_DivisibleBy()

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

Definition at line 1915 of file p_polys.h.

1916{
1918 pIfThen1(a!=NULL, p_LmCheckPolyRing1(a, r));
1919
1920 if (a != NULL && (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r)))
1921 return _p_LmDivisibleByNoComp(a,b,r);
1922 return FALSE;
1923}

◆ 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}
#define exponent

◆ p_EqualPolys() [1/2]

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

Definition at line 4581 of file p_polys.cc.

4582{
4583 while ((p1 != NULL) && (p2 != NULL))
4584 {
4585 if (! p_LmEqual(p1, p2,r))
4586 return FALSE;
4587 if (! n_Equal(p_GetCoeff(p1,r), p_GetCoeff(p2,r),r->cf ))
4588 return FALSE;
4589 pIter(p1);
4590 pIter(p2);
4591 }
4592 return (p1==p2);
4593}

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

4620{
4621 assume( r1 == r2 || rSamePolyRep(r1, r2) ); // will be used in rEqual!
4622 assume( r1->cf == r2->cf );
4623
4624 while ((p1 != NULL) && (p2 != NULL))
4625 {
4626 // returns 1 if ExpVector(p)==ExpVector(q): does not compare numbers !!
4627 // #define p_LmEqual(p1, p2, r) p_ExpVectorEqual(p1, p2, r)
4628
4629 if (! p_ExpVectorEqual(p1, p2, r1, r2))
4630 return FALSE;
4631
4632 if (! n_Equal(p_GetCoeff(p1,r1), p_GetCoeff(p2,r2), r1->cf ))
4633 return FALSE;
4634
4635 pIter(p1);
4636 pIter(p2);
4637 }
4638 return (p1==p2);
4639}
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:1802

◆ p_ExpVectorAdd()

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

Definition at line 1426 of file p_polys.h.

1427{
1428 p_LmCheckPolyRing1(p1, r);
1429 p_LmCheckPolyRing1(p2, r);
1430#if PDEBUG >= 1
1431 for (int i=1; i<=r->N; i++)
1432 pAssume1((unsigned long) (p_GetExp(p1, i, r) + p_GetExp(p2, i, r)) <= r->bitmask);
1433 pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0);
1434#endif
1435
1436 p_MemAdd_LengthGeneral(p1->exp, p2->exp, r->ExpL_Size);
1438}

◆ p_ExpVectorAddSub()

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

Definition at line 1471 of file p_polys.h.

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

◆ p_ExpVectorCopy()

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

Definition at line 1328 of file p_polys.h.

1329{
1332 memcpy(d_p->exp, s_p->exp, r->ExpL_Size*sizeof(long));
1333}

◆ p_ExpVectorDiff()

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

Definition at line 1489 of file p_polys.h.

1490{
1491 p_LmCheckPolyRing1(p1, r);
1492 p_LmCheckPolyRing1(p2, r);
1494#if PDEBUG >= 2
1495 for (int i=1; i<=r->N; i++)
1496 pAssume1(p_GetExp(p1, i, r) >= p_GetExp(p2, i, r));
1497 pAssume1(!rRing_has_Comp(r) || p_GetComp(p1, r) == p_GetComp(p2, r));
1498#endif
1499
1500 p_MemDiff_LengthGeneral(pr->exp, p1->exp, p2->exp, r->ExpL_Size);
1502}

◆ p_ExpVectorEqual()

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

Definition at line 1504 of file p_polys.h.

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

◆ p_ExpVectorSub()

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

Definition at line 1455 of file p_polys.h.

1456{
1457 p_LmCheckPolyRing1(p1, r);
1458 p_LmCheckPolyRing1(p2, r);
1459#if PDEBUG >= 1
1460 for (int i=1; i<=r->N; i++)
1461 pAssume1(p_GetExp(p1, i, r) >= p_GetExp(p2, i, r));
1462 pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0 ||
1463 p_GetComp(p1, r) == p_GetComp(p2, r));
1464#endif
1465
1466 p_MemSub_LengthGeneral(p1->exp, p2->exp, r->ExpL_Size);
1468}

◆ p_ExpVectorSum()

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

Definition at line 1440 of file p_polys.h.

1441{
1442 p_LmCheckPolyRing1(p1, r);
1443 p_LmCheckPolyRing1(p2, r);
1445#if PDEBUG >= 1
1446 for (int i=1; i<=r->N; i++)
1447 pAssume1((unsigned long) (p_GetExp(p1, i, r) + p_GetExp(p2, i, r)) <= r->bitmask);
1448 pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0);
1449#endif
1450
1451 p_MemSum_LengthGeneral(pr->exp, p1->exp, p2->exp, r->ExpL_Size);
1453}

◆ 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 {
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 381 of file p_polys.h.

381{ 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 4999 of file p_polys.cc.

5000{
5001 assume(f!=NULL);
5002 assume(g!=NULL);
5003 assume(pNext(f)==NULL);
5004 poly G=p_Head(f,r);
5005 poly h=g;
5006 int *mf=(int*)omAlloc((r->N+1)*sizeof(int));
5007 p_GetExpV(f,mf,r);
5008 int *mh=(int*)omAlloc((r->N+1)*sizeof(int));
5011 loop
5012 {
5013 if (h==NULL) break;
5014 if(!one_coeff)
5015 {
5017 one_coeff=n_IsOne(n,r->cf);
5018 p_SetCoeff(G,n,r);
5019 }
5020 p_GetExpV(h,mh,r);
5022 for(unsigned j=r->N;j!=0;j--)
5023 {
5024 if (mh[j]<mf[j]) mf[j]=mh[j];
5025 if (mf[j]>0) const_mon=FALSE;
5026 }
5027 if (one_coeff && const_mon) break;
5028 pIter(h);
5029 }
5030 mf[0]=0;
5031 p_SetExpV(G,mf,r); // included is p_SetComp, p_Setm
5032 omFreeSize(mf,(r->N+1)*sizeof(int));
5033 omFreeSize(mh,(r->N+1)*sizeof(int));
5034 return G;
5035}
STATIC_VAR TreeM * G
Definition janet.cc:31
#define omAlloc(size)

◆ 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}
static int p_Comp_k_n(poly a, poly b, int k, ring r)
Definition p_polys.h:641
static void p_SetCompP(poly p, int i, ring r)
Definition p_polys.h:255

◆ 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 573 of file p_polys.h.

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

◆ p_GetExp() [2/3]

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

Definition at line 556 of file p_polys.h.

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

◆ 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 470 of file p_polys.h.

471{
472 pAssume2((VarOffset >> (24 + 6)) == 0);
473#if 0
474 int pos=(VarOffset & 0xffffff);
475 int bitpos=(VarOffset >> 24);
476 unsigned long exp=(p->exp[pos] >> bitmask) & iBitmask;
477 return exp;
478#else
479 return (long)
480 ((p->exp[(VarOffset & 0xffffff)] >> (VarOffset >> 24))
481 & iBitmask);
482#endif
483}
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 1387 of file p_polys.h.

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

◆ p_GetExpDiff()

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

Definition at line 636 of file p_polys.h.

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

◆ p_GetExpSum()

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

Definition at line 630 of file p_polys.h.

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

◆ p_GetExpV()

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

Definition at line 1535 of file p_polys.h.

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

◆ p_GetExpVL()

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

Definition at line 1544 of file p_polys.h.

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

◆ p_GetExpVLV()

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

Definition at line 1551 of file p_polys.h.

1552{
1554 for (unsigned j = r->N; j!=0; j--)
1555 ev[j-1] = p_GetExp(p, j, r);
1556 return (int64)p_GetComp(p,r);
1557}

◆ p_GetMaxExp() [1/2]

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

Definition at line 805 of file p_polys.h.

806{
807 return p_GetMaxExp(p_GetMaxExpL(p, r), r);
808}
static unsigned long p_GetMaxExp(const unsigned long l, const ring r)
Definition p_polys.h:782
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 782 of file p_polys.h.

783{
784 unsigned long bitmask = r->bitmask;
785 unsigned long max = (l & bitmask);
786 unsigned long j = r->ExpPerLong - 1;
787
788 if (j > 0)
789 {
790 unsigned long i = r->BitsPerExp;
791 long e;
792 loop
793 {
794 e = ((l >> i) & bitmask);
795 if ((unsigned long) e > max)
796 max = e;
797 j--;
798 if (j==0) break;
799 i += r->BitsPerExp;
800 }
801 }
802 return max;
803}
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)))
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)))
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

◆ p_GetOrder()

static long p_GetOrder ( poly  p,
ring  r 
)
inlinestatic

Definition at line 422 of file p_polys.h.

423{
425 if (r->typ==NULL) return ((p)->exp[r->pOrdIndex]);
426 int i=0;
427 loop
428 {
429 switch(r->typ[i].ord_typ)
430 {
431 case ro_am:
432 case ro_wp_neg:
433 return ((p->exp[r->pOrdIndex])-POLY_NEGWEIGHT_OFFSET);
434 case ro_syzcomp:
435 case ro_syz:
436 case ro_cp:
437 i++;
438 break;
439 //case ro_dp:
440 //case ro_wp:
441 default:
442 return ((p)->exp[r->pOrdIndex]);
443 }
444 }
445}
@ ro_syz
Definition ring.h:60
@ ro_cp
Definition ring.h:58
@ ro_wp_neg
Definition ring.h:56
@ ro_am
Definition ring.h:54

◆ 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:52
@ ro_wp
Definition ring.h:53

◆ p_GetShortExpVector()

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

Definition at line 4849 of file p_polys.cc.

4850{
4851 assume(p != NULL);
4852 unsigned long ev = 0; // short exponent vector
4853 unsigned int n = BIT_SIZEOF_LONG / r->N; // number of bits per exp
4854 unsigned int m1; // highest bit which is filled with (n+1)
4855 unsigned int i=0;
4856 int j=1;
4857
4858 if (n == 0)
4859 {
4860 if (r->N <2*BIT_SIZEOF_LONG)
4861 {
4862 n=1;
4863 m1=0;
4864 }
4865 else
4866 {
4867 for (; j<=r->N; j++)
4868 {
4869 if (p_GetExp(p,j,r) > 0) i++;
4870 if (i == BIT_SIZEOF_LONG) break;
4871 }
4872 if (i>0)
4873 ev = ~(0UL) >> (BIT_SIZEOF_LONG - i);
4874 return ev;
4875 }
4876 }
4877 else
4878 {
4879 m1 = (n+1)*(BIT_SIZEOF_LONG - n*r->N);
4880 }
4881
4882 n++;
4883 while (i<m1)
4884 {
4885 ev |= GetBitFields(p_GetExp(p, j,r), i, n);
4886 i += n;
4887 j++;
4888 }
4889
4890 n--;
4891 while (i<BIT_SIZEOF_LONG)
4892 {
4893 ev |= GetBitFields(p_GetExp(p, j,r), i, n);
4894 i += n;
4895 j++;
4896 }
4897 return ev;
4898}
#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:4817

◆ p_GetShortExpVector0()

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

Definition at line 4900 of file p_polys.cc.

4901{
4902 assume(p != NULL);
4903 assume(r->N >=BIT_SIZEOF_LONG);
4904 unsigned long ev = 0; // short exponent vector
4905
4906 for (int j=BIT_SIZEOF_LONG; j>0; j--)
4907 {
4908 if (p_GetExp(p, j,r)>0)
4909 ev |= Sy_bitL(j-1);
4910 }
4911 return ev;
4912}
#define Sy_bitL(x)
Definition options.h:32

◆ p_GetShortExpVector1()

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

Definition at line 4915 of file p_polys.cc.

4916{
4917 assume(p != NULL);
4918 assume(r->N <BIT_SIZEOF_LONG);
4919 assume(2*r->N >=BIT_SIZEOF_LONG);
4920 unsigned long ev = 0; // short exponent vector
4921 int rest=r->N;
4922 int e;
4923 // 2 bits per exp
4924 int j=r->N;
4925 for (; j>BIT_SIZEOF_LONG-r->N; j--)
4926 {
4927 if ((e=p_GetExp(p, j,r))>0)
4928 {
4929 ev |= Sy_bitL(j-1);
4930 if (e>1)
4931 {
4932 ev|=Sy_bitL(rest+j-1);
4933 }
4934 }
4935 }
4936 // 1 bit per exp
4937 for (; j>0; j--)
4938 {
4939 if (p_GetExp(p, j,r)>0)
4940 {
4941 ev |= Sy_bitL(j-1);
4942 }
4943 }
4944 return ev;
4945}

◆ p_GetTotalDegree()

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

Definition at line 811 of file p_polys.h.

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

◆ 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 861 of file p_polys.h.

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

◆ p_Head0()

poly p_Head0 ( const poly  p,
const ring  r 
)

like p_Head, but allow NULL coeff

Definition at line 5055 of file p_polys.cc.

5056{
5057 if (p==NULL) return NULL;
5058 if (pGetCoeff(p)==NULL) return p_CopyPowerProduct0(p,NULL,r);
5059 return p_Head(p,r);
5060}

◆ 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:607
@ ringorder_lp
Definition ring.h:77
void sBucket_Add_m(sBucket_pt bucket, poly p)
Definition sbuckets.cc:173
sBucket_pt sBucketCreate(const ring r)
Definition sbuckets.cc:96
void sBucketDestroyAdd(sBucket_pt bucket, poly *p, int *length)
Definition sbuckets.h:68

◆ p_IncrExp()

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

Definition at line 592 of file p_polys.h.

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

◆ p_Init() [1/2]

static poly p_Init ( const ring  r)
inlinestatic

Definition at line 1345 of file p_polys.h.

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

◆ p_Init() [2/2]

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

Definition at line 1335 of file p_polys.h.

1336{
1337 p_CheckRing1(r);
1338 pAssume1(bin != NULL && omSizeWOfBin(r->PolyBin) == omSizeWOfBin(bin));
1339 poly p;
1340 omTypeAlloc0Bin(poly, p, bin);
1342 p_SetRingOfLm(p, r);
1343 return p;
1344}

◆ 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;
2653 pIter(p);
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);
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 {
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:2692
LINLINE number nlSub(number la, number li, const coeffs r)
Definition longrat.cc:2758
LINLINE void nlDelete(number *a, const coeffs r)
Definition longrat.cc:2657
BOOLEAN nlGreaterZero(number za, const coeffs r)
Definition longrat.cc:1303
number nlGcd(number a, number b, const coeffs r)
Definition longrat.cc:1340
void nlNormalize(number &x, const coeffs r)
Definition longrat.cc:1481

◆ p_IsConstant()

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

Definition at line 1979 of file p_polys.h.

1980{
1981 if (p == NULL) return TRUE;
1982 return (pNext(p)==NULL) && p_LmIsConstant(p, r);
1983}

◆ 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 1973 of file p_polys.h.

1974{
1975 if (p == NULL) return TRUE;
1976 return (pNext(p)==NULL) && p_LmIsConstantComp(p, r);
1977}

◆ p_IsConstantPoly()

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

Definition at line 1993 of file p_polys.h.

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

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

3324{
3325 poly qp=p;
3326 int o;
3327
3328 if ((p == NULL) || (pNext(p) == NULL)) return TRUE;
3329 pFDegProc d;
3330 if (r->pLexOrder && (r->order[0]==ringorder_lp))
3331 d=p_Totaldegree;
3332 else
3333 d=r->pFDeg;
3334 o = d(p,r);
3335 do
3336 {
3337 if (d(qp,r) != o) return FALSE;
3338 pIter(qp);
3339 }
3340 while (qp != NULL);
3341 return TRUE;
3342}

◆ p_IsHomogeneousDP()

BOOLEAN p_IsHomogeneousDP ( poly  p,
const ring  r 
)

Definition at line 3347 of file p_polys.cc.

3348{
3349 poly qp=p;
3350 int o;
3351
3352 if ((p == NULL) || (pNext(p) == NULL)) return TRUE;
3353 o = p_Totaldegree(p,r);
3354 do
3355 {
3356 if (p_Totaldegree(qp,r) != o) return FALSE;
3357 pIter(qp);
3358 }
3359 while (qp != NULL);
3360 return TRUE;
3361}

◆ p_IsHomogeneousW() [1/2]

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

Definition at line 3383 of file p_polys.cc.

3384{
3385 poly qp=p;
3386 long o;
3387
3388 if ((p == NULL) || (pNext(p) == NULL)) return TRUE;
3389 pIter(qp);
3390 o = totaldegreeWecart_IV(p,r,w->ivGetVec())+(*module_w)[p_GetComp(p,r)];
3391 do
3392 {
3393 long oo=totaldegreeWecart_IV(qp,r,w->ivGetVec())+(*module_w)[p_GetComp(qp,r)];
3394 if (oo != o) return FALSE;
3395 pIter(qp);
3396 }
3397 while (qp != NULL);
3398 return TRUE;
3399}

◆ p_IsHomogeneousW() [2/2]

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

Definition at line 3366 of file p_polys.cc.

3367{
3368 poly qp=p;
3369 long o;
3370
3371 if ((p == NULL) || (pNext(p) == NULL)) return TRUE;
3372 pIter(qp);
3373 o = totaldegreeWecart_IV(p,r,w->ivGetVec());
3374 do
3375 {
3376 if (totaldegreeWecart_IV(qp,r,w->ivGetVec()) != o) return FALSE;
3377 pIter(qp);
3378 }
3379 while (qp != NULL);
3380 return TRUE;
3381}

◆ p_IsOne()

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

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

Definition at line 1986 of file p_polys.h.

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

◆ 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 2006 of file p_polys.h.

2007{
2008 if (p == NULL) return FALSE;
2009 if (rField_is_Ring(r))
2010 return (p_LmIsConstant(p, r) && n_IsUnit(pGetCoeff(p),r->cf));
2011 return p_LmIsConstant(p, r);
2012}

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

4456{
4457 while((p!=NULL) && (p_Totaldegree(p,R)>m)) p_LmDelete(&p,R);
4458 if (p==NULL) return NULL;
4459 poly r=p;
4460 while (pNext(p)!=NULL)
4461 {
4462 if (p_Totaldegree(pNext(p),R)>m)
4463 {
4464 p_LmDelete(&pNext(p),R);
4465 }
4466 else
4467 pIter(p);
4468 }
4469 return r;
4470}

◆ p_JetW()

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

Definition at line 4499 of file p_polys.cc.

4500{
4501 while((p!=NULL) && (totaldegreeWecart_IV(p,R,w)>m)) p_LmDelete(&p,R);
4502 if (p==NULL) return NULL;
4503 poly r=p;
4504 while (pNext(p)!=NULL)
4505 {
4507 {
4508 p_LmDelete(&pNext(p),R);
4509 }
4510 else
4511 pIter(p);
4512 }
4513 return r;
4514}

◆ p_Last()

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

Definition at line 4690 of file p_polys.cc.

4691{
4692 if (p == NULL)
4693 {
4694 l = 0;
4695 return NULL;
4696 }
4697 l = 1;
4698 poly a = p;
4699 if (! rIsSyzIndexRing(r))
4700 {
4701 poly next = pNext(a);
4702 while (next!=NULL)
4703 {
4704 a = next;
4705 next = pNext(a);
4706 l++;
4707 }
4708 }
4709 else
4710 {
4711 long unsigned curr_limit = rGetCurrSyzLimit(r);
4712 poly pp = a;
4713 while ((a=pNext(a))!=NULL)
4714 {
4715 if (__p_GetComp(a,r)<=curr_limit/*syzComp*/)
4716 l++;
4717 else break;
4718 pp = a;
4719 }
4720 a=pp;
4721 }
4722 return a;
4723}
ListNode * next
Definition janet.h:31
static int rGetCurrSyzLimit(const ring r)
Definition ring.h:728
static BOOLEAN rIsSyzIndexRing(const ring r)
Definition ring.h:725

◆ 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

◆ 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 382 of file p_polys.h.

382{ 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 {
83 // be more sloppy for qrings
84 (r->qideal != NULL &&
86 omSizeWOfAddr(p)==omSizeWOfBin(r->PolyBin)) ||
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 1595 of file p_polys.h.

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

◆ p_LmDelete() [1/2]

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

Definition at line 744 of file p_polys.h.

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

◆ p_LmDelete() [2/2]

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

Definition at line 724 of file p_polys.h.

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

◆ p_LmDelete0()

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

Definition at line 734 of file p_polys.h.

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

◆ p_LmDeleteAndNext()

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

Definition at line 756 of file p_polys.h.

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

◆ 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 1906 of file p_polys.h.

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

◆ p_LmDivisibleByNoComp() [1/2]

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

Definition at line 1899 of file p_polys.h.

1900{
1903 return _p_LmDivisibleByNoComp(a, ra, b, rb);
1904}

◆ p_LmDivisibleByNoComp() [2/2]

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

Definition at line 1892 of file p_polys.h.

1893{
1894 p_LmCheckPolyRing1(a, r);
1896 return _p_LmDivisibleByNoComp(a, b, r);
1897}

◆ p_LmDivisibleByPart()

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

Definition at line 1877 of file p_polys.h.

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

◆ p_LmExpVectorAddIsOk()

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

Definition at line 2014 of file p_polys.h.

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

◆ p_LmFree() [1/2]

static void p_LmFree ( poly *  p,
ring   
)
inlinestatic

Definition at line 697 of file p_polys.h.

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

◆ p_LmFree() [2/2]

static void p_LmFree ( poly  p,
ring   
)
inlinestatic

Definition at line 684 of file p_polys.h.

686{
688 #ifdef XALLOC_BIN
689 omFreeBin(p,r->PolyBin);
690 #else
692 #endif
693}

◆ p_LmFreeAndNext()

static poly p_LmFreeAndNext ( poly  p,
ring   
)
inlinestatic

Definition at line 712 of file p_polys.h.

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

◆ p_LmInit() [1/3]

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

Definition at line 1350 of file p_polys.h.

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

◆ p_LmInit() [2/3]

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

Definition at line 1378 of file p_polys.h.

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

◆ 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 1361 of file p_polys.h.

1362{
1365 pAssume1(d_r->N <= s_r->N);
1366 poly d_p = p_Init(d_r, d_bin);
1367 for (unsigned i=d_r->N; i!=0; i--)
1368 {
1369 p_SetExp(d_p, i, p_GetExp(s_p, i,s_r), d_r);
1370 }
1371 if (rRing_has_Comp(d_r))
1372 {
1374 }
1375 p_Setm(d_p, d_r);
1376 return d_p;
1377}

◆ p_LmIsConstant()

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

Definition at line 1024 of file p_polys.h.

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

◆ p_LmIsConstantComp()

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

Definition at line 1007 of file p_polys.h.

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

◆ p_LmShallowCopyDelete()

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

Definition at line 1408 of file p_polys.h.

1409{
1411 pAssume1(omSizeWOfBin(bin) == omSizeWOfBin(r->PolyBin));
1412 poly new_p = p_New(r);
1413 memcpy(new_p->exp, p->exp, r->ExpL_Size*sizeof(long));
1415 pNext(new_p) = pNext(p);
1417 return new_p;
1418}

◆ 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 1925 of file p_polys.h.

1927{
1928 p_LmCheckPolyRing1(a, r);
1930#ifndef PDIV_DEBUG
1931 _pPolyAssume2(p_GetShortExpVector(a, r) == sev_a, a, r);
1933
1934 if (sev_a & not_sev_b)
1935 {
1937 return FALSE;
1938 }
1939 return p_LmDivisibleBy(a, b, r);
1940#else
1941 return pDebugLmShortDivisibleBy(a, sev_a, r, b, not_sev_b, r);
1942#endif
1943}

◆ 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 1945 of file p_polys.h.

1947{
1948 p_LmCheckPolyRing1(a, r);
1950#ifndef PDIV_DEBUG
1951 _pPolyAssume2(p_GetShortExpVector(a, r) == sev_a, a, r);
1953
1954 if (sev_a & not_sev_b)
1955 {
1957 return FALSE;
1958 }
1959 return p_LmDivisibleByNoComp(a, b, r);
1960#else
1962#endif
1963}

◆ p_LowVar()

int p_LowVar ( poly  p,
const ring  r 
)

the minimal index of used variables - 1

Definition at line 4749 of file p_polys.cc.

4750{
4751 int k,l,lex;
4752
4753 if (p == NULL) return -1;
4754
4755 k = 32000;/*a very large dummy value*/
4756 while (p != NULL)
4757 {
4758 l = 1;
4759 lex = p_GetExp(p,l,r);
4760 while ((l < (rVar(r))) && (lex == 0))
4761 {
4762 l++;
4763 lex = p_GetExp(p,l,r);
4764 }
4765 l--;
4766 if (l < k) k = l;
4767 pIter(p);
4768 }
4769 return k;
4770}

◆ p_LtCmp()

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

Definition at line 1636 of file p_polys.h.

1637{
1638 int res = p_LmCmp(p,q,r);
1639 if(res == 0)
1640 {
1641 if(p_GetCoeff(p,r) == NULL || p_GetCoeff(q,r) == NULL)
1642 return res;
1643 number pc = n_Copy(p_GetCoeff(p,r),r->cf);
1644 number qc = n_Copy(p_GetCoeff(q,r),r->cf);
1645 if(!n_GreaterZero(pc,r->cf))
1646 pc = n_InpNeg(pc,r->cf);
1647 if(!n_GreaterZero(qc,r->cf))
1648 qc = n_InpNeg(qc,r->cf);
1649 if(n_Greater(pc,qc,r->cf))
1650 res = 1;
1651 else if(n_Greater(qc,pc,r->cf))
1652 res = -1;
1653 else if(n_Equal(pc,qc,r->cf))
1654 res = 0;
1655 n_Delete(&pc,r->cf);
1656 n_Delete(&qc,r->cf);
1657 }
1658 return res;
1659}

◆ p_LtCmpNoAbs()

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

Definition at line 1662 of file p_polys.h.

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

◆ p_LtCmpOrdSgnDiffM()

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

Definition at line 1684 of file p_polys.h.

1685{
1686 return(p_LtCmp(p,q,r) == r->OrdSgn);
1687}

◆ p_LtCmpOrdSgnDiffP()

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

Definition at line 1693 of file p_polys.h.

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

◆ p_LtCmpOrdSgnEqM()

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

Definition at line 1709 of file p_polys.h.

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

◆ p_LtCmpOrdSgnEqP()

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

Definition at line 1718 of file p_polys.h.

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

◆ p_MaxComp() [1/2]

static long p_MaxComp ( poly  p,
ring  lmRing 
)
inlinestatic

Definition at line 312 of file p_polys.h.

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

◆ p_MaxComp() [2/2]

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

Definition at line 293 of file p_polys.h.

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

◆ p_MaxExpPerVar()

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

max exponent of variable x_i in p

Definition at line 5061 of file p_polys.cc.

5062{
5063 int m=0;
5064 while(p!=NULL)
5065 {
5066 int mm=p_GetExp(p,i,r);
5067 if (mm>m) m=mm;
5068 pIter(p);
5069 }
5070 return m;
5071}

◆ 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 1307 of file p_polys.h.

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

◆ p_MemSub_NegWeightAdjust()

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

Definition at line 1317 of file p_polys.h.

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

◆ p_Merge_q()

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

Definition at line 1227 of file p_polys.h.

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

◆ p_MinComp() [1/2]

static long p_MinComp ( poly  p,
ring  lmRing 
)
inlinestatic

Definition at line 333 of file p_polys.h.

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

◆ p_MinComp() [2/2]

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

Definition at line 314 of file p_polys.h.

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

◆ p_MinDeg()

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

Definition at line 4517 of file p_polys.cc.

4518{
4519 if(p==NULL)
4520 return -1;
4521 int d=-1;
4522 while(p!=NULL)
4523 {
4524 int d0=0;
4525 for(int j=0;j<rVar(R);j++)
4526 if(w==NULL||j>=w->length())
4527 d0+=p_GetExp(p,j+1,R);
4528 else
4529 d0+=(*w)[j]*p_GetExp(p,j+1,R);
4530 if(d0<d||d==-1)
4531 d=d0;
4532 pIter(p);
4533 }
4534 return d;
4535}

◆ 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 1082 of file p_polys.h.

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

◆ 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 1071 of file p_polys.h.

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

◆ p_mm_Mult()

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

Definition at line 1062 of file p_polys.h.

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

◆ p_Mult_mm()

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

Definition at line 1052 of file p_polys.h.

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

◆ p_Mult_nn() [1/2]

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

Definition at line 974 of file p_polys.h.

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

◆ p_Mult_nn() [2/2]

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

Definition at line 959 of file p_polys.h.

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

◆ p_Mult_q()

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

Definition at line 1119 of file p_polys.h.

1120{
1121 assume( (p != q) || (p == NULL && q == NULL) );
1122
1123 if (UNLIKELY(p == NULL))
1124 {
1125 p_Delete(&q, r);
1126 return NULL;
1127 }
1128 if (UNLIKELY(q == NULL))
1129 {
1130 p_Delete(&p, r);
1131 return NULL;
1132 }
1133
1134 if (pNext(p) == NULL)
1135 {
1136 q = r->p_Procs->p_mm_Mult(q, p, r);
1137 p_LmDelete(&p, r);
1138 return q;
1139 }
1140
1141 if (pNext(q) == NULL)
1142 {
1143 p = r->p_Procs->p_Mult_mm(p, q, r);
1144 p_LmDelete(&q, r);
1145 return p;
1146 }
1147#if defined(HAVE_PLURAL) || defined(HAVE_SHIFTBBA)
1148 if (UNLIKELY(rIsNCRing(r)))
1149 return _nc_p_Mult_q(p, q, r);
1150 else
1151#endif
1152#ifdef HAVE_RINGS
1153 if (UNLIKELY(!nCoeff_is_Domain(r->cf)))
1154 return _p_Mult_q_Normal_ZeroDiv(p, q, 0, r);
1155 else
1156#endif
1157 return _p_Mult_q(p, q, 0, r);
1158}
#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 622 of file p_polys.h.

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

◆ p_Neg()

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

Definition at line 1108 of file p_polys.h.

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

◆ p_New() [1/2]

static poly p_New ( const ring  ,
omBin  bin 
)
inlinestatic

Definition at line 665 of file p_polys.h.

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

◆ p_New() [2/2]

static poly p_New ( ring  r)
inlinestatic

Definition at line 676 of file p_polys.h.

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

◆ p_Norm()

void p_Norm ( poly  p1,
const ring  r 
)

Definition at line 3759 of file p_polys.cc.

3760{
3761 if (UNLIKELY(p1==NULL)) return;
3762 if (rField_is_Ring(r))
3763 {
3764 if(!n_GreaterZero(pGetCoeff(p1),r->cf)) p1 = p_Neg(p1,r);
3765 if (!n_IsUnit(pGetCoeff(p1), r->cf)) return;
3766 // Werror("p_Norm not possible in the case of coefficient rings.");
3767 }
3768 else //(p1!=NULL)
3769 {
3770 if (!n_IsOne(pGetCoeff(p1),r->cf))
3771 {
3772 if (UNLIKELY(pNext(p1)==NULL))
3773 {
3774 p_SetCoeff(p1,n_Init(1,r->cf),r);
3775 return;
3776 }
3777 number k = pGetCoeff(p1);
3778 pSetCoeff0(p1,n_Init(1,r->cf));
3779 poly h = pNext(p1);
3780 if (LIKELY(rField_is_Zp(r)))
3781 {
3782 if (r->cf->ch>32003)
3783 {
3784 number inv=n_Invers(k,r->cf);
3785 while (h!=NULL)
3786 {
3787 number c=n_Mult(pGetCoeff(h),inv,r->cf);
3788 // no need to normalize
3789 p_SetCoeff(h,c,r);
3790 pIter(h);
3791 }
3792 // no need for n_Delete for Zp: n_Delete(&inv,r->cf);
3793 }
3794 else
3795 {
3796 while (h!=NULL)
3797 {
3798 number c=n_Div(pGetCoeff(h),k,r->cf);
3799 // no need to normalize
3800 p_SetCoeff(h,c,r);
3801 pIter(h);
3802 }
3803 }
3804 }
3805 else if(getCoeffType(r->cf)==n_algExt)
3806 {
3807 n_Normalize(k,r->cf);
3808 number inv=n_Invers(k,r->cf);
3809 while (h!=NULL)
3810 {
3811 number c=n_Mult(pGetCoeff(h),inv,r->cf);
3812 // no need to normalize
3813 // normalize already in nMult: Zp_a, Q_a
3814 p_SetCoeff(h,c,r);
3815 pIter(h);
3816 }
3817 n_Delete(&inv,r->cf);
3818 n_Delete(&k,r->cf);
3819 }
3820 else
3821 {
3822 n_Normalize(k,r->cf);
3823 while (h!=NULL)
3824 {
3825 number c=n_Div(pGetCoeff(h),k,r->cf);
3826 // no need to normalize: Z/p, R
3827 // remains: Q
3828 if (rField_is_Q(r)) n_Normalize(c,r->cf);
3829 p_SetCoeff(h,c,r);
3830 pIter(h);
3831 }
3832 n_Delete(&k,r->cf);
3833 }
3834 }
3835 else
3836 {
3837 //if (r->cf->cfNormalize != nDummy2) //TODO: OPTIMIZE
3838 if (rField_is_Q(r))
3839 {
3840 poly h = pNext(p1);
3841 while (h!=NULL)
3842 {
3843 n_Normalize(pGetCoeff(h),r->cf);
3844 pIter(h);
3845 }
3846 }
3847 }
3848 }
3849}
#define LIKELY(X)
Definition auxiliary.h:404

◆ p_Normalize()

void p_Normalize ( poly  p,
const ring  r 
)

Definition at line 3854 of file p_polys.cc.

3855{
3856 const coeffs cf=r->cf;
3857 /* Z/p, GF(p,n), R, long R/C, Nemo rings */
3858 if (cf->cfNormalize==ndNormalize)
3859 return;
3860 while (p!=NULL)
3861 {
3862 // no test before n_Normalize: n_Normalize should fix problems
3864 pIter(p);
3865 }
3866}
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 4171 of file p_polys.cc.

4173{
4174#if 0
4175 p_Test(p, oldRing);
4176 PrintS("p_PermPoly::p: "); p_Write(p, oldRing, oldRing);
4177#endif
4178 const int OldpVariables = rVar(oldRing);
4179 poly result = NULL;
4180 poly result_last = NULL;
4181 poly aq = NULL; /* the map coefficient */
4182 poly qq; /* the mapped monomial */
4183 assume(dst != NULL);
4184 assume(dst->cf != NULL);
4185 #ifdef HAVE_PLURAL
4186 poly tmp_mm=p_One(dst);
4187 #endif
4188 while (p != NULL)
4189 {
4190 // map the coefficient
4191 if ( ((OldPar == 0) || (par_perm == NULL) || rField_is_GF(oldRing) || (nMap==ndCopyMap))
4192 && (nMap != NULL) )
4193 {
4194 qq = p_Init(dst);
4195 assume( nMap != NULL );
4196 number n = nMap(p_GetCoeff(p, oldRing), oldRing->cf, dst->cf);
4197 n_Test (n,dst->cf);
4198 if ( nCoeff_is_algExt(dst->cf) )
4199 n_Normalize(n, dst->cf);
4200 p_GetCoeff(qq, dst) = n;// Note: n can be a ZERO!!!
4201 }
4202 else
4203 {
4204 qq = p_One(dst);
4205// aq = naPermNumber(p_GetCoeff(p, oldRing), par_perm, OldPar, oldRing); // no dst???
4206// poly n_PermNumber(const number z, const int *par_perm, const int P, const ring src, const ring dst)
4208 p_Test(aq, dst);
4209 if ( nCoeff_is_algExt(dst->cf) )
4211 if (aq == NULL)
4212 p_SetCoeff(qq, n_Init(0, dst->cf),dst); // Very dirty trick!!!
4213 p_Test(aq, dst);
4214 }
4215 if (rRing_has_Comp(dst))
4217 if ( n_IsZero(pGetCoeff(qq), dst->cf) )
4218 {
4219 p_LmDelete(&qq,dst);
4220 qq = NULL;
4221 }
4222 else
4223 {
4224 // map pars:
4225 int mapped_to_par = 0;
4226 for(int i = 1; i <= OldpVariables; i++)
4227 {
4228 int e = p_GetExp(p, i, oldRing);
4229 if (e != 0)
4230 {
4231 if (perm==NULL)
4232 p_SetExp(qq, i, e, dst);
4233 else if (perm[i]>0)
4234 {
4235 #ifdef HAVE_PLURAL
4236 if(use_mult)
4237 {
4238 p_SetExp(tmp_mm,perm[i],e,dst);
4239 p_Setm(tmp_mm,dst);
4241 p_SetExp(tmp_mm,perm[i],0,dst);
4242
4243 }
4244 else
4245 #endif
4246 p_AddExp(qq,perm[i], e/*p_GetExp( p,i,oldRing)*/, dst);
4247 }
4248 else if (perm[i]<0)
4249 {
4250 number c = p_GetCoeff(qq, dst);
4251 if (rField_is_GF(dst))
4252 {
4253 assume( dst->cf->extRing == NULL );
4254 number ee = n_Param(1, dst);
4255 number eee;
4256 n_Power(ee, e, &eee, dst->cf); //nfDelete(ee,dst);
4257 ee = n_Mult(c, eee, dst->cf);
4258 //nfDelete(c,dst);nfDelete(eee,dst);
4259 pSetCoeff0(qq,ee);
4260 }
4261 else if (nCoeff_is_Extension(dst->cf))
4262 {
4263 const int par = -perm[i];
4264 assume( par > 0 );
4265// WarnS("longalg missing 3");
4266#if 1
4267 const coeffs C = dst->cf;
4268 assume( C != NULL );
4269 const ring R = C->extRing;
4270 assume( R != NULL );
4271 assume( par <= rVar(R) );
4272 poly pcn; // = (number)c
4273 assume( !n_IsZero(c, C) );
4274 if( nCoeff_is_algExt(C) )
4275 pcn = (poly) c;
4276 else // nCoeff_is_transExt(C)
4277 pcn = NUM((fraction)c);
4278 if (pNext(pcn) == NULL) // c->z
4279 p_AddExp(pcn, -perm[i], e, R);
4280 else /* more difficult: we have really to multiply: */
4281 {
4282 poly mmc = p_ISet(1, R);
4283 p_SetExp(mmc, -perm[i], e, R);
4284 p_Setm(mmc, R);
4285 number nnc;
4286 // convert back to a number: number nnc = mmc;
4287 if( nCoeff_is_algExt(C) )
4288 nnc = (number) mmc;
4289 else // nCoeff_is_transExt(C)
4290 nnc = ntInit(mmc, C);
4291 p_GetCoeff(qq, dst) = n_Mult((number)c, nnc, C);
4292 n_Delete((number *)&c, C);
4293 n_Delete((number *)&nnc, C);
4294 }
4295 mapped_to_par=1;
4296#endif
4297 }
4298 }
4299 else
4300 {
4301 /* this variable maps to 0 !*/
4302 p_LmDelete(&qq, dst);
4303 break;
4304 }
4305 }
4306 }
4307 if ( mapped_to_par && (qq!= NULL) && nCoeff_is_algExt(dst->cf) )
4308 {
4309 number n = p_GetCoeff(qq, dst);
4310 n_Normalize(n, dst->cf);
4311 p_GetCoeff(qq, dst) = n;
4312 }
4313 }
4314 pIter(p);
4315
4316#if 0
4317 p_Test(aq,dst);
4318 PrintS("aq: "); p_Write(aq, dst, dst);
4319#endif
4320
4321
4322#if 1
4323 if (qq!=NULL)
4324 {
4325 p_Setm(qq,dst);
4326
4327 p_Test(aq,dst);
4328 p_Test(qq,dst);
4329
4330#if 0
4331 PrintS("qq: "); p_Write(qq, dst, dst);
4332#endif
4333
4334 if (aq!=NULL)
4335 qq=p_Mult_q(aq,qq,dst);
4336 aq = qq;
4337 while (pNext(aq) != NULL) pIter(aq);
4338 if (result_last==NULL)
4339 {
4340 result=qq;
4341 }
4342 else
4343 {
4345 }
4347 aq = NULL;
4348 }
4349 else if (aq!=NULL)
4350 {
4351 p_Delete(&aq,dst);
4352 }
4353 }
4355#else
4356 // if (qq!=NULL)
4357 // {
4358 // pSetm(qq);
4359 // pTest(qq);
4360 // pTest(aq);
4361 // if (aq!=NULL) qq=pMult(aq,qq);
4362 // aq = qq;
4363 // while (pNext(aq) != NULL) pIter(aq);
4364 // pNext(aq) = result;
4365 // aq = NULL;
4366 // result = qq;
4367 // }
4368 // else if (aq!=NULL)
4369 // {
4370 // pDelete(&aq);
4371 // }
4372 //}
4373 //p = result;
4374 //result = NULL;
4375 //while (p != NULL)
4376 //{
4377 // qq = p;
4378 // pIter(p);
4379 // qq->next = NULL;
4380 // result = pAdd(result, qq);
4381 //}
4382#endif
4383 p_Test(result,dst);
4384#if 0
4385 p_Test(result,dst);
4386 PrintS("result: "); p_Write(result,dst,dst);
4387#endif
4388 #ifdef HAVE_PLURAL
4390 #endif
4391 return result;
4392}
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:4068
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:1052
static poly p_SortAdd(poly p, const ring r, BOOLEAN revert=FALSE)
Definition p_polys.h:1234
static BOOLEAN rField_is_GF(const ring r)
Definition ring.h:526
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 1220 of file p_polys.h.

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

◆ 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 1198 of file p_polys.h.

1200{
1201#ifdef HAVE_PLURAL
1202 if (rIsPluralRing(r))
1203 return nc_p_Plus_mm_Mult_qq(p, m, q, lp, lq, r);
1204#endif
1205
1206// this should be implemented more efficiently
1207 poly res;
1208 int shorter;
1210 number n_neg = n_Copy(n_old, r->cf);
1211 n_neg = n_InpNeg(n_neg, r->cf);
1212 pSetCoeff0(m, n_neg);
1213 res = r->p_Procs->p_Minus_mm_Mult_qq(p, m, q, shorter, NULL, r);
1214 lp = (lp + lq) - shorter;
1215 pSetCoeff0(m, n_old);
1216 n_Delete(&n_neg, r->cf);
1217 return res;
1218}
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:405

◆ 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))
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;
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:694
static BOOLEAN rIsLPRing(const ring r)
Definition ring.h:416

◆ 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);
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:592
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 4567 of file p_polys.cc.

4568{
4569 int *ww=iv2array(w,R);
4570 if(p!=NULL)
4571 {
4572 if(u==NULL)
4573 p=p_JetW(p,n,ww,R);
4574 else
4575 p=p_JetW(p_Mult_q(p,p_Invers(n-p_MinDeg(p,w,R),u,w,R),R),n,ww,R);
4576 }
4577 omFreeSize((ADDRESS)ww,(rVar(R)+1)*sizeof(int));
4578 return p;
4579}
static poly p_Invers(int n, poly u, intvec *w, const ring R)
Definition p_polys.cc:4538
int p_MinDeg(poly p, intvec *w, const ring R)
Definition p_polys.cc:4517
poly p_JetW(poly p, int m, int *w, const ring R)
Definition p_polys.cc:4499
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 413 of file p_polys.h.

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

◆ p_SetComp()

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

Definition at line 248 of file p_polys.h.

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

◆ p_SetCompP() [1/2]

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

Definition at line 282 of file p_polys.h.

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

◆ p_SetCompP() [2/2]

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

Definition at line 255 of file p_polys.h.

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

◆ 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 583 of file p_polys.h.

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

◆ p_SetExp() [2/3]

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

Definition at line 563 of file p_polys.h.

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

◆ 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 489 of file p_polys.h.

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

◆ p_SetExpV()

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

Definition at line 1559 of file p_polys.h.

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

◆ p_SetExpVL()

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

Definition at line 1568 of file p_polys.h.

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

◆ p_SetExpVLV()

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

Definition at line 1579 of file p_polys.h.

1580{
1582 for (unsigned j = r->N; j!=0; j--)
1583 p_SetExp(p, j, ev[j-1], r);
1584 p_SetComp(p, comp,r);
1585
1586 p_Setm(p, r);
1587}

◆ p_Setm()

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

Definition at line 234 of file p_polys.h.

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

◆ p_SetModDeg()

void p_SetModDeg ( intvec w,
ring  r 
)

Definition at line 3713 of file p_polys.cc.

3714{
3715 if (w!=NULL)
3716 {
3717 r->pModW = w;
3718 pOldFDeg = r->pFDeg;
3719 pOldLDeg = r->pLDeg;
3720 pOldLexOrder = r->pLexOrder;
3722 r->pLexOrder = TRUE;
3723 }
3724 else
3725 {
3726 r->pModW = NULL;
3728 r->pLexOrder = pOldLexOrder;
3729 }
3730}
STATIC_VAR pLDegProc pOldLDeg
Definition p_polys.cc:3701
void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
Definition p_polys.cc:3689
STATIC_VAR BOOLEAN pOldLexOrder
Definition p_polys.cc:3702
STATIC_VAR pFDegProc pOldFDeg
Definition p_polys.cc:3700
void pSetDegProcs(ring r, pFDegProc new_FDeg, pLDegProc new_lDeg)
Definition p_polys.cc:3677
static long pModDeg(poly p, ring r)
Definition p_polys.cc:3704

◆ p_ShallowCopyDelete()

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

Definition at line 929 of file p_polys.h.

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

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

4776{
4777 poly qp1 = *p,qp2 = *p;/*working pointers*/
4778 int j = p_MaxComp(*p,r),k = p_MinComp(*p,r);
4779
4780 if (j+i < 0) return ;
4781 BOOLEAN toPoly= ((j == -i) && (j == k));
4782 while (qp1 != NULL)
4783 {
4784 if (toPoly || (__p_GetComp(qp1,r)+i > 0))
4785 {
4786 p_AddComp(qp1,i,r);
4787 p_SetmComp(qp1,r);
4788 qp2 = qp1;
4789 pIter(qp1);
4790 }
4791 else
4792 {
4793 if (qp2 == *p)
4794 {
4795 pIter(*p);
4796 p_LmDelete(&qp2,r);
4797 qp2 = *p;
4798 qp1 = *p;
4799 }
4800 else
4801 {
4802 qp2->next = qp1->next;
4803 if (qp1!=NULL) p_LmDelete(&qp1,r);
4804 qp1 = qp2->next;
4805 }
4806 }
4807 }
4808}
return
static unsigned long p_AddComp(poly p, unsigned long v, ring r)
Definition p_polys.h:448

◆ 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 1234 of file p_polys.h.

1235{
1236 if (revert) p = pReverse(p);
1237 return sBucketSortAdd(p, r);
1238}
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 1244 of file p_polys.h.

1245{
1246 if (revert) p = pReverse(p);
1247 return sBucketSortMerge(p, r);
1248}
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 1255 of file p_polys.h.

1256{
1257 return p_String(p, p_ring, p_ring);
1258}
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 }
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 }
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 }
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 1259 of file p_polys.h.

1260{
1262}
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.
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:586

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

◆ 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 454 of file p_polys.h.

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

◆ p_SubExp()

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

Definition at line 614 of file p_polys.h.

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

◆ p_Subst()

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

Definition at line 3999 of file p_polys.cc.

4000{
4001#ifdef HAVE_SHIFTBBA
4002 // also don't even use p_Subst0 for Letterplace
4003 if (rIsLPRing(r))
4004 {
4005 poly subst = p_LPSubst(p, n, e, r);
4006 p_Delete(&p, r);
4007 return subst;
4008 }
4009#endif
4010
4011 if (e == NULL) return p_Subst0(p, n,r);
4012
4013 if (p_IsConstant(e,r))
4014 {
4015 if (n_IsOne(pGetCoeff(e),r->cf)) return p_Subst1(p,n,r);
4016 else return p_Subst2(p, n, pGetCoeff(e),r);
4017 }
4018
4019#ifdef HAVE_PLURAL
4020 if (rIsPluralRing(r))
4021 {
4022 return nc_pSubst(p,n,e,r);
4023 }
4024#endif
4025
4026 int exponent,i;
4027 poly h, res, m;
4028 int *me,*ee;
4029 number nu,nu1;
4030
4031 me=(int *)omAlloc((rVar(r)+1)*sizeof(int));
4032 ee=(int *)omAlloc((rVar(r)+1)*sizeof(int));
4033 if (e!=NULL) p_GetExpV(e,ee,r);
4034 res=NULL;
4035 h=p;
4036 while (h!=NULL)
4037 {
4038 if ((e!=NULL) || (p_GetExp(h,n,r)==0))
4039 {
4040 m=p_Head(h,r);
4041 p_GetExpV(m,me,r);
4042 exponent=me[n];
4043 me[n]=0;
4044 for(i=rVar(r);i>0;i--)
4045 me[i]+=exponent*ee[i];
4046 p_SetExpV(m,me,r);
4047 if (e!=NULL)
4048 {
4049 n_Power(pGetCoeff(e),exponent,&nu,r->cf);
4050 nu1=n_Mult(pGetCoeff(m),nu,r->cf);
4051 n_Delete(&nu,r->cf);
4052 p_SetCoeff(m,nu1,r);
4053 }
4054 res=p_Add_q(res,m,r);
4055 }
4056 p_LmDelete(&h,r);
4057 }
4058 omFreeSize((ADDRESS)me,(rVar(r)+1)*sizeof(int));
4059 omFreeSize((ADDRESS)ee,(rVar(r)+1)*sizeof(int));
4060 return res;
4061}
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:3974
static poly p_Subst1(poly p, int n, const ring r)
Definition p_polys.cc:3906
static poly p_Subst2(poly p, int n, number e, const ring r)
Definition p_polys.cc:3933
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 3458 of file p_polys.cc.

3459{
3460 poly q = *p,qq=NULL,result = NULL;
3461 unsigned long kk=(unsigned long)k;
3462
3463 if (q==NULL) return NULL;
3465 if (__p_GetComp(q,r)==kk)
3466 {
3467 result = q;
3469 {
3470 do
3471 {
3472 p_SetComp(q,0,r);
3473 p_SetmComp(q,r);
3474 qq = q;
3475 pIter(q);
3476 }
3477 while ((q!=NULL) && (__p_GetComp(q,r)==kk));
3478 }
3479 else
3480 {
3481 do
3482 {
3483 p_SetComp(q,0,r);
3484 qq = q;
3485 pIter(q);
3486 }
3487 while ((q!=NULL) && (__p_GetComp(q,r)==kk));
3488 }
3489
3490 *p = q;
3491 pNext(qq) = NULL;
3492 }
3493 if (q==NULL) return result;
3494 if (__p_GetComp(q,r) > kk)
3495 {
3496 p_SubComp(q,1,r);
3497 if (use_setmcomp) p_SetmComp(q,r);
3498 }
3499 poly pNext_q;
3500 while ((pNext_q=pNext(q))!=NULL)
3501 {
3502 unsigned long c=__p_GetComp(pNext_q,r);
3503 if (/*__p_GetComp(pNext_q,r)*/c==kk)
3504 {
3505 if (result==NULL)
3506 {
3507 result = pNext_q;
3508 qq = result;
3509 }
3510 else
3511 {
3512 pNext(qq) = pNext_q;
3513 pIter(qq);
3514 }
3515 pNext(q) = pNext(pNext_q);
3516 pNext(qq) =NULL;
3517 p_SetComp(qq,0,r);
3518 if (use_setmcomp) p_SetmComp(qq,r);
3519 }
3520 else
3521 {
3522 /*pIter(q);*/ q=pNext_q;
3523 if (/*__p_GetComp(q,r)*/c > kk)
3524 {
3525 p_SubComp(q,1,r);
3526 if (use_setmcomp) p_SetmComp(q,r);
3527 }
3528 }
3529 }
3530 return result;
3531}

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

3536{
3537 spolyrec pp, qq;
3538 poly p, q, p_prev;
3539 int l = 0;
3540
3541#ifndef SING_NDEBUG
3542 int lp = pLength(*r_p);
3543#endif
3544
3545 pNext(&pp) = *r_p;
3546 p = *r_p;
3547 p_prev = &pp;
3548 q = &qq;
3549
3550 while(p != NULL)
3551 {
3552 while (__p_GetComp(p,r) == comp)
3553 {
3554 pNext(q) = p;
3555 pIter(q);
3556 p_SetComp(p, 0,r);
3557 p_SetmComp(p,r);
3558 pIter(p);
3559 l++;
3560 if (p == NULL)
3561 {
3562 pNext(p_prev) = NULL;
3563 goto Finish;
3564 }
3565 }
3566 pNext(p_prev) = p;
3567 p_prev = p;
3568 pIter(p);
3569 }
3570
3571 Finish:
3572 pNext(q) = NULL;
3573 *r_p = pNext(&pp);
3574 *r_q = pNext(&qq);
3575 *lq = l;
3576#ifndef SING_NDEBUG
3577 assume(pLength(*r_p) + pLength(*r_q) == lp);
3578#endif
3579 p_Test(*r_p,r);
3580 p_Test(*r_q,r);
3581}

◆ p_Totaldegree()

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

Definition at line 1522 of file p_polys.h.

1523{
1525 unsigned long s = p_GetTotalDegree(p->exp[r->VarL_Offset[0]],
1526 r,
1527 r->ExpPerLong);
1528 for (unsigned i=r->VarL_Size-1; i!=0; i--)
1529 {
1530 s += p_GetTotalDegree(p->exp[r->VarL_Offset[i]], r,r->ExpPerLong);
1531 }
1532 return (long)s;
1533}

◆ p_Var()

int p_Var ( poly  mi,
const ring  r 
)

Definition at line 4725 of file p_polys.cc.

4726{
4727 if (m==NULL) return 0;
4728 if (pNext(m)!=NULL) return 0;
4729 int i,e=0;
4730 for (i=rVar(r); i>0; i--)
4731 {
4732 int exp=p_GetExp(m,i,r);
4733 if (exp==1)
4734 {
4735 if (e==0) e=i;
4736 else return 0;
4737 }
4738 else if (exp!=0)
4739 {
4740 return 0;
4741 }
4742 }
4743 return e;
4744}

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

3636{
3637 poly h;
3638 int k;
3639
3640 for(int i=len-1;i>=0;i--) p[i]=NULL;
3641 while (v!=NULL)
3642 {
3643 h=p_Head(v,r);
3644 k=__p_GetComp(h,r);
3645 if (k>len) { Werror("wrong rank:%d, should be %d",len,k); }
3646 else
3647 {
3648 p_SetComp(h,0,r);
3649 p_Setm(h,r);
3650 pNext(h)=p[k-1];p[k-1]=h;
3651 }
3652 pIter(v);
3653 }
3654 for(int i=len-1;i>=0;i--)
3655 {
3656 if (p[i]!=NULL) p[i]=pReverse(p[i]);
3657 }
3658}

◆ p_Vec2Poly()

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

Definition at line 3613 of file p_polys.cc.

3614{
3615 poly h;
3616 poly res=NULL;
3617 long unsigned kk=k;
3618
3619 while (v!=NULL)
3620 {
3621 if (__p_GetComp(v,r)==kk)
3622 {
3623 h=p_Head(v,r);
3624 p_SetComp(h,0,r);
3625 pNext(h)=res;res=h;
3626 }
3627 pIter(v);
3628 }
3629 if (res!=NULL) res=pReverse(res);
3630 return res;
3631}

◆ p_Vec2Polys()

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

Definition at line 3665 of file p_polys.cc.

3666{
3667 *len=p_MaxComp(v,r);
3668 if (*len==0) *len=1;
3669 *p=(poly*)omAlloc((*len)*sizeof(poly));
3670 p_Vec2Array(v,*p,*len,r);
3671}
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:3635

◆ p_VectorHasUnit()

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

Definition at line 3425 of file p_polys.cc.

3426{
3427 poly q=p,qq;
3428 int j=0;
3429 long unsigned i;
3430
3431 *len = 0;
3432 while (q!=NULL)
3433 {
3434 if (p_LmIsConstantComp(q,r))
3435 {
3436 i = __p_GetComp(q,r);
3437 qq = p;
3438 while ((qq != q) && (__p_GetComp(qq,r) != i)) pIter(qq);
3439 if (qq == q)
3440 {
3441 j = 0;
3442 while (qq!=NULL)
3443 {
3444 if (__p_GetComp(qq,r)==i) j++;
3445 pIter(qq);
3446 }
3447 if ((*len == 0) || (j<*len))
3448 {
3449 *len = j;
3450 *k = i;
3451 }
3452 }
3453 }
3454 pIter(q);
3455 }
3456}

◆ p_VectorHasUnitB()

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

Definition at line 3402 of file p_polys.cc.

3403{
3404 poly q=p,qq;
3405 long unsigned i;
3406
3407 while (q!=NULL)
3408 {
3409 if (p_LmIsConstantComp(q,r))
3410 {
3411 i = __p_GetComp(q,r);
3412 qq = p;
3413 while ((qq != q) && (__p_GetComp(qq,r) != i)) pIter(qq);
3414 if (qq == q)
3415 {
3416 *k = i;
3417 return TRUE;
3418 }
3419 }
3420 pIter(q);
3421 }
3422 return FALSE;
3423}

◆ 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 1263 of file p_polys.h.

1264{
1266}

◆ 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 1267 of file p_polys.h.

1268{
1270}
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 1271 of file p_polys.h.

1272{
1273 p_wrp(p, p_ring, p_ring);
1274}
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:99
@ ringorder_a
Definition ring.h:70
@ ringorder_am
Definition ring.h:89
@ ringorder_a64
for int64 weights
Definition ring.h:71
@ ringorder_C
Definition ring.h:73
@ ringorder_S
S?
Definition ring.h:75
@ ringorder_ds
Definition ring.h:85
@ ringorder_Dp
Definition ring.h:80
@ ringorder_unspec
Definition ring.h:95
@ ringorder_L
Definition ring.h:90
@ ringorder_Ds
Definition ring.h:86
@ ringorder_dp
Definition ring.h:78
@ ringorder_c
Definition ring.h:72
@ ringorder_aa
for idElimination, like a, except pFDeg, pWeigths ignore it
Definition ring.h:92
@ ringorder_no
Definition ring.h:69
@ ringorder_Wp
Definition ring.h:82
@ ringorder_ws
Definition ring.h:87
@ ringorder_Ws
Definition ring.h:88
@ ringorder_IS
Induced (Schreyer) ordering.
Definition ring.h:94
@ ringorder_ls
degree, ip
Definition ring.h:84
@ ringorder_s
s?
Definition ring.h:76
@ ringorder_wp
Definition ring.h:81
@ ringorder_M
Definition ring.h:74
#define ringorder_rs
Definition ring.h:100

◆ pEnlargeSet()

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

Definition at line 3736 of file p_polys.cc.

3737{
3738 poly* h;
3739
3740 if (increment==0) return;
3741 if (*p==NULL)
3742 {
3743 h=(poly*)omAlloc0(increment*sizeof(poly));
3744 }
3745 else
3746 {
3747 h=(poly*)omReallocSize((poly*)*p,l*sizeof(poly),(l+increment)*sizeof(poly));
3748 if (increment>0)
3749 {
3750 memset(&(h[l]),0,increment*sizeof(poly));
3751 }
3752 }
3753 *p=h;
3754}
#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 4399 of file p_polys.cc.

4400{
4401 poly r=NULL;
4402 poly t=NULL;
4403
4404 while (p!=NULL)
4405 {
4406 if (p_Totaldegree(p,R)<=m)
4407 {
4408 if (r==NULL)
4409 r=p_Head(p,R);
4410 else
4411 if (t==NULL)
4412 {
4413 pNext(r)=p_Head(p,R);
4414 t=pNext(r);
4415 }
4416 else
4417 {
4418 pNext(t)=p_Head(p,R);
4419 pIter(t);
4420 }
4421 }
4422 pIter(p);
4423 }
4424 return r;
4425}

◆ pp_Jet0()

poly pp_Jet0 ( poly  p,
const ring  R 
)

Definition at line 4427 of file p_polys.cc.

4428{
4429 poly r=NULL;
4430 poly t=NULL;
4431
4432 while (p!=NULL)
4433 {
4434 if (p_LmIsConstantComp(p,R))
4435 {
4436 if (r==NULL)
4437 r=p_Head(p,R);
4438 else
4439 if (t==NULL)
4440 {
4441 pNext(r)=p_Head(p,R);
4442 t=pNext(r);
4443 }
4444 else
4445 {
4446 pNext(t)=p_Head(p,R);
4447 pIter(t);
4448 }
4449 }
4450 pIter(p);
4451 }
4452 return r;
4453}

◆ pp_JetW()

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

Definition at line 4472 of file p_polys.cc.

4473{
4474 poly r=NULL;
4475 poly t=NULL;
4476 while (p!=NULL)
4477 {
4478 if (totaldegreeWecart_IV(p,R,w)<=m)
4479 {
4480 if (r==NULL)
4481 r=p_Head(p,R);
4482 else
4483 if (t==NULL)
4484 {
4485 pNext(r)=p_Head(p,R);
4486 t=pNext(r);
4487 }
4488 else
4489 {
4490 pNext(t)=p_Head(p,R);
4491 pIter(t);
4492 }
4493 }
4494 pIter(p);
4495 }
4496 return r;
4497}

◆ pp_mm_Mult()

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

Definition at line 1042 of file p_polys.h.

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

◆ 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 1091 of file p_polys.h.

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

◆ 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 1099 of file p_polys.h.

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

◆ pp_Mult_mm()

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

Definition at line 1032 of file p_polys.h.

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

◆ pp_Mult_nn()

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

Definition at line 993 of file p_polys.h.

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

◆ pp_Mult_qq()

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

Definition at line 1161 of file p_polys.h.

1162{
1163 if (UNLIKELY(p == NULL || q == NULL)) return NULL;
1164
1165 if (pNext(p) == NULL)
1166 {
1167 return r->p_Procs->pp_mm_Mult(q, p, r);
1168 }
1169
1170 if (pNext(q) == NULL)
1171 {
1172 return r->p_Procs->pp_Mult_mm(p, q, r);
1173 }
1174
1175 poly qq = q;
1176 if (UNLIKELY(p == q))
1177 qq = p_Copy(q, r);
1178
1179 poly res;
1180#if defined(HAVE_PLURAL) || defined(HAVE_SHIFTBBA)
1181 if (UNLIKELY(rIsNCRing(r)))
1182 res = _nc_pp_Mult_qq(p, qq, r);
1183 else
1184#endif
1185#ifdef HAVE_RINGS
1186 if (UNLIKELY(!nCoeff_is_Domain(r->cf)))
1187 res = _p_Mult_q_Normal_ZeroDiv(p, qq, 1, r);
1188 else
1189#endif
1190 res = _p_Mult_q(p, qq, 1, r);
1191
1192 if (UNLIKELY(qq != q))
1193 p_Delete(&qq, r);
1194 return res;
1195}
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 3689 of file p_polys.cc.

3690{
3691 assume(old_FDeg != NULL && old_lDeg != NULL);
3692 r->pFDeg = old_FDeg;
3693 r->pLDeg = old_lDeg;
3694}

◆ pReverse()

static poly pReverse ( poly  p)
inlinestatic

Definition at line 336 of file p_polys.h.

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

◆ pSetDegProcs()

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

Definition at line 3677 of file p_polys.cc.

3678{
3679 assume(new_FDeg != NULL);
3680 r->pFDeg = new_FDeg;
3681
3682 if (new_lDeg == NULL)
3683 new_lDeg = r->pLDegOrig;
3684
3685 r->pLDeg = new_lDeg;
3686}