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                 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(__isl_take isl_basic_map *bmap,
2116         enum isl_dim_type dst_type, unsigned dst_pos,
2117         enum isl_dim_type src_type, unsigned src_pos, unsigned n)
2118 {
2119         int i;
2120         struct isl_dim_map *dim_map;
2121         struct isl_basic_map *res;
2122         enum isl_dim_type t;
2123         unsigned total, off;
2124
2125         if (!bmap)
2126                 return NULL;
2127         if (n == 0)
2128                 return bmap;
2129
2130         isl_assert(bmap->ctx, src_pos + n <= isl_basic_map_dim(bmap, src_type),
2131                 goto error);
2132
2133         if (dst_type == src_type && dst_pos == src_pos)
2134                 return bmap;
2135
2136         isl_assert(bmap->ctx, dst_type != src_type, goto error);
2137
2138         if (pos(bmap->dim, dst_type) + dst_pos ==
2139             pos(bmap->dim, src_type) + src_pos +
2140                                             ((src_type < dst_type) ? n : 0)) {
2141                 bmap = isl_basic_map_cow(bmap);
2142                 if (!bmap)
2143                         return NULL;
2144
2145                 bmap->dim = isl_dim_move(bmap->dim, dst_type, dst_pos,
2146                                                 src_type, src_pos, n);
2147                 if (!bmap->dim)
2148                         goto error;
2149
2150                 return bmap;
2151         }
2152
2153         total = isl_basic_map_total_dim(bmap);
2154         dim_map = isl_dim_map_alloc(bmap->ctx, total);
2155
2156         off = 0;
2157         for (t = isl_dim_param; t <= isl_dim_out; ++t) {
2158                 unsigned size = isl_dim_size(bmap->dim, t);
2159                 if (t == dst_type) {
2160                         isl_dim_map_dim_range(dim_map, bmap->dim, t,
2161                                             0, dst_pos, off);
2162                         off += dst_pos;
2163                         isl_dim_map_dim_range(dim_map, bmap->dim, src_type,
2164                                             src_pos, n, off);
2165                         off += n;
2166                         isl_dim_map_dim_range(dim_map, bmap->dim, t,
2167                                             dst_pos, size - dst_pos, off);
2168                         off += size - dst_pos;
2169                 } else if (t == src_type) {
2170                         isl_dim_map_dim_range(dim_map, bmap->dim, t,
2171                                             0, src_pos, off);
2172                         off += src_pos;
2173                         isl_dim_map_dim_range(dim_map, bmap->dim, t,
2174                                         src_pos + n, size - src_pos - n, off);
2175                         off += size - src_pos - n;
2176                 } else {
2177                         isl_dim_map_dim(dim_map, bmap->dim, t, off);
2178                         off += size;
2179                 }
2180         }
2181         isl_dim_map_div(dim_map, bmap, off + n);
2182
2183         res = isl_basic_map_alloc_dim(isl_basic_map_get_dim(bmap),
2184                         bmap->n_div, bmap->n_eq, bmap->n_ineq);
2185         bmap = add_constraints_dim_map(res, bmap, dim_map);
2186
2187         bmap->dim = isl_dim_move(bmap->dim, dst_type, dst_pos,
2188                                         src_type, src_pos, n);
2189         if (!bmap->dim)
2190                 goto error;
2191
2192         return bmap;
2193 error:
2194         isl_basic_map_free(bmap);
2195         return NULL;
2196 }
2197
2198 __isl_give isl_set *isl_set_move(__isl_take isl_set *set,
2199         enum isl_dim_type dst_type, unsigned dst_pos,
2200         enum isl_dim_type src_type, unsigned src_pos, unsigned n)
2201 {
2202         if (!set)
2203                 return NULL;
2204         isl_assert(set->ctx, dst_type != isl_dim_in, goto error);
2205         return (isl_set *)isl_map_move((isl_map *)set, dst_type, dst_pos,
2206                                         src_type, src_pos, n);
2207 error:
2208         isl_set_free(set);
2209         return NULL;
2210 }
2211
2212 __isl_give isl_map *isl_map_move(__isl_take isl_map *map,
2213         enum isl_dim_type dst_type, unsigned dst_pos,
2214         enum isl_dim_type src_type, unsigned src_pos, unsigned n)
2215 {
2216         int i;
2217
2218         if (!map)
2219                 return NULL;
2220         if (n == 0)
2221                 return map;
2222
2223         isl_assert(map->ctx, src_pos + n <= isl_map_dim(map, src_type),
2224                 goto error);
2225
2226         if (dst_type == src_type && dst_pos == src_pos)
2227                 return map;
2228
2229         isl_assert(map->ctx, dst_type != src_type, goto error);
2230
2231         map = isl_map_cow(map);
2232         if (!map)
2233                 return NULL;
2234
2235         map->dim = isl_dim_move(map->dim, dst_type, dst_pos, src_type, src_pos, n);
2236         if (!map->dim)
2237                 goto error;
2238
2239         for (i = 0; i < map->n; ++i) {
2240                 map->p[i] = isl_basic_map_move(map->p[i], dst_type, dst_pos,
2241                                                 src_type, src_pos, n);
2242                 if (!map->p[i])
2243                         goto error;
2244         }
2245
2246         return map;
2247 error:
2248         isl_map_free(map);
2249         return NULL;
2250 }
2251
2252 /* Move the specified dimensions to the last columns right before
2253  * the divs.  Don't change the dimension specification of bmap.
2254  * That's the responsibility of the caller.
2255  */
2256 static __isl_give isl_basic_map *move_last(__isl_take isl_basic_map *bmap,
2257         enum isl_dim_type type, unsigned first, unsigned n)
2258 {
2259         struct isl_dim_map *dim_map;
2260         struct isl_basic_map *res;
2261         enum isl_dim_type t;
2262         unsigned total, off;
2263
2264         if (!bmap)
2265                 return NULL;
2266         if (pos(bmap->dim, type) + first + n == 1 + isl_dim_total(bmap->dim))
2267                 return bmap;
2268
2269         total = isl_basic_map_total_dim(bmap);
2270         dim_map = isl_dim_map_alloc(bmap->ctx, total);
2271
2272         off = 0;
2273         for (t = isl_dim_param; t <= isl_dim_out; ++t) {
2274                 unsigned size = isl_dim_size(bmap->dim, t);
2275                 if (t == type) {
2276                         isl_dim_map_dim_range(dim_map, bmap->dim, t,
2277                                             0, first, off);
2278                         off += first;
2279                         isl_dim_map_dim_range(dim_map, bmap->dim, t,
2280                                             first, n, total - bmap->n_div - n);
2281                         isl_dim_map_dim_range(dim_map, bmap->dim, t,
2282                                             first + n, size - (first + n), off);
2283                         off += size - (first + n);
2284                 } else {
2285                         isl_dim_map_dim(dim_map, bmap->dim, t, off);
2286                         off += size;
2287                 }
2288         }
2289         isl_dim_map_div(dim_map, bmap, off + n);
2290
2291         res = isl_basic_map_alloc_dim(isl_basic_map_get_dim(bmap),
2292                         bmap->n_div, bmap->n_eq, bmap->n_ineq);
2293         res = add_constraints_dim_map(res, bmap, dim_map);
2294         return res;
2295 }
2296
2297 /* Turn the n dimensions of type type, starting at first
2298  * into existentially quantified variables.
2299  */
2300 __isl_give isl_basic_map *isl_basic_map_project_out(
2301                 __isl_take isl_basic_map *bmap,
2302                 enum isl_dim_type type, unsigned first, unsigned n)
2303 {
2304         int i;
2305         size_t row_size;
2306         isl_int **new_div;
2307         isl_int *old;
2308
2309         if (n == 0)
2310                 return bmap;
2311
2312         if (!bmap)
2313                 return NULL;
2314
2315         if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
2316                 return isl_basic_map_remove(bmap, type, first, n);
2317
2318         isl_assert(bmap->ctx, first + n <= isl_basic_map_dim(bmap, type),
2319                         goto error);
2320
2321         bmap = move_last(bmap, type, first, n);
2322         bmap = isl_basic_map_cow(bmap);
2323
2324         row_size = 1 + isl_dim_total(bmap->dim) + bmap->extra;
2325         old = bmap->block2.data;
2326         bmap->block2 = isl_blk_extend(bmap->ctx, bmap->block2,
2327                                         (bmap->extra + n) * (1 + row_size));
2328         if (!bmap->block2.data)
2329                 goto error;
2330         new_div = isl_alloc_array(ctx, isl_int *, bmap->extra + n);
2331         if (!new_div)
2332                 goto error;
2333         for (i = 0; i < n; ++i) {
2334                 new_div[i] = bmap->block2.data +
2335                                 (bmap->extra + i) * (1 + row_size);
2336                 isl_seq_clr(new_div[i], 1 + row_size);
2337         }
2338         for (i = 0; i < bmap->extra; ++i)
2339                 new_div[n + i] = bmap->block2.data + (bmap->div[i] - old);
2340         free(bmap->div);
2341         bmap->div = new_div;
2342         bmap->n_div += n;
2343         bmap->extra += n;
2344
2345         bmap->dim = isl_dim_drop(bmap->dim, type, first, n);
2346         if (!bmap->dim)
2347                 goto error;
2348         bmap = isl_basic_map_simplify(bmap);
2349         bmap = isl_basic_map_drop_redundant_divs(bmap);
2350         return isl_basic_map_finalize(bmap);
2351 error:
2352         isl_basic_map_free(bmap);
2353         return NULL;
2354 }
2355
2356 /* Turn the n dimensions of type type, starting at first
2357  * into existentially quantified variables.
2358  */
2359 struct isl_basic_set *isl_basic_set_project_out(struct isl_basic_set *bset,
2360                 enum isl_dim_type type, unsigned first, unsigned n)
2361 {
2362         return (isl_basic_set *)isl_basic_map_project_out(
2363                         (isl_basic_map *)bset, type, first, n);
2364 }
2365
2366 /* Turn the n dimensions of type type, starting at first
2367  * into existentially quantified variables.
2368  */
2369 __isl_give isl_map *isl_map_project_out(__isl_take isl_map *map,
2370                 enum isl_dim_type type, unsigned first, unsigned n)
2371 {
2372         int i;
2373
2374         if (!map)
2375                 return NULL;
2376
2377         if (n == 0)
2378                 return map;
2379
2380         isl_assert(map->ctx, first + n <= isl_map_dim(map, type), goto error);
2381
2382         map = isl_map_cow(map);
2383         if (!map)
2384                 return NULL;
2385
2386         map->dim = isl_dim_drop(map->dim, type, first, n);
2387         if (!map->dim)
2388                 goto error;
2389
2390         for (i = 0; i < map->n; ++i) {
2391                 map->p[i] = isl_basic_map_project_out(map->p[i], type, first, n);
2392                 if (!map->p[i])
2393                         goto error;
2394         }
2395
2396         return map;
2397 error:
2398         isl_map_free(map);
2399         return map;
2400 }
2401
2402 /* Turn the n dimensions of type type, starting at first
2403  * into existentially quantified variables.
2404  */
2405 __isl_give isl_set *isl_set_project_out(__isl_take isl_set *set,
2406                 enum isl_dim_type type, unsigned first, unsigned n)
2407 {
2408         return (isl_set *)isl_map_project_out((isl_map *)set, type, first, n);
2409 }
2410
2411 static struct isl_basic_map *add_divs(struct isl_basic_map *bmap, unsigned n)
2412 {
2413         int i, j;
2414
2415         for (i = 0; i < n; ++i) {
2416                 j = isl_basic_map_alloc_div(bmap);
2417                 if (j < 0)
2418                         goto error;
2419                 isl_seq_clr(bmap->div[j], 1+1+isl_basic_map_total_dim(bmap));
2420         }
2421         return bmap;
2422 error:
2423         isl_basic_map_free(bmap);
2424         return NULL;
2425 }
2426
2427 struct isl_basic_map *isl_basic_map_apply_range(
2428                 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
2429 {
2430         struct isl_dim *dim_result = NULL;
2431         struct isl_basic_map *bmap;
2432         unsigned n_in, n_out, n, nparam, total, pos;
2433         struct isl_dim_map *dim_map1, *dim_map2;
2434
2435         if (!bmap1 || !bmap2)
2436                 goto error;
2437
2438         dim_result = isl_dim_join(isl_dim_copy(bmap1->dim),
2439                                   isl_dim_copy(bmap2->dim));
2440
2441         n_in = isl_basic_map_n_in(bmap1);
2442         n_out = isl_basic_map_n_out(bmap2);
2443         n = isl_basic_map_n_out(bmap1);
2444         nparam = isl_basic_map_n_param(bmap1);
2445
2446         total = nparam + n_in + n_out + bmap1->n_div + bmap2->n_div + n;
2447         dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
2448         dim_map2 = isl_dim_map_alloc(bmap1->ctx, total);
2449         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
2450         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos = 0);
2451         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
2452         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos += n_in);
2453         isl_dim_map_div(dim_map1, bmap1, pos += n_out);
2454         isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
2455         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += bmap2->n_div);
2456         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos);
2457
2458         bmap = isl_basic_map_alloc_dim(dim_result,
2459                         bmap1->n_div + bmap2->n_div + n,
2460                         bmap1->n_eq + bmap2->n_eq,
2461                         bmap1->n_ineq + bmap2->n_ineq);
2462         bmap = add_constraints_dim_map(bmap, bmap1, dim_map1);
2463         bmap = add_constraints_dim_map(bmap, bmap2, dim_map2);
2464         bmap = add_divs(bmap, n);
2465         bmap = isl_basic_map_simplify(bmap);
2466         bmap = isl_basic_map_drop_redundant_divs(bmap);
2467         return isl_basic_map_finalize(bmap);
2468 error:
2469         isl_basic_map_free(bmap1);
2470         isl_basic_map_free(bmap2);
2471         return NULL;
2472 }
2473
2474 struct isl_basic_set *isl_basic_set_apply(
2475                 struct isl_basic_set *bset, struct isl_basic_map *bmap)
2476 {
2477         if (!bset || !bmap)
2478                 goto error;
2479
2480         isl_assert(bset->ctx, isl_basic_map_compatible_domain(bmap, bset),
2481                     goto error);
2482
2483         return (struct isl_basic_set *)
2484                 isl_basic_map_apply_range((struct isl_basic_map *)bset, bmap);
2485 error:
2486         isl_basic_set_free(bset);
2487         isl_basic_map_free(bmap);
2488         return NULL;
2489 }
2490
2491 struct isl_basic_map *isl_basic_map_apply_domain(
2492                 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
2493 {
2494         if (!bmap1 || !bmap2)
2495                 goto error;
2496
2497         isl_assert(bmap1->ctx,
2498             isl_basic_map_n_in(bmap1) == isl_basic_map_n_in(bmap2), goto error);
2499         isl_assert(bmap1->ctx,
2500             isl_basic_map_n_param(bmap1) == isl_basic_map_n_param(bmap2),
2501             goto error);
2502
2503         bmap1 = isl_basic_map_reverse(bmap1);
2504         bmap1 = isl_basic_map_apply_range(bmap1, bmap2);
2505         return isl_basic_map_reverse(bmap1);
2506 error:
2507         isl_basic_map_free(bmap1);
2508         isl_basic_map_free(bmap2);
2509         return NULL;
2510 }
2511
2512 /* Given two basic maps A -> f(A) and B -> g(B), construct a basic map
2513  * A \cap B -> f(A) + f(B)
2514  */
2515 struct isl_basic_map *isl_basic_map_sum(
2516                 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
2517 {
2518         unsigned n_in, n_out, nparam, total, pos;
2519         struct isl_basic_map *bmap = NULL;
2520         struct isl_dim_map *dim_map1, *dim_map2;
2521         int i;
2522
2523         if (!bmap1 || !bmap2)
2524                 goto error;
2525
2526         isl_assert(bmap1->ctx, isl_dim_equal(bmap1->dim, bmap2->dim),
2527                 goto error);
2528
2529         nparam = isl_basic_map_n_param(bmap1);
2530         n_in = isl_basic_map_n_in(bmap1);
2531         n_out = isl_basic_map_n_out(bmap1);
2532
2533         total = nparam + n_in + n_out + bmap1->n_div + bmap2->n_div + 2 * n_out;
2534         dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
2535         dim_map2 = isl_dim_map_alloc(bmap2->ctx, total);
2536         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
2537         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos);
2538         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
2539         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos);
2540         isl_dim_map_div(dim_map1, bmap1, pos += n_in + n_out);
2541         isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
2542         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += bmap2->n_div);
2543         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos += n_out);
2544
2545         bmap = isl_basic_map_alloc_dim(isl_dim_copy(bmap1->dim),
2546                         bmap1->n_div + bmap2->n_div + 2 * n_out,
2547                         bmap1->n_eq + bmap2->n_eq + n_out,
2548                         bmap1->n_ineq + bmap2->n_ineq);
2549         for (i = 0; i < n_out; ++i) {
2550                 int j = isl_basic_map_alloc_equality(bmap);
2551                 if (j < 0)
2552                         goto error;
2553                 isl_seq_clr(bmap->eq[j], 1+total);
2554                 isl_int_set_si(bmap->eq[j][1+nparam+n_in+i], -1);
2555                 isl_int_set_si(bmap->eq[j][1+pos+i], 1);
2556                 isl_int_set_si(bmap->eq[j][1+pos-n_out+i], 1);
2557         }
2558         bmap = add_constraints_dim_map(bmap, bmap1, dim_map1);
2559         bmap = add_constraints_dim_map(bmap, bmap2, dim_map2);
2560         bmap = add_divs(bmap, 2 * n_out);
2561
2562         bmap = isl_basic_map_simplify(bmap);
2563         return isl_basic_map_finalize(bmap);
2564 error:
2565         isl_basic_map_free(bmap);
2566         isl_basic_map_free(bmap1);
2567         isl_basic_map_free(bmap2);
2568         return NULL;
2569 }
2570
2571 /* Given two maps A -> f(A) and B -> g(B), construct a map
2572  * A \cap B -> f(A) + f(B)
2573  */
2574 struct isl_map *isl_map_sum(struct isl_map *map1, struct isl_map *map2)
2575 {
2576         struct isl_map *result;
2577         int i, j;
2578
2579         if (!map1 || !map2)
2580                 goto error;
2581
2582         isl_assert(map1->ctx, isl_dim_equal(map1->dim, map2->dim), goto error);
2583
2584         result = isl_map_alloc_dim(isl_dim_copy(map1->dim),
2585                                 map1->n * map2->n, 0);
2586         if (!result)
2587                 goto error;
2588         for (i = 0; i < map1->n; ++i)
2589                 for (j = 0; j < map2->n; ++j) {
2590                         struct isl_basic_map *part;
2591                         part = isl_basic_map_sum(
2592                                     isl_basic_map_copy(map1->p[i]),
2593                                     isl_basic_map_copy(map2->p[j]));
2594                         if (isl_basic_map_is_empty(part))
2595                                 isl_basic_map_free(part);
2596                         else
2597                                 result = isl_map_add_basic_map(result, part);
2598                         if (!result)
2599                                 goto error;
2600                 }
2601         isl_map_free(map1);
2602         isl_map_free(map2);
2603         return result;
2604 error:
2605         isl_map_free(map1);
2606         isl_map_free(map2);
2607         return NULL;
2608 }
2609
2610 /* Given a basic map A -> f(A), construct A -> -f(A).
2611  */
2612 struct isl_basic_map *isl_basic_map_neg(struct isl_basic_map *bmap)
2613 {
2614         int i, j;
2615         unsigned off, n;
2616
2617         bmap = isl_basic_map_cow(bmap);
2618         if (!bmap)
2619                 return NULL;
2620
2621         n = isl_basic_map_dim(bmap, isl_dim_out);
2622         off = isl_basic_map_offset(bmap, isl_dim_out);
2623         for (i = 0; i < bmap->n_eq; ++i)
2624                 for (j = 0; j < n; ++j)
2625                         isl_int_neg(bmap->eq[i][off+j], bmap->eq[i][off+j]);
2626         for (i = 0; i < bmap->n_ineq; ++i)
2627                 for (j = 0; j < n; ++j)
2628                         isl_int_neg(bmap->ineq[i][off+j], bmap->ineq[i][off+j]);
2629         for (i = 0; i < bmap->n_div; ++i)
2630                 for (j = 0; j < n; ++j)
2631                         isl_int_neg(bmap->div[i][1+off+j], bmap->div[i][1+off+j]);
2632         return isl_basic_map_finalize(bmap);
2633 }
2634
2635 /* Given a map A -> f(A), construct A -> -f(A).
2636  */
2637 struct isl_map *isl_map_neg(struct isl_map *map)
2638 {
2639         int i;
2640
2641         map = isl_map_cow(map);
2642         if (!map)
2643                 return NULL;
2644
2645         for (i = 0; i < map->n; ++i) {
2646                 map->p[i] = isl_basic_map_neg(map->p[i]);
2647                 if (!map->p[i])
2648                         goto error;
2649         }
2650
2651         return map;
2652 error:
2653         isl_map_free(map);
2654         return NULL;
2655 }
2656
2657 /* Given a basic map A -> f(A) and an integer d, construct a basic map
2658  * A -> floor(f(A)/d).
2659  */
2660 struct isl_basic_map *isl_basic_map_floordiv(struct isl_basic_map *bmap,
2661                 isl_int d)
2662 {
2663         unsigned n_in, n_out, nparam, total, pos;
2664         struct isl_basic_map *result = NULL;
2665         struct isl_dim_map *dim_map;
2666         int i;
2667
2668         if (!bmap)
2669                 return NULL;
2670
2671         nparam = isl_basic_map_n_param(bmap);
2672         n_in = isl_basic_map_n_in(bmap);
2673         n_out = isl_basic_map_n_out(bmap);
2674
2675         total = nparam + n_in + n_out + bmap->n_div + n_out;
2676         dim_map = isl_dim_map_alloc(bmap->ctx, total);
2677         isl_dim_map_dim(dim_map, bmap->dim, isl_dim_param, pos = 0);
2678         isl_dim_map_dim(dim_map, bmap->dim, isl_dim_in, pos += nparam);
2679         isl_dim_map_div(dim_map, bmap, pos += n_in + n_out);
2680         isl_dim_map_dim(dim_map, bmap->dim, isl_dim_out, pos += bmap->n_div);
2681
2682         result = isl_basic_map_alloc_dim(isl_dim_copy(bmap->dim),
2683                         bmap->n_div + n_out,
2684                         bmap->n_eq, bmap->n_ineq + 2 * n_out);
2685         result = add_constraints_dim_map(result, bmap, dim_map);
2686         result = add_divs(result, n_out);
2687         for (i = 0; i < n_out; ++i) {
2688                 int j;
2689                 j = isl_basic_map_alloc_inequality(result);
2690                 if (j < 0)
2691                         goto error;
2692                 isl_seq_clr(result->ineq[j], 1+total);
2693                 isl_int_neg(result->ineq[j][1+nparam+n_in+i], d);
2694                 isl_int_set_si(result->ineq[j][1+pos+i], 1);
2695                 j = isl_basic_map_alloc_inequality(result);
2696                 if (j < 0)
2697                         goto error;
2698                 isl_seq_clr(result->ineq[j], 1+total);
2699                 isl_int_set(result->ineq[j][1+nparam+n_in+i], d);
2700                 isl_int_set_si(result->ineq[j][1+pos+i], -1);
2701                 isl_int_sub_ui(result->ineq[j][0], d, 1);
2702         }
2703
2704         result = isl_basic_map_simplify(result);
2705         return isl_basic_map_finalize(result);
2706 error:
2707         isl_basic_map_free(result);
2708         return NULL;
2709 }
2710
2711 /* Given a map A -> f(A) and an integer d, construct a map
2712  * A -> floor(f(A)/d).
2713  */
2714 struct isl_map *isl_map_floordiv(struct isl_map *map, isl_int d)
2715 {
2716         int i;
2717
2718         map = isl_map_cow(map);
2719         if (!map)
2720                 return NULL;
2721
2722         ISL_F_CLR(map, ISL_MAP_DISJOINT);
2723         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
2724         for (i = 0; i < map->n; ++i) {
2725                 map->p[i] = isl_basic_map_floordiv(map->p[i], d);
2726                 if (!map->p[i])
2727                         goto error;
2728         }
2729
2730         return map;
2731 error:
2732         isl_map_free(map);
2733         return NULL;
2734 }
2735
2736 static struct isl_basic_map *var_equal(struct isl_basic_map *bmap, unsigned pos)
2737 {
2738         int i;
2739         unsigned nparam;
2740         unsigned n_in;
2741
2742         i = isl_basic_map_alloc_equality(bmap);
2743         if (i < 0)
2744                 goto error;
2745         nparam = isl_basic_map_n_param(bmap);
2746         n_in = isl_basic_map_n_in(bmap);
2747         isl_seq_clr(bmap->eq[i], 1 + isl_basic_map_total_dim(bmap));
2748         isl_int_set_si(bmap->eq[i][1+nparam+pos], -1);
2749         isl_int_set_si(bmap->eq[i][1+nparam+n_in+pos], 1);
2750         return isl_basic_map_finalize(bmap);
2751 error:
2752         isl_basic_map_free(bmap);
2753         return NULL;
2754 }
2755
2756 /* Add a constraints to "bmap" expressing i_pos < o_pos
2757  */
2758 static struct isl_basic_map *var_less(struct isl_basic_map *bmap, unsigned pos)
2759 {
2760         int i;
2761         unsigned nparam;
2762         unsigned n_in;
2763
2764         i = isl_basic_map_alloc_inequality(bmap);
2765         if (i < 0)
2766                 goto error;
2767         nparam = isl_basic_map_n_param(bmap);
2768         n_in = isl_basic_map_n_in(bmap);
2769         isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap));
2770         isl_int_set_si(bmap->ineq[i][0], -1);
2771         isl_int_set_si(bmap->ineq[i][1+nparam+pos], -1);
2772         isl_int_set_si(bmap->ineq[i][1+nparam+n_in+pos], 1);
2773         return isl_basic_map_finalize(bmap);
2774 error:
2775         isl_basic_map_free(bmap);
2776         return NULL;
2777 }
2778
2779 /* Add a constraints to "bmap" expressing i_pos > o_pos
2780  */
2781 static struct isl_basic_map *var_more(struct isl_basic_map *bmap, unsigned pos)
2782 {
2783         int i;
2784         unsigned nparam;
2785         unsigned n_in;
2786
2787         i = isl_basic_map_alloc_inequality(bmap);
2788         if (i < 0)
2789                 goto error;
2790         nparam = isl_basic_map_n_param(bmap);
2791         n_in = isl_basic_map_n_in(bmap);
2792         isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap));
2793         isl_int_set_si(bmap->ineq[i][0], -1);
2794         isl_int_set_si(bmap->ineq[i][1+nparam+pos], 1);
2795         isl_int_set_si(bmap->ineq[i][1+nparam+n_in+pos], -1);
2796         return isl_basic_map_finalize(bmap);
2797 error:
2798         isl_basic_map_free(bmap);
2799         return NULL;
2800 }
2801
2802 struct isl_basic_map *isl_basic_map_equal(struct isl_dim *dim, unsigned n_equal)
2803 {
2804         int i;
2805         struct isl_basic_map *bmap;
2806         bmap = isl_basic_map_alloc_dim(dim, 0, n_equal, 0);
2807         if (!bmap)
2808                 return NULL;
2809         for (i = 0; i < n_equal && bmap; ++i)
2810                 bmap = var_equal(bmap, i);
2811         return isl_basic_map_finalize(bmap);
2812 }
2813
2814 /* Return a relation on pairs of sets of dimension "dim" expressing i_pos < o_pos
2815  */
2816 struct isl_basic_map *isl_basic_map_less_at(struct isl_dim *dim, unsigned pos)
2817 {
2818         int i;
2819         struct isl_basic_map *bmap;
2820         bmap = isl_basic_map_alloc_dim(dim, 0, pos, 1);
2821         if (!bmap)
2822                 return NULL;
2823         for (i = 0; i < pos && bmap; ++i)
2824                 bmap = var_equal(bmap, i);
2825         if (bmap)
2826                 bmap = var_less(bmap, pos);
2827         return isl_basic_map_finalize(bmap);
2828 }
2829
2830 /* Return a relation on pairs of sets of dimension "dim" expressing i_pos > o_pos
2831  */
2832 struct isl_basic_map *isl_basic_map_more_at(struct isl_dim *dim, unsigned pos)
2833 {
2834         int i;
2835         struct isl_basic_map *bmap;
2836         bmap = isl_basic_map_alloc_dim(dim, 0, pos, 1);
2837         if (!bmap)
2838                 return NULL;
2839         for (i = 0; i < pos && bmap; ++i)
2840                 bmap = var_equal(bmap, i);
2841         if (bmap)
2842                 bmap = var_more(bmap, pos);
2843         return isl_basic_map_finalize(bmap);
2844 }
2845
2846 static __isl_give isl_map *map_lex_lte(__isl_take isl_dim *dims, int equal)
2847 {
2848         struct isl_map *map;
2849         unsigned dim;
2850         int i;
2851
2852         if (!dims)
2853                 return NULL;
2854         dim = dims->n_out;
2855         map = isl_map_alloc_dim(isl_dim_copy(dims), dim + equal, ISL_MAP_DISJOINT);
2856
2857         for (i = 0; i < dim; ++i)
2858                 map = isl_map_add_basic_map(map,
2859                                   isl_basic_map_less_at(isl_dim_copy(dims), i));
2860         if (equal)
2861                 map = isl_map_add_basic_map(map,
2862                                   isl_basic_map_equal(isl_dim_copy(dims), dim));
2863
2864         isl_dim_free(dims);
2865         return map;
2866 }
2867
2868 __isl_give isl_map *isl_map_lex_lt(__isl_take isl_dim *set_dim)
2869 {
2870         return map_lex_lte(isl_dim_map(set_dim), 0);
2871 }
2872
2873 __isl_give isl_map *isl_map_lex_le(__isl_take isl_dim *set_dim)
2874 {
2875         return map_lex_lte(isl_dim_map(set_dim), 1);
2876 }
2877
2878 static __isl_give isl_map *map_lex_gte(__isl_take isl_dim *dims, int equal)
2879 {
2880         struct isl_map *map;
2881         unsigned dim;
2882         int i;
2883
2884         if (!dims)
2885                 return NULL;
2886         dim = dims->n_out;
2887         map = isl_map_alloc_dim(isl_dim_copy(dims), dim + equal, ISL_MAP_DISJOINT);
2888
2889         for (i = 0; i < dim; ++i)
2890                 map = isl_map_add_basic_map(map,
2891                                   isl_basic_map_more_at(isl_dim_copy(dims), i));
2892         if (equal)
2893                 map = isl_map_add_basic_map(map,
2894                                   isl_basic_map_equal(isl_dim_copy(dims), dim));
2895
2896         isl_dim_free(dims);
2897         return map;
2898 }
2899
2900 __isl_give isl_map *isl_map_lex_gt(__isl_take isl_dim *set_dim)
2901 {
2902         return map_lex_gte(isl_dim_map(set_dim), 0);
2903 }
2904
2905 __isl_give isl_map *isl_map_lex_ge(__isl_take isl_dim *set_dim)
2906 {
2907         return map_lex_gte(isl_dim_map(set_dim), 1);
2908 }
2909
2910 struct isl_basic_map *isl_basic_map_from_basic_set(
2911                 struct isl_basic_set *bset, struct isl_dim *dim)
2912 {
2913         struct isl_basic_map *bmap;
2914
2915         bset = isl_basic_set_cow(bset);
2916         if (!bset || !dim)
2917                 goto error;
2918
2919         isl_assert(bset->ctx, isl_dim_compatible(bset->dim, dim), goto error);
2920         isl_dim_free(bset->dim);
2921         bmap = (struct isl_basic_map *) bset;
2922         bmap->dim = dim;
2923         return isl_basic_map_finalize(bmap);
2924 error:
2925         isl_basic_set_free(bset);
2926         isl_dim_free(dim);
2927         return NULL;
2928 }
2929
2930 struct isl_basic_set *isl_basic_set_from_basic_map(struct isl_basic_map *bmap)
2931 {
2932         if (!bmap)
2933                 goto error;
2934         if (bmap->dim->n_in == 0)
2935                 return (struct isl_basic_set *)bmap;
2936         bmap = isl_basic_map_cow(bmap);
2937         if (!bmap)
2938                 goto error;
2939         bmap->dim = isl_dim_cow(bmap->dim);
2940         if (!bmap->dim)
2941                 goto error;
2942         bmap->dim->n_out += bmap->dim->n_in;
2943         bmap->dim->n_in = 0;
2944         bmap = isl_basic_map_finalize(bmap);
2945         return (struct isl_basic_set *)bmap;
2946 error:
2947         isl_basic_map_free(bmap);
2948         return NULL;
2949 }
2950
2951 /* For a div d = floor(f/m), add the constraints
2952  *
2953  *              f - m d >= 0
2954  *              -(f-(n-1)) + m d >= 0
2955  *
2956  * Note that the second constraint is the negation of
2957  *
2958  *              f - m d >= n
2959  */
2960 int isl_basic_map_add_div_constraints(struct isl_basic_map *bmap, unsigned div)
2961 {
2962         int i, j;
2963         unsigned total = isl_basic_map_total_dim(bmap);
2964         unsigned div_pos = 1 + total - bmap->n_div + div;
2965
2966         i = isl_basic_map_alloc_inequality(bmap);
2967         if (i < 0)
2968                 return -1;
2969         isl_seq_cpy(bmap->ineq[i], bmap->div[div]+1, 1+total);
2970         isl_int_neg(bmap->ineq[i][div_pos], bmap->div[div][0]);
2971
2972         j = isl_basic_map_alloc_inequality(bmap);
2973         if (j < 0)
2974                 return -1;
2975         isl_seq_neg(bmap->ineq[j], bmap->ineq[i], 1 + total);
2976         isl_int_add(bmap->ineq[j][0], bmap->ineq[j][0], bmap->ineq[j][div_pos]);
2977         isl_int_sub_ui(bmap->ineq[j][0], bmap->ineq[j][0], 1);
2978         return j;
2979 }
2980
2981 struct isl_basic_set *isl_basic_map_underlying_set(
2982                 struct isl_basic_map *bmap)
2983 {
2984         if (!bmap)
2985                 goto error;
2986         if (bmap->dim->nparam == 0 && bmap->dim->n_in == 0 && bmap->n_div == 0)
2987                 return (struct isl_basic_set *)bmap;
2988         bmap = isl_basic_map_cow(bmap);
2989         if (!bmap)
2990                 goto error;
2991         bmap->dim = isl_dim_underlying(bmap->dim, bmap->n_div);
2992         if (!bmap->dim)
2993                 goto error;
2994         bmap->extra -= bmap->n_div;
2995         bmap->n_div = 0;
2996         bmap = isl_basic_map_finalize(bmap);
2997         return (struct isl_basic_set *)bmap;
2998 error:
2999         return NULL;
3000 }
3001
3002 __isl_give isl_basic_set *isl_basic_set_underlying_set(
3003                 __isl_take isl_basic_set *bset)
3004 {
3005         return isl_basic_map_underlying_set((isl_basic_map *)bset);
3006 }
3007
3008 struct isl_basic_map *isl_basic_map_overlying_set(
3009         struct isl_basic_set *bset, struct isl_basic_map *like)
3010 {
3011         struct isl_basic_map *bmap;
3012         struct isl_ctx *ctx;
3013         unsigned total;
3014         int i;
3015
3016         if (!bset || !like)
3017                 goto error;
3018         ctx = bset->ctx;
3019         isl_assert(ctx, bset->n_div == 0, goto error);
3020         isl_assert(ctx, isl_basic_set_n_param(bset) == 0, goto error);
3021         isl_assert(ctx, bset->dim->n_out == isl_basic_map_total_dim(like),
3022                         goto error);
3023         if (isl_dim_equal(bset->dim, like->dim) && like->n_div == 0) {
3024                 isl_basic_map_free(like);
3025                 return (struct isl_basic_map *)bset;
3026         }
3027         bset = isl_basic_set_cow(bset);
3028         if (!bset)
3029                 goto error;
3030         total = bset->dim->n_out + bset->extra;
3031         bmap = (struct isl_basic_map *)bset;
3032         isl_dim_free(bmap->dim);
3033         bmap->dim = isl_dim_copy(like->dim);
3034         if (!bmap->dim)
3035                 goto error;
3036         bmap->n_div = like->n_div;
3037         bmap->extra += like->n_div;
3038         if (bmap->extra) {
3039                 unsigned ltotal;
3040                 ltotal = total - bmap->extra + like->extra;
3041                 if (ltotal > total)
3042                         ltotal = total;
3043                 bmap->block2 = isl_blk_extend(ctx, bmap->block2,
3044                                         bmap->extra * (1 + 1 + total));
3045                 if (isl_blk_is_error(bmap->block2))
3046                         goto error;
3047                 bmap->div = isl_realloc_array(ctx, bmap->div, isl_int *,
3048                                                 bmap->extra);
3049                 if (!bmap->div)
3050                         goto error;
3051                 for (i = 0; i < bmap->extra; ++i)
3052                         bmap->div[i] = bmap->block2.data + i * (1 + 1 + total);
3053                 for (i = 0; i < like->n_div; ++i) {
3054                         isl_seq_cpy(bmap->div[i], like->div[i], 1 + 1 + ltotal);
3055                         isl_seq_clr(bmap->div[i]+1+1+ltotal, total - ltotal);
3056                 }
3057                 bmap = isl_basic_map_extend_constraints(bmap,
3058                                                         0, 2 * like->n_div);
3059                 for (i = 0; i < like->n_div; ++i) {
3060                         if (isl_int_is_zero(bmap->div[i][0]))
3061                                 continue;
3062                         if (isl_basic_map_add_div_constraints(bmap, i) < 0)
3063                                 goto error;
3064                 }
3065         }
3066         isl_basic_map_free(like);
3067         bmap = isl_basic_map_simplify(bmap);
3068         bmap = isl_basic_map_finalize(bmap);
3069         return bmap;
3070 error:
3071         isl_basic_map_free(like);
3072         isl_basic_set_free(bset);
3073         return NULL;
3074 }
3075
3076 struct isl_basic_set *isl_basic_set_from_underlying_set(
3077         struct isl_basic_set *bset, struct isl_basic_set *like)
3078 {
3079         return (struct isl_basic_set *)
3080                 isl_basic_map_overlying_set(bset, (struct isl_basic_map *)like);
3081 }
3082
3083 struct isl_set *isl_set_from_underlying_set(
3084         struct isl_set *set, struct isl_basic_set *like)
3085 {
3086         int i;
3087
3088         if (!set || !like)
3089                 goto error;
3090         isl_assert(set->ctx, set->dim->n_out == isl_basic_set_total_dim(like),
3091                     goto error);
3092         if (isl_dim_equal(set->dim, like->dim) && like->n_div == 0) {
3093                 isl_basic_set_free(like);
3094                 return set;
3095         }
3096         set = isl_set_cow(set);
3097         if (!set)
3098                 goto error;
3099         for (i = 0; i < set->n; ++i) {
3100                 set->p[i] = isl_basic_set_from_underlying_set(set->p[i],
3101                                                       isl_basic_set_copy(like));
3102                 if (!set->p[i])
3103                         goto error;
3104         }
3105         isl_dim_free(set->dim);
3106         set->dim = isl_dim_copy(like->dim);
3107         if (!set->dim)
3108                 goto error;
3109         isl_basic_set_free(like);
3110         return set;
3111 error:
3112         isl_basic_set_free(like);
3113         isl_set_free(set);
3114         return NULL;
3115 }
3116
3117 struct isl_set *isl_map_underlying_set(struct isl_map *map)
3118 {
3119         int i;
3120
3121         map = isl_map_cow(map);
3122         if (!map)
3123                 return NULL;
3124         map->dim = isl_dim_cow(map->dim);
3125         if (!map->dim)
3126                 goto error;
3127
3128         for (i = 1; i < map->n; ++i)
3129                 isl_assert(map->ctx, map->p[0]->n_div == map->p[i]->n_div,
3130                                 goto error);
3131         for (i = 0; i < map->n; ++i) {
3132                 map->p[i] = (struct isl_basic_map *)
3133                                 isl_basic_map_underlying_set(map->p[i]);
3134                 if (!map->p[i])
3135                         goto error;
3136         }
3137         if (map->n == 0)
3138                 map->dim = isl_dim_underlying(map->dim, 0);
3139         else {
3140                 isl_dim_free(map->dim);
3141                 map->dim = isl_dim_copy(map->p[0]->dim);
3142         }
3143         if (!map->dim)
3144                 goto error;
3145         return (struct isl_set *)map;
3146 error:
3147         isl_map_free(map);
3148         return NULL;
3149 }
3150
3151 struct isl_set *isl_set_to_underlying_set(struct isl_set *set)
3152 {
3153         return (struct isl_set *)isl_map_underlying_set((struct isl_map *)set);
3154 }
3155
3156 struct isl_basic_set *isl_basic_map_domain(struct isl_basic_map *bmap)
3157 {
3158         struct isl_basic_set *domain;
3159         unsigned n_in;
3160         unsigned n_out;
3161         if (!bmap)
3162                 return NULL;
3163         n_in = isl_basic_map_n_in(bmap);
3164         n_out = isl_basic_map_n_out(bmap);
3165         domain = isl_basic_set_from_basic_map(bmap);
3166         return isl_basic_set_project_out(domain, isl_dim_set, n_in, n_out);
3167 }
3168
3169 struct isl_basic_set *isl_basic_map_range(struct isl_basic_map *bmap)
3170 {
3171         return isl_basic_map_domain(isl_basic_map_reverse(bmap));
3172 }
3173
3174 struct isl_set *isl_map_range(struct isl_map *map)
3175 {
3176         int i;
3177         struct isl_set *set;
3178
3179         if (!map)
3180                 goto error;
3181         if (isl_map_dim(map, isl_dim_in) == 0)
3182                 return (isl_set *)map;
3183
3184         map = isl_map_cow(map);
3185         if (!map)
3186                 goto error;
3187
3188         set = (struct isl_set *) map;
3189         set->dim = isl_dim_drop_inputs(set->dim, 0, set->dim->n_in);
3190         if (!set->dim)
3191                 goto error;
3192         for (i = 0; i < map->n; ++i) {
3193                 set->p[i] = isl_basic_map_range(map->p[i]);
3194                 if (!set->p[i])
3195                         goto error;
3196         }
3197         ISL_F_CLR(set, ISL_MAP_DISJOINT);
3198         ISL_F_CLR(set, ISL_SET_NORMALIZED);
3199         return set;
3200 error:
3201         isl_map_free(map);
3202         return NULL;
3203 }
3204
3205 struct isl_map *isl_map_from_set(struct isl_set *set, struct isl_dim *dim)
3206 {
3207         int i;
3208         struct isl_map *map = NULL;
3209
3210         set = isl_set_cow(set);
3211         if (!set || !dim)
3212                 goto error;
3213         isl_assert(set->ctx, isl_dim_compatible(set->dim, dim), goto error);
3214         map = (struct isl_map *)set;
3215         for (i = 0; i < set->n; ++i) {
3216                 map->p[i] = isl_basic_map_from_basic_set(
3217                                 set->p[i], isl_dim_copy(dim));
3218                 if (!map->p[i])
3219                         goto error;
3220         }
3221         isl_dim_free(map->dim);
3222         map->dim = dim;
3223         return map;
3224 error:
3225         isl_dim_free(dim);
3226         isl_set_free(set);
3227         return NULL;
3228 }
3229
3230 struct isl_map *isl_map_from_range(struct isl_set *set)
3231 {
3232         return (struct isl_map *)set;
3233 }
3234
3235 __isl_give isl_map *isl_map_from_domain(__isl_take isl_set *set)
3236 {
3237         return isl_map_reverse(isl_map_from_range(set));;
3238 }
3239
3240 __isl_give isl_map *isl_map_from_domain_and_range(__isl_take isl_set *domain,
3241         __isl_take isl_set *range)
3242 {
3243         return isl_map_product(isl_map_from_domain(domain),
3244                                isl_map_from_range(range));
3245 }
3246
3247 struct isl_set *isl_set_from_map(struct isl_map *map)
3248 {
3249         int i;
3250         struct isl_set *set = NULL;
3251
3252         if (!map)
3253                 return NULL;
3254         map = isl_map_cow(map);
3255         if (!map)
3256                 return NULL;
3257         map->dim = isl_dim_cow(map->dim);
3258         if (!map->dim)
3259                 goto error;
3260         map->dim->n_out += map->dim->n_in;
3261         map->dim->n_in = 0;
3262         set = (struct isl_set *)map;
3263         for (i = 0; i < map->n; ++i) {
3264                 set->p[i] = isl_basic_set_from_basic_map(map->p[i]);
3265                 if (!set->p[i])
3266                         goto error;
3267         }
3268         return set;
3269 error:
3270         isl_map_free(map);
3271         return NULL;
3272 }
3273
3274 struct isl_map *isl_map_alloc_dim(struct isl_dim *dim, int n, unsigned flags)
3275 {
3276         struct isl_map *map;
3277
3278         if (!dim)
3279                 return NULL;
3280         isl_assert(dim->ctx, n >= 0, return NULL);
3281         map = isl_alloc(dim->ctx, struct isl_map,
3282                         sizeof(struct isl_map) +
3283                         (n - 1) * sizeof(struct isl_basic_map *));
3284         if (!map)
3285                 goto error;
3286
3287         map->ctx = dim->ctx;
3288         isl_ctx_ref(map->ctx);
3289         map->ref = 1;
3290         map->size = n;
3291         map->n = 0;
3292         map->dim = dim;
3293         map->flags = flags;
3294         return map;
3295 error:
3296         isl_dim_free(dim);
3297         return NULL;
3298 }
3299
3300 struct isl_map *isl_map_alloc(struct isl_ctx *ctx,
3301                 unsigned nparam, unsigned in, unsigned out, int n,
3302                 unsigned flags)
3303 {
3304         struct isl_map *map;
3305         struct isl_dim *dims;
3306
3307         dims = isl_dim_alloc(ctx, nparam, in, out);
3308         if (!dims)
3309                 return NULL;
3310
3311         map = isl_map_alloc_dim(dims, n, flags);
3312         return map;
3313 }
3314
3315 struct isl_basic_map *isl_basic_map_empty(struct isl_dim *dim)
3316 {
3317         struct isl_basic_map *bmap;
3318         bmap = isl_basic_map_alloc_dim(dim, 0, 1, 0);
3319         bmap = isl_basic_map_set_to_empty(bmap);
3320         return bmap;
3321 }
3322
3323 struct isl_basic_set *isl_basic_set_empty(struct isl_dim *dim)
3324 {
3325         struct isl_basic_set *bset;
3326         bset = isl_basic_set_alloc_dim(dim, 0, 1, 0);
3327         bset = isl_basic_set_set_to_empty(bset);
3328         return bset;
3329 }
3330
3331 struct isl_basic_map *isl_basic_map_empty_like(struct isl_basic_map *model)
3332 {
3333         struct isl_basic_map *bmap;
3334         if (!model)
3335                 return NULL;
3336         bmap = isl_basic_map_alloc_dim(isl_dim_copy(model->dim), 0, 1, 0);
3337         bmap = isl_basic_map_set_to_empty(bmap);
3338         return bmap;
3339 }
3340
3341 struct isl_basic_map *isl_basic_map_empty_like_map(struct isl_map *model)
3342 {
3343         struct isl_basic_map *bmap;
3344         if (!model)
3345                 return NULL;
3346         bmap = isl_basic_map_alloc_dim(isl_dim_copy(model->dim), 0, 1, 0);
3347         bmap = isl_basic_map_set_to_empty(bmap);
3348         return bmap;
3349 }
3350
3351 struct isl_basic_set *isl_basic_set_empty_like(struct isl_basic_set *model)
3352 {
3353         struct isl_basic_set *bset;
3354         if (!model)
3355                 return NULL;
3356         bset = isl_basic_set_alloc_dim(isl_dim_copy(model->dim), 0, 1, 0);
3357         bset = isl_basic_set_set_to_empty(bset);
3358         return bset;
3359 }
3360
3361 struct isl_basic_map *isl_basic_map_universe(struct isl_dim *dim)
3362 {
3363         struct isl_basic_map *bmap;
3364         bmap = isl_basic_map_alloc_dim(dim, 0, 0, 0);
3365         return bmap;
3366 }
3367
3368 struct isl_basic_set *isl_basic_set_universe(struct isl_dim *dim)
3369 {
3370         struct isl_basic_set *bset;
3371         bset = isl_basic_set_alloc_dim(dim, 0, 0, 0);
3372         return bset;
3373 }
3374
3375 __isl_give isl_basic_map *isl_basic_map_universe_like(
3376                 __isl_keep isl_basic_map *model)
3377 {
3378         if (!model)
3379                 return NULL;
3380         return isl_basic_map_alloc_dim(isl_dim_copy(model->dim), 0, 0, 0);
3381 }
3382
3383 struct isl_basic_set *isl_basic_set_universe_like(struct isl_basic_set *model)
3384 {
3385         if (!model)
3386                 return NULL;
3387         return isl_basic_set_alloc_dim(isl_dim_copy(model->dim), 0, 0, 0);
3388 }
3389
3390 __isl_give isl_basic_set *isl_basic_set_universe_like_set(
3391         __isl_keep isl_set *model)
3392 {
3393         if (!model)
3394                 return NULL;
3395         return isl_basic_set_alloc_dim(isl_dim_copy(model->dim), 0, 0, 0);
3396 }
3397
3398 struct isl_map *isl_map_empty(struct isl_dim *dim)
3399 {
3400         return isl_map_alloc_dim(dim, 0, ISL_MAP_DISJOINT);
3401 }
3402
3403 struct isl_map *isl_map_empty_like(struct isl_map *model)
3404 {
3405         if (!model)
3406                 return NULL;
3407         return isl_map_alloc_dim(isl_dim_copy(model->dim), 0, ISL_MAP_DISJOINT);
3408 }
3409
3410 struct isl_map *isl_map_empty_like_basic_map(struct isl_basic_map *model)
3411 {
3412         if (!model)
3413                 return NULL;
3414         return isl_map_alloc_dim(isl_dim_copy(model->dim), 0, ISL_MAP_DISJOINT);
3415 }
3416
3417 struct isl_set *isl_set_empty(struct isl_dim *dim)
3418 {
3419         return isl_set_alloc_dim(dim, 0, ISL_MAP_DISJOINT);
3420 }
3421
3422 struct isl_set *isl_set_empty_like(struct isl_set *model)
3423 {
3424         if (!model)
3425                 return NULL;
3426         return isl_set_empty(isl_dim_copy(model->dim));
3427 }
3428
3429 struct isl_map *isl_map_universe(struct isl_dim *dim)
3430 {
3431         struct isl_map *map;
3432         if (!dim)
3433                 return NULL;
3434         map = isl_map_alloc_dim(isl_dim_copy(dim), 1, ISL_MAP_DISJOINT);
3435         map = isl_map_add_basic_map(map, isl_basic_map_universe(dim));
3436         return map;
3437 }
3438
3439 struct isl_set *isl_set_universe(struct isl_dim *dim)
3440 {
3441         struct isl_set *set;
3442         if (!dim)
3443                 return NULL;
3444         set = isl_set_alloc_dim(isl_dim_copy(dim), 1, ISL_MAP_DISJOINT);
3445         set = isl_set_add_basic_set(set, isl_basic_set_universe(dim));
3446         return set;
3447 }
3448
3449 __isl_give isl_set *isl_set_universe_like(__isl_keep isl_set *model)
3450 {
3451         if (!model)
3452                 return NULL;
3453         return isl_set_universe(isl_dim_copy(model->dim));
3454 }
3455
3456 struct isl_map *isl_map_dup(struct isl_map *map)
3457 {
3458         int i;
3459         struct isl_map *dup;
3460
3461         if (!map)
3462                 return NULL;
3463         dup = isl_map_alloc_dim(isl_dim_copy(map->dim), map->n, map->flags);
3464         for (i = 0; i < map->n; ++i)
3465                 dup = isl_map_add_basic_map(dup, isl_basic_map_copy(map->p[i]));
3466         return dup;
3467 }
3468
3469 __isl_give isl_map *isl_map_add_basic_map(__isl_take isl_map *map,
3470                                                 __isl_take isl_basic_map *bmap)
3471 {
3472         if (!bmap || !map)
3473                 goto error;
3474         if (isl_basic_map_fast_is_empty(bmap)) {
3475                 isl_basic_map_free(bmap);
3476                 return map;
3477         }
3478         isl_assert(map->ctx, isl_dim_equal(map->dim, bmap->dim), goto error);
3479         isl_assert(map->ctx, map->n < map->size, goto error);
3480         map->p[map->n] = bmap;
3481         map->n++;
3482         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
3483         return map;
3484 error:
3485         if (map)
3486                 isl_map_free(map);
3487         if (bmap)
3488                 isl_basic_map_free(bmap);
3489         return NULL;
3490 }
3491
3492 void isl_map_free(struct isl_map *map)
3493 {
3494         int i;
3495
3496         if (!map)
3497                 return;
3498
3499         if (--map->ref > 0)
3500                 return;
3501
3502         isl_ctx_deref(map->ctx);
3503         for (i = 0; i < map->n; ++i)
3504                 isl_basic_map_free(map->p[i]);
3505         isl_dim_free(map->dim);
3506         free(map);
3507 }
3508
3509 struct isl_map *isl_map_extend(struct isl_map *base,
3510                 unsigned nparam, unsigned n_in, unsigned n_out)
3511 {
3512         int i;
3513
3514         base = isl_map_cow(base);
3515         if (!base)
3516                 return NULL;
3517
3518         base->dim = isl_dim_extend(base->dim, nparam, n_in, n_out);
3519         if (!base->dim)
3520                 goto error;
3521         for (i = 0; i < base->n; ++i) {
3522                 base->p[i] = isl_basic_map_extend_dim(base->p[i],
3523                                 isl_dim_copy(base->dim), 0, 0, 0);
3524                 if (!base->p[i])
3525                         goto error;
3526         }
3527         return base;
3528 error:
3529         isl_map_free(base);
3530         return NULL;
3531 }
3532
3533 struct isl_set *isl_set_extend(struct isl_set *base,
3534                 unsigned nparam, unsigned dim)
3535 {
3536         return (struct isl_set *)isl_map_extend((struct isl_map *)base,
3537                                                         nparam, 0, dim);
3538 }
3539
3540 static struct isl_basic_map *isl_basic_map_fix_pos_si(
3541         struct isl_basic_map *bmap, unsigned pos, int value)
3542 {
3543         int j;
3544
3545         bmap = isl_basic_map_cow(bmap);
3546         bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
3547         j = isl_basic_map_alloc_equality(bmap);
3548         if (j < 0)
3549                 goto error;
3550         isl_seq_clr(bmap->eq[j] + 1, isl_basic_map_total_dim(bmap));
3551         isl_int_set_si(bmap->eq[j][pos], -1);
3552         isl_int_set_si(bmap->eq[j][0], value);
3553         bmap = isl_basic_map_simplify(bmap);
3554         return isl_basic_map_finalize(bmap);
3555 error:
3556         isl_basic_map_free(bmap);
3557         return NULL;
3558 }
3559
3560 static __isl_give isl_basic_map *isl_basic_map_fix_pos(
3561         __isl_take isl_basic_map *bmap, unsigned pos, isl_int value)
3562 {
3563         int j;
3564
3565         bmap = isl_basic_map_cow(bmap);
3566         bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
3567         j = isl_basic_map_alloc_equality(bmap);
3568         if (j < 0)
3569                 goto error;
3570         isl_seq_clr(bmap->eq[j] + 1, isl_basic_map_total_dim(bmap));
3571         isl_int_set_si(bmap->eq[j][pos], -1);
3572         isl_int_set(bmap->eq[j][0], value);
3573         bmap = isl_basic_map_simplify(bmap);
3574         return isl_basic_map_finalize(bmap);
3575 error:
3576         isl_basic_map_free(bmap);
3577         return NULL;
3578 }
3579
3580 struct isl_basic_map *isl_basic_map_fix_si(struct isl_basic_map *bmap,
3581                 enum isl_dim_type type, unsigned pos, int value)
3582 {
3583         if (!bmap)
3584                 return NULL;
3585         isl_assert(bmap->ctx, pos < isl_basic_map_dim(bmap, type), goto error);
3586         return isl_basic_map_fix_pos_si(bmap,
3587                 isl_basic_map_offset(bmap, type) + pos, value);
3588 error:
3589         isl_basic_map_free(bmap);
3590         return NULL;
3591 }
3592
3593 __isl_give isl_basic_map *isl_basic_map_fix(__isl_take isl_basic_map *bmap,
3594                 enum isl_dim_type type, unsigned pos, isl_int value)
3595 {
3596         if (!bmap)
3597                 return NULL;
3598         isl_assert(bmap->ctx, pos < isl_basic_map_dim(bmap, type), goto error);
3599         return isl_basic_map_fix_pos(bmap,
3600                 isl_basic_map_offset(bmap, type) + pos, value);
3601 error:
3602         isl_basic_map_free(bmap);
3603         return NULL;
3604 }
3605
3606 struct isl_basic_set *isl_basic_set_fix_si(struct isl_basic_set *bset,
3607                 enum isl_dim_type type, unsigned pos, int value)
3608 {
3609         return (struct isl_basic_set *)
3610                 isl_basic_map_fix_si((struct isl_basic_map *)bset,
3611                                         type, pos, value);
3612 }
3613
3614 __isl_give isl_basic_set *isl_basic_set_fix(__isl_take isl_basic_set *bset,
3615                 enum isl_dim_type type, unsigned pos, isl_int value)
3616 {
3617         return (struct isl_basic_set *)
3618                 isl_basic_map_fix((struct isl_basic_map *)bset,
3619                                         type, pos, value);
3620 }
3621
3622 struct isl_basic_map *isl_basic_map_fix_input_si(struct isl_basic_map *bmap,
3623                 unsigned input, int value)
3624 {
3625         return isl_basic_map_fix_si(bmap, isl_dim_in, input, value);
3626 }
3627
3628 struct isl_basic_set *isl_basic_set_fix_dim_si(struct isl_basic_set *bset,
3629                 unsigned dim, int value)
3630 {
3631         return (struct isl_basic_set *)
3632                 isl_basic_map_fix_si((struct isl_basic_map *)bset,
3633                                         isl_dim_set, dim, value);
3634 }
3635
3636 struct isl_map *isl_map_fix_si(struct isl_map *map,
3637                 enum isl_dim_type type, unsigned pos, int value)
3638 {
3639         int i;
3640
3641         map = isl_map_cow(map);
3642         if (!map)
3643                 return NULL;
3644
3645         isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error);
3646         for (i = 0; i < map->n; ++i) {
3647                 map->p[i] = isl_basic_map_fix_si(map->p[i], type, pos, value);
3648                 if (!map->p[i])
3649                         goto error;
3650         }
3651         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
3652         return map;
3653 error:
3654         isl_map_free(map);
3655         return NULL;
3656 }
3657
3658 __isl_give isl_set *isl_set_fix_si(__isl_take isl_set *set,
3659                 enum isl_dim_type type, unsigned pos, int value)
3660 {
3661         return (struct isl_set *)
3662                 isl_map_fix_si((struct isl_map *)set, type, pos, value);
3663 }
3664
3665 __isl_give isl_map *isl_map_fix(__isl_take isl_map *map,
3666                 enum isl_dim_type type, unsigned pos, isl_int value)
3667 {
3668         int i;
3669
3670         map = isl_map_cow(map);
3671         if (!map)
3672                 return NULL;
3673
3674         isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error);
3675         for (i = 0; i < map->n; ++i) {
3676                 map->p[i] = isl_basic_map_fix(map->p[i], type, pos, value);
3677                 if (!map->p[i])
3678                         goto error;
3679         }
3680         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
3681         return map;
3682 error:
3683         isl_map_free(map);
3684         return NULL;
3685 }
3686
3687 __isl_give isl_set *isl_set_fix(__isl_take isl_set *set,
3688                 enum isl_dim_type type, unsigned pos, isl_int value)
3689 {
3690         return (struct isl_set *)isl_map_fix((isl_map *)set, type, pos, value);
3691 }
3692
3693 struct isl_map *isl_map_fix_input_si(struct isl_map *map,
3694                 unsigned input, int value)
3695 {
3696         return isl_map_fix_si(map, isl_dim_in, input, value);
3697 }
3698
3699 struct isl_set *isl_set_fix_dim_si(struct isl_set *set, unsigned dim, int value)
3700 {
3701         return (struct isl_set *)
3702                 isl_map_fix_si((struct isl_map *)set, isl_dim_set, dim, value);
3703 }
3704
3705 __isl_give isl_basic_map *isl_basic_map_lower_bound_si(
3706                 __isl_take isl_basic_map *bmap,
3707                 enum isl_dim_type type, unsigned pos, int value)
3708 {
3709         int j;
3710
3711         if (!bmap)
3712                 return NULL;
3713         isl_assert(bmap->ctx, pos < isl_basic_map_dim(bmap, type), goto error);
3714         pos += isl_basic_map_offset(bmap, type);
3715         bmap = isl_basic_map_cow(bmap);
3716         bmap = isl_basic_map_extend_constraints(bmap, 0, 1);
3717         j = isl_basic_map_alloc_inequality(bmap);
3718         if (j < 0)
3719                 goto error;
3720         isl_seq_clr(bmap->ineq[j], 1 + isl_basic_map_total_dim(bmap));
3721         isl_int_set_si(bmap->ineq[j][pos], 1);
3722         isl_int_set_si(bmap->ineq[j][0], -value);
3723         bmap = isl_basic_map_simplify(bmap);
3724         return isl_basic_map_finalize(bmap);
3725 error:
3726         isl_basic_map_free(bmap);
3727         return NULL;
3728 }
3729
3730 struct isl_basic_set *isl_basic_set_lower_bound_dim(struct isl_basic_set *bset,
3731         unsigned dim, isl_int value)
3732 {
3733         int j;
3734
3735         bset = isl_basic_set_cow(bset);
3736         bset = isl_basic_set_extend_constraints(bset, 0, 1);
3737         j = isl_basic_set_alloc_inequality(bset);
3738         if (j < 0)
3739                 goto error;
3740         isl_seq_clr(bset->ineq[j], 1 + isl_basic_set_total_dim(bset));
3741         isl_int_set_si(bset->ineq[j][1 + isl_basic_set_n_param(bset) + dim], 1);
3742         isl_int_neg(bset->ineq[j][0], value);
3743         bset = isl_basic_set_simplify(bset);
3744         return isl_basic_set_finalize(bset);
3745 error:
3746         isl_basic_set_free(bset);
3747         return NULL;
3748 }
3749
3750 __isl_give isl_map *isl_map_lower_bound_si(__isl_take isl_map *map,
3751                 enum isl_dim_type type, unsigned pos, int value)
3752 {
3753         int i;
3754
3755         map = isl_map_cow(map);
3756         if (!map)
3757                 return NULL;
3758
3759         isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error);
3760         for (i = 0; i < map->n; ++i) {
3761                 map->p[i] = isl_basic_map_lower_bound_si(map->p[i],
3762                                                          type, pos, value);
3763                 if (!map->p[i])
3764                         goto error;
3765         }
3766         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
3767         return map;
3768 error:
3769         isl_map_free(map);
3770         return NULL;
3771 }
3772
3773 __isl_give isl_set *isl_set_lower_bound_si(__isl_take isl_set *set,
3774                 enum isl_dim_type type, unsigned pos, int value)
3775 {
3776         return (struct isl_set *)
3777                 isl_map_lower_bound_si((struct isl_map *)set, type, pos, value);
3778 }
3779
3780 struct isl_set *isl_set_lower_bound_dim(struct isl_set *set, unsigned dim,
3781                                         isl_int value)
3782 {
3783         int i;
3784
3785         set = isl_set_cow(set);
3786         if (!set)
3787                 return NULL;
3788
3789         isl_assert(set->ctx, dim < isl_set_n_dim(set), goto error);
3790         for (i = 0; i < set->n; ++i) {
3791                 set->p[i] = isl_basic_set_lower_bound_dim(set->p[i], dim, value);
3792                 if (!set->p[i])
3793                         goto error;
3794         }
3795         return set;
3796 error:
3797         isl_set_free(set);
3798         return NULL;
3799 }
3800
3801 struct isl_map *isl_map_reverse(struct isl_map *map)
3802 {
3803         int i;
3804
3805         map = isl_map_cow(map);
3806         if (!map)
3807                 return NULL;
3808
3809         map->dim = isl_dim_reverse(map->dim);
3810         if (!map->dim)
3811                 goto error;
3812         for (i = 0; i < map->n; ++i) {
3813                 map->p[i] = isl_basic_map_reverse(map->p[i]);
3814                 if (!map->p[i])
3815                         goto error;
3816         }
3817         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
3818         return map;
3819 error:
3820         isl_map_free(map);
3821         return NULL;
3822 }
3823
3824 static struct isl_map *isl_basic_map_partial_lexopt(
3825                 struct isl_basic_map *bmap, struct isl_basic_set *dom,
3826                 struct isl_set **empty, int max)
3827 {
3828         if (!bmap)
3829                 goto error;
3830         if (bmap->ctx->opt->pip == ISL_PIP_PIP)
3831                 return isl_pip_basic_map_lexopt(bmap, dom, empty, max);
3832         else
3833                 return isl_tab_basic_map_partial_lexopt(bmap, dom, empty, max);
3834 error:
3835         isl_basic_map_free(bmap);
3836         isl_basic_set_free(dom);
3837         if (empty)
3838                 *empty = NULL;
3839         return NULL;
3840 }
3841
3842 struct isl_map *isl_basic_map_partial_lexmax(
3843                 struct isl_basic_map *bmap, struct isl_basic_set *dom,
3844                 struct isl_set **empty)
3845 {
3846         return isl_basic_map_partial_lexopt(bmap, dom, empty, 1);
3847 }
3848
3849 struct isl_map *isl_basic_map_partial_lexmin(
3850                 struct isl_basic_map *bmap, struct isl_basic_set *dom,
3851                 struct isl_set **empty)
3852 {
3853         return isl_basic_map_partial_lexopt(bmap, dom, empty, 0);
3854 }
3855
3856 struct isl_set *isl_basic_set_partial_lexmin(
3857                 struct isl_basic_set *bset, struct isl_basic_set *dom,
3858                 struct isl_set **empty)
3859 {
3860         return (struct isl_set *)
3861                 isl_basic_map_partial_lexmin((struct isl_basic_map *)bset,
3862                         dom, empty);
3863 }
3864
3865 struct isl_set *isl_basic_set_partial_lexmax(
3866                 struct isl_basic_set *bset, struct isl_basic_set *dom,
3867                 struct isl_set **empty)
3868 {
3869         return (struct isl_set *)
3870                 isl_basic_map_partial_lexmax((struct isl_basic_map *)bset,
3871                         dom, empty);
3872 }
3873
3874 /* Given a basic map "bmap", compute the lexicograhically minimal
3875  * (or maximal) image element for each domain element in dom.
3876  * Set *empty to those elements in dom that do not have an image element.
3877  *
3878  * We first make sure the basic sets in dom are disjoint and then
3879  * simply collect the results over each of the basic sets separately.
3880  * We could probably improve the efficiency a bit by moving the union
3881  * domain down into the parametric integer programming.
3882  */
3883 static __isl_give isl_map *basic_map_partial_lexopt(
3884                 __isl_take isl_basic_map *bmap, __isl_take isl_set *dom,
3885                 __isl_give isl_set **empty, int max)
3886 {
3887         int i;
3888         struct isl_map *res;
3889
3890         dom = isl_set_make_disjoint(dom);
3891         if (!dom)
3892                 goto error;
3893
3894         if (isl_set_fast_is_empty(dom)) {
3895                 res = isl_map_empty_like_basic_map(bmap);
3896                 *empty = isl_set_empty_like(dom);
3897                 isl_set_free(dom);
3898                 isl_basic_map_free(bmap);
3899                 return res;
3900         }
3901
3902         res = isl_basic_map_partial_lexopt(isl_basic_map_copy(bmap),
3903                         isl_basic_set_copy(dom->p[0]), empty, max);
3904
3905         for (i = 1; i < dom->n; ++i) {
3906                 struct isl_map *res_i;
3907                 struct isl_set *empty_i;
3908
3909                 res_i = isl_basic_map_partial_lexopt(isl_basic_map_copy(bmap),
3910                                 isl_basic_set_copy(dom->p[i]), &empty_i, max);
3911
3912                 res = isl_map_union_disjoint(res, res_i);
3913                 *empty = isl_set_union_disjoint(*empty, empty_i);
3914         }
3915
3916         isl_set_free(dom);
3917         isl_basic_map_free(bmap);
3918         return res;
3919 error:
3920         *empty = NULL;
3921         isl_set_free(dom);
3922         isl_basic_map_free(bmap);
3923         return NULL;
3924 }
3925
3926 /* Given a map "map", compute the lexicograhically minimal
3927  * (or maximal) image element for each domain element in dom.
3928  * Set *empty to those elements in dom that do not have an image element.
3929  *
3930  * We first compute the lexicographically minimal or maximal element
3931  * in the first basic map.  This results in a partial solution "res"
3932  * and a subset "todo" of dom that still need to be handled.
3933  * We then consider each of the remaining maps in "map" and successively
3934  * improve both "res" and "todo".
3935  *
3936  * Let res^k and todo^k be the results after k steps and let i = k + 1.
3937  * Assume we are computing the lexicographical maximum.
3938  * We first intersect basic map i with a relation that maps elements
3939  * to elements that are lexicographically larger than the image elements
3940  * in res^k and the compute the maximum image element of this intersection.
3941  * The result ("better") corresponds to those image elements in basic map i
3942  * that are better than what we had before.  The remainder ("keep") are the
3943  * domain elements for which the image element in res_k was better.
3944  * We also compute the lexicographical maximum of basic map i in todo^k.
3945  * res^i is the result of the operation + better + those elements in
3946  *              res^k that we should keep
3947  * todo^i is the remainder of the maximum operation on todo^k.
3948  */
3949 static __isl_give isl_map *isl_map_partial_lexopt(
3950                 __isl_take isl_map *map, __isl_take isl_set *dom,
3951                 __isl_give isl_set **empty, int max)
3952 {
3953         int i;
3954         struct isl_map *res;
3955         struct isl_set *todo;
3956
3957         if (!map || !dom)
3958                 goto error;
3959
3960         if (isl_map_fast_is_empty(map)) {
3961                 if (empty)
3962                         *empty = dom;
3963                 else
3964                         isl_set_free(dom);
3965                 return map;
3966         }
3967
3968         res = basic_map_partial_lexopt(isl_basic_map_copy(map->p[0]),
3969                                         isl_set_copy(dom), &todo, max);
3970
3971         for (i = 1; i < map->n; ++i) {
3972                 struct isl_map *lt;
3973                 struct isl_map *better;
3974                 struct isl_set *keep;
3975                 struct isl_map *res_i;
3976                 struct isl_set *todo_i;
3977                 struct isl_dim *dim = isl_map_get_dim(res);
3978
3979                 dim = isl_dim_range(dim);
3980                 if (max)
3981                         lt = isl_map_lex_lt(dim);
3982                 else
3983                         lt = isl_map_lex_gt(dim);
3984                 lt = isl_map_apply_range(isl_map_copy(res), lt);
3985                 lt = isl_map_intersect(lt,
3986                         isl_map_from_basic_map(isl_basic_map_copy(map->p[i])));
3987                 better = isl_map_partial_lexopt(lt,
3988                         isl_map_domain(isl_map_copy(res)),
3989                         &keep, max);
3990
3991                 res_i = basic_map_partial_lexopt(isl_basic_map_copy(map->p[i]),
3992                                                 todo, &todo_i, max);
3993
3994                 res = isl_map_intersect_domain(res, keep);
3995                 res = isl_map_union_disjoint(res, res_i);
3996                 res = isl_map_union_disjoint(res, better);
3997                 todo = todo_i;
3998         }
3999
4000         isl_set_free(dom);
4001         isl_map_free(map);
4002
4003         if (empty)
4004                 *empty = todo;
4005         else
4006                 isl_set_free(todo);
4007
4008         return res;
4009 error:
4010         if (empty)
4011                 *empty = NULL;
4012         isl_set_free(dom);
4013         isl_map_free(map);
4014         return NULL;
4015 }
4016
4017 __isl_give isl_map *isl_map_partial_lexmax(
4018                 __isl_take isl_map *map, __isl_take isl_set *dom,
4019                 __isl_give isl_set **empty)
4020 {
4021         return isl_map_partial_lexopt(map, dom, empty, 1);
4022 }
4023
4024 __isl_give isl_map *isl_map_partial_lexmin(
4025                 __isl_take isl_map *map, __isl_take isl_set *dom,
4026                 __isl_give isl_set **empty)
4027 {
4028         return isl_map_partial_lexopt(map, dom, empty, 0);
4029 }
4030
4031 __isl_give isl_set *isl_set_partial_lexmin(
4032                 __isl_take isl_set *set, __isl_take isl_set *dom,
4033                 __isl_give isl_set **empty)
4034 {
4035         return (struct isl_set *)
4036                 isl_map_partial_lexmin((struct isl_map *)set,
4037                         dom, empty);
4038 }
4039
4040 __isl_give isl_set *isl_set_partial_lexmax(
4041                 __isl_take isl_set *set, __isl_take isl_set *dom,
4042                 __isl_give isl_set **empty)
4043 {
4044         return (struct isl_set *)
4045                 isl_map_partial_lexmax((struct isl_map *)set,
4046                         dom, empty);
4047 }
4048
4049 __isl_give isl_map *isl_basic_map_lexopt(__isl_take isl_basic_map *bmap, int max)
4050 {
4051         struct isl_basic_set *dom = NULL;
4052         struct isl_dim *dom_dim;
4053
4054         if (!bmap)
4055                 goto error;
4056         dom_dim = isl_dim_domain(isl_dim_copy(bmap->dim));
4057         dom = isl_basic_set_universe(dom_dim);
4058         return isl_basic_map_partial_lexopt(bmap, dom, NULL, max);
4059 error:
4060         isl_basic_map_free(bmap);
4061         return NULL;
4062 }
4063
4064 __isl_give isl_map *isl_basic_map_lexmin(__isl_take isl_basic_map *bmap)
4065 {
4066         return isl_basic_map_lexopt(bmap, 0);
4067 }
4068
4069 __isl_give isl_map *isl_basic_map_lexmax(__isl_take isl_basic_map *bmap)
4070 {
4071         return isl_basic_map_lexopt(bmap, 1);
4072 }
4073
4074 __isl_give isl_set *isl_basic_set_lexmin(__isl_take isl_basic_set *bset)
4075 {
4076         return (isl_set *)isl_basic_map_lexmin((isl_basic_map *)bset);
4077 }
4078
4079 __isl_give isl_set *isl_basic_set_lexmax(__isl_take isl_basic_set *bset)
4080 {
4081         return (isl_set *)isl_basic_map_lexmax((isl_basic_map *)bset);
4082 }
4083
4084 __isl_give isl_map *isl_map_lexopt(__isl_take isl_map *map, int max)
4085 {
4086         struct isl_set *dom = NULL;
4087         struct isl_dim *dom_dim;
4088
4089         if (!map)
4090                 goto error;
4091         dom_dim = isl_dim_domain(isl_dim_copy(map->dim));
4092         dom = isl_set_universe(dom_dim);
4093         return isl_map_partial_lexopt(map, dom, NULL, max);
4094 error:
4095         isl_map_free(map);
4096         return NULL;
4097 }
4098
4099 __isl_give isl_map *isl_map_lexmin(__isl_take isl_map *map)
4100 {
4101         return isl_map_lexopt(map, 0);
4102 }
4103
4104 __isl_give isl_map *isl_map_lexmax(__isl_take isl_map *map)
4105 {
4106         return isl_map_lexopt(map, 1);
4107 }
4108
4109 __isl_give isl_set *isl_set_lexmin(__isl_take isl_set *set)
4110 {
4111         return (isl_set *)isl_map_lexmin((isl_map *)set);
4112 }
4113
4114 __isl_give isl_set *isl_set_lexmax(__isl_take isl_set *set)
4115 {
4116         return (isl_set *)isl_map_lexmax((isl_map *)set);
4117 }
4118
4119 static struct isl_map *isl_map_reset_dim(struct isl_map *map,
4120         struct isl_dim *dim)
4121 {
4122         int i;
4123
4124         if (!map || !dim)
4125                 goto error;
4126
4127         for (i = 0; i < map->n; ++i) {
4128                 isl_dim_free(map->p[i]->dim);
4129                 map->p[i]->dim = isl_dim_copy(dim);
4130         }
4131         isl_dim_free(map->dim);
4132         map->dim = dim;
4133
4134         return map;
4135 error:
4136         isl_map_free(map);
4137         isl_dim_free(dim);
4138         return NULL;
4139 }
4140
4141 static struct isl_set *isl_set_reset_dim(struct isl_set *set,
4142         struct isl_dim *dim)
4143 {
4144         return (struct isl_set *) isl_map_reset_dim((struct isl_map *)set, dim);
4145 }
4146
4147 /* Apply a preimage specified by "mat" on the parameters of "bset".
4148  * bset is assumed to have only parameters and divs.
4149  */
4150 static struct isl_basic_set *basic_set_parameter_preimage(
4151         struct isl_basic_set *bset, struct isl_mat *mat)
4152 {
4153         unsigned nparam;
4154
4155         if (!bset || !mat)
4156                 goto error;
4157
4158         bset->dim = isl_dim_cow(bset->dim);
4159         if (!bset->dim)
4160                 goto error;
4161
4162         nparam = isl_basic_set_dim(bset, isl_dim_param);
4163
4164         isl_assert(bset->ctx, mat->n_row == 1 + nparam, goto error);
4165
4166         bset->dim->nparam = 0;
4167         bset->dim->n_out = nparam;
4168         bset = isl_basic_set_preimage(bset, mat);
4169         if (bset) {
4170                 bset->dim->nparam = bset->dim->n_out;
4171                 bset->dim->n_out = 0;
4172         }
4173         return bset;
4174 error:
4175         isl_mat_free(mat);
4176         isl_basic_set_free(bset);
4177         return NULL;
4178 }
4179
4180 /* Apply a preimage specified by "mat" on the parameters of "set".
4181  * set is assumed to have only parameters and divs.
4182  */
4183 static struct isl_set *set_parameter_preimage(
4184         struct isl_set *set, struct isl_mat *mat)
4185 {
4186         struct isl_dim *dim = NULL;
4187         unsigned nparam;
4188
4189         if (!set || !mat)
4190                 goto error;
4191
4192         dim = isl_dim_copy(set->dim);
4193         dim = isl_dim_cow(dim);
4194         if (!dim)
4195                 goto error;
4196
4197         nparam = isl_set_dim(set, isl_dim_param);
4198
4199         isl_assert(set->ctx, mat->n_row == 1 + nparam, goto error);
4200
4201         dim->nparam = 0;
4202         dim->n_out = nparam;
4203         isl_set_reset_dim(set, dim);
4204         set = isl_set_preimage(set, mat);
4205         if (!set)
4206                 goto error2;
4207         dim = isl_dim_copy(set->dim);
4208         dim = isl_dim_cow(dim);
4209         if (!dim)
4210                 goto error2;
4211         dim->nparam = dim->n_out;
4212         dim->n_out = 0;
4213         isl_set_reset_dim(set, dim);
4214         return set;
4215 error:
4216         isl_dim_free(dim);
4217         isl_mat_free(mat);
4218 error2:
4219         isl_set_free(set);
4220         return NULL;
4221 }
4222
4223 /* Intersect the basic set "bset" with the affine space specified by the
4224  * equalities in "eq".
4225  */
4226 static struct isl_basic_set *basic_set_append_equalities(
4227         struct isl_basic_set *bset, struct isl_mat *eq)
4228 {
4229         int i, k;
4230         unsigned len;
4231
4232         if (!bset || !eq)
4233                 goto error;
4234
4235         bset = isl_basic_set_extend_dim(bset, isl_dim_copy(bset->dim), 0,
4236                                         eq->n_row, 0);
4237         if (!bset)
4238                 goto error;
4239
4240         len = 1 + isl_dim_total(bset->dim) + bset->extra;
4241         for (i = 0; i < eq->n_row; ++i) {
4242                 k = isl_basic_set_alloc_equality(bset);
4243                 if (k < 0)
4244                         goto error;
4245                 isl_seq_cpy(bset->eq[k], eq->row[i], eq->n_col);
4246                 isl_seq_clr(bset->eq[k] + eq->n_col, len - eq->n_col);
4247         }
4248         isl_mat_free(eq);
4249
4250         return bset;
4251 error:
4252         isl_mat_free(eq);
4253         isl_basic_set_free(bset);
4254         return NULL;
4255 }
4256
4257 /* Intersect the set "set" with the affine space specified by the
4258  * equalities in "eq".
4259  */
4260 static struct isl_set *set_append_equalities(struct isl_set *set,
4261         struct isl_mat *eq)
4262 {
4263         int i;
4264
4265         if (!set || !eq)
4266                 goto error;
4267
4268         for (i = 0; i < set->n; ++i) {
4269                 set->p[i] = basic_set_append_equalities(set->p[i],
4270                                         isl_mat_copy(eq));
4271                 if (!set->p[i])
4272                         goto error;
4273         }
4274         isl_mat_free(eq);
4275         return set;
4276 error:
4277         isl_mat_free(eq);
4278         isl_set_free(set);
4279         return NULL;
4280 }
4281
4282 /* Project the given basic set onto its parameter domain, possibly introducing
4283  * new, explicit, existential variables in the constraints.
4284  * The input has parameters and (possibly implicit) existential variables.
4285  * The output has the same parameters, but only
4286  * explicit existentially quantified variables.
4287  *
4288  * The actual projection is performed by pip, but pip doesn't seem
4289  * to like equalities very much, so we first remove the equalities
4290  * among the parameters by performing a variable compression on
4291  * the parameters.  Afterward, an inverse transformation is performed
4292  * and the equalities among the parameters are inserted back in.
4293  */
4294 static struct isl_set *parameter_compute_divs(struct isl_basic_set *bset)
4295 {
4296         int i, j;
4297         struct isl_mat *eq;
4298         struct isl_mat *T, *T2;
4299         struct isl_set *set;
4300         unsigned nparam, n_div;
4301
4302         bset = isl_basic_set_cow(bset);
4303         if (!bset)
4304                 return NULL;
4305
4306         if (bset->n_eq == 0)
4307                 return isl_basic_set_lexmin(bset);
4308
4309         isl_basic_set_gauss(bset, NULL);
4310
4311         nparam = isl_basic_set_dim(bset, isl_dim_param);
4312         n_div = isl_basic_set_dim(bset, isl_dim_div);
4313
4314         for (i = 0, j = n_div - 1; i < bset->n_eq && j >= 0; --j) {
4315                 if (!isl_int_is_zero(bset->eq[i][1 + nparam + j]))
4316                         ++i;
4317         }
4318         if (i == bset->n_eq)
4319                 return isl_basic_set_lexmin(bset);
4320
4321         eq = isl_mat_sub_alloc(bset->ctx, bset->eq, i, bset->n_eq - i,
4322                 0, 1 + nparam);
4323         eq = isl_mat_cow(eq);
4324         T = isl_mat_variable_compression(isl_mat_copy(eq), &T2);
4325         bset = basic_set_parameter_preimage(bset, T);
4326
4327         set = isl_basic_set_lexmin(bset);
4328         set = set_parameter_preimage(set, T2);
4329         set = set_append_equalities(set, eq);
4330         return set;
4331 }
4332
4333 /* Compute an explicit representation for all the existentially
4334  * quantified variables.
4335  * The input and output dimensions are first turned into parameters.
4336  * compute_divs then returns a map with the same parameters and
4337  * no input or output dimensions and the dimension specification
4338  * is reset to that of the input.
4339  */
4340 static struct isl_map *compute_divs(struct isl_basic_map *bmap)
4341 {
4342         struct isl_basic_set *bset;
4343         struct isl_set *set;
4344         struct isl_map *map;
4345         struct isl_dim *dim, *orig_dim = NULL;
4346         unsigned         nparam;
4347         unsigned         n_in;
4348         unsigned         n_out;
4349
4350         bmap = isl_basic_map_cow(bmap);
4351         if (!bmap)
4352                 return NULL;
4353
4354         nparam = isl_basic_map_dim(bmap, isl_dim_param);
4355         n_in = isl_basic_map_dim(bmap, isl_dim_in);
4356         n_out = isl_basic_map_dim(bmap, isl_dim_out);
4357         dim = isl_dim_set_alloc(bmap->ctx, nparam + n_in + n_out, 0);
4358         if (!dim)
4359                 goto error;
4360
4361         orig_dim = bmap->dim;
4362         bmap->dim = dim;
4363         bset = (struct isl_basic_set *)bmap;
4364
4365         set = parameter_compute_divs(bset);
4366         map = (struct isl_map *)set;
4367         map = isl_map_reset_dim(map, orig_dim);
4368
4369         return map;
4370 error:
4371         isl_basic_map_free(bmap);
4372         return NULL;
4373 }
4374
4375 static int basic_map_divs_known(__isl_keep isl_basic_map *bmap)
4376 {
4377         int i;
4378         unsigned off;
4379
4380         if (!bmap)
4381                 return -1;
4382
4383         off = isl_dim_total(bmap->dim);
4384         for (i = 0; i < bmap->n_div; ++i) {
4385                 if (isl_int_is_zero(bmap->div[i][0]))
4386                         return 0;
4387                 isl_assert(bmap->ctx, isl_int_is_zero(bmap->div[i][1+1+off+i]),
4388                                 return -1);
4389         }
4390         return 1;
4391 }
4392
4393 static int map_divs_known(__isl_keep isl_map *map)
4394 {
4395         int i;
4396
4397         if (!map)
4398                 return -1;
4399
4400         for (i = 0; i < map->n; ++i) {
4401                 int known = basic_map_divs_known(map->p[i]);
4402                 if (known <= 0)
4403                         return known;
4404         }
4405
4406         return 1;
4407 }
4408
4409 /* If bmap contains any unknown divs, then compute explicit
4410  * expressions for them.  However, this computation may be
4411  * quite expensive, so first try to remove divs that aren't
4412  * strictly needed.
4413  */
4414 struct isl_map *isl_basic_map_compute_divs(struct isl_basic_map *bmap)
4415 {
4416         int i;
4417         int known;
4418         struct isl_map *map;
4419
4420         known = basic_map_divs_known(bmap);
4421         if (known < 0)
4422                 goto error;
4423         if (known)
4424                 return isl_map_from_basic_map(bmap);
4425
4426         bmap = isl_basic_map_drop_redundant_divs(bmap);
4427
4428         known = basic_map_divs_known(bmap);
4429         if (known < 0)
4430                 goto error;
4431         if (known)
4432                 return isl_map_from_basic_map(bmap);
4433
4434         map = compute_divs(bmap);
4435         return map;
4436 error:
4437         isl_basic_map_free(bmap);
4438         return NULL;
4439 }
4440
4441 struct isl_map *isl_map_compute_divs(struct isl_map *map)
4442 {
4443         int i;
4444         int known;
4445         struct isl_map *res;
4446
4447         if (!map)
4448                 return NULL;
4449         if (map->n == 0)
4450                 return map;
4451
4452         known = map_divs_known(map);
4453         if (known < 0) {
4454                 isl_map_free(map);
4455                 return NULL;
4456         }
4457         if (known)
4458                 return map;
4459
4460         res = isl_basic_map_compute_divs(isl_basic_map_copy(map->p[0]));
4461         for (i = 1 ; i < map->n; ++i) {
4462                 struct isl_map *r2;
4463                 r2 = isl_basic_map_compute_divs(isl_basic_map_copy(map->p[i]));
4464                 if (ISL_F_ISSET(map, ISL_MAP_DISJOINT))
4465                         res = isl_map_union_disjoint(res, r2);
4466                 else
4467                         res = isl_map_union(res, r2);
4468         }
4469         isl_map_free(map);
4470
4471         return res;
4472 }
4473
4474 struct isl_set *isl_basic_set_compute_divs(struct isl_basic_set *bset)
4475 {
4476         return (struct isl_set *)
4477                 isl_basic_map_compute_divs((struct isl_basic_map *)bset);
4478 }
4479
4480 struct isl_set *isl_set_compute_divs(struct isl_set *set)
4481 {
4482         return (struct isl_set *)
4483                 isl_map_compute_divs((struct isl_map *)set);
4484 }
4485
4486 struct isl_set *isl_map_domain(struct isl_map *map)
4487 {
4488         int i;
4489         struct isl_set *set;
4490
4491         if (!map)
4492                 goto error;
4493
4494         map = isl_map_cow(map);
4495         if (!map)
4496                 return NULL;
4497
4498         set = (struct isl_set *)map;
4499         set->dim = isl_dim_domain(set->dim);
4500         if (!set->dim)
4501                 goto error;
4502         for (i = 0; i < map->n; ++i) {
4503                 set->p[i] = isl_basic_map_domain(map->p[i]);
4504                 if (!set->p[i])
4505                         goto error;
4506         }
4507         ISL_F_CLR(set, ISL_MAP_DISJOINT);
4508         ISL_F_CLR(set, ISL_SET_NORMALIZED);
4509         return set;
4510 error:
4511         isl_map_free(map);
4512         return NULL;
4513 }
4514
4515 struct isl_map *isl_map_union_disjoint(
4516                         struct isl_map *map1, struct isl_map *map2)
4517 {
4518         int i;
4519         unsigned flags = 0;
4520         struct isl_map *map = NULL;
4521
4522         if (!map1 || !map2)
4523                 goto error;
4524
4525         if (map1->n == 0) {
4526                 isl_map_free(map1);
4527                 return map2;
4528         }
4529         if (map2->n == 0) {
4530                 isl_map_free(map2);
4531                 return map1;
4532         }
4533
4534         isl_assert(map1->ctx, isl_dim_equal(map1->dim, map2->dim), goto error);
4535
4536         if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) &&
4537             ISL_F_ISSET(map2, ISL_MAP_DISJOINT))
4538                 ISL_FL_SET(flags, ISL_MAP_DISJOINT);
4539
4540         map = isl_map_alloc_dim(isl_dim_copy(map1->dim),
4541                                 map1->n + map2->n, flags);
4542         if (!map)
4543                 goto error;
4544         for (i = 0; i < map1->n; ++i) {
4545                 map = isl_map_add_basic_map(map,
4546                                   isl_basic_map_copy(map1->p[i]));
4547                 if (!map)
4548                         goto error;
4549         }
4550         for (i = 0; i < map2->n; ++i) {
4551                 map = isl_map_add_basic_map(map,
4552                                   isl_basic_map_copy(map2->p[i]));
4553                 if (!map)
4554                         goto error;
4555         }
4556         isl_map_free(map1);
4557         isl_map_free(map2);
4558         return map;
4559 error:
4560         isl_map_free(map);
4561         isl_map_free(map1);
4562         isl_map_free(map2);
4563         return NULL;
4564 }
4565
4566 struct isl_map *isl_map_union(struct isl_map *map1, struct isl_map *map2)
4567 {
4568         map1 = isl_map_union_disjoint(map1, map2);
4569         if (!map1)
4570                 return NULL;
4571         if (map1->n > 1)
4572                 ISL_F_CLR(map1, ISL_MAP_DISJOINT);
4573         return map1;
4574 }
4575
4576 struct isl_set *isl_set_union_disjoint(
4577                         struct isl_set *set1, struct isl_set *set2)
4578 {
4579         return (struct isl_set *)
4580                 isl_map_union_disjoint(
4581                         (struct isl_map *)set1, (struct isl_map *)set2);
4582 }
4583
4584 struct isl_set *isl_set_union(struct isl_set *set1, struct isl_set *set2)
4585 {
4586         return (struct isl_set *)
4587                 isl_map_union((struct isl_map *)set1, (struct isl_map *)set2);
4588 }
4589
4590 struct isl_map *isl_map_intersect_range(
4591                 struct isl_map *map, struct isl_set *set)
4592 {
4593         unsigned flags = 0;
4594         struct isl_map *result;
4595         int i, j;
4596
4597         if (!map || !set)
4598                 goto error;
4599
4600         if (ISL_F_ISSET(map, ISL_MAP_DISJOINT) &&
4601             ISL_F_ISSET(set, ISL_MAP_DISJOINT))
4602                 ISL_FL_SET(flags, ISL_MAP_DISJOINT);
4603
4604         result = isl_map_alloc_dim(isl_dim_copy(map->dim),
4605                                         map->n * set->n, flags);
4606         if (!result)
4607                 goto error;
4608         for (i = 0; i < map->n; ++i)
4609                 for (j = 0; j < set->n; ++j) {
4610                         result = isl_map_add_basic_map(result,
4611                             isl_basic_map_intersect_range(
4612                                 isl_basic_map_copy(map->p[i]),
4613                                 isl_basic_set_copy(set->p[j])));
4614                         if (!result)
4615                                 goto error;
4616                 }
4617         isl_map_free(map);
4618         isl_set_free(set);
4619         return result;
4620 error:
4621         isl_map_free(map);
4622         isl_set_free(set);
4623         return NULL;
4624 }
4625
4626 struct isl_map *isl_map_intersect_domain(
4627                 struct isl_map *map, struct isl_set *set)
4628 {
4629         return isl_map_reverse(
4630                 isl_map_intersect_range(isl_map_reverse(map), set));
4631 }
4632
4633 struct isl_map *isl_map_apply_domain(
4634                 struct isl_map *map1, struct isl_map *map2)
4635 {
4636         if (!map1 || !map2)
4637                 goto error;
4638         map1 = isl_map_reverse(map1);
4639         map1 = isl_map_apply_range(map1, map2);
4640         return isl_map_reverse(map1);
4641 error:
4642         isl_map_free(map1);
4643         isl_map_free(map2);
4644         return NULL;
4645 }
4646
4647 struct isl_map *isl_map_apply_range(
4648                 struct isl_map *map1, struct isl_map *map2)
4649 {
4650         struct isl_dim *dim_result;
4651         struct isl_map *result;
4652         int i, j;
4653
4654         if (!map1 || !map2)
4655                 goto error;
4656
4657         dim_result = isl_dim_join(isl_dim_copy(map1->dim),
4658                                   isl_dim_copy(map2->dim));
4659
4660         result = isl_map_alloc_dim(dim_result, map1->n * map2->n, 0);
4661         if (!result)
4662                 goto error;
4663         for (i = 0; i < map1->n; ++i)
4664                 for (j = 0; j < map2->n; ++j) {
4665                         result = isl_map_add_basic_map(result,
4666                             isl_basic_map_apply_range(
4667                                 isl_basic_map_copy(map1->p[i]),
4668                                 isl_basic_map_copy(map2->p[j])));
4669                         if (!result)
4670                                 goto error;
4671                 }
4672         isl_map_free(map1);
4673         isl_map_free(map2);
4674         if (result && result->n <= 1)
4675                 ISL_F_SET(result, ISL_MAP_DISJOINT);
4676         return result;
4677 error:
4678         isl_map_free(map1);
4679         isl_map_free(map2);
4680         return NULL;
4681 }
4682
4683 /*
4684  * returns range - domain
4685  */
4686 struct isl_basic_set *isl_basic_map_deltas(struct isl_basic_map *bmap)
4687 {
4688         isl_dim *dims;
4689         struct isl_basic_set *bset;
4690         unsigned dim;
4691         unsigned nparam;
4692         int i;
4693
4694         if (!bmap)
4695                 goto error;
4696         dim = isl_basic_map_n_in(bmap);
4697         nparam = isl_basic_map_n_param(bmap);
4698         isl_assert(bmap->ctx, dim == isl_basic_map_n_out(bmap), goto error);
4699         bset = isl_basic_set_from_basic_map(bmap);
4700         bset = isl_basic_set_cow(bset);
4701         dims = isl_basic_set_get_dim(bset);
4702         dims = isl_dim_add(dims, isl_dim_set, dim);
4703         bset = isl_basic_set_extend_dim(bset, dims, 0, dim, 0);
4704         bset = isl_basic_set_swap_vars(bset, 2*dim);
4705         for (i = 0; i < dim; ++i) {
4706                 int j = isl_basic_map_alloc_equality(
4707                                             (struct isl_basic_map *)bset);
4708                 if (j < 0)
4709                         goto error;
4710                 isl_seq_clr(bset->eq[j], 1 + isl_basic_set_total_dim(bset));
4711                 isl_int_set_si(bset->eq[j][1+nparam+i], 1);
4712                 isl_int_set_si(bset->eq[j][1+nparam+dim+i], 1);
4713                 isl_int_set_si(bset->eq[j][1+nparam+2*dim+i], -1);
4714         }
4715         return isl_basic_set_project_out(bset, isl_dim_set, dim, 2*dim);
4716 error:
4717         isl_basic_map_free(bmap);
4718         return NULL;
4719 }
4720
4721 /*
4722  * returns range - domain
4723  */
4724 struct isl_set *isl_map_deltas(struct isl_map *map)
4725 {
4726         int i;
4727         isl_dim *dim;
4728         struct isl_set *result;
4729
4730         if (!map)
4731                 return NULL;
4732
4733         isl_assert(map->ctx, isl_map_n_in(map) == isl_map_n_out(map), goto error);
4734         dim = isl_map_get_dim(map);
4735         dim = isl_dim_domain(dim);
4736         result = isl_set_alloc_dim(dim, map->n, map->flags);
4737         if (!result)
4738                 goto error;
4739         for (i = 0; i < map->n; ++i)
4740                 result = isl_set_add_basic_set(result,
4741                           isl_basic_map_deltas(isl_basic_map_copy(map->p[i])));
4742         isl_map_free(map);
4743         return result;
4744 error:
4745         isl_map_free(map);
4746         return NULL;
4747 }
4748
4749 static struct isl_basic_map *basic_map_identity(struct isl_dim *dims)
4750 {
4751         struct isl_basic_map *bmap;
4752         unsigned nparam;
4753         unsigned dim;
4754         int i;
4755
4756         if (!dims)
4757                 return NULL;
4758
4759         nparam = dims->nparam;
4760         dim = dims->n_out;
4761         bmap = isl_basic_map_alloc_dim(dims, 0, dim, 0);
4762         if (!bmap)
4763                 goto error;
4764
4765         for (i = 0; i < dim; ++i) {
4766                 int j = isl_basic_map_alloc_equality(bmap);
4767                 if (j < 0)
4768                         goto error;
4769                 isl_seq_clr(bmap->eq[j], 1 + isl_basic_map_total_dim(bmap));
4770                 isl_int_set_si(bmap->eq[j][1+nparam+i], 1);
4771                 isl_int_set_si(bmap->eq[j][1+nparam+dim+i], -1);
4772         }
4773         return isl_basic_map_finalize(bmap);
4774 error:
4775         isl_basic_map_free(bmap);
4776         return NULL;
4777 }
4778
4779 struct isl_basic_map *isl_basic_map_identity(struct isl_dim *set_dim)
4780 {
4781         struct isl_dim *dim = isl_dim_map(set_dim);
4782         if (!dim)
4783                 return NULL;
4784         return basic_map_identity(dim);
4785 }
4786
4787 struct isl_basic_map *isl_basic_map_identity_like(struct isl_basic_map *model)
4788 {
4789         if (!model || !model->dim)
4790                 return NULL;
4791         isl_assert(model->ctx,
4792                         model->dim->n_in == model->dim->n_out, return NULL);
4793         return basic_map_identity(isl_dim_copy(model->dim));
4794 }
4795
4796 static struct isl_map *map_identity(struct isl_dim *dim)
4797 {
4798         struct isl_map *map = isl_map_alloc_dim(dim, 1, ISL_MAP_DISJOINT);
4799         return isl_map_add_basic_map(map, basic_map_identity(isl_dim_copy(dim)));
4800 }
4801
4802 struct isl_map *isl_map_identity(struct isl_dim *set_dim)
4803 {
4804         struct isl_dim *dim = isl_dim_map(set_dim);
4805         if (!dim)
4806                 return NULL;
4807         return map_identity(dim);
4808 }
4809
4810 struct isl_map *isl_map_identity_like(struct isl_map *model)
4811 {
4812         if (!model || !model->dim)
4813                 return NULL;
4814         isl_assert(model->ctx,
4815                         model->dim->n_in == model->dim->n_out, return NULL);
4816         return map_identity(isl_dim_copy(model->dim));
4817 }
4818
4819 struct isl_map *isl_map_identity_like_basic_map(struct isl_basic_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 /* Construct a basic set with all set dimensions having only non-negative
4829  * values.
4830  */
4831 struct isl_basic_set *isl_basic_set_positive_orthant(struct isl_dim *dims)
4832 {
4833         int i;
4834         unsigned nparam;
4835         unsigned dim;
4836         struct isl_basic_set *bset;
4837
4838         if (!dims)
4839                 return NULL;
4840         nparam = dims->nparam;
4841         dim = dims->n_out;
4842         bset = isl_basic_set_alloc_dim(dims, 0, 0, dim);
4843         if (!bset)
4844                 return NULL;
4845         for (i = 0; i < dim; ++i) {
4846                 int k = isl_basic_set_alloc_inequality(bset);
4847                 if (k < 0)
4848                         goto error;
4849                 isl_seq_clr(bset->ineq[k], 1 + isl_basic_set_total_dim(bset));
4850                 isl_int_set_si(bset->ineq[k][1 + nparam + i], 1);
4851         }
4852         return bset;
4853 error:
4854         isl_basic_set_free(bset);
4855         return NULL;
4856 }
4857
4858 __isl_give isl_set *isl_set_split_dims(__isl_take isl_set *set,
4859         enum isl_dim_type type, unsigned first, unsigned n)
4860 {
4861         int i;
4862         isl_basic_set *nonneg = NULL;
4863         isl_basic_set *neg = NULL;
4864
4865         if (!set)
4866                 return NULL;
4867         if (n == 0)
4868                 return set;
4869
4870         isl_assert(set->ctx, first + n <= isl_set_dim(set, type), goto error);
4871
4872         for (i = 0; i < n; ++i) {
4873                 int k;
4874
4875                 neg = NULL;
4876                 nonneg = isl_basic_set_alloc_dim(isl_set_get_dim(set), 0, 0, 1);
4877                 k = isl_basic_set_alloc_inequality(nonneg);
4878                 if (k < 0)
4879                         goto error;
4880                 isl_seq_clr(nonneg->ineq[k], 1 + isl_basic_set_total_dim(nonneg));
4881                 isl_int_set_si(nonneg->ineq[k][pos(set->dim, type) + first + i], 1);
4882
4883                 neg = isl_basic_set_alloc_dim(isl_set_get_dim(set), 0, 0, 1);
4884                 k = isl_basic_set_alloc_inequality(neg);
4885                 if (k < 0)
4886                         goto error;
4887                 isl_seq_clr(neg->ineq[k], 1 + isl_basic_set_total_dim(neg));
4888                 isl_int_set_si(neg->ineq[k][0], -1);
4889                 isl_int_set_si(neg->ineq[k][pos(set->dim, type) + first + i], -1);
4890
4891                 set = isl_set_intersect(set, isl_basic_set_union(nonneg, neg));
4892         }
4893
4894         return set;
4895 error:
4896         isl_basic_set_free(nonneg);
4897         isl_basic_set_free(neg);
4898         isl_set_free(set);
4899         return NULL;
4900 }
4901
4902 int isl_set_is_equal(struct isl_set *set1, struct isl_set *set2)
4903 {
4904         return isl_map_is_equal((struct isl_map *)set1, (struct isl_map *)set2);
4905 }
4906
4907 int isl_basic_map_is_subset(
4908                 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
4909 {
4910         int is_subset;
4911         struct isl_map *map1;
4912         struct isl_map *map2;
4913
4914         if (!bmap1 || !bmap2)
4915                 return -1;
4916
4917         map1 = isl_map_from_basic_map(isl_basic_map_copy(bmap1));
4918         map2 = isl_map_from_basic_map(isl_basic_map_copy(bmap2));
4919
4920         is_subset = isl_map_is_subset(map1, map2);
4921
4922         isl_map_free(map1);
4923         isl_map_free(map2);
4924
4925         return is_subset;
4926 }
4927
4928 int isl_basic_map_is_equal(
4929                 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
4930 {
4931         int is_subset;
4932
4933         if (!bmap1 || !bmap2)
4934                 return -1;
4935         is_subset = isl_basic_map_is_subset(bmap1, bmap2);
4936         if (is_subset != 1)
4937                 return is_subset;
4938         is_subset = isl_basic_map_is_subset(bmap2, bmap1);
4939         return is_subset;
4940 }
4941
4942 int isl_basic_set_is_equal(
4943                 struct isl_basic_set *bset1, struct isl_basic_set *bset2)
4944 {
4945         return isl_basic_map_is_equal(
4946                 (struct isl_basic_map *)bset1, (struct isl_basic_map *)bset2);
4947 }
4948
4949 int isl_map_is_empty(struct isl_map *map)
4950 {
4951         int i;
4952         int is_empty;
4953
4954         if (!map)
4955                 return -1;
4956         for (i = 0; i < map->n; ++i) {
4957                 is_empty = isl_basic_map_is_empty(map->p[i]);
4958                 if (is_empty < 0)
4959                         return -1;
4960                 if (!is_empty)
4961                         return 0;
4962         }
4963         return 1;
4964 }
4965
4966 int isl_map_fast_is_empty(struct isl_map *map)
4967 {
4968         return map->n == 0;
4969 }
4970
4971 int isl_set_fast_is_empty(struct isl_set *set)
4972 {
4973         return set->n == 0;
4974 }
4975
4976 int isl_set_is_empty(struct isl_set *set)
4977 {
4978         return isl_map_is_empty((struct isl_map *)set);
4979 }
4980
4981 int isl_map_is_equal(struct isl_map *map1, struct isl_map *map2)
4982 {
4983         int is_subset;
4984
4985         if (!map1 || !map2)
4986                 return -1;
4987         is_subset = isl_map_is_subset(map1, map2);
4988         if (is_subset != 1)
4989                 return is_subset;
4990         is_subset = isl_map_is_subset(map2, map1);
4991         return is_subset;
4992 }
4993
4994 int isl_basic_map_is_strict_subset(
4995                 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
4996 {
4997         int is_subset;
4998
4999         if (!bmap1 || !bmap2)
5000                 return -1;
5001         is_subset = isl_basic_map_is_subset(bmap1, bmap2);
5002         if (is_subset != 1)
5003                 return is_subset;
5004         is_subset = isl_basic_map_is_subset(bmap2, bmap1);
5005         if (is_subset == -1)
5006                 return is_subset;
5007         return !is_subset;
5008 }
5009
5010 int isl_map_is_strict_subset(struct isl_map *map1, struct isl_map *map2)
5011 {
5012         int is_subset;
5013
5014         if (!map1 || !map2)
5015                 return -1;
5016         is_subset = isl_map_is_subset(map1, map2);
5017         if (is_subset != 1)
5018                 return is_subset;
5019         is_subset = isl_map_is_subset(map2, map1);
5020         if (is_subset == -1)
5021                 return is_subset;
5022         return !is_subset;
5023 }
5024
5025 int isl_set_is_strict_subset(__isl_keep isl_set *set1, __isl_keep isl_set *set2)
5026 {
5027         return isl_map_is_strict_subset((isl_map *)set1, (isl_map *)set2);
5028 }
5029
5030 int isl_basic_map_is_universe(struct isl_basic_map *bmap)
5031 {
5032         if (!bmap)
5033                 return -1;
5034         return bmap->n_eq == 0 && bmap->n_ineq == 0;
5035 }
5036
5037 int isl_basic_set_is_universe(struct isl_basic_set *bset)
5038 {
5039         if (!bset)
5040                 return -1;
5041         return bset->n_eq == 0 && bset->n_ineq == 0;
5042 }
5043
5044 int isl_map_fast_is_universe(__isl_keep isl_map *map)
5045 {
5046         if (!map)
5047                 return -1;
5048
5049         return map->n == 1 && isl_basic_map_is_universe(map->p[0]);
5050 }
5051
5052 int isl_set_fast_is_universe(__isl_keep isl_set *set)
5053 {
5054         return isl_map_fast_is_universe((isl_map *) set);
5055 }
5056
5057 int isl_basic_map_is_empty(struct isl_basic_map *bmap)
5058 {
5059         struct isl_basic_set *bset = NULL;
5060         struct isl_vec *sample = NULL;
5061         int empty;
5062         unsigned total;
5063
5064         if (!bmap)
5065                 return -1;
5066
5067         if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
5068                 return 1;
5069
5070         if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL)) {
5071                 struct isl_basic_map *copy = isl_basic_map_copy(bmap);
5072                 copy = isl_basic_map_convex_hull(copy);
5073                 empty = ISL_F_ISSET(copy, ISL_BASIC_MAP_EMPTY);
5074                 isl_basic_map_free(copy);
5075                 return empty;
5076         }
5077
5078         total = 1 + isl_basic_map_total_dim(bmap);
5079         if (bmap->sample && bmap->sample->size == total) {
5080                 int contains = isl_basic_map_contains(bmap, bmap->sample);
5081                 if (contains < 0)
5082                         return -1;
5083                 if (contains)
5084                         return 0;
5085         }
5086         isl_vec_free(bmap->sample);
5087         bmap->sample = NULL;
5088         bset = isl_basic_map_underlying_set(isl_basic_map_copy(bmap));
5089         if (!bset)
5090                 return -1;
5091         sample = isl_basic_set_sample_vec(bset);
5092         if (!sample)
5093                 return -1;
5094         empty = sample->size == 0;
5095         isl_vec_free(bmap->sample);
5096         bmap->sample = sample;
5097         if (empty)
5098                 ISL_F_SET(bmap, ISL_BASIC_MAP_EMPTY);
5099
5100         return empty;
5101 }
5102
5103 int isl_basic_map_fast_is_empty(struct isl_basic_map *bmap)
5104 {
5105         if (!bmap)
5106                 return -1;
5107         return ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY);
5108 }
5109
5110 int isl_basic_set_fast_is_empty(struct isl_basic_set *bset)
5111 {
5112         if (!bset)
5113                 return -1;
5114         return ISL_F_ISSET(bset, ISL_BASIC_SET_EMPTY);
5115 }
5116
5117 int isl_basic_set_is_empty(struct isl_basic_set *bset)
5118 {
5119         return isl_basic_map_is_empty((struct isl_basic_map *)bset);
5120 }
5121
5122 struct isl_map *isl_basic_map_union(
5123         struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
5124 {
5125         struct isl_map *map;
5126         if (!bmap1 || !bmap2)
5127                 return NULL;
5128
5129         isl_assert(bmap1->ctx, isl_dim_equal(bmap1->dim, bmap2->dim), goto error);
5130
5131         map = isl_map_alloc_dim(isl_dim_copy(bmap1->dim), 2, 0);
5132         if (!map)
5133                 goto error;
5134         map = isl_map_add_basic_map(map, bmap1);
5135         map = isl_map_add_basic_map(map, bmap2);
5136         return map;
5137 error:
5138         isl_basic_map_free(bmap1);
5139         isl_basic_map_free(bmap2);
5140         return NULL;
5141 }
5142
5143 struct isl_set *isl_basic_set_union(
5144                 struct isl_basic_set *bset1, struct isl_basic_set *bset2)
5145 {
5146         return (struct isl_set *)isl_basic_map_union(
5147                                             (struct isl_basic_map *)bset1,
5148                                             (struct isl_basic_map *)bset2);
5149 }
5150
5151 /* Order divs such that any div only depends on previous divs */
5152 struct isl_basic_map *isl_basic_map_order_divs(struct isl_basic_map *bmap)
5153 {
5154         int i;
5155         unsigned off = isl_dim_total(bmap->dim);
5156
5157         for (i = 0; i < bmap->n_div; ++i) {
5158                 int pos;
5159                 if (isl_int_is_zero(bmap->div[i][0]))
5160                         continue;
5161                 pos = isl_seq_first_non_zero(bmap->div[i]+1+1+off+i,
5162                                                             bmap->n_div-i);
5163                 if (pos == -1)
5164                         continue;
5165                 isl_basic_map_swap_div(bmap, i, i + pos);
5166                 --i;
5167         }
5168         return bmap;
5169 }
5170
5171 struct isl_basic_set *isl_basic_set_order_divs(struct isl_basic_set *bset)
5172 {
5173         return (struct isl_basic_set *)
5174                 isl_basic_map_order_divs((struct isl_basic_map *)bset);
5175 }
5176
5177 __isl_give isl_map *isl_map_order_divs(__isl_take isl_map *map)
5178 {
5179         int i;
5180
5181         if (!map)
5182                 return 0;
5183
5184         for (i = 0; i < map->n; ++i) {
5185                 map->p[i] = isl_basic_map_order_divs(map->p[i]);
5186                 if (!map->p[i])
5187                         goto error;
5188         }
5189
5190         return map;
5191 error:
5192         isl_map_free(map);
5193         return NULL;
5194 }
5195
5196 /* Look for a div in dst that corresponds to the div "div" in src.
5197  * The divs before "div" in src and dst are assumed to be the same.
5198  *
5199  * Returns -1 if no corresponding div was found and the position
5200  * of the corresponding div in dst otherwise.
5201  */
5202 static int find_div(struct isl_basic_map *dst,
5203                         struct isl_basic_map *src, unsigned div)
5204 {
5205         int i;
5206
5207         unsigned total = isl_dim_total(src->dim);
5208
5209         isl_assert(dst->ctx, div <= dst->n_div, return -1);
5210         for (i = div; i < dst->n_div; ++i)
5211                 if (isl_seq_eq(dst->div[i], src->div[div], 1+1+total+div) &&
5212                     isl_seq_first_non_zero(dst->div[i]+1+1+total+div,
5213                                                 dst->n_div - div) == -1)
5214                         return i;
5215         return -1;
5216 }
5217
5218 struct isl_basic_map *isl_basic_map_align_divs(
5219                 struct isl_basic_map *dst, struct isl_basic_map *src)
5220 {
5221         int i;
5222         unsigned total = isl_dim_total(src->dim);
5223
5224         if (!dst || !src)
5225                 goto error;
5226
5227         if (src->n_div == 0)
5228                 return dst;
5229
5230         for (i = 0; i < src->n_div; ++i)
5231                 isl_assert(src->ctx, !isl_int_is_zero(src->div[i][0]), goto error);
5232
5233         src = isl_basic_map_order_divs(src);
5234         dst = isl_basic_map_cow(dst);
5235         dst = isl_basic_map_extend_dim(dst, isl_dim_copy(dst->dim),
5236                         src->n_div, 0, 2 * src->n_div);
5237         if (!dst)
5238                 return NULL;
5239         for (i = 0; i < src->n_div; ++i) {
5240                 int j = find_div(dst, src, i);
5241                 if (j < 0) {
5242                         j = isl_basic_map_alloc_div(dst);
5243                         if (j < 0)
5244                                 goto error;
5245                         isl_seq_cpy(dst->div[j], src->div[i], 1+1+total+i);
5246                         isl_seq_clr(dst->div[j]+1+1+total+i, dst->n_div - i);
5247                         if (isl_basic_map_add_div_constraints(dst, j) < 0)
5248                                 goto error;
5249                 }
5250                 if (j != i)
5251                         isl_basic_map_swap_div(dst, i, j);
5252         }
5253         return dst;
5254 error:
5255         isl_basic_map_free(dst);
5256         return NULL;
5257 }
5258
5259 struct isl_basic_set *isl_basic_set_align_divs(
5260                 struct isl_basic_set *dst, struct isl_basic_set *src)
5261 {
5262         return (struct isl_basic_set *)isl_basic_map_align_divs(
5263                 (struct isl_basic_map *)dst, (struct isl_basic_map *)src);
5264 }
5265
5266 struct isl_map *isl_map_align_divs(struct isl_map *map)
5267 {
5268         int i;
5269
5270         if (!map)
5271                 return NULL;
5272         if (map->n == 0)
5273                 return map;
5274         map = isl_map_compute_divs(map);
5275         map = isl_map_cow(map);
5276         if (!map)
5277                 return NULL;
5278
5279         for (i = 1; i < map->n; ++i)
5280                 map->p[0] = isl_basic_map_align_divs(map->p[0], map->p[i]);
5281         for (i = 1; i < map->n; ++i)
5282                 map->p[i] = isl_basic_map_align_divs(map->p[i], map->p[0]);
5283
5284         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
5285         return map;
5286 }
5287
5288 struct isl_set *isl_set_align_divs(struct isl_set *set)
5289 {
5290         return (struct isl_set *)isl_map_align_divs((struct isl_map *)set);
5291 }
5292
5293 struct isl_set *isl_set_apply(struct isl_set *set, struct isl_map *map)
5294 {
5295         if (!set || !map)
5296                 goto error;
5297         isl_assert(set->ctx, isl_map_compatible_domain(map, set), goto error);
5298         map = isl_map_intersect_domain(map, set);
5299         set = isl_map_range(map);
5300         return set;
5301 error:
5302         isl_set_free(set);
5303         isl_map_free(map);
5304         return NULL;
5305 }
5306
5307 /* There is no need to cow as removing empty parts doesn't change
5308  * the meaning of the set.
5309  */
5310 struct isl_map *isl_map_remove_empty_parts(struct isl_map *map)
5311 {
5312         int i;
5313
5314         if (!map)
5315                 return NULL;
5316
5317         for (i = map->n-1; i >= 0; --i) {
5318                 if (!ISL_F_ISSET(map->p[i], ISL_BASIC_MAP_EMPTY))
5319                         continue;
5320                 isl_basic_map_free(map->p[i]);
5321                 if (i != map->n-1) {
5322                         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
5323                         map->p[i] = map->p[map->n-1];
5324                 }
5325                 map->n--;
5326         }
5327
5328         return map;
5329 }
5330
5331 struct isl_set *isl_set_remove_empty_parts(struct isl_set *set)
5332 {
5333         return (struct isl_set *)
5334                 isl_map_remove_empty_parts((struct isl_map *)set);
5335 }
5336
5337 struct isl_basic_map *isl_map_copy_basic_map(struct isl_map *map)
5338 {
5339         struct isl_basic_map *bmap;
5340         if (!map || map->n == 0)
5341                 return NULL;
5342         bmap = map->p[map->n-1];
5343         isl_assert(map->ctx, ISL_F_ISSET(bmap, ISL_BASIC_SET_FINAL), return NULL);
5344         return isl_basic_map_copy(bmap);
5345 }
5346
5347 struct isl_basic_set *isl_set_copy_basic_set(struct isl_set *set)
5348 {
5349         return (struct isl_basic_set *)
5350                 isl_map_copy_basic_map((struct isl_map *)set);
5351 }
5352
5353 __isl_give isl_map *isl_map_drop_basic_map(__isl_take isl_map *map,
5354                                                 __isl_keep isl_basic_map *bmap)
5355 {
5356         int i;
5357
5358         if (!map || !bmap)
5359                 goto error;
5360         for (i = map->n-1; i >= 0; --i) {
5361                 if (map->p[i] != bmap)
5362                         continue;
5363                 map = isl_map_cow(map);
5364                 if (!map)
5365                         goto error;
5366                 isl_basic_map_free(map->p[i]);
5367                 if (i != map->n-1) {
5368                         ISL_F_CLR(map, ISL_SET_NORMALIZED);
5369                         map->p[i] = map->p[map->n-1];
5370                 }
5371                 map->n--;
5372                 return map;
5373         }
5374         return map;
5375 error:
5376         isl_map_free(map);
5377         return NULL;
5378 }
5379
5380 struct isl_set *isl_set_drop_basic_set(struct isl_set *set,
5381                                                 struct isl_basic_set *bset)
5382 {
5383         return (struct isl_set *)isl_map_drop_basic_map((struct isl_map *)set,
5384                                                 (struct isl_basic_map *)bset);
5385 }
5386
5387 /* Given two basic sets bset1 and bset2, compute the maximal difference
5388  * between the values of dimension pos in bset1 and those in bset2
5389  * for any common value of the parameters and dimensions preceding pos.
5390  */
5391 static enum isl_lp_result basic_set_maximal_difference_at(
5392         __isl_keep isl_basic_set *bset1, __isl_keep isl_basic_set *bset2,
5393         int pos, isl_int *opt)
5394 {
5395         struct isl_dim *dims;
5396         struct isl_basic_map *bmap1 = NULL;
5397         struct isl_basic_map *bmap2 = NULL;
5398         struct isl_ctx *ctx;
5399         struct isl_vec *obj;
5400         unsigned total;
5401         unsigned nparam;
5402         unsigned dim1, dim2;
5403         enum isl_lp_result res;
5404
5405         if (!bset1 || !bset2)
5406                 return isl_lp_error;
5407
5408         nparam = isl_basic_set_n_param(bset1);
5409         dim1 = isl_basic_set_n_dim(bset1);
5410         dim2 = isl_basic_set_n_dim(bset2);
5411         dims = isl_dim_alloc(bset1->ctx, nparam, pos, dim1 - pos);
5412         bmap1 = isl_basic_map_from_basic_set(isl_basic_set_copy(bset1), dims);
5413         dims = isl_dim_alloc(bset2->ctx, nparam, pos, dim2 - pos);
5414         bmap2 = isl_basic_map_from_basic_set(isl_basic_set_copy(bset2), dims);
5415         if (!bmap1 || !bmap2)
5416                 goto error;
5417         bmap1 = isl_basic_map_cow(bmap1);
5418         bmap1 = isl_basic_map_extend(bmap1, nparam,
5419                         pos, (dim1 - pos) + (dim2 - pos),
5420                         bmap2->n_div, bmap2->n_eq, bmap2->n_ineq);
5421         bmap1 = add_constraints(bmap1, bmap2, 0, dim1 - pos);
5422         if (!bmap1)
5423                 goto error;
5424         total = isl_basic_map_total_dim(bmap1);
5425         ctx = bmap1->ctx;
5426         obj = isl_vec_alloc(ctx, 1 + total);
5427         isl_seq_clr(obj->block.data, 1 + total);
5428         isl_int_set_si(obj->block.data[1+nparam+pos], 1);
5429         isl_int_set_si(obj->block.data[1+nparam+pos+(dim1-pos)], -1);
5430         if (!obj)
5431                 goto error;
5432         res = isl_basic_map_solve_lp(bmap1, 1, obj->block.data, ctx->one,
5433                                         opt, NULL, NULL);
5434         isl_basic_map_free(bmap1);
5435         isl_vec_free(obj);
5436         return res;
5437 error:
5438         isl_basic_map_free(bmap1);
5439         isl_basic_map_free(bmap2);
5440         return isl_lp_error;
5441 }
5442
5443 /* Given two _disjoint_ basic sets bset1 and bset2, check whether
5444  * for any common value of the parameters and dimensions preceding pos
5445  * in both basic sets, the values of dimension pos in bset1 are
5446  * smaller or larger than those in bset2.
5447  *
5448  * Returns
5449  *       1 if bset1 follows bset2
5450  *      -1 if bset1 precedes bset2
5451  *       0 if bset1 and bset2 are incomparable
5452  *      -2 if some error occurred.
5453  */
5454 int isl_basic_set_compare_at(struct isl_basic_set *bset1,
5455         struct isl_basic_set *bset2, int pos)
5456 {
5457         isl_int opt;
5458         enum isl_lp_result res;
5459         int cmp;
5460
5461         isl_int_init(opt);
5462
5463         res = basic_set_maximal_difference_at(bset1, bset2, pos, &opt);
5464
5465         if (res == isl_lp_empty)
5466                 cmp = 0;
5467         else if ((res == isl_lp_ok && isl_int_is_pos(opt)) ||
5468                   res == isl_lp_unbounded)
5469                 cmp = 1;
5470         else if (res == isl_lp_ok && isl_int_is_neg(opt))
5471                 cmp = -1;
5472         else
5473                 cmp = -2;
5474
5475         isl_int_clear(opt);
5476         return cmp;
5477 }
5478
5479 /* Given two basic sets bset1 and bset2, check whether
5480  * for any common value of the parameters and dimensions preceding pos
5481  * there is a value of dimension pos in bset1 that is larger
5482  * than a value of the same dimension in bset2.
5483  *
5484  * Return
5485  *       1 if there exists such a pair
5486  *       0 if there is no such pair, but there is a pair of equal values
5487  *      -1 otherwise
5488  *      -2 if some error occurred.
5489  */
5490 int isl_basic_set_follows_at(__isl_keep isl_basic_set *bset1,
5491         __isl_keep isl_basic_set *bset2, int pos)
5492 {
5493         isl_int opt;
5494         enum isl_lp_result res;
5495         int cmp;
5496
5497         isl_int_init(opt);
5498
5499         res = basic_set_maximal_difference_at(bset1, bset2, pos, &opt);
5500
5501         if (res == isl_lp_empty)
5502                 cmp = -1;
5503         else if ((res == isl_lp_ok && isl_int_is_pos(opt)) ||
5504                   res == isl_lp_unbounded)
5505                 cmp = 1;
5506         else if (res == isl_lp_ok && isl_int_is_neg(opt))
5507                 cmp = -1;
5508         else if (res == isl_lp_ok)
5509                 cmp = 0;
5510         else
5511                 cmp = -2;
5512
5513         isl_int_clear(opt);
5514         return cmp;
5515 }
5516
5517 /* Given two sets set1 and set2, check whether
5518  * for any common value of the parameters and dimensions preceding pos
5519  * there is a value of dimension pos in set1 that is larger
5520  * than a value of the same dimension in set2.
5521  *
5522  * Return
5523  *       1 if there exists such a pair
5524  *       0 if there is no such pair, but there is a pair of equal values
5525  *      -1 otherwise
5526  *      -2 if some error occurred.
5527  */
5528 int isl_set_follows_at(__isl_keep isl_set *set1,
5529         __isl_keep isl_set *set2, int pos)
5530 {
5531         int i, j;
5532         int follows = -1;
5533
5534         if (!set1 || !set2)
5535                 return -2;
5536
5537         for (i = 0; i < set1->n; ++i)
5538                 for (j = 0; j < set2->n; ++j) {
5539                         int f;
5540                         f = isl_basic_set_follows_at(set1->p[i], set2->p[j], pos);
5541                         if (f == 1 || f == -2)
5542                                 return f;
5543                         if (f > follows)
5544                                 follows = f;
5545                 }
5546
5547         return follows;
5548 }
5549
5550 static int isl_basic_map_fast_has_fixed_var(struct isl_basic_map *bmap,
5551         unsigned pos, isl_int *val)
5552 {
5553         int i;
5554         int d;
5555         unsigned total;
5556
5557         if (!bmap)
5558                 return -1;
5559         total = isl_basic_map_total_dim(bmap);
5560         for (i = 0, d = total-1; i < bmap->n_eq && d+1 > pos; ++i) {
5561                 for (; d+1 > pos; --d)
5562                         if (!isl_int_is_zero(bmap->eq[i][1+d]))
5563                                 break;
5564                 if (d != pos)
5565                         continue;
5566                 if (isl_seq_first_non_zero(bmap->eq[i]+1, d) != -1)
5567                         return 0;
5568                 if (isl_seq_first_non_zero(bmap->eq[i]+1+d+1, total-d-1) != -1)
5569                         return 0;
5570                 if (!isl_int_is_one(bmap->eq[i][1+d]))
5571                         return 0;
5572                 if (val)
5573                         isl_int_neg(*val, bmap->eq[i][0]);
5574                 return 1;
5575         }
5576         return 0;
5577 }
5578
5579 static int isl_map_fast_has_fixed_var(struct isl_map *map,
5580         unsigned pos, isl_int *val)
5581 {
5582         int i;
5583         isl_int v;
5584         isl_int tmp;
5585         int fixed;
5586
5587         if (!map)
5588                 return -1;
5589         if (map->n == 0)
5590                 return 0;
5591         if (map->n == 1)
5592                 return isl_basic_map_fast_has_fixed_var(map->p[0], pos, val);
5593         isl_int_init(v);
5594         isl_int_init(tmp);
5595         fixed = isl_basic_map_fast_has_fixed_var(map->p[0], pos, &v);
5596         for (i = 1; fixed == 1 && i < map->n; ++i) {
5597                 fixed = isl_basic_map_fast_has_fixed_var(map->p[i], pos, &tmp);
5598                 if (fixed == 1 && isl_int_ne(tmp, v))
5599                         fixed = 0;
5600         }
5601         if (val)
5602                 isl_int_set(*val, v);
5603         isl_int_clear(tmp);
5604         isl_int_clear(v);
5605         return fixed;
5606 }
5607
5608 static int isl_basic_set_fast_has_fixed_var(struct isl_basic_set *bset,
5609         unsigned pos, isl_int *val)
5610 {
5611         return isl_basic_map_fast_has_fixed_var((struct isl_basic_map *)bset,
5612                                                 pos, val);
5613 }
5614
5615 static int isl_set_fast_has_fixed_var(struct isl_set *set, unsigned pos,
5616         isl_int *val)
5617 {
5618         return isl_map_fast_has_fixed_var((struct isl_map *)set, pos, val);
5619 }
5620
5621 int isl_basic_map_fast_is_fixed(struct isl_basic_map *bmap,
5622         enum isl_dim_type type, unsigned pos, isl_int *val)
5623 {
5624         if (pos >= isl_basic_map_dim(bmap, type))
5625                 return -1;
5626         return isl_basic_map_fast_has_fixed_var(bmap,
5627                 isl_basic_map_offset(bmap, type) - 1 + pos, val);
5628 }
5629
5630 int isl_map_fast_is_fixed(struct isl_map *map,
5631         enum isl_dim_type type, unsigned pos, isl_int *val)
5632 {
5633         if (pos >= isl_map_dim(map, type))
5634                 return -1;
5635         return isl_map_fast_has_fixed_var(map,
5636                 map_offset(map, type) - 1 + pos, val);
5637 }
5638
5639 /* Check if dimension dim has fixed value and if so and if val is not NULL,
5640  * then return this fixed value in *val.
5641  */
5642 int isl_basic_set_fast_dim_is_fixed(struct isl_basic_set *bset, unsigned dim,
5643         isl_int *val)
5644 {
5645         return isl_basic_set_fast_has_fixed_var(bset,
5646                                         isl_basic_set_n_param(bset) + dim, val);
5647 }
5648
5649 /* Check if dimension dim has fixed value and if so and if val is not NULL,
5650  * then return this fixed value in *val.
5651  */
5652 int isl_set_fast_dim_is_fixed(struct isl_set *set, unsigned dim, isl_int *val)
5653 {
5654         return isl_set_fast_has_fixed_var(set, isl_set_n_param(set) + dim, val);
5655 }
5656
5657 /* Check if input variable in has fixed value and if so and if val is not NULL,
5658  * then return this fixed value in *val.
5659  */
5660 int isl_map_fast_input_is_fixed(struct isl_map *map, unsigned in, isl_int *val)
5661 {
5662         return isl_map_fast_has_fixed_var(map, isl_map_n_param(map) + in, val);
5663 }
5664
5665 /* Check if dimension dim has an (obvious) fixed lower bound and if so
5666  * and if val is not NULL, then return this lower bound in *val.
5667  */
5668 int isl_basic_set_fast_dim_has_fixed_lower_bound(struct isl_basic_set *bset,
5669         unsigned dim, isl_int *val)
5670 {
5671         int i, i_eq = -1, i_ineq = -1;
5672         isl_int *c;
5673         unsigned total;
5674         unsigned nparam;
5675
5676         if (!bset)
5677                 return -1;
5678         total = isl_basic_set_total_dim(bset);
5679         nparam = isl_basic_set_n_param(bset);
5680         for (i = 0; i < bset->n_eq; ++i) {
5681                 if (isl_int_is_zero(bset->eq[i][1+nparam+dim]))
5682                         continue;
5683                 if (i_eq != -1)
5684                         return 0;
5685                 i_eq = i;
5686         }
5687         for (i = 0; i < bset->n_ineq; ++i) {
5688                 if (!isl_int_is_pos(bset->ineq[i][1+nparam+dim]))
5689                         continue;
5690                 if (i_eq != -1 || i_ineq != -1)
5691                         return 0;
5692                 i_ineq = i;
5693         }
5694         if (i_eq == -1 && i_ineq == -1)
5695                 return 0;
5696         c = i_eq != -1 ? bset->eq[i_eq] : bset->ineq[i_ineq];
5697         /* The coefficient should always be one due to normalization. */
5698         if (!isl_int_is_one(c[1+nparam+dim]))
5699                 return 0;
5700         if (isl_seq_first_non_zero(c+1, nparam+dim) != -1)
5701                 return 0;
5702         if (isl_seq_first_non_zero(c+1+nparam+dim+1,
5703                                         total - nparam - dim - 1) != -1)
5704                 return 0;
5705         if (val)
5706                 isl_int_neg(*val, c[0]);
5707         return 1;
5708 }
5709
5710 int isl_set_fast_dim_has_fixed_lower_bound(struct isl_set *set,
5711         unsigned dim, isl_int *val)
5712 {
5713         int i;
5714         isl_int v;
5715         isl_int tmp;
5716         int fixed;
5717
5718         if (!set)
5719                 return -1;
5720         if (set->n == 0)
5721                 return 0;
5722         if (set->n == 1)
5723                 return isl_basic_set_fast_dim_has_fixed_lower_bound(set->p[0],
5724                                                                 dim, val);
5725         isl_int_init(v);
5726         isl_int_init(tmp);
5727         fixed = isl_basic_set_fast_dim_has_fixed_lower_bound(set->p[0],
5728                                                                 dim, &v);
5729         for (i = 1; fixed == 1 && i < set->n; ++i) {
5730                 fixed = isl_basic_set_fast_dim_has_fixed_lower_bound(set->p[i],
5731                                                                 dim, &tmp);
5732                 if (fixed == 1 && isl_int_ne(tmp, v))
5733                         fixed = 0;
5734         }
5735         if (val)
5736                 isl_int_set(*val, v);
5737         isl_int_clear(tmp);
5738         isl_int_clear(v);
5739         return fixed;
5740 }
5741
5742 struct constraint {
5743         unsigned        size;
5744         isl_int         *c;
5745 };
5746
5747 static int qsort_constraint_cmp(const void *p1, const void *p2)
5748 {
5749         const struct constraint *c1 = (const struct constraint *)p1;
5750         const struct constraint *c2 = (const struct constraint *)p2;
5751         unsigned size = isl_min(c1->size, c2->size);
5752         return isl_seq_cmp(c1->c, c2->c, size);
5753 }
5754
5755 static struct isl_basic_map *isl_basic_map_sort_constraints(
5756         struct isl_basic_map *bmap)
5757 {
5758         int i;
5759         struct constraint *c;
5760         unsigned total;
5761
5762         if (!bmap)
5763                 return NULL;
5764         total = isl_basic_map_total_dim(bmap);
5765         c = isl_alloc_array(bmap->ctx, struct constraint, bmap->n_ineq);
5766         if (!c)
5767                 goto error;
5768         for (i = 0; i < bmap->n_ineq; ++i) {
5769                 c[i].size = total;
5770                 c[i].c = bmap->ineq[i];
5771         }
5772         qsort(c, bmap->n_ineq, sizeof(struct constraint), qsort_constraint_cmp);
5773         for (i = 0; i < bmap->n_ineq; ++i)
5774                 bmap->ineq[i] = c[i].c;
5775         free(c);
5776         return bmap;
5777 error:
5778         isl_basic_map_free(bmap);
5779         return NULL;
5780 }
5781
5782 struct isl_basic_map *isl_basic_map_normalize(struct isl_basic_map *bmap)
5783 {
5784         if (!bmap)
5785                 return NULL;
5786         if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_NORMALIZED))
5787                 return bmap;
5788         bmap = isl_basic_map_convex_hull(bmap);
5789         bmap = isl_basic_map_sort_constraints(bmap);
5790         ISL_F_SET(bmap, ISL_BASIC_MAP_NORMALIZED);
5791         return bmap;
5792 }
5793
5794 struct isl_basic_set *isl_basic_set_normalize(struct isl_basic_set *bset)
5795 {
5796         return (struct isl_basic_set *)isl_basic_map_normalize(
5797                                                 (struct isl_basic_map *)bset);
5798 }
5799
5800 static int isl_basic_map_fast_cmp(const struct isl_basic_map *bmap1,
5801         const struct isl_basic_map *bmap2)
5802 {
5803         int i, cmp;
5804         unsigned total;
5805
5806         if (bmap1 == bmap2)
5807                 return 0;
5808         if (isl_basic_map_n_param(bmap1) != isl_basic_map_n_param(bmap2))
5809                 return isl_basic_map_n_param(bmap1) - isl_basic_map_n_param(bmap2);
5810         if (isl_basic_map_n_in(bmap1) != isl_basic_map_n_in(bmap2))
5811                 return isl_basic_map_n_out(bmap1) - isl_basic_map_n_out(bmap2);
5812         if (isl_basic_map_n_out(bmap1) != isl_basic_map_n_out(bmap2))
5813                 return isl_basic_map_n_out(bmap1) - isl_basic_map_n_out(bmap2);
5814         if (ISL_F_ISSET(bmap1, ISL_BASIC_MAP_EMPTY) &&
5815             ISL_F_ISSET(bmap2, ISL_BASIC_MAP_EMPTY))
5816                 return 0;
5817         if (ISL_F_ISSET(bmap1, ISL_BASIC_MAP_EMPTY))
5818                 return 1;
5819         if (ISL_F_ISSET(bmap2, ISL_BASIC_MAP_EMPTY))
5820                 return -1;
5821         if (bmap1->n_eq != bmap2->n_eq)
5822                 return bmap1->n_eq - bmap2->n_eq;
5823         if (bmap1->n_ineq != bmap2->n_ineq)
5824                 return bmap1->n_ineq - bmap2->n_ineq;
5825         if (bmap1->n_div != bmap2->n_div)
5826                 return bmap1->n_div - bmap2->n_div;
5827         total = isl_basic_map_total_dim(bmap1);
5828         for (i = 0; i < bmap1->n_eq; ++i) {
5829                 cmp = isl_seq_cmp(bmap1->eq[i], bmap2->eq[i], 1+total);
5830                 if (cmp)
5831                         return cmp;
5832         }
5833         for (i = 0; i < bmap1->n_ineq; ++i) {
5834                 cmp = isl_seq_cmp(bmap1->ineq[i], bmap2->ineq[i], 1+total);
5835                 if (cmp)
5836                         return cmp;
5837         }
5838         for (i = 0; i < bmap1->n_div; ++i) {
5839                 cmp = isl_seq_cmp(bmap1->div[i], bmap2->div[i], 1+1+total);
5840                 if (cmp)
5841                         return cmp;
5842         }
5843         return 0;
5844 }
5845
5846 static int isl_basic_map_fast_is_equal(struct isl_basic_map *bmap1,
5847         struct isl_basic_map *bmap2)
5848 {
5849         return isl_basic_map_fast_cmp(bmap1, bmap2) == 0;
5850 }
5851
5852 static int qsort_bmap_cmp(const void *p1, const void *p2)
5853 {
5854         const struct isl_basic_map *bmap1 = *(const struct isl_basic_map **)p1;
5855         const struct isl_basic_map *bmap2 = *(const struct isl_basic_map **)p2;
5856
5857         return isl_basic_map_fast_cmp(bmap1, bmap2);
5858 }
5859
5860 /* We normalize in place, but if anything goes wrong we need
5861  * to return NULL, so we need to make sure we don't change the
5862  * meaning of any possible other copies of map.
5863  */
5864 struct isl_map *isl_map_normalize(struct isl_map *map)
5865 {
5866         int i, j;
5867         struct isl_basic_map *bmap;
5868
5869         if (!map)
5870                 return NULL;
5871         if (ISL_F_ISSET(map, ISL_MAP_NORMALIZED))
5872                 return map;
5873         for (i = 0; i < map->n; ++i) {
5874                 bmap = isl_basic_map_normalize(isl_basic_map_copy(map->p[i]));
5875                 if (!bmap)
5876                         goto error;
5877                 isl_basic_map_free(map->p[i]);
5878                 map->p[i] = bmap;
5879         }
5880         qsort(map->p, map->n, sizeof(struct isl_basic_map *), qsort_bmap_cmp);
5881         ISL_F_SET(map, ISL_MAP_NORMALIZED);
5882         map = isl_map_remove_empty_parts(map);
5883         if (!map)
5884                 return NULL;
5885         for (i = map->n - 1; i >= 1; --i) {
5886                 if (!isl_basic_map_fast_is_equal(map->p[i-1], map->p[i]))
5887                         continue;
5888                 isl_basic_map_free(map->p[i-1]);
5889                 for (j = i; j < map->n; ++j)
5890                         map->p[j-1] = map->p[j];
5891                 map->n--;
5892         }
5893         return map;
5894 error:
5895         isl_map_free(map);
5896         return NULL;
5897
5898 }
5899
5900 struct isl_set *isl_set_normalize(struct isl_set *set)
5901 {
5902         return (struct isl_set *)isl_map_normalize((struct isl_map *)set);
5903 }
5904
5905 int isl_map_fast_is_equal(struct isl_map *map1, struct isl_map *map2)
5906 {
5907         int i;
5908         int equal;
5909
5910         if (!map1 || !map2)
5911                 return -1;
5912
5913         if (map1 == map2)
5914                 return 1;
5915         if (!isl_dim_equal(map1->dim, map2->dim))
5916                 return 0;
5917
5918         map1 = isl_map_copy(map1);
5919         map2 = isl_map_copy(map2);
5920         map1 = isl_map_normalize(map1);
5921         map2 = isl_map_normalize(map2);
5922         if (!map1 || !map2)
5923                 goto error;
5924         equal = map1->n == map2->n;
5925         for (i = 0; equal && i < map1->n; ++i) {
5926                 equal = isl_basic_map_fast_is_equal(map1->p[i], map2->p[i]);
5927                 if (equal < 0)
5928                         goto error;
5929         }
5930         isl_map_free(map1);
5931         isl_map_free(map2);
5932         return equal;
5933 error:
5934         isl_map_free(map1);
5935         isl_map_free(map2);
5936         return -1;
5937 }
5938
5939 int isl_set_fast_is_equal(struct isl_set *set1, struct isl_set *set2)
5940 {
5941         return isl_map_fast_is_equal((struct isl_map *)set1,
5942                                                 (struct isl_map *)set2);
5943 }
5944
5945 /* Return an interval that ranges from min to max (inclusive)
5946  */
5947 struct isl_basic_set *isl_basic_set_interval(struct isl_ctx *ctx,
5948         isl_int min, isl_int max)
5949 {
5950         int k;
5951         struct isl_basic_set *bset = NULL;
5952
5953         bset = isl_basic_set_alloc(ctx, 0, 1, 0, 0, 2);
5954         if (!bset)
5955                 goto error;
5956
5957         k = isl_basic_set_alloc_inequality(bset);
5958         if (k < 0)
5959                 goto error;
5960         isl_int_set_si(bset->ineq[k][1], 1);
5961         isl_int_neg(bset->ineq[k][0], min);
5962
5963         k = isl_basic_set_alloc_inequality(bset);
5964         if (k < 0)
5965                 goto error;
5966         isl_int_set_si(bset->ineq[k][1], -1);
5967         isl_int_set(bset->ineq[k][0], max);
5968
5969         return bset;
5970 error:
5971         isl_basic_set_free(bset);
5972         return NULL;
5973 }
5974
5975 /* Return the Cartesian product of the basic sets in list (in the given order).
5976  */
5977 struct isl_basic_set *isl_basic_set_product(struct isl_basic_set_list *list)
5978 {
5979         int i;
5980         unsigned dim;
5981         unsigned nparam;
5982         unsigned extra;
5983         unsigned n_eq;
5984         unsigned n_ineq;
5985         struct isl_basic_set *product = NULL;
5986
5987         if (!list)
5988                 goto error;
5989         isl_assert(list->ctx, list->n > 0, goto error);
5990         isl_assert(list->ctx, list->p[0], goto error);
5991         nparam = isl_basic_set_n_param(list->p[0]);
5992         dim = isl_basic_set_n_dim(list->p[0]);
5993         extra = list->p[0]->n_div;
5994         n_eq = list->p[0]->n_eq;
5995         n_ineq = list->p[0]->n_ineq;
5996         for (i = 1; i < list->n; ++i) {
5997                 isl_assert(list->ctx, list->p[i], goto error);
5998                 isl_assert(list->ctx,
5999                     nparam == isl_basic_set_n_param(list->p[i]), goto error);
6000                 dim += isl_basic_set_n_dim(list->p[i]);
6001                 extra += list->p[i]->n_div;
6002                 n_eq += list->p[i]->n_eq;
6003                 n_ineq += list->p[i]->n_ineq;
6004         }
6005         product = isl_basic_set_alloc(list->ctx, nparam, dim, extra,
6006                                         n_eq, n_ineq);
6007         if (!product)
6008                 goto error;
6009         dim = 0;
6010         for (i = 0; i < list->n; ++i) {
6011                 isl_basic_set_add_constraints(product,
6012                                         isl_basic_set_copy(list->p[i]), dim);
6013                 dim += isl_basic_set_n_dim(list->p[i]);
6014         }
6015         isl_basic_set_list_free(list);
6016         return product;
6017 error:
6018         isl_basic_set_free(product);
6019         isl_basic_set_list_free(list);
6020         return NULL;
6021 }
6022
6023 struct isl_basic_map *isl_basic_map_product(
6024                 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
6025 {
6026         struct isl_dim *dim_result = NULL;
6027         struct isl_basic_map *bmap;
6028         unsigned in1, in2, out1, out2, nparam, total, pos;
6029         struct isl_dim_map *dim_map1, *dim_map2;
6030
6031         if (!bmap1 || !bmap2)
6032                 goto error;
6033
6034         isl_assert(bmap1->ctx, isl_dim_match(bmap1->dim, isl_dim_param,
6035                                      bmap2->dim, isl_dim_param), goto error);
6036         dim_result = isl_dim_product(isl_dim_copy(bmap1->dim),
6037                                                    isl_dim_copy(bmap2->dim));
6038
6039         in1 = isl_basic_map_n_in(bmap1);
6040         in2 = isl_basic_map_n_in(bmap2);
6041         out1 = isl_basic_map_n_out(bmap1);
6042         out2 = isl_basic_map_n_out(bmap2);
6043         nparam = isl_basic_map_n_param(bmap1);
6044
6045         total = nparam + in1 + in2 + out1 + out2 + bmap1->n_div + bmap2->n_div;
6046         dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
6047         dim_map2 = isl_dim_map_alloc(bmap1->ctx, total);
6048         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
6049         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos = 0);
6050         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
6051         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos += in1);
6052         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += in2);
6053         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos += out1);
6054         isl_dim_map_div(dim_map1, bmap1, pos += out2);
6055         isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
6056
6057         bmap = isl_basic_map_alloc_dim(dim_result,
6058                         bmap1->n_div + bmap2->n_div,
6059                         bmap1->n_eq + bmap2->n_eq,
6060                         bmap1->n_ineq + bmap2->n_ineq);
6061         bmap = add_constraints_dim_map(bmap, bmap1, dim_map1);
6062         bmap = add_constraints_dim_map(bmap, bmap2, dim_map2);
6063         bmap = isl_basic_map_simplify(bmap);
6064         return isl_basic_map_finalize(bmap);
6065 error:
6066         isl_basic_map_free(bmap1);
6067         isl_basic_map_free(bmap2);
6068         return NULL;
6069 }
6070
6071 /* Given two maps A -> B and C -> D, construct a map (A, C) -> (B, D)
6072  */
6073 struct isl_map *isl_map_product(struct isl_map *map1, struct isl_map *map2)
6074 {
6075         unsigned flags = 0;
6076         struct isl_map *result;
6077         int i, j;
6078
6079         if (!map1 || !map2)
6080                 goto error;
6081
6082         isl_assert(map1->ctx, isl_dim_match(map1->dim, isl_dim_param,
6083                                          map2->dim, isl_dim_param), goto error);
6084
6085         if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) &&
6086             ISL_F_ISSET(map2, ISL_MAP_DISJOINT))
6087                 ISL_FL_SET(flags, ISL_MAP_DISJOINT);
6088
6089         result = isl_map_alloc_dim(isl_dim_product(isl_dim_copy(map1->dim),
6090                                                    isl_dim_copy(map2->dim)),
6091                                 map1->n * map2->n, flags);
6092         if (!result)
6093                 goto error;
6094         for (i = 0; i < map1->n; ++i)
6095                 for (j = 0; j < map2->n; ++j) {
6096                         struct isl_basic_map *part;
6097                         part = isl_basic_map_product(
6098                                     isl_basic_map_copy(map1->p[i]),
6099                                     isl_basic_map_copy(map2->p[j]));
6100                         if (isl_basic_map_is_empty(part))
6101                                 isl_basic_map_free(part);
6102                         else
6103                                 result = isl_map_add_basic_map(result, part);
6104                         if (!result)
6105                                 goto error;
6106                 }
6107         isl_map_free(map1);
6108         isl_map_free(map2);
6109         return result;
6110 error:
6111         isl_map_free(map1);
6112         isl_map_free(map2);
6113         return NULL;
6114 }
6115
6116 /* Given two set A and B, construct its Cartesian product A x B.
6117  */
6118 struct isl_set *isl_set_product(struct isl_set *set1, struct isl_set *set2)
6119 {
6120         return (struct isl_set *)isl_map_product((struct isl_map *)set1,
6121                                                  (struct isl_map *)set2);
6122 }
6123
6124 uint32_t isl_basic_set_get_hash(struct isl_basic_set *bset)
6125 {
6126         int i;
6127         uint32_t hash = isl_hash_init();
6128         unsigned total;
6129
6130         if (!bset)
6131                 return 0;
6132         bset = isl_basic_set_copy(bset);
6133         bset = isl_basic_set_normalize(bset);
6134         if (!bset)
6135                 return 0;
6136         total = isl_basic_set_total_dim(bset);
6137         isl_hash_byte(hash, bset->n_eq & 0xFF);
6138         for (i = 0; i < bset->n_eq; ++i) {
6139                 uint32_t c_hash;
6140                 c_hash = isl_seq_get_hash(bset->eq[i], 1 + total);
6141                 isl_hash_hash(hash, c_hash);
6142         }
6143         isl_hash_byte(hash, bset->n_ineq & 0xFF);
6144         for (i = 0; i < bset->n_ineq; ++i) {
6145                 uint32_t c_hash;
6146                 c_hash = isl_seq_get_hash(bset->ineq[i], 1 + total);
6147                 isl_hash_hash(hash, c_hash);
6148         }
6149         isl_hash_byte(hash, bset->n_div & 0xFF);
6150         for (i = 0; i < bset->n_div; ++i) {
6151                 uint32_t c_hash;
6152                 if (isl_int_is_zero(bset->div[i][0]))
6153                         continue;
6154                 isl_hash_byte(hash, i & 0xFF);
6155                 c_hash = isl_seq_get_hash(bset->div[i], 1 + 1 + total);
6156                 isl_hash_hash(hash, c_hash);
6157         }
6158         isl_basic_set_free(bset);
6159         return hash;
6160 }
6161
6162 uint32_t isl_set_get_hash(struct isl_set *set)
6163 {
6164         int i;
6165         uint32_t hash;
6166
6167         if (!set)
6168                 return 0;
6169         set = isl_set_copy(set);
6170         set = isl_set_normalize(set);
6171         if (!set)
6172                 return 0;
6173
6174         hash = isl_hash_init();
6175         for (i = 0; i < set->n; ++i) {
6176                 uint32_t bset_hash;
6177                 bset_hash = isl_basic_set_get_hash(set->p[i]);
6178                 isl_hash_hash(hash, bset_hash);
6179         }
6180
6181         isl_set_free(set);
6182
6183         return hash;
6184 }
6185
6186 /* Check if the value for dimension dim is completely determined
6187  * by the values of the other parameters and variables.
6188  * That is, check if dimension dim is involved in an equality.
6189  */
6190 int isl_basic_set_dim_is_unique(struct isl_basic_set *bset, unsigned dim)
6191 {
6192         int i;
6193         unsigned nparam;
6194
6195         if (!bset)
6196                 return -1;
6197         nparam = isl_basic_set_n_param(bset);
6198         for (i = 0; i < bset->n_eq; ++i)
6199                 if (!isl_int_is_zero(bset->eq[i][1 + nparam + dim]))
6200                         return 1;
6201         return 0;
6202 }
6203
6204 /* Check if the value for dimension dim is completely determined
6205  * by the values of the other parameters and variables.
6206  * That is, check if dimension dim is involved in an equality
6207  * for each of the subsets.
6208  */
6209 int isl_set_dim_is_unique(struct isl_set *set, unsigned dim)
6210 {
6211         int i;
6212
6213         if (!set)
6214                 return -1;
6215         for (i = 0; i < set->n; ++i) {
6216                 int unique;
6217                 unique = isl_basic_set_dim_is_unique(set->p[i], dim);
6218                 if (unique != 1)
6219                         return unique;
6220         }
6221         return 1;
6222 }
6223
6224 int isl_map_foreach_basic_map(__isl_keep isl_map *map,
6225         int (*fn)(__isl_take isl_basic_map *bmap, void *user), void *user)
6226 {
6227         int i;
6228
6229         if (!map)
6230                 return -1;
6231
6232         for (i = 0; i < map->n; ++i)
6233                 if (fn(isl_basic_map_copy(map->p[i]), user) < 0)
6234                         return -1;
6235
6236         return 0;
6237 }
6238
6239 int isl_set_foreach_basic_set(__isl_keep isl_set *set,
6240         int (*fn)(__isl_take isl_basic_set *bset, void *user), void *user)
6241 {
6242         int i;
6243
6244         if (!set)
6245                 return -1;
6246
6247         for (i = 0; i < set->n; ++i)
6248                 if (fn(isl_basic_set_copy(set->p[i]), user) < 0)
6249                         return -1;
6250
6251         return 0;
6252 }
6253
6254 __isl_give isl_basic_set *isl_basic_set_lift(__isl_take isl_basic_set *bset)
6255 {
6256         struct isl_dim *dim;
6257
6258         if (!bset)
6259                 return NULL;
6260
6261         if (bset->n_div == 0)
6262                 return bset;
6263
6264         bset = isl_basic_set_cow(bset);
6265         if (!bset)
6266                 return NULL;
6267
6268         dim = isl_basic_set_get_dim(bset);
6269         dim = isl_dim_add(dim, isl_dim_set, bset->n_div);
6270         if (!dim)
6271                 goto error;
6272         isl_dim_free(bset->dim);
6273         bset->dim = dim;
6274         bset->n_div = 0;
6275
6276         return bset;
6277 error:
6278         isl_basic_set_free(bset);
6279         return NULL;
6280 }
6281
6282 __isl_give isl_set *isl_set_lift(__isl_take isl_set *set)
6283 {
6284         int i;
6285         struct isl_dim *dim;
6286         unsigned n_div;
6287
6288         set = isl_set_align_divs(set);
6289
6290         if (!set)
6291                 return NULL;
6292         if (set->n == 0 || set->p[0]->n_div == 0)
6293                 return set;
6294
6295         set = isl_set_cow(set);
6296         if (!set)
6297                 return NULL;
6298
6299         n_div = set->p[0]->n_div;
6300         dim = isl_set_get_dim(set);
6301         dim = isl_dim_add(dim, isl_dim_set, n_div);
6302         if (!dim)
6303                 goto error;
6304         isl_dim_free(set->dim);
6305         set->dim = dim;
6306
6307         for (i = 0; i < set->n; ++i) {
6308                 set->p[i] = isl_basic_set_lift(set->p[i]);
6309                 if (!set->p[i])
6310                         goto error;
6311         }
6312
6313         return set;
6314 error:
6315         isl_set_free(set);
6316         return NULL;
6317 }
6318
6319 __isl_give isl_map *isl_set_lifting(__isl_take isl_set *set)
6320 {
6321         struct isl_dim *dim;
6322         struct isl_basic_map *bmap;
6323         unsigned n_set;
6324         unsigned n_div;
6325         unsigned n_param;
6326         unsigned total;
6327         int i, k, l;
6328
6329         set = isl_set_align_divs(set);
6330
6331         if (!set)
6332                 return NULL;
6333
6334         dim = isl_set_get_dim(set);
6335         if (set->n == 0 || set->p[0]->n_div == 0) {
6336                 isl_set_free(set);
6337                 return isl_map_identity(dim);
6338         }
6339
6340         n_div = set->p[0]->n_div;
6341         dim = isl_dim_map(dim);
6342         n_param = isl_dim_size(dim, isl_dim_param);
6343         n_set = isl_dim_size(dim, isl_dim_in);
6344         dim = isl_dim_extend(dim, n_param, n_set, n_set + n_div);
6345         bmap = isl_basic_map_alloc_dim(dim, 0, n_set, 2 * n_div);
6346         for (i = 0; i < n_set; ++i)
6347                 bmap = var_equal(bmap, i);
6348
6349         total = n_param + n_set + n_set + n_div;
6350         for (i = 0; i < n_div; ++i) {
6351                 k = isl_basic_map_alloc_inequality(bmap);
6352                 if (k < 0)
6353                         goto error;
6354                 isl_seq_cpy(bmap->ineq[k], set->p[0]->div[i]+1, 1+n_param);
6355                 isl_seq_clr(bmap->ineq[k]+1+n_param, n_set);
6356                 isl_seq_cpy(bmap->ineq[k]+1+n_param+n_set,
6357                             set->p[0]->div[i]+1+1+n_param, n_set + n_div);
6358                 isl_int_neg(bmap->ineq[k][1+n_param+n_set+n_set+i],
6359                             set->p[0]->div[i][0]);
6360
6361                 l = isl_basic_map_alloc_inequality(bmap);
6362                 if (l < 0)
6363                         goto error;
6364                 isl_seq_neg(bmap->ineq[l], bmap->ineq[k], 1 + total);
6365                 isl_int_add(bmap->ineq[l][0], bmap->ineq[l][0],
6366                             set->p[0]->div[i][0]);
6367                 isl_int_sub_ui(bmap->ineq[l][0], bmap->ineq[l][0], 1);
6368         }
6369
6370         isl_set_free(set);
6371         return isl_map_from_basic_map(bmap);
6372 error:
6373         isl_set_free(set);
6374         isl_basic_map_free(bmap);
6375         return NULL;
6376 }
6377
6378 int isl_basic_set_size(__isl_keep isl_basic_set *bset)
6379 {
6380         unsigned dim;
6381         int size = 0;
6382
6383         if (!bset)
6384                 return -1;
6385
6386         dim = isl_basic_set_total_dim(bset);
6387         size += bset->n_eq * (1 + dim);
6388         size += bset->n_ineq * (1 + dim);
6389         size += bset->n_div * (2 + dim);
6390
6391         return size;
6392 }
6393
6394 int isl_set_size(__isl_keep isl_set *set)
6395 {
6396         int i;
6397         int size = 0;
6398
6399         if (!set)
6400                 return -1;
6401
6402         for (i = 0; i < set->n; ++i)
6403                 size += isl_basic_set_size(set->p[i]);
6404
6405         return size;
6406 }
6407
6408 int isl_basic_map_dim_is_bounded(__isl_keep isl_basic_map *bmap,
6409         enum isl_dim_type type, unsigned pos)
6410 {
6411         int i;
6412         int lower, upper;
6413
6414         if (!bmap)
6415                 return -1;
6416
6417         isl_assert(bmap->ctx, pos < isl_basic_map_dim(bmap, type), return -1);
6418
6419         pos += isl_basic_map_offset(bmap, type);
6420
6421         for (i = 0; i < bmap->n_eq; ++i)
6422                 if (!isl_int_is_zero(bmap->eq[i][pos]))
6423                         return 1;
6424
6425         lower = upper = 0;
6426         for (i = 0; i < bmap->n_ineq; ++i) {
6427                 int sgn = isl_int_sgn(bmap->ineq[i][pos]);
6428                 if (sgn > 0)
6429                         lower = 1;
6430                 if (sgn < 0)
6431                         upper = 1;
6432         }
6433
6434         return lower && upper;
6435 }
6436
6437 int isl_map_dim_is_bounded(__isl_keep isl_map *map,
6438         enum isl_dim_type type, unsigned pos)
6439 {
6440         int i;
6441
6442         if (!map)
6443                 return -1;
6444
6445         for (i = 0; i < map->n; ++i) {
6446                 int bounded;
6447                 bounded = isl_basic_map_dim_is_bounded(map->p[i], type, pos);
6448                 if (bounded < 0 || !bounded)
6449                         return bounded;
6450         }
6451
6452         return 1;
6453 }
6454
6455 /* Return 1 if the specified dim is involved in both an upper bound
6456  * and a lower bound.
6457  */
6458 int isl_set_dim_is_bounded(__isl_keep isl_set *set,
6459         enum isl_dim_type type, unsigned pos)
6460 {
6461         return isl_map_dim_is_bounded((isl_map *)set, type, pos);
6462 }