 |
My Project
debian-1:4.1.1-p2+ds-4build2
|
Go to the source code of this file.
|
#define | pIfThen(cond, check) do {if (cond) {check;}} while (0) |
|
#define | p_Test(p, r) _p_Test(p, r, PDEBUG) |
|
#define | p_LmTest(p, r) _p_LmTest(p, r, PDEBUG) |
|
#define | pp_Test(p, lmRing, tailRing) _pp_Test(p, lmRing, tailRing, PDEBUG) |
|
#define | p_SetmComp p_Setm |
|
#define | __p_Mult_nn(p, n, r) r->p_Procs->p_Mult_nn(p, n, r) |
|
#define | __pp_Mult_nn(p, n, r) r->p_Procs->pp_Mult_nn(p, n, r) |
|
#define | _p_LmCmpAction(p, q, r, actionE, actionG, actionS) |
|
#define | pDivAssume(x) do {} while (0) |
|
#define | p_LmCmpAction(p, q, r, actionE, actionG, actionS) _p_LmCmpAction(p, q, r, actionE, actionG, actionS) |
|
#define | p_LmEqual(p1, p2, r) p_ExpVectorEqual(p1, p2, r) |
|
|
poly | p_Farey (poly p, number N, const ring r) |
|
poly | p_ChineseRemainder (poly *xx, number *x, number *q, int rl, CFArray &inv_cache, const ring R) |
|
unsigned long | p_GetShortExpVector (const poly a, const ring r) |
|
unsigned long | p_GetShortExpVector (const poly p, const poly pp, const ring r) |
| p_GetShortExpVector of p * pp More...
|
|
BOOLEAN | p_DivisibleByRingCase (poly f, poly g, const ring r) |
| divisibility check over ground ring (which may contain zero divisors); TRUE iff LT(f) divides LT(g), i.e., LT(f)*c*m = LT(g), for some coefficient c and some monomial m; does not take components into account More...
|
|
poly | p_One (const ring r) |
|
int | p_MinDeg (poly p, intvec *w, const ring R) |
|
long | p_DegW (poly p, const short *w, const ring R) |
|
BOOLEAN | p_OneComp (poly p, const ring r) |
| return TRUE if all monoms have the same component More...
|
|
int | p_IsPurePower (const poly p, const ring r) |
| return i, if head depends only on var(i) More...
|
|
int | p_IsUnivariate (poly p, const ring r) |
| return i, if poly depends only on var(i) More...
|
|
int | p_GetVariables (poly p, int *e, const ring r) |
| set entry e[i] to 1 if var(i) occurs in p, ignore var(j) if e[j]>0 return #(e[i]>0) More...
|
|
poly | p_ISet (long i, const ring r) |
| returns the poly representing the integer i More...
|
|
poly | p_NSet (number n, const ring r) |
| returns the poly representing the number n, destroys n More...
|
|
void | p_Vec2Polys (poly v, poly **p, int *len, const ring r) |
|
void | p_Vec2Array (poly v, poly *p, int len, const ring r) |
| julia: vector to already allocated array (len=p_MaxComp(v,r)) More...
|
|
void | p_ShallowDelete (poly *p, const ring r) |
|
poly | p_Sub (poly a, poly b, const ring r) |
|
poly | p_Power (poly p, int i, const ring r) |
|
BOOLEAN | pIsMonomOf (poly p, poly m) |
|
BOOLEAN | pHaveCommonMonoms (poly p, poly q) |
|
BOOLEAN | p_LmCheckIsFromRing (poly p, ring r) |
|
BOOLEAN | p_LmCheckPolyRing (poly p, ring r) |
|
BOOLEAN | p_CheckIsFromRing (poly p, ring r) |
|
BOOLEAN | p_CheckPolyRing (poly p, ring r) |
|
BOOLEAN | p_CheckRing (ring r) |
|
BOOLEAN | _p_Test (poly p, ring r, int level) |
|
BOOLEAN | _p_LmTest (poly p, ring r, int level) |
|
BOOLEAN | _pp_Test (poly p, ring lmRing, ring tailRing, int level) |
|
static unsigned | pLength (poly a) |
|
poly | p_Last (const poly a, int &l, const ring r) |
|
void | p_Norm (poly p1, const ring r) |
|
void | p_Normalize (poly p, const ring r) |
|
void | p_ProjectiveUnique (poly p, const ring r) |
|
void | p_ContentForGB (poly p, const ring r) |
|
void | p_Content (poly p, const ring r) |
|
void | p_SimpleContent (poly p, int s, const ring r) |
|
number | p_InitContent (poly ph, const ring r) |
|
poly | p_Cleardenom (poly p, const ring r) |
|
void | p_Cleardenom_n (poly p, const ring r, number &c) |
|
int | p_Size (poly p, const ring r) |
|
poly | p_Homogen (poly p, int varnum, const ring r) |
|
BOOLEAN | p_IsHomogeneous (poly p, const ring r) |
|
static void | p_Setm (poly p, const ring r) |
|
p_SetmProc | p_GetSetmProc (const ring r) |
|
poly | p_Subst (poly p, int n, poly e, const ring r) |
|
static unsigned long | p_SetComp (poly p, unsigned long c, ring r) |
|
static void | p_SetCompP (poly p, int i, ring r) |
|
static void | p_SetCompP (poly p, int i, ring lmRing, ring tailRing) |
|
static long | p_MaxComp (poly p, ring lmRing, ring tailRing) |
|
static long | p_MaxComp (poly p, ring lmRing) |
|
static long | p_MinComp (poly p, ring lmRing, ring tailRing) |
|
static long | p_MinComp (poly p, ring lmRing) |
|
static poly | pReverse (poly p) |
|
void | pEnlargeSet (poly **p, int length, int increment) |
|
void | p_String0 (poly p, ring lmRing, ring tailRing) |
| print p according to ShortOut in lmRing & tailRing More...
|
|
char * | p_String (poly p, ring lmRing, ring tailRing) |
|
void | p_Write (poly p, ring lmRing, ring tailRing) |
|
void | p_Write0 (poly p, ring lmRing, ring tailRing) |
|
void | p_wrp (poly p, ring lmRing, ring tailRing) |
|
void | p_String0Short (const poly p, ring lmRing, ring tailRing) |
| print p in a short way, if possible More...
|
|
void | p_String0Long (const poly p, ring lmRing, ring tailRing) |
| print p in a long way More...
|
|
static long | p_FDeg (const poly p, const ring r) |
|
static long | p_LDeg (const poly p, int *l, const ring r) |
|
long | p_WFirstTotalDegree (poly p, ring r) |
|
long | p_WTotaldegree (poly p, const ring r) |
|
long | p_WDegree (poly p, const ring r) |
|
long | pLDeg0 (poly p, int *l, ring r) |
|
long | pLDeg0c (poly p, int *l, ring r) |
|
long | pLDegb (poly p, int *l, ring r) |
|
long | pLDeg1 (poly p, int *l, ring r) |
|
long | pLDeg1c (poly p, int *l, ring r) |
|
long | pLDeg1_Deg (poly p, int *l, ring r) |
|
long | pLDeg1c_Deg (poly p, int *l, ring r) |
|
long | pLDeg1_Totaldegree (poly p, int *l, ring r) |
|
long | pLDeg1c_Totaldegree (poly p, int *l, ring r) |
|
long | pLDeg1_WFirstTotalDegree (poly p, int *l, ring r) |
|
long | pLDeg1c_WFirstTotalDegree (poly p, int *l, ring r) |
|
BOOLEAN | p_EqualPolys (poly p1, poly p2, const ring r) |
|
BOOLEAN | p_EqualPolys (poly p1, poly p2, const ring r1, const ring r2) |
| same as the usual p_EqualPolys for polys belonging to equal rings More...
|
|
long | p_Deg (poly a, const ring r) |
|
static number | p_SetCoeff (poly p, number n, ring r) |
|
static long | p_GetOrder (poly p, ring r) |
|
static unsigned long | p_AddComp (poly p, unsigned long v, ring r) |
|
static unsigned long | p_SubComp (poly p, unsigned long v, ring r) |
|
static long | p_GetExp (const poly p, const unsigned long iBitmask, const int VarOffset) |
| get a single variable exponent @Note: the integer VarOffset encodes: More...
|
|
static unsigned long | p_SetExp (poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset) |
| set a single variable exponent @Note: VarOffset encodes the position in p->exp More...
|
|
static long | p_GetExp (const poly p, const ring r, const int VarOffset) |
|
static long | p_SetExp (poly p, const long e, const ring r, const int VarOffset) |
|
static long | p_GetExp (const poly p, const int v, const ring r) |
| get v^th exponent for a monomial More...
|
|
static long | p_SetExp (poly p, const int v, const long e, const ring r) |
| set v^th exponent for a monomial More...
|
|
static long | p_IncrExp (poly p, int v, ring r) |
|
static long | p_DecrExp (poly p, int v, ring r) |
|
static long | p_AddExp (poly p, int v, long ee, ring r) |
|
static long | p_SubExp (poly p, int v, long ee, ring r) |
|
static long | p_MultExp (poly p, int v, long ee, ring r) |
|
static long | p_GetExpSum (poly p1, poly p2, int i, ring r) |
|
static long | p_GetExpDiff (poly p1, poly p2, int i, ring r) |
|
static int | p_Comp_k_n (poly a, poly b, int k, ring r) |
|
static poly | p_New (const ring, omBin bin) |
|
static poly | p_New (ring r) |
|
static void | p_LmFree (poly p, ring) |
|
static void | p_LmFree (poly *p, ring) |
|
static poly | p_LmFreeAndNext (poly p, ring) |
|
static void | p_LmDelete (poly p, const ring r) |
|
static void | p_LmDelete (poly *p, const ring r) |
|
static poly | p_LmDeleteAndNext (poly p, const ring r) |
|
unsigned long | p_GetMaxExpL (poly p, const ring r, unsigned long l_max=0) |
| return the maximal exponent of p in form of the maximal long var More...
|
|
poly | p_GetMaxExpP (poly p, ring r) |
| return monomial r such that GetExp(r,i) is maximum of all monomials in p; coeff == 0, next == NULL, ord is not set More...
|
|
static unsigned long | p_GetMaxExp (const unsigned long l, const ring r) |
|
static unsigned long | p_GetMaxExp (const poly p, const ring r) |
|
static unsigned long | p_GetTotalDegree (const unsigned long l, const ring r, const int number_of_exps) |
|
static poly | p_Copy_noCheck (poly p, const ring r) |
| returns a copy of p (without any additional testing) More...
|
|
static poly | p_Copy (poly p, const ring r) |
| returns a copy of p More...
|
|
static poly | p_Head (poly p, const ring r) |
|
static poly | p_Copy (poly p, const ring lmRing, const ring tailRing) |
|
static void | p_Delete (poly *p, const ring r) |
|
static void | p_Delete (poly *p, const ring lmRing, const ring tailRing) |
|
static poly | p_ShallowCopyDelete (poly p, const ring r, omBin bin) |
|
static poly | p_Add_q (poly p, poly q, const ring r) |
|
static poly | p_Add_q (poly p, poly q, int &lp, int lq, const ring r) |
| like p_Add_q, except that if lp == pLength(lp) lq == pLength(lq) then lp == pLength(p+q) More...
|
|
static poly | p_Mult_nn (poly p, number n, const ring r) |
|
static poly | p_Mult_nn (poly p, number n, const ring lmRing, const ring tailRing) |
|
static poly | pp_Mult_nn (poly p, number n, const ring r) |
|
static BOOLEAN | p_LmIsConstantComp (const poly p, const ring r) |
|
static BOOLEAN | p_LmIsConstant (const poly p, const ring r) |
|
static poly | pp_Mult_mm (poly p, poly m, const ring r) |
|
static poly | p_Mult_mm (poly p, poly m, const ring r) |
|
static poly | p_Minus_mm_Mult_qq (poly p, const poly m, const poly q, int &lp, int lq, const poly spNoether, const ring r) |
|
static poly | p_Minus_mm_Mult_qq (poly p, const poly m, const poly q, const ring r) |
|
static poly | pp_Mult_Coeff_mm_DivSelect (poly p, const poly m, const ring r) |
|
static poly | pp_Mult_Coeff_mm_DivSelect (poly p, int &lp, const poly m, const ring r) |
|
static poly | p_Neg (poly p, const ring r) |
|
poly | _p_Mult_q (poly p, poly q, const int copy, const ring r) |
| Returns: p * q, Destroys: if !copy then p, q Assumes: pLength(p) >= 2 pLength(q) >=2. More...
|
|
static poly | p_Mult_q (poly p, poly q, const ring r) |
|
static poly | pp_Mult_qq (poly p, poly q, const ring r) |
|
static poly | p_Plus_mm_Mult_qq (poly p, poly m, poly q, int &lp, int lq, const ring r) |
|
static poly | p_Plus_mm_Mult_qq (poly p, poly m, poly q, const ring r) |
|
static poly | p_Merge_q (poly p, poly q, const ring r) |
|
static poly | p_SortAdd (poly p, const ring r, BOOLEAN revert=FALSE) |
|
static poly | p_SortMerge (poly p, const ring r, BOOLEAN revert=FALSE) |
|
static char * | p_String (poly p, ring p_ring) |
|
static void | p_String0 (poly p, ring p_ring) |
|
static void | p_Write (poly p, ring p_ring) |
|
static void | p_Write0 (poly p, ring p_ring) |
|
static void | p_wrp (poly p, ring p_ring) |
|
static void | p_MemAdd_NegWeightAdjust (poly p, const ring r) |
|
static void | p_MemSub_NegWeightAdjust (poly p, const ring r) |
|
static void | p_ExpVectorCopy (poly d_p, poly s_p, const ring r) |
|
static poly | p_Init (const ring r, omBin bin) |
|
static poly | p_Init (const ring r) |
|
static poly | p_LmInit (poly p, const ring r) |
|
static poly | p_LmInit (poly s_p, const ring s_r, const ring d_r, omBin d_bin) |
|
static poly | p_LmInit (poly s_p, const ring s_r, const ring d_r) |
|
static poly | p_GetExp_k_n (poly p, int l, int k, const ring r) |
|
static poly | p_LmShallowCopyDelete (poly p, const ring r) |
|
static void | p_ExpVectorAdd (poly p1, poly p2, const ring r) |
|
static void | p_ExpVectorSum (poly pr, poly p1, poly p2, const ring r) |
|
static void | p_ExpVectorSub (poly p1, poly p2, const ring r) |
|
static void | p_ExpVectorAddSub (poly p1, poly p2, poly p3, const ring r) |
|
static void | p_ExpVectorDiff (poly pr, poly p1, poly p2, const ring r) |
|
static BOOLEAN | p_ExpVectorEqual (poly p1, poly p2, const ring r) |
|
static long | p_Totaldegree (poly p, const ring r) |
|
static void | p_GetExpV (poly p, int *ev, const ring r) |
|
static void | p_GetExpVL (poly p, int64 *ev, const ring r) |
|
static void | p_SetExpV (poly p, int *ev, const ring r) |
|
static void | p_SetExpVL (poly p, int64 *ev, const ring r) |
|
static int | p_LmCmp (poly p, poly q, const ring r) |
|
static int | p_LtCmp (poly p, poly q, const ring r) |
|
static int | p_LtCmpNoAbs (poly p, poly q, const ring r) |
|
static int | p_LtCmpOrdSgnDiffM (poly p, poly q, const ring r) |
|
static int | p_LtCmpOrdSgnDiffP (poly p, poly q, const ring r) |
|
static int | p_LtCmpOrdSgnEqM (poly p, poly q, const ring r) |
|
static int | p_LtCmpOrdSgnEqP (poly p, poly q, const ring r) |
|
BOOLEAN | p_ComparePolys (poly p1, poly p2, const ring r) |
| returns TRUE if p1 is a skalar multiple of p2 assume p1 != NULL and p2 != NULL More...
|
|
static int | p_Cmp (poly p1, poly p2, ring r) |
|
static BOOLEAN | _p_LmDivisibleByNoComp (poly a, poly b, const ring r) |
| return: FALSE, if there exists i, such that a->exp[i] > b->exp[i] TRUE, otherwise (1) Consider long vars, instead of single exponents (2) Clearly, if la > lb, then FALSE (3) Suppose la <= lb, and consider first bits of single exponents in l: if TRUE, then value of these bits is la ^ lb if FALSE, then la-lb causes an "overflow" into one of those bits, i.e., la ^ lb != la - lb More...
|
|
static BOOLEAN | _p_LmDivisibleByNoComp (poly a, const ring r_a, poly b, const ring r_b) |
|
static BOOLEAN | _p_LmDivisibleByNoCompPart (poly a, const ring r_a, poly b, const ring r_b, const int start, const int end) |
|
static BOOLEAN | _p_LmDivisibleByPart (poly a, const ring r_a, poly b, const ring r_b, const int start, const int end) |
|
static BOOLEAN | p_LmDivisibleByPart (poly a, poly b, const ring r, const int start, const int end) |
|
static BOOLEAN | _p_LmDivisibleBy (poly a, poly b, const ring r) |
|
static BOOLEAN | _p_LmDivisibleBy (poly a, const ring r_a, poly b, const ring r_b) |
|
static BOOLEAN | p_LmDivisibleByNoComp (poly a, poly b, const ring r) |
|
static BOOLEAN | p_LmDivisibleByNoComp (poly a, const ring ra, poly b, const ring rb) |
|
static BOOLEAN | p_LmDivisibleBy (poly a, poly b, const ring r) |
|
static BOOLEAN | p_DivisibleBy (poly a, poly b, const ring r) |
|
static BOOLEAN | p_DivisibleBy (poly a, const ring r_a, poly b, const ring r_b) |
|
static BOOLEAN | p_LmDivisibleBy (poly a, const ring r_a, poly b, const ring r_b) |
|
static BOOLEAN | p_LmShortDivisibleBy (poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r) |
|
static BOOLEAN | p_LmShortDivisibleByNoComp (poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r) |
|
static BOOLEAN | p_LmShortDivisibleBy (poly a, unsigned long sev_a, const ring r_a, poly b, unsigned long not_sev_b, const ring r_b) |
|
static BOOLEAN | p_IsConstantComp (const poly p, const ring r) |
|
static BOOLEAN | p_IsConstant (const poly p, const ring r) |
|
static BOOLEAN | p_IsOne (const poly p, const ring R) |
| either poly(1) or gen(k)?! More...
|
|
static BOOLEAN | p_IsConstantPoly (const poly p, const ring r) |
|
static BOOLEAN | p_IsUnit (const poly p, const ring r) |
|
static BOOLEAN | p_LmExpVectorAddIsOk (const poly p1, const poly p2, const ring r) |
|
void | p_Split (poly p, poly *r) |
|
BOOLEAN | p_HasNotCF (poly p1, poly p2, const ring r) |
|
poly | p_mInit (const char *s, BOOLEAN &ok, const ring r) |
|
const char * | p_Read (const char *s, poly &p, const ring r) |
|
poly | p_MDivide (poly a, poly b, const ring r) |
|
poly | p_DivideM (poly a, poly b, const ring r) |
|
poly | p_Div_nn (poly p, const number n, const ring r) |
|
void | p_Lcm (const poly a, const poly b, poly m, const ring r) |
|
poly | p_Lcm (const poly a, const poly b, const ring r) |
|
poly | p_LcmRat (const poly a, const poly b, const long lCompM, const ring r) |
|
poly | p_GetCoeffRat (poly p, int ishift, ring r) |
|
void | p_LmDeleteAndNextRat (poly *p, int ishift, ring r) |
|
void | p_ContentRat (poly &ph, const ring r) |
|
poly | p_Diff (poly a, int k, const ring r) |
|
poly | p_DiffOp (poly a, poly b, BOOLEAN multiply, const ring r) |
|
int | p_Weight (int c, const ring r) |
|
poly | p_PolyDiv (poly &p, const poly divisor, const BOOLEAN needResult, const ring r) |
| assumes that p and divisor are univariate polynomials in r, mentioning the same variable; assumes divisor != NULL; p may be NULL; assumes a global monomial ordering in r; performs polynomial division of p by divisor: More...
|
|
BOOLEAN | p_VectorHasUnitB (poly p, int *k, const ring r) |
|
void | p_VectorHasUnit (poly p, int *k, int *len, const ring r) |
|
poly | p_TakeOutComp1 (poly *p, int k, const ring r) |
|
void | p_TakeOutComp (poly *p, long comp, poly *q, int *lq, const ring r) |
|
poly | p_TakeOutComp (poly *p, int k, const ring r) |
|
void | p_DeleteComp (poly *p, int k, const ring r) |
|
void | pSetDegProcs (ring r, pFDegProc new_FDeg, pLDegProc new_lDeg=NULL) |
|
void | pRestoreDegProcs (ring r, pFDegProc old_FDeg, pLDegProc old_lDeg) |
|
void | p_SetModDeg (intvec *w, ring r) |
|
poly | pp_Jet (poly p, int m, const ring R) |
|
poly | p_Jet (poly p, int m, const ring R) |
|
poly | pp_JetW (poly p, int m, short *w, const ring R) |
|
poly | p_JetW (poly p, int m, short *w, const ring R) |
|
poly | n_PermNumber (const number z, const int *par_perm, const int OldPar, const ring src, const ring dst) |
|
poly | p_PermPoly (poly p, const int *perm, const ring OldRing, const ring dst, nMapFunc nMap, const int *par_perm=NULL, int OldPar=0, BOOLEAN use_mult=FALSE) |
|
poly | p_Series (int n, poly p, poly u, intvec *w, const ring R) |
|
int | p_Var (poly mi, const ring r) |
|
int | p_LowVar (poly p, const ring r) |
| the minimal index of used variables - 1 More...
|
|
void | p_Shift (poly *p, int i, const ring r) |
| shifts components of the vector p by i More...
|
|
int | p_Compare (const poly a, const poly b, const ring R) |
|
poly | p_GcdMon (poly f, poly g, const ring r) |
| polynomial gcd for f=mon More...
|
|
poly | p_Div_mm (poly p, const poly m, const ring r) |
| divide polynomial by monomial More...
|
|
◆ __p_Mult_nn
#define __p_Mult_nn |
( |
|
p, |
|
|
|
n, |
|
|
|
r |
|
) |
| r->p_Procs->p_Mult_nn(p, n, r) |
◆ __pp_Mult_nn
#define __pp_Mult_nn |
( |
|
p, |
|
|
|
n, |
|
|
|
r |
|
) |
| r->p_Procs->pp_Mult_nn(p, n, r) |
◆ _p_LmCmpAction
#define _p_LmCmpAction |
( |
|
p, |
|
|
|
q, |
|
|
|
r, |
|
|
|
actionE, |
|
|
|
actionG, |
|
|
|
actionS |
|
) |
| |
Value:
actionE, actionG, actionS)
Definition at line 1222 of file p_polys.h.
◆ p_LmCmpAction
#define p_LmCmpAction |
( |
|
p, |
|
|
|
q, |
|
|
|
r, |
|
|
|
actionE, |
|
|
|
actionG, |
|
|
|
actionS |
|
) |
| _p_LmCmpAction(p, q, r, actionE, actionG, actionS) |
◆ p_LmEqual
◆ p_LmTest
◆ p_SetmComp
◆ p_Test
◆ pDivAssume
◆ pIfThen
◆ pp_Test
◆ _p_LmDivisibleBy() [1/2]
◆ _p_LmDivisibleBy() [2/2]
static BOOLEAN _p_LmDivisibleBy |
( |
poly |
a, |
|
|
poly |
b, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
◆ _p_LmDivisibleByNoComp() [1/2]
static BOOLEAN _p_LmDivisibleByNoComp |
( |
poly |
a, |
|
|
const ring |
r_a, |
|
|
poly |
b, |
|
|
const ring |
r_b |
|
) |
| |
|
inlinestatic |
◆ _p_LmDivisibleByNoComp() [2/2]
static BOOLEAN _p_LmDivisibleByNoComp |
( |
poly |
a, |
|
|
poly |
b, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
return: FALSE, if there exists i, such that a->exp[i] > b->exp[i] TRUE, otherwise (1) Consider long vars, instead of single exponents (2) Clearly, if la > lb, then FALSE (3) Suppose la <= lb, and consider first bits of single exponents in l: if TRUE, then value of these bits is la ^ lb if FALSE, then la-lb causes an "overflow" into one of those bits, i.e., la ^ lb != la - lb
Definition at line 1685 of file p_polys.h.
1687 int i=r->VarL_Size - 1;
1688 unsigned long divmask = r->divmask;
1689 unsigned long la, lb;
1691 if (r->VarL_LowIndex >= 0)
1693 i += r->VarL_LowIndex;
1699 (((la & divmask) ^ (lb & divmask)) != ((lb - la) & divmask)))
1706 while (
i>=r->VarL_LowIndex);
1712 la = a->exp[r->VarL_Offset[
i]];
1713 lb =
b->exp[r->VarL_Offset[
i]];
1715 (((la & divmask) ^ (lb & divmask)) != ((lb - la) & divmask)))
◆ _p_LmDivisibleByNoCompPart()
◆ _p_LmDivisibleByPart()
◆ _p_LmTest()
BOOLEAN _p_LmTest |
( |
poly |
p, |
|
|
ring |
r, |
|
|
int |
level |
|
) |
| |
◆ _p_Mult_q()
poly _p_Mult_q |
( |
poly |
p, |
|
|
poly |
q, |
|
|
const int |
copy, |
|
|
const ring |
r |
|
) |
| |
Returns: p * q, Destroys: if !copy then p, q Assumes: pLength(p) >= 2 pLength(q) >=2.
Definition at line 273 of file p_Mult_q.cc.
◆ _p_Test()
BOOLEAN _p_Test |
( |
poly |
p, |
|
|
ring |
r, |
|
|
int |
level |
|
) |
| |
Definition at line 212 of file pDebug.cc.
266 long c1, cc1, ccc1, ec1;
270 if (o->
data.syzcomp.Components!=
NULL)
272 cc1 = o->
data.syzcomp.Components[c1];
273 ccc1 = o->
data.syzcomp.ShiftedComponents[cc1];
275 else { cc1=0; ccc1=0; }
278 ec1 =
p->exp[o->
data.syzcomp.place];
310 for (
i=r->N;
i>0;
i--)
◆ _pp_Test()
BOOLEAN _pp_Test |
( |
poly |
p, |
|
|
ring |
lmRing, |
|
|
ring |
tailRing, |
|
|
int |
level |
|
) |
| |
◆ n_PermNumber()
Definition at line 3910 of file p_polys.cc.
3913 PrintS(
"\nSource Ring: \n");
3918 number zz =
n_Copy(z, src->cf);
3923 PrintS(
"\nDestination Ring: \n");
3935 const coeffs srcCf = src->cf;
3943 const ring srcExtRing = srcCf->extRing;
3946 const coeffs dstCf = dst->cf;
3958 zz = NUM((fraction)z);
3962 if( !DENIS1((fraction)z) )
3965 WarnS(
"Not defined: Cannot map a rational fraction and make a polynomial out of it! Ignoring the denominator.");
3971 WerrorS(
"Number permutation is not implemented for this data yet!");
3983 if ((par_perm ==
NULL) && (
rPar(dst) != 0 &&
rVar (srcExtRing) > 0))
3986 perm=(
int *)
omAlloc0((
rVar(srcExtRing)+1)*
sizeof(int));
3997 && (!DENIS1((fraction)z))
4000 number n=nMap(
pGetCoeff(DEN((fraction)z)),srcExtRing->cf, dstCf);
◆ p_Add_q() [1/2]
static poly p_Add_q |
( |
poly |
p, |
|
|
poly |
q, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 892 of file p_polys.h.
895 if (q==
NULL)
return p;
896 if (
p==
NULL)
return q;
898 return r->p_Procs->p_Add_q(
p, q, shorter, r);
◆ p_Add_q() [2/2]
static poly p_Add_q |
( |
poly |
p, |
|
|
poly |
q, |
|
|
int & |
lp, |
|
|
int |
lq, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
like p_Add_q, except that if lp == pLength(lp) lq == pLength(lq) then lp == pLength(p+q)
Definition at line 902 of file p_polys.h.
905 if (q==
NULL)
return p;
906 if (
p==
NULL) { lp=
lq;
return q; }
908 poly
res = r->p_Procs->p_Add_q(
p, q, shorter, r);
◆ p_AddComp()
static unsigned long p_AddComp |
( |
poly |
p, |
|
|
unsigned long |
v, |
|
|
ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_AddExp()
static long p_AddExp |
( |
poly |
p, |
|
|
int |
v, |
|
|
long |
ee, |
|
|
ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_CheckIsFromRing()
BOOLEAN p_CheckIsFromRing |
( |
poly |
p, |
|
|
ring |
r |
|
) |
| |
◆ p_CheckPolyRing()
BOOLEAN p_CheckPolyRing |
( |
poly |
p, |
|
|
ring |
r |
|
) |
| |
◆ p_CheckRing()
◆ p_ChineseRemainder()
poly p_ChineseRemainder |
( |
poly * |
xx, |
|
|
number * |
x, |
|
|
number * |
q, |
|
|
int |
rl, |
|
|
CFArray & |
inv_cache, |
|
|
const ring |
R |
|
) |
| |
◆ p_Cleardenom()
poly p_Cleardenom |
( |
poly |
p, |
|
|
const ring |
r |
|
) |
| |
Definition at line 2782 of file p_polys.cc.
2789 #if CLEARENUMERATORS
2832 #if 0 && CLEARENUMERATORS
2876 #ifdef HAVE_RATGRING
◆ p_Cleardenom_n()
void p_Cleardenom_n |
( |
poly |
p, |
|
|
const ring |
r, |
|
|
number & |
c |
|
) |
| |
Definition at line 2891 of file p_polys.cc.
2900 #if CLEARENUMERATORS
2953 #if CLEARENUMERATORS
◆ p_Cmp()
static int p_Cmp |
( |
poly |
p1, |
|
|
poly |
p2, |
|
|
ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_Comp_k_n()
static int p_Comp_k_n |
( |
poly |
a, |
|
|
poly |
b, |
|
|
int |
k, |
|
|
ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_Compare()
◆ p_ComparePolys()
returns TRUE if p1 is a skalar multiple of p2 assume p1 != NULL and p2 != NULL
Definition at line 4460 of file p_polys.cc.
4480 while ((p1 !=
NULL) )
◆ p_Content()
void p_Content |
( |
poly |
p, |
|
|
const ring |
r |
|
) |
| |
Definition at line 2238 of file p_polys.cc.
2240 if (ph==
NULL)
return;
2246 if (
cf->cfSubringGcd==
ndGcd)
return;
2251 goto content_finish;
2263 goto content_finish;
◆ p_ContentForGB()
void p_ContentForGB |
( |
poly |
p, |
|
|
const ring |
r |
|
) |
| |
Definition at line 2283 of file p_polys.cc.
2291 #if CLEARENUMERATORS
2344 #if CLEARENUMERATORS
2409 h =
n_Init(1, r->cf->extRing->cf);
◆ p_ContentRat()
void p_ContentRat |
( |
poly & |
ph, |
|
|
const ring |
r |
|
) |
| |
Definition at line 1691 of file p_polys.cc.
1699 poly *C = (poly *)
omAlloc0((len+1)*
sizeof(poly));
1700 poly *LM = (poly *)
omAlloc0((len+1)*
sizeof(poly));
1701 int *
D = (
int *)
omAlloc0((len+1)*
sizeof(int));
1702 int *L = (
int *)
omAlloc0((len+1)*
sizeof(int));
1708 int HasConstantCoef = 0;
1709 int is = r->real_var_start - 1;
1721 HasConstantCoef = 1;
1731 int mindeglen = len;
1743 if (
D[
i] == mintdeg)
1745 if (L[
i] < mindeglen)
1752 d =
p_Copy(C[pmindeglen], r);
◆ p_Copy() [1/2]
static poly p_Copy |
( |
poly |
p, |
|
|
const ring |
lmRing, |
|
|
const ring |
tailRing |
|
) |
| |
|
inlinestatic |
Definition at line 839 of file p_polys.h.
844 if (tailRing == lmRing)
◆ p_Copy() [2/2]
static poly p_Copy |
( |
poly |
p, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
returns a copy of p
Definition at line 812 of file p_polys.h.
◆ p_Copy_noCheck()
static poly p_Copy_noCheck |
( |
poly |
p, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
returns a copy of p (without any additional testing)
Definition at line 802 of file p_polys.h.
808 return r->p_Procs->p_Copy(
p, r);
◆ p_DecrExp()
static long p_DecrExp |
( |
poly |
p, |
|
|
int |
v, |
|
|
ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_Deg()
long p_Deg |
( |
poly |
a, |
|
|
const ring |
r |
|
) |
| |
◆ p_DegW()
long p_DegW |
( |
poly |
p, |
|
|
const short * |
w, |
|
|
const ring |
R |
|
) |
| |
◆ p_Delete() [1/2]
static void p_Delete |
( |
poly * |
p, |
|
|
const ring |
lmRing, |
|
|
const ring |
tailRing |
|
) |
| |
|
inlinestatic |
Definition at line 864 of file p_polys.h.
870 if (tailRing == lmRing)
◆ p_Delete() [2/2]
static void p_Delete |
( |
poly * |
p, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_DeleteComp()
void p_DeleteComp |
( |
poly * |
p, |
|
|
int |
k, |
|
|
const ring |
r |
|
) |
| |
◆ p_Diff()
poly p_Diff |
( |
poly |
a, |
|
|
int |
k, |
|
|
const ring |
r |
|
) |
| |
◆ p_DiffOp()
poly p_DiffOp |
( |
poly |
a, |
|
|
poly |
b, |
|
|
BOOLEAN |
multiply, |
|
|
const ring |
r |
|
) |
| |
◆ p_Div_mm()
poly p_Div_mm |
( |
poly |
p, |
|
|
const poly |
m, |
|
|
const ring |
r |
|
) |
| |
divide polynomial by monomial
Definition at line 1500 of file p_polys.cc.
◆ p_Div_nn()
poly p_Div_nn |
( |
poly |
p, |
|
|
const number |
n, |
|
|
const ring |
r |
|
) |
| |
◆ p_DivideM()
poly p_DivideM |
( |
poly |
a, |
|
|
poly |
b, |
|
|
const ring |
r |
|
) |
| |
◆ p_DivisibleBy() [1/2]
◆ p_DivisibleBy() [2/2]
static BOOLEAN p_DivisibleBy |
( |
poly |
a, |
|
|
poly |
b, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
◆ 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 1589 of file p_polys.cc.
1592 for(
int i = (
int)
rVar(r);
i>0;
i--)
◆ p_EqualPolys() [1/2]
◆ p_EqualPolys() [2/2]
same as the usual p_EqualPolys for polys belonging to equal rings
Definition at line 4434 of file p_polys.cc.
4437 assume( r1->cf == r2->cf );
4439 while ((p1 !=
NULL) && (p2 !=
NULL))
◆ p_ExpVectorAdd()
static void p_ExpVectorAdd |
( |
poly |
p1, |
|
|
poly |
p2, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_ExpVectorAddSub()
static void p_ExpVectorAddSub |
( |
poly |
p1, |
|
|
poly |
p2, |
|
|
poly |
p3, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_ExpVectorCopy()
static void p_ExpVectorCopy |
( |
poly |
d_p, |
|
|
poly |
s_p, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 1259 of file p_polys.h.
1263 memcpy(d_p->exp, s_p->exp, r->ExpL_Size*
sizeof(
long));
◆ p_ExpVectorDiff()
static void p_ExpVectorDiff |
( |
poly |
pr, |
|
|
poly |
p1, |
|
|
poly |
p2, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_ExpVectorEqual()
static BOOLEAN p_ExpVectorEqual |
( |
poly |
p1, |
|
|
poly |
p2, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 1435 of file p_polys.h.
1440 unsigned i = r->ExpL_Size;
1441 unsigned long *ep = p1->exp;
1442 unsigned long *eq = p2->exp;
1447 if (ep[
i] != eq[
i])
return FALSE;
◆ p_ExpVectorSub()
static void p_ExpVectorSub |
( |
poly |
p1, |
|
|
poly |
p2, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_ExpVectorSum()
static void p_ExpVectorSum |
( |
poly |
pr, |
|
|
poly |
p1, |
|
|
poly |
p2, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_Farey()
poly p_Farey |
( |
poly |
p, |
|
|
number |
N, |
|
|
const ring |
r |
|
) |
| |
◆ p_FDeg()
Definition at line 380 of file p_polys.h.
380 {
return r->pFDeg(
p,r); }
◆ p_GcdMon()
poly p_GcdMon |
( |
poly |
f, |
|
|
poly |
g, |
|
|
const ring |
r |
|
) |
| |
polynomial gcd for f=mon
Definition at line 4824 of file p_polys.cc.
4831 int *mf=(
int*)
omAlloc((r->N+1)*
sizeof(int));
4833 int *mh=(
int*)
omAlloc((r->N+1)*
sizeof(int));
4847 for(
unsigned j=r->N;
j!=0;
j--)
4849 if (mh[
j]<mf[
j]) mf[
j]=mh[
j];
4850 if (mf[
j]>0) const_mon=
FALSE;
4852 if (one_coeff && const_mon)
break;
◆ p_GetCoeffRat()
poly p_GetCoeffRat |
( |
poly |
p, |
|
|
int |
ishift, |
|
|
ring |
r |
|
) |
| |
◆ p_GetExp() [1/3]
get v^th exponent for a monomial
Definition at line 572 of file p_polys.h.
577 return p_GetExp(
p, r->bitmask, r->VarOffset[
v]);
◆ p_GetExp() [2/3]
◆ p_GetExp() [3/3]
static long p_GetExp |
( |
const poly |
p, |
|
|
const unsigned long |
iBitmask, |
|
|
const int |
VarOffset |
|
) |
| |
|
inlinestatic |
get a single variable exponent @Note: the integer VarOffset encodes:
- the position of a variable in the exponent vector p->exp (lower 24 bits)
- number of bits to shift to the right in the upper 8 bits (which takes at most 6 bits for 64 bit) Thus VarOffset always has 2 zero higher bits!
Definition at line 469 of file p_polys.h.
471 pAssume2((VarOffset >> (24 + 6)) == 0);
473 int pos=(VarOffset & 0xffffff);
474 int bitpos=(VarOffset >> 24);
475 unsigned long exp=(
p->exp[pos] >> bitmask) & iBitmask;
479 ((
p->exp[(VarOffset & 0xffffff)] >> (VarOffset >> 24))
◆ p_GetExp_k_n()
static poly p_GetExp_k_n |
( |
poly |
p, |
|
|
int |
l, |
|
|
int |
k, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 1318 of file p_polys.h.
1325 memcpy(np->exp,
p->exp, r->ExpL_Size*
sizeof(
long));
◆ p_GetExpDiff()
static long p_GetExpDiff |
( |
poly |
p1, |
|
|
poly |
p2, |
|
|
int |
i, |
|
|
ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_GetExpSum()
static long p_GetExpSum |
( |
poly |
p1, |
|
|
poly |
p2, |
|
|
int |
i, |
|
|
ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_GetExpV()
static void p_GetExpV |
( |
poly |
p, |
|
|
int * |
ev, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 1466 of file p_polys.h.
1469 for (
unsigned j = r->N;
j!=0;
j--)
◆ p_GetExpVL()
static void p_GetExpVL |
( |
poly |
p, |
|
|
int64 * |
ev, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 1475 of file p_polys.h.
1478 for (
unsigned j = r->N;
j!=0;
j--)
◆ p_GetMaxExp() [1/2]
static unsigned long p_GetMaxExp |
( |
const poly |
p, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_GetMaxExp() [2/2]
static unsigned long p_GetMaxExp |
( |
const unsigned long |
l, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 747 of file p_polys.h.
749 unsigned long bitmask = r->bitmask;
750 unsigned long max = (
l & bitmask);
751 unsigned long j = r->ExpPerLong - 1;
755 unsigned long i = r->BitsPerExp;
759 e = ((
l >>
i) & bitmask);
760 if ((
unsigned long) e >
max)
◆ p_GetMaxExpL()
unsigned long p_GetMaxExpL |
( |
poly |
p, |
|
|
const ring |
r, |
|
|
unsigned long |
l_max = 0 |
|
) |
| |
return the maximal exponent of p in form of the maximal long var
Definition at line 1167 of file p_polys.cc.
1169 unsigned long l_p, divmask = r->divmask;
1174 l_p =
p->exp[r->VarL_Offset[0]];
1176 (((l_max & divmask) ^ (l_p & divmask)) != ((l_max-l_p) & divmask)))
1178 for (
i=1;
i<r->VarL_Size;
i++)
1180 l_p =
p->exp[r->VarL_Offset[
i]];
1183 (((l_max & divmask) ^ (l_p & divmask)) != ((l_max-l_p) & divmask)))
◆ p_GetMaxExpP()
poly p_GetMaxExpP |
( |
poly |
p, |
|
|
ring |
r |
|
) |
| |
return monomial r such that GetExp(r,i) is maximum of all monomials in p; coeff == 0, next == NULL, ord is not set
Definition at line 1130 of file p_polys.cc.
1138 unsigned long l_p, l_max;
1139 unsigned long divmask = r->divmask;
1143 offset = r->VarL_Offset[0];
1148 (((l_max & divmask) ^ (l_p & divmask)) != ((l_max-l_p) & divmask)))
1151 for (
i=1;
i<r->VarL_Size;
i++)
1158 (((l_max & divmask) ^ (l_p & divmask)) != ((l_max-l_p) & divmask)))
◆ p_GetOrder()
static long p_GetOrder |
( |
poly |
p, |
|
|
ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 421 of file p_polys.h.
424 if (r->typ==
NULL)
return ((
p)->
exp[r->pOrdIndex]);
428 switch(r->typ[
i].ord_typ)
441 return ((
p)->
exp[r->pOrdIndex]);
◆ p_GetSetmProc()
Definition at line 552 of file p_polys.cc.
559 if (r->typ[0].ord_typ ==
ro_dp &&
560 r->typ[0].data.dp.start == 1 &&
561 r->typ[0].data.dp.end == r->N &&
562 r->typ[0].data.dp.place == r->pOrdIndex)
564 if (r->typ[0].ord_typ ==
ro_wp &&
565 r->typ[0].data.wp.start == 1 &&
566 r->typ[0].data.wp.end == r->N &&
567 r->typ[0].data.wp.place == r->pOrdIndex &&
568 r->typ[0].data.wp.weights == r->firstwv)
◆ p_GetShortExpVector() [1/2]
unsigned long p_GetShortExpVector |
( |
const poly |
a, |
|
|
const ring |
r |
|
) |
| |
Definition at line 4665 of file p_polys.cc.
4668 unsigned long ev = 0;
4682 for (;
j<=r->N;
j++)
◆ p_GetShortExpVector() [2/2]
unsigned long p_GetShortExpVector |
( |
const poly |
p, |
|
|
const poly |
pp, |
|
|
const ring |
r |
|
) |
| |
p_GetShortExpVector of p * pp
Definition at line 4717 of file p_polys.cc.
4722 unsigned long ev = 0;
4726 unsigned long i = 0L;
4737 for (;
j<=r->N;
j++)
◆ p_GetTotalDegree()
static unsigned long p_GetTotalDegree |
( |
const unsigned long |
l, |
|
|
const ring |
r, |
|
|
const int |
number_of_exps |
|
) |
| |
|
inlinestatic |
Definition at line 776 of file p_polys.h.
778 const unsigned long bitmask = r->bitmask;
779 unsigned long sum = (
l & bitmask);
780 unsigned long j = number_of_exps - 1;
784 unsigned long i = r->BitsPerExp;
787 sum += ((
l >>
i) & bitmask);
◆ 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 1259 of file p_polys.cc.
1266 for(
i=r->N;
i>0;
i--)
◆ p_HasNotCF()
◆ p_Head()
static poly p_Head |
( |
poly |
p, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 825 of file p_polys.h.
832 memcpy(np->exp,
p->exp, r->ExpL_Size*
sizeof(
long));
◆ p_Homogen()
poly p_Homogen |
( |
poly |
p, |
|
|
int |
varnum, |
|
|
const ring |
r |
|
) |
| |
◆ p_IncrExp()
static long p_IncrExp |
( |
poly |
p, |
|
|
int |
v, |
|
|
ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_Init() [1/2]
static poly p_Init |
( |
const ring |
r | ) |
|
|
inlinestatic |
◆ p_Init() [2/2]
◆ p_InitContent()
number p_InitContent |
( |
poly |
ph, |
|
|
const ring |
r |
|
) |
| |
Definition at line 2549 of file p_polys.cc.
2573 d=
nlAdd(n1,t,r->cf);
2575 d=
nlSub(n1,t,r->cf);
2584 d=
nlAdd(n2,t,r->cf);
2586 d=
nlSub(n2,t,r->cf);
2593 d=
nlGcd(n1,n2,r->cf);
2616 if (s2==-1)
return n_Copy(d,r->cf);
◆ p_IsConstant()
◆ p_IsConstantComp()
◆ p_IsConstantPoly()
◆ p_ISet()
poly p_ISet |
( |
long |
i, |
|
|
const ring |
r |
|
) |
| |
returns the poly representing the integer i
Definition at line 1289 of file p_polys.cc.
◆ p_IsHomogeneous()
◆ p_IsOne()
either poly(1) or gen(k)?!
Definition at line 1931 of file p_polys.h.
◆ p_IsPurePower()
return i, if head depends only on var(i)
Definition at line 1218 of file p_polys.cc.
◆ p_IsUnit()
◆ p_IsUnivariate()
int p_IsUnivariate |
( |
poly |
p, |
|
|
const ring |
r |
|
) |
| |
return i, if poly depends only on var(i)
Definition at line 1239 of file p_polys.cc.
1249 if((
k!=-1)&&(
k!=
i))
return 0;
◆ p_Jet()
poly p_Jet |
( |
poly |
p, |
|
|
int |
m, |
|
|
const ring |
R |
|
) |
| |
◆ p_JetW()
poly p_JetW |
( |
poly |
p, |
|
|
int |
m, |
|
|
short * |
w, |
|
|
const ring |
R |
|
) |
| |
◆ p_Last()
poly p_Last |
( |
const poly |
a, |
|
|
int & |
l, |
|
|
const ring |
r |
|
) |
| |
◆ p_Lcm() [1/2]
◆ p_Lcm() [2/2]
◆ p_LcmRat()
Definition at line 1624 of file p_polys.cc.
1632 for (
int i = r->real_var_end;
i>=r->real_var_start;
i--)
◆ p_LDeg()
static long p_LDeg |
( |
const poly |
p, |
|
|
int * |
l, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 381 of file p_polys.h.
381 {
return r->pLDeg(
p,
l,r); }
◆ p_LmCheckIsFromRing()
BOOLEAN p_LmCheckIsFromRing |
( |
poly |
p, |
|
|
ring |
r |
|
) |
| |
Definition at line 71 of file pDebug.cc.
75 #if (OM_TRACK > 0) && defined(OM_TRACK_CUSTOM)
76 void* custom = omGetCustomOfAddr(
p);
85 "monomial not from specified ring",
p,r);
◆ p_LmCheckPolyRing()
BOOLEAN p_LmCheckPolyRing |
( |
poly |
p, |
|
|
ring |
r |
|
) |
| |
◆ p_LmCmp()
static int p_LmCmp |
( |
poly |
p, |
|
|
poly |
q, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 1507 of file p_polys.h.
1512 const unsigned long* _s1 = ((
unsigned long*)
p->exp);
1513 const unsigned long* _s2 = ((
unsigned long*) q->exp);
1516 const unsigned long _l = r->CmpL_Size;
1520 LengthGeneral_OrdGeneral_LoopTop:
1526 if (_i == _l)
return 0;
1527 goto LengthGeneral_OrdGeneral_LoopTop;
1529 const long* _ordsgn = (
long*) r->ordsgn;
1535 return -(_ordsgn[_i]);
1539 if (_ordsgn[_i] == 1)
return 1;
1542 if (_ordsgn[_i] == 1)
return -1;
◆ p_LmDelete() [1/2]
static void p_LmDelete |
( |
poly * |
p, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_LmDelete() [2/2]
static void p_LmDelete |
( |
poly |
p, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_LmDeleteAndNext()
static poly p_LmDeleteAndNext |
( |
poly |
p, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_LmDeleteAndNextRat()
void p_LmDeleteAndNextRat |
( |
poly * |
p, |
|
|
int |
ishift, |
|
|
ring |
r |
|
) |
| |
◆ p_LmDivisibleBy() [1/2]
◆ p_LmDivisibleBy() [2/2]
static BOOLEAN p_LmDivisibleBy |
( |
poly |
a, |
|
|
poly |
b, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_LmDivisibleByNoComp() [1/2]
static BOOLEAN p_LmDivisibleByNoComp |
( |
poly |
a, |
|
|
const ring |
ra, |
|
|
poly |
b, |
|
|
const ring |
rb |
|
) |
| |
|
inlinestatic |
◆ p_LmDivisibleByNoComp() [2/2]
static BOOLEAN p_LmDivisibleByNoComp |
( |
poly |
a, |
|
|
poly |
b, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_LmDivisibleByPart()
◆ p_LmExpVectorAddIsOk()
Definition at line 1958 of file p_polys.h.
1963 unsigned long l1, l2, divmask = r->divmask;
1966 for (
i=0;
i<r->VarL_Size;
i++)
1968 l1 = p1->exp[r->VarL_Offset[
i]];
1969 l2 = p2->exp[r->VarL_Offset[
i]];
1971 if ( (l1 > ULONG_MAX - l2) ||
1972 (((l1 & divmask) ^ (l2 & divmask)) != ((l1 + l2) & divmask)))
◆ p_LmFree() [1/2]
static void p_LmFree |
( |
poly * |
p, |
|
|
ring |
|
|
) |
| |
|
inlinestatic |
◆ p_LmFree() [2/2]
static void p_LmFree |
( |
poly |
p, |
|
|
ring |
|
|
) |
| |
|
inlinestatic |
◆ p_LmFreeAndNext()
static poly p_LmFreeAndNext |
( |
poly |
p, |
|
|
ring |
|
|
) |
| |
|
inlinestatic |
◆ p_LmInit() [1/3]
static poly p_LmInit |
( |
poly |
p, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 1281 of file p_polys.h.
1287 memcpy(np->exp,
p->exp, r->ExpL_Size*
sizeof(
long));
◆ p_LmInit() [2/3]
static poly p_LmInit |
( |
poly |
s_p, |
|
|
const ring |
s_r, |
|
|
const ring |
d_r |
|
) |
| |
|
inlinestatic |
◆ p_LmInit() [3/3]
static poly p_LmInit |
( |
poly |
s_p, |
|
|
const ring |
s_r, |
|
|
const ring |
d_r, |
|
|
omBin |
d_bin |
|
) |
| |
|
inlinestatic |
Definition at line 1292 of file p_polys.h.
1297 poly d_p =
p_Init(d_r, d_bin);
1298 for (
unsigned i=d_r->N;
i!=0;
i--)
◆ p_LmIsConstant()
◆ p_LmIsConstantComp()
Definition at line 962 of file p_polys.h.
965 int i = r->VarL_Size - 1;
969 if (
p->exp[r->VarL_Offset[
i]] != 0)
◆ p_LmShallowCopyDelete()
static poly p_LmShallowCopyDelete |
( |
poly |
p, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 1339 of file p_polys.h.
1343 poly new_p =
p_New(r);
1344 memcpy(new_p->exp,
p->exp, r->ExpL_Size*
sizeof(
long));
◆ p_LmShortDivisibleBy() [1/2]
static BOOLEAN p_LmShortDivisibleBy |
( |
poly |
a, |
|
|
unsigned long |
sev_a, |
|
|
const ring |
r_a, |
|
|
poly |
b, |
|
|
unsigned long |
not_sev_b, |
|
|
const ring |
r_b |
|
) |
| |
|
inlinestatic |
Definition at line 1889 of file p_polys.h.
1898 if (sev_a & not_sev_b)
◆ p_LmShortDivisibleBy() [2/2]
static BOOLEAN p_LmShortDivisibleBy |
( |
poly |
a, |
|
|
unsigned long |
sev_a, |
|
|
poly |
b, |
|
|
unsigned long |
not_sev_b, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 1849 of file p_polys.h.
1858 if (sev_a & not_sev_b)
◆ p_LmShortDivisibleByNoComp()
static BOOLEAN p_LmShortDivisibleByNoComp |
( |
poly |
a, |
|
|
unsigned long |
sev_a, |
|
|
poly |
b, |
|
|
unsigned long |
not_sev_b, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 1869 of file p_polys.h.
1878 if (sev_a & not_sev_b)
◆ p_LowVar()
int p_LowVar |
( |
poly |
p, |
|
|
const ring |
r |
|
) |
| |
the minimal index of used variables - 1
Definition at line 4564 of file p_polys.cc.
4568 if (
p ==
NULL)
return -1;
4575 while ((
l < (
rVar(r))) && (lex == 0))
◆ p_LtCmp()
static int p_LtCmp |
( |
poly |
p, |
|
|
poly |
q, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_LtCmpNoAbs()
static int p_LtCmpNoAbs |
( |
poly |
p, |
|
|
poly |
q, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_LtCmpOrdSgnDiffM()
static int p_LtCmpOrdSgnDiffM |
( |
poly |
p, |
|
|
poly |
q, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_LtCmpOrdSgnDiffP()
static int p_LtCmpOrdSgnDiffP |
( |
poly |
p, |
|
|
poly |
q, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_LtCmpOrdSgnEqM()
static int p_LtCmpOrdSgnEqM |
( |
poly |
p, |
|
|
poly |
q, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_LtCmpOrdSgnEqP()
static int p_LtCmpOrdSgnEqP |
( |
poly |
p, |
|
|
poly |
q, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_MaxComp() [1/2]
static long p_MaxComp |
( |
poly |
p, |
|
|
ring |
lmRing |
|
) |
| |
|
inlinestatic |
◆ p_MaxComp() [2/2]
static long p_MaxComp |
( |
poly |
p, |
|
|
ring |
lmRing, |
|
|
ring |
tailRing |
|
) |
| |
|
inlinestatic |
◆ p_MDivide()
poly p_MDivide |
( |
poly |
a, |
|
|
poly |
b, |
|
|
const ring |
r |
|
) |
| |
◆ p_MemAdd_NegWeightAdjust()
static void p_MemAdd_NegWeightAdjust |
( |
poly |
p, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 1238 of file p_polys.h.
1240 if (r->NegWeightL_Offset !=
NULL)
1242 for (
int i=r->NegWeightL_Size-1;
i>=0;
i--)
◆ p_MemSub_NegWeightAdjust()
static void p_MemSub_NegWeightAdjust |
( |
poly |
p, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 1248 of file p_polys.h.
1250 if (r->NegWeightL_Offset !=
NULL)
1252 for (
int i=r->NegWeightL_Size-1;
i>=0;
i--)
◆ p_Merge_q()
static poly p_Merge_q |
( |
poly |
p, |
|
|
poly |
q, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 1158 of file p_polys.h.
1161 return r->p_Procs->p_Merge_q(
p, q, r);
◆ p_MinComp() [1/2]
static long p_MinComp |
( |
poly |
p, |
|
|
ring |
lmRing |
|
) |
| |
|
inlinestatic |
◆ p_MinComp() [2/2]
static long p_MinComp |
( |
poly |
p, |
|
|
ring |
lmRing, |
|
|
ring |
tailRing |
|
) |
| |
|
inlinestatic |
◆ p_MinDeg()
◆ p_mInit()
Definition at line 1412 of file p_polys.cc.
1418 if ((
s!=st)&&isdigit(st[0]))
◆ p_Minus_mm_Mult_qq() [1/2]
static poly p_Minus_mm_Mult_qq |
( |
poly |
p, |
|
|
const poly |
m, |
|
|
const poly |
q, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 1017 of file p_polys.h.
1021 return r->p_Procs->p_Minus_mm_Mult_qq(
p,
m, q, shorter,
NULL, r);
◆ p_Minus_mm_Mult_qq() [2/2]
static poly p_Minus_mm_Mult_qq |
( |
poly |
p, |
|
|
const poly |
m, |
|
|
const poly |
q, |
|
|
int & |
lp, |
|
|
int |
lq, |
|
|
const poly |
spNoether, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 1006 of file p_polys.h.
1010 const poly
res = r->p_Procs->p_Minus_mm_Mult_qq(
p,
m, q, shorter, spNoether, r);
◆ p_Mult_mm()
static poly p_Mult_mm |
( |
poly |
p, |
|
|
poly |
m, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 997 of file p_polys.h.
1003 return r->p_Procs->p_Mult_mm(
p,
m, r);
◆ p_Mult_nn() [1/2]
static poly p_Mult_nn |
( |
poly |
p, |
|
|
number |
n, |
|
|
const ring |
lmRing, |
|
|
const ring |
tailRing |
|
) |
| |
|
inlinestatic |
Definition at line 929 of file p_polys.h.
934 if (lmRing == tailRing)
939 p = lmRing->p_Procs->p_Mult_nn(
p, n, lmRing);
942 pNext(
p) = tailRing->p_Procs->p_Mult_nn(pnext, n, tailRing);
◆ p_Mult_nn() [2/2]
static poly p_Mult_nn |
( |
poly |
p, |
|
|
number |
n, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 914 of file p_polys.h.
925 return r->p_Procs->p_Mult_nn(
p, n, r);
◆ p_Mult_q()
static poly p_Mult_q |
( |
poly |
p, |
|
|
poly |
q, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 1050 of file p_polys.h.
1072 q = r->p_Procs->p_Mult_mm(q,
p, r);
1080 p = r->p_Procs->p_Mult_mm(
p, q, r);
◆ p_MultExp()
static long p_MultExp |
( |
poly |
p, |
|
|
int |
v, |
|
|
long |
ee, |
|
|
ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_Neg()
static poly p_Neg |
( |
poly |
p, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 1043 of file p_polys.h.
1045 return r->p_Procs->p_Neg(
p, r);
◆ p_New() [1/2]
◆ p_New() [2/2]
static poly p_New |
( |
ring |
r | ) |
|
|
inlinestatic |
◆ p_Norm()
void p_Norm |
( |
poly |
p1, |
|
|
const ring |
r |
|
) |
| |
◆ p_Normalize()
void p_Normalize |
( |
poly |
p, |
|
|
const ring |
r |
|
) |
| |
◆ p_NSet()
poly p_NSet |
( |
number |
n, |
|
|
const ring |
r |
|
) |
| |
returns the poly representing the number n, destroys n
Definition at line 1435 of file p_polys.cc.
◆ p_One()
poly p_One |
( |
const ring |
r | ) |
|
◆ p_OneComp()
return TRUE if all monoms have the same component
Definition at line 1200 of file p_polys.cc.
◆ p_PermPoly()
Definition at line 4014 of file p_polys.cc.
4021 const int OldpVariables =
rVar(oldRing);
4023 poly result_last =
NULL;
4029 poly tmp_mm=
p_One(dst);
4039 number n = nMap(
p_GetCoeff(
p, oldRing), oldRing->cf, dst->cf);
4068 int mapped_to_par = 0;
4069 for(
int i = 1;
i <= OldpVariables;
i++)
4099 n_Power(ee, e, &eee, dst->cf);
4100 ee =
n_Mult(c, eee, dst->cf);
4106 const int par = -perm[
i];
4110 const coeffs C = dst->cf;
4112 const ring
R = C->extRing;
4120 pcn = NUM((fraction)c);
4181 if (result_last==
NULL)
4187 pNext(result_last)=qq;
◆ p_Plus_mm_Mult_qq() [1/2]
static poly p_Plus_mm_Mult_qq |
( |
poly |
p, |
|
|
poly |
m, |
|
|
poly |
q, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_Plus_mm_Mult_qq() [2/2]
static poly p_Plus_mm_Mult_qq |
( |
poly |
p, |
|
|
poly |
m, |
|
|
poly |
q, |
|
|
int & |
lp, |
|
|
int |
lq, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 1129 of file p_polys.h.
1141 number n_neg =
n_Copy(n_old, r->cf);
1144 res = r->p_Procs->p_Minus_mm_Mult_qq(
p,
m, q, shorter,
NULL, r);
1145 lp = (lp +
lq) - shorter;
◆ p_PolyDiv()
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 1817 of file p_polys.cc.
1824 int divisorLE =
p_GetExp(divisor, 1, r);
◆ p_Power()
poly p_Power |
( |
poly |
p, |
|
|
int |
i, |
|
|
const ring |
r |
|
) |
| |
Definition at line 2144 of file p_polys.cc.
2156 if ( (
i > 0) && ((
unsigned long )
i > (r->bitmask)))
2158 Werror(
"exponent %d is too large, max. is %ld",
i,r->bitmask);
2202 int char_p=
rChar(r);
2203 if ((char_p>0) && (
i>char_p)
2209 while (rest>=char_p)
2224 if ((char_p==0) || (
i<=char_p))
◆ p_ProjectiveUnique()
void p_ProjectiveUnique |
( |
poly |
p, |
|
|
const ring |
r |
|
) |
| |
Definition at line 3080 of file p_polys.cc.
3141 fraction
f = (fraction)
h;
3152 if (!
n_IsOne (n, C->extRing->cf))
3156 nMap=
n_SetMap (C->extRing->cf, C);
3157 number ninv= nMap (n,C->extRing->cf, C);
◆ p_Read()
Definition at line 1340 of file p_polys.cc.
1353 while (*
s!=
'\0')
s++;
1365 const char *s_save=
s;
1367 if (((
unsigned long)
i) > r->bitmask/2)
1398 for(
unsigned int k = iFirstAltVar;
k <= iLastAltVar;
k++)
◆ p_Series()
poly p_Series |
( |
int |
n, |
|
|
poly |
p, |
|
|
poly |
u, |
|
|
intvec * |
w, |
|
|
const ring |
R |
|
) |
| |
Definition at line 4382 of file p_polys.cc.
4390 p=
p_JetW(
p_Mult_q(
p,
p_Invers(n-
p_MinDeg(
p,
w,
R),u,
w,
R),
R),n,ww,
R);
◆ p_SetCoeff()
static number p_SetCoeff |
( |
poly |
p, |
|
|
number |
n, |
|
|
ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_SetComp()
static unsigned long p_SetComp |
( |
poly |
p, |
|
|
unsigned long |
c, |
|
|
ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_SetCompP() [1/2]
static void p_SetCompP |
( |
poly |
p, |
|
|
int |
i, |
|
|
ring |
lmRing, |
|
|
ring |
tailRing |
|
) |
| |
|
inlinestatic |
◆ p_SetCompP() [2/2]
static void p_SetCompP |
( |
poly |
p, |
|
|
int |
i, |
|
|
ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_SetExp() [1/3]
set v^th exponent for a monomial
Definition at line 582 of file p_polys.h.
587 return p_SetExp(
p, e, r->bitmask, r->VarOffset[
v]);
◆ p_SetExp() [2/3]
static long p_SetExp |
( |
poly |
p, |
|
|
const long |
e, |
|
|
const ring |
r, |
|
|
const int |
VarOffset |
|
) |
| |
|
inlinestatic |
◆ p_SetExp() [3/3]
static unsigned long p_SetExp |
( |
poly |
p, |
|
|
const unsigned long |
e, |
|
|
const unsigned long |
iBitmask, |
|
|
const int |
VarOffset |
|
) |
| |
|
inlinestatic |
set a single variable exponent @Note: VarOffset encodes the position in p->exp
- See also
- p_GetExp
Definition at line 488 of file p_polys.h.
492 pAssume2((VarOffset >> (24 + 6)) == 0);
495 REGISTER int shift = VarOffset >> 24;
496 unsigned long ee = e << shift ;
500 p->exp[
offset] &= ~( iBitmask << shift );
◆ p_SetExpV()
static void p_SetExpV |
( |
poly |
p, |
|
|
int * |
ev, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 1481 of file p_polys.h.
1484 for (
unsigned j = r->N;
j!=0;
j--)
◆ p_SetExpVL()
static void p_SetExpVL |
( |
poly |
p, |
|
|
int64 * |
ev, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 1491 of file p_polys.h.
1494 for (
unsigned j = r->N;
j!=0;
j--)
◆ p_Setm()
static void p_Setm |
( |
poly |
p, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_SetModDeg()
void p_SetModDeg |
( |
intvec * |
w, |
|
|
ring |
r |
|
) |
| |
◆ p_ShallowCopyDelete()
static poly p_ShallowCopyDelete |
( |
poly |
p, |
|
|
const ring |
r, |
|
|
omBin |
bin |
|
) |
| |
|
inlinestatic |
Definition at line 884 of file p_polys.h.
888 return r->p_Procs->p_ShallowCopyDelete(
p, r, bin);
◆ p_ShallowDelete()
void p_ShallowDelete |
( |
poly * |
p, |
|
|
const ring |
r |
|
) |
| |
◆ p_Shift()
void p_Shift |
( |
poly * |
p, |
|
|
int |
i, |
|
|
const ring |
r |
|
) |
| |
shifts components of the vector p by i
Definition at line 4590 of file p_polys.cc.
4592 poly qp1 = *
p,qp2 = *
p;
4617 qp2->next = qp1->next;
◆ p_SimpleContent()
void p_SimpleContent |
( |
poly |
p, |
|
|
int |
s, |
|
|
const ring |
r |
|
) |
| |
Definition at line 2492 of file p_polys.cc.
2495 if (ph==
NULL)
return;
2506 if (
n_Size(d,r->cf)<=smax)
2514 if (smax==1) smax=2;
◆ p_Size()
int p_Size |
( |
poly |
p, |
|
|
const ring |
r |
|
) |
| |
Definition at line 3191 of file p_polys.cc.
3194 if (r->cf->has_simple_Alloc)
◆ p_SortAdd()
◆ p_SortMerge()
◆ p_Split()
void p_Split |
( |
poly |
p, |
|
|
poly * |
r |
|
) |
| |
◆ p_String() [1/2]
char* p_String |
( |
poly |
p, |
|
|
ring |
lmRing, |
|
|
ring |
tailRing |
|
) |
| |
◆ p_String() [2/2]
static char* p_String |
( |
poly |
p, |
|
|
ring |
p_ring |
|
) |
| |
|
inlinestatic |
◆ p_String0() [1/2]
void p_String0 |
( |
poly |
p, |
|
|
ring |
lmRing, |
|
|
ring |
tailRing |
|
) |
| |
print p according to ShortOut in lmRing & tailRing
Definition at line 134 of file polys0.cc.
145 if ((
p_GetComp(
p, lmRing) == 0) || (!lmRing->VectorOut))
177 if (
p ==
NULL)
break;
◆ p_String0() [2/2]
static void p_String0 |
( |
poly |
p, |
|
|
ring |
p_ring |
|
) |
| |
|
inlinestatic |
◆ p_String0Long()
void p_String0Long |
( |
const poly |
p, |
|
|
ring |
lmRing, |
|
|
ring |
tailRing |
|
) |
| |
print p in a long way
print p in a long way
Definition at line 114 of file polys0.cc.
124 lmRing->ShortOut =
FALSE;
125 tailRing->ShortOut =
FALSE;
129 lmRing->ShortOut = bLMShortOut;
130 tailRing->ShortOut = bTAILShortOut;
◆ p_String0Short()
void p_String0Short |
( |
const poly |
p, |
|
|
ring |
lmRing, |
|
|
ring |
tailRing |
|
) |
| |
print p in a short way, if possible
print p in a short way, if possible
Definition at line 95 of file polys0.cc.
109 lmRing->ShortOut = bLMShortOut;
110 tailRing->ShortOut = bTAILShortOut;
◆ p_Sub()
poly p_Sub |
( |
poly |
a, |
|
|
poly |
b, |
|
|
const ring |
r |
|
) |
| |
◆ p_SubComp()
static unsigned long p_SubComp |
( |
poly |
p, |
|
|
unsigned long |
v, |
|
|
ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_SubExp()
static long p_SubExp |
( |
poly |
p, |
|
|
int |
v, |
|
|
long |
ee, |
|
|
ring |
r |
|
) |
| |
|
inlinestatic |
◆ p_Subst()
poly p_Subst |
( |
poly |
p, |
|
|
int |
n, |
|
|
poly |
e, |
|
|
const ring |
r |
|
) |
| |
◆ p_TakeOutComp() [1/2]
poly p_TakeOutComp |
( |
poly * |
p, |
|
|
int |
k, |
|
|
const ring |
r |
|
) |
| |
◆ p_TakeOutComp() [2/2]
void p_TakeOutComp |
( |
poly * |
p, |
|
|
long |
comp, |
|
|
poly * |
q, |
|
|
int * |
lq, |
|
|
const ring |
r |
|
) |
| |
◆ p_TakeOutComp1()
poly p_TakeOutComp1 |
( |
poly * |
p, |
|
|
int |
k, |
|
|
const ring |
r |
|
) |
| |
◆ p_Totaldegree()
static long p_Totaldegree |
( |
poly |
p, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 1453 of file p_polys.h.
1459 for (
unsigned i=r->VarL_Size-1;
i!=0;
i--)
◆ p_Var()
int p_Var |
( |
poly |
mi, |
|
|
const ring |
r |
|
) |
| |
◆ p_Vec2Array()
void p_Vec2Array |
( |
poly |
v, |
|
|
poly * |
p, |
|
|
int |
len, |
|
|
const ring |
r |
|
) |
| |
julia: vector to already allocated array (len=p_MaxComp(v,r))
Definition at line 3550 of file p_polys.cc.
3564 for(
int i=len-1;
i>=0;
i--)
◆ p_Vec2Polys()
void p_Vec2Polys |
( |
poly |
v, |
|
|
poly ** |
p, |
|
|
int * |
len, |
|
|
const ring |
r |
|
) |
| |
Definition at line 3527 of file p_polys.cc.
3533 if (*len==0) *len=1;
3534 *
p=(poly*)
omAlloc0((*len)*
sizeof(poly));
3543 for(
int i=(*len-1);
i>=0;
i--)
◆ p_VectorHasUnit()
void p_VectorHasUnit |
( |
poly |
p, |
|
|
int * |
k, |
|
|
int * |
len, |
|
|
const ring |
r |
|
) |
| |
Definition at line 3302 of file p_polys.cc.
3323 if ((*len == 0) || (
j<*len))
◆ p_VectorHasUnitB()
◆ p_WDegree()
long p_WDegree |
( |
poly |
p, |
|
|
const ring |
r |
|
) |
| |
Definition at line 706 of file p_polys.cc.
713 for(
i=1;
i<=r->firstBlockEnds;
i++)
◆ p_Weight()
int p_Weight |
( |
int |
c, |
|
|
const ring |
r |
|
) |
| |
Definition at line 697 of file p_polys.cc.
699 if ((r->firstwv==
NULL) || (
i>r->firstBlockEnds))
703 return r->firstwv[
i-1];
◆ p_WFirstTotalDegree()
long p_WFirstTotalDegree |
( |
poly |
p, |
|
|
ring |
r |
|
) |
| |
Definition at line 588 of file p_polys.cc.
593 for (
i=1;
i<= r->firstBlockEnds;
i++)
◆ p_Write() [1/2]
void p_Write |
( |
poly |
p, |
|
|
ring |
lmRing, |
|
|
ring |
tailRing |
|
) |
| |
◆ p_Write() [2/2]
static void p_Write |
( |
poly |
p, |
|
|
ring |
p_ring |
|
) |
| |
|
inlinestatic |
◆ p_Write0() [1/2]
void p_Write0 |
( |
poly |
p, |
|
|
ring |
lmRing, |
|
|
ring |
tailRing |
|
) |
| |
◆ p_Write0() [2/2]
static void p_Write0 |
( |
poly |
p, |
|
|
ring |
p_ring |
|
) |
| |
|
inlinestatic |
◆ p_wrp() [1/2]
void p_wrp |
( |
poly |
p, |
|
|
ring |
lmRing, |
|
|
ring |
tailRing |
|
) |
| |
◆ p_wrp() [2/2]
static void p_wrp |
( |
poly |
p, |
|
|
ring |
p_ring |
|
) |
| |
|
inlinestatic |
◆ p_WTotaldegree()
long p_WTotaldegree |
( |
poly |
p, |
|
|
const ring |
r |
|
) |
| |
Definition at line 605 of file p_polys.cc.
612 for (
i=0;r->order[
i]!=0;
i++)
619 for (
k=b0 ;
k<=b1 ;
k++)
628 for (
k=b0 ;
k<=b1 ;
k++)
637 for (
k=b0 ;
k<=b1 ;
k++)
650 for (
k=b0 ;
k<=b1 ;
k++)
658 for (
k=0;
k<=(b1 - b0 );
k++)
◆ pEnlargeSet()
void pEnlargeSet |
( |
poly ** |
p, |
|
|
int |
length, |
|
|
int |
increment |
|
) |
| |
Definition at line 3633 of file p_polys.cc.
3639 if (increment==0)
return;
3640 h=(poly*)
omAlloc0(increment*
sizeof(poly));
3647 memset(&(
h[
l]),0,increment*
sizeof(poly));
◆ pHaveCommonMonoms()
BOOLEAN pHaveCommonMonoms |
( |
poly |
p, |
|
|
poly |
q |
|
) |
| |
◆ pIsMonomOf()
BOOLEAN pIsMonomOf |
( |
poly |
p, |
|
|
poly |
m |
|
) |
| |
◆ pLDeg0()
long pLDeg0 |
( |
poly |
p, |
|
|
int * |
l, |
|
|
ring |
r |
|
) |
| |
◆ pLDeg0c()
long pLDeg0c |
( |
poly |
p, |
|
|
int * |
l, |
|
|
ring |
r |
|
) |
| |
◆ pLDeg1()
long pLDeg1 |
( |
poly |
p, |
|
|
int * |
l, |
|
|
ring |
r |
|
) |
| |
◆ pLDeg1_Deg()
long pLDeg1_Deg |
( |
poly |
p, |
|
|
int * |
l, |
|
|
ring |
r |
|
) |
| |
◆ pLDeg1_Totaldegree()
long pLDeg1_Totaldegree |
( |
poly |
p, |
|
|
int * |
l, |
|
|
ring |
r |
|
) |
| |
◆ pLDeg1_WFirstTotalDegree()
long pLDeg1_WFirstTotalDegree |
( |
poly |
p, |
|
|
int * |
l, |
|
|
ring |
r |
|
) |
| |
◆ pLDeg1c()
long pLDeg1c |
( |
poly |
p, |
|
|
int * |
l, |
|
|
ring |
r |
|
) |
| |
◆ pLDeg1c_Deg()
long pLDeg1c_Deg |
( |
poly |
p, |
|
|
int * |
l, |
|
|
ring |
r |
|
) |
| |
◆ pLDeg1c_Totaldegree()
long pLDeg1c_Totaldegree |
( |
poly |
p, |
|
|
int * |
l, |
|
|
ring |
r |
|
) |
| |
◆ pLDeg1c_WFirstTotalDegree()
long pLDeg1c_WFirstTotalDegree |
( |
poly |
p, |
|
|
int * |
l, |
|
|
ring |
r |
|
) |
| |
◆ pLDegb()
long pLDegb |
( |
poly |
p, |
|
|
int * |
l, |
|
|
ring |
r |
|
) |
| |
Definition at line 803 of file p_polys.cc.
807 long o = r->pFDeg(
p, r);
◆ pLength()
static unsigned pLength |
( |
poly |
a | ) |
|
|
inlinestatic |
◆ pp_Jet()
poly pp_Jet |
( |
poly |
p, |
|
|
int |
m, |
|
|
const ring |
R |
|
) |
| |
◆ pp_JetW()
poly pp_JetW |
( |
poly |
p, |
|
|
int |
m, |
|
|
short * |
w, |
|
|
const ring |
R |
|
) |
| |
◆ pp_Mult_Coeff_mm_DivSelect() [1/2]
static poly pp_Mult_Coeff_mm_DivSelect |
( |
poly |
p, |
|
|
const poly |
m, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 1026 of file p_polys.h.
1029 return r->p_Procs->pp_Mult_Coeff_mm_DivSelect(
p,
m, shorter, r);
◆ pp_Mult_Coeff_mm_DivSelect() [2/2]
static poly pp_Mult_Coeff_mm_DivSelect |
( |
poly |
p, |
|
|
int & |
lp, |
|
|
const poly |
m, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 1034 of file p_polys.h.
1037 poly
pp = r->p_Procs->pp_Mult_Coeff_mm_DivSelect(
p,
m, shorter, r);
◆ pp_Mult_mm()
static poly pp_Mult_mm |
( |
poly |
p, |
|
|
poly |
m, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 987 of file p_polys.h.
993 return r->p_Procs->pp_Mult_mm(
p,
m, r);
◆ pp_Mult_nn()
static poly pp_Mult_nn |
( |
poly |
p, |
|
|
number |
n, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 948 of file p_polys.h.
956 return r->p_Procs->pp_Mult_nn(
p, n, r);
◆ pp_Mult_qq()
static poly pp_Mult_qq |
( |
poly |
p, |
|
|
poly |
q, |
|
|
const ring |
r |
|
) |
| |
|
inlinestatic |
Definition at line 1093 of file p_polys.h.
1103 return r->p_Procs->pp_Mult_mm(q,
p, r);
1108 return r->p_Procs->pp_Mult_mm(
p, q, r);
◆ pRestoreDegProcs()
Definition at line 3586 of file p_polys.cc.
3589 r->pFDeg = old_FDeg;
3590 r->pLDeg = old_lDeg;
◆ pReverse()
static poly pReverse |
( |
poly |
p | ) |
|
|
inlinestatic |
◆ pSetDegProcs()
Definition at line 3574 of file p_polys.cc.
3577 r->pFDeg = new_FDeg;
3579 if (new_lDeg ==
NULL)
3580 new_lDeg = r->pLDegOrig;
3582 r->pLDeg = new_lDeg;
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
#define _pPolyAssume2(cond, p, r)
static poly p_Pow_charp(poly p, int i, const ring r)
static int si_min(const int a, const int b)
static poly _p_Mult_q_Normal(poly p, poly q, const int copy, const ring r)
static BOOLEAN _p_LmDivisibleByNoCompPart(poly a, const ring r_a, poly b, const ring r_b, const int start, const int end)
static unsigned long p_SubComp(poly p, unsigned long v, ring r)
static poly p_LmFreeAndNext(poly p, ring)
int exponent(const CanonicalForm &f, int q)
int exponent ( const CanonicalForm & f, int q )
#define p_MemCmp_LengthGeneral_OrdGeneral(s1, s2, length, ordsgn, actionE, actionG, actionS)
#define pIfThen1(cond, check)
static void writemon(poly p, int ko, const ring r)
static BOOLEAN _p_LmDivisibleByNoComp(poly a, poly b, const ring r)
return: FALSE, if there exists i, such that a->exp[i] > b->exp[i] TRUE, otherwise (1) Consider long v...
#define p_MemDiff_LengthGeneral(r, s1, s2, length)
static unsigned long p_GetTotalDegree(const unsigned long l, const ring r, const int number_of_exps)
void StringAppendS(const char *st)
static BOOLEAN p_LmIsConstantComp(const poly p, const ring r)
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
#define p_MemSum_LengthGeneral(r, s1, s2, length)
void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
static poly _p_Mult_q_Normal_ZeroDiv(poly p, poly q, const int copy, const ring r)
static poly p_DebugInit(poly p, ring src_ring, ring dest_ring)
static poly p_MonPower(poly p, int exp, const ring r)
void p_Normalize(poly p, const ring r)
BOOLEAN pDebugLmShortDivisibleByNoComp(poly p1, unsigned long sev_1, ring r_1, poly p2, unsigned long not_sev_2, ring r_2)
static poly p_Invers(int n, poly u, intvec *w, const ring R)
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 ...
void p_Write0(poly p, ring lmRing, ring tailRing)
BOOLEAN rOrd_SetCompRequiresSetm(const ring r)
return TRUE if p_SetComp requires p_Setm
static BOOLEAN rCanShortOut(const ring r)
poly singclap_gcd(poly f, poly g, const ring r)
destroys f and g
BOOLEAN p_CheckIsFromRing(poly p, ring r)
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
static pLDegProc pOldLDeg
void sBucketDestroyAdd(sBucket_pt bucket, poly *p, int *length)
void sBucket_Add_m(sBucket_pt bucket, poly p)
unsigned long p_GetShortExpVector(const poly a, const ring r)
unsigned long p_GetMaxExpL(poly p, const ring r, unsigned long l_max=0)
return the maximal exponent of p in form of the maximal long var
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)
BOOLEAN p_DebugLmDivisibleByNoComp(poly a, poly b, ring r)
#define p_SetRingOfLm(p, r)
long(* pFDegProc)(poly p, ring r)
static poly p_Head(poly p, const ring r)
static poly p_Mult_mm(poly p, poly m, const ring r)
#define MIN_LENGTH_BUCKET
#define p_MemSub_LengthGeneral(r, s, length)
char * p_String(poly p, ring lmRing, ring tailRing)
static poly p_Neg(poly p, const ring r)
static poly p_LmInit(poly p, const ring r)
static void p_SetCompP(poly p, int i, ring r)
static poly p_Plus_mm_Mult_qq(poly p, poly m, poly q, int &lp, int lq, const ring r)
static poly p_TwoMonPower(poly p, int exp, const ring r)
short * iv2array(intvec *iv, const ring R)
poly singclap_pdivide(poly f, poly g, const ring r)
long totaldegreeWecart_IV(poly p, ring r, const short *w)
BOOLEAN pqLength(poly p, poly q, int &lp, int &lq, const int min)
#define TEST_OPT_CONTENTSB
#define __p_GetComp(p, r)
static void p_MemAdd_NegWeightAdjust(poly p, const ring r)
number ndCopyMap(number a, const coeffs aRing, const coeffs r)
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
#define p_MemAdd_LengthGeneral(r, s, length)
number p_InitContent(poly ph, const ring r)
void p_wrp(poly p, ring lmRing, ring tailRing)
static unsigned long p_GetMaxExpL2(unsigned long l1, unsigned long l2, const ring r, unsigned long number_of_exp)
static const FORCE_INLINE char * n_Read(const char *s, number *a, const coeffs r)
!!! Recommendation: This method is too cryptic to be part of the user- !!! interface....
const CanonicalForm CFMap CFMap & N
static BOOLEAN rField_is_Zp_a(const ring r)
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
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....
static FORCE_INLINE BOOLEAN n_Greater(number a, number b, const coeffs r)
ordered fields: TRUE iff 'a' is larger than 'b'; in Z/pZ: TRUE iff la > lb, where la and lb are the l...
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
#define POLY_NEGWEIGHT_OFFSET
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...
static BOOLEAN rField_has_Units(const ring r)
#define __p_Mult_nn(p, n, r)
void p_Lcm(const poly a, const poly b, poly m, const ring r)
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
LINLINE number nlSub(number la, number li, const coeffs r)
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
static void p_ExpVectorSub(poly p1, poly p2, const ring r)
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,...
#define p_LmEqual(p1, p2, r)
void p_Setm_Dummy(poly p, const ring r)
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
BOOLEAN p_LmCheckPolyRing(poly p, ring r)
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
static int rGetCurrSyzLimit(const ring r)
static unsigned pLength(poly a)
BOOLEAN _p_LmTest(poly p, ring r, int level)
poly n_PermNumber(const number z, const int *par_perm, const int, const ring src, const ring dst)
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
int r_IsRingVar(const char *n, char **names, int N)
static void p_SetExpV(poly p, int *ev, const ring r)
void p_LmDeleteAndNextRat(poly *p, int ishift, ring r)
for(int i=0;i<=n;i++) degsf[i]
long p_WFirstTotalDegree(poly p, const ring r)
static poly p_Copy(poly p, const ring r)
returns a copy of p
poly p_Power(poly p, int i, const ring r)
static pFDegProc pOldFDeg
BOOLEAN p_LmCheckIsFromRing(poly p, ring r)
static short rVar(const ring r)
#define rVar(r) (r->N)
static long p_MinComp(poly p, ring lmRing, ring tailRing)
#define p_MemAddSub_LengthGeneral(r, s, t, length)
static long p_GetOrder(poly p, ring r)
#define TEST_OPT_INTSTRATEGY
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)
#define omIsBinPageAddr(addr)
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
static BOOLEAN rField_is_Q_a(const ring r)
static poly p_SortAdd(poly p, const ring r, BOOLEAN revert=FALSE)
#define pPolyAssumeReturnMsg(cond, msg)
#define _pPolyAssumeReturnMsg(cond, msg, p, r)
static FORCE_INLINE void n_Write(number n, const coeffs r, const BOOLEAN bShortOut=TRUE)
#define TEST_OPT_NOT_BUCKETS
void PrintS(const char *s)
size_t omSizeWOfAddr(void *addr)
poly sBucketSortAdd(poly p, const ring r)
Sorts p with bucketSort: p may have equal monomials.
#define omFreeSize(addr, size)
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
static int p_Cmp(poly p1, poly p2, ring r)
char * p_String(poly p, ring lmRing, ring tailRing)
omError_t omTestBinAddrSize(void *addr, size_t size, int check_level)
#define omFreeBinAddr(addr)
static int p_Comp_k_n(poly a, poly b, int k, ring r)
static short scaFirstAltVar(ring r)
BOOLEAN dPolyReportError(poly p, ring r, const char *fmt,...)
static poly _p_Mult_q_Bucket(poly p, const int lp, poly q, const int lq, const int copy, const ring r)
static BOOLEAN rField_is_Ring(const ring r)
poly p_Div_nn(poly p, const number n, const ring r)
static poly p_Subst2(poly p, int n, number e, const ring r)
#define pFalseReturn(cond)
sBucket_pt sBucketCreate(const ring r)
void p_ContentRat(poly &ph, const ring r)
poly p_JetW(poly p, int m, short *w, const ring R)
static BOOLEAN rIsRatGRing(const ring r)
static FORCE_INLINE BOOLEAN nCoeff_is_Q_a(const coeffs r)
void p_Write0(poly p, ring lmRing, ring tailRing)
#define pAssumeReturn(cond)
static int max(int a, int b)
number ndGcd(number, number, const coeffs r)
static void p_LmDelete(poly p, const ring r)
static poly p_New(const ring, omBin bin)
number nlGcd(number a, number b, const coeffs r)
#define omTypeAlloc0Bin(type, addr, bin)
void p_String0(poly p, ring lmRing, ring tailRing)
print p according to ShortOut in lmRing & tailRing
poly nc_p_Plus_mm_Mult_qq(poly p, const poly m, const poly q, int &lp, const int, const ring r)
static int p_LtCmp(poly p, poly q, const ring r)
void nlNormalize(number &x, const coeffs r)
void p_Write(poly p, ring lmRing, ring tailRing)
poly p_Cleardenom(poly p, const ring r)
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of 'a' and 'b', i.e., a*b
#define omTypeAllocBin(type, addr, bin)
static int rPar(const ring r)
(r->cf->P)
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
poly sBucketSortMerge(poly p, const ring r)
Sorts p with bucketSort: assumes all monomials of p are different.
static BOOLEAN p_DivisibleBy(poly a, poly b, const ring r)
const char * p_Read(const char *st, poly &rc, const ring r)
static void p_GetExpV(poly p, int *ev, const ring r)
static poly p_Init(const ring r, omBin bin)
static int p_LmCmp(poly p, poly q, const ring r)
int p_MinDeg(poly p, intvec *w, const ring R)
void p_Setm_WFirstTotalDegree(poly p, const ring r)
static BOOLEAN _p_LmDivisibleBy(poly a, poly b, const ring r)
#define __pp_Mult_nn(p, n, r)
poly _nc_p_Mult_q(poly p, poly q, const ring r)
general NC-multiplication with destruction
static poly nc_mm_Mult_p(const poly m, poly p, const ring r)
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
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)
BOOLEAN nlGreaterZero(number za, const coeffs r)
static FORCE_INLINE BOOLEAN nCoeff_is_transExt(const coeffs r)
TRUE iff r represents a transcendental extension field.
static poly p_Subst1(poly p, int n, const ring r)
@ n_transExt
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
void p_Setm_General(poly p, const ring r)
static FORCE_INLINE number n_Farey(number a, number b, const coeffs r)
poly singclap_pmult(poly f, poly g, const ring r)
BOOLEAN p_CheckRing(ring r)
gmp_float exp(const gmp_float &a)
static FORCE_INLINE number n_Sub(number a, number b, const coeffs r)
return the difference of 'a' and 'b', i.e., a-b
BOOLEAN pIsMonomOf(poly p, poly m)
#define p_LmCheckPolyRing2(p, r)
BOOLEAN p_CheckRing(ring r)
static void p_LmFree(poly p, ring)
void p_ContentForGB(poly ph, const ring r)
number ntInit(long i, const coeffs cf)
long p_Deg(poly a, const ring r)
void nlInpGcd(number &a, number b, const coeffs r)
static void p_Delete(poly *p, const ring r)
poly _nc_pp_Mult_qq(const poly p, const poly q, const ring r)
general NC-multiplication without destruction
static poly p_Add_q(poly p, poly q, const ring r)
static BOOLEAN rField_is_GF(const ring r)
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 ...
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
static void p_MemSub_NegWeightAdjust(poly p, const ring r)
static poly p_Copy_noCheck(poly p, const ring r)
returns a copy of p (without any additional testing)
void rWrite(ring r, BOOLEAN details)
void StringSetS(const char *st)
#define omTestList(ptr, level)
static int si_max(const int a, const int b)
static unsigned long p_AddComp(poly p, unsigned long v, ring r)
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...
void pSetDegProcs(ring r, pFDegProc new_FDeg, pLDegProc new_lDeg)
LINLINE number nlAdd(number la, number li, const coeffs r)
BOOLEAN p_CheckPolyRing(poly p, ring r)
#define rRing_has_Comp(r)
#define _pPolyAssumeReturn(cond, p, r)
@ ringorder_IS
Induced (Schreyer) ordering.
#define omSizeWOfBin(bin_ptr)
void Werror(const char *fmt,...)
static BOOLEAN pOldLexOrder
static short scaLastAltVar(ring r)
static number p_SetCoeff(poly p, number n, ring r)
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),...
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
static FORCE_INLINE number n_Gcd(number a, number b, const coeffs r)
in Z: return the gcd of 'a' and 'b' in Z/nZ, Z/2^kZ: computed as in the case Z in Z/pZ,...
void WerrorS(const char *s)
static poly p_Pow(poly p, int i, const ring r)
static BOOLEAN rField_has_simple_inverse(const ring r)
static poly p_DiffOpM(poly a, poly b, BOOLEAN multiply, const ring r)
#define MIN_LENGTH_FACTORY
poly _p_Mult_q(poly p, poly q, const int copy, const ring r)
Returns: p * q, Destroys: if !copy then p, q Assumes: pLength(p) >= 2 pLength(q) >=2.
static long p_AddExp(poly p, int v, long ee, ring r)
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:...
static FORCE_INLINE number n_ChineseRemainderSym(number *a, number *b, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs r)
const char * eati(const char *s, int *i)
static poly nc_mm_Mult_pp(const poly m, const poly p, const ring r)
#define p_LmCheckPolyRing1(p, r)
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
poly p_GetCoeffRat(poly p, int ishift, ring r)
static FORCE_INLINE void n_Power(number a, int b, number *res, const coeffs r)
fill res with the power a^b
static void p_Setm(poly p, const ring r)
static unsigned long GetBitFields(const long e, const unsigned int s, const unsigned int n)
static poly p_GetExp_k_n(poly p, int l, int k, const ring r)
const Variable & v
< [in] a sqrfree bivariate poly
static long p_IncrExp(poly p, int v, ring r)
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...
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.
static long p_Totaldegree(poly p, const ring r)
static BOOLEAN p_ExpVectorEqual(poly p1, poly p2, const ring r1, const ring r2)
static BOOLEAN p_IsConstant(const poly p, const ring r)
@ ringorder_aa
for idElimination, like a, except pFDeg, pWeigths ignore it
const CanonicalForm int s
static unsigned long p_GetMaxExp(const unsigned long l, const ring r)
CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
int status int void size_t count
static BOOLEAN rIsSyzIndexRing(const ring r)
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...
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
void p_Setm_TotalDegree(poly p, const ring r)
int comp(const CanonicalForm &A, const CanonicalForm &B)
compare polynomials
static poly p_Mult_q(poly p, poly q, const ring r)
@ ringorder_rs
opposite of ls
@ ringorder_a64
for int64 weights
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
CFArray copy(const CFList &list)
write elements of list into an array
void p_String0(poly p, ring lmRing, ring tailRing)
print p according to ShortOut in lmRing & tailRing
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...
static bool rIsSCA(const ring r)
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
LINLINE void nlDelete(number *a, const coeffs r)
static BOOLEAN rField_is_Zp(const ring r)
static BOOLEAN rShortOut(const ring r)
static BOOLEAN p_LmDivisibleByNoComp(poly a, poly b, const ring r)
static poly p_Subst0(poly p, int n, const ring r)
static long p_MaxComp(poly p, ring lmRing, ring tailRing)
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.
BOOLEAN _p_Test(poly p, ring r, int level)
static poly pReverse(poly p)
static long p_DecrExp(poly p, int v, ring r)
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
static poly p_Mult_nn(poly p, number n, const ring r)
BOOLEAN pDebugLmShortDivisibleBy(poly p1, unsigned long sev_1, ring r_1, poly p2, unsigned long not_sev_2, ring r_2)
static long pModDeg(poly p, ring r)
@ n_algExt
used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic
static FORCE_INLINE BOOLEAN nCoeff_is_Domain(const coeffs r)
returns TRUE, if r is a field or r has no zero divisors (i.e is a domain)
static BOOLEAN p_LmIsConstant(const poly p, const ring r)
static BOOLEAN rField_is_Q(const ring r)
#define omReallocSize(addr, o_size, size)
int p_Weight(int i, const ring r)