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_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)
 
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 )   r->p_Procs->p_Mult_nn(p, n, r)

Definition at line 971 of file p_polys.h.

◆ __pp_Mult_nn

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

Definition at line 1002 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 1276 of file p_polys.h.

1276#define _p_LmCmpAction(p, q, r, actionE, actionG, actionS) \
1277 p_MemCmp_LengthGeneral_OrdGeneral(p->exp, q->exp, r->CmpL_Size, r->ordsgn, \
1278 actionE, actionG, actionS)

◆ p_LmCmpAction

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

Definition at line 1719 of file p_polys.h.

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

◆ p_LmEqual

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

Definition at line 1723 of file p_polys.h.

◆ p_LmTest

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

Definition at line 162 of file p_polys.h.

◆ p_SetmComp

#define p_SetmComp   p_Setm

Definition at line 244 of file p_polys.h.

◆ p_Test

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

Definition at line 161 of file p_polys.h.

◆ pDivAssume

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

Definition at line 1282 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 1871 of file p_polys.h.

1872{
1873 if (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r))
1874 return _p_LmDivisibleByNoComp(a, b, r);
1875 return FALSE;
1876}
#define FALSE
Definition auxiliary.h:96
CanonicalForm b
Definition cfModGcd.cc:4111
#define p_GetComp(p, r)
Definition monomials.h:64
static BOOLEAN _p_LmDivisibleByNoComp(poly a, poly b, const ring r)
return: FALSE, if there exists i, such that a->exp[i] > b->exp[i] TRUE, otherwise (1) Consider long v...
Definition p_polys.h:1765

◆ _p_LmDivisibleByNoComp() [1/2]

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

Definition at line 1814 of file p_polys.h.

1815{
1816 int i=r_a->N;
1817 pAssume1(r_a->N == r_b->N);
1818
1819 do
1820 {
1821 if (p_GetExp(a,i,r_a) > p_GetExp(b,i,r_b))
1822 {
1823 return FALSE;
1824 }
1825 i--;
1826 }
1827 while (i);
1828/*#ifdef HAVE_RINGS
1829 return n_DivBy(p_GetCoeff(b, r_b), p_GetCoeff(a, r_a), r_a->cf);
1830#else
1831*/
1832 return TRUE;
1833//#endif
1834}
#define TRUE
Definition auxiliary.h:100
int i
Definition cfEzgcd.cc:132
#define pAssume1(cond)
Definition monomials.h:171
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
Definition p_polys.h:469

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

1766{
1767 int i=r->VarL_Size - 1;
1768 unsigned long divmask = r->divmask;
1769 unsigned long la, lb;
1770
1771 if (r->VarL_LowIndex >= 0)
1772 {
1773 i += r->VarL_LowIndex;
1774 do
1775 {
1776 la = a->exp[i];
1777 lb = b->exp[i];
1778 if ((la > lb) ||
1779 (((la & divmask) ^ (lb & divmask)) != ((lb - la) & divmask)))
1780 {
1782 return FALSE;
1783 }
1784 i--;
1785 }
1786 while (i>=r->VarL_LowIndex);
1787 }
1788 else
1789 {
1790 do
1791 {
1792 la = a->exp[r->VarL_Offset[i]];
1793 lb = b->exp[r->VarL_Offset[i]];
1794 if ((la > lb) ||
1795 (((la & divmask) ^ (lb & divmask)) != ((lb - la) & divmask)))
1796 {
1798 return FALSE;
1799 }
1800 i--;
1801 }
1802 while (i>=0);
1803 }
1804/*#ifdef HAVE_RINGS
1805 pDivAssume(p_DebugLmDivisibleByNoComp(a, b, r) == n_DivBy(p_GetCoeff(b, r), p_GetCoeff(a, r), r->cf));
1806 return (!rField_is_Ring(r)) || n_DivBy(p_GetCoeff(b, r), p_GetCoeff(a, r), r->cf);
1807#else
1808*/
1810 return TRUE;
1811//#endif
1812}
BOOLEAN p_DebugLmDivisibleByNoComp(poly a, poly b, ring r)
Definition pDebug.cc:144
#define pDivAssume(x)
Definition p_polys.h:1282

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

1838{
1839 int i=end;
1840 pAssume1(r_a->N == r_b->N);
1841
1842 do
1843 {
1844 if (p_GetExp(a,i,r_a) > p_GetExp(b,i,r_b))
1845 return FALSE;
1846 i--;
1847 }
1848 while (i>=start);
1849/*#ifdef HAVE_RINGS
1850 return n_DivBy(p_GetCoeff(b, r_b), p_GetCoeff(a, r_a), r_a->cf);
1851#else
1852*/
1853 return TRUE;
1854//#endif
1855}

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

1857{
1858 if (p_GetComp(a, r_a) == 0 || p_GetComp(a,r_a) == p_GetComp(b,r_b))
1859 return _p_LmDivisibleByNoCompPart(a, r_a, b, r_b,start,end);
1860 return FALSE;
1861}
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:1837

◆ _p_LmTest()

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

Definition at line 326 of file pDebug.cc.

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

◆ _p_Mult_q()

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

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

Definition at line 313 of file p_Mult_q.cc.

314{
315 assume(r != NULL);
316#ifdef HAVE_RINGS
317 if (!nCoeff_is_Domain(r->cf))
318 return _p_Mult_q_Normal_ZeroDiv(p, q, copy, r);
319#endif
320 int lp, lq, l;
321 poly pt;
322
323 // MIN_LENGTH_FACTORY must be >= MIN_LENGTH_FACTORY_QQ, MIN_FLINT_QQ, MIN_FLINT_Zp 20
325
326 if (lp < lq)
327 {
328 pt = p;
329 p = q;
330 q = pt;
331 l = lp;
332 lp = lq;
333 lq = l;
334 }
335 BOOLEAN pure_polys=(p_GetComp(p,r)==0) && (p_GetComp(q,r)==0);
336 #ifdef HAVE_FLINT
337 #if __FLINT_RELEASE >= 20503
338 if (lq>MIN_FLINT_QQ)
339 {
341 if (pure_polys && rField_is_Q(r) && !convSingRFlintR(ctx,r))
342 {
343 // lq is a lower bound for the length of p and q
344 poly res=Flint_Mult_MP(p,lq,q,lq,ctx,r);
345 if (!copy)
346 {
347 p_Delete(&p,r);
348 p_Delete(&q,r);
349 }
350 return res;
351 }
352 }
353 if (lq>MIN_FLINT_Zp)
354 {
357 {
358 // lq is a lower bound for the length of p and q
359 poly res=Flint_Mult_MP(p,lq,q,lq,ctx,r);
360 if (!copy)
361 {
362 p_Delete(&p,r);
363 p_Delete(&q,r);
364 }
365 return res;
366 }
367 }
368 if (lq>MIN_FLINT_Z)
369 {
371 if (pure_polys && rField_is_Z(r) && !convSingRFlintR(ctx,r))
372 {
373 // lq is a lower bound for the length of p and q
374 poly res=Flint_Mult_MP(p,lq,q,lq,ctx,r);
375 if (!copy)
376 {
377 p_Delete(&p,r);
378 p_Delete(&q,r);
379 }
380 return res;
381 }
382 }
383 #endif
384 #endif
386 return _p_Mult_q_Normal(p, q, copy, r);
387 else if (pure_polys
388 && ((r->cf->extRing==NULL)||(r->cf->extRing->qideal!=NULL))
389 /* exclude trans. extensions: may contain rat.funct as cf */
390 && (((lq >= MIN_LENGTH_FACTORY)
391 && (r->cf->convSingNFactoryN!=ndConvSingNFactoryN))
393 && rField_is_Q(r))))
394 {
395 poly h=singclap_pmult(p,q,r);
396 if (!copy)
397 {
398 p_Delete(&p,r);
399 p_Delete(&q,r);
400 }
401 return h;
402 }
403 else
404 {
405 lp=pLength(p);
406 lq=pLength(q);
407 return _p_Mult_q_Bucket(p, lp, q, lq, copy, r);
408 }
409}
int l
Definition cfEzgcd.cc:100
poly singclap_pmult(poly f, poly g, const ring r)
Definition clapsing.cc:577
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:743
CanonicalForm res
Definition facAbsFact.cc:60
CFArray copy(const CFList &list)
write elements of list into an array
STATIC_VAR Poly * h
Definition janet.cc:971
#define assume(x)
Definition mod2.h:387
Definition lq.h:40
CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition numbers.cc:313
#define TEST_OPT_NOT_BUCKETS
Definition options.h:105
static void pqLengthApprox(poly p, poly q, int &lp, int &lq, const int min)
Definition p_Mult_q.cc:69
#define MIN_LENGTH_FACTORY
Definition p_Mult_q.cc:304
#define MIN_FLINT_Z
Definition p_Mult_q.cc:308
#define MIN_FLINT_QQ
Definition p_Mult_q.cc:306
static poly _p_Mult_q_Normal(poly p, poly q, const int copy, const ring r)
Definition p_Mult_q.cc:223
#define MIN_LENGTH_FACTORY_QQ
Definition p_Mult_q.cc:305
static 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
static poly _p_Mult_q_Normal_ZeroDiv(poly p, poly q, const int copy, const ring r)
Definition p_Mult_q.cc:195
#define MIN_FLINT_Zp
Definition p_Mult_q.cc:307
#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:901
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_Test()

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

Definition at line 215 of file pDebug.cc.

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

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

◆ n_PermNumber()

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

Definition at line 4049 of file p_polys.cc.

4050{
4051#if 0
4052 PrintS("\nSource Ring: \n");
4053 rWrite(src);
4054
4055 if(0)
4056 {
4057 number zz = n_Copy(z, src->cf);
4058 PrintS("z: "); n_Write(zz, src);
4059 n_Delete(&zz, src->cf);
4060 }
4061
4062 PrintS("\nDestination Ring: \n");
4063 rWrite(dst);
4064
4065 /*Print("\nOldPar: %d\n", OldPar);
4066 for( int i = 1; i <= OldPar; i++ )
4067 {
4068 Print("par(%d) -> par/var (%d)\n", i, par_perm[i-1]);
4069 }*/
4070#endif
4071 if( z == NULL )
4072 return NULL;
4073
4074 const coeffs srcCf = src->cf;
4075 assume( srcCf != NULL );
4076
4078 assume( src->cf->extRing!=NULL );
4079
4080 poly zz = NULL;
4081
4082 const ring srcExtRing = srcCf->extRing;
4083 assume( srcExtRing != NULL );
4084
4085 const coeffs dstCf = dst->cf;
4086 assume( dstCf != NULL );
4087
4088 if( nCoeff_is_algExt(srcCf) ) // nCoeff_is_GF(srcCf)?
4089 {
4090 zz = (poly) z;
4091 if( zz == NULL ) return NULL;
4092 }
4093 else if (nCoeff_is_transExt(srcCf))
4094 {
4095 assume( !IS0(z) );
4096
4097 zz = NUM((fraction)z);
4098 p_Test (zz, srcExtRing);
4099
4100 if( zz == NULL ) return NULL;
4101 if( !DENIS1((fraction)z) )
4102 {
4104 WarnS("Not defined: Cannot map a rational fraction and make a polynomial out of it! Ignoring the denominator.");
4105 }
4106 }
4107 else
4108 {
4109 assume (FALSE);
4110 WerrorS("Number permutation is not implemented for this data yet!");
4111 return NULL;
4112 }
4113
4114 assume( zz != NULL );
4115 p_Test (zz, srcExtRing);
4116
4118
4119 assume( nMap != NULL );
4120
4121 poly qq;
4122 if ((par_perm == NULL) && (rPar(dst) != 0 && rVar (srcExtRing) > 0))
4123 {
4124 int* perm;
4125 perm=(int *)omAlloc0((rVar(srcExtRing)+1)*sizeof(int));
4126 for(int i=si_min(rVar(srcExtRing),rPar(dst));i>0;i--)
4127 perm[i]=-i;
4129 omFreeSize ((ADDRESS)perm, (rVar(srcExtRing)+1)*sizeof(int));
4130 }
4131 else
4133
4135 && (!DENIS1((fraction)z))
4137 {
4139 qq=p_Div_nn(qq,n,dst);
4140 n_Delete(&n,dstCf);
4142 }
4143 p_Test (qq, dst);
4144
4145 return qq;
4146}
static int si_min(const int a, const int b)
Definition auxiliary.h:125
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
Definition coeffs.h:455
static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
Definition coeffs.h:843
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:704
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition coeffs.h:459
static FORCE_INLINE void n_Write(number n, const coeffs r, const BOOLEAN bShortOut=TRUE)
Definition coeffs.h:595
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
Definition coeffs.h:914
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition coeffs.h:80
static FORCE_INLINE BOOLEAN nCoeff_is_transExt(const coeffs r)
TRUE iff r represents a transcendental extension field.
Definition coeffs.h:922
#define WarnS
Definition emacs.cc:78
void WerrorS(const char *s)
Definition feFopen.cc:24
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition monomials.h:44
The main handler for Singular numbers which are suitable for Singular polynomials.
#define omFreeSize(addr, size)
#define omAlloc0(size)
poly p_PermPoly(poly p, const int *perm, const ring oldRing, const ring dst, nMapFunc nMap, const int *par_perm, int OldPar, BOOLEAN use_mult)
Definition p_polys.cc:4152
poly p_Div_nn(poly p, const number n, const ring r)
Definition p_polys.cc:1508
void p_Normalize(poly p, const ring r)
Definition p_polys.cc:3835
static BOOLEAN p_IsConstant(const poly p, const ring r)
Definition p_polys.h:1964
#define p_Test(p, r)
Definition p_polys.h:161
#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 936 of file p_polys.h.

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

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

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

