[0e1846] | 1 | /***************************************** |
---|
| 2 | * Computer Algebra System SINGULAR * |
---|
| 3 | *****************************************/ |
---|
[0f0974] | 4 | /* $Id: numbers.cc,v 1.14 1999-06-21 16:46:39 Singular Exp $ */ |
---|
[32df82] | 5 | |
---|
[0e1846] | 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" |
---|
[8a150b] | 20 | #include "gnumpfl.h" |
---|
[0ae5116] | 21 | #include "gnumpc.h" |
---|
[8a150b] | 22 | #include "ring.h" |
---|
[0e1846] | 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); |
---|
[1fc83c0] | 41 | numberfunc nMult, nSub, nAdd, nDiv, nIntDiv, nIntMod, nExactDiv; |
---|
[0e1846] | 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); |
---|
[0f0974] | 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); |
---|
[0e1846] | 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 | |
---|
[0ae5116] | 87 | number ndIntMod(number a, number b) { return nInit(0); } |
---|
| 88 | |
---|
[0f0974] | 89 | number ndGetDenom(number n) { return nInit(1); } |
---|
| 90 | |
---|
[0e1846] | 91 | int nGetChar() { return nChar; } |
---|
| 92 | |
---|
[fb8518f] | 93 | int ndSize(number a) {return (int)nIsZero(a)==FALSE; } |
---|
[0e1846] | 94 | |
---|
| 95 | /*2 |
---|
| 96 | * init operations for characteristic c (complete==TRUE) |
---|
| 97 | * init nDelete for characteristic c (complete==FALSE) |
---|
| 98 | */ |
---|
[8a150b] | 99 | void nSetChar(ring r, BOOLEAN complete) |
---|
[0e1846] | 100 | { |
---|
[8a150b] | 101 | int c=rInternalChar(r); |
---|
| 102 | |
---|
[0e1846] | 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; |
---|
[0f0974] | 113 | nGetDenom = ndGetDenom; |
---|
| 114 | nName = ndName; |
---|
[0e1846] | 115 | } |
---|
[8a150b] | 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)) |
---|
[0e1846] | 119 | { |
---|
[8a150b] | 120 | naSetChar(c,complete,r->parameter,rPar(r)); |
---|
[0e1846] | 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; |
---|
[1fc83c0] | 140 | nExactDiv= naDiv; |
---|
[0e1846] | 141 | nIntDiv= naIntDiv; |
---|
[0ae5116] | 142 | nIntMod= ndIntMod; /* dummy !! */ |
---|
[0e1846] | 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; |
---|
[f64447] | 159 | nSize = naSize; |
---|
[0f0974] | 160 | nGetDenom = naGetDenom; |
---|
[0e1846] | 161 | #ifdef LDEBUG |
---|
| 162 | nDBTest=naDBTest; |
---|
| 163 | #endif |
---|
| 164 | } |
---|
| 165 | } |
---|
| 166 | else |
---|
[8a150b] | 167 | if (rField_is_Q(r)) |
---|
[0e1846] | 168 | { |
---|
| 169 | #ifdef LDEBUG |
---|
| 170 | nDBDelete= nlDBDelete; |
---|
| 171 | #else |
---|
| 172 | nDelete= nlDelete; |
---|
| 173 | #endif |
---|
| 174 | if (complete) |
---|
| 175 | { |
---|
| 176 | test |= Sy_bit(OPT_INTSTRATEGY); /*26*/ |
---|
| 177 | nNew = nlNew; |
---|
| 178 | nNormalize=nlNormalize; |
---|
| 179 | nInit = nlInit; |
---|
| 180 | nInt = nlInt; |
---|
| 181 | nAdd = nlAdd; |
---|
| 182 | nSub = nlSub; |
---|
| 183 | nMult = nlMult; |
---|
| 184 | nDiv = nlDiv; |
---|
[1fc83c0] | 185 | nExactDiv= nlExactDiv; |
---|
[0e1846] | 186 | nIntDiv= nlIntDiv; |
---|
| 187 | nIntMod= nlIntMod; |
---|
| 188 | nNeg = nlNeg; |
---|
| 189 | nInvers= nlInvers; |
---|
| 190 | nCopy = nlCopy; |
---|
| 191 | nGreater = nlGreater; |
---|
| 192 | nEqual = nlEqual; |
---|
| 193 | nIsZero = nlIsZero; |
---|
| 194 | nIsOne = nlIsOne; |
---|
| 195 | nIsMOne = nlIsMOne; |
---|
| 196 | nGreaterZero = nlGreaterZero; |
---|
| 197 | nWrite = nlWrite; |
---|
| 198 | nRead = nlRead; |
---|
| 199 | nPower = nlPower; |
---|
| 200 | nGcd = nlGcd; |
---|
| 201 | nLcm = nlLcm; |
---|
| 202 | nSetMap = nlSetMap; |
---|
| 203 | nSize = nlSize; |
---|
[0f0974] | 204 | nGetDenom = nlGetDenom; |
---|
[0e1846] | 205 | #ifdef LDEBUG |
---|
| 206 | nDBTest=nlDBTest; |
---|
| 207 | #endif |
---|
| 208 | } |
---|
| 209 | } |
---|
[8a150b] | 210 | else if (rField_is_Zp(r)) |
---|
[0e1846] | 211 | /*----------------------char. p----------------*/ |
---|
| 212 | { |
---|
| 213 | #ifdef LDEBUG |
---|
| 214 | nDBDelete= nDBDummy1; |
---|
| 215 | #else |
---|
| 216 | nDelete= nDummy1; |
---|
| 217 | #endif |
---|
| 218 | if (complete) |
---|
| 219 | { |
---|
| 220 | npSetChar(c); |
---|
| 221 | test &= ~Sy_bit(OPT_INTSTRATEGY); /*26*/ |
---|
| 222 | nNew = nDummy1; |
---|
| 223 | nNormalize=nDummy2; |
---|
| 224 | nInit = npInit; |
---|
| 225 | nInt = npInt; |
---|
| 226 | nAdd = npAdd; |
---|
| 227 | nSub = npSub; |
---|
| 228 | nMult = npMult; |
---|
| 229 | nDiv = npDiv; |
---|
[1fc83c0] | 230 | nExactDiv= npDiv; |
---|
[0e1846] | 231 | nIntDiv= npDiv; |
---|
[0ae5116] | 232 | nIntMod= ndIntMod; /* dummy !! */ |
---|
[0e1846] | 233 | nNeg = npNeg; |
---|
| 234 | nInvers= npInvers; |
---|
| 235 | nCopy = npCopy; |
---|
| 236 | nGreater = npGreater; |
---|
| 237 | nEqual = npEqual; |
---|
| 238 | nIsZero = npIsZero; |
---|
| 239 | nIsOne = npIsOne; |
---|
| 240 | nIsMOne = npIsMOne; |
---|
| 241 | nGreaterZero = npGreaterZero; |
---|
| 242 | nWrite = npWrite; |
---|
| 243 | nRead = npRead; |
---|
| 244 | nPower = npPower; |
---|
| 245 | nGcd = ndGcd; |
---|
| 246 | nLcm = ndGcd; /* tricky, isn't it ?*/ |
---|
| 247 | nSetMap = npSetMap; |
---|
[0f0974] | 248 | /* nName= ndName; */ |
---|
[0e1846] | 249 | /*nSize = ndSize;*/ |
---|
| 250 | #ifdef LDEBUG |
---|
| 251 | nDBTest=npDBTest; |
---|
| 252 | #endif |
---|
| 253 | } |
---|
| 254 | } |
---|
| 255 | else |
---|
[8a150b] | 256 | /* -------------- GF(p^m) -----------------------*/ |
---|
| 257 | if (rField_is_GF(r)) |
---|
[0e1846] | 258 | { |
---|
| 259 | #ifdef LDEBUG |
---|
| 260 | nDBDelete= nDBDummy1; |
---|
| 261 | #else |
---|
| 262 | nDelete= nDummy1; |
---|
| 263 | #endif |
---|
| 264 | if (complete) |
---|
| 265 | { |
---|
| 266 | test &= ~Sy_bit(OPT_INTSTRATEGY); /*26*/ |
---|
[8a150b] | 267 | nfSetChar(c,r->parameter); |
---|
[0e1846] | 268 | nNew = nDummy1; |
---|
| 269 | nNormalize=nDummy2; |
---|
| 270 | nInit = nfInit; |
---|
| 271 | nPar = nfPar; |
---|
| 272 | nParDeg= nfParDeg; |
---|
| 273 | nInt = nfInt; |
---|
| 274 | nAdd = nfAdd; |
---|
| 275 | nSub = nfSub; |
---|
| 276 | nMult = nfMult; |
---|
| 277 | nDiv = nfDiv; |
---|
[1fc83c0] | 278 | nExactDiv= nfDiv; |
---|
[0e1846] | 279 | nIntDiv= nfDiv; |
---|
[0ae5116] | 280 | nIntMod= ndIntMod; /* dummy !! */ |
---|
[0e1846] | 281 | nNeg = nfNeg; |
---|
| 282 | nInvers= nfInvers; |
---|
| 283 | nCopy = nfCopy; |
---|
| 284 | nGreater = nfGreater; |
---|
| 285 | nEqual = nfEqual; |
---|
| 286 | nIsZero = nfIsZero; |
---|
| 287 | nIsOne = nfIsOne; |
---|
| 288 | nIsMOne = nfIsMOne; |
---|
| 289 | nGreaterZero = nfGreaterZero; |
---|
| 290 | nWrite = nfWrite; |
---|
| 291 | nRead = nfRead; |
---|
| 292 | nPower = nfPower; |
---|
| 293 | nGcd = ndGcd; |
---|
| 294 | nLcm = ndGcd; /* tricky, isn't it ?*/ |
---|
| 295 | nSetMap = nfSetMap; |
---|
| 296 | nName= nfName; |
---|
| 297 | /*nSize = ndSize;*/ |
---|
| 298 | #ifdef LDEBUG |
---|
| 299 | nDBTest=nfDBTest; |
---|
| 300 | #endif |
---|
| 301 | } |
---|
| 302 | } |
---|
| 303 | else |
---|
[8a150b] | 304 | /* -------------- R -----------------------*/ |
---|
| 305 | //if (c==(-1)) |
---|
| 306 | if (rField_is_R(r)) |
---|
[0e1846] | 307 | { |
---|
| 308 | #ifdef LDEBUG |
---|
| 309 | nDBDelete= nDBDummy1; |
---|
| 310 | #else |
---|
| 311 | nDelete= nDummy1; |
---|
| 312 | #endif |
---|
| 313 | if (complete) |
---|
| 314 | { |
---|
| 315 | nNew=nDummy1; |
---|
| 316 | nNormalize=nDummy2; |
---|
| 317 | nInit = nrInit; |
---|
| 318 | nInt = nrInt; |
---|
| 319 | nAdd = nrAdd; |
---|
| 320 | nSub = nrSub; |
---|
| 321 | nMult = nrMult; |
---|
| 322 | nDiv = nrDiv; |
---|
[1fc83c0] | 323 | nExactDiv= nrDiv; |
---|
[0e1846] | 324 | nIntDiv= nrDiv; |
---|
[0ae5116] | 325 | nIntMod= ndIntMod; /* dummy !! */ |
---|
[0e1846] | 326 | nNeg = nrNeg; |
---|
| 327 | nInvers= nrInvers; |
---|
| 328 | nCopy = nrCopy; |
---|
| 329 | nGreater = nrGreater; |
---|
| 330 | nEqual = nrEqual; |
---|
| 331 | nIsZero = nrIsZero; |
---|
| 332 | nIsOne = nrIsOne; |
---|
| 333 | nIsMOne = nrIsMOne; |
---|
| 334 | nGreaterZero = nrGreaterZero; |
---|
| 335 | nWrite = nrWrite; |
---|
| 336 | nRead = nrRead; |
---|
| 337 | nPower = nrPower; |
---|
| 338 | nGcd = ndGcd; |
---|
| 339 | nLcm = ndGcd; /* tricky, isn't it ?*/ |
---|
| 340 | nSetMap=nrSetMap; |
---|
[0f0974] | 341 | /* nName= ndName; */ |
---|
[0e1846] | 342 | /*nSize = ndSize;*/ |
---|
| 343 | #ifdef LDEBUG |
---|
| 344 | nDBTest=nrDBTest; |
---|
| 345 | #endif |
---|
| 346 | } |
---|
| 347 | } |
---|
[8a150b] | 348 | else |
---|
| 349 | /* -------------- long R -----------------------*/ |
---|
| 350 | if (rField_is_long_R(r)) |
---|
| 351 | { |
---|
| 352 | setGMPFloatPrecBytes(r->ch_flags); |
---|
| 353 | #ifdef LDEBUG |
---|
| 354 | nDBDelete= ngfDBDelete; |
---|
| 355 | #else |
---|
| 356 | nDelete= ngfDelete; |
---|
| 357 | #endif |
---|
| 358 | if (complete) |
---|
| 359 | { |
---|
| 360 | nNew=ngfNew; |
---|
| 361 | nNormalize=nDummy2; |
---|
| 362 | nInit = ngfInit; |
---|
| 363 | nInt = ngfInt; |
---|
| 364 | nAdd = ngfAdd; |
---|
| 365 | nSub = ngfSub; |
---|
| 366 | nMult = ngfMult; |
---|
| 367 | nDiv = ngfDiv; |
---|
| 368 | nExactDiv= ngfDiv; |
---|
| 369 | nIntDiv= ngfDiv; |
---|
[0ae5116] | 370 | nIntMod= ndIntMod; /* dummy !! */ |
---|
[8a150b] | 371 | nNeg = ngfNeg; |
---|
| 372 | nInvers= ngfInvers; |
---|
| 373 | nCopy = ngfCopy; |
---|
| 374 | nGreater = ngfGreater; |
---|
| 375 | nEqual = ngfEqual; |
---|
| 376 | nIsZero = ngfIsZero; |
---|
| 377 | nIsOne = ngfIsOne; |
---|
| 378 | nIsMOne = ngfIsMOne; |
---|
| 379 | nGreaterZero = ngfGreaterZero; |
---|
| 380 | nWrite = ngfWrite; |
---|
| 381 | nRead = ngfRead; |
---|
| 382 | nPower = ngfPower; |
---|
| 383 | nGcd = ndGcd; |
---|
| 384 | nLcm = ndGcd; /* tricky, isn't it ?*/ |
---|
| 385 | nSetMap=ngfSetMap; |
---|
[0f0974] | 386 | /* nName= ndName; */ |
---|
[8a150b] | 387 | /*nSize = ndSize;*/ |
---|
| 388 | #ifdef LDEBUG |
---|
| 389 | nDBTest=ngfDBTest; |
---|
[0ae5116] | 390 | #endif |
---|
| 391 | } |
---|
| 392 | } |
---|
| 393 | /* -------------- long C -----------------------*/ |
---|
[7fad0d] | 394 | else if (rField_is_long_C(r)) |
---|
[0ae5116] | 395 | { |
---|
| 396 | setGMPFloatPrecBytes(r->ch_flags); |
---|
| 397 | #ifdef LDEBUG |
---|
| 398 | nDBDelete= ngcDBDelete; |
---|
| 399 | #else |
---|
| 400 | nDelete= ngcDelete; |
---|
| 401 | #endif |
---|
| 402 | if (complete) |
---|
| 403 | { |
---|
| 404 | nNew=ngcNew; |
---|
| 405 | nNormalize=nDummy2; |
---|
| 406 | nInit = ngcInit; |
---|
| 407 | nInt = ngcInt; |
---|
| 408 | nAdd = ngcAdd; |
---|
| 409 | nSub = ngcSub; |
---|
| 410 | nMult = ngcMult; |
---|
| 411 | nDiv = ngcDiv; |
---|
| 412 | nExactDiv= ngcDiv; |
---|
| 413 | nIntDiv= ngcDiv; |
---|
| 414 | nIntMod= ndIntMod; /* dummy !! */ |
---|
| 415 | nNeg = ngcNeg; |
---|
| 416 | nInvers= ngcInvers; |
---|
| 417 | nCopy = ngcCopy; |
---|
| 418 | nGreater = ngcGreater; |
---|
| 419 | nEqual = ngcEqual; |
---|
| 420 | nIsZero = ngcIsZero; |
---|
| 421 | nIsOne = ngcIsOne; |
---|
| 422 | nIsMOne = ngcIsMOne; |
---|
| 423 | nGreaterZero = ngcGreaterZero; |
---|
| 424 | nWrite = ngcWrite; |
---|
| 425 | nRead = ngcRead; |
---|
| 426 | nPower = ngcPower; |
---|
| 427 | nGcd = ndGcd; |
---|
| 428 | nLcm = ndGcd; /* tricky, isn't it ?*/ |
---|
| 429 | nSetMap=ngcSetMap; |
---|
| 430 | nPar=ngcPar; |
---|
| 431 | /*nSize = ndSize;*/ |
---|
| 432 | #ifdef LDEBUG |
---|
| 433 | nDBTest=ngcDBTest; |
---|
[8a150b] | 434 | #endif |
---|
| 435 | } |
---|
| 436 | } |
---|
| 437 | #ifdef TEST |
---|
| 438 | else |
---|
| 439 | { |
---|
| 440 | WerrorS("unknown field"); |
---|
| 441 | } |
---|
| 442 | #endif |
---|
[0e1846] | 443 | if (complete&&(!errorreported)) nNULL=nInit(0); |
---|
| 444 | } |
---|
| 445 | |
---|