My Project
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_GetShortExpVector (const poly p, const poly pp, const ring r)
 p_GetShortExpVector of p * pp More...
 
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 More...
 
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 More...
 
int p_IsPurePower (const poly p, const ring r)
 return i, if head depends only on var(i) More...
 
int p_IsUnivariate (poly p, const ring r)
 return i, if poly depends only on var(i) More...
 
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) More...
 
poly p_ISet (long i, const ring r)
 returns the poly representing the integer i More...
 
poly p_NSet (number n, const ring r)
 returns the poly representing the number n, destroys n More...
 
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)) More...
 
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 unsigned 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_Content_n (poly p, number &c, 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)
 
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 More...
 
char * p_String (poly p, ring lmRing, ring tailRing)
 
void p_Write (poly p, ring lmRing, ring tailRing)
 
void p_Write0 (poly p, ring lmRing, ring tailRing)
 
void p_wrp (poly p, ring lmRing, ring tailRing)
 
void p_String0Short (const poly p, ring lmRing, ring tailRing)
 print p in a short way, if possible More...
 
void p_String0Long (const poly p, ring lmRing, ring tailRing)
 print p in a long way More...
 
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 More...
 
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: More...
 
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 More...
 
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 More...
 
static long p_SetExp (poly p, const int v, const long e, const ring r)
 set v^th exponent for a monomial More...
 
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 More...
 
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 More...
 
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) More...
 
static poly p_Copy (poly p, const ring r)
 returns a copy of p More...
 
static poly p_Head (const poly p, const ring r)
 copy the (leading) term of p More...
 
poly p_Head0 (const poly p, const ring r)
 like p_Head, but allow NULL coeff More...
 
poly p_CopyPowerProduct (const poly p, const ring r)
 like p_Head, but with coefficient 1 More...
 
poly p_CopyPowerProduct0 (const poly p, const number n, const ring r)
 like p_Head, but with coefficient n More...
 
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 More...
 
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) More...
 
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) More...
 
static poly p_Mult_q (poly p, poly q, const ring r)
 
static poly pp_Mult_qq (poly p, poly q, const ring r)
 
static poly p_Plus_mm_Mult_qq (poly p, poly m, poly q, int &lp, int lq, const ring r)
 
static poly p_Plus_mm_Mult_qq (poly p, poly m, poly q, const ring r)
 
static poly p_Merge_q (poly p, poly q, const ring r)
 
static poly p_SortAdd (poly p, const ring r, BOOLEAN revert=FALSE)
 
static poly p_SortMerge (poly p, const ring r, BOOLEAN revert=FALSE)
 
static char * p_String (poly p, ring p_ring)
 
static void p_String0 (poly p, ring p_ring)
 
static void p_Write (poly p, ring p_ring)
 
static void p_Write0 (poly p, ring p_ring)
 
static void p_wrp (poly p, ring p_ring)
 
static void p_MemAdd_NegWeightAdjust (poly p, const ring r)
 
static void p_MemSub_NegWeightAdjust (poly p, const ring r)
 
static void p_ExpVectorCopy (poly d_p, poly s_p, const ring r)
 
static poly p_Init (const ring r, omBin bin)
 
static poly p_Init (const ring r)
 
static poly p_LmInit (poly p, const ring r)
 
static poly p_LmInit (poly s_p, const ring s_r, const ring d_r, omBin d_bin)
 
static poly p_LmInit (poly s_p, const ring s_r, const ring d_r)
 
static poly p_GetExp_k_n (poly p, int l, int k, const ring r)
 
static poly p_LmShallowCopyDelete (poly p, const ring r)
 
static void p_ExpVectorAdd (poly p1, poly p2, const ring r)
 
static void p_ExpVectorSum (poly pr, poly p1, poly p2, const ring r)
 
static void p_ExpVectorSub (poly p1, poly p2, const ring r)
 
static void p_ExpVectorAddSub (poly p1, poly p2, poly p3, const ring r)
 
static void p_ExpVectorDiff (poly pr, poly p1, poly p2, const ring r)
 
static BOOLEAN p_ExpVectorEqual (poly p1, poly p2, const ring r)
 
static long p_Totaldegree (poly p, const ring r)
 
static void p_GetExpV (poly p, int *ev, const ring r)
 
static void p_GetExpVL (poly p, int64 *ev, const ring r)
 
static int64 p_GetExpVLV (poly p, int64 *ev, const ring r)
 
static void p_SetExpV (poly p, int *ev, const ring r)
 
static void p_SetExpVL (poly p, int64 *ev, const ring r)
 
static void p_SetExpVLV (poly p, int64 *ev, int64 comp, const ring r)
 
static int p_LmCmp (poly p, poly q, const ring r)
 
static int p_LtCmp (poly p, poly q, const ring r)
 
static int p_LtCmpNoAbs (poly p, poly q, const ring r)
 
static int p_LtCmpOrdSgnDiffM (poly p, poly q, const ring r)
 
static int p_LtCmpOrdSgnDiffP (poly p, poly q, const ring r)
 
static int p_LtCmpOrdSgnEqM (poly p, poly q, const ring r)
 
static int p_LtCmpOrdSgnEqP (poly p, poly q, const ring r)
 
BOOLEAN p_ComparePolys (poly p1, poly p2, const ring r)
 returns TRUE if p1 is a skalar multiple of p2 assume p1 != NULL and p2 != NULL More...
 
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 More...
 
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_LmDivisibleBy (poly a, const ring r_a, poly b, const ring r_b)
 
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_DivisibleBy (poly a, const ring r_a, poly b, const ring r_b)
 
static BOOLEAN p_LmDivisibleBy (poly a, const ring r_a, poly b, const ring r_b)
 
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_LmShortDivisibleBy (poly a, unsigned long sev_a, const ring r_a, poly b, unsigned long not_sev_b, const ring r_b)
 
static BOOLEAN p_IsConstantComp (const poly p, const ring r)
 like the respective p_LmIs* routines, except that p might be empty More...
 
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)?! More...
 
static BOOLEAN p_IsConstantPoly (const poly p, const ring r)
 
static BOOLEAN p_IsUnit (const poly p, const ring r)
 
static BOOLEAN p_LmExpVectorAddIsOk (const poly p1, const poly p2, const ring r)
 
void p_Split (poly p, poly *r)
 
BOOLEAN p_HasNotCF (poly p1, poly p2, const ring r)
 
BOOLEAN p_HasNotCFRing (poly p1, poly p2, const ring r)
 
poly p_mInit (const char *s, BOOLEAN &ok, const ring r)
 
const char * p_Read (const char *s, poly &p, const ring r)
 
poly p_MDivide (poly a, poly b, const ring r)
 
poly p_DivideM (poly a, poly b, const ring r)
 
poly pp_DivideM (poly a, poly b, const ring r)
 
poly p_Div_nn (poly p, const number n, const ring r)
 
void p_Lcm (const poly a, const poly b, poly m, const ring r)
 
poly p_Lcm (const poly a, const poly b, const ring r)
 
poly p_LcmRat (const poly a, const poly b, const long lCompM, const ring r)
 
poly p_GetCoeffRat (poly p, int ishift, ring r)
 
void p_LmDeleteAndNextRat (poly *p, int ishift, ring r)
 
void p_ContentRat (poly &ph, const ring r)
 
poly p_Diff (poly a, int k, const ring r)
 
poly p_DiffOp (poly a, poly b, BOOLEAN multiply, const ring r)
 
int p_Weight (int c, const ring r)
 
poly p_PolyDiv (poly &p, const poly divisor, const BOOLEAN needResult, const ring r)
 assumes that p and divisor are univariate polynomials in r, mentioning the same variable; assumes divisor != NULL; p may be NULL; assumes a global monomial ordering in r; performs polynomial division of p by divisor: More...
 
BOOLEAN p_VectorHasUnitB (poly p, int *k, const ring r)
 
void p_VectorHasUnit (poly p, int *k, int *len, const ring r)
 
poly p_TakeOutComp1 (poly *p, int k, const ring r)
 
void p_TakeOutComp (poly *p, long comp, poly *q, int *lq, const ring r)
 
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 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 More...
 
void p_Shift (poly *p, int i, const ring r)
 shifts components of the vector p by i More...
 
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 More...
 
poly p_Div_mm (poly p, const poly m, const ring r)
 divide polynomial by monomial More...
 
int p_MaxExpPerVar (poly p, int i, const ring r)
 max exponent of variable x_i in p More...
 

Macro Definition Documentation

◆ __p_Mult_nn

#define __p_Mult_nn (   p,
  n,
 
)    r->p_Procs->p_Mult_nn(p, n, r)

Definition at line 943 of file p_polys.h.

◆ __pp_Mult_nn

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

Definition at line 974 of file p_polys.h.

◆ _p_LmCmpAction

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

Definition at line 1248 of file p_polys.h.

◆ p_LmCmpAction

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

Definition at line 1699 of file p_polys.h.

◆ p_LmEqual

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

Definition at line 1703 of file p_polys.h.

◆ p_LmTest

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

Definition at line 163 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,
 
)    _p_Test(p, r, PDEBUG)

Definition at line 162 of file p_polys.h.

◆ pDivAssume

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

Definition at line 1254 of file p_polys.h.

◆ pIfThen

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

Definition at line 156 of file p_polys.h.

◆ pp_Test

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

Definition at line 164 of file p_polys.h.

Function Documentation

◆ _p_LmDivisibleBy() [1/2]

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

Definition at line 1855 of file p_polys.h.

1856{
1857 if (p_GetComp(a, r_a) == 0 || p_GetComp(a,r_a) == p_GetComp(b,r_b))
1858 return _p_LmDivisibleByNoComp(a, r_a, b, r_b);
1859 return FALSE;
1860}
#define FALSE
Definition: auxiliary.h:96
CanonicalForm b
Definition: cfModGcd.cc:4103
#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:1745

◆ _p_LmDivisibleBy() [2/2]

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

Definition at line 1849 of file p_polys.h.

1850{
1851 if (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r))
1852 return _p_LmDivisibleByNoComp(a, b, r);
1853 return FALSE;
1854}

◆ _p_LmDivisibleByNoComp() [1/2]

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

Definition at line 1794 of file p_polys.h.

1795{
1796 int i=r_a->N;
1797 pAssume1(r_a->N == r_b->N);
1798
1799 do
1800 {
1801 if (p_GetExp(a,i,r_a) > p_GetExp(b,i,r_b))
1802 return FALSE;
1803 i--;
1804 }
1805 while (i);
1806/*#ifdef HAVE_RINGS
1807 return n_DivBy(p_GetCoeff(b, r_b), p_GetCoeff(a, r_a), r_a->cf);
1808#else
1809*/
1810 return TRUE;
1811//#endif
1812}
#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 1745 of file p_polys.h.

1746{
1747 int i=r->VarL_Size - 1;
1748 unsigned long divmask = r->divmask;
1749 unsigned long la, lb;
1750
1751 if (r->VarL_LowIndex >= 0)
1752 {
1753 i += r->VarL_LowIndex;
1754 do
1755 {
1756 la = a->exp[i];
1757 lb = b->exp[i];
1758 if ((la > lb) ||
1759 (((la & divmask) ^ (lb & divmask)) != ((lb - la) & divmask)))
1760 {
1762 return FALSE;
1763 }
1764 i--;
1765 }
1766 while (i>=r->VarL_LowIndex);
1767 }
1768 else
1769 {
1770 do
1771 {
1772 la = a->exp[r->VarL_Offset[i]];
1773 lb = b->exp[r->VarL_Offset[i]];
1774 if ((la > lb) ||
1775 (((la & divmask) ^ (lb & divmask)) != ((lb - la) & divmask)))
1776 {
1778 return FALSE;
1779 }
1780 i--;
1781 }
1782 while (i>=0);
1783 }
1784/*#ifdef HAVE_RINGS
1785 pDivAssume(p_DebugLmDivisibleByNoComp(a, b, r) == n_DivBy(p_GetCoeff(b, r), p_GetCoeff(a, r), r->cf));
1786 return (!rField_is_Ring(r)) || n_DivBy(p_GetCoeff(b, r), p_GetCoeff(a, r), r->cf);
1787#else
1788*/
1790 return TRUE;
1791//#endif
1792}
BOOLEAN p_DebugLmDivisibleByNoComp(poly a, poly b, ring r)
Definition: pDebug.cc:141
#define pDivAssume(x)
Definition: p_polys.h:1254

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

1816{
1817 int i=end;
1818 pAssume1(r_a->N == r_b->N);
1819
1820 do
1821 {
1822 if (p_GetExp(a,i,r_a) > p_GetExp(b,i,r_b))
1823 return FALSE;
1824 i--;
1825 }
1826 while (i>=start);
1827/*#ifdef HAVE_RINGS
1828 return n_DivBy(p_GetCoeff(b, r_b), p_GetCoeff(a, r_a), r_a->cf);
1829#else
1830*/
1831 return TRUE;
1832//#endif
1833}

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

1835{
1836 if (p_GetComp(a, r_a) == 0 || p_GetComp(a,r_a) == p_GetComp(b,r_b))
1837 return _p_LmDivisibleByNoCompPart(a, r_a, b, r_b,start,end);
1838 return FALSE;
1839}
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:1815

◆ _p_LmTest()

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

Definition at line 323 of file pDebug.cc.

324{
325 if (level < 0 || p == NULL) return TRUE;
326 poly pnext = pNext(p);
327 pNext(p) = NULL;
328 BOOLEAN test_res = _p_Test(p, r, level);
329 pNext(p) = pnext;
330 return test_res;
331}
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:212

◆ _p_Mult_q()

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

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

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 {
340 fmpq_mpoly_ctx_t ctx;
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 {
355 nmod_mpoly_ctx_t ctx;
356 if (pure_polys && rField_is_Zp(r) && !convSingRFlintR(ctx,r))
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 {
370 fmpz_mpoly_ctx_t ctx;
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 && (((lq >= MIN_LENGTH_FACTORY)
389 && (r->cf->convSingNFactoryN!=ndConvSingNFactoryN))
391 && rField_is_Q(r))))
392 {
393 poly h=singclap_pmult(p,q,r);
394 if (!copy)
395 {
396 p_Delete(&p,r);
397 p_Delete(&q,r);
398 }
399 return h;
400 }
401 else
402 {
403 lp=pLength(p);
404 lq=pLength(q);
405 return _p_Mult_q_Bucket(p, lp, q, lq, copy, r);
406 }
407}
int l
Definition: cfEzgcd.cc:100
poly singclap_pmult(poly f, poly g, const ring r)
Definition: clapsing.cc:554
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:739
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:276
#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 void p_Delete(poly *p, const ring r)
Definition: p_polys.h:873
static unsigned pLength(poly a)
Definition: p_polys.h:191
static BOOLEAN rField_is_Z(const ring r)
Definition: ring.h:510
static BOOLEAN rField_is_Zp(const ring r)
Definition: ring.h:501
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:507

◆ _p_Test()

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

Definition at line 212 of file pDebug.cc.

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

◆ _pp_Test()

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

Definition at line 333 of file pDebug.cc.

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

◆ n_PermNumber()

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

Definition at line 4060 of file p_polys.cc.

