My Project
Loading...
Searching...
No Matches
fglmSdata Class Reference

Public Member Functions

 fglmSdata (const ideal thisIdeal)
 
 ~fglmSdata ()
 
BOOLEAN state () const
 
int getBasisSize () const
 
int newBasisElem (poly &p)
 
void newBorderElem (poly &m, fglmVector v)
 
BOOLEAN candidatesLeft () const
 
fglmSelem nextCandidate ()
 
void updateCandidates ()
 
int getEdgeNumber (const poly m) const
 
poly getSpanPoly (int number) const
 
fglmVector getVectorRep (const poly m)
 
fglmVector getBorderDiv (const poly m, int &var) const
 

Private Attributes

ideal theIdeal
 
int idelems
 
int * varpermutation
 
int basisBS
 
int basisMax
 
int basisSize
 
polyset basis
 
int borderBS
 
int borderMax
 
int borderSize
 
borderElemborder
 
List< fglmSelemnlist
 
BOOLEAN _state
 

Detailed Description

Definition at line 336 of file fglmzero.cc.

Constructor & Destructor Documentation

◆ fglmSdata()

fglmSdata::fglmSdata ( const ideal thisIdeal)

Definition at line 372 of file fglmzero.cc.

373{
374 // An dieser Stelle kann die BlockSize ( =BS ) noch sinnvoller berechnet
375 // werden, jenachdem wie das Ideal aussieht.
376 theIdeal= thisIdeal;
378 varpermutation = (int*)omAlloc( ((currRing->N)+1)*sizeof(int) );
379 // Sort ring variables by increasing values (because of weighted orderings)
380 ideal perm = idMaxIdeal(1);
381 intvec *iv = idSort(perm,TRUE);
382 idDelete(&perm);
383 for(int i = (currRing->N); i > 0; i--) varpermutation[(currRing->N)+1-i] = (*iv)[i-1];
384 delete iv;
385
386 basisBS= 100;
388 basisSize= 0;
389 basis= (polyset)omAlloc( basisMax*sizeof( poly ) );
390
391 borderBS= 100;
393 borderSize= 0;
394#ifndef HAVE_EXPLICIT_CONSTR
395 border= new borderElem[ borderMax ];
396#else
397 border= (borderElem *)omAlloc( borderMax*sizeof( borderElem ) );
398#endif
399 // rem: the constructors are called in newBorderElem().
400 _state= TRUE;
401}
#define TRUE
Definition auxiliary.h:101
int i
Definition cfEzgcd.cc:132
polyset basis
Definition fglmzero.cc:346
int basisMax
Definition fglmzero.cc:344
int basisBS
Definition fglmzero.cc:343
int idelems
Definition fglmzero.cc:340
ideal theIdeal
Definition fglmzero.cc:339
int basisSize
Definition fglmzero.cc:345
int borderMax
Definition fglmzero.cc:349
int * varpermutation
Definition fglmzero.cc:341
BOOLEAN _state
Definition fglmzero.cc:354
borderElem * border
Definition fglmzero.cc:351
int borderSize
Definition fglmzero.cc:350
int borderBS
Definition fglmzero.cc:348
#define idDelete(H)
delete an ideal
Definition ideals.h:29
#define idMaxIdeal(D)
initialise the maximal ideal (at 0)
Definition ideals.h:33
static intvec * idSort(ideal id, BOOLEAN nolex=TRUE)
Definition ideals.h:188
#define omAlloc(size)
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition polys.cc:13
poly * polyset
Definition polys.h:260
#define IDELEMS(i)

◆ ~fglmSdata()

fglmSdata::~fglmSdata ( )

Definition at line 403 of file fglmzero.cc.

404{
405 omFreeSize( (ADDRESS)varpermutation, ((currRing->N)+1)*sizeof(int) );
406 for ( int k = basisSize; k > 0; k-- )
407 pLmDelete( basis + k ); //. rem: basis runs from basis[1]..basis[basisSize]
408 omFreeSize( (ADDRESS)basis, basisMax*sizeof( poly ) );
409#ifndef HAVE_EXPLICIT_CONSTR
410 delete [] border;
411#else
412 for ( int l = borderSize; l > 0; l-- )
413 // rem: the polys of borderElem are deleted via ~borderElem()
414 border[l].~borderElem();
415 omFreeSize( (ADDRESS)border, borderMax*sizeof( borderElem ) );
416#endif
417}
void * ADDRESS
Definition auxiliary.h:120
int l
Definition cfEzgcd.cc:100
int k
Definition cfEzgcd.cc:99
#define omFreeSize(addr, size)
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
Definition polys.h:77

Member Function Documentation

◆ candidatesLeft()

BOOLEAN fglmSdata::candidatesLeft ( ) const
inline

