My Project  UNKNOWN_GIT_VERSION
fglmvec.cc
Go to the documentation of this file.
1 // emacs edit mode for this file is -*- C++ -*-
2 
3 /****************************************
4 * Computer Algebra System SINGULAR *
5 ****************************************/
6 /*
7 * ABSTRACT - The FGLM-Algorithm
8 * Implementation of number-vectors for the fglm algorithm.
9 * (See fglm.cc). Based on a letter-envelope implementation, mainly
10 * written to be used by the fglm algorithm. Hence they are
11 * specialized for this purpose.
12 */
13 
14 
15 
16 
17 #include "kernel/mod2.h"
18 
19 #include "omalloc/omalloc.h"
20 #include "kernel/structs.h"
21 #include "coeffs/numbers.h"
22 #include "fglm.h"
23 #include "fglmvec.h"
24 
25 #define PROT(msg)
26 #define STICKYPROT(msg) if (BTEST1(OPT_PROT)) Print(msg)
27 #define PROT2(msg,arg)
28 #define STICKYPROT2(msg,arg) if (BTEST1(OPT_PROT)) Print(msg,arg)
29 #define fglmASSERT(ignore1,ignore2)
30 
32 {
33 private:
34  int ref_count;
35  int N;
36  number *elems;
37 public:
38  fglmVectorRep ():ref_count (1), N (0), elems (0)
39  {
40  }
41  fglmVectorRep (int n, number * e):ref_count (1), N (n), elems (e)
42  {
43  }
44  fglmVectorRep (int n):ref_count (1), N (n)
45  {
46  fglmASSERT (N >= 0, "illegal Vector representation");
47  if(N == 0)
48  elems = 0;
49  else
50  {
51  elems = (number *) omAlloc (N * sizeof (number));
52  for(int i = N - 1; i >= 0; i--)
53  elems[i] = nInit (0);
54  }
55  }
57  {
58  if(N > 0)
59  {
60  for(int i = N - 1; i >= 0; i--)
61  nDelete (elems + i);
62  omFreeSize ((ADDRESS) elems, N * sizeof (number));
63  }
64  }
65 
66  fglmVectorRep *clone () const
67  {
68  if(N > 0)
69  {
70  number *elems_clone;
71  elems_clone = (number *) omAlloc (N * sizeof (number));
72  for(int i = N - 1; i >= 0; i--)
73  elems_clone[i] = nCopy (elems[i]);
74  return new fglmVectorRep (N, elems_clone);
75  }
76  else
77  return new fglmVectorRep (N, 0);
78  }
80  {
81  return --ref_count == 0;
82  }
84  {
85  ref_count++;
86  return this;
87  }
88  int refcount () const
89  {
90  return ref_count;
91  }
92  BOOLEAN isUnique () const
93  {
94  return ref_count == 1;
95  }
96 
97  int size () const
98  {
99  return N;
100  }
101  int isZero () const
102  {
103  int k;
104  for(k = N; k > 0; k--)
105  {
106  if(!nIsZero (getconstelem (k)))
107  return 0;
108  }
109  return 1;
110  }
111  int numNonZeroElems () const
112  {
113  int num = 0;
114  int k;
115  for(k = N; k > 0; k--)
116  {
117  if(!nIsZero (getconstelem (k)))
118  num++;
119  }
120  return num;
121  }
122  void setelem (int i, number n)
123  {
124  fglmASSERT (0 < i && i <= N, "setelem: wrong index");
125  nDelete (elems + i - 1);
126  elems[i - 1] = n;
127  }
128  number ejectelem (int i, number n)
129  {
130  fglmASSERT (isUnique (), "should only be called if unique!");
131  number temp = elems[i - 1];
132  elems[i - 1] = n;
133  return temp;
134  }
135  number & getelem (int i)
136  {
137  fglmASSERT (0 < i && i <= N, "getelem: wrong index");
138  return elems[i - 1];
139  }
140  number getconstelem (int i) const
141  {
142  fglmASSERT (0 < i && i <= N, "getconstelem: wrong index");
143  return elems[i - 1];
144  }
145  friend class fglmVector;
146 };
147 
148 
149 ///--------------------------------------------------------------------------------
150 /// Implementation of class fglmVector
151 ///--------------------------------------------------------------------------------
152 
154 {
155 }
156 
158 {
159 }
160 
162 {
163 }
164 
166 {
167  rep->setelem (basis, nInit (1));
168 }
169 
171 {
172  rep = v.rep->copyObject ();
173 }
174 
176 {
177  if(rep->deleteObject ())
178  delete rep;
179 }
180 
181 #ifndef HAVE_EXPLICIT_CONSTR
182 void fglmVector::mac_constr (const fglmVector & v)
183 {
184  rep = v.rep->copyObject ();
185 }
186 
187 void fglmVector::mac_constr_i (int size)
188 {
189  rep = new fglmVectorRep (size);
190 }
191 
192 void fglmVector::clearelems ()
193 {
194  if(rep->deleteObject ())
195  delete rep;
196 }
197 #endif
198 
200 {
201  if(rep->refcount () != 1)
202  {
203  rep->deleteObject ();
204  rep = rep->clone ();
205  }
206 }
207 
208 int fglmVector::size () const
209 {
210  return rep->size ();
211 }
212 
214 {
215  return rep->numNonZeroElems ();
216 }
217 
218 void
219  fglmVector::nihilate (const number fac1, const number fac2,
220  const fglmVector v)
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 }
261 
263 {
264  if(this != &v)
265  {
266  if(rep->deleteObject ())
267  delete rep;
268  rep = v.rep->copyObject ();
269  }
270  return *this;
271 }
272 
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 }
290 
292 {
293  return !(*this == v);
294 }
295 
297 {
298  return rep->isZero ();
299 }
300 
302 {
303  return nIsZero (rep->getconstelem (i));
304 }
305 
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 }
328 
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 }
350 
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 }
371 
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 }
398 
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 }
412 
413 fglmVector operator + (const fglmVector & lhs, const fglmVector & rhs)
414 {
415  fglmVector temp = lhs;
416  temp += rhs;
417  return temp;
418 }
419 
420 fglmVector operator - (const fglmVector & lhs, const fglmVector & rhs)
421 {
422  fglmVector temp = lhs;
423  temp -= rhs;
424  return temp;
425 }
426 
427 fglmVector operator * (const fglmVector & v, const number n)
428 {
429  fglmVector temp = v;
430  temp *= n;
431  return temp;
432 }
433 
434 fglmVector operator * (const number n, const fglmVector & v)
435 {
436  fglmVector temp = v;
437  temp *= n;
438  return temp;
439 }
440 
441 number & fglmVector::getelem (int i)
442 {
443  makeUnique ();
444  return rep->getelem (i);
445 }
446 
447 number fglmVector::getconstelem (int i) const
448 {
449  return rep->getconstelem (i);
450 }
451 
452 void fglmVector::setelem (int i, number & n)
453 {
454  makeUnique ();
455  rep->setelem (i, n);
456  n = n_Init (0, currRing->cf);
457 }
458 
459 number fglmVector::gcd () const
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 }
502 
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 }
536 
537 // ----------------------------------------------------------------------------
538 // Local Variables: ***
539 // compile-command: "make Singular" ***
540 // page-delimiter: "^\\‍( \\|//!\\‍)" ***
541 // fold-internal-margins: nil ***
542 // End: ***
fglmVectorRep::getelem
number & getelem(int i)
Definition: fglmvec.cc:135
FALSE
#define FALSE
Definition: auxiliary.h:94
omalloc.h
fglmVector::operator-=
fglmVector & operator-=(const fglmVector &)
Definition: fglmvec.cc:329
nNormalize
#define nNormalize(n)
Definition: numbers.h:31
fglmVector::clearDenom
number clearDenom()
Definition: fglmvec.cc:503
fglmVectorRep::fglmVectorRep
fglmVectorRep(int n, number *e)
Definition: fglmvec.cc:41
fglmVector::isZero
int isZero()
Definition: fglmvec.cc:296
k
int k
Definition: cfEzgcd.cc:92
fglmVectorRep
Definition: fglmvec.cc:32
nAdd
#define nAdd(n1, n2)
Definition: numbers.h:19
fglmASSERT
#define fglmASSERT(ignore1, ignore2)
Definition: fglmvec.cc:29
ADDRESS
void * ADDRESS
Definition: auxiliary.h:133
fglmVector::getelem
number & getelem(int i)
Definition: fglmvec.cc:441
num
CanonicalForm num(const CanonicalForm &f)
Definition: canonicalform.h:330
nEqual
#define nEqual(n1, n2)
Definition: numbers.h:21
fglmVectorRep::getconstelem
number getconstelem(int i) const
Definition: fglmvec.cc:140
fglmVectorRep::ref_count
int ref_count
Definition: fglmvec.cc:34
fglmVectorRep::deleteObject
BOOLEAN deleteObject()
Definition: fglmvec.cc:79
fglmVectorRep::copyObject
fglmVectorRep * copyObject()
Definition: fglmvec.cc:83
fglmVector::operator*=
fglmVector & operator*=(const number &)
Definition: fglmvec.cc:351
fglmVectorRep::size
int size() const
Definition: fglmvec.cc:97
fglmVector::rep
fglmVectorRep * rep
Definition: fglmvec.h:21
fglmVector
Definition: fglmvec.h:19
fglmVectorRep::setelem
void setelem(int i, number n)
Definition: fglmvec.cc:122
fglmVector::operator/=
fglmVector & operator/=(const number &)
Definition: fglmvec.cc:372
operator+
fglmVector operator+(const fglmVector &lhs, const fglmVector &rhs)
Definition: fglmvec.cc:413
n_NormalizeHelper
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:717
found
bool found
Definition: facFactorize.cc:56
nGreaterZero
#define nGreaterZero(n)
Definition: numbers.h:28
fglmVectorRep::isZero
int isZero() const
Definition: fglmvec.cc:101
fglmVector::fglmVector
fglmVector()
Definition: fglmvec.cc:157
nInpNeg
#define nInpNeg(n)
Definition: numbers.h:22
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
i
int i
Definition: cfEzgcd.cc:125
operator-
fglmVector operator-(const fglmVector &v)
Definition: fglmvec.cc:399
nIsOne
#define nIsOne(n)
Definition: numbers.h:26
fglmVectorRep::ejectelem
number ejectelem(int i, number n)
Definition: fglmvec.cc:128
fglmVector::setelem
void setelem(int i, number &n)
Definition: fglmvec.cc:452
fglmVector::operator=
fglmVector & operator=(const fglmVector &v)
Definition: fglmvec.cc:262
omFreeSize
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
BOOLEAN
int BOOLEAN
Definition: auxiliary.h:85
structs.h
fglmVector::operator+=
fglmVector & operator+=(const fglmVector &)
Definition: fglmvec.cc:306
fglmVector::numNonZeroElems
int numNonZeroElems() const
Definition: fglmvec.cc:213
fglmVectorRep::refcount
int refcount() const
Definition: fglmvec.cc:88
mod2.h
size
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
fglmVectorRep::fglmVectorRep
fglmVectorRep(int n)
Definition: fglmvec.cc:44
fglmVectorRep::elems
number * elems
Definition: fglmvec.cc:36
omAlloc
#define omAlloc(size)
Definition: omAllocDecl.h:210
fglmVector::operator==
int operator==(const fglmVector &)
Definition: fglmvec.cc:273
nDiv
#define nDiv(a, b)
Definition: numbers.h:33
n_Init
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:538
fglmVectorRep::isUnique
BOOLEAN isUnique() const
Definition: fglmvec.cc:92
fglmVector::makeUnique
void makeUnique()
Definition: fglmvec.cc:199
fglmVector::nihilate
void nihilate(const number fac1, const number fac2, const fglmVector v)
Definition: fglmvec.cc:219
operator*
fglmVector operator*(const fglmVector &v, const number n)
Definition: fglmvec.cc:427
fglmVector::~fglmVector
~fglmVector()
Definition: fglmvec.cc:175
fglmVectorRep::clone
fglmVectorRep * clone() const
Definition: fglmvec.cc:66
fglmVector::gcd
number gcd() const
Definition: fglmvec.cc:459
nIsZero
#define nIsZero(n)
Definition: numbers.h:20
nMult
#define nMult(n1, n2)
Definition: numbers.h:18
nSub
#define nSub(n1, n2)
Definition: numbers.h:23
fglmVector::operator!=
int operator!=(const fglmVector &)
Definition: fglmvec.cc:291
fglmVectorRep::~fglmVectorRep
~fglmVectorRep()
Definition: fglmvec.cc:56
fglmVector::getconstelem
number getconstelem(int i) const
Definition: fglmvec.cc:447
nDelete
#define nDelete(n)
Definition: numbers.h:17
n_SubringGcd
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
Definition: coeffs.h:688
v
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
fglmvec.h
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
nInit
#define nInit(i)
Definition: numbers.h:25
nCopy
#define nCopy(n)
Definition: numbers.h:16
fglmVectorRep::fglmVectorRep
fglmVectorRep()
Definition: fglmvec.cc:38
numbers.h
fglmVectorRep::numNonZeroElems
int numNonZeroElems() const
Definition: fglmvec.cc:111
fglm.h
fglmVectorRep::N
int N
Definition: fglmvec.cc:35
fglmVector::elemIsZero
int elemIsZero(int i)
Definition: fglmvec.cc:301
fglmVector::size
int size() const
Definition: fglmvec.cc:208