2 ent-mpfr.c -- Numeric types for SXEmacs
3 Copyright (C) 2005, 2006 Sebastian Freundt
5 Author: Sebastian Freundt
7 This file is part of SXEmacs
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.
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.
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/>. */
27 #include "sysproc.h" /* For qxe_getpid */
30 #include "ent-optable.h"
32 #include "ent-indef.h"
37 Lisp_Object Veuler_mascheroni;
40 bigfr ent_scratch_bigfr;
41 static ase_nullary_operation_f Qent_mpfr_zero, Qent_mpfr_one;
45 bigfr_print(Lisp_Object obj, Lisp_Object printcharfun, int SXE_UNUSED(unused))
47 Bufbyte *fstr = bigfr_to_string(XBIGFR_DATA(obj), 10);
48 write_c_string((char*)fstr, printcharfun);
50 fstr = (Bufbyte *)NULL;
55 bigfr_equal (Lisp_Object obj1, Lisp_Object obj2, int unused)
57 return bigfr_eq(XBIGFR_DATA(obj1), XBIGFR_DATA(obj2));
61 bigfr_hash (Lisp_Object obj, int unused)
63 return bigfr_hashcode(XBIGFR_DATA(obj));
67 bigfr_mark (Lisp_Object unused)
73 bigfr_finalise (void *header, int for_disksave)
77 ("Can't dump an emacs containing MPFR objects", Qt);
83 static const struct lrecord_description bigfr_description[] = {
84 { XD_OPAQUE_DATA_PTR, offsetof(Lisp_Bigfr, data) },
88 DEFINE_BASIC_LRECORD_IMPLEMENTATION("bigfr", bigfr,
89 bigfr_mark, bigfr_print, bigfr_finalise,
90 bigfr_equal, bigfr_hash,
91 bigfr_description, Lisp_Bigfr);
94 DEFUN ("bigfr-get-precision", Fbigfr_get_precision, 1, 1, 0, /*
95 Return the precision of bigfr F as an integer.
100 return make_integer((signed long)XBIGFR_GET_PREC(f));
103 #ifndef MPFR_PREC_MIN
104 #define MPFR_PREC_MIN 2UL
107 DEFUN ("bigfr-set-precision", Fbigfr_set_precision, 2, 2, 0, /*
108 Set the precision of F, a bigfr, to PRECISION, a nonnegative integer.
109 The new precision of F is returned. Note that the return value may differ
110 from PRECISION if the underlying library is unable to support exactly
111 PRECISION bits of precision.
118 if (INTP(precision)) {
119 prec = (XINT(precision) <= 0)
120 ? MPFR_PREC_MIN : (unsigned long)XINT(precision);
122 #if defined HAVE_MPZ && (defined WITH_GMP || defined WITH_MP)
123 else if (BIGZP(precision)) {
124 prec = bigz_fits_ulong_p(XBIGZ_DATA(precision))
125 ? bigz_to_ulong(XBIGZ_DATA(precision))
128 #endif /* HAVE_MPZ */
130 dead_wrong_type_argument(Qintegerp, f);
134 XBIGFR_SET_PREC(f, prec);
135 return Fbigfr_get_precision(f);
139 Bufbyte *bigfr_to_string(mpfr_t f, int base)
144 const int sign = mpfr_sgn(f);
145 const int neg = (sign < 0) ? 1 : 0;
149 str = indef_to_string((indef)POS_INFINITY);
151 str = indef_to_string((indef)NEG_INFINITY);
154 } else if (mpfr_nan_p(f)) {
155 str = indef_to_string((indef)NOT_A_NUMBER);
161 str = (Bufbyte *)mpfr_get_str(NULL, &expt, base, 0, f,
163 len = strlen((char *)str) + 1; /* Count the null terminator */
165 /* Move digits down to insert a radix point */
167 /* We need room for a radix point and leading zeroes */
168 const int space = -expt + 2;
169 xrealloc_array(str, Bufbyte, len + space);
170 memmove(&str[space + neg], &str[neg], len - neg);
171 memset(&str[neg], '0', space);
174 } else if (expt < len) {
175 /* We just need room for a radix point */
176 xrealloc_array(str, Bufbyte, len + 1);
177 memmove(&str[expt + neg + 1],
180 str[expt + neg] = '.';
183 /* We need room for trailing zeroes */
184 xrealloc_array(str, Bufbyte, expt + 1);
185 memset(&str[len-1], '0', expt+2-len);
194 Lisp_Object read_bigfr_string(char *cp)
196 /* The mpfr version of bigfr_set_string (mpfr_set_str)
197 has the following limitation: if p starts with a '+'
198 sign, it does nothing; i.e., it leaves its bigfloat
200 Therefore, move p past any leading '+' signs. */
204 bigfr_init_prec(bfr, bigfr_get_default_prec());
209 bigfr_set_string(bfr, (const char*)cp, 0);
210 result = make_bigfr_bfr(bfr);
216 #if defined HAVE_MPC && defined WITH_MPC || \
217 defined HAVE_PSEUC && defined WITH_PSEUC
218 Lisp_Object read_bigc_string(char *cp)
224 BIGFR_INIT_PREC(bf_re, Qnil);
225 BIGFR_INIT_PREC(bf_im, Qnil);
227 /* MPC bigc_set_string has no effect
228 * with initial + sign */
231 bigfr_set_string(bf_re, cp, 0);
234 /* jump over a leading minus */
238 while ((*cp >= '0' && *cp <= '9') ||
242 /* read the imaginary part */
252 if ((*cp == 'i' || *cp == 'I') &&
254 /* expand +i to +1i and -i to -1i */
255 bigfr_set_long(bf_im, 1L);
256 } else if (sign == 0) {
257 /* obviously we did not have a+bi,
260 bigfr_set(bf_im, bf_re);
261 bigfr_set_long(bf_re, 0L);
263 bigfr_set_string(bf_im, cp, 0);
267 bigfr_neg(bf_im, bf_im);
269 result = make_bigc_bfr(bf_re, bf_im,
270 max(bigfr_get_prec(bf_re),
271 bigfr_get_prec(bf_im)));
282 ent_sum_BIGFR_T(Lisp_Object l, Lisp_Object r)
284 bigfr_set_prec(ent_scratch_bigfr,
285 max(XBIGFR_GET_PREC(l), XBIGFR_GET_PREC(r)));
286 bigfr_add(ent_scratch_bigfr, XBIGFR_DATA(l), XBIGFR_DATA(r));
287 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
290 ent_sum_BIGFR_T_INT_T(Lisp_Object l, Lisp_Object r)
292 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(l));
293 bigfr_set_long(ent_scratch_bigfr, ent_int(r));
294 bigfr_add(ent_scratch_bigfr, XBIGFR_DATA(l), ent_scratch_bigfr);
295 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
298 ent_sum_INT_T_BIGFR_T(Lisp_Object l, Lisp_Object r)
300 return ent_sum_BIGFR_T_INT_T(r, l);
302 #if defined HAVE_MPZ && (defined WITH_GMP || defined WITH_MP)
304 ent_sum_BIGFR_T_BIGZ_T(Lisp_Object l, Lisp_Object r)
306 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(l));
307 bigfr_set_bigz(ent_scratch_bigfr, XBIGZ_DATA(r));
308 bigfr_add(ent_scratch_bigfr, XBIGFR_DATA(l), ent_scratch_bigfr);
309 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
312 ent_sum_BIGZ_T_BIGFR_T(Lisp_Object l, Lisp_Object r)
314 return ent_sum_BIGFR_T_BIGZ_T(r, l);
317 #if defined HAVE_MPQ && defined WITH_GMP
319 ent_sum_BIGFR_T_BIGQ_T(Lisp_Object l, Lisp_Object r)
321 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(l));
322 bigfr_set_bigq(ent_scratch_bigfr, XBIGQ_DATA(r));
323 bigfr_add(ent_scratch_bigfr, XBIGFR_DATA(l), ent_scratch_bigfr);
324 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
327 ent_sum_BIGQ_T_BIGFR_T(Lisp_Object l, Lisp_Object r)
329 return ent_sum_BIGFR_T_BIGQ_T(r, l);
332 #if defined HAVE_MPF && defined WITH_GMP
334 ent_sum_BIGFR_T_BIGF_T(Lisp_Object l, Lisp_Object r)
336 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(l));
337 bigfr_set_bigf(ent_scratch_bigfr, XBIGF_DATA(r));
338 bigfr_add(ent_scratch_bigfr, XBIGFR_DATA(l), ent_scratch_bigfr);
339 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
342 ent_sum_BIGF_T_BIGFR_T(Lisp_Object l, Lisp_Object r)
344 return ent_sum_BIGFR_T_BIGF_T(r, l);
349 ent_sum_BIGFR_T_FLOAT_T(Lisp_Object l, Lisp_Object r)
351 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(l));
352 bigfr_set_fpfloat(ent_scratch_bigfr, XFLOAT_DATA(r));
353 bigfr_add(ent_scratch_bigfr, XBIGFR_DATA(l), ent_scratch_bigfr);
354 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
357 ent_sum_FLOAT_T_BIGFR_T(Lisp_Object l, Lisp_Object r)
359 return ent_sum_BIGFR_T_FLOAT_T(r, l);
365 ent_diff_BIGFR_T(Lisp_Object l, Lisp_Object r)
367 bigfr_set_prec(ent_scratch_bigfr,
368 max(XBIGFR_GET_PREC(l), XBIGFR_GET_PREC(r)));
369 bigfr_sub(ent_scratch_bigfr, XBIGFR_DATA(l), XBIGFR_DATA(r));
370 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
373 ent_diff_BIGFR_T_INT_T(Lisp_Object l, Lisp_Object r)
375 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(l));
376 bigfr_set_long(ent_scratch_bigfr, ent_int(r));
377 bigfr_sub(ent_scratch_bigfr, XBIGFR_DATA(l), ent_scratch_bigfr);
378 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
381 ent_diff_INT_T_BIGFR_T(Lisp_Object l, Lisp_Object r)
383 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(r));
384 bigfr_set_long(ent_scratch_bigfr, ent_int(l));
385 bigfr_sub(ent_scratch_bigfr, ent_scratch_bigfr, XBIGFR_DATA(r));
386 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
388 #if defined HAVE_MPZ && (defined WITH_GMP || defined WITH_MP)
390 ent_diff_BIGFR_T_BIGZ_T(Lisp_Object l, Lisp_Object r)
392 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(l));
393 bigfr_set_bigz(ent_scratch_bigfr, XBIGZ_DATA(r));
394 bigfr_sub(ent_scratch_bigfr, XBIGFR_DATA(l), ent_scratch_bigfr);
395 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
398 ent_diff_BIGZ_T_BIGFR_T(Lisp_Object l, Lisp_Object r)
400 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(r));
401 bigfr_set_bigz(ent_scratch_bigfr, XBIGZ_DATA(l));
402 bigfr_sub(ent_scratch_bigfr, ent_scratch_bigfr, XBIGFR_DATA(r));
403 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
406 #if defined HAVE_MPQ && defined WITH_GMP
408 ent_diff_BIGFR_T_BIGQ_T(Lisp_Object l, Lisp_Object r)
410 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(l));
411 bigfr_set_bigq(ent_scratch_bigfr, XBIGQ_DATA(r));
412 bigfr_sub(ent_scratch_bigfr, XBIGFR_DATA(l), ent_scratch_bigfr);
413 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
416 ent_diff_BIGQ_T_BIGFR_T(Lisp_Object l, Lisp_Object r)
418 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(r));
419 bigfr_set_bigq(ent_scratch_bigfr, XBIGQ_DATA(l));
420 bigfr_sub(ent_scratch_bigfr, ent_scratch_bigfr, XBIGFR_DATA(r));
421 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
424 #if defined HAVE_MPF && defined WITH_GMP
426 ent_diff_BIGFR_T_BIGF_T(Lisp_Object l, Lisp_Object r)
428 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(l));
429 bigfr_set_bigf(ent_scratch_bigfr, XBIGF_DATA(r));
430 bigfr_sub(ent_scratch_bigfr, XBIGFR_DATA(l), ent_scratch_bigfr);
431 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
434 ent_diff_BIGF_T_BIGFR_T(Lisp_Object l, Lisp_Object r)
436 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(r));
437 bigfr_set_bigf(ent_scratch_bigfr, XBIGF_DATA(l));
438 bigfr_sub(ent_scratch_bigfr, ent_scratch_bigfr, XBIGFR_DATA(r));
439 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
444 ent_diff_BIGFR_T_FLOAT_T(Lisp_Object l, Lisp_Object r)
446 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(l));
447 bigfr_set_fpfloat(ent_scratch_bigfr, XFLOAT_DATA(r));
448 bigfr_sub(ent_scratch_bigfr, XBIGFR_DATA(l), ent_scratch_bigfr);
449 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
452 ent_diff_FLOAT_T_BIGFR_T(Lisp_Object l, Lisp_Object r)
454 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(r));
455 bigfr_set_fpfloat(ent_scratch_bigfr, XFLOAT_DATA(l));
456 bigfr_sub(ent_scratch_bigfr, ent_scratch_bigfr, XBIGFR_DATA(r));
457 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
462 ent_neg_BIGFR_T(Lisp_Object l)
464 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(l));
465 bigfr_neg(ent_scratch_bigfr, XBIGFR_DATA(l));
466 return make_bigfr_bfr(ent_scratch_bigfr);
470 ent_prod_BIGFR_T(Lisp_Object l, Lisp_Object r)
472 bigfr_set_prec(ent_scratch_bigfr,
473 max(XBIGFR_GET_PREC(l), XBIGFR_GET_PREC(r)));
474 bigfr_mul(ent_scratch_bigfr, XBIGFR_DATA(l), XBIGFR_DATA(r));
475 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
478 ent_prod_BIGFR_T_INT_T(Lisp_Object l, Lisp_Object r)
480 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(l));
481 bigfr_set_long(ent_scratch_bigfr, ent_int(r));
482 bigfr_mul(ent_scratch_bigfr, XBIGFR_DATA(l), ent_scratch_bigfr);
483 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
486 ent_prod_INT_T_BIGFR_T(Lisp_Object l, Lisp_Object r)
488 return ent_prod_BIGFR_T_INT_T(r, l);
490 #if defined HAVE_MPZ && (defined WITH_GMP || defined WITH_MP)
492 ent_prod_BIGFR_T_BIGZ_T(Lisp_Object l, Lisp_Object r)
494 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(l));
495 bigfr_set_bigz(ent_scratch_bigfr, XBIGZ_DATA(r));
496 bigfr_mul(ent_scratch_bigfr, XBIGFR_DATA(l), ent_scratch_bigfr);
497 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
500 ent_prod_BIGZ_T_BIGFR_T(Lisp_Object l, Lisp_Object r)
502 return ent_prod_BIGFR_T_BIGZ_T(r, l);
505 #if defined HAVE_MPQ && defined WITH_GMP
507 ent_prod_BIGFR_T_BIGQ_T(Lisp_Object l, Lisp_Object r)
509 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(l));
510 bigfr_set_bigq(ent_scratch_bigfr, XBIGQ_DATA(r));
511 bigfr_mul(ent_scratch_bigfr, XBIGFR_DATA(l), ent_scratch_bigfr);
512 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
515 ent_prod_BIGQ_T_BIGFR_T(Lisp_Object l, Lisp_Object r)
517 return ent_prod_BIGFR_T_BIGQ_T(r, l);
520 #if defined HAVE_MPF && defined WITH_GMP
522 ent_prod_BIGFR_T_BIGF_T(Lisp_Object l, Lisp_Object r)
524 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(l));
525 bigfr_set_bigf(ent_scratch_bigfr, XBIGF_DATA(r));
526 bigfr_mul(ent_scratch_bigfr, XBIGFR_DATA(l), ent_scratch_bigfr);
527 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
530 ent_prod_BIGF_T_BIGFR_T(Lisp_Object l, Lisp_Object r)
532 return ent_prod_BIGFR_T_BIGF_T(r, l);
537 ent_prod_BIGFR_T_FLOAT_T(Lisp_Object l, Lisp_Object r)
539 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(l));
540 bigfr_set_fpfloat(ent_scratch_bigfr, XFLOAT_DATA(r));
541 bigfr_mul(ent_scratch_bigfr, XBIGFR_DATA(l), ent_scratch_bigfr);
542 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
545 ent_prod_FLOAT_T_BIGFR_T(Lisp_Object l, Lisp_Object r)
547 return ent_prod_BIGFR_T_FLOAT_T(r, l);
552 ent_div_BIGFR_T(Lisp_Object l, Lisp_Object r)
554 if (bigfr_sign(XBIGFR_DATA(r)) == 0) {
555 int lsgn = bigfr_sign(XBIGFR_DATA(l));
557 return make_indef(POS_INFINITY);
559 return make_indef(NEG_INFINITY);
561 return make_indef(NOT_A_NUMBER);
563 bigfr_set_prec(ent_scratch_bigfr,
564 max(XBIGFR_GET_PREC(l), XBIGFR_GET_PREC(r)));
565 bigfr_div(ent_scratch_bigfr, XBIGFR_DATA(l), XBIGFR_DATA(r));
566 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
569 ent_div_BIGFR_T_INT_T(Lisp_Object l, Lisp_Object r)
571 if (ent_int(r) == 0) {
572 int lsgn = bigfr_sign(XBIGFR_DATA(l));
574 return make_indef(POS_INFINITY);
576 return make_indef(NEG_INFINITY);
578 return make_indef(NOT_A_NUMBER);
581 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(l));
582 bigfr_set_long(ent_scratch_bigfr, ent_int(r));
583 bigfr_div(ent_scratch_bigfr, XBIGFR_DATA(l), ent_scratch_bigfr);
584 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
587 ent_div_INT_T_BIGFR_T(Lisp_Object l, Lisp_Object r)
589 if (bigfr_sign(XBIGFR_DATA(r)) == 0) {
590 EMACS_INT rl = ent_int(l);
592 return make_indef(POS_INFINITY);
594 return make_indef(NEG_INFINITY);
596 return make_indef(NOT_A_NUMBER);
599 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(r));
600 bigfr_set_long(ent_scratch_bigfr, ent_int(l));
601 bigfr_div(ent_scratch_bigfr, ent_scratch_bigfr, XBIGFR_DATA(r));
602 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
604 #if defined HAVE_MPZ && (defined WITH_GMP || defined WITH_MP)
606 ent_div_BIGFR_T_BIGZ_T(Lisp_Object l, Lisp_Object r)
608 if (bigz_sign(XBIGZ_DATA(r)) == 0) {
609 int lsgn = bigfr_sign(XBIGFR_DATA(l));
611 return make_indef(POS_INFINITY);
613 return make_indef(NEG_INFINITY);
615 return make_indef(NOT_A_NUMBER);
618 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(l));
619 bigfr_set_bigz(ent_scratch_bigfr, XBIGZ_DATA(r));
620 bigfr_div(ent_scratch_bigfr, XBIGFR_DATA(l), ent_scratch_bigfr);
621 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
624 ent_div_BIGZ_T_BIGFR_T(Lisp_Object l, Lisp_Object r)
626 if (bigfr_sign(XBIGFR_DATA(r)) == 0) {
627 int lsgn = bigz_sign(XBIGZ_DATA(l));
629 return make_indef(POS_INFINITY);
631 return make_indef(NEG_INFINITY);
633 return make_indef(NOT_A_NUMBER);
636 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(r));
637 bigfr_set_bigz(ent_scratch_bigfr, XBIGZ_DATA(l));
638 bigfr_div(ent_scratch_bigfr, ent_scratch_bigfr, XBIGFR_DATA(r));
639 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
642 #if defined HAVE_MPQ && defined WITH_GMP
644 ent_div_BIGFR_T_BIGQ_T(Lisp_Object l, Lisp_Object r)
646 if (bigq_sign(XBIGQ_DATA(r)) == 0) {
647 int lsgn = bigfr_sign(XBIGFR_DATA(l));
649 return make_indef(POS_INFINITY);
651 return make_indef(NEG_INFINITY);
653 return make_indef(NOT_A_NUMBER);
656 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(l));
657 bigfr_set_bigq(ent_scratch_bigfr, XBIGQ_DATA(r));
658 bigfr_div(ent_scratch_bigfr, XBIGFR_DATA(l), ent_scratch_bigfr);
659 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
662 ent_div_BIGQ_T_BIGFR_T(Lisp_Object l, Lisp_Object r)
664 if (bigfr_sign(XBIGFR_DATA(r)) == 0) {
665 int lsgn = bigq_sign(XBIGQ_DATA(l));
667 return make_indef(POS_INFINITY);
669 return make_indef(NEG_INFINITY);
671 return make_indef(NOT_A_NUMBER);
674 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(r));
675 bigfr_set_bigq(ent_scratch_bigfr, XBIGQ_DATA(l));
676 bigfr_div(ent_scratch_bigfr, ent_scratch_bigfr, XBIGFR_DATA(r));
677 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
680 #if defined HAVE_MPF && defined WITH_GMP
682 ent_div_BIGFR_T_BIGF_T(Lisp_Object l, Lisp_Object r)
684 if (bigf_sign(XBIGF_DATA(r)) == 0) {
685 int lsgn = bigfr_sign(XBIGFR_DATA(l));
687 return make_indef(POS_INFINITY);
689 return make_indef(NEG_INFINITY);
691 return make_indef(NOT_A_NUMBER);
694 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(l));
695 bigfr_set_bigf(ent_scratch_bigfr, XBIGF_DATA(r));
696 bigfr_div(ent_scratch_bigfr, XBIGFR_DATA(l), ent_scratch_bigfr);
697 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
700 ent_div_BIGF_T_BIGFR_T(Lisp_Object l, Lisp_Object r)
702 if (bigfr_sign(XBIGFR_DATA(r)) == 0) {
703 int lsgn = bigf_sign(XBIGF_DATA(l));
705 return make_indef(POS_INFINITY);
707 return make_indef(NEG_INFINITY);
709 return make_indef(NOT_A_NUMBER);
712 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(r));
713 bigfr_set_bigf(ent_scratch_bigfr, XBIGF_DATA(l));
714 bigfr_div(ent_scratch_bigfr, ent_scratch_bigfr, XBIGFR_DATA(r));
715 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
720 ent_div_BIGFR_T_FLOAT_T(Lisp_Object l, Lisp_Object r)
722 if (XFLOAT_DATA(r) == 0.0f) {
723 int lsgn = bigfr_sign(XBIGFR_DATA(l));
725 return make_indef(POS_INFINITY);
727 return make_indef(NEG_INFINITY);
729 return make_indef(NOT_A_NUMBER);
732 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(l));
733 bigfr_set_fpfloat(ent_scratch_bigfr, XFLOAT_DATA(r));
734 bigfr_div(ent_scratch_bigfr, XBIGFR_DATA(l), ent_scratch_bigfr);
735 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
738 ent_div_FLOAT_T_BIGFR_T(Lisp_Object l, Lisp_Object r)
740 if (bigfr_sign(XBIGFR_DATA(r)) == 0) {
741 if (XFLOAT_DATA(l) > 0.0f)
742 return make_indef(POS_INFINITY);
743 else if (XFLOAT_DATA(r) < 0.0f)
744 return make_indef(NEG_INFINITY);
746 return make_indef(NOT_A_NUMBER);
749 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(r));
750 bigfr_set_fpfloat(ent_scratch_bigfr, XFLOAT_DATA(l));
751 bigfr_div(ent_scratch_bigfr, ent_scratch_bigfr, XBIGFR_DATA(r));
752 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
757 ent_inv_BIGFR_T(Lisp_Object r)
759 if (bigfr_sign(XBIGFR_DATA(r)) == 0) {
760 return make_indef(POS_INFINITY);
762 bigfr_set_long(ent_scratch_bigfr, 1L);
763 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(r));
764 bigfr_div(ent_scratch_bigfr, ent_scratch_bigfr, XBIGFR_DATA(r));
765 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
768 ent_rem_BIGFR_T(Lisp_Object unused, Lisp_Object r)
770 return Qent_mpfr_zero;
773 ent_mod_BIGFR_T(Lisp_Object l, Lisp_Object r)
775 if (bigfr_sign(XBIGFR_DATA(r)) == 0) {
776 return Qent_mpfr_zero;
778 bigfr_set_prec(ent_scratch_bigfr,
779 max(XBIGFR_GET_PREC(l), XBIGFR_GET_PREC(r)));
780 bigfr_div(ent_scratch_bigfr, XBIGFR_DATA(l), XBIGFR_DATA(r));
781 bigfr_trunc(ent_scratch_bigfr, ent_scratch_bigfr);
782 bigfr_mul(ent_scratch_bigfr, ent_scratch_bigfr, XBIGFR_DATA(r));
783 bigfr_sub(ent_scratch_bigfr, XBIGFR_DATA(l), ent_scratch_bigfr);
784 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
788 ent_pow_BIGFR_T_integer(Lisp_Object l, Lisp_Object r)
792 if (NILP(Fnonnegativep(r))) {
794 ent_pow_BIGFR_T_integer(l, ent_unop_neg(r)));
799 #if defined HAVE_MPZ && (defined WITH_GMP || defined WITH_MP)
800 } else if (BIGZP(r)) {
801 if (bigz_fits_long_p(XBIGZ_DATA(r)))
802 expo = bigz_to_long(XBIGZ_DATA(r));
804 Fsignal(Qarith_error, list1(r));
807 Fsignal(Qarith_error, list1(r));
811 bigfr_set_prec(ent_scratch_bigfr, XBIGFR_GET_PREC(l));
812 bigfr_pow(ent_scratch_bigfr, XBIGFR_DATA(l), expo);
813 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
819 ent_lt_bigfr(Lisp_Object l, Lisp_Object r)
821 return (bigfr_lt(XBIGFR_DATA(l), XBIGFR_DATA(r)));
824 ent_lt_bigfr_int(Lisp_Object l, Lisp_Object r)
826 bigfr_set_long(ent_scratch_bigfr, ent_int(r));
827 return (bigfr_lt(XBIGFR_DATA(l), ent_scratch_bigfr));
830 ent_lt_int_bigfr(Lisp_Object l, Lisp_Object r)
832 bigfr_set_long(ent_scratch_bigfr, ent_int(l));
833 return (bigfr_lt(ent_scratch_bigfr, XBIGFR_DATA(r)));
835 #if defined HAVE_MPZ && (defined WITH_GMP || defined WITH_MP)
837 ent_lt_bigfr_bigz(Lisp_Object l, Lisp_Object r)
839 bigfr_set_bigz(ent_scratch_bigfr, XBIGZ_DATA(r));
840 return (bigfr_lt(XBIGFR_DATA(l), ent_scratch_bigfr));
843 ent_lt_bigz_bigfr(Lisp_Object l, Lisp_Object r)
845 bigfr_set_bigz(ent_scratch_bigfr, XBIGZ_DATA(l));
846 return (bigfr_lt(ent_scratch_bigfr, XBIGFR_DATA(r)));
849 #if defined HAVE_MPQ && defined WITH_GMP
851 ent_lt_bigfr_bigq(Lisp_Object l, Lisp_Object r)
853 bigfr_set_bigq(ent_scratch_bigfr, XBIGQ_DATA(r));
854 return (bigfr_lt(XBIGFR_DATA(l), ent_scratch_bigfr));
857 ent_lt_bigq_bigfr(Lisp_Object l, Lisp_Object r)
859 bigfr_set_bigq(ent_scratch_bigfr, XBIGQ_DATA(l));
860 return (bigfr_lt(ent_scratch_bigfr, XBIGFR_DATA(r)));
863 #if defined HAVE_MPF && defined WITH_GMP
865 ent_lt_bigfr_bigf(Lisp_Object l, Lisp_Object r)
867 bigfr_set_bigf(ent_scratch_bigfr, XBIGF_DATA(r));
868 return (bigfr_lt(XBIGFR_DATA(l), ent_scratch_bigfr));
871 ent_lt_bigf_bigfr(Lisp_Object l, Lisp_Object r)
873 bigfr_set_bigf(ent_scratch_bigfr, XBIGF_DATA(l));
874 return (bigfr_lt(ent_scratch_bigfr, XBIGFR_DATA(r)));
879 ent_lt_bigfr_fpfloat(Lisp_Object l, Lisp_Object r)
881 bigfr_set_fpfloat(ent_scratch_bigfr, XFLOAT_DATA(r));
882 return (bigfr_lt(XBIGFR_DATA(l), ent_scratch_bigfr));
885 ent_lt_fpfloat_bigfr(Lisp_Object l, Lisp_Object r)
887 bigfr_set_fpfloat(ent_scratch_bigfr, XFLOAT_DATA(l));
888 return (bigfr_lt(ent_scratch_bigfr, XBIGFR_DATA(r)));
893 ent_gt_bigfr(Lisp_Object l, Lisp_Object r)
895 return (bigfr_gt(XBIGFR_DATA(l), XBIGFR_DATA(r)));
898 ent_gt_bigfr_int(Lisp_Object l, Lisp_Object r)
900 bigfr_set_long(ent_scratch_bigfr, ent_int(r));
901 return (bigfr_gt(XBIGFR_DATA(l), ent_scratch_bigfr));
904 ent_gt_int_bigfr(Lisp_Object l, Lisp_Object r)
906 bigfr_set_long(ent_scratch_bigfr, ent_int(l));
907 return (bigfr_gt(ent_scratch_bigfr, XBIGFR_DATA(r)));
909 #if defined HAVE_MPZ && (defined WITH_GMP || defined WITH_MP)
911 ent_gt_bigfr_bigz(Lisp_Object l, Lisp_Object r)
913 bigfr_set_bigz(ent_scratch_bigfr, XBIGZ_DATA(r));
914 return (bigfr_gt(XBIGFR_DATA(l), ent_scratch_bigfr));
917 ent_gt_bigz_bigfr(Lisp_Object l, Lisp_Object r)
919 bigfr_set_bigz(ent_scratch_bigfr, XBIGZ_DATA(l));
920 return (bigfr_gt(ent_scratch_bigfr, XBIGFR_DATA(r)));
923 #if defined HAVE_MPQ && defined WITH_GMP
925 ent_gt_bigfr_bigq(Lisp_Object l, Lisp_Object r)
927 bigfr_set_bigq(ent_scratch_bigfr, XBIGQ_DATA(r));
928 return (bigfr_gt(XBIGFR_DATA(l), ent_scratch_bigfr));
931 ent_gt_bigq_bigfr(Lisp_Object l, Lisp_Object r)
933 bigfr_set_bigq(ent_scratch_bigfr, XBIGQ_DATA(l));
934 return (bigfr_gt(ent_scratch_bigfr, XBIGFR_DATA(r)));
937 #if defined HAVE_MPF && defined WITH_GMP
939 ent_gt_bigfr_bigf(Lisp_Object l, Lisp_Object r)
941 bigfr_set_bigf(ent_scratch_bigfr, XBIGF_DATA(r));
942 return (bigfr_gt(XBIGFR_DATA(l), ent_scratch_bigfr));
945 ent_gt_bigf_bigfr(Lisp_Object l, Lisp_Object r)
947 bigfr_set_bigf(ent_scratch_bigfr, XBIGF_DATA(l));
948 return (bigfr_gt(ent_scratch_bigfr, XBIGFR_DATA(r)));
953 ent_gt_bigfr_fpfloat(Lisp_Object l, Lisp_Object r)
955 bigfr_set_fpfloat(ent_scratch_bigfr, XFLOAT_DATA(r));
956 return (bigfr_gt(XBIGFR_DATA(l), ent_scratch_bigfr));
959 ent_gt_fpfloat_bigfr(Lisp_Object l, Lisp_Object r)
961 bigfr_set_fpfloat(ent_scratch_bigfr, XFLOAT_DATA(l));
962 return (bigfr_gt(ent_scratch_bigfr, XBIGFR_DATA(r)));
967 ent_eq_bigfr(Lisp_Object l, Lisp_Object r)
969 return (bigfr_eq(XBIGFR_DATA(l), XBIGFR_DATA(r)));
972 ent_eq_bigfr_int(Lisp_Object l, Lisp_Object r)
974 bigfr_set_long(ent_scratch_bigfr, ent_int(r));
975 return (bigfr_eq(XBIGFR_DATA(l), ent_scratch_bigfr));
978 ent_eq_int_bigfr(Lisp_Object l, Lisp_Object r)
980 bigfr_set_long(ent_scratch_bigfr, ent_int(l));
981 return (bigfr_eq(ent_scratch_bigfr, XBIGFR_DATA(r)));
983 #if defined HAVE_MPZ && (defined WITH_GMP || defined WITH_MP)
985 ent_eq_bigfr_bigz(Lisp_Object l, Lisp_Object r)
987 bigfr_set_bigz(ent_scratch_bigfr, XBIGZ_DATA(r));
988 return (bigfr_eq(XBIGFR_DATA(l), ent_scratch_bigfr));
991 ent_eq_bigz_bigfr(Lisp_Object l, Lisp_Object r)
993 bigfr_set_bigz(ent_scratch_bigfr, XBIGZ_DATA(l));
994 return (bigfr_eq(ent_scratch_bigfr, XBIGFR_DATA(r)));
997 #if defined HAVE_MPQ && defined WITH_GMP
999 ent_eq_bigfr_bigq(Lisp_Object l, Lisp_Object r)
1001 bigfr_set_bigq(ent_scratch_bigfr, XBIGQ_DATA(r));
1002 return (bigfr_eq(XBIGFR_DATA(l), ent_scratch_bigfr));
1005 ent_eq_bigq_bigfr(Lisp_Object l, Lisp_Object r)
1007 bigfr_set_bigq(ent_scratch_bigfr, XBIGQ_DATA(l));
1008 return (bigfr_eq(ent_scratch_bigfr, XBIGFR_DATA(r)));
1011 #if defined HAVE_MPF && defined WITH_GMP
1013 ent_eq_bigfr_bigf(Lisp_Object l, Lisp_Object r)
1015 bigfr_set_bigf(ent_scratch_bigfr, XBIGF_DATA(r));
1016 return (bigfr_eq(XBIGFR_DATA(l), ent_scratch_bigfr));
1019 ent_eq_bigf_bigfr(Lisp_Object l, Lisp_Object r)
1021 bigfr_set_bigf(ent_scratch_bigfr, XBIGF_DATA(l));
1022 return (bigfr_eq(ent_scratch_bigfr, XBIGFR_DATA(r)));
1027 ent_eq_bigfr_fpfloat(Lisp_Object l, Lisp_Object r)
1029 bigfr_set_fpfloat(ent_scratch_bigfr, XFLOAT_DATA(r));
1030 return (bigfr_eq(XBIGFR_DATA(l), ent_scratch_bigfr));
1033 ent_eq_fpfloat_bigfr(Lisp_Object l, Lisp_Object r)
1035 bigfr_set_fpfloat(ent_scratch_bigfr, XFLOAT_DATA(l));
1036 return (bigfr_eq(ent_scratch_bigfr, XBIGFR_DATA(r)));
1041 ent_ne_bigfr(Lisp_Object l, Lisp_Object r)
1043 return !(bigfr_eq(XBIGFR_DATA(l), XBIGFR_DATA(r)));
1046 ent_ne_bigfr_int(Lisp_Object l, Lisp_Object r)
1048 bigfr_set_long(ent_scratch_bigfr, ent_int(r));
1049 return !(bigfr_eq(XBIGFR_DATA(l), ent_scratch_bigfr));
1052 ent_ne_int_bigfr(Lisp_Object l, Lisp_Object r)
1054 bigfr_set_long(ent_scratch_bigfr, ent_int(l));
1055 return !(bigfr_eq(ent_scratch_bigfr, XBIGFR_DATA(r)));
1057 #if defined HAVE_MPZ && (defined WITH_GMP || defined WITH_MP)
1059 ent_ne_bigfr_bigz(Lisp_Object l, Lisp_Object r)
1061 bigfr_set_bigz(ent_scratch_bigfr, XBIGZ_DATA(r));
1062 return !(bigfr_eq(XBIGFR_DATA(l), ent_scratch_bigfr));
1065 ent_ne_bigz_bigfr(Lisp_Object l, Lisp_Object r)
1067 bigfr_set_bigz(ent_scratch_bigfr, XBIGZ_DATA(l));
1068 return !(bigfr_eq(ent_scratch_bigfr, XBIGFR_DATA(r)));
1071 #if defined HAVE_MPQ && defined WITH_GMP
1073 ent_ne_bigfr_bigq(Lisp_Object l, Lisp_Object r)
1075 bigfr_set_bigq(ent_scratch_bigfr, XBIGQ_DATA(r));
1076 return !(bigfr_eq(XBIGFR_DATA(l), ent_scratch_bigfr));
1079 ent_ne_bigq_bigfr(Lisp_Object l, Lisp_Object r)
1081 bigfr_set_bigq(ent_scratch_bigfr, XBIGQ_DATA(l));
1082 return !(bigfr_eq(ent_scratch_bigfr, XBIGFR_DATA(r)));
1085 #if defined HAVE_MPF && defined WITH_GMP
1087 ent_ne_bigfr_bigf(Lisp_Object l, Lisp_Object r)
1089 bigfr_set_bigf(ent_scratch_bigfr, XBIGF_DATA(r));
1090 return !(bigfr_eq(XBIGFR_DATA(l), ent_scratch_bigfr));
1093 ent_ne_bigf_bigfr(Lisp_Object l, Lisp_Object r)
1095 bigfr_set_bigf(ent_scratch_bigfr, XBIGF_DATA(l));
1096 return !(bigfr_eq(ent_scratch_bigfr, XBIGFR_DATA(r)));
1101 ent_ne_bigfr_fpfloat(Lisp_Object l, Lisp_Object r)
1103 bigfr_set_fpfloat(ent_scratch_bigfr, XFLOAT_DATA(r));
1104 return !(bigfr_eq(XBIGFR_DATA(l), ent_scratch_bigfr));
1107 ent_ne_fpfloat_bigfr(Lisp_Object l, Lisp_Object r)
1109 bigfr_set_fpfloat(ent_scratch_bigfr, XFLOAT_DATA(l));
1110 return !(bigfr_eq(ent_scratch_bigfr, XBIGFR_DATA(r)));
1115 static inline Lisp_Object
1116 _ent_lift_INT_T_BIGFR_T(Lisp_Object number, ent_lift_args_t la)
1118 unsigned long precision = la->precision;
1119 return make_bigfr(ent_int(number), precision);
1122 static inline Lisp_Object
1123 _ent_lift_BIGFR_T_INT_T(Lisp_Object number, ent_lift_args_t SXE_UNUSED(la))
1125 return make_int(bigfr_to_long(XBIGFR_DATA(number)));
1128 #if defined HAVE_MPZ && (defined WITH_GMP || defined WITH_MP)
1129 static inline Lisp_Object
1130 _ent_lift_BIGZ_T_BIGFR_T(Lisp_Object number, ent_lift_args_t la)
1132 unsigned long precision = la->precision;
1134 bigfr_set_prec(ent_scratch_bigfr, precision);
1135 bigfr_set_bigz(ent_scratch_bigfr, XBIGZ_DATA(number));
1136 return make_bigfr_bfr(ent_scratch_bigfr);
1139 static inline Lisp_Object
1140 _ent_lift_BIGFR_T_BIGZ_T(Lisp_Object number, ent_lift_args_t SXE_UNUSED(la))
1142 bigz_set_bigfr(ent_scratch_bigz, XBIGFR_DATA(number));
1143 return make_bigz_bz(ent_scratch_bigz);
1145 #endif /* HAVE_MPZ */
1147 #if defined HAVE_MPQ && defined WITH_GMP
1148 static inline Lisp_Object
1149 _ent_lift_BIGQ_T_BIGFR_T(Lisp_Object number, ent_lift_args_t la)
1151 unsigned long precision = la->precision;
1153 bigfr_set_prec(ent_scratch_bigfr, precision);
1154 bigfr_set_bigq(ent_scratch_bigfr, XBIGQ_DATA(number));
1155 return make_bigfr_bfr(ent_scratch_bigfr);
1157 #endif /* HAVE_MPQ */
1159 #if defined HAVE_MPF && defined WITH_GMP
1160 static inline Lisp_Object
1161 _ent_lift_BIGF_T_BIGFR_T(Lisp_Object number, ent_lift_args_t la)
1163 unsigned long precision = la->precision;
1165 bigfr_set_prec(ent_scratch_bigfr, precision);
1166 bigfr_set_bigf(ent_scratch_bigfr, XBIGF_DATA(number));
1167 return make_bigfr_bfr(ent_scratch_bigfr);
1170 static inline Lisp_Object
1171 _ent_lift_BIGFR_T_BIGF_T(Lisp_Object number, ent_lift_args_t la)
1173 unsigned long precision = la->precision;
1175 bigf_set_prec(ent_scratch_bigf, precision);
1176 bigf_set_bigfr(ent_scratch_bigf, XBIGFR_DATA(number));
1177 return make_bigf_bf(ent_scratch_bigf);
1179 #endif /* HAVE_MPF */
1182 static inline Lisp_Object
1183 _ent_lift_FLOAT_T_BIGFR_T(Lisp_Object number, ent_lift_args_t la)
1185 unsigned long precision = la->precision;
1187 bigfr_set_prec(ent_scratch_bigfr, precision);
1188 bigfr_set_fpfloat(ent_scratch_bigfr, XFLOAT_DATA(number));
1189 return make_bigfr_bfr(ent_scratch_bigfr);
1192 static inline Lisp_Object
1193 _ent_lift_BIGFR_T_FLOAT_T(Lisp_Object number, ent_lift_args_t SXE_UNUSED(la))
1195 return make_float(bigfr_to_fpfloat(XBIGFR_DATA(number)));
1199 static inline Lisp_Object
1200 _ent_lift_BIGFR_T_BIGFR_T(Lisp_Object number, ent_lift_args_t la)
1202 unsigned long precision = la->precision;
1204 bigfr_set_prec(ent_scratch_bigfr, precision);
1205 bigfr_set(ent_scratch_bigfr, XBIGFR_DATA(number));
1206 return ent_mpfr_wipe_indef(ent_scratch_bigfr);
1210 ent_mpfr_zerop(Lisp_Object l)
1212 return (bigfr_sign(XBIGFR_DATA(l)) == 0);
1216 ent_mpfr_onep(Lisp_Object l)
1218 return (bigfr_to_fpfloat(XBIGFR_DATA(l)) == 1.0f);
1222 ent_mpfr_unitp(Lisp_Object unused)
1229 ent_mpfr_nullary_optable_init(void)
1231 Qent_mpfr_zero = make_bigfr(0.0f, internal_get_precision(Qnil));
1232 Qent_mpfr_one = make_bigfr(1.0f, internal_get_precision(Qnil));
1233 staticpro(&Qent_mpfr_zero);
1234 staticpro(&Qent_mpfr_one);
1236 ent_nullop_register(ASE_NULLARY_OP_ZERO, BIGFR_T, Qent_mpfr_zero);
1237 ent_nullop_register(ASE_NULLARY_OP_ONE, BIGFR_T, Qent_mpfr_one);
1241 ent_mpfr_unary_optable_init(void)
1243 ent_unop_register(ASE_UNARY_OP_NEG, BIGFR_T, ent_neg_BIGFR_T);
1244 ent_unop_register(ASE_UNARY_OP_INV, BIGFR_T, ent_inv_BIGFR_T);
1248 ent_mpfr_binary_optable_init(void)
1251 ent_binop_register(ASE_BINARY_OP_SUM,
1252 BIGFR_T, BIGFR_T, ent_sum_BIGFR_T);
1253 ent_binop_register(ASE_BINARY_OP_SUM,
1254 BIGFR_T, INT_T, ent_sum_BIGFR_T_INT_T);
1255 ent_binop_register(ASE_BINARY_OP_SUM,
1256 INT_T, BIGFR_T, ent_sum_INT_T_BIGFR_T);
1257 #if defined HAVE_MPZ && (defined WITH_GMP || defined WITH_MP)
1258 ent_binop_register(ASE_BINARY_OP_SUM,
1259 BIGFR_T, BIGZ_T, ent_sum_BIGFR_T_BIGZ_T);
1260 ent_binop_register(ASE_BINARY_OP_SUM,
1261 BIGZ_T, BIGFR_T, ent_sum_BIGZ_T_BIGFR_T);
1263 #if defined HAVE_MPQ && defined WITH_GMP
1264 ent_binop_register(ASE_BINARY_OP_SUM,
1265 BIGFR_T, BIGQ_T, ent_sum_BIGFR_T_BIGQ_T);
1266 ent_binop_register(ASE_BINARY_OP_SUM,
1267 BIGQ_T, BIGFR_T, ent_sum_BIGQ_T_BIGFR_T);
1269 #if defined HAVE_MPF && defined WITH_GMP
1270 ent_binop_register(ASE_BINARY_OP_SUM,
1271 BIGFR_T, BIGF_T, ent_sum_BIGFR_T_BIGF_T);
1272 ent_binop_register(ASE_BINARY_OP_SUM,
1273 BIGF_T, BIGFR_T, ent_sum_BIGF_T_BIGFR_T);
1276 ent_binop_register(ASE_BINARY_OP_SUM,
1277 FLOAT_T, BIGFR_T, ent_sum_FLOAT_T_BIGFR_T);
1278 ent_binop_register(ASE_BINARY_OP_SUM,
1279 BIGFR_T, FLOAT_T, ent_sum_BIGFR_T_FLOAT_T);
1282 ent_binop_register(ASE_BINARY_OP_DIFF,
1283 BIGFR_T, BIGFR_T, ent_diff_BIGFR_T);
1284 ent_binop_register(ASE_BINARY_OP_DIFF,
1285 BIGFR_T, INT_T, ent_diff_BIGFR_T_INT_T);
1286 ent_binop_register(ASE_BINARY_OP_DIFF,
1287 INT_T, BIGFR_T, ent_diff_INT_T_BIGFR_T);
1288 #if defined HAVE_MPZ && (defined WITH_GMP || defined WITH_MP)
1289 ent_binop_register(ASE_BINARY_OP_DIFF,
1290 BIGFR_T, BIGZ_T, ent_diff_BIGFR_T_BIGZ_T);
1291 ent_binop_register(ASE_BINARY_OP_DIFF,
1292 BIGZ_T, BIGFR_T, ent_diff_BIGZ_T_BIGFR_T);
1294 #if defined HAVE_MPQ && defined WITH_GMP
1295 ent_binop_register(ASE_BINARY_OP_DIFF,
1296 BIGFR_T, BIGQ_T, ent_diff_BIGFR_T_BIGQ_T);
1297 ent_binop_register(ASE_BINARY_OP_DIFF,
1298 BIGQ_T, BIGFR_T, ent_diff_BIGQ_T_BIGFR_T);
1300 #if defined HAVE_MPF && defined WITH_GMP
1301 ent_binop_register(ASE_BINARY_OP_DIFF,
1302 BIGFR_T, BIGF_T, ent_diff_BIGFR_T_BIGF_T);
1303 ent_binop_register(ASE_BINARY_OP_DIFF,
1304 BIGF_T, BIGFR_T, ent_diff_BIGF_T_BIGFR_T);
1307 ent_binop_register(ASE_BINARY_OP_DIFF,
1308 FLOAT_T, BIGFR_T, ent_diff_FLOAT_T_BIGFR_T);
1309 ent_binop_register(ASE_BINARY_OP_DIFF,
1310 BIGFR_T, FLOAT_T, ent_diff_BIGFR_T_FLOAT_T);
1314 ent_binop_register(ASE_BINARY_OP_PROD,
1315 BIGFR_T, BIGFR_T, ent_prod_BIGFR_T);
1316 ent_binop_register(ASE_BINARY_OP_PROD,
1317 BIGFR_T, INT_T, ent_prod_BIGFR_T_INT_T);
1318 ent_binop_register(ASE_BINARY_OP_PROD,
1319 INT_T, BIGFR_T, ent_prod_INT_T_BIGFR_T);
1320 #if defined HAVE_MPZ && (defined WITH_GMP || defined WITH_MP)
1321 ent_binop_register(ASE_BINARY_OP_PROD,
1322 BIGFR_T, BIGZ_T, ent_prod_BIGFR_T_BIGZ_T);
1323 ent_binop_register(ASE_BINARY_OP_PROD,
1324 BIGZ_T, BIGFR_T, ent_prod_BIGZ_T_BIGFR_T);
1326 #if defined HAVE_MPQ && defined WITH_GMP
1327 ent_binop_register(ASE_BINARY_OP_PROD,
1328 BIGFR_T, BIGQ_T, ent_prod_BIGFR_T_BIGQ_T);
1329 ent_binop_register(ASE_BINARY_OP_PROD,
1330 BIGQ_T, BIGFR_T, ent_prod_BIGQ_T_BIGFR_T);
1332 #if defined HAVE_MPF && defined WITH_GMP
1333 ent_binop_register(ASE_BINARY_OP_PROD,
1334 BIGFR_T, BIGF_T, ent_prod_BIGFR_T_BIGF_T);
1335 ent_binop_register(ASE_BINARY_OP_PROD,
1336 BIGF_T, BIGFR_T, ent_prod_BIGF_T_BIGFR_T);
1339 ent_binop_register(ASE_BINARY_OP_PROD,
1340 FLOAT_T, BIGFR_T, ent_prod_FLOAT_T_BIGFR_T);
1341 ent_binop_register(ASE_BINARY_OP_PROD,
1342 BIGFR_T, FLOAT_T, ent_prod_BIGFR_T_FLOAT_T);
1345 ent_binop_register(ASE_BINARY_OP_DIV,
1346 BIGFR_T, BIGFR_T, ent_div_BIGFR_T);
1347 ent_binop_register(ASE_BINARY_OP_DIV,
1348 BIGFR_T, INT_T, ent_div_BIGFR_T_INT_T);
1349 ent_binop_register(ASE_BINARY_OP_DIV,
1350 INT_T, BIGFR_T, ent_div_INT_T_BIGFR_T);
1351 #if defined HAVE_MPZ && (defined WITH_GMP || defined WITH_MP)
1352 ent_binop_register(ASE_BINARY_OP_DIV,
1353 BIGFR_T, BIGZ_T, ent_div_BIGFR_T_BIGZ_T);
1354 ent_binop_register(ASE_BINARY_OP_DIV,
1355 BIGZ_T, BIGFR_T, ent_div_BIGZ_T_BIGFR_T);
1357 #if defined HAVE_MPQ && defined WITH_GMP
1358 ent_binop_register(ASE_BINARY_OP_DIV,
1359 BIGFR_T, BIGQ_T, ent_div_BIGFR_T_BIGQ_T);
1360 ent_binop_register(ASE_BINARY_OP_DIV,
1361 BIGQ_T, BIGFR_T, ent_div_BIGQ_T_BIGFR_T);
1363 #if defined HAVE_MPF && defined WITH_GMP
1364 ent_binop_register(ASE_BINARY_OP_DIV,
1365 BIGFR_T, BIGF_T, ent_div_BIGFR_T_BIGF_T);
1366 ent_binop_register(ASE_BINARY_OP_DIV,
1367 BIGF_T, BIGFR_T, ent_div_BIGF_T_BIGFR_T);
1370 ent_binop_register(ASE_BINARY_OP_DIV,
1371 FLOAT_T, BIGFR_T, ent_div_FLOAT_T_BIGFR_T);
1372 ent_binop_register(ASE_BINARY_OP_DIV,
1373 BIGFR_T, FLOAT_T, ent_div_BIGFR_T_FLOAT_T);
1376 ent_binop_register(ASE_BINARY_OP_QUO,
1377 BIGFR_T, BIGFR_T, ent_div_BIGFR_T);
1378 ent_binop_register(ASE_BINARY_OP_QUO,
1379 BIGFR_T, INT_T, ent_div_BIGFR_T_INT_T);
1380 ent_binop_register(ASE_BINARY_OP_QUO,
1381 INT_T, BIGFR_T, ent_div_INT_T_BIGFR_T);
1382 #if defined HAVE_MPZ && (defined WITH_GMP || defined WITH_MP)
1383 ent_binop_register(ASE_BINARY_OP_QUO,
1384 BIGFR_T, BIGZ_T, ent_div_BIGFR_T_BIGZ_T);
1385 ent_binop_register(ASE_BINARY_OP_QUO,
1386 BIGZ_T, BIGFR_T, ent_div_BIGZ_T_BIGFR_T);
1388 #if defined HAVE_MPQ && defined WITH_GMP
1389 ent_binop_register(ASE_BINARY_OP_QUO,
1390 BIGFR_T, BIGQ_T, ent_div_BIGFR_T_BIGQ_T);
1391 ent_binop_register(ASE_BINARY_OP_QUO,
1392 BIGQ_T, BIGFR_T, ent_div_BIGQ_T_BIGFR_T);
1394 #if defined HAVE_MPF && defined WITH_GMP
1395 ent_binop_register(ASE_BINARY_OP_QUO,
1396 BIGFR_T, BIGF_T, ent_div_BIGFR_T_BIGF_T);
1397 ent_binop_register(ASE_BINARY_OP_QUO,
1398 BIGF_T, BIGFR_T, ent_div_BIGF_T_BIGFR_T);
1401 ent_binop_register(ASE_BINARY_OP_QUO,
1402 FLOAT_T, BIGFR_T, ent_div_FLOAT_T_BIGFR_T);
1403 ent_binop_register(ASE_BINARY_OP_QUO,
1404 BIGFR_T, FLOAT_T, ent_div_BIGFR_T_FLOAT_T);
1408 ent_binop_register(ASE_BINARY_OP_MOD,
1409 BIGFR_T, BIGFR_T, ent_mod_BIGFR_T);
1410 ent_binop_register(ASE_BINARY_OP_REM,
1411 BIGFR_T, BIGFR_T, ent_rem_BIGFR_T);
1412 ent_binop_register(ASE_BINARY_OP_REM,
1413 INT_T, BIGFR_T, ent_rem_BIGFR_T);
1414 ent_binop_register(ASE_BINARY_OP_REM,
1415 INDEF_T, BIGFR_T, ent_rem_BIGFR_T);
1416 #if defined HAVE_MPZ && (defined WITH_GMP || defined WITH_MP)
1417 ent_binop_register(ASE_BINARY_OP_REM,
1418 BIGZ_T, BIGFR_T, ent_rem_BIGFR_T);
1420 #if defined HAVE_MPQ && defined WITH_GMP
1421 ent_binop_register(ASE_BINARY_OP_REM,
1422 BIGQ_T, BIGFR_T, ent_rem_BIGFR_T);
1424 #if defined HAVE_MPF && defined WITH_GMP
1425 ent_binop_register(ASE_BINARY_OP_REM,
1426 BIGF_T, BIGFR_T, ent_rem_BIGFR_T);
1429 ent_binop_register(ASE_BINARY_OP_REM,
1430 FLOAT_T, BIGFR_T, ent_rem_BIGFR_T);
1434 ent_binop_register(ASE_BINARY_OP_POW,
1435 BIGFR_T, INT_T, ent_pow_BIGFR_T_integer);
1436 #if defined HAVE_MPZ && (defined WITH_GMP || defined WITH_MP)
1437 ent_binop_register(ASE_BINARY_OP_POW,
1438 BIGFR_T, BIGZ_T, ent_pow_BIGFR_T_integer);
1444 ent_mpfr_unary_reltable_init(void)
1446 ent_unrel_register(ASE_UNARY_REL_ZEROP, BIGFR_T, ent_mpfr_zerop);
1447 ent_unrel_register(ASE_UNARY_REL_ONEP, BIGFR_T, ent_mpfr_onep);
1448 ent_unrel_register(ASE_UNARY_REL_UNITP, BIGFR_T, ent_mpfr_unitp);
1452 ent_mpfr_binary_reltable_init(void)
1454 ent_binrel_register(ASE_BINARY_REL_LESSP,
1455 BIGFR_T, BIGFR_T, ent_lt_bigfr);
1456 ent_binrel_register(ASE_BINARY_REL_GREATERP,
1457 BIGFR_T, BIGFR_T, ent_gt_bigfr);
1458 ent_binrel_register(ASE_BINARY_REL_EQUALP,
1459 BIGFR_T, BIGFR_T, ent_eq_bigfr);
1460 ent_binrel_register(ASE_BINARY_REL_NEQP,
1461 BIGFR_T, BIGFR_T, ent_ne_bigfr);
1463 ent_binrel_register(ASE_BINARY_REL_LESSP,
1464 BIGFR_T, INT_T, ent_lt_bigfr_int);
1465 ent_binrel_register(ASE_BINARY_REL_GREATERP,
1466 BIGFR_T, INT_T, ent_gt_bigfr_int);
1467 ent_binrel_register(ASE_BINARY_REL_EQUALP,
1468 BIGFR_T, INT_T, ent_eq_bigfr_int);
1469 ent_binrel_register(ASE_BINARY_REL_NEQP,
1470 BIGFR_T, INT_T, ent_ne_bigfr_int);
1472 ent_binrel_register(ASE_BINARY_REL_LESSP,
1473 INT_T, BIGFR_T, ent_lt_int_bigfr);
1474 ent_binrel_register(ASE_BINARY_REL_GREATERP,
1475 INT_T, BIGFR_T, ent_gt_int_bigfr);
1476 ent_binrel_register(ASE_BINARY_REL_EQUALP,
1477 INT_T, BIGFR_T, ent_eq_int_bigfr);
1478 ent_binrel_register(ASE_BINARY_REL_NEQP,
1479 INT_T, BIGFR_T, ent_ne_int_bigfr);
1481 #if defined HAVE_MPZ && (defined WITH_GMP || defined WITH_MP)
1482 ent_binrel_register(ASE_BINARY_REL_LESSP,
1483 BIGFR_T, BIGZ_T, ent_lt_bigfr_bigz);
1484 ent_binrel_register(ASE_BINARY_REL_GREATERP,
1485 BIGFR_T, BIGZ_T, ent_gt_bigfr_bigz);
1486 ent_binrel_register(ASE_BINARY_REL_EQUALP,
1487 BIGFR_T, BIGZ_T, ent_eq_bigfr_bigz);
1488 ent_binrel_register(ASE_BINARY_REL_NEQP,
1489 BIGFR_T, BIGZ_T, ent_ne_bigfr_bigz);
1491 ent_binrel_register(ASE_BINARY_REL_LESSP,
1492 BIGZ_T, BIGFR_T, ent_lt_bigz_bigfr);
1493 ent_binrel_register(ASE_BINARY_REL_GREATERP,
1494 BIGZ_T, BIGFR_T, ent_gt_bigz_bigfr);
1495 ent_binrel_register(ASE_BINARY_REL_EQUALP,
1496 BIGZ_T, BIGFR_T, ent_eq_bigz_bigfr);
1497 ent_binrel_register(ASE_BINARY_REL_NEQP,
1498 BIGZ_T, BIGFR_T, ent_ne_bigz_bigfr);
1500 #if defined HAVE_MPQ && defined WITH_GMP
1501 ent_binrel_register(ASE_BINARY_REL_LESSP,
1502 BIGFR_T, BIGQ_T, ent_lt_bigfr_bigq);
1503 ent_binrel_register(ASE_BINARY_REL_GREATERP,
1504 BIGFR_T, BIGQ_T, ent_gt_bigfr_bigq);
1505 ent_binrel_register(ASE_BINARY_REL_EQUALP,
1506 BIGFR_T, BIGQ_T, ent_eq_bigfr_bigq);
1507 ent_binrel_register(ASE_BINARY_REL_NEQP,
1508 BIGFR_T, BIGQ_T, ent_ne_bigfr_bigq);
1510 ent_binrel_register(ASE_BINARY_REL_LESSP,
1511 BIGQ_T, BIGFR_T, ent_lt_bigq_bigfr);
1512 ent_binrel_register(ASE_BINARY_REL_GREATERP,
1513 BIGQ_T, BIGFR_T, ent_gt_bigq_bigfr);
1514 ent_binrel_register(ASE_BINARY_REL_EQUALP,
1515 BIGQ_T, BIGFR_T, ent_eq_bigq_bigfr);
1516 ent_binrel_register(ASE_BINARY_REL_NEQP,
1517 BIGQ_T, BIGFR_T, ent_ne_bigq_bigfr);
1519 #if defined HAVE_MPF && defined WITH_GMP
1520 ent_binrel_register(ASE_BINARY_REL_LESSP,
1521 BIGFR_T, BIGF_T, ent_lt_bigfr_bigf);
1522 ent_binrel_register(ASE_BINARY_REL_GREATERP,
1523 BIGFR_T, BIGF_T, ent_gt_bigfr_bigf);
1524 ent_binrel_register(ASE_BINARY_REL_EQUALP,
1525 BIGFR_T, BIGF_T, ent_eq_bigfr_bigf);
1526 ent_binrel_register(ASE_BINARY_REL_NEQP,
1527 BIGFR_T, BIGF_T, ent_ne_bigfr_bigf);
1529 ent_binrel_register(ASE_BINARY_REL_LESSP,
1530 BIGF_T, BIGFR_T, ent_lt_bigf_bigfr);
1531 ent_binrel_register(ASE_BINARY_REL_GREATERP,
1532 BIGF_T, BIGFR_T, ent_gt_bigf_bigfr);
1533 ent_binrel_register(ASE_BINARY_REL_EQUALP,
1534 BIGF_T, BIGFR_T, ent_eq_bigf_bigfr);
1535 ent_binrel_register(ASE_BINARY_REL_NEQP,
1536 BIGF_T, BIGFR_T, ent_ne_bigf_bigfr);
1539 ent_binrel_register(ASE_BINARY_REL_LESSP,
1540 BIGFR_T, FLOAT_T, ent_lt_bigfr_fpfloat);
1541 ent_binrel_register(ASE_BINARY_REL_GREATERP,
1542 BIGFR_T, FLOAT_T, ent_gt_bigfr_fpfloat);
1543 ent_binrel_register(ASE_BINARY_REL_EQUALP,
1544 BIGFR_T, FLOAT_T, ent_eq_bigfr_fpfloat);
1545 ent_binrel_register(ASE_BINARY_REL_NEQP,
1546 BIGFR_T, FLOAT_T, ent_ne_bigfr_fpfloat);
1548 ent_binrel_register(ASE_BINARY_REL_LESSP,
1549 FLOAT_T, BIGFR_T, ent_lt_fpfloat_bigfr);
1550 ent_binrel_register(ASE_BINARY_REL_GREATERP,
1551 FLOAT_T, BIGFR_T, ent_gt_fpfloat_bigfr);
1552 ent_binrel_register(ASE_BINARY_REL_EQUALP,
1553 FLOAT_T, BIGFR_T, ent_eq_fpfloat_bigfr);
1554 ent_binrel_register(ASE_BINARY_REL_NEQP,
1555 FLOAT_T, BIGFR_T, ent_ne_fpfloat_bigfr);
1560 ent_mpfr_lifttable_init(void)
1562 ent_lift_register(BIGFR_T, BIGFR_T, _ent_lift_BIGFR_T_BIGFR_T);
1563 ent_lift_register(BIGFR_T, INT_T, _ent_lift_BIGFR_T_INT_T);
1564 ent_lift_register(INT_T, BIGFR_T, _ent_lift_INT_T_BIGFR_T);
1565 #if defined HAVE_MPZ && (defined WITH_GMP || defined WITH_MP)
1566 ent_lift_register(BIGFR_T, BIGZ_T, _ent_lift_BIGFR_T_BIGZ_T);
1567 ent_lift_register(BIGZ_T, BIGFR_T, _ent_lift_BIGZ_T_BIGFR_T);
1569 #if defined HAVE_MPQ && defined WITH_GMP
1570 ent_lift_register(BIGQ_T, BIGFR_T, _ent_lift_BIGQ_T_BIGFR_T);
1572 #if defined HAVE_MPF && defined WITH_GMP
1573 ent_lift_register(BIGFR_T, BIGF_T, _ent_lift_BIGFR_T_BIGF_T);
1574 ent_lift_register(BIGF_T, BIGFR_T, _ent_lift_BIGF_T_BIGFR_T);
1577 ent_lift_register(BIGFR_T, FLOAT_T, _ent_lift_BIGFR_T_FLOAT_T);
1578 ent_lift_register(FLOAT_T, BIGFR_T, _ent_lift_FLOAT_T_BIGFR_T);
1580 ent_lift_register(INDEF_T, BIGFR_T, ent_lift_INDEF_T_COMPARABLE);
1584 void init_optables_BIGFR_T(void)
1586 ent_mpfr_nullary_optable_init();
1587 ent_mpfr_unary_optable_init();
1588 ent_mpfr_binary_optable_init();
1589 ent_mpfr_unary_reltable_init();
1590 ent_mpfr_binary_reltable_init();
1591 ent_mpfr_lifttable_init();
1594 void init_ent_mpfr(void)
1596 bigfr_init(ent_scratch_bigfr);
1598 Veuler = make_bigfr(0.0, 2048UL);
1599 bigfr_set_long(ent_scratch_bigfr, 1L);
1600 mpfr_exp(XBIGFR_DATA(Veuler), ent_scratch_bigfr, GMP_RNDN);
1602 Veuler_mascheroni = make_bigfr(0.0, 2048UL);
1603 mpfr_const_euler(XBIGFR_DATA(Veuler_mascheroni), GMP_RNDN);
1605 Vpi = make_bigfr(0.0, 2048UL);
1606 mpfr_const_pi(XBIGFR_DATA(Vpi), GMP_RNDN);
1609 void syms_of_ent_mpfr(void)
1611 INIT_LRECORD_IMPLEMENTATION(bigfr);
1613 DEFSUBR(Fbigfr_get_precision);
1614 DEFSUBR(Fbigfr_set_precision);
1616 bigfr_set_default_prec(128UL);
1619 void vars_of_ent_mpfr(void)
1621 /* define pi and e */
1623 /* just some dummy values atm, to make the dumper smile */
1624 Veuler = make_int(1L);
1625 Veuler_mascheroni = make_int(1L);
1628 DEFVAR_CONST_LISP("euler", &Veuler /*
1629 The value of Euler's constant e (2.7182818...).
1631 DEFVAR_CONST_LISP("euler-mascheroni", &Veuler_mascheroni /*
1632 The value of the Euler-Mascheroni constant (0.5772156...).
1634 DEFVAR_CONST_LISP("pi", &Vpi /*
1635 The value of pi (3.1415926...).
1638 Fprovide(intern("bigfr"));