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)
 
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 int pLength (poly a)
 
poly p_Last (const poly a, int &l, const ring r)
 
void p_Norm (poly p1, const ring r)
 
void p_Normalize (poly p, const ring r)
 
void p_ProjectiveUnique (poly p, const ring r)
 
void p_ContentForGB (poly p, const ring r)
 
void p_Content (poly p, const ring r)
 
void p_SimpleContent (poly p, int s, const ring r)
 
number p_InitContent (poly ph, const ring r)
 
poly p_Cleardenom (poly p, const ring r)
 
void p_Cleardenom_n (poly p, const ring r, number &c)
 
int p_Size (poly p, const ring r)
 
poly p_Homogen (poly p, int varnum, const ring r)
 
BOOLEAN p_IsHomogeneous (poly p, const ring r)
 
BOOLEAN p_IsHomogeneousW (poly p, const intvec *w, const ring r)
 
BOOLEAN p_IsHomogeneousW (poly p, const intvec *w, const intvec *module_w, const ring r)
 
static void p_Setm (poly p, const ring r)
 
p_SetmProc p_GetSetmProc (const ring r)
 
poly p_Subst (poly p, int n, poly e, const ring r)
 
static unsigned long p_SetComp (poly p, unsigned long c, ring r)
 
static void p_SetCompP (poly p, int i, ring r)
 
static void p_SetCompP (poly p, int i, ring lmRing, ring tailRing)
 
static long p_MaxComp (poly p, ring lmRing, ring tailRing)
 
static long p_MaxComp (poly p, ring lmRing)
 
static long p_MinComp (poly p, ring lmRing, ring tailRing)
 
static long p_MinComp (poly p, ring lmRing)
 
static poly pReverse (poly p)
 
void pEnlargeSet (poly **p, int length, int increment)
 
void p_String0 (poly p, ring lmRing, ring tailRing)
 print p according to ShortOut in lmRing & tailRing 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_LmDivisibleByNoComp (poly a, poly b, const ring r)
 
static BOOLEAN p_LmDivisibleByNoComp (poly a, const ring ra, poly b, const ring rb)
 
static BOOLEAN p_LmDivisibleBy (poly a, poly b, const ring r)
 
static BOOLEAN p_DivisibleBy (poly a, poly b, const ring r)
 
static BOOLEAN p_LmShortDivisibleBy (poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
 
static BOOLEAN p_LmShortDivisibleByNoComp (poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
 
static BOOLEAN p_IsConstantComp (const poly p, const ring r)
 like the respective p_LmIs* routines, except that p might be empty 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)
 
void p_TakeOutComp (poly *p, long comp, poly *q, int *lq, const ring r)
 Splits *p into two polys: *q which consists of all monoms with component == comp and *p of all other monoms *lq == pLength(*q) On return all components pf *q == 0. More...
 
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 969 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 1000 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 1274 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 1717 of file p_polys.h.

◆ p_LmEqual

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

Definition at line 1721 of file p_polys.h.

◆ p_LmTest

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

Definition at line 160 of file p_polys.h.

◆ p_SetmComp

#define p_SetmComp   p_Setm

Definition at line 242 of file p_polys.h.

◆ p_Test

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

Definition at line 159 of file p_polys.h.

◆ pDivAssume

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

Definition at line 1280 of file p_polys.h.

◆ pIfThen

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

Definition at line 153 of file p_polys.h.

◆ pp_Test

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

Definition at line 161 of file p_polys.h.

Function Documentation

◆ _p_LmDivisibleBy()

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

Definition at line 1869 of file p_polys.h.

1870 {
1871  if (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r))
1872  return _p_LmDivisibleByNoComp(a, b, r);
1873  return FALSE;
1874 }
#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:1763

◆ _p_LmDivisibleByNoComp() [1/2]

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

Definition at line 1812 of file p_polys.h.

1813 {
1814  int i=r_a->N;
1815  pAssume1(r_a->N == r_b->N);
1816 
1817  do
1818  {
1819  if (p_GetExp(a,i,r_a) > p_GetExp(b,i,r_b))
1820  {
1821  return FALSE;
1822  }
1823  i--;
1824  }
1825  while (i);
1826 /*#ifdef HAVE_RINGS
1827  return n_DivBy(p_GetCoeff(b, r_b), p_GetCoeff(a, r_a), r_a->cf);
1828 #else
1829 */
1830  return TRUE;
1831 //#endif
1832 }
#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:467

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

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

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

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

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

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

◆ _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  && ((r->cf->extRing==NULL)||(r->cf->extRing->qideal!=NULL))
389  /* exclude trans. extensions: may contain rat.funct as cf */
390  && (((lq >= MIN_LENGTH_FACTORY)
391  && (r->cf->convSingNFactoryN!=ndConvSingNFactoryN))
392  || ((lq >= MIN_LENGTH_FACTORY_QQ)
393  && rField_is_Q(r))))
394  {
395  poly h=singclap_pmult(p,q,r);
396  if (!copy)
397  {
398  p_Delete(&p,r);
399  p_Delete(&q,r);
400  }
401  return h;
402  }
403  else
404  {
405  lp=pLength(p);
406  lq=pLength(q);
407  return _p_Mult_q_Bucket(p, lp, q, lq, copy, r);
408  }
409 }
int l
Definition: cfEzgcd.cc:100
poly singclap_pmult(poly f, poly g, const ring r)
Definition: clapsing.cc:577
static FORCE_INLINE BOOLEAN nCoeff_is_Domain(const coeffs r)
returns TRUE, if r is a field or r has no zero divisors (i.e is a domain)
Definition: coeffs.h:736
CanonicalForm res
Definition: facAbsFact.cc:60
CFArray copy(const CFList &list)
write elements of list into an array
STATIC_VAR Poly * h
Definition: janet.cc:971
#define assume(x)
Definition: mod2.h:389
Definition: lq.h:40
CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition: numbers.cc:313
#define TEST_OPT_NOT_BUCKETS
Definition: options.h:106
static void pqLengthApprox(poly p, poly q, int &lp, int &lq, const int min)
Definition: p_Mult_q.cc:69
#define MIN_LENGTH_FACTORY
Definition: p_Mult_q.cc:304
#define MIN_FLINT_Z
Definition: p_Mult_q.cc:308
#define MIN_FLINT_QQ
Definition: p_Mult_q.cc:306
static poly _p_Mult_q_Normal(poly p, poly q, const int copy, const ring r)
Definition: p_Mult_q.cc:223
#define MIN_LENGTH_FACTORY_QQ
Definition: p_Mult_q.cc:305
static poly _p_Mult_q_Bucket(poly p, const int lp, poly q, const int lq, const int copy, const ring r)
Definition: p_Mult_q.cc:100
static poly _p_Mult_q_Normal_ZeroDiv(poly p, poly q, const int copy, const ring r)
Definition: p_Mult_q.cc:195
#define MIN_FLINT_Zp
Definition: p_Mult_q.cc:307
#define MIN_LENGTH_BUCKET
Definition: p_Mult_q.h:21
static int pLength(poly a)
Definition: p_polys.h:188
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:899
static BOOLEAN rField_is_Z(const ring r)
Definition: ring.h:509
static BOOLEAN rField_is_Zp(const ring r)
Definition: ring.h:500
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:506

◆ _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:709
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
Definition: coeffs.h:461
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:441
#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:4522
static int p_LmCmp(poly p, poly q, const ring r)
Definition: p_polys.h:1578
static void p_LmFree(poly p, ring)
Definition: p_polys.h:681
@ ro_syzcomp
Definition: ring.h:59
union sro_ord::@1 data
Definition: ring.h:219
#define omTestBinAddrSize(A, B, C)
Definition: xalloc.h:272

◆ _pp_Test()

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

Definition at line 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 4023 of file p_polys.cc.

4024 {
4025 #if 0
4026  PrintS("\nSource Ring: \n");
4027  rWrite(src);
4028 
4029  if(0)
4030  {
4031  number zz = n_Copy(z, src->cf);
4032  PrintS("z: "); n_Write(zz, src);
4033  n_Delete(&zz, src->cf);
4034  }
4035 
4036  PrintS("\nDestination Ring: \n");
4037  rWrite(dst);
4038 
4039  /*Print("\nOldPar: %d\n", OldPar);
4040  for( int i = 1; i <= OldPar; i++ )
4041  {
4042  Print("par(%d) -> par/var (%d)\n", i, par_perm[i-1]);
4043  }*/
4044 #endif
4045  if( z == NULL )
4046  return NULL;
4047 
4048  const coeffs srcCf = src->cf;
4049  assume( srcCf != NULL );
4050 
4051  assume( !nCoeff_is_GF(srcCf) );
4052  assume( src->cf->extRing!=NULL );
4053 
4054  poly zz = NULL;
4055 
4056  const ring srcExtRing = srcCf->extRing;
4057  assume( srcExtRing != NULL );
4058 
4059  const coeffs dstCf = dst->cf;
4060  assume( dstCf != NULL );
4061 
4062  if( nCoeff_is_algExt(srcCf) ) // nCoeff_is_GF(srcCf)?
4063  {
4064  zz = (poly) z;
4065  if( zz == NULL ) return NULL;
4066  }
4067  else if (nCoeff_is_transExt(srcCf))
4068  {
4069  assume( !IS0(z) );
4070 
4071  zz = NUM((fraction)z);
4072  p_Test (zz, srcExtRing);
4073 
4074  if( zz == NULL ) return NULL;
4075  if( !DENIS1((fraction)z) )
4076  {
4077  if (!p_IsConstant(DEN((fraction)z),srcExtRing))
4078  WarnS("Not defined: Cannot map a rational fraction and make a polynomial out of it! Ignoring the denominator.");
4079  }
4080  }
4081  else
4082  {
4083  assume (FALSE);
4084  WerrorS("Number permutation is not implemented for this data yet!");
4085  return NULL;
4086  }
4087 
4088  assume( zz != NULL );
4089  p_Test (zz, srcExtRing);
4090 
4091  nMapFunc nMap = n_SetMap(srcExtRing->cf, dstCf);
4092 
4093  assume( nMap != NULL );
4094 
4095  poly qq;
4096  if ((par_perm == NULL) && (rPar(dst) != 0 && rVar (srcExtRing) > 0))
4097  {
4098  int* perm;
4099  perm=(int *)omAlloc0((rVar(srcExtRing)+1)*sizeof(int));
4100  for(int i=si_min(rVar(srcExtRing),rPar(dst));i>0;i--)
4101  perm[i]=-i;
4102  qq = p_PermPoly(zz, perm, srcExtRing, dst, nMap, NULL, rVar(srcExtRing)-1);
4103  omFreeSize ((ADDRESS)perm, (rVar(srcExtRing)+1)*sizeof(int));
4104  }
4105  else
4106  qq = p_PermPoly(zz, par_perm-1, srcExtRing, dst, nMap, NULL, rVar (srcExtRing)-1);
4107 
4108  if(nCoeff_is_transExt(srcCf)
4109  && (!DENIS1((fraction)z))
4110  && p_IsConstant(DEN((fraction)z),srcExtRing))
4111  {
4112  number n=nMap(pGetCoeff(DEN((fraction)z)),srcExtRing->cf, dstCf);
4113  qq=p_Div_nn(qq,n,dst);
4114  n_Delete(&n,dstCf);
4115  p_Normalize(qq,dst);
4116  }
4117  p_Test (qq, dst);
4118 
4119  return qq;
4120 }
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:448
static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
Definition: coeffs.h:836
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:697
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:452
static FORCE_INLINE void n_Write(number n, const coeffs r, const BOOLEAN bShortOut=TRUE)
Definition: coeffs.h:588
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
Definition: coeffs.h:907
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:915
#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:4126
poly p_Div_nn(poly p, const number n, const ring r)
Definition: p_polys.cc:1501
void p_Normalize(poly p, const ring r)
Definition: p_polys.cc:3809
static BOOLEAN p_IsConstant(const poly p, const ring r)
Definition: p_polys.h:1962
#define p_Test(p, r)
Definition: p_polys.h:159
@ 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:599
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:592

