isl_map.c

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