My Project
Loading...
Searching...
No Matches
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
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 )); // ?
266
268 TS_ASSERT( !nCoeff_is_Zn( r ));
270 TS_ASSERT( !nCoeff_is_Z( r ));
272 TS_ASSERT( !nCoeff_is_Zp( r ));
274 TS_ASSERT( !nCoeff_is_R( r ));
275 TS_ASSERT( !nCoeff_is_GF( 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 TS_ASSERT_EQUALS(x, y)
Definition TestSuite.h:255
#define TS_ASSERT_DIFFERS(x, y)
Definition TestSuite.h:287
#define TS_ASSERT(e)
Definition TestSuite.h:239
#define TRUE
Definition auxiliary.h:101
#define FALSE
Definition auxiliary.h:97
#define NULLp
Definition auxiliary.h:109
int p
Definition cfModGcd.cc:4086
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....
Definition coeffs.h:776
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:790
static FORCE_INLINE void n_CoeffWrite(const coeffs r, BOOLEAN details=TRUE)
output the coeff description
Definition coeffs.h:720
static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
Definition coeffs.h:832
static FORCE_INLINE BOOLEAN nCoeff_is_Z(const coeffs r)
Definition coeffs.h:809
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
Definition coeffs.h:839
static FORCE_INLINE BOOLEAN nCoeff_is_long_R(const coeffs r)
Definition coeffs.h:884
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_PtoM(const coeffs r)
Definition coeffs.h:727
@ n_R
single prescision (6,6) real numbers
Definition coeffs.h:31
@ n_GF
\GF{p^n < 2^16}
Definition coeffs.h:32
@ n_Q
rational (GMP) numbers
Definition coeffs.h:30
@ n_Zn
only used if HAVE_RINGS is defined
Definition coeffs.h:44
@ n_long_R
real floating point (GMP) numbers
Definition coeffs.h:33
@ n_Z2m
only used if HAVE_RINGS is defined
Definition coeffs.h:46
@ n_long_C
complex floating point (GMP) numbers
Definition coeffs.h:41
static FORCE_INLINE BOOLEAN nCoeff_is_CF(const coeffs r)
Definition coeffs.h:890
static FORCE_INLINE BOOLEAN nCoeff_is_numeric(const coeffs r)
Definition coeffs.h:825
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:734
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:895
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
Definition coeffs.h:799
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition numbers.cc:406
static FORCE_INLINE void nSetChar(const coeffs r)
initialisations after each ring change
Definition coeffs.h:444
static FORCE_INLINE BOOLEAN nCoeff_has_simple_Alloc(const coeffs r)
TRUE if n_Delete is empty operation.
Definition coeffs.h:899
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
Definition coeffs.h:730
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition coeffs.h:429
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition coeffs.h:448
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition coeffs.h:459
static FORCE_INLINE BOOLEAN nCoeff_is_Zn(const coeffs r)
Definition coeffs.h:819
static FORCE_INLINE int n_NumberOfParameters(const coeffs r)
Returns the number of parameters.
Definition coeffs.h:767
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition coeffs.h:793
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_2toM(const coeffs r)
Definition coeffs.h:724
static FORCE_INLINE BOOLEAN nCoeff_is_R(const coeffs r)
Definition coeffs.h:829
static FORCE_INLINE BOOLEAN nCoeff_is_long_C(const coeffs r)
Definition coeffs.h:887
void nKillChar(coeffs r)
undo all initialisations
Definition numbers.cc:556
void TestArith(const coeffs r)
void TestSum(const coeffs r, const unsigned long N)
Definition coeffs_test.h:25
The main handler for Singular numbers which are suitable for Singular polynomials.
#define NULL
Definition omList.c:12
void PrintS(const char *s)
Definition reporter.cc:284
void PrintLn()
Definition reporter.cc:310

◆ 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}
const CanonicalForm CFMap CFMap & N
Definition cfEzgcd.cc:56
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of 'a' and 'b', i.e., a*b
Definition coeffs.h:637
static FORCE_INLINE number n_Add(number a, number b, const coeffs r)
return the sum of 'a' and 'b', i.e., a+b
Definition coeffs.h:651
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
Definition coeffs.h:468
static FORCE_INLINE number n_Sub(number a, number b, const coeffs r)
return the difference of 'a' and 'b', i.e., a-b
Definition coeffs.h:656
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:539
static FORCE_INLINE BOOLEAN n_Equal(number a, number b, const coeffs r)
TRUE iff 'a' and 'b' represent the same number; they may have different representations.
Definition coeffs.h:464
static FORCE_INLINE void n_InpAdd(number &a, number b, const coeffs r)
addition of 'a' and 'b'; replacement of 'a' by the sum a+b
Definition coeffs.h:647

◆ 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);
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}
int i
Definition cfEzgcd.cc:132
int k
Definition cfEzgcd.cc:99
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:558
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of 'a' and 'b', i.e., a/b; raises an error if 'b' is not invertible in r exceptio...
Definition coeffs.h:616
static FORCE_INLINE BOOLEAN n_DivBy(number a, number b, const coeffs r)
test whether 'a' is divisible 'b'; for r encoding a field: TRUE iff 'b' does not represent zero in Z:...
Definition coeffs.h:748
static FORCE_INLINE void n_InpMult(number &a, number b, const coeffs r)
multiplication of 'a' and 'b'; replacement of 'a' by the product a*b
Definition coeffs.h:642
const CanonicalForm int s
Definition facAbsFact.cc:51
CanonicalForm res
Definition facAbsFact.cc:60
#define assume(x)
Definition mod2.h:389
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:171

Variable Documentation

◆ globalPrintingFixture

GlobalPrintingFixture globalPrintingFixture
static

Definition at line 350 of file coeffs_test.h.