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