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)) 164 const int pVariables = r->N;
166 for (
int i = pVariables;
i!=0;
i--)
209 const poly,
const ring
r)
220 shorter =
pLength(p)-org_p-org_q;
227 const int,
const ring
r)
242 return gnc_p_Minus_mm_Mult_qq(
p,
m, q, d1, i, t,
r);
374 int *
P=(
int *)
omAlloc0((rN+1)*
sizeof(int));
375 int *
M=(
int *)
omAlloc0((rN+1)*
sizeof(int));
417 if (side==1) s=
"gnc_p_Mult_mm";
418 else s=
"gnc_mm_Mult_p";
419 Print(
"%s: exponent mismatch %d and %d\n",s,expP,expM);
480 int *F=(
int *)
omAlloc0((rN+1)*
sizeof(int));
481 int *
G=(
int *)
omAlloc0((rN+1)*
sizeof(int));
483 memcpy(F, F0,(rN+1)*
sizeof(
int));
485 memcpy(G, G0,(rN+1)*
sizeof(
int));
491 while ((F[iF]==0)&&(iF>=1)) iF--;
502 while ((G[jG]==0)&&(jG<rN)) jG++;
504 while ((G[iG]==0)&&(iG>1)) iG--;
511 {
for(
int ii=rN;ii>0;ii--) F[ii]+=G[ii]; }
519 number cff=
n_Init(1,r->cf);
525 if (r->GetNC()->IsSkewConstant==1)
528 for(j=jG; j<=iG; j++)
533 for(i=j+1; i<=iF; i++)
535 cpower = cpower + F[
i];
537 cpower = cpower*G[
j];
538 tpower = tpower + cpower;
542 n_Power(cff,tpower,&tmp_num, r->cf);
548 number totcff=
n_Init(1,r->cf);
549 for(j=jG; j<=iG; j++)
554 for(i=j+1; i<=iF; i++)
560 n_Power(cff,cpower,&tmp_num, r->cf);
561 cff =
n_Mult(totcff,tmp_num, r->cf);
564 totcff =
n_Copy(cff,r->cf);
572 {
for(
int ii=rN;ii>0;ii--) F[ii]+=G[ii]; }
594 int *Prv=(
int *)
omAlloc0((rN+1)*
sizeof(int));
595 int *Nxt=(
int *)
omAlloc0((rN+1)*
sizeof(int));
598 int cnt=0;
int cnf=0;
603 Prv[
i]=F[
i]; Nxt[
i]=0;
607 if (cnf==0)
freeT(Prv,rN);
609 for (i=jG+1;i<=rN;i++)
633 number *c=(number *)
omAlloc0((rN+1)*
sizeof(number));
638 int *U=(
int *)
omAlloc0((rN+1)*
sizeof(int));
640 for (i=jG;i<=rN;i++) U[i]=Nxt[i]+G[i];
740 while ((F[iF]==0)&&(iF>0)) iF-- ;
751 while ((F[jF]==0)&&(jF<=rN)) jF++;
802 int *Prv=(
int*)
omAlloc0((rN+1)*
sizeof(int));
803 int *Nxt=(
int*)
omAlloc0((rN+1)*
sizeof(int));
804 int *lF=(
int *)
omAlloc0((rN+1)*
sizeof(int));
806 int cnt=0;
int cnf=0;
810 Prv[
i]=F[
i]; Nxt[
i]=0;
819 for (i=jG+1;i<=rN;i++)
822 if (cnf!=0) { Prv[
i]=0;}
869 number *c=(number *)
omAlloc0((cnt+2)*
sizeof(number));
875 int *U=(
int *)
omAlloc0((rN+1)*
sizeof(int));
879 memcpy(U, Nxt,(rN+1)*
sizeof(
int));
944 num=
n_Mult(c[cnt+1],c[cnt],r->cf);
994 matrix cMT=r->GetNC()->MT[cMTindex];
1016 cMT=r->GetNC()->MT[cMTindex];
1038 cMT=r->GetNC()->MT[cMTindex];
1072 if( FormulaMultiplier !=
NULL )
1073 PairType = FormulaMultiplier->
GetPair(j, i);
1127 n_Power(tmp_number,a*b,&tmp_number, r->cf);
1140 if( FormulaMultiplier !=
NULL )
1141 PairType = FormulaMultiplier->
GetPair(j, i);
1154 int cMTsize=r->GetNC()->MTsize[vik];
1158 if (newcMTsize<=cMTsize)
1161 if (out !=
NULL)
return (out);
1164 if (newcMTsize > cMTsize)
1166 int inM=(((newcMTsize+6)/7)*7);
1167 assume (inM>=newcMTsize);
1172 for (k=1;k<=cMTsize;k++)
1174 for (m=1;m<=cMTsize;m++)
1188 r->GetNC()->MT[
UPMATELEM(j,i,rN)] = tmp;
1190 r->GetNC()->MTsize[
UPMATELEM(j,i,rN)] = newcMTsize;
1224 while ( (
MATELEM(cMT,1,toXY)==
NULL) && (toXY>=2)) toXY--;
1225 for (m=toXY+1;m<=
b;m++)
1238 WarnS(
"Error: a=1; MATELEM!=0");
1248 while ( (
MATELEM(cMT,toYX,1)==
NULL) && (toYX>=2)) toYX--;
1249 for (m=toYX+1;m<=
a;m++)
1262 WarnS(
"Error: b=1, MATELEM!=0");
1272 int dXY=0;
int dYX=0;
1275 int toX=a-1;
int toY=b-1;
1279 while ( (
MATELEM(cMT,toX,b)==
NULL) && (toX>=1)) toX--;
1282 while ( (
MATELEM(cMT,1,toXY)==
NULL) && (toXY>=1)) toXY--;
1288 while ( (
MATELEM(cMT,a,toY)==
NULL) && (toY>=1)) toY--;
1291 while ( (
MATELEM(cMT,toYX,1)==
NULL) && (toYX>=1)) toYX--;
1302 for (m=toXY+1;m<=
b;m++)
1315 WarnS(
"dYX>=dXY,toXY; MATELEM==0");
1322 for (k=toX+1;k<=
a;k++)
1335 WarnS(
"dYX>=dXY,toX; MATELEM==0");
1347 for (m=toYX+1;m<=
a;m++)
1360 WarnS(
"dYX<dXY,toYX; MATELEM==0");
1367 for (k=toY+1;k<=
b;k++)
1380 WarnS(
"dYX<dXY,toY; MATELEM==0");
1409 dReportError(
"nc_ReduceSpolyOld: different components");
1463 if ((lCompP1!=lCompP2) && (lCompP1!=0) && (lCompP2!=0))
1466 WerrorS(
"gnc_ReduceSpolyNew: different non-zero components!");
1536 dReportError(
"gnc_CreateSpolyOld : different components!");
1547 pL =
p_Lcm(p1,p2,r);
1631 if ((lCompP1!=lCompP2) && (lCompP1!=0) && (lCompP2!=0))
1634 WerrorS(
"gnc_CreateSpolyNew: different non-zero components!");
1688 WarnS(
"gnc_CreateSpolyNew: wrong monomials!");
1744 WerrorS(
"ERROR in nc_CreateSpoly: result of multiplication is Zero!\n");
1899 void gnc_ReduceSpolyTail(
poly p1,
poly q,
poly q2,
poly spNoether,
const ring
r)
1916 number MinusOne=
n_Init(-1,r->cf);
1917 if (!
n_Equal(cQ,MinusOne,r->cf))
1948 if ((lCompP1!=lCompP2) && (lCompP1!=0) && (lCompP2!=0))
1951 WerrorS(
"nc_CreateShortSpoly: wrong module components!");
1958 #ifdef HAVE_RATGRING 2020 if( !
kbTest(b) )
WerrorS(
"nc_kBucketPolyRed: broken bucket!");
2121 if (c!=
NULL) *c=ctmp;
2155 if (c!=
NULL) *c=ctmp;
2203 PrintS(
"nc_PolyPolyRedNew(");
2267 if(b ==
NULL)
return;
2353 int *M1=(
int *)
omAlloc0((rN+1)*
sizeof(int));
2354 int *M2=(
int *)
omAlloc0((rN+1)*
sizeof(int));
2355 int *aPREFIX=(
int *)
omAlloc0((rN+1)*
sizeof(int));
2356 int *aSUFFIX=(
int *)
omAlloc0((rN+1)*
sizeof(int));
2378 if (i<j) {nMax=
j; nMin=
i;}
else {nMax=
i; nMin=
j;}
2397 if (i>j) bres=
p_Neg(bres, r);
2402 memcpy(aSUFFIX, M1,(rN+1)*
sizeof(
int));
2403 memcpy(aPREFIX, M1,(rN+1)*
sizeof(
int));
2404 for (k=1;k<=
j;k++) aSUFFIX[k]=0;
2405 for (k=j;k<=rN;k++) aPREFIX[k]=0;
2427 memcpy(aSUFFIX, M2,(rN+1)*
sizeof(
int));
2428 memcpy(aPREFIX, M2,(rN+1)*
sizeof(
int));
2429 for (k=1;k<=
i;k++) aSUFFIX[k]=0;
2430 for (k=i;k<=rN;k++) aPREFIX[k]=0;
2464 if (a>b) {j=
b; i=
a;}
2488 for(s=1;s<=
size;s++)
2490 for(t=1;t<=
size;t++)
2509 totdeg=totdeg+
p_Deg(p,r);
2512 number ntd =
n_Init(totdeg, r->cf);
2513 number nln =
n_Init(length, r->cf);
2514 number nres=
n_Div(ntd,nln, r->cf);
2542 if( r->GetNC()->GetGlobalMultiplier() !=
NULL )
2544 delete r->GetNC()->GetGlobalMultiplier();
2545 r->GetNC()->GetGlobalMultiplier() =
NULL;
2548 if( r->GetNC()->GetFormulaPowerMultiplier() !=
NULL )
2550 delete r->GetNC()->GetFormulaPowerMultiplier();
2551 r->GetNC()->GetFormulaPowerMultiplier() =
NULL;
2561 for(j=i+1;j<=rN;j++)
2568 id_Delete((ideal *)&(r->GetNC()->COM),r);
2573 if(
rIsSCA(r) && (r->GetNC()->SCAQuotient() !=
NULL) )
2641 int *ExpVar=(
int*)
omAlloc0((rN+1)*
sizeof(int));
2642 int *ExpTmp=(
int*)
omAlloc0((rN+1)*
sizeof(int));
2644 int i;
int j;
int k;
2647 for (i=1; i<rN; i++)
2651 for (j=i+1; j<=rN; j++)
2664 if (ExpVar[k]!=0) OK=0;
2705 for(i=1; i<r->N; i++)
2707 for(j=i+1; j<=r->N; j++)
2718 Werror(
"Bad ordering at %d,%d\n",i,j);
2749 bool bSetupQuotient,
bool bCopyInput,
bool bBeQuiet,
2750 ring curr,
bool dummy_ring )
2755 if( !bSetupQuotient)
2774 WarnS(
"commutative ring with 1 variable");
2791 PrintS(
"nc_CallPlural(), Input data, CCC: \n");
2796 PrintS(
"nc_CallPlural(), Input data, DDD: \n");
2809 if( (!bBeQuiet) && (r->GetNC() !=
NULL) )
2810 WarnS(
"going to redefine the algebra structure");
2817 matrix C;
bool bCnew =
false;
2825 bool IsSkewConstant =
false, tmpIsSkewConstant;
2844 Werror(
"Square %d x %d matrix expected", r->N, r->N);
2851 if (( CCC !=
NULL) && (CC ==
NULL)) CC = CCC;
2852 if (( CCN !=
NULL) && (CN ==
NULL)) CN = CCN;
2863 Werror(
"Square %d x %d matrix expected",r->N,r->N);
2871 if (( DDD !=
NULL) && (DD ==
NULL)) DD = DDD;
2872 if (( DDN !=
NULL) && (DN ==
NULL)) DN = DDN;
2880 WerrorS(
"Incorrect input : non-constants are not allowed as coefficients (first argument)");
2888 WerrorS(
"Incorrect input : zero coefficients are not allowed");
2900 IsSkewConstant =
true;
2902 C =
mpNew(r->N,r->N);
2905 for(i=1; i<r->N; i++)
2906 for(j=i+1; j<=r->N; j++)
2914 if ( (CN ==
NULL) && (CC !=
NULL) )
2924 tmpIsSkewConstant =
true;
2926 for(i=1; i<r->N; i++)
2927 for(j=i+1; j<=r->N; j++)
2935 Werror(
"Incorrect input : non-constants are not allowed as coefficients (first argument at [%d, %d])", i, j);
2946 WerrorS(
"Incorrect input : matrix of coefficients contains zeros in the upper triangle");
2953 if (!
n_Equal(pN, qN, curr->cf)) tmpIsSkewConstant =
false;
2967 IsSkewConstant = tmpIsSkewConstant;
2969 if ( tmpIsSkewConstant &&
n_IsOne(pN, curr->cf) )
2978 D =
mpNew(r->N,r->N); bDnew =
true;
2988 for(i=1; i<r->N; i++)
2989 for(j=i+1; j<=r->N; j++)
2999 for(
int i = 1; (i < r->N) && b; i++)
3000 for(
int j = i+1; (j <= r->N) && b; j++)
3031 PrintS(
"nc_CallPlural(), Computed data, C: \n");
3034 PrintS(
"nc_CallPlural(), Computed data, D: \n");
3037 Print(
"\nTemporary: type = %d, IsSkewConstant = %d\n", nctype, IsSkewConstant);
3047 WerrorS(
"Matrix of polynomials violates the ordering condition");
3067 if (r->GetNC() !=
NULL)
3070 WarnS(
"Changing the NC-structure of an existing NC-ring!!!");
3075 r->GetNC() = nc_new;
3091 WarnS(
"Error occurred while coping/setuping the NC structure!");
3108 r->GetNC()->IsSkewConstant=1;
3125 r->GetNC()->MTsize = (
int *)
omAlloc0((r->N*(r->N-1))/2*
sizeof(int));
3133 for(i=1; i<r->N; i++)
3135 for(j=i+1; j<=r->N; j++)
3140 r->GetNC()->MTsize[
UPMATELEM(i,j,r->N)] = 1;
3149 r->GetNC()->MTsize[
UPMATELEM(i,j,r->N)] = DefMTsize;
3150 r->GetNC()->MT[
UPMATELEM(i,j,r->N)] =
mpNew(DefMTsize, DefMTsize);
3178 r->GetNC()->IsSkewConstant = 0;
3182 r->GetNC()->COM=
COM;
3202 p_Procs->p_Mult_mm = rGR->p_Procs->p_Mult_mm =
gnc_p_Mult_mm;
3249 p_Procs->p_Minus_mm_Mult_qq =
NULL;
3255 r->GetNC()->SPoly() = gnc_CreateSpoly;
3256 r->GetNC()->ReduceSPoly() = gnc_ReduceSpoly;
3290 int *PRE = (
int *)
omAlloc0((rN+1)*
sizeof(int));
3291 int *SUF = (
int *)
omAlloc0((rN+1)*
sizeof(int));
3301 pow = PRE[n]; PRE[n]=0;
3305 for (i=n+1; i<=rN; i++)
3347 for(
int i=1;
i<rr->N;
i++)
3348 for(
int j=
i+1;
j<=rr->N;
j++)
3352 WarnS(
"Error initializing multiplication!");
3364 if (dstRing == srcRing)
3366 return(
p_Copy(p,dstRing));
3377 int *par_perm = (
int *)
omAlloc0((
rPar(srcRing)+1)*
sizeof(
int));
3385 if ((shift<0) || (shift >
rVar(srcRing)))
3387 WerrorS(
"bad shifts in p_CopyEmbed");
3390 for (i=1; i<= srcRing->N; i++)
3394 q =
p_PermPoly(p,perm,srcRing, dstRing, nMap,par_perm,
rPar(srcRing));
3402 int diagnose =
TRUE;
3410 if (rBase->N != rCandidate->N) diagnose =
FALSE;
3429 if ( Rop == dst )
return(
p_Copy(p, dst));
3435 WarnS(
"an opposite ring should be used");
3451 for(i=1; i<=Rop->N; i++)
3453 perm[
i] = Rop->N+1-
i;
3468 if ( Rop == dst )
return id_Copy(I, dst);
3473 WarnS(
"an opposite ring should be used");
3477 ideal idOp =
idInit(I->ncols, I->rank);
3478 for (i=0; i< (I->ncols)*(I->nrows); i++)
3480 idOp->m[
i] =
pOppose(Rop,I->m[i], dst);
3489 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)
poly p_Lcm(const poly a, const poly b, const long lCompM, 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)
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
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
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)
static poly p_Init(const ring r, omBin bin)
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.