My Project  debian-1:4.1.1-p2+ds-4
Public Member Functions | Private Member Functions | Private Attributes
idealFunctionals Class Reference

Public Member Functions

 idealFunctionals (int blockSize, int numFuncs)
 
 ~idealFunctionals ()
 
int dimen () const
 
void endofConstruction ()
 
void map (ring source)
 
void insertCols (int *divisors, int to)
 
void insertCols (int *divisors, const fglmVector to)
 
fglmVector addCols (const int var, int basisSize, const fglmVector v) const
 
fglmVector multiply (const fglmVector v, int var) const
 

Private Member Functions

matHeadergrow (int var)
 

Private Attributes

int _block
 
int _max
 
int _size
 
int _nfunc
 
int * currentSize
 
matHeader ** func
 

Detailed Description

Definition at line 76 of file fglmzero.cc.

Constructor & Destructor Documentation

◆ idealFunctionals()

idealFunctionals::idealFunctionals ( int  blockSize,
int  numFuncs 
)

Definition at line 100 of file fglmzero.cc.

101 {
102  int k;
103  _block= blockSize;
104  _max= _block;
105  _size= 0;
106  _nfunc= numFuncs;
107 
108  currentSize= (int *)omAlloc0( _nfunc*sizeof( int ) );
109  //for ( k= _nfunc-1; k >= 0; k-- )
110  // currentSize[k]= 0;
111 
112  func= (matHeader **)omAlloc( _nfunc*sizeof( matHeader * ) );
113  for ( k= _nfunc-1; k >= 0; k-- )
114  func[k]= (matHeader *)omAlloc( _max*sizeof( matHeader ) );
115 }

◆ ~idealFunctionals()

idealFunctionals::~idealFunctionals ( )

Definition at line 117 of file fglmzero.cc.

118 {
119  int k;
120  int l;
121  int row;
122  matHeader * colp;
123  matElem * elemp;
124  for ( k= _nfunc-1; k >= 0; k-- ) {
125  for ( l= _size-1, colp= func[k]; l >= 0; l--, colp++ ) {
126  if ( ( colp->owner == TRUE ) && ( colp->size > 0 ) ) {
127  for ( row= colp->size-1, elemp= colp->elems; row >= 0; row--, elemp++ )
128  nDelete( & elemp->elem );
129  omFreeSize( (ADDRESS)colp->elems, colp->size*sizeof( matElem ) );
130  }
131  }
132  omFreeSize( (ADDRESS)func[k], _max*sizeof( matHeader ) );
133  }
134  omFreeSize( (ADDRESS)func, _nfunc*sizeof( matHeader * ) );
135  omFreeSize( (ADDRESS)currentSize, _nfunc*sizeof( int ) );
136 }

Member Function Documentation

◆ addCols()

fglmVector idealFunctionals::addCols ( const int  var,
int  basisSize,
const fglmVector  v 
) const

Definition at line 243 of file fglmzero.cc.

244 {
245  fglmVector result( basisSize );
246  matHeader * colp;
247  matElem * elemp;
248  number factor, temp;
249  int k, l;
250  int vsize = v.size();
251 
252  fglmASSERT( currentSize[var-1]+1 >= vsize, "wrong v.size()" );
253  for ( k= 1, colp= func[var-1]; k <= vsize; k++, colp++ ) {
254  factor= v.getconstelem( k );
255  if ( ! nIsZero( factor ) ) {
256  for ( l= colp->size-1, elemp= colp->elems; l >= 0; l--, elemp++ ) {
257  temp= nMult( factor, elemp->elem );
258  number newelem= nAdd( result.getconstelem( elemp->row ), temp );
259  nDelete( & temp );
260  nNormalize( newelem );
261  result.setelem( elemp->row, newelem );
262  }
263  }
264  }
265  return result;
266 }

◆ dimen()

int idealFunctionals::dimen ( ) const
inline

Definition at line 90 of file fglmzero.cc.

90 { fglmASSERT( _size>0, "called too early"); return _size; }

◆ endofConstruction()

void idealFunctionals::endofConstruction ( )

Definition at line 139 of file fglmzero.cc.

140 {
141  _size= currentSize[0];
142 }

◆ grow()

matHeader * idealFunctionals::grow ( int  var)
private

Definition at line 179 of file fglmzero.cc.

180 {
181  if ( currentSize[var-1] == _max ) {
182  int k;
183  for ( k= _nfunc; k > 0; k-- )
184  func[k-1]= (matHeader *)omReallocSize( func[k-1], _max*sizeof( matHeader ), (_max + _block)*sizeof( matHeader ) );
185  _max+= _block;
186  }
187  currentSize[var-1]++;
188  return func[var-1] + currentSize[var-1] - 1;
189 }

◆ insertCols() [1/2]

void idealFunctionals::insertCols ( int *  divisors,
const fglmVector  to 
)

Definition at line 212 of file fglmzero.cc.

213 {
214  // divisors runs from divisors[0]..divisors[size-1]
215  fglmASSERT( 0 < divisors[0] && divisors[0] <= _nfunc, "wrong number of divisors" );
216  int k, l;
217  int numElems= to.numNonZeroElems();
218  matElem * elems;
219  matElem * elemp;
220  BOOLEAN owner = TRUE;
221  if ( numElems > 0 ) {
222  elems= (matElem *)omAlloc( numElems * sizeof( matElem ) );
223  for ( k= 1, l= 1, elemp= elems; k <= numElems; k++, elemp++ ) {
224  while ( nIsZero( to.getconstelem(l) ) ) l++;
225  elemp->row= l;
226  elemp->elem= nCopy( to.getconstelem( l ) );
227  l++; // hochzaehlen, damit wir nicht noch einmal die gleiche Stelle testen
228  }
229  }
230  else
231  elems= NULL;
232  for ( k= divisors[0]; k > 0; k-- ) {
233  fglmASSERT( 0 < divisors[k] && divisors[k] <= _nfunc, "wrong divisor" );
234  matHeader * colp = grow( divisors[k] );
235  colp->size= numElems;
236  colp->elems= elems;
237  colp->owner= owner;
238  owner= FALSE;
239  }
240 }

◆ insertCols() [2/2]

void idealFunctionals::insertCols ( int *  divisors,
int  to 
)

Definition at line 192 of file fglmzero.cc.

193 {
194  fglmASSERT( 0 < divisors[0] && divisors[0] <= _nfunc, "wrong number of divisors" );
195  int k;
196  BOOLEAN owner = TRUE;
197  matElem * elems = (matElem *)omAlloc( sizeof( matElem ) );
198  elems->row= to;
199  elems->elem= nInit( 1 );
200  for ( k= divisors[0]; k > 0; k-- ) {
201  fglmASSERT( 0 < divisors[k] && divisors[k] <= _nfunc, "wrong divisor" );
202  matHeader * colp = grow( divisors[k] );
203  colp->size= 1;
204  colp->elems= elems;
205  colp->owner= owner;
206  owner= FALSE;
207  }
208 }

◆ map()

void idealFunctionals::map ( ring  source)

Definition at line 145 of file fglmzero.cc.

146 {
147  // maps from ring source to currentRing.
148  int var, col, row;
149  matHeader * colp;
150  matElem * elemp;
151  number newelem;
152 
153  int * perm = (int *)omAlloc0( (_nfunc+1)*sizeof( int ) );
154  maFindPerm( source->names, source->N, NULL, 0, currRing->names,
155  currRing->N, NULL, 0, perm, NULL , currRing->cf->type);
156  nMapFunc nMap=n_SetMap( source->cf, currRing->cf);
157 
158  matHeader ** temp = (matHeader **)omAlloc( _nfunc*sizeof( matHeader * ));
159  for ( var= 0; var < _nfunc; var ++ ) {
160  for ( col= 0, colp= func[var]; col < _size; col++, colp++ ) {
161  if ( colp->owner == TRUE ) {
162  for ( row= colp->size-1, elemp= colp->elems; row >= 0;
163  row--, elemp++ )
164  {
165  newelem= nMap( elemp->elem, source->cf, currRing->cf );
166  nDelete( & elemp->elem );
167  elemp->elem= newelem;
168  }
169  }
170  }
171  temp[ perm[var+1]-1 ]= func[var];
172  }
173  omFreeSize( (ADDRESS)func, _nfunc*sizeof( matHeader * ) );
174  omFreeSize( (ADDRESS)perm, (_nfunc+1)*sizeof( int ) );
175  func= temp;
176 }

◆ multiply()

fglmVector idealFunctionals::multiply ( const fglmVector  v,
int  var 
) const

Definition at line 269 of file fglmzero.cc.

