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 
)    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 
)    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)
p
int p
Definition: cfModGcd.cc:4078
p_MemCmp_LengthGeneral_OrdGeneral
#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,
  r 
)    p_ExpVectorEqual(p1, p2, r)

Definition at line 1721 of file p_polys.h.

◆ p_LmTest

#define p_LmTest (   p,
  r 
)    _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,
  r 
)    _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}
FALSE
#define FALSE
Definition: auxiliary.h:96
b
CanonicalForm b
Definition: cfModGcd.cc:4103
p_GetComp
#define p_GetComp(p, r)
Definition: monomials.h:64
_p_LmDivisibleByNoComp
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}
TRUE
#define TRUE
Definition: auxiliary.h:100
i
int i
Definition: cfEzgcd.cc:132
pAssume1
#define pAssume1(cond)
Definition: monomials.h:171
p_GetExp
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 {
1779 pDivAssume(p_DebugLmDivisibleByNoComp(a, b, r) == FALSE);
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 {
1795 pDivAssume(p_DebugLmDivisibleByNoComp(a, b, r) == FALSE);
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*/
1807 pDivAssume(p_DebugLmDivisibleByNoComp(a, b, r) == TRUE);
1808 return TRUE;
1809//#endif
1810}
p_DebugLmDivisibleByNoComp
BOOLEAN p_DebugLmDivisibleByNoComp(poly a, poly b, ring r)
Definition: pDebug.cc:141
pDivAssume
#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}
_p_LmDivisibleByNoCompPart
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}
BOOLEAN
int BOOLEAN
Definition: auxiliary.h:87
level
int level(const CanonicalForm &f)
Definition: canonicalform.h:331
pNext
#define pNext(p)
Definition: monomials.h:36
NULL
#define NULL
Definition: omList.c:12
_p_Test
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
324 pqLengthApprox(p, q, lp, lq, MIN_LENGTH_FACTORY);
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
385 if (lq < MIN_LENGTH_BUCKET || TEST_OPT_NOT_BUCKETS)
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}
l
int l
Definition: cfEzgcd.cc:100
singclap_pmult
poly singclap_pmult(poly f, poly g, const ring r)
Definition: clapsing.cc:577
nCoeff_is_Domain
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
res
CanonicalForm res
Definition: facAbsFact.cc:60
copy
CFArray copy(const CFList &list)
write elements of list into an array
Definition: facFqBivarUtil.cc:364
h
STATIC_VAR Poly * h
Definition: janet.cc:971
assume
#define assume(x)
Definition: mod2.h:389
lq
Definition: lq.h:40
ndConvSingNFactoryN
CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition: numbers.cc:313
TEST_OPT_NOT_BUCKETS
#define TEST_OPT_NOT_BUCKETS
Definition: options.h:106
pqLengthApprox
static void pqLengthApprox(poly p, poly q, int &lp, int &lq, const int min)
Definition: p_Mult_q.cc:69
MIN_LENGTH_FACTORY
#define MIN_LENGTH_FACTORY
Definition: p_Mult_q.cc:304
MIN_FLINT_Z
#define MIN_FLINT_Z
Definition: p_Mult_q.cc:308
MIN_FLINT_QQ
#define MIN_FLINT_QQ
Definition: p_Mult_q.cc:306
_p_Mult_q_Normal
static poly _p_Mult_q_Normal(poly p, poly q, const int copy, const ring r)
Definition: p_Mult_q.cc:223
MIN_LENGTH_FACTORY_QQ
#define MIN_LENGTH_FACTORY_QQ
Definition: p_Mult_q.cc:305
_p_Mult_q_Bucket
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
_p_Mult_q_Normal_ZeroDiv
static poly _p_Mult_q_Normal_ZeroDiv(poly p, poly q, const int copy, const ring r)
Definition: p_Mult_q.cc:195
MIN_FLINT_Zp
#define MIN_FLINT_Zp
Definition: p_Mult_q.cc:307
MIN_LENGTH_BUCKET
#define MIN_LENGTH_BUCKET
Definition: p_Mult_q.h:21
pLength
static int pLength(poly a)
Definition: p_polys.h:188
p_Delete
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:899
rField_is_Z
static BOOLEAN rField_is_Z(const ring r)
Definition: ring.h:509
rField_is_Zp
static BOOLEAN rField_is_Zp(const ring r)
Definition: ring.h:500
rField_is_Q
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
229 pFalseReturn(p_CheckRing(r));
230
231 // this checks that p does not contain a loop: rather expensive O(length^2)
232 #ifndef OM_NDEBUG
233 if (level > 1)
234 pFalseReturn(omTestList(p, level) == omError_NoError);
235 #endif
236
237 int ismod = p_GetComp(p, r) != 0;
238
239 while (p != NULL)
240 {
241 // ring check
242 pFalseReturn(p_LmCheckIsFromRing(p, r));
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}
PDEBUG
#define PDEBUG
Definition: auxiliary.h:170
n_Test
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
Definition: coeffs.h:709
n_IsZero
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
Definition: coeffs.h:461
n_GetChar
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:441
pFalseReturn
#define pFalseReturn(cond)
Definition: monomials.h:139
pIter
#define pIter(p)
Definition: monomials.h:37
_pPolyAssumeReturnMsg
#define _pPolyAssumeReturnMsg(cond, msg, p, r)
Definition: monomials.h:124
omSizeWOfBin
#define omSizeWOfBin(bin_ptr)
Definition: omAllocPrivate.h:100
omError_NoError
@ omError_NoError
Definition: omError.h:18
omTestList
#define omTestList(ptr, level)
Definition: omList.h:81
p_DebugInit
static poly p_DebugInit(poly p, ring src_ring, ring dest_ring)
Definition: pDebug.cc:195
dPolyReportError
BOOLEAN dPolyReportError(poly p, ring r, const char *fmt,...)
Definition: pDebug.cc:42
p_CheckRing
BOOLEAN p_CheckRing(ring r)
Definition: pDebug.cc:128
p_LmCheckIsFromRing
BOOLEAN p_LmCheckIsFromRing(poly p, ring r)
Definition: pDebug.cc:71
p_ExpVectorEqual
static BOOLEAN p_ExpVectorEqual(poly p1, poly p2, const ring r1, const ring r2)
Definition: p_polys.cc:4522
p_LmCmp
static int p_LmCmp(poly p, poly q, const ring r)
Definition: p_polys.h:1578
p_LmFree
static void p_LmFree(poly p, ring)
Definition: p_polys.h:681
ro_syzcomp
@ ro_syzcomp
Definition: ring.h:59
sro_ord::data
union sro_ord::@1 data
sro_ord
Definition: ring.h:219
omTestBinAddrSize
#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}
_p_LmTest
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}
ADDRESS
void * ADDRESS
Definition: auxiliary.h:119
si_min
static int si_min(const int a, const int b)
Definition: auxiliary.h:125
n_Copy
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
Definition: coeffs.h:448
nCoeff_is_GF
static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
Definition: coeffs.h:836
n_SetMap
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
n_Delete
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:452
n_Write
static FORCE_INLINE void n_Write(number n, const coeffs r, const BOOLEAN bShortOut=TRUE)
Definition: coeffs.h:588
nCoeff_is_algExt
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
Definition: coeffs.h:907
nMapFunc
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:73
nCoeff_is_transExt
static FORCE_INLINE BOOLEAN nCoeff_is_transExt(const coeffs r)
TRUE iff r represents a transcendental extension field.
Definition: coeffs.h:915
WarnS
#define WarnS
Definition: emacs.cc:78
WerrorS
void WerrorS(const char *s)
Definition: feFopen.cc:24
pGetCoeff
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
coeffs
The main handler for Singular numbers which are suitable for Singular polynomials.
omFreeSize
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
omAlloc0
#define omAlloc0(size)
Definition: omAllocDecl.h:211
p_PermPoly
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
p_Div_nn
poly p_Div_nn(poly p, const number n, const ring r)
Definition: p_polys.cc:1501
p_Normalize
void p_Normalize(poly p, const ring r)
Definition: p_polys.cc:3809
p_IsConstant
static BOOLEAN p_IsConstant(const poly p, const ring r)
Definition: p_polys.h:1962
p_Test
#define p_Test(p, r)
Definition: p_polys.h:159
NUM
@ NUM
Definition: readcf.cc:170
PrintS
void PrintS(const char *s)
Definition: reporter.cc:284
rWrite
void rWrite(ring r, BOOLEAN details)
Definition: ring.cc:226
rPar
static int rPar(const ring r)
(r->cf->P)
Definition: ring.h:599
rVar
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);
448 pAssume2(rRing_has_Comp(r));
449 return __p_GetComp(p,r) += v;
450}
v
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:39
p_LmCheckPolyRing2
#define p_LmCheckPolyRing2(p, r)
Definition: monomials.h:199
pAssume2
#define pAssume2(cond)
Definition: monomials.h:193
__p_GetComp
#define __p_GetComp(p, r)
Definition: monomials.h:63
rRing_has_Comp
#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}
p_SetExp
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 {
106 pFalseReturn(p_LmCheckIsFromRing(p, r));
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}
pAssumeReturn
#define pAssumeReturn(cond)
Definition: monomials.h:78
p_CheckIsFromRing
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}
x
Variable x
Definition: cfModGcd.cc:4082
n_ChineseRemainderSym
static FORCE_INLINE number n_ChineseRemainderSym(number *a, number *b, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs r)
Definition: coeffs.h:761
n_Init
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
j
int j
Definition: facHensel.cc:110
p_SetCoeff
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:410
pReverse
static poly pReverse(poly p)
Definition: p_polys.h:333
p_Head
static poly p_Head(const poly p, const ring r)
copy the (leading) term of p
Definition: p_polys.h:858
p_LmFreeAndNext
static poly p_LmFreeAndNext(poly p, ring)
Definition: p_polys.h:709
R
#define R
Definition: sirandom.c:27
loop
#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
2871 if (rField_is_Zp(r) && TEST_OPT_INTSTRATEGY)
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);
2913 d=n_NormalizeHelper(h,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}
CPolyCoeffsEnumerator
This is a polynomial enumerator for simple iteration over coefficients of polynomials.
Definition: PolyEnumerator.h:130
n_Mult
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
n_NormalizeHelper
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
n_GreaterZero
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
nCoeff_is_Q
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
Definition: coeffs.h:803
n_ClearDenominators
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
nCoeff_is_Q_a
static FORCE_INLINE BOOLEAN nCoeff_is_Q_a(const coeffs r)
Definition: coeffs.h:882
n_ClearContent
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
n_Normalize
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
n_IsOne
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition: coeffs.h:465
TEST_OPT_INTSTRATEGY
#define TEST_OPT_INTSTRATEGY
Definition: options.h:111
TEST_OPT_CONTENTSB
#define TEST_OPT_CONTENTSB
Definition: options.h:128
p_ContentRat
void p_ContentRat(poly &ph, const ring r)
Definition: p_polys.cc:1740
p_ContentForGB
void p_ContentForGB(poly ph, const ring r)
Definition: p_polys.cc:2351
p_Neg
static poly p_Neg(poly p, const ring r)
Definition: p_polys.h:1105
rIsRatGRing
static BOOLEAN rIsRatGRing(const ring r)
Definition: ring.h:427
rField_is_Ring
#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);
3049 d=n_NormalizeHelper(h,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 {
3085 d=n_NormalizeHelper(h,pGetCoeff(p),C);
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}
n_Invers
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
n_InpNeg
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
n_Div
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
rField_is_Q_a
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}
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: 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}
N
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:56
k
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}
n_Sub
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
p_Cmp
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}
n_DivBy
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
n_Equal
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
pAssume
#define pAssume(cond)
Definition: monomials.h:90
p_LmEqual
#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 {
2325 n_Normalize(pGetCoeff(p),cf);
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 }
2343content_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}
cf
CanonicalForm cf
Definition: cfModGcd.cc:4083
n_ExactDiv
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
n_SubringGcd
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
Definition: coeffs.h:663
ndGcd
number ndGcd(number, number, const coeffs r)
Definition: numbers.cc:189
p_InitContent
number p_InitContent(poly ph, const ring r)
Definition: p_polys.cc:2631
rField_is_Zp_a
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
@ 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
@ n_transExt
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
Definition: coeffs.h:38
n_GetUnit
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
getCoeffType
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
rField_has_Units
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
1842cleanup:
1843 omFree(C);
1844 omFree(LM);
1845 omFree(D);
1846 omFree(L);
1847}
singclap_pdivide
poly singclap_pdivide(poly f, poly g, const ring r)
Definition: clapsing.cc:624
D
#define D(A)
Definition: gentable.cc:131
omFree
#define omFree(addr)
Definition: omAllocDecl.h:261
p_LmDeleteAndNextRat
void p_LmDeleteAndNextRat(poly *p, int ishift, ring r)
Definition: p_polys.cc:1696
p_GetCoeffRat
poly p_GetCoeffRat(poly p, int ishift, ring r)
Definition: p_polys.cc:1718
p_Add_q
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:934
p_Mult_q
static poly p_Mult_q(poly p, poly q, const ring r)
Definition: p_polys.h:1112
p_GetExp_k_n
static poly p_GetExp_k_n(poly p, int l, int k, const ring r)
Definition: p_polys.h:1370
p_Copy
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition: p_polys.h:844
p_Totaldegree
static long p_Totaldegree(poly p, const ring r)
Definition: p_polys.h:1505
singclap_gcd
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}
p_Copy_noCheck
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}
pp
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}
p_CopyPowerProduct0
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}
p_LmCheckPolyRing1
#define p_LmCheckPolyRing1(p, r)
Definition: monomials.h:177
pSetCoeff0
#define pSetCoeff0(p, n)
Definition: monomials.h:59
p_SetRingOfLm
#define p_SetRingOfLm(p, r)
Definition: monomials.h:144
omTypeAllocBin
#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}
p_LmCheckPolyRing
BOOLEAN p_LmCheckPolyRing(poly p, ring r)
Definition: pDebug.cc:120
p_GetOrder
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}
w
const CanonicalForm & w
Definition: facAbsFact.cc:51
totaldegreeWecart_IV
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}
p_LmDelete
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}
p_SubComp
static unsigned long p_SubComp(poly p, unsigned long v, ring r)
Definition: p_polys.h:451
p_SetmComp
#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}
f
FILE * f
Definition: checklibs.c:9
last
STATIC_VAR poly last
Definition: hdegree.cc:1173
p_LmInit
static poly p_LmInit(poly p, const ring r)
Definition: p_polys.h:1333
p_Setm
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:231
p_DecrExp
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}
result
return result
Definition: facAbsBiFact.cc:75
p_DiffOpM
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}
m
int m
Definition: cfEzgcd.cc:128
p_ExpVectorSub
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}
p_DivisibleBy
static BOOLEAN p_DivisibleBy(poly a, poly b, const ring r)
Definition: p_polys.h:1898
__p_Mult_nn
#define __p_Mult_nn(p, n, r)
Definition: p_polys.h:969
rIsNCRing
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{
1900 pIfThen1(b!=NULL, p_LmCheckPolyRing1(b, r));
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}
pIfThen1
#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
g
Definition: cfModGcd.cc:4090
exponent
int exponent(const CanonicalForm &f, int q)
int exponent ( const CanonicalForm & f, int q )
Definition: gengftables-conway.cc:93

