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