Macros | Functions
p_polys.h File Reference
#include <omalloc/omalloc.h>
#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_LmCmpAction(p, q, r, actionE, actionG, actionS)
 
#define pDivAssume(x)   do {} while (0)
 
#define p_LmCmpAction(p, q, r, actionE, actionG, actionS)   _p_LmCmpAction(p, q, r, actionE, actionG, actionS)
 
#define p_LmEqual(p1, p2, r)   p_ExpVectorEqual(p1, p2, r)
 

Functions

poly p_Farey (poly p, number N, const ring r)
 
poly p_ChineseRemainder (poly *xx, number *x, number *q, int rl, CFArray &inv_cache, const ring R)
 
unsigned long p_GetShortExpVector (const poly a, const ring r)
 
unsigned long p_GetShortExpVector (const poly p, const poly pp, const ring r)
 p_GetShortExpVector of p * pp More...
 
BOOLEAN p_DivisibleByRingCase (poly f, poly g, const ring r)
 divisibility check over ground ring (which may contain zero divisors); TRUE iff LT(f) divides LT(g), i.e., LT(f)*c*m = LT(g), for some coefficient c and some monomial m; does not take components into account More...
 
poly p_One (const ring r)
 
int p_MinDeg (poly p, intvec *w, const ring R)
 
long p_DegW (poly p, const short *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)
 
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_Content (poly p, const ring r)
 
void p_SimpleContent (poly p, int s, const ring r)
 
poly p_Cleardenom (poly p, const ring r)
 
void p_Cleardenom_n (poly p, const ring r, number &c)
 
int p_Size (poly p, const ring r)
 
poly p_Homogen (poly p, int varnum, const ring r)
 
BOOLEAN p_IsHomogeneous (poly p, const ring r)
 
static void p_Setm (poly p, const ring r)
 
p_SetmProc p_GetSetmProc (const ring r)
 
poly p_Subst (poly p, int n, poly e, const ring r)
 
static unsigned long p_SetComp (poly p, unsigned long c, ring r)
 
static void p_SetCompP (poly p, int i, ring r)
 
static void p_SetCompP (poly p, int i, ring lmRing, ring tailRing)
 
static long p_MaxComp (poly p, ring lmRing, ring tailRing)
 
static long p_MaxComp (poly p, ring lmRing)
 
static long p_MinComp (poly p, ring lmRing, ring tailRing)
 
static long p_MinComp (poly p, ring lmRing)
 
static poly pReverse (poly p)
 
void pEnlargeSet (poly **p, int length, int increment)
 
void p_String0 (poly p, ring lmRing, ring tailRing)
 print p according to ShortOut in lmRing & tailRing More...
 
char * p_String (poly p, ring lmRing, ring tailRing)
 
void p_Write (poly p, ring lmRing, ring tailRing)
 
void p_Write0 (poly p, ring lmRing, ring tailRing)
 
void p_wrp (poly p, ring lmRing, ring tailRing)
 
void p_String0Short (const poly p, ring lmRing, ring tailRing)
 print p in a short way, if possible More...
 
void p_String0Long (const poly p, ring lmRing, ring tailRing)
 print p in a long way More...
 
static long p_FDeg (const poly p, const ring r)
 
static long p_LDeg (const poly p, int *l, const ring r)
 
long p_WFirstTotalDegree (poly p, ring r)
 
long p_WTotaldegree (poly p, const ring r)
 
long p_WDegree (poly p, const ring r)
 
long pLDeg0 (poly p, int *l, ring r)
 
long pLDeg0c (poly p, int *l, ring r)
 
long pLDegb (poly p, int *l, ring r)
 
long pLDeg1 (poly p, int *l, ring r)
 
long pLDeg1c (poly p, int *l, ring r)
 
long pLDeg1_Deg (poly p, int *l, ring r)
 
long pLDeg1c_Deg (poly p, int *l, ring r)
 
long pLDeg1_Totaldegree (poly p, int *l, ring r)
 
long pLDeg1c_Totaldegree (poly p, int *l, ring r)
 
long pLDeg1_WFirstTotalDegree (poly p, int *l, ring r)
 
long pLDeg1c_WFirstTotalDegree (poly p, int *l, ring r)
 
BOOLEAN p_EqualPolys (poly p1, poly p2, const ring r)
 
BOOLEAN p_EqualPolys (poly p1, poly p2, const ring r1, const ring r2)
 same as the usual p_EqualPolys for polys belonging to equal rings More...
 
long p_Deg (poly a, const ring r)
 
static number p_SetCoeff (poly p, number n, ring r)
 
static long p_GetOrder (poly p, ring r)
 
static unsigned long p_AddComp (poly p, unsigned long v, ring r)
 
static unsigned long p_SubComp (poly p, unsigned long v, ring r)
 
static long p_GetExp (const poly p, const unsigned long iBitmask, const int VarOffset)
 get a single variable exponent : 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 : 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_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 unsigned long p_GetTotalDegree (const unsigned long l, const ring r)
 
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 (poly p, const ring r)
 
static poly p_Copy (poly p, const ring lmRing, const ring tailRing)
 
static void p_Delete (poly *p, const ring r)
 
static void p_Delete (poly *p, const ring lmRing, const ring tailRing)
 
static poly p_ShallowCopyDelete (poly p, const ring r, omBin bin)
 
static poly p_Add_q (poly p, poly q, const ring r)
 