◆ 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}
p_GetCoeff
#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}
rSamePolyRep
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}
p_MemAdd_LengthGeneral
#define p_MemAdd_LengthGeneral(r, s, length)
Definition: p_MemAdd.h:173
p_MemAdd_NegWeightAdjust
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}
p_MemAddSub_LengthGeneral
#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}
p_MemDiff_LengthGeneral
#define p_MemDiff_LengthGeneral(r, s1, s2, length)
Definition: p_MemAdd.h:262
p_MemSub_NegWeightAdjust
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}
p_MemSub_LengthGeneral
#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}
p_MemSum_LengthGeneral
#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}
n_Farey
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}
G
STATIC_VAR TreeM * G
Definition: janet.cc:31
omAlloc
#define omAlloc(size)
Definition: omAllocDecl.h:210
p_SetExpV
static void p_SetExpV(poly p, int *ev, const ring r)
Definition: p_polys.h:1542
p_GetExpV
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}
s
const CanonicalForm int s
Definition: facAbsFact.cc:51
p_Comp_k_n
static int p_Comp_k_n(poly a, poly b, int k, ring r)
Definition: p_polys.h:638
p_SetCompP
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}
exp
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}
int64
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}
p_GetMaxExp
static unsigned long p_GetMaxExp(const unsigned long l, const ring r)
Definition: p_polys.h:779
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: 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}
max
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}
p_GetMaxExpL2
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}
offset
STATIC_VAR int offset
Definition: janet.cc:29
p_CheckPolyRing
BOOLEAN p_CheckPolyRing(poly p, ring r)
Definition: pDebug.cc:112
p_Init
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}
POLY_NEGWEIGHT_OFFSET
#define POLY_NEGWEIGHT_OFFSET
Definition: monomials.h:236
ro_syz
@ ro_syz
Definition: ring.h:60
ro_cp
@ ro_cp
Definition: ring.h:58
ro_wp_neg
@ ro_wp_neg
Definition: ring.h:56
ro_am
@ 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)
577 return p_Setm_WFirstTotalDegree;
578 }
579 return p_Setm_General;
580}
p_Setm_WFirstTotalDegree
void p_Setm_WFirstTotalDegree(poly p, const ring r)
Definition: p_polys.cc:554
p_Setm_Dummy
void p_Setm_Dummy(poly p, const ring r)
Definition: p_polys.cc:541
p_Setm_TotalDegree
void p_Setm_TotalDegree(poly p, const ring r)
Definition: p_polys.cc:547
p_Setm_General
void p_Setm_General(poly p, const ring r)
Definition: p_polys.cc:158
ro_dp
@ ro_dp
Definition: ring.h:52
ro_wp
@ 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}
BIT_SIZEOF_LONG
#define BIT_SIZEOF_LONG
Definition: auxiliary.h:80
GetBitFields
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}
p_AddExp
static long p_AddExp(poly p, int v, long ee, ring r)
Definition: p_polys.h:604
pFDegProc
long(* pFDegProc)(poly p, ring r)
Definition: ring.h:38
ringorder_lp
@ ringorder_lp
Definition: ring.h:77
sBucket_Add_m
void sBucket_Add_m(sBucket_pt bucket, poly p)
Definition: sbuckets.cc:173
sBucketCreate
sBucket_pt sBucketCreate(const ring r)
Definition: sbuckets.cc:96
sBucketDestroyAdd
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);
1324 p_MemAdd_NegWeightAdjust(p, r);
1325 p_SetRingOfLm(p, r);
1326 return p;
1327}
p_CheckRing1
#define p_CheckRing1(r)
Definition: monomials.h:178
omTypeAlloc0Bin
#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{
2635 assume(!TEST_OPT_CONTENTSB);
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}
n_Size
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
n_GetNumerator
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
nlAdd
LINLINE number nlAdd(number la, number li, const coeffs r)
Definition: longrat.cc:2701
nlSub
LINLINE number nlSub(number la, number li, const coeffs r)
Definition: longrat.cc:2767
nlDelete
LINLINE void nlDelete(number *a, const coeffs r)
Definition: longrat.cc:2666
nlGreaterZero
BOOLEAN nlGreaterZero(number za, const coeffs r)
Definition: longrat.cc:1308
nlGcd
number nlGcd(number a, number b, const coeffs r)
Definition: longrat.cc:1345
nlNormalize
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}
p_LmIsConstant
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}
p_LmIsConstantComp
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}
n_IsUnit
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}
next
ListNode * next
Definition: janet.h:31
rGetCurrSyzLimit
static int rGetCurrSyzLimit(const ring r)
Definition: ring.h:723
rIsSyzIndexRing
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}
p_Lcm
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}
si_max
static int si_max(const int a, const int b)
Definition: auxiliary.h:124
p_SetComp
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 {
92 _pPolyAssumeReturn(omIsBinPageAddr(p),p,r);
93 _pPolyAssumeReturn(omSizeWOfAddr(p)==omSizeWOfBin(r->PolyBin),p,r);
94 return TRUE;
95 }
96 return FALSE;
97 #endif
98 }
99 return TRUE;
100}
pPolyAssumeReturnMsg
#define pPolyAssumeReturnMsg(cond, msg)
Definition: monomials.h:137
_pPolyAssumeReturn
#define _pPolyAssumeReturn(cond, p, r)
Definition: monomials.h:101
omIsBinPageAddr
#define omIsBinPageAddr(addr)
Definition: omBinPage.h:68
omSizeWOfAddr
#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
if(!FE_OPT_NO_SHELL_FLAG)(void) system(sys)
REGISTER
#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}
omFreeBin
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
omFreeBinAddr
#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}
p_CheckRing
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}
p_New
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 {
1919 pAssume1(p_LmDivisibleByNoComp(a, b, r) == FALSE);
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}
_pPolyAssume2
#define _pPolyAssume2(cond, p, r)
Definition: monomials.h:195
p_LmDivisibleByNoComp
static BOOLEAN p_LmDivisibleByNoComp(poly a, poly b, const ring r)
Definition: p_polys.h:1875
p_LmDivisibleBy
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
Definition: p_polys.h:1889
p_GetShortExpVector
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 {
1939 pAssume1(p_LmDivisibleByNoComp(a, b, r) == FALSE);
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}
n_Greater
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}
p_LtCmp
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);}
p_MaxComp
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);}
p_MinComp
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 {
1450 errorreported=TRUE;
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}
errorreported
VAR short errorreported
Definition: feFopen.cc:23
p_Read
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}
p_Mult_nn
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}
_nc_p_Mult_q
poly _nc_p_Mult_q(poly p, poly q, const ring r)
general NC-multiplication with destruction
Definition: old.gring.cc:215
_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,...
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}
p_CheckRing2
#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}
UNLIKELY
#define UNLIKELY(X)
Definition: auxiliary.h:404
LIKELY
#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
3818 n_Normalize(pGetCoeff(p),cf);
3819 pIter(p);
3820 }
3821}
ndNormalize
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}
n_Param
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
nCoeff_is_Extension
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
Definition: coeffs.h:843
ndCopyMap
number ndCopyMap(number a, const coeffs src, const coeffs dst)
Definition: numbers.cc:291
n_Power
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
n_PermNumber
poly n_PermNumber(const number z, const int *par_perm, const int, const ring src, const ring dst)
Definition: p_polys.cc:4023
p_ISet
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
Definition: p_polys.cc:1297
p_One
poly p_One(const ring r)
Definition: p_polys.cc:1313
p_Write
void p_Write(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:342
p_Mult_mm
static poly p_Mult_mm(poly p, poly m, const ring r)
Definition: p_polys.h:1049
p_SortAdd
static poly p_SortAdd(poly p, const ring r, BOOLEAN revert=FALSE)
Definition: p_polys.h:1217
rField_is_GF
static BOOLEAN rField_is_GF(const ring r)
Definition: ring.h:521
ntInit
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}
p_Plus_mm_Mult_qq
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}
nc_p_Plus_mm_Mult_qq
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
rIsPluralRing
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}
p_Deg
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}
p_Power
poly p_Power(poly p, int i, const ring r)
Definition: p_polys.cc:2193
p_TwoMonPower
static poly p_TwoMonPower(poly p, int exp, const ring r)
Definition: p_polys.cc:2102
p_Pow_charp
static poly p_Pow_charp(poly p, int i, const ring r)
Definition: p_polys.cc:2181
p_MonPower
static poly p_MonPower(poly p, int exp, const ring r)
Definition: p_polys.cc:1996
p_Pow
static poly p_Pow(poly p, int i, const ring r)
Definition: p_polys.cc:2167
Werror
void Werror(const char *fmt,...)
Definition: reporter.cc:189
rInternalChar
static int rInternalChar(const ring r)
Definition: ring.h:689
rIsLPRing
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
3157 if (nCoeff_is_Zp(C) && TEST_OPT_INTSTRATEGY)
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}
nCoeff_is_Ring
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
Definition: coeffs.h:727
nCoeff_is_Zp
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition: coeffs.h:797
p_Cleardenom
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 }
1414done:
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 }
1439finish:
1440 return s;
1441}
n_Read
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
eati
const char * eati(const char *s, int *i)
Definition: reporter.cc:373
rIsSCA
static bool rIsSCA(const ring r)
Definition: nc.h:190
p_IncrExp
static long p_IncrExp(poly p, int v, ring r)
Definition: p_polys.h:589
r_IsRingVar
int r_IsRingVar(const char *n, char **names, int N)
Definition: ring.cc:212
scaLastAltVar
static short scaLastAltVar(ring r)
Definition: sca.h:25
scaFirstAltVar
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}
p_Invers
static poly p_Invers(int n, poly u, intvec *w, const ring R)
Definition: p_polys.cc:4465
p_MinDeg
int p_MinDeg(poly p, intvec *w, const ring R)
Definition: p_polys.cc:4444
p_JetW
poly p_JetW(poly p, int m, int *w, const ring R)
Definition: p_polys.cc:4426
iv2array
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);
257 if (rOrd_SetCompRequiresSetm(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}
rOrd_SetCompRequiresSetm
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}
comp
int comp(const CanonicalForm &A, const CanonicalForm &B)
compare polynomials
Definition: facSparseHensel.h:25