4061{
4062#if 0
4063 PrintS("\nSource Ring: \n");
4064 rWrite(src);
4065
4066 if(0)
4067 {
4068 number zz = n_Copy(z, src->cf);
4069 PrintS("z: "); n_Write(zz, src);
4070 n_Delete(&zz, src->cf);
4071 }
4072
4073 PrintS("\nDestination Ring: \n");
4074 rWrite(dst);
4075
4076 /*Print("\nOldPar: %d\n", OldPar);
4077 for( int i = 1; i <= OldPar; i++ )
4078 {
4079 Print("par(%d) -> par/var (%d)\n", i, par_perm[i-1]);
4080 }*/
4081#endif
4082 if( z == NULL )
4083 return NULL;
4084
4085 const coeffs srcCf = src->cf;
4086 assume( srcCf != NULL );
4087
4088 assume( !nCoeff_is_GF(srcCf) );
4089 assume( src->cf->extRing!=NULL );
4090
4091 poly zz = NULL;
4092
4093 const ring srcExtRing = srcCf->extRing;
4094 assume( srcExtRing != NULL );
4095
4096 const coeffs dstCf = dst->cf;
4097 assume( dstCf != NULL );
4098
4099 if( nCoeff_is_algExt(srcCf) ) // nCoeff_is_GF(srcCf)?
4100 {
4101 zz = (poly) z;
4102 if( zz == NULL ) return NULL;
4103 }
4104 else if (nCoeff_is_transExt(srcCf))
4105 {
4106 assume( !IS0(z) );
4107
4108 zz = NUM((fraction)z);
4109 p_Test (zz, srcExtRing);
4110
4111 if( zz == NULL ) return NULL;
4112 if( !DENIS1((fraction)z) )
4113 {
4114 if (!p_IsConstant(DEN((fraction)z),srcExtRing))
4115 WarnS("Not defined: Cannot map a rational fraction and make a polynomial out of it! Ignoring the denominator.");
4116 }
4117 }
4118 else
4119 {
4120 assume (FALSE);
4121 WerrorS("Number permutation is not implemented for this data yet!");
4122 return NULL;
4123 }
4124
4125 assume( zz != NULL );
4126 p_Test (zz, srcExtRing);
4127
4128 nMapFunc nMap = n_SetMap(srcExtRing->cf, dstCf);
4129
4130 assume( nMap != NULL );
4131
4132 poly qq;
4133 if ((par_perm == NULL) && (rPar(dst) != 0 && rVar (srcExtRing) > 0))
4134 {
4135 int* perm;
4136 perm=(int *)omAlloc0((rVar(srcExtRing)+1)*sizeof(int));
4137 for(int i=si_min(rVar(srcExtRing),rPar(dst));i>0;i--)
4138 perm[i]=-i;
4139 qq = p_PermPoly(zz, perm, srcExtRing, dst, nMap, NULL, rVar(srcExtRing)-1);
4140 omFreeSize ((ADDRESS)perm, (rVar(srcExtRing)+1)*sizeof(int));
4141 }
4142 else
4143 qq = p_PermPoly(zz, par_perm-1, srcExtRing, dst, nMap, NULL, rVar (srcExtRing)-1);
4144
4145 if(nCoeff_is_transExt(srcCf)
4146 && (!DENIS1((fraction)z))
4147 && p_IsConstant(DEN((fraction)z),srcExtRing))
4148 {
4149 number n=nMap(pGetCoeff(DEN((fraction)z)),srcExtRing->cf, dstCf);
4150 qq=p_Div_nn(qq,n,dst);
4151 n_Delete(&n,dstCf);
4152 p_Normalize(qq,dst);
4153 }
4154 p_Test (qq, dst);
4155
4156 return qq;
4157}
void * ADDRESS
Definition: auxiliary.h:119
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:451
static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
Definition: coeffs.h:839
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:700
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:455
static FORCE_INLINE void n_Write(number n, const coeffs r, const BOOLEAN bShortOut=TRUE)
Definition: coeffs.h:591
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
Definition: coeffs.h:910
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:73
static FORCE_INLINE BOOLEAN nCoeff_is_transExt(const coeffs r)
TRUE iff r represents a transcendental extension field.
Definition: coeffs.h:918
#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)
Definition: omAllocDecl.h:260
#define omAlloc0(size)
Definition: omAllocDecl.h:211
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:4163
poly p_Div_nn(poly p, const number n, const ring r)
Definition: p_polys.cc:1497
void p_Normalize(poly p, const ring r)
Definition: p_polys.cc:3847
static BOOLEAN p_IsConstant(const poly p, const ring r)
Definition: p_polys.h:1983
#define p_Test(p, r)
Definition: p_polys.h:162
@ NUM
Definition: readcf.cc:170
void PrintS(const char *s)
Definition: reporter.cc:284
void rWrite(ring r, BOOLEAN details)
Definition: ring.cc:226
static int rPar(const ring r)
(r->cf->P)
Definition: ring.h:600
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:593

◆ p_Add_q() [1/2]

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

Definition at line 908 of file p_polys.h.

909{
910 assume( (p != q) || (p == NULL && q == NULL) );
911 if (q==NULL) return p;
912 if (p==NULL) return q;
913 int shorter;
914 return r->p_Procs->p_Add_q(p, q, shorter, r);
915}

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

919{
920 assume( (p != q) || (p == NULL && q == NULL) );
921 if (q==NULL) return p;
922 if (p==NULL) { lp=lq; return q; }
923 int shorter;
924 poly res = r->p_Procs->p_Add_q(p, q, shorter, r);
925 lp += lq - shorter;
926 return res;
927}

◆ 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 102 of file pDebug.cc.

103{
104 while (p!=NULL)
105 {
107 pIter(p);
108 }
109 return TRUE;
110}

◆ p_CheckPolyRing()

BOOLEAN p_CheckPolyRing ( poly  p,
ring  r 
)

Definition at line 112 of file pDebug.cc.

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

◆ p_CheckRing()

BOOLEAN p_CheckRing ( ring  r)

Definition at line 128 of file pDebug.cc.

129{
130 #ifndef X_OMALLOC
131 pAssumeReturn(r != NULL && r->PolyBin != NULL);
132 #endif
133 return TRUE;
134}

◆ p_ChineseRemainder()

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

Definition at line 88 of file p_polys.cc.

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

2907{
2908 if( p == NULL )
2909 return NULL;
2910
2911 assume( r != NULL );
2912 assume( r->cf != NULL );
2913 const coeffs C = r->cf;
2914
2915#if CLEARENUMERATORS
2916 if( 0 )
2917 {
2919 n_ClearDenominators(itr, C);
2920 n_ClearContent(itr, C); // divide out the content
2921 p_Test(p, r); n_Test(pGetCoeff(p), C);
2922 assume(n_GreaterZero(pGetCoeff(p), C)); // ??
2923// if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
2924 return p;
2925 }
2926#endif
2927
2928 number d, h;
2929
2930 if (rField_is_Ring(r))
2931 {
2932 if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
2933 return p;
2934 }
2935
2937 {
2938 if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
2939 return p;
2940 }
2941
2942 assume(p != NULL);
2943
2944 if(pNext(p)==NULL)
2945 {
2946 if (!TEST_OPT_CONTENTSB)
2947 p_SetCoeff(p,n_Init(1,C),r);
2948 else if(!n_GreaterZero(pGetCoeff(p),C))
2949 p = p_Neg(p,r);
2950 return p;
2951 }
2952
2953 assume(pNext(p)!=NULL);
2954 poly start=p;
2955
2956#if 0 && CLEARENUMERATORS
2957//CF: does not seem to work that well..
2958
2959 if( nCoeff_is_Q(C) || nCoeff_is_Q_a(C) )
2960 {
2962 n_ClearDenominators(itr, C);
2963 n_ClearContent(itr, C); // divide out the content
2964 p_Test(p, r); n_Test(pGetCoeff(p), C);
2965 assume(n_GreaterZero(pGetCoeff(p), C)); // ??
2966// if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
2967 return start;
2968 }
2969#endif
2970
2971 if(1)
2972 {
2973 // get lcm of all denominators ----------------------------------
2974 h = n_Init(1,C);
2975 while (p!=NULL)
2976 {
2979 n_Delete(&h,C);
2980 h=d;
2981 pIter(p);
2982 }
2983 /* h now contains the 1/lcm of all denominators */
2984 if(!n_IsOne(h,C))
2985 {
2986 // multiply by the lcm of all denominators
2987 p = start;
2988 while (p!=NULL)
2989 {
2990 d=n_Mult(h,pGetCoeff(p),C);
2991 n_Normalize(d,C);
2992 p_SetCoeff(p,d,r);
2993 pIter(p);
2994 }
2995 }
2996 n_Delete(&h,C);
2997 p=start;
2998
2999 p_ContentForGB(p,r);
3000#ifdef HAVE_RATGRING
3001 if (rIsRatGRing(r))
3002 {
3003 /* quick unit detection in the rational case is done in gr_nc_bba */
3004 p_ContentRat(p, r);
3005 start=p;
3006 }
3007#endif
3008 }
3009
3010 if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
3011
3012 return start;
3013}
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:636
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:695
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:494
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
Definition: coeffs.h:806
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:935
static FORCE_INLINE BOOLEAN nCoeff_is_Q_a(const coeffs r)
Definition: coeffs.h:885
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:928
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition: coeffs.h:578
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition: coeffs.h:468
#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:1736
void p_ContentForGB(poly ph, const ring r)
Definition: p_polys.cc:2416
static poly p_Neg(poly p, const ring r)
Definition: p_polys.h:1079
static BOOLEAN rIsRatGRing(const ring r)
Definition: ring.h:427
#define rField_is_Ring(R)
Definition: ring.h:486

◆ p_Cleardenom_n()

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

Definition at line 3015 of file p_polys.cc.

3016{
3017 const coeffs C = r->cf;
3018 number d, h;
3019
3020 assume( ph != NULL );
3021
3022 poly p = ph;
3023
3024#if CLEARENUMERATORS
3025 if( 0 )
3026 {
3027 CPolyCoeffsEnumerator itr(ph);
3028
3029 n_ClearDenominators(itr, d, C); // multiply with common denom. d
3030 n_ClearContent(itr, h, C); // divide by the content h
3031
3032 c = n_Div(d, h, C); // d/h
3033
3034 n_Delete(&d, C);
3035 n_Delete(&h, C);
3036
3037 n_Test(c, C);
3038
3039 p_Test(ph, r); n_Test(pGetCoeff(ph), C);
3040 assume(n_GreaterZero(pGetCoeff(ph), C)); // ??
3041/*
3042 if(!n_GreaterZero(pGetCoeff(ph),C))
3043 {
3044 ph = p_Neg(ph,r);
3045 c = n_InpNeg(c, C);
3046 }
3047*/
3048 return;
3049 }
3050#endif
3051
3052
3053 if( pNext(p) == NULL )
3054 {
3056 {
3057 c=n_Invers(pGetCoeff(p), C);
3058 p_SetCoeff(p, n_Init(1, C), r);
3059 }
3060 else
3061 {
3062 c=n_Init(1,C);
3063 }
3064
3065 if(!n_GreaterZero(pGetCoeff(ph),C))
3066 {
3067 ph = p_Neg(ph,r);
3068 c = n_InpNeg(c, C);
3069 }
3070
3071 return;
3072 }
3073 if (TEST_OPT_CONTENTSB) { c=n_Init(1,C); return; }
3074
3075 assume( pNext(p) != NULL );
3076
3077#if CLEARENUMERATORS
3078 if( nCoeff_is_Q(C) || nCoeff_is_Q_a(C) )
3079 {
3080 CPolyCoeffsEnumerator itr(ph);
3081
3082 n_ClearDenominators(itr, d, C); // multiply with common denom. d
3083 n_ClearContent(itr, h, C); // divide by the content h
3084
3085 c = n_Div(d, h, C); // d/h
3086
3087 n_Delete(&d, C);
3088 n_Delete(&h, C);
3089
3090 n_Test(c, C);
3091
3092 p_Test(ph, r); n_Test(pGetCoeff(ph), C);
3093 assume(n_GreaterZero(pGetCoeff(ph), C)); // ??
3094/*
3095 if(!n_GreaterZero(pGetCoeff(ph),C))
3096 {
3097 ph = p_Neg(ph,r);
3098 c = n_InpNeg(c, C);
3099 }
3100*/
3101 return;
3102 }
3103#endif
3104
3105
3106
3107
3108 if(1)
3109 {
3110 h = n_Init(1,C);
3111 while (p!=NULL)
3112 {
3115 n_Delete(&h,C);
3116 h=d;
3117 pIter(p);
3118 }
3119 c=h;
3120 /* contains the 1/lcm of all denominators */
3121 if(!n_IsOne(h,C))
3122 {
3123 p = ph;
3124 while (p!=NULL)
3125 {
3126 /* should be: // NOTE: don't use ->coef!!!!
3127 * number hh;
3128 * nGetDenom(p->coef,&hh);
3129 * nMult(&h,&hh,&d);
3130 * nNormalize(d);
3131 * nDelete(&hh);
3132 * nMult(d,p->coef,&hh);
3133 * nDelete(&d);
3134 * nDelete(&(p->coef));
3135 * p->coef =hh;
3136 */
3137 d=n_Mult(h,pGetCoeff(p),C);
3138 n_Normalize(d,C);
3139 p_SetCoeff(p,d,r);
3140 pIter(p);
3141 }
3142 if (rField_is_Q_a(r))
3143 {
3144 loop
3145 {
3146 h = n_Init(1,C);
3147 p=ph;
3148 while (p!=NULL)
3149 {
3151 n_Delete(&h,C);
3152 h=d;
3153 pIter(p);
3154 }
3155 /* contains the 1/lcm of all denominators */
3156 if(!n_IsOne(h,C))
3157 {
3158 p = ph;
3159 while (p!=NULL)
3160 {
3161 /* should be: // NOTE: don't use ->coef!!!!
3162 * number hh;
3163 * nGetDenom(p->coef,&hh);
3164 * nMult(&h,&hh,&d);
3165 * nNormalize(d);
3166 * nDelete(&hh);
3167 * nMult(d,p->coef,&hh);
3168 * nDelete(&d);
3169 * nDelete(&(p->coef));
3170 * p->coef =hh;
3171 */
3172 d=n_Mult(h,pGetCoeff(p),C);
3173 n_Normalize(d,C);
3174 p_SetCoeff(p,d,r);
3175 pIter(p);
3176 }
3177 number t=n_Mult(c,h,C);
3178 n_Delete(&c,C);
3179 c=t;
3180 }
3181 else
3182 {
3183 break;
3184 }
3185 n_Delete(&h,C);
3186 }
3187 }
3188 }
3189 }
3190
3191 if(!n_GreaterZero(pGetCoeff(ph),C))
3192 {
3193 ph = p_Neg(ph,r);
3194 c = n_InpNeg(c, C);
3195 }
3196
3197}
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:564
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:557
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:615
static BOOLEAN rField_is_Q_a(const ring r)
Definition: ring.h:540

◆ p_Cmp()

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

Definition at line 1707 of file p_polys.h.

1708{
1709 if (p2==NULL)
1710 {
1711 if (p1==NULL) return 0;
1712 return 1;
1713 }
1714 if (p1==NULL)
1715 return -1;
1716 return p_LmCmp(p1,p2,r);
1717}

◆ p_CmpPolys()

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

Definition at line 1719 of file p_polys.h.

1720{
1721 if (p2==NULL)
1722 {
1723 if (p1==NULL) return 0;
1724 return 1;
1725 }
1726 if (p1==NULL)
1727 return -1;
1728 return p_ComparePolys(p1,p2,r);
1729}
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:4609

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

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

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

4610{
4611 number n,nn;
4612 pAssume(p1 != NULL && p2 != NULL);
4613
4614 if (!p_LmEqual(p1,p2,r)) //compare leading mons
4615 return FALSE;
4616 if ((pNext(p1)==NULL) && (pNext(p2)!=NULL))
4617 return FALSE;
4618 if ((pNext(p2)==NULL) && (pNext(p1)!=NULL))
4619 return FALSE;
4620 if (pLength(p1) != pLength(p2))
4621 return FALSE;
4622 #ifdef HAVE_RINGS
4623 if (rField_is_Ring(r))
4624 {
4625 if (!n_DivBy(pGetCoeff(p1), pGetCoeff(p2), r->cf)) return FALSE;
4626 }
4627 #endif
4628 n=n_Div(pGetCoeff(p1),pGetCoeff(p2),r->cf);
4629 while ((p1 != NULL) /*&& (p2 != NULL)*/)
4630 {
4631 if ( ! p_LmEqual(p1, p2,r))
4632 {
4633 n_Delete(&n, r->cf);
4634 return FALSE;
4635 }
4636 if (!n_Equal(pGetCoeff(p1), nn = n_Mult(pGetCoeff(p2),n, r->cf), r->cf))
4637 {
4638 n_Delete(&n, r->cf);
4639 n_Delete(&nn, r->cf);
4640 return FALSE;
4641 }
4642 n_Delete(&nn, r->cf);
4643 pIter(p1);
4644 pIter(p2);
4645 }
4646 n_Delete(&n, r->cf);
4647 return TRUE;
4648}
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:753
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:460
#define pAssume(cond)
Definition: monomials.h:90
#define p_LmEqual(p1, p2, r)
Definition: p_polys.h:1703

◆ p_Content()

void p_Content ( poly  p,
const ring  r 
)

Definition at line 2287 of file p_polys.cc.

2288{
2289 if (ph==NULL) return;
2290 const coeffs cf=r->cf;
2291 if (pNext(ph)==NULL)
2292 {
2293 p_SetCoeff(ph,n_Init(1,cf),r);
2294 return;
2295 }
2296 if ((cf->cfSubringGcd==ndGcd)
2297 || (cf->cfGcd==ndGcd)) /* trivial gcd*/
2298 return;
2299 number h;
2300 if ((rField_is_Q(r))
2301 || (rField_is_Q_a(r))
2302 || (rField_is_Zp_a)(r)
2303 || (rField_is_Z(r))
2304 )
2305 {
2306 h=p_InitContent(ph,r); /* first guess of a gcd of all coeffs */
2307 }
2308 else
2309 {
2310 h=n_Copy(pGetCoeff(ph),cf);
2311 }
2312 poly p;
2313 if(n_IsOne(h,cf))
2314 {
2315 goto content_finish;
2316 }
2317 p=ph;
2318 // take the SubringGcd of all coeffs
2319 while (p!=NULL)
2320 {
2322 number d=n_SubringGcd(h,pGetCoeff(p),cf);
2323 n_Delete(&h,cf);
2324 h = d;
2325 if(n_IsOne(h,cf))
2326 {
2327 goto content_finish;
2328 }
2329 pIter(p);
2330 }
2331 // if found<>1, divide by it
2332 p = ph;
2333 while (p!=NULL)
2334 {
2335 number d = n_ExactDiv(pGetCoeff(p),h,cf);
2336 p_SetCoeff(p,d,r);
2337 pIter(p);
2338 }
2339content_finish:
2340 n_Delete(&h,r->cf);
2341 // and last: check leading sign:
2342 if(!n_GreaterZero(pGetCoeff(ph),r->cf)) ph = p_Neg(ph,r);
2343}
CanonicalForm cf
Definition: cfModGcd.cc:4083
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:622
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
Definition: coeffs.h:666
number ndGcd(number, number, const coeffs r)
Definition: numbers.cc:165
number p_InitContent(poly ph, const ring r)
Definition: p_polys.cc:2696
static BOOLEAN rField_is_Zp_a(const ring r)
Definition: ring.h:530

