My Project
Loading...
Searching...
No Matches
Public Member Functions | Private Attributes
fglmDdata Class Reference

Public Member Functions

 fglmDdata (int dimension)
 
 ~fglmDdata ()
 
int getBasisSize () const
 
BOOLEAN candidatesLeft () const
 
fglmDelem nextCandidate ()
 
void newBasisElem (poly &m, fglmVector v, fglmVector p, number &denom)
 
void updateCandidates (poly m, const fglmVector v)
 
void newGroebnerPoly (fglmVector &v, poly &p)
 
void gaussreduce (fglmVector &v, fglmVector &p, number &denom)
 
ideal buildIdeal ()
 

Private Attributes

int dimen
 
oldGaussElem * gauss
 
BOOLEAN * isPivot
 
int * perm
 
int basisSize
 
polyset basis
 
int * varpermutation
 
int groebnerBS
 
int groebnerSize
 
ideal destId
 
List< fglmDelem > nlist
 

Detailed Description

Definition at line 758 of file fglmzero.cc.

Constructor & Destructor Documentation

◆ fglmDdata()

fglmDdata::fglmDdata ( int  dimension)

Definition at line 793 of file fglmzero.cc.

794{
795 int k;
796 dimen= dimension;
797 basisSize= 0;
798 //. All arrays run from [1]..[dimen], thus omAlloc( dimen + 1 )!
799#ifndef HAVE_EXPLICIT_CONSTR
800 gauss= new oldGaussElem[ dimen+1 ];
801#else
802 gauss= (oldGaussElem *)omAlloc( (dimen+1)*sizeof( oldGaussElem ) );
803#endif
804 isPivot= (BOOLEAN *)omAlloc( (dimen+1)*sizeof( BOOLEAN ) );
805 for ( k= dimen; k > 0; k-- ) isPivot[k]= FALSE;
806 perm= (int *)omAlloc( (dimen+1)*sizeof( int ) );
807 basis= (polyset)omAlloc( (dimen+1)*sizeof( poly ) );
808 varpermutation = (int*)omAlloc( ((currRing->N)+1)*sizeof(int) );
809 // Sort ring variables by increasing values (because of weighted orderings)
810 ideal perm_id = idMaxIdeal(1);
811 intvec *iv = idSort(perm_id,TRUE);
812 idDelete(&perm_id);
813 for(int i = (currRing->N); i > 0; i--) varpermutation[(currRing->N)+1-i] = (*iv)[i-1];
814 delete iv;
815
816 groebnerBS= 16;
817 groebnerSize= 0;
818 destId= idInit( groebnerBS, 1 );
819}
BOOLEAN
int BOOLEAN
Definition: auxiliary.h:87
TRUE
#define TRUE
Definition: auxiliary.h:100
FALSE
#define FALSE
Definition: auxiliary.h:96
dimension
BOOLEAN dimension(leftv res, leftv args)
Definition: bbcone.cc:757
i
int i
Definition: cfEzgcd.cc:132
k
int k
Definition: cfEzgcd.cc:99
fglmDdata::isPivot
BOOLEAN * isPivot
Definition: fglmzero.cc:763
fglmDdata::dimen
int dimen
Definition: fglmzero.cc:761
fglmDdata::varpermutation
int * varpermutation
Definition: fglmzero.cc:768
fglmDdata::gauss
oldGaussElem * gauss
Definition: fglmzero.cc:762
fglmDdata::groebnerSize
int groebnerSize
Definition: fglmzero.cc:771
fglmDdata::basisSize
int basisSize
Definition: fglmzero.cc:765
fglmDdata::basis
polyset basis
Definition: fglmzero.cc:766
fglmDdata::groebnerBS
int groebnerBS
Definition: fglmzero.cc:770
fglmDdata::destId
ideal destId
Definition: fglmzero.cc:772
fglmDdata::perm
int * perm
Definition: fglmzero.cc:764
intvec
Definition: intvec.h:23
idDelete
#define idDelete(H)
delete an ideal
Definition: ideals.h:29
idMaxIdeal
#define idMaxIdeal(D)
initialise the maximal ideal (at 0)
Definition: ideals.h:33
idSort
static intvec * idSort(ideal id, BOOLEAN nolex=TRUE)
Definition: ideals.h:184
omAlloc
#define omAlloc(size)
Definition: omAllocDecl.h:210
currRing
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
polyset
poly * polyset
Definition: polys.h:259
idInit
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35

◆ ~fglmDdata()

fglmDdata::~fglmDdata ( )

Definition at line 821 of file fglmzero.cc.

822{
823 // STICKYPROT2("dimen= %i", dimen);
824 // STICKYPROT2("basisSize= %i", basisSize);
825 // fglmASSERT( dimen == basisSize, "Es wurden nicht alle BasisElemente gefunden!" );
826 int k;
827#ifndef HAVE_EXPLICIT_CONSTR
828 delete [] gauss;
829#else
830 // use basisSize instead of dimen because of fglmquot!
831 for ( k= basisSize; k > 0; k-- )
832 gauss[k].~oldGaussElem();
833 omFreeSize( (ADDRESS)gauss, (dimen+1)*sizeof( oldGaussElem ) );
834#endif
835 omFreeSize( (ADDRESS)isPivot, (dimen+1)*sizeof( BOOLEAN ) );
836 omFreeSize( (ADDRESS)perm, (dimen+1)*sizeof( int ) );
837 // use basisSize instead of dimen because of fglmquot!
838 //. Remember: There is no poly in basis[0], thus k > 0
839 for ( k= basisSize; k > 0; k-- )
840 pLmDelete( basis[k]);
841 omFreeSize( (ADDRESS)basis, (dimen+1)*sizeof( poly ) );
842 omFreeSize( (ADDRESS)varpermutation, ((currRing->N)+1)*sizeof(int) );
843}
ADDRESS
void * ADDRESS
Definition: auxiliary.h:119
omFreeSize
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
pLmDelete
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
Definition: polys.h:76

Member Function Documentation

◆ buildIdeal()

ideal fglmDdata::buildIdeal ( )
inline

Definition at line 786 of file fglmzero.cc.

787 {
788 idSkipZeroes( destId );
789 return destId;
790 }
idSkipZeroes
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
Definition: simpleideals.cc:181

◆ candidatesLeft()

BOOLEAN fglmDdata::candidatesLeft ( ) const
inline

Definition at line 780 of file fglmzero.cc.

780{ return ( nlist.isEmpty() ? FALSE : TRUE ); }
List::isEmpty
int isEmpty() const
Definition: ftmpl_list.cc:267
fglmDdata::nlist
List< fglmDelem > nlist
Definition: fglmzero.cc:774

◆ gaussreduce()

void fglmDdata::gaussreduce ( fglmVector &  v,
fglmVector &  p,
number &  denom 
)

Definition at line 979 of file fglmzero.cc.

980{
981 int k;
982 number fac1, fac2;
983 number temp;
984 fglmASSERT( pdenom == NULL, "pdenom in gaussreduce should be NULL" );
985 pdenom= nInit( 1 );
986 number vdenom = v.clearDenom();
987 if ( ! nIsZero( vdenom ) && ! nIsOne( vdenom ) ) {
988 p.setelem( p.size(), vdenom );
989 }
990 else {
991 nDelete( &vdenom );
992 }
993 number gcd = v.gcd();
994 if ( ! nIsZero( gcd ) && ! nIsOne( gcd ) ) {
995 v /= gcd;
996 number temp= nMult( pdenom, gcd );
997 nDelete( &pdenom );
998 pdenom= temp;
999 }
1000 nDelete( & gcd );
1001
1002 for ( k= 1; k <= basisSize; k++ ) {
1003
1004 if ( ! v.elemIsZero( perm[k] ) ) {
1005 fac1= gauss[k].fac;
1006 fac2= nCopy( v.getconstelem( perm[k] ) );
1007 v.nihilate( fac1, fac2, gauss[k].v );
1008 fac1= nMult( fac1, gauss[k].pdenom );
1009 temp= nMult( fac2, pdenom );
1010 nDelete( &fac2 );
1011 fac2= temp;
1012 p.nihilate( fac1, fac2, gauss[k].p );
1013 temp= nMult( pdenom, gauss[k].pdenom );
1014 nDelete( &pdenom );
1015 pdenom= temp;
1016
1017 nDelete( & fac1 );
1018 nDelete( & fac2 );
1019 number gcd = v.gcd();
1020 if ( ! nIsZero( gcd ) && ! nIsOne( gcd ) )
1021 {
1022 v /= gcd;
1023 number temp= nMult( pdenom, gcd );
1024 nDelete( &pdenom );
1025 pdenom= temp;
1026 }
1027 nDelete( & gcd );
1028 gcd= p.gcd();
1029 temp= n_SubringGcd( pdenom, gcd, currRing->cf );
1030 nDelete( &gcd );
1031 gcd= temp;
1032 if ( ! nIsZero( gcd ) && ! nIsOne( gcd ) )
1033 {
1034 p /= gcd;
1035 temp= nDiv( pdenom, gcd );
1036 nDelete( & pdenom );
1037 pdenom= temp;
1038 nNormalize( pdenom );
1039 }
1040 nDelete( & gcd );
1041 }
1042 }
1043}
p
int p
Definition: cfModGcd.cc:4078
oldGaussElem::fac
number fac
Definition: fglmzero.cc:727
n_SubringGcd
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
Definition: coeffs.h:663
v
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:39
fglmASSERT
#define fglmASSERT(ignore1, ignore2)
Definition: fglmzero.cc:52
nDiv
#define nDiv(a, b)
Definition: numbers.h:32
nDelete
#define nDelete(n)
Definition: numbers.h:16
nIsZero
#define nIsZero(n)
Definition: numbers.h:19
nCopy
#define nCopy(n)
Definition: numbers.h:15
nIsOne
#define nIsOne(n)
Definition: numbers.h:25
nNormalize
#define nNormalize(n)
Definition: numbers.h:30
nInit
#define nInit(i)
Definition: numbers.h:24
nMult
#define nMult(n1, n2)
Definition: numbers.h:17
NULL
#define NULL
Definition: omList.c:12
gcd
int gcd(int a, int b)
Definition: walkSupport.cc:836

◆ getBasisSize()

int fglmDdata::getBasisSize ( ) const
inline

Definition at line 779 of file fglmzero.cc.

779{ return basisSize; }

◆ newBasisElem()

void fglmDdata::newBasisElem ( poly &  m,
fglmVector  v,
fglmVector  p,
number &  denom 
)

Definition at line 854 of file fglmzero.cc.

855{
856// inserts m as a new basis monom. m is NOT copied but directly inserted.
857// returns m=NULL to indicate, that now basis is oweing m.
858 basisSize++;
859 basis[basisSize]= m;
860 m= NULL;
861 int k= 1;
862 while ( nIsZero(v.getconstelem(k)) || isPivot[k] ) {
863 k++;
864 }
865 fglmASSERT( k <= dimen, "Error(1) in fglmDdata::pivot-search");
866 number pivot= v.getconstelem( k );
867 int pivotcol = k;
868 k++;
869 while ( k <= dimen ) {
870 if ( ! nIsZero( v.getconstelem(k) ) && ! isPivot[k] ) {
871 if ( nGreater( v.getconstelem( k ), pivot ) ) {
872 pivot= v.getconstelem( k );
873 pivotcol= k;
874 }
875 }
876 k++;
877 }
878 fglmASSERT( ! nIsZero( pivot ), "Error(2) fglmDdata::Pivotelement ist Null" );
879 isPivot[ pivotcol ]= TRUE;
880 perm[basisSize]= pivotcol;
881
882 pivot= nCopy( v.getconstelem( pivotcol ) );
883#ifndef HAVE_EXPLICIT_CONSTR
884 gauss[basisSize].insertElem( v, p, denom, pivot );
885#else
886 gauss[basisSize].oldGaussElem( v, p, denom, pivot );
887#endif
888}
m
int m
Definition: cfEzgcd.cc:128
oldGaussElem::oldGaussElem
oldGaussElem(const fglmVector newv, const fglmVector newp, number &newpdenom, number &newfac)
Definition: fglmzero.cc:732
pivot
bool pivot(const matrix aMat, const int r1, const int r2, const int c1, const int c2, int *bestR, int *bestC, const ring R)
This code computes a score for each non-zero matrix entry in aMat[r1..r2, c1..c2].
Definition: linearAlgebra.cc:68
nGreater
#define nGreater(a, b)
Definition: numbers.h:28

◆ newGroebnerPoly()

void fglmDdata::newGroebnerPoly ( fglmVector &  v,
poly &  p 
)

Definition at line 936 of file fglmzero.cc.

941{
942 //. Baue das Polynom von oben nach unten:
943 fglmASSERT( p.size() == basisSize+1, "GP::newGroebnerPoly: p has wrong size" );
944 int k;
945 poly result = m;
946 poly temp = result;
947 m= NULL;
948 if ( nGetChar() > 0 ) {
949 number lead = nCopy( p.getconstelem( basisSize+1 ) );
950 p /= lead;
951 nDelete( & lead );
952 }
953 if ( nGetChar() == 0 ) {
954 number gcd= p.gcd();
955 fglmASSERT( ! nIsZero( gcd ), "FATAL: gcd and thus p is zero" );
956 if ( ! nIsOne( gcd ) )
957 p /= gcd;
958 nDelete( & gcd );
959 }
960 pSetCoeff( result, nCopy( p.getconstelem( basisSize+1 ) ) );
961 for ( k= basisSize; k > 0; k-- ) {
962 if ( ! nIsZero( p.getconstelem( k ) ) ) {
963 temp->next= pCopy( basis[k] );
964 pIter( temp );
965 pSetCoeff( temp, nCopy( p.getconstelem( k ) ) );
966 }
967 }
968 pSetm( result );
969 if ( ! nGreaterZero( pGetCoeff( result ) ) ) result= pNeg( result );
970 if ( groebnerSize == IDELEMS( destId ) ) {
971 pEnlargeSet( & destId->m, IDELEMS( destId ), groebnerBS );
972 IDELEMS( destId )+= groebnerBS;
973 }
974 (destId->m)[groebnerSize]= result;
975 groebnerSize++;
976}
result
return result
Definition: facAbsBiFact.cc:75
pIter
#define pIter(p)
Definition: monomials.h:37
pGetCoeff
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
nGetChar
#define nGetChar()
Definition: numbers.h:23
nGreaterZero
#define nGreaterZero(n)
Definition: numbers.h:27
pEnlargeSet
void pEnlargeSet(poly **p, int l, int increment)
Definition: p_polys.cc:3696
pSetm
#define pSetm(p)
Definition: polys.h:271
pNeg
#define pNeg(p)
Definition: polys.h:198
pSetCoeff
#define pSetCoeff(p, n)
deletes old coeff before setting the new one
Definition: polys.h:31
pCopy
#define pCopy(p)
return a copy of the poly
Definition: polys.h:185
IDELEMS
#define IDELEMS(i)
Definition: simpleideals.h:23

◆ nextCandidate()

fglmDelem fglmDdata::nextCandidate ( )

Definition at line 846 of file fglmzero.cc.

847{
848 fglmDelem result = nlist.getFirst();
849 nlist.removeFirst();
850 return result;
851}
List::getFirst
T getFirst() const
Definition: ftmpl_list.cc:279
List::removeFirst
void removeFirst()
Definition: ftmpl_list.cc:287
fglmDelem
Definition: fglm.h:47

◆ updateCandidates()

void fglmDdata::updateCandidates ( poly  m,
const fglmVector  v 
)

Definition at line 891 of file fglmzero.cc.

892{
893 ListIterator<fglmDelem> list = nlist;
894 poly newmonom = NULL;
895 int k = (currRing->N);
896 BOOLEAN done = FALSE;
897 int state = 0;
898 while ( k >= 1 )
899 {
900 newmonom = pCopy( m );
901 pIncrExp( newmonom, varpermutation[k] );
902 pSetm( newmonom );
903 done= FALSE;
904 while ( list.hasItem() && (!done) )
905 {
906 if ( (state= pCmp( list.getItem().monom, newmonom )) < 0 )
907 list++;
908 else done= TRUE;
909 }
910 if ( !done )
911 {
912 nlist.append( fglmDelem( newmonom, v, k ) );
913 break;
914 }
915 if ( state == 0 )
916 {
917 list.getItem().newDivisor();
918 pLmDelete( & newmonom );
919 }
920 else
921 {
922 list.insert( fglmDelem( newmonom, v, k ) );
923 }
924 k--;
925 }
926 while ( --k >= 1 )
927 {
928 newmonom= pCopy( m );
929 pIncrExp( newmonom, varpermutation[k] );
930 pSetm( newmonom );
931 nlist.append( fglmDelem( newmonom, v, k ) );
932 }
933}
ListIterator::getItem
T & getItem() const
Definition: ftmpl_list.cc:431
ListIterator::insert
void insert(const T &)
Definition: ftmpl_list.cc:492
List::append
void append(const T &)
Definition: ftmpl_list.cc:256
pCmp
#define pCmp(p1, p2)
pCmp: args may be NULL returns: (p2==NULL ? 1 : (p1 == NULL ? -1 : p_LmCmp(p1, p2)))
Definition: polys.h:115
pIncrExp
#define pIncrExp(p, i)
Definition: polys.h:43

Field Documentation

◆ basis

polyset fglmDdata::basis
private

Definition at line 766 of file fglmzero.cc.

◆ basisSize

int fglmDdata::basisSize
private

Definition at line 765 of file fglmzero.cc.

◆ destId

ideal fglmDdata::destId
private

Definition at line 772 of file fglmzero.cc.

◆ dimen

int fglmDdata::dimen
private

Definition at line 761 of file fglmzero.cc.

◆ gauss

oldGaussElem* fglmDdata::gauss
private

Definition at line 762 of file fglmzero.cc.

◆ groebnerBS

int fglmDdata::groebnerBS
private

Definition at line 770 of file fglmzero.cc.

◆ groebnerSize

int fglmDdata::groebnerSize
private

Definition at line 771 of file fglmzero.cc.

◆ isPivot

BOOLEAN* fglmDdata::isPivot
private

Definition at line 763 of file fglmzero.cc.

◆ nlist

List<fglmDelem> fglmDdata::nlist
private

Definition at line 774 of file fglmzero.cc.

◆ perm

int* fglmDdata::perm
private

Definition at line 764 of file fglmzero.cc.

◆ varpermutation

int* fglmDdata::varpermutation
private

Definition at line 768 of file fglmzero.cc.

The documentation for this class was generated from the following file:
Generated on Mon Feb 27 2023 10:53:53 for My Project by   doxygen 1.9.5 for Singular