source: git/libpolys/tests/coeffs_test.h @ 9310cb

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