static poly p_Add_q (poly p, poly q, int &lp, int lq, const ring r)
 like p_Add_q, except that if lp == pLength(lp) lq == pLength(lq) then lp == pLength(p+q) 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 p_Mult_mm (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. 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_SetExpV (poly p, int *ev, const ring r)
 
static int p_LmCmp (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 BOOLEAN _p_LmDivisibleByNoComp (poly a, poly b, const ring r)
 return: FALSE, if there exists i, such that a->exp[i] > b->exp[i] TRUE, otherwise (1) Consider long vars, instead of single exponents (2) Clearly, if la > lb, then FALSE (3) Suppose la <= lb, and consider first bits of single exponents in l: if TRUE, then value of these bits is la ^ lb if FALSE, then la-lb causes an "overflow" into one of those bits, i.e., la ^ lb != la - lb More...
 
static BOOLEAN _p_LmDivisibleByNoComp (poly a, const ring r_a, poly b, const ring r_b)
 
static BOOLEAN _p_LmDivisibleByNoCompPart (poly a, const ring r_a, poly b, const ring r_b, const int start, const int end)
 
static BOOLEAN _p_LmDivisibleByPart (poly a, const ring r_a, poly b, const ring r_b, const int start, const int end)
 
static BOOLEAN p_LmDivisibleByPart (poly a, poly b, const ring r, const int start, const int end)
 
static BOOLEAN _p_LmDivisibleBy (poly a, poly b, const ring r)
 
static BOOLEAN _p_LmDivisibleBy (poly a, const ring r_a, poly b, const ring r_b)
 
static BOOLEAN p_LmDivisibleByNoComp (poly a, poly b, const ring r)
 
static BOOLEAN p_LmDivisibleByNoComp (poly a, const ring ra, poly b, const ring rb)
 
static BOOLEAN p_LmDivisibleBy (poly a, poly b, const ring r)
 
static BOOLEAN p_DivisibleBy (poly a, poly b, const ring r)
 
static BOOLEAN p_DivisibleBy (poly a, const ring r_a, poly b, const ring r_b)
 
static BOOLEAN p_LmDivisibleBy (poly a, const ring r_a, poly b, const ring r_b)
 
static BOOLEAN p_LmShortDivisibleBy (poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
 
static BOOLEAN p_LmShortDivisibleByNoComp (poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
 
static BOOLEAN p_LmShortDivisibleBy (poly a, unsigned long sev_a, const ring r_a, poly b, unsigned long not_sev_b, const ring r_b)
 
static BOOLEAN p_IsConstantComp (const poly p, const ring r)
 
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)
 
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_Divide (poly a, poly b, const ring r)
 
poly p_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_LcmRat (const poly a, const poly b, const long lCompM, const ring r)
 
poly p_GetCoeffRat (poly p, int ishift, ring r)
 
void p_LmDeleteAndNextRat (poly *p, int ishift, ring r)
 
void p_ContentRat (poly &ph, const ring r)
 
poly p_Diff (poly a, int k, const ring r)
 
poly p_DiffOp (poly a, poly b, BOOLEAN multiply, const ring r)
 
int p_Weight (int c, const ring r)
 
poly p_PolyDiv (poly &p, const poly divisor, const BOOLEAN needResult, const ring r)
 assumes that p and divisor are univariate polynomials in r, mentioning the same variable; assumes divisor != NULL; p may be NULL; assumes a global monomial ordering in r; performs polynomial division of p by divisor: More...
 
BOOLEAN p_VectorHasUnitB (poly p, int *k, const ring r)
 
void p_VectorHasUnit (poly p, int *k, int *len, const ring r)
 
poly p_TakeOutComp1 (poly *p, int k, const ring r)
 
void p_TakeOutComp (poly *p, long comp, poly *q, int *lq, const ring r)
 
poly p_TakeOutComp (poly *p, int k, const ring r)
 
void p_DeleteComp (poly *p, int k, const ring r)
 
void pSetDegProcs (ring r, pFDegProc new_FDeg, pLDegProc new_lDeg=NULL)
 
void pRestoreDegProcs (ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
 
void p_SetModDeg (intvec *w, ring r)
 
poly pp_Jet (poly p, int m, const ring R)
 
poly p_Jet (poly p, int m, const ring R)
 
poly pp_JetW (poly p, int m, short *w, const ring R)
 
poly p_JetW (poly p, int m, short *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)
 
poly p_Invers (int n, 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...
 

Macro Definition Documentation

#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)
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208
#define p_MemCmp_LengthGeneral_OrdGeneral(s1, s2, length, ordsgn, actionE, actionG, actionS)
Definition: p_MemCmp.h:719

Definition at line 1205 of file p_polys.h.

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

Definition at line 1516 of file p_polys.h.

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

Definition at line 1520 of file p_polys.h.

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

Definition at line 161 of file p_polys.h.

#define p_SetmComp   p_Setm

Definition at line 239 of file p_polys.h.

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

Definition at line 160 of file p_polys.h.

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

Definition at line 1211 of file p_polys.h.

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

Definition at line 154 of file p_polys.h.

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

Definition at line 162 of file p_polys.h.

Function Documentation

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

Definition at line 1651 of file p_polys.h.

1652 {
1653  if (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r))
1654  return _p_LmDivisibleByNoComp(a, b, r);
1655  return FALSE;
1656 }
const poly a
Definition: syzextra.cc:212
#define FALSE
Definition: auxiliary.h:140
#define p_GetComp(p, r)
Definition: monomials.h:72
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:1547
const ring r
Definition: syzextra.cc:208
const poly b
Definition: syzextra.cc:213
static BOOLEAN _p_LmDivisibleBy ( poly  a,
const ring  r_a,
poly  b,
const ring  r_b 
)
inlinestatic

Definition at line 1657 of file p_polys.h.

1658 {
1659  if (p_GetComp(a, r_a) == 0 || p_GetComp(a,r_a) == p_GetComp(b,r_b))
1660  return _p_LmDivisibleByNoComp(a, r_a, b, r_b);
1661  return FALSE;
1662 }
const poly a
Definition: syzextra.cc:212
#define FALSE
Definition: auxiliary.h:140
#define p_GetComp(p, r)
Definition: monomials.h:72
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:1547
const poly b
Definition: syzextra.cc:213
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 1547 of file p_polys.h.

1548 {
1549  int i=r->VarL_Size - 1;
1550  unsigned long divmask = r->divmask;
1551  unsigned long la, lb;
1552 
1553  if (r->VarL_LowIndex >= 0)
1554  {
1555  i += r->VarL_LowIndex;
1556  do
1557  {
1558  la = a->exp[i];
1559  lb = b->exp[i];
1560  if ((la > lb) ||
1561  (((la & divmask) ^ (lb & divmask)) != ((lb - la) & divmask)))
1562  {
1564  return FALSE;
1565  }
1566  i--;
1567  }
1568  while (i>=r->VarL_LowIndex);
1569  }
1570  else
1571  {
1572  do
1573  {
1574  la = a->exp[r->VarL_Offset[i]];
1575  lb = b->exp[r->VarL_Offset[i]];
1576  if ((la > lb) ||
1577  (((la & divmask) ^ (lb & divmask)) != ((lb - la) & divmask)))
1578  {
1580  return FALSE;
1581  }
1582  i--;
1583  }
1584  while (i>=0);
1585  }
1586 /*#ifdef HAVE_RINGS
1587  pDivAssume(p_DebugLmDivisibleByNoComp(a, b, r) == n_DivBy(p_GetCoeff(b, r), p_GetCoeff(a, r), r->cf));
1588  return (!rField_is_Ring(r)) || n_DivBy(p_GetCoeff(b, r), p_GetCoeff(a, r), r->cf);
1589 #else
1590 */
1592  return TRUE;
1593 //#endif
1594 }
const poly a
Definition: syzextra.cc:212
#define FALSE
Definition: auxiliary.h:140
BOOLEAN p_DebugLmDivisibleByNoComp(poly a, poly b, ring r)
Definition: pDebug.cc:140
#define TRUE
Definition: auxiliary.h:144
const ring r
Definition: syzextra.cc:208
int i
Definition: cfEzgcd.cc:123
#define pDivAssume(x)
Definition: p_polys.h:1211
const poly b
Definition: syzextra.cc:213
static BOOLEAN _p_LmDivisibleByNoComp ( poly  a,
const ring  r_a,
poly  b,
const ring  r_b 
)
inlinestatic

Definition at line 1596 of file p_polys.h.

1597 {
1598  int i=r_a->N;
1599  pAssume1(r_a->N == r_b->N);
1600 
1601  do
1602  {
1603  if (p_GetExp(a,i,r_a) > p_GetExp(b,i,r_b))
1604  return FALSE;
1605  i--;
1606  }
1607  while (i);
1608 /*#ifdef HAVE_RINGS
1609  return n_DivBy(p_GetCoeff(b, r_b), p_GetCoeff(a, r_a), r_a->cf);
1610 #else
1611 */
1612  return TRUE;
1613 //#endif
1614 }
const poly a
Definition: syzextra.cc:212
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
int i
Definition: cfEzgcd.cc:123
#define pAssume1(cond)
Definition: monomials.h:179
const poly b
Definition: syzextra.cc:213
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 1617 of file p_polys.h.

1618 {
1619  int i=end;
1620  pAssume1(r_a->N == r_b->N);
1621 
1622  do
1623  {
1624  if (p_GetExp(a,i,r_a) > p_GetExp(b,i,r_b))
1625  return FALSE;
1626  i--;
1627  }
1628  while (i>=start);
1629 /*#ifdef HAVE_RINGS
1630  return n_DivBy(p_GetCoeff(b, r_b), p_GetCoeff(a, r_a), r_a->cf);
1631 #else
1632 */
1633  return TRUE;
1634 //#endif
1635 }
const poly a
Definition: syzextra.cc:212
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
int i
Definition: cfEzgcd.cc:123
#define pAssume1(cond)
Definition: monomials.h:179
const poly b
Definition: syzextra.cc:213
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 1636 of file p_polys.h.

1637 {
1638  if (p_GetComp(a, r_a) == 0 || p_GetComp(a,r_a) == p_GetComp(b,r_b))
1639  return _p_LmDivisibleByNoCompPart(a, r_a, b, r_b,start,end);
1640  return FALSE;
1641 }
const poly a
Definition: syzextra.cc:212
#define FALSE
Definition: auxiliary.h:140
#define p_GetComp(p, r)
Definition: monomials.h:72
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:1617
const poly b
Definition: syzextra.cc:213
BOOLEAN _p_LmTest ( poly  p,
ring  r,
int  level 
)

Definition at line 322 of file pDebug.cc.

323 {
324  if (level < 0 || p == NULL) return TRUE;
325  poly pnext = pNext(p);
326  pNext(p) = NULL;
327  BOOLEAN test_res = _p_Test(p, r, level);
328  pNext(p) = pnext;
329  return test_res;
330 }
int level(const CanonicalForm &f)
return P p
Definition: myNF.cc:203
#define TRUE
Definition: auxiliary.h:144
const ring r
Definition: syzextra.cc:208
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
BOOLEAN _p_Test(poly p, ring r, int level)
Definition: pDebug.cc:211
polyrec * poly
Definition: hilb.h:10
int BOOLEAN
Definition: auxiliary.h:131
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 at line 273 of file p_Mult_q.cc.

274 {
275  assume(r != NULL);
276 #ifdef HAVE_RINGS
277  if (!nCoeff_is_Domain(r->cf))
278  return _p_Mult_q_Normal_ZeroDiv(p, q, copy, r);
279 #endif
280  int lp, lq, l;
281  poly pt;
282 
283  pqLength(p, q, lp, lq, MIN_LENGTH_BUCKET);
284 
285  if (lp < lq)
286  {
287  pt = p;
288  p = q;
289  q = pt;
290  l = lp;
291  lp = lq;
292  lq = l;
293  }
295  return _p_Mult_q_Normal(p, q, copy, r);
296  else
297  {
298  assume(lp == pLength(p));
299  assume(lq == pLength(q));
300  return _p_Mult_q_Bucket(p, lp, q, lq, copy, r);
301  }
302 }
CFArray copy(const CFList &list)
write elements of list into an array
return P p
Definition: myNF.cc:203
#define MIN_LENGTH_BUCKET
Definition: p_Mult_q.h:22
static poly _p_Mult_q_Normal_ZeroDiv(poly p, poly q, const int copy, const ring r)
Definition: p_Mult_q.cc:163
static int pLength(poly a)
Definition: p_polys.h:189
#define TEST_OPT_NOT_BUCKETS
Definition: options.h:100
const ring r
Definition: syzextra.cc:208
#define assume(x)
Definition: mod2.h:405
static poly _p_Mult_q_Normal(poly p, poly q, const int copy, const ring r)
Definition: p_Mult_q.cc:191
BOOLEAN pqLength(poly p, poly q, int &lp, int &lq, const int min)
Definition: p_Mult_q.cc:27
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:762
#define NULL
Definition: omList.c:10
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:66
polyrec * poly
Definition: hilb.h:10
int l
Definition: cfEzgcd.cc:94
BOOLEAN _p_Test ( poly  p,
ring  r,
int  level 
)

Definition at line 211 of file pDebug.cc.

212 {
213  assume(r->cf !=NULL);
214 
215  if (PDEBUG > level) level = PDEBUG;
216  if (level < 0 || p == NULL) return TRUE;
217 
218  poly p_prev = NULL;
219 
220  #ifndef OM_NDEBUG
221  #ifndef X_OMALLOC
222  // check addr with level+1 so as to check bin/page of addr
223  _pPolyAssumeReturnMsg(omTestBinAddrSize(p, (omSizeWOfBin(r->PolyBin))*SIZEOF_LONG, level+1)
224  == omError_NoError, "memory error",p,r);
225  #endif
226  #endif
227 
229 
230  // this checks that p does not contain a loop: rather expensive O(length^2)
231  #ifndef OM_NDEBUG
232  if (level > 1)
234  #endif
235 
236  int ismod = p_GetComp(p, r) != 0;
237 
238  while (p != NULL)
239  {
240  // ring check
242  #ifndef OM_NDEBUG
243  #ifndef X_OMALLOC
244  // omAddr check
245  _pPolyAssumeReturnMsg(omTestBinAddrSize(p, (omSizeWOfBin(r->PolyBin))*SIZEOF_LONG, 1)
246  == omError_NoError, "memory error",p,r);
247  #endif
248  #endif
249  // number/coef check
250  _pPolyAssumeReturnMsg(p->coef != NULL || (n_GetChar(r->cf) >= 2), "NULL coef",p,r);
251 
252  #ifdef LDEBUG
253  _pPolyAssumeReturnMsg(n_Test(p->coef,r->cf),"coeff err",p,r);
254  #endif
255  _pPolyAssumeReturnMsg(!n_IsZero(p->coef, r->cf), "Zero coef",p,r);
256 
257  // check for valid comp
258  _pPolyAssumeReturnMsg(p_GetComp(p, r) >= 0 && (p_GetComp(p, r)<65000), "component out of range ?",p,r);
259  // check for mix poly/vec representation
260  _pPolyAssumeReturnMsg(ismod == (p_GetComp(p, r) != 0), "mixed poly/vector",p,r);
261 
262  // special check for ringorder_s/S
263  if ((r->typ!=NULL) && (r->typ[0].ord_typ == ro_syzcomp))
264  {
265  long c1, cc1, ccc1, ec1;
266  sro_ord* o = &(r->typ[0]);
267 
268  c1 = p_GetComp(p, r);
269  if (o->data.syzcomp.Components!=NULL)
270  {
271  cc1 = o->data.syzcomp.Components[c1];
272  ccc1 = o->data.syzcomp.ShiftedComponents[cc1];
273  }
274  else { cc1=0; ccc1=0; }
275  _pPolyAssumeReturnMsg(c1 == 0 || cc1 != 0, "Component <-> TrueComponent zero mismatch",p,r);
276  _pPolyAssumeReturnMsg(c1 == 0 || ccc1 != 0,"Component <-> ShiftedComponent zero mismatch",p,r);
277  ec1 = p->exp[o->data.syzcomp.place];
278  //pPolyAssumeReturnMsg(ec1 == ccc1, "Shifted comp out of sync. should %d, is %d");
279  if (ec1 != ccc1)
280  {
281  dPolyReportError(p,r,"Shifted comp out of sync. should %d, is %d",ccc1,ec1);
282  return FALSE;
283  }
284  }
285 
286  // check that p_Setm works ok
287  if (level > 0)
288  {
289  poly p_should_equal = p_DebugInit(p, r, r);
290  _pPolyAssumeReturnMsg(p_ExpVectorEqual(p, p_should_equal, r), "p_Setm field(s) out of sync",p,r);
291  p_LmFree(p_should_equal, r);
292  }
293 
294  // check order
295  if (p_prev != NULL)
296  {
297  int cmp = p_LmCmp(p_prev, p, r);
298  if (cmp == 0)
299  {
300  _pPolyAssumeReturnMsg(0, "monoms p and p->next are equal", p_prev, r);
301  }
302  else
303  _pPolyAssumeReturnMsg(p_LmCmp(p_prev, p, r) == 1, "wrong order", p_prev, r);
304 
305  // check that compare worked sensibly
306  if (level > 1 && p_GetComp(p_prev, r) == p_GetComp(p, r))
307  {
308  int i;
309  for (i=r->N; i>0; i--)
310  {
311  if (p_GetExp(p_prev, i, r) != p_GetExp(p, i, r)) break;
312  }
313  _pPolyAssumeReturnMsg(i > 0, "Exponents equal but compare different", p_prev, r);
314  }
315  }
316  p_prev = p;
317  pIter(p);
318  }
319  return TRUE;
320 }
int level(const CanonicalForm &f)
static poly p_DebugInit(poly p, ring src_ring, ring dest_ring)
Definition: pDebug.cc:194
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
#define omTestList(ptr, level)
Definition: omList.h:81
#define p_GetComp(p, r)
Definition: monomials.h:72
omError_t omTestBinAddrSize(void *addr, size_t size, int check_level)
Definition: omDebug.c:44
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:445
#define TRUE
Definition: auxiliary.h:144
BOOLEAN dPolyReportError(poly p, ring r, const char *fmt,...)
Definition: pDebug.cc:44
static void p_LmFree(poly p, ring)
Definition: p_polys.h:678
union sro_ord::@0 data
#define pIter(p)
Definition: monomials.h:44
#define pFalseReturn(cond)
Definition: monomials.h:147
BOOLEAN p_LmCheckIsFromRing(poly p, ring r)
Definition: pDebug.cc:71
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
#define assume(x)
Definition: mod2.h:405
#define PDEBUG
Definition: auxiliary.h:227
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
Definition: coeffs.h:739
Definition: ring.h:180
static int p_LmCmp(poly p, poly q, const ring r)
Definition: p_polys.h:1473
int i
Definition: cfEzgcd.cc:123
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the zero element.
Definition: coeffs.h:465
BOOLEAN p_CheckRing(ring r)
Definition: pDebug.cc:127
#define NULL
Definition: omList.c:10
#define omSizeWOfBin(bin_ptr)
static BOOLEAN p_ExpVectorEqual(poly p1, poly p2, const ring r1, const ring r2)
Definition: p_polys.cc:4332
polyrec * poly
Definition: hilb.h:10
#define _pPolyAssumeReturnMsg(cond, msg, p, r)
Definition: monomials.h:132
BOOLEAN _pp_Test ( poly  p,
ring  lmRing,
ring  tailRing,
int  level 
)

Definition at line 332 of file pDebug.cc.

333 {
334  if (PDEBUG > level) level = PDEBUG;
335  if (level < 0 || p == NULL) return TRUE;
336  if (pNext(p) == NULL || lmRing == tailRing) return _p_Test(p, lmRing, level);
337 
340 
341  // check that lm > Lm(tail)
342  if (level > 1)
343  {
344  poly lm = p;
345  poly tail = p_DebugInit(pNext(p), tailRing, lmRing);
346  poly pnext = pNext(lm);
347  pNext(lm) = tail;
348  BOOLEAN cmp = p_LmCmp(lm, tail, lmRing);
349  if (cmp != 1)
350  dPolyReportError(lm, lmRing, "wrong order: lm <= Lm(tail)");
351  p_LmFree(tail, lmRing);
352  pNext(lm) = pnext;
353  return (cmp == 1);
354  }
355  return TRUE;
356 }
int level(const CanonicalForm &f)
static poly p_DebugInit(poly p, ring src_ring, ring dest_ring)
Definition: pDebug.cc:194
BEGIN_NAMESPACE_SINGULARXX const ring lmRing
Definition: DebugPrint.h:30
return P p
Definition: myNF.cc:203
BEGIN_NAMESPACE_SINGULARXX const ring const ring tailRing
Definition: DebugPrint.h:30
#define TRUE
Definition: auxiliary.h:144
BOOLEAN dPolyReportError(poly p, ring r, const char *fmt,...)
Definition: pDebug.cc:44
static void p_LmFree(poly p, ring)
Definition: p_polys.h:678
BOOLEAN _p_LmTest(poly p, ring r, int level)
Definition: pDebug.cc:322
#define pFalseReturn(cond)
Definition: monomials.h:147
#define PDEBUG
Definition: auxiliary.h:227
static int p_LmCmp(poly p, poly q, const ring r)
Definition: p_polys.h:1473
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
BOOLEAN _p_Test(poly p, ring r, int level)
Definition: pDebug.cc:211
polyrec * poly
Definition: hilb.h:10
int BOOLEAN
Definition: auxiliary.h:131
poly n_PermNumber ( const number  z,
const int *  par_perm,
const int  OldPar,
const ring  src,
const ring  dst 
)

Definition at line 3833 of file p_polys.cc.

3834 {
3835 #if 0
3836  PrintS("\nSource Ring: \n");
3837  rWrite(src);
3838 
3839  if(0)
3840  {
3841  number zz = n_Copy(z, src->cf);
3842  PrintS("z: "); n_Write(zz, src);
3843  n_Delete(&zz, src->cf);
3844  }
3845 
3846  PrintS("\nDestination Ring: \n");
3847  rWrite(dst);
3848 
3849  /*Print("\nOldPar: %d\n", OldPar);
3850  for( int i = 1; i <= OldPar; i++ )
3851  {
3852  Print("par(%d) -> par/var (%d)\n", i, par_perm[i-1]);
3853  }*/
3854 #endif
3855  if( z == NULL )
3856  return NULL;
3857 
3858  const coeffs srcCf = src->cf;
3859  assume( srcCf != NULL );
3860 
3861  assume( !nCoeff_is_GF(srcCf) );
3862  assume( src->cf->extRing!=NULL );
3863 
3864  poly zz = NULL;
3865 
3866  const ring srcExtRing = srcCf->extRing;
3867  assume( srcExtRing != NULL );
3868 
3869  const coeffs dstCf = dst->cf;
3870  assume( dstCf != NULL );
3871 
3872  if( nCoeff_is_algExt(srcCf) ) // nCoeff_is_GF(srcCf)?
3873  {
3874  zz = (poly) z;
3875  if( zz == NULL ) return NULL;
3876  }
3877  else if (nCoeff_is_transExt(srcCf))
3878  {
3879  assume( !IS0(z) );
3880 
3881  zz = NUM((fraction)z);
3882  p_Test (zz, srcExtRing);
3883 
3884  if( zz == NULL ) return NULL;
3885  if( !DENIS1((fraction)z) )
3886  {
3887  if (!p_IsConstant(DEN((fraction)z),srcExtRing))
3888  WarnS("Not defined: Cannot map a rational fraction and make a polynomial out of it! Ignoring the denumerator.");
3889  }
3890  }
3891  else
3892  {
3893  assume (FALSE);
3894  Werror("Number permutation is not implemented for this data yet!");
3895  return NULL;
3896  }
3897 
3898  assume( zz != NULL );
3899  p_Test (zz, srcExtRing);
3900 
3901  nMapFunc nMap = n_SetMap(srcExtRing->cf, dstCf);
3902 
3903  assume( nMap != NULL );
3904 
3905  poly qq;
3906  if ((par_perm == NULL) && (rPar(dst) != 0 && rVar (srcExtRing) > 0))
3907  {
3908  int* perm;
3909  perm=(int *)omAlloc0((rVar(srcExtRing)+1)*sizeof(int));
3910  perm[0]= 0;
3911  for(int i=si_min(rVar(srcExtRing),rPar(dst));i>0;i--)
3912  perm[i]=-i;
3913  qq = p_PermPoly(zz, perm, srcExtRing, dst, nMap, NULL, rVar(srcExtRing)-1);
3914  omFreeSize ((ADDRESS)perm, (rVar(srcExtRing)+1)*sizeof(int));
3915  }
3916  else
3917  qq = p_PermPoly(zz, par_perm-1, srcExtRing, dst, nMap, NULL, rVar (srcExtRing)-1);
3918 
3919  if(nCoeff_is_transExt(srcCf)
3920  && (!DENIS1((fraction)z))
3921  && p_IsConstant(DEN((fraction)z),srcExtRing))
3922  {
3923  number n=nMap(pGetCoeff(DEN((fraction)z)),srcExtRing->cf, dstCf);
3924  qq=p_Div_nn(qq,n,dst);
3925  n_Delete(&n,dstCf);
3926  p_Normalize(qq,dst);
3927  }
3928  p_Test (qq, dst);
3929 
3930  return qq;
3931 }
static int si_min(const int a, const int b)
Definition: auxiliary.h:167
#define FALSE
Definition: auxiliary.h:140
static int rPar(const ring r)
(r->cf->P)
Definition: ring.h:544
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:537
poly p_Div_nn(poly p, const number n, const ring r)
Definition: p_polys.cc:1480
void * ADDRESS
Definition: auxiliary.h:161
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
#define WarnS
Definition: emacs.cc:81
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:3937
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
Definition: coeffs.h:913
#define assume(x)
Definition: mod2.h:405
static BOOLEAN p_IsConstant(const poly p, const ring r)
Definition: p_polys.h:1785
The main handler for Singular numbers which are suitable for Singular polynomials.
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:72
static FORCE_INLINE void n_Write(number &n, const coeffs r, const BOOLEAN bShortOut=TRUE)
Definition: coeffs.h:592
static FORCE_INLINE BOOLEAN nCoeff_is_transExt(const coeffs r)
TRUE iff r represents a transcendental extension field.
Definition: coeffs.h:921
int i
Definition: cfEzgcd.cc:123
void PrintS(const char *s)
Definition: reporter.cc:294
void rWrite(ring r, BOOLEAN details)
Definition: ring.cc:236
static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
Definition: coeffs.h:842
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:722
#define p_Test(p, r)
Definition: p_polys.h:160
void p_Normalize(poly p, const ring r)
Definition: p_polys.cc:3632
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of &#39;n&#39;
Definition: coeffs.h:452
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
polyrec * poly
Definition: hilb.h:10
int perm[100]
void Werror(const char *fmt,...)
Definition: reporter.cc:199
#define omAlloc0(size)
Definition: omAllocDecl.h:211
static poly p_Add_q ( poly  p,
poly  q,
const ring  r 
)
inlinestatic

Definition at line 883 of file p_polys.h.

884 {
885  assume( (p != q) || (p == NULL && q == NULL) );
886  int shorter;
887  return r->p_Procs->p_Add_q(p, q, shorter, r);
888 }
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
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 891 of file p_polys.h.

892 {
893  assume( (p != q) || (p == NULL && q == NULL) );
894  int shorter;
895  poly res = r->p_Procs->p_Add_q(p, q, shorter, r);
896  lp = (lp + lq) - shorter;
897  return res;
898 }
return P p
Definition: myNF.cc:203
poly res
Definition: myNF.cc:322
const ring r
Definition: syzextra.cc:208
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
polyrec * poly
Definition: hilb.h:10
static unsigned long p_AddComp ( poly  p,
unsigned long  v,
ring  r 
)
inlinestatic

Definition at line 442 of file p_polys.h.

443 {
446  return __p_GetComp(p,r) += v;
447 }
#define p_LmCheckPolyRing2(p, r)
Definition: monomials.h:207
#define __p_GetComp(p, r)
Definition: monomials.h:71
return P p
Definition: myNF.cc:203
#define pAssume2(cond)
Definition: monomials.h:201
const ring r
Definition: syzextra.cc:208
#define rRing_has_Comp(r)
Definition: monomials.h:274
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
static long p_AddExp ( poly  p,
int  v,
long  ee,
ring  r 
)
inlinestatic

Definition at line 601 of file p_polys.h.

602 {
604  int e = p_GetExp(p,v,r);
605  e += ee;
606  return p_SetExp(p,v,e,r);
607 }
#define p_LmCheckPolyRing2(p, r)
Definition: monomials.h:207
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent : VarOffset encodes the position in p->exp
Definition: p_polys.h:483
BOOLEAN p_CheckIsFromRing ( poly  p,
ring  r 
)

Definition at line 101 of file pDebug.cc.

102 {
103  while (p!=NULL)
104  {
106  pIter(p);
107  }
108  return TRUE;
109 }
return P p
Definition: myNF.cc:203
#define TRUE
Definition: auxiliary.h:144
#define pIter(p)
Definition: monomials.h:44
#define pFalseReturn(cond)
Definition: monomials.h:147
BOOLEAN p_LmCheckIsFromRing(poly p, ring r)
Definition: pDebug.cc:71
const ring r
Definition: syzextra.cc:208
#define NULL
Definition: omList.c:10
BOOLEAN p_CheckPolyRing ( poly  p,
ring  r 
)

Definition at line 111 of file pDebug.cc.

112 {
113  #ifndef X_OMALLOC
114  pAssumeReturn(r != NULL && r->PolyBin != NULL);
115  #endif
116  return p_CheckIsFromRing(p, r);
117 }
return P p
Definition: myNF.cc:203
#define pAssumeReturn(cond)
Definition: monomials.h:86
const ring r
Definition: syzextra.cc:208
#define NULL
Definition: omList.c:10
BOOLEAN p_CheckIsFromRing(poly p, ring r)
Definition: pDebug.cc:101
BOOLEAN p_CheckRing ( ring  r)

Definition at line 127 of file pDebug.cc.

128 {
129  #ifndef X_OMALLOC
130  pAssumeReturn(r != NULL && r->PolyBin != NULL);
131  #endif
132  return TRUE;
133 }
#define TRUE
Definition: auxiliary.h:144
#define pAssumeReturn(cond)
Definition: monomials.h:86
const ring r
Definition: syzextra.cc:208
#define NULL
Definition: omList.c:10
poly p_ChineseRemainder ( poly xx,
number *  x,
number *  q,
int  rl,
CFArray inv_cache,
const ring  R 
)

Definition at line 94 of file p_polys.cc.

95 {
96  poly r,h,hh;
97  int j;
98  poly res_p=NULL;
99  loop
100  {
101  /* search the lead term */
102  r=NULL;
103  for(j=rl-1;j>=0;j--)
104  {
105  h=xx[j];
106  if ((h!=NULL)
107  &&((r==NULL)||(p_LmCmp(r,h,R)==-1)))
108  r=h;
109  }
110  /* nothing found -> return */
111  if (r==NULL) break;
112  /* create the monomial in h */
113  h=p_Head(r,R);
114  /* collect the coeffs in x[..]*/
115  for(j=rl-1;j>=0;j--)
116  {
117  hh=xx[j];
118  if ((hh!=NULL) && (p_LmCmp(h,hh,R)==0))
119  {
120  x[j]=pGetCoeff(hh);
121  hh=p_LmFreeAndNext(hh,R);
122  xx[j]=hh;
123  }
124  else
125  x[j]=n_Init(0, R);
126  }
127  number n=n_ChineseRemainderSym(x,q,rl,TRUE,inv_cache,R->cf);
128  for(j=rl-1;j>=0;j--)
129  {
130  x[j]=NULL; // n_Init(0...) takes no memory
131  }
132  if (n_IsZero(n,R)) p_Delete(&h,R);
133  else
134  {
135  //Print("new mon:");pWrite(h);
136  p_SetCoeff(h,n,R);
137  pNext(h)=res_p;
138  res_p=h; // building res_p in reverse order!
139  }
140  }
141  res_p=pReverse(res_p);
142  p_Test(res_p, R);
143  return res_p;
144 }
loop
Definition: myNF.cc:98
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:539
#define TRUE
Definition: auxiliary.h:144
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:407
static poly p_Head(poly p, const ring r)
Definition: p_polys.h:818
const ring r
Definition: syzextra.cc:208
int j
Definition: myNF.cc:70
static FORCE_INLINE number n_ChineseRemainderSym(number *a, number *b, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs r)
Definition: coeffs.h:787
const ring R
Definition: DebugPrint.cc:36
static int p_LmCmp(poly p, poly q, const ring r)
Definition: p_polys.h:1473
static poly p_LmFreeAndNext(poly p, ring)
Definition: p_polys.h:698
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the zero element.
Definition: coeffs.h:465
static poly pReverse(poly p)
Definition: p_polys.h:330
#define p_Test(p, r)
Definition: p_polys.h:160
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:849
#define NULL
Definition: omList.c:10
Variable x
Definition: cfModGcd.cc:4023
#define pNext(p)
Definition: monomials.h:43
polyrec * poly
Definition: hilb.h:10
static Poly * h
Definition: janet.cc:978
poly p_Cleardenom ( poly  p,
const ring  r 
)

Definition at line 2707 of file p_polys.cc.

2708 {
2709  if( p == NULL )
2710  return NULL;
2711 
2712  assume( r != NULL ); assume( r->cf != NULL ); const coeffs C = r->cf;
2713 
2714 #if CLEARENUMERATORS
2715  if( 0 )
2716  {
2717  CPolyCoeffsEnumerator itr(p);
2718 
2719  n_ClearDenominators(itr, C);
2720 
2721  n_ClearContent(itr, C); // divide out the content
2722 
2723  p_Test(p, r); n_Test(pGetCoeff(p), C);
2724  assume(n_GreaterZero(pGetCoeff(p), C)); // ??
2725 // if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
2726 
2727  return p;
2728  }
2729 #endif
2730 
2731 
2732  number d, h;
2733 
2734 #ifdef HAVE_RINGS
2735  if (rField_is_Ring(r))
2736  {
2737  p_Content(p,r);
2738  if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
2739  return p;
2740  }
2741 #endif
2742 
2744  {
2745  if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
2746  return p;
2747  }
2748 
2749  assume(p != NULL);
2750 
2751  if(pNext(p)==NULL)
2752  {
2753  if (!TEST_OPT_CONTENTSB
2754  && !rField_is_Ring(r))
2755  p_SetCoeff(p,n_Init(1,r->cf),r);
2756  else if(!n_GreaterZero(pGetCoeff(p),C))
2757  p = p_Neg(p,r);
2758  return p;
2759  }
2760 
2761  assume(pNext(p)!=NULL);
2762  poly start=p;
2763 
2764 #if 0 && CLEARENUMERATORS
2765 //CF: does not seem to work that well..
2766 
2767  if( nCoeff_is_Q(C) || nCoeff_is_Q_a(C) )
2768  {
2769  CPolyCoeffsEnumerator itr(p);
2770 
2771  n_ClearDenominators(itr, C);
2772 
2773  n_ClearContent(itr, C); // divide out the content
2774 
2775  p_Test(p, r); n_Test(pGetCoeff(p), C);
2776  assume(n_GreaterZero(pGetCoeff(p), C)); // ??
2777 // if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
2778 
2779  return start;
2780  }
2781 #endif
2782 
2783  if(1)
2784  {
2785  h = n_Init(1,r->cf);
2786  while (p!=NULL)
2787  {
2788  n_Normalize(pGetCoeff(p),r->cf);
2789  d=n_NormalizeHelper(h,pGetCoeff(p),r->cf);
2790  n_Delete(&h,r->cf);
2791  h=d;
2792  pIter(p);
2793  }
2794  /* contains the 1/lcm of all denominators */
2795  if(!n_IsOne(h,r->cf))
2796  {
2797  p = start;
2798  while (p!=NULL)
2799  {
2800  /* should be: // NOTE: don't use ->coef!!!!
2801  * number hh;
2802  * nGetDenom(p->coef,&hh);
2803  * nMult(&h,&hh,&d);
2804  * nNormalize(d);
2805  * nDelete(&hh);
2806  * nMult(d,p->coef,&hh);
2807  * nDelete(&d);
2808  * nDelete(&(p->coef));
2809  * p->coef =hh;
2810  */
2811  d=n_Mult(h,pGetCoeff(p),r->cf);
2812  n_Normalize(d,r->cf);
2813  p_SetCoeff(p,d,r);
2814  pIter(p);
2815  }
2816  n_Delete(&h,r->cf);
2817  }
2818  n_Delete(&h,r->cf);
2819  p=start;
2820 
2821  p_Content(p,r);
2822 #ifdef HAVE_RATGRING
2823  if (rIsRatGRing(r))
2824  {
2825  /* quick unit detection in the rational case is done in gr_nc_bba */
2826  p_ContentRat(p, r);
2827  start=p;
2828  }
2829 #endif
2830  }
2831 
2832  if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
2833 
2834  return start;
2835 }
return P p
Definition: myNF.cc:203
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the one element.
Definition: coeffs.h:469
static BOOLEAN rIsRatGRing(const ring r)
Definition: ring.h:372
#define TEST_OPT_CONTENTSB
Definition: options.h:121
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:539
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition: coeffs.h:579
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:718
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
Definition: coeffs.h:829
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:407
static FORCE_INLINE BOOLEAN nCoeff_is_Q_a(const coeffs r)
Definition: coeffs.h:888
#define pIter(p)
Definition: monomials.h:44
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of &#39;a&#39; and &#39;b&#39;, i.e., a*b
Definition: coeffs.h:637
void p_ContentRat(poly &ph, const ring r)
Definition: p_polys.cc:1655
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:931
const ring r
Definition: syzextra.cc:208
#define TEST_OPT_INTSTRATEGY
Definition: options.h:105
This is a polynomial enumerator for simple iteration over coefficients of polynomials.
#define assume(x)
Definition: mod2.h:405
The main handler for Singular numbers which are suitable for Singular polynomials.
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
Definition: coeffs.h:739
void p_Content(poly ph, const ring r)
Definition: p_polys.cc:2207
#define p_Test(p, r)
Definition: p_polys.h:160
static BOOLEAN rField_is_Zp(const ring r)
Definition: ring.h:452
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:434
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
static poly p_Neg(poly p, const ring r)
Definition: p_polys.h:1019
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
static FORCE_INLINE BOOLEAN n_GreaterZero(number n, const coeffs r)
ordered fields: TRUE iff &#39;n&#39; is positive; in Z/pZ: TRUE iff 0 < m <= roundedBelow(p/2), where m is the long representing n in C: TRUE iff (Im(n) != 0 and Im(n) >= 0) or (Im(n) == 0 and Re(n) >= 0) in K(a)/<p(a)>: TRUE iff (n != 0 and (LC(n) > 0 or deg(n) > 0)) in K(t_1, ..., t_n): TRUE iff (LC(numerator(n) is a constant and > 0) or (LC(numerator(n) is not a constant) in Z/2^kZ: TRUE iff 0 < n <= 2^(k-1) in Z/mZ: TRUE iff the internal mpz is greater than zero in Z: TRUE iff n > 0
Definition: coeffs.h:495
polyrec * poly
Definition: hilb.h:10
static Poly * h
Definition: janet.cc:978
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:938
void p_Cleardenom_n ( poly  p,
const ring  r,
number &  c 
)

Definition at line 2837 of file p_polys.cc.

2838 {
2839  const coeffs C = r->cf;
2840  number d, h;
2841 
2842  assume( ph != NULL );
2843 
2844  poly p = ph;
2845 
2846 #if CLEARENUMERATORS
2847  if( 0 )
2848  {
2849  CPolyCoeffsEnumerator itr(ph);
2850 
2851  n_ClearDenominators(itr, d, C); // multiply with common denom. d
2852  n_ClearContent(itr, h, C); // divide by the content h
2853 
2854  c = n_Div(d, h, C); // d/h
2855 
2856  n_Delete(&d, C);
2857  n_Delete(&h, C);
2858 
2859  n_Test(c, C);
2860 
2861  p_Test(ph, r); n_Test(pGetCoeff(ph), C);
2862  assume(n_GreaterZero(pGetCoeff(ph), C)); // ??
2863 /*
2864  if(!n_GreaterZero(pGetCoeff(ph),C))
2865  {
2866  ph = p_Neg(ph,r);
2867  c = n_InpNeg(c, C);
2868  }
2869 */
2870  return;
2871  }
2872 #endif
2873 
2874 
2875  if( pNext(p) == NULL )
2876  {
2877  c=n_Invers(pGetCoeff(p), C);
2878  p_SetCoeff(p, n_Init(1, C), r);
2879 
2880  assume( n_GreaterZero(pGetCoeff(ph),C) );
2881  if(!n_GreaterZero(pGetCoeff(ph),C))
2882  {
2883  ph = p_Neg(ph,r);
2884  c = n_InpNeg(c, C);
2885  }
2886 
2887  return;
2888  }
2889 
2890  assume( pNext(p) != NULL );
2891 
2892 #if CLEARENUMERATORS
2893  if( nCoeff_is_Q(C) || nCoeff_is_Q_a(C) )
2894  {
2895  CPolyCoeffsEnumerator itr(ph);
2896 
2897  n_ClearDenominators(itr, d, C); // multiply with common denom. d
2898  n_ClearContent(itr, h, C); // divide by the content h
2899 
2900  c = n_Div(d, h, C); // d/h
2901 
2902  n_Delete(&d, C);
2903  n_Delete(&h, C);
2904 
2905  n_Test(c, C);
2906 
2907  p_Test(ph, r); n_Test(pGetCoeff(ph), C);
2908  assume(n_GreaterZero(pGetCoeff(ph), C)); // ??
2909 /*
2910  if(!n_GreaterZero(pGetCoeff(ph),C))
2911  {
2912  ph = p_Neg(ph,r);
2913  c = n_InpNeg(c, C);
2914  }
2915 */
2916  return;
2917  }
2918 #endif
2919 
2920 
2921 
2922 
2923  if(1)
2924  {
2925  h = n_Init(1,r->cf);
2926  while (p!=NULL)
2927  {
2928  n_Normalize(pGetCoeff(p),r->cf);
2929  d=n_NormalizeHelper(h,pGetCoeff(p),r->cf);
2930  n_Delete(&h,r->cf);
2931  h=d;
2932  pIter(p);
2933  }
2934  c=h;
2935  /* contains the 1/lcm of all denominators */
2936  if(!n_IsOne(h,r->cf))
2937  {
2938  p = ph;
2939  while (p!=NULL)
2940  {
2941  /* should be: // NOTE: don't use ->coef!!!!
2942  * number hh;
2943  * nGetDenom(p->coef,&hh);
2944  * nMult(&h,&hh,&d);
2945  * nNormalize(d);
2946  * nDelete(&hh);
2947  * nMult(d,p->coef,&hh);
2948  * nDelete(&d);
2949  * nDelete(&(p->coef));
2950  * p->coef =hh;
2951  */
2952  d=n_Mult(h,pGetCoeff(p),r->cf);
2953  n_Normalize(d,r->cf);
2954  p_SetCoeff(p,d,r);
2955  pIter(p);
2956  }
2957  if (rField_is_Q_a(r))
2958  {
2959  loop
2960  {
2961  h = n_Init(1,r->cf);
2962  p=ph;
2963  while (p!=NULL)
2964  {
2965  d=n_NormalizeHelper(h,pGetCoeff(p),r->cf);
2966  n_Delete(&h,r->cf);
2967  h=d;
2968  pIter(p);
2969  }
2970  /* contains the 1/lcm of all denominators */
2971  if(!n_IsOne(h,r->cf))
2972  {
2973  p = ph;
2974  while (p!=NULL)
2975  {
2976  /* should be: // NOTE: don't use ->coef!!!!
2977  * number hh;
2978  * nGetDenom(p->coef,&hh);
2979  * nMult(&h,&hh,&d);
2980  * nNormalize(d);
2981  * nDelete(&hh);
2982  * nMult(d,p->coef,&hh);
2983  * nDelete(&d);
2984  * nDelete(&(p->coef));
2985  * p->coef =hh;
2986  */
2987  d=n_Mult(h,pGetCoeff(p),r->cf);
2988  n_Normalize(d,r->cf);
2989  p_SetCoeff(p,d,r);
2990  pIter(p);
2991  }
2992  number t=n_Mult(c,h,r->cf);
2993  n_Delete(&c,r->cf);
2994  c=t;
2995  }
2996  else
2997  {
2998  break;
2999  }
3000  n_Delete(&h,r->cf);
3001  }
3002  }
3003  }
3004  }
3005 
3006  if(!n_GreaterZero(pGetCoeff(ph),C))
3007  {
3008  ph = p_Neg(ph,r);
3009  c = n_InpNeg(c, C);
3010  }
3011 
3012 }
loop
Definition: myNF.cc:98
return P p
Definition: myNF.cc:203
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the one element.
Definition: coeffs.h:469
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:539
static BOOLEAN rField_is_Q_a(const ring r)
Definition: ring.h:485
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition: coeffs.h:579
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:718
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
Definition: coeffs.h:829
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:407
static FORCE_INLINE BOOLEAN nCoeff_is_Q_a(const coeffs r)
Definition: coeffs.h:888
#define pIter(p)
Definition: monomials.h:44
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of &#39;a&#39; and &#39;b&#39;, i.e., a*b
Definition: coeffs.h:637
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:931
const ring r
Definition: syzextra.cc:208
This is a polynomial enumerator for simple iteration over coefficients of polynomials.
#define assume(x)
Definition: mod2.h:405
The main handler for Singular numbers which are suitable for Singular polynomials.
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
Definition: coeffs.h:739
static FORCE_INLINE number n_Invers(number a, const coeffs r)
return the multiplicative inverse of &#39;a&#39;; raise an error if &#39;a&#39; is not invertible ...
Definition: coeffs.h:565
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:558
#define p_Test(p, r)
Definition: p_polys.h:160
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of &#39;a&#39; and &#39;b&#39;, i.e., a/b; raises an error if &#39;b&#39; is not invertible in r exceptio...
Definition: coeffs.h:616
#define pNext(p)
Definition: monomials.h:43
static poly p_Neg(poly p, const ring r)
Definition: p_polys.h:1019
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
static FORCE_INLINE BOOLEAN n_GreaterZero(number n, const coeffs r)
ordered fields: TRUE iff &#39;n&#39; is positive; in Z/pZ: TRUE iff 0 < m <= roundedBelow(p/2), where m is the long representing n in C: TRUE iff (Im(n) != 0 and Im(n) >= 0) or (Im(n) == 0 and Re(n) >= 0) in K(a)/<p(a)>: TRUE iff (n != 0 and (LC(n) > 0 or deg(n) > 0)) in K(t_1, ..., t_n): TRUE iff (LC(numerator(n) is a constant and > 0) or (LC(numerator(n) is not a constant) in Z/2^kZ: TRUE iff 0 < n <= 2^(k-1) in Z/mZ: TRUE iff the internal mpz is greater than zero in Z: TRUE iff n > 0
Definition: coeffs.h:495
polyrec * poly
Definition: hilb.h:10
static Poly * h
Definition: janet.cc:978
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:938
static int p_Cmp ( poly  p1,
poly  p2,
ring  r 
)
inlinestatic

Definition at line 1524 of file p_polys.h.

1525 {
1526  if (p2==NULL)
1527  return 1;
1528  if (p1==NULL)
1529  return -1;
1530  return p_LmCmp(p1,p2,r);
1531 }
const ring r
Definition: syzextra.cc:208
static int p_LmCmp(poly p, poly q, const ring r)
Definition: p_polys.h:1473
#define NULL
Definition: omList.c:10
END_NAMESPACE const void * p2
Definition: syzextra.cc:202
static int p_Comp_k_n ( poly  a,
poly  b,
int  k,
ring  r 
)
inlinestatic

Definition at line 635 of file p_polys.h.

636 {
637  if ((a==NULL) || (b==NULL) ) return FALSE;
640  pAssume2(k > 0 && k <= r->N);
641  int i=k;
642  for(;i<=r->N;i++)
643  {
644  if (p_GetExp(a,i,r) != p_GetExp(b,i,r)) return FALSE;
645  // if (a->exp[(r->VarOffset[i] & 0xffffff)] != b->exp[(r->VarOffset[i] & 0xffffff)]) return FALSE;
646  }
647  return TRUE;
648 }
#define p_LmCheckPolyRing2(p, r)
Definition: monomials.h:207
const poly a
Definition: syzextra.cc:212
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
int k
Definition: cfEzgcd.cc:93
#define pAssume2(cond)
Definition: monomials.h:201
const ring r
Definition: syzextra.cc:208
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:49
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
const poly b
Definition: syzextra.cc:213
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 4382 of file p_polys.cc.

4383 {
4384  number n,nn;
4385  pAssume(p1 != NULL && p2 != NULL);
4386 
4387  if (!p_LmEqual(p1,p2,r)) //compare leading mons
4388  return FALSE;
4389  if ((pNext(p1)==NULL) && (pNext(p2)!=NULL))
4390  return FALSE;
4391  if ((pNext(p2)==NULL) && (pNext(p1)!=NULL))
4392  return FALSE;
4393  if (pLength(p1) != pLength(p2))
4394  return FALSE;
4395 #ifdef HAVE_RINGS
4396  if (rField_is_Ring(r))
4397  {
4398  if (!n_DivBy(p_GetCoeff(p1, r), p_GetCoeff(p2, r), r)) return FALSE;
4399  }
4400 #endif
4401  n=n_Div(p_GetCoeff(p1,r),p_GetCoeff(p2,r),r);
4402  while ((p1 != NULL) /*&& (p2 != NULL)*/)
4403  {
4404  if ( ! p_LmEqual(p1, p2,r))
4405  {
4406  n_Delete(&n, r);
4407  return FALSE;
4408  }
4409  if (!n_Equal(p_GetCoeff(p1, r), nn = n_Mult(p_GetCoeff(p2, r),n, r->cf), r->cf))
4410  {
4411  n_Delete(&n, r);
4412  n_Delete(&nn, r);
4413  return FALSE;
4414  }
4415  n_Delete(&nn, r);
4416  pIter(p1);
4417  pIter(p2);
4418  }
4419  n_Delete(&n, r);
4420  return TRUE;
4421 }
#define FALSE
Definition: auxiliary.h:140
#define pAssume(cond)
Definition: monomials.h:98
#define TRUE
Definition: auxiliary.h:144
static int pLength(poly a)
Definition: p_polys.h:189
#define pIter(p)
Definition: monomials.h:44
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of &#39;a&#39; and &#39;b&#39;, i.e., a*b
Definition: coeffs.h:637
const ring r
Definition: syzextra.cc:208
static FORCE_INLINE BOOLEAN n_DivBy(number a, number b, const coeffs r)
test whether &#39;a&#39; is divisible &#39;b&#39;; for r encoding a field: TRUE iff &#39;b&#39; does not represent zero in Z:...
Definition: coeffs.h:776
#define p_LmEqual(p1, p2, r)
Definition: p_polys.h:1520
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:434
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of &#39;a&#39; and &#39;b&#39;, i.e., a/b; raises an error if &#39;b&#39; is not invertible in r exceptio...
Definition: coeffs.h:616
#define pNext(p)
Definition: monomials.h:43
static FORCE_INLINE BOOLEAN n_Equal(number a, number b, const coeffs r)
TRUE iff &#39;a&#39; and &#39;b&#39; represent the same number; they may have different representations.
Definition: coeffs.h:461
#define p_GetCoeff(p, r)
Definition: monomials.h:57
END_NAMESPACE const void * p2
Definition: syzextra.cc:202
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
void p_Content ( poly  p,
const ring  r 
)

Definition at line 2207 of file p_polys.cc.

2208 {
2209  assume( ph != NULL );
2210 
2211  assume( r != NULL ); assume( r->cf != NULL );
2212 
2213 
2214 #if CLEARENUMERATORS
2215  if( 0 )
2216  {
2217  const coeffs C = r->cf;
2218  // experimentall (recursive enumerator treatment) of alg. Ext!
2219  CPolyCoeffsEnumerator itr(ph);
2220  n_ClearContent(itr, r->cf);
2221 
2222  p_Test(ph, r); n_Test(pGetCoeff(ph), C);
2223  assume(n_GreaterZero(pGetCoeff(ph), C)); // ??
2224 
2225  // if(!n_GreaterZero(pGetCoeff(ph),r->cf)) ph = p_Neg(ph,r);
2226  return;
2227  }
2228 #endif
2229 
2230 
2231 #ifdef HAVE_RINGS
2232  if (rField_is_Ring(r))
2233  {
2234  if (rField_has_Units(r))
2235  {
2236  number k = n_GetUnit(pGetCoeff(ph),r->cf);
2237  if (!n_IsOne(k,r->cf))
2238  {
2239  number tmpGMP = k;
2240  k = n_Invers(k,r->cf);
2241  n_Delete(&tmpGMP,r->cf);
2242  poly h = pNext(ph);
2243  p_SetCoeff(ph, n_Mult(pGetCoeff(ph), k,r->cf),r);
2244  while (h != NULL)
2245  {
2246  p_SetCoeff(h, n_Mult(pGetCoeff(h), k,r->cf),r);
2247  pIter(h);
2248  }
2249 // assume( n_GreaterZero(pGetCoeff(ph),r->cf) );
2250 // if(!n_GreaterZero(pGetCoeff(ph),r->cf)) ph = p_Neg(ph,r);
2251  }
2252  n_Delete(&k,r->cf);
2253  }
2254  return;
2255  }
2256 #endif
2257  number h,d;
2258  poly p;
2259 
2260  if(TEST_OPT_CONTENTSB) return;
2261  if(pNext(ph)==NULL)
2262  {
2263  p_SetCoeff(ph,n_Init(1,r->cf),r);
2264  }
2265  else
2266  {
2267  assume( pNext(ph) != NULL );
2268 #if CLEARENUMERATORS
2269  if( nCoeff_is_Q(r->cf) )
2270  {
2271  // experimentall (recursive enumerator treatment) of alg. Ext!
2272  CPolyCoeffsEnumerator itr(ph);
2273  n_ClearContent(itr, r->cf);
2274 
2275  p_Test(ph, r); n_Test(pGetCoeff(ph), r->cf);
2276  assume(n_GreaterZero(pGetCoeff(ph), r->cf)); // ??
2277 
2278  // if(!n_GreaterZero(pGetCoeff(ph),r->cf)) ph = p_Neg(ph,r);
2279  return;
2280  }
2281 #endif
2282 
2283  n_Normalize(pGetCoeff(ph),r->cf);
2284  if(!n_GreaterZero(pGetCoeff(ph),r->cf)) ph = p_Neg(ph,r);
2285  if (rField_is_Q(r)||(getCoeffType(r->cf)==n_transExt)) // should not be used anymore if CLEARENUMERATORS is 1
2286  {
2287  h=p_InitContent(ph,r);
2288  p=ph;
2289  }
2290  else
2291  {
2292  h=n_Copy(pGetCoeff(ph),r->cf);
2293  p = pNext(ph);
2294  }
2295  while (p!=NULL)
2296  {
2297  n_Normalize(pGetCoeff(p),r->cf);
2298  d=n_SubringGcd(h,pGetCoeff(p),r->cf);
2299  n_Delete(&h,r->cf);
2300  h = d;
2301  if(n_IsOne(h,r->cf))
2302  {
2303  break;
2304  }
2305  pIter(p);
2306  }
2307  p = ph;
2308  //number tmp;
2309  if(!n_IsOne(h,r->cf))
2310  {
2311  while (p!=NULL)
2312  {
2313  //d = nDiv(pGetCoeff(p),h);
2314  //tmp = nExactDiv(pGetCoeff(p),h);
2315  //if (!nEqual(d,tmp))
2316  //{
2317  // StringSetS("** div0:");nWrite(pGetCoeff(p));StringAppendS("/");
2318  // nWrite(h);StringAppendS("=");nWrite(d);StringAppendS(" int:");
2319  // nWrite(tmp);Print(StringEndS("\n")); // NOTE/TODO: use StringAppendS("\n"); omFree(s);
2320  //}
2321  //nDelete(&tmp);
2322  d = n_ExactDiv(pGetCoeff(p),h,r->cf);
2323  p_SetCoeff(p,d,r);
2324  pIter(p);
2325  }
2326  }
2327  n_Delete(&h,r->cf);
2328  if (rField_is_Q_a(r))
2329  {
2330  // special handling for alg. ext.:
2331  if (getCoeffType(r->cf)==n_algExt)
2332  {
2333  h = n_Init(1, r->cf->extRing->cf);
2334  p=ph;
2335  while (p!=NULL)
2336  { // each monom: coeff in Q_a
2337  poly c_n_n=(poly)pGetCoeff(p);
2338  poly c_n=c_n_n;
2339  while (c_n!=NULL)
2340  { // each monom: coeff in Q
2341  d=n_NormalizeHelper(h,pGetCoeff(c_n),r->cf->extRing->cf);
2342  n_Delete(&h,r->cf->extRing->cf);
2343  h=d;
2344  pIter(c_n);
2345  }
2346  pIter(p);
2347  }
2348  /* h contains the 1/lcm of all denominators in c_n_n*/
2349  //n_Normalize(h,r->cf->extRing->cf);
2350  if(!n_IsOne(h,r->cf->extRing->cf))
2351  {
2352  p=ph;
2353  while (p!=NULL)
2354  { // each monom: coeff in Q_a
2355  poly c_n=(poly)pGetCoeff(p);
2356  while (c_n!=NULL)
2357  { // each monom: coeff in Q
2358  d=n_Mult(h,pGetCoeff(c_n),r->cf->extRing->cf);
2359  n_Normalize(d,r->cf->extRing->cf);
2360  n_Delete(&pGetCoeff(c_n),r->cf->extRing->cf);
2361  pGetCoeff(c_n)=d;
2362  pIter(c_n);
2363  }
2364  pIter(p);
2365  }
2366  }
2367  n_Delete(&h,r->cf->extRing->cf);
2368  }
2369  /*else
2370  {
2371  // special handling for rat. functions.:
2372  number hzz =NULL;
2373  p=ph;
2374  while (p!=NULL)
2375  { // each monom: coeff in Q_a (Z_a)
2376  fraction f=(fraction)pGetCoeff(p);
2377  poly c_n=NUM(f);
2378  if (hzz==NULL)
2379  {
2380  hzz=n_Copy(pGetCoeff(c_n),r->cf->extRing->cf);
2381  pIter(c_n);
2382  }
2383  while ((c_n!=NULL)&&(!n_IsOne(hzz,r->cf->extRing->cf)))
2384  { // each monom: coeff in Q (Z)
2385  d=n_Gcd(hzz,pGetCoeff(c_n),r->cf->extRing->cf);
2386  n_Delete(&hzz,r->cf->extRing->cf);
2387  hzz=d;
2388  pIter(c_n);
2389  }
2390  pIter(p);
2391  }
2392  // hzz contains the gcd of all numerators in f
2393  h=n_Invers(hzz,r->cf->extRing->cf);
2394  n_Delete(&hzz,r->cf->extRing->cf);
2395  n_Normalize(h,r->cf->extRing->cf);
2396  if(!n_IsOne(h,r->cf->extRing->cf))
2397  {
2398  p=ph;
2399  while (p!=NULL)
2400  { // each monom: coeff in Q_a (Z_a)
2401  fraction f=(fraction)pGetCoeff(p);
2402  NUM(f)=p_Mult_nn(NUM(f),h,r->cf->extRing);
2403  p_Normalize(NUM(f),r->cf->extRing);
2404  pIter(p);
2405  }
2406  }
2407  n_Delete(&h,r->cf->extRing->cf);
2408  }*/
2409  }
2410  }
2411  if(!n_GreaterZero(pGetCoeff(ph),r->cf)) ph = p_Neg(ph,r);
2412 }
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:533
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
Definition: coeffs.h:38
return P p
Definition: myNF.cc:203
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the one element.
Definition: coeffs.h:469
#define TEST_OPT_CONTENTSB
Definition: options.h:121
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:539
static BOOLEAN rField_is_Q_a(const ring r)
Definition: ring.h:485
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition: coeffs.h:579
int k
Definition: cfEzgcd.cc:93
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:718
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
Definition: coeffs.h:829
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:407
#define pIter(p)
Definition: monomials.h:44
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of &#39;a&#39; and &#39;b&#39;, i.e., a*b
Definition: coeffs.h:637
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:931
const ring r
Definition: syzextra.cc:208
This is a polynomial enumerator for simple iteration over coefficients of polynomials.
#define assume(x)
Definition: mod2.h:405
The main handler for Singular numbers which are suitable for Singular polynomials.
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
Definition: coeffs.h:739
static FORCE_INLINE number n_Invers(number a, const coeffs r)
return the multiplicative inverse of &#39;a&#39;; raise an error if &#39;a&#39; is not invertible ...
Definition: coeffs.h:565
static number p_InitContent(poly ph, const ring r)
Definition: p_polys.cc:2474
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:458
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
#define p_Test(p, r)
Definition: p_polys.h:160
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:434
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of &#39;n&#39;
Definition: coeffs.h:452
used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic ...
Definition: coeffs.h:35
#define pNext(p)
Definition: monomials.h:43
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:623
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
Definition: coeffs.h:689
static poly p_Neg(poly p, const ring r)
Definition: p_polys.h:1019
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
static FORCE_INLINE BOOLEAN n_GreaterZero(number n, const coeffs r)
ordered fields: TRUE iff &#39;n&#39; is positive; in Z/pZ: TRUE iff 0 < m <= roundedBelow(p/2), where m is the long representing n in C: TRUE iff (Im(n) != 0 and Im(n) >= 0) or (Im(n) == 0 and Re(n) >= 0) in K(a)/<p(a)>: TRUE iff (n != 0 and (LC(n) > 0 or deg(n) > 0)) in K(t_1, ..., t_n): TRUE iff (LC(numerator(n) is a constant and > 0) or (LC(numerator(n) is not a constant) in Z/2^kZ: TRUE iff 0 < n <= 2^(k-1) in Z/mZ: TRUE iff the internal mpz is greater than zero in Z: TRUE iff n > 0
Definition: coeffs.h:495
polyrec * poly
Definition: hilb.h:10
static BOOLEAN rField_has_Units(const ring r)
Definition: ring.h:440
static Poly * h
Definition: janet.cc:978
void p_ContentRat ( poly ph,
const ring  r 
)

Definition at line 1655 of file p_polys.cc.

1658 {
1659  // init array of RatLeadCoeffs
1660  // poly p_GetCoeffRat(poly p, int ishift, ring r);
1661 
1662  int len=pLength(ph);
1663  poly *C = (poly *)omAlloc0((len+1)*sizeof(poly)); //rat coeffs
1664  poly *LM = (poly *)omAlloc0((len+1)*sizeof(poly)); // rat lead terms
1665  int *D = (int *)omAlloc0((len+1)*sizeof(int)); //degrees of coeffs
1666  int *L = (int *)omAlloc0((len+1)*sizeof(int)); //lengths of coeffs
1667  int k = 0;
1668  poly p = p_Copy(ph, r); // ph will be needed below
1669  int mintdeg = p_Totaldegree(p, r);
1670  int minlen = len;
1671  int dd = 0; int i;
1672  int HasConstantCoef = 0;
1673  int is = r->real_var_start - 1;
1674  while (p!=NULL)
1675  {
1676  LM[k] = p_GetExp_k_n(p,1,is, r); // need LmRat istead of p_HeadRat(p, is, currRing); !
1677  C[k] = p_GetCoeffRat(p, is, r);
1678  D[k] = p_Totaldegree(C[k], r);
1679  mintdeg = si_min(mintdeg,D[k]);
1680  L[k] = pLength(C[k]);
1681  minlen = si_min(minlen,L[k]);
1682  if (p_IsConstant(C[k], r))
1683  {
1684  // C[k] = const, so the content will be numerical
1685  HasConstantCoef = 1;
1686  // smth like goto cleanup and return(pContent(p));
1687  }
1688  p_LmDeleteAndNextRat(&p, is, r);
1689  k++;
1690  }
1691 
1692  // look for 1 element of minimal degree and of minimal length
1693  k--;
1694  poly d;
1695  int mindeglen = len;
1696  if (k<=0) // this poly is not a ratgring poly -> pContent
1697  {
1698  p_Delete(&C[0], r);
1699  p_Delete(&LM[0], r);
1700  p_Content(ph, r);
1701  goto cleanup;
1702  }
1703 
1704  int pmindeglen;
1705  for(i=0; i<=k; i++)
1706  {
1707  if (D[i] == mintdeg)
1708  {
1709  if (L[i] < mindeglen)
1710  {
1711  mindeglen=L[i];
1712  pmindeglen = i;
1713  }
1714  }
1715  }
1716  d = p_Copy(C[pmindeglen], r);
1717  // there are dd>=1 mindeg elements
1718  // and pmideglen is the coordinate of one of the smallest among them
1719 
1720  // poly g = singclap_gcd(p_Copy(p,r),p_Copy(q,r));
1721  // return naGcd(d,d2,currRing);
1722 
1723  // adjoin pContentRat here?
1724  for(i=0; i<=k; i++)
1725  {
1726  d=singclap_gcd(d,p_Copy(C[i], r), r);
1727  if (p_Totaldegree(d, r)==0)
1728  {
1729  // cleanup, pContent, return
1730  p_Delete(&d, r);
1731  for(;k>=0;k--)
1732  {
1733  p_Delete(&C[k], r);
1734  p_Delete(&LM[k], r);
1735  }
1736  p_Content(ph, r);
1737  goto cleanup;
1738  }
1739  }
1740  for(i=0; i<=k; i++)
1741  {
1742  poly h=singclap_pdivide(C[i],d, r);
1743  p_Delete(&C[i], r);
1744  C[i]=h;
1745  }
1746 
1747  // zusammensetzen,
1748  p=NULL; // just to be sure
1749  for(i=0; i<=k; i++)
1750  {
1751  p = p_Add_q(p, p_Mult_q(C[i],LM[i], r), r);
1752  C[i]=NULL; LM[i]=NULL;
1753  }
1754  p_Delete(&ph, r); // do not need it anymore
1755  ph = p;
1756  // aufraeumen, return
1757 cleanup:
1758  omFree(C);
1759  omFree(LM);
1760  omFree(D);
1761  omFree(L);
1762 }
#define D(A)
Definition: gentable.cc:119
static int si_min(const int a, const int b)
Definition: auxiliary.h:167
return P p
Definition: myNF.cc:203
poly singclap_gcd(poly f, poly g, const ring r)
destroys f and g
Definition: clapsing.cc:287
static long p_Totaldegree(poly p, const ring r)
Definition: p_polys.h:1436
int k
Definition: cfEzgcd.cc:93
poly singclap_pdivide(poly f, poly g, const ring r)
Definition: clapsing.cc:547
static int pLength(poly a)
Definition: p_polys.h:189
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition: p_polys.h:810
const ring r
Definition: syzextra.cc:208
#define omFree(addr)
Definition: omAllocDecl.h:261
static BOOLEAN p_IsConstant(const poly p, const ring r)
Definition: p_polys.h:1785
void p_LmDeleteAndNextRat(poly *p, int ishift, ring r)
Definition: p_polys.cc:1611
poly p_GetCoeffRat(poly p, int ishift, ring r)
Definition: p_polys.cc:1633
int i
Definition: cfEzgcd.cc:123
void p_Content(poly ph, const ring r)
Definition: p_polys.cc:2207
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:849
#define NULL
Definition: omList.c:10
static poly p_GetExp_k_n(poly p, int l, int k, const ring r)
Definition: p_polys.h:1301
polyrec * poly
Definition: hilb.h:10
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:883
static Poly * h
Definition: janet.cc:978
static poly p_Mult_q(poly p, poly q, const ring r)
Definition: p_polys.h:1026
#define omAlloc0(size)
Definition: omAllocDecl.h:211
static poly p_Copy ( poly  p,
const ring  r 
)
inlinestatic

returns a copy of p

Definition at line 810 of file p_polys.h.

811 {
812  p_Test(p,r);
813  const poly pp = p_Copy_noCheck(p, r);
814  p_Test(pp,r);
815  return pp;
816 }
return P p
Definition: myNF.cc:203
poly pp
Definition: myNF.cc:296
static poly p_Copy_noCheck(poly p, const ring r)
returns a copy of p (without any additional testing)
Definition: p_polys.h:803
const ring r
Definition: syzextra.cc:208
#define p_Test(p, r)
Definition: p_polys.h:160
polyrec * poly
Definition: hilb.h:10
static poly p_Copy ( poly  p,
const ring  lmRing,
const ring  tailRing 
)
inlinestatic

Definition at line 832 of file p_polys.h.

833 {
834  if (p != NULL)
835  {
836 #ifndef PDEBUG
837  if (tailRing == lmRing)
838  return p_Copy_noCheck(p, tailRing);
839 #endif
840  poly pres = p_Head(p, lmRing);
841  pNext(pres) = p_Copy_noCheck(pNext(p), tailRing);
842  return pres;
843  }
844  else
845  return NULL;
846 }
BEGIN_NAMESPACE_SINGULARXX const ring lmRing
Definition: DebugPrint.h:30
return P p
Definition: myNF.cc:203
BEGIN_NAMESPACE_SINGULARXX const ring const ring tailRing
Definition: DebugPrint.h:30
static poly p_Copy_noCheck(poly p, const ring r)
returns a copy of p (without any additional testing)
Definition: p_polys.h:803
static poly p_Head(poly p, const ring r)
Definition: p_polys.h:818
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
polyrec * poly
Definition: hilb.h:10
static poly p_Copy_noCheck ( poly  p,
const ring  r 
)
inlinestatic

returns a copy of p (without any additional testing)

Definition at line 803 of file p_polys.h.

804 {
805  assume(r != NULL); assume(r->p_Procs != NULL); assume(r->p_Procs->p_Copy != NULL);
806  return r->p_Procs->p_Copy(p, r);
807 }
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static long p_DecrExp ( poly  p,
int  v,
ring  r 
)
inlinestatic

Definition at line 593 of file p_polys.h.

594 {
596  int e = p_GetExp(p,v,r);
597  pAssume2(e > 0);
598  e--;
599  return p_SetExp(p,v,e,r);
600 }
#define p_LmCheckPolyRing2(p, r)
Definition: monomials.h:207
return P p
Definition: myNF.cc:203
#define pAssume2(cond)
Definition: monomials.h:201
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent : VarOffset encodes the position in p->exp
Definition: p_polys.h:483
long p_Deg ( poly  a,
const ring  r 
)

Definition at line 586 of file p_polys.cc.

587 {
589 // assume(p_GetOrder(a, r) == p_WTotaldegree(a, r)); // WRONG assume!
590  return p_GetOrder(a, r);
591 }
const poly a
Definition: syzextra.cc:212
const ring r
Definition: syzextra.cc:208
static long p_GetOrder(poly p, ring r)
Definition: p_polys.h:416
BOOLEAN p_LmCheckPolyRing(poly p, ring r)
Definition: pDebug.cc:119
long p_DegW ( poly  p,
const short *  w,
const ring  R 
)

Definition at line 689 of file p_polys.cc.

690 {
691  p_Test(p, R);
692  assume( w != NULL );
693  long r=-LONG_MAX;
694 
695  while (p!=NULL)
696  {
697  long t=totaldegreeWecart_IV(p,R,w);
698  if (t>r) r=t;
699  pIter(p);
700  }
701  return r;
702 }
return P p
Definition: myNF.cc:203
long totaldegreeWecart_IV(poly p, ring r, const short *w)
Definition: weight.cc:239
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
#define assume(x)
Definition: mod2.h:405
const ring R
Definition: DebugPrint.cc:36
#define p_Test(p, r)
Definition: p_polys.h:160
#define NULL
Definition: omList.c:10
const CanonicalForm & w
Definition: facAbsFact.cc:55
static void p_Delete ( poly p,
const ring  r 
)
inlinestatic

Definition at line 849 of file p_polys.h.

850 {
851  assume( p!= NULL );
852  r->p_Procs->p_Delete(p, r);
853 }
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static void p_Delete ( poly p,
const ring  lmRing,
const ring  tailRing 
)
inlinestatic

Definition at line 855 of file p_polys.h.

856 {
857  assume( p!= NULL );
858  if (*p != NULL)
859  {
860 #ifndef PDEBUG
861  if (tailRing == lmRing)
862  {
863  p_Delete(p, tailRing);
864  return;
865  }
866 #endif
867  if (pNext(*p) != NULL)
868  p_Delete(&pNext(*p), tailRing);
869  p_LmDelete(p, lmRing);
870  }
871 }
BEGIN_NAMESPACE_SINGULARXX const ring lmRing
Definition: DebugPrint.h:30
return P p
Definition: myNF.cc:203
BEGIN_NAMESPACE_SINGULARXX const ring const ring tailRing
Definition: DebugPrint.h:30
#define assume(x)
Definition: mod2.h:405
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:849
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:706
void p_DeleteComp ( poly p,
int  k,
const ring  r 
)

Definition at line 3437 of file p_polys.cc.

3438 {
3439  poly q;
3440 
3441  while ((*p!=NULL) && (p_GetComp(*p,r)==k)) p_LmDelete(p,r);
3442  if (*p==NULL) return;
3443  q = *p;
3444  if (p_GetComp(q,r)>k)
3445  {
3446  p_SubComp(q,1,r);
3447  p_SetmComp(q,r);
3448  }
3449  while (pNext(q)!=NULL)
3450  {
3451  if (p_GetComp(pNext(q),r)==k)
3452  p_LmDelete(&(pNext(q)),r);
3453  else
3454  {
3455  pIter(q);
3456  if (p_GetComp(q,r)>k)
3457  {
3458  p_SubComp(q,1,r);
3459  p_SetmComp(q,r);
3460  }
3461  }
3462  }
3463 }
return P p
Definition: myNF.cc:203
#define p_GetComp(p, r)
Definition: monomials.h:72
int k
Definition: cfEzgcd.cc:93
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
static unsigned long p_SubComp(poly p, unsigned long v, ring r)
Definition: p_polys.h:448
#define p_SetmComp
Definition: p_polys.h:239
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:706
polyrec * poly
Definition: hilb.h:10
poly p_Diff ( poly  a,
int  k,
const ring  r 
)

Definition at line 1809 of file p_polys.cc.

1810 {
1811  poly res, f, last;
1812  number t;
1813 
1814  last = res = NULL;
1815  while (a!=NULL)
1816  {
1817  if (p_GetExp(a,k,r)!=0)
1818  {
1819  f = p_LmInit(a,r);
1820  t = n_Init(p_GetExp(a,k,r),r->cf);
1821  pSetCoeff0(f,n_Mult(t,pGetCoeff(a),r->cf));
1822  n_Delete(&t,r->cf);
1823  if (n_IsZero(pGetCoeff(f),r->cf))
1824  p_LmDelete(&f,r);
1825  else
1826  {
1827  p_DecrExp(f,k,r);
1828  p_Setm(f,r);
1829  if (res==NULL)
1830  {
1831  res=last=f;
1832  }
1833  else
1834  {
1835  pNext(last)=f;
1836  last=f;
1837  }
1838  }
1839  }
1840  pIter(a);
1841  }
1842  return res;
1843 }
const poly a
Definition: syzextra.cc:212
static poly last
Definition: hdegree.cc:1075
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:539
int k
Definition: cfEzgcd.cc:93
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
#define pIter(p)
Definition: monomials.h:44
poly res
Definition: myNF.cc:322
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of &#39;a&#39; and &#39;b&#39;, i.e., a*b
Definition: coeffs.h:637
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
FILE * f
Definition: checklibs.c:7
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the zero element.
Definition: coeffs.h:465
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
static poly p_LmInit(poly p, const ring r)
Definition: p_polys.h:1264
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:228
#define pSetCoeff0(p, n)
Definition: monomials.h:67
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:706
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
static long p_DecrExp(poly p, int v, ring r)
Definition: p_polys.h:593
polyrec * poly
Definition: hilb.h:10
poly p_DiffOp ( poly  a,
poly  b,
BOOLEAN  multiply,
const ring  r 
)

Definition at line 1884 of file p_polys.cc.

1885 {
1886  poly result=NULL;
1887  poly h;
1888  for(;a!=NULL;pIter(a))
1889  {
1890  for(h=b;h!=NULL;pIter(h))
1891  {
1892  result=p_Add_q(result,p_DiffOpM(a,h,multiply,r),r);
1893  }
1894  }
1895  return result;
1896 }
const poly a
Definition: syzextra.cc:212
static poly p_DiffOpM(poly a, poly b, BOOLEAN multiply, const ring r)
Definition: p_polys.cc:1845
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
#define NULL
Definition: omList.c:10
polyrec * poly
Definition: hilb.h:10
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:883
static Poly * h
Definition: janet.cc:978
const poly b
Definition: syzextra.cc:213
return result
Definition: facAbsBiFact.cc:76
poly p_Div_nn ( poly  p,
const number  n,
const ring  r 
)

Definition at line 1480 of file p_polys.cc.

1481 {
1482  pAssume(!n_IsZero(n,r->cf));
1483  p_Test(p, r);
1484 
1485  poly q = p;
1486  while (p != NULL)
1487  {
1488  number nc = pGetCoeff(p);
1489  pSetCoeff0(p, n_Div(nc, n, r->cf));
1490  n_Delete(&nc, r->cf);
1491  pIter(p);
1492  }
1493  p_Test(q, r);
1494  return q;
1495 }
return P p
Definition: myNF.cc:203
#define pAssume(cond)
Definition: monomials.h:98
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the zero element.
Definition: coeffs.h:465
#define p_Test(p, r)
Definition: p_polys.h:160
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of &#39;a&#39; and &#39;b&#39;, i.e., a/b; raises an error if &#39;b&#39; is not invertible in r exceptio...
Definition: coeffs.h:616
#define pSetCoeff0(p, n)
Definition: monomials.h:67
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
polyrec * poly
Definition: hilb.h:10
poly p_Divide ( poly  a,
poly  b,
const ring  r 
)

Definition at line 1467 of file p_polys.cc.

1468 {
1469  assume((p_GetComp(a,r)==p_GetComp(b,r)) || (p_GetComp(b,r)==0));
1470  int i;
1471  poly result = p_Init(r);
1472 
1473  for(i=(int)r->N; i; i--)
1474  p_SetExp(result,i, p_GetExp(a,i,r)- p_GetExp(b,i,r),r);
1475  p_SetComp(result, p_GetComp(a,r) - p_GetComp(b,r),r);
1476  p_Setm(result,r);
1477  return result;
1478 }
const poly a
Definition: syzextra.cc:212
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition: p_polys.h:242
#define p_GetComp(p, r)
Definition: monomials.h:72
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
#define assume(x)
Definition: mod2.h:405
int i
Definition: cfEzgcd.cc:123
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent : VarOffset encodes the position in p->exp
Definition: p_polys.h:483
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:228
polyrec * poly
Definition: hilb.h:10
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1249
const poly b
Definition: syzextra.cc:213
return result
Definition: facAbsBiFact.cc:76
poly p_DivideM ( poly  a,
poly  b,
const ring  r 
)

Definition at line 1501 of file p_polys.cc.

1502 {
1503  if (a==NULL) { p_Delete(&b,r); return NULL; }
1504  poly result=a;
1505  poly prev=NULL;
1506  int i;
1507 #ifdef HAVE_RINGS
1508  number inv=pGetCoeff(b);
1509 #else
1510  number inv=n_Invers(pGetCoeff(b),r->cf);
1511 #endif
1512 
1513  while (a!=NULL)
1514  {
1515  if (p_DivisibleBy(b,a,r))
1516  {
1517  for(i=(int)r->N; i; i--)
1518  p_SubExp(a,i, p_GetExp(b,i,r),r);
1519  p_SubComp(a, p_GetComp(b,r),r);
1520  p_Setm(a,r);
1521  prev=a;
1522  pIter(a);
1523  }
1524  else
1525  {
1526  if (prev==NULL)
1527  {
1528  p_LmDelete(&result,r);
1529  a=result;
1530  }
1531  else
1532  {
1533  p_LmDelete(&pNext(prev),r);
1534  a=pNext(prev);
1535  }
1536  }
1537  }
1538 #ifdef HAVE_RINGS
1539  if (n_IsUnit(inv,r->cf))
1540  {
1541  inv = n_Invers(inv,r->cf);
1542  p_Mult_nn(result,inv,r);
1543  n_Delete(&inv, r->cf);
1544  }
1545  else
1546  {
1547  p_Div_nn(result,inv,r);
1548  }
1549 #else
1550  p_Mult_nn(result,inv,r);
1551  n_Delete(&inv, r->cf);
1552 #endif
1553  p_Delete(&b, r);
1554  return result;
1555 }
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:516
const poly a
Definition: syzextra.cc:212
#define p_GetComp(p, r)
Definition: monomials.h:72
poly p_Div_nn(poly p, const number n, const ring r)
Definition: p_polys.cc:1480
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
static long p_SubExp(poly p, int v, long ee, ring r)
Definition: p_polys.h:608
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
static BOOLEAN p_DivisibleBy(poly a, poly b, const ring r)
Definition: p_polys.h:1686
static FORCE_INLINE number n_Invers(number a, const coeffs r)
return the multiplicative inverse of &#39;a&#39;; raise an error if &#39;a&#39; is not invertible ...
Definition: coeffs.h:565
int i
Definition: cfEzgcd.cc:123
static poly p_Mult_nn(poly p, number n, const ring r)
Definition: p_polys.h:901
static unsigned long p_SubComp(poly p, unsigned long v, ring r)
Definition: p_polys.h:448
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:849
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:228
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:706
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
polyrec * poly
Definition: hilb.h:10
const poly b
Definition: syzextra.cc:213
return result
Definition: facAbsBiFact.cc:76
static BOOLEAN p_DivisibleBy ( poly  a,
poly  b,
const ring  r 
)
inlinestatic

Definition at line 1686 of file p_polys.h.

1687 {
1690 
1691  if (a != NULL && (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r)))
1692  return _p_LmDivisibleByNoComp(a,b,r);
1693  return FALSE;
1694 }
const poly a
Definition: syzextra.cc:212
#define FALSE
Definition: auxiliary.h:140
#define p_GetComp(p, r)
Definition: monomials.h:72
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:1547
const ring r
Definition: syzextra.cc:208
#define p_LmCheckPolyRing1(p, r)
Definition: monomials.h:185
#define pIfThen1(cond, check)
Definition: monomials.h:187
#define NULL
Definition: omList.c:10
const poly b
Definition: syzextra.cc:213
static BOOLEAN p_DivisibleBy ( poly  a,
const ring  r_a,
poly  b,
const ring  r_b 
)
inlinestatic

Definition at line 1695 of file p_polys.h.

1696 {
1697  pIfThen1(b!=NULL, p_LmCheckPolyRing1(b, r_b));
1698  pIfThen1(a!=NULL, p_LmCheckPolyRing1(a, r_a));
1699  if (a != NULL) {
1700  return _p_LmDivisibleBy(a, r_a, b, r_b);
1701  }
1702  return FALSE;
1703 }
const poly a
Definition: syzextra.cc:212
#define FALSE
Definition: auxiliary.h:140
static BOOLEAN _p_LmDivisibleBy(poly a, poly b, const ring r)
Definition: p_polys.h:1651
#define p_LmCheckPolyRing1(p, r)
Definition: monomials.h:185
#define pIfThen1(cond, check)
Definition: monomials.h:187
#define NULL
Definition: omList.c:10
const poly b
Definition: syzextra.cc:213
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 1559 of file p_polys.cc.

1560 {
1561  int exponent;
1562  for(int i = (int)rVar(r); i>0; i--)
1563  {
1564  exponent = p_GetExp(g, i, r) - p_GetExp(f, i, r);
1565  if (exponent < 0) return FALSE;
1566  }
1567  return n_DivBy(pGetCoeff(g), pGetCoeff(f), r->cf);
1568 }
#define FALSE
Definition: auxiliary.h:140
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:537
g
Definition: cfModGcd.cc:4031
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
static FORCE_INLINE BOOLEAN n_DivBy(number a, number b, const coeffs r)
test whether &#39;a&#39; is divisible &#39;b&#39;; for r encoding a field: TRUE iff &#39;b&#39; does not represent zero in Z:...
Definition: coeffs.h:776
FILE * f
Definition: checklibs.c:7
int i
Definition: cfEzgcd.cc:123
int exponent(const CanonicalForm &f, int q)
int exponent ( const CanonicalForm & f, int q )
BOOLEAN p_EqualPolys ( poly  p1,
poly  p2,
const ring  r 
)

Definition at line 4318 of file p_polys.cc.

4319 {
4320  while ((p1 != NULL) && (p2 != NULL))
4321  {
4322  if (! p_LmEqual(p1, p2,r))
4323  return FALSE;
4324  if (! n_Equal(p_GetCoeff(p1,r), p_GetCoeff(p2,r),r->cf ))
4325  return FALSE;
4326  pIter(p1);
4327  pIter(p2);
4328  }
4329  return (p1==p2);
4330 }
#define FALSE
Definition: auxiliary.h:140
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
#define p_LmEqual(p1, p2, r)
Definition: p_polys.h:1520
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN n_Equal(number a, number b, const coeffs r)
TRUE iff &#39;a&#39; and &#39;b&#39; represent the same number; they may have different representations.
Definition: coeffs.h:461
#define p_GetCoeff(p, r)
Definition: monomials.h:57
END_NAMESPACE const void * p2
Definition: syzextra.cc:202
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 4356 of file p_polys.cc.

4357 {
4358  assume( r1 == r2 || rSamePolyRep(r1, r2) ); // will be used in rEqual!
4359  assume( r1->cf == r2->cf );
4360 
4361  while ((p1 != NULL) && (p2 != NULL))
4362  {
4363  // returns 1 if ExpVector(p)==ExpVector(q): does not compare numbers !!
4364  // #define p_LmEqual(p1, p2, r) p_ExpVectorEqual(p1, p2, r)
4365 
4366  if (! p_ExpVectorEqual(p1, p2, r1, r2))
4367  return FALSE;
4368 
4369  if (! n_Equal(p_GetCoeff(p1,r1), p_GetCoeff(p2,r2), r1->cf ))
4370  return FALSE;
4371 
4372  pIter(p1);
4373  pIter(p2);
4374  }
4375  return (p1==p2);
4376 }
#define FALSE
Definition: auxiliary.h:140
#define pIter(p)
Definition: monomials.h:44
#define assume(x)
Definition: mod2.h:405
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:1681
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN n_Equal(number a, number b, const coeffs r)
TRUE iff &#39;a&#39; and &#39;b&#39; represent the same number; they may have different representations.
Definition: coeffs.h:461
#define p_GetCoeff(p, r)
Definition: monomials.h:57
END_NAMESPACE const void * p2
Definition: syzextra.cc:202
static BOOLEAN p_ExpVectorEqual(poly p1, poly p2, const ring r1, const ring r2)
Definition: p_polys.cc:4332
static void p_ExpVectorAdd ( poly  p1,
poly  p2,
const ring  r 
)
inlinestatic

Definition at line 1340 of file p_polys.h.

1341 {
1342  p_LmCheckPolyRing1(p1, r);
1344 #if PDEBUG >= 1
1345  for (int i=1; i<=r->N; i++)
1346  pAssume1((unsigned long) (p_GetExp(p1, i, r) + p_GetExp(p2, i, r)) <= r->bitmask);
1347  pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0);
1348 #endif
1349 
1350  p_MemAdd_LengthGeneral(p1->exp, p2->exp, r->ExpL_Size);
1352 }
#define p_GetComp(p, r)
Definition: monomials.h:72
const ring r
Definition: syzextra.cc:208
#define p_MemAdd_LengthGeneral(r, s, length)
Definition: p_MemAdd.h:173
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
static void p_MemAdd_NegWeightAdjust(poly p, const ring r)
Definition: p_polys.h:1221
int i
Definition: cfEzgcd.cc:123
#define p_LmCheckPolyRing1(p, r)
Definition: monomials.h:185
END_NAMESPACE const void * p2
Definition: syzextra.cc:202
#define pAssume1(cond)
Definition: monomials.h:179
static void p_ExpVectorAddSub ( poly  p1,
poly  p2,
poly  p3,
const ring  r 
)
inlinestatic

Definition at line 1385 of file p_polys.h.

1386 {
1387  p_LmCheckPolyRing1(p1, r);
1389  p_LmCheckPolyRing1(p3, r);
1390 #if PDEBUG >= 1
1391  for (int i=1; i<=r->N; i++)
1392  pAssume1(p_GetExp(p1, i, r) + p_GetExp(p2, i, r) >= p_GetExp(p3, i, r));
1393  pAssume1(p_GetComp(p1, r) == 0 ||
1394  (p_GetComp(p2, r) - p_GetComp(p3, r) == 0) ||
1395  (p_GetComp(p1, r) == p_GetComp(p2, r) - p_GetComp(p3, r)));
1396 #endif
1397 
1398  p_MemAddSub_LengthGeneral(p1->exp, p2->exp, p3->exp, r->ExpL_Size);
1399  // no need to adjust in case of NegWeights
1400 }
#define p_GetComp(p, r)
Definition: monomials.h:72
#define p_MemAddSub_LengthGeneral(r, s, t, length)
Definition: p_MemAdd.h:312
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
int i
Definition: cfEzgcd.cc:123
#define p_LmCheckPolyRing1(p, r)
Definition: monomials.h:185
END_NAMESPACE const void * p2
Definition: syzextra.cc:202
#define pAssume1(cond)
Definition: monomials.h:179
static void p_ExpVectorCopy ( poly  d_p,
poly  s_p,
const ring  r 
)
inlinestatic

Definition at line 1242 of file p_polys.h.

1243 {
1244  p_LmCheckPolyRing1(d_p, r);
1245  p_LmCheckPolyRing1(s_p, r);
1246  memcpy(d_p->exp, s_p->exp, r->ExpL_Size*sizeof(long));
1247 }
const ring r
Definition: syzextra.cc:208
#define p_LmCheckPolyRing1(p, r)
Definition: monomials.h:185
static void p_ExpVectorDiff ( poly  pr,
poly  p1,
poly  p2,
const ring  r 
)
inlinestatic

Definition at line 1403 of file p_polys.h.

1404 {
1405  p_LmCheckPolyRing1(p1, r);
1407  p_LmCheckPolyRing1(pr, r);
1408 #if PDEBUG >= 2
1409  for (int i=1; i<=r->N; i++)
1410  pAssume1(p_GetExp(p1, i, r) >= p_GetExp(p2, i, r));
1411  pAssume1(!rRing_has_Comp(r) || p_GetComp(p1, r) == p_GetComp(p2, r));
1412 #endif
1413 
1414  p_MemDiff_LengthGeneral(pr->exp, p1->exp, p2->exp, r->ExpL_Size);
1416 }
#define p_GetComp(p, r)
Definition: monomials.h:72
static void p_MemSub_NegWeightAdjust(poly p, const ring r)
Definition: p_polys.h:1231
const ring r
Definition: syzextra.cc:208
#define p_MemDiff_LengthGeneral(r, s1, s2, length)
Definition: p_MemAdd.h:262
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
int i
Definition: cfEzgcd.cc:123
#define p_LmCheckPolyRing1(p, r)
Definition: monomials.h:185
#define rRing_has_Comp(r)
Definition: monomials.h:274
END_NAMESPACE const void * p2
Definition: syzextra.cc:202
#define pAssume1(cond)
Definition: monomials.h:179
static BOOLEAN p_ExpVectorEqual ( poly  p1,
poly  p2,
const ring  r 
)
inlinestatic

Definition at line 1418 of file p_polys.h.

1419 {
1420  p_LmCheckPolyRing1(p1, r);
1422 
1423  int i = r->ExpL_Size;
1424  unsigned long *ep = p1->exp;
1425  unsigned long *eq = p2->exp;
1426 
1427  do
1428  {
1429  i--;
1430  if (ep[i] != eq[i]) return FALSE;
1431  }
1432  while (i);
1433  return TRUE;
1434 }
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
const ring r
Definition: syzextra.cc:208
int i
Definition: cfEzgcd.cc:123
#define p_LmCheckPolyRing1(p, r)
Definition: monomials.h:185
END_NAMESPACE const void * p2
Definition: syzextra.cc:202
static void p_ExpVectorSub ( poly  p1,
poly  p2,
const ring  r 
)
inlinestatic

Definition at line 1369 of file p_polys.h.

1370 {
1371  p_LmCheckPolyRing1(p1, r);
1373 #if PDEBUG >= 1
1374  for (int i=1; i<=r->N; i++)
1375  pAssume1(p_GetExp(p1, i, r) >= p_GetExp(p2, i, r));
1376  pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0 ||
1377  p_GetComp(p1, r) == p_GetComp(p2, r));
1378 #endif
1379 
1380  p_MemSub_LengthGeneral(p1->exp, p2->exp, r->ExpL_Size);
1382 
1383 }
#define p_GetComp(p, r)
Definition: monomials.h:72
static void p_MemSub_NegWeightAdjust(poly p, const ring r)
Definition: p_polys.h:1231
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
int i
Definition: cfEzgcd.cc:123
#define p_LmCheckPolyRing1(p, r)
Definition: monomials.h:185
#define p_MemSub_LengthGeneral(r, s, length)
Definition: p_MemAdd.h:291
END_NAMESPACE const void * p2
Definition: syzextra.cc:202
#define pAssume1(cond)
Definition: monomials.h:179
static void p_ExpVectorSum ( poly  pr,
poly  p1,
poly  p2,
const ring  r 
)
inlinestatic

Definition at line 1354 of file p_polys.h.

1355 {
1356  p_LmCheckPolyRing1(p1, r);
1358  p_LmCheckPolyRing1(pr, r);
1359 #if PDEBUG >= 1
1360  for (int i=1; i<=r->N; i++)
1361  pAssume1((unsigned long) (p_GetExp(p1, i, r) + p_GetExp(p2, i, r)) <= r->bitmask);
1362  pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0);
1363 #endif
1364 
1365  p_MemSum_LengthGeneral(pr->exp, p1->exp, p2->exp, r->ExpL_Size);
1367 }
#define p_MemSum_LengthGeneral(r, s1, s2, length)
Definition: p_MemAdd.h:86
#define p_GetComp(p, r)
Definition: monomials.h:72
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
static void p_MemAdd_NegWeightAdjust(poly p, const ring r)
Definition: p_polys.h:1221
int i
Definition: cfEzgcd.cc:123
#define p_LmCheckPolyRing1(p, r)
Definition: monomials.h:185
END_NAMESPACE const void * p2
Definition: syzextra.cc:202
#define pAssume1(cond)
Definition: monomials.h:179
poly p_Farey ( poly  p,
number  N,
const ring  r 
)

