Macros | Functions | Variables
p_polys.cc File Reference
#include <ctype.h>
#include <omalloc/omalloc.h>
#include <misc/auxiliary.h>
#include <misc/options.h>
#include <misc/intvec.h>
#include <coeffs/longrat.h>
#include <polys/PolyEnumerator.h>
#include <polys/ext_fields/transext.h>
#include <polys/ext_fields/algext.h>
#include <polys/weight.h>
#include <polys/simpleideals.h>
#include "ring.h"
#include "p_polys.h"
#include <polys/templates/p_MemCmp.h>
#include <polys/templates/p_MemAdd.h>
#include <polys/templates/p_MemCopy.h>
#include "nc/nc.h"
#include "nc/sca.h"
#include "coeffrings.h"
#include "clapsing.h"
#include <polys/templates/p_Delete__T.cc>

Go to the source code of this file.

Macros

#define TRANSEXT_PRIVATES
 
#define ADIDEBUG   0
 
#define MYTEST   0
 
#define CLEARENUMERATORS   1
 
#define Sy_bit_L(x)   (((unsigned long)1L)<<(x))
 
#define LINKAGE
 
#define p_Delete__T   p_ShallowDelete
 
#define n_Delete__T(n, r)   do {} while (0)
 

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)
 
void p_Setm_General (poly p, const ring r)
 
void p_Setm_Syz (poly p, ring r, int *Components, long *ShiftedComponents)
 
void p_Setm_Dummy (poly p, const ring r)
 
void p_Setm_TotalDegree (poly p, const ring r)
 
void p_Setm_WFirstTotalDegree (poly p, const ring r)
 
p_SetmProc p_GetSetmProc (const ring r)
 
long p_Deg (poly a, const ring r)
 
long p_WFirstTotalDegree (poly p, const ring r)
 
long p_WTotaldegree (poly p, const ring r)
 
long p_DegW (poly p, const short *w, const ring R)
 
int p_Weight (int i, const ring r)
 
long p_WDegree (poly p, const ring r)
 
long pLDeg0 (poly p, int *l, const ring r)
 
long pLDeg0c (poly p, int *l, const ring r)
 
long pLDegb (poly p, int *l, const ring r)
 
long pLDeg1 (poly p, int *l, const ring r)
 
long pLDeg1c (poly p, int *l, const ring r)
 
long pLDeg1_Deg (poly p, int *l, const ring r)
 
long pLDeg1c_Deg (poly p, int *l, const ring r)
 
long pLDeg1_Totaldegree (poly p, int *l, const ring r)
 
long pLDeg1c_Totaldegree (poly p, int *l, const ring r)
 
long pLDeg1_WFirstTotalDegree (poly p, int *l, const ring r)
 
long pLDeg1c_WFirstTotalDegree (poly p, int *l, const ring r)
 
static unsigned long p_GetMaxExpL2 (unsigned long l1, unsigned long l2, const ring r, unsigned long number_of_exp)
 
static unsigned long p_GetMaxExpL2 (unsigned long l1, unsigned long l2, const ring r)
 
poly p_GetMaxExpP (poly p, const 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...
 
unsigned long p_GetMaxExpL (poly p, const ring r, unsigned long l_max)
 return the maximal exponent of p in form of the maximal long var More...
 
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_One (const ring r)
 
void p_Split (poly p, poly *h)
 
BOOLEAN p_HasNotCF (poly p1, poly p2, const ring r)
 
const char * p_Read (const char *st, poly &rc, const ring r)
 
poly p_mInit (const char *st, BOOLEAN &ok, const ring r)
 
poly p_NSet (number n, const ring r)
 returns the poly representing the number n, destroys n More...
 
poly p_Divide (poly a, poly b, const ring r)
 
poly p_Div_nn (poly p, const number n, const ring r)
 
poly p_DivideM (poly a, poly b, const ring r)
 
BOOLEAN p_DivisibleByRingCase (poly f, poly g, const ring r)
 divisibility check over ground ring (which may contain zero divisors); TRUE iff LT(f) divides LT(g), i.e., LT(f)*c*m = LT(g), for some coefficient c and some monomial m; does not take components into account More...
 
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)
 
void p_LmDeleteAndNextRat (poly *p, int ishift, ring r)
 
poly p_GetCoeffRat (poly p, int ishift, ring r)
 
void p_ContentRat (poly &ph, 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...
 
poly p_Diff (poly a, int k, const ring r)
 
static poly p_DiffOpM (poly a, poly b, BOOLEAN multiply, const ring r)
 
poly p_DiffOp (poly a, poly b, BOOLEAN multiply, const ring r)
 
poly p_Sub (poly p1, poly p2, const ring r)
 
static poly p_MonPower (poly p, int exp, const ring r)
 
static void p_MonMult (poly p, poly q, const ring r)
 
static poly p_MonMultC (poly p, poly q, const ring rr)
 
static number * pnBin (int exp, const ring r)
 
static void pnFreeBin (number *bin, int exp, const coeffs r)
 
static poly p_TwoMonPower (poly p, int exp, const ring r)
 
static poly p_Pow (poly p, int i, const ring r)
 
static poly p_Pow_charp (poly p, int i, const ring r)
 
poly p_Power (poly p, int i, const ring r)
 
static number p_InitContent (poly ph, const ring r)
 
void p_Content (poly ph, const ring r)
 
void p_SimpleContent (poly ph, int smax, const ring r)
 
poly p_Cleardenom (poly p, const ring r)
 
void p_Cleardenom_n (poly ph, const ring r, number &c)
 
void p_ProjectiveUnique (poly ph, const ring r)
 
int p_Size (poly p, const ring r)
 
poly p_Homogen (poly p, int varnum, const ring r)
 
BOOLEAN p_IsHomogeneous (poly p, const ring r)
 
BOOLEAN p_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)
 
poly p_TakeOutComp (poly *p, int k, const ring r)
 
void p_TakeOutComp (poly *r_p, long comp, poly *r_q, int *lq, const ring r)
 
void p_DeleteComp (poly *p, int k, const ring r)
 
void p_Vec2Polys (poly v, poly **p, int *len, const ring r)
 
void pSetDegProcs (ring r, pFDegProc new_FDeg, pLDegProc new_lDeg)
 
