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