Definition at line 363 of file fglmzero.cc.

363{ return ( nlist.isEmpty() ? FALSE : TRUE ); }
#define FALSE
Definition auxiliary.h:97
List< fglmSelem > nlist
Definition fglmzero.cc:353

◆ getBasisSize()

int fglmSdata::getBasisSize ( ) const
inline

Definition at line 360 of file fglmzero.cc.

360{ return basisSize; };

◆ getBorderDiv()

fglmVector fglmSdata::getBorderDiv ( const poly m,
int & var ) const

Definition at line 578 of file fglmzero.cc.

579{
580// int num2 = borderSize;
581// while ( num2 > 0 ) {
582// poly temp = border[num2].monom;
583// if ( pDivisibleBy( temp, m ) ) {
584// poly divisor = pDivideM( m, temp );
585// int var = pIsPurePower( divisor );
586// if ( (var != 0) && (pGetCoeff( divisor, var ) == 1) ) {
587// Print( "poly %s divides poly %s", pString( temp ), pString( m ) );
588// }
589// }
590// num2--;
591// }
592 int num = borderSize;
593 while ( num > 0 ) {
594 poly temp = border[num].monom;
595 if ( pDivisibleBy( temp, m ) ) {
596 var = (currRing->N);
597 while ( var > 0 ) {
598 if ( (pGetExp( m, var ) - pGetExp( temp, var )) == 1 )
599 return border[num].nf;
600 var--;
601 }
602 }
603 num--;
604 }
605 return fglmVector();
606}
CanonicalForm num(const CanonicalForm &f)
int m
Definition cfEzgcd.cc:128
#define pGetExp(p, i)
Exponent.
Definition polys.h:42
#define pDivisibleBy(a, b)
returns TRUE, if leading monom of a divides leading monom of b i.e., if there exists a expvector c > ...
Definition polys.h:139

◆ getEdgeNumber()

int fglmSdata::getEdgeNumber ( const poly m) const

Definition at line 529 of file fglmzero.cc.

530{
531 for ( int k = idelems; k > 0; k-- )
532 if ( pLmEqual( m, (theIdeal->m)[k-1] ) )
533 return k;
534 return 0;
535}
#define pLmEqual(p1, p2)
Definition polys.h:112

◆ getSpanPoly()

poly fglmSdata::getSpanPoly ( int number) const
inline

Definition at line 367 of file fglmzero.cc.

367{ return pCopy( (theIdeal->m)[number-1] ); }
#define pCopy(p)
return a copy of the poly
Definition polys.h:186

◆ getVectorRep()

fglmVector fglmSdata::getVectorRep ( const poly m)

Definition at line 543 of file fglmzero.cc.

544{
545 fglmVector temp( basisSize );
546 poly m = p;
547 int num = basisSize;
548 while ( m != NULL ) {
549 int comp = pCmp( m, basis[num] );
550 if ( comp == 0 ) {
551 fglmASSERT( num > 0, "Error(1) in fglmSdata::getVectorRep" );
552 number newelem = nCopy( pGetCoeff( m ) );
553 temp.setelem( num, newelem );
554 num--;
555 pIter( m );
556 }
557 else {
558 if ( comp < 0 ) {
559 num--;
560 }
561 else {
562 // This is the place where we can detect if the sourceIdeal
563 // is not reduced. In this case m is not in basis[]. Since basis[]
564 // is ordered this is the case, if and only if basis[i]<m
565 // and basis[j]>m for all j>i
566 _state= FALSE;
567 return temp;
568 }
569 }
570 }
571 return temp;
572}
int p
Definition cfModGcd.cc:4086
int comp(const CanonicalForm &A, const CanonicalForm &B)
compare polynomials
#define fglmASSERT(ignore1, ignore2)
Definition fglmzero.cc:52
#define pIter(p)
Definition monomials.h:37
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition monomials.h:44
#define nCopy(n)
Definition numbers.h:15
#define NULL
Definition omList.c:12
#define pCmp(p1, p2)
pCmp: args may be NULL returns: (p2==NULL ? 1 : (p1 == NULL ? -1 : p_LmCmp(p1, p2)))
Definition polys.h:116

◆ newBasisElem()

int fglmSdata::newBasisElem ( poly & p)

Definition at line 424 of file fglmzero.cc.

425{
426 basisSize++;
427 if ( basisSize == basisMax ) {
428 basis= (polyset)omReallocSize( basis, basisMax*sizeof( poly ), (basisMax + basisBS)*sizeof( poly ) );
430 }
431 basis[basisSize]= m;
432 m= NULL;
433 return basisSize;
434}
#define omReallocSize(addr, o_size, size)

◆ newBorderElem()

void fglmSdata::newBorderElem ( poly & m,
fglmVector v )

