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 int isl_val_get_num_isl_int(__isl_keep isl_val *v, isl_int *n)
 299 {
 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;
 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_2exp(__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 /* Return the minimum of "v1" and "v2".
 561  */
 562 __isl_give isl_val *isl_val_min(__isl_take isl_val *v1, __isl_take isl_val *v2)
 563 {
 564         if (!v1 || !v2)
 565                 goto error;
 566
 567         if (isl_val_is_nan(v1)) {
 568                 isl_val_free(v2);
 569                 return v1;
 570         }
 571         if (isl_val_is_nan(v2)) {
 572                 isl_val_free(v1);
 573                 return v2;
 574         }
 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;
 581         }
 582 error:
 583         isl_val_free(v1);
 584         isl_val_free(v2);
 585         return NULL;
 586 }
 587
 588 /* Return the maximum of "v1" and "v2".
 589  */
 590 __isl_give isl_val *isl_val_max(__isl_take isl_val *v1, __isl_take isl_val *v2)
 591 {
 592         if (!v1 || !v2)
 593                 goto error;
 594
 595         if (isl_val_is_nan(v1)) {
 596                 isl_val_free(v2);
 597                 return v1;
 598         }
 599         if (isl_val_is_nan(v2)) {
 600                 isl_val_free(v1);
 601                 return v2;
 602         }
 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;
 609         }
 610 error:
 611         isl_val_free(v1);
 612         isl_val_free(v2);
 613         return NULL;
 614 }
 615
 616 /* Return the sum of "v1" and "v2".
 617  */
 618 __isl_give isl_val *isl_val_add(__isl_take isl_val *v1, __isl_take isl_val *v2)
 619 {
 620         if (!v1 || !v2)
 621                 goto error;
 622         if (isl_val_is_nan(v1)) {
 623                 isl_val_free(v2);
 624                 return v1;
 625         }
 626         if (isl_val_is_nan(v2)) {
 627                 isl_val_free(v1);
 628                 return v2;
 629         }
 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);
 634         }
 635         if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1)) {
 636                 isl_val_free(v2);
 637                 return v1;
 638         }
 639         if (isl_val_is_infty(v2) || isl_val_is_neginfty(v2)) {
 640                 isl_val_free(v1);
 641                 return v2;
 642         }
 643         if (isl_val_is_zero(v1)) {
 644                 isl_val_free(v1);
 645                 return v2;
 646         }
 647         if (isl_val_is_zero(v2)) {
 648                 isl_val_free(v2);
 649                 return v1;
 650         }
 651
 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);
 664                 }
 665                 v1 = isl_val_normalize(v1);
 666         }
 667         isl_val_free(v2);
 668         return v1;
 669 error:
 670         isl_val_free(v1);
 671         isl_val_free(v2);
 672         return NULL;
 673 }
 674
 675 /* Return the sum of "v1" and "v2".
 676  */
 677 __isl_give isl_val *isl_val_add_ui(__isl_take isl_val *v1, unsigned long v2)
 678 {
 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;
 688
 689         isl_int_addmul_ui(v1->n, v1->d, v2);
 690
 691         return v1;
 692 }
 693
 694 /* Subtract "v2" from "v1".
 695  */
 696 __isl_give isl_val *isl_val_sub(__isl_take isl_val *v1, __isl_take isl_val *v2)
 697 {
 698         if (!v1 || !v2)
 699                 goto error;
 700         if (isl_val_is_nan(v1)) {
 701                 isl_val_free(v2);
 702                 return v1;
 703         }
 704         if (isl_val_is_nan(v2)) {
 705                 isl_val_free(v1);
 706                 return v2;
 707         }
 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);
 712         }
 713         if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1)) {
 714                 isl_val_free(v2);
 715                 return v1;
 716         }
 717         if (isl_val_is_infty(v2) || isl_val_is_neginfty(v2)) {
 718                 isl_val_free(v1);
 719                 return isl_val_neg(v2);
 720         }
 721         if (isl_val_is_zero(v2)) {
 722                 isl_val_free(v2);
 723                 return v1;
 724         }
 725         if (isl_val_is_zero(v1)) {
 726                 isl_val_free(v1);
 727                 return isl_val_neg(v2);
 728         }
 729
 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);
 742                 }
 743                 v1 = isl_val_normalize(v1);
 744         }
 745         isl_val_free(v2);
 746         return v1;
 747 error:
 748         isl_val_free(v1);
 749         isl_val_free(v2);
 750         return NULL;
 751 }
 752
 753 /* Subtract "v2" from "v1".
 754  */
 755 __isl_give isl_val *isl_val_sub_ui(__isl_take isl_val *v1, unsigned long v2)
 756 {
 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;
 766
 767         isl_int_submul_ui(v1->n, v1->d, v2);
 768
 769         return v1;
 770 }
 771
 772 /* Return the product of "v1" and "v2".
 773  */
 774 __isl_give isl_val *isl_val_mul(__isl_take isl_val *v1, __isl_take isl_val *v2)
 775 {
 776         if (!v1 || !v2)
 777                 goto error;
 778         if (isl_val_is_nan(v1)) {
 779                 isl_val_free(v2);
 780                 return v1;
 781         }
 782         if (isl_val_is_nan(v2)) {
 783                 isl_val_free(v1);
 784                 return v2;
 785         }
 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);
 790         }
 791         if (isl_val_is_zero(v1)) {
 792                 isl_val_free(v2);
 793                 return v1;
 794         }
 795         if (isl_val_is_zero(v2)) {
 796                 isl_val_free(v1);
 797                 return v2;
 798         }
 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;
 804         }
 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;
 810         }
 811
 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);
 821         }
 822         isl_val_free(v2);
 823         return v1;
 824 error:
 825         isl_val_free(v1);
 826         isl_val_free(v2);
 827         return NULL;
 828 }
 829
 830 /* Return the product of "v1" and "v2".
 831  *
 832  * This is a private copy of isl_val_mul for use in the generic
 833  * isl_multi_*_scale_val instantiated for isl_val.
 834  */
 835 __isl_give isl_val *isl_val_scale_val(__isl_take isl_val *v1,
 836         __isl_take isl_val *v2)
 837 {
 838         return isl_val_mul(v1, v2);
 839 }
 840
 841 /* Return the product of "v1" and "v2".
 842  */
 843 __isl_give isl_val *isl_val_mul_ui(__isl_take isl_val *v1, unsigned long v2)
 844 {
 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;
 853         }
 854         if (v2 == 1)
 855                 return v1;
 856         v1 = isl_val_cow(v1);
 857         if (!v1)
 858                 return NULL;
 859
 860         isl_int_mul_ui(v1->n, v1->n, v2);
 861
 862         return isl_val_normalize(v1);
 863 }
 864
 865 /* Divide "v1" by "v2".
 866  */
 867 __isl_give isl_val *isl_val_div(__isl_take isl_val *v1, __isl_take isl_val *v2)
 868 {
 869         if (!v1 || !v2)
 870                 goto error;
 871         if (isl_val_is_nan(v1)) {
 872                 isl_val_free(v2);
 873                 return v1;
 874         }
 875         if (isl_val_is_nan(v2)) {
 876                 isl_val_free(v1);
 877                 return v2;
 878         }
 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);
 883         }
 884         if (isl_val_is_zero(v1)) {
 885                 isl_val_free(v2);
 886                 return v1;
 887         }
 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;
 893         }
 894         if (isl_val_is_infty(v2) || isl_val_is_neginfty(v2)) {
 895                 isl_val_free(v2);
 896                 return isl_val_set_zero(v1);
 897         }
 898
 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);
 909         }
 910         isl_val_free(v2);
 911         return v1;
 912 error:
 913         isl_val_free(v1);
 914         isl_val_free(v2);
 915         return NULL;
 916 }
 917
 918 /* Divide "v1" by "v2".
 919  */
 920 __isl_give isl_val *isl_val_div_ui(__isl_take isl_val *v1, unsigned long v2)
 921 {
 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;
 937
 938         isl_int_mul_ui(v1->d, v1->d, v2);
 939
 940         return isl_val_normalize(v1);
 941 }
 942
 943 /* Divide "v1" by "v2".
 944  *
 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.
 947  */
 948 __isl_give isl_val *isl_val_scale_down_val(__isl_take isl_val *v1,
 949         __isl_take isl_val *v2)
 950 {
 951         return isl_val_div(v1, v2);
 952 }
 953
 954 /* Given two integer values "v1" and "v2", check if "v1" is divisible by "v2".
 955  */
 956 isl_bool isl_val_is_divisible_by(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
 957 {
 958         if (!v1 || !v2)
 959                 return isl_bool_error;
 960
 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);
 964
 965         return isl_int_is_divisible_by(v1->n, v2->n);
 966 }
 967
 968 /* Given two integer values "v1" and "v2", return the residue of "v1"
 969  * modulo "v2".
 970  */
 971 __isl_give isl_val *isl_val_mod(__isl_take isl_val *v1, __isl_take isl_val *v2)
 972 {
 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;
 981         }
 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;
 992 }
 993
 994 /* Given two integer values "v1" and "v2", return the residue of "v1"
 995  * modulo "v2".
 996  *
 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.
 999  */
