My Project  debian-1:4.1.1-p2+ds-4build4
Public Member Functions | Protected Member Functions | Protected Attributes | Friends
fglmVector Class Reference

#include <fglmvec.h>

Public Member Functions

 fglmVector ()
 
 fglmVector (int size)
 
 fglmVector (int size, int basis)
 
 fglmVector (const fglmVector &v)
 
 ~fglmVector ()
 
int size () const
 
int numNonZeroElems () const
 
void nihilate (const number fac1, const number fac2, const fglmVector v)
 
fglmVectoroperator= (const fglmVector &v)
 
int operator== (const fglmVector &)
 
int operator!= (const fglmVector &)
 
int isZero ()
 
int elemIsZero (int i)
 
fglmVectoroperator+= (const fglmVector &)
 
fglmVectoroperator-= (const fglmVector &)
 
fglmVectoroperator*= (const number &)
 
fglmVectoroperator/= (const number &)
 
number getconstelem (int i) const
 
number & getelem (int i)
 
void setelem (int i, number &n)
 
number gcd () const
 
number clearDenom ()
 

Protected Member Functions

void makeUnique ()
 
 fglmVector (fglmVectorRep *rep)
 

Protected Attributes

fglmVectorReprep
 

Friends

fglmVector operator- (const fglmVector &v)
 
fglmVector operator+ (const fglmVector &lhs, const fglmVector &rhs)
 
fglmVector operator- (const fglmVector &lhs, const fglmVector &rhs)
 
fglmVector operator* (const fglmVector &v, const number n)
 
fglmVector operator* (const number n, const fglmVector &v)
 

Detailed Description

Definition at line 18 of file fglmvec.h.

Constructor & Destructor Documentation

◆ fglmVector() [1/5]

fglmVector::fglmVector ( fglmVectorRep r)
protected

Implementation of class fglmVector

Definition at line 153 of file fglmvec.cc.

153  :rep (r)
154 {
155 }
fglmVectorRep * rep
Definition: fglmvec.h:21

◆ fglmVector() [2/5]

fglmVector::fglmVector ( )

Definition at line 157 of file fglmvec.cc.

157  :rep (new fglmVectorRep ())
158 {
159 }

◆ fglmVector() [3/5]

fglmVector::fglmVector ( int  size)

Definition at line 161 of file fglmvec.cc.

161  :rep (new fglmVectorRep (size))
162 {
163 }
int size() const
Definition: fglmvec.cc:208

◆ fglmVector() [4/5]

fglmVector::fglmVector ( int  size,
int  basis 
)

Definition at line 165 of file fglmvec.cc.

165  :rep (new fglmVectorRep (size))
166 {
167  rep->setelem (basis, nInit (1));
168 }
void setelem(int i, number n)
Definition: fglmvec.cc:122
#define nInit(i)
Definition: numbers.h:25

◆ fglmVector() [5/5]

fglmVector::fglmVector ( const fglmVector v)

Definition at line 170 of file fglmvec.cc.

171 {
172  rep = v.rep->copyObject ();
173 }
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37

◆ ~fglmVector()

fglmVector::~fglmVector ( )

Definition at line 175 of file fglmvec.cc.

176 {
177  if(rep->deleteObject ())
178  delete rep;
179 }
BOOLEAN deleteObject()
Definition: fglmvec.cc:79

Member Function Documentation

◆ clearDenom()

number fglmVector::clearDenom ( )

Definition at line 503 of file fglmvec.cc.

504 {
505  number theLcm = nInit (1);
506  BOOLEAN isZero = TRUE;
507  int i;
508  for(i = size (); i > 0; i--)
509  {
510  if(!nIsZero (rep->getconstelem (i)))
511  {
512  isZero = FALSE;
513  number temp = n_NormalizeHelper (theLcm, rep->getconstelem (i), currRing->cf);
514  nDelete (&theLcm);
515  theLcm = temp;
516  }
517  }
518  if(isZero)
519  {
520  nDelete (&theLcm);
521  theLcm = nInit (0);
522  }
523  else
524  {
525  if(!nIsOne (theLcm))
526  {
527  *this *= theLcm;
528  for(i = size (); i > 0; i--)
529  {
530  nNormalize (rep->getelem (i));
531  }
532  }
533  }
534  return theLcm;
535 }
int BOOLEAN
Definition: auxiliary.h:85
#define TRUE
Definition: auxiliary.h:98
#define FALSE
Definition: auxiliary.h:94
int i
Definition: cfEzgcd.cc:125
number getconstelem(int i) const
Definition: fglmvec.cc:140
number & getelem(int i)
Definition: fglmvec.cc:135
int isZero()
Definition: fglmvec.cc:296
static FORCE_INLINE number n_NormalizeHelper(number a, number b, const coeffs r)
assume that r is a quotient field (otherwise, return 1) for arguments (a1/a2,b1/b2) return (lcm(a1,...
Definition: coeffs.h:718
#define nDelete(n)
Definition: numbers.h:17
#define nIsZero(n)
Definition: numbers.h:20
#define nIsOne(n)
Definition: numbers.h:26
#define nNormalize(n)
Definition: numbers.h:31
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13

◆ elemIsZero()

int fglmVector::elemIsZero ( int  i)

Definition at line 301 of file fglmvec.cc.

302 {
303  return nIsZero (rep->getconstelem (i));
304 }

◆ gcd()

number fglmVector::gcd ( ) const

Definition at line 459 of file fglmvec.cc.

460 {
461  int i = rep->size ();
462  BOOLEAN found = FALSE;
463  BOOLEAN gcdIsOne = FALSE;
464  number theGcd;
465  number current;
466  while(i > 0 && !found)
467  {
468  current = rep->getconstelem (i);
469  if(!nIsZero (current))
470  {
471  theGcd = nCopy (current);
472  found = TRUE;
473  if(!nGreaterZero (theGcd))
474  {
475  theGcd = nInpNeg (theGcd);
476  }
477  if(nIsOne (theGcd))
478  gcdIsOne = TRUE;
479  }
480  i--;
481  }
482  if(found)
483  {
484  while(i > 0 && !gcdIsOne)
485  {
486  current = rep->getconstelem (i);
487  if(!nIsZero (current))
488  {
489  number temp = n_SubringGcd (theGcd, current, currRing->cf);
490  nDelete (&theGcd);
491  theGcd = temp;
492  if(nIsOne (theGcd))
493  gcdIsOne = TRUE;
494  }
495  i--;
496  }
497  }
498  else
499  theGcd = nInit (0);
500  return theGcd;
501 }
int size() const
Definition: fglmvec.cc:97
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
Definition: coeffs.h:689
bool found
Definition: facFactorize.cc:56
#define nInpNeg(n)
Definition: numbers.h:22
#define nCopy(n)
Definition: numbers.h:16
#define nGreaterZero(n)
Definition: numbers.h:28

◆ getconstelem()

number fglmVector::getconstelem ( int  i) const

Definition at line 447 of file fglmvec.cc.

448 {
449  return rep->getconstelem (i);
450 }

◆ getelem()

number & fglmVector::getelem ( int  i)

Definition at line 441 of file fglmvec.cc.

442 {
443  makeUnique ();
444  return rep->getelem (i);
445 }
void makeUnique()
Definition: fglmvec.cc:199

◆ isZero()

int fglmVector::isZero ( )

Definition at line 296 of file fglmvec.cc.

297 {
298  return rep->isZero ();
299 }
int isZero() const
Definition: fglmvec.cc:101

◆ makeUnique()

void fglmVector::makeUnique ( )
protected

Definition at line 199 of file fglmvec.cc.

200 {
201  if(rep->refcount () != 1)
202  {
203  rep->deleteObject ();
204  rep = rep->clone ();
205  }
206 }
int refcount() const
Definition: fglmvec.cc:88
fglmVectorRep * clone() const
Definition: fglmvec.cc:66

◆ nihilate()

void fglmVector::nihilate ( const number  fac1,
const number  fac2,
const fglmVector  v 
)

Definition at line 219 of file fglmvec.cc.

221 {
222  int i;
223  int vsize = v.size ();
224  number term1, term2;
225  fglmASSERT (vsize <= rep->size (), "v has to be smaller oder equal");
226  if(rep->isUnique ())
227  {
228  for(i = vsize; i > 0; i--)
229  {
230  term1 = nMult (fac1, rep->getconstelem (i));
231  term2 = nMult (fac2, v.rep->getconstelem (i));
232  rep->setelem (i, nSub (term1, term2));
233  nDelete (&term1);
234  nDelete (&term2);
235  }
236  for(i = rep->size (); i > vsize; i--)
237  {
238  rep->setelem (i, nMult (fac1, rep->getconstelem (i)));
239  }
240  }
241  else
242  {
243  number *newelems;
244  newelems = (number *) omAlloc (rep->size () * sizeof (number));
245  for(i = vsize; i > 0; i--)
246  {
247  term1 = nMult (fac1, rep->getconstelem (i));
248  term2 = nMult (fac2, v.rep->getconstelem (i));
249  newelems[i - 1] = nSub (term1, term2);
250  nDelete (&term1);
251  nDelete (&term2);
252  }
253  for(i = rep->size (); i > vsize; i--)
254  {
255  newelems[i - 1] = nMult (fac1, rep->getconstelem (i));
256  }
257  rep->deleteObject ();
258  rep = new fglmVectorRep (rep->size (), newelems);
259  }
260 }
BOOLEAN isUnique() const
Definition: fglmvec.cc:92
#define fglmASSERT(ignore1, ignore2)
Definition: fglmvec.cc:29
#define nSub(n1, n2)
Definition: numbers.h:23
#define nMult(n1, n2)
Definition: numbers.h:18
#define omAlloc(size)
Definition: omAllocDecl.h:210

◆ numNonZeroElems()

int fglmVector::numNonZeroElems ( ) const

Definition at line 213 of file fglmvec.cc.

214 {
215  return rep->numNonZeroElems ();
216 }
int numNonZeroElems() const
Definition: fglmvec.cc:111

◆ operator!=()

int fglmVector::operator!= ( const fglmVector v)

Definition at line 291 of file fglmvec.cc.

292 {
293  return !(*this == v);
294 }

◆ operator*=()

fglmVector & fglmVector::operator*= ( const number &  n)

Definition at line 351 of file fglmvec.cc.

352 {
353  int s = rep->size ();
354  int i;
355  if(!rep->isUnique ())
356  {
357  number *temp;
358  temp = (number *) omAlloc (s * sizeof (number));
359  for(i = s; i > 0; i--)
360  temp[i - 1] = nMult (rep->getconstelem (i), n);
361  rep->deleteObject ();
362  rep = new fglmVectorRep (s, temp);
363  }
364  else
365  {
366  for(i = s; i > 0; i--)
367  rep->setelem (i, nMult (rep->getconstelem (i), n));
368  }
369  return *this;
370 }
const CanonicalForm int s
Definition: facAbsFact.cc:55

◆ operator+=()

fglmVector & fglmVector::operator+= ( const fglmVector v)

Definition at line 306 of file fglmvec.cc.

307 {
308  fglmASSERT (size () == v.size (), "incompatible vectors");
309  // ACHTUNG : Das Verhalten hier mit gcd genau ueberpruefen!
310  int i;
311  if(rep->isUnique ())
312  {
313  for(i = rep->size (); i > 0; i--)
314  rep->setelem (i, nAdd (rep->getconstelem (i), v.rep->getconstelem (i)));
315  }
316  else
317  {
318  int n = rep->size ();
319  number *newelems;
320  newelems = (number *) omAlloc (n * sizeof (number));
321  for(i = n; i > 0; i--)
322  newelems[i - 1] = nAdd (rep->getconstelem (i), v.rep->getconstelem (i));
323  rep->deleteObject ();
324  rep = new fglmVectorRep (n, newelems);
325  }
326  return *this;
327 }
#define nAdd(n1, n2)
Definition: numbers.h:19

◆ operator-=()

fglmVector & fglmVector::operator-= ( const fglmVector v)

Definition at line 329 of file fglmvec.cc.

330 {
331  fglmASSERT (size () == v.size (), "incompatible vectors");
332  int i;
333  if(rep->isUnique ())
334  {
335  for(i = rep->size (); i > 0; i--)
336  rep->setelem (i, nSub (rep->getconstelem (i), v.rep->getconstelem (i)));
337  }
338  else
339  {
340  int n = rep->size ();
341  number *newelems;
342  newelems = (number *) omAlloc (n * sizeof (number));
343  for(i = n; i > 0; i--)
344  newelems[i - 1] = nSub (rep->getconstelem (i), v.rep->getconstelem (i));
345  rep->deleteObject ();
346  rep = new fglmVectorRep (n, newelems);
347  }
348  return *this;
349 }

◆ operator/=()

fglmVector & fglmVector::operator/= ( const number &  n)

Definition at line 372 of file fglmvec.cc.

373 {
374  int s = rep->size ();
375  int i;
376  if(!rep->isUnique ())
377  {
378  number *temp;
379  temp = (number *) omAlloc (s * sizeof (number));
380  for(i = s; i > 0; i--)
381  {
382  temp[i - 1] = nDiv (rep->getconstelem (i), n);
383  nNormalize (temp[i - 1]);
384  }
385  rep->deleteObject ();
386  rep = new fglmVectorRep (s, temp);
387  }
388  else
389  {
390  for(i = s; i > 0; i--)
391  {
392  rep->setelem (i, nDiv (rep->getconstelem (i), n));
393  nNormalize (rep->getelem (i));
394  }
395  }
396  return *this;
397 }
#define nDiv(a, b)
Definition: numbers.h:33

◆ operator=()

fglmVector & fglmVector::operator= ( const fglmVector v)

Definition at line 262 of file fglmvec.cc.

263 {
264  if(this != &v)
265  {
266  if(rep->deleteObject ())
267  delete rep;
268  rep = v.rep->copyObject ();
269  }
270  return *this;
271 }

◆ operator==()

int fglmVector::operator== ( const fglmVector v)

Definition at line 273 of file fglmvec.cc.

274 {
275  if(rep->size () == v.rep->size ())
276  {
277  if(rep == v.rep)
278  return 1;
279  else
280  {
281  int i;
282  for(i = rep->size (); i > 0; i--)
283  if(!nEqual (rep->getconstelem (i), v.rep->getconstelem (i)))
284  return 0;
285  return 1;
286  }
287  }
288  return 0;
289 }
#define nEqual(n1, n2)
Definition: numbers.h:21

◆ setelem()

void fglmVector::setelem ( int  i,
number &  n 
)

Definition at line 452 of file fglmvec.cc.

453 {
454  makeUnique ();
455  rep->setelem (i, n);
456  n = n_Init (0, currRing->cf);
457 }
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition: coeffs.h:539

◆ size()

int fglmVector::size ( ) const

Definition at line 208 of file fglmvec.cc.

209 {
210  return rep->size ();
211 }

Friends And Related Function Documentation

◆ operator* [1/2]

fglmVector operator* ( const fglmVector v,
const number  n 
)
friend

Definition at line 427 of file fglmvec.cc.

428 {
429  fglmVector temp = v;
430  temp *= n;
431  return temp;
432 }

◆ operator* [2/2]

fglmVector operator* ( const number  n,
const fglmVector v 
)
friend

Definition at line 434 of file fglmvec.cc.

435 {
436  fglmVector temp = v;
437  temp *= n;
438  return temp;
439 }

◆ operator+

fglmVector operator+ ( const fglmVector lhs,
const fglmVector rhs 
)
friend

Definition at line 413 of file fglmvec.cc.

414 {
415  fglmVector temp = lhs;
416  temp += rhs;
417  return temp;
418 }

◆ operator- [1/2]

fglmVector operator- ( const fglmVector lhs,
const fglmVector rhs 
)
friend

Definition at line 420 of file fglmvec.cc.

421 {
422  fglmVector temp = lhs;
423  temp -= rhs;
424  return temp;
425 }

◆ operator- [2/2]

fglmVector operator- ( const fglmVector v)
friend

Definition at line 399 of file fglmvec.cc.

400 {
401  fglmVector temp (v.size ());
402  int i;
403  number n;
404  for(i = v.size (); i > 0; i--)
405  {
406  n = nCopy (v.getconstelem (i));
407  n = nInpNeg (n);
408  temp.setelem (i, n);
409  }
410  return temp;
411 }

Field Documentation

◆ rep

fglmVectorRep* fglmVector::rep
protected

Definition at line 21 of file fglmvec.h.


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