void pRestoreDegProcs (ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
 
static long pModDeg (poly p, ring r)
 
void p_SetModDeg (intvec *w, ring r)
 
void pEnlargeSet (poly **p, int l, int increment)
 
void p_Norm (poly p1, const ring r)
 
void p_Normalize (poly p, const ring r)
 
static void p_SplitAndReversePoly (poly p, int n, poly *non_zero, poly *zero, const ring r)
 
static poly p_Subst1 (poly p, int n, const ring r)
 
static poly p_Subst2 (poly p, int n, number e, const ring r)
 
static poly p_Subst0 (poly p, int n, const ring r)
 
poly p_Subst (poly p, int n, poly e, const ring r)
 
poly n_PermNumber (const number z, const int *par_perm, const int, 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, int OldPar, BOOLEAN use_mult)
 
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)
 
int p_MinDeg (poly p, intvec *w, const ring R)
 
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)
 
BOOLEAN p_EqualPolys (poly p1, poly p2, const ring r)
 
static BOOLEAN p_ExpVectorEqual (poly p1, poly p2, const ring r1, const ring r2)
 
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...
 
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...
 
poly p_Last (const poly p, int &l, const ring r)
 
int p_Var (poly m, 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...
 
static unsigned long GetBitFields (const long e, const unsigned int s, const unsigned int n)
 
unsigned long p_GetShortExpVector (const poly p, const ring r)
 
unsigned long p_GetShortExpVector (const poly p, const poly pp, const ring r)
 p_GetShortExpVector of p * pp More...
 

Variables

static int * _components = NULL
 
static long * _componentsShifted = NULL
 
static int _componentsExternal = 0
 
BOOLEAN pSetm_error =0
 
static pFDegProc pOldFDeg
 
static pLDegProc pOldLDeg
 
static BOOLEAN pOldLexOrder
 

Macro Definition Documentation

#define ADIDEBUG   0

Definition at line 56 of file p_polys.cc.

#define CLEARENUMERATORS   1

Definition at line 2205 of file p_polys.cc.

#define LINKAGE

Definition at line 4699 of file p_polys.cc.

#define MYTEST   0

Definition at line 160 of file p_polys.cc.

#define n_Delete__T (   n,
  r 
)    do {} while (0)

Definition at line 4703 of file p_polys.cc.

#define p_Delete__T   p_ShallowDelete

Definition at line 4701 of file p_polys.cc.

#define Sy_bit_L (   x)    (((unsigned long)1L)<<(x))
#define TRANSEXT_PRIVATES

Definition at line 25 of file p_polys.cc.

Function Documentation

static unsigned long GetBitFields ( const long  e,
const unsigned int  s,
const unsigned int  n 
)
inlinestatic

Definition at line 4553 of file p_polys.cc.