◆ p_Content_n()

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

Definition at line 2345 of file p_polys.cc.

2346{
2347 const coeffs cf=r->cf;
2348 if (ph==NULL)
2349 {
2350 c=n_Init(1,cf);
2351 return;
2352 }
2353 if (pNext(ph)==NULL)
2354 {
2355 c=pGetCoeff(ph);
2356 p_SetCoeff0(ph,n_Init(1,cf),r);
2357 }
2358 if ((cf->cfSubringGcd==ndGcd)
2359 || (cf->cfGcd==ndGcd)) /* trivial gcd*/
2360 {
2361 c=n_Init(1,r->cf);
2362 return;
2363 }
2364 number h;
2365 if ((rField_is_Q(r))
2366 || (rField_is_Q_a(r))
2367 || (rField_is_Zp_a)(r)
2368 || (rField_is_Z(r))
2369 )
2370 {
2371 h=p_InitContent(ph,r); /* first guess of a gcd of all coeffs */
2372 }
2373 else
2374 {
2375 h=n_Copy(pGetCoeff(ph),cf);
2376 }
2377 poly p;
2378 if(n_IsOne(h,cf))
2379 {
2380 goto content_finish;
2381 }
2382 p=ph;
2383 // take the SubringGcd of all coeffs
2384 while (p!=NULL)
2385 {
2387 number d=n_SubringGcd(h,pGetCoeff(p),cf);
2388 n_Delete(&h,cf);
2389 h = d;
2390 if(n_IsOne(h,cf))
2391 {
2392 goto content_finish;
2393 }
2394 pIter(p);
2395 }
2396 // if found<>1, divide by it
2397 p = ph;
2398 while (p!=NULL)
2399 {
2400 number d = n_ExactDiv(pGetCoeff(p),h,cf);
2401 p_SetCoeff(p,d,r);
2402 pIter(p);
2403 }
2404content_finish:
2405 c=h;
2406 // and last: check leading sign:
2407 if(!n_GreaterZero(pGetCoeff(ph),r->cf))
2408 {
2409 c = n_InpNeg(c,r->cf);
2410 ph = p_Neg(ph,r);
2411 }
2412}
#define p_SetCoeff0(p, n, r)
Definition: monomials.h:60

◆ p_ContentForGB()

void p_ContentForGB ( poly  p,
const ring  r 
)

Definition at line 2416 of file p_polys.cc.

2417{
2418 if(TEST_OPT_CONTENTSB) return;
2419 assume( ph != NULL );
2420
2421 assume( r != NULL ); assume( r->cf != NULL );
2422
2423
2424#if CLEARENUMERATORS
2425 if( 0 )
2426 {
2427 const coeffs C = r->cf;
2428 // experimentall (recursive enumerator treatment) of alg. Ext!
2429 CPolyCoeffsEnumerator itr(ph);
2430 n_ClearContent(itr, r->cf);
2431
2432 p_Test(ph, r); n_Test(pGetCoeff(ph), C);
2433 assume(n_GreaterZero(pGetCoeff(ph), C)); // ??
2434
2435 // if(!n_GreaterZero(pGetCoeff(ph),r->cf)) ph = p_Neg(ph,r);
2436 return;
2437 }
2438#endif
2439
2440
2441#ifdef HAVE_RINGS
2442 if (rField_is_Ring(r))
2443 {
2444 if (rField_has_Units(r))
2445 {
2446 number k = n_GetUnit(pGetCoeff(ph),r->cf);
2447 if (!n_IsOne(k,r->cf))
2448 {
2449 number tmpGMP = k;
2450 k = n_Invers(k,r->cf);
2451 n_Delete(&tmpGMP,r->cf);
2452 poly h = pNext(ph);
2453 p_SetCoeff(ph, n_Mult(pGetCoeff(ph), k,r->cf),r);
2454 while (h != NULL)
2455 {
2456 p_SetCoeff(h, n_Mult(pGetCoeff(h), k,r->cf),r);
2457 pIter(h);
2458 }
2459// assume( n_GreaterZero(pGetCoeff(ph),r->cf) );
2460// if(!n_GreaterZero(pGetCoeff(ph),r->cf)) ph = p_Neg(ph,r);
2461 }
2462 n_Delete(&k,r->cf);
2463 }
2464 return;
2465 }
2466#endif
2467 number h,d;
2468 poly p;
2469
2470 if(pNext(ph)==NULL)
2471 {
2472 p_SetCoeff(ph,n_Init(1,r->cf),r);
2473 }
2474 else
2475 {
2476 assume( pNext(ph) != NULL );
2477#if CLEARENUMERATORS
2478 if( nCoeff_is_Q(r->cf) )
2479 {
2480 // experimentall (recursive enumerator treatment) of alg. Ext!
2481 CPolyCoeffsEnumerator itr(ph);
2482 n_ClearContent(itr, r->cf);
2483
2484 p_Test(ph, r); n_Test(pGetCoeff(ph), r->cf);
2485 assume(n_GreaterZero(pGetCoeff(ph), r->cf)); // ??
2486
2487 // if(!n_GreaterZero(pGetCoeff(ph),r->cf)) ph = p_Neg(ph,r);
2488 return;
2489 }
2490#endif
2491
2492 n_Normalize(pGetCoeff(ph),r->cf);
2493 if(!n_GreaterZero(pGetCoeff(ph),r->cf)) ph = p_Neg(ph,r);
2494 if (rField_is_Q(r)||(getCoeffType(r->cf)==n_transExt)) // should not be used anymore if CLEARENUMERATORS is 1
2495 {
2496 h=p_InitContent(ph,r);
2497 p=ph;
2498 }
2499 else
2500 {
2501 h=n_Copy(pGetCoeff(ph),r->cf);
2502 p = pNext(ph);
2503 }
2504 while (p!=NULL)
2505 {
2506 n_Normalize(pGetCoeff(p),r->cf);
2507 d=n_SubringGcd(h,pGetCoeff(p),r->cf);
2508 n_Delete(&h,r->cf);
2509 h = d;
2510 if(n_IsOne(h,r->cf))
2511 {
2512 break;
2513 }
2514 pIter(p);
2515 }
2516 //number tmp;
2517 if(!n_IsOne(h,r->cf))
2518 {
2519 p = ph;
2520 while (p!=NULL)
2521 {
2522 //d = nDiv(pGetCoeff(p),h);
2523 //tmp = nExactDiv(pGetCoeff(p),h);
2524 //if (!nEqual(d,tmp))
2525 //{
2526 // StringSetS("** div0:");nWrite(pGetCoeff(p));StringAppendS("/");
2527 // nWrite(h);StringAppendS("=");nWrite(d);StringAppendS(" int:");
2528 // nWrite(tmp);Print(StringEndS("\n")); // NOTE/TODO: use StringAppendS("\n"); omFree(s);
2529 //}
2530 //nDelete(&tmp);
2531 d = n_ExactDiv(pGetCoeff(p),h,r->cf);
2532 p_SetCoeff(p,d,r);
2533 pIter(p);
2534 }
2535 }
2536 n_Delete(&h,r->cf);
2537 if (rField_is_Q_a(r))
2538 {
2539 // special handling for alg. ext.:
2540 if (getCoeffType(r->cf)==n_algExt)
2541 {
2542 h = n_Init(1, r->cf->extRing->cf);
2543 p=ph;
2544 while (p!=NULL)
2545 { // each monom: coeff in Q_a
2546 poly c_n_n=(poly)pGetCoeff(p);
2547 poly c_n=c_n_n;
2548 while (c_n!=NULL)
2549 { // each monom: coeff in Q
2550 d=n_NormalizeHelper(h,pGetCoeff(c_n),r->cf->extRing->cf);
2551 n_Delete(&h,r->cf->extRing->cf);
2552 h=d;
2553 pIter(c_n);
2554 }
2555 pIter(p);
2556 }
2557 /* h contains the 1/lcm of all denominators in c_n_n*/
2558 //n_Normalize(h,r->cf->extRing->cf);
2559 if(!n_IsOne(h,r->cf->extRing->cf))
2560 {
2561 p=ph;
2562 while (p!=NULL)
2563 { // each monom: coeff in Q_a
2564 poly c_n=(poly)pGetCoeff(p);
2565 while (c_n!=NULL)
2566 { // each monom: coeff in Q
2567 d=n_Mult(h,pGetCoeff(c_n),r->cf->extRing->cf);
2568 n_Normalize(d,r->cf->extRing->cf);
2569 n_Delete(&pGetCoeff(c_n),r->cf->extRing->cf);
2570 pGetCoeff(c_n)=d;
2571 pIter(c_n);
2572 }
2573 pIter(p);
2574 }
2575 }
2576 n_Delete(&h,r->cf->extRing->cf);
2577 }
2578 /*else
2579 {
2580 // special handling for rat. functions.:
2581 number hzz =NULL;
2582 p=ph;
2583 while (p!=NULL)
2584 { // each monom: coeff in Q_a (Z_a)
2585 fraction f=(fraction)pGetCoeff(p);
2586 poly c_n=NUM(f);
2587 if (hzz==NULL)
2588 {
2589 hzz=n_Copy(pGetCoeff(c_n),r->cf->extRing->cf);
2590 pIter(c_n);
2591 }
2592 while ((c_n!=NULL)&&(!n_IsOne(hzz,r->cf->extRing->cf)))
2593 { // each monom: coeff in Q (Z)
2594 d=n_Gcd(hzz,pGetCoeff(c_n),r->cf->extRing->cf);
2595 n_Delete(&hzz,r->cf->extRing->cf);
2596 hzz=d;
2597 pIter(c_n);
2598 }
2599 pIter(p);
2600 }
2601 // hzz contains the gcd of all numerators in f
2602 h=n_Invers(hzz,r->cf->extRing->cf);
2603 n_Delete(&hzz,r->cf->extRing->cf);
2604 n_Normalize(h,r->cf->extRing->cf);
2605 if(!n_IsOne(h,r->cf->extRing->cf))
2606 {
2607 p=ph;
2608 while (p!=NULL)
2609 { // each monom: coeff in Q_a (Z_a)
2610 fraction f=(fraction)pGetCoeff(p);
2611 NUM(f)=__p_Mult_nn(NUM(f),h,r->cf->extRing);
2612 p_Normalize(NUM(f),r->cf->extRing);
2613 pIter(p);
2614 }
2615 }
2616 n_Delete(&h,r->cf->extRing->cf);
2617 }*/
2618 }
2619 }
2620 if(!n_GreaterZero(pGetCoeff(ph),r->cf)) ph = p_Neg(ph,r);
2621}
@ 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:532
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
static BOOLEAN rField_has_Units(const ring r)
Definition: ring.h:491

◆ p_ContentRat()

void p_ContentRat ( poly &  ph,
const ring  r 
)

Definition at line 1736 of file p_polys.cc.

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

856{
857 if (p != NULL)
858 {
859#ifndef PDEBUG
860 if (tailRing == lmRing)
861 return p_Copy_noCheck(p, tailRing);
862#endif
863 poly pres = p_Head(p, lmRing);
864 if (pNext(p)!=NULL)
865 pNext(pres) = p_Copy_noCheck(pNext(p), tailRing);
866 return pres;
867 }
868 else
869 return NULL;
870}
static poly p_Copy_noCheck(poly p, const ring r)
returns a copy of p (without any additional testing)
Definition: p_polys.h:808

◆ p_Copy() [2/2]

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

returns a copy of p

Definition at line 818 of file p_polys.h.

819{
820 if (p!=NULL)
821 {
822 p_Test(p,r);
823 const poly pp = p_Copy_noCheck(p, r);
824 p_Test(pp,r);
825 return pp;
826 }
827 else
828 return NULL;
829}
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 808 of file p_polys.h.

809{
810 /*assume(p!=NULL);*/
811 assume(r != NULL);
812 assume(r->p_Procs != NULL);
813 assume(r->p_Procs->p_Copy != NULL);
814 return r->p_Procs->p_Copy(p, r);
815}

◆ p_CopyPowerProduct()

poly p_CopyPowerProduct ( const poly  p,
const ring  r 
)

like p_Head, but with coefficient 1

Definition at line 5024 of file p_polys.cc.

5025{
5026 if (p == NULL) return NULL;
5027 return p_CopyPowerProduct0(p,n_Init(1,r->cf),r);
5028}
poly p_CopyPowerProduct0(const poly p, number n, const ring r)
like p_Head, but with coefficient n
Definition: p_polys.cc:5012

◆ p_CopyPowerProduct0()

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

like p_Head, but with coefficient n

Definition at line 5012 of file p_polys.cc.

5013{
5015 poly np;
5016 omTypeAllocBin(poly, np, r->PolyBin);
5017 p_SetRingOfLm(np, r);
5018 memcpy(np->exp, p->exp, r->ExpL_Size*sizeof(long));
5019 pNext(np) = NULL;
5020 pSetCoeff0(np, n);
5021 return np;
5022}
#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)
Definition: omAllocDecl.h:203

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

584{
585 p_LmCheckPolyRing(a, r);
586// assume(p_GetOrder(a, r) == p_WTotaldegree(a, r)); // WRONG assume!
587 return p_GetOrder(a, r);
588}
BOOLEAN p_LmCheckPolyRing(poly p, ring r)
Definition: pDebug.cc:120
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 686 of file p_polys.cc.

687{
688 p_Test(p, R);
689 assume( w != NULL );
690 long r=-LONG_MAX;
691
692 while (p!=NULL)
693 {
694 long t=totaldegreeWecart_IV(p,R,w);
695 if (t>r) r=t;
696 pIter(p);
697 }
698 return r;
699}
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 880 of file p_polys.h.

881{
882 assume( p!= NULL );
883 if (*p != NULL)
884 {
885#ifndef PDEBUG
886 if (tailRing == lmRing)
887 {
888 p_Delete(p, tailRing);
889 return;
890 }
891#endif
892 if (pNext(*p) != NULL)
893 p_Delete(&pNext(*p), tailRing);
894 p_LmDelete(p, lmRing);
895 }
896}
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:711

◆ p_Delete() [2/2]

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

Definition at line 873 of file p_polys.h.

874{
875 assume( p!= NULL );
876 assume( r!= NULL );
877 if ((*p)!=NULL) r->p_Procs->p_Delete(p, r);
878}

◆ p_DeleteComp()

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

Definition at line 3618 of file p_polys.cc.

3619{
3620 poly q;
3621 long unsigned kk=k;
3622
3623 while ((*p!=NULL) && (__p_GetComp(*p,r)==kk)) p_LmDelete(p,r);
3624 if (*p==NULL) return;
3625 q = *p;
3626 if (__p_GetComp(q,r)>kk)
3627 {
3628 p_SubComp(q,1,r);
3629 p_SetmComp(q,r);
3630 }
3631 while (pNext(q)!=NULL)
3632 {
3633 if (__p_GetComp(pNext(q),r)==kk)
3634 p_LmDelete(&(pNext(q)),r);
3635 else
3636 {
3637 pIter(q);
3638 if (__p_GetComp(q,r)>kk)
3639 {
3640 p_SubComp(q,1,r);
3641 p_SetmComp(q,r);
3642 }
3643 }
3644 }
3645}
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 1890 of file p_polys.cc.

1891{
1892 poly res, f, last;
1893 number t;
1894
1895 last = res = NULL;
1896 while (a!=NULL)
1897 {
1898 if (p_GetExp(a,k,r)!=0)
1899 {
1900 f = p_LmInit(a,r);
1901 t = n_Init(p_GetExp(a,k,r),r->cf);
1902 pSetCoeff0(f,n_Mult(t,pGetCoeff(a),r->cf));
1903 n_Delete(&t,r->cf);
1904 if (n_IsZero(pGetCoeff(f),r->cf))
1905 p_LmDelete(&f,r);
1906 else
1907 {
1908 p_DecrExp(f,k,r);
1909 p_Setm(f,r);
1910 if (res==NULL)
1911 {
1912 res=last=f;
1913 }
1914 else
1915 {
1916 pNext(last)=f;
1917 last=f;
1918 }
1919 }
1920 }
1921 pIter(a);
1922 }
1923 return res;
1924}
FILE * f
Definition: checklibs.c:9
STATIC_VAR poly last
Definition: hdegree.cc:1151
static poly p_LmInit(poly p, const ring r)
Definition: p_polys.h:1307
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 1965 of file p_polys.cc.

1966{
1967 poly result=NULL;
1968 poly h;
1969 for(;a!=NULL;pIter(a))
1970 {
1971 for(h=b;h!=NULL;pIter(h))
1972 {
1973 result=p_Add_q(result,p_DiffOpM(a,h,multiply,r),r);
1974 }
1975 }
1976 return result;
1977}
return result
Definition: facAbsBiFact.cc:75
static poly p_DiffOpM(poly a, poly b, BOOLEAN multiply, const ring r)
Definition: p_polys.cc:1926

