26 # define PLURAL_INTERNAL_DECLARATIONS 106 #define freeT(A,v) omFreeSize((ADDRESS)A,(v+1)*sizeof(int)) 107 #define freeN(A,k) omFreeSize((ADDRESS)A,k*sizeof(number)) 156 const poly,
const ring
r)
167 shorter =
pLength(p)-org_p-org_q;
174 const int,
const ring
r)
189 return gnc_p_Minus_mm_Mult_qq(
p,
m, q, d1, i, t,
r);
321 int *
P=(
int *)
omAlloc0((rN+1)*
sizeof(int));
322 int *
M=(
int *)
omAlloc0((rN+1)*
sizeof(int));
364 if (side==1) s=
"gnc_p_Mult_mm";
365 else s=
"gnc_mm_Mult_p";
366 Print(
"%s: exponent mismatch %d and %d\n",s,expP,expM);
427 int *F=(
int *)
omAlloc0((rN+1)*
sizeof(int));
428 int *
G=(
int *)
omAlloc0((rN+1)*
sizeof(int));
430 memcpy(F, F0,(rN+1)*
sizeof(
int));
432 memcpy(G, G0,(rN+1)*
sizeof(
int));
438 while ((F[iF]==0)&&(iF>=1)) iF--;
449 while ((G[jG]==0)&&(jG<rN)) jG++;
451 while ((G[iG]==0)&&(iG>1)) iG--;
458 {
for(
int ii=rN;ii>0;ii--) F[ii]+=G[ii]; }
466 number cff=
n_Init(1,r->cf);
472 if (r->GetNC()->IsSkewConstant==1)
475 for(j=jG; j<=iG; j++)
480 for(i=j+1; i<=iF; i++)
482 cpower = cpower + F[
i];
484 cpower = cpower*G[
j];
485 tpower = tpower + cpower;
489 n_Power(cff,tpower,&tmp_num, r->cf);
495 number totcff=
n_Init(1,r->cf);
496 for(j=jG; j<=iG; j++)
501 for(i=j+1; i<=iF; i++)
507 n_Power(cff,cpower,&tmp_num, r->cf);
508 cff =
n_Mult(totcff,tmp_num, r->cf);
511 totcff =
n_Copy(cff,r->cf);
519 {
for(
int ii=rN;ii>0;ii--) F[ii]+=G[ii]; }
541 int *Prv=(
int *)
omAlloc0((rN+1)*
sizeof(int));
542 int *Nxt=(
int *)
omAlloc0((rN+1)*
sizeof(int));
545 int cnt=0;
int cnf=0;
550 Prv[
i]=F[
i]; Nxt[
i]=0;
554 if (cnf==0)
freeT(Prv,rN);
556 for (i=jG+1;i<=rN;i++)
580 number *c=(number *)
omAlloc0((rN+1)*
sizeof(number));
585 int *U=(
int *)
omAlloc0((rN+1)*
sizeof(int));
587 for (i=jG;i<=rN;i++) U[i]=Nxt[i]+G[i];
687 while ((F[iF]==0)&&(iF>0)) iF-- ;
698 while ((F[jF]==0)&&(jF<=rN)) jF++;
749 int *Prv=(
int*)
omAlloc0((rN+1)*
sizeof(int));
750 int *Nxt=(
int*)
omAlloc0((rN+1)*
sizeof(int));
751 int *lF=(
int *)
omAlloc0((rN+1)*
sizeof(int));
753 int cnt=0;
int cnf=0;
757 Prv[
i]=F[
i]; Nxt[
i]=0;
766 for (i=jG+1;i<=rN;i++)
769 if (cnf!=0) { Prv[
i]=0;}
816 number *c=(number *)
omAlloc0((cnt+2)*
sizeof(number));
822 int *U=(
int *)
omAlloc0((rN+1)*
sizeof(int));
826 memcpy(U, Nxt,(rN+1)*
sizeof(
int));
891 num=
n_Mult(c[cnt+1],c[cnt],r->cf);
941 matrix cMT=r->GetNC()->MT[cMTindex];
963 cMT=r->GetNC()->MT[cMTindex];
985 cMT=r->GetNC()->MT[cMTindex];
1019 if( FormulaMultiplier !=
NULL )
1020 PairType = FormulaMultiplier->
GetPair(j, i);
1074 n_Power(tmp_number,a*b,&tmp_number, r->cf);
1087 if( FormulaMultiplier !=
NULL )
1088 PairType = FormulaMultiplier->
GetPair(j, i);
1101 int cMTsize=r->GetNC()->MTsize[vik];
1105 if (newcMTsize<=cMTsize)
1108 if (out !=
NULL)
return (out);
1111 if (newcMTsize > cMTsize)
1113 int inM=(((newcMTsize+6)/7)*7);
1114 assume (inM>=newcMTsize);
1119 for (k=1;k<=cMTsize;k++)
1121 for (m=1;m<=cMTsize;m++)
1135 r->GetNC()->MT[
UPMATELEM(j,i,rN)] = tmp;
1137 r->GetNC()->MTsize[
UPMATELEM(j,i,rN)] = newcMTsize;
1171 while ( (
MATELEM(cMT,1,toXY)==
NULL) && (toXY>=2)) toXY--;
1172 for (m=toXY+1;m<=
b;m++)
1185 WarnS(
"Error: a=1; MATELEM!=0");
1195 while ( (
MATELEM(cMT,toYX,1)==
NULL) && (toYX>=2)) toYX--;
1196 for (m=toYX+1;m<=
a;m++)
1209 WarnS(
"Error: b=1, MATELEM!=0");
1219 int dXY=0;
int dYX=0;
1222 int toX=a-1;
int toY=b-1;
1226 while ( (
MATELEM(cMT,toX,b)==
NULL) && (toX>=1)) toX--;
1229 while ( (
MATELEM(cMT,1,toXY)==
NULL) && (toXY>=1)) toXY--;
1235 while ( (
MATELEM(cMT,a,toY)==
NULL) && (toY>=1)) toY--;
1238 while ( (
MATELEM(cMT,toYX,1)==
NULL) && (toYX>=1)) toYX--;
1249 for (m=toXY+1;m<=
b;m++)
1262 WarnS(
"dYX>=dXY,toXY; MATELEM==0");
1269 for (k=toX+1;k<=
a;k++)
1282 WarnS(
"dYX>=dXY,toX; MATELEM==0");
1294 for (m=toYX+1;m<=
a;m++)
1307 WarnS(
"dYX<dXY,toYX; MATELEM==0");
1314 for (k=toY+1;k<=
b;k++)
1327 WarnS(
"dYX<dXY,toY; MATELEM==0");
1356 dReportError(
"nc_ReduceSpolyOld: different components");
1410 if ((lCompP1!=lCompP2) && (lCompP1!=0) && (lCompP2!=0))
1413 WerrorS(
"gnc_ReduceSpolyNew: different non-zero components!");
1483 dReportError(
"gnc_CreateSpolyOld : different components!");
1494 pL =
p_Lcm(p1,p2,r);
1578 if ((lCompP1!=lCompP2) && (lCompP1!=0) && (lCompP2!=0))
1581 WerrorS(
"gnc_CreateSpolyNew: different non-zero components!");
1635 WarnS(
"gnc_CreateSpolyNew: wrong monomials!");
1691 WerrorS(
"ERROR in nc_CreateSpoly: result of multiplication is Zero!\n");
1846 void gnc_ReduceSpolyTail(
poly p1,
poly q,
poly q2,
poly spNoether,
const ring
r)
1863 number MinusOne=
n_Init(-1,r->cf);
1864 if (!
n_Equal(cQ,MinusOne,r->cf))
1895 if ((lCompP1!=lCompP2) && (lCompP1!=0) && (lCompP2!=0))
1898 WerrorS(
"nc_CreateShortSpoly: wrong module components!");
1905 #ifdef HAVE_RATGRING 1913 m =
p_Lcm(p1, p2, r);
1967 if( !
kbTest(b) )
WerrorS(
"nc_kBucketPolyRed: broken bucket!");
2068 if (c!=
NULL) *c=ctmp;
2102 if (c!=
NULL) *c=ctmp;
2150 PrintS(
"nc_PolyPolyRedNew(");
2214 if(b ==
NULL)
return;
2300 int *M1=(
int *)
omAlloc0((rN+1)*
sizeof(int));
2301 int *M2=(
int *)
omAlloc0((rN+1)*
sizeof(int));
2302 int *aPREFIX=(
int *)
omAlloc0((rN+1)*
sizeof(int));
2303 int *aSUFFIX=(
int *)
omAlloc0((rN+1)*
sizeof(int));
2325 if (i<j) {nMax=
j; nMin=
i;}
else {nMax=
i; nMin=
j;}
2344 if (i>j) bres=
p_Neg(bres, r);
2349 memcpy(aSUFFIX, M1,(rN+1)*
sizeof(
int));
2350 memcpy(aPREFIX, M1,(rN+1)*
sizeof(
int));
2351 for (k=1;k<=
j;k++) aSUFFIX[k]=0;
2352 for (k=j;k<=rN;k++) aPREFIX[k]=0;
2374 memcpy(aSUFFIX, M2,(rN+1)*
sizeof(
int));
2375 memcpy(aPREFIX, M2,(rN+1)*
sizeof(
int));
2376 for (k=1;k<=
i;k++) aSUFFIX[k]=0;
2377 for (k=i;k<=rN;k++) aPREFIX[k]=0;
2411 if (a>b) {j=
b; i=
a;}
2435 for(s=1;s<=
size;s++)
2437 for(t=1;t<=
size;t++)
2456 totdeg=totdeg+
p_Deg(p,r);
2459 number ntd =
n_Init(totdeg, r->cf);
2460 number nln =
n_Init(length, r->cf);
2461 number nres=
n_Div(ntd,nln, r->cf);
2489 if( r->GetNC()->GetGlobalMultiplier() !=
NULL )
2491 delete r->GetNC()->GetGlobalMultiplier();
2492 r->GetNC()->GetGlobalMultiplier() =
NULL;
2495 if( r->GetNC()->GetFormulaPowerMultiplier() !=
NULL )
2497 delete r->GetNC()->GetFormulaPowerMultiplier();
2498 r->GetNC()->GetFormulaPowerMultiplier() =
NULL;
2508 for(j=i+1;j<=rN;j++)
2515 id_Delete((ideal *)&(r->GetNC()->COM),r);
2520 if(
rIsSCA(r) && (r->GetNC()->SCAQuotient() !=
NULL) )
2588 int *ExpVar=(
int*)
omAlloc0((rN+1)*
sizeof(int));
2589 int *ExpTmp=(
int*)
omAlloc0((rN+1)*
sizeof(int));
2591 int i;
int j;
int k;
2594 for (i=1; i<rN; i++)
2598 for (j=i+1; j<=rN; j++)
2611 if (ExpVar[k]!=0) OK=0;
2652 for(i=1; i<r->N; i++)
2654 for(j=i+1; j<=r->N; j++)
2665 Werror(
"Bad ordering at %d,%d\n",i,j);
2696 bool bSetupQuotient,
bool bCopyInput,
bool bBeQuiet,
2697 ring curr,
bool dummy_ring )
2702 if( !bSetupQuotient)
2721 WarnS(
"commutative ring with 1 variable");
2738 PrintS(
"nc_CallPlural(), Input data, CCC: \n");
2743 PrintS(
"nc_CallPlural(), Input data, DDD: \n");
2756 if( (!bBeQuiet) && (r->GetNC() !=
NULL) )
2757 WarnS(
"going to redefine the algebra structure");
2764 matrix C;
bool bCnew =
false;
2772 bool IsSkewConstant =
false, tmpIsSkewConstant;
2791 Werror(
"Square %d x %d matrix expected", r->N, r->N);
2798 if (( CCC !=
NULL) && (CC ==
NULL)) CC = CCC;
2799 if (( CCN !=
NULL) && (CN ==
NULL)) CN = CCN;
2810 Werror(
"Square %d x %d matrix expected",r->N,r->N);
2818 if (( DDD !=
NULL) && (DD ==
NULL)) DD = DDD;
2819 if (( DDN !=
NULL) && (DN ==
NULL)) DN = DDN;
2827 WerrorS(
"Incorrect input : non-constants are not allowed as coefficients (first argument)");
2835 WerrorS(
"Incorrect input : zero coefficients are not allowed");
2847 IsSkewConstant =
true;
2849 C =
mpNew(r->N,r->N);
2852 for(i=1; i<r->N; i++)
2853 for(j=i+1; j<=r->N; j++)
2861 if ( (CN ==
NULL) && (CC !=
NULL) )
2871 tmpIsSkewConstant =
true;
2873 for(i=1; i<r->N; i++)
2874 for(j=i+1; j<=r->N; j++)
2882 Werror(
"Incorrect input : non-constants are not allowed as coefficients (first argument at [%d, %d])", i, j);
2893 WerrorS(
"Incorrect input : matrix of coefficients contains zeros in the upper triangle");
2900 if (!
n_Equal(pN, qN, curr->cf)) tmpIsSkewConstant =
false;
2914 IsSkewConstant = tmpIsSkewConstant;
2916 if ( tmpIsSkewConstant &&
n_IsOne(pN, curr->cf) )
2925 D =
mpNew(r->N,r->N); bDnew =
true;
2935 for(i=1; i<r->N; i++)
2936 for(j=i+1; j<=r->N; j++)
2946 for(
int i = 1; (i < r->N) && b; i++)
2947 for(
int j = i+1; (j <= r->N) && b; j++)
2978 PrintS(
"nc_CallPlural(), Computed data, C: \n");
2981 PrintS(
"nc_CallPlural(), Computed data, D: \n");
2984 Print(
"\nTemporary: type = %d, IsSkewConstant = %d\n", nctype, IsSkewConstant);
2994 WerrorS(
"Matrix of polynomials violates the ordering condition");
3014 if (r->GetNC() !=
NULL)
3017 WarnS(
"Changing the NC-structure of an existing NC-ring!!!");
3022 r->GetNC() = nc_new;
3038 WarnS(
"Error occurred while coping/setuping the NC structure!");
3055 r->GetNC()->IsSkewConstant=1;
3072 r->GetNC()->MTsize = (
int *)
omAlloc0((r->N*(r->N-1))/2*
sizeof(int));
3080 for(i=1; i<r->N; i++)
3082 for(j=i+1; j<=r->N; j++)
3087 r->GetNC()->MTsize[
UPMATELEM(i,j,r->N)] = 1;
3096 r->GetNC()->MTsize[
UPMATELEM(i,j,r->N)] = DefMTsize;
3097 r->GetNC()->MT[
UPMATELEM(i,j,r->N)] =
mpNew(DefMTsize, DefMTsize);
3125 r->GetNC()->IsSkewConstant = 0;
3129 r->GetNC()->COM=
COM;
3149 p_Procs->p_Mult_mm = rGR->p_Procs->p_Mult_mm =
gnc_p_Mult_mm;
3196 p_Procs->p_Minus_mm_Mult_qq =
NULL;
3202 r->GetNC()->SPoly() = gnc_CreateSpoly;
3203 r->GetNC()->ReduceSPoly() = gnc_ReduceSpoly;
3237 int *PRE = (
int *)
omAlloc0((rN+1)*
sizeof(int));
3238 int *SUF = (
int *)
omAlloc0((rN+1)*
sizeof(int));
3248 pow = PRE[n]; PRE[n]=0;
3252 for (i=n+1; i<=rN; i++)
3294 for(
int i=1;
i<rr->N;
i++)
3295 for(
int j=
i+1;
j<=rr->N;
j++)
3299 WarnS(
"Error initializing multiplication!");
3311 if (dstRing == srcRing)
3313 return(
p_Copy(p,dstRing));
3323 int *perm = (
int *)
omAlloc0((
rVar(srcRing)+1)*
sizeof(int));
3324 int *par_perm = (
int *)
omAlloc0((
rPar(srcRing)+1)*
sizeof(
int));
3332 if ((shift<0) || (shift >
rVar(srcRing)))
3334 WerrorS(
"bad shifts in p_CopyEmbed");
3337 for (i=1; i<= srcRing->N; i++)
3341 q =
p_PermPoly(p,perm,srcRing, dstRing, nMap,par_perm,
rPar(srcRing));
3349 int diagnose =
TRUE;
3357 if (rBase->N != rCandidate->N) diagnose =
FALSE;
3376 if ( Rop == dst )
return(
p_Copy(p, dst));
3382 WarnS(
"an opposite ring should be used");
3393 int *perm=(
int *)
omAlloc0((Rop->N+1)*
sizeof(int));
3398 for(i=1; i<=Rop->N; i++)
3400 perm[
i] = Rop->N+1-
i;
3415 if ( Rop == dst )
return id_Copy(I, dst);
3420 WarnS(
"an opposite ring should be used");
3424 ideal idOp =
idInit(I->ncols, I->rank);
3425 for (i=0; i< (I->ncols)*(I->nrows); i++)
3427 idOp->m[
i] =
pOppose(Rop,I->m[i], dst);
3436 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)
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)
static poly p_Mult_nn(poly p, number n, const ring r)
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)
void p_Content(poly ph, const ring r)
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
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
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.