 |
My Project
debian-1:4.1.1-p2+ds-4build2
|
Go to the source code of this file.
|
static void | fglmEliminateMonomials (poly *pptr, fglmVector &v, polyset monomials, int numMonoms) |
|
static BOOLEAN | fglmReductionStep (poly *pptr, ideal source, int *w) |
|
static void | fglmReduce (poly *pptr, fglmVector &v, polyset m, int numMonoms, ideal source, int *w) |
|
poly | fglmNewLinearCombination (ideal source, poly monset) |
|
poly | fglmLinearCombination (ideal source, poly monset) |
|
◆ fglmEliminateMonomials()
static void fglmEliminateMonomials |
( |
poly * |
pptr, |
|
|
fglmVector & |
v, |
|
|
polyset |
monomials, |
|
|
int |
numMonoms |
|
) |
| |
|
static |
Definition at line 37 of file fglmcomb.cc.
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 );
◆ fglmLinearCombination()
poly fglmLinearCombination |
( |
ideal |
source, |
|
|
poly |
monset |
|
) |
| |
Definition at line 416 of file fglmcomb.cc.
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 );
513 p= gauss.getDependence();
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++ )
◆ fglmNewLinearCombination()
poly fglmNewLinearCombination |
( |
ideal |
source, |
|
|
poly |
monset |
|
) |
| |
Definition at line 154 of file fglmcomb.cc.
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] ) {
333 if ( (
isZero= gauss.reduce(
v[best-1] )) ==
TRUE ) {
334 p= gauss.getDependence();
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++ ) {
370 if ( ! temp.elemIsZero(
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++ )
◆ fglmReduce()
static void fglmReduce |
( |
poly * |
pptr, |
|
|
fglmVector & |
v, |
|
|
polyset |
m, |
|
|
int |
numMonoms, |
|
|
ideal |
source, |
|
|
int * |
w |
|
) |
| |
|
static |
Definition at line 129 of file fglmcomb.cc.
133 while ( reduced ==
TRUE ) {
139 if ( temp !=
NULL ) {
143 while ( reduced ==
TRUE ) {
◆ fglmReductionStep()
static BOOLEAN fglmReductionStep |
( |
poly * |
pptr, |
|
|
ideal |
source, |
|
|
int * |
w |
|
) |
| |
|
static |
Definition at line 76 of file fglmcomb.cc.
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) );
#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
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced
#define pGetExp(p, i)
Exponent.
fglmVector(fglmVectorRep *rep)
#define __p_Mult_nn(p, n, r)
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
static unsigned pLength(poly a)
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
#define omFreeSize(addr, size)
poly p_Cleardenom(poly p, const ring r)
static BOOLEAN fglmReductionStep(poly *pptr, ideal source, int *w)
static void fglmReduce(poly *pptr, fglmVector &v, polyset m, int numMonoms, ideal source, int *w)
poly kNF(ideal F, ideal Q, poly p, int syzComp, int lazyReduce)
#define pLmInit(p)
like pInit, except that expvector is initialized to that of p, p must be != NULL
static void fglmEliminateMonomials(poly *pptr, fglmVector &v, polyset monomials, int numMonoms)
#define pSetCoeff(p, n)
deletes old coeff before setting the new one
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
#define STICKYPROT2(msg, arg)
const Variable & v
< [in] a sqrfree bivariate poly
#define pCopy(p)
return a copy of the poly
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
#define pCmp(p1, p2)
pCmp: args may be NULL returns: (p2==NULL ? 1 : (p1 == NULL ? -1 : p_LmCmp(p1, p2)))
#define omReallocSize(addr, o_size, size)