1000 __isl_give isl_val *isl_val_mod_val(__isl_take isl_val *v1,
1001         __isl_take isl_val *v2)
1002 {
1003         return isl_val_mod(v1, v2);
1004 }
1005
1006 /* Given two integer values, return their greatest common divisor.
1007  */
1008 __isl_give isl_val *isl_val_gcd(__isl_take isl_val *v1, __isl_take isl_val *v2)
1009 {
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;
1018         }
1019         if (isl_val_is_one(v1)) {
1020                 isl_val_free(v2);
1021                 return v1;
1022         }
1023         if (isl_val_is_one(v2)) {
1024                 isl_val_free(v1);
1025                 return v2;
1026         }
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;
1037 }
1038
1039 /* Compute x, y and g such that g = gcd(a,b) and a*x+b*y = g.
1040  */
1041 static void isl_int_gcdext(isl_int *g, isl_int *x, isl_int *y,
1042         isl_int a, isl_int b)
1043 {
1044         isl_int d, tmp;
1045         isl_int a_copy, b_copy;
1046
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);
1063         }
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);
1074         }
1075         isl_int_clear(d);
1076         isl_int_clear(tmp);
1077         isl_int_clear(a_copy);
1078         isl_int_clear(b_copy);
1079 }
1080
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.
1083  */
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)
1086 {
1087         isl_ctx *ctx;
1088         isl_val *a = NULL, *b = NULL;
1089
1090         if (!x && !y)
1091                 return isl_val_gcd(v1, v2);
1092
1093         if (!v1 || !v2)
1094                 goto error;
1095
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);
1100
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;
1129 }
1130
1131 /* Does "v" represent an integer value?
1132  */
1133 isl_bool isl_val_is_int(__isl_keep isl_val *v)
1134 {
1135         if (!v)
1136                 return isl_bool_error;
1137
1138         return isl_int_is_one(v->d);
1139 }
1140
1141 /* Does "v" represent a rational value?
1142  */
1143 isl_bool isl_val_is_rat(__isl_keep isl_val *v)
1144 {
1145         if (!v)
1146                 return isl_bool_error;
1147
1148         return !isl_int_is_zero(v->d);
1149 }
1150
1151 /* Does "v" represent NaN?
1152  */
1153 isl_bool isl_val_is_nan(__isl_keep isl_val *v)
1154 {
1155         if (!v)
1156                 return isl_bool_error;
1157
1158         return isl_int_is_zero(v->n) && isl_int_is_zero(v->d);
1159 }
1160
1161 /* Does "v" represent +infinity?
1162  */
1163 isl_bool isl_val_is_infty(__isl_keep isl_val *v)
1164 {
1165         if (!v)
1166                 return isl_bool_error;
1167
1168         return isl_int_is_pos(v->n) && isl_int_is_zero(v->d);
1169 }
1170
1171 /* Does "v" represent -infinity?
1172  */
1173 isl_bool isl_val_is_neginfty(__isl_keep isl_val *v)
1174 {
1175         if (!v)
1176                 return isl_bool_error;
1177
1178         return isl_int_is_neg(v->n) && isl_int_is_zero(v->d);
1179 }
1180
1181 /* Does "v" represent the integer zero?
1182  */
1183 isl_bool isl_val_is_zero(__isl_keep isl_val *v)
1184 {
1185         if (!v)
1186                 return isl_bool_error;
1187
1188         return isl_int_is_zero(v->n) && !isl_int_is_zero(v->d);
1189 }
1190
1191 /* Does "v" represent the integer one?
1192  */
1193 isl_bool isl_val_is_one(__isl_keep isl_val *v)
1194 {
1195         if (!v)
1196                 return isl_bool_error;
1197
1198         if (isl_val_is_nan(v))
1199                 return isl_bool_false;
1200
1201         return isl_int_eq(v->n, v->d);
1202 }
1203
1204 /* Does "v" represent the integer negative one?
1205  */
1206 isl_bool isl_val_is_negone(__isl_keep isl_val *v)
1207 {
1208         if (!v)
1209                 return isl_bool_error;
1210
1211         return isl_int_is_neg(v->n) && isl_int_abs_eq(v->n, v->d);
1212 }
1213
1214 /* Is "v" (strictly) positive?
1215  */
1216 isl_bool isl_val_is_pos(__isl_keep isl_val *v)
1217 {
1218         if (!v)
1219                 return isl_bool_error;
1220
1221         return isl_int_is_pos(v->n);
1222 }
1223
1224 /* Is "v" (strictly) negative?
1225  */
1226 isl_bool isl_val_is_neg(__isl_keep isl_val *v)
1227 {
1228         if (!v)
1229                 return isl_bool_error;
1230
1231         return isl_int_is_neg(v->n);
1232 }
1233
1234 /* Is "v" non-negative?
1235  */
1236 isl_bool isl_val_is_nonneg(__isl_keep isl_val *v)
1237 {
1238         if (!v)
1239                 return isl_bool_error;
1240
1241         if (isl_val_is_nan(v))
1242                 return isl_bool_false;
1243
1244         return isl_int_is_nonneg(v->n);
1245 }
1246
1247 /* Is "v" non-positive?
1248  */
1249 isl_bool isl_val_is_nonpos(__isl_keep isl_val *v)
1250 {
1251         if (!v)
1252                 return isl_bool_error;
1253
1254         if (isl_val_is_nan(v))
1255                 return isl_bool_false;
1256
1257         return isl_int_is_nonpos(v->n);
1258 }
1259
1260 /* Return the sign of "v".
1261  *
1262  * The sign of NaN is undefined.
1263  */
1264 int isl_val_sgn(__isl_keep isl_val *v)
1265 {
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;
1273 }
1274
1275 /* Is "v1" (strictly) less than "v2"?
1276  */
1277 isl_bool isl_val_lt(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1278 {
1279         isl_int t;
1280         isl_bool lt;
1281
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;
1298
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);
1304
1305         return lt;
1306 }
1307
1308 /* Is "v1" (strictly) greater than "v2"?
1309  */
1310 isl_bool isl_val_gt(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1311 {
1312         return isl_val_lt(v2, v1);
1313 }
1314
1315 /* Is "v" (strictly) greater than "i"?
1316  */
1317 isl_bool isl_val_gt_si(__isl_keep isl_val *v, long i)
1318 {
1319         isl_val *vi;
1320         isl_bool res;
1321
1322         if (!v)
1323                 return isl_bool_error;
1324         if (isl_val_is_int(v))
1325                 return isl_int_cmp_si(v->n, i) > 0;
1326         if (isl_val_is_nan(v))
1327                 return isl_bool_false;
1328         if (isl_val_is_infty(v))
1329                 return isl_bool_true;
1330         if (isl_val_is_neginfty(v))
1331                 return isl_bool_false;
1332
1333         vi = isl_val_int_from_si(isl_val_get_ctx(v), i);
1334         res = isl_val_gt(v, vi);
1335         isl_val_free(vi);
1336
1337         return res;
1338 }
1339
1340 /* Is "v1" less than or equal to "v2"?
1341  */
1342 isl_bool isl_val_le(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1343 {
1344         isl_int t;
1345         isl_bool le;
1346
1347         if (!v1 || !v2)
1348                 return isl_bool_error;
1349         if (isl_val_is_int(v1) && isl_val_is_int(v2))
1350                 return isl_int_le(v1->n, v2->n);
1351         if (isl_val_is_nan(v1) || isl_val_is_nan(v2))
1352                 return isl_bool_false;
1353         if (isl_val_eq(v1, v2))
1354                 return isl_bool_true;
1355         if (isl_val_is_infty(v2))
1356                 return isl_bool_true;
1357         if (isl_val_is_infty(v1))
1358                 return isl_bool_false;
1359         if (isl_val_is_neginfty(v1))
1360                 return isl_bool_true;
1361         if (isl_val_is_neginfty(v2))
1362                 return isl_bool_false;
1363
1364         isl_int_init(t);
1365         isl_int_mul(t, v1->n, v2->d);
1366         isl_int_submul(t, v2->n, v1->d);
1367         le = isl_int_is_nonpos(t);
1368         isl_int_clear(t);
1369
1370         return le;
1371 }
1372
1373 /* Is "v1" greater than or equal to "v2"?
1374  */
1375 isl_bool isl_val_ge(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1376 {
1377         return isl_val_le(v2, v1);
1378 }
1379
1380 /* How does "v" compare to "i"?
1381  *
1382  * Return 1 if v is greater, -1 if v is smaller and 0 if v is equal to i.
1383  *
1384  * If v is NaN (or NULL), then the result is undefined.
1385  */
1386 int isl_val_cmp_si(__isl_keep isl_val *v, long i)
1387 {
1388         isl_int t;
1389         int cmp;
1390
1391         if (!v)
1392                 return 0;
1393         if (isl_val_is_int(v))
1394                 return isl_int_cmp_si(v->n, i);
1395         if (isl_val_is_nan(v))
1396                 return 0;
1397         if (isl_val_is_infty(v))
1398                 return 1;
1399         if (isl_val_is_neginfty(v))
1400                 return -1;
1401
1402         isl_int_init(t);
1403         isl_int_mul_si(t, v->d, i);
1404         isl_int_sub(t, v->n, t);
1405         cmp = isl_int_sgn(t);
1406         isl_int_clear(t);
1407
1408         return cmp;
1409 }
1410
1411 /* Is "v1" equal to "v2"?
1412  */
1413 isl_bool isl_val_eq(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1414 {
1415         if (!v1 || !v2)
1416                 return isl_bool_error;
1417         if (isl_val_is_nan(v1) || isl_val_is_nan(v2))
1418                 return isl_bool_false;
1419
1420         return isl_int_eq(v1->n, v2->n) && isl_int_eq(v1->d, v2->d);
1421 }
1422
1423 /* Is "v1" equal to "v2" in absolute value?
1424  */
1425 isl_bool isl_val_abs_eq(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1426 {
1427         if (!v1 || !v2)
1428                 return isl_bool_error;
1429         if (isl_val_is_nan(v1) || isl_val_is_nan(v2))
1430                 return isl_bool_false;
1431
1432         return isl_int_abs_eq(v1->n, v2->n) && isl_int_eq(v1->d, v2->d);
1433 }
1434
1435 /* Is "v1" different from "v2"?
1436  */
1437 isl_bool isl_val_ne(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1438 {
1439         if (!v1 || !v2)
1440                 return isl_bool_error;
1441         if (isl_val_is_nan(v1) || isl_val_is_nan(v2))
1442                 return isl_bool_false;
1443
1444         return isl_int_ne(v1->n, v2->n) || isl_int_ne(v1->d, v2->d);
1445 }
1446
1447 /* Print a textual representation of "v" onto "p".
1448  */
1449 __isl_give isl_printer *isl_printer_print_val(__isl_take isl_printer *p,
1450         __isl_keep isl_val *v)
1451 {
1452         int neg;
1453
1454         if (!p || !v)
1455                 return isl_printer_free(p);
1456
1457         neg = isl_int_is_neg(v->n);
1458         if (neg) {
1459                 p = isl_printer_print_str(p, "-");
1460                 isl_int_neg(v->n, v->n);
1461         }
1462         if (isl_int_is_zero(v->d)) {
1463                 int sgn = isl_int_sgn(v->n);
1464                 p = isl_printer_print_str(p, sgn < 0 ? "-infty" :
1465                                             sgn == 0 ? "NaN" : "infty");
1466         } else
1467                 p = isl_printer_print_isl_int(p, v->n);
1468         if (neg)
1469                 isl_int_neg(v->n, v->n);
1470         if (!isl_int_is_zero(v->d) && !isl_int_is_one(v->d)) {
1471                 p = isl_printer_print_str(p, "/");
1472                 p = isl_printer_print_isl_int(p, v->d);
1473         }
1474
1475         return p;
1476 }
1477
1478 /* Is "val1" (obviously) equal to "val2"?
1479  *
1480  * This is a private copy of isl_val_eq for use in the generic
1481  * isl_multi_*_plain_is_equal instantiated for isl_val.
1482  */
1483 int isl_val_plain_is_equal(__isl_keep isl_val *val1, __isl_keep isl_val *val2)
1484 {
1485         return isl_val_eq(val1, val2);
1486 }
1487
1488 /* Does "v" have any non-zero coefficients
1489  * for any dimension in the given range?
1490  *
1491  * This function is only meant to be used in the generic isl_multi_*
1492  * functions which have to deal with base objects that have an associated
1493  * space.  Since an isl_val does not have any coefficients, this function
1494  * always return 0.
1495  */
1496 int isl_val_involves_dims(__isl_keep isl_val *v, enum isl_dim_type type,
1497         unsigned first, unsigned n)
1498 {
1499         if (!v)
1500                 return -1;
1501
1502         return 0;
1503 }
1504
1505 /* Insert "n" dimensions of type "type" at position "first".
1506  *
1507  * This function is only meant to be used in the generic isl_multi_*
1508  * functions which have to deal with base objects that have an associated
1509  * space.  Since an isl_val does not have an associated space, this function
1510  * does not do anything.
1511  */
1512 __isl_give isl_val *isl_val_insert_dims(__isl_take isl_val *v,
1513         enum isl_dim_type type, unsigned first, unsigned n)
1514 {
1515         return v;
1516 }
1517
1518 /* Drop the "n" first dimensions of type "type" at position "first".
1519  *
1520  * This function is only meant to be used in the generic isl_multi_*
1521  * functions which have to deal with base objects that have an associated
1522  * space.  Since an isl_val does not have an associated space, this function
1523  * does not do anything.
1524  */
1525 __isl_give isl_val *isl_val_drop_dims(__isl_take isl_val *v,
1526         enum isl_dim_type type, unsigned first, unsigned n)
1527 {
1528         return v;
1529 }
1530
1531 /* Change the name of the dimension of type "type" at position "pos" to "s".
1532  *
1533  * This function is only meant to be used in the generic isl_multi_*
1534  * functions which have to deal with base objects that have an associated
1535  * space.  Since an isl_val does not have an associated space, this function
1536  * does not do anything.
1537  */
1538 __isl_give isl_val *isl_val_set_dim_name(__isl_take isl_val *v,
1539         enum isl_dim_type type, unsigned pos, const char *s)
1540 {
1541         return v;
1542 }
1543
1544 /* Return the space of "v".
1545  *
1546  * This function is only meant to be used in the generic isl_multi_*
1547  * functions which have to deal with base objects that have an associated
1548  * space.  The conditions surrounding the call to this function make sure
1549  * that this function will never actually get called.  We return a valid
1550  * space anyway, just in case.
1551  */
1552 __isl_give isl_space *isl_val_get_space(__isl_keep isl_val *v)
1553 {
1554         if (!v)
1555                 return NULL;
1556
1557         return isl_space_params_alloc(isl_val_get_ctx(v), 0);
1558 }
1559
1560 /* Reset the domain space of "v" to "space".
1561  *
1562  * This function is only meant to be used in the generic isl_multi_*
1563  * functions which have to deal with base objects that have an associated
1564  * space.  Since an isl_val does not have an associated space, this function
1565  * does not do anything, apart from error handling and cleaning up memory.
1566  */
1567 __isl_give isl_val *isl_val_reset_domain_space(__isl_take isl_val *v,
1568         __isl_take isl_space *space)
1569 {
1570         if (!space)
1571                 return isl_val_free(v);
1572         isl_space_free(space);
1573         return v;
1574 }
1575
1576 /* Align the parameters of "v" to those of "space".
1577  *
1578  * This function is only meant to be used in the generic isl_multi_*
1579  * functions which have to deal with base objects that have an associated
1580  * space.  Since an isl_val does not have an associated space, this function
1581  * does not do anything, apart from error handling and cleaning up memory.
1582  * Note that the conditions surrounding the call to this function make sure
1583  * that this function will never actually get called.
1584  */
1585 __isl_give isl_val *isl_val_align_params(__isl_take isl_val *v,
1586         __isl_take isl_space *space)
1587 {
1588         if (!space)
1589                 return isl_val_free(v);
1590         isl_space_free(space);
1591         return v;
1592 }
1593
1594 /* Reorder the dimensions of the domain of "v" according
1595  * to the given reordering.
1596  *
1597  * This function is only meant to be used in the generic isl_multi_*
1598  * functions which have to deal with base objects that have an associated
1599  * space.  Since an isl_val does not have an associated space, this function
1600  * does not do anything, apart from error handling and cleaning up memory.
1601  */
1602 __isl_give isl_val *isl_val_realign_domain(__isl_take isl_val *v,
1603         __isl_take isl_reordering *r)
1604 {
1605         if (!r)
1606                 return isl_val_free(v);
1607         isl_reordering_free(r);
1608         return v;
1609 }
1610
1611 /* Return an isl_val that is zero on "ls".
1612  *
1613  * This function is only meant to be used in the generic isl_multi_*
1614  * functions which have to deal with base objects that have an associated
1615  * space.  Since an isl_val does not have an associated space, this function
1616  * simply returns a zero isl_val in the same context as "ls".
1617  */
1618 __isl_give isl_val *isl_val_zero_on_domain(__isl_take isl_local_space *ls)
1619 {
1620         isl_ctx *ctx;
1621
1622         if (!ls)
1623                 return NULL;
1624         ctx = isl_local_space_get_ctx(ls);
1625         isl_local_space_free(ls);
1626         return isl_val_zero(ctx);
1627 }
1628
1629 /* Do the parameters of "v" match those of "space"?
1630  *
1631  * This function is only meant to be used in the generic isl_multi_*
1632  * functions which have to deal with base objects that have an associated
1633  * space.  Since an isl_val does not have an associated space, this function
1634  * simply returns true, except if "v" or "space" are NULL.
1635  */
1636 isl_bool isl_val_matching_params(__isl_keep isl_val *v,
1637         __isl_keep isl_space *space)
1638 {
1639         if (!v || !space)
1640                 return isl_bool_error;
1641         return isl_bool_true;
1642 }
1643
1644 /* Check that the domain space of "v" matches "space".
1645  *
1646  * This function is only meant to be used in the generic isl_multi_*
1647  * functions which have to deal with base objects that have an associated
1648  * space.  Since an isl_val does not have an associated space, this function
1649  * simply returns 0, except if "v" or "space" are NULL.
1650  */
1651 isl_stat isl_val_check_match_domain_space(__isl_keep isl_val *v,
1652         __isl_keep isl_space *space)
1653 {
1654         if (!v || !space)
1655                 return isl_stat_error;
1656         return isl_stat_ok;
1657 }
1658
1659 #define isl_val_involves_nan isl_val_is_nan
1660
1661 #undef BASE
1662 #define BASE val
1663
1664 #define NO_DOMAIN
1665 #define NO_IDENTITY
1666 #define NO_FROM_BASE
1667 #define NO_MOVE_DIMS
1668 #include <isl_multi_no_explicit_domain.c>
1669 #include <isl_multi_templ.c>
1670 #include <isl_multi_dims.c>
1671
1672 /* Apply "fn" to each of the elements of "mv" with as second argument "v".
1673  */
1674 static __isl_give isl_multi_val *isl_multi_val_fn_val(
1675         __isl_take isl_multi_val *mv,
1676         __isl_give isl_val *(*fn)(__isl_take isl_val *v1,
1677                                         __isl_take isl_val *v2),
1678         __isl_take isl_val *v)
1679 {
1680         int i;
1681
1682         mv = isl_multi_val_cow(mv);
1683         if (!mv || !v)
1684                 goto error;
1685
1686         for (i = 0; i < mv->n; ++i) {
1687                 mv->u.p[i] = fn(mv->u.p[i], isl_val_copy(v));
1688                 if (!mv->u.p[i])
1689                         goto error;
1690         }
1691
1692         isl_val_free(v);
1693         return mv;
1694 error:
1695         isl_val_free(v);
1696         isl_multi_val_free(mv);
1697         return NULL;
1698 }
1699
1700 /* Add "v" to each of the elements of "mv".
1701  */
1702 __isl_give isl_multi_val *isl_multi_val_add_val(__isl_take isl_multi_val *mv,
1703         __isl_take isl_val *v)
1704 {
1705         if (!v)
1706                 return isl_multi_val_free(mv);
1707         if (isl_val_is_zero(v)) {
1708                 isl_val_free(v);
1709                 return mv;
1710         }
1711         return isl_multi_val_fn_val(mv, &isl_val_add, v);
1712 }
1713
1714 /* Reduce the elements of "mv" modulo "v".
1715  */
1716 __isl_give isl_multi_val *isl_multi_val_mod_val(__isl_take isl_multi_val *mv,
1717         __isl_take isl_val *v)
1718 {
1719         return isl_multi_val_fn_val(mv, &isl_val_mod, v);
1720 }