◆ p_Div_mm()

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

divide polynomial by monomial

Definition at line 1530 of file p_polys.cc.

1531{
1532 p_Test(p, r);
1533 p_Test(m, r);
1534 poly result = p;
1535 poly prev = NULL;
1536 number n=pGetCoeff(m);
1537 while (p!=NULL)
1538 {
1539 number nc = n_Div(pGetCoeff(p),n,r->cf);
1540 n_Normalize(nc,r->cf);
1541 if (!n_IsZero(nc,r->cf))
1542 {
1543 p_SetCoeff(p,nc,r);
1544 prev=p;
1545 p_ExpVectorSub(p,m,r);
1546 pIter(p);
1547 }
1548 else
1549 {
1550 if (prev==NULL)
1551 {
1552 p_LmDelete(&result,r);
1553 p=result;
1554 }
1555 else
1556 {
1557 p_LmDelete(&pNext(prev),r);
1558 p=pNext(prev);
1559 }
1560 }
1561 }
1562 p_Test(result,r);
1563 return(result);
1564}
int m
Definition: cfEzgcd.cc:128
static void p_ExpVectorSub(poly p1, poly p2, const ring r)
Definition: p_polys.h:1412

◆ p_Div_nn()

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

Definition at line 1497 of file p_polys.cc.

1498{
1499 pAssume(!n_IsZero(n,r->cf));
1500 p_Test(p, r);
1501 poly result = p;
1502 poly prev = NULL;
1503 while (p!=NULL)
1504 {
1505 number nc = n_Div(pGetCoeff(p),n,r->cf);
1506 if (!n_IsZero(nc,r->cf))
1507 {
1508 p_SetCoeff(p,nc,r);
1509 prev=p;
1510 pIter(p);
1511 }
1512 else
1513 {
1514 if (prev==NULL)
1515 {
1516 p_LmDelete(&result,r);
1517 p=result;
1518 }
1519 else
1520 {
1521 p_LmDelete(&pNext(prev),r);
1522 p=pNext(prev);
1523 }
1524 }
1525 }
1526 p_Test(result,r);
1527 return(result);
1528}

◆ p_DivideM()

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

Definition at line 1570 of file p_polys.cc.

1571{
1572 if (a==NULL) { p_Delete(&b,r); return NULL; }
1573 poly result=a;
1574
1575 if(!p_IsConstant(b,r))
1576 {
1577 if (rIsNCRing(r))
1578 {
1579 WerrorS("p_DivideM not implemented for non-commuative rings");
1580 return NULL;
1581 }
1582 poly prev=NULL;
1583 while (a!=NULL)
1584 {
1585 if (p_DivisibleBy(b,a,r))
1586 {
1587 p_ExpVectorSub(a,b,r);
1588 prev=a;
1589 pIter(a);
1590 }
1591 else
1592 {
1593 if (prev==NULL)
1594 {
1595 p_LmDelete(&result,r);
1596 a=result;
1597 }
1598 else
1599 {
1600 p_LmDelete(&pNext(prev),r);
1601 a=pNext(prev);
1602 }
1603 }
1604 }
1605 }
1606 if (result!=NULL)
1607 {
1608 number inv=pGetCoeff(b);
1609 //if ((!rField_is_Ring(r)) || n_IsUnit(inv,r->cf))
1610 if (rField_is_Zp(r))
1611 {
1612 inv = n_Invers(inv,r->cf);
1613 __p_Mult_nn(result,inv,r);
1614 n_Delete(&inv, r->cf);
1615 }
1616 else
1617 {
1618 result = p_Div_nn(result,inv,r);
1619 }
1620 }
1621 p_Delete(&b, r);
1622 return result;
1623}
static BOOLEAN p_DivisibleBy(poly a, poly b, const ring r)
Definition: p_polys.h:1884
#define __p_Mult_nn(p, n, r)
Definition: p_polys.h:943
static BOOLEAN rIsNCRing(const ring r)
Definition: ring.h:421

◆ p_DivisibleBy() [1/2]

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

Definition at line 1893 of file p_polys.h.

1894{
1896 pIfThen1(a!=NULL, p_LmCheckPolyRing1(a, r_a));
1897 if (a != NULL) {
1898 return _p_LmDivisibleBy(a, r_a, b, r_b);
1899 }
1900 return FALSE;
1901}
#define pIfThen1(cond, check)
Definition: monomials.h:179
static BOOLEAN _p_LmDivisibleBy(poly a, poly b, const ring r)
Definition: p_polys.h:1849

◆ p_DivisibleBy() [2/2]

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

Definition at line 1884 of file p_polys.h.

1885{
1887 pIfThen1(a!=NULL, p_LmCheckPolyRing1(a, r));
1888
1889 if (a != NULL && (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r)))
1890 return _p_LmDivisibleByNoComp(a,b,r);
1891 return FALSE;
1892}

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

1635{
1636 int exponent;
1637 for(int i = (int)rVar(r); i>0; i--)
1638 {
1639 exponent = p_GetExp(g, i, r) - p_GetExp(f, i, r);
1640 if (exponent < 0) return FALSE;
1641 }
1642 return n_DivBy(pGetCoeff(g), pGetCoeff(f), r->cf);
1643}
g
Definition: cfModGcd.cc:4090
int exponent(const CanonicalForm &f, int q)
int exponent ( const CanonicalForm & f, int q )

◆ p_EqualPolys() [1/2]

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

Definition at line 4545 of file p_polys.cc.

4546{
4547 while ((p1 != NULL) && (p2 != NULL))
4548 {
4549 if (! p_LmEqual(p1, p2,r))
4550 return FALSE;
4551 if (! n_Equal(p_GetCoeff(p1,r), p_GetCoeff(p2,r),r->cf ))
4552 return FALSE;
4553 pIter(p1);
4554 pIter(p2);
4555 }
4556 return (p1==p2);
4557}
#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 4583 of file p_polys.cc.

4584{
4585 assume( r1 == r2 || rSamePolyRep(r1, r2) ); // will be used in rEqual!
4586 assume( r1->cf == r2->cf );
4587
4588 while ((p1 != NULL) && (p2 != NULL))
4589 {
4590 // returns 1 if ExpVector(p)==ExpVector(q): does not compare numbers !!
4591 // #define p_LmEqual(p1, p2, r) p_ExpVectorEqual(p1, p2, r)
4592
4593 if (! p_ExpVectorEqual(p1, p2, r1, r2))
4594 return FALSE;
4595
4596 if (! n_Equal(p_GetCoeff(p1,r1), p_GetCoeff(p2,r2), r1->cf ))
4597 return FALSE;
4598
4599 pIter(p1);
4600 pIter(p2);
4601 }
4602 return (p1==p2);
4603}
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:1713

◆ p_ExpVectorAdd()

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

Definition at line 1383 of file p_polys.h.

1384{
1385 p_LmCheckPolyRing1(p1, r);
1386 p_LmCheckPolyRing1(p2, r);
1387#if PDEBUG >= 1
1388 for (int i=1; i<=r->N; i++)
1389 pAssume1((unsigned long) (p_GetExp(p1, i, r) + p_GetExp(p2, i, r)) <= r->bitmask);
1390 pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0);
1391#endif
1392
1393 p_MemAdd_LengthGeneral(p1->exp, p2->exp, r->ExpL_Size);
1395}
#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:1264

◆ p_ExpVectorAddSub()

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

Definition at line 1428 of file p_polys.h.

1429{
1430 p_LmCheckPolyRing1(p1, r);
1431 p_LmCheckPolyRing1(p2, r);
1432 p_LmCheckPolyRing1(p3, r);
1433#if PDEBUG >= 1
1434 for (int i=1; i<=r->N; i++)
1435 pAssume1(p_GetExp(p1, i, r) + p_GetExp(p2, i, r) >= p_GetExp(p3, i, r));
1436 pAssume1(p_GetComp(p1, r) == 0 ||
1437 (p_GetComp(p2, r) - p_GetComp(p3, r) == 0) ||
1438 (p_GetComp(p1, r) == p_GetComp(p2, r) - p_GetComp(p3, r)));
1439#endif
1440
1441 p_MemAddSub_LengthGeneral(p1->exp, p2->exp, p3->exp, r->ExpL_Size);
1442 // no need to adjust in case of NegWeights
1443}
#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 1285 of file p_polys.h.

1286{
1287 p_LmCheckPolyRing1(d_p, r);
1288 p_LmCheckPolyRing1(s_p, r);
1289 memcpy(d_p->exp, s_p->exp, r->ExpL_Size*sizeof(long));
1290}

◆ p_ExpVectorDiff()

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

Definition at line 1446 of file p_polys.h.

1447{
1448 p_LmCheckPolyRing1(p1, r);
1449 p_LmCheckPolyRing1(p2, r);
1450 p_LmCheckPolyRing1(pr, r);
1451#if PDEBUG >= 2
1452 for (int i=1; i<=r->N; i++)
1453 pAssume1(p_GetExp(p1, i, r) >= p_GetExp(p2, i, r));
1454 pAssume1(!rRing_has_Comp(r) || p_GetComp(p1, r) == p_GetComp(p2, r));
1455#endif
1456
1457 p_MemDiff_LengthGeneral(pr->exp, p1->exp, p2->exp, r->ExpL_Size);
1459}
#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:1274

◆ p_ExpVectorEqual()

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

Definition at line 1461 of file p_polys.h.

1462{
1463 p_LmCheckPolyRing1(p1, r);
1464 p_LmCheckPolyRing1(p2, r);
1465
1466 unsigned i = r->ExpL_Size;
1467 unsigned long *ep = p1->exp;
1468 unsigned long *eq = p2->exp;
1469
1470 do
1471 {
1472 i--;
1473 if (ep[i] != eq[i]) return FALSE;
1474 }
1475 while (i!=0);
1476 return TRUE;
1477}

◆ p_ExpVectorSub()

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

Definition at line 1412 of file p_polys.h.

1413{
1414 p_LmCheckPolyRing1(p1, r);
1415 p_LmCheckPolyRing1(p2, r);
1416#if PDEBUG >= 1
1417 for (int i=1; i<=r->N; i++)
1418 pAssume1(p_GetExp(p1, i, r) >= p_GetExp(p2, i, r));
1419 pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0 ||
1420 p_GetComp(p1, r) == p_GetComp(p2, r));
1421#endif
1422
1423 p_MemSub_LengthGeneral(p1->exp, p2->exp, r->ExpL_Size);
1425}
#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 1397 of file p_polys.h.

1398{
1399 p_LmCheckPolyRing1(p1, r);
1400 p_LmCheckPolyRing1(p2, r);
1401 p_LmCheckPolyRing1(pr, r);
1402#if PDEBUG >= 1
1403 for (int i=1; i<=r->N; i++)
1404 pAssume1((unsigned long) (p_GetExp(p1, i, r) + p_GetExp(p2, i, r)) <= r->bitmask);
1405 pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0);
1406#endif
1407
1408 p_MemSum_LengthGeneral(pr->exp, p1->exp, p2->exp, r->ExpL_Size);
1410}
#define p_MemSum_LengthGeneral(r, s1, s2, length)
Definition: p_MemAdd.h:86

◆ p_Farey()

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

Definition at line 54 of file p_polys.cc.

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

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

4975{
4976 assume(f!=NULL);
4977 assume(g!=NULL);
4978 assume(pNext(f)==NULL);
4979 poly G=p_Head(f,r);
4980 poly h=g;
4981 int *mf=(int*)omAlloc((r->N+1)*sizeof(int));
4982 p_GetExpV(f,mf,r);
4983 int *mh=(int*)omAlloc((r->N+1)*sizeof(int));
4984 BOOLEAN const_mon;
4985 BOOLEAN one_coeff=n_IsOne(pGetCoeff(G),r->cf);
4986 loop
4987 {
4988 if (h==NULL) break;
4989 if(!one_coeff)
4990 {
4991 number n=n_SubringGcd(pGetCoeff(G),pGetCoeff(h),r->cf);
4992 one_coeff=n_IsOne(n,r->cf);
4993 p_SetCoeff(G,n,r);
4994 }
4995 p_GetExpV(h,mh,r);
4996 const_mon=TRUE;
4997 for(unsigned j=r->N;j!=0;j--)
4998 {
4999 if (mh[j]<mf[j]) mf[j]=mh[j];
5000 if (mf[j]>0) const_mon=FALSE;
5001 }
5002 if (one_coeff && const_mon) break;
5003 pIter(h);
5004 }
5005 mf[0]=0;
5006 p_SetExpV(G,mf,r); // included is p_SetComp, p_Setm
5007 omFreeSize(mf,(r->N+1)*sizeof(int));
5008 omFreeSize(mh,(r->N+1)*sizeof(int));
5009 return G;
5010}
STATIC_VAR TreeM * G
Definition: janet.cc:31
#define omAlloc(size)
Definition: omAllocDecl.h:210
static void p_SetExpV(poly p, int *ev, const ring r)
Definition: p_polys.h:1516
static void p_GetExpV(poly p, int *ev, const ring r)
Definition: p_polys.h:1492

◆ p_GetCoeffRat()

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

Definition at line 1714 of file p_polys.cc.

1715{
1716 poly q = pNext(p);
1717 poly res; // = p_Head(p,r);
1718 res = p_GetExp_k_n(p, ishift+1, r->N, r); // does pSetm internally
1719 p_SetCoeff(res,n_Copy(p_GetCoeff(p,r),r),r);
1720 poly s;
1721 long cmp = p_GetComp(p, r);
1722 while ( (q!= NULL) && (p_Comp_k_n(p, q, ishift+1, r)) && (p_GetComp(q, r) == cmp) )
1723 {
1724 s = p_GetExp_k_n(q, ishift+1, r->N, r);
1725 p_SetCoeff(s,n_Copy(p_GetCoeff(q,r),r),r);
1726 res = p_Add_q(res,s,r);
1727 q = pNext(q);
1728 }
1729 cmp = 0;
1730 p_SetCompP(res,cmp,r);
1731 return res;
1732}
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)
Definition: mpr_complex.cc:357

◆ p_GetExp_k_n()

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

Definition at line 1344 of file p_polys.h.

1345{
1346 if (p == NULL) return NULL;
1348 poly np;
1349 omTypeAllocBin(poly, np, r->PolyBin);
1350 p_SetRingOfLm(np, r);
1351 memcpy(np->exp, p->exp, r->ExpL_Size*sizeof(long));
1352 pNext(np) = NULL;
1353 pSetCoeff0(np, n_Init(1, r->cf));
1354 int i;
1355 for(i=l;i<=k;i++)
1356 {
1357 //np->exp[(r->VarOffset[i] & 0xffffff)] =0;
1358 p_SetExp(np,i,0,r);
1359 }
1360 p_Setm(np,r);
1361 return np;
1362}

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

1493{
1495 for (unsigned j = r->N; j!=0; j--)
1496 ev[j] = p_GetExp(p, j, r);
1497
1498 ev[0] = p_GetComp(p, r);
1499}

◆ p_GetExpVL()

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

Definition at line 1501 of file p_polys.h.

1502{
1504 for (unsigned j = r->N; j!=0; j--)
1505 ev[j-1] = p_GetExp(p, j, r);
1506}

◆ p_GetExpVLV()

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

Definition at line 1508 of file p_polys.h.

1509{
1511 for (unsigned j = r->N; j!=0; j--)
1512 ev[j-1] = p_GetExp(p, j, r);
1513 return (int64)p_GetComp(p,r);
1514}
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 776 of file p_polys.h.

777{
778 return p_GetMaxExp(p_GetMaxExpL(p, r), r);
779}
static unsigned long p_GetMaxExp(const unsigned long l, const ring r)
Definition: p_polys.h:753
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:1171

◆ p_GetMaxExp() [2/2]

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

Definition at line 753 of file p_polys.h.

754{
755 unsigned long bitmask = r->bitmask;
756 unsigned long max = (l & bitmask);
757 unsigned long j = r->ExpPerLong - 1;
758
759 if (j > 0)
760 {
761 unsigned long i = r->BitsPerExp;
762 long e;
763 loop
764 {
765 e = ((l >> i) & bitmask);
766 if ((unsigned long) e > max)
767 max = e;
768 j--;
769 if (j==0) break;
770 i += r->BitsPerExp;
771 }
772 }
773 return max;
774}
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 1171 of file p_polys.cc.

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

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

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

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

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

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

Definition at line 4814 of file p_polys.cc.

4815{
4816 assume(p != NULL);
4817 unsigned long ev = 0; // short exponent vector
4818 unsigned int n = BIT_SIZEOF_LONG / r->N; // number of bits per exp
4819 unsigned int m1; // highest bit which is filled with (n+1)
4820 unsigned int i=0;
4821 int j=1;
4822
4823 if (n == 0)
4824 {
4825 if (r->N <2*BIT_SIZEOF_LONG)
4826 {
4827 n=1;
4828 m1=0;
4829 }
4830 else
4831 {
4832 for (; j<=r->N; j++)
4833 {
4834 if (p_GetExp(p,j,r) > 0) i++;
4835 if (i == BIT_SIZEOF_LONG) break;
4836 }
4837 if (i>0)
4838 ev = ~(0UL) >> (BIT_SIZEOF_LONG - i);
4839 return ev;
4840 }
4841 }
4842 else
4843 {
4844 m1 = (n+1)*(BIT_SIZEOF_LONG - n*r->N);
4845 }
4846
4847 n++;
4848 while (i<m1)
4849 {
4850 ev |= GetBitFields(p_GetExp(p, j,r), i, n);
4851 i += n;
4852 j++;
4853 }
4854
4855 n--;
4856 while (i<BIT_SIZEOF_LONG)
4857 {
4858 ev |= GetBitFields(p_GetExp(p, j,r), i, n);
4859 i += n;
4860 j++;
4861 }
4862 return ev;
4863}
#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:4781

