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 __isl_give isl_basic_map *isl_basic_map_domain_map(
3638         __isl_take isl_basic_map *bmap)
3639 {
3640         int i, k;
3641         isl_dim *dim;
3642         isl_basic_map *domain;
3643         isl_basic_set *bset;
3644         int nparam, n_in, n_out;
3645         unsigned total;
3646
3647         nparam = isl_basic_map_dim(bmap, isl_dim_param);
3648         n_in = isl_basic_map_dim(bmap, isl_dim_in);
3649         n_out = isl_basic_map_dim(bmap, isl_dim_out);
3650
3651         dim = isl_dim_from_range(isl_dim_domain(isl_basic_map_get_dim(bmap)));
3652         domain = isl_basic_map_universe(dim);
3653
3654         bmap = isl_basic_map_from_domain(isl_basic_map_wrap(bmap));
3655         bmap = isl_basic_map_apply_range(bmap, domain);
3656         bmap = isl_basic_map_extend_constraints(bmap, n_in, 0);
3657
3658         total = isl_basic_map_total_dim(bmap);
3659
3660         for (i = 0; i < n_in; ++i) {
3661                 k = isl_basic_map_alloc_equality(bmap);
3662                 if (k < 0)
3663                         goto error;
3664                 isl_seq_clr(bmap->eq[k], 1 + total);
3665                 isl_int_set_si(bmap->eq[k][1 + nparam + i], -1);
3666                 isl_int_set_si(bmap->eq[k][1 + nparam + n_in + n_out + i], 1);
3667         }
3668
3669         bmap = isl_basic_map_gauss(bmap, NULL);
3670         return isl_basic_map_finalize(bmap);
3671 error:
3672         isl_basic_map_free(bmap);
3673         return NULL;
3674 }
3675
3676 __isl_give isl_basic_map *isl_basic_map_range_map(
3677         __isl_take isl_basic_map *bmap)
3678 {
3679         int i, k;
3680         isl_dim *dim;
3681         isl_basic_map *range;
3682         isl_basic_set *bset;
3683         int nparam, n_in, n_out;
3684         unsigned total;
3685
3686         nparam = isl_basic_map_dim(bmap, isl_dim_param);
3687         n_in = isl_basic_map_dim(bmap, isl_dim_in);
3688         n_out = isl_basic_map_dim(bmap, isl_dim_out);
3689
3690         dim = isl_dim_from_range(isl_dim_range(isl_basic_map_get_dim(bmap)));
3691         range = isl_basic_map_universe(dim);
3692
3693         bmap = isl_basic_map_from_domain(isl_basic_map_wrap(bmap));
3694         bmap = isl_basic_map_apply_range(bmap, range);
3695         bmap = isl_basic_map_extend_constraints(bmap, n_out, 0);
3696
3697         total = isl_basic_map_total_dim(bmap);
3698
3699         for (i = 0; i < n_out; ++i) {
3700                 k = isl_basic_map_alloc_equality(bmap);
3701                 if (k < 0)
3702                         goto error;
3703                 isl_seq_clr(bmap->eq[k], 1 + total);
3704                 isl_int_set_si(bmap->eq[k][1 + nparam + n_in + i], -1);
3705                 isl_int_set_si(bmap->eq[k][1 + nparam + n_in + n_out + i], 1);
3706         }
3707
3708         bmap = isl_basic_map_gauss(bmap, NULL);
3709         return isl_basic_map_finalize(bmap);
3710 error:
3711         isl_basic_map_free(bmap);
3712         return NULL;
3713 }
3714
3715 struct isl_set *isl_map_range(struct isl_map *map)
3716 {
3717         int i;
3718         struct isl_set *set;
3719
3720         if (!map)
3721                 goto error;
3722         if (isl_map_dim(map, isl_dim_in) == 0)
3723                 return (isl_set *)map;
3724
3725         map = isl_map_cow(map);
3726         if (!map)
3727                 goto error;
3728
3729         set = (struct isl_set *) map;
3730         set->dim = isl_dim_drop_inputs(set->dim, 0, set->dim->n_in);
3731         if (!set->dim)
3732                 goto error;
3733         for (i = 0; i < map->n; ++i) {
3734                 set->p[i] = isl_basic_map_range(map->p[i]);
3735                 if (!set->p[i])
3736                         goto error;
3737         }
3738         ISL_F_CLR(set, ISL_MAP_DISJOINT);
3739         ISL_F_CLR(set, ISL_SET_NORMALIZED);
3740         return set;
3741 error:
3742         isl_map_free(map);
3743         return NULL;
3744 }
3745
3746 __isl_give isl_map *isl_map_domain_map(__isl_take isl_map *map)
3747 {
3748         int i;
3749         isl_dim *domain_dim;
3750
3751         map = isl_map_cow(map);
3752         if (!map)
3753                 return NULL;
3754
3755         domain_dim = isl_dim_from_range(isl_dim_domain(isl_map_get_dim(map)));
3756         map->dim = isl_dim_from_domain(isl_dim_wrap(map->dim));
3757         map->dim = isl_dim_join(map->dim, domain_dim);
3758         if (!map->dim)
3759                 goto error;
3760         for (i = 0; i < map->n; ++i) {
3761                 map->p[i] = isl_basic_map_domain_map(map->p[i]);
3762                 if (!map->p[i])
3763                         goto error;
3764         }
3765         ISL_F_CLR(map, ISL_MAP_DISJOINT);
3766         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
3767         return map;
3768 error:
3769         isl_map_free(map);
3770         return NULL;
3771 }
3772
3773 __isl_give isl_map *isl_map_range_map(__isl_take isl_map *map)
3774 {
3775         int i;
3776         isl_dim *range_dim;
3777
3778         map = isl_map_cow(map);
3779         if (!map)
3780                 return NULL;
3781
3782         range_dim = isl_dim_range(isl_map_get_dim(map));
3783         map->dim = isl_dim_from_domain(isl_dim_wrap(map->dim));
3784         map->dim = isl_dim_join(map->dim, range_dim);
3785         if (!map->dim)
3786                 goto error;
3787         for (i = 0; i < map->n; ++i) {
3788                 map->p[i] = isl_basic_map_range_map(map->p[i]);
3789                 if (!map->p[i])
3790                         goto error;
3791         }
3792         ISL_F_CLR(map, ISL_MAP_DISJOINT);
3793         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
3794         return map;
3795 error:
3796         isl_map_free(map);
3797         return NULL;
3798 }
3799
3800 struct isl_map *isl_map_from_set(struct isl_set *set, struct isl_dim *dim)
3801 {
3802         int i;
3803         struct isl_map *map = NULL;
3804
3805         set = isl_set_cow(set);
3806         if (!set || !dim)
3807                 goto error;
3808         isl_assert(set->ctx, isl_dim_compatible(set->dim, dim), goto error);
3809         map = (struct isl_map *)set;
3810         for (i = 0; i < set->n; ++i) {
3811                 map->p[i] = isl_basic_map_from_basic_set(
3812                                 set->p[i], isl_dim_copy(dim));
3813                 if (!map->p[i])
3814                         goto error;
3815         }
3816         isl_dim_free(map->dim);
3817         map->dim = dim;
3818         return map;
3819 error:
3820         isl_dim_free(dim);
3821         isl_set_free(set);
3822         return NULL;
3823 }
3824
3825 __isl_give isl_basic_map *isl_basic_map_from_domain(
3826         __isl_take isl_basic_set *bset)
3827 {
3828         return isl_basic_map_reverse(isl_basic_map_from_range(bset));
3829 }
3830
3831 __isl_give isl_basic_map *isl_basic_map_from_range(
3832         __isl_take isl_basic_set *bset)
3833 {
3834         return (isl_basic_map *)bset;
3835 }
3836
3837 struct isl_map *isl_map_from_range(struct isl_set *set)
3838 {
3839         return (struct isl_map *)set;
3840 }
3841
3842 __isl_give isl_map *isl_map_from_domain(__isl_take isl_set *set)
3843 {
3844         return isl_map_reverse(isl_map_from_range(set));
3845 }
3846
3847 __isl_give isl_map *isl_map_from_domain_and_range(__isl_take isl_set *domain,
3848         __isl_take isl_set *range)
3849 {
3850         return isl_map_apply_range(isl_map_from_domain(domain),
3851                                    isl_map_from_range(range));
3852 }
3853
3854 struct isl_set *isl_set_from_map(struct isl_map *map)
3855 {
3856         int i;
3857         struct isl_set *set = NULL;
3858
3859         if (!map)
3860                 return NULL;
3861         map = isl_map_cow(map);
3862         if (!map)
3863                 return NULL;
3864         map->dim = isl_dim_as_set_dim(map->dim);
3865         if (!map->dim)
3866                 goto error;
3867         set = (struct isl_set *)map;
3868         for (i = 0; i < map->n; ++i) {
3869                 set->p[i] = isl_basic_set_from_basic_map(map->p[i]);
3870                 if (!set->p[i])
3871                         goto error;
3872         }
3873         return set;
3874 error:
3875         isl_map_free(map);
3876         return NULL;
3877 }
3878
3879 struct isl_map *isl_map_alloc_dim(struct isl_dim *dim, int n, unsigned flags)
3880 {
3881         struct isl_map *map;
3882
3883         if (!dim)
3884                 return NULL;
3885         isl_assert(dim->ctx, n >= 0, return NULL);
3886         map = isl_alloc(dim->ctx, struct isl_map,
3887                         sizeof(struct isl_map) +
3888                         (n - 1) * sizeof(struct isl_basic_map *));
3889         if (!map)
3890                 goto error;
3891
3892         map->ctx = dim->ctx;
3893         isl_ctx_ref(map->ctx);
3894         map->ref = 1;
3895         map->size = n;
3896         map->n = 0;
3897         map->dim = dim;
3898         map->flags = flags;
3899         return map;
3900 error:
3901         isl_dim_free(dim);
3902         return NULL;
3903 }
3904
3905 struct isl_map *isl_map_alloc(struct isl_ctx *ctx,
3906                 unsigned nparam, unsigned in, unsigned out, int n,
3907                 unsigned flags)
3908 {
3909         struct isl_map *map;
3910         struct isl_dim *dims;
3911
3912         dims = isl_dim_alloc(ctx, nparam, in, out);
3913         if (!dims)
3914                 return NULL;
3915
3916         map = isl_map_alloc_dim(dims, n, flags);
3917         return map;
3918 }
3919
3920 struct isl_basic_map *isl_basic_map_empty(struct isl_dim *dim)
3921 {
3922         struct isl_basic_map *bmap;
3923         bmap = isl_basic_map_alloc_dim(dim, 0, 1, 0);
3924         bmap = isl_basic_map_set_to_empty(bmap);
3925         return bmap;
3926 }
3927
3928 struct isl_basic_set *isl_basic_set_empty(struct isl_dim *dim)
3929 {
3930         struct isl_basic_set *bset;
3931         bset = isl_basic_set_alloc_dim(dim, 0, 1, 0);
3932         bset = isl_basic_set_set_to_empty(bset);
3933         return bset;
3934 }
3935
3936 struct isl_basic_map *isl_basic_map_empty_like(struct isl_basic_map *model)
3937 {
3938         struct isl_basic_map *bmap;
3939         if (!model)
3940                 return NULL;
3941         bmap = isl_basic_map_alloc_dim(isl_dim_copy(model->dim), 0, 1, 0);
3942         bmap = isl_basic_map_set_to_empty(bmap);
3943         return bmap;
3944 }
3945
3946 struct isl_basic_map *isl_basic_map_empty_like_map(struct isl_map *model)
3947 {
3948         struct isl_basic_map *bmap;
3949         if (!model)
3950                 return NULL;
3951         bmap = isl_basic_map_alloc_dim(isl_dim_copy(model->dim), 0, 1, 0);
3952         bmap = isl_basic_map_set_to_empty(bmap);
3953         return bmap;
3954 }
3955
3956 struct isl_basic_set *isl_basic_set_empty_like(struct isl_basic_set *model)
3957 {
3958         struct isl_basic_set *bset;
3959         if (!model)
3960                 return NULL;
3961         bset = isl_basic_set_alloc_dim(isl_dim_copy(model->dim), 0, 1, 0);
3962         bset = isl_basic_set_set_to_empty(bset);
3963         return bset;
3964 }
3965
3966 struct isl_basic_map *isl_basic_map_universe(struct isl_dim *dim)
3967 {
3968         struct isl_basic_map *bmap;
3969         bmap = isl_basic_map_alloc_dim(dim, 0, 0, 0);
3970         return bmap;
3971 }
3972
3973 struct isl_basic_set *isl_basic_set_universe(struct isl_dim *dim)
3974 {
3975         struct isl_basic_set *bset;
3976         bset = isl_basic_set_alloc_dim(dim, 0, 0, 0);
3977         return bset;
3978 }
3979
3980 __isl_give isl_basic_map *isl_basic_map_universe_like(
3981                 __isl_keep isl_basic_map *model)
3982 {
3983         if (!model)
3984                 return NULL;
3985         return isl_basic_map_alloc_dim(isl_dim_copy(model->dim), 0, 0, 0);
3986 }
3987
3988 struct isl_basic_set *isl_basic_set_universe_like(struct isl_basic_set *model)
3989 {
3990         if (!model)
3991                 return NULL;
3992         return isl_basic_set_alloc_dim(isl_dim_copy(model->dim), 0, 0, 0);
3993 }
3994
3995 __isl_give isl_basic_set *isl_basic_set_universe_like_set(
3996         __isl_keep isl_set *model)
3997 {
3998         if (!model)
3999                 return NULL;
4000         return isl_basic_set_alloc_dim(isl_dim_copy(model->dim), 0, 0, 0);
4001 }
4002
4003 struct isl_map *isl_map_empty(struct isl_dim *dim)
4004 {
4005         return isl_map_alloc_dim(dim, 0, ISL_MAP_DISJOINT);
4006 }
4007
4008 struct isl_map *isl_map_empty_like(struct isl_map *model)
4009 {
4010         if (!model)
4011                 return NULL;
4012         return isl_map_alloc_dim(isl_dim_copy(model->dim), 0, ISL_MAP_DISJOINT);
4013 }
4014
4015 struct isl_map *isl_map_empty_like_basic_map(struct isl_basic_map *model)
4016 {
4017         if (!model)
4018                 return NULL;
4019         return isl_map_alloc_dim(isl_dim_copy(model->dim), 0, ISL_MAP_DISJOINT);
4020 }
4021
4022 struct isl_set *isl_set_empty(struct isl_dim *dim)
4023 {
4024         return isl_set_alloc_dim(dim, 0, ISL_MAP_DISJOINT);
4025 }
4026
4027 struct isl_set *isl_set_empty_like(struct isl_set *model)
4028 {
4029         if (!model)
4030                 return NULL;
4031         return isl_set_empty(isl_dim_copy(model->dim));
4032 }
4033
4034 struct isl_map *isl_map_universe(struct isl_dim *dim)
4035 {
4036         struct isl_map *map;
4037         if (!dim)
4038                 return NULL;
4039         map = isl_map_alloc_dim(isl_dim_copy(dim), 1, ISL_MAP_DISJOINT);
4040         map = isl_map_add_basic_map(map, isl_basic_map_universe(dim));
4041         return map;
4042 }
4043
4044 struct isl_set *isl_set_universe(struct isl_dim *dim)
4045 {
4046         struct isl_set *set;
4047         if (!dim)
4048                 return NULL;
4049         set = isl_set_alloc_dim(isl_dim_copy(dim), 1, ISL_MAP_DISJOINT);
4050         set = isl_set_add_basic_set(set, isl_basic_set_universe(dim));
4051         return set;
4052 }
4053
4054 __isl_give isl_set *isl_set_universe_like(__isl_keep isl_set *model)
4055 {
4056         if (!model)
4057                 return NULL;
4058         return isl_set_universe(isl_dim_copy(model->dim));
4059 }
4060
4061 struct isl_map *isl_map_dup(struct isl_map *map)
4062 {
4063         int i;
4064         struct isl_map *dup;
4065
4066         if (!map)
4067                 return NULL;
4068         dup = isl_map_alloc_dim(isl_dim_copy(map->dim), map->n, map->flags);
4069         for (i = 0; i < map->n; ++i)
4070                 dup = isl_map_add_basic_map(dup, isl_basic_map_copy(map->p[i]));
4071         return dup;
4072 }
4073
4074 __isl_give isl_map *isl_map_add_basic_map(__isl_take isl_map *map,
4075                                                 __isl_take isl_basic_map *bmap)
4076 {
4077         if (!bmap || !map)
4078                 goto error;
4079         if (isl_basic_map_fast_is_empty(bmap)) {
4080                 isl_basic_map_free(bmap);
4081                 return map;
4082         }
4083         isl_assert(map->ctx, isl_dim_equal(map->dim, bmap->dim), goto error);
4084         isl_assert(map->ctx, map->n < map->size, goto error);
4085         map->p[map->n] = bmap;
4086         map->n++;
4087         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
4088         return map;
4089 error:
4090         if (map)
4091                 isl_map_free(map);
4092         if (bmap)
4093                 isl_basic_map_free(bmap);
4094         return NULL;
4095 }
4096
4097 void isl_map_free(struct isl_map *map)
4098 {
4099         int i;
4100
4101         if (!map)
4102                 return;
4103
4104         if (--map->ref > 0)
4105                 return;
4106
4107         isl_ctx_deref(map->ctx);
4108         for (i = 0; i < map->n; ++i)
4109                 isl_basic_map_free(map->p[i]);
4110         isl_dim_free(map->dim);
4111         free(map);
4112 }
4113
4114 struct isl_map *isl_map_extend(struct isl_map *base,
4115                 unsigned nparam, unsigned n_in, unsigned n_out)
4116 {
4117         int i;
4118
4119         base = isl_map_cow(base);
4120         if (!base)
4121                 return NULL;
4122
4123         base->dim = isl_dim_extend(base->dim, nparam, n_in, n_out);
4124         if (!base->dim)
4125                 goto error;
4126         for (i = 0; i < base->n; ++i) {
4127                 base->p[i] = isl_basic_map_extend_dim(base->p[i],
4128                                 isl_dim_copy(base->dim), 0, 0, 0);
4129                 if (!base->p[i])
4130                         goto error;
4131         }
4132         return base;
4133 error:
4134         isl_map_free(base);
4135         return NULL;
4136 }
4137
4138 struct isl_set *isl_set_extend(struct isl_set *base,
4139                 unsigned nparam, unsigned dim)
4140 {
4141         return (struct isl_set *)isl_map_extend((struct isl_map *)base,
4142                                                         nparam, 0, dim);
4143 }
4144
4145 static struct isl_basic_map *isl_basic_map_fix_pos_si(
4146         struct isl_basic_map *bmap, unsigned pos, int value)
4147 {
4148         int j;
4149
4150         bmap = isl_basic_map_cow(bmap);
4151         bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
4152         j = isl_basic_map_alloc_equality(bmap);
4153         if (j < 0)
4154                 goto error;
4155         isl_seq_clr(bmap->eq[j] + 1, isl_basic_map_total_dim(bmap));
4156         isl_int_set_si(bmap->eq[j][pos], -1);
4157         isl_int_set_si(bmap->eq[j][0], value);
4158         bmap = isl_basic_map_simplify(bmap);
4159         return isl_basic_map_finalize(bmap);
4160 error:
4161         isl_basic_map_free(bmap);
4162         return NULL;
4163 }
4164
4165 static __isl_give isl_basic_map *isl_basic_map_fix_pos(
4166         __isl_take isl_basic_map *bmap, unsigned pos, isl_int value)
4167 {
4168         int j;
4169
4170         bmap = isl_basic_map_cow(bmap);
4171         bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
4172         j = isl_basic_map_alloc_equality(bmap);
4173         if (j < 0)
4174                 goto error;
4175         isl_seq_clr(bmap->eq[j] + 1, isl_basic_map_total_dim(bmap));
4176         isl_int_set_si(bmap->eq[j][pos], -1);
4177         isl_int_set(bmap->eq[j][0], value);
4178         bmap = isl_basic_map_simplify(bmap);
4179         return isl_basic_map_finalize(bmap);
4180 error:
4181         isl_basic_map_free(bmap);
4182         return NULL;
4183 }
4184
4185 struct isl_basic_map *isl_basic_map_fix_si(struct isl_basic_map *bmap,
4186                 enum isl_dim_type type, unsigned pos, int value)
4187 {
4188         if (!bmap)
4189                 return NULL;
4190         isl_assert(bmap->ctx, pos < isl_basic_map_dim(bmap, type), goto error);
4191         return isl_basic_map_fix_pos_si(bmap,
4192                 isl_basic_map_offset(bmap, type) + pos, value);
4193 error:
4194         isl_basic_map_free(bmap);
4195         return NULL;
4196 }
4197
4198 __isl_give isl_basic_map *isl_basic_map_fix(__isl_take isl_basic_map *bmap,
4199                 enum isl_dim_type type, unsigned pos, isl_int value)
4200 {
4201         if (!bmap)
4202                 return NULL;
4203         isl_assert(bmap->ctx, pos < isl_basic_map_dim(bmap, type), goto error);
4204         return isl_basic_map_fix_pos(bmap,
4205                 isl_basic_map_offset(bmap, type) + pos, value);
4206 error:
4207         isl_basic_map_free(bmap);
4208         return NULL;
4209 }
4210
4211 struct isl_basic_set *isl_basic_set_fix_si(struct isl_basic_set *bset,
4212                 enum isl_dim_type type, unsigned pos, int value)
4213 {
4214         return (struct isl_basic_set *)
4215                 isl_basic_map_fix_si((struct isl_basic_map *)bset,
4216                                         type, pos, value);
4217 }
4218
4219 __isl_give isl_basic_set *isl_basic_set_fix(__isl_take isl_basic_set *bset,
4220                 enum isl_dim_type type, unsigned pos, isl_int value)
4221 {
4222         return (struct isl_basic_set *)
4223                 isl_basic_map_fix((struct isl_basic_map *)bset,
4224                                         type, pos, value);
4225 }
4226
4227 struct isl_basic_map *isl_basic_map_fix_input_si(struct isl_basic_map *bmap,
4228                 unsigned input, int value)
4229 {
4230         return isl_basic_map_fix_si(bmap, isl_dim_in, input, value);
4231 }
4232
4233 struct isl_basic_set *isl_basic_set_fix_dim_si(struct isl_basic_set *bset,
4234                 unsigned dim, int value)
4235 {
4236         return (struct isl_basic_set *)
4237                 isl_basic_map_fix_si((struct isl_basic_map *)bset,
4238                                         isl_dim_set, dim, value);
4239 }
4240
4241 struct isl_map *isl_map_fix_si(struct isl_map *map,
4242                 enum isl_dim_type type, unsigned pos, int value)
4243 {
4244         int i;
4245
4246         map = isl_map_cow(map);
4247         if (!map)
4248                 return NULL;
4249
4250         isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error);
4251         for (i = 0; i < map->n; ++i) {
4252                 map->p[i] = isl_basic_map_fix_si(map->p[i], type, pos, value);
4253                 if (!map->p[i])
4254                         goto error;
4255         }
4256         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
4257         return map;
4258 error:
4259         isl_map_free(map);
4260         return NULL;
4261 }
4262
4263 __isl_give isl_set *isl_set_fix_si(__isl_take isl_set *set,
4264                 enum isl_dim_type type, unsigned pos, int value)
4265 {
4266         return (struct isl_set *)
4267                 isl_map_fix_si((struct isl_map *)set, type, pos, value);
4268 }
4269
4270 __isl_give isl_map *isl_map_fix(__isl_take isl_map *map,
4271                 enum isl_dim_type type, unsigned pos, isl_int value)
4272 {
4273         int i;
4274
4275         map = isl_map_cow(map);
4276         if (!map)
4277                 return NULL;
4278
4279         isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error);
4280         for (i = 0; i < map->n; ++i) {
4281                 map->p[i] = isl_basic_map_fix(map->p[i], type, pos, value);
4282                 if (!map->p[i])
4283                         goto error;
4284         }
4285         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
4286         return map;
4287 error:
4288         isl_map_free(map);
4289         return NULL;
4290 }
4291
4292 __isl_give isl_set *isl_set_fix(__isl_take isl_set *set,
4293                 enum isl_dim_type type, unsigned pos, isl_int value)
4294 {
4295         return (struct isl_set *)isl_map_fix((isl_map *)set, type, pos, value);
4296 }
4297
4298 struct isl_map *isl_map_fix_input_si(struct isl_map *map,
4299                 unsigned input, int value)
4300 {
4301         return isl_map_fix_si(map, isl_dim_in, input, value);
4302 }
4303
4304 struct isl_set *isl_set_fix_dim_si(struct isl_set *set, unsigned dim, int value)
4305 {
4306         return (struct isl_set *)
4307                 isl_map_fix_si((struct isl_map *)set, isl_dim_set, dim, value);
4308 }
4309
4310 __isl_give isl_basic_map *isl_basic_map_lower_bound_si(
4311                 __isl_take isl_basic_map *bmap,
4312                 enum isl_dim_type type, unsigned pos, int value)
4313 {
4314         int j;
4315
4316         if (!bmap)
4317                 return NULL;
4318         isl_assert(bmap->ctx, pos < isl_basic_map_dim(bmap, type), goto error);
4319         pos += isl_basic_map_offset(bmap, type);
4320         bmap = isl_basic_map_cow(bmap);
4321         bmap = isl_basic_map_extend_constraints(bmap, 0, 1);
4322         j = isl_basic_map_alloc_inequality(bmap);
4323         if (j < 0)
4324                 goto error;
4325         isl_seq_clr(bmap->ineq[j], 1 + isl_basic_map_total_dim(bmap));
4326         isl_int_set_si(bmap->ineq[j][pos], 1);
4327         isl_int_set_si(bmap->ineq[j][0], -value);
4328         bmap = isl_basic_map_simplify(bmap);
4329         return isl_basic_map_finalize(bmap);
4330 error:
4331         isl_basic_map_free(bmap);
4332         return NULL;
4333 }
4334
4335 struct isl_basic_set *isl_basic_set_lower_bound_dim(struct isl_basic_set *bset,
4336         unsigned dim, isl_int value)
4337 {
4338         int j;
4339
4340         bset = isl_basic_set_cow(bset);
4341         bset = isl_basic_set_extend_constraints(bset, 0, 1);
4342         j = isl_basic_set_alloc_inequality(bset);
4343         if (j < 0)
4344                 goto error;
4345         isl_seq_clr(bset->ineq[j], 1 + isl_basic_set_total_dim(bset));
4346         isl_int_set_si(bset->ineq[j][1 + isl_basic_set_n_param(bset) + dim], 1);
4347         isl_int_neg(bset->ineq[j][0], value);
4348         bset = isl_basic_set_simplify(bset);
4349         return isl_basic_set_finalize(bset);
4350 error:
4351         isl_basic_set_free(bset);
4352         return NULL;
4353 }
4354
4355 __isl_give isl_map *isl_map_lower_bound_si(__isl_take isl_map *map,
4356                 enum isl_dim_type type, unsigned pos, int value)
4357 {
4358         int i;
4359
4360         map = isl_map_cow(map);
4361         if (!map)
4362                 return NULL;
4363
4364         isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error);
4365         for (i = 0; i < map->n; ++i) {
4366                 map->p[i] = isl_basic_map_lower_bound_si(map->p[i],
4367                                                          type, pos, value);
4368                 if (!map->p[i])
4369                         goto error;
4370         }
4371         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
4372         return map;
4373 error:
4374         isl_map_free(map);
4375         return NULL;
4376 }
4377
4378 __isl_give isl_set *isl_set_lower_bound_si(__isl_take isl_set *set,
4379                 enum isl_dim_type type, unsigned pos, int value)
4380 {
4381         return (struct isl_set *)
4382                 isl_map_lower_bound_si((struct isl_map *)set, type, pos, value);
4383 }
4384
4385 struct isl_set *isl_set_lower_bound_dim(struct isl_set *set, unsigned dim,
4386                                         isl_int value)
4387 {
4388         int i;
4389
4390         set = isl_set_cow(set);
4391         if (!set)
4392                 return NULL;
4393
4394         isl_assert(set->ctx, dim < isl_set_n_dim(set), goto error);
4395         for (i = 0; i < set->n; ++i) {
4396                 set->p[i] = isl_basic_set_lower_bound_dim(set->p[i], dim, value);
4397                 if (!set->p[i])
4398                         goto error;
4399         }
4400         return set;
4401 error:
4402         isl_set_free(set);
4403         return NULL;
4404 }
4405
4406 struct isl_map *isl_map_reverse(struct isl_map *map)
4407 {
4408         int i;
4409
4410         map = isl_map_cow(map);
4411         if (!map)
4412                 return NULL;
4413
4414         map->dim = isl_dim_reverse(map->dim);
4415         if (!map->dim)
4416                 goto error;
4417         for (i = 0; i < map->n; ++i) {
4418                 map->p[i] = isl_basic_map_reverse(map->p[i]);
4419                 if (!map->p[i])
4420                         goto error;
4421         }
4422         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
4423         return map;
4424 error:
4425         isl_map_free(map);
4426         return NULL;
4427 }
4428
4429 static struct isl_map *isl_basic_map_partial_lexopt(
4430                 struct isl_basic_map *bmap, struct isl_basic_set *dom,
4431                 struct isl_set **empty, int max)
4432 {
4433         if (!bmap)
4434                 goto error;
4435         if (bmap->ctx->opt->pip == ISL_PIP_PIP)
4436                 return isl_pip_basic_map_lexopt(bmap, dom, empty, max);
4437         else
4438                 return isl_tab_basic_map_partial_lexopt(bmap, dom, empty, max);
4439 error:
4440         isl_basic_map_free(bmap);
4441         isl_basic_set_free(dom);
4442         if (empty)
4443                 *empty = NULL;
4444         return NULL;
4445 }
4446
4447 struct isl_map *isl_basic_map_partial_lexmax(
4448                 struct isl_basic_map *bmap, struct isl_basic_set *dom,
4449                 struct isl_set **empty)
4450 {
4451         return isl_basic_map_partial_lexopt(bmap, dom, empty, 1);
4452 }
4453
4454 struct isl_map *isl_basic_map_partial_lexmin(
4455                 struct isl_basic_map *bmap, struct isl_basic_set *dom,
4456                 struct isl_set **empty)
4457 {
4458         return isl_basic_map_partial_lexopt(bmap, dom, empty, 0);
4459 }
4460
4461 struct isl_set *isl_basic_set_partial_lexmin(
4462                 struct isl_basic_set *bset, struct isl_basic_set *dom,
4463                 struct isl_set **empty)
4464 {
4465         return (struct isl_set *)
4466                 isl_basic_map_partial_lexmin((struct isl_basic_map *)bset,
4467                         dom, empty);
4468 }
4469
4470 struct isl_set *isl_basic_set_partial_lexmax(
4471                 struct isl_basic_set *bset, struct isl_basic_set *dom,
4472                 struct isl_set **empty)
4473 {
4474         return (struct isl_set *)
4475                 isl_basic_map_partial_lexmax((struct isl_basic_map *)bset,
4476                         dom, empty);
4477 }
4478
4479 /* Given a basic map "bmap", compute the lexicograhically minimal
4480  * (or maximal) image element for each domain element in dom.
4481  * Set *empty to those elements in dom that do not have an image element.
4482  *
4483  * We first make sure the basic sets in dom are disjoint and then
4484  * simply collect the results over each of the basic sets separately.
4485  * We could probably improve the efficiency a bit by moving the union
4486  * domain down into the parametric integer programming.
4487  */
4488 static __isl_give isl_map *basic_map_partial_lexopt(
4489                 __isl_take isl_basic_map *bmap, __isl_take isl_set *dom,
4490                 __isl_give isl_set **empty, int max)
4491 {
4492         int i;
4493         struct isl_map *res;
4494
4495         dom = isl_set_make_disjoint(dom);
4496         if (!dom)
4497                 goto error;
4498
4499         if (isl_set_fast_is_empty(dom)) {
4500                 res = isl_map_empty_like_basic_map(bmap);
4501                 *empty = isl_set_empty_like(dom);
4502                 isl_set_free(dom);
4503                 isl_basic_map_free(bmap);
4504                 return res;
4505         }
4506
4507         res = isl_basic_map_partial_lexopt(isl_basic_map_copy(bmap),
4508                         isl_basic_set_copy(dom->p[0]), empty, max);
4509
4510         for (i = 1; i < dom->n; ++i) {
4511                 struct isl_map *res_i;
4512                 struct isl_set *empty_i;
4513
4514                 res_i = isl_basic_map_partial_lexopt(isl_basic_map_copy(bmap),
4515                                 isl_basic_set_copy(dom->p[i]), &empty_i, max);
4516
4517                 res = isl_map_union_disjoint(res, res_i);
4518                 *empty = isl_set_union_disjoint(*empty, empty_i);
4519         }
4520
4521         isl_set_free(dom);
4522         isl_basic_map_free(bmap);
4523         return res;
4524 error:
4525         *empty = NULL;
4526         isl_set_free(dom);
4527         isl_basic_map_free(bmap);
4528         return NULL;
4529 }
4530
4531 /* Given a map "map", compute the lexicograhically minimal
4532  * (or maximal) image element for each domain element in dom.
4533  * Set *empty to those elements in dom that do not have an image element.
4534  *
4535  * We first compute the lexicographically minimal or maximal element
4536  * in the first basic map.  This results in a partial solution "res"
4537  * and a subset "todo" of dom that still need to be handled.
4538  * We then consider each of the remaining maps in "map" and successively
4539  * improve both "res" and "todo".
4540  *
4541  * Let res^k and todo^k be the results after k steps and let i = k + 1.
4542  * Assume we are computing the lexicographical maximum.
4543  * We first intersect basic map i with a relation that maps elements
4544  * to elements that are lexicographically larger than the image elements
4545  * in res^k and the compute the maximum image element of this intersection.
4546  * The result ("better") corresponds to those image elements in basic map i
4547  * that are better than what we had before.  The remainder ("keep") are the
4548  * domain elements for which the image element in res_k was better.
4549  * We also compute the lexicographical maximum of basic map i in todo^k.
4550  * res^i is the result of the operation + better + those elements in
4551  *              res^k that we should keep
4552  * todo^i is the remainder of the maximum operation on todo^k.
4553  */
4554 static __isl_give isl_map *isl_map_partial_lexopt(
4555                 __isl_take isl_map *map, __isl_take isl_set *dom,
4556                 __isl_give isl_set **empty, int max)
4557 {
4558         int i;
4559         struct isl_map *res;
4560         struct isl_set *todo;
4561
4562         if (!map || !dom)
4563                 goto error;
4564
4565         if (isl_map_fast_is_empty(map)) {
4566                 if (empty)
4567                         *empty = dom;
4568                 else
4569                         isl_set_free(dom);
4570                 return map;
4571         }
4572
4573         res = basic_map_partial_lexopt(isl_basic_map_copy(map->p[0]),
4574                                         isl_set_copy(dom), &todo, max);
4575
4576         for (i = 1; i < map->n; ++i) {
4577                 struct isl_map *lt;
4578                 struct isl_map *better;
4579                 struct isl_set *keep;
4580                 struct isl_map *res_i;
4581                 struct isl_set *todo_i;
4582                 struct isl_dim *dim = isl_map_get_dim(res);
4583
4584                 dim = isl_dim_range(dim);
4585                 if (max)
4586                         lt = isl_map_lex_lt(dim);
4587                 else
4588                         lt = isl_map_lex_gt(dim);
4589                 lt = isl_map_apply_range(isl_map_copy(res), lt);
4590                 lt = isl_map_intersect(lt,
4591                         isl_map_from_basic_map(isl_basic_map_copy(map->p[i])));
4592                 better = isl_map_partial_lexopt(lt,
4593                         isl_map_domain(isl_map_copy(res)),
4594                         &keep, max);
4595
4596                 res_i = basic_map_partial_lexopt(isl_basic_map_copy(map->p[i]),
4597                                                 todo, &todo_i, max);
4598
4599                 res = isl_map_intersect_domain(res, keep);
4600                 res = isl_map_union_disjoint(res, res_i);
4601                 res = isl_map_union_disjoint(res, better);
4602                 todo = todo_i;
4603         }
4604
4605         isl_set_free(dom);
4606         isl_map_free(map);
4607
4608         if (empty)
4609                 *empty = todo;
4610         else
4611                 isl_set_free(todo);
4612
4613         return res;
4614 error:
4615         if (empty)
4616                 *empty = NULL;
4617         isl_set_free(dom);
4618         isl_map_free(map);
4619         return NULL;
4620 }
4621
4622 __isl_give isl_map *isl_map_partial_lexmax(
4623                 __isl_take isl_map *map, __isl_take isl_set *dom,
4624                 __isl_give isl_set **empty)
4625 {
4626         return isl_map_partial_lexopt(map, dom, empty, 1);
4627 }
4628
4629 __isl_give isl_map *isl_map_partial_lexmin(
4630                 __isl_take isl_map *map, __isl_take isl_set *dom,
4631                 __isl_give isl_set **empty)
4632 {
4633         return isl_map_partial_lexopt(map, dom, empty, 0);
4634 }
4635
4636 __isl_give isl_set *isl_set_partial_lexmin(
4637                 __isl_take isl_set *set, __isl_take isl_set *dom,
4638                 __isl_give isl_set **empty)
4639 {
4640         return (struct isl_set *)
4641                 isl_map_partial_lexmin((struct isl_map *)set,
4642                         dom, empty);
4643 }
4644
4645 __isl_give isl_set *isl_set_partial_lexmax(
4646                 __isl_take isl_set *set, __isl_take isl_set *dom,
4647                 __isl_give isl_set **empty)
4648 {
4649         return (struct isl_set *)
4650                 isl_map_partial_lexmax((struct isl_map *)set,
4651                         dom, empty);
4652 }
4653
4654 __isl_give isl_map *isl_basic_map_lexopt(__isl_take isl_basic_map *bmap, int max)
4655 {
4656         struct isl_basic_set *dom = NULL;
4657         struct isl_dim *dom_dim;
4658
4659         if (!bmap)
4660                 goto error;
4661         dom_dim = isl_dim_domain(isl_dim_copy(bmap->dim));
4662         dom = isl_basic_set_universe(dom_dim);
4663         return isl_basic_map_partial_lexopt(bmap, dom, NULL, max);
4664 error:
4665         isl_basic_map_free(bmap);
4666         return NULL;
4667 }
4668
4669 __isl_give isl_map *isl_basic_map_lexmin(__isl_take isl_basic_map *bmap)
4670 {
4671         return isl_basic_map_lexopt(bmap, 0);
4672 }
4673
4674 __isl_give isl_map *isl_basic_map_lexmax(__isl_take isl_basic_map *bmap)
4675 {
4676         return isl_basic_map_lexopt(bmap, 1);
4677 }
4678
4679 __isl_give isl_set *isl_basic_set_lexmin(__isl_take isl_basic_set *bset)
4680 {
4681         return (isl_set *)isl_basic_map_lexmin((isl_basic_map *)bset);
4682 }
4683
4684 __isl_give isl_set *isl_basic_set_lexmax(__isl_take isl_basic_set *bset)
4685 {
4686         return (isl_set *)isl_basic_map_lexmax((isl_basic_map *)bset);
4687 }
4688
4689 __isl_give isl_map *isl_map_lexopt(__isl_take isl_map *map, int max)
4690 {
4691         struct isl_set *dom = NULL;
4692         struct isl_dim *dom_dim;
4693
4694         if (!map)
4695                 goto error;
4696         dom_dim = isl_dim_domain(isl_dim_copy(map->dim));
4697         dom = isl_set_universe(dom_dim);
4698         return isl_map_partial_lexopt(map, dom, NULL, max);
4699 error:
4700         isl_map_free(map);
4701         return NULL;
4702 }
4703
4704 __isl_give isl_map *isl_map_lexmin(__isl_take isl_map *map)
4705 {
4706         return isl_map_lexopt(map, 0);
4707 }
4708
4709 __isl_give isl_map *isl_map_lexmax(__isl_take isl_map *map)
4710 {
4711         return isl_map_lexopt(map, 1);
4712 }
4713
4714 __isl_give isl_set *isl_set_lexmin(__isl_take isl_set *set)
4715 {
4716         return (isl_set *)isl_map_lexmin((isl_map *)set);
4717 }
4718
4719 __isl_give isl_set *isl_set_lexmax(__isl_take isl_set *set)
4720 {
4721         return (isl_set *)isl_map_lexmax((isl_map *)set);
4722 }
4723
4724 /* Apply a preimage specified by "mat" on the parameters of "bset".
4725  * bset is assumed to have only parameters and divs.
4726  */
4727 static struct isl_basic_set *basic_set_parameter_preimage(
4728         struct isl_basic_set *bset, struct isl_mat *mat)
4729 {
4730         unsigned nparam;
4731
4732         if (!bset || !mat)
4733                 goto error;
4734
4735         bset->dim = isl_dim_cow(bset->dim);
4736         if (!bset->dim)
4737                 goto error;
4738
4739         nparam = isl_basic_set_dim(bset, isl_dim_param);
4740
4741         isl_assert(bset->ctx, mat->n_row == 1 + nparam, goto error);
4742
4743         bset->dim->nparam = 0;
4744         bset->dim->n_out = nparam;
4745         bset = isl_basic_set_preimage(bset, mat);
4746         if (bset) {
4747                 bset->dim->nparam = bset->dim->n_out;
4748                 bset->dim->n_out = 0;
4749         }
4750         return bset;
4751 error:
4752         isl_mat_free(mat);
4753         isl_basic_set_free(bset);
4754         return NULL;
4755 }
4756
4757 /* Apply a preimage specified by "mat" on the parameters of "set".
4758  * set is assumed to have only parameters and divs.
4759  */
4760 static struct isl_set *set_parameter_preimage(
4761         struct isl_set *set, struct isl_mat *mat)
4762 {
4763         struct isl_dim *dim = NULL;
4764         unsigned nparam;
4765
4766         if (!set || !mat)
4767                 goto error;
4768
4769         dim = isl_dim_copy(set->dim);
4770         dim = isl_dim_cow(dim);
4771         if (!dim)
4772                 goto error;
4773
4774         nparam = isl_set_dim(set, isl_dim_param);
4775
4776         isl_assert(set->ctx, mat->n_row == 1 + nparam, goto error);
4777
4778         dim->nparam = 0;
4779         dim->n_out = nparam;
4780         isl_set_reset_dim(set, dim);
4781         set = isl_set_preimage(set, mat);
4782         if (!set)
4783                 goto error2;
4784         dim = isl_dim_copy(set->dim);
4785         dim = isl_dim_cow(dim);
4786         if (!dim)
4787                 goto error2;
4788         dim->nparam = dim->n_out;
4789         dim->n_out = 0;
4790         isl_set_reset_dim(set, dim);
4791         return set;
4792 error:
4793         isl_dim_free(dim);
4794         isl_mat_free(mat);
4795 error2:
4796         isl_set_free(set);
4797         return NULL;
4798 }
4799
4800 /* Intersect the basic set "bset" with the affine space specified by the
4801  * equalities in "eq".
4802  */
4803 static struct isl_basic_set *basic_set_append_equalities(
4804         struct isl_basic_set *bset, struct isl_mat *eq)
4805 {
4806         int i, k;
4807         unsigned len;
4808
4809         if (!bset || !eq)
4810                 goto error;
4811
4812         bset = isl_basic_set_extend_dim(bset, isl_dim_copy(bset->dim), 0,
4813                                         eq->n_row, 0);
4814         if (!bset)
4815                 goto error;
4816
4817         len = 1 + isl_dim_total(bset->dim) + bset->extra;
4818         for (i = 0; i < eq->n_row; ++i) {
4819                 k = isl_basic_set_alloc_equality(bset);
4820                 if (k < 0)
4821                         goto error;
4822                 isl_seq_cpy(bset->eq[k], eq->row[i], eq->n_col);
4823                 isl_seq_clr(bset->eq[k] + eq->n_col, len - eq->n_col);
4824         }
4825         isl_mat_free(eq);
4826
4827         bset = isl_basic_set_gauss(bset, NULL);
4828         bset = isl_basic_set_finalize(bset);
4829
4830         return bset;
4831 error:
4832         isl_mat_free(eq);
4833         isl_basic_set_free(bset);
4834         return NULL;
4835 }
4836
4837 /* Intersect the set "set" with the affine space specified by the
4838  * equalities in "eq".
4839  */
4840 static struct isl_set *set_append_equalities(struct isl_set *set,
4841         struct isl_mat *eq)
4842 {
4843         int i;
4844
4845         if (!set || !eq)
4846                 goto error;
4847
4848         for (i = 0; i < set->n; ++i) {
4849                 set->p[i] = basic_set_append_equalities(set->p[i],
4850                                         isl_mat_copy(eq));
4851                 if (!set->p[i])
4852                         goto error;
4853         }
4854         isl_mat_free(eq);
4855         return set;
4856 error:
4857         isl_mat_free(eq);
4858         isl_set_free(set);
4859         return NULL;
4860 }
4861
4862 /* Project the given basic set onto its parameter domain, possibly introducing
4863  * new, explicit, existential variables in the constraints.
4864  * The input has parameters and (possibly implicit) existential variables.
4865  * The output has the same parameters, but only
4866  * explicit existentially quantified variables.
4867  *
4868  * The actual projection is performed by pip, but pip doesn't seem
4869  * to like equalities very much, so we first remove the equalities
4870  * among the parameters by performing a variable compression on
4871  * the parameters.  Afterward, an inverse transformation is performed
4872  * and the equalities among the parameters are inserted back in.
4873  */
4874 static struct isl_set *parameter_compute_divs(struct isl_basic_set *bset)
4875 {
4876         int i, j;
4877         struct isl_mat *eq;
4878         struct isl_mat *T, *T2;
4879         struct isl_set *set;
4880         unsigned nparam, n_div;
4881
4882         bset = isl_basic_set_cow(bset);
4883         if (!bset)
4884                 return NULL;
4885
4886         if (bset->n_eq == 0)
4887                 return isl_basic_set_lexmin(bset);
4888
4889         isl_basic_set_gauss(bset, NULL);
4890
4891         nparam = isl_basic_set_dim(bset, isl_dim_param);
4892         n_div = isl_basic_set_dim(bset, isl_dim_div);
4893
4894         for (i = 0, j = n_div - 1; i < bset->n_eq && j >= 0; --j) {
4895                 if (!isl_int_is_zero(bset->eq[i][1 + nparam + j]))
4896                         ++i;
4897         }
4898         if (i == bset->n_eq)
4899                 return isl_basic_set_lexmin(bset);
4900
4901         eq = isl_mat_sub_alloc(bset->ctx, bset->eq, i, bset->n_eq - i,
4902                 0, 1 + nparam);
4903         eq = isl_mat_cow(eq);
4904         T = isl_mat_variable_compression(isl_mat_copy(eq), &T2);
4905         if (T && T->n_col == 0) {
4906                 isl_mat_free(T);
4907                 isl_mat_free(T2);
4908                 isl_mat_free(eq);
4909                 bset = isl_basic_set_set_to_empty(bset);
4910                 return isl_set_from_basic_set(bset);
4911         }
4912         bset = basic_set_parameter_preimage(bset, T);
4913
4914         set = isl_basic_set_lexmin(bset);
4915         set = set_parameter_preimage(set, T2);
4916         set = set_append_equalities(set, eq);
4917         return set;
4918 }
4919
4920 /* Compute an explicit representation for all the existentially
4921  * quantified variables.
4922  * The input and output dimensions are first turned into parameters.
4923  * compute_divs then returns a map with the same parameters and
4924  * no input or output dimensions and the dimension specification
4925  * is reset to that of the input.
4926  */
4927 static struct isl_map *compute_divs(struct isl_basic_map *bmap)
4928 {
4929         struct isl_basic_set *bset;
4930         struct isl_set *set;
4931         struct isl_map *map;
4932         struct isl_dim *dim, *orig_dim = NULL;
4933         unsigned         nparam;
4934         unsigned         n_in;
4935         unsigned         n_out;
4936
4937         bmap = isl_basic_map_cow(bmap);
4938         if (!bmap)
4939                 return NULL;
4940
4941         nparam = isl_basic_map_dim(bmap, isl_dim_param);
4942         n_in = isl_basic_map_dim(bmap, isl_dim_in);
4943         n_out = isl_basic_map_dim(bmap, isl_dim_out);
4944         dim = isl_dim_set_alloc(bmap->ctx, nparam + n_in + n_out, 0);
4945         if (!dim)
4946                 goto error;
4947
4948         orig_dim = bmap->dim;
4949         bmap->dim = dim;
4950         bset = (struct isl_basic_set *)bmap;
4951
4952         set = parameter_compute_divs(bset);
4953         map = (struct isl_map *)set;
4954         map = isl_map_reset_dim(map, orig_dim);
4955
4956         return map;
4957 error:
4958         isl_basic_map_free(bmap);
4959         return NULL;
4960 }
4961
4962 static int basic_map_divs_known(__isl_keep isl_basic_map *bmap)
4963 {
4964         int i;
4965         unsigned off;
4966
4967         if (!bmap)
4968                 return -1;
4969
4970         off = isl_dim_total(bmap->dim);
4971         for (i = 0; i < bmap->n_div; ++i) {
4972                 if (isl_int_is_zero(bmap->div[i][0]))
4973                         return 0;
4974                 isl_assert(bmap->ctx, isl_int_is_zero(bmap->div[i][1+1+off+i]),
4975                                 return -1);
4976         }
4977         return 1;
4978 }
4979
4980 static int map_divs_known(__isl_keep isl_map *map)
4981 {
4982         int i;
4983
4984         if (!map)
4985                 return -1;
4986
4987         for (i = 0; i < map->n; ++i) {
4988                 int known = basic_map_divs_known(map->p[i]);
4989                 if (known <= 0)
4990                         return known;
4991         }
4992
4993         return 1;
4994 }
4995
4996 /* If bmap contains any unknown divs, then compute explicit
4997  * expressions for them.  However, this computation may be
4998  * quite expensive, so first try to remove divs that aren't
4999  * strictly needed.
5000  */
5001 struct isl_map *isl_basic_map_compute_divs(struct isl_basic_map *bmap)
5002 {
5003         int i;
5004         int known;
5005         struct isl_map *map;
5006
5007         known = basic_map_divs_known(bmap);
5008         if (known < 0)
5009                 goto error;
5010         if (known)
5011                 return isl_map_from_basic_map(bmap);
5012
5013         bmap = isl_basic_map_drop_redundant_divs(bmap);
5014
5015         known = basic_map_divs_known(bmap);
5016         if (known < 0)
5017                 goto error;
5018         if (known)
5019                 return isl_map_from_basic_map(bmap);
5020
5021         map = compute_divs(bmap);
5022         return map;
5023 error:
5024         isl_basic_map_free(bmap);
5025         return NULL;
5026 }
5027
5028 struct isl_map *isl_map_compute_divs(struct isl_map *map)
5029 {
5030         int i;
5031         int known;
5032         struct isl_map *res;
5033
5034         if (!map)
5035                 return NULL;
5036         if (map->n == 0)
5037                 return map;
5038
5039         known = map_divs_known(map);
5040         if (known < 0) {
5041                 isl_map_free(map);
5042                 return NULL;
5043         }
5044         if (known)
5045                 return map;
5046
5047         res = isl_basic_map_compute_divs(isl_basic_map_copy(map->p[0]));
5048         for (i = 1 ; i < map->n; ++i) {
5049                 struct isl_map *r2;
5050                 r2 = isl_basic_map_compute_divs(isl_basic_map_copy(map->p[i]));
5051                 if (ISL_F_ISSET(map, ISL_MAP_DISJOINT))
5052                         res = isl_map_union_disjoint(res, r2);
5053                 else
5054                         res = isl_map_union(res, r2);
5055         }
5056         isl_map_free(map);
5057
5058         return res;
5059 }
5060
5061 struct isl_set *isl_basic_set_compute_divs(struct isl_basic_set *bset)
5062 {
5063         return (struct isl_set *)
5064                 isl_basic_map_compute_divs((struct isl_basic_map *)bset);
5065 }
5066
5067 struct isl_set *isl_set_compute_divs(struct isl_set *set)
5068 {
5069         return (struct isl_set *)
5070                 isl_map_compute_divs((struct isl_map *)set);
5071 }
5072
5073 struct isl_set *isl_map_domain(struct isl_map *map)
5074 {
5075         int i;
5076         struct isl_set *set;
5077
5078         if (!map)
5079                 goto error;
5080
5081         map = isl_map_cow(map);
5082         if (!map)
5083                 return NULL;
5084
5085         set = (struct isl_set *)map;
5086         set->dim = isl_dim_domain(set->dim);
5087         if (!set->dim)
5088                 goto error;
5089         for (i = 0; i < map->n; ++i) {
5090                 set->p[i] = isl_basic_map_domain(map->p[i]);
5091                 if (!set->p[i])
5092                         goto error;
5093         }
5094         ISL_F_CLR(set, ISL_MAP_DISJOINT);
5095         ISL_F_CLR(set, ISL_SET_NORMALIZED);
5096         return set;
5097 error:
5098         isl_map_free(map);
5099         return NULL;
5100 }
5101
5102 struct isl_map *isl_map_union_disjoint(
5103                         struct isl_map *map1, struct isl_map *map2)
5104 {
5105         int i;
5106         unsigned flags = 0;
5107         struct isl_map *map = NULL;
5108
5109         if (!map1 || !map2)
5110                 goto error;
5111
5112         if (map1->n == 0) {
5113                 isl_map_free(map1);
5114                 return map2;
5115         }
5116         if (map2->n == 0) {
5117                 isl_map_free(map2);
5118                 return map1;
5119         }
5120
5121         isl_assert(map1->ctx, isl_dim_equal(map1->dim, map2->dim), goto error);
5122
5123         if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) &&
5124             ISL_F_ISSET(map2, ISL_MAP_DISJOINT))
5125                 ISL_FL_SET(flags, ISL_MAP_DISJOINT);
5126
5127         map = isl_map_alloc_dim(isl_dim_copy(map1->dim),
5128                                 map1->n + map2->n, flags);
5129         if (!map)
5130                 goto error;
5131         for (i = 0; i < map1->n; ++i) {
5132                 map = isl_map_add_basic_map(map,
5133                                   isl_basic_map_copy(map1->p[i]));
5134                 if (!map)
5135                         goto error;
5136         }
5137         for (i = 0; i < map2->n; ++i) {
5138                 map = isl_map_add_basic_map(map,
5139                                   isl_basic_map_copy(map2->p[i]));
5140                 if (!map)
5141                         goto error;
5142         }
5143         isl_map_free(map1);
5144         isl_map_free(map2);
5145         return map;
5146 error:
5147         isl_map_free(map);
5148         isl_map_free(map1);
5149         isl_map_free(map2);
5150         return NULL;
5151 }
5152
5153 struct isl_map *isl_map_union(struct isl_map *map1, struct isl_map *map2)
5154 {
5155         map1 = isl_map_union_disjoint(map1, map2);
5156         if (!map1)
5157                 return NULL;
5158         if (map1->n > 1)
5159                 ISL_F_CLR(map1, ISL_MAP_DISJOINT);
5160         return map1;
5161 }
5162
5163 struct isl_set *isl_set_union_disjoint(
5164                         struct isl_set *set1, struct isl_set *set2)
5165 {
5166         return (struct isl_set *)
5167                 isl_map_union_disjoint(
5168                         (struct isl_map *)set1, (struct isl_map *)set2);
5169 }
5170
5171 struct isl_set *isl_set_union(struct isl_set *set1, struct isl_set *set2)
5172 {
5173         return (struct isl_set *)
5174                 isl_map_union((struct isl_map *)set1, (struct isl_map *)set2);
5175 }
5176
5177 struct isl_map *isl_map_intersect_range(
5178                 struct isl_map *map, struct isl_set *set)
5179 {
5180         unsigned flags = 0;
5181         struct isl_map *result;
5182         int i, j;
5183
5184         if (!map || !set)
5185                 goto error;
5186
5187         if (ISL_F_ISSET(map, ISL_MAP_DISJOINT) &&
5188             ISL_F_ISSET(set, ISL_MAP_DISJOINT))
5189                 ISL_FL_SET(flags, ISL_MAP_DISJOINT);
5190
5191         result = isl_map_alloc_dim(isl_dim_copy(map->dim),
5192                                         map->n * set->n, flags);
5193         if (!result)
5194                 goto error;
5195         for (i = 0; i < map->n; ++i)
5196                 for (j = 0; j < set->n; ++j) {
5197                         result = isl_map_add_basic_map(result,
5198                             isl_basic_map_intersect_range(
5199                                 isl_basic_map_copy(map->p[i]),
5200                                 isl_basic_set_copy(set->p[j])));
5201                         if (!result)
5202                                 goto error;
5203                 }
5204         isl_map_free(map);
5205         isl_set_free(set);
5206         return result;
5207 error:
5208         isl_map_free(map);
5209         isl_set_free(set);
5210         return NULL;
5211 }
5212
5213 struct isl_map *isl_map_intersect_domain(
5214                 struct isl_map *map, struct isl_set *set)
5215 {
5216         return isl_map_reverse(
5217                 isl_map_intersect_range(isl_map_reverse(map), set));
5218 }
5219
5220 struct isl_map *isl_map_apply_domain(
5221                 struct isl_map *map1, struct isl_map *map2)
5222 {
5223         if (!map1 || !map2)
5224                 goto error;
5225         map1 = isl_map_reverse(map1);
5226         map1 = isl_map_apply_range(map1, map2);
5227         return isl_map_reverse(map1);
5228 error:
5229         isl_map_free(map1);
5230         isl_map_free(map2);
5231         return NULL;
5232 }
5233
5234 struct isl_map *isl_map_apply_range(
5235                 struct isl_map *map1, struct isl_map *map2)
5236 {
5237         struct isl_dim *dim_result;
5238         struct isl_map *result;
5239         int i, j;
5240
5241         if (!map1 || !map2)
5242                 goto error;
5243
5244         dim_result = isl_dim_join(isl_dim_copy(map1->dim),
5245                                   isl_dim_copy(map2->dim));
5246
5247         result = isl_map_alloc_dim(dim_result, map1->n * map2->n, 0);
5248         if (!result)
5249                 goto error;
5250         for (i = 0; i < map1->n; ++i)
5251                 for (j = 0; j < map2->n; ++j) {
5252                         result = isl_map_add_basic_map(result,
5253                             isl_basic_map_apply_range(
5254                                 isl_basic_map_copy(map1->p[i]),
5255                                 isl_basic_map_copy(map2->p[j])));
5256                         if (!result)
5257                                 goto error;
5258                 }
5259         isl_map_free(map1);
5260         isl_map_free(map2);
5261         if (result && result->n <= 1)
5262                 ISL_F_SET(result, ISL_MAP_DISJOINT);
5263         return result;
5264 error:
5265         isl_map_free(map1);
5266         isl_map_free(map2);
5267         return NULL;
5268 }
5269
5270 /*
5271  * returns range - domain
5272  */
5273 struct isl_basic_set *isl_basic_map_deltas(struct isl_basic_map *bmap)
5274 {
5275         isl_dim *dims, *target_dim;
5276         struct isl_basic_set *bset;
5277         unsigned dim;
5278         unsigned nparam;
5279         int i;
5280
5281         if (!bmap)
5282                 goto error;
5283         isl_assert(bmap->ctx, isl_dim_tuple_match(bmap->dim, isl_dim_in,
5284                                                   bmap->dim, isl_dim_out),
5285                    goto error);
5286         target_dim = isl_dim_domain(isl_basic_map_get_dim(bmap));
5287         dim = isl_basic_map_n_in(bmap);
5288         nparam = isl_basic_map_n_param(bmap);
5289         bset = isl_basic_set_from_basic_map(bmap);
5290         bset = isl_basic_set_cow(bset);
5291         dims = isl_basic_set_get_dim(bset);
5292         dims = isl_dim_add(dims, isl_dim_set, dim);
5293         bset = isl_basic_set_extend_dim(bset, dims, 0, dim, 0);
5294         bset = isl_basic_set_swap_vars(bset, 2*dim);
5295         for (i = 0; i < dim; ++i) {
5296                 int j = isl_basic_map_alloc_equality(
5297                                             (struct isl_basic_map *)bset);
5298                 if (j < 0)
5299                         goto error;
5300                 isl_seq_clr(bset->eq[j], 1 + isl_basic_set_total_dim(bset));
5301                 isl_int_set_si(bset->eq[j][1+nparam+i], 1);
5302                 isl_int_set_si(bset->eq[j][1+nparam+dim+i], 1);
5303                 isl_int_set_si(bset->eq[j][1+nparam+2*dim+i], -1);
5304         }
5305         bset = isl_basic_set_project_out(bset, isl_dim_set, dim, 2*dim);
5306         bset = isl_basic_set_reset_dim(bset, target_dim);
5307         return bset;
5308 error:
5309         isl_basic_map_free(bmap);
5310         return NULL;
5311 }
5312
5313 /*
5314  * returns range - domain
5315  */
5316 struct isl_set *isl_map_deltas(struct isl_map *map)
5317 {
5318         int i;
5319         isl_dim *dim;
5320         struct isl_set *result;
5321
5322         if (!map)
5323                 return NULL;
5324
5325         isl_assert(map->ctx, isl_dim_tuple_match(map->dim, isl_dim_in,
5326                                                  map->dim, isl_dim_out),
5327                    goto error);
5328         dim = isl_map_get_dim(map);
5329         dim = isl_dim_domain(dim);
5330         result = isl_set_alloc_dim(dim, map->n, map->flags);
5331         if (!result)
5332                 goto error;
5333         for (i = 0; i < map->n; ++i)
5334                 result = isl_set_add_basic_set(result,
5335                           isl_basic_map_deltas(isl_basic_map_copy(map->p[i])));
5336         isl_map_free(map);
5337         return result;
5338 error:
5339         isl_map_free(map);
5340         return NULL;
5341 }
5342
5343 static struct isl_basic_map *basic_map_identity(struct isl_dim *dims)
5344 {
5345         struct isl_basic_map *bmap;
5346         unsigned nparam;
5347         unsigned dim;
5348         int i;
5349
5350         if (!dims)
5351                 return NULL;
5352
5353         nparam = dims->nparam;
5354         dim = dims->n_out;
5355         bmap = isl_basic_map_alloc_dim(dims, 0, dim, 0);
5356         if (!bmap)
5357                 goto error;
5358
5359         for (i = 0; i < dim; ++i) {
5360                 int j = isl_basic_map_alloc_equality(bmap);
5361                 if (j < 0)
5362                         goto error;
5363                 isl_seq_clr(bmap->eq[j], 1 + isl_basic_map_total_dim(bmap));
5364                 isl_int_set_si(bmap->eq[j][1+nparam+i], 1);
5365                 isl_int_set_si(bmap->eq[j][1+nparam+dim+i], -1);
5366         }
5367         return isl_basic_map_finalize(bmap);
5368 error:
5369         isl_basic_map_free(bmap);
5370         return NULL;
5371 }
5372
5373 struct isl_basic_map *isl_basic_map_identity(struct isl_dim *set_dim)
5374 {
5375         struct isl_dim *dim = isl_dim_map(set_dim);
5376         if (!dim)
5377                 return NULL;
5378         return basic_map_identity(dim);
5379 }
5380
5381 struct isl_basic_map *isl_basic_map_identity_like(struct isl_basic_map *model)
5382 {
5383         if (!model || !model->dim)
5384                 return NULL;
5385         isl_assert(model->ctx,
5386                         model->dim->n_in == model->dim->n_out, return NULL);
5387         return basic_map_identity(isl_dim_copy(model->dim));
5388 }
5389
5390 static struct isl_map *map_identity(struct isl_dim *dim)
5391 {
5392         struct isl_map *map = isl_map_alloc_dim(dim, 1, ISL_MAP_DISJOINT);
5393         return isl_map_add_basic_map(map, basic_map_identity(isl_dim_copy(dim)));
5394 }
5395
5396 struct isl_map *isl_map_identity(struct isl_dim *set_dim)
5397 {
5398         struct isl_dim *dim = isl_dim_map(set_dim);
5399         if (!dim)
5400                 return NULL;
5401         return map_identity(dim);
5402 }
5403
5404 struct isl_map *isl_map_identity_like(struct isl_map *model)
5405 {
5406         if (!model || !model->dim)
5407                 return NULL;
5408         isl_assert(model->ctx,
5409                         model->dim->n_in == model->dim->n_out, return NULL);
5410         return map_identity(isl_dim_copy(model->dim));
5411 }
5412
5413 struct isl_map *isl_map_identity_like_basic_map(struct isl_basic_map *model)
5414 {
5415         if (!model || !model->dim)
5416                 return NULL;
5417         isl_assert(model->ctx,
5418                         model->dim->n_in == model->dim->n_out, return NULL);
5419         return map_identity(isl_dim_copy(model->dim));
5420 }
5421
5422 /* Construct a basic set with all set dimensions having only non-negative
5423  * values.
5424  */
5425 struct isl_basic_set *isl_basic_set_positive_orthant(struct isl_dim *dims)
5426 {
5427         int i;
5428         unsigned nparam;
5429         unsigned dim;
5430         struct isl_basic_set *bset;
5431
5432         if (!dims)
5433                 return NULL;
5434         nparam = dims->nparam;
5435         dim = dims->n_out;
5436         bset = isl_basic_set_alloc_dim(dims, 0, 0, dim);
5437         if (!bset)
5438                 return NULL;
5439         for (i = 0; i < dim; ++i) {
5440                 int k = isl_basic_set_alloc_inequality(bset);
5441                 if (k < 0)
5442                         goto error;
5443                 isl_seq_clr(bset->ineq[k], 1 + isl_basic_set_total_dim(bset));
5444                 isl_int_set_si(bset->ineq[k][1 + nparam + i], 1);
5445         }
5446         return bset;
5447 error:
5448         isl_basic_set_free(bset);
5449         return NULL;
5450 }
5451
5452 __isl_give isl_set *isl_set_split_dims(__isl_take isl_set *set,
5453         enum isl_dim_type type, unsigned first, unsigned n)
5454 {
5455         int i;
5456         isl_basic_set *nonneg = NULL;
5457         isl_basic_set *neg = NULL;
5458
5459         if (!set)
5460                 return NULL;
5461         if (n == 0)
5462                 return set;
5463
5464         isl_assert(set->ctx, first + n <= isl_set_dim(set, type), goto error);
5465
5466         for (i = 0; i < n; ++i) {
5467                 int k;
5468
5469                 neg = NULL;
5470                 nonneg = isl_basic_set_alloc_dim(isl_set_get_dim(set), 0, 0, 1);
5471                 k = isl_basic_set_alloc_inequality(nonneg);
5472                 if (k < 0)
5473                         goto error;
5474                 isl_seq_clr(nonneg->ineq[k], 1 + isl_basic_set_total_dim(nonneg));
5475                 isl_int_set_si(nonneg->ineq[k][pos(set->dim, type) + first + i], 1);
5476
5477                 neg = isl_basic_set_alloc_dim(isl_set_get_dim(set), 0, 0, 1);
5478                 k = isl_basic_set_alloc_inequality(neg);
5479                 if (k < 0)
5480                         goto error;
5481                 isl_seq_clr(neg->ineq[k], 1 + isl_basic_set_total_dim(neg));
5482                 isl_int_set_si(neg->ineq[k][0], -1);
5483                 isl_int_set_si(neg->ineq[k][pos(set->dim, type) + first + i], -1);
5484
5485                 set = isl_set_intersect(set, isl_basic_set_union(nonneg, neg));
5486         }
5487
5488         return set;
5489 error:
5490         isl_basic_set_free(nonneg);
5491         isl_basic_set_free(neg);
5492         isl_set_free(set);
5493         return NULL;
5494 }
5495
5496 int isl_set_is_equal(struct isl_set *set1, struct isl_set *set2)
5497 {
5498         return isl_map_is_equal((struct isl_map *)set1, (struct isl_map *)set2);
5499 }
5500
5501 int isl_basic_map_is_subset(
5502                 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
5503 {
5504         int is_subset;
5505         struct isl_map *map1;
5506         struct isl_map *map2;
5507
5508         if (!bmap1 || !bmap2)
5509                 return -1;
5510
5511         map1 = isl_map_from_basic_map(isl_basic_map_copy(bmap1));
5512         map2 = isl_map_from_basic_map(isl_basic_map_copy(bmap2));
5513
5514         is_subset = isl_map_is_subset(map1, map2);
5515
5516         isl_map_free(map1);
5517         isl_map_free(map2);
5518
5519         return is_subset;
5520 }
5521
5522 int isl_basic_map_is_equal(
5523                 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
5524 {
5525         int is_subset;
5526
5527         if (!bmap1 || !bmap2)
5528                 return -1;
5529         is_subset = isl_basic_map_is_subset(bmap1, bmap2);
5530         if (is_subset != 1)
5531                 return is_subset;
5532         is_subset = isl_basic_map_is_subset(bmap2, bmap1);
5533         return is_subset;
5534 }
5535
5536 int isl_basic_set_is_equal(
5537                 struct isl_basic_set *bset1, struct isl_basic_set *bset2)
5538 {
5539         return isl_basic_map_is_equal(
5540                 (struct isl_basic_map *)bset1, (struct isl_basic_map *)bset2);
5541 }
5542
5543 int isl_map_is_empty(struct isl_map *map)
5544 {
5545         int i;
5546         int is_empty;
5547
5548         if (!map)
5549                 return -1;
5550         for (i = 0; i < map->n; ++i) {
5551                 is_empty = isl_basic_map_is_empty(map->p[i]);
5552                 if (is_empty < 0)
5553                         return -1;
5554                 if (!is_empty)
5555                         return 0;
5556         }
5557         return 1;
5558 }
5559
5560 int isl_map_fast_is_empty(struct isl_map *map)
5561 {
5562         return map ? map->n == 0 : -1;
5563 }
5564
5565 int isl_set_fast_is_empty(struct isl_set *set)
5566 {
5567         return set ? set->n == 0 : -1;
5568 }
5569
5570 int isl_set_is_empty(struct isl_set *set)
5571 {
5572         return isl_map_is_empty((struct isl_map *)set);
5573 }
5574
5575 int isl_map_has_equal_dim(__isl_keep isl_map *map1, __isl_keep isl_map *map2)
5576 {
5577         if (!map1 || !map2)
5578                 return -1;
5579
5580         return isl_dim_equal(map1->dim, map2->dim);
5581 }
5582
5583 int isl_set_has_equal_dim(__isl_keep isl_set *set1, __isl_keep isl_set *set2)
5584 {
5585         if (!set1 || !set2)
5586                 return -1;
5587
5588         return isl_dim_equal(set1->dim, set2->dim);
5589 }
5590
5591 int isl_map_is_equal(struct isl_map *map1, struct isl_map *map2)
5592 {
5593         int is_subset;
5594
5595         if (!map1 || !map2)
5596                 return -1;
5597         is_subset = isl_map_is_subset(map1, map2);
5598         if (is_subset != 1)
5599                 return is_subset;
5600         is_subset = isl_map_is_subset(map2, map1);
5601         return is_subset;
5602 }
5603
5604 int isl_basic_map_is_strict_subset(
5605                 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
5606 {
5607         int is_subset;
5608
5609         if (!bmap1 || !bmap2)
5610                 return -1;
5611         is_subset = isl_basic_map_is_subset(bmap1, bmap2);
5612         if (is_subset != 1)
5613                 return is_subset;
5614         is_subset = isl_basic_map_is_subset(bmap2, bmap1);
5615         if (is_subset == -1)
5616                 return is_subset;
5617         return !is_subset;
5618 }
5619
5620 int isl_map_is_strict_subset(struct isl_map *map1, struct isl_map *map2)
5621 {
5622         int is_subset;
5623
5624         if (!map1 || !map2)
5625                 return -1;
5626         is_subset = isl_map_is_subset(map1, map2);
5627         if (is_subset != 1)
5628                 return is_subset;
5629         is_subset = isl_map_is_subset(map2, map1);
5630         if (is_subset == -1)
5631                 return is_subset;
5632         return !is_subset;
5633 }
5634
5635 int isl_set_is_strict_subset(__isl_keep isl_set *set1, __isl_keep isl_set *set2)
5636 {
5637         return isl_map_is_strict_subset((isl_map *)set1, (isl_map *)set2);
5638 }
5639
5640 int isl_basic_map_is_universe(struct isl_basic_map *bmap)
5641 {
5642         if (!bmap)
5643                 return -1;
5644         return bmap->n_eq == 0 && bmap->n_ineq == 0;
5645 }
5646
5647 int isl_basic_set_is_universe(struct isl_basic_set *bset)
5648 {
5649         if (!bset)
5650                 return -1;
5651         return bset->n_eq == 0 && bset->n_ineq == 0;
5652 }
5653
5654 int isl_map_fast_is_universe(__isl_keep isl_map *map)
5655 {
5656         int i;
5657
5658         if (!map)
5659                 return -1;
5660
5661         for (i = 0; i < map->n; ++i) {
5662                 int r = isl_basic_map_is_universe(map->p[i]);
5663                 if (r < 0 || r)
5664                         return r;
5665         }
5666
5667         return 0;
5668 }
5669
5670 int isl_set_fast_is_universe(__isl_keep isl_set *set)
5671 {
5672         return isl_map_fast_is_universe((isl_map *) set);
5673 }
5674
5675 int isl_basic_map_is_empty(struct isl_basic_map *bmap)
5676 {
5677         struct isl_basic_set *bset = NULL;
5678         struct isl_vec *sample = NULL;
5679         int empty;
5680         unsigned total;
5681
5682         if (!bmap)
5683                 return -1;
5684
5685         if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
5686                 return 1;
5687
5688         if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL)) {
5689                 struct isl_basic_map *copy = isl_basic_map_copy(bmap);
5690                 copy = isl_basic_map_remove_redundancies(copy);
5691                 empty = ISL_F_ISSET(copy, ISL_BASIC_MAP_EMPTY);
5692                 isl_basic_map_free(copy);
5693                 return empty;
5694         }
5695
5696         total = 1 + isl_basic_map_total_dim(bmap);
5697         if (bmap->sample && bmap->sample->size == total) {
5698                 int contains = isl_basic_map_contains(bmap, bmap->sample);
5699                 if (contains < 0)
5700                         return -1;
5701                 if (contains)
5702                         return 0;
5703         }
5704         isl_vec_free(bmap->sample);
5705         bmap->sample = NULL;
5706         bset = isl_basic_map_underlying_set(isl_basic_map_copy(bmap));
5707         if (!bset)
5708                 return -1;
5709         sample = isl_basic_set_sample_vec(bset);
5710         if (!sample)
5711                 return -1;
5712         empty = sample->size == 0;
5713         isl_vec_free(bmap->sample);
5714         bmap->sample = sample;
5715         if (empty)
5716                 ISL_F_SET(bmap, ISL_BASIC_MAP_EMPTY);
5717
5718         return empty;
5719 }
5720
5721 int isl_basic_map_fast_is_empty(struct isl_basic_map *bmap)
5722 {
5723         if (!bmap)
5724                 return -1;
5725         return ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY);
5726 }
5727
5728 int isl_basic_set_fast_is_empty(struct isl_basic_set *bset)
5729 {
5730         if (!bset)
5731                 return -1;
5732         return ISL_F_ISSET(bset, ISL_BASIC_SET_EMPTY);
5733 }
5734
5735 int isl_basic_set_is_empty(struct isl_basic_set *bset)
5736 {
5737         return isl_basic_map_is_empty((struct isl_basic_map *)bset);
5738 }
5739
5740 struct isl_map *isl_basic_map_union(
5741         struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
5742 {
5743         struct isl_map *map;
5744         if (!bmap1 || !bmap2)
5745                 return NULL;
5746
5747         isl_assert(bmap1->ctx, isl_dim_equal(bmap1->dim, bmap2->dim), goto error);
5748
5749         map = isl_map_alloc_dim(isl_dim_copy(bmap1->dim), 2, 0);
5750         if (!map)
5751                 goto error;
5752         map = isl_map_add_basic_map(map, bmap1);
5753         map = isl_map_add_basic_map(map, bmap2);
5754         return map;
5755 error:
5756         isl_basic_map_free(bmap1);
5757         isl_basic_map_free(bmap2);
5758         return NULL;
5759 }
5760
5761 struct isl_set *isl_basic_set_union(
5762                 struct isl_basic_set *bset1, struct isl_basic_set *bset2)
5763 {
5764         return (struct isl_set *)isl_basic_map_union(
5765                                             (struct isl_basic_map *)bset1,
5766                                             (struct isl_basic_map *)bset2);
5767 }
5768
5769 /* Order divs such that any div only depends on previous divs */
5770 struct isl_basic_map *isl_basic_map_order_divs(struct isl_basic_map *bmap)
5771 {
5772         int i;
5773         unsigned off;
5774
5775         if (!bmap)
5776                 return NULL;
5777
5778         off = isl_dim_total(bmap->dim);
5779
5780         for (i = 0; i < bmap->n_div; ++i) {
5781                 int pos;
5782                 if (isl_int_is_zero(bmap->div[i][0]))
5783                         continue;
5784                 pos = isl_seq_first_non_zero(bmap->div[i]+1+1+off+i,
5785                                                             bmap->n_div-i);
5786                 if (pos == -1)
5787                         continue;
5788                 isl_basic_map_swap_div(bmap, i, i + pos);
5789                 --i;
5790         }
5791         return bmap;
5792 }
5793
5794 struct isl_basic_set *isl_basic_set_order_divs(struct isl_basic_set *bset)
5795 {
5796         return (struct isl_basic_set *)
5797                 isl_basic_map_order_divs((struct isl_basic_map *)bset);
5798 }
5799
5800 __isl_give isl_map *isl_map_order_divs(__isl_take isl_map *map)
5801 {
5802         int i;
5803
5804         if (!map)
5805                 return 0;
5806
5807         for (i = 0; i < map->n; ++i) {
5808                 map->p[i] = isl_basic_map_order_divs(map->p[i]);
5809                 if (!map->p[i])
5810                         goto error;
5811         }
5812
5813         return map;
5814 error:
5815         isl_map_free(map);
5816         return NULL;
5817 }
5818
5819 /* Look for a div in dst that corresponds to the div "div" in src.
5820  * The divs before "div" in src and dst are assumed to be the same.
5821  *
5822  * Returns -1 if no corresponding div was found and the position
5823  * of the corresponding div in dst otherwise.
5824  */
5825 static int find_div(struct isl_basic_map *dst,
5826                         struct isl_basic_map *src, unsigned div)
5827 {
5828         int i;
5829
5830         unsigned total = isl_dim_total(src->dim);
5831
5832         isl_assert(dst->ctx, div <= dst->n_div, return -1);
5833         for (i = div; i < dst->n_div; ++i)
5834                 if (isl_seq_eq(dst->div[i], src->div[div], 1+1+total+div) &&
5835                     isl_seq_first_non_zero(dst->div[i]+1+1+total+div,
5836                                                 dst->n_div - div) == -1)
5837                         return i;
5838         return -1;
5839 }
5840
5841 struct isl_basic_map *isl_basic_map_align_divs(
5842                 struct isl_basic_map *dst, struct isl_basic_map *src)
5843 {
5844         int i;
5845         unsigned total = isl_dim_total(src->dim);
5846
5847         if (!dst || !src)
5848                 goto error;
5849
5850         if (src->n_div == 0)
5851                 return dst;
5852
5853         for (i = 0; i < src->n_div; ++i)
5854                 isl_assert(src->ctx, !isl_int_is_zero(src->div[i][0]), goto error);
5855
5856         src = isl_basic_map_order_divs(src);
5857         dst = isl_basic_map_cow(dst);
5858         dst = isl_basic_map_extend_dim(dst, isl_dim_copy(dst->dim),
5859                         src->n_div, 0, 2 * src->n_div);
5860         if (!dst)
5861                 return NULL;
5862         for (i = 0; i < src->n_div; ++i) {
5863                 int j = find_div(dst, src, i);
5864                 if (j < 0) {
5865                         j = isl_basic_map_alloc_div(dst);
5866                         if (j < 0)
5867                                 goto error;
5868                         isl_seq_cpy(dst->div[j], src->div[i], 1+1+total+i);
5869                         isl_seq_clr(dst->div[j]+1+1+total+i, dst->n_div - i);
5870                         if (isl_basic_map_add_div_constraints(dst, j) < 0)
5871                                 goto error;
5872                 }
5873                 if (j != i)
5874                         isl_basic_map_swap_div(dst, i, j);
5875         }
5876         return dst;
5877 error:
5878         isl_basic_map_free(dst);
5879         return NULL;
5880 }
5881
5882 struct isl_basic_set *isl_basic_set_align_divs(
5883                 struct isl_basic_set *dst, struct isl_basic_set *src)
5884 {
5885         return (struct isl_basic_set *)isl_basic_map_align_divs(
5886                 (struct isl_basic_map *)dst, (struct isl_basic_map *)src);
5887 }
5888
5889 struct isl_map *isl_map_align_divs(struct isl_map *map)
5890 {
5891         int i;
5892
5893         if (!map)
5894                 return NULL;
5895         if (map->n == 0)
5896                 return map;
5897         map = isl_map_compute_divs(map);
5898         map = isl_map_cow(map);
5899         if (!map)
5900                 return NULL;
5901
5902         for (i = 1; i < map->n; ++i)
5903                 map->p[0] = isl_basic_map_align_divs(map->p[0], map->p[i]);
5904         for (i = 1; i < map->n; ++i)
5905                 map->p[i] = isl_basic_map_align_divs(map->p[i], map->p[0]);
5906
5907         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
5908         return map;
5909 }
5910
5911 struct isl_set *isl_set_align_divs(struct isl_set *set)
5912 {
5913         return (struct isl_set *)isl_map_align_divs((struct isl_map *)set);
5914 }
5915
5916 struct isl_set *isl_set_apply(struct isl_set *set, struct isl_map *map)
5917 {
5918         if (!set || !map)
5919                 goto error;
5920         isl_assert(set->ctx, isl_map_compatible_domain(map, set), goto error);
5921         map = isl_map_intersect_domain(map, set);
5922         set = isl_map_range(map);
5923         return set;
5924 error:
5925         isl_set_free(set);
5926         isl_map_free(map);
5927         return NULL;
5928 }
5929
5930 /* There is no need to cow as removing empty parts doesn't change
5931  * the meaning of the set.
5932  */
5933 struct isl_map *isl_map_remove_empty_parts(struct isl_map *map)
5934 {
5935         int i;
5936
5937         if (!map)
5938                 return NULL;
5939
5940         for (i = map->n-1; i >= 0; --i) {
5941                 if (!ISL_F_ISSET(map->p[i], ISL_BASIC_MAP_EMPTY))
5942                         continue;
5943                 isl_basic_map_free(map->p[i]);
5944                 if (i != map->n-1) {
5945                         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
5946                         map->p[i] = map->p[map->n-1];
5947                 }
5948                 map->n--;
5949         }
5950
5951         return map;
5952 }
5953
5954 struct isl_set *isl_set_remove_empty_parts(struct isl_set *set)
5955 {
5956         return (struct isl_set *)
5957                 isl_map_remove_empty_parts((struct isl_map *)set);
5958 }
5959
5960 struct isl_basic_map *isl_map_copy_basic_map(struct isl_map *map)
5961 {
5962         struct isl_basic_map *bmap;
5963         if (!map || map->n == 0)
5964                 return NULL;
5965         bmap = map->p[map->n-1];
5966         isl_assert(map->ctx, ISL_F_ISSET(bmap, ISL_BASIC_SET_FINAL), return NULL);
5967         return isl_basic_map_copy(bmap);
5968 }
5969
5970 struct isl_basic_set *isl_set_copy_basic_set(struct isl_set *set)
5971 {
5972         return (struct isl_basic_set *)
5973                 isl_map_copy_basic_map((struct isl_map *)set);
5974 }
5975
5976 __isl_give isl_map *isl_map_drop_basic_map(__isl_take isl_map *map,
5977                                                 __isl_keep isl_basic_map *bmap)
5978 {
5979         int i;
5980
5981         if (!map || !bmap)
5982                 goto error;
5983         for (i = map->n-1; i >= 0; --i) {
5984                 if (map->p[i] != bmap)
5985                         continue;
5986                 map = isl_map_cow(map);
5987                 if (!map)
5988                         goto error;
5989                 isl_basic_map_free(map->p[i]);
5990                 if (i != map->n-1) {
5991                         ISL_F_CLR(map, ISL_SET_NORMALIZED);
5992                         map->p[i] = map->p[map->n-1];
5993                 }
5994                 map->n--;
5995                 return map;
5996         }
5997         return map;
5998 error:
5999         isl_map_free(map);
6000         return NULL;
6001 }
6002
6003 struct isl_set *isl_set_drop_basic_set(struct isl_set *set,
6004                                                 struct isl_basic_set *bset)
6005 {
6006         return (struct isl_set *)isl_map_drop_basic_map((struct isl_map *)set,
6007                                                 (struct isl_basic_map *)bset);
6008 }
6009
6010 /* Given two basic sets bset1 and bset2, compute the maximal difference
6011  * between the values of dimension pos in bset1 and those in bset2
6012  * for any common value of the parameters and dimensions preceding pos.
6013  */
6014 static enum isl_lp_result basic_set_maximal_difference_at(
6015         __isl_keep isl_basic_set *bset1, __isl_keep isl_basic_set *bset2,
6016         int pos, isl_int *opt)
6017 {
6018         struct isl_dim *dims;
6019         struct isl_basic_map *bmap1 = NULL;
6020         struct isl_basic_map *bmap2 = NULL;
6021         struct isl_ctx *ctx;
6022         struct isl_vec *obj;
6023         unsigned total;
6024         unsigned nparam;
6025         unsigned dim1, dim2;
6026         enum isl_lp_result res;
6027
6028         if (!bset1 || !bset2)
6029                 return isl_lp_error;
6030
6031         nparam = isl_basic_set_n_param(bset1);
6032         dim1 = isl_basic_set_n_dim(bset1);
6033         dim2 = isl_basic_set_n_dim(bset2);
6034         dims = isl_dim_alloc(bset1->ctx, nparam, pos, dim1 - pos);
6035         bmap1 = isl_basic_map_from_basic_set(isl_basic_set_copy(bset1), dims);
6036         dims = isl_dim_alloc(bset2->ctx, nparam, pos, dim2 - pos);
6037         bmap2 = isl_basic_map_from_basic_set(isl_basic_set_copy(bset2), dims);
6038         if (!bmap1 || !bmap2)
6039                 goto error;
6040         bmap1 = isl_basic_map_cow(bmap1);
6041         bmap1 = isl_basic_map_extend(bmap1, nparam,
6042                         pos, (dim1 - pos) + (dim2 - pos),
6043                         bmap2->n_div, bmap2->n_eq, bmap2->n_ineq);
6044         bmap1 = add_constraints(bmap1, bmap2, 0, dim1 - pos);
6045         if (!bmap1)
6046                 goto error;
6047         total = isl_basic_map_total_dim(bmap1);
6048         ctx = bmap1->ctx;
6049         obj = isl_vec_alloc(ctx, 1 + total);
6050         isl_seq_clr(obj->block.data, 1 + total);
6051         isl_int_set_si(obj->block.data[1+nparam+pos], 1);
6052         isl_int_set_si(obj->block.data[1+nparam+pos+(dim1-pos)], -1);
6053         if (!obj)
6054                 goto error;
6055         res = isl_basic_map_solve_lp(bmap1, 1, obj->block.data, ctx->one,
6056                                         opt, NULL, NULL);
6057         isl_basic_map_free(bmap1);
6058         isl_vec_free(obj);
6059         return res;
6060 error:
6061         isl_basic_map_free(bmap1);
6062         isl_basic_map_free(bmap2);
6063         return isl_lp_error;
6064 }
6065
6066 /* Given two _disjoint_ basic sets bset1 and bset2, check whether
6067  * for any common value of the parameters and dimensions preceding pos
6068  * in both basic sets, the values of dimension pos in bset1 are
6069  * smaller or larger than those in bset2.
6070  *
6071  * Returns
6072  *       1 if bset1 follows bset2
6073  *      -1 if bset1 precedes bset2
6074  *       0 if bset1 and bset2 are incomparable
6075  *      -2 if some error occurred.
6076  */
6077 int isl_basic_set_compare_at(struct isl_basic_set *bset1,
6078         struct isl_basic_set *bset2, int pos)
6079 {
6080         isl_int opt;
6081         enum isl_lp_result res;
6082         int cmp;
6083
6084         isl_int_init(opt);
6085
6086         res = basic_set_maximal_difference_at(bset1, bset2, pos, &opt);
6087
6088         if (res == isl_lp_empty)
6089                 cmp = 0;
6090         else if ((res == isl_lp_ok && isl_int_is_pos(opt)) ||
6091                   res == isl_lp_unbounded)
6092                 cmp = 1;
6093         else if (res == isl_lp_ok && isl_int_is_neg(opt))
6094                 cmp = -1;
6095         else
6096                 cmp = -2;
6097
6098         isl_int_clear(opt);
6099         return cmp;
6100 }
6101
6102 /* Given two basic sets bset1 and bset2, check whether
6103  * for any common value of the parameters and dimensions preceding pos
6104  * there is a value of dimension pos in bset1 that is larger
6105  * than a value of the same dimension in bset2.
6106  *
6107  * Return
6108  *       1 if there exists such a pair
6109  *       0 if there is no such pair, but there is a pair of equal values
6110  *      -1 otherwise
6111  *      -2 if some error occurred.
6112  */
6113 int isl_basic_set_follows_at(__isl_keep isl_basic_set *bset1,
6114         __isl_keep isl_basic_set *bset2, int pos)
6115 {
6116         isl_int opt;
6117         enum isl_lp_result res;
6118         int cmp;
6119
6120         isl_int_init(opt);
6121
6122         res = basic_set_maximal_difference_at(bset1, bset2, pos, &opt);
6123
6124         if (res == isl_lp_empty)
6125                 cmp = -1;
6126         else if ((res == isl_lp_ok && isl_int_is_pos(opt)) ||
6127                   res == isl_lp_unbounded)
6128                 cmp = 1;
6129         else if (res == isl_lp_ok && isl_int_is_neg(opt))
6130                 cmp = -1;
6131         else if (res == isl_lp_ok)
6132                 cmp = 0;
6133         else
6134                 cmp = -2;
6135
6136         isl_int_clear(opt);
6137         return cmp;
6138 }
6139
6140 /* Given two sets set1 and set2, check whether
6141  * for any common value of the parameters and dimensions preceding pos
6142  * there is a value of dimension pos in set1 that is larger
6143  * than a value of the same dimension in set2.
6144  *
6145  * Return
6146  *       1 if there exists such a pair
6147  *       0 if there is no such pair, but there is a pair of equal values
6148  *      -1 otherwise
6149  *      -2 if some error occurred.
6150  */
6151 int isl_set_follows_at(__isl_keep isl_set *set1,
6152         __isl_keep isl_set *set2, int pos)
6153 {
6154         int i, j;
6155         int follows = -1;
6156
6157         if (!set1 || !set2)
6158                 return -2;
6159
6160         for (i = 0; i < set1->n; ++i)
6161                 for (j = 0; j < set2->n; ++j) {
6162                         int f;
6163                         f = isl_basic_set_follows_at(set1->p[i], set2->p[j], pos);
6164                         if (f == 1 || f == -2)
6165                                 return f;
6166                         if (f > follows)
6167                                 follows = f;
6168                 }
6169
6170         return follows;
6171 }
6172
6173 static int isl_basic_map_fast_has_fixed_var(struct isl_basic_map *bmap,
6174         unsigned pos, isl_int *val)
6175 {
6176         int i;
6177         int d;
6178         unsigned total;
6179
6180         if (!bmap)
6181                 return -1;
6182         total = isl_basic_map_total_dim(bmap);
6183         for (i = 0, d = total-1; i < bmap->n_eq && d+1 > pos; ++i) {
6184                 for (; d+1 > pos; --d)
6185                         if (!isl_int_is_zero(bmap->eq[i][1+d]))
6186                                 break;
6187                 if (d != pos)
6188                         continue;
6189                 if (isl_seq_first_non_zero(bmap->eq[i]+1, d) != -1)
6190                         return 0;
6191                 if (isl_seq_first_non_zero(bmap->eq[i]+1+d+1, total-d-1) != -1)
6192                         return 0;
6193                 if (!isl_int_is_one(bmap->eq[i][1+d]))
6194                         return 0;
6195                 if (val)
6196                         isl_int_neg(*val, bmap->eq[i][0]);
6197                 return 1;
6198         }
6199         return 0;
6200 }
6201
6202 static int isl_map_fast_has_fixed_var(struct isl_map *map,
6203         unsigned pos, isl_int *val)
6204 {
6205         int i;
6206         isl_int v;
6207         isl_int tmp;
6208         int fixed;
6209
6210         if (!map)
6211                 return -1;
6212         if (map->n == 0)
6213                 return 0;
6214         if (map->n == 1)
6215                 return isl_basic_map_fast_has_fixed_var(map->p[0], pos, val);
6216         isl_int_init(v);
6217         isl_int_init(tmp);
6218         fixed = isl_basic_map_fast_has_fixed_var(map->p[0], pos, &v);
6219         for (i = 1; fixed == 1 && i < map->n; ++i) {
6220                 fixed = isl_basic_map_fast_has_fixed_var(map->p[i], pos, &tmp);
6221                 if (fixed == 1 && isl_int_ne(tmp, v))
6222                         fixed = 0;
6223         }
6224         if (val)
6225                 isl_int_set(*val, v);
6226         isl_int_clear(tmp);
6227         isl_int_clear(v);
6228         return fixed;
6229 }
6230
6231 static int isl_basic_set_fast_has_fixed_var(struct isl_basic_set *bset,
6232         unsigned pos, isl_int *val)
6233 {
6234         return isl_basic_map_fast_has_fixed_var((struct isl_basic_map *)bset,
6235                                                 pos, val);
6236 }
6237
6238 static int isl_set_fast_has_fixed_var(struct isl_set *set, unsigned pos,
6239         isl_int *val)
6240 {
6241         return isl_map_fast_has_fixed_var((struct isl_map *)set, pos, val);
6242 }
6243
6244 int isl_basic_map_fast_is_fixed(struct isl_basic_map *bmap,
6245         enum isl_dim_type type, unsigned pos, isl_int *val)
6246 {
6247         if (pos >= isl_basic_map_dim(bmap, type))
6248                 return -1;
6249         return isl_basic_map_fast_has_fixed_var(bmap,
6250                 isl_basic_map_offset(bmap, type) - 1 + pos, val);
6251 }
6252
6253 int isl_map_fast_is_fixed(struct isl_map *map,
6254         enum isl_dim_type type, unsigned pos, isl_int *val)
6255 {
6256         if (pos >= isl_map_dim(map, type))
6257                 return -1;
6258         return isl_map_fast_has_fixed_var(map,
6259                 map_offset(map, type) - 1 + pos, val);
6260 }
6261
6262 /* Check if dimension dim has fixed value and if so and if val is not NULL,
6263  * then return this fixed value in *val.
6264  */
6265 int isl_basic_set_fast_dim_is_fixed(struct isl_basic_set *bset, unsigned dim,
6266         isl_int *val)
6267 {
6268         return isl_basic_set_fast_has_fixed_var(bset,
6269                                         isl_basic_set_n_param(bset) + dim, val);
6270 }
6271
6272 /* Check if dimension dim has fixed value and if so and if val is not NULL,
6273  * then return this fixed value in *val.
6274  */
6275 int isl_set_fast_dim_is_fixed(struct isl_set *set, unsigned dim, isl_int *val)
6276 {
6277         return isl_set_fast_has_fixed_var(set, isl_set_n_param(set) + dim, val);
6278 }
6279
6280 /* Check if input variable in has fixed value and if so and if val is not NULL,
6281  * then return this fixed value in *val.
6282  */
6283 int isl_map_fast_input_is_fixed(struct isl_map *map, unsigned in, isl_int *val)
6284 {
6285         return isl_map_fast_has_fixed_var(map, isl_map_n_param(map) + in, val);
6286 }
6287
6288 /* Check if dimension dim has an (obvious) fixed lower bound and if so
6289  * and if val is not NULL, then return this lower bound in *val.
6290  */
6291 int isl_basic_set_fast_dim_has_fixed_lower_bound(struct isl_basic_set *bset,
6292         unsigned dim, isl_int *val)
6293 {
6294         int i, i_eq = -1, i_ineq = -1;
6295         isl_int *c;
6296         unsigned total;
6297         unsigned nparam;
6298
6299         if (!bset)
6300                 return -1;
6301         total = isl_basic_set_total_dim(bset);
6302         nparam = isl_basic_set_n_param(bset);
6303         for (i = 0; i < bset->n_eq; ++i) {
6304                 if (isl_int_is_zero(bset->eq[i][1+nparam+dim]))
6305                         continue;
6306                 if (i_eq != -1)
6307                         return 0;
6308                 i_eq = i;
6309         }
6310         for (i = 0; i < bset->n_ineq; ++i) {
6311                 if (!isl_int_is_pos(bset->ineq[i][1+nparam+dim]))
6312                         continue;
6313                 if (i_eq != -1 || i_ineq != -1)
6314                         return 0;
6315                 i_ineq = i;
6316         }
6317         if (i_eq == -1 && i_ineq == -1)
6318                 return 0;
6319         c = i_eq != -1 ? bset->eq[i_eq] : bset->ineq[i_ineq];
6320         /* The coefficient should always be one due to normalization. */
6321         if (!isl_int_is_one(c[1+nparam+dim]))
6322                 return 0;
6323         if (isl_seq_first_non_zero(c+1, nparam+dim) != -1)
6324                 return 0;
6325         if (isl_seq_first_non_zero(c+1+nparam+dim+1,
6326                                         total - nparam - dim - 1) != -1)
6327                 return 0;
6328         if (val)
6329                 isl_int_neg(*val, c[0]);
6330         return 1;
6331 }
6332
6333 int isl_set_fast_dim_has_fixed_lower_bound(struct isl_set *set,
6334         unsigned dim, isl_int *val)
6335 {
6336         int i;
6337         isl_int v;
6338         isl_int tmp;
6339         int fixed;
6340
6341         if (!set)
6342                 return -1;
6343         if (set->n == 0)
6344                 return 0;
6345         if (set->n == 1)
6346                 return isl_basic_set_fast_dim_has_fixed_lower_bound(set->p[0],
6347                                                                 dim, val);
6348         isl_int_init(v);
6349         isl_int_init(tmp);
6350         fixed = isl_basic_set_fast_dim_has_fixed_lower_bound(set->p[0],
6351                                                                 dim, &v);
6352         for (i = 1; fixed == 1 && i < set->n; ++i) {
6353                 fixed = isl_basic_set_fast_dim_has_fixed_lower_bound(set->p[i],
6354                                                                 dim, &tmp);
6355                 if (fixed == 1 && isl_int_ne(tmp, v))
6356                         fixed = 0;
6357         }
6358         if (val)
6359                 isl_int_set(*val, v);
6360         isl_int_clear(tmp);
6361         isl_int_clear(v);
6362         return fixed;
6363 }
6364
6365 struct constraint {
6366         unsigned        size;
6367         isl_int         *c;
6368 };
6369
6370 static int qsort_constraint_cmp(const void *p1, const void *p2)
6371 {
6372         const struct constraint *c1 = (const struct constraint *)p1;
6373         const struct constraint *c2 = (const struct constraint *)p2;
6374         unsigned size = isl_min(c1->size, c2->size);
6375         return isl_seq_cmp(c1->c, c2->c, size);
6376 }
6377
6378 static struct isl_basic_map *isl_basic_map_sort_constraints(
6379         struct isl_basic_map *bmap)
6380 {
6381         int i;
6382         struct constraint *c;
6383         unsigned total;
6384
6385         if (!bmap)
6386                 return NULL;
6387         total = isl_basic_map_total_dim(bmap);
6388         c = isl_alloc_array(bmap->ctx, struct constraint, bmap->n_ineq);
6389         if (!c)
6390                 goto error;
6391         for (i = 0; i < bmap->n_ineq; ++i) {
6392                 c[i].size = total;
6393                 c[i].c = bmap->ineq[i];
6394         }
6395         qsort(c, bmap->n_ineq, sizeof(struct constraint), qsort_constraint_cmp);
6396         for (i = 0; i < bmap->n_ineq; ++i)
6397                 bmap->ineq[i] = c[i].c;
6398         free(c);
6399         return bmap;
6400 error:
6401         isl_basic_map_free(bmap);
6402         return NULL;
6403 }
6404
6405 __isl_give isl_basic_set *isl_basic_set_sort_constraints(
6406         __isl_take isl_basic_set *bset)
6407 {
6408         return (struct isl_basic_set *)isl_basic_map_sort_constraints(
6409                                                 (struct isl_basic_map *)bset);
6410 }
6411
6412 struct isl_basic_map *isl_basic_map_normalize(struct isl_basic_map *bmap)
6413 {
6414         if (!bmap)
6415                 return NULL;
6416         if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_NORMALIZED))
6417                 return bmap;
6418         bmap = isl_basic_map_remove_redundancies(bmap);
6419         bmap = isl_basic_map_sort_constraints(bmap);
6420         ISL_F_SET(bmap, ISL_BASIC_MAP_NORMALIZED);
6421         return bmap;
6422 }
6423
6424 struct isl_basic_set *isl_basic_set_normalize(struct isl_basic_set *bset)
6425 {
6426         return (struct isl_basic_set *)isl_basic_map_normalize(
6427                                                 (struct isl_basic_map *)bset);
6428 }
6429
6430 int isl_basic_map_fast_cmp(const __isl_keep isl_basic_map *bmap1,
6431         const __isl_keep isl_basic_map *bmap2)
6432 {
6433         int i, cmp;
6434         unsigned total;
6435
6436         if (bmap1 == bmap2)
6437                 return 0;
6438         if (isl_basic_map_n_param(bmap1) != isl_basic_map_n_param(bmap2))
6439                 return isl_basic_map_n_param(bmap1) - isl_basic_map_n_param(bmap2);
6440         if (isl_basic_map_n_in(bmap1) != isl_basic_map_n_in(bmap2))
6441                 return isl_basic_map_n_out(bmap1) - isl_basic_map_n_out(bmap2);
6442         if (isl_basic_map_n_out(bmap1) != isl_basic_map_n_out(bmap2))
6443                 return isl_basic_map_n_out(bmap1) - isl_basic_map_n_out(bmap2);
6444         if (ISL_F_ISSET(bmap1, ISL_BASIC_MAP_EMPTY) &&
6445             ISL_F_ISSET(bmap2, ISL_BASIC_MAP_EMPTY))
6446                 return 0;
6447         if (ISL_F_ISSET(bmap1, ISL_BASIC_MAP_EMPTY))
6448                 return 1;
6449         if (ISL_F_ISSET(bmap2, ISL_BASIC_MAP_EMPTY))
6450                 return -1;
6451         if (bmap1->n_eq != bmap2->n_eq)
6452                 return bmap1->n_eq - bmap2->n_eq;
6453         if (bmap1->n_ineq != bmap2->n_ineq)
6454                 return bmap1->n_ineq - bmap2->n_ineq;
6455         if (bmap1->n_div != bmap2->n_div)
6456                 return bmap1->n_div - bmap2->n_div;
6457         total = isl_basic_map_total_dim(bmap1);
6458         for (i = 0; i < bmap1->n_eq; ++i) {
6459                 cmp = isl_seq_cmp(bmap1->eq[i], bmap2->eq[i], 1+total);
6460                 if (cmp)
6461                         return cmp;
6462         }
6463         for (i = 0; i < bmap1->n_ineq; ++i) {
6464                 cmp = isl_seq_cmp(bmap1->ineq[i], bmap2->ineq[i], 1+total);
6465                 if (cmp)
6466                         return cmp;
6467         }
6468         for (i = 0; i < bmap1->n_div; ++i) {
6469                 cmp = isl_seq_cmp(bmap1->div[i], bmap2->div[i], 1+1+total);
6470                 if (cmp)
6471                         return cmp;
6472         }
6473         return 0;
6474 }
6475
6476 int isl_basic_map_fast_is_equal(__isl_keep isl_basic_map *bmap1,
6477         __isl_keep isl_basic_map *bmap2)
6478 {
6479         return isl_basic_map_fast_cmp(bmap1, bmap2) == 0;
6480 }
6481
6482 int isl_basic_set_fast_is_equal(__isl_keep isl_basic_set *bset1,
6483         __isl_keep isl_basic_set *bset2)
6484 {
6485         return isl_basic_map_fast_is_equal((isl_basic_map *)bset1,
6486                                             (isl_basic_map *)bset2);
6487 }
6488
6489 static int qsort_bmap_cmp(const void *p1, const void *p2)
6490 {
6491         const struct isl_basic_map *bmap1 = *(const struct isl_basic_map **)p1;
6492         const struct isl_basic_map *bmap2 = *(const struct isl_basic_map **)p2;
6493
6494         return isl_basic_map_fast_cmp(bmap1, bmap2);
6495 }
6496
6497 /* We normalize in place, but if anything goes wrong we need
6498  * to return NULL, so we need to make sure we don't change the
6499  * meaning of any possible other copies of map.
6500  */
6501 struct isl_map *isl_map_normalize(struct isl_map *map)
6502 {
6503         int i, j;
6504         struct isl_basic_map *bmap;
6505
6506         if (!map)
6507                 return NULL;
6508         if (ISL_F_ISSET(map, ISL_MAP_NORMALIZED))
6509                 return map;
6510         for (i = 0; i < map->n; ++i) {
6511                 bmap = isl_basic_map_normalize(isl_basic_map_copy(map->p[i]));
6512                 if (!bmap)
6513                         goto error;
6514                 isl_basic_map_free(map->p[i]);
6515                 map->p[i] = bmap;
6516         }
6517         qsort(map->p, map->n, sizeof(struct isl_basic_map *), qsort_bmap_cmp);
6518         ISL_F_SET(map, ISL_MAP_NORMALIZED);
6519         map = isl_map_remove_empty_parts(map);
6520         if (!map)
6521                 return NULL;
6522         for (i = map->n - 1; i >= 1; --i) {
6523                 if (!isl_basic_map_fast_is_equal(map->p[i-1], map->p[i]))
6524                         continue;
6525                 isl_basic_map_free(map->p[i-1]);
6526                 for (j = i; j < map->n; ++j)
6527                         map->p[j-1] = map->p[j];
6528                 map->n--;
6529         }
6530         return map;
6531 error:
6532         isl_map_free(map);
6533         return NULL;
6534
6535 }
6536
6537 struct isl_set *isl_set_normalize(struct isl_set *set)
6538 {
6539         return (struct isl_set *)isl_map_normalize((struct isl_map *)set);
6540 }
6541
6542 int isl_map_fast_is_equal(struct isl_map *map1, struct isl_map *map2)
6543 {
6544         int i;
6545         int equal;
6546
6547         if (!map1 || !map2)
6548                 return -1;
6549
6550         if (map1 == map2)
6551                 return 1;
6552         if (!isl_dim_equal(map1->dim, map2->dim))
6553                 return 0;
6554
6555         map1 = isl_map_copy(map1);
6556         map2 = isl_map_copy(map2);
6557         map1 = isl_map_normalize(map1);
6558         map2 = isl_map_normalize(map2);
6559         if (!map1 || !map2)
6560                 goto error;
6561         equal = map1->n == map2->n;
6562         for (i = 0; equal && i < map1->n; ++i) {
6563                 equal = isl_basic_map_fast_is_equal(map1->p[i], map2->p[i]);
6564                 if (equal < 0)
6565                         goto error;
6566         }
6567         isl_map_free(map1);
6568         isl_map_free(map2);
6569         return equal;
6570 error:
6571         isl_map_free(map1);
6572         isl_map_free(map2);
6573         return -1;
6574 }
6575
6576 int isl_set_fast_is_equal(struct isl_set *set1, struct isl_set *set2)
6577 {
6578         return isl_map_fast_is_equal((struct isl_map *)set1,
6579                                                 (struct isl_map *)set2);
6580 }
6581
6582 /* Return an interval that ranges from min to max (inclusive)
6583  */
6584 struct isl_basic_set *isl_basic_set_interval(struct isl_ctx *ctx,
6585         isl_int min, isl_int max)
6586 {
6587         int k;
6588         struct isl_basic_set *bset = NULL;
6589
6590         bset = isl_basic_set_alloc(ctx, 0, 1, 0, 0, 2);
6591         if (!bset)
6592                 goto error;
6593
6594         k = isl_basic_set_alloc_inequality(bset);
6595         if (k < 0)
6596                 goto error;
6597         isl_int_set_si(bset->ineq[k][1], 1);
6598         isl_int_neg(bset->ineq[k][0], min);
6599
6600         k = isl_basic_set_alloc_inequality(bset);
6601         if (k < 0)
6602                 goto error;
6603         isl_int_set_si(bset->ineq[k][1], -1);
6604         isl_int_set(bset->ineq[k][0], max);
6605
6606         return bset;
6607 error:
6608         isl_basic_set_free(bset);
6609         return NULL;
6610 }
6611
6612 /* Return the Cartesian product of the basic sets in list (in the given order).
6613  */
6614 struct isl_basic_set *isl_basic_set_product(struct isl_basic_set_list *list)
6615 {
6616         int i;
6617         unsigned dim;
6618         unsigned nparam;
6619         unsigned extra;
6620         unsigned n_eq;
6621         unsigned n_ineq;
6622         struct isl_basic_set *product = NULL;
6623
6624         if (!list)
6625                 goto error;
6626         isl_assert(list->ctx, list->n > 0, goto error);
6627         isl_assert(list->ctx, list->p[0], goto error);
6628         nparam = isl_basic_set_n_param(list->p[0]);
6629         dim = isl_basic_set_n_dim(list->p[0]);
6630         extra = list->p[0]->n_div;
6631         n_eq = list->p[0]->n_eq;
6632         n_ineq = list->p[0]->n_ineq;
6633         for (i = 1; i < list->n; ++i) {
6634                 isl_assert(list->ctx, list->p[i], goto error);
6635                 isl_assert(list->ctx,
6636                     nparam == isl_basic_set_n_param(list->p[i]), goto error);
6637                 dim += isl_basic_set_n_dim(list->p[i]);
6638                 extra += list->p[i]->n_div;
6639                 n_eq += list->p[i]->n_eq;
6640                 n_ineq += list->p[i]->n_ineq;
6641         }
6642         product = isl_basic_set_alloc(list->ctx, nparam, dim, extra,
6643                                         n_eq, n_ineq);
6644         if (!product)
6645                 goto error;
6646         dim = 0;
6647         for (i = 0; i < list->n; ++i) {
6648                 isl_basic_set_add_constraints(product,
6649                                         isl_basic_set_copy(list->p[i]), dim);
6650                 dim += isl_basic_set_n_dim(list->p[i]);
6651         }
6652         isl_basic_set_list_free(list);
6653         return product;
6654 error:
6655         isl_basic_set_free(product);
6656         isl_basic_set_list_free(list);
6657         return NULL;
6658 }
6659
6660 struct isl_basic_map *isl_basic_map_product(
6661                 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
6662 {
6663         struct isl_dim *dim_result = NULL;
6664         struct isl_basic_map *bmap;
6665         unsigned in1, in2, out1, out2, nparam, total, pos;
6666         struct isl_dim_map *dim_map1, *dim_map2;
6667
6668         if (!bmap1 || !bmap2)
6669                 goto error;
6670
6671         isl_assert(bmap1->ctx, isl_dim_match(bmap1->dim, isl_dim_param,
6672                                      bmap2->dim, isl_dim_param), goto error);
6673         dim_result = isl_dim_product(isl_dim_copy(bmap1->dim),
6674                                                    isl_dim_copy(bmap2->dim));
6675
6676         in1 = isl_basic_map_n_in(bmap1);
6677         in2 = isl_basic_map_n_in(bmap2);
6678         out1 = isl_basic_map_n_out(bmap1);
6679         out2 = isl_basic_map_n_out(bmap2);
6680         nparam = isl_basic_map_n_param(bmap1);
6681
6682         total = nparam + in1 + in2 + out1 + out2 + bmap1->n_div + bmap2->n_div;
6683         dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
6684         dim_map2 = isl_dim_map_alloc(bmap1->ctx, total);
6685         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
6686         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos = 0);
6687         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
6688         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos += in1);
6689         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += in2);
6690         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos += out1);
6691         isl_dim_map_div(dim_map1, bmap1, pos += out2);
6692         isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
6693
6694         bmap = isl_basic_map_alloc_dim(dim_result,
6695                         bmap1->n_div + bmap2->n_div,
6696                         bmap1->n_eq + bmap2->n_eq,
6697                         bmap1->n_ineq + bmap2->n_ineq);
6698         bmap = add_constraints_dim_map(bmap, bmap1, dim_map1);
6699         bmap = add_constraints_dim_map(bmap, bmap2, dim_map2);
6700         bmap = isl_basic_map_simplify(bmap);
6701         return isl_basic_map_finalize(bmap);
6702 error:
6703         isl_basic_map_free(bmap1);
6704         isl_basic_map_free(bmap2);
6705         return NULL;
6706 }
6707
6708 /* Given two maps A -> B and C -> D, construct a map [A -> C] -> [B -> D]
6709  */
6710 struct isl_map *isl_map_product(struct isl_map *map1, struct isl_map *map2)
6711 {
6712         unsigned flags = 0;
6713         struct isl_map *result;
6714         int i, j;
6715
6716         if (!map1 || !map2)
6717                 goto error;
6718
6719         isl_assert(map1->ctx, isl_dim_match(map1->dim, isl_dim_param,
6720                                          map2->dim, isl_dim_param), goto error);
6721
6722         if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) &&
6723             ISL_F_ISSET(map2, ISL_MAP_DISJOINT))
6724                 ISL_FL_SET(flags, ISL_MAP_DISJOINT);
6725
6726         result = isl_map_alloc_dim(isl_dim_product(isl_dim_copy(map1->dim),
6727                                                    isl_dim_copy(map2->dim)),
6728                                 map1->n * map2->n, flags);
6729         if (!result)
6730                 goto error;
6731         for (i = 0; i < map1->n; ++i)
6732                 for (j = 0; j < map2->n; ++j) {
6733                         struct isl_basic_map *part;
6734                         part = isl_basic_map_product(
6735                                     isl_basic_map_copy(map1->p[i]),
6736                                     isl_basic_map_copy(map2->p[j]));
6737                         if (isl_basic_map_is_empty(part))
6738                                 isl_basic_map_free(part);
6739                         else
6740                                 result = isl_map_add_basic_map(result, part);
6741                         if (!result)
6742                                 goto error;
6743                 }
6744         isl_map_free(map1);
6745         isl_map_free(map2);
6746         return result;
6747 error:
6748         isl_map_free(map1);
6749         isl_map_free(map2);
6750         return NULL;
6751 }
6752
6753 /* Given two maps A -> B and C -> D, construct a map (A, C) -> (B, D)
6754  */
6755 __isl_give isl_map *isl_map_flat_product(__isl_take isl_map *map1,
6756         __isl_take isl_map *map2)
6757 {
6758         isl_map *prod;
6759
6760         prod = isl_map_product(map1, map2);
6761         prod = isl_map_flatten(prod);
6762         return prod;
6763 }
6764
6765 /* Given two set A and B, construct its Cartesian product A x B.
6766  */
6767 struct isl_set *isl_set_product(struct isl_set *set1, struct isl_set *set2)
6768 {
6769         return (struct isl_set *)isl_map_product((struct isl_map *)set1,
6770                                                  (struct isl_map *)set2);
6771 }
6772
6773 __isl_give isl_set *isl_set_flat_product(__isl_take isl_set *set1,
6774         __isl_take isl_set *set2)
6775 {
6776         return (isl_set *)isl_map_flat_product((isl_map *)set1, (isl_map *)set2);
6777 }
6778
6779 uint32_t isl_basic_set_get_hash(struct isl_basic_set *bset)
6780 {
6781         int i;
6782         uint32_t hash = isl_hash_init();
6783         unsigned total;
6784
6785         if (!bset)
6786                 return 0;
6787         bset = isl_basic_set_copy(bset);
6788         bset = isl_basic_set_normalize(bset);
6789         if (!bset)
6790                 return 0;
6791         total = isl_basic_set_total_dim(bset);
6792         isl_hash_byte(hash, bset->n_eq & 0xFF);
6793         for (i = 0; i < bset->n_eq; ++i) {
6794                 uint32_t c_hash;
6795                 c_hash = isl_seq_get_hash(bset->eq[i], 1 + total);
6796                 isl_hash_hash(hash, c_hash);
6797         }
6798         isl_hash_byte(hash, bset->n_ineq & 0xFF);
6799         for (i = 0; i < bset->n_ineq; ++i) {
6800                 uint32_t c_hash;
6801                 c_hash = isl_seq_get_hash(bset->ineq[i], 1 + total);
6802                 isl_hash_hash(hash, c_hash);
6803         }
6804         isl_hash_byte(hash, bset->n_div & 0xFF);
6805         for (i = 0; i < bset->n_div; ++i) {
6806                 uint32_t c_hash;
6807                 if (isl_int_is_zero(bset->div[i][0]))
6808                         continue;
6809                 isl_hash_byte(hash, i & 0xFF);
6810                 c_hash = isl_seq_get_hash(bset->div[i], 1 + 1 + total);
6811                 isl_hash_hash(hash, c_hash);
6812         }
6813         isl_basic_set_free(bset);
6814         return hash;
6815 }
6816
6817 uint32_t isl_set_get_hash(struct isl_set *set)
6818 {
6819         int i;
6820         uint32_t hash;
6821
6822         if (!set)
6823                 return 0;
6824         set = isl_set_copy(set);
6825         set = isl_set_normalize(set);
6826         if (!set)
6827                 return 0;
6828
6829         hash = isl_hash_init();
6830         for (i = 0; i < set->n; ++i) {
6831                 uint32_t bset_hash;
6832                 bset_hash = isl_basic_set_get_hash(set->p[i]);
6833                 isl_hash_hash(hash, bset_hash);
6834         }
6835
6836         isl_set_free(set);
6837
6838         return hash;
6839 }
6840
6841 /* Check if the value for dimension dim is completely determined
6842  * by the values of the other parameters and variables.
6843  * That is, check if dimension dim is involved in an equality.
6844  */
6845 int isl_basic_set_dim_is_unique(struct isl_basic_set *bset, unsigned dim)
6846 {
6847         int i;
6848         unsigned nparam;
6849
6850         if (!bset)
6851                 return -1;
6852         nparam = isl_basic_set_n_param(bset);
6853         for (i = 0; i < bset->n_eq; ++i)
6854                 if (!isl_int_is_zero(bset->eq[i][1 + nparam + dim]))
6855                         return 1;
6856         return 0;
6857 }
6858
6859 /* Check if the value for dimension dim is completely determined
6860  * by the values of the other parameters and variables.
6861  * That is, check if dimension dim is involved in an equality
6862  * for each of the subsets.
6863  */
6864 int isl_set_dim_is_unique(struct isl_set *set, unsigned dim)
6865 {
6866         int i;
6867
6868         if (!set)
6869                 return -1;
6870         for (i = 0; i < set->n; ++i) {
6871                 int unique;
6872                 unique = isl_basic_set_dim_is_unique(set->p[i], dim);
6873                 if (unique != 1)
6874                         return unique;
6875         }
6876         return 1;
6877 }
6878
6879 int isl_map_foreach_basic_map(__isl_keep isl_map *map,
6880         int (*fn)(__isl_take isl_basic_map *bmap, void *user), void *user)
6881 {
6882         int i;
6883
6884         if (!map)
6885                 return -1;
6886
6887         for (i = 0; i < map->n; ++i)
6888                 if (fn(isl_basic_map_copy(map->p[i]), user) < 0)
6889                         return -1;
6890
6891         return 0;
6892 }
6893
6894 int isl_set_foreach_basic_set(__isl_keep isl_set *set,
6895         int (*fn)(__isl_take isl_basic_set *bset, void *user), void *user)
6896 {
6897         int i;
6898
6899         if (!set)
6900                 return -1;
6901
6902         for (i = 0; i < set->n; ++i)
6903                 if (fn(isl_basic_set_copy(set->p[i]), user) < 0)
6904                         return -1;
6905
6906         return 0;
6907 }
6908
6909 __isl_give isl_basic_set *isl_basic_set_lift(__isl_take isl_basic_set *bset)
6910 {
6911         struct isl_dim *dim;
6912
6913         if (!bset)
6914                 return NULL;
6915
6916         if (bset->n_div == 0)
6917                 return bset;
6918
6919         bset = isl_basic_set_cow(bset);
6920         if (!bset)
6921                 return NULL;
6922
6923         dim = isl_basic_set_get_dim(bset);
6924         dim = isl_dim_add(dim, isl_dim_set, bset->n_div);
6925         if (!dim)
6926                 goto error;
6927         isl_dim_free(bset->dim);
6928         bset->dim = dim;
6929         bset->n_div = 0;
6930
6931         bset = isl_basic_set_finalize(bset);
6932
6933         return bset;
6934 error:
6935         isl_basic_set_free(bset);
6936         return NULL;
6937 }
6938
6939 __isl_give isl_set *isl_set_lift(__isl_take isl_set *set)
6940 {
6941         int i;
6942         struct isl_dim *dim;
6943         unsigned n_div;
6944
6945         set = isl_set_align_divs(set);
6946
6947         if (!set)
6948                 return NULL;
6949         if (set->n == 0 || set->p[0]->n_div == 0)
6950                 return set;
6951
6952         set = isl_set_cow(set);
6953         if (!set)
6954                 return NULL;
6955
6956         n_div = set->p[0]->n_div;
6957         dim = isl_set_get_dim(set);
6958         dim = isl_dim_add(dim, isl_dim_set, n_div);
6959         if (!dim)
6960                 goto error;
6961         isl_dim_free(set->dim);
6962         set->dim = dim;
6963
6964         for (i = 0; i < set->n; ++i) {
6965                 set->p[i] = isl_basic_set_lift(set->p[i]);
6966                 if (!set->p[i])
6967                         goto error;
6968         }
6969
6970         return set;
6971 error:
6972         isl_set_free(set);
6973         return NULL;
6974 }
6975
6976 __isl_give isl_map *isl_set_lifting(__isl_take isl_set *set)
6977 {
6978         struct isl_dim *dim;
6979         struct isl_basic_map *bmap;
6980         unsigned n_set;
6981         unsigned n_div;
6982         unsigned n_param;
6983         unsigned total;
6984         int i, k, l;
6985
6986         set = isl_set_align_divs(set);
6987
6988         if (!set)
6989                 return NULL;
6990
6991         dim = isl_set_get_dim(set);
6992         if (set->n == 0 || set->p[0]->n_div == 0) {
6993                 isl_set_free(set);
6994                 return isl_map_identity(dim);
6995         }
6996
6997         n_div = set->p[0]->n_div;
6998         dim = isl_dim_map(dim);
6999         n_param = isl_dim_size(dim, isl_dim_param);
7000         n_set = isl_dim_size(dim, isl_dim_in);
7001         dim = isl_dim_extend(dim, n_param, n_set, n_set + n_div);
7002         bmap = isl_basic_map_alloc_dim(dim, 0, n_set, 2 * n_div);
7003         for (i = 0; i < n_set; ++i)
7004                 bmap = var_equal(bmap, i);
7005
7006         total = n_param + n_set + n_set + n_div;
7007         for (i = 0; i < n_div; ++i) {
7008                 k = isl_basic_map_alloc_inequality(bmap);
7009                 if (k < 0)
7010                         goto error;
7011                 isl_seq_cpy(bmap->ineq[k], set->p[0]->div[i]+1, 1+n_param);
7012                 isl_seq_clr(bmap->ineq[k]+1+n_param, n_set);
7013                 isl_seq_cpy(bmap->ineq[k]+1+n_param+n_set,
7014                             set->p[0]->div[i]+1+1+n_param, n_set + n_div);
7015                 isl_int_neg(bmap->ineq[k][1+n_param+n_set+n_set+i],
7016                             set->p[0]->div[i][0]);
7017
7018                 l = isl_basic_map_alloc_inequality(bmap);
7019                 if (l < 0)
7020                         goto error;
7021                 isl_seq_neg(bmap->ineq[l], bmap->ineq[k], 1 + total);
7022                 isl_int_add(bmap->ineq[l][0], bmap->ineq[l][0],
7023                             set->p[0]->div[i][0]);
7024                 isl_int_sub_ui(bmap->ineq[l][0], bmap->ineq[l][0], 1);
7025         }
7026
7027         isl_set_free(set);
7028         return isl_map_from_basic_map(bmap);
7029 error:
7030         isl_set_free(set);
7031         isl_basic_map_free(bmap);
7032         return NULL;
7033 }
7034
7035 int isl_basic_set_size(__isl_keep isl_basic_set *bset)
7036 {
7037         unsigned dim;
7038         int size = 0;
7039
7040         if (!bset)
7041                 return -1;
7042
7043         dim = isl_basic_set_total_dim(bset);
7044         size += bset->n_eq * (1 + dim);
7045         size += bset->n_ineq * (1 + dim);
7046         size += bset->n_div * (2 + dim);
7047
7048         return size;
7049 }
7050
7051 int isl_set_size(__isl_keep isl_set *set)
7052 {
7053         int i;
7054         int size = 0;
7055
7056         if (!set)
7057                 return -1;
7058
7059         for (i = 0; i < set->n; ++i)
7060                 size += isl_basic_set_size(set->p[i]);
7061
7062         return size;
7063 }
7064
7065 int isl_basic_map_dim_is_bounded(__isl_keep isl_basic_map *bmap,
7066         enum isl_dim_type type, unsigned pos)
7067 {
7068         int i;
7069         int lower, upper;
7070
7071         if (!bmap)
7072                 return -1;
7073
7074         isl_assert(bmap->ctx, pos < isl_basic_map_dim(bmap, type), return -1);
7075
7076         pos += isl_basic_map_offset(bmap, type);
7077
7078         for (i = 0; i < bmap->n_eq; ++i)
7079                 if (!isl_int_is_zero(bmap->eq[i][pos]))
7080                         return 1;
7081
7082         lower = upper = 0;
7083         for (i = 0; i < bmap->n_ineq; ++i) {
7084                 int sgn = isl_int_sgn(bmap->ineq[i][pos]);
7085                 if (sgn > 0)
7086                         lower = 1;
7087                 if (sgn < 0)
7088                         upper = 1;
7089         }
7090
7091         return lower && upper;
7092 }
7093
7094 int isl_map_dim_is_bounded(__isl_keep isl_map *map,
7095         enum isl_dim_type type, unsigned pos)
7096 {
7097         int i;
7098
7099         if (!map)
7100                 return -1;
7101
7102         for (i = 0; i < map->n; ++i) {
7103                 int bounded;
7104                 bounded = isl_basic_map_dim_is_bounded(map->p[i], type, pos);
7105                 if (bounded < 0 || !bounded)
7106                         return bounded;
7107         }
7108
7109         return 1;
7110 }
7111
7112 /* Return 1 if the specified dim is involved in both an upper bound
7113  * and a lower bound.
7114  */
7115 int isl_set_dim_is_bounded(__isl_keep isl_set *set,
7116         enum isl_dim_type type, unsigned pos)
7117 {
7118         return isl_map_dim_is_bounded((isl_map *)set, type, pos);
7119 }
7120
7121 /* For each of the "n" variables starting at "first", determine
7122  * the sign of the variable and put the results in the first "n"
7123  * elements of the array "signs".
7124  * Sign
7125  *      1 means that the variable is non-negative
7126  *      -1 means that the variable is non-positive
7127  *      0 means the variable attains both positive and negative values.
7128  */
7129 int isl_basic_set_vars_get_sign(__isl_keep isl_basic_set *bset,
7130         unsigned first, unsigned n, int *signs)
7131 {
7132         isl_vec *bound = NULL;
7133         struct isl_tab *tab = NULL;
7134         struct isl_tab_undo *snap;
7135         int i;
7136
7137         if (!bset || !signs)
7138                 return -1;
7139
7140         bound = isl_vec_alloc(bset->ctx, 1 + isl_basic_set_total_dim(bset));
7141         tab = isl_tab_from_basic_set(bset);
7142         if (!bound || !tab)
7143                 goto error;
7144
7145         isl_seq_clr(bound->el, bound->size);
7146         isl_int_set_si(bound->el[0], -1);
7147
7148         snap = isl_tab_snap(tab);
7149         for (i = 0; i < n; ++i) {
7150                 int empty;
7151
7152                 isl_int_set_si(bound->el[1 + first + i], -1);
7153                 if (isl_tab_add_ineq(tab, bound->el) < 0)
7154                         goto error;
7155                 empty = tab->empty;
7156                 isl_int_set_si(bound->el[1 + first + i], 0);
7157                 if (isl_tab_rollback(tab, snap) < 0)
7158                         goto error;
7159
7160                 if (empty) {
7161                         signs[i] = 1;
7162                         continue;
7163                 }
7164
7165                 isl_int_set_si(bound->el[1 + first + i], 1);
7166                 if (isl_tab_add_ineq(tab, bound->el) < 0)
7167                         goto error;
7168                 empty = tab->empty;
7169                 isl_int_set_si(bound->el[1 + first + i], 0);
7170                 if (isl_tab_rollback(tab, snap) < 0)
7171                         goto error;
7172
7173                 signs[i] = empty ? -1 : 0;
7174         }
7175
7176         isl_tab_free(tab);
7177         isl_vec_free(bound);
7178         return 0;
7179 error:
7180         isl_tab_free(tab);
7181         isl_vec_free(bound);
7182         return -1;
7183 }
7184
7185 int isl_basic_set_dims_get_sign(__isl_keep isl_basic_set *bset,
7186         enum isl_dim_type type, unsigned first, unsigned n, int *signs)
7187 {
7188         if (!bset || !signs)
7189                 return -1;
7190         isl_assert(bset->ctx, first + n <= isl_basic_set_dim(bset, type),
7191                 return -1);
7192
7193         first += pos(bset->dim, type) - 1;
7194         return isl_basic_set_vars_get_sign(bset, first, n, signs);
7195 }
7196
7197 /* Check if the given map is single-valued.
7198  * We simply compute
7199  *
7200  *      M \circ M^-1
7201  *
7202  * and check if the result is a subset of the identity mapping.
7203  */
7204 int isl_map_is_single_valued(__isl_keep isl_map *map)
7205 {
7206         isl_map *test;
7207         isl_map *id;
7208         int sv;
7209
7210         test = isl_map_reverse(isl_map_copy(map));
7211         test = isl_map_apply_range(test, isl_map_copy(map));
7212
7213         id = isl_map_identity(isl_dim_range(isl_map_get_dim(map)));
7214
7215         sv = isl_map_is_subset(test, id);
7216
7217         isl_map_free(test);
7218         isl_map_free(id);
7219
7220         return sv;
7221 }
7222
7223 int isl_map_is_bijective(__isl_keep isl_map *map)
7224 {
7225         int sv;
7226
7227         sv = isl_map_is_single_valued(map);
7228         if (sv < 0 || !sv)
7229                 return sv;
7230
7231         map = isl_map_copy(map);
7232         map = isl_map_reverse(map);
7233         sv = isl_map_is_single_valued(map);
7234         isl_map_free(map);
7235
7236         return sv;
7237 }
7238
7239 int isl_set_is_singleton(__isl_keep isl_set *set)
7240 {
7241         return isl_map_is_single_valued((isl_map *)set);
7242 }
7243
7244 int isl_map_is_translation(__isl_keep isl_map *map)
7245 {
7246         int ok;
7247         isl_set *delta;
7248
7249         delta = isl_map_deltas(isl_map_copy(map));
7250         ok = isl_set_is_singleton(delta);
7251         isl_set_free(delta);
7252
7253         return ok;
7254 }
7255
7256 static int unique(isl_int *p, unsigned pos, unsigned len)
7257 {
7258         if (isl_seq_first_non_zero(p, pos) != -1)
7259                 return 0;
7260         if (isl_seq_first_non_zero(p + pos + 1, len - pos - 1) != -1)
7261                 return 0;
7262         return 1;
7263 }
7264
7265 int isl_basic_set_is_box(__isl_keep isl_basic_set *bset)
7266 {
7267         int i, j;
7268         unsigned nvar;
7269         unsigned ovar;
7270
7271         if (!bset)
7272                 return -1;
7273
7274         if (isl_basic_set_dim(bset, isl_dim_div) != 0)
7275                 return 0;
7276
7277         nvar = isl_basic_set_dim(bset, isl_dim_set);
7278         ovar = isl_dim_offset(bset->dim, isl_dim_set);
7279         for (j = 0; j < nvar; ++j) {
7280                 int lower = 0, upper = 0;
7281                 for (i = 0; i < bset->n_eq; ++i) {
7282                         if (isl_int_is_zero(bset->eq[i][1 + ovar + j]))
7283                                 continue;
7284                         if (!unique(bset->eq[i] + 1 + ovar, j, nvar))
7285                                 return 0;
7286                         break;
7287                 }
7288                 if (i < bset->n_eq)
7289                         continue;
7290                 for (i = 0; i < bset->n_ineq; ++i) {
7291                         if (isl_int_is_zero(bset->ineq[i][1 + ovar + j]))
7292                                 continue;
7293                         if (!unique(bset->ineq[i] + 1 + ovar, j, nvar))
7294                                 return 0;
7295                         if (isl_int_is_pos(bset->ineq[i][1 + ovar + j]))
7296                                 lower = 1;
7297                         else
7298                                 upper = 1;
7299                 }
7300                 if (!lower || !upper)
7301                         return 0;
7302         }
7303
7304         return 1;
7305 }
7306
7307 int isl_set_is_box(__isl_keep isl_set *set)
7308 {
7309         if (!set)
7310                 return -1;
7311         if (set->n != 1)
7312                 return 0;
7313
7314         return isl_basic_set_is_box(set->p[0]);
7315 }
7316
7317 int isl_basic_set_is_wrapping(__isl_keep isl_basic_set *bset)
7318 {
7319         if (!bset)
7320                 return -1;
7321
7322         return isl_dim_is_wrapping(bset->dim);
7323 }
7324
7325 int isl_set_is_wrapping(__isl_keep isl_set *set)
7326 {
7327         if (!set)
7328                 return -1;
7329
7330         return isl_dim_is_wrapping(set->dim);
7331 }
7332
7333 __isl_give isl_basic_set *isl_basic_map_wrap(__isl_take isl_basic_map *bmap)
7334 {
7335         bmap = isl_basic_map_cow(bmap);
7336         if (!bmap)
7337                 return NULL;
7338
7339         bmap->dim = isl_dim_wrap(bmap->dim);
7340         if (!bmap->dim)
7341                 goto error;
7342
7343         bmap = isl_basic_map_finalize(bmap);
7344
7345         return (isl_basic_set *)bmap;
7346 error:
7347         isl_basic_map_free(bmap);
7348         return NULL;
7349 }
7350
7351 __isl_give isl_set *isl_map_wrap(__isl_take isl_map *map)
7352 {
7353         int i;
7354
7355         map = isl_map_cow(map);
7356         if (!map)
7357                 return NULL;
7358
7359         for (i = 0; i < map->n; ++i) {
7360                 map->p[i] = (isl_basic_map *)isl_basic_map_wrap(map->p[i]);
7361                 if (!map->p[i])
7362                         goto error;
7363         }
7364         map->dim = isl_dim_wrap(map->dim);
7365         if (!map->dim)
7366                 goto error;
7367
7368         return (isl_set *)map;
7369 error:
7370         isl_map_free(map);
7371         return NULL;
7372 }
7373
7374 __isl_give isl_basic_map *isl_basic_set_unwrap(__isl_take isl_basic_set *bset)
7375 {
7376         bset = isl_basic_set_cow(bset);
7377         if (!bset)
7378                 return NULL;
7379
7380         bset->dim = isl_dim_unwrap(bset->dim);
7381         if (!bset->dim)
7382                 goto error;
7383
7384         bset = isl_basic_set_finalize(bset);
7385
7386         return (isl_basic_map *)bset;
7387 error:
7388         isl_basic_set_free(bset);
7389         return NULL;
7390 }
7391
7392 __isl_give isl_map *isl_set_unwrap(__isl_take isl_set *set)
7393 {
7394         int i;
7395
7396         if (!set)
7397                 return NULL;
7398
7399         if (!isl_set_is_wrapping(set))
7400                 isl_die(set->ctx, isl_error_invalid, "not a wrapping set",
7401                         goto error);
7402
7403         set = isl_set_cow(set);
7404         if (!set)
7405                 return NULL;
7406
7407         for (i = 0; i < set->n; ++i) {
7408                 set->p[i] = (isl_basic_set *)isl_basic_set_unwrap(set->p[i]);
7409                 if (!set->p[i])
7410                         goto error;
7411         }
7412
7413         set->dim = isl_dim_unwrap(set->dim);
7414         if (!set->dim)
7415                 goto error;
7416
7417         return (isl_map *)set;
7418 error:
7419         isl_set_free(set);
7420         return NULL;
7421 }
7422
7423 __isl_give isl_basic_map *isl_basic_map_reset(__isl_take isl_basic_map *bmap,
7424         enum isl_dim_type type)
7425 {
7426         if (!bmap)
7427                 return NULL;
7428
7429         if (!isl_dim_is_named_or_nested(bmap->dim, type))
7430                 return bmap;
7431
7432         bmap = isl_basic_map_cow(bmap);
7433         if (!bmap)
7434                 return NULL;
7435
7436         bmap->dim = isl_dim_reset(bmap->dim, type);
7437         if (!bmap->dim)
7438                 goto error;
7439
7440         bmap = isl_basic_map_finalize(bmap);
7441
7442         return bmap;
7443 error:
7444         isl_basic_map_free(bmap);
7445         return NULL;
7446 }
7447
7448 __isl_give isl_map *isl_map_reset(__isl_take isl_map *map,
7449         enum isl_dim_type type)
7450 {
7451         int i;
7452
7453         if (!map)
7454                 return NULL;
7455
7456         if (!isl_dim_is_named_or_nested(map->dim, type))
7457                 return map;
7458
7459         map = isl_map_cow(map);
7460         if (!map)
7461                 return NULL;
7462
7463         for (i = 0; i < map->n; ++i) {
7464                 map->p[i] = isl_basic_map_reset(map->p[i], type);
7465                 if (!map->p[i])
7466                         goto error;
7467         }
7468         map->dim = isl_dim_reset(map->dim, type);
7469         if (!map->dim)
7470                 goto error;
7471
7472         return map;
7473 error:
7474         isl_map_free(map);
7475         return NULL;
7476 }
7477
7478 __isl_give isl_basic_map *isl_basic_map_flatten(__isl_take isl_basic_map *bmap)
7479 {
7480         if (!bmap)
7481                 return NULL;
7482
7483         if (!bmap->dim->nested[0] && !bmap->dim->nested[1])
7484                 return bmap;
7485
7486         bmap = isl_basic_map_cow(bmap);
7487         if (!bmap)
7488                 return NULL;
7489
7490         bmap->dim = isl_dim_flatten(bmap->dim);
7491         if (!bmap->dim)
7492                 goto error;
7493
7494         bmap = isl_basic_map_finalize(bmap);
7495
7496         return bmap;
7497 error:
7498         isl_basic_map_free(bmap);
7499         return NULL;
7500 }
7501
7502 __isl_give isl_map *isl_map_flatten(__isl_take isl_map *map)
7503 {
7504         int i;
7505
7506         if (!map)
7507                 return NULL;
7508
7509         if (!map->dim->nested[0] && !map->dim->nested[1])
7510                 return map;
7511
7512         map = isl_map_cow(map);
7513         if (!map)
7514                 return NULL;
7515
7516         for (i = 0; i < map->n; ++i) {
7517                 map->p[i] = isl_basic_map_flatten(map->p[i]);
7518                 if (!map->p[i])
7519                         goto error;
7520         }
7521         map->dim = isl_dim_flatten(map->dim);
7522         if (!map->dim)
7523                 goto error;
7524
7525         return map;
7526 error:
7527         isl_map_free(map);
7528         return NULL;
7529 }
7530
7531 /* Extend the given dim_map with mappings for the divs in bmap.
7532  */
7533 static __isl_give struct isl_dim_map *extend_dim_map(
7534         __isl_keep struct isl_dim_map *dim_map,
7535         __isl_keep isl_basic_map *bmap)
7536 {
7537         int i;
7538         struct isl_dim_map *res;
7539         int offset;
7540
7541         offset = isl_basic_map_offset(bmap, isl_dim_div);
7542
7543         res = isl_dim_map_alloc(bmap->ctx, dim_map->len - 1 + bmap->n_div);
7544         if (!res)
7545                 return NULL;
7546
7547         for (i = 0; i < dim_map->len; ++i)
7548                 res->pos[i] = dim_map->pos[i];
7549         for (i = 0; i < bmap->n_div; ++i)
7550                 res->pos[dim_map->len + i] = offset + i;
7551
7552         return res;
7553 }
7554
7555 /* Extract a dim_map from a reordering.
7556  * We essentially need to reverse the mapping, and add an offset
7557  * of 1 for the constant term.
7558  */
7559 __isl_give struct isl_dim_map *isl_dim_map_from_reordering(
7560         __isl_keep isl_reordering *exp)
7561 {
7562         int i;
7563         struct isl_dim_map *dim_map;
7564
7565         if (!exp)
7566                 return NULL;
7567
7568         dim_map = isl_dim_map_alloc(exp->dim->ctx, isl_dim_total(exp->dim));
7569         if (!dim_map)
7570                 return NULL;
7571
7572         for (i = 0; i < exp->len; ++i)
7573                 dim_map->pos[1 + exp->pos[i]] = 1 + i;
7574
7575         return dim_map;
7576 }
7577
7578 /* Reorder the dimensions of "bmap" according to the given dim_map
7579  * and set the dimension specification to "dim".
7580  */
7581 __isl_give isl_basic_map *isl_basic_map_realign(__isl_take isl_basic_map *bmap,
7582         __isl_take isl_dim *dim, __isl_take struct isl_dim_map *dim_map)
7583 {
7584         isl_basic_map *res;
7585
7586         bmap = isl_basic_map_cow(bmap);
7587         if (!bmap || !dim || !dim_map)
7588                 goto error;
7589
7590         res = isl_basic_map_alloc_dim(dim,
7591                         bmap->n_div, bmap->n_eq, bmap->n_ineq);
7592         res = add_constraints_dim_map(res, bmap, dim_map);
7593         res = isl_basic_map_finalize(res);
7594         return res;
7595 error:
7596         free(dim_map);
7597         isl_basic_map_free(bmap);
7598         isl_dim_free(dim);
7599         return NULL;
7600 }
7601
7602 /* Reorder the dimensions of "map" according to given reordering.
7603  */
7604 __isl_give isl_map *isl_map_realign(__isl_take isl_map *map,
7605         __isl_take isl_reordering *r)
7606 {
7607         int i;
7608         struct isl_dim_map *dim_map;
7609
7610         map = isl_map_cow(map);
7611         dim_map = isl_dim_map_from_reordering(r);
7612         if (!map || !r || !dim_map)
7613                 goto error;
7614
7615         for (i = 0; i < map->n; ++i) {
7616                 struct isl_dim_map *dim_map_i;
7617
7618                 dim_map_i = extend_dim_map(dim_map, map->p[i]);
7619
7620                 map->p[i] = isl_basic_map_realign(map->p[i],
7621                                             isl_dim_copy(r->dim), dim_map_i);
7622
7623                 if (!map->p[i])
7624                         goto error;
7625         }
7626
7627         map = isl_map_reset_dim(map, isl_dim_copy(r->dim));
7628
7629         isl_reordering_free(r);
7630         free(dim_map);
7631         return map;
7632 error:
7633         free(dim_map);
7634         isl_map_free(map);
7635         isl_reordering_free(r);
7636         return NULL;
7637 }
7638
7639 __isl_give isl_set *isl_set_realign(__isl_take isl_set *set,
7640         __isl_take isl_reordering *r)
7641 {
7642         return (isl_set *)isl_map_realign((isl_map *)set, r);
7643 }
7644
7645 __isl_give isl_mat *isl_basic_map_equalities_matrix(
7646                 __isl_keep isl_basic_map *bmap, enum isl_dim_type c1,
7647                 enum isl_dim_type c2, enum isl_dim_type c3,
7648                 enum isl_dim_type c4, enum isl_dim_type c5)
7649 {
7650         enum isl_dim_type c[5] = { c1, c2, c3, c4, c5 };
7651         struct isl_mat *mat;
7652         int i, j, k;
7653         int pos;
7654
7655         if (!bmap)
7656                 return NULL;
7657         mat = isl_mat_alloc(bmap->ctx, bmap->n_eq,
7658                                 isl_basic_map_total_dim(bmap) + 1);
7659         if (!mat)
7660                 return NULL;
7661         for (i = 0; i < bmap->n_eq; ++i)
7662                 for (j = 0, pos = 0; j < 5; ++j) {
7663                         int off = isl_basic_map_offset(bmap, c[j]);
7664                         for (k = 0; k < isl_basic_map_dim(bmap, c[j]); ++k) {
7665                                 isl_int_set(mat->row[i][pos],
7666                                             bmap->eq[i][off + k]);
7667                                 ++pos;
7668                         }
7669                 }
7670
7671         return mat;
7672 }
7673
7674 __isl_give isl_mat *isl_basic_map_inequalities_matrix(
7675                 __isl_keep isl_basic_map *bmap, enum isl_dim_type c1,
7676                 enum isl_dim_type c2, enum isl_dim_type c3,
7677                 enum isl_dim_type c4, enum isl_dim_type c5)
7678 {
7679         enum isl_dim_type c[5] = { c1, c2, c3, c4, c5 };
7680         struct isl_mat *mat;
7681         int i, j, k;
7682         int pos;
7683
7684         if (!bmap)
7685                 return NULL;
7686         mat = isl_mat_alloc(bmap->ctx, bmap->n_ineq,
7687                                 isl_basic_map_total_dim(bmap) + 1);
7688         if (!mat)
7689                 return NULL;
7690         for (i = 0; i < bmap->n_ineq; ++i)
7691                 for (j = 0, pos = 0; j < 5; ++j) {
7692                         int off = isl_basic_map_offset(bmap, c[j]);
7693                         for (k = 0; k < isl_basic_map_dim(bmap, c[j]); ++k) {
7694                                 isl_int_set(mat->row[i][pos],
7695                                             bmap->ineq[i][off + k]);
7696                                 ++pos;
7697                         }
7698                 }
7699
7700         return mat;
7701 }
7702
7703 __isl_give isl_basic_map *isl_basic_map_from_constraint_matrices(
7704         __isl_take isl_dim *dim,
7705         __isl_take isl_mat *eq, __isl_take isl_mat *ineq, enum isl_dim_type c1,
7706         enum isl_dim_type c2, enum isl_dim_type c3,
7707         enum isl_dim_type c4, enum isl_dim_type c5)
7708 {
7709         enum isl_dim_type c[5] = { c1, c2, c3, c4, c5 };
7710         isl_basic_map *bmap;
7711         unsigned total;
7712         unsigned extra;
7713         int i, j, k, l;
7714         int pos;
7715
7716         if (!dim || !eq || !ineq)
7717                 goto error;
7718
7719         if (eq->n_col != ineq->n_col)
7720                 isl_die(dim->ctx, isl_error_invalid,
7721                         "equalities and inequalities matrices should have "
7722                         "same number of columns", goto error);
7723
7724         total = 1 + isl_dim_total(dim);
7725
7726         if (eq->n_col < total)
7727                 isl_die(dim->ctx, isl_error_invalid,
7728                         "number of columns too small", goto error);
7729
7730         extra = eq->n_col - total;
7731
7732         bmap = isl_basic_map_alloc_dim(isl_dim_copy(dim), extra,
7733                                        eq->n_row, ineq->n_row);
7734         if (!bmap)
7735                 goto error;
7736         for (i = 0; i < extra; ++i)
7737                 if (isl_basic_map_alloc_div(bmap) < 0)
7738                         goto error;
7739         for (i = 0; i < eq->n_row; ++i) {
7740                 l = isl_basic_map_alloc_equality(bmap);
7741                 if (l < 0)
7742                         goto error;
7743                 for (j = 0, pos = 0; j < 5; ++j) {
7744                         int off = isl_basic_map_offset(bmap, c[j]);
7745                         for (k = 0; k < isl_basic_map_dim(bmap, c[j]); ++k) {
7746                                 isl_int_set(bmap->eq[l][off + k],
7747                                             eq->row[i][pos]);
7748                                 ++pos;
7749                         }
7750                 }
7751         }
7752         for (i = 0; i < ineq->n_row; ++i) {
7753                 l = isl_basic_map_alloc_inequality(bmap);
7754                 if (l < 0)
7755                         goto error;
7756                 for (j = 0, pos = 0; j < 5; ++j) {
7757                         int off = isl_basic_map_offset(bmap, c[j]);
7758                         for (k = 0; k < isl_basic_map_dim(bmap, c[j]); ++k) {
7759                                 isl_int_set(bmap->ineq[l][off + k],
7760                                             ineq->row[i][pos]);
7761                                 ++pos;
7762                         }
7763                 }
7764         }
7765
7766         isl_dim_free(dim);
7767         isl_mat_free(eq);
7768         isl_mat_free(ineq);
7769
7770         return bmap;
7771 error:
7772         isl_dim_free(dim);
7773         isl_mat_free(eq);
7774         isl_mat_free(ineq);
7775         return NULL;
7776 }
7777
7778 __isl_give isl_basic_set *isl_basic_set_from_constraint_matrices(
7779         __isl_take isl_dim *dim,
7780         __isl_take isl_mat *eq, __isl_take isl_mat *ineq, enum isl_dim_type c1,
7781         enum isl_dim_type c2, enum isl_dim_type c3, enum isl_dim_type c4)
7782 {
7783         return (isl_basic_set*)
7784             isl_basic_map_from_constraint_matrices(dim, eq, ineq,
7785                                                    c1, c2, c3, c4, isl_dim_in);
7786 }