Definition at line 61 of file p_polys.cc.

62 {
63  poly h=p_Copy(p,r);
64  poly hh=h;
65  while(h!=NULL)
66  {
67  number c=pGetCoeff(h);
68  pSetCoeff0(h,n_Farey(c,N,r->cf));
69  n_Delete(&c,r->cf);
70  pIter(h);
71  }
72  while((hh!=NULL)&&(n_IsZero(pGetCoeff(hh),r->cf)))
73  {
74  p_LmDelete(&hh,r);
75  }
76  h=hh;
77  while((h!=NULL) && (pNext(h)!=NULL))
78  {
79  if(n_IsZero(pGetCoeff(pNext(h)),r->cf))
80  {
81  p_LmDelete(&pNext(h),r);
82  }
83  else pIter(h);
84  }
85  return hh;
86 }
return P p
Definition: myNF.cc:203
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition: p_polys.h:810
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:49
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the zero element.
Definition: coeffs.h:465
static FORCE_INLINE number n_Farey(number a, number b, const coeffs r)
Definition: coeffs.h:790
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
#define pSetCoeff0(p, n)
Definition: monomials.h:67
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:706
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
polyrec * poly
Definition: hilb.h:10
static Poly * h
Definition: janet.cc:978
static long p_FDeg ( const poly  p,
const ring  r 
)
inlinestatic

Definition at line 375 of file p_polys.h.

375 { return r->pFDeg(p,r); }
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208
poly p_GetCoeffRat ( poly  p,
int  ishift,
ring  r 
)

Definition at line 1633 of file p_polys.cc.

