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++)
2512 id_Delete((ideal *)&(r->GetNC()->COM),r);
2517 if(
rIsSCA(r) && (r->GetNC()->SCAQuotient() !=
NULL) )
2519 id_Delete(&r->GetNC()->SCAQuotient(), r);
2585 int *ExpVar=(
int*)
omAlloc0((rN+1)*
sizeof(int));
2586 int *ExpTmp=(
int*)
omAlloc0((rN+1)*
sizeof(int));
2588 int i;
int j;
int k;
2591 for (
i=1;
i<rN;
i++)
2595 for (
j=
i+1;
j<=rN;
j++)
2608 if (ExpVar[
k]!=0) OK=0;
2649 for(
i=1;
i<r->N;
i++)
2651 for(
j=
i+1;
j<=r->N;
j++)
2662 Werror(
"Bad ordering at %d,%d\n",
i,
j);
2693 bool bSetupQuotient,
bool bCopyInput,
bool bBeQuiet,
2694 ring curr,
bool dummy_ring )
2699 if( !bSetupQuotient)
2718 WarnS(
"commutative ring with 1 variable");
2730 PrintS(
"nc_CallPlural(), Input data, CCC: \n");
2735 PrintS(
"nc_CallPlural(), Input data, DDD: \n");
2748 if( (!bBeQuiet) && (r->GetNC() !=
NULL) )
2749 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);
2784 if (( CCC !=
NULL) && (CC ==
NULL)) CC = CCC;
2785 if (( CCN !=
NULL) && (CN ==
NULL)) CN = CCN;
2796 Werror(
"Square %d x %d matrix expected",r->N,r->N);
2801 if (( DDD !=
NULL) && (DD ==
NULL)) DD = DDD;
2802 if (( DDN !=
NULL) && (DN ==
NULL)) DN = DDN;
2810 WerrorS(
"Incorrect input : non-constants are not allowed as coefficients (first argument)");
2818 WerrorS(
"Incorrect input : zero coefficients are not allowed");
2827 IsSkewConstant =
true;
2829 C =
mpNew(r->N,r->N);
2832 for(
i=1;
i<r->N;
i++)
2833 for(
j=
i+1;
j<=r->N;
j++)
2841 else if ( (CN ==
NULL) && (CC !=
NULL) )
2851 if (!pN_set)
n_Delete(&pN,curr->cf);
2856 tmpIsSkewConstant =
true;
2858 for(
i=1;
i<r->N;
i++)
2859 for(
j=
i+1;
j<=r->N;
j++)
2867 Werror(
"Incorrect input : non-constants are not allowed as coefficients (first argument at [%d, %d])",
i,
j);
2877 WerrorS(
"Incorrect input : matrix of coefficients contains zeros in the upper triangle");
2881 if (!
n_Equal(pN, qN, curr->cf)) tmpIsSkewConstant =
false;
2896 IsSkewConstant = tmpIsSkewConstant;
2898 if ( tmpIsSkewConstant &&
n_IsOne(pN, curr->cf) )
2902 if (!pN_set)
n_Delete(&pN,curr->cf);
2908 D =
mpNew(r->N,r->N); bDnew =
true;
2918 for(
i=1;
i<r->N;
i++)
2919 for(
j=
i+1;
j<=r->N;
j++)
2929 for(
int i = 1; (
i < r->N) &&
b;
i++)
2930 for(
int j =
i+1; (
j <= r->N) &&
b;
j++)
2961 PrintS(
"nc_CallPlural(), Computed data, C: \n");
2964 PrintS(
"nc_CallPlural(), Computed data, D: \n");
2967 Print(
"\nTemporary: type = %d, IsSkewConstant = %d\n", nctype, IsSkewConstant);
2977 WerrorS(
"Matrix of polynomials violates the ordering condition");
2994 if (r->GetNC() !=
NULL)
2997 WarnS(
"Changing the NC-structure of an existing NC-ring!!!");
3002 r->GetNC() = nc_new;
3015 WarnS(
"Error occurred while coping/setuping the NC structure!");
3032 r->GetNC()->IsSkewConstant=1;
3049 r->GetNC()->MTsize = (
int *)
omAlloc0((r->N*(r->N-1))/2*
sizeof(
int));
3050 id_Test((ideal)r->GetNC()->C, r);
3057 for(
i=1;
i<r->N;
i++)
3059 for(
j=
i+1;
j<=r->N;
j++)
3073 r->GetNC()->MTsize[
UPMATELEM(
i,
j,r->N)] = DefMTsize;
3102 r->GetNC()->IsSkewConstant = 0;
3106 r->GetNC()->COM=
COM;
3126 p_Procs->p_Mult_mm = rGR->p_Procs->p_Mult_mm =
gnc_p_Mult_mm;
3173 p_Procs->p_Minus_mm_Mult_qq =
NULL;
3176 r->GetNC()->mmMultP() = gnc_mm_Mult_p;
3177 r->GetNC()->mmMultPP() = gnc_mm_Mult_pp;
3179 r->GetNC()->SPoly() = gnc_CreateSpoly;
3180 r->GetNC()->ReduceSPoly() = gnc_ReduceSpoly;
3214 int *PRE = (
int *)
omAlloc0((rN+1)*
sizeof(int));
3215 int *SUF = (
int *)
omAlloc0((rN+1)*
sizeof(int));
3225 pow = PRE[n]; PRE[n]=0;
3229 for (
i=n+1;
i<=rN;
i++)
3271 for(
int i=1;
i<rr->N;
i++)
3272 for(
int j=
i+1;
j<=rr->N;
j++)
3276 WarnS(
"Error initializing multiplication!");
3288 if (dstRing == srcRing)
3300 int *perm = (
int *)
omAlloc0((
rVar(srcRing)+1)*
sizeof(int));
3301 int *par_perm = (
int *)
omAlloc0((
rPar(srcRing)+1)*
sizeof(
int));
3309 if ((shift<0) || (shift >
rVar(srcRing)))
3311 WerrorS(
"bad shifts in p_CopyEmbed");
3314 for (
i=1;
i<= srcRing->N;
i++)
3318 q =
p_PermPoly(
p,perm,srcRing, dstRing, nMap,par_perm,
rPar(srcRing));
3326 int diagnose =
TRUE;
3334 if (rBase->N != rCandidate->N) diagnose =
FALSE;
3353 if ( Rop == dst )
return(
p_Copy(
p, dst));
3359 WarnS(
"an opposite ring should be used");
3370 int *perm=(
int *)
omAlloc0((Rop->N+1)*
sizeof(int));
3375 for(
i=1;
i<=Rop->N;
i++)
3377 perm[
i] = Rop->N+1-
i;
3392 if ( Rop == dst )
return id_Copy(I, dst);
3397 WarnS(
"an opposite ring should be used");
3401 ideal idOp =
idInit(I->ncols, I->rank);
3402 for (
i=0;
i< (I->ncols)*(I->nrows);
i++)
3413 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 brocken 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)
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)
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
static void gnc_kBucketPolyRedNew(kBucket_pt b, poly p, number *c, BOOLEAN reduce)
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)
static ideal BBA_Proc_Dummy(const ideal, const ideal, const intvec *, const intvec *, kStrategy, const ring)
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
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...
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 intvec *, 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)
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
ideal idInit(int idsize, int rank)
initialise an ideal / module
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix