[4f684a] | 1 | #include "config.h" |
---|
| 2 | |
---|
[b27c052] | 3 | #include "common.h" |
---|
| 4 | using namespace std; |
---|
[4f684a] | 5 | |
---|
[17e473] | 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 | |
---|
[fba6f18] | 17 | #include <polys/ext_fields/algext.h> |
---|
[4f684a] | 18 | #include <polys/monomials/ring.h> |
---|
[b27c052] | 19 | #include <polys/monomials/p_polys.h> |
---|
[4f684a] | 20 | |
---|
[fba6f18] | 21 | #include <polys/simpleideals.h> |
---|
[4f684a] | 22 | |
---|
[b27c052] | 23 | class MyGlobalPrintingFixture : public GlobalPrintingFixture |
---|
[17e473] | 24 | { |
---|
| 25 | public: |
---|
[b27c052] | 26 | virtual bool setUpWorld() |
---|
| 27 | { |
---|
| 28 | |
---|
| 29 | GlobalPrintingFixture::setUpWorld(); |
---|
[59a62bd] | 30 | |
---|
[b27c052] | 31 | |
---|
[17e473] | 32 | TS_ASSERT_EQUALS( nRegister( n_Zp, npInitChar), n_Zp ); |
---|
| 33 | TS_ASSERT_EQUALS( nRegister( n_GF, nfInitChar), n_GF ); |
---|
| 34 | TS_ASSERT_EQUALS( nRegister( n_R, nrInitChar), n_R ); |
---|
| 35 | TS_ASSERT_EQUALS( nRegister( n_Q, nlInitChar), n_Q ); |
---|
| 36 | TS_ASSERT_EQUALS( nRegister( n_R, nrInitChar), n_R ); |
---|
| 37 | |
---|
| 38 | #ifdef HAVE_RINGS |
---|
| 39 | TS_ASSERT_EQUALS( nRegister( n_Z, nrzInitChar), n_Z ); // these are UNusable at the moment! |
---|
| 40 | #endif |
---|
| 41 | |
---|
| 42 | return true; |
---|
| 43 | } |
---|
| 44 | }; |
---|
| 45 | |
---|
| 46 | |
---|
| 47 | // |
---|
| 48 | // We can rely on this file being included exactly once |
---|
| 49 | // and declare this global variable in the header file. |
---|
| 50 | // |
---|
[b27c052] | 51 | static MyGlobalPrintingFixture globalPrintingFixture; |
---|
[17e473] | 52 | |
---|
| 53 | |
---|
| 54 | namespace |
---|
| 55 | { |
---|
[bfde6c] | 56 | |
---|
[17e473] | 57 | void PrintRing(const ring r) |
---|
| 58 | { |
---|
| 59 | rWrite(r); PrintLn(); |
---|
| 60 | #ifdef RDEBUG |
---|
| 61 | rDebugPrint(r); PrintLn(); |
---|
| 62 | #endif |
---|
| 63 | } |
---|
[b27c052] | 64 | |
---|
| 65 | static inline std::string _2S(poly a, const ring r) |
---|
| 66 | { |
---|
| 67 | p_Test(a,r); |
---|
| 68 | |
---|
| 69 | StringSetS(""); |
---|
| 70 | p_Write(a, r); |
---|
| 71 | |
---|
| 72 | const char* s = StringAppendS(""); |
---|
| 73 | |
---|
| 74 | std::stringstream ss; ss << s; |
---|
| 75 | |
---|
| 76 | StringSetS(""); |
---|
| 77 | return ss.str(); |
---|
| 78 | } |
---|
| 79 | |
---|
| 80 | static inline void PrintSized(/*const*/ poly a, const ring r, BOOLEAN eoln = TRUE) |
---|
| 81 | { |
---|
| 82 | std::clog << _2S(a, r) << ", of size: " << p_Size(a, r); |
---|
| 83 | |
---|
| 84 | if( eoln ) |
---|
| 85 | std::clog << std::endl; |
---|
| 86 | } |
---|
| 87 | |
---|
| 88 | static inline void Delete(poly &p, const ring r) |
---|
| 89 | { |
---|
| 90 | if( p != NULL ) |
---|
| 91 | p_Delete(&p, r); |
---|
| 92 | |
---|
| 93 | p = NULL; |
---|
| 94 | } |
---|
| 95 | |
---|
[b5b9dc] | 96 | void TestSum(const ring r, const int N) |
---|
[b27c052] | 97 | { |
---|
[bfde6c] | 98 | TS_ASSERT_DIFFERS( r , NULLp); |
---|
| 99 | TS_ASSERT_DIFFERS( r->cf, NULLp); |
---|
| 100 | |
---|
| 101 | |
---|
[b27c052] | 102 | clog << ( _2S("TEST: sum[0..") + _2S(N) + "]: "); |
---|
| 103 | clog << endl; |
---|
| 104 | |
---|
| 105 | assume( N > 0 ); // just for now... |
---|
| 106 | |
---|
[b5b9dc] | 107 | const int ssss = (N * (N+1)) / 2; |
---|
[b27c052] | 108 | |
---|
[b5b9dc] | 109 | poly sum1 = p_ISet(ssss, r); |
---|
[b27c052] | 110 | clog<< "poly(N*(N+1)/2) (int: " << ssss << "): "; PrintSized(sum1, r); |
---|
| 111 | |
---|
[b5b9dc] | 112 | poly s=NULL, ss=NULL, i=NULL, res=NULL; |
---|
[b27c052] | 113 | |
---|
[b5b9dc] | 114 | s = p_ISet(N , r); |
---|
| 115 | i = p_ISet(N+1, r); |
---|
[b27c052] | 116 | |
---|
| 117 | i = p_Mult_q(s, i, r); s = NULL; |
---|
| 118 | |
---|
| 119 | clog<< "poly(N)*poly(N+1): (int: "<< N*(N+1) << "): "; PrintSized(i, r); |
---|
| 120 | |
---|
| 121 | number t = n_Init(2, r->cf); |
---|
[bfde6c] | 122 | clog<< "number(2): "; PrintSized(t, r->cf); |
---|
[b27c052] | 123 | |
---|
| 124 | if( !n_IsZero( t, r->cf) ) |
---|
| 125 | { |
---|
[bfde6c] | 126 | if( i != NULL ) |
---|
| 127 | { |
---|
| 128 | number ii = p_GetCoeff(i, r); |
---|
| 129 | clog<< "number(poly(N)*poly(N+1)): "; PrintSized(ii, r->cf); |
---|
| 130 | |
---|
[6c5f32] | 131 | #ifdef HAVE_RINGS |
---|
[bfde6c] | 132 | TS_ASSERT( n_DivBy(ii, t, r->cf) ); |
---|
[6c5f32] | 133 | #endif |
---|
| 134 | res = p_Div_nn(i, t, r); i = NULL; |
---|
[bfde6c] | 135 | } |
---|
[b27c052] | 136 | |
---|
[bfde6c] | 137 | |
---|
| 138 | |
---|
| 139 | clog<< "(poly(N)*poly(N+1))/number(2): "; PrintSized(res, r); |
---|
| 140 | poly d = p_Sub(p_Copy(res, r), p_Copy(sum1, r), r); |
---|
| 141 | |
---|
[b27c052] | 142 | if( d != NULL ) |
---|
| 143 | TS_ASSERT( n_IsZeroDivisor(p_GetCoeff(d, r), r->cf) ); |
---|
[bfde6c] | 144 | |
---|
[b27c052] | 145 | Delete(d, r); |
---|
[bfde6c] | 146 | |
---|
[b27c052] | 147 | if( n_GetChar(r->cf) == 0 ) |
---|
| 148 | { |
---|
| 149 | TS_ASSERT( p_EqualPolys(sum1, res, r) ); |
---|
| 150 | TS_ASSERT( p_EqualPolys(res, sum1, r) ); |
---|
| 151 | } |
---|
| 152 | } else |
---|
| 153 | TS_ASSERT_EQUALS( n_GetChar(r->cf), 2); |
---|
| 154 | |
---|
| 155 | n_Delete(&t, r->cf); |
---|
| 156 | |
---|
| 157 | |
---|
[b5b9dc] | 158 | s = NULL; |
---|
| 159 | ss = NULL; |
---|
[b27c052] | 160 | for( int k = N; k >= 0; k-- ) |
---|
| 161 | { |
---|
[b5b9dc] | 162 | i = p_ISet(k, r); |
---|
[b27c052] | 163 | s = p_Add_q(s, i, r); // s += i |
---|
| 164 | |
---|
[b5b9dc] | 165 | i = p_Neg( p_ISet(k, r), r ); |
---|
[b27c052] | 166 | ss = p_Add_q(ss, i, r); // ss -= i |
---|
| 167 | } |
---|
| 168 | |
---|
| 169 | clog<< "ss(-sum): "; PrintSized(ss, r); |
---|
| 170 | |
---|
| 171 | ss = p_Neg(ss, r); // ss = -ss |
---|
| 172 | |
---|
| 173 | clog<< "real sum : "; PrintSized(s, r); |
---|
| 174 | clog<< "real sum(--): "; PrintSized(ss, r); |
---|
| 175 | |
---|
| 176 | TS_ASSERT( p_EqualPolys(s, ss, r) ); |
---|
| 177 | TS_ASSERT( p_EqualPolys(ss, s, r) ); |
---|
| 178 | |
---|
| 179 | TODO(somebody, fix the delete method!); |
---|
[b7d7eb] | 180 | |
---|
[b27c052] | 181 | Delete(sum1, r); |
---|
| 182 | Delete(res, r); |
---|
| 183 | |
---|
| 184 | Delete(s, r); |
---|
| 185 | Delete(ss, r); |
---|
[b7d7eb] | 186 | |
---|
[b27c052] | 187 | clog << ( " >>> TEST DONE!" ); |
---|
| 188 | clog << endl; |
---|
| 189 | |
---|
| 190 | } |
---|
| 191 | |
---|
| 192 | void Test(const ring r) |
---|
| 193 | { |
---|
[ae6d28] | 194 | if( r == NULL ) |
---|
| 195 | TS_FAIL("Could not get needed ring"); |
---|
| 196 | else |
---|
| 197 | { |
---|
| 198 | TestSum( r, 10 ); |
---|
| 199 | TestSum( r, 100 ); |
---|
| 200 | TestSum( r, 101 ); |
---|
| 201 | TestSum( r, 1001 ); |
---|
| 202 | TestSum( r, 9000 ); |
---|
| 203 | } |
---|
[b27c052] | 204 | } |
---|
| 205 | |
---|
[17e473] | 206 | } |
---|
| 207 | |
---|
[4f684a] | 208 | class PolysTestSuite : public CxxTest::TestSuite |
---|
| 209 | { |
---|
[c28ecf] | 210 | private: |
---|
[cfb500] | 211 | /* replaces n by n + c * var^exp (in-place); |
---|
| 212 | expects exp >= 0 */ |
---|
| 213 | void plusTerm(number &n, int c, int exp, const coeffs cf) |
---|
| 214 | { |
---|
| 215 | number x = n_Par(1, cf); |
---|
| 216 | number pow = n_Init(1, cf); |
---|
| 217 | number temp; |
---|
| 218 | for (int i = 1; i <= exp; i++) |
---|
| 219 | { |
---|
| 220 | temp = n_Mult(pow, x, cf); |
---|
| 221 | n_Delete(&pow, cf); |
---|
| 222 | pow = temp; |
---|
| 223 | } |
---|
| 224 | n_Delete(&x, cf); |
---|
| 225 | number m = n_Init(c, cf); |
---|
| 226 | number t = n_Mult(m, pow, cf); |
---|
| 227 | n_Delete(&m, cf); n_Delete(&pow, cf); |
---|
| 228 | temp = n_Add(n, t, cf); |
---|
| 229 | n_Delete(&n, cf); n_Delete(&t, cf); |
---|
| 230 | n = temp; |
---|
| 231 | } |
---|
[4a2260e] | 232 | void checkInverse(number n, const coeffs cf) |
---|
| 233 | { |
---|
| 234 | clog << "n = "; n_Write(n, cf); |
---|
| 235 | number n1 = n_Invers(n, cf); |
---|
| 236 | clog << "==> n^(-1) = "; n_Write(n1, cf); |
---|
| 237 | number n2 = n_Mult(n, n1, cf); |
---|
| 238 | clog << "(check: n * n^(-1) = "; n_Write(n2, cf); |
---|
[cfb500] | 239 | TS_ASSERT( n_IsOne(n2, cf) ); |
---|
[4a2260e] | 240 | n_Delete(&n1, cf); n_Delete(&n2, cf); |
---|
| 241 | } |
---|
[c28ecf] | 242 | void TestArithCf(const coeffs r) |
---|
| 243 | { |
---|
| 244 | clog << ("TEST: Simple Arithmetics: "); |
---|
| 245 | clog << endl; |
---|
| 246 | |
---|
| 247 | number two = n_Init(2, r); |
---|
| 248 | |
---|
| 249 | number t = n_Init(1, r); |
---|
| 250 | ndInpAdd(t, t, r); |
---|
| 251 | TS_ASSERT( n_Equal(two, t, r) ); |
---|
| 252 | n_Delete(&t, r); |
---|
| 253 | |
---|
| 254 | if( getCoeffType(r) == n_Q ) |
---|
| 255 | { |
---|
| 256 | number t = n_Init(1, r); |
---|
| 257 | nlInpAdd(t, t, r); |
---|
| 258 | TS_ASSERT( n_Equal(two, t, r) ); |
---|
| 259 | n_Delete(&t, r); |
---|
| 260 | } |
---|
| 261 | |
---|
| 262 | const int N = 66666; |
---|
| 263 | |
---|
| 264 | number a = n_Init(N, r); |
---|
| 265 | |
---|
| 266 | clog<< "a: "; PrintSized(a, r); |
---|
| 267 | |
---|
| 268 | clog<< "two: "; PrintSized(two, r); |
---|
| 269 | |
---|
| 270 | number aa0 = n_Init(N*2, r); |
---|
| 271 | |
---|
| 272 | number aa = n_Add(a, a, r); |
---|
| 273 | |
---|
| 274 | clog<< "aa = a + a: "; PrintSized(aa, r); |
---|
| 275 | |
---|
| 276 | number aa2 = n_Mult(a, two, r); |
---|
| 277 | |
---|
| 278 | clog<< "aa2 = a * 2: "; PrintSized(aa2, r); |
---|
| 279 | |
---|
| 280 | number aa1 = n_Mult(two, a, r); |
---|
| 281 | |
---|
| 282 | clog<< "aa1 = 2 * a: "; PrintSized(aa1, r); |
---|
| 283 | |
---|
| 284 | n_Delete(&a, r); |
---|
| 285 | n_Delete(&two, r); |
---|
| 286 | |
---|
| 287 | a = n_Sub( aa, aa1, r ); |
---|
| 288 | |
---|
| 289 | clog<< "a = aa - aa1: "; PrintSized(a, r); |
---|
| 290 | |
---|
| 291 | TS_ASSERT( n_IsZero(a, r) ); |
---|
| 292 | |
---|
| 293 | n_Delete(&a, r); |
---|
| 294 | |
---|
| 295 | a = n_Sub( aa, aa2, r ); |
---|
| 296 | |
---|
| 297 | clog<< "a = aa - aa2: "; PrintSized(a, r); |
---|
| 298 | |
---|
| 299 | TS_ASSERT( n_IsZero(a, r) ); |
---|
| 300 | |
---|
| 301 | n_Delete(&a, r); |
---|
| 302 | |
---|
| 303 | a = n_Sub( aa1, aa2, r ); |
---|
| 304 | |
---|
| 305 | clog<< "a = aa1 - aa2: "; PrintSized(a, r); |
---|
| 306 | |
---|
| 307 | TS_ASSERT( n_IsZero(a, r) ); |
---|
| 308 | |
---|
| 309 | n_Delete(&a, r); |
---|
| 310 | |
---|
| 311 | TS_ASSERT( n_Equal(aa, aa1, r) ); |
---|
| 312 | TS_ASSERT( n_Equal(aa, aa2, r) ); |
---|
| 313 | TS_ASSERT( n_Equal(aa1, aa2, r) ); |
---|
| 314 | |
---|
| 315 | TS_ASSERT( n_Equal(aa0, aa, r) ); |
---|
| 316 | TS_ASSERT( n_Equal(aa0, aa1, r) ); |
---|
| 317 | TS_ASSERT( n_Equal(aa0, aa2, r) ); |
---|
| 318 | |
---|
| 319 | n_Delete(&aa, r); |
---|
| 320 | n_Delete(&aa1, r); |
---|
| 321 | n_Delete(&aa2, r); |
---|
| 322 | |
---|
| 323 | n_Delete(&aa0, r); |
---|
| 324 | |
---|
| 325 | clog << ( " >>> TEST DONE!" ); |
---|
| 326 | clog << endl; |
---|
| 327 | } |
---|
| 328 | void TestSumCf(const coeffs r, const unsigned long N) |
---|
| 329 | { |
---|
| 330 | clog << ( _2S("TEST: sum[0..") + _2S(N) + "]: "); |
---|
| 331 | clog << endl; |
---|
| 332 | |
---|
| 333 | assume( N > 0 ); // just for now... |
---|
| 334 | |
---|
| 335 | const unsigned long ssss = (N * (N+1)) / 2; |
---|
| 336 | |
---|
| 337 | number sum1 = n_Init(ssss, r); |
---|
| 338 | clog<< "N*(N+1)/2 (int: " << ssss << "): "; PrintSized(sum1, r); |
---|
| 339 | |
---|
| 340 | number s, ss, i, res; |
---|
| 341 | |
---|
| 342 | s = n_Init(N , r); |
---|
| 343 | i = n_Init(N+1, r); |
---|
| 344 | ndInpMult(s, i, r); |
---|
| 345 | n_Delete(&i, r); |
---|
| 346 | |
---|
| 347 | clog<< "N*(N+1): ("<< N*(N+1) << ")"; PrintSized(s, r); |
---|
| 348 | |
---|
| 349 | i = n_Init(2, r); |
---|
| 350 | clog<< "2: "; PrintSized(i, r); |
---|
| 351 | |
---|
| 352 | if( !n_IsZero( i, r) ) |
---|
| 353 | { |
---|
| 354 | #ifdef HAVE_RINGS |
---|
| 355 | TS_ASSERT( n_DivBy(s, i, r) ); |
---|
| 356 | #endif |
---|
| 357 | |
---|
| 358 | res = n_Div(s, i, r); |
---|
| 359 | |
---|
| 360 | clog<< "N*(N+1)/2: "; PrintSized(res, r); |
---|
| 361 | |
---|
| 362 | |
---|
| 363 | number d = n_Sub(res, sum1, r); |
---|
| 364 | TS_ASSERT( n_IsZeroDivisor(d, r) ); |
---|
| 365 | n_Delete(&d, r); |
---|
| 366 | |
---|
| 367 | if( n_GetChar(r) == 0 ) |
---|
| 368 | { |
---|
| 369 | TS_ASSERT( n_Equal(sum1, res, r) ); |
---|
| 370 | TS_ASSERT( n_Equal(res, sum1, r) ); |
---|
| 371 | } |
---|
| 372 | } else |
---|
| 373 | TS_ASSERT_EQUALS( n_GetChar(r), 2); |
---|
| 374 | |
---|
| 375 | |
---|
| 376 | n_Delete(&s, r); n_Delete(&i, r); |
---|
| 377 | |
---|
| 378 | n_Delete(&sum1, r); n_Delete(&res, r); |
---|
| 379 | |
---|
| 380 | |
---|
| 381 | s = n_Init(0 , r); |
---|
| 382 | ss = n_Init(0 , r); |
---|
| 383 | for( int k = N; k >= 0; k-- ) |
---|
| 384 | { |
---|
| 385 | i = n_Init(k, r); |
---|
| 386 | ndInpAdd(s, i, r); // s += i |
---|
| 387 | |
---|
| 388 | i = n_Neg(i, r); |
---|
| 389 | ndInpAdd(ss, i, r); // ss -= i |
---|
| 390 | |
---|
| 391 | n_Delete(&i, r); |
---|
| 392 | } |
---|
| 393 | clog<< "ss: "; PrintSized(ss, r); |
---|
| 394 | |
---|
| 395 | ss = n_Neg(ss, r); // ss = -ss |
---|
| 396 | |
---|
| 397 | clog<< "real sum : "; PrintSized(s, r); |
---|
| 398 | clog<< "real sum(--): "; PrintSized(ss, r); |
---|
| 399 | |
---|
| 400 | TS_ASSERT( n_Equal(s, ss, r) ); |
---|
| 401 | TS_ASSERT( n_Equal(ss, s, r) ); |
---|
| 402 | |
---|
| 403 | n_Delete(&s, r); |
---|
| 404 | n_Delete(&ss, r); |
---|
| 405 | |
---|
| 406 | clog << ( " >>> TEST DONE!" ); |
---|
| 407 | clog << endl; |
---|
| 408 | |
---|
| 409 | } |
---|
[4f684a] | 410 | public: |
---|
[17e473] | 411 | void test_Z13_t() |
---|
| 412 | { |
---|
| 413 | clog << "Creating Z/13[t]: " << endl; |
---|
| 414 | |
---|
| 415 | char* n[] = {"t"}; |
---|
| 416 | ring r = rDefault( 13, 1, n); |
---|
| 417 | TS_ASSERT_DIFFERS( r, NULLp ); |
---|
| 418 | |
---|
| 419 | PrintRing(r); |
---|
| 420 | |
---|
| 421 | TS_ASSERT( rField_is_Domain(r) ); |
---|
| 422 | TS_ASSERT( !rField_is_Q(r) ); |
---|
| 423 | |
---|
| 424 | TS_ASSERT( rField_is_Zp(r) ); |
---|
| 425 | TS_ASSERT( !rField_is_Zp(r, 11) ); |
---|
| 426 | TS_ASSERT( rField_is_Zp(r, 13) ); |
---|
| 427 | |
---|
| 428 | TS_ASSERT_EQUALS( rVar(r), 1); |
---|
| 429 | |
---|
[b27c052] | 430 | Test(r); |
---|
| 431 | |
---|
[17e473] | 432 | rDelete(r); |
---|
| 433 | } |
---|
| 434 | |
---|
| 435 | void test_QQ_t() |
---|
| 436 | { |
---|
| 437 | clog << "Creating Q[s]: " << endl; |
---|
| 438 | |
---|
| 439 | char* n[] = {"s"}; |
---|
| 440 | ring r = rDefault( 0, 1, n); |
---|
| 441 | TS_ASSERT_DIFFERS( r, NULLp ); |
---|
| 442 | |
---|
| 443 | PrintRing(r); |
---|
| 444 | |
---|
| 445 | TS_ASSERT( rField_is_Domain(r) ); |
---|
| 446 | TS_ASSERT( rField_is_Q(r) ); |
---|
| 447 | |
---|
| 448 | TS_ASSERT( !rField_is_Zp(r) ); |
---|
| 449 | TS_ASSERT( !rField_is_Zp(r, 11) ); |
---|
| 450 | |
---|
| 451 | TS_ASSERT_EQUALS( rVar(r), 1); |
---|
| 452 | |
---|
[b27c052] | 453 | Test(r); |
---|
| 454 | |
---|
[17e473] | 455 | rDelete(r); |
---|
| 456 | } |
---|
| 457 | |
---|
| 458 | void test_Z11_x_y_z() |
---|
| 459 | { |
---|
| 460 | clog << "Creating Z/11[x, y, z]: " << endl; |
---|
| 461 | |
---|
| 462 | char* n[] = {"x", "y", "z"}; |
---|
| 463 | ring r = rDefault( 11, 3, n); |
---|
[4f684a] | 464 | TS_ASSERT_DIFFERS( r, NULLp ); |
---|
| 465 | |
---|
[17e473] | 466 | PrintRing(r); |
---|
[4f684a] | 467 | |
---|
[17e473] | 468 | TS_ASSERT( rField_is_Domain(r) ); |
---|
| 469 | TS_ASSERT( !rField_is_Q(r) ); |
---|
| 470 | |
---|
| 471 | TS_ASSERT( rField_is_Zp(r) ); |
---|
| 472 | TS_ASSERT( rField_is_Zp(r, 11) ); |
---|
| 473 | TS_ASSERT( !rField_is_Zp(r, 13) ); |
---|
| 474 | |
---|
| 475 | TS_ASSERT_EQUALS( rVar(r), 3); |
---|
| 476 | |
---|
[b27c052] | 477 | Test(r); |
---|
| 478 | |
---|
[17e473] | 479 | rDelete(r); |
---|
| 480 | } |
---|
| 481 | void test_QQ_x_y_z() |
---|
| 482 | { |
---|
| 483 | clog << "Creating QQ[x, y, z, u]: " << endl; |
---|
| 484 | |
---|
| 485 | char* n[] = {"x", "y", "z", "u"}; |
---|
| 486 | ring r = rDefault( 0, 4, n); |
---|
| 487 | TS_ASSERT_DIFFERS( r, NULLp ); |
---|
| 488 | |
---|
| 489 | PrintRing(r); |
---|
| 490 | |
---|
| 491 | TS_ASSERT( rField_is_Domain(r) ); |
---|
| 492 | TS_ASSERT( rField_is_Q(r) ); |
---|
| 493 | |
---|
| 494 | TS_ASSERT( !rField_is_Zp(r) ); |
---|
| 495 | TS_ASSERT( !rField_is_Zp(r, 11) ); |
---|
| 496 | |
---|
| 497 | TS_ASSERT_EQUALS( rVar(r), 4); |
---|
| 498 | |
---|
[b27c052] | 499 | Test(r); |
---|
| 500 | |
---|
[8c9912] | 501 | rDelete(r); |
---|
[4f684a] | 502 | } |
---|
[17e473] | 503 | |
---|
| 504 | |
---|
| 505 | void test_Z13_t_GF() |
---|
| 506 | { |
---|
[17b0b05] | 507 | StringSetS("ressources in use (as reported by feStringAppendResources(0):\n"); |
---|
| 508 | feStringAppendResources(0); |
---|
| 509 | PrintS(StringAppendS("\n")); |
---|
| 510 | |
---|
[17e473] | 511 | clog << "Creating GF[t]: " << endl; |
---|
| 512 | |
---|
| 513 | char* n[] = {"t"}; |
---|
| 514 | |
---|
| 515 | GFInfo param; |
---|
| 516 | |
---|
| 517 | param.GFChar= 5; |
---|
| 518 | param.GFDegree= 2; |
---|
| 519 | param.GFPar_name= (const char*)"Q"; |
---|
| 520 | |
---|
| 521 | const coeffs cf = nInitChar( n_GF, ¶m ); |
---|
| 522 | |
---|
[ae6d28] | 523 | if( cf == NULL ) |
---|
| 524 | TS_FAIL("Could not get needed coeff. domain"); |
---|
| 525 | |
---|
[17e473] | 526 | TS_ASSERT_DIFFERS( cf, NULLp ); |
---|
| 527 | |
---|
| 528 | ring r = rDefault( cf, 1, n); // now cf belongs to r! |
---|
| 529 | TS_ASSERT_DIFFERS( r, NULLp ); |
---|
| 530 | |
---|
| 531 | PrintRing(r); |
---|
| 532 | |
---|
| 533 | TS_ASSERT( rField_is_Domain(r) ); |
---|
| 534 | TS_ASSERT( !rField_is_Q(r) ); |
---|
| 535 | |
---|
| 536 | TS_ASSERT( !rField_is_Zp(r) ); |
---|
| 537 | TS_ASSERT( !rField_is_Zp(r, 11) ); |
---|
| 538 | TS_ASSERT( !rField_is_Zp(r, 13) ); |
---|
| 539 | TS_ASSERT( rField_is_GF(r) ); |
---|
| 540 | |
---|
[4f07ef] | 541 | TS_ASSERT( rField_is_GF(r, 5) ); |
---|
| 542 | TS_ASSERT( !rField_is_GF(r, 25) ); |
---|
[17e473] | 543 | |
---|
| 544 | TS_ASSERT_EQUALS( rVar(r), 1); |
---|
| 545 | |
---|
[b27c052] | 546 | Test(r); |
---|
| 547 | |
---|
[17e473] | 548 | rDelete(r); // kills 'cf' as well! |
---|
| 549 | } |
---|
[fba6f18] | 550 | |
---|
| 551 | void test_Q_Ext_a() |
---|
| 552 | { |
---|
| 553 | clog << "Start by creating Q[a]..." << endl; |
---|
| 554 | |
---|
| 555 | char* n[] = {"a"}; |
---|
| 556 | ring r = rDefault( 0, 1, n); // Q[a] |
---|
| 557 | TS_ASSERT_DIFFERS( r, NULLp ); |
---|
| 558 | |
---|
| 559 | PrintRing(r); |
---|
| 560 | |
---|
| 561 | TS_ASSERT( rField_is_Domain(r) ); |
---|
| 562 | TS_ASSERT( rField_is_Q(r) ); |
---|
| 563 | |
---|
| 564 | TS_ASSERT( !rField_is_Zp(r) ); |
---|
| 565 | TS_ASSERT( !rField_is_Zp(r, 11) ); |
---|
| 566 | |
---|
| 567 | TS_ASSERT_EQUALS( rVar(r), 1); |
---|
| 568 | |
---|
| 569 | poly minPoly = p_ISet(1, r); // minPoly = 1 |
---|
| 570 | p_SetExp(minPoly, 1, 2, r); p_Setm(minPoly, r); // minPoly = a^2 |
---|
| 571 | minPoly = p_Add_q(minPoly, p_ISet(1, r), r); // minPoly = a^2 + 1 |
---|
| 572 | ideal minIdeal = idInit(1); // minIdeal = < 0 > |
---|
| 573 | minIdeal->m[0] = minPoly; // minIdeal = < a^2 + 1 > |
---|
| 574 | |
---|
| 575 | n_coeffType type = nRegister(n_Ext, naInitChar); |
---|
| 576 | TS_ASSERT(type == n_Ext); |
---|
| 577 | |
---|
| 578 | ExtInfo extParam; |
---|
| 579 | extParam.r = r; |
---|
| 580 | extParam.i = minIdeal; |
---|
| 581 | |
---|
| 582 | clog << "Next create the extension field Q[a]/<a2+1>..." << endl; |
---|
| 583 | |
---|
| 584 | const coeffs cf = nInitChar(type, &extParam); // Q[a]/<a2+1> |
---|
[ae6d28] | 585 | |
---|
| 586 | if( cf == NULL ) |
---|
| 587 | TS_FAIL("Could not get needed coeff. domain"); |
---|
[fba6f18] | 588 | |
---|
| 589 | TS_ASSERT_DIFFERS( cf->cfCoeffWrite, NULLp ); |
---|
| 590 | |
---|
| 591 | if( cf->cfCoeffWrite != NULL ) |
---|
| 592 | { |
---|
| 593 | clog << "Coeff-domain: " << endl; |
---|
| 594 | n_CoeffWrite(cf); PrintLn(); |
---|
| 595 | } |
---|
[c28ecf] | 596 | |
---|
| 597 | // some tests for the coefficient field represented by cf: |
---|
| 598 | TestArithCf(cf); |
---|
| 599 | TestSumCf(cf, 10); |
---|
| 600 | TestSumCf(cf, 100); |
---|
| 601 | TestSumCf(cf, 101); |
---|
| 602 | TestSumCf(cf, 1001); |
---|
| 603 | TestSumCf(cf, 9000); |
---|
[fba6f18] | 604 | |
---|
| 605 | clog << "Finally create the polynomial ring (Q[a]/<a2+1>)[x, y]..." |
---|
| 606 | << endl; |
---|
| 607 | |
---|
| 608 | char* m[] = {"x", "y"}; |
---|
| 609 | ring s = rDefault(cf, 2, m); // (Q[a]/<a2+1>)[x, y] |
---|
| 610 | TS_ASSERT_DIFFERS(s, NULLp); |
---|
[17e473] | 611 | |
---|
[fba6f18] | 612 | PrintRing(s); |
---|
| 613 | |
---|
| 614 | TS_ASSERT( rField_is_Domain(s) ); |
---|
| 615 | TS_ASSERT( !rField_is_Q(s) ); |
---|
| 616 | TS_ASSERT( !rField_is_Zp(s) ); |
---|
| 617 | TS_ASSERT( !rField_is_Zp(s, 11) ); |
---|
| 618 | TS_ASSERT( !rField_is_Zp(s, 13) ); |
---|
| 619 | TS_ASSERT( !rField_is_GF(s) ); |
---|
| 620 | TS_ASSERT( rField_is_Extension(s) ); |
---|
| 621 | TS_ASSERT( !rField_is_GF(s, 25) ); |
---|
| 622 | TS_ASSERT_EQUALS(rVar(s), 2); |
---|
| 623 | |
---|
[c28ecf] | 624 | Test(s); |
---|
[4a2260e] | 625 | |
---|
| 626 | clog << endl |
---|
[cfb500] | 627 | << "Now let's compute some inverses in Q[a]/<a^2+1>..." |
---|
| 628 | << endl; |
---|
| 629 | |
---|
| 630 | number u; |
---|
| 631 | u = NULL; plusTerm(u, 1, 1, cf); plusTerm(u, 1, 0, cf); // a + 1 |
---|
| 632 | checkInverse(u, cf); n_Delete(&u, cf); |
---|
| 633 | u = NULL; plusTerm(u, 1, 1, cf); plusTerm(u, -1, 0, cf); // a - 1 |
---|
| 634 | checkInverse(u, cf); n_Delete(&u, cf); |
---|
| 635 | u = NULL; plusTerm(u, 1, 1, cf); plusTerm(u, 5, 0, cf); // a + 5 |
---|
| 636 | checkInverse(u, cf); n_Delete(&u, cf); |
---|
| 637 | u = NULL; plusTerm(u, 1, 1, cf); plusTerm(u, -5, 0, cf); // a - 5 |
---|
| 638 | checkInverse(u, cf); n_Delete(&u, cf); |
---|
| 639 | u = NULL; plusTerm(u, 17, 1, cf); plusTerm(u, 5, 0, cf); // 17a + 5 |
---|
| 640 | checkInverse(u, cf); n_Delete(&u, cf); |
---|
| 641 | |
---|
| 642 | rDelete(s); // kills 'cf' and 'r' as well |
---|
| 643 | } |
---|
| 644 | void test_Q_Ext_b() |
---|
| 645 | { |
---|
| 646 | clog << "Start by creating Q[b]..." << endl; |
---|
| 647 | |
---|
| 648 | char* n[] = {"b"}; |
---|
| 649 | ring r = rDefault( 0, 1, n); // Q[b] |
---|
| 650 | TS_ASSERT_DIFFERS( r, NULLp ); |
---|
| 651 | |
---|
| 652 | PrintRing(r); |
---|
| 653 | |
---|
| 654 | TS_ASSERT( rField_is_Domain(r) ); |
---|
| 655 | TS_ASSERT( rField_is_Q(r) ); |
---|
| 656 | |
---|
| 657 | TS_ASSERT( !rField_is_Zp(r) ); |
---|
| 658 | TS_ASSERT( !rField_is_Zp(r, 11) ); |
---|
| 659 | |
---|
| 660 | TS_ASSERT_EQUALS( rVar(r), 1); |
---|
| 661 | |
---|
| 662 | poly minPoly = p_ISet(1, r); // minPoly = 1 |
---|
| 663 | p_SetExp(minPoly, 1, 7, r); p_Setm(minPoly, r); // minPoly = b^7 |
---|
| 664 | minPoly = p_Add_q(minPoly, p_ISet(17, r), r); // minPoly = b^7 + 17 |
---|
| 665 | ideal minIdeal = idInit(1); // minIdeal = < 0 > |
---|
| 666 | minIdeal->m[0] = minPoly; // minIdeal = < b^7 + 17 > |
---|
| 667 | |
---|
| 668 | n_coeffType type = nRegister(n_Ext, naInitChar); |
---|
| 669 | TS_ASSERT(type == n_Ext); |
---|
| 670 | |
---|
| 671 | ExtInfo extParam; |
---|
| 672 | extParam.r = r; |
---|
| 673 | extParam.i = minIdeal; |
---|
| 674 | |
---|
| 675 | clog << "Next create the extension field Q[b]/<b^7+17>..." << endl; |
---|
| 676 | |
---|
| 677 | const coeffs cf = nInitChar(type, &extParam); // Q[b]/<b^7+17> |
---|
| 678 | |
---|
| 679 | if( cf == NULL ) |
---|
| 680 | TS_FAIL("Could not get needed coeff. domain"); |
---|
| 681 | |
---|
| 682 | TS_ASSERT_DIFFERS( cf->cfCoeffWrite, NULLp ); |
---|
| 683 | |
---|
| 684 | if( cf->cfCoeffWrite != NULL ) |
---|
| 685 | { |
---|
| 686 | clog << "Coeff-domain: " << endl; |
---|
| 687 | n_CoeffWrite(cf); PrintLn(); |
---|
| 688 | } |
---|
| 689 | |
---|
| 690 | // some tests for the coefficient field represented by cf: |
---|
| 691 | TestArithCf(cf); |
---|
| 692 | TestSumCf(cf, 10); |
---|
| 693 | TestSumCf(cf, 100); |
---|
| 694 | TestSumCf(cf, 101); |
---|
| 695 | TestSumCf(cf, 1001); |
---|
| 696 | TestSumCf(cf, 9000); |
---|
| 697 | |
---|
| 698 | clog << "Finally create the polynomial ring (Q[b]/<b^7+17>)[u, v, w]..." |
---|
| 699 | << endl; |
---|
| 700 | |
---|
| 701 | char* m[] = {"u", "v", "w"}; |
---|
| 702 | ring s = rDefault(cf, 3, m); // (Q[b]/<b^7+17>)[u, v, w] |
---|
| 703 | TS_ASSERT_DIFFERS(s, NULLp); |
---|
| 704 | |
---|
| 705 | PrintRing(s); |
---|
| 706 | |
---|
| 707 | TS_ASSERT( rField_is_Domain(s) ); |
---|
| 708 | TS_ASSERT( !rField_is_Q(s) ); |
---|
| 709 | TS_ASSERT( !rField_is_Zp(s) ); |
---|
| 710 | TS_ASSERT( !rField_is_Zp(s, 11) ); |
---|
| 711 | TS_ASSERT( !rField_is_Zp(s, 13) ); |
---|
| 712 | TS_ASSERT( !rField_is_GF(s) ); |
---|
| 713 | TS_ASSERT( rField_is_Extension(s) ); |
---|
| 714 | TS_ASSERT( !rField_is_GF(s, 25) ); |
---|
| 715 | TS_ASSERT_EQUALS(rVar(s), 3); |
---|
| 716 | |
---|
| 717 | Test(s); |
---|
| 718 | |
---|
| 719 | clog << endl |
---|
| 720 | << "Now let's compute some inverses in Q[b]/<b^7+17>..." |
---|
[4a2260e] | 721 | << endl; |
---|
| 722 | |
---|
[cfb500] | 723 | number u; |
---|
| 724 | u = NULL; plusTerm(u, 1, 2, cf); plusTerm(u, 33, 0, cf); // b^2 + 33 |
---|
| 725 | checkInverse(u, cf); n_Delete(&u, cf); |
---|
| 726 | u = NULL; plusTerm(u, 1, 5, cf); plusTerm(u, -137, 0, cf); // b^5 - 137 |
---|
| 727 | checkInverse(u, cf); n_Delete(&u, cf); |
---|
| 728 | |
---|
| 729 | clog << endl |
---|
| 730 | << "Now let's check a gcd computation in Q[b]..." |
---|
| 731 | << endl; |
---|
| 732 | |
---|
| 733 | number v; |
---|
| 734 | v = NULL; plusTerm(v, 1, 2, cf); plusTerm(v, 7, 1, cf); |
---|
| 735 | plusTerm(v, 1, 0, cf); // b^2 + 7b + 1 |
---|
| 736 | number w = n_Mult(v, v, cf); // (b^2 + 7b + 1)^2 |
---|
| 737 | number y = n_Mult(v, w, cf); // (b^2 + 7b + 1)^3 |
---|
| 738 | n_Delete(&v, cf); |
---|
| 739 | v = NULL; plusTerm(v, 2, 2, cf); plusTerm(v, -61, 1, cf); // 2b^2 - 61b |
---|
| 740 | number z = n_Mult(w, v, cf); // (b^2 + 7b + 1)^2 * (2b^2 - 61b) |
---|
| 741 | n_Delete(&v, cf); |
---|
[4a2260e] | 742 | |
---|
[cfb500] | 743 | clog << "z = "; n_Write(z, cf); |
---|
| 744 | clog << "y = "; n_Write(y, cf); |
---|
| 745 | number theGcd = n_Gcd(z, y, cf); // should yield w = (b^2 + 7b + 1)^2 |
---|
| 746 | clog << "gcd(z, y) = "; n_Write(theGcd, cf); |
---|
| 747 | |
---|
| 748 | v = n_Sub(theGcd, w, cf); |
---|
| 749 | TS_ASSERT( v == NULL ); |
---|
| 750 | n_Delete(&v, cf); |
---|
| 751 | |
---|
| 752 | clog << endl |
---|
| 753 | << "Now let's check an ext_gcd computation in Q[b]..." |
---|
| 754 | << endl; |
---|
| 755 | |
---|
| 756 | poly zFactor; poly yFactor; |
---|
| 757 | poly ppp = p_ExtGcd((poly)z, zFactor, (poly)y, yFactor, cf->algring); |
---|
| 758 | v = n_Sub(theGcd, (number)ppp, cf); |
---|
| 759 | TS_ASSERT( v == NULL ); |
---|
| 760 | clog << "z = "; n_Write(z, cf); |
---|
| 761 | clog << "zFactor = "; p_Write(zFactor, cf->algring); |
---|
| 762 | clog << "y = "; n_Write(y, cf); |
---|
| 763 | clog << "yFactor = "; p_Write(yFactor, cf->algring); |
---|
| 764 | number v1 = n_Mult(z, (number)zFactor, cf); |
---|
| 765 | number v2 = n_Mult(y, (number)yFactor, cf); |
---|
| 766 | number v3 = n_Add(v1, v2, cf); |
---|
| 767 | clog << "z * zFactor + y * yFactor = "; n_Write(v3, cf); |
---|
| 768 | clog << "gcd(z, y) = "; p_Write(ppp, cf->algring); |
---|
| 769 | number v4 = n_Sub(v3, w, cf); |
---|
| 770 | TS_ASSERT( v4 == NULL ); |
---|
[4a2260e] | 771 | |
---|
[cfb500] | 772 | p_Delete(&ppp, cf->algring); p_Delete(&zFactor, cf->algring); |
---|
| 773 | p_Delete(&yFactor, cf->algring); |
---|
| 774 | n_Delete(&z, cf); n_Delete(&y, cf); n_Delete(&w, cf); |
---|
| 775 | n_Delete(&theGcd, cf); n_Delete(&v, cf); n_Delete(&v1, cf); |
---|
| 776 | n_Delete(&v2, cf); n_Delete(&v3, cf); n_Delete(&v4, cf); |
---|
[fba6f18] | 777 | |
---|
| 778 | rDelete(s); // kills 'cf' and 'r' as well |
---|
| 779 | } |
---|
[4f684a] | 780 | }; |
---|
| 781 | |
---|