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 ) {
82 for ( k=
IDELEMS( source ) - 1; k >= 0; k-- ) {
88 if ( w[k] < w[best-1] ) {
97 poly p2 = (source->m)[best-1];
101 for ( i= (
currRing->N); i > 0; i-- )
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 208 for ( k= 0; k <
IDELEMS( source ); k++ ) {
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 )
235 for ( b= 0; (b < basisSize) && (found ==
FALSE); b++ )
242 if ( found ==
FALSE )
244 if ( basisSize == basisMax )
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 );
277 while ( mon !=
NULL ) {
280 while ( found ==
FALSE ) {
300 for ( k= 0; k < basisSize; k++ )
309 for ( k= 0; k < numMonoms; k++ ) {
316 while ( (isZero ==
FALSE) && (act < numMonoms) ) {
318 for ( k= numMonoms - 1; k >= 0; k-- ) {
319 if ( lengthes[k] > 0 ) {
324 if ( lengthes[k] < lengthes[best-1] ) {
333 if ( ( isZero= gauss.
reduce( v[best-1] )) ==
TRUE ) {
341 #ifndef HAVE_EXPLICIT_CONSTR 342 v[best-1].clearelems();
348 if ( isZero ==
TRUE ) {
355 for ( k= 0; k < p.
size(); k++ ) {
369 for ( k= 1; k <= numMonoms; k++ ) {
371 if ( result ==
NULL ) {
372 result=
pCopy( m[k-1] );
376 sum->next=
pCopy( m[k-1] );
390 #ifndef HAVE_EXPLICIT_CONSTR 396 for ( k= 0; k < basisSize; k++ )
400 #ifndef HAVE_EXPLICIT_CONSTR 403 for ( k= 0; k < numMonoms; k++ )
408 for ( k= 0; k < numMonoms; k++ )
433 while ( temp !=
NULL ) {
447 for ( k= 0; k < numMonoms; k++ ) {
460 while ( sm !=
NULL ) {
463 for ( b= 0; (b < basisSize) && (found ==
FALSE); b++ )
465 if ( found ==
FALSE ) {
467 if ( basisSize == basisMax ) {
471 basis[basisSize]=
pHead( sm );
484 for ( k= 0; k < numMonoms; k++ ) {
485 #ifndef HAVE_EXPLICIT_CONSTR 486 v[
k].mac_constr_i( basisSize );
492 while ( mon !=
NULL ) {
495 while ( found ==
FALSE ) {
511 for ( k= 0; (k < numMonoms) && (isZero ==
FALSE); k++ ) {
513 if ( ( isZero= gauss.
reduce( v[k] )) ==
TRUE )
520 if ( isZero ==
TRUE ) {
525 for ( k= 1; k <= p.
size(); k++ ) {
529 comb=
pAdd( comb, temp );
536 for ( k= 0; k < numMonoms; k++ ) {
543 for ( k= numMonoms - 1; k >= 0; k-- ) v[k].~
fglmVector();
545 for ( k= 0; k < basisSize; k++ )
int numNonZeroElems() const
fglmVector(fglmVectorRep *rep)
Implementation of class fglmVector
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)
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
#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 ...
void p_Content(poly ph, const ring r)
static void fglmEliminateMonomials(poly *pptr, fglmVector &v, polyset monomials, int numMonoms)
const Variable & v
< [in] a sqrfree bivariate poly
#define pDivisibleBy(a, b)
returns TRUE, if leading monom of a divides leading monom of b i.e., if there exists a expvector c > ...
void setelem(int i, number &n)
bool isZero(const CFArray &A)
checks if entries of A are zero
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced ...
#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)