◆ p_AddComp()

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

Definition at line 447 of file p_polys.h.

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

◆ p_AddExp()

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

Definition at line 606 of file p_polys.h.

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

◆ 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:768
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:542
int j
Definition facHensel.cc:110
static number p_SetCoeff(poly p, number n, ring r)
Definition p_polys.h:412
static poly pReverse(poly p)
Definition p_polys.h:335
static poly p_Head(const poly p, const ring r)
copy the (leading) term of p
Definition p_polys.h:860
static poly p_LmFreeAndNext(poly p, ring)
Definition p_polys.h:711
#define R
Definition sirandom.c:27
#define loop
Definition structs.h:75

◆ p_Cleardenom()

poly p_Cleardenom ( poly p,
const ring r )

Definition at line 2851 of file p_polys.cc.

2852{
2853 if( p == NULL )
2854 return NULL;
2855
2856 assume( r != NULL );
2857 assume( r->cf != NULL );
2858 const coeffs C = r->cf;
2859
2860#if CLEARENUMERATORS
2861 if( 0 )
2862 {
2865 n_ClearContent(itr, C); // divide out the content
2866 p_Test(p, r); n_Test(pGetCoeff(p), C);
2867 assume(n_GreaterZero(pGetCoeff(p), C)); // ??
2868// if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
2869 return p;
2870 }
2871#endif
2872
2873 number d, h;
2874
2875 if (rField_is_Ring(r))
2876 {
2877 if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
2878 return p;
2879 }
2880
2882 {
2883 if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
2884 return p;
2885 }
2886
2887 assume(p != NULL);
2888
2889 if(pNext(p)==NULL)
2890 {
2891 if (!TEST_OPT_CONTENTSB)
2892 p_SetCoeff(p,n_Init(1,C),r);
2893 else if(!n_GreaterZero(pGetCoeff(p),C))
2894 p = p_Neg(p,r);
2895 return p;
2896 }
2897
2898 assume(pNext(p)!=NULL);
2899 poly start=p;
2900
2901#if 0 && CLEARENUMERATORS
2902//CF: does not seem to work that well..
2903
2904 if( nCoeff_is_Q(C) || nCoeff_is_Q_a(C) )
2905 {
2908 n_ClearContent(itr, C); // divide out the content
2909 p_Test(p, r); n_Test(pGetCoeff(p), C);
2910 assume(n_GreaterZero(pGetCoeff(p), C)); // ??
2911// if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
2912 return start;
2913 }
2914#endif
2915
2916 if(1)
2917 {
2918 // get lcm of all denominators ----------------------------------
2919 h = n_Init(1,C);
2920 while (p!=NULL)
2921 {
2924 n_Delete(&h,C);
2925 h=d;
2926 pIter(p);
2927 }
2928 /* h now contains the 1/lcm of all denominators */
2929 if(!n_IsOne(h,C))
2930 {
2931 // multiply by the lcm of all denominators
2932 p = start;
2933 while (p!=NULL)
2934 {
2935 d=n_Mult(h,pGetCoeff(p),C);
2936 n_Normalize(d,C);
2937 p_SetCoeff(p,d,r);
2938 pIter(p);
2939 }
2940 }
2941 n_Delete(&h,C);
2942 p=start;
2943
2944 p_ContentForGB(p,r);
2945#ifdef HAVE_RATGRING
2946 if (rIsRatGRing(r))
2947 {
2948 /* quick unit detection in the rational case is done in gr_nc_bba */
2949 p_ContentRat(p, r);
2950 start=p;
2951 }
2952#endif
2953 }
2954
2955 if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
2956
2957 return start;
2958}
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:640
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:699
static FORCE_INLINE BOOLEAN n_GreaterZero(number n, const coeffs r)
ordered fields: TRUE iff 'n' is positive; in Z/pZ: TRUE iff 0 < m <= roundedBelow(p/2),...
Definition coeffs.h:498
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
Definition coeffs.h:810
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:939
static FORCE_INLINE BOOLEAN nCoeff_is_Q_a(const coeffs r)
Definition coeffs.h:889
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:932
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition coeffs.h:582
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition coeffs.h:472
#define TEST_OPT_INTSTRATEGY
Definition options.h:110
#define TEST_OPT_CONTENTSB
Definition options.h:127
void p_ContentRat(poly &ph, const ring r)
Definition p_polys.cc:1750
void p_ContentForGB(poly ph, const ring r)
Definition p_polys.cc:2361
static poly p_Neg(poly p, const ring r)
Definition p_polys.h:1107
static BOOLEAN rIsRatGRing(const ring r)
Definition ring.h:432
#define rField_is_Ring(R)
Definition ring.h:490

◆ p_Cleardenom_n()

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

Definition at line 2960 of file p_polys.cc.

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

1728{
1729 if (p2==NULL)
1730 {
1731 if (p1==NULL) return 0;
1732 return 1;
1733 }
1734 if (p1==NULL)
1735 return -1;
1736 return p_LmCmp(p1,p2,r);
1737}

◆ p_CmpPolys()

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

Definition at line 1739 of file p_polys.h.

1740{
1741 if (p2==NULL)
1742 {
1743 if (p1==NULL) return 0;
1744 return 1;
1745 }
1746 if (p1==NULL)
1747 return -1;
1748 return p_ComparePolys(p1,p2,r);
1749}
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:4626

◆ p_Comp_k_n()

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

Definition at line 640 of file p_polys.h.

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

◆ p_Compare()

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

Definition at line 4946 of file p_polys.cc.

4947{
4948 int r=p_Cmp(a,b,R);
4949 if ((r==0)&&(a!=NULL))
4950 {
4951 number h=n_Sub(pGetCoeff(a),pGetCoeff(b),R->cf);
4952 /* compare lead coeffs */
4953 r = -1+n_IsZero(h,R->cf)+2*n_GreaterZero(h,R->cf); /* -1: <, 0:==, 1: > */
4954 n_Delete(&h,R->cf);
4955 }
4956 else if (a==NULL)
4957 {
4958 if (b==NULL)
4959 {
4960 /* compare 0, 0 */
4961 r=0;
4962 }
4963 else if(p_IsConstant(b,R))
4964 {
4965 /* compare 0, const */
4966 r = 1-2*n_GreaterZero(pGetCoeff(b),R->cf); /* -1: <, 1: > */
4967 }
4968 }
4969 else if (b==NULL)
4970 {
4971 if (p_IsConstant(a,R))
4972 {
4973 /* compare const, 0 */
4974 r = -1+2*n_GreaterZero(pGetCoeff(a),R->cf); /* -1: <, 1: > */
4975 }
4976 }
4977 return(r);
4978}
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:659
static int p_Cmp(poly p1, poly p2, ring r)
Definition p_polys.h:1727

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

4627{
4628 number n,nn;
4629 pAssume(p1 != NULL && p2 != NULL);
4630
4631 if (!p_LmEqual(p1,p2,r)) //compare leading mons
4632 return FALSE;
4633 if ((pNext(p1)==NULL) && (pNext(p2)!=NULL))
4634 return FALSE;
4635 if ((pNext(p2)==NULL) && (pNext(p1)!=NULL))
4636 return FALSE;
4637 if (pLength(p1) != pLength(p2))
4638 return FALSE;
4639 #ifdef HAVE_RINGS
4640 if (rField_is_Ring(r))
4641 {
4642 if (!n_DivBy(pGetCoeff(p1), pGetCoeff(p2), r->cf)) return FALSE;
4643 }
4644 #endif
4645 n=n_Div(pGetCoeff(p1),pGetCoeff(p2),r->cf);
4646 while ((p1 != NULL) /*&& (p2 != NULL)*/)
4647 {
4648 if ( ! p_LmEqual(p1, p2,r))
4649 {
4650 n_Delete(&n, r->cf);
4651 return FALSE;
4652 }
4653 if (!n_Equal(pGetCoeff(p1), nn = n_Mult(pGetCoeff(p2),n, r->cf), r->cf))
4654 {
4655 n_Delete(&n, r->cf);
4656 n_Delete(&nn, r->cf);
4657 return FALSE;
4658 }
4659 n_Delete(&nn, r->cf);
4660 pIter(p1);
4661 pIter(p2);
4662 }
4663 n_Delete(&n, r->cf);
4664 return TRUE;
4665}
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:757
static FORCE_INLINE BOOLEAN n_Equal(number a, number b, const coeffs r)
TRUE iff 'a' and 'b' represent the same number; they may have different representations.
Definition coeffs.h:464
#define pAssume(cond)
Definition monomials.h:90
#define p_LmEqual(p1, p2, r)
Definition p_polys.h:1723

◆ p_Content()

void p_Content ( poly p,
const ring r )

Definition at line 2301 of file p_polys.cc.

2302{
2303 if (ph==NULL) return;
2304 const coeffs cf=r->cf;
2305 if (pNext(ph)==NULL)
2306 {
2307 p_SetCoeff(ph,n_Init(1,cf),r);
2308 return;
2309 }
2310 if ((cf->cfSubringGcd==ndGcd)
2311 || (cf->cfGcd==ndGcd)) /* trivial gcd*/
2312 return;
2313 number h;
2314 if ((rField_is_Q(r))
2315 || (rField_is_Q_a(r))
2316 || (rField_is_Zp_a)(r)
2317 || (rField_is_Z(r))
2318 )
2319 {
2320 h=p_InitContent(ph,r); /* first guess of a gcd of all coeffs */
2321 }
2322 else
2323 {
2325 }
2326 poly p;
2327 if(n_IsOne(h,cf))
2328 {
2329 goto content_finish;
2330 }
2331 p=ph;
2332 // take the SubringGcd of all coeffs
2333 while (p!=NULL)
2334 {
2337 n_Delete(&h,cf);
2338 h = d;
2339 if(n_IsOne(h,cf))
2340 {
2341 goto content_finish;
2342 }
2343 pIter(p);
2344 }
2345 // if found<>1, divide by it
2346 p = ph;
2347 while (p!=NULL)
2348 {
2350 p_SetCoeff(p,d,r);
2351 pIter(p);
2352 }
2354 n_Delete(&h,r->cf);
2355 // and last: check leading sign:
2356 if(!n_GreaterZero(pGetCoeff(ph),r->cf)) ph = p_Neg(ph,r);
2357}
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:626
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
Definition coeffs.h:670
number ndGcd(number, number, const coeffs r)
Definition numbers.cc:189
number p_InitContent(poly ph, const ring r)
Definition p_polys.cc:2641
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 2361 of file p_polys.cc.

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

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

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

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

◆ p_Copy() [2/2]

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

returns a copy of p

Definition at line 846 of file p_polys.h.

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

◆ p_Copy_noCheck()

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

returns a copy of p (without any additional testing)

Definition at line 836 of file p_polys.h.

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

◆ p_CopyPowerProduct()

poly p_CopyPowerProduct ( const poly p,
const ring r )

like p_Head, but with coefficient 1

Definition at line 5030 of file p_polys.cc.

