source: git/libpolys/tests/coeffs_test.h @ 405407

jengelh-datetimespielwiese
Last change on this file since 405407 was 405407, checked in by Hans Schoenemann <hannes@…>, 9 years ago
fix: libcoeffs tests and gcc 4.8: inline routines exist several times (cannot test for equality of procedure variables)
  • Property mode set to 100644
File size: 9.9 KB
Line 
1#ifdef HAVE_CONFIG_H
2#include "libpolysconfig.h"
3#endif /* HAVE_CONFIG_H */
4#include <misc/auxiliary.h>
5#include <omalloc/omalloc.h>
6
7
8#include <reporter/reporter.h>
9#include <resources/feResource.h>
10
11#include <coeffs/coeffs.h>
12#include <coeffs/numbers.h>
13
14
15// the following headers are private...
16#include <coeffs/longrat.h>
17#include <coeffs/gnumpfl.h>
18#include <coeffs/gnumpc.h>
19#include <coeffs/shortfl.h>
20#include <coeffs/ffields.h>
21#include <coeffs/modulop.h>
22#include <coeffs/rmodulon.h>
23#include <coeffs/rmodulo2m.h>
24#include <coeffs/rintegers.h>
25
26
27#include "common.h"
28using namespace std;
29
30
31void TestSum(const coeffs r, const unsigned long N)
32{
33  clog << ( _2S("TEST: sum[0..") + _2S(N) + "]: ");
34  clog << endl;
35
36  assume( N > 0 ); // just for now...
37
38  const unsigned long ssss = (N * (N+1)) / 2;
39
40  number sum1 = n_Init(ssss, r);
41  clog<< "N*(N+1)/2 (int: " << ssss << "): "; PrintSized(sum1, r);
42
43  number s, ss, i, res;
44
45  s = n_Init(, r);
46  i = n_Init(N+1, r);
47  ndInpMult(s, i, r);
48  n_Delete(&i, r);
49
50  clog<< "N*(N+1): ("<< N*(N+1) << ")"; PrintSized(s, r);
51
52  i = n_Init(2, r);
53  clog<< "2: "; PrintSized(i, r);
54
55  if( !n_IsZero( i, r) )
56  {
57#ifdef HAVE_RINGS
58    TS_ASSERT( n_DivBy(s, i, r) );
59#endif
60
61    res = n_Div(s, i, r);
62
63    clog<< "N*(N+1)/2: "; PrintSized(res, r);
64
65
66    number d = n_Sub(res, sum1, r);
67    TS_ASSERT( n_IsZeroDivisor(d, r) );
68    n_Delete(&d, r);
69
70    if( n_GetChar(r) == 0 )
71    {
72      TS_ASSERT( n_Equal(sum1, res, r) );
73      TS_ASSERT( n_Equal(res, sum1, r) );
74    }
75  } else
76    TS_ASSERT_EQUALS( n_GetChar(r), 2);
77
78
79  n_Delete(&s, r);  n_Delete(&i, r);
80
81  n_Delete(&sum1, r); n_Delete(&res, r);
82
83
84  s = n_Init(0  , r);
85  ss = n_Init(0 , r);
86  for( int k = N; k >= 0; k-- )
87  {
88    i = n_Init(k, r);
89    ndInpAdd(s, i, r); // s += i
90
91    i = n_Neg(i, r);
92    ndInpAdd(ss, i, r); // ss -= i
93
94    n_Delete(&i, r);
95  }
96  clog<< "ss: "; PrintSized(ss, r);
97
98  ss = n_Neg(ss, r); // ss = -ss
99
100  clog<< "real sum    : "; PrintSized(s, r);
101  clog<< "real sum(--): "; PrintSized(ss, r);
102
103  TS_ASSERT( n_Equal(s, ss, r) );
104  TS_ASSERT( n_Equal(ss, s, r) );
105
106  n_Delete(&s, r);
107  n_Delete(&ss, r);
108
109  clog << ( " >>> TEST DONE!" );
110  clog << endl;
111
112}
113
114
115void TestArith(const coeffs r)
116{
117  clog << ("TEST: Simple Arithmetics: ");
118  clog << endl;
119
120  number two = n_Init(2, r);
121
122  number t = n_Init(1, r);
123  ndInpAdd(t, t, r);
124  TS_ASSERT( n_Equal(two, t, r) );
125  n_Delete(&t, r);
126
127  if( getCoeffType(r) == n_Q )
128  {
129    number t = n_Init(1, r);
130    nlInpAdd(t, t, r);
131    TS_ASSERT( n_Equal(two, t, r) );
132    n_Delete(&t, r);
133  }
134
135
136
137
138  const int N = 66666;
139
140  number a = n_Init(N, r);
141
142  clog<< "a: "; PrintSized(a, r);
143
144
145  clog<< "two: "; PrintSized(two, r);
146
147  number aa0 = n_Init(N*2, r);
148
149  number aa = n_Add(a, a, r);
150
151  clog<< "aa = a + a: "; PrintSized(aa, r);
152
153  number aa2 = n_Mult(a, two, r);
154
155  clog<< "aa2 = a * 2: "; PrintSized(aa2, r);
156
157  number aa1 = n_Mult(two, a, r);
158
159  clog<< "aa1 = 2 * a: "; PrintSized(aa1, r);
160
161  n_Delete(&a, r);
162  n_Delete(&two, r);
163
164
165  a = n_Sub( aa, aa1, r );
166
167  clog<< "a = aa - aa1: "; PrintSized(a, r);
168
169  TS_ASSERT( n_IsZero(a, r) );
170
171  n_Delete(&a, r);
172
173  a = n_Sub( aa, aa2, r );
174
175  clog<< "a = aa - aa2: "; PrintSized(a, r);
176
177  TS_ASSERT( n_IsZero(a, r) );
178
179  n_Delete(&a, r);
180
181
182  a = n_Sub( aa1, aa2, r );
183
184  clog<< "a = aa1 - aa2: "; PrintSized(a, r);
185
186  TS_ASSERT( n_IsZero(a, r) );
187
188  n_Delete(&a, r);
189
190
191
192  TS_ASSERT( n_Equal(aa, aa1, r) );
193  TS_ASSERT( n_Equal(aa, aa2, r) );
194  TS_ASSERT( n_Equal(aa1, aa2, r) );
195
196  TS_ASSERT( n_Equal(aa0, aa, r) );
197  TS_ASSERT( n_Equal(aa0, aa1, r) );
198  TS_ASSERT( n_Equal(aa0, aa2, r) );
199
200  n_Delete(&aa, r);
201  n_Delete(&aa1, r);
202  n_Delete(&aa2, r);
203
204  n_Delete(&aa0, r);
205
206  clog << ( " >>> TEST DONE!" );
207  clog << endl;
208
209}
210
211
212
213
214
215BOOLEAN Test(const n_coeffType type, void* p = NULLp)
216{
217
218  clog << endl;
219  clog << ( "----------------------- Testing coeffs: [" + _2S(type) +  ", " + _2S(p) + "]: -----------------------");
220  clog << endl;
221
222  const coeffs r = nInitChar( type, p );
223
224  if( r == NULLp )
225  {
226    clog << ( "Test: could not get this coeff. domain" );
227    return FALSE;
228  };
229
230  TS_ASSERT_DIFFERS( r->cfCoeffWrite, NULLp );
231
232  if( r->cfCoeffWrite != NULL )
233  {
234    clog << "Coeff-domain: "  << endl;
235    n_CoeffWrite(r); PrintLn();
236  }
237
238  if (n_NumberOfParameters(r) > 0) 
239  {
240    number z = n_Param(1, r); // also any integer instead of 0//?
241    PrintS("Parameter: "); PrintSized(z, r);
242    n_Delete(&z, r);   
243  }
244   
245
246  clog << "Char: " << n_GetChar(r) << endl;
247
248
249  TS_ASSERT_DIFFERS( r, NULLp );
250  nSetChar( r );
251  TS_ASSERT_EQUALS( getCoeffType(r), type );
252
253  TS_ASSERT_DIFFERS( r->cfInit, NULLp );
254  TS_ASSERT_DIFFERS( r->cfWriteLong, NULLp );
255  TS_ASSERT_DIFFERS( r->cfAdd, NULLp );
256  TS_ASSERT_DIFFERS( r->cfDelete, NULLp );
257
258  switch( type )
259  {
260    case n_Q:
261    {
262      //TS_ASSERT_EQUALS( r->cfInit, nlInit );
263      //TS_ASSERT_EQUALS( r->cfAdd, nlAdd );
264      //TS_ASSERT_EQUALS( r->cfDelete, nlDelete );
265
266      TS_ASSERT(  nCoeff_is_Q( r ));
267      TS_ASSERT(  nCoeff_is_Domain( r ));
268
269      TS_ASSERT( !nCoeff_has_Units( r )); // ?
270      TS_ASSERT( !nCoeff_has_simple_inverse( r ));// ?
271      TS_ASSERT( !nCoeff_has_simple_Alloc( r )); // ?
272
273      TS_ASSERT( !nCoeff_is_Ring_2toM( r ));
274      TS_ASSERT( !nCoeff_is_Ring_ModN( r ));
275      TS_ASSERT( !nCoeff_is_Ring_PtoM( r ));
276      TS_ASSERT( !nCoeff_is_Ring_Z( r ));
277      TS_ASSERT( !nCoeff_is_Ring( r ));
278      TS_ASSERT( !nCoeff_is_Zp( r ));
279      TS_ASSERT( !nCoeff_is_numeric( r ));
280      TS_ASSERT( !nCoeff_is_R( r ));
281      TS_ASSERT( !nCoeff_is_GF( r ));
282      TS_ASSERT( !nCoeff_is_long_R( r ));
283      TS_ASSERT( !nCoeff_is_long_C( r ));
284      TS_ASSERT( !nCoeff_is_CF( r ));
285      TS_ASSERT( !nCoeff_is_Extension( r ));
286
287      break;
288    }
289    case n_long_R:
290    {
291      //TS_ASSERT_EQUALS( r->cfInit, ngfInit );
292      //TS_ASSERT_EQUALS( r->cfAdd, ngfAdd );
293      //TS_ASSERT_EQUALS( r->cfDelete, ngfDelete );
294      break;
295    }
296    case n_long_C:
297    {
298//       TS_ASSERT_EQUALS( r->cfInit, ngcInit );
299//       TS_ASSERT_EQUALS( r->cfAdd, ngcAdd );
300//       TS_ASSERT_EQUALS( r->cfDelete, ngcDelete );
301      break;
302    }
303    case n_R:
304    {
305      //TS_ASSERT_EQUALS( r->cfInit, nrInit );
306      //TS_ASSERT_EQUALS( r->cfAdd, nrAdd );
307  //    TS_ASSERT_EQUALS( r->cfDelete, nrDelete ); // No?
308      break;
309    }
310    case n_GF:
311    {
312//       TS_ASSERT_EQUALS( r->cfInit, nfInit );
313//       TS_ASSERT_EQUALS( r->cfAdd, nfAdd );
314      //TS_ASSERT_EQUALS( r->cfDelete, nfDelete );
315      break;
316    }
317#ifdef HAVE_RINGS
318    case n_Z2m:
319    {
320      //TS_ASSERT_EQUALS( r->cfInit, nr2mInit );
321      //TS_ASSERT_EQUALS( r->cfAdd, nr2mAdd );
322      //TS_ASSERT_EQUALS( r->cfDelete, ndDelete );
323      break;
324    }
325    case n_Zn:
326    {
327      //TS_ASSERT_EQUALS( r->cfInit, nrnInit );
328      //TS_ASSERT_EQUALS( r->cfAdd, nrnAdd );
329      //TS_ASSERT_EQUALS( r->cfDelete, nrnDelete );
330      break;
331    }
332#endif
333    default:
334    {
335      // ...
336    }
337  }
338
339  TestArith( r );
340  TestSum( r, 10 );
341  TestSum( r, 100 );
342  TestSum( r, 101 );
343  TestSum( r, 1001 );
344  TestSum( r, 9000 );
345
346  nKillChar( r );
347
348  return TRUE;
349}
350
351
352
353// We can rely on this file being included exactly once
354// and declare this global variable in the header file.
355//
356static GlobalPrintingFixture globalPrintingFixture;
357
358
359class CoeffsTestSuite : public CxxTest::TestSuite
360{
361 public:
362//   void test_dummy() { float fnum = 2.00001f; TS_ASSERT_DELTA (fnum, 2.0f, 0.0001f);  }
363
364   void test_Z2m4()
365   {
366#ifdef HAVE_RINGS
367     n_coeffType type = n_Z2m;
368     TS_ASSERT( Test(type, (void*) 4) );
369#endif
370   }
371
372   void test_Zp101()
373   {
374     n_coeffType type = n_Zp;
375     TS_ASSERT( Test(type, (void*) 101) );
376   }
377
378   void test_Z2m8()
379   {
380#ifdef HAVE_RINGS
381     n_coeffType type =  n_Z2m;
382     TS_ASSERT( Test(type, (void*) 8) );
383#endif
384   }
385
386   void simple(const n_coeffType _type)
387   {
388     n_coeffType type = _type;
389     TS_ASSERT( type == _type ); // ?
390     TS_ASSERT( Test(type) );
391   }
392
393   void test_Q()
394   {
395     simple(n_Q);
396   }
397
398   void test_R()
399   {
400     simple(n_R);
401   }
402
403
404   void test_Z()
405   {
406#ifdef HAVE_RINGS
407     simple(n_Z);  // No need in GMP?
408#endif
409   }
410
411
412   void test_GF_toobig()
413   {
414     n_coeffType type = n_GF;
415
416     GFInfo param;
417
418     param.GFChar= 5;
419     param.GFDegree= 12;
420     param.GFPar_name= (const char*)"q";
421
422     TS_ASSERT( !Test(type, (void*) &param) );
423
424      // it should not be used by numbers... right?
425      // TODO: what is our policy wrt param-pointer-ownership?
426   }
427
428   void test_GF()
429   {
430     // TODO: what if it was already registered?
431     // Q: no way to deRegister a type?
432     n_coeffType type = n_GF;
433
434     GFInfo param;
435
436     param.GFChar= 5;
437     param.GFDegree= 2;
438     param.GFPar_name= (const char*)"Q";
439
440     TS_ASSERT( Test(type, (void*) &param) );
441
442      // it should not be used by numbers... right?
443      // TODO: what is our policy wrt param-pointer-ownership?
444   }
445
446
447   void test_Zn3()
448   {
449#ifdef HAVE_RINGS
450     n_coeffType type = n_Zn;
451
452     ZnmInfo Znmparam;
453     Znmparam.base= (mpz_ptr) omAlloc (sizeof (mpz_t));
454     mpz_init_set_ui (Znmparam.base, 3);
455     Znmparam.exp= 1;
456
457     TS_ASSERT( Test(type, (void*) &Znmparam) );
458#endif
459   }
460
461   void test_Z2m2()
462   {
463#ifdef HAVE_RINGS
464     n_coeffType type = n_Z2m;
465
466     TS_ASSERT( Test(type, (void*) 2) );
467#endif
468   }
469
470   void test_LR()
471   {
472     simple(n_long_R);
473   }
474
475   void test_LC()
476   {
477     simple(n_long_C);
478   }
479
480   void test_Q_special()
481   {
482     const coeffs cf = nInitChar(n_Q, NULLp);
483
484     if (cf == NULLp)
485       clog << ( "Test: could not get this coeff. domain" );
486
487     TS_ASSERT_DIFFERS(cf->cfCoeffWrite, NULLp);
488
489     if (cf->cfCoeffWrite != NULL )
490     {
491       clog << "Coeff-domain: "  << endl;
492       n_CoeffWrite(cf); PrintLn();
493     }
494
495     number q1 = n_Init(21, cf);
496     number q2 = n_Init(2, cf);
497     number q3 = n_Div(q1, q2, cf);
498     number q4 = n_Init(30, cf);
499     number q5 = n_Mult(q3, q4, cf);
500     TS_ASSERT(n_Test(q5, cf));
501     Print("21/2 * 30 = %d\n", n_Int(q5, cf));
502     TS_ASSERT(n_Test(q5, cf));
503     n_Delete(&q1, cf);
504     n_Delete(&q2, cf);
505     n_Delete(&q3, cf);
506     n_Delete(&q4, cf);
507     n_Delete(&q5, cf);
508   }
509};
510
Note: See TracBrowser for help on using the repository browser.