| 1 | /***************************************** |
|---|
| 2 | * Computer Algebra System SINGULAR * |
|---|
| 3 | *****************************************/ |
|---|
| 4 | /* $Id: numbers.cc,v 1.17 1999-07-01 16:13:40 Singular Exp $ */ |
|---|
| 5 | |
|---|
| 6 | /* |
|---|
| 7 | * ABSTRACT: interface to coefficient aritmetics |
|---|
| 8 | */ |
|---|
| 9 | |
|---|
| 10 | #include <string.h> |
|---|
| 11 | #include <stdlib.h> |
|---|
| 12 | #include "mod2.h" |
|---|
| 13 | #include "tok.h" |
|---|
| 14 | #include "febase.h" |
|---|
| 15 | #include "kstd1.h" |
|---|
| 16 | #include "numbers.h" |
|---|
| 17 | #include "longrat.h" |
|---|
| 18 | #include "longalg.h" |
|---|
| 19 | #include "modulop.h" |
|---|
| 20 | #include "gnumpfl.h" |
|---|
| 21 | #include "gnumpc.h" |
|---|
| 22 | #include "ring.h" |
|---|
| 23 | #ifndef FAST_AND_DIRTY |
|---|
| 24 | #undef npMultM |
|---|
| 25 | #undef npSubM |
|---|
| 26 | #undef npNegM |
|---|
| 27 | #undef npEqualM |
|---|
| 28 | #endif |
|---|
| 29 | #include "ffields.h" |
|---|
| 30 | #include "shortfl.h" |
|---|
| 31 | |
|---|
| 32 | //static int characteristic = 0; |
|---|
| 33 | extern int IsPrime(int p); |
|---|
| 34 | |
|---|
| 35 | void (*nNew)(number *a); |
|---|
| 36 | number (*nInit)(int i); |
|---|
| 37 | number (*nPar)(int i); |
|---|
| 38 | int (*nParDeg)(number n); |
|---|
| 39 | int (*nSize)(number n); |
|---|
| 40 | int (*nInt)(number &n); |
|---|
| 41 | numberfunc nMult, nSub, nAdd, nDiv, nIntDiv, nIntMod, nExactDiv; |
|---|
| 42 | number (*nNeg)(number a); |
|---|
| 43 | number (*nInvers)(number a); |
|---|
| 44 | void (*nNormalize)(number &a); |
|---|
| 45 | number (*nCopy)(number a); |
|---|
| 46 | BOOLEAN (*nGreater)(number a,number b); |
|---|
| 47 | BOOLEAN (*nEqual)(number a,number b); |
|---|
| 48 | BOOLEAN (*nIsZero)(number a); |
|---|
| 49 | BOOLEAN (*nIsOne)(number a); |
|---|
| 50 | BOOLEAN (*nIsMOne)(number a); |
|---|
| 51 | BOOLEAN (*nGreaterZero)(number a); |
|---|
| 52 | void (*nWrite)(number &a); |
|---|
| 53 | char * (*nRead)(char *s,number *a); |
|---|
| 54 | void (*nPower)(number a, int i, number * result); |
|---|
| 55 | number (*nGetDenom)(number &n); |
|---|
| 56 | numberfunc nGcd,nLcm; |
|---|
| 57 | BOOLEAN (*nSetMap)(int c,char **par, int nop, number minpol); |
|---|
| 58 | number (*nMap)(number from); |
|---|
| 59 | char * (*nName)(number n); |
|---|
| 60 | #ifdef LDEBUG |
|---|
| 61 | BOOLEAN (*nDBTest)(number a, char *f, int l); |
|---|
| 62 | void (*nDBDelete)(number *a, char *f, int l); |
|---|
| 63 | #else |
|---|
| 64 | void (*nDelete)(number *a); |
|---|
| 65 | #endif |
|---|
| 66 | |
|---|
| 67 | /*0 implementation*/ |
|---|
| 68 | number nNULL; /* the 0 as constant */ |
|---|
| 69 | int nChar; |
|---|
| 70 | |
|---|
| 71 | void nDummy1(number* d) { *d=NULL; } |
|---|
| 72 | |
|---|
| 73 | #ifdef LDEBUG |
|---|
| 74 | void nDBDummy1(number* d,char *f, int l) { *d=NULL; } |
|---|
| 75 | #endif |
|---|
| 76 | |
|---|
| 77 | void nDummy2(number& d) { } |
|---|
| 78 | |
|---|
| 79 | char * ndName(number n) { return NULL; } |
|---|
| 80 | |
|---|
| 81 | number ndPar(int i) { return nInit(0); } |
|---|
| 82 | |
|---|
| 83 | int ndParDeg(number n) { return 0; } |
|---|
| 84 | |
|---|
| 85 | number ndGcd(number a, number b) { return nInit(1); } |
|---|
| 86 | |
|---|
| 87 | number ndIntMod(number a, number b) { return nInit(0); } |
|---|
| 88 | |
|---|
| 89 | number ndGetDenom(number &n) { return nInit(1); } |
|---|
| 90 | |
|---|
| 91 | int nGetChar() { return nChar; } |
|---|
| 92 | |
|---|
| 93 | int ndSize(number a) {return (int)nIsZero(a)==FALSE; } |
|---|
| 94 | |
|---|
| 95 | /*2 |
|---|
| 96 | * init operations for characteristic c (complete==TRUE) |
|---|
| 97 | * init nDelete for characteristic c (complete==FALSE) |
|---|
| 98 | */ |
|---|
| 99 | void nSetChar(ring r, BOOLEAN complete) |
|---|
| 100 | { |
|---|
| 101 | int c=rInternalChar(r); |
|---|
| 102 | |
|---|
| 103 | if (nNULL!=NULL) |
|---|
| 104 | { |
|---|
| 105 | nDelete(&nNULL);nNULL=NULL; |
|---|
| 106 | } |
|---|
| 107 | if (complete) |
|---|
| 108 | { |
|---|
| 109 | nChar=c; |
|---|
| 110 | nPar = ndPar; |
|---|
| 111 | nParDeg= ndParDeg; |
|---|
| 112 | nSize = ndSize; |
|---|
| 113 | nGetDenom = ndGetDenom; |
|---|
| 114 | nName = ndName; |
|---|
| 115 | } |
|---|
| 116 | //Print("n:c=%d compl=%d param=%d\n",c,complete,r->parameter); |
|---|
| 117 | //if ((c == 1) || (c< (-1))) |
|---|
| 118 | if (rField_is_Extension(r)) |
|---|
| 119 | { |
|---|
| 120 | naSetChar(c,complete,r->parameter,rPar(r)); |
|---|
| 121 | #ifdef LDEBUG |
|---|
| 122 | nDBDelete= naDBDelete; |
|---|
| 123 | #else |
|---|
| 124 | nDelete= naDelete; |
|---|
| 125 | #endif |
|---|
| 126 | if (complete) |
|---|
| 127 | { |
|---|
| 128 | test |= Sy_bit(OPT_INTSTRATEGY); /*intStrategy*/ |
|---|
| 129 | test &= ~Sy_bit(OPT_REDTAIL); /*noredTail*/ |
|---|
| 130 | nNew = naNew; |
|---|
| 131 | nNormalize=naNormalize; |
|---|
| 132 | nInit = naInit; |
|---|
| 133 | nPar = naPar; |
|---|
| 134 | nParDeg= naParDeg; |
|---|
| 135 | nInt = naInt; |
|---|
| 136 | nAdd = naAdd; |
|---|
| 137 | nSub = naSub; |
|---|
| 138 | nMult = naMult; |
|---|
| 139 | nDiv = naDiv; |
|---|
| 140 | nExactDiv= naDiv; |
|---|
| 141 | nIntDiv= naIntDiv; |
|---|
| 142 | nIntMod= ndIntMod; /* dummy !! */ |
|---|
| 143 | nNeg = naNeg; |
|---|
| 144 | nInvers= naInvers; |
|---|
| 145 | nCopy = naCopy; |
|---|
| 146 | nGreater = naGreater; |
|---|
| 147 | nEqual = naEqual; |
|---|
| 148 | nIsZero = naIsZero; |
|---|
| 149 | nIsOne = naIsOne; |
|---|
| 150 | nIsMOne = naIsMOne; |
|---|
| 151 | nGreaterZero = naGreaterZero; |
|---|
| 152 | nWrite = naWrite; |
|---|
| 153 | nRead = naRead; |
|---|
| 154 | nPower = naPower; |
|---|
| 155 | nGcd = naGcd; |
|---|
| 156 | nLcm = naLcm; |
|---|
| 157 | nSetMap = naSetMap; |
|---|
| 158 | nName= naName; |
|---|
| 159 | nSize = naSize; |
|---|
| 160 | nGetDenom = naGetDenom; |
|---|
| 161 | #ifdef LDEBUG |
|---|
| 162 | nDBTest=naDBTest; |
|---|
| 163 | #endif |
|---|
| 164 | } |
|---|
| 165 | } |
|---|
| 166 | else if (rField_is_Q(r)) |
|---|
| 167 | { |
|---|
| 168 | #ifdef LDEBUG |
|---|
| 169 | nDBDelete= nlDBDelete; |
|---|
| 170 | #else |
|---|
| 171 | nDelete= nlDelete; |
|---|
| 172 | #endif |
|---|
| 173 | if (complete) |
|---|
| 174 | { |
|---|
| 175 | test |= Sy_bit(OPT_INTSTRATEGY); /*26*/ |
|---|
| 176 | nNew = nlNew; |
|---|
| 177 | nNormalize=nlNormalize; |
|---|
| 178 | nInit = nlInit; |
|---|
| 179 | nInt = nlInt; |
|---|
| 180 | nAdd = nlAdd; |
|---|
| 181 | nSub = nlSub; |
|---|
| 182 | nMult = nlMult; |
|---|
| 183 | nDiv = nlDiv; |
|---|
| 184 | nExactDiv= nlExactDiv; |
|---|
| 185 | nIntDiv= nlIntDiv; |
|---|
| 186 | nIntMod= nlIntMod; |
|---|
| 187 | nNeg = nlNeg; |
|---|
| 188 | nInvers= nlInvers; |
|---|
| 189 | nCopy = nlCopy; |
|---|
| 190 | nGreater = nlGreater; |
|---|
| 191 | nEqual = nlEqual; |
|---|
| 192 | nIsZero = nlIsZero; |
|---|
| 193 | nIsOne = nlIsOne; |
|---|
| 194 | nIsMOne = nlIsMOne; |
|---|
| 195 | nGreaterZero = nlGreaterZero; |
|---|
| 196 | nWrite = nlWrite; |
|---|
| 197 | nRead = nlRead; |
|---|
| 198 | nPower = nlPower; |
|---|
| 199 | nGcd = nlGcd; |
|---|
| 200 | nLcm = nlLcm; |
|---|
| 201 | nSetMap = nlSetMap; |
|---|
| 202 | nSize = nlSize; |
|---|
| 203 | nGetDenom = nlGetDenom; |
|---|
| 204 | #ifdef LDEBUG |
|---|
| 205 | nDBTest=nlDBTest; |
|---|
| 206 | #endif |
|---|
| 207 | } |
|---|
| 208 | } |
|---|
| 209 | else if (rField_is_Zp(r)) |
|---|
| 210 | /*----------------------char. p----------------*/ |
|---|
| 211 | { |
|---|
| 212 | #ifdef LDEBUG |
|---|
| 213 | nDBDelete= nDBDummy1; |
|---|
| 214 | #else |
|---|
| 215 | nDelete= nDummy1; |
|---|
| 216 | #endif |
|---|
| 217 | if (complete) |
|---|
| 218 | { |
|---|
| 219 | npSetChar(c); |
|---|
| 220 | test &= ~Sy_bit(OPT_INTSTRATEGY); /*26*/ |
|---|
| 221 | nNew = nDummy1; |
|---|
| 222 | nNormalize=nDummy2; |
|---|
| 223 | nInit = npInit; |
|---|
| 224 | nInt = npInt; |
|---|
| 225 | nAdd = npAdd; |
|---|
| 226 | nSub = npSub; |
|---|
| 227 | nMult = npMult; |
|---|
| 228 | nDiv = npDiv; |
|---|
| 229 | nExactDiv= npDiv; |
|---|
| 230 | nIntDiv= npDiv; |
|---|
| 231 | nIntMod= ndIntMod; /* dummy !! */ |
|---|
| 232 | nNeg = npNeg; |
|---|
| 233 | nInvers= npInvers; |
|---|
| 234 | nCopy = npCopy; |
|---|
| 235 | nGreater = npGreater; |
|---|
| 236 | nEqual = npEqual; |
|---|
| 237 | nIsZero = npIsZero; |
|---|
| 238 | nIsOne = npIsOne; |
|---|
| 239 | nIsMOne = npIsMOne; |
|---|
| 240 | nGreaterZero = npGreaterZero; |
|---|
| 241 | nWrite = npWrite; |
|---|
| 242 | nRead = npRead; |
|---|
| 243 | nPower = npPower; |
|---|
| 244 | nGcd = ndGcd; |
|---|
| 245 | nLcm = ndGcd; /* tricky, isn't it ?*/ |
|---|
| 246 | nSetMap = npSetMap; |
|---|
| 247 | /* nName= ndName; */ |
|---|
| 248 | /*nSize = ndSize;*/ |
|---|
| 249 | #ifdef LDEBUG |
|---|
| 250 | nDBTest=npDBTest; |
|---|
| 251 | #endif |
|---|
| 252 | } |
|---|
| 253 | } |
|---|
| 254 | /* -------------- GF(p^m) -----------------------*/ |
|---|
| 255 | else if (rField_is_GF(r)) |
|---|
| 256 | { |
|---|
| 257 | #ifdef LDEBUG |
|---|
| 258 | nDBDelete= nDBDummy1; |
|---|
| 259 | #else |
|---|
| 260 | nDelete= nDummy1; |
|---|
| 261 | #endif |
|---|
| 262 | if (complete) |
|---|
| 263 | { |
|---|
| 264 | test &= ~Sy_bit(OPT_INTSTRATEGY); /*26*/ |
|---|
| 265 | nfSetChar(c,r->parameter); |
|---|
| 266 | nNew = nDummy1; |
|---|
| 267 | nNormalize=nDummy2; |
|---|
| 268 | nInit = nfInit; |
|---|
| 269 | nPar = nfPar; |
|---|
| 270 | nParDeg= nfParDeg; |
|---|
| 271 | nInt = nfInt; |
|---|
| 272 | nAdd = nfAdd; |
|---|
| 273 | nSub = nfSub; |
|---|
| 274 | nMult = nfMult; |
|---|
| 275 | nDiv = nfDiv; |
|---|
| 276 | nExactDiv= nfDiv; |
|---|
| 277 | nIntDiv= nfDiv; |
|---|
| 278 | nIntMod= ndIntMod; /* dummy !! */ |
|---|
| 279 | nNeg = nfNeg; |
|---|
| 280 | nInvers= nfInvers; |
|---|
| 281 | nCopy = nfCopy; |
|---|
| 282 | nGreater = nfGreater; |
|---|
| 283 | nEqual = nfEqual; |
|---|
| 284 | nIsZero = nfIsZero; |
|---|
| 285 | nIsOne = nfIsOne; |
|---|
| 286 | nIsMOne = nfIsMOne; |
|---|
| 287 | nGreaterZero = nfGreaterZero; |
|---|
| 288 | nWrite = nfWrite; |
|---|
| 289 | nRead = nfRead; |
|---|
| 290 | nPower = nfPower; |
|---|
| 291 | nGcd = ndGcd; |
|---|
| 292 | nLcm = ndGcd; /* tricky, isn't it ?*/ |
|---|
| 293 | nSetMap = nfSetMap; |
|---|
| 294 | nName= nfName; |
|---|
| 295 | /*nSize = ndSize;*/ |
|---|
| 296 | #ifdef LDEBUG |
|---|
| 297 | nDBTest=nfDBTest; |
|---|
| 298 | #endif |
|---|
| 299 | } |
|---|
| 300 | } |
|---|
| 301 | /* -------------- R -----------------------*/ |
|---|
| 302 | //if (c==(-1)) |
|---|
| 303 | else if (rField_is_R(r)) |
|---|
| 304 | { |
|---|
| 305 | #ifdef LDEBUG |
|---|
| 306 | nDBDelete= nDBDummy1; |
|---|
| 307 | #else |
|---|
| 308 | nDelete= nDummy1; |
|---|
| 309 | #endif |
|---|
| 310 | if (complete) |
|---|
| 311 | { |
|---|
| 312 | nNew=nDummy1; |
|---|
| 313 | nNormalize=nDummy2; |
|---|
| 314 | nInit = nrInit; |
|---|
| 315 | nInt = nrInt; |
|---|
| 316 | nAdd = nrAdd; |
|---|
| 317 | nSub = nrSub; |
|---|
| 318 | nMult = nrMult; |
|---|
| 319 | nDiv = nrDiv; |
|---|
| 320 | nExactDiv= nrDiv; |
|---|
| 321 | nIntDiv= nrDiv; |
|---|
| 322 | nIntMod= ndIntMod; /* dummy !! */ |
|---|
| 323 | nNeg = nrNeg; |
|---|
| 324 | nInvers= nrInvers; |
|---|
| 325 | nCopy = nrCopy; |
|---|
| 326 | nGreater = nrGreater; |
|---|
| 327 | nEqual = nrEqual; |
|---|
| 328 | nIsZero = nrIsZero; |
|---|
| 329 | nIsOne = nrIsOne; |
|---|
| 330 | nIsMOne = nrIsMOne; |
|---|
| 331 | nGreaterZero = nrGreaterZero; |
|---|
| 332 | nWrite = nrWrite; |
|---|
| 333 | nRead = nrRead; |
|---|
| 334 | nPower = nrPower; |
|---|
| 335 | nGcd = ndGcd; |
|---|
| 336 | nLcm = ndGcd; /* tricky, isn't it ?*/ |
|---|
| 337 | nSetMap=nrSetMap; |
|---|
| 338 | /* nName= ndName; */ |
|---|
| 339 | /*nSize = ndSize;*/ |
|---|
| 340 | #ifdef LDEBUG |
|---|
| 341 | nDBTest=nrDBTest; |
|---|
| 342 | #endif |
|---|
| 343 | } |
|---|
| 344 | } |
|---|
| 345 | /* -------------- long R -----------------------*/ |
|---|
| 346 | else if (rField_is_long_R(r)) |
|---|
| 347 | { |
|---|
| 348 | setGMPFloatDigits(r->ch_flags); |
|---|
| 349 | #ifdef LDEBUG |
|---|
| 350 | nDBDelete= ngfDBDelete; |
|---|
| 351 | #else |
|---|
| 352 | nDelete= ngfDelete; |
|---|
| 353 | #endif |
|---|
| 354 | if (complete) |
|---|
| 355 | { |
|---|
| 356 | nNew=ngfNew; |
|---|
| 357 | nNormalize=nDummy2; |
|---|
| 358 | nInit = ngfInit; |
|---|
| 359 | nInt = ngfInt; |
|---|
| 360 | nAdd = ngfAdd; |
|---|
| 361 | nSub = ngfSub; |
|---|
| 362 | nMult = ngfMult; |
|---|
| 363 | nDiv = ngfDiv; |
|---|
| 364 | nExactDiv= ngfDiv; |
|---|
| 365 | nIntDiv= ngfDiv; |
|---|
| 366 | nIntMod= ndIntMod; /* dummy !! */ |
|---|
| 367 | nNeg = ngfNeg; |
|---|
| 368 | nInvers= ngfInvers; |
|---|
| 369 | nCopy = ngfCopy; |
|---|
| 370 | nGreater = ngfGreater; |
|---|
| 371 | nEqual = ngfEqual; |
|---|
| 372 | nIsZero = ngfIsZero; |
|---|
| 373 | nIsOne = ngfIsOne; |
|---|
| 374 | nIsMOne = ngfIsMOne; |
|---|
| 375 | nGreaterZero = ngfGreaterZero; |
|---|
| 376 | nWrite = ngfWrite; |
|---|
| 377 | nRead = ngfRead; |
|---|
| 378 | nPower = ngfPower; |
|---|
| 379 | nGcd = ndGcd; |
|---|
| 380 | nLcm = ndGcd; /* tricky, isn't it ?*/ |
|---|
| 381 | nSetMap=ngfSetMap; |
|---|
| 382 | /* nName= ndName; */ |
|---|
| 383 | /*nSize = ndSize;*/ |
|---|
| 384 | #ifdef LDEBUG |
|---|
| 385 | nDBTest=ngfDBTest; |
|---|
| 386 | #endif |
|---|
| 387 | } |
|---|
| 388 | } |
|---|
| 389 | /* -------------- long C -----------------------*/ |
|---|
| 390 | else if (rField_is_long_C(r)) |
|---|
| 391 | { |
|---|
| 392 | setGMPFloatDigits(r->ch_flags); |
|---|
| 393 | #ifdef LDEBUG |
|---|
| 394 | nDBDelete= ngcDBDelete; |
|---|
| 395 | #else |
|---|
| 396 | nDelete= ngcDelete; |
|---|
| 397 | #endif |
|---|
| 398 | if (complete) |
|---|
| 399 | { |
|---|
| 400 | nNew=ngcNew; |
|---|
| 401 | nNormalize=nDummy2; |
|---|
| 402 | nInit = ngcInit; |
|---|
| 403 | nInt = ngcInt; |
|---|
| 404 | nAdd = ngcAdd; |
|---|
| 405 | nSub = ngcSub; |
|---|
| 406 | nMult = ngcMult; |
|---|
| 407 | nDiv = ngcDiv; |
|---|
| 408 | nExactDiv= ngcDiv; |
|---|
| 409 | nIntDiv= ngcDiv; |
|---|
| 410 | nIntMod= ndIntMod; /* dummy !! */ |
|---|
| 411 | nNeg = ngcNeg; |
|---|
| 412 | nInvers= ngcInvers; |
|---|
| 413 | nCopy = ngcCopy; |
|---|
| 414 | nGreater = ngcGreater; |
|---|
| 415 | nEqual = ngcEqual; |
|---|
| 416 | nIsZero = ngcIsZero; |
|---|
| 417 | nIsOne = ngcIsOne; |
|---|
| 418 | nIsMOne = ngcIsMOne; |
|---|
| 419 | nGreaterZero = ngcGreaterZero; |
|---|
| 420 | nWrite = ngcWrite; |
|---|
| 421 | nRead = ngcRead; |
|---|
| 422 | nPower = ngcPower; |
|---|
| 423 | nGcd = ndGcd; |
|---|
| 424 | nLcm = ndGcd; /* tricky, isn't it ?*/ |
|---|
| 425 | nSetMap=ngcSetMap; |
|---|
| 426 | nPar=ngcPar; |
|---|
| 427 | /*nSize = ndSize;*/ |
|---|
| 428 | #ifdef LDEBUG |
|---|
| 429 | nDBTest=ngcDBTest; |
|---|
| 430 | #endif |
|---|
| 431 | } |
|---|
| 432 | } |
|---|
| 433 | #ifdef TEST |
|---|
| 434 | else |
|---|
| 435 | { |
|---|
| 436 | WerrorS("unknown field"); |
|---|
| 437 | } |
|---|
| 438 | #endif |
|---|
| 439 | if (complete&&(!errorreported)) nNULL=nInit(0); |
|---|
| 440 | } |
|---|
| 441 | |
|---|