5031{
5032 if (p == NULL) return NULL;
5033 return p_CopyPowerProduct0(p,n_Init(1,r->cf),r);
5034}
poly p_CopyPowerProduct0(const poly p, number n, const ring r)
like p_Head, but with coefficient n
Definition p_polys.cc:5018

◆ p_CopyPowerProduct0()

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

like p_Head, but with coefficient n

Definition at line 5018 of file p_polys.cc.

5019{
5021 poly np;
5022 omTypeAllocBin(poly, np, r->PolyBin);
5023 p_SetRingOfLm(np, r);
5024 memcpy(np->exp, p->exp, r->ExpL_Size*sizeof(long));
5025 pNext(np) = NULL;
5026 pSetCoeff0(np, n);
5027 return np;
5028}
#define p_LmCheckPolyRing1(p, r)
Definition monomials.h:177
#define pSetCoeff0(p, n)
Definition monomials.h:59
#define p_SetRingOfLm(p, r)
Definition monomials.h:144
#define omTypeAllocBin(type, addr, bin)

◆ p_DecrExp()

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

Definition at line 598 of file p_polys.h.

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

◆ p_Deg()

long p_Deg ( poly a,
const ring r )

Definition at line 587 of file p_polys.cc.

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

◆ p_DegW()

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

Definition at line 693 of file p_polys.cc.

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

◆ p_Delete() [1/2]

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

Definition at line 908 of file p_polys.h.

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

◆ p_Delete() [2/2]

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

Definition at line 901 of file p_polys.h.

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

◆ p_DeleteComp()

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

Definition at line 3565 of file p_polys.cc.

3566{
3567 poly q;
3568 long unsigned kk=k;
3569
3570 while ((*p!=NULL) && (__p_GetComp(*p,r)==kk)) p_LmDelete(p,r);
3571 if (*p==NULL) return;
3572 q = *p;
3573 if (__p_GetComp(q,r)>kk)
3574 {
3575 p_SubComp(q,1,r);
3576 p_SetmComp(q,r);
3577 }
3578 while (pNext(q)!=NULL)
3579 {
3580 long c=__p_GetComp(pNext(q),r);
3581 if (/*__p_GetComp(pNext(q),r)*/c==kk)
3582 p_LmDelete(&(pNext(q)),r);
3583 else
3584 {
3585 pIter(q);
3586 if (/*__p_GetComp(q,r)*/c>kk)
3587 {
3588 p_SubComp(q,1,r);
3589 p_SetmComp(q,r);
3590 }
3591 }
3592 }
3593}
static unsigned long p_SubComp(poly p, unsigned long v, ring r)
Definition p_polys.h:453
#define p_SetmComp
Definition p_polys.h:244

◆ p_Diff()

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

Definition at line 1904 of file p_polys.cc.

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

◆ p_DiffOp()

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

Definition at line 1979 of file p_polys.cc.

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

◆ p_Div_mm()

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

divide polynomial by monomial

Definition at line 1544 of file p_polys.cc.

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

◆ p_Div_nn()

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

Definition at line 1508 of file p_polys.cc.

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

◆ p_DivideM()

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

Definition at line 1584 of file p_polys.cc.

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

1901{
1903 pIfThen1(a!=NULL, p_LmCheckPolyRing1(a, r));
1904
1905 if (a != NULL && (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r)))
1906 return _p_LmDivisibleByNoComp(a,b,r);
1907 return FALSE;
1908}
#define pIfThen1(cond, check)
Definition monomials.h:179

◆ p_DivisibleByRingCase()

BOOLEAN p_DivisibleByRingCase ( poly f,
poly g,
const ring r )

divisibility check over ground ring (which may contain zero divisors); TRUE iff LT(f) divides LT(g), i.e., LT(f)*c*m = LT(g), for some coefficient c and some monomial m; does not take components into account

Definition at line 1648 of file p_polys.cc.

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

◆ p_EqualPolys() [1/2]

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

Definition at line 4562 of file p_polys.cc.

4563{
4564 while ((p1 != NULL) && (p2 != NULL))
4565 {
4566 if (! p_LmEqual(p1, p2,r))
4567 return FALSE;
4568 if (! n_Equal(p_GetCoeff(p1,r), p_GetCoeff(p2,r),r->cf ))
4569 return FALSE;
4570 pIter(p1);
4571 pIter(p2);
4572 }
4573 return (p1==p2);
4574}
#define p_GetCoeff(p, r)
Definition monomials.h:50

◆ p_EqualPolys() [2/2]

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

same as the usual p_EqualPolys for polys belonging to equal rings

Definition at line 4600 of file p_polys.cc.

4601{
4602 assume( r1 == r2 || rSamePolyRep(r1, r2) ); // will be used in rEqual!
4603 assume( r1->cf == r2->cf );
4604
4605 while ((p1 != NULL) && (p2 != NULL))
4606 {
4607 // returns 1 if ExpVector(p)==ExpVector(q): does not compare numbers !!
4608 // #define p_LmEqual(p1, p2, r) p_ExpVectorEqual(p1, p2, r)
4609
4610 if (! p_ExpVectorEqual(p1, p2, r1, r2))
4611 return FALSE;
4612
4613 if (! n_Equal(p_GetCoeff(p1,r1), p_GetCoeff(p2,r2), r1->cf ))
4614 return FALSE;
4615
4616 pIter(p1);
4617 pIter(p2);
4618 }
4619 return (p1==p2);
4620}
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:1801

◆ p_ExpVectorAdd()

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

Definition at line 1411 of file p_polys.h.

1412{
1413 p_LmCheckPolyRing1(p1, r);
1414 p_LmCheckPolyRing1(p2, r);
1415#if PDEBUG >= 1
1416 for (int i=1; i<=r->N; i++)
1417 pAssume1((unsigned long) (p_GetExp(p1, i, r) + p_GetExp(p2, i, r)) <= r->bitmask);
1418 pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0);
1419#endif
1420
1421 p_MemAdd_LengthGeneral(p1->exp, p2->exp, r->ExpL_Size);
1423}
#define p_MemAdd_LengthGeneral(r, s, length)
Definition p_MemAdd.h:173
static void p_MemAdd_NegWeightAdjust(poly p, const ring r)
Definition p_polys.h:1292

◆ p_ExpVectorAddSub()

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

Definition at line 1456 of file p_polys.h.

1457{
1458 p_LmCheckPolyRing1(p1, r);
1459 p_LmCheckPolyRing1(p2, r);
1461#if PDEBUG >= 1
1462 for (int i=1; i<=r->N; i++)
1463 pAssume1(p_GetExp(p1, i, r) + p_GetExp(p2, i, r) >= p_GetExp(p3, i, r));
1464 pAssume1(p_GetComp(p1, r) == 0 ||
1465 (p_GetComp(p2, r) - p_GetComp(p3, r) == 0) ||
1466 (p_GetComp(p1, r) == p_GetComp(p2, r) - p_GetComp(p3, r)));
1467#endif
1468
1469 p_MemAddSub_LengthGeneral(p1->exp, p2->exp, p3->exp, r->ExpL_Size);
1470 // no need to adjust in case of NegWeights
1471}
#define p_MemAddSub_LengthGeneral(r, s, t, length)
Definition p_MemAdd.h:312

◆ p_ExpVectorCopy()

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

Definition at line 1313 of file p_polys.h.

1314{
1317 memcpy(d_p->exp, s_p->exp, r->ExpL_Size*sizeof(long));
1318}

◆ p_ExpVectorDiff()

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

Definition at line 1474 of file p_polys.h.

1475{
1476 p_LmCheckPolyRing1(p1, r);
1477 p_LmCheckPolyRing1(p2, r);
1479#if PDEBUG >= 2
1480 for (int i=1; i<=r->N; i++)
1481 pAssume1(p_GetExp(p1, i, r) >= p_GetExp(p2, i, r));
1482 pAssume1(!rRing_has_Comp(r) || p_GetComp(p1, r) == p_GetComp(p2, r));
1483#endif
1484
1485 p_MemDiff_LengthGeneral(pr->exp, p1->exp, p2->exp, r->ExpL_Size);
1487}
#define p_MemDiff_LengthGeneral(r, s1, s2, length)
Definition p_MemAdd.h:262
static void p_MemSub_NegWeightAdjust(poly p, const ring r)
Definition p_polys.h:1302

◆ p_ExpVectorEqual()

static BOOLEAN p_ExpVectorEqual ( 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);
1493
1494 unsigned i = r->ExpL_Size;
1495 unsigned long *ep = p1->exp;
1496 unsigned long *eq = p2->exp;
1497
1498 do
1499 {
1500 i--;
1501 if (ep[i] != eq[i]) return FALSE;
1502 }
1503 while (i!=0);
1504 return TRUE;
1505}

◆ p_ExpVectorSub()

static void p_ExpVectorSub ( 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);
1444#if PDEBUG >= 1
1445 for (int i=1; i<=r->N; i++)
1446 pAssume1(p_GetExp(p1, i, r) >= p_GetExp(p2, i, r));
1447 pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0 ||
1448 p_GetComp(p1, r) == p_GetComp(p2, r));
1449#endif
1450
1451 p_MemSub_LengthGeneral(p1->exp, p2->exp, r->ExpL_Size);
1453}
#define p_MemSub_LengthGeneral(r, s, length)
Definition p_MemAdd.h:291

◆ p_ExpVectorSum()

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

Definition at line 1425 of file p_polys.h.

1426{
1427 p_LmCheckPolyRing1(p1, r);
1428 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_MemSum_LengthGeneral(pr->exp, p1->exp, p2->exp, r->ExpL_Size);
1438}
#define p_MemSum_LengthGeneral(r, s1, s2, length)
Definition p_MemAdd.h:86

◆ p_Farey()

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

Definition at line 54 of file p_polys.cc.

