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_p_mm_Mult";
361 Print(
"%s: exponent mismatch %d and %d\n",s,expP,expM);
423 int *F=(
int *)
omAlloc0((rN+1)*
sizeof(int));
424 int *
G=(
int *)
omAlloc0((rN+1)*
sizeof(int));
426 memcpy(F, F0,(rN+1)*
sizeof(
int));
428 memcpy(G, G0,(rN+1)*
sizeof(
int));
434 while ((F[iF]==0)&&(iF>=1)) iF--;
445 while ((G[jG]==0)&&(jG<rN)) jG++;
447 while ((G[iG]==0)&&(iG>1)) iG--;
454 {
for(
int ii=rN;ii>0;ii--) F[ii]+=G[ii]; }
462 number cff=
n_Init(1,r->cf);
468 if (r->GetNC()->IsSkewConstant==1)
471 for(j=jG; j<=iG; j++)
476 for(i=j+1; i<=iF; i++)
478 cpower = cpower + F[
i];
480 cpower = cpower*G[
j];
481 tpower = tpower + cpower;
485 n_Power(cff,tpower,&tmp_num, r->cf);
491 number totcff=
n_Init(1,r->cf);
492 for(j=jG; j<=iG; j++)
497 for(i=j+1; i<=iF; i++)
503 n_Power(cff,cpower,&tmp_num, r->cf);
504 cff =
n_Mult(totcff,tmp_num, r->cf);
507 totcff =
n_Copy(cff,r->cf);
515 {
for(
int ii=rN;ii>0;ii--) F[ii]+=G[ii]; }
537 int *Prv=(
int *)
omAlloc0((rN+1)*
sizeof(int));
538 int *Nxt=(
int *)
omAlloc0((rN+1)*
sizeof(int));
541 int cnt=0;
int cnf=0;
546 Prv[
i]=F[
i]; Nxt[
i]=0;
550 if (cnf==0)
freeT(Prv,rN);
552 for (i=jG+1;i<=rN;i++)
576 number *c=(number *)
omAlloc0((rN+1)*
sizeof(number));
581 int *U=(
int *)
omAlloc0((rN+1)*
sizeof(int));
583 for (i=jG;i<=rN;i++) U[i]=Nxt[i]+G[i];
683 while ((F[iF]==0)&&(iF>0)) iF-- ;
694 while ((F[jF]==0)&&(jF<=rN)) jF++;
745 int *Prv=(
int*)
omAlloc0((rN+1)*
sizeof(int));
746 int *Nxt=(
int*)
omAlloc0((rN+1)*
sizeof(int));
747 int *lF=(
int *)
omAlloc0((rN+1)*
sizeof(int));
749 int cnt=0;
int cnf=0;
753 Prv[
i]=F[
i]; Nxt[
i]=0;
762 for (i=jG+1;i<=rN;i++)
765 if (cnf!=0) { Prv[
i]=0;}
812 number *c=(number *)
omAlloc0((cnt+2)*
sizeof(number));
818 int *U=(
int *)
omAlloc0((rN+1)*
sizeof(int));
822 memcpy(U, Nxt,(rN+1)*
sizeof(
int));
887 num=
n_Mult(c[cnt+1],c[cnt],r->cf);
937 matrix cMT=r->GetNC()->MT[cMTindex];
959 cMT=r->GetNC()->MT[cMTindex];
981 cMT=r->GetNC()->MT[cMTindex];
1015 if( FormulaMultiplier !=
NULL )
1016 PairType = FormulaMultiplier->
GetPair(j, i);
1070 n_Power(tmp_number,a*b,&tmp_number, r->cf);
1083 if( FormulaMultiplier !=
NULL )
1084 PairType = FormulaMultiplier->
GetPair(j, i);
1097 int cMTsize=r->GetNC()->MTsize[vik];
1101 if (newcMTsize<=cMTsize)
1104 if (out !=
NULL)
return (out);
1107 if (newcMTsize > cMTsize)
1109 int inM=(((newcMTsize+6)/7)*7);
1110 assume (inM>=newcMTsize);
1115 for (k=1;k<=cMTsize;k++)
1117 for (m=1;m<=cMTsize;m++)
1131 r->GetNC()->MT[
UPMATELEM(j,i,rN)] = tmp;
1133 r->GetNC()->MTsize[
UPMATELEM(j,i,rN)] = newcMTsize;
1167 while ( (
MATELEM(cMT,1,toXY)==
NULL) && (toXY>=2)) toXY--;
1168 for (m=toXY+1;m<=
b;m++)
1181 WarnS(
"Error: a=1; MATELEM!=0");
1191 while ( (
MATELEM(cMT,toYX,1)==
NULL) && (toYX>=2)) toYX--;
1192 for (m=toYX+1;m<=a;m++)
1205 WarnS(
"Error: b=1, MATELEM!=0");
1215 int dXY=0;
int dYX=0;
1218 int toX=a-1;
int toY=b-1;
1222 while ( (
MATELEM(cMT,toX,b)==
NULL) && (toX>=1)) toX--;
1225 while ( (
MATELEM(cMT,1,toXY)==
NULL) && (toXY>=1)) toXY--;
1231 while ( (
MATELEM(cMT,a,toY)==
NULL) && (toY>=1)) toY--;
1234 while ( (
MATELEM(cMT,toYX,1)==
NULL) && (toYX>=1)) toYX--;
1245 for (m=toXY+1;m<=
b;m++)
1258 WarnS(
"dYX>=dXY,toXY; MATELEM==0");
1265 for (k=toX+1;k<=a;k++)
1278 WarnS(
"dYX>=dXY,toX; MATELEM==0");
1290 for (m=toYX+1;m<=a;m++)
1303 WarnS(
"dYX<dXY,toYX; MATELEM==0");
1310 for (k=toY+1;k<=
b;k++)
1323 WarnS(
"dYX<dXY,toY; MATELEM==0");
1352 dReportError(
"nc_ReduceSpolyOld: different components");
1406 if ((lCompP1!=lCompP2) && (lCompP1!=0) && (lCompP2!=0))
1409 WerrorS(
"gnc_ReduceSpolyNew: different non-zero components!");
1478 dReportError(
"gnc_CreateSpolyOld : different components!");
1489 pL =
p_Lcm(p1,p2,r);
1572 if ((lCompP1!=lCompP2) && (lCompP1!=0) && (lCompP2!=0))
1575 WerrorS(
"gnc_CreateSpolyNew: different non-zero components!");
1591 poly pL =
p_Lcm(p1,p2,r);
1629 WarnS(
"gnc_CreateSpolyNew: wrong monomials!");
1685 WerrorS(
"ERROR in nc_CreateSpoly: result of multiplication is Zero!\n");
1840 void gnc_ReduceSpolyTail(poly p1, poly q, poly q2, poly spNoether,
const ring r)
1857 number MinusOne=
n_Init(-1,r->cf);
1858 if (!
n_Equal(cQ,MinusOne,r->cf))
1889 if ((lCompP1!=lCompP2) && (lCompP1!=0) && (lCompP2!=0))
1892 WerrorS(
"nc_CreateShortSpoly: wrong module components!");
1899 #ifdef HAVE_RATGRING 1907 m =
p_Lcm(p1, p2, r);
1956 if( !
kbTest(b) )
WerrorS(
"nc_kBucketPolyRed: broken bucket!");
2057 if (c!=
NULL) *c=ctmp;
2091 if (c!=
NULL) *c=ctmp;
2139 PrintS(
"nc_PolyPolyRedNew(");
2203 if(b ==
NULL)
return;
2289 int *M1=(
int *)
omAlloc0((rN+1)*
sizeof(int));
2290 int *M2=(
int *)
omAlloc0((rN+1)*
sizeof(int));
2291 int *aPREFIX=(
int *)
omAlloc0((rN+1)*
sizeof(int));
2292 int *aSUFFIX=(
int *)
omAlloc0((rN+1)*
sizeof(int));
2314 if (i<j) {nMax=
j; nMin=
i;}
else {nMax=
i; nMin=
j;}
2333 if (i>j) bres=
p_Neg(bres, r);
2338 memcpy(aSUFFIX, M1,(rN+1)*
sizeof(
int));
2339 memcpy(aPREFIX, M1,(rN+1)*
sizeof(
int));
2340 for (k=1;k<=
j;k++) aSUFFIX[k]=0;
2341 for (k=j;k<=rN;k++) aPREFIX[k]=0;
2363 memcpy(aSUFFIX, M2,(rN+1)*
sizeof(
int));
2364 memcpy(aPREFIX, M2,(rN+1)*
sizeof(
int));
2365 for (k=1;k<=
i;k++) aSUFFIX[k]=0;
2366 for (k=i;k<=rN;k++) aPREFIX[k]=0;
2400 if (a>b) {j=
b; i=a;}
2424 for(s=1;s<=
size;s++)
2426 for(t=1;t<=
size;t++)
2445 totdeg=totdeg+
p_Deg(p,r);
2448 number ntd =
n_Init(totdeg, r->cf);
2449 number nln =
n_Init(length, r->cf);
2450 number nres=
n_Div(ntd,nln, r->cf);
2478 if( r->GetNC()->GetGlobalMultiplier() !=
NULL )
2480 delete r->GetNC()->GetGlobalMultiplier();
2481 r->GetNC()->GetGlobalMultiplier() =
NULL;
2484 if( r->GetNC()->GetFormulaPowerMultiplier() !=
NULL )
2486 delete r->GetNC()->GetFormulaPowerMultiplier();
2487 r->GetNC()->GetFormulaPowerMultiplier() =
NULL;
2497 for(j=i+1;j<=rN;j++)
2504 id_Delete((ideal *)&(r->GetNC()->COM),r);
2509 if(
rIsSCA(r) && (r->GetNC()->SCAQuotient() !=
NULL) )
2511 id_Delete(&r->GetNC()->SCAQuotient(), r);
2577 int *ExpVar=(
int*)
omAlloc0((rN+1)*
sizeof(int));
2578 int *ExpTmp=(
int*)
omAlloc0((rN+1)*
sizeof(int));
2580 int i;
int j;
int k;
2583 for (i=1; i<rN; i++)
2587 for (j=i+1; j<=rN; j++)
2600 if (ExpVar[k]!=0) OK=0;
2641 for(i=1; i<r->N; i++)
2643 for(j=i+1; j<=r->N; j++)
2654 Werror(
"Bad ordering at %d,%d\n",i,j);
2685 bool bSetupQuotient,
bool bCopyInput,
bool bBeQuiet,
2686 ring curr,
bool dummy_ring )
2691 if( !bSetupQuotient)
2710 WarnS(
"commutative ring with 1 variable");
2727 PrintS(
"nc_CallPlural(), Input data, CCC: \n");
2732 PrintS(
"nc_CallPlural(), Input data, DDD: \n");
2745 if( (!bBeQuiet) && (r->GetNC() !=
NULL) )
2746 WarnS(
"going to redefine the algebra structure");
2753 matrix C;
bool bCnew =
false;
2761 bool IsSkewConstant =
false, tmpIsSkewConstant;
2780 Werror(
"Square %d x %d matrix expected", r->N, r->N);
2787 if (( CCC !=
NULL) && (CC ==
NULL)) CC = CCC;
2788 if (( CCN !=
NULL) && (CN ==
NULL)) CN = CCN;
2799 Werror(
"Square %d x %d matrix expected",r->N,r->N);
2807 if (( DDD !=
NULL) && (DD ==
NULL)) DD = DDD;
2808 if (( DDN !=
NULL) && (DN ==
NULL)) DN = DDN;
2816 WerrorS(
"Incorrect input : non-constants are not allowed as coefficients (first argument)");
2824 WerrorS(
"Incorrect input : zero coefficients are not allowed");
2836 IsSkewConstant =
true;
2838 C =
mpNew(r->N,r->N);
2841 for(i=1; i<r->N; i++)
2842 for(j=i+1; j<=r->N; j++)
2850 if ( (CN ==
NULL) && (CC !=
NULL) )
2860 if (!pN_set)
n_Delete(&pN,curr->cf);
2865 tmpIsSkewConstant =
true;
2867 for(i=1; i<r->N; i++)
2868 for(j=i+1; j<=r->N; j++)
2876 Werror(
"Incorrect input : non-constants are not allowed as coefficients (first argument at [%d, %d])", i, j);
2887 WerrorS(
"Incorrect input : matrix of coefficients contains zeros in the upper triangle");
2894 if (!
n_Equal(pN, qN, curr->cf)) tmpIsSkewConstant =
false;
2908 IsSkewConstant = tmpIsSkewConstant;
2910 if ( tmpIsSkewConstant &&
n_IsOne(pN, curr->cf) )
2914 if (!pN_set)
n_Delete(&pN,curr->cf);
2920 D =
mpNew(r->N,r->N); bDnew =
true;
2930 for(i=1; i<r->N; i++)
2931 for(j=i+1; j<=r->N; j++)
2941 for(
int i = 1; (i < r->N) && b; i++)
2942 for(
int j = i+1; (j <= r->N) && b; j++)
2973 PrintS(
"nc_CallPlural(), Computed data, C: \n");
2976 PrintS(
"nc_CallPlural(), Computed data, D: \n");
2979 Print(
"\nTemporary: type = %d, IsSkewConstant = %d\n", nctype, IsSkewConstant);
2989 WerrorS(
"Matrix of polynomials violates the ordering condition");
3009 if (r->GetNC() !=
NULL)
3012 WarnS(
"Changing the NC-structure of an existing NC-ring!!!");
3017 r->GetNC() = nc_new;
3033 WarnS(
"Error occurred while coping/setuping the NC structure!");
3050 r->GetNC()->IsSkewConstant=1;
3067 r->GetNC()->MTsize = (
int *)
omAlloc0((r->N*(r->N-1))/2*
sizeof(int));
3068 id_Test((ideal)r->GetNC()->C, r);
3075 for(i=1; i<r->N; i++)
3077 for(j=i+1; j<=r->N; j++)
3082 r->GetNC()->MTsize[
UPMATELEM(i,j,r->N)] = 1;
3091 r->GetNC()->MTsize[
UPMATELEM(i,j,r->N)] = DefMTsize;
3092 r->GetNC()->MT[
UPMATELEM(i,j,r->N)] =
mpNew(DefMTsize, DefMTsize);
3120 r->GetNC()->IsSkewConstant = 0;
3124 r->GetNC()->COM=
COM;
3144 p_Procs->p_Mult_mm = rGR->p_Procs->p_Mult_mm =
gnc_p_Mult_mm;
3191 p_Procs->p_Minus_mm_Mult_qq =
NULL;
3194 r->GetNC()->mmMultP() = gnc_mm_Mult_p;
3195 r->GetNC()->mmMultPP() = gnc_mm_Mult_pp;
3197 r->GetNC()->SPoly() = gnc_CreateSpoly;
3198 r->GetNC()->ReduceSPoly() = gnc_ReduceSpoly;
3232 int *PRE = (
int *)
omAlloc0((rN+1)*
sizeof(int));
3233 int *SUF = (
int *)
omAlloc0((rN+1)*
sizeof(int));
3243 pow = PRE[n]; PRE[n]=0;
3247 for (i=n+1; i<=rN; i++)
3289 for(
int i=1;
i<rr->N;
i++)
3290 for(
int j=
i+1;
j<=rr->N;
j++)
3294 WarnS(
"Error initializing multiplication!");
3306 if (dstRing == srcRing)
3308 return(
p_Copy(p,dstRing));
3318 int *perm = (
int *)
omAlloc0((
rVar(srcRing)+1)*
sizeof(int));
3319 int *par_perm = (
int *)
omAlloc0((
rPar(srcRing)+1)*
sizeof(
int));
3327 if ((shift<0) || (shift >
rVar(srcRing)))
3329 WerrorS(
"bad shifts in p_CopyEmbed");
3332 for (i=1; i<= srcRing->N; i++)
3336 q =
p_PermPoly(p,perm,srcRing, dstRing, nMap,par_perm,
rPar(srcRing));
3344 int diagnose =
TRUE;
3352 if (rBase->N != rCandidate->N) diagnose =
FALSE;
3371 if ( Rop == dst )
return(
p_Copy(p, dst));
3377 WarnS(
"an opposite ring should be used");
3388 int *perm=(
int *)
omAlloc0((Rop->N+1)*
sizeof(int));
3393 for(i=1; i<=Rop->N; i++)
3395 perm[
i] = Rop->N+1-
i;
3410 if ( Rop == dst )
return id_Copy(I, dst);
3415 WarnS(
"an opposite ring should be used");
3419 ideal idOp =
idInit(I->ncols, I->rank);
3420 for (i=0; i< (I->ncols)*(I->nrows); i++)
3422 idOp->m[
i] =
pOppose(Rop,I->m[i], dst);
3431 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)
poly gnc_pp_mm_Mult(const poly p, const poly m, const 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 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)
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)
static BOOLEAN rIsNCRing(const 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
poly gnc_p_mm_Mult(poly m, const poly p, const ring r)
int setNCExtensions(int iMask)
#define UPMATELEM(i, j, nVar)
#define MATELEM(mat, i, j)
1-based access to matrix
void kBucket_Add_q(kBucket_pt bucket, poly q, int *l)
Add to Bucket a poly ,i.e. Bpoly == q+Bpoly.