◆ p_Add_q() [1/2]

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

Definition at line 934 of file p_polys.h.

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

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

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

◆ p_AddComp()

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

Definition at line 445 of file p_polys.h.

446 {
447  p_LmCheckPolyRing2(p, r);
449  return __p_GetComp(p,r) += v;
450 }
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 604 of file p_polys.h.

605 {
606  p_LmCheckPolyRing2(p, r);
607  int e = p_GetExp(p,v,r);
608  e += ee;
609  return p_SetExp(p,v,e,r);
610 }
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:486

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

◆ p_Cleardenom()

poly p_Cleardenom ( poly  p,
const ring  r 
)

Definition at line 2841 of file p_polys.cc.

2842 {
2843  if( p == NULL )
2844  return NULL;
2845 
2846  assume( r != NULL );
2847  assume( r->cf != NULL );
2848  const coeffs C = r->cf;
2849 
2850 #if CLEARENUMERATORS
2851  if( 0 )
2852  {
2853  CPolyCoeffsEnumerator itr(p);
2854  n_ClearDenominators(itr, C);
2855  n_ClearContent(itr, C); // divide out the content
2856  p_Test(p, r); n_Test(pGetCoeff(p), C);
2857  assume(n_GreaterZero(pGetCoeff(p), C)); // ??
2858 // if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
2859  return p;
2860  }
2861 #endif
2862 
2863  number d, h;
2864 
2865  if (rField_is_Ring(r))
2866  {
2867  if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
2868  return p;
2869  }
2870 
2872  {
2873  if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
2874  return p;
2875  }
2876 
2877  assume(p != NULL);
2878 
2879  if(pNext(p)==NULL)
2880  {
2881  if (!TEST_OPT_CONTENTSB)
2882  p_SetCoeff(p,n_Init(1,C),r);
2883  else if(!n_GreaterZero(pGetCoeff(p),C))
2884  p = p_Neg(p,r);
2885  return p;
2886  }
2887 
2888  assume(pNext(p)!=NULL);
2889  poly start=p;
2890 
2891 #if 0 && CLEARENUMERATORS
2892 //CF: does not seem to work that well..
2893 
2894  if( nCoeff_is_Q(C) || nCoeff_is_Q_a(C) )
2895  {
2896  CPolyCoeffsEnumerator itr(p);
2897  n_ClearDenominators(itr, C);
2898  n_ClearContent(itr, C); // divide out the content
2899  p_Test(p, r); n_Test(pGetCoeff(p), C);
2900  assume(n_GreaterZero(pGetCoeff(p), C)); // ??
2901 // if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
2902  return start;
2903  }
2904 #endif
2905 
2906  if(1)
2907  {
2908  // get lcm of all denominators ----------------------------------
2909  h = n_Init(1,C);
2910  while (p!=NULL)
2911  {
2912  n_Normalize(pGetCoeff(p),C);
2914  n_Delete(&h,C);
2915  h=d;
2916  pIter(p);
2917  }
2918  /* h now contains the 1/lcm of all denominators */
2919  if(!n_IsOne(h,C))
2920  {
2921  // multiply by the lcm of all denominators
2922  p = start;
2923  while (p!=NULL)
2924  {
2925  d=n_Mult(h,pGetCoeff(p),C);
2926  n_Normalize(d,C);
2927  p_SetCoeff(p,d,r);
2928  pIter(p);
2929  }
2930  }
2931  n_Delete(&h,C);
2932  p=start;
2933 
2934  p_ContentForGB(p,r);
2935 #ifdef HAVE_RATGRING
2936  if (rIsRatGRing(r))
2937  {
2938  /* quick unit detection in the rational case is done in gr_nc_bba */
2939  p_ContentRat(p, r);
2940  start=p;
2941  }
2942 #endif
2943  }
2944 
2945  if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
2946 
2947  return start;
2948 }
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:633
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:692
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:491
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
Definition: coeffs.h:803
static FORCE_INLINE void n_ClearDenominators(ICoeffsEnumerator &numberCollectionEnumerator, number &d, const coeffs r)
(inplace) Clears denominators on a collection of numbers number d is the LCM of all the coefficient d...
Definition: coeffs.h:932
static FORCE_INLINE BOOLEAN nCoeff_is_Q_a(const coeffs r)
Definition: coeffs.h:882
static FORCE_INLINE void n_ClearContent(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs r)
Computes the content and (inplace) divides it out on a collection of numbers number c is the content ...
Definition: coeffs.h:925
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition: coeffs.h:575
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition: coeffs.h:465
#define TEST_OPT_INTSTRATEGY
Definition: options.h:111
#define TEST_OPT_CONTENTSB
Definition: options.h:128
void p_ContentRat(poly &ph, const ring r)
Definition: p_polys.cc:1740
void p_ContentForGB(poly ph, const ring r)
Definition: p_polys.cc:2351
static poly p_Neg(poly p, const ring r)
Definition: p_polys.h:1105
static BOOLEAN rIsRatGRing(const ring r)
Definition: ring.h:427
#define rField_is_Ring(R)
Definition: ring.h:485

◆ p_Cleardenom_n()

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

Definition at line 2950 of file p_polys.cc.

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

◆ p_Cmp()

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

Definition at line 1725 of file p_polys.h.

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

◆ p_CmpPolys()

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

Definition at line 1737 of file p_polys.h.

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

◆ p_Comp_k_n()

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

Definition at line 638 of file p_polys.h.

639 {
640  if ((a==NULL) || (b==NULL) ) return FALSE;
641  p_LmCheckPolyRing2(a, r);
642  p_LmCheckPolyRing2(b, r);
643  pAssume2(k > 0 && k <= r->N);
644  int i=k;
645  for(;i<=r->N;i++)
646  {
647  if (p_GetExp(a,i,r) != p_GetExp(b,i,r)) return FALSE;
648  // if (a->exp[(r->VarOffset[i] & 0xffffff)] != b->exp[(r->VarOffset[i] & 0xffffff)]) return FALSE;
649  }
650  return TRUE;
651 }
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 4845 of file p_polys.cc.

4846 {
4847  int r=p_Cmp(a,b,R);
4848  if ((r==0)&&(a!=NULL))
4849  {
4850  number h=n_Sub(pGetCoeff(a),pGetCoeff(b),R->cf);
4851  /* compare lead coeffs */
4852  r = -1+n_IsZero(h,R->cf)+2*n_GreaterZero(h,R->cf); /* -1: <, 0:==, 1: > */
4853  n_Delete(&h,R->cf);
4854  }
4855  else if (a==NULL)
4856  {
4857  if (b==NULL)
4858  {
4859  /* compare 0, 0 */
4860  r=0;
4861  }
4862  else if(p_IsConstant(b,R))
4863  {
4864  /* compare 0, const */
4865  r = 1-2*n_GreaterZero(pGetCoeff(b),R->cf); /* -1: <, 1: > */
4866  }
4867  }
4868  else if (b==NULL)
4869  {
4870  if (p_IsConstant(a,R))
4871  {
4872  /* compare const, 0 */
4873  r = -1+2*n_GreaterZero(pGetCoeff(a),R->cf); /* -1: <, 1: > */
4874  }
4875  }
4876  return(r);
4877 }
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:652
static int p_Cmp(poly p1, poly p2, ring r)
Definition: p_polys.h:1725

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

4573 {
4574  number n,nn;
4575  pAssume(p1 != NULL && p2 != NULL);
4576 
4577  if (!p_LmEqual(p1,p2,r)) //compare leading mons
4578  return FALSE;
4579  if ((pNext(p1)==NULL) && (pNext(p2)!=NULL))
4580  return FALSE;
4581  if ((pNext(p2)==NULL) && (pNext(p1)!=NULL))
4582  return FALSE;
4583  if (pLength(p1) != pLength(p2))
4584  return FALSE;
4585  #ifdef HAVE_RINGS
4586  if (rField_is_Ring(r))
4587  {
4588  if (!n_DivBy(pGetCoeff(p1), pGetCoeff(p2), r->cf)) return FALSE;
4589  }
4590  #endif
4591  n=n_Div(pGetCoeff(p1),pGetCoeff(p2),r->cf);
4592  while ((p1 != NULL) /*&& (p2 != NULL)*/)
4593  {
4594  if ( ! p_LmEqual(p1, p2,r))
4595  {
4596  n_Delete(&n, r->cf);
4597  return FALSE;
4598  }
4599  if (!n_Equal(pGetCoeff(p1), nn = n_Mult(pGetCoeff(p2),n, r->cf), r->cf))
4600  {
4601  n_Delete(&n, r->cf);
4602  n_Delete(&nn, r->cf);
4603  return FALSE;
4604  }
4605  n_Delete(&nn, r->cf);
4606  pIter(p1);
4607  pIter(p2);
4608  }
4609  n_Delete(&n, r->cf);
4610  return TRUE;
4611 }
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:750
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:457
#define pAssume(cond)
Definition: monomials.h:90
#define p_LmEqual(p1, p2, r)
Definition: p_polys.h:1721

◆ p_Content()

void p_Content ( poly  p,
const ring  r 
)

Definition at line 2291 of file p_polys.cc.

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

◆ p_ContentForGB()

void p_ContentForGB ( poly  p,
const ring  r 
)

Definition at line 2351 of file p_polys.cc.

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

◆ p_ContentRat()

void p_ContentRat ( poly &  ph,
const ring  r 
)

Definition at line 1740 of file p_polys.cc.

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

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

◆ p_Copy() [2/2]

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

returns a copy of p

Definition at line 844 of file p_polys.h.

845 {
846  if (p!=NULL)
847  {
848  p_Test(p,r);
849  const poly pp = p_Copy_noCheck(p, r);
850  p_Test(pp,r);
851  return pp;
852  }
853  else
854  return NULL;
855 }
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 834 of file p_polys.h.

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

◆ p_CopyPowerProduct()

poly p_CopyPowerProduct ( const poly  p,
const ring  r 
)

like p_Head, but with coefficient 1

Definition at line 4929 of file p_polys.cc.

4930 {
4931  if (p == NULL) return NULL;
4932  return p_CopyPowerProduct0(p,n_Init(1,r->cf),r);
4933 }
poly p_CopyPowerProduct0(const poly p, number n, const ring r)
like p_Head, but with coefficient n
Definition: p_polys.cc:4917

◆ p_CopyPowerProduct0()

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

like p_Head, but with coefficient n

Definition at line 4917 of file p_polys.cc.

4918 {
4919  p_LmCheckPolyRing1(p, r);
4920  poly np;
4921  omTypeAllocBin(poly, np, r->PolyBin);
4922  p_SetRingOfLm(np, r);
4923  memcpy(np->exp, p->exp, r->ExpL_Size*sizeof(long));
4924  pNext(np) = NULL;
4925  pSetCoeff0(np, n);
4926  return np;
4927 }
#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 596 of file p_polys.h.

597 {
598  p_LmCheckPolyRing2(p, r);
599  int e = p_GetExp(p,v,r);
600  pAssume2(e > 0);
601  e--;
602  return p_SetExp(p,v,e,r);
603 }

◆ p_Deg()

