Loading...
Searching...
No Matches
p_polys.cc File Reference
`#include <ctype.h>`
`#include "misc/auxiliary.h"`
`#include "misc/options.h"`
`#include "misc/intvec.h"`
`#include "coeffs/longrat.h"`
`#include "coeffs/numbers.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 "polys/shiftop.h"`
`#include "clapsing.h"`
`#include "polys/templates/p_Delete__T.cc"`

Go to the source code of this file.

## Macros

#define | TRANSEXT_PRIVATES
#define | MYTEST 0
#define | CLEARENUMERATORS 1
#define | LINKAGE
#define | p_Delete__T p_ShallowDelete
#define | n_Delete__T(n, r)

## Functions

poly | p_Farey (poly p, number N, const ring r)
poly | p_ChineseRemainder (poly *xx, number *x, number *q, int rl, CFArray &inv_cache, const ring R)
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 int *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
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
BOOLEAN | p_OneComp (poly p, const ring r)
| return TRUE if all monoms have the same component
int | p_IsPurePower (const poly p, const ring r)
| return i, if head depends only on var(i)
int | p_IsUnivariate (poly p, const ring r)
| return i, if poly depends only on var(i)
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)
poly | p_ISet (long i, const ring r)
| returns the poly representing the integer i
poly | p_One (const ring r)
void | p_Split (poly p, poly *h)
BOOLEAN | p_HasNotCF (poly p1, poly p2, const ring r)
BOOLEAN | p_HasNotCFRing (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
poly | p_MDivide (poly a, poly b, const ring r)
poly | p_Div_nn (poly p, const number n, const ring r)
poly | p_Div_mm (poly p, const poly m, const ring r)
| divide polynomial by monomial
poly | p_DivideM (poly a, poly b, const ring r)
poly | pp_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
void | p_Lcm (const poly a, const poly b, poly m, const ring r)
poly | p_Lcm (const poly a, const poly b, const ring r)
poly | p_LcmRat (const poly a, const poly b, const long lCompM, const ring r)
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:
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)
void | p_Content (poly ph, const ring r)
void | p_ContentForGB (poly ph, const ring r)
void | p_SimpleContent (poly ph, int smax, const ring r)
number | p_InitContent (poly ph, 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)
poly | p_HomogenDP (poly p, int varnum, const ring r)
BOOLEAN | p_IsHomogeneous (poly p, const ring r)
BOOLEAN | p_IsHomogeneousDP (poly p, const ring r)
BOOLEAN | p_IsHomogeneousW (poly p, const intvec *w, const ring r)
BOOLEAN | p_IsHomogeneousW (poly p, const intvec *w, const intvec *module_w, const ring r)
BOOLEAN | p_VectorHasUnitB (poly p, int *k, const ring r)
void | p_VectorHasUnit (poly p, int *k, int *len, 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)
| Splits *p into two polys: *q which consists of all monoms with component == comp and *p of all other monoms *lq == pLength(*q) On return all components pf *q == 0.
void | p_DeleteComp (poly *p, int k, const ring r)
poly | p_Vec2Poly (poly v, int k, const ring r)
void | p_Vec2Array (poly v, poly *p, int len, const ring r)
| vector to already allocated array (len>=p_MaxComp(v,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 | pp_Jet0 (poly p, const ring R)
poly | p_Jet (poly p, int m, const ring R)
poly | pp_JetW (poly p, int m, int *w, const ring R)
poly | p_JetW (poly p, int m, int *w, const ring R)
int | p_MinDeg (poly p, intvec *w, const ring R)
static poly | p_Invers (int n, poly u, intvec *w, const ring R)
poly | p_Series (int n, poly p, 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
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
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
void | p_Shift (poly *p, int i, const ring r)
| shifts components of the vector p by i
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_GetShortExpVector0 (const poly p, const ring r)
unsigned long | p_GetShortExpVector1 (const poly p, const ring r)
int | p_Compare (const poly a, const poly b, const ring R)
poly | p_GcdMon (poly f, poly g, const ring r)
| polynomial gcd for f=mon
poly | p_CopyPowerProduct0 (const poly p, number n, const ring r)
| like p_Head, but with coefficient n
poly | p_CopyPowerProduct (const poly p, const ring r)
| like p_Head, but with coefficient 1
poly | p_Head0 (const poly p, const ring r)
| like p_Head, but allow NULL coeff
int | p_MaxExpPerVar (poly p, int i, const ring r)
| max exponent of variable x_i in p

## Variables

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

## Macro Definition Documentation

## CLEARENUMERATORS

#define CLEARENUMERATORS 1

Definition at line 2401 of file p_polys.cc.

## LINKAGE

#define LINKAGE

Definition at line 5038 of file p_polys.cc.

## MYTEST

#define MYTEST 0

Definition at line 155 of file p_polys.cc.

## n_Delete__T

#define n_Delete__T | ( |  | n,
|  |  | r )

Value:
do {} while (0)

Definition at line 5042 of file p_polys.cc.

## p_Delete__T

#define p_Delete__T p_ShallowDelete

Definition at line 5040 of file p_polys.cc.

## TRANSEXT_PRIVATES

#define TRANSEXT_PRIVATES

Definition at line 24 of file p_polys.cc.

## Function Documentation

## GetBitFields()

unsigned long GetBitFields | ( | const long | e,
|  | const unsigned int | s,
|  | const unsigned int | n )

inline static

Definition at line 4902 of file p_polys.cc.

{
unsigned int i = 0;
unsigned long ev = 0L;
assume(n > 0 && s < BIT_SIZEOF_LONG);
do
{
assume(s+i < BIT_SIZEOF_LONG);
if (e > (long) i) ev |= Sy_bitL(s+i);
else break;
i++;
}
while (i < n);
return ev;
}
BIT_SIZEOF_LONG
#define BIT_SIZEOF_LONG
Definition auxiliary.h:80
i
int i
Definition cfEzgcd.cc:132
s
const CanonicalForm int s
Definition facAbsFact.cc:51
assume
#define assume(x)
Definition mod2.h:389
Sy_bitL
#define Sy_bitL(x)
Definition options.h:32

## n_PermNumber()

poly n_PermNumber | ( | const number | z,
|  | const int * | par_perm,
|  | const int | OldPar,
|  | const ring | src,
|  | const ring | dst )

Definition at line 4153 of file p_polys.cc.

{
#if 0
PrintS("\nSource Ring: \n");
rWrite(src);
if(0)
{
number zz = n_Copy(z, src->cf);
PrintS("z: "); n_Write(zz, src);
n_Delete(&zz, src->cf);
}
PrintS("\nDestination Ring: \n");
rWrite(dst);
/*Print("\nOldPar: %d\n", OldPar);
for( int i = 1; i <= OldPar; i++ )
{
Print("par(%d) -> par/var (%d)\n", i, par_perm[i-1]);
}*/
#endif
if( z == NULL )
return NULL;
const coeffs srcCf = src->cf;
assume( srcCf != NULL );
assume( !nCoeff_is_GF(srcCf) );
assume( src->cf->extRing!=NULL );
poly zz = NULL;
const ring srcExtRing = srcCf->extRing;
assume( srcExtRing != NULL );
const coeffs dstCf = dst->cf;
assume( dstCf != NULL );
if( nCoeff_is_algExt(srcCf) ) // nCoeff_is_GF(srcCf)?
{
zz = (poly) z;
if( zz == NULL ) return NULL;
}
else if (nCoeff_is_transExt(srcCf))
{
assume( !IS0(z) );
zz = NUM((fraction)z);
p_Test (zz, srcExtRing);
if( zz == NULL ) return NULL;
if( !DENIS1((fraction)z) )
{
if (!p_IsConstant(DEN((fraction)z),srcExtRing))
WarnS("Not defined: Cannot map a rational fraction and make a polynomial out of it! Ignoring the denominator.");
}
}
else
{
assume (FALSE);
WerrorS("Number permutation is not implemented for this data yet!");
return NULL;
}
assume( zz != NULL );
p_Test (zz, srcExtRing);
nMapFunc nMap = n_SetMap(srcExtRing->cf, dstCf);
assume( nMap != NULL );
poly qq;
if ((par_perm == NULL) && (rPar(dst) != 0 && rVar (srcExtRing) > 0))
{
int* perm;
perm=(int *)omAlloc0((rVar(srcExtRing)+1)*sizeof(int));
for(int i=si_min(rVar(srcExtRing),rPar(dst));i>0;i--)
perm[i]=-i;
qq = p_PermPoly(zz, perm, srcExtRing, dst, nMap, NULL, rVar(srcExtRing)-1);
omFreeSize ((ADDRESS)perm, (rVar(srcExtRing)+1)*sizeof(int));
}
else
qq = p_PermPoly(zz, par_perm-1, srcExtRing, dst, nMap, NULL, rVar (srcExtRing)-1);
if(nCoeff_is_transExt(srcCf)
&& (!DENIS1((fraction)z))
&& p_IsConstant(DEN((fraction)z),srcExtRing))
{
number n=nMap(pGetCoeff(DEN((fraction)z)),srcExtRing->cf, dstCf);
qq=p_Div_nn(qq,n,dst);
n_Delete(&n,dstCf);
p_Normalize(qq,dst);
}
p_Test (qq, dst);
return qq;
}
FALSE
#define FALSE
Definition auxiliary.h:97
ADDRESS
void * ADDRESS
Definition auxiliary.h:120
si_min
static int si_min(const int a, const int b)
Definition auxiliary.h:126
n_Copy
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
Definition coeffs.h:457
nCoeff_is_GF
static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
Definition coeffs.h:834
n_SetMap
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
Definition coeffs.h:703
n_Delete
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition coeffs.h:461
n_Write
static FORCE_INLINE void n_Write(number n, const coeffs r, const BOOLEAN bShortOut=TRUE)
Definition coeffs.h:594
nCoeff_is_algExt
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
Definition coeffs.h:905
nMapFunc
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition coeffs.h:80
nCoeff_is_transExt
static FORCE_INLINE BOOLEAN nCoeff_is_transExt(const coeffs r)
TRUE iff r represents a transcendental extension field.
Definition coeffs.h:913
WarnS
#define WarnS
Definition emacs.cc:78
WerrorS
void WerrorS(const char *s)
Definition feFopen.cc:24
pGetCoeff
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition monomials.h:44
coeffs
The main handler for Singular numbers which are suitable for Singular polynomials.
omFreeSize
#define omFreeSize(addr, size)
Definition omAllocDecl.h:260
omAlloc0
#define omAlloc0(size)
Definition omAllocDecl.h:211
NULL
#define NULL
Definition omList.c:12
p_PermPoly
poly p_PermPoly(poly p, const int *perm, const ring oldRing, const ring dst, nMapFunc nMap, const int *par_perm, int OldPar, BOOLEAN use_mult)
Definition p_polys.cc:4256
p_Div_nn
poly p_Div_nn(poly p, const number n, const ring r)
Definition p_polys.cc:1506
p_Normalize
void p_Normalize(poly p, const ring r)
Definition p_polys.cc:3939
p_IsConstant
static BOOLEAN p_IsConstant(const poly p, const ring r)
Definition p_polys.h:1985
p_Test
#define p_Test(p, r)
Definition p_polys.h:161
NUM
#define NUM
Definition readcf.cc:180
PrintS
void PrintS(const char *s)
Definition reporter.cc:288
rWrite
void rWrite(ring r, BOOLEAN details)
Definition ring.cc:227
rPar
static int rPar(const ring r)
(r->cf->P)
Definition ring.h:605
rVar
static short rVar(const ring r)
define rVar(r) (r->N)
Definition ring.h:598

## p_ChineseRemainder()

poly p_ChineseRemainder | ( | poly * | xx,
|  | number * | x,
|  | number * | q,
|  | int | rl,
|  | CFArray & | inv_cache,
|  | const ring | R )

Definition at line 88 of file p_polys.cc.

{
poly r,h,hh;
int j;
poly res_p=NULL;
loop
{
/* search the lead term */
r=NULL;
for(j=rl-1;j>=0;j--)
{
h=xx[j];
if ((h!=NULL)
&&((r==NULL)||(p_LmCmp(r,h,R)==-1)))
r=h;
}
/* nothing found -> return */
if (r==NULL) break;
/* create the monomial in h */
h=p_Head(r,R);
/* collect the coeffs in x[..]*/
for(j=rl-1;j>=0;j--)
{
hh=xx[j];
if ((hh!=NULL) && (p_LmCmp(h,hh,R)==0))
{
x[j]=pGetCoeff(hh);
hh=p_LmFreeAndNext(hh,R);
xx[j]=hh;
}
else
x[j]=n_Init(0, R->cf);
}
number n=n_ChineseRemainderSym(x,q,rl,TRUE,inv_cache,R->cf);
for(j=rl-1;j>=0;j--)
{
x[j]=NULL; // n_Init(0...) takes no memory
}
if (n_IsZero(n,R->cf)) p_Delete(&h,R);
else
{
//Print("new mon:");pWrite(h);
p_SetCoeff(h,n,R);
pNext(h)=res_p;
res_p=h; // building res_p in reverse order!
}
}
res_p=pReverse(res_p);
p_Test(res_p, R);
return res_p;
}
TRUE
#define TRUE
Definition auxiliary.h:101
x
Variable x
Definition cfModGcd.cc:4090
n_IsZero
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
Definition coeffs.h:470
n_ChineseRemainderSym
static FORCE_INLINE number n_ChineseRemainderSym(number *a, number *b, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs r)
Definition coeffs.h:759
n_Init
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition coeffs.h:541
j
int j
Definition facHensel.cc:110
h
STATIC_VAR Poly * h
Definition janet.cc:971
pNext
#define pNext(p)
Definition monomials.h:36
p_SetCoeff
static number p_SetCoeff(poly p, number n, ring r)
Definition p_polys.h:414
pReverse
static poly pReverse(poly p)
Definition p_polys.h:337
p_Head
static poly p_Head(const poly p, const ring r)
copy the (leading) term of p
Definition p_polys.h:862
p_LmCmp
static int p_LmCmp(poly p, poly q, const ring r)
Definition p_polys.h:1601
p_Delete
static void p_Delete(poly *p, const ring r)
Definition p_polys.h:903
p_LmFreeAndNext
static poly p_LmFreeAndNext(poly p, ring)
Definition p_polys.h:713
R
#define R
Definition sirandom.c:27
loop
#define loop
Definition structs.h:71

## p_Cleardenom()

poly p_Cleardenom | ( | poly | p,
|  | const ring | r )

Definition at line 2893 of file p_polys.cc.

{
if( p == NULL )
return NULL;
assume( r != NULL );
assume( r->cf != NULL );
const coeffs C = r->cf;
#if CLEARENUMERATORS
if( 0 )
{
CPolyCoeffsEnumerator itr(p);
n_ClearDenominators(itr, C);
n_ClearContent(itr, C); // divide out the content
p_Test(p, r); n_Test(pGetCoeff(p), C);
assume(n_GreaterZero(pGetCoeff(p), C)); // ??
// if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
return p;
}
#endif
number d, h;
if (rField_is_Ring(r))
{
if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
return p;
}
if (rField_is_Zp(r) && TEST_OPT_INTSTRATEGY)
{
if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
return p;
}
assume(p != NULL);
if(pNext(p)==NULL)
{
if (!TEST_OPT_CONTENTSB)
p_SetCoeff(p,n_Init(1,C),r);
else if(!n_GreaterZero(pGetCoeff(p),C))
p = p_Neg(p,r);
return p;
}
assume(pNext(p)!=NULL);
poly start=p;
#if 0 && CLEARENUMERATORS
//CF: does not seem to work that well..
if( nCoeff_is_Q(C) || nCoeff_is_Q_a(C) )
{
CPolyCoeffsEnumerator itr(p);
n_ClearDenominators(itr, C);
n_ClearContent(itr, C); // divide out the content
p_Test(p, r); n_Test(pGetCoeff(p), C);
assume(n_GreaterZero(pGetCoeff(p), C)); // ??
// if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
return start;
}
#endif
if(1)
{
// get lcm of all denominators ----------------------------------
h = n_Init(1,C);
while (p!=NULL)
{
n_Normalize(pGetCoeff(p),C);
d=n_NormalizeHelper(h,pGetCoeff(p),C);
n_Delete(&h,C);
h=d;
pIter(p);
}
/* h now contains the 1/lcm of all denominators */
if(!n_IsOne(h,C))
{
// multiply by the lcm of all denominators
p = start;
while (p!=NULL)
{
d=n_Mult(h,pGetCoeff(p),C);
n_Normalize(d,C);
p_SetCoeff(p,d,r);
pIter(p);
}
}
n_Delete(&h,C);
p=start;
p_ContentForGB(p,r);
#ifdef HAVE_RATGRING
if (rIsRatGRing(r))
{
/* quick unit detection in the rational case is done in gr_nc_bba */
p_ContentRat(p, r);
start=p;
}
#endif
}
if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
return start;
}
p
int p
Definition cfModGcd.cc:4086
CPolyCoeffsEnumerator
This is a polynomial enumerator for simple iteration over coefficients of polynomials.
Definition PolyEnumerator.h:130
n_Mult
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of 'a' and 'b', i.e., a*b
Definition coeffs.h:639
n_NormalizeHelper
static FORCE_INLINE number n_NormalizeHelper(number a, number b, const coeffs r)
assume that r is a quotient field (otherwise, return 1) for arguments (a1/a2,b1/b2) return (lcm(a1,...
Definition coeffs.h:698
n_Test
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r).
Definition coeffs.h:715
n_GreaterZero
static FORCE_INLINE BOOLEAN n_GreaterZero(number n, const coeffs r)
ordered fields: TRUE iff 'n' is positive; in Z/pZ: TRUE iff 0 < m <= roundedBelow(p/2),...
Definition coeffs.h:500
nCoeff_is_Q
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
Definition coeffs.h:801
n_ClearDenominators
static FORCE_INLINE void n_ClearDenominators(ICoeffsEnumerator &numberCollectionEnumerator, number &d, const coeffs r)
(inplace) Clears denominators on a collection of numbers number d is the LCM of all the coefficient d...
Definition coeffs.h:934
nCoeff_is_Q_a
static FORCE_INLINE BOOLEAN nCoeff_is_Q_a(const coeffs r)
Definition coeffs.h:880
n_ClearContent
static FORCE_INLINE void n_ClearContent(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs r)
Computes the content and (inplace) divides it out on a collection of numbers number c is the content ...
Definition coeffs.h:927
n_Normalize
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition coeffs.h:581
n_IsOne
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition coeffs.h:474
pIter
#define pIter(p)
Definition monomials.h:37
TEST_OPT_INTSTRATEGY
#define TEST_OPT_INTSTRATEGY
Definition options.h:112
TEST_OPT_CONTENTSB
#define TEST_OPT_CONTENTSB
Definition options.h:129
p_ContentRat
void p_ContentRat(poly &ph, const ring r)
Definition p_polys.cc:1748
p_ContentForGB
void p_ContentForGB(poly ph, const ring r)
Definition p_polys.cc:2403
p_Neg
static poly p_Neg(poly p, const ring r)
Definition p_polys.h:1114
rField_is_Zp
static BOOLEAN rField_is_Zp(const ring r)
Definition ring.h:506
rIsRatGRing
static BOOLEAN rIsRatGRing(const ring r)
Definition ring.h:433
rField_is_Ring
#define rField_is_Ring(R)
Definition ring.h:491

## p_Cleardenom_n()

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

Definition at line 3002 of file p_polys.cc.

{
const coeffs C = r->cf;
number d, h;
assume( ph != NULL );
poly p = ph;
#if CLEARENUMERATORS
if( 0 )
{
CPolyCoeffsEnumerator itr(ph);
n_ClearDenominators(itr, d, C); // multiply with common denom. d
n_ClearContent(itr, h, C); // divide by the content h
c = n_Div(d, h, C); // d/h
n_Delete(&d, C);
n_Delete(&h, C);
n_Test(c, C);
p_Test(ph, r); n_Test(pGetCoeff(ph), C);
assume(n_GreaterZero(pGetCoeff(ph), C)); // ??
/*
if(!n_GreaterZero(pGetCoeff(ph),C))
{
ph = p_Neg(ph,r);
c = n_InpNeg(c, C);
}
*/
return;
}
#endif
if( pNext(p) == NULL )
{
if(!TEST_OPT_CONTENTSB)
{
c=n_Invers(pGetCoeff(p), C);
p_SetCoeff(p, n_Init(1, C), r);
}
else
{
c=n_Init(1,C);
}
if(!n_GreaterZero(pGetCoeff(ph),C))
{
ph = p_Neg(ph,r);
c = n_InpNeg(c, C);
}
return;
}
if (TEST_OPT_CONTENTSB) { c=n_Init(1,C); return; }
assume( pNext(p) != NULL );
#if CLEARENUMERATORS
if( nCoeff_is_Q(C) || nCoeff_is_Q_a(C) )
{
CPolyCoeffsEnumerator itr(ph);
n_ClearDenominators(itr, d, C); // multiply with common denom. d
n_ClearContent(itr, h, C); // divide by the content h
c = n_Div(d, h, C); // d/h
n_Delete(&d, C);
n_Delete(&h, C);
n_Test(c, C);
p_Test(ph, r); n_Test(pGetCoeff(ph), C);
assume(n_GreaterZero(pGetCoeff(ph), C)); // ??
/*
if(!n_GreaterZero(pGetCoeff(ph),C))
{
ph = p_Neg(ph,r);
c = n_InpNeg(c, C);
}
*/
return;
}
#endif
if(1)
{
h = n_Init(1,C);
while (p!=NULL)
{
n_Normalize(pGetCoeff(p),C);
d=n_NormalizeHelper(h,pGetCoeff(p),C);
n_Delete(&h,C);
h=d;
pIter(p);
}
c=h;
/* contains the 1/lcm of all denominators */
if(!n_IsOne(h,C))
{
p = ph;
while (p!=NULL)
{
/* should be: // NOTE: don't use ->coef!!!!
* number hh;
* nGetDenom(p->coef,&hh);
* nMult(&h,&hh,&d);
* nNormalize(d);
* nDelete(&hh);
* nMult(d,p->coef,&hh);
* nDelete(&d);
* nDelete(&(p->coef));
* p->coef =hh;
*/
d=n_Mult(h,pGetCoeff(p),C);
n_Normalize(d,C);
p_SetCoeff(p,d,r);
pIter(p);
}
if (rField_is_Q_a(r))
{
loop
{
h = n_Init(1,C);
p=ph;
while (p!=NULL)
{
d=n_NormalizeHelper(h,pGetCoeff(p),C);
n_Delete(&h,C);
h=d;
pIter(p);
}
/* contains the 1/lcm of all denominators */
if(!n_IsOne(h,C))
{
p = ph;
while (p!=NULL)
{
/* should be: // NOTE: don't use ->coef!!!!
* number hh;
* nGetDenom(p->coef,&hh);
* nMult(&h,&hh,&d);
* nNormalize(d);
* nDelete(&hh);
* nMult(d,p->coef,&hh);
* nDelete(&d);
* nDelete(&(p->coef));
* p->coef =hh;
*/
d=n_Mult(h,pGetCoeff(p),C);
n_Normalize(d,C);
p_SetCoeff(p,d,r);
pIter(p);
}
number t=n_Mult(c,h,C);
n_Delete(&c,C);
c=t;
}
else
{
break;
}
n_Delete(&h,C);
}
}
}
}
if(!n_GreaterZero(pGetCoeff(ph),C))
{
ph = p_Neg(ph,r);
c = n_InpNeg(c, C);
}
}
n_Invers
static FORCE_INLINE number n_Invers(number a, const coeffs r)
return the multiplicative inverse of 'a'; raise an error if 'a' is not invertible
Definition coeffs.h:567
n_InpNeg
static FORCE_INLINE number n_InpNeg(number n, const coeffs r)
in-place negation of n MUST BE USED: n = n_InpNeg(n) (no copy is returned)
Definition coeffs.h:560
n_Div
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of 'a' and 'b', i.e., a/b; raises an error if 'b' is not invertible in r exceptio...
Definition coeffs.h:618
rField_is_Q_a
static BOOLEAN rField_is_Q_a(const ring r)
Definition ring.h:545

## p_Compare()

int p_Compare | ( | const poly | a,
|  | const poly | b,
|  | const ring | R )

Definition at line 5050 of file p_polys.cc.

{
int r=p_Cmp(a,b,R);
if ((r==0)&&(a!=NULL))
{
number h=n_Sub(pGetCoeff(a),pGetCoeff(b),R->cf);
/* compare lead coeffs */
r = -1+n_IsZero(h,R->cf)+2*n_GreaterZero(h,R->cf); /* -1: <, 0:==, 1: > */
n_Delete(&h,R->cf);
}
else if (a==NULL)
{
if (b==NULL)
{
/* compare 0, 0 */
r=0;
}
else if(p_IsConstant(b,R))
{
/* compare 0, const */
r = 1-2*n_GreaterZero(pGetCoeff(b),R->cf); /* -1: <, 1: > */
}
}
else if (b==NULL)
{
if (p_IsConstant(a,R))
{
/* compare const, 0 */
r = -1+2*n_GreaterZero(pGetCoeff(a),R->cf); /* -1: <, 1: > */
}
}
return(r);
}
b
CanonicalForm b
Definition cfModGcd.cc:4111
n_Sub
static FORCE_INLINE number n_Sub(number a, number b, const coeffs r)
return the difference of 'a' and 'b', i.e., a-b
Definition coeffs.h:658
p_Cmp
static int p_Cmp(poly p1, poly p2, ring r)
Definition p_polys.h:1748

## p_ComparePolys()

BOOLEAN p_ComparePolys | ( | poly | p1,
|  | poly | p2,
|  | const ring | r )

returns TRUE if p1 is a skalar multiple of p2 assume p1 != NULL and p2 != NULL

Definition at line 4730 of file p_polys.cc.

{
number n,nn;
pAssume(p1 != NULL && p2 != NULL);
if (!p_LmEqual(p1,p2,r)) //compare leading mons
return FALSE;
if ((pNext(p1)==NULL) && (pNext(p2)!=NULL))
return FALSE;
if ((pNext(p2)==NULL) && (pNext(p1)!=NULL))
return FALSE;
if (pLength(p1) != pLength(p2))
return FALSE;
#ifdef HAVE_RINGS
if (rField_is_Ring(r))
{
if (!n_DivBy(pGetCoeff(p1), pGetCoeff(p2), r->cf)) return FALSE;
}
#endif
n=n_Div(pGetCoeff(p1),pGetCoeff(p2),r->cf);
while ((p1 != NULL) /*&& (p2 != NULL)*/)
{
if ( ! p_LmEqual(p1, p2,r))
{
n_Delete(&n, r->cf);
return FALSE;
}
if (!n_Equal(pGetCoeff(p1), nn = n_Mult(pGetCoeff(p2),n, r->cf), r->cf))
{
n_Delete(&n, r->cf);
n_Delete(&nn, r->cf);
return FALSE;
}
n_Delete(&nn, r->cf);
pIter(p1);
pIter(p2);
}
n_Delete(&n, r->cf);
return TRUE;
}
n_DivBy
static FORCE_INLINE BOOLEAN n_DivBy(number a, number b, const coeffs r)
test whether 'a' is divisible 'b'; for r encoding a field: TRUE iff 'b' does not represent zero in Z:...
Definition coeffs.h:750
n_Equal
static FORCE_INLINE BOOLEAN n_Equal(number a, number b, const coeffs r)
TRUE iff 'a' and 'b' represent the same number; they may have different representations.
Definition coeffs.h:466
pAssume
#define pAssume(cond)
Definition monomials.h:90
pLength
static int pLength(poly a)
Definition p_polys.h:190
p_LmEqual
#define p_LmEqual(p1, p2, r)
Definition p_polys.h:1744

## p_Content()

void p_Content | ( | poly | ph,
|  | const ring | r )

Definition at line 2343 of file p_polys.cc.

{
if (ph==NULL) return;
const coeffs cf=r->cf;
if (pNext(ph)==NULL)
{
p_SetCoeff(ph,n_Init(1,cf),r);
return;
}
if ((cf->cfSubringGcd==ndGcd)
|| (cf->cfGcd==ndGcd)) /* trivial gcd*/
return;
number h;
if ((rField_is_Q(r))
|| (rField_is_Q_a(r))
|| (rField_is_Zp_a)(r)
|| (rField_is_Z(r))
)
{
h=p_InitContent(ph,r); /* first guess of a gcd of all coeffs */
}
else
{
h=n_Copy(pGetCoeff(ph),cf);
}
poly p;
if(n_IsOne(h,cf))
{
goto content_finish;
}
p=ph;
// take the SubringGcd of all coeffs
while (p!=NULL)
{
n_Normalize(pGetCoeff(p),cf);
number d=n_SubringGcd(h,pGetCoeff(p),cf);
n_Delete(&h,cf);
h = d;
if(n_IsOne(h,cf))
{
goto content_finish;
}
pIter(p);
}
// if found<>1, divide by it
p = ph;
while (p!=NULL)
{
number d = n_ExactDiv(pGetCoeff(p),h,cf);
p_SetCoeff(p,d,r);
pIter(p);
}
content_finish:
n_Delete(&h,r->cf);
// and last: check leading sign:
if(!n_GreaterZero(pGetCoeff(ph),r->cf)) ph = p_Neg(ph,r);
}
cf
CanonicalForm cf
Definition cfModGcd.cc:4091
n_ExactDiv
static FORCE_INLINE number n_ExactDiv(number a, number b, const coeffs r)
assume that there is a canonical subring in cf and we know that division is possible for these a and ...
Definition coeffs.h:625
n_SubringGcd
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
Definition coeffs.h:669
ndGcd
number ndGcd(number, number, const coeffs r)
Definition numbers.cc:193
p_InitContent
number p_InitContent(poly ph, const ring r)
Definition p_polys.cc:2683
rField_is_Zp_a
static BOOLEAN rField_is_Zp_a(const ring r)
Definition ring.h:535
rField_is_Z
static BOOLEAN rField_is_Z(const ring r)
Definition ring.h:515
rField_is_Q
static BOOLEAN rField_is_Q(const ring r)
Definition ring.h:512

## p_ContentForGB()

void p_ContentForGB | ( | poly | ph,
|  | const ring | r )

Definition at line 2403 of file p_polys.cc.

{
if(TEST_OPT_CONTENTSB) return;
assume( ph != NULL );
assume( r != NULL ); assume( r->cf != NULL );
#if CLEARENUMERATORS
if( 0 )
{
const coeffs C = r->cf;
// experimentall (recursive enumerator treatment) of alg. Ext!
CPolyCoeffsEnumerator itr(ph);
n_ClearContent(itr, r->cf);
p_Test(ph, r); n_Test(pGetCoeff(ph), C);
assume(n_GreaterZero(pGetCoeff(ph), C)); // ??
// if(!n_GreaterZero(pGetCoeff(ph),r->cf)) ph = p_Neg(ph,r);
return;
}
#endif
#ifdef HAVE_RINGS
if (rField_is_Ring(r))
{
if (rField_has_Units(r))
{
number k = n_GetUnit(pGetCoeff(ph),r->cf);
if (!n_IsOne(k,r->cf))
{
number tmpGMP = k;
k = n_Invers(k,r->cf);
n_Delete(&tmpGMP,r->cf);
poly h = pNext(ph);
p_SetCoeff(ph, n_Mult(pGetCoeff(ph), k,r->cf),r);
while (h != NULL)
{
p_SetCoeff(h, n_Mult(pGetCoeff(h), k,r->cf),r);
pIter(h);
}
// assume( n_GreaterZero(pGetCoeff(ph),r->cf) );
// if(!n_GreaterZero(pGetCoeff(ph),r->cf)) ph = p_Neg(ph,r);
}
n_Delete(&k,r->cf);
}
return;
}
#endif
number h,d;
poly p;
if(pNext(ph)==NULL)
{
p_SetCoeff(ph,n_Init(1,r->cf),r);
}
else
{
assume( pNext(ph) != NULL );
#if CLEARENUMERATORS
if( nCoeff_is_Q(r->cf) )
{
// experimentall (recursive enumerator treatment) of alg. Ext!
CPolyCoeffsEnumerator itr(ph);
n_ClearContent(itr, r->cf);
p_Test(ph, r); n_Test(pGetCoeff(ph), r->cf);
assume(n_GreaterZero(pGetCoeff(ph), r->cf)); // ??
// if(!n_GreaterZero(pGetCoeff(ph),r->cf)) ph = p_Neg(ph,r);
return;
}
#endif
n_Normalize(pGetCoeff(ph),r->cf);
if(!n_GreaterZero(pGetCoeff(ph),r->cf)) ph = p_Neg(ph,r);
if (rField_is_Q(r)||(getCoeffType(r->cf)==n_transExt)) // should not be used anymore if CLEARENUMERATORS is 1
{
h=p_InitContent(ph,r);
p=ph;
}
else
{
h=n_Copy(pGetCoeff(ph),r->cf);
p = pNext(ph);
}
while (p!=NULL)
{
n_Normalize(pGetCoeff(p),r->cf);
d=n_SubringGcd(h,pGetCoeff(p),r->cf);
n_Delete(&h,r->cf);
h = d;
if(n_IsOne(h,r->cf))
{
break;
}
pIter(p);
}
//number tmp;
if(!n_IsOne(h,r->cf))
{
p = ph;
while (p!=NULL)
{
//d = nDiv(pGetCoeff(p),h);
//tmp = nExactDiv(pGetCoeff(p),h);
//if (!nEqual(d,tmp))
//{
// StringSetS("** div0:");nWrite(pGetCoeff(p));StringAppendS("/");
// nWrite(h);StringAppendS("=");nWrite(d);StringAppendS(" int:");
// nWrite(tmp);Print(StringEndS("\n")); // NOTE/TODO: use StringAppendS("\n"); omFree(s);
//}
//nDelete(&tmp);
d = n_ExactDiv(pGetCoeff(p),h,r->cf);
p_SetCoeff(p,d,r);
pIter(p);
}
}
n_Delete(&h,r->cf);
if (rField_is_Q_a(r))
{
// special handling for alg. ext.:
if (getCoeffType(r->cf)==n_algExt)
{
h = n_Init(1, r->cf->extRing->cf);
p=ph;
while (p!=NULL)
{ // each monom: coeff in Q_a
poly c_n_n=(poly)pGetCoeff(p);
poly c_n=c_n_n;
while (c_n!=NULL)
{ // each monom: coeff in Q
d=n_NormalizeHelper(h,pGetCoeff(c_n),r->cf->extRing->cf);
n_Delete(&h,r->cf->extRing->cf);
h=d;
pIter(c_n);
}
pIter(p);
}
/* h contains the 1/lcm of all denominators in c_n_n*/
//n_Normalize(h,r->cf->extRing->cf);
if(!n_IsOne(h,r->cf->extRing->cf))
{
p=ph;
while (p!=NULL)
{ // each monom: coeff in Q_a
poly c_n=(poly)pGetCoeff(p);
while (c_n!=NULL)
{ // each monom: coeff in Q
d=n_Mult(h,pGetCoeff(c_n),r->cf->extRing->cf);
n_Normalize(d,r->cf->extRing->cf);
n_Delete(&pGetCoeff(c_n),r->cf->extRing->cf);
pGetCoeff(c_n)=d;
pIter(c_n);
}
pIter(p);
}
}
n_Delete(&h,r->cf->extRing->cf);
}
/*else
{
// special handling for rat. functions.:
number hzz =NULL;
p=ph;
while (p!=NULL)
{ // each monom: coeff in Q_a (Z_a)
fraction f=(fraction)pGetCoeff(p);
poly c_n=NUM(f);
if (hzz==NULL)
{
hzz=n_Copy(pGetCoeff(c_n),r->cf->extRing->cf);
pIter(c_n);
}
while ((c_n!=NULL)&&(!n_IsOne(hzz,r->cf->extRing->cf)))
{ // each monom: coeff in Q (Z)
d=n_Gcd(hzz,pGetCoeff(c_n),r->cf->extRing->cf);
n_Delete(&hzz,r->cf->extRing->cf);
hzz=d;
pIter(c_n);
}
pIter(p);
}
// hzz contains the gcd of all numerators in f
h=n_Invers(hzz,r->cf->extRing->cf);
n_Delete(&hzz,r->cf->extRing->cf);
n_Normalize(h,r->cf->extRing->cf);
if(!n_IsOne(h,r->cf->extRing->cf))
{
p=ph;
while (p!=NULL)
{ // each monom: coeff in Q_a (Z_a)
fraction f=(fraction)pGetCoeff(p);
NUM(f)=__p_Mult_nn(NUM(f),h,r->cf->extRing);
p_Normalize(NUM(f),r->cf->extRing);
pIter(p);
}
}
n_Delete(&h,r->cf->extRing->cf);
}*/
}
}
if(!n_GreaterZero(pGetCoeff(ph),r->cf)) ph = p_Neg(ph,r);
}
k
int k
Definition cfEzgcd.cc:99
n_algExt
@ n_algExt
used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic
Definition coeffs.h:35
n_transExt
@ n_transExt
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
Definition coeffs.h:38
n_GetUnit
static FORCE_INLINE number n_GetUnit(number n, const coeffs r)
in Z: 1 in Z/kZ (where k is not a prime): largest divisor of n (taken in Z) that is co-prime with k i...
Definition coeffs.h:537
getCoeffType
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition coeffs.h:431
rField_has_Units
static BOOLEAN rField_has_Units(const ring r)
Definition ring.h:496

## p_ContentRat()

void p_ContentRat | ( | poly & | ph,
|  | const ring | r )

Definition at line 1748 of file p_polys.cc.

{
// init array of RatLeadCoeffs
// poly p_GetCoeffRat(poly p, int ishift, ring r);
int len=pLength(ph);
poly *C = (poly *)omAlloc0((len+1)*sizeof(poly)); //rat coeffs
poly *LM = (poly *)omAlloc0((len+1)*sizeof(poly)); // rat lead terms
int *D = (int *)omAlloc0((len+1)*sizeof(int)); //degrees of coeffs
int *L = (int *)omAlloc0((len+1)*sizeof(int)); //lengths of coeffs
int k = 0;
poly p = p_Copy(ph, r); // ph will be needed below
int mintdeg = p_Totaldegree(p, r);
int minlen = len;
int dd = 0; int i;
int HasConstantCoef = 0;
int is = r->real_var_start - 1;
while (p!=NULL)
{
LM[k] = p_GetExp_k_n(p,1,is, r); // need LmRat instead of p_HeadRat(p, is, currRing); !
C[k] = p_GetCoeffRat(p, is, r);
D[k] = p_Totaldegree(C[k], r);
mintdeg = si_min(mintdeg,D[k]);
L[k] = pLength(C[k]);
minlen = si_min(minlen,L[k]);
if (p_IsConstant(C[k], r))
{
// C[k] = const, so the content will be numerical
HasConstantCoef = 1;
// smth like goto cleanup and return(pContent(p));
}
p_LmDeleteAndNextRat(&p, is, r);
k++;
}
// look for 1 element of minimal degree and of minimal length
k--;
poly d;
int mindeglen = len;
if (k<=0) // this poly is not a ratgring poly -> pContent
{
p_Delete(&C[0], r);
p_Delete(&LM[0], r);
p_ContentForGB(ph, r);
goto cleanup;
}
int pmindeglen;
for(i=0; i<=k; i++)
{
if (D[i] == mintdeg)
{
if (L[i] < mindeglen)
{
mindeglen=L[i];
pmindeglen = i;
}
}
}
d = p_Copy(C[pmindeglen], r);
// there are dd>=1 mindeg elements
// and pmideglen is the coordinate of one of the smallest among them
// poly g = singclap_gcd(p_Copy(p,r),p_Copy(q,r));
// return naGcd(d,d2,currRing);
// adjoin pContentRat here?
for(i=0; i<=k; i++)
{
d=singclap_gcd(d,p_Copy(C[i], r), r);
if (p_Totaldegree(d, r)==0)
{
// cleanup, pContent, return
p_Delete(&d, r);
for(;k>=0;k--)
{
p_Delete(&C[k], r);
p_Delete(&LM[k], r);
}
p_ContentForGB(ph, r);
goto cleanup;
}
}
for(i=0; i<=k; i++)
{
poly h=singclap_pdivide(C[i],d, r);
p_Delete(&C[i], r);
C[i]=h;
}
// zusammensetzen,
p=NULL; // just to be sure
for(i=0; i<=k; i++)
{
p = p_Add_q(p, p_Mult_q(C[i],LM[i], r), r);
C[i]=NULL; LM[i]=NULL;
}
p_Delete(&ph, r); // do not need it anymore
ph = p;
// aufraeumen, return
cleanup:
omFree(C);
omFree(LM);
omFree(D);
omFree(L);
}
singclap_pdivide
poly singclap_pdivide(poly f, poly g, const ring r)
Definition clapsing.cc:649
D
#define D(A)
Definition gentable.cc:128
omFree
#define omFree(addr)
Definition omAllocDecl.h:261
p_LmDeleteAndNextRat
void p_LmDeleteAndNextRat(poly *p, int ishift, ring r)
Definition p_polys.cc:1704
p_GetCoeffRat
poly p_GetCoeffRat(poly p, int ishift, ring r)
Definition p_polys.cc:1726
p_Add_q
static poly p_Add_q(poly p, poly q, const ring r)
Definition p_polys.h:938
p_Mult_q
static poly p_Mult_q(poly p, poly q, const ring r)
Definition p_polys.h:1125
p_GetExp_k_n
static poly p_GetExp_k_n(poly p, int l, int k, const ring r)
Definition p_polys.h:1393
p_Copy
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition p_polys.h:848
p_Totaldegree
static long p_Totaldegree(poly p, const ring r)
Definition p_polys.h:1528
singclap_gcd
poly singclap_gcd(poly f, poly g, const ring r)
polynomial gcd via singclap_gcd_r resp. idSyzygies destroys f and g
Definition polys.cc:409

## p_CopyPowerProduct()

poly p_CopyPowerProduct | ( | const poly | p,
|  | const ring | r )

like p_Head, but with coefficient 1

Definition at line 5134 of file p_polys.cc.

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

## p_CopyPowerProduct0()

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

like p_Head, but with coefficient n

Definition at line 5122 of file p_polys.cc.

{
p_LmCheckPolyRing1(p, r);
poly np;
omTypeAllocBin(poly, np, r->PolyBin);
p_SetRingOfLm(np, r);
memcpy(np->exp, p->exp, r->ExpL_Size*sizeof(long));
pNext(np) = NULL;
pSetCoeff0(np, n);
return np;
}
p_LmCheckPolyRing1
#define p_LmCheckPolyRing1(p, r)
Definition monomials.h:177
pSetCoeff0
#define pSetCoeff0(p, n)
Definition monomials.h:59
p_SetRingOfLm
#define p_SetRingOfLm(p, r)
Definition monomials.h:144
omTypeAllocBin
#define omTypeAllocBin(type, addr, bin)
Definition omAllocDecl.h:203

## p_Deg()

long p_Deg | ( | poly | a,
|  | const ring | r )

Definition at line 586 of file p_polys.cc.

{
p_LmCheckPolyRing(a, r);
// assume(p_GetOrder(a, r) == p_WTotaldegree(a, r)); // WRONG assume!
return p_GetOrder(a, r);
}
p_LmCheckPolyRing
BOOLEAN p_LmCheckPolyRing(poly p, ring r)
Definition pDebug.cc:123
p_GetOrder
static long p_GetOrder(poly p, ring r)
Definition p_polys.h:423

## p_DegW()

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

Definition at line 691 of file p_polys.cc.

{
p_Test(p, R);
assume( w != NULL );
long r=-LONG_MAX;
while (p!=NULL)
{
long t=totaldegreeWecart_IV(p,R,w);
if (t>r) r=t;
pIter(p);
}
return r;
}
w
const CanonicalForm & w
Definition facAbsFact.cc:51
totaldegreeWecart_IV
long totaldegreeWecart_IV(poly p, ring r, const int *w)
Definition weight.cc:231

## p_DeleteComp()

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

Definition at line 3668 of file p_polys.cc.

{
poly q;
long unsigned kk=k;
while ((*p!=NULL) && (__p_GetComp(*p,r)==kk)) p_LmDelete(p,r);
if (*p==NULL) return;
q = *p;
if (__p_GetComp(q,r)>kk)
{
p_SubComp(q,1,r);
p_SetmComp(q,r);
}
while (pNext(q)!=NULL)
{
unsigned long c=__p_GetComp(pNext(q),r);
if (/*__p_GetComp(pNext(q),r)*/c==kk)
p_LmDelete(&(pNext(q)),r);
else
{
pIter(q);
if (/*__p_GetComp(q,r)*/c>kk)
{
p_SubComp(q,1,r);
p_SetmComp(q,r);
}
}
}
}
__p_GetComp
#define __p_GetComp(p, r)
Definition monomials.h:63
p_LmDelete
static void p_LmDelete(poly p, const ring r)
Definition p_polys.h:725
p_SubComp
static unsigned long p_SubComp(poly p, unsigned long v, ring r)
Definition p_polys.h:455
p_SetmComp
#define p_SetmComp
Definition p_polys.h:246

## p_Diff()

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

Definition at line 1902 of file p_polys.cc.

{
poly res, f, last;
number t;
last = res = NULL;
while (a!=NULL)
{
if (p_GetExp(a,k,r)!=0)
{
f = p_LmInit(a,r);
t = n_Init(p_GetExp(a,k,r),r->cf);
pSetCoeff0(f,n_Mult(t,pGetCoeff(a),r->cf));
n_Delete(&t,r->cf);
if (n_IsZero(pGetCoeff(f),r->cf))
p_LmDelete(&f,r);
else
{
p_DecrExp(f,k,r);
p_Setm(f,r);
if (res==NULL)
{
res=last=f;
}
else
{
pNext(last)=f;
last=f;
}
}
}
pIter(a);
}
return res;
}
f
FILE * f
Definition checklibs.c:9
res
CanonicalForm res
Definition facAbsFact.cc:60
last
STATIC_VAR poly last
Definition hdegree.cc:1138
p_LmInit
static poly p_LmInit(poly p, const ring r)
Definition p_polys.h:1356
p_Setm
static void p_Setm(poly p, const ring r)
Definition p_polys.h:235
p_GetExp
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
Definition p_polys.h:471
p_DecrExp
static long p_DecrExp(poly p, int v, ring r)
Definition p_polys.h:600

## p_DiffOp()

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

Definition at line 1977 of file p_polys.cc.

{
poly result=NULL;
poly h;
for(;a!=NULL;pIter(a))
{
for(h=b;h!=NULL;pIter(h))
{
result=p_Add_q(result,p_DiffOpM(a,h,multiply,r),r);
}
}
return result;
}
result
return result
Definition facAbsBiFact.cc:76
p_DiffOpM
static poly p_DiffOpM(poly a, poly b, BOOLEAN multiply, const ring r)
Definition p_polys.cc:1938

## p_DiffOpM()

poly p_DiffOpM | ( | poly | a,
|  | poly | b,
|  | BOOLEAN | multiply,
|  | const ring | r )

static

Definition at line 1938 of file p_polys.cc.

{
int i,j,s;
number n,h,hh;
poly p=p_One(r);
n=n_Mult(pGetCoeff(a),pGetCoeff(b),r->cf);
for(i=rVar(r);i>0;i--)
{
s=p_GetExp(b,i,r);
if (s<p_GetExp(a,i,r))
{
n_Delete(&n,r->cf);
p_LmDelete(&p,r);
return NULL;
}
if (multiply)
{
for(j=p_GetExp(a,i,r); j>0;j--)
{
h = n_Init(s,r->cf);
hh=n_Mult(n,h,r->cf);
n_Delete(&h,r->cf);
n_Delete(&n,r->cf);
n=hh;
s--;
}
p_SetExp(p,i,s,r);
}
else
{
p_SetExp(p,i,s-p_GetExp(a,i,r),r);
}
}
p_Setm(p,r);
/*if (multiply)*/ p_SetCoeff(p,n,r);
if (n_IsZero(n,r->cf)) p=p_LmDeleteAndNext(p,r); // return NULL as p is a monomial
return p;
}
p_One
poly p_One(const ring r)
Definition p_polys.cc:1314
p_SetExp
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent @Note: VarOffset encodes the position in p->exp
Definition p_polys.h:490
p_LmDeleteAndNext
static poly p_LmDeleteAndNext(poly p, const ring r)
Definition p_polys.h:757

## p_Div_mm()

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

divide polynomial by monomial

Definition at line 1542 of file p_polys.cc.

{
p_Test(p, r);
p_Test(m, r);
poly result = p;
poly prev = NULL;
number n=pGetCoeff(m);
while (p!=NULL)
{
number nc = n_Div(pGetCoeff(p),n,r->cf);
n_Normalize(nc,r->cf);
if (!n_IsZero(nc,r->cf))
{
p_SetCoeff(p,nc,r);
prev=p;
p_ExpVectorSub(p,m,r);
pIter(p);
}
else
{
if (prev==NULL)
{
p_LmDelete(&result,r);
p=result;
}
else
{
p_LmDelete(&pNext(prev),r);
p=pNext(prev);
}
}
}
p_Test(result,r);
return(result);
}
m
int m
Definition cfEzgcd.cc:128
p_ExpVectorSub
static void p_ExpVectorSub(poly p1, poly p2, const ring r)
Definition p_polys.h:1461

## p_Div_nn()

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

Definition at line 1506 of file p_polys.cc.

{
pAssume(!n_IsZero(n,r->cf));
p_Test(p, r);
poly result = p;
poly prev = NULL;
if (!n_IsOne(n,r->cf))
{
while (p!=NULL)
{
number nc = n_Div(pGetCoeff(p),n,r->cf);
if (!n_IsZero(nc,r->cf))
{
p_SetCoeff(p,nc,r);
prev=p;
pIter(p);
}
else
{
if (prev==NULL)
{
p_LmDelete(&result,r);
p=result;
}
else
{
p_LmDelete(&pNext(prev),r);
p=pNext(prev);
}
}
}
p_Test(result,r);
}
return(result);
}

## p_DivideM()

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

Definition at line 1582 of file p_polys.cc.

{
if (a==NULL) { p_Delete(&b,r); return NULL; }
poly result=a;
if(!p_IsConstant(b,r))
{
if (rIsNCRing(r))
{
WerrorS("p_DivideM not implemented for non-commuative rings");
return NULL;
}
poly prev=NULL;
while (a!=NULL)
{
if (p_DivisibleBy(b,a,r))
{
p_ExpVectorSub(a,b,r);
prev=a;
pIter(a);
}
else
{
if (prev==NULL)
{
p_LmDelete(&result,r);
a=result;
}
else
{
p_LmDelete(&pNext(prev),r);
a=pNext(prev);
}
}
}
}
if (result!=NULL)
{
number inv=pGetCoeff(b);
//if ((!rField_is_Ring(r)) || n_IsUnit(inv,r->cf))
if (rField_is_Zp(r))
{
inv = n_Invers(inv,r->cf);
__p_Mult_nn(result,inv,r);
n_Delete(&inv, r->cf);
}
else
{
result = p_Div_nn(result,inv,r);
}
}
p_Delete(&b, r);
return result;
}
p_DivisibleBy
static BOOLEAN p_DivisibleBy(poly a, poly b, const ring r)
Definition p_polys.h:1921
__p_Mult_nn
#define __p_Mult_nn(p, n, r)
Definition p_polys.h:973
rIsNCRing
static BOOLEAN rIsNCRing(const ring r)
Definition ring.h:427

## p_DivisibleByRingCase()

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

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

Definition at line 1646 of file p_polys.cc.

{
int exponent;
for(int i = (int)rVar(r); i>0; i--)
{
exponent = p_GetExp(g, i, r) - p_GetExp(f, i, r);
if (exponent < 0) return FALSE;
}
return n_DivBy(pGetCoeff(g), pGetCoeff(f), r->cf);
}
g
g
Definition cfModGcd.cc:4098
exponent
#define exponent
Definition interpolation.cc:31

## p_EqualPolys() [1/2]

BOOLEAN p_EqualPolys | ( | poly | p1,
|  | poly | p2,
|  | const ring | r )

Definition at line 4666 of file p_polys.cc.

{
while ((p1 != NULL) && (p2 != NULL))
{
if (! p_LmEqual(p1, p2,r))
return FALSE;
if (! n_Equal(p_GetCoeff(p1,r), p_GetCoeff(p2,r),r->cf ))
return FALSE;
pIter(p1);
pIter(p2);
}
return (p1==p2);
}
p_GetCoeff
#define p_GetCoeff(p, r)
Definition monomials.h:50

## p_EqualPolys() [2/2]

BOOLEAN p_EqualPolys | ( | poly | p1,
|  | poly | p2,
|  | const ring | r1,
|  | const ring | r2 )

same as the usual p_EqualPolys for polys belonging to equal rings

Definition at line 4704 of file p_polys.cc.

{
assume( r1 == r2 || rSamePolyRep(r1, r2) ); // will be used in rEqual!
assume( r1->cf == r2->cf );
while ((p1 != NULL) && (p2 != NULL))
{
// returns 1 if ExpVector(p)==ExpVector(q): does not compare numbers !!
// #define p_LmEqual(p1, p2, r) p_ExpVectorEqual(p1, p2, r)
if (! p_ExpVectorEqual(p1, p2, r1, r2))
return FALSE;
if (! n_Equal(p_GetCoeff(p1,r1), p_GetCoeff(p2,r2), r1->cf ))
return FALSE;
pIter(p1);
pIter(p2);
}
return (p1==p2);
}
p_ExpVectorEqual
static BOOLEAN p_ExpVectorEqual(poly p1, poly p2, const ring r1, const ring r2)
Definition p_polys.cc:4680
rSamePolyRep
BOOLEAN rSamePolyRep(ring r1, ring r2)
returns TRUE, if r1 and r2 represents the monomials in the same way FALSE, otherwise this is an analo...
Definition ring.cc:1805

## p_ExpVectorEqual()

BOOLEAN p_ExpVectorEqual | ( | poly | p1,
|  | poly | p2,
|  | const ring | r1,
|  | const ring | r2 )

inline static

Definition at line 4680 of file p_polys.cc.

{
assume( r1 == r2 || rSamePolyRep(r1, r2) );
p_LmCheckPolyRing1(p1, r1);
p_LmCheckPolyRing1(p2, r2);
int i = r1->ExpL_Size;
assume( r1->ExpL_Size == r2->ExpL_Size );
unsigned long *ep = p1->exp;
unsigned long *eq = p2->exp;
do
{
i--;
if (ep[i] != eq[i]) return FALSE;
}
while (i);
return TRUE;
}

## p_Farey()

poly p_Farey | ( | poly | p,
|  | number | N,
|  | const ring | r )

Definition at line 54 of file p_polys.cc.

{
poly h=p_Copy(p,r);
poly hh=h;
while(h!=NULL)
{
number c=pGetCoeff(h);
pSetCoeff0(h,n_Farey(c,N,r->cf));
n_Delete(&c,r->cf);
pIter(h);
}
while((hh!=NULL)&&(n_IsZero(pGetCoeff(hh),r->cf)))
{
p_LmDelete(&hh,r);
}
h=hh;
while((h!=NULL) && (pNext(h)!=NULL))
{
if(n_IsZero(pGetCoeff(pNext(h)),r->cf))
{
p_LmDelete(&pNext(h),r);
}
else pIter(h);
}
return hh;
}
N
const CanonicalForm CFMap CFMap & N
Definition cfEzgcd.cc:56
n_Farey
static FORCE_INLINE number n_Farey(number a, number b, const coeffs r)
Definition coeffs.h:762

## p_GcdMon()

poly p_GcdMon | ( | poly | f,
|  | poly | g,
|  | const ring | r )

polynomial gcd for f=mon

Definition at line 5084 of file p_polys.cc.

{
assume(f!=NULL);
assume(g!=NULL);
assume(pNext(f)==NULL);
poly G=p_Head(f,r);
poly h=g;
int *mf=(int*)omAlloc((r->N+1)*sizeof(int));
p_GetExpV(f,mf,r);
int *mh=(int*)omAlloc((r->N+1)*sizeof(int));
BOOLEAN const_mon;
BOOLEAN one_coeff=n_IsOne(pGetCoeff(G),r->cf);
loop
{
if (h==NULL) break;
if(!one_coeff)
{
number n=n_SubringGcd(pGetCoeff(G),pGetCoeff(h),r->cf);
one_coeff=n_IsOne(n,r->cf);
p_SetCoeff(G,n,r);
}
p_GetExpV(h,mh,r);
const_mon=TRUE;
for(unsigned j=r->N;j!=0;j--)
{
if (mh[j]<mf[j]) mf[j]=mh[j];
if (mf[j]>0) const_mon=FALSE;
}
if (one_coeff && const_mon) break;
pIter(h);
}
mf[0]=0;
p_SetExpV(G,mf,r); // included is p_SetComp, p_Setm
omFreeSize(mf,(r->N+1)*sizeof(int));
omFreeSize(mh,(r->N+1)*sizeof(int));
return G;
}
BOOLEAN
int BOOLEAN
Definition auxiliary.h:88
G
STATIC_VAR TreeM * G
Definition janet.cc:31
omAlloc
#define omAlloc(size)
Definition omAllocDecl.h:210
p_SetExpV
static void p_SetExpV(poly p, int *ev, const ring r)
Definition p_polys.h:1565
p_GetExpV
static void p_GetExpV(poly p, int *ev, const ring r)
Definition p_polys.h:1541

## p_GetCoeffRat()

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

Definition at line 1726 of file p_polys.cc.

{
poly q = pNext(p);
poly res; // = p_Head(p,r);
res = p_GetExp_k_n(p, ishift+1, r->N, r); // does pSetm internally
p_SetCoeff(res,n_Copy(p_GetCoeff(p,r),r),r);
poly s;
long cmp = p_GetComp(p, r);
while ( (q!= NULL) && (p_Comp_k_n(p, q, ishift+1, r)) && (p_GetComp(q, r) == cmp) )
{
s = p_GetExp_k_n(q, ishift+1, r->N, r);
p_SetCoeff(s,n_Copy(p_GetCoeff(q,r),r),r);
res = p_Add_q(res,s,r);
q = pNext(q);
}
cmp = 0;
p_SetCompP(res,cmp,r);
return res;
}
p_GetComp
#define p_GetComp(p, r)
Definition monomials.h:64
p_Comp_k_n
static int p_Comp_k_n(poly a, poly b, int k, ring r)
Definition p_polys.h:642
p_SetCompP
static void p_SetCompP(poly p, int i, ring r)
Definition p_polys.h:256

## p_GetMaxExpL()

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

{
unsigned long l_p, divmask = r->divmask;
int i;
while (p != NULL)
{
l_p = p->exp[r->VarL_Offset[0]];
if (l_p > l_max ||
(((l_max & divmask) ^ (l_p & divmask)) != ((l_max-l_p) & divmask)))
l_max = p_GetMaxExpL2(l_max, l_p, r);
for (i=1; i<r->VarL_Size; i++)
{
l_p = p->exp[r->VarL_Offset[i]];
// do the divisibility trick to find out whether l has an exponent
if (l_p > l_max ||
(((l_max & divmask) ^ (l_p & divmask)) != ((l_max-l_p) & divmask)))
l_max = p_GetMaxExpL2(l_max, l_p, r);
}
pIter(p);
}
return l_max;
}
p_GetMaxExpL2
static unsigned long p_GetMaxExpL2(unsigned long l1, unsigned long l2, const ring r, unsigned long number_of_exp)
Definition p_polys.cc:1108

## p_GetMaxExpL2() [1/2]

unsigned long p_GetMaxExpL2 | ( | unsigned long | l1,
|  | unsigned long | l2,
|  | const ring | r )

inline static

Definition at line 1134 of file p_polys.cc.

{
return p_GetMaxExpL2(l1, l2, r, r->ExpPerLong);
}

## p_GetMaxExpL2() [2/2]

unsigned long p_GetMaxExpL2 | ( | unsigned long | l1,
|  | unsigned long | l2,
|  | const ring | r,
|  | unsigned long | number_of_exp )

inline static

Definition at line 1108 of file p_polys.cc.

{
const unsigned long bitmask = r->bitmask;
unsigned long ml1 = l1 & bitmask;
unsigned long ml2 = l2 & bitmask;
unsigned long max = (ml1 > ml2 ? ml1 : ml2);
unsigned long j = number_of_exp - 1;
if (j > 0)
{
unsigned long mask = bitmask << r->BitsPerExp;
while (1)
{
ml1 = l1 & mask;
ml2 = l2 & mask;
max |= ((ml1 > ml2 ? ml1 : ml2) & mask);
j--;
if (j == 0) break;
mask = mask << r->BitsPerExp;
}
}
return max;
}
max
static int max(int a, int b)
Definition fast_mult.cc:264

## p_GetMaxExpP()

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

{
p_CheckPolyRing(p, r);
if (p == NULL) return p_Init(r);
poly max = p_LmInit(p, r);
pIter(p);
if (p == NULL) return max;
int i, offset;
unsigned long l_p, l_max;
unsigned long divmask = r->divmask;
do
{
offset = r->VarL_Offset[0];
l_p = p->exp[offset];
l_max = max->exp[offset];
// do the divisibility trick to find out whether l has an exponent
if (l_p > l_max ||
(((l_max & divmask) ^ (l_p & divmask)) != ((l_max-l_p) & divmask)))
max->exp[offset] = p_GetMaxExpL2(l_max, l_p, r);
for (i=1; i<r->VarL_Size; i++)
{
offset = r->VarL_Offset[i];
l_p = p->exp[offset];
l_max = max->exp[offset];
// do the divisibility trick to find out whether l has an exponent
if (l_p > l_max ||
(((l_max & divmask) ^ (l_p & divmask)) != ((l_max-l_p) & divmask)))
max->exp[offset] = p_GetMaxExpL2(l_max, l_p, r);
}
pIter(p);
}
while (p != NULL);
return max;
}
offset
STATIC_VAR int offset
Definition janet.cc:29
p_CheckPolyRing
BOOLEAN p_CheckPolyRing(poly p, ring r)
Definition pDebug.cc:115
p_Init
static poly p_Init(const ring r, omBin bin)
Definition p_polys.h:1341

## p_GetSetmProc()

p_SetmProc p_GetSetmProc | ( | const ring | r | ) |

Definition at line 559 of file p_polys.cc.

{
// covers lp, rp, ls,
if (r->typ == NULL) return p_Setm_Dummy;
if (r->OrdSize == 1)
{
if ((r->typ[0].ord_typ == ro_dp) &&
(r->typ[0].data.dp.start == 1) &&
(r->typ[0].data.dp.end == r->N) &&
(r->typ[0].data.dp.place == r->pOrdIndex))
return p_Setm_TotalDegree;
if ((r->typ[0].ord_typ == ro_wp) &&
(r->typ[0].data.wp.start == 1) &&
(r->typ[0].data.wp.end == r->N) &&
(r->typ[0].data.wp.place == r->pOrdIndex) &&
(r->typ[0].data.wp.weights == r->firstwv))
return p_Setm_WFirstTotalDegree;
}
return p_Setm_General;
}
p_Setm_WFirstTotalDegree
void p_Setm_WFirstTotalDegree(poly p, const ring r)
Definition p_polys.cc:553
p_Setm_Dummy
void p_Setm_Dummy(poly p, const ring r)
Definition p_polys.cc:540
p_Setm_TotalDegree
void p_Setm_TotalDegree(poly p, const ring r)
Definition p_polys.cc:546
p_Setm_General
void p_Setm_General(poly p, const ring r)
Definition p_polys.cc:158
ro_dp
@ ro_dp
Definition ring.h:53
ro_wp
@ ro_wp
Definition ring.h:54

## p_GetShortExpVector()

unsigned long p_GetShortExpVector | ( | const poly | p,
|  | const ring | r )

Definition at line 4934 of file p_polys.cc.

{
assume(p != NULL);
unsigned long ev = 0; // short exponent vector
unsigned int n = BIT_SIZEOF_LONG / r->N; // number of bits per exp
unsigned int m1; // highest bit which is filled with (n+1)
unsigned int i=0;
int j=1;
if (n == 0)
{
if (r->N <2*BIT_SIZEOF_LONG)
{
n=1;
m1=0;
}
else
{
for (; j<=r->N; j++)
{
if (p_GetExp(p,j,r) > 0) i++;
if (i == BIT_SIZEOF_LONG) break;
}
if (i>0)
ev = ~(0UL) >> (BIT_SIZEOF_LONG - i);
return ev;
}
}
else
{
m1 = (n+1)*(BIT_SIZEOF_LONG - n*r->N);
}
n++;
while (i<m1)
{
ev |= GetBitFields(p_GetExp(p, j,r), i, n);
i += n;
j++;
}
n--;
while (i<BIT_SIZEOF_LONG)
{
ev |= GetBitFields(p_GetExp(p, j,r), i, n);
i += n;
j++;
}
return ev;
}
GetBitFields
static unsigned long GetBitFields(const long e, const unsigned int s, const unsigned int n)
Definition p_polys.cc:4902

## p_GetShortExpVector0()

unsigned long p_GetShortExpVector0 | ( | const poly | p,
|  | const ring | r )

Definition at line 4985 of file p_polys.cc.

{
assume(p != NULL);
assume(r->N >=BIT_SIZEOF_LONG);
unsigned long ev = 0; // short exponent vector
for (int j=BIT_SIZEOF_LONG; j>0; j--)
{
if (p_GetExp(p, j,r)>0)
ev |= Sy_bitL(j-1);
}
return ev;
}

## p_GetShortExpVector1()

unsigned long p_GetShortExpVector1 | ( | const poly | p,
|  | const ring | r )

Definition at line 5000 of file p_polys.cc.

{
assume(p != NULL);
assume(r->N <BIT_SIZEOF_LONG);
assume(2*r->N >=BIT_SIZEOF_LONG);
unsigned long ev = 0; // short exponent vector
int rest=r->N;
int e;
// 2 bits per exp
int j=r->N;
for (; j>BIT_SIZEOF_LONG-r->N; j--)
{
if ((e=p_GetExp(p, j,r))>0)
{
ev |= Sy_bitL(j-1);
if (e>1)
{
ev|=Sy_bitL(rest+j-1);
}
}
}
// 1 bit per exp
for (; j>0; j--)
{
if (p_GetExp(p, j,r)>0)
{
ev |= Sy_bitL(j-1);
}
}
return ev;
}

## p_GetVariables()

int p_GetVariables | ( | poly | p,
|  | int * | e,
|  | const ring | r )

set entry e[i] to 1 if var(i) occurs in p, ignore var(j) if e[j]>0 return #(e[i]>0)

Definition at line 1268 of file p_polys.cc.

{
int i;
int n=0;
while(p!=NULL)
{
n=0;
for(i=r->N; i>0; i--)
{
if(e[i]==0)
{
if (p_GetExp(p,i,r)>0)
{
e[i]=1;
n++;
}
}
else
n++;
}
if (n==r->N) break;
pIter(p);
}
return n;
}

## p_HasNotCF()

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

Definition at line 1330 of file p_polys.cc.

{
if (p_GetComp(p1,r) > 0 || p_GetComp(p2,r) > 0)
return FALSE;
int i = rVar(r);
loop
{
if ((p_GetExp(p1, i, r) > 0) && (p_GetExp(p2, i, r) > 0))
return FALSE;
i--;
if (i == 0)
return TRUE;
}
}

## p_HasNotCFRing()

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

Definition at line 1346 of file p_polys.cc.

{
if (p_GetComp(p1,r) > 0 || p_GetComp(p2,r) > 0)
return FALSE;
int i = rVar(r);
loop
{
if ((p_GetExp(p1, i, r) > 0) && (p_GetExp(p2, i, r) > 0))
return FALSE;
i--;
if (i == 0) {
if (n_DivBy(pGetCoeff(p1), pGetCoeff(p2), r->cf) ||
n_DivBy(pGetCoeff(p2), pGetCoeff(p1), r->cf)) {
return FALSE;
} else {
return TRUE;
}
}
}
}

## p_Head0()

poly p_Head0 | ( | const poly | p,
|  | const ring | r )

like p_Head, but allow NULL coeff

Definition at line 5140 of file p_polys.cc.

{
if (p==NULL) return NULL;
if (pGetCoeff(p)==NULL) return p_CopyPowerProduct0(p,NULL,r);
return p_Head(p,r);
}

## p_Homogen()

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

Definition at line 3319 of file p_polys.cc.

{
pFDegProc deg;
if (r->pLexOrder && (r->order[0]==ringorder_lp))
deg=p_Totaldegree;
else
deg=r->pFDeg;
poly q=NULL, qn;
int o,ii;
sBucket_pt bp;
if (p!=NULL)
{
if ((varnum < 1) || (varnum > rVar(r)))
{
return NULL;
}
o=deg(p,r);
q=pNext(p);
while (q != NULL)
{
ii=deg(q,r);
if (ii>o) o=ii;
pIter(q);
}
q = p_Copy(p,r);
bp = sBucketCreate(r);
while (q != NULL)
{
ii = o-deg(q,r);
if (ii!=0)
{
p_AddExp(q,varnum, (long)ii,r);
p_Setm(q,r);
}
qn = pNext(q);
pNext(q) = NULL;
sBucket_Add_m(bp, q);
q = qn;
}
sBucketDestroyAdd(bp, &q, &ii);
}
return q;
}
p_AddExp
static long p_AddExp(poly p, int v, long ee, ring r)
Definition p_polys.h:608
pFDegProc
long(* pFDegProc)(poly p, ring r)
Definition ring.h:39
ringorder_lp
@ ringorder_lp
Definition ring.h:78
sBucket_Add_m
void sBucket_Add_m(sBucket_pt bucket, poly p)
Definition sbuckets.cc:173
sBucketCreate
sBucket_pt sBucketCreate(const ring r)
Definition sbuckets.cc:96
sBucket_pt
sBucket * sBucket_pt
Definition sbuckets.h:16
sBucketDestroyAdd
void sBucketDestroyAdd(sBucket_pt bucket, poly *p, int *length)
Definition sbuckets.h:68

## p_HomogenDP()

poly p_HomogenDP | ( | poly | p,
|  | int | varnum,
|  | const ring | r )

Definition at line 3365 of file p_polys.cc.

{
poly q=NULL, qn;
int o,ii;
sBucket_pt bp;
if (p!=NULL)
{
if ((varnum < 1) || (varnum > rVar(r)))
{
return NULL;
}
o=p_Totaldegree(p,r);
q=pNext(p);
while (q != NULL)
{
ii=p_Totaldegree(q,r);
if (ii>o) o=ii;
pIter(q);
}
q = p_Copy(p,r);
bp = sBucketCreate(r);
while (q != NULL)
{
ii = o-p_Totaldegree(q,r);
if (ii!=0)
{
p_AddExp(q,varnum, (long)ii,r);
p_Setm(q,r);
}
qn = pNext(q);
pNext(q) = NULL;
sBucket_Add_m(bp, q);
q = qn;
}
sBucketDestroyAdd(bp, &q, &ii);
}
return q;
}

## p_InitContent()

number p_InitContent | ( | poly | ph,
|  | const ring | r )

Definition at line 2683 of file p_polys.cc.

{
assume(!TEST_OPT_CONTENTSB);
assume(ph!=NULL);
assume(pNext(ph)!=NULL);
assume(rField_is_Q(r));
if (pNext(pNext(ph))==NULL)
{
return n_GetNumerator(pGetCoeff(pNext(ph)),r->cf);
}
poly p=ph;
number n1=n_GetNumerator(pGetCoeff(p),r->cf);
pIter(p);
number n2=n_GetNumerator(pGetCoeff(p),r->cf);
pIter(p);
number d;
number t;
loop
{
nlNormalize(pGetCoeff(p),r->cf);
t=n_GetNumerator(pGetCoeff(p),r->cf);
if (nlGreaterZero(t,r->cf))
d=nlAdd(n1,t,r->cf);
else
d=nlSub(n1,t,r->cf);
nlDelete(&t,r->cf);
nlDelete(&n1,r->cf);
n1=d;
pIter(p);
if (p==NULL) break;
nlNormalize(pGetCoeff(p),r->cf);
t=n_GetNumerator(pGetCoeff(p),r->cf);
if (nlGreaterZero(t,r->cf))
d=nlAdd(n2,t,r->cf);
else
d=nlSub(n2,t,r->cf);
nlDelete(&t,r->cf);
nlDelete(&n2,r->cf);
n2=d;
pIter(p);
if (p==NULL) break;
}
d=nlGcd(n1,n2,r->cf);
nlDelete(&n1,r->cf);
nlDelete(&n2,r->cf);
return d;
}
#else
{
/* ph has al least 2 terms */
number d=pGetCoeff(ph);
int s=n_Size(d,r->cf);
pIter(ph);
number d2=pGetCoeff(ph);
int s2=n_Size(d2,r->cf);
pIter(ph);
if (ph==NULL)
{
if (s<s2) return n_Copy(d,r->cf);
else return n_Copy(d2,r->cf);
}
do
{
number nd=pGetCoeff(ph);
int ns=n_Size(nd,r->cf);
if (ns<=2)
{
s2=s;
d2=d;
d=nd;
s=ns;
break;
}
else if (ns<s)
{
s2=s;
d2=d;
d=nd;
s=ns;
}
pIter(ph);
}
while(ph!=NULL);
return n_SubringGcd(d,d2,r->cf);
}
n_Size
static FORCE_INLINE int n_Size(number n, const coeffs r)
return a non-negative measure for the complexity of n; return 0 only when n represents zero; (used fo...
Definition coeffs.h:573
n_GetNumerator
static FORCE_INLINE number n_GetNumerator(number &n, const coeffs r)
return the numerator of n (if elements of r are by nature not fractional, result is n)
Definition coeffs.h:611
nlAdd
LINLINE number nlAdd(number la, number li, const coeffs r)
Definition longrat.cc:2672
nlSub
LINLINE number nlSub(number la, number li, const coeffs r)
Definition longrat.cc:2738
nlDelete
LINLINE void nlDelete(number *a, const coeffs r)
Definition longrat.cc:2637
nlGreaterZero
BOOLEAN nlGreaterZero(number za, const coeffs r)
Definition longrat.cc:1303
nlGcd
number nlGcd(number a, number b, const coeffs r)
Definition longrat.cc:1340
nlNormalize
void nlNormalize(number &x, const coeffs r)
Definition longrat.cc:1481

## p_Invers()

poly p_Invers | ( | int | n,
|  | poly | u,
|  | intvec * | w,
|  | const ring | R )

static

Definition at line 4623 of file p_polys.cc.

{
if(n<0)
return NULL;
number u0=n_Invers(pGetCoeff(u),R->cf);
poly v=p_NSet(u0,R);
if(n==0)
return v;
int *ww=iv2array(w,R);
poly u1=p_JetW(p_Sub(p_One(R),__p_Mult_nn(u,u0,R),R),n,ww,R);
if(u1==NULL)
{
omFreeSize((ADDRESS)ww,(rVar(R)+1)*sizeof(int));
return v;
}
poly v1=__p_Mult_nn(p_Copy(u1,R),u0,R);
v=p_Add_q(v,p_Copy(v1,R),R);
for(int i=n/p_MinDeg(u1,w,R);i>1;i--)
{
v1=p_JetW(p_Mult_q(v1,p_Copy(u1,R),R),n,ww,R);
v=p_Add_q(v,p_Copy(v1,R),R);
}
p_Delete(&u1,R);
p_Delete(&v1,R);
omFreeSize((ADDRESS)ww,(rVar(R)+1)*sizeof(int));
return v;
}
v
const Variable & v
< [in] a sqrfree bivariate poly
Definition facBivar.h:39
p_MinDeg
int p_MinDeg(poly p, intvec *w, const ring R)
Definition p_polys.cc:4602
p_Sub
poly p_Sub(poly p1, poly p2, const ring r)
Definition p_polys.cc:1994
p_NSet
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
Definition p_polys.cc:1474
p_JetW
poly p_JetW(poly p, int m, int *w, const ring R)
Definition p_polys.cc:4584
iv2array
int * iv2array(intvec *iv, const ring R)
Definition weight.cc:200

## p_ISet()

poly p_ISet | ( | long | i,
|  | const ring | r )

returns the poly representing the integer i

Definition at line 1298 of file p_polys.cc.

{
poly rc = NULL;
if (i!=0)
{
rc = p_Init(r);
pSetCoeff0(rc,n_Init(i,r->cf));
if (n_IsZero(pGetCoeff(rc),r->cf))
p_LmDelete(&rc,r);
}
return rc;
}

## p_IsHomogeneous()

BOOLEAN p_IsHomogeneous | ( | poly | p,
|  | const ring | r )

Definition at line 3408 of file p_polys.cc.

{
poly qp=p;
int o;
if ((p == NULL) || (pNext(p) == NULL)) return TRUE;
pFDegProc d;
if (r->pLexOrder && (r->order[0]==ringorder_lp))
d=p_Totaldegree;
else
d=r->pFDeg;
o = d(p,r);
do
{
if (d(qp,r) != o) return FALSE;
pIter(qp);
}
while (qp != NULL);
return TRUE;
}

## p_IsHomogeneousDP()

BOOLEAN p_IsHomogeneousDP | ( | poly | p,
|  | const ring | r )

Definition at line 3432 of file p_polys.cc.

{
poly qp=p;
int o;
if ((p == NULL) || (pNext(p) == NULL)) return TRUE;
o = p_Totaldegree(p,r);
do
{
if (p_Totaldegree(qp,r) != o) return FALSE;
pIter(qp);
}
while (qp != NULL);
return TRUE;
}

## p_IsHomogeneousW() [1/2]

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

Definition at line 3468 of file p_polys.cc.

{
poly qp=p;
long o;
if ((p == NULL) || (pNext(p) == NULL)) return TRUE;
pIter(qp);
o = totaldegreeWecart_IV(p,r,w->ivGetVec())+(*module_w)[p_GetComp(p,r)];
do
{
long oo=totaldegreeWecart_IV(qp,r,w->ivGetVec())+(*module_w)[p_GetComp(qp,r)];
if (oo != o) return FALSE;
pIter(qp);
}
while (qp != NULL);
return TRUE;
}

## p_IsHomogeneousW() [2/2]

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

Definition at line 3451 of file p_polys.cc.

{
poly qp=p;
long o;
if ((p == NULL) || (pNext(p) == NULL)) return TRUE;
pIter(qp);
o = totaldegreeWecart_IV(p,r,w->ivGetVec());
do
{
if (totaldegreeWecart_IV(qp,r,w->ivGetVec()) != o) return FALSE;
pIter(qp);
}
while (qp != NULL);
return TRUE;
}

## p_IsPurePower()

int p_IsPurePower | ( | const poly | p,
|  | const ring | r )

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

Definition at line 1227 of file p_polys.cc.

{
int i,k=0;
for (i=r->N;i;i--)
{
if (p_GetExp(p,i, r)!=0)
{
if(k!=0) return 0;
k=i;
}
}
return k;
}

## p_IsUnivariate()

int p_IsUnivariate | ( | poly | p,
|  | const ring | r )

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

Definition at line 1248 of file p_polys.cc.

{
int i,k=-1;
while (p!=NULL)
{
for (i=r->N;i;i--)
{
if (p_GetExp(p,i, r)!=0)
{
if((k!=-1)&&(k!=i)) return 0;
k=i;
}
}
pIter(p);
}
return k;
}

## p_Jet()

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

Definition at line 4540 of file p_polys.cc.

{
while((p!=NULL) && (p_Totaldegree(p,R)>m)) p_LmDelete(&p,R);
if (p==NULL) return NULL;
poly r=p;
while (pNext(p)!=NULL)
{
if (p_Totaldegree(pNext(p),R)>m)
{
p_LmDelete(&pNext(p),R);
}
else
pIter(p);
}
return r;
}

## p_JetW()

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

Definition at line 4584 of file p_polys.cc.

{
while((p!=NULL) && (totaldegreeWecart_IV(p,R,w)>m)) p_LmDelete(&p,R);
if (p==NULL) return NULL;
poly r=p;
while (pNext(p)!=NULL)
{
if (totaldegreeWecart_IV(pNext(p),R,w)>m)
{
p_LmDelete(&pNext(p),R);
}
else
pIter(p);
}
return r;
}

## p_Last()

poly p_Last | ( | const poly | p,
|  | int & | l,
|  | const ring | r )

Definition at line 4775 of file p_polys.cc.

{
if (p == NULL)
{
l = 0;
return NULL;
}
l = 1;
poly a = p;
if (! rIsSyzIndexRing(r))
{
poly next = pNext(a);
while (next!=NULL)
{
a = next;
next = pNext(a);
l++;
}
}
else
{
long unsigned curr_limit = rGetCurrSyzLimit(r);
poly pp = a;
while ((a=pNext(a))!=NULL)
{
if (__p_GetComp(a,r)<=curr_limit/*syzComp*/)
l++;
else break;
pp = a;
}
a=pp;
}
return a;
}
pp
CanonicalForm FACTORY_PUBLIC pp(const CanonicalForm &)
CanonicalForm pp ( const CanonicalForm & f ).
Definition cf_gcd.cc:676
l
int l
Definition cfEzgcd.cc:100
next
ListNode * next
Definition janet.h:31
rGetCurrSyzLimit
static int rGetCurrSyzLimit(const ring r)
Definition ring.h:729
rIsSyzIndexRing
static BOOLEAN rIsSyzIndexRing(const ring r)
Definition ring.h:726

## p_Lcm() [1/2]

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

Definition at line 1668 of file p_polys.cc.

{
poly m=p_Init(r);
p_Lcm(a, b, m, r);
p_Setm(m,r);
return(m);
}
p_Lcm
void p_Lcm(const poly a, const poly b, poly m, const ring r)
Definition p_polys.cc:1659

## p_Lcm() [2/2]

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

Definition at line 1659 of file p_polys.cc.

{
for (int i=r->N; i; --i)
p_SetExp(m,i, si_max( p_GetExp(a,i,r), p_GetExp(b,i,r)),r);
p_SetComp(m, si_max(p_GetComp(a,r), p_GetComp(b,r)),r);
/* Don't do a pSetm here, otherwise hres/lres chockes */
}
si_max
static int si_max(const int a, const int b)
Definition auxiliary.h:125
p_SetComp
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition p_polys.h:249

## p_LcmRat()

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

Definition at line 1681 of file p_polys.cc.

{
poly m = // p_One( r);
p_Init(r);
// const int (currRing->N) = r->N;
// for (int i = (currRing->N); i>=r->real_var_start; i--)
for (int i = r->real_var_end; i>=r->real_var_start; i--)
{
const int lExpA = p_GetExp (a, i, r);
const int lExpB = p_GetExp (b, i, r);
p_SetExp (m, i, si_max(lExpA, lExpB), r);
}
p_SetComp (m, lCompM, r);
p_Setm(m,r);
p_GetCoeff(m, r)=NULL;
return(m);
};

## p_LmDeleteAndNextRat()

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

Definition at line 1704 of file p_polys.cc.

{
/* modifies p*/
// Print("start: "); Print(" "); p_wrp(*p,r);
p_LmCheckPolyRing2(*p, r);
poly q = p_Head(*p,r);
const long cmp = p_GetComp(*p, r);
while ( ( (*p)!=NULL ) && ( p_Comp_k_n(*p, q, ishift+1, r) ) && (p_GetComp(*p, r) == cmp) )
{
p_LmDelete(p,r);
// Print("while: ");p_wrp(*p,r);Print(" ");
}
// p_wrp(*p,r);Print(" ");
// PrintS("end\n");
p_LmDelete(&q,r);
}
p_LmCheckPolyRing2
#define p_LmCheckPolyRing2(p, r)
Definition monomials.h:199

## p_LowVar()

int p_LowVar | ( | poly | p,
|  | const ring | r )

the minimal index of used variables - 1

Definition at line 4834 of file p_polys.cc.

{
int k,l,lex;
if (p == NULL) return -1;
k = 32000;/*a very large dummy value*/
while (p != NULL)
{
l = 1;
lex = p_GetExp(p,l,r);
while ((l < (rVar(r))) && (lex == 0))
{
l++;
lex = p_GetExp(p,l,r);
}
l--;
if (l < k) k = l;
pIter(p);
}
return k;
}

## p_MaxExpPerVar()

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

max exponent of variable x_i in p

Definition at line 5146 of file p_polys.cc.

{
int m=0;
while(p!=NULL)
{
int mm=p_GetExp(p,i,r);
if (mm>m) m=mm;
pIter(p);
}
return m;
}

## p_MDivide()

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

Definition at line 1493 of file p_polys.cc.

{
assume((p_GetComp(a,r)==p_GetComp(b,r)) || (p_GetComp(b,r)==0));
int i;
poly result = p_Init(r);
for(i=(int)r->N; i; i--)
p_SetExp(result,i, p_GetExp(a,i,r)- p_GetExp(b,i,r),r);
p_SetComp(result, p_GetComp(a,r) - p_GetComp(b,r),r);
p_Setm(result,r);
return result;
}

## p_MinDeg()

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

Definition at line 4602 of file p_polys.cc.

{
if(p==NULL)
return -1;
int d=-1;
while(p!=NULL)
{
int d0=0;
for(int j=0;j<rVar(R);j++)
if(w==NULL||j>=w->length())
d0+=p_GetExp(p,j+1,R);
else
d0+=(*w)[j]*p_GetExp(p,j+1,R);
if(d0<d||d==-1)
d=d0;
pIter(p);
}
return d;
}

## p_mInit()

poly p_mInit | ( | const char * | st,
|  | BOOLEAN & | ok,
|  | const ring | r )

Definition at line 1443 of file p_polys.cc.

{
poly p;
char *sst=(char*)st;
BOOLEAN neg=FALSE;
if (sst[0]=='-') { neg=TRUE; sst=sst+1; }
const char *s=p_Read(sst,p,r);
if (*s!='\0')
{
if ((s!=sst)&&isdigit(sst[0]))
{
errorreported=TRUE;
}
ok=FALSE;
if (p!=NULL)
{
if (pGetCoeff(p)==NULL) p_LmFree(p,r);
else p_LmDelete(p,r);
}
return NULL;
}
p_Test(p,r);
ok=!errorreported;
if (neg) p=p_Neg(p,r);
return p;
}
errorreported
VAR short errorreported
Definition feFopen.cc:23
p_Read
const char * p_Read(const char *st, poly &rc, const ring r)
Definition p_polys.cc:1371
p_LmFree
static void p_LmFree(poly p, ring)
Definition p_polys.h:685

## p_MonMult()

void p_MonMult | ( | poly | p,
|  | poly | q,
|  | const ring | r )

static

Definition at line 2036 of file p_polys.cc.

{
number x, y;
y = pGetCoeff(p);
x = n_Mult(y,pGetCoeff(q),r->cf);
n_Delete(&y,r->cf);
pSetCoeff0(p,x);
//for (int i=pVariables; i!=0; i--)
//{
// pAddExp(p,i, pGetExp(q,i));
//}
//p->Order += q->Order;
p_ExpVectorAdd(p,q,r);
}
y
const CanonicalForm int const CFList const Variable & y
Definition facAbsFact.cc:53
p_ExpVectorAdd
static void p_ExpVectorAdd(poly p1, poly p2, const ring r)
Definition p_polys.h:1432

## p_MonMultC()

poly p_MonMultC | ( | poly | p,
|  | poly | q,
|  | const ring | rr )

static

Definition at line 2056 of file p_polys.cc.

{
number x;
poly r = p_Init(rr);
x = n_Mult(pGetCoeff(p),pGetCoeff(q),rr->cf);
pSetCoeff0(r,x);
p_ExpVectorSum(r,p, q, rr);
return r;
}
p_ExpVectorSum
static void p_ExpVectorSum(poly pr, poly p1, poly p2, const ring r)
Definition p_polys.h:1446

## p_MonPower()

poly p_MonPower | ( | poly | p,
|  | int | exp,
|  | const ring | r )

static

Definition at line 2004 of file p_polys.cc.

{
int i;
if(!n_IsOne(pGetCoeff(p),r->cf))
{
number x, y;
y = pGetCoeff(p);
n_Power(y,exp,&x,r->cf);
#ifdef HAVE_RINGS // may have zero divisors
if (UNLIKELY(n_IsZero(x,r->cf)))
{
p_LmDelete(&p,r);
n_Delete(&x,r->cf);
return NULL;
}
#endif
n_Delete(&y,r->cf);
pSetCoeff0(p,x);
}
for (i=rVar(r); i!=0; i--)
{
p_MultExp(p,i, exp,r);
}
p_Setm(p,r);
return p;
}
UNLIKELY
#define UNLIKELY(X)
Definition auxiliary.h:405
n_Power
static FORCE_INLINE void n_Power(number a, int b, number *res, const coeffs r)
fill res with the power a^b
Definition coeffs.h:635
exp
gmp_float exp(const gmp_float &a)
Definition mpr_complex.cc:349
p_MultExp
static long p_MultExp(poly p, int v, long ee, ring r)
Definition p_polys.h:623

## p_Norm()

void p_Norm | ( | poly | p1,
|  | const ring | r )

Definition at line 3844 of file p_polys.cc.

{
if (UNLIKELY(p1==NULL)) return;
if (rField_is_Ring(r))
{
if(!n_GreaterZero(pGetCoeff(p1),r->cf)) p1 = p_Neg(p1,r);
if (!n_IsUnit(pGetCoeff(p1), r->cf)) return;
// Werror("p_Norm not possible in the case of coefficient rings.");
}
else //(p1!=NULL)
{
if (!n_IsOne(pGetCoeff(p1),r->cf))
{
if (UNLIKELY(pNext(p1)==NULL))
{
p_SetCoeff(p1,n_Init(1,r->cf),r);
return;
}
number k = pGetCoeff(p1);
pSetCoeff0(p1,n_Init(1,r->cf));
poly h = pNext(p1);
if (LIKELY(rField_is_Zp(r)))
{
if (r->cf->ch>32003)
{
number inv=n_Invers(k,r->cf);
while (h!=NULL)
{
number c=n_Mult(pGetCoeff(h),inv,r->cf);
// no need to normalize
p_SetCoeff(h,c,r);
pIter(h);
}
// no need for n_Delete for Zp: n_Delete(&inv,r->cf);
}
else
{
while (h!=NULL)
{
number c=n_Div(pGetCoeff(h),k,r->cf);
// no need to normalize
p_SetCoeff(h,c,r);
pIter(h);
}
}
}
else if(getCoeffType(r->cf)==n_algExt)
{
n_Normalize(k,r->cf);
number inv=n_Invers(k,r->cf);
while (h!=NULL)
{
number c=n_Mult(pGetCoeff(h),inv,r->cf);
// no need to normalize
// normalize already in nMult: Zp_a, Q_a
p_SetCoeff(h,c,r);
pIter(h);
}
n_Delete(&inv,r->cf);
n_Delete(&k,r->cf);
}
else
{
n_Normalize(k,r->cf);
while (h!=NULL)
{
number c=n_Div(pGetCoeff(h),k,r->cf);
// no need to normalize: Z/p, R
// remains: Q
if (rField_is_Q(r)) n_Normalize(c,r->cf);
p_SetCoeff(h,c,r);
pIter(h);
}
n_Delete(&k,r->cf);
}
}
else
{
//if (r->cf->cfNormalize != nDummy2) //TODO: OPTIMIZE
if (rField_is_Q(r))
{
poly h = pNext(p1);
while (h!=NULL)
{
n_Normalize(pGetCoeff(h),r->cf);
pIter(h);
}
}
}
}
}
LIKELY
#define LIKELY(X)
Definition auxiliary.h:404
n_IsUnit
static FORCE_INLINE BOOLEAN n_IsUnit(number n, const coeffs r)
TRUE iff n has a multiplicative inverse in the given coeff field/ring r.
Definition coeffs.h:521

## p_Normalize()

void p_Normalize | ( | poly | p,
|  | const ring | r )

Definition at line 3939 of file p_polys.cc.

{
const coeffs cf=r->cf;
/* Z/p, GF(p,n), R, long R/C, Nemo rings */
if (cf->cfNormalize==ndNormalize)
return;
while (p!=NULL)
{
// no test before n_Normalize: n_Normalize should fix problems
n_Normalize(pGetCoeff(p),cf);
pIter(p);
}
}
ndNormalize
void ndNormalize(number &, const coeffs)
Definition numbers.cc:191

## p_NSet()

poly p_NSet | ( | number | n,
|  | const ring | r )

returns the poly representing the number n, destroys n

Definition at line 1474 of file p_polys.cc.

{
if (n_IsZero(n,r->cf))
{
n_Delete(&n, r->cf);
return NULL;
}
else
{
poly rc = p_Init(r);
pSetCoeff0(rc,n);
return rc;
}
}

## p_One()

poly p_One | ( | const ring | r | ) |

Definition at line 1314 of file p_polys.cc.

{
poly rc = p_Init(r);
pSetCoeff0(rc,n_Init(1,r->cf));
return rc;
}

## p_OneComp()

BOOLEAN p_OneComp | ( | poly | p,
|  | const ring | r )

return TRUE if all monoms have the same component

Definition at line 1209 of file p_polys.cc.

{
if(p!=NULL)
{
long i = p_GetComp(p, r);
while (pNext(p)!=NULL)
{
pIter(p);
if(i != p_GetComp(p, r)) return FALSE;
}
}
return TRUE;
}

## p_PermPoly()

poly p_PermPoly | ( | poly | p,
|  | const int * | perm,
|  | const ring | oldRing,
|  | const ring | dst,
|  | nMapFunc | nMap,
|  | const int * | par_perm,
|  | int | OldPar,
|  | BOOLEAN | use_mult )

Definition at line 4256 of file p_polys.cc.

{
#if 0
p_Test(p, oldRing);
PrintS("p_PermPoly::p: "); p_Write(p, oldRing, oldRing);
#endif
const int OldpVariables = rVar(oldRing);
poly result = NULL;
poly result_last = NULL;
poly aq = NULL; /* the map coefficient */
poly qq; /* the mapped monomial */
assume(dst != NULL);
assume(dst->cf != NULL);
#ifdef HAVE_PLURAL
poly tmp_mm=p_One(dst);
#endif
while (p != NULL)
{
// map the coefficient
if ( ((OldPar == 0) || (par_perm == NULL) || rField_is_GF(oldRing) || (nMap==ndCopyMap))
&& (nMap != NULL) )
{
qq = p_Init(dst);
assume( nMap != NULL );
number n = nMap(p_GetCoeff(p, oldRing), oldRing->cf, dst->cf);
n_Test (n,dst->cf);
if ( nCoeff_is_algExt(dst->cf) )
n_Normalize(n, dst->cf);
p_GetCoeff(qq, dst) = n;// Note: n can be a ZERO!!!
}
else
{
qq = p_One(dst);
// aq = naPermNumber(p_GetCoeff(p, oldRing), par_perm, OldPar, oldRing); // no dst???
// poly n_PermNumber(const number z, const int *par_perm, const int P, const ring src, const ring dst)
aq = n_PermNumber(p_GetCoeff(p, oldRing), par_perm, OldPar, oldRing, dst);
p_Test(aq, dst);
if ( nCoeff_is_algExt(dst->cf) )
p_Normalize(aq,dst);
if (aq == NULL)
p_SetCoeff(qq, n_Init(0, dst->cf),dst); // Very dirty trick!!!
p_Test(aq, dst);
}
if (rRing_has_Comp(dst))
p_SetComp(qq, p_GetComp(p, oldRing), dst);
if ( n_IsZero(pGetCoeff(qq), dst->cf) )
{
p_LmDelete(&qq,dst);
qq = NULL;
}
else
{
// map pars:
int mapped_to_par = 0;
for(int i = 1; i <= OldpVariables; i++)
{
int e = p_GetExp(p, i, oldRing);
if (e != 0)
{
if (perm==NULL)
p_SetExp(qq, i, e, dst);
else if (perm[i]>0)
{
#ifdef HAVE_PLURAL
if(use_mult)
{
p_SetExp(tmp_mm,perm[i],e,dst);
p_Setm(tmp_mm,dst);
qq=p_Mult_mm(qq,tmp_mm,dst);
p_SetExp(tmp_mm,perm[i],0,dst);
}
else
#endif
p_AddExp(qq,perm[i], e/*p_GetExp( p,i,oldRing)*/, dst);
}
else if (perm[i]<0)
{
number c = p_GetCoeff(qq, dst);
if (rField_is_GF(dst))
{
assume( dst->cf->extRing == NULL );
number ee = n_Param(1, dst);
number eee;
n_Power(ee, e, &eee, dst->cf); //nfDelete(ee,dst);
ee = n_Mult(c, eee, dst->cf);
//nfDelete(c,dst);nfDelete(eee,dst);
pSetCoeff0(qq,ee);
}
else if (nCoeff_is_Extension(dst->cf))
{
const int par = -perm[i];
assume( par > 0 );
// WarnS("longalg missing 3");
#if 1
const coeffs C = dst->cf;
assume( C != NULL );
const ring R = C->extRing;
assume( R != NULL );
assume( par <= rVar(R) );
poly pcn; // = (number)c
assume( !n_IsZero(c, C) );
if( nCoeff_is_algExt(C) )
pcn = (poly) c;
else // nCoeff_is_transExt(C)
pcn = NUM((fraction)c);
if (pNext(pcn) == NULL) // c->z
p_AddExp(pcn, -perm[i], e, R);
else /* more difficult: we have really to multiply: */
{
poly mmc = p_ISet(1, R);
p_SetExp(mmc, -perm[i], e, R);
p_Setm(mmc, R);
number nnc;
// convert back to a number: number nnc = mmc;
if( nCoeff_is_algExt(C) )
nnc = (number) mmc;
else // nCoeff_is_transExt(C)
nnc = ntInit(mmc, C);
p_GetCoeff(qq, dst) = n_Mult((number)c, nnc, C);
n_Delete((number *)&c, C);
n_Delete((number *)&nnc, C);
}
mapped_to_par=1;
#endif
}
}
else
{
/* this variable maps to 0 !*/
p_LmDelete(&qq, dst);
break;
}
}
}
if ( mapped_to_par && (qq!= NULL) && nCoeff_is_algExt(dst->cf) )
{
number n = p_GetCoeff(qq, dst);
n_Normalize(n, dst->cf);
p_GetCoeff(qq, dst) = n;
}
}
pIter(p);
#if 0
p_Test(aq,dst);
PrintS("aq: "); p_Write(aq, dst, dst);
#endif
#if 1
if (qq!=NULL)
{
p_Setm(qq,dst);
p_Test(aq,dst);
p_Test(qq,dst);
#if 0
PrintS("qq: "); p_Write(qq, dst, dst);
#endif
if (aq!=NULL)
qq=p_Mult_q(aq,qq,dst);
aq = qq;
while (pNext(aq) != NULL) pIter(aq);
if (result_last==NULL)
{
result=qq;
}
else
{
pNext(result_last)=qq;
}
result_last=aq;
aq = NULL;
}
else if (aq!=NULL)
{
p_Delete(&aq,dst);
}
}
result=p_SortAdd(result,dst);
#else
// if (qq!=NULL)
// {
// pSetm(qq);
// pTest(qq);
// pTest(aq);
// if (aq!=NULL) qq=pMult(aq,qq);
// aq = qq;
// while (pNext(aq) != NULL) pIter(aq);
// pNext(aq) = result;
// aq = NULL;
// result = qq;
// }
// else if (aq!=NULL)
// {
// pDelete(&aq);
// }
//}
//p = result;
//result = NULL;
//while (p != NULL)
//{
// qq = p;
// pIter(p);
// qq->next = NULL;
// result = pAdd(result, qq);
//}
#endif
p_Test(result,dst);
#if 0
p_Test(result,dst);
PrintS("result: "); p_Write(result,dst,dst);
#endif
#ifdef HAVE_PLURAL
p_LmDelete(&tmp_mm,dst);
#endif
return result;
}
n_Param
static FORCE_INLINE number n_Param(const int iParameter, const coeffs r)
return the (iParameter^th) parameter as a NEW number NOTE: parameter numbering: 1....
Definition coeffs.h:778
nCoeff_is_Extension
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
Definition coeffs.h:841
ndCopyMap
number ndCopyMap(number a, const coeffs src, const coeffs dst)
Definition numbers.cc:293
rRing_has_Comp
#define rRing_has_Comp(r)
Definition monomials.h:266
n_PermNumber
poly n_PermNumber(const number z, const int *par_perm, const int, const ring src, const ring dst)
Definition p_polys.cc:4153
p_ISet
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
Definition p_polys.cc:1298
p_Write
void p_Write(poly p, ring lmRing, ring tailRing)
Definition polys0.cc:342
p_Mult_mm
static poly p_Mult_mm(poly p, poly m, const ring r)
Definition p_polys.h:1053
p_SortAdd
static poly p_SortAdd(poly p, const ring r, BOOLEAN revert=FALSE)
Definition p_polys.h:1240
rField_is_GF
static BOOLEAN rField_is_GF(const ring r)
Definition ring.h:527
ntInit
number ntInit(long i, const coeffs cf)
Definition transext.cc:704

## p_PolyDiv()

poly p_PolyDiv | ( | poly & | p,
|  | const poly | divisor,
|  | const BOOLEAN | needResult,
|  | const ring | r )

assumes that p and divisor are univariate polynomials in r, mentioning the same variable; assumes divisor != NULL; p may be NULL; assumes a global monomial ordering in r; performs polynomial division of p by divisor:

- afterwards p contains the remainder of the division, i.e., p_before = result * divisor + p_afterwards;
- if needResult == TRUE, then the method computes and returns 'result', otherwise NULL is returned (This parametrization can be used when one is only interested in the remainder of the division. In this case, the method will be slightly faster.) leaves divisor unmodified

Definition at line 1874 of file p_polys.cc.

{
assume(divisor != NULL);
if (p == NULL) return NULL;
poly result = NULL;
number divisorLC = p_GetCoeff(divisor, r);
int divisorLE = p_GetExp(divisor, 1, r);
while ((p != NULL) && (p_Deg(p, r) >= p_Deg(divisor, r)))
{
/* determine t = LT(p) / LT(divisor) */
poly t = p_ISet(1, r);
number c = n_Div(p_GetCoeff(p, r), divisorLC, r->cf);
n_Normalize(c,r->cf);
p_SetCoeff(t, c, r);
int e = p_GetExp(p, 1, r) - divisorLE;
p_SetExp(t, 1, e, r);
p_Setm(t, r);
if (needResult) result = p_Add_q(result, p_Copy(t, r), r);
p = p_Add_q(p, p_Neg(p_Mult_q(t, p_Copy(divisor, r), r), r), r);
}
return result;
}
p_Deg
long p_Deg(poly a, const ring r)
Definition p_polys.cc:586

## p_Pow()

poly p_Pow | ( | poly | p,
|  | int | i,
|  | const ring | r )

static

Definition at line 2183 of file p_polys.cc.

{
#ifdef HAVE_FLINT
#if __FLINT_RELEASE >= 20503
if ((i>16) && rField_is_Q(r))
{
fmpq_mpoly_ctx_t ctx;
if (!convSingRFlintR(ctx,r))
{
fmpq_mpoly_t pp,res;
fmpq_mpoly_init(res,ctx);
convSingPFlintMP(pp,ctx,p,pLength(p),r);
fmpq_mpoly_pow_ui(res,pp,i,ctx);
poly pres=convFlintMPSingP(res,ctx,r);
fmpq_mpoly_clear(res,ctx);
fmpq_mpoly_clear(pp,ctx);
fmpq_mpoly_ctx_clear(ctx);
return pres;
}
}
else if ((>17) && rField_is_Zp(r))
{
nmod_mpoly_ctx_t ctx;
if (!convSingRFlintR(ctx,r))
{
nmod_mpoly_t pp,res;
convSingPFlintMP(pp,ctx,p,pLength(p),r);
nmod_mpoly_init(res,ctx);
fq_nmod_mpoly_pow_ui(res,pp,i,ctx);
poly pres=convFlintMPSingP(res,ctx,r);
nmod_mpoly_clear(res,ctx);
nmod_mpoly_clear(pp,ctx);
nmod_mpoly_ctx_clear(ctx);
return pres;
}
}
#endif
#endif
poly rc = p_Copy(p,r);
i -= 2;
do
{
rc = p_Mult_q(rc,p_Copy(p,r),r);
p_Normalize(rc,r);
i--;
}
while (i != 0);
return p_Mult_q(rc,p,r);
}

## p_Pow_charp()

poly p_Pow_charp | ( | poly | p,
|  | int | i,
|  | const ring | r )

static

Definition at line 2233 of file p_polys.cc.

{
//assume char_p == i
poly h=p;
while(h!=NULL) { p_MonPower(h,i,r);pIter(h);}
return p;
}
p_MonPower
static poly p_MonPower(poly p, int exp, const ring r)
Definition p_polys.cc:2004

## p_Power()

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

Definition at line 2245 of file p_polys.cc.

{
poly rc=NULL;
if (i==0)
{
p_Delete(&p,r);
return p_One(r);
}
if(p!=NULL)
{
if ( (i > 0) && ((unsigned long ) i > (r->bitmask))
#ifdef HAVE_SHIFTBBA
&& (!rIsLPRing(r))
#endif
)
{
Werror("exponent %d is too large, max. is %ld",i,r->bitmask);
return NULL;
}
switch (i)
{
// cannot happen, see above
// case 0:
// {
// rc=pOne();
// pDelete(&p);
// break;
// }
case 1:
rc=p;
break;
case 2:
rc=p_Mult_q(p_Copy(p,r),p,r);
break;
default:
if (i < 0)
{
p_Delete(&p,r);
return NULL;
}
else
{
#ifdef HAVE_PLURAL
if (rIsNCRing(r)) /* in the NC case nothing helps :-( */
{
int j=i;
rc = p_Copy(p,r);
while (j>1)
{
rc = p_Mult_q(p_Copy(p,r),rc,r);
j--;
}
p_Delete(&p,r);
return rc;
}
#endif
rc = pNext(p);
if (rc == NULL)
return p_MonPower(p,i,r);
/* else: binom ?*/
int char_p=rInternalChar(r);
if ((char_p>0) && (i>char_p)
&& ((rField_is_Zp(r,char_p)
|| (rField_is_Zp_a(r,char_p)))))
{
poly h=p_Pow_charp(p_Copy(p,r),char_p,r);
int rest=i-char_p;
while (rest>=char_p)
{
rest-=char_p;
h=p_Mult_q(h,p_Pow_charp(p_Copy(p,r),char_p,r),r);
}
poly res=h;
if (rest>0)
res=p_Mult_q(p_Power(p_Copy(p,r),rest,r),h,r);
p_Delete(&p,r);
return res;
}
if ((pNext(rc) != NULL)
|| rField_is_Ring(r)
)
return p_Pow(p,i,r);
if ((char_p==0) || (i<=char_p)) /* && pNext(rc)==NULL */
return p_TwoMonPower(p,i,r);
return p_Pow(p,i,r);
}
/*end default:*/
}
}
return rc;
}
p_Power
poly p_Power(poly p, int i, const ring r)
Definition p_polys.cc:2245
p_TwoMonPower
static poly p_TwoMonPower(poly p, int exp, const ring r)
Definition p_polys.cc:2118
p_Pow_charp
static poly p_Pow_charp(poly p, int i, const ring r)
Definition p_polys.cc:2233
p_Pow
static poly p_Pow(poly p, int i, const ring r)
Definition p_polys.cc:2183
Werror
void Werror(const char *fmt,...)
Definition reporter.cc:189
rInternalChar
static int rInternalChar(const ring r)
Definition ring.h:695
rIsLPRing
static BOOLEAN rIsLPRing(const ring r)
Definition ring.h:417

## p_ProjectiveUnique()

void p_ProjectiveUnique | ( | poly | ph,
|  | const ring | r )

Definition at line 3191 of file p_polys.cc.

{
if( ph == NULL )
return;
const coeffs C = r->cf;
number h;
poly p;
if (nCoeff_is_Ring(C))
{
p_ContentForGB(ph,r);
if(!n_GreaterZero(pGetCoeff(ph),C)) ph = p_Neg(ph,r);
assume( n_GreaterZero(pGetCoeff(ph),C) );
return;
}
if (nCoeff_is_Zp(C) && TEST_OPT_INTSTRATEGY)
{
if(!n_GreaterZero(pGetCoeff(ph),C)) ph = p_Neg(ph,r);
return;
}
p = ph;
assume(p != NULL);
if(pNext(p)==NULL) // a monomial
{
p_SetCoeff(p, n_Init(1, C), r);
return;
}
assume(pNext(p)!=NULL);
if(!nCoeff_is_Q(C) && !nCoeff_is_transExt(C))
{
h = p_GetCoeff(p, C);
number hInv = n_Invers(h, C);
if(errorreported) return;
pIter(p);
while (p!=NULL)
{
p_SetCoeff(p, n_Mult(p_GetCoeff(p, C), hInv, C), r);
pIter(p);
}
n_Delete(&hInv, C);
p = ph;
p_SetCoeff(p, n_Init(1, C), r);
}
p_Cleardenom(ph, r); //removes also Content
/* normalize ph over a transcendental extension s.t.
lead (ph) is > 0 if extRing->cf == Q
or lead (ph) is monic if extRing->cf == Zp*/
if (nCoeff_is_transExt(C))
{
p= ph;
h= p_GetCoeff (p, C);
fraction f = (fraction) h;
number n=p_GetCoeff (NUM (f),C->extRing->cf);
if (rField_is_Q (C->extRing))
{
if (!n_GreaterZero(n,C->extRing->cf))
{
p=p_Neg (p,r);
}
}
else if (rField_is_Zp(C->extRing))
{
if (!n_IsOne (n, C->extRing->cf))
{
n=n_Invers (n,C->extRing->cf);
nMapFunc nMap;
nMap= n_SetMap (C->extRing->cf, C);
number ninv= nMap (n,C->extRing->cf, C);
p=__p_Mult_nn (p, ninv, r);
n_Delete (&ninv, C);
n_Delete (&n, C->extRing->cf);
}
}
p= ph;
}
return;
}
nCoeff_is_Ring
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
Definition coeffs.h:732
nCoeff_is_Zp
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition coeffs.h:795
p_Cleardenom
poly p_Cleardenom(poly p, const ring r)
Definition p_polys.cc:2893

## p_Read()

const char * p_Read | ( | const char * | st,
|  | poly & | rc,
|  | const ring | r )

Definition at line 1371 of file p_polys.cc.

{
if (r==NULL) { rc=NULL;return st;}
int i,j;
rc = p_Init(r);
const char *s = n_Read(st,&(p_GetCoeff(rc, r)),r->cf);
if (s==st)
/* i.e. it does not start with a coeff: test if it is a ringvar*/
{
j = r_IsRingVar(s,r->names,r->N);
if (j >= 0)
{
p_IncrExp(rc,1+j,r);
while (*s!='\0') s++;
goto done;
}
}
while (*s!='\0')
{
char ss[2];
ss[0] = *s++;
ss[1] = '\0';
j = r_IsRingVar(ss,r->names,r->N);
if (j >= 0)
{
const char *s_save=s;
s = eati(s,&i);
if (((unsigned long)i) > r->bitmask/2)
{
// exponent to large: it is not a monomial
p_LmDelete(&rc,r);
return s_save;
}
p_AddExp(rc,1+j, (long)i, r);
}
else
{
// 1st char of is not a varname
// We return the parsed polynomial nevertheless. This is needed when
// we are parsing coefficients in a rational function field.
s--;
break;
}
}
done:
if (n_IsZero(pGetCoeff(rc),r->cf)) p_LmDelete(&rc,r);
else
{
#ifdef HAVE_PLURAL
// in super-commutative ring
// squares of anti-commutative variables are zeroes!
if(rIsSCA(r))
{
const unsigned int iFirstAltVar = scaFirstAltVar(r);
const unsigned int iLastAltVar = scaLastAltVar(r);
assume(rc != NULL);
for(unsigned int k = iFirstAltVar; k <= iLastAltVar; k++)
if( p_GetExp(rc, k, r) > 1 )
{
p_LmDelete(&rc, r);
goto finish;
}
}
#endif
p_Setm(rc,r);
}
finish:
return s;
}
n_Read
static FORCE_INLINE const char * n_Read(const char *s, number *a, const coeffs r)
!!! Recommendation: This method is too cryptic to be part of the user- !!! interface....
Definition coeffs.h:601
eati
const char * eati(const char *s, int *i)
Definition reporter.cc:377
rIsSCA
static bool rIsSCA(const ring r)
Definition nc.h:190
p_IncrExp
static long p_IncrExp(poly p, int v, ring r)
Definition p_polys.h:593
r_IsRingVar
int r_IsRingVar(const char *n, char **names, int N)
Definition ring.cc:213
scaLastAltVar
static short scaLastAltVar(ring r)
Definition sca.h:25
scaFirstAltVar
static short scaFirstAltVar(ring r)
Definition sca.h:18

## p_Series()

poly p_Series | ( | int | n,
|  | poly | p,
|  | poly | u,
|  | intvec * | w,
|  | const ring | R )

Definition at line 4652 of file p_polys.cc.

{
int *ww=iv2array(w,R);
if(p!=NULL)
{
if(u==NULL)
p=p_JetW(p,n,ww,R);
else
p=p_JetW(p_Mult_q(p,p_Invers(n-p_MinDeg(p,w,R),u,w,R),R),n,ww,R);
}
omFreeSize((ADDRESS)ww,(rVar(R)+1)*sizeof(int));
return p;
}
p_Invers
static poly p_Invers(int n, poly u, intvec *w, const ring R)
Definition p_polys.cc:4623

## p_Setm_Dummy()

void p_Setm_Dummy | ( | poly | p,
|  | const ring | r )

Definition at line 540 of file p_polys.cc.

{
p_LmCheckPolyRing(p, r);
}

## p_Setm_General()

void p_Setm_General | ( | poly | p,
|  | const ring | r )

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

Definition at line 158 of file p_polys.cc.

{
p_LmCheckPolyRing(p, r);
int pos=0;
if (r->typ!=NULL)
{
loop
{
unsigned long ord=0;
sro_ord* o=&(r->typ[pos]);
switch(o->ord_typ)
{
case ro_dp:
{
int a,e;
a=o->data.dp.start;
e=o->data.dp.end;
for(int i=a;i<=e;i++) ord+=p_GetExp(p,i,r);
p->exp[o->data.dp.place]=ord;
break;
}
case ro_wp_neg:
ord=POLY_NEGWEIGHT_OFFSET; // no break;
case ro_wp:
{
int a,e;
a=o->data.wp.start;
e=o->data.wp.end;
int *w=o->data.wp.weights;
#if 1
for(int i=a;i<=e;i++) ord+=((unsigned long)p_GetExp(p,i,r))*((unsigned long)w[i-a]);
#else
long ai;
int ei,wi;
for(int i=a;i<=e;i++)
{
ei=p_GetExp(p,i,r);
wi=w[i-a];
ai=ei*wi;
if (ai/ei!=wi) pSetm_error=TRUE;
ord+=ai;
if (ord<ai) pSetm_error=TRUE;
}
#endif
p->exp[o->data.wp.place]=ord;
break;
}
case ro_am:
{
ord = POLY_NEGWEIGHT_OFFSET;
const short a=o->data.am.start;
const short e=o->data.am.end;
const int * w=o->data.am.weights;
#if 1
for(short i=a; i<=e; i++, w++)
ord += ((*w) * p_GetExp(p,i,r));
#else
long ai;
int ei,wi;
for(short i=a;i<=e;i++)
{
ei=p_GetExp(p,i,r);
wi=w[i-a];
ai=ei*wi;
if (ai/ei!=wi) pSetm_error=TRUE;
ord += ai;
if (ord<ai) pSetm_error=TRUE;
}
#endif
const int c = p_GetComp(p,r);
const short len_gen= o->data.am.len_gen;
if ((c > 0) && (c <= len_gen))
{
assume( w == o->data.am.weights_m );
assume( w[0] == len_gen );
ord += w[c];
}
p->exp[o->data.am.place] = ord;
break;
}
case ro_wp64:
{
int64 ord=0;
int a,e;
a=o->data.wp64.start;
e=o->data.wp64.end;
int64 *w=o->data.wp64.weights64;
int64 ei,wi,ai;
for(int i=a;i<=e;i++)
{
//Print("exp %d w %d \n",p_GetExp(p,i,r),(int)w[i-a]);
//ord+=((int64)p_GetExp(p,i,r))*w[i-a];
ei=(int64)p_GetExp(p,i,r);
wi=w[i-a];
ai=ei*wi;
if(ei!=0 && ai/ei!=wi)
{
pSetm_error=TRUE;
#if SIZEOF_LONG == 4
Print("ai %lld, wi %lld\n",ai,wi);
#else
Print("ai %ld, wi %ld\n",ai,wi);
#endif
}
ord+=ai;
if (ord<ai)
{
pSetm_error=TRUE;
#if SIZEOF_LONG == 4
Print("ai %lld, ord %lld\n",ai,ord);
#else
Print("ai %ld, ord %ld\n",ai,ord);
#endif
}
}
#if SIZEOF_LONG == 4
int64 mask=(int64)0x7fffffff;
long a_0=(long)(ord&mask); //2^31
long a_1=(long)(ord >>31 ); /*(ord/(mask+1));*/
//Print("mask: %x, ord: %d, a_0: %d, a_1: %d\n"
//,(int)mask,(int)ord,(int)a_0,(int)a_1);
//Print("mask: %d",mask);
p->exp[o->data.wp64.place]=a_1;
p->exp[o->data.wp64.place+1]=a_0;
#elif SIZEOF_LONG == 8
p->exp[o->data.wp64.place]=ord;
#endif
// if(p_Setm_error) PrintS("***************************\n"
// "***************************\n"
// "**WARNING: overflow error**\n"
// "***************************\n"
// "***************************\n");
break;
}
case ro_cp:
{
int a,e;
a=o->data.cp.start;
e=o->data.cp.end;
int pl=o->data.cp.place;
for(int i=a;i<=e;i++) { p->exp[pl]=p_GetExp(p,i,r); pl++; }
break;
}
case ro_syzcomp:
{
long c=__p_GetComp(p,r);
long sc = c;
int* Components = (_componentsExternal ? _components :
o->data.syzcomp.Components);
long* ShiftedComponents = (_componentsExternal ? _componentsShifted:
o->data.syzcomp.ShiftedComponents);
if (ShiftedComponents != NULL)
{
assume(Components != NULL);
assume(c == 0 || Components[c] != 0);
sc = ShiftedComponents[Components[c]];
assume(c == 0 || sc != 0);
}
p->exp[o->data.syzcomp.place]=sc;
break;
}
case ro_syz:
{
const unsigned long c = __p_GetComp(p, r);
const short place = o->data.syz.place;
const int limit = o->data.syz.limit;
if (c > (unsigned long)limit)
p->exp[place] = o->data.syz.curr_index;
else if (c > 0)
{
assume( (1 <= c) && (c <= (unsigned long)limit) );
p->exp[place]= o->data.syz.syz_index[c];
}
else
{
assume(c == 0);
p->exp[place]= 0;
}
break;
}
// Prefix for Induced Schreyer ordering
case ro_isTemp: // Do nothing?? (to be removed into suffix later on...?)
{
assume(p != NULL);
#ifndef SING_NDEBUG
#if MYTEST
Print("p_Setm_General: ro_isTemp ord: pos: %d, p: ", pos); p_wrp(p, r);
#endif
#endif
int c = p_GetComp(p, r);
assume( c >= 0 );
// Let's simulate case ro_syz above....
// Should accumulate (by Suffix) and be a level indicator
const int* const pVarOffset = o->data.isTemp.pVarOffset;
assume( pVarOffset != NULL );
// TODO: Can this be done in the suffix???
for( int i = 1; i <= r->N; i++ ) // No v[0] here!!!
{
const int vo = pVarOffset[i];
if( vo != -1) // TODO: optimize: can be done once!
{
// Hans! Please don't break it again! p_SetExp(p, ..., r, vo) is correct:
p_SetExp(p, p_GetExp(p, i, r), r, vo); // copy put them verbatim
// Hans! Please don't break it again! p_GetExp(p, r, vo) is correct:
assume( p_GetExp(p, r, vo) == p_GetExp(p, i, r) ); // copy put them verbatim
}
}
#ifndef SING_NDEBUG
for( int i = 1; i <= r->N; i++ ) // No v[0] here!!!
{
const int vo = pVarOffset[i];
if( vo != -1) // TODO: optimize: can be done once!
{
// Hans! Please don't break it again! p_GetExp(p, r, vo) is correct:
assume( p_GetExp(p, r, vo) == p_GetExp(p, i, r) ); // copy put them verbatim
}
}
#if MYTEST
// if( p->exp[o->data.isTemp.start] > 0 )
PrintS("after Values: "); p_wrp(p, r);
#endif
#endif
break;
}
// Suffix for Induced Schreyer ordering
case ro_is:
{
#ifndef SING_NDEBUG
#if MYTEST
Print("p_Setm_General: ro_is ord: pos: %d, p: ", pos); p_wrp(p, r);
#endif
#endif
assume(p != NULL);
int c = p_GetComp(p, r);
assume( c >= 0 );
const ideal F = o->data.is.F;
const int limit = o->data.is.limit;
assume( limit >= 0 );
const int start = o->data.is.start;
if( F != NULL && c > limit )
{
#ifndef SING_NDEBUG
#if MYTEST
Print("p_Setm_General: ro_is : in rSetm: pos: %d, c: %d > limit: %d\n", c, pos, limit);
PrintS("preComputed Values: ");
p_wrp(p, r);
#endif
#endif
// if( c > limit ) // BUG???
p->exp[start] = 1;
// else
// p->exp[start] = 0;
c -= limit;
assume( c > 0 );
c--;
if( c >= IDELEMS(F) )
break;
assume( c < IDELEMS(F) ); // What about others???
const poly pp = F->m[c]; // get reference monomial!!!
if(pp == NULL)
break;
assume(pp != NULL);
#ifndef SING_NDEBUG
#if MYTEST
Print("Respective F[c - %d: %d] pp: ", limit, c);
p_wrp(pp, r);
#endif
#endif
const int end = o->data.is.end;
assume(start <= end);
// const int st = o->data.isTemp.start;
#ifndef SING_NDEBUG
#if MYTEST
Print("p_Setm_General: is(-Temp-) :: c: %d, limit: %d, [st:%d] ===>>> %ld\n", c, limit, start, p->exp[start]);
#endif
#endif
// p_ExpVectorAdd(p, pp, r);
for( int i = start; i <= end; i++) // v[0] may be here...
p->exp[i] += pp->exp[i]; // !!!!!!!! ADD corresponding LT(F)
// p_MemAddAdjust(p, ri);
if (r->NegWeightL_Offset != NULL)
{
for (int i=r->NegWeightL_Size-1; i>=0; i--)
{
const int _i = r->NegWeightL_Offset[i];
if( start <= _i && _i <= end )
p->exp[_i] -= POLY_NEGWEIGHT_OFFSET;
}
}
#ifndef SING_NDEBUG
const int* const pVarOffset = o->data.is.pVarOffset;
assume( pVarOffset != NULL );
for( int i = 1; i <= r->N; i++ ) // No v[0] here!!!
{
const int vo = pVarOffset[i];
if( vo != -1) // TODO: optimize: can be done once!
// Hans! Please don't break it again! p_GetExp(p/pp, r, vo) is correct:
assume( p_GetExp(p, r, vo) == (p_GetExp(p, i, r) + p_GetExp(pp, r, vo)) );
}
// TODO: how to check this for computed values???
#if MYTEST
PrintS("Computed Values: "); p_wrp(p, r);
#endif
#endif
} else
{
p->exp[start] = 0; //!!!!????? where?????
const int* const pVarOffset = o->data.is.pVarOffset;
// What about v[0] - component: it will be added later by
// suffix!!!
// TODO: Test it!
const int vo = pVarOffset[0];
if( vo != -1 )
p->exp[vo] = c; // initial component v[0]!
#ifndef SING_NDEBUG
#if MYTEST
Print("ELSE p_Setm_General: ro_is :: c: %d <= limit: %d, vo: %d, exp: %d\n", c, limit, vo, p->exp[vo]);
p_wrp(p, r);
#endif
#endif
}
break;
}
default:
dReportError("wrong ord in rSetm:%d\n",o->ord_typ);
return;
}
pos++;
if (pos == r->OrdSize) return;
}
}
}
int64
long int64
Definition auxiliary.h:68
Print
#define Print
Definition emacs.cc:80
dReportError
int dReportError(const char *fmt,...)
Definition dError.cc:44
POLY_NEGWEIGHT_OFFSET
#define POLY_NEGWEIGHT_OFFSET
Definition monomials.h:236
_componentsExternal
STATIC_VAR int _componentsExternal
Definition p_polys.cc:148
_componentsShifted
STATIC_VAR long * _componentsShifted
Definition p_polys.cc:147
pSetm_error
VAR BOOLEAN pSetm_error
Definition p_polys.cc:150
_components
STATIC_VAR int * _components
Definition p_polys.cc:146
p_wrp
void p_wrp(poly p, ring lmRing, ring tailRing)
Definition polys0.cc:373
sro_ord::ord_typ
ro_typ ord_typ
Definition ring.h:226
ro_wp64
@ ro_wp64
Definition ring.h:56
ro_syz
@ ro_syz
Definition ring.h:61
ro_cp
@ ro_cp
Definition ring.h:59
ro_is
@ ro_is
Definition ring.h:62
ro_wp_neg
@ ro_wp_neg
Definition ring.h:57
ro_isTemp
@ ro_isTemp
Definition ring.h:62
ro_am
@ ro_am
Definition ring.h:55
ro_syzcomp
@ ro_syzcomp
Definition ring.h:60
sro_ord::data
union sro_ord::@006200034235045362245112336324125006204215012002 data
sro_ord
Definition ring.h:225
IDELEMS
#define IDELEMS(i)
Definition simpleideals.h:23

## p_Setm_Syz()

void p_Setm_Syz | ( | poly | p,
|  | ring | r,
|  | int * | Components,
|  | long * | ShiftedComponents )

Definition at line 530 of file p_polys.cc.

{
_components = Components;
_componentsShifted = ShiftedComponents;
_componentsExternal = 1;
p_Setm_General(p, r);
_componentsExternal = 0;
}

## p_Setm_TotalDegree()

void p_Setm_TotalDegree | ( | poly | p,
|  | const ring | r )

Definition at line 546 of file p_polys.cc.

{
p_LmCheckPolyRing(p, r);
p->exp[r->pOrdIndex] = p_Totaldegree(p, r);
}

## p_Setm_WFirstTotalDegree()

void p_Setm_WFirstTotalDegree | ( | poly | p,
|  | const ring | r )

Definition at line 553 of file p_polys.cc.

{
p_LmCheckPolyRing(p, r);
p->exp[r->pOrdIndex] = p_WFirstTotalDegree(p, r);
}
p_WFirstTotalDegree
long p_WFirstTotalDegree(poly p, const ring r)
Definition p_polys.cc:595

## p_SetModDeg()

void p_SetModDeg | ( | intvec * | w,
|  | ring | r )

Definition at line 3798 of file p_polys.cc.

{
if (w!=NULL)
{
r->pModW = w;
pOldFDeg = r->pFDeg;
pOldLDeg = r->pLDeg;
pOldLexOrder = r->pLexOrder;
pSetDegProcs(r,pModDeg);
r->pLexOrder = TRUE;
}
else
{
r->pModW = NULL;
pRestoreDegProcs(r,pOldFDeg, pOldLDeg);
r->pLexOrder = pOldLexOrder;
}
}
pOldLDeg
STATIC_VAR pLDegProc pOldLDeg
Definition p_polys.cc:3786
pRestoreDegProcs
void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
Definition p_polys.cc:3774
pOldLexOrder
STATIC_VAR BOOLEAN pOldLexOrder
Definition p_polys.cc:3787
pOldFDeg
STATIC_VAR pFDegProc pOldFDeg
Definition p_polys.cc:3785
pSetDegProcs
void pSetDegProcs(ring r, pFDegProc new_FDeg, pLDegProc new_lDeg)
Definition p_polys.cc:3762
pModDeg
static long pModDeg(poly p, ring r)
Definition p_polys.cc:3789

## p_Shift()

void p_Shift | ( | poly * | p,
|  | int | i,
|  | const ring | r )

shifts components of the vector p by i

Definition at line 4860 of file p_polys.cc.

{
poly qp1 = *p,qp2 = *p;/*working pointers*/
int j = p_MaxComp(*p,r),k = p_MinComp(*p,r);
if (j+i < 0) return ;
BOOLEAN toPoly= ((j == -i) && (j == k));
while (qp1 != NULL)
{
if (toPoly || (__p_GetComp(qp1,r)+i > 0))
{
p_AddComp(qp1,i,r);
p_SetmComp(qp1,r);
qp2 = qp1;
pIter(qp1);
}
else
{
if (qp2 == *p)
{
pIter(*p);
p_LmDelete(&qp2,r);
qp2 = *p;
qp1 = *p;
}
else
{
qp2->next = qp1->next;
if (qp1!=NULL) p_LmDelete(&qp1,r);
qp1 = qp2->next;
}
}
}
}
return
return
Definition cfGcdAlgExt.cc:219
p_MinComp
static long p_MinComp(poly p, ring lmRing, ring tailRing)
Definition p_polys.h:315
p_AddComp
static unsigned long p_AddComp(poly p, unsigned long v, ring r)
Definition p_polys.h:449
p_MaxComp
static long p_MaxComp(poly p, ring lmRing, ring tailRing)
Definition p_polys.h:294

## p_SimpleContent()

void p_SimpleContent | ( | poly | ph,
|  | int | smax,
|  | const ring | r )

Definition at line 2612 of file p_polys.cc.

{
if(TEST_OPT_CONTENTSB) return;
if (ph==NULL) return;
if (pNext(ph)==NULL)
{
p_SetCoeff(ph,n_Init(1,r->cf),r);
return;
}
if (pNext(pNext(ph))==NULL)
{
return;
}
if (!(rField_is_Q(r))
&& (!rField_is_Q_a(r))
&& (!rField_is_Zp_a(r))
&& (!rField_is_Z(r))
)
{
return;
}
number d=p_InitContent(ph,r);
number h=d;
if (n_Size(d,r->cf)<=smax)
{
n_Delete(&h,r->cf);
//if (TEST_OPT_PROT) PrintS("G");
return;
}
poly p=ph;
if (smax==1) smax=2;
while (p!=NULL)
{
#if 1
d=n_SubringGcd(h,pGetCoeff(p),r->cf);
n_Delete(&h,r->cf);
h = d;
#else
n_InpGcd(h,pGetCoeff(p),r->cf);
#endif
if(n_Size(h,r->cf)<smax)
{
//if (TEST_OPT_PROT) PrintS("g");
n_Delete(&h,r->cf);
return;
}
pIter(p);
}
p = ph;
if (!n_GreaterZero(pGetCoeff(p),r->cf)) h=n_InpNeg(h,r->cf);
if(n_IsOne(h,r->cf))
{
n_Delete(&h,r->cf);
return;
}
if (TEST_OPT_PROT) PrintS("c");
while (p!=NULL)
{
#if 1
d = n_ExactDiv(pGetCoeff(p),h,r->cf);
p_SetCoeff(p,d,r);
#else
STATISTIC(n_ExactDiv); nlInpExactDiv(pGetCoeff(p),h,r->cf); // no such function... ?
#endif
pIter(p);
}
n_Delete(&h,r->cf);
}
TEST_OPT_PROT
#define TEST_OPT_PROT
Definition options.h:105

## p_Size()

int p_Size | ( | poly | p,
|  | const ring | r )

Definition at line 3302 of file p_polys.cc.

{
int count = 0;
if (r->cf->has_simple_Alloc)
return pLength(p);
while ( p != NULL )
{
count+= n_Size( pGetCoeff( p ), r->cf );
pIter( p );
}
return count;
}
count
int status int void size_t count
Definition si_signals.h:69

## p_Split()

void p_Split | ( | poly | p,
|  | poly * | h )

Definition at line 1321 of file p_polys.cc.

{
*h=pNext(p);
pNext(p)=NULL;
}

## p_SplitAndReversePoly()

void p_SplitAndReversePoly | ( | poly | p,
|  | int | n,
|  | poly * | non_zero,
|  | poly * | zero,
|  | const ring | r )

static

Definition at line 3955 of file p_polys.cc.

{
if (p == NULL)
{
*non_zero = NULL;
*zero = NULL;
return;
}
spolyrec sz;
poly z, n_z, next;
z = &sz;
n_z = NULL;
while(p != NULL)
{
next = pNext(p);
if (p_GetExp(p, n,r) == 0)
{
pNext(z) = p;
pIter(z);
}
else
{
pNext(p) = n_z;
n_z = p;
}
p = next;
}
pNext(z) = NULL;
*zero = pNext(&sz);
*non_zero = n_z;
}
spolyrec
Definition monomials.h:23

## p_Sub()

poly p_Sub | ( | poly | p1,
|  | poly | p2,
|  | const ring | r )

Definition at line 1994 of file p_polys.cc.

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

## p_Subst()

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

Definition at line 4084 of file p_polys.cc.

{
#ifdef HAVE_SHIFTBBA
// also don't even use p_Subst0 for Letterplace
if (rIsLPRing(r))
{
poly subst = p_LPSubst(p, n, e, r);
p_Delete(&p, r);
return subst;
}
#endif
if (e == NULL) return p_Subst0(p, n,r);
if (p_IsConstant(e,r))
{
if (n_IsOne(pGetCoeff(e),r->cf)) return p_Subst1(p,n,r);
else return p_Subst2(p, n, pGetCoeff(e),r);
}
#ifdef HAVE_PLURAL
if (rIsPluralRing(r))
{
return nc_pSubst(p,n,e,r);
}
#endif
int exponent,i;
poly h, res, m;
int *me,*ee;
number nu,nu1;
me=(int *)omAlloc((rVar(r)+1)*sizeof(int));
ee=(int *)omAlloc((rVar(r)+1)*sizeof(int));
if (e!=NULL) p_GetExpV(e,ee,r);
res=NULL;
h=p;
while (h!=NULL)
{
if ((e!=NULL) || (p_GetExp(h,n,r)==0))
{
m=p_Head(h,r);
p_GetExpV(m,me,r);
exponent=me[n];
me[n]=0;
for(i=rVar(r);i>0;i--)
me[i]+=exponent*ee[i];
p_SetExpV(m,me,r);
if (e!=NULL)
{
n_Power(pGetCoeff(e),exponent,&nu,r->cf);
nu1=n_Mult(pGetCoeff(m),nu,r->cf);
n_Delete(&nu,r->cf);
p_SetCoeff(m,nu1,r);
}
res=p_Add_q(res,m,r);
}
p_LmDelete(&h,r);
}
omFreeSize((ADDRESS)me,(rVar(r)+1)*sizeof(int));
omFreeSize((ADDRESS)ee,(rVar(r)+1)*sizeof(int));
return res;
}
subst
CanonicalForm subst(const CanonicalForm &f, const CFList &a, const CFList &b, const CanonicalForm &Rstar, bool isFunctionField)
Definition facAlgFuncUtil.cc:120
nc_pSubst
poly nc_pSubst(poly p, int n, poly e, const ring r)
substitute the n-th variable by e in p destroy p e is not a constant
Definition old.gring.cc:3185
p_Subst0
static poly p_Subst0(poly p, int n, const ring r)
Definition p_polys.cc:4059
p_Subst1
static poly p_Subst1(poly p, int n, const ring r)
Definition p_polys.cc:3991
p_Subst2
static poly p_Subst2(poly p, int n, number e, const ring r)
Definition p_polys.cc:4018
rIsPluralRing
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition ring.h:406
p_LPSubst
poly p_LPSubst(poly p, int n, poly e, const ring r)
Definition shiftop.cc:912

## p_Subst0()

poly p_Subst0 | ( | poly | p,
|  | int | n,
|  | const ring | r )

static

Definition at line 4059 of file p_polys.cc.

{
spolyrec res;
poly h = &res;
pNext(h) = p;
while (pNext(h)!=NULL)
{
if (p_GetExp(pNext(h),n,r)!=0)
{
p_LmDelete(&pNext(h),r);
}
else
{
pIter(h);
}
}
p_Test(pNext(&res),r);
return pNext(&res);
}

## p_Subst1()

poly p_Subst1 | ( | poly | p,
|  | int | n,
|  | const ring | r )

static

Definition at line 3991 of file p_polys.cc.

{
poly qq=NULL, result = NULL;
poly zero=NULL, non_zero=NULL;
// reverse, so that add is likely to be linear
p_SplitAndReversePoly(p, n, &non_zero, &zero,r);
while (non_zero != NULL)
{
assume(p_GetExp(non_zero, n,r) != 0);
qq = non_zero;
pIter(non_zero);
qq->next = NULL;
p_SetExp(qq,n,0,r);
p_Setm(qq,r);
result = p_Add_q(result,qq,r);
}
p = p_Add_q(result, zero,r);
p_Test(p,r);
return p;
}
p_SplitAndReversePoly
static void p_SplitAndReversePoly(poly p, int n, poly *non_zero, poly *zero, const ring r)
Definition p_polys.cc:3955

## p_Subst2()

poly p_Subst2 | ( | poly | p,
|  | int | n,
|  | number | e,
|  | const ring | r )

static

Definition at line 4018 of file p_polys.cc.

{
assume( ! n_IsZero(e,r->cf) );
poly qq,result = NULL;
number nn, nm;
poly zero, non_zero;
// reverse, so that add is likely to be linear
p_SplitAndReversePoly(p, n, &non_zero, &zero,r);
while (non_zero != NULL)
{
assume(p_GetExp(non_zero, n, r) != 0);
qq = non_zero;
pIter(non_zero);
qq->next = NULL;
n_Power(e, p_GetExp(qq, n, r), &nn,r->cf);
nm = n_Mult(nn, pGetCoeff(qq),r->cf);
#ifdef HAVE_RINGS
if (n_IsZero(nm,r->cf))
{
p_LmFree(&qq,r);
n_Delete(&nm,r->cf);
}
else
#endif
{
p_SetCoeff(qq, nm,r);
p_SetExp(qq, n, 0,r);
p_Setm(qq,r);
result = p_Add_q(result,qq,r);
}
n_Delete(&nn,r->cf);
}
p = p_Add_q(result, zero,r);
p_Test(p,r);
return p;
}

## p_TakeOutComp() [1/2]

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

Definition at line 3543 of file p_polys.cc.

{
poly q = *p,qq=NULL,result = NULL;
unsigned long kk=(unsigned long)k;
if (q==NULL) return NULL;
BOOLEAN use_setmcomp=rOrd_SetCompRequiresSetm(r);
if (__p_GetComp(q,r)==kk)
{
result = q;
if (UNLIKELY(use_setmcomp))
{
do
{
p_SetComp(q,0,r);
p_SetmComp(q,r);
qq = q;
pIter(q);
}
while ((q!=NULL) && (__p_GetComp(q,r)==kk));
}
else
{
do
{
p_SetComp(q,0,r);
qq = q;
pIter(q);
}
while ((q!=NULL) && (__p_GetComp(q,r)==kk));
}
*p = q;
pNext(qq) = NULL;
}
if (q==NULL) return result;
if (__p_GetComp(q,r) > kk)
{
p_SubComp(q,1,r);
if (use_setmcomp) p_SetmComp(q,r);
}
poly pNext_q;
while ((pNext_q=pNext(q))!=NULL)
{
unsigned long c=__p_GetComp(pNext_q,r);
if (/*__p_GetComp(pNext_q,r)*/c==kk)
{
if (result==NULL)
{
result = pNext_q;
qq = result;
}
else
{
pNext(qq) = pNext_q;
pIter(qq);
}
pNext(q) = pNext(pNext_q);
pNext(qq) =NULL;
p_SetComp(qq,0,r);
if (use_setmcomp) p_SetmComp(qq,r);
}
else
{
/*pIter(q);*/ q=pNext_q;
if (/*__p_GetComp(q,r)*/c > kk)
{
p_SubComp(q,1,r);
if (use_setmcomp) p_SetmComp(q,r);
}
}
}
return result;
}
rOrd_SetCompRequiresSetm
BOOLEAN rOrd_SetCompRequiresSetm(const ring r)
return TRUE if p_SetComp requires p_Setm
Definition ring.cc:2023

## p_TakeOutComp() [2/2]

void p_TakeOutComp | ( | poly * | r_p,
|  | long | comp,
|  | poly * | r_q,
|  | int * | lq,
|  | const ring | r )

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

Definition at line 3620 of file p_polys.cc.

{
spolyrec pp, qq;
poly p, q, p_prev;
int l = 0;
#ifndef SING_NDEBUG
int lp = pLength(*r_p);
#endif
pNext(&pp) = *r_p;
p = *r_p;
p_prev = &pp;
q = &qq;
while(p != NULL)
{
while (__p_GetComp(p,r) == (unsigned long)comp)
{
pNext(q) = p;
pIter(q);
p_SetComp(p, 0,r);
p_SetmComp(p,r);
pIter(p);
l++;
if (p == NULL)
{
pNext(p_prev) = NULL;
goto Finish;
}
}
pNext(p_prev) = p;
p_prev = p;
pIter(p);
}
Finish:
pNext(q) = NULL;
*r_p = pNext(&pp);
*r_q = pNext(&qq);
*lq = l;
#ifndef SING_NDEBUG
assume(pLength(*r_p) + pLength(*r_q) == lp);
#endif
p_Test(*r_p,r);
p_Test(*r_q,r);
}
comp
int comp(const CanonicalForm &A, const CanonicalForm &B)
compare polynomials
Definition facSparseHensel.h:25
lq
Definition lq.h:40

## p_TwoMonPower()

poly p_TwoMonPower | ( | poly | p,
|  | int | exp,
|  | const ring | r )

static

Definition at line 2118 of file p_polys.cc.

{
int eh, e;
long al;
poly *a;
poly tail, b, res, h;
number x;
number *bin = pnBin(exp,r);
tail = pNext(p);
if (bin == NULL)
{
p_MonPower(p,exp,r);
p_MonPower(tail,exp,r);
p_Test(p,r);
return p;
}
eh = exp >> 1;
al = (exp + 1) * sizeof(poly);
a = (poly *)omAlloc(al);
a[1] = p;
for (e=1; e<exp; e++)
{
a[e+1] = p_MonMultC(a[e],p,r);
}
res = a[exp];
b = p_Head(tail,r);
for (e=exp-1; e>eh; e--)
{
h = a[e];
x = n_Mult(bin[exp-e],pGetCoeff(h),r->cf);
p_SetCoeff(h,x,r);
p_MonMult(h,b,r);
res = pNext(res) = h;
p_MonMult(b,tail,r);
}
for (e=eh; e!=0; e--)
{
h = a[e];
x = n_Mult(bin[e],pGetCoeff(h),r->cf);
p_SetCoeff(h,x,r);
p_MonMult(h,b,r);
res = pNext(res) = h;
p_MonMult(b,tail,r);
}
p_LmDelete(&tail,r);
pNext(res) = b;
pNext(b) = NULL;
res = a[exp];
omFreeSize((ADDRESS)a, al);
pnFreeBin(bin, exp, r->cf);
// tail=res;
// while((tail!=NULL)&&(pNext(tail)!=NULL))
// {
// if(nIsZero(pGetCoeff(pNext(tail))))
// {
// pLmDelete(&pNext(tail));
// }
// else
// pIter(tail);
// }
p_Test(res,r);
return res;
}
pnBin
static number * pnBin(int exp, const ring r)
Definition p_polys.cc:2070
pnFreeBin
static void pnFreeBin(number *bin, int exp, const coeffs r)
Definition p_polys.cc:2101
p_MonMultC
static poly p_MonMultC(poly p, poly q, const ring rr)
Definition p_polys.cc:2056
p_MonMult
static void p_MonMult(poly p, poly q, const ring r)
Definition p_polys.cc:2036

## p_Var()

int p_Var | ( | poly | m,
|  | const ring | r )

Definition at line 4810 of file p_polys.cc.

{
if (m==NULL) return 0;
if (pNext(m)!=NULL) return 0;
int i,e=0;
for (i=rVar(r); i>0; i--)
{
int exp=p_GetExp(m,i,r);
if (exp==1)
{
if (e==0) e=i;
else return 0;
}
else if (exp!=0)
{
return 0;
}
}
return e;
}

## p_Vec2Array()

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

vector to already allocated array (len>=p_MaxComp(v,r))

julia: vector to already allocated array (len=p_MaxComp(v,r))

Definition at line 3720 of file p_polys.cc.

{
poly h;
int k;
for(int i=len-1;i>=0;i--) p[i]=NULL;
while (v!=NULL)
{
h=p_Head(v,r);
k=__p_GetComp(h,r);
if (k>len) { Werror("wrong rank:%d, should be %d",len,k); }
else
{
p_SetComp(h,0,r);
p_Setm(h,r);
pNext(h)=p[k-1];p[k-1]=h;
}
pIter(v);
}
for(int i=len-1;i>=0;i--)
{
if (p[i]!=NULL) p[i]=pReverse(p[i]);
}
}

## p_Vec2Poly()

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

Definition at line 3698 of file p_polys.cc.

{
poly h;
poly res=NULL;
long unsigned kk=k;
while (v!=NULL)
{
if (__p_GetComp(v,r)==kk)
{
h=p_Head(v,r);
p_SetComp(h,0,r);
pNext(h)=res;res=h;
}
pIter(v);
}
if (res!=NULL) res=pReverse(res);
return res;
}

## p_Vec2Polys()

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

Definition at line 3750 of file p_polys.cc.

{
*len=p_MaxComp(v,r);
if (*len==0) *len=1;
*p=(poly*)omAlloc((*len)*sizeof(poly));
p_Vec2Array(v,*p,*len,r);
}
p_Vec2Array
void p_Vec2Array(poly v, poly *p, int len, const ring r)
vector to already allocated array (len>=p_MaxComp(v,r))
Definition p_polys.cc:3720

## p_VectorHasUnit()

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

Definition at line 3510 of file p_polys.cc.

{
poly q=p,qq;
int j=0;
long unsigned i;
*len = 0;
while (q!=NULL)
{
if (p_LmIsConstantComp(q,r))
{
i = __p_GetComp(q,r);
qq = p;
while ((qq != q) && (__p_GetComp(qq,r) != i)) pIter(qq);
if (qq == q)
{
j = 0;
while (qq!=NULL)
{
if (__p_GetComp(qq,r)==i) j++;
pIter(qq);
}
if ((*len == 0) || (j<*len))
{
*len = j;
*k = i;
}
}
}
pIter(q);
}
}
p_LmIsConstantComp
static BOOLEAN p_LmIsConstantComp(const poly p, const ring r)
Definition p_polys.h:1008

## p_VectorHasUnitB()

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

Definition at line 3487 of file p_polys.cc.

{
poly q=p,qq;
long unsigned i;
while (q!=NULL)
{
if (p_LmIsConstantComp(q,r))
{
i = __p_GetComp(q,r);
qq = p;
while ((qq != q) && (__p_GetComp(qq,r) != i)) pIter(qq);
if (qq == q)
{
*k = i;
return TRUE;
}
}
pIter(q);
}
return FALSE;
}

## p_WDegree()

long p_WDegree | ( | poly | p,
|  | const ring | r )

Definition at line 715 of file p_polys.cc.

{
if (r->firstwv==NULL) return p_Totaldegree(p, r);
p_LmCheckPolyRing(p, r);
int i;
long j =0;
for(i=1;i<=r->firstBlockEnds;i++)
j+=p_GetExp(p, i, r)*r->firstwv[i-1];
for (;i<=rVar(r);i++)
j+=p_GetExp(p,i, r)*p_Weight(i, r);
return j;
}
p_Weight
int p_Weight(int i, const ring r)
Definition p_polys.cc:706

## p_Weight()

int p_Weight | ( | int | i,
|  | const ring | r )

Definition at line 706 of file p_polys.cc.

{
if ((r->firstwv==NULL) || (i>r->firstBlockEnds))
{
return 1;
}
return r->firstwv[i-1];
}

## p_WFirstTotalDegree()

long p_WFirstTotalDegree | ( | poly | p,
|  | const ring | r )

Definition at line 595 of file p_polys.cc.

{
int i;
long sum = 0;
for (i=1; i<= r->firstBlockEnds; i++)
{
sum += p_GetExp(p, i, r)*r->firstwv[i-1];
}
return sum;
}

## p_WTotaldegree()

long p_WTotaldegree | ( | poly | p,
|  | const ring | r )

Definition at line 612 of file p_polys.cc.

{
p_LmCheckPolyRing(p, r);
int i, k;
long j =0;
// iterate through each block:
for (i=0;r->order[i]!=0;i++)
{
int b0=r->block0[i];
int b1=r->block1[i];
switch(r->order[i])
{
case ringorder_M:
for (k=b0 /*r->block0[i]*/;k<=b1 /*r->block1[i]*/;k++)
{ // in jedem block:
j+= p_GetExp(p,k,r)*r->wvhdl[i][k - b0 /*r->block0[i]*/]*r->OrdSgn;
}
break;
case ringorder_am:
b1=si_min(b1,r->N); /* no break, continue as ringorder_a*/
case ringorder_a:
for (k=b0 /*r->block0[i]*/;k<=b1 /*r->block1[i]*/;k++)
{ // only one line
j+= p_GetExp(p,k,r)*r->wvhdl[i][k - b0 /*r->block0[i]*/];
}
return j*r->OrdSgn;
case ringorder_wp:
case ringorder_ws:
case ringorder_Wp:
case ringorder_Ws:
for (k=b0 /*r->block0[i]*/;k<=b1 /*r->block1[i]*/;k++)
{ // in jedem block:
j+= p_GetExp(p,k,r)*r->wvhdl[i][k - b0 /*r->block0[i]*/];
}
break;
case ringorder_lp:
case ringorder_ls:
case ringorder_rs:
case ringorder_dp:
case ringorder_ds:
case ringorder_Dp:
case ringorder_Ds:
case ringorder_rp:
for (k=b0 /*r->block0[i]*/;k<=b1 /*r->block1[i]*/;k++)
{
j+= p_GetExp(p,k,r);
}
break;
case ringorder_a64:
{
int64* w=(int64*)r->wvhdl[i];
for (k=0;k<=(b1 /*r->block1[i]*/ - b0 /*r->block0[i]*/);k++)
{
//there should be added a line which checks if w[k]>2^31
j+= p_GetExp(p,k+1, r)*(long)w[k];
}
//break;
return j;
}
default:
#if 0
case ringorder_c: /* nothing to do*/
case ringorder_C: /* nothing to do*/
case ringorder_S: /* nothing to do*/
case ringorder_s: /* nothing to do*/
case ringorder_IS: /* nothing to do */
case ringorder_unspec: /* to make clang happy, does not occur*/
case ringorder_no: /* to make clang happy, does not occur*/
case ringorder_L: /* to make clang happy, does not occur*/
case ringorder_aa: /* ignored by p_WTotaldegree*/
#endif
break;
/* no default: all orderings covered */
}
}
return j;
}
ringorder_rp
#define ringorder_rp
Definition ring.h:100
ringorder_a
@ ringorder_a
Definition ring.h:71
ringorder_am
@ ringorder_am
Definition ring.h:90
ringorder_a64
@ ringorder_a64
for int64 weights
Definition ring.h:72
ringorder_C
@ ringorder_C
Definition ring.h:74
ringorder_S
@ ringorder_S
S?
Definition ring.h:76
ringorder_ds
@ ringorder_ds
Definition ring.h:86
ringorder_Dp
@ ringorder_Dp
Definition ring.h:81
ringorder_unspec
@ ringorder_unspec
Definition ring.h:96
ringorder_L
@ ringorder_L
Definition ring.h:91
ringorder_Ds
@ ringorder_Ds
Definition ring.h:87
ringorder_dp
@ ringorder_dp
Definition ring.h:79
ringorder_c
@ ringorder_c
Definition ring.h:73
ringorder_aa
@ ringorder_aa
for idElimination, like a, except pFDeg, pWeigths ignore it
Definition ring.h:93
ringorder_no
@ ringorder_no
Definition ring.h:70
ringorder_Wp
@ ringorder_Wp
Definition ring.h:83
ringorder_ws
@ ringorder_ws
Definition ring.h:88
ringorder_Ws
@ ringorder_Ws
Definition ring.h:89
ringorder_IS
@ ringorder_IS
Induced (Schreyer) ordering.
Definition ring.h:95
ringorder_ls
@ ringorder_ls
degree, ip
Definition ring.h:85
ringorder_s
@ ringorder_s
s?
Definition ring.h:77
ringorder_wp
@ ringorder_wp
Definition ring.h:82
ringorder_M
@ ringorder_M
Definition ring.h:75
ringorder_rs
#define ringorder_rs
Definition ring.h:101

## pEnlargeSet()

void pEnlargeSet | ( | poly ** | p,
|  | int | l,
|  | int | increment )

Definition at line 3821 of file p_polys.cc.

{
poly* h;
if (increment==0) return;
if (*p==NULL)
{
h=(poly*)omAlloc0(increment*sizeof(poly));
}
else
{
h=(poly*)omReallocSize((poly*)*p,l*sizeof(poly),(l+increment)*sizeof(poly));
if (increment>0)
{
memset(&(h[l]),0,increment*sizeof(poly));
}
}
*p=h;
}
omReallocSize
#define omReallocSize(addr, o_size, size)
Definition omAllocDecl.h:220

## pLDeg0()

long pLDeg0 | ( | poly | p,
|  | int * | l,
|  | const ring | r )

Definition at line 740 of file p_polys.cc.

{
p_CheckPolyRing(p, r);
long unsigned k= p_GetComp(p, r);
int ll=1;
if (k > 0)
{
while ((pNext(p)!=NULL) && (__p_GetComp(pNext(p), r)==k))
{
pIter(p);
ll++;
}
}
else
{
while (pNext(p)!=NULL)
{
pIter(p);
ll++;
}
}
*l=ll;
return r->pFDeg(p, r);
}

## pLDeg0c()

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

Definition at line 771 of file p_polys.cc.

{
assume(p!=NULL);
p_Test(p,r);
p_CheckPolyRing(p, r);
long o;
int ll=1;
if (! rIsSyzIndexRing(r))
{
while (pNext(p) != NULL)
{
pIter(p);
ll++;
}
o = r->pFDeg(p, r);
}
else
{
long unsigned curr_limit = rGetCurrSyzLimit(r);
poly pp = p;
while ((p=pNext(p))!=NULL)
{
if (__p_GetComp(p, r)<=curr_limit/*syzComp*/)
ll++;
else break;
pp = p;
}
p_Test(pp,r);
o = r->pFDeg(pp, r);
}
*l=ll;
return o;
}

## pLDeg1()

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

Definition at line 842 of file p_polys.cc.

{
p_CheckPolyRing(p, r);
long unsigned k= p_GetComp(p, r);
int ll=1;
long t,max;
max=r->pFDeg(p, r);
if (k > 0)
{
while (((p=pNext(p))!=NULL) && (__p_GetComp(p, r)==k))
{
t=r->pFDeg(p, r);
if (t>max) max=t;
ll++;
}
}
else
{
while ((p=pNext(p))!=NULL)
{
t=r->pFDeg(p, r);
if (t>max) max=t;
ll++;
}
}
*l=ll;
return max;
}

## pLDeg1_Deg()

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

Definition at line 911 of file p_polys.cc.

{
assume(r->pFDeg == p_Deg);
p_CheckPolyRing(p, r);
long unsigned k= p_GetComp(p, r);
int ll=1;
long t,max;
max=p_GetOrder(p, r);
if (k > 0)
{
while (((p=pNext(p))!=NULL) && (__p_GetComp(p, r)==k))
{
t=p_GetOrder(p, r);
if (t>max) max=t;
ll++;
}
}
else
{
while ((p=pNext(p))!=NULL)
{
t=p_GetOrder(p, r);
if (t>max) max=t;
ll++;
}
}
*l=ll;
return max;
}

## pLDeg1_Totaldegree()

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

Definition at line 976 of file p_polys.cc.

{
p_CheckPolyRing(p, r);
long unsigned k= p_GetComp(p, r);
int ll=1;
long t,max;
max=p_Totaldegree(p, r);
if (k > 0)
{
while (((p=pNext(p))!=NULL) && (__p_GetComp(p, r)==k))
{
t=p_Totaldegree(p, r);
if (t>max) max=t;
ll++;
}
}
else
{
while ((p=pNext(p))!=NULL)
{
t=p_Totaldegree(p, r);
if (t>max) max=t;
ll++;
}
}
*l=ll;
return max;
}

## pLDeg1_WFirstTotalDegree()

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

Definition at line 1039 of file p_polys.cc.

{
p_CheckPolyRing(p, r);
long unsigned k= p_GetComp(p, r);
int ll=1;
long t,max;
max=p_WFirstTotalDegree(p, r);
if (k > 0)
{
while (((p=pNext(p))!=NULL) && (__p_GetComp(p, r)==k))
{
t=p_WFirstTotalDegree(p, r);
if (t>max) max=t;
ll++;
}
}
else
{
while ((p=pNext(p))!=NULL)
{
t=p_WFirstTotalDegree(p, r);
if (t>max) max=t;
ll++;
}
}
*l=ll;
return max;
}

## pLDeg1c()

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

Definition at line 878 of file p_polys.cc.

{
p_CheckPolyRing(p, r);
int ll=1;
long t,max;
max=r->pFDeg(p, r);
if (rIsSyzIndexRing(r))
{
long unsigned limit = rGetCurrSyzLimit(r);
while ((p=pNext(p))!=NULL)
{
if (__p_GetComp(p, r)<=limit)
{
if ((t=r->pFDeg(p, r))>max) max=t;
ll++;
}
else break;
}
}
else
{
while ((p=pNext(p))!=NULL)
{
if ((t=r->pFDeg(p, r))>max) max=t;
ll++;
}
}
*l=ll;
return max;
}

## pLDeg1c_Deg()

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

Definition at line 942 of file p_polys.cc.

{
assume(r->pFDeg == p_Deg);
p_CheckPolyRing(p, r);
int ll=1;
long t,max;
max=p_GetOrder(p, r);
if (rIsSyzIndexRing(r))
{
long unsigned limit = rGetCurrSyzLimit(r);
while ((p=pNext(p))!=NULL)
{
if (__p_GetComp(p, r)<=limit)
{
if ((t=p_GetOrder(p, r))>max) max=t;
ll++;
}
else break;
}
}
else
{
while ((p=pNext(p))!=NULL)
{
if ((t=p_GetOrder(p, r))>max) max=t;
ll++;
}
}
*l=ll;
return max;
}

## pLDeg1c_Totaldegree()

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

Definition at line 1006 of file p_polys.cc.

{
p_CheckPolyRing(p, r);
int ll=1;
long t,max;
max=p_Totaldegree(p, r);
if (rIsSyzIndexRing(r))
{
long unsigned limit = rGetCurrSyzLimit(r);
while ((p=pNext(p))!=NULL)
{
if (__p_GetComp(p, r)<=limit)
{
if ((t=p_Totaldegree(p, r))>max) max=t;
ll++;
}
else break;
}
}
else
{
while ((p=pNext(p))!=NULL)
{
if ((t=p_Totaldegree(p, r))>max) max=t;
ll++;
}
}
*l=ll;
return max;
}

## pLDeg1c_WFirstTotalDegree()

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

Definition at line 1069 of file p_polys.cc.

{
p_CheckPolyRing(p, r);
int ll=1;
long t,max;
max=p_WFirstTotalDegree(p, r);
if (rIsSyzIndexRing(r))
{
long unsigned limit = rGetCurrSyzLimit(r);
while ((p=pNext(p))!=NULL)
{
if (__p_GetComp(p, r)<=limit)
{
if ((t=p_Totaldegree(p, r))>max) max=t;
ll++;
}
else break;
}
}
else
{
while ((p=pNext(p))!=NULL)
{
if ((t=p_Totaldegree(p, r))>max) max=t;
ll++;
}
}
*l=ll;
return max;
}

## pLDegb()

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

Definition at line 812 of file p_polys.cc.

{
p_CheckPolyRing(p, r);
long unsigned k= p_GetComp(p, r);
long o = r->pFDeg(p, r);
int ll=1;
if (k != 0)
{
while (((p=pNext(p))!=NULL) && (__p_GetComp(p, r)==k))
{
ll++;
}
}
else
{
while ((p=pNext(p)) !=NULL)
{
ll++;
}
}
*l=ll;
return o;
}

## pModDeg()

long pModDeg | ( | poly | p,
|  | ring | r )

static

Definition at line 3789 of file p_polys.cc.

{
long d=pOldFDeg(p, r);
int c=__p_GetComp(p, r);
if ((c>0) && ((r->pModW)->range(c-1))) d+= (*(r->pModW))[c-1];
return d;
//return pOldFDeg(p, r)+(*pModW)[p_GetComp(p, r)-1];
}

## pnBin()

number * pnBin | ( | int | exp,
|  | const ring | r )

static

Definition at line 2070 of file p_polys.cc.

{
int e, i, h;
number x, y, *bin=NULL;
x = n_Init(exp,r->cf);
if (n_IsZero(x,r->cf))
{
n_Delete(&x,r->cf);
return bin;
}
h = (exp >> 1) + 1;
bin = (number *)omAlloc0(h*sizeof(number));
bin[1] = x;
if (exp < 4)
return bin;
i = exp - 1;
for (e=2; e<h; e++)
{
x = n_Init(i,r->cf);
i--;
y = n_Mult(x,bin[e-1],r->cf);
n_Delete(&x,r->cf);
x = n_Init(e,r->cf);
bin[e] = n_ExactDiv(y,x,r->cf);
n_Delete(&x,r->cf);
n_Delete(&y,r->cf);
}
return bin;
}

## pnFreeBin()

void pnFreeBin | ( | number * | bin,
|  | int | exp,
|  | const coeffs | r )

static

Definition at line 2101 of file p_polys.cc.

{
int e, h = (exp >> 1) + 1;
if (bin[1] != NULL)
{
for (e=1; e<h; e++)
n_Delete(&(bin[e]),r);
}
omFreeSize((ADDRESS)bin, h*sizeof(number));
}

## pp_DivideM()

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

Definition at line 1637 of file p_polys.cc.

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

## pp_Jet()

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

Definition at line 4484 of file p_polys.cc.

{
poly r=NULL;
poly t=NULL;
while (p!=NULL)
{
if (p_Totaldegree(p,R)<=m)
{
if (r==NULL)
r=p_Head(p,R);
else
if (t==NULL)
{
pNext(r)=p_Head(p,R);
t=pNext(r);
}
else
{
pNext(t)=p_Head(p,R);
pIter(t);
}
}
pIter(p);
}
return r;
}

## pp_Jet0()

poly pp_Jet0 | ( | poly | p,
|  | const ring | R )

Definition at line 4512 of file p_polys.cc.

{
poly r=NULL;
poly t=NULL;
while (p!=NULL)
{
if (p_LmIsConstantComp(p,R))
{
if (r==NULL)
r=p_Head(p,R);
else
if (t==NULL)
{
pNext(r)=p_Head(p,R);
t=pNext(r);
}
else
{
pNext(t)=p_Head(p,R);
pIter(t);
}
}
pIter(p);
}
return r;
}

## pp_JetW()

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

Definition at line 4557 of file p_polys.cc.

{
poly r=NULL;
poly t=NULL;
while (p!=NULL)
{
if (totaldegreeWecart_IV(p,R,w)<=m)
{
if (r==NULL)
r=p_Head(p,R);
else
if (t==NULL)
{
pNext(r)=p_Head(p,R);
t=pNext(r);
}
else
{
pNext(t)=p_Head(p,R);
pIter(t);
}
}
pIter(p);
}
return r;
}

## pRestoreDegProcs()

void pRestoreDegProcs | ( | ring | r,
|  | pFDegProc | old_FDeg,
|  | pLDegProc | old_lDeg )

Definition at line 3774 of file p_polys.cc.

{
assume(old_FDeg != NULL && old_lDeg != NULL);
r->pFDeg = old_FDeg;
r->pLDeg = old_lDeg;
}

## pSetDegProcs()

void pSetDegProcs | ( | ring | r,
|  | pFDegProc | new_FDeg,
|  | pLDegProc | new_lDeg )

Definition at line 3762 of file p_polys.cc.

{
assume(new_FDeg != NULL);
r->pFDeg = new_FDeg;
if (new_lDeg == NULL)
new_lDeg = r->pLDegOrig;
r->pLDeg = new_lDeg;
}

## Variable Documentation

## _components

STATIC_VAR int* _components = NULL

Definition at line 146 of file p_polys.cc.

## _componentsExternal

STATIC_VAR int _componentsExternal = 0

Definition at line 148 of file p_polys.cc.

## _componentsShifted

STATIC_VAR long* _componentsShifted = NULL

Definition at line 147 of file p_polys.cc.

## pOldFDeg

STATIC_VAR pFDegProc pOldFDeg

Definition at line 3785 of file p_polys.cc.

## pOldLDeg

STATIC_VAR pLDegProc pOldLDeg

Definition at line 3786 of file p_polys.cc.

## pOldLexOrder

STATIC_VAR BOOLEAN pOldLexOrder

Definition at line 3787 of file p_polys.cc.

## pSetm_error

VAR BOOLEAN pSetm_error =0

Definition at line 150 of file p_polys.cc.