270 {
271  fglmASSERT( v.size() == _size, "multiply: v has wrong size");
273  matHeader * colp;
274  matElem * elemp;
275  number factor, temp;
276  int k, l;
277  for ( k= 1, colp= func[var-1]; k <= _size; k++, colp++ ) {
278  factor= v.getconstelem( k );
279  if ( ! nIsZero( factor ) ) {
280  for ( l= colp->size-1, elemp= colp->elems; l >= 0; l--, elemp++ ) {
281  temp= nMult( factor, elemp->elem );
282  number newelem= nAdd( result.getconstelem( elemp->row ), temp );
283  nDelete( & temp );
284  nNormalize( newelem );
285  result.setelem( elemp->row, newelem );
286  }
287  }
288  }
289  return result;
290 }

Field Documentation

◆ _block

int idealFunctionals::_block
private

Definition at line 79 of file fglmzero.cc.

◆ _max

int idealFunctionals::_max
private

Definition at line 80 of file fglmzero.cc.

◆ _nfunc

int idealFunctionals::_nfunc
private

Definition at line 82 of file fglmzero.cc.

◆ _size

int idealFunctionals::_size
private

Definition at line 81 of file fglmzero.cc.

◆ currentSize

int* idealFunctionals::currentSize
private

Definition at line 83 of file fglmzero.cc.

◆ func

matHeader** idealFunctionals::func
private

Definition at line 84 of file fglmzero.cc.


The documentation for this class was generated from the following file:
FALSE
#define FALSE
Definition: auxiliary.h:94
matHeader
Definition: fglmzero.cc:69
nNormalize
#define nNormalize(n)
Definition: numbers.h:30
k
int k
Definition: cfEzgcd.cc:92
result
return result
Definition: facAbsBiFact.cc:76
nAdd
#define nAdd(n1, n2)
Definition: numbers.h:18
ADDRESS
void * ADDRESS
Definition: auxiliary.h:133
idealFunctionals::_nfunc
int _nfunc
Definition: fglmzero.cc:82
fglmVector
Definition: fglmvec.h:17
currRing
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
TRUE
#define TRUE
Definition: auxiliary.h:98
nMapFunc
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:73
omFreeSize
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:258
BOOLEAN
int BOOLEAN
Definition: auxiliary.h:85
fglmVector::numNonZeroElems
int numNonZeroElems() const
Definition: fglmvec.cc:212
omAlloc
#define omAlloc(size)
Definition: omAllocDecl.h:208
matHeader::owner
BOOLEAN owner
Definition: fglmzero.cc:72
idealFunctionals::_size
int _size
Definition: fglmzero.cc:81
nIsZero
#define nIsZero(n)
Definition: numbers.h:19
nMult
#define nMult(n1, n2)
Definition: numbers.h:17
matElem::row
int row
Definition: fglmzero.cc:65
fglmASSERT
#define fglmASSERT(ignore1, ignore2)
Definition: fglmzero.cc:54
factor
CanonicalForm factor
Definition: facAbsFact.cc:101
matHeader::size
int size
Definition: fglmzero.cc:71
matHeader::elems
matElem * elems
Definition: fglmzero.cc:73
matElem::elem
number elem
Definition: fglmzero.cc:66
NULL
#define NULL
Definition: omList.c:9
idealFunctionals::func
matHeader ** func
Definition: fglmzero.cc:84
maFindPerm
void maFindPerm(char const *const *const preim_names, int preim_n, char const *const *const preim_par, int preim_p, char const *const *const names, int n, char const *const *const par, int nop, int *perm, int *par_perm, n_coeffType ch)
Definition: maps.cc:164
fglmVector::getconstelem
number getconstelem(int i) const
Definition: fglmvec.cc:446
l
int l
Definition: cfEzgcd.cc:93
nDelete
#define nDelete(n)
Definition: numbers.h:16
idealFunctionals::_block
int _block
Definition: fglmzero.cc:79
matElem
The idealFunctionals.
Definition: fglmzero.cc:63
v
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
nInit
#define nInit(i)
Definition: numbers.h:24
n_SetMap
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
Definition: coeffs.h:721
idealFunctionals::currentSize
int * currentSize
Definition: fglmzero.cc:83
idealFunctionals::grow
matHeader * grow(int var)
Definition: fglmzero.cc:179
nCopy
#define nCopy(n)
Definition: numbers.h:15
omAlloc0
#define omAlloc0(size)
Definition: omAllocDecl.h:209
idealFunctionals::_max
int _max
Definition: fglmzero.cc:80
omReallocSize
#define omReallocSize(addr, o_size, size)
Definition: omAllocDecl.h:218