long p_Deg ( poly  a,
const ring  r 
)

Definition at line 587 of file p_polys.cc.

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

◆ p_DegW()

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

Definition at line 690 of file p_polys.cc.

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

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

◆ p_Delete() [2/2]

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

Definition at line 899 of file p_polys.h.

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

◆ p_DeleteComp()

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

Definition at line 3540 of file p_polys.cc.

3541 {
3542  poly q;
3543  long unsigned kk=k;
3544 
3545  while ((*p!=NULL) && (__p_GetComp(*p,r)==kk)) p_LmDelete(p,r);
3546  if (*p==NULL) return;
3547  q = *p;
3548  if (__p_GetComp(q,r)>kk)
3549  {
3550  p_SubComp(q,1,r);
3551  p_SetmComp(q,r);
3552  }
3553  while (pNext(q)!=NULL)
3554  {
3555  if (__p_GetComp(pNext(q),r)==kk)
3556  p_LmDelete(&(pNext(q)),r);
3557  else
3558  {
3559  pIter(q);
3560  if (__p_GetComp(q,r)>kk)
3561  {
3562  p_SubComp(q,1,r);
3563  p_SetmComp(q,r);
3564  }
3565  }
3566  }
3567 }
static unsigned long p_SubComp(poly p, unsigned long v, ring r)
Definition: p_polys.h:451
#define p_SetmComp
Definition: p_polys.h:242

◆ p_Diff()

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

Definition at line 1894 of file p_polys.cc.

1895 {
1896  poly res, f, last;
1897  number t;
1898 
1899  last = res = NULL;
1900  while (a!=NULL)
1901  {
1902  if (p_GetExp(a,k,r)!=0)
1903  {
1904  f = p_LmInit(a,r);
1905  t = n_Init(p_GetExp(a,k,r),r->cf);
1906  pSetCoeff0(f,n_Mult(t,pGetCoeff(a),r->cf));
1907  n_Delete(&t,r->cf);
1908  if (n_IsZero(pGetCoeff(f),r->cf))
1909  p_LmDelete(&f,r);
1910  else
1911  {
1912  p_DecrExp(f,k,r);
1913  p_Setm(f,r);
1914  if (res==NULL)
1915  {
1916  res=last=f;
1917  }
1918  else
1919  {
1920  pNext(last)=f;
1921  last=f;
1922  }
1923  }
1924  }
1925  pIter(a);
1926  }
1927  return res;
1928 }
FILE * f
Definition: checklibs.c:9
STATIC_VAR poly last
Definition: hdegree.cc:1173
static poly p_LmInit(poly p, const ring r)
Definition: p_polys.h:1333
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:231
static long p_DecrExp(poly p, int v, ring r)
Definition: p_polys.h:596

◆ p_DiffOp()

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

Definition at line 1969 of file p_polys.cc.

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

◆ p_Div_mm()

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

divide polynomial by monomial

Definition at line 1534 of file p_polys.cc.

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

◆ p_Div_nn()

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

Definition at line 1501 of file p_polys.cc.

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

◆ p_DivideM()

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

Definition at line 1574 of file p_polys.cc.

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

◆ p_DivisibleBy()

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

Definition at line 1898 of file p_polys.h.

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

◆ p_DivisibleByRingCase()

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

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

Definition at line 1638 of file p_polys.cc.

1639 {
1640  int exponent;
1641  for(int i = (int)rVar(r); i>0; i--)
1642  {
1643  exponent = p_GetExp(g, i, r) - p_GetExp(f, i, r);
1644  if (exponent < 0) return FALSE;
1645  }
1646  return n_DivBy(pGetCoeff(g), pGetCoeff(f), r->cf);
1647 }
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 4508 of file p_polys.cc.

4509 {
4510  while ((p1 != NULL) && (p2 != NULL))
4511  {
4512  if (! p_LmEqual(p1, p2,r))
4513  return FALSE;
4514  if (! n_Equal(p_GetCoeff(p1,r), p_GetCoeff(p2,r),r->cf ))
4515  return FALSE;
4516  pIter(p1);
4517  pIter(p2);
4518  }
4519  return (p1==p2);
4520 }
#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 4546 of file p_polys.cc.

4547 {
4548  assume( r1 == r2 || rSamePolyRep(r1, r2) ); // will be used in rEqual!
4549  assume( r1->cf == r2->cf );
4550 
4551  while ((p1 != NULL) && (p2 != NULL))
4552  {
4553  // returns 1 if ExpVector(p)==ExpVector(q): does not compare numbers !!
4554  // #define p_LmEqual(p1, p2, r) p_ExpVectorEqual(p1, p2, r)
4555 
4556  if (! p_ExpVectorEqual(p1, p2, r1, r2))
4557  return FALSE;
4558 
4559  if (! n_Equal(p_GetCoeff(p1,r1), p_GetCoeff(p2,r2), r1->cf ))
4560  return FALSE;
4561 
4562  pIter(p1);
4563  pIter(p2);
4564  }
4565  return (p1==p2);
4566 }
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:1799

◆ p_ExpVectorAdd()

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

Definition at line 1409 of file p_polys.h.

1410 {
1411  p_LmCheckPolyRing1(p1, r);
1412  p_LmCheckPolyRing1(p2, r);
1413 #if PDEBUG >= 1
1414  for (int i=1; i<=r->N; i++)
1415  pAssume1((unsigned long) (p_GetExp(p1, i, r) + p_GetExp(p2, i, r)) <= r->bitmask);
1416  pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0);
1417 #endif
1418 
1419  p_MemAdd_LengthGeneral(p1->exp, p2->exp, r->ExpL_Size);
1420  p_MemAdd_NegWeightAdjust(p1, r);
1421 }
#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:1290

◆ p_ExpVectorAddSub()

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

Definition at line 1454 of file p_polys.h.

1455 {
1456  p_LmCheckPolyRing1(p1, r);
1457  p_LmCheckPolyRing1(p2, r);
1458  p_LmCheckPolyRing1(p3, r);
1459 #if PDEBUG >= 1
1460  for (int i=1; i<=r->N; i++)
1461  pAssume1(p_GetExp(p1, i, r) + p_GetExp(p2, i, r) >= p_GetExp(p3, i, r));
1462  pAssume1(p_GetComp(p1, r) == 0 ||
1463  (p_GetComp(p2, r) - p_GetComp(p3, r) == 0) ||
1464  (p_GetComp(p1, r) == p_GetComp(p2, r) - p_GetComp(p3, r)));
1465 #endif
1466 
1467  p_MemAddSub_LengthGeneral(p1->exp, p2->exp, p3->exp, r->ExpL_Size);
1468  // no need to adjust in case of NegWeights
1469 }
#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 1311 of file p_polys.h.

1312 {
1313  p_LmCheckPolyRing1(d_p, r);
1314  p_LmCheckPolyRing1(s_p, r);
1315  memcpy(d_p->exp, s_p->exp, r->ExpL_Size*sizeof(long));
1316 }

◆ p_ExpVectorDiff()

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

Definition at line 1472 of file p_polys.h.

1473 {
1474  p_LmCheckPolyRing1(p1, r);
1475  p_LmCheckPolyRing1(p2, r);
1476  p_LmCheckPolyRing1(pr, r);
1477 #if PDEBUG >= 2
1478  for (int i=1; i<=r->N; i++)
1479  pAssume1(p_GetExp(p1, i, r) >= p_GetExp(p2, i, r));
1480  pAssume1(!rRing_has_Comp(r) || p_GetComp(p1, r) == p_GetComp(p2, r));
1481 #endif
1482 
1483  p_MemDiff_LengthGeneral(pr->exp, p1->exp, p2->exp, r->ExpL_Size);
1484  p_MemSub_NegWeightAdjust(pr, r);
1485 }
#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:1300

◆ p_ExpVectorEqual()

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

Definition at line 1487 of file p_polys.h.

1488 {
1489  p_LmCheckPolyRing1(p1, r);
1490  p_LmCheckPolyRing1(p2, r);
1491 
1492  unsigned i = r->ExpL_Size;
1493  unsigned long *ep = p1->exp;
1494  unsigned long *eq = p2->exp;
1495 
1496  do
1497  {
1498  i--;
1499  if (ep[i] != eq[i]) return FALSE;
1500  }
1501  while (i!=0);
1502  return TRUE;
1503 }

◆ p_ExpVectorSub()

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

Definition at line 1438 of file p_polys.h.

1439 {
1440  p_LmCheckPolyRing1(p1, r);
1441  p_LmCheckPolyRing1(p2, r);
1442 #if PDEBUG >= 1
1443  for (int i=1; i<=r->N; i++)
1444  pAssume1(p_GetExp(p1, i, r) >= p_GetExp(p2, i, r));
1445  pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0 ||
1446  p_GetComp(p1, r) == p_GetComp(p2, r));
1447 #endif
1448 
1449  p_MemSub_LengthGeneral(p1->exp, p2->exp, r->ExpL_Size);
1450  p_MemSub_NegWeightAdjust(p1, r);
1451 }
#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 1423 of file p_polys.h.

1424 {
1425  p_LmCheckPolyRing1(p1, r);
1426  p_LmCheckPolyRing1(p2, r);
1427  p_LmCheckPolyRing1(pr, r);
1428 #if PDEBUG >= 1
1429  for (int i=1; i<=r->N; i++)
1430  pAssume1((unsigned long) (p_GetExp(p1, i, r) + p_GetExp(p2, i, r)) <= r->bitmask);
1431  pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0);
1432 #endif
1433 
1434  p_MemSum_LengthGeneral(pr->exp, p1->exp, p2->exp, r->ExpL_Size);
1435  p_MemAdd_NegWeightAdjust(pr, r);
1436 }
#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:764

◆ p_FDeg()

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

Definition at line 378 of file p_polys.h.

378 { 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 4879 of file p_polys.cc.

4880 {
4881  assume(f!=NULL);
4882  assume(g!=NULL);
4883  assume(pNext(f)==NULL);
4884  poly G=p_Head(f,r);
4885  poly h=g;
4886  int *mf=(int*)omAlloc((r->N+1)*sizeof(int));
4887  p_GetExpV(f,mf,r);
4888  int *mh=(int*)omAlloc((r->N+1)*sizeof(int));
4889  BOOLEAN const_mon;
4890  BOOLEAN one_coeff=n_IsOne(pGetCoeff(G),r->cf);
4891  loop
4892  {
4893  if (h==NULL) break;
4894  if(!one_coeff)
4895  {
4896  number n=n_SubringGcd(pGetCoeff(G),pGetCoeff(h),r->cf);
4897  one_coeff=n_IsOne(n,r->cf);
4898  p_SetCoeff(G,n,r);
4899  }
4900  p_GetExpV(h,mh,r);
4901  const_mon=TRUE;
4902  for(unsigned j=r->N;j!=0;j--)
4903  {
4904  if (mh[j]<mf[j]) mf[j]=mh[j];
4905  if (mf[j]>0) const_mon=FALSE;
4906  }
4907  if (one_coeff && const_mon) break;
4908  pIter(h);
4909  }
4910  mf[0]=0;
4911  p_SetExpV(G,mf,r); // included is p_SetComp, p_Setm
4912  omFreeSize(mf,(r->N+1)*sizeof(int));
4913  omFreeSize(mh,(r->N+1)*sizeof(int));
4914  return G;
4915 }
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:1542
static void p_GetExpV(poly p, int *ev, const ring r)
Definition: p_polys.h:1518

◆ p_GetCoeffRat()

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

Definition at line 1718 of file p_polys.cc.

1719 {
1720  poly q = pNext(p);
1721  poly res; // = p_Head(p,r);
1722  res = p_GetExp_k_n(p, ishift+1, r->N, r); // does pSetm internally
1723  p_SetCoeff(res,n_Copy(p_GetCoeff(p,r),r),r);
1724  poly s;
1725  long cmp = p_GetComp(p, r);
1726  while ( (q!= NULL) && (p_Comp_k_n(p, q, ishift+1, r)) && (p_GetComp(q, r) == cmp) )
1727  {
1728  s = p_GetExp_k_n(q, ishift+1, r->N, r);
1729  p_SetCoeff(s,n_Copy(p_GetCoeff(q,r),r),r);
1730  res = p_Add_q(res,s,r);
1731  q = pNext(q);
1732  }
1733  cmp = 0;
1734  p_SetCompP(res,cmp,r);
1735  return res;
1736 }
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:638
static void p_SetCompP(poly p, int i, ring r)
Definition: p_polys.h:252

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

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

◆ p_GetExp() [2/3]

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

Definition at line 553 of file p_polys.h.

554 {
555  p_LmCheckPolyRing2(p, r);
556  pAssume2(VarOffset != -1);
557  return p_GetExp(p, r->bitmask, VarOffset);
558 }

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

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

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

◆ p_GetExpDiff()

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

Definition at line 633 of file p_polys.h.

634 {
635  return p_GetExp(p1,i,r) - p_GetExp(p2,i,r);
636 }

◆ p_GetExpSum()

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

Definition at line 627 of file p_polys.h.

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

◆ p_GetExpV()

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

Definition at line 1518 of file p_polys.h.

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

◆ p_GetExpVL()

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

Definition at line 1527 of file p_polys.h.

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

◆ p_GetExpVLV()

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

Definition at line 1534 of file p_polys.h.

1535 {
1536  p_LmCheckPolyRing1(p, r);
1537  for (unsigned j = r->N; j!=0; j--)
1538  ev[j-1] = p_GetExp(p, j, r);
1539  return (int64)p_GetComp(p,r);
1540 }
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 802 of file p_polys.h.

803 {
804  return p_GetMaxExp(p_GetMaxExpL(p, r), r);
805 }
static unsigned long p_GetMaxExp(const unsigned long l, const ring r)
Definition: p_polys.h:779
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:1175

◆ p_GetMaxExp() [2/2]

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

Definition at line 779 of file p_polys.h.

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

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

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

1139 {
1140  p_CheckPolyRing(p, r);
1141  if (p == NULL) return p_Init(r);
1142  poly max = p_LmInit(p, r);
1143  pIter(p);
1144  if (p == NULL) return max;
1145  int i, offset;
1146  unsigned long l_p, l_max;
1147  unsigned long divmask = r->divmask;
1148 
1149  do
1150  {
1151  offset = r->VarL_Offset[0];
1152  l_p = p->exp[offset];
1153  l_max = max->exp[offset];
1154  // do the divisibility trick to find out whether l has an exponent
1155  if (l_p > l_max ||
1156  (((l_max & divmask) ^ (l_p & divmask)) != ((l_max-l_p) & divmask)))
1157  max->exp[offset] = p_GetMaxExpL2(l_max, l_p, r);
1158 
1159  for (i=1; i<r->VarL_Size; i++)
1160  {
1161  offset = r->VarL_Offset[i];
1162  l_p = p->exp[offset];
1163  l_max = max->exp[offset];
1164  // do the divisibility trick to find out whether l has an exponent
1165  if (l_p > l_max ||
1166  (((l_max & divmask) ^ (l_p & divmask)) != ((l_max-l_p) & divmask)))
1167  max->exp[offset] = p_GetMaxExpL2(l_max, l_p, r);
1168  }
1169  pIter(p);
1170  }
1171  while (p != NULL);
1172  return max;
1173 }
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:1318

◆ p_GetOrder()

static long p_GetOrder ( poly  p,
ring  r 
)
inlinestatic

Definition at line 419 of file p_polys.h.

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

◆ p_GetSetmProc()

p_SetmProc p_GetSetmProc ( const ring  r)

Definition at line 560 of file p_polys.cc.

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

◆ p_GetShortExpVector()

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

Definition at line 4776 of file p_polys.cc.

4777 {
4778  assume(p != NULL);
4779  unsigned long ev = 0; // short exponent vector
4780  unsigned int n = BIT_SIZEOF_LONG / r->N; // number of bits per exp
4781  unsigned int m1; // highest bit which is filled with (n+1)
4782  unsigned int i=0;
4783  int j=1;
4784 
4785  if (n == 0)
4786  {
4787  if (r->N <2*BIT_SIZEOF_LONG)
4788  {
4789  n=1;
4790  m1=0;
4791  }
4792  else
4793  {
4794  for (; j<=r->N; j++)
4795  {
4796  if (p_GetExp(p,j,r) > 0) i++;
4797  if (i == BIT_SIZEOF_LONG) break;
4798  }
4799  if (i>0)
4800  ev = ~(0UL) >> (BIT_SIZEOF_LONG - i);
4801  return ev;
4802  }
4803  }
4804  else
4805  {
4806  m1 = (n+1)*(BIT_SIZEOF_LONG - n*r->N);
4807  }
4808 
4809  n++;
4810  while (i<m1)
4811  {
4812  ev |= GetBitFields(p_GetExp(p, j,r), i, n);
4813  i += n;
4814  j++;
4815  }
4816 
4817  n--;
4818  while (i<BIT_SIZEOF_LONG)
4819  {
4820  ev |= GetBitFields(p_GetExp(p, j,r), i, n);
4821  i += n;
4822  j++;
4823  }
4824  return ev;
4825 }
#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:4744

◆ p_GetTotalDegree()

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

Definition at line 808 of file p_polys.h.

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

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

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

◆ p_HasNotCF()

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

Definition at line 1329 of file p_polys.cc.

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

◆ p_HasNotCFRing()

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

Definition at line 1345 of file p_polys.cc.

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

◆ p_Head()

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

copy the (leading) term of p

Definition at line 858 of file p_polys.h.

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

◆ p_Head0()

poly p_Head0 ( const poly  p,
const ring  r 
)

like p_Head, but allow NULL coeff

Definition at line 4935 of file p_polys.cc.

4936 {
4937  if (p==NULL) return NULL;
4938  if (pGetCoeff(p)==NULL) return p_CopyPowerProduct0(p,NULL,r);
4939  return p_Head(p,r);
4940 }

◆ p_Homogen()

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

Definition at line 3266 of file p_polys.cc.

3267 {
3268  pFDegProc deg;
3269  if (r->pLexOrder && (r->order[0]==ringorder_lp))
3270  deg=p_Totaldegree;
3271  else
3272  deg=r->pFDeg;
3273 
3274  poly q=NULL, qn;
3275  int o,ii;
3276  sBucket_pt bp;
3277 
3278  if (p!=NULL)
3279  {
3280  if ((varnum < 1) || (varnum > rVar(r)))
3281  {
3282  return NULL;
3283  }
3284  o=deg(p,r);
3285  q=pNext(p);
3286  while (q != NULL)
3287  {
3288  ii=deg(q,r);
3289  if (ii>o) o=ii;
3290  pIter(q);
3291  }
3292  q = p_Copy(p,r);
3293  bp = sBucketCreate(r);
3294  while (q != NULL)
3295  {
3296  ii = o-deg(q,r);
3297  if (ii!=0)
3298  {
3299  p_AddExp(q,varnum, (long)ii,r);
3300  p_Setm(q,r);
3301  }
3302  qn = pNext(q);
3303  pNext(q) = NULL;
3304  sBucket_Add_m(bp, q);
3305  q = qn;
3306  }
3307  sBucketDestroyAdd(bp, &q, &ii);
3308  }
3309  return q;
3310 }
static long p_AddExp(poly p, int v, long ee, ring r)
Definition: p_polys.h:604
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 589 of file p_polys.h.

590 {
591  p_LmCheckPolyRing2(p, r);
592  int e = p_GetExp(p,v,r);
593  e++;
594  return p_SetExp(p,v,e,r);
595 }

◆ p_Init() [1/2]

static poly p_Init ( const ring  r)
inlinestatic

Definition at line 1328 of file p_polys.h.

1329 {
1330  return p_Init(r, r->PolyBin);
1331 }

◆ p_Init() [2/2]

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

Definition at line 1318 of file p_polys.h.

1319 {
1320  p_CheckRing1(r);
1321  pAssume1(bin != NULL && omSizeWOfBin(r->PolyBin) == omSizeWOfBin(bin));
1322  poly p;
1323  omTypeAlloc0Bin(poly, p, bin);
1325  p_SetRingOfLm(p, r);
1326  return p;
1327 }
#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 2631 of file p_polys.cc.

2634 {
2636  assume(ph!=NULL);
2637  assume(pNext(ph)!=NULL);
2638  assume(rField_is_Q(r));
2639  if (pNext(pNext(ph))==NULL)
2640  {
2641  return n_GetNumerator(pGetCoeff(pNext(ph)),r->cf);
2642  }
2643  poly p=ph;
2644  number n1=n_GetNumerator(pGetCoeff(p),r->cf);
2645  pIter(p);
2646  number n2=n_GetNumerator(pGetCoeff(p),r->cf);
2647  pIter(p);
2648  number d;
2649  number t;
2650  loop
2651  {
2652  nlNormalize(pGetCoeff(p),r->cf);
2653  t=n_GetNumerator(pGetCoeff(p),r->cf);
2654  if (nlGreaterZero(t,r->cf))
2655  d=nlAdd(n1,t,r->cf);
2656  else
2657  d=nlSub(n1,t,r->cf);
2658  nlDelete(&t,r->cf);
2659  nlDelete(&n1,r->cf);
2660  n1=d;
2661  pIter(p);
2662  if (p==NULL) break;
2663  nlNormalize(pGetCoeff(p),r->cf);
2664  t=n_GetNumerator(pGetCoeff(p),r->cf);
2665  if (nlGreaterZero(t,r->cf))
2666  d=nlAdd(n2,t,r->cf);
2667  else
2668  d=nlSub(n2,t,r->cf);
2669  nlDelete(&t,r->cf);
2670  nlDelete(&n2,r->cf);
2671  n2=d;
2672  pIter(p);
2673  if (p==NULL) break;
2674  }
2675  d=nlGcd(n1,n2,r->cf);
2676  nlDelete(&n1,r->cf);
2677  nlDelete(&n2,r->cf);
2678  return d;
2679 }
2680 #else
2681 {
2682  /* ph has al least 2 terms */
2683  number d=pGetCoeff(ph);
2684  int s=n_Size(d,r->cf);
2685  pIter(ph);
2686  number d2=pGetCoeff(ph);
2687  int s2=n_Size(d2,r->cf);
2688  pIter(ph);
2689  if (ph==NULL)
2690  {
2691  if (s<s2) return n_Copy(d,r->cf);
2692  else return n_Copy(d2,r->cf);
2693  }
2694  do
2695  {
2696  number nd=pGetCoeff(ph);
2697  int ns=n_Size(nd,r->cf);
2698  if (ns<=2)
2699  {
2700  s2=s;
2701  d2=d;
2702  d=nd;
2703  s=ns;
2704  break;
2705  }
2706  else if (ns<s)
2707  {
2708  s2=s;
2709  d2=d;
2710  d=nd;
2711  s=ns;
2712  }
2713  pIter(ph);
2714  }
2715  while(ph!=NULL);
2716  return n_SubringGcd(d,d2,r->cf);
2717 }
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:567
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:605
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 1962 of file p_polys.h.

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

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

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

◆ p_IsConstantPoly()

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

Definition at line 1976 of file p_polys.h.

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

◆ p_ISet()

poly p_ISet ( long  i,
const ring  r 
)

returns the poly representing the integer i

Definition at line 1297 of file p_polys.cc.

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

◆ p_IsHomogeneous()

BOOLEAN p_IsHomogeneous ( poly  p,
const ring  r 
)

Definition at line 3315 of file p_polys.cc.

3316 {
3317  poly qp=p;
3318  int o;
3319 
3320  if ((p == NULL) || (pNext(p) == NULL)) return TRUE;
3321  pFDegProc d;
3322  if (r->pLexOrder && (r->order[0]==ringorder_lp))
3323  d=p_Totaldegree;
3324  else
3325  d=r->pFDeg;
3326  o = d(p,r);
3327  do
3328  {
3329  if (d(qp,r) != o) return FALSE;
3330  pIter(qp);
3331  }
3332  while (qp != NULL);
3333  return TRUE;
3334 }

◆ p_IsHomogeneousW() [1/2]

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

Definition at line 3356 of file p_polys.cc.

3357 {
3358  poly qp=p;
3359  long o;
3360 
3361  if ((p == NULL) || (pNext(p) == NULL)) return TRUE;
3362  pIter(qp);
3363  o = totaldegreeWecart_IV(p,r,w->ivGetVec())+(*module_w)[p_GetComp(p,r)];
3364  do
3365  {
3366  long oo=totaldegreeWecart_IV(qp,r,w->ivGetVec())+(*module_w)[p_GetComp(qp,r)];
3367  if (oo != o) return FALSE;
3368  pIter(qp);
3369  }
3370  while (qp != NULL);
3371  return TRUE;
3372 }

◆ p_IsHomogeneousW() [2/2]

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

Definition at line 3339 of file p_polys.cc.

3340 {
3341  poly qp=p;
3342  long o;
3343 
3344  if ((p == NULL) || (pNext(p) == NULL)) return TRUE;
3345  pIter(qp);
3346  o = totaldegreeWecart_IV(p,r,w->ivGetVec());
3347  do
3348  {
3349  if (totaldegreeWecart_IV(qp,r,w->ivGetVec()) != o) return FALSE;
3350  pIter(qp);
3351  }
3352  while (qp != NULL);
3353  return TRUE;
3354 }

◆ p_IsOne()

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

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

Definition at line 1969 of file p_polys.h.

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

◆ p_IsPurePower()

int p_IsPurePower ( const poly  p,
const ring  r 
)

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

Definition at line 1226 of file p_polys.cc.

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

◆ p_IsUnit()

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

Definition at line 1989 of file p_polys.h.

1990 {
1991  if (p == NULL) return FALSE;
1992  if (rField_is_Ring(r))
1993  return (p_LmIsConstant(p, r) && n_IsUnit(pGetCoeff(p),r->cf));
1994  return p_LmIsConstant(p, r);
1995 }
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:512

◆ p_IsUnivariate()

int p_IsUnivariate ( poly  p,
const ring  r 
)

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

Definition at line 1247 of file p_polys.cc.

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

◆ p_Jet()

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

Definition at line 4382 of file p_polys.cc.

4383 {
4384  while((p!=NULL) && (p_Totaldegree(p,R)>m)) p_LmDelete(&p,R);
4385  if (p==NULL) return NULL;
4386  poly r=p;
4387  while (pNext(p)!=NULL)
4388  {
4389  if (p_Totaldegree(pNext(p),R)>m)
4390  {
4391  p_LmDelete(&pNext(p),R);
4392  }
4393  else
4394  pIter(p);
4395  }
4396  return r;
4397 }

◆ p_JetW()

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

Definition at line 4426 of file p_polys.cc.

4427 {
4428  while((p!=NULL) && (totaldegreeWecart_IV(p,R,w)>m)) p_LmDelete(&p,R);
4429  if (p==NULL) return NULL;
4430  poly r=p;
4431  while (pNext(p)!=NULL)
4432  {
4433  if (totaldegreeWecart_IV(pNext(p),R,w)>m)
4434  {
4435  p_LmDelete(&pNext(p),R);
4436  }
4437  else
4438  pIter(p);
4439  }
4440  return r;
4441 }

◆ p_Last()

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

Definition at line 4617 of file p_polys.cc.

4618 {
4619  if (p == NULL)
4620  {
4621  l = 0;
4622  return NULL;
4623  }
4624  l = 1;
4625  poly a = p;
4626  if (! rIsSyzIndexRing(r))
4627  {
4628  poly next = pNext(a);
4629  while (next!=NULL)
4630  {
4631  a = next;
4632  next = pNext(a);
4633  l++;
4634  }
4635  }
4636  else
4637  {
4638  long unsigned curr_limit = rGetCurrSyzLimit(r);
4639  poly pp = a;
4640  while ((a=pNext(a))!=NULL)
4641  {
4642  if (__p_GetComp(a,r)<=curr_limit/*syzComp*/)
4643  l++;
4644  else break;
4645  pp = a;
4646  }
4647  a=pp;
4648  }
4649  return a;
4650 }
ListNode * next
Definition: janet.h:31
static int rGetCurrSyzLimit(const ring r)
Definition: ring.h:723
static BOOLEAN rIsSyzIndexRing(const ring r)
Definition: ring.h:720

◆ p_Lcm() [1/2]

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

Definition at line 1660 of file p_polys.cc.

1661 {
1662  poly m=p_Init(r);
1663  p_Lcm(a, b, m, r);
1664  p_Setm(m,r);
1665  return(m);
1666 }
void p_Lcm(const poly a, const poly b, poly m, const ring r)
Definition: p_polys.cc:1651

◆ p_Lcm() [2/2]

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

Definition at line 1651 of file p_polys.cc.

1652 {
1653  for (int i=r->N; i; --i)
1654  p_SetExp(m,i, si_max( p_GetExp(a,i,r), p_GetExp(b,i,r)),r);
1655 
1656  p_SetComp(m, si_max(p_GetComp(a,r), p_GetComp(b,r)),r);
1657  /* Don't do a pSetm here, otherwise hres/lres chockes */
1658 }
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:245

◆ p_LcmRat()

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

Definition at line 1673 of file p_polys.cc.

1674 {
1675  poly m = // p_One( r);
1676  p_Init(r);
1677 
1678 // const int (currRing->N) = r->N;
1679 
1680  // for (int i = (currRing->N); i>=r->real_var_start; i--)
1681  for (int i = r->real_var_end; i>=r->real_var_start; i--)
1682  {
1683  const int lExpA = p_GetExp (a, i, r);
1684  const int lExpB = p_GetExp (b, i, r);
1685 
1686  p_SetExp (m, i, si_max(lExpA, lExpB), r);
1687  }
1688 
1689  p_SetComp (m, lCompM, r);
1690  p_Setm(m,r);
1691  p_GetCoeff(m, r)=NULL;
1692 
1693  return(m);
1694 };

◆ p_LDeg()

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

Definition at line 379 of file p_polys.h.

379 { 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:223

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

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

◆ p_LmDelete() [1/2]

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

Definition at line 741 of file p_polys.h.

742 {
743  p_LmCheckPolyRing2(*p, r);
744  poly h = *p;
745  *p = pNext(h);
746  n_Delete(&pGetCoeff(h), r->cf);
747  #ifdef XALLOC_BIN
748  omFreeBin(h,r->PolyBin);
749  #else
750  omFreeBinAddr(h);
751  #endif
752 }
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
#define omFreeBinAddr(addr)
Definition: omAllocDecl.h:258

◆ p_LmDelete() [2/2]

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

Definition at line 721 of file p_polys.h.

722 {
723  p_LmCheckPolyRing2(p, r);
724  n_Delete(&pGetCoeff(p), r->cf);
725  #ifdef XALLOC_BIN
726  omFreeBin(p,r->PolyBin);
727  #else
728  omFreeBinAddr(p);
729  #endif
730 }

◆ p_LmDelete0()

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

Definition at line 731 of file p_polys.h.

732 {
733  p_LmCheckPolyRing2(p, r);
734  if (pGetCoeff(p)!=NULL) n_Delete(&pGetCoeff(p), r->cf);
735  #ifdef XALLOC_BIN
736  omFreeBin(p,r->PolyBin);
737  #else
738  omFreeBinAddr(p);
739  #endif
740 }

◆ p_LmDeleteAndNext()

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

Definition at line 753 of file p_polys.h.

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

◆ p_LmDeleteAndNextRat()

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

Definition at line 1696 of file p_polys.cc.

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

◆ p_LmDivisibleBy()

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

Definition at line 1889 of file p_polys.h.

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

◆ p_LmDivisibleByNoComp() [1/2]

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

Definition at line 1882 of file p_polys.h.

1883 {
1884  p_LmCheckPolyRing1(a, ra);
1885  p_LmCheckPolyRing1(b, rb);
1886  return _p_LmDivisibleByNoComp(a, ra, b, rb);
1887 }

◆ p_LmDivisibleByNoComp() [2/2]

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

Definition at line 1875 of file p_polys.h.

1876 {
1877  p_LmCheckPolyRing1(a, r);
1878  p_LmCheckPolyRing1(b, r);
1879  return _p_LmDivisibleByNoComp(a, b, r);
1880 }

◆ p_LmDivisibleByPart()

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

Definition at line 1860 of file p_polys.h.

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

◆ p_LmExpVectorAddIsOk()

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

Definition at line 1997 of file p_polys.h.

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

◆ p_LmFree() [1/2]

static void p_LmFree ( poly *  p,
ring   
)
inlinestatic

Definition at line 694 of file p_polys.h.

696 {
697  p_LmCheckPolyRing2(*p, r);
698  poly h = *p;
699  *p = pNext(h);
700  #ifdef XALLOC_BIN
701  omFreeBin(h,r->PolyBin);
702  #else
703  omFreeBinAddr(h);
704  #endif
705 }

◆ p_LmFree() [2/2]

static void p_LmFree ( poly  p,
ring   
)
inlinestatic

Definition at line 681 of file p_polys.h.

683 {
684  p_LmCheckPolyRing2(p, r);
685  #ifdef XALLOC_BIN
686  omFreeBin(p,r->PolyBin);
687  #else
688  omFreeBinAddr(p);
689  #endif
690 }

◆ p_LmFreeAndNext()

static poly p_LmFreeAndNext ( poly  p,
ring   
)
inlinestatic

Definition at line 709 of file p_polys.h.

711 {
712  p_LmCheckPolyRing2(p, r);
713  poly pnext = pNext(p);
714  #ifdef XALLOC_BIN
715  omFreeBin(p,r->PolyBin);
716  #else
717  omFreeBinAddr(p);
718  #endif
719  return pnext;
720 }

◆ p_LmInit() [1/3]

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

Definition at line 1333 of file p_polys.h.

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

◆ p_LmInit() [2/3]

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

Definition at line 1361 of file p_polys.h.

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

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

1345 {
1346  p_LmCheckPolyRing1(s_p, s_r);
1347  p_CheckRing(d_r);
1348  pAssume1(d_r->N <= s_r->N);
1349  poly d_p = p_Init(d_r, d_bin);
1350  for (unsigned i=d_r->N; i!=0; i--)
1351  {
1352  p_SetExp(d_p, i, p_GetExp(s_p, i,s_r), d_r);
1353  }
1354  if (rRing_has_Comp(d_r))
1355  {
1356  p_SetComp(d_p, p_GetComp(s_p,s_r), d_r);
1357  }
1358  p_Setm(d_p, d_r);
1359  return d_p;
1360 }
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 1021 of file p_polys.h.

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

◆ p_LmIsConstantComp()

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

Definition at line 1004 of file p_polys.h.

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

◆ p_LmShallowCopyDelete()

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

Definition at line 1391 of file p_polys.h.

1392 {
1393  p_LmCheckPolyRing1(p, r);
1394  pAssume1(omSizeWOfBin(bin) == omSizeWOfBin(r->PolyBin));
1395  poly new_p = p_New(r);
1396  memcpy(new_p->exp, p->exp, r->ExpL_Size*sizeof(long));
1397  pSetCoeff0(new_p, pGetCoeff(p));
1398  pNext(new_p) = pNext(p);
1399  omFreeBinAddr(p);
1400  return new_p;
1401 }
static poly p_New(const ring, omBin bin)
Definition: p_polys.h:662

◆ p_LmShortDivisibleBy()

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

Definition at line 1908 of file p_polys.h.

1910 {
1911  p_LmCheckPolyRing1(a, r);
1912  p_LmCheckPolyRing1(b, r);
1913 #ifndef PDIV_DEBUG
1914  _pPolyAssume2(p_GetShortExpVector(a, r) == sev_a, a, r);
1915  _pPolyAssume2(p_GetShortExpVector(b, r) == ~ not_sev_b, b, r);
1916 
1917  if (sev_a & not_sev_b)
1918  {
1920  return FALSE;
1921  }
1922  return p_LmDivisibleBy(a, b, r);
1923 #else
1924  return pDebugLmShortDivisibleBy(a, sev_a, r, b, not_sev_b, r);
1925 #endif
1926 }
#define _pPolyAssume2(cond, p, r)
Definition: monomials.h:195
static BOOLEAN p_LmDivisibleByNoComp(poly a, poly b, const ring r)
Definition: p_polys.h:1875
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
Definition: p_polys.h:1889
unsigned long p_GetShortExpVector(const poly a, const ring r)
Definition: p_polys.cc:4776

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

1930 {
1931  p_LmCheckPolyRing1(a, r);
1932  p_LmCheckPolyRing1(b, r);
1933 #ifndef PDIV_DEBUG
1934  _pPolyAssume2(p_GetShortExpVector(a, r) == sev_a, a, r);
1935  _pPolyAssume2(p_GetShortExpVector(b, r) == ~ not_sev_b, b, r);
1936 
1937  if (sev_a & not_sev_b)
1938  {
1940  return FALSE;
1941  }
1942  return p_LmDivisibleByNoComp(a, b, r);
1943 #else
1944  return pDebugLmShortDivisibleByNoComp(a, sev_a, r, b, not_sev_b, r);
1945 #endif
1946 }

◆ p_LowVar()

int p_LowVar ( poly  p,
const ring  r 
)

the minimal index of used variables - 1

Definition at line 4676 of file p_polys.cc.

4677 {
4678  int k,l,lex;
4679 
4680  if (p == NULL) return -1;
4681 
4682  k = 32000;/*a very large dummy value*/
4683  while (p != NULL)
4684  {
4685  l = 1;
4686  lex = p_GetExp(p,l,r);
4687  while ((l < (rVar(r))) && (lex == 0))
4688  {
4689  l++;
4690  lex = p_GetExp(p,l,r);
4691  }
4692  l--;
4693  if (l < k) k = l;
4694  pIter(p);
4695  }
4696  return k;
4697 }

◆ p_LtCmp()

static int p_LtCmp ( 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 = n_Copy(p_GetCoeff(p,r),r->cf);
1627  number qc = n_Copy(p_GetCoeff(q,r),r->cf);
1628  if(!n_GreaterZero(pc,r->cf))
1629  pc = n_InpNeg(pc,r->cf);
1630  if(!n_GreaterZero(qc,r->cf))
1631  qc = n_InpNeg(qc,r->cf);
1632  if(n_Greater(pc,qc,r->cf))
1633  res = 1;
1634  else if(n_Greater(qc,pc,r->cf))
1635  res = -1;
1636  else if(n_Equal(pc,qc,r->cf))
1637  res = 0;
1638  n_Delete(&pc,r->cf);
1639  n_Delete(&qc,r->cf);
1640  }
1641  return res;
1642 }
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:508

◆ p_LtCmpNoAbs()

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

Definition at line 1645 of file p_polys.h.

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

◆ p_LtCmpOrdSgnDiffM()

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

Definition at line 1667 of file p_polys.h.

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

◆ p_LtCmpOrdSgnDiffP()

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

Definition at line 1676 of file p_polys.h.

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

◆ p_LtCmpOrdSgnEqM()

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

Definition at line 1692 of file p_polys.h.

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

◆ p_LtCmpOrdSgnEqP()

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

Definition at line 1701 of file p_polys.h.

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

◆ p_MaxComp() [1/2]

static long p_MaxComp ( poly  p,
ring  lmRing 
)
inlinestatic

Definition at line 309 of file p_polys.h.

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

◆ p_MaxComp() [2/2]

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

Definition at line 290 of file p_polys.h.

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

◆ p_MaxExpPerVar()

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

max exponent of variable x_i in p

Definition at line 4941 of file p_polys.cc.

4942 {
4943  int m=0;
4944  while(p!=NULL)
4945  {
4946  int mm=p_GetExp(p,i,r);
4947  if (mm>m) m=mm;
4948  pIter(p);
4949  }
4950  return m;
4951 }

◆ p_MDivide()

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

Definition at line 1488 of file p_polys.cc.

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

◆ p_MemAdd_NegWeightAdjust()

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

Definition at line 1290 of file p_polys.h.

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

◆ p_MemSub_NegWeightAdjust()

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

Definition at line 1300 of file p_polys.h.

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

◆ p_Merge_q()

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

Definition at line 1210 of file p_polys.h.

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

◆ p_MinComp() [1/2]

static long p_MinComp ( poly  p,
ring  lmRing 
)
inlinestatic

Definition at line 330 of file p_polys.h.

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

◆ p_MinComp() [2/2]

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

Definition at line 311 of file p_polys.h.

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

◆ p_MinDeg()

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

Definition at line 4444 of file p_polys.cc.

4445 {
4446  if(p==NULL)
4447  return -1;
4448  int d=-1;
4449  while(p!=NULL)
4450  {
4451  int d0=0;
4452  for(int j=0;j<rVar(R);j++)
4453  if(w==NULL||j>=w->length())
4454  d0+=p_GetExp(p,j+1,R);
4455  else
4456  d0+=(*w)[j]*p_GetExp(p,j+1,R);
4457  if(d0<d||d==-1)
4458  d=d0;
4459  pIter(p);
4460  }
4461  return d;
4462 }

◆ p_mInit()

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

Definition at line 1442 of file p_polys.cc.

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

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

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

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

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

◆ p_mm_Mult()

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

Definition at line 1059 of file p_polys.h.

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

◆ p_Mult_mm()

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

Definition at line 1049 of file p_polys.h.

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

◆ p_Mult_nn() [1/2]

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

Definition at line 971 of file p_polys.h.

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

◆ p_Mult_nn() [2/2]

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

Definition at line 956 of file p_polys.h.

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

◆ p_Mult_q()

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

Definition at line 1112 of file p_polys.h.

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

620 {
621  p_LmCheckPolyRing2(p, r);
622  long e = p_GetExp(p,v,r);
623  e *= ee;
624  return p_SetExp(p,v,e,r);
625 }

◆ p_Neg()

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

Definition at line 1105 of file p_polys.h.

1106 {
1107  return r->p_Procs->p_Neg(p, r);
1108 }

◆ p_New() [1/2]

static poly p_New ( const  ring,
omBin  bin 
)
inlinestatic

Definition at line 662 of file p_polys.h.

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

◆ p_New() [2/2]

static poly p_New ( ring  r)
inlinestatic

Definition at line 673 of file p_polys.h.

674 {
675  return p_New(r, r->PolyBin);
676 }

◆ p_Norm()

void p_Norm ( poly  p1,
const ring  r 
)

Definition at line 3715 of file p_polys.cc.

3716 {
3717  if (LIKELY(rField_is_Ring(r)))
3718  {
3719  if(!n_GreaterZero(pGetCoeff(p1),r->cf)) p1 = p_Neg(p1,r);
3720  if (!n_IsUnit(pGetCoeff(p1), r->cf)) return;
3721  // Werror("p_Norm not possible in the case of coefficient rings.");
3722  }
3723  else if (LIKELY(p1!=NULL))
3724  {
3725  if (UNLIKELY(pNext(p1)==NULL))
3726  {
3727  p_SetCoeff(p1,n_Init(1,r->cf),r);
3728  return;
3729  }
3730  if (!n_IsOne(pGetCoeff(p1),r->cf))
3731  {
3732  number k = pGetCoeff(p1);
3733  pSetCoeff0(p1,n_Init(1,r->cf));
3734  poly h = pNext(p1);
3735  if (LIKELY(rField_is_Zp(r)))
3736  {
3737  if (r->cf->ch>32003)
3738  {
3739  number inv=n_Invers(k,r->cf);
3740  while (h!=NULL)
3741  {
3742  number c=n_Mult(pGetCoeff(h),inv,r->cf);
3743  // no need to normalize
3744  p_SetCoeff(h,c,r);
3745  pIter(h);
3746  }
3747  // no need for n_Delete for Zp: n_Delete(&inv,r->cf);
3748  }
3749  else
3750  {
3751  while (h!=NULL)
3752  {
3753  number c=n_Div(pGetCoeff(h),k,r->cf);
3754  // no need to normalize
3755  p_SetCoeff(h,c,r);
3756  pIter(h);
3757  }
3758  }
3759  }
3760  else if(getCoeffType(r->cf)==n_algExt)
3761  {
3762  n_Normalize(k,r->cf);
3763  number inv=n_Invers(k,r->cf);
3764  while (h!=NULL)
3765  {
3766  number c=n_Mult(pGetCoeff(h),inv,r->cf);
3767  // no need to normalize
3768  // normalize already in nMult: Zp_a, Q_a
3769  p_SetCoeff(h,c,r);
3770  pIter(h);
3771  }
3772  n_Delete(&inv,r->cf);
3773  n_Delete(&k,r->cf);
3774  }
3775  else
3776  {
3777  n_Normalize(k,r->cf);
3778  while (h!=NULL)
3779  {
3780  number c=n_Div(pGetCoeff(h),k,r->cf);
3781  // no need to normalize: Z/p, R
3782  // remains: Q
3783  if (rField_is_Q(r)) n_Normalize(c,r->cf);
3784  p_SetCoeff(h,c,r);
3785  pIter(h);
3786  }
3787  n_Delete(&k,r->cf);
3788  }
3789  }
3790  else
3791  {
3792  //if (r->cf->cfNormalize != nDummy2) //TODO: OPTIMIZE
3793  if (rField_is_Q(r))
3794  {
3795  poly h = pNext(p1);
3796  while (h!=NULL)
3797  {
3798  n_Normalize(pGetCoeff(h),r->cf);
3799  pIter(h);
3800  }
3801  }
3802  }
3803  }
3804 }
#define UNLIKELY(X)
Definition: auxiliary.h:404
#define LIKELY(X)
Definition: auxiliary.h:403

◆ p_Normalize()

void p_Normalize ( poly  p,
const ring  r 
)

Definition at line 3809 of file p_polys.cc.

3810 {
3811  const coeffs cf=r->cf;
3812  /* Z/p, GF(p,n), R, long R/C, Nemo rings */
3813  if (cf->cfNormalize==ndNormalize)
3814  return;
3815  while (p!=NULL)
3816  {
3817  // no test befor n_Normalize: n_Normalize should fix problems
3819  pIter(p);
3820  }
3821 }
void ndNormalize(number &, const coeffs)
Definition: numbers.cc:187

◆ p_NSet()

poly p_NSet ( number  n,
const ring  r 
)

returns the poly representing the number n, destroys n

Definition at line 1469 of file p_polys.cc.

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

◆ p_One()

poly p_One ( const ring  r)

Definition at line 1313 of file p_polys.cc.

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

◆ p_OneComp()

BOOLEAN p_OneComp ( poly  p,
const ring  r 
)

return TRUE if all monoms have the same component

Definition at line 1208 of file p_polys.cc.

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

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

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

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

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

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

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

◆ p_Power()

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

Definition at line 2193 of file p_polys.cc.

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

◆ p_ProjectiveUnique()

void p_ProjectiveUnique ( poly  p,
const ring  r 
)

Definition at line 3139 of file p_polys.cc.

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

◆ p_Read()

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

Definition at line 1370 of file p_polys.cc.

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

4495 {
4496  int *ww=iv2array(w,R);
4497  if(p!=NULL)
4498  {
4499  if(u==NULL)
4500  p=p_JetW(p,n,ww,R);
4501  else
4502  p=p_JetW(p_Mult_q(p,p_Invers(n-p_MinDeg(p,w,R),u,w,R),R),n,ww,R);
4503  }
4504  omFreeSize((ADDRESS)ww,(rVar(R)+1)*sizeof(int));
4505  return p;
4506 }
static poly p_Invers(int n, poly u, intvec *w, const ring R)
Definition: p_polys.cc:4465
int p_MinDeg(poly p, intvec *w, const ring R)
Definition: p_polys.cc:4444
poly p_JetW(poly p, int m, int *w, const ring R)
Definition: p_polys.cc:4426
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 410 of file p_polys.h.

411 {
412  p_LmCheckPolyRing2(p, r);
413  n_Delete(&(p->coef), r->cf);
414  (p)->coef=n;
415  return n;
416 }

◆ p_SetComp()

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

Definition at line 245 of file p_polys.h.

246 {
247  p_LmCheckPolyRing2(p, r);
248  if (r->pCompIndex>=0) __p_GetComp(p,r) = c;
249  return c;
250 }

◆ p_SetCompP() [1/2]

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

Definition at line 279 of file p_polys.h.

280 {
281  if (p != NULL)
282  {
283  p_SetComp(p, i, lmRing);
284  p_SetmComp(p, lmRing);
285  p_SetCompP(pNext(p), i, tailRing);
286  }
287 }

◆ p_SetCompP() [2/2]

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

Definition at line 252 of file p_polys.h.

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

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

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

◆ p_SetExp() [2/3]

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

Definition at line 560 of file p_polys.h.

561 {
562  p_LmCheckPolyRing2(p, r);
563  pAssume2(VarOffset != -1);
564  return p_SetExp(p, e, r->bitmask, VarOffset);
565 }

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

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

◆ p_SetExpV()

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

Definition at line 1542 of file p_polys.h.

1543 {
1544  p_LmCheckPolyRing1(p, r);
1545  for (unsigned j = r->N; j!=0; j--)
1546  p_SetExp(p, j, ev[j], r);
1547 
1548  if(ev[0]!=0) p_SetComp(p, ev[0],r);
1549  p_Setm(p, r);
1550 }

◆ p_SetExpVL()

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

Definition at line 1551 of file p_polys.h.

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

◆ p_SetExpVLV()

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

Definition at line 1562 of file p_polys.h.

1563 {
1564  p_LmCheckPolyRing1(p, r);
1565  for (unsigned j = r->N; j!=0; j--)
1566  p_SetExp(p, j, ev[j-1], r);
1567  p_SetComp(p, comp,r);
1568 
1569  p_Setm(p, r);
1570 }
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 231 of file p_polys.h.

232 {
233  p_CheckRing2(r);
234  r->p_Setm(p, r);
235 }

◆ p_SetModDeg()

void p_SetModDeg ( intvec w,
ring  r 
)

Definition at line 3669 of file p_polys.cc.

3670 {
3671  if (w!=NULL)
3672  {
3673  r->pModW = w;
3674  pOldFDeg = r->pFDeg;
3675  pOldLDeg = r->pLDeg;
3676  pOldLexOrder = r->pLexOrder;
3677  pSetDegProcs(r,pModDeg);
3678  r->pLexOrder = TRUE;
3679  }
3680  else
3681  {
3682  r->pModW = NULL;
3684  r->pLexOrder = pOldLexOrder;
3685  }
3686 }
STATIC_VAR pLDegProc pOldLDeg
Definition: p_polys.cc:3657
void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
Definition: p_polys.cc:3645
STATIC_VAR BOOLEAN pOldLexOrder
Definition: p_polys.cc:3658
STATIC_VAR pFDegProc pOldFDeg
Definition: p_polys.cc:3656
void pSetDegProcs(ring r, pFDegProc new_FDeg, pLDegProc new_lDeg)
Definition: p_polys.cc:3633
static long pModDeg(poly p, ring r)
Definition: p_polys.cc:3660

◆ p_ShallowCopyDelete()

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

Definition at line 926 of file p_polys.h.

927 {
928  p_LmCheckPolyRing2(p, r);
929  pAssume2(omSizeWOfBin(r->PolyBin) == omSizeWOfBin(bin));
930  return r->p_Procs->p_ShallowCopyDelete(p, r, bin);
931 }

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

4703 {
4704  poly qp1 = *p,qp2 = *p;/*working pointers*/
4705  int j = p_MaxComp(*p,r),k = p_MinComp(*p,r);
4706 
4707  if (j+i < 0) return ;
4708  BOOLEAN toPoly= ((j == -i) && (j == k));
4709  while (qp1 != NULL)
4710  {
4711  if (toPoly || (__p_GetComp(qp1,r)+i > 0))
4712  {
4713  p_AddComp(qp1,i,r);
4714  p_SetmComp(qp1,r);
4715  qp2 = qp1;
4716  pIter(qp1);
4717  }
4718  else
4719  {
4720  if (qp2 == *p)
4721  {
4722  pIter(*p);
4723  p_LmDelete(&qp2,r);
4724  qp2 = *p;
4725  qp1 = *p;
4726  }
4727  else
4728  {
4729  qp2->next = qp1->next;
4730  if (qp1!=NULL) p_LmDelete(&qp1,r);
4731  qp1 = qp2->next;
4732  }
4733  }
4734  }
4735 }
return
Definition: cfGcdAlgExt.cc:218
static unsigned long p_AddComp(poly p, unsigned long v, ring r)
Definition: p_polys.h:445

◆ p_SimpleContent()

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

Definition at line 2560 of file p_polys.cc.

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

◆ p_Size()

int p_Size ( poly  p,
const ring  r 
)

Definition at line 3249 of file p_polys.cc.

3250 {
3251  int count = 0;
3252  if (r->cf->has_simple_Alloc)
3253  return pLength(p);
3254  while ( p != NULL )
3255  {
3256  count+= n_Size( pGetCoeff( p ), r->cf );
3257  pIter( p );
3258  }
3259  return count;
3260 }
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 1217 of file p_polys.h.

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

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

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

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

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

1243 {
1244  p_String0(p, p_ring, p_ring);
1245 }
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:581

◆ 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:586

◆ p_Sub()

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

Definition at line 1986 of file p_polys.cc.

1987 {
1988  return p_Add_q(p1, p_Neg(p2,r),r);
1989 }

◆ p_SubComp()

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

Definition at line 451 of file p_polys.h.

452 {
453  p_LmCheckPolyRing2(p, r);
455  _pPolyAssume2(__p_GetComp(p,r) >= v,p,r);
456  return __p_GetComp(p,r) -= v;
457 }

◆ p_SubExp()

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

Definition at line 611 of file p_polys.h.

612 {
613  p_LmCheckPolyRing2(p, r);
614  long e = p_GetExp(p,v,r);
615  pAssume2(e >= ee);
616  e -= ee;
617  return p_SetExp(p,v,e,r);
618 }

◆ p_Subst()

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

Definition at line 3954 of file p_polys.cc.

3955 {
3956 #ifdef HAVE_SHIFTBBA
3957  // also don't even use p_Subst0 for Letterplace
3958  if (rIsLPRing(r))
3959  {
3960  poly subst = p_LPSubst(p, n, e, r);
3961  p_Delete(&p, r);
3962  return subst;
3963  }
3964 #endif
3965 
3966  if (e == NULL) return p_Subst0(p, n,r);
3967 
3968  if (p_IsConstant(e,r))
3969  {
3970  if (n_IsOne(pGetCoeff(e),r->cf)) return p_Subst1(p,n,r);
3971  else return p_Subst2(p, n, pGetCoeff(e),r);
3972  }
3973 
3974 #ifdef HAVE_PLURAL
3975  if (rIsPluralRing(r))
3976  {
3977  return nc_pSubst(p,n,e,r);
3978  }
3979 #endif
3980 
3981  int exponent,i;
3982  poly h, res, m;
3983  int *me,*ee;
3984  number nu,nu1;
3985 
3986  me=(int *)omAlloc((rVar(r)+1)*sizeof(int));
3987  ee=(int *)omAlloc((rVar(r)+1)*sizeof(int));
3988  if (e!=NULL) p_GetExpV(e,ee,r);
3989  res=NULL;
3990  h=p;
3991  while (h!=NULL)
3992  {
3993  if ((e!=NULL) || (p_GetExp(h,n,r)==0))
3994  {
3995  m=p_Head(h,r);
3996  p_GetExpV(m,me,r);
3997  exponent=me[n];
3998  me[n]=0;
3999  for(i=rVar(r);i>0;i--)
4000  me[i]+=exponent*ee[i];
4001  p_SetExpV(m,me,r);
4002  if (e!=NULL)
4003  {
4004  n_Power(pGetCoeff(e),exponent,&nu,r->cf);
4005  nu1=n_Mult(pGetCoeff(m),nu,r->cf);
4006  n_Delete(&nu,r->cf);
4007  p_SetCoeff(m,nu1,r);
4008  }
4009  res=p_Add_q(res,m,r);
4010  }
4011  p_LmDelete(&h,r);
4012  }
4013  omFreeSize((ADDRESS)me,(rVar(r)+1)*sizeof(int));
4014  omFreeSize((ADDRESS)ee,(rVar(r)+1)*sizeof(int));
4015  return res;
4016 }
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:3211
static poly p_Subst0(poly p, int n, const ring r)
Definition: p_polys.cc:3929
static poly p_Subst1(poly p, int n, const ring r)
Definition: p_polys.cc:3861
static poly p_Subst2(poly p, int n, number e, const ring r)
Definition: p_polys.cc:3888
poly p_LPSubst(poly p, int n, poly e, const ring r)
Definition: shiftop.cc:912

◆ p_TakeOutComp() [1/2]

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

Definition at line 3431 of file p_polys.cc.

3432 {
3433  poly q = *p,qq=NULL,result = NULL;
3434 
3435  if (q==NULL) return NULL;
3436  BOOLEAN use_setmcomp=rOrd_SetCompRequiresSetm(r);
3437  if (__p_GetComp(q,r)==k)
3438  {
3439  result = q;
3440  do
3441  {
3442  p_SetComp(q,0,r);
3443  if (use_setmcomp) p_SetmComp(q,r);
3444  qq = q;
3445  pIter(q);
3446  }
3447  while ((q!=NULL) && (__p_GetComp(q,r)==k));
3448  *p = q;
3449  pNext(qq) = NULL;
3450  }
3451  if (q==NULL) return result;
3452  if (__p_GetComp(q,r) > k)
3453  {
3454  p_SubComp(q,1,r);
3455  if (use_setmcomp) p_SetmComp(q,r);
3456  }
3457  poly pNext_q;
3458  while ((pNext_q=pNext(q))!=NULL)
3459  {
3460  if (__p_GetComp(pNext_q,r)==k)
3461  {
3462  if (result==NULL)
3463  {
3464  result = pNext_q;
3465  qq = result;
3466  }
3467  else
3468  {
3469  pNext(qq) = pNext_q;
3470  pIter(qq);
3471  }
3472  pNext(q) = pNext(pNext_q);
3473  pNext(qq) =NULL;
3474  p_SetComp(qq,0,r);
3475  if (use_setmcomp) p_SetmComp(qq,r);
3476  }
3477  else
3478  {
3479  /*pIter(q);*/ q=pNext_q;
3480  if (__p_GetComp(q,r) > k)
3481  {
3482  p_SubComp(q,1,r);
3483  if (use_setmcomp) p_SetmComp(q,r);
3484  }
3485  }
3486  }
3487  return result;
3488 }

◆ p_TakeOutComp() [2/2]

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

Splits *p into two polys: *q which consists of all monoms with component == comp and *p of all other monoms *lq == pLength(*q) On return all components pf *q == 0.

Definition at line 3492 of file p_polys.cc.

3493 {
3494  spolyrec pp, qq;
3495  poly p, q, p_prev;
3496  int l = 0;
3497 
3498 #ifndef SING_NDEBUG
3499  int lp = pLength(*r_p);
3500 #endif
3501 
3502  pNext(&pp) = *r_p;
3503  p = *r_p;
3504  p_prev = &pp;
3505  q = &qq;
3506 
3507  while(p != NULL)
3508  {
3509  while (__p_GetComp(p,r) == comp)
3510  {
3511  pNext(q) = p;
3512  pIter(q);
3513  p_SetComp(p, 0,r);
3514  p_SetmComp(p,r);
3515  pIter(p);
3516  l++;
3517  if (p == NULL)
3518  {
3519  pNext(p_prev) = NULL;
3520  goto Finish;
3521  }
3522  }
3523  pNext(p_prev) = p;
3524  p_prev = p;
3525  pIter(p);
3526  }
3527 
3528  Finish:
3529  pNext(q) = NULL;
3530  *r_p = pNext(&pp);
3531  *r_q = pNext(&qq);
3532  *lq = l;
3533 #ifndef SING_NDEBUG
3534  assume(pLength(*r_p) + pLength(*r_q) == (unsigned)lp);
3535 #endif
3536  p_Test(*r_p,r);
3537  p_Test(*r_q,r);
3538 }

◆ p_Totaldegree()

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

Definition at line 1505 of file p_polys.h.

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

◆ p_Var()

int p_Var ( poly  mi,
const ring  r 
)

Definition at line 4652 of file p_polys.cc.

4653 {
4654  if (m==NULL) return 0;
4655  if (pNext(m)!=NULL) return 0;
4656  int i,e=0;
4657  for (i=rVar(r); i>0; i--)
4658  {
4659  int exp=p_GetExp(m,i,r);
4660  if (exp==1)
4661  {
4662  if (e==0) e=i;
4663  else return 0;
4664  }
4665  else if (exp!=0)
4666  {
4667  return 0;
4668  }
4669  }
4670  return e;
4671 }

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

3592 {
3593  poly h;
3594  int k;
3595 
3596  for(int i=len-1;i>=0;i--) p[i]=NULL;
3597  while (v!=NULL)
3598  {
3599  h=p_Head(v,r);
3600  k=__p_GetComp(h,r);
3601  if (k>len) { Werror("wrong rank:%d, should be %d",len,k); }
3602  else
3603  {
3604  p_SetComp(h,0,r);
3605  p_Setm(h,r);
3606  pNext(h)=p[k-1];p[k-1]=h;
3607  }
3608  pIter(v);
3609  }
3610  for(int i=len-1;i>=0;i--)
3611  {
3612  if (p[i]!=NULL) p[i]=pReverse(p[i]);
3613  }
3614 }

◆ p_Vec2Poly()

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

Definition at line 3569 of file p_polys.cc.

3570 {
3571  poly h;
3572  poly res=NULL;
3573  long unsigned kk=k;
3574 
3575  while (v!=NULL)
3576  {
3577  if (__p_GetComp(v,r)==kk)
3578  {
3579  h=p_Head(v,r);
3580  p_SetComp(h,0,r);
3581  pNext(h)=res;res=h;
3582  }
3583  pIter(v);
3584  }
3585  if (res!=NULL) res=pReverse(res);
3586  return res;
3587 }

◆ p_Vec2Polys()

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

Definition at line 3621 of file p_polys.cc.

3622 {
3623  *len=p_MaxComp(v,r);
3624  if (*len==0) *len=1;
3625  *p=(poly*)omAlloc((*len)*sizeof(poly));
3626  p_Vec2Array(v,*p,*len,r);
3627 }
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:3591

◆ p_VectorHasUnit()

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

Definition at line 3398 of file p_polys.cc.

3399 {
3400  poly q=p,qq;
3401  int j=0;
3402  long unsigned i;
3403 
3404  *len = 0;
3405  while (q!=NULL)
3406  {
3407  if (p_LmIsConstantComp(q,r))
3408  {
3409  i = __p_GetComp(q,r);
3410  qq = p;
3411  while ((qq != q) && (__p_GetComp(qq,r) != i)) pIter(qq);
3412  if (qq == q)
3413  {
3414  j = 0;
3415  while (qq!=NULL)
3416  {
3417  if (__p_GetComp(qq,r)==i) j++;
3418  pIter(qq);
3419  }
3420  if ((*len == 0) || (j<*len))
3421  {
3422  *len = j;
3423  *k = i;
3424  }
3425  }
3426  }
3427  pIter(q);
3428  }
3429 }

◆ p_VectorHasUnitB()

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

Definition at line 3375 of file p_polys.cc.

3376 {
3377  poly q=p,qq;
3378  long unsigned i;
3379 
3380  while (q!=NULL)
3381  {
3382  if (p_LmIsConstantComp(q,r))
3383  {
3384  i = __p_GetComp(q,r);
3385  qq = p;
3386  while ((qq != q) && (__p_GetComp(qq,r) != i)) pIter(qq);
3387  if (qq == q)
3388  {
3389  *k = i;
3390  return TRUE;
3391  }
3392  }
3393  pIter(q);
3394  }
3395  return FALSE;
3396 }

◆ p_WDegree()

long p_WDegree ( poly  p,
const ring  r 
)

Definition at line 714 of file p_polys.cc.

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

◆ p_Weight()

int p_Weight ( int  c,
const ring  r 
)

Definition at line 705 of file p_polys.cc.

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

◆ p_WFirstTotalDegree()

long p_WFirstTotalDegree ( poly  p,
ring  r 
)

Definition at line 596 of file p_polys.cc.

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

◆ p_Write() [1/2]

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

Definition at line 342 of file polys0.cc.

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

◆ p_Write() [2/2]

static void p_Write ( poly  p,
ring  p_ring 
)
inlinestatic

Definition at line 1246 of file p_polys.h.

1247 {
1248  p_Write(p, p_ring, p_ring);
1249 }

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

1251 {
1252  p_Write0(p, p_ring, p_ring);
1253 }
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 1254 of file p_polys.h.

1255 {
1256  p_wrp(p, p_ring, p_ring);
1257 }
void p_wrp(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:373

◆ p_WTotaldegree()

long p_WTotaldegree ( poly  p,
const ring  r 
)

Definition at line 613 of file p_polys.cc.

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

3693 {
3694  poly* h;
3695 
3696  if (increment==0) return;
3697  if (*p==NULL)
3698  {
3699  h=(poly*)omAlloc0(increment*sizeof(poly));
3700  }
3701  else
3702  {
3703  h=(poly*)omReallocSize((poly*)*p,l*sizeof(poly),(l+increment)*sizeof(poly));
3704  if (increment>0)
3705  {
3706  memset(&(h[l]),0,increment*sizeof(poly));
3707  }
3708  }
3709  *p=h;
3710 }
#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 739 of file p_polys.cc.

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

◆ pLDeg0c()

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

Definition at line 770 of file p_polys.cc.

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

◆ pLDeg1()

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

Definition at line 841 of file p_polys.cc.

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

◆ pLDeg1_Deg()

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

Definition at line 910 of file p_polys.cc.

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

◆ pLDeg1_Totaldegree()

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

Definition at line 975 of file p_polys.cc.

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

◆ pLDeg1_WFirstTotalDegree()

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

Definition at line 1038 of file p_polys.cc.

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

◆ pLDeg1c()

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

Definition at line 877 of file p_polys.cc.

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

◆ pLDeg1c_Deg()

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

Definition at line 941 of file p_polys.cc.

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

◆ pLDeg1c_Totaldegree()

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

Definition at line 1005 of file p_polys.cc.

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

◆ pLDeg1c_WFirstTotalDegree()

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

Definition at line 1068 of file p_polys.cc.

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

◆ pLDegb()

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

Definition at line 811 of file p_polys.cc.

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

◆ pLength()

static int pLength ( poly  a)
inlinestatic

Definition at line 188 of file p_polys.h.

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

◆ pp_DivideM()

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

Definition at line 1629 of file p_polys.cc.

1630 {
1631  if (a==NULL) { return NULL; }
1632  // TODO: better implementation without copying a,b
1633  return p_DivideM(p_Copy(a,r),p_Head(b,r),r);
1634 }
poly p_DivideM(poly a, poly b, const ring r)
Definition: p_polys.cc:1574

◆ pp_Jet()

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

Definition at line 4354 of file p_polys.cc.

4355 {
4356  poly r=NULL;
4357  poly t=NULL;
4358 
4359  while (p!=NULL)
4360  {
4361  if (p_Totaldegree(p,R)<=m)
4362  {
4363  if (r==NULL)
4364  r=p_Head(p,R);
4365  else
4366  if (t==NULL)
4367  {
4368  pNext(r)=p_Head(p,R);
4369  t=pNext(r);
4370  }
4371  else
4372  {
4373  pNext(t)=p_Head(p,R);
4374  pIter(t);
4375  }
4376  }
4377  pIter(p);
4378  }
4379  return r;
4380 }

◆ pp_JetW()

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

Definition at line 4399 of file p_polys.cc.

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

◆ pp_mm_Mult()

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

Definition at line 1039 of file p_polys.h.

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

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

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

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

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

◆ pp_Mult_mm()

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

Definition at line 1029 of file p_polys.h.

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

◆ pp_Mult_nn()

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

Definition at line 990 of file p_polys.h.

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

◆ pp_Mult_qq()

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

Definition at line 1149 of file p_polys.h.

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

3646 {
3647  assume(old_FDeg != NULL && old_lDeg != NULL);
3648  r->pFDeg = old_FDeg;
3649  r->pLDeg = old_lDeg;
3650 }

◆ pReverse()

static poly pReverse ( poly  p)
inlinestatic

Definition at line 333 of file p_polys.h.

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

◆ pSetDegProcs()

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

Definition at line 3633 of file p_polys.cc.

3634 {
3635  assume(new_FDeg != NULL);
3636  r->pFDeg = new_FDeg;
3637 
3638  if (new_lDeg == NULL)
3639  new_lDeg = r->pLDegOrig;
3640 
3641  r->pLDeg = new_lDeg;
3642 }