◆ 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;
3683 pRestoreDegProcs(r,pOldFDeg, pOldLDeg);
3684 r->pLexOrder = pOldLexOrder;
3685 }
3686}
pOldLDeg
STATIC_VAR pLDegProc pOldLDeg
Definition: p_polys.cc:3657
pRestoreDegProcs
void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
Definition: p_polys.cc:3645
pOldLexOrder
STATIC_VAR BOOLEAN pOldLexOrder
Definition: p_polys.cc:3658
pOldFDeg
STATIC_VAR pFDegProc pOldFDeg
Definition: p_polys.cc:3656
pSetDegProcs
void pSetDegProcs(ring r, pFDegProc new_FDeg, pLDegProc new_lDeg)
Definition: p_polys.cc:3633
pModDeg
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
return
Definition: cfGcdAlgExt.cc:218
p_AddComp
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}
TEST_OPT_PROT
#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}
count
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}
sBucketSortAdd
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}
sBucketSortMerge
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}
p_String0
void p_String0(poly p, ring lmRing, ring tailRing)
print p according to ShortOut in lmRing & tailRing
Definition: polys0.cc:223
StringSetS
void StringSetS(const char *st)
Definition: reporter.cc:128
StringEndS
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}
p_String
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}
writemon
static void writemon(poly p, int ko, const ring r)
Definition: polys0.cc:24
writemonLP
static void writemonLP(poly p, int ko, const ring r)
Definition: polys0.cc:104
StringAppendS
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}
p_String0
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}
rShortOut
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}
rCanShortOut
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);
454 pAssume2(rRing_has_Comp(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}
subst
CanonicalForm subst(const CanonicalForm &f, const CFList &a, const CFList &b, const CanonicalForm &Rstar, bool isFunctionField)
Definition: facAlgFuncUtil.cc:120
nc_pSubst
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
p_Subst0
static poly p_Subst0(poly p, int n, const ring r)
Definition: p_polys.cc:3929
p_Subst1
static poly p_Subst1(poly p, int n, const ring r)
Definition: p_polys.cc:3861
p_Subst2
static poly p_Subst2(poly p, int n, number e, const ring r)
Definition: p_polys.cc:3888
p_LPSubst
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}
p_GetTotalDegree
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}
p_Vec2Array
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}
p_Weight
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}
p_Write0
void p_Write0(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:332
PrintLn
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}
p_String
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}
p_Write0
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}
p_wrp
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
for(int i=0;i<=n;i++) degsf[i]
Definition: cfEzgcd.cc:72
ringorder_a
@ ringorder_a
Definition: ring.h:70
ringorder_am
@ ringorder_am
Definition: ring.h:88
ringorder_a64
@ ringorder_a64
for int64 weights
Definition: ring.h:71
ringorder_rs
@ ringorder_rs
opposite of ls
Definition: ring.h:92
ringorder_C
@ ringorder_C
Definition: ring.h:73
ringorder_S
@ ringorder_S
S?
Definition: ring.h:75
ringorder_ds
@ ringorder_ds
Definition: ring.h:84
ringorder_Dp
@ ringorder_Dp
Definition: ring.h:80
ringorder_unspec
@ ringorder_unspec
Definition: ring.h:94
ringorder_L
@ ringorder_L
Definition: ring.h:89
ringorder_Ds
@ ringorder_Ds
Definition: ring.h:85
ringorder_dp
@ ringorder_dp
Definition: ring.h:78
ringorder_c
@ ringorder_c
Definition: ring.h:72
ringorder_rp
@ ringorder_rp
Definition: ring.h:79
ringorder_aa
@ ringorder_aa
for idElimination, like a, except pFDeg, pWeigths ignore it
Definition: ring.h:91
ringorder_no
@ ringorder_no
Definition: ring.h:69
ringorder_Wp
@ ringorder_Wp
Definition: ring.h:82
ringorder_ws
@ ringorder_ws
Definition: ring.h:86
ringorder_Ws
@ ringorder_Ws
Definition: ring.h:87
ringorder_IS
@ ringorder_IS
Induced (Schreyer) ordering.
Definition: ring.h:93
ringorder_ls
@ ringorder_ls
Definition: ring.h:83
ringorder_s
@ ringorder_s
s?
Definition: ring.h:76
ringorder_wp
@ ringorder_wp
Definition: ring.h:81
ringorder_M
@ 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}
omReallocSize
#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}
pIsMonomOf
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
1045 max=p_WFirstTotalDegree(p, r);
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}
p_WFirstTotalDegree
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
1074 max=p_WFirstTotalDegree(p, r);
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}
p_DivideM
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}
__pp_Mult_nn
#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}
_nc_pp_Mult_qq
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}
Generated on Thu Apr 27 2023 08:16:02 for My Project by   doxygen 1.9.4 for Singular