Data Structures | Functions | Variables
coeffs_test.h File Reference
#include "misc/auxiliary.h"
#include "reporter/reporter.h"
#include "resources/feResource.h"
#include "coeffs/coeffs.h"
#include "coeffs/numbers.h"
#include "coeffs/longrat.h"
#include "coeffs/gnumpfl.h"
#include "coeffs/gnumpc.h"
#include "coeffs/shortfl.h"
#include "coeffs/ffields.h"
#include "coeffs/modulop.h"
#include "coeffs/rmodulon.h"
#include "coeffs/rmodulo2m.h"
#include "coeffs/rintegers.h"
#include "common.h"

Go to the source code of this file.

Data Structures

class  CoeffsTestSuite
 

Functions

void TestSum (const coeffs r, const unsigned long N)
 
void TestArith (const coeffs r)
 
BOOLEAN Test (const n_coeffType type, void *p=NULLp)
 

Variables

static GlobalPrintingFixture globalPrintingFixture
 

Function Documentation

◆ Test()

BOOLEAN Test ( const n_coeffType  type,
void *  p = NULLp 
)

Definition at line 209 of file coeffs_test.h.

210 {
211 
212  clog << endl;
213  clog << ( "----------------------- Testing coeffs: [" + _2S(type) + ", " + _2S(p) + "]: -----------------------");
214  clog << endl;
215 
216  const coeffs r = nInitChar( type, p );
217 
218  if( r == NULLp )
219  {
220  clog << ( "Test: could not get this coeff. domain" );
221  return FALSE;
222  };
223 
224  TS_ASSERT_DIFFERS( r->cfCoeffWrite, NULLp );
225 
226  if( r->cfCoeffWrite != NULL )
227  {
228  clog << "Coeff-domain: " << endl;
229  n_CoeffWrite(r); PrintLn();
230  }
231 
232  if (n_NumberOfParameters(r) > 0)
233  {
234  number z = n_Param(1, r); // also any integer instead of 0//?
235  PrintS("Parameter: "); PrintSized(z, r);
236  n_Delete(&z, r);
237  }
238 
239 
240  clog << "Char: " << n_GetChar(r) << endl;
241 
242 
243  TS_ASSERT_DIFFERS( r, NULLp );
244  nSetChar( r );
245  TS_ASSERT_EQUALS( getCoeffType(r), type );
246 
247  TS_ASSERT_DIFFERS( r->cfInit, NULLp );
248  TS_ASSERT_DIFFERS( r->cfWriteLong, NULLp );
249  TS_ASSERT_DIFFERS( r->cfAdd, NULLp );
250  TS_ASSERT_DIFFERS( r->cfDelete, NULLp );
251 
252  switch( type )
253  {
254  case n_Q:
255  {
256  //TS_ASSERT_EQUALS( r->cfInit, nlInit );
257  //TS_ASSERT_EQUALS( r->cfAdd, nlAdd );
258  //TS_ASSERT_EQUALS( r->cfDelete, nlDelete );
259 
260  TS_ASSERT( nCoeff_is_Q( r ));
262 
263  TS_ASSERT( !nCoeff_has_Units( r )); // ?
265  TS_ASSERT( !nCoeff_has_simple_Alloc( r )); // ?
266 
268  TS_ASSERT( !nCoeff_is_Zn( r ));
270  TS_ASSERT( !nCoeff_is_Z( r ));
271  TS_ASSERT( !nCoeff_is_Ring( r ));
272  TS_ASSERT( !nCoeff_is_Zp( r ));
274  TS_ASSERT( !nCoeff_is_R( r ));
275  TS_ASSERT( !nCoeff_is_GF( r ));
276  TS_ASSERT( !nCoeff_is_long_R( r ));
277  TS_ASSERT( !nCoeff_is_long_C( r ));
278  TS_ASSERT( !nCoeff_is_CF( r ));
280 
281  break;
282  }
283  case n_long_R:
284  {
285  //TS_ASSERT_EQUALS( r->cfInit, ngfInit );
286  //TS_ASSERT_EQUALS( r->cfAdd, ngfAdd );
287  //TS_ASSERT_EQUALS( r->cfDelete, ngfDelete );
288  break;
289  }
290  case n_long_C:
291  {
292 // TS_ASSERT_EQUALS( r->cfInit, ngcInit );
293 // TS_ASSERT_EQUALS( r->cfAdd, ngcAdd );
294 // TS_ASSERT_EQUALS( r->cfDelete, ngcDelete );
295  break;
296  }
297  case n_R:
298  {
299  //TS_ASSERT_EQUALS( r->cfInit, nrInit );
300  //TS_ASSERT_EQUALS( r->cfAdd, nrAdd );
301  // TS_ASSERT_EQUALS( r->cfDelete, nrDelete ); // No?
302  break;
303  }
304  case n_GF:
305  {
306 // TS_ASSERT_EQUALS( r->cfInit, nfInit );
307 // TS_ASSERT_EQUALS( r->cfAdd, nfAdd );
308  //TS_ASSERT_EQUALS( r->cfDelete, nfDelete );
309  break;
310  }
311 #ifdef HAVE_RINGS
312  case n_Z2m:
313  {
314  //TS_ASSERT_EQUALS( r->cfInit, nr2mInit );
315  //TS_ASSERT_EQUALS( r->cfAdd, nr2mAdd );
316  //TS_ASSERT_EQUALS( r->cfDelete, ndDelete );
317  break;
318  }
319  case n_Zn:
320  {
321  //TS_ASSERT_EQUALS( r->cfInit, nrnInit );
322  //TS_ASSERT_EQUALS( r->cfAdd, nrnAdd );
323  //TS_ASSERT_EQUALS( r->cfDelete, nrnDelete );
324  break;
325  }
326 #endif
327  default:
328  {
329  // ...
330  }
331  }
332 
333  TestArith( r );
334  TestSum( r, 10 );
335  TestSum( r, 100 );
336  TestSum( r, 101 );
337  TestSum( r, 1001 );
338  TestSum( r, 9000 );
339 
340  nKillChar( r );
341 
342  return TRUE;
343 }
#define NULLp
Definition: auxiliary.h:108
void TestSum(const coeffs r, const unsigned long N)
Definition: coeffs_test.h:25
static FORCE_INLINE BOOLEAN nCoeff_is_numeric(const coeffs r)
Definition: coeffs.h:854
void PrintLn()
Definition: reporter.cc:310
only used if HAVE_RINGS is defined
Definition: coeffs.h:45
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition: coeffs.h:822
only used if HAVE_RINGS is defined
Definition: coeffs.h:47
#define FALSE
Definition: auxiliary.h:96
static FORCE_INLINE BOOLEAN nCoeff_is_long_R(const coeffs r)
Definition: coeffs.h:913
#define TS_ASSERT_EQUALS(x, y)
Definition: TestSuite.h:255
static FORCE_INLINE void nSetChar(const coeffs r)
initialisations after each ring change
Definition: coeffs.h:436
rational (GMP) numbers
Definition: coeffs.h:31
static FORCE_INLINE BOOLEAN nCoeff_is_R(const coeffs r)
Definition: coeffs.h:858
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_2toM(const coeffs r)
Definition: coeffs.h:746
static FORCE_INLINE BOOLEAN nCoeff_has_simple_inverse(const coeffs r)
TRUE, if the computation of the inverse is fast, i.e. prefer leading coeff. 1 over content...
Definition: coeffs.h:924
void TestArith(const coeffs r)
Definition: coeffs_test.h:109
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:444
#define TRUE
Definition: auxiliary.h:100
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
Definition: coeffs.h:828
static FORCE_INLINE BOOLEAN nCoeff_is_long_C(const coeffs r)
Definition: coeffs.h:916
static FORCE_INLINE BOOLEAN nCoeff_is_Z(const coeffs r)
Definition: coeffs.h:838
#define TS_ASSERT(e)
Definition: TestSuite.h:239
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
Definition: coeffs.h:752
real floating point (GMP) numbers
Definition: coeffs.h:34
static FORCE_INLINE int n_NumberOfParameters(const coeffs r)
Returns the number of parameters.
Definition: coeffs.h:796
static FORCE_INLINE number n_Param(const int iParameter, const coeffs r)
return the (iParameter^th) parameter as a NEW number NOTE: parameter numbering: 1..n_NumberOfParameters(...)
Definition: coeffs.h:805
single prescision (6,6) real numbers
Definition: coeffs.h:32
static FORCE_INLINE BOOLEAN nCoeff_is_CF(const coeffs r)
Definition: coeffs.h:919
The main handler for Singular numbers which are suitable for Singular polynomials.
static FORCE_INLINE BOOLEAN nCoeff_has_Units(const coeffs r)
returns TRUE, if r is not a field and r has non-trivial units
Definition: coeffs.h:819
static FORCE_INLINE BOOLEAN nCoeff_has_simple_Alloc(const coeffs r)
TRUE if n_Delete/n_New are empty operations.
Definition: coeffs.h:928
complex floating point (GMP) numbers
Definition: coeffs.h:42
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_PtoM(const coeffs r)
Definition: coeffs.h:749
void PrintS(const char *s)
Definition: reporter.cc:284
static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
Definition: coeffs.h:861
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
static FORCE_INLINE void n_CoeffWrite(const coeffs r, BOOLEAN details=TRUE)
output the coeff description
Definition: coeffs.h:741
static FORCE_INLINE BOOLEAN nCoeff_is_Domain(const coeffs r)
returns TRUE, if r is a field or r has no zero divisors (i.e is a domain)
Definition: coeffs.h:761
#define NULL
Definition: omList.c:12
{p^n < 2^16}
Definition: coeffs.h:33
#define TS_ASSERT_DIFFERS(x, y)
Definition: TestSuite.h:287
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
Definition: coeffs.h:868
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:455
int p
Definition: cfModGcd.cc:4019
static FORCE_INLINE BOOLEAN nCoeff_is_Zn(const coeffs r)
Definition: coeffs.h:848
void nKillChar(coeffs r)
undo all initialisations
Definition: numbers.cc:510
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:349

