 |
My Project
debian-1:4.1.2-p1+ds-2
|
Go to the documentation of this file.
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)
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));
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");
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
1917 const ring r =
b->bucket_ring;
1950 const ring r =
b->bucket_ring;
2030 const ring r =
b->bucket_ring;
2057 if (c!=
NULL) *c=ctmp;
2063 const ring r =
b->bucket_ring;
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;}
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;}
2426 for(t=1;t<=
size;t++)
2445 totdeg=totdeg+
p_Deg(
p,r);
2448 number ntd =
n_Init(totdeg, 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++)
3091 r->GetNC()->MTsize[
UPMATELEM(
i,
j,r->N)] = 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)
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++)
3431 if( rGR->qideal ==
NULL )
poly nc_mm_Bracket_nn(poly m1, poly m2, const ring r)
returns [m1,m2] for two monoms, destroys nothing without coeffs
int dReportError(const char *fmt,...)
poly gnc_uu_Mult_ww_horvert(int i, int a, int j, int b, const ring r)
poly gnc_ReduceSpolyNew(const poly p1, poly p2, const ring r)
poly gnc_CreateSpolyOld(const poly p1, const poly p2, const ring r)
BOOLEAN ncInitSpecialPairMultiplication(ring r)
static poly p_LmDeleteAndNext(poly p, const ring r)
poly pOppose(ring Rop, poly p, const ring dst)
opposes a vector p from Rop to currRing (dst!)
poly p_LcmRat(const poly a, const poly b, const long lCompM, const ring r)
poly _nc_p_Mult_q(poly pPolyP, poly pPolyQ, const ring rRing)
general NC-multiplication with destruction
poly gnc_p_Mult_mm_Common(poly p, const poly m, int side, const ring r)
void * cast_A_to_vptr(A a)
poly gnc_pp_mm_Mult(const poly p, const poly m, const ring r)
void p_Write0(poly p, ring lmRing, ring tailRing)
static void p_ExpVectorDiff(poly pr, poly p1, poly p2, const ring r)
#define MATELEM(mat, i, j)
1-based access to matrix
const CanonicalForm int const CFList const Variable & y
bool ncExtensions(int iMask)
poly gnc_p_mm_Mult(poly m, const poly p, 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
void p_DebugPrint(poly p, const ring r)
poly gnc_p_Mult_mm(poly p, const poly m, const ring r)
poly nc_p_CopyPut(poly a, const ring r)
static poly p_Head(poly p, const ring r)
copy the i(leading) term of p
static poly p_Mult_mm(poly p, poly m, const ring r)
#define MIN_LENGTH_BUCKET
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
static nc_type & ncRingType(nc_struct *p)
number kBucketPolyRed(kBucket_pt bucket, poly p1, int l1, poly spNoether)
void gnc_kBucketPolyRedNew(kBucket_pt b, poly p, number *c)
static poly p_Neg(poly p, const ring r)
static void p_SetCompP(poly p, int i, ring r)
void gnc_kBucketPolyRed_ZNew(kBucket_pt b, poly p, number *c)
BOOLEAN nc_CheckSubalgebra(poly PolyVar, ring r)
static BOOLEAN length(leftv result, leftv arg)
BOOLEAN pqLength(poly p, poly q, int &lp, int &lq, const int min)
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
static poly pp_Mult_mm(poly p, poly m, const ring r)
const poly kBucketGetLm(kBucket_pt bucket)
poly gnc_uu_Mult_ww_vert(int i, int a, int j, int b, const ring r)
const CanonicalForm CFMap CFMap & N
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
BOOLEAN p_HasNotCF(poly p1, poly p2, const ring r)
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
poly nc_p_Bracket_qq(poly p, const poly q, const ring r)
returns [p,q], destroys p
#define __p_Mult_nn(p, n, r)
void p_Lcm(const poly a, const poly b, poly m, 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 iiWriteMatrix(matrix im, const char *n, int dim, const ring r, int spaces)
set spaces to zero by default
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const 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
void nc_rKill(ring r)
complete destructor
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
static unsigned pLength(poly a)
static void p_SetExpV(poly p, int *ev, const ring r)
static poly NF_Proc_Dummy(ideal, ideal, poly, int, int, const ring)
BOOLEAN gnc_InitMultiplication(ring r, bool bSetupQuotient=false)
static poly p_Copy(poly p, const ring r)
returns a copy of p
poly p_Power(poly p, int i, const ring r)
poly _nc_pp_Mult_qq(const poly pPolyP, const poly pPolyQ, const ring rRing)
general NC-multiplication without destruction
void nc_PolyPolyRedOld(poly &b, poly p, number *c, const ring r)
static short rVar(const ring r)
#define rVar(r) (r->N)
poly gnc_mm_Mult_uu(int *F, int jG, int bG, const ring r)
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
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)
void kBucket_Add_q(kBucket_pt bucket, poly q, int *l)
Add to Bucket a poly ,i.e. Bpoly == q+Bpoly.
bool nc_rCopy(ring res, const ring r, bool bSetupQuotient)
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
#define TEST_OPT_NOT_BUCKETS
void PrintS(const char *s)
#define omFreeSize(addr, size)
ideal(* BBA_Proc)(const ideal, const ideal, const intvec *, const intvec *, kStrategy strat, const ring)
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
BOOLEAN kbTest(kBucket_pt bucket)
Tests.
void sca_p_ProcsSet(ring rGR, p_Procs_s *p_Procs)
static BOOLEAN rIsRatGRing(const ring r)
poly _gnc_p_Mult_q(poly p, poly q, const int copy, const ring r)
static void p_LmDelete(poly p, const ring r)
STATIC_VAR p_Procs_s * _p_procs
void p_Write(poly p, ring lmRing, ring tailRing)
poly p_Cleardenom(poly p, const ring r)
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 int rPar(const ring r)
(r->cf->P)
poly p_CopyEmbed(poly p, ring srcRing, int shift, int, ring dstRing)
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
static BOOLEAN p_DivisibleBy(poly a, poly b, const ring r)
poly gnc_pp_Mult_mm(const poly p, const poly m, const ring r, poly &last)
struct p_Procs_s p_Procs_s
static void p_GetExpV(poly p, int *ev, const ring r)
poly gnc_uu_Mult_ww(int i, int a, int j, int b, const ring r)
static int p_LmCmp(poly p, poly q, const ring r)
void mp_Delete(matrix *a, const ring r)
static poly nc_mm_Mult_p(const poly m, poly p, const ring r)
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)
matrix mpNew(int r, int c)
create a r x c zero-matrix
static FORCE_INLINE number n_Sub(number a, number b, const coeffs r)
return the difference of 'a' and 'b', i.e., a-b
#define UPMATELEM(i, j, nVar)
static void p_LmFree(poly p, ring)
bool nc_SetupQuotient(ring rGR, const ring rG, bool bCopy)
long p_Deg(poly a, const ring r)
static BOOLEAN rIsNCRing(const ring r)
static void p_Delete(poly *p, const ring r)
static poly p_Add_q(poly p, poly q, 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)
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
void gnc_kBucketPolyRed_ZOld(kBucket_pt b, poly p, number *c)
static ideal BBA_Proc_Dummy(const ideal, const ideal, const intvec *, const intvec *, kStrategy, const ring)
static int si_max(const int a, const int b)
gmp_float log(const gmp_float &a)
BOOLEAN rIsLikeOpposite(ring rBase, ring rCandidate)
checks whether rings rBase and rCandidate could be opposite to each other returns TRUE if it is so
static void gnc_p_ProcsSet(ring rGR, p_Procs_s *p_Procs)
BOOLEAN gnc_CheckOrdCondition(matrix D, ring r)
matrix nc_PrintMat(int a, int b, ring r, int metric)
returns matrix with the info on noncomm multiplication
poly nc_p_CopyGet(poly a, const ring r)
int setNCExtensions(int iMask)
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
void Werror(const char *fmt,...)
ideal idInit(int idsize, int rank)
initialise an ideal / module
void nc_p_ProcsSet(ring rGR, p_Procs_s *p_Procs)
static number p_SetCoeff(poly p, number n, ring r)
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.
ring nc_rCreateNCcomm(ring r)
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
Rational pow(const Rational &a, int e)
poly(* NF_Proc)(ideal, ideal, poly, int, int, const ring _currRing)
void WerrorS(const char *s)
static long p_AddExp(poly p, int v, long ee, ring r)
static poly nc_mm_Mult_pp(const poly m, const poly p, const ring r)
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
ideal idOppose(ring Rop, ideal I, const ring dst)
opposes a module I from Rop to currRing(dst)
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
static FORCE_INLINE void n_Power(number a, int b, number *res, const coeffs r)
fill res with the power a^b
static void p_Setm(poly p, const ring r)
void nc_PolyPolyRedNew(poly &b, poly p, number *c, const ring r)
const Variable & v
< [in] a sqrfree bivariate poly
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 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 BOOLEAN p_IsConstantPoly(const poly p, const ring r)
static BOOLEAN p_IsConstant(const poly p, const ring r)
const CanonicalForm int s
poly gnc_CreateSpolyNew(const poly p1, const poly p2, const ring r)
void nc_PolyPolyRed(poly &b, poly p, number *c, const ring r)
poly gnc_mm_Mult_nn(int *F, int *G, const ring r)
void gnc_kBucketPolyRedOld(kBucket_pt b, poly p, number *c)
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 nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
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 p_ISet(long i, const ring r)
returns the poly representing the integer i
ideal id_Copy(ideal h1, const ring r)
copy an ideal
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
CFArray copy(const CFList &list)
write elements of list into an array
poly prCopyR_NoSort(poly p, ring src_r, ring dest_r)
matrix mp_Copy(matrix a, const ring r)
copies matrix a (from ring r to r)
static bool rIsSCA(const ring r)
static poly gnc_uu_Mult_ww_formula(int i, int a, int j, int b, const ring r)
bool sca_SetupQuotient(ring rGR, ring rG, bool bCopy)
CPolynomialSummator: unifies bucket and polynomial summation as the later is brocken in buckets :(.
poly nc_CreateShortSpoly(poly p1, poly p2, const ring r)
void nc_CleanUp(nc_struct *p)
static BOOLEAN p_LmIsConstant(const poly p, const ring r)
poly gnc_ReduceSpolyOld(const poly p1, poly p2, const ring r)
void p_Cleardenom_n(poly ph, const ring r, number &c)