15 #include "factory/factory.h" 32 # include <iostream.h> 44 while ( (temp !=
NULL) && (point < numMonoms) ) {
45 state=
pCmp( temp, monomials[point] );
49 if ( pretemp ==
NULL ) {
60 number newelem =
nAdd(
pGetCoeff( todelete ),
v.getconstelem( point+1 ) );
61 v.setelem( point+1, newelem );
82 for (
k=
IDELEMS( source ) - 1;
k >= 0;
k-- ) {
88 if (
w[
k] <
w[best-1] ) {
97 poly p2 = (source->m)[best-1];
115 number temp =
nDiv( n1, n2 );
123 *pptr=
pAdd( *pptr, p2 );
125 return ( (best > 0) );
133 while ( reduced ==
TRUE ) {
139 if ( temp !=
NULL ) {
143 while ( reduced ==
TRUE ) {
164 int basisMax = basisBS;
166 int * weights =
NULL;
167 int * lengthes =
NULL;
180 for (
k= 0;
k < numMonoms;
k++ ) {
191 #ifndef HAVE_EXPLICIT_CONSTR 197 #ifndef HAVE_EXPLICIT_CONSTR 209 poly temp= (source->m)[
k];
211 while ( temp !=
NULL ) {
219 lengthes= (
int *)
omAlloc( numMonoms *
sizeof(
int ) );
220 order= (
int *)
omAlloc( numMonoms *
sizeof(
int ) );
223 for (
k= 0;
k < numMonoms;
k++ )
229 fglmReduce( & current, currV,
m, numMonoms, source, weights );
232 while ( temp !=
NULL )
244 if ( basisSize == basisMax )
247 basis= (
polyset)
omReallocSize( basis, basisMax *
sizeof( poly ), (basisMax + basisBS ) *
sizeof( poly ) );
253 basis[basisSize]=
pLmInit(temp);
260 #ifndef HAVE_EXPLICIT_CONSTR 261 mv[
k].mac_constr( currV );
268 for (
k= 0;
k < numMonoms;
k++ ) {
271 #ifndef HAVE_EXPLICIT_CONSTR 272 v[
k].mac_constr_i( basisSize );
274 v[
k].fglmVector( basisSize );
277 while ( mon !=
NULL ) {
289 v[
k].setelem(
b+1, coeff );
300 for (
k= 0;
k < basisSize;
k++ )
309 for (
k= 0;
k < numMonoms;
k++ ) {
310 lengthes[
k]=
v[
k].numNonZeroElems();
318 for (
k= numMonoms - 1;
k >= 0;
k-- ) {
319 if ( lengthes[
k] > 0 ) {
324 if ( lengthes[
k] < lengthes[best-1] ) {
341 #ifndef HAVE_EXPLICIT_CONSTR 342 v[best-1].clearelems();
344 v[best-1].~fglmVector();
349 number
gcd =
p.gcd();
355 for (
k= 0;
k <
p.size();
k++ ) {
356 if ( !
p.elemIsZero(
k+1 ) ) {
357 temp+=
p.getconstelem(
k+1 ) * mv[order[
k]];
369 for (
k= 1;
k <= numMonoms;
k++ ) {
389 #ifndef HAVE_EXPLICIT_CONSTR 395 for (
k= 0;
k < basisSize;
k++ )
399 #ifndef HAVE_EXPLICIT_CONSTR 402 for (
k= 0;
k < numMonoms;
k++ )
407 for (
k= 0;
k < numMonoms;
k++ )
432 while ( temp !=
NULL ) {
446 for (
k= 0;
k < numMonoms;
k++ ) {
447 poly mon=
pHead( temp );
459 while ( sm !=
NULL ) {
466 if ( basisSize == basisMax ) {
467 basis= (
polyset)
omReallocSize( basis, basisMax *
sizeof( poly ), (basisMax + basisBS ) *
sizeof( poly ) );
470 basis[basisSize]=
pHead( sm );
483 for (
k= 0;
k < numMonoms;
k++ ) {
484 #ifndef HAVE_EXPLICIT_CONSTR 485 v[
k].mac_constr_i( basisSize );
487 v[
k].fglmVector( basisSize );
491 while ( mon !=
NULL ) {
501 v[
k].setelem(
b+1, coeff );
520 number
gcd =
p.gcd();
524 for (
k= 1;
k <=
p.size();
k++ ) {
525 if ( !
p.elemIsZero(
k ) ) {
528 comb=
pAdd( comb, temp );
535 for (
k= 0;
k < numMonoms;
k++ ) {
544 for (
k= 0;
k < basisSize;
k++ )
fglmVector(fglmVectorRep *rep)
poly kNF(ideal F, ideal Q, poly p, int syzComp, int lazyReduce)
Compatiblity layer for legacy polynomial operations (over currRing)
number getconstelem(int i) const
poly fglmLinearCombination(ideal source, poly monset)
#define omFreeSize(addr, size)
static void fglmReduce(poly *pptr, fglmVector &v, polyset m, int numMonoms, ideal source, int *w)
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
#define pCmp(p1, p2)
pCmp: args may be NULL returns: (p2==NULL ? 1 : (p1 == NULL ? -1 : p_LmCmp(p1, p2)))
poly fglmNewLinearCombination(ideal source, poly monset)
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
fglmVector getDependence()
#define omReallocSize(addr, o_size, size)
#define pGetExp(p, i)
Exponent.
#define pLmInit(p)
like pInit, except that expvector is initialized to that of p, p must be != NULL
static BOOLEAN fglmReductionStep(poly *pptr, ideal source, int *w)
BOOLEAN reduce(fglmVector v)
static unsigned pLength(poly a)
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
static void fglmEliminateMonomials(poly *pptr, fglmVector &v, polyset monomials, int numMonoms)
const Variable & v
< [in] a sqrfree bivariate poly
#define __p_Mult_nn(p, n, r)
#define pDivisibleBy(a, b)
returns TRUE, if leading monom of a divides leading monom of b i.e., if there exists a expvector c > ...
bool isZero(const CFArray &A)
checks if entries of A are zero
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced
poly p_Cleardenom(poly p, const ring r)
#define pSetCoeff(p, n)
deletes old coeff before setting the new one
#define pCopy(p)
return a copy of the poly
#define STICKYPROT2(msg, arg)