55{
56 poly h=p_Copy(p,r);
57 poly hh=h;
58 while(h!=NULL)
59 {
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:771

◆ p_FDeg()

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

Definition at line 380 of file p_polys.h.

380{ 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 4980 of file p_polys.cc.

4981{
4982 assume(f!=NULL);
4983 assume(g!=NULL);
4984 assume(pNext(f)==NULL);
4985 poly G=p_Head(f,r);
4986 poly h=g;
4987 int *mf=(int*)omAlloc((r->N+1)*sizeof(int));
4988 p_GetExpV(f,mf,r);
4989 int *mh=(int*)omAlloc((r->N+1)*sizeof(int));
4992 loop
4993 {
4994 if (h==NULL) break;
4995 if(!one_coeff)
4996 {
4998 one_coeff=n_IsOne(n,r->cf);
4999 p_SetCoeff(G,n,r);
5000 }
5001 p_GetExpV(h,mh,r);
5003 for(unsigned j=r->N;j!=0;j--)
5004 {
5005 if (mh[j]<mf[j]) mf[j]=mh[j];
5006 if (mf[j]>0) const_mon=FALSE;
5007 }
5008 if (one_coeff && const_mon) break;
5009 pIter(h);
5010 }
5011 mf[0]=0;
5012 p_SetExpV(G,mf,r); // included is p_SetComp, p_Setm
5013 omFreeSize(mf,(r->N+1)*sizeof(int));
5014 omFreeSize(mh,(r->N+1)*sizeof(int));
5015 return G;
5016}
STATIC_VAR TreeM * G
Definition janet.cc:31
#define omAlloc(size)
static void p_SetExpV(poly p, int *ev, const ring r)
Definition p_polys.h:1544
static void p_GetExpV(poly p, int *ev, const ring r)
Definition p_polys.h:1520

◆ p_GetCoeffRat()

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

Definition at line 1728 of file p_polys.cc.

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

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

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

◆ p_GetExp() [2/3]

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

Definition at line 555 of file p_polys.h.

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

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

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

1373{
1374 if (p == NULL) return NULL;
1376 poly np;
1377 omTypeAllocBin(poly, np, r->PolyBin);
1378 p_SetRingOfLm(np, r);
1379 memcpy(np->exp, p->exp, r->ExpL_Size*sizeof(long));
1380 pNext(np) = NULL;
1381 pSetCoeff0(np, n_Init(1, r->cf));
1382 int i;
1383 for(i=l;i<=k;i++)
1384 {
1385 //np->exp[(r->VarOffset[i] & 0xffffff)] =0;
1386 p_SetExp(np,i,0,r);
1387 }
1388 p_Setm(np,r);
1389 return np;
1390}

◆ p_GetExpDiff()

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

Definition at line 635 of file p_polys.h.

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

◆ p_GetExpSum()

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

Definition at line 629 of file p_polys.h.

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

◆ p_GetExpV()

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

Definition at line 1520 of file p_polys.h.

1521{
1523 for (unsigned j = r->N; j!=0; j--)
1524 ev[j] = p_GetExp(p, j, r);
1525
1526 ev[0] = p_GetComp(p, r);
1527}

◆ p_GetExpVL()

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

Definition at line 1529 of file p_polys.h.

1530{
1532 for (unsigned j = r->N; j!=0; j--)
1533 ev[j-1] = p_GetExp(p, j, r);
1534}

◆ p_GetExpVLV()

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

Definition at line 1536 of file p_polys.h.

1537{
1539 for (unsigned j = r->N; j!=0; j--)
1540 ev[j-1] = p_GetExp(p, j, r);
1541 return (int64)p_GetComp(p,r);
1542}
long int64
Definition auxiliary.h:68

◆ p_GetMaxExp() [1/2]

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

Definition at line 804 of file p_polys.h.

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

◆ p_GetMaxExp() [2/2]

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

Definition at line 781 of file p_polys.h.

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

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

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

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

◆ p_GetOrder()

static long p_GetOrder ( poly p,
ring r )
inlinestatic

Definition at line 421 of file p_polys.h.

422{
424 if (r->typ==NULL) return ((p)->exp[r->pOrdIndex]);
425 int i=0;
426 loop
427 {
428 switch(r->typ[i].ord_typ)
429 {
430 case ro_am:
431 case ro_wp_neg:
432 return ((p->exp[r->pOrdIndex])-POLY_NEGWEIGHT_OFFSET);
433 case ro_syzcomp:
434 case ro_syz:
435 case ro_cp:
436 i++;
437 break;
438 //case ro_dp:
439 //case ro_wp:
440 default:
441 return ((p)->exp[r->pOrdIndex]);
442 }
443 }
444}
#define POLY_NEGWEIGHT_OFFSET
Definition monomials.h:236
@ 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 560 of file p_polys.cc.

561{
562 // covers lp, rp, ls,
563 if (r->typ == NULL) return p_Setm_Dummy;
564
565 if (r->OrdSize == 1)
566 {
567 if (r->typ[0].ord_typ == ro_dp &&
568 r->typ[0].data.dp.start == 1 &&
569 r->typ[0].data.dp.end == r->N &&
570 r->typ[0].data.dp.place == r->pOrdIndex)
571 return p_Setm_TotalDegree;
572 if (r->typ[0].ord_typ == ro_wp &&
573 r->typ[0].data.wp.start == 1 &&
574 r->typ[0].data.wp.end == r->N &&
575 r->typ[0].data.wp.place == r->pOrdIndex &&
576 r->typ[0].data.wp.weights == r->firstwv)
578 }
579 return p_Setm_General;
580}
void p_Setm_WFirstTotalDegree(poly p, const ring r)
Definition p_polys.cc:554
void p_Setm_Dummy(poly p, const ring r)
Definition p_polys.cc:541
void p_Setm_TotalDegree(poly p, const ring r)
Definition p_polys.cc:547
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 4830 of file p_polys.cc.

4831{
4832 assume(p != NULL);
4833 unsigned long ev = 0; // short exponent vector
4834 unsigned int n = BIT_SIZEOF_LONG / r->N; // number of bits per exp
4835 unsigned int m1; // highest bit which is filled with (n+1)
4836 unsigned int i=0;
4837 int j=1;
4838
4839 if (n == 0)
4840 {
4841 if (r->N <2*BIT_SIZEOF_LONG)
4842 {
4843 n=1;
4844 m1=0;
4845 }
4846 else
4847 {
4848 for (; j<=r->N; j++)
4849 {
4850 if (p_GetExp(p,j,r) > 0) i++;
4851 if (i == BIT_SIZEOF_LONG) break;
4852 }
4853 if (i>0)
4854 ev = ~(0UL) >> (BIT_SIZEOF_LONG - i);
4855 return ev;
4856 }
4857 }
4858 else
4859 {
4860 m1 = (n+1)*(BIT_SIZEOF_LONG - n*r->N);
4861 }
4862
4863 n++;
4864 while (i<m1)
4865 {
4866 ev |= GetBitFields(p_GetExp(p, j,r), i, n);
4867 i += n;
4868 j++;
4869 }
4870
4871 n--;
4872 while (i<BIT_SIZEOF_LONG)
4873 {
4874 ev |= GetBitFields(p_GetExp(p, j,r), i, n);
4875 i += n;
4876 j++;
4877 }
4878 return ev;
4879}
#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:4798

◆ p_GetShortExpVector0()

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

Definition at line 4881 of file p_polys.cc.

4882{
4883 assume(p != NULL);
4884 assume(r->N >=BIT_SIZEOF_LONG);
4885 unsigned long ev = 0; // short exponent vector
4886
4887 for (int j=BIT_SIZEOF_LONG; j>0; j--)
4888 {
4889 if (p_GetExp(p, j,r)>0)
4890 ev |= Sy_bitL(j-1);
4891 }
4892 return ev;
4893}
#define Sy_bitL(x)
Definition options.h:32

◆ p_GetShortExpVector1()

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

Definition at line 4896 of file p_polys.cc.

4897{
4898 assume(p != NULL);
4899 assume(r->N <BIT_SIZEOF_LONG);
4900 assume(2*r->N >=BIT_SIZEOF_LONG);
4901 unsigned long ev = 0; // short exponent vector
4902 int rest=r->N;
4903 int e;
4904 // 2 bits per exp
4905 int j=r->N;
4906 for (; j>BIT_SIZEOF_LONG-r->N; j--)
4907 {
4908 if ((e=p_GetExp(p, j,r))>0)
4909 {
4910 ev |= Sy_bitL(j-1);
4911 if (e>1)
4912 {
4913 ev|=Sy_bitL(rest+j-1);
4914 }
4915 }
4916 }
4917 // 1 bit per exp
4918 for (; j>0; j--)
4919 {
4920 if (p_GetExp(p, j,r)>0)
4921 {
4922 ev |= Sy_bitL(j-1);
4923 }
4924 }
4925 return ev;
4926}

◆ p_GetTotalDegree()

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

Definition at line 810 of file p_polys.h.

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

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

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

◆ p_HasNotCF()

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

Definition at line 1332 of file p_polys.cc.

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

◆ p_HasNotCFRing()

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

Definition at line 1348 of file p_polys.cc.

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

◆ p_Head()

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

copy the (leading) term of p

Definition at line 860 of file p_polys.h.

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

◆ p_Head0()

poly p_Head0 ( const poly p,
const ring r )

like p_Head, but allow NULL coeff

Definition at line 5036 of file p_polys.cc.

5037{
5038 if (p==NULL) return NULL;
5039 if (pGetCoeff(p)==NULL) return p_CopyPowerProduct0(p,NULL,r);
5040 return p_Head(p,r);
5041}

◆ p_Homogen()

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

Definition at line 3276 of file p_polys.cc.

3277{
3278 pFDegProc deg;
3279 if (r->pLexOrder && (r->order[0]==ringorder_lp))
3280 deg=p_Totaldegree;
3281 else
3282 deg=r->pFDeg;
3283
3284 poly q=NULL, qn;
3285 int o,ii;
3286 sBucket_pt bp;
3287
3288 if (p!=NULL)
3289 {
3290 if ((varnum < 1) || (varnum > rVar(r)))
3291 {
3292 return NULL;
3293 }
3294 o=deg(p,r);
3295 q=pNext(p);
3296 while (q != NULL)
3297 {
3298 ii=deg(q,r);
3299 if (ii>o) o=ii;
3300 pIter(q);
3301 }
3302 q = p_Copy(p,r);
3303 bp = sBucketCreate(r);
3304 while (q != NULL)
3305 {
3306 ii = o-deg(q,r);
3307 if (ii!=0)
3308 {
3309 p_AddExp(q,varnum, (long)ii,r);
3310 p_Setm(q,r);
3311 }
3312 qn = pNext(q);
3313 pNext(q) = NULL;
3314 sBucket_Add_m(bp, q);
3315 q = qn;
3316 }
3317 sBucketDestroyAdd(bp, &q, &ii);
3318 }
3319 return q;
3320}
static long p_AddExp(poly p, int v, long ee, ring r)
Definition p_polys.h:606
long(* pFDegProc)(poly p, ring r)
Definition ring.h:38
@ 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 591 of file p_polys.h.

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

◆ p_Init() [1/2]

static poly p_Init ( const ring r)
inlinestatic

Definition at line 1330 of file p_polys.h.

1331{
1332 return p_Init(r, r->PolyBin);
1333}

◆ p_Init() [2/2]

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

Definition at line 1320 of file p_polys.h.

1321{
1322 p_CheckRing1(r);
1323 pAssume1(bin != NULL && omSizeWOfBin(r->PolyBin) == omSizeWOfBin(bin));
1324 poly p;
1325 omTypeAlloc0Bin(poly, p, bin);
1327 p_SetRingOfLm(p, r);
1328 return p;
1329}
#define p_CheckRing1(r)
Definition monomials.h:178
#define omTypeAlloc0Bin(type, addr, bin)

◆ p_InitContent()

number p_InitContent ( poly ph,
const ring r )

Definition at line 2641 of file p_polys.cc.

2644{
2646 assume(ph!=NULL);
2647 assume(pNext(ph)!=NULL);
2648 assume(rField_is_Q(r));
2649 if (pNext(pNext(ph))==NULL)
2650 {
2651 return n_GetNumerator(pGetCoeff(pNext(ph)),r->cf);
2652 }
2653 poly p=ph;
2655 pIter(p);
2657 pIter(p);
2658 number d;
2659 number t;
2660 loop
2661 {
2662 nlNormalize(pGetCoeff(p),r->cf);
2663 t=n_GetNumerator(pGetCoeff(p),r->cf);
2664 if (nlGreaterZero(t,r->cf))
2665 d=nlAdd(n1,t,r->cf);
2666 else
2667 d=nlSub(n1,t,r->cf);
2668 nlDelete(&t,r->cf);
2669 nlDelete(&n1,r->cf);
2670 n1=d;
2671 pIter(p);
2672 if (p==NULL) break;
2673 nlNormalize(pGetCoeff(p),r->cf);
2674 t=n_GetNumerator(pGetCoeff(p),r->cf);
2675 if (nlGreaterZero(t,r->cf))
2676 d=nlAdd(n2,t,r->cf);
2677 else
2678 d=nlSub(n2,t,r->cf);
2679 nlDelete(&t,r->cf);
2680 nlDelete(&n2,r->cf);
2681 n2=d;
2682 pIter(p);
2683 if (p==NULL) break;
2684 }
2685 d=nlGcd(n1,n2,r->cf);
2686 nlDelete(&n1,r->cf);
2687 nlDelete(&n2,r->cf);
2688 return d;
2689}
2690#else
2691{
2692 /* ph has al least 2 terms */
2693 number d=pGetCoeff(ph);
2694 int s=n_Size(d,r->cf);
2695 pIter(ph);
2697 int s2=n_Size(d2,r->cf);
2698 pIter(ph);
2699 if (ph==NULL)
2700 {
2701 if (s<s2) return n_Copy(d,r->cf);
2702 else return n_Copy(d2,r->cf);
2703 }
2704 do
2705 {
2707 int ns=n_Size(nd,r->cf);
2708 if (ns<=2)
2709 {
2710 s2=s;
2711 d2=d;
2712 d=nd;
2713 s=ns;
2714 break;
2715 }
2716 else if (ns<s)
2717 {
2718 s2=s;
2719 d2=d;
2720 d=nd;
2721 s=ns;
2722 }
2723 pIter(ph);
2724 }
2725 while(ph!=NULL);
2726 return n_SubringGcd(d,d2,r->cf);
2727}
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:574
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:612
LINLINE number nlAdd(number la, number li, const coeffs r)
Definition longrat.cc:2704
LINLINE number nlSub(number la, number li, const coeffs r)
Definition longrat.cc:2770
LINLINE void nlDelete(number *a, const coeffs r)
Definition longrat.cc:2669
BOOLEAN nlGreaterZero(number za, const coeffs r)
Definition longrat.cc:1309
number nlGcd(number a, number b, const coeffs r)
Definition longrat.cc:1346
void nlNormalize(number &x, const coeffs r)
Definition longrat.cc:1487

◆ p_IsConstant()

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

Definition at line 1964 of file p_polys.h.

1965{
1966 if (p == NULL) return TRUE;
1967 return (pNext(p)==NULL) && p_LmIsConstant(p, r);
1968}
static BOOLEAN p_LmIsConstant(const poly p, const ring r)
Definition p_polys.h:1023

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

1959{
1960 if (p == NULL) return TRUE;
1961 return (pNext(p)==NULL) && p_LmIsConstantComp(p, r);
1962}
static BOOLEAN p_LmIsConstantComp(const poly p, const ring r)
Definition p_polys.h:1006

◆ p_IsConstantPoly()

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

Definition at line 1978 of file p_polys.h.

1979{
1980 p_Test(p, r);
1981 poly pp=p;
1982 while(pp!=NULL)
1983 {
1984 if (! p_LmIsConstantComp(pp, r))
1985 return FALSE;
1986 pIter(pp);
1987 }
1988 return TRUE;
1989}

◆ p_ISet()

poly p_ISet ( long i,
const ring r )

returns the poly representing the integer i

Definition at line 1300 of file p_polys.cc.

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

◆ p_IsHomogeneous()

BOOLEAN p_IsHomogeneous ( poly p,
const ring r )

Definition at line 3325 of file p_polys.cc.

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

◆ p_IsHomogeneousW() [1/2]

BOOLEAN p_IsHomogeneousW ( poly p,
const intvec * w,
const intvec * module_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())+(*module_w)[p_GetComp(p,r)];
3374 do
3375 {
3376 long oo=totaldegreeWecart_IV(qp,r,w->ivGetVec())+(*module_w)[p_GetComp(qp,r)];
3377 if (oo != o) return FALSE;
3378 pIter(qp);
3379 }
3380 while (qp != NULL);
3381 return TRUE;
3382}

◆ p_IsHomogeneousW() [2/2]

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

Definition at line 3349 of file p_polys.cc.

3350{
3351 poly qp=p;
3352 long o;
3353
3354 if ((p == NULL) || (pNext(p) == NULL)) return TRUE;
3355 pIter(qp);
3356 o = totaldegreeWecart_IV(p,r,w->ivGetVec());
3357 do
3358 {
3359 if (totaldegreeWecart_IV(qp,r,w->ivGetVec()) != o) return FALSE;
3360 pIter(qp);
3361 }
3362 while (qp != NULL);
3363 return TRUE;
3364}

◆ p_IsOne()

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

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

Definition at line 1971 of file p_polys.h.

1972{
1973 if (p == NULL) return FALSE; /* TODO check if 0 == 1 */
1974 p_Test(p, R);
1975 return (p_IsConstant(p, R) && n_IsOne(p_GetCoeff(p, R), R->cf));
1976}

◆ p_IsPurePower()

int p_IsPurePower ( const poly p,
const ring r )

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

Definition at line 1229 of file p_polys.cc.

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

◆ p_IsUnit()

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

Definition at line 1991 of file p_polys.h.

1992{
1993 if (p == NULL) return FALSE;
1994 if (rField_is_Ring(r))
1995 return (p_LmIsConstant(p, r) && n_IsUnit(pGetCoeff(p),r->cf));
1996 return p_LmIsConstant(p, r);
1997}
static FORCE_INLINE BOOLEAN n_IsUnit(number n, const coeffs r)
TRUE iff n has a multiplicative inverse in the given coeff field/ring r.
Definition coeffs.h:519

◆ p_IsUnivariate()

int p_IsUnivariate ( poly p,
const ring r )

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

Definition at line 1250 of file p_polys.cc.

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

◆ p_Jet()

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

Definition at line 4436 of file p_polys.cc.

4437{
4438 while((p!=NULL) && (p_Totaldegree(p,R)>m)) p_LmDelete(&p,R);
4439 if (p==NULL) return NULL;
4440 poly r=p;
4441 while (pNext(p)!=NULL)
4442 {
4443 if (p_Totaldegree(pNext(p),R)>m)
4444 {
4445 p_LmDelete(&pNext(p),R);
4446 }
4447 else
4448 pIter(p);
4449 }
4450 return r;
4451}

◆ p_JetW()

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

Definition at line 4480 of file p_polys.cc.

4481{
4482 while((p!=NULL) && (totaldegreeWecart_IV(p,R,w)>m)) p_LmDelete(&p,R);
4483 if (p==NULL) return NULL;
4484 poly r=p;
4485 while (pNext(p)!=NULL)
4486 {
4488 {
4489 p_LmDelete(&pNext(p),R);
4490 }
4491 else
4492 pIter(p);
4493 }
4494 return r;
4495}

◆ p_Last()

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

Definition at line 4671 of file p_polys.cc.

4672{
4673 if (p == NULL)
4674 {
4675 l = 0;
4676 return NULL;
4677 }
4678 l = 1;
4679 poly a = p;
4680 if (! rIsSyzIndexRing(r))
4681 {
4682 poly next = pNext(a);
4683 while (next!=NULL)
4684 {
4685 a = next;
4686 next = pNext(a);
4687 l++;
4688 }
4689 }
4690 else
4691 {
4692 long unsigned curr_limit = rGetCurrSyzLimit(r);
4693 poly pp = a;
4694 while ((a=pNext(a))!=NULL)
4695 {
4696 if (__p_GetComp(a,r)<=curr_limit/*syzComp*/)
4697 l++;
4698 else break;
4699 pp = a;
4700 }
4701 a=pp;
4702 }
4703 return a;
4704}
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 1670 of file p_polys.cc.

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

◆ p_Lcm() [2/2]

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

Definition at line 1661 of file p_polys.cc.

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

◆ p_LcmRat()

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

Definition at line 1683 of file p_polys.cc.

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

◆ p_LDeg()

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

Definition at line 381 of file p_polys.h.

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

1581{
1583 p_LmCheckPolyRing1(q, r);
1584
1585 const unsigned long* _s1 = ((unsigned long*) p->exp);
1586 const unsigned long* _s2 = ((unsigned long*) q->exp);
1587 REGISTER unsigned long _v1;
1588 REGISTER unsigned long _v2;
1589 const unsigned long _l = r->CmpL_Size;
1590
1591 REGISTER unsigned long _i=0;
1592
1594 _v1 = _s1[_i];
1595 _v2 = _s2[_i];
1596 if (_v1 == _v2)
1597 {
1598 _i++;
1599 if (_i == _l) return 0;
1601 }
1602 const long* _ordsgn = (long*) r->ordsgn;
1603#if 1 /* two variants*/
1604 if (_v1 > _v2)
1605 {
1606 return _ordsgn[_i];
1607 }
1608 return -(_ordsgn[_i]);
1609#else
1610 if (_v1 > _v2)
1611 {
1612 if (_ordsgn[_i] == 1) return 1;
1613 return -1;
1614 }
1615 if (_ordsgn[_i] == 1) return -1;
1616 return 1;
1617#endif
1618}
#define REGISTER
Definition omalloc.h:27

◆ p_LmDelete() [1/2]

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

Definition at line 743 of file p_polys.h.

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

◆ p_LmDelete() [2/2]

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

Definition at line 723 of file p_polys.h.

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

◆ p_LmDelete0()

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

Definition at line 733 of file p_polys.h.

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

◆ p_LmDeleteAndNext()

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

Definition at line 755 of file p_polys.h.

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

◆ p_LmDeleteAndNextRat()

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

Definition at line 1706 of file p_polys.cc.

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

◆ p_LmDivisibleBy()

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

Definition at line 1891 of file p_polys.h.

1892{
1894 pIfThen1(a != NULL, p_LmCheckPolyRing1(b, r));
1895 if (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r))
1896 return _p_LmDivisibleByNoComp(a, b, r);
1897 return FALSE;
1898}

◆ p_LmDivisibleByNoComp() [1/2]

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

Definition at line 1884 of file p_polys.h.

1885{
1888 return _p_LmDivisibleByNoComp(a, ra, b, rb);
1889}

◆ p_LmDivisibleByNoComp() [2/2]

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

Definition at line 1877 of file p_polys.h.

1878{
1879 p_LmCheckPolyRing1(a, r);
1881 return _p_LmDivisibleByNoComp(a, b, r);
1882}

◆ p_LmDivisibleByPart()

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

Definition at line 1862 of file p_polys.h.

1863{
1865 pIfThen1(a != NULL, p_LmCheckPolyRing1(b, r));
1866 if (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r))
1867 return _p_LmDivisibleByNoCompPart(a, r, b, r,start, end);
1868 return FALSE;
1869}

◆ p_LmExpVectorAddIsOk()

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

Definition at line 1999 of file p_polys.h.

2001{
2002 p_LmCheckPolyRing(p1, r);
2003 p_LmCheckPolyRing(p2, r);
2004 unsigned long l1, l2, divmask = r->divmask;
2005 int i;
2006
2007 for (i=0; i<r->VarL_Size; i++)
2008 {
2009 l1 = p1->exp[r->VarL_Offset[i]];
2010 l2 = p2->exp[r->VarL_Offset[i]];
2011 // do the divisiblity trick
2012 if ( (l1 > ULONG_MAX - l2) ||
2013 (((l1 & divmask) ^ (l2 & divmask)) != ((l1 + l2) & divmask)))
2014 return FALSE;
2015 }
2016 return TRUE;
2017}

◆ p_LmFree() [1/2]

static void p_LmFree ( poly * p,
ring  )
inlinestatic

Definition at line 696 of file p_polys.h.

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

◆ p_LmFree() [2/2]

static void p_LmFree ( poly p,
ring  )
inlinestatic

Definition at line 683 of file p_polys.h.

685{
687 #ifdef XALLOC_BIN
688 omFreeBin(p,r->PolyBin);
689 #else
691 #endif
692}

◆ p_LmFreeAndNext()

static poly p_LmFreeAndNext ( poly p,
ring  )
inlinestatic

Definition at line 711 of file p_polys.h.

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

◆ p_LmInit() [1/3]

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

Definition at line 1335 of file p_polys.h.

1336{
1338 poly np;
1339 omTypeAllocBin(poly, np, r->PolyBin);
1340 p_SetRingOfLm(np, r);
1341 memcpy(np->exp, p->exp, r->ExpL_Size*sizeof(long));
1342 pNext(np) = NULL;
1343 pSetCoeff0(np, NULL);
1344 return np;
1345}

◆ p_LmInit() [2/3]

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

Definition at line 1363 of file p_polys.h.

1364{
1365 pAssume1(d_r != NULL);
1366 return p_LmInit(s_p, s_r, d_r, d_r->PolyBin);
1367}

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

1347{
1350 pAssume1(d_r->N <= s_r->N);
1351 poly d_p = p_Init(d_r, d_bin);
1352 for (unsigned i=d_r->N; i!=0; i--)
1353 {
1354 p_SetExp(d_p, i, p_GetExp(s_p, i,s_r), d_r);
1355 }
1356 if (rRing_has_Comp(d_r))
1357 {
1359 }
1360 p_Setm(d_p, d_r);
1361 return d_p;
1362}
BOOLEAN p_CheckRing(ring r)
Definition pDebug.cc:131

◆ p_LmIsConstant()

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

Definition at line 1023 of file p_polys.h.

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

◆ p_LmIsConstantComp()

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

Definition at line 1006 of file p_polys.h.

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

◆ p_LmShallowCopyDelete()

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

Definition at line 1393 of file p_polys.h.

1394{
1396 pAssume1(omSizeWOfBin(bin) == omSizeWOfBin(r->PolyBin));
1397 poly new_p = p_New(r);
1398 memcpy(new_p->exp, p->exp, r->ExpL_Size*sizeof(long));
1400 pNext(new_p) = pNext(p);
1402 return new_p;
1403}
static poly p_New(const ring, omBin bin)
Definition p_polys.h:664

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

1912{
1913 p_LmCheckPolyRing1(a, r);
1915#ifndef PDIV_DEBUG
1916 _pPolyAssume2(p_GetShortExpVector(a, r) == sev_a, a, r);
1918
1919 if (sev_a & not_sev_b)
1920 {
1922 return FALSE;
1923 }
1924 return p_LmDivisibleBy(a, b, r);
1925#else
1926 return pDebugLmShortDivisibleBy(a, sev_a, r, b, not_sev_b, r);
1927#endif
1928}
#define _pPolyAssume2(cond, p, r)
Definition monomials.h:195
static BOOLEAN p_LmDivisibleByNoComp(poly a, poly b, const ring r)
Definition p_polys.h:1877
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
Definition p_polys.h:1891
unsigned long p_GetShortExpVector(const poly a, const ring r)
Definition p_polys.cc:4830

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

