Data Structures | Functions | Variables
coeffs_test.h File Reference
#include <misc/auxiliary.h>
#include <omalloc/omalloc.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 212 of file coeffs_test.h.

213 {
214 
215  clog << endl;
216  clog << ( "----------------------- Testing coeffs: [" + _2S(type) + ", " + _2S(p) + "]: -----------------------");
217  clog << endl;
218 
219  const coeffs r = nInitChar( type, p );
220 
221  if( r == NULLp )
222  {
223  clog << ( "Test: could not get this coeff. domain" );
224  return FALSE;
225  };
226 
227  TS_ASSERT_DIFFERS( r->cfCoeffWrite, NULLp );
228 
229  if( r->cfCoeffWrite != NULL )
230  {
231  clog << "Coeff-domain: " << endl;
232  n_CoeffWrite(r); PrintLn();
233  }
234 
235  if (n_NumberOfParameters(r) > 0)
236  {
237  number z = n_Param(1, r); // also any integer instead of 0//?
238  PrintS("Parameter: "); PrintSized(z, r);
239  n_Delete(&z, r);
240  }
241 
242 
243  clog << "Char: " << n_GetChar(r) << endl;
244 
245 
247  nSetChar( r );
248  TS_ASSERT_EQUALS( getCoeffType(r), type );
249 
250  TS_ASSERT_DIFFERS( r->cfInit, NULLp );
251  TS_ASSERT_DIFFERS( r->cfWriteLong, NULLp );
252  TS_ASSERT_DIFFERS( r->cfAdd, NULLp );
253  TS_ASSERT_DIFFERS( r->cfDelete, NULLp );
254 
255  switch( type )
256  {
257  case n_Q:
258  {
259  //TS_ASSERT_EQUALS( r->cfInit, nlInit );
260  //TS_ASSERT_EQUALS( r->cfAdd, nlAdd );
261  //TS_ASSERT_EQUALS( r->cfDelete, nlDelete );
262 
263  TS_ASSERT( nCoeff_is_Q( r ));
265 
266  TS_ASSERT( !nCoeff_has_Units( r )); // ?
269 
274  TS_ASSERT( !nCoeff_is_Ring( r ));
275  TS_ASSERT( !nCoeff_is_Zp( r ));
277  TS_ASSERT( !nCoeff_is_R( r ));
278  TS_ASSERT( !nCoeff_is_GF( r ));
281  TS_ASSERT( !nCoeff_is_CF( r ));
283 
284  break;
285  }
286  case n_long_R:
287  {
288  //TS_ASSERT_EQUALS( r->cfInit, ngfInit );
289  //TS_ASSERT_EQUALS( r->cfAdd, ngfAdd );
290  //TS_ASSERT_EQUALS( r->cfDelete, ngfDelete );
291  break;
292  }
293  case n_long_C:
294  {
295 // TS_ASSERT_EQUALS( r->cfInit, ngcInit );
296 // TS_ASSERT_EQUALS( r->cfAdd, ngcAdd );
297 // TS_ASSERT_EQUALS( r->cfDelete, ngcDelete );
298  break;
299  }
300  case n_R:
301  {
302  //TS_ASSERT_EQUALS( r->cfInit, nrInit );
303  //TS_ASSERT_EQUALS( r->cfAdd, nrAdd );
304  // TS_ASSERT_EQUALS( r->cfDelete, nrDelete ); // No?
305  break;
306  }
307  case n_GF:
308  {
309 // TS_ASSERT_EQUALS( r->cfInit, nfInit );
310 // TS_ASSERT_EQUALS( r->cfAdd, nfAdd );
311  //TS_ASSERT_EQUALS( r->cfDelete, nfDelete );
312  break;
313  }
314 #ifdef HAVE_RINGS
315  case n_Z2m:
316  {
317  //TS_ASSERT_EQUALS( r->cfInit, nr2mInit );
318  //TS_ASSERT_EQUALS( r->cfAdd, nr2mAdd );
319  //TS_ASSERT_EQUALS( r->cfDelete, ndDelete );
320  break;
321  }
322  case n_Zn:
323  {
324  //TS_ASSERT_EQUALS( r->cfInit, nrnInit );
325  //TS_ASSERT_EQUALS( r->cfAdd, nrnAdd );
326  //TS_ASSERT_EQUALS( r->cfDelete, nrnDelete );
327  break;
328  }
329 #endif
330  default:
331  {
332  // ...
333  }
334  }
335 
336  TestArith( r );
337  TestSum( r, 10 );
338  TestSum( r, 100 );
339  TestSum( r, 101 );
340  TestSum( r, 1001 );
341  TestSum( r, 9000 );
342 
343  nKillChar( r );
344 
345  return TRUE;
346 }
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_ModN(const coeffs r)
Definition: coeffs.h:753
#define NULLp
Definition: auxiliary.h:106
void TestSum(const coeffs r, const unsigned long N)
Definition: coeffs_test.h:28
static FORCE_INLINE BOOLEAN nCoeff_is_numeric(const coeffs r)
Definition: coeffs.h:849
void PrintLn()
Definition: reporter.cc:310
only used if HAVE_RINGS is defined
Definition: coeffs.h:44
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition: coeffs.h:834
only used if HAVE_RINGS is defined
Definition: coeffs.h:46
#define FALSE
Definition: auxiliary.h:94
return P p
Definition: myNF.cc:203
static FORCE_INLINE BOOLEAN nCoeff_is_long_R(const coeffs r)
Definition: coeffs.h:908
#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:440
rational (GMP) numbers
Definition: coeffs.h:31
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_Z(const coeffs r)
Definition: coeffs.h:759
static FORCE_INLINE BOOLEAN nCoeff_is_R(const coeffs r)
Definition: coeffs.h:853
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_2toM(const coeffs r)
Definition: coeffs.h:750
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:919
void TestArith(const coeffs r)
Definition: coeffs_test.h:112
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:448
#define TRUE
Definition: auxiliary.h:98
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
Definition: coeffs.h:840
static FORCE_INLINE BOOLEAN nCoeff_is_long_C(const coeffs r)
Definition: coeffs.h:911
#define TS_ASSERT(e)
Definition: TestSuite.h:239
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
Definition: coeffs.h:762
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:808
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:817
single prescision (6,6) real numbers
Definition: coeffs.h:32
const ring r
Definition: syzextra.cc:208
static FORCE_INLINE BOOLEAN nCoeff_is_CF(const coeffs r)
Definition: coeffs.h:914
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:831
static FORCE_INLINE BOOLEAN nCoeff_has_simple_Alloc(const coeffs r)
TRUE if n_Delete/n_New are empty operations.
Definition: coeffs.h:923
complex floating point (GMP) numbers
Definition: coeffs.h:42
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_PtoM(const coeffs r)
Definition: coeffs.h:756
void PrintS(const char *s)
Definition: reporter.cc:284
static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
Definition: coeffs.h:856
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:425
static FORCE_INLINE void n_CoeffWrite(const coeffs r, BOOLEAN details=TRUE)
output the coeff description
Definition: coeffs.h:745
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:773
#define NULL
Definition: omList.c:10
{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:863
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:459
void nKillChar(coeffs r)
undo all initialisations
Definition: numbers.cc:504
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:341

◆ TestArith()

void TestArith ( const coeffs  r)

Definition at line 112 of file coeffs_test.h.

113 {
114  clog << ("TEST: Simple Arithmetics: ");
115  clog << endl;
116 
117  number two = n_Init(2, r);
118 
119  number t = n_Init(1, r);
120  n_InpAdd(t, t, r);
121  TS_ASSERT( n_Equal(two, t, r) );
122  n_Delete(&t, r);
123 
124  if( getCoeffType(r) == n_Q )
125  {
126  number t = n_Init(1, r);
127  n_InpAdd(t, t, r);
128  TS_ASSERT( n_Equal(two, t, r) );
129  n_Delete(&t, r);
130  }
131 
132 
133 
134 
135  const int N = 66666;
136 
137  number a = n_Init(N, r);
138 
139  clog<< "a: "; PrintSized(a, r);
140 
141 
142  clog<< "two: "; PrintSized(two, r);
143 
144  number aa0 = n_Init(N*2, r);
145 
146  number aa = n_Add(a, a, r);
147 
148  clog<< "aa = a + a: "; PrintSized(aa, r);
149 
150  number aa2 = n_Mult(a, two, r);
151 
152  clog<< "aa2 = a * 2: "; PrintSized(aa2, r);
153 
154  number aa1 = n_Mult(two, a, r);
155 
156  clog<< "aa1 = 2 * a: "; PrintSized(aa1, r);
157 
158  n_Delete(&a, r);
159  n_Delete(&two, r);
160 
161 
162  a = n_Sub( aa, aa1, r );
163 
164  clog<< "a = aa - aa1: "; PrintSized(a, r);
165 
166  TS_ASSERT( n_IsZero(a, r) );
167 
168  n_Delete(&a, r);
169 
170  a = n_Sub( aa, aa2, r );
171 
172  clog<< "a = aa - aa2: "; PrintSized(a, r);
173 
174  TS_ASSERT( n_IsZero(a, r) );
175 
176  n_Delete(&a, r);
177 
178 
179  a = n_Sub( aa1, aa2, r );
180 
181  clog<< "a = aa1 - aa2: "; PrintSized(a, r);
182 
183  TS_ASSERT( n_IsZero(a, r) );
184 
185  n_Delete(&a, r);
186 
187 
188 
189  TS_ASSERT( n_Equal(aa, aa1, r) );
190  TS_ASSERT( n_Equal(aa, aa2, r) );
191  TS_ASSERT( n_Equal(aa1, aa2, r) );
192 
193  TS_ASSERT( n_Equal(aa0, aa, r) );
194  TS_ASSERT( n_Equal(aa0, aa1, r) );
195  TS_ASSERT( n_Equal(aa0, aa2, r) );
196 
197  n_Delete(&aa, r);
198  n_Delete(&aa1, r);
199  n_Delete(&aa2, r);
200 
201  n_Delete(&aa0, r);
202 
203  clog << ( " >>> TEST DONE!" );
204  clog << endl;
205 
206 }
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:673
const poly a
Definition: syzextra.cc:212
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:542
#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:650
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:640
const ring r
Definition: syzextra.cc:208
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:49
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:660
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the zero element.
Definition: coeffs.h:468
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:425
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:464
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:459

◆ TestSum()

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

Definition at line 28 of file coeffs_test.h.

29 {
30  clog << ( _2S("TEST: sum[0..") + _2S(N) + "]: ");
31  clog << endl;
32 
33  assume( N > 0 ); // just for now...
34 
35  const unsigned long ssss = (N * (N+1)) / 2;
36 
37  number sum1 = n_Init(ssss, r);
38  clog<< "N*(N+1)/2 (int: " << ssss << "): "; PrintSized(sum1, r);
39 
40  number s, ss, i, res;
41 
42  s = n_Init(N , r);
43  i = n_Init(N+1, r);
44  n_InpMult(s, i, r);
45  n_Delete(&i, r);
46 
47  clog<< "N*(N+1): ("<< N*(N+1) << ")"; PrintSized(s, r);
48 
49  i = n_Init(2, r);
50  clog<< "2: "; PrintSized(i, r);
51 
52  if( !n_IsZero( i, r) )
53  {
54 #ifdef HAVE_RINGS
55  TS_ASSERT( n_DivBy(s, i, r) );
56 #endif
57 
58  res = n_Div(s, i, r);
59 
60  clog<< "N*(N+1)/2: "; PrintSized(res, r);
61 
62 
63  number d = n_Sub(res, sum1, r);
65  n_Delete(&d, r);
66 
67  if( n_GetChar(r) == 0 )
68  {
69  TS_ASSERT( n_Equal(sum1, res, r) );
70  TS_ASSERT( n_Equal(res, sum1, r) );
71  }
72  } else
74 
75 
76  n_Delete(&s, r); n_Delete(&i, r);
77 
78  n_Delete(&sum1, r); n_Delete(&res, r);
79 
80 
81  s = n_Init(0 , r);
82  ss = n_Init(0 , r);
83  for( int k = N; k >= 0; k-- )
84  {
85  i = n_Init(k, r);
86  n_InpAdd(s, i, r); // s += i
87 
88  i = n_InpNeg(i, r);
89  n_InpAdd(ss, i, r); // ss -= i
90 
91  n_Delete(&i, r);
92  }
93  clog<< "ss: "; PrintSized(ss, r);
94 
95  ss = n_InpNeg(ss, r); // ss = -ss
96 
97  clog<< "real sum : "; PrintSized(s, r);
98  clog<< "real sum(--): "; PrintSized(ss, r);
99 
100  TS_ASSERT( n_Equal(s, ss, r) );
101  TS_ASSERT( n_Equal(ss, s, r) );
102 
103  n_Delete(&s, r);
104  n_Delete(&ss, r);
105 
106  clog << ( " >>> TEST DONE!" );
107  clog << endl;
108 
109 }
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:673
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:645
#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:542
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:137
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:448
int k
Definition: cfEzgcd.cc:93
#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:650
poly res
Definition: myNF.cc:322
const ring r
Definition: syzextra.cc:208
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:49
#define assume(x)
Definition: mod2.h:394
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:787
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:561
int i
Definition: cfEzgcd.cc:123
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the zero element.
Definition: coeffs.h:468
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:619
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:464
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:459

Variable Documentation

◆ globalPrintingFixture

GlobalPrintingFixture globalPrintingFixture
static

Definition at line 353 of file coeffs_test.h.