isl_aff.c

   1 /*
   2  * Copyright 2011      INRIA Saclay
   3  * Copyright 2011      Sven Verdoolaege
   4  *
   5  * Use of this software is governed by the GNU LGPLv2.1 license
   6  *
   7  * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
   8  * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
   9  * 91893 Orsay, France
  10  */
  11
  12 #include <isl_ctx_private.h>
  13 #include <isl_map_private.h>
  14 #include <isl_aff_private.h>
  15 #include <isl_space_private.h>
  16 #include <isl_local_space_private.h>
  17 #include <isl_mat_private.h>
  18 #include <isl_list_private.h>
  19 #include <isl/constraint.h>
  20 #include <isl/seq.h>
  21 #include <isl/set.h>
  22
  23 __isl_give isl_aff *isl_aff_alloc_vec(__isl_take isl_local_space *ls,
  24         __isl_take isl_vec *v)
  25 {
  26         isl_aff *aff;
  27
  28         if (!ls || !v)
  29                 goto error;
  30
  31         aff = isl_calloc_type(v->ctx, struct isl_aff);
  32         if (!aff)
  33                 goto error;
  34
  35         aff->ref = 1;
  36         aff->ls = ls;
  37         aff->v = v;
  38
  39         return aff;
  40 error:
  41         isl_local_space_free(ls);
  42         isl_vec_free(v);
  43         return NULL;
  44 }
  45
  46 __isl_give isl_aff *isl_aff_alloc(__isl_take isl_local_space *ls)
  47 {
  48         isl_ctx *ctx;
  49         isl_vec *v;
  50         unsigned total;
  51
  52         if (!ls)
  53                 return NULL;
  54
  55         ctx = isl_local_space_get_ctx(ls);
  56         if (!isl_local_space_divs_known(ls))
  57                 isl_die(ctx, isl_error_invalid, "local space has unknown divs",
  58                         goto error);
  59         if (!isl_local_space_is_set(ls))
  60                 isl_die(ctx, isl_error_invalid,
  61                         "domain of affine expression should be a set",
  62                         goto error);
  63
  64         total = isl_local_space_dim(ls, isl_dim_all);
  65         v = isl_vec_alloc(ctx, 1 + 1 + total);
  66         return isl_aff_alloc_vec(ls, v);
  67 error:
  68         isl_local_space_free(ls);
  69         return NULL;
  70 }
  71
  72 __isl_give isl_aff *isl_aff_zero_on_domain(__isl_take isl_local_space *ls)
  73 {
  74         isl_aff *aff;
  75
  76         aff = isl_aff_alloc(ls);
  77         if (!aff)
  78                 return NULL;
  79
  80         isl_int_set_si(aff->v->el[0], 1);
  81         isl_seq_clr(aff->v->el + 1, aff->v->size - 1);
  82
  83         return aff;
  84 }
  85
  86 __isl_give isl_aff *isl_aff_copy(__isl_keep isl_aff *aff)
  87 {
  88         if (!aff)
  89                 return NULL;
  90
  91         aff->ref++;
  92         return aff;
  93 }
  94
  95 __isl_give isl_aff *isl_aff_dup(__isl_keep isl_aff *aff)
  96 {
  97         if (!aff)
  98                 return NULL;
  99
 100         return isl_aff_alloc_vec(isl_local_space_copy(aff->ls),
 101                                  isl_vec_copy(aff->v));
 102 }
 103
 104 __isl_give isl_aff *isl_aff_cow(__isl_take isl_aff *aff)
 105 {
 106         if (!aff)
 107                 return NULL;
 108
 109         if (aff->ref == 1)
 110                 return aff;
 111         aff->ref--;
 112         return isl_aff_dup(aff);
 113 }
 114
 115 void *isl_aff_free(__isl_take isl_aff *aff)
 116 {
 117         if (!aff)
 118                 return NULL;
 119
 120         if (--aff->ref > 0)
 121                 return NULL;
 122
 123         isl_local_space_free(aff->ls);
 124         isl_vec_free(aff->v);
 125
 126         free(aff);
 127
 128         return NULL;
 129 }
 130
 131 isl_ctx *isl_aff_get_ctx(__isl_keep isl_aff *aff)
 132 {
 133         return aff ? isl_local_space_get_ctx(aff->ls) : NULL;
 134 }
 135
 136 /* Externally, an isl_aff has a map space, but internally, the
 137  * ls field corresponds to the domain of that space.
 138  */
 139 int isl_aff_dim(__isl_keep isl_aff *aff, enum isl_dim_type type)
 140 {
 141         if (!aff)
 142                 return 0;
 143         if (type == isl_dim_out)
 144                 return 1;
 145         if (type == isl_dim_in)
 146                 type = isl_dim_set;
 147         return isl_local_space_dim(aff->ls, type);
 148 }
 149
 150 __isl_give isl_space *isl_aff_get_domain_space(__isl_keep isl_aff *aff)
 151 {
 152         return aff ? isl_local_space_get_space(aff->ls) : NULL;
 153 }
 154
 155 __isl_give isl_space *isl_aff_get_space(__isl_keep isl_aff *aff)
 156 {
 157         isl_space *space;
 158         if (!aff)
 159                 return NULL;
 160         space = isl_local_space_get_space(aff->ls);
 161         space = isl_space_from_domain(space);
 162         space = isl_space_add_dims(space, isl_dim_out, 1);
 163         return space;
 164 }
 165
 166 __isl_give isl_local_space *isl_aff_get_domain_local_space(
 167         __isl_keep isl_aff *aff)
 168 {
 169         return aff ? isl_local_space_copy(aff->ls) : NULL;
 170 }
 171
 172 __isl_give isl_local_space *isl_aff_get_local_space(__isl_keep isl_aff *aff)
 173 {
 174         isl_local_space *ls;
 175         if (!aff)
 176                 return NULL;
 177         ls = isl_local_space_copy(aff->ls);
 178         ls = isl_local_space_from_domain(ls);
 179         ls = isl_local_space_add_dims(ls, isl_dim_out, 1);
 180         return ls;
 181 }
 182
 183 /* Externally, an isl_aff has a map space, but internally, the
 184  * ls field corresponds to the domain of that space.
 185  */
 186 const char *isl_aff_get_dim_name(__isl_keep isl_aff *aff,
 187         enum isl_dim_type type, unsigned pos)
 188 {
 189         if (!aff)
 190                 return NULL;
 191         if (type == isl_dim_out)
 192                 return NULL;
 193         if (type == isl_dim_in)
 194                 type = isl_dim_set;
 195         return isl_local_space_get_dim_name(aff->ls, type, pos);
 196 }
 197
 198 __isl_give isl_aff *isl_aff_reset_domain_space(__isl_take isl_aff *aff,
 199         __isl_take isl_space *dim)
 200 {
 201         aff = isl_aff_cow(aff);
 202         if (!aff || !dim)
 203                 goto error;
 204
 205         aff->ls = isl_local_space_reset_space(aff->ls, dim);
 206         if (!aff->ls)
 207                 return isl_aff_free(aff);
 208
 209         return aff;
 210 error:
 211         isl_aff_free(aff);
 212         isl_space_free(dim);
 213         return NULL;
 214 }
 215
 216 /* Reset the space of "aff".  This function is called from isl_pw_templ.c
 217  * and doesn't know if the space of an element object is represented
 218  * directly or through its domain.  It therefore passes along both.
 219  */
 220 __isl_give isl_aff *isl_aff_reset_space_and_domain(__isl_take isl_aff *aff,
 221         __isl_take isl_space *space, __isl_take isl_space *domain)
 222 {
 223         isl_space_free(space);
 224         return isl_aff_reset_domain_space(aff, domain);
 225 }
 226
 227 /* Reorder the coefficients of the affine expression based
 228  * on the given reodering.
 229  * The reordering r is assumed to have been extended with the local
 230  * variables.
 231  */
 232 static __isl_give isl_vec *vec_reorder(__isl_take isl_vec *vec,
 233         __isl_take isl_reordering *r, int n_div)
 234 {
 235         isl_vec *res;
 236         int i;
 237
 238         if (!vec || !r)
 239                 goto error;
 240
 241         res = isl_vec_alloc(vec->ctx,
 242                             2 + isl_space_dim(r->dim, isl_dim_all) + n_div);
 243         isl_seq_cpy(res->el, vec->el, 2);
 244         isl_seq_clr(res->el + 2, res->size - 2);
 245         for (i = 0; i < r->len; ++i)
 246                 isl_int_set(res->el[2 + r->pos[i]], vec->el[2 + i]);
 247
 248         isl_reordering_free(r);
 249         isl_vec_free(vec);
 250         return res;
 251 error:
 252         isl_vec_free(vec);
 253         isl_reordering_free(r);
 254         return NULL;
 255 }
 256
 257 /* Reorder the dimensions of the domain of "aff" according
 258  * to the given reordering.
 259  */
 260 __isl_give isl_aff *isl_aff_realign_domain(__isl_take isl_aff *aff,
 261         __isl_take isl_reordering *r)
 262 {
 263         aff = isl_aff_cow(aff);
 264         if (!aff)
 265                 goto error;
 266
 267         r = isl_reordering_extend(r, aff->ls->div->n_row);
 268         aff->v = vec_reorder(aff->v, isl_reordering_copy(r),
 269                                 aff->ls->div->n_row);
 270         aff->ls = isl_local_space_realign(aff->ls, r);
 271
 272         if (!aff->v || !aff->ls)
 273                 return isl_aff_free(aff);
 274
 275         return aff;
 276 error:
 277         isl_aff_free(aff);
 278         isl_reordering_free(r);
 279         return NULL;
 280 }
 281
 282 int isl_aff_plain_is_zero(__isl_keep isl_aff *aff)
 283 {
 284         if (!aff)
 285                 return -1;
 286
 287         return isl_seq_first_non_zero(aff->v->el + 1, aff->v->size - 1) < 0;
 288 }
 289
 290 int isl_aff_plain_is_equal(__isl_keep isl_aff *aff1, __isl_keep isl_aff *aff2)
 291 {
 292         int equal;
 293
 294         if (!aff1 || !aff2)
 295                 return -1;
 296
 297         equal = isl_local_space_is_equal(aff1->ls, aff2->ls);
 298         if (equal < 0 || !equal)
 299                 return equal;
 300
 301         return isl_vec_is_equal(aff1->v, aff2->v);
 302 }
 303
 304 int isl_aff_get_denominator(__isl_keep isl_aff *aff, isl_int *v)
 305 {
 306         if (!aff)
 307                 return -1;
 308         isl_int_set(*v, aff->v->el[0]);
 309         return 0;
 310 }
 311
 312 int isl_aff_get_constant(__isl_keep isl_aff *aff, isl_int *v)
 313 {
 314         if (!aff)
 315                 return -1;
 316         isl_int_set(*v, aff->v->el[1]);
 317         return 0;
 318 }
 319
 320 int isl_aff_get_coefficient(__isl_keep isl_aff *aff,
 321         enum isl_dim_type type, int pos, isl_int *v)
 322 {
 323         if (!aff)
 324                 return -1;
 325
 326         if (type == isl_dim_out)
 327                 isl_die(aff->v->ctx, isl_error_invalid,
 328                         "output/set dimension does not have a coefficient",
 329                         return -1);
 330         if (type == isl_dim_in)
 331                 type = isl_dim_set;
 332
 333         if (pos >= isl_local_space_dim(aff->ls, type))
 334                 isl_die(aff->v->ctx, isl_error_invalid,
 335                         "position out of bounds", return -1);
 336
 337         pos += isl_local_space_offset(aff->ls, type);
 338         isl_int_set(*v, aff->v->el[1 + pos]);
 339
 340         return 0;
 341 }
 342
 343 __isl_give isl_aff *isl_aff_set_denominator(__isl_take isl_aff *aff, isl_int v)
 344 {
 345         aff = isl_aff_cow(aff);
 346         if (!aff)
 347                 return NULL;
 348
 349         aff->v = isl_vec_cow(aff->v);
 350         if (!aff->v)
 351                 return isl_aff_free(aff);
 352
 353         isl_int_set(aff->v->el[0], v);
 354
 355         return aff;
 356 }
 357
 358 __isl_give isl_aff *isl_aff_set_constant(__isl_take isl_aff *aff, isl_int v)
 359 {
 360         aff = isl_aff_cow(aff);
 361         if (!aff)
 362                 return NULL;
 363
 364         aff->v = isl_vec_cow(aff->v);
 365         if (!aff->v)
 366                 return isl_aff_free(aff);
 367
 368         isl_int_set(aff->v->el[1], v);
 369
 370         return aff;
 371 }
 372
 373 __isl_give isl_aff *isl_aff_add_constant(__isl_take isl_aff *aff, isl_int v)
 374 {
 375         if (isl_int_is_zero(v))
 376                 return aff;
 377
 378         aff = isl_aff_cow(aff);
 379         if (!aff)
 380                 return NULL;
 381
 382         aff->v = isl_vec_cow(aff->v);
 383         if (!aff->v)
 384                 return isl_aff_free(aff);
 385
 386         isl_int_addmul(aff->v->el[1], aff->v->el[0], v);
 387
 388         return aff;
 389 }
 390
 391 __isl_give isl_aff *isl_aff_add_constant_si(__isl_take isl_aff *aff, int v)
 392 {
 393         isl_int t;
 394
 395         isl_int_init(t);
 396         isl_int_set_si(t, v);
 397         aff = isl_aff_add_constant(aff, t);
 398         isl_int_clear(t);
 399
 400         return aff;
 401 }
 402
 403 __isl_give isl_aff *isl_aff_set_constant_si(__isl_take isl_aff *aff, int v)
 404 {
 405         aff = isl_aff_cow(aff);
 406         if (!aff)
 407                 return NULL;
 408
 409         aff->v = isl_vec_cow(aff->v);
 410         if (!aff->v)
 411                 return isl_aff_free(aff);
 412
 413         isl_int_set_si(aff->v->el[1], v);
 414
 415         return aff;
 416 }
 417
 418 __isl_give isl_aff *isl_aff_set_coefficient(__isl_take isl_aff *aff,
 419         enum isl_dim_type type, int pos, isl_int v)
 420 {
 421         if (!aff)
 422                 return NULL;
 423
 424         if (type == isl_dim_out)
 425                 isl_die(aff->v->ctx, isl_error_invalid,
 426                         "output/set dimension does not have a coefficient",
 427                         return isl_aff_free(aff));
 428         if (type == isl_dim_in)
 429                 type = isl_dim_set;
 430
 431         if (pos >= isl_local_space_dim(aff->ls, type))
 432                 isl_die(aff->v->ctx, isl_error_invalid,
 433                         "position out of bounds", return isl_aff_free(aff));
 434
 435         aff = isl_aff_cow(aff);
 436         if (!aff)
 437                 return NULL;
 438
 439         aff->v = isl_vec_cow(aff->v);
 440         if (!aff->v)
 441                 return isl_aff_free(aff);
 442
 443         pos += isl_local_space_offset(aff->ls, type);
 444         isl_int_set(aff->v->el[1 + pos], v);
 445
 446         return aff;
 447 }
 448
 449 __isl_give isl_aff *isl_aff_set_coefficient_si(__isl_take isl_aff *aff,
 450         enum isl_dim_type type, int pos, int v)
 451 {
 452         if (!aff)
 453                 return NULL;
 454
 455         if (type == isl_dim_out)
 456                 isl_die(aff->v->ctx, isl_error_invalid,
 457                         "output/set dimension does not have a coefficient",
 458                         return isl_aff_free(aff));
 459         if (type == isl_dim_in)
 460                 type = isl_dim_set;
 461
 462         if (pos >= isl_local_space_dim(aff->ls, type))
 463                 isl_die(aff->v->ctx, isl_error_invalid,
 464                         "position out of bounds", return isl_aff_free(aff));
 465
 466         aff = isl_aff_cow(aff);
 467         if (!aff)
 468                 return NULL;
 469
 470         aff->v = isl_vec_cow(aff->v);
 471         if (!aff->v)
 472                 return isl_aff_free(aff);
 473
 474         pos += isl_local_space_offset(aff->ls, type);
 475         isl_int_set_si(aff->v->el[1 + pos], v);
 476
 477         return aff;
 478 }
 479
 480 __isl_give isl_aff *isl_aff_add_coefficient(__isl_take isl_aff *aff,
 481         enum isl_dim_type type, int pos, isl_int v)
 482 {
 483         if (!aff)
 484                 return NULL;
 485
 486         if (type == isl_dim_out)
 487                 isl_die(aff->v->ctx, isl_error_invalid,
 488                         "output/set dimension does not have a coefficient",
 489                         return isl_aff_free(aff));
 490         if (type == isl_dim_in)
 491                 type = isl_dim_set;
 492
 493         if (pos >= isl_local_space_dim(aff->ls, type))
 494                 isl_die(aff->v->ctx, isl_error_invalid,
 495                         "position out of bounds", return isl_aff_free(aff));
 496
 497         aff = isl_aff_cow(aff);
 498         if (!aff)
 499                 return NULL;
 500
 501         aff->v = isl_vec_cow(aff->v);
 502         if (!aff->v)
 503                 return isl_aff_free(aff);
 504
 505         pos += isl_local_space_offset(aff->ls, type);
 506         isl_int_addmul(aff->v->el[1 + pos], aff->v->el[0], v);
 507
 508         return aff;
 509 }
 510
 511 __isl_give isl_aff *isl_aff_add_coefficient_si(__isl_take isl_aff *aff,
 512         enum isl_dim_type type, int pos, int v)
 513 {
 514         isl_int t;
 515
 516         isl_int_init(t);
 517         isl_int_set_si(t, v);
 518         aff = isl_aff_add_coefficient(aff, type, pos, t);
 519         isl_int_clear(t);
 520
 521         return aff;
 522 }
 523
 524 __isl_give isl_aff *isl_aff_get_div(__isl_keep isl_aff *aff, int pos)
 525 {
 526         if (!aff)
 527                 return NULL;
 528
 529         return isl_local_space_get_div(aff->ls, pos);
 530 }
 531
 532 __isl_give isl_aff *isl_aff_neg(__isl_take isl_aff *aff)
 533 {
 534         aff = isl_aff_cow(aff);
 535         if (!aff)
 536                 return NULL;
 537         aff->v = isl_vec_cow(aff->v);
 538         if (!aff->v)
 539                 return isl_aff_free(aff);
 540
 541         isl_seq_neg(aff->v->el + 1, aff->v->el + 1, aff->v->size - 1);
 542
 543         return aff;
 544 }
 545
 546 /* Given f, return floor(f).
 547  * If f is an integer expression, then just return f.
 548  * Otherwise, if f = g/m, write g = q m + r,
 549  * create a new div d = [r/m] and return the expression q + d.
 550  * The coefficients in r are taken to lie between -m/2 and m/2.
 551  */
 552 __isl_give isl_aff *isl_aff_floor(__isl_take isl_aff *aff)
 553 {
 554         int i;
 555         int size;
 556         isl_ctx *ctx;
 557         isl_vec *div;
 558
 559         if (!aff)
 560                 return NULL;
 561
 562         if (isl_int_is_one(aff->v->el[0]))
 563                 return aff;
 564
 565         aff = isl_aff_cow(aff);
 566         if (!aff)
 567                 return NULL;
 568
 569         aff->v = isl_vec_cow(aff->v);
 570         div = isl_vec_copy(aff->v);
 571         div = isl_vec_cow(div);
 572         if (!div)
 573                 return isl_aff_free(aff);
 574
 575         ctx = isl_aff_get_ctx(aff);
 576         isl_int_fdiv_q(aff->v->el[0], aff->v->el[0], ctx->two);
 577         for (i = 1; i < aff->v->size; ++i) {
 578                 isl_int_fdiv_r(div->el[i], div->el[i], div->el[0]);
 579                 isl_int_fdiv_q(aff->v->el[i], aff->v->el[i], div->el[0]);
 580                 if (isl_int_gt(div->el[i], aff->v->el[0])) {
 581                         isl_int_sub(div->el[i], div->el[i], div->el[0]);
 582                         isl_int_add_ui(aff->v->el[i], aff->v->el[i], 1);
 583                 }
 584         }
 585
 586         aff->ls = isl_local_space_add_div(aff->ls, div);
 587         if (!aff->ls)
 588                 return isl_aff_free(aff);
 589
 590         size = aff->v->size;
 591         aff->v = isl_vec_extend(aff->v, size + 1);
 592         if (!aff->v)
 593                 return isl_aff_free(aff);
 594         isl_int_set_si(aff->v->el[0], 1);
 595         isl_int_set_si(aff->v->el[size], 1);
 596
 597         return aff;
 598 }
 599
 600 /* Compute
 601  *
 602  *      aff mod m = aff - m * floor(aff/m)
 603  */
 604 __isl_give isl_aff *isl_aff_mod(__isl_take isl_aff *aff, isl_int m)
 605 {
 606         isl_aff *res;
 607
 608         res = isl_aff_copy(aff);
 609         aff = isl_aff_scale_down(aff, m);
 610         aff = isl_aff_floor(aff);
 611         aff = isl_aff_scale(aff, m);
 612         res = isl_aff_sub(res, aff);
 613
 614         return res;
 615 }
 616
 617 /* Compute
 618  *
 619  *      pwaff mod m = pwaff - m * floor(pwaff/m)
 620  */
 621 __isl_give isl_pw_aff *isl_pw_aff_mod(__isl_take isl_pw_aff *pwaff, isl_int m)
 622 {
 623         isl_pw_aff *res;
 624
 625         res = isl_pw_aff_copy(pwaff);
 626         pwaff = isl_pw_aff_scale_down(pwaff, m);
 627         pwaff = isl_pw_aff_floor(pwaff);
 628         pwaff = isl_pw_aff_scale(pwaff, m);
 629         res = isl_pw_aff_sub(res, pwaff);
 630
 631         return res;
 632 }
 633
 634 /* Given f, return ceil(f).
 635  * If f is an integer expression, then just return f.
 636  * Otherwise, create a new div d = [-f] and return the expression -d.
 637  */
 638 __isl_give isl_aff *isl_aff_ceil(__isl_take isl_aff *aff)
 639 {
 640         if (!aff)
 641                 return NULL;
 642
 643         if (isl_int_is_one(aff->v->el[0]))
 644                 return aff;
 645
 646         aff = isl_aff_neg(aff);
 647         aff = isl_aff_floor(aff);
 648         aff = isl_aff_neg(aff);
 649
 650         return aff;
 651 }
 652
 653 /* Apply the expansion computed by isl_merge_divs.
 654  * The expansion itself is given by "exp" while the resulting
 655  * list of divs is given by "div".
 656  */
 657 __isl_give isl_aff *isl_aff_expand_divs( __isl_take isl_aff *aff,
 658         __isl_take isl_mat *div, int *exp)
 659 {
 660         int i, j;
 661         int old_n_div;
 662         int new_n_div;
 663         int offset;
 664
 665         aff = isl_aff_cow(aff);
 666         if (!aff || !div)
 667                 goto error;
 668
 669         old_n_div = isl_local_space_dim(aff->ls, isl_dim_div);
 670         new_n_div = isl_mat_rows(div);
 671         if (new_n_div < old_n_div)
 672                 isl_die(isl_mat_get_ctx(div), isl_error_invalid,
 673                         "not an expansion", goto error);
 674
 675         aff->v = isl_vec_extend(aff->v, aff->v->size + new_n_div - old_n_div);
 676         if (!aff->v)
 677                 goto error;
 678
 679         offset = 1 + isl_local_space_offset(aff->ls, isl_dim_div);
 680         j = old_n_div - 1;
 681         for (i = new_n_div - 1; i >= 0; --i) {
 682                 if (j >= 0 && exp[j] == i) {
 683                         if (i != j)
 684                                 isl_int_swap(aff->v->el[offset + i],
 685                                              aff->v->el[offset + j]);
 686                         j--;
 687                 } else
 688                         isl_int_set_si(aff->v->el[offset + i], 0);
 689         }
 690
 691         aff->ls = isl_local_space_replace_divs(aff->ls, isl_mat_copy(div));
 692         if (!aff->ls)
 693                 goto error;
 694         isl_mat_free(div);
 695         return aff;
 696 error:
 697         isl_aff_free(aff);
 698         isl_mat_free(div);
 699         return NULL;
 700 }
 701
 702 /* Add two affine expressions that live in the same local space.
 703  */
 704 static __isl_give isl_aff *add_expanded(__isl_take isl_aff *aff1,
 705         __isl_take isl_aff *aff2)
 706 {
 707         isl_int gcd, f;
 708
 709         aff1 = isl_aff_cow(aff1);
 710         if (!aff1 || !aff2)
 711                 goto error;
 712
 713         aff1->v = isl_vec_cow(aff1->v);
 714         if (!aff1->v)
 715                 goto error;
 716
 717         isl_int_init(gcd);
 718         isl_int_init(f);
 719         isl_int_gcd(gcd, aff1->v->el[0], aff2->v->el[0]);
 720         isl_int_divexact(f, aff2->v->el[0], gcd);
 721         isl_seq_scale(aff1->v->el + 1, aff1->v->el + 1, f, aff1->v->size - 1);
 722         isl_int_divexact(f, aff1->v->el[0], gcd);
 723         isl_seq_addmul(aff1->v->el + 1, f, aff2->v->el + 1, aff1->v->size - 1);
 724         isl_int_divexact(f, aff2->v->el[0], gcd);
 725         isl_int_mul(aff1->v->el[0], aff1->v->el[0], f);
 726         isl_int_clear(f);
 727         isl_int_clear(gcd);
 728
 729         isl_aff_free(aff2);
 730         return aff1;
 731 error:
 732         isl_aff_free(aff1);
 733         isl_aff_free(aff2);
 734         return NULL;
 735 }
 736
 737 __isl_give isl_aff *isl_aff_add(__isl_take isl_aff *aff1,
 738         __isl_take isl_aff *aff2)
 739 {
 740         isl_ctx *ctx;
 741         int *exp1 = NULL;
 742         int *exp2 = NULL;
 743         isl_mat *div;
 744
 745         if (!aff1 || !aff2)
 746                 goto error;
 747
 748         ctx = isl_aff_get_ctx(aff1);
 749         if (!isl_space_is_equal(aff1->ls->dim, aff2->ls->dim))
 750                 isl_die(ctx, isl_error_invalid,
 751                         "spaces don't match", goto error);
 752
 753         if (aff1->ls->div->n_row == 0 && aff2->ls->div->n_row == 0)
 754                 return add_expanded(aff1, aff2);
 755
 756         exp1 = isl_alloc_array(ctx, int, aff1->ls->div->n_row);
 757         exp2 = isl_alloc_array(ctx, int, aff2->ls->div->n_row);
 758         if (!exp1 || !exp2)
 759                 goto error;
 760
 761         div = isl_merge_divs(aff1->ls->div, aff2->ls->div, exp1, exp2);
 762         aff1 = isl_aff_expand_divs(aff1, isl_mat_copy(div), exp1);
 763         aff2 = isl_aff_expand_divs(aff2, div, exp2);
 764         free(exp1);
 765         free(exp2);
 766
 767         return add_expanded(aff1, aff2);
 768 error:
 769         free(exp1);
 770         free(exp2);
 771         isl_aff_free(aff1);
 772         isl_aff_free(aff2);
 773         return NULL;
 774 }
 775
 776 __isl_give isl_aff *isl_aff_sub(__isl_take isl_aff *aff1,
 777         __isl_take isl_aff *aff2)
 778 {
 779         return isl_aff_add(aff1, isl_aff_neg(aff2));
 780 }
 781
 782 __isl_give isl_aff *isl_aff_scale(__isl_take isl_aff *aff, isl_int f)
 783 {
 784         isl_int gcd;
 785
 786         if (isl_int_is_one(f))
 787                 return aff;
 788
 789         aff = isl_aff_cow(aff);
 790         if (!aff)
 791                 return NULL;
 792         aff->v = isl_vec_cow(aff->v);
 793         if (!aff->v)
 794                 return isl_aff_free(aff);
 795
 796         isl_int_init(gcd);
 797         isl_int_gcd(gcd, aff->v->el[0], f);
 798         isl_int_divexact(aff->v->el[0], aff->v->el[0], gcd);
 799         isl_int_divexact(gcd, f, gcd);
 800         isl_seq_scale(aff->v->el + 1, aff->v->el + 1, gcd, aff->v->size - 1);
 801         isl_int_clear(gcd);
 802
 803         return aff;
 804 }
 805
 806 __isl_give isl_aff *isl_aff_scale_down(__isl_take isl_aff *aff, isl_int f)
 807 {
 808         isl_int gcd;
 809
 810         if (isl_int_is_one(f))
 811                 return aff;
 812
 813         aff = isl_aff_cow(aff);
 814         if (!aff)
 815                 return NULL;
 816         aff->v = isl_vec_cow(aff->v);
 817         if (!aff->v)
 818                 return isl_aff_free(aff);
 819
 820         isl_int_init(gcd);
 821         isl_seq_gcd(aff->v->el + 1, aff->v->size - 1, &gcd);
 822         isl_int_gcd(gcd, gcd, f);
 823         isl_seq_scale_down(aff->v->el + 1, aff->v->el + 1, gcd, aff->v->size - 1);
 824         isl_int_divexact(gcd, f, gcd);
 825         isl_int_mul(aff->v->el[0], aff->v->el[0], gcd);
 826         isl_int_clear(gcd);
 827
 828         return aff;
 829 }
 830
 831 __isl_give isl_aff *isl_aff_scale_down_ui(__isl_take isl_aff *aff, unsigned f)
 832 {
 833         isl_int v;
 834
 835         if (f == 1)
 836                 return aff;
 837
 838         isl_int_init(v);
 839         isl_int_set_ui(v, f);
 840         aff = isl_aff_scale_down(aff, v);
 841         isl_int_clear(v);
 842
 843         return aff;
 844 }
 845
 846 __isl_give isl_aff *isl_aff_set_dim_name(__isl_take isl_aff *aff,
 847         enum isl_dim_type type, unsigned pos, const char *s)
 848 {
 849         aff = isl_aff_cow(aff);
 850         if (!aff)
 851                 return NULL;
 852         if (type == isl_dim_out)
 853                 isl_die(aff->v->ctx, isl_error_invalid,
 854                         "cannot set name of output/set dimension",
 855                         return isl_aff_free(aff));
 856         if (type == isl_dim_in)
 857                 type = isl_dim_set;
 858         aff->ls = isl_local_space_set_dim_name(aff->ls, type, pos, s);
 859         if (!aff->ls)
 860                 return isl_aff_free(aff);
 861
 862         return aff;
 863 }
 864
 865 __isl_give isl_aff *isl_aff_set_dim_id(__isl_take isl_aff *aff,
 866         enum isl_dim_type type, unsigned pos, __isl_take isl_id *id)
 867 {
 868         aff = isl_aff_cow(aff);
 869         if (!aff)
 870                 return isl_id_free(id);
 871         if (type == isl_dim_out)
 872                 isl_die(aff->v->ctx, isl_error_invalid,
 873                         "cannot set name of output/set dimension",
 874                         goto error);
 875         if (type == isl_dim_in)
 876                 type = isl_dim_set;
 877         aff->ls = isl_local_space_set_dim_id(aff->ls, type, pos, id);
 878         if (!aff->ls)
 879                 return isl_aff_free(aff);
 880
 881         return aff;
 882 error:
 883         isl_id_free(id);
 884         isl_aff_free(aff);
 885         return NULL;
 886 }
 887
 888 /* Exploit the equalities in "eq" to simplify the affine expression
 889  * and the expressions of the integer divisions in the local space.
 890  * The integer divisions in this local space are assumed to appear
 891  * as regular dimensions in "eq".
 892  */
 893 static __isl_give isl_aff *isl_aff_substitute_equalities_lifted(
 894         __isl_take isl_aff *aff, __isl_take isl_basic_set *eq)
 895 {
 896         int i, j;
 897         unsigned total;
 898         unsigned n_div;
 899
 900         if (!eq)
 901                 goto error;
 902         if (eq->n_eq == 0) {
 903                 isl_basic_set_free(eq);
 904                 return aff;
 905         }
 906
 907         aff = isl_aff_cow(aff);
 908         if (!aff)
 909                 goto error;
 910
 911         aff->ls = isl_local_space_substitute_equalities(aff->ls,
 912                                                         isl_basic_set_copy(eq));
 913         if (!aff->ls)
 914                 goto error;
 915
 916         total = 1 + isl_space_dim(eq->dim, isl_dim_all);
 917         n_div = eq->n_div;
 918         for (i = 0; i < eq->n_eq; ++i) {
 919                 j = isl_seq_last_non_zero(eq->eq[i], total + n_div);
 920                 if (j < 0 || j == 0 || j >= total)
 921                         continue;
 922
 923                 isl_seq_elim(aff->v->el + 1, eq->eq[i], j, total,
 924                                 &aff->v->el[0]);
 925         }
 926
 927         isl_basic_set_free(eq);
 928         return aff;
 929 error:
 930         isl_basic_set_free(eq);
 931         isl_aff_free(aff);
 932         return NULL;
 933 }
 934
 935 /* Exploit the equalities in "eq" to simplify the affine expression
 936  * and the expressions of the integer divisions in the local space.
 937  */
 938 static __isl_give isl_aff *isl_aff_substitute_equalities(
 939         __isl_take isl_aff *aff, __isl_take isl_basic_set *eq)
 940 {
 941         int n_div;
 942
 943         if (!aff || !eq)
 944                 goto error;
 945         n_div = isl_local_space_dim(aff->ls, isl_dim_div);
 946         if (n_div > 0)
 947                 eq = isl_basic_set_add(eq, isl_dim_set, n_div);
 948         return isl_aff_substitute_equalities_lifted(aff, eq);
 949 error:
 950         isl_basic_set_free(eq);
 951         isl_aff_free(aff);
 952         return NULL;
 953 }
 954
 955 /* Look for equalities among the variables shared by context and aff
 956  * and the integer divisions of aff, if any.
 957  * The equalities are then used to eliminate coefficients and/or integer
 958  * divisions from aff.
 959  */
 960 __isl_give isl_aff *isl_aff_gist(__isl_take isl_aff *aff,
 961         __isl_take isl_set *context)
 962 {
 963         isl_basic_set *hull;
 964         int n_div;
 965
 966         if (!aff)
 967                 goto error;
 968         n_div = isl_local_space_dim(aff->ls, isl_dim_div);
 969         if (n_div > 0) {
 970                 isl_basic_set *bset;
 971                 isl_local_space *ls;
 972                 context = isl_set_add_dims(context, isl_dim_set, n_div);
 973                 ls = isl_aff_get_domain_local_space(aff);
 974                 bset = isl_basic_set_from_local_space(ls);
 975                 bset = isl_basic_set_lift(bset);
 976                 bset = isl_basic_set_flatten(bset);
 977                 context = isl_set_intersect(context,
 978                                             isl_set_from_basic_set(bset));
 979         }
 980
 981         hull = isl_set_affine_hull(context);
 982         return isl_aff_substitute_equalities_lifted(aff, hull);
 983 error:
 984         isl_aff_free(aff);
 985         isl_set_free(context);
 986         return NULL;
 987 }
 988
 989 /* Return a basic set containing those elements in the space
 990  * of aff where it is non-negative.
 991  */
 992 __isl_give isl_basic_set *isl_aff_nonneg_basic_set(__isl_take isl_aff *aff)
 993 {
 994         isl_constraint *ineq;
 995
 996         ineq = isl_inequality_from_aff(aff);
 997
 998         return isl_basic_set_from_constraint(ineq);
 999 }
