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)
169 const int,
const ring r)
179poly 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));
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++)
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;
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");
1840void 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!");
1917 const ring r =
b->bucket_ring;
1950 const ring r =
b->bucket_ring;
2031 const ring r =
b->bucket_ring;
2058 if (c!=
NULL) *c=ctmp;
2065 const ring r =
b->bucket_ring;
2099 if (c!=
NULL) *c=ctmp;
2147 PrintS(
"nc_PolyPolyRedNew(");
2211 if(
b ==
NULL)
return;
2297 int *M1=(
int *)
omAlloc0((rN+1)*
sizeof(
int));
2298 int *M2=(
int *)
omAlloc0((rN+1)*
sizeof(
int));
2299 int *aPREFIX=(
int *)
omAlloc0((rN+1)*
sizeof(
int));
2300 int *aSUFFIX=(
int *)
omAlloc0((rN+1)*
sizeof(
int));
2322 if (
i<
j) {nMax=
j; nMin=
i;}
else {nMax=
i; nMin=
j;}
2346 memcpy(aSUFFIX, M1,(rN+1)*
sizeof(
int));
2347 memcpy(aPREFIX, M1,(rN+1)*
sizeof(
int));
2348 for (
k=1;
k<=
j;
k++) aSUFFIX[
k]=0;
2349 for (
k=
j;
k<=rN;
k++) aPREFIX[
k]=0;
2371 memcpy(aSUFFIX, M2,(rN+1)*
sizeof(
int));
2372 memcpy(aPREFIX, M2,(rN+1)*
sizeof(
int));
2373 for (
k=1;
k<=
i;
k++) aSUFFIX[
k]=0;
2374 for (
k=
i;
k<=rN;
k++) aPREFIX[
k]=0;
2408 if (a>
b) {
j=
b;
i=a;}
2434 for(t=1;t<=
size;t++)
2453 totdeg=totdeg+
p_Deg(
p,r);
2456 number ntd =
n_Init(totdeg, r->cf);
2458 number nres=
n_Div(ntd,nln, r->cf);
2486 if( r->GetNC()->GetGlobalMultiplier() !=
NULL )
2488 delete r->GetNC()->GetGlobalMultiplier();
2489 r->GetNC()->GetGlobalMultiplier() =
NULL;
2492 if( r->GetNC()->GetFormulaPowerMultiplier() !=
NULL )
2494 delete r->GetNC()->GetFormulaPowerMultiplier();
2495 r->GetNC()->GetFormulaPowerMultiplier() =
NULL;
2505 for(
j=
i+1;
j<=rN;
j++)
2510 int mat_size=rN*(rN-1)/2;
2511 mat_size=
si_max(1,mat_size);
2514 id_Delete((ideal *)&(r->GetNC()->COM),r);
2519 if(
rIsSCA(r) && (r->GetNC()->SCAQuotient() !=
NULL) )
2521 id_Delete(&r->GetNC()->SCAQuotient(), r);
2587 int *ExpVar=(
int*)
omAlloc0((rN+1)*
sizeof(
int));
2588 int *ExpTmp=(
int*)
omAlloc0((rN+1)*
sizeof(
int));
2590 int i;
int j;
int k;
2593 for (
i=1;
i<rN;
i++)
2597 for (
j=
i+1;
j<=rN;
j++)
2610 if (ExpVar[
k]!=0) OK=0;
2651 for(
i=1;
i<r->N;
i++)
2653 for(
j=
i+1;
j<=r->N;
j++)
2664 Werror(
"Bad ordering at %d,%d\n",
i,
j);
2695 bool bSetupQuotient,
bool bCopyInput,
bool bBeQuiet,
2696 ring curr,
bool dummy_ring )
2701 if( !bSetupQuotient)
2713 PrintS(
"nc_CallPlural(), Input data, CCC: \n");
2718 PrintS(
"nc_CallPlural(), Input data, DDD: \n");
2731 if( (!bBeQuiet) && (r->GetNC() !=
NULL) )
2732 WarnS(
"going to redefine the algebra structure");
2736 matrix C;
bool bCnew =
false;
2744 bool IsSkewConstant =
false, tmpIsSkewConstant;
2758 Werror(
"Square %d x %d matrix expected", r->N, r->N);
2762 if (( CCC !=
NULL) && (CC ==
NULL)) CC = CCC;
2763 if (( CCN !=
NULL) && (CN ==
NULL)) CN = CCN;
2774 Werror(
"Square %d x %d matrix expected",r->N,r->N);
2779 if (( DDD !=
NULL) && (DD ==
NULL)) DD = DDD;
2780 if (( DDN !=
NULL) && (DN ==
NULL)) DN = DDN;
2788 WerrorS(
"Incorrect input : non-constants are not allowed as coefficients (first argument)");
2796 WerrorS(
"Incorrect input : zero coefficients are not allowed");
2805 IsSkewConstant =
true;
2807 C =
mpNew(r->N,r->N);
2810 for(
i=1;
i<r->N;
i++)
2811 for(
j=
i+1;
j<=r->N;
j++)
2819 else if ( (CN ==
NULL) && (CC !=
NULL) )
2829 if (!pN_set)
n_Delete(&pN,curr->cf);
2834 tmpIsSkewConstant =
true;
2836 for(
i=1;
i<r->N;
i++)
2837 for(
j=
i+1;
j<=r->N;
j++)
2845 Werror(
"Incorrect input : non-constants are not allowed as coefficients (first argument at [%d, %d])",
i,
j);
2855 WerrorS(
"Incorrect input : matrix of coefficients contains zeros in the upper triangle");
2859 if (!
n_Equal(pN, qN, curr->cf)) tmpIsSkewConstant =
false;
2874 IsSkewConstant = tmpIsSkewConstant;
2876 if ( tmpIsSkewConstant &&
n_IsOne(pN, curr->cf) )
2880 if (!pN_set)
n_Delete(&pN,curr->cf);
2886 D =
mpNew(r->N,r->N); bDnew =
true;
2896 for(
i=1;
i<r->N;
i++)
2897 for(
j=
i+1;
j<=r->N;
j++)
2907 for(
int i = 1; (
i < r->N) &&
b;
i++)
2908 for(
int j =
i+1; (
j <= r->N) &&
b;
j++)
2939 PrintS(
"nc_CallPlural(), Computed data, C: \n");
2942 PrintS(
"nc_CallPlural(), Computed data, D: \n");
2945 Print(
"\nTemporary: type = %d, IsSkewConstant = %d\n", nctype, IsSkewConstant);
2955 WerrorS(
"Matrix of polynomials violates the ordering condition");
2972 if (r->GetNC() !=
NULL)
2975 WarnS(
"Changing the NC-structure of an existing NC-ring!!!");
2980 r->GetNC() = nc_new;
2993 WarnS(
"Error occurred while coping/setuping the NC structure!");
3020 int mat_size=r->N*(r->N-1)/2;
3021 mat_size=
si_max(1,mat_size);
3023 r->GetNC()->MTsize = (
int *)
omAlloc0(mat_size*
sizeof(
int));
3024 id_Test((ideal)r->GetNC()->C, r);
3031 for(
i=1;
i<r->N;
i++)
3033 for(
j=
i+1;
j<=r->N;
j++)
3047 r->GetNC()->MTsize[
UPMATELEM(
i,
j,r->N)] = DefMTsize;
3076 r->GetNC()->IsSkewConstant = 0;
3080 r->GetNC()->COM=
COM;
3100 p_Procs->p_Mult_mm = rGR->p_Procs->p_Mult_mm =
gnc_p_Mult_mm;
3147 p_Procs->p_Minus_mm_Mult_qq =
NULL;
3150 r->GetNC()->mmMultP() = gnc_mm_Mult_p;
3151 r->GetNC()->mmMultPP() = gnc_mm_Mult_pp;
3153 r->GetNC()->SPoly() = gnc_CreateSpoly;
3154 r->GetNC()->ReduceSPoly() = gnc_ReduceSpoly;
3188 int *PRE = (
int *)
omAlloc0((rN+1)*
sizeof(
int));
3189 int *SUF = (
int *)
omAlloc0((rN+1)*
sizeof(
int));
3199 pow = PRE[n]; PRE[n]=0;
3203 for (
i=n+1;
i<=rN;
i++)
3245 for(
int i=1;
i<rr->N;
i++)
3246 for(
int j=
i+1;
j<=rr->N;
j++)
3250 WarnS(
"Error initializing multiplication!");
3262 if (dstRing == srcRing)
3274 int *perm = (
int *)
omAlloc0((
rVar(srcRing)+1)*
sizeof(
int));
3275 int *par_perm = (
int *)
omAlloc0((
rPar(srcRing)+1)*
sizeof(
int));
3283 if ((shift<0) || (shift >
rVar(srcRing)))
3285 WerrorS(
"bad shifts in p_CopyEmbed");
3288 for (
i=1;
i<= srcRing->N;
i++)
3292 q =
p_PermPoly(
p,perm,srcRing, dstRing, nMap,par_perm,
rPar(srcRing));
3300 int diagnose =
TRUE;
3308 if (rBase->N != rCandidate->N) diagnose =
FALSE;
3327 if ( Rop == dst )
return(
p_Copy(
p, dst));
3333 WarnS(
"an opposite ring should be used");
3344 int *perm=(
int *)
omAlloc0((Rop->N+1)*
sizeof(
int));
3349 for(
i=1;
i<=Rop->N;
i++)
3351 perm[
i] = Rop->N+1-
i;
3366 if ( Rop == dst )
return id_Copy(I, dst);
3371 WarnS(
"an opposite ring should be used");
3375 ideal idOp =
idInit(I->ncols, I->rank);
3376 for (
i=0;
i< (I->ncols)*(I->nrows);
i++)
3387 if( rGR->qideal ==
NULL )
Rational pow(const Rational &a, int e)
static int si_max(const int a, const int b)
void * cast_A_to_vptr(A a)
const CanonicalForm CFMap CFMap & N
CPolynomialSummator: unifies bucket and polynomial summation as the later is broken in buckets :(.
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of 'a' and 'b', i.e., a*b
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
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
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.
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
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 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_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...
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
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 FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/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.
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
const CanonicalForm int s
const CanonicalForm int const CFList const Variable & y
const Variable & v
< [in] a sqrfree bivariate poly
CFArray copy(const CFList &list)
write elements of list into an array
void WerrorS(const char *s)
EXTERN_VAR BBA_Proc gnc_gr_bba
EXTERN_VAR BBA_Proc gnc_gr_mora
EXTERN_VAR BBA_Proc sca_gr_bba
EXTERN_VAR BBA_Proc sca_mora
EXTERN_VAR BBA_Proc sca_bba
ideal id_Copy(ideal h1, const ring r)
copy an ideal
static BOOLEAN length(leftv result, leftv arg)
BOOLEAN kbTest(kBucket_pt bucket)
Tests.
number kBucketPolyRed(kBucket_pt bucket, poly p1, int l1, poly spNoether)
void kBucket_Add_q(kBucket_pt bucket, poly q, int *l)
Add to Bucket a poly ,i.e. Bpoly == q+Bpoly.
void kBucketPolyRedNF(kBucket_pt bucket, poly p1, int l1, poly spNoether)
const poly kBucketGetLm(kBucket_pt bucket)
static poly nc_mm_Mult_pp(const poly m, const poly p, const ring r)
static bool rIsSCA(const ring r)
static poly nc_mm_Mult_p(const poly m, poly p, const ring r)
static nc_type & ncRingType(nc_struct *p)
#define UPMATELEM(i, j, nVar)
poly nc_p_Minus_mm_Mult_qq(poly p, const poly m, const poly q, int &lp, const poly, const ring r)
for p_Minus_mm_Mult_qq in pInline2.h
void sca_p_ProcsSet(ring rGR, p_Procs_s *p_Procs)
bool sca_SetupQuotient(ring rGR, ring rG, bool bCopy)
void mp_Delete(matrix *a, const ring r)
matrix mpNew(int r, int c)
create a r x c zero-matrix
matrix mp_Copy(matrix a, const ring r)
copies matrix a (from ring r to r)
void iiWriteMatrix(matrix im, const char *n, int dim, const ring r, int spaces)
set spaces to zero by default
#define MATELEM(mat, i, j)
1-based access to matrix
int dReportError(const char *fmt,...)
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
gmp_float log(const gmp_float &a)
BOOLEAN ncInitSpecialPairMultiplication(ring r)
static void gnc_kBucketPolyRed_ZNew(kBucket_pt b, poly p, number *c, BOOLEAN reduce)
static poly gnc_uu_Mult_ww_formula(int i, int a, int j, int b, const ring r)
poly gnc_ReduceSpolyOld(const poly p1, poly p2, const ring r)
ring nc_rCreateNCcomm(ring r)
poly gnc_CreateSpolyNew(const poly p1, const poly p2, const ring r)
static poly NF_Proc_Dummy(ideal, ideal, poly, int, int, const ring)
ideal idOppose(ring Rop, ideal I, const ring dst)
opposes a module I from Rop to currRing(dst)
poly _nc_pp_Mult_qq(const poly pPolyP, const poly pPolyQ, const ring rRing)
general NC-multiplication without destruction
void nc_p_ProcsSet(ring rGR, p_Procs_s *p_Procs)
void nc_PolyPolyRedNew(poly &b, poly p, number *c, const ring r)
poly gnc_uu_Mult_ww_horvert(int i, int a, int j, int b, const ring r)
poly _nc_p_Mult_q(poly pPolyP, poly pPolyQ, const ring rRing)
general NC-multiplication with destruction
void nc_PolyPolyRed(poly &b, poly p, number *c, const ring r)
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_pp_mm_Mult(const poly p, const poly m, const ring r)
poly nc_CreateShortSpoly(poly p1, poly p2, const ring r)
poly gnc_p_Mult_mm(poly p, const poly m, const ring r)
poly gnc_uu_Mult_ww(int i, int a, int j, int b, const ring r)
bool nc_rCopy(ring res, const ring r, bool bSetupQuotient)
poly p_CopyEmbed(poly p, ring srcRing, int shift, int, ring dstRing)
poly gnc_ReduceSpolyNew(const poly p1, poly p2, const ring r)
bool ncExtensions(int iMask)
poly nc_p_CopyGet(poly a, const ring r)
bool nc_SetupQuotient(ring rGR, const ring rG, bool bCopy)
static void gnc_p_ProcsSet(ring rGR, p_Procs_s *p_Procs)
poly gnc_CreateSpolyOld(const poly p1, const poly p2, const ring r)
BOOLEAN gnc_InitMultiplication(ring r, bool bSetupQuotient=false)
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,...
poly pOppose(ring Rop, poly p, const ring dst)
opposes a vector p from Rop to currRing (dst!)
void gnc_kBucketPolyRed_ZOld(kBucket_pt b, poly p, number *c)
void nc_CleanUp(nc_struct *p)
poly _gnc_p_Mult_q(poly p, poly q, const int copy, const ring r)
void gnc_kBucketPolyRedOld(kBucket_pt b, poly p, number *c)
BOOLEAN gnc_CheckOrdCondition(matrix D, ring r)
poly nc_p_CopyPut(poly a, const ring r)
int setNCExtensions(int iMask)
BOOLEAN rIsLikeOpposite(ring rBase, ring rCandidate)
checks whether rings rBase and rCandidate could be opposite to each other returns TRUE if it is so
poly nc_p_Plus_mm_Mult_qq(poly p, const poly m, const poly q, int &lp, const int, const ring r)
BOOLEAN nc_CheckSubalgebra(poly PolyVar, ring r)
poly gnc_uu_Mult_ww_vert(int i, int a, int j, int b, const ring r)
poly gnc_p_mm_Mult(poly m, const poly p, const ring r)
poly gnc_p_Mult_mm_Common(poly p, const poly m, int side, const ring r)
void nc_PolyPolyRedOld(poly &b, poly p, number *c, const ring r)
poly nc_mm_Bracket_nn(poly m1, poly m2, const ring r)
returns [m1,m2] for two monoms, destroys nothing without coeffs
poly nc_p_Bracket_qq(poly p, const poly q, const ring r)
returns [p,q], destroys p
void nc_rKill(ring r)
complete destructor
static ideal BBA_Proc_Dummy(const ideal, const ideal, const intvec *, const bigintmat *, kStrategy, const ring)
static void gnc_kBucketPolyRedNew(kBucket_pt b, poly p, number *c, BOOLEAN)
poly gnc_mm_Mult_uu(int *F, int jG, int bG, const ring r)
poly gnc_mm_Mult_nn(int *F, int *G, const ring r)
poly gnc_pp_Mult_mm(const poly p, const poly m, const ring r, poly &last)
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
matrix nc_PrintMat(int a, int b, ring r, int metric)
returns matrix with the info on noncomm multiplication
#define omFreeSize(addr, size)
#define TEST_OPT_NOT_BUCKETS
BOOLEAN pqLength(poly p, poly q, int &lp, int &lq, const int min)
return TRUE and lp == pLength(p), lq == pLength(q), if min(pLength(p), pLength(q)) >= min FALSE if mi...
#define MIN_LENGTH_BUCKET
STATIC_VAR p_Procs_s * _p_procs
void p_Cleardenom_n(poly ph, const ring r, number &c)
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
BOOLEAN p_HasNotCF(poly p1, poly p2, const ring r)
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
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 p_Power(poly p, int i, const ring r)
poly p_Cleardenom(poly p, const ring r)
poly p_LcmRat(const poly a, const poly b, const long lCompM, const ring r)
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
long p_Deg(poly a, const ring r)
void p_Lcm(const poly a, const poly b, poly m, const ring r)
static poly p_Neg(poly p, const ring r)
static int pLength(poly a)
static poly p_Add_q(poly p, poly q, const ring r)
static void p_LmDelete(poly p, const ring r)
static long p_AddExp(poly p, int v, long ee, ring r)
void p_Write(poly p, ring lmRing, ring tailRing)
static void p_SetExpV(poly p, int *ev, const ring r)
static poly pp_Mult_mm(poly p, poly m, const ring r)
static void p_SetCompP(poly p, int i, 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 @Note: VarOffset encodes the position in p->exp
static void p_ExpVectorDiff(poly pr, poly p1, poly p2, const ring r)
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
static void p_Setm(poly p, const ring r)
static number p_SetCoeff(poly p, number n, ring r)
static poly p_Head(const poly p, const ring r)
copy the (leading) term of p
static int p_LmCmp(poly p, poly q, const ring r)
static BOOLEAN p_LmIsConstant(const poly p, const ring r)
static BOOLEAN p_IsConstant(const poly p, const ring r)
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
static BOOLEAN p_DivisibleBy(poly a, poly b, const ring r)
static void p_Delete(poly *p, const ring r)
static void p_GetExpV(poly p, int *ev, const ring r)
void p_Write0(poly p, ring lmRing, ring tailRing)
static poly p_Mult_mm(poly p, poly m, const ring r)
static void p_LmFree(poly p, ring)
static poly p_LmDeleteAndNext(poly p, const ring r)
static poly p_Copy(poly p, const ring r)
returns a copy of p
#define __p_Mult_nn(p, n, r)
poly prCopyR_NoSort(poly p, ring src_r, ring dest_r)
void PrintS(const char *s)
void Werror(const char *fmt,...)
void p_DebugPrint(poly p, const ring r)
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 BOOLEAN rHasLocalOrMixedOrdering(const ring r)
struct p_Procs_s p_Procs_s
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
ideal(* BBA_Proc)(const ideal, const ideal, const intvec *, const bigintmat *, kStrategy strat, const ring)
static BOOLEAN rIsRatGRing(const ring r)
static int rPar(const ring r)
(r->cf->P)
poly(* NF_Proc)(ideal, ideal, poly, int, int, const ring _currRing)
static BOOLEAN rIsNCRing(const ring r)
static short rVar(const ring r)
#define rVar(r) (r->N)
ideal idInit(int idsize, int rank)
initialise an ideal / module
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix