isl_map.c

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