◆ TestArith()

void TestArith ( const coeffs  r)

Definition at line 109 of file coeffs_test.h.

110 {
111  clog << ("TEST: Simple Arithmetics: ");
112  clog << endl;
113 
114  number two = n_Init(2, r);
115 
116  number t = n_Init(1, r);
117  n_InpAdd(t, t, r);
118  TS_ASSERT( n_Equal(two, t, r) );
119  n_Delete(&t, r);
120 
121  if( getCoeffType(r) == n_Q )
122  {
123  number t = n_Init(1, r);
124  n_InpAdd(t, t, r);
125  TS_ASSERT( n_Equal(two, t, r) );
126  n_Delete(&t, r);
127  }
128 
129 
130 
131 
132  const int N = 66666;
133 
134  number a = n_Init(N, r);
135 
136  clog<< "a: "; PrintSized(a, r);
137 
138 
139  clog<< "two: "; PrintSized(two, r);
140 
141  number aa0 = n_Init(N*2, r);
142 
143  number aa = n_Add(a, a, r);
144 
145  clog<< "aa = a + a: "; PrintSized(aa, r);
146 
147  number aa2 = n_Mult(a, two, r);
148 
149  clog<< "aa2 = a * 2: "; PrintSized(aa2, r);
150 
151  number aa1 = n_Mult(two, a, r);
152 
153  clog<< "aa1 = 2 * a: "; PrintSized(aa1, r);
154 
155  n_Delete(&a, r);
156  n_Delete(&two, r);
157 
158 
159  a = n_Sub( aa, aa1, r );
160 
161  clog<< "a = aa - aa1: "; PrintSized(a, r);
162 
163  TS_ASSERT( n_IsZero(a, r) );
164 
165  n_Delete(&a, r);
166 
167  a = n_Sub( aa, aa2, r );
168 
169  clog<< "a = aa - aa2: "; PrintSized(a, r);
170 
171  TS_ASSERT( n_IsZero(a, r) );
172 
173  n_Delete(&a, r);
174 
175 
176  a = n_Sub( aa1, aa2, r );
177 
178  clog<< "a = aa1 - aa2: "; PrintSized(a, r);
179 
180  TS_ASSERT( n_IsZero(a, r) );
181 
182  n_Delete(&a, r);
183 
184 
185 
186  TS_ASSERT( n_Equal(aa, aa1, r) );
187  TS_ASSERT( n_Equal(aa, aa2, r) );
188  TS_ASSERT( n_Equal(aa1, aa2, r) );
189 
190  TS_ASSERT( n_Equal(aa0, aa, r) );
191  TS_ASSERT( n_Equal(aa0, aa1, r) );
192  TS_ASSERT( n_Equal(aa0, aa2, r) );
193 
194  n_Delete(&aa, r);
195  n_Delete(&aa1, r);
196  n_Delete(&aa2, r);
197 
198  n_Delete(&aa0, r);
199 
200  clog << ( " >>> TEST DONE!" );
201  clog << endl;
202 
203 }
static FORCE_INLINE number n_Sub(number a, number b, const coeffs r)
return the difference of &#39;a&#39; and &#39;b&#39;, i.e., a-b
Definition: coeffs.h:669
rational (GMP) numbers
Definition: coeffs.h:31
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition: coeffs.h:538
#define TS_ASSERT(e)
Definition: TestSuite.h:239
static FORCE_INLINE void n_InpAdd(number &a, number b, const coeffs r)
addition of &#39;a&#39; and &#39;b&#39;; replacement of &#39;a&#39; by the sum a+b
Definition: coeffs.h:646
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of &#39;a&#39; and &#39;b&#39;, i.e., a*b
Definition: coeffs.h:636
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:48
static FORCE_INLINE number n_Add(number a, number b, const coeffs r)
return the sum of &#39;a&#39; and &#39;b&#39;, i.e., a+b
Definition: coeffs.h:656
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the zero element.
Definition: coeffs.h:464
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
static FORCE_INLINE BOOLEAN n_Equal(number a, number b, const coeffs r)
TRUE iff &#39;a&#39; and &#39;b&#39; represent the same number; they may have different representations.
Definition: coeffs.h:460
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:455

