cgit.sxemacs.org Git - sxemacs/blob - src/ent/ent-gaussian.c

   1 /*
   2   ent-gaussian.c -- Numeric types for SXEmacs
   3   Copyright (C) 2005, 2006 Sebastian Freundt
   4
   5   Author:  Sebastian Freundt
   6
   7 This file is part of SXEmacs
   8
   9 SXEmacs is free software: you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation, either version 3 of the License, or
  12 (at your option) any later version.
  13
  14 SXEmacs is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  21
  22
  23 #include <config.h>
  24 #include <limits.h>
  25 #include <math.h>
  26 #include "lisp.h"
  27 #include "sysproc.h"    /* For qxe_getpid */
  28
  29 #include "ent.h"
  30 #include "ent-float.h"
  31 #ifdef HAVE_MPFR
  32 #include "ent-mpfr.h"
  33 #endif
  34 #include "ent-gaussian.h"
  35 #ifdef HAVE_MPC
  36 #include "ent-mpc.h"
  37 #endif
  38
  39 bigg ent_scratch_bigg;
  40 static ase_nullary_operation_f Qent_gaussian_zero, Qent_gaussian_one;
  41
  42 \f
  43 static void
  44 bigg_print(Lisp_Object obj, Lisp_Object printcharfun, int SXE_UNUSED(escapeflag))
  45 {
  46         Bufbyte *fstr = bigg_to_string(XBIGG_DATA(obj), 10);
  47         write_c_string((char*)fstr, printcharfun);
  48         xfree(fstr);
  49         fstr = (Bufbyte *)NULL;
  50         return;
  51 }
  52
  53 static int
  54 bigg_equal(Lisp_Object obj1, Lisp_Object obj2, int SXE_UNUSED(depth))
  55 {
  56         return bigg_eql(XBIGG_DATA(obj1), XBIGG_DATA(obj2));
  57 }
  58
  59 static unsigned long
  60 bigg_hash(Lisp_Object obj, int SXE_UNUSED(depth))
  61 {
  62         return bigg_hashcode(XBIGG_DATA(obj));
  63 }
  64
  65 static Lisp_Object
  66 bigg_mark(Lisp_Object SXE_UNUSED(obj))
  67 {
  68         return Qnil;
  69 }
  70
  71 static void
  72 bigg_finalise(void *SXE_UNUSED(header), int for_disksave)
  73 {
  74         if (for_disksave)
  75                 signal_simple_error
  76                         ("Can't dump an emacs containing "
  77                          "pseudo-gaussian objects",Qt);
  78 }
  79
  80 static const struct lrecord_description bigg_description[] = {
  81         { XD_OPAQUE_DATA_PTR, offsetof(Lisp_Bigg, data) },
  82         { XD_END }
  83 };
  84
  85 DEFINE_BASIC_LRECORD_IMPLEMENTATION("bigg", bigg,
  86                                     bigg_mark, bigg_print, bigg_finalise,
  87                                     bigg_equal, bigg_hash,
  88                                     bigg_description, Lisp_Bigg);
  89
  90 DEFUN("make-bigg", Fmake_bigg, 2, 2, 0, /*
  91 Return the Gaussian number whose rational component is REAL-PART
  92 and whose imaginary component is IMAGINARY-PART.
  93 */
  94        (real_part, imaginary_part))
  95 {
  96         CHECK_COMPARABLE(real_part);
  97         CHECK_COMPARABLE(imaginary_part);
  98
  99         {
 100                 Lisp_Object tmp_r = Fcoerce_number(real_part, Qbigz, Qnil);
 101                 Lisp_Object tmp_i = Fcoerce_number(imaginary_part, Qbigz, Qnil);
 102                 return make_bigg_bz(XBIGZ_DATA(tmp_r), XBIGZ_DATA(tmp_i));
 103         }
 104 }
 105
 106 \f
 107 /* basic functions */
 108 void bigg_init(bigg g)
 109 {
 110         bigz_init(bigg_re(g));
 111         bigz_init(bigg_im(g));
 112 }
 113
 114 void bigg_fini(bigg g)
 115 {
 116         bigz_fini(bigg_re(g));
 117         bigz_fini(bigg_im(g));
 118 }
 119
 120 unsigned long bigg_hashcode(bigg g)
 121 {
 122         return (bigz_hashcode(bigg_re(g)) ^
 123                 bigz_hashcode(bigg_im(g)));
 124 }
 125
 126 Bufbyte *bigg_to_string(bigg g, int base)
 127 {
 128         Bufbyte *intg_str;
 129         Bufbyte *imag_str;
 130         int intg_len, imag_len;
 131         int sign, neg;
 132
 133         intg_str = (Bufbyte*)bigz_to_string(bigg_re(g), base);
 134         imag_str = (Bufbyte*)bigz_to_string(bigg_im(g), base);
 135
 136         intg_len = strlen((char*)intg_str);
 137         imag_len = strlen((char*)imag_str);
 138
 139         sign = bigz_sign(bigg_im(g));
 140         neg = (sign >= 0) ? 1 : 0;
 141
 142         /* now append the imaginary string */
 143         XREALLOC_ARRAY(intg_str, Bufbyte, intg_len + neg + imag_len + 2);
 144         if (neg)
 145                 intg_str[intg_len] = '+';
 146         memmove(&intg_str[intg_len + neg],
 147                 &imag_str[0],
 148                 imag_len);
 149         intg_str[intg_len+neg+imag_len] = 'i';
 150         intg_str[intg_len+neg+imag_len+1] = '\0';
 151         xfree(imag_str);
 152
 153         return intg_str;
 154 }
 155
 156 /***** Bigg: converting assignments *****/
 157 void bigg_set(bigg g1,bigg g2)
 158 {
 159         bigz_set(bigg_re(g1), bigg_re(g2));
 160         bigz_set(bigg_im(g1), bigg_im(g2));
 161 }
 162
 163 void bigg_set_long(bigg g, long l)
 164 {
 165         bigz_set_long(bigg_re(g), l);
 166         bigz_set_long(bigg_im(g), 0L);
 167 }
 168
 169 void bigg_set_long_long(bigg g, long l1, long l2)
 170 {
 171         bigz_set_long(bigg_re(g), l1);
 172         bigz_set_long(bigg_im(g), l2);
 173 }
 174
 175 void bigg_set_ulong(bigg g, unsigned long ul)
 176 {
 177         bigz_set_ulong(bigg_re(g), ul);
 178         bigz_set_ulong(bigg_im(g), 0UL);
 179 }
 180
 181 void bigg_set_ulong_ulong(bigg g, unsigned long ul1, unsigned long ul2)
 182 {
 183         bigz_set_ulong(bigg_re(g), ul1);
 184         bigz_set_ulong(bigg_im(g), ul2);
 185 }
 186
 187 void bigg_set_bigz(bigg g, bigz z)
 188 {
 189         bigz_set(bigg_re(g), z);
 190         bigz_set_long(bigg_im(g), 0L);
 191 }
 192
 193 void bigg_set_bigz_bigz(bigg g, bigz z1, bigz z2)
 194 {
 195         bigz_set(bigg_re(g), z1);
 196         bigz_set(bigg_im(g), z2);
 197 }
 198
 199 /* void bigc_set_bigg(bigc c, bigg g)
 200  * {
 201  *      bigc_set_bigfr_bigfr(bigg_re(g), z1);
 202  * }
 203  */
 204
 205 /***** Bigg: comparisons *****/
 206 int bigg_eql(bigg g1, bigg g2)
 207 {
 208         return ((bigz_eql(bigg_re(g1), bigg_re(g2))) &&
 209                 (bigz_eql(bigg_im(g1), bigg_im(g2))));
 210 }
 211
 212 /***** Bigg: arithmetic *****/
 213 #if defined HAVE_MPFR && defined WITH_MPFR
 214 void bigg_abs(bigfr res, bigg g)
 215 {
 216         /* the absolute archimedean valuation of a+bi is defined as:
 217          * (a^2 + b^2)^(1/2)
 218          */
 219         bigz accu1, accu2, bz;
 220         bigz_init(accu1);
 221         bigz_init(accu2);
 222         bigz_init(bz);
 223
 224         bigz_mul(accu1, bigg_re(g), bigg_re(g));
 225         bigz_mul(accu2, bigg_im(g), bigg_im(g));
 226         bigz_add(bz, accu1, accu2);
 227
 228         bigfr_set_bigz(res, bz);
 229         bigfr_sqrt(res, res);
 230
 231         bigz_fini(accu1);
 232         bigz_fini(accu2);
 233         bigz_fini(bz);
 234 }
 235 #endif
 236
 237 void bigg_norm(bigz res, bigg g)
 238 {
 239         /* norm is the square of the absolute archimedean valuation */
 240         bigz accu1, accu2;
 241         bigz_init(accu1);
 242         bigz_init(accu2);
 243
 244         bigz_mul(accu1, bigg_re(g), bigg_re(g));
 245         bigz_mul(accu2, bigg_im(g), bigg_im(g));
 246         bigz_add(res, accu1, accu2);
 247
 248         bigz_fini(accu1);
 249         bigz_fini(accu2);
 250 }
 251
 252 void bigg_neg(bigg res, bigg g)
 253 {
 254         /* negation is defined point-wise */
 255         bigz_neg(bigg_re(res), bigg_re(g));
 256         bigz_neg(bigg_im(res), bigg_im(g));
 257 }
 258
 259 void bigg_conj(bigg res, bigg g)
 260 {
 261         bigg_set(res, g);
 262         bigz_neg(bigg_im(res), bigg_im(res));
 263 }
 264
 265 void bigg_add(bigg res, bigg g1, bigg g2)
 266 {
 267         /* addition is defined point-wise */
 268         bigz accu1, accu2;
 269         bigz_init(accu1);
 270         bigz_init(accu2);
 271
 272         bigz_add(accu1, bigg_re(g1), bigg_re(g2));
 273         bigz_add(accu2, bigg_im(g1), bigg_im(g2));
 274         bigg_set_bigz_bigz(res, accu1, accu2);
 275
 276         bigz_fini(accu1);
 277         bigz_fini(accu2);
 278 }
 279
 280 void bigg_sub(bigg res, bigg g1, bigg g2)
 281 {
 282         /* subtraction is defined point-wise */
 283         bigz_sub(bigg_re(res), bigg_re(g1), bigg_re(g2));
 284         bigz_sub(bigg_im(res), bigg_im(g1), bigg_im(g2));
 285 }
 286
 287 void bigg_mul(bigg res, bigg g1, bigg g2)
 288 {
 289         /* multiplication is defined as:
 290          * (a + bi)*(c + di) = (ac - bd) + (ad + bc)i
 291          */
 292         bigz accu1, accu2, accu3, accu4;
 293         bigz_init(accu1);
 294         bigz_init(accu2);
 295         bigz_init(accu3);
 296         bigz_init(accu4);
 297
 298         bigz_mul(accu1, bigg_re(g1), bigg_re(g2));
 299         bigz_mul(accu2, bigg_im(g1), bigg_im(g2));
 300         bigz_mul(accu3, bigg_re(g1), bigg_im(g2));
 301         bigz_mul(accu4, bigg_im(g1), bigg_re(g2));
 302
 303         bigz_sub(bigg_re(res), accu1, accu2);
 304         bigz_add(bigg_im(res), accu3, accu4);
 305
 306         bigz_fini(accu1);
 307         bigz_fini(accu2);
 308         bigz_fini(accu3);
 309         bigz_fini(accu4);
 310 }
 311
 312 void bigg_div(bigg res, bigg g1, bigg g2)
 313 {
 314         /* division is defined as:
 315          * (a + bi) div (c + di) = ((a+bi)*(c-di)) div (c*c+d*d)
 316          */
 317         bigz accu1, accu2;
 318         bigg accug;
 319         bigz_init(accu1);
 320         bigz_init(accu2);
 321         bigg_init(accug);
 322
 323         /* compute: c^2 + d^2 */
 324         bigz_mul(accu1, bigg_re(g2), bigg_re(g2));
 325         bigz_mul(accu2, bigg_im(g2), bigg_im(g2));
 326         bigz_add(accu1, accu1, accu2);
 327
 328         /* do normal multiplication with conjugate of g2 */
 329         bigg_conj(accug, g2);
 330         bigg_mul(accug, g1, accug);
 331
 332         bigg_set(res, accug);
 333
 334         /* now divide (g1*conj(g2)) by c^2+d^2 (point-wise) */
 335         bigz_div(bigg_re(res), bigg_re(accug), accu1);
 336         bigz_div(bigg_im(res), bigg_im(accug), accu1);
 337
 338         bigg_fini(accug);
 339         bigz_fini(accu2);
 340         bigz_fini(accu1);
 341 }
 342
 343 void bigg_mod(bigg res, bigg g1, bigg g2)
 344 {
 345         /* the modulo relation is defined as:
 346          * (a + bi) mod (c + di) ~
 347          * (a+bi) - ((a+bi) div (c-di)) * (c+di)
 348          */
 349         bigg accug;
 350         bigg_init(accug);
 351
 352         /* do normal division */
 353         bigg_div(accug, g1, g2);
 354
 355         /* now re-multiply g2 */
 356         bigg_mul(accug, accug, g2);
 357
 358         /* and find the difference */
 359         bigg_sub(res, g1, accug);
 360
 361         bigg_fini(accug);
 362 }
 363
 364 void bigg_pow(bigg res, bigg g1, unsigned long g2)
 365 {
 366 #if defined(HAVE_MPZ) && defined(WITH_GMP)
 367         unsigned long i;
 368         bigz bin, resintg, resimag, tmpbz1, tmpbz2, tmpbz3, intg, imag;
 369
 370         bigz_init(bin);
 371         bigz_init(resintg);
 372         bigz_init(resimag);
 373         bigz_init(intg);
 374         bigz_init(imag);
 375         bigz_init(tmpbz1);
 376         bigz_init(tmpbz2);
 377         bigz_init(tmpbz3);
 378
 379         bigz_set_long(resintg, 0L);
 380         bigz_set_long(resimag, 0L);
 381
 382         bigz_set(intg, bigg_re(g1));
 383         bigz_set(imag, bigg_im(g1));
 384
 385         /* we compute using the binomial coefficients */
 386         for (i=0; i<=g2; i++) {
 387                 mpz_bin_uiui(bin, g2, i);
 388                 if (i % 2 == 0) {
 389                         /* real part changes */
 390                         bigz_pow(tmpbz1, intg, g2-i);
 391                         bigz_pow(tmpbz2, imag, i);
 392                         bigz_mul(tmpbz3, tmpbz1, tmpbz2);
 393                         bigz_mul(bin, bin, tmpbz3);
 394                         if (i % 4 == 0) {
 395                                 bigz_add(resintg, resintg, bin);
 396                         } else if (i % 4 == 2) {
 397                                 bigz_sub(resintg, resintg, bin);
 398                         }
 399                 } else {
 400                         /* imag part changes */
 401                         bigz_pow(tmpbz1, intg, g2-i);
 402                         bigz_pow(tmpbz2, imag, i);
 403                         bigz_mul(tmpbz3, tmpbz1, tmpbz2);
 404                         bigz_mul(bin, bin, tmpbz3);
 405                         if (i % 4 == 1) {
 406                                 bigz_add(resimag, resimag, bin);
 407                         } else if (i % 4 == 3) {
 408                                 bigz_sub(resimag, resimag, bin);
 409                         }
 410                 }
 411         }
 412
 413         bigg_set_bigz_bigz(res, resintg, resimag);
 414
 415         bigz_fini(bin);
 416         bigz_fini(intg);
 417         bigz_fini(imag);
 418         bigz_init(resintg);
 419         bigz_init(resimag);
 420         bigz_fini(tmpbz1);
 421         bigz_fini(tmpbz2);
 422         bigz_fini(tmpbz3);
 423 #else
 424         bigg_set_long_long(res, 0L, 0L);
 425 #endif
 426 }
 427
 428 Lisp_Object read_bigg_string(char *cp)
 429 {
 430         bigz bz_re, bz_im;
 431         int sign;
 432         Lisp_Object result;
 433         Bufbyte *end;
 434         Bufbyte tmp;
 435
 436         bigz_init(bz_re);
 437         bigz_init(bz_im);
 438
 439         /* MPZ bigz_set_string has no effect
 440          * with initial + sign */
 441         if (*cp == '+')
 442                 cp++;
 443
 444         end = (Bufbyte *)cp;
 445
 446         if (*cp == '-') {
 447                 /* jump over a leading minus */
 448                 cp++;
 449         }
 450
 451         while ((*cp >= '0' && *cp <= '9'))
 452                 cp++;
 453
 454         /* MPZ cannot read numbers with characters after them.
 455          * See limitations below in convert GMP-MPZ strings
 456          */
 457         tmp = (Bufbyte)*cp;
 458         *cp = '\0';
 459         bigz_set_string(bz_re, (char *)end, 0);
 460         *cp = tmp;
 461
 462         /* read the imaginary part */
 463         sign = 0;
 464         if (*cp == '+') {
 465                 cp++;
 466                 sign = 1;
 467         }
 468         if (*cp == '-') {
 469                 cp++;
 470                 sign = -1;
 471         }
 472         if ((*cp == 'i' || *cp == 'I') && (sign == 1)) {
 473                 /* expand +i to +1i and -i to -1i */
 474                 bigz_set_long(bz_im, 1L);
 475         } else if ((*cp == 'i' || *cp == 'I') && (sign == -1)) {
 476                 /* expand +i to +1i and -i to -1i */
 477                 bigz_set_long(bz_im, -1L);
 478         } else if (sign == 0) {
 479                 /* obviously we did not have a+bi,
 480                  * but merely bi
 481                  */
 482                 bigz_set(bz_im, bz_re);
 483                 bigz_set_long(bz_re, 0L);
 484         } else {
 485                 end = (Bufbyte*)cp;
 486                 if (sign == -1)
 487                         end--;
 488                 while ((*cp >= '0' && *cp <= '9'))
 489                         cp++;
 490                 tmp = (Bufbyte)*cp;
 491                 *cp = '\0';
 492                 bigz_set_string(bz_im, (char *)end, 0);
 493                 *cp = tmp;
 494         }
 495
 496         result = make_bigg_bz(bz_re, bz_im);
 497
 498         bigz_fini(bz_re);
 499         bigz_fini(bz_im);
 500         return result;
 501 }
 502
 503 /* bigg ops */
 504 static inline int
 505 ent_gaussian_zerop(Lisp_Object o)
 506 {
 507         return (bigz_sign(bigg_re(XBIGG_DATA(o))) == 0 &&
 508                 bigz_sign(bigg_im(XBIGG_DATA(o))) == 0);
 509 }
 510
 511 static inline int
 512 ent_gaussian_onep(Lisp_Object o)
 513 {
 514         return ((bigz_fits_long_p(bigg_re(XBIGG_DATA(o))) &&
 515                  bigz_to_long(bigg_re(XBIGG_DATA(o))) == 1L) &&
 516                 bigz_sign(bigg_im(XBIGG_DATA(o))) == 0);
 517 }
 518
 519 static inline int
 520 ent_gaussian_unitp(Lisp_Object o)
 521 {
 522         return (!ent_gaussian_zerop(o) &&
 523                 (bigz_fits_long_p(bigg_re(XBIGG_DATA(o))) &&
 524                  (bigz_to_long(bigg_re(XBIGG_DATA(o))) == 0L ||
 525                   bigz_to_long(bigg_re(XBIGG_DATA(o))) == 1L ||
 526                   bigz_to_long(bigg_re(XBIGG_DATA(o))) == -1L)) &&
 527                 (bigz_fits_long_p(bigg_im(XBIGG_DATA(o))) &&
 528                  (bigz_to_long(bigg_im(XBIGG_DATA(o))) == 0L ||
 529                   bigz_to_long(bigg_im(XBIGG_DATA(o))) == 1L ||
 530                   bigz_to_long(bigg_im(XBIGG_DATA(o))) == -1L)));
 531 }
 532
 533 static inline Lisp_Object
 534 ent_sum_BIGG_T(Lisp_Object l, Lisp_Object r)
 535 {
 536         bigg_add(ent_scratch_bigg, XBIGG_DATA(l), XBIGG_DATA(r));
 537         return make_bigg_bg(ent_scratch_bigg);
 538 }
 539 static inline Lisp_Object
 540 ent_sum_BIGG_T_COMPARABLE(Lisp_Object l, Lisp_Object r)
 541 {
 542         CHECK_COMPARABLE(r);
 543
 544         r = ent_lift(r, BIGZ_T, NULL);
 545
 546         bigg_set_bigz(ent_scratch_bigg, XBIGZ_DATA(r));
 547         bigg_add(ent_scratch_bigg, XBIGG_DATA(l), ent_scratch_bigg);
 548         return make_bigg_bg(ent_scratch_bigg);
 549 }
 550 static inline Lisp_Object
 551 ent_sum_COMPARABLE_BIGG_T(Lisp_Object l, Lisp_Object r)
 552 {
 553         CHECK_COMPARABLE(l);
 554
 555         l = ent_lift(l, BIGZ_T, NULL);
 556
 557         bigg_set_bigz(ent_scratch_bigg, XBIGZ_DATA(l));
 558         bigg_add(ent_scratch_bigg, ent_scratch_bigg, XBIGG_DATA(r));
 559         return make_bigg_bg(ent_scratch_bigg);
 560 }
 561
 562 static inline Lisp_Object
 563 ent_diff_BIGG_T(Lisp_Object l, Lisp_Object r)
 564 {
 565         bigg_sub(ent_scratch_bigg, XBIGG_DATA(l), XBIGG_DATA(r));
 566         return make_bigg_bg(ent_scratch_bigg);
 567 }
 568 static inline Lisp_Object
 569 ent_diff_BIGG_T_COMPARABLE(Lisp_Object l, Lisp_Object r)
 570 {
 571         CHECK_COMPARABLE(r);
 572
 573         r = ent_lift(r, BIGZ_T, NULL);
 574
 575         bigg_set_bigz(ent_scratch_bigg, XBIGZ_DATA(r));
 576         bigg_sub(ent_scratch_bigg, XBIGG_DATA(l), ent_scratch_bigg);
 577         return make_bigg_bg(ent_scratch_bigg);
 578 }
 579 static inline Lisp_Object
 580 ent_diff_COMPARABLE_BIGG_T(Lisp_Object l, Lisp_Object r)
 581 {
 582         CHECK_COMPARABLE(l);
 583
 584         l = ent_lift(l, BIGZ_T, NULL);
 585
 586         bigg_set_bigz(ent_scratch_bigg, XBIGZ_DATA(l));
 587         bigg_sub(ent_scratch_bigg, ent_scratch_bigg, XBIGG_DATA(r));
 588         return make_bigg_bg(ent_scratch_bigg);
 589 }
 590
 591 static inline Lisp_Object
 592 ent_neg_BIGG_T(Lisp_Object l)
 593 {
 594         bigg_neg(ent_scratch_bigg, XBIGG_DATA(l));
 595         return make_bigg_bg(ent_scratch_bigg);
 596 }
 597
 598 static inline Lisp_Object
 599 ent_prod_BIGG_T(Lisp_Object l, Lisp_Object r)
 600 {
 601         bigg_mul(ent_scratch_bigg, XBIGG_DATA(l), XBIGG_DATA(r));
 602         return make_bigg_bg(ent_scratch_bigg);
 603 }
 604 static inline Lisp_Object
 605 ent_prod_BIGG_T_COMPARABLE(Lisp_Object l, Lisp_Object r)
 606 {
 607         CHECK_COMPARABLE(r);
 608
 609         r = ent_lift(r, BIGZ_T, NULL);
 610
 611         bigg_set_bigz(ent_scratch_bigg, XBIGZ_DATA(r));
 612         bigg_mul(ent_scratch_bigg, XBIGG_DATA(l), ent_scratch_bigg);
 613         return make_bigg_bg(ent_scratch_bigg);
 614 }
 615 static inline Lisp_Object
 616 ent_prod_COMPARABLE_BIGG_T(Lisp_Object l, Lisp_Object r)
 617 {
 618         CHECK_COMPARABLE(l);
 619
 620         l = ent_lift(l, BIGZ_T, NULL);
 621
 622         bigg_set_bigz(ent_scratch_bigg, XBIGZ_DATA(l));
 623         bigg_mul(ent_scratch_bigg, ent_scratch_bigg, XBIGG_DATA(r));
 624         return make_bigg_bg(ent_scratch_bigg);
 625 }
 626
 627 static inline Lisp_Object
 628 ent_div_BIGG_T(Lisp_Object l, Lisp_Object r)
 629 {
 630         if (ent_gaussian_zerop(r)) {
 631                 if (!ent_gaussian_zerop(l)) {
 632                         return make_indef(COMPLEX_INFINITY);
 633                 } else {
 634                         return make_indef(NOT_A_NUMBER);
 635                 }
 636         }
 637         bigg_div(ent_scratch_bigg, XBIGG_DATA(l), XBIGG_DATA(r));
 638         return make_bigg_bg(ent_scratch_bigg);
 639 }
 640 static inline Lisp_Object
 641 ent_div_BIGG_T_COMPARABLE(Lisp_Object l, Lisp_Object r)
 642 {
 643         CHECK_COMPARABLE(r);
 644
 645         if (ent_unrel_zerop(l)) {
 646                 if (!ent_gaussian_zerop(l)) {
 647                         return make_indef(COMPLEX_INFINITY);
 648                 } else {
 649                         return make_indef(NOT_A_NUMBER);
 650                 }
 651         }
 652
 653         r = ent_lift(r, BIGZ_T, NULL);
 654
 655         bigg_set_bigz(ent_scratch_bigg, XBIGZ_DATA(r));
 656         bigg_div(ent_scratch_bigg, XBIGG_DATA(l), ent_scratch_bigg);
 657         return make_bigg_bg(ent_scratch_bigg);
 658 }
 659 static inline Lisp_Object
 660 ent_div_COMPARABLE_BIGG_T(Lisp_Object l, Lisp_Object r)
 661 {
 662         CHECK_COMPARABLE(l);
 663
 664         if (ent_gaussian_zerop(r)) {
 665                 if (!ent_unrel_zerop(l)) {
 666                         return make_indef(COMPLEX_INFINITY);
 667                 } else {
 668                         return make_indef(NOT_A_NUMBER);
 669                 }
 670         }
 671
 672         l = ent_lift(l, BIGZ_T, NULL);
 673
 674         bigg_set_bigz(ent_scratch_bigg, XBIGZ_DATA(l));
 675         bigg_div(ent_scratch_bigg, ent_scratch_bigg, XBIGG_DATA(r));
 676         return make_bigg_bg(ent_scratch_bigg);
 677 }
 678
 679 #if defined HAVE_MPC && defined WITH_MPC ||     \
 680         defined HAVE_PSEUC && defined WITH_PSEUC
 681 static inline Lisp_Object
 682 ent_quo_BIGG_T(Lisp_Object l, Lisp_Object r)
 683 {
 684         Lisp_Object tmp_l, tmp_r;
 685
 686         if (ent_gaussian_zerop(r)) {
 687                 if (!ent_gaussian_zerop(l)) {
 688                         return make_indef(COMPLEX_INFINITY);
 689                 } else {
 690                         return make_indef(NOT_A_NUMBER);
 691                 }
 692         }
 693
 694         bigc_set_prec(ent_scratch_bigc, internal_get_precision(Qnil));
 695         tmp_l = Fcoerce_number(l, Qbigc, Qnil);
 696         tmp_r = Fcoerce_number(r, Qbigc, Qnil);
 697         bigc_div(ent_scratch_bigc, XBIGC_DATA(tmp_l), XBIGC_DATA(tmp_r));
 698         return make_bigc_bc(ent_scratch_bigc);
 699 }
 700 static inline Lisp_Object
 701 ent_quo_BIGG_T_COMPARABLE(Lisp_Object l, Lisp_Object r)
 702 {
 703         CHECK_COMPARABLE(r);
 704
 705         if (ent_unrel_zerop(r)) {
 706                 if (!ent_gaussian_zerop(l)) {
 707                         return make_indef(COMPLEX_INFINITY);
 708                 } else {
 709                         return make_indef(NOT_A_NUMBER);
 710                 }
 711         }
 712
 713         l = ent_lift(l, BIGC_T, NULL);
 714         return ent_binop(ASE_BINARY_OP_QUO, l, r);
 715 }
 716 static inline Lisp_Object
 717 ent_quo_COMPARABLE_BIGG_T(Lisp_Object l, Lisp_Object r)
 718 {
 719         CHECK_COMPARABLE(l);
 720
 721         if (ent_gaussian_zerop(r)) {
 722                 if (!ent_unrel_zerop(l)) {
 723                         return make_indef(COMPLEX_INFINITY);
 724                 } else {
 725                         return make_indef(NOT_A_NUMBER);
 726                 }
 727         }
 728
 729         r = ent_lift(r, BIGC_T, NULL);
 730         return ent_binop(ASE_BINARY_OP_QUO, l, r);
 731 }
 732 #endif
 733
 734 static inline Lisp_Object
 735 ent_inv_BIGG_T(Lisp_Object r)
 736 {
 737         if (ent_gaussian_zerop(r)) {
 738                 return make_indef(COMPLEX_INFINITY);
 739         }
 740         bigg_div(ent_scratch_bigg,
 741                  XBIGG_DATA(Qent_gaussian_one), XBIGG_DATA(r));
 742         return make_bigg_bg(ent_scratch_bigg);
 743 }
 744 static inline Lisp_Object
 745 ent_rem_BIGG_T(Lisp_Object l, Lisp_Object r)
 746 {
 747         if (ent_gaussian_zerop(r)) {
 748                 return make_bigg(0, 0);
 749         }
 750         bigg_mod(ent_scratch_bigg, XBIGG_DATA(l), XBIGG_DATA(r));
 751         return make_bigg_bg(ent_scratch_bigg);
 752 }
 753 static inline Lisp_Object
 754 ent_pow_BIGG_T_integer(Lisp_Object l, Lisp_Object r)
 755 {
 756         long unsigned int expo = 0UL;
 757
 758         if (INTP(r)) {
 759                 expo = ent_int(r);
 760         } else if (BIGZP(r)) {
 761                 if (bigz_fits_ulong_p(XBIGZ_DATA(r)))
 762                         expo = bigz_to_ulong(XBIGZ_DATA(r));
 763                 else
 764                         Fsignal(Qarith_error, r);
 765         } else {
 766                 Fsignal(Qdomain_error, r);
 767         }
 768         bigg_pow(ent_scratch_bigg, XBIGG_DATA(l), expo);
 769         return make_bigg_bg(ent_scratch_bigg);
 770 }
 771
 772 /* relations */
 773 static inline int
 774 ent_eq_bigg(Lisp_Object l, Lisp_Object r)
 775 {
 776         return (bigz_eql(bigg_re(XBIGG_DATA(l)), bigg_re(XBIGG_DATA(r))) &&
 777                 bigz_eql(bigg_im(XBIGG_DATA(l)), bigg_im(XBIGG_DATA(r))));
 778 }
 779
 780 static inline int
 781 ent_ne_bigg(Lisp_Object l, Lisp_Object r)
 782 {
 783         return !(bigz_eql(bigg_re(XBIGG_DATA(l)), bigg_re(XBIGG_DATA(r))) &&
 784                  bigz_eql(bigg_im(XBIGG_DATA(l)), bigg_im(XBIGG_DATA(r))));
 785 }
 786
 787 #if 0
 788 static inline Lisp_Object
 789 ent_vallt_BIGG_T(Lisp_Object l, Lisp_Object r)
 790 {
 791         bigz b2;
 792         int result;
 793
 794         bigz_init(b2);
 795         bigg_norm(ent_scratch_bigz, XBIGG_DATA(l));
 796         bigg_norm(b2, XBIGG_DATA(r));
 797         result = bigz_lt(ent_scratch_bigz, b2);
 798
 799         bigz_fini(b2);
 800         return (result) ? Qt : Qnil;
 801 }
 802 static inline Lisp_Object
 803 ent_valgt_BIGG_T(Lisp_Object l, Lisp_Object r)
 804 {
 805         bigz b2;
 806         int result;
 807
 808         bigz_init(b2);
 809         bigg_norm(ent_scratch_bigz, XBIGG_DATA(l));
 810         bigg_norm(b2, XBIGG_DATA(r));
 811         result = bigz_gt(ent_scratch_bigz, b2);
 812
 813         bigz_fini(b2);
 814         return (result) ? Qt : Qnil;
 815 }
 816 static inline Lisp_Object
 817 ent_valeq_BIGG_T(Lisp_Object l, Lisp_Object r)
 818 {
 819         bigz b2;
 820         int result;
 821
 822         bigz_init(b2);
 823         bigg_norm(ent_scratch_bigz, XBIGG_DATA(l));
 824         bigg_norm(b2, XBIGG_DATA(r));
 825         result = bigz_eql(ent_scratch_bigz, b2);
 826
 827         bigz_fini(b2);
 828         return (result) ? Qt : Qnil;
 829 }
 830 static inline Lisp_Object
 831 ent_valne_BIGG_T(Lisp_Object l, Lisp_Object r)
 832 {
 833         bigz b2;
 834         int result;
 835
 836         bigz_init(b2);
 837         bigg_norm(ent_scratch_bigz, XBIGG_DATA(l));
 838         bigg_norm(b2, XBIGG_DATA(r));
 839         result = bigz_eql(ent_scratch_bigz, b2);
 840
 841         bigz_fini(b2);
 842         return (result) ? Qnil : Qt;
 843 }
 844 #endif
 845
 846 \f
 847 static Lisp_Object
 848 ent_lift_all_BIGG_T(Lisp_Object number, ent_lift_args_t SXE_UNUSED(la))
 849 {
 850         number = ent_lift(number, BIGZ_T, NULL);
 851         bigg_set_bigz(ent_scratch_bigg, XBIGZ_DATA(number));
 852         return make_bigg_bg(ent_scratch_bigg);
 853 }
 854
 855 #if defined HAVE_MPC && defined WITH_MPC ||     \
 856         defined HAVE_PSEUC && defined WITH_PSEUC
 857 static Lisp_Object
 858 ent_lift_BIGC_T_BIGG_T(Lisp_Object number, ent_lift_args_t SXE_UNUSED(la))
 859 {
 860         Lisp_Object re, im;
 861
 862         re = Freal_part(number);
 863         re = ent_lift(re, BIGZ_T, NULL);
 864         im = Fimaginary_part(number);
 865         im = ent_lift(im, BIGZ_T, NULL);
 866
 867         return make_bigg_bz(XBIGZ_DATA(re), XBIGZ_DATA(im));
 868 }
 869 #endif
 870
 871 \f
 872 static inline void
 873 ent_gaussian_nullary_optable_init(void)
 874 {
 875         Qent_gaussian_zero = make_bigg(0L, 0L);
 876         Qent_gaussian_one = make_bigg(1L, 0L);
 877         staticpro(&Qent_gaussian_zero);
 878         staticpro(&Qent_gaussian_one);
 879
 880         ent_nullop_register(ASE_NULLARY_OP_ZERO, BIGG_T, Qent_gaussian_zero);
 881         ent_nullop_register(ASE_NULLARY_OP_ONE, BIGG_T, Qent_gaussian_one);
 882 }
 883
 884 static inline void
 885 ent_gaussian_unary_optable_init(void)
 886 {
 887         ent_unop_register(ASE_UNARY_OP_NEG, BIGG_T, ent_neg_BIGG_T);
 888         ent_unop_register(ASE_UNARY_OP_INV, BIGG_T, ent_inv_BIGG_T);
 889 }
 890
 891 static inline void
 892 ent_gaussian_binary_optable_init(void)
 893 {
 894         /* sums */
 895         ent_binop_register(ASE_BINARY_OP_SUM,
 896                            BIGG_T, BIGG_T, ent_sum_BIGG_T);
 897         ent_binop_register(ASE_BINARY_OP_SUM,
 898                            BIGG_T, INT_T, ent_sum_BIGG_T_COMPARABLE);
 899         ent_binop_register(ASE_BINARY_OP_SUM,
 900                            INT_T, BIGG_T, ent_sum_COMPARABLE_BIGG_T);
 901 #if defined HAVE_MPZ && (defined WITH_GMP || defined WITH_MP)
 902         ent_binop_register(ASE_BINARY_OP_SUM,
 903                            BIGG_T, BIGZ_T, ent_sum_BIGG_T_COMPARABLE);
 904         ent_binop_register(ASE_BINARY_OP_SUM,
 905                            BIGZ_T, BIGG_T, ent_sum_COMPARABLE_BIGG_T);
 906 #endif
 907 #if defined HAVE_MPQ && defined WITH_GMP
 908         ent_binop_register(ASE_BINARY_OP_SUM,
 909                            BIGG_T, BIGQ_T, ent_sum_BIGG_T_COMPARABLE);
 910         ent_binop_register(ASE_BINARY_OP_SUM,
 911                            BIGQ_T, BIGG_T, ent_sum_COMPARABLE_BIGG_T);
 912 #endif
 913 #if defined HAVE_MPF && defined WITH_GMP
 914         ent_binop_register(ASE_BINARY_OP_SUM,
 915                            BIGG_T, BIGF_T, ent_sum_BIGG_T_COMPARABLE);
 916         ent_binop_register(ASE_BINARY_OP_SUM,
 917                            BIGF_T, BIGG_T, ent_sum_COMPARABLE_BIGG_T);
 918 #endif
 919 #if defined HAVE_MPFR && defined WITH_MPFR
 920         ent_binop_register(ASE_BINARY_OP_SUM,
 921                            BIGG_T, BIGFR_T, ent_sum_BIGG_T_COMPARABLE);
 922         ent_binop_register(ASE_BINARY_OP_SUM,
 923                            BIGFR_T, BIGG_T, ent_sum_COMPARABLE_BIGG_T);
 924 #endif
 925 #ifdef HAVE_FPFLOAT
 926         ent_binop_register(ASE_BINARY_OP_SUM,
 927                            BIGG_T, FLOAT_T, ent_sum_BIGG_T_COMPARABLE);
 928         ent_binop_register(ASE_BINARY_OP_SUM,
 929                            FLOAT_T, BIGG_T, ent_sum_COMPARABLE_BIGG_T);
 930 #endif
 931         /* diffs */
 932         ent_binop_register(ASE_BINARY_OP_DIFF,
 933                            BIGG_T, BIGG_T, ent_diff_BIGG_T);
 934         ent_binop_register(ASE_BINARY_OP_DIFF,
 935                            BIGG_T, INT_T, ent_diff_BIGG_T_COMPARABLE);
 936         ent_binop_register(ASE_BINARY_OP_DIFF,
 937                            INT_T, BIGG_T, ent_diff_COMPARABLE_BIGG_T);
 938         ent_binop_register(ASE_BINARY_OP_DIFF,
 939                            BIGG_T, BIGZ_T, ent_diff_BIGG_T_COMPARABLE);
 940         ent_binop_register(ASE_BINARY_OP_DIFF,
 941                            BIGZ_T, BIGG_T, ent_diff_COMPARABLE_BIGG_T);
 942 #if defined HAVE_MPQ && defined WITH_GMP
 943         ent_binop_register(ASE_BINARY_OP_DIFF,
 944                            BIGG_T, BIGQ_T, ent_diff_BIGG_T_COMPARABLE);
 945         ent_binop_register(ASE_BINARY_OP_DIFF,
 946                            BIGQ_T, BIGG_T, ent_diff_COMPARABLE_BIGG_T);
 947 #endif
 948 #if defined HAVE_MPF && defined WITH_GMP
 949         ent_binop_register(ASE_BINARY_OP_DIFF,
 950                            BIGG_T, BIGF_T, ent_diff_BIGG_T_COMPARABLE);
 951         ent_binop_register(ASE_BINARY_OP_DIFF,
 952                            BIGF_T, BIGG_T, ent_diff_COMPARABLE_BIGG_T);
 953 #endif
 954 #if defined HAVE_MPFR && defined WITH_MPFR
 955         ent_binop_register(ASE_BINARY_OP_DIFF,
 956                            BIGG_T, BIGFR_T, ent_diff_BIGG_T_COMPARABLE);
 957         ent_binop_register(ASE_BINARY_OP_DIFF,
 958                            BIGFR_T, BIGG_T, ent_diff_COMPARABLE_BIGG_T);
 959 #endif
 960 #ifdef HAVE_FPFLOAT
 961         ent_binop_register(ASE_BINARY_OP_DIFF,
 962                            BIGG_T, FLOAT_T, ent_diff_BIGG_T_COMPARABLE);
 963         ent_binop_register(ASE_BINARY_OP_DIFF,
 964                            FLOAT_T, BIGG_T, ent_diff_COMPARABLE_BIGG_T);
 965 #endif
 966         /* prods */
 967         ent_binop_register(ASE_BINARY_OP_PROD,
 968                            BIGG_T, BIGG_T, ent_prod_BIGG_T);
 969         ent_binop_register(ASE_BINARY_OP_PROD,
 970                            BIGG_T, INT_T, ent_prod_BIGG_T_COMPARABLE);
 971         ent_binop_register(ASE_BINARY_OP_PROD,
 972                            INT_T, BIGG_T, ent_prod_COMPARABLE_BIGG_T);
 973         ent_binop_register(ASE_BINARY_OP_PROD,
 974                            BIGG_T, BIGZ_T, ent_prod_BIGG_T_COMPARABLE);
 975         ent_binop_register(ASE_BINARY_OP_PROD,
 976                            BIGZ_T, BIGG_T, ent_prod_COMPARABLE_BIGG_T);
 977 #if defined HAVE_MPQ && defined WITH_GMP
 978         ent_binop_register(ASE_BINARY_OP_PROD,
 979                            BIGG_T, BIGQ_T, ent_prod_BIGG_T_COMPARABLE);
 980         ent_binop_register(ASE_BINARY_OP_PROD,
 981                            BIGQ_T, BIGG_T, ent_prod_COMPARABLE_BIGG_T);
 982 #endif
 983 #if defined HAVE_MPF && defined WITH_GMP
 984         ent_binop_register(ASE_BINARY_OP_PROD,
 985                            BIGG_T, BIGF_T, ent_prod_BIGG_T_COMPARABLE);
 986         ent_binop_register(ASE_BINARY_OP_PROD,
 987                            BIGF_T, BIGG_T, ent_prod_COMPARABLE_BIGG_T);
 988 #endif
 989 #if defined HAVE_MPFR && defined WITH_MPFR
 990         ent_binop_register(ASE_BINARY_OP_PROD,
 991                            BIGG_T, BIGFR_T, ent_prod_BIGG_T_COMPARABLE);
 992         ent_binop_register(ASE_BINARY_OP_PROD,
 993                            BIGFR_T, BIGG_T, ent_prod_COMPARABLE_BIGG_T);
 994 #endif
 995 #ifdef HAVE_FPFLOAT
 996         ent_binop_register(ASE_BINARY_OP_PROD,
 997                            BIGG_T, FLOAT_T, ent_prod_BIGG_T_COMPARABLE);
 998         ent_binop_register(ASE_BINARY_OP_PROD,
 999                            FLOAT_T, BIGG_T, ent_prod_COMPARABLE_BIGG_T);
1000 #endif
1001
1002         /* divisions and quotients */
1003         ent_binop_register(ASE_BINARY_OP_DIV,
1004                            BIGG_T, BIGG_T, ent_div_BIGG_T);
1005         ent_binop_register(ASE_BINARY_OP_DIV,
1006                            BIGG_T, INT_T, ent_div_BIGG_T_COMPARABLE);
1007         ent_binop_register(ASE_BINARY_OP_DIV,
1008                            INT_T, BIGG_T, ent_div_COMPARABLE_BIGG_T);
1009         ent_binop_register(ASE_BINARY_OP_DIV,
1010                            BIGG_T, BIGZ_T, ent_div_BIGG_T_COMPARABLE);
1011         ent_binop_register(ASE_BINARY_OP_DIV,
1012                            BIGZ_T, BIGG_T, ent_div_COMPARABLE_BIGG_T);
1013 #if defined HAVE_MPQ && defined WITH_GMP
1014         ent_binop_register(ASE_BINARY_OP_DIV,
1015                            BIGG_T, BIGQ_T, ent_div_BIGG_T_COMPARABLE);
1016         ent_binop_register(ASE_BINARY_OP_DIV,
1017                            BIGQ_T, BIGG_T, ent_div_COMPARABLE_BIGG_T);
1018 #endif
1019 #if defined HAVE_MPF && defined WITH_GMP
1020         ent_binop_register(ASE_BINARY_OP_DIV,
1021                            BIGG_T, BIGF_T, ent_div_BIGG_T_COMPARABLE);
1022         ent_binop_register(ASE_BINARY_OP_DIV,
1023                            BIGF_T, BIGG_T, ent_div_COMPARABLE_BIGG_T);
1024 #endif
1025 #if defined HAVE_MPFR && defined WITH_MPFR
1026         ent_binop_register(ASE_BINARY_OP_DIV,
1027                            BIGG_T, BIGFR_T, ent_div_BIGG_T_COMPARABLE);
1028         ent_binop_register(ASE_BINARY_OP_DIV,
1029                            BIGFR_T, BIGG_T, ent_div_COMPARABLE_BIGG_T);
1030 #endif
1031 #ifdef HAVE_FPFLOAT
1032         ent_binop_register(ASE_BINARY_OP_DIV,
1033                            BIGG_T, FLOAT_T, ent_div_BIGG_T_COMPARABLE);
1034         ent_binop_register(ASE_BINARY_OP_DIV,
1035                            FLOAT_T, BIGG_T, ent_div_COMPARABLE_BIGG_T);
1036 #endif
1037
1038 #if defined HAVE_MPC && defined WITH_MPC ||     \
1039         defined HAVE_PSEUC && defined WITH_PSEUC
1040         ent_binop_register(ASE_BINARY_OP_QUO,
1041                            BIGG_T, BIGG_T, ent_quo_BIGG_T);
1042         ent_binop_register(ASE_BINARY_OP_QUO,
1043                            BIGG_T, BIGZ_T, ent_quo_BIGG_T_COMPARABLE);
1044         ent_binop_register(ASE_BINARY_OP_QUO,
1045                            BIGZ_T, BIGG_T, ent_quo_COMPARABLE_BIGG_T);
1046 #if defined HAVE_MPQ && defined WITH_GMP
1047         ent_binop_register(ASE_BINARY_OP_QUO,
1048                            BIGG_T, BIGQ_T, ent_quo_BIGG_T_COMPARABLE);
1049         ent_binop_register(ASE_BINARY_OP_QUO,
1050                            BIGQ_T, BIGG_T, ent_quo_COMPARABLE_BIGG_T);
1051 #endif
1052 #if defined HAVE_MPF && defined WITH_GMP
1053         ent_binop_register(ASE_BINARY_OP_QUO,
1054                            BIGG_T, BIGF_T, ent_quo_BIGG_T_COMPARABLE);
1055         ent_binop_register(ASE_BINARY_OP_QUO,
1056                            BIGF_T, BIGG_T, ent_quo_COMPARABLE_BIGG_T);
1057 #endif
1058 #if defined HAVE_MPFR && defined WITH_MPFR
1059         ent_binop_register(ASE_BINARY_OP_QUO,
1060                            BIGG_T, BIGFR_T, ent_quo_BIGG_T_COMPARABLE);
1061         ent_binop_register(ASE_BINARY_OP_QUO,
1062                            BIGFR_T, BIGG_T, ent_quo_COMPARABLE_BIGG_T);
1063 #endif
1064 #ifdef HAVE_FPFLOAT
1065         ent_binop_register(ASE_BINARY_OP_QUO,
1066                            BIGG_T, FLOAT_T, ent_quo_BIGG_T_COMPARABLE);
1067         ent_binop_register(ASE_BINARY_OP_QUO,
1068                            FLOAT_T, BIGG_T, ent_quo_COMPARABLE_BIGG_T);
1069 #endif
1070 #else  /* !HAVE_MPC */
1071         ent_binop_register(ASE_BINARY_OP_QUO,
1072                            BIGG_T, BIGG_T, ent_div_BIGG_T);
1073         ent_binop_register(ASE_BINARY_OP_QUO,
1074                            BIGG_T, BIGZ_T, ent_div_BIGG_T_COMPARABLE);
1075         ent_binop_register(ASE_BINARY_OP_QUO,
1076                            BIGZ_T, BIGG_T, ent_div_COMPARABLE_BIGG_T);
1077 #if defined HAVE_MPQ && defined WITH_GMP
1078         ent_binop_register(ASE_BINARY_OP_QUO,
1079                            BIGG_T, BIGQ_T, ent_div_BIGG_T_COMPARABLE);
1080         ent_binop_register(ASE_BINARY_OP_QUO,
1081                            BIGQ_T, BIGG_T, ent_div_COMPARABLE_BIGG_T);
1082 #endif
1083 #if defined HAVE_MPF && defined WITH_GMP
1084         ent_binop_register(ASE_BINARY_OP_QUO,
1085                            BIGG_T, BIGF_T, ent_div_BIGG_T_COMPARABLE);
1086         ent_binop_register(ASE_BINARY_OP_QUO,
1087                            BIGF_T, BIGG_T, ent_div_COMPARABLE_BIGG_T);
1088 #endif
1089 #if defined HAVE_MPFR && defined WITH_MPFR
1090         ent_binop_register(ASE_BINARY_OP_QUO,
1091                            BIGG_T, BIGFR_T, ent_div_BIGG_T_COMPARABLE);
1092         ent_binop_register(ASE_BINARY_OP_QUO,
1093                            BIGFR_T, BIGG_T, ent_div_COMPARABLE_BIGG_T);
1094 #endif
1095 #ifdef HAVE_FPFLOAT
1096         ent_binop_register(ASE_BINARY_OP_QUO,
1097                            BIGG_T, FLOAT_T, ent_div_BIGG_T_COMPARABLE);
1098         ent_binop_register(ASE_BINARY_OP_QUO,
1099                            FLOAT_T, BIGG_T, ent_div_COMPARABLE_BIGG_T);
1100 #endif
1101 #endif
1102         ent_binop_register(ASE_BINARY_OP_REM,
1103                            BIGG_T, BIGG_T, ent_rem_BIGG_T);
1104         ent_binop_register(ASE_BINARY_OP_MOD,
1105                            BIGG_T, BIGG_T, ent_rem_BIGG_T);
1106         ent_binop_register(ASE_BINARY_OP_POW,
1107                            BIGG_T, INT_T, ent_pow_BIGG_T_integer);
1108         ent_binop_register(ASE_BINARY_OP_POW,
1109                            BIGG_T, BIGZ_T, ent_pow_BIGG_T_integer);
1110 }
1111
1112 static inline void
1113 ent_gaussian_unary_reltable_init(void)
1114 {
1115         ent_unrel_register(ASE_UNARY_REL_ZEROP, BIGG_T, ent_gaussian_zerop);
1116         ent_unrel_register(ASE_UNARY_REL_ONEP, BIGG_T, ent_gaussian_onep);
1117         ent_unrel_register(ASE_UNARY_REL_UNITP, BIGG_T, ent_gaussian_unitp);
1118 }
1119
1120 static inline void
1121 ent_gaussian_binary_reltable_init(void)
1122 {
1123         ent_binrel_register(ASE_BINARY_REL_EQUALP,
1124                             BIGG_T, BIGG_T, ent_eq_bigg);
1125         ent_binrel_register(ASE_BINARY_REL_NEQP,
1126                             BIGG_T, BIGG_T, ent_ne_bigg);
1127 }
1128
1129 static inline void
1130 ent_gaussian_lifttable_init(void)
1131 {
1132         ent_lift_register(INT_T, BIGG_T, ent_lift_all_BIGG_T);
1133         ent_lift_register(BIGZ_T, BIGC_T, ent_lift_all_BIGG_T);
1134 #if defined HAVE_MPQ && defined WITH_GMP
1135         ent_lift_register(BIGQ_T, BIGG_T, ent_lift_all_BIGG_T);
1136 #endif
1137 #if defined HAVE_MPF && defined WITH_GMP
1138         ent_lift_register(BIGF_T, BIGG_T, ent_lift_all_BIGG_T);
1139 #endif
1140 #if defined HAVE_MPFR && defined WITH_MPFR
1141         ent_lift_register(BIGFR_T, BIGG_T, ent_lift_all_BIGG_T);
1142 #endif
1143 #ifdef HAVE_FPFLOAT
1144         ent_lift_register(FLOAT_T, BIGG_T, ent_lift_all_BIGG_T);
1145 #endif
1146 #if defined HAVE_MPC && defined WITH_MPC ||     \
1147         defined HAVE_PSEUC && defined WITH_PSEUC
1148         ent_lift_register(BIGC_T, BIGG_T, ent_lift_BIGC_T_BIGG_T);
1149 #endif
1150 }
1151
1152 void init_optables_BIGG_T(void)
1153 {
1154         ent_gaussian_nullary_optable_init();
1155         ent_gaussian_unary_optable_init();
1156         ent_gaussian_binary_optable_init();
1157         ent_gaussian_unary_reltable_init();
1158         ent_gaussian_binary_reltable_init();
1159         ent_gaussian_lifttable_init();
1160 }
1161
1162 void init_ent_gaussian(void)
1163 {
1164         bigg_init(ent_scratch_bigg);
1165 }
1166
1167 void syms_of_ent_gaussian(void)
1168 {
1169         INIT_LRECORD_IMPLEMENTATION(bigg);
1170
1171         DEFSUBR(Fmake_bigg);
1172 }
1173
1174 void vars_of_ent_gaussian(void)
1175 {
1176         Fprovide(intern("bigg"));
1177         Fprovide(intern("gaussian"));
1178 }