1000
1001 /* Return a basic set containing those elements in the space
1002  * of aff where it is zero.
1003  */
1004 __isl_give isl_basic_set *isl_aff_zero_basic_set(__isl_take isl_aff *aff)
1005 {
1006         isl_constraint *ineq;
1007
1008         ineq = isl_equality_from_aff(aff);
1009
1010         return isl_basic_set_from_constraint(ineq);
1011 }
1012
1013 /* Return a basic set containing those elements in the shared space
1014  * of aff1 and aff2 where aff1 is greater than or equal to aff2.
1015  */
1016 __isl_give isl_basic_set *isl_aff_ge_basic_set(__isl_take isl_aff *aff1,
1017         __isl_take isl_aff *aff2)
1018 {
1019         aff1 = isl_aff_sub(aff1, aff2);
1020
1021         return isl_aff_nonneg_basic_set(aff1);
1022 }
1023
1024 /* Return a basic set containing those elements in the shared space
1025  * of aff1 and aff2 where aff1 is smaller than or equal to aff2.
1026  */
1027 __isl_give isl_basic_set *isl_aff_le_basic_set(__isl_take isl_aff *aff1,
1028         __isl_take isl_aff *aff2)
1029 {
1030         return isl_aff_ge_basic_set(aff2, aff1);
1031 }
1032
1033 __isl_give isl_aff *isl_aff_add_on_domain(__isl_keep isl_set *dom,
1034         __isl_take isl_aff *aff1, __isl_take isl_aff *aff2)
1035 {
1036         aff1 = isl_aff_add(aff1, aff2);
1037         aff1 = isl_aff_gist(aff1, isl_set_copy(dom));
1038         return aff1;
1039 }
1040
1041 int isl_aff_is_empty(__isl_keep isl_aff *aff)
1042 {
1043         if (!aff)
1044                 return -1;
1045
1046         return 0;
1047 }
1048
1049 /* Check whether the given affine expression has non-zero coefficient
1050  * for any dimension in the given range or if any of these dimensions
1051  * appear with non-zero coefficients in any of the integer divisions
1052  * involved in the affine expression.
1053  */
1054 int isl_aff_involves_dims(__isl_keep isl_aff *aff,
1055         enum isl_dim_type type, unsigned first, unsigned n)
1056 {
1057         int i;
1058         isl_ctx *ctx;
1059         int *active = NULL;
1060         int involves = 0;
1061
1062         if (!aff)
1063                 return -1;
1064         if (n == 0)
1065                 return 0;
1066
1067         ctx = isl_aff_get_ctx(aff);
1068         if (first + n > isl_aff_dim(aff, type))
1069                 isl_die(ctx, isl_error_invalid,
1070                         "range out of bounds", return -1);
1071
1072         active = isl_local_space_get_active(aff->ls, aff->v->el + 2);
1073         if (!active)
1074                 goto error;
1075
1076         first += isl_local_space_offset(aff->ls, type) - 1;
1077         for (i = 0; i < n; ++i)
1078                 if (active[first + i]) {
1079                         involves = 1;
1080                         break;
1081                 }
1082
1083         free(active);
1084
1085         return involves;
1086 error:
1087         free(active);
1088         return -1;
1089 }
1090
1091 __isl_give isl_aff *isl_aff_drop_dims(__isl_take isl_aff *aff,
1092         enum isl_dim_type type, unsigned first, unsigned n)
1093 {
1094         isl_ctx *ctx;
1095
1096         if (!aff)
1097                 return NULL;
1098         if (type == isl_dim_out)
1099                 isl_die(aff->v->ctx, isl_error_invalid,
1100                         "cannot drop output/set dimension",
1101                         return isl_aff_free(aff));
1102         if (type == isl_dim_in)
1103                 type = isl_dim_set;
1104         if (n == 0 && !isl_local_space_is_named_or_nested(aff->ls, type))
1105                 return aff;
1106
1107         ctx = isl_aff_get_ctx(aff);
1108         if (first + n > isl_local_space_dim(aff->ls, type))
1109                 isl_die(ctx, isl_error_invalid, "range out of bounds",
1110                         return isl_aff_free(aff));
1111
1112         aff = isl_aff_cow(aff);
1113         if (!aff)
1114                 return NULL;
1115
1116         aff->ls = isl_local_space_drop_dims(aff->ls, type, first, n);
1117         if (!aff->ls)
1118                 return isl_aff_free(aff);
1119
1120         first += 1 + isl_local_space_offset(aff->ls, type);
1121         aff->v = isl_vec_drop_els(aff->v, first, n);
1122         if (!aff->v)
1123                 return isl_aff_free(aff);
1124
1125         return aff;
1126 }
1127
1128 __isl_give isl_aff *isl_aff_insert_dims(__isl_take isl_aff *aff,
1129         enum isl_dim_type type, unsigned first, unsigned n)
1130 {
1131         isl_ctx *ctx;
1132
1133         if (!aff)
1134                 return NULL;
1135         if (type == isl_dim_out)
1136                 isl_die(aff->v->ctx, isl_error_invalid,
1137                         "cannot insert output/set dimensions",
1138                         return isl_aff_free(aff));
1139         if (type == isl_dim_in)
1140                 type = isl_dim_set;
1141         if (n == 0 && !isl_local_space_is_named_or_nested(aff->ls, type))
1142                 return aff;
1143
1144         ctx = isl_aff_get_ctx(aff);
1145         if (first > isl_local_space_dim(aff->ls, type))
1146                 isl_die(ctx, isl_error_invalid, "position out of bounds",
1147                         return isl_aff_free(aff));
1148
1149         aff = isl_aff_cow(aff);
1150         if (!aff)
1151                 return NULL;
1152
1153         aff->ls = isl_local_space_insert_dims(aff->ls, type, first, n);
1154         if (!aff->ls)
1155                 return isl_aff_free(aff);
1156
1157         first += 1 + isl_local_space_offset(aff->ls, type);
1158         aff->v = isl_vec_insert_zero_els(aff->v, first, n);
1159         if (!aff->v)
1160                 return isl_aff_free(aff);
1161
1162         return aff;
1163 }
1164
1165 __isl_give isl_aff *isl_aff_add_dims(__isl_take isl_aff *aff,
1166         enum isl_dim_type type, unsigned n)
1167 {
1168         unsigned pos;
1169
1170         pos = isl_aff_dim(aff, type);
1171
1172         return isl_aff_insert_dims(aff, type, pos, n);
1173 }
1174
1175 __isl_give isl_pw_aff *isl_pw_aff_add_dims(__isl_take isl_pw_aff *pwaff,
1176         enum isl_dim_type type, unsigned n)
1177 {
1178         unsigned pos;
1179
1180         pos = isl_pw_aff_dim(pwaff, type);
1181
1182         return isl_pw_aff_insert_dims(pwaff, type, pos, n);
1183 }
1184
1185 __isl_give isl_pw_aff *isl_pw_aff_from_aff(__isl_take isl_aff *aff)
1186 {
1187         isl_set *dom = isl_set_universe(isl_aff_get_domain_space(aff));
1188         return isl_pw_aff_alloc(dom, aff);
1189 }
1190
1191 #undef PW
1192 #define PW isl_pw_aff
1193 #undef EL
1194 #define EL isl_aff
1195 #undef EL_IS_ZERO
1196 #define EL_IS_ZERO is_empty
1197 #undef ZERO
1198 #define ZERO empty
1199 #undef IS_ZERO
1200 #define IS_ZERO is_empty
1201 #undef FIELD
1202 #define FIELD aff
1203
1204 #define NO_EVAL
1205 #define NO_OPT
1206 #define NO_MOVE_DIMS
1207 #define NO_LIFT
1208 #define NO_MORPH
1209
1210 #include <isl_pw_templ.c>
1211
1212 static __isl_give isl_set *align_params_pw_pw_set_and(
1213         __isl_take isl_pw_aff *pwaff1, __isl_take isl_pw_aff *pwaff2,
1214         __isl_give isl_set *(*fn)(__isl_take isl_pw_aff *pwaff1,
1215                                     __isl_take isl_pw_aff *pwaff2))
1216 {
1217         if (!pwaff1 || !pwaff2)
1218                 goto error;
1219         if (isl_space_match(pwaff1->dim, isl_dim_param,
1220                           pwaff2->dim, isl_dim_param))
1221                 return fn(pwaff1, pwaff2);
1222         if (!isl_space_has_named_params(pwaff1->dim) ||
1223             !isl_space_has_named_params(pwaff2->dim))
1224                 isl_die(isl_pw_aff_get_ctx(pwaff1), isl_error_invalid,
1225                         "unaligned unnamed parameters", goto error);
1226         pwaff1 = isl_pw_aff_align_params(pwaff1, isl_pw_aff_get_space(pwaff2));
1227         pwaff2 = isl_pw_aff_align_params(pwaff2, isl_pw_aff_get_space(pwaff1));
1228         return fn(pwaff1, pwaff2);
1229 error:
1230         isl_pw_aff_free(pwaff1);
1231         isl_pw_aff_free(pwaff2);
1232         return NULL;
1233 }
1234
1235 /* Compute a piecewise quasi-affine expression with a domain that
1236  * is the union of those of pwaff1 and pwaff2 and such that on each
1237  * cell, the quasi-affine expression is the better (according to cmp)
1238  * of those of pwaff1 and pwaff2.  If only one of pwaff1 or pwaff2
1239  * is defined on a given cell, then the associated expression
1240  * is the defined one.
1241  */
1242 static __isl_give isl_pw_aff *pw_aff_union_opt(__isl_take isl_pw_aff *pwaff1,
1243         __isl_take isl_pw_aff *pwaff2,
1244         __isl_give isl_basic_set *(*cmp)(__isl_take isl_aff *aff1,
1245                                         __isl_take isl_aff *aff2))
1246 {
1247         int i, j, n;
1248         isl_pw_aff *res;
1249         isl_ctx *ctx;
1250         isl_set *set;
1251
1252         if (!pwaff1 || !pwaff2)
1253                 goto error;
1254
1255         ctx = isl_space_get_ctx(pwaff1->dim);
1256         if (!isl_space_is_equal(pwaff1->dim, pwaff2->dim))
1257                 isl_die(ctx, isl_error_invalid,
1258                         "arguments should live in same space", goto error);
1259
1260         if (isl_pw_aff_is_empty(pwaff1)) {
1261                 isl_pw_aff_free(pwaff1);
1262                 return pwaff2;
1263         }
1264
1265         if (isl_pw_aff_is_empty(pwaff2)) {
1266                 isl_pw_aff_free(pwaff2);
1267                 return pwaff1;
1268         }
1269
1270         n = 2 * (pwaff1->n + 1) * (pwaff2->n + 1);
1271         res = isl_pw_aff_alloc_size(isl_space_copy(pwaff1->dim), n);
1272
1273         for (i = 0; i < pwaff1->n; ++i) {
1274                 set = isl_set_copy(pwaff1->p[i].set);
1275                 for (j = 0; j < pwaff2->n; ++j) {
1276                         struct isl_set *common;
1277                         isl_set *better;
1278
1279                         common = isl_set_intersect(
1280                                         isl_set_copy(pwaff1->p[i].set),
1281                                         isl_set_copy(pwaff2->p[j].set));
1282                         better = isl_set_from_basic_set(cmp(
1283                                         isl_aff_copy(pwaff2->p[j].aff),
1284                                         isl_aff_copy(pwaff1->p[i].aff)));
1285                         better = isl_set_intersect(common, better);
1286                         if (isl_set_plain_is_empty(better)) {
1287                                 isl_set_free(better);
1288                                 continue;
1289                         }
1290                         set = isl_set_subtract(set, isl_set_copy(better));
1291
1292                         res = isl_pw_aff_add_piece(res, better,
1293                                                 isl_aff_copy(pwaff2->p[j].aff));
1294                 }
1295                 res = isl_pw_aff_add_piece(res, set,
1296                                                 isl_aff_copy(pwaff1->p[i].aff));
1297         }
1298
1299         for (j = 0; j < pwaff2->n; ++j) {
1300                 set = isl_set_copy(pwaff2->p[j].set);
1301                 for (i = 0; i < pwaff1->n; ++i)
1302                         set = isl_set_subtract(set,
1303                                         isl_set_copy(pwaff1->p[i].set));
1304                 res = isl_pw_aff_add_piece(res, set,
1305                                                 isl_aff_copy(pwaff2->p[j].aff));
1306         }
1307
1308         isl_pw_aff_free(pwaff1);
1309         isl_pw_aff_free(pwaff2);
1310
1311         return res;
1312 error:
1313         isl_pw_aff_free(pwaff1);
1314         isl_pw_aff_free(pwaff2);
1315         return NULL;
1316 }
1317
1318 /* Compute a piecewise quasi-affine expression with a domain that
1319  * is the union of those of pwaff1 and pwaff2 and such that on each
1320  * cell, the quasi-affine expression is the maximum of those of pwaff1
1321  * and pwaff2.  If only one of pwaff1 or pwaff2 is defined on a given
1322  * cell, then the associated expression is the defined one.
1323  */
1324 static __isl_give isl_pw_aff *pw_aff_union_max(__isl_take isl_pw_aff *pwaff1,
1325         __isl_take isl_pw_aff *pwaff2)
1326 {
1327         return pw_aff_union_opt(pwaff1, pwaff2, &isl_aff_ge_basic_set);
1328 }
1329
1330 __isl_give isl_pw_aff *isl_pw_aff_union_max(__isl_take isl_pw_aff *pwaff1,
1331         __isl_take isl_pw_aff *pwaff2)
1332 {
1333         return isl_pw_aff_align_params_pw_pw_and(pwaff1, pwaff2,
1334                                                         &pw_aff_union_max);
1335 }
1336
1337 /* Compute a piecewise quasi-affine expression with a domain that
1338  * is the union of those of pwaff1 and pwaff2 and such that on each
1339  * cell, the quasi-affine expression is the minimum of those of pwaff1
1340  * and pwaff2.  If only one of pwaff1 or pwaff2 is defined on a given
1341  * cell, then the associated expression is the defined one.
1342  */
1343 static __isl_give isl_pw_aff *pw_aff_union_min(__isl_take isl_pw_aff *pwaff1,
1344         __isl_take isl_pw_aff *pwaff2)
1345 {
1346         return pw_aff_union_opt(pwaff1, pwaff2, &isl_aff_le_basic_set);
1347 }
1348
1349 __isl_give isl_pw_aff *isl_pw_aff_union_min(__isl_take isl_pw_aff *pwaff1,
1350         __isl_take isl_pw_aff *pwaff2)
1351 {
1352         return isl_pw_aff_align_params_pw_pw_and(pwaff1, pwaff2,
1353                                                         &pw_aff_union_min);
1354 }
1355
1356 __isl_give isl_pw_aff *isl_pw_aff_union_opt(__isl_take isl_pw_aff *pwaff1,
1357         __isl_take isl_pw_aff *pwaff2, int max)
1358 {
1359         if (max)
1360                 return isl_pw_aff_union_max(pwaff1, pwaff2);
1361         else
1362                 return isl_pw_aff_union_min(pwaff1, pwaff2);
1363 }
1364
1365 /* Construct a map with as domain the domain of pwaff and
1366  * one-dimensional range corresponding to the affine expressions.
1367  */
1368 static __isl_give isl_map *map_from_pw_aff(__isl_take isl_pw_aff *pwaff)
1369 {
1370         int i;
1371         isl_space *dim;
1372         isl_map *map;
1373
1374         if (!pwaff)
1375                 return NULL;
1376
1377         dim = isl_pw_aff_get_space(pwaff);
1378         map = isl_map_empty(dim);
1379
1380         for (i = 0; i < pwaff->n; ++i) {
1381                 isl_basic_map *bmap;
1382                 isl_map *map_i;
1383
1384                 bmap = isl_basic_map_from_aff(isl_aff_copy(pwaff->p[i].aff));
1385                 map_i = isl_map_from_basic_map(bmap);
1386                 map_i = isl_map_intersect_domain(map_i,
1387                                                 isl_set_copy(pwaff->p[i].set));
1388                 map = isl_map_union_disjoint(map, map_i);
1389         }
1390
1391         isl_pw_aff_free(pwaff);
1392
1393         return map;
1394 }
1395
1396 /* Construct a map with as domain the domain of pwaff and
1397  * one-dimensional range corresponding to the affine expressions.
1398  */
1399 __isl_give isl_map *isl_map_from_pw_aff(__isl_take isl_pw_aff *pwaff)
1400 {
1401         if (isl_space_is_set(pwaff->dim))
1402                 isl_die(isl_pw_aff_get_ctx(pwaff), isl_error_invalid,
1403                         "space of input is not a map",
1404                         return isl_pw_aff_free(pwaff));
1405         return map_from_pw_aff(pwaff);
1406 }
1407
1408 /* Construct a one-dimensional set with as parameter domain
1409  * the domain of pwaff and the single set dimension
1410  * corresponding to the affine expressions.
1411  */
1412 __isl_give isl_set *isl_set_from_pw_aff(__isl_take isl_pw_aff *pwaff)
1413 {
1414         if (!isl_space_is_set(pwaff->dim))
1415                 isl_die(isl_pw_aff_get_ctx(pwaff), isl_error_invalid,
1416                         "space of input is not a set",
1417                         return isl_pw_aff_free(pwaff));
1418         return map_from_pw_aff(pwaff);
1419 }
1420
1421 /* Return a set containing those elements in the domain
1422  * of pwaff where it is non-negative.
1423  */
1424 __isl_give isl_set *isl_pw_aff_nonneg_set(__isl_take isl_pw_aff *pwaff)
1425 {
1426         int i;
1427         isl_set *set;
1428
1429         if (!pwaff)
1430                 return NULL;
1431
1432         set = isl_set_empty(isl_pw_aff_get_domain_space(pwaff));
1433
1434         for (i = 0; i < pwaff->n; ++i) {
1435                 isl_basic_set *bset;
1436                 isl_set *set_i;
1437
1438                 bset = isl_aff_nonneg_basic_set(isl_aff_copy(pwaff->p[i].aff));
1439                 set_i = isl_set_from_basic_set(bset);
1440                 set_i = isl_set_intersect(set_i, isl_set_copy(pwaff->p[i].set));
1441                 set = isl_set_union_disjoint(set, set_i);
1442         }
1443
1444         isl_pw_aff_free(pwaff);
1445
1446         return set;
1447 }
1448
1449 /* Return a set containing those elements in the domain
1450  * of pwaff where it is zero.
1451  */
1452 __isl_give isl_set *isl_pw_aff_zero_set(__isl_take isl_pw_aff *pwaff)
1453 {
1454         int i;
1455         isl_set *set;
1456
1457         if (!pwaff)
1458                 return NULL;
1459
1460         set = isl_set_empty(isl_pw_aff_get_domain_space(pwaff));
1461
1462         for (i = 0; i < pwaff->n; ++i) {
1463                 isl_basic_set *bset;
1464                 isl_set *set_i;
1465
1466                 bset = isl_aff_zero_basic_set(isl_aff_copy(pwaff->p[i].aff));
1467                 set_i = isl_set_from_basic_set(bset);
1468                 set_i = isl_set_intersect(set_i, isl_set_copy(pwaff->p[i].set));
1469                 set = isl_set_union_disjoint(set, set_i);
1470         }
1471
1472         isl_pw_aff_free(pwaff);
1473
1474         return set;
1475 }
1476
1477 /* Return a set containing those elements in the domain
1478  * of pwaff where it is not zero.
1479  */
1480 __isl_give isl_set *isl_pw_aff_non_zero_set(__isl_take isl_pw_aff *pwaff)
1481 {
1482         return isl_set_complement(isl_pw_aff_zero_set(pwaff));
1483 }
1484
1485 /* Return a set containing those elements in the shared domain
1486  * of pwaff1 and pwaff2 where pwaff1 is greater than (or equal) to pwaff2.
1487  *
1488  * We compute the difference on the shared domain and then construct
1489  * the set of values where this difference is non-negative.
1490  * If strict is set, we first subtract 1 from the difference.
1491  * If equal is set, we only return the elements where pwaff1 and pwaff2
1492  * are equal.
1493  */
1494 static __isl_give isl_set *pw_aff_gte_set(__isl_take isl_pw_aff *pwaff1,
1495         __isl_take isl_pw_aff *pwaff2, int strict, int equal)
1496 {
1497         isl_set *set1, *set2;
1498
1499         set1 = isl_pw_aff_domain(isl_pw_aff_copy(pwaff1));
1500         set2 = isl_pw_aff_domain(isl_pw_aff_copy(pwaff2));
1501         set1 = isl_set_intersect(set1, set2);
1502         pwaff1 = isl_pw_aff_intersect_domain(pwaff1, isl_set_copy(set1));
1503         pwaff2 = isl_pw_aff_intersect_domain(pwaff2, isl_set_copy(set1));
1504         pwaff1 = isl_pw_aff_add(pwaff1, isl_pw_aff_neg(pwaff2));
1505
1506         if (strict) {
1507                 isl_space *dim = isl_set_get_space(set1);
1508                 isl_aff *aff;
1509                 aff = isl_aff_zero_on_domain(isl_local_space_from_space(dim));
1510                 aff = isl_aff_add_constant_si(aff, -1);
1511                 pwaff1 = isl_pw_aff_add(pwaff1, isl_pw_aff_alloc(set1, aff));
1512         } else
1513                 isl_set_free(set1);
1514
1515         if (equal)
1516                 return isl_pw_aff_zero_set(pwaff1);
1517         return isl_pw_aff_nonneg_set(pwaff1);
1518 }
1519
1520 /* Return a set containing those elements in the shared domain
1521  * of pwaff1 and pwaff2 where pwaff1 is equal to pwaff2.
1522  */
1523 static __isl_give isl_set *pw_aff_eq_set(__isl_take isl_pw_aff *pwaff1,
1524         __isl_take isl_pw_aff *pwaff2)
1525 {
1526         return pw_aff_gte_set(pwaff1, pwaff2, 0, 1);
1527 }
1528
1529 __isl_give isl_set *isl_pw_aff_eq_set(__isl_take isl_pw_aff *pwaff1,
1530         __isl_take isl_pw_aff *pwaff2)
1531 {
1532         return align_params_pw_pw_set_and(pwaff1, pwaff2, &pw_aff_eq_set);
1533 }
1534
1535 /* Return a set containing those elements in the shared domain
1536  * of pwaff1 and pwaff2 where pwaff1 is greater than or equal to pwaff2.
1537  */
1538 static __isl_give isl_set *pw_aff_ge_set(__isl_take isl_pw_aff *pwaff1,
1539         __isl_take isl_pw_aff *pwaff2)
1540 {
1541         return pw_aff_gte_set(pwaff1, pwaff2, 0, 0);
1542 }
1543
1544 __isl_give isl_set *isl_pw_aff_ge_set(__isl_take isl_pw_aff *pwaff1,
1545         __isl_take isl_pw_aff *pwaff2)
1546 {
1547         return align_params_pw_pw_set_and(pwaff1, pwaff2, &pw_aff_ge_set);
1548 }
1549
1550 /* Return a set containing those elements in the shared domain
1551  * of pwaff1 and pwaff2 where pwaff1 is strictly greater than pwaff2.
1552  */
1553 static __isl_give isl_set *pw_aff_gt_set(__isl_take isl_pw_aff *pwaff1,
1554         __isl_take isl_pw_aff *pwaff2)
1555 {
1556         return pw_aff_gte_set(pwaff1, pwaff2, 1, 0);
1557 }
1558
1559 __isl_give isl_set *isl_pw_aff_gt_set(__isl_take isl_pw_aff *pwaff1,
1560         __isl_take isl_pw_aff *pwaff2)
1561 {
1562         return align_params_pw_pw_set_and(pwaff1, pwaff2, &pw_aff_gt_set);
1563 }
1564
1565 __isl_give isl_set *isl_pw_aff_le_set(__isl_take isl_pw_aff *pwaff1,
1566         __isl_take isl_pw_aff *pwaff2)
1567 {
1568         return isl_pw_aff_ge_set(pwaff2, pwaff1);
1569 }
1570
1571 __isl_give isl_set *isl_pw_aff_lt_set(__isl_take isl_pw_aff *pwaff1,
1572         __isl_take isl_pw_aff *pwaff2)
1573 {
1574         return isl_pw_aff_gt_set(pwaff2, pwaff1);
1575 }
1576
1577 /* Return a set containing those elements in the shared domain
1578  * of the elements of list1 and list2 where each element in list1
1579  * has the relation specified by "fn" with each element in list2.
1580  */
1581 static __isl_give isl_set *pw_aff_list_set(__isl_take isl_pw_aff_list *list1,
1582         __isl_take isl_pw_aff_list *list2,
1583         __isl_give isl_set *(*fn)(__isl_take isl_pw_aff *pwaff1,
1584                                     __isl_take isl_pw_aff *pwaff2))
1585 {
1586         int i, j;
1587         isl_ctx *ctx;
1588         isl_set *set;
1589
1590         if (!list1 || !list2)
1591                 goto error;
1592
1593         ctx = isl_pw_aff_list_get_ctx(list1);
1594         if (list1->n < 1 || list2->n < 1)
1595                 isl_die(ctx, isl_error_invalid,
1596                         "list should contain at least one element", goto error);
1597
1598         set = isl_set_universe(isl_pw_aff_get_domain_space(list1->p[0]));
1599         for (i = 0; i < list1->n; ++i)
1600                 for (j = 0; j < list2->n; ++j) {
1601                         isl_set *set_ij;
1602
1603                         set_ij = fn(isl_pw_aff_copy(list1->p[i]),
1604                                     isl_pw_aff_copy(list2->p[j]));
1605                         set = isl_set_intersect(set, set_ij);
1606                 }
1607
1608         isl_pw_aff_list_free(list1);
1609         isl_pw_aff_list_free(list2);
1610         return set;
1611 error:
1612         isl_pw_aff_list_free(list1);
1613         isl_pw_aff_list_free(list2);
1614         return NULL;
1615 }
1616
1617 /* Return a set containing those elements in the shared domain
1618  * of the elements of list1 and list2 where each element in list1
1619  * is equal to each element in list2.
1620  */
1621 __isl_give isl_set *isl_pw_aff_list_eq_set(__isl_take isl_pw_aff_list *list1,
1622         __isl_take isl_pw_aff_list *list2)
1623 {
1624         return pw_aff_list_set(list1, list2, &isl_pw_aff_eq_set);
1625 }
1626
1627 __isl_give isl_set *isl_pw_aff_list_ne_set(__isl_take isl_pw_aff_list *list1,
1628         __isl_take isl_pw_aff_list *list2)
1629 {
1630         return pw_aff_list_set(list1, list2, &isl_pw_aff_ne_set);
1631 }
1632
1633 /* Return a set containing those elements in the shared domain
1634  * of the elements of list1 and list2 where each element in list1
1635  * is less than or equal to each element in list2.
1636  */
1637 __isl_give isl_set *isl_pw_aff_list_le_set(__isl_take isl_pw_aff_list *list1,
1638         __isl_take isl_pw_aff_list *list2)
1639 {
1640         return pw_aff_list_set(list1, list2, &isl_pw_aff_le_set);
1641 }
1642
1643 __isl_give isl_set *isl_pw_aff_list_lt_set(__isl_take isl_pw_aff_list *list1,
1644         __isl_take isl_pw_aff_list *list2)
1645 {
1646         return pw_aff_list_set(list1, list2, &isl_pw_aff_lt_set);
1647 }
1648
1649 __isl_give isl_set *isl_pw_aff_list_ge_set(__isl_take isl_pw_aff_list *list1,
1650         __isl_take isl_pw_aff_list *list2)
1651 {
1652         return pw_aff_list_set(list1, list2, &isl_pw_aff_ge_set);
1653 }
1654
1655 __isl_give isl_set *isl_pw_aff_list_gt_set(__isl_take isl_pw_aff_list *list1,
1656         __isl_take isl_pw_aff_list *list2)
1657 {
1658         return pw_aff_list_set(list1, list2, &isl_pw_aff_gt_set);
1659 }
1660
1661
1662 /* Return a set containing those elements in the shared domain
1663  * of pwaff1 and pwaff2 where pwaff1 is not equal to pwaff2.
1664  */
1665 static __isl_give isl_set *pw_aff_ne_set(__isl_take isl_pw_aff *pwaff1,
1666         __isl_take isl_pw_aff *pwaff2)
1667 {
1668         isl_set *set_lt, *set_gt;
1669
1670         set_lt = isl_pw_aff_lt_set(isl_pw_aff_copy(pwaff1),
1671                                    isl_pw_aff_copy(pwaff2));
1672         set_gt = isl_pw_aff_gt_set(pwaff1, pwaff2);
1673         return isl_set_union_disjoint(set_lt, set_gt);
1674 }
1675
1676 __isl_give isl_set *isl_pw_aff_ne_set(__isl_take isl_pw_aff *pwaff1,
1677         __isl_take isl_pw_aff *pwaff2)
1678 {
1679         return align_params_pw_pw_set_and(pwaff1, pwaff2, &pw_aff_ne_set);
1680 }
1681
1682 __isl_give isl_pw_aff *isl_pw_aff_scale_down(__isl_take isl_pw_aff *pwaff,
1683         isl_int v)
1684 {
1685         int i;
1686
1687         if (isl_int_is_one(v))
1688                 return pwaff;
1689         if (!isl_int_is_pos(v))
1690                 isl_die(isl_pw_aff_get_ctx(pwaff), isl_error_invalid,
1691                         "factor needs to be positive",
1692                         return isl_pw_aff_free(pwaff));
1693         pwaff = isl_pw_aff_cow(pwaff);
1694         if (!pwaff)
1695                 return NULL;
1696         if (pwaff->n == 0)
1697                 return pwaff;
1698
1699         for (i = 0; i < pwaff->n; ++i) {
1700                 pwaff->p[i].aff = isl_aff_scale_down(pwaff->p[i].aff, v);
1701                 if (!pwaff->p[i].aff)
1702                         return isl_pw_aff_free(pwaff);
1703         }
1704
1705         return pwaff;
1706 }
1707
1708 __isl_give isl_pw_aff *isl_pw_aff_floor(__isl_take isl_pw_aff *pwaff)
1709 {
1710         int i;
1711
1712         pwaff = isl_pw_aff_cow(pwaff);
1713         if (!pwaff)
1714                 return NULL;
1715         if (pwaff->n == 0)
1716                 return pwaff;
1717
1718         for (i = 0; i < pwaff->n; ++i) {
1719                 pwaff->p[i].aff = isl_aff_floor(pwaff->p[i].aff);
1720                 if (!pwaff->p[i].aff)
1721                         return isl_pw_aff_free(pwaff);
1722         }
1723
1724         return pwaff;
1725 }
1726
1727 __isl_give isl_pw_aff *isl_pw_aff_ceil(__isl_take isl_pw_aff *pwaff)
1728 {
1729         int i;
1730
1731         pwaff = isl_pw_aff_cow(pwaff);
1732         if (!pwaff)
1733                 return NULL;
1734         if (pwaff->n == 0)
1735                 return pwaff;
1736
1737         for (i = 0; i < pwaff->n; ++i) {
1738                 pwaff->p[i].aff = isl_aff_ceil(pwaff->p[i].aff);
1739                 if (!pwaff->p[i].aff)
1740                         return isl_pw_aff_free(pwaff);
1741         }
1742
1743         return pwaff;
1744 }
1745
1746 /* Return an affine expression that is equal to pwaff_true for elements
1747  * in "cond" and to pwaff_false for elements not in "cond".
1748  * That is, return cond ? pwaff_true : pwaff_false;
1749  */
1750 __isl_give isl_pw_aff *isl_pw_aff_cond(__isl_take isl_set *cond,
1751         __isl_take isl_pw_aff *pwaff_true, __isl_take isl_pw_aff *pwaff_false)
1752 {
1753         isl_set *comp;
1754
1755         comp = isl_set_complement(isl_set_copy(cond));
1756         pwaff_true = isl_pw_aff_intersect_domain(pwaff_true, cond);
1757         pwaff_false = isl_pw_aff_intersect_domain(pwaff_false, comp);
1758
1759         return isl_pw_aff_add_disjoint(pwaff_true, pwaff_false);
1760 }
1761
1762 int isl_aff_is_cst(__isl_keep isl_aff *aff)
1763 {
1764         if (!aff)
1765                 return -1;
1766
1767         return isl_seq_first_non_zero(aff->v->el + 2, aff->v->size - 2) == -1;
1768 }
1769
1770 /* Check whether pwaff is a piecewise constant.
1771  */
1772 int isl_pw_aff_is_cst(__isl_keep isl_pw_aff *pwaff)
1773 {
1774         int i;
1775
1776         if (!pwaff)
1777                 return -1;
1778
1779         for (i = 0; i < pwaff->n; ++i) {
1780                 int is_cst = isl_aff_is_cst(pwaff->p[i].aff);
1781                 if (is_cst < 0 || !is_cst)
1782                         return is_cst;
1783         }
1784
1785         return 1;
1786 }
1787
1788 __isl_give isl_aff *isl_aff_mul(__isl_take isl_aff *aff1,
1789         __isl_take isl_aff *aff2)
1790 {
1791         if (!isl_aff_is_cst(aff2) && isl_aff_is_cst(aff1))
1792                 return isl_aff_mul(aff2, aff1);
1793
1794         if (!isl_aff_is_cst(aff2))
1795                 isl_die(isl_aff_get_ctx(aff1), isl_error_invalid,
1796                         "at least one affine expression should be constant",
1797                         goto error);
1798
1799         aff1 = isl_aff_cow(aff1);
1800         if (!aff1 || !aff2)
1801                 goto error;
1802
1803         aff1 = isl_aff_scale(aff1, aff2->v->el[1]);
1804         aff1 = isl_aff_scale_down(aff1, aff2->v->el[0]);
1805
1806         isl_aff_free(aff2);
1807         return aff1;
1808 error:
1809         isl_aff_free(aff1);
1810         isl_aff_free(aff2);
1811         return NULL;
1812 }
1813
1814 static __isl_give isl_pw_aff *pw_aff_mul(__isl_take isl_pw_aff *pwaff1,
1815         __isl_take isl_pw_aff *pwaff2)
1816 {
1817         int i, j, n;
1818         isl_pw_aff *res;
1819
1820         if (!pwaff1 || !pwaff2)
1821                 goto error;
1822
1823         n = pwaff1->n * pwaff2->n;
1824         res = isl_pw_aff_alloc_size(isl_space_copy(pwaff1->dim), n);
1825
1826         for (i = 0; i < pwaff1->n; ++i) {
1827                 for (j = 0; j < pwaff2->n; ++j) {
1828                         isl_set *common;
1829                         isl_aff *prod;
1830                         common = isl_set_intersect(
1831                                         isl_set_copy(pwaff1->p[i].set),
1832                                         isl_set_copy(pwaff2->p[j].set));
1833                         if (isl_set_plain_is_empty(common)) {
1834                                 isl_set_free(common);
1835                                 continue;
1836                         }
1837
1838                         prod = isl_aff_mul(isl_aff_copy(pwaff1->p[i].aff),
1839                                             isl_aff_copy(pwaff2->p[j].aff));
1840
1841                         res = isl_pw_aff_add_piece(res, common, prod);
1842                 }
1843         }
1844
1845         isl_pw_aff_free(pwaff1);
1846         isl_pw_aff_free(pwaff2);
1847         return res;
1848 error:
1849         isl_pw_aff_free(pwaff1);
1850         isl_pw_aff_free(pwaff2);
1851         return NULL;
1852 }
1853
1854 __isl_give isl_pw_aff *isl_pw_aff_mul(__isl_take isl_pw_aff *pwaff1,
1855         __isl_take isl_pw_aff *pwaff2)
1856 {
1857         return isl_pw_aff_align_params_pw_pw_and(pwaff1, pwaff2, &pw_aff_mul);
1858 }
1859
1860 static __isl_give isl_pw_aff *pw_aff_min(__isl_take isl_pw_aff *pwaff1,
1861         __isl_take isl_pw_aff *pwaff2)
1862 {
1863         isl_set *le;
1864
1865         le = isl_pw_aff_le_set(isl_pw_aff_copy(pwaff1),
1866                                 isl_pw_aff_copy(pwaff2));
1867         return isl_pw_aff_cond(le, pwaff1, pwaff2);
1868 }
1869
1870 __isl_give isl_pw_aff *isl_pw_aff_min(__isl_take isl_pw_aff *pwaff1,
1871         __isl_take isl_pw_aff *pwaff2)
1872 {
1873         return isl_pw_aff_align_params_pw_pw_and(pwaff1, pwaff2, &pw_aff_min);
1874 }
1875
1876 static __isl_give isl_pw_aff *pw_aff_max(__isl_take isl_pw_aff *pwaff1,
1877         __isl_take isl_pw_aff *pwaff2)
1878 {
1879         isl_set *le;
1880
1881         le = isl_pw_aff_ge_set(isl_pw_aff_copy(pwaff1),
1882                                 isl_pw_aff_copy(pwaff2));
1883         return isl_pw_aff_cond(le, pwaff1, pwaff2);
1884 }
1885
1886 __isl_give isl_pw_aff *isl_pw_aff_max(__isl_take isl_pw_aff *pwaff1,
1887         __isl_take isl_pw_aff *pwaff2)
1888 {
1889         return isl_pw_aff_align_params_pw_pw_and(pwaff1, pwaff2, &pw_aff_max);
1890 }
1891
1892 static __isl_give isl_pw_aff *pw_aff_list_reduce(
1893         __isl_take isl_pw_aff_list *list,
1894         __isl_give isl_pw_aff *(*fn)(__isl_take isl_pw_aff *pwaff1,
1895                                         __isl_take isl_pw_aff *pwaff2))
1896 {
1897         int i;
1898         isl_ctx *ctx;
1899         isl_pw_aff *res;
1900
1901         if (!list)
1902                 return NULL;
1903
1904         ctx = isl_pw_aff_list_get_ctx(list);
1905         if (list->n < 1)
1906                 isl_die(ctx, isl_error_invalid,
1907                         "list should contain at least one element",
1908                         return isl_pw_aff_list_free(list));
1909
1910         res = isl_pw_aff_copy(list->p[0]);
1911         for (i = 1; i < list->n; ++i)
1912                 res = fn(res, isl_pw_aff_copy(list->p[i]));
1913
1914         isl_pw_aff_list_free(list);
1915         return res;
1916 }
1917
1918 /* Return an isl_pw_aff that maps each element in the intersection of the
1919  * domains of the elements of list to the minimal corresponding affine
1920  * expression.
1921  */
1922 __isl_give isl_pw_aff *isl_pw_aff_list_min(__isl_take isl_pw_aff_list *list)
1923 {
1924         return pw_aff_list_reduce(list, &isl_pw_aff_min);
1925 }
1926
1927 /* Return an isl_pw_aff that maps each element in the intersection of the
1928  * domains of the elements of list to the maximal corresponding affine
1929  * expression.
1930  */
1931 __isl_give isl_pw_aff *isl_pw_aff_list_max(__isl_take isl_pw_aff_list *list)
1932 {
1933         return pw_aff_list_reduce(list, &isl_pw_aff_max);
1934 }
1935
1936 #undef BASE
1937 #define BASE aff
1938
1939 #include <isl_multi_templ.c>
1940
1941 __isl_give isl_multi_aff *isl_multi_aff_add(__isl_take isl_multi_aff *maff1,
1942         __isl_take isl_multi_aff *maff2)
1943 {
1944         int i;
1945         isl_ctx *ctx;
1946
1947         maff1 = isl_multi_aff_cow(maff1);
1948         if (!maff1 || !maff2)
1949                 goto error;
1950
1951         ctx = isl_multi_aff_get_ctx(maff1);
1952         if (!isl_space_is_equal(maff1->space, maff2->space))
1953                 isl_die(ctx, isl_error_invalid,
1954                         "spaces don't match", goto error);
1955
1956         for (i = 0; i < maff1->n; ++i) {
1957                 maff1->p[i] = isl_aff_add(maff1->p[i],
1958                                             isl_aff_copy(maff2->p[i]));
1959                 if (!maff1->p[i])
1960                         goto error;
1961         }
1962
1963         isl_multi_aff_free(maff2);
1964         return maff1;
1965 error:
1966         isl_multi_aff_free(maff1);
1967         isl_multi_aff_free(maff2);
1968         return NULL;
1969 }
1970
1971 __isl_give isl_multi_aff *isl_multi_aff_scale(__isl_take isl_multi_aff *maff,
1972         isl_int f)
1973 {
1974         int i;
1975
1976         maff = isl_multi_aff_cow(maff);
1977         if (!maff)
1978                 return NULL;
1979
1980         for (i = 0; i < maff->n; ++i) {
1981                 maff->p[i] = isl_aff_scale(maff->p[i], f);
1982                 if (!maff->p[i])
1983                         return isl_multi_aff_free(maff);
1984         }
1985
1986         return maff;
1987 }
1988
1989 __isl_give isl_multi_aff *isl_multi_aff_add_on_domain(__isl_keep isl_set *dom,
1990         __isl_take isl_multi_aff *maff1, __isl_take isl_multi_aff *maff2)
1991 {
1992         maff1 = isl_multi_aff_add(maff1, maff2);
1993         maff1 = isl_multi_aff_gist(maff1, isl_set_copy(dom));
1994         return maff1;
1995 }
1996
1997 int isl_multi_aff_is_empty(__isl_keep isl_multi_aff *maff)
1998 {
1999         if (!maff)
2000                 return -1;
2001
2002         return 0;
2003 }
2004
2005 int isl_multi_aff_plain_is_equal(__isl_keep isl_multi_aff *maff1,
2006         __isl_keep isl_multi_aff *maff2)
2007 {
2008         int i;
2009         int equal;
2010
2011         if (!maff1 || !maff2)
2012                 return -1;
2013         if (maff1->n != maff2->n)
2014                 return 0;
2015         equal = isl_space_is_equal(maff1->space, maff2->space);
2016         if (equal < 0 || !equal)
2017                 return equal;
2018
2019         for (i = 0; i < maff1->n; ++i) {
2020                 equal = isl_aff_plain_is_equal(maff1->p[i], maff2->p[i]);
2021                 if (equal < 0 || !equal)
2022                         return equal;
2023         }
2024
2025         return 1;
2026 }
2027
2028 __isl_give isl_multi_aff *isl_multi_aff_set_dim_name(
2029         __isl_take isl_multi_aff *maff,
2030         enum isl_dim_type type, unsigned pos, const char *s)
2031 {
2032         int i;
2033
2034         maff = isl_multi_aff_cow(maff);
2035         if (!maff)
2036                 return NULL;
2037
2038         maff->space = isl_space_set_dim_name(maff->space, type, pos, s);
2039         if (!maff->space)
2040                 return isl_multi_aff_free(maff);
2041         for (i = 0; i < maff->n; ++i) {
2042                 maff->p[i] = isl_aff_set_dim_name(maff->p[i], type, pos, s);
2043                 if (!maff->p[i])
2044                         return isl_multi_aff_free(maff);
2045         }
2046
2047         return maff;
2048 }
2049
2050 __isl_give isl_multi_aff *isl_multi_aff_drop_dims(__isl_take isl_multi_aff *maff,
2051         enum isl_dim_type type, unsigned first, unsigned n)
2052 {
2053         int i;
2054
2055         maff = isl_multi_aff_cow(maff);
2056         if (!maff)
2057                 return NULL;
2058
2059         maff->space = isl_space_drop_dims(maff->space, type, first, n);
2060         if (!maff->space)
2061                 return isl_multi_aff_free(maff);
2062         for (i = 0; i < maff->n; ++i) {
2063                 maff->p[i] = isl_aff_drop_dims(maff->p[i], type, first, n);
2064                 if (!maff->p[i])
2065                         return isl_multi_aff_free(maff);
2066         }
2067
2068         return maff;
2069 }