1634 {
1635  poly q = pNext(p);
1636  poly res; // = p_Head(p,r);
1637  res = p_GetExp_k_n(p, ishift+1, r->N, r); // does pSetm internally
1638  p_SetCoeff(res,n_Copy(p_GetCoeff(p,r),r),r);
1639  poly s;
1640  long cmp = p_GetComp(p, r);
1641  while ( (q!= NULL) && (p_Comp_k_n(p, q, ishift+1, r)) && (p_GetComp(q, r) == cmp) )
1642  {
1643  s = p_GetExp_k_n(q, ishift+1, r->N, r);
1644  p_SetCoeff(s,n_Copy(p_GetCoeff(q,r),r),r);
1645  res = p_Add_q(res,s,r);
1646  q = pNext(q);
1647  }
1648  cmp = 0;
1649  p_SetCompP(res,cmp,r);
1650  return res;
1651 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
return P p
Definition: myNF.cc:203
#define p_GetComp(p, r)
Definition: monomials.h:72
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:407
poly res
Definition: myNF.cc:322
const ring r
Definition: syzextra.cc:208
static int p_Comp_k_n(poly a, poly b, int k, ring r)
Definition: p_polys.h:635
static void p_SetCompP(poly p, int i, ring r)
Definition: p_polys.h:249
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of &#39;n&#39;
Definition: coeffs.h:452
#define pNext(p)
Definition: monomials.h:43
#define p_GetCoeff(p, r)
Definition: monomials.h:57
static poly p_GetExp_k_n(poly p, int l, int k, const ring r)
Definition: p_polys.h:1301
polyrec * poly
Definition: hilb.h:10
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:883
static long p_GetExp ( const poly  p,
const unsigned long  iBitmask,
const int  VarOffset 
)
inlinestatic

get a single variable exponent : 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 464 of file p_polys.h.

465 {
466  pAssume2((VarOffset >> (24 + 6)) == 0);
467 #if 0
468  int pos=(VarOffset & 0xffffff);
469  int bitpos=(VarOffset >> 24);
470  unsigned long exp=(p->exp[pos] >> bitmask) & iBitmask;
471  return exp;
472 #else
473  return (long)
474  ((p->exp[(VarOffset & 0xffffff)] >> (VarOffset >> 24))
475  & iBitmask);
476 #endif
477 }
return P p
Definition: myNF.cc:203
#define pAssume2(cond)
Definition: monomials.h:201
p exp[i]
Definition: DebugPrint.cc:39
static long p_GetExp ( const poly  p,
const ring  r,
const int  VarOffset 
)
inlinestatic

Definition at line 550 of file p_polys.h.

551 {
553  pAssume2(VarOffset != -1);
554  return p_GetExp(p, r->bitmask, VarOffset);
555 }
#define p_LmCheckPolyRing2(p, r)
Definition: monomials.h:207
return P p
Definition: myNF.cc:203
#define pAssume2(cond)
Definition: monomials.h:201
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
static long p_GetExp ( const poly  p,
const int  v,
const ring  r 
)
inlinestatic

get v^th exponent for a monomial

Definition at line 567 of file p_polys.h.

568 {
570  pAssume2(v>0 && v <= r->N);
571  pAssume2(r->VarOffset[v] != -1);
572  return p_GetExp(p, r->bitmask, r->VarOffset[v]);
573 }
#define p_LmCheckPolyRing2(p, r)
Definition: monomials.h:207
return P p
Definition: myNF.cc:203
#define pAssume2(cond)
Definition: monomials.h:201
const ring r
Definition: syzextra.cc:208
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:49
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
static poly p_GetExp_k_n ( poly  p,
int  l,
int  k,
const ring  r 
)
inlinestatic

Definition at line 1301 of file p_polys.h.

1302 {
1303  if (p == NULL) return NULL;
1305  poly np;
1306  omTypeAllocBin(poly, np, r->PolyBin);
1307  p_SetRingOfLm(np, r);
1308  memcpy(np->exp, p->exp, r->ExpL_Size*sizeof(long));
1309  pNext(np) = NULL;
1310  pSetCoeff0(np, n_Init(1, r->cf));
1311  int i;
1312  for(i=l;i<=k;i++)
1313  {
1314  //np->exp[(r->VarOffset[i] & 0xffffff)] =0;
1315  p_SetExp(np,i,0,r);
1316  }
1317  p_Setm(np,r);
1318  return np;
1319 }
return P p
Definition: myNF.cc:203
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:539
int k
Definition: cfEzgcd.cc:93
#define omTypeAllocBin(type, addr, bin)
Definition: omAllocDecl.h:203
const ring r
Definition: syzextra.cc:208
#define p_SetRingOfLm(p, r)
Definition: monomials.h:152
int i
Definition: cfEzgcd.cc:123
#define p_LmCheckPolyRing1(p, r)
Definition: monomials.h:185
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent : VarOffset encodes the position in p->exp
Definition: p_polys.h:483
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:228
#define pSetCoeff0(p, n)
Definition: monomials.h:67
polyrec * poly
Definition: hilb.h:10
int l
Definition: cfEzgcd.cc:94
static long p_GetExpDiff ( poly  p1,
poly  p2,
int  i,
ring  r 
)
inlinestatic

Definition at line 630 of file p_polys.h.

631 {
632  return p_GetExp(p1,i,r) - p_GetExp(p2,i,r);
633 }
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
int i
Definition: cfEzgcd.cc:123
END_NAMESPACE const void * p2
Definition: syzextra.cc:202
static long p_GetExpSum ( poly  p1,
poly  p2,
int  i,
ring  r 
)
inlinestatic

Definition at line 624 of file p_polys.h.

625 {
626  p_LmCheckPolyRing2(p1, r);
628  return p_GetExp(p1,i,r) + p_GetExp(p2,i,r);
629 }
#define p_LmCheckPolyRing2(p, r)
Definition: monomials.h:207
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
int i
Definition: cfEzgcd.cc:123
END_NAMESPACE const void * p2
Definition: syzextra.cc:202
static void p_GetExpV ( poly  p,
int *  ev,
const ring  r 
)
inlinestatic

Definition at line 1449 of file p_polys.h.

1450 {
1452  for (int j = r->N; j; j--)
1453  ev[j] = p_GetExp(p, j, r);
1454 
1455  ev[0] = p_GetComp(p, r);
1456 }
return P p
Definition: myNF.cc:203
#define p_GetComp(p, r)
Definition: monomials.h:72
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
int j
Definition: myNF.cc:70
#define p_LmCheckPolyRing1(p, r)
Definition: monomials.h:185
static unsigned long p_GetMaxExp ( const unsigned long  l,
const ring  r 
)
inlinestatic

Definition at line 742 of file p_polys.h.

743 {
744  unsigned long bitmask = r->bitmask;
745  unsigned long max = (l & bitmask);
746  unsigned long j = r->ExpPerLong - 1;
747 
748  if (j > 0)
749  {
750  unsigned long i = r->BitsPerExp;
751  long e;
752  loop
753  {
754  e = ((l >> i) & bitmask);
755  if ((unsigned long) e > max)
756  max = e;
757  j--;
758  if (j==0) break;
759  i += r->BitsPerExp;
760  }
761  }
762  return max;
763 }
loop
Definition: myNF.cc:98
const ring r
Definition: syzextra.cc:208
int j
Definition: myNF.cc:70
static int max(int a, int b)
Definition: fast_mult.cc:264
int i
Definition: cfEzgcd.cc:123
int l
Definition: cfEzgcd.cc:94
static unsigned long p_GetMaxExp ( const poly  p,
const ring  r 
)
inlinestatic

Definition at line 765 of file p_polys.h.

766 {
767  return p_GetMaxExp(p_GetMaxExpL(p, r), r);
768 }
return P p
Definition: myNF.cc:203
static unsigned long p_GetMaxExp(const unsigned long l, const ring r)
Definition: p_polys.h:742
const ring r
Definition: syzextra.cc:208
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:1174
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 1174 of file p_polys.cc.

1175 {
1176  unsigned long l_p, divmask = r->divmask;
1177  int i;
1178 
1179  while (p != NULL)
1180  {
1181  l_p = p->exp[r->VarL_Offset[0]];
1182  if (l_p > l_max ||
1183  (((l_max & divmask) ^ (l_p & divmask)) != ((l_max-l_p) & divmask)))
1184  l_max = p_GetMaxExpL2(l_max, l_p, r);
1185  for (i=1; i<r->VarL_Size; i++)
1186  {
1187  l_p = p->exp[r->VarL_Offset[i]];
1188  // do the divisibility trick to find out whether l has an exponent
1189  if (l_p > l_max ||
1190  (((l_max & divmask) ^ (l_p & divmask)) != ((l_max-l_p) & divmask)))
1191  l_max = p_GetMaxExpL2(l_max, l_p, r);
1192  }
1193  pIter(p);
1194  }
1195  return l_max;
1196 }
return P p
Definition: myNF.cc:203
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
static unsigned long p_GetMaxExpL2(unsigned long l1, unsigned long l2, const ring r, unsigned long number_of_exp)
Definition: p_polys.cc:1106
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 1137 of file p_polys.cc.

1138 {
1139  p_CheckPolyRing(p, r);
1140  if (p == NULL) return p_Init(r);
1141  poly max = p_LmInit(p, r);
1142  pIter(p);
1143  if (p == NULL) return max;
1144  int i, offset;
1145  unsigned long l_p, l_max;
1146  unsigned long divmask = r->divmask;
1147 
1148  do
1149  {
1150  offset = r->VarL_Offset[0];
1151  l_p = p->exp[offset];
1152  l_max = max->exp[offset];
1153  // do the divisibility trick to find out whether l has an exponent
1154  if (l_p > l_max ||
1155  (((l_max & divmask) ^ (l_p & divmask)) != ((l_max-l_p) & divmask)))
1156  max->exp[offset] = p_GetMaxExpL2(l_max, l_p, r);
1157 
1158  for (i=1; i<r->VarL_Size; i++)
1159  {
1160  offset = r->VarL_Offset[i];
1161  l_p = p->exp[offset];
1162  l_max = max->exp[offset];
1163  // do the divisibility trick to find out whether l has an exponent
1164  if (l_p > l_max ||
1165  (((l_max & divmask) ^ (l_p & divmask)) != ((l_max-l_p) & divmask)))
1166  max->exp[offset] = p_GetMaxExpL2(l_max, l_p, r);
1167  }
1168  pIter(p);
1169  }
1170  while (p != NULL);
1171  return max;
1172 }
return P p
Definition: myNF.cc:203
#define pIter(p)
Definition: monomials.h:44
BOOLEAN p_CheckPolyRing(poly p, ring r)
Definition: pDebug.cc:111
const ring r
Definition: syzextra.cc:208
static int max(int a, int b)
Definition: fast_mult.cc:264
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
static poly p_LmInit(poly p, const ring r)
Definition: p_polys.h:1264
static unsigned long p_GetMaxExpL2(unsigned long l1, unsigned long l2, const ring r, unsigned long number_of_exp)
Definition: p_polys.cc:1106
polyrec * poly
Definition: hilb.h:10
int offset
Definition: libparse.cc:1091
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1249
static long p_GetOrder ( poly  p,
ring  r 
)
inlinestatic

Definition at line 416 of file p_polys.h.

417 {
419  if (r->typ==NULL) return ((p)->exp[r->pOrdIndex]);
420  int i=0;
421  loop
422  {
423  switch(r->typ[i].ord_typ)
424  {
425  case ro_am:
426  case ro_wp_neg:
427  return ((p->exp[r->pOrdIndex])-POLY_NEGWEIGHT_OFFSET);
428  case ro_syzcomp:
429  case ro_syz:
430  case ro_cp:
431  i++;
432  break;
433  //case ro_dp:
434  //case ro_wp:
435  default:
436  return ((p)->exp[r->pOrdIndex]);
437  }
438  }
439 }
#define p_LmCheckPolyRing2(p, r)
Definition: monomials.h:207
Definition: ring.h:68
#define POLY_NEGWEIGHT_OFFSET
Definition: monomials.h:244
loop
Definition: myNF.cc:98
return P p
Definition: myNF.cc:203
Definition: ring.h:66
Definition: ring.h:64
const ring r
Definition: syzextra.cc:208
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
Definition: ring.h:62
p exp[i]
Definition: DebugPrint.cc:39
p_SetmProc p_GetSetmProc ( const ring  r)

Definition at line 559 of file p_polys.cc.

560 {
561  // covers lp, rp, ls,
562  if (r->typ == NULL) return p_Setm_Dummy;
563 
564  if (r->OrdSize == 1)
565  {
566  if (r->typ[0].ord_typ == ro_dp &&
567  r->typ[0].data.dp.start == 1 &&
568  r->typ[0].data.dp.end == r->N &&
569  r->typ[0].data.dp.place == r->pOrdIndex)
570  return p_Setm_TotalDegree;
571  if (r->typ[0].ord_typ == ro_wp &&
572  r->typ[0].data.wp.start == 1 &&
573  r->typ[0].data.wp.end == r->N &&
574  r->typ[0].data.wp.place == r->pOrdIndex &&
575  r->typ[0].data.wp.weights == r->firstwv)
577  }
578  return p_Setm_General;
579 }
void p_Setm_General(poly p, const ring r)
Definition: p_polys.cc:163
Definition: ring.h:61
void p_Setm_WFirstTotalDegree(poly p, const ring r)
Definition: p_polys.cc:553
void p_Setm_TotalDegree(poly p, const ring r)
Definition: p_polys.cc:546
const ring r
Definition: syzextra.cc:208
void p_Setm_Dummy(poly p, const ring r)
Definition: p_polys.cc:540
#define NULL
Definition: omList.c:10
Definition: ring.h:60
unsigned long p_GetShortExpVector ( const poly  a,
const ring  r 
)

Definition at line 4586 of file p_polys.cc.

4587 {
4588  assume(p != NULL);
4589  unsigned long ev = 0; // short exponent vector
4590  unsigned int n = BIT_SIZEOF_LONG / r->N; // number of bits per exp
4591  unsigned int m1; // highest bit which is filled with (n+1)
4592  int i=0,j=1;
4593 
4594  if (n == 0)
4595  {
4596  if (r->N <2*BIT_SIZEOF_LONG)
4597  {
4598  n=1;
4599  m1=0;
4600  }
4601  else
4602  {
4603  for (; j<=r->N; j++)
4604  {
4605  if (p_GetExp(p,j,r) > 0) i++;
4606  if (i == BIT_SIZEOF_LONG) break;
4607  }
4608  if (i>0)
4609  ev = ~(0UL) >> (BIT_SIZEOF_LONG - i);
4610  return ev;
4611  }
4612  }
4613  else
4614  {
4615  m1 = (n+1)*(BIT_SIZEOF_LONG - n*r->N);
4616  }
4617 
4618  n++;
4619  while (i<m1)
4620  {
4621  ev |= GetBitFields(p_GetExp(p, j,r), i, n);
4622  i += n;
4623  j++;
4624  }
4625 
4626  n--;
4627  while (i<BIT_SIZEOF_LONG)
4628  {
4629  ev |= GetBitFields(p_GetExp(p, j,r), i, n);
4630  i += n;
4631  j++;
4632  }
4633  return ev;
4634 }
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
int j
Definition: myNF.cc:70
#define assume(x)
Definition: mod2.h:405
int i
Definition: cfEzgcd.cc:123
static unsigned long GetBitFields(const long e, const unsigned int s, const unsigned int n)
Definition: p_polys.cc:4553
#define NULL
Definition: omList.c:10
#define BIT_SIZEOF_LONG
Definition: auxiliary.h:124
unsigned long p_GetShortExpVector ( const poly  p,
const poly  pp,
const ring  r 
)

p_GetShortExpVector of p * pp

Definition at line 4638 of file p_polys.cc.

4639 {
4640  assume(p != NULL);
4641  assume(pp != NULL);
4642 
4643  unsigned long ev = 0; // short exponent vector
4644  unsigned int n = BIT_SIZEOF_LONG / r->N; // number of bits per exp
4645  unsigned int m1; // highest bit which is filled with (n+1)
4646  int j=1;
4647  unsigned long i = 0L;
4648 
4649  if (n == 0)
4650  {
4651  if (r->N <2*BIT_SIZEOF_LONG)
4652  {
4653  n=1;
4654  m1=0;
4655  }
4656  else
4657  {
4658  for (; j<=r->N; j++)
4659  {
4660  if (p_GetExp(p,j,r) > 0 || p_GetExp(pp,j,r) > 0) i++;
4661  if (i == BIT_SIZEOF_LONG) break;
4662  }
4663  if (i>0)
4664  ev = ~(0UL) >> (BIT_SIZEOF_LONG - i);
4665  return ev;
4666  }
4667  }
4668  else
4669  {
4670  m1 = (n+1)*(BIT_SIZEOF_LONG - n*r->N);
4671  }
4672 
4673  n++;
4674  while (i<m1)
4675  {
4676  ev |= GetBitFields(p_GetExp(p, j,r) + p_GetExp(pp, j,r), i, n);
4677  i += n;
4678  j++;
4679  }
4680 
4681  n--;
4682  while (i<BIT_SIZEOF_LONG)
4683  {
4684  ev |= GetBitFields(p_GetExp(p, j,r) + p_GetExp(pp, j,r), i, n);
4685  i += n;
4686  j++;
4687  }
4688  return ev;
4689 }
return P p
Definition: myNF.cc:203
poly pp
Definition: myNF.cc:296
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
int j
Definition: myNF.cc:70
#define assume(x)
Definition: mod2.h:405
int i
Definition: cfEzgcd.cc:123
static unsigned long GetBitFields(const long e, const unsigned int s, const unsigned int n)
Definition: p_polys.cc:4553
#define NULL
Definition: omList.c:10
#define BIT_SIZEOF_LONG
Definition: auxiliary.h:124
static unsigned long p_GetTotalDegree ( const unsigned long  l,
const ring  r,
const int  number_of_exps 
)
inlinestatic

Definition at line 771 of file p_polys.h.

772 {
773  const unsigned long bitmask = r->bitmask;
774  unsigned long sum = (l & bitmask);
775  unsigned long j = number_of_exps - 1;
776 
777  if (j > 0)
778  {
779  unsigned long i = r->BitsPerExp;
780  loop
781  {
782  sum += ((l >> i) & bitmask);
783  j--;
784  if (j==0) break;
785  i += r->BitsPerExp;
786  }
787  }
788  return sum;
789 }
loop
Definition: myNF.cc:98
const ring r
Definition: syzextra.cc:208
int j
Definition: myNF.cc:70
int i
Definition: cfEzgcd.cc:123
int l
Definition: cfEzgcd.cc:94
static unsigned long p_GetTotalDegree ( const unsigned long  l,
const ring  r 
)
inlinestatic

Definition at line 792 of file p_polys.h.

793 {
794  return p_GetTotalDegree(l, r, r->ExpPerLong);
795 }
static unsigned long p_GetTotalDegree(const unsigned long l, const ring r, const int number_of_exps)
Definition: p_polys.h:771
const ring r
Definition: syzextra.cc:208
int l
Definition: cfEzgcd.cc:94
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 1272 of file p_polys.cc.

1273 {
1274  int i;
1275  int n=0;
1276  while(p!=NULL)
1277  {
1278  n=0;
1279  for(i=r->N; i>0; i--)
1280  {
1281  if(e[i]==0)
1282  {
1283  if (p_GetExp(p,i,r)>0)
1284  {
1285  e[i]=1;
1286  n++;
1287  }
1288  }
1289  else
1290  n++;
1291  }
1292  if (n==r->N) break;
1293  pIter(p);
1294  }
1295  return n;
1296 }
return P p
Definition: myNF.cc:203
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
BOOLEAN p_HasNotCF ( poly  p1,
poly  p2,
const ring  r 
)

Definition at line 1334 of file p_polys.cc.

1335 {
1336 
1337  if (p_GetComp(p1,r) > 0 || p_GetComp(p2,r) > 0)
1338  return FALSE;
1339  int i = rVar(r);
1340  loop
1341  {
1342  if ((p_GetExp(p1, i, r) > 0) && (p_GetExp(p2, i, r) > 0))
1343  return FALSE;
1344  i--;
1345  if (i == 0)
1346  return TRUE;
1347  }
1348 }
loop
Definition: myNF.cc:98
#define FALSE
Definition: auxiliary.h:140
#define p_GetComp(p, r)
Definition: monomials.h:72
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:537
#define TRUE
Definition: auxiliary.h:144
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
int i
Definition: cfEzgcd.cc:123
END_NAMESPACE const void * p2
Definition: syzextra.cc:202
static poly p_Head ( poly  p,
const ring  r 
)
inlinestatic

Definition at line 818 of file p_polys.h.

819 {
820  if (p == NULL) return NULL;
822  poly np;
823  omTypeAllocBin(poly, np, r->PolyBin);
824  p_SetRingOfLm(np, r);
825  memcpy(np->exp, p->exp, r->ExpL_Size*sizeof(long));
826  pNext(np) = NULL;
827  pSetCoeff0(np, n_Copy(pGetCoeff(p), r->cf));
828  return np;
829 }
return P p
Definition: myNF.cc:203
#define omTypeAllocBin(type, addr, bin)
Definition: omAllocDecl.h:203
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
const ring r
Definition: syzextra.cc:208
#define p_SetRingOfLm(p, r)
Definition: monomials.h:152
#define p_LmCheckPolyRing1(p, r)
Definition: monomials.h:185
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of &#39;n&#39;
Definition: coeffs.h:452
#define pNext(p)
Definition: monomials.h:43
#define pSetCoeff0(p, n)
Definition: monomials.h:67
polyrec * poly
Definition: hilb.h:10
poly p_Homogen ( poly  p,
int  varnum,
const ring  r 
)

Definition at line 3149 of file p_polys.cc.

3150 {
3151  pFDegProc deg;
3152  if (r->pLexOrder && (r->order[0]==ringorder_lp))
3153  deg=p_Totaldegree;
3154  else
3155  deg=r->pFDeg;
3156 
3157  poly q=NULL, qn;
3158  int o,ii;
3159  sBucket_pt bp;
3160 
3161  if (p!=NULL)
3162  {
3163  if ((varnum < 1) || (varnum > rVar(r)))
3164  {
3165  return NULL;
3166  }
3167  o=deg(p,r);
3168  q=pNext(p);
3169  while (q != NULL)
3170  {
3171  ii=deg(q,r);
3172  if (ii>o) o=ii;
3173  pIter(q);
3174  }
3175  q = p_Copy(p,r);
3176  bp = sBucketCreate(r);
3177  while (q != NULL)
3178  {
3179  ii = o-deg(q,r);
3180  if (ii!=0)
3181  {
3182  p_AddExp(q,varnum, (long)ii,r);
3183  p_Setm(q,r);
3184  }
3185  qn = pNext(q);
3186  pNext(q) = NULL;
3187  sBucket_Add_p(bp, q, 1);
3188  q = qn;
3189  }
3190  sBucketDestroyAdd(bp, &q, &ii);
3191  }
3192  return q;
3193 }
return P p
Definition: myNF.cc:203
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:537
void sBucketDestroyAdd(sBucket_pt bucket, poly *p, int *length)
Definition: sbuckets.h:72
static long p_Totaldegree(poly p, const ring r)
Definition: p_polys.h:1436
void sBucket_Add_p(sBucket_pt bucket, poly p, int length)
adds poly p to bucket destroys p!
Definition: sbuckets.cc:206
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition: p_polys.h:810
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
sBucket_pt sBucketCreate(const ring r)
Definition: sbuckets.cc:125
#define NULL
Definition: omList.c:10
long(* pFDegProc)(poly p, ring r)
Definition: ring.h:46
#define pNext(p)
Definition: monomials.h:43
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:228
static long p_AddExp(poly p, int v, long ee, ring r)
Definition: p_polys.h:601
polyrec * poly
Definition: hilb.h:10
static long p_IncrExp ( poly  p,
int  v,
ring  r 
)
inlinestatic

Definition at line 586 of file p_polys.h.

587 {
589  int e = p_GetExp(p,v,r);
590  e++;
591  return p_SetExp(p,v,e,r);
592 }
#define p_LmCheckPolyRing2(p, r)
Definition: monomials.h:207
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent : VarOffset encodes the position in p->exp
Definition: p_polys.h:483
static poly p_Init ( const ring  r,
omBin  bin 
)
inlinestatic

Definition at line 1249 of file p_polys.h.

1250 {
1251  p_CheckRing1(r);
1252  pAssume1(bin != NULL && omSizeWOfBin(r->PolyBin) == omSizeWOfBin(bin));
1253  poly p;
1254  omTypeAlloc0Bin(poly, p, bin);
1256  p_SetRingOfLm(p, r);
1257  return p;
1258 }
return P p
Definition: myNF.cc:203
#define p_CheckRing1(r)
Definition: monomials.h:186
const ring r
Definition: syzextra.cc:208
#define p_SetRingOfLm(p, r)
Definition: monomials.h:152
static void p_MemAdd_NegWeightAdjust(poly p, const ring r)
Definition: p_polys.h:1221
#define omTypeAlloc0Bin(type, addr, bin)
Definition: omAllocDecl.h:204
#define NULL
Definition: omList.c:10
#define omSizeWOfBin(bin_ptr)
polyrec * poly
Definition: hilb.h:10
#define pAssume1(cond)
Definition: monomials.h:179
static poly p_Init ( const ring  r)
inlinestatic

Definition at line 1259 of file p_polys.h.

1260 {
1261  return p_Init(r, r->PolyBin);
1262 }
const ring r
Definition: syzextra.cc:208
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1249
poly p_Invers ( int  n,
poly  u,
intvec w,
const ring  R 
)

Definition at line 4290 of file p_polys.cc.

4291 {
4292  if(n<0)
4293  return NULL;
4294  number u0=n_Invers(pGetCoeff(u),R->cf);
4295  poly v=p_NSet(u0,R);
4296  if(n==0)
4297  return v;
4298  short *ww=iv2array(w,R);
4299  poly u1=p_JetW(p_Sub(p_One(R),p_Mult_nn(u,u0,R),R),n,ww,R);
4300  if(u1==NULL)
4301  {
4302  omFreeSize((ADDRESS)ww,(rVar(R)+1)*sizeof(short));
4303  return v;
4304  }
4305  poly v1=p_Mult_nn(p_Copy(u1,R),u0,R);
4306  v=p_Add_q(v,p_Copy(v1,R),R);
4307  for(int i=n/p_MinDeg(u1,w,R);i>1;i--)
4308  {
4309  v1=p_JetW(p_Mult_q(v1,p_Copy(u1,R),R),n,ww,R);
4310  v=p_Add_q(v,p_Copy(v1,R),R);
4311  }
4312  p_Delete(&u1,R);
4313  p_Delete(&v1,R);
4314  omFreeSize((ADDRESS)ww,(rVar(R)+1)*sizeof(short));
4315  return v;
4316 }
short * iv2array(intvec *iv, const ring R)
Definition: weight.cc:208
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
Definition: p_polys.cc:1448
int p_MinDeg(poly p, intvec *w, const ring R)
Definition: p_polys.cc:4254
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:537
void * ADDRESS
Definition: auxiliary.h:161
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
poly p_Sub(poly p1, poly p2, const ring r)
Definition: p_polys.cc:1901
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition: p_polys.h:810
poly p_One(const ring r)
Definition: p_polys.cc:1318
const ring R
Definition: DebugPrint.cc:36
static FORCE_INLINE number n_Invers(number a, const coeffs r)
return the multiplicative inverse of &#39;a&#39;; raise an error if &#39;a&#39; is not invertible ...
Definition: coeffs.h:565
int i
Definition: cfEzgcd.cc:123
static poly p_Mult_nn(poly p, number n, const ring r)
Definition: p_polys.h:901
poly p_JetW(poly p, int m, short *w, const ring R)
Definition: p_polys.cc:4236
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:849
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define NULL
Definition: omList.c:10
polyrec * poly
Definition: hilb.h:10
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:883
static poly p_Mult_q(poly p, poly q, const ring r)
Definition: p_polys.h:1026
static BOOLEAN p_IsConstant ( const poly  p,
const ring  r 
)
inlinestatic

Definition at line 1785 of file p_polys.h.

1786 {
1787  if (p == NULL) return TRUE;
1788  p_Test(p, r);
1789  return (pNext(p)==NULL) && p_LmIsConstant(p, r);
1790 }
return P p
Definition: myNF.cc:203
#define TRUE
Definition: auxiliary.h:144
static BOOLEAN p_LmIsConstant(const poly p, const ring r)
Definition: p_polys.h:955
const ring r
Definition: syzextra.cc:208
#define p_Test(p, r)
Definition: p_polys.h:160
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
static BOOLEAN p_IsConstantComp ( const poly  p,
const ring  r 
)
inlinestatic

Definition at line 1779 of file p_polys.h.

1780 {
1781  if (p == NULL) return TRUE;
1782  return (pNext(p)==NULL) && p_LmIsConstantComp(p, r);
1783 }
static BOOLEAN p_LmIsConstantComp(const poly p, const ring r)
Definition: p_polys.h:938
return P p
Definition: myNF.cc:203
#define TRUE
Definition: auxiliary.h:144
const ring r
Definition: syzextra.cc:208
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
static BOOLEAN p_IsConstantPoly ( const poly  p,
const ring  r 
)
inlinestatic

Definition at line 1799 of file p_polys.h.

1800 {
1801  p_Test(p, r);
1802  poly pp=p;
1803  while(pp!=NULL)
1804  {
1805  if (! p_LmIsConstantComp(pp, r))
1806  return FALSE;
1807  pIter(pp);
1808  }
1809  return TRUE;
1810 }
static BOOLEAN p_LmIsConstantComp(const poly p, const ring r)
Definition: p_polys.h:938
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
#define TRUE
Definition: auxiliary.h:144
poly pp
Definition: myNF.cc:296
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
#define p_Test(p, r)
Definition: p_polys.h:160
#define NULL
Definition: omList.c:10
polyrec * poly
Definition: hilb.h:10
poly p_ISet ( long  i,
const ring  r 
)

returns the poly representing the integer i

Definition at line 1302 of file p_polys.cc.

1303 {
1304  poly rc = NULL;
1305  if (i!=0)
1306  {
1307  rc = p_Init(r);
1308  pSetCoeff0(rc,n_Init(i,r->cf));
1309  if (n_IsZero(pGetCoeff(rc),r->cf))
1310  p_LmDelete(&rc,r);
1311  }
1312  return rc;
1313 }
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:539
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
const ring r
Definition: syzextra.cc:208
int i
Definition: cfEzgcd.cc:123
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the zero element.
Definition: coeffs.h:465
#define NULL
Definition: omList.c:10
#define pSetCoeff0(p, n)
Definition: monomials.h:67
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:706
polyrec * poly
Definition: hilb.h:10
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1249
BOOLEAN p_IsHomogeneous ( poly  p,
const ring  r 
)

Definition at line 3198 of file p_polys.cc.

3199 {
3200  poly qp=p;
3201  int o;
3202 
3203  if ((p == NULL) || (pNext(p) == NULL)) return TRUE;
3204  pFDegProc d;
3205  if (r->pLexOrder && (r->order[0]==ringorder_lp))
3206  d=p_Totaldegree;
3207  else
3208  d=r->pFDeg;
3209  o = d(p,r);
3210  do
3211  {
3212  if (d(qp,r) != o) return FALSE;
3213  pIter(qp);
3214  }
3215  while (qp != NULL);
3216  return TRUE;
3217 }
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
#define TRUE
Definition: auxiliary.h:144
static long p_Totaldegree(poly p, const ring r)
Definition: p_polys.h:1436
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
#define NULL
Definition: omList.c:10
long(* pFDegProc)(poly p, ring r)
Definition: ring.h:46
#define pNext(p)
Definition: monomials.h:43
polyrec * poly
Definition: hilb.h:10
static BOOLEAN p_IsOne ( const poly  p,
const ring  R 
)
inlinestatic

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

Definition at line 1793 of file p_polys.h.

1794 {
1795  p_Test(p, R);
1796  return (p_IsConstant(p, R) && n_IsOne(p_GetCoeff(p, R), R->cf));
1797 }
return P p
Definition: myNF.cc:203
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the one element.
Definition: coeffs.h:469
static BOOLEAN p_IsConstant(const poly p, const ring r)
Definition: p_polys.h:1785
const ring R
Definition: DebugPrint.cc:36
#define p_Test(p, r)
Definition: p_polys.h:160
#define p_GetCoeff(p, r)
Definition: monomials.h:57
int p_IsPurePower ( const poly  p,
const ring  r 
)

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

Definition at line 1224 of file p_polys.cc.

1225 {
1226 #ifdef HAVE_RINGS
1227  if (rField_is_Ring(r))
1228  {
1229  if (p == NULL) return 0;
1230  if (!n_IsUnit(pGetCoeff(p), r->cf)) return 0;
1231  }
1232 #endif
1233  int i,k=0;
1234 
1235  for (i=r->N;i;i--)
1236  {
1237  if (p_GetExp(p,i, r)!=0)
1238  {
1239  if(k!=0) return 0;
1240  k=i;
1241  }
1242  }
1243  return k;
1244 }
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:516
return P p
Definition: myNF.cc:203
int k
Definition: cfEzgcd.cc:93
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
int i
Definition: cfEzgcd.cc:123
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:434
#define NULL
Definition: omList.c:10
static BOOLEAN p_IsUnit ( const poly  p,
const ring  r 
)
inlinestatic

Definition at line 1812 of file p_polys.h.

1813 {
1814  if (p == NULL) return FALSE;
1815 #ifdef HAVE_RINGS
1816  if (rField_is_Ring(r))
1817  return (p_LmIsConstant(p, r) && n_IsUnit(pGetCoeff(p),r->cf));
1818 #endif
1819  return p_LmIsConstant(p, r);
1820 }
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:516
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
static BOOLEAN p_LmIsConstant(const poly p, const ring r)
Definition: p_polys.h:955
const ring r
Definition: syzextra.cc:208
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:434
#define NULL
Definition: omList.c:10
int p_IsUnivariate ( poly  p,
const ring  r 
)

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

Definition at line 1252 of file p_polys.cc.

1253 {
1254  int i,k=-1;
1255 
1256  while (p!=NULL)
1257  {
1258  for (i=r->N;i;i--)
1259  {
1260  if (p_GetExp(p,i, r)!=0)
1261  {
1262  if((k!=-1)&&(k!=i)) return 0;
1263  k=i;
1264  }
1265  }
1266  pIter(p);
1267  }
1268  return k;
1269 }
return P p
Definition: myNF.cc:203
int k
Definition: cfEzgcd.cc:93
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
poly p_Jet ( poly  p,
int  m,
const ring  R 
)

Definition at line 4192 of file p_polys.cc.

4193 {
4194  while((p!=NULL) && (p_Totaldegree(p,R)>m)) p_LmDelete(&p,R);
4195  if (p==NULL) return NULL;
4196  poly r=p;
4197  while (pNext(p)!=NULL)
4198  {
4199  if (p_Totaldegree(pNext(p),R)>m)
4200  {
4201  p_LmDelete(&pNext(p),R);
4202  }
4203  else
4204  pIter(p);
4205  }
4206  return r;
4207 }
return P p
Definition: myNF.cc:203
static long p_Totaldegree(poly p, const ring r)
Definition: p_polys.h:1436
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
const ring R
Definition: DebugPrint.cc:36
int m
Definition: cfEzgcd.cc:119
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:706
polyrec * poly
Definition: hilb.h:10
poly p_JetW ( poly  p,
int  m,
short *  w,
const ring  R 
)

Definition at line 4236 of file p_polys.cc.

4237 {
4238  while((p!=NULL) && (totaldegreeWecart_IV(p,R,w)>m)) p_LmDelete(&p,R);
4239  if (p==NULL) return NULL;
4240  poly r=p;
4241  while (pNext(p)!=NULL)
4242  {
4243  if (totaldegreeWecart_IV(pNext(p),R,w)>m)
4244  {
4245  p_LmDelete(&pNext(p),R);
4246  }
4247  else
4248  pIter(p);
4249  }
4250  return r;
4251 }
return P p
Definition: myNF.cc:203
long totaldegreeWecart_IV(poly p, ring r, const short *w)
Definition: weight.cc:239
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
const ring R
Definition: DebugPrint.cc:36
int m
Definition: cfEzgcd.cc:119
#define NULL
Definition: omList.c:10
const CanonicalForm & w
Definition: facAbsFact.cc:55
#define pNext(p)
Definition: monomials.h:43
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:706
polyrec * poly
Definition: hilb.h:10
poly p_Last ( const poly  a,
int &  l,
const ring  r 
)

Definition at line 4427 of file p_polys.cc.

4428 {
4429  if (p == NULL)
4430  {
4431  l = 0;
4432  return NULL;
4433  }
4434  l = 1;
4435  poly a = p;
4436  if (! rIsSyzIndexRing(r))
4437  {
4438  poly next = pNext(a);
4439  while (next!=NULL)
4440  {
4441  a = next;
4442  next = pNext(a);
4443  l++;
4444  }
4445  }
4446  else
4447  {
4448  int curr_limit = rGetCurrSyzLimit(r);
4449  poly pp = a;
4450  while ((a=pNext(a))!=NULL)
4451  {
4452  if (p_GetComp(a,r)<=curr_limit/*syzComp*/)
4453  l++;
4454  else break;
4455  pp = a;
4456  }
4457  a=pp;
4458  }
4459  return a;
4460 }
const poly a
Definition: syzextra.cc:212
return P p
Definition: myNF.cc:203
static BOOLEAN rIsSyzIndexRing(const ring r)
Definition: ring.h:711
#define p_GetComp(p, r)
Definition: monomials.h:72
static int rGetCurrSyzLimit(const ring r)
Definition: ring.h:714
poly pp
Definition: myNF.cc:296
const ring r
Definition: syzextra.cc:208
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
polyrec * poly
Definition: hilb.h:10
int l
Definition: cfEzgcd.cc:94
ListNode * next
Definition: janet.h:31
void p_Lcm ( const poly  a,
const poly  b,
poly  m,
const ring  r 
)

Definition at line 1572 of file p_polys.cc.

1573 {
1574  for (int i=rVar(r); i; --i)
1575  p_SetExp(m,i, si_max( p_GetExp(a,i,r), p_GetExp(b,i,r)),r);
1576 
1578  /* Don't do a pSetm here, otherwise hres/lres chockes */
1579 }
const poly a
Definition: syzextra.cc:212
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition: p_polys.h:242
#define p_GetComp(p, r)
Definition: monomials.h:72
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:537
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
int m
Definition: cfEzgcd.cc:119
static int si_max(const int a, const int b)
Definition: auxiliary.h:166
int i
Definition: cfEzgcd.cc:123
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent : VarOffset encodes the position in p->exp
Definition: p_polys.h:483
const poly b
Definition: syzextra.cc:213
poly p_LcmRat ( const poly  a,
const poly  b,
const long  lCompM,
const ring  r 
)

Definition at line 1588 of file p_polys.cc.

1589 {
1590  poly m = // p_One( r);
1591  p_Init(r);
1592 
1593 // const int (currRing->N) = r->N;
1594 
1595  // for (int i = (currRing->N); i>=r->real_var_start; i--)
1596  for (int i = r->real_var_end; i>=r->real_var_start; i--)
1597  {
1598  const int lExpA = p_GetExp (a, i, r);
1599  const int lExpB = p_GetExp (b, i, r);
1600 
1601  p_SetExp (m, i, si_max(lExpA, lExpB), r);
1602  }
1603 
1604  p_SetComp (m, lCompM, r);
1605  p_Setm(m,r);
1606  n_New(&(p_GetCoeff(m, r)), r);
1607 
1608  return(m);
1609 };
#define n_New(n, r)
Definition: coeffs.h:441
const poly a
Definition: syzextra.cc:212
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition: p_polys.h:242
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
int m
Definition: cfEzgcd.cc:119
static int si_max(const int a, const int b)
Definition: auxiliary.h:166
int i
Definition: cfEzgcd.cc:123
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent : VarOffset encodes the position in p->exp
Definition: p_polys.h:483
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:228
#define p_GetCoeff(p, r)
Definition: monomials.h:57
polyrec * poly
Definition: hilb.h:10
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1249
const poly b
Definition: syzextra.cc:213
static long p_LDeg ( const poly  p,
int *  l,
const ring  r 
)
inlinestatic

Definition at line 376 of file p_polys.h.

376 { return r->pLDeg(p,l,r); }
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208
int l
Definition: cfEzgcd.cc:94
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  {
93  return TRUE;
94  }
95  return FALSE;
96  #endif
97  }
98  return TRUE;
99 }
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
#define TRUE
Definition: auxiliary.h:144
size_t omSizeWOfAddr(void *addr)
#define _pPolyAssumeReturn(cond, p, r)
Definition: monomials.h:109
const ring r
Definition: syzextra.cc:208
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:1681
#define NULL
Definition: omList.c:10
#define omIsBinPageAddr(addr)
Definition: omBinPage.h:71
#define omSizeWOfBin(bin_ptr)
#define pPolyAssumeReturnMsg(cond, msg)
Definition: monomials.h:145
BOOLEAN p_LmCheckPolyRing ( poly  p,
ring  r 
)

