2 ent-gmp.c -- Numeric types for SXEmacs
3 Copyright (C) 2004 Jerry James
4 Copyright (C) 2004, 2005, 2006 Sebastian Freundt
7 Backport: Sebastian Freundt
9 This file is part of SXEmacs
11 SXEmacs is free software: you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation, either version 3 of the License, or
14 (at your option) any later version.
16 SXEmacs is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
29 #include "sysproc.h" /* For qxe_getpid */
33 static mpf_t float_print_min, float_print_max;
34 gmp_randstate_t random_state;
36 bigz ent_scratch_bigz;
37 bigq ent_scratch_bigq;
38 bigf ent_scratch_bigf;
40 static ase_nullary_operation_f Qent_mpz_zero, Qent_mpz_one;
41 static ase_nullary_operation_f Qent_mpq_zero, Qent_mpq_one;
42 static ase_nullary_operation_f Qent_mpf_zero, Qent_mpf_one;
45 #define yrealloc_array(ptr, type, len) \
46 ((void)(ptr = (type*)yrealloc(ptr, (len) * sizeof(type))))
50 /************************* Big Rational Integers ****************************/
52 bigz_print (Lisp_Object obj, Lisp_Object printcharfun, int SXE_UNUSED(escapeflag))
56 bstr = (Bufbyte*)bigz_to_string(XBIGZ_DATA(obj), 10);
57 write_c_string((char*)bstr, printcharfun);
59 bstr = (Bufbyte *)NULL;
63 bigz_equal (Lisp_Object obj1, Lisp_Object obj2, int SXE_UNUSED(depth))
65 return bigz_eql(XBIGZ_DATA(obj1), XBIGZ_DATA(obj2));
69 bigz_hash (Lisp_Object obj, int SXE_UNUSED(depth))
71 return (unsigned long)bigz_hashcode(XBIGZ_DATA(obj));
74 static const struct lrecord_description bigz_description[] = {
75 { XD_OPAQUE_DATA_PTR, offsetof(Lisp_Bigz, data) },
79 DEFINE_BASIC_LRECORD_IMPLEMENTATION("bigz", bigz,
80 NULL, bigz_print, NULL,
81 bigz_equal, bigz_hash,
82 bigz_description, Lisp_Bigz);
85 /************************** Rational Integer Fractions **********************/
87 bigq_print (Lisp_Object obj, Lisp_Object printcharfun, int SXE_UNUSED(escapeflag))
91 rstr = (Bufbyte*)bigq_to_string(XBIGQ_DATA(obj), 10);
92 write_c_string((char *)rstr, printcharfun);
94 rstr = (Bufbyte *)NULL;
99 bigq_equal (Lisp_Object obj1, Lisp_Object obj2, int SXE_UNUSED(depth))
101 return bigq_eql(XBIGQ_DATA(obj1), XBIGQ_DATA(obj2));
105 bigq_hash (Lisp_Object obj, int SXE_UNUSED(depth))
107 return bigq_hashcode(XBIGQ_DATA(obj));
110 static const struct lrecord_description bigq_description[] = {
111 { XD_OPAQUE_DATA_PTR, offsetof (Lisp_Bigq, data) },
115 DEFINE_BASIC_LRECORD_IMPLEMENTATION("bigq", bigq,
116 NULL, bigq_print, NULL,
117 bigq_equal, bigq_hash,
118 bigq_description, Lisp_Bigq);
121 /********************************** Bigfs ***********************************/
123 bigf_print(Lisp_Object obj, Lisp_Object printcharfun, int SXE_UNUSED(escapeflag))
125 Bufbyte *fstr = bigf_to_string(XBIGF_DATA(obj), 10);
126 write_c_string((char*)fstr, printcharfun);
128 fstr = (Bufbyte *)NULL;
133 bigf_equal(Lisp_Object obj1, Lisp_Object obj2, int SXE_UNUSED(depth))
135 return bigf_eq(XBIGF_DATA(obj1), XBIGF_DATA(obj2));
139 bigf_hash(Lisp_Object obj, int SXE_UNUSED(depth))
141 return bigf_hashcode(XBIGF_DATA(obj));
144 static const struct lrecord_description bigf_description[] = {
145 { XD_OPAQUE_DATA_PTR, offsetof(Lisp_Bigf, data) },
149 DEFINE_BASIC_LRECORD_IMPLEMENTATION("bigf", bigf,
150 NULL, bigf_print, NULL,
151 bigf_equal, bigf_hash,
152 bigf_description, Lisp_Bigf);
154 DEFUN("bigf-get-precision", Fbigf_get_precision, 1, 1, 0, /*
155 Return the precision of bigf F as an integer.
160 return make_integer((signed long)XBIGF_GET_PREC(f));
163 DEFUN("bigf-set-precision", Fbigf_set_precision, 2, 2, 0, /*
164 Set the precision of F, a bigf, to PRECISION, a nonnegative integer.
165 The new precision of F is returned. Note that the return value may differ
166 from PRECISION if the underlying library is unable to support exactly
167 PRECISION bits of precision.
174 if (INTP(precision)) {
175 prec = (XINT(precision) <= 0)
176 ? 1UL : (unsigned long)XINT(precision);
179 else if (BIGZP(precision)) {
180 prec = bigz_fits_ulong_p(XBIGZ_DATA(precision))
181 ? bigz_to_ulong(XBIGZ_DATA(precision))
184 #endif /* HAVE_MPZ */
186 dead_wrong_type_argument(Qintegerp, f);
190 XBIGF_SET_PREC(f, prec);
191 return Fbigf_get_precision(f);
197 bigf_to_string(mpf_t f, int base)
200 Bufbyte *str = (Bufbyte*)mpf_get_str(NULL, &expt, base, 0, f);
201 const int sign = mpf_sgn(f);
202 const int neg = (sign < 0) ? 1 : 0;
203 int len = strlen((char *)str) + 1; /* Count the null terminator */
205 /* Move digits down to insert a radix point */
207 /* We need room for a radix point and leading zeroes */
208 const int space = -expt + 2;
209 xrealloc_array(str, Bufbyte, len + space);
210 memmove(&str[space + neg], &str[neg], len - neg);
211 memset(&str[neg], '0', space);
214 } else if (expt < len) {
215 /* We just need room for a radix point */
216 xrealloc_array(str, Bufbyte, len + 1);
217 memmove(&str[expt + neg + 1],
220 str[expt + neg] = '.';
223 /* We need room for trailing zeroes */
224 xrealloc_array(str, Bufbyte, expt + 1);
225 memset(&str[len-1], '0', expt+2-len);
236 read_bigz_string(const char *cp, int base)
243 /* MPZ bigz_set_string has no effect
244 * with initial + sign */
249 bigz_set_string(bz, (const char*)cp, base);
250 result = make_bigz_bz(bz);
257 Lisp_Object read_bigq_string(char *cp)
264 /* The GMP version of bigq_set_string (mpq_set_str) has the following
266 - If p starts with a '+' sign, it does nothing; i.e., it leaves its
267 ratio argument untouched.
268 - If p has a '+' sign after the '/' (e.g., 300/+400), it sets the
269 numerator from the string, but *leaves the denominator unchanged*.
270 - If p has trailing nonnumeric characters, it sets the numerator from
271 the string, but leaves the denominator unchanged.
272 - If p has more than one '/', (e.g., 1/2/3), then it sets the
273 numerator from the string, but leaves the denominator unchanged.
275 Therefore, move p past any leading '+' signs, temporarily drop a null
276 after the numeric characters we are trying to convert, and then put
277 the nulled character back afterward. I am not going to fix problem
278 #2; just don't write ratios that look like that. */
283 bigq_set_string(bq, cp, 0);
284 bigq_canonicalize(bq);
286 result = ent_mpq_downgrade_maybe(bq);
292 Lisp_Object read_bigf_string(char *cp)
297 bigf_init_prec(bf, internal_get_precision(Qnil));
299 /* The GMP version of bigf_set_string (mpf_set_str)
300 has the following limitation: if p starts with a '+'
301 sign, it does nothing; i.e., it leaves its bigfloat
303 Therefore, move p past any leading '+' signs. */
308 bigf_set_string(bf, cp, 0);
309 result = make_bigf_bf(bf);
317 _ent_mpz_zerop(bigz n)
319 return (bigz_sign(n) == 0);
323 ent_mpz_zerop(Lisp_Object l)
325 return _ent_mpz_zerop(XBIGZ_DATA(l));
329 _ent_mpz_onep(bigz n)
331 return (bigz_fits_long_p(n) && bigz_to_long(n) == 1L);
335 ent_mpz_onep(Lisp_Object l)
337 return _ent_mpz_onep(XBIGZ_DATA(l));
341 _ent_mpz_unitp(bigz n)
343 return (bigz_fits_long_p(n) &&
344 (bigz_to_long(n) == 1L || bigz_to_long(n) == -1L));
348 ent_mpz_unitp(Lisp_Object l)
350 return _ent_mpz_unitp(XBIGZ_DATA(l));
354 ent_sum_BIGZ_T(Lisp_Object l, Lisp_Object r)
356 bigz_add(ent_scratch_bigz, XBIGZ_DATA(l), XBIGZ_DATA(r));
357 return ent_mpz_downgrade_maybe(ent_scratch_bigz);
360 ent_sum_BIGZ_T_INT_T(Lisp_Object l, Lisp_Object r)
362 bigz_set_long(ent_scratch_bigz, ent_int(r));
363 bigz_add(ent_scratch_bigz, XBIGZ_DATA(l), ent_scratch_bigz);
364 return ent_mpz_downgrade_maybe(ent_scratch_bigz);
367 ent_sum_INT_T_BIGZ_T(Lisp_Object l, Lisp_Object r)
369 return ent_sum_BIGZ_T_INT_T(r, l);
373 ent_sum_BIGZ_T_FLOAT_T(Lisp_Object l, Lisp_Object r)
375 return __ent_binop_lift_1(
376 ASE_BINARY_OP_SUM, BIGZ_T, l, FLOAT_T, r, NULL);
379 ent_sum_FLOAT_T_BIGZ_T(Lisp_Object l, Lisp_Object r)
381 return __ent_binop_lift_2(
382 ASE_BINARY_OP_SUM, FLOAT_T, l, BIGZ_T, r, NULL);
387 ent_diff_BIGZ_T(Lisp_Object l, Lisp_Object r)
389 bigz_sub(ent_scratch_bigz, XBIGZ_DATA(l), XBIGZ_DATA(r));
390 return ent_mpz_downgrade_maybe(ent_scratch_bigz);
393 ent_diff_BIGZ_T_INT_T(Lisp_Object l, Lisp_Object r)
395 bigz_set_long(ent_scratch_bigz, ent_int(r));
396 bigz_sub(ent_scratch_bigz, XBIGZ_DATA(l), ent_scratch_bigz);
397 return ent_mpz_downgrade_maybe(ent_scratch_bigz);
400 ent_diff_INT_T_BIGZ_T(Lisp_Object l, Lisp_Object r)
402 bigz_set_long(ent_scratch_bigz, ent_int(l));
403 bigz_sub(ent_scratch_bigz, ent_scratch_bigz, XBIGZ_DATA(r));
404 return ent_mpz_downgrade_maybe(ent_scratch_bigz);
408 ent_diff_BIGZ_T_FLOAT_T(Lisp_Object l, Lisp_Object r)
410 return __ent_binop_lift_1(
411 ASE_BINARY_OP_DIFF, BIGZ_T, l, FLOAT_T, r, NULL);
414 ent_diff_FLOAT_T_BIGZ_T(Lisp_Object l, Lisp_Object r)
416 return __ent_binop_lift_2(
417 ASE_BINARY_OP_DIFF, FLOAT_T, l, BIGZ_T, r, NULL);
422 ent_neg_BIGZ_T(Lisp_Object l)
424 bigz_neg(ent_scratch_bigz, XBIGZ_DATA(l));
425 return make_bigz_bz(ent_scratch_bigz);
429 ent_prod_BIGZ_T(Lisp_Object l, Lisp_Object r)
431 bigz_mul(ent_scratch_bigz, XBIGZ_DATA(l), XBIGZ_DATA(r));
432 return ent_mpz_downgrade_maybe(ent_scratch_bigz);
435 ent_prod_BIGZ_T_INT_T(Lisp_Object l, Lisp_Object r)
437 bigz_set_long(ent_scratch_bigz, ent_int(r));
438 bigz_mul(ent_scratch_bigz, XBIGZ_DATA(l), ent_scratch_bigz);
439 return ent_mpz_downgrade_maybe(ent_scratch_bigz);
442 ent_prod_INT_T_BIGZ_T(Lisp_Object l, Lisp_Object r)
444 return ent_prod_BIGZ_T_INT_T(r, l);
448 ent_prod_BIGZ_T_FLOAT_T(Lisp_Object l, Lisp_Object r)
450 return __ent_binop_lift_1(
451 ASE_BINARY_OP_PROD, BIGZ_T, l, FLOAT_T, r, NULL);
454 ent_prod_FLOAT_T_BIGZ_T(Lisp_Object l, Lisp_Object r)
456 return __ent_binop_lift_2(
457 ASE_BINARY_OP_PROD, FLOAT_T, l, BIGZ_T, r, NULL);
462 ent_div_BIGZ_T(Lisp_Object l, Lisp_Object r)
464 if (bigz_sign(XBIGZ_DATA(r)) == 0) {
465 int lsgn = bigz_sign(XBIGZ_DATA(l));
467 return make_indef(POS_INFINITY);
469 return make_indef(NEG_INFINITY);
471 return make_indef(NOT_A_NUMBER);
473 bigz_div(ent_scratch_bigz, XBIGZ_DATA(l), XBIGZ_DATA(r));
474 return ent_mpz_downgrade_maybe(ent_scratch_bigz);
477 ent_div_BIGZ_T_INT_T(Lisp_Object l, Lisp_Object r)
479 if (ent_int(r) == 0) {
480 int lsgn = bigz_sign(XBIGZ_DATA(l));
482 return make_indef(POS_INFINITY);
484 return make_indef(NEG_INFINITY);
486 return make_indef(NOT_A_NUMBER);
489 bigz_set_long(ent_scratch_bigz, ent_int(r));
490 bigz_div(ent_scratch_bigz, XBIGZ_DATA(l), ent_scratch_bigz);
491 return ent_mpz_downgrade_maybe(ent_scratch_bigz);
494 ent_div_INT_T_BIGZ_T(Lisp_Object l, Lisp_Object r)
496 if (bigz_sign(XBIGZ_DATA(r)) == 0) {
497 EMACS_INT rl = ent_int(l);
499 return make_indef(POS_INFINITY);
501 return make_indef(NEG_INFINITY);
503 return make_indef(NOT_A_NUMBER);
506 bigz_set_long(ent_scratch_bigz, ent_int(l));
507 bigz_div(ent_scratch_bigz, ent_scratch_bigz, XBIGZ_DATA(r));
508 return ent_mpz_downgrade_maybe(ent_scratch_bigz);
512 ent_div_BIGZ_T_FLOAT_T(Lisp_Object l, Lisp_Object r)
514 return __ent_binop_lift_1(
515 ASE_BINARY_OP_DIV, BIGZ_T, l, FLOAT_T, r, NULL);
518 ent_div_FLOAT_T_BIGZ_T(Lisp_Object l, Lisp_Object r)
520 return __ent_binop_lift_2(
521 ASE_BINARY_OP_DIV, FLOAT_T, l, BIGZ_T, r, NULL);
526 ent_quo_BIGZ_T(Lisp_Object l, Lisp_Object r)
528 if (bigz_sign(XBIGZ_DATA(r)) == 0) {
529 int lsgn = bigz_sign(XBIGZ_DATA(l));
531 return make_indef(POS_INFINITY);
533 return make_indef(NEG_INFINITY);
535 return make_indef(NOT_A_NUMBER);
538 bigq_set_bigz_bigz(ent_scratch_bigq,
539 XBIGZ_DATA(l), XBIGZ_DATA(r));
540 return ent_mpq_downgrade_maybe(ent_scratch_bigq);
543 ent_quo_BIGZ_T_INT_T(Lisp_Object l, Lisp_Object r)
545 EMACS_INT rr = ent_int(r);
547 int lsgn = bigz_sign(XBIGZ_DATA(l));
549 return make_indef(POS_INFINITY);
551 return make_indef(NEG_INFINITY);
553 return make_indef(NOT_A_NUMBER);
556 bigz_set_long(ent_scratch_bigz, rr);
557 return make_bigq_bz(XBIGZ_DATA(l), ent_scratch_bigz);
560 ent_quo_INT_T_BIGZ_T(Lisp_Object l, Lisp_Object r)
562 if (bigz_sign(XBIGZ_DATA(r)) == 0) {
563 EMACS_INT rl = ent_int(l);
565 return make_indef(POS_INFINITY);
567 return make_indef(NEG_INFINITY);
569 return make_indef(NOT_A_NUMBER);
572 bigz_set_long(ent_scratch_bigz, ent_int(l));
573 return make_bigq_bz(ent_scratch_bigz, XBIGZ_DATA(r));
577 ent_inv_BIGZ_T(Lisp_Object r)
579 if (bigz_sign(XBIGZ_DATA(r)) == 0) {
580 return make_indef(POS_INFINITY);
581 } else if (ent_mpz_unitp(r)) {
584 return make_bigq_bz(XBIGZ_DATA(Qent_mpz_one), XBIGZ_DATA(r));
589 ent_rem_BIGZ_T(Lisp_Object l, Lisp_Object r)
591 if (bigz_sign(XBIGZ_DATA(r)) == 0) {
594 bigz_mod(ent_scratch_bigz, XBIGZ_DATA(l), XBIGZ_DATA(r));
595 return make_bigz_bz(ent_scratch_bigz);
598 ent_rem_BIGZ_T_INT_T(Lisp_Object l, Lisp_Object r)
600 EMACS_INT rr = ent_int(r);
604 bigz_set_long(ent_scratch_bigz, rr);
605 bigz_mod(ent_scratch_bigz, XBIGZ_DATA(l), ent_scratch_bigz);
606 return ent_mpz_downgrade_maybe(ent_scratch_bigz);
609 ent_rem_INT_T_BIGZ_T(Lisp_Object l, Lisp_Object r)
611 if (bigz_sign(XBIGZ_DATA(r)) == 0) {
614 bigz_set_long(ent_scratch_bigz, ent_int(l));
615 bigz_mod(ent_scratch_bigz, ent_scratch_bigz, XBIGZ_DATA(r));
616 return ent_mpz_downgrade_maybe(ent_scratch_bigz);
620 ent_pow_BIGZ_T_integer_trivial(Lisp_Object l, Lisp_Object r)
622 if (!bigz_fits_long_p(XBIGZ_DATA(l)))
623 return Qnull_pointer;
625 if (bigz_to_long(XBIGZ_DATA(l)) == 1L) {
627 } else if (bigz_to_long(XBIGZ_DATA(l)) == -1L) {
628 if (!NILP(Fevenp(r)))
632 } else if (ent_mpz_zerop(l)) {
633 /* actually only idiots want to compute 0-powers
634 * think I put a sleep(10) here to pretend that we're
635 * working rilly hard to solve that problem */
636 if (ent_unrel_zerop(r))
639 return Qent_mpz_zero;
641 return Qnull_pointer;
645 ent_pow_INT_T_integer_trivial(Lisp_Object l, Lisp_Object r)
649 } else if (XINT(l) == -1L) {
650 if (!NILP(Fevenp(r)))
654 } else if (XINT(l) == 0L) {
655 /* actually only idiots want to compute 0-powers
656 * think I put a sleep(10) here to pretend that we're
657 * working rilly hard to solve that problem */
658 if (ent_unrel_zerop(r))
663 return Qnull_pointer;
667 ent_pow_integer_integer(Lisp_Object l, Lisp_Object r)
673 if (INTP(l) && (result = ent_pow_INT_T_integer_trivial(l, r)))
675 else if (BIGZP(l) && (result = ent_pow_BIGZ_T_integer_trivial(l, r)))
678 if (NILP(Fnonnegativep(r))) {
679 /* l can't be inverted in Z, we return 0 or the inverse in Q
680 * depending on `common_lisp_slash' */
681 if (!common_lisp_slash)
682 return Qent_mpz_zero;
685 ent_pow_integer_integer(l, ent_unop_neg(r)));
690 } else if (BIGZP(r)) {
691 if (bigz_fits_long_p(XBIGZ_DATA(r)))
692 expo = bigz_to_long(XBIGZ_DATA(r));
694 Fsignal(Qrange_error, list1(r));
696 Fsignal(Qoperation_error, list1(r));
701 bigz_set_long(ent_scratch_bigz, XINT(l));
702 } else if (BIGZP(l)) {
703 bigz_set(ent_scratch_bigz, XBIGZ_DATA(l));
705 Fsignal(Qoperation_error, list1(l));
709 bigz_pow(ent_scratch_bigz, ent_scratch_bigz, expo);
710 return ent_mpz_downgrade_maybe(ent_scratch_bigz);
715 ent_lt_bigz(Lisp_Object l, Lisp_Object r)
717 return (bigz_lt(XBIGZ_DATA(l), XBIGZ_DATA(r)));
720 ent_lt_bigz_int(Lisp_Object l, Lisp_Object r)
722 bigz_set_long(ent_scratch_bigz, ent_int(r));
723 return (bigz_lt(XBIGZ_DATA(l), ent_scratch_bigz));
726 ent_lt_int_bigz(Lisp_Object l, Lisp_Object r)
728 bigz_set_long(ent_scratch_bigz, ent_int(l));
729 return (bigz_lt(ent_scratch_bigz, XBIGZ_DATA(r)));
733 ent_gt_bigz(Lisp_Object l, Lisp_Object r)
735 return (bigz_gt(XBIGZ_DATA(l), XBIGZ_DATA(r)));
738 ent_gt_bigz_int(Lisp_Object l, Lisp_Object r)
740 bigz_set_long(ent_scratch_bigz, ent_int(r));
741 return (bigz_gt(XBIGZ_DATA(l), ent_scratch_bigz));
744 ent_gt_int_bigz(Lisp_Object l, Lisp_Object r)
746 bigz_set_long(ent_scratch_bigz, ent_int(l));
747 return (bigz_gt(ent_scratch_bigz, XBIGZ_DATA(r)));
751 ent_eq_bigz(Lisp_Object l, Lisp_Object r)
753 return (bigz_eql(XBIGZ_DATA(l), XBIGZ_DATA(r)));
756 ent_eq_bigz_int(Lisp_Object l, Lisp_Object r)
758 bigz_set_long(ent_scratch_bigz, ent_int(r));
759 return (bigz_eql(XBIGZ_DATA(l), ent_scratch_bigz));
762 ent_eq_int_bigz(Lisp_Object l, Lisp_Object r)
764 return ent_eq_bigz_int(r, l);
768 ent_ne_bigz(Lisp_Object l, Lisp_Object r)
770 return !ent_eq_bigz(l, r);
773 ent_ne_bigz_int(Lisp_Object l, Lisp_Object r)
775 return !ent_eq_bigz_int(l, r);
778 ent_ne_int_bigz(Lisp_Object l, Lisp_Object r)
780 return ent_ne_bigz_int(r, l);
785 ent_lt_bigzq_float(Lisp_Object l, Lisp_Object r)
787 return ent_binrel_lift_1(ASE_BINARY_REL_LESSP, l, r, NULL);
790 ent_lt_float_bigzq(Lisp_Object l, Lisp_Object r)
792 return ent_binrel_lift_2(ASE_BINARY_REL_LESSP, l, r, NULL);
795 ent_gt_bigzq_float(Lisp_Object l, Lisp_Object r)
797 return ent_binrel_lift_1(ASE_BINARY_REL_GREATERP, l, r, NULL);
800 ent_gt_float_bigzq(Lisp_Object l, Lisp_Object r)
802 return ent_binrel_lift_2(ASE_BINARY_REL_GREATERP, l, r, NULL);
805 ent_eq_bigzq_float(Lisp_Object l, Lisp_Object r)
807 return ent_binrel_lift_1(ASE_BINARY_REL_EQUALP, l, r, NULL);
810 ent_eq_float_bigzq(Lisp_Object l, Lisp_Object r)
812 return ent_binrel_lift_2(ASE_BINARY_REL_EQUALP, l, r, NULL);
815 ent_ne_bigzq_float(Lisp_Object l, Lisp_Object r)
817 return ent_binrel_lift_1(ASE_BINARY_REL_NEQP, l, r, NULL);
820 ent_ne_float_bigzq(Lisp_Object l, Lisp_Object r)
822 return ent_binrel_lift_2(ASE_BINARY_REL_NEQP, l, r, NULL);
828 _ent_lift_INT_T_BIGZ_T(Lisp_Object number, ent_lift_args_t SXE_UNUSED(la))
830 return make_bigz(ent_int(number));
834 _ent_lift_BIGZ_T_INT_T(Lisp_Object number, ent_lift_args_t SXE_UNUSED(la))
836 return make_int(bigz_to_long(XBIGZ_DATA(number)));
841 _ent_lift_FLOAT_T_BIGZ_T(Lisp_Object number, ent_lift_args_t SXE_UNUSED(la))
843 bigz_set_fpfloat(ent_scratch_bigz, XFLOAT_DATA(number));
844 return make_bigz_bz(ent_scratch_bigz);
848 _ent_lift_BIGZ_T_FLOAT_T(Lisp_Object number, ent_lift_args_t SXE_UNUSED(la))
850 /* can result in an indef object */
851 return make_float(bigz_to_fpfloat(XBIGZ_DATA(number)));
858 ent_mpq_zerop(Lisp_Object l)
860 return (bigq_sign(XBIGQ_DATA(l)) == 0);
864 ent_mpq_onep(Lisp_Object l)
866 #define num bigq_numerator(XBIGQ_DATA(l))
867 #define den bigq_denominator(XBIGQ_DATA(l))
868 return (bigz_fits_long_p(num) &&
869 bigz_to_long(num) == 1L &&
870 bigz_fits_long_p(den) &&
871 bigz_to_long(den) == 1L);
877 ent_mpq_unitp(Lisp_Object unused)
883 ent_sum_BIGQ_T(Lisp_Object l, Lisp_Object r)
885 bigq_add(ent_scratch_bigq, XBIGQ_DATA(l), XBIGQ_DATA(r));
886 return ent_mpq_downgrade_maybe(ent_scratch_bigq);
889 ent_sum_BIGQ_T_scratch(Lisp_Object l)
891 bigq_add(ent_scratch_bigq, XBIGQ_DATA(l), ent_scratch_bigq);
892 return ent_mpq_downgrade_maybe(ent_scratch_bigq);
895 ent_sum_BIGQ_T_INT_T(Lisp_Object l, Lisp_Object r)
897 bigq_set_long(ent_scratch_bigq, ent_int(r));
898 return ent_sum_BIGQ_T_scratch(l);
901 ent_sum_INT_T_BIGQ_T(Lisp_Object l, Lisp_Object r)
903 bigq_set_long(ent_scratch_bigq, ent_int(l));
904 return ent_sum_BIGQ_T_scratch(r);
907 ent_sum_BIGQ_T_BIGZ_T(Lisp_Object l, Lisp_Object r)
909 bigq_set_bigz(ent_scratch_bigq, XBIGZ_DATA(r));
910 return ent_sum_BIGQ_T_scratch(l);
913 ent_sum_BIGZ_T_BIGQ_T(Lisp_Object l, Lisp_Object r)
915 return ent_sum_BIGQ_T_BIGZ_T(r, l);
919 ent_sum_BIGQ_T_FLOAT_T(Lisp_Object l, Lisp_Object r)
921 return __ent_binop_lift_1(
922 ASE_BINARY_OP_SUM, BIGQ_T, l, FLOAT_T, r, NULL);
925 ent_sum_FLOAT_T_BIGQ_T(Lisp_Object l, Lisp_Object r)
927 return __ent_binop_lift_2(
928 ASE_BINARY_OP_SUM, FLOAT_T, l, BIGQ_T, r, NULL);
933 ent_diff_BIGQ_T(Lisp_Object l, Lisp_Object r)
935 bigq_sub(ent_scratch_bigq, XBIGQ_DATA(l), XBIGQ_DATA(r));
936 return ent_mpq_downgrade_maybe(ent_scratch_bigq);
939 ent_diff_BIGQ_T_INT_T(Lisp_Object l, Lisp_Object r)
941 bigq_set_long(ent_scratch_bigq, ent_int(r));
942 bigq_sub(ent_scratch_bigq, XBIGQ_DATA(l), ent_scratch_bigq);
943 return ent_mpq_downgrade_maybe(ent_scratch_bigq);
946 ent_diff_INT_T_BIGQ_T(Lisp_Object l, Lisp_Object r)
948 bigq_set_long(ent_scratch_bigq, ent_int(l));
949 bigq_sub(ent_scratch_bigq, ent_scratch_bigq, XBIGQ_DATA(r));
950 return ent_mpq_downgrade_maybe(ent_scratch_bigq);
953 ent_diff_BIGQ_T_BIGZ_T(Lisp_Object l, Lisp_Object r)
955 bigq_set_bigz(ent_scratch_bigq, XBIGZ_DATA(r));
956 bigq_sub(ent_scratch_bigq, XBIGQ_DATA(l), ent_scratch_bigq);
957 return ent_mpq_downgrade_maybe(ent_scratch_bigq);
960 ent_diff_BIGZ_T_BIGQ_T(Lisp_Object l, Lisp_Object r)
962 bigq_set_bigz(ent_scratch_bigq, XBIGZ_DATA(l));
963 bigq_sub(ent_scratch_bigq, ent_scratch_bigq, XBIGQ_DATA(r));
964 return ent_mpq_downgrade_maybe(ent_scratch_bigq);
968 ent_diff_BIGQ_T_FLOAT_T(Lisp_Object l, Lisp_Object r)
970 return __ent_binop_lift_1(
971 ASE_BINARY_OP_DIFF, BIGQ_T, l, FLOAT_T, r, NULL);
974 ent_diff_FLOAT_T_BIGQ_T(Lisp_Object l, Lisp_Object r)
976 return __ent_binop_lift_2(
977 ASE_BINARY_OP_SUM, FLOAT_T, l, BIGQ_T, r, NULL);
982 ent_neg_BIGQ_T(Lisp_Object l)
984 bigq_neg(ent_scratch_bigq, XBIGQ_DATA(l));
985 return make_bigq_bq(ent_scratch_bigq);
989 ent_prod_BIGQ_T(Lisp_Object l, Lisp_Object r)
991 bigq_mul(ent_scratch_bigq, XBIGQ_DATA(l), XBIGQ_DATA(r));
992 return ent_mpq_downgrade_maybe(ent_scratch_bigq);
995 ent_prod_BIGQ_T_INT_T(Lisp_Object l, Lisp_Object r)
997 bigq_set_long(ent_scratch_bigq, ent_int(r));
998 bigq_mul(ent_scratch_bigq, XBIGQ_DATA(l), ent_scratch_bigq);
999 return ent_mpq_downgrade_maybe(ent_scratch_bigq);
1002 ent_prod_INT_T_BIGQ_T(Lisp_Object l, Lisp_Object r)
1004 return ent_prod_BIGQ_T_INT_T(r, l);
1007 ent_prod_BIGQ_T_BIGZ_T(Lisp_Object l, Lisp_Object r)
1009 bigq_set_bigz(ent_scratch_bigq, XBIGZ_DATA(r));
1010 bigq_mul(ent_scratch_bigq, XBIGQ_DATA(l), ent_scratch_bigq);
1011 return ent_mpq_downgrade_maybe(ent_scratch_bigq);
1014 ent_prod_BIGZ_T_BIGQ_T(Lisp_Object l, Lisp_Object r)
1016 return ent_prod_BIGQ_T_BIGZ_T(r, l);
1020 ent_prod_BIGQ_T_FLOAT_T(Lisp_Object l, Lisp_Object r)
1022 return __ent_binop_lift_1(
1023 ASE_BINARY_OP_PROD, BIGQ_T, l, FLOAT_T, r, NULL);
1026 ent_prod_FLOAT_T_BIGQ_T(Lisp_Object l, Lisp_Object r)
1028 return __ent_binop_lift_2(
1029 ASE_BINARY_OP_PROD, FLOAT_T, l, BIGQ_T, r, NULL);
1034 ent_div_BIGQ_T(Lisp_Object l, Lisp_Object r)
1036 if (bigq_sign(XBIGQ_DATA(r)) == 0) {
1037 int lsgn = bigq_sign(XBIGQ_DATA(l));
1039 return make_indef(POS_INFINITY);
1041 return make_indef(NEG_INFINITY);
1043 return make_indef(NOT_A_NUMBER);
1045 bigq_div(ent_scratch_bigq, XBIGQ_DATA(l), XBIGQ_DATA(r));
1046 return ent_mpq_downgrade_maybe(ent_scratch_bigq);
1049 ent_div_BIGQ_T_INT_T(Lisp_Object l, Lisp_Object r)
1051 EMACS_INT rr = ent_int(r);
1053 int lsgn = bigq_sign(XBIGQ_DATA(l));
1055 return make_indef(POS_INFINITY);
1057 return make_indef(NEG_INFINITY);
1059 return make_indef(NOT_A_NUMBER);
1062 bigq_set_long(ent_scratch_bigq, rr);
1063 bigq_div(ent_scratch_bigq, XBIGQ_DATA(l), ent_scratch_bigq);
1064 return ent_mpq_downgrade_maybe(ent_scratch_bigq);
1067 ent_div_INT_T_BIGQ_T(Lisp_Object l, Lisp_Object r)
1069 if (bigq_sign(XBIGQ_DATA(r)) == 0) {
1070 EMACS_INT rl = ent_int(l);
1072 return make_indef(POS_INFINITY);
1074 return make_indef(NEG_INFINITY);
1076 return make_indef(NOT_A_NUMBER);
1079 bigq_set_long(ent_scratch_bigq, ent_int(l));
1080 bigq_div(ent_scratch_bigq, ent_scratch_bigq, XBIGQ_DATA(r));
1081 return ent_mpq_downgrade_maybe(ent_scratch_bigq);
1084 ent_div_BIGQ_T_BIGZ_T(Lisp_Object l, Lisp_Object r)
1086 if (bigz_sign(XBIGZ_DATA(r)) == 0) {
1087 int lsgn = bigq_sign(XBIGQ_DATA(l));
1089 return make_indef(POS_INFINITY);
1091 return make_indef(NEG_INFINITY);
1093 return make_indef(NOT_A_NUMBER);
1096 bigq_set_bigz(ent_scratch_bigq, XBIGZ_DATA(r));
1097 bigq_div(ent_scratch_bigq, XBIGQ_DATA(l), ent_scratch_bigq);
1098 return ent_mpq_downgrade_maybe(ent_scratch_bigq);
1101 ent_div_BIGZ_T_BIGQ_T(Lisp_Object l, Lisp_Object r)
1103 if (bigq_sign(XBIGQ_DATA(r)) == 0) {
1104 int lsgn = bigz_sign(XBIGZ_DATA(l));
1106 return make_indef(POS_INFINITY);
1108 return make_indef(NEG_INFINITY);
1110 return make_indef(NOT_A_NUMBER);
1113 bigq_set_bigz(ent_scratch_bigq, XBIGZ_DATA(l));
1114 bigq_div(ent_scratch_bigq, ent_scratch_bigq, XBIGQ_DATA(r));
1115 return ent_mpq_downgrade_maybe(ent_scratch_bigq);
1119 ent_div_BIGQ_T_FLOAT_T(Lisp_Object l, Lisp_Object r)
1121 return __ent_binop_lift_1(
1122 ASE_BINARY_OP_DIV, BIGQ_T, l, FLOAT_T, r, NULL);
1125 ent_div_FLOAT_T_BIGQ_T(Lisp_Object l, Lisp_Object r)
1127 return __ent_binop_lift_2(
1128 ASE_BINARY_OP_DIV, FLOAT_T, l, BIGQ_T, r, NULL);
1133 ent_quo_INT_T(Lisp_Object l, Lisp_Object r)
1135 if (ent_int(r) == 0) {
1137 return make_indef(POS_INFINITY);
1138 else if (ent_int(l) < 0)
1139 return make_indef(NEG_INFINITY);
1141 return make_indef(NOT_A_NUMBER);
1144 if (ent_int(r) < 0) {
1145 bigq_set_long_ulong(ent_scratch_bigq,
1146 -ent_int(l), (unsigned long)-ent_int(r));
1147 return ent_mpq_downgrade_maybe(ent_scratch_bigq);
1149 bigq_set_long_ulong(ent_scratch_bigq,
1150 ent_int(l), (unsigned long)ent_int(r));
1151 return ent_mpq_downgrade_maybe(ent_scratch_bigq);
1156 ent_inv_BIGQ_T(Lisp_Object r)
1158 if (bigq_sign(XBIGQ_DATA(r)) == 0) {
1159 return make_indef(POS_INFINITY);
1161 bigq_set_long(ent_scratch_bigq, 1L);
1162 bigq_div(ent_scratch_bigq, ent_scratch_bigq, XBIGQ_DATA(r));
1163 return ent_mpq_downgrade_maybe(ent_scratch_bigq);
1167 ent_inv_INT_T(Lisp_Object l)
1169 if (ent_int(l) == 0) {
1170 return make_indef(POS_INFINITY);
1172 return make_bigq(1L, ent_int(l));
1176 ent_rem_BIGQ_T(Lisp_Object unused, Lisp_Object r)
1178 if (bigq_sign(XBIGQ_DATA(r)) == 0) {
1181 /* actually the zero constructor should be called */
1182 return Qent_mpq_zero;
1185 ent_mod_BIGQ_T(Lisp_Object l, Lisp_Object r)
1187 if (bigq_sign(XBIGQ_DATA(r)) == 0) {
1190 bigq_div(ent_scratch_bigq, XBIGQ_DATA(l), XBIGQ_DATA(r));
1191 bigz_div(ent_scratch_bigz,
1192 bigq_numerator(ent_scratch_bigq),
1193 bigq_denominator(ent_scratch_bigq));
1195 bigq_set_bigz(ent_scratch_bigq, ent_scratch_bigz);
1196 bigq_mul(ent_scratch_bigq, ent_scratch_bigq, XBIGQ_DATA(r));
1197 bigq_sub(ent_scratch_bigq, XBIGQ_DATA(l), ent_scratch_bigq);
1198 return ent_mpq_downgrade_maybe(ent_scratch_bigq);
1202 ent_pow_BIGQ_T_integer_trivial(Lisp_Object l, Lisp_Object r)
1204 if (!_ent_mpz_onep(XBIGQ_DENOMINATOR(l)) ||
1205 !bigz_fits_long_p(XBIGQ_NUMERATOR(l)))
1206 return Qnull_pointer;
1208 if (bigz_to_long(XBIGQ_NUMERATOR(l)) == 1L) {
1210 } else if (bigz_to_long(XBIGQ_NUMERATOR(l)) == -1L) {
1211 if (!NILP(Fevenp(r)))
1212 return Qent_mpq_one;
1215 } else if (ent_mpq_zerop(l)) {
1216 /* actually only idiots want to compute 0-powers
1217 * think I put a sleep(10) here to pretend that we're
1218 * working rilly hard to solve that problem */
1219 if (ent_unrel_zerop(r))
1220 return Qent_mpq_one;
1222 return Qent_mpq_zero;
1224 return Qnull_pointer;
1228 ent_pow_BIGQ_T_integer(Lisp_Object l, Lisp_Object r)
1230 Lisp_Object num, den, result;
1233 if ((result = ent_pow_BIGQ_T_integer_trivial(l, r)))
1236 if (NILP(Fnonnegativep(r))) {
1237 return ent_unop_inv(
1238 ent_pow_BIGQ_T_integer(l, ent_unop_neg(r)));
1241 num = ent_binop(ASE_BINARY_OP_POW,
1242 make_bigz_bz(XBIGQ_NUMERATOR(l)), r);
1243 den = ent_binop(ASE_BINARY_OP_POW,
1244 make_bigz_bz(XBIGQ_DENOMINATOR(l)), r);
1246 if (!INTEGERP(num) || !INTEGERP(den)) {
1247 Fsignal(Qdomain_error, list2(num, den));
1251 if (BIGZP(num) && BIGZP(den))
1252 return make_bigq_bz(XBIGZ_DATA(num), XBIGZ_DATA(den));
1253 else if (INTP(num) && INTP(den))
1254 return make_bigq(ent_int(num), ent_int(den));
1256 num = ent_lift(num, BIGZ_T, NULL);
1257 den = ent_lift(den, BIGZ_T, NULL);
1258 return make_bigq_bz(XBIGZ_DATA(num), XBIGZ_DATA(den));
1266 ent_lt_bigq(Lisp_Object l, Lisp_Object r)
1268 return (bigq_lt(XBIGQ_DATA(l), XBIGQ_DATA(r)));
1271 ent_lt_bigq_int(Lisp_Object l, Lisp_Object r)
1273 bigq_set_long(ent_scratch_bigq, ent_int(r));
1274 return (bigq_lt(XBIGQ_DATA(l), ent_scratch_bigq));
1277 ent_lt_int_bigq(Lisp_Object l, Lisp_Object r)
1279 bigq_set_long(ent_scratch_bigq, ent_int(l));
1280 return (bigq_lt(ent_scratch_bigq, XBIGQ_DATA(r)));
1283 ent_lt_bigq_bigz(Lisp_Object l, Lisp_Object r)
1285 bigq_set_bigz(ent_scratch_bigq, XBIGZ_DATA(r));
1286 return (bigq_lt(XBIGQ_DATA(l), ent_scratch_bigq));
1289 ent_lt_bigz_bigq(Lisp_Object l, Lisp_Object r)
1291 bigq_set_bigz(ent_scratch_bigq, XBIGZ_DATA(l));
1292 return (bigq_lt(ent_scratch_bigq, XBIGQ_DATA(r)));
1296 ent_gt_bigq(Lisp_Object l, Lisp_Object r)
1298 return (bigq_gt(XBIGQ_DATA(l), XBIGQ_DATA(r)));
1301 ent_gt_bigq_int(Lisp_Object l, Lisp_Object r)
1303 bigq_set_long(ent_scratch_bigq, ent_int(r));
1304 return (bigq_gt(XBIGQ_DATA(l), ent_scratch_bigq));
1307 ent_gt_int_bigq(Lisp_Object l, Lisp_Object r)
1309 bigq_set_long(ent_scratch_bigq, ent_int(l));
1310 return (bigq_gt(ent_scratch_bigq, XBIGQ_DATA(r)));
1313 ent_gt_bigq_bigz(Lisp_Object l, Lisp_Object r)
1315 bigq_set_bigz(ent_scratch_bigq, XBIGZ_DATA(r));
1316 return (bigq_gt(XBIGQ_DATA(l), ent_scratch_bigq));
1319 ent_gt_bigz_bigq(Lisp_Object l, Lisp_Object r)
1321 bigq_set_bigz(ent_scratch_bigq, XBIGZ_DATA(l));
1322 return (bigq_gt(ent_scratch_bigq, XBIGQ_DATA(r)));
1326 ent_eq_bigq(Lisp_Object l, Lisp_Object r)
1328 return (bigq_eql(XBIGQ_DATA(l), XBIGQ_DATA(r)));
1331 ent_eq_bigq_int(Lisp_Object l, Lisp_Object r)
1333 bigq_set_long(ent_scratch_bigq, ent_int(r));
1334 return (bigq_eql(XBIGQ_DATA(l), ent_scratch_bigq));
1337 ent_eq_int_bigq(Lisp_Object l, Lisp_Object r)
1339 bigq_set_long(ent_scratch_bigq, ent_int(l));
1340 return (bigq_eql(ent_scratch_bigq, XBIGQ_DATA(r)));
1343 ent_eq_bigq_bigz(Lisp_Object l, Lisp_Object r)
1345 bigq_set_bigz(ent_scratch_bigq, XBIGZ_DATA(r));
1346 return (bigq_eql(XBIGQ_DATA(l), ent_scratch_bigq));
1349 ent_eq_bigz_bigq(Lisp_Object l, Lisp_Object r)
1351 bigq_set_bigz(ent_scratch_bigq, XBIGZ_DATA(l));
1352 return (bigq_eql(ent_scratch_bigq, XBIGQ_DATA(r)));
1356 ent_ne_bigq(Lisp_Object l, Lisp_Object r)
1358 return !(bigq_eql(XBIGQ_DATA(l), XBIGQ_DATA(r)));
1361 ent_ne_bigq_int(Lisp_Object l, Lisp_Object r)
1363 bigq_set_long(ent_scratch_bigq, ent_int(r));
1364 return !(bigq_eql(XBIGQ_DATA(l), ent_scratch_bigq));
1367 ent_ne_int_bigq(Lisp_Object l, Lisp_Object r)
1369 bigq_set_long(ent_scratch_bigq, ent_int(l));
1370 return !(bigq_eql(ent_scratch_bigq, XBIGQ_DATA(r)));
1373 ent_ne_bigq_bigz(Lisp_Object l, Lisp_Object r)
1375 bigq_set_bigz(ent_scratch_bigq, XBIGZ_DATA(r));
1376 return !(bigq_eql(XBIGQ_DATA(l), ent_scratch_bigq));
1379 ent_ne_bigz_bigq(Lisp_Object l, Lisp_Object r)
1381 bigq_set_bigz(ent_scratch_bigq, XBIGZ_DATA(l));
1382 return !(bigq_eql(ent_scratch_bigq, XBIGQ_DATA(r)));
1386 static inline Lisp_Object
1387 _ent_lift_INT_T_BIGQ_T(Lisp_Object number, ent_lift_args_t SXE_UNUSED(la))
1389 return make_bigq(ent_int(number), 1UL);
1392 static inline Lisp_Object
1393 _ent_lift_BIGQ_T_INT_T(Lisp_Object number, ent_lift_args_t SXE_UNUSED(la))
1395 bigz_div(ent_scratch_bigz,
1396 XBIGQ_NUMERATOR(number),
1397 XBIGQ_DENOMINATOR(number));
1398 return make_int(bigz_to_long(ent_scratch_bigz));
1401 static inline Lisp_Object
1402 _ent_lift_BIGZ_T_BIGQ_T(Lisp_Object number, ent_lift_args_t SXE_UNUSED(la))
1404 bigz_set_long(ent_scratch_bigz, 1L);
1405 return make_bigq_bz(XBIGZ_DATA(number), ent_scratch_bigz);
1408 static inline Lisp_Object
1409 _ent_lift_BIGQ_T_BIGZ_T(Lisp_Object number, ent_lift_args_t SXE_UNUSED(la))
1411 bigz_div(ent_scratch_bigz,
1412 XBIGQ_NUMERATOR(number),
1413 XBIGQ_DENOMINATOR(number));
1414 return make_bigz_bz(ent_scratch_bigz);
1418 static inline Lisp_Object
1419 _ent_lift_FLOAT_T_BIGQ_T(Lisp_Object number, ent_lift_args_t SXE_UNUSED(la))
1421 bigq_set_fpfloat(ent_scratch_bigq, XFLOAT_DATA(number));
1422 return make_bigq_bq(ent_scratch_bigq);
1425 static inline Lisp_Object
1426 _ent_lift_BIGQ_T_FLOAT_T(Lisp_Object number, ent_lift_args_t SXE_UNUSED(la))
1428 /* can result in an indef object */
1429 return make_float(bigq_to_fpfloat(XBIGQ_DATA(number)));
1436 ent_mpf_zerop(Lisp_Object l)
1438 return (bigf_sign(XBIGF_DATA(l)) == 0);
1442 ent_mpf_onep(Lisp_Object l)
1444 return (bigf_to_fpfloat(XBIGF_DATA(l)) == 1.0f);
1448 ent_mpf_unitp(Lisp_Object unused)
1454 ent_sum_BIGF_T(Lisp_Object l, Lisp_Object r)
1456 bigf_set_prec(ent_scratch_bigf,
1457 max(XBIGF_GET_PREC(l), XBIGF_GET_PREC(r)));
1458 bigf_add(ent_scratch_bigf, XBIGF_DATA(l), XBIGF_DATA(r));
1459 return make_bigf_bf(ent_scratch_bigf);
1462 ent_sum_BIGF_T_INT_T(Lisp_Object l, Lisp_Object r)
1464 bigf_set_prec(ent_scratch_bigf, XBIGF_GET_PREC(l));
1465 bigf_set_long(ent_scratch_bigf, ent_int(r));
1466 bigf_add(ent_scratch_bigf, XBIGF_DATA(l), ent_scratch_bigf);
1467 return make_bigf_bf(ent_scratch_bigf);
1470 ent_sum_INT_T_BIGF_T(Lisp_Object l, Lisp_Object r)
1472 return ent_sum_BIGF_T_INT_T(r, l);
1475 ent_sum_BIGF_T_BIGZ_T(Lisp_Object l, Lisp_Object r)
1477 bigf_set_prec(ent_scratch_bigf, XBIGF_GET_PREC(l));
1478 bigf_set_bigz(ent_scratch_bigf, XBIGZ_DATA(r));
1479 bigf_add(ent_scratch_bigf, XBIGF_DATA(l), ent_scratch_bigf);
1480 return make_bigf_bf(ent_scratch_bigf);
1483 ent_sum_BIGZ_T_BIGF_T(Lisp_Object l, Lisp_Object r)
1485 return ent_sum_BIGF_T_BIGZ_T(r, l);
1488 ent_sum_BIGF_T_BIGQ_T(Lisp_Object l, Lisp_Object r)
1490 bigf_set_prec(ent_scratch_bigf, XBIGF_GET_PREC(l));
1491 bigf_set_bigq(ent_scratch_bigf, XBIGQ_DATA(r));
1492 bigf_add(ent_scratch_bigf, XBIGF_DATA(l), ent_scratch_bigf);
1493 return make_bigf_bf(ent_scratch_bigf);
1496 ent_sum_BIGQ_T_BIGF_T(Lisp_Object l, Lisp_Object r)
1498 return ent_sum_BIGF_T_BIGQ_T(r, l);
1502 ent_sum_BIGF_T_FLOAT_T(Lisp_Object l, Lisp_Object r)
1504 bigf_set_prec(ent_scratch_bigf, XBIGF_GET_PREC(l));
1505 bigf_set_fpfloat(ent_scratch_bigf, XFLOAT_DATA(r));
1506 bigf_add(ent_scratch_bigf, XBIGF_DATA(l), ent_scratch_bigf);
1507 return make_bigf_bf(ent_scratch_bigf);
1510 ent_sum_FLOAT_T_BIGF_T(Lisp_Object l, Lisp_Object r)
1512 return ent_sum_BIGF_T_FLOAT_T(r, l);
1517 ent_diff_BIGF_T(Lisp_Object l, Lisp_Object r)
1519 bigf_set_prec(ent_scratch_bigf,
1520 max(XBIGF_GET_PREC(l), XBIGF_GET_PREC(r)));
1521 bigf_sub(ent_scratch_bigf, XBIGF_DATA(l), XBIGF_DATA(r));
1522 return make_bigf_bf(ent_scratch_bigf);
1525 ent_diff_BIGF_T_INT_T(Lisp_Object l, Lisp_Object r)
1527 bigf_set_prec(ent_scratch_bigf, XBIGF_GET_PREC(l));
1528 bigf_set_long(ent_scratch_bigf, ent_int(r));
1529 bigf_sub(ent_scratch_bigf, XBIGF_DATA(l), ent_scratch_bigf);
1530 return make_bigf_bf(ent_scratch_bigf);
1533 ent_diff_INT_T_BIGF_T(Lisp_Object l, Lisp_Object r)
1535 bigf_set_prec(ent_scratch_bigf, XBIGF_GET_PREC(r));
1536 bigf_set_long(ent_scratch_bigf, ent_int(l));
1537 bigf_sub(ent_scratch_bigf, ent_scratch_bigf, XBIGF_DATA(r));
1538 return make_bigf_bf(ent_scratch_bigf);
1541 ent_diff_BIGF_T_BIGZ_T(Lisp_Object l, Lisp_Object r)
1543 bigf_set_prec(ent_scratch_bigf, XBIGF_GET_PREC(l));
1544 bigf_set_bigz(ent_scratch_bigf, XBIGZ_DATA(r));
1545 bigf_sub(ent_scratch_bigf, XBIGF_DATA(l), ent_scratch_bigf);
1546 return make_bigf_bf(ent_scratch_bigf);
1549 ent_diff_BIGZ_T_BIGF_T(Lisp_Object l, Lisp_Object r)
1551 bigf_set_prec(ent_scratch_bigf, XBIGF_GET_PREC(r));
1552 bigf_set_bigz(ent_scratch_bigf, XBIGZ_DATA(l));
1553 bigf_sub(ent_scratch_bigf, ent_scratch_bigf, XBIGF_DATA(r));
1554 return make_bigf_bf(ent_scratch_bigf);
1557 ent_diff_BIGF_T_BIGQ_T(Lisp_Object l, Lisp_Object r)
1559 bigf_set_prec(ent_scratch_bigf, XBIGF_GET_PREC(l));
1560 bigf_set_bigq(ent_scratch_bigf, XBIGQ_DATA(r));
1561 bigf_sub(ent_scratch_bigf, XBIGF_DATA(l), ent_scratch_bigf);
1562 return make_bigf_bf(ent_scratch_bigf);
1565 ent_diff_BIGQ_T_BIGF_T(Lisp_Object l, Lisp_Object r)
1567 bigf_set_prec(ent_scratch_bigf, XBIGF_GET_PREC(r));
1568 bigf_set_bigq(ent_scratch_bigf, XBIGQ_DATA(l));
1569 bigf_sub(ent_scratch_bigf, ent_scratch_bigf, XBIGF_DATA(r));
1570 return make_bigf_bf(ent_scratch_bigf);
1574 ent_diff_BIGF_T_FLOAT_T(Lisp_Object l, Lisp_Object r)
1576 bigf_set_prec(ent_scratch_bigf, XBIGF_GET_PREC(l));
1577 bigf_set_fpfloat(ent_scratch_bigf, XFLOAT_DATA(r));
1578 bigf_sub(ent_scratch_bigf, XBIGF_DATA(l), ent_scratch_bigf);
1579 return make_bigf_bf(ent_scratch_bigf);
1582 ent_diff_FLOAT_T_BIGF_T(Lisp_Object l, Lisp_Object r)
1584 bigf_set_prec(ent_scratch_bigf, XBIGF_GET_PREC(r));
1585 bigf_set_fpfloat(ent_scratch_bigf, XFLOAT_DATA(l));
1586 bigf_sub(ent_scratch_bigf, ent_scratch_bigf, XBIGF_DATA(r));
1587 return make_bigf_bf(ent_scratch_bigf);
1592 ent_neg_BIGF_T(Lisp_Object l)
1594 bigf_set_prec(ent_scratch_bigf, XBIGF_GET_PREC(l));
1595 bigf_neg(ent_scratch_bigf, XBIGF_DATA(l));
1596 return make_bigf_bf(ent_scratch_bigf);
1600 ent_prod_BIGF_T(Lisp_Object l, Lisp_Object r)
1602 bigf_set_prec(ent_scratch_bigf,
1603 max(XBIGF_GET_PREC(l), XBIGF_GET_PREC(r)));
1604 bigf_mul(ent_scratch_bigf, XBIGF_DATA(l), XBIGF_DATA(r));
1605 return make_bigf_bf(ent_scratch_bigf);
1608 ent_prod_BIGF_T_INT_T(Lisp_Object l, Lisp_Object r)
1610 bigf_set_prec(ent_scratch_bigf, XBIGF_GET_PREC(l));
1611 bigf_set_long(ent_scratch_bigf, ent_int(r));
1612 bigf_mul(ent_scratch_bigf, XBIGF_DATA(l), ent_scratch_bigf);
1613 return make_bigf_bf(ent_scratch_bigf);
1616 ent_prod_INT_T_BIGF_T(Lisp_Object l, Lisp_Object r)
1618 return ent_prod_BIGF_T_INT_T(r, l);
1621 ent_prod_BIGF_T_BIGZ_T(Lisp_Object l, Lisp_Object r)
1623 bigf_set_prec(ent_scratch_bigf, XBIGF_GET_PREC(l));
1624 bigf_set_bigz(ent_scratch_bigf, XBIGZ_DATA(r));
1625 bigf_mul(ent_scratch_bigf, XBIGF_DATA(l), ent_scratch_bigf);
1626 return make_bigf_bf(ent_scratch_bigf);
1629 ent_prod_BIGZ_T_BIGF_T(Lisp_Object l, Lisp_Object r)
1631 return ent_prod_BIGF_T_BIGZ_T(r, l);
1634 ent_prod_BIGF_T_BIGQ_T(Lisp_Object l, Lisp_Object r)
1636 bigf_set_prec(ent_scratch_bigf, XBIGF_GET_PREC(l));
1637 bigf_set_bigq(ent_scratch_bigf, XBIGQ_DATA(r));
1638 bigf_mul(ent_scratch_bigf, XBIGF_DATA(l), ent_scratch_bigf);
1639 return make_bigf_bf(ent_scratch_bigf);
1642 ent_prod_BIGQ_T_BIGF_T(Lisp_Object l, Lisp_Object r)
1644 return ent_prod_BIGF_T_BIGQ_T(r, l);
1648 ent_prod_BIGF_T_FLOAT_T(Lisp_Object l, Lisp_Object r)
1650 bigf_set_prec(ent_scratch_bigf, XBIGF_GET_PREC(l));
1651 bigf_set_fpfloat(ent_scratch_bigf, XFLOAT_DATA(r));
1652 bigf_mul(ent_scratch_bigf, XBIGF_DATA(l), ent_scratch_bigf);
1653 return make_bigf_bf(ent_scratch_bigf);
1656 ent_prod_FLOAT_T_BIGF_T(Lisp_Object l, Lisp_Object r)
1658 return ent_prod_BIGF_T_FLOAT_T(r, l);
1663 ent_div_BIGF_T(Lisp_Object l, Lisp_Object r)
1665 if (bigf_sign(XBIGF_DATA(r)) == 0) {
1666 int lsgn = bigf_sign(XBIGF_DATA(l));
1668 return make_indef(POS_INFINITY);
1670 return make_indef(NEG_INFINITY);
1672 return make_indef(NOT_A_NUMBER);
1674 bigf_set_prec(ent_scratch_bigf,
1675 max(XBIGF_GET_PREC(l), XBIGF_GET_PREC(r)));
1676 bigf_div(ent_scratch_bigf, XBIGF_DATA(l), XBIGF_DATA(r));
1677 return make_bigf_bf(ent_scratch_bigf);
1680 ent_div_BIGF_T_INT_T(Lisp_Object l, Lisp_Object r)
1682 EMACS_INT rr = ent_int(r);
1684 int lsgn = bigf_sign(XBIGF_DATA(l));
1686 return make_indef(POS_INFINITY);
1688 return make_indef(NEG_INFINITY);
1690 return make_indef(NOT_A_NUMBER);
1693 bigf_set_prec(ent_scratch_bigf, XBIGF_GET_PREC(l));
1694 bigf_set_long(ent_scratch_bigf, rr);
1695 bigf_div(ent_scratch_bigf, XBIGF_DATA(l), ent_scratch_bigf);
1696 return make_bigf_bf(ent_scratch_bigf);
1699 ent_div_INT_T_BIGF_T(Lisp_Object l, Lisp_Object r)
1701 if (bigf_sign(XBIGF_DATA(r)) == 0) {
1702 EMACS_INT rl = ent_int(l);
1704 return make_indef(POS_INFINITY);
1706 return make_indef(NEG_INFINITY);
1708 return make_indef(NOT_A_NUMBER);
1711 bigf_set_prec(ent_scratch_bigf, XBIGF_GET_PREC(r));
1712 bigf_set_long(ent_scratch_bigf, ent_int(l));
1713 bigf_div(ent_scratch_bigf, ent_scratch_bigf, XBIGF_DATA(r));
1714 return make_bigf_bf(ent_scratch_bigf);
1717 ent_div_BIGF_T_BIGZ_T(Lisp_Object l, Lisp_Object r)
1719 if (bigz_sign(XBIGZ_DATA(r)) == 0) {
1720 int lsgn = bigf_sign(XBIGF_DATA(l));
1722 return make_indef(POS_INFINITY);
1724 return make_indef(NEG_INFINITY);
1726 return make_indef(NOT_A_NUMBER);
1729 bigf_set_prec(ent_scratch_bigf, XBIGF_GET_PREC(l));
1730 bigf_set_bigz(ent_scratch_bigf, XBIGZ_DATA(r));
1731 bigf_div(ent_scratch_bigf, XBIGF_DATA(l), ent_scratch_bigf);
1732 return make_bigf_bf(ent_scratch_bigf);
1735 ent_div_BIGZ_T_BIGF_T(Lisp_Object l, Lisp_Object r)
1737 if (bigf_sign(XBIGF_DATA(r)) == 0) {
1738 int lsgn = bigz_sign(XBIGZ_DATA(l));
1740 return make_indef(POS_INFINITY);
1742 return make_indef(NEG_INFINITY);
1744 return make_indef(NOT_A_NUMBER);
1747 bigf_set_prec(ent_scratch_bigf, XBIGF_GET_PREC(r));
1748 bigf_set_bigz(ent_scratch_bigf, XBIGZ_DATA(l));
1749 bigf_div(ent_scratch_bigf, ent_scratch_bigf, XBIGF_DATA(r));
1750 return make_bigf_bf(ent_scratch_bigf);
1753 ent_div_BIGF_T_BIGQ_T(Lisp_Object l, Lisp_Object r)
1755 if (bigq_sign(XBIGQ_DATA(r)) == 0) {
1756 int lsgn = bigf_sign(XBIGF_DATA(l));
1758 return make_indef(POS_INFINITY);
1760 return make_indef(NEG_INFINITY);
1762 return make_indef(NOT_A_NUMBER);
1765 bigf_set_prec(ent_scratch_bigf, XBIGF_GET_PREC(l));
1766 bigf_set_bigq(ent_scratch_bigf, XBIGQ_DATA(r));
1767 bigf_div(ent_scratch_bigf, XBIGF_DATA(l), ent_scratch_bigf);
1768 return make_bigf_bf(ent_scratch_bigf);
1771 ent_div_BIGQ_T_BIGF_T(Lisp_Object l, Lisp_Object r)
1773 if (bigf_sign(XBIGF_DATA(r)) == 0) {
1774 int lsgn = bigq_sign(XBIGQ_DATA(l));
1776 return make_indef(POS_INFINITY);
1778 return make_indef(NEG_INFINITY);
1780 return make_indef(NOT_A_NUMBER);
1783 bigf_set_prec(ent_scratch_bigf, XBIGF_GET_PREC(r));
1784 bigf_set_bigq(ent_scratch_bigf, XBIGQ_DATA(l));
1785 bigf_div(ent_scratch_bigf, ent_scratch_bigf, XBIGF_DATA(r));
1786 return make_bigf_bf(ent_scratch_bigf);
1790 ent_div_BIGF_T_FLOAT_T(Lisp_Object l, Lisp_Object r)
1792 if (XFLOAT_DATA(r) == 0.0f) {
1793 int lsgn = bigf_sign(XBIGF_DATA(l));
1795 return make_indef(POS_INFINITY);
1797 return make_indef(NEG_INFINITY);
1799 return make_indef(NOT_A_NUMBER);
1802 bigf_set_prec(ent_scratch_bigf, XBIGF_GET_PREC(l));
1803 bigf_set_fpfloat(ent_scratch_bigf, XFLOAT_DATA(r));
1804 bigf_div(ent_scratch_bigf, XBIGF_DATA(l), ent_scratch_bigf);
1805 return make_bigf_bf(ent_scratch_bigf);
1808 ent_div_FLOAT_T_BIGF_T(Lisp_Object l, Lisp_Object r)
1810 if (bigf_sign(XBIGF_DATA(r)) == 0) {
1811 if (XFLOAT_DATA(l) > 0.0f)
1812 return make_indef(POS_INFINITY);
1813 else if (XFLOAT_DATA(l) < 0.0f)
1814 return make_indef(NEG_INFINITY);
1816 return make_indef(NOT_A_NUMBER);
1819 bigf_set_prec(ent_scratch_bigf, XBIGF_GET_PREC(r));
1820 bigf_set_fpfloat(ent_scratch_bigf, XFLOAT_DATA(l));
1821 bigf_div(ent_scratch_bigf, ent_scratch_bigf, XBIGF_DATA(r));
1822 return make_bigf_bf(ent_scratch_bigf);
1827 ent_inv_BIGF_T(Lisp_Object r)
1829 if (bigf_sign(XBIGF_DATA(r)) == 0) {
1830 return make_indef(POS_INFINITY);
1832 bigf_set_long(ent_scratch_bigf, 1L);
1833 bigf_set_prec(ent_scratch_bigf, XBIGF_GET_PREC(r));
1834 bigf_div(ent_scratch_bigf, ent_scratch_bigf, XBIGF_DATA(r));
1835 return make_bigf_bf(ent_scratch_bigf);
1839 ent_rem_BIGF_T(Lisp_Object unused, Lisp_Object r)
1841 return Qent_mpf_zero;;
1845 ent_mod_BIGF_T(Lisp_Object l, Lisp_Object r)
1847 if (bigf_sign(XBIGF_DATA(r)) == 0) {
1848 return Qent_mpf_zero;;
1850 bigf_set_prec(ent_scratch_bigf,
1851 max(XBIGF_GET_PREC(l), XBIGF_GET_PREC(r)));
1852 bigf_div(ent_scratch_bigf, XBIGF_DATA(l), XBIGF_DATA(r));
1853 bigf_trunc(ent_scratch_bigf, ent_scratch_bigf);
1854 bigf_mul(ent_scratch_bigf, ent_scratch_bigf, XBIGF_DATA(r));
1855 bigf_sub(ent_scratch_bigf, XBIGF_DATA(l), ent_scratch_bigf);
1856 return make_bigf_bf(ent_scratch_bigf);
1858 #if defined(bigf_pow)
1860 ent_pow_BIGF_T_integer_trivial(Lisp_Object l, Lisp_Object r)
1862 if (bigf_to_fpfloat(XBIGF_DATA(l)) == 1.0f) {
1864 } else if (bigf_to_fpfloat(XBIGF_DATA(l)) == -1.0f) {
1865 if (!NILP(Fevenp(r)))
1866 return Qent_mpf_one;
1869 } else if (ent_mpf_zerop(l)) {
1870 /* actually only idiots want to compute 0-powers
1871 * think I put a sleep(10) here to pretend that we're
1872 * working rilly hard to solve that problem */
1873 if (ent_unrel_zerop(r))
1874 return Qent_mpf_one;
1876 return Qent_mpf_zero;
1878 return Qnull_pointer;
1882 ent_pow_BIGF_T_integer(Lisp_Object l, Lisp_Object r)
1884 unsigned long expo = 0;
1888 if ((result = ent_pow_BIGF_T_integer_trivial(l, r)))
1891 if (NILP(Fnonnegativep(r))) {
1892 return ent_unop_inv(
1893 ent_pow_BIGF_T_integer(l, ent_unop_neg(r)));
1898 } else if (BIGZP(r)) {
1899 if (bigz_fits_ulong_p(XBIGZ_DATA(r)))
1900 expo = bigz_to_ulong(XBIGZ_DATA(r));
1902 Fsignal(Qrange_error, list1(r));
1904 Fsignal(Qoperation_error, list1(r));
1908 bigf_set_prec(ent_scratch_bigf, XBIGF_GET_PREC(l));
1909 bigf_pow(ent_scratch_bigf, XBIGF_DATA(l), expo);
1910 return make_bigf_bf(ent_scratch_bigf);
1916 ent_lt_bigf(Lisp_Object l, Lisp_Object r)
1918 return (bigf_lt(XBIGF_DATA(l), XBIGF_DATA(r)));
1921 ent_lt_bigf_int(Lisp_Object l, Lisp_Object r)
1923 bigf_set_long(ent_scratch_bigf, ent_int(r));
1924 return (bigf_lt(XBIGF_DATA(l), ent_scratch_bigf));
1927 ent_lt_int_bigf(Lisp_Object l, Lisp_Object r)
1929 bigf_set_long(ent_scratch_bigf, ent_int(l));
1930 return (bigf_lt(ent_scratch_bigf, XBIGF_DATA(r)));
1933 ent_lt_bigf_bigz(Lisp_Object l, Lisp_Object r)
1935 bigf_set_bigz(ent_scratch_bigf, XBIGZ_DATA(r));
1936 return (bigf_lt(XBIGF_DATA(l), ent_scratch_bigf));
1939 ent_lt_bigz_bigf(Lisp_Object l, Lisp_Object r)
1941 bigf_set_bigz(ent_scratch_bigf, XBIGZ_DATA(l));
1942 return (bigf_lt(ent_scratch_bigf, XBIGF_DATA(r)));
1945 ent_lt_bigf_bigq(Lisp_Object l, Lisp_Object r)
1947 bigf_set_bigq(ent_scratch_bigf, XBIGQ_DATA(r));
1948 return (bigf_lt(XBIGF_DATA(l), ent_scratch_bigf));
1951 ent_lt_bigq_bigf(Lisp_Object l, Lisp_Object r)
1953 bigf_set_bigq(ent_scratch_bigf, XBIGQ_DATA(l));
1954 return (bigf_lt(ent_scratch_bigf, XBIGF_DATA(r)));
1958 ent_lt_bigf_fpfloat(Lisp_Object l, Lisp_Object r)
1960 bigf_set_fpfloat(ent_scratch_bigf, XFLOAT_DATA(r));
1961 return (bigf_lt(XBIGF_DATA(l), ent_scratch_bigf));
1964 ent_lt_fpfloat_bigf(Lisp_Object l, Lisp_Object r)
1966 bigf_set_fpfloat(ent_scratch_bigf, XFLOAT_DATA(l));
1967 return (bigf_lt(ent_scratch_bigf, XBIGF_DATA(r)));
1972 ent_gt_bigf(Lisp_Object l, Lisp_Object r)
1974 return (bigf_gt(XBIGF_DATA(l), XBIGF_DATA(r)));
1977 ent_gt_bigf_int(Lisp_Object l, Lisp_Object r)
1979 bigf_set_long(ent_scratch_bigf, ent_int(r));
1980 return (bigf_gt(XBIGF_DATA(l), ent_scratch_bigf));
1983 ent_gt_int_bigf(Lisp_Object l, Lisp_Object r)
1985 bigf_set_long(ent_scratch_bigf, ent_int(l));
1986 return (bigf_gt(ent_scratch_bigf, XBIGF_DATA(r)));
1989 ent_gt_bigf_bigz(Lisp_Object l, Lisp_Object r)
1991 bigf_set_bigz(ent_scratch_bigf, XBIGZ_DATA(r));
1992 return (bigf_gt(XBIGF_DATA(l), ent_scratch_bigf));
1995 ent_gt_bigz_bigf(Lisp_Object l, Lisp_Object r)
1997 bigf_set_bigz(ent_scratch_bigf, XBIGZ_DATA(l));
1998 return (bigf_gt(ent_scratch_bigf, XBIGF_DATA(r)));
2001 ent_gt_bigf_bigq(Lisp_Object l, Lisp_Object r)
2003 bigf_set_bigq(ent_scratch_bigf, XBIGQ_DATA(r));
2004 return (bigf_gt(XBIGF_DATA(l), ent_scratch_bigf));
2007 ent_gt_bigq_bigf(Lisp_Object l, Lisp_Object r)
2009 bigf_set_bigq(ent_scratch_bigf, XBIGQ_DATA(l));
2010 return (bigf_gt(ent_scratch_bigf, XBIGF_DATA(r)));
2014 ent_gt_bigf_fpfloat(Lisp_Object l, Lisp_Object r)
2016 bigf_set_fpfloat(ent_scratch_bigf, XFLOAT_DATA(r));
2017 return (bigf_gt(XBIGF_DATA(l), ent_scratch_bigf));
2020 ent_gt_fpfloat_bigf(Lisp_Object l, Lisp_Object r)
2022 bigf_set_fpfloat(ent_scratch_bigf, XFLOAT_DATA(l));
2023 return (bigf_gt(ent_scratch_bigf, XBIGF_DATA(r)));
2028 ent_eq_bigf(Lisp_Object l, Lisp_Object r)
2030 return (bigf_eq(XBIGF_DATA(l), XBIGF_DATA(r)));
2033 ent_eq_bigf_int(Lisp_Object l, Lisp_Object r)
2035 bigf_set_long(ent_scratch_bigf, ent_int(r));
2036 return (bigf_eq(XBIGF_DATA(l), ent_scratch_bigf));
2039 ent_eq_int_bigf(Lisp_Object l, Lisp_Object r)
2041 return ent_eq_bigf_int(r, l);
2044 ent_eq_bigf_bigz(Lisp_Object l, Lisp_Object r)
2046 bigf_set_bigz(ent_scratch_bigf, XBIGZ_DATA(r));
2047 return (bigf_eq(XBIGF_DATA(l), ent_scratch_bigf));
2050 ent_eq_bigz_bigf(Lisp_Object l, Lisp_Object r)
2052 return ent_eq_bigf_bigz(r, l);
2055 ent_eq_bigf_bigq(Lisp_Object l, Lisp_Object r)
2057 bigf_set_bigq(ent_scratch_bigf, XBIGQ_DATA(r));
2058 return (bigf_eq(XBIGF_DATA(l), ent_scratch_bigf));
2061 ent_eq_bigq_bigf(Lisp_Object l, Lisp_Object r)
2063 return ent_eq_bigf_bigq(r, l);
2067 ent_eq_bigf_fpfloat(Lisp_Object l, Lisp_Object r)
2069 bigf_set_fpfloat(ent_scratch_bigf, XFLOAT_DATA(r));
2070 return (bigf_eq(XBIGF_DATA(l), ent_scratch_bigf));
2073 ent_eq_fpfloat_bigf(Lisp_Object l, Lisp_Object r)
2075 bigf_set_fpfloat(ent_scratch_bigf, XFLOAT_DATA(l));
2076 return (bigf_eq(ent_scratch_bigf, XBIGF_DATA(r)));
2081 ent_ne_bigf(Lisp_Object l, Lisp_Object r)
2083 return !(bigf_eq(XBIGF_DATA(l), XBIGF_DATA(r)));
2086 ent_ne_bigf_int(Lisp_Object l, Lisp_Object r)
2088 bigf_set_long(ent_scratch_bigf, ent_int(r));
2089 return !(bigf_eq(XBIGF_DATA(l), ent_scratch_bigf));
2092 ent_ne_int_bigf(Lisp_Object l, Lisp_Object r)
2094 return ent_ne_bigf_int(r, l);
2097 ent_ne_bigf_bigz(Lisp_Object l, Lisp_Object r)
2099 bigf_set_bigz(ent_scratch_bigf, XBIGZ_DATA(r));
2100 return !(bigf_eq(XBIGF_DATA(l), ent_scratch_bigf));
2103 ent_ne_bigz_bigf(Lisp_Object l, Lisp_Object r)
2105 return ent_ne_bigf_bigz(r, l);
2108 ent_ne_bigf_bigq(Lisp_Object l, Lisp_Object r)
2110 bigf_set_bigq(ent_scratch_bigf, XBIGQ_DATA(r));
2111 return !(bigf_eq(XBIGF_DATA(l), ent_scratch_bigf));
2114 ent_ne_bigq_bigf(Lisp_Object l, Lisp_Object r)
2116 return ent_ne_bigf_bigq(r, l);
2120 ent_ne_bigf_fpfloat(Lisp_Object l, Lisp_Object r)
2122 bigf_set_fpfloat(ent_scratch_bigf, XFLOAT_DATA(r));
2123 return !(bigf_eq(XBIGF_DATA(l), ent_scratch_bigf));
2126 ent_ne_fpfloat_bigf(Lisp_Object l, Lisp_Object r)
2128 bigf_set_fpfloat(ent_scratch_bigf, XFLOAT_DATA(l));
2129 return !(bigf_eq(ent_scratch_bigf, XBIGF_DATA(r)));
2135 ent_lift_INT_T_BIGF_T(Lisp_Object number, ent_lift_args_t la)
2137 unsigned long precision = la->precision;
2139 return make_bigf(ent_int(number), precision);
2143 ent_lift_BIGF_T_INT_T(Lisp_Object number, ent_lift_args_t SXE_UNUSED(la))
2145 return make_int(bigf_to_long(XBIGF_DATA(number)));
2149 ent_lift_BIGZ_T_BIGF_T(Lisp_Object number, ent_lift_args_t la)
2151 unsigned long precision = la->precision;
2153 bigf_set_prec(ent_scratch_bigf, precision);
2154 bigf_set_bigz(ent_scratch_bigf, XBIGZ_DATA(number));
2155 return make_bigf_bf(ent_scratch_bigf);
2159 ent_lift_BIGF_T_BIGZ_T(Lisp_Object number, ent_lift_args_t SXE_UNUSED(la))
2161 bigz_set_bigf(ent_scratch_bigz, XBIGF_DATA(number));
2162 return make_bigz_bz(ent_scratch_bigz);
2166 ent_lift_BIGQ_T_BIGF_T(Lisp_Object number, ent_lift_args_t la)
2168 unsigned long precision = la->precision;
2170 bigf_set_prec(ent_scratch_bigf, precision);
2171 bigf_set_bigq(ent_scratch_bigf, XBIGQ_DATA(number));
2172 return make_bigf_bf(ent_scratch_bigf);
2176 ent_lift_BIGF_T_BIGQ_T(Lisp_Object number, ent_lift_args_t SXE_UNUSED(la))
2178 bigq_set_bigf(ent_scratch_bigq, XBIGF_DATA(number));
2179 return make_bigq_bq(ent_scratch_bigq);
2184 ent_lift_FLOAT_T_BIGF_T(Lisp_Object number, ent_lift_args_t la)
2186 unsigned long precision = la->precision;
2188 bigf_set_prec(ent_scratch_bigf, precision);
2189 bigf_set_fpfloat(ent_scratch_bigf, XFLOAT_DATA(number));
2190 return make_bigf_bf(ent_scratch_bigf);
2194 ent_lift_BIGF_T_FLOAT_T(Lisp_Object number, ent_lift_args_t SXE_UNUSED(la))
2196 /* can result in an indef object */
2197 return make_float(bigf_to_fpfloat(XBIGF_DATA(number)));
2202 ent_lift_BIGF_T_BIGF_T(Lisp_Object number, ent_lift_args_t la)
2204 unsigned long precision = la->precision;
2206 bigf_set_prec(ent_scratch_bigf, precision);
2207 bigf_set(ent_scratch_bigf, XBIGF_DATA(number));
2208 return make_bigf_bf(ent_scratch_bigf);
2213 ent_mpz_nullary_optable_init(void)
2215 Qent_mpz_zero = make_bigz(0L);
2216 Qent_mpz_one = make_bigz(1L);
2217 staticpro(&Qent_mpz_zero);
2218 staticpro(&Qent_mpz_one);
2220 ent_nullop_register(ASE_NULLARY_OP_ZERO, BIGZ_T, Qent_mpz_zero);
2221 ent_nullop_register(ASE_NULLARY_OP_ONE, BIGZ_T, Qent_mpz_one);
2225 ent_mpz_unary_optable_init(void)
2227 ent_unop_register(ASE_UNARY_OP_NEG, BIGZ_T, ent_neg_BIGZ_T);
2228 ent_unop_register(ASE_UNARY_OP_INV, BIGZ_T, ent_inv_BIGZ_T);
2232 ent_mpz_binary_optable_init(void)
2234 ent_binop_register(ASE_BINARY_OP_SUM,
2235 BIGZ_T, BIGZ_T, ent_sum_BIGZ_T);
2236 ent_binop_register(ASE_BINARY_OP_SUM,
2237 BIGZ_T, INT_T, ent_sum_BIGZ_T_INT_T);
2238 ent_binop_register(ASE_BINARY_OP_SUM,
2239 INT_T, BIGZ_T, ent_sum_INT_T_BIGZ_T);
2241 ent_binop_register(ASE_BINARY_OP_SUM,
2242 FLOAT_T, BIGZ_T, ent_sum_FLOAT_T_BIGZ_T);
2243 ent_binop_register(ASE_BINARY_OP_SUM,
2244 BIGZ_T, FLOAT_T, ent_sum_BIGZ_T_FLOAT_T);
2247 ent_binop_register(ASE_BINARY_OP_DIFF,
2248 BIGZ_T, BIGZ_T, ent_diff_BIGZ_T);
2249 ent_binop_register(ASE_BINARY_OP_DIFF,
2250 BIGZ_T, INT_T, ent_diff_BIGZ_T_INT_T);
2251 ent_binop_register(ASE_BINARY_OP_DIFF,
2252 INT_T, BIGZ_T, ent_diff_INT_T_BIGZ_T);
2254 ent_binop_register(ASE_BINARY_OP_DIFF,
2255 FLOAT_T, BIGZ_T, ent_diff_FLOAT_T_BIGZ_T);
2256 ent_binop_register(ASE_BINARY_OP_DIFF,
2257 BIGZ_T, FLOAT_T, ent_diff_BIGZ_T_FLOAT_T);
2260 ent_binop_register(ASE_BINARY_OP_PROD,
2261 BIGZ_T, BIGZ_T, ent_prod_BIGZ_T);
2262 ent_binop_register(ASE_BINARY_OP_PROD,
2263 BIGZ_T, INT_T, ent_prod_BIGZ_T_INT_T);
2264 ent_binop_register(ASE_BINARY_OP_PROD,
2265 INT_T, BIGZ_T, ent_prod_INT_T_BIGZ_T);
2267 ent_binop_register(ASE_BINARY_OP_PROD,
2268 FLOAT_T, BIGZ_T, ent_prod_FLOAT_T_BIGZ_T);
2269 ent_binop_register(ASE_BINARY_OP_PROD,
2270 BIGZ_T, FLOAT_T, ent_prod_BIGZ_T_FLOAT_T);
2273 ent_binop_register(ASE_BINARY_OP_DIV,
2274 BIGZ_T, BIGZ_T, ent_div_BIGZ_T);
2275 ent_binop_register(ASE_BINARY_OP_DIV,
2276 BIGZ_T, INT_T, ent_div_BIGZ_T_INT_T);
2277 ent_binop_register(ASE_BINARY_OP_DIV,
2278 INT_T, BIGZ_T, ent_div_INT_T_BIGZ_T);
2280 ent_binop_register(ASE_BINARY_OP_DIV,
2281 FLOAT_T, BIGZ_T, ent_div_FLOAT_T_BIGZ_T);
2282 ent_binop_register(ASE_BINARY_OP_DIV,
2283 BIGZ_T, FLOAT_T, ent_div_BIGZ_T_FLOAT_T);
2286 ent_binop_register(ASE_BINARY_OP_QUO,
2287 BIGZ_T, BIGZ_T, ent_quo_BIGZ_T);
2288 ent_binop_register(ASE_BINARY_OP_QUO,
2289 BIGZ_T, INT_T, ent_quo_BIGZ_T_INT_T);
2290 ent_binop_register(ASE_BINARY_OP_QUO,
2291 INT_T, BIGZ_T, ent_quo_INT_T_BIGZ_T);
2293 ent_binop_register(ASE_BINARY_OP_QUO,
2294 FLOAT_T, BIGZ_T, ent_div_FLOAT_T_BIGZ_T);
2295 ent_binop_register(ASE_BINARY_OP_QUO,
2296 BIGZ_T, FLOAT_T, ent_div_BIGZ_T_FLOAT_T);
2300 ent_binop_register(ASE_BINARY_OP_REM,
2301 BIGZ_T, BIGZ_T, ent_rem_BIGZ_T);
2302 ent_binop_register(ASE_BINARY_OP_REM,
2303 BIGZ_T, INT_T, ent_rem_BIGZ_T_INT_T);
2304 ent_binop_register(ASE_BINARY_OP_REM,
2305 INT_T, BIGZ_T, ent_rem_INT_T_BIGZ_T);
2306 ent_binop_register(ASE_BINARY_OP_MOD,
2307 BIGZ_T, BIGZ_T, ent_rem_BIGZ_T);
2308 ent_binop_register(ASE_BINARY_OP_MOD,
2309 BIGZ_T, INT_T, ent_rem_BIGZ_T_INT_T);
2310 ent_binop_register(ASE_BINARY_OP_MOD,
2311 INT_T, BIGZ_T, ent_rem_INT_T_BIGZ_T);
2314 ent_binop_register(ASE_BINARY_OP_POW,
2315 INT_T, INT_T, ent_pow_integer_integer);
2316 ent_binop_register(ASE_BINARY_OP_POW,
2317 INT_T, BIGZ_T, ent_pow_integer_integer);
2318 ent_binop_register(ASE_BINARY_OP_POW,
2319 BIGZ_T, INT_T, ent_pow_integer_integer);
2320 ent_binop_register(ASE_BINARY_OP_POW,
2321 BIGZ_T, BIGZ_T, ent_pow_integer_integer);
2325 ent_mpz_unary_reltable_init(void)
2327 ent_unrel_register(ASE_UNARY_REL_ZEROP, BIGZ_T, ent_mpz_zerop);
2328 ent_unrel_register(ASE_UNARY_REL_ONEP, BIGZ_T, ent_mpz_onep);
2329 ent_unrel_register(ASE_UNARY_REL_UNITP, BIGZ_T, ent_mpz_unitp);
2333 ent_mpz_binary_reltable_init(void)
2335 ent_binrel_register(ASE_BINARY_REL_LESSP,
2336 BIGZ_T, BIGZ_T, ent_lt_bigz);
2337 ent_binrel_register(ASE_BINARY_REL_GREATERP,
2338 BIGZ_T, BIGZ_T, ent_gt_bigz);
2339 ent_binrel_register(ASE_BINARY_REL_EQUALP,
2340 BIGZ_T, BIGZ_T, ent_eq_bigz);
2341 ent_binrel_register(ASE_BINARY_REL_NEQP,
2342 BIGZ_T, BIGZ_T, ent_ne_bigz);
2344 ent_binrel_register(ASE_BINARY_REL_LESSP,
2345 BIGZ_T, INT_T, ent_lt_bigz_int);
2346 ent_binrel_register(ASE_BINARY_REL_GREATERP,
2347 BIGZ_T, INT_T, ent_gt_bigz_int);
2348 ent_binrel_register(ASE_BINARY_REL_EQUALP,
2349 BIGZ_T, INT_T, ent_eq_bigz_int);
2350 ent_binrel_register(ASE_BINARY_REL_NEQP,
2351 BIGZ_T, INT_T, ent_ne_bigz_int);
2353 ent_binrel_register(ASE_BINARY_REL_LESSP,
2354 INT_T, BIGZ_T, ent_lt_int_bigz);
2355 ent_binrel_register(ASE_BINARY_REL_GREATERP,
2356 INT_T, BIGZ_T, ent_gt_int_bigz);
2357 ent_binrel_register(ASE_BINARY_REL_EQUALP,
2358 INT_T, BIGZ_T, ent_eq_int_bigz);
2359 ent_binrel_register(ASE_BINARY_REL_NEQP,
2360 INT_T, BIGZ_T, ent_ne_int_bigz);
2363 ent_binrel_register(ASE_BINARY_REL_LESSP,
2364 BIGZ_T, FLOAT_T, ent_lt_bigzq_float);
2365 ent_binrel_register(ASE_BINARY_REL_GREATERP,
2366 BIGZ_T, FLOAT_T, ent_gt_bigzq_float);
2367 ent_binrel_register(ASE_BINARY_REL_EQUALP,
2368 BIGZ_T, FLOAT_T, ent_eq_bigzq_float);
2369 ent_binrel_register(ASE_BINARY_REL_NEQP,
2370 BIGZ_T, FLOAT_T, ent_ne_bigzq_float);
2372 ent_binrel_register(ASE_BINARY_REL_LESSP,
2373 FLOAT_T, BIGZ_T, ent_lt_float_bigzq);
2374 ent_binrel_register(ASE_BINARY_REL_GREATERP,
2375 FLOAT_T, BIGZ_T, ent_gt_float_bigzq);
2376 ent_binrel_register(ASE_BINARY_REL_EQUALP,
2377 FLOAT_T, BIGZ_T, ent_eq_float_bigzq);
2378 ent_binrel_register(ASE_BINARY_REL_NEQP,
2379 FLOAT_T, BIGZ_T, ent_ne_float_bigzq);
2384 ent_mpz_lifttable_init(void)
2386 ent_lift_register(BIGZ_T, INT_T, _ent_lift_BIGZ_T_INT_T);
2387 ent_lift_register(INT_T, BIGZ_T, _ent_lift_INT_T_BIGZ_T);
2389 ent_lift_register(BIGZ_T, FLOAT_T, _ent_lift_BIGZ_T_FLOAT_T);
2390 ent_lift_register(FLOAT_T, BIGZ_T, _ent_lift_FLOAT_T_BIGZ_T);
2392 ent_lift_register(INDEF_T, BIGZ_T, ent_lift_INDEF_T_COMPARABLE);
2395 void init_optables_BIGZ_T (void)
2397 ent_mpz_nullary_optable_init();
2398 ent_mpz_unary_optable_init();
2399 ent_mpz_binary_optable_init();
2400 ent_mpz_unary_reltable_init();
2401 ent_mpz_binary_reltable_init();
2402 ent_mpz_lifttable_init();
2407 ent_mpq_nullary_optable_init(void)
2409 Qent_mpq_zero = make_bigq(0L, 1L);
2410 Qent_mpq_one = make_bigq(1L, 1L);
2411 staticpro(&Qent_mpq_zero);
2412 staticpro(&Qent_mpq_one);
2414 ent_nullop_register(ASE_NULLARY_OP_ZERO, BIGQ_T, Qent_mpq_zero);
2415 ent_nullop_register(ASE_NULLARY_OP_ONE, BIGQ_T, Qent_mpq_one);
2419 ent_mpq_unary_optable_init(void)
2421 ent_unop_register(ASE_UNARY_OP_NEG, BIGQ_T, ent_neg_BIGQ_T);
2422 ent_unop_register(ASE_UNARY_OP_INV, BIGQ_T, ent_inv_BIGQ_T);
2423 ent_unop_register(ASE_UNARY_OP_INV, INT_T, ent_inv_INT_T);
2427 ent_mpq_binary_optable_init(void)
2430 ent_binop_register(ASE_BINARY_OP_SUM,
2431 BIGQ_T, BIGQ_T, ent_sum_BIGQ_T);
2432 ent_binop_register(ASE_BINARY_OP_SUM,
2433 BIGQ_T, INT_T, ent_sum_BIGQ_T_INT_T);
2434 ent_binop_register(ASE_BINARY_OP_SUM,
2435 INT_T, BIGQ_T, ent_sum_INT_T_BIGQ_T);
2436 ent_binop_register(ASE_BINARY_OP_SUM,
2437 BIGQ_T, BIGZ_T, ent_sum_BIGQ_T_BIGZ_T);
2438 ent_binop_register(ASE_BINARY_OP_SUM,
2439 BIGZ_T, BIGQ_T, ent_sum_BIGZ_T_BIGQ_T);
2441 ent_binop_register(ASE_BINARY_OP_SUM,
2442 FLOAT_T, BIGQ_T, ent_sum_FLOAT_T_BIGQ_T);
2443 ent_binop_register(ASE_BINARY_OP_SUM,
2444 BIGQ_T, FLOAT_T, ent_sum_BIGQ_T_FLOAT_T);
2447 ent_binop_register(ASE_BINARY_OP_DIFF,
2448 BIGQ_T, BIGQ_T, ent_diff_BIGQ_T);
2449 ent_binop_register(ASE_BINARY_OP_DIFF,
2450 BIGQ_T, INT_T, ent_diff_BIGQ_T_INT_T);
2451 ent_binop_register(ASE_BINARY_OP_DIFF,
2452 INT_T, BIGQ_T, ent_diff_INT_T_BIGQ_T);
2453 ent_binop_register(ASE_BINARY_OP_DIFF,
2454 BIGQ_T, BIGZ_T, ent_diff_BIGQ_T_BIGZ_T);
2455 ent_binop_register(ASE_BINARY_OP_DIFF,
2456 BIGZ_T, BIGQ_T, ent_diff_BIGZ_T_BIGQ_T);
2458 ent_binop_register(ASE_BINARY_OP_DIFF,
2459 FLOAT_T, BIGQ_T, ent_diff_FLOAT_T_BIGQ_T);
2460 ent_binop_register(ASE_BINARY_OP_DIFF,
2461 BIGQ_T, FLOAT_T, ent_diff_BIGQ_T_FLOAT_T);
2465 ent_binop_register(ASE_BINARY_OP_PROD,
2466 BIGQ_T, BIGQ_T, ent_prod_BIGQ_T);
2467 ent_binop_register(ASE_BINARY_OP_PROD,
2468 BIGQ_T, INT_T, ent_prod_BIGQ_T_INT_T);
2469 ent_binop_register(ASE_BINARY_OP_PROD,
2470 INT_T, BIGQ_T, ent_prod_INT_T_BIGQ_T);
2471 ent_binop_register(ASE_BINARY_OP_PROD,
2472 BIGQ_T, BIGZ_T, ent_prod_BIGQ_T_BIGZ_T);
2473 ent_binop_register(ASE_BINARY_OP_PROD,
2474 BIGZ_T, BIGQ_T, ent_prod_BIGZ_T_BIGQ_T);
2476 ent_binop_register(ASE_BINARY_OP_PROD,
2477 FLOAT_T, BIGQ_T, ent_prod_FLOAT_T_BIGQ_T);
2478 ent_binop_register(ASE_BINARY_OP_PROD,
2479 BIGQ_T, FLOAT_T, ent_prod_BIGQ_T_FLOAT_T);
2482 ent_binop_register(ASE_BINARY_OP_DIV,
2483 BIGQ_T, BIGQ_T, ent_div_BIGQ_T);
2484 ent_binop_register(ASE_BINARY_OP_DIV,
2485 BIGQ_T, INT_T, ent_div_BIGQ_T_INT_T);
2486 ent_binop_register(ASE_BINARY_OP_DIV,
2487 INT_T, BIGQ_T, ent_div_INT_T_BIGQ_T);
2488 ent_binop_register(ASE_BINARY_OP_DIV,
2489 BIGQ_T, BIGZ_T, ent_div_BIGQ_T_BIGZ_T);
2490 ent_binop_register(ASE_BINARY_OP_DIV,
2491 BIGZ_T, BIGQ_T, ent_div_BIGZ_T_BIGQ_T);
2493 ent_binop_register(ASE_BINARY_OP_DIV,
2494 FLOAT_T, BIGQ_T, ent_div_FLOAT_T_BIGQ_T);
2495 ent_binop_register(ASE_BINARY_OP_DIV,
2496 BIGQ_T, FLOAT_T, ent_div_BIGQ_T_FLOAT_T);
2499 ent_binop_register(ASE_BINARY_OP_QUO,
2500 INT_T, INT_T, ent_quo_INT_T);
2501 ent_binop_register(ASE_BINARY_OP_QUO,
2502 BIGQ_T, BIGQ_T, ent_div_BIGQ_T);
2503 ent_binop_register(ASE_BINARY_OP_QUO,
2504 BIGQ_T, INT_T, ent_div_BIGQ_T_INT_T);
2505 ent_binop_register(ASE_BINARY_OP_QUO,
2506 INT_T, BIGQ_T, ent_div_INT_T_BIGQ_T);
2507 ent_binop_register(ASE_BINARY_OP_QUO,
2508 BIGQ_T, BIGZ_T, ent_div_BIGQ_T_BIGZ_T);
2509 ent_binop_register(ASE_BINARY_OP_QUO,
2510 BIGZ_T, BIGQ_T, ent_div_BIGZ_T_BIGQ_T);
2512 ent_binop_register(ASE_BINARY_OP_QUO,
2513 FLOAT_T, BIGQ_T, ent_div_FLOAT_T_BIGQ_T);
2514 ent_binop_register(ASE_BINARY_OP_QUO,
2515 BIGQ_T, FLOAT_T, ent_div_BIGQ_T_FLOAT_T);
2519 ent_binop_register(ASE_BINARY_OP_REM,
2520 BIGQ_T, BIGQ_T, ent_rem_BIGQ_T);
2521 ent_binop_register(ASE_BINARY_OP_MOD,
2522 BIGQ_T, BIGQ_T, ent_mod_BIGQ_T);
2523 ent_binop_register(ASE_BINARY_OP_POW,
2524 BIGQ_T, INT_T, ent_pow_BIGQ_T_integer);
2525 ent_binop_register(ASE_BINARY_OP_POW,
2526 BIGQ_T, BIGZ_T, ent_pow_BIGQ_T_integer);
2530 ent_mpq_unary_reltable_init(void)
2532 ent_unrel_register(ASE_UNARY_REL_ZEROP, BIGQ_T, ent_mpq_zerop);
2533 ent_unrel_register(ASE_UNARY_REL_ONEP, BIGQ_T, ent_mpq_onep);
2534 ent_unrel_register(ASE_UNARY_REL_UNITP, BIGQ_T, ent_mpq_unitp);
2538 ent_mpq_binary_reltable_init(void)
2540 ent_binrel_register(ASE_BINARY_REL_LESSP,
2541 BIGQ_T, BIGQ_T, ent_lt_bigq);
2542 ent_binrel_register(ASE_BINARY_REL_GREATERP,
2543 BIGQ_T, BIGQ_T, ent_gt_bigq);
2544 ent_binrel_register(ASE_BINARY_REL_EQUALP,
2545 BIGQ_T, BIGQ_T, ent_eq_bigq);
2546 ent_binrel_register(ASE_BINARY_REL_NEQP,
2547 BIGQ_T, BIGQ_T, ent_ne_bigq);
2549 ent_binrel_register(ASE_BINARY_REL_LESSP,
2550 BIGQ_T, INT_T, ent_lt_bigq_int);
2551 ent_binrel_register(ASE_BINARY_REL_GREATERP,
2552 BIGQ_T, INT_T, ent_gt_bigq_int);
2553 ent_binrel_register(ASE_BINARY_REL_EQUALP,
2554 BIGQ_T, INT_T, ent_eq_bigq_int);
2555 ent_binrel_register(ASE_BINARY_REL_NEQP,
2556 BIGQ_T, INT_T, ent_ne_bigq_int);
2558 ent_binrel_register(ASE_BINARY_REL_LESSP,
2559 INT_T, BIGQ_T, ent_lt_int_bigq);
2560 ent_binrel_register(ASE_BINARY_REL_GREATERP,
2561 INT_T, BIGQ_T, ent_gt_int_bigq);
2562 ent_binrel_register(ASE_BINARY_REL_EQUALP,
2563 INT_T, BIGQ_T, ent_eq_int_bigq);
2564 ent_binrel_register(ASE_BINARY_REL_NEQP,
2565 INT_T, BIGQ_T, ent_ne_int_bigq);
2567 ent_binrel_register(ASE_BINARY_REL_LESSP,
2568 BIGQ_T, BIGZ_T, ent_lt_bigq_bigz);
2569 ent_binrel_register(ASE_BINARY_REL_GREATERP,
2570 BIGQ_T, BIGZ_T, ent_gt_bigq_bigz);
2571 ent_binrel_register(ASE_BINARY_REL_EQUALP,
2572 BIGQ_T, BIGZ_T, ent_eq_bigq_bigz);
2573 ent_binrel_register(ASE_BINARY_REL_NEQP,
2574 BIGQ_T, BIGZ_T, ent_ne_bigq_bigz);
2576 ent_binrel_register(ASE_BINARY_REL_LESSP,
2577 BIGZ_T, BIGQ_T, ent_lt_bigz_bigq);
2578 ent_binrel_register(ASE_BINARY_REL_GREATERP,
2579 BIGZ_T, BIGQ_T, ent_gt_bigz_bigq);
2580 ent_binrel_register(ASE_BINARY_REL_EQUALP,
2581 BIGZ_T, BIGQ_T, ent_eq_bigz_bigq);
2582 ent_binrel_register(ASE_BINARY_REL_NEQP,
2583 BIGZ_T, BIGQ_T, ent_ne_bigz_bigq);
2586 ent_binrel_register(ASE_BINARY_REL_LESSP,
2587 BIGQ_T, FLOAT_T, ent_lt_bigzq_float);
2588 ent_binrel_register(ASE_BINARY_REL_GREATERP,
2589 BIGQ_T, FLOAT_T, ent_gt_bigzq_float);
2590 ent_binrel_register(ASE_BINARY_REL_EQUALP,
2591 BIGQ_T, FLOAT_T, ent_eq_bigzq_float);
2592 ent_binrel_register(ASE_BINARY_REL_NEQP,
2593 BIGQ_T, FLOAT_T, ent_ne_bigzq_float);
2595 ent_binrel_register(ASE_BINARY_REL_LESSP,
2596 FLOAT_T, BIGQ_T, ent_lt_float_bigzq);
2597 ent_binrel_register(ASE_BINARY_REL_GREATERP,
2598 FLOAT_T, BIGQ_T, ent_gt_float_bigzq);
2599 ent_binrel_register(ASE_BINARY_REL_EQUALP,
2600 FLOAT_T, BIGQ_T, ent_eq_float_bigzq);
2601 ent_binrel_register(ASE_BINARY_REL_NEQP,
2602 FLOAT_T, BIGQ_T, ent_ne_float_bigzq);
2607 ent_mpq_lifttable_init(void)
2609 ent_lift_register(BIGQ_T, INT_T, _ent_lift_BIGQ_T_INT_T);
2610 ent_lift_register(INT_T, BIGQ_T, _ent_lift_INT_T_BIGQ_T);
2611 ent_lift_register(BIGQ_T, BIGZ_T, _ent_lift_BIGQ_T_BIGZ_T);
2612 ent_lift_register(BIGZ_T, BIGQ_T, _ent_lift_BIGZ_T_BIGQ_T);
2614 ent_lift_register(BIGQ_T, FLOAT_T, _ent_lift_BIGQ_T_FLOAT_T);
2615 ent_lift_register(FLOAT_T, BIGQ_T, _ent_lift_FLOAT_T_BIGQ_T);
2617 ent_lift_register(INDEF_T, BIGQ_T, ent_lift_INDEF_T_COMPARABLE);
2620 void init_optables_BIGQ_T (void)
2622 ent_mpq_nullary_optable_init();
2623 ent_mpq_unary_optable_init();
2624 ent_mpq_binary_optable_init();
2625 ent_mpq_unary_reltable_init();
2626 ent_mpq_binary_reltable_init();
2627 ent_mpq_lifttable_init();
2632 ent_mpf_nullary_optable_init(void)
2634 Qent_mpf_zero = make_bigf(0.0f, internal_get_precision(Qnil));
2635 Qent_mpf_one = make_bigf(1.0f, internal_get_precision(Qnil));
2636 staticpro(&Qent_mpf_zero);
2637 staticpro(&Qent_mpf_one);
2639 ent_nullop_register(ASE_NULLARY_OP_ZERO, BIGF_T, Qent_mpf_zero);
2640 ent_nullop_register(ASE_NULLARY_OP_ONE, BIGF_T, Qent_mpf_one);
2644 ent_mpf_unary_optable_init(void)
2646 ent_unop_register(ASE_UNARY_OP_NEG, BIGF_T, ent_neg_BIGF_T);
2647 ent_unop_register(ASE_UNARY_OP_INV, BIGF_T, ent_inv_BIGF_T);
2651 ent_mpf_binary_optable_init(void)
2654 ent_binop_register(ASE_BINARY_OP_SUM,
2655 BIGF_T, BIGF_T, ent_sum_BIGF_T);
2656 ent_binop_register(ASE_BINARY_OP_SUM,
2657 BIGF_T, INT_T, ent_sum_BIGF_T_INT_T);
2658 ent_binop_register(ASE_BINARY_OP_SUM,
2659 INT_T, BIGF_T, ent_sum_INT_T_BIGF_T);
2660 ent_binop_register(ASE_BINARY_OP_SUM,
2661 BIGF_T, BIGZ_T, ent_sum_BIGF_T_BIGZ_T);
2662 ent_binop_register(ASE_BINARY_OP_SUM,
2663 BIGZ_T, BIGF_T, ent_sum_BIGZ_T_BIGF_T);
2664 ent_binop_register(ASE_BINARY_OP_SUM,
2665 BIGF_T, BIGQ_T, ent_sum_BIGF_T_BIGQ_T);
2666 ent_binop_register(ASE_BINARY_OP_SUM,
2667 BIGQ_T, BIGF_T, ent_sum_BIGQ_T_BIGF_T);
2669 ent_binop_register(ASE_BINARY_OP_SUM,
2670 BIGF_T, FLOAT_T, ent_sum_BIGF_T_FLOAT_T);
2671 ent_binop_register(ASE_BINARY_OP_SUM,
2672 FLOAT_T, BIGF_T, ent_sum_FLOAT_T_BIGF_T);
2675 ent_binop_register(ASE_BINARY_OP_DIFF,
2676 BIGF_T, BIGF_T, ent_diff_BIGF_T);
2677 ent_binop_register(ASE_BINARY_OP_DIFF,
2678 BIGF_T, INT_T, ent_diff_BIGF_T_INT_T);
2679 ent_binop_register(ASE_BINARY_OP_DIFF,
2680 INT_T, BIGF_T, ent_diff_INT_T_BIGF_T);
2681 ent_binop_register(ASE_BINARY_OP_DIFF,
2682 BIGF_T, BIGZ_T, ent_diff_BIGF_T_BIGZ_T);
2683 ent_binop_register(ASE_BINARY_OP_DIFF,
2684 BIGZ_T, BIGF_T, ent_diff_BIGZ_T_BIGF_T);
2685 ent_binop_register(ASE_BINARY_OP_DIFF,
2686 BIGF_T, BIGQ_T, ent_diff_BIGF_T_BIGQ_T);
2687 ent_binop_register(ASE_BINARY_OP_DIFF,
2688 BIGQ_T, BIGF_T, ent_diff_BIGQ_T_BIGF_T);
2690 ent_binop_register(ASE_BINARY_OP_DIFF,
2691 BIGF_T, FLOAT_T, ent_diff_BIGF_T_FLOAT_T);
2692 ent_binop_register(ASE_BINARY_OP_DIFF,
2693 FLOAT_T, BIGF_T, ent_diff_FLOAT_T_BIGF_T);
2696 ent_binop_register(ASE_BINARY_OP_PROD,
2697 BIGF_T, BIGF_T, ent_prod_BIGF_T);
2698 ent_binop_register(ASE_BINARY_OP_PROD,
2699 BIGF_T, INT_T, ent_prod_BIGF_T_INT_T);
2700 ent_binop_register(ASE_BINARY_OP_PROD,
2701 INT_T, BIGF_T, ent_prod_INT_T_BIGF_T);
2702 ent_binop_register(ASE_BINARY_OP_PROD,
2703 BIGF_T, BIGZ_T, ent_prod_BIGF_T_BIGZ_T);
2704 ent_binop_register(ASE_BINARY_OP_PROD,
2705 BIGZ_T, BIGF_T, ent_prod_BIGZ_T_BIGF_T);
2706 ent_binop_register(ASE_BINARY_OP_PROD,
2707 BIGF_T, BIGQ_T, ent_prod_BIGF_T_BIGQ_T);
2708 ent_binop_register(ASE_BINARY_OP_PROD,
2709 BIGQ_T, BIGF_T, ent_prod_BIGQ_T_BIGF_T);
2711 ent_binop_register(ASE_BINARY_OP_PROD,
2712 BIGF_T, FLOAT_T, ent_prod_BIGF_T_FLOAT_T);
2713 ent_binop_register(ASE_BINARY_OP_PROD,
2714 FLOAT_T, BIGF_T, ent_prod_FLOAT_T_BIGF_T);
2717 /* divisions and quotients */
2718 ent_binop_register(ASE_BINARY_OP_DIV,
2719 BIGF_T, BIGF_T, ent_div_BIGF_T);
2720 ent_binop_register(ASE_BINARY_OP_DIV,
2721 BIGF_T, INT_T, ent_div_BIGF_T_INT_T);
2722 ent_binop_register(ASE_BINARY_OP_DIV,
2723 INT_T, BIGF_T, ent_div_INT_T_BIGF_T);
2724 ent_binop_register(ASE_BINARY_OP_DIV,
2725 BIGF_T, BIGZ_T, ent_div_BIGF_T_BIGZ_T);
2726 ent_binop_register(ASE_BINARY_OP_DIV,
2727 BIGZ_T, BIGF_T, ent_div_BIGZ_T_BIGF_T);
2728 ent_binop_register(ASE_BINARY_OP_DIV,
2729 BIGF_T, BIGQ_T, ent_div_BIGF_T_BIGQ_T);
2730 ent_binop_register(ASE_BINARY_OP_DIV,
2731 BIGQ_T, BIGF_T, ent_div_BIGQ_T_BIGF_T);
2733 ent_binop_register(ASE_BINARY_OP_DIV,
2734 BIGF_T, FLOAT_T, ent_div_BIGF_T_FLOAT_T);
2735 ent_binop_register(ASE_BINARY_OP_DIV,
2736 FLOAT_T, BIGF_T, ent_div_FLOAT_T_BIGF_T);
2738 ent_binop_register(ASE_BINARY_OP_QUO,
2739 BIGF_T, BIGF_T, ent_div_BIGF_T);
2740 ent_binop_register(ASE_BINARY_OP_QUO,
2741 BIGF_T, INT_T, ent_div_BIGF_T_INT_T);
2742 ent_binop_register(ASE_BINARY_OP_QUO,
2743 INT_T, BIGF_T, ent_div_INT_T_BIGF_T);
2744 ent_binop_register(ASE_BINARY_OP_QUO,
2745 BIGF_T, BIGZ_T, ent_div_BIGF_T_BIGZ_T);
2746 ent_binop_register(ASE_BINARY_OP_QUO,
2747 BIGZ_T, BIGF_T, ent_div_BIGZ_T_BIGF_T);
2748 ent_binop_register(ASE_BINARY_OP_QUO,
2749 BIGF_T, BIGQ_T, ent_div_BIGF_T_BIGQ_T);
2750 ent_binop_register(ASE_BINARY_OP_QUO,
2751 BIGQ_T, BIGF_T, ent_div_BIGQ_T_BIGF_T);
2753 ent_binop_register(ASE_BINARY_OP_QUO,
2754 BIGF_T, FLOAT_T, ent_div_BIGF_T_FLOAT_T);
2755 ent_binop_register(ASE_BINARY_OP_QUO,
2756 FLOAT_T, BIGF_T, ent_div_FLOAT_T_BIGF_T);
2759 ent_binop_register(ASE_BINARY_OP_REM,
2760 BIGF_T, BIGF_T, ent_rem_BIGF_T);
2761 ent_binop_register(ASE_BINARY_OP_MOD,
2762 BIGF_T, BIGF_T, ent_mod_BIGF_T);
2764 ent_binop_register(ASE_BINARY_OP_POW,
2765 BIGF_T, INT_T, ent_pow_BIGF_T_integer);
2766 ent_binop_register(ASE_BINARY_OP_POW,
2767 BIGF_T, BIGZ_T, ent_pow_BIGF_T_integer);
2772 ent_mpf_unary_reltable_init(void)
2774 ent_unrel_register(ASE_UNARY_REL_ZEROP, BIGF_T, ent_mpf_zerop);
2775 ent_unrel_register(ASE_UNARY_REL_ONEP, BIGF_T, ent_mpf_onep);
2776 ent_unrel_register(ASE_UNARY_REL_UNITP, BIGF_T, ent_mpf_unitp);
2780 ent_mpf_binary_reltable_init(void)
2782 ent_binrel_register(ASE_BINARY_REL_LESSP,
2783 BIGF_T, BIGF_T, ent_lt_bigf);
2784 ent_binrel_register(ASE_BINARY_REL_GREATERP,
2785 BIGF_T, BIGF_T, ent_gt_bigf);
2786 ent_binrel_register(ASE_BINARY_REL_EQUALP,
2787 BIGF_T, BIGF_T, ent_eq_bigf);
2788 ent_binrel_register(ASE_BINARY_REL_NEQP,
2789 BIGF_T, BIGF_T, ent_ne_bigf);
2791 ent_binrel_register(ASE_BINARY_REL_LESSP,
2792 BIGF_T, INT_T, ent_lt_bigf_int);
2793 ent_binrel_register(ASE_BINARY_REL_GREATERP,
2794 BIGF_T, INT_T, ent_gt_bigf_int);
2795 ent_binrel_register(ASE_BINARY_REL_EQUALP,
2796 BIGF_T, INT_T, ent_eq_bigf_int);
2797 ent_binrel_register(ASE_BINARY_REL_NEQP,
2798 BIGF_T, INT_T, ent_ne_bigf_int);
2800 ent_binrel_register(ASE_BINARY_REL_LESSP,
2801 INT_T, BIGF_T, ent_lt_int_bigf);
2802 ent_binrel_register(ASE_BINARY_REL_GREATERP,
2803 INT_T, BIGF_T, ent_gt_int_bigf);
2804 ent_binrel_register(ASE_BINARY_REL_EQUALP,
2805 INT_T, BIGF_T, ent_eq_int_bigf);
2806 ent_binrel_register(ASE_BINARY_REL_NEQP,
2807 INT_T, BIGF_T, ent_ne_int_bigf);
2809 ent_binrel_register(ASE_BINARY_REL_LESSP,
2810 BIGF_T, BIGZ_T, ent_lt_bigf_bigz);
2811 ent_binrel_register(ASE_BINARY_REL_GREATERP,
2812 BIGF_T, BIGZ_T, ent_gt_bigf_bigz);
2813 ent_binrel_register(ASE_BINARY_REL_EQUALP,
2814 BIGF_T, BIGZ_T, ent_eq_bigf_bigz);
2815 ent_binrel_register(ASE_BINARY_REL_NEQP,
2816 BIGF_T, BIGZ_T, ent_ne_bigf_bigz);
2818 ent_binrel_register(ASE_BINARY_REL_LESSP,
2819 BIGZ_T, BIGF_T, ent_lt_bigz_bigf);
2820 ent_binrel_register(ASE_BINARY_REL_GREATERP,
2821 BIGZ_T, BIGF_T, ent_gt_bigz_bigf);
2822 ent_binrel_register(ASE_BINARY_REL_EQUALP,
2823 BIGZ_T, BIGF_T, ent_eq_bigz_bigf);
2824 ent_binrel_register(ASE_BINARY_REL_NEQP,
2825 BIGZ_T, BIGF_T, ent_ne_bigz_bigf);
2827 ent_binrel_register(ASE_BINARY_REL_LESSP,
2828 BIGF_T, BIGQ_T, ent_lt_bigf_bigq);
2829 ent_binrel_register(ASE_BINARY_REL_GREATERP,
2830 BIGF_T, BIGQ_T, ent_gt_bigf_bigq);
2831 ent_binrel_register(ASE_BINARY_REL_EQUALP,
2832 BIGF_T, BIGQ_T, ent_eq_bigf_bigq);
2833 ent_binrel_register(ASE_BINARY_REL_NEQP,
2834 BIGF_T, BIGQ_T, ent_ne_bigf_bigq);
2836 ent_binrel_register(ASE_BINARY_REL_LESSP,
2837 BIGQ_T, BIGF_T, ent_lt_bigq_bigf);
2838 ent_binrel_register(ASE_BINARY_REL_GREATERP,
2839 BIGQ_T, BIGF_T, ent_gt_bigq_bigf);
2840 ent_binrel_register(ASE_BINARY_REL_EQUALP,
2841 BIGQ_T, BIGF_T, ent_eq_bigq_bigf);
2842 ent_binrel_register(ASE_BINARY_REL_NEQP,
2843 BIGQ_T, BIGF_T, ent_ne_bigq_bigf);
2846 ent_binrel_register(ASE_BINARY_REL_LESSP,
2847 BIGF_T, FLOAT_T, ent_lt_bigf_fpfloat);
2848 ent_binrel_register(ASE_BINARY_REL_GREATERP,
2849 BIGF_T, FLOAT_T, ent_gt_bigf_fpfloat);
2850 ent_binrel_register(ASE_BINARY_REL_EQUALP,
2851 BIGF_T, FLOAT_T, ent_eq_bigf_fpfloat);
2852 ent_binrel_register(ASE_BINARY_REL_NEQP,
2853 BIGF_T, FLOAT_T, ent_ne_bigf_fpfloat);
2855 ent_binrel_register(ASE_BINARY_REL_LESSP,
2856 FLOAT_T, BIGF_T, ent_lt_fpfloat_bigf);
2857 ent_binrel_register(ASE_BINARY_REL_GREATERP,
2858 FLOAT_T, BIGF_T, ent_gt_fpfloat_bigf);
2859 ent_binrel_register(ASE_BINARY_REL_EQUALP,
2860 FLOAT_T, BIGF_T, ent_eq_fpfloat_bigf);
2861 ent_binrel_register(ASE_BINARY_REL_NEQP,
2862 FLOAT_T, BIGF_T, ent_ne_fpfloat_bigf);
2867 ent_mpf_lifttable_init(void)
2869 ent_lift_register(INT_T, BIGF_T, ent_lift_INT_T_BIGF_T);
2870 ent_lift_register(BIGF_T, INT_T, ent_lift_BIGF_T_INT_T);
2871 ent_lift_register(BIGZ_T, BIGF_T, ent_lift_BIGZ_T_BIGF_T);
2872 ent_lift_register(BIGF_T, BIGZ_T, ent_lift_BIGF_T_BIGZ_T);
2873 ent_lift_register(BIGQ_T, BIGF_T, ent_lift_BIGQ_T_BIGF_T);
2874 ent_lift_register(BIGF_T, BIGQ_T, ent_lift_BIGF_T_BIGQ_T);
2876 ent_lift_register(FLOAT_T, BIGF_T, ent_lift_FLOAT_T_BIGF_T);
2877 ent_lift_register(BIGF_T, FLOAT_T, ent_lift_BIGF_T_FLOAT_T);
2879 ent_lift_register(BIGF_T, BIGF_T, ent_lift_BIGF_T_BIGF_T);
2880 ent_lift_register(INDEF_T, BIGF_T, ent_lift_INDEF_T_COMPARABLE);
2883 void init_optables_BIGF_T (void)
2885 ent_mpf_nullary_optable_init();
2886 ent_mpf_unary_optable_init();
2887 ent_mpf_binary_optable_init();
2888 ent_mpf_unary_reltable_init();
2889 ent_mpf_binary_reltable_init();
2890 ent_mpf_lifttable_init();
2895 /* Prepare the bignum/bigfloat random number generator */
2896 gmp_randinit_default(random_state);
2897 gmp_randseed_ui(random_state, getpid() + time (NULL));
2899 bigz_init(ent_scratch_bigz);
2902 void init_ent_mpq(void)
2904 bigq_init(ent_scratch_bigq);
2909 /* The smallest number that is printed without exponents */
2910 mpf_init_set_d(float_print_min, 0.001);
2912 /* The largest number that is printed without exponents */
2913 mpf_init_set_ui(float_print_max, 10000000UL);
2915 bigf_init(ent_scratch_bigf);
2918 void syms_of_ent_mpz(void)
2920 INIT_LRECORD_IMPLEMENTATION(bigz);
2923 void syms_of_ent_mpq(void)
2925 INIT_LRECORD_IMPLEMENTATION(bigq);
2928 void syms_of_ent_mpf(void)
2930 INIT_LRECORD_IMPLEMENTATION(bigf);
2932 DEFSUBR(Fbigf_get_precision);
2933 DEFSUBR(Fbigf_set_precision);
2936 void vars_of_ent_mpz(void)
2938 Fprovide(intern("bignum")); /* for XE compatibility */
2939 Fprovide(intern("bigz"));
2942 void vars_of_ent_mpq(void)
2944 Fprovide(intern("ratio")); /* for XE compatibility */
2945 Fprovide(intern("bigq"));
2948 void vars_of_ent_mpf(void)
2950 bigf_set_default_prec(128UL);
2952 Fprovide(intern("bigfloat")); /* for XE compatibility */
2953 Fprovide(intern("bigf"));