◆ TestSum()

void TestSum ( const coeffs  r,
const unsigned long  N 
)

Definition at line 25 of file coeffs_test.h.

26 {
27  clog << ( _2S("TEST: sum[0..") + _2S(N) + "]: ");
28  clog << endl;
29 
30  assume( N > 0 ); // just for now...
31 
32  const unsigned long ssss = (N * (N+1)) / 2;
33 
34  number sum1 = n_Init(ssss, r);
35  clog<< "N*(N+1)/2 (int: " << ssss << "): "; PrintSized(sum1, r);
36 
37  number s, ss, i, res;
38 
39  s = n_Init(N , r);
40  i = n_Init(N+1, r);
41  n_InpMult(s, i, r);
42  n_Delete(&i, r);
43 
44  clog<< "N*(N+1): ("<< N*(N+1) << ")"; PrintSized(s, r);
45 
46  i = n_Init(2, r);
47  clog<< "2: "; PrintSized(i, r);
48 
49  if( !n_IsZero( i, r) )
50  {
51 #ifdef HAVE_RINGS
52  TS_ASSERT( n_DivBy(s, i, r) );
53 #endif
54 
55  res = n_Div(s, i, r);
56 
57  clog<< "N*(N+1)/2: "; PrintSized(res, r);
58 
59 
60  number d = n_Sub(res, sum1, r);
61  TS_ASSERT( n_IsZeroDivisor(d, r) );
62  n_Delete(&d, r);
63 
64  if( n_GetChar(r) == 0 )
65  {
66  TS_ASSERT( n_Equal(sum1, res, r) );
67  TS_ASSERT( n_Equal(res, sum1, r) );
68  }
69  } else
71 
72 
73  n_Delete(&s, r); n_Delete(&i, r);
74 
75  n_Delete(&sum1, r); n_Delete(&res, r);
76 
77 
78  s = n_Init(0 , r);
79  ss = n_Init(0 , r);
80  for( int k = N; k >= 0; k-- )
81  {
82  i = n_Init(k, r);
83  n_InpAdd(s, i, r); // s += i
84 
85  i = n_InpNeg(i, r);
86  n_InpAdd(ss, i, r); // ss -= i
87 
88  n_Delete(&i, r);
89  }
90  clog<< "ss: "; PrintSized(ss, r);
91 
92  ss = n_InpNeg(ss, r); // ss = -ss
93 
94  clog<< "real sum : "; PrintSized(s, r);
95  clog<< "real sum(--): "; PrintSized(ss, r);
96 
97  TS_ASSERT( n_Equal(s, ss, r) );
98  TS_ASSERT( n_Equal(ss, s, r) );
99 
100  n_Delete(&s, r);
101  n_Delete(&ss, r);
102 
103  clog << ( " >>> TEST DONE!" );
104  clog << endl;
105 
106 }
static FORCE_INLINE number n_Sub(number a, number b, const coeffs r)
return the difference of &#39;a&#39; and &#39;b&#39;, i.e., a-b
Definition: coeffs.h:669
const CanonicalForm int s
Definition: facAbsFact.cc:55
static FORCE_INLINE void n_InpMult(number &a, number b, const coeffs r)
multiplication of &#39;a&#39; and &#39;b&#39;; replacement of &#39;a&#39; by the product a*b
Definition: coeffs.h:641
#define TS_ASSERT_EQUALS(x, y)
Definition: TestSuite.h:255
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition: coeffs.h:538
BOOLEAN n_IsZeroDivisor(number a, const coeffs r)
Test whether a is a zero divisor in r i.e. not coprime with char. of r very inefficient implementatio...
Definition: numbers.cc:145
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:444
int k
Definition: cfEzgcd.cc:92
#define TS_ASSERT(e)
Definition: TestSuite.h:239
static FORCE_INLINE void n_InpAdd(number &a, number b, const coeffs r)
addition of &#39;a&#39; and &#39;b&#39;; replacement of &#39;a&#39; by the sum a+b
Definition: coeffs.h:646
CanonicalForm res
Definition: facAbsFact.cc:64
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:48
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE BOOLEAN n_DivBy(number a, number b, const coeffs r)
test whether &#39;a&#39; is divisible &#39;b&#39;; for r encoding a field: TRUE iff &#39;b&#39; does not represent zero in Z:...
Definition: coeffs.h:775
static FORCE_INLINE number n_InpNeg(number n, const coeffs r)
in-place negation of n MUST BE USED: n = n_InpNeg(n) (no copy is returned)
Definition: coeffs.h:557
int i
Definition: cfEzgcd.cc:125
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the zero element.
Definition: coeffs.h:464
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of &#39;a&#39; and &#39;b&#39;, i.e., a/b; raises an error if &#39;b&#39; is not invertible in r exceptio...
Definition: coeffs.h:615
static FORCE_INLINE BOOLEAN n_Equal(number a, number b, const coeffs r)
TRUE iff &#39;a&#39; and &#39;b&#39; represent the same number; they may have different representations.
Definition: coeffs.h:460
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:455

Variable Documentation

◆ globalPrintingFixture

GlobalPrintingFixture globalPrintingFixture
static

Definition at line 350 of file coeffs_test.h.