Definition at line 119 of file pDebug.cc.

120 {
121  #ifndef X_OMALLOC
122  pAssumeReturn(r != NULL && r->PolyBin != NULL);
123  #endif
124  pAssumeReturn(p != NULL);
125  return p_LmCheckIsFromRing(p, r);
126 }
return P p
Definition: myNF.cc:203
#define pAssumeReturn(cond)
Definition: monomials.h:86
BOOLEAN p_LmCheckIsFromRing(poly p, ring r)
Definition: pDebug.cc:71
const ring r
Definition: syzextra.cc:208
#define NULL
Definition: omList.c:10
static int p_LmCmp ( poly  p,
poly  q,
const ring  r 
)
inlinestatic

Definition at line 1473 of file p_polys.h.

1474 {
1476  p_LmCheckPolyRing1(q, r);
1477 
1478  const unsigned long* _s1 = ((unsigned long*) p->exp);
1479  const unsigned long* _s2 = ((unsigned long*) q->exp);
1480  register unsigned long _v1;
1481  register unsigned long _v2;
1482  const unsigned long _l = r->CmpL_Size;
1483 
1484  register unsigned long _i=0;
1485 
1486  LengthGeneral_OrdGeneral_LoopTop:
1487  _v1 = _s1[_i];
1488  _v2 = _s2[_i];
1489  if (_v1 == _v2)
1490  {
1491  _i++;
1492  if (_i == _l) return 0;
1493  goto LengthGeneral_OrdGeneral_LoopTop;
1494  }
1495  const long* _ordsgn = (long*) r->ordsgn;
1496  if (_v1 > _v2)
1497  {
1498  if (_ordsgn[_i] == 1) return 1;
1499  return -1;
1500  }
1501  if (_ordsgn[_i] == 1) return -1;
1502  return 1;
1503 
1504 }
if(0 > strat->sl)
Definition: myNF.cc:73
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208
#define p_LmCheckPolyRing1(p, r)
Definition: monomials.h:185
static void p_LmDelete ( poly  p,
const ring  r 
)
inlinestatic

Definition at line 706 of file p_polys.h.

707 {
709  n_Delete(&pGetCoeff(p), r->cf);
710  omFreeBinAddr(p);
711 }
#define p_LmCheckPolyRing2(p, r)
Definition: monomials.h:207
return P p
Definition: myNF.cc:203
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
const ring r
Definition: syzextra.cc:208
#define omFreeBinAddr(addr)
Definition: omAllocDecl.h:258
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
static void p_LmDelete ( poly p,
const ring  r 
)
inlinestatic

Definition at line 712 of file p_polys.h.

713 {
715  poly h = *p;
716  *p = pNext(h);
717  n_Delete(&pGetCoeff(h), r->cf);
718  omFreeBinAddr(h);
719 }
#define p_LmCheckPolyRing2(p, r)
Definition: monomials.h:207
return P p
Definition: myNF.cc:203
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
const ring r
Definition: syzextra.cc:208
#define omFreeBinAddr(addr)
Definition: omAllocDecl.h:258
#define pNext(p)
Definition: monomials.h:43
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
polyrec * poly
Definition: hilb.h:10
static Poly * h
Definition: janet.cc:978
static poly p_LmDeleteAndNext ( poly  p,
const ring  r 
)
inlinestatic

Definition at line 720 of file p_polys.h.

721 {
723  poly pnext = pNext(p);
724  n_Delete(&pGetCoeff(p), r->cf);
725  omFreeBinAddr(p);
726  return pnext;
727 }
#define p_LmCheckPolyRing2(p, r)
Definition: monomials.h:207
return P p
Definition: myNF.cc:203
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
const ring r
Definition: syzextra.cc:208
#define omFreeBinAddr(addr)
Definition: omAllocDecl.h:258
#define pNext(p)
Definition: monomials.h:43
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
polyrec * poly
Definition: hilb.h:10
void p_LmDeleteAndNextRat ( poly p,
int  ishift,
ring  r 
)

Definition at line 1611 of file p_polys.cc.

1612 {
1613  /* modifies p*/
1614  // Print("start: "); Print(" "); p_wrp(*p,r);
1615  p_LmCheckPolyRing2(*p, r);
1616  poly q = p_Head(*p,r);
1617  const long cmp = p_GetComp(*p, r);
1618  while ( ( (*p)!=NULL ) && ( p_Comp_k_n(*p, q, ishift+1, r) ) && (p_GetComp(*p, r) == cmp) )
1619  {
1620  p_LmDelete(p,r);
1621  // Print("while: ");p_wrp(*p,r);Print(" ");
1622  }
1623  // p_wrp(*p,r);Print(" ");
1624  // PrintS("end\n");
1625  p_LmDelete(&q,r);
1626 }
#define p_LmCheckPolyRing2(p, r)
Definition: monomials.h:207
return P p
Definition: myNF.cc:203
#define p_GetComp(p, r)
Definition: monomials.h:72
static poly p_Head(poly p, const ring r)
Definition: p_polys.h:818
const ring r
Definition: syzextra.cc:208
static int p_Comp_k_n(poly a, poly b, int k, ring r)
Definition: p_polys.h:635
#define NULL
Definition: omList.c:10
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:706
polyrec * poly
Definition: hilb.h:10
static BOOLEAN p_LmDivisibleBy ( poly  a,
poly  b,
const ring  r 
)
inlinestatic

Definition at line 1677 of file p_polys.h.

1678 {
1681  if (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r))
1682  return _p_LmDivisibleByNoComp(a, b, r);
1683  return FALSE;
1684 }
const poly a
Definition: syzextra.cc:212
#define FALSE
Definition: auxiliary.h:140
#define p_GetComp(p, r)
Definition: monomials.h:72
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:1547
const ring r
Definition: syzextra.cc:208
#define p_LmCheckPolyRing1(p, r)
Definition: monomials.h:185
#define pIfThen1(cond, check)
Definition: monomials.h:187
#define NULL
Definition: omList.c:10
const poly b
Definition: syzextra.cc:213
static BOOLEAN p_LmDivisibleBy ( poly  a,
const ring  r_a,
poly  b,
const ring  r_b 
)
inlinestatic

Definition at line 1704 of file p_polys.h.

1705 {
1706  p_LmCheckPolyRing(a, r_a);
1707  p_LmCheckPolyRing(b, r_b);
1708  return _p_LmDivisibleBy(a, r_a, b, r_b);
1709 }
const poly a
Definition: syzextra.cc:212
static BOOLEAN _p_LmDivisibleBy(poly a, poly b, const ring r)
Definition: p_polys.h:1651
BOOLEAN p_LmCheckPolyRing(poly p, ring r)
Definition: pDebug.cc:119
const poly b
Definition: syzextra.cc:213
static BOOLEAN p_LmDivisibleByNoComp ( poly  a,
poly  b,
const ring  r 
)
inlinestatic

Definition at line 1663 of file p_polys.h.

1664 {
1667  return _p_LmDivisibleByNoComp(a, b, r);
1668 }
const poly a
Definition: syzextra.cc:212
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:1547
const ring r
Definition: syzextra.cc:208
#define p_LmCheckPolyRing1(p, r)
Definition: monomials.h:185
const poly b
Definition: syzextra.cc:213
static BOOLEAN p_LmDivisibleByNoComp ( poly  a,
const ring  ra,
poly  b,
const ring  rb 
)
inlinestatic

Definition at line 1670 of file p_polys.h.

1671 {
1672  p_LmCheckPolyRing1(a, ra);
1673  p_LmCheckPolyRing1(b, rb);
1674  return _p_LmDivisibleByNoComp(a, ra, b, rb);
1675 }
const poly a
Definition: syzextra.cc:212
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:1547
#define p_LmCheckPolyRing1(p, r)
Definition: monomials.h:185
const poly b
Definition: syzextra.cc:213
static BOOLEAN p_LmDivisibleByPart ( poly  a,
poly  b,
const ring  r,
const int  start,
const int  end 
)
inlinestatic

Definition at line 1642 of file p_polys.h.

1643 {
1646  if (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r))
1647  return _p_LmDivisibleByNoCompPart(a, r, b, r,start, end);
1648  return FALSE;
1649 }
const poly a
Definition: syzextra.cc:212
#define FALSE
Definition: auxiliary.h:140
#define p_GetComp(p, r)
Definition: monomials.h:72
const ring r
Definition: syzextra.cc:208
#define p_LmCheckPolyRing1(p, r)
Definition: monomials.h:185
#define pIfThen1(cond, check)
Definition: monomials.h:187
#define NULL
Definition: omList.c:10
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:1617
const poly b
Definition: syzextra.cc:213
static BOOLEAN p_LmExpVectorAddIsOk ( const poly  p1,
const poly  p2,
const ring  r 
)
inlinestatic

Definition at line 1822 of file p_polys.h.

1824 {
1825  p_LmCheckPolyRing(p1, r);
1827  unsigned long l1, l2, divmask = r->divmask;
1828  int i;
1829 
1830  for (i=0; i<r->VarL_Size; i++)
1831  {
1832  l1 = p1->exp[r->VarL_Offset[i]];
1833  l2 = p2->exp[r->VarL_Offset[i]];
1834  // do the divisiblity trick
1835  if ( (l1 > ULONG_MAX - l2) ||
1836  (((l1 & divmask) ^ (l2 & divmask)) != ((l1 + l2) & divmask)))
1837  return FALSE;
1838  }
1839  return TRUE;
1840 }
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
const ring r
Definition: syzextra.cc:208
int i
Definition: cfEzgcd.cc:123
BOOLEAN p_LmCheckPolyRing(poly p, ring r)
Definition: pDebug.cc:119
END_NAMESPACE const void * p2
Definition: syzextra.cc:202
static void p_LmFree ( poly  p,
ring   
)
inlinestatic

Definition at line 678 of file p_polys.h.

680 {
682  omFreeBinAddr(p);
683 }
#define p_LmCheckPolyRing2(p, r)
Definition: monomials.h:207
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208
#define omFreeBinAddr(addr)
Definition: omAllocDecl.h:258
static void p_LmFree ( poly p,
ring   
)
inlinestatic

Definition at line 687 of file p_polys.h.

689 {
691  poly h = *p;
692  *p = pNext(h);
693  omFreeBinAddr(h);
694 }
#define p_LmCheckPolyRing2(p, r)
Definition: monomials.h:207
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208
#define omFreeBinAddr(addr)
Definition: omAllocDecl.h:258
#define pNext(p)
Definition: monomials.h:43
polyrec * poly
Definition: hilb.h:10
static Poly * h
Definition: janet.cc:978
static poly p_LmFreeAndNext ( poly  p,
ring   
)
inlinestatic

Definition at line 698 of file p_polys.h.

700 {
702  poly pnext = pNext(p);
703  omFreeBinAddr(p);
704  return pnext;
705 }
#define p_LmCheckPolyRing2(p, r)
Definition: monomials.h:207
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208
#define omFreeBinAddr(addr)
Definition: omAllocDecl.h:258
#define pNext(p)
Definition: monomials.h:43
polyrec * poly
Definition: hilb.h:10
static poly p_LmInit ( poly  p,
const ring  r 
)
inlinestatic

Definition at line 1264 of file p_polys.h.

1265 {
1267  poly np;
1268  omTypeAllocBin(poly, np, r->PolyBin);
1269  p_SetRingOfLm(np, r);
1270  memcpy(np->exp, p->exp, r->ExpL_Size*sizeof(long));
1271  pNext(np) = NULL;
1272  pSetCoeff0(np, NULL);
1273  return np;
1274 }
return P p
Definition: myNF.cc:203
#define omTypeAllocBin(type, addr, bin)
Definition: omAllocDecl.h:203
const ring r
Definition: syzextra.cc:208
#define p_SetRingOfLm(p, r)
Definition: monomials.h:152
#define p_LmCheckPolyRing1(p, r)
Definition: monomials.h:185
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
#define pSetCoeff0(p, n)
Definition: monomials.h:67
polyrec * poly
Definition: hilb.h:10
static poly p_LmInit ( poly  s_p,
const ring  s_r,
const ring  d_r,
omBin  d_bin 
)
inlinestatic

Definition at line 1275 of file p_polys.h.

1276 {
1277  p_LmCheckPolyRing1(s_p, s_r);
1278  p_CheckRing(d_r);
1279  pAssume1(d_r->N <= s_r->N);
1280  poly d_p = p_Init(d_r, d_bin);
1281  for (int i=d_r->N; i>0; i--)
1282  {
1283  p_SetExp(d_p, i, p_GetExp(s_p, i,s_r), d_r);
1284  }
1285  if (rRing_has_Comp(d_r))
1286  {
1287  p_SetComp(d_p, p_GetComp(s_p,s_r), d_r);
1288  }
1289  p_Setm(d_p, d_r);
1290  return d_p;
1291 }
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition: p_polys.h:242
#define p_GetComp(p, r)
Definition: monomials.h:72
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
int i
Definition: cfEzgcd.cc:123
#define p_LmCheckPolyRing1(p, r)
Definition: monomials.h:185
#define rRing_has_Comp(r)
Definition: monomials.h:274
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent : VarOffset encodes the position in p->exp
Definition: p_polys.h:483
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:228
polyrec * poly
Definition: hilb.h:10
BOOLEAN p_CheckRing(ring r)
Definition: pDebug.cc:127
#define pAssume1(cond)
Definition: monomials.h:179
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1249
static poly p_LmInit ( poly  s_p,
const ring  s_r,
const ring  d_r 
)
inlinestatic

Definition at line 1292 of file p_polys.h.

1293 {
1294  pAssume1(d_r != NULL);
1295  return p_LmInit(s_p, s_r, d_r, d_r->PolyBin);
1296 }
#define NULL
Definition: omList.c:10
static poly p_LmInit(poly p, const ring r)
Definition: p_polys.h:1264
#define pAssume1(cond)
Definition: monomials.h:179
static BOOLEAN p_LmIsConstant ( const poly  p,
const ring  r 
)
inlinestatic

Definition at line 955 of file p_polys.h.

956 {
957  if (p_LmIsConstantComp(p, r))
958  return (p_GetComp(p, r) == 0);
959  return FALSE;
960 }
static BOOLEAN p_LmIsConstantComp(const poly p, const ring r)
Definition: p_polys.h:938
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
#define p_GetComp(p, r)
Definition: monomials.h:72
const ring r
Definition: syzextra.cc:208
static BOOLEAN p_LmIsConstantComp ( const poly  p,
const ring  r 
)
inlinestatic

Definition at line 938 of file p_polys.h.

939 {
940  //p_LmCheckPolyRing(p, r);
941  int i = r->VarL_Size - 1;
942 
943  do
944  {
945  if (p->exp[r->VarL_Offset[i]] != 0)
946  return FALSE;
947  i--;
948  }
949  while (i >= 0);
950  return TRUE;
951 }
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
#define TRUE
Definition: auxiliary.h:144
const ring r
Definition: syzextra.cc:208
int i
Definition: cfEzgcd.cc:123
static poly p_LmShallowCopyDelete ( poly  p,
const ring  r 
)
inlinestatic

Definition at line 1322 of file p_polys.h.

1323 {
1325  pAssume1(omSizeWOfBin(bin) == omSizeWOfBin(r->PolyBin));
1326  poly new_p = p_New(r);
1327  memcpy(new_p->exp, p->exp, r->ExpL_Size*sizeof(long));
1328  pSetCoeff0(new_p, pGetCoeff(p));
1329  pNext(new_p) = pNext(p);
1330  omFreeBinAddr(p);
1331  return new_p;
1332 }
return P p
Definition: myNF.cc:203
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
const ring r
Definition: syzextra.cc:208
#define omFreeBinAddr(addr)
Definition: omAllocDecl.h:258
#define p_LmCheckPolyRing1(p, r)
Definition: monomials.h:185
#define omSizeWOfBin(bin_ptr)
#define pNext(p)
Definition: monomials.h:43
#define pSetCoeff0(p, n)
Definition: monomials.h:67
polyrec * poly
Definition: hilb.h:10
static poly p_New(const ring, omBin bin)
Definition: p_polys.h:659
#define pAssume1(cond)
Definition: monomials.h:179
static BOOLEAN p_LmShortDivisibleBy ( poly  a,
unsigned long  sev_a,
poly  b,
unsigned long  not_sev_b,
const ring  r 
)
inlinestatic

Definition at line 1711 of file p_polys.h.

1713 {
1716 #ifndef PDIV_DEBUG
1717  _pPolyAssume2(p_GetShortExpVector(a, r) == sev_a, a, r);
1718  _pPolyAssume2(p_GetShortExpVector(b, r) == ~ not_sev_b, b, r);
1719 
1720  if (sev_a & not_sev_b)
1721  {
1723  return FALSE;
1724  }
1725  return p_LmDivisibleBy(a, b, r);
1726 #else
1727  return pDebugLmShortDivisibleBy(a, sev_a, r, b, not_sev_b, r);
1728 #endif
1729 }
const poly a
Definition: syzextra.cc:212
#define FALSE
Definition: auxiliary.h:140
unsigned long p_GetShortExpVector(const poly a, const ring r)
Definition: p_polys.cc:4586
static BOOLEAN p_LmDivisibleByNoComp(poly a, poly b, const ring r)
Definition: p_polys.h:1663
#define _pPolyAssume2(cond, p, r)
Definition: monomials.h:203
const ring r
Definition: syzextra.cc:208
#define p_LmCheckPolyRing1(p, r)
Definition: monomials.h:185
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
Definition: p_polys.h:1677
#define pAssume1(cond)
Definition: monomials.h:179
const poly b
Definition: syzextra.cc:213
BOOLEAN pDebugLmShortDivisibleBy(poly p1, unsigned long sev_1, ring r_1, poly p2, unsigned long not_sev_2, ring r_2)
Definition: pDebug.cc:365
static BOOLEAN p_LmShortDivisibleBy ( poly  a,
unsigned long  sev_a,
const ring  r_a,
poly  b,
unsigned long  not_sev_b,
const ring  r_b 
)
inlinestatic

Definition at line 1751 of file p_polys.h.

1753 {
1754  p_LmCheckPolyRing1(a, r_a);
1755  p_LmCheckPolyRing1(b, r_b);
1756 #ifndef PDIV_DEBUG
1757  _pPolyAssume2(p_GetShortExpVector(a, r_a) == sev_a, a, r_a);
1758  _pPolyAssume2(p_GetShortExpVector(b, r_b) == ~ not_sev_b, b, r_b);
1759 
1760  if (sev_a & not_sev_b)
1761  {
1762  pAssume1(_p_LmDivisibleByNoComp(a, r_a, b, r_b) == FALSE);
1763  return FALSE;
1764  }
1765  return _p_LmDivisibleBy(a, r_a, b, r_b);
1766 #else
1767  return pDebugLmShortDivisibleBy(a, sev_a, r_a, b, not_sev_b, r_b);
1768 #endif
1769 }
const poly a
Definition: syzextra.cc:212
#define FALSE
Definition: auxiliary.h:140
unsigned long p_GetShortExpVector(const poly a, const ring r)
Definition: p_polys.cc:4586
#define _pPolyAssume2(cond, p, r)
Definition: monomials.h:203
static BOOLEAN _p_LmDivisibleBy(poly a, poly b, const ring r)
Definition: p_polys.h:1651
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:1547
#define p_LmCheckPolyRing1(p, r)
Definition: monomials.h:185
#define pAssume1(cond)
Definition: monomials.h:179
const poly b
Definition: syzextra.cc:213
BOOLEAN pDebugLmShortDivisibleBy(poly p1, unsigned long sev_1, ring r_1, poly p2, unsigned long not_sev_2, ring r_2)
Definition: pDebug.cc:365
static BOOLEAN p_LmShortDivisibleByNoComp ( poly  a,
unsigned long  sev_a,
poly  b,
unsigned long  not_sev_b,
const ring  r 
)
inlinestatic

Definition at line 1731 of file p_polys.h.

1733 {
1736 #ifndef PDIV_DEBUG
1737  _pPolyAssume2(p_GetShortExpVector(a, r) == sev_a, a, r);
1738  _pPolyAssume2(p_GetShortExpVector(b, r) == ~ not_sev_b, b, r);
1739 
1740  if (sev_a & not_sev_b)
1741  {
1743  return FALSE;
1744  }
1745  return p_LmDivisibleByNoComp(a, b, r);
1746 #else
1747  return pDebugLmShortDivisibleByNoComp(a, sev_a, r, b, not_sev_b, r);
1748 #endif
1749 }
const poly a
Definition: syzextra.cc:212
BOOLEAN pDebugLmShortDivisibleByNoComp(poly p1, unsigned long sev_1, ring r_1, poly p2, unsigned long not_sev_2, ring r_2)
Definition: pDebug.cc:388
#define FALSE
Definition: auxiliary.h:140
unsigned long p_GetShortExpVector(const poly a, const ring r)
Definition: p_polys.cc:4586
static BOOLEAN p_LmDivisibleByNoComp(poly a, poly b, const ring r)
Definition: p_polys.h:1663
#define _pPolyAssume2(cond, p, r)
Definition: monomials.h:203
const ring r
Definition: syzextra.cc:208
#define p_LmCheckPolyRing1(p, r)
Definition: monomials.h:185
#define pAssume1(cond)
Definition: monomials.h:179
const poly b
Definition: syzextra.cc:213
int p_LowVar ( poly  p,
const ring  r 
)

the minimal index of used variables - 1

Definition at line 4486 of file p_polys.cc.

4487 {
4488  int k,l,lex;
4489 
4490  if (p == NULL) return -1;
4491 
4492  k = 32000;/*a very large dummy value*/
4493  while (p != NULL)
4494  {
4495  l = 1;
4496  lex = p_GetExp(p,l,r);
4497  while ((l < (rVar(r))) && (lex == 0))
4498  {
4499  l++;
4500  lex = p_GetExp(p,l,r);
4501  }
4502  l--;
4503  if (l < k) k = l;
4504  pIter(p);
4505  }
4506  return k;
4507 }
return P p
Definition: myNF.cc:203
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:537
int k
Definition: cfEzgcd.cc:93
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
#define NULL
Definition: omList.c:10
int l
Definition: cfEzgcd.cc:94
static long p_MaxComp ( poly  p,
ring  lmRing,
ring  tailRing 
)
inlinestatic

Definition at line 287 of file p_polys.h.

288 {
289  long result,i;
290 
291  if(p==NULL) return 0;
292  result = p_GetComp(p, lmRing);
293  if (result != 0)
294  {
295  loop
296  {
297  pIter(p);
298  if(p==NULL) break;
299  i = p_GetComp(p, tailRing);
300  if (i>result) result = i;
301  }
302  }
303  return result;
304 }
BEGIN_NAMESPACE_SINGULARXX const ring lmRing
Definition: DebugPrint.h:30
loop
Definition: myNF.cc:98
return P p
Definition: myNF.cc:203
#define p_GetComp(p, r)
Definition: monomials.h:72
BEGIN_NAMESPACE_SINGULARXX const ring const ring tailRing
Definition: DebugPrint.h:30
#define pIter(p)
Definition: monomials.h:44
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
return result
Definition: facAbsBiFact.cc:76
static long p_MaxComp ( poly  p,
ring  lmRing 
)
inlinestatic

Definition at line 306 of file p_polys.h.

306 {return p_MaxComp(p,lmRing,lmRing);}
BEGIN_NAMESPACE_SINGULARXX const ring lmRing
Definition: DebugPrint.h:30
return P p
Definition: myNF.cc:203
static long p_MaxComp(poly p, ring lmRing, ring tailRing)
Definition: p_polys.h:287
static void p_MemAdd_NegWeightAdjust ( poly  p,
const ring  r 
)
inlinestatic

Definition at line 1221 of file p_polys.h.

1222 {
1223  if (r->NegWeightL_Offset != NULL)
1224  {
1225  for (int i=r->NegWeightL_Size-1; i>=0; i--)
1226  {
1227  p->exp[r->NegWeightL_Offset[i]] -= POLY_NEGWEIGHT_OFFSET;
1228  }
1229  }
1230 }
#define POLY_NEGWEIGHT_OFFSET
Definition: monomials.h:244
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
static void p_MemSub_NegWeightAdjust ( poly  p,
const ring  r 
)
inlinestatic

Definition at line 1231 of file p_polys.h.

1232 {
1233  if (r->NegWeightL_Offset != NULL)
1234  {
1235  for (int i=r->NegWeightL_Size-1; i>=0; i--)
1236  {
1237  p->exp[r->NegWeightL_Offset[i]] += POLY_NEGWEIGHT_OFFSET;
1238  }
1239  }
1240 }
#define POLY_NEGWEIGHT_OFFSET
Definition: monomials.h:244
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
static poly p_Merge_q ( poly  p,
poly  q,
const ring  r 
)
inlinestatic

Definition at line 1141 of file p_polys.h.

1142 {
1143  assume( (p != q) || (p == NULL && q == NULL) );
1144  return r->p_Procs->p_Merge_q(p, q, r);
1145 }
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static long p_MinComp ( poly  p,
ring  lmRing,
ring  tailRing 
)
inlinestatic

Definition at line 308 of file p_polys.h.

309 {
310  long result,i;
311 
312  if(p==NULL) return 0;
313  result = p_GetComp(p,lmRing);
314  if (result != 0)
315  {
316  loop
317  {
318  pIter(p);
319  if(p==NULL) break;
320  i = p_GetComp(p,tailRing);
321  if (i<result) result = i;
322  }
323  }
324  return result;
325 }
BEGIN_NAMESPACE_SINGULARXX const ring lmRing
Definition: DebugPrint.h:30
loop
Definition: myNF.cc:98
return P p
Definition: myNF.cc:203
#define p_GetComp(p, r)
Definition: monomials.h:72
BEGIN_NAMESPACE_SINGULARXX const ring const ring tailRing
Definition: DebugPrint.h:30
#define pIter(p)
Definition: monomials.h:44
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
return result
Definition: facAbsBiFact.cc:76
static long p_MinComp ( poly  p,
ring  lmRing 
)
inlinestatic

Definition at line 327 of file p_polys.h.

327 {return p_MinComp(p,lmRing,lmRing);}
BEGIN_NAMESPACE_SINGULARXX const ring lmRing
Definition: DebugPrint.h:30
return P p
Definition: myNF.cc:203
static long p_MinComp(poly p, ring lmRing, ring tailRing)
Definition: p_polys.h:308
int p_MinDeg ( poly  p,
intvec w,
const ring  R 
)

Definition at line 4254 of file p_polys.cc.

4255 {
4256  if(p==NULL)
4257  return -1;
4258  int d=-1;
4259  while(p!=NULL)
4260  {
4261  int d0=0;
4262  for(int j=0;j<rVar(R);j++)
4263  if(w==NULL||j>=w->length())
4264  d0+=p_GetExp(p,j+1,R);
4265  else
4266  d0+=(*w)[j]*p_GetExp(p,j+1,R);
4267  if(d0<d||d==-1)
4268  d=d0;
4269  pIter(p);
4270  }
4271  return d;
4272 }
return P p
Definition: myNF.cc:203
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:537
int length() const
Definition: intvec.h:86
#define pIter(p)
Definition: monomials.h:44
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
int j
Definition: myNF.cc:70
const ring R
Definition: DebugPrint.cc:36
#define NULL
Definition: omList.c:10
poly p_mInit ( const char *  s,
BOOLEAN ok,
const ring  r 
)

Definition at line 1425 of file p_polys.cc.

