isl_map.c

   1 /*
   2  * Copyright 2008-2009 Katholieke Universiteit Leuven
   3  * Copyright 2010      INRIA Saclay
   4  *
   5  * Use of this software is governed by the GNU LGPLv2.1 license
   6  *
   7  * Written by Sven Verdoolaege, K.U.Leuven, Departement
   8  * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
   9  * and INRIA Saclay - Ile-de-France, Parc Club Orsay Universite,
  10  * ZAC des vignes, 4 rue Jacques Monod, 91893 Orsay, France
  11  */
  12
  13 #include <string.h>
  14 #include <strings.h>
  15 #include "isl_ctx.h"
  16 #include "isl_blk.h"
  17 #include "isl_dim.h"
  18 #include "isl_equalities.h"
  19 #include "isl_list.h"
  20 #include "isl_lp.h"
  21 #include "isl_seq.h"
  22 #include "isl_set.h"
  23 #include "isl_map.h"
  24 #include "isl_map_private.h"
  25 #include "isl_map_piplib.h"
  26 #include "isl_sample.h"
  27 #include "isl_tab.h"
  28 #include "isl_vec.h"
  29
  30 /* Maps dst positions to src positions */
  31 struct isl_dim_map {
  32         unsigned len;
  33         int pos[1];
  34 };
  35
  36 static struct isl_dim_map *isl_dim_map_alloc(struct isl_ctx *ctx, unsigned len)
  37 {
  38         int i;
  39         struct isl_dim_map *dim_map;
  40         dim_map = isl_alloc(ctx, struct isl_dim_map,
  41                                 sizeof(struct isl_dim_map) + len * sizeof(int));
  42         if (!dim_map)
  43                 return NULL;
  44         dim_map->len = 1 + len;
  45         dim_map->pos[0] = 0;
  46         for (i = 0; i < len; ++i)
  47                 dim_map->pos[1 + i] = -1;
  48         return dim_map;
  49 }
  50
  51 static unsigned n(struct isl_dim *dim, enum isl_dim_type type)
  52 {
  53         switch (type) {
  54         case isl_dim_param:     return dim->nparam;
  55         case isl_dim_in:        return dim->n_in;
  56         case isl_dim_out:       return dim->n_out;
  57         case isl_dim_all:       return dim->nparam + dim->n_in + dim->n_out;
  58         }
  59 }
  60
  61 static unsigned pos(struct isl_dim *dim, enum isl_dim_type type)
  62 {
  63         switch (type) {
  64         case isl_dim_param:     return 1;
  65         case isl_dim_in:        return 1 + dim->nparam;
  66         case isl_dim_out:       return 1 + dim->nparam + dim->n_in;
  67         }
  68 }
  69
  70 static void isl_dim_map_dim_range(struct isl_dim_map *dim_map,
  71         struct isl_dim *dim, enum isl_dim_type type,
  72         unsigned first, unsigned n, unsigned dst_pos)
  73 {
  74         int i;
  75         unsigned src_pos;
  76
  77         if (!dim_map || !dim)
  78                 return;
  79
  80         src_pos = pos(dim, type);
  81         for (i = 0; i < n; ++i)
  82                 dim_map->pos[1 + dst_pos + i] = src_pos + first + i;
  83 }
  84
  85 static void isl_dim_map_dim(struct isl_dim_map *dim_map, struct isl_dim *dim,
  86                 enum isl_dim_type type, unsigned dst_pos)
  87 {
  88         isl_dim_map_dim_range(dim_map, dim, type, 0, n(dim, type), dst_pos);
  89 }
  90
  91 static void isl_dim_map_div(struct isl_dim_map *dim_map,
  92                 struct isl_basic_map *bmap, unsigned dst_pos)
  93 {
  94         int i;
  95         unsigned src_pos;
  96
  97         if (!dim_map || !bmap)
  98                 return;
  99
 100         src_pos = 1 + isl_dim_total(bmap->dim);
 101         for (i = 0; i < bmap->n_div; ++i)
 102                 dim_map->pos[1 + dst_pos + i] = src_pos + i;
 103 }
 104
 105 static void isl_dim_map_dump(struct isl_dim_map *dim_map)
 106 {
 107         int i;
 108
 109         for (i = 0; i < dim_map->len; ++i)
 110                 fprintf(stderr, "%d -> %d; ", i, dim_map->pos[i]);
 111         fprintf(stderr, "\n");
 112 }
 113
 114 unsigned isl_basic_map_dim(const struct isl_basic_map *bmap,
 115                                 enum isl_dim_type type)
 116 {
 117         switch (type) {
 118         case isl_dim_param:
 119         case isl_dim_in:
 120         case isl_dim_out:       return isl_dim_size(bmap->dim, type);
 121         case isl_dim_div:       return bmap->n_div;
 122         case isl_dim_all:       return isl_basic_map_total_dim(bmap);
 123         }
 124 }
 125
 126 unsigned isl_map_dim(const struct isl_map *map, enum isl_dim_type type)
 127 {
 128         return map ? n(map->dim, type) : 0;
 129 }
 130
 131 unsigned isl_set_dim(const struct isl_set *set, enum isl_dim_type type)
 132 {
 133         return set ? n(set->dim, type) : 0;
 134 }
 135
 136 unsigned isl_basic_map_offset(struct isl_basic_map *bmap,
 137                                         enum isl_dim_type type)
 138 {
 139         struct isl_dim *dim = bmap->dim;
 140         switch (type) {
 141         case isl_dim_param:     return 1;
 142         case isl_dim_in:        return 1 + dim->nparam;
 143         case isl_dim_out:       return 1 + dim->nparam + dim->n_in;
 144         case isl_dim_div:       return 1 + dim->nparam + dim->n_in + dim->n_out;
 145         }
 146 }
 147
 148 static unsigned map_offset(struct isl_map *map, enum isl_dim_type type)
 149 {
 150         return pos(map->dim, type);
 151 }
 152
 153 unsigned isl_basic_set_dim(const struct isl_basic_set *bset,
 154                                 enum isl_dim_type type)
 155 {
 156         return isl_basic_map_dim((const struct isl_basic_map*)bset, type);
 157 }
 158
 159 unsigned isl_basic_set_n_dim(const struct isl_basic_set *bset)
 160 {
 161         return bset->dim->n_out;
 162 }
 163
 164 unsigned isl_basic_set_n_param(const struct isl_basic_set *bset)
 165 {
 166         return bset->dim->nparam;
 167 }
 168
 169 unsigned isl_basic_set_total_dim(const struct isl_basic_set *bset)
 170 {
 171         return isl_dim_total(bset->dim) + bset->n_div;
 172 }
 173
 174 unsigned isl_set_n_dim(const struct isl_set *set)
 175 {
 176         return set->dim->n_out;
 177 }
 178
 179 unsigned isl_set_n_param(const struct isl_set *set)
 180 {
 181         return set->dim->nparam;
 182 }
 183
 184 unsigned isl_basic_map_n_in(const struct isl_basic_map *bmap)
 185 {
 186         return bmap->dim->n_in;
 187 }
 188
 189 unsigned isl_basic_map_n_out(const struct isl_basic_map *bmap)
 190 {
 191         return bmap->dim->n_out;
 192 }
 193
 194 unsigned isl_basic_map_n_param(const struct isl_basic_map *bmap)
 195 {
 196         return bmap->dim->nparam;
 197 }
 198
 199 unsigned isl_basic_map_n_div(const struct isl_basic_map *bmap)
 200 {
 201         return bmap->n_div;
 202 }
 203
 204 unsigned isl_basic_map_total_dim(const struct isl_basic_map *bmap)
 205 {
 206         return isl_dim_total(bmap->dim) + bmap->n_div;
 207 }
 208
 209 unsigned isl_map_n_in(const struct isl_map *map)
 210 {
 211         return map->dim->n_in;
 212 }
 213
 214 unsigned isl_map_n_out(const struct isl_map *map)
 215 {
 216         return map->dim->n_out;
 217 }
 218
 219 unsigned isl_map_n_param(const struct isl_map *map)
 220 {
 221         return map->dim->nparam;
 222 }
 223
 224 int isl_map_compatible_domain(struct isl_map *map, struct isl_set *set)
 225 {
 226         return map->dim->n_in == set->dim->n_out &&
 227                map->dim->nparam == set->dim->nparam;
 228 }
 229
 230 int isl_basic_map_compatible_domain(struct isl_basic_map *bmap,
 231                 struct isl_basic_set *bset)
 232 {
 233         return bmap->dim->n_in == bset->dim->n_out &&
 234                bmap->dim->nparam == bset->dim->nparam;
 235 }
 236
 237 int isl_basic_map_compatible_range(struct isl_basic_map *bmap,
 238                 struct isl_basic_set *bset)
 239 {
 240         return bmap->dim->n_out == bset->dim->n_out &&
 241                bmap->dim->nparam == bset->dim->nparam;
 242 }
 243
 244 struct isl_dim *isl_basic_map_get_dim(struct isl_basic_map *bmap)
 245 {
 246         if (!bmap)
 247                 return NULL;
 248         return isl_dim_copy(bmap->dim);
 249 }
 250
 251 struct isl_dim *isl_basic_set_get_dim(struct isl_basic_set *bset)
 252 {
 253         if (!bset)
 254                 return NULL;
 255         return isl_dim_copy(bset->dim);
 256 }
 257
 258 struct isl_dim *isl_map_get_dim(struct isl_map *map)
 259 {
 260         if (!map)
 261                 return NULL;
 262         return isl_dim_copy(map->dim);
 263 }
 264
 265 struct isl_dim *isl_set_get_dim(struct isl_set *set)
 266 {
 267         if (!set)
 268                 return NULL;
 269         return isl_dim_copy(set->dim);
 270 }
 271
 272 static struct isl_basic_map *basic_map_init(struct isl_ctx *ctx,
 273                 struct isl_basic_map *bmap, unsigned extra,
 274                 unsigned n_eq, unsigned n_ineq)
 275 {
 276         int i;
 277         size_t row_size = 1 + isl_dim_total(bmap->dim) + extra;
 278
 279         bmap->block = isl_blk_alloc(ctx, (n_ineq + n_eq) * row_size);
 280         if (isl_blk_is_error(bmap->block)) {
 281                 free(bmap);
 282                 return NULL;
 283         }
 284
 285         bmap->ineq = isl_alloc_array(ctx, isl_int *, n_ineq + n_eq);
 286         if (!bmap->ineq) {
 287                 isl_blk_free(ctx, bmap->block);
 288                 free(bmap);
 289                 return NULL;
 290         }
 291
 292         if (extra == 0) {
 293                 bmap->block2 = isl_blk_empty();
 294                 bmap->div = NULL;
 295         } else {
 296                 bmap->block2 = isl_blk_alloc(ctx, extra * (1 + row_size));
 297                 if (isl_blk_is_error(bmap->block2)) {
 298                         free(bmap->ineq);
 299                         isl_blk_free(ctx, bmap->block);
 300                         free(bmap);
 301                         return NULL;
 302                 }
 303
 304                 bmap->div = isl_alloc_array(ctx, isl_int *, extra);
 305                 if (!bmap->div) {
 306                         isl_blk_free(ctx, bmap->block2);
 307                         free(bmap->ineq);
 308                         isl_blk_free(ctx, bmap->block);
 309                         free(bmap);
 310                         return NULL;
 311                 }
 312         }
 313
 314         for (i = 0; i < n_ineq + n_eq; ++i)
 315                 bmap->ineq[i] = bmap->block.data + i * row_size;
 316
 317         for (i = 0; i < extra; ++i)
 318                 bmap->div[i] = bmap->block2.data + i * (1 + row_size);
 319
 320         bmap->ctx = ctx;
 321         isl_ctx_ref(ctx);
 322         bmap->ref = 1;
 323         bmap->flags = 0;
 324         bmap->c_size = n_eq + n_ineq;
 325         bmap->eq = bmap->ineq + n_ineq;
 326         bmap->extra = extra;
 327         bmap->n_eq = 0;
 328         bmap->n_ineq = 0;
 329         bmap->n_div = 0;
 330         bmap->sample = NULL;
 331
 332         return bmap;
 333 error:
 334         isl_basic_map_free(bmap);
 335         return NULL;
 336 }
 337
 338 struct isl_basic_set *isl_basic_set_alloc(struct isl_ctx *ctx,
 339                 unsigned nparam, unsigned dim, unsigned extra,
 340                 unsigned n_eq, unsigned n_ineq)
 341 {
 342         struct isl_basic_map *bmap;
 343         bmap = isl_basic_map_alloc(ctx, nparam, 0, dim, extra, n_eq, n_ineq);
 344         return (struct isl_basic_set *)bmap;
 345 }
 346
 347 struct isl_basic_set *isl_basic_set_alloc_dim(struct isl_dim *dim,
 348                 unsigned extra, unsigned n_eq, unsigned n_ineq)
 349 {
 350         struct isl_basic_map *bmap;
 351         if (!dim)
 352                 return NULL;
 353         isl_assert(dim->ctx, dim->n_in == 0, return NULL);
 354         bmap = isl_basic_map_alloc_dim(dim, extra, n_eq, n_ineq);
 355         return (struct isl_basic_set *)bmap;
 356 }
 357
 358 struct isl_basic_map *isl_basic_map_alloc_dim(struct isl_dim *dim,
 359                 unsigned extra, unsigned n_eq, unsigned n_ineq)
 360 {
 361         struct isl_basic_map *bmap;
 362
 363         if (!dim)
 364                 return NULL;
 365         bmap = isl_alloc_type(dim->ctx, struct isl_basic_map);
 366         if (!bmap)
 367                 goto error;
 368         bmap->dim = dim;
 369
 370         return basic_map_init(dim->ctx, bmap, extra, n_eq, n_ineq);
 371 error:
 372         isl_dim_free(dim);
 373         return NULL;
 374 }
 375
 376 struct isl_basic_map *isl_basic_map_alloc(struct isl_ctx *ctx,
 377                 unsigned nparam, unsigned in, unsigned out, unsigned extra,
 378                 unsigned n_eq, unsigned n_ineq)
 379 {
 380         struct isl_basic_map *bmap;
 381         struct isl_dim *dim;
 382
 383         dim = isl_dim_alloc(ctx, nparam, in, out);
 384         if (!dim)
 385                 return NULL;
 386
 387         bmap = isl_basic_map_alloc_dim(dim, extra, n_eq, n_ineq);
 388         return bmap;
 389 }
 390
 391 static void dup_constraints(
 392                 struct isl_basic_map *dst, struct isl_basic_map *src)
 393 {
 394         int i;
 395         unsigned total = isl_basic_map_total_dim(src);
 396
 397         for (i = 0; i < src->n_eq; ++i) {
 398                 int j = isl_basic_map_alloc_equality(dst);
 399                 isl_seq_cpy(dst->eq[j], src->eq[i], 1+total);
 400         }
 401
 402         for (i = 0; i < src->n_ineq; ++i) {
 403                 int j = isl_basic_map_alloc_inequality(dst);
 404                 isl_seq_cpy(dst->ineq[j], src->ineq[i], 1+total);
 405         }
 406
 407         for (i = 0; i < src->n_div; ++i) {
 408                 int j = isl_basic_map_alloc_div(dst);
 409                 isl_seq_cpy(dst->div[j], src->div[i], 1+1+total);
 410         }
 411         ISL_F_SET(dst, ISL_BASIC_SET_FINAL);
 412 }
 413
 414 struct isl_basic_map *isl_basic_map_dup(struct isl_basic_map *bmap)
 415 {
 416         struct isl_basic_map *dup;
 417
 418         if (!bmap)
 419                 return NULL;
 420         dup = isl_basic_map_alloc_dim(isl_dim_copy(bmap->dim),
 421                         bmap->n_div, bmap->n_eq, bmap->n_ineq);
 422         if (!dup)
 423                 return NULL;
 424         dup_constraints(dup, bmap);
 425         dup->flags = bmap->flags;
 426         dup->sample = isl_vec_copy(bmap->sample);
 427         return dup;
 428 }
 429
 430 struct isl_basic_set *isl_basic_set_dup(struct isl_basic_set *bset)
 431 {
 432         struct isl_basic_map *dup;
 433
 434         dup = isl_basic_map_dup((struct isl_basic_map *)bset);
 435         return (struct isl_basic_set *)dup;
 436 }
 437
 438 struct isl_basic_set *isl_basic_set_copy(struct isl_basic_set *bset)
 439 {
 440         if (!bset)
 441                 return NULL;
 442
 443         if (ISL_F_ISSET(bset, ISL_BASIC_SET_FINAL)) {
 444                 bset->ref++;
 445                 return bset;
 446         }
 447         return isl_basic_set_dup(bset);
 448 }
 449
 450 struct isl_set *isl_set_copy(struct isl_set *set)
 451 {
 452         if (!set)
 453                 return NULL;
 454
 455         set->ref++;
 456         return set;
 457 }
 458
 459 struct isl_basic_map *isl_basic_map_copy(struct isl_basic_map *bmap)
 460 {
 461         if (!bmap)
 462                 return NULL;
 463
 464         if (ISL_F_ISSET(bmap, ISL_BASIC_SET_FINAL)) {
 465                 bmap->ref++;
 466                 return bmap;
 467         }
 468         return isl_basic_map_dup(bmap);
 469 }
 470
 471 struct isl_map *isl_map_copy(struct isl_map *map)
 472 {
 473         if (!map)
 474                 return NULL;
 475
 476         map->ref++;
 477         return map;
 478 }
 479
 480 void isl_basic_map_free(struct isl_basic_map *bmap)
 481 {
 482         if (!bmap)
 483                 return;
 484
 485         if (--bmap->ref > 0)
 486                 return;
 487
 488         isl_ctx_deref(bmap->ctx);
 489         free(bmap->div);
 490         isl_blk_free(bmap->ctx, bmap->block2);
 491         free(bmap->ineq);
 492         isl_blk_free(bmap->ctx, bmap->block);
 493         isl_vec_free(bmap->sample);
 494         isl_dim_free(bmap->dim);
 495         free(bmap);
 496 }
 497
 498 void isl_basic_set_free(struct isl_basic_set *bset)
 499 {
 500         isl_basic_map_free((struct isl_basic_map *)bset);
 501 }
 502
 503 static int room_for_con(struct isl_basic_map *bmap, unsigned n)
 504 {
 505         return bmap->n_eq + bmap->n_ineq + n <= bmap->c_size;
 506 }
 507
 508 int isl_basic_map_alloc_equality(struct isl_basic_map *bmap)
 509 {
 510         struct isl_ctx *ctx;
 511         if (!bmap)
 512                 return -1;
 513         ctx = bmap->ctx;
 514         isl_assert(ctx, room_for_con(bmap, 1), return -1);
 515         isl_assert(ctx, (bmap->eq - bmap->ineq) + bmap->n_eq <= bmap->c_size,
 516                         return -1);
 517         ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
 518         ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT);
 519         ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_IMPLICIT);
 520         ISL_F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES);
 521         ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
 522         if ((bmap->eq - bmap->ineq) + bmap->n_eq == bmap->c_size) {
 523                 isl_int *t;
 524                 int j = isl_basic_map_alloc_inequality(bmap);
 525                 if (j < 0)
 526                         return -1;
 527                 t = bmap->ineq[j];
 528                 bmap->ineq[j] = bmap->ineq[bmap->n_ineq - 1];
 529                 bmap->ineq[bmap->n_ineq - 1] = bmap->eq[-1];
 530                 bmap->eq[-1] = t;
 531                 bmap->n_eq++;
 532                 bmap->n_ineq--;
 533                 bmap->eq--;
 534                 return 0;
 535         }
 536         isl_seq_clr(bmap->eq[bmap->n_eq] + 1 + isl_basic_map_total_dim(bmap),
 537                       bmap->extra - bmap->n_div);
 538         return bmap->n_eq++;
 539 }
 540
 541 int isl_basic_set_alloc_equality(struct isl_basic_set *bset)
 542 {
 543         return isl_basic_map_alloc_equality((struct isl_basic_map *)bset);
 544 }
 545
 546 int isl_basic_map_free_equality(struct isl_basic_map *bmap, unsigned n)
 547 {
 548         if (!bmap)
 549                 return -1;
 550         isl_assert(bmap->ctx, n <= bmap->n_eq, return -1);
 551         bmap->n_eq -= n;
 552         return 0;
 553 }
 554
 555 int isl_basic_set_free_equality(struct isl_basic_set *bset, unsigned n)
 556 {
 557         return isl_basic_map_free_equality((struct isl_basic_map *)bset, n);
 558 }
 559
 560 int isl_basic_map_drop_equality(struct isl_basic_map *bmap, unsigned pos)
 561 {
 562         isl_int *t;
 563         if (!bmap)
 564                 return -1;
 565         isl_assert(bmap->ctx, pos < bmap->n_eq, return -1);
 566
 567         if (pos != bmap->n_eq - 1) {
 568                 t = bmap->eq[pos];
 569                 bmap->eq[pos] = bmap->eq[bmap->n_eq - 1];
 570                 bmap->eq[bmap->n_eq - 1] = t;
 571         }
 572         bmap->n_eq--;
 573         return 0;
 574 }
 575
 576 int isl_basic_set_drop_equality(struct isl_basic_set *bset, unsigned pos)
 577 {
 578         return isl_basic_map_drop_equality((struct isl_basic_map *)bset, pos);
 579 }
 580
 581 void isl_basic_map_inequality_to_equality(
 582                 struct isl_basic_map *bmap, unsigned pos)
 583 {
 584         isl_int *t;
 585
 586         t = bmap->ineq[pos];
 587         bmap->ineq[pos] = bmap->ineq[bmap->n_ineq - 1];
 588         bmap->ineq[bmap->n_ineq - 1] = bmap->eq[-1];
 589         bmap->eq[-1] = t;
 590         bmap->n_eq++;
 591         bmap->n_ineq--;
 592         bmap->eq--;
 593         ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT);
 594         ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
 595         ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
 596         ISL_F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES);
 597 }
 598
 599 static int room_for_ineq(struct isl_basic_map *bmap, unsigned n)
 600 {
 601         return bmap->n_ineq + n <= bmap->eq - bmap->ineq;
 602 }
 603
 604 int isl_basic_map_alloc_inequality(struct isl_basic_map *bmap)
 605 {
 606         struct isl_ctx *ctx;
 607         if (!bmap)
 608                 return -1;
 609         ctx = bmap->ctx;
 610         isl_assert(ctx, room_for_ineq(bmap, 1), return -1);
 611         ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_IMPLICIT);
 612         ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT);
 613         ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
 614         ISL_F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES);
 615         isl_seq_clr(bmap->ineq[bmap->n_ineq] +
 616                       1 + isl_basic_map_total_dim(bmap),
 617                       bmap->extra - bmap->n_div);
 618         return bmap->n_ineq++;
 619 }
 620
 621 int isl_basic_set_alloc_inequality(struct isl_basic_set *bset)
 622 {
 623         return isl_basic_map_alloc_inequality((struct isl_basic_map *)bset);
 624 }
 625
 626 int isl_basic_map_free_inequality(struct isl_basic_map *bmap, unsigned n)
 627 {
 628         if (!bmap)
 629                 return -1;
 630         isl_assert(bmap->ctx, n <= bmap->n_ineq, return -1);
 631         bmap->n_ineq -= n;
 632         return 0;
 633 }
 634
 635 int isl_basic_set_free_inequality(struct isl_basic_set *bset, unsigned n)
 636 {
 637         return isl_basic_map_free_inequality((struct isl_basic_map *)bset, n);
 638 }
 639
 640 int isl_basic_map_drop_inequality(struct isl_basic_map *bmap, unsigned pos)
 641 {
 642         isl_int *t;
 643         if (!bmap)
 644                 return -1;
 645         isl_assert(bmap->ctx, pos < bmap->n_ineq, return -1);
 646
 647         if (pos != bmap->n_ineq - 1) {
 648                 t = bmap->ineq[pos];
 649                 bmap->ineq[pos] = bmap->ineq[bmap->n_ineq - 1];
 650                 bmap->ineq[bmap->n_ineq - 1] = t;
 651                 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
 652         }
 653         bmap->n_ineq--;
 654         return 0;
 655 }
 656
 657 int isl_basic_set_drop_inequality(struct isl_basic_set *bset, unsigned pos)
 658 {
 659         return isl_basic_map_drop_inequality((struct isl_basic_map *)bset, pos);
 660 }
 661
 662 __isl_give isl_basic_map *isl_basic_map_add_eq(__isl_take isl_basic_map *bmap,
 663         isl_int *eq)
 664 {
 665         int k;
 666
 667         bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
 668         if (!bmap)
 669                 return NULL;
 670         k = isl_basic_map_alloc_equality(bmap);
 671         if (k < 0)
 672                 goto error;
 673         isl_seq_cpy(bmap->eq[k], eq, 1 + isl_basic_map_total_dim(bmap));
 674         return bmap;
 675 error:
 676         isl_basic_map_free(bmap);
 677         return NULL;
 678 }
 679
 680 __isl_give isl_basic_set *isl_basic_set_add_eq(__isl_take isl_basic_set *bset,
 681         isl_int *eq)
 682 {
 683         return (isl_basic_set *)
 684                 isl_basic_map_add_eq((isl_basic_map *)bset, eq);
 685 }
 686
 687 __isl_give isl_basic_map *isl_basic_map_add_ineq(__isl_take isl_basic_map *bmap,
 688         isl_int *ineq)
 689 {
 690         int k;
 691
 692         bmap = isl_basic_map_extend_constraints(bmap, 0, 1);
 693         if (!bmap)
 694                 return NULL;
 695         k = isl_basic_map_alloc_inequality(bmap);
 696         if (k < 0)
 697                 goto error;
 698         isl_seq_cpy(bmap->ineq[k], ineq, 1 + isl_basic_map_total_dim(bmap));
 699         return bmap;
 700 error:
 701         isl_basic_map_free(bmap);
 702         return NULL;
 703 }
 704
 705 __isl_give isl_basic_set *isl_basic_set_add_ineq(__isl_take isl_basic_set *bset,
 706         isl_int *ineq)
 707 {
 708         return (isl_basic_set *)
 709                 isl_basic_map_add_ineq((isl_basic_map *)bset, ineq);
 710 }
 711
 712 int isl_basic_map_alloc_div(struct isl_basic_map *bmap)
 713 {
 714         if (!bmap)
 715                 return -1;
 716         isl_assert(bmap->ctx, bmap->n_div < bmap->extra, return -1);
 717         isl_seq_clr(bmap->div[bmap->n_div] +
 718                       1 + 1 + isl_basic_map_total_dim(bmap),
 719                       bmap->extra - bmap->n_div);
 720         ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
 721         return bmap->n_div++;
 722 }
 723
 724 int isl_basic_set_alloc_div(struct isl_basic_set *bset)
 725 {
 726         return isl_basic_map_alloc_div((struct isl_basic_map *)bset);
 727 }
 728
 729 int isl_basic_map_free_div(struct isl_basic_map *bmap, unsigned n)
 730 {
 731         if (!bmap)
 732                 return -1;
 733         isl_assert(bmap->ctx, n <= bmap->n_div, return -1);
 734         bmap->n_div -= n;
 735         return 0;
 736 }
 737
 738 int isl_basic_set_free_div(struct isl_basic_set *bset, unsigned n)
 739 {
 740         return isl_basic_map_free_div((struct isl_basic_map *)bset, n);
 741 }
 742
 743 /* Copy constraint from src to dst, putting the vars of src at offset
 744  * dim_off in dst and the divs of src at offset div_off in dst.
 745  * If both sets are actually map, then dim_off applies to the input
 746  * variables.
 747  */
 748 static void copy_constraint(struct isl_basic_map *dst_map, isl_int *dst,
 749                             struct isl_basic_map *src_map, isl_int *src,
 750                             unsigned in_off, unsigned out_off, unsigned div_off)
 751 {
 752         unsigned src_nparam = isl_basic_map_n_param(src_map);
 753         unsigned dst_nparam = isl_basic_map_n_param(dst_map);
 754         unsigned src_in = isl_basic_map_n_in(src_map);
 755         unsigned dst_in = isl_basic_map_n_in(dst_map);
 756         unsigned src_out = isl_basic_map_n_out(src_map);
 757         unsigned dst_out = isl_basic_map_n_out(dst_map);
 758         isl_int_set(dst[0], src[0]);
 759         isl_seq_cpy(dst+1, src+1, isl_min(dst_nparam, src_nparam));
 760         if (dst_nparam > src_nparam)
 761                 isl_seq_clr(dst+1+src_nparam,
 762                                 dst_nparam - src_nparam);
 763         isl_seq_clr(dst+1+dst_nparam, in_off);
 764         isl_seq_cpy(dst+1+dst_nparam+in_off,
 765                     src+1+src_nparam,
 766                     isl_min(dst_in-in_off, src_in));
 767         if (dst_in-in_off > src_in)
 768                 isl_seq_clr(dst+1+dst_nparam+in_off+src_in,
 769                                 dst_in - in_off - src_in);
 770         isl_seq_clr(dst+1+dst_nparam+dst_in, out_off);
 771         isl_seq_cpy(dst+1+dst_nparam+dst_in+out_off,
 772                     src+1+src_nparam+src_in,
 773                     isl_min(dst_out-out_off, src_out));
 774         if (dst_out-out_off > src_out)
 775                 isl_seq_clr(dst+1+dst_nparam+dst_in+out_off+src_out,
 776                                 dst_out - out_off - src_out);
 777         isl_seq_clr(dst+1+dst_nparam+dst_in+dst_out, div_off);
 778         isl_seq_cpy(dst+1+dst_nparam+dst_in+dst_out+div_off,
 779                     src+1+src_nparam+src_in+src_out,
 780                     isl_min(dst_map->extra-div_off, src_map->n_div));
 781         if (dst_map->n_div-div_off > src_map->n_div)
 782                 isl_seq_clr(dst+1+dst_nparam+dst_in+dst_out+
 783                                 div_off+src_map->n_div,
 784                                 dst_map->n_div - div_off - src_map->n_div);
 785 }
 786
 787 static void copy_div(struct isl_basic_map *dst_map, isl_int *dst,
 788                      struct isl_basic_map *src_map, isl_int *src,
 789                      unsigned in_off, unsigned out_off, unsigned div_off)
 790 {
 791         isl_int_set(dst[0], src[0]);
 792         copy_constraint(dst_map, dst+1, src_map, src+1, in_off, out_off, div_off);
 793 }
 794
 795 static struct isl_basic_map *add_constraints(struct isl_basic_map *bmap1,
 796                 struct isl_basic_map *bmap2, unsigned i_pos, unsigned o_pos)
 797 {
 798         int i;
 799         unsigned div_off;
 800
 801         if (!bmap1 || !bmap2)
 802                 goto error;
 803
 804         div_off = bmap1->n_div;
 805
 806         for (i = 0; i < bmap2->n_eq; ++i) {
 807                 int i1 = isl_basic_map_alloc_equality(bmap1);
 808                 if (i1 < 0)
 809                         goto error;
 810                 copy_constraint(bmap1, bmap1->eq[i1], bmap2, bmap2->eq[i],
 811                                 i_pos, o_pos, div_off);
 812         }
 813
 814         for (i = 0; i < bmap2->n_ineq; ++i) {
 815                 int i1 = isl_basic_map_alloc_inequality(bmap1);
 816                 if (i1 < 0)
 817                         goto error;
 818                 copy_constraint(bmap1, bmap1->ineq[i1], bmap2, bmap2->ineq[i],
 819                                 i_pos, o_pos, div_off);
 820         }
 821
 822         for (i = 0; i < bmap2->n_div; ++i) {
 823                 int i1 = isl_basic_map_alloc_div(bmap1);
 824                 if (i1 < 0)
 825                         goto error;
 826                 copy_div(bmap1, bmap1->div[i1], bmap2, bmap2->div[i],
 827                          i_pos, o_pos, div_off);
 828         }
 829
 830         isl_basic_map_free(bmap2);
 831
 832         return bmap1;
 833
 834 error:
 835         isl_basic_map_free(bmap1);
 836         isl_basic_map_free(bmap2);
 837         return NULL;
 838 }
 839
 840 static void copy_constraint_dim_map(isl_int *dst, isl_int *src,
 841                                         struct isl_dim_map *dim_map)
 842 {
 843         int i;
 844
 845         for (i = 0; i < dim_map->len; ++i) {
 846                 if (dim_map->pos[i] < 0)
 847                         isl_int_set_si(dst[i], 0);
 848                 else
 849                         isl_int_set(dst[i], src[dim_map->pos[i]]);
 850         }
 851 }
 852
 853 static void copy_div_dim_map(isl_int *dst, isl_int *src,
 854                                         struct isl_dim_map *dim_map)
 855 {
 856         isl_int_set(dst[0], src[0]);
 857         copy_constraint_dim_map(dst+1, src+1, dim_map);
 858 }
 859
 860 static struct isl_basic_map *add_constraints_dim_map(struct isl_basic_map *dst,
 861                 struct isl_basic_map *src, struct isl_dim_map *dim_map)
 862 {
 863         int i;
 864
 865         if (!src || !dst || !dim_map)
 866                 goto error;
 867
 868         for (i = 0; i < src->n_eq; ++i) {
 869                 int i1 = isl_basic_map_alloc_equality(dst);
 870                 if (i1 < 0)
 871                         goto error;
 872                 copy_constraint_dim_map(dst->eq[i1], src->eq[i], dim_map);
 873         }
 874
 875         for (i = 0; i < src->n_ineq; ++i) {
 876                 int i1 = isl_basic_map_alloc_inequality(dst);
 877                 if (i1 < 0)
 878                         goto error;
 879                 copy_constraint_dim_map(dst->ineq[i1], src->ineq[i], dim_map);
 880         }
 881
 882         for (i = 0; i < src->n_div; ++i) {
 883                 int i1 = isl_basic_map_alloc_div(dst);
 884                 if (i1 < 0)
 885                         goto error;
 886                 copy_div_dim_map(dst->div[i1], src->div[i], dim_map);
 887         }
 888
 889         free(dim_map);
 890         isl_basic_map_free(src);
 891
 892         return dst;
 893 error:
 894         free(dim_map);
 895         isl_basic_map_free(src);
 896         isl_basic_map_free(dst);
 897         return NULL;
 898 }
 899
 900 struct isl_basic_set *isl_basic_set_add_constraints(struct isl_basic_set *bset1,
 901                 struct isl_basic_set *bset2, unsigned pos)
 902 {
 903         return (struct isl_basic_set *)
 904                 add_constraints((struct isl_basic_map *)bset1,
 905                                 (struct isl_basic_map *)bset2, 0, pos);
 906 }
 907
 908 struct isl_basic_map *isl_basic_map_extend_dim(struct isl_basic_map *base,
 909                 struct isl_dim *dim, unsigned extra,
 910                 unsigned n_eq, unsigned n_ineq)
 911 {
 912         struct isl_basic_map *ext;
 913         unsigned flags;
 914         int dims_ok;
 915
 916         if (!dim)
 917                 goto error;
 918
 919         if (!base)
 920                 goto error;
 921
 922         dims_ok = isl_dim_equal(base->dim, dim) &&
 923                   base->extra >= base->n_div + extra;
 924
 925         if (dims_ok && room_for_con(base, n_eq + n_ineq) &&
 926                        room_for_ineq(base, n_ineq)) {
 927                 isl_dim_free(dim);
 928                 return base;
 929         }
 930
 931         isl_assert(base->ctx, base->dim->nparam <= dim->nparam, goto error);
 932         isl_assert(base->ctx, base->dim->n_in <= dim->n_in, goto error);
 933         isl_assert(base->ctx, base->dim->n_out <= dim->n_out, goto error);
 934         extra += base->extra;
 935         n_eq += base->n_eq;
 936         n_ineq += base->n_ineq;
 937
 938         ext = isl_basic_map_alloc_dim(dim, extra, n_eq, n_ineq);
 939         dim = NULL;
 940         if (!ext)
 941                 goto error;
 942
 943         if (dims_ok)
 944                 ext->sample = isl_vec_copy(base->sample);
 945         flags = base->flags;
 946         ext = add_constraints(ext, base, 0, 0);
 947         if (ext) {
 948                 ext->flags = flags;
 949                 ISL_F_CLR(ext, ISL_BASIC_SET_FINAL);
 950         }
 951
 952         return ext;
 953
 954 error:
 955         isl_dim_free(dim);
 956         isl_basic_map_free(base);
 957         return NULL;
 958 }
 959
 960 struct isl_basic_set *isl_basic_set_extend_dim(struct isl_basic_set *base,
 961                 struct isl_dim *dim, unsigned extra,
 962                 unsigned n_eq, unsigned n_ineq)
 963 {
 964         return (struct isl_basic_set *)
 965                 isl_basic_map_extend_dim((struct isl_basic_map *)base, dim,
 966                                                         extra, n_eq, n_ineq);
 967 }
 968
 969 struct isl_basic_map *isl_basic_map_extend_constraints(
 970                 struct isl_basic_map *base, unsigned n_eq, unsigned n_ineq)
 971 {
 972         if (!base)
 973                 return NULL;
 974         return isl_basic_map_extend_dim(base, isl_dim_copy(base->dim),
 975                                         0, n_eq, n_ineq);
 976 }
 977
 978 struct isl_basic_map *isl_basic_map_extend(struct isl_basic_map *base,
 979                 unsigned nparam, unsigned n_in, unsigned n_out, unsigned extra,
 980                 unsigned n_eq, unsigned n_ineq)
 981 {
 982         struct isl_basic_map *bmap;
 983         struct isl_dim *dim;
 984
 985         if (!base)
 986                 return NULL;
 987         dim = isl_dim_alloc(base->ctx, nparam, n_in, n_out);
 988         if (!dim)
 989                 return NULL;
 990
 991         bmap = isl_basic_map_extend_dim(base, dim, extra, n_eq, n_ineq);
 992         return bmap;
 993 }
 994
 995 struct isl_basic_set *isl_basic_set_extend(struct isl_basic_set *base,
 996                 unsigned nparam, unsigned dim, unsigned extra,
 997                 unsigned n_eq, unsigned n_ineq)
 998 {
 999         return (struct isl_basic_set *)
1000                 isl_basic_map_extend((struct isl_basic_map *)base,
1001                                         nparam, 0, dim, extra, n_eq, n_ineq);
1002 }
1003
1004 struct isl_basic_set *isl_basic_set_extend_constraints(
1005                 struct isl_basic_set *base, unsigned n_eq, unsigned n_ineq)
1006 {
1007         return (struct isl_basic_set *)
1008                 isl_basic_map_extend_constraints((struct isl_basic_map *)base,
1009                                                     n_eq, n_ineq);
1010 }
1011
1012 struct isl_basic_set *isl_basic_set_cow(struct isl_basic_set *bset)
1013 {
1014         return (struct isl_basic_set *)
1015                 isl_basic_map_cow((struct isl_basic_map *)bset);
1016 }
1017
1018 struct isl_basic_map *isl_basic_map_cow(struct isl_basic_map *bmap)
1019 {
1020         if (!bmap)
1021                 return NULL;
1022
1023         if (bmap->ref > 1) {
1024                 bmap->ref--;
1025                 bmap = isl_basic_map_dup(bmap);
1026         }
1027         ISL_F_CLR(bmap, ISL_BASIC_SET_FINAL);
1028         return bmap;
1029 }
1030
1031 struct isl_set *isl_set_cow(struct isl_set *set)
1032 {
1033         if (!set)
1034                 return NULL;
1035
1036         if (set->ref == 1)
1037                 return set;
1038         set->ref--;
1039         return isl_set_dup(set);
1040 }
1041
1042 struct isl_map *isl_map_cow(struct isl_map *map)
1043 {
1044         if (!map)
1045                 return NULL;
1046
1047         if (map->ref == 1)
1048                 return map;
1049         map->ref--;
1050         return isl_map_dup(map);
1051 }
1052
1053 static void swap_vars(struct isl_blk blk, isl_int *a,
1054                         unsigned a_len, unsigned b_len)
1055 {
1056         isl_seq_cpy(blk.data, a+a_len, b_len);
1057         isl_seq_cpy(blk.data+b_len, a, a_len);
1058         isl_seq_cpy(a, blk.data, b_len+a_len);
1059 }
1060
1061 struct isl_basic_set *isl_basic_set_swap_vars(
1062                 struct isl_basic_set *bset, unsigned n)
1063 {
1064         int i;
1065         struct isl_blk blk;
1066         unsigned dim;
1067         unsigned nparam;
1068
1069         if (!bset)
1070                 goto error;
1071
1072         nparam = isl_basic_set_n_param(bset);
1073         dim = isl_basic_set_n_dim(bset);
1074         isl_assert(bset->ctx, n <= dim, goto error);
1075
1076         if (n == dim)
1077                 return bset;
1078
1079         bset = isl_basic_set_cow(bset);
1080         if (!bset)
1081                 return NULL;
1082
1083         blk = isl_blk_alloc(bset->ctx, dim);
1084         if (isl_blk_is_error(blk))
1085                 goto error;
1086
1087         for (i = 0; i < bset->n_eq; ++i)
1088                 swap_vars(blk,
1089                           bset->eq[i]+1+nparam, n, dim - n);
1090
1091         for (i = 0; i < bset->n_ineq; ++i)
1092                 swap_vars(blk,
1093                           bset->ineq[i]+1+nparam, n, dim - n);
1094
1095         for (i = 0; i < bset->n_div; ++i)
1096                 swap_vars(blk,
1097                           bset->div[i]+1+1+nparam, n, dim - n);
1098
1099         isl_blk_free(bset->ctx, blk);
1100
1101         ISL_F_CLR(bset, ISL_BASIC_SET_NORMALIZED);
1102         return isl_basic_set_gauss(bset, NULL);
1103 error:
1104         isl_basic_set_free(bset);
1105         return NULL;
1106 }
1107
1108 struct isl_set *isl_set_swap_vars(struct isl_set *set, unsigned n)
1109 {
1110         int i;
1111         set = isl_set_cow(set);
1112         if (!set)
1113                 return NULL;
1114
1115         for (i = 0; i < set->n; ++i) {
1116                 set->p[i] = isl_basic_set_swap_vars(set->p[i], n);
1117                 if (!set->p[i]) {
1118                         isl_set_free(set);
1119                         return NULL;
1120                 }
1121         }
1122         ISL_F_CLR(set, ISL_SET_NORMALIZED);
1123         return set;
1124 }
1125
1126 struct isl_basic_map *isl_basic_map_set_to_empty(struct isl_basic_map *bmap)
1127 {
1128         int i = 0;
1129         unsigned total;
1130         if (!bmap)
1131                 goto error;
1132         total = isl_basic_map_total_dim(bmap);
1133         isl_basic_map_free_div(bmap, bmap->n_div);
1134         isl_basic_map_free_inequality(bmap, bmap->n_ineq);
1135         if (bmap->n_eq > 0)
1136                 isl_basic_map_free_equality(bmap, bmap->n_eq-1);
1137         else {
1138                 i = isl_basic_map_alloc_equality(bmap);
1139                 if (i < 0)
1140                         goto error;
1141         }
1142         isl_int_set_si(bmap->eq[i][0], 1);
1143         isl_seq_clr(bmap->eq[i]+1, total);
1144         ISL_F_SET(bmap, ISL_BASIC_MAP_EMPTY);
1145         isl_vec_free(bmap->sample);
1146         bmap->sample = NULL;
1147         return isl_basic_map_finalize(bmap);
1148 error:
1149         isl_basic_map_free(bmap);
1150         return NULL;
1151 }
1152
1153 struct isl_basic_set *isl_basic_set_set_to_empty(struct isl_basic_set *bset)
1154 {
1155         return (struct isl_basic_set *)
1156                 isl_basic_map_set_to_empty((struct isl_basic_map *)bset);
1157 }
1158
1159 void isl_basic_map_swap_div(struct isl_basic_map *bmap, int a, int b)
1160 {
1161         int i;
1162         unsigned off = isl_dim_total(bmap->dim);
1163         isl_int *t = bmap->div[a];
1164         bmap->div[a] = bmap->div[b];
1165         bmap->div[b] = t;
1166
1167         for (i = 0; i < bmap->n_eq; ++i)
1168                 isl_int_swap(bmap->eq[i][1+off+a], bmap->eq[i][1+off+b]);
1169
1170         for (i = 0; i < bmap->n_ineq; ++i)
1171                 isl_int_swap(bmap->ineq[i][1+off+a], bmap->ineq[i][1+off+b]);
1172
1173         for (i = 0; i < bmap->n_div; ++i)
1174                 isl_int_swap(bmap->div[i][1+1+off+a], bmap->div[i][1+1+off+b]);
1175         ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
1176 }
1177
1178 /* Eliminate the specified n dimensions starting at first from the
1179  * constraints using Fourier-Motzkin.  The dimensions themselves
1180  * are not removed.
1181  */
1182 __isl_give isl_map *isl_map_eliminate(__isl_take isl_map *map,
1183         enum isl_dim_type type, unsigned first, unsigned n)
1184 {
1185         int i;
1186
1187         if (!map)
1188                 return NULL;
1189         if (n == 0)
1190                 return map;
1191
1192         map = isl_map_cow(map);
1193         if (!map)
1194                 return NULL;
1195         isl_assert(map->ctx, first + n <= isl_map_dim(map, type), goto error);
1196         first += pos(map->dim, type) - 1;
1197
1198         for (i = 0; i < map->n; ++i) {
1199                 map->p[i] = isl_basic_map_eliminate_vars(map->p[i], first, n);
1200                 if (!map->p[i])
1201                         goto error;
1202         }
1203         return map;
1204 error:
1205         isl_map_free(map);
1206         return NULL;
1207 }
1208
1209 /* Eliminate the specified n dimensions starting at first from the
1210  * constraints using Fourier-Motzkin.  The dimensions themselves
1211  * are not removed.
1212  */
1213 __isl_give isl_set *isl_set_eliminate(__isl_take isl_set *set,
1214         enum isl_dim_type type, unsigned first, unsigned n)
1215 {
1216         return (isl_set *)isl_map_eliminate((isl_map *)set, type, first, n);
1217 }
1218
1219 /* Eliminate the specified n dimensions starting at first from the
1220  * constraints using Fourier-Motzkin.  The dimensions themselves
1221  * are not removed.
1222  */
1223 __isl_give isl_set *isl_set_eliminate_dims(__isl_take isl_set *set,
1224         unsigned first, unsigned n)
1225 {
1226         return isl_set_eliminate(set, isl_dim_set, first, n);
1227 }
1228
1229 /* Project out n dimensions starting at first using Fourier-Motzkin */
1230 struct isl_set *isl_set_remove_dims(struct isl_set *set,
1231         unsigned first, unsigned n)
1232 {
1233         set = isl_set_eliminate_dims(set, first, n);
1234         set = isl_set_drop_dims(set, first, n);
1235         return set;
1236 }
1237
1238 struct isl_basic_set *isl_basic_set_remove_divs(struct isl_basic_set *bset)
1239 {
1240         bset = isl_basic_set_eliminate_vars(bset, isl_dim_total(bset->dim),
1241                                                 bset->n_div);
1242         if (!bset)
1243                 return NULL;
1244         bset->n_div = 0;
1245         return bset;
1246 }
1247
1248 struct isl_set *isl_set_remove_divs(struct isl_set *set)
1249 {
1250         int i;
1251
1252         if (!set)
1253                 return NULL;
1254         if (set->n == 0)
1255                 return set;
1256
1257         set = isl_set_cow(set);
1258         if (!set)
1259                 return NULL;
1260
1261         for (i = 0; i < set->n; ++i) {
1262                 set->p[i] = isl_basic_set_remove_divs(set->p[i]);
1263                 if (!set->p[i])
1264                         goto error;
1265         }
1266         return set;
1267 error:
1268         isl_set_free(set);
1269         return NULL;
1270 }
1271
1272 struct isl_basic_map *isl_basic_map_remove(struct isl_basic_map *bmap,
1273         enum isl_dim_type type, unsigned first, unsigned n)
1274 {
1275         if (!bmap)
1276                 return NULL;
1277         isl_assert(bmap->ctx, first + n <= isl_basic_map_dim(bmap, type),
1278                         goto error);
1279         if (n == 0)
1280                 return bmap;
1281         bmap = isl_basic_map_eliminate_vars(bmap,
1282                         isl_basic_map_offset(bmap, type) - 1 + first, n);
1283         if (!bmap)
1284                 return bmap;
1285         if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY) && type == isl_dim_div)
1286                 return bmap;
1287         bmap = isl_basic_map_drop(bmap, type, first, n);
1288         return bmap;
1289 error:
1290         isl_basic_map_free(bmap);
1291         return NULL;
1292 }
1293
1294 __isl_give isl_basic_set *isl_basic_set_remove(__isl_take isl_basic_set *bset,
1295         enum isl_dim_type type, unsigned first, unsigned n)
1296 {
1297         return (isl_basic_set *)
1298                 isl_basic_map_remove((isl_basic_map *)bset, type, first, n);
1299 }
1300
1301 struct isl_map *isl_map_remove(struct isl_map *map,
1302         enum isl_dim_type type, unsigned first, unsigned n)
1303 {
1304         int i;
1305
1306         if (n == 0)
1307                 return map;
1308
1309         map = isl_map_cow(map);
1310         if (!map)
1311                 return NULL;
1312         isl_assert(map->ctx, first + n <= isl_map_dim(map, type), goto error);
1313
1314         for (i = 0; i < map->n; ++i) {
1315                 map->p[i] = isl_basic_map_eliminate_vars(map->p[i],
1316                         isl_basic_map_offset(map->p[i], type) - 1 + first, n);
1317                 if (!map->p[i])
1318                         goto error;
1319         }
1320         map = isl_map_drop(map, type, first, n);
1321         return map;
1322 error:
1323         isl_map_free(map);
1324         return NULL;
1325 }
1326
1327 __isl_give isl_set *isl_set_remove(__isl_take isl_set *bset,
1328         enum isl_dim_type type, unsigned first, unsigned n)
1329 {
1330         return (isl_set *)isl_map_remove((isl_map *)bset, type, first, n);
1331 }
1332
1333 /* Project out n inputs starting at first using Fourier-Motzkin */
1334 struct isl_map *isl_map_remove_inputs(struct isl_map *map,
1335         unsigned first, unsigned n)
1336 {
1337         return isl_map_remove(map, isl_dim_in, first, n);
1338 }
1339
1340 /* Project out n dimensions starting at first using Fourier-Motzkin */
1341 struct isl_basic_set *isl_basic_set_remove_dims(struct isl_basic_set *bset,
1342         unsigned first, unsigned n)
1343 {
1344         unsigned nparam = isl_basic_set_n_param(bset);
1345         bset = isl_basic_set_eliminate_vars(bset, nparam + first, n);
1346         bset = isl_basic_set_drop_dims(bset, first, n);
1347         return bset;
1348 }
1349
1350 static void dump_term(struct isl_basic_map *bmap,
1351                         isl_int c, int pos, FILE *out)
1352 {
1353         const char *name;
1354         unsigned in = isl_basic_map_n_in(bmap);
1355         unsigned dim = in + isl_basic_map_n_out(bmap);
1356         unsigned nparam = isl_basic_map_n_param(bmap);
1357         if (!pos)
1358                 isl_int_print(out, c, 0);
1359         else {
1360                 if (!isl_int_is_one(c))
1361                         isl_int_print(out, c, 0);
1362                 if (pos < 1 + nparam) {
1363                         name = isl_dim_get_name(bmap->dim,
1364                                                 isl_dim_param, pos - 1);
1365                         if (name)
1366                                 fprintf(out, "%s", name);
1367                         else
1368                                 fprintf(out, "p%d", pos - 1);
1369                 } else if (pos < 1 + nparam + in)
1370                         fprintf(out, "i%d", pos - 1 - nparam);
1371                 else if (pos < 1 + nparam + dim)
1372                         fprintf(out, "o%d", pos - 1 - nparam - in);
1373                 else
1374                         fprintf(out, "e%d", pos - 1 - nparam - dim);
1375         }
1376 }
1377
1378 static void dump_constraint_sign(struct isl_basic_map *bmap, isl_int *c,
1379                                 int sign, FILE *out)
1380 {
1381         int i;
1382         int first;
1383         unsigned len = 1 + isl_basic_map_total_dim(bmap);
1384         isl_int v;
1385
1386         isl_int_init(v);
1387         for (i = 0, first = 1; i < len; ++i) {
1388                 if (isl_int_sgn(c[i]) * sign <= 0)
1389                         continue;
1390                 if (!first)
1391                         fprintf(out, " + ");
1392                 first = 0;
1393                 isl_int_abs(v, c[i]);
1394                 dump_term(bmap, v, i, out);
1395         }
1396         isl_int_clear(v);
1397         if (first)
1398                 fprintf(out, "0");
1399 }
1400
1401 static void dump_constraint(struct isl_basic_map *bmap, isl_int *c,
1402                                 const char *op, FILE *out, int indent)
1403 {
1404         int i;
1405
1406         fprintf(out, "%*s", indent, "");
1407
1408         dump_constraint_sign(bmap, c, 1, out);
1409         fprintf(out, " %s ", op);
1410         dump_constraint_sign(bmap, c, -1, out);
1411
1412         fprintf(out, "\n");
1413
1414         for (i = bmap->n_div; i < bmap->extra; ++i) {
1415                 if (isl_int_is_zero(c[1+isl_dim_total(bmap->dim)+i]))
1416                         continue;
1417                 fprintf(out, "%*s", indent, "");
1418                 fprintf(out, "ERROR: unused div coefficient not zero\n");
1419                 abort();
1420         }
1421 }
1422
1423 static void dump_constraints(struct isl_basic_map *bmap,
1424                                 isl_int **c, unsigned n,
1425                                 const char *op, FILE *out, int indent)
1426 {
1427         int i;
1428
1429         for (i = 0; i < n; ++i)
1430                 dump_constraint(bmap, c[i], op, out, indent);
1431 }
1432
1433 static void dump_affine(struct isl_basic_map *bmap, isl_int *exp, FILE *out)
1434 {
1435         int j;
1436         int first = 1;
1437         unsigned total = isl_basic_map_total_dim(bmap);
1438
1439         for (j = 0; j < 1 + total; ++j) {
1440                 if (isl_int_is_zero(exp[j]))
1441                         continue;
1442                 if (!first && isl_int_is_pos(exp[j]))
1443                         fprintf(out, "+");
1444                 dump_term(bmap, exp[j], j, out);
1445                 first = 0;
1446         }
1447 }
1448
1449 static void dump(struct isl_basic_map *bmap, FILE *out, int indent)
1450 {
1451         int i;
1452
1453         dump_constraints(bmap, bmap->eq, bmap->n_eq, "=", out, indent);
1454         dump_constraints(bmap, bmap->ineq, bmap->n_ineq, ">=", out, indent);
1455
1456         for (i = 0; i < bmap->n_div; ++i) {
1457                 fprintf(out, "%*s", indent, "");
1458                 fprintf(out, "e%d = [(", i);
1459                 dump_affine(bmap, bmap->div[i]+1, out);
1460                 fprintf(out, ")/");
1461                 isl_int_print(out, bmap->div[i][0], 0);
1462                 fprintf(out, "]\n");
1463         }
1464 }
1465
1466 void isl_basic_set_dump(struct isl_basic_set *bset, FILE *out, int indent)
1467 {
1468         if (!bset) {
1469                 fprintf(out, "null basic set\n");
1470                 return;
1471         }
1472
1473         fprintf(out, "%*s", indent, "");
1474         fprintf(out, "ref: %d, nparam: %d, dim: %d, extra: %d, flags: %x\n",
1475                         bset->ref, bset->dim->nparam, bset->dim->n_out,
1476                         bset->extra, bset->flags);
1477         dump((struct isl_basic_map *)bset, out, indent);
1478 }
1479
1480 void isl_basic_map_dump(struct isl_basic_map *bmap, FILE *out, int indent)
1481 {
1482         if (!bmap) {
1483                 fprintf(out, "null basic map\n");
1484                 return;
1485         }
1486
1487         fprintf(out, "%*s", indent, "");
1488         fprintf(out, "ref: %d, nparam: %d, in: %d, out: %d, extra: %d, "
1489                         "flags: %x, n_name: %d\n",
1490                 bmap->ref,
1491                 bmap->dim->nparam, bmap->dim->n_in, bmap->dim->n_out,
1492                 bmap->extra, bmap->flags, bmap->dim->n_name);
1493         dump(bmap, out, indent);
1494 }
1495
1496 int isl_inequality_negate(struct isl_basic_map *bmap, unsigned pos)
1497 {
1498         unsigned total;
1499         if (!bmap)
1500                 return -1;
1501         total = isl_basic_map_total_dim(bmap);
1502         isl_assert(bmap->ctx, pos < bmap->n_ineq, return -1);
1503         isl_seq_neg(bmap->ineq[pos], bmap->ineq[pos], 1 + total);
1504         isl_int_sub_ui(bmap->ineq[pos][0], bmap->ineq[pos][0], 1);
1505         ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
1506         return 0;
1507 }
1508
1509 struct isl_set *isl_set_alloc_dim(struct isl_dim *dim, int n, unsigned flags)
1510 {
1511         struct isl_set *set;
1512
1513         if (!dim)
1514                 return NULL;
1515         isl_assert(dim->ctx, dim->n_in == 0, return NULL);
1516         isl_assert(dim->ctx, n >= 0, return NULL);
1517         set = isl_alloc(dim->ctx, struct isl_set,
1518                         sizeof(struct isl_set) +
1519                         (n - 1) * sizeof(struct isl_basic_set *));
1520         if (!set)
1521                 goto error;
1522
1523         set->ctx = dim->ctx;
1524         isl_ctx_ref(set->ctx);
1525         set->ref = 1;
1526         set->size = n;
1527         set->n = 0;
1528         set->dim = dim;
1529         set->flags = flags;
1530         return set;
1531 error:
1532         isl_dim_free(dim);
1533         return NULL;
1534 }
1535
1536 struct isl_set *isl_set_alloc(struct isl_ctx *ctx,
1537                 unsigned nparam, unsigned dim, int n, unsigned flags)
1538 {
1539         struct isl_set *set;
1540         struct isl_dim *dims;
1541
1542         dims = isl_dim_alloc(ctx, nparam, 0, dim);
1543         if (!dims)
1544                 return NULL;
1545
1546         set = isl_set_alloc_dim(dims, n, flags);
1547         return set;
1548 }
1549
1550 /* Make sure "map" has room for at least "n" more basic maps.
1551  */
1552 struct isl_map *isl_map_grow(struct isl_map *map, int n)
1553 {
1554         int i;
1555         struct isl_map *grown = NULL;
1556
1557         if (!map)
1558                 return NULL;
1559         isl_assert(map->ctx, n >= 0, goto error);
1560         if (map->n + n <= map->size)
1561                 return map;
1562         grown = isl_map_alloc_dim(isl_map_get_dim(map), map->n + n, map->flags);
1563         if (!grown)
1564                 goto error;
1565         for (i = 0; i < map->n; ++i) {
1566                 grown->p[i] = isl_basic_map_copy(map->p[i]);
1567                 if (!grown->p[i])
1568                         goto error;
1569                 grown->n++;
1570         }
1571         isl_map_free(map);
1572         return grown;
1573 error:
1574         isl_map_free(grown);
1575         isl_map_free(map);
1576         return NULL;
1577 }
1578
1579 /* Make sure "set" has room for at least "n" more basic sets.
1580  */
1581 struct isl_set *isl_set_grow(struct isl_set *set, int n)
1582 {
1583         return (struct isl_set *)isl_map_grow((struct isl_map *)set, n);
1584 }
1585
1586 struct isl_set *isl_set_dup(struct isl_set *set)
1587 {
1588         int i;
1589         struct isl_set *dup;
1590
1591         if (!set)
1592                 return NULL;
1593
1594         dup = isl_set_alloc_dim(isl_dim_copy(set->dim), set->n, set->flags);
1595         if (!dup)
1596                 return NULL;
1597         for (i = 0; i < set->n; ++i)
1598                 dup = isl_set_add_basic_set(dup, isl_basic_set_copy(set->p[i]));
1599         return dup;
1600 }
1601
1602 struct isl_set *isl_set_from_basic_set(struct isl_basic_set *bset)
1603 {
1604         struct isl_set *set;
1605
1606         if (!bset)
1607                 return NULL;
1608
1609         set = isl_set_alloc_dim(isl_dim_copy(bset->dim), 1, ISL_MAP_DISJOINT);
1610         if (!set) {
1611                 isl_basic_set_free(bset);
1612                 return NULL;
1613         }
1614         return isl_set_add_basic_set(set, bset);
1615 }
1616
1617 struct isl_map *isl_map_from_basic_map(struct isl_basic_map *bmap)
1618 {
1619         struct isl_map *map;
1620
1621         if (!bmap)
1622                 return NULL;
1623
1624         map = isl_map_alloc_dim(isl_dim_copy(bmap->dim), 1, ISL_MAP_DISJOINT);
1625         if (!map) {
1626                 isl_basic_map_free(bmap);
1627                 return NULL;
1628         }
1629         return isl_map_add_basic_map(map, bmap);
1630 }
1631
1632 __isl_give isl_set *isl_set_add_basic_set(__isl_take isl_set *set,
1633                                                 __isl_take isl_basic_set *bset)
1634 {
1635         return (struct isl_set *)isl_map_add_basic_map((struct isl_map *)set,
1636                                                 (struct isl_basic_map *)bset);
1637 }
1638
1639 void isl_set_free(struct isl_set *set)
1640 {
1641         int i;
1642
1643         if (!set)
1644                 return;
1645
1646         if (--set->ref > 0)
1647                 return;
1648
1649         isl_ctx_deref(set->ctx);
1650         for (i = 0; i < set->n; ++i)
1651                 isl_basic_set_free(set->p[i]);
1652         isl_dim_free(set->dim);
1653         free(set);
1654 }
1655
1656 void isl_set_dump(struct isl_set *set, FILE *out, int indent)
1657 {
1658         int i;
1659
1660         if (!set) {
1661                 fprintf(out, "null set\n");
1662                 return;
1663         }
1664
1665         fprintf(out, "%*s", indent, "");
1666         fprintf(out, "ref: %d, n: %d, nparam: %d, dim: %d, flags: %x\n",
1667                         set->ref, set->n, set->dim->nparam, set->dim->n_out,
1668                         set->flags);
1669         for (i = 0; i < set->n; ++i) {
1670                 fprintf(out, "%*s", indent, "");
1671                 fprintf(out, "basic set %d:\n", i);
1672                 isl_basic_set_dump(set->p[i], out, indent+4);
1673         }
1674 }
1675
1676 void isl_map_dump(struct isl_map *map, FILE *out, int indent)
1677 {
1678         int i;
1679
1680         if (!map) {
1681                 fprintf(out, "null map\n");
1682                 return;
1683         }
1684
1685         fprintf(out, "%*s", indent, "");
1686         fprintf(out, "ref: %d, n: %d, nparam: %d, in: %d, out: %d, "
1687                      "flags: %x, n_name: %d\n",
1688                         map->ref, map->n, map->dim->nparam, map->dim->n_in,
1689                         map->dim->n_out, map->flags, map->dim->n_name);
1690         for (i = 0; i < map->n; ++i) {
1691                 fprintf(out, "%*s", indent, "");
1692                 fprintf(out, "basic map %d:\n", i);
1693                 isl_basic_map_dump(map->p[i], out, indent+4);
1694         }
1695 }
1696
1697 struct isl_basic_map *isl_basic_map_intersect_domain(
1698                 struct isl_basic_map *bmap, struct isl_basic_set *bset)
1699 {
1700         struct isl_basic_map *bmap_domain;
1701         struct isl_dim *dim;
1702
1703         if (!bmap || !bset)
1704                 goto error;
1705
1706         isl_assert(bset->ctx, isl_dim_match(bmap->dim, isl_dim_param,
1707                                         bset->dim, isl_dim_param), goto error);
1708
1709         if (isl_dim_size(bset->dim, isl_dim_set) != 0)
1710                 isl_assert(bset->ctx,
1711                     isl_basic_map_compatible_domain(bmap, bset), goto error);
1712
1713         bmap = isl_basic_map_cow(bmap);
1714         bmap = isl_basic_map_extend_dim(bmap, isl_dim_copy(bmap->dim),
1715                         bset->n_div, bset->n_eq, bset->n_ineq);
1716         if (!bmap)
1717                 goto error;
1718         dim = isl_dim_reverse(isl_dim_copy(bset->dim));
1719         bmap_domain = isl_basic_map_from_basic_set(bset, dim);
1720         bmap = add_constraints(bmap, bmap_domain, 0, 0);
1721
1722         bmap = isl_basic_map_simplify(bmap);
1723         return isl_basic_map_finalize(bmap);
1724 error:
1725         isl_basic_map_free(bmap);
1726         isl_basic_set_free(bset);
1727         return NULL;
1728 }
1729
1730 struct isl_basic_map *isl_basic_map_intersect_range(
1731                 struct isl_basic_map *bmap, struct isl_basic_set *bset)
1732 {
1733         struct isl_basic_map *bmap_range;
1734
1735         if (!bmap || !bset)
1736                 goto error;
1737
1738         isl_assert(bset->ctx, isl_dim_match(bmap->dim, isl_dim_param,
1739                                         bset->dim, isl_dim_param), goto error);
1740
1741         if (isl_dim_size(bset->dim, isl_dim_set) != 0)
1742                 isl_assert(bset->ctx,
1743                     isl_basic_map_compatible_range(bmap, bset), goto error);
1744
1745         bmap = isl_basic_map_cow(bmap);
1746         bmap = isl_basic_map_extend_dim(bmap, isl_dim_copy(bmap->dim),
1747                         bset->n_div, bset->n_eq, bset->n_ineq);
1748         if (!bmap)
1749                 goto error;
1750         bmap_range = isl_basic_map_from_basic_set(bset, isl_dim_copy(bset->dim));
1751         bmap = add_constraints(bmap, bmap_range, 0, 0);
1752
1753         bmap = isl_basic_map_simplify(bmap);
1754         return isl_basic_map_finalize(bmap);
1755 error:
1756         isl_basic_map_free(bmap);
1757         isl_basic_set_free(bset);
1758         return NULL;
1759 }
1760
1761 int isl_basic_map_contains(struct isl_basic_map *bmap, struct isl_vec *vec)
1762 {
1763         int i;
1764         unsigned total;
1765         isl_int s;
1766
1767         total = 1 + isl_basic_map_total_dim(bmap);
1768         if (total != vec->size)
1769                 return -1;
1770
1771         isl_int_init(s);
1772
1773         for (i = 0; i < bmap->n_eq; ++i) {
1774                 isl_seq_inner_product(vec->el, bmap->eq[i], total, &s);
1775                 if (!isl_int_is_zero(s)) {
1776                         isl_int_clear(s);
1777                         return 0;
1778                 }
1779         }
1780
1781         for (i = 0; i < bmap->n_ineq; ++i) {
1782                 isl_seq_inner_product(vec->el, bmap->ineq[i], total, &s);
1783                 if (isl_int_is_neg(s)) {
1784                         isl_int_clear(s);
1785                         return 0;
1786                 }
1787         }
1788
1789         isl_int_clear(s);
1790
1791         return 1;
1792 }
1793
1794 int isl_basic_set_contains(struct isl_basic_set *bset, struct isl_vec *vec)
1795 {
1796         return isl_basic_map_contains((struct isl_basic_map *)bset, vec);
1797 }
1798
1799 struct isl_basic_map *isl_basic_map_intersect(
1800                 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
1801 {
1802         struct isl_vec *sample = NULL;
1803
1804         if (!bmap1 || !bmap2)
1805                 goto error;
1806
1807         isl_assert(bmap1->ctx, isl_dim_match(bmap1->dim, isl_dim_param,
1808                                      bmap2->dim, isl_dim_param), goto error);
1809         if (isl_dim_total(bmap1->dim) ==
1810                                 isl_dim_size(bmap1->dim, isl_dim_param) &&
1811             isl_dim_total(bmap2->dim) !=
1812                                 isl_dim_size(bmap2->dim, isl_dim_param))
1813                 return isl_basic_map_intersect(bmap2, bmap1);
1814
1815         if (isl_dim_total(bmap2->dim) !=
1816                                         isl_dim_size(bmap2->dim, isl_dim_param))
1817                 isl_assert(bmap1->ctx,
1818                             isl_dim_equal(bmap1->dim, bmap2->dim), goto error);
1819
1820         if (bmap1->sample &&
1821             isl_basic_map_contains(bmap1, bmap1->sample) > 0 &&
1822             isl_basic_map_contains(bmap2, bmap1->sample) > 0)
1823                 sample = isl_vec_copy(bmap1->sample);
1824         else if (bmap2->sample &&
1825             isl_basic_map_contains(bmap1, bmap2->sample) > 0 &&
1826             isl_basic_map_contains(bmap2, bmap2->sample) > 0)
1827                 sample = isl_vec_copy(bmap2->sample);
1828
1829         bmap1 = isl_basic_map_cow(bmap1);
1830         bmap1 = isl_basic_map_extend_dim(bmap1, isl_dim_copy(bmap1->dim),
1831                         bmap2->n_div, bmap2->n_eq, bmap2->n_ineq);
1832         if (!bmap1)
1833                 goto error;
1834         bmap1 = add_constraints(bmap1, bmap2, 0, 0);
1835
1836         if (sample) {
1837                 isl_vec_free(bmap1->sample);
1838                 bmap1->sample = sample;
1839         }
1840
1841         bmap1 = isl_basic_map_simplify(bmap1);
1842         return isl_basic_map_finalize(bmap1);
1843 error:
1844         if (sample)
1845                 isl_vec_free(sample);
1846         isl_basic_map_free(bmap1);
1847         isl_basic_map_free(bmap2);
1848         return NULL;
1849 }
1850
1851 struct isl_basic_set *isl_basic_set_intersect(
1852                 struct isl_basic_set *bset1, struct isl_basic_set *bset2)
1853 {
1854         return (struct isl_basic_set *)
1855                 isl_basic_map_intersect(
1856                         (struct isl_basic_map *)bset1,
1857                         (struct isl_basic_map *)bset2);
1858 }
1859
1860 /* Special case of isl_map_intersect, where both map1 and map2
1861  * are convex, without any divs and such that either map1 or map2
1862  * contains a single constraint.  This constraint is then simply
1863  * added to the other map.
1864  */
1865 static __isl_give isl_map *map_intersect_add_constraint(
1866         __isl_take isl_map *map1, __isl_take isl_map *map2)
1867 {
1868         struct isl_basic_map *bmap1;
1869         struct isl_basic_map *bmap2;
1870
1871         isl_assert(map1->ctx, map1->n == 1, goto error);
1872         isl_assert(map2->ctx, map1->n == 1, goto error);
1873         isl_assert(map1->ctx, map1->p[0]->n_div == 0, goto error);
1874         isl_assert(map2->ctx, map1->p[0]->n_div == 0, goto error);
1875
1876         if (map2->p[0]->n_eq + map2->p[0]->n_ineq != 1)
1877                 return isl_map_intersect(map2, map1);
1878
1879         isl_assert(map2->ctx,
1880                     map2->p[0]->n_eq + map2->p[0]->n_ineq == 1, goto error);
1881
1882         map1 = isl_map_cow(map1);
1883         if (!map1)
1884                 goto error;
1885         if (isl_map_fast_is_empty(map1)) {
1886                 isl_map_free(map2);
1887                 return map1;
1888         }
1889         map1->p[0] = isl_basic_map_cow(map1->p[0]);
1890         if (map2->p[0]->n_eq == 1)
1891                 map1->p[0] = isl_basic_map_add_eq(map1->p[0], map2->p[0]->eq[0]);
1892         else
1893                 map1->p[0] = isl_basic_map_add_ineq(map1->p[0],
1894                                                         map2->p[0]->ineq[0]);
1895
1896         map1->p[0] = isl_basic_map_simplify(map1->p[0]);
1897         map1->p[0] = isl_basic_map_finalize(map1->p[0]);
1898         if (!map1->p[0])
1899                 goto error;
1900
1901         if (isl_basic_map_fast_is_empty(map1->p[0])) {
1902                 isl_basic_map_free(map1->p[0]);
1903                 map1->n = 0;
1904         }
1905
1906         isl_map_free(map2);
1907
1908         return map1;
1909 error:
1910         isl_map_free(map1);
1911         isl_map_free(map2);
1912         return NULL;
1913 }
1914
1915 struct isl_map *isl_map_intersect(struct isl_map *map1, struct isl_map *map2)
1916 {
1917         unsigned flags = 0;
1918         struct isl_map *result;
1919         int i, j;
1920
1921         if (!map1 || !map2)
1922                 goto error;
1923
1924         if (isl_map_fast_is_empty(map1)) {
1925                 isl_map_free(map2);
1926                 return map1;
1927         }
1928         if (isl_map_fast_is_empty(map2)) {
1929                 isl_map_free(map1);
1930                 return map2;
1931         }
1932
1933         if (map1->n == 1 && map2->n == 1 &&
1934             map1->p[0]->n_div == 0 && map2->p[0]->n_div == 0 &&
1935             isl_dim_equal(map1->dim, map2->dim) &&
1936             (map1->p[0]->n_eq + map1->p[0]->n_ineq == 1 ||
1937              map2->p[0]->n_eq + map2->p[0]->n_ineq == 1))
1938                 return map_intersect_add_constraint(map1, map2);
1939         isl_assert(map1->ctx, isl_dim_match(map1->dim, isl_dim_param,
1940                                          map2->dim, isl_dim_param), goto error);
1941         if (isl_dim_total(map1->dim) ==
1942                                 isl_dim_size(map1->dim, isl_dim_param) &&
1943             isl_dim_total(map2->dim) != isl_dim_size(map2->dim, isl_dim_param))
1944                 return isl_map_intersect(map2, map1);
1945
1946         if (isl_dim_total(map2->dim) != isl_dim_size(map2->dim, isl_dim_param))
1947                 isl_assert(map1->ctx,
1948                             isl_dim_equal(map1->dim, map2->dim), goto error);
1949
1950         if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) &&
1951             ISL_F_ISSET(map2, ISL_MAP_DISJOINT))
1952                 ISL_FL_SET(flags, ISL_MAP_DISJOINT);
1953
1954         result = isl_map_alloc_dim(isl_dim_copy(map1->dim),
1955                                 map1->n * map2->n, flags);
1956         if (!result)
1957                 goto error;
1958         for (i = 0; i < map1->n; ++i)
1959                 for (j = 0; j < map2->n; ++j) {
1960                         struct isl_basic_map *part;
1961                         part = isl_basic_map_intersect(
1962                                     isl_basic_map_copy(map1->p[i]),
1963                                     isl_basic_map_copy(map2->p[j]));
1964                         if (isl_basic_map_is_empty(part))
1965                                 isl_basic_map_free(part);
1966                         else
1967                                 result = isl_map_add_basic_map(result, part);
1968                         if (!result)
1969                                 goto error;
1970                 }
1971         isl_map_free(map1);
1972         isl_map_free(map2);
1973         return result;
1974 error:
1975         isl_map_free(map1);
1976         isl_map_free(map2);
1977         return NULL;
1978 }
1979
1980 struct isl_set *isl_set_intersect(struct isl_set *set1, struct isl_set *set2)
1981 {
1982         return (struct isl_set *)
1983                 isl_map_intersect((struct isl_map *)set1,
1984                                   (struct isl_map *)set2);
1985 }
1986
1987 struct isl_basic_map *isl_basic_map_reverse(struct isl_basic_map *bmap)
1988 {
1989         struct isl_dim *dim;
1990         struct isl_basic_set *bset;
1991         unsigned in;
1992
1993         if (!bmap)
1994                 return NULL;
1995         bmap = isl_basic_map_cow(bmap);
1996         if (!bmap)
1997                 return NULL;
1998         dim = isl_dim_reverse(isl_dim_copy(bmap->dim));
1999         in = isl_basic_map_n_in(bmap);
2000         bset = isl_basic_set_from_basic_map(bmap);
2001         bset = isl_basic_set_swap_vars(bset, in);
2002         return isl_basic_map_from_basic_set(bset, dim);
2003 }
2004
2005 __isl_give isl_basic_map *isl_basic_map_insert(__isl_take isl_basic_map *bmap,
2006                 enum isl_dim_type type, unsigned pos, unsigned n)
2007 {
2008         struct isl_dim *res_dim;
2009         struct isl_basic_map *res;
2010         struct isl_dim_map *dim_map;
2011         unsigned total, off;
2012         enum isl_dim_type t;
2013
2014         if (n == 0)
2015                 return bmap;
2016
2017         if (!bmap)
2018                 return NULL;
2019
2020         res_dim = isl_dim_insert(isl_basic_map_get_dim(bmap), type, pos, n);
2021
2022         total = isl_basic_map_total_dim(bmap) + n;
2023         dim_map = isl_dim_map_alloc(bmap->ctx, total);
2024         off = 0;
2025         for (t = isl_dim_param; t <= isl_dim_out; ++t) {
2026                 if (t != type) {
2027                         isl_dim_map_dim(dim_map, bmap->dim, t, off);
2028                 } else {
2029                         unsigned size = isl_basic_map_dim(bmap, t);
2030                         isl_dim_map_dim_range(dim_map, bmap->dim, t,
2031                                                 0, pos, off);
2032                         isl_dim_map_dim_range(dim_map, bmap->dim, t,
2033                                                 pos, size - pos, off + pos + n);
2034                 }
2035                 off += isl_dim_size(res_dim, t);
2036         }
2037         isl_dim_map_div(dim_map, bmap, off);
2038
2039         res = isl_basic_map_alloc_dim(res_dim,
2040                         bmap->n_div, bmap->n_eq, bmap->n_ineq);
2041         res = add_constraints_dim_map(res, bmap, dim_map);
2042         res = isl_basic_map_simplify(res);
2043         return isl_basic_map_finalize(res);
2044 }
2045
2046 __isl_give isl_basic_map *isl_basic_map_add(__isl_take isl_basic_map *bmap,
2047                 enum isl_dim_type type, unsigned n)
2048 {
2049         if (!bmap)
2050                 return NULL;
2051         return isl_basic_map_insert(bmap, type,
2052                                         isl_basic_map_dim(bmap, type), n);
2053 }
2054
2055 __isl_give isl_basic_set *isl_basic_set_add(__isl_take isl_basic_set *bset,
2056                 enum isl_dim_type type, unsigned n)
2057 {
2058         if (!bset)
2059                 return NULL;
2060         isl_assert(bset->ctx, type != isl_dim_in, goto error);
2061         return (isl_basic_set *)isl_basic_map_add((isl_basic_map *)bset, type, n);
2062 error:
2063         isl_basic_set_free(bset);
2064         return NULL;
2065 }
2066
2067 __isl_give isl_map *isl_map_insert(__isl_take isl_map *map,
2068                 enum isl_dim_type type, unsigned pos, unsigned n)
2069 {
2070         int i;
2071
2072         if (n == 0)
2073                 return map;
2074
2075         map = isl_map_cow(map);
2076         if (!map)
2077                 return NULL;
2078
2079         map->dim = isl_dim_insert(map->dim, type, pos, n);
2080         if (!map->dim)
2081                 goto error;
2082
2083         for (i = 0; i < map->n; ++i) {
2084                 map->p[i] = isl_basic_map_insert(map->p[i], type, pos, n);
2085                 if (!map->p[i])
2086                         goto error;
2087         }
2088
2089         return map;
2090 error:
2091         isl_map_free(map);
2092         return NULL;
2093 }
2094
2095 __isl_give isl_map *isl_map_add(__isl_take isl_map *map,
2096                 enum isl_dim_type type, unsigned n)
2097 {
2098         if (!map)
2099                 return NULL;
2100         return isl_map_insert(map, type, isl_map_dim(map, type), n);
2101 }
2102
2103 __isl_give isl_set *isl_set_add(__isl_take isl_set *set,
2104                 enum isl_dim_type type, unsigned n)
2105 {
2106         if (!set)
2107                 return NULL;
2108         isl_assert(set->ctx, type != isl_dim_in, goto error);
2109         return (isl_set *)isl_map_add((isl_map *)set, type, n);
2110 error:
2111         isl_set_free(set);
2112         return NULL;
2113 }
2114
2115 __isl_give isl_basic_map *isl_basic_map_move_dims(
2116         __isl_take isl_basic_map *bmap,
2117         enum isl_dim_type dst_type, unsigned dst_pos,
2118         enum isl_dim_type src_type, unsigned src_pos, unsigned n)
2119 {
2120         int i;
2121         struct isl_dim_map *dim_map;
2122         struct isl_basic_map *res;
2123         enum isl_dim_type t;
2124         unsigned total, off;
2125
2126         if (!bmap)
2127                 return NULL;
2128         if (n == 0)
2129                 return bmap;
2130
2131         isl_assert(bmap->ctx, src_pos + n <= isl_basic_map_dim(bmap, src_type),
2132                 goto error);
2133
2134         if (dst_type == src_type && dst_pos == src_pos)
2135                 return bmap;
2136
2137         isl_assert(bmap->ctx, dst_type != src_type, goto error);
2138
2139         if (pos(bmap->dim, dst_type) + dst_pos ==
2140             pos(bmap->dim, src_type) + src_pos +
2141                                             ((src_type < dst_type) ? n : 0)) {
2142                 bmap = isl_basic_map_cow(bmap);
2143                 if (!bmap)
2144                         return NULL;
2145
2146                 bmap->dim = isl_dim_move(bmap->dim, dst_type, dst_pos,
2147                                                 src_type, src_pos, n);
2148                 if (!bmap->dim)
2149                         goto error;
2150
2151                 return bmap;
2152         }
2153
2154         total = isl_basic_map_total_dim(bmap);
2155         dim_map = isl_dim_map_alloc(bmap->ctx, total);
2156
2157         off = 0;
2158         for (t = isl_dim_param; t <= isl_dim_out; ++t) {
2159                 unsigned size = isl_dim_size(bmap->dim, t);
2160                 if (t == dst_type) {
2161                         isl_dim_map_dim_range(dim_map, bmap->dim, t,
2162                                             0, dst_pos, off);
2163                         off += dst_pos;
2164                         isl_dim_map_dim_range(dim_map, bmap->dim, src_type,
2165                                             src_pos, n, off);
2166                         off += n;
2167                         isl_dim_map_dim_range(dim_map, bmap->dim, t,
2168                                             dst_pos, size - dst_pos, off);
2169                         off += size - dst_pos;
2170                 } else if (t == src_type) {
2171                         isl_dim_map_dim_range(dim_map, bmap->dim, t,
2172                                             0, src_pos, off);
2173                         off += src_pos;
2174                         isl_dim_map_dim_range(dim_map, bmap->dim, t,
2175                                         src_pos + n, size - src_pos - n, off);
2176                         off += size - src_pos - n;
2177                 } else {
2178                         isl_dim_map_dim(dim_map, bmap->dim, t, off);
2179                         off += size;
2180                 }
2181         }
2182         isl_dim_map_div(dim_map, bmap, off + n);
2183
2184         res = isl_basic_map_alloc_dim(isl_basic_map_get_dim(bmap),
2185                         bmap->n_div, bmap->n_eq, bmap->n_ineq);
2186         bmap = add_constraints_dim_map(res, bmap, dim_map);
2187
2188         bmap->dim = isl_dim_move(bmap->dim, dst_type, dst_pos,
2189                                         src_type, src_pos, n);
2190         if (!bmap->dim)
2191                 goto error;
2192
2193         return bmap;
2194 error:
2195         isl_basic_map_free(bmap);
2196         return NULL;
2197 }
2198
2199 __isl_give isl_set *isl_set_move_dims(__isl_take isl_set *set,
2200         enum isl_dim_type dst_type, unsigned dst_pos,
2201         enum isl_dim_type src_type, unsigned src_pos, unsigned n)
2202 {
2203         if (!set)
2204                 return NULL;
2205         isl_assert(set->ctx, dst_type != isl_dim_in, goto error);
2206         return (isl_set *)isl_map_move_dims((isl_map *)set, dst_type, dst_pos,
2207                                         src_type, src_pos, n);
2208 error:
2209         isl_set_free(set);
2210         return NULL;
2211 }
2212
2213 __isl_give isl_map *isl_map_move_dims(__isl_take isl_map *map,
2214         enum isl_dim_type dst_type, unsigned dst_pos,
2215         enum isl_dim_type src_type, unsigned src_pos, unsigned n)
2216 {
2217         int i;
2218
2219         if (!map)
2220                 return NULL;
2221         if (n == 0)
2222                 return map;
2223
2224         isl_assert(map->ctx, src_pos + n <= isl_map_dim(map, src_type),
2225                 goto error);
2226
2227         if (dst_type == src_type && dst_pos == src_pos)
2228                 return map;
2229
2230         isl_assert(map->ctx, dst_type != src_type, goto error);
2231
2232         map = isl_map_cow(map);
2233         if (!map)
2234                 return NULL;
2235
2236         map->dim = isl_dim_move(map->dim, dst_type, dst_pos, src_type, src_pos, n);
2237         if (!map->dim)
2238                 goto error;
2239
2240         for (i = 0; i < map->n; ++i) {
2241                 map->p[i] = isl_basic_map_move_dims(map->p[i],
2242                                                 dst_type, dst_pos,
2243                                                 src_type, src_pos, n);
2244                 if (!map->p[i])
2245                         goto error;
2246         }
2247
2248         return map;
2249 error:
2250         isl_map_free(map);
2251         return NULL;
2252 }
2253
2254 /* Move the specified dimensions to the last columns right before
2255  * the divs.  Don't change the dimension specification of bmap.
2256  * That's the responsibility of the caller.
2257  */
2258 static __isl_give isl_basic_map *move_last(__isl_take isl_basic_map *bmap,
2259         enum isl_dim_type type, unsigned first, unsigned n)
2260 {
2261         struct isl_dim_map *dim_map;
2262         struct isl_basic_map *res;
2263         enum isl_dim_type t;
2264         unsigned total, off;
2265
2266         if (!bmap)
2267                 return NULL;
2268         if (pos(bmap->dim, type) + first + n == 1 + isl_dim_total(bmap->dim))
2269                 return bmap;
2270
2271         total = isl_basic_map_total_dim(bmap);
2272         dim_map = isl_dim_map_alloc(bmap->ctx, total);
2273
2274         off = 0;
2275         for (t = isl_dim_param; t <= isl_dim_out; ++t) {
2276                 unsigned size = isl_dim_size(bmap->dim, t);
2277                 if (t == type) {
2278                         isl_dim_map_dim_range(dim_map, bmap->dim, t,
2279                                             0, first, off);
2280                         off += first;
2281                         isl_dim_map_dim_range(dim_map, bmap->dim, t,
2282                                             first, n, total - bmap->n_div - n);
2283                         isl_dim_map_dim_range(dim_map, bmap->dim, t,
2284                                             first + n, size - (first + n), off);
2285                         off += size - (first + n);
2286                 } else {
2287                         isl_dim_map_dim(dim_map, bmap->dim, t, off);
2288                         off += size;
2289                 }
2290         }
2291         isl_dim_map_div(dim_map, bmap, off + n);
2292
2293         res = isl_basic_map_alloc_dim(isl_basic_map_get_dim(bmap),
2294                         bmap->n_div, bmap->n_eq, bmap->n_ineq);
2295         res = add_constraints_dim_map(res, bmap, dim_map);
2296         return res;
2297 }
2298
2299 /* Turn the n dimensions of type type, starting at first
2300  * into existentially quantified variables.
2301  */
2302 __isl_give isl_basic_map *isl_basic_map_project_out(
2303                 __isl_take isl_basic_map *bmap,
2304                 enum isl_dim_type type, unsigned first, unsigned n)
2305 {
2306         int i;
2307         size_t row_size;
2308         isl_int **new_div;
2309         isl_int *old;
2310
2311         if (n == 0)
2312                 return bmap;
2313
2314         if (!bmap)
2315                 return NULL;
2316
2317         if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
2318                 return isl_basic_map_remove(bmap, type, first, n);
2319
2320         isl_assert(bmap->ctx, first + n <= isl_basic_map_dim(bmap, type),
2321                         goto error);
2322
2323         bmap = move_last(bmap, type, first, n);
2324         bmap = isl_basic_map_cow(bmap);
2325
2326         row_size = 1 + isl_dim_total(bmap->dim) + bmap->extra;
2327         old = bmap->block2.data;
2328         bmap->block2 = isl_blk_extend(bmap->ctx, bmap->block2,
2329                                         (bmap->extra + n) * (1 + row_size));
2330         if (!bmap->block2.data)
2331                 goto error;
2332         new_div = isl_alloc_array(ctx, isl_int *, bmap->extra + n);
2333         if (!new_div)
2334                 goto error;
2335         for (i = 0; i < n; ++i) {
2336                 new_div[i] = bmap->block2.data +
2337                                 (bmap->extra + i) * (1 + row_size);
2338                 isl_seq_clr(new_div[i], 1 + row_size);
2339         }
2340         for (i = 0; i < bmap->extra; ++i)
2341                 new_div[n + i] = bmap->block2.data + (bmap->div[i] - old);
2342         free(bmap->div);
2343         bmap->div = new_div;
2344         bmap->n_div += n;
2345         bmap->extra += n;
2346
2347         bmap->dim = isl_dim_drop(bmap->dim, type, first, n);
2348         if (!bmap->dim)
2349                 goto error;
2350         bmap = isl_basic_map_simplify(bmap);
2351         bmap = isl_basic_map_drop_redundant_divs(bmap);
2352         return isl_basic_map_finalize(bmap);
2353 error:
2354         isl_basic_map_free(bmap);
2355         return NULL;
2356 }
2357
2358 /* Turn the n dimensions of type type, starting at first
2359  * into existentially quantified variables.
2360  */
2361 struct isl_basic_set *isl_basic_set_project_out(struct isl_basic_set *bset,
2362                 enum isl_dim_type type, unsigned first, unsigned n)
2363 {
2364         return (isl_basic_set *)isl_basic_map_project_out(
2365                         (isl_basic_map *)bset, type, first, n);
2366 }
2367
2368 /* Turn the n dimensions of type type, starting at first
2369  * into existentially quantified variables.
2370  */
2371 __isl_give isl_map *isl_map_project_out(__isl_take isl_map *map,
2372                 enum isl_dim_type type, unsigned first, unsigned n)
2373 {
2374         int i;
2375
2376         if (!map)
2377                 return NULL;
2378
2379         if (n == 0)
2380                 return map;
2381
2382         isl_assert(map->ctx, first + n <= isl_map_dim(map, type), goto error);
2383
2384         map = isl_map_cow(map);
2385         if (!map)
2386                 return NULL;
2387
2388         map->dim = isl_dim_drop(map->dim, type, first, n);
2389         if (!map->dim)
2390                 goto error;
2391
2392         for (i = 0; i < map->n; ++i) {
2393                 map->p[i] = isl_basic_map_project_out(map->p[i], type, first, n);
2394                 if (!map->p[i])
2395                         goto error;
2396         }
2397
2398         return map;
2399 error:
2400         isl_map_free(map);
2401         return map;
2402 }
2403
2404 /* Turn the n dimensions of type type, starting at first
2405  * into existentially quantified variables.
2406  */
2407 __isl_give isl_set *isl_set_project_out(__isl_take isl_set *set,
2408                 enum isl_dim_type type, unsigned first, unsigned n)
2409 {
2410         return (isl_set *)isl_map_project_out((isl_map *)set, type, first, n);
2411 }
2412
2413 static struct isl_basic_map *add_divs(struct isl_basic_map *bmap, unsigned n)
2414 {
2415         int i, j;
2416
2417         for (i = 0; i < n; ++i) {
2418                 j = isl_basic_map_alloc_div(bmap);
2419                 if (j < 0)
2420                         goto error;
2421                 isl_seq_clr(bmap->div[j], 1+1+isl_basic_map_total_dim(bmap));
2422         }
2423         return bmap;
2424 error:
2425         isl_basic_map_free(bmap);
2426         return NULL;
2427 }
2428
2429 struct isl_basic_map *isl_basic_map_apply_range(
2430                 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
2431 {
2432         struct isl_dim *dim_result = NULL;
2433         struct isl_basic_map *bmap;
2434         unsigned n_in, n_out, n, nparam, total, pos;
2435         struct isl_dim_map *dim_map1, *dim_map2;
2436
2437         if (!bmap1 || !bmap2)
2438                 goto error;
2439
2440         dim_result = isl_dim_join(isl_dim_copy(bmap1->dim),
2441                                   isl_dim_copy(bmap2->dim));
2442
2443         n_in = isl_basic_map_n_in(bmap1);
2444         n_out = isl_basic_map_n_out(bmap2);
2445         n = isl_basic_map_n_out(bmap1);
2446         nparam = isl_basic_map_n_param(bmap1);
2447
2448         total = nparam + n_in + n_out + bmap1->n_div + bmap2->n_div + n;
2449         dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
2450         dim_map2 = isl_dim_map_alloc(bmap1->ctx, total);
2451         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
2452         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos = 0);
2453         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
2454         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos += n_in);
2455         isl_dim_map_div(dim_map1, bmap1, pos += n_out);
2456         isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
2457         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += bmap2->n_div);
2458         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos);
2459
2460         bmap = isl_basic_map_alloc_dim(dim_result,
2461                         bmap1->n_div + bmap2->n_div + n,
2462                         bmap1->n_eq + bmap2->n_eq,
2463                         bmap1->n_ineq + bmap2->n_ineq);
2464         bmap = add_constraints_dim_map(bmap, bmap1, dim_map1);
2465         bmap = add_constraints_dim_map(bmap, bmap2, dim_map2);
2466         bmap = add_divs(bmap, n);
2467         bmap = isl_basic_map_simplify(bmap);
2468         bmap = isl_basic_map_drop_redundant_divs(bmap);
2469         return isl_basic_map_finalize(bmap);
2470 error:
2471         isl_basic_map_free(bmap1);
2472         isl_basic_map_free(bmap2);
2473         return NULL;
2474 }
2475
2476 struct isl_basic_set *isl_basic_set_apply(
2477                 struct isl_basic_set *bset, struct isl_basic_map *bmap)
2478 {
2479         if (!bset || !bmap)
2480                 goto error;
2481
2482         isl_assert(bset->ctx, isl_basic_map_compatible_domain(bmap, bset),
2483                     goto error);
2484
2485         return (struct isl_basic_set *)
2486                 isl_basic_map_apply_range((struct isl_basic_map *)bset, bmap);
2487 error:
2488         isl_basic_set_free(bset);
2489         isl_basic_map_free(bmap);
2490         return NULL;
2491 }
2492
2493 struct isl_basic_map *isl_basic_map_apply_domain(
2494                 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
2495 {
2496         if (!bmap1 || !bmap2)
2497                 goto error;
2498
2499         isl_assert(bmap1->ctx,
2500             isl_basic_map_n_in(bmap1) == isl_basic_map_n_in(bmap2), goto error);
2501         isl_assert(bmap1->ctx,
2502             isl_basic_map_n_param(bmap1) == isl_basic_map_n_param(bmap2),
2503             goto error);
2504
2505         bmap1 = isl_basic_map_reverse(bmap1);
2506         bmap1 = isl_basic_map_apply_range(bmap1, bmap2);
2507         return isl_basic_map_reverse(bmap1);
2508 error:
2509         isl_basic_map_free(bmap1);
2510         isl_basic_map_free(bmap2);
2511         return NULL;
2512 }
2513
2514 /* Given two basic maps A -> f(A) and B -> g(B), construct a basic map
2515  * A \cap B -> f(A) + f(B)
2516  */
2517 struct isl_basic_map *isl_basic_map_sum(
2518                 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
2519 {
2520         unsigned n_in, n_out, nparam, total, pos;
2521         struct isl_basic_map *bmap = NULL;
2522         struct isl_dim_map *dim_map1, *dim_map2;
2523         int i;
2524
2525         if (!bmap1 || !bmap2)
2526                 goto error;
2527
2528         isl_assert(bmap1->ctx, isl_dim_equal(bmap1->dim, bmap2->dim),
2529                 goto error);
2530
2531         nparam = isl_basic_map_n_param(bmap1);
2532         n_in = isl_basic_map_n_in(bmap1);
2533         n_out = isl_basic_map_n_out(bmap1);
2534
2535         total = nparam + n_in + n_out + bmap1->n_div + bmap2->n_div + 2 * n_out;
2536         dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
2537         dim_map2 = isl_dim_map_alloc(bmap2->ctx, total);
2538         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
2539         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos);
2540         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
2541         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos);
2542         isl_dim_map_div(dim_map1, bmap1, pos += n_in + n_out);
2543         isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
2544         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += bmap2->n_div);
2545         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos += n_out);
2546
2547         bmap = isl_basic_map_alloc_dim(isl_dim_copy(bmap1->dim),
2548                         bmap1->n_div + bmap2->n_div + 2 * n_out,
2549                         bmap1->n_eq + bmap2->n_eq + n_out,
2550                         bmap1->n_ineq + bmap2->n_ineq);
2551         for (i = 0; i < n_out; ++i) {
2552                 int j = isl_basic_map_alloc_equality(bmap);
2553                 if (j < 0)
2554                         goto error;
2555                 isl_seq_clr(bmap->eq[j], 1+total);
2556                 isl_int_set_si(bmap->eq[j][1+nparam+n_in+i], -1);
2557                 isl_int_set_si(bmap->eq[j][1+pos+i], 1);
2558                 isl_int_set_si(bmap->eq[j][1+pos-n_out+i], 1);
2559         }
2560         bmap = add_constraints_dim_map(bmap, bmap1, dim_map1);
2561         bmap = add_constraints_dim_map(bmap, bmap2, dim_map2);
2562         bmap = add_divs(bmap, 2 * n_out);
2563
2564         bmap = isl_basic_map_simplify(bmap);
2565         return isl_basic_map_finalize(bmap);
2566 error:
2567         isl_basic_map_free(bmap);
2568         isl_basic_map_free(bmap1);
2569         isl_basic_map_free(bmap2);
2570         return NULL;
2571 }
2572
2573 /* Given two maps A -> f(A) and B -> g(B), construct a map
2574  * A \cap B -> f(A) + f(B)
2575  */
2576 struct isl_map *isl_map_sum(struct isl_map *map1, struct isl_map *map2)
2577 {
2578         struct isl_map *result;
2579         int i, j;
2580
2581         if (!map1 || !map2)
2582                 goto error;
2583
2584         isl_assert(map1->ctx, isl_dim_equal(map1->dim, map2->dim), goto error);
2585
2586         result = isl_map_alloc_dim(isl_dim_copy(map1->dim),
2587                                 map1->n * map2->n, 0);
2588         if (!result)
2589                 goto error;
2590         for (i = 0; i < map1->n; ++i)
2591                 for (j = 0; j < map2->n; ++j) {
2592                         struct isl_basic_map *part;
2593                         part = isl_basic_map_sum(
2594                                     isl_basic_map_copy(map1->p[i]),
2595                                     isl_basic_map_copy(map2->p[j]));
2596                         if (isl_basic_map_is_empty(part))
2597                                 isl_basic_map_free(part);
2598                         else
2599                                 result = isl_map_add_basic_map(result, part);
2600                         if (!result)
2601                                 goto error;
2602                 }
2603         isl_map_free(map1);
2604         isl_map_free(map2);
2605         return result;
2606 error:
2607         isl_map_free(map1);
2608         isl_map_free(map2);
2609         return NULL;
2610 }
2611
2612 /* Given a basic map A -> f(A), construct A -> -f(A).
2613  */
2614 struct isl_basic_map *isl_basic_map_neg(struct isl_basic_map *bmap)
2615 {
2616         int i, j;
2617         unsigned off, n;
2618
2619         bmap = isl_basic_map_cow(bmap);
2620         if (!bmap)
2621                 return NULL;
2622
2623         n = isl_basic_map_dim(bmap, isl_dim_out);
2624         off = isl_basic_map_offset(bmap, isl_dim_out);
2625         for (i = 0; i < bmap->n_eq; ++i)
2626                 for (j = 0; j < n; ++j)
2627                         isl_int_neg(bmap->eq[i][off+j], bmap->eq[i][off+j]);
2628         for (i = 0; i < bmap->n_ineq; ++i)
2629                 for (j = 0; j < n; ++j)
2630                         isl_int_neg(bmap->ineq[i][off+j], bmap->ineq[i][off+j]);
2631         for (i = 0; i < bmap->n_div; ++i)
2632                 for (j = 0; j < n; ++j)
2633                         isl_int_neg(bmap->div[i][1+off+j], bmap->div[i][1+off+j]);
2634         return isl_basic_map_finalize(bmap);
2635 }
2636
2637 /* Given a map A -> f(A), construct A -> -f(A).
2638  */
2639 struct isl_map *isl_map_neg(struct isl_map *map)
2640 {
2641         int i;
2642
2643         map = isl_map_cow(map);
2644         if (!map)
2645                 return NULL;
2646
2647         for (i = 0; i < map->n; ++i) {
2648                 map->p[i] = isl_basic_map_neg(map->p[i]);
2649                 if (!map->p[i])
2650                         goto error;
2651         }
2652
2653         return map;
2654 error:
2655         isl_map_free(map);
2656         return NULL;
2657 }
2658
2659 /* Given a basic map A -> f(A) and an integer d, construct a basic map
2660  * A -> floor(f(A)/d).
2661  */
2662 struct isl_basic_map *isl_basic_map_floordiv(struct isl_basic_map *bmap,
2663                 isl_int d)
2664 {
2665         unsigned n_in, n_out, nparam, total, pos;
2666         struct isl_basic_map *result = NULL;
2667         struct isl_dim_map *dim_map;
2668         int i;
2669
2670         if (!bmap)
2671                 return NULL;
2672
2673         nparam = isl_basic_map_n_param(bmap);
2674         n_in = isl_basic_map_n_in(bmap);
2675         n_out = isl_basic_map_n_out(bmap);
2676
2677         total = nparam + n_in + n_out + bmap->n_div + n_out;
2678         dim_map = isl_dim_map_alloc(bmap->ctx, total);
2679         isl_dim_map_dim(dim_map, bmap->dim, isl_dim_param, pos = 0);
2680         isl_dim_map_dim(dim_map, bmap->dim, isl_dim_in, pos += nparam);
2681         isl_dim_map_div(dim_map, bmap, pos += n_in + n_out);
2682         isl_dim_map_dim(dim_map, bmap->dim, isl_dim_out, pos += bmap->n_div);
2683
2684         result = isl_basic_map_alloc_dim(isl_dim_copy(bmap->dim),
2685                         bmap->n_div + n_out,
2686                         bmap->n_eq, bmap->n_ineq + 2 * n_out);
2687         result = add_constraints_dim_map(result, bmap, dim_map);
2688         result = add_divs(result, n_out);
2689         for (i = 0; i < n_out; ++i) {
2690                 int j;
2691                 j = isl_basic_map_alloc_inequality(result);
2692                 if (j < 0)
2693                         goto error;
2694                 isl_seq_clr(result->ineq[j], 1+total);
2695                 isl_int_neg(result->ineq[j][1+nparam+n_in+i], d);
2696                 isl_int_set_si(result->ineq[j][1+pos+i], 1);
2697                 j = isl_basic_map_alloc_inequality(result);
2698                 if (j < 0)
2699                         goto error;
2700                 isl_seq_clr(result->ineq[j], 1+total);
2701                 isl_int_set(result->ineq[j][1+nparam+n_in+i], d);
2702                 isl_int_set_si(result->ineq[j][1+pos+i], -1);
2703                 isl_int_sub_ui(result->ineq[j][0], d, 1);
2704         }
2705
2706         result = isl_basic_map_simplify(result);
2707         return isl_basic_map_finalize(result);
2708 error:
2709         isl_basic_map_free(result);
2710         return NULL;
2711 }
2712
2713 /* Given a map A -> f(A) and an integer d, construct a map
2714  * A -> floor(f(A)/d).
2715  */
2716 struct isl_map *isl_map_floordiv(struct isl_map *map, isl_int d)
2717 {
2718         int i;
2719
2720         map = isl_map_cow(map);
2721         if (!map)
2722                 return NULL;
2723
2724         ISL_F_CLR(map, ISL_MAP_DISJOINT);
2725         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
2726         for (i = 0; i < map->n; ++i) {
2727                 map->p[i] = isl_basic_map_floordiv(map->p[i], d);
2728                 if (!map->p[i])
2729                         goto error;
2730         }
2731
2732         return map;
2733 error:
2734         isl_map_free(map);
2735         return NULL;
2736 }
2737
2738 static struct isl_basic_map *var_equal(struct isl_basic_map *bmap, unsigned pos)
2739 {
2740         int i;
2741         unsigned nparam;
2742         unsigned n_in;
2743
2744         i = isl_basic_map_alloc_equality(bmap);
2745         if (i < 0)
2746                 goto error;
2747         nparam = isl_basic_map_n_param(bmap);
2748         n_in = isl_basic_map_n_in(bmap);
2749         isl_seq_clr(bmap->eq[i], 1 + isl_basic_map_total_dim(bmap));
2750         isl_int_set_si(bmap->eq[i][1+nparam+pos], -1);
2751         isl_int_set_si(bmap->eq[i][1+nparam+n_in+pos], 1);
2752         return isl_basic_map_finalize(bmap);
2753 error:
2754         isl_basic_map_free(bmap);
2755         return NULL;
2756 }
2757
2758 /* Add a constraints to "bmap" expressing i_pos < o_pos
2759  */
2760 static struct isl_basic_map *var_less(struct isl_basic_map *bmap, unsigned pos)
2761 {
2762         int i;
2763         unsigned nparam;
2764         unsigned n_in;
2765
2766         i = isl_basic_map_alloc_inequality(bmap);
2767         if (i < 0)
2768                 goto error;
2769         nparam = isl_basic_map_n_param(bmap);
2770         n_in = isl_basic_map_n_in(bmap);
2771         isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap));
2772         isl_int_set_si(bmap->ineq[i][0], -1);
2773         isl_int_set_si(bmap->ineq[i][1+nparam+pos], -1);
2774         isl_int_set_si(bmap->ineq[i][1+nparam+n_in+pos], 1);
2775         return isl_basic_map_finalize(bmap);
2776 error:
2777         isl_basic_map_free(bmap);
2778         return NULL;
2779 }
2780
2781 /* Add a constraints to "bmap" expressing i_pos > o_pos
2782  */
2783 static struct isl_basic_map *var_more(struct isl_basic_map *bmap, unsigned pos)
2784 {
2785         int i;
2786         unsigned nparam;
2787         unsigned n_in;
2788
2789         i = isl_basic_map_alloc_inequality(bmap);
2790         if (i < 0)
2791                 goto error;
2792         nparam = isl_basic_map_n_param(bmap);
2793         n_in = isl_basic_map_n_in(bmap);
2794         isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap));
2795         isl_int_set_si(bmap->ineq[i][0], -1);
2796         isl_int_set_si(bmap->ineq[i][1+nparam+pos], 1);
2797         isl_int_set_si(bmap->ineq[i][1+nparam+n_in+pos], -1);
2798         return isl_basic_map_finalize(bmap);
2799 error:
2800         isl_basic_map_free(bmap);
2801         return NULL;
2802 }
2803
2804 struct isl_basic_map *isl_basic_map_equal(struct isl_dim *dim, unsigned n_equal)
2805 {
2806         int i;
2807         struct isl_basic_map *bmap;
2808         bmap = isl_basic_map_alloc_dim(dim, 0, n_equal, 0);
2809         if (!bmap)
2810                 return NULL;
2811         for (i = 0; i < n_equal && bmap; ++i)
2812                 bmap = var_equal(bmap, i);
2813         return isl_basic_map_finalize(bmap);
2814 }
2815
2816 /* Return a relation on pairs of sets of dimension "dim" expressing i_pos < o_pos
2817  */
2818 struct isl_basic_map *isl_basic_map_less_at(struct isl_dim *dim, unsigned pos)
2819 {
2820         int i;
2821         struct isl_basic_map *bmap;
2822         bmap = isl_basic_map_alloc_dim(dim, 0, pos, 1);
2823         if (!bmap)
2824                 return NULL;
2825         for (i = 0; i < pos && bmap; ++i)
2826                 bmap = var_equal(bmap, i);
2827         if (bmap)
2828                 bmap = var_less(bmap, pos);
2829         return isl_basic_map_finalize(bmap);
2830 }
2831
2832 /* Return a relation on pairs of sets of dimension "dim" expressing i_pos > o_pos
2833  */
2834 struct isl_basic_map *isl_basic_map_more_at(struct isl_dim *dim, unsigned pos)
2835 {
2836         int i;
2837         struct isl_basic_map *bmap;
2838         bmap = isl_basic_map_alloc_dim(dim, 0, pos, 1);
2839         if (!bmap)
2840                 return NULL;
2841         for (i = 0; i < pos && bmap; ++i)
2842                 bmap = var_equal(bmap, i);
2843         if (bmap)
2844                 bmap = var_more(bmap, pos);
2845         return isl_basic_map_finalize(bmap);
2846 }
2847
2848 static __isl_give isl_map *map_lex_lte(__isl_take isl_dim *dims, int equal)
2849 {
2850         struct isl_map *map;
2851         unsigned dim;
2852         int i;
2853
2854         if (!dims)
2855                 return NULL;
2856         dim = dims->n_out;
2857         map = isl_map_alloc_dim(isl_dim_copy(dims), dim + equal, ISL_MAP_DISJOINT);
2858
2859         for (i = 0; i < dim; ++i)
2860                 map = isl_map_add_basic_map(map,
2861                                   isl_basic_map_less_at(isl_dim_copy(dims), i));
2862         if (equal)
2863                 map = isl_map_add_basic_map(map,
2864                                   isl_basic_map_equal(isl_dim_copy(dims), dim));
2865
2866         isl_dim_free(dims);
2867         return map;
2868 }
2869
2870 __isl_give isl_map *isl_map_lex_lt(__isl_take isl_dim *set_dim)
2871 {
2872         return map_lex_lte(isl_dim_map(set_dim), 0);
2873 }
2874
2875 __isl_give isl_map *isl_map_lex_le(__isl_take isl_dim *set_dim)
2876 {
2877         return map_lex_lte(isl_dim_map(set_dim), 1);
2878 }
2879
2880 static __isl_give isl_map *map_lex_gte(__isl_take isl_dim *dims, int equal)
2881 {
2882         struct isl_map *map;
2883         unsigned dim;
2884         int i;
2885
2886         if (!dims)
2887                 return NULL;
2888         dim = dims->n_out;
2889         map = isl_map_alloc_dim(isl_dim_copy(dims), dim + equal, ISL_MAP_DISJOINT);
2890
2891         for (i = 0; i < dim; ++i)
2892                 map = isl_map_add_basic_map(map,
2893                                   isl_basic_map_more_at(isl_dim_copy(dims), i));
2894         if (equal)
2895                 map = isl_map_add_basic_map(map,
2896                                   isl_basic_map_equal(isl_dim_copy(dims), dim));
2897
2898         isl_dim_free(dims);
2899         return map;
2900 }
2901
2902 __isl_give isl_map *isl_map_lex_gt(__isl_take isl_dim *set_dim)
2903 {
2904         return map_lex_gte(isl_dim_map(set_dim), 0);
2905 }
2906
2907 __isl_give isl_map *isl_map_lex_ge(__isl_take isl_dim *set_dim)
2908 {
2909         return map_lex_gte(isl_dim_map(set_dim), 1);
2910 }
2911
2912 struct isl_basic_map *isl_basic_map_from_basic_set(
2913                 struct isl_basic_set *bset, struct isl_dim *dim)
2914 {
2915         struct isl_basic_map *bmap;
2916
2917         bset = isl_basic_set_cow(bset);
2918         if (!bset || !dim)
2919                 goto error;
2920
2921         isl_assert(bset->ctx, isl_dim_compatible(bset->dim, dim), goto error);
2922         isl_dim_free(bset->dim);
2923         bmap = (struct isl_basic_map *) bset;
2924         bmap->dim = dim;
2925         return isl_basic_map_finalize(bmap);
2926 error:
2927         isl_basic_set_free(bset);
2928         isl_dim_free(dim);
2929         return NULL;
2930 }
2931
2932 struct isl_basic_set *isl_basic_set_from_basic_map(struct isl_basic_map *bmap)
2933 {
2934         if (!bmap)
2935                 goto error;
2936         if (bmap->dim->n_in == 0)
2937                 return (struct isl_basic_set *)bmap;
2938         bmap = isl_basic_map_cow(bmap);
2939         if (!bmap)
2940                 goto error;
2941         bmap->dim = isl_dim_cow(bmap->dim);
2942         if (!bmap->dim)
2943                 goto error;
2944         bmap->dim->n_out += bmap->dim->n_in;
2945         bmap->dim->n_in = 0;
2946         bmap = isl_basic_map_finalize(bmap);
2947         return (struct isl_basic_set *)bmap;
2948 error:
2949         isl_basic_map_free(bmap);
2950         return NULL;
2951 }
2952
2953 /* For a div d = floor(f/m), add the constraints
2954  *
2955  *              f - m d >= 0
2956  *              -(f-(n-1)) + m d >= 0
2957  *
2958  * Note that the second constraint is the negation of
2959  *
2960  *              f - m d >= n
2961  */
2962 int isl_basic_map_add_div_constraints(struct isl_basic_map *bmap, unsigned div)
2963 {
2964         int i, j;
2965         unsigned total = isl_basic_map_total_dim(bmap);
2966         unsigned div_pos = 1 + total - bmap->n_div + div;
2967
2968         i = isl_basic_map_alloc_inequality(bmap);
2969         if (i < 0)
2970                 return -1;
2971         isl_seq_cpy(bmap->ineq[i], bmap->div[div]+1, 1+total);
2972         isl_int_neg(bmap->ineq[i][div_pos], bmap->div[div][0]);
2973
2974         j = isl_basic_map_alloc_inequality(bmap);
2975         if (j < 0)
2976                 return -1;
2977         isl_seq_neg(bmap->ineq[j], bmap->ineq[i], 1 + total);
2978         isl_int_add(bmap->ineq[j][0], bmap->ineq[j][0], bmap->ineq[j][div_pos]);
2979         isl_int_sub_ui(bmap->ineq[j][0], bmap->ineq[j][0], 1);
2980         return j;
2981 }
2982
2983 struct isl_basic_set *isl_basic_map_underlying_set(
2984                 struct isl_basic_map *bmap)
2985 {
2986         if (!bmap)
2987                 goto error;
2988         if (bmap->dim->nparam == 0 && bmap->dim->n_in == 0 && bmap->n_div == 0)
2989                 return (struct isl_basic_set *)bmap;
2990         bmap = isl_basic_map_cow(bmap);
2991         if (!bmap)
2992                 goto error;
2993         bmap->dim = isl_dim_underlying(bmap->dim, bmap->n_div);
2994         if (!bmap->dim)
2995                 goto error;
2996         bmap->extra -= bmap->n_div;
2997         bmap->n_div = 0;
2998         bmap = isl_basic_map_finalize(bmap);
2999         return (struct isl_basic_set *)bmap;
3000 error:
3001         return NULL;
3002 }
3003
3004 __isl_give isl_basic_set *isl_basic_set_underlying_set(
3005                 __isl_take isl_basic_set *bset)
3006 {
3007         return isl_basic_map_underlying_set((isl_basic_map *)bset);
3008 }
3009
3010 struct isl_basic_map *isl_basic_map_overlying_set(
3011         struct isl_basic_set *bset, struct isl_basic_map *like)
3012 {
3013         struct isl_basic_map *bmap;
3014         struct isl_ctx *ctx;
3015         unsigned total;
3016         int i;
3017
3018         if (!bset || !like)
3019                 goto error;
3020         ctx = bset->ctx;
3021         isl_assert(ctx, bset->n_div == 0, goto error);
3022         isl_assert(ctx, isl_basic_set_n_param(bset) == 0, goto error);
3023         isl_assert(ctx, bset->dim->n_out == isl_basic_map_total_dim(like),
3024                         goto error);
3025         if (isl_dim_equal(bset->dim, like->dim) && like->n_div == 0) {
3026                 isl_basic_map_free(like);
3027                 return (struct isl_basic_map *)bset;
3028         }
3029         bset = isl_basic_set_cow(bset);
3030         if (!bset)
3031                 goto error;
3032         total = bset->dim->n_out + bset->extra;
3033         bmap = (struct isl_basic_map *)bset;
3034         isl_dim_free(bmap->dim);
3035         bmap->dim = isl_dim_copy(like->dim);
3036         if (!bmap->dim)
3037                 goto error;
3038         bmap->n_div = like->n_div;
3039         bmap->extra += like->n_div;
3040         if (bmap->extra) {
3041                 unsigned ltotal;
3042                 ltotal = total - bmap->extra + like->extra;
3043                 if (ltotal > total)
3044                         ltotal = total;
3045                 bmap->block2 = isl_blk_extend(ctx, bmap->block2,
3046                                         bmap->extra * (1 + 1 + total));
3047                 if (isl_blk_is_error(bmap->block2))
3048                         goto error;
3049                 bmap->div = isl_realloc_array(ctx, bmap->div, isl_int *,
3050                                                 bmap->extra);
3051                 if (!bmap->div)
3052                         goto error;
3053                 for (i = 0; i < bmap->extra; ++i)
3054                         bmap->div[i] = bmap->block2.data + i * (1 + 1 + total);
3055                 for (i = 0; i < like->n_div; ++i) {
3056                         isl_seq_cpy(bmap->div[i], like->div[i], 1 + 1 + ltotal);
3057                         isl_seq_clr(bmap->div[i]+1+1+ltotal, total - ltotal);
3058                 }
3059                 bmap = isl_basic_map_extend_constraints(bmap,
3060                                                         0, 2 * like->n_div);
3061                 for (i = 0; i < like->n_div; ++i) {
3062                         if (isl_int_is_zero(bmap->div[i][0]))
3063                                 continue;
3064                         if (isl_basic_map_add_div_constraints(bmap, i) < 0)
3065                                 goto error;
3066                 }
3067         }
3068         isl_basic_map_free(like);
3069         bmap = isl_basic_map_simplify(bmap);
3070         bmap = isl_basic_map_finalize(bmap);
3071         return bmap;
3072 error:
3073         isl_basic_map_free(like);
3074         isl_basic_set_free(bset);
3075         return NULL;
3076 }
3077
3078 struct isl_basic_set *isl_basic_set_from_underlying_set(
3079         struct isl_basic_set *bset, struct isl_basic_set *like)
3080 {
3081         return (struct isl_basic_set *)
3082                 isl_basic_map_overlying_set(bset, (struct isl_basic_map *)like);
3083 }
3084
3085 struct isl_set *isl_set_from_underlying_set(
3086         struct isl_set *set, struct isl_basic_set *like)
3087 {
3088         int i;
3089
3090         if (!set || !like)
3091                 goto error;
3092         isl_assert(set->ctx, set->dim->n_out == isl_basic_set_total_dim(like),
3093                     goto error);
3094         if (isl_dim_equal(set->dim, like->dim) && like->n_div == 0) {
3095                 isl_basic_set_free(like);
3096                 return set;
3097         }
3098         set = isl_set_cow(set);
3099         if (!set)
3100                 goto error;
3101         for (i = 0; i < set->n; ++i) {
3102                 set->p[i] = isl_basic_set_from_underlying_set(set->p[i],
3103                                                       isl_basic_set_copy(like));
3104                 if (!set->p[i])
3105                         goto error;
3106         }
3107         isl_dim_free(set->dim);
3108         set->dim = isl_dim_copy(like->dim);
3109         if (!set->dim)
3110                 goto error;
3111         isl_basic_set_free(like);
3112         return set;
3113 error:
3114         isl_basic_set_free(like);
3115         isl_set_free(set);
3116         return NULL;
3117 }
3118
3119 struct isl_set *isl_map_underlying_set(struct isl_map *map)
3120 {
3121         int i;
3122
3123         map = isl_map_cow(map);
3124         if (!map)
3125                 return NULL;
3126         map->dim = isl_dim_cow(map->dim);
3127         if (!map->dim)
3128                 goto error;
3129
3130         for (i = 1; i < map->n; ++i)
3131                 isl_assert(map->ctx, map->p[0]->n_div == map->p[i]->n_div,
3132                                 goto error);
3133         for (i = 0; i < map->n; ++i) {
3134                 map->p[i] = (struct isl_basic_map *)
3135                                 isl_basic_map_underlying_set(map->p[i]);
3136                 if (!map->p[i])
3137                         goto error;
3138         }
3139         if (map->n == 0)
3140                 map->dim = isl_dim_underlying(map->dim, 0);
3141         else {
3142                 isl_dim_free(map->dim);
3143                 map->dim = isl_dim_copy(map->p[0]->dim);
3144         }
3145         if (!map->dim)
3146                 goto error;
3147         return (struct isl_set *)map;
3148 error:
3149         isl_map_free(map);
3150         return NULL;
3151 }
3152
3153 struct isl_set *isl_set_to_underlying_set(struct isl_set *set)
3154 {
3155         return (struct isl_set *)isl_map_underlying_set((struct isl_map *)set);
3156 }
3157
3158 struct isl_basic_set *isl_basic_map_domain(struct isl_basic_map *bmap)
3159 {
3160         struct isl_basic_set *domain;
3161         unsigned n_in;
3162         unsigned n_out;
3163         if (!bmap)
3164                 return NULL;
3165         n_in = isl_basic_map_n_in(bmap);
3166         n_out = isl_basic_map_n_out(bmap);
3167         domain = isl_basic_set_from_basic_map(bmap);
3168         return isl_basic_set_project_out(domain, isl_dim_set, n_in, n_out);
3169 }
3170
3171 struct isl_basic_set *isl_basic_map_range(struct isl_basic_map *bmap)
3172 {
3173         return isl_basic_map_domain(isl_basic_map_reverse(bmap));
3174 }
3175
3176 struct isl_set *isl_map_range(struct isl_map *map)
3177 {
3178         int i;
3179         struct isl_set *set;
3180
3181         if (!map)
3182                 goto error;
3183         if (isl_map_dim(map, isl_dim_in) == 0)
3184                 return (isl_set *)map;
3185
3186         map = isl_map_cow(map);
3187         if (!map)
3188                 goto error;
3189
3190         set = (struct isl_set *) map;
3191         set->dim = isl_dim_drop_inputs(set->dim, 0, set->dim->n_in);
3192         if (!set->dim)
3193                 goto error;
3194         for (i = 0; i < map->n; ++i) {
3195                 set->p[i] = isl_basic_map_range(map->p[i]);
3196                 if (!set->p[i])
3197                         goto error;
3198         }
3199         ISL_F_CLR(set, ISL_MAP_DISJOINT);
3200         ISL_F_CLR(set, ISL_SET_NORMALIZED);
3201         return set;
3202 error:
3203         isl_map_free(map);
3204         return NULL;
3205 }
3206
3207 struct isl_map *isl_map_from_set(struct isl_set *set, struct isl_dim *dim)
3208 {
3209         int i;
3210         struct isl_map *map = NULL;
3211
3212         set = isl_set_cow(set);
3213         if (!set || !dim)
3214                 goto error;
3215         isl_assert(set->ctx, isl_dim_compatible(set->dim, dim), goto error);
3216         map = (struct isl_map *)set;
3217         for (i = 0; i < set->n; ++i) {
3218                 map->p[i] = isl_basic_map_from_basic_set(
3219                                 set->p[i], isl_dim_copy(dim));
3220                 if (!map->p[i])
3221                         goto error;
3222         }
3223         isl_dim_free(map->dim);
3224         map->dim = dim;
3225         return map;
3226 error:
3227         isl_dim_free(dim);
3228         isl_set_free(set);
3229         return NULL;
3230 }
3231
3232 struct isl_map *isl_map_from_range(struct isl_set *set)
3233 {
3234         return (struct isl_map *)set;
3235 }
3236
3237 __isl_give isl_map *isl_map_from_domain(__isl_take isl_set *set)
3238 {
3239         return isl_map_reverse(isl_map_from_range(set));;
3240 }
3241
3242 __isl_give isl_map *isl_map_from_domain_and_range(__isl_take isl_set *domain,
3243         __isl_take isl_set *range)
3244 {
3245         return isl_map_product(isl_map_from_domain(domain),
3246                                isl_map_from_range(range));
3247 }
3248
3249 struct isl_set *isl_set_from_map(struct isl_map *map)
3250 {
3251         int i;
3252         struct isl_set *set = NULL;
3253
3254         if (!map)
3255                 return NULL;
3256         map = isl_map_cow(map);
3257         if (!map)
3258                 return NULL;
3259         map->dim = isl_dim_cow(map->dim);
3260         if (!map->dim)
3261                 goto error;
3262         map->dim->n_out += map->dim->n_in;
3263         map->dim->n_in = 0;
3264         set = (struct isl_set *)map;
3265         for (i = 0; i < map->n; ++i) {
3266                 set->p[i] = isl_basic_set_from_basic_map(map->p[i]);
3267                 if (!set->p[i])
3268                         goto error;
3269         }
3270         return set;
3271 error:
3272         isl_map_free(map);
3273         return NULL;
3274 }
3275
3276 struct isl_map *isl_map_alloc_dim(struct isl_dim *dim, int n, unsigned flags)
3277 {
3278         struct isl_map *map;
3279
3280         if (!dim)
3281                 return NULL;
3282         isl_assert(dim->ctx, n >= 0, return NULL);
3283         map = isl_alloc(dim->ctx, struct isl_map,
3284                         sizeof(struct isl_map) +
3285                         (n - 1) * sizeof(struct isl_basic_map *));
3286         if (!map)
3287                 goto error;
3288
3289         map->ctx = dim->ctx;
3290         isl_ctx_ref(map->ctx);
3291         map->ref = 1;
3292         map->size = n;
3293         map->n = 0;
3294         map->dim = dim;
3295         map->flags = flags;
3296         return map;
3297 error:
3298         isl_dim_free(dim);
3299         return NULL;
3300 }
3301
3302 struct isl_map *isl_map_alloc(struct isl_ctx *ctx,
3303                 unsigned nparam, unsigned in, unsigned out, int n,
3304                 unsigned flags)
3305 {
3306         struct isl_map *map;
3307         struct isl_dim *dims;
3308
3309         dims = isl_dim_alloc(ctx, nparam, in, out);
3310         if (!dims)
3311                 return NULL;
3312
3313         map = isl_map_alloc_dim(dims, n, flags);
3314         return map;
3315 }
3316
3317 struct isl_basic_map *isl_basic_map_empty(struct isl_dim *dim)
3318 {
3319         struct isl_basic_map *bmap;
3320         bmap = isl_basic_map_alloc_dim(dim, 0, 1, 0);
3321         bmap = isl_basic_map_set_to_empty(bmap);
3322         return bmap;
3323 }
3324
3325 struct isl_basic_set *isl_basic_set_empty(struct isl_dim *dim)
3326 {
3327         struct isl_basic_set *bset;
3328         bset = isl_basic_set_alloc_dim(dim, 0, 1, 0);
3329         bset = isl_basic_set_set_to_empty(bset);
3330         return bset;
3331 }
3332
3333 struct isl_basic_map *isl_basic_map_empty_like(struct isl_basic_map *model)
3334 {
3335         struct isl_basic_map *bmap;
3336         if (!model)
3337                 return NULL;
3338         bmap = isl_basic_map_alloc_dim(isl_dim_copy(model->dim), 0, 1, 0);
3339         bmap = isl_basic_map_set_to_empty(bmap);
3340         return bmap;
3341 }
3342
3343 struct isl_basic_map *isl_basic_map_empty_like_map(struct isl_map *model)
3344 {
3345         struct isl_basic_map *bmap;
3346         if (!model)
3347                 return NULL;
3348         bmap = isl_basic_map_alloc_dim(isl_dim_copy(model->dim), 0, 1, 0);
3349         bmap = isl_basic_map_set_to_empty(bmap);
3350         return bmap;
3351 }
3352
3353 struct isl_basic_set *isl_basic_set_empty_like(struct isl_basic_set *model)
3354 {
3355         struct isl_basic_set *bset;
3356         if (!model)
3357                 return NULL;
3358         bset = isl_basic_set_alloc_dim(isl_dim_copy(model->dim), 0, 1, 0);
3359         bset = isl_basic_set_set_to_empty(bset);
3360         return bset;
3361 }
3362
3363 struct isl_basic_map *isl_basic_map_universe(struct isl_dim *dim)
3364 {
3365         struct isl_basic_map *bmap;
3366         bmap = isl_basic_map_alloc_dim(dim, 0, 0, 0);
3367         return bmap;
3368 }
3369
3370 struct isl_basic_set *isl_basic_set_universe(struct isl_dim *dim)
3371 {
3372         struct isl_basic_set *bset;
3373         bset = isl_basic_set_alloc_dim(dim, 0, 0, 0);
3374         return bset;
3375 }
3376
3377 __isl_give isl_basic_map *isl_basic_map_universe_like(
3378                 __isl_keep isl_basic_map *model)
3379 {
3380         if (!model)
3381                 return NULL;
3382         return isl_basic_map_alloc_dim(isl_dim_copy(model->dim), 0, 0, 0);
3383 }
3384
3385 struct isl_basic_set *isl_basic_set_universe_like(struct isl_basic_set *model)
3386 {
3387         if (!model)
3388                 return NULL;
3389         return isl_basic_set_alloc_dim(isl_dim_copy(model->dim), 0, 0, 0);
3390 }
3391
3392 __isl_give isl_basic_set *isl_basic_set_universe_like_set(
3393         __isl_keep isl_set *model)
3394 {
3395         if (!model)
3396                 return NULL;
3397         return isl_basic_set_alloc_dim(isl_dim_copy(model->dim), 0, 0, 0);
3398 }
3399
3400 struct isl_map *isl_map_empty(struct isl_dim *dim)
3401 {
3402         return isl_map_alloc_dim(dim, 0, ISL_MAP_DISJOINT);
3403 }
3404
3405 struct isl_map *isl_map_empty_like(struct isl_map *model)
3406 {
3407         if (!model)
3408                 return NULL;
3409         return isl_map_alloc_dim(isl_dim_copy(model->dim), 0, ISL_MAP_DISJOINT);
3410 }
3411
3412 struct isl_map *isl_map_empty_like_basic_map(struct isl_basic_map *model)
3413 {
3414         if (!model)
3415                 return NULL;
3416         return isl_map_alloc_dim(isl_dim_copy(model->dim), 0, ISL_MAP_DISJOINT);
3417 }
3418
3419 struct isl_set *isl_set_empty(struct isl_dim *dim)
3420 {
3421         return isl_set_alloc_dim(dim, 0, ISL_MAP_DISJOINT);
3422 }
3423
3424 struct isl_set *isl_set_empty_like(struct isl_set *model)
3425 {
3426         if (!model)
3427                 return NULL;
3428         return isl_set_empty(isl_dim_copy(model->dim));
3429 }
3430
3431 struct isl_map *isl_map_universe(struct isl_dim *dim)
3432 {
3433         struct isl_map *map;
3434         if (!dim)
3435                 return NULL;
3436         map = isl_map_alloc_dim(isl_dim_copy(dim), 1, ISL_MAP_DISJOINT);
3437         map = isl_map_add_basic_map(map, isl_basic_map_universe(dim));
3438         return map;
3439 }
3440
3441 struct isl_set *isl_set_universe(struct isl_dim *dim)
3442 {
3443         struct isl_set *set;
3444         if (!dim)
3445                 return NULL;
3446         set = isl_set_alloc_dim(isl_dim_copy(dim), 1, ISL_MAP_DISJOINT);
3447         set = isl_set_add_basic_set(set, isl_basic_set_universe(dim));
3448         return set;
3449 }
3450
3451 __isl_give isl_set *isl_set_universe_like(__isl_keep isl_set *model)
3452 {
3453         if (!model)
3454                 return NULL;
3455         return isl_set_universe(isl_dim_copy(model->dim));
3456 }
3457
3458 struct isl_map *isl_map_dup(struct isl_map *map)
3459 {
3460         int i;
3461         struct isl_map *dup;
3462
3463         if (!map)
3464                 return NULL;
3465         dup = isl_map_alloc_dim(isl_dim_copy(map->dim), map->n, map->flags);
3466         for (i = 0; i < map->n; ++i)
3467                 dup = isl_map_add_basic_map(dup, isl_basic_map_copy(map->p[i]));
3468         return dup;
3469 }
3470
3471 __isl_give isl_map *isl_map_add_basic_map(__isl_take isl_map *map,
3472                                                 __isl_take isl_basic_map *bmap)
3473 {
3474         if (!bmap || !map)
3475                 goto error;
3476         if (isl_basic_map_fast_is_empty(bmap)) {
3477                 isl_basic_map_free(bmap);
3478                 return map;
3479         }
3480         isl_assert(map->ctx, isl_dim_equal(map->dim, bmap->dim), goto error);
3481         isl_assert(map->ctx, map->n < map->size, goto error);
3482         map->p[map->n] = bmap;
3483         map->n++;
3484         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
3485         return map;
3486 error:
3487         if (map)
3488                 isl_map_free(map);
3489         if (bmap)
3490                 isl_basic_map_free(bmap);
3491         return NULL;
3492 }
3493
3494 void isl_map_free(struct isl_map *map)
3495 {
3496         int i;
3497
3498         if (!map)
3499                 return;
3500
3501         if (--map->ref > 0)
3502                 return;
3503
3504         isl_ctx_deref(map->ctx);
3505         for (i = 0; i < map->n; ++i)
3506                 isl_basic_map_free(map->p[i]);
3507         isl_dim_free(map->dim);
3508         free(map);
3509 }
3510
3511 struct isl_map *isl_map_extend(struct isl_map *base,
3512                 unsigned nparam, unsigned n_in, unsigned n_out)
3513 {
3514         int i;
3515
3516         base = isl_map_cow(base);
3517         if (!base)
3518                 return NULL;
3519
3520         base->dim = isl_dim_extend(base->dim, nparam, n_in, n_out);
3521         if (!base->dim)
3522                 goto error;
3523         for (i = 0; i < base->n; ++i) {
3524                 base->p[i] = isl_basic_map_extend_dim(base->p[i],
3525                                 isl_dim_copy(base->dim), 0, 0, 0);
3526                 if (!base->p[i])
3527                         goto error;
3528         }
3529         return base;
3530 error:
3531         isl_map_free(base);
3532         return NULL;
3533 }
3534
3535 struct isl_set *isl_set_extend(struct isl_set *base,
3536                 unsigned nparam, unsigned dim)
3537 {
3538         return (struct isl_set *)isl_map_extend((struct isl_map *)base,
3539                                                         nparam, 0, dim);
3540 }
3541
3542 static struct isl_basic_map *isl_basic_map_fix_pos_si(
3543         struct isl_basic_map *bmap, unsigned pos, int value)
3544 {
3545         int j;
3546
3547         bmap = isl_basic_map_cow(bmap);
3548         bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
3549         j = isl_basic_map_alloc_equality(bmap);
3550         if (j < 0)
3551                 goto error;
3552         isl_seq_clr(bmap->eq[j] + 1, isl_basic_map_total_dim(bmap));
3553         isl_int_set_si(bmap->eq[j][pos], -1);
3554         isl_int_set_si(bmap->eq[j][0], value);
3555         bmap = isl_basic_map_simplify(bmap);
3556         return isl_basic_map_finalize(bmap);
3557 error:
3558         isl_basic_map_free(bmap);
3559         return NULL;
3560 }
3561
3562 static __isl_give isl_basic_map *isl_basic_map_fix_pos(
3563         __isl_take isl_basic_map *bmap, unsigned pos, isl_int value)
3564 {
3565         int j;
3566
3567         bmap = isl_basic_map_cow(bmap);
3568         bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
3569         j = isl_basic_map_alloc_equality(bmap);
3570         if (j < 0)
3571                 goto error;
3572         isl_seq_clr(bmap->eq[j] + 1, isl_basic_map_total_dim(bmap));
3573         isl_int_set_si(bmap->eq[j][pos], -1);
3574         isl_int_set(bmap->eq[j][0], value);
3575         bmap = isl_basic_map_simplify(bmap);
3576         return isl_basic_map_finalize(bmap);
3577 error:
3578         isl_basic_map_free(bmap);
3579         return NULL;
3580 }
3581
3582 struct isl_basic_map *isl_basic_map_fix_si(struct isl_basic_map *bmap,
3583                 enum isl_dim_type type, unsigned pos, int value)
3584 {
3585         if (!bmap)
3586                 return NULL;
3587         isl_assert(bmap->ctx, pos < isl_basic_map_dim(bmap, type), goto error);
3588         return isl_basic_map_fix_pos_si(bmap,
3589                 isl_basic_map_offset(bmap, type) + pos, value);
3590 error:
3591         isl_basic_map_free(bmap);
3592         return NULL;
3593 }
3594
3595 __isl_give isl_basic_map *isl_basic_map_fix(__isl_take isl_basic_map *bmap,
3596                 enum isl_dim_type type, unsigned pos, isl_int value)
3597 {
3598         if (!bmap)
3599                 return NULL;
3600         isl_assert(bmap->ctx, pos < isl_basic_map_dim(bmap, type), goto error);
3601         return isl_basic_map_fix_pos(bmap,
3602                 isl_basic_map_offset(bmap, type) + pos, value);
3603 error:
3604         isl_basic_map_free(bmap);
3605         return NULL;
3606 }
3607
3608 struct isl_basic_set *isl_basic_set_fix_si(struct isl_basic_set *bset,
3609                 enum isl_dim_type type, unsigned pos, int value)
3610 {
3611         return (struct isl_basic_set *)
3612                 isl_basic_map_fix_si((struct isl_basic_map *)bset,
3613                                         type, pos, value);
3614 }
3615
3616 __isl_give isl_basic_set *isl_basic_set_fix(__isl_take isl_basic_set *bset,
3617                 enum isl_dim_type type, unsigned pos, isl_int value)
3618 {
3619         return (struct isl_basic_set *)
3620                 isl_basic_map_fix((struct isl_basic_map *)bset,
3621                                         type, pos, value);
3622 }
3623
3624 struct isl_basic_map *isl_basic_map_fix_input_si(struct isl_basic_map *bmap,
3625                 unsigned input, int value)
3626 {
3627         return isl_basic_map_fix_si(bmap, isl_dim_in, input, value);
3628 }
3629
3630 struct isl_basic_set *isl_basic_set_fix_dim_si(struct isl_basic_set *bset,
3631                 unsigned dim, int value)
3632 {
3633         return (struct isl_basic_set *)
3634                 isl_basic_map_fix_si((struct isl_basic_map *)bset,
3635                                         isl_dim_set, dim, value);
3636 }
3637
3638 struct isl_map *isl_map_fix_si(struct isl_map *map,
3639                 enum isl_dim_type type, unsigned pos, int value)
3640 {
3641         int i;
3642
3643         map = isl_map_cow(map);
3644         if (!map)
3645                 return NULL;
3646
3647         isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error);
3648         for (i = 0; i < map->n; ++i) {
3649                 map->p[i] = isl_basic_map_fix_si(map->p[i], type, pos, value);
3650                 if (!map->p[i])
3651                         goto error;
3652         }
3653         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
3654         return map;
3655 error:
3656         isl_map_free(map);
3657         return NULL;
3658 }
3659
3660 __isl_give isl_set *isl_set_fix_si(__isl_take isl_set *set,
3661                 enum isl_dim_type type, unsigned pos, int value)
3662 {
3663         return (struct isl_set *)
3664                 isl_map_fix_si((struct isl_map *)set, type, pos, value);
3665 }
3666
3667 __isl_give isl_map *isl_map_fix(__isl_take isl_map *map,
3668                 enum isl_dim_type type, unsigned pos, isl_int value)
3669 {
3670         int i;
3671
3672         map = isl_map_cow(map);
3673         if (!map)
3674                 return NULL;
3675
3676         isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error);
3677         for (i = 0; i < map->n; ++i) {
3678                 map->p[i] = isl_basic_map_fix(map->p[i], type, pos, value);
3679                 if (!map->p[i])
3680                         goto error;
3681         }
3682         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
3683         return map;
3684 error:
3685         isl_map_free(map);
3686         return NULL;
3687 }
3688
3689 __isl_give isl_set *isl_set_fix(__isl_take isl_set *set,
3690                 enum isl_dim_type type, unsigned pos, isl_int value)
3691 {
3692         return (struct isl_set *)isl_map_fix((isl_map *)set, type, pos, value);
3693 }
3694
3695 struct isl_map *isl_map_fix_input_si(struct isl_map *map,
3696                 unsigned input, int value)
3697 {
3698         return isl_map_fix_si(map, isl_dim_in, input, value);
3699 }
3700
3701 struct isl_set *isl_set_fix_dim_si(struct isl_set *set, unsigned dim, int value)
3702 {
3703         return (struct isl_set *)
3704                 isl_map_fix_si((struct isl_map *)set, isl_dim_set, dim, value);
3705 }
3706
3707 __isl_give isl_basic_map *isl_basic_map_lower_bound_si(
3708                 __isl_take isl_basic_map *bmap,
3709                 enum isl_dim_type type, unsigned pos, int value)
3710 {
3711         int j;
3712
3713         if (!bmap)
3714                 return NULL;
3715         isl_assert(bmap->ctx, pos < isl_basic_map_dim(bmap, type), goto error);
3716         pos += isl_basic_map_offset(bmap, type);
3717         bmap = isl_basic_map_cow(bmap);
3718         bmap = isl_basic_map_extend_constraints(bmap, 0, 1);
3719         j = isl_basic_map_alloc_inequality(bmap);
3720         if (j < 0)
3721                 goto error;
3722         isl_seq_clr(bmap->ineq[j], 1 + isl_basic_map_total_dim(bmap));
3723         isl_int_set_si(bmap->ineq[j][pos], 1);
3724         isl_int_set_si(bmap->ineq[j][0], -value);
3725         bmap = isl_basic_map_simplify(bmap);
3726         return isl_basic_map_finalize(bmap);
3727 error:
3728         isl_basic_map_free(bmap);
3729         return NULL;
3730 }
3731
3732 struct isl_basic_set *isl_basic_set_lower_bound_dim(struct isl_basic_set *bset,
3733         unsigned dim, isl_int value)
3734 {
3735         int j;
3736
3737         bset = isl_basic_set_cow(bset);
3738         bset = isl_basic_set_extend_constraints(bset, 0, 1);
3739         j = isl_basic_set_alloc_inequality(bset);
3740         if (j < 0)
3741                 goto error;
3742         isl_seq_clr(bset->ineq[j], 1 + isl_basic_set_total_dim(bset));
3743         isl_int_set_si(bset->ineq[j][1 + isl_basic_set_n_param(bset) + dim], 1);
3744         isl_int_neg(bset->ineq[j][0], value);
3745         bset = isl_basic_set_simplify(bset);
3746         return isl_basic_set_finalize(bset);
3747 error:
3748         isl_basic_set_free(bset);
3749         return NULL;
3750 }
3751
3752 __isl_give isl_map *isl_map_lower_bound_si(__isl_take isl_map *map,
3753                 enum isl_dim_type type, unsigned pos, int value)
3754 {
3755         int i;
3756
3757         map = isl_map_cow(map);
3758         if (!map)
3759                 return NULL;
3760
3761         isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error);
3762         for (i = 0; i < map->n; ++i) {
3763                 map->p[i] = isl_basic_map_lower_bound_si(map->p[i],
3764                                                          type, pos, value);
3765                 if (!map->p[i])
3766                         goto error;
3767         }
3768         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
3769         return map;
3770 error:
3771         isl_map_free(map);
3772         return NULL;
3773 }
3774
3775 __isl_give isl_set *isl_set_lower_bound_si(__isl_take isl_set *set,
3776                 enum isl_dim_type type, unsigned pos, int value)
3777 {
3778         return (struct isl_set *)
3779                 isl_map_lower_bound_si((struct isl_map *)set, type, pos, value);
3780 }
3781
3782 struct isl_set *isl_set_lower_bound_dim(struct isl_set *set, unsigned dim,
3783                                         isl_int value)
3784 {
3785         int i;
3786
3787         set = isl_set_cow(set);
3788         if (!set)
3789                 return NULL;
3790
3791         isl_assert(set->ctx, dim < isl_set_n_dim(set), goto error);
3792         for (i = 0; i < set->n; ++i) {
3793                 set->p[i] = isl_basic_set_lower_bound_dim(set->p[i], dim, value);
3794                 if (!set->p[i])
3795                         goto error;
3796         }
3797         return set;
3798 error:
3799         isl_set_free(set);
3800         return NULL;
3801 }
3802
3803 struct isl_map *isl_map_reverse(struct isl_map *map)
3804 {
3805         int i;
3806
3807         map = isl_map_cow(map);
3808         if (!map)
3809                 return NULL;
3810
3811         map->dim = isl_dim_reverse(map->dim);
3812         if (!map->dim)
3813                 goto error;
3814         for (i = 0; i < map->n; ++i) {
3815                 map->p[i] = isl_basic_map_reverse(map->p[i]);
3816                 if (!map->p[i])
3817                         goto error;
3818         }
3819         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
3820         return map;
3821 error:
3822         isl_map_free(map);
3823         return NULL;
3824 }
3825
3826 static struct isl_map *isl_basic_map_partial_lexopt(
3827                 struct isl_basic_map *bmap, struct isl_basic_set *dom,
3828                 struct isl_set **empty, int max)
3829 {
3830         if (!bmap)
3831                 goto error;
3832         if (bmap->ctx->opt->pip == ISL_PIP_PIP)
3833                 return isl_pip_basic_map_lexopt(bmap, dom, empty, max);
3834         else
3835                 return isl_tab_basic_map_partial_lexopt(bmap, dom, empty, max);
3836 error:
3837         isl_basic_map_free(bmap);
3838         isl_basic_set_free(dom);
3839         if (empty)
3840                 *empty = NULL;
3841         return NULL;
3842 }
3843
3844 struct isl_map *isl_basic_map_partial_lexmax(
3845                 struct isl_basic_map *bmap, struct isl_basic_set *dom,
3846                 struct isl_set **empty)
3847 {
3848         return isl_basic_map_partial_lexopt(bmap, dom, empty, 1);
3849 }
3850
3851 struct isl_map *isl_basic_map_partial_lexmin(
3852                 struct isl_basic_map *bmap, struct isl_basic_set *dom,
3853                 struct isl_set **empty)
3854 {
3855         return isl_basic_map_partial_lexopt(bmap, dom, empty, 0);
3856 }
3857
3858 struct isl_set *isl_basic_set_partial_lexmin(
3859                 struct isl_basic_set *bset, struct isl_basic_set *dom,
3860                 struct isl_set **empty)
3861 {
3862         return (struct isl_set *)
3863                 isl_basic_map_partial_lexmin((struct isl_basic_map *)bset,
3864                         dom, empty);
3865 }
3866
3867 struct isl_set *isl_basic_set_partial_lexmax(
3868                 struct isl_basic_set *bset, struct isl_basic_set *dom,
3869                 struct isl_set **empty)
3870 {
3871         return (struct isl_set *)
3872                 isl_basic_map_partial_lexmax((struct isl_basic_map *)bset,
3873                         dom, empty);
3874 }
3875
3876 /* Given a basic map "bmap", compute the lexicograhically minimal
3877  * (or maximal) image element for each domain element in dom.
3878  * Set *empty to those elements in dom that do not have an image element.
3879  *
3880  * We first make sure the basic sets in dom are disjoint and then
3881  * simply collect the results over each of the basic sets separately.
3882  * We could probably improve the efficiency a bit by moving the union
3883  * domain down into the parametric integer programming.
3884  */
3885 static __isl_give isl_map *basic_map_partial_lexopt(
3886                 __isl_take isl_basic_map *bmap, __isl_take isl_set *dom,
3887                 __isl_give isl_set **empty, int max)
3888 {
3889         int i;
3890         struct isl_map *res;
3891
3892         dom = isl_set_make_disjoint(dom);
3893         if (!dom)
3894                 goto error;
3895
3896         if (isl_set_fast_is_empty(dom)) {
3897                 res = isl_map_empty_like_basic_map(bmap);
3898                 *empty = isl_set_empty_like(dom);
3899                 isl_set_free(dom);
3900                 isl_basic_map_free(bmap);
3901                 return res;
3902         }
3903
3904         res = isl_basic_map_partial_lexopt(isl_basic_map_copy(bmap),
3905                         isl_basic_set_copy(dom->p[0]), empty, max);
3906
3907         for (i = 1; i < dom->n; ++i) {
3908                 struct isl_map *res_i;
3909                 struct isl_set *empty_i;
3910
3911                 res_i = isl_basic_map_partial_lexopt(isl_basic_map_copy(bmap),
3912                                 isl_basic_set_copy(dom->p[i]), &empty_i, max);
3913
3914                 res = isl_map_union_disjoint(res, res_i);
3915                 *empty = isl_set_union_disjoint(*empty, empty_i);
3916         }
3917
3918         isl_set_free(dom);
3919         isl_basic_map_free(bmap);
3920         return res;
3921 error:
3922         *empty = NULL;
3923         isl_set_free(dom);
3924         isl_basic_map_free(bmap);
3925         return NULL;
3926 }
3927
3928 /* Given a map "map", compute the lexicograhically minimal
3929  * (or maximal) image element for each domain element in dom.
3930  * Set *empty to those elements in dom that do not have an image element.
3931  *
3932  * We first compute the lexicographically minimal or maximal element
3933  * in the first basic map.  This results in a partial solution "res"
3934  * and a subset "todo" of dom that still need to be handled.
3935  * We then consider each of the remaining maps in "map" and successively
3936  * improve both "res" and "todo".
3937  *
3938  * Let res^k and todo^k be the results after k steps and let i = k + 1.
3939  * Assume we are computing the lexicographical maximum.
3940  * We first intersect basic map i with a relation that maps elements
3941  * to elements that are lexicographically larger than the image elements
3942  * in res^k and the compute the maximum image element of this intersection.
3943  * The result ("better") corresponds to those image elements in basic map i
3944  * that are better than what we had before.  The remainder ("keep") are the
3945  * domain elements for which the image element in res_k was better.
3946  * We also compute the lexicographical maximum of basic map i in todo^k.
3947  * res^i is the result of the operation + better + those elements in
3948  *              res^k that we should keep
3949  * todo^i is the remainder of the maximum operation on todo^k.
3950  */
3951 static __isl_give isl_map *isl_map_partial_lexopt(
3952                 __isl_take isl_map *map, __isl_take isl_set *dom,
3953                 __isl_give isl_set **empty, int max)
3954 {
3955         int i;
3956         struct isl_map *res;
3957         struct isl_set *todo;
3958
3959         if (!map || !dom)
3960                 goto error;
3961
3962         if (isl_map_fast_is_empty(map)) {
3963                 if (empty)
3964                         *empty = dom;
3965                 else
3966                         isl_set_free(dom);
3967                 return map;
3968         }
3969
3970         res = basic_map_partial_lexopt(isl_basic_map_copy(map->p[0]),
3971                                         isl_set_copy(dom), &todo, max);
3972
3973         for (i = 1; i < map->n; ++i) {
3974                 struct isl_map *lt;
3975                 struct isl_map *better;
3976                 struct isl_set *keep;
3977                 struct isl_map *res_i;
3978                 struct isl_set *todo_i;
3979                 struct isl_dim *dim = isl_map_get_dim(res);
3980
3981                 dim = isl_dim_range(dim);
3982                 if (max)
3983                         lt = isl_map_lex_lt(dim);
3984                 else
3985                         lt = isl_map_lex_gt(dim);
3986                 lt = isl_map_apply_range(isl_map_copy(res), lt);
3987                 lt = isl_map_intersect(lt,
3988                         isl_map_from_basic_map(isl_basic_map_copy(map->p[i])));
3989                 better = isl_map_partial_lexopt(lt,
3990                         isl_map_domain(isl_map_copy(res)),
3991                         &keep, max);
3992
3993                 res_i = basic_map_partial_lexopt(isl_basic_map_copy(map->p[i]),
3994                                                 todo, &todo_i, max);
3995
3996                 res = isl_map_intersect_domain(res, keep);
3997                 res = isl_map_union_disjoint(res, res_i);
3998                 res = isl_map_union_disjoint(res, better);
3999                 todo = todo_i;
4000         }
4001
4002         isl_set_free(dom);
4003         isl_map_free(map);
4004
4005         if (empty)
4006                 *empty = todo;
4007         else
4008                 isl_set_free(todo);
4009
4010         return res;
4011 error:
4012         if (empty)
4013                 *empty = NULL;
4014         isl_set_free(dom);
4015         isl_map_free(map);
4016         return NULL;
4017 }
4018
4019 __isl_give isl_map *isl_map_partial_lexmax(
4020                 __isl_take isl_map *map, __isl_take isl_set *dom,
4021                 __isl_give isl_set **empty)
4022 {
4023         return isl_map_partial_lexopt(map, dom, empty, 1);
4024 }
4025
4026 __isl_give isl_map *isl_map_partial_lexmin(
4027                 __isl_take isl_map *map, __isl_take isl_set *dom,
4028                 __isl_give isl_set **empty)
4029 {
4030         return isl_map_partial_lexopt(map, dom, empty, 0);
4031 }
4032
4033 __isl_give isl_set *isl_set_partial_lexmin(
4034                 __isl_take isl_set *set, __isl_take isl_set *dom,
4035                 __isl_give isl_set **empty)
4036 {
4037         return (struct isl_set *)
4038                 isl_map_partial_lexmin((struct isl_map *)set,
4039                         dom, empty);
4040 }
4041
4042 __isl_give isl_set *isl_set_partial_lexmax(
4043                 __isl_take isl_set *set, __isl_take isl_set *dom,
4044                 __isl_give isl_set **empty)
4045 {
4046         return (struct isl_set *)
4047                 isl_map_partial_lexmax((struct isl_map *)set,
4048                         dom, empty);
4049 }
4050
4051 __isl_give isl_map *isl_basic_map_lexopt(__isl_take isl_basic_map *bmap, int max)
4052 {
4053         struct isl_basic_set *dom = NULL;
4054         struct isl_dim *dom_dim;
4055
4056         if (!bmap)
4057                 goto error;
4058         dom_dim = isl_dim_domain(isl_dim_copy(bmap->dim));
4059         dom = isl_basic_set_universe(dom_dim);
4060         return isl_basic_map_partial_lexopt(bmap, dom, NULL, max);
4061 error:
4062         isl_basic_map_free(bmap);
4063         return NULL;
4064 }
4065
4066 __isl_give isl_map *isl_basic_map_lexmin(__isl_take isl_basic_map *bmap)
4067 {
4068         return isl_basic_map_lexopt(bmap, 0);
4069 }
4070
4071 __isl_give isl_map *isl_basic_map_lexmax(__isl_take isl_basic_map *bmap)
4072 {
4073         return isl_basic_map_lexopt(bmap, 1);
4074 }
4075
4076 __isl_give isl_set *isl_basic_set_lexmin(__isl_take isl_basic_set *bset)
4077 {
4078         return (isl_set *)isl_basic_map_lexmin((isl_basic_map *)bset);
4079 }
4080
4081 __isl_give isl_set *isl_basic_set_lexmax(__isl_take isl_basic_set *bset)
4082 {
4083         return (isl_set *)isl_basic_map_lexmax((isl_basic_map *)bset);
4084 }
4085
4086 __isl_give isl_map *isl_map_lexopt(__isl_take isl_map *map, int max)
4087 {
4088         struct isl_set *dom = NULL;
4089         struct isl_dim *dom_dim;
4090
4091         if (!map)
4092                 goto error;
4093         dom_dim = isl_dim_domain(isl_dim_copy(map->dim));
4094         dom = isl_set_universe(dom_dim);
4095         return isl_map_partial_lexopt(map, dom, NULL, max);
4096 error:
4097         isl_map_free(map);
4098         return NULL;
4099 }
4100
4101 __isl_give isl_map *isl_map_lexmin(__isl_take isl_map *map)
4102 {
4103         return isl_map_lexopt(map, 0);
4104 }
4105
4106 __isl_give isl_map *isl_map_lexmax(__isl_take isl_map *map)
4107 {
4108         return isl_map_lexopt(map, 1);
4109 }
4110
4111 __isl_give isl_set *isl_set_lexmin(__isl_take isl_set *set)
4112 {
4113         return (isl_set *)isl_map_lexmin((isl_map *)set);
4114 }
4115
4116 __isl_give isl_set *isl_set_lexmax(__isl_take isl_set *set)
4117 {
4118         return (isl_set *)isl_map_lexmax((isl_map *)set);
4119 }
4120
4121 static struct isl_map *isl_map_reset_dim(struct isl_map *map,
4122         struct isl_dim *dim)
4123 {
4124         int i;
4125
4126         if (!map || !dim)
4127                 goto error;
4128
4129         for (i = 0; i < map->n; ++i) {
4130                 isl_dim_free(map->p[i]->dim);
4131                 map->p[i]->dim = isl_dim_copy(dim);
4132         }
4133         isl_dim_free(map->dim);
4134         map->dim = dim;
4135
4136         return map;
4137 error:
4138         isl_map_free(map);
4139         isl_dim_free(dim);
4140         return NULL;
4141 }
4142
4143 static struct isl_set *isl_set_reset_dim(struct isl_set *set,
4144         struct isl_dim *dim)
4145 {
4146         return (struct isl_set *) isl_map_reset_dim((struct isl_map *)set, dim);
4147 }
4148
4149 /* Apply a preimage specified by "mat" on the parameters of "bset".
4150  * bset is assumed to have only parameters and divs.
4151  */
4152 static struct isl_basic_set *basic_set_parameter_preimage(
4153         struct isl_basic_set *bset, struct isl_mat *mat)
4154 {
4155         unsigned nparam;
4156
4157         if (!bset || !mat)
4158                 goto error;
4159
4160         bset->dim = isl_dim_cow(bset->dim);
4161         if (!bset->dim)
4162                 goto error;
4163
4164         nparam = isl_basic_set_dim(bset, isl_dim_param);
4165
4166         isl_assert(bset->ctx, mat->n_row == 1 + nparam, goto error);
4167
4168         bset->dim->nparam = 0;
4169         bset->dim->n_out = nparam;
4170         bset = isl_basic_set_preimage(bset, mat);
4171         if (bset) {
4172                 bset->dim->nparam = bset->dim->n_out;
4173                 bset->dim->n_out = 0;
4174         }
4175         return bset;
4176 error:
4177         isl_mat_free(mat);
4178         isl_basic_set_free(bset);
4179         return NULL;
4180 }
4181
4182 /* Apply a preimage specified by "mat" on the parameters of "set".
4183  * set is assumed to have only parameters and divs.
4184  */
4185 static struct isl_set *set_parameter_preimage(
4186         struct isl_set *set, struct isl_mat *mat)
4187 {
4188         struct isl_dim *dim = NULL;
4189         unsigned nparam;
4190
4191         if (!set || !mat)
4192                 goto error;
4193
4194         dim = isl_dim_copy(set->dim);
4195         dim = isl_dim_cow(dim);
4196         if (!dim)
4197                 goto error;
4198
4199         nparam = isl_set_dim(set, isl_dim_param);
4200
4201         isl_assert(set->ctx, mat->n_row == 1 + nparam, goto error);
4202
4203         dim->nparam = 0;
4204         dim->n_out = nparam;
4205         isl_set_reset_dim(set, dim);
4206         set = isl_set_preimage(set, mat);
4207         if (!set)
4208                 goto error2;
4209         dim = isl_dim_copy(set->dim);
4210         dim = isl_dim_cow(dim);
4211         if (!dim)
4212                 goto error2;
4213         dim->nparam = dim->n_out;
4214         dim->n_out = 0;
4215         isl_set_reset_dim(set, dim);
4216         return set;
4217 error:
4218         isl_dim_free(dim);
4219         isl_mat_free(mat);
4220 error2:
4221         isl_set_free(set);
4222         return NULL;
4223 }
4224
4225 /* Intersect the basic set "bset" with the affine space specified by the
4226  * equalities in "eq".
4227  */
4228 static struct isl_basic_set *basic_set_append_equalities(
4229         struct isl_basic_set *bset, struct isl_mat *eq)
4230 {
4231         int i, k;
4232         unsigned len;
4233
4234         if (!bset || !eq)
4235                 goto error;
4236
4237         bset = isl_basic_set_extend_dim(bset, isl_dim_copy(bset->dim), 0,
4238                                         eq->n_row, 0);
4239         if (!bset)
4240                 goto error;
4241
4242         len = 1 + isl_dim_total(bset->dim) + bset->extra;
4243         for (i = 0; i < eq->n_row; ++i) {
4244                 k = isl_basic_set_alloc_equality(bset);
4245                 if (k < 0)
4246                         goto error;
4247                 isl_seq_cpy(bset->eq[k], eq->row[i], eq->n_col);
4248                 isl_seq_clr(bset->eq[k] + eq->n_col, len - eq->n_col);
4249         }
4250         isl_mat_free(eq);
4251
4252         return bset;
4253 error:
4254         isl_mat_free(eq);
4255         isl_basic_set_free(bset);
4256         return NULL;
4257 }
4258
4259 /* Intersect the set "set" with the affine space specified by the
4260  * equalities in "eq".
4261  */
4262 static struct isl_set *set_append_equalities(struct isl_set *set,
4263         struct isl_mat *eq)
4264 {
4265         int i;
4266
4267         if (!set || !eq)
4268                 goto error;
4269
4270         for (i = 0; i < set->n; ++i) {
4271                 set->p[i] = basic_set_append_equalities(set->p[i],
4272                                         isl_mat_copy(eq));
4273                 if (!set->p[i])
4274                         goto error;
4275         }
4276         isl_mat_free(eq);
4277         return set;
4278 error:
4279         isl_mat_free(eq);
4280         isl_set_free(set);
4281         return NULL;
4282 }
4283
4284 /* Project the given basic set onto its parameter domain, possibly introducing
4285  * new, explicit, existential variables in the constraints.
4286  * The input has parameters and (possibly implicit) existential variables.
4287  * The output has the same parameters, but only
4288  * explicit existentially quantified variables.
4289  *
4290  * The actual projection is performed by pip, but pip doesn't seem
4291  * to like equalities very much, so we first remove the equalities
4292  * among the parameters by performing a variable compression on
4293  * the parameters.  Afterward, an inverse transformation is performed
4294  * and the equalities among the parameters are inserted back in.
4295  */
4296 static struct isl_set *parameter_compute_divs(struct isl_basic_set *bset)
4297 {
4298         int i, j;
4299         struct isl_mat *eq;
4300         struct isl_mat *T, *T2;
4301         struct isl_set *set;
4302         unsigned nparam, n_div;
4303
4304         bset = isl_basic_set_cow(bset);
4305         if (!bset)
4306                 return NULL;
4307
4308         if (bset->n_eq == 0)
4309                 return isl_basic_set_lexmin(bset);
4310
4311         isl_basic_set_gauss(bset, NULL);
4312
4313         nparam = isl_basic_set_dim(bset, isl_dim_param);
4314         n_div = isl_basic_set_dim(bset, isl_dim_div);
4315
4316         for (i = 0, j = n_div - 1; i < bset->n_eq && j >= 0; --j) {
4317                 if (!isl_int_is_zero(bset->eq[i][1 + nparam + j]))
4318                         ++i;
4319         }
4320         if (i == bset->n_eq)
4321                 return isl_basic_set_lexmin(bset);
4322
4323         eq = isl_mat_sub_alloc(bset->ctx, bset->eq, i, bset->n_eq - i,
4324                 0, 1 + nparam);
4325         eq = isl_mat_cow(eq);
4326         T = isl_mat_variable_compression(isl_mat_copy(eq), &T2);
4327         if (T && T->n_col == 0) {
4328                 isl_mat_free(T);
4329                 isl_mat_free(T2);
4330                 isl_mat_free(eq);
4331                 bset = isl_basic_set_set_to_empty(bset);
4332                 return isl_set_from_basic_set(bset);
4333         }
4334         bset = basic_set_parameter_preimage(bset, T);
4335
4336         set = isl_basic_set_lexmin(bset);
4337         set = set_parameter_preimage(set, T2);
4338         set = set_append_equalities(set, eq);
4339         return set;
4340 }
4341
4342 /* Compute an explicit representation for all the existentially
4343  * quantified variables.
4344  * The input and output dimensions are first turned into parameters.
4345  * compute_divs then returns a map with the same parameters and
4346  * no input or output dimensions and the dimension specification
4347  * is reset to that of the input.
4348  */
4349 static struct isl_map *compute_divs(struct isl_basic_map *bmap)
4350 {
4351         struct isl_basic_set *bset;
4352         struct isl_set *set;
4353         struct isl_map *map;
4354         struct isl_dim *dim, *orig_dim = NULL;
4355         unsigned         nparam;
4356         unsigned         n_in;
4357         unsigned         n_out;
4358
4359         bmap = isl_basic_map_cow(bmap);
4360         if (!bmap)
4361                 return NULL;
4362
4363         nparam = isl_basic_map_dim(bmap, isl_dim_param);
4364         n_in = isl_basic_map_dim(bmap, isl_dim_in);
4365         n_out = isl_basic_map_dim(bmap, isl_dim_out);
4366         dim = isl_dim_set_alloc(bmap->ctx, nparam + n_in + n_out, 0);
4367         if (!dim)
4368                 goto error;
4369
4370         orig_dim = bmap->dim;
4371         bmap->dim = dim;
4372         bset = (struct isl_basic_set *)bmap;
4373
4374         set = parameter_compute_divs(bset);
4375         map = (struct isl_map *)set;
4376         map = isl_map_reset_dim(map, orig_dim);
4377
4378         return map;
4379 error:
4380         isl_basic_map_free(bmap);
4381         return NULL;
4382 }
4383
4384 static int basic_map_divs_known(__isl_keep isl_basic_map *bmap)
4385 {
4386         int i;
4387         unsigned off;
4388
4389         if (!bmap)
4390                 return -1;
4391
4392         off = isl_dim_total(bmap->dim);
4393         for (i = 0; i < bmap->n_div; ++i) {
4394                 if (isl_int_is_zero(bmap->div[i][0]))
4395                         return 0;
4396                 isl_assert(bmap->ctx, isl_int_is_zero(bmap->div[i][1+1+off+i]),
4397                                 return -1);
4398         }
4399         return 1;
4400 }
4401
4402 static int map_divs_known(__isl_keep isl_map *map)
4403 {
4404         int i;
4405
4406         if (!map)
4407                 return -1;
4408
4409         for (i = 0; i < map->n; ++i) {
4410                 int known = basic_map_divs_known(map->p[i]);
4411                 if (known <= 0)
4412                         return known;
4413         }
4414
4415         return 1;
4416 }
4417
4418 /* If bmap contains any unknown divs, then compute explicit
4419  * expressions for them.  However, this computation may be
4420  * quite expensive, so first try to remove divs that aren't
4421  * strictly needed.
4422  */
4423 struct isl_map *isl_basic_map_compute_divs(struct isl_basic_map *bmap)
4424 {
4425         int i;
4426         int known;
4427         struct isl_map *map;
4428
4429         known = basic_map_divs_known(bmap);
4430         if (known < 0)
4431                 goto error;
4432         if (known)
4433                 return isl_map_from_basic_map(bmap);
4434
4435         bmap = isl_basic_map_drop_redundant_divs(bmap);
4436
4437         known = basic_map_divs_known(bmap);
4438         if (known < 0)
4439                 goto error;
4440         if (known)
4441                 return isl_map_from_basic_map(bmap);
4442
4443         map = compute_divs(bmap);
4444         return map;
4445 error:
4446         isl_basic_map_free(bmap);
4447         return NULL;
4448 }
4449
4450 struct isl_map *isl_map_compute_divs(struct isl_map *map)
4451 {
4452         int i;
4453         int known;
4454         struct isl_map *res;
4455
4456         if (!map)
4457                 return NULL;
4458         if (map->n == 0)
4459                 return map;
4460
4461         known = map_divs_known(map);
4462         if (known < 0) {
4463                 isl_map_free(map);
4464                 return NULL;
4465         }
4466         if (known)
4467                 return map;
4468
4469         res = isl_basic_map_compute_divs(isl_basic_map_copy(map->p[0]));
4470         for (i = 1 ; i < map->n; ++i) {
4471                 struct isl_map *r2;
4472                 r2 = isl_basic_map_compute_divs(isl_basic_map_copy(map->p[i]));
4473                 if (ISL_F_ISSET(map, ISL_MAP_DISJOINT))
4474                         res = isl_map_union_disjoint(res, r2);
4475                 else
4476                         res = isl_map_union(res, r2);
4477         }
4478         isl_map_free(map);
4479
4480         return res;
4481 }
4482
4483 struct isl_set *isl_basic_set_compute_divs(struct isl_basic_set *bset)
4484 {
4485         return (struct isl_set *)
4486                 isl_basic_map_compute_divs((struct isl_basic_map *)bset);
4487 }
4488
4489 struct isl_set *isl_set_compute_divs(struct isl_set *set)
4490 {
4491         return (struct isl_set *)
4492                 isl_map_compute_divs((struct isl_map *)set);
4493 }
4494
4495 struct isl_set *isl_map_domain(struct isl_map *map)
4496 {
4497         int i;
4498         struct isl_set *set;
4499
4500         if (!map)
4501                 goto error;
4502
4503         map = isl_map_cow(map);
4504         if (!map)
4505                 return NULL;
4506
4507         set = (struct isl_set *)map;
4508         set->dim = isl_dim_domain(set->dim);
4509         if (!set->dim)
4510                 goto error;
4511         for (i = 0; i < map->n; ++i) {
4512                 set->p[i] = isl_basic_map_domain(map->p[i]);
4513                 if (!set->p[i])
4514                         goto error;
4515         }
4516         ISL_F_CLR(set, ISL_MAP_DISJOINT);
4517         ISL_F_CLR(set, ISL_SET_NORMALIZED);
4518         return set;
4519 error:
4520         isl_map_free(map);
4521         return NULL;
4522 }
4523
4524 struct isl_map *isl_map_union_disjoint(
4525                         struct isl_map *map1, struct isl_map *map2)
4526 {
4527         int i;
4528         unsigned flags = 0;
4529         struct isl_map *map = NULL;
4530
4531         if (!map1 || !map2)
4532                 goto error;
4533
4534         if (map1->n == 0) {
4535                 isl_map_free(map1);
4536                 return map2;
4537         }
4538         if (map2->n == 0) {
4539                 isl_map_free(map2);
4540                 return map1;
4541         }
4542
4543         isl_assert(map1->ctx, isl_dim_equal(map1->dim, map2->dim), goto error);
4544
4545         if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) &&
4546             ISL_F_ISSET(map2, ISL_MAP_DISJOINT))
4547                 ISL_FL_SET(flags, ISL_MAP_DISJOINT);
4548
4549         map = isl_map_alloc_dim(isl_dim_copy(map1->dim),
4550                                 map1->n + map2->n, flags);
4551         if (!map)
4552                 goto error;
4553         for (i = 0; i < map1->n; ++i) {
4554                 map = isl_map_add_basic_map(map,
4555                                   isl_basic_map_copy(map1->p[i]));
4556                 if (!map)
4557                         goto error;
4558         }
4559         for (i = 0; i < map2->n; ++i) {
4560                 map = isl_map_add_basic_map(map,
4561                                   isl_basic_map_copy(map2->p[i]));
4562                 if (!map)
4563                         goto error;
4564         }
4565         isl_map_free(map1);
4566         isl_map_free(map2);
4567         return map;
4568 error:
4569         isl_map_free(map);
4570         isl_map_free(map1);
4571         isl_map_free(map2);
4572         return NULL;
4573 }
4574
4575 struct isl_map *isl_map_union(struct isl_map *map1, struct isl_map *map2)
4576 {
4577         map1 = isl_map_union_disjoint(map1, map2);
4578         if (!map1)
4579                 return NULL;
4580         if (map1->n > 1)
4581                 ISL_F_CLR(map1, ISL_MAP_DISJOINT);
4582         return map1;
4583 }
4584
4585 struct isl_set *isl_set_union_disjoint(
4586                         struct isl_set *set1, struct isl_set *set2)
4587 {
4588         return (struct isl_set *)
4589                 isl_map_union_disjoint(
4590                         (struct isl_map *)set1, (struct isl_map *)set2);
4591 }
4592
4593 struct isl_set *isl_set_union(struct isl_set *set1, struct isl_set *set2)
4594 {
4595         return (struct isl_set *)
4596                 isl_map_union((struct isl_map *)set1, (struct isl_map *)set2);
4597 }
4598
4599 struct isl_map *isl_map_intersect_range(
4600                 struct isl_map *map, struct isl_set *set)
4601 {
4602         unsigned flags = 0;
4603         struct isl_map *result;
4604         int i, j;
4605
4606         if (!map || !set)
4607                 goto error;
4608
4609         if (ISL_F_ISSET(map, ISL_MAP_DISJOINT) &&
4610             ISL_F_ISSET(set, ISL_MAP_DISJOINT))
4611                 ISL_FL_SET(flags, ISL_MAP_DISJOINT);
4612
4613         result = isl_map_alloc_dim(isl_dim_copy(map->dim),
4614                                         map->n * set->n, flags);
4615         if (!result)
4616                 goto error;
4617         for (i = 0; i < map->n; ++i)
4618                 for (j = 0; j < set->n; ++j) {
4619                         result = isl_map_add_basic_map(result,
4620                             isl_basic_map_intersect_range(
4621                                 isl_basic_map_copy(map->p[i]),
4622                                 isl_basic_set_copy(set->p[j])));
4623                         if (!result)
4624                                 goto error;
4625                 }
4626         isl_map_free(map);
4627         isl_set_free(set);
4628         return result;
4629 error:
4630         isl_map_free(map);
4631         isl_set_free(set);
4632         return NULL;
4633 }
4634
4635 struct isl_map *isl_map_intersect_domain(
4636                 struct isl_map *map, struct isl_set *set)
4637 {
4638         return isl_map_reverse(
4639                 isl_map_intersect_range(isl_map_reverse(map), set));
4640 }
4641
4642 struct isl_map *isl_map_apply_domain(
4643                 struct isl_map *map1, struct isl_map *map2)
4644 {
4645         if (!map1 || !map2)
4646                 goto error;
4647         map1 = isl_map_reverse(map1);
4648         map1 = isl_map_apply_range(map1, map2);
4649         return isl_map_reverse(map1);
4650 error:
4651         isl_map_free(map1);
4652         isl_map_free(map2);
4653         return NULL;
4654 }
4655
4656 struct isl_map *isl_map_apply_range(
4657                 struct isl_map *map1, struct isl_map *map2)
4658 {
4659         struct isl_dim *dim_result;
4660         struct isl_map *result;
4661         int i, j;
4662
4663         if (!map1 || !map2)
4664                 goto error;
4665
4666         dim_result = isl_dim_join(isl_dim_copy(map1->dim),
4667                                   isl_dim_copy(map2->dim));
4668
4669         result = isl_map_alloc_dim(dim_result, map1->n * map2->n, 0);
4670         if (!result)
4671                 goto error;
4672         for (i = 0; i < map1->n; ++i)
4673                 for (j = 0; j < map2->n; ++j) {
4674                         result = isl_map_add_basic_map(result,
4675                             isl_basic_map_apply_range(
4676                                 isl_basic_map_copy(map1->p[i]),
4677                                 isl_basic_map_copy(map2->p[j])));
4678                         if (!result)
4679                                 goto error;
4680                 }
4681         isl_map_free(map1);
4682         isl_map_free(map2);
4683         if (result && result->n <= 1)
4684                 ISL_F_SET(result, ISL_MAP_DISJOINT);
4685         return result;
4686 error:
4687         isl_map_free(map1);
4688         isl_map_free(map2);
4689         return NULL;
4690 }
4691
4692 /*
4693  * returns range - domain
4694  */
4695 struct isl_basic_set *isl_basic_map_deltas(struct isl_basic_map *bmap)
4696 {
4697         isl_dim *dims;
4698         struct isl_basic_set *bset;
4699         unsigned dim;
4700         unsigned nparam;
4701         int i;
4702
4703         if (!bmap)
4704                 goto error;
4705         dim = isl_basic_map_n_in(bmap);
4706         nparam = isl_basic_map_n_param(bmap);
4707         isl_assert(bmap->ctx, dim == isl_basic_map_n_out(bmap), goto error);
4708         bset = isl_basic_set_from_basic_map(bmap);
4709         bset = isl_basic_set_cow(bset);
4710         dims = isl_basic_set_get_dim(bset);
4711         dims = isl_dim_add(dims, isl_dim_set, dim);
4712         bset = isl_basic_set_extend_dim(bset, dims, 0, dim, 0);
4713         bset = isl_basic_set_swap_vars(bset, 2*dim);
4714         for (i = 0; i < dim; ++i) {
4715                 int j = isl_basic_map_alloc_equality(
4716                                             (struct isl_basic_map *)bset);
4717                 if (j < 0)
4718                         goto error;
4719                 isl_seq_clr(bset->eq[j], 1 + isl_basic_set_total_dim(bset));
4720                 isl_int_set_si(bset->eq[j][1+nparam+i], 1);
4721                 isl_int_set_si(bset->eq[j][1+nparam+dim+i], 1);
4722                 isl_int_set_si(bset->eq[j][1+nparam+2*dim+i], -1);
4723         }
4724         return isl_basic_set_project_out(bset, isl_dim_set, dim, 2*dim);
4725 error:
4726         isl_basic_map_free(bmap);
4727         return NULL;
4728 }
4729
4730 /*
4731  * returns range - domain
4732  */
4733 struct isl_set *isl_map_deltas(struct isl_map *map)
4734 {
4735         int i;
4736         isl_dim *dim;
4737         struct isl_set *result;
4738
4739         if (!map)
4740                 return NULL;
4741
4742         isl_assert(map->ctx, isl_map_n_in(map) == isl_map_n_out(map), goto error);
4743         dim = isl_map_get_dim(map);
4744         dim = isl_dim_domain(dim);
4745         result = isl_set_alloc_dim(dim, map->n, map->flags);
4746         if (!result)
4747                 goto error;
4748         for (i = 0; i < map->n; ++i)
4749                 result = isl_set_add_basic_set(result,
4750                           isl_basic_map_deltas(isl_basic_map_copy(map->p[i])));
4751         isl_map_free(map);
4752         return result;
4753 error:
4754         isl_map_free(map);
4755         return NULL;
4756 }
4757
4758 static struct isl_basic_map *basic_map_identity(struct isl_dim *dims)
4759 {
4760         struct isl_basic_map *bmap;
4761         unsigned nparam;
4762         unsigned dim;
4763         int i;
4764
4765         if (!dims)
4766                 return NULL;
4767
4768         nparam = dims->nparam;
4769         dim = dims->n_out;
4770         bmap = isl_basic_map_alloc_dim(dims, 0, dim, 0);
4771         if (!bmap)
4772                 goto error;
4773
4774         for (i = 0; i < dim; ++i) {
4775                 int j = isl_basic_map_alloc_equality(bmap);
4776                 if (j < 0)
4777                         goto error;
4778                 isl_seq_clr(bmap->eq[j], 1 + isl_basic_map_total_dim(bmap));
4779                 isl_int_set_si(bmap->eq[j][1+nparam+i], 1);
4780                 isl_int_set_si(bmap->eq[j][1+nparam+dim+i], -1);
4781         }
4782         return isl_basic_map_finalize(bmap);
4783 error:
4784         isl_basic_map_free(bmap);
4785         return NULL;
4786 }
4787
4788 struct isl_basic_map *isl_basic_map_identity(struct isl_dim *set_dim)
4789 {
4790         struct isl_dim *dim = isl_dim_map(set_dim);
4791         if (!dim)
4792                 return NULL;
4793         return basic_map_identity(dim);
4794 }
4795
4796 struct isl_basic_map *isl_basic_map_identity_like(struct isl_basic_map *model)
4797 {
4798         if (!model || !model->dim)
4799                 return NULL;
4800         isl_assert(model->ctx,
4801                         model->dim->n_in == model->dim->n_out, return NULL);
4802         return basic_map_identity(isl_dim_copy(model->dim));
4803 }
4804
4805 static struct isl_map *map_identity(struct isl_dim *dim)
4806 {
4807         struct isl_map *map = isl_map_alloc_dim(dim, 1, ISL_MAP_DISJOINT);
4808         return isl_map_add_basic_map(map, basic_map_identity(isl_dim_copy(dim)));
4809 }
4810
4811 struct isl_map *isl_map_identity(struct isl_dim *set_dim)
4812 {
4813         struct isl_dim *dim = isl_dim_map(set_dim);
4814         if (!dim)
4815                 return NULL;
4816         return map_identity(dim);
4817 }
4818
4819 struct isl_map *isl_map_identity_like(struct isl_map *model)
4820 {
4821         if (!model || !model->dim)
4822                 return NULL;
4823         isl_assert(model->ctx,
4824                         model->dim->n_in == model->dim->n_out, return NULL);
4825         return map_identity(isl_dim_copy(model->dim));
4826 }
4827
4828 struct isl_map *isl_map_identity_like_basic_map(struct isl_basic_map *model)
4829 {
4830         if (!model || !model->dim)
4831                 return NULL;
4832         isl_assert(model->ctx,
4833                         model->dim->n_in == model->dim->n_out, return NULL);
4834         return map_identity(isl_dim_copy(model->dim));
4835 }
4836
4837 /* Construct a basic set with all set dimensions having only non-negative
4838  * values.
4839  */
4840 struct isl_basic_set *isl_basic_set_positive_orthant(struct isl_dim *dims)
4841 {
4842         int i;
4843         unsigned nparam;
4844         unsigned dim;
4845         struct isl_basic_set *bset;
4846
4847         if (!dims)
4848                 return NULL;
4849         nparam = dims->nparam;
4850         dim = dims->n_out;
4851         bset = isl_basic_set_alloc_dim(dims, 0, 0, dim);
4852         if (!bset)
4853                 return NULL;
4854         for (i = 0; i < dim; ++i) {
4855                 int k = isl_basic_set_alloc_inequality(bset);
4856                 if (k < 0)
4857                         goto error;
4858                 isl_seq_clr(bset->ineq[k], 1 + isl_basic_set_total_dim(bset));
4859                 isl_int_set_si(bset->ineq[k][1 + nparam + i], 1);
4860         }
4861         return bset;
4862 error:
4863         isl_basic_set_free(bset);
4864         return NULL;
4865 }
4866
4867 __isl_give isl_set *isl_set_split_dims(__isl_take isl_set *set,
4868         enum isl_dim_type type, unsigned first, unsigned n)
4869 {
4870         int i;
4871         isl_basic_set *nonneg = NULL;
4872         isl_basic_set *neg = NULL;
4873
4874         if (!set)
4875                 return NULL;
4876         if (n == 0)
4877                 return set;
4878
4879         isl_assert(set->ctx, first + n <= isl_set_dim(set, type), goto error);
4880
4881         for (i = 0; i < n; ++i) {
4882                 int k;
4883
4884                 neg = NULL;
4885                 nonneg = isl_basic_set_alloc_dim(isl_set_get_dim(set), 0, 0, 1);
4886                 k = isl_basic_set_alloc_inequality(nonneg);
4887                 if (k < 0)
4888                         goto error;
4889                 isl_seq_clr(nonneg->ineq[k], 1 + isl_basic_set_total_dim(nonneg));
4890                 isl_int_set_si(nonneg->ineq[k][pos(set->dim, type) + first + i], 1);
4891
4892                 neg = isl_basic_set_alloc_dim(isl_set_get_dim(set), 0, 0, 1);
4893                 k = isl_basic_set_alloc_inequality(neg);
4894                 if (k < 0)
4895                         goto error;
4896                 isl_seq_clr(neg->ineq[k], 1 + isl_basic_set_total_dim(neg));
4897                 isl_int_set_si(neg->ineq[k][0], -1);
4898                 isl_int_set_si(neg->ineq[k][pos(set->dim, type) + first + i], -1);
4899
4900                 set = isl_set_intersect(set, isl_basic_set_union(nonneg, neg));
4901         }
4902
4903         return set;
4904 error:
4905         isl_basic_set_free(nonneg);
4906         isl_basic_set_free(neg);
4907         isl_set_free(set);
4908         return NULL;
4909 }
4910
4911 int isl_set_is_equal(struct isl_set *set1, struct isl_set *set2)
4912 {
4913         return isl_map_is_equal((struct isl_map *)set1, (struct isl_map *)set2);
4914 }
4915
4916 int isl_basic_map_is_subset(
4917                 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
4918 {
4919         int is_subset;
4920         struct isl_map *map1;
4921         struct isl_map *map2;
4922
4923         if (!bmap1 || !bmap2)
4924                 return -1;
4925
4926         map1 = isl_map_from_basic_map(isl_basic_map_copy(bmap1));
4927         map2 = isl_map_from_basic_map(isl_basic_map_copy(bmap2));
4928
4929         is_subset = isl_map_is_subset(map1, map2);
4930
4931         isl_map_free(map1);
4932         isl_map_free(map2);
4933
4934         return is_subset;
4935 }
4936
4937 int isl_basic_map_is_equal(
4938                 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
4939 {
4940         int is_subset;
4941
4942         if (!bmap1 || !bmap2)
4943                 return -1;
4944         is_subset = isl_basic_map_is_subset(bmap1, bmap2);
4945         if (is_subset != 1)
4946                 return is_subset;
4947         is_subset = isl_basic_map_is_subset(bmap2, bmap1);
4948         return is_subset;
4949 }
4950
4951 int isl_basic_set_is_equal(
4952                 struct isl_basic_set *bset1, struct isl_basic_set *bset2)
4953 {
4954         return isl_basic_map_is_equal(
4955                 (struct isl_basic_map *)bset1, (struct isl_basic_map *)bset2);
4956 }
4957
4958 int isl_map_is_empty(struct isl_map *map)
4959 {
4960         int i;
4961         int is_empty;
4962
4963         if (!map)
4964                 return -1;
4965         for (i = 0; i < map->n; ++i) {
4966                 is_empty = isl_basic_map_is_empty(map->p[i]);
4967                 if (is_empty < 0)
4968                         return -1;
4969                 if (!is_empty)
4970                         return 0;
4971         }
4972         return 1;
4973 }
4974
4975 int isl_map_fast_is_empty(struct isl_map *map)
4976 {
4977         return map->n == 0;
4978 }
4979
4980 int isl_set_fast_is_empty(struct isl_set *set)
4981 {
4982         return set->n == 0;
4983 }
4984
4985 int isl_set_is_empty(struct isl_set *set)
4986 {
4987         return isl_map_is_empty((struct isl_map *)set);
4988 }
4989
4990 int isl_map_is_equal(struct isl_map *map1, struct isl_map *map2)
4991 {
4992         int is_subset;
4993
4994         if (!map1 || !map2)
4995                 return -1;
4996         is_subset = isl_map_is_subset(map1, map2);
4997         if (is_subset != 1)
4998                 return is_subset;
4999         is_subset = isl_map_is_subset(map2, map1);
5000         return is_subset;
5001 }
5002
5003 int isl_basic_map_is_strict_subset(
5004                 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
5005 {
5006         int is_subset;
5007
5008         if (!bmap1 || !bmap2)
5009                 return -1;
5010         is_subset = isl_basic_map_is_subset(bmap1, bmap2);
5011         if (is_subset != 1)
5012                 return is_subset;
5013         is_subset = isl_basic_map_is_subset(bmap2, bmap1);
5014         if (is_subset == -1)
5015                 return is_subset;
5016         return !is_subset;
5017 }
5018
5019 int isl_map_is_strict_subset(struct isl_map *map1, struct isl_map *map2)
5020 {
5021         int is_subset;
5022
5023         if (!map1 || !map2)
5024                 return -1;
5025         is_subset = isl_map_is_subset(map1, map2);
5026         if (is_subset != 1)
5027                 return is_subset;
5028         is_subset = isl_map_is_subset(map2, map1);
5029         if (is_subset == -1)
5030                 return is_subset;
5031         return !is_subset;
5032 }
5033
5034 int isl_set_is_strict_subset(__isl_keep isl_set *set1, __isl_keep isl_set *set2)
5035 {
5036         return isl_map_is_strict_subset((isl_map *)set1, (isl_map *)set2);
5037 }
5038
5039 int isl_basic_map_is_universe(struct isl_basic_map *bmap)
5040 {
5041         if (!bmap)
5042                 return -1;
5043         return bmap->n_eq == 0 && bmap->n_ineq == 0;
5044 }
5045
5046 int isl_basic_set_is_universe(struct isl_basic_set *bset)
5047 {
5048         if (!bset)
5049                 return -1;
5050         return bset->n_eq == 0 && bset->n_ineq == 0;
5051 }
5052
5053 int isl_map_fast_is_universe(__isl_keep isl_map *map)
5054 {
5055         if (!map)
5056                 return -1;
5057
5058         return map->n == 1 && isl_basic_map_is_universe(map->p[0]);
5059 }
5060
5061 int isl_set_fast_is_universe(__isl_keep isl_set *set)
5062 {
5063         return isl_map_fast_is_universe((isl_map *) set);
5064 }
5065
5066 int isl_basic_map_is_empty(struct isl_basic_map *bmap)
5067 {
5068         struct isl_basic_set *bset = NULL;
5069         struct isl_vec *sample = NULL;
5070         int empty;
5071         unsigned total;
5072
5073         if (!bmap)
5074                 return -1;
5075
5076         if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
5077                 return 1;
5078
5079         if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL)) {
5080                 struct isl_basic_map *copy = isl_basic_map_copy(bmap);
5081                 copy = isl_basic_map_convex_hull(copy);
5082                 empty = ISL_F_ISSET(copy, ISL_BASIC_MAP_EMPTY);
5083                 isl_basic_map_free(copy);
5084                 return empty;
5085         }
5086
5087         total = 1 + isl_basic_map_total_dim(bmap);
5088         if (bmap->sample && bmap->sample->size == total) {
5089                 int contains = isl_basic_map_contains(bmap, bmap->sample);
5090                 if (contains < 0)
5091                         return -1;
5092                 if (contains)
5093                         return 0;
5094         }
5095         isl_vec_free(bmap->sample);
5096         bmap->sample = NULL;
5097         bset = isl_basic_map_underlying_set(isl_basic_map_copy(bmap));
5098         if (!bset)
5099                 return -1;
5100         sample = isl_basic_set_sample_vec(bset);
5101         if (!sample)
5102                 return -1;
5103         empty = sample->size == 0;
5104         isl_vec_free(bmap->sample);
5105         bmap->sample = sample;
5106         if (empty)
5107                 ISL_F_SET(bmap, ISL_BASIC_MAP_EMPTY);
5108
5109         return empty;
5110 }
5111
5112 int isl_basic_map_fast_is_empty(struct isl_basic_map *bmap)
5113 {
5114         if (!bmap)
5115                 return -1;
5116         return ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY);
5117 }
5118
5119 int isl_basic_set_fast_is_empty(struct isl_basic_set *bset)
5120 {
5121         if (!bset)
5122                 return -1;
5123         return ISL_F_ISSET(bset, ISL_BASIC_SET_EMPTY);
5124 }
5125
5126 int isl_basic_set_is_empty(struct isl_basic_set *bset)
5127 {
5128         return isl_basic_map_is_empty((struct isl_basic_map *)bset);
5129 }
5130
5131 struct isl_map *isl_basic_map_union(
5132         struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
5133 {
5134         struct isl_map *map;
5135         if (!bmap1 || !bmap2)
5136                 return NULL;
5137
5138         isl_assert(bmap1->ctx, isl_dim_equal(bmap1->dim, bmap2->dim), goto error);
5139
5140         map = isl_map_alloc_dim(isl_dim_copy(bmap1->dim), 2, 0);
5141         if (!map)
5142                 goto error;
5143         map = isl_map_add_basic_map(map, bmap1);
5144         map = isl_map_add_basic_map(map, bmap2);
5145         return map;
5146 error:
5147         isl_basic_map_free(bmap1);
5148         isl_basic_map_free(bmap2);
5149         return NULL;
5150 }
5151
5152 struct isl_set *isl_basic_set_union(
5153                 struct isl_basic_set *bset1, struct isl_basic_set *bset2)
5154 {
5155         return (struct isl_set *)isl_basic_map_union(
5156                                             (struct isl_basic_map *)bset1,
5157                                             (struct isl_basic_map *)bset2);
5158 }
5159
5160 /* Order divs such that any div only depends on previous divs */
5161 struct isl_basic_map *isl_basic_map_order_divs(struct isl_basic_map *bmap)
5162 {
5163         int i;
5164         unsigned off = isl_dim_total(bmap->dim);
5165
5166         for (i = 0; i < bmap->n_div; ++i) {
5167                 int pos;
5168                 if (isl_int_is_zero(bmap->div[i][0]))
5169                         continue;
5170                 pos = isl_seq_first_non_zero(bmap->div[i]+1+1+off+i,
5171                                                             bmap->n_div-i);
5172                 if (pos == -1)
5173                         continue;
5174                 isl_basic_map_swap_div(bmap, i, i + pos);
5175                 --i;
5176         }
5177         return bmap;
5178 }
5179
5180 struct isl_basic_set *isl_basic_set_order_divs(struct isl_basic_set *bset)
5181 {
5182         return (struct isl_basic_set *)
5183                 isl_basic_map_order_divs((struct isl_basic_map *)bset);
5184 }
5185
5186 __isl_give isl_map *isl_map_order_divs(__isl_take isl_map *map)
5187 {
5188         int i;
5189
5190         if (!map)
5191                 return 0;
5192
5193         for (i = 0; i < map->n; ++i) {
5194                 map->p[i] = isl_basic_map_order_divs(map->p[i]);
5195                 if (!map->p[i])
5196                         goto error;
5197         }
5198
5199         return map;
5200 error:
5201         isl_map_free(map);
5202         return NULL;
5203 }
5204
5205 /* Look for a div in dst that corresponds to the div "div" in src.
5206  * The divs before "div" in src and dst are assumed to be the same.
5207  *
5208  * Returns -1 if no corresponding div was found and the position
5209  * of the corresponding div in dst otherwise.
5210  */
5211 static int find_div(struct isl_basic_map *dst,
5212                         struct isl_basic_map *src, unsigned div)
5213 {
5214         int i;
5215
5216         unsigned total = isl_dim_total(src->dim);
5217
5218         isl_assert(dst->ctx, div <= dst->n_div, return -1);
5219         for (i = div; i < dst->n_div; ++i)
5220                 if (isl_seq_eq(dst->div[i], src->div[div], 1+1+total+div) &&
5221                     isl_seq_first_non_zero(dst->div[i]+1+1+total+div,
5222                                                 dst->n_div - div) == -1)
5223                         return i;
5224         return -1;
5225 }
5226
5227 struct isl_basic_map *isl_basic_map_align_divs(
5228                 struct isl_basic_map *dst, struct isl_basic_map *src)
5229 {
5230         int i;
5231         unsigned total = isl_dim_total(src->dim);
5232
5233         if (!dst || !src)
5234                 goto error;
5235
5236         if (src->n_div == 0)
5237                 return dst;
5238
5239         for (i = 0; i < src->n_div; ++i)
5240                 isl_assert(src->ctx, !isl_int_is_zero(src->div[i][0]), goto error);
5241
5242         src = isl_basic_map_order_divs(src);
5243         dst = isl_basic_map_cow(dst);
5244         dst = isl_basic_map_extend_dim(dst, isl_dim_copy(dst->dim),
5245                         src->n_div, 0, 2 * src->n_div);
5246         if (!dst)
5247                 return NULL;
5248         for (i = 0; i < src->n_div; ++i) {
5249                 int j = find_div(dst, src, i);
5250                 if (j < 0) {
5251                         j = isl_basic_map_alloc_div(dst);
5252                         if (j < 0)
5253                                 goto error;
5254                         isl_seq_cpy(dst->div[j], src->div[i], 1+1+total+i);
5255                         isl_seq_clr(dst->div[j]+1+1+total+i, dst->n_div - i);
5256                         if (isl_basic_map_add_div_constraints(dst, j) < 0)
5257                                 goto error;
5258                 }
5259                 if (j != i)
5260                         isl_basic_map_swap_div(dst, i, j);
5261         }
5262         return dst;
5263 error:
5264         isl_basic_map_free(dst);
5265         return NULL;
5266 }
5267
5268 struct isl_basic_set *isl_basic_set_align_divs(
5269                 struct isl_basic_set *dst, struct isl_basic_set *src)
5270 {
5271         return (struct isl_basic_set *)isl_basic_map_align_divs(
5272                 (struct isl_basic_map *)dst, (struct isl_basic_map *)src);
5273 }
5274
5275 struct isl_map *isl_map_align_divs(struct isl_map *map)
5276 {
5277         int i;
5278
5279         if (!map)
5280                 return NULL;
5281         if (map->n == 0)
5282                 return map;
5283         map = isl_map_compute_divs(map);
5284         map = isl_map_cow(map);
5285         if (!map)
5286                 return NULL;
5287
5288         for (i = 1; i < map->n; ++i)
5289                 map->p[0] = isl_basic_map_align_divs(map->p[0], map->p[i]);
5290         for (i = 1; i < map->n; ++i)
5291                 map->p[i] = isl_basic_map_align_divs(map->p[i], map->p[0]);
5292
5293         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
5294         return map;
5295 }
5296
5297 struct isl_set *isl_set_align_divs(struct isl_set *set)
5298 {
5299         return (struct isl_set *)isl_map_align_divs((struct isl_map *)set);
5300 }
5301
5302 struct isl_set *isl_set_apply(struct isl_set *set, struct isl_map *map)
5303 {
5304         if (!set || !map)
5305                 goto error;
5306         isl_assert(set->ctx, isl_map_compatible_domain(map, set), goto error);
5307         map = isl_map_intersect_domain(map, set);
5308         set = isl_map_range(map);
5309         return set;
5310 error:
5311         isl_set_free(set);
5312         isl_map_free(map);
5313         return NULL;
5314 }
5315
5316 /* There is no need to cow as removing empty parts doesn't change
5317  * the meaning of the set.
5318  */
5319 struct isl_map *isl_map_remove_empty_parts(struct isl_map *map)
5320 {
5321         int i;
5322
5323         if (!map)
5324                 return NULL;
5325
5326         for (i = map->n-1; i >= 0; --i) {
5327                 if (!ISL_F_ISSET(map->p[i], ISL_BASIC_MAP_EMPTY))
5328                         continue;
5329                 isl_basic_map_free(map->p[i]);
5330                 if (i != map->n-1) {
5331                         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
5332                         map->p[i] = map->p[map->n-1];
5333                 }
5334                 map->n--;
5335         }
5336
5337         return map;
5338 }
5339
5340 struct isl_set *isl_set_remove_empty_parts(struct isl_set *set)
5341 {
5342         return (struct isl_set *)
5343                 isl_map_remove_empty_parts((struct isl_map *)set);
5344 }
5345
5346 struct isl_basic_map *isl_map_copy_basic_map(struct isl_map *map)
5347 {
5348         struct isl_basic_map *bmap;
5349         if (!map || map->n == 0)
5350                 return NULL;
5351         bmap = map->p[map->n-1];
5352         isl_assert(map->ctx, ISL_F_ISSET(bmap, ISL_BASIC_SET_FINAL), return NULL);
5353         return isl_basic_map_copy(bmap);
5354 }
5355
5356 struct isl_basic_set *isl_set_copy_basic_set(struct isl_set *set)
5357 {
5358         return (struct isl_basic_set *)
5359                 isl_map_copy_basic_map((struct isl_map *)set);
5360 }
5361
5362 __isl_give isl_map *isl_map_drop_basic_map(__isl_take isl_map *map,
5363                                                 __isl_keep isl_basic_map *bmap)
5364 {
5365         int i;
5366
5367         if (!map || !bmap)
5368                 goto error;
5369         for (i = map->n-1; i >= 0; --i) {
5370                 if (map->p[i] != bmap)
5371                         continue;
5372                 map = isl_map_cow(map);
5373                 if (!map)
5374                         goto error;
5375                 isl_basic_map_free(map->p[i]);
5376                 if (i != map->n-1) {
5377                         ISL_F_CLR(map, ISL_SET_NORMALIZED);
5378                         map->p[i] = map->p[map->n-1];
5379                 }
5380                 map->n--;
5381                 return map;
5382         }
5383         return map;
5384 error:
5385         isl_map_free(map);
5386         return NULL;
5387 }
5388
5389 struct isl_set *isl_set_drop_basic_set(struct isl_set *set,
5390                                                 struct isl_basic_set *bset)
5391 {
5392         return (struct isl_set *)isl_map_drop_basic_map((struct isl_map *)set,
5393                                                 (struct isl_basic_map *)bset);
5394 }
5395
5396 /* Given two basic sets bset1 and bset2, compute the maximal difference
5397  * between the values of dimension pos in bset1 and those in bset2
5398  * for any common value of the parameters and dimensions preceding pos.
5399  */
5400 static enum isl_lp_result basic_set_maximal_difference_at(
5401         __isl_keep isl_basic_set *bset1, __isl_keep isl_basic_set *bset2,
5402         int pos, isl_int *opt)
5403 {
5404         struct isl_dim *dims;
5405         struct isl_basic_map *bmap1 = NULL;
5406         struct isl_basic_map *bmap2 = NULL;
5407         struct isl_ctx *ctx;
5408         struct isl_vec *obj;
5409         unsigned total;
5410         unsigned nparam;
5411         unsigned dim1, dim2;
5412         enum isl_lp_result res;
5413
5414         if (!bset1 || !bset2)
5415                 return isl_lp_error;
5416
5417         nparam = isl_basic_set_n_param(bset1);
5418         dim1 = isl_basic_set_n_dim(bset1);
5419         dim2 = isl_basic_set_n_dim(bset2);
5420         dims = isl_dim_alloc(bset1->ctx, nparam, pos, dim1 - pos);
5421         bmap1 = isl_basic_map_from_basic_set(isl_basic_set_copy(bset1), dims);
5422         dims = isl_dim_alloc(bset2->ctx, nparam, pos, dim2 - pos);
5423         bmap2 = isl_basic_map_from_basic_set(isl_basic_set_copy(bset2), dims);
5424         if (!bmap1 || !bmap2)
5425                 goto error;
5426         bmap1 = isl_basic_map_cow(bmap1);
5427         bmap1 = isl_basic_map_extend(bmap1, nparam,
5428                         pos, (dim1 - pos) + (dim2 - pos),
5429                         bmap2->n_div, bmap2->n_eq, bmap2->n_ineq);
5430         bmap1 = add_constraints(bmap1, bmap2, 0, dim1 - pos);
5431         if (!bmap1)
5432                 goto error;
5433         total = isl_basic_map_total_dim(bmap1);
5434         ctx = bmap1->ctx;
5435         obj = isl_vec_alloc(ctx, 1 + total);
5436         isl_seq_clr(obj->block.data, 1 + total);
5437         isl_int_set_si(obj->block.data[1+nparam+pos], 1);
5438         isl_int_set_si(obj->block.data[1+nparam+pos+(dim1-pos)], -1);
5439         if (!obj)
5440                 goto error;
5441         res = isl_basic_map_solve_lp(bmap1, 1, obj->block.data, ctx->one,
5442                                         opt, NULL, NULL);
5443         isl_basic_map_free(bmap1);
5444         isl_vec_free(obj);
5445         return res;
5446 error:
5447         isl_basic_map_free(bmap1);
5448         isl_basic_map_free(bmap2);
5449         return isl_lp_error;
5450 }
5451
5452 /* Given two _disjoint_ basic sets bset1 and bset2, check whether
5453  * for any common value of the parameters and dimensions preceding pos
5454  * in both basic sets, the values of dimension pos in bset1 are
5455  * smaller or larger than those in bset2.
5456  *
5457  * Returns
5458  *       1 if bset1 follows bset2
5459  *      -1 if bset1 precedes bset2
5460  *       0 if bset1 and bset2 are incomparable
5461  *      -2 if some error occurred.
5462  */
5463 int isl_basic_set_compare_at(struct isl_basic_set *bset1,
5464         struct isl_basic_set *bset2, int pos)
5465 {
5466         isl_int opt;
5467         enum isl_lp_result res;
5468         int cmp;
5469
5470         isl_int_init(opt);
5471
5472         res = basic_set_maximal_difference_at(bset1, bset2, pos, &opt);
5473
5474         if (res == isl_lp_empty)
5475                 cmp = 0;
5476         else if ((res == isl_lp_ok && isl_int_is_pos(opt)) ||
5477                   res == isl_lp_unbounded)
5478                 cmp = 1;
5479         else if (res == isl_lp_ok && isl_int_is_neg(opt))
5480                 cmp = -1;
5481         else
5482                 cmp = -2;
5483
5484         isl_int_clear(opt);
5485         return cmp;
5486 }
5487
5488 /* Given two basic sets bset1 and bset2, check whether
5489  * for any common value of the parameters and dimensions preceding pos
5490  * there is a value of dimension pos in bset1 that is larger
5491  * than a value of the same dimension in bset2.
5492  *
5493  * Return
5494  *       1 if there exists such a pair
5495  *       0 if there is no such pair, but there is a pair of equal values
5496  *      -1 otherwise
5497  *      -2 if some error occurred.
5498  */
5499 int isl_basic_set_follows_at(__isl_keep isl_basic_set *bset1,
5500         __isl_keep isl_basic_set *bset2, int pos)
5501 {
5502         isl_int opt;
5503         enum isl_lp_result res;
5504         int cmp;
5505
5506         isl_int_init(opt);
5507
5508         res = basic_set_maximal_difference_at(bset1, bset2, pos, &opt);
5509
5510         if (res == isl_lp_empty)
5511                 cmp = -1;
5512         else if ((res == isl_lp_ok && isl_int_is_pos(opt)) ||
5513                   res == isl_lp_unbounded)
5514                 cmp = 1;
5515         else if (res == isl_lp_ok && isl_int_is_neg(opt))
5516                 cmp = -1;
5517         else if (res == isl_lp_ok)
5518                 cmp = 0;
5519         else
5520                 cmp = -2;
5521
5522         isl_int_clear(opt);
5523         return cmp;
5524 }
5525
5526 /* Given two sets set1 and set2, check whether
5527  * for any common value of the parameters and dimensions preceding pos
5528  * there is a value of dimension pos in set1 that is larger
5529  * than a value of the same dimension in set2.
5530  *
5531  * Return
5532  *       1 if there exists such a pair
5533  *       0 if there is no such pair, but there is a pair of equal values
5534  *      -1 otherwise
5535  *      -2 if some error occurred.
5536  */
5537 int isl_set_follows_at(__isl_keep isl_set *set1,
5538         __isl_keep isl_set *set2, int pos)
5539 {
5540         int i, j;
5541         int follows = -1;
5542
5543         if (!set1 || !set2)
5544                 return -2;
5545
5546         for (i = 0; i < set1->n; ++i)
5547                 for (j = 0; j < set2->n; ++j) {
5548                         int f;
5549                         f = isl_basic_set_follows_at(set1->p[i], set2->p[j], pos);
5550                         if (f == 1 || f == -2)
5551                                 return f;
5552                         if (f > follows)
5553                                 follows = f;
5554                 }
5555
5556         return follows;
5557 }
5558
5559 static int isl_basic_map_fast_has_fixed_var(struct isl_basic_map *bmap,
5560         unsigned pos, isl_int *val)
5561 {
5562         int i;
5563         int d;
5564         unsigned total;
5565
5566         if (!bmap)
5567                 return -1;
5568         total = isl_basic_map_total_dim(bmap);
5569         for (i = 0, d = total-1; i < bmap->n_eq && d+1 > pos; ++i) {
5570                 for (; d+1 > pos; --d)
5571                         if (!isl_int_is_zero(bmap->eq[i][1+d]))
5572                                 break;
5573                 if (d != pos)
5574                         continue;
5575                 if (isl_seq_first_non_zero(bmap->eq[i]+1, d) != -1)
5576                         return 0;
5577                 if (isl_seq_first_non_zero(bmap->eq[i]+1+d+1, total-d-1) != -1)
5578                         return 0;
5579                 if (!isl_int_is_one(bmap->eq[i][1+d]))
5580                         return 0;
5581                 if (val)
5582                         isl_int_neg(*val, bmap->eq[i][0]);
5583                 return 1;
5584         }
5585         return 0;
5586 }
5587
5588 static int isl_map_fast_has_fixed_var(struct isl_map *map,
5589         unsigned pos, isl_int *val)
5590 {
5591         int i;
5592         isl_int v;
5593         isl_int tmp;
5594         int fixed;
5595
5596         if (!map)
5597                 return -1;
5598         if (map->n == 0)
5599                 return 0;
5600         if (map->n == 1)
5601                 return isl_basic_map_fast_has_fixed_var(map->p[0], pos, val);
5602         isl_int_init(v);
5603         isl_int_init(tmp);
5604         fixed = isl_basic_map_fast_has_fixed_var(map->p[0], pos, &v);
5605         for (i = 1; fixed == 1 && i < map->n; ++i) {
5606                 fixed = isl_basic_map_fast_has_fixed_var(map->p[i], pos, &tmp);
5607                 if (fixed == 1 && isl_int_ne(tmp, v))
5608                         fixed = 0;
5609         }
5610         if (val)
5611                 isl_int_set(*val, v);
5612         isl_int_clear(tmp);
5613         isl_int_clear(v);
5614         return fixed;
5615 }
5616
5617 static int isl_basic_set_fast_has_fixed_var(struct isl_basic_set *bset,
5618         unsigned pos, isl_int *val)
5619 {
5620         return isl_basic_map_fast_has_fixed_var((struct isl_basic_map *)bset,
5621                                                 pos, val);
5622 }
5623
5624 static int isl_set_fast_has_fixed_var(struct isl_set *set, unsigned pos,
5625         isl_int *val)
5626 {
5627         return isl_map_fast_has_fixed_var((struct isl_map *)set, pos, val);
5628 }
5629
5630 int isl_basic_map_fast_is_fixed(struct isl_basic_map *bmap,
5631         enum isl_dim_type type, unsigned pos, isl_int *val)
5632 {
5633         if (pos >= isl_basic_map_dim(bmap, type))
5634                 return -1;
5635         return isl_basic_map_fast_has_fixed_var(bmap,
5636                 isl_basic_map_offset(bmap, type) - 1 + pos, val);
5637 }
5638
5639 int isl_map_fast_is_fixed(struct isl_map *map,
5640         enum isl_dim_type type, unsigned pos, isl_int *val)
5641 {
5642         if (pos >= isl_map_dim(map, type))
5643                 return -1;
5644         return isl_map_fast_has_fixed_var(map,
5645                 map_offset(map, type) - 1 + pos, val);
5646 }
5647
5648 /* Check if dimension dim has fixed value and if so and if val is not NULL,
5649  * then return this fixed value in *val.
5650  */
5651 int isl_basic_set_fast_dim_is_fixed(struct isl_basic_set *bset, unsigned dim,
5652         isl_int *val)
5653 {
5654         return isl_basic_set_fast_has_fixed_var(bset,
5655                                         isl_basic_set_n_param(bset) + dim, val);
5656 }
5657
5658 /* Check if dimension dim has fixed value and if so and if val is not NULL,
5659  * then return this fixed value in *val.
5660  */
5661 int isl_set_fast_dim_is_fixed(struct isl_set *set, unsigned dim, isl_int *val)
5662 {
5663         return isl_set_fast_has_fixed_var(set, isl_set_n_param(set) + dim, val);
5664 }
5665
5666 /* Check if input variable in has fixed value and if so and if val is not NULL,
5667  * then return this fixed value in *val.
5668  */
5669 int isl_map_fast_input_is_fixed(struct isl_map *map, unsigned in, isl_int *val)
5670 {
5671         return isl_map_fast_has_fixed_var(map, isl_map_n_param(map) + in, val);
5672 }
5673
5674 /* Check if dimension dim has an (obvious) fixed lower bound and if so
5675  * and if val is not NULL, then return this lower bound in *val.
5676  */
5677 int isl_basic_set_fast_dim_has_fixed_lower_bound(struct isl_basic_set *bset,
5678         unsigned dim, isl_int *val)
5679 {
5680         int i, i_eq = -1, i_ineq = -1;
5681         isl_int *c;
5682         unsigned total;
5683         unsigned nparam;
5684
5685         if (!bset)
5686                 return -1;
5687         total = isl_basic_set_total_dim(bset);
5688         nparam = isl_basic_set_n_param(bset);
5689         for (i = 0; i < bset->n_eq; ++i) {
5690                 if (isl_int_is_zero(bset->eq[i][1+nparam+dim]))
5691                         continue;
5692                 if (i_eq != -1)
5693                         return 0;
5694                 i_eq = i;
5695         }
5696         for (i = 0; i < bset->n_ineq; ++i) {
5697                 if (!isl_int_is_pos(bset->ineq[i][1+nparam+dim]))
5698                         continue;
5699                 if (i_eq != -1 || i_ineq != -1)
5700                         return 0;
5701                 i_ineq = i;
5702         }
5703         if (i_eq == -1 && i_ineq == -1)
5704                 return 0;
5705         c = i_eq != -1 ? bset->eq[i_eq] : bset->ineq[i_ineq];
5706         /* The coefficient should always be one due to normalization. */
5707         if (!isl_int_is_one(c[1+nparam+dim]))
5708                 return 0;
5709         if (isl_seq_first_non_zero(c+1, nparam+dim) != -1)
5710                 return 0;
5711         if (isl_seq_first_non_zero(c+1+nparam+dim+1,
5712                                         total - nparam - dim - 1) != -1)
5713                 return 0;
5714         if (val)
5715                 isl_int_neg(*val, c[0]);
5716         return 1;
5717 }
5718
5719 int isl_set_fast_dim_has_fixed_lower_bound(struct isl_set *set,
5720         unsigned dim, isl_int *val)
5721 {
5722         int i;
5723         isl_int v;
5724         isl_int tmp;
5725         int fixed;
5726
5727         if (!set)
5728                 return -1;
5729         if (set->n == 0)
5730                 return 0;
5731         if (set->n == 1)
5732                 return isl_basic_set_fast_dim_has_fixed_lower_bound(set->p[0],
5733                                                                 dim, val);
5734         isl_int_init(v);
5735         isl_int_init(tmp);
5736         fixed = isl_basic_set_fast_dim_has_fixed_lower_bound(set->p[0],
5737                                                                 dim, &v);
5738         for (i = 1; fixed == 1 && i < set->n; ++i) {
5739                 fixed = isl_basic_set_fast_dim_has_fixed_lower_bound(set->p[i],
5740                                                                 dim, &tmp);
5741                 if (fixed == 1 && isl_int_ne(tmp, v))
5742                         fixed = 0;
5743         }
5744         if (val)
5745                 isl_int_set(*val, v);
5746         isl_int_clear(tmp);
5747         isl_int_clear(v);
5748         return fixed;
5749 }
5750
5751 struct constraint {
5752         unsigned        size;
5753         isl_int         *c;
5754 };
5755
5756 static int qsort_constraint_cmp(const void *p1, const void *p2)
5757 {
5758         const struct constraint *c1 = (const struct constraint *)p1;
5759         const struct constraint *c2 = (const struct constraint *)p2;
5760         unsigned size = isl_min(c1->size, c2->size);
5761         return isl_seq_cmp(c1->c, c2->c, size);
5762 }
5763
5764 static struct isl_basic_map *isl_basic_map_sort_constraints(
5765         struct isl_basic_map *bmap)
5766 {
5767         int i;
5768         struct constraint *c;
5769         unsigned total;
5770
5771         if (!bmap)
5772                 return NULL;
5773         total = isl_basic_map_total_dim(bmap);
5774         c = isl_alloc_array(bmap->ctx, struct constraint, bmap->n_ineq);
5775         if (!c)
5776                 goto error;
5777         for (i = 0; i < bmap->n_ineq; ++i) {
5778                 c[i].size = total;
5779                 c[i].c = bmap->ineq[i];
5780         }
5781         qsort(c, bmap->n_ineq, sizeof(struct constraint), qsort_constraint_cmp);
5782         for (i = 0; i < bmap->n_ineq; ++i)
5783                 bmap->ineq[i] = c[i].c;
5784         free(c);
5785         return bmap;
5786 error:
5787         isl_basic_map_free(bmap);
5788         return NULL;
5789 }
5790
5791 struct isl_basic_map *isl_basic_map_normalize(struct isl_basic_map *bmap)
5792 {
5793         if (!bmap)
5794                 return NULL;
5795         if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_NORMALIZED))
5796                 return bmap;
5797         bmap = isl_basic_map_convex_hull(bmap);
5798         bmap = isl_basic_map_sort_constraints(bmap);
5799         ISL_F_SET(bmap, ISL_BASIC_MAP_NORMALIZED);
5800         return bmap;
5801 }
5802
5803 struct isl_basic_set *isl_basic_set_normalize(struct isl_basic_set *bset)
5804 {
5805         return (struct isl_basic_set *)isl_basic_map_normalize(
5806                                                 (struct isl_basic_map *)bset);
5807 }
5808
5809 static int isl_basic_map_fast_cmp(const struct isl_basic_map *bmap1,
5810         const struct isl_basic_map *bmap2)
5811 {
5812         int i, cmp;
5813         unsigned total;
5814
5815         if (bmap1 == bmap2)
5816                 return 0;
5817         if (isl_basic_map_n_param(bmap1) != isl_basic_map_n_param(bmap2))
5818                 return isl_basic_map_n_param(bmap1) - isl_basic_map_n_param(bmap2);
5819         if (isl_basic_map_n_in(bmap1) != isl_basic_map_n_in(bmap2))
5820                 return isl_basic_map_n_out(bmap1) - isl_basic_map_n_out(bmap2);
5821         if (isl_basic_map_n_out(bmap1) != isl_basic_map_n_out(bmap2))
5822                 return isl_basic_map_n_out(bmap1) - isl_basic_map_n_out(bmap2);
5823         if (ISL_F_ISSET(bmap1, ISL_BASIC_MAP_EMPTY) &&
5824             ISL_F_ISSET(bmap2, ISL_BASIC_MAP_EMPTY))
5825                 return 0;
5826         if (ISL_F_ISSET(bmap1, ISL_BASIC_MAP_EMPTY))
5827                 return 1;
5828         if (ISL_F_ISSET(bmap2, ISL_BASIC_MAP_EMPTY))
5829                 return -1;
5830         if (bmap1->n_eq != bmap2->n_eq)
5831                 return bmap1->n_eq - bmap2->n_eq;
5832         if (bmap1->n_ineq != bmap2->n_ineq)
5833                 return bmap1->n_ineq - bmap2->n_ineq;
5834         if (bmap1->n_div != bmap2->n_div)
5835                 return bmap1->n_div - bmap2->n_div;
5836         total = isl_basic_map_total_dim(bmap1);
5837         for (i = 0; i < bmap1->n_eq; ++i) {
5838                 cmp = isl_seq_cmp(bmap1->eq[i], bmap2->eq[i], 1+total);
5839                 if (cmp)
5840                         return cmp;
5841         }
5842         for (i = 0; i < bmap1->n_ineq; ++i) {
5843                 cmp = isl_seq_cmp(bmap1->ineq[i], bmap2->ineq[i], 1+total);
5844                 if (cmp)
5845                         return cmp;
5846         }
5847         for (i = 0; i < bmap1->n_div; ++i) {
5848                 cmp = isl_seq_cmp(bmap1->div[i], bmap2->div[i], 1+1+total);
5849                 if (cmp)
5850                         return cmp;
5851         }
5852         return 0;
5853 }
5854
5855 static int isl_basic_map_fast_is_equal(struct isl_basic_map *bmap1,
5856         struct isl_basic_map *bmap2)
5857 {
5858         return isl_basic_map_fast_cmp(bmap1, bmap2) == 0;
5859 }
5860
5861 static int qsort_bmap_cmp(const void *p1, const void *p2)
5862 {
5863         const struct isl_basic_map *bmap1 = *(const struct isl_basic_map **)p1;
5864         const struct isl_basic_map *bmap2 = *(const struct isl_basic_map **)p2;
5865
5866         return isl_basic_map_fast_cmp(bmap1, bmap2);
5867 }
5868
5869 /* We normalize in place, but if anything goes wrong we need
5870  * to return NULL, so we need to make sure we don't change the
5871  * meaning of any possible other copies of map.
5872  */
5873 struct isl_map *isl_map_normalize(struct isl_map *map)
5874 {
5875         int i, j;
5876         struct isl_basic_map *bmap;
5877
5878         if (!map)
5879                 return NULL;
5880         if (ISL_F_ISSET(map, ISL_MAP_NORMALIZED))
5881                 return map;
5882         for (i = 0; i < map->n; ++i) {
5883                 bmap = isl_basic_map_normalize(isl_basic_map_copy(map->p[i]));
5884                 if (!bmap)
5885                         goto error;
5886                 isl_basic_map_free(map->p[i]);
5887                 map->p[i] = bmap;
5888         }
5889         qsort(map->p, map->n, sizeof(struct isl_basic_map *), qsort_bmap_cmp);
5890         ISL_F_SET(map, ISL_MAP_NORMALIZED);
5891         map = isl_map_remove_empty_parts(map);
5892         if (!map)
5893                 return NULL;
5894         for (i = map->n - 1; i >= 1; --i) {
5895                 if (!isl_basic_map_fast_is_equal(map->p[i-1], map->p[i]))
5896                         continue;
5897                 isl_basic_map_free(map->p[i-1]);
5898                 for (j = i; j < map->n; ++j)
5899                         map->p[j-1] = map->p[j];
5900                 map->n--;
5901         }
5902         return map;
5903 error:
5904         isl_map_free(map);
5905         return NULL;
5906
5907 }
5908
5909 struct isl_set *isl_set_normalize(struct isl_set *set)
5910 {
5911         return (struct isl_set *)isl_map_normalize((struct isl_map *)set);
5912 }
5913
5914 int isl_map_fast_is_equal(struct isl_map *map1, struct isl_map *map2)
5915 {
5916         int i;
5917         int equal;
5918
5919         if (!map1 || !map2)
5920                 return -1;
5921
5922         if (map1 == map2)
5923                 return 1;
5924         if (!isl_dim_equal(map1->dim, map2->dim))
5925                 return 0;
5926
5927         map1 = isl_map_copy(map1);
5928         map2 = isl_map_copy(map2);
5929         map1 = isl_map_normalize(map1);
5930         map2 = isl_map_normalize(map2);
5931         if (!map1 || !map2)
5932                 goto error;
5933         equal = map1->n == map2->n;
5934         for (i = 0; equal && i < map1->n; ++i) {
5935                 equal = isl_basic_map_fast_is_equal(map1->p[i], map2->p[i]);
5936                 if (equal < 0)
5937                         goto error;
5938         }
5939         isl_map_free(map1);
5940         isl_map_free(map2);
5941         return equal;
5942 error:
5943         isl_map_free(map1);
5944         isl_map_free(map2);
5945         return -1;
5946 }
5947
5948 int isl_set_fast_is_equal(struct isl_set *set1, struct isl_set *set2)
5949 {
5950         return isl_map_fast_is_equal((struct isl_map *)set1,
5951                                                 (struct isl_map *)set2);
5952 }
5953
5954 /* Return an interval that ranges from min to max (inclusive)
5955  */
5956 struct isl_basic_set *isl_basic_set_interval(struct isl_ctx *ctx,
5957         isl_int min, isl_int max)
5958 {
5959         int k;
5960         struct isl_basic_set *bset = NULL;
5961
5962         bset = isl_basic_set_alloc(ctx, 0, 1, 0, 0, 2);
5963         if (!bset)
5964                 goto error;
5965
5966         k = isl_basic_set_alloc_inequality(bset);
5967         if (k < 0)
5968                 goto error;
5969         isl_int_set_si(bset->ineq[k][1], 1);
5970         isl_int_neg(bset->ineq[k][0], min);
5971
5972         k = isl_basic_set_alloc_inequality(bset);
5973         if (k < 0)
5974                 goto error;
5975         isl_int_set_si(bset->ineq[k][1], -1);
5976         isl_int_set(bset->ineq[k][0], max);
5977
5978         return bset;
5979 error:
5980         isl_basic_set_free(bset);
5981         return NULL;
5982 }
5983
5984 /* Return the Cartesian product of the basic sets in list (in the given order).
5985  */
5986 struct isl_basic_set *isl_basic_set_product(struct isl_basic_set_list *list)
5987 {
5988         int i;
5989         unsigned dim;
5990         unsigned nparam;
5991         unsigned extra;
5992         unsigned n_eq;
5993         unsigned n_ineq;
5994         struct isl_basic_set *product = NULL;
5995
5996         if (!list)
5997                 goto error;
5998         isl_assert(list->ctx, list->n > 0, goto error);
5999         isl_assert(list->ctx, list->p[0], goto error);
6000         nparam = isl_basic_set_n_param(list->p[0]);
6001         dim = isl_basic_set_n_dim(list->p[0]);
6002         extra = list->p[0]->n_div;
6003         n_eq = list->p[0]->n_eq;
6004         n_ineq = list->p[0]->n_ineq;
6005         for (i = 1; i < list->n; ++i) {
6006                 isl_assert(list->ctx, list->p[i], goto error);
6007                 isl_assert(list->ctx,
6008                     nparam == isl_basic_set_n_param(list->p[i]), goto error);
6009                 dim += isl_basic_set_n_dim(list->p[i]);
6010                 extra += list->p[i]->n_div;
6011                 n_eq += list->p[i]->n_eq;
6012                 n_ineq += list->p[i]->n_ineq;
6013         }
6014         product = isl_basic_set_alloc(list->ctx, nparam, dim, extra,
6015                                         n_eq, n_ineq);
6016         if (!product)
6017                 goto error;
6018         dim = 0;
6019         for (i = 0; i < list->n; ++i) {
6020                 isl_basic_set_add_constraints(product,
6021                                         isl_basic_set_copy(list->p[i]), dim);
6022                 dim += isl_basic_set_n_dim(list->p[i]);
6023         }
6024         isl_basic_set_list_free(list);
6025         return product;
6026 error:
6027         isl_basic_set_free(product);
6028         isl_basic_set_list_free(list);
6029         return NULL;
6030 }
6031
6032 struct isl_basic_map *isl_basic_map_product(
6033                 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
6034 {
6035         struct isl_dim *dim_result = NULL;
6036         struct isl_basic_map *bmap;
6037         unsigned in1, in2, out1, out2, nparam, total, pos;
6038         struct isl_dim_map *dim_map1, *dim_map2;
6039
6040         if (!bmap1 || !bmap2)
6041                 goto error;
6042
6043         isl_assert(bmap1->ctx, isl_dim_match(bmap1->dim, isl_dim_param,
6044                                      bmap2->dim, isl_dim_param), goto error);
6045         dim_result = isl_dim_product(isl_dim_copy(bmap1->dim),
6046                                                    isl_dim_copy(bmap2->dim));
6047
6048         in1 = isl_basic_map_n_in(bmap1);
6049         in2 = isl_basic_map_n_in(bmap2);
6050         out1 = isl_basic_map_n_out(bmap1);
6051         out2 = isl_basic_map_n_out(bmap2);
6052         nparam = isl_basic_map_n_param(bmap1);
6053
6054         total = nparam + in1 + in2 + out1 + out2 + bmap1->n_div + bmap2->n_div;
6055         dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
6056         dim_map2 = isl_dim_map_alloc(bmap1->ctx, total);
6057         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
6058         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos = 0);
6059         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
6060         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos += in1);
6061         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += in2);
6062         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos += out1);
6063         isl_dim_map_div(dim_map1, bmap1, pos += out2);
6064         isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
6065
6066         bmap = isl_basic_map_alloc_dim(dim_result,
6067                         bmap1->n_div + bmap2->n_div,
6068                         bmap1->n_eq + bmap2->n_eq,
6069                         bmap1->n_ineq + bmap2->n_ineq);
6070         bmap = add_constraints_dim_map(bmap, bmap1, dim_map1);
6071         bmap = add_constraints_dim_map(bmap, bmap2, dim_map2);
6072         bmap = isl_basic_map_simplify(bmap);
6073         return isl_basic_map_finalize(bmap);
6074 error:
6075         isl_basic_map_free(bmap1);
6076         isl_basic_map_free(bmap2);
6077         return NULL;
6078 }
6079
6080 /* Given two maps A -> B and C -> D, construct a map (A, C) -> (B, D)
6081  */
6082 struct isl_map *isl_map_product(struct isl_map *map1, struct isl_map *map2)
6083 {
6084         unsigned flags = 0;
6085         struct isl_map *result;
6086         int i, j;
6087
6088         if (!map1 || !map2)
6089                 goto error;
6090
6091         isl_assert(map1->ctx, isl_dim_match(map1->dim, isl_dim_param,
6092                                          map2->dim, isl_dim_param), goto error);
6093
6094         if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) &&
6095             ISL_F_ISSET(map2, ISL_MAP_DISJOINT))
6096                 ISL_FL_SET(flags, ISL_MAP_DISJOINT);
6097
6098         result = isl_map_alloc_dim(isl_dim_product(isl_dim_copy(map1->dim),
6099                                                    isl_dim_copy(map2->dim)),
6100                                 map1->n * map2->n, flags);
6101         if (!result)
6102                 goto error;
6103         for (i = 0; i < map1->n; ++i)
6104                 for (j = 0; j < map2->n; ++j) {
6105                         struct isl_basic_map *part;
6106                         part = isl_basic_map_product(
6107                                     isl_basic_map_copy(map1->p[i]),
6108                                     isl_basic_map_copy(map2->p[j]));
6109                         if (isl_basic_map_is_empty(part))
6110                                 isl_basic_map_free(part);
6111                         else
6112                                 result = isl_map_add_basic_map(result, part);
6113                         if (!result)
6114                                 goto error;
6115                 }
6116         isl_map_free(map1);
6117         isl_map_free(map2);
6118         return result;
6119 error:
6120         isl_map_free(map1);
6121         isl_map_free(map2);
6122         return NULL;
6123 }
6124
6125 /* Given two set A and B, construct its Cartesian product A x B.
6126  */
6127 struct isl_set *isl_set_product(struct isl_set *set1, struct isl_set *set2)
6128 {
6129         return (struct isl_set *)isl_map_product((struct isl_map *)set1,
6130                                                  (struct isl_map *)set2);
6131 }
6132
6133 uint32_t isl_basic_set_get_hash(struct isl_basic_set *bset)
6134 {
6135         int i;
6136         uint32_t hash = isl_hash_init();
6137         unsigned total;
6138
6139         if (!bset)
6140                 return 0;
6141         bset = isl_basic_set_copy(bset);
6142         bset = isl_basic_set_normalize(bset);
6143         if (!bset)
6144                 return 0;
6145         total = isl_basic_set_total_dim(bset);
6146         isl_hash_byte(hash, bset->n_eq & 0xFF);
6147         for (i = 0; i < bset->n_eq; ++i) {
6148                 uint32_t c_hash;
6149                 c_hash = isl_seq_get_hash(bset->eq[i], 1 + total);
6150                 isl_hash_hash(hash, c_hash);
6151         }
6152         isl_hash_byte(hash, bset->n_ineq & 0xFF);
6153         for (i = 0; i < bset->n_ineq; ++i) {
6154                 uint32_t c_hash;
6155                 c_hash = isl_seq_get_hash(bset->ineq[i], 1 + total);
6156                 isl_hash_hash(hash, c_hash);
6157         }
6158         isl_hash_byte(hash, bset->n_div & 0xFF);
6159         for (i = 0; i < bset->n_div; ++i) {
6160                 uint32_t c_hash;
6161                 if (isl_int_is_zero(bset->div[i][0]))
6162                         continue;
6163                 isl_hash_byte(hash, i & 0xFF);
6164                 c_hash = isl_seq_get_hash(bset->div[i], 1 + 1 + total);
6165                 isl_hash_hash(hash, c_hash);
6166         }
6167         isl_basic_set_free(bset);
6168         return hash;
6169 }
6170
6171 uint32_t isl_set_get_hash(struct isl_set *set)
6172 {
6173         int i;
6174         uint32_t hash;
6175
6176         if (!set)
6177                 return 0;
6178         set = isl_set_copy(set);
6179         set = isl_set_normalize(set);
6180         if (!set)
6181                 return 0;
6182
6183         hash = isl_hash_init();
6184         for (i = 0; i < set->n; ++i) {
6185                 uint32_t bset_hash;
6186                 bset_hash = isl_basic_set_get_hash(set->p[i]);
6187                 isl_hash_hash(hash, bset_hash);
6188         }
6189
6190         isl_set_free(set);
6191
6192         return hash;
6193 }
6194
6195 /* Check if the value for dimension dim is completely determined
6196  * by the values of the other parameters and variables.
6197  * That is, check if dimension dim is involved in an equality.
6198  */
6199 int isl_basic_set_dim_is_unique(struct isl_basic_set *bset, unsigned dim)
6200 {
6201         int i;
6202         unsigned nparam;
6203
6204         if (!bset)
6205                 return -1;
6206         nparam = isl_basic_set_n_param(bset);
6207         for (i = 0; i < bset->n_eq; ++i)
6208                 if (!isl_int_is_zero(bset->eq[i][1 + nparam + dim]))
6209                         return 1;
6210         return 0;
6211 }
6212
6213 /* Check if the value for dimension dim is completely determined
6214  * by the values of the other parameters and variables.
6215  * That is, check if dimension dim is involved in an equality
6216  * for each of the subsets.
6217  */
6218 int isl_set_dim_is_unique(struct isl_set *set, unsigned dim)
6219 {
6220         int i;
6221
6222         if (!set)
6223                 return -1;
6224         for (i = 0; i < set->n; ++i) {
6225                 int unique;
6226                 unique = isl_basic_set_dim_is_unique(set->p[i], dim);
6227                 if (unique != 1)
6228                         return unique;
6229         }
6230         return 1;
6231 }
6232
6233 int isl_map_foreach_basic_map(__isl_keep isl_map *map,
6234         int (*fn)(__isl_take isl_basic_map *bmap, void *user), void *user)
6235 {
6236         int i;
6237
6238         if (!map)
6239                 return -1;
6240
6241         for (i = 0; i < map->n; ++i)
6242                 if (fn(isl_basic_map_copy(map->p[i]), user) < 0)
6243                         return -1;
6244
6245         return 0;
6246 }
6247
6248 int isl_set_foreach_basic_set(__isl_keep isl_set *set,
6249         int (*fn)(__isl_take isl_basic_set *bset, void *user), void *user)
6250 {
6251         int i;
6252
6253         if (!set)
6254                 return -1;
6255
6256         for (i = 0; i < set->n; ++i)
6257                 if (fn(isl_basic_set_copy(set->p[i]), user) < 0)
6258                         return -1;
6259
6260         return 0;
6261 }
6262
6263 __isl_give isl_basic_set *isl_basic_set_lift(__isl_take isl_basic_set *bset)
6264 {
6265         struct isl_dim *dim;
6266
6267         if (!bset)
6268                 return NULL;
6269
6270         if (bset->n_div == 0)
6271                 return bset;
6272
6273         bset = isl_basic_set_cow(bset);
6274         if (!bset)
6275                 return NULL;
6276
6277         dim = isl_basic_set_get_dim(bset);
6278         dim = isl_dim_add(dim, isl_dim_set, bset->n_div);
6279         if (!dim)
6280                 goto error;
6281         isl_dim_free(bset->dim);
6282         bset->dim = dim;
6283         bset->n_div = 0;
6284
6285         return bset;
6286 error:
6287         isl_basic_set_free(bset);
6288         return NULL;
6289 }
6290
6291 __isl_give isl_set *isl_set_lift(__isl_take isl_set *set)
6292 {
6293         int i;
6294         struct isl_dim *dim;
6295         unsigned n_div;
6296
6297         set = isl_set_align_divs(set);
6298
6299         if (!set)
6300                 return NULL;
6301         if (set->n == 0 || set->p[0]->n_div == 0)
6302                 return set;
6303
6304         set = isl_set_cow(set);
6305         if (!set)
6306                 return NULL;
6307
6308         n_div = set->p[0]->n_div;
6309         dim = isl_set_get_dim(set);
6310         dim = isl_dim_add(dim, isl_dim_set, n_div);
6311         if (!dim)
6312                 goto error;
6313         isl_dim_free(set->dim);
6314         set->dim = dim;
6315
6316         for (i = 0; i < set->n; ++i) {
6317                 set->p[i] = isl_basic_set_lift(set->p[i]);
6318                 if (!set->p[i])
6319                         goto error;
6320         }
6321
6322         return set;
6323 error:
6324         isl_set_free(set);
6325         return NULL;
6326 }
6327
6328 __isl_give isl_map *isl_set_lifting(__isl_take isl_set *set)
6329 {
6330         struct isl_dim *dim;
6331         struct isl_basic_map *bmap;
6332         unsigned n_set;
6333         unsigned n_div;
6334         unsigned n_param;
6335         unsigned total;
6336         int i, k, l;
6337
6338         set = isl_set_align_divs(set);
6339
6340         if (!set)
6341                 return NULL;
6342
6343         dim = isl_set_get_dim(set);
6344         if (set->n == 0 || set->p[0]->n_div == 0) {
6345                 isl_set_free(set);
6346                 return isl_map_identity(dim);
6347         }
6348
6349         n_div = set->p[0]->n_div;
6350         dim = isl_dim_map(dim);
6351         n_param = isl_dim_size(dim, isl_dim_param);
6352         n_set = isl_dim_size(dim, isl_dim_in);
6353         dim = isl_dim_extend(dim, n_param, n_set, n_set + n_div);
6354         bmap = isl_basic_map_alloc_dim(dim, 0, n_set, 2 * n_div);
6355         for (i = 0; i < n_set; ++i)
6356                 bmap = var_equal(bmap, i);
6357
6358         total = n_param + n_set + n_set + n_div;
6359         for (i = 0; i < n_div; ++i) {
6360                 k = isl_basic_map_alloc_inequality(bmap);
6361                 if (k < 0)
6362                         goto error;
6363                 isl_seq_cpy(bmap->ineq[k], set->p[0]->div[i]+1, 1+n_param);
6364                 isl_seq_clr(bmap->ineq[k]+1+n_param, n_set);
6365                 isl_seq_cpy(bmap->ineq[k]+1+n_param+n_set,
6366                             set->p[0]->div[i]+1+1+n_param, n_set + n_div);
6367                 isl_int_neg(bmap->ineq[k][1+n_param+n_set+n_set+i],
6368                             set->p[0]->div[i][0]);
6369
6370                 l = isl_basic_map_alloc_inequality(bmap);
6371                 if (l < 0)
6372                         goto error;
6373                 isl_seq_neg(bmap->ineq[l], bmap->ineq[k], 1 + total);
6374                 isl_int_add(bmap->ineq[l][0], bmap->ineq[l][0],
6375                             set->p[0]->div[i][0]);
6376                 isl_int_sub_ui(bmap->ineq[l][0], bmap->ineq[l][0], 1);
6377         }
6378
6379         isl_set_free(set);
6380         return isl_map_from_basic_map(bmap);
6381 error:
6382         isl_set_free(set);
6383         isl_basic_map_free(bmap);
6384         return NULL;
6385 }
6386
6387 int isl_basic_set_size(__isl_keep isl_basic_set *bset)
6388 {
6389         unsigned dim;
6390         int size = 0;
6391
6392         if (!bset)
6393                 return -1;
6394
6395         dim = isl_basic_set_total_dim(bset);
6396         size += bset->n_eq * (1 + dim);
6397         size += bset->n_ineq * (1 + dim);
6398         size += bset->n_div * (2 + dim);
6399
6400         return size;
6401 }
6402
6403 int isl_set_size(__isl_keep isl_set *set)
6404 {
6405         int i;
6406         int size = 0;
6407
6408         if (!set)
6409                 return -1;
6410
6411         for (i = 0; i < set->n; ++i)
6412                 size += isl_basic_set_size(set->p[i]);
6413
6414         return size;
6415 }
6416
6417 int isl_basic_map_dim_is_bounded(__isl_keep isl_basic_map *bmap,
6418         enum isl_dim_type type, unsigned pos)
6419 {
6420         int i;
6421         int lower, upper;
6422
6423         if (!bmap)
6424                 return -1;
6425
6426         isl_assert(bmap->ctx, pos < isl_basic_map_dim(bmap, type), return -1);
6427
6428         pos += isl_basic_map_offset(bmap, type);
6429
6430         for (i = 0; i < bmap->n_eq; ++i)
6431                 if (!isl_int_is_zero(bmap->eq[i][pos]))
6432                         return 1;
6433
6434         lower = upper = 0;
6435         for (i = 0; i < bmap->n_ineq; ++i) {
6436                 int sgn = isl_int_sgn(bmap->ineq[i][pos]);
6437                 if (sgn > 0)
6438                         lower = 1;
6439                 if (sgn < 0)
6440                         upper = 1;
6441         }
6442
6443         return lower && upper;
6444 }
6445
6446 int isl_map_dim_is_bounded(__isl_keep isl_map *map,
6447         enum isl_dim_type type, unsigned pos)
6448 {
6449         int i;
6450
6451         if (!map)
6452                 return -1;
6453
6454         for (i = 0; i < map->n; ++i) {
6455                 int bounded;
6456                 bounded = isl_basic_map_dim_is_bounded(map->p[i], type, pos);
6457                 if (bounded < 0 || !bounded)
6458                         return bounded;
6459         }
6460
6461         return 1;
6462 }
6463
6464 /* Return 1 if the specified dim is involved in both an upper bound
6465  * and a lower bound.
6466  */
6467 int isl_set_dim_is_bounded(__isl_keep isl_set *set,
6468         enum isl_dim_type type, unsigned pos)
6469 {
6470         return isl_map_dim_is_bounded((isl_map *)set, type, pos);
6471 }