26 # define PLURAL_INTERNAL_DECLARATIONS 107 #define freeT(A,v) omFreeSize((ADDRESS)A,(v+1)*sizeof(int)) 108 #define freeN(A,k) omFreeSize((ADDRESS)A,k*sizeof(number)) 165 const int pVariables = r->N;
167 for (
int i = pVariables;
i!=0;
i--)
210 const poly,
const ring
r)
221 shorter =
pLength(p)-org_p-org_q;
228 const int,
const ring
r)
243 return gnc_p_Minus_mm_Mult_qq(
p,
m, q, d1, i, t,
r);
375 int *
P=(
int *)
omAlloc0((rN+1)*
sizeof(int));
376 int *
M=(
int *)
omAlloc0((rN+1)*
sizeof(int));
409 PrintS(
"gnc_p_Mult_mm: Multiplication in the left module from the right");
418 if (side==1) s=
"gnc_p_Mult_mm";
419 else s=
"gnc_mm_Mult_p";
420 Print(
"%s: exponent mismatch %d and %d\n",s,expP,expM);
481 int *F=(
int *)
omAlloc0((rN+1)*
sizeof(int));
482 int *
G=(
int *)
omAlloc0((rN+1)*
sizeof(int));
484 memcpy(F, F0,(rN+1)*
sizeof(
int));
486 memcpy(G, G0,(rN+1)*
sizeof(
int));
492 while ((F[iF]==0)&&(iF>=1)) iF--;
503 while ((G[jG]==0)&&(jG<rN)) jG++;
505 while ((G[iG]==0)&&(iG>1)) iG--;
512 {
for(
int ii=rN;ii>0;ii--) F[ii]+=G[ii]; }
526 if (r->GetNC()->IsSkewConstant==1)
529 for(j=jG; j<=iG; j++)
534 for(i=j+1; i<=iF; i++)
536 cpower = cpower + F[
i];
538 cpower = cpower*G[
j];
539 tpower = tpower + cpower;
543 n_Power(cff,tpower,&tmp_num, r);
549 number totcff=
n_Init(1,r);
550 for(j=jG; j<=iG; j++)
555 for(i=j+1; i<=iF; i++)
561 n_Power(cff,cpower,&tmp_num, r);
562 cff =
n_Mult(totcff,tmp_num, r);
573 {
for(
int ii=rN;ii>0;ii--) F[ii]+=G[ii]; }
595 int *Prv=(
int *)
omAlloc0((rN+1)*
sizeof(int));
596 int *Nxt=(
int *)
omAlloc0((rN+1)*
sizeof(int));
599 int cnt=0;
int cnf=0;
604 Prv[
i]=F[
i]; Nxt[
i]=0;
608 if (cnf==0)
freeT(Prv,rN);
610 for (i=jG+1;i<=rN;i++)
634 number *c=(number *)
omAlloc0((rN+1)*
sizeof(number));
639 int *U=(
int *)
omAlloc0((rN+1)*
sizeof(int));
641 for (i=jG;i<=rN;i++) U[i]=Nxt[i]+G[i];
741 while ((F[iF]==0)&&(iF>0)) iF-- ;
752 while ((F[jF]==0)&&(jF<=rN)) jF++;
803 int *Prv=(
int*)
omAlloc0((rN+1)*
sizeof(int));
804 int *Nxt=(
int*)
omAlloc0((rN+1)*
sizeof(int));
805 int *lF=(
int *)
omAlloc0((rN+1)*
sizeof(int));
807 int cnt=0;
int cnf=0;
811 Prv[
i]=F[
i]; Nxt[
i]=0;
820 for (i=jG+1;i<=rN;i++)
823 if (cnf!=0) { Prv[
i]=0;}
870 number *c=(number *)
omAlloc0((cnt+2)*
sizeof(number));
876 int *U=(
int *)
omAlloc0((rN+1)*
sizeof(int));
880 memcpy(U, Nxt,(rN+1)*
sizeof(
int));
945 num=
n_Mult(c[cnt+1],c[cnt],r);
995 matrix cMT=r->GetNC()->MT[cMTindex];
1017 cMT=r->GetNC()->MT[cMTindex];
1039 cMT=r->GetNC()->MT[cMTindex];
1073 if( FormulaMultiplier !=
NULL )
1074 PairType = FormulaMultiplier->
GetPair(j, i);
1128 n_Power(tmp_number,a*b,&tmp_number, r);
1141 if( FormulaMultiplier !=
NULL )
1142 PairType = FormulaMultiplier->
GetPair(j, i);
1155 int cMTsize=r->GetNC()->MTsize[vik];
1159 if (newcMTsize<=cMTsize)
1162 if (out !=
NULL)
return (out);
1165 if (newcMTsize > cMTsize)
1167 int inM=(((newcMTsize+6)/7)*7);
1168 assume (inM>=newcMTsize);
1173 for (k=1;k<=cMTsize;k++)
1175 for (m=1;m<=cMTsize;m++)
1189 r->GetNC()->MT[
UPMATELEM(j,i,rN)] = tmp;
1191 r->GetNC()->MTsize[
UPMATELEM(j,i,rN)] = newcMTsize;
1225 while ( (
MATELEM(cMT,1,toXY)==
NULL) && (toXY>=2)) toXY--;
1226 for (m=toXY+1;m<=
b;m++)
1239 WarnS(
"Error: a=1; MATELEM!=0");
1249 while ( (
MATELEM(cMT,toYX,1)==
NULL) && (toYX>=2)) toYX--;
1250 for (m=toYX+1;m<=
a;m++)
1263 WarnS(
"Error: b=1, MATELEM!=0");
1273 int dXY=0;
int dYX=0;
1276 int toX=a-1;
int toY=b-1;
1280 while ( (
MATELEM(cMT,toX,b)==
NULL) && (toX>=1)) toX--;
1283 while ( (
MATELEM(cMT,1,toXY)==
NULL) && (toXY>=1)) toXY--;
1289 while ( (
MATELEM(cMT,a,toY)==
NULL) && (toY>=1)) toY--;
1292 while ( (
MATELEM(cMT,toYX,1)==
NULL) && (toYX>=1)) toYX--;
1303 for (m=toXY+1;m<=
b;m++)
1316 WarnS(
"dYX>=dXY,toXY; MATELEM==0");
1323 for (k=toX+1;k<=
a;k++)
1336 WarnS(
"dYX>=dXY,toX; MATELEM==0");
1348 for (m=toYX+1;m<=
a;m++)
1361 WarnS(
"dYX<dXY,toYX; MATELEM==0");
1368 for (k=toY+1;k<=
b;k++)
1381 WarnS(
"dYX<dXY,toY; MATELEM==0");
1410 dReportError(
"nc_ReduceSpolyOld: different components");
1464 if ((lCompP1!=lCompP2) && (lCompP1!=0) && (lCompP2!=0))
1467 WerrorS(
"gnc_ReduceSpolyNew: different non-zero components!");
1537 dReportError(
"gnc_CreateSpolyOld : different components!");
1548 pL =
p_Lcm(p1,p2,r);
1632 if ((lCompP1!=lCompP2) && (lCompP1!=0) && (lCompP2!=0))
1635 WerrorS(
"gnc_CreateSpolyNew: different non-zero components!");
1689 WarnS(
"gnc_CreateSpolyNew: wrong monomials!");
1745 WerrorS(
"ERROR in nc_CreateSpoly: result of multiplication is Zero!\n");
1900 void gnc_ReduceSpolyTail(
poly p1,
poly q,
poly q2,
poly spNoether,
const ring
r)
1917 number MinusOne=
n_Init(-1,r);
1949 if ((lCompP1!=lCompP2) && (lCompP1!=0) && (lCompP2!=0))
1952 WerrorS(
"nc_CreateShortSpoly: wrong module components!");
1959 #ifdef HAVE_RATGRING 2021 if( !
kbTest(b) )
WerrorS(
"nc_kBucketPolyRed: broken bucket!");
2122 if (c!=
NULL) *c=ctmp;
2156 if (c!=
NULL) *c=ctmp;
2204 PrintS(
"nc_PolyPolyRedNew(");
2268 if(b ==
NULL)
return;
2354 int *M1=(
int *)
omAlloc0((rN+1)*
sizeof(int));
2355 int *M2=(
int *)
omAlloc0((rN+1)*
sizeof(int));
2356 int *aPREFIX=(
int *)
omAlloc0((rN+1)*
sizeof(int));
2357 int *aSUFFIX=(
int *)
omAlloc0((rN+1)*
sizeof(int));
2379 if (i<j) {nMax=
j; nMin=
i;}
else {nMax=
i; nMin=
j;}
2398 if (i>j) bres=
p_Neg(bres, r);
2403 memcpy(aSUFFIX, M1,(rN+1)*
sizeof(
int));
2404 memcpy(aPREFIX, M1,(rN+1)*
sizeof(
int));
2405 for (k=1;k<=
j;k++) aSUFFIX[k]=0;
2406 for (k=j;k<=rN;k++) aPREFIX[k]=0;
2428 memcpy(aSUFFIX, M2,(rN+1)*
sizeof(
int));
2429 memcpy(aPREFIX, M2,(rN+1)*
sizeof(
int));
2430 for (k=1;k<=
i;k++) aSUFFIX[k]=0;
2431 for (k=i;k<=rN;k++) aPREFIX[k]=0;
2465 if (a>b) {j=
b; i=
a;}
2489 for(s=1;s<=
size;s++)
2491 for(t=1;t<=
size;t++)
2510 totdeg=totdeg+
p_Deg(p,r);
2513 number ntd =
n_Init(totdeg, r);
2514 number nln =
n_Init(length, r);
2515 number nres=
n_Div(ntd,nln, r);
2543 if( r->GetNC()->GetGlobalMultiplier() !=
NULL )
2545 delete r->GetNC()->GetGlobalMultiplier();
2546 r->GetNC()->GetGlobalMultiplier() =
NULL;
2549 if( r->GetNC()->GetFormulaPowerMultiplier() !=
NULL )
2551 delete r->GetNC()->GetFormulaPowerMultiplier();
2552 r->GetNC()->GetFormulaPowerMultiplier() =
NULL;
2562 for(j=i+1;j<=rN;j++)
2569 id_Delete((ideal *)&(r->GetNC()->COM),r);
2574 if(
rIsSCA(r) && (r->GetNC()->SCAQuotient() !=
NULL) )
2642 int *ExpVar=(
int*)
omAlloc0((rN+1)*
sizeof(int));
2643 int *ExpTmp=(
int*)
omAlloc0((rN+1)*
sizeof(int));
2645 int i;
int j;
int k;
2648 for (i=1; i<rN; i++)
2652 for (j=i+1; j<=rN; j++)
2665 if (ExpVar[k]!=0) OK=0;
2706 for(i=1; i<r->N; i++)
2708 for(j=i+1; j<=r->N; j++)
2719 Werror(
"Bad ordering at %d,%d\n",i,j);
2750 bool bSetupQuotient,
bool bCopyInput,
bool bBeQuiet,
2751 ring curr,
bool dummy_ring )
2756 if( !bSetupQuotient)
2775 WarnS(
"commutative ring with 1 variable");
2792 PrintS(
"nc_CallPlural(), Input data, CCC: \n");
2797 PrintS(
"nc_CallPlural(), Input data, DDD: \n");
2810 if( (!bBeQuiet) && (r->GetNC() !=
NULL) )
2811 WarnS(
"going to redefine the algebra structure");
2818 matrix C;
bool bCnew =
false;
2826 bool IsSkewConstant =
false, tmpIsSkewConstant;
2845 Werror(
"Square %d x %d matrix expected", r->N, r->N);
2852 if (( CCC !=
NULL) && (CC ==
NULL)) CC = CCC;
2853 if (( CCN !=
NULL) && (CN ==
NULL)) CN = CCN;
2864 Werror(
"Square %d x %d matrix expected",r->N,r->N);
2872 if (( DDD !=
NULL) && (DD ==
NULL)) DD = DDD;
2873 if (( DDN !=
NULL) && (DN ==
NULL)) DN = DDN;
2881 WerrorS(
"Incorrect input : non-constants are not allowed as coefficients (first argument)");
2889 WerrorS(
"Incorrect input : zero coefficients are not allowed");
2901 IsSkewConstant =
true;
2903 C =
mpNew(r->N,r->N);
2906 for(i=1; i<r->N; i++)
2907 for(j=i+1; j<=r->N; j++)
2915 if ( (CN ==
NULL) && (CC !=
NULL) )
2925 tmpIsSkewConstant =
true;
2927 for(i=1; i<r->N; i++)
2928 for(j=i+1; j<=r->N; j++)
2936 Werror(
"Incorrect input : non-constants are not allowed as coefficients (first argument at [%d, %d])", i, j);
2947 WerrorS(
"Incorrect input : matrix of coefficients contains zeros in the upper triangle");
2954 if (!
n_Equal(pN, qN, curr->cf)) tmpIsSkewConstant =
false;
2968 IsSkewConstant = tmpIsSkewConstant;
2970 if ( tmpIsSkewConstant &&
n_IsOne(pN, curr) )
2979 D =
mpNew(r->N,r->N); bDnew =
true;
2989 for(i=1; i<r->N; i++)
2990 for(j=i+1; j<=r->N; j++)
3000 for(
int i = 1; (i < r->N) && b; i++)
3001 for(
int j = i+1; (j <= r->N) && b; j++)
3032 PrintS(
"nc_CallPlural(), Computed data, C: \n");
3035 PrintS(
"nc_CallPlural(), Computed data, D: \n");
3038 Print(
"\nTemporary: type = %d, IsSkewConstant = %d\n", nctype, IsSkewConstant);
3048 WerrorS(
"Matrix of polynomials violates the ordering condition");
3068 if (r->GetNC() !=
NULL)
3071 WarnS(
"Changing the NC-structure of an existing NC-ring!!!");
3076 r->GetNC() = nc_new;
3092 WarnS(
"Error occurred while coping/setuping the NC structure!");
3109 r->GetNC()->IsSkewConstant=1;
3126 r->GetNC()->MTsize = (
int *)
omAlloc0((r->N*(r->N-1))/2*
sizeof(int));
3134 for(i=1; i<r->N; i++)
3136 for(j=i+1; j<=r->N; j++)
3141 r->GetNC()->MTsize[
UPMATELEM(i,j,r->N)] = 1;
3150 r->GetNC()->MTsize[
UPMATELEM(i,j,r->N)] = DefMTsize;
3151 r->GetNC()->MT[
UPMATELEM(i,j,r->N)] =
mpNew(DefMTsize, DefMTsize);
3179 r->GetNC()->IsSkewConstant = 0;
3183 r->GetNC()->COM=
COM;
3203 p_Procs->p_Mult_mm = rGR->p_Procs->p_Mult_mm =
gnc_p_Mult_mm;
3250 p_Procs->p_Minus_mm_Mult_qq =
NULL;
3256 r->GetNC()->SPoly() = gnc_CreateSpoly;
3257 r->GetNC()->ReduceSPoly() = gnc_ReduceSpoly;
3291 int *PRE = (
int *)
omAlloc0((rN+1)*
sizeof(int));
3292 int *SUF = (
int *)
omAlloc0((rN+1)*
sizeof(int));
3302 pow = PRE[n]; PRE[n]=0;
3306 for (i=n+1; i<=rN; i++)
3348 for(
int i=1;
i<rr->N;
i++)
3349 for(
int j=
i+1;
j<=rr->N;
j++)
3353 WarnS(
"Error initializing multiplication!");
3365 if (dstRing == srcRing)
3367 return(
p_Copy(p,dstRing));
3378 int *par_perm = (
int *)
omAlloc0((
rPar(srcRing)+1)*
sizeof(
int));
3386 if ((shift<0) || (shift >
rVar(srcRing)))
3388 WerrorS(
"bad shifts in p_CopyEmbed");
3391 for (i=1; i<= srcRing->N; i++)
3395 q =
p_PermPoly(p,perm,srcRing, dstRing, nMap,par_perm,
rPar(srcRing));
3403 int diagnose =
TRUE;
3411 if (rBase->N != rCandidate->N) diagnose =
FALSE;
3430 if ( Rop == dst )
return(
p_Copy(p, dst));
3436 WarnS(
"an opposite ring should be used");
3452 for(i=1; i<=Rop->N; i++)
3454 perm[
i] = Rop->N+1-
i;
3469 if ( Rop == dst )
return id_Copy(I, dst);
3474 WarnS(
"an opposite ring should be used");
3478 ideal idOp =
idInit(I->ncols, I->rank);
3479 for (i=0; i< (I->ncols)*(I->nrows); i++)
3481 idOp->m[
i] =
pOppose(Rop,I->m[i], dst);
3490 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
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 int pLength(poly a)
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)
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)
static ideal BBA_Proc_Dummy(const ideal, const ideal, const intvec *, const intvec *, kStrategy strat, const ring)
static poly NF_Proc_Dummy(ideal, ideal, poly, int, int, const ring _currRing)
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)
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.