My Project  debian-1:4.1.2-p1+ds-2
coeffs_test.h
Go to the documentation of this file.
1 #include "misc/auxiliary.h"
2 
3 #include "reporter/reporter.h"
4 #include "resources/feResource.h"
5 
6 #include "coeffs/coeffs.h"
7 #include "coeffs/numbers.h"
8 
9 // the following headers are private...
10 #include "coeffs/longrat.h"
11 #include "coeffs/gnumpfl.h"
12 #include "coeffs/gnumpc.h"
13 #include "coeffs/shortfl.h"
14 #include "coeffs/ffields.h"
15 #include "coeffs/modulop.h"
16 #include "coeffs/rmodulon.h"
17 #include "coeffs/rmodulo2m.h"
18 #include "coeffs/rintegers.h"
19 
20 
21 #include "common.h"
22 using namespace std;
23 
24 
25 void TestSum(const coeffs r, const unsigned long N)
26 {
27  clog << ( _2S("TEST: sum[0..") + _2S(N) + "]: ");
28  clog << endl;
29 
30  assume( N > 0 ); // just for now...
31 
32  const unsigned long ssss = (N * (N+1)) / 2;
33 
34  number sum1 = n_Init(ssss, r);
35  clog<< "N*(N+1)/2 (int: " << ssss << "): "; PrintSized(sum1, r);
36 
37  number s, ss, i, res;
38 
39  s = n_Init(N , r);
40  i = n_Init(N+1, r);
41  n_InpMult(s, i, r);
42  n_Delete(&i, r);
43 
44  clog<< "N*(N+1): ("<< N*(N+1) << ")"; PrintSized(s, r);
45 
46  i = n_Init(2, r);
47  clog<< "2: "; PrintSized(i, r);
48 
49  if( !n_IsZero( i, r) )
50  {
51 #ifdef HAVE_RINGS
52  TS_ASSERT( n_DivBy(s, i, r) );
53 #endif
54 
55  res = n_Div(s, i, r);
56 
57  clog<< "N*(N+1)/2: "; PrintSized(res, r);
58 
59 
60  number d = n_Sub(res, sum1, r);
61  TS_ASSERT( n_IsZeroDivisor(d, r) );
62  n_Delete(&d, r);
63 
64  if( n_GetChar(r) == 0 )
65  {
66  TS_ASSERT( n_Equal(sum1, res, r) );
67  TS_ASSERT( n_Equal(res, sum1, r) );
68  }
69  } else
71 
72 
73  n_Delete(&s, r); n_Delete(&i, r);
74 
75  n_Delete(&sum1, r); n_Delete(&res, r);
76 
77 
78  s = n_Init(0 , r);
79  ss = n_Init(0 , r);
80  for( int k = N; k >= 0; k-- )
81  {
82  i = n_Init(k, r);
83  n_InpAdd(s, i, r); // s += i
84 
85  i = n_InpNeg(i, r);
86  n_InpAdd(ss, i, r); // ss -= i
87 
88  n_Delete(&i, r);
89  }
90  clog<< "ss: "; PrintSized(ss, r);
91 
92  ss = n_InpNeg(ss, r); // ss = -ss
93 
94  clog<< "real sum : "; PrintSized(s, r);
95  clog<< "real sum(--): "; PrintSized(ss, r);
96 
97  TS_ASSERT( n_Equal(s, ss, r) );
98  TS_ASSERT( n_Equal(ss, s, r) );
99 
100  n_Delete(&s, r);
101  n_Delete(&ss, r);
102 
103  clog << ( " >>> TEST DONE!" );
104  clog << endl;
105 
106 }
107 
108 
109 void TestArith(const coeffs r)
110 {
111  clog << ("TEST: Simple Arithmetics: ");
112  clog << endl;
113 
114  number two = n_Init(2, r);
115 
116  number t = n_Init(1, r);
117  n_InpAdd(t, t, r);
118  TS_ASSERT( n_Equal(two, t, r) );
119  n_Delete(&t, r);
120 
121  if( getCoeffType(r) == n_Q )
122  {
123  number t = n_Init(1, r);
124  n_InpAdd(t, t, r);
125  TS_ASSERT( n_Equal(two, t, r) );
126  n_Delete(&t, r);
127  }
128 
129 
130 
131 
132  const int N = 66666;
133 
134  number a = n_Init(N, r);
135 
136  clog<< "a: "; PrintSized(a, r);
137 
138 
139  clog<< "two: "; PrintSized(two, r);
140 
141  number aa0 = n_Init(N*2, r);
142 
143  number aa = n_Add(a, a, r);
144 
145  clog<< "aa = a + a: "; PrintSized(aa, r);
146 
147  number aa2 = n_Mult(a, two, r);
148 
149  clog<< "aa2 = a * 2: "; PrintSized(aa2, r);
150 
151  number aa1 = n_Mult(two, a, r);
152 
153  clog<< "aa1 = 2 * a: "; PrintSized(aa1, r);
154 
155  n_Delete(&a, r);
156  n_Delete(&two, r);
157 
158 
159  a = n_Sub( aa, aa1, r );
160 
161  clog<< "a = aa - aa1: "; PrintSized(a, r);
162 
163  TS_ASSERT( n_IsZero(a, r) );
164 
165  n_Delete(&a, r);
166 
167  a = n_Sub( aa, aa2, r );
168 
169  clog<< "a = aa - aa2: "; PrintSized(a, r);
170 
171  TS_ASSERT( n_IsZero(a, r) );
172 
173  n_Delete(&a, r);
174 
175 
176  a = n_Sub( aa1, aa2, r );
177 
178  clog<< "a = aa1 - aa2: "; PrintSized(a, r);
179 
180  TS_ASSERT( n_IsZero(a, r) );
181 
182  n_Delete(&a, r);
183 
184 
185 
186  TS_ASSERT( n_Equal(aa, aa1, r) );
187  TS_ASSERT( n_Equal(aa, aa2, r) );
188  TS_ASSERT( n_Equal(aa1, aa2, r) );
189 
190  TS_ASSERT( n_Equal(aa0, aa, r) );
191  TS_ASSERT( n_Equal(aa0, aa1, r) );
192  TS_ASSERT( n_Equal(aa0, aa2, r) );
193 
194  n_Delete(&aa, r);
195  n_Delete(&aa1, r);
196  n_Delete(&aa2, r);
197 
198  n_Delete(&aa0, r);
199 
200  clog << ( " >>> TEST DONE!" );
201  clog << endl;
202 
203 }
204 
205 
206 
207 
208 
209 BOOLEAN Test(const n_coeffType type, void* p = NULLp)
210 {
211 
212  clog << endl;
213  clog << ( "----------------------- Testing coeffs: [" + _2S(type) + ", " + _2S(p) + "]: -----------------------");
214  clog << endl;
215 
216  const coeffs r = nInitChar( type, p );
217 
218  if( r == NULLp )
219  {
220  clog << ( "Test: could not get this coeff. domain" );
221  return FALSE;
222  };
223 
224  TS_ASSERT_DIFFERS( r->cfCoeffWrite, NULLp );
225 
226  if( r->cfCoeffWrite != NULL )
227  {
228  clog << "Coeff-domain: " << endl;
229  n_CoeffWrite(r); PrintLn();
230  }
231 
232  if (n_NumberOfParameters(r) > 0)
233  {
234  number z = n_Param(1, r); // also any integer instead of 0//?
235  PrintS("Parameter: "); PrintSized(z, r);
236  n_Delete(&z, r);
237  }
238 
239 
240  clog << "Char: " << n_GetChar(r) << endl;
241 
242 
243  TS_ASSERT_DIFFERS( r, NULLp );
244  nSetChar( r );
245  TS_ASSERT_EQUALS( getCoeffType(r), type );
246 
247  TS_ASSERT_DIFFERS( r->cfInit, NULLp );
248  TS_ASSERT_DIFFERS( r->cfWriteLong, NULLp );
249  TS_ASSERT_DIFFERS( r->cfAdd, NULLp );
250  TS_ASSERT_DIFFERS( r->cfDelete, NULLp );
251 
252  switch( type )
253  {
254  case n_Q:
255  {
256  //TS_ASSERT_EQUALS( r->cfInit, nlInit );
257  //TS_ASSERT_EQUALS( r->cfAdd, nlAdd );
258  //TS_ASSERT_EQUALS( r->cfDelete, nlDelete );
259 
260  TS_ASSERT( nCoeff_is_Q( r ));
262 
263  TS_ASSERT( !nCoeff_has_Units( r )); // ?
265  TS_ASSERT( !nCoeff_has_simple_Alloc( r )); // ?
266 
268  TS_ASSERT( !nCoeff_is_Zn( r ));
270  TS_ASSERT( !nCoeff_is_Z( r ));
271  TS_ASSERT( !nCoeff_is_Ring( r ));
272  TS_ASSERT( !nCoeff_is_Zp( r ));
274  TS_ASSERT( !nCoeff_is_R( r ));
275  TS_ASSERT( !nCoeff_is_GF( r ));
276  TS_ASSERT( !nCoeff_is_long_R( r ));
277  TS_ASSERT( !nCoeff_is_long_C( r ));
278  TS_ASSERT( !nCoeff_is_CF( r ));
280 
281  break;
282  }
283  case n_long_R:
284  {
285  //TS_ASSERT_EQUALS( r->cfInit, ngfInit );
286  //TS_ASSERT_EQUALS( r->cfAdd, ngfAdd );
287  //TS_ASSERT_EQUALS( r->cfDelete, ngfDelete );
288  break;
289  }
290  case n_long_C:
291  {
292 // TS_ASSERT_EQUALS( r->cfInit, ngcInit );
293 // TS_ASSERT_EQUALS( r->cfAdd, ngcAdd );
294 // TS_ASSERT_EQUALS( r->cfDelete, ngcDelete );
295  break;
296  }
297  case n_R:
298  {
299  //TS_ASSERT_EQUALS( r->cfInit, nrInit );
300  //TS_ASSERT_EQUALS( r->cfAdd, nrAdd );
301  // TS_ASSERT_EQUALS( r->cfDelete, nrDelete ); // No?
302  break;
303  }
304  case n_GF:
305  {
306 // TS_ASSERT_EQUALS( r->cfInit, nfInit );
307 // TS_ASSERT_EQUALS( r->cfAdd, nfAdd );
308  //TS_ASSERT_EQUALS( r->cfDelete, nfDelete );
309  break;
310  }
311 #ifdef HAVE_RINGS
312  case n_Z2m:
313  {
314  //TS_ASSERT_EQUALS( r->cfInit, nr2mInit );
315  //TS_ASSERT_EQUALS( r->cfAdd, nr2mAdd );
316  //TS_ASSERT_EQUALS( r->cfDelete, ndDelete );
317  break;
318  }
319  case n_Zn:
320  {
321  //TS_ASSERT_EQUALS( r->cfInit, nrnInit );
322  //TS_ASSERT_EQUALS( r->cfAdd, nrnAdd );
323  //TS_ASSERT_EQUALS( r->cfDelete, nrnDelete );
324  break;
325  }
326 #endif
327  default:
328  {
329  // ...
330  }
331  }
332 
333  TestArith( r );
334  TestSum( r, 10 );
335  TestSum( r, 100 );
336  TestSum( r, 101 );
337  TestSum( r, 1001 );
338  TestSum( r, 9000 );
339 
340  nKillChar( r );
341 
342  return TRUE;
343 }
344 
345 
346 
347 // We can rely on this file being included exactly once
348 // and declare this global variable in the header file.
349 //
351 
352 
354 {
355  public:
356 // void test_dummy() { float fnum = 2.00001f; TS_ASSERT_DELTA (fnum, 2.0f, 0.0001f); }
357 
358  void test_Z2m4()
359  {
360 #ifdef HAVE_RINGS
361  n_coeffType type = n_Z2m;
362  TS_ASSERT( Test(type, (void*) 4) );
363 #endif
364  }
365 
366  void test_Zp101()
367  {
368  n_coeffType type = n_Zp;
369  TS_ASSERT( Test(type, (void*) 101) );
370  }
371 
372  void test_Z2m8()
373  {
374 #ifdef HAVE_RINGS
375  n_coeffType type = n_Z2m;
376  TS_ASSERT( Test(type, (void*) 8) );
377 #endif
378  }
379 
380  void simple(const n_coeffType _type)
381  {
382  n_coeffType type = _type;
383  TS_ASSERT( type == _type ); // ?
384  TS_ASSERT( Test(type) );
385  }
386 
387  void test_Q()
388  {
389  simple(n_Q);
390  }
391 
392  void test_R()
393  {
394  simple(n_R);
395  }
396 
397 
398  void test_Z()
399  {
400 #ifdef HAVE_RINGS
401  simple(n_Z); // No need in GMP?
402 #endif
403  }
404 
405 
407  {
408  n_coeffType type = n_GF;
409 
410  GFInfo param;
411 
412  param.GFChar= 5;
413  param.GFDegree= 12;
414  param.GFPar_name= (const char*)"q";
415 
416  TS_ASSERT( !Test(type, (void*) &param) );
417 
418  // it should not be used by numbers... right?
419  // TODO: what is our policy wrt param-pointer-ownership?
420  }
421 
422  void test_GF()
423  {
424  // TODO: what if it was already registered?
425  // Q: no way to deRegister a type?
426  n_coeffType type = n_GF;
427 
428  GFInfo param;
429 
430  param.GFChar= 5;
431  param.GFDegree= 2;
432  param.GFPar_name= (const char*)"Q";
433 
434  TS_ASSERT( Test(type, (void*) &param) );
435 
436  // it should not be used by numbers... right?
437  // TODO: what is our policy wrt param-pointer-ownership?
438  }
439 
440 
441  void test_Zn3()
442  {
443 #ifdef HAVE_RINGS
444  n_coeffType type = n_Zn;
445 
446  ZnmInfo Znmparam;
447  Znmparam.base= (mpz_ptr) omAlloc (sizeof (mpz_t));
448  mpz_init_set_ui (Znmparam.base, 3);
449  Znmparam.exp= 1;
450 
451  TS_ASSERT( Test(type, (void*) &Znmparam) );
452 #endif
453  }
454 
455  void test_Z2m2()
456  {
457 #ifdef HAVE_RINGS
458  n_coeffType type = n_Z2m;
459 
460  TS_ASSERT( Test(type, (void*) 2) );
461 #endif
462  }
463 
464  void test_LR()
465  {
466  simple(n_long_R);
467  }
468 
469  void test_LC()
470  {
471  simple(n_long_C);
472  }
473 
475  {
476  const coeffs cf = nInitChar(n_Q, NULLp);
477 
478  if (cf == NULLp)
479  clog << ( "Test: could not get this coeff. domain" );
480 
481  TS_ASSERT_DIFFERS(cf->cfCoeffWrite, NULLp);
482 
483  if (cf->cfCoeffWrite != NULL )
484  {
485  clog << "Coeff-domain: " << endl;
486  n_CoeffWrite(cf); PrintLn();
487  }
488 
489  number q1 = n_Init(21, cf);
490  number q2 = n_Init(2, cf);
491  number q3 = n_Div(q1, q2, cf);
492  number q4 = n_Init(30, cf);
493  number q5 = n_Mult(q3, q4, cf);
494  TS_ASSERT(n_Test(q5, cf));
495  Print("21/2 * 30 = %ld\n", n_Int(q5, cf));
496  TS_ASSERT(n_Test(q5, cf));
497  n_Delete(&q1, cf);
498  n_Delete(&q2, cf);
499  n_Delete(&q3, cf);
500  n_Delete(&q4, cf);
501  n_Delete(&q5, cf);
502  }
503 };
504 
getCoeffType
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:420
FALSE
#define FALSE
Definition: auxiliary.h:96
n_Zn
only used if HAVE_RINGS is defined
Definition: coeffs.h:44
TS_ASSERT_DIFFERS
#define TS_ASSERT_DIFFERS(x, y)
Definition: TestSuite.h:287
nCoeff_is_numeric
static FORCE_INLINE BOOLEAN nCoeff_is_numeric(const coeffs r)
Definition: coeffs.h:853
GFInfo::GFChar
int GFChar
Definition: coeffs.h:93
TS_ASSERT
#define TS_ASSERT(e)
Definition: TestSuite.h:239
nCoeff_is_Zp
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition: coeffs.h:821
Test
BOOLEAN Test(const n_coeffType type, void *p=NULLp)
Definition: coeffs_test.h:209
nSetChar
static FORCE_INLINE void nSetChar(const coeffs r)
initialisations after each ring change
Definition: coeffs.h:435
nCoeff_is_R
static FORCE_INLINE BOOLEAN nCoeff_is_R(const coeffs r)
Definition: coeffs.h:857
k
int k
Definition: cfEzgcd.cc:92
rmodulo2m.h
nCoeff_is_Z
static FORCE_INLINE BOOLEAN nCoeff_is_Z(const coeffs r)
Definition: coeffs.h:837
nCoeff_is_Ring_2toM
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_2toM(const coeffs r)
Definition: coeffs.h:745
n_InpMult
static FORCE_INLINE void n_InpMult(number &a, number b, const coeffs r)
multiplication of 'a' and 'b'; replacement of 'a' by the product a*b
Definition: coeffs.h:640
n_GetChar
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:443
GFInfo
Creation data needed for finite fields.
Definition: coeffs.h:91
n_long_C
complex floating point (GMP) numbers
Definition: coeffs.h:41
CoeffsTestSuite::test_Zp101
void test_Zp101()
Definition: coeffs_test.h:366
gnumpc.h
n_Z2m
only used if HAVE_RINGS is defined
Definition: coeffs.h:46
cf
CanonicalForm cf
Definition: cfModGcd.cc:4024
CoeffsTestSuite::test_Q_special
void test_Q_special()
Definition: coeffs_test.h:474
CoeffsTestSuite::test_R
void test_R()
Definition: coeffs_test.h:392
n_Delete
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:454
n_GF
\GF{p^n < 2^16}
Definition: coeffs.h:32
nInitChar
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:349
n_Q
rational (GMP) numbers
Definition: coeffs.h:30
CoeffsTestSuite
Definition: coeffs_test.h:353
auxiliary.h
N
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:48
TestArith
void TestArith(const coeffs r)
Definition: coeffs_test.h:109
n_IsZero
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
Definition: coeffs.h:463
nCoeff_is_GF
static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
Definition: coeffs.h:860
n_NumberOfParameters
static FORCE_INLINE int n_NumberOfParameters(const coeffs r)
Returns the number of parameters.
Definition: coeffs.h:795
reporter.h
n_Param
static FORCE_INLINE number n_Param(const int iParameter, const coeffs r)
return the (iParameter^th) parameter as a NEW number NOTE: parameter numbering: 1....
Definition: coeffs.h:804
ZnmInfo::exp
int exp
Definition: rmodulon.h:17
nCoeff_is_long_C
static FORCE_INLINE BOOLEAN nCoeff_is_long_C(const coeffs r)
Definition: coeffs.h:915
rintegers.h
n_IsZeroDivisor
BOOLEAN n_IsZeroDivisor(number a, const coeffs r)
Test whether a is a zero divisor in r i.e. not coprime with char. of r very inefficient implementatio...
Definition: numbers.cc:145
ffields.h
n_long_R
real floating point (GMP) numbers
Definition: coeffs.h:33
n_coeffType
n_coeffType
Definition: coeffs.h:26
nCoeff_is_Q
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
Definition: coeffs.h:827
n_CoeffWrite
static FORCE_INLINE void n_CoeffWrite(const coeffs r, BOOLEAN details=TRUE)
output the coeff description
Definition: coeffs.h:740
n_Add
static FORCE_INLINE number n_Add(number a, number b, const coeffs r)
return the sum of 'a' and 'b', i.e., a+b
Definition: coeffs.h:655
n_InpAdd
static FORCE_INLINE void n_InpAdd(number &a, number b, const coeffs r)
addition of 'a' and 'b'; replacement of 'a' by the sum a+b
Definition: coeffs.h:645
TRUE
#define TRUE
Definition: auxiliary.h:100
i
int i
Definition: cfEzgcd.cc:125
res
CanonicalForm res
Definition: facAbsFact.cc:64
GlobalPrintingFixture
Definition: common.h:90
CoeffsTestSuite::test_LC
void test_LC()
Definition: coeffs_test.h:469
PrintS
void PrintS(const char *s)
Definition: reporter.cc:283
BOOLEAN
int BOOLEAN
Definition: auxiliary.h:87
CxxTest::TestSuite
Definition: TestSuite.h:21
shortfl.h
rmodulon.h
ZnmInfo::base
mpz_ptr base
Definition: rmodulon.h:17
nCoeff_is_Ring
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
Definition: coeffs.h:751
TS_ASSERT_EQUALS
#define TS_ASSERT_EQUALS(x, y)
Definition: TestSuite.h:255
GFInfo::GFDegree
int GFDegree
Definition: coeffs.h:94
nCoeff_has_simple_Alloc
static FORCE_INLINE BOOLEAN nCoeff_has_simple_Alloc(const coeffs r)
TRUE if n_Delete/n_New are empty operations.
Definition: coeffs.h:927
coeffs
TestSum
void TestSum(const coeffs r, const unsigned long N)
Definition: coeffs_test.h:25
nCoeff_is_long_R
static FORCE_INLINE BOOLEAN nCoeff_is_long_R(const coeffs r)
Definition: coeffs.h:912
n_Z
only used if HAVE_RINGS is defined
Definition: coeffs.h:43
n_Mult
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of 'a' and 'b', i.e., a*b
Definition: coeffs.h:635
omAlloc
#define omAlloc(size)
Definition: omAllocDecl.h:208
nCoeff_is_Ring_PtoM
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_PtoM(const coeffs r)
Definition: coeffs.h:748
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:537
GFInfo::GFPar_name
const char * GFPar_name
Definition: coeffs.h:95
CoeffsTestSuite::test_LR
void test_LR()
Definition: coeffs_test.h:464
CoeffsTestSuite::test_Z2m4
void test_Z2m4()
Definition: coeffs_test.h:358
nCoeff_is_CF
static FORCE_INLINE BOOLEAN nCoeff_is_CF(const coeffs r)
Definition: coeffs.h:918
nCoeff_is_Extension
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
Definition: coeffs.h:867
n_InpNeg
static FORCE_INLINE number n_InpNeg(number n, const coeffs r)
in-place negation of n MUST BE USED: n = n_InpNeg(n) (no copy is returned)
Definition: coeffs.h:556
nCoeff_has_Units
static FORCE_INLINE BOOLEAN nCoeff_has_Units(const coeffs r)
returns TRUE, if r is not a field and r has non-trivial units
Definition: coeffs.h:818
n_R
single prescision (6,6) real numbers
Definition: coeffs.h:31
n_Sub
static FORCE_INLINE number n_Sub(number a, number b, const coeffs r)
return the difference of 'a' and 'b', i.e., a-b
Definition: coeffs.h:668
common.h
n_Zp
\F{p < 2^31}
Definition: coeffs.h:29
Print
#define Print
Definition: emacs.cc:79
CoeffsTestSuite::test_GF_toobig
void test_GF_toobig()
Definition: coeffs_test.h:406
NULLp
#define NULLp
Definition: auxiliary.h:108
globalPrintingFixture
static GlobalPrintingFixture globalPrintingFixture
Definition: coeffs_test.h:350
n_DivBy
static FORCE_INLINE BOOLEAN n_DivBy(number a, number b, const coeffs r)
test whether 'a' is divisible 'b'; for r encoding a field: TRUE iff 'b' does not represent zero in Z:...
Definition: coeffs.h:774
gnumpfl.h
assume
#define assume(x)
Definition: mod2.h:384
NULL
#define NULL
Definition: omList.c:11
nCoeff_is_Zn
static FORCE_INLINE BOOLEAN nCoeff_is_Zn(const coeffs r)
Definition: coeffs.h:847
n_Int
static FORCE_INLINE long n_Int(number &n, const coeffs r)
conversion of n to an int; 0 if not possible in Z/pZ: the representing int lying in (-p/2 ....
Definition: coeffs.h:546
CoeffsTestSuite::test_Z2m8
void test_Z2m8()
Definition: coeffs_test.h:372
CoeffsTestSuite::simple
void simple(const n_coeffType _type)
Definition: coeffs_test.h:380
n_Equal
static FORCE_INLINE BOOLEAN n_Equal(number a, number b, const coeffs r)
TRUE iff 'a' and 'b' represent the same number; they may have different representations.
Definition: coeffs.h:459
feResource.h
p
int p
Definition: cfModGcd.cc:4019
longrat.h
ZnmInfo
Definition: rmodulon.h:17
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
n_Div
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of 'a' and 'b', i.e., a/b; raises an error if 'b' is not invertible in r exceptio...
Definition: coeffs.h:614
PrintLn
void PrintLn()
Definition: reporter.cc:309
CoeffsTestSuite::test_GF
void test_GF()
Definition: coeffs_test.h:422
n_Test
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
Definition: coeffs.h:737
numbers.h
CoeffsTestSuite::test_Zn3
void test_Zn3()
Definition: coeffs_test.h:441
modulop.h
nKillChar
void nKillChar(coeffs r)
undo all initialisations
Definition: numbers.cc:510
nCoeff_has_simple_inverse
static FORCE_INLINE BOOLEAN nCoeff_has_simple_inverse(const coeffs r)
TRUE, if the computation of the inverse is fast, i.e. prefer leading coeff. 1 over content.
Definition: coeffs.h:923
CoeffsTestSuite::test_Z
void test_Z()
Definition: coeffs_test.h:398
nCoeff_is_Domain
static FORCE_INLINE BOOLEAN nCoeff_is_Domain(const coeffs r)
returns TRUE, if r is a field or r has no zero divisors (i.e is a domain)
Definition: coeffs.h:760
coeffs.h
CoeffsTestSuite::test_Q
void test_Q()
Definition: coeffs_test.h:387
CoeffsTestSuite::test_Z2m2
void test_Z2m2()
Definition: coeffs_test.h:455