31 Term t = Yap_MkBigIntTerm(
new);
34 Yap_ArithError(RESOURCE_ERROR_STACK, t,
">>/2");
42 Term t = Yap_MkBigRatTerm(
new);
45 Yap_ArithError(RESOURCE_ERROR_STACK, t,
">>/2");
52Yap_gmp_add_ints(Int i, Int j)
56 mpz_init_set_si(&
new,i);
58 mpz_add_ui(&
new, &
new, j);
61 mpz_sub_ui(&
new, &
new, -(j+1));
62 mpz_sub_ui(&
new, &
new, 1);
64 mpz_sub_ui(&
new, &
new, -j);
67 return MkBigAndClose(&
new);
71Yap_gmp_sub_ints(Int i, Int j)
76 mpz_init_set_si(&
new,i);
78 mpz_sub_ui(&
new, &
new, j);
81 mpz_add_ui(&
new, &
new, -(j+1));
82 mpz_add_ui(&
new, &
new, 1);
84 mpz_add_ui(&
new, &
new, -j);
87 return MkBigAndClose(&
new);
88 t = Yap_MkBigIntTerm(&
new);
94Yap_gmp_mul_ints(Int i, Int j)
98 mpz_init_set_si(&
new,i);
99 mpz_mul_si(&
new, &
new, j);
100 return MkBigAndClose(&
new);
104Yap_gmp_sll_ints(Int i, Int j)
108 mpz_init_set_si(&
new,i);
109 mpz_mul_2exp(&
new, &
new, j);
110 return MkBigAndClose(&
new);
115Yap_gmp_add_int_big(Int i, Term t)
117 CELL *pt = RepAppl(t);
118 if (pt[1] == BIG_INT) {
120 MP_INT *b = Yap_BigIntOfTerm(t);
121 mpz_init_set_si(&
new, i);
122 mpz_add(&
new, &
new, b);
123 return MkBigAndClose(&
new);
126 MP_RAT *b = Yap_BigRatOfTerm(t);
128 mpq_set_si(&
new, i, 1L);
129 mpq_add(&
new, &
new, b);
130 return MkRatAndClose(&
new);
136Yap_gmp_set_bit(Int i, Term t)
138 MP_INT *b = Yap_BigIntOfTerm(t);
144Yap_gmp_sub_int_big(Int i, Term t)
146 CELL *pt = RepAppl(t);
147 if (pt[1] == BIG_INT) {
149 MP_INT *b = Yap_BigIntOfTerm(t);
151 mpz_init_set_si(&
new, i);
152 mpz_sub(&
new, &
new, b);
153 return MkBigAndClose(&
new);
156 MP_RAT *b = Yap_BigRatOfTerm(t);
159 mpq_set_si(&
new, i, 1L);
160 mpq_sub(&
new, &
new, b);
161 return MkRatAndClose(&
new);
167Yap_gmp_mul_int_big(Int i, Term t)
169 CELL *pt = RepAppl(t);
170 if (pt[1] == BIG_INT) {
172 MP_INT *b = Yap_BigIntOfTerm(t);
174 mpz_init_set_si(&
new, i);
175 mpz_mul(&
new, &
new, b);
176 return MkBigAndClose(&
new);
179 MP_RAT *b = Yap_BigRatOfTerm(t);
182 mpq_set_si(&
new, i, 1L);
183 mpq_mul(&
new, &
new, b);
184 return MkRatAndClose(&
new);
190Yap_gmp_sub_big_int(Term t, Int i)
192 CELL *pt = RepAppl(t);
193 if (pt[1] == BIG_INT) {
195 MP_INT *b = Yap_BigIntOfTerm(t);
197 mpz_init_set_si(&
new, i);
199 mpz_add(&
new, &
new, b);
200 return MkBigAndClose(&
new);
203 MP_RAT *b = Yap_BigRatOfTerm(t);
206 mpq_set_si(&
new, i, 1L);
207 mpq_sub(&
new, b, &
new);
208 return MkRatAndClose(&
new);
214Yap_gmp_div_int_big(Int i, Term t)
216 CELL *pt = RepAppl(t);
217 if (pt[1] == BIG_INT) {
222 MP_RAT *b = Yap_BigRatOfTerm(t);
225 mpq_set_si(&
new, i, 1L);
226 mpq_div(&
new, &
new, b);
227 return MkRatAndClose(&
new);
233Yap_gmp_div_big_int(Term t, Int i)
235 CELL *pt = RepAppl(t);
236 if (pt[1] == BIG_INT) {
238 MP_INT *b = Yap_BigIntOfTerm(t);
240 mpz_init_set(&
new, b);
241 if ( (-3 / 2) == -2 ) {
243 mpz_tdiv_q_ui(&
new, &
new, i);
245 Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, MkIntTerm(0),
"// /2");
248 mpz_tdiv_q_ui(&
new, &
new, -i);
253 mpz_fdiv_q_ui(&
new, &
new, i);
255 Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, MkIntTerm(0),
"// /2");
258 mpz_fdiv_q_ui(&
new, &
new, -i);
262 return MkBigAndClose(&
new);
265 MP_RAT *b = Yap_BigRatOfTerm(t);
268 mpq_set_si(&
new, i, 1L);
269 mpq_div(&
new, b, &
new);
270 return MkRatAndClose(&
new);
276Yap_gmp_div2_big_int(Term t, Int i)
278 CELL *pt = RepAppl(t);
279 if (pt[1] == BIG_INT) {
281 MP_INT *b = Yap_BigIntOfTerm(t);
283 mpz_init_set(&
new, b);
285 mpz_fdiv_q_ui(&
new, &
new, i);
287 Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, MkIntTerm(0),
"// /2");
290 mpz_fdiv_q_ui(&
new, &
new, -i);
293 return MkBigAndClose(&
new);
296 MP_RAT *b = Yap_BigRatOfTerm(t);
299 mpq_set_si(&
new, i, 1L);
300 mpq_div(&
new, b, &
new);
301 return MkRatAndClose(&
new);
307Yap_gmp_and_int_big(Int i, Term t)
310 CELL *pt = RepAppl(t);
312 if (pt[1] != BIG_INT) {
313 Yap_ArithError(TYPE_ERROR_INTEGER, t,
"/\\/2");
315 b = Yap_BigIntOfTerm(t);
317 mpz_init_set_si(&
new, i);
318 mpz_and(&
new, &
new, b);
319 return MkBigAndClose(&
new);
324Yap_gmp_ior_int_big(Int i, Term t)
327 CELL *pt = RepAppl(t);
329 if (pt[1] != BIG_INT) {
330 Yap_ArithError(TYPE_ERROR_INTEGER, t,
"\\/ /2");
332 b = Yap_BigIntOfTerm(t);
334 mpz_init_set_si(&
new, i);
335 mpz_ior(&
new, &
new, b);
336 return MkBigAndClose(&
new);
340#if !defined(HAVE_MPZ_XOR) && !defined(mpz_xor)
348 mpz_ior(
new, r1, r2);
350 mpz_and(n2, n2,
new);
352 mpz_and(n3, n3,
new);
353 mpz_ior(
new, n2, n3);
361Yap_gmp_xor_int_big(Int i, Term t)
364 CELL *pt = RepAppl(t);
366 if (pt[1] != BIG_INT) {
367 Yap_ArithError(TYPE_ERROR_INTEGER, t,
"#/2");
369 b = Yap_BigIntOfTerm(t);
371 mpz_init_set_si(&
new,i);
372 mpz_xor(&
new, &
new, b);
373 return MkBigAndClose(&
new);
378Yap_gmp_sll_big_int(Term t, Int i)
380 CELL *pt = RepAppl(t);
381 if (pt[1] == BIG_INT) {
383 MP_INT *b = Yap_BigIntOfTerm(t);
387 mpz_mul_2exp(&
new, b, i);
394 Yap_ArithError(RESOURCE_ERROR_HUGE_INT, MkIntegerTerm(i),
"<</2");
396 mpz_fdiv_q_2exp(&
new, b, -i);
398 return MkBigAndClose(&
new);
401 MP_RAT *b = Yap_BigRatOfTerm(t);
405 mpq_mul_2exp (&
new, b, i);
410 mpq_div_2exp (&
new, b, i);
412 return MkRatAndClose(&
new);
417Yap_gmp_add_big_big(Term t1, Term t2)
419 CELL *pt1 = RepAppl(t1);
420 CELL *pt2 = RepAppl(t2);
421 if (pt1[1] == BIG_INT && pt2[1] == BIG_INT) {
423 MP_INT *b1 = Yap_BigIntOfTerm(t1);
424 MP_INT *b2 = Yap_BigIntOfTerm(t2);
426 mpz_init_set(&
new, b1);
427 mpz_add(&
new, &
new, b2);
428 return MkBigAndClose(&
new);
433 if (pt1[1] == BIG_INT) {
436 mpq_set_z(b1, Yap_BigIntOfTerm(t1));
438 b1 = Yap_BigRatOfTerm(t1);
440 if (pt2[1] == BIG_INT) {
443 mpq_set_z(b2, Yap_BigIntOfTerm(t2));
445 b2 = Yap_BigRatOfTerm(t2);
448 mpq_add(&
new, b1, b2);
449 return MkRatAndClose(&
new);
454Yap_gmp_sub_big_big(Term t1, Term t2)
456 CELL *pt1 = RepAppl(t1);
457 CELL *pt2 = RepAppl(t2);
458 if (pt1[1] == BIG_INT && pt2[1] == BIG_INT) {
460 MP_INT *b1 = Yap_BigIntOfTerm(t1);
461 MP_INT *b2 = Yap_BigIntOfTerm(t2);
463 mpz_init_set(&
new, b1);
464 mpz_sub(&
new, &
new, b2);
465 return MkBigAndClose(&
new);
470 if (pt1[1] == BIG_INT) {
473 mpq_set_z(b1, Yap_BigIntOfTerm(t1));
475 b1 = Yap_BigRatOfTerm(t1);
477 if (pt2[1] == BIG_INT) {
480 mpq_set_z(b2, Yap_BigIntOfTerm(t2));
482 b2 = Yap_BigRatOfTerm(t2);
485 mpq_sub(&
new, b1, b2);
486 return MkRatAndClose(&
new);
491Yap_gmp_mul_big_big(Term t1, Term t2)
493 CELL *pt1 = RepAppl(t1);
494 CELL *pt2 = RepAppl(t2);
495 if (pt1[1] == BIG_INT && pt2[1] == BIG_INT) {
497 MP_INT *b1 = Yap_BigIntOfTerm(t1);
498 MP_INT *b2 = Yap_BigIntOfTerm(t2);
500 mpz_init_set(&
new, b1);
501 mpz_mul(&
new, &
new, b2);
502 return MkBigAndClose(&
new);
507 int f1 = FALSE, f2 = FALSE;
509 if (pt1[1] == BIG_INT) {
512 mpq_set_z(b1, Yap_BigIntOfTerm(t1));
515 b1 = Yap_BigRatOfTerm(t1);
517 if (pt2[1] == BIG_INT) {
520 mpq_set_z(b2, Yap_BigIntOfTerm(t2));
523 b2 = Yap_BigRatOfTerm(t2);
526 mpq_mul(&
new, b1, b2);
527 if (f1) mpq_clear(b1);
528 if (f2) mpq_clear(b2);
529 return MkRatAndClose(&
new);
535Yap_gmp_div_big_big(Term t1, Term t2)
537 CELL *pt1 = RepAppl(t1);
538 CELL *pt2 = RepAppl(t2);
539 if (pt1[1] == BIG_INT && pt2[1] == BIG_INT) {
541 MP_INT *b1 = Yap_BigIntOfTerm(t1);
542 MP_INT *b2 = Yap_BigIntOfTerm(t2);
544 mpz_init_set(&
new, b1);
545 if ( (-3 / 2) == -2 ) {
546 mpz_tdiv_q(&
new, &
new, b2);
548 mpz_fdiv_q(&
new, &
new, b2);
550 return MkBigAndClose(&
new);
555 if (pt1[1] == BIG_INT) {
558 mpq_set_z(b1, Yap_BigIntOfTerm(t1));
560 b1 = Yap_BigRatOfTerm(t1);
562 if (pt2[1] == BIG_INT) {
565 mpq_set_z(b2, Yap_BigIntOfTerm(t2));
567 b2 = Yap_BigRatOfTerm(t2);
570 mpq_div(&
new, b1, b2);
571 return MkRatAndClose(&
new);
577Yap_gmp_div2_big_big(Term t1, Term t2)
579 CELL *pt1 = RepAppl(t1);
580 CELL *pt2 = RepAppl(t2);
581 if (pt1[1] == BIG_INT && pt2[1] == BIG_INT) {
583 MP_INT *b1 = Yap_BigIntOfTerm(t1);
584 MP_INT *b2 = Yap_BigIntOfTerm(t2);
586 mpz_init_set(&
new, b1);
587 mpz_fdiv_q(&
new, &
new, b2);
588 return MkBigAndClose(&
new);
593 if (pt1[1] == BIG_INT) {
596 mpq_set_z(b1, Yap_BigIntOfTerm(t1));
598 b1 = Yap_BigRatOfTerm(t1);
600 if (pt2[1] == BIG_INT) {
603 mpq_set_z(b2, Yap_BigIntOfTerm(t2));
605 b2 = Yap_BigRatOfTerm(t2);
608 mpq_div(&
new, b1, b2);
609 return MkRatAndClose(&
new);
614Yap_gmp_and_big_big(Term t1, Term t2)
616 CELL *pt1 = RepAppl(t1);
617 CELL *pt2 = RepAppl(t2);
618 if (pt1[1] == BIG_INT && pt2[1] == BIG_INT) {
620 MP_INT *b1 = Yap_BigIntOfTerm(t1);
621 MP_INT *b2 = Yap_BigIntOfTerm(t2);
623 mpz_init_set(&
new, b1);
624 mpz_and(&
new, &
new, b2);
625 return MkBigAndClose(&
new);
627 if (pt1[1] != BIG_INT) {
628 Yap_ArithError(TYPE_ERROR_INTEGER, t1,
"/\\/2");
631 Yap_ArithError(TYPE_ERROR_INTEGER, t2,
"/\\/2");
635Yap_gmp_ior_big_big(Term t1, Term t2)
637 CELL *pt1 = RepAppl(t1);
638 CELL *pt2 = RepAppl(t2);
639 if (pt1[1] == BIG_INT && pt2[1] == BIG_INT) {
641 MP_INT *b1 = Yap_BigIntOfTerm(t1);
642 MP_INT *b2 = Yap_BigIntOfTerm(t2);
644 mpz_init_set(&
new, b1);
645 mpz_ior(&
new, &
new, b2);
646 return MkBigAndClose(&
new);
648 if (pt1[1] != BIG_INT) {
649 Yap_ArithError(TYPE_ERROR_INTEGER, t1,
"\\/ /2");
652 Yap_ArithError(TYPE_ERROR_INTEGER, t2,
"\\/ /2");
656Yap_gmp_xor_big_big(Term t1, Term t2)
658 CELL *pt1 = RepAppl(t1);
659 CELL *pt2 = RepAppl(t2);
660 if (pt1[1] == BIG_INT && pt2[1] == BIG_INT) {
662 MP_INT *b1 = Yap_BigIntOfTerm(t1);
663 MP_INT *b2 = Yap_BigIntOfTerm(t2);
665 mpz_init_set(&
new, b1);
666 mpz_xor(&
new, &
new, b2);
667 return MkBigAndClose(&
new);
669 if (pt1[1] != BIG_INT) {
670 Yap_ArithError(TYPE_ERROR_INTEGER, t1,
"\\/ /2");
673 Yap_ArithError(TYPE_ERROR_INTEGER, t2,
"\\/ /2");
677Yap_gmp_mod_big_big(Term t1, Term t2)
679 CELL *pt1 = RepAppl(t1);
680 CELL *pt2 = RepAppl(t2);
681 if (pt1[1] == BIG_INT && pt2[1] == BIG_INT) {
683 MP_INT *b1 = Yap_BigIntOfTerm(t1);
684 MP_INT *b2 = Yap_BigIntOfTerm(t2);
687 mpz_fdiv_r(&
new, b1, b2);
688 return MkBigAndClose(&
new);
690 if (pt1[1] != BIG_INT) {
691 Yap_ArithError(TYPE_ERROR_INTEGER, t1,
"mod/2");
694 Yap_ArithError(TYPE_ERROR_INTEGER, t2,
"mod/2");
698Yap_gmp_mod_big_int(Term t, Int i2)
700 CELL *pt = RepAppl(t);
701 if (pt[1] != BIG_INT) {
702 Yap_ArithError(TYPE_ERROR_INTEGER, t,
"mod/2");
704 MP_INT *b = Yap_BigIntOfTerm(t);
707 mpz_init_set_si(&
new, i2);
708 mpz_fdiv_r(&
new, b, &
new);
709 return MkBigAndClose(&
new);
714Yap_gmp_mod_int_big(Int i1, Term t)
717 CELL *pt = RepAppl(t);
718 if (pt[1] != BIG_INT) {
719 Yap_ArithError(TYPE_ERROR_INTEGER, t,
"mod/2");
721 MP_INT *b = Yap_BigIntOfTerm(t);
724 if (mpz_sgn(b) > 0) {
728 return MkIntegerTerm(i1);
733 mpz_init_set_si(&
new, i1);
734 mpz_add(&
new, &
new, b);
735 return MkBigAndClose(&
new);
742 mpz_init_set_si(&
new, i1);
743 mpz_add(&
new, b, &
new);
744 return MkBigAndClose(&
new);
747 return MkIntegerTerm(i1);
754Yap_gmp_rem_big_big(Term t1, Term t2)
756 CELL *pt1 = RepAppl(t1);
757 CELL *pt2 = RepAppl(t2);
758 if (pt1[1] == BIG_INT && pt2[1] == BIG_INT) {
760 MP_INT *b1 = Yap_BigIntOfTerm(t1);
761 MP_INT *b2 = Yap_BigIntOfTerm(t2);
764 mpz_tdiv_r(&
new, b1, b2);
765 return MkBigAndClose(&
new);
767 if (pt1[1] != BIG_INT) {
768 Yap_ArithError(TYPE_ERROR_INTEGER, t1,
"rem/2");
770 Yap_ArithError(TYPE_ERROR_INTEGER, t2,
"rem/2");
775Yap_gmp_rem_big_int(Term t, Int i2)
777 CELL *pt = RepAppl(t);
778 if (pt[1] != BIG_INT) {
779 Yap_ArithError(TYPE_ERROR_INTEGER, t,
"rem/2");
781 MP_INT *b = Yap_BigIntOfTerm(t);
784 mpz_init_set_si(&
new, i2);
785 mpz_tdiv_r(&
new, b, &
new);
786 return MkBigAndClose(&
new);
791Yap_gmp_rem_int_big(Int i1, Term t)
794 CELL *pt = RepAppl(t);
795 if (pt[1] != BIG_INT) {
796 Yap_ArithError(TYPE_ERROR_INTEGER, t,
"rem/2");
799 return MkIntegerTerm(i1);
804Yap_gmp_gcd_big_big(Term t1, Term t2)
806 CELL *pt1 = RepAppl(t1);
807 CELL *pt2 = RepAppl(t2);
808 if (pt1[1] == BIG_INT && pt2[1] == BIG_INT) {
810 MP_INT *b1 = Yap_BigIntOfTerm(t1);
811 MP_INT *b2 = Yap_BigIntOfTerm(t2);
813 mpz_init_set(&
new, b1);
814 mpz_gcd(&
new, &
new, b2);
815 return MkBigAndClose(&
new);
817 if (pt1[1] != BIG_INT) {
818 Yap_ArithError(TYPE_ERROR_INTEGER, t1,
"gcd/2");
820 Yap_ArithError(TYPE_ERROR_INTEGER, t2,
"gcd/2");
825Yap_gmp_gcd_int_big(Int i, Term t)
828 CELL *pt = RepAppl(t);
829 if (pt[1] != BIG_INT) {
830 Yap_ArithError(TYPE_ERROR_INTEGER, t,
"gcd/2");
834 return MkIntegerTerm(mpz_gcd_ui(NULL,Yap_BigIntOfTerm(t),i));
838 return MkIntegerTerm(mpz_gcd_ui(NULL,Yap_BigIntOfTerm(t),-i));
844Yap_gmp_float_to_big(Float v)
848 mpz_init_set_d(&
new, v);
849 return MkBigAndClose(&
new);
853Yap_gmp_to_float(Term t)
855 CELL *pt = RepAppl(t);
856 if (pt[1] == BIG_INT) {
857 MP_INT *b = Yap_BigIntOfTerm(t);
860 MP_RAT *b = Yap_BigRatOfTerm(t);
866Yap_gmp_add_float_big(Float d, Term t)
869 CELL *pt = RepAppl(t);
870 if (pt[1] == BIG_INT) {
871 MP_INT *b = Yap_BigIntOfTerm(t);
872 return MkFloatTerm(d+mpz_get_d(b));
874 MP_RAT *b = Yap_BigRatOfTerm(t);
875 return MkFloatTerm(d+mpq_get_d(b));
880Yap_gmp_sub_float_big(Float d, Term t)
883 CELL *pt = RepAppl(t);
884 if (pt[1] == BIG_INT) {
885 MP_INT *b = Yap_BigIntOfTerm(t);
886 return MkFloatTerm(d-mpz_get_d(b));
888 MP_RAT *b = Yap_BigRatOfTerm(t);
889 return MkFloatTerm(d-mpq_get_d(b));
894Yap_gmp_sub_big_float(Term t, Float d)
897 CELL *pt = RepAppl(t);
898 if (pt[1] == BIG_INT) {
899 MP_INT *b = Yap_BigIntOfTerm(t);
900 return MkFloatTerm(mpz_get_d(b)-d);
902 MP_RAT *b = Yap_BigRatOfTerm(t);
903 return MkFloatTerm(mpq_get_d(b)-d);
908Yap_gmp_mul_float_big(Float d, Term t)
911 CELL *pt = RepAppl(t);
912 if (pt[1] == BIG_INT) {
913 MP_INT *b = Yap_BigIntOfTerm(t);
914 return MkFloatTerm(d*mpz_get_d(b));
916 MP_RAT *b = Yap_BigRatOfTerm(t);
917 return MkFloatTerm(d*mpq_get_d(b));
922Yap_gmp_fdiv_float_big(Float d, Term t)
925 CELL *pt = RepAppl(t);
926 if (pt[1] == BIG_INT) {
927 MP_INT *b = Yap_BigIntOfTerm(t);
928 return MkFloatTerm(d/mpz_get_d(b));
930 MP_RAT *b = Yap_BigRatOfTerm(t);
931 return MkFloatTerm(d/mpq_get_d(b));
936Yap_gmp_fdiv_big_float(Term t, Float d)
939 CELL *pt = RepAppl(t);
940 if (pt[1] == BIG_INT) {
941 MP_INT *b = Yap_BigIntOfTerm(t);
942 return MkFloatTerm(mpz_get_d(b)/d);
944 MP_RAT *b = Yap_BigRatOfTerm(t);
945 return MkFloatTerm(mpq_get_d(b)/d);
950Yap_gmp_exp_int_int(Int i1, Int i2)
954 mpz_init_set_si(&
new, i1);
955 mpz_pow_ui (&
new, &
new, (
unsigned long int)i2);
956 return MkBigAndClose(&
new);
960Yap_gmp_exp_big_int(Term t, Int i)
965 CELL *pt = RepAppl(t);
966 if (pt[1] == BIG_INT) {
967 MP_INT *b = Yap_BigIntOfTerm(t);
971 mpz_pow_ui (&
new, b, (
unsigned long int)i);
974 if (i==0)
return MkIntTerm(1);
975 mpz_init_set_si(&
new, i);
976 mpz_powm (&
new, b, &
new, b);
978 return MkBigAndClose(&
new);
980 MP_RAT *b = Yap_BigRatOfTerm(t);
981 Float dbl = mpq_get_d(b);
982 return MkFloatTerm(pow(dbl,i));
987Yap_gmp_exp_int_big(Int i, Term t)
990 CELL *pt = RepAppl(t);
991 if (pt[1] == BIG_INT) {
992 Yap_ArithError(RESOURCE_ERROR_HUGE_INT, t,
"^/2");
994 MP_INT *b = Yap_BigIntOfTerm(t);
995 Float dbl = mpz_get_d(b);
996 return MkFloatTerm(pow(i,dbl));
1001Yap_gmp_exp_big_big(Term t1, Term t2)
1004 CELL *pt1 = RepAppl(t1);
1005 CELL *pt2 = RepAppl(t2);
1008 if (pt1[1] == BIG_INT && pt2[1] == BIG_INT) {
1009 Yap_ArithError(RESOURCE_ERROR_HUGE_INT, t2,
"^/2");
1011 if (pt1[1] != BIG_INT) {
1012 dbl1 = mpz_get_d(Yap_BigIntOfTerm(t1));
1014 dbl1 = mpq_get_d(Yap_BigRatOfTerm(t1));
1016 if (pt2[2] != BIG_INT) {
1017 dbl2 = mpz_get_d(Yap_BigIntOfTerm(t2));
1019 dbl2 = mpq_get_d(Yap_BigRatOfTerm(t2));
1021 return MkFloatTerm(pow(dbl1,dbl2));
1027Yap_gmp_big_from_64bits(YAP_LONG_LONG i)
1033 snprintf(s,64,
"%I64d", (
long long int)i);
1035 snprintf(s, 64,
"%lld", (
long long int)i);
1037 sprintf(s,
"%lld", (
long long int)i);
1039 mpz_init_set_str (&
new, s, 10);
1040 return MkBigAndClose(&
new);
1044Yap_gmq_rdiv_int_int(Int i1, Int i2)
1053 mpq_set_si(&
new, i1, i2);
1054 mpq_canonicalize(&
new);
1055 return MkRatAndClose(&
new);
1059Yap_gmq_rdiv_int_big(Int i1, Term t2)
1062 CELL *pt2 = RepAppl(t2);
1064 mpq_set_si(&
new, i1, 1L);
1065 if (pt2[1] == BIG_INT) {
1067 MP_INT *b = Yap_BigIntOfTerm(t2);
1070 mpq_set_z(&new2, b);
1071 mpq_div(&
new,&
new,&new2);
1074 MP_RAT *b = Yap_BigRatOfTerm(t2);
1075 mpq_div(&
new,&
new,b);
1077 return MkRatAndClose(&
new);
1081Yap_gmq_rdiv_big_int(Term t1, Int i2)
1084 CELL *pt1 = RepAppl(t1);
1087 mpq_set_si(&
new, i2, 1L);
1088 if (pt1[1] == BIG_INT) {
1089 MP_INT *b = Yap_BigIntOfTerm(t1);
1093 mpq_set_z(&new2, b);
1094 mpq_div(&
new,&new2,&
new);
1097 MP_RAT *b = Yap_BigRatOfTerm(t1);
1099 mpq_div(&
new,b,&
new);
1101 return MkRatAndClose(&
new);
1105Yap_gmq_rdiv_big_big(Term t1, Term t2)
1108 CELL *pt1 = RepAppl(t1);
1109 CELL *pt2 = RepAppl(t2);
1112 if (pt1[1] == BIG_INT) {
1113 MP_INT *b1 = Yap_BigIntOfTerm(t1);
1114 mpq_set_z(&
new, b1);
1116 MP_RAT *b1 = Yap_BigRatOfTerm(t1);
1120 if (pt2[1] == BIG_INT) {
1122 MP_INT *b2 = Yap_BigIntOfTerm(t2);
1125 mpq_set_z(&new2, b2);
1126 mpq_div(&
new,&
new,&new2);
1129 MP_RAT *b2 = Yap_BigRatOfTerm(t2);
1130 mpq_div(&
new,&
new,b2);
1132 return MkRatAndClose(&
new);
1136Yap_gmp_fdiv_int_big(Int i1, Term t2)
1143 CELL *pt2 = RepAppl(t2);
1147 mpq_set_si(b1, i1, 1L);
1148 if (pt2[1] == BIG_INT) {
1151 mpq_set_z(b2, Yap_BigIntOfTerm(t2));
1153 b2 = Yap_BigRatOfTerm(t2);
1156 mpq_div(&
new, b1, b2);
1157 d = mpq_get_d(&
new);
1159 return MkFloatTerm(d);
1163Yap_gmp_fdiv_big_int(Term t2, Int i1)
1170 CELL *pt2 = RepAppl(t2);
1174 mpq_set_si(b1, i1, 1L);
1175 if (pt2[1] == BIG_INT) {
1178 mpq_set_z(b2, Yap_BigIntOfTerm(t2));
1180 b2 = Yap_BigRatOfTerm(t2);
1183 mpq_div(&
new, b2, b1);
1184 d = mpq_get_d(&
new);
1186 return MkFloatTerm(d);
1190Yap_gmp_fdiv_big_big(Term t1, Term t2)
1193 CELL *pt1 = RepAppl(t1);
1194 CELL *pt2 = RepAppl(t2);
1200 if (pt1[1] == BIG_INT) {
1203 mpq_set_z(b1, Yap_BigIntOfTerm(t1));
1205 b1 = Yap_BigRatOfTerm(t1);
1207 if (pt2[1] == BIG_INT) {
1210 mpq_set_z(b2, Yap_BigIntOfTerm(t2));
1212 b2 = Yap_BigRatOfTerm(t2);
1215 mpq_div(&
new, b1, b2);
1216 d = mpq_get_d(&
new);
1218 return MkFloatTerm(d);
1222Yap_gmp_cmp_big_int(Term t, Int i)
1224 CELL *pt = RepAppl(t);
1225 if (pt[1] == BIG_INT) {
1226 MP_INT *b = Yap_BigIntOfTerm(t);
1227 return mpz_cmp_si(b,i);
1229 MP_RAT *b = Yap_BigRatOfTerm(t);
1230 return mpq_cmp_si(b,i,1);
1235Yap_gmp_cmp_int_big(Int i, Term t)
1237 CELL *pt = RepAppl(t);
1238 if (pt[1] == BIG_INT) {
1239 MP_INT *b = Yap_BigIntOfTerm(t);
1240 return -mpz_cmp_si(b,i);
1242 MP_RAT *b = Yap_BigRatOfTerm(t);
1243 return -mpq_cmp_si(b,i,1);
1248Yap_gmp_cmp_big_float(Term t, Float d)
1250 CELL *pt = RepAppl(t);
1251 if (pt[1] == BIG_INT) {
1252 MP_INT *b = Yap_BigIntOfTerm(t);
1253 return mpz_cmp_d(b,d);
1255 MP_RAT *b = Yap_BigRatOfTerm(t);
1256 Float d1 = mpq_get_d(b);
1266Yap_gmp_cmp_big_big(Term t1, Term t2)
1268 CELL *pt1 = RepAppl(t1);
1269 CELL *pt2 = RepAppl(t2);
1270 if (pt1[1] == BIG_INT && pt2[1] == BIG_INT) {
1271 MP_INT *b1 = Yap_BigIntOfTerm(t1);
1272 MP_INT *b2 = Yap_BigIntOfTerm(t2);
1274 return mpz_cmp(b1, b2);
1280 if (pt1[1] == BIG_INT) {
1284 mpq_set_z(b1, Yap_BigIntOfTerm(t1));
1286 b1 = Yap_BigRatOfTerm(t1);
1288 if (pt2[1] == BIG_INT) {
1293 mpq_set_z(b2, Yap_BigIntOfTerm(t2));
1295 b2 = Yap_BigRatOfTerm(t2);
1301 return mpq_cmp(b1, b2);
1306Yap_gmp_tcmp_big_int(Term t, Int i)
1308 CELL *pt = RepAppl(t);
1309 if (pt[1] == BIG_INT) {
1310 MP_INT *b = Yap_BigIntOfTerm(t);
1311 return mpz_cmp_si(b,i);
1318Yap_gmp_tcmp_int_big(Int i, Term t)
1320 CELL *pt = RepAppl(t);
1321 if (pt[1] == BIG_INT) {
1322 MP_INT *b = Yap_BigIntOfTerm(t);
1323 return -mpz_cmp_si(b,i);
1330Yap_gmp_tcmp_big_float(Term t, Float d)
1336Yap_gmp_tcmp_big_big(Term t1, Term t2)
1338 CELL *pt1 = RepAppl(t1);
1339 CELL *pt2 = RepAppl(t2);
1341 if (pt1[1] == BIG_INT && pt2[1] == BIG_INT) {
1342 MP_INT *b1 = Yap_BigIntOfTerm(t1);
1343 MP_INT *b2 = Yap_BigIntOfTerm(t2);
1345 return mpz_cmp(b1, b2);
1349 if (pt1[1] == BIG_INT) {
1351 }
else if (pt1[1] == BIG_RATIONAL) {
1352 b1 = Yap_BigRatOfTerm(t1);
1356 if (pt2[1] == BIG_INT) {
1358 }
else if (pt2[1] == BIG_RATIONAL) {
1359 b2 = Yap_BigRatOfTerm(t2);
1363 return mpq_cmp(b1, b2);
1368Yap_gmp_neg_int(Int i)
1372 mpz_init_set_si(&
new, Int_MIN);
1373 mpz_neg(&
new, &
new);
1374 return MkBigAndClose(&
new);
1378Yap_gmp_neg_big(Term t)
1380 CELL *pt = RepAppl(t);
1381 if (pt[1] == BIG_INT) {
1382 MP_INT *b = Yap_BigIntOfTerm(t);
1384 mpz_init_set(&
new, b);
1385 mpz_neg(&
new, &
new);
1386 return MkBigAndClose(&
new);
1388 MP_RAT *b = Yap_BigRatOfTerm(t);
1392 return MkRatAndClose(&
new);
1397Yap_gmp_float_to_rational(Float dbl)
1401 mpq_set_d(&
new, dbl);
1402 return MkRatAndClose(&
new);
1417#define DBL_EPSILON 0.00000000000000022204
1421Yap_gmp_float_rationalize(Float dbl)
1423 Float e0 = dbl, p0 = 0.0, q0 = 1.0;
1424 Float e1 = -1.0, p1 = 1.0, q1 = 0.0;
1428 do { Float r = floor(e0/e1);
1429 Float e00 = e0, p00 = p0, q00 = q0;
1438 }
while(fabs(d) > DBL_EPSILON);
1440 mpz_init_set_d(mpq_numref(&
new), p1);
1441 mpz_init_set_d(mpq_denref(&
new), q1);
1442 mpq_canonicalize(&
new);
1443 return MkRatAndClose(&
new);
1447Yap_gmp_abs_big(Term t)
1449 CELL *pt = RepAppl(t);
1450 if (pt[1] == BIG_INT) {
1451 MP_INT *b = Yap_BigIntOfTerm(t);
1453 mpz_init_set(&
new, b);
1454 mpz_abs(&
new, &
new);
1455 return MkBigAndClose(&
new);
1457 MP_RAT *b = Yap_BigRatOfTerm(t);
1461 return MkRatAndClose(&
new);
1466Yap_gmp_unot_big(Term t)
1468 CELL *pt = RepAppl(t);
1469 if (pt[1] == BIG_INT) {
1470 MP_INT *b = Yap_BigIntOfTerm(t);
1472 mpz_init_set(&
new, b);
1473 mpz_com(&
new, &
new);
1474 return MkBigAndClose(&
new);
1476 Yap_ArithError(TYPE_ERROR_INTEGER, t,
"#/1");
1481Yap_gmp_floor(Term t)
1483 CELL *pt = RepAppl(t);
1484 if (pt[1] == BIG_INT) {
1487 MP_RAT *b = Yap_BigRatOfTerm(t);
1491 if (mpq_sgn(b) < 0 && mpz_cmp_si(mpq_denref(b),1L) != 0) {
1492 mpz_sub_ui(&
new,&
new,1L);
1494 return MkBigAndClose(&
new);
1499Yap_gmp_ceiling(Term t)
1501 CELL *pt = RepAppl(t);
1502 if (pt[1] == BIG_INT) {
1505 MP_RAT *b = Yap_BigRatOfTerm(t);
1509 if (mpq_sgn(b) > 0 && mpz_cmp_si(mpq_denref(b),1L) != 0) {
1510 mpz_add_ui(&
new,&
new,1L);
1512 return MkBigAndClose(&
new);
1517Yap_gmp_round(Term t)
1519 CELL *pt = RepAppl(t);
1520 if (pt[1] == BIG_INT) {
1523 MP_RAT *b = Yap_BigRatOfTerm(t);
1529 mpq_set_ui(&half, 1, 2);
1530 if ( mpq_sgn(b) > 0 )
1531 mpq_add(&q, b, &half);
1533 mpq_sub(&q, b, &half);
1536 mpz_set_q(&
new, &q);
1539 return MkBigAndClose(&
new);
1544Yap_gmp_trunc(Term t)
1546 CELL *pt = RepAppl(t);
1547 if (pt[1] == BIG_INT) {
1550 MP_RAT *b = Yap_BigRatOfTerm(t);
1552 int sgn = mpq_sgn(b);
1560 mpz_neg(&
new, &
new);
1562 return MkBigAndClose(&
new);
1567Yap_gmp_float_fractional_part(Term t)
1569 CELL *pt = RepAppl(t);
1570 if (pt[1] == BIG_INT) {
1571 Yap_ArithError(TYPE_ERROR_FLOAT, t,
"X is float_fractional_part(%f)", FloatOfTerm(t));
1573 MP_RAT *b = Yap_BigRatOfTerm(t);
1577 mpz_tdiv_q(mpq_numref(&
new),
1580 mpz_set_ui(mpq_denref(&
new), 1);
1581 mpq_sub(&
new, b, &
new);
1582 return MkRatAndClose(&
new);
1587Yap_gmp_float_integer_part(Term t)
1589 CELL *pt = RepAppl(t);
1590 if (pt[1] == BIG_INT) {
1591 Yap_ArithError(TYPE_ERROR_FLOAT, t,
"X is float_integer_part(%f)", FloatOfTerm(t));
1593 MP_RAT *b = Yap_BigRatOfTerm(t);
1600 return MkBigAndClose(&
new);
1608 CELL *pt = RepAppl(t);
1609 if (pt[1] == BIG_INT) {
1610 return MkIntegerTerm(mpz_sgn(Yap_BigIntOfTerm(t)));
1612 return MkIntegerTerm(mpq_sgn(Yap_BigRatOfTerm(t)));
1620 CELL *pt = RepAppl(t);
1621 if (pt[1] == BIG_INT) {
1622 MP_INT *big = Yap_BigIntOfTerm(t);
1623 if ( mpz_sgn(big) <= 0 ) {
1624 Yap_ArithError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t,
1625 "lsb/1 received negative bignum");
1627 return MkIntegerTerm(mpz_scan1(big,0));
1629 Yap_ArithError(TYPE_ERROR_INTEGER, t,
"lsb");
1637 CELL *pt = RepAppl(t);
1638 if (pt[1] == BIG_INT) {
1639 MP_INT *big = Yap_BigIntOfTerm(t);
1640 if ( mpz_sgn(big) <= 0 ) {
1641 Yap_ArithError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t,
1642 "msb/1 received negative bignum");
1644 return MkIntegerTerm(mpz_sizeinbase(big,2));
1646 Yap_ArithError(TYPE_ERROR_INTEGER, t,
"popcount");
1651Yap_gmp_popcount(Term t)
1654 CELL *pt = RepAppl(t);
1655 if (pt[1] == BIG_INT) {
1656 MP_INT *big = Yap_BigIntOfTerm(t);
1657 if ( mpz_sgn(big) <= 0 ) {
1658 Yap_ArithError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t,
1659 "popcount/1 received negative bignum");
1661 return MkIntegerTerm(mpz_popcount(big));
1663 Yap_ArithError(TYPE_ERROR_INTEGER, t,
"popcount");
1668Yap_mpz_to_string(
MP_INT *b,
char *s,
size_t sz,
int base)
1671 size_t size = mpz_sizeinbase(b, base);
1675 return mpz_get_str (s, base, b);
1681Yap_gmp_to_string(Term t,
char *s,
size_t sz,
int base)
1683 if (RepAppl(t)[1] == BIG_INT) {
1684 MP_INT *b = Yap_BigIntOfTerm(t);
1687 size_t size = mpz_sizeinbase(b, base);
1692 return mpz_get_str (s, base, b);
1693 }
else if (RepAppl(t)[1] == BIG_RATIONAL) {
1694 MP_RAT *b = Yap_BigRatOfTerm(t);
1697 mpz_sizeinbase(mpq_numref(b), base)+
1698 mpz_sizeinbase(mpq_denref(b), base)+
1705 if (!(s = malloc(siz)))
1708 strncpy(s,
"rdiv(",sz);
1710 mpz_get_str (s+pos, base, mpq_numref(b));
1713 mpz_get_str (s+(pos+1), base, mpq_denref(b));
1721Yap_gmp_to_size(Term t,
int base)
1723 if (RepAppl(t)[1] == BIG_INT) {
1724 MP_INT *b = Yap_BigIntOfTerm(t);
1725 return mpz_sizeinbase(b, base);
1726 }
else if (RepAppl(t)[1] == BIG_RATIONAL) {
1727 MP_RAT *b = Yap_BigRatOfTerm(t);
1729 mpz_sizeinbase(mpq_numref(b), base)+
1730 mpz_sizeinbase(mpq_denref(b), base)+
1737Yap_term_to_existing_big(Term t,
MP_INT *b)
1741 if (IsIntegerTerm(t)) {
1742 mpz_set_si(b,IntegerOfTerm(t));
1745 if (IsBigIntTerm(t)) {
1746 if (RepAppl(t)[1] != BIG_INT)
1748 mpz_set(b,Yap_BigIntOfTerm(t));
1755Yap_term_to_existing_rat(Term t,
MP_RAT *b)
1759 if (IsIntegerTerm(t)) {
1760 mpq_set_si(b, IntegerOfTerm(t), 1);
1763 if (IsBigIntTerm(t)) {
1764 CELL flag = RepAppl(t)[1];
1765 if (flag == BIG_INT) {
1766 mpq_set_z(b, Yap_BigIntOfTerm(t));
1769 if (flag == BIG_RATIONAL) {
1770 mpq_set(b, Yap_BigRatOfTerm(t));