1426 {
1427  poly p;
1428  const char *s=p_Read(st,p,r);
1429  if (*s!='\0')
1430  {
1431  if ((s!=st)&&isdigit(st[0]))
1432  {
1434  }
1435  ok=FALSE;
1436  p_Delete(&p,r);
1437  return NULL;
1438  }
1439  p_Test(p,r);
1440  ok=!errorreported;
1441  return p;
1442 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
#define TRUE
Definition: auxiliary.h:144
const char * p_Read(const char *st, poly &rc, const ring r)
Definition: p_polys.cc:1353
const ring r
Definition: syzextra.cc:208
#define p_Test(p, r)
Definition: p_polys.h:160
short errorreported
Definition: feFopen.cc:23
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:849
#define NULL
Definition: omList.c:10
polyrec * poly
Definition: hilb.h:10
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 982 of file p_polys.h.

984 {
985  int shorter;
986  const poly res = r->p_Procs->p_Minus_mm_Mult_qq(p, m, q, shorter, spNoether, r);
987  lp += lq - shorter;
988 // assume( lp == pLength(res) );
989  return res;
990 }
return P p
Definition: myNF.cc:203
poly res
Definition: myNF.cc:322
const ring r
Definition: syzextra.cc:208
int m
Definition: cfEzgcd.cc:119
polyrec * poly
Definition: hilb.h:10
static poly p_Minus_mm_Mult_qq ( poly  p,
const poly  m,
const poly  q,
const ring  r 
)
inlinestatic

Definition at line 993 of file p_polys.h.

994 {
995  int shorter;
996 
997  return r->p_Procs->p_Minus_mm_Mult_qq(p, m, q, shorter, NULL, r);
998 }
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208
int m
Definition: cfEzgcd.cc:119
#define NULL
Definition: omList.c:10
static poly p_Mult_mm ( poly  p,
poly  m,
const ring  r 
)
inlinestatic

Definition at line 974 of file p_polys.h.

975 {
976  if (p_LmIsConstant(m, r))
977  return p_Mult_nn(p, pGetCoeff(m), r);
978  else
979  return r->p_Procs->p_Mult_mm(p, m, r);
980 }
return P p
Definition: myNF.cc:203
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
static BOOLEAN p_LmIsConstant(const poly p, const ring r)
Definition: p_polys.h:955
const ring r
Definition: syzextra.cc:208
int m
Definition: cfEzgcd.cc:119
static poly p_Mult_nn(poly p, number n, const ring r)
Definition: p_polys.h:901
static poly p_Mult_nn ( poly  p,
number  n,
const ring  r 
)
inlinestatic

Definition at line 901 of file p_polys.h.

902 {
903  if (n_IsOne(n, r->cf))
904  return p;
905  else if (n_IsZero(n, r->cf))
906  {
907  r->p_Procs->p_Delete(&p, r); // NOTE: without p_Delete - memory leak!
908  return NULL;
909  } else
910  return r->p_Procs->p_Mult_nn(p, n, r);
911 }
return P p
Definition: myNF.cc:203
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the one element.
Definition: coeffs.h:469
const ring r
Definition: syzextra.cc:208
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the zero element.
Definition: coeffs.h:465
#define NULL
Definition: omList.c:10
static poly p_Mult_nn ( poly  p,
number  n,
const ring  lmRing,
const ring  tailRing 
)
inlinestatic

Definition at line 913 of file p_polys.h.

915 {
916 #ifndef PDEBUG
917  if (lmRing == tailRing)
918  return p_Mult_nn(p, n, tailRing);
919 #endif
920  poly pnext = pNext(p);
921  pNext(p) = NULL;
922  p = lmRing->p_Procs->p_Mult_nn(p, n, lmRing);
923  pNext(p) = tailRing->p_Procs->p_Mult_nn(pnext, n, tailRing);
924  return p;
925 }
BEGIN_NAMESPACE_SINGULARXX const ring lmRing
Definition: DebugPrint.h:30
return P p
Definition: myNF.cc:203
BEGIN_NAMESPACE_SINGULARXX const ring const ring tailRing
Definition: DebugPrint.h:30
static poly p_Mult_nn(poly p, number n, const ring r)
Definition: p_polys.h:901
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
polyrec * poly
Definition: hilb.h:10
static poly p_Mult_q ( poly  p,
poly  q,
const ring  r 
)
inlinestatic

Definition at line 1026 of file p_polys.h.

1027 {
1028  assume( (p != q) || (p == NULL && q == NULL) );
1029 
1030  if (p == NULL)
1031  {
1032  r->p_Procs->p_Delete(&q, r);
1033  return NULL;
1034  }
1035  if (q == NULL)
1036  {
1037  r->p_Procs->p_Delete(&p, r);
1038  return NULL;
1039  }
1040 
1041  if (pNext(p) == NULL)
1042  {
1043 #ifdef HAVE_PLURAL
1044  if (rIsPluralRing(r))
1045  q = nc_mm_Mult_p(p, q, r);
1046  else
1047 #endif /* HAVE_PLURAL */
1048  q = r->p_Procs->p_Mult_mm(q, p, r);
1049 
1050  r->p_Procs->p_Delete(&p, r);
1051  return q;
1052  }
1053 
1054  if (pNext(q) == NULL)
1055  {
1056  // NEEDED
1057 #ifdef HAVE_PLURAL
1058 /* if (rIsPluralRing(r))
1059  p = gnc_p_Mult_mm(p, q, r); // ???
1060  else*/
1061 #endif /* HAVE_PLURAL */
1062  p = r->p_Procs->p_Mult_mm(p, q, r);
1063 
1064  r->p_Procs->p_Delete(&q, r);
1065  return p;
1066  }
1067 #ifdef HAVE_PLURAL
1068  if (rIsPluralRing(r))
1069  return _nc_p_Mult_q(p, q, r);
1070  else
1071 #endif
1072  return _p_Mult_q(p, q, 0, r);
1073 }
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:273
return P p
Definition: myNF.cc:203
static poly nc_mm_Mult_p(const poly m, poly p, const ring r)
Definition: nc.h:250
const ring r
Definition: syzextra.cc:208
#define assume(x)
Definition: mod2.h:405
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:361
poly _nc_p_Mult_q(poly p, poly q, const ring r)
general NC-multiplication with destruction
Definition: old.gring.cc:274
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
static long p_MultExp ( poly  p,
int  v,
long  ee,
ring  r 
)
inlinestatic

Definition at line 616 of file p_polys.h.

617 {
619  long e = p_GetExp(p,v,r);
620  e *= ee;
621  return p_SetExp(p,v,e,r);
622 }
#define p_LmCheckPolyRing2(p, r)
Definition: monomials.h:207
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent : VarOffset encodes the position in p->exp
Definition: p_polys.h:483
static poly p_Neg ( poly  p,
const ring  r 
)
inlinestatic

Definition at line 1019 of file p_polys.h.

1020 {
1021  return r->p_Procs->p_Neg(p, r);
1022 }
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208
static poly p_New ( const ring  ,
omBin  bin 
)
inlinestatic

Definition at line 659 of file p_polys.h.

661 {
662  p_CheckRing2(r);
663  pAssume2(bin != NULL && omSizeWOfBin(r->PolyBin) == omSizeWOfBin(bin));
664  poly p;
665  omTypeAllocBin(poly, p, bin);
666  p_SetRingOfLm(p, r);
667  return p;
668 }
return P p
Definition: myNF.cc:203
#define p_CheckRing2(r)
Definition: monomials.h:208
#define omTypeAllocBin(type, addr, bin)
Definition: omAllocDecl.h:203
#define pAssume2(cond)
Definition: monomials.h:201
const ring r
Definition: syzextra.cc:208
#define p_SetRingOfLm(p, r)
Definition: monomials.h:152
#define NULL
Definition: omList.c:10
#define omSizeWOfBin(bin_ptr)
polyrec * poly
Definition: hilb.h:10
static poly p_New ( ring  r)
inlinestatic

Definition at line 670 of file p_polys.h.

671 {
672  return p_New(r, r->PolyBin);
673 }
const ring r
Definition: syzextra.cc:208
static poly p_New(const ring, omBin bin)
Definition: p_polys.h:659
void p_Norm ( poly  p1,
const ring  r 
)

Definition at line 3576 of file p_polys.cc.

3577 {
3578 #ifdef HAVE_RINGS
3579  if (rField_is_Ring(r))
3580  {
3581  if (!n_IsUnit(pGetCoeff(p1), r->cf)) return;
3582  // Werror("p_Norm not possible in the case of coefficient rings.");
3583  }
3584  else
3585 #endif
3586  if (p1!=NULL)
3587  {
3588  if (pNext(p1)==NULL)
3589  {
3590  p_SetCoeff(p1,n_Init(1,r->cf),r);
3591  return;
3592  }
3593  poly h;
3594  if (!n_IsOne(pGetCoeff(p1),r->cf))
3595  {
3596  number k, c;
3597  n_Normalize(pGetCoeff(p1),r->cf);
3598  k = pGetCoeff(p1);
3599  c = n_Init(1,r->cf);
3600  pSetCoeff0(p1,c);
3601  h = pNext(p1);
3602  while (h!=NULL)
3603  {
3604  c=n_Div(pGetCoeff(h),k,r->cf);
3605  // no need to normalize: Z/p, R
3606  // normalize already in nDiv: Q_a, Z/p_a
3607  // remains: Q
3608  if (rField_is_Q(r) && (!n_IsOne(c,r->cf))) n_Normalize(c,r->cf);
3609  p_SetCoeff(h,c,r);
3610  pIter(h);
3611  }
3612  n_Delete(&k,r->cf);
3613  }
3614  else
3615  {
3616  //if (r->cf->cfNormalize != nDummy2) //TODO: OPTIMIZE
3617  {
3618  h = pNext(p1);
3619  while (h!=NULL)
3620  {
3621  n_Normalize(pGetCoeff(h),r->cf);
3622  pIter(h);
3623  }
3624  }
3625  }
3626  }
3627 }
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:516
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the one element.
Definition: coeffs.h:469
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:539
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition: coeffs.h:579
int k
Definition: cfEzgcd.cc:93
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:407
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:458
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:434
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of &#39;a&#39; and &#39;b&#39;, i.e., a/b; raises an error if &#39;b&#39; is not invertible in r exceptio...
Definition: coeffs.h:616
#define pNext(p)
Definition: monomials.h:43
#define pSetCoeff0(p, n)
Definition: monomials.h:67
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
polyrec * poly
Definition: hilb.h:10
static Poly * h
Definition: janet.cc:978
void p_Normalize ( poly  p,
const ring  r 
)

Definition at line 3632 of file p_polys.cc.

3633 {
3634  if (rField_has_simple_inverse(r)) return; /* Z/p, GF(p,n), R, long R/C */
3635  while (p!=NULL)
3636  {
3637  // no test befor n_Normalize: n_Normalize should fix problems
3638  n_Normalize(pGetCoeff(p),r->cf);
3639  pIter(p);
3640  }
3641 }
return P p
Definition: myNF.cc:203
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition: coeffs.h:579
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
static BOOLEAN rField_has_simple_inverse(const ring r)
Definition: ring.h:494
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
#define NULL
Definition: omList.c:10
poly p_NSet ( number  n,
const ring  r 
)

returns the poly representing the number n, destroys n

Definition at line 1448 of file p_polys.cc.

1449 {
1450  if (n_IsZero(n,r->cf))
1451  {
1452  n_Delete(&n, r->cf);
1453  return NULL;
1454  }
1455  else
1456  {
1457  poly rc = p_Init(r);
1458  pSetCoeff0(rc,n);
1459  return rc;
1460  }
1461 }
const ring r
Definition: syzextra.cc:208
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the zero element.
Definition: coeffs.h:465
#define NULL
Definition: omList.c:10
#define pSetCoeff0(p, n)
Definition: monomials.h:67
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
polyrec * poly
Definition: hilb.h:10
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1249
poly p_One ( const ring  r)

Definition at line 1318 of file p_polys.cc.

1319 {
1320  poly rc = p_Init(r);
1321  pSetCoeff0(rc,n_Init(1,r->cf));
1322  return rc;
1323 }
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:539
const ring r
Definition: syzextra.cc:208
#define pSetCoeff0(p, n)
Definition: monomials.h:67
polyrec * poly
Definition: hilb.h:10
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1249
BOOLEAN p_OneComp ( poly  p,
const ring  r 
)

return TRUE if all monoms have the same component

Definition at line 1207 of file p_polys.cc.

1208 {
1209  if(p!=NULL)
1210  {
1211  long i = p_GetComp(p, r);
1212  while (pNext(p)!=NULL)
1213  {
1214  pIter(p);
1215  if(i != p_GetComp(p, r)) return FALSE;
1216  }
1217  }
1218  return TRUE;
1219 }
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
#define p_GetComp(p, r)
Definition: monomials.h:72
#define TRUE
Definition: auxiliary.h:144
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
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 3937 of file p_polys.cc.

3939 {
3940 #if 0
3941  p_Test(p, oldRing);
3942  PrintS("p_PermPoly::p: "); p_Write(p, oldRing, oldRing);
3943 #endif
3944  const int OldpVariables = rVar(oldRing);
3945  poly result = NULL;
3946  poly result_last = NULL;
3947  poly aq = NULL; /* the map coefficient */
3948  poly qq; /* the mapped monomial */
3949  assume(dst != NULL);
3950  assume(dst->cf != NULL);
3951  #ifdef HAVE_PLURAL
3952  poly tmp_mm=p_One(dst);
3953  #endif
3954  while (p != NULL)
3955  {
3956  // map the coefficient
3957  if ( ((OldPar == 0) || (par_perm == NULL) || rField_is_GF(oldRing)) && (nMap != NULL) )
3958  {
3959  qq = p_Init(dst);
3960  assume( nMap != NULL );
3961  number n = nMap(p_GetCoeff(p, oldRing), oldRing->cf, dst->cf);
3962  n_Test (n,dst->cf);
3963  if ( nCoeff_is_algExt(dst->cf) )
3964  n_Normalize(n, dst->cf);
3965  p_GetCoeff(qq, dst) = n;// Note: n can be a ZERO!!!
3966  }
3967  else
3968  {
3969  qq = p_One(dst);
3970 // aq = naPermNumber(p_GetCoeff(p, oldRing), par_perm, OldPar, oldRing); // no dst???
3971 // poly n_PermNumber(const number z, const int *par_perm, const int P, const ring src, const ring dst)
3972  aq = n_PermNumber(p_GetCoeff(p, oldRing), par_perm, OldPar, oldRing, dst);
3973  p_Test(aq, dst);
3974  if ( nCoeff_is_algExt(dst->cf) )
3975  p_Normalize(aq,dst);
3976  if (aq == NULL)
3977  p_SetCoeff(qq, n_Init(0, dst->cf),dst); // Very dirty trick!!!
3978  p_Test(aq, dst);
3979  }
3980  if (rRing_has_Comp(dst))
3981  p_SetComp(qq, p_GetComp(p, oldRing), dst);
3982  if ( n_IsZero(pGetCoeff(qq), dst->cf) )
3983  {
3984  p_LmDelete(&qq,dst);
3985  qq = NULL;
3986  }
3987  else
3988  {
3989  // map pars:
3990  int mapped_to_par = 0;
3991  for(int i = 1; i <= OldpVariables; i++)
3992  {
3993  int e = p_GetExp(p, i, oldRing);
3994  if (e != 0)
3995  {
3996  if (perm==NULL)
3997  p_SetExp(qq, i, e, dst);
3998  else if (perm[i]>0)
3999  {
4000  #ifdef HAVE_PLURAL
4001  if(use_mult)
4002  {
4003  p_SetExp(tmp_mm,perm[i],e,dst);
4004  p_Setm(tmp_mm,dst);
4005  qq=p_Mult_mm(qq,tmp_mm,dst);
4006  p_SetExp(tmp_mm,perm[i],0,dst);
4007 
4008  }
4009  else
4010  #endif
4011  p_AddExp(qq,perm[i], e/*p_GetExp( p,i,oldRing)*/, dst);
4012  }
4013  else if (perm[i]<0)
4014  {
4015  number c = p_GetCoeff(qq, dst);
4016  if (rField_is_GF(dst))
4017  {
4018  assume( dst->cf->extRing == NULL );
4019  number ee = n_Param(1, dst);
4020  number eee;
4021  n_Power(ee, e, &eee, dst->cf); //nfDelete(ee,dst);
4022  ee = n_Mult(c, eee, dst->cf);
4023  //nfDelete(c,dst);nfDelete(eee,dst);
4024  pSetCoeff0(qq,ee);
4025  }
4026  else if (nCoeff_is_Extension(dst->cf))
4027  {
4028  const int par = -perm[i];
4029  assume( par > 0 );
4030 // WarnS("longalg missing 3");
4031 #if 1
4032  const coeffs C = dst->cf;
4033  assume( C != NULL );
4034  const ring R = C->extRing;
4035  assume( R != NULL );
4036  assume( par <= rVar(R) );
4037  poly pcn; // = (number)c
4038  assume( !n_IsZero(c, C) );
4039  if( nCoeff_is_algExt(C) )
4040  pcn = (poly) c;
4041  else // nCoeff_is_transExt(C)
4042  pcn = NUM((fraction)c);
4043  if (pNext(pcn) == NULL) // c->z
4044  p_AddExp(pcn, -perm[i], e, R);
4045  else /* more difficult: we have really to multiply: */
4046  {
4047  poly mmc = p_ISet(1, R);
4048  p_SetExp(mmc, -perm[i], e, R);
4049  p_Setm(mmc, R);
4050  number nnc;
4051  // convert back to a number: number nnc = mmc;
4052  if( nCoeff_is_algExt(C) )
4053  nnc = (number) mmc;
4054  else // nCoeff_is_transExt(C)
4055  nnc = ntInit(mmc, C);
4056  p_GetCoeff(qq, dst) = n_Mult((number)c, nnc, C);
4057  n_Delete((number *)&c, C);
4058  n_Delete((number *)&nnc, C);
4059  }
4060  mapped_to_par=1;
4061 #endif
4062  }
4063  }
4064  else
4065  {
4066  /* this variable maps to 0 !*/
4067  p_LmDelete(&qq, dst);
4068  break;
4069  }
4070  }
4071  }
4072  if ( mapped_to_par && (qq!= NULL) && nCoeff_is_algExt(dst->cf) )
4073  {
4074  number n = p_GetCoeff(qq, dst);
4075  n_Normalize(n, dst->cf);
4076  p_GetCoeff(qq, dst) = n;
4077  }
4078  }
4079  pIter(p);
4080 
4081 #if 0
4082  p_Test(aq,dst);
4083  PrintS("aq: "); p_Write(aq, dst, dst);
4084 #endif
4085 
4086 
4087 #if 1
4088  if (qq!=NULL)
4089  {
4090  p_Setm(qq,dst);
4091 
4092  p_Test(aq,dst);
4093  p_Test(qq,dst);
4094 
4095 #if 0
4096  PrintS("qq: "); p_Write(qq, dst, dst);
4097 #endif
4098 
4099  if (aq!=NULL)
4100  qq=p_Mult_q(aq,qq,dst);
4101  aq = qq;
4102  while (pNext(aq) != NULL) pIter(aq);
4103  if (result_last==NULL)
4104  {
4105  result=qq;
4106  }
4107  else
4108  {
4109  pNext(result_last)=qq;
4110  }
4111  result_last=aq;
4112  aq = NULL;
4113  }
4114  else if (aq!=NULL)
4115  {
4116  p_Delete(&aq,dst);
4117  }
4118  }
4119  result=p_SortAdd(result,dst);
4120 #else
4121  // if (qq!=NULL)
4122  // {
4123  // pSetm(qq);
4124  // pTest(qq);
4125  // pTest(aq);
4126  // if (aq!=NULL) qq=pMult(aq,qq);
4127  // aq = qq;
4128  // while (pNext(aq) != NULL) pIter(aq);
4129  // pNext(aq) = result;
4130  // aq = NULL;
4131  // result = qq;
4132  // }
4133  // else if (aq!=NULL)
4134  // {
4135  // pDelete(&aq);
4136  // }
4137  //}
4138  //p = result;
4139  //result = NULL;
4140  //while (p != NULL)
4141  //{
4142  // qq = p;
4143  // pIter(p);
4144  // qq->next = NULL;
4145  // result = pAdd(result, qq);
4146  //}
4147 #endif
4148  p_Test(result,dst);
4149 #if 0
4150  p_Test(result,dst);
4151  PrintS("result: "); p_Write(result,dst,dst);
4152 #endif
4153  #ifdef HAVE_PLURAL
4154  p_LmDelete(&tmp_mm,dst);
4155  #endif
4156  return result;
4157 }
return P p
Definition: myNF.cc:203
static poly p_Mult_mm(poly p, poly m, const ring r)
Definition: p_polys.h:974
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition: p_polys.h:242
#define p_GetComp(p, r)
Definition: monomials.h:72
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:539
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:537
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition: coeffs.h:579
static BOOLEAN rField_is_GF(const ring r)
Definition: ring.h:467
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:407
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..n_NumberOfParameters(...)
Definition: coeffs.h:806
#define pIter(p)
Definition: monomials.h:44
static poly p_SortAdd(poly p, const ring r, BOOLEAN revert=FALSE)
Definition: p_polys.h:1148
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of &#39;a&#39; and &#39;b&#39;, i.e., a*b
Definition: coeffs.h:637
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
Definition: coeffs.h:913
poly p_One(const ring r)
Definition: p_polys.cc:1318
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
number ntInit(long i, const coeffs cf)
Definition: transext.cc:616
#define assume(x)
Definition: mod2.h:405
The main handler for Singular numbers which are suitable for Singular polynomials.
const ring R
Definition: DebugPrint.cc:36
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
Definition: coeffs.h:739
int i
Definition: cfEzgcd.cc:123
void PrintS(const char *s)
Definition: reporter.cc:294
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the zero element.
Definition: coeffs.h:465
#define p_Test(p, r)
Definition: p_polys.h:160
void p_Normalize(poly p, const ring r)
Definition: p_polys.cc:3632
#define rRing_has_Comp(r)
Definition: monomials.h:274
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:849
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent : VarOffset encodes the position in p->exp
Definition: p_polys.h:483
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:633
#define NULL
Definition: omList.c:10
poly n_PermNumber(const number z, const int *par_perm, const int, const ring src, const ring dst)
Definition: p_polys.cc:3833
#define pNext(p)
Definition: monomials.h:43
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:228
#define pSetCoeff0(p, n)
Definition: monomials.h:67
static long p_AddExp(poly p, int v, long ee, ring r)
Definition: p_polys.h:601
#define p_GetCoeff(p, r)
Definition: monomials.h:57
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
Definition: coeffs.h:849
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:706
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
void p_Write(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:206
polyrec * poly
Definition: hilb.h:10
int perm[100]
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1249
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
Definition: p_polys.cc:1302
static poly p_Mult_q(poly p, poly q, const ring r)
Definition: p_polys.h:1026
return result
Definition: facAbsBiFact.cc:76
static poly p_Plus_mm_Mult_qq ( poly  p,
poly  m,
poly  q,
int &  lp,
int  lq,
const ring  r 
)
inlinestatic

Definition at line 1112 of file p_polys.h.

1114 {
1115 #ifdef HAVE_PLURAL
1116  if (rIsPluralRing(r))
1117  return nc_p_Plus_mm_Mult_qq(p, m, q, lp, lq, r);
1118 #endif
1119 
1120 // this should be implemented more efficiently
1121  poly res;
1122  int shorter;
1123  number n_old = pGetCoeff(m);
1124  number n_neg = n_Copy(n_old, r->cf);
1125  n_neg = n_InpNeg(n_neg, r->cf);
1126  pSetCoeff0(m, n_neg);
1127  res = r->p_Procs->p_Minus_mm_Mult_qq(p, m, q, shorter, NULL, r);
1128  lp = (lp + lq) - shorter;
1129  pSetCoeff0(m, n_old);
1130  n_Delete(&n_neg, r->cf);
1131  return res;
1132 }
return P p
Definition: myNF.cc:203
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
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:227
poly res
Definition: myNF.cc:322
const ring r
Definition: syzextra.cc:208
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:361
int m
Definition: cfEzgcd.cc:119
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:558
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of &#39;n&#39;
Definition: coeffs.h:452
#define pSetCoeff0(p, n)
Definition: monomials.h:67
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
polyrec * poly
Definition: hilb.h:10
static poly p_Plus_mm_Mult_qq ( poly  p,
poly  m,
poly  q,
const ring  r 
)
inlinestatic

Definition at line 1134 of file p_polys.h.

1135 {
1136  int lp = 0, lq = 0;
1137  return p_Plus_mm_Mult_qq(p, m, q, lp, lq, r);
1138 }
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208
int m
Definition: cfEzgcd.cc:119
static poly p_Plus_mm_Mult_qq(poly p, poly m, poly q, int &lp, int lq, const ring r)
Definition: p_polys.h:1112
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 1781 of file p_polys.cc.

1782 {
1783  assume(divisor != NULL);
1784  if (p == NULL) return NULL;
1785 
1786  poly result = NULL;
1787  number divisorLC = p_GetCoeff(divisor, r);
1788  int divisorLE = p_GetExp(divisor, 1, r);
1789  while ((p != NULL) && (p_Deg(p, r) >= p_Deg(divisor, r)))
1790  {
1791  /* determine t = LT(p) / LT(divisor) */
1792  poly t = p_ISet(1, r);
1793  number c = n_Div(p_GetCoeff(p, r), divisorLC, r->cf);
1794  n_Normalize(c,r->cf);
1795  p_SetCoeff(t, c, r);
1796  int e = p_GetExp(p, 1, r) - divisorLE;
1797  p_SetExp(t, 1, e, r);
1798  p_Setm(t, r);
1799  if (needResult) result = p_Add_q(result, p_Copy(t, r), r);
1800  p = p_Add_q(p, p_Neg(p_Mult_q(t, p_Copy(divisor, r), r), r), r);
1801  }
1802  return result;
1803 }
return P p
Definition: myNF.cc:203
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition: coeffs.h:579
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:407
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition: p_polys.h:810
long p_Deg(poly a, const ring r)
Definition: p_polys.cc:586
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
#define assume(x)
Definition: mod2.h:405
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent : VarOffset encodes the position in p->exp
Definition: p_polys.h:483
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of &#39;a&#39; and &#39;b&#39;, i.e., a/b; raises an error if &#39;b&#39; is not invertible in r exceptio...
Definition: coeffs.h:616
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:228
#define p_GetCoeff(p, r)
Definition: monomials.h:57
static poly p_Neg(poly p, const ring r)
Definition: p_polys.h:1019
polyrec * poly
Definition: hilb.h:10
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:883
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
Definition: p_polys.cc:1302
static poly p_Mult_q(poly p, poly q, const ring r)
Definition: p_polys.h:1026
return result
Definition: facAbsBiFact.cc:76
poly p_Power ( poly  p,
int  i,
const ring  r 
)

Definition at line 2108 of file p_polys.cc.

2109 {
2110  poly rc=NULL;
2111 
2112  if (i==0)
2113  {
2114  p_Delete(&p,r);
2115  return p_One(r);
2116  }
2117 
2118  if(p!=NULL)
2119  {
2120  if ( (i > 0) && ((unsigned long ) i > (r->bitmask)))
2121  {
2122  Werror("exponent %d is too large, max. is %ld",i,r->bitmask);
2123  return NULL;
2124  }
2125  switch (i)
2126  {
2127 // cannot happen, see above
2128 // case 0:
2129 // {
2130 // rc=pOne();
2131 // pDelete(&p);
2132 // break;
2133 // }
2134  case 1:
2135  rc=p;
2136  break;
2137  case 2:
2138  rc=p_Mult_q(p_Copy(p,r),p,r);
2139  break;
2140  default:
2141  if (i < 0)
2142  {
2143  p_Delete(&p,r);
2144  return NULL;
2145  }
2146  else
2147  {
2148 #ifdef HAVE_PLURAL
2149  if (rIsPluralRing(r)) /* in the NC case nothing helps :-( */
2150  {
2151  int j=i;
2152  rc = p_Copy(p,r);
2153  while (j>1)
2154  {
2155  rc = p_Mult_q(p_Copy(p,r),rc,r);
2156  j--;
2157  }
2158  p_Delete(&p,r);
2159  return rc;
2160  }
2161 #endif
2162  rc = pNext(p);
2163  if (rc == NULL)
2164  return p_MonPower(p,i,r);
2165  /* else: binom ?*/
2166  int char_p=rChar(r);
2167  if ((char_p>0) && (i>char_p)
2168  && ((rField_is_Zp(r,char_p)
2169  || (rField_is_Zp_a(r,char_p)))))
2170  {
2171  poly h=p_Pow_charp(p_Copy(p,r),char_p,r);
2172  int rest=i-char_p;
2173  while (rest>=char_p)
2174  {
2175  rest-=char_p;
2176  h=p_Mult_q(h,p_Pow_charp(p_Copy(p,r),char_p,r),r);
2177  }
2178  poly res=h;
2179  if (rest>0)
2180  res=p_Mult_q(p_Power(p_Copy(p,r),rest,r),h,r);
2181  p_Delete(&p,r);
2182  return res;
2183  }
2184  if ((pNext(rc) != NULL)
2185 #ifdef HAVE_RINGS
2186  || rField_is_Ring(r)
2187 #endif
2188  )
2189  return p_Pow(p,i,r);
2190  if ((char_p==0) || (i<=char_p))
2191  return p_TwoMonPower(p,i,r);
2192  return p_Pow(p,i,r);
2193  }
2194  /*end default:*/
2195  }
2196  }
2197  return rc;
2198 }
static poly p_MonPower(poly p, int exp, const ring r)
Definition: p_polys.cc:1911
static BOOLEAN rField_is_Zp_a(const ring r)
Definition: ring.h:475
return P p
Definition: myNF.cc:203
int rChar(ring r)
Definition: ring.cc:684
static poly p_TwoMonPower(poly p, int exp, const ring r)
Definition: p_polys.cc:2017
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition: p_polys.h:810
poly res
Definition: myNF.cc:322
const ring r
Definition: syzextra.cc:208
poly p_One(const ring r)
Definition: p_polys.cc:1318
int j
Definition: myNF.cc:70
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:361
int i
Definition: cfEzgcd.cc:123
static poly p_Pow(poly p, int i, const ring r)
Definition: p_polys.cc:2082
static BOOLEAN rField_is_Zp(const ring r)
Definition: ring.h:452
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:849
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:434
#define NULL
Definition: omList.c:10
static poly p_Pow_charp(poly p, int i, const ring r)
Definition: p_polys.cc:2096
#define pNext(p)
Definition: monomials.h:43
polyrec * poly
Definition: hilb.h:10
static Poly * h
Definition: janet.cc:978
static poly p_Mult_q(poly p, poly q, const ring r)
Definition: p_polys.h:1026
poly p_Power(poly p, int i, const ring r)
Definition: p_polys.cc:2108
void Werror(const char *fmt,...)
Definition: reporter.cc:199
void p_ProjectiveUnique ( poly  p,
const ring  r 
)

Definition at line 3019 of file p_polys.cc.

3020 {
3021  if( ph == NULL )
3022  return;
3023 
3024  assume( r != NULL ); assume( r->cf != NULL ); const coeffs C = r->cf;
3025 
3026  number h;
3027  poly p;
3028 
3029 #ifdef HAVE_RINGS
3030  if (rField_is_Ring(r))
3031  {
3032  p_Content(ph,r);
3033  if(!n_GreaterZero(pGetCoeff(ph),C)) ph = p_Neg(ph,r);
3034  assume( n_GreaterZero(pGetCoeff(ph),C) );
3035  return;
3036  }
3037 #endif
3038 
3040  {
3041  assume( n_GreaterZero(pGetCoeff(ph),C) );
3042  if(!n_GreaterZero(pGetCoeff(ph),C)) ph = p_Neg(ph,r);
3043  return;
3044  }
3045  p = ph;
3046 
3047  assume(p != NULL);
3048 
3049  if(pNext(p)==NULL) // a monomial
3050  {
3051  p_SetCoeff(p, n_Init(1, C), r);
3052  return;
3053  }
3054 
3055  assume(pNext(p)!=NULL);
3056 
3057  if(!rField_is_Q(r) && !nCoeff_is_transExt(C))
3058  {
3059  h = p_GetCoeff(p, C);
3060  number hInv = n_Invers(h, C);
3061  pIter(p);
3062  while (p!=NULL)
3063  {
3064  p_SetCoeff(p, n_Mult(p_GetCoeff(p, C), hInv, C), r);
3065  pIter(p);
3066  }
3067  n_Delete(&hInv, C);
3068  p = ph;
3069  p_SetCoeff(p, n_Init(1, C), r);
3070  }
3071 
3072  p_Cleardenom(ph, r); //performs also a p_Content
3073 
3074 
3075  /* normalize ph over a transcendental extension s.t.
3076  lead (ph) is > 0 if extRing->cf == Q
3077  or lead (ph) is monic if extRing->cf == Zp*/
3078  if (nCoeff_is_transExt(C))
3079  {
3080  p= ph;
3081  h= p_GetCoeff (p, C);
3082  fraction f = (fraction) h;
3083  number n=p_GetCoeff (NUM (f),C->extRing->cf);
3084  if (rField_is_Q (C->extRing))
3085  {
3086  if (!n_GreaterZero(n,C->extRing->cf))
3087  {
3088  p=p_Neg (p,r);
3089  }
3090  }
3091  else if (rField_is_Zp(C->extRing))
3092  {
3093  if (!n_IsOne (n, C->extRing->cf))
3094  {
3095  n=n_Invers (n,C->extRing->cf);
3096  nMapFunc nMap;
3097  nMap= n_SetMap (C->extRing->cf, C);
3098  number ninv= nMap (n,C->extRing->cf, C);
3099  p=p_Mult_nn (p, ninv, r);
3100  n_Delete (&ninv, C);
3101  n_Delete (&n, C->extRing->cf);
3102  }
3103  }
3104  p= ph;
3105  }
3106 
3107  return;
3108 }
return P p
Definition: myNF.cc:203
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the one element.
Definition: coeffs.h:469
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:539
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:407
#define pIter(p)
Definition: monomials.h:44
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of &#39;a&#39; and &#39;b&#39;, i.e., a*b
Definition: coeffs.h:637
const ring r
Definition: syzextra.cc:208
#define TEST_OPT_INTSTRATEGY
Definition: options.h:105
#define assume(x)
Definition: mod2.h:405
The main handler for Singular numbers which are suitable for Singular polynomials.
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:72
static FORCE_INLINE number n_Invers(number a, const coeffs r)
return the multiplicative inverse of &#39;a&#39;; raise an error if &#39;a&#39; is not invertible ...
Definition: coeffs.h:565
static FORCE_INLINE BOOLEAN nCoeff_is_transExt(const coeffs r)
TRUE iff r represents a transcendental extension field.
Definition: coeffs.h:921
FILE * f
Definition: checklibs.c:7
static poly p_Mult_nn(poly p, number n, const ring r)
Definition: p_polys.h:901
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:458
void p_Content(poly ph, const ring r)
Definition: p_polys.cc:2207
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:722
static BOOLEAN rField_is_Zp(const ring r)
Definition: ring.h:452
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:434
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
#define p_GetCoeff(p, r)
Definition: monomials.h:57
static poly p_Neg(poly p, const ring r)
Definition: p_polys.h:1019
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
static FORCE_INLINE BOOLEAN n_GreaterZero(number n, const coeffs r)
ordered fields: TRUE iff &#39;n&#39; is positive; in Z/pZ: TRUE iff 0 < m <= roundedBelow(p/2), where m is the long representing n in C: TRUE iff (Im(n) != 0 and Im(n) >= 0) or (Im(n) == 0 and Re(n) >= 0) in K(a)/<p(a)>: TRUE iff (n != 0 and (LC(n) > 0 or deg(n) > 0)) in K(t_1, ..., t_n): TRUE iff (LC(numerator(n) is a constant and > 0) or (LC(numerator(n) is not a constant) in Z/2^kZ: TRUE iff 0 < n <= 2^(k-1) in Z/mZ: TRUE iff the internal mpz is greater than zero in Z: TRUE iff n > 0
Definition: coeffs.h:495
polyrec * poly
Definition: hilb.h:10
static Poly * h
Definition: janet.cc:978
poly p_Cleardenom(poly p, const ring r)
Definition: p_polys.cc:2707
const char* p_Read ( const char *  s,
poly p,
const ring  r 
)

Definition at line 1353 of file p_polys.cc.

1354 {
1355  if (r==NULL) { rc=NULL;return st;}
1356  int i,j;
1357  rc = p_Init(r);
1358  const char *s = n_Read(st,&(p_GetCoeff(rc, r)),r->cf);
1359  if (s==st)
1360  /* i.e. it does not start with a coeff: test if it is a ringvar*/
1361  {
1362  j = r_IsRingVar(s,r->names,r->N);
1363  if (j >= 0)
1364  {
1365  p_IncrExp(rc,1+j,r);
1366  while (*s!='\0') s++;
1367  goto done;
1368  }
1369  }
1370  while (*s!='\0')
1371  {
1372  char ss[2];
1373  ss[0] = *s++;
1374  ss[1] = '\0';
1375  j = r_IsRingVar(ss,r->names,r->N);
1376  if (j >= 0)
1377  {
1378  const char *s_save=s;
1379  s = eati(s,&i);
1380  if (((unsigned long)i) > r->bitmask/2)
1381  {
1382  // exponent to large: it is not a monomial
1383  p_LmDelete(&rc,r);
1384  return s_save;
1385  }
1386  p_AddExp(rc,1+j, (long)i, r);
1387  }
1388  else
1389  {
1390  // 1st char of is not a varname
1391  // We return the parsed polynomial nevertheless. This is needed when
1392  // we are parsing coefficients in a rational function field.
1393  s--;
1394  break;
1395  }
1396  }
1397 done:
1398  if (n_IsZero(pGetCoeff(rc),r->cf)) p_LmDelete(&rc,r);
1399  else
1400  {
1401 #ifdef HAVE_PLURAL
1402  // in super-commutative ring
1403  // squares of anti-commutative variables are zeroes!
1404  if(rIsSCA(r))
1405  {
1406  const unsigned int iFirstAltVar = scaFirstAltVar(r);
1407  const unsigned int iLastAltVar = scaLastAltVar(r);
1408 
1409  assume(rc != NULL);
1410 
1411  for(unsigned int k = iFirstAltVar; k <= iLastAltVar; k++)
1412  if( p_GetExp(rc, k, r) > 1 )
1413  {
1414  p_LmDelete(&rc, r);
1415  goto finish;
1416  }
1417  }
1418 #endif
1419 
1420  p_Setm(rc,r);
1421  }
1422 finish:
1423  return s;
1424 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
const char * eati(const char *s, int *i)
Definition: reporter.cc:390
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. As defined here, it is merely a helper !!! method for parsing number input strings.
Definition: coeffs.h:599
static long p_IncrExp(poly p, int v, ring r)
Definition: p_polys.h:586
int k
Definition: cfEzgcd.cc:93
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
int r_IsRingVar(const char *n, char **names, int N)
Definition: ring.cc:222
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
int j
Definition: myNF.cc:70
#define assume(x)
Definition: mod2.h:405
int i
Definition: cfEzgcd.cc:123
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the zero element.
Definition: coeffs.h:465
static short scaFirstAltVar(ring r)
Definition: sca.h:18
#define NULL
Definition: omList.c:10
static short scaLastAltVar(ring r)
Definition: sca.h:25
static bool rIsSCA(const ring r)
Definition: nc.h:206
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:228
static long p_AddExp(poly p, int v, long ee, ring r)
Definition: p_polys.h:601
#define p_GetCoeff(p, r)
Definition: monomials.h:57
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:706
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1249
poly p_Series ( int  n,
poly  p,
poly  u,
intvec w,
const ring  R 
)

Definition at line 4276 of file p_polys.cc.

4277 {
4278  short *ww=iv2array(w,R);
4279  if(p!=NULL)
4280  {
4281  if(u==NULL)
4282  p=p_JetW(p,n,ww,R);
4283  else
4284  p=p_JetW(p_Mult_q(p,p_Invers(n-p_MinDeg(p,w,R),u,w,R),R),n,ww,R);
4285  }
4286  omFreeSize((ADDRESS)ww,(rVar(R)+1)*sizeof(short));
4287  return p;
4288 }
return P p
Definition: myNF.cc:203
short * iv2array(intvec *iv, const ring R)
Definition: weight.cc:208
int p_MinDeg(poly p, intvec *w, const ring R)
Definition: p_polys.cc:4254
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:537
void * ADDRESS
Definition: auxiliary.h:161
poly p_Invers(int n, poly u, intvec *w, const ring R)
Definition: p_polys.cc:4290
const ring R
Definition: DebugPrint.cc:36
poly p_JetW(poly p, int m, short *w, const ring R)
Definition: p_polys.cc:4236
#define NULL
Definition: omList.c:10
static poly p_Mult_q(poly p, poly q, const ring r)
Definition: p_polys.h:1026
static number p_SetCoeff ( poly  p,
number  n,
ring  r 
)
inlinestatic

Definition at line 407 of file p_polys.h.

408 {
410  n_Delete(&(p->coef), r->cf);
411  (p)->coef=n;
412  return n;
413 }
#define p_LmCheckPolyRing2(p, r)
Definition: monomials.h:207
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
static unsigned long p_SetComp ( poly  p,
unsigned long  c,
ring  r 
)
inlinestatic

Definition at line 242 of file p_polys.h.

243 {
245  if (r->pCompIndex>=0) __p_GetComp(p,r) = c;
246  return c;
247 }
#define p_LmCheckPolyRing2(p, r)
Definition: monomials.h:207
#define __p_GetComp(p, r)
Definition: monomials.h:71
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208
static void p_SetCompP ( poly  p,
int  i,
ring  r 
)
inlinestatic

Definition at line 249 of file p_polys.h.

250 {
251  if (p != NULL)
252  {
253  p_Test(p, r);
255  {
256  do
257  {
258  p_SetComp(p, i, r);
259  p_SetmComp(p, r);
260  pIter(p);
261  }
262  while (p != NULL);
263  }
264  else
265  {
266  do
267  {
268  p_SetComp(p, i, r);
269  pIter(p);
270  }
271  while(p != NULL);
272  }
273  }
274 }
return P p
Definition: myNF.cc:203
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition: p_polys.h:242
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
int i
Definition: cfEzgcd.cc:123
BOOLEAN rOrd_SetCompRequiresSetm(const ring r)
return TRUE if p_SetComp requires p_Setm
Definition: ring.cc:1875
#define p_Test(p, r)
Definition: p_polys.h:160
#define p_SetmComp
Definition: p_polys.h:239
#define NULL
Definition: omList.c:10
static void p_SetCompP ( poly  p,
int  i,
ring  lmRing,
ring  tailRing 
)
inlinestatic

Definition at line 276 of file p_polys.h.

277 {
278  if (p != NULL)
279  {
280  p_SetComp(p, i, lmRing);
281  p_SetmComp(p, lmRing);
283  }
284 }
BEGIN_NAMESPACE_SINGULARXX const ring lmRing
Definition: DebugPrint.h:30
return P p
Definition: myNF.cc:203
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition: p_polys.h:242
BEGIN_NAMESPACE_SINGULARXX const ring const ring tailRing
Definition: DebugPrint.h:30
static void p_SetCompP(poly p, int i, ring r)
Definition: p_polys.h:249
int i
Definition: cfEzgcd.cc:123
#define p_SetmComp
Definition: p_polys.h:239
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
static unsigned long p_SetExp ( poly  p,
const unsigned long  e,
const unsigned long  iBitmask,
const int  VarOffset 
)
inlinestatic

set a single variable exponent : VarOffset encodes the position in p->exp

See also
p_GetExp

Definition at line 483 of file p_polys.h.

484 {
485  pAssume2(e>=0);
486  pAssume2(e<=iBitmask);
487  pAssume2((VarOffset >> (24 + 6)) == 0);
488 
489  // shift e to the left:
490  register int shift = VarOffset >> 24;
491  unsigned long ee = e << shift /*(VarOffset >> 24)*/;
492  // find the bits in the exponent vector
493  register int offset = (VarOffset & 0xffffff);
494  // clear the bits in the exponent vector:
495  p->exp[offset] &= ~( iBitmask << shift );
496  // insert e with |
497  p->exp[ offset ] |= ee;
498  return e;
499 }
return P p
Definition: myNF.cc:203
#define pAssume2(cond)
Definition: monomials.h:201
int offset
Definition: libparse.cc:1091
static long p_SetExp ( poly  p,
const long  e,
const ring  r,
const int  VarOffset 
)
inlinestatic

Definition at line 557 of file p_polys.h.

558 {
560  pAssume2(VarOffset != -1);
561  return p_SetExp(p, e, r->bitmask, VarOffset);
562 }
#define p_LmCheckPolyRing2(p, r)
Definition: monomials.h:207
return P p
Definition: myNF.cc:203
#define pAssume2(cond)
Definition: monomials.h:201
const ring r
Definition: syzextra.cc:208
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent : VarOffset encodes the position in p->exp
Definition: p_polys.h:483
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 577 of file p_polys.h.

578 {
580  pAssume2(v>0 && v <= r->N);
581  pAssume2(r->VarOffset[v] != -1);
582  return p_SetExp(p, e, r->bitmask, r->VarOffset[v]);
583 }
#define p_LmCheckPolyRing2(p, r)
Definition: monomials.h:207
return P p
Definition: myNF.cc:203
#define pAssume2(cond)
Definition: monomials.h:201
const ring r
Definition: syzextra.cc:208
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:49
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent : VarOffset encodes the position in p->exp
Definition: p_polys.h:483
static void p_SetExpV ( poly  p,
int *  ev,
const ring  r 
)
inlinestatic

Definition at line 1457 of file p_polys.h.

1458 {
1460  for (int j = r->N; j; j--)
1461  p_SetExp(p, j, ev[j], r);
1462 
1463  p_SetComp(p, ev[0],r);
1464  p_Setm(p, r);
1465 }
return P p
Definition: myNF.cc:203
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition: p_polys.h:242
const ring r
Definition: syzextra.cc:208
int j
Definition: myNF.cc:70
#define p_LmCheckPolyRing1(p, r)
Definition: monomials.h:185
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent : VarOffset encodes the position in p->exp
Definition: p_polys.h:483
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:228
static void p_Setm ( poly  p,
const ring  r 
)
inlinestatic

Definition at line 228 of file p_polys.h.

229 {
230  p_CheckRing2(r);
231  r->p_Setm(p, r);
232 }
return P p
Definition: myNF.cc:203
#define p_CheckRing2(r)
Definition: monomials.h:208
const ring r
Definition: syzextra.cc:208
void p_SetModDeg ( intvec w,
ring  r 
)

Definition at line 3528 of file p_polys.cc.

3529 {
3530  if (w!=NULL)
3531  {
3532  r->pModW = w;
3533  pOldFDeg = r->pFDeg;
3534  pOldLDeg = r->pLDeg;
3535  pOldLexOrder = r->pLexOrder;
3537  r->pLexOrder = TRUE;
3538  }
3539  else
3540  {
3541  r->pModW = NULL;
3543  r->pLexOrder = pOldLexOrder;
3544  }
3545 }
static BOOLEAN pOldLexOrder
Definition: p_polys.cc:3517
static long pModDeg(poly p, ring r)
Definition: p_polys.cc:3519
#define TRUE
Definition: auxiliary.h:144
const ring r
Definition: syzextra.cc:208
void pSetDegProcs(ring r, pFDegProc new_FDeg, pLDegProc new_lDeg)
Definition: p_polys.cc:3492
void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
Definition: p_polys.cc:3504
static pLDegProc pOldLDeg
Definition: p_polys.cc:3516
#define NULL
Definition: omList.c:10
static pFDegProc pOldFDeg
Definition: p_polys.cc:3515
const CanonicalForm & w
Definition: facAbsFact.cc:55
static poly p_ShallowCopyDelete ( poly  p,
const ring  r,
omBin  bin 
)
inlinestatic

Definition at line 875 of file p_polys.h.

876 {
878  pAssume2(omSizeWOfBin(r->PolyBin) == omSizeWOfBin(bin));
879  return r->p_Procs->p_ShallowCopyDelete(p, r, bin);
880 }
#define p_LmCheckPolyRing2(p, r)
Definition: monomials.h:207
return P p
Definition: myNF.cc:203
#define pAssume2(cond)
Definition: monomials.h:201
const ring r
Definition: syzextra.cc:208
#define omSizeWOfBin(bin_ptr)
void p_ShallowDelete ( poly p,
const ring  r 
)
void p_Shift ( poly p,
int  i,
const ring  r 
)

shifts components of the vector p by i

Definition at line 4512 of file p_polys.cc.

4513 {
4514  poly qp1 = *p,qp2 = *p;/*working pointers*/
4515  int j = p_MaxComp(*p,r),k = p_MinComp(*p,r);
4516 
4517  if (j+i < 0) return ;
4518  while (qp1 != NULL)
4519  {
4520  if ((p_GetComp(qp1,r)+i > 0) || ((j == -i) && (j == k)))
4521  {
4522  p_AddComp(qp1,i,r);
4523  p_SetmComp(qp1,r);
4524  qp2 = qp1;
4525  pIter(qp1);
4526  }
4527  else
4528  {
4529  if (qp2 == *p)
4530  {
4531  pIter(*p);
4532  p_LmDelete(&qp2,r);
4533  qp2 = *p;
4534  qp1 = *p;
4535  }
4536  else
4537  {
4538  qp2->next = qp1->next;
4539  if (qp1!=NULL) p_LmDelete(&qp1,r);
4540  qp1 = qp2->next;
4541  }
4542  }
4543  }
4544 }
static unsigned long p_AddComp(poly p, unsigned long v, ring r)
Definition: p_polys.h:442
return
Definition: syzextra.cc:280
return P p
Definition: myNF.cc:203
#define p_GetComp(p, r)
Definition: monomials.h:72
int k
Definition: cfEzgcd.cc:93
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
int j
Definition: myNF.cc:70
int i
Definition: cfEzgcd.cc:123
static long p_MinComp(poly p, ring lmRing, ring tailRing)
Definition: p_polys.h:308
#define p_SetmComp
Definition: p_polys.h:239
#define NULL
Definition: omList.c:10
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:706
polyrec * poly
Definition: hilb.h:10
static long p_MaxComp(poly p, ring lmRing, ring tailRing)
Definition: p_polys.h:287
void p_SimpleContent ( poly  p,
int  s,
const ring  r 
)

Definition at line 2416 of file p_polys.cc.

2417 {
2418  if(TEST_OPT_CONTENTSB) return;
2419  if (ph==NULL) return;
2420  if (pNext(ph)==NULL)
2421  {
2422  p_SetCoeff(ph,n_Init(1,r->cf),r);
2423  return;
2424  }
2425  if ((pNext(pNext(ph))==NULL)||(!rField_is_Q(r)))
2426  {
2427  return;
2428  }
2429  number d=p_InitContent(ph,r);
2430  if (n_Size(d,r->cf)<=smax)
2431  {
2432  //if (TEST_OPT_PROT) PrintS("G");
2433  return;
2434  }
2435 
2436 
2437  poly p=ph;
2438  number h=d;
2439  if (smax==1) smax=2;
2440  while (p!=NULL)
2441  {
2442 #if 0
2443  d=n_Gcd(h,pGetCoeff(p),r->cf);
2444  n_Delete(&h,r->cf);
2445  h = d;
2446 #else
2447  STATISTIC(n_Gcd); nlInpGcd(h,pGetCoeff(p),r->cf); // FIXME? TODO? // extern void nlInpGcd(number &a, number b, const coeffs r);
2448 #endif
2449  if(n_Size(h,r->cf)<smax)
2450  {
2451  //if (TEST_OPT_PROT) PrintS("g");
2452  return;
2453  }
2454  pIter(p);
2455  }
2456  p = ph;
2457  if (!n_GreaterZero(pGetCoeff(p),r->cf)) h=n_InpNeg(h,r->cf);
2458  if(n_IsOne(h,r->cf)) return;
2459  //if (TEST_OPT_PROT) PrintS("c");
2460  while (p!=NULL)
2461  {
2462 #if 1
2463  d = n_ExactDiv(pGetCoeff(p),h,r->cf);
2464  p_SetCoeff(p,d,r);
2465 #else
2466  STATISTIC(n_ExactDiv); nlInpExactDiv(pGetCoeff(p),h,r->cf); // no such function... ?
2467 #endif
2468  pIter(p);
2469  }
2470  n_Delete(&h,r->cf);
2471 }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE number n_Gcd(number a, number b, const coeffs r)
in Z: return the gcd of &#39;a&#39; and &#39;b&#39; in Z/nZ, Z/2^kZ: computed as in the case Z in Z/pZ...
Definition: coeffs.h:687
return P p
Definition: myNF.cc:203
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the one element.
Definition: coeffs.h:469
#define TEST_OPT_CONTENTSB
Definition: options.h:121
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:539
void nlInpGcd(number &a, number b, const coeffs r)
Definition: longrat.cc:2759
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:407
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
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:558
static number p_InitContent(poly ph, const ring r)
Definition: p_polys.cc:2474
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:458
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
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:623
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
static FORCE_INLINE BOOLEAN n_GreaterZero(number n, const coeffs r)
ordered fields: TRUE iff &#39;n&#39; is positive; in Z/pZ: TRUE iff 0 < m <= roundedBelow(p/2), where m is the long representing n in C: TRUE iff (Im(n) != 0 and Im(n) >= 0) or (Im(n) == 0 and Re(n) >= 0) in K(a)/<p(a)>: TRUE iff (n != 0 and (LC(n) > 0 or deg(n) > 0)) in K(t_1, ..., t_n): TRUE iff (LC(numerator(n) is a constant and > 0) or (LC(numerator(n) is not a constant) in Z/2^kZ: TRUE iff 0 < n <= 2^(k-1) in Z/mZ: TRUE iff the internal mpz is greater than zero in Z: TRUE iff n > 0
Definition: coeffs.h:495
polyrec * poly
Definition: hilb.h:10
static Poly * h
Definition: janet.cc:978
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:571
int p_Size ( poly  p,
const ring  r 
)

Definition at line 3132 of file p_polys.cc.

3133 {
3134  int count = 0;
3135  if (r->cf->has_simple_Alloc)
3136  return pLength(p);
3137  while ( p != NULL )
3138  {
3139  count+= n_Size( pGetCoeff( p ), r->cf );
3140  pIter( p );
3141  }
3142  return count;
3143 }
int status int void size_t count
Definition: si_signals.h:59
return P p
Definition: myNF.cc:203
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
static int pLength(poly a)
Definition: p_polys.h:189
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
#define NULL
Definition: omList.c:10
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:571
static poly p_SortAdd ( poly  p,
const ring  r,
BOOLEAN  revert = FALSE 
)
inlinestatic

Definition at line 1148 of file p_polys.h.

1149 {
1150  if (revert) p = pReverse(p);
1151  return sBucketSortAdd(p, r);
1152 }
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208
poly sBucketSortAdd(poly p, const ring r)
Sorts p with bucketSort: p may have equal monomials.
Definition: sbuckets.cc:369
static poly pReverse(poly p)
Definition: p_polys.h:330
static poly p_SortMerge ( poly  p,
const ring  r,
BOOLEAN  revert = FALSE 
)
inlinestatic

Definition at line 1158 of file p_polys.h.

1159 {
1160  if (revert) p = pReverse(p);
1161  return sBucketSortMerge(p, r);
1162 }
return P p
Definition: myNF.cc:203
poly sBucketSortMerge(poly p, const ring r)
Sorts p with bucketSort: assumes all monomials of p are different.
Definition: sbuckets.cc:332
const ring r
Definition: syzextra.cc:208
static poly pReverse(poly p)
Definition: p_polys.h:330
void p_Split ( poly  p,
poly r 
)

Definition at line 1325 of file p_polys.cc.

1326 {
1327  *h=pNext(p);
1328  pNext(p)=NULL;
1329 }
return P p
Definition: myNF.cc:203
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
static Poly * h
Definition: janet.cc:978
char* p_String ( poly  p,
ring  lmRing,
ring  tailRing 
)

Definition at line 186 of file polys0.cc.

187 {
188  StringSetS("");
190  return StringEndS();
191 }
BEGIN_NAMESPACE_SINGULARXX const ring lmRing
Definition: DebugPrint.h:30
return P p
Definition: myNF.cc:203
BEGIN_NAMESPACE_SINGULARXX const ring const ring tailRing
Definition: DebugPrint.h:30
char * StringEndS()
Definition: reporter.cc:151
void StringSetS(const char *st)
Definition: reporter.cc:128
void p_String0(poly p, ring lmRing, ring tailRing)
print p according to ShortOut in lmRing & tailRing
Definition: polys0.cc:136
static char* p_String ( poly  p,
ring  p_ring 
)
inlinestatic

Definition at line 1169 of file p_polys.h.

1170 {
1171  return p_String(p, p_ring, p_ring);
1172 }
char * p_String(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:186
return P p
Definition: myNF.cc:203
void p_String0 ( poly  p,
ring  lmRing,
ring  tailRing 
)

print p according to ShortOut in lmRing & tailRing

Definition at line 136 of file polys0.cc.

137 {
138  if (p == NULL)
139  {
140  StringAppendS("0");
141  return;
142  }
144  if ((n_GetChar(lmRing->cf) == 0)
145  && (nCoeff_is_transExt(lmRing->cf)))
146  p_Normalize(p,lmRing); /* Manual/absfact.tst */
147  if ((p_GetComp(p, lmRing) == 0) || (!lmRing->VectorOut))
148  {
149  writemon(p,0, lmRing);
150  p = pNext(p);
151  while (p!=NULL)
152  {
153  assume((p->coef==NULL)||(!n_IsZero(p->coef,tailRing->cf)));
154  if ((p->coef==NULL)||n_GreaterZero(p->coef,tailRing->cf))
155  StringAppendS("+");
156  writemon(p,0, tailRing);
157  p = pNext(p);
158  }
159  return;
160  }
161 
162  long k = 1;
163  StringAppendS("[");
164  loop
165  {
166  while (k < p_GetComp(p,lmRing))
167  {
168  StringAppendS("0,");
169  k++;
170  }
171  writemon(p,k,lmRing);
172  pIter(p);
173  while ((p!=NULL) && (k == p_GetComp(p, tailRing)))
174  {
175  if (n_GreaterZero(p->coef,tailRing->cf)) StringAppendS("+");
176  writemon(p,k,tailRing);
177  pIter(p);
178  }
179  if (p == NULL) break;
180  StringAppendS(",");
181  k++;
182  }
183  StringAppendS("]");
184 }
BEGIN_NAMESPACE_SINGULARXX const ring lmRing
Definition: DebugPrint.h:30
loop
Definition: myNF.cc:98
return P p
Definition: myNF.cc:203
#define p_GetComp(p, r)
Definition: monomials.h:72
BEGIN_NAMESPACE_SINGULARXX const ring const ring tailRing
Definition: DebugPrint.h:30
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:445
int k
Definition: cfEzgcd.cc:93
#define pIter(p)
Definition: monomials.h:44
#define assume(x)
Definition: mod2.h:405
void StringAppendS(const char *st)
Definition: reporter.cc:107
static FORCE_INLINE BOOLEAN nCoeff_is_transExt(const coeffs r)
TRUE iff r represents a transcendental extension field.
Definition: coeffs.h:921
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the zero element.
Definition: coeffs.h:465
void p_Normalize(poly p, const ring r)
Definition: p_polys.cc:3632
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
static FORCE_INLINE BOOLEAN n_GreaterZero(number n, const coeffs r)
ordered fields: TRUE iff &#39;n&#39; is positive; in Z/pZ: TRUE iff 0 < m <= roundedBelow(p/2), where m is the long representing n in C: TRUE iff (Im(n) != 0 and Im(n) >= 0) or (Im(n) == 0 and Re(n) >= 0) in K(a)/<p(a)>: TRUE iff (n != 0 and (LC(n) > 0 or deg(n) > 0)) in K(t_1, ..., t_n): TRUE iff (LC(numerator(n) is a constant and > 0) or (LC(numerator(n) is not a constant) in Z/2^kZ: TRUE iff 0 < n <= 2^(k-1) in Z/mZ: TRUE iff the internal mpz is greater than zero in Z: TRUE iff n > 0
Definition: coeffs.h:495
static void writemon(poly p, int ko, const ring r)
Definition: polys0.cc:23
static void p_String0 ( poly  p,
ring  p_ring 
)
inlinestatic

Definition at line 1173 of file p_polys.h.

1174 {
1175  p_String0(p, p_ring, p_ring);
1176 }
return P p
Definition: myNF.cc:203
void p_String0(poly p, ring lmRing, ring tailRing)
print p according to ShortOut in lmRing & tailRing
Definition: polys0.cc:136
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 116 of file polys0.cc.

117 {
118  // NOTE: the following (non-thread-safe!) UGLYNESS
119  // (changing naRing->ShortOut for a while) is due to Hans!
120  // Just think of other ring using the VERY SAME naRing and possible
121  // side-effects...
122  // but this is not a problem: i/o is not thread-safe anyway.
123  const BOOLEAN bLMShortOut = rShortOut(lmRing);
124  const BOOLEAN bTAILShortOut = rShortOut(tailRing);
125 
126  lmRing->ShortOut = FALSE;
127  tailRing->ShortOut = FALSE;
128 
130 
131  lmRing->ShortOut = bLMShortOut;
132  tailRing->ShortOut = bTAILShortOut;
133 }
BEGIN_NAMESPACE_SINGULARXX const ring lmRing
Definition: DebugPrint.h:30
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
BEGIN_NAMESPACE_SINGULARXX const ring const ring tailRing
Definition: DebugPrint.h:30
static BOOLEAN rShortOut(const ring r)
Definition: ring.h:526
void p_String0(poly p, ring lmRing, ring tailRing)
print p according to ShortOut in lmRing & tailRing
Definition: polys0.cc:136
int BOOLEAN
Definition: auxiliary.h:131
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 97 of file polys0.cc.

98 {
99  // NOTE: the following (non-thread-safe!) UGLYNESS
100  // (changing naRing->ShortOut for a while) is due to Hans!
101  // Just think of other ring using the VERY SAME naRing and possible
102  // side-effects...
103  const BOOLEAN bLMShortOut = rShortOut(lmRing);
104  const BOOLEAN bTAILShortOut = rShortOut(tailRing);
105 
106  lmRing->ShortOut = rCanShortOut(lmRing);
107  tailRing->ShortOut = rCanShortOut(tailRing);
108 
110 
111  lmRing->ShortOut = bLMShortOut;
112  tailRing->ShortOut = bTAILShortOut;
113 }
BEGIN_NAMESPACE_SINGULARXX const ring lmRing
Definition: DebugPrint.h:30
return P p
Definition: myNF.cc:203
BEGIN_NAMESPACE_SINGULARXX const ring const ring tailRing
Definition: DebugPrint.h:30
static BOOLEAN rShortOut(const ring r)
Definition: ring.h:526
static BOOLEAN rCanShortOut(const ring r)
Definition: ring.h:531
void p_String0(poly p, ring lmRing, ring tailRing)
print p according to ShortOut in lmRing & tailRing
Definition: polys0.cc:136
int BOOLEAN
Definition: auxiliary.h:131
poly p_Sub ( poly  a,
poly  b,
const ring  r 
)

Definition at line 1901 of file p_polys.cc.

1902 {
1903  return p_Add_q(p1, p_Neg(p2,r),r);
1904 }
const ring r
Definition: syzextra.cc:208
static poly p_Neg(poly p, const ring r)
Definition: p_polys.h:1019
END_NAMESPACE const void * p2
Definition: syzextra.cc:202
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:883
static unsigned long p_SubComp ( poly  p,
unsigned long  v,
ring  r 
)
inlinestatic

Definition at line 448 of file p_polys.h.

449 {
453  return __p_GetComp(p,r) -= v;
454 }
#define p_LmCheckPolyRing2(p, r)
Definition: monomials.h:207
#define __p_GetComp(p, r)
Definition: monomials.h:71
return P p
Definition: myNF.cc:203
#define _pPolyAssume2(cond, p, r)
Definition: monomials.h:203
#define pAssume2(cond)
Definition: monomials.h:201
const ring r
Definition: syzextra.cc:208
#define rRing_has_Comp(r)
Definition: monomials.h:274
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
static long p_SubExp ( poly  p,
int  v,
long  ee,
ring  r 
)
inlinestatic

Definition at line 608 of file p_polys.h.

609 {
611  long e = p_GetExp(p,v,r);
612  pAssume2(e >= ee);
613  e -= ee;
614  return p_SetExp(p,v,e,r);
615 }
#define p_LmCheckPolyRing2(p, r)
Definition: monomials.h:207
return P p
Definition: myNF.cc:203
#define pAssume2(cond)
Definition: monomials.h:201
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent : VarOffset encodes the position in p->exp
Definition: p_polys.h:483
poly p_Subst ( poly  p,
int  n,
poly  e,
const ring  r 
)

Definition at line 3774 of file p_polys.cc.

3775 {
3776  if (e == NULL) return p_Subst0(p, n,r);
3777 
3778  if (p_IsConstant(e,r))
3779  {
3780  if (n_IsOne(pGetCoeff(e),r->cf)) return p_Subst1(p,n,r);
3781  else return p_Subst2(p, n, pGetCoeff(e),r);
3782  }
3783 
3784 #ifdef HAVE_PLURAL
3785  if (rIsPluralRing(r))
3786  {
3787  return nc_pSubst(p,n,e,r);
3788  }
3789 #endif
3790 
3791  int exponent,i;
3792  poly h, res, m;
3793  int *me,*ee;
3794  number nu,nu1;
3795 
3796  me=(int *)omAlloc((rVar(r)+1)*sizeof(int));
3797  ee=(int *)omAlloc((rVar(r)+1)*sizeof(int));
3798  if (e!=NULL) p_GetExpV(e,ee,r);
3799  res=NULL;
3800  h=p;
3801  while (h!=NULL)
3802  {
3803  if ((e!=NULL) || (p_GetExp(h,n,r)==0))
3804  {
3805  m=p_Head(h,r);
3806  p_GetExpV(m,me,r);
3807  exponent=me[n];
3808  me[n]=0;
3809  for(i=rVar(r);i>0;i--)
3810  me[i]+=exponent*ee[i];
3811  p_SetExpV(m,me,r);
3812  if (e!=NULL)
3813  {
3814  n_Power(pGetCoeff(e),exponent,&nu,r->cf);
3815  nu1=n_Mult(pGetCoeff(m),nu,r->cf);
3816  n_Delete(&nu,r->cf);
3817  p_SetCoeff(m,nu1,r);
3818  }
3819  res=p_Add_q(res,m,r);
3820  }
3821  p_LmDelete(&h,r);
3822  }
3823  omFreeSize((ADDRESS)me,(rVar(r)+1)*sizeof(int));
3824  omFreeSize((ADDRESS)ee,(rVar(r)+1)*sizeof(int));
3825  return res;
3826 }
return P p
Definition: myNF.cc:203
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the one element.
Definition: coeffs.h:469
static void p_GetExpV(poly p, int *ev, const ring r)
Definition: p_polys.h:1449
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
static poly p_Subst1(poly p, int n, const ring r)
Definition: p_polys.cc:3681
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:537
void * ADDRESS
Definition: auxiliary.h:161
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
#define omAlloc(size)
Definition: omAllocDecl.h:210
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:407
static void p_SetExpV(poly p, int *ev, const ring r)
Definition: p_polys.h:1457
poly res
Definition: myNF.cc:322
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of &#39;a&#39; and &#39;b&#39;, i.e., a*b
Definition: coeffs.h:637
static poly p_Head(poly p, const ring r)
Definition: p_polys.h:818
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:361
static BOOLEAN p_IsConstant(const poly p, const ring r)
Definition: p_polys.h:1785
static poly p_Subst0(poly p, int n, const ring r)
Definition: p_polys.cc:3749
int m
Definition: cfEzgcd.cc:119
int i
Definition: cfEzgcd.cc:123
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:633
#define NULL
Definition: omList.c:10
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:706
int exponent(const CanonicalForm &f, int q)
int exponent ( const CanonicalForm & f, int q )
static poly p_Subst2(poly p, int n, number e, const ring r)
Definition: p_polys.cc:3708
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
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:3288
polyrec * poly
Definition: hilb.h:10
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:883
static Poly * h
Definition: janet.cc:978
void p_TakeOutComp ( poly p,
long  comp,
poly q,
int *  lq,
const ring  r 
)

Definition at line 3389 of file p_polys.cc.

3390 {
3391  spolyrec pp, qq;
3392  poly p, q, p_prev;
3393  int l = 0;
3394 
3395 #ifdef HAVE_ASSUME
3396  int lp = pLength(*r_p);
3397 #endif
3398 
3399  pNext(&pp) = *r_p;
3400  p = *r_p;
3401  p_prev = &pp;
3402  q = &qq;
3403 
3404  while(p != NULL)
3405  {
3406  while (p_GetComp(p,r) == comp)
3407  {
3408  pNext(q) = p;
3409  pIter(q);
3410  p_SetComp(p, 0,r);
3411  p_SetmComp(p,r);
3412  pIter(p);
3413  l++;
3414  if (p == NULL)
3415  {
3416  pNext(p_prev) = NULL;
3417  goto Finish;
3418  }
3419  }
3420  pNext(p_prev) = p;
3421  p_prev = p;
3422  pIter(p);
3423  }
3424 
3425  Finish:
3426  pNext(q) = NULL;
3427  *r_p = pNext(&pp);
3428  *r_q = pNext(&qq);
3429  *lq = l;
3430 #ifdef HAVE_ASSUME
3431  assume(pLength(*r_p) + pLength(*r_q) == lp);
3432 #endif
3433  p_Test(*r_p,r);
3434  p_Test(*r_q,r);
3435 }
return P p
Definition: myNF.cc:203
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition: p_polys.h:242
#define p_GetComp(p, r)
Definition: monomials.h:72
static int pLength(poly a)
Definition: p_polys.h:189
poly pp
Definition: myNF.cc:296
int comp(const CanonicalForm &A, const CanonicalForm &B)
compare polynomials
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
#define assume(x)
Definition: mod2.h:405
#define p_Test(p, r)
Definition: p_polys.h:160
#define p_SetmComp
Definition: p_polys.h:239
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
polyrec * poly
Definition: hilb.h:10
int l
Definition: cfEzgcd.cc:94
poly p_TakeOutComp ( poly p,
int  k,
const ring  r 
)

Definition at line 3328 of file p_polys.cc.

3329 {
3330  poly q = *p,qq=NULL,result = NULL;
3331 
3332  if (q==NULL) return NULL;
3333  BOOLEAN use_setmcomp=rOrd_SetCompRequiresSetm(r);
3334  if (p_GetComp(q,r)==k)
3335  {
3336  result = q;
3337  do
3338  {
3339  p_SetComp(q,0,r);
3340  if (use_setmcomp) p_SetmComp(q,r);
3341  qq = q;
3342  pIter(q);
3343  }
3344  while ((q!=NULL) && (p_GetComp(q,r)==k));
3345  *p = q;
3346  pNext(qq) = NULL;
3347  }
3348  if (q==NULL) return result;
3349  if (p_GetComp(q,r) > k)
3350  {
3351  p_SubComp(q,1,r);
3352  if (use_setmcomp) p_SetmComp(q,r);
3353  }
3354  poly pNext_q;
3355  while ((pNext_q=pNext(q))!=NULL)
3356  {
3357  if (p_GetComp(pNext_q,r)==k)
3358  {
3359  if (result==NULL)
3360  {
3361  result = pNext_q;
3362  qq = result;
3363  }
3364  else
3365  {
3366  pNext(qq) = pNext_q;
3367  pIter(qq);
3368  }
3369  pNext(q) = pNext(pNext_q);
3370  pNext(qq) =NULL;
3371  p_SetComp(qq,0,r);
3372  if (use_setmcomp) p_SetmComp(qq,r);
3373  }
3374  else
3375  {
3376  /*pIter(q);*/ q=pNext_q;
3377  if (p_GetComp(q,r) > k)
3378  {
3379  p_SubComp(q,1,r);
3380  if (use_setmcomp) p_SetmComp(q,r);
3381  }
3382  }
3383  }
3384  return result;
3385 }
return P p
Definition: myNF.cc:203
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition: p_polys.h:242
#define p_GetComp(p, r)
Definition: monomials.h:72
int k
Definition: cfEzgcd.cc:93
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
BOOLEAN rOrd_SetCompRequiresSetm(const ring r)
return TRUE if p_SetComp requires p_Setm
Definition: ring.cc:1875
static unsigned long p_SubComp(poly p, unsigned long v, ring r)
Definition: p_polys.h:448
#define p_SetmComp
Definition: p_polys.h:239
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
polyrec * poly
Definition: hilb.h:10
int BOOLEAN
Definition: auxiliary.h:131
return result
Definition: facAbsBiFact.cc:76
poly p_TakeOutComp1 ( poly p,
int  k,
const ring  r 
)

Definition at line 3277 of file p_polys.cc.

3278 {
3279  poly q = *p;
3280 
3281  if (q==NULL) return NULL;
3282 
3283  poly qq=NULL,result = NULL;
3284 
3285  if (p_GetComp(q,r)==k)
3286  {
3287  result = q; /* *p */
3288  while ((q!=NULL) && (p_GetComp(q,r)==k))
3289  {
3290  p_SetComp(q,0,r);
3291  p_SetmComp(q,r);
3292  qq = q;
3293  pIter(q);
3294  }
3295  *p = q;
3296  pNext(qq) = NULL;
3297  }
3298  if (q==NULL) return result;
3299 // if (pGetComp(q) > k) pGetComp(q)--;
3300  while (pNext(q)!=NULL)
3301  {
3302  if (p_GetComp(pNext(q),r)==k)
3303  {
3304  if (result==NULL)
3305  {
3306  result = pNext(q);
3307  qq = result;
3308  }
3309  else
3310  {
3311  pNext(qq) = pNext(q);
3312  pIter(qq);
3313  }
3314  pNext(q) = pNext(pNext(q));
3315  pNext(qq) =NULL;
3316  p_SetComp(qq,0,r);
3317  p_SetmComp(qq,r);
3318  }
3319  else
3320  {
3321  pIter(q);
3322 // if (pGetComp(q) > k) pGetComp(q)--;
3323  }
3324  }
3325  return result;
3326 }
return P p
Definition: myNF.cc:203
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition: p_polys.h:242
#define p_GetComp(p, r)
Definition: monomials.h:72
int k
Definition: cfEzgcd.cc:93
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
#define p_SetmComp
Definition: p_polys.h:239
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
polyrec * poly
Definition: hilb.h:10
return result
Definition: facAbsBiFact.cc:76
static long p_Totaldegree ( poly  p,
const ring  r 
)
inlinestatic

Definition at line 1436 of file p_polys.h.

1437 {
1439  unsigned long s = p_GetTotalDegree(p->exp[r->VarL_Offset[0]],
1440  r,
1441  r->MinExpPerLong);
1442  for (int i=r->VarL_Size-1; i>0; i--)
1443  {
1444  s += p_GetTotalDegree(p->exp[r->VarL_Offset[i]], r);
1445  }
1446  return (long)s;
1447 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
return P p
Definition: myNF.cc:203
static unsigned long p_GetTotalDegree(const unsigned long l, const ring r, const int number_of_exps)
Definition: p_polys.h:771
const ring r
Definition: syzextra.cc:208
int i
Definition: cfEzgcd.cc:123
#define p_LmCheckPolyRing1(p, r)
Definition: monomials.h:185
int p_Var ( poly  mi,
const ring  r 
)

Definition at line 4462 of file p_polys.cc.

4463 {
4464  if (m==NULL) return 0;
4465  if (pNext(m)!=NULL) return 0;
4466  int i,e=0;
4467  for (i=rVar(r); i>0; i--)
4468  {
4469  int exp=p_GetExp(m,i,r);
4470  if (exp==1)
4471  {
4472  if (e==0) e=i;
4473  else return 0;
4474  }
4475  else if (exp!=0)
4476  {
4477  return 0;
4478  }
4479  }
4480  return e;
4481 }
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:537
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
int m
Definition: cfEzgcd.cc:119
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
p exp[i]
Definition: DebugPrint.cc:39
void p_Vec2Polys ( poly  v,
poly **  p,
int *  len,
const ring  r 
)

Definition at line 3470 of file p_polys.cc.

3471 {
3472  poly h;
3473  int k;
3474 
3475  *len=p_MaxComp(v,r);
3476  if (*len==0) *len=1;
3477  *p=(poly*)omAlloc0((*len)*sizeof(poly));
3478  while (v!=NULL)
3479  {
3480  h=p_Head(v,r);
3481  k=p_GetComp(h,r);
3482  p_SetComp(h,0,r);
3483  (*p)[k-1]=p_Add_q((*p)[k-1],h,r);
3484  pIter(v);
3485  }
3486 }
return P p
Definition: myNF.cc:203
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition: p_polys.h:242
#define p_GetComp(p, r)
Definition: monomials.h:72
int k
Definition: cfEzgcd.cc:93
#define pIter(p)
Definition: monomials.h:44
static poly p_Head(poly p, const ring r)
Definition: p_polys.h:818
const ring r
Definition: syzextra.cc:208
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define NULL
Definition: omList.c:10
polyrec * poly
Definition: hilb.h:10
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:883
static Poly * h
Definition: janet.cc:978
#define omAlloc0(size)
Definition: omAllocDecl.h:211
static long p_MaxComp(poly p, ring lmRing, ring tailRing)
Definition: p_polys.h:287
void p_VectorHasUnit ( poly  p,
int *  k,
int *  len,
const ring  r 
)

Definition at line 3245 of file p_polys.cc.

3246 {
3247  poly q=p,qq;
3248  int i,j=0;
3249 
3250  *len = 0;
3251  while (q!=NULL)
3252  {
3253  if (p_LmIsConstantComp(q,r))
3254  {
3255  i = p_GetComp(q,r);
3256  qq = p;
3257  while ((qq != q) && (p_GetComp(qq,r) != i)) pIter(qq);
3258  if (qq == q)
3259  {
3260  j = 0;
3261  while (qq!=NULL)
3262  {
3263  if (p_GetComp(qq,r)==i) j++;
3264  pIter(qq);
3265  }
3266  if ((*len == 0) || (j<*len))
3267  {
3268  *len = j;
3269  *k = i;
3270  }
3271  }
3272  }
3273  pIter(q);
3274  }
3275 }
static BOOLEAN p_LmIsConstantComp(const poly p, const ring r)
Definition: p_polys.h:938
return P p
Definition: myNF.cc:203
#define p_GetComp(p, r)
Definition: monomials.h:72
int k
Definition: cfEzgcd.cc:93
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
int j
Definition: myNF.cc:70
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
polyrec * poly
Definition: hilb.h:10
BOOLEAN p_VectorHasUnitB ( poly  p,
int *  k,
const ring  r 
)

Definition at line 3220 of file p_polys.cc.

3221 {
3222  poly q=p,qq;
3223  int i;
3224 
3225  while (q!=NULL)
3226  {
3227  if (p_LmIsConstantComp(q,r))
3228  {
3229  i = p_GetComp(q,r);
3230  qq = p;
3231  while ((qq != q) && (p_GetComp(qq,r) != i)) pIter(qq);
3232  if (qq == q)
3233  {
3234  *k = i;
3235  return TRUE;
3236  }
3237  else
3238  pIter(q);
3239  }
3240  else pIter(q);
3241  }
3242  return FALSE;
3243 }
static BOOLEAN p_LmIsConstantComp(const poly p, const ring r)
Definition: p_polys.h:938
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
#define p_GetComp(p, r)
Definition: monomials.h:72
#define TRUE
Definition: auxiliary.h:144
int k
Definition: cfEzgcd.cc:93
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
polyrec * poly
Definition: hilb.h:10
long p_WDegree ( poly  p,
const ring  r 
)

Definition at line 713 of file p_polys.cc.

714 {
715  if (r->firstwv==NULL) return p_Totaldegree(p, r);
717  int i;
718  long j =0;
719 
720  for(i=1;i<=r->firstBlockEnds;i++)
721  j+=p_GetExp(p, i, r)*r->firstwv[i-1];
722 
723  for (;i<=rVar(r);i++)
724  j+=p_GetExp(p,i, r)*p_Weight(i, r);
725 
726  return j;
727 }
return P p
Definition: myNF.cc:203
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:537
static long p_Totaldegree(poly p, const ring r)
Definition: p_polys.h:1436
int p_Weight(int i, const ring r)
Definition: p_polys.cc:704
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
int j
Definition: myNF.cc:70
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
BOOLEAN p_LmCheckPolyRing(poly p, ring r)
Definition: pDebug.cc:119
int p_Weight ( int  c,
const ring  r 
)

Definition at line 704 of file p_polys.cc.

705 {
706  if ((r->firstwv==NULL) || (i>r->firstBlockEnds))
707  {
708  return 1;
709  }
710  return r->firstwv[i-1];
711 }
const ring r
Definition: syzextra.cc:208
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
long p_WFirstTotalDegree ( poly  p,
ring  r 
)

Definition at line 595 of file p_polys.cc.

596 {
597  int i;
598  long sum = 0;
599 
600  for (i=1; i<= r->firstBlockEnds; i++)
601  {
602  sum += p_GetExp(p, i, r)*r->firstwv[i-1];
603  }
604  return sum;
605 }
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
int i
Definition: cfEzgcd.cc:123
void p_Write ( poly  p,
ring  lmRing,
ring  tailRing 
)

Definition at line 206 of file polys0.cc.

207 {
209  PrintLn();
210 }
void PrintLn()
Definition: reporter.cc:327
BEGIN_NAMESPACE_SINGULARXX const ring lmRing
Definition: DebugPrint.h:30
return P p
Definition: myNF.cc:203
BEGIN_NAMESPACE_SINGULARXX const ring const ring tailRing
Definition: DebugPrint.h:30
void p_Write0(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:196
static void p_Write ( poly  p,
ring  p_ring 
)
inlinestatic

Definition at line 1177 of file p_polys.h.

1178 {
1179  p_Write(p, p_ring, p_ring);
1180 }
return P p
Definition: myNF.cc:203
void p_Write(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:206
void p_Write0 ( poly  p,
ring  lmRing,
ring  tailRing 
)

Definition at line 196 of file polys0.cc.

197 {
198  char *s=p_String(p, lmRing, tailRing);
199  PrintS(s);
200  omFree(s);
201 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
char * p_String(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:186
BEGIN_NAMESPACE_SINGULARXX const ring lmRing
Definition: DebugPrint.h:30
return P p
Definition: myNF.cc:203
BEGIN_NAMESPACE_SINGULARXX const ring const ring tailRing
Definition: DebugPrint.h:30
#define omFree(addr)
Definition: omAllocDecl.h:261
void PrintS(const char *s)
Definition: reporter.cc:294
static void p_Write0 ( poly  p,
ring  p_ring 
)
inlinestatic

Definition at line 1181 of file p_polys.h.

1182 {
1183  p_Write0(p, p_ring, p_ring);
1184 }
return P p
Definition: myNF.cc:203
void p_Write0(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:196
void p_wrp ( poly  p,
ring  lmRing,
ring  tailRing 
)

Definition at line 237 of file polys0.cc.

238 {
239  poly r;
240 
241  if (p==NULL) PrintS("NULL");
242  else if (pNext(p)==NULL) p_Write0(p, lmRing);
243  else
244  {
245  r = pNext(pNext(p));
246  pNext(pNext(p)) = NULL;
247  p_Write0(p, tailRing);
248  if (r!=NULL)
249  {
250  PrintS("+...");
251  pNext(pNext(p)) = r;
252  }
253  }
254 }
BEGIN_NAMESPACE_SINGULARXX const ring lmRing
Definition: DebugPrint.h:30
return P p
Definition: myNF.cc:203
BEGIN_NAMESPACE_SINGULARXX const ring const ring tailRing
Definition: DebugPrint.h:30
const ring r
Definition: syzextra.cc:208
void p_Write0(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:196
void PrintS(const char *s)
Definition: reporter.cc:294
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
polyrec * poly
Definition: hilb.h:10
static void p_wrp ( poly  p,
ring  p_ring 
)
inlinestatic

Definition at line 1185 of file p_polys.h.

1186 {
1187  p_wrp(p, p_ring, p_ring);
1188 }
return P p
Definition: myNF.cc:203
void p_wrp(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:237
long p_WTotaldegree ( poly  p,
const ring  r 
)

Definition at line 612 of file p_polys.cc.

613 {
615  int i, k;
616  long j =0;
617 
618  // iterate through each block:
619  for (i=0;r->order[i]!=0;i++)
620  {
621  int b0=r->block0[i];
622  int b1=r->block1[i];
623  switch(r->order[i])
624  {
625  case ringorder_M:
626  for (k=b0 /*r->block0[i]*/;k<=b1 /*r->block1[i]*/;k++)
627  { // in jedem block:
628  j+= p_GetExp(p,k,r)*r->wvhdl[i][k - b0 /*r->block0[i]*/]*r->OrdSgn;
629  }
630  break;
631  case ringorder_wp:
632  case ringorder_ws:
633  case ringorder_Wp:
634  case ringorder_Ws:
635  for (k=b0 /*r->block0[i]*/;k<=b1 /*r->block1[i]*/;k++)
636  { // in jedem block:
637  j+= p_GetExp(p,k,r)*r->wvhdl[i][k - b0 /*r->block0[i]*/];
638  }
639  break;
640  case ringorder_lp:
641  case ringorder_ls:
642  case ringorder_rs:
643  case ringorder_dp:
644  case ringorder_ds:
645  case ringorder_Dp:
646  case ringorder_Ds:
647  case ringorder_rp:
648  for (k=b0 /*r->block0[i]*/;k<=b1 /*r->block1[i]*/;k++)
649  {
650  j+= p_GetExp(p,k,r);
651  }
652  break;
653  case ringorder_a64:
654  {
655  int64* w=(int64*)r->wvhdl[i];
656  for (k=0;k<=(b1 /*r->block1[i]*/ - b0 /*r->block0[i]*/);k++)
657  {
658  //there should be added a line which checks if w[k]>2^31
659  j+= p_GetExp(p,k+1, r)*(long)w[k];
660  }
661  //break;
662  return j;
663  }
664  case ringorder_c:
665  case ringorder_C:
666  case ringorder_S:
667  case ringorder_s:
668  case ringorder_aa:
669  case ringorder_IS:
670  break;
671  case ringorder_a:
672  for (k=b0 /*r->block0[i]*/;k<=b1 /*r->block1[i]*/;k++)
673  { // only one line
674  j+= p_GetExp(p,k, r)*r->wvhdl[i][ k- b0 /*r->block0[i]*/];
675  }
676  //break;
677  return j;
678 
679 #ifndef SING_NDEBUG
680  default:
681  Print("missing order %d in p_WTotaldegree\n",r->order[i]);
682  break;
683 #endif
684  }
685  }
686  return j;
687 }
for idElimination, like a, except pFDeg, pWeigths ignore it
Definition: ring.h:690
for int64 weights
Definition: ring.h:670
#define Print
Definition: emacs.cc:83
return P p
Definition: myNF.cc:203
opposite of ls
Definition: ring.h:691
long int64
Definition: auxiliary.h:112
int k
Definition: cfEzgcd.cc:93
const ring r
Definition: syzextra.cc:208
for(int i=0;i< R->ExpL_Size;i++) Print("%09lx "
Definition: cfEzgcd.cc:66
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
int j
Definition: myNF.cc:70
int i
Definition: cfEzgcd.cc:123
Induced (Schreyer) ordering.
Definition: ring.h:692
S?
Definition: ring.h:674
BOOLEAN p_LmCheckPolyRing(poly p, ring r)
Definition: pDebug.cc:119
const CanonicalForm & w
Definition: facAbsFact.cc:55
s?
Definition: ring.h:675
void pEnlargeSet ( poly **  p,
int  length,
int  increment 
)

Definition at line 3551 of file p_polys.cc.

3552 {
3553  poly* h;
3554 
3555  if (*p==NULL)
3556  {
3557  if (increment==0) return;
3558  h=(poly*)omAlloc0(increment*sizeof(poly));
3559  }
3560  else
3561  {
3562  h=(poly*)omReallocSize((poly*)*p,l*sizeof(poly),(l+increment)*sizeof(poly));
3563  if (increment>0)
3564  {
3565  //for (i=l; i<l+increment; i++)
3566  // h[i]=NULL;
3567  memset(&(h[l]),0,increment*sizeof(poly));
3568  }
3569  }
3570  *p=h;
3571 }
return P p
Definition: myNF.cc:203
#define omReallocSize(addr, o_size, size)
Definition: omAllocDecl.h:220
#define NULL
Definition: omList.c:10
polyrec * poly
Definition: hilb.h:10
static Poly * h
Definition: janet.cc:978
#define omAlloc0(size)
Definition: omAllocDecl.h:211
int l
Definition: cfEzgcd.cc:94
BOOLEAN pHaveCommonMonoms ( poly  p,
poly  q 
)

Definition at line 174 of file pDebug.cc.

175 {
176  while (p != NULL)
177  {
178  if (pIsMonomOf(q, p))
179  {
180  return TRUE;
181  }
182  pIter(p);
183  }
184  return FALSE;
185 }
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
#define TRUE
Definition: auxiliary.h:144
#define pIter(p)
Definition: monomials.h:44
BOOLEAN pIsMonomOf(poly p, poly m)
Definition: pDebug.cc:164
#define NULL
Definition: omList.c:10
BOOLEAN pIsMonomOf ( poly  p,
poly  m 
)

Definition at line 164 of file pDebug.cc.

165 {
166  if (m == NULL) return TRUE;
167  while (p != NULL)
168  {
169  if (p == m) return TRUE;
170  pIter(p);
171  }
172  return FALSE;
173 }
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
#define TRUE
Definition: auxiliary.h:144
#define pIter(p)
Definition: monomials.h:44
int m
Definition: cfEzgcd.cc:119
#define NULL
Definition: omList.c:10
long pLDeg0 ( poly  p,
int *  l,
ring  r 
)

Definition at line 738 of file p_polys.cc.

739 {
740  p_CheckPolyRing(p, r);
741  long k= p_GetComp(p, r);
742  int ll=1;
743 
744  if (k > 0)
745  {
746  while ((pNext(p)!=NULL) && (p_GetComp(pNext(p), r)==k))
747  {
748  pIter(p);
749  ll++;
750  }
751  }
752  else
753  {
754  while (pNext(p)!=NULL)
755  {
756  pIter(p);
757  ll++;
758  }
759  }
760  *l=ll;
761  return r->pFDeg(p, r);
762 }
return P p
Definition: myNF.cc:203
#define p_GetComp(p, r)
Definition: monomials.h:72
int k
Definition: cfEzgcd.cc:93
#define pIter(p)
Definition: monomials.h:44
BOOLEAN p_CheckPolyRing(poly p, ring r)
Definition: pDebug.cc:111
const ring r
Definition: syzextra.cc:208
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
int l
Definition: cfEzgcd.cc:94
long pLDeg0c ( poly  p,
int *  l,
ring  r 
)

Definition at line 769 of file p_polys.cc.

770 {
771  assume(p!=NULL);
772  p_Test(p,r);
773  p_CheckPolyRing(p, r);
774  long o;
775  int ll=1;
776 
777  if (! rIsSyzIndexRing(r))
778  {
779  while (pNext(p) != NULL)
780  {
781  pIter(p);
782  ll++;
783  }
784  o = r->pFDeg(p, r);
785  }
786  else
787  {
788  int curr_limit = rGetCurrSyzLimit(r);
789  poly pp = p;
790  while ((p=pNext(p))!=NULL)
791  {
792  if (p_GetComp(p, r)<=curr_limit/*syzComp*/)
793  ll++;
794  else break;
795  pp = p;
796  }
797  p_Test(pp,r);
798  o = r->pFDeg(pp, r);
799  }
800  *l=ll;
801  return o;
802 }
return P p
Definition: myNF.cc:203
static BOOLEAN rIsSyzIndexRing(const ring r)
Definition: ring.h:711
#define p_GetComp(p, r)
Definition: monomials.h:72
static int rGetCurrSyzLimit(const ring r)
Definition: ring.h:714
poly pp
Definition: myNF.cc:296
#define pIter(p)
Definition: monomials.h:44
BOOLEAN p_CheckPolyRing(poly p, ring r)
Definition: pDebug.cc:111
const ring r
Definition: syzextra.cc:208
#define assume(x)
Definition: mod2.h:405
#define p_Test(p, r)
Definition: p_polys.h:160
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
polyrec * poly
Definition: hilb.h:10
int l
Definition: cfEzgcd.cc:94
long pLDeg1 ( poly  p,
int *  l,
ring  r 
)

Definition at line 840 of file p_polys.cc.

841 {
842  p_CheckPolyRing(p, r);
843  long k= p_GetComp(p, r);
844  int ll=1;
845  long t,max;
846 
847  max=r->pFDeg(p, r);
848  if (k > 0)
849  {
850  while (((p=pNext(p))!=NULL) && (p_GetComp(p, r)==k))
851  {
852  t=r->pFDeg(p, r);
853  if (t>max) max=t;
854  ll++;
855  }
856  }
857  else
858  {
859  while ((p=pNext(p))!=NULL)
860  {
861  t=r->pFDeg(p, r);
862  if (t>max) max=t;
863  ll++;
864  }
865  }
866  *l=ll;
867  return max;
868 }
return P p
Definition: myNF.cc:203
#define p_GetComp(p, r)
Definition: monomials.h:72
int k
Definition: cfEzgcd.cc:93
BOOLEAN p_CheckPolyRing(poly p, ring r)
Definition: pDebug.cc:111
const ring r
Definition: syzextra.cc:208
static int max(int a, int b)
Definition: fast_mult.cc:264
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
int l
Definition: cfEzgcd.cc:94
long pLDeg1_Deg ( poly  p,
int *  l,
ring  r 
)

Definition at line 909 of file p_polys.cc.

910 {
911  assume(r->pFDeg == p_Deg);
912  p_CheckPolyRing(p, r);
913  long k= p_GetComp(p, r);
914  int ll=1;
915  long t,max;
916 
917  max=p_GetOrder(p, r);
918  if (k > 0)
919  {
920  while (((p=pNext(p))!=NULL) && (p_GetComp(p, r)==k))
921  {
922  t=p_GetOrder(p, r);
923  if (t>max) max=t;
924  ll++;
925  }
926  }
927  else
928  {
929  while ((p=pNext(p))!=NULL)
930  {
931  t=p_GetOrder(p, r);
932  if (t>max) max=t;
933  ll++;
934  }
935  }
936  *l=ll;
937  return max;
938 }
return P p
Definition: myNF.cc:203
#define p_GetComp(p, r)
Definition: monomials.h:72
int k
Definition: cfEzgcd.cc:93
BOOLEAN p_CheckPolyRing(poly p, ring r)
Definition: pDebug.cc:111
long p_Deg(poly a, const ring r)
Definition: p_polys.cc:586
const ring r
Definition: syzextra.cc:208
static int max(int a, int b)
Definition: fast_mult.cc:264
#define assume(x)
Definition: mod2.h:405
static long p_GetOrder(poly p, ring r)
Definition: p_polys.h:416
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
int l
Definition: cfEzgcd.cc:94
long pLDeg1_Totaldegree ( poly  p,
int *  l,
ring  r 
)

Definition at line 974 of file p_polys.cc.

975 {
976  p_CheckPolyRing(p, r);
977  long k= p_GetComp(p, r);
978  int ll=1;
979  long t,max;
980 
981  max=p_Totaldegree(p, r);
982  if (k > 0)
983  {
984  while (((p=pNext(p))!=NULL) && (p_GetComp(p, r)==k))
985  {
986  t=p_Totaldegree(p, r);
987  if (t>max) max=t;
988  ll++;
989  }
990  }
991  else
992  {
993  while ((p=pNext(p))!=NULL)
994  {
995  t=p_Totaldegree(p, r);
996  if (t>max) max=t;
997  ll++;
998  }
999  }
1000  *l=ll;
1001  return max;
1002 }
return P p
Definition: myNF.cc:203
#define p_GetComp(p, r)
Definition: monomials.h:72
static long p_Totaldegree(poly p, const ring r)
Definition: p_polys.h:1436
int k
Definition: cfEzgcd.cc:93
BOOLEAN p_CheckPolyRing(poly p, ring r)
Definition: pDebug.cc:111
const ring r
Definition: syzextra.cc:208
static int max(int a, int b)
Definition: fast_mult.cc:264
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
int l
Definition: cfEzgcd.cc:94
long pLDeg1_WFirstTotalDegree ( poly  p,
int *  l,
ring  r 
)

Definition at line 1037 of file p_polys.cc.

1038 {
1039  p_CheckPolyRing(p, r);
1040  long k= p_GetComp(p, r);
1041  int ll=1;
1042  long t,max;
1043 
1044  max=p_WFirstTotalDegree(p, r);
1045  if (k > 0)
1046  {
1047  while (((p=pNext(p))!=NULL) && (p_GetComp(p, r)==k))
1048  {
1049  t=p_WFirstTotalDegree(p, r);
1050  if (t>max) max=t;
1051  ll++;
1052  }
1053  }
1054  else
1055  {
1056  while ((p=pNext(p))!=NULL)
1057  {
1058  t=p_WFirstTotalDegree(p, r);
1059  if (t>max) max=t;
1060  ll++;
1061  }
1062  }
1063  *l=ll;
1064  return max;
1065 }
return P p
Definition: myNF.cc:203
#define p_GetComp(p, r)
Definition: monomials.h:72
int k
Definition: cfEzgcd.cc:93
BOOLEAN p_CheckPolyRing(poly p, ring r)
Definition: pDebug.cc:111
const ring r
Definition: syzextra.cc:208
static int max(int a, int b)
Definition: fast_mult.cc:264
long p_WFirstTotalDegree(poly p, const ring r)
Definition: p_polys.cc:595
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
int l
Definition: cfEzgcd.cc:94
long pLDeg1c ( poly  p,
int *  l,
ring  r 
)

Definition at line 876 of file p_polys.cc.

877 {
878  p_CheckPolyRing(p, r);
879  int ll=1;
880  long t,max;
881 
882  max=r->pFDeg(p, r);
883  if (rIsSyzIndexRing(r))
884  {
885  long limit = rGetCurrSyzLimit(r);
886  while ((p=pNext(p))!=NULL)
887  {
888  if (p_GetComp(p, r)<=limit)
889  {
890  if ((t=r->pFDeg(p, r))>max) max=t;
891  ll++;
892  }
893  else break;
894  }
895  }
896  else
897  {
898  while ((p=pNext(p))!=NULL)
899  {
900  if ((t=r->pFDeg(p, r))>max) max=t;
901  ll++;
902  }
903  }
904  *l=ll;
905  return max;
906 }
return P p
Definition: myNF.cc:203
static BOOLEAN rIsSyzIndexRing(const ring r)
Definition: ring.h:711
#define p_GetComp(p, r)
Definition: monomials.h:72
static int rGetCurrSyzLimit(const ring r)
Definition: ring.h:714
BOOLEAN p_CheckPolyRing(poly p, ring r)
Definition: pDebug.cc:111
const ring r
Definition: syzextra.cc:208
static int max(int a, int b)
Definition: fast_mult.cc:264
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
int l
Definition: cfEzgcd.cc:94
long pLDeg1c_Deg ( poly  p,
int *  l,
ring  r 
)

Definition at line 940 of file p_polys.cc.

941 {
942  assume(r->pFDeg == p_Deg);
943  p_CheckPolyRing(p, r);
944  int ll=1;
945  long t,max;
946 
947  max=p_GetOrder(p, r);
948  if (rIsSyzIndexRing(r))
949  {
950  long limit = rGetCurrSyzLimit(r);
951  while ((p=pNext(p))!=NULL)
952  {
953  if (p_GetComp(p, r)<=limit)
954  {
955  if ((t=p_GetOrder(p, r))>max) max=t;
956  ll++;
957  }
958  else break;
959  }
960  }
961  else
962  {
963  while ((p=pNext(p))!=NULL)
964  {
965  if ((t=p_GetOrder(p, r))>max) max=t;
966  ll++;
967  }
968  }
969  *l=ll;
970  return max;
971 }
return P p
Definition: myNF.cc:203
static BOOLEAN rIsSyzIndexRing(const ring r)
Definition: ring.h:711
#define p_GetComp(p, r)
Definition: monomials.h:72
static int rGetCurrSyzLimit(const ring r)
Definition: ring.h:714
BOOLEAN p_CheckPolyRing(poly p, ring r)
Definition: pDebug.cc:111
long p_Deg(poly a, const ring r)
Definition: p_polys.cc:586
const ring r
Definition: syzextra.cc:208
static int max(int a, int b)
Definition: fast_mult.cc:264
#define assume(x)
Definition: mod2.h:405
static long p_GetOrder(poly p, ring r)
Definition: p_polys.h:416
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
int l
Definition: cfEzgcd.cc:94
long pLDeg1c_Totaldegree ( poly  p,
int *  l,
ring  r 
)

Definition at line 1004 of file p_polys.cc.

1005 {
1006  p_CheckPolyRing(p, r);
1007  int ll=1;
1008  long t,max;
1009 
1010  max=p_Totaldegree(p, r);
1011  if (rIsSyzIndexRing(r))
1012  {
1013  long limit = rGetCurrSyzLimit(r);
1014  while ((p=pNext(p))!=NULL)
1015  {
1016  if (p_GetComp(p, r)<=limit)
1017  {
1018  if ((t=p_Totaldegree(p, r))>max) max=t;
1019  ll++;
1020  }
1021  else break;
1022  }
1023  }
1024  else
1025  {
1026  while ((p=pNext(p))!=NULL)
1027  {
1028  if ((t=p_Totaldegree(p, r))>max) max=t;
1029  ll++;
1030  }
1031  }
1032  *l=ll;
1033  return max;
1034 }
return P p
Definition: myNF.cc:203
static BOOLEAN rIsSyzIndexRing(const ring r)
Definition: ring.h:711
#define p_GetComp(p, r)
Definition: monomials.h:72
static int rGetCurrSyzLimit(const ring r)
Definition: ring.h:714
static long p_Totaldegree(poly p, const ring r)
Definition: p_polys.h:1436
BOOLEAN p_CheckPolyRing(poly p, ring r)
Definition: pDebug.cc:111
const ring r
Definition: syzextra.cc:208
static int max(int a, int b)
Definition: fast_mult.cc:264
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
int l
Definition: cfEzgcd.cc:94
long pLDeg1c_WFirstTotalDegree ( poly  p,
int *  l,
ring  r 
)

Definition at line 1067 of file p_polys.cc.

1068 {
1069  p_CheckPolyRing(p, r);
1070  int ll=1;
1071  long t,max;
1072 
1073  max=p_WFirstTotalDegree(p, r);
1074  if (rIsSyzIndexRing(r))
1075  {
1076  long limit = rGetCurrSyzLimit(r);
1077  while ((p=pNext(p))!=NULL)
1078  {
1079  if (p_GetComp(p, r)<=limit)
1080  {
1081  if ((t=p_Totaldegree(p, r))>max) max=t;
1082  ll++;
1083  }
1084  else break;
1085  }
1086  }
1087  else
1088  {
1089  while ((p=pNext(p))!=NULL)
1090  {
1091  if ((t=p_Totaldegree(p, r))>max) max=t;
1092  ll++;
1093  }
1094  }
1095  *l=ll;
1096  return max;
1097 }
return P p
Definition: myNF.cc:203
static BOOLEAN rIsSyzIndexRing(const ring r)
Definition: ring.h:711
#define p_GetComp(p, r)
Definition: monomials.h:72
static int rGetCurrSyzLimit(const ring r)
Definition: ring.h:714
static long p_Totaldegree(poly p, const ring r)
Definition: p_polys.h:1436
BOOLEAN p_CheckPolyRing(poly p, ring r)
Definition: pDebug.cc:111
const ring r
Definition: syzextra.cc:208
static int max(int a, int b)
Definition: fast_mult.cc:264
long p_WFirstTotalDegree(poly p, const ring r)
Definition: p_polys.cc:595
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
int l
Definition: cfEzgcd.cc:94
long pLDegb ( poly  p,
int *  l,
ring  r 
)

Definition at line 810 of file p_polys.cc.

811 {
812  p_CheckPolyRing(p, r);
813  long k= p_GetComp(p, r);
814  long o = r->pFDeg(p, r);
815  int ll=1;
816 
817  if (k != 0)
818  {
819  while (((p=pNext(p))!=NULL) && (p_GetComp(p, r)==k))
820  {
821  ll++;
822  }
823  }
824  else
825  {
826  while ((p=pNext(p)) !=NULL)
827  {
828  ll++;
829  }
830  }
831  *l=ll;
832  return o;
833 }
return P p
Definition: myNF.cc:203
#define p_GetComp(p, r)
Definition: monomials.h:72
int k
Definition: cfEzgcd.cc:93
BOOLEAN p_CheckPolyRing(poly p, ring r)
Definition: pDebug.cc:111
const ring r
Definition: syzextra.cc:208
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
int l
Definition: cfEzgcd.cc:94
static int pLength ( poly  a)
inlinestatic

Definition at line 189 of file p_polys.h.

190 {
191  int l = 0;
192  while (a!=NULL)
193  {
194  pIter(a);
195  l++;
196  }
197  return l;
198 }
const poly a
Definition: syzextra.cc:212
#define pIter(p)
Definition: monomials.h:44
#define NULL
Definition: omList.c:10
int l
Definition: cfEzgcd.cc:94
poly pp_Jet ( poly  p,
int  m,
const ring  R 
)

Definition at line 4164 of file p_polys.cc.

4165 {
4166  poly r=NULL;
4167  poly t=NULL;
4168 
4169  while (p!=NULL)
4170  {
4171  if (p_Totaldegree(p,R)<=m)
4172  {
4173  if (r==NULL)
4174  r=p_Head(p,R);
4175  else
4176  if (t==NULL)
4177  {
4178  pNext(r)=p_Head(p,R);
4179  t=pNext(r);
4180  }
4181  else
4182  {
4183  pNext(t)=p_Head(p,R);
4184  pIter(t);
4185  }
4186  }
4187  pIter(p);
4188  }
4189  return r;
4190 }
return P p
Definition: myNF.cc:203
static long p_Totaldegree(poly p, const ring r)
Definition: p_polys.h:1436
#define pIter(p)
Definition: monomials.h:44
static poly p_Head(poly p, const ring r)
Definition: p_polys.h:818
const ring r
Definition: syzextra.cc:208
const ring R
Definition: DebugPrint.cc:36
int m
Definition: cfEzgcd.cc:119
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
polyrec * poly
Definition: hilb.h:10
poly pp_JetW ( poly  p,
int  m,
short *  w,
const ring  R 
)

Definition at line 4209 of file p_polys.cc.

4210 {
4211  poly r=NULL;
4212  poly t=NULL;
4213  while (p!=NULL)
4214  {
4215  if (totaldegreeWecart_IV(p,R,w)<=m)
4216  {
4217  if (r==NULL)
4218  r=p_Head(p,R);
4219  else
4220  if (t==NULL)
4221  {
4222  pNext(r)=p_Head(p,R);
4223  t=pNext(r);
4224  }
4225  else
4226  {
4227  pNext(t)=p_Head(p,R);
4228  pIter(t);
4229  }
4230  }
4231  pIter(p);
4232  }
4233  return r;
4234 }
return P p
Definition: myNF.cc:203
long totaldegreeWecart_IV(poly p, ring r, const short *w)
Definition: weight.cc:239
#define pIter(p)
Definition: monomials.h:44
static poly p_Head(poly p, const ring r)
Definition: p_polys.h:818
const ring r
Definition: syzextra.cc:208
const ring R
Definition: DebugPrint.cc:36
int m
Definition: cfEzgcd.cc:119
#define NULL
Definition: omList.c:10
const CanonicalForm & w
Definition: facAbsFact.cc:55
#define pNext(p)
Definition: monomials.h:43
polyrec * poly
Definition: hilb.h:10
static poly pp_Mult_Coeff_mm_DivSelect ( poly  p,
const poly  m,
const ring  r 
)
inlinestatic

Definition at line 1002 of file p_polys.h.

1003 {
1004  int shorter;
1005  return r->p_Procs->pp_Mult_Coeff_mm_DivSelect(p, m, shorter, r);
1006 }
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208
int m
Definition: cfEzgcd.cc:119
static poly pp_Mult_Coeff_mm_DivSelect ( poly  p,
int &  lp,
const poly  m,
const ring  r 
)
inlinestatic

Definition at line 1010 of file p_polys.h.

1011 {
1012  int shorter;
1013  poly pp = r->p_Procs->pp_Mult_Coeff_mm_DivSelect(p, m, shorter, r);
1014  lp -= shorter;
1015  return pp;
1016 }
return P p
Definition: myNF.cc:203
poly pp
Definition: myNF.cc:296
const ring r
Definition: syzextra.cc:208
int m
Definition: cfEzgcd.cc:119
polyrec * poly
Definition: hilb.h:10
static poly pp_Mult_mm ( poly  p,
poly  m,
const ring  r 
)
inlinestatic

Definition at line 963 of file p_polys.h.

964 {
965  if (p_LmIsConstant(m, r))
966  return pp_Mult_nn(p, pGetCoeff(m), r);
967  else
968  {
969  return r->p_Procs->pp_Mult_mm(p, m, r);
970  }
971 }
return P p
Definition: myNF.cc:203
static poly pp_Mult_nn(poly p, number n, const ring r)
Definition: p_polys.h:928
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
static BOOLEAN p_LmIsConstant(const poly p, const ring r)
Definition: p_polys.h:955
const ring r
Definition: syzextra.cc:208
int m
Definition: cfEzgcd.cc:119
static poly pp_Mult_nn ( poly  p,
number  n,
const ring  r 
)
inlinestatic

Definition at line 928 of file p_polys.h.

929 {
930  if (n_IsOne(n, r->cf))
931  return p_Copy(p, r);
932  else
933  return r->p_Procs->pp_Mult_nn(p, n, r);
934 }
return P p
Definition: myNF.cc:203
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the one element.
Definition: coeffs.h:469
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition: p_polys.h:810
const ring r
Definition: syzextra.cc:208
static poly pp_Mult_qq ( poly  p,
poly  q,
const ring  r 
)
inlinestatic

Definition at line 1076 of file p_polys.h.

1077 {
1078  if (p == NULL || q == NULL) return NULL;
1079 
1080  if (pNext(p) == NULL)
1081  {
1082 #ifdef HAVE_PLURAL
1083  if (rIsPluralRing(r))
1084  return nc_mm_Mult_pp(p, q, r);
1085 #endif
1086  return r->p_Procs->pp_Mult_mm(q, p, r);
1087  }
1088 
1089  if (pNext(q) == NULL)
1090  {
1091  return r->p_Procs->pp_Mult_mm(p, q, r);
1092  }
1093 
1094  poly qq = q;
1095  if (p == q)
1096  qq = p_Copy(q, r);
1097 
1098  poly res;
1099 #ifdef HAVE_PLURAL
1100  if (rIsPluralRing(r))
1101  res = _nc_pp_Mult_qq(p, qq, r);
1102  else
1103 #endif
1104  res = _p_Mult_q(p, qq, 1, r);
1105 
1106  if (qq != q)
1107  p_Delete(&qq, r);
1108  return res;
1109 }
poly _nc_pp_Mult_qq(const poly p, const poly q, const ring r)
general NC-multiplication without destruction
Definition: old.gring.cc:313
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:273
return P p
Definition: myNF.cc:203
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition: p_polys.h:810
poly res
Definition: myNF.cc:322
const ring r
Definition: syzextra.cc:208
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:361
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:849
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
static poly nc_mm_Mult_pp(const poly m, const poly p, const ring r)
Definition: nc.h:240
polyrec * poly
Definition: hilb.h:10
void pRestoreDegProcs ( ring  r,
pFDegProc  old_FDeg,
pLDegProc  old_lDeg 
)

Definition at line 3504 of file p_polys.cc.

3505 {
3506  assume(old_FDeg != NULL && old_lDeg != NULL);
3507  r->pFDeg = old_FDeg;
3508  r->pLDeg = old_lDeg;
3509 }
const ring r
Definition: syzextra.cc:208
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static poly pReverse ( poly  p)
inlinestatic

Definition at line 330 of file p_polys.h.

331 {
332  if (p == NULL || pNext(p) == NULL) return p;
333 
334  poly q = pNext(p), // == pNext(p)
335  qn;
336  pNext(p) = NULL;
337  do
338  {
339  qn = pNext(q);
340  pNext(q) = p;
341  p = q;
342  q = qn;
343  }
344  while (qn != NULL);
345  return p;
346 }
return P p
Definition: myNF.cc:203
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
polyrec * poly
Definition: hilb.h:10
void pSetDegProcs ( ring  r,
pFDegProc  new_FDeg,
pLDegProc  new_lDeg = NULL 
)

Definition at line 3492 of file p_polys.cc.

3493 {
3494  assume(new_FDeg != NULL);
3495  r->pFDeg = new_FDeg;
3496 
3497  if (new_lDeg == NULL)
3498  new_lDeg = r->pLDegOrig;
3499 
3500  r->pLDeg = new_lDeg;
3501 }
const ring r
Definition: syzextra.cc:208
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10