1932{
1933 p_LmCheckPolyRing1(a, r);
1935#ifndef PDIV_DEBUG
1936 _pPolyAssume2(p_GetShortExpVector(a, r) == sev_a, a, r);
1938
1939 if (sev_a & not_sev_b)
1940 {
1942 return FALSE;
1943 }
1944 return p_LmDivisibleByNoComp(a, b, r);
1945#else
1947#endif
1948}

◆ p_LowVar()

int p_LowVar ( poly p,
const ring r )

the minimal index of used variables - 1

Definition at line 4730 of file p_polys.cc.

4731{
4732 int k,l,lex;
4733
4734 if (p == NULL) return -1;
4735
4736 k = 32000;/*a very large dummy value*/
4737 while (p != NULL)
4738 {
4739 l = 1;
4740 lex = p_GetExp(p,l,r);
4741 while ((l < (rVar(r))) && (lex == 0))
4742 {
4743 l++;
4744 lex = p_GetExp(p,l,r);
4745 }
4746 l--;
4747 if (l < k) k = l;
4748 pIter(p);
4749 }
4750 return k;
4751}

◆ p_LtCmp()

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

Definition at line 1621 of file p_polys.h.

1622{
1623 int res = p_LmCmp(p,q,r);
1624 if(res == 0)
1625 {
1626 if(p_GetCoeff(p,r) == NULL || p_GetCoeff(q,r) == NULL)
1627 return res;
1628 number pc = n_Copy(p_GetCoeff(p,r),r->cf);
1629 number qc = n_Copy(p_GetCoeff(q,r),r->cf);
1630 if(!n_GreaterZero(pc,r->cf))
1631 pc = n_InpNeg(pc,r->cf);
1632 if(!n_GreaterZero(qc,r->cf))
1633 qc = n_InpNeg(qc,r->cf);
1634 if(n_Greater(pc,qc,r->cf))
1635 res = 1;
1636 else if(n_Greater(qc,pc,r->cf))
1637 res = -1;
1638 else if(n_Equal(pc,qc,r->cf))
1639 res = 0;
1640 n_Delete(&pc,r->cf);
1641 n_Delete(&qc,r->cf);
1642 }
1643 return res;
1644}
static FORCE_INLINE BOOLEAN n_Greater(number a, number b, const coeffs r)
ordered fields: TRUE iff 'a' is larger than 'b'; in Z/pZ: TRUE iff la > lb, where la and lb are the l...
Definition coeffs.h:515

◆ p_LtCmpNoAbs()

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

Definition at line 1647 of file p_polys.h.

1648{
1649 int res = p_LmCmp(p,q,r);
1650 if(res == 0)
1651 {
1652 if(p_GetCoeff(p,r) == NULL || p_GetCoeff(q,r) == NULL)
1653 return res;
1654 number pc = p_GetCoeff(p,r);
1655 number qc = p_GetCoeff(q,r);
1656 if(n_Greater(pc,qc,r->cf))
1657 res = 1;
1658 if(n_Greater(qc,pc,r->cf))
1659 res = -1;
1660 if(n_Equal(pc,qc,r->cf))
1661 res = 0;
1662 }
1663 return res;
1664}

◆ p_LtCmpOrdSgnDiffM()

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

Definition at line 1669 of file p_polys.h.

1670{
1671 return(p_LtCmp(p,q,r) == r->OrdSgn);
1672}
static int p_LtCmp(poly p, poly q, const ring r)
Definition p_polys.h:1621

◆ p_LtCmpOrdSgnDiffP()

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

Definition at line 1678 of file p_polys.h.

1679{
1680 if(r->OrdSgn == 1)
1681 {
1682 return(p_LmCmp(p,q,r) == -1);
1683 }
1684 else
1685 {
1686 return(p_LtCmp(p,q,r) != -1);
1687 }
1688}

◆ p_LtCmpOrdSgnEqM()

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

Definition at line 1694 of file p_polys.h.

1695{
1696 return(p_LtCmp(p,q,r) == -r->OrdSgn);
1697}

◆ p_LtCmpOrdSgnEqP()

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

Definition at line 1703 of file p_polys.h.

1704{
1705 return(p_LtCmp(p,q,r) == r->OrdSgn);
1706}

◆ p_MaxComp() [1/2]

static long p_MaxComp ( poly p,
ring lmRing )
inlinestatic

Definition at line 311 of file p_polys.h.

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

◆ p_MaxComp() [2/2]

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

Definition at line 292 of file p_polys.h.

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

◆ p_MaxExpPerVar()

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

max exponent of variable x_i in p

Definition at line 5042 of file p_polys.cc.

5043{
5044 int m=0;
5045 while(p!=NULL)
5046 {
5047 int mm=p_GetExp(p,i,r);
5048 if (mm>m) m=mm;
5049 pIter(p);
5050 }
5051 return m;
5052}

◆ p_MDivide()

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

Definition at line 1495 of file p_polys.cc.

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

◆ p_MemAdd_NegWeightAdjust()

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

Definition at line 1292 of file p_polys.h.

1293{
1294 if (r->NegWeightL_Offset != NULL)
1295 {
1296 for (int i=r->NegWeightL_Size-1; i>=0; i--)
1297 {
1298 p->exp[r->NegWeightL_Offset[i]] -= POLY_NEGWEIGHT_OFFSET;
1299 }
1300 }
1301}

◆ p_MemSub_NegWeightAdjust()

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

Definition at line 1302 of file p_polys.h.

1303{
1304 if (r->NegWeightL_Offset != NULL)
1305 {
1306 for (int i=r->NegWeightL_Size-1; i>=0; i--)
1307 {
1308 p->exp[r->NegWeightL_Offset[i]] += POLY_NEGWEIGHT_OFFSET;
1309 }
1310 }
1311}

◆ p_Merge_q()

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

Definition at line 1212 of file p_polys.h.

1213{
1214 assume( (p != q) || (p == NULL && q == NULL) );
1215 return r->p_Procs->p_Merge_q(p, q, r);
1216}

◆ p_MinComp() [1/2]

static long p_MinComp ( poly p,
ring lmRing )
inlinestatic

Definition at line 332 of file p_polys.h.

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

◆ p_MinComp() [2/2]

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

Definition at line 313 of file p_polys.h.

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

◆ p_MinDeg()

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

Definition at line 4498 of file p_polys.cc.

4499{
4500 if(p==NULL)
4501 return -1;
4502 int d=-1;
4503 while(p!=NULL)
4504 {
4505 int d0=0;
4506 for(int j=0;j<rVar(R);j++)
4507 if(w==NULL||j>=w->length())
4508 d0+=p_GetExp(p,j+1,R);
4509 else
4510 d0+=(*w)[j]*p_GetExp(p,j+1,R);
4511 if(d0<d||d==-1)
4512 d=d0;
4513 pIter(p);
4514 }
4515 return d;
4516}

◆ p_mInit()

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

Definition at line 1445 of file p_polys.cc.

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

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

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

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

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

◆ p_mm_Mult()

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

Definition at line 1061 of file p_polys.h.

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

◆ p_Mult_mm()

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

Definition at line 1051 of file p_polys.h.

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

◆ p_Mult_nn() [1/2]

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

Definition at line 973 of file p_polys.h.

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

◆ p_Mult_nn() [2/2]

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

Definition at line 958 of file p_polys.h.

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

◆ p_Mult_q()

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

Definition at line 1114 of file p_polys.h.

1115{
1116 assume( (p != q) || (p == NULL && q == NULL) );
1117
1118 if (p == NULL)
1119 {
1120 p_Delete(&q, r);
1121 return NULL;
1122 }
1123 if (q == NULL)
1124 {
1125 p_Delete(&p, r);
1126 return NULL;
1127 }
1128
1129 if (pNext(p) == NULL)
1130 {
1131 q = r->p_Procs->p_mm_Mult(q, p, r);
1132 p_LmDelete(&p, r);
1133 return q;
1134 }
1135
1136 if (pNext(q) == NULL)
1137 {
1138 p = r->p_Procs->p_Mult_mm(p, q, r);
1139 p_LmDelete(&q, r);
1140 return p;
1141 }
1142#if defined(HAVE_PLURAL) || defined(HAVE_SHIFTBBA)
1143 if (rIsNCRing(r))
1144 return _nc_p_Mult_q(p, q, r);
1145 else
1146#endif
1147 return _p_Mult_q(p, q, 0, r);
1148}
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:313

◆ p_MultExp()

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

Definition at line 621 of file p_polys.h.

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

◆ p_Neg()

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

Definition at line 1107 of file p_polys.h.

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

◆ p_New() [1/2]

static poly p_New ( const ring ,
omBin bin )
inlinestatic

Definition at line 664 of file p_polys.h.

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

◆ p_New() [2/2]

static poly p_New ( ring r)
inlinestatic

Definition at line 675 of file p_polys.h.

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

◆ p_Norm()

void p_Norm ( poly p1,
const ring r )

Definition at line 3741 of file p_polys.cc.

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

◆ p_Normalize()

void p_Normalize ( poly p,
const ring r )

Definition at line 3835 of file p_polys.cc.

3836{
3837 const coeffs cf=r->cf;
3838 /* Z/p, GF(p,n), R, long R/C, Nemo rings */
3839 if (cf->cfNormalize==ndNormalize)
3840 return;
3841 while (p!=NULL)
3842 {
3843 // no test befor n_Normalize: n_Normalize should fix problems
3845 pIter(p);
3846 }
3847}
void ndNormalize(number &, const coeffs)
Definition numbers.cc:187

◆ p_NSet()

poly p_NSet ( number n,
const ring r )

returns the poly representing the number n, destroys n

Definition at line 1476 of file p_polys.cc.

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

◆ p_One()

poly p_One ( const ring r)

Definition at line 1316 of file p_polys.cc.

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

◆ p_OneComp()

BOOLEAN p_OneComp ( poly p,
const ring r )

return TRUE if all monoms have the same component

Definition at line 1211 of file p_polys.cc.

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

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

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

1206{
1207 int lp = 0, lq = 0;
1208 return p_Plus_mm_Mult_qq(p, m, q, lp, lq, r);
1209}
static poly p_Plus_mm_Mult_qq(poly p, poly m, poly q, int &lp, int lq, const ring r)
Definition p_polys.h:1183

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

1185{
1186#ifdef HAVE_PLURAL
1187 if (rIsPluralRing(r))
1188 return nc_p_Plus_mm_Mult_qq(p, m, q, lp, lq, r);
1189#endif
1190
1191// this should be implemented more efficiently
1192 poly res;
1193 int shorter;
1195 number n_neg = n_Copy(n_old, r->cf);
1196 n_neg = n_InpNeg(n_neg, r->cf);
1197 pSetCoeff0(m, n_neg);
1198 res = r->p_Procs->p_Minus_mm_Mult_qq(p, m, q, shorter, NULL, r);
1199 lp = (lp + lq) - shorter;
1200 pSetCoeff0(m, n_old);
1201 n_Delete(&n_neg, r->cf);
1202 return res;
1203}
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 1876 of file p_polys.cc.

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

◆ p_Power()

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

Definition at line 2203 of file p_polys.cc.

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

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

◆ p_Read()

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

Definition at line 1373 of file p_polys.cc.

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

4549{
4550 int *ww=iv2array(w,R);
4551 if(p!=NULL)
4552 {
4553 if(u==NULL)
4554 p=p_JetW(p,n,ww,R);
4555 else
4556 p=p_JetW(p_Mult_q(p,p_Invers(n-p_MinDeg(p,w,R),u,w,R),R),n,ww,R);
4557 }
4558 omFreeSize((ADDRESS)ww,(rVar(R)+1)*sizeof(int));
4559 return p;
4560}
static poly p_Invers(int n, poly u, intvec *w, const ring R)
Definition p_polys.cc:4519
int p_MinDeg(poly p, intvec *w, const ring R)
Definition p_polys.cc:4498
poly p_JetW(poly p, int m, int *w, const ring R)
Definition p_polys.cc:4480
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 412 of file p_polys.h.

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

◆ p_SetComp()

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

Definition at line 247 of file p_polys.h.

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

◆ p_SetCompP() [1/2]

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

Definition at line 281 of file p_polys.h.

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

◆ p_SetCompP() [2/2]

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

