My Project
Loading...
Searching...
No Matches
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 ));
261 TS_ASSERT( nCoeff_is_Domain( r ));
262
263 TS_ASSERT( !nCoeff_has_Units( r )); // ?
264 TS_ASSERT( !nCoeff_has_simple_inverse( r ));// ?
265 TS_ASSERT( !nCoeff_has_simple_Alloc( r )); // ?
266
267 TS_ASSERT( !nCoeff_is_Ring_2toM( r ));
268 TS_ASSERT( !nCoeff_is_Zn( r ));
269 TS_ASSERT( !nCoeff_is_Ring_PtoM( r ));
270 TS_ASSERT( !nCoeff_is_Z( r ));
271 TS_ASSERT( !nCoeff_is_Ring( r ));
272 TS_ASSERT( !nCoeff_is_Zp( r ));
273 TS_ASSERT( !nCoeff_is_numeric( 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 ));
279 TS_ASSERT( !nCoeff_is_Extension( 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}
TS_ASSERT_EQUALS
#define TS_ASSERT_EQUALS(x, y)
Definition TestSuite.h:255
TS_ASSERT_DIFFERS
#define TS_ASSERT_DIFFERS(x, y)
Definition TestSuite.h:287
TS_ASSERT
#define TS_ASSERT(e)
Definition TestSuite.h:239
TRUE
#define TRUE
Definition auxiliary.h:101
FALSE
#define FALSE
Definition auxiliary.h:97
NULLp
#define NULLp
Definition auxiliary.h:109
p
int p
Definition cfModGcd.cc:4086
n_R
@ n_R
single prescision (6,6) real numbers
Definition coeffs.h:31
n_GF
@ n_GF
\GF{p^n < 2^16}
Definition coeffs.h:32
n_Q
@ n_Q
rational (GMP) numbers
Definition coeffs.h:30
n_Zn
@ n_Zn
only used if HAVE_RINGS is defined
Definition coeffs.h:44
n_long_R
@ n_long_R
real floating point (GMP) numbers
Definition coeffs.h:33
n_Z2m
@ n_Z2m
only used if HAVE_RINGS is defined
Definition coeffs.h:46
n_long_C
@ n_long_C
complex floating point (GMP) numbers
Definition coeffs.h:41
nInitChar
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition numbers.cc:412
nKillChar
void nKillChar(coeffs r)
undo all initialisations
Definition numbers.cc:563
TestArith
void TestArith(const coeffs r)
Definition coeffs_test.h:109
TestSum
void TestSum(const coeffs r, const unsigned long N)
Definition coeffs_test.h:25
coeffs
The main handler for Singular numbers which are suitable for Singular polynomials.
NULL
#define NULL
Definition omList.c:12
PrintS
void PrintS(const char *s)
Definition reporter.cc:288
PrintLn
void PrintLn()
Definition reporter.cc:314

◆ 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}
N
const CanonicalForm CFMap CFMap & N
Definition cfEzgcd.cc:56

◆ 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
70 TS_ASSERT_EQUALS( n_GetChar(r), 2);
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}
i
int i
Definition cfEzgcd.cc:132
k
int k
Definition cfEzgcd.cc:99
s
const CanonicalForm int s
Definition facAbsFact.cc:51
res
CanonicalForm res
Definition facAbsFact.cc:60
assume
#define assume(x)
Definition mod2.h:389
n_IsZeroDivisor
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:177

Variable Documentation

◆ globalPrintingFixture

GlobalPrintingFixture globalPrintingFixture
static

Definition at line 350 of file coeffs_test.h.

Generated on for My Project by   doxygen 1.18.0 for Singular