isl_val.c

   1 /*
   2  * Copyright 2013      Ecole Normale Superieure
   3  *
   4  * Use of this software is governed by the MIT license
   5  *
   6  * Written by Sven Verdoolaege,
   7  * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
   8  */
   9
  10 #include <isl_int.h>
  11 #include <isl_ctx_private.h>
  12 #include <isl_val_private.h>
  13
  14 #undef BASE
  15 #define BASE val
  16
  17 #include <isl_list_templ.c>
  18
  19 /* Allocate an isl_val object with indeterminate value.
  20  */
  21 __isl_give isl_val *isl_val_alloc(isl_ctx *ctx)
  22 {
  23         isl_val *v;
  24
  25         v = isl_alloc_type(ctx, struct isl_val);
  26         if (!v)
  27                 return NULL;
  28
  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);
  34
  35         return v;
  36 }
  37
  38 /* Return a reference to an isl_val representing zero.
  39  */
  40 __isl_give isl_val *isl_val_zero(isl_ctx *ctx)
  41 {
  42         return isl_val_int_from_si(ctx, 0);
  43 }
  44
  45 /* Return a reference to an isl_val representing one.
  46  */
  47 __isl_give isl_val *isl_val_one(isl_ctx *ctx)
  48 {
  49         return isl_val_int_from_si(ctx, 1);
  50 }
  51
  52 /* Return a reference to an isl_val representing negative one.
  53  */
  54 __isl_give isl_val *isl_val_negone(isl_ctx *ctx)
  55 {
  56         return isl_val_int_from_si(ctx, -1);
  57 }
  58
  59 /* Return a reference to an isl_val representing NaN.
  60  */
  61 __isl_give isl_val *isl_val_nan(isl_ctx *ctx)
  62 {
  63         isl_val *v;
  64
  65         v = isl_val_alloc(ctx);
  66         if (!v)
  67                 return NULL;
  68
  69         isl_int_set_si(v->n, 0);
  70         isl_int_set_si(v->d, 0);
  71
  72         return v;
  73 }
  74
  75 /* Change "v" into a NaN.
  76  */
  77 __isl_give isl_val *isl_val_set_nan(__isl_take isl_val *v)
  78 {
  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;
  86
  87         isl_int_set_si(v->n, 0);
  88         isl_int_set_si(v->d, 0);
  89
  90         return v;
  91 }
  92
  93 /* Return a reference to an isl_val representing +infinity.
  94  */
  95 __isl_give isl_val *isl_val_infty(isl_ctx *ctx)
  96 {
  97         isl_val *v;
  98
  99         v = isl_val_alloc(ctx);
 100         if (!v)
 101                 return NULL;
 102
 103         isl_int_set_si(v->n, 1);
 104         isl_int_set_si(v->d, 0);
 105
 106         return v;
 107 }
 108
 109 /* Return a reference to an isl_val representing -infinity.
 110  */
 111 __isl_give isl_val *isl_val_neginfty(isl_ctx *ctx)
 112 {
 113         isl_val *v;
 114
 115         v = isl_val_alloc(ctx);
 116         if (!v)
 117                 return NULL;
 118
 119         isl_int_set_si(v->n, -1);
 120         isl_int_set_si(v->d, 0);
 121
 122         return v;
 123 }
 124
 125 /* Return a reference to an isl_val representing the integer "i".
 126  */
 127 __isl_give isl_val *isl_val_int_from_si(isl_ctx *ctx, long i)
 128 {
 129         isl_val *v;
 130
 131         v = isl_val_alloc(ctx);
 132         if (!v)
 133                 return NULL;
 134
 135         isl_int_set_si(v->n, i);
 136         isl_int_set_si(v->d, 1);
 137
 138         return v;
 139 }
 140
 141 /* Change the value of "v" to be equal to the integer "i".
 142  */
 143 __isl_give isl_val *isl_val_set_si(__isl_take isl_val *v, long i)
 144 {
 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;
 152
 153         isl_int_set_si(v->n, i);
 154         isl_int_set_si(v->d, 1);
 155
 156         return v;
 157 }
 158
 159 /* Change the value of "v" to be equal to zero.
 160  */
 161 __isl_give isl_val *isl_val_set_zero(__isl_take isl_val *v)
 162 {
 163         return isl_val_set_si(v, 0);
 164 }
 165
 166 /* Return a reference to an isl_val representing the unsigned integer "u".
 167  */
 168 __isl_give isl_val *isl_val_int_from_ui(isl_ctx *ctx, unsigned long u)
 169 {
 170         isl_val *v;
 171
 172         v = isl_val_alloc(ctx);
 173         if (!v)
 174                 return NULL;
 175
 176         isl_int_set_ui(v->n, u);
 177         isl_int_set_si(v->d, 1);
 178
 179         return v;
 180 }
 181
 182 /* Return a reference to an isl_val representing the integer "n".
 183  */
 184 __isl_give isl_val *isl_val_int_from_isl_int(isl_ctx *ctx, isl_int n)
 185 {
 186         isl_val *v;
 187
 188         v = isl_val_alloc(ctx);
 189         if (!v)
 190                 return NULL;
 191
 192         isl_int_set(v->n, n);
 193         isl_int_set_si(v->d, 1);
 194
 195         return v;
 196 }
 197
 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.
 200  */
 201 __isl_give isl_val *isl_val_rat_from_isl_int(isl_ctx *ctx,
 202         isl_int n, isl_int d)
 203 {
 204         isl_val *v;
 205
 206         v = isl_val_alloc(ctx);
 207         if (!v)
 208                 return NULL;
 209
 210         isl_int_set(v->n, n);
 211         isl_int_set(v->d, d);
 212
 213         return v;
 214 }
 215
 216 /* Return a new reference to "v".
 217  */
 218 __isl_give isl_val *isl_val_copy(__isl_keep isl_val *v)
 219 {
 220         if (!v)
 221                 return NULL;
 222
 223         v->ref++;
 224         return v;
 225 }
 226
 227 /* Return a fresh copy of "val".
 228  */
 229 __isl_give isl_val *isl_val_dup(__isl_keep isl_val *val)
 230 {
 231         isl_val *dup;
 232
 233         if (!val)
 234                 return NULL;
 235
 236         dup = isl_val_alloc(isl_val_get_ctx(val));
 237         if (!dup)
 238                 return NULL;
 239
 240         isl_int_set(dup->n, val->n);
 241         isl_int_set(dup->d, val->d);
 242
 243         return dup;
 244 }
 245
 246 /* Return an isl_val that is equal to "val" and that has only
 247  * a single reference.
 248  */
 249 __isl_give isl_val *isl_val_cow(__isl_take isl_val *val)
 250 {
 251         if (!val)
 252                 return NULL;
 253
 254         if (val->ref == 1)
 255                 return val;
 256         val->ref--;
 257         return isl_val_dup(val);
 258 }
 259
 260 /* Free "v" and return NULL.
 261  */
 262 __isl_null isl_val *isl_val_free(__isl_take isl_val *v)
 263 {
 264         if (!v)
 265                 return NULL;
 266
 267         if (--v->ref > 0)
 268                 return NULL;
 269
 270         isl_ctx_deref(v->ctx);
 271         isl_int_clear(v->n);
 272         isl_int_clear(v->d);
 273         free(v);
 274         return NULL;
 275 }
 276
 277 /* Extract the numerator of a rational value "v" as an integer.
 278  *
 279  * If "v" is not a rational value, then the result is undefined.
 280  */
 281 long isl_val_get_num_si(__isl_keep isl_val *v)
 282 {
 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);
 292 }
 293
 294 /* Extract the numerator of a rational value "v" as an isl_int.
 295  *
 296  * If "v" is not a rational value, then the result is undefined.
 297  */
 298 isl_stat isl_val_get_num_isl_int(__isl_keep isl_val *v, isl_int *n)
 299 {
 300         if (!v)
 301                 return isl_stat_error;
 302         if (!isl_val_is_rat(v))
 303                 isl_die(isl_val_get_ctx(v), isl_error_invalid,
 304                         "expecting rational value", return isl_stat_error);
 305         isl_int_set(*n, v->n);
 306         return isl_stat_ok;
 307 }
 308
 309 /* Extract the denominator of a rational value "v" as an integer.
 310  *
 311  * If "v" is not a rational value, then the result is undefined.
 312  */
 313 long isl_val_get_den_si(__isl_keep isl_val *v)
 314 {
 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);
 324 }
 325
 326 /* Extract the denominator of a rational value "v" as an isl_val.
 327  *
 328  * If "v" is not a rational value, then the result is undefined.
 329  */
 330 __isl_give isl_val *isl_val_get_den_val(__isl_keep isl_val *v)
 331 {
 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);
 338 }
 339
 340 /* Return an approximation of "v" as a double.
 341  */
 342 double isl_val_get_d(__isl_keep isl_val *v)
 343 {
 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);
 350 }
 351
 352 /* Return the isl_ctx to which "val" belongs.
 353  */
 354 isl_ctx *isl_val_get_ctx(__isl_keep isl_val *val)
 355 {
 356         return val ? val->ctx : NULL;
 357 }
 358
 359 /* Return a hash value that digests "val".
 360  */
 361 uint32_t isl_val_get_hash(__isl_keep isl_val *val)
 362 {
 363         uint32_t hash;
 364
 365         if (!val)
 366                 return 0;
 367
 368         hash = isl_hash_init();
 369         hash = isl_int_hash(val->n, hash);
 370         hash = isl_int_hash(val->d, hash);
 371
 372         return hash;
 373 }
 374
 375 /* Normalize "v".
 376  *
 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.
 380  *
 381  * This function should not be called by an external user
 382  * since it will only be given normalized values.
 383  */
 384 __isl_give isl_val *isl_val_normalize(__isl_take isl_val *v)
 385 {
 386         isl_ctx *ctx;
 387
 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);
 397         }
 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;
 405 }
 406
 407 /* Return the opposite of "v".
 408  */
 409 __isl_give isl_val *isl_val_neg(__isl_take isl_val *v)
 410 {
 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;
 417
 418         v = isl_val_cow(v);
 419         if (!v)
 420                 return NULL;
 421         isl_int_neg(v->n, v->n);
 422
 423         return v;
 424 }
 425
 426 /* Return the inverse of "v".
 427  */
 428 __isl_give isl_val *isl_val_inv(__isl_take isl_val *v)
 429 {
 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);
 438         }
 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);
 443         }
 444
 445         v = isl_val_cow(v);
 446         if (!v)
 447                 return NULL;
 448         isl_int_swap(v->n, v->d);
 449
 450         return isl_val_normalize(v);
 451 }
 452
 453 /* Return the absolute value of "v".
 454  */
 455 __isl_give isl_val *isl_val_abs(__isl_take isl_val *v)
 456 {
 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);
 464 }
 465
 466 /* Return the "floor" (greatest integer part) of "v".
 467  * That is, return the result of rounding towards -infinity.
 468  */
 469 __isl_give isl_val *isl_val_floor(__isl_take isl_val *v)
 470 {
 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;
 477
 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);
 483
 484         return v;
 485 }
 486
 487 /* Return the "ceiling" of "v".
 488  * That is, return the result of rounding towards +infinity.
 489  */
 490 __isl_give isl_val *isl_val_ceil(__isl_take isl_val *v)
 491 {
 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;
 498
 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);
 504
 505         return v;
 506 }
 507
 508 /* Truncate "v".
 509  * That is, return the result of rounding towards zero.
 510  */
 511 __isl_give isl_val *isl_val_trunc(__isl_take isl_val *v)
 512 {
 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;
 519
 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);
 525
 526         return v;
 527 }
 528
 529 /* Return 2^v, where v is an integer (that is not too large).
 530  */
 531 __isl_give isl_val *isl_val_pow2(__isl_take isl_val *v)
 532 {
 533         unsigned long exp;
 534         int neg;
 535
 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);
 555         }
 556
 557         return v;
 558 }
 559
 560 /* This is an alternative name for the function above.
 561  */
 562 __isl_give isl_val *isl_val_2exp(__isl_take isl_val *v)
 563 {
 564         return isl_val_pow2(v);
 565 }
 566
 567 /* Return the minimum of "v1" and "v2".
 568  */
 569 __isl_give isl_val *isl_val_min(__isl_take isl_val *v1, __isl_take isl_val *v2)
 570 {
 571         if (!v1 || !v2)
 572                 goto error;
 573
 574         if (isl_val_is_nan(v1)) {
 575                 isl_val_free(v2);
 576                 return v1;
 577         }
 578         if (isl_val_is_nan(v2)) {
 579                 isl_val_free(v1);
 580                 return v2;
 581         }
 582         if (isl_val_le(v1, v2)) {
 583                 isl_val_free(v2);
 584                 return v1;
 585         } else {
 586                 isl_val_free(v1);
 587                 return v2;
 588         }
 589 error:
 590         isl_val_free(v1);
 591         isl_val_free(v2);
 592         return NULL;
 593 }
 594
 595 /* Return the maximum of "v1" and "v2".
 596  */
 597 __isl_give isl_val *isl_val_max(__isl_take isl_val *v1, __isl_take isl_val *v2)
 598 {
 599         if (!v1 || !v2)
 600                 goto error;
 601
 602         if (isl_val_is_nan(v1)) {
 603                 isl_val_free(v2);
 604                 return v1;
 605         }
 606         if (isl_val_is_nan(v2)) {
 607                 isl_val_free(v1);
 608                 return v2;
 609         }
 610         if (isl_val_ge(v1, v2)) {
 611                 isl_val_free(v2);
 612                 return v1;
 613         } else {
 614                 isl_val_free(v1);
 615                 return v2;
 616         }
 617 error:
 618         isl_val_free(v1);
 619         isl_val_free(v2);
 620         return NULL;
 621 }
 622
 623 /* Return the sum of "v1" and "v2".
 624  */
 625 __isl_give isl_val *isl_val_add(__isl_take isl_val *v1, __isl_take isl_val *v2)
 626 {
 627         if (!v1 || !v2)
 628                 goto error;
 629         if (isl_val_is_nan(v1)) {
 630                 isl_val_free(v2);
 631                 return v1;
 632         }
 633         if (isl_val_is_nan(v2)) {
 634                 isl_val_free(v1);
 635                 return v2;
 636         }
 637         if ((isl_val_is_infty(v1) && isl_val_is_neginfty(v2)) ||
 638             (isl_val_is_neginfty(v1) && isl_val_is_infty(v2))) {
 639                 isl_val_free(v2);
 640                 return isl_val_set_nan(v1);
 641         }
 642         if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1)) {
 643                 isl_val_free(v2);
 644                 return v1;
 645         }
 646         if (isl_val_is_infty(v2) || isl_val_is_neginfty(v2)) {
 647                 isl_val_free(v1);
 648                 return v2;
 649         }
 650         if (isl_val_is_zero(v1)) {
 651                 isl_val_free(v1);
 652                 return v2;
 653         }
 654         if (isl_val_is_zero(v2)) {
 655                 isl_val_free(v2);
 656                 return v1;
 657         }
 658
 659         v1 = isl_val_cow(v1);
 660         if (!v1)
 661                 goto error;
 662         if (isl_val_is_int(v1) && isl_val_is_int(v2))
 663                 isl_int_add(v1->n, v1->n, v2->n);
 664         else {
 665                 if (isl_int_eq(v1->d, v2->d))
 666                         isl_int_add(v1->n, v1->n, v2->n);
 667                 else {
 668                         isl_int_mul(v1->n, v1->n, v2->d);
 669                         isl_int_addmul(v1->n, v2->n, v1->d);
 670                         isl_int_mul(v1->d, v1->d, v2->d);
 671                 }
 672                 v1 = isl_val_normalize(v1);
 673         }
 674         isl_val_free(v2);
 675         return v1;
 676 error:
 677         isl_val_free(v1);
 678         isl_val_free(v2);
 679         return NULL;
 680 }
 681
 682 /* Return the sum of "v1" and "v2".
 683  */
 684 __isl_give isl_val *isl_val_add_ui(__isl_take isl_val *v1, unsigned long v2)
 685 {
 686         if (!v1)
 687                 return NULL;
 688         if (!isl_val_is_rat(v1))
 689                 return v1;
 690         if (v2 == 0)
 691                 return v1;
 692         v1 = isl_val_cow(v1);
 693         if (!v1)
 694                 return NULL;
 695
 696         isl_int_addmul_ui(v1->n, v1->d, v2);
 697
 698         return v1;
 699 }
 700
 701 /* Subtract "v2" from "v1".
 702  */
 703 __isl_give isl_val *isl_val_sub(__isl_take isl_val *v1, __isl_take isl_val *v2)
 704 {
 705         if (!v1 || !v2)
 706                 goto error;
 707         if (isl_val_is_nan(v1)) {
 708                 isl_val_free(v2);
 709                 return v1;
 710         }
 711         if (isl_val_is_nan(v2)) {
 712                 isl_val_free(v1);
 713                 return v2;
 714         }
 715         if ((isl_val_is_infty(v1) && isl_val_is_infty(v2)) ||
 716             (isl_val_is_neginfty(v1) && isl_val_is_neginfty(v2))) {
 717                 isl_val_free(v2);
 718                 return isl_val_set_nan(v1);
 719         }
 720         if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1)) {
 721                 isl_val_free(v2);
 722                 return v1;
 723         }
 724         if (isl_val_is_infty(v2) || isl_val_is_neginfty(v2)) {
 725                 isl_val_free(v1);
 726                 return isl_val_neg(v2);
 727         }
 728         if (isl_val_is_zero(v2)) {
 729                 isl_val_free(v2);
 730                 return v1;
 731         }
 732         if (isl_val_is_zero(v1)) {
 733                 isl_val_free(v1);
 734                 return isl_val_neg(v2);
 735         }
 736
 737         v1 = isl_val_cow(v1);
 738         if (!v1)
 739                 goto error;
 740         if (isl_val_is_int(v1) && isl_val_is_int(v2))
 741                 isl_int_sub(v1->n, v1->n, v2->n);
 742         else {
 743                 if (isl_int_eq(v1->d, v2->d))
 744                         isl_int_sub(v1->n, v1->n, v2->n);
 745                 else {
 746                         isl_int_mul(v1->n, v1->n, v2->d);
 747                         isl_int_submul(v1->n, v2->n, v1->d);
 748                         isl_int_mul(v1->d, v1->d, v2->d);
 749                 }
 750                 v1 = isl_val_normalize(v1);
 751         }
 752         isl_val_free(v2);
 753         return v1;
 754 error:
 755         isl_val_free(v1);
 756         isl_val_free(v2);
 757         return NULL;
 758 }
 759
 760 /* Subtract "v2" from "v1".
 761  */
 762 __isl_give isl_val *isl_val_sub_ui(__isl_take isl_val *v1, unsigned long v2)
 763 {
 764         if (!v1)
 765                 return NULL;
 766         if (!isl_val_is_rat(v1))
 767                 return v1;
 768         if (v2 == 0)
 769                 return v1;
 770         v1 = isl_val_cow(v1);
 771         if (!v1)
 772                 return NULL;
 773
 774         isl_int_submul_ui(v1->n, v1->d, v2);
 775
 776         return v1;
 777 }
 778
 779 /* Return the product of "v1" and "v2".
 780  */
 781 __isl_give isl_val *isl_val_mul(__isl_take isl_val *v1, __isl_take isl_val *v2)
 782 {
 783         if (!v1 || !v2)
 784                 goto error;
 785         if (isl_val_is_nan(v1)) {
 786                 isl_val_free(v2);
 787                 return v1;
 788         }
 789         if (isl_val_is_nan(v2)) {
 790                 isl_val_free(v1);
 791                 return v2;
 792         }
 793         if ((!isl_val_is_rat(v1) && isl_val_is_zero(v2)) ||
 794             (isl_val_is_zero(v1) && !isl_val_is_rat(v2))) {
 795                 isl_val_free(v2);
 796                 return isl_val_set_nan(v1);
 797         }
 798         if (isl_val_is_zero(v1)) {
 799                 isl_val_free(v2);
 800                 return v1;
 801         }
 802         if (isl_val_is_zero(v2)) {
 803                 isl_val_free(v1);
 804                 return v2;
 805         }
 806         if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1)) {
 807                 if (isl_val_is_neg(v2))
 808                         v1 = isl_val_neg(v1);
 809                 isl_val_free(v2);
 810                 return v1;
 811         }
 812         if (isl_val_is_infty(v2) || isl_val_is_neginfty(v2)) {
 813                 if (isl_val_is_neg(v1))
 814                         v2 = isl_val_neg(v2);
 815                 isl_val_free(v1);
 816                 return v2;
 817         }
 818
 819         v1 = isl_val_cow(v1);
 820         if (!v1)
 821                 goto error;
 822         if (isl_val_is_int(v1) && isl_val_is_int(v2))
 823                 isl_int_mul(v1->n, v1->n, v2->n);
 824         else {
 825                 isl_int_mul(v1->n, v1->n, v2->n);
 826                 isl_int_mul(v1->d, v1->d, v2->d);
 827                 v1 = isl_val_normalize(v1);
 828         }
 829         isl_val_free(v2);
 830         return v1;
 831 error:
 832         isl_val_free(v1);
 833         isl_val_free(v2);
 834         return NULL;
 835 }
 836
 837 /* Return the product of "v1" and "v2".
 838  *
 839  * This is a private copy of isl_val_mul for use in the generic
 840  * isl_multi_*_scale_val instantiated for isl_val.
 841  */
 842 __isl_give isl_val *isl_val_scale_val(__isl_take isl_val *v1,
 843         __isl_take isl_val *v2)
 844 {
 845         return isl_val_mul(v1, v2);
 846 }
 847
 848 /* Return the product of "v1" and "v2".
 849  */
 850 __isl_give isl_val *isl_val_mul_ui(__isl_take isl_val *v1, unsigned long v2)
 851 {
 852         if (!v1)
 853                 return NULL;
 854         if (isl_val_is_nan(v1))
 855                 return v1;
 856         if (!isl_val_is_rat(v1)) {
 857                 if (v2 == 0)
 858                         v1 = isl_val_set_nan(v1);
 859                 return v1;
 860         }
 861         if (v2 == 1)
 862                 return v1;
 863         v1 = isl_val_cow(v1);
 864         if (!v1)
 865                 return NULL;
 866
 867         isl_int_mul_ui(v1->n, v1->n, v2);
 868
 869         return isl_val_normalize(v1);
 870 }
 871
 872 /* Divide "v1" by "v2".
 873  */
 874 __isl_give isl_val *isl_val_div(__isl_take isl_val *v1, __isl_take isl_val *v2)
 875 {
 876         if (!v1 || !v2)
 877                 goto error;
 878         if (isl_val_is_nan(v1)) {
 879                 isl_val_free(v2);
 880                 return v1;
 881         }
 882         if (isl_val_is_nan(v2)) {
 883                 isl_val_free(v1);
 884                 return v2;
 885         }
 886         if (isl_val_is_zero(v2) ||
 887             (!isl_val_is_rat(v1) && !isl_val_is_rat(v2))) {
 888                 isl_val_free(v2);
 889                 return isl_val_set_nan(v1);
 890         }
 891         if (isl_val_is_zero(v1)) {
 892                 isl_val_free(v2);
 893                 return v1;
 894         }
 895         if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1)) {
 896                 if (isl_val_is_neg(v2))
 897                         v1 = isl_val_neg(v1);
 898                 isl_val_free(v2);
 899                 return v1;
 900         }
 901         if (isl_val_is_infty(v2) || isl_val_is_neginfty(v2)) {
 902                 isl_val_free(v2);
 903                 return isl_val_set_zero(v1);
 904         }
 905
 906         v1 = isl_val_cow(v1);
 907         if (!v1)
 908                 goto error;
 909         if (isl_val_is_int(v2)) {
 910                 isl_int_mul(v1->d, v1->d, v2->n);
 911                 v1 = isl_val_normalize(v1);
 912         } else {
 913                 isl_int_mul(v1->d, v1->d, v2->n);
 914                 isl_int_mul(v1->n, v1->n, v2->d);
 915                 v1 = isl_val_normalize(v1);
 916         }
 917         isl_val_free(v2);
 918         return v1;
 919 error:
 920         isl_val_free(v1);
 921         isl_val_free(v2);
 922         return NULL;
 923 }
 924
 925 /* Divide "v1" by "v2".
 926  */
 927 __isl_give isl_val *isl_val_div_ui(__isl_take isl_val *v1, unsigned long v2)
 928 {
 929         if (!v1)
 930                 return NULL;
 931         if (isl_val_is_nan(v1))
 932                 return v1;
 933         if (v2 == 0)
 934                 return isl_val_set_nan(v1);
 935         if (v2 == 1)
 936                 return v1;
 937         if (isl_val_is_zero(v1))
 938                 return v1;
 939         if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1))
 940                 return v1;
 941         v1 = isl_val_cow(v1);
 942         if (!v1)
 943                 return NULL;
 944
 945         isl_int_mul_ui(v1->d, v1->d, v2);
 946
 947         return isl_val_normalize(v1);
 948 }
 949
 950 /* Divide "v1" by "v2".
 951  *
 952  * This is a private copy of isl_val_div for use in the generic
 953  * isl_multi_*_scale_down_val instantiated for isl_val.
 954  */
 955 __isl_give isl_val *isl_val_scale_down_val(__isl_take isl_val *v1,
 956         __isl_take isl_val *v2)
 957 {
 958         return isl_val_div(v1, v2);
 959 }
 960
 961 /* Given two integer values "v1" and "v2", check if "v1" is divisible by "v2".
 962  */
 963 isl_bool isl_val_is_divisible_by(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
 964 {
 965         if (!v1 || !v2)
 966                 return isl_bool_error;
 967
 968         if (!isl_val_is_int(v1) || !isl_val_is_int(v2))
 969                 isl_die(isl_val_get_ctx(v1), isl_error_invalid,
 970                         "expecting two integers", return isl_bool_error);
 971
 972         return isl_int_is_divisible_by(v1->n, v2->n);
 973 }
 974
 975 /* Given two integer values "v1" and "v2", return the residue of "v1"
 976  * modulo "v2".
 977  */
 978 __isl_give isl_val *isl_val_mod(__isl_take isl_val *v1, __isl_take isl_val *v2)
 979 {
 980         if (!v1 || !v2)
 981                 goto error;
 982         if (!isl_val_is_int(v1) || !isl_val_is_int(v2))
 983                 isl_die(isl_val_get_ctx(v1), isl_error_invalid,
 984                         "expecting two integers", goto error);
 985         if (isl_val_is_nonneg(v1) && isl_val_lt(v1, v2)) {
 986                 isl_val_free(v2);
 987                 return v1;
 988         }
 989         v1 = isl_val_cow(v1);
 990         if (!v1)
 991                 goto error;
 992         isl_int_fdiv_r(v1->n, v1->n, v2->n);
 993         isl_val_free(v2);
 994         return v1;
 995 error:
 996         isl_val_free(v1);
 997         isl_val_free(v2);
 998         return NULL;
 999 }
1000
1001 /* Given two integer values "v1" and "v2", return the residue of "v1"
1002  * modulo "v2".
1003  *
1004  * This is a private copy of isl_val_mod for use in the generic
1005  * isl_multi_*_mod_multi_val instantiated for isl_val.
1006  */
1007 __isl_give isl_val *isl_val_mod_val(__isl_take isl_val *v1,
1008         __isl_take isl_val *v2)
1009 {
1010         return isl_val_mod(v1, v2);
1011 }
1012
1013 /* Given two integer values, return their greatest common divisor.
1014  */
1015 __isl_give isl_val *isl_val_gcd(__isl_take isl_val *v1, __isl_take isl_val *v2)
1016 {
1017         if (!v1 || !v2)
1018                 goto error;
1019         if (!isl_val_is_int(v1) || !isl_val_is_int(v2))
1020                 isl_die(isl_val_get_ctx(v1), isl_error_invalid,
1021                         "expecting two integers", goto error);
1022         if (isl_val_eq(v1, v2)) {
1023                 isl_val_free(v2);
1024                 return v1;
1025         }
1026         if (isl_val_is_one(v1)) {
1027                 isl_val_free(v2);
1028                 return v1;
1029         }
1030         if (isl_val_is_one(v2)) {
1031                 isl_val_free(v1);
1032                 return v2;
1033         }
1034         v1 = isl_val_cow(v1);
1035         if (!v1)
1036                 goto error;
1037         isl_int_gcd(v1->n, v1->n, v2->n);
1038         isl_val_free(v2);
1039         return v1;
1040 error:
1041         isl_val_free(v1);
1042         isl_val_free(v2);
1043         return NULL;
1044 }
1045
1046 /* Compute x, y and g such that g = gcd(a,b) and a*x+b*y = g.
1047  */
1048 static void isl_int_gcdext(isl_int *g, isl_int *x, isl_int *y,
1049         isl_int a, isl_int b)
1050 {
1051         isl_int d, tmp;
1052         isl_int a_copy, b_copy;
1053
1054         isl_int_init(a_copy);
1055         isl_int_init(b_copy);
1056         isl_int_init(d);
1057         isl_int_init(tmp);
1058         isl_int_set(a_copy, a);
1059         isl_int_set(b_copy, b);
1060         isl_int_abs(*g, a_copy);
1061         isl_int_abs(d, b_copy);
1062         isl_int_set_si(*x, 1);
1063         isl_int_set_si(*y, 0);
1064         while (isl_int_is_pos(d)) {
1065                 isl_int_fdiv_q(tmp, *g, d);
1066                 isl_int_submul(*x, tmp, *y);
1067                 isl_int_submul(*g, tmp, d);
1068                 isl_int_swap(*g, d);
1069                 isl_int_swap(*x, *y);
1070         }
1071         if (isl_int_is_zero(a_copy))
1072                 isl_int_set_si(*x, 0);
1073         else if (isl_int_is_neg(a_copy))
1074                 isl_int_neg(*x, *x);
1075         if (isl_int_is_zero(b_copy))
1076                 isl_int_set_si(*y, 0);
1077         else {
1078                 isl_int_mul(tmp, a_copy, *x);
1079                 isl_int_sub(tmp, *g, tmp);
1080                 isl_int_divexact(*y, tmp, b_copy);
1081         }
1082         isl_int_clear(d);
1083         isl_int_clear(tmp);
1084         isl_int_clear(a_copy);
1085         isl_int_clear(b_copy);
1086 }
1087
1088 /* Given two integer values v1 and v2, return their greatest common divisor g,
1089  * as well as two integers x and y such that x * v1 + y * v2 = g.
1090  */
1091 __isl_give isl_val *isl_val_gcdext(__isl_take isl_val *v1,
1092         __isl_take isl_val *v2, __isl_give isl_val **x, __isl_give isl_val **y)
1093 {
1094         isl_ctx *ctx;
1095         isl_val *a = NULL, *b = NULL;
1096
1097         if (!x && !y)
1098                 return isl_val_gcd(v1, v2);
1099
1100         if (!v1 || !v2)
1101                 goto error;
1102
1103         ctx = isl_val_get_ctx(v1);
1104         if (!isl_val_is_int(v1) || !isl_val_is_int(v2))
1105                 isl_die(ctx, isl_error_invalid,
1106                         "expecting two integers", goto error);
1107
1108         v1 = isl_val_cow(v1);
1109         a = isl_val_alloc(ctx);
1110         b = isl_val_alloc(ctx);
1111         if (!v1 || !a || !b)
1112                 goto error;
1113         isl_int_gcdext(&v1->n, &a->n, &b->n, v1->n, v2->n);
1114         if (x) {
1115                 isl_int_set_si(a->d, 1);
1116                 *x = a;
1117         } else
1118                 isl_val_free(a);
1119         if (y) {
1120                 isl_int_set_si(b->d, 1);
1121                 *y = b;
1122         } else
1123                 isl_val_free(b);
1124         isl_val_free(v2);
1125         return v1;
1126 error:
1127         isl_val_free(v1);
1128         isl_val_free(v2);
1129         isl_val_free(a);
1130         isl_val_free(b);
1131         if (x)
1132                 *x = NULL;
1133         if (y)
1134                 *y = NULL;
1135         return NULL;
1136 }
1137
1138 /* Does "v" represent an integer value?
1139  */
1140 isl_bool isl_val_is_int(__isl_keep isl_val *v)
1141 {
1142         if (!v)
1143                 return isl_bool_error;
1144
1145         return isl_int_is_one(v->d);
1146 }
1147
1148 /* Does "v" represent a rational value?
1149  */
1150 isl_bool isl_val_is_rat(__isl_keep isl_val *v)
1151 {
1152         if (!v)
1153                 return isl_bool_error;
1154
1155         return !isl_int_is_zero(v->d);
1156 }
1157
1158 /* Does "v" represent NaN?
1159  */
1160 isl_bool isl_val_is_nan(__isl_keep isl_val *v)
1161 {
1162         if (!v)
1163                 return isl_bool_error;
1164
1165         return isl_int_is_zero(v->n) && isl_int_is_zero(v->d);
1166 }
1167
1168 /* Does "v" represent +infinity?
1169  */
1170 isl_bool isl_val_is_infty(__isl_keep isl_val *v)
1171 {
1172         if (!v)
1173                 return isl_bool_error;
1174
1175         return isl_int_is_pos(v->n) && isl_int_is_zero(v->d);
1176 }
1177
1178 /* Does "v" represent -infinity?
1179  */
1180 isl_bool isl_val_is_neginfty(__isl_keep isl_val *v)
1181 {
1182         if (!v)
1183                 return isl_bool_error;
1184
1185         return isl_int_is_neg(v->n) && isl_int_is_zero(v->d);
1186 }
1187
1188 /* Does "v" represent the integer zero?
1189  */
1190 isl_bool isl_val_is_zero(__isl_keep isl_val *v)
1191 {
1192         if (!v)
1193                 return isl_bool_error;
1194
1195         return isl_int_is_zero(v->n) && !isl_int_is_zero(v->d);
1196 }
1197
1198 /* Does "v" represent the integer one?
1199  */
1200 isl_bool isl_val_is_one(__isl_keep isl_val *v)
1201 {
1202         if (!v)
1203                 return isl_bool_error;
1204
1205         if (isl_val_is_nan(v))
1206                 return isl_bool_false;
1207
1208         return isl_int_eq(v->n, v->d);
1209 }
1210
1211 /* Does "v" represent the integer negative one?
1212  */
1213 isl_bool isl_val_is_negone(__isl_keep isl_val *v)
1214 {
1215         if (!v)
1216                 return isl_bool_error;
1217
1218         return isl_int_is_neg(v->n) && isl_int_abs_eq(v->n, v->d);
1219 }
1220
1221 /* Is "v" (strictly) positive?
1222  */
1223 isl_bool isl_val_is_pos(__isl_keep isl_val *v)
1224 {
1225         if (!v)
1226                 return isl_bool_error;
1227
1228         return isl_int_is_pos(v->n);
1229 }
1230
1231 /* Is "v" (strictly) negative?
1232  */
1233 isl_bool isl_val_is_neg(__isl_keep isl_val *v)
1234 {
1235         if (!v)
1236                 return isl_bool_error;
1237
1238         return isl_int_is_neg(v->n);
1239 }
1240
1241 /* Is "v" non-negative?
1242  */
1243 isl_bool isl_val_is_nonneg(__isl_keep isl_val *v)
1244 {
1245         if (!v)
1246                 return isl_bool_error;
1247
1248         if (isl_val_is_nan(v))
1249                 return isl_bool_false;
1250
1251         return isl_int_is_nonneg(v->n);
1252 }
1253
1254 /* Is "v" non-positive?
1255  */
1256 isl_bool isl_val_is_nonpos(__isl_keep isl_val *v)
1257 {
1258         if (!v)
1259                 return isl_bool_error;
1260
1261         if (isl_val_is_nan(v))
1262                 return isl_bool_false;
1263
1264         return isl_int_is_nonpos(v->n);
1265 }
1266
1267 /* Return the sign of "v".
1268  *
1269  * The sign of NaN is undefined.
1270  */
1271 int isl_val_sgn(__isl_keep isl_val *v)
1272 {
1273         if (!v)
1274                 return 0;
1275         if (isl_val_is_zero(v))
1276                 return 0;
1277         if (isl_val_is_pos(v))
1278                 return 1;
1279         return -1;
1280 }
1281
1282 /* Is "v1" (strictly) less than "v2"?
1283  */
1284 isl_bool isl_val_lt(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1285 {
1286         isl_int t;
1287         isl_bool lt;
1288
1289         if (!v1 || !v2)
1290                 return isl_bool_error;
1291         if (isl_val_is_int(v1) && isl_val_is_int(v2))
1292                 return isl_int_lt(v1->n, v2->n);
1293         if (isl_val_is_nan(v1) || isl_val_is_nan(v2))
1294                 return isl_bool_false;
1295         if (isl_val_eq(v1, v2))
1296                 return isl_bool_false;
1297         if (isl_val_is_infty(v2))
1298                 return isl_bool_true;
1299         if (isl_val_is_infty(v1))
1300                 return isl_bool_false;
1301         if (isl_val_is_neginfty(v1))
1302                 return isl_bool_true;
1303         if (isl_val_is_neginfty(v2))
1304                 return isl_bool_false;
1305
1306         isl_int_init(t);
1307         isl_int_mul(t, v1->n, v2->d);
1308         isl_int_submul(t, v2->n, v1->d);
1309         lt = isl_int_is_neg(t);
1310         isl_int_clear(t);
1311
1312         return lt;
1313 }
1314
1315 /* Is "v1" (strictly) greater than "v2"?
1316  */
1317 isl_bool isl_val_gt(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1318 {
1319         return isl_val_lt(v2, v1);
1320 }
1321
1322 /* Is "v" (strictly) greater than "i"?
1323  */
1324 isl_bool isl_val_gt_si(__isl_keep isl_val *v, long i)
1325 {
1326         isl_val *vi;
1327         isl_bool res;
1328
1329         if (!v)
1330                 return isl_bool_error;
1331         if (isl_val_is_int(v))
1332                 return isl_int_cmp_si(v->n, i) > 0;
1333         if (isl_val_is_nan(v))
1334                 return isl_bool_false;
1335         if (isl_val_is_infty(v))
1336                 return isl_bool_true;
1337         if (isl_val_is_neginfty(v))
1338                 return isl_bool_false;
1339
1340         vi = isl_val_int_from_si(isl_val_get_ctx(v), i);
1341         res = isl_val_gt(v, vi);
1342         isl_val_free(vi);
1343
1344         return res;
1345 }
1346
1347 /* Is "v1" less than or equal to "v2"?
1348  */
1349 isl_bool isl_val_le(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1350 {
1351         isl_int t;
1352         isl_bool le;
1353
1354         if (!v1 || !v2)
1355                 return isl_bool_error;
1356         if (isl_val_is_int(v1) && isl_val_is_int(v2))
1357                 return isl_int_le(v1->n, v2->n);
1358         if (isl_val_is_nan(v1) || isl_val_is_nan(v2))
1359                 return isl_bool_false;
1360         if (isl_val_eq(v1, v2))
1361                 return isl_bool_true;
1362         if (isl_val_is_infty(v2))
1363                 return isl_bool_true;
1364         if (isl_val_is_infty(v1))
1365                 return isl_bool_false;
1366         if (isl_val_is_neginfty(v1))
1367                 return isl_bool_true;
1368         if (isl_val_is_neginfty(v2))
1369                 return isl_bool_false;
1370
1371         isl_int_init(t);
1372         isl_int_mul(t, v1->n, v2->d);
1373         isl_int_submul(t, v2->n, v1->d);
1374         le = isl_int_is_nonpos(t);
1375         isl_int_clear(t);
1376
1377         return le;
1378 }
1379
1380 /* Is "v1" greater than or equal to "v2"?
1381  */
1382 isl_bool isl_val_ge(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1383 {
1384         return isl_val_le(v2, v1);
1385 }
1386
1387 /* How does "v" compare to "i"?
1388  *
1389  * Return 1 if v is greater, -1 if v is smaller and 0 if v is equal to i.
1390  *
1391  * If v is NaN (or NULL), then the result is undefined.
1392  */
1393 int isl_val_cmp_si(__isl_keep isl_val *v, long i)
1394 {
1395         isl_int t;
1396         int cmp;
1397
1398         if (!v)
1399                 return 0;
1400         if (isl_val_is_int(v))
1401                 return isl_int_cmp_si(v->n, i);
1402         if (isl_val_is_nan(v))
1403                 return 0;
1404         if (isl_val_is_infty(v))
1405                 return 1;
1406         if (isl_val_is_neginfty(v))
1407                 return -1;
1408
1409         isl_int_init(t);
1410         isl_int_mul_si(t, v->d, i);
1411         isl_int_sub(t, v->n, t);
1412         cmp = isl_int_sgn(t);
1413         isl_int_clear(t);
1414
1415         return cmp;
1416 }
1417
1418 /* Is "v1" equal to "v2"?
1419  */
1420 isl_bool isl_val_eq(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1421 {
1422         if (!v1 || !v2)
1423                 return isl_bool_error;
1424         if (isl_val_is_nan(v1) || isl_val_is_nan(v2))
1425                 return isl_bool_false;
1426
1427         return isl_int_eq(v1->n, v2->n) && isl_int_eq(v1->d, v2->d);
1428 }
1429
1430 /* Is "v1" equal to "v2" in absolute value?
1431  */
1432 isl_bool isl_val_abs_eq(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1433 {
1434         if (!v1 || !v2)
1435                 return isl_bool_error;
1436         if (isl_val_is_nan(v1) || isl_val_is_nan(v2))
1437                 return isl_bool_false;
1438
1439         return isl_int_abs_eq(v1->n, v2->n) && isl_int_eq(v1->d, v2->d);
1440 }
1441
1442 /* Is "v1" different from "v2"?
1443  */
1444 isl_bool isl_val_ne(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1445 {
1446         if (!v1 || !v2)
1447                 return isl_bool_error;
1448         if (isl_val_is_nan(v1) || isl_val_is_nan(v2))
1449                 return isl_bool_false;
1450
1451         return isl_int_ne(v1->n, v2->n) || isl_int_ne(v1->d, v2->d);
1452 }
1453
1454 /* Print a textual representation of "v" onto "p".
1455  */
1456 __isl_give isl_printer *isl_printer_print_val(__isl_take isl_printer *p,
1457         __isl_keep isl_val *v)
1458 {
1459         int neg;
1460
1461         if (!p || !v)
1462                 return isl_printer_free(p);
1463
1464         neg = isl_int_is_neg(v->n);
1465         if (neg) {
1466                 p = isl_printer_print_str(p, "-");
1467                 isl_int_neg(v->n, v->n);
1468         }
1469         if (isl_int_is_zero(v->d)) {
1470                 int sgn = isl_int_sgn(v->n);
1471                 p = isl_printer_print_str(p, sgn < 0 ? "-infty" :
1472                                             sgn == 0 ? "NaN" : "infty");
1473         } else
1474                 p = isl_printer_print_isl_int(p, v->n);
1475         if (neg)
1476                 isl_int_neg(v->n, v->n);
1477         if (!isl_int_is_zero(v->d) && !isl_int_is_one(v->d)) {
1478                 p = isl_printer_print_str(p, "/");
1479                 p = isl_printer_print_isl_int(p, v->d);
1480         }
1481
1482         return p;
1483 }
1484
1485 /* Is "val1" (obviously) equal to "val2"?
1486  *
1487  * This is a private copy of isl_val_eq for use in the generic
1488  * isl_multi_*_plain_is_equal instantiated for isl_val.
1489  */
1490 int isl_val_plain_is_equal(__isl_keep isl_val *val1, __isl_keep isl_val *val2)
1491 {
1492         return isl_val_eq(val1, val2);
1493 }
1494
1495 /* Does "v" have any non-zero coefficients
1496  * for any dimension in the given range?
1497  *
1498  * This function is only meant to be used in the generic isl_multi_*
1499  * functions which have to deal with base objects that have an associated
1500  * space.  Since an isl_val does not have any coefficients, this function
1501  * always returns isl_bool_false.
1502  */
1503 isl_bool isl_val_involves_dims(__isl_keep isl_val *v, enum isl_dim_type type,
1504         unsigned first, unsigned n)
1505 {
1506         if (!v)
1507                 return isl_bool_error;
1508
1509         return isl_bool_false;
1510 }
1511
1512 /* Insert "n" dimensions of type "type" at position "first".
1513  *
1514  * This function is only meant to be used in the generic isl_multi_*
1515  * functions which have to deal with base objects that have an associated
1516  * space.  Since an isl_val does not have an associated space, this function
1517  * does not do anything.
1518  */
1519 __isl_give isl_val *isl_val_insert_dims(__isl_take isl_val *v,
1520         enum isl_dim_type type, unsigned first, unsigned n)
1521 {
1522         return v;
1523 }
1524
1525 /* Drop the "n" first dimensions of type "type" at position "first".
1526  *
1527  * This function is only meant to be used in the generic isl_multi_*
1528  * functions which have to deal with base objects that have an associated
1529  * space.  Since an isl_val does not have an associated space, this function
1530  * does not do anything.
1531  */
1532 __isl_give isl_val *isl_val_drop_dims(__isl_take isl_val *v,
1533         enum isl_dim_type type, unsigned first, unsigned n)
1534 {
1535         return v;
1536 }
1537
1538 /* Change the name of the dimension of type "type" at position "pos" to "s".
1539  *
1540  * This function is only meant to be used in the generic isl_multi_*
1541  * functions which have to deal with base objects that have an associated
1542  * space.  Since an isl_val does not have an associated space, this function
1543  * does not do anything.
1544  */
1545 __isl_give isl_val *isl_val_set_dim_name(__isl_take isl_val *v,
1546         enum isl_dim_type type, unsigned pos, const char *s)
1547 {
1548         return v;
1549 }
1550
1551 /* Return the space of "v".
1552  *
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.  The conditions surrounding the call to this function make sure
1556  * that this function will never actually get called.  We return a valid
1557  * space anyway, just in case.
1558  */
1559 __isl_give isl_space *isl_val_get_space(__isl_keep isl_val *v)
1560 {
1561         if (!v)
1562                 return NULL;
1563
1564         return isl_space_params_alloc(isl_val_get_ctx(v), 0);
1565 }
1566
1567 /* Reset the domain space of "v" to "space".
1568  *
1569  * This function is only meant to be used in the generic isl_multi_*
1570  * functions which have to deal with base objects that have an associated
1571  * space.  Since an isl_val does not have an associated space, this function
1572  * does not do anything, apart from error handling and cleaning up memory.
1573  */
1574 __isl_give isl_val *isl_val_reset_domain_space(__isl_take isl_val *v,
1575         __isl_take isl_space *space)
1576 {
1577         if (!space)
1578                 return isl_val_free(v);
1579         isl_space_free(space);
1580         return v;
1581 }
1582
1583 /* Align the parameters of "v" to those of "space".
1584  *
1585  * This function is only meant to be used in the generic isl_multi_*
1586  * functions which have to deal with base objects that have an associated
1587  * space.  Since an isl_val does not have an associated space, this function
1588  * does not do anything, apart from error handling and cleaning up memory.
1589  * Note that the conditions surrounding the call to this function make sure
1590  * that this function will never actually get called.
1591  */
1592 __isl_give isl_val *isl_val_align_params(__isl_take isl_val *v,
1593         __isl_take isl_space *space)
1594 {
1595         if (!space)
1596                 return isl_val_free(v);
1597         isl_space_free(space);
1598         return v;
1599 }
1600
1601 /* Reorder the dimensions of the domain of "v" according
1602  * to the given reordering.
1603  *
1604  * This function is only meant to be used in the generic isl_multi_*
1605  * functions which have to deal with base objects that have an associated
1606  * space.  Since an isl_val does not have an associated space, this function
1607  * does not do anything, apart from error handling and cleaning up memory.
1608  */
1609 __isl_give isl_val *isl_val_realign_domain(__isl_take isl_val *v,
1610         __isl_take isl_reordering *r)
1611 {
1612         if (!r)
1613                 return isl_val_free(v);
1614         isl_reordering_free(r);
1615         return v;
1616 }
1617
1618 /* Return an isl_val that is zero on "ls".
1619  *
1620  * This function is only meant to be used in the generic isl_multi_*
1621  * functions which have to deal with base objects that have an associated
1622  * space.  Since an isl_val does not have an associated space, this function
1623  * simply returns a zero isl_val in the same context as "ls".
1624  */
1625 __isl_give isl_val *isl_val_zero_on_domain(__isl_take isl_local_space *ls)
1626 {
1627         isl_ctx *ctx;
1628
1629         if (!ls)
1630                 return NULL;
1631         ctx = isl_local_space_get_ctx(ls);
1632         isl_local_space_free(ls);
1633         return isl_val_zero(ctx);
1634 }
1635
1636 /* Do the parameters of "v" match those of "space"?
1637  *
1638  * This function is only meant to be used in the generic isl_multi_*
1639  * functions which have to deal with base objects that have an associated
1640  * space.  Since an isl_val does not have an associated space, this function
1641  * simply returns true, except if "v" or "space" are NULL.
1642  */
1643 isl_bool isl_val_matching_params(__isl_keep isl_val *v,
1644         __isl_keep isl_space *space)
1645 {
1646         if (!v || !space)
1647                 return isl_bool_error;
1648         return isl_bool_true;
1649 }
1650
1651 /* Check that the domain space of "v" matches "space".
1652  *
1653  * This function is only meant to be used in the generic isl_multi_*
1654  * functions which have to deal with base objects that have an associated
1655  * space.  Since an isl_val does not have an associated space, this function
1656  * simply returns 0, except if "v" or "space" are NULL.
1657  */
1658 isl_stat isl_val_check_match_domain_space(__isl_keep isl_val *v,
1659         __isl_keep isl_space *space)
1660 {
1661         if (!v || !space)
1662                 return isl_stat_error;
1663         return isl_stat_ok;
1664 }
1665
1666 #define isl_val_involves_nan isl_val_is_nan
1667
1668 #undef BASE
1669 #define BASE val
1670
1671 #include <isl_multi_no_explicit_domain.c>
1672 #include <isl_multi_templ.c>
1673 #include <isl_multi_dims.c>
1674 #include <isl_multi_product_templ.c>
1675 #include <isl_multi_splice_templ.c>
1676 #include <isl_multi_zero_templ.c>
1677
1678 /* Apply "fn" to each of the elements of "mv" with as second argument "v".
1679  */
1680 static __isl_give isl_multi_val *isl_multi_val_fn_val(
1681         __isl_take isl_multi_val *mv,
1682         __isl_give isl_val *(*fn)(__isl_take isl_val *v1,
1683                                         __isl_take isl_val *v2),
1684         __isl_take isl_val *v)
1685 {
1686         int i;
1687
1688         mv = isl_multi_val_cow(mv);
1689         if (!mv || !v)
1690                 goto error;
1691
1692         for (i = 0; i < mv->n; ++i) {
1693                 mv->u.p[i] = fn(mv->u.p[i], isl_val_copy(v));
1694                 if (!mv->u.p[i])
1695                         goto error;
1696         }
1697
1698         isl_val_free(v);
1699         return mv;
1700 error:
1701         isl_val_free(v);
1702         isl_multi_val_free(mv);
1703         return NULL;
1704 }
1705
1706 /* Add "v" to each of the elements of "mv".
1707  */
1708 __isl_give isl_multi_val *isl_multi_val_add_val(__isl_take isl_multi_val *mv,
1709         __isl_take isl_val *v)
1710 {
1711         if (!v)
1712                 return isl_multi_val_free(mv);
1713         if (isl_val_is_zero(v)) {
1714                 isl_val_free(v);
1715                 return mv;
1716         }
1717         return isl_multi_val_fn_val(mv, &isl_val_add, v);
1718 }
1719
1720 /* Reduce the elements of "mv" modulo "v".
1721  */
1722 __isl_give isl_multi_val *isl_multi_val_mod_val(__isl_take isl_multi_val *mv,
1723         __isl_take isl_val *v)
1724 {
1725         return isl_multi_val_fn_val(mv, &isl_val_mod, v);
1726 }