source: git/libpolys/tests/polys_test.h @ 010f3b

spielwiese
Last change on this file since 010f3b was 010f3b, checked in by Frank Seelisch <seelisch@…>, 13 years ago
more tests for transcendental case
  • Property mode set to 100644
File size: 24.0 KB
Line 
1#include "config.h"
2
3#include "common.h"
4using namespace std;
5
6// the following headers are private...
7#include <coeffs/longrat.h>
8#include <coeffs/gnumpfl.h>
9#include <coeffs/gnumpc.h>
10#include <coeffs/shortfl.h>
11#include <coeffs/ffields.h>
12#include <coeffs/modulop.h>
13#include <coeffs/rmodulon.h>
14#include <coeffs/rmodulo2m.h>
15#include <coeffs/rintegers.h>
16
17#include <polys/ext_fields/algext.h>
18#include <polys/ext_fields/transext.h>
19#include <polys/monomials/ring.h>
20#include <polys/monomials/p_polys.h>
21
22#include <polys/simpleideals.h>
23
24#if 0 //ifdef HAVE_FACTORY
25#include <polys/clapsing.h>
26#include <factory/factory.h>
27#endif
28
29class MyGlobalPrintingFixture : public GlobalPrintingFixture
30{
31  public:
32    virtual bool setUpWorld()
33    {
34
35      GlobalPrintingFixture::setUpWorld();
36
37
38      //TS_ASSERT_EQUALS( nRegister( n_Zp, npInitChar), n_Zp );
39      //TS_ASSERT_EQUALS( nRegister( n_GF, nfInitChar), n_GF );
40      //TS_ASSERT_EQUALS( nRegister( n_R, nrInitChar), n_R );
41      //TS_ASSERT_EQUALS( nRegister( n_Q, nlInitChar), n_Q );
42      //TS_ASSERT_EQUALS( nRegister( n_R, nrInitChar), n_R );
43
44#ifdef HAVE_RINGS
45      //TS_ASSERT_EQUALS( nRegister( n_Z, nrzInitChar), n_Z ); // these are UNusable at the moment!
46#endif
47
48      return true;
49    }
50};
51
52
53//
54// We can rely on this file being included exactly once
55// and declare this global variable in the header file.
56//
57static MyGlobalPrintingFixture globalPrintingFixture;
58
59
60namespace
61{
62
63  void PrintRing(const ring r)
64  {
65    rWrite(r); PrintLn();
66  #ifdef  RDEBUG
67    rDebugPrint(r); PrintLn();
68  #endif
69  }
70
71  static inline std::string _2S(poly a, const ring r)
72  {
73    p_Test(a,r);
74
75    StringSetS("");
76    p_Write(a, r);
77
78    const char* s = StringAppendS("");
79
80    std::stringstream ss;  ss << s;
81
82    StringSetS("");
83    return ss.str();
84  }
85
86  static inline void PrintSized(/*const*/ poly a, const ring r, BOOLEAN eoln = TRUE)
87  {
88    std::clog << _2S(a, r) << ", of size: " << p_Size(a, r);
89
90    if( eoln )
91      std::clog << std::endl;
92  }
93
94static inline void Delete(poly &p, const ring r)
95{
96  if( p != NULL )
97    p_Delete(&p, r);
98
99  p = NULL;
100}
101
102void TestSum(const ring r, const int N)
103{
104  TS_ASSERT_DIFFERS( r    , NULLp);
105  TS_ASSERT_DIFFERS( r->cf, NULLp);
106
107
108  clog << ( _2S("TEST: sum[0..") + _2S(N) + "]: ");
109  clog << endl;
110
111  assume( N > 0 ); // just for now...
112
113  const int ssss = (N * (N+1)) / 2;
114
115  poly sum1 = p_ISet(ssss, r);
116  clog<< "poly(N*(N+1)/2) (int: " << ssss << "): "; PrintSized(sum1, r);
117
118  poly s=NULL, ss=NULL, i=NULL, res=NULL;
119
120  s = p_ISet(, r);
121  i = p_ISet(N+1, r);
122
123  i = p_Mult_q(s, i, r); s = NULL;
124
125  clog<< "poly(N)*poly(N+1): (int: "<< N*(N+1) << "): "; PrintSized(i, r);
126
127  number t = n_Init(2, r->cf);
128  clog<< "number(2): "; PrintSized(t, r->cf);
129
130  if( !n_IsZero( t, r->cf) )
131  {
132    if( i != NULL )
133    {
134      number ii = p_GetCoeff(i, r);
135      clog<< "number(poly(N)*poly(N+1)): "; PrintSized(ii, r->cf);
136
137#ifdef HAVE_RINGS
138      TS_ASSERT( n_DivBy(ii, t, r->cf) );
139#endif
140       res = p_Div_nn(i, t, r); i = NULL;
141    }
142
143
144
145    clog<< "(poly(N)*poly(N+1))/number(2): "; PrintSized(res, r);
146    poly d = p_Sub(p_Copy(res, r), p_Copy(sum1, r), r);
147
148    if( d != NULL )
149      TS_ASSERT( n_IsZeroDivisor(p_GetCoeff(d, r), r->cf) );
150
151    Delete(d, r);
152
153    if( n_GetChar(r->cf) == 0 )
154    {
155      TS_ASSERT( p_EqualPolys(sum1, res, r) );
156      TS_ASSERT( p_EqualPolys(res, sum1, r) );
157    }
158  } else
159    TS_ASSERT_EQUALS( n_GetChar(r->cf), 2);
160
161  n_Delete(&t, r->cf);
162
163
164  s = NULL;
165  ss = NULL;
166  for( int k = N; k >= 0; k-- )
167  {
168    i = p_ISet(k, r);
169    s = p_Add_q(s, i, r); // s += i
170
171    i = p_Neg( p_ISet(k, r), r );
172    ss = p_Add_q(ss, i, r); // ss -= i
173  }
174
175  clog<< "ss(-sum): "; PrintSized(ss, r);
176
177  ss = p_Neg(ss, r); // ss = -ss
178
179  clog<< "real sum    : "; PrintSized(s, r);
180  clog<< "real sum(--): "; PrintSized(ss, r);
181
182  TS_ASSERT( p_EqualPolys(s, ss, r) );
183  TS_ASSERT( p_EqualPolys(ss, s, r) );
184
185  TODO(somebody, fix the delete method!);
186
187  Delete(sum1, r);
188  Delete(res, r);
189
190  Delete(s, r);
191  Delete(ss, r);
192
193  clog << ( " >>> TEST DONE!" );
194  clog << endl;
195
196}
197
198void Test(const ring r)
199{
200  if( r == NULL )
201      TS_FAIL("Could not get needed ring");
202  else
203  {
204    TestSum( r, 10 );
205    TestSum( r, 100 );
206    TestSum( r, 101 );
207    TestSum( r, 1001 );
208    TestSum( r, 9000 );
209  }
210}
211
212}
213
214class PolysTestSuite : public CxxTest::TestSuite
215{
216private:
217  /* replaces p by p + c * var(i)^exp (in-place);
218     expects exp >= 0 */
219  void plusTerm(poly &p, int c, int i, int exp, const ring r)
220  {
221    poly t = p_ISet(c, r); p_SetExp(t, i, exp, r); p_Setm(t, r);
222    p = p_Add_q(p, t, r);
223  }
224  void checkInverse(number n, const coeffs cf)
225  {
226    clog << "n = "; p_Write((poly)n, cf->extRing);
227    number n1 = n_Invers(n, cf);
228    clog << "==> n^(-1) = "; p_Write((poly)n1, cf->extRing);
229    number n2 = n_Mult(n, n1, cf);
230    clog << "check: n * n^(-1) = "; p_Write((poly)n2, cf->extRing);
231    TS_ASSERT( n_IsOne(n2, cf) );
232    n_Delete(&n1, cf); n_Delete(&n2, cf);
233  }
234  /* assumes that cf represents a rational function field;
235     does NOT copy p, i.e. uses p directly inside the resulting number */
236  number toFractionNumber(poly p, const coeffs cf)
237  {
238    number n = n_Init(1, cf);
239    fraction f = (fraction)n;
240    p_Delete(&(f->numerator), cf->extRing);
241    f->numerator = p;
242    return n;
243  }
244  void TestArithCf(const coeffs r)
245  {
246    clog << ("TEST: Simple Arithmetics: ");
247    clog << endl;
248
249    number two = n_Init(2, r);
250
251    number t = n_Init(1, r);
252    ndInpAdd(t, t, r);
253    TS_ASSERT( n_Equal(two, t, r) );
254    n_Delete(&t, r);
255
256    if( getCoeffType(r) == n_Q )
257    {
258      number t = n_Init(1, r);
259      nlInpAdd(t, t, r);
260      TS_ASSERT( n_Equal(two, t, r) );
261      n_Delete(&t, r);
262    }
263
264    const int N = 66666;
265
266    number a = n_Init(N, r);
267
268    clog<< "a: "; PrintSized(a, r);
269
270    clog<< "two: "; PrintSized(two, r);
271
272    number aa0 = n_Init(N*2, r);
273
274    number aa = n_Add(a, a, r);
275
276    clog<< "aa = a + a: "; PrintSized(aa, r);
277
278    number aa2 = n_Mult(a, two, r);
279
280    clog<< "aa2 = a * 2: "; PrintSized(aa2, r);
281
282    number aa1 = n_Mult(two, a, r);
283
284    clog<< "aa1 = 2 * a: "; PrintSized(aa1, r);
285
286    n_Delete(&a, r);
287    n_Delete(&two, r);
288
289    a = n_Sub( aa, aa1, r );
290
291    clog<< "a = aa - aa1: "; PrintSized(a, r);
292
293    TS_ASSERT( n_IsZero(a, r) );
294
295    n_Delete(&a, r);
296
297    a = n_Sub( aa, aa2, r );
298
299    clog<< "a = aa - aa2: "; PrintSized(a, r);
300
301    TS_ASSERT( n_IsZero(a, r) );
302
303    n_Delete(&a, r);
304
305    a = n_Sub( aa1, aa2, r );
306
307    clog<< "a = aa1 - aa2: "; PrintSized(a, r);
308
309    TS_ASSERT( n_IsZero(a, r) );
310
311    n_Delete(&a, r);
312
313    TS_ASSERT( n_Equal(aa, aa1, r) );
314    TS_ASSERT( n_Equal(aa, aa2, r) );
315    TS_ASSERT( n_Equal(aa1, aa2, r) );
316
317    TS_ASSERT( n_Equal(aa0, aa, r) );
318    TS_ASSERT( n_Equal(aa0, aa1, r) );
319    TS_ASSERT( n_Equal(aa0, aa2, r) );
320
321    n_Delete(&aa, r);
322    n_Delete(&aa1, r);
323    n_Delete(&aa2, r);
324
325    n_Delete(&aa0, r);
326
327    clog << ( " >>> TEST DONE!" );
328    clog << endl;
329  }
330  void TestSumCf(const coeffs r, const unsigned long N)
331  {
332    clog << ( _2S("TEST: sum[0..") + _2S(N) + "]: ");
333    clog << endl;
334
335    assume( N > 0 ); // just for now...
336
337    const unsigned long ssss = (N * (N+1)) / 2;
338
339    number sum1 = n_Init(ssss, r);
340    clog<< "N*(N+1)/2 (int: " << ssss << "): "; PrintSized(sum1, r);
341
342    number s, ss, i, res;
343
344    s = n_Init(, r);
345    i = n_Init(N+1, r);
346    ndInpMult(s, i, r);
347    n_Delete(&i, r);
348
349    clog<< "N*(N+1): ("<< N*(N+1) << ")"; PrintSized(s, r);
350
351    i = n_Init(2, r);
352    clog<< "2: "; PrintSized(i, r);
353
354    if( !n_IsZero( i, r) )
355    {
356  #ifdef HAVE_RINGS
357      TS_ASSERT( n_DivBy(s, i, r) );
358  #endif
359
360      res = n_Div(s, i, r);
361
362      clog<< "N*(N+1)/2: "; PrintSized(res, r);
363
364
365      number d = n_Sub(res, sum1, r);
366      TS_ASSERT( n_IsZeroDivisor(d, r) );
367      n_Delete(&d, r);
368
369      if( n_GetChar(r) == 0 )
370      {
371        TS_ASSERT( n_Equal(sum1, res, r) );
372        TS_ASSERT( n_Equal(res, sum1, r) );
373      }
374    } else
375      TS_ASSERT_EQUALS( n_GetChar(r), 2);
376
377
378    n_Delete(&s, r);  n_Delete(&i, r);
379
380    n_Delete(&sum1, r); n_Delete(&res, r);
381
382
383    s = n_Init(0  , r);
384    ss = n_Init(0 , r);
385    for( int k = N; k >= 0; k-- )
386    {
387      i = n_Init(k, r);
388      ndInpAdd(s, i, r); // s += i
389
390      i = n_Neg(i, r);
391      ndInpAdd(ss, i, r); // ss -= i
392
393      n_Delete(&i, r);
394    }
395    clog<< "ss: "; PrintSized(ss, r);
396
397    ss = n_Neg(ss, r); // ss = -ss
398
399    clog<< "real sum    : "; PrintSized(s, r);
400    clog<< "real sum(--): "; PrintSized(ss, r);
401
402    TS_ASSERT( n_Equal(s, ss, r) );
403    TS_ASSERT( n_Equal(ss, s, r) );
404
405    n_Delete(&s, r);
406    n_Delete(&ss, r);
407
408    clog << ( " >>> TEST DONE!" );
409    clog << endl;
410
411  }
412public:
413  void test_Z13_t()
414  {
415    clog << "Creating  Z/13[t]: " << endl;
416
417    char* n[] = {"t"};
418    ring r = rDefault( 13, 1, n);
419    TS_ASSERT_DIFFERS( r, NULLp );
420
421    PrintRing(r);
422
423    TS_ASSERT( rField_is_Domain(r) );
424    TS_ASSERT( !rField_is_Q(r) );
425
426    TS_ASSERT( rField_is_Zp(r) );
427    TS_ASSERT( !rField_is_Zp(r, 11) );
428    TS_ASSERT( rField_is_Zp(r, 13) );
429
430    TS_ASSERT_EQUALS( rVar(r), 1);
431
432    Test(r);
433
434    rDelete(r);
435  }
436
437  void test_QQ_t()
438  {
439    clog << "Creating  Q[s]: " << endl;
440
441    char* n[] = {"s"};
442    ring r = rDefault( 0, 1, n);
443    TS_ASSERT_DIFFERS( r, NULLp );
444
445    PrintRing(r);
446
447    TS_ASSERT( rField_is_Domain(r) );
448    TS_ASSERT( rField_is_Q(r) );
449
450    TS_ASSERT( !rField_is_Zp(r) );
451    TS_ASSERT( !rField_is_Zp(r, 11) );
452
453    TS_ASSERT_EQUALS( rVar(r), 1);
454
455    Test(r);
456
457    rDelete(r);
458  }
459
460  void test_Z11_x_y_z()
461  {
462     clog << "Creating  Z/11[x, y, z]: " << endl;
463
464     char* n[] = {"x", "y", "z"};
465     ring r = rDefault( 11, 3, n);
466     TS_ASSERT_DIFFERS( r, NULLp );
467
468     PrintRing(r);
469
470     TS_ASSERT( rField_is_Domain(r) );
471     TS_ASSERT( !rField_is_Q(r) );
472
473     TS_ASSERT( rField_is_Zp(r) );
474     TS_ASSERT( rField_is_Zp(r, 11) );
475     TS_ASSERT( !rField_is_Zp(r, 13) );
476
477     TS_ASSERT_EQUALS( rVar(r), 3);
478
479     Test(r);
480
481     rDelete(r);
482  }
483   void test_QQ_x_y_z()
484   {
485     clog << "Creating  QQ[x, y, z, u]: " << endl;
486
487     char* n[] = {"x", "y", "z", "u"};
488     ring r = rDefault( 0, 4, n);
489     TS_ASSERT_DIFFERS( r, NULLp );
490
491     PrintRing(r);
492
493     TS_ASSERT( rField_is_Domain(r) );
494     TS_ASSERT( rField_is_Q(r) );
495
496     TS_ASSERT( !rField_is_Zp(r) );
497     TS_ASSERT( !rField_is_Zp(r, 11) );
498
499     TS_ASSERT_EQUALS( rVar(r), 4);
500
501     Test(r);
502
503     rDelete(r);
504   }
505
506
507   void test_Z13_t_GF()
508   {
509     clog << "Creating  GF[t]: " << endl;
510
511     char* n[] = {"t"};
512
513     GFInfo param;
514
515     param.GFChar= 5;
516     param.GFDegree= 2;
517     param.GFPar_name= (const char*)"Q";
518
519     const coeffs cf = nInitChar( n_GF, &param );
520
521     if( cf == NULL )
522       TS_FAIL("Could not get needed coeff. domain");
523
524     TS_ASSERT_DIFFERS( cf, NULLp );
525
526     ring r = rDefault( cf, 1, n);  // now cf belongs to r!
527     TS_ASSERT_DIFFERS( r, NULLp );
528
529     PrintRing(r);
530
531     TS_ASSERT( rField_is_Domain(r) );
532     TS_ASSERT( !rField_is_Q(r) );
533
534     TS_ASSERT( !rField_is_Zp(r) );
535     TS_ASSERT( !rField_is_Zp(r, 11) );
536     TS_ASSERT( !rField_is_Zp(r, 13) );
537     TS_ASSERT( rField_is_GF(r) );
538
539     TS_ASSERT( rField_is_GF(r, 5) );
540     TS_ASSERT( !rField_is_GF(r, 25) );
541
542     TS_ASSERT_EQUALS( rVar(r), 1);
543
544     Test(r);
545
546     rDelete(r); // kills 'cf' as well!
547   }
548
549  void test_Q_Ext_a()
550  {
551    clog << "Start by creating Q[a]..." << endl;
552
553    char* n[] = {"a"};
554    ring r = rDefault( 0, 1, n);   // Q[a]
555    TS_ASSERT_DIFFERS( r, NULLp );
556
557    PrintRing(r);
558
559    TS_ASSERT( rField_is_Domain(r) );
560    TS_ASSERT( rField_is_Q(r) );
561
562    TS_ASSERT( !rField_is_Zp(r) );
563    TS_ASSERT( !rField_is_Zp(r, 11) );
564
565    TS_ASSERT_EQUALS( rVar(r), 1);
566
567    poly minPoly = p_ISet(1, r);                    // minPoly = 1
568    p_SetExp(minPoly, 1, 2, r); p_Setm(minPoly, r); // minPoly = a^2
569    minPoly = p_Add_q(minPoly, p_ISet(1, r), r);    // minPoly = a^2 + 1
570    ideal minIdeal = idInit(1);                     // minIdeal = < 0 >
571    minIdeal->m[0] = minPoly;                       // minIdeal = < a^2 + 1 >
572
573    n_coeffType type = nRegister(n_algExt, naInitChar);
574    TS_ASSERT(type == n_algExt);
575
576    AlgExtInfo extParam;
577    extParam.r = r;
578    extParam.i = minIdeal;
579
580    clog << "Next create the extension field Q[a]/<a2+1>..." << endl;
581
582    const coeffs cf = nInitChar(type, &extParam);   // Q[a]/<a2+1>
583
584    if( cf == NULL )
585      TS_FAIL("Could not get needed coeff. domain");
586
587    TS_ASSERT_DIFFERS( cf->cfCoeffWrite, NULLp );
588
589    if( cf->cfCoeffWrite != NULL )
590    {
591      clog << "Coeff-domain: "  << endl;
592      n_CoeffWrite(cf); PrintLn();
593    }
594
595    TS_ASSERT( nCoeff_is_algExt(cf) );
596    TS_ASSERT( !nCoeff_is_transExt(cf) );
597
598    // some tests for the coefficient field represented by cf:
599    TestArithCf(cf);
600    TestSumCf(cf, 10);
601    TestSumCf(cf, 100);
602    TestSumCf(cf, 101);
603    TestSumCf(cf, 1001);
604    TestSumCf(cf, 2000);
605
606    clog << "Finally create the polynomial ring (Q[a]/<a2+1>)[x, y]..."
607         << endl;
608
609    char* m[] = {"x", "y"};
610    ring s = rDefault(cf, 2, m);   // (Q[a]/<a2+1>)[x, y]
611    TS_ASSERT_DIFFERS(s, NULLp);
612
613    PrintRing(s);
614
615    TS_ASSERT( rField_is_Domain(s) );
616    TS_ASSERT( !rField_is_Q(s) );
617    TS_ASSERT( !rField_is_Zp(s) );
618    TS_ASSERT( !rField_is_Zp(s, 11) );
619    TS_ASSERT( !rField_is_Zp(s, 13) );
620    TS_ASSERT( !rField_is_GF(s) );
621    TS_ASSERT( rField_is_Extension(s) );
622    TS_ASSERT( !rField_is_GF(s, 25) );
623    TS_ASSERT_EQUALS(rVar(s), 2);
624
625    Test(s);
626
627    clog << endl
628         << "Now let's compute some inverses in Q[a]/<a^2+1>..."
629         << endl;
630
631    poly u;
632    u = NULL; plusTerm(u, 1, 1, 1, cf->extRing);
633    plusTerm(u, 1, 1, 0, cf->extRing);  // a + 1
634    checkInverse((number)u, cf); p_Delete(&u, cf->extRing);
635    u = NULL; plusTerm(u, 1, 1, 1, cf->extRing);
636    plusTerm(u, -1, 1, 0, cf->extRing); // a - 1
637    checkInverse((number)u, cf); p_Delete(&u, cf->extRing);
638    u = NULL; plusTerm(u, 1, 1, 1, cf->extRing);
639    plusTerm(u, 5, 1, 0, cf->extRing);  // a + 5
640    checkInverse((number)u, cf); p_Delete(&u, cf->extRing);
641    u = NULL; plusTerm(u, 1, 1, 1, cf->extRing);
642    plusTerm(u, -5, 1, 0, cf->extRing); // a - 5
643    checkInverse((number)u, cf); p_Delete(&u, cf->extRing);
644    u = NULL; plusTerm(u, 17, 1, 1, cf->extRing);
645    plusTerm(u, 5, 1, 0, cf->extRing); // 17a + 5
646    checkInverse((number)u, cf); p_Delete(&u, cf->extRing);
647
648    rDelete(s); // kills 'cf' and 'r' as well
649  }
650  void test_Q_Ext_b()
651  {
652    clog << "Start by creating Q[b]..." << endl;
653
654    char* n[] = {"b"};
655    ring r = rDefault( 0, 1, n);   // Q[b]
656    TS_ASSERT_DIFFERS( r, NULLp );
657
658    PrintRing(r);
659
660    TS_ASSERT( rField_is_Domain(r) );
661    TS_ASSERT( rField_is_Q(r) );
662
663    TS_ASSERT( !rField_is_Zp(r) );
664    TS_ASSERT( !rField_is_Zp(r, 11) );
665
666    TS_ASSERT_EQUALS( rVar(r), 1);
667
668    poly minPoly = p_ISet(1, r);                    // minPoly = 1
669    p_SetExp(minPoly, 1, 7, r); p_Setm(minPoly, r); // minPoly = b^7
670    minPoly = p_Add_q(minPoly, p_ISet(17, r), r);   // minPoly = b^7 + 17
671    ideal minIdeal = idInit(1);                     // minIdeal = < 0 >
672    minIdeal->m[0] = minPoly;                       // minIdeal = < b^7 + 17 >
673
674    n_coeffType type = nRegister(n_algExt, naInitChar);
675    TS_ASSERT(type == n_algExt);
676
677    AlgExtInfo extParam;
678    extParam.r = r;
679    extParam.i = minIdeal;
680
681    clog << "Next create the extension field Q[b]/<b^7+17>..." << endl;
682
683    const coeffs cf = nInitChar(type, &extParam);   // Q[b]/<b^7+17>
684
685    if( cf == NULL )
686      TS_FAIL("Could not get needed coeff. domain");
687
688    TS_ASSERT_DIFFERS( cf->cfCoeffWrite, NULLp );
689
690    if( cf->cfCoeffWrite != NULL )
691    {
692      clog << "Coeff-domain: "  << endl;
693      n_CoeffWrite(cf); PrintLn();
694    }
695
696    TS_ASSERT( nCoeff_is_algExt(cf) );
697    TS_ASSERT( !nCoeff_is_transExt(cf) );
698
699    // some tests for the coefficient field represented by cf:
700    TestArithCf(cf);
701    TestSumCf(cf, 10);
702    TestSumCf(cf, 100);
703    TestSumCf(cf, 101);
704    TestSumCf(cf, 1001);
705    TestSumCf(cf, 9000);
706
707    clog << "Finally create the polynomial ring (Q[b]/<b^7+17>)[u, v, w]..."
708         << endl;
709
710    char* m[] = {"u", "v", "w"};
711    ring s = rDefault(cf, 3, m);   // (Q[b]/<b^7+17>)[u, v, w]
712    TS_ASSERT_DIFFERS(s, NULLp);
713
714    PrintRing(s);
715
716    TS_ASSERT( rField_is_Domain(s) );
717    TS_ASSERT( !rField_is_Q(s) );
718    TS_ASSERT( !rField_is_Zp(s) );
719    TS_ASSERT( !rField_is_Zp(s, 11) );
720    TS_ASSERT( !rField_is_Zp(s, 13) );
721    TS_ASSERT( !rField_is_GF(s) );
722    TS_ASSERT( rField_is_Extension(s) );
723    TS_ASSERT( !rField_is_GF(s, 25) );
724    TS_ASSERT_EQUALS(rVar(s), 3);
725
726    Test(s);
727
728    clog << endl
729         << "Now let's compute some inverses in Q[b]/<b^7+17>..."
730         << endl;
731
732    poly u;
733    u = NULL; plusTerm(u, 1, 1, 2, cf->extRing);
734    plusTerm(u, 33, 1, 0, cf->extRing);     // b^2 + 33
735    checkInverse((number)u, cf); p_Delete(&u, cf->extRing);
736    u = NULL; plusTerm(u, 1, 1, 5, cf->extRing);
737    plusTerm(u, -137, 1, 0, cf->extRing);   // b^5 - 137
738    checkInverse((number)u, cf); p_Delete(&u, cf->extRing);
739
740    clog << endl
741         << "Now let's check a gcd computation in Q[b]..."
742         << endl;
743
744    poly v;
745    v = NULL; plusTerm(v, 1, 1, 2, cf->extRing);
746    plusTerm(v, 7, 1, 1, cf->extRing);
747    plusTerm(v, 1, 1, 0, cf->extRing);            // b^2 + 7b + 1
748    number w = n_Mult((number)v, (number)v, cf);  // (b^2 + 7b + 1)^2
749    number y = n_Mult((number)v, (number)w, cf);  // (b^2 + 7b + 1)^3
750    p_Delete(&v, cf->extRing);
751    v = NULL; plusTerm(v, 2, 1, 2, cf->extRing);
752    plusTerm(v, -61, 1, 1, cf->extRing);          // 2b^2 - 61b
753    number z = n_Mult((number)w,
754                      (number)v, cf);   // (b^2 + 7b + 1)^2 * (2b^2 - 61b)
755    p_Delete(&v, cf->extRing);
756
757    clog << "z = "; p_Write((poly)z, cf->extRing);
758    clog << "y = "; p_Write((poly)y, cf->extRing);
759    number theGcd = n_Gcd(z, y, cf);   // should yield w = (b^2 + 7b + 1)^2
760    clog << "gcd(z, y) = "; p_Write((poly)theGcd, cf->extRing);
761
762    v = (poly)n_Sub(theGcd, w, cf);
763    TS_ASSERT( v == NULL );
764    p_Delete(&v, cf->extRing);
765
766    clog << endl
767         << "Now let's check an ext_gcd computation in Q[b]..."
768         << endl;
769
770    poly zFactor; poly yFactor;
771    poly ppp = p_ExtGcd((poly)z, zFactor, (poly)y, yFactor, cf->extRing);
772    v = (poly)n_Sub(theGcd, (number)ppp, cf);
773    TS_ASSERT( v == NULL );
774    clog << "z = "; p_Write((poly)z, cf->extRing);
775    clog << "zFactor = "; p_Write(zFactor, cf->extRing);
776    clog << "y = "; p_Write((poly)y, cf->extRing);
777    clog << "yFactor = "; p_Write((poly)yFactor, cf->extRing);
778    number v1 = n_Mult(z, (number)zFactor, cf);
779    number v2 = n_Mult(y, (number)yFactor, cf);
780    number v3 = n_Add(v1, v2, cf);
781    clog << "z * zFactor + y * yFactor = "; p_Write((poly)v3, cf->extRing);
782    clog << "gcd(z, y) = "; p_Write(ppp, cf->extRing);
783    number v4 = n_Sub(v3, w, cf);
784    TS_ASSERT( v4 == NULL );
785
786    p_Delete(&ppp, cf->extRing); p_Delete(&zFactor, cf->extRing);
787    p_Delete(&yFactor, cf->extRing);
788    n_Delete(&z, cf); n_Delete(&y, cf); n_Delete(&w, cf);
789    n_Delete(&theGcd, cf); p_Delete(&v, cf->extRing); n_Delete(&v1, cf);
790    n_Delete(&v2, cf); n_Delete(&v3, cf); n_Delete(&v4, cf);
791
792    rDelete(s); // kills 'cf' and 'r' as well
793  }
794  void test_Z_17_Ext_a()
795  {
796    clog << "Start by creating Z_17[a]..." << endl;
797
798    char* n[] = {"a"};
799    ring r = rDefault( 17, 1, n);   // Z/17Z[a]
800    TS_ASSERT_DIFFERS( r, NULLp );
801
802    PrintRing(r);
803
804    TS_ASSERT( rField_is_Domain(r) );
805    TS_ASSERT( !rField_is_Q(r) );
806
807    TS_ASSERT( rField_is_Zp(r) );
808    TS_ASSERT( rField_is_Zp(r, 17) );
809
810    TS_ASSERT_EQUALS( rVar(r), 1);
811
812    poly minPoly = p_ISet(1, r);                    // minPoly = 1
813    p_SetExp(minPoly, 1, 2, r); p_Setm(minPoly, r); // minPoly = a^2
814    minPoly = p_Add_q(minPoly, p_ISet(3, r), r);    // minPoly = a^2 + 3
815    ideal minIdeal = idInit(1);                     // minIdeal = < 0 >
816    minIdeal->m[0] = minPoly;                       // minIdeal = < a^2 + 3 >
817
818    n_coeffType type = nRegister(n_algExt, naInitChar);
819    TS_ASSERT(type == n_algExt);
820
821    AlgExtInfo extParam;
822    extParam.r = r;
823    extParam.i = minIdeal;
824
825    clog << "Next create the extension field Z_17[a]/<a^2+3>..." << endl;
826
827    const coeffs cf = nInitChar(type, &extParam);   // Z_17[a]/<a^2+3>
828
829    if( cf == NULL )
830      TS_FAIL("Could not get needed coeff. domain");
831
832    TS_ASSERT_DIFFERS( cf->cfCoeffWrite, NULLp );
833
834    if( cf->cfCoeffWrite != NULL )
835    {
836      clog << "Coeff-domain: "  << endl;
837      n_CoeffWrite(cf); PrintLn();
838    }
839
840    TS_ASSERT( nCoeff_is_algExt(cf) );
841    TS_ASSERT( !nCoeff_is_transExt(cf) );
842
843    // some tests for the coefficient field represented by cf:
844    TestArithCf(cf);
845    TestSumCf(cf, 10);
846    TestSumCf(cf, 100);
847    TestSumCf(cf, 101);
848    TestSumCf(cf, 1001);
849    TestSumCf(cf, 9000);
850
851    clog << "Finally create the polynomial ring (Z_17[a]/<a^2+3>)[u, v, w]..."
852         << endl;
853
854    char* m[] = {"u", "v", "w"};
855    ring s = rDefault(cf, 3, m);   // (Z_17[a]/<a^2+3>)[u, v, w]
856    TS_ASSERT_DIFFERS(s, NULLp);
857
858    PrintRing(s);
859
860    TS_ASSERT( rField_is_Domain(s) );
861    TS_ASSERT( !rField_is_Q(s) );
862    TS_ASSERT( !rField_is_Zp(s) );
863    TS_ASSERT( !rField_is_Zp(s, 11) );
864    TS_ASSERT( !rField_is_Zp(s, 17) );
865    TS_ASSERT( !rField_is_GF(s) );
866    TS_ASSERT( rField_is_Extension(s) );
867    TS_ASSERT( !rField_is_GF(s, 25) );
868    TS_ASSERT_EQUALS(rVar(s), 3);
869
870    Test(s);
871   
872    rDelete(s); // kills 'cf' and 'r' as well
873  }
874  void test_Q_Ext_s_t()
875  {
876    clog << "Start by creating Q[s, t]..." << endl;
877
878    char* n[] = {"s", "t"};
879    ring r = rDefault( 0, 2, n);   // Q[s, t]
880    TS_ASSERT_DIFFERS( r, NULLp );
881
882    PrintRing(r);
883
884    TS_ASSERT( rField_is_Domain(r) );
885    TS_ASSERT( rField_is_Q(r) );
886
887    TS_ASSERT( !rField_is_Zp(r) );
888    TS_ASSERT( !rField_is_Zp(r, 17) );
889
890    TS_ASSERT_EQUALS( rVar(r), 2);
891
892    n_coeffType type = nRegister(n_transExt, ntInitChar);
893    TS_ASSERT(type == n_transExt);
894
895    TransExtInfo extParam;
896    extParam.r = r;
897
898    clog << "Next create the rational function field Q(s, t)..." << endl;
899
900    const coeffs cf = nInitChar(type, &extParam);   // Q(s, t)
901
902    if( cf == NULL )
903      TS_FAIL("Could not get needed coeff. domain");
904
905    TS_ASSERT_DIFFERS( cf->cfCoeffWrite, NULLp );
906
907    if( cf->cfCoeffWrite != NULL )
908    {
909      clog << "Coeff-domain: "  << endl;
910      n_CoeffWrite(cf); PrintLn();
911    }
912
913    TS_ASSERT( !nCoeff_is_algExt(cf) );
914    TS_ASSERT( nCoeff_is_transExt(cf) );
915
916    // some tests for the coefficient field represented by cf:
917    TestArithCf(cf);
918    TestSumCf(cf, 10);
919    TestSumCf(cf, 100);
920    TestSumCf(cf, 101);
921    TestSumCf(cf, 1001);
922    TestSumCf(cf, 9000);
923
924    clog << "Finally create the polynomial ring Q(s, t)[x, y, z]..."
925         << endl;
926
927    char* m[] = {"x", "y", "z"};
928    ring s = rDefault(cf, 3, m);   // Q(s, t)[x, y, z]
929    TS_ASSERT_DIFFERS(s, NULLp);
930
931    PrintRing(s);
932
933    TS_ASSERT( rField_is_Domain(s) );
934    TS_ASSERT( !rField_is_Q(s) );
935    TS_ASSERT( !rField_is_Zp(s) );
936    TS_ASSERT( !rField_is_Zp(s, 11) );
937    TS_ASSERT( !rField_is_Zp(s, 17) );
938    TS_ASSERT( !rField_is_GF(s) );
939    TS_ASSERT( rField_is_Extension(s) );
940    TS_ASSERT( !rField_is_GF(s, 25) );
941    TS_ASSERT_EQUALS(rVar(s), 3);
942
943    Test(s);
944   
945    /* some special tests: */
946    poly v1 = NULL;
947    plusTerm(v1, 1, 1, 1, cf->extRing);       // s
948    plusTerm(v1, 1, 1, 0, cf->extRing);       // s + 1
949    poly v2 = NULL;
950    plusTerm(v2, 1, 1, 1, cf->extRing);       // s
951    plusTerm(v2, 2, 2, 1, cf->extRing);       // s + 2t
952    poly v = p_Mult_q(v1, v2, cf->extRing);   // (s + 1) * (s + 2t)
953    number v_n = toFractionNumber(v, cf);
954    PrintSized(v_n, cf);
955    poly w = NULL;
956    plusTerm(w, 1, 1, 1, cf->extRing);        // s
957    plusTerm(w, 1, 1, 0, cf->extRing);        // s + 1
958    number w_n = toFractionNumber(w, cf);
959    PrintSized(w_n, cf);
960    number vOverW_n = n_Div(v_n, w_n, cf);
961    PrintSized(vOverW_n, cf);
962    number wOverV_n = n_Invers(vOverW_n, cf);
963    PrintSized(wOverV_n, cf);
964    number prod = n_Mult(vOverW_n, wOverV_n, cf);
965    PrintSized(prod, cf);
966    number tmp; number nn = n_Copy(vOverW_n, cf);
967    for (int i = 1; i <= 20; i++)
968    {
969      tmp = n_Div(nn, v_n, cf);
970      n_Delete(&nn, cf);
971      nn = tmp;
972      clog << i << ". "; PrintSized(nn, cf);
973    }
974    n_Delete(&prod, cf); n_Delete(&nn, cf);
975    n_Delete(&v_n, cf); n_Delete(&w_n, cf);
976    n_Delete(&vOverW_n, cf); n_Delete(&wOverV_n, cf);
977   
978    rDelete(s); // kills 'cf' and 'r' as well
979  }
980};
981
Note: See TracBrowser for help on using the repository browser.