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++ )
226 poly current =
pCopy( m[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 )
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 );
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] );
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 ) {
462 for ( b= 0; (b < basisSize) && (found ==
FALSE); b++ )
464 if ( found ==
FALSE ) {
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 );
491 while ( mon !=
NULL ) {
494 while ( found ==
FALSE ) {
510 for ( k= 0; (k < numMonoms) && (isZero ==
FALSE); k++ ) {
512 if ( ( isZero= gauss.
reduce( v[k] )) ==
TRUE )
519 if ( isZero ==
TRUE ) {
524 for ( k= 1; k <= p.
size(); k++ ) {
526 poly temp =
pCopy( m[k-1] );
528 comb=
pAdd( comb, temp );
535 for ( k= 0; k < numMonoms; k++ ) {
542 for ( k= numMonoms - 1; k >= 0; k-- ) v[k].~
fglmVector();
544 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)
#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 > ...
void setelem(int i, number &n)
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)