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

fieker-DuValspielwiese
Last change on this file since d9e190 was d9e190, checked in by Mohamed Barakat <mohamed.barakat@…>, 13 years ago
got rid of program_invocation_name (non-portable) and replaced it by an educated guess changed the test generation script to save a copy of the program name in main
  • Property mode set to 100644
File size: 10.6 KB
Line 
1#include <cxxtest/TestSuite.h>
2#include <cxxtest/GlobalFixture.h>
3
4#include "config.h"
5#include <misc/auxiliary.h>
6#include <omalloc/omalloc.h>
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
31namespace
32{
33
34void TestSum(const coeffs r, const unsigned long N)
35{
36  clog << ( _2S("TEST: sum[0..") + _2S(N) + "]: ");
37  clog << endl;
38
39  assume( N > 0 ); // just for now...
40
41  const unsigned long ssss = (N * (N+1)) / 2;
42 
43  number sum1 = n_Init(ssss, r);
44  clog<< "N*(N+1)/2 (int: " << ssss << "): "; PrintSized(sum1, r);
45
46  number s, ss, i, res;
47
48  s = n_Init(, r);
49  i = n_Init(N+1, r);
50  ndInpMult(s, i, r);
51  n_Delete(&i, r);
52 
53  clog<< "N*(N+1): ("<< N*(N+1) << ")"; PrintSized(s, r); 
54 
55  i = n_Init(2, r);
56  clog<< "2: "; PrintSized(i, r); 
57
58  if( !n_IsZero( i, r) )
59  {
60    TS_ASSERT( n_DivBy(s, i, r) );
61    res = n_Div(s, i, r);
62 
63    clog<< "N*(N+1)/2: "; PrintSized(res, r);
64    number d = n_Sub(res, sum1, r);
65   
66    TS_ASSERT( ndIsZeroDivisor(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 a = n_Init(66666, r);
119   
120  clog<< "a: "; PrintSized(a, r);
121
122  number two = n_Init(2, r);
123 
124  clog<< "two: "; PrintSized(two, r);
125
126  number aa = n_Add(a, a, r);
127
128  clog<< "aa = a + a: "; PrintSized(aa, r);
129 
130  number aa2 = n_Mult(a, two, r);
131
132  clog<< "aa2 = a * 2: "; PrintSized(aa2, r);
133
134  number aa1 = n_Mult(two, a, r);
135 
136  clog<< "aa1 = 2 * a: "; PrintSized(aa1, r);
137
138  n_Delete(&a, r);
139  n_Delete(&two, r);
140
141
142  a = n_Sub( aa, aa1, r );
143 
144  clog<< "a = aa - aa1: "; PrintSized(a, r);
145
146  TS_ASSERT( n_IsZero(a, r) );
147
148  n_Delete(&a, r);
149
150  a = n_Sub( aa, aa2, r );
151
152  clog<< "a = aa - aa2: "; PrintSized(a, r);
153
154  TS_ASSERT( n_IsZero(a, r) );
155
156  n_Delete(&a, r);
157
158
159  a = n_Sub( aa1, aa2, r );
160
161  clog<< "a = aa1 - aa2: "; PrintSized(a, r);
162
163  TS_ASSERT( n_IsZero(a, r) );
164
165  n_Delete(&a, r);
166
167
168 
169  TS_ASSERT( n_Equal(aa, aa1, r) );
170
171  TS_ASSERT( n_Equal(aa, aa2, r) );
172
173  TS_ASSERT( n_Equal(aa1, aa2, r) );
174 
175
176  n_Delete(&aa, r);
177  n_Delete(&aa1, r);
178  n_Delete(&aa2, r);
179
180
181  clog << ( " >>> TEST DONE!" );
182  clog << endl;
183
184}
185
186
187
188 
189
190BOOLEAN Test(const n_coeffType type, void* p = NULLp)
191{
192 
193  clog << endl;
194  clog << ( "----------------------- Testing coeffs: [" + _2S(type) +  ", " + _2S(p) + "]: -----------------------");
195  clog << endl;
196
197  const coeffs r = nInitChar( type, p );
198
199  if( r == NULLp )
200  {
201    clog << ( "Test: could not get this coeff. domain" );
202    return FALSE;
203  };
204
205  TS_ASSERT_DIFFERS( r->cfCoeffWrite, NULLp );
206
207  if( r->cfCoeffWrite != NULL )
208  {
209    clog << "Coeff-domain: "  << endl; 
210    n_CoeffWrite(r); PrintLn();
211  }
212
213
214  if (getCoeffType(r) == n_GF) //some special test for GF
215  {
216    number z = nfPar (0, r); // also any integer instead of 0//?
217    clog << "Generator: "; PrintSized(z, r);
218    n_Delete(&z, r);   
219  }
220
221  clog << "Char: " << n_GetChar(r) << endl; 
222
223 
224  TS_ASSERT_DIFFERS( r, NULLp );
225  nSetChar( r );
226  TS_ASSERT_EQUALS( getCoeffType(r), type );
227
228  TS_ASSERT_DIFFERS( r->cfInit, NULLp );
229  TS_ASSERT_DIFFERS( r->cfWrite, NULLp );
230  TS_ASSERT_DIFFERS( r->cfAdd, NULLp );
231  TS_ASSERT_DIFFERS( r->cfDelete, NULLp );
232
233  switch( type )
234  {
235    case n_Q:
236    {
237      TS_ASSERT_EQUALS( r->cfInit, nlInit );
238      TS_ASSERT_EQUALS( r->cfWrite, nlWrite );
239      TS_ASSERT_EQUALS( r->cfAdd, nlAdd );
240      TS_ASSERT_EQUALS( r->cfDelete, nlDelete );
241     
242      TS_ASSERT(  nCoeff_is_Q( r ));
243      TS_ASSERT(  nCoeff_is_Domain( r ));
244
245      TS_ASSERT( !nCoeff_has_Units( r )); // ?
246      TS_ASSERT( !nCoeff_has_simple_inverse( r ));// ?
247      TS_ASSERT( !nCoeff_has_simple_Alloc( r )); // ?
248
249      TS_ASSERT( !nCoeff_is_Ring_2toM( r ));
250      TS_ASSERT( !nCoeff_is_Ring_ModN( r ));
251      TS_ASSERT( !nCoeff_is_Ring_PtoM( r ));
252      TS_ASSERT( !nCoeff_is_Ring_Z( r ));
253      TS_ASSERT( !nCoeff_is_Ring( r ));
254      TS_ASSERT( !nCoeff_is_Zp( r ));
255      TS_ASSERT( !nCoeff_is_numeric( r ));
256      TS_ASSERT( !nCoeff_is_R( r ));
257      TS_ASSERT( !nCoeff_is_Q_a( r ));
258      TS_ASSERT( !nCoeff_is_Zp_a( r ));
259      TS_ASSERT( !nCoeff_is_GF( r ));
260      TS_ASSERT( !nCoeff_is_long_R( r ));
261      TS_ASSERT( !nCoeff_is_long_C( r ));
262      TS_ASSERT( !nCoeff_is_CF( r ));
263      TS_ASSERT( !nCoeff_is_Extension( r ));
264     
265      break;
266    }
267    case n_long_R:
268    {
269      TS_ASSERT_EQUALS( r->cfInit, ngfInit );
270      TS_ASSERT_EQUALS( r->cfWrite, ngfWrite );
271      TS_ASSERT_EQUALS( r->cfAdd, ngfAdd );
272      TS_ASSERT_EQUALS( r->cfDelete, ngfDelete );
273      break;
274    }
275    case n_long_C:
276    {
277      TS_ASSERT_EQUALS( r->cfInit, ngcInit );
278      TS_ASSERT_EQUALS( r->cfWrite, ngcWrite );
279      TS_ASSERT_EQUALS( r->cfAdd, ngcAdd );
280      TS_ASSERT_EQUALS( r->cfDelete, ngcDelete );   
281      break;
282    }
283    case n_R:
284    {
285      TS_ASSERT_EQUALS( r->cfInit, nrInit );
286      TS_ASSERT_EQUALS( r->cfWrite, nrWrite );
287      TS_ASSERT_EQUALS( r->cfAdd, nrAdd );
288  //    TS_ASSERT_EQUALS( r->cfDelete, nrDelete ); // No?
289      break;
290    }
291    case n_GF:
292    {
293      TS_ASSERT_EQUALS( r->cfInit, nfInit );
294      TS_ASSERT_EQUALS( r->cfWrite, nfWrite );
295      TS_ASSERT_EQUALS( r->cfAdd, nfAdd );
296      //TS_ASSERT_EQUALS( r->cfDelete, nfDelete );
297      break;
298    }
299#ifdef HAVE_RINGS
300    case n_Z2m:
301    {
302      TS_ASSERT_EQUALS( r->cfInit, nr2mInit );
303      TS_ASSERT_EQUALS( r->cfWrite, nr2mWrite );
304      TS_ASSERT_EQUALS( r->cfAdd, nr2mAdd );
305      TS_ASSERT_EQUALS( r->cfDelete, ndDelete );
306      break;
307    }
308    case n_Zn:
309    {
310      TS_ASSERT_EQUALS( r->cfInit, nrnInit );
311      TS_ASSERT_EQUALS( r->cfWrite, nrnWrite );
312      TS_ASSERT_EQUALS( r->cfAdd, nrnAdd );
313      TS_ASSERT_EQUALS( r->cfDelete, nrnDelete );
314      break;
315    }
316#endif
317    default:
318    {
319      // ...
320    }
321  }
322
323  TestArith( r );
324  TestSum( r, 10 );
325  TestSum( r, 100 );
326  TestSum( r, 101 );
327  TestSum( r, 1001 );
328  TestSum( r, 9000 );
329
330  nKillChar( r );
331
332  return TRUE;
333}
334
335
336}
337
338
339
340class GlobalPrintingFixture : public CxxTest::GlobalFixture
341{
342  public:
343    bool setUpWorld() {
344      clog << endl << ( "<world>" ) << endl;
345      feInitResources(argv0);
346      return true;
347    }
348    bool tearDownWorld() { clog << endl <<( "</world>" )  << endl; return true; }
349    bool setUp() { clog << endl <<( "<test>" )  << endl; return true; }
350    bool tearDown() { clog << endl <<( "</test>" )  << endl; return true; }
351};
352
353
354//
355// We can rely on this file being included exactly once
356// and declare this global variable in the header file.
357//
358static GlobalPrintingFixture globalPrintingFixture;
359
360
361class CoeffsTestSuite : public CxxTest::TestSuite
362{
363 public:
364//   void test_dummy() { float fnum = 2.00001f; TS_ASSERT_DELTA (fnum, 2.0f, 0.0001f);  }
365
366   void test_Z2m4()
367   {
368#ifdef HAVE_RINGS
369     n_coeffType type = nRegister( n_Z2m, nr2mInitChar); TS_ASSERT( type == n_Z2m ); 
370     TS_ASSERT( Test(type, (void*) 4) );
371#endif
372   }
373
374   void test_Zp101()
375   {
376     n_coeffType type = nRegister( n_Zp, npInitChar); TS_ASSERT( type == n_Zp );
377     TS_ASSERT( Test(type, (void*) 101) );
378   }
379
380   void test_Z2m8()
381   {
382#ifdef HAVE_RINGS
383     n_coeffType type = nRegister( n_Z2m, nr2mInitChar); TS_ASSERT( type == n_Z2m ); 
384     TS_ASSERT( Test(type, (void*) 8) );
385#endif
386   }
387   
388   void simple(const n_coeffType _type, cfInitCharProc p)
389   {
390     n_coeffType type = nRegister( _type, p);
391     TS_ASSERT( type == _type ); // ?
392     TS_ASSERT( Test(type) );
393   }
394   
395   void test_Q()
396   {
397     simple(n_Q, nlInitChar);
398   }
399   
400   void test_R()
401   {
402     simple(n_R, nrInitChar);
403   }
404
405
406   void test_Z()
407   {
408#ifdef HAVE_RINGS
409     simple(n_Z, nrzInitChar);  // No need in GMP?
410#endif
411   }
412
413   
414   void test_GF_toobig()
415   {
416     n_coeffType type = nRegister( n_GF, nfInitChar);
417     TS_ASSERT( type == n_GF );
418
419     GFInfo param;
420
421     param.GFChar= 5;
422     param.GFDegree= 12;
423     param.GFPar_name= (const char*)"q";
424
425     TS_ASSERT( !Test(type, (void*) &param) );
426
427      // it should not be used by numbers... right?
428      // TODO: what is our policy wrt param-pointer-ownership?
429   }
430
431   void test_GF()
432   {
433     // TODO: what if it was already registered?
434     // Q: no way to deRegister a type?
435     n_coeffType type = nRegister( n_GF, nfInitChar);
436     TS_ASSERT( type == n_GF );
437
438     GFInfo param;
439
440     param.GFChar= 5;
441     param.GFDegree= 2;
442     param.GFPar_name= (const char*)"Q";
443
444     TS_ASSERT( Test(type, (void*) &param) );
445
446      // it should not be used by numbers... right?
447      // TODO: what is our policy wrt param-pointer-ownership?
448   }
449   
450
451   void test_Zn3()
452   {
453#ifdef HAVE_RINGS
454     //  TODO(Somebody, This will result in memory corruption at Z_2^m later on (due to the succs. setGMPFloatDigits?)...!?); // ????
455     n_coeffType type = nRegister( n_Zn, nrnInitChar); TS_ASSERT( 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 = nRegister( n_Z2m, nr2mInitChar); TS_ASSERT( type == n_Z2m );
465
466     TS_ASSERT( Test(type, (void*) 2) );
467#endif
468   }
469
470   TODO(Somebody, floating arithmetics via GMP rely on two global variables (see setGMPFloatDigits). Please fix it!);
471
472   void test_LR()
473   {
474     setGMPFloatDigits( 10, 5 ); // Init global variables in mpr_complex.cc for gmp_float's... // Note that this seems also to be required for Z_2^m (and Zn?)!????
475     simple(n_long_R, ngfInitChar);
476   }
477   
478   void test_LC()
479   {
480     setGMPFloatDigits( 10, 5 ); // Init global variables in mpr_complex.cc for gmp_float's... // Note that this seems also to be required for Z_2^m (and Zn?)!????
481     simple(n_long_C, ngcInitChar);
482   } 
483
484   
485   // polynomial rings needed for extentions: n_Zp_a, n_Q_a!
486   
487};
488
Note: See TracBrowser for help on using the repository browser.