2 * Copyright 2013 Ecole Normale Superieure
4 * Use of this software is governed by the MIT license
6 * Written by Sven Verdoolaege,
7 * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
11 #include <isl_ctx_private.h>
12 #include <isl_val_private.h>
17 #include <isl_list_templ.c>
19 /* Allocate an isl_val object with indeterminate value.
21 __isl_give isl_val *isl_val_alloc(isl_ctx *ctx)
25 v = isl_alloc_type(ctx, struct isl_val);
38 /* Return a reference to an isl_val representing zero.
40 __isl_give isl_val *isl_val_zero(isl_ctx *ctx)
42 return isl_val_int_from_si(ctx, 0);
45 /* Return a reference to an isl_val representing one.
47 __isl_give isl_val *isl_val_one(isl_ctx *ctx)
49 return isl_val_int_from_si(ctx, 1);
52 /* Return a reference to an isl_val representing NaN.
54 __isl_give isl_val *isl_val_nan(isl_ctx *ctx)
58 v = isl_val_alloc(ctx);
62 isl_int_set_si(v->n, 0);
63 isl_int_set_si(v->d, 0);
68 /* Change "v" into a NaN.
70 __isl_give isl_val *isl_val_set_nan(__isl_take isl_val *v)
74 if (isl_val_is_nan(v))
80 isl_int_set_si(v->n, 0);
81 isl_int_set_si(v->d, 0);
86 /* Return a reference to an isl_val representing +infinity.
88 __isl_give isl_val *isl_val_infty(isl_ctx *ctx)
92 v = isl_val_alloc(ctx);
96 isl_int_set_si(v->n, 1);
97 isl_int_set_si(v->d, 0);
102 /* Return a reference to an isl_val representing -infinity.
104 __isl_give isl_val *isl_val_neginfty(isl_ctx *ctx)
108 v = isl_val_alloc(ctx);
112 isl_int_set_si(v->n, -1);
113 isl_int_set_si(v->d, 0);
118 /* Return a reference to an isl_val representing the integer "i".
120 __isl_give isl_val *isl_val_int_from_si(isl_ctx *ctx, long i)
124 v = isl_val_alloc(ctx);
128 isl_int_set_si(v->n, i);
129 isl_int_set_si(v->d, 1);
134 /* Change the value of "v" to be equal to the integer "i".
136 __isl_give isl_val *isl_val_set_si(__isl_take isl_val *v, long i)
140 if (isl_val_is_int(v) && isl_int_cmp_si(v->n, i) == 0)
146 isl_int_set_si(v->n, i);
147 isl_int_set_si(v->d, 1);
152 /* Change the value of "v" to be equal to zero.
154 __isl_give isl_val *isl_val_set_zero(__isl_take isl_val *v)
156 return isl_val_set_si(v, 0);
159 /* Return a reference to an isl_val representing the unsigned integer "u".
161 __isl_give isl_val *isl_val_int_from_ui(isl_ctx *ctx, unsigned long u)
165 v = isl_val_alloc(ctx);
169 isl_int_set_ui(v->n, u);
170 isl_int_set_si(v->d, 1);
175 /* Return a reference to an isl_val representing the integer "n".
177 __isl_give isl_val *isl_val_int_from_isl_int(isl_ctx *ctx, isl_int n)
181 v = isl_val_alloc(ctx);
185 isl_int_set(v->n, n);
186 isl_int_set_si(v->d, 1);
191 /* Return a reference to an isl_val representing the rational value "n"/"d".
192 * Normalizing the isl_val (if needed) is left to the caller.
194 __isl_give isl_val *isl_val_rat_from_isl_int(isl_ctx *ctx,
195 isl_int n, isl_int d)
199 v = isl_val_alloc(ctx);
203 isl_int_set(v->n, n);
204 isl_int_set(v->d, d);
209 /* Return a new reference to "v".
211 __isl_give isl_val *isl_val_copy(__isl_keep isl_val *v)
220 /* Return a fresh copy of "val".
222 __isl_give isl_val *isl_val_dup(__isl_keep isl_val *val)
229 dup = isl_val_alloc(isl_val_get_ctx(val));
233 isl_int_set(dup->n, val->n);
234 isl_int_set(dup->d, val->d);
239 /* Return an isl_val that is equal to "val" and that has only
240 * a single reference.
242 __isl_give isl_val *isl_val_cow(__isl_take isl_val *val)
250 return isl_val_dup(val);
253 /* Free "v" and return NULL.
255 void *isl_val_free(__isl_take isl_val *v)
263 isl_ctx_deref(v->ctx);
270 /* Extract the numerator of a rational value "v" as an integer.
272 * If "v" is not a rational value, then the result is undefined.
274 long isl_val_get_num_si(__isl_keep isl_val *v)
278 if (!isl_val_is_rat(v))
279 isl_die(isl_val_get_ctx(v), isl_error_invalid,
280 "expecting rational value", return 0);
281 if (!isl_int_fits_slong(v->n))
282 isl_die(isl_val_get_ctx(v), isl_error_invalid,
283 "numerator too large", return 0);
284 return isl_int_get_si(v->n);
287 /* Extract the denominator of a rational value "v" as an integer.
289 * If "v" is not a rational value, then the result is undefined.
291 long isl_val_get_den_si(__isl_keep isl_val *v)
295 if (!isl_val_is_rat(v))
296 isl_die(isl_val_get_ctx(v), isl_error_invalid,
297 "expecting rational value", return 0);
298 if (!isl_int_fits_slong(v->d))
299 isl_die(isl_val_get_ctx(v), isl_error_invalid,
300 "denominator too large", return 0);
301 return isl_int_get_si(v->d);
304 /* Return an approximation of "v" as a double.
306 double isl_val_get_d(__isl_keep isl_val *v)
310 if (!isl_val_is_rat(v))
311 isl_die(isl_val_get_ctx(v), isl_error_invalid,
312 "expecting rational value", return 0);
313 return isl_int_get_d(v->n) / isl_int_get_d(v->d);
316 /* Return the isl_ctx to which "val" belongs.
318 isl_ctx *isl_val_get_ctx(__isl_keep isl_val *val)
320 return val ? val->ctx : NULL;
325 * In particular, make sure that the denominator of a rational value
326 * is positive and the numerator and denominator do not have any
329 * This function should not be called by an external user
330 * since it will only be given normalized values.
332 __isl_give isl_val *isl_val_normalize(__isl_take isl_val *v)
338 if (isl_val_is_int(v))
340 if (!isl_val_is_rat(v))
342 if (isl_int_is_neg(v->d)) {
343 isl_int_neg(v->d, v->d);
344 isl_int_neg(v->n, v->n);
346 ctx = isl_val_get_ctx(v);
347 isl_int_gcd(ctx->normalize_gcd, v->n, v->d);
348 if (isl_int_is_one(ctx->normalize_gcd))
350 isl_int_divexact(v->n, v->n, ctx->normalize_gcd);
351 isl_int_divexact(v->d, v->d, ctx->normalize_gcd);
355 /* Return the opposite of "v".
357 __isl_give isl_val *isl_val_neg(__isl_take isl_val *v)
361 if (isl_val_is_nan(v))
363 if (isl_val_is_zero(v))
369 isl_int_neg(v->n, v->n);
374 /* Return the absolute value of "v".
376 __isl_give isl_val *isl_val_abs(__isl_take isl_val *v)
380 if (isl_val_is_nan(v))
382 if (isl_val_is_nonneg(v))
384 return isl_val_neg(v);
387 /* Return the "floor" (greatest integer part) of "v".
388 * That is, return the result of rounding towards -infinity.
390 __isl_give isl_val *isl_val_floor(__isl_take isl_val *v)
394 if (isl_val_is_int(v))
396 if (!isl_val_is_rat(v))
402 isl_int_fdiv_q(v->n, v->n, v->d);
403 isl_int_set_si(v->d, 1);
408 /* Return the "ceiling" of "v".
409 * That is, return the result of rounding towards +infinity.
411 __isl_give isl_val *isl_val_ceil(__isl_take isl_val *v)
415 if (isl_val_is_int(v))
417 if (!isl_val_is_rat(v))
423 isl_int_cdiv_q(v->n, v->n, v->d);
424 isl_int_set_si(v->d, 1);
430 * That is, return the result of rounding towards zero.
432 __isl_give isl_val *isl_val_trunc(__isl_take isl_val *v)
436 if (isl_val_is_int(v))
438 if (!isl_val_is_rat(v))
444 isl_int_tdiv_q(v->n, v->n, v->d);
445 isl_int_set_si(v->d, 1);
450 /* Return 2^v, where v is an integer (that is not too large).
452 __isl_give isl_val *isl_val_2exp(__isl_take isl_val *v)
460 if (!isl_val_is_int(v))
461 isl_die(isl_val_get_ctx(v), isl_error_invalid,
462 "can only compute integer powers",
463 return isl_val_free(v));
464 neg = isl_val_is_neg(v);
466 isl_int_neg(v->n, v->n);
467 if (!isl_int_fits_ulong(v->n))
468 isl_die(isl_val_get_ctx(v), isl_error_invalid,
469 "exponent too large", return isl_val_free(v));
470 exp = isl_int_get_ui(v->n);
472 isl_int_mul_2exp(v->d, v->d, exp);
473 isl_int_set_si(v->n, 1);
475 isl_int_mul_2exp(v->n, v->d, exp);
481 /* Return the minimum of "v1" and "v2".
483 __isl_give isl_val *isl_val_min(__isl_take isl_val *v1, __isl_take isl_val *v2)
488 if (isl_val_is_nan(v1)) {
492 if (isl_val_is_nan(v2)) {
496 if (isl_val_le(v1, v2)) {
509 /* Return the maximum of "v1" and "v2".
511 __isl_give isl_val *isl_val_max(__isl_take isl_val *v1, __isl_take isl_val *v2)
516 if (isl_val_is_nan(v1)) {
520 if (isl_val_is_nan(v2)) {
524 if (isl_val_ge(v1, v2)) {
537 /* Return the sum of "v1" and "v2".
539 __isl_give isl_val *isl_val_add(__isl_take isl_val *v1, __isl_take isl_val *v2)
543 if (isl_val_is_nan(v1)) {
547 if (isl_val_is_nan(v2)) {
551 if ((isl_val_is_infty(v1) && isl_val_is_neginfty(v2)) ||
552 (isl_val_is_neginfty(v1) && isl_val_is_infty(v2))) {
554 return isl_val_set_nan(v1);
556 if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1)) {
560 if (isl_val_is_infty(v2) || isl_val_is_neginfty(v2)) {
564 if (isl_val_is_zero(v1)) {
568 if (isl_val_is_zero(v2)) {
573 v1 = isl_val_cow(v1);
576 if (isl_val_is_int(v1) && isl_val_is_int(v2))
577 isl_int_add(v1->n, v1->n, v2->n);
579 if (isl_int_eq(v1->d, v2->d))
580 isl_int_add(v1->n, v1->n, v2->n);
582 isl_int_mul(v1->n, v1->n, v2->d);
583 isl_int_addmul(v1->n, v2->n, v1->d);
584 isl_int_mul(v1->d, v1->d, v2->d);
586 v1 = isl_val_normalize(v1);
596 /* Return the sum of "v1" and "v2".
598 __isl_give isl_val *isl_val_add_ui(__isl_take isl_val *v1, unsigned long v2)
602 if (!isl_val_is_rat(v1))
606 v1 = isl_val_cow(v1);
610 isl_int_addmul_ui(v1->n, v1->d, v2);
615 /* Subtract "v2" from "v1".
617 __isl_give isl_val *isl_val_sub(__isl_take isl_val *v1, __isl_take isl_val *v2)
621 if (isl_val_is_nan(v1)) {
625 if (isl_val_is_nan(v2)) {
629 if ((isl_val_is_infty(v1) && isl_val_is_infty(v2)) ||
630 (isl_val_is_neginfty(v1) && isl_val_is_neginfty(v2))) {
632 return isl_val_set_nan(v1);
634 if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1)) {
638 if (isl_val_is_infty(v2) || isl_val_is_neginfty(v2)) {
640 return isl_val_neg(v2);
642 if (isl_val_is_zero(v2)) {
646 if (isl_val_is_zero(v1)) {
648 return isl_val_neg(v2);
651 v1 = isl_val_cow(v1);
654 if (isl_val_is_int(v1) && isl_val_is_int(v2))
655 isl_int_sub(v1->n, v1->n, v2->n);
657 if (isl_int_eq(v1->d, v2->d))
658 isl_int_sub(v1->n, v1->n, v2->n);
660 isl_int_mul(v1->n, v1->n, v2->d);
661 isl_int_submul(v1->n, v2->n, v1->d);
662 isl_int_mul(v1->d, v1->d, v2->d);
664 v1 = isl_val_normalize(v1);
674 /* Subtract "v2" from "v1".
676 __isl_give isl_val *isl_val_sub_ui(__isl_take isl_val *v1, unsigned long v2)
680 if (!isl_val_is_rat(v1))
684 v1 = isl_val_cow(v1);
688 isl_int_submul_ui(v1->n, v1->d, v2);
693 /* Return the product of "v1" and "v2".
695 __isl_give isl_val *isl_val_mul(__isl_take isl_val *v1, __isl_take isl_val *v2)
699 if (isl_val_is_nan(v1)) {
703 if (isl_val_is_nan(v2)) {
707 if ((!isl_val_is_rat(v1) && isl_val_is_zero(v2)) ||
708 (isl_val_is_zero(v1) && !isl_val_is_rat(v2))) {
710 return isl_val_set_nan(v1);
712 if (isl_val_is_zero(v1)) {
716 if (isl_val_is_zero(v2)) {
720 if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1)) {
721 if (isl_val_is_neg(v2))
722 v1 = isl_val_neg(v1);
726 if (isl_val_is_infty(v2) || isl_val_is_neginfty(v2)) {
727 if (isl_val_is_neg(v1))
728 v2 = isl_val_neg(v2);
733 v1 = isl_val_cow(v1);
736 if (isl_val_is_int(v1) && isl_val_is_int(v2))
737 isl_int_mul(v1->n, v1->n, v2->n);
739 isl_int_mul(v1->n, v1->n, v2->n);
740 isl_int_mul(v1->d, v1->d, v2->d);
741 v1 = isl_val_normalize(v1);
751 /* Return the product of "v1" and "v2".
753 __isl_give isl_val *isl_val_mul_ui(__isl_take isl_val *v1, unsigned long v2)
757 if (isl_val_is_nan(v1))
759 if (!isl_val_is_rat(v1)) {
761 v1 = isl_val_set_nan(v1);
766 v1 = isl_val_cow(v1);
770 isl_int_mul_ui(v1->n, v1->n, v2);
772 return isl_val_normalize(v1);
775 /* Divide "v1" by "v2".
777 __isl_give isl_val *isl_val_div(__isl_take isl_val *v1, __isl_take isl_val *v2)
781 if (isl_val_is_nan(v1)) {
785 if (isl_val_is_nan(v2)) {
789 if (isl_val_is_zero(v2) ||
790 (!isl_val_is_rat(v1) && !isl_val_is_rat(v2))) {
792 return isl_val_set_nan(v1);
794 if (isl_val_is_zero(v1)) {
798 if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1)) {
799 if (isl_val_is_neg(v2))
800 v1 = isl_val_neg(v1);
804 if (isl_val_is_infty(v2) || isl_val_is_neginfty(v2)) {
806 return isl_val_set_zero(v1);
809 v1 = isl_val_cow(v1);
812 if (isl_val_is_int(v2)) {
813 isl_int_mul(v1->d, v1->d, v2->n);
814 v1 = isl_val_normalize(v1);
816 isl_int_mul(v1->d, v1->d, v2->n);
817 isl_int_mul(v1->n, v1->n, v2->d);
818 v1 = isl_val_normalize(v1);
828 /* Given two integer values "v1" and "v2", check if "v1" is divisible by "v2".
830 int isl_val_is_divisible_by(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
835 if (!isl_val_is_int(v1) || !isl_val_is_int(v2))
836 isl_die(isl_val_get_ctx(v1), isl_error_invalid,
837 "expecting two integers", return -1);
839 return isl_int_is_divisible_by(v1->n, v2->n);
842 /* Given two integer values "v1" and "v2", return the residue of "v1"
845 __isl_give isl_val *isl_val_mod(__isl_take isl_val *v1, __isl_take isl_val *v2)
849 if (!isl_val_is_int(v1) || !isl_val_is_int(v2))
850 isl_die(isl_val_get_ctx(v1), isl_error_invalid,
851 "expecting two integers", goto error);
852 if (isl_val_is_nonneg(v1) && isl_val_lt(v1, v2)) {
856 v1 = isl_val_cow(v1);
859 isl_int_fdiv_r(v1->n, v1->n, v2->n);
868 /* Given two integer values, return their greatest common divisor.
870 __isl_give isl_val *isl_val_gcd(__isl_take isl_val *v1, __isl_take isl_val *v2)
874 if (!isl_val_is_int(v1) || !isl_val_is_int(v2))
875 isl_die(isl_val_get_ctx(v1), isl_error_invalid,
876 "expecting two integers", goto error);
877 if (isl_val_eq(v1, v2)) {
881 if (isl_val_is_one(v1)) {
885 if (isl_val_is_one(v2)) {
889 v1 = isl_val_cow(v1);
892 isl_int_gcd(v1->n, v1->n, v2->n);
901 /* Given two integer values v1 and v2, return their greatest common divisor g,
902 * as well as two integers x and y such that x * v1 + y * v2 = g.
904 __isl_give isl_val *isl_val_gcdext(__isl_take isl_val *v1,
905 __isl_take isl_val *v2, __isl_give isl_val **x, __isl_give isl_val **y)
908 isl_val *a = NULL, *b = NULL;
911 return isl_val_gcd(v1, v2);
916 ctx = isl_val_get_ctx(v1);
917 if (!isl_val_is_int(v1) || !isl_val_is_int(v2))
918 isl_die(ctx, isl_error_invalid,
919 "expecting two integers", goto error);
921 v1 = isl_val_cow(v1);
922 a = isl_val_alloc(ctx);
923 b = isl_val_alloc(ctx);
926 isl_int_gcdext(v1->n, a->n, b->n, v1->n, v2->n);
928 isl_int_set_si(a->d, 1);
933 isl_int_set_si(b->d, 1);
951 /* Does "v" represent an integer value?
953 int isl_val_is_int(__isl_keep isl_val *v)
958 return isl_int_is_one(v->d);
961 /* Does "v" represent a rational value?
963 int isl_val_is_rat(__isl_keep isl_val *v)
968 return !isl_int_is_zero(v->d);
971 /* Does "v" represent NaN?
973 int isl_val_is_nan(__isl_keep isl_val *v)
978 return isl_int_is_zero(v->n) && isl_int_is_zero(v->d);
981 /* Does "v" represent +infinity?
983 int isl_val_is_infty(__isl_keep isl_val *v)
988 return isl_int_is_pos(v->n) && isl_int_is_zero(v->d);
991 /* Does "v" represent -infinity?
993 int isl_val_is_neginfty(__isl_keep isl_val *v)
998 return isl_int_is_neg(v->n) && isl_int_is_zero(v->d);
1001 /* Does "v" represent the integer zero?
1003 int isl_val_is_zero(__isl_keep isl_val *v)
1008 return isl_int_is_zero(v->n) && !isl_int_is_zero(v->d);
1011 /* Does "v" represent the integer one?
1013 int isl_val_is_one(__isl_keep isl_val *v)
1018 return isl_int_eq(v->n, v->d);
1021 /* Does "v" represent the integer negative one?
1023 int isl_val_is_negone(__isl_keep isl_val *v)
1028 return isl_int_is_neg(v->n) && isl_int_abs_eq(v->n, v->d);
1031 /* Is "v" (strictly) positive?
1033 int isl_val_is_pos(__isl_keep isl_val *v)
1038 return isl_int_is_pos(v->n);
1041 /* Is "v" (strictly) negative?
1043 int isl_val_is_neg(__isl_keep isl_val *v)
1048 return isl_int_is_neg(v->n);
1051 /* Is "v" non-negative?
1053 int isl_val_is_nonneg(__isl_keep isl_val *v)
1058 if (isl_val_is_nan(v))
1061 return isl_int_is_nonneg(v->n);
1064 /* Is "v" non-positive?
1066 int isl_val_is_nonpos(__isl_keep isl_val *v)
1071 if (isl_val_is_nan(v))
1074 return isl_int_is_nonpos(v->n);
1077 /* Return the sign of "v".
1079 * The sign of NaN is undefined.
1081 int isl_val_sgn(__isl_keep isl_val *v)
1085 if (isl_val_is_zero(v))
1087 if (isl_val_is_pos(v))
1092 /* Is "v1" (strictly) less than "v2"?
1094 int isl_val_lt(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1101 if (isl_val_is_int(v1) && isl_val_is_int(v2))
1102 return isl_int_lt(v1->n, v2->n);
1103 if (isl_val_is_nan(v1) || isl_val_is_nan(v2))
1105 if (isl_val_eq(v1, v2))
1107 if (isl_val_is_infty(v2))
1109 if (isl_val_is_infty(v1))
1111 if (isl_val_is_neginfty(v1))
1113 if (isl_val_is_neginfty(v2))
1117 isl_int_mul(t, v1->n, v2->d);
1118 isl_int_submul(t, v2->n, v1->d);
1119 lt = isl_int_is_neg(t);
1125 /* Is "v1" (strictly) greater than "v2"?
1127 int isl_val_gt(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1129 return isl_val_lt(v2, v1);
1132 /* Is "v1" less than or equal to "v2"?
1134 int isl_val_le(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1141 if (isl_val_is_int(v1) && isl_val_is_int(v2))
1142 return isl_int_le(v1->n, v2->n);
1143 if (isl_val_is_nan(v1) || isl_val_is_nan(v2))
1145 if (isl_val_eq(v1, v2))
1147 if (isl_val_is_infty(v2))
1149 if (isl_val_is_infty(v1))
1151 if (isl_val_is_neginfty(v1))
1153 if (isl_val_is_neginfty(v2))
1157 isl_int_mul(t, v1->n, v2->d);
1158 isl_int_submul(t, v2->n, v1->d);
1159 le = isl_int_is_nonpos(t);
1165 /* Is "v1" greater than or equal to "v2"?
1167 int isl_val_ge(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1169 return isl_val_le(v2, v1);
1172 /* How does "v" compare to "i"?
1174 * Return 1 if v is greater, -1 if v is smaller and 0 if v is equal to i.
1176 * If v is NaN (or NULL), then the result is undefined.
1178 int isl_val_cmp_si(__isl_keep isl_val *v, long i)
1185 if (isl_val_is_int(v))
1186 return isl_int_cmp_si(v->n, i);
1187 if (isl_val_is_nan(v))
1189 if (isl_val_is_infty(v))
1191 if (isl_val_is_neginfty(v))
1195 isl_int_mul_si(t, v->d, i);
1196 isl_int_sub(t, v->n, t);
1197 cmp = isl_int_sgn(t);
1203 /* Is "v1" equal to "v2"?
1205 int isl_val_eq(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1209 if (isl_val_is_nan(v1) || isl_val_is_nan(v2))
1212 return isl_int_eq(v1->n, v2->n) && isl_int_eq(v1->d, v2->d);
1215 /* Is "v1" different from "v2"?
1217 int isl_val_ne(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1221 if (isl_val_is_nan(v1) || isl_val_is_nan(v2))
1224 return isl_int_ne(v1->n, v2->n) || isl_int_ne(v1->d, v2->d);
1227 /* Print a textual representation of "v" onto "p".
1229 __isl_give isl_printer *isl_printer_print_val(__isl_take isl_printer *p,
1230 __isl_keep isl_val *v)
1235 return isl_printer_free(p);
1237 neg = isl_int_is_neg(v->n);
1239 p = isl_printer_print_str(p, "-");
1240 isl_int_neg(v->n, v->n);
1242 if (isl_int_is_zero(v->d)) {
1243 int sgn = isl_int_sgn(v->n);
1244 p = isl_printer_print_str(p, sgn < 0 ? "-infty" :
1245 sgn == 0 ? "NaN" : "infty");
1247 p = isl_printer_print_isl_int(p, v->n);
1249 isl_int_neg(v->n, v->n);
1250 if (!isl_int_is_zero(v->d) && !isl_int_is_one(v->d)) {
1251 p = isl_printer_print_str(p, "/");
1252 p = isl_printer_print_isl_int(p, v->d);