26 # define PLURAL_INTERNAL_DECLARATIONS 101 #define freeT(A,v) omFreeSize((ADDRESS)A,(v+1)*sizeof(int)) 102 #define freeN(A,k) omFreeSize((ADDRESS)A,k*sizeof(number)) 151 const poly,
const ring r)
162 shorter =
pLength(p)-org_p-org_q;
169 const int,
const ring r)
179 poly gnc_p_Minus_mm_Mult_qq_ign(poly
p,
const poly
m, poly q,
int & d1, poly d2,
const ring r, poly &d3)
184 return gnc_p_Minus_mm_Mult_qq(
p,
m, q, d1, i, t, r);
276 for( poly q = pPolyQ; q !=
NULL; q =
pNext(q) )
316 int *P=(
int *)
omAlloc0((rN+1)*
sizeof(int));
317 int *
M=(
int *)
omAlloc0((rN+1)*
sizeof(int));
359 if (side==1) s=
"gnc_p_Mult_mm";
360 else s=
"gnc_mm_Mult_p";
361 Print(
"%s: exponent mismatch %d and %d\n",s,expP,expM);
422 int *F=(
int *)
omAlloc0((rN+1)*
sizeof(int));
423 int *
G=(
int *)
omAlloc0((rN+1)*
sizeof(int));
425 memcpy(F, F0,(rN+1)*
sizeof(
int));
427 memcpy(G, G0,(rN+1)*
sizeof(
int));
433 while ((F[iF]==0)&&(iF>=1)) iF--;
444 while ((G[jG]==0)&&(jG<rN)) jG++;
446 while ((G[iG]==0)&&(iG>1)) iG--;
453 {
for(
int ii=rN;ii>0;ii--) F[ii]+=G[ii]; }
461 number cff=
n_Init(1,r->cf);
467 if (r->GetNC()->IsSkewConstant==1)
470 for(j=jG; j<=iG; j++)
475 for(i=j+1; i<=iF; i++)
477 cpower = cpower + F[
i];
479 cpower = cpower*G[
j];
480 tpower = tpower + cpower;
484 n_Power(cff,tpower,&tmp_num, r->cf);
490 number totcff=
n_Init(1,r->cf);
491 for(j=jG; j<=iG; j++)
496 for(i=j+1; i<=iF; i++)
502 n_Power(cff,cpower,&tmp_num, r->cf);
503 cff =
n_Mult(totcff,tmp_num, r->cf);
506 totcff =
n_Copy(cff,r->cf);
514 {
for(
int ii=rN;ii>0;ii--) F[ii]+=G[ii]; }
536 int *Prv=(
int *)
omAlloc0((rN+1)*
sizeof(int));
537 int *Nxt=(
int *)
omAlloc0((rN+1)*
sizeof(int));
540 int cnt=0;
int cnf=0;
545 Prv[
i]=F[
i]; Nxt[
i]=0;
549 if (cnf==0)
freeT(Prv,rN);
551 for (i=jG+1;i<=rN;i++)
575 number *c=(number *)
omAlloc0((rN+1)*
sizeof(number));
580 int *U=(
int *)
omAlloc0((rN+1)*
sizeof(int));
582 for (i=jG;i<=rN;i++) U[i]=Nxt[i]+G[i];
682 while ((F[iF]==0)&&(iF>0)) iF-- ;
693 while ((F[jF]==0)&&(jF<=rN)) jF++;
744 int *Prv=(
int*)
omAlloc0((rN+1)*
sizeof(int));
745 int *Nxt=(
int*)
omAlloc0((rN+1)*
sizeof(int));
746 int *lF=(
int *)
omAlloc0((rN+1)*
sizeof(int));
748 int cnt=0;
int cnf=0;
752 Prv[
i]=F[
i]; Nxt[
i]=0;
761 for (i=jG+1;i<=rN;i++)
764 if (cnf!=0) { Prv[
i]=0;}
811 number *c=(number *)
omAlloc0((cnt+2)*
sizeof(number));
817 int *U=(
int *)
omAlloc0((rN+1)*
sizeof(int));
821 memcpy(U, Nxt,(rN+1)*
sizeof(
int));
886 num=
n_Mult(c[cnt+1],c[cnt],r->cf);
936 matrix cMT=r->GetNC()->MT[cMTindex];
958 cMT=r->GetNC()->MT[cMTindex];
980 cMT=r->GetNC()->MT[cMTindex];
1014 if( FormulaMultiplier !=
NULL )
1015 PairType = FormulaMultiplier->
GetPair(j, i);
1069 n_Power(tmp_number,a*b,&tmp_number, r->cf);
1082 if( FormulaMultiplier !=
NULL )
1083 PairType = FormulaMultiplier->
GetPair(j, i);
1096 int cMTsize=r->GetNC()->MTsize[vik];
1100 if (newcMTsize<=cMTsize)
1103 if (out !=
NULL)
return (out);
1106 if (newcMTsize > cMTsize)
1108 int inM=(((newcMTsize+6)/7)*7);
1109 assume (inM>=newcMTsize);
1114 for (k=1;k<=cMTsize;k++)
1116 for (m=1;m<=cMTsize;m++)
1130 r->GetNC()->MT[
UPMATELEM(j,i,rN)] = tmp;
1132 r->GetNC()->MTsize[
UPMATELEM(j,i,rN)] = newcMTsize;
1166 while ( (
MATELEM(cMT,1,toXY)==
NULL) && (toXY>=2)) toXY--;
1167 for (m=toXY+1;m<=
b;m++)
1180 WarnS(
"Error: a=1; MATELEM!=0");
1190 while ( (
MATELEM(cMT,toYX,1)==
NULL) && (toYX>=2)) toYX--;
1191 for (m=toYX+1;m<=a;m++)
1204 WarnS(
"Error: b=1, MATELEM!=0");
1214 int dXY=0;
int dYX=0;
1217 int toX=a-1;
int toY=b-1;
1221 while ( (
MATELEM(cMT,toX,b)==
NULL) && (toX>=1)) toX--;
1224 while ( (
MATELEM(cMT,1,toXY)==
NULL) && (toXY>=1)) toXY--;
1230 while ( (
MATELEM(cMT,a,toY)==
NULL) && (toY>=1)) toY--;
1233 while ( (
MATELEM(cMT,toYX,1)==
NULL) && (toYX>=1)) toYX--;
1244 for (m=toXY+1;m<=
b;m++)
1257 WarnS(
"dYX>=dXY,toXY; MATELEM==0");
1264 for (k=toX+1;k<=a;k++)
1277 WarnS(
"dYX>=dXY,toX; MATELEM==0");
1289 for (m=toYX+1;m<=a;m++)
1302 WarnS(
"dYX<dXY,toYX; MATELEM==0");
1309 for (k=toY+1;k<=
b;k++)
1322 WarnS(
"dYX<dXY,toY; MATELEM==0");
1351 dReportError(
"nc_ReduceSpolyOld: different components");
1405 if ((lCompP1!=lCompP2) && (lCompP1!=0) && (lCompP2!=0))
1408 WerrorS(
"gnc_ReduceSpolyNew: different non-zero components!");
1477 dReportError(
"gnc_CreateSpolyOld : different components!");
1488 pL =
p_Lcm(p1,p2,r);
1571 if ((lCompP1!=lCompP2) && (lCompP1!=0) && (lCompP2!=0))
1574 WerrorS(
"gnc_CreateSpolyNew: different non-zero components!");
1590 poly pL =
p_Lcm(p1,p2,r);
1628 WarnS(
"gnc_CreateSpolyNew: wrong monomials!");
1684 WerrorS(
"ERROR in nc_CreateSpoly: result of multiplication is Zero!\n");
1839 void gnc_ReduceSpolyTail(poly p1, poly q, poly q2, poly spNoether,
const ring r)
1856 number MinusOne=
n_Init(-1,r->cf);
1857 if (!
n_Equal(cQ,MinusOne,r->cf))
1888 if ((lCompP1!=lCompP2) && (lCompP1!=0) && (lCompP2!=0))
1891 WerrorS(
"nc_CreateShortSpoly: wrong module components!");
1898 #ifdef HAVE_RATGRING 1906 m =
p_Lcm(p1, p2, r);
1955 if( !
kbTest(b) )
WerrorS(
"nc_kBucketPolyRed: broken bucket!");
2056 if (c!=
NULL) *c=ctmp;
2090 if (c!=
NULL) *c=ctmp;
2138 PrintS(
"nc_PolyPolyRedNew(");
2202 if(b ==
NULL)
return;
2288 int *M1=(
int *)
omAlloc0((rN+1)*
sizeof(int));
2289 int *M2=(
int *)
omAlloc0((rN+1)*
sizeof(int));
2290 int *aPREFIX=(
int *)
omAlloc0((rN+1)*
sizeof(int));
2291 int *aSUFFIX=(
int *)
omAlloc0((rN+1)*
sizeof(int));
2313 if (i<j) {nMax=
j; nMin=
i;}
else {nMax=
i; nMin=
j;}
2332 if (i>j) bres=
p_Neg(bres, r);
2337 memcpy(aSUFFIX, M1,(rN+1)*
sizeof(
int));
2338 memcpy(aPREFIX, M1,(rN+1)*
sizeof(
int));
2339 for (k=1;k<=
j;k++) aSUFFIX[k]=0;
2340 for (k=j;k<=rN;k++) aPREFIX[k]=0;
2362 memcpy(aSUFFIX, M2,(rN+1)*
sizeof(
int));
2363 memcpy(aPREFIX, M2,(rN+1)*
sizeof(
int));
2364 for (k=1;k<=
i;k++) aSUFFIX[k]=0;
2365 for (k=i;k<=rN;k++) aPREFIX[k]=0;
2399 if (a>b) {j=
b; i=a;}
2423 for(s=1;s<=
size;s++)
2425 for(t=1;t<=
size;t++)
2444 totdeg=totdeg+
p_Deg(p,r);
2447 number ntd =
n_Init(totdeg, r->cf);
2448 number nln =
n_Init(length, r->cf);
2449 number nres=
n_Div(ntd,nln, r->cf);
2477 if( r->GetNC()->GetGlobalMultiplier() !=
NULL )
2479 delete r->GetNC()->GetGlobalMultiplier();
2480 r->GetNC()->GetGlobalMultiplier() =
NULL;
2483 if( r->GetNC()->GetFormulaPowerMultiplier() !=
NULL )
2485 delete r->GetNC()->GetFormulaPowerMultiplier();
2486 r->GetNC()->GetFormulaPowerMultiplier() =
NULL;
2496 for(j=i+1;j<=rN;j++)
2503 id_Delete((ideal *)&(r->GetNC()->COM),r);
2508 if(
rIsSCA(r) && (r->GetNC()->SCAQuotient() !=
NULL) )
2510 id_Delete(&r->GetNC()->SCAQuotient(), r);
2576 int *ExpVar=(
int*)
omAlloc0((rN+1)*
sizeof(int));
2577 int *ExpTmp=(
int*)
omAlloc0((rN+1)*
sizeof(int));
2579 int i;
int j;
int k;
2582 for (i=1; i<rN; i++)
2586 for (j=i+1; j<=rN; j++)
2599 if (ExpVar[k]!=0) OK=0;
2640 for(i=1; i<r->N; i++)
2642 for(j=i+1; j<=r->N; j++)
2653 Werror(
"Bad ordering at %d,%d\n",i,j);
2684 bool bSetupQuotient,
bool bCopyInput,
bool bBeQuiet,
2685 ring curr,
bool dummy_ring )
2690 if( !bSetupQuotient)
2709 WarnS(
"commutative ring with 1 variable");
2726 PrintS(
"nc_CallPlural(), Input data, CCC: \n");
2731 PrintS(
"nc_CallPlural(), Input data, DDD: \n");
2744 if( (!bBeQuiet) && (r->GetNC() !=
NULL) )
2745 WarnS(
"going to redefine the algebra structure");
2752 matrix C;
bool bCnew =
false;
2760 bool IsSkewConstant =
false, tmpIsSkewConstant;
2779 Werror(
"Square %d x %d matrix expected", r->N, r->N);
2786 if (( CCC !=
NULL) && (CC ==
NULL)) CC = CCC;
2787 if (( CCN !=
NULL) && (CN ==
NULL)) CN = CCN;
2798 Werror(
"Square %d x %d matrix expected",r->N,r->N);
2806 if (( DDD !=
NULL) && (DD ==
NULL)) DD = DDD;
2807 if (( DDN !=
NULL) && (DN ==
NULL)) DN = DDN;
2815 WerrorS(
"Incorrect input : non-constants are not allowed as coefficients (first argument)");
2823 WerrorS(
"Incorrect input : zero coefficients are not allowed");
2835 IsSkewConstant =
true;
2837 C =
mpNew(r->N,r->N);
2840 for(i=1; i<r->N; i++)
2841 for(j=i+1; j<=r->N; j++)
2849 if ( (CN ==
NULL) && (CC !=
NULL) )
2859 if (!pN_set)
n_Delete(&pN,curr->cf);
2864 tmpIsSkewConstant =
true;
2866 for(i=1; i<r->N; i++)
2867 for(j=i+1; j<=r->N; j++)
2875 Werror(
"Incorrect input : non-constants are not allowed as coefficients (first argument at [%d, %d])", i, j);
2886 WerrorS(
"Incorrect input : matrix of coefficients contains zeros in the upper triangle");
2893 if (!
n_Equal(pN, qN, curr->cf)) tmpIsSkewConstant =
false;
2907 IsSkewConstant = tmpIsSkewConstant;
2909 if ( tmpIsSkewConstant &&
n_IsOne(pN, curr->cf) )
2913 if (!pN_set)
n_Delete(&pN,curr->cf);
2919 D =
mpNew(r->N,r->N); bDnew =
true;
2929 for(i=1; i<r->N; i++)
2930 for(j=i+1; j<=r->N; j++)
2940 for(
int i = 1; (i < r->N) && b; i++)
2941 for(
int j = i+1; (j <= r->N) && b; j++)
2972 PrintS(
"nc_CallPlural(), Computed data, C: \n");
2975 PrintS(
"nc_CallPlural(), Computed data, D: \n");
2978 Print(
"\nTemporary: type = %d, IsSkewConstant = %d\n", nctype, IsSkewConstant);
2988 WerrorS(
"Matrix of polynomials violates the ordering condition");
3008 if (r->GetNC() !=
NULL)
3011 WarnS(
"Changing the NC-structure of an existing NC-ring!!!");
3016 r->GetNC() = nc_new;
3032 WarnS(
"Error occurred while coping/setuping the NC structure!");
3049 r->GetNC()->IsSkewConstant=1;
3066 r->GetNC()->MTsize = (
int *)
omAlloc0((r->N*(r->N-1))/2*
sizeof(int));
3067 id_Test((ideal)r->GetNC()->C, r);
3074 for(i=1; i<r->N; i++)
3076 for(j=i+1; j<=r->N; j++)
3081 r->GetNC()->MTsize[
UPMATELEM(i,j,r->N)] = 1;
3090 r->GetNC()->MTsize[
UPMATELEM(i,j,r->N)] = DefMTsize;
3091 r->GetNC()->MT[
UPMATELEM(i,j,r->N)] =
mpNew(DefMTsize, DefMTsize);
3119 r->GetNC()->IsSkewConstant = 0;
3123 r->GetNC()->COM=
COM;
3143 p_Procs->p_Mult_mm = rGR->p_Procs->p_Mult_mm =
gnc_p_Mult_mm;
3190 p_Procs->p_Minus_mm_Mult_qq =
NULL;
3196 r->GetNC()->SPoly() = gnc_CreateSpoly;
3197 r->GetNC()->ReduceSPoly() = gnc_ReduceSpoly;
3231 int *PRE = (
int *)
omAlloc0((rN+1)*
sizeof(int));
3232 int *SUF = (
int *)
omAlloc0((rN+1)*
sizeof(int));
3242 pow = PRE[n]; PRE[n]=0;
3246 for (i=n+1; i<=rN; i++)
3288 for(
int i=1;
i<rr->N;
i++)
3289 for(
int j=
i+1;
j<=rr->N;
j++)
3293 WarnS(
"Error initializing multiplication!");
3305 if (dstRing == srcRing)
3307 return(
p_Copy(p,dstRing));
3317 int *perm = (
int *)
omAlloc0((
rVar(srcRing)+1)*
sizeof(int));
3318 int *par_perm = (
int *)
omAlloc0((
rPar(srcRing)+1)*
sizeof(
int));
3326 if ((shift<0) || (shift >
rVar(srcRing)))
3328 WerrorS(
"bad shifts in p_CopyEmbed");
3331 for (i=1; i<= srcRing->N; i++)
3335 q =
p_PermPoly(p,perm,srcRing, dstRing, nMap,par_perm,
rPar(srcRing));
3343 int diagnose =
TRUE;
3351 if (rBase->N != rCandidate->N) diagnose =
FALSE;
3370 if ( Rop == dst )
return(
p_Copy(p, dst));
3376 WarnS(
"an opposite ring should be used");
3387 int *perm=(
int *)
omAlloc0((Rop->N+1)*
sizeof(int));
3392 for(i=1; i<=Rop->N; i++)
3394 perm[
i] = Rop->N+1-
i;
3409 if ( Rop == dst )
return id_Copy(I, dst);
3414 WarnS(
"an opposite ring should be used");
3418 ideal idOp =
idInit(I->ncols, I->rank);
3419 for (i=0; i< (I->ncols)*(I->nrows); i++)
3421 idOp->m[
i] =
pOppose(Rop,I->m[i], dst);
3430 if( rGR->qideal ==
NULL )
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
static FORCE_INLINE number n_Sub(number a, number b, const coeffs r)
return the difference of 'a' and 'b', i.e., a-b
static poly NF_Proc_Dummy(ideal, ideal, poly, int, int, const ring)
BOOLEAN kbTest(kBucket_pt bucket)
Tests.
poly(* NF_Proc)(ideal, ideal, poly, int, int, const ring _currRing)
ideal idOppose(ring Rop, ideal I, const ring dst)
opposes a module I from Rop to currRing(dst)
const CanonicalForm int s
poly nc_mm_Bracket_nn(poly m1, poly m2, const ring r)
returns [m1,m2] for two monoms, destroys nothing without coeffs
const CanonicalForm int const CFList const Variable & y
void p_DebugPrint(poly p, const ring r)
ideal(* BBA_Proc)(const ideal, const ideal, const intvec *, const intvec *, kStrategy strat, const ring)
CFArray copy(const CFList &list)
write elements of list into an array
poly prCopyR_NoSort(poly p, ring src_r, ring dest_r)
poly _gnc_p_Mult_q(poly p, poly q, const int copy, const ring r)
static poly p_LmDeleteAndNext(poly p, const ring r)
void nc_rKill(ring r)
complete destructor
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
number kBucketPolyRed(kBucket_pt bucket, poly p1, int l1, poly spNoether)
ideal id_Copy(ideal h1, const ring r)
copy an ideal
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
static int rPar(const ring r)
(r->cf->P)
static poly p_Mult_mm(poly p, poly m, const ring r)
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
poly p_CopyEmbed(poly p, ring srcRing, int shift, int, ring dstRing)
void nc_p_ProcsSet(ring rGR, p_Procs_s *p_Procs)
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
struct p_Procs_s p_Procs_s
poly gnc_CreateSpolyOld(const poly p1, const poly p2, const ring r)
poly pOppose(ring Rop, poly p, const ring dst)
opposes a vector p from Rop to currRing (dst!)
void nc_PolyPolyRedNew(poly &b, poly p, number *c, const ring r)
static BOOLEAN rIsRatGRing(const ring r)
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
static void p_GetExpV(poly p, int *ev, const ring r)
#define omFreeSize(addr, size)
poly nc_p_Minus_mm_Mult_qq(poly p, const poly m, const poly q, int &shorter, const poly, const ring r)
for p_Minus_mm_Mult_qq in pInline2.h
const poly kBucketGetLm(kBucket_pt bucket)
static short rVar(const ring r)
#define rVar(r) (r->N)
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
#define MIN_LENGTH_BUCKET
poly gnc_mm_Mult_nn(int *F, int *G, const ring r)
gmp_float log(const gmp_float &a)
void p_Lcm(const poly a, const poly b, poly m, const ring r)
static poly pp_Mult_mm(poly p, poly m, const ring r)
bool nc_SetupQuotient(ring rGR, const ring rG, bool bCopy)
static poly gnc_uu_Mult_ww_formula(int i, int a, int j, int b, const ring r)
poly gnc_p_Mult_mm_Common(poly p, const poly m, int side, const ring r)
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
void WerrorS(const char *s)
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
poly gnc_pp_Mult_mm(const poly p, const poly m, const ring r, poly &last)
static number p_SetCoeff(poly p, number n, ring r)
static void p_LmFree(poly p, ring)
BOOLEAN nc_CheckSubalgebra(poly PolyVar, ring r)
static void p_SetExpV(poly p, int *ev, const ring r)
poly nc_CreateShortSpoly(poly p1, poly p2, const ring r)
static poly p_Copy(poly p, const ring r)
returns a copy of p
poly gnc_ReduceSpolyNew(const poly p1, poly p2, const ring r)
BOOLEAN rIsLikeOpposite(ring rBase, ring rCandidate)
checks whether rings rBase and rCandidate could be opposite to each other returns TRUE if it is so ...
void iiWriteMatrix(matrix im, const char *n, int dim, const ring r, int spaces)
set spaces to zero by default
#define TEST_OPT_NOT_BUCKETS
void nc_CleanUp(nc_struct *p)
static BOOLEAN p_LmIsConstant(const poly p, const ring r)
void p_Cleardenom_n(poly ph, const ring r, number &c)
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of 'a' and 'b', i.e., a*b
void gnc_kBucketPolyRed_ZNew(kBucket_pt b, poly p, number *c)
static poly nc_mm_Mult_p(const poly m, poly p, const ring r)
static poly p_Head(poly p, const ring r)
bool nc_rCopy(ring res, const ring r, bool bSetupQuotient)
long p_Deg(poly a, const ring r)
poly p_LcmRat(const poly a, const poly b, const long lCompM, const ring r)
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 _nc_p_Mult_q(poly pPolyP, poly pPolyQ, const ring rRing)
general NC-multiplication with destruction
poly gnc_uu_Mult_ww_vert(int i, int a, int j, int b, const ring r)
static void p_SetCompP(poly p, int i, ring r)
const CanonicalForm CFMap CFMap & N
poly nc_p_Bracket_qq(poly p, const poly q, const ring r)
returns [p,q], destroys p
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
static BOOLEAN p_IsConstant(const poly p, const ring r)
poly gnc_mm_Mult_p(const poly m, poly p, const ring r)
poly nc_p_CopyGet(poly a, const ring r)
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
poly gnc_CreateSpolyNew(const poly p1, const poly p2, const ring r)
poly gnc_mm_Mult_pp(const poly m, const poly p, const ring r)
void gnc_kBucketPolyRedOld(kBucket_pt b, poly p, number *c)
static BOOLEAN p_DivisibleBy(poly a, poly b, const ring r)
static int p_LmCmp(poly p, poly q, const ring r)
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 ...
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 number n_InpNeg(number n, const coeffs r)
in-place negation of n MUST BE USED: n = n_InpNeg(n) (no copy is returned)
static int si_max(const int a, const int b)
void gnc_kBucketPolyRedNew(kBucket_pt b, poly p, number *c)
BOOLEAN gnc_InitMultiplication(ring r, bool bSetupQuotient=false)
void PrintS(const char *s)
void sca_p_ProcsSet(ring rGR, p_Procs_s *p_Procs)
poly gnc_uu_Mult_ww_horvert(int i, int a, int j, int b, const ring r)
poly gnc_mm_Mult_uu(int *F, int jG, int bG, const ring r)
static unsigned pLength(poly a)
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
void mp_Delete(matrix *a, const ring r)
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
BOOLEAN pqLength(poly p, poly q, int &lp, int &lq, const int min)
BOOLEAN p_HasNotCF(poly p1, poly p2, const ring r)
BOOLEAN nc_CallPlural(matrix CCC, matrix DDD, poly CCN, poly DDN, ring r, bool bSetupQuotient, bool bCopyInput, bool bBeQuiet, ring curr, bool dummy_ring)
returns TRUE if there were errors analyze inputs, check them for consistency detects nc_type...
matrix mpNew(int r, int c)
create a r x c zero-matrix
void p_Write0(poly p, ring lmRing, ring tailRing)
static void p_Delete(poly *p, const ring r)
ideal idInit(int idsize, int rank)
initialise an ideal / module
const Variable & v
< [in] a sqrfree bivariate poly
static void p_ExpVectorDiff(poly pr, poly p1, poly p2, const ring r)
BOOLEAN gnc_CheckOrdCondition(matrix D, 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 : VarOffset encodes the position in p->exp
static FORCE_INLINE void n_Power(number a, int b, number *res, const coeffs r)
fill res with the power a^b
#define __p_Mult_nn(p, n, r)
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
void * cast_A_to_vptr(A a)
poly gnc_ReduceSpolyOld(const poly p1, poly p2, 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...
void nc_PolyPolyRedOld(poly &b, poly p, number *c, const ring r)
poly _nc_pp_Mult_qq(const poly pPolyP, const poly pPolyQ, const ring rRing)
general NC-multiplication without destruction
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 BOOLEAN length(leftv result, leftv arg)
poly gnc_uu_Mult_ww(int i, int a, int j, int b, const ring r)
bool sca_SetupQuotient(ring rGR, ring rG, bool bCopy)
static p_Procs_s * _p_procs
static BOOLEAN p_IsConstantPoly(const poly p, const ring r)
static bool rIsSCA(const ring r)
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.
BOOLEAN ncInitSpecialPairMultiplication(ring r)
static void p_Setm(poly p, const ring r)
static long p_AddExp(poly p, int v, long ee, ring r)
matrix mp_Copy(matrix a, const ring r)
copies matrix a (from ring r to r)
static nc_type & ncRingType(nc_struct *p)
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
int dReportError(const char *fmt,...)
void gnc_kBucketPolyRed_ZOld(kBucket_pt b, poly p, number *c)
static poly p_Neg(poly p, const ring r)
static void p_LmDelete(poly p, const ring r)
static poly nc_mm_Mult_pp(const poly m, const poly p, const ring r)
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
static FORCE_INLINE BOOLEAN n_IsMOne(number n, const coeffs r)
TRUE iff 'n' represents the additive inverse of the one element, i.e. -1.
void p_Write(poly p, ring lmRing, ring tailRing)
static void gnc_p_ProcsSet(ring rGR, p_Procs_s *p_Procs)
CPolynomialSummator: unifies bucket and polynomial summation as the later is brocken in buckets :(...
static poly p_Add_q(poly p, poly q, const ring r)
void nc_PolyPolyRed(poly &b, poly p, number *c, const ring r)
poly nc_p_Plus_mm_Mult_qq(poly p, const poly m, const poly q, int &lp, const int, const ring r)
Rational pow(const Rational &a, int e)
ring nc_rCreateNCcomm(ring r)
poly nc_p_CopyPut(poly a, const ring r)
poly p_Cleardenom(poly p, const ring r)
static ideal BBA_Proc_Dummy(const ideal, const ideal, const intvec *, const intvec *, kStrategy, const ring)
poly gnc_p_Mult_mm(poly p, const poly m, const ring r)
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
poly p_Power(poly p, int i, const ring r)
void Werror(const char *fmt,...)
bool ncExtensions(int iMask)
matrix nc_PrintMat(int a, int b, ring r, int metric)
returns matrix with the info on noncomm multiplication
int setNCExtensions(int iMask)
#define UPMATELEM(i, j, nVar)
#define MATELEM(mat, i, j)
void kBucket_Add_q(kBucket_pt bucket, poly q, int *l)
Add to Bucket a poly ,i.e. Bpoly == q+Bpoly.