4555 {
4556 #define Sy_bit_L(x) (((unsigned long)1L)<<(x))
4557  unsigned int i = 0;
4558  unsigned long ev = 0L;
4559  assume(n > 0 && s < BIT_SIZEOF_LONG);
4560  do
4561  {
4562  assume(s+i < BIT_SIZEOF_LONG);
4563  if (e > (long) i) ev |= Sy_bit_L(s+i);
4564  else break;
4565  i++;
4566  }
4567  while (i < n);
4568  return ev;
4569 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
#define assume(x)
Definition: mod2.h:405
int i
Definition: cfEzgcd.cc:123
#define Sy_bit_L(x)
#define BIT_SIZEOF_LONG
Definition: auxiliary.h:124
poly n_PermNumber ( const number  z,
const int *  par_perm,
const int  ,
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
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  ph,
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
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  ph,
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
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
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
static poly p_DiffOpM ( poly  a,
poly  b,
BOOLEAN  multiply,
const ring  r 
)
static

Definition at line 1845 of file p_polys.cc.

1846 {
1847  int i,j,s;
1848  number n,h,hh;
1849  poly p=p_One(r);
1850  n=n_Mult(pGetCoeff(a),pGetCoeff(b),r->cf);
1851  for(i=rVar(r);i>0;i--)
1852  {
1853  s=p_GetExp(b,i,r);
1854  if (s<p_GetExp(a,i,r))
1855  {
1856  n_Delete(&n,r->cf);
1857  p_LmDelete(&p,r);
1858  return NULL;
1859  }
1860  if (multiply)
1861  {
1862  for(j=p_GetExp(a,i,r); j>0;j--)
1863  {
1864  h = n_Init(s,r->cf);
1865  hh=n_Mult(n,h,r->cf);
1866  n_Delete(&h,r->cf);
1867  n_Delete(&n,r->cf);
1868  n=hh;
1869  s--;
1870  }
1871  p_SetExp(p,i,s,r);
1872  }
1873  else
1874  {
1875  p_SetExp(p,i,s-p_GetExp(a,i,r),r);
1876  }
1877  }
1878  p_Setm(p,r);
1879  /*if (multiply)*/ p_SetCoeff(p,n,r);
1880  if (n_IsZero(n,r->cf)) p=p_LmDeleteAndNext(p,r); // return NULL as p is a monomial
1881  return p;
1882 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
const poly a
Definition: syzextra.cc:212
static poly p_LmDeleteAndNext(poly p, const ring r)
Definition: p_polys.h:720
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
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:537
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_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
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
int j
Definition: myNF.cc:70
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 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 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
static Poly * h
Definition: janet.cc:978
const poly b
Definition: syzextra.cc:213
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
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 BOOLEAN p_ExpVectorEqual ( poly  p1,
poly  p2,
const ring  r1,
const ring  r2 
)
inlinestatic

Definition at line 4332 of file p_polys.cc.

4333 {
4334  assume( r1 == r2 || rSamePolyRep(r1, r2) );
4335 
4336  p_LmCheckPolyRing1(p1, r1);
4337  p_LmCheckPolyRing1(p2, r2);
4338 
4339  int i = r1->ExpL_Size;
4340 
4341  assume( r1->ExpL_Size == r2->ExpL_Size );
4342 
4343  unsigned long *ep = p1->exp;
4344  unsigned long *eq = p2->exp;
4345 
4346  do
4347  {
4348  i--;
4349  if (ep[i] != eq[i]) return FALSE;
4350  }
4351  while (i);
4352 
4353  return TRUE;
4354 }
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
#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
int i
Definition: cfEzgcd.cc:123
#define p_LmCheckPolyRing1(p, r)
Definition: monomials.h:185
END_NAMESPACE const void * p2
Definition: syzextra.cc:202
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
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
unsigned long p_GetMaxExpL ( poly  p,
const ring  r,
unsigned long  l_max 
)

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
static unsigned long p_GetMaxExpL2 ( unsigned long  l1,
unsigned long  l2,
const ring  r,
unsigned long  number_of_exp 
)
inlinestatic

Definition at line 1106 of file p_polys.cc.

1108 {
1109  const unsigned long bitmask = r->bitmask;
1110  unsigned long ml1 = l1 & bitmask;
1111  unsigned long ml2 = l2 & bitmask;
1112  unsigned long max = (ml1 > ml2 ? ml1 : ml2);
1113  unsigned long j = number_of_exp - 1;
1114 
1115  if (j > 0)
1116  {
1117  unsigned long mask = bitmask << r->BitsPerExp;
1118  while (1)
1119  {
1120  ml1 = l1 & mask;
1121  ml2 = l2 & mask;
1122  max |= ((ml1 > ml2 ? ml1 : ml2) & mask);
1123  j--;
1124  if (j == 0) break;
1125  mask = mask << r->BitsPerExp;
1126  }
1127  }
1128  return max;
1129 }
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
static unsigned long p_GetMaxExpL2 ( unsigned long  l1,
unsigned long  l2,
const ring  r 
)
inlinestatic

Definition at line 1132 of file p_polys.cc.

1133 {
1134  return p_GetMaxExpL2(l1, l2, r, r->ExpPerLong);
1135 }
const ring r
Definition: syzextra.cc:208
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,
const 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
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  p,
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
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
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 number p_InitContent ( poly  ph,
const ring  r 
)
static

Definition at line 2474 of file p_polys.cc.

2477 {
2479  assume(ph!=NULL);
2480  assume(pNext(ph)!=NULL);
2481  assume(rField_is_Q(r));
2482  if (pNext(pNext(ph))==NULL)
2483  {
2484  return n_GetNumerator(pGetCoeff(pNext(ph)),r->cf);
2485  }
2486  poly p=ph;
2487  number n1=n_GetNumerator(pGetCoeff(p),r->cf);
2488  pIter(p);
2489  number n2=n_GetNumerator(pGetCoeff(p),r->cf);
2490  pIter(p);
2491  number d;
2492  number t;
2493  loop
2494  {
2495  nlNormalize(pGetCoeff(p),r->cf);
2496  t=n_GetNumerator(pGetCoeff(p),r->cf);
2497  if (nlGreaterZero(t,r->cf))
2498  d=nlAdd(n1,t,r->cf);
2499  else
2500  d=nlSub(n1,t,r->cf);
2501  nlDelete(&t,r->cf);
2502  nlDelete(&n1,r->cf);
2503  n1=d;
2504  pIter(p);
2505  if (p==NULL) break;
2506  nlNormalize(pGetCoeff(p),r->cf);
2507  t=n_GetNumerator(pGetCoeff(p),r->cf);
2508  if (nlGreaterZero(t,r->cf))
2509  d=nlAdd(n2,t,r->cf);
2510  else
2511  d=nlSub(n2,t,r->cf);
2512  nlDelete(&t,r->cf);
2513  nlDelete(&n2,r->cf);
2514  n2=d;
2515  pIter(p);
2516  if (p==NULL) break;
2517  }
2518  d=nlGcd(n1,n2,r->cf);
2519  nlDelete(&n1,r->cf);
2520  nlDelete(&n2,r->cf);
2521  return d;
2522 }
2523 #else
2524 {
2525  number d=pGetCoeff(ph);
2526  int s;
2527  int s2=-1;
2528  if(rField_is_Q(r))
2529  {
2530  if (SR_HDL(d)&SR_INT) return d;
2531  s=mpz_size1(d->z);
2532  }
2533  else
2534  s=n_Size(d,r);
2535  number d2=d;
2536  loop
2537  {
2538  pIter(ph);
2539  if(ph==NULL)
2540  {
2541  if (s2==-1) return n_Copy(d,r->cf);
2542  break;
2543  }
2544  if (rField_is_Q(r))
2545  {
2546  if (SR_HDL(pGetCoeff(ph))&SR_INT)
2547  {
2548  s2=s;
2549  d2=d;
2550  s=0;
2551  d=pGetCoeff(ph);
2552  if (s2==0) break;
2553  }
2554  else if (mpz_size1((pGetCoeff(ph)->z))<=s)
2555  {
2556  s2=s;
2557  d2=d;
2558  d=pGetCoeff(ph);
2559  s=mpz_size1(d->z);
2560  }
2561  }
2562  else
2563  {
2564  int ns=n_Size(pGetCoeff(ph),r);
2565  if (ns<=3)
2566  {
2567  s2=s;
2568  d2=d;
2569  d=pGetCoeff(ph);
2570  s=ns;
2571  if (s2<=3) break;
2572  }
2573  else if (ns<s)
2574  {
2575  s2=s;
2576  d2=d;
2577  d=pGetCoeff(ph);
2578  s=ns;
2579  }
2580  }
2581  }
2582  return n_SubringGcd(d,d2,r->cf);
2583 }
static FORCE_INLINE number n_GetNumerator(number &n, const coeffs r)
return the numerator of n (if elements of r are by nature not fractional, result is n) ...
Definition: coeffs.h:609
LINLINE number nlSub(number la, number li, const coeffs r)
Definition: longrat.cc:2581
const CanonicalForm int s
Definition: facAbsFact.cc:55
BOOLEAN nlGreaterZero(number za, const coeffs r)
Definition: longrat.cc:1155
loop
Definition: myNF.cc:98
return P p
Definition: myNF.cc:203
#define TEST_OPT_CONTENTSB
Definition: options.h:121
LINLINE number nlAdd(number la, number li, const coeffs r)
Definition: longrat.cc:2515
number nlGcd(number a, number b, const coeffs r)
Definition: longrat.cc:1192
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
#define assume(x)
Definition: mod2.h:405
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:458
void nlNormalize(number &x, const coeffs r)
Definition: longrat.cc:1334
#define mpz_size1(A)
Definition: si_gmp.h:12
#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
LINLINE void nlDelete(number *a, const coeffs r)
Definition: longrat.cc:2480
#define SR_INT
Definition: longrat.h:65
#define pNext(p)
Definition: monomials.h:43
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
Definition: coeffs.h:689
#define SR_HDL(A)
Definition: tgb.cc:35
polyrec * poly
Definition: hilb.h: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
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
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
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
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  p,
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
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
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
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 *  st,
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 void p_MonMult ( poly  p,
poly  q,
const ring  r 
)
static

Definition at line 1935 of file p_polys.cc.

1936 {
1937  number x, y;
1938 
1939  y = pGetCoeff(p);
1940  x = n_Mult(y,pGetCoeff(q),r->cf);
1941  n_Delete(&y,r->cf);
1942  pSetCoeff0(p,x);
1943  //for (int i=pVariables; i!=0; i--)
1944  //{
1945  // pAddExp(p,i, pGetExp(q,i));
1946  //}
1947  //p->Order += q->Order;
1948  p_ExpVectorAdd(p,q,r);
1949 }
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:57
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 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 void p_ExpVectorAdd(poly p1, poly p2, const ring r)
Definition: p_polys.h:1340
Variable x
Definition: cfModGcd.cc:4023
#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
static poly p_MonMultC ( poly  p,
poly  q,
const ring  rr 
)
static

Definition at line 1955 of file p_polys.cc.

1956 {
1957  number x;
1958  poly r = p_Init(rr);
1959 
1960  x = n_Mult(pGetCoeff(p),pGetCoeff(q),rr->cf);
1961  pSetCoeff0(r,x);
1962  p_ExpVectorSum(r,p, q, rr);
1963  return r;
1964 }
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 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
Variable x
Definition: cfModGcd.cc:4023
#define pSetCoeff0(p, n)
Definition: monomials.h:67
static void p_ExpVectorSum(poly pr, poly p1, poly p2, const ring r)
Definition: p_polys.h:1354
polyrec * poly
Definition: hilb.h:10
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1249
static poly p_MonPower ( poly  p,
int  exp,
const ring  r 
)
static

Definition at line 1911 of file p_polys.cc.

1912 {
1913  int i;
1914 
1915  if(!n_IsOne(pGetCoeff(p),r->cf))
1916  {
1917  number x, y;
1918  y = pGetCoeff(p);
1919  n_Power(y,exp,&x,r->cf);
1920  n_Delete(&y,r->cf);
1921  pSetCoeff0(p,x);
1922  }
1923  for (i=rVar(r); i!=0; i--)
1924  {
1925  p_MultExp(p,i, exp,r);
1926  }
1927  p_Setm(p,r);
1928  return p;
1929 }
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:57
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 short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:537
static long p_MultExp(poly p, int v, long ee, ring r)
Definition: p_polys.h:616
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 void n_Power(number a, int b, number *res, const coeffs r)
fill res with the power a^b
Definition: coeffs.h:633
Variable x
Definition: cfModGcd.cc:4023
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:228
#define pSetCoeff0(p, n)
Definition: monomials.h:67
p exp[i]
Definition: DebugPrint.cc:39
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
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,
int  OldPar,
BOOLEAN  use_mult 
)

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
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
static poly p_Pow ( poly  p,
int  i,
const ring  r 
)
static

Definition at line 2082 of file p_polys.cc.

2083 {
2084  poly rc = p_Copy(p,r);
2085  i -= 2;
2086  do
2087  {
2088  rc = p_Mult_q(rc,p_Copy(p,r),r);
2089  p_Normalize(rc,r);
2090  i--;
2091  }
2092  while (i != 0);
2093  return p_Mult_q(rc,p,r);
2094 }
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
const ring r
Definition: syzextra.cc:208
int i
Definition: cfEzgcd.cc:123
void p_Normalize(poly p, const ring r)
Definition: p_polys.cc:3632
polyrec * poly
Definition: hilb.h:10
static poly p_Mult_q(poly p, poly q, const ring r)
Definition: p_polys.h:1026
static poly p_Pow_charp ( poly  p,
int  i,
const ring  r 
)
static

Definition at line 2096 of file p_polys.cc.

2097 {
2098  //assume char_p == i
2099  poly h=p;
2100  while(h!=NULL) { p_MonPower(h,i,r);pIter(h);}
2101  return p;
2102 }
static poly p_MonPower(poly p, int exp, const ring r)
Definition: p_polys.cc:1911
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
polyrec * poly
Definition: hilb.h:10
static Poly * h
Definition: janet.cc:978
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  ph,
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 *  st,
poly rc,
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
void p_Setm_Dummy ( poly  p,
const ring  r 
)

Definition at line 540 of file p_polys.cc.

541 {
543 }
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208
BOOLEAN p_LmCheckPolyRing(poly p, ring r)
Definition: pDebug.cc:119
void p_Setm_General ( poly  p,
const ring  r 
)

!!!????? where?????

Definition at line 163 of file p_polys.cc.

164 {
166  int pos=0;
167  if (r->typ!=NULL)
168  {
169  loop
170  {
171  unsigned long ord=0;
172  sro_ord* o=&(r->typ[pos]);
173  switch(o->ord_typ)
174  {
175  case ro_dp:
176  {
177  int a,e;
178  a=o->data.dp.start;
179  e=o->data.dp.end;
180  for(int i=a;i<=e;i++) ord+=p_GetExp(p,i,r);
181  p->exp[o->data.dp.place]=ord;
182  break;
183  }
184  case ro_wp_neg:
186  // no break;
187  case ro_wp:
188  {
189  int a,e;
190  a=o->data.wp.start;
191  e=o->data.wp.end;
192  int *w=o->data.wp.weights;
193 #if 1
194  for(int i=a;i<=e;i++) ord+=((unsigned long)p_GetExp(p,i,r))*((unsigned long)w[i-a]);
195 #else
196  long ai;
197  int ei,wi;
198  for(int i=a;i<=e;i++)
199  {
200  ei=p_GetExp(p,i,r);
201  wi=w[i-a];
202  ai=ei*wi;
203  if (ai/ei!=wi) pSetm_error=TRUE;
204  ord+=ai;
205  if (ord<ai) pSetm_error=TRUE;
206  }
207 #endif
208  p->exp[o->data.wp.place]=ord;
209  break;
210  }
211  case ro_am:
212  {
213  ord = POLY_NEGWEIGHT_OFFSET;
214  const short a=o->data.am.start;
215  const short e=o->data.am.end;
216  const int * w=o->data.am.weights;
217 #if 1
218  for(short i=a; i<=e; i++, w++)
219  ord += ((*w) * p_GetExp(p,i,r));
220 #else
221  long ai;
222  int ei,wi;
223  for(short i=a;i<=e;i++)
224  {
225  ei=p_GetExp(p,i,r);
226  wi=w[i-a];
227  ai=ei*wi;
228  if (ai/ei!=wi) pSetm_error=TRUE;
229  ord += ai;
230  if (ord<ai) pSetm_error=TRUE;
231  }
232 #endif
233  const int c = p_GetComp(p,r);
234 
235  const short len_gen= o->data.am.len_gen;
236 
237  if ((c > 0) && (c <= len_gen))
238  {
239  assume( w == o->data.am.weights_m );
240  assume( w[0] == len_gen );
241  ord += w[c];
242  }
243 
244  p->exp[o->data.am.place] = ord;
245  break;
246  }
247  case ro_wp64:
248  {
249  int64 ord=0;
250  int a,e;
251  a=o->data.wp64.start;
252  e=o->data.wp64.end;
253  int64 *w=o->data.wp64.weights64;
254  int64 ei,wi,ai;
255  for(int i=a;i<=e;i++)
256  {
257  //Print("exp %d w %d \n",p_GetExp(p,i,r),(int)w[i-a]);
258  //ord+=((int64)p_GetExp(p,i,r))*w[i-a];
259  ei=(int64)p_GetExp(p,i,r);
260  wi=w[i-a];
261  ai=ei*wi;
262  if(ei!=0 && ai/ei!=wi)
263  {
265  #if SIZEOF_LONG == 4
266  Print("ai %lld, wi %lld\n",ai,wi);
267  #else
268  Print("ai %ld, wi %ld\n",ai,wi);
269  #endif
270  }
271  ord+=ai;
272  if (ord<ai)
273  {
275  #if SIZEOF_LONG == 4
276  Print("ai %lld, ord %lld\n",ai,ord);
277  #else
278  Print("ai %ld, ord %ld\n",ai,ord);
279  #endif
280  }
281  }
282  int64 mask=(int64)0x7fffffff;
283  long a_0=(long)(ord&mask); //2^31
284  long a_1=(long)(ord >>31 ); /*(ord/(mask+1));*/
285 
286  //Print("mask: %x, ord: %d, a_0: %d, a_1: %d\n"
287  //,(int)mask,(int)ord,(int)a_0,(int)a_1);
288  //Print("mask: %d",mask);
289 
290  p->exp[o->data.wp64.place]=a_1;
291  p->exp[o->data.wp64.place+1]=a_0;
292 // if(p_Setm_error) Print("***************************\n
293 // ***************************\n
294 // **WARNING: overflow error**\n
295 // ***************************\n
296 // ***************************\n");
297  break;
298  }
299  case ro_cp:
300  {
301  int a,e;
302  a=o->data.cp.start;
303  e=o->data.cp.end;
304  int pl=o->data.cp.place;
305  for(int i=a;i<=e;i++) { p->exp[pl]=p_GetExp(p,i,r); pl++; }
306  break;
307  }
308  case ro_syzcomp:
309  {
310  long c=p_GetComp(p,r);
311  long sc = c;
312  int* Components = (_componentsExternal ? _components :
313  o->data.syzcomp.Components);
314  long* ShiftedComponents = (_componentsExternal ? _componentsShifted:
315  o->data.syzcomp.ShiftedComponents);
316  if (ShiftedComponents != NULL)
317  {
318  assume(Components != NULL);
319  assume(c == 0 || Components[c] != 0);
320  sc = ShiftedComponents[Components[c]];
321  assume(c == 0 || sc != 0);
322  }
323  p->exp[o->data.syzcomp.place]=sc;
324  break;
325  }
326  case ro_syz:
327  {
328  const unsigned long c = p_GetComp(p, r);
329  const short place = o->data.syz.place;
330  const int limit = o->data.syz.limit;
331 
332  if (c > (unsigned long)limit)
333  p->exp[place] = o->data.syz.curr_index;
334  else if (c > 0)
335  {
336  assume( (1 <= c) && (c <= (unsigned long)limit) );
337  p->exp[place]= o->data.syz.syz_index[c];
338  }
339  else
340  {
341  assume(c == 0);
342  p->exp[place]= 0;
343  }
344  break;
345  }
346  // Prefix for Induced Schreyer ordering
347  case ro_isTemp: // Do nothing?? (to be removed into suffix later on...?)
348  {
349  assume(p != NULL);
350 
351 #ifndef SING_NDEBUG
352 #if MYTEST
353  Print("p_Setm_General: ro_isTemp ord: pos: %d, p: ", pos); p_wrp(p, r);
354 #endif
355 #endif
356  int c = p_GetComp(p, r);
357 
358  assume( c >= 0 );
359 
360  // Let's simulate case ro_syz above....
361  // Should accumulate (by Suffix) and be a level indicator
362  const int* const pVarOffset = o->data.isTemp.pVarOffset;
363 
364  assume( pVarOffset != NULL );
365 
366  // TODO: Can this be done in the suffix???
367  for( int i = 1; i <= r->N; i++ ) // No v[0] here!!!
368  {
369  const int vo = pVarOffset[i];
370  if( vo != -1) // TODO: optimize: can be done once!
371  {
372  // Hans! Please don't break it again! p_SetExp(p, ..., r, vo) is correct:
373  p_SetExp(p, p_GetExp(p, i, r), r, vo); // copy put them verbatim
374  // Hans! Please don't break it again! p_GetExp(p, r, vo) is correct:
375  assume( p_GetExp(p, r, vo) == p_GetExp(p, i, r) ); // copy put them verbatim
376  }
377  }
378 #ifndef SING_NDEBUG
379  for( int i = 1; i <= r->N; i++ ) // No v[0] here!!!
380  {
381  const int vo = pVarOffset[i];
382  if( vo != -1) // TODO: optimize: can be done once!
383  {
384  // Hans! Please don't break it again! p_GetExp(p, r, vo) is correct:
385  assume( p_GetExp(p, r, vo) == p_GetExp(p, i, r) ); // copy put them verbatim
386  }
387  }
388 #if MYTEST
389 // if( p->exp[o->data.isTemp.start] > 0 )
390  PrintS("after Values: "); p_wrp(p, r);
391 #endif
392 #endif
393  break;
394  }
395 
396  // Suffix for Induced Schreyer ordering
397  case ro_is:
398  {
399 #ifndef SING_NDEBUG
400 #if MYTEST
401  Print("p_Setm_General: ro_is ord: pos: %d, p: ", pos); p_wrp(p, r);
402 #endif
403 #endif
404 
405  assume(p != NULL);
406 
407  int c = p_GetComp(p, r);
408 
409  assume( c >= 0 );
410  const ideal F = o->data.is.F;
411  const int limit = o->data.is.limit;
412  assume( limit >= 0 );
413  const int start = o->data.is.start;
414 
415  if( F != NULL && c > limit )
416  {
417 #ifndef SING_NDEBUG
418 #if MYTEST
419  Print("p_Setm_General: ro_is : in rSetm: pos: %d, c: %d > limit: %d\n", c, pos, limit);
420  PrintS("preComputed Values: ");
421  p_wrp(p, r);
422 #endif
423 #endif
424 // if( c > limit ) // BUG???
425  p->exp[start] = 1;
426 // else
427 // p->exp[start] = 0;
428 
429 
430  c -= limit;
431  assume( c > 0 );
432  c--;
433 
434  if( c >= IDELEMS(F) )
435  break;
436 
437  assume( c < IDELEMS(F) ); // What about others???
438 
439  const poly pp = F->m[c]; // get reference monomial!!!
440 
441  if(pp == NULL)
442  break;
443 
444  assume(pp != NULL);
445 
446 #ifndef SING_NDEBUG
447 #if MYTEST
448  Print("Respective F[c - %d: %d] pp: ", limit, c);
449  p_wrp(pp, r);
450 #endif
451 #endif
452 
453  const int end = o->data.is.end;
454  assume(start <= end);
455 
456 
457 // const int st = o->data.isTemp.start;
458 
459 #ifndef SING_NDEBUG
460  Print("p_Setm_General: is(-Temp-) :: c: %d, limit: %d, [st:%d] ===>>> %ld\n", c, limit, start, p->exp[start]);
461 #endif
462 
463  // p_ExpVectorAdd(p, pp, r);
464 
465  for( int i = start; i <= end; i++) // v[0] may be here...
466  p->exp[i] += pp->exp[i]; // !!!!!!!! ADD corresponding LT(F)
467 
468  // p_MemAddAdjust(p, ri);
469  if (r->NegWeightL_Offset != NULL)
470  {
471  for (int i=r->NegWeightL_Size-1; i>=0; i--)
472  {
473  const int _i = r->NegWeightL_Offset[i];
474  if( start <= _i && _i <= end )
475  p->exp[_i] -= POLY_NEGWEIGHT_OFFSET;
476  }
477  }
478 
479 
480 #ifndef SING_NDEBUG
481  const int* const pVarOffset = o->data.is.pVarOffset;
482 
483  assume( pVarOffset != NULL );
484 
485  for( int i = 1; i <= r->N; i++ ) // No v[0] here!!!
486  {
487  const int vo = pVarOffset[i];
488  if( vo != -1) // TODO: optimize: can be done once!
489  // Hans! Please don't break it again! p_GetExp(p/pp, r, vo) is correct:
490  assume( p_GetExp(p, r, vo) == (p_GetExp(p, i, r) + p_GetExp(pp, r, vo)) );
491  }
492  // TODO: how to check this for computed values???
493 #if MYTEST
494  PrintS("Computed Values: "); p_wrp(p, r);
495 #endif
496 #endif
497  } else
498  {
499  p->exp[start] = 0; //!!!!????? where?????
500 
501  const int* const pVarOffset = o->data.is.pVarOffset;
502 
503  // What about v[0] - component: it will be added later by
504  // suffix!!!
505  // TODO: Test it!
506  const int vo = pVarOffset[0];
507  if( vo != -1 )
508  p->exp[vo] = c; // initial component v[0]!
509 
510 #ifndef SING_NDEBUG
511 #if MYTEST
512  Print("ELSE p_Setm_General: ro_is :: c: %d <= limit: %d, vo: %d, exp: %d\n", c, limit, vo, p->exp[vo]);
513  p_wrp(p, r);
514 #endif
515 #endif
516  }
517 
518  break;
519  }
520  default:
521  dReportError("wrong ord in rSetm:%d\n",o->ord_typ);
522  return;
523  }
524  pos++;
525  if (pos == r->OrdSize) return;
526  }
527  }
528 }
Definition: ring.h:68
const poly a
Definition: syzextra.cc:212
#define POLY_NEGWEIGHT_OFFSET
Definition: monomials.h:244
#define Print
Definition: emacs.cc:83
Definition: ring.h:61
loop
Definition: myNF.cc:98
if(0 > strat->sl)
Definition: myNF.cc:73
return P p
Definition: myNF.cc:203
static int _componentsExternal
Definition: p_polys.cc:153
#define p_GetComp(p, r)
Definition: monomials.h:72
long int64
Definition: auxiliary.h:112
#define TRUE
Definition: auxiliary.h:144
Definition: ring.h:66
Definition: ring.h:64
union sro_ord::@0 data
poly pp
Definition: myNF.cc:296
ro_typ ord_typ
Definition: ring.h:182
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
Definition: ring.h:180
int i
Definition: cfEzgcd.cc:123
void PrintS(const char *s)
Definition: reporter.cc:294
BOOLEAN pSetm_error
Definition: p_polys.cc:155
#define IDELEMS(i)
Definition: simpleideals.h:24
Definition: ring.h:69
Definition: ring.h:69
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
BOOLEAN p_LmCheckPolyRing(poly p, ring r)
Definition: pDebug.cc:119
static int * _components
Definition: p_polys.cc:151
const CanonicalForm & w
Definition: facAbsFact.cc:55
Definition: ring.h:63
Definition: ring.h:60
Definition: ring.h:62
int dReportError(const char *fmt,...)
Definition: dError.cc:45
static long * _componentsShifted
Definition: p_polys.cc:152
void p_wrp(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:237
polyrec * poly
Definition: hilb.h:10
void p_Setm_Syz ( poly  p,
ring  r,
int *  Components,
long *  ShiftedComponents 
)

Definition at line 530 of file p_polys.cc.

531 {
532  _components = Components;
533  _componentsShifted = ShiftedComponents;
535  p_Setm_General(p, r);
537 }
void p_Setm_General(poly p, const ring r)
Definition: p_polys.cc:163
return P p
Definition: myNF.cc:203
static int _componentsExternal
Definition: p_polys.cc:153
const ring r
Definition: syzextra.cc:208
static int * _components
Definition: p_polys.cc:151
static long * _componentsShifted
Definition: p_polys.cc:152
void p_Setm_TotalDegree ( poly  p,
const ring  r 
)

Definition at line 546 of file p_polys.cc.

547 {
549  p->exp[r->pOrdIndex] = p_Totaldegree(p, r);
550 }
return P p
Definition: myNF.cc:203
static long p_Totaldegree(poly p, const ring r)
Definition: p_polys.h:1436
const ring r
Definition: syzextra.cc:208
BOOLEAN p_LmCheckPolyRing(poly p, ring r)
Definition: pDebug.cc:119
void p_Setm_WFirstTotalDegree ( poly  p,
const ring  r 
)

Definition at line 553 of file p_polys.cc.

554 {
556  p->exp[r->pOrdIndex] = p_WFirstTotalDegree(p, r);
557 }
return P p
Definition: myNF.cc:203
const ring r
Definition: syzextra.cc:208
long p_WFirstTotalDegree(poly p, const ring r)
Definition: p_polys.cc:595
BOOLEAN p_LmCheckPolyRing(poly p, ring r)
Definition: pDebug.cc:119
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
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  ph,
int  smax,
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
void p_Split ( poly  p,
poly h 
)

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
static void p_SplitAndReversePoly ( poly  p,
int  n,
poly non_zero,
poly zero,
const ring  r 
)
static

Definition at line 3645 of file p_polys.cc.

3646 {
3647  if (p == NULL)
3648  {
3649  *non_zero = NULL;
3650  *zero = NULL;
3651  return;
3652  }
3653  spolyrec sz;
3654  poly z, n_z, next;
3655  z = &sz;
3656  n_z = NULL;
3657 
3658  while(p != NULL)
3659  {
3660  next = pNext(p);
3661  if (p_GetExp(p, n,r) == 0)
3662  {
3663  pNext(z) = p;
3664  pIter(z);
3665  }
3666  else
3667  {
3668  pNext(p) = n_z;
3669  n_z = p;
3670  }
3671  p = next;
3672  }
3673  pNext(z) = NULL;
3674  *zero = pNext(&sz);
3675  *non_zero = n_z;
3676 }
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
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
polyrec * poly
Definition: hilb.h:10
ListNode * next
Definition: janet.h:31
poly p_Sub ( poly  p1,
poly  p2,
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
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
static poly p_Subst0 ( poly  p,
int  n,
const ring  r 
)
static

Definition at line 3749 of file p_polys.cc.

3750 {
3751  spolyrec res;
3752  poly h = &res;
3753  pNext(h) = p;
3754 
3755  while (pNext(h)!=NULL)
3756  {
3757  if (p_GetExp(pNext(h),n,r)!=0)
3758  {
3759  p_LmDelete(&pNext(h),r);
3760  }
3761  else
3762  {
3763  pIter(h);
3764  }
3765  }
3766  p_Test(pNext(&res),r);
3767  return pNext(&res);
3768 }
return P p
Definition: myNF.cc:203
#define pIter(p)
Definition: monomials.h:44
poly res
Definition: myNF.cc:322
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 p_Test(p, r)
Definition: p_polys.h:160
#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
static Poly * h
Definition: janet.cc:978
static poly p_Subst1 ( poly  p,
int  n,
const ring  r 
)
static

Definition at line 3681 of file p_polys.cc.

3682 {
3683  poly qq=NULL, result = NULL;
3684  poly zero=NULL, non_zero=NULL;
3685 
3686  // reverse, so that add is likely to be linear
3687  p_SplitAndReversePoly(p, n, &non_zero, &zero,r);
3688 
3689  while (non_zero != NULL)
3690  {
3691  assume(p_GetExp(non_zero, n,r) != 0);
3692  qq = non_zero;
3693  pIter(non_zero);
3694  qq->next = NULL;
3695  p_SetExp(qq,n,0,r);
3696  p_Setm(qq,r);
3697  result = p_Add_q(result,qq,r);
3698  }
3699  p = p_Add_q(result, zero,r);
3700  p_Test(p,r);
3701  return p;
3702 }
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
#define assume(x)
Definition: mod2.h:405
#define p_Test(p, r)
Definition: p_polys.h:160
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 void p_Setm(poly p, const ring r)
Definition: p_polys.h:228
static void p_SplitAndReversePoly(poly p, int n, poly *non_zero, poly *zero, const ring r)
Definition: p_polys.cc:3645
polyrec * poly
Definition: hilb.h:10
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:883
return result
Definition: facAbsBiFact.cc:76
static poly p_Subst2 ( poly  p,
int  n,
number  e,
const ring  r 
)
static

Definition at line 3708 of file p_polys.cc.

3709 {
3710  assume( ! n_IsZero(e,r->cf) );
3711  poly qq,result = NULL;
3712  number nn, nm;
3713  poly zero, non_zero;
3714 
3715  // reverse, so that add is likely to be linear
3716  p_SplitAndReversePoly(p, n, &non_zero, &zero,r);
3717 
3718  while (non_zero != NULL)
3719  {
3720  assume(p_GetExp(non_zero, n, r) != 0);
3721  qq = non_zero;
3722  pIter(non_zero);
3723  qq->next = NULL;
3724  n_Power(e, p_GetExp(qq, n, r), &nn,r->cf);
3725  nm = n_Mult(nn, pGetCoeff(qq),r->cf);
3726 #ifdef HAVE_RINGS
3727  if (n_IsZero(nm,r->cf))
3728  {
3729  p_LmFree(&qq,r);
3730  n_Delete(&nm,r->cf);
3731  }
3732  else
3733 #endif
3734  {
3735  p_SetCoeff(qq, nm,r);
3736  p_SetExp(qq, n, 0,r);
3737  p_Setm(qq,r);
3738  result = p_Add_q(result,qq,r);
3739  }
3740  n_Delete(&nn,r->cf);
3741  }
3742  p = p_Add_q(result, zero,r);
3743  p_Test(p,r);
3744  return p;
3745 }
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 number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:407
static void p_LmFree(poly p, ring)
Definition: p_polys.h:678
#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 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 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
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
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:228
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
static void p_SplitAndReversePoly(poly p, int n, poly *non_zero, poly *zero, const ring r)
Definition: p_polys.cc:3645
polyrec * poly
Definition: hilb.h:10
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:883
return result
Definition: facAbsBiFact.cc:76
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
void p_TakeOutComp ( poly r_p,
long  comp,
poly r_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_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 poly p_TwoMonPower ( poly  p,
int  exp,
const ring  r 
)
static

Definition at line 2017 of file p_polys.cc.

2018 {
2019  int eh, e;
2020  long al;
2021  poly *a;
2022  poly tail, b, res, h;
2023  number x;
2024  number *bin = pnBin(exp,r);
2025 
2026  tail = pNext(p);
2027  if (bin == NULL)
2028  {
2029  p_MonPower(p,exp,r);
2030  p_MonPower(tail,exp,r);
2031  p_Test(p,r);
2032  return p;
2033  }
2034  eh = exp >> 1;
2035  al = (exp + 1) * sizeof(poly);
2036  a = (poly *)omAlloc(al);
2037  a[1] = p;
2038  for (e=1; e<exp; e++)
2039  {
2040  a[e+1] = p_MonMultC(a[e],p,r);
2041  }
2042  res = a[exp];
2043  b = p_Head(tail,r);
2044  for (e=exp-1; e>eh; e--)
2045  {
2046  h = a[e];
2047  x = n_Mult(bin[exp-e],pGetCoeff(h),r->cf);
2048  p_SetCoeff(h,x,r);
2049  p_MonMult(h,b,r);
2050  res = pNext(res) = h;
2051  p_MonMult(b,tail,r);
2052  }
2053  for (e=eh; e!=0; e--)
2054  {
2055  h = a[e];
2056  x = n_Mult(bin[e],pGetCoeff(h),r->cf);
2057  p_SetCoeff(h,x,r);
2058  p_MonMult(h,b,r);
2059  res = pNext(res) = h;
2060  p_MonMult(b,tail,r);
2061  }
2062  p_LmDelete(&tail,r);
2063  pNext(res) = b;
2064  pNext(b) = NULL;
2065  res = a[exp];
2066  omFreeSize((ADDRESS)a, al);
2067  pnFreeBin(bin, exp, r->cf);
2068 // tail=res;
2069 // while((tail!=NULL)&&(pNext(tail)!=NULL))
2070 // {
2071 // if(nIsZero(pGetCoeff(pNext(tail))))
2072 // {
2073 // pLmDelete(&pNext(tail));
2074 // }
2075 // else
2076 // pIter(tail);
2077 // }
2078  p_Test(res,r);
2079  return res;
2080 }
static poly p_MonPower(poly p, int exp, const ring r)
Definition: p_polys.cc:1911
const poly a
Definition: syzextra.cc:212
return P p
Definition: myNF.cc:203
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
static void p_MonMult(poly p, poly q, const ring r)
Definition: p_polys.cc:1935
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
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 poly p_MonMultC(poly p, poly q, const ring rr)
Definition: p_polys.cc:1955
static number * pnBin(int exp, const ring r)
Definition: p_polys.cc:1969
#define p_Test(p, r)
Definition: p_polys.h:160
#define NULL
Definition: omList.c:10
Variable x
Definition: cfModGcd.cc:4023
#define pNext(p)
Definition: monomials.h:43
p exp[i]
Definition: DebugPrint.cc:39
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:706
polyrec * poly
Definition: hilb.h:10
static Poly * h
Definition: janet.cc:978
const poly b
Definition: syzextra.cc:213
static void pnFreeBin(number *bin, int exp, const coeffs r)
Definition: p_polys.cc:2000
int p_Var ( poly  m,
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  i,
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,
const 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
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  l,
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
long pLDeg0 ( poly  p,
int *  l,
const 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,
const 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,
const 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,
const 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,
const 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,
const 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,
const 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,
const 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,
const 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,
const 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,
const 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 long pModDeg ( poly  p,
ring  r 
)
static

Definition at line 3519 of file p_polys.cc.

3520 {
3521  long d=pOldFDeg(p, r);
3522  int c=p_GetComp(p, r);
3523  if ((c>0) && ((r->pModW)->range(c-1))) d+= (*(r->pModW))[c-1];
3524  return d;
3525  //return pOldFDeg(p, r)+(*pModW)[p_GetComp(p, r)-1];
3526 }
return P p
Definition: myNF.cc:203
#define p_GetComp(p, r)
Definition: monomials.h:72
const ring r
Definition: syzextra.cc:208
static pFDegProc pOldFDeg
Definition: p_polys.cc:3515
static number* pnBin ( int  exp,
const ring  r 
)
static

Definition at line 1969 of file p_polys.cc.

1970 {
1971  int e, i, h;
1972  number x, y, *bin=NULL;
1973 
1974  x = n_Init(exp,r->cf);
1975  if (n_IsZero(x,r->cf))
1976  {
1977  n_Delete(&x,r->cf);
1978  return bin;
1979  }
1980  h = (exp >> 1) + 1;
1981  bin = (number *)omAlloc0(h*sizeof(number));
1982  bin[1] = x;
1983  if (exp < 4)
1984  return bin;
1985  i = exp - 1;
1986  for (e=2; e<h; e++)
1987  {
1988  x = n_Init(i,r->cf);
1989  i--;
1990  y = n_Mult(x,bin[e-1],r->cf);
1991  n_Delete(&x,r->cf);
1992  x = n_Init(e,r->cf);
1993  bin[e] = n_ExactDiv(y,x,r->cf);
1994  n_Delete(&x,r->cf);
1995  n_Delete(&y,r->cf);
1996  }
1997  return bin;
1998 }
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:57
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 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
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
Variable x
Definition: cfModGcd.cc:4023
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
p exp[i]
Definition: DebugPrint.cc:39
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
static Poly * h
Definition: janet.cc:978
#define omAlloc0(size)
Definition: omAllocDecl.h:211
static void pnFreeBin ( number *  bin,
int  exp,
const coeffs  r 
)
static

Definition at line 2000 of file p_polys.cc.

2001 {
2002  int e, h = (exp >> 1) + 1;
2003 
2004  if (bin[1] != NULL)
2005  {
2006  for (e=1; e<h; e++)
2007  n_Delete(&(bin[e]),r);
2008  }
2009  omFreeSize((ADDRESS)bin, h*sizeof(number));
2010 }
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
void * ADDRESS
Definition: auxiliary.h:161
const ring r
Definition: syzextra.cc:208
#define NULL
Definition: omList.c:10
p exp[i]
Definition: DebugPrint.cc:39
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
static Poly * h
Definition: janet.cc:978
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
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
void pSetDegProcs ( ring  r,
pFDegProc  new_FDeg,
pLDegProc  new_lDeg 
)

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

Variable Documentation

int* _components = NULL
static

Definition at line 151 of file p_polys.cc.

int _componentsExternal = 0
static

Definition at line 153 of file p_polys.cc.

long* _componentsShifted = NULL
static

Definition at line 152 of file p_polys.cc.

pFDegProc pOldFDeg
static

Definition at line 3515 of file p_polys.cc.

pLDegProc pOldLDeg
static

Definition at line 3516 of file p_polys.cc.

BOOLEAN pOldLexOrder
static

Definition at line 3517 of file p_polys.cc.

BOOLEAN pSetm_error =0

Definition at line 155 of file p_polys.cc.