◆ p_GetShortExpVector() [2/2]

unsigned long p_GetShortExpVector ( const poly  p,
const poly  pp,
const ring  r 
)

p_GetShortExpVector of p * pp

Definition at line 4867 of file p_polys.cc.

4868{
4869 assume(p != NULL);
4870 assume(pp != NULL);
4871
4872 unsigned long ev = 0; // short exponent vector
4873 unsigned int n = BIT_SIZEOF_LONG / r->N; // number of bits per exp
4874 unsigned int m1; // highest bit which is filled with (n+1)
4875 int j=1;
4876 unsigned long i = 0L;
4877
4878 if (n == 0)
4879 {
4880 if (r->N <2*BIT_SIZEOF_LONG)
4881 {
4882 n=1;
4883 m1=0;
4884 }
4885 else
4886 {
4887 for (; j<=r->N; j++)
4888 {
4889 if (p_GetExp(p,j,r) > 0 || p_GetExp(pp,j,r) > 0) i++;
4890 if (i == BIT_SIZEOF_LONG) break;
4891 }
4892 if (i>0)
4893 ev = ~(0UL) >> (BIT_SIZEOF_LONG - i);
4894 return ev;
4895 }
4896 }
4897 else
4898 {
4899 m1 = (n+1)*(BIT_SIZEOF_LONG - n*r->N);
4900 }
4901
4902 n++;
4903 while (i<m1)
4904 {
4905 ev |= GetBitFields(p_GetExp(p, j,r) + p_GetExp(pp, j,r), i, n);
4906 i += n;
4907 j++;
4908 }
4909
4910 n--;
4911 while (i<BIT_SIZEOF_LONG)
4912 {
4913 ev |= GetBitFields(p_GetExp(p, j,r) + p_GetExp(pp, j,r), i, n);
4914 i += n;
4915 j++;
4916 }
4917 return ev;
4918}

◆ p_GetTotalDegree()

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

Definition at line 782 of file p_polys.h.

783{
784 const unsigned long bitmask = r->bitmask;
785 unsigned long sum = (l & bitmask);
786 unsigned long j = number_of_exps - 1;
787
788 if (j > 0)
789 {
790 unsigned long i = r->BitsPerExp;
791 loop
792 {
793 sum += ((l >> i) & bitmask);
794 j--;
795 if (j==0) break;
796 i += r->BitsPerExp;
797 }
798 }
799 return sum;
800}

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

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

◆ p_HasNotCF()

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

Definition at line 1325 of file p_polys.cc.

1326{
1327
1328 if (p_GetComp(p1,r) > 0 || p_GetComp(p2,r) > 0)
1329 return FALSE;
1330 int i = rVar(r);
1331 loop
1332 {
1333 if ((p_GetExp(p1, i, r) > 0) && (p_GetExp(p2, i, r) > 0))
1334 return FALSE;
1335 i--;
1336 if (i == 0)
1337 return TRUE;
1338 }
1339}

◆ p_HasNotCFRing()

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

Definition at line 1341 of file p_polys.cc.

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

◆ p_Head()

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

copy the (leading) term of p

Definition at line 832 of file p_polys.h.

833{
834 if (p == NULL) return NULL;
836 poly np;
837 omTypeAllocBin(poly, np, r->PolyBin);
838 p_SetRingOfLm(np, r);
839 memcpy(np->exp, p->exp, r->ExpL_Size*sizeof(long));
840 pNext(np) = NULL;
841 pSetCoeff0(np, n_Copy(pGetCoeff(p), r->cf));
842 return np;
843}

◆ p_Head0()

poly p_Head0 ( const poly  p,
const ring  r 
)

like p_Head, but allow NULL coeff

Definition at line 5030 of file p_polys.cc.

5031{
5032 if (p==NULL) return NULL;
5033 if (pGetCoeff(p)==NULL) return p_CopyPowerProduct0(p,NULL,r);
5034 return p_Head(p,r);
5035}

◆ p_Homogen()

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

Definition at line 3331 of file p_polys.cc.

3332{
3333 pFDegProc deg;
3334 if (r->pLexOrder && (r->order[0]==ringorder_lp))
3335 deg=p_Totaldegree;
3336 else
3337 deg=r->pFDeg;
3338
3339 poly q=NULL, qn;
3340 int o,ii;
3341 sBucket_pt bp;
3342
3343 if (p!=NULL)
3344 {
3345 if ((varnum < 1) || (varnum > rVar(r)))
3346 {
3347 return NULL;
3348 }
3349 o=deg(p,r);
3350 q=pNext(p);
3351 while (q != NULL)
3352 {
3353 ii=deg(q,r);
3354 if (ii>o) o=ii;
3355 pIter(q);
3356 }
3357 q = p_Copy(p,r);
3358 bp = sBucketCreate(r);
3359 while (q != NULL)
3360 {
3361 ii = o-deg(q,r);
3362 if (ii!=0)
3363 {
3364 p_AddExp(q,varnum, (long)ii,r);
3365 p_Setm(q,r);
3366 }
3367 qn = pNext(q);
3368 pNext(q) = NULL;
3369 sBucket_Add_m(bp, q);
3370 q = qn;
3371 }
3372 sBucketDestroyAdd(bp, &q, &ii);
3373 }
3374 return q;
3375}
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 1302 of file p_polys.h.

1303{
1304 return p_Init(r, r->PolyBin);
1305}

◆ p_Init() [2/2]

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

Definition at line 1292 of file p_polys.h.

1293{
1294 p_CheckRing1(r);
1295 pAssume1(bin != NULL && omSizeWOfBin(r->PolyBin) == omSizeWOfBin(bin));
1296 poly p;
1297 omTypeAlloc0Bin(poly, p, bin);
1299 p_SetRingOfLm(p, r);
1300 return p;
1301}
#define p_CheckRing1(r)
Definition: monomials.h:178
#define omTypeAlloc0Bin(type, addr, bin)
Definition: omAllocDecl.h:204

◆ p_InitContent()

number p_InitContent ( poly  ph,
const ring  r 
)

Definition at line 2696 of file p_polys.cc.

2699{
2701 assume(ph!=NULL);
2702 assume(pNext(ph)!=NULL);
2703 assume(rField_is_Q(r));
2704 if (pNext(pNext(ph))==NULL)
2705 {
2706 return n_GetNumerator(pGetCoeff(pNext(ph)),r->cf);
2707 }
2708 poly p=ph;
2709 number n1=n_GetNumerator(pGetCoeff(p),r->cf);
2710 pIter(p);
2711 number n2=n_GetNumerator(pGetCoeff(p),r->cf);
2712 pIter(p);
2713 number d;
2714 number t;
2715 loop
2716 {
2717 nlNormalize(pGetCoeff(p),r->cf);
2718 t=n_GetNumerator(pGetCoeff(p),r->cf);
2719 if (nlGreaterZero(t,r->cf))
2720 d=nlAdd(n1,t,r->cf);
2721 else
2722 d=nlSub(n1,t,r->cf);
2723 nlDelete(&t,r->cf);
2724 nlDelete(&n1,r->cf);
2725 n1=d;
2726 pIter(p);
2727 if (p==NULL) break;
2728 nlNormalize(pGetCoeff(p),r->cf);
2729 t=n_GetNumerator(pGetCoeff(p),r->cf);
2730 if (nlGreaterZero(t,r->cf))
2731 d=nlAdd(n2,t,r->cf);
2732 else
2733 d=nlSub(n2,t,r->cf);
2734 nlDelete(&t,r->cf);
2735 nlDelete(&n2,r->cf);
2736 n2=d;
2737 pIter(p);
2738 if (p==NULL) break;
2739 }
2740 d=nlGcd(n1,n2,r->cf);
2741 nlDelete(&n1,r->cf);
2742 nlDelete(&n2,r->cf);
2743 return d;
2744}
2745#else
2746{
2747 /* ph has al least 2 terms */
2748 number d=pGetCoeff(ph);
2749 int s=n_Size(d,r->cf);
2750 pIter(ph);
2751 number d2=pGetCoeff(ph);
2752 int s2=n_Size(d2,r->cf);
2753 pIter(ph);
2754 if (ph==NULL)
2755 {
2756 if (s<s2) return n_Copy(d,r->cf);
2757 else return n_Copy(d2,r->cf);
2758 }
2759 do
2760 {
2761 number nd=pGetCoeff(ph);
2762 int ns=n_Size(nd,r->cf);
2763 if (ns<=2)
2764 {
2765 s2=s;
2766 d2=d;
2767 d=nd;
2768 s=ns;
2769 break;
2770 }
2771 else if (ns<s)
2772 {
2773 s2=s;
2774 d2=d;
2775 d=nd;
2776 s=ns;
2777 }
2778 pIter(ph);
2779 }
2780 while(ph!=NULL);
2781 return n_SubringGcd(d,d2,r->cf);
2782}
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:570
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:608
LINLINE number nlAdd(number la, number li, const coeffs r)
Definition: longrat.cc:2701
LINLINE number nlSub(number la, number li, const coeffs r)
Definition: longrat.cc:2767
LINLINE void nlDelete(number *a, const coeffs r)
Definition: longrat.cc:2666
BOOLEAN nlGreaterZero(number za, const coeffs r)
Definition: longrat.cc:1308
number nlGcd(number a, number b, const coeffs r)
Definition: longrat.cc:1345
void nlNormalize(number &x, const coeffs r)
Definition: longrat.cc:1486

◆ p_IsConstant()

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

Definition at line 1983 of file p_polys.h.

1984{
1985 if (p == NULL) return TRUE;
1986 return (pNext(p)==NULL) && p_LmIsConstant(p, r);
1987}
static BOOLEAN p_LmIsConstant(const poly p, const ring r)
Definition: p_polys.h:995

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

1978{
1979 if (p == NULL) return TRUE;
1980 return (pNext(p)==NULL) && p_LmIsConstantComp(p, r);
1981}
static BOOLEAN p_LmIsConstantComp(const poly p, const ring r)
Definition: p_polys.h:978

◆ p_IsConstantPoly()

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

Definition at line 1997 of file p_polys.h.

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

◆ p_ISet()

poly p_ISet ( long  i,
const ring  r 
)

returns the poly representing the integer i

Definition at line 1293 of file p_polys.cc.

1294{
1295 poly rc = NULL;
1296 if (i!=0)
1297 {
1298 rc = p_Init(r);
1299 pSetCoeff0(rc,n_Init(i,r->cf));
1300 if (n_IsZero(pGetCoeff(rc),r->cf))
1301 p_LmDelete(&rc,r);
1302 }
1303 return rc;
1304}

◆ p_IsHomogeneous()

BOOLEAN p_IsHomogeneous ( poly  p,
const ring  r 
)

Definition at line 3380 of file p_polys.cc.

3381{
3382 poly qp=p;
3383 int o;
3384
3385 if ((p == NULL) || (pNext(p) == NULL)) return TRUE;
3386 pFDegProc d;
3387 if (r->pLexOrder && (r->order[0]==ringorder_lp))
3388 d=p_Totaldegree;
3389 else
3390 d=r->pFDeg;
3391 o = d(p,r);
3392 do
3393 {
3394 if (d(qp,r) != o) return FALSE;
3395 pIter(qp);
3396 }
3397 while (qp != NULL);
3398 return TRUE;
3399}

◆ p_IsOne()

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

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

Definition at line 1990 of file p_polys.h.

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

◆ p_IsPurePower()

int p_IsPurePower ( const poly  p,
const ring  r 
)

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

Definition at line 1222 of file p_polys.cc.

1223{
1224 int i,k=0;
1225
1226 for (i=r->N;i;i--)
1227 {
1228 if (p_GetExp(p,i, r)!=0)
1229 {
1230 if(k!=0) return 0;
1231 k=i;
1232 }
1233 }
1234 return k;
1235}

◆ p_IsUnit()

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

Definition at line 2010 of file p_polys.h.

2011{
2012 if (p == NULL) return FALSE;
2013 if (rField_is_Ring(r))
2014 return (p_LmIsConstant(p, r) && n_IsUnit(pGetCoeff(p),r->cf));
2015 return p_LmIsConstant(p, r);
2016}
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:515

◆ p_IsUnivariate()

int p_IsUnivariate ( poly  p,
const ring  r 
)

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

Definition at line 1243 of file p_polys.cc.

1244{
1245 int i,k=-1;
1246
1247 while (p!=NULL)
1248 {
1249 for (i=r->N;i;i--)
1250 {
1251 if (p_GetExp(p,i, r)!=0)
1252 {
1253 if((k!=-1)&&(k!=i)) return 0;
1254 k=i;
1255 }
1256 }
1257 pIter(p);
1258 }
1259 return k;
1260}

◆ p_Jet()

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

Definition at line 4419 of file p_polys.cc.

4420{
4421 while((p!=NULL) && (p_Totaldegree(p,R)>m)) p_LmDelete(&p,R);
4422 if (p==NULL) return NULL;
4423 poly r=p;
4424 while (pNext(p)!=NULL)
4425 {
4426 if (p_Totaldegree(pNext(p),R)>m)
4427 {
4428 p_LmDelete(&pNext(p),R);
4429 }
4430 else
4431 pIter(p);
4432 }
4433 return r;
4434}

◆ p_JetW()

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

Definition at line 4463 of file p_polys.cc.

4464{
4465 while((p!=NULL) && (totaldegreeWecart_IV(p,R,w)>m)) p_LmDelete(&p,R);
4466 if (p==NULL) return NULL;
4467 poly r=p;
4468 while (pNext(p)!=NULL)
4469 {
4471 {
4472 p_LmDelete(&pNext(p),R);
4473 }
4474 else
4475 pIter(p);
4476 }
4477 return r;
4478}

◆ p_Last()

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

Definition at line 4654 of file p_polys.cc.

4655{
4656 if (p == NULL)
4657 {
4658 l = 0;
4659 return NULL;
4660 }
4661 l = 1;
4662 poly a = p;
4663 if (! rIsSyzIndexRing(r))
4664 {
4665 poly next = pNext(a);
4666 while (next!=NULL)
4667 {
4668 a = next;
4669 next = pNext(a);
4670 l++;
4671 }
4672 }
4673 else
4674 {
4675 long unsigned curr_limit = rGetCurrSyzLimit(r);
4676 poly pp = a;
4677 while ((a=pNext(a))!=NULL)
4678 {
4679 if (__p_GetComp(a,r)<=curr_limit/*syzComp*/)
4680 l++;
4681 else break;
4682 pp = a;
4683 }
4684 a=pp;
4685 }
4686 return a;
4687}
ListNode * next
Definition: janet.h:31
static int rGetCurrSyzLimit(const ring r)
Definition: ring.h:724
static BOOLEAN rIsSyzIndexRing(const ring r)
Definition: ring.h:721

◆ p_Lcm() [1/2]

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

Definition at line 1656 of file p_polys.cc.

1657{
1658 poly m=p_Init(r);
1659 p_Lcm(a, b, m, r);
1660 p_Setm(m,r);
1661 return(m);
1662}
void p_Lcm(const poly a, const poly b, poly m, const ring r)
Definition: p_polys.cc:1647

◆ p_Lcm() [2/2]

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

Definition at line 1647 of file p_polys.cc.

1648{
1649 for (int i=r->N; i; --i)
1650 p_SetExp(m,i, si_max( p_GetExp(a,i,r), p_GetExp(b,i,r)),r);
1651
1652 p_SetComp(m, si_max(p_GetComp(a,r), p_GetComp(b,r)),r);
1653 /* Don't do a pSetm here, otherwise hres/lres chockes */
1654}
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 1669 of file p_polys.cc.

1670{
1671 poly m = // p_One( r);
1672 p_Init(r);
1673
1674// const int (currRing->N) = r->N;
1675
1676 // for (int i = (currRing->N); i>=r->real_var_start; i--)
1677 for (int i = r->real_var_end; i>=r->real_var_start; i--)
1678 {
1679 const int lExpA = p_GetExp (a, i, r);
1680 const int lExpB = p_GetExp (b, i, r);
1681
1682 p_SetExp (m, i, si_max(lExpA, lExpB), r);
1683 }
1684
1685 p_SetComp (m, lCompM, r);
1686 p_Setm(m,r);
1687 n_New(&(p_GetCoeff(m, r)), r);
1688
1689 return(m);
1690};
#define n_New(n, r)
Definition: coeffs.h:440

◆ 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 71 of file pDebug.cc.

72{
73 if (p != NULL)
74 {
75 #if (OM_TRACK > 0) && defined(OM_TRACK_CUSTOM)
76 void* custom = omGetCustomOfAddr(p);
77 if (custom != NULL)
78 {
79 pPolyAssumeReturnMsg(custom == r ||
80 // be more sloppy for qrings
81 (r->qideal != NULL &&
83 omSizeWOfAddr(p)==omSizeWOfBin(r->PolyBin)) ||
84 rSamePolyRep((ring) custom, r),
85 "monomial not from specified ring",p,r);
86 return TRUE;
87 }
88 else
89 #endif
90 #ifndef X_OMALLOC
91 {
94 return TRUE;
95 }
96 return FALSE;
97 #endif
98 }
99 return TRUE;
100}
#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:269

◆ p_LmCheckPolyRing()

BOOLEAN p_LmCheckPolyRing ( poly  p,
ring  r 
)

Definition at line 120 of file pDebug.cc.

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

◆ p_LmCmp()

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

Definition at line 1552 of file p_polys.h.

1553{
1555 p_LmCheckPolyRing1(q, r);
1556
1557 const unsigned long* _s1 = ((unsigned long*) p->exp);
1558 const unsigned long* _s2 = ((unsigned long*) q->exp);
1559 REGISTER unsigned long _v1;
1560 REGISTER unsigned long _v2;
1561 const unsigned long _l = r->CmpL_Size;
1562
1563 REGISTER unsigned long _i=0;
1564
1565 LengthGeneral_OrdGeneral_LoopTop:
1566 _v1 = _s1[_i];
1567 _v2 = _s2[_i];
1568 if (_v1 == _v2)
1569 {
1570 _i++;
1571 if (_i == _l) return 0;
1572 goto LengthGeneral_OrdGeneral_LoopTop;
1573 }
1574 const long* _ordsgn = (long*) r->ordsgn;
1575#if 1 /* two variants*/
1576 if (_v1 > _v2)
1577 {
1578 return _ordsgn[_i];
1579 }
1580 return -(_ordsgn[_i]);
1581#else
1582 if (_v1 > _v2)
1583 {
1584 if (_ordsgn[_i] == 1) return 1;
1585 return -1;
1586 }
1587 if (_ordsgn[_i] == 1) return -1;
1588 return 1;
1589#endif
1590}
if(yy_init)
Definition: libparse.cc:1420
#define REGISTER
Definition: omalloc.h:27

◆ p_LmDelete() [1/2]

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

Definition at line 723 of file p_polys.h.

724{
726 poly h = *p;
727 *p = pNext(h);
728 n_Delete(&pGetCoeff(h), r->cf);
730}
#define omFreeBinAddr(addr)
Definition: omAllocDecl.h:258

◆ p_LmDelete() [2/2]

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

Definition at line 711 of file p_polys.h.

712{
714 n_Delete(&pGetCoeff(p), r->cf);
716}

◆ p_LmDelete0()

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

Definition at line 717 of file p_polys.h.

718{
720 if (pGetCoeff(p)!=NULL) n_Delete(&pGetCoeff(p), r->cf);
722}

◆ p_LmDeleteAndNext()

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

Definition at line 731 of file p_polys.h.

732{
734 poly pnext = pNext(p);
735 n_Delete(&pGetCoeff(p), r->cf);
737 return pnext;
738}

◆ p_LmDeleteAndNextRat()

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

Definition at line 1692 of file p_polys.cc.

1693{
1694 /* modifies p*/
1695 // Print("start: "); Print(" "); p_wrp(*p,r);
1696 p_LmCheckPolyRing2(*p, r);
1697 poly q = p_Head(*p,r);
1698 const long cmp = p_GetComp(*p, r);
1699 while ( ( (*p)!=NULL ) && ( p_Comp_k_n(*p, q, ishift+1, r) ) && (p_GetComp(*p, r) == cmp) )
1700 {
1701 p_LmDelete(p,r);
1702 // Print("while: ");p_wrp(*p,r);Print(" ");
1703 }
1704 // p_wrp(*p,r);Print(" ");
1705 // PrintS("end\n");
1706 p_LmDelete(&q,r);
1707}

◆ p_LmDivisibleBy() [1/2]

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

Definition at line 1902 of file p_polys.h.

1903{
1904 p_LmCheckPolyRing(a, r_a);
1905 p_LmCheckPolyRing(b, r_b);
1906 return _p_LmDivisibleBy(a, r_a, b, r_b);
1907}

◆ p_LmDivisibleBy() [2/2]

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

Definition at line 1875 of file p_polys.h.

1876{
1878 pIfThen1(a != NULL, p_LmCheckPolyRing1(b, r));
1879 if (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r))
1880 return _p_LmDivisibleByNoComp(a, b, r);
1881 return FALSE;
1882}

◆ p_LmDivisibleByNoComp() [1/2]

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

Definition at line 1868 of file p_polys.h.

1869{
1870 p_LmCheckPolyRing1(a, ra);
1871 p_LmCheckPolyRing1(b, rb);
1872 return _p_LmDivisibleByNoComp(a, ra, b, rb);
1873}

◆ p_LmDivisibleByNoComp() [2/2]

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

Definition at line 1861 of file p_polys.h.

1862{
1863 p_LmCheckPolyRing1(a, r);
1865 return _p_LmDivisibleByNoComp(a, b, r);
1866}

◆ p_LmDivisibleByPart()

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

Definition at line 1840 of file p_polys.h.

1841{
1843 pIfThen1(a != NULL, p_LmCheckPolyRing1(b, r));
1844 if (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r))
1845 return _p_LmDivisibleByNoCompPart(a, r, b, r,start, end);
1846 return FALSE;
1847}

◆ p_LmExpVectorAddIsOk()

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

Definition at line 2018 of file p_polys.h.

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

◆ p_LmFree() [1/2]

static void p_LmFree ( poly *  p,
ring   
)
inlinestatic

Definition at line 692 of file p_polys.h.

694{
696 poly h = *p;
697 *p = pNext(h);
699}

◆ p_LmFree() [2/2]

static void p_LmFree ( poly  p,
ring   
)
inlinestatic

Definition at line 683 of file p_polys.h.

685{
688}

◆ p_LmFreeAndNext()

static poly p_LmFreeAndNext ( poly  p,
ring   
)
inlinestatic

Definition at line 703 of file p_polys.h.

705{
707 poly pnext = pNext(p);
709 return pnext;
710}

◆ p_LmInit() [1/3]

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

Definition at line 1307 of file p_polys.h.

1308{
1310 poly np;
1311 omTypeAllocBin(poly, np, r->PolyBin);
1312 p_SetRingOfLm(np, r);
1313 memcpy(np->exp, p->exp, r->ExpL_Size*sizeof(long));
1314 pNext(np) = NULL;
1315 pSetCoeff0(np, NULL);
1316 return np;
1317}

◆ p_LmInit() [2/3]

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

Definition at line 1335 of file p_polys.h.

1336{
1337 pAssume1(d_r != NULL);
1338 return p_LmInit(s_p, s_r, d_r, d_r->PolyBin);
1339}

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

1319{
1320 p_LmCheckPolyRing1(s_p, s_r);
1321 p_CheckRing(d_r);
1322 pAssume1(d_r->N <= s_r->N);
1323 poly d_p = p_Init(d_r, d_bin);
1324 for (unsigned i=d_r->N; i!=0; i--)
1325 {
1326 p_SetExp(d_p, i, p_GetExp(s_p, i,s_r), d_r);
1327 }
1328 if (rRing_has_Comp(d_r))
1329 {
1330 p_SetComp(d_p, p_GetComp(s_p,s_r), d_r);
1331 }
1332 p_Setm(d_p, d_r);
1333 return d_p;
1334}
BOOLEAN p_CheckRing(ring r)
Definition: pDebug.cc:128

◆ p_LmIsConstant()

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

Definition at line 995 of file p_polys.h.

996{
997 if (p_LmIsConstantComp(p, r))
998 return (p_GetComp(p, r) == 0);
999 return FALSE;
1000}

◆ p_LmIsConstantComp()

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

Definition at line 978 of file p_polys.h.

979{
980 //p_LmCheckPolyRing(p, r);
981 int i = r->VarL_Size - 1;
982
983 do
984 {
985 if (p->exp[r->VarL_Offset[i]] != 0)
986 return FALSE;
987 i--;
988 }
989 while (i >= 0);
990 return TRUE;
991}

◆ p_LmShallowCopyDelete()

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

Definition at line 1365 of file p_polys.h.

1366{
1368 pAssume1(omSizeWOfBin(bin) == omSizeWOfBin(r->PolyBin));
1369 poly new_p = p_New(r);
1370 memcpy(new_p->exp, p->exp, r->ExpL_Size*sizeof(long));
1371 pSetCoeff0(new_p, pGetCoeff(p));
1372 pNext(new_p) = pNext(p);
1374 return new_p;
1375}
static poly p_New(const ring, omBin bin)
Definition: p_polys.h:664

◆ p_LmShortDivisibleBy() [1/2]

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

Definition at line 1949 of file p_polys.h.

1951{
1952 p_LmCheckPolyRing1(a, r_a);
1953 p_LmCheckPolyRing1(b, r_b);
1954#ifndef PDIV_DEBUG
1955 _pPolyAssume2(p_GetShortExpVector(a, r_a) == sev_a, a, r_a);
1956 _pPolyAssume2(p_GetShortExpVector(b, r_b) == ~ not_sev_b, b, r_b);
1957
1958 if (sev_a & not_sev_b)
1959 {
1960 pAssume1(_p_LmDivisibleByNoComp(a, r_a, b, r_b) == FALSE);
1961 return FALSE;
1962 }
1963 return _p_LmDivisibleBy(a, r_a, b, r_b);
1964#else
1965 return pDebugLmShortDivisibleBy(a, sev_a, r_a, b, not_sev_b, r_b);
1966#endif
1967}
#define _pPolyAssume2(cond, p, r)
Definition: monomials.h:195
BOOLEAN pDebugLmShortDivisibleBy(poly p1, unsigned long sev_1, ring r_1, poly p2, unsigned long not_sev_2, ring r_2)
Definition: pDebug.cc:366
unsigned long p_GetShortExpVector(const poly a, const ring r)
Definition: p_polys.cc:4814

◆ p_LmShortDivisibleBy() [2/2]

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

Definition at line 1909 of file p_polys.h.

1911{
1912 p_LmCheckPolyRing1(a, r);
1914#ifndef PDIV_DEBUG
1915 _pPolyAssume2(p_GetShortExpVector(a, r) == sev_a, a, r);
1916 _pPolyAssume2(p_GetShortExpVector(b, r) == ~ not_sev_b, b, r);
1917
1918 if (sev_a & not_sev_b)
1919 {
1921 return FALSE;
1922 }
1923 return p_LmDivisibleBy(a, b, r);
1924#else
1925 return pDebugLmShortDivisibleBy(a, sev_a, r, b, not_sev_b, r);
1926#endif
1927}
static BOOLEAN p_LmDivisibleByNoComp(poly a, poly b, const ring r)
Definition: p_polys.h:1861
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
Definition: p_polys.h:1875

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

1931{
1932 p_LmCheckPolyRing1(a, r);
1934#ifndef PDIV_DEBUG
1935 _pPolyAssume2(p_GetShortExpVector(a, r) == sev_a, a, r);
1936 _pPolyAssume2(p_GetShortExpVector(b, r) == ~ not_sev_b, b, r);
1937
1938 if (sev_a & not_sev_b)
1939 {
1941 return FALSE;
1942 }
1943 return p_LmDivisibleByNoComp(a, b, r);
1944#else
1945 return pDebugLmShortDivisibleByNoComp(a, sev_a, r, b, not_sev_b, r);
1946#endif
1947}
BOOLEAN pDebugLmShortDivisibleByNoComp(poly p1, unsigned long sev_1, ring r_1, poly p2, unsigned long not_sev_2, ring r_2)
Definition: pDebug.cc:389

◆ p_LowVar()

int p_LowVar ( poly  p,
const ring  r 
)

the minimal index of used variables - 1

Definition at line 4713 of file p_polys.cc.

4714{
4715 int k,l,lex;
4716
4717 if (p == NULL) return -1;
4718
4719 k = 32000;/*a very large dummy value*/
4720 while (p != NULL)
4721 {
4722 l = 1;
4723 lex = p_GetExp(p,l,r);
4724 while ((l < (rVar(r))) && (lex == 0))
4725 {
4726 l++;
4727 lex = p_GetExp(p,l,r);
4728 }
4729 l--;
4730 if (l < k) k = l;
4731 pIter(p);
4732 }
4733 return k;
4734}

◆ p_LtCmp()

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

Definition at line 1593 of file p_polys.h.

1594{
1595 int res = p_LmCmp(p,q,r);
1596 if(res == 0)
1597 {
1598 if(p_GetCoeff(p,r) == NULL || p_GetCoeff(q,r) == NULL)
1599 return res;
1600 number pc = n_Copy(p_GetCoeff(p,r),r->cf);
1601 number qc = n_Copy(p_GetCoeff(q,r),r->cf);
1602 if(!n_GreaterZero(pc,r->cf))
1603 pc = n_InpNeg(pc,r->cf);
1604 if(!n_GreaterZero(qc,r->cf))
1605 qc = n_InpNeg(qc,r->cf);
1606 if(n_Greater(pc,qc,r->cf))
1607 res = 1;
1608 else if(n_Greater(qc,pc,r->cf))
1609 res = -1;
1610 else if(n_Equal(pc,qc,r->cf))
1611 res = 0;
1612 n_Delete(&pc,r->cf);
1613 n_Delete(&qc,r->cf);
1614 }
1615 return res;
1616}
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:511

◆ p_LtCmpNoAbs()

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

Definition at line 1619 of file p_polys.h.

1620{
1621 int res = p_LmCmp(p,q,r);
1622 if(res == 0)
1623 {
1624 if(p_GetCoeff(p,r) == NULL || p_GetCoeff(q,r) == NULL)
1625 return res;
1626 number pc = p_GetCoeff(p,r);
1627 number qc = p_GetCoeff(q,r);
1628 if(n_Greater(pc,qc,r->cf))
1629 res = 1;
1630 if(n_Greater(qc,pc,r->cf))
1631 res = -1;
1632 if(n_Equal(pc,qc,r->cf))
1633 res = 0;
1634 }
1635 return res;
1636}

◆ p_LtCmpOrdSgnDiffM()

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

Definition at line 1641 of file p_polys.h.

1642{
1643 if(r->OrdSgn == 1)
1644 {
1645 return(p_LtCmp(p,q,r) == 1);
1646 }
1647 else
1648 {
1649 return(p_LmCmp(p,q,r) == -1);
1650 }
1651}
static int p_LtCmp(poly p, poly q, const ring r)
Definition: p_polys.h:1593

◆ p_LtCmpOrdSgnDiffP()

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

Definition at line 1657 of file p_polys.h.

1658{
1659 if(r->OrdSgn == 1)
1660 {
1661 return(p_LmCmp(p,q,r) == -1);
1662 }
1663 else
1664 {
1665 return(p_LtCmp(p,q,r) != -1);
1666 }
1667
1668}

◆ p_LtCmpOrdSgnEqM()

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

Definition at line 1674 of file p_polys.h.

1675{
1676 return(p_LtCmp(p,q,r) == -r->OrdSgn);
1677}

◆ p_LtCmpOrdSgnEqP()

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

Definition at line 1683 of file p_polys.h.

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

◆ 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;
297 result = p_GetComp(p, lmRing);
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 5036 of file p_polys.cc.

5037{
5038 int m=0;
5039 while(p!=NULL)
5040 {
5041 int mm=p_GetExp(p,i,r);
5042 if (mm>m) m=mm;
5043 pIter(p);
5044 }
5045 return m;
5046}

◆ p_MDivide()

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

Definition at line 1484 of file p_polys.cc.

1485{
1486 assume((p_GetComp(a,r)==p_GetComp(b,r)) || (p_GetComp(b,r)==0));
1487 int i;
1488 poly result = p_Init(r);
1489
1490 for(i=(int)r->N; i; i--)
1491 p_SetExp(result,i, p_GetExp(a,i,r)- p_GetExp(b,i,r),r);
1492 p_SetComp(result, p_GetComp(a,r) - p_GetComp(b,r),r);
1493 p_Setm(result,r);
1494 return result;
1495}

◆ p_MemAdd_NegWeightAdjust()

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

Definition at line 1264 of file p_polys.h.

1265{
1266 if (r->NegWeightL_Offset != NULL)
1267 {
1268 for (int i=r->NegWeightL_Size-1; i>=0; i--)
1269 {
1270 p->exp[r->NegWeightL_Offset[i]] -= POLY_NEGWEIGHT_OFFSET;
1271 }
1272 }
1273}

◆ p_MemSub_NegWeightAdjust()

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

Definition at line 1274 of file p_polys.h.

1275{
1276 if (r->NegWeightL_Offset != NULL)
1277 {
1278 for (int i=r->NegWeightL_Size-1; i>=0; i--)
1279 {
1280 p->exp[r->NegWeightL_Offset[i]] += POLY_NEGWEIGHT_OFFSET;
1281 }
1282 }
1283}

◆ p_Merge_q()

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

Definition at line 1184 of file p_polys.h.

1185{
1186 assume( (p != q) || (p == NULL && q == NULL) );
1187 return r->p_Procs->p_Merge_q(p, q, r);
1188}