Definition at line 254 of file p_polys.h.

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

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

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

◆ p_SetExp() [2/3]

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

Definition at line 562 of file p_polys.h.

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

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

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

◆ p_SetExpV()

static void p_SetExpV ( poly p,
int * 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 p_SetExp(p, j, ev[j], r);
1549
1550 if(ev[0]!=0) p_SetComp(p, ev[0],r);
1551 p_Setm(p, r);
1552}

◆ p_SetExpVL()

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

Definition at line 1553 of file p_polys.h.

1554{
1556 for (unsigned j = r->N; j!=0; j--)
1557 p_SetExp(p, j, ev[j-1], r);
1558 p_SetComp(p, 0,r);
1559
1560 p_Setm(p, r);
1561}

◆ p_SetExpVLV()

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

Definition at line 1564 of file p_polys.h.

1565{
1567 for (unsigned j = r->N; j!=0; j--)
1568 p_SetExp(p, j, ev[j-1], r);
1569 p_SetComp(p, comp,r);
1570
1571 p_Setm(p, r);
1572}
int comp(const CanonicalForm &A, const CanonicalForm &B)
compare polynomials

◆ p_Setm()

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

Definition at line 233 of file p_polys.h.

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

◆ p_SetModDeg()

void p_SetModDeg ( intvec * w,
ring r )

Definition at line 3695 of file p_polys.cc.

3696{
3697 if (w!=NULL)
3698 {
3699 r->pModW = w;
3700 pOldFDeg = r->pFDeg;
3701 pOldLDeg = r->pLDeg;
3702 pOldLexOrder = r->pLexOrder;
3704 r->pLexOrder = TRUE;
3705 }
3706 else
3707 {
3708 r->pModW = NULL;
3710 r->pLexOrder = pOldLexOrder;
3711 }
3712}
STATIC_VAR pLDegProc pOldLDeg
Definition p_polys.cc:3683
void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
Definition p_polys.cc:3671
STATIC_VAR BOOLEAN pOldLexOrder
Definition p_polys.cc:3684
STATIC_VAR pFDegProc pOldFDeg
Definition p_polys.cc:3682
void pSetDegProcs(ring r, pFDegProc new_FDeg, pLDegProc new_lDeg)
Definition p_polys.cc:3659
static long pModDeg(poly p, ring r)
Definition p_polys.cc:3686

◆ p_ShallowCopyDelete()

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

Definition at line 928 of file p_polys.h.

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

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

4757{
4758 poly qp1 = *p,qp2 = *p;/*working pointers*/
4759 int j = p_MaxComp(*p,r),k = p_MinComp(*p,r);
4760
4761 if (j+i < 0) return ;
4762 BOOLEAN toPoly= ((j == -i) && (j == k));
4763 while (qp1 != NULL)
4764 {
4765 if (toPoly || (__p_GetComp(qp1,r)+i > 0))
4766 {
4767 p_AddComp(qp1,i,r);
4768 p_SetmComp(qp1,r);
4769 qp2 = qp1;
4770 pIter(qp1);
4771 }
4772 else
4773 {
4774 if (qp2 == *p)
4775 {
4776 pIter(*p);
4777 p_LmDelete(&qp2,r);
4778 qp2 = *p;
4779 qp1 = *p;
4780 }
4781 else
4782 {
4783 qp2->next = qp1->next;
4784 if (qp1!=NULL) p_LmDelete(&qp1,r);
4785 qp1 = qp2->next;
4786 }
4787 }
4788 }
4789}
return
static unsigned long p_AddComp(poly p, unsigned long v, ring r)
Definition p_polys.h:447

◆ p_SimpleContent()

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

Definition at line 2570 of file p_polys.cc.

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

◆ p_Size()

int p_Size ( poly p,
const ring r )

Definition at line 3259 of file p_polys.cc.

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

◆ p_SortAdd()

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

Definition at line 1219 of file p_polys.h.

1220{
1221 if (revert) p = pReverse(p);
1222 return sBucketSortAdd(p, r);
1223}
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 1229 of file p_polys.h.

1230{
1231 if (revert) p = pReverse(p);
1232 return sBucketSortMerge(p, r);
1233}
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 1323 of file p_polys.cc.

1324{
1325 *h=pNext(p);
1326 pNext(p)=NULL;
1327}

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

1241{
1242 return p_String(p, p_ring, p_ring);
1243}
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 1244 of file p_polys.h.

1245{
1247}
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!) UGLYNESS
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!) UGLYNESS
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 1996 of file p_polys.cc.

1997{
1998 return p_Add_q(p1, p_Neg(p2,r),r);
1999}

◆ p_SubComp()

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

Definition at line 453 of file p_polys.h.

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

◆ p_SubExp()

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

Definition at line 613 of file p_polys.h.

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

◆ p_Subst()

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

Definition at line 3980 of file p_polys.cc.

3981{
3982#ifdef HAVE_SHIFTBBA
3983 // also don't even use p_Subst0 for Letterplace
3984 if (rIsLPRing(r))
3985 {
3986 poly subst = p_LPSubst(p, n, e, r);
3987 p_Delete(&p, r);
3988 return subst;
3989 }
3990#endif
3991
3992 if (e == NULL) return p_Subst0(p, n,r);
3993
3994 if (p_IsConstant(e,r))
3995 {
3996 if (n_IsOne(pGetCoeff(e),r->cf)) return p_Subst1(p,n,r);
3997 else return p_Subst2(p, n, pGetCoeff(e),r);
3998 }
3999
4000#ifdef HAVE_PLURAL
4001 if (rIsPluralRing(r))
4002 {
4003 return nc_pSubst(p,n,e,r);
4004 }
4005#endif
4006
4007 int exponent,i;
4008 poly h, res, m;
4009 int *me,*ee;
4010 number nu,nu1;
4011
4012 me=(int *)omAlloc((rVar(r)+1)*sizeof(int));
4013 ee=(int *)omAlloc((rVar(r)+1)*sizeof(int));
4014 if (e!=NULL) p_GetExpV(e,ee,r);
4015 res=NULL;
4016 h=p;
4017 while (h!=NULL)
4018 {
4019 if ((e!=NULL) || (p_GetExp(h,n,r)==0))
4020 {
4021 m=p_Head(h,r);
4022 p_GetExpV(m,me,r);
4023 exponent=me[n];
4024 me[n]=0;
4025 for(i=rVar(r);i>0;i--)
4026 me[i]+=exponent*ee[i];
4027 p_SetExpV(m,me,r);
4028 if (e!=NULL)
4029 {
4030 n_Power(pGetCoeff(e),exponent,&nu,r->cf);
4031 nu1=n_Mult(pGetCoeff(m),nu,r->cf);
4032 n_Delete(&nu,r->cf);
4033 p_SetCoeff(m,nu1,r);
4034 }
4035 res=p_Add_q(res,m,r);
4036 }
4037 p_LmDelete(&h,r);
4038 }
4039 omFreeSize((ADDRESS)me,(rVar(r)+1)*sizeof(int));
4040 omFreeSize((ADDRESS)ee,(rVar(r)+1)*sizeof(int));
4041 return res;
4042}
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:3955
static poly p_Subst1(poly p, int n, const ring r)
Definition p_polys.cc:3887
static poly p_Subst2(poly p, int n, number e, const ring r)
Definition p_polys.cc:3914
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 3441 of file p_polys.cc.

3442{
3443 poly q = *p,qq=NULL,result = NULL;
3444
3445 if (q==NULL) return NULL;
3447 if (__p_GetComp(q,r)==k)
3448 {
3449 result = q;
3451 {
3452 do
3453 {
3454 p_SetComp(q,0,r);
3455 p_SetmComp(q,r);
3456 qq = q;
3457 pIter(q);
3458 }
3459 while ((q!=NULL) && (__p_GetComp(q,r)==k));
3460 }
3461 else
3462 {
3463 do
3464 {
3465 p_SetComp(q,0,r);
3466 qq = q;
3467 pIter(q);
3468 }
3469 while ((q!=NULL) && (__p_GetComp(q,r)==k));
3470 }
3471
3472 *p = q;
3473 pNext(qq) = NULL;
3474 }
3475 if (q==NULL) return result;
3476 if (__p_GetComp(q,r) > k)
3477 {
3478 p_SubComp(q,1,r);
3479 if (use_setmcomp) p_SetmComp(q,r);
3480 }
3481 poly pNext_q;
3482 while ((pNext_q=pNext(q))!=NULL)
3483 {
3484 long c=__p_GetComp(pNext_q,r);
3485 if (/*__p_GetComp(pNext_q,r)*/c==k)
3486 {
3487 if (result==NULL)
3488 {
3489 result = pNext_q;
3490 qq = result;
3491 }
3492 else
3493 {
3494 pNext(qq) = pNext_q;
3495 pIter(qq);
3496 }
3497 pNext(q) = pNext(pNext_q);
3498 pNext(qq) =NULL;
3499 p_SetComp(qq,0,r);
3500 if (use_setmcomp) p_SetmComp(qq,r);
3501 }
3502 else
3503 {
3504 /*pIter(q);*/ q=pNext_q;
3505 if (/*__p_GetComp(q,r)*/c > k)
3506 {
3507 p_SubComp(q,1,r);
3508 if (use_setmcomp) p_SetmComp(q,r);
3509 }
3510 }
3511 }
3512 return result;
3513}

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

3518{
3519 spolyrec pp, qq;
3520 poly p, q, p_prev;
3521 int l = 0;
3522
3523#ifndef SING_NDEBUG
3524 int lp = pLength(*r_p);
3525#endif
3526
3527 pNext(&pp) = *r_p;
3528 p = *r_p;
3529 p_prev = &pp;
3530 q = &qq;
3531
3532 while(p != NULL)
3533 {
3534 while (__p_GetComp(p,r) == comp)
3535 {
3536 pNext(q) = p;
3537 pIter(q);
3538 p_SetComp(p, 0,r);
3539 p_SetmComp(p,r);
3540 pIter(p);
3541 l++;
3542 if (p == NULL)
3543 {
3544 pNext(p_prev) = NULL;
3545 goto Finish;
3546 }
3547 }
3548 pNext(p_prev) = p;
3549 p_prev = p;
3550 pIter(p);
3551 }
3552
3553 Finish:
3554 pNext(q) = NULL;
3555 *r_p = pNext(&pp);
3556 *r_q = pNext(&qq);
3557 *lq = l;
3558#ifndef SING_NDEBUG
3559 assume(pLength(*r_p) + pLength(*r_q) == (unsigned)lp);
3560#endif
3561 p_Test(*r_p,r);
3562 p_Test(*r_q,r);
3563}

◆ p_Totaldegree()

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

Definition at line 1507 of file p_polys.h.

1508{
1510 unsigned long s = p_GetTotalDegree(p->exp[r->VarL_Offset[0]],
1511 r,
1512 r->ExpPerLong);
1513 for (unsigned i=r->VarL_Size-1; i!=0; i--)
1514 {
1515 s += p_GetTotalDegree(p->exp[r->VarL_Offset[i]], r,r->ExpPerLong);
1516 }
1517 return (long)s;
1518}
static unsigned long p_GetTotalDegree(const unsigned long l, const ring r, const int number_of_exps)
Definition p_polys.h:810

◆ p_Var()

int p_Var ( poly mi,
const ring r )

Definition at line 4706 of file p_polys.cc.

4707{
4708 if (m==NULL) return 0;
4709 if (pNext(m)!=NULL) return 0;
4710 int i,e=0;
4711 for (i=rVar(r); i>0; i--)
4712 {
4713 int exp=p_GetExp(m,i,r);
4714 if (exp==1)
4715 {
4716 if (e==0) e=i;
4717 else return 0;
4718 }
4719 else if (exp!=0)
4720 {
4721 return 0;
4722 }
4723 }
4724 return e;
4725}

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

3618{
3619 poly h;
3620 int k;
3621
3622 for(int i=len-1;i>=0;i--) p[i]=NULL;
3623 while (v!=NULL)
3624 {
3625 h=p_Head(v,r);
3626 k=__p_GetComp(h,r);
3627 if (k>len) { Werror("wrong rank:%d, should be %d",len,k); }
3628 else
3629 {
3630 p_SetComp(h,0,r);
3631 p_Setm(h,r);
3632 pNext(h)=p[k-1];p[k-1]=h;
3633 }
3634 pIter(v);
3635 }
3636 for(int i=len-1;i>=0;i--)
3637 {
3638 if (p[i]!=NULL) p[i]=pReverse(p[i]);
3639 }
3640}