Definition at line 441 of file fglmzero.cc.

442{
443 borderSize++;
444 if ( borderSize == borderMax ) {
445#ifndef HAVE_EXPLICIT_CONSTR
446 borderElem * tempborder = new borderElem[ borderMax+borderBS ];
447 for ( int k = 0; k < borderMax; k++ ) {
448 tempborder[k]= border[k];
449 border[k].insertElem( NULL, fglmVector() );
450 }
451 delete [] border;
452 border= tempborder;
453#else
454 border= (borderElem *)omReallocSize( border, borderMax*sizeof( borderElem ), (borderMax + borderBS)*sizeof( borderElem ) );
455#endif
457 }
458#ifndef HAVE_EXPLICIT_CONSTR
459 border[borderSize].insertElem( m, v );
460#else
461 border[borderSize].borderElem( m, v );
462#endif
463 m= NULL;
464}
const Variable & v
< [in] a sqrfree bivariate poly
Definition facBivar.h:39

◆ nextCandidate()

fglmSelem fglmSdata::nextCandidate ( )

Definition at line 467 of file fglmzero.cc.

468{
469 fglmSelem result = nlist.getFirst();
470 nlist.removeFirst();
471 return result;
472}
return result

◆ state()

BOOLEAN fglmSdata::state ( ) const
inline

Definition at line 359 of file fglmzero.cc.

359{ return _state; };

◆ updateCandidates()

void fglmSdata::updateCandidates ( )

Definition at line 479 of file fglmzero.cc.

480{
481 ListIterator<fglmSelem> list = nlist;
482 fglmASSERT( basisSize > 0 && basisSize < basisMax, "Error(1) in fglmSdata::updateCandidates - wrong bassSize" );
483 poly m = basis[basisSize];
484 poly newmonom = NULL;
485 int k = (currRing->N);
486 BOOLEAN done = FALSE;
487 int state = 0;
488 while ( k >= 1 )
489 {
490 newmonom = pCopy( m );
491 pIncrExp( newmonom, varpermutation[k] );
492 pSetm( newmonom );
493 done= FALSE;
494 while ( list.hasItem() && (!done) )
495 {
496 if ( (state= pCmp( list.getItem().monom, newmonom )) < 0 )
497 list++;
498 else done= TRUE;
499 }
500 if ( !done )
501 {
502 nlist.append( fglmSelem( newmonom, varpermutation[k] ) );
503 break;
504 }
505 if ( state == 0 )
506 {
507 list.getItem().newDivisor( varpermutation[k] );
508 pLmDelete(&newmonom);
509 }
510 else
511 {
512 list.insert( fglmSelem( newmonom, varpermutation[k] ) );
513 }
514 k--;
515 }
516 while ( --k >= 1 )
517 {
518 newmonom= pCopy( m ); // HIER
519 pIncrExp( newmonom, varpermutation[k] );
520 pSetm( newmonom );
521 nlist.append( fglmSelem( newmonom, varpermutation[k] ) );
522 }
523}
int BOOLEAN
Definition auxiliary.h:88
T & getItem() const
void insert(const T &)
BOOLEAN state() const
Definition fglmzero.cc:359
#define pSetm(p)
Definition polys.h:272
#define pIncrExp(p, i)
Definition polys.h:44

Field Documentation

◆ _state

BOOLEAN fglmSdata::_state
private

Definition at line 354 of file fglmzero.cc.

◆ basis

polyset fglmSdata::basis
private

Definition at line 346 of file fglmzero.cc.

◆ basisBS

int fglmSdata::basisBS
private

Definition at line 343 of file fglmzero.cc.

◆ basisMax

int fglmSdata::basisMax
private

Definition at line 344 of file fglmzero.cc.

◆ basisSize

int fglmSdata::basisSize
private

Definition at line 345 of file fglmzero.cc.

◆ border

borderElem* fglmSdata::border
private

Definition at line 351 of file fglmzero.cc.

◆ borderBS

int fglmSdata::borderBS
private

Definition at line 348 of file fglmzero.cc.

◆ borderMax

int fglmSdata::borderMax
private

Definition at line 349 of file fglmzero.cc.

◆ borderSize

int fglmSdata::borderSize
private

Definition at line 350 of file fglmzero.cc.

◆ idelems

int fglmSdata::idelems
private

Definition at line 340 of file fglmzero.cc.

◆ nlist

List<fglmSelem> fglmSdata::nlist
private

Definition at line 353 of file fglmzero.cc.

◆ theIdeal

ideal fglmSdata::theIdeal
private

Definition at line 339 of file fglmzero.cc.

◆ varpermutation

int* fglmSdata::varpermutation
private

Definition at line 341 of file fglmzero.cc.


The documentation for this class was generated from the following file: