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))
390  || ((lq >= MIN_LENGTH_FACTORY_QQ)
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::@0 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 {
449  p_LmCheckPolyRing2(p, r);
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 {
608  p_LmCheckPolyRing2(p, r);
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:79

◆ 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  {
2918  CPolyCoeffsEnumerator itr(p);
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  {
2961  CPolyCoeffsEnumerator itr(p);
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  {
2977  n_Normalize(pGetCoeff(p),C);
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  {
3055  if(!TEST_OPT_CONTENTSB)
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  {
3113  n_Normalize(pGetCoeff(p),C);
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);
644  p_LmCheckPolyRing2(b, 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  }
2339 content_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  }
2404 content_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
1838 cleanup:
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 {
5014  p_LmCheckPolyRing1(p, r);
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 {
600  p_LmCheckPolyRing2(p, r);
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 {
1895  pIfThen1(b!=NULL, p_LmCheckPolyRing1(b, r_b));
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);
1394  p_MemAdd_NegWeightAdjust(p1, r);
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);
1458  p_MemSub_NegWeightAdjust(pr, r);
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);
1424  p_MemSub_NegWeightAdjust(p1, r);
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);
1409  p_MemAdd_NegWeightAdjust(pr, r);
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 {
574  p_LmCheckPolyRing2(p, r);
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 {
557  p_LmCheckPolyRing2(p, r);
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;
1347  p_LmCheckPolyRing1(p, r);
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 {
1494  p_LmCheckPolyRing1(p, r);
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 {
1503  p_LmCheckPolyRing1(p, r);
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 {
1510  p_LmCheckPolyRing1(p, r);
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 {
423  p_LmCheckPolyRing2(p, r);
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;
835  p_LmCheckPolyRing1(p, r);
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 {
593  p_LmCheckPolyRing2(p, r);
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  {
4470  if (totaldegreeWecart_IV(pNext(p),R,w)>m)
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 &&
82  omIsBinPageAddr(p) &&
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 {
1554  p_LmCheckPolyRing1(p, r);
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 {
725  p_LmCheckPolyRing2(*p, r);
726  poly h = *p;
727  *p = pNext(h);
728  n_Delete(&pGetCoeff(h), r->cf);
729  omFreeBinAddr(h);
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 {
713  p_LmCheckPolyRing2(p, r);
714  n_Delete(&pGetCoeff(p), r->cf);
715  omFreeBinAddr(p);
716 }

◆ p_LmDelete0()

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

Definition at line 717 of file p_polys.h.

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

◆ p_LmDeleteAndNext()

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

Definition at line 731 of file p_polys.h.

732 {
733  p_LmCheckPolyRing2(p, r);
734  poly pnext = pNext(p);
735  n_Delete(&pGetCoeff(p), r->cf);
736  omFreeBinAddr(p);
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 {
1877  p_LmCheckPolyRing1(b, r);
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);
1864  p_LmCheckPolyRing1(b, 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 {
1842  p_LmCheckPolyRing1(b, r);
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 {
695  p_LmCheckPolyRing2(*p, r);
696  poly h = *p;
697  *p = pNext(h);
698  omFreeBinAddr(h);
699 }

◆ p_LmFree() [2/2]

static void p_LmFree ( poly  p,
ring   
)
inlinestatic

Definition at line 683 of file p_polys.h.

685 {
686  p_LmCheckPolyRing2(p, r);
687  omFreeBinAddr(p);
688 }

◆ p_LmFreeAndNext()

static poly p_LmFreeAndNext ( poly  p,
ring   
)
inlinestatic

Definition at line 703 of file p_polys.h.

705 {
706  p_LmCheckPolyRing2(p, r);
707  poly pnext = pNext(p);
708  omFreeBinAddr(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 {
1309  p_LmCheckPolyRing1(p, r);
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 {
1367  p_LmCheckPolyRing1(p, r);
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);
1373  omFreeBinAddr(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);
1913  p_LmCheckPolyRing1(b, 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);
1933  p_LmCheckPolyRing1(b, 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 {
623  p_LmCheckPolyRing2(p, r);
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  }
1410 done:
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  }
1435 finish:
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 {
414  p_LmCheckPolyRing2(p, r);
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 {
249  p_LmCheckPolyRing2(p, r);
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 {
584  p_LmCheckPolyRing2(p, r);
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 {
564  p_LmCheckPolyRing2(p, r);
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 {
1518  p_LmCheckPolyRing1(p, r);
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 {
1527  p_LmCheckPolyRing1(p, r);
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 {
1538  p_LmCheckPolyRing1(p, r);
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;
3755  pSetDegProcs(r,pModDeg);
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 {
902  p_LmCheckPolyRing2(p, r);
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 {
455  p_LmCheckPolyRing2(p, r);
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 {
615  p_LmCheckPolyRing2(p, r);
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:911

◆ 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 {
1481  p_LmCheckPolyRing1(p, r);
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);
713  p_LmCheckPolyRing(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 {
611  p_LmCheckPolyRing(p, r);
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 }