isl_pw_*_eval: fix type of variable
[isl.git] / isl_val.c
blob3f8560471421e97b3e0e5bda06ef86cd30f86e19
1 /*
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
8 */
10 #include <isl_int.h>
11 #include <isl_ctx_private.h>
12 #include <isl_val_private.h>
14 #undef BASE
15 #define BASE val
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)
23 isl_val *v;
25 v = isl_alloc_type(ctx, struct isl_val);
26 if (!v)
27 return NULL;
29 v->ctx = ctx;
30 isl_ctx_ref(ctx);
31 v->ref = 1;
32 isl_int_init(v->n);
33 isl_int_init(v->d);
35 return v;
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 negative one.
54 __isl_give isl_val *isl_val_negone(isl_ctx *ctx)
56 return isl_val_int_from_si(ctx, -1);
59 /* Return a reference to an isl_val representing NaN.
61 __isl_give isl_val *isl_val_nan(isl_ctx *ctx)
63 isl_val *v;
65 v = isl_val_alloc(ctx);
66 if (!v)
67 return NULL;
69 isl_int_set_si(v->n, 0);
70 isl_int_set_si(v->d, 0);
72 return v;
75 /* Change "v" into a NaN.
77 __isl_give isl_val *isl_val_set_nan(__isl_take isl_val *v)
79 if (!v)
80 return NULL;
81 if (isl_val_is_nan(v))
82 return v;
83 v = isl_val_cow(v);
84 if (!v)
85 return NULL;
87 isl_int_set_si(v->n, 0);
88 isl_int_set_si(v->d, 0);
90 return v;
93 /* Return a reference to an isl_val representing +infinity.
95 __isl_give isl_val *isl_val_infty(isl_ctx *ctx)
97 isl_val *v;
99 v = isl_val_alloc(ctx);
100 if (!v)
101 return NULL;
103 isl_int_set_si(v->n, 1);
104 isl_int_set_si(v->d, 0);
106 return v;
109 /* Return a reference to an isl_val representing -infinity.
111 __isl_give isl_val *isl_val_neginfty(isl_ctx *ctx)
113 isl_val *v;
115 v = isl_val_alloc(ctx);
116 if (!v)
117 return NULL;
119 isl_int_set_si(v->n, -1);
120 isl_int_set_si(v->d, 0);
122 return v;
125 /* Return a reference to an isl_val representing the integer "i".
127 __isl_give isl_val *isl_val_int_from_si(isl_ctx *ctx, long i)
129 isl_val *v;
131 v = isl_val_alloc(ctx);
132 if (!v)
133 return NULL;
135 isl_int_set_si(v->n, i);
136 isl_int_set_si(v->d, 1);
138 return v;
141 /* Change the value of "v" to be equal to the integer "i".
143 __isl_give isl_val *isl_val_set_si(__isl_take isl_val *v, long i)
145 if (!v)
146 return NULL;
147 if (isl_val_is_int(v) && isl_int_cmp_si(v->n, i) == 0)
148 return v;
149 v = isl_val_cow(v);
150 if (!v)
151 return NULL;
153 isl_int_set_si(v->n, i);
154 isl_int_set_si(v->d, 1);
156 return v;
159 /* Change the value of "v" to be equal to zero.
161 __isl_give isl_val *isl_val_set_zero(__isl_take isl_val *v)
163 return isl_val_set_si(v, 0);
166 /* Return a reference to an isl_val representing the unsigned integer "u".
168 __isl_give isl_val *isl_val_int_from_ui(isl_ctx *ctx, unsigned long u)
170 isl_val *v;
172 v = isl_val_alloc(ctx);
173 if (!v)
174 return NULL;
176 isl_int_set_ui(v->n, u);
177 isl_int_set_si(v->d, 1);
179 return v;
182 /* Return a reference to an isl_val representing the integer "n".
184 __isl_give isl_val *isl_val_int_from_isl_int(isl_ctx *ctx, isl_int n)
186 isl_val *v;
188 v = isl_val_alloc(ctx);
189 if (!v)
190 return NULL;
192 isl_int_set(v->n, n);
193 isl_int_set_si(v->d, 1);
195 return v;
198 /* Return a reference to an isl_val representing the rational value "n"/"d".
199 * Normalizing the isl_val (if needed) is left to the caller.
201 __isl_give isl_val *isl_val_rat_from_isl_int(isl_ctx *ctx,
202 isl_int n, isl_int d)
204 isl_val *v;
206 v = isl_val_alloc(ctx);
207 if (!v)
208 return NULL;
210 isl_int_set(v->n, n);
211 isl_int_set(v->d, d);
213 return v;
216 /* Return a new reference to "v".
218 __isl_give isl_val *isl_val_copy(__isl_keep isl_val *v)
220 if (!v)
221 return NULL;
223 v->ref++;
224 return v;
227 /* Return a fresh copy of "val".
229 __isl_give isl_val *isl_val_dup(__isl_keep isl_val *val)
231 isl_val *dup;
233 if (!val)
234 return NULL;
236 dup = isl_val_alloc(isl_val_get_ctx(val));
237 if (!dup)
238 return NULL;
240 isl_int_set(dup->n, val->n);
241 isl_int_set(dup->d, val->d);
243 return dup;
246 /* Return an isl_val that is equal to "val" and that has only
247 * a single reference.
249 __isl_give isl_val *isl_val_cow(__isl_take isl_val *val)
251 if (!val)
252 return NULL;
254 if (val->ref == 1)
255 return val;
256 val->ref--;
257 return isl_val_dup(val);
260 /* Free "v" and return NULL.
262 __isl_null isl_val *isl_val_free(__isl_take isl_val *v)
264 if (!v)
265 return NULL;
267 if (--v->ref > 0)
268 return NULL;
270 isl_ctx_deref(v->ctx);
271 isl_int_clear(v->n);
272 isl_int_clear(v->d);
273 free(v);
274 return NULL;
277 /* Extract the numerator of a rational value "v" as an integer.
279 * If "v" is not a rational value, then the result is undefined.
281 long isl_val_get_num_si(__isl_keep isl_val *v)
283 if (!v)
284 return 0;
285 if (!isl_val_is_rat(v))
286 isl_die(isl_val_get_ctx(v), isl_error_invalid,
287 "expecting rational value", return 0);
288 if (!isl_int_fits_slong(v->n))
289 isl_die(isl_val_get_ctx(v), isl_error_invalid,
290 "numerator too large", return 0);
291 return isl_int_get_si(v->n);
294 /* Extract the numerator of a rational value "v" as an isl_int.
296 * If "v" is not a rational value, then the result is undefined.
298 int isl_val_get_num_isl_int(__isl_keep isl_val *v, isl_int *n)
300 if (!v)
301 return -1;
302 if (!isl_val_is_rat(v))
303 isl_die(isl_val_get_ctx(v), isl_error_invalid,
304 "expecting rational value", return -1);
305 isl_int_set(*n, v->n);
306 return 0;
309 /* Extract the denominator of a rational value "v" as an integer.
311 * If "v" is not a rational value, then the result is undefined.
313 long isl_val_get_den_si(__isl_keep isl_val *v)
315 if (!v)
316 return 0;
317 if (!isl_val_is_rat(v))
318 isl_die(isl_val_get_ctx(v), isl_error_invalid,
319 "expecting rational value", return 0);
320 if (!isl_int_fits_slong(v->d))
321 isl_die(isl_val_get_ctx(v), isl_error_invalid,
322 "denominator too large", return 0);
323 return isl_int_get_si(v->d);
326 /* Extract the denominator of a rational value "v" as an isl_val.
328 * If "v" is not a rational value, then the result is undefined.
330 __isl_give isl_val *isl_val_get_den_val(__isl_keep isl_val *v)
332 if (!v)
333 return NULL;
334 if (!isl_val_is_rat(v))
335 isl_die(isl_val_get_ctx(v), isl_error_invalid,
336 "expecting rational value", return NULL);
337 return isl_val_int_from_isl_int(isl_val_get_ctx(v), v->d);
340 /* Return an approximation of "v" as a double.
342 double isl_val_get_d(__isl_keep isl_val *v)
344 if (!v)
345 return 0;
346 if (!isl_val_is_rat(v))
347 isl_die(isl_val_get_ctx(v), isl_error_invalid,
348 "expecting rational value", return 0);
349 return isl_int_get_d(v->n) / isl_int_get_d(v->d);
352 /* Return the isl_ctx to which "val" belongs.
354 isl_ctx *isl_val_get_ctx(__isl_keep isl_val *val)
356 return val ? val->ctx : NULL;
359 /* Return a hash value that digests "val".
361 uint32_t isl_val_get_hash(__isl_keep isl_val *val)
363 uint32_t hash;
365 if (!val)
366 return 0;
368 hash = isl_hash_init();
369 hash = isl_int_hash(val->n, hash);
370 hash = isl_int_hash(val->d, hash);
372 return hash;
375 /* Normalize "v".
377 * In particular, make sure that the denominator of a rational value
378 * is positive and the numerator and denominator do not have any
379 * common divisors.
381 * This function should not be called by an external user
382 * since it will only be given normalized values.
384 __isl_give isl_val *isl_val_normalize(__isl_take isl_val *v)
386 isl_ctx *ctx;
388 if (!v)
389 return NULL;
390 if (isl_val_is_int(v))
391 return v;
392 if (!isl_val_is_rat(v))
393 return v;
394 if (isl_int_is_neg(v->d)) {
395 isl_int_neg(v->d, v->d);
396 isl_int_neg(v->n, v->n);
398 ctx = isl_val_get_ctx(v);
399 isl_int_gcd(ctx->normalize_gcd, v->n, v->d);
400 if (isl_int_is_one(ctx->normalize_gcd))
401 return v;
402 isl_int_divexact(v->n, v->n, ctx->normalize_gcd);
403 isl_int_divexact(v->d, v->d, ctx->normalize_gcd);
404 return v;
407 /* Return the opposite of "v".
409 __isl_give isl_val *isl_val_neg(__isl_take isl_val *v)
411 if (!v)
412 return NULL;
413 if (isl_val_is_nan(v))
414 return v;
415 if (isl_val_is_zero(v))
416 return v;
418 v = isl_val_cow(v);
419 if (!v)
420 return NULL;
421 isl_int_neg(v->n, v->n);
423 return v;
426 /* Return the inverse of "v".
428 __isl_give isl_val *isl_val_inv(__isl_take isl_val *v)
430 if (!v)
431 return NULL;
432 if (isl_val_is_nan(v))
433 return v;
434 if (isl_val_is_zero(v)) {
435 isl_ctx *ctx = isl_val_get_ctx(v);
436 isl_val_free(v);
437 return isl_val_nan(ctx);
439 if (isl_val_is_infty(v) || isl_val_is_neginfty(v)) {
440 isl_ctx *ctx = isl_val_get_ctx(v);
441 isl_val_free(v);
442 return isl_val_zero(ctx);
445 v = isl_val_cow(v);
446 if (!v)
447 return NULL;
448 isl_int_swap(v->n, v->d);
450 return isl_val_normalize(v);
453 /* Return the absolute value of "v".
455 __isl_give isl_val *isl_val_abs(__isl_take isl_val *v)
457 if (!v)
458 return NULL;
459 if (isl_val_is_nan(v))
460 return v;
461 if (isl_val_is_nonneg(v))
462 return v;
463 return isl_val_neg(v);
466 /* Return the "floor" (greatest integer part) of "v".
467 * That is, return the result of rounding towards -infinity.
469 __isl_give isl_val *isl_val_floor(__isl_take isl_val *v)
471 if (!v)
472 return NULL;
473 if (isl_val_is_int(v))
474 return v;
475 if (!isl_val_is_rat(v))
476 return v;
478 v = isl_val_cow(v);
479 if (!v)
480 return NULL;
481 isl_int_fdiv_q(v->n, v->n, v->d);
482 isl_int_set_si(v->d, 1);
484 return v;
487 /* Return the "ceiling" of "v".
488 * That is, return the result of rounding towards +infinity.
490 __isl_give isl_val *isl_val_ceil(__isl_take isl_val *v)
492 if (!v)
493 return NULL;
494 if (isl_val_is_int(v))
495 return v;
496 if (!isl_val_is_rat(v))
497 return v;
499 v = isl_val_cow(v);
500 if (!v)
501 return NULL;
502 isl_int_cdiv_q(v->n, v->n, v->d);
503 isl_int_set_si(v->d, 1);
505 return v;
508 /* Truncate "v".
509 * That is, return the result of rounding towards zero.
511 __isl_give isl_val *isl_val_trunc(__isl_take isl_val *v)
513 if (!v)
514 return NULL;
515 if (isl_val_is_int(v))
516 return v;
517 if (!isl_val_is_rat(v))
518 return v;
520 v = isl_val_cow(v);
521 if (!v)
522 return NULL;
523 isl_int_tdiv_q(v->n, v->n, v->d);
524 isl_int_set_si(v->d, 1);
526 return v;
529 /* Return 2^v, where v is an integer (that is not too large).
531 __isl_give isl_val *isl_val_2exp(__isl_take isl_val *v)
533 unsigned long exp;
534 int neg;
536 v = isl_val_cow(v);
537 if (!v)
538 return NULL;
539 if (!isl_val_is_int(v))
540 isl_die(isl_val_get_ctx(v), isl_error_invalid,
541 "can only compute integer powers",
542 return isl_val_free(v));
543 neg = isl_val_is_neg(v);
544 if (neg)
545 isl_int_neg(v->n, v->n);
546 if (!isl_int_fits_ulong(v->n))
547 isl_die(isl_val_get_ctx(v), isl_error_invalid,
548 "exponent too large", return isl_val_free(v));
549 exp = isl_int_get_ui(v->n);
550 if (neg) {
551 isl_int_mul_2exp(v->d, v->d, exp);
552 isl_int_set_si(v->n, 1);
553 } else {
554 isl_int_mul_2exp(v->n, v->d, exp);
557 return v;
560 /* Return the minimum of "v1" and "v2".
562 __isl_give isl_val *isl_val_min(__isl_take isl_val *v1, __isl_take isl_val *v2)
564 if (!v1 || !v2)
565 goto error;
567 if (isl_val_is_nan(v1)) {
568 isl_val_free(v2);
569 return v1;
571 if (isl_val_is_nan(v2)) {
572 isl_val_free(v1);
573 return v2;
575 if (isl_val_le(v1, v2)) {
576 isl_val_free(v2);
577 return v1;
578 } else {
579 isl_val_free(v1);
580 return v2;
582 error:
583 isl_val_free(v1);
584 isl_val_free(v2);
585 return NULL;
588 /* Return the maximum of "v1" and "v2".
590 __isl_give isl_val *isl_val_max(__isl_take isl_val *v1, __isl_take isl_val *v2)
592 if (!v1 || !v2)
593 goto error;
595 if (isl_val_is_nan(v1)) {
596 isl_val_free(v2);
597 return v1;
599 if (isl_val_is_nan(v2)) {
600 isl_val_free(v1);
601 return v2;
603 if (isl_val_ge(v1, v2)) {
604 isl_val_free(v2);
605 return v1;
606 } else {
607 isl_val_free(v1);
608 return v2;
610 error:
611 isl_val_free(v1);
612 isl_val_free(v2);
613 return NULL;
616 /* Return the sum of "v1" and "v2".
618 __isl_give isl_val *isl_val_add(__isl_take isl_val *v1, __isl_take isl_val *v2)
620 if (!v1 || !v2)
621 goto error;
622 if (isl_val_is_nan(v1)) {
623 isl_val_free(v2);
624 return v1;
626 if (isl_val_is_nan(v2)) {
627 isl_val_free(v1);
628 return v2;
630 if ((isl_val_is_infty(v1) && isl_val_is_neginfty(v2)) ||
631 (isl_val_is_neginfty(v1) && isl_val_is_infty(v2))) {
632 isl_val_free(v2);
633 return isl_val_set_nan(v1);
635 if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1)) {
636 isl_val_free(v2);
637 return v1;
639 if (isl_val_is_infty(v2) || isl_val_is_neginfty(v2)) {
640 isl_val_free(v1);
641 return v2;
643 if (isl_val_is_zero(v1)) {
644 isl_val_free(v1);
645 return v2;
647 if (isl_val_is_zero(v2)) {
648 isl_val_free(v2);
649 return v1;
652 v1 = isl_val_cow(v1);
653 if (!v1)
654 goto error;
655 if (isl_val_is_int(v1) && isl_val_is_int(v2))
656 isl_int_add(v1->n, v1->n, v2->n);
657 else {
658 if (isl_int_eq(v1->d, v2->d))
659 isl_int_add(v1->n, v1->n, v2->n);
660 else {
661 isl_int_mul(v1->n, v1->n, v2->d);
662 isl_int_addmul(v1->n, v2->n, v1->d);
663 isl_int_mul(v1->d, v1->d, v2->d);
665 v1 = isl_val_normalize(v1);
667 isl_val_free(v2);
668 return v1;
669 error:
670 isl_val_free(v1);
671 isl_val_free(v2);
672 return NULL;
675 /* Return the sum of "v1" and "v2".
677 __isl_give isl_val *isl_val_add_ui(__isl_take isl_val *v1, unsigned long v2)
679 if (!v1)
680 return NULL;
681 if (!isl_val_is_rat(v1))
682 return v1;
683 if (v2 == 0)
684 return v1;
685 v1 = isl_val_cow(v1);
686 if (!v1)
687 return NULL;
689 isl_int_addmul_ui(v1->n, v1->d, v2);
691 return v1;
694 /* Subtract "v2" from "v1".
696 __isl_give isl_val *isl_val_sub(__isl_take isl_val *v1, __isl_take isl_val *v2)
698 if (!v1 || !v2)
699 goto error;
700 if (isl_val_is_nan(v1)) {
701 isl_val_free(v2);
702 return v1;
704 if (isl_val_is_nan(v2)) {
705 isl_val_free(v1);
706 return v2;
708 if ((isl_val_is_infty(v1) && isl_val_is_infty(v2)) ||
709 (isl_val_is_neginfty(v1) && isl_val_is_neginfty(v2))) {
710 isl_val_free(v2);
711 return isl_val_set_nan(v1);
713 if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1)) {
714 isl_val_free(v2);
715 return v1;
717 if (isl_val_is_infty(v2) || isl_val_is_neginfty(v2)) {
718 isl_val_free(v1);
719 return isl_val_neg(v2);
721 if (isl_val_is_zero(v2)) {
722 isl_val_free(v2);
723 return v1;
725 if (isl_val_is_zero(v1)) {
726 isl_val_free(v1);
727 return isl_val_neg(v2);
730 v1 = isl_val_cow(v1);
731 if (!v1)
732 goto error;
733 if (isl_val_is_int(v1) && isl_val_is_int(v2))
734 isl_int_sub(v1->n, v1->n, v2->n);
735 else {
736 if (isl_int_eq(v1->d, v2->d))
737 isl_int_sub(v1->n, v1->n, v2->n);
738 else {
739 isl_int_mul(v1->n, v1->n, v2->d);
740 isl_int_submul(v1->n, v2->n, v1->d);
741 isl_int_mul(v1->d, v1->d, v2->d);
743 v1 = isl_val_normalize(v1);
745 isl_val_free(v2);
746 return v1;
747 error:
748 isl_val_free(v1);
749 isl_val_free(v2);
750 return NULL;
753 /* Subtract "v2" from "v1".
755 __isl_give isl_val *isl_val_sub_ui(__isl_take isl_val *v1, unsigned long v2)
757 if (!v1)
758 return NULL;
759 if (!isl_val_is_rat(v1))
760 return v1;
761 if (v2 == 0)
762 return v1;
763 v1 = isl_val_cow(v1);
764 if (!v1)
765 return NULL;
767 isl_int_submul_ui(v1->n, v1->d, v2);
769 return v1;
772 /* Return the product of "v1" and "v2".
774 __isl_give isl_val *isl_val_mul(__isl_take isl_val *v1, __isl_take isl_val *v2)
776 if (!v1 || !v2)
777 goto error;
778 if (isl_val_is_nan(v1)) {
779 isl_val_free(v2);
780 return v1;
782 if (isl_val_is_nan(v2)) {
783 isl_val_free(v1);
784 return v2;
786 if ((!isl_val_is_rat(v1) && isl_val_is_zero(v2)) ||
787 (isl_val_is_zero(v1) && !isl_val_is_rat(v2))) {
788 isl_val_free(v2);
789 return isl_val_set_nan(v1);
791 if (isl_val_is_zero(v1)) {
792 isl_val_free(v2);
793 return v1;
795 if (isl_val_is_zero(v2)) {
796 isl_val_free(v1);
797 return v2;
799 if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1)) {
800 if (isl_val_is_neg(v2))
801 v1 = isl_val_neg(v1);
802 isl_val_free(v2);
803 return v1;
805 if (isl_val_is_infty(v2) || isl_val_is_neginfty(v2)) {
806 if (isl_val_is_neg(v1))
807 v2 = isl_val_neg(v2);
808 isl_val_free(v1);
809 return v2;
812 v1 = isl_val_cow(v1);
813 if (!v1)
814 goto error;
815 if (isl_val_is_int(v1) && isl_val_is_int(v2))
816 isl_int_mul(v1->n, v1->n, v2->n);
817 else {
818 isl_int_mul(v1->n, v1->n, v2->n);
819 isl_int_mul(v1->d, v1->d, v2->d);
820 v1 = isl_val_normalize(v1);
822 isl_val_free(v2);
823 return v1;
824 error:
825 isl_val_free(v1);
826 isl_val_free(v2);
827 return NULL;
830 /* Return the product of "v1" and "v2".
832 * This is a private copy of isl_val_mul for use in the generic
833 * isl_multi_*_scale_val instantiated for isl_val.
835 __isl_give isl_val *isl_val_scale_val(__isl_take isl_val *v1,
836 __isl_take isl_val *v2)
838 return isl_val_mul(v1, v2);
841 /* Return the product of "v1" and "v2".
843 __isl_give isl_val *isl_val_mul_ui(__isl_take isl_val *v1, unsigned long v2)
845 if (!v1)
846 return NULL;
847 if (isl_val_is_nan(v1))
848 return v1;
849 if (!isl_val_is_rat(v1)) {
850 if (v2 == 0)
851 v1 = isl_val_set_nan(v1);
852 return v1;
854 if (v2 == 1)
855 return v1;
856 v1 = isl_val_cow(v1);
857 if (!v1)
858 return NULL;
860 isl_int_mul_ui(v1->n, v1->n, v2);
862 return isl_val_normalize(v1);
865 /* Divide "v1" by "v2".
867 __isl_give isl_val *isl_val_div(__isl_take isl_val *v1, __isl_take isl_val *v2)
869 if (!v1 || !v2)
870 goto error;
871 if (isl_val_is_nan(v1)) {
872 isl_val_free(v2);
873 return v1;
875 if (isl_val_is_nan(v2)) {
876 isl_val_free(v1);
877 return v2;
879 if (isl_val_is_zero(v2) ||
880 (!isl_val_is_rat(v1) && !isl_val_is_rat(v2))) {
881 isl_val_free(v2);
882 return isl_val_set_nan(v1);
884 if (isl_val_is_zero(v1)) {
885 isl_val_free(v2);
886 return v1;
888 if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1)) {
889 if (isl_val_is_neg(v2))
890 v1 = isl_val_neg(v1);
891 isl_val_free(v2);
892 return v1;
894 if (isl_val_is_infty(v2) || isl_val_is_neginfty(v2)) {
895 isl_val_free(v2);
896 return isl_val_set_zero(v1);
899 v1 = isl_val_cow(v1);
900 if (!v1)
901 goto error;
902 if (isl_val_is_int(v2)) {
903 isl_int_mul(v1->d, v1->d, v2->n);
904 v1 = isl_val_normalize(v1);
905 } else {
906 isl_int_mul(v1->d, v1->d, v2->n);
907 isl_int_mul(v1->n, v1->n, v2->d);
908 v1 = isl_val_normalize(v1);
910 isl_val_free(v2);
911 return v1;
912 error:
913 isl_val_free(v1);
914 isl_val_free(v2);
915 return NULL;
918 /* Divide "v1" by "v2".
920 __isl_give isl_val *isl_val_div_ui(__isl_take isl_val *v1, unsigned long v2)
922 if (!v1)
923 return NULL;
924 if (isl_val_is_nan(v1))
925 return v1;
926 if (v2 == 0)
927 return isl_val_set_nan(v1);
928 if (v2 == 1)
929 return v1;
930 if (isl_val_is_zero(v1))
931 return v1;
932 if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1))
933 return v1;
934 v1 = isl_val_cow(v1);
935 if (!v1)
936 return NULL;
938 isl_int_mul_ui(v1->d, v1->d, v2);
940 return isl_val_normalize(v1);
943 /* Divide "v1" by "v2".
945 * This is a private copy of isl_val_div for use in the generic
946 * isl_multi_*_scale_down_val instantiated for isl_val.
948 __isl_give isl_val *isl_val_scale_down_val(__isl_take isl_val *v1,
949 __isl_take isl_val *v2)
951 return isl_val_div(v1, v2);
954 /* Given two integer values "v1" and "v2", check if "v1" is divisible by "v2".
956 isl_bool isl_val_is_divisible_by(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
958 if (!v1 || !v2)
959 return isl_bool_error;
961 if (!isl_val_is_int(v1) || !isl_val_is_int(v2))
962 isl_die(isl_val_get_ctx(v1), isl_error_invalid,
963 "expecting two integers", return isl_bool_error);
965 return isl_int_is_divisible_by(v1->n, v2->n);
968 /* Given two integer values "v1" and "v2", return the residue of "v1"
969 * modulo "v2".
971 __isl_give isl_val *isl_val_mod(__isl_take isl_val *v1, __isl_take isl_val *v2)
973 if (!v1 || !v2)
974 goto error;
975 if (!isl_val_is_int(v1) || !isl_val_is_int(v2))
976 isl_die(isl_val_get_ctx(v1), isl_error_invalid,
977 "expecting two integers", goto error);
978 if (isl_val_is_nonneg(v1) && isl_val_lt(v1, v2)) {
979 isl_val_free(v2);
980 return v1;
982 v1 = isl_val_cow(v1);
983 if (!v1)
984 goto error;
985 isl_int_fdiv_r(v1->n, v1->n, v2->n);
986 isl_val_free(v2);
987 return v1;
988 error:
989 isl_val_free(v1);
990 isl_val_free(v2);
991 return NULL;
994 /* Given two integer values "v1" and "v2", return the residue of "v1"
995 * modulo "v2".
997 * This is a private copy of isl_val_mod for use in the generic
998 * isl_multi_*_mod_multi_val instantiated for isl_val.
1000 __isl_give isl_val *isl_val_mod_val(__isl_take isl_val *v1,
1001 __isl_take isl_val *v2)
1003 return isl_val_mod(v1, v2);
1006 /* Given two integer values, return their greatest common divisor.
1008 __isl_give isl_val *isl_val_gcd(__isl_take isl_val *v1, __isl_take isl_val *v2)
1010 if (!v1 || !v2)
1011 goto error;
1012 if (!isl_val_is_int(v1) || !isl_val_is_int(v2))
1013 isl_die(isl_val_get_ctx(v1), isl_error_invalid,
1014 "expecting two integers", goto error);
1015 if (isl_val_eq(v1, v2)) {
1016 isl_val_free(v2);
1017 return v1;
1019 if (isl_val_is_one(v1)) {
1020 isl_val_free(v2);
1021 return v1;
1023 if (isl_val_is_one(v2)) {
1024 isl_val_free(v1);
1025 return v2;
1027 v1 = isl_val_cow(v1);
1028 if (!v1)
1029 goto error;
1030 isl_int_gcd(v1->n, v1->n, v2->n);
1031 isl_val_free(v2);
1032 return v1;
1033 error:
1034 isl_val_free(v1);
1035 isl_val_free(v2);
1036 return NULL;
1039 /* Compute x, y and g such that g = gcd(a,b) and a*x+b*y = g.
1041 static void isl_int_gcdext(isl_int *g, isl_int *x, isl_int *y,
1042 isl_int a, isl_int b)
1044 isl_int d, tmp;
1045 isl_int a_copy, b_copy;
1047 isl_int_init(a_copy);
1048 isl_int_init(b_copy);
1049 isl_int_init(d);
1050 isl_int_init(tmp);
1051 isl_int_set(a_copy, a);
1052 isl_int_set(b_copy, b);
1053 isl_int_abs(*g, a_copy);
1054 isl_int_abs(d, b_copy);
1055 isl_int_set_si(*x, 1);
1056 isl_int_set_si(*y, 0);
1057 while (isl_int_is_pos(d)) {
1058 isl_int_fdiv_q(tmp, *g, d);
1059 isl_int_submul(*x, tmp, *y);
1060 isl_int_submul(*g, tmp, d);
1061 isl_int_swap(*g, d);
1062 isl_int_swap(*x, *y);
1064 if (isl_int_is_zero(a_copy))
1065 isl_int_set_si(*x, 0);
1066 else if (isl_int_is_neg(a_copy))
1067 isl_int_neg(*x, *x);
1068 if (isl_int_is_zero(b_copy))
1069 isl_int_set_si(*y, 0);
1070 else {
1071 isl_int_mul(tmp, a_copy, *x);
1072 isl_int_sub(tmp, *g, tmp);
1073 isl_int_divexact(*y, tmp, b_copy);
1075 isl_int_clear(d);
1076 isl_int_clear(tmp);
1077 isl_int_clear(a_copy);
1078 isl_int_clear(b_copy);
1081 /* Given two integer values v1 and v2, return their greatest common divisor g,
1082 * as well as two integers x and y such that x * v1 + y * v2 = g.
1084 __isl_give isl_val *isl_val_gcdext(__isl_take isl_val *v1,
1085 __isl_take isl_val *v2, __isl_give isl_val **x, __isl_give isl_val **y)
1087 isl_ctx *ctx;
1088 isl_val *a = NULL, *b = NULL;
1090 if (!x && !y)
1091 return isl_val_gcd(v1, v2);
1093 if (!v1 || !v2)
1094 goto error;
1096 ctx = isl_val_get_ctx(v1);
1097 if (!isl_val_is_int(v1) || !isl_val_is_int(v2))
1098 isl_die(ctx, isl_error_invalid,
1099 "expecting two integers", goto error);
1101 v1 = isl_val_cow(v1);
1102 a = isl_val_alloc(ctx);
1103 b = isl_val_alloc(ctx);
1104 if (!v1 || !a || !b)
1105 goto error;
1106 isl_int_gcdext(&v1->n, &a->n, &b->n, v1->n, v2->n);
1107 if (x) {
1108 isl_int_set_si(a->d, 1);
1109 *x = a;
1110 } else
1111 isl_val_free(a);
1112 if (y) {
1113 isl_int_set_si(b->d, 1);
1114 *y = b;
1115 } else
1116 isl_val_free(b);
1117 isl_val_free(v2);
1118 return v1;
1119 error:
1120 isl_val_free(v1);
1121 isl_val_free(v2);
1122 isl_val_free(a);
1123 isl_val_free(b);
1124 if (x)
1125 *x = NULL;
1126 if (y)
1127 *y = NULL;
1128 return NULL;
1131 /* Does "v" represent an integer value?
1133 isl_bool isl_val_is_int(__isl_keep isl_val *v)
1135 if (!v)
1136 return isl_bool_error;
1138 return isl_int_is_one(v->d);
1141 /* Does "v" represent a rational value?
1143 isl_bool isl_val_is_rat(__isl_keep isl_val *v)
1145 if (!v)
1146 return isl_bool_error;
1148 return !isl_int_is_zero(v->d);
1151 /* Does "v" represent NaN?
1153 isl_bool isl_val_is_nan(__isl_keep isl_val *v)
1155 if (!v)
1156 return isl_bool_error;
1158 return isl_int_is_zero(v->n) && isl_int_is_zero(v->d);
1161 /* Does "v" represent +infinity?
1163 isl_bool isl_val_is_infty(__isl_keep isl_val *v)
1165 if (!v)
1166 return isl_bool_error;
1168 return isl_int_is_pos(v->n) && isl_int_is_zero(v->d);
1171 /* Does "v" represent -infinity?
1173 isl_bool isl_val_is_neginfty(__isl_keep isl_val *v)
1175 if (!v)
1176 return isl_bool_error;
1178 return isl_int_is_neg(v->n) && isl_int_is_zero(v->d);
1181 /* Does "v" represent the integer zero?
1183 isl_bool isl_val_is_zero(__isl_keep isl_val *v)
1185 if (!v)
1186 return isl_bool_error;
1188 return isl_int_is_zero(v->n) && !isl_int_is_zero(v->d);
1191 /* Does "v" represent the integer one?
1193 isl_bool isl_val_is_one(__isl_keep isl_val *v)
1195 if (!v)
1196 return isl_bool_error;
1198 if (isl_val_is_nan(v))
1199 return isl_bool_false;
1201 return isl_int_eq(v->n, v->d);
1204 /* Does "v" represent the integer negative one?
1206 isl_bool isl_val_is_negone(__isl_keep isl_val *v)
1208 if (!v)
1209 return isl_bool_error;
1211 return isl_int_is_neg(v->n) && isl_int_abs_eq(v->n, v->d);
1214 /* Is "v" (strictly) positive?
1216 isl_bool isl_val_is_pos(__isl_keep isl_val *v)
1218 if (!v)
1219 return isl_bool_error;
1221 return isl_int_is_pos(v->n);
1224 /* Is "v" (strictly) negative?
1226 isl_bool isl_val_is_neg(__isl_keep isl_val *v)
1228 if (!v)
1229 return isl_bool_error;
1231 return isl_int_is_neg(v->n);
1234 /* Is "v" non-negative?
1236 isl_bool isl_val_is_nonneg(__isl_keep isl_val *v)
1238 if (!v)
1239 return isl_bool_error;
1241 if (isl_val_is_nan(v))
1242 return isl_bool_false;
1244 return isl_int_is_nonneg(v->n);
1247 /* Is "v" non-positive?
1249 isl_bool isl_val_is_nonpos(__isl_keep isl_val *v)
1251 if (!v)
1252 return isl_bool_error;
1254 if (isl_val_is_nan(v))
1255 return isl_bool_false;
1257 return isl_int_is_nonpos(v->n);
1260 /* Return the sign of "v".
1262 * The sign of NaN is undefined.
1264 int isl_val_sgn(__isl_keep isl_val *v)
1266 if (!v)
1267 return 0;
1268 if (isl_val_is_zero(v))
1269 return 0;
1270 if (isl_val_is_pos(v))
1271 return 1;
1272 return -1;
1275 /* Is "v1" (strictly) less than "v2"?
1277 isl_bool isl_val_lt(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1279 isl_int t;
1280 isl_bool lt;
1282 if (!v1 || !v2)
1283 return isl_bool_error;
1284 if (isl_val_is_int(v1) && isl_val_is_int(v2))
1285 return isl_int_lt(v1->n, v2->n);
1286 if (isl_val_is_nan(v1) || isl_val_is_nan(v2))
1287 return isl_bool_false;
1288 if (isl_val_eq(v1, v2))
1289 return isl_bool_false;
1290 if (isl_val_is_infty(v2))
1291 return isl_bool_true;
1292 if (isl_val_is_infty(v1))
1293 return isl_bool_false;
1294 if (isl_val_is_neginfty(v1))
1295 return isl_bool_true;
1296 if (isl_val_is_neginfty(v2))
1297 return isl_bool_false;
1299 isl_int_init(t);
1300 isl_int_mul(t, v1->n, v2->d);
1301 isl_int_submul(t, v2->n, v1->d);
1302 lt = isl_int_is_neg(t);
1303 isl_int_clear(t);
1305 return lt;
1308 /* Is "v1" (strictly) greater than "v2"?
1310 isl_bool isl_val_gt(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1312 return isl_val_lt(v2, v1);
1315 /* Is "v1" less than or equal to "v2"?
1317 isl_bool isl_val_le(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1319 isl_int t;
1320 isl_bool le;
1322 if (!v1 || !v2)
1323 return isl_bool_error;
1324 if (isl_val_is_int(v1) && isl_val_is_int(v2))
1325 return isl_int_le(v1->n, v2->n);
1326 if (isl_val_is_nan(v1) || isl_val_is_nan(v2))
1327 return isl_bool_false;
1328 if (isl_val_eq(v1, v2))
1329 return isl_bool_true;
1330 if (isl_val_is_infty(v2))
1331 return isl_bool_true;
1332 if (isl_val_is_infty(v1))
1333 return isl_bool_false;
1334 if (isl_val_is_neginfty(v1))
1335 return isl_bool_true;
1336 if (isl_val_is_neginfty(v2))
1337 return isl_bool_false;
1339 isl_int_init(t);
1340 isl_int_mul(t, v1->n, v2->d);
1341 isl_int_submul(t, v2->n, v1->d);
1342 le = isl_int_is_nonpos(t);
1343 isl_int_clear(t);
1345 return le;
1348 /* Is "v1" greater than or equal to "v2"?
1350 isl_bool isl_val_ge(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1352 return isl_val_le(v2, v1);
1355 /* How does "v" compare to "i"?
1357 * Return 1 if v is greater, -1 if v is smaller and 0 if v is equal to i.
1359 * If v is NaN (or NULL), then the result is undefined.
1361 int isl_val_cmp_si(__isl_keep isl_val *v, long i)
1363 isl_int t;
1364 int cmp;
1366 if (!v)
1367 return 0;
1368 if (isl_val_is_int(v))
1369 return isl_int_cmp_si(v->n, i);
1370 if (isl_val_is_nan(v))
1371 return 0;
1372 if (isl_val_is_infty(v))
1373 return 1;
1374 if (isl_val_is_neginfty(v))
1375 return -1;
1377 isl_int_init(t);
1378 isl_int_mul_si(t, v->d, i);
1379 isl_int_sub(t, v->n, t);
1380 cmp = isl_int_sgn(t);
1381 isl_int_clear(t);
1383 return cmp;
1386 /* Is "v1" equal to "v2"?
1388 isl_bool isl_val_eq(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1390 if (!v1 || !v2)
1391 return isl_bool_error;
1392 if (isl_val_is_nan(v1) || isl_val_is_nan(v2))
1393 return isl_bool_false;
1395 return isl_int_eq(v1->n, v2->n) && isl_int_eq(v1->d, v2->d);
1398 /* Is "v1" equal to "v2" in absolute value?
1400 isl_bool isl_val_abs_eq(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1402 if (!v1 || !v2)
1403 return isl_bool_error;
1404 if (isl_val_is_nan(v1) || isl_val_is_nan(v2))
1405 return isl_bool_false;
1407 return isl_int_abs_eq(v1->n, v2->n) && isl_int_eq(v1->d, v2->d);
1410 /* Is "v1" different from "v2"?
1412 isl_bool isl_val_ne(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1414 if (!v1 || !v2)
1415 return isl_bool_error;
1416 if (isl_val_is_nan(v1) || isl_val_is_nan(v2))
1417 return isl_bool_false;
1419 return isl_int_ne(v1->n, v2->n) || isl_int_ne(v1->d, v2->d);
1422 /* Print a textual representation of "v" onto "p".
1424 __isl_give isl_printer *isl_printer_print_val(__isl_take isl_printer *p,
1425 __isl_keep isl_val *v)
1427 int neg;
1429 if (!p || !v)
1430 return isl_printer_free(p);
1432 neg = isl_int_is_neg(v->n);
1433 if (neg) {
1434 p = isl_printer_print_str(p, "-");
1435 isl_int_neg(v->n, v->n);
1437 if (isl_int_is_zero(v->d)) {
1438 int sgn = isl_int_sgn(v->n);
1439 p = isl_printer_print_str(p, sgn < 0 ? "-infty" :
1440 sgn == 0 ? "NaN" : "infty");
1441 } else
1442 p = isl_printer_print_isl_int(p, v->n);
1443 if (neg)
1444 isl_int_neg(v->n, v->n);
1445 if (!isl_int_is_zero(v->d) && !isl_int_is_one(v->d)) {
1446 p = isl_printer_print_str(p, "/");
1447 p = isl_printer_print_isl_int(p, v->d);
1450 return p;
1453 /* Is "val1" (obviously) equal to "val2"?
1455 * This is a private copy of isl_val_eq for use in the generic
1456 * isl_multi_*_plain_is_equal instantiated for isl_val.
1458 int isl_val_plain_is_equal(__isl_keep isl_val *val1, __isl_keep isl_val *val2)
1460 return isl_val_eq(val1, val2);
1463 /* Does "v" have any non-zero coefficients
1464 * for any dimension in the given range?
1466 * This function is only meant to be used in the generic isl_multi_*
1467 * functions which have to deal with base objects that have an associated
1468 * space. Since an isl_val does not have any coefficients, this function
1469 * always return 0.
1471 int isl_val_involves_dims(__isl_keep isl_val *v, enum isl_dim_type type,
1472 unsigned first, unsigned n)
1474 if (!v)
1475 return -1;
1477 return 0;
1480 /* Insert "n" dimensions of type "type" at position "first".
1482 * This function is only meant to be used in the generic isl_multi_*
1483 * functions which have to deal with base objects that have an associated
1484 * space. Since an isl_val does not have an associated space, this function
1485 * does not do anything.
1487 __isl_give isl_val *isl_val_insert_dims(__isl_take isl_val *v,
1488 enum isl_dim_type type, unsigned first, unsigned n)
1490 return v;
1493 /* Drop the "n" first dimensions of type "type" at position "first".
1495 * This function is only meant to be used in the generic isl_multi_*
1496 * functions which have to deal with base objects that have an associated
1497 * space. Since an isl_val does not have an associated space, this function
1498 * does not do anything.
1500 __isl_give isl_val *isl_val_drop_dims(__isl_take isl_val *v,
1501 enum isl_dim_type type, unsigned first, unsigned n)
1503 return v;
1506 /* Change the name of the dimension of type "type" at position "pos" to "s".
1508 * This function is only meant to be used in the generic isl_multi_*
1509 * functions which have to deal with base objects that have an associated
1510 * space. Since an isl_val does not have an associated space, this function
1511 * does not do anything.
1513 __isl_give isl_val *isl_val_set_dim_name(__isl_take isl_val *v,
1514 enum isl_dim_type type, unsigned pos, const char *s)
1516 return v;
1519 /* Return the space of "v".
1521 * This function is only meant to be used in the generic isl_multi_*
1522 * functions which have to deal with base objects that have an associated
1523 * space. The conditions surrounding the call to this function make sure
1524 * that this function will never actually get called. We return a valid
1525 * space anyway, just in case.
1527 __isl_give isl_space *isl_val_get_space(__isl_keep isl_val *v)
1529 if (!v)
1530 return NULL;
1532 return isl_space_params_alloc(isl_val_get_ctx(v), 0);
1535 /* Reset the domain space of "v" to "space".
1537 * This function is only meant to be used in the generic isl_multi_*
1538 * functions which have to deal with base objects that have an associated
1539 * space. Since an isl_val does not have an associated space, this function
1540 * does not do anything, apart from error handling and cleaning up memory.
1542 __isl_give isl_val *isl_val_reset_domain_space(__isl_take isl_val *v,
1543 __isl_take isl_space *space)
1545 if (!space)
1546 return isl_val_free(v);
1547 isl_space_free(space);
1548 return v;
1551 /* Align the parameters of "v" to those of "space".
1553 * This function is only meant to be used in the generic isl_multi_*
1554 * functions which have to deal with base objects that have an associated
1555 * space. Since an isl_val does not have an associated space, this function
1556 * does not do anything, apart from error handling and cleaning up memory.
1557 * Note that the conditions surrounding the call to this function make sure
1558 * that this function will never actually get called.
1560 __isl_give isl_val *isl_val_align_params(__isl_take isl_val *v,
1561 __isl_take isl_space *space)
1563 if (!space)
1564 return isl_val_free(v);
1565 isl_space_free(space);
1566 return v;
1569 /* Reorder the dimensions of the domain of "v" according
1570 * to the given reordering.
1572 * This function is only meant to be used in the generic isl_multi_*
1573 * functions which have to deal with base objects that have an associated
1574 * space. Since an isl_val does not have an associated space, this function
1575 * does not do anything, apart from error handling and cleaning up memory.
1577 __isl_give isl_val *isl_val_realign_domain(__isl_take isl_val *v,
1578 __isl_take isl_reordering *r)
1580 if (!r)
1581 return isl_val_free(v);
1582 isl_reordering_free(r);
1583 return v;
1586 /* Return an isl_val that is zero on "ls".
1588 * This function is only meant to be used in the generic isl_multi_*
1589 * functions which have to deal with base objects that have an associated
1590 * space. Since an isl_val does not have an associated space, this function
1591 * simply returns a zero isl_val in the same context as "ls".
1593 __isl_give isl_val *isl_val_zero_on_domain(__isl_take isl_local_space *ls)
1595 isl_ctx *ctx;
1597 if (!ls)
1598 return NULL;
1599 ctx = isl_local_space_get_ctx(ls);
1600 isl_local_space_free(ls);
1601 return isl_val_zero(ctx);
1604 /* Do the parameters of "v" match those of "space"?
1606 * This function is only meant to be used in the generic isl_multi_*
1607 * functions which have to deal with base objects that have an associated
1608 * space. Since an isl_val does not have an associated space, this function
1609 * simply returns true, except if "v" or "space" are NULL.
1611 isl_bool isl_val_matching_params(__isl_keep isl_val *v,
1612 __isl_keep isl_space *space)
1614 if (!v || !space)
1615 return isl_bool_error;
1616 return isl_bool_true;
1619 /* Check that the domain space of "v" matches "space".
1621 * This function is only meant to be used in the generic isl_multi_*
1622 * functions which have to deal with base objects that have an associated
1623 * space. Since an isl_val does not have an associated space, this function
1624 * simply returns 0, except if "v" or "space" are NULL.
1626 isl_stat isl_val_check_match_domain_space(__isl_keep isl_val *v,
1627 __isl_keep isl_space *space)
1629 if (!v || !space)
1630 return isl_stat_error;
1631 return isl_stat_ok;
1634 #define isl_val_involves_nan isl_val_is_nan
1636 #undef BASE
1637 #define BASE val
1639 #define NO_DOMAIN
1640 #define NO_IDENTITY
1641 #define NO_FROM_BASE
1642 #define NO_MOVE_DIMS
1643 #include <isl_multi_no_explicit_domain.c>
1644 #include <isl_multi_templ.c>
1645 #include <isl_multi_dims.c>
1647 /* Apply "fn" to each of the elements of "mv" with as second argument "v".
1649 static __isl_give isl_multi_val *isl_multi_val_fn_val(
1650 __isl_take isl_multi_val *mv,
1651 __isl_give isl_val *(*fn)(__isl_take isl_val *v1,
1652 __isl_take isl_val *v2),
1653 __isl_take isl_val *v)
1655 int i;
1657 mv = isl_multi_val_cow(mv);
1658 if (!mv || !v)
1659 goto error;
1661 for (i = 0; i < mv->n; ++i) {
1662 mv->u.p[i] = fn(mv->u.p[i], isl_val_copy(v));
1663 if (!mv->u.p[i])
1664 goto error;
1667 isl_val_free(v);
1668 return mv;
1669 error:
1670 isl_val_free(v);
1671 isl_multi_val_free(mv);
1672 return NULL;
1675 /* Add "v" to each of the elements of "mv".
1677 __isl_give isl_multi_val *isl_multi_val_add_val(__isl_take isl_multi_val *mv,
1678 __isl_take isl_val *v)
1680 if (!v)
1681 return isl_multi_val_free(mv);
1682 if (isl_val_is_zero(v)) {
1683 isl_val_free(v);
1684 return mv;
1686 return isl_multi_val_fn_val(mv, &isl_val_add, v);
1689 /* Reduce the elements of "mv" modulo "v".
1691 __isl_give isl_multi_val *isl_multi_val_mod_val(__isl_take isl_multi_val *mv,
1692 __isl_take isl_val *v)
1694 return isl_multi_val_fn_val(mv, &isl_val_mod, v);