◆ 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;
318 result = p_GetComp(p,lmRing);
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 4481 of file p_polys.cc.

4482{
4483 if(p==NULL)
4484 return -1;
4485 int d=-1;
4486 while(p!=NULL)
4487 {
4488 int d0=0;
4489 for(int j=0;j<rVar(R);j++)
4490 if(w==NULL||j>=w->length())
4491 d0+=p_GetExp(p,j+1,R);
4492 else
4493 d0+=(*w)[j]*p_GetExp(p,j+1,R);
4494 if(d0<d||d==-1)
4495 d=d0;
4496 pIter(p);
4497 }
4498 return d;
4499}

◆ p_mInit()

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

Definition at line 1438 of file p_polys.cc.

1439{
1440 poly p;
1441 const char *s=p_Read(st,p,r);
1442 if (*s!='\0')
1443 {
1444 if ((s!=st)&&isdigit(st[0]))
1445 {
1447 }
1448 ok=FALSE;
1449 if (p!=NULL)
1450 {
1451 if (pGetCoeff(p)==NULL) p_LmFree(p,r);
1452 else p_LmDelete(p,r);
1453 }
1454 return NULL;
1455 }
1456 p_Test(p,r);
1457 ok=!errorreported;
1458 return p;
1459}
VAR short errorreported
Definition: feFopen.cc:23
const char * p_Read(const char *st, poly &rc, const ring r)
Definition: p_polys.cc:1366

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

1054{
1055 int shorter;
1056
1057 return r->p_Procs->p_Minus_mm_Mult_qq(p, m, q, shorter, NULL, r);
1058}

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

1044{
1045 int shorter;
1046 const poly res = r->p_Procs->p_Minus_mm_Mult_qq(p, m, q, shorter, spNoether, r);
1047 lp += lq - shorter;
1048// assume( lp == pLength(res) );
1049 return res;
1050}

◆ p_mm_Mult()

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

Definition at line 1033 of file p_polys.h.

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

◆ p_Mult_mm()

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

Definition at line 1023 of file p_polys.h.

1024{
1025 if (p==NULL) return NULL;
1026 if (p_LmIsConstant(m, r))
1027 return __p_Mult_nn(p, pGetCoeff(m), r);
1028 else
1029 return r->p_Procs->p_Mult_mm(p, m, r);
1030}

◆ p_Mult_nn() [1/2]

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

Definition at line 945 of file p_polys.h.

947{
948 assume(p!=NULL);
949#ifndef PDEBUG
950 if (lmRing == tailRing)
951 return p_Mult_nn(p, n, tailRing);
952#endif
953 poly pnext = pNext(p);
954 pNext(p) = NULL;
955 p = lmRing->p_Procs->p_Mult_nn(p, n, lmRing);
956 if (pnext!=NULL)
957 {
958 pNext(p) = tailRing->p_Procs->p_Mult_nn(pnext, n, tailRing);
959 }
960 return p;
961}
static poly p_Mult_nn(poly p, number n, const ring r)
Definition: p_polys.h:930

◆ p_Mult_nn() [2/2]

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

Definition at line 930 of file p_polys.h.

931{
932 if (p==NULL) return NULL;
933 if (n_IsOne(n, r->cf))
934 return p;
935 else if (n_IsZero(n, r->cf))
936 {
937 p_Delete(&p, r); // NOTE: without p_Delete - memory leak!
938 return NULL;
939 }
940 else
941 return r->p_Procs->p_Mult_nn(p, n, r);
942}

◆ p_Mult_q()

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

Definition at line 1086 of file p_polys.h.

1087{
1088 assume( (p != q) || (p == NULL && q == NULL) );
1089
1090 if (p == NULL)
1091 {
1092 p_Delete(&q, r);
1093 return NULL;
1094 }
1095 if (q == NULL)
1096 {
1097 p_Delete(&p, r);
1098 return NULL;
1099 }
1100
1101 if (pNext(p) == NULL)
1102 {
1103 q = r->p_Procs->p_mm_Mult(q, p, r);
1104 p_LmDelete(&p, r);
1105 return q;
1106 }
1107
1108 if (pNext(q) == NULL)
1109 {
1110 p = r->p_Procs->p_Mult_mm(p, q, r);
1111 p_LmDelete(&q, r);
1112 return p;
1113 }
1114#if defined(HAVE_PLURAL) || defined(HAVE_SHIFTBBA)
1115 if (rIsNCRing(r))
1116 return _nc_p_Mult_q(p, q, r);
1117 else
1118#endif
1119 return _p_Mult_q(p, q, 0, r);
1120}
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 1079 of file p_polys.h.

1080{
1081 return r->p_Procs->p_Neg(p, r);
1082}

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

3794{
3795 if (rField_is_Ring(r))
3796 {
3797 if(!n_GreaterZero(pGetCoeff(p1),r->cf)) p1 = p_Neg(p1,r);
3798 if (!n_IsUnit(pGetCoeff(p1), r->cf)) return;
3799 // Werror("p_Norm not possible in the case of coefficient rings.");
3800 }
3801 else if (p1!=NULL)
3802 {
3803 if (pNext(p1)==NULL)
3804 {
3805 p_SetCoeff(p1,n_Init(1,r->cf),r);
3806 return;
3807 }
3808 if (!n_IsOne(pGetCoeff(p1),r->cf))
3809 {
3810 number k, c;
3811 n_Normalize(pGetCoeff(p1),r->cf);
3812 k = pGetCoeff(p1);
3813 c = n_Init(1,r->cf);
3814 pSetCoeff0(p1,c);
3815 poly h = pNext(p1);
3816 while (h!=NULL)
3817 {
3818 c=n_Div(pGetCoeff(h),k,r->cf);
3819 // no need to normalize: Z/p, R
3820 // normalize already in nDiv: Q_a, Z/p_a
3821 // remains: Q
3822 if (rField_is_Q(r) && (!n_IsOne(c,r->cf))) n_Normalize(c,r->cf);
3823 p_SetCoeff(h,c,r);
3824 pIter(h);
3825 }
3826 n_Delete(&k,r->cf);
3827 }
3828 else
3829 {
3830 //if (r->cf->cfNormalize != nDummy2) //TODO: OPTIMIZE
3831 if (rField_is_Q(r))
3832 {
3833 poly h = pNext(p1);
3834 while (h!=NULL)
3835 {
3836 n_Normalize(pGetCoeff(h),r->cf);
3837 pIter(h);
3838 }
3839 }
3840 }
3841 }
3842}

◆ p_Normalize()

void p_Normalize ( poly  p,
const ring  r 
)

Definition at line 3847 of file p_polys.cc.

3848{
3849 if ((rField_has_simple_inverse(r)) /* Z/p, GF(p,n), R, long R/C */
3850 || (r->cf->cfNormalize==ndNormalize)) /* Nemo rings, ...*/
3851 return;
3852 while (p!=NULL)
3853 {
3854 // no test befor n_Normalize: n_Normalize should fix problems
3855 n_Normalize(pGetCoeff(p),r->cf);
3856 pIter(p);
3857 }
3858}
void ndNormalize(number &, const coeffs)
Definition: numbers.cc:163
static BOOLEAN rField_has_simple_inverse(const ring r)
Definition: ring.h:549

◆ p_NSet()

poly p_NSet ( number  n,
const ring  r 
)

returns the poly representing the number n, destroys n

Definition at line 1465 of file p_polys.cc.

1466{
1467 if (n_IsZero(n,r->cf))
1468 {
1469 n_Delete(&n, r->cf);
1470 return NULL;
1471 }
1472 else
1473 {
1474 poly rc = p_Init(r);
1475 pSetCoeff0(rc,n);
1476 return rc;
1477 }
1478}

◆ p_One()

poly p_One ( const ring  r)

Definition at line 1309 of file p_polys.cc.

1310{
1311 poly rc = p_Init(r);
1312 pSetCoeff0(rc,n_Init(1,r->cf));
1313 return rc;
1314}

◆ p_OneComp()

BOOLEAN p_OneComp ( poly  p,
const ring  r 
)

return TRUE if all monoms have the same component

Definition at line 1204 of file p_polys.cc.

1205{
1206 if(p!=NULL)
1207 {
1208 long i = p_GetComp(p, r);
1209 while (pNext(p)!=NULL)
1210 {
1211 pIter(p);
1212 if(i != p_GetComp(p, r)) return FALSE;
1213 }
1214 }
1215 return TRUE;
1216}

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

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

1178{
1179 int lp = 0, lq = 0;
1180 return p_Plus_mm_Mult_qq(p, m, q, lp, lq, r);
1181}
static poly p_Plus_mm_Mult_qq(poly p, poly m, poly q, int &lp, int lq, const ring r)
Definition: p_polys.h:1155

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

1157{
1158#ifdef HAVE_PLURAL
1159 if (rIsPluralRing(r))
1160 return nc_p_Plus_mm_Mult_qq(p, m, q, lp, lq, r);
1161#endif
1162
1163// this should be implemented more efficiently
1164 poly res;
1165 int shorter;
1166 number n_old = pGetCoeff(m);
1167 number n_neg = n_Copy(n_old, r->cf);
1168 n_neg = n_InpNeg(n_neg, r->cf);
1169 pSetCoeff0(m, n_neg);
1170 res = r->p_Procs->p_Minus_mm_Mult_qq(p, m, q, shorter, NULL, r);
1171 lp = (lp + lq) - shorter;
1172 pSetCoeff0(m, n_old);
1173 n_Delete(&n_neg, r->cf);
1174 return res;
1175}
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:400

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

1863{
1864 assume(divisor != NULL);
1865 if (p == NULL) return NULL;
1866
1867 poly result = NULL;
1868 number divisorLC = p_GetCoeff(divisor, r);
1869 int divisorLE = p_GetExp(divisor, 1, r);
1870 while ((p != NULL) && (p_Deg(p, r) >= p_Deg(divisor, r)))
1871 {
1872 /* determine t = LT(p) / LT(divisor) */
1873 poly t = p_ISet(1, r);
1874 number c = n_Div(p_GetCoeff(p, r), divisorLC, r->cf);
1875 n_Normalize(c,r->cf);
1876 p_SetCoeff(t, c, r);
1877 int e = p_GetExp(p, 1, r) - divisorLE;
1878 p_SetExp(t, 1, e, r);
1879 p_Setm(t, r);
1880 if (needResult) result = p_Add_q(result, p_Copy(t, r), r);
1881 p = p_Add_q(p, p_Neg(p_Mult_q(t, p_Copy(divisor, r), r), r), r);
1882 }
1883 return result;
1884}
long p_Deg(poly a, const ring r)
Definition: p_polys.cc:583

◆ p_Power()

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

Definition at line 2189 of file p_polys.cc.

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

◆ p_ProjectiveUnique()

void p_ProjectiveUnique ( poly  p,
const ring  r 
)

Definition at line 3204 of file p_polys.cc.

3205{
3206 if( ph == NULL )
3207 return;
3208
3209 const coeffs C = r->cf;
3210
3211 number h;
3212 poly p;
3213
3214 if (nCoeff_is_Ring(C))
3215 {
3216 p_ContentForGB(ph,r);
3217 if(!n_GreaterZero(pGetCoeff(ph),C)) ph = p_Neg(ph,r);
3218 assume( n_GreaterZero(pGetCoeff(ph),C) );
3219 return;
3220 }
3221
3223 {
3224 if(!n_GreaterZero(pGetCoeff(ph),C)) ph = p_Neg(ph,r);
3225 return;
3226 }
3227 p = ph;
3228
3229 assume(p != NULL);
3230
3231 if(pNext(p)==NULL) // a monomial
3232 {
3233 p_SetCoeff(p, n_Init(1, C), r);
3234 return;
3235 }
3236
3237 assume(pNext(p)!=NULL);
3238
3239 if(!nCoeff_is_Q(C) && !nCoeff_is_transExt(C))
3240 {
3241 h = p_GetCoeff(p, C);
3242 number hInv = n_Invers(h, C);
3243 pIter(p);
3244 while (p!=NULL)
3245 {
3246 p_SetCoeff(p, n_Mult(p_GetCoeff(p, C), hInv, C), r);
3247 pIter(p);
3248 }
3249 n_Delete(&hInv, C);
3250 p = ph;
3251 p_SetCoeff(p, n_Init(1, C), r);
3252 }
3253
3254 p_Cleardenom(ph, r); //removes also Content
3255
3256
3257 /* normalize ph over a transcendental extension s.t.
3258 lead (ph) is > 0 if extRing->cf == Q
3259 or lead (ph) is monic if extRing->cf == Zp*/
3260 if (nCoeff_is_transExt(C))
3261 {
3262 p= ph;
3263 h= p_GetCoeff (p, C);
3264 fraction f = (fraction) h;
3265 number n=p_GetCoeff (NUM (f),C->extRing->cf);
3266 if (rField_is_Q (C->extRing))
3267 {
3268 if (!n_GreaterZero(n,C->extRing->cf))
3269 {
3270 p=p_Neg (p,r);
3271 }
3272 }
3273 else if (rField_is_Zp(C->extRing))
3274 {
3275 if (!n_IsOne (n, C->extRing->cf))
3276 {
3277 n=n_Invers (n,C->extRing->cf);
3278 nMapFunc nMap;
3279 nMap= n_SetMap (C->extRing->cf, C);
3280 number ninv= nMap (n,C->extRing->cf, C);
3281 p=__p_Mult_nn (p, ninv, r);
3282 n_Delete (&ninv, C);
3283 n_Delete (&n, C->extRing->cf);
3284 }
3285 }
3286 p= ph;
3287 }
3288
3289 return;
3290}
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
Definition: coeffs.h:730
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition: coeffs.h:800
poly p_Cleardenom(poly p, const ring r)
Definition: p_polys.cc:2906

◆ p_Read()

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

Definition at line 1366 of file p_polys.cc.

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

