source: git/libpolys/tests/coeffs_test.h @ 488808e

jengelh-datetimespielwiese
Last change on this file since 488808e was 488808e, checked in by Frank Seelisch <seelisch@…>, 12 years ago
removed calls to nCoeff_is_Q_a and nCoeff_is_Zp_a (kept definitions for compatibility towards svn trunk); changed map in algext.cc
  • Property mode set to 100644
File size: 10.5 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 = nRegister( n_Z2m, nr2mInitChar); TS_ASSERT( type == n_Z2m ); 
373     TS_ASSERT( Test(type, (void*) 4) );
374#endif
375   }
376
377   void test_Zp101()
378   {
379     n_coeffType type = nRegister( n_Zp, npInitChar); TS_ASSERT( 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 = nRegister( n_Z2m, nr2mInitChar); TS_ASSERT( type == n_Z2m ); 
387     TS_ASSERT( Test(type, (void*) 8) );
388#endif
389   }
390   
391   void simple(const n_coeffType _type, cfInitCharProc p)
392   {
393     n_coeffType type = nRegister( _type, p);
394     TS_ASSERT( type == _type ); // ?
395     TS_ASSERT( Test(type) );
396   }
397   
398   void test_Q()
399   {
400     simple(n_Q, nlInitChar);
401   }
402   
403   void test_R()
404   {
405     simple(n_R, nrInitChar);
406   }
407
408
409   void test_Z()
410   {
411#ifdef HAVE_RINGS
412     simple(n_Z, nrzInitChar);  // No need in GMP?
413#endif
414   }
415
416   
417   void test_GF_toobig()
418   {
419     n_coeffType type = nRegister( n_GF, nfInitChar);
420     TS_ASSERT( type == n_GF );
421
422     GFInfo param;
423
424     param.GFChar= 5;
425     param.GFDegree= 12;
426     param.GFPar_name= (const char*)"q";
427
428     TS_ASSERT( !Test(type, (void*) &param) );
429
430      // it should not be used by numbers... right?
431      // TODO: what is our policy wrt param-pointer-ownership?
432   }
433
434   void test_GF()
435   {
436     // TODO: what if it was already registered?
437     // Q: no way to deRegister a type?
438     n_coeffType type = nRegister( n_GF, nfInitChar);
439     TS_ASSERT( type == n_GF );
440
441     GFInfo param;
442
443     param.GFChar= 5;
444     param.GFDegree= 2;
445     param.GFPar_name= (const char*)"Q";
446
447     TS_ASSERT( Test(type, (void*) &param) );
448
449      // it should not be used by numbers... right?
450      // TODO: what is our policy wrt param-pointer-ownership?
451   }
452   
453
454   void test_Zn3()
455   {
456#ifdef HAVE_RINGS
457     //  TODO(Somebody, This will result in memory corruption at Z_2^m later on (due to the succs. setGMPFloatDigits?)...!?); // ????
458     n_coeffType type = nRegister( n_Zn, nrnInitChar); TS_ASSERT( type == n_Zn );
459
460     TS_ASSERT( Test(type, (void*) 3) );
461#endif
462   }
463
464   void test_Z2m2()
465   {
466#ifdef HAVE_RINGS
467     n_coeffType type = nRegister( n_Z2m, nr2mInitChar); TS_ASSERT( type == n_Z2m );
468
469     TS_ASSERT( Test(type, (void*) 2) );
470#endif
471   }
472
473   TODO(Somebody, floating arithmetics via GMP rely on two global variables (see setGMPFloatDigits). Please fix it!);
474
475   void test_LR()
476   {
477     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?)!????
478     simple(n_long_R, ngfInitChar);
479   }
480   
481   void test_LC()
482   {
483     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?)!????
484     simple(n_long_C, ngcInitChar);
485   } 
486
487   
488   // polynomial rings needed for extentions: n_algExt, n_transExt !
489   
490};
491
Note: See TracBrowser for help on using the repository browser.