◆ p_Vec2Poly()

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

Definition at line 3595 of file p_polys.cc.

3596{
3597 poly h;
3598 poly res=NULL;
3599 long unsigned kk=k;
3600
3601 while (v!=NULL)
3602 {
3603 if (__p_GetComp(v,r)==kk)
3604 {
3605 h=p_Head(v,r);
3606 p_SetComp(h,0,r);
3607 pNext(h)=res;res=h;
3608 }
3609 pIter(v);
3610 }
3611 if (res!=NULL) res=pReverse(res);
3612 return res;
3613}

◆ p_Vec2Polys()

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

Definition at line 3647 of file p_polys.cc.

3648{
3649 *len=p_MaxComp(v,r);
3650 if (*len==0) *len=1;
3651 *p=(poly*)omAlloc((*len)*sizeof(poly));
3652 p_Vec2Array(v,*p,*len,r);
3653}
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:3617

◆ p_VectorHasUnit()

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

Definition at line 3408 of file p_polys.cc.

3409{
3410 poly q=p,qq;
3411 int j=0;
3412 long unsigned i;
3413
3414 *len = 0;
3415 while (q!=NULL)
3416 {
3417 if (p_LmIsConstantComp(q,r))
3418 {
3419 i = __p_GetComp(q,r);
3420 qq = p;
3421 while ((qq != q) && (__p_GetComp(qq,r) != i)) pIter(qq);
3422 if (qq == q)
3423 {
3424 j = 0;
3425 while (qq!=NULL)
3426 {
3427 if (__p_GetComp(qq,r)==i) j++;
3428 pIter(qq);
3429 }
3430 if ((*len == 0) || (j<*len))
3431 {
3432 *len = j;
3433 *k = i;
3434 }
3435 }
3436 }
3437 pIter(q);
3438 }
3439}

◆ p_VectorHasUnitB()

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

Definition at line 3385 of file p_polys.cc.

3386{
3387 poly q=p,qq;
3388 long unsigned i;
3389
3390 while (q!=NULL)
3391 {
3392 if (p_LmIsConstantComp(q,r))
3393 {
3394 i = __p_GetComp(q,r);
3395 qq = p;
3396 while ((qq != q) && (__p_GetComp(qq,r) != i)) pIter(qq);
3397 if (qq == q)
3398 {
3399 *k = i;
3400 return TRUE;
3401 }
3402 }
3403 pIter(q);
3404 }
3405 return FALSE;
3406}

◆ p_WDegree()

long p_WDegree ( poly p,
const ring r )

Definition at line 717 of file p_polys.cc.

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

◆ p_Weight()

int p_Weight ( int c,
const ring r )

Definition at line 708 of file p_polys.cc.

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

◆ p_WFirstTotalDegree()

long p_WFirstTotalDegree ( poly p,
ring r )

Definition at line 596 of file p_polys.cc.

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

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

1249{
1251}

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

1253{
1255}
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 1256 of file p_polys.h.

1257{
1258 p_wrp(p, p_ring, p_ring);
1259}
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 613 of file p_polys.cc.

614{
616 int i, k;
617 long j =0;
618
619 // iterate through each block:
620 for (i=0;r->order[i]!=0;i++)
621 {
622 int b0=r->block0[i];
623 int b1=r->block1[i];
624 switch(r->order[i])
625 {
626 case ringorder_M:
627 for (k=b0 /*r->block0[i]*/;k<=b1 /*r->block1[i]*/;k++)
628 { // in jedem block:
629 j+= p_GetExp(p,k,r)*r->wvhdl[i][k - b0 /*r->block0[i]*/]*r->OrdSgn;
630 }
631 break;
632 case ringorder_am:
633 b1=si_min(b1,r->N);
634 /* no break, continue as ringorder_a*/
635 case ringorder_a:
636 for (k=b0 /*r->block0[i]*/;k<=b1 /*r->block1[i]*/;k++)
637 { // only one line
638 j+= p_GetExp(p,k,r)*r->wvhdl[i][k - b0 /*r->block0[i]*/];
639 }
640 return j*r->OrdSgn;
641 case ringorder_wp:
642 case ringorder_ws:
643 case ringorder_Wp:
644 case ringorder_Ws:
645 for (k=b0 /*r->block0[i]*/;k<=b1 /*r->block1[i]*/;k++)
646 { // in jedem block:
647 j+= p_GetExp(p,k,r)*r->wvhdl[i][k - b0 /*r->block0[i]*/];
648 }
649 break;
650 case ringorder_lp:
651 case ringorder_ls:
652 case ringorder_rs:
653 case ringorder_dp:
654 case ringorder_ds:
655 case ringorder_Dp:
656 case ringorder_Ds:
657 case ringorder_rp:
658 for (k=b0 /*r->block0[i]*/;k<=b1 /*r->block1[i]*/;k++)
659 {
660 j+= p_GetExp(p,k,r);
661 }
662 break;
663 case ringorder_a64:
664 {
665 int64* w=(int64*)r->wvhdl[i];
666 for (k=0;k<=(b1 /*r->block1[i]*/ - b0 /*r->block0[i]*/);k++)
667 {
668 //there should be added a line which checks if w[k]>2^31
669 j+= p_GetExp(p,k+1, r)*(long)w[k];
670 }
671 //break;
672 return j;
673 }
674 default:
675 #if 0
676 case ringorder_c: /* nothing to do*/
677 case ringorder_C: /* nothing to do*/
678 case ringorder_S: /* nothing to do*/
679 case ringorder_s: /* nothing to do*/
680 case ringorder_IS: /* nothing to do */
681 case ringorder_unspec: /* to make clang happy, does not occur*/
682 case ringorder_no: /* to make clang happy, does not occur*/
683 case ringorder_L: /* to make clang happy, does not occur*/
684 case ringorder_aa: /* ignored by p_WTotaldegree*/
685 #endif
686 break;
687 /* no default: all orderings covered */
688 }
689 }
690 return j;
691}
#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 3718 of file p_polys.cc.

3719{
3720 poly* h;
3721
3722 if (increment==0) return;
3723 if (*p==NULL)
3724 {
3725 h=(poly*)omAlloc0(increment*sizeof(poly));
3726 }
3727 else
3728 {
3729 h=(poly*)omReallocSize((poly*)*p,l*sizeof(poly),(l+increment)*sizeof(poly));
3730 if (increment>0)
3731 {
3732 memset(&(h[l]),0,increment*sizeof(poly));
3733 }
3734 }
3735 *p=h;
3736}
#define omReallocSize(addr, o_size, size)

◆ pHaveCommonMonoms()

BOOLEAN pHaveCommonMonoms ( poly p,
poly q )

Definition at line 178 of file pDebug.cc.

179{
180 while (p != NULL)
181 {
182 if (pIsMonomOf(q, p))
183 {
184 return TRUE;
185 }
186 pIter(p);
187 }
188 return FALSE;
189}
BOOLEAN pIsMonomOf(poly p, poly m)
Definition pDebug.cc:168

◆ pIsMonomOf()

BOOLEAN pIsMonomOf ( poly p,
poly m )

Definition at line 168 of file pDebug.cc.

169{
170 if (m == NULL) return TRUE;
171 while (p != NULL)
172 {
173 if (p == m) return TRUE;
174 pIter(p);
175 }
176 return FALSE;
177}

◆ pLDeg0()

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

Definition at line 742 of file p_polys.cc.

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

◆ pLDeg0c()

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

Definition at line 773 of file p_polys.cc.

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

◆ pLDeg1()

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

Definition at line 844 of file p_polys.cc.

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

◆ pLDeg1_Deg()

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

Definition at line 913 of file p_polys.cc.

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

◆ pLDeg1_Totaldegree()

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

Definition at line 978 of file p_polys.cc.

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

◆ pLDeg1_WFirstTotalDegree()

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

Definition at line 1041 of file p_polys.cc.

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

◆ pLDeg1c()

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

Definition at line 880 of file p_polys.cc.

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

◆ pLDeg1c_Deg()

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

Definition at line 944 of file p_polys.cc.

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

◆ pLDeg1c_Totaldegree()

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

Definition at line 1008 of file p_polys.cc.

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

◆ pLDeg1c_WFirstTotalDegree()

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

Definition at line 1071 of file p_polys.cc.

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

◆ pLDegb()

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

Definition at line 814 of file p_polys.cc.

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

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

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

◆ pp_Jet()

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

Definition at line 4380 of file p_polys.cc.

4381{
4382 poly r=NULL;
4383 poly t=NULL;
4384
4385 while (p!=NULL)
4386 {
4387 if (p_Totaldegree(p,R)<=m)
4388 {
4389 if (r==NULL)
4390 r=p_Head(p,R);
4391 else
4392 if (t==NULL)
4393 {
4394 pNext(r)=p_Head(p,R);
4395 t=pNext(r);
4396 }
4397 else
4398 {
4399 pNext(t)=p_Head(p,R);
4400 pIter(t);
4401 }
4402 }
4403 pIter(p);
4404 }
4405 return r;
4406}

◆ pp_Jet0()

poly pp_Jet0 ( poly p,
const ring R )

Definition at line 4408 of file p_polys.cc.

4409{
4410 poly r=NULL;
4411 poly t=NULL;
4412
4413 while (p!=NULL)
4414 {
4415 if (p_LmIsConstantComp(p,R))
4416 {
4417 if (r==NULL)
4418 r=p_Head(p,R);
4419 else
4420 if (t==NULL)
4421 {
4422 pNext(r)=p_Head(p,R);
4423 t=pNext(r);
4424 }
4425 else
4426 {
4427 pNext(t)=p_Head(p,R);
4428 pIter(t);
4429 }
4430 }
4431 pIter(p);
4432 }
4433 return r;
4434}

◆ pp_JetW()

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

Definition at line 4453 of file p_polys.cc.

4454{
4455 poly r=NULL;
4456 poly t=NULL;
4457 while (p!=NULL)
4458 {
4459 if (totaldegreeWecart_IV(p,R,w)<=m)
4460 {
4461 if (r==NULL)
4462 r=p_Head(p,R);
4463 else
4464 if (t==NULL)
4465 {
4466 pNext(r)=p_Head(p,R);
4467 t=pNext(r);
4468 }
4469 else
4470 {
4471 pNext(t)=p_Head(p,R);
4472 pIter(t);
4473 }
4474 }
4475 pIter(p);
4476 }
4477 return r;
4478}

◆ pp_mm_Mult()

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

Definition at line 1041 of file p_polys.h.

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

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

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

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

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

◆ pp_Mult_mm()

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

Definition at line 1031 of file p_polys.h.

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

◆ pp_Mult_nn()

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

Definition at line 992 of file p_polys.h.

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

◆ pp_Mult_qq()

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

Definition at line 1151 of file p_polys.h.

1152{
1153 if (p == NULL || q == NULL) return NULL;
1154
1155 if (pNext(p) == NULL)
1156 {
1157 return r->p_Procs->pp_mm_Mult(q, p, r);
1158 }
1159
1160 if (pNext(q) == NULL)
1161 {
1162 return r->p_Procs->pp_Mult_mm(p, q, r);
1163 }
1164
1165 poly qq = q;
1166 if (p == q)
1167 qq = p_Copy(q, r);
1168
1169 poly res;
1170#if defined(HAVE_PLURAL) || defined(HAVE_SHIFTBBA)
1171 if (rIsNCRing(r))
1172 res = _nc_pp_Mult_qq(p, qq, r);
1173 else
1174#endif
1175 res = _p_Mult_q(p, qq, 1, r);
1176
1177 if (qq != q)
1178 p_Delete(&qq, r);
1179 return res;
1180}
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 3671 of file p_polys.cc.

3672{
3673 assume(old_FDeg != NULL && old_lDeg != NULL);
3674 r->pFDeg = old_FDeg;
3675 r->pLDeg = old_lDeg;
3676}

◆ pReverse()

static poly pReverse ( poly p)
inlinestatic

Definition at line 335 of file p_polys.h.

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

◆ pSetDegProcs()

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

Definition at line 3659 of file p_polys.cc.

3660{
3661 assume(new_FDeg != NULL);
3662 r->pFDeg = new_FDeg;
3663
3664 if (new_lDeg == NULL)
3665 new_lDeg = r->pLDegOrig;
3666
3667 r->pLDeg = new_lDeg;
3668}