4532{
4533 int *ww=iv2array(w,R);
4534 if(p!=NULL)
4535 {
4536 if(u==NULL)
4537 p=p_JetW(p,n,ww,R);
4538 else
4539 p=p_JetW(p_Mult_q(p,p_Invers(n-p_MinDeg(p,w,R),u,w,R),R),n,ww,R);
4540 }
4541 omFreeSize((ADDRESS)ww,(rVar(R)+1)*sizeof(int));
4542 return p;
4543}
static poly p_Invers(int n, poly u, intvec *w, const ring R)
Definition: p_polys.cc:4502
int p_MinDeg(poly p, intvec *w, const ring R)
Definition: p_polys.cc:4481
poly p_JetW(poly p, int m, int *w, const ring R)
Definition: p_polys.cc:4463
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);
286 p_SetmComp(p, 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:1907

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

1517{
1519 for (unsigned j = r->N; j!=0; j--)
1520 p_SetExp(p, j, ev[j], r);
1521
1522 if(ev[0]!=0) p_SetComp(p, ev[0],r);
1523 p_Setm(p, r);
1524}

◆ p_SetExpVL()

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

Definition at line 1525 of file p_polys.h.

1526{
1528 for (unsigned j = r->N; j!=0; j--)
1529 p_SetExp(p, j, ev[j-1], r);
1530 p_SetComp(p, 0,r);
1531
1532 p_Setm(p, r);
1533}

◆ p_SetExpVLV()

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

Definition at line 1536 of file p_polys.h.

1537{
1539 for (unsigned j = r->N; j!=0; j--)
1540 p_SetExp(p, j, ev[j-1], r);
1541 p_SetComp(p, comp,r);
1542
1543 p_Setm(p, r);
1544}
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 3747 of file p_polys.cc.

3748{
3749 if (w!=NULL)
3750 {
3751 r->pModW = w;
3752 pOldFDeg = r->pFDeg;
3753 pOldLDeg = r->pLDeg;
3754 pOldLexOrder = r->pLexOrder;
3756 r->pLexOrder = TRUE;
3757 }
3758 else
3759 {
3760 r->pModW = NULL;
3762 r->pLexOrder = pOldLexOrder;
3763 }
3764}
STATIC_VAR pLDegProc pOldLDeg
Definition: p_polys.cc:3735
void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
Definition: p_polys.cc:3723
STATIC_VAR BOOLEAN pOldLexOrder
Definition: p_polys.cc:3736
STATIC_VAR pFDegProc pOldFDeg
Definition: p_polys.cc:3734
void pSetDegProcs(ring r, pFDegProc new_FDeg, pLDegProc new_lDeg)
Definition: p_polys.cc:3711
static long pModDeg(poly p, ring r)
Definition: p_polys.cc:3738

◆ p_ShallowCopyDelete()

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

Definition at line 900 of file p_polys.h.

901{
903 pAssume2(omSizeWOfBin(r->PolyBin) == omSizeWOfBin(bin));
904 return r->p_Procs->p_ShallowCopyDelete(p, r, bin);
905}

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

4740{
4741 poly qp1 = *p,qp2 = *p;/*working pointers*/
4742 int j = p_MaxComp(*p,r),k = p_MinComp(*p,r);
4743
4744 if (j+i < 0) return ;
4745 BOOLEAN toPoly= ((j == -i) && (j == k));
4746 while (qp1 != NULL)
4747 {
4748 if (toPoly || (__p_GetComp(qp1,r)+i > 0))
4749 {
4750 p_AddComp(qp1,i,r);
4751 p_SetmComp(qp1,r);
4752 qp2 = qp1;
4753 pIter(qp1);
4754 }
4755 else
4756 {
4757 if (qp2 == *p)
4758 {
4759 pIter(*p);
4760 p_LmDelete(&qp2,r);
4761 qp2 = *p;
4762 qp1 = *p;
4763 }
4764 else
4765 {
4766 qp2->next = qp1->next;
4767 if (qp1!=NULL) p_LmDelete(&qp1,r);
4768 qp1 = qp2->next;
4769 }
4770 }
4771 }
4772}
return
Definition: cfGcdAlgExt.cc:218
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 2625 of file p_polys.cc.

2626{
2627 if(TEST_OPT_CONTENTSB) return;
2628 if (ph==NULL) return;
2629 if (pNext(ph)==NULL)
2630 {
2631 p_SetCoeff(ph,n_Init(1,r->cf),r);
2632 return;
2633 }
2634 if (pNext(pNext(ph))==NULL)
2635 {
2636 return;
2637 }
2638 if (!(rField_is_Q(r))
2639 && (!rField_is_Q_a(r))
2640 && (!rField_is_Zp_a(r))
2641 && (!rField_is_Z(r))
2642 )
2643 {
2644 return;
2645 }
2646 number d=p_InitContent(ph,r);
2647 number h=d;
2648 if (n_Size(d,r->cf)<=smax)
2649 {
2650 n_Delete(&h,r->cf);
2651 //if (TEST_OPT_PROT) PrintS("G");
2652 return;
2653 }
2654
2655 poly p=ph;
2656 if (smax==1) smax=2;
2657 while (p!=NULL)
2658 {
2659#if 1
2660 d=n_SubringGcd(h,pGetCoeff(p),r->cf);
2661 n_Delete(&h,r->cf);
2662 h = d;
2663#else
2664 n_InpGcd(h,pGetCoeff(p),r->cf);
2665#endif
2666 if(n_Size(h,r->cf)<smax)
2667 {
2668 //if (TEST_OPT_PROT) PrintS("g");
2669 n_Delete(&h,r->cf);
2670 return;
2671 }
2672 pIter(p);
2673 }
2674 p = ph;
2675 if (!n_GreaterZero(pGetCoeff(p),r->cf)) h=n_InpNeg(h,r->cf);
2676 if(n_IsOne(h,r->cf))
2677 {
2678 n_Delete(&h,r->cf);
2679 return;
2680 }
2681 if (TEST_OPT_PROT) PrintS("c");
2682 while (p!=NULL)
2683 {
2684#if 1
2685 d = n_ExactDiv(pGetCoeff(p),h,r->cf);
2686 p_SetCoeff(p,d,r);
2687#else
2688 STATISTIC(n_ExactDiv); nlInpExactDiv(pGetCoeff(p),h,r->cf); // no such function... ?
2689#endif
2690 pIter(p);
2691 }
2692 n_Delete(&h,r->cf);
2693}
#define TEST_OPT_PROT
Definition: options.h:103

◆ p_Size()

int p_Size ( poly  p,
const ring  r 
)

Definition at line 3314 of file p_polys.cc.

3315{
3316 int count = 0;
3317 if (r->cf->has_simple_Alloc)
3318 return pLength(p);
3319 while ( p != NULL )
3320 {
3321 count+= n_Size( pGetCoeff( p ), r->cf );
3322 pIter( p );
3323 }
3324 return count;
3325}
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 1191 of file p_polys.h.

1192{
1193 if (revert) p = pReverse(p);
1194 return sBucketSortAdd(p, r);
1195}
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 1201 of file p_polys.h.

1202{
1203 if (revert) p = pReverse(p);
1204 return sBucketSortMerge(p, r);
1205}
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 1316 of file p_polys.cc.

1317{
1318 *h=pNext(p);
1319 pNext(p)=NULL;
1320}

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

1213{
1214 return p_String(p, p_ring, p_ring);
1215}
char * p_String(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:322

◆ p_String0() [1/2]

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

print p according to ShortOut in lmRing & tailRing

Definition at line 223 of file polys0.cc.

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

◆ p_String0() [2/2]

static void p_String0 ( poly  p,
ring  p_ring 
)
inlinestatic

Definition at line 1216 of file p_polys.h.

1217{
1218 p_String0(p, p_ring, p_ring);
1219}
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.
210 const BOOLEAN bLMShortOut = rShortOut(lmRing);
211 const BOOLEAN bTAILShortOut = rShortOut(tailRing);
212
213 lmRing->ShortOut = FALSE;
214 tailRing->ShortOut = FALSE;
215
216 p_String0(p, lmRing, tailRing);
217
218 lmRing->ShortOut = bLMShortOut;
219 tailRing->ShortOut = bTAILShortOut;
220}
static BOOLEAN rShortOut(const ring r)
Definition: ring.h:582

◆ 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...
190 const BOOLEAN bLMShortOut = rShortOut(lmRing);
191 const BOOLEAN bTAILShortOut = rShortOut(tailRing);
192
193 lmRing->ShortOut = rCanShortOut(lmRing);
194 tailRing->ShortOut = rCanShortOut(tailRing);
195
196 p_String0(p, lmRing, tailRing);
197
198 lmRing->ShortOut = bLMShortOut;
199 tailRing->ShortOut = bTAILShortOut;
200}
static BOOLEAN rCanShortOut(const ring r)
Definition: ring.h:587

◆ p_Sub()

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

Definition at line 1982 of file p_polys.cc.

1983{
1984 return p_Add_q(p1, p_Neg(p2,r),r);
1985}

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

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

◆ p_TakeOutComp() [1/2]

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

Definition at line 3509 of file p_polys.cc.

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

◆ p_TakeOutComp() [2/2]

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

Definition at line 3570 of file p_polys.cc.

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

◆ p_TakeOutComp1()

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

Definition at line 3458 of file p_polys.cc.

3459{
3460 poly q = *p;
3461
3462 if (q==NULL) return NULL;
3463
3464 poly qq=NULL,result = NULL;
3465 long unsigned kk=k;
3466 if (__p_GetComp(q,r)==kk)
3467 {
3468 result = q; /* *p */
3469 while ((q!=NULL) && (__p_GetComp(q,r)==kk))
3470 {
3471 p_SetComp(q,0,r);
3472 p_SetmComp(q,r);
3473 qq = q;
3474 pIter(q);
3475 }
3476 *p = q;
3477 pNext(qq) = NULL;
3478 }
3479 if (q==NULL) return result;
3480// if (pGetComp(q) > k) pGetComp(q)--;
3481 while (pNext(q)!=NULL)
3482 {
3483 if (__p_GetComp(pNext(q),r)==kk)
3484 {
3485 if (result==NULL)
3486 {
3487 result = pNext(q);
3488 qq = result;
3489 }
3490 else
3491 {
3492 pNext(qq) = pNext(q);
3493 pIter(qq);
3494 }
3495 pNext(q) = pNext(pNext(q));
3496 pNext(qq) =NULL;
3497 p_SetComp(qq,0,r);
3498 p_SetmComp(qq,r);
3499 }
3500 else
3501 {
3502 pIter(q);
3503// if (pGetComp(q) > k) pGetComp(q)--;
3504 }
3505 }
3506 return result;
3507}

◆ p_Totaldegree()

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

Definition at line 1479 of file p_polys.h.

1480{
1482 unsigned long s = p_GetTotalDegree(p->exp[r->VarL_Offset[0]],
1483 r,
1484 r->ExpPerLong);
1485 for (unsigned i=r->VarL_Size-1; i!=0; i--)
1486 {
1487 s += p_GetTotalDegree(p->exp[r->VarL_Offset[i]], r,r->ExpPerLong);
1488 }
1489 return (long)s;
1490}
static unsigned long p_GetTotalDegree(const unsigned long l, const ring r, const int number_of_exps)
Definition: p_polys.h:782

◆ p_Var()

int p_Var ( poly  mi,
const ring  r 
)

Definition at line 4689 of file p_polys.cc.

4690{
4691 if (m==NULL) return 0;
4692 if (pNext(m)!=NULL) return 0;
4693 int i,e=0;
4694 for (i=rVar(r); i>0; i--)
4695 {
4696 int exp=p_GetExp(m,i,r);
4697 if (exp==1)
4698 {
4699 if (e==0) e=i;
4700 else return 0;
4701 }
4702 else if (exp!=0)
4703 {
4704 return 0;
4705 }
4706 }
4707 return e;
4708}

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

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

◆ p_Vec2Poly()

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

Definition at line 3647 of file p_polys.cc.

3648{
3649 poly h;
3650 poly res=NULL;
3651 long unsigned kk=k;
3652
3653 while (v!=NULL)
3654 {
3655 if (__p_GetComp(v,r)==kk)
3656 {
3657 h=p_Head(v,r);
3658 p_SetComp(h,0,r);
3659 pNext(h)=res;res=h;
3660 }
3661 pIter(v);
3662 }
3663 if (res!=NULL) res=pReverse(res);
3664 return res;
3665}

◆ p_Vec2Polys()

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

Definition at line 3699 of file p_polys.cc.

3700{
3701 *len=p_MaxComp(v,r);
3702 if (*len==0) *len=1;
3703 *p=(poly*)omAlloc((*len)*sizeof(poly));
3704 p_Vec2Array(v,*p,*len,r);
3705}
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:3669

◆ p_VectorHasUnit()

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

Definition at line 3425 of file p_polys.cc.

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

◆ p_VectorHasUnitB()

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

Definition at line 3402 of file p_polys.cc.

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

◆ p_WDegree()

long p_WDegree ( poly  p,
const ring  r 
)

Definition at line 710 of file p_polys.cc.

711{
712 if (r->firstwv==NULL) return p_Totaldegree(p, r);
714 int i;
715 long j =0;
716
717 for(i=1;i<=r->firstBlockEnds;i++)
718 j+=p_GetExp(p, i, r)*r->firstwv[i-1];
719
720 for (;i<=rVar(r);i++)
721 j+=p_GetExp(p,i, r)*p_Weight(i, r);
722
723 return j;
724}
int p_Weight(int i, const ring r)
Definition: p_polys.cc:701

◆ p_Weight()

int p_Weight ( int  c,
const ring  r 
)

Definition at line 701 of file p_polys.cc.

702{
703 if ((r->firstwv==NULL) || (i>r->firstBlockEnds))
704 {
705 return 1;
706 }
707 return r->firstwv[i-1];
708}

◆ p_WFirstTotalDegree()

long p_WFirstTotalDegree ( poly  p,
ring  r 
)

Definition at line 592 of file p_polys.cc.

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

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

1221{
1222 p_Write(p, p_ring, p_ring);
1223}

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

1225{
1226 p_Write0(p, p_ring, p_ring);
1227}
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 1228 of file p_polys.h.

1229{
1230 p_wrp(p, p_ring, p_ring);
1231}
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 609 of file p_polys.cc.

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

◆ pEnlargeSet()

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

Definition at line 3770 of file p_polys.cc.

3771{
3772 poly* h;
3773
3774 if (*p==NULL)
3775 {
3776 if (increment==0) return;
3777 h=(poly*)omAlloc0(increment*sizeof(poly));
3778 }
3779 else
3780 {
3781 h=(poly*)omReallocSize((poly*)*p,l*sizeof(poly),(l+increment)*sizeof(poly));
3782 if (increment>0)
3783 {
3784 memset(&(h[l]),0,increment*sizeof(poly));
3785 }
3786 }
3787 *p=h;
3788}
#define omReallocSize(addr, o_size, size)
Definition: omAllocDecl.h:220

◆ pHaveCommonMonoms()

BOOLEAN pHaveCommonMonoms ( poly  p,
poly  q 
)

Definition at line 175 of file pDebug.cc.

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

◆ pIsMonomOf()

BOOLEAN pIsMonomOf ( poly  p,
poly  m 
)

Definition at line 165 of file pDebug.cc.

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

◆ pLDeg0()

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

Definition at line 735 of file p_polys.cc.

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

◆ pLDeg0c()

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

Definition at line 766 of file p_polys.cc.

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

◆ pLDeg1()

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

Definition at line 837 of file p_polys.cc.

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

◆ pLDeg1_Deg()

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

Definition at line 906 of file p_polys.cc.

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

◆ pLDeg1_Totaldegree()

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

Definition at line 971 of file p_polys.cc.

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

◆ pLDeg1_WFirstTotalDegree()

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

Definition at line 1034 of file p_polys.cc.

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

◆ pLDeg1c()

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

Definition at line 873 of file p_polys.cc.

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

◆ pLDeg1c_Deg()

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

Definition at line 937 of file p_polys.cc.

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

◆ pLDeg1c_Totaldegree()

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

Definition at line 1001 of file p_polys.cc.

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

◆ pLDeg1c_WFirstTotalDegree()

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

Definition at line 1064 of file p_polys.cc.

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

◆ pLDegb()

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

Definition at line 807 of file p_polys.cc.

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

◆ pLength()

static unsigned pLength ( poly  a)
inlinestatic

Definition at line 191 of file p_polys.h.

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

◆ pp_DivideM()

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

Definition at line 1625 of file p_polys.cc.

1626{
1627 if (a==NULL) { return NULL; }
1628 // TODO: better implementation without copying a,b
1629 return p_DivideM(p_Copy(a,r),p_Head(b,r),r);
1630}
poly p_DivideM(poly a, poly b, const ring r)
Definition: p_polys.cc:1570

◆ pp_Jet()

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

Definition at line 4391 of file p_polys.cc.

4392{
4393 poly r=NULL;
4394 poly t=NULL;
4395
4396 while (p!=NULL)
4397 {
4398 if (p_Totaldegree(p,R)<=m)
4399 {
4400 if (r==NULL)
4401 r=p_Head(p,R);
4402 else
4403 if (t==NULL)
4404 {
4405 pNext(r)=p_Head(p,R);
4406 t=pNext(r);
4407 }
4408 else
4409 {
4410 pNext(t)=p_Head(p,R);
4411 pIter(t);
4412 }
4413 }
4414 pIter(p);
4415 }
4416 return r;
4417}

◆ pp_JetW()

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

Definition at line 4436 of file p_polys.cc.

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

◆ pp_mm_Mult()

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

Definition at line 1013 of file p_polys.h.

1014{
1015 if (p==NULL) return NULL;
1016 if (p_LmIsConstant(m, r))
1017 return __pp_Mult_nn(p, pGetCoeff(m), r);
1018 else
1019 return r->p_Procs->pp_mm_Mult(p, m, r);
1020}
#define __pp_Mult_nn(p, n, r)
Definition: p_polys.h:974

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

1063{
1064 int shorter;
1065 return r->p_Procs->pp_Mult_Coeff_mm_DivSelect(p, m, shorter, r);
1066}

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

1071{
1072 int shorter;
1073 poly pp = r->p_Procs->pp_Mult_Coeff_mm_DivSelect(p, m, shorter, r);
1074 lp -= shorter;
1075 return pp;
1076}

◆ pp_Mult_mm()

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

Definition at line 1003 of file p_polys.h.

1004{
1005 if (p==NULL) return NULL;
1006 if (p_LmIsConstant(m, r))
1007 return __pp_Mult_nn(p, pGetCoeff(m), r);
1008 else
1009 return r->p_Procs->pp_Mult_mm(p, m, r);
1010}

◆ pp_Mult_nn()

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

Definition at line 964 of file p_polys.h.

965{
966 if (p==NULL) return NULL;
967 if (n_IsOne(n, r->cf))
968 return p_Copy(p, r);
969 else if (n_IsZero(n, r->cf))
970 return NULL;
971 else
972 return r->p_Procs->pp_Mult_nn(p, n, r);
973}

◆ pp_Mult_qq()

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

Definition at line 1123 of file p_polys.h.

1124{
1125 if (p == NULL || q == NULL) return NULL;
1126
1127 if (pNext(p) == NULL)
1128 {
1129 return r->p_Procs->pp_mm_Mult(q, p, r);
1130 }
1131
1132 if (pNext(q) == NULL)
1133 {
1134 return r->p_Procs->pp_Mult_mm(p, q, r);
1135 }
1136
1137 poly qq = q;
1138 if (p == q)
1139 qq = p_Copy(q, r);
1140
1141 poly res;
1142#if defined(HAVE_PLURAL) || defined(HAVE_SHIFTBBA)
1143 if (rIsNCRing(r))
1144 res = _nc_pp_Mult_qq(p, qq, r);
1145 else
1146#endif
1147 res = _p_Mult_q(p, qq, 1, r);
1148
1149 if (qq != q)
1150 p_Delete(&qq, r);
1151 return res;
1152}
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 3723 of file p_polys.cc.

3724{
3725 assume(old_FDeg != NULL && old_lDeg != NULL);
3726 r->pFDeg = old_FDeg;
3727 r->pLDeg = old_lDeg;
3728}

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

3712{
3713 assume(new_FDeg != NULL);
3714 r->pFDeg = new_FDeg;
3715
3716 if (new_lDeg == NULL)
3717 new_lDeg = r->pLDegOrig;
3718
3719 r->pLDeg = new_lDeg;
3720}