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_basic_set *isl_basic_set_move_dims(__isl_take isl_basic_set *bset,
2204         enum isl_dim_type dst_type, unsigned dst_pos,
2205         enum isl_dim_type src_type, unsigned src_pos, unsigned n)
2206 {
2207         return (isl_basic_set *)isl_basic_map_move_dims(
2208                 (isl_basic_map *)bset, dst_type, dst_pos, src_type, src_pos, n);
2209 }
2210
2211 __isl_give isl_set *isl_set_move_dims(__isl_take isl_set *set,
2212         enum isl_dim_type dst_type, unsigned dst_pos,
2213         enum isl_dim_type src_type, unsigned src_pos, unsigned n)
2214 {
2215         if (!set)
2216                 return NULL;
2217         isl_assert(set->ctx, dst_type != isl_dim_in, goto error);
2218         return (isl_set *)isl_map_move_dims((isl_map *)set, dst_type, dst_pos,
2219                                         src_type, src_pos, n);
2220 error:
2221         isl_set_free(set);
2222         return NULL;
2223 }
2224
2225 __isl_give isl_map *isl_map_move_dims(__isl_take isl_map *map,
2226         enum isl_dim_type dst_type, unsigned dst_pos,
2227         enum isl_dim_type src_type, unsigned src_pos, unsigned n)
2228 {
2229         int i;
2230
2231         if (!map)
2232                 return NULL;
2233         if (n == 0)
2234                 return map;
2235
2236         isl_assert(map->ctx, src_pos + n <= isl_map_dim(map, src_type),
2237                 goto error);
2238
2239         if (dst_type == src_type && dst_pos == src_pos)
2240                 return map;
2241
2242         isl_assert(map->ctx, dst_type != src_type, goto error);
2243
2244         map = isl_map_cow(map);
2245         if (!map)
2246                 return NULL;
2247
2248         map->dim = isl_dim_move(map->dim, dst_type, dst_pos, src_type, src_pos, n);
2249         if (!map->dim)
2250                 goto error;
2251
2252         for (i = 0; i < map->n; ++i) {
2253                 map->p[i] = isl_basic_map_move_dims(map->p[i],
2254                                                 dst_type, dst_pos,
2255                                                 src_type, src_pos, n);
2256                 if (!map->p[i])
2257                         goto error;
2258         }
2259
2260         return map;
2261 error:
2262         isl_map_free(map);
2263         return NULL;
2264 }
2265
2266 /* Move the specified dimensions to the last columns right before
2267  * the divs.  Don't change the dimension specification of bmap.
2268  * That's the responsibility of the caller.
2269  */
2270 static __isl_give isl_basic_map *move_last(__isl_take isl_basic_map *bmap,
2271         enum isl_dim_type type, unsigned first, unsigned n)
2272 {
2273         struct isl_dim_map *dim_map;
2274         struct isl_basic_map *res;
2275         enum isl_dim_type t;
2276         unsigned total, off;
2277
2278         if (!bmap)
2279                 return NULL;
2280         if (pos(bmap->dim, type) + first + n == 1 + isl_dim_total(bmap->dim))
2281                 return bmap;
2282
2283         total = isl_basic_map_total_dim(bmap);
2284         dim_map = isl_dim_map_alloc(bmap->ctx, total);
2285
2286         off = 0;
2287         for (t = isl_dim_param; t <= isl_dim_out; ++t) {
2288                 unsigned size = isl_dim_size(bmap->dim, t);
2289                 if (t == type) {
2290                         isl_dim_map_dim_range(dim_map, bmap->dim, t,
2291                                             0, first, off);
2292                         off += first;
2293                         isl_dim_map_dim_range(dim_map, bmap->dim, t,
2294                                             first, n, total - bmap->n_div - n);
2295                         isl_dim_map_dim_range(dim_map, bmap->dim, t,
2296                                             first + n, size - (first + n), off);
2297                         off += size - (first + n);
2298                 } else {
2299                         isl_dim_map_dim(dim_map, bmap->dim, t, off);
2300                         off += size;
2301                 }
2302         }
2303         isl_dim_map_div(dim_map, bmap, off + n);
2304
2305         res = isl_basic_map_alloc_dim(isl_basic_map_get_dim(bmap),
2306                         bmap->n_div, bmap->n_eq, bmap->n_ineq);
2307         res = add_constraints_dim_map(res, bmap, dim_map);
2308         return res;
2309 }
2310
2311 /* Turn the n dimensions of type type, starting at first
2312  * into existentially quantified variables.
2313  */
2314 __isl_give isl_basic_map *isl_basic_map_project_out(
2315                 __isl_take isl_basic_map *bmap,
2316                 enum isl_dim_type type, unsigned first, unsigned n)
2317 {
2318         int i;
2319         size_t row_size;
2320         isl_int **new_div;
2321         isl_int *old;
2322
2323         if (n == 0)
2324                 return bmap;
2325
2326         if (!bmap)
2327                 return NULL;
2328
2329         if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
2330                 return isl_basic_map_remove(bmap, type, first, n);
2331
2332         isl_assert(bmap->ctx, first + n <= isl_basic_map_dim(bmap, type),
2333                         goto error);
2334
2335         bmap = move_last(bmap, type, first, n);
2336         bmap = isl_basic_map_cow(bmap);
2337
2338         row_size = 1 + isl_dim_total(bmap->dim) + bmap->extra;
2339         old = bmap->block2.data;
2340         bmap->block2 = isl_blk_extend(bmap->ctx, bmap->block2,
2341                                         (bmap->extra + n) * (1 + row_size));
2342         if (!bmap->block2.data)
2343                 goto error;
2344         new_div = isl_alloc_array(ctx, isl_int *, bmap->extra + n);
2345         if (!new_div)
2346                 goto error;
2347         for (i = 0; i < n; ++i) {
2348                 new_div[i] = bmap->block2.data +
2349                                 (bmap->extra + i) * (1 + row_size);
2350                 isl_seq_clr(new_div[i], 1 + row_size);
2351         }
2352         for (i = 0; i < bmap->extra; ++i)
2353                 new_div[n + i] = bmap->block2.data + (bmap->div[i] - old);
2354         free(bmap->div);
2355         bmap->div = new_div;
2356         bmap->n_div += n;
2357         bmap->extra += n;
2358
2359         bmap->dim = isl_dim_drop(bmap->dim, type, first, n);
2360         if (!bmap->dim)
2361                 goto error;
2362         bmap = isl_basic_map_simplify(bmap);
2363         bmap = isl_basic_map_drop_redundant_divs(bmap);
2364         return isl_basic_map_finalize(bmap);
2365 error:
2366         isl_basic_map_free(bmap);
2367         return NULL;
2368 }
2369
2370 /* Turn the n dimensions of type type, starting at first
2371  * into existentially quantified variables.
2372  */
2373 struct isl_basic_set *isl_basic_set_project_out(struct isl_basic_set *bset,
2374                 enum isl_dim_type type, unsigned first, unsigned n)
2375 {
2376         return (isl_basic_set *)isl_basic_map_project_out(
2377                         (isl_basic_map *)bset, type, first, n);
2378 }
2379
2380 /* Turn the n dimensions of type type, starting at first
2381  * into existentially quantified variables.
2382  */
2383 __isl_give isl_map *isl_map_project_out(__isl_take isl_map *map,
2384                 enum isl_dim_type type, unsigned first, unsigned n)
2385 {
2386         int i;
2387
2388         if (!map)
2389                 return NULL;
2390
2391         if (n == 0)
2392                 return map;
2393
2394         isl_assert(map->ctx, first + n <= isl_map_dim(map, type), goto error);
2395
2396         map = isl_map_cow(map);
2397         if (!map)
2398                 return NULL;
2399
2400         map->dim = isl_dim_drop(map->dim, type, first, n);
2401         if (!map->dim)
2402                 goto error;
2403
2404         for (i = 0; i < map->n; ++i) {
2405                 map->p[i] = isl_basic_map_project_out(map->p[i], type, first, n);
2406                 if (!map->p[i])
2407                         goto error;
2408         }
2409
2410         return map;
2411 error:
2412         isl_map_free(map);
2413         return map;
2414 }
2415
2416 /* Turn the n dimensions of type type, starting at first
2417  * into existentially quantified variables.
2418  */
2419 __isl_give isl_set *isl_set_project_out(__isl_take isl_set *set,
2420                 enum isl_dim_type type, unsigned first, unsigned n)
2421 {
2422         return (isl_set *)isl_map_project_out((isl_map *)set, type, first, n);
2423 }
2424
2425 static struct isl_basic_map *add_divs(struct isl_basic_map *bmap, unsigned n)
2426 {
2427         int i, j;
2428
2429         for (i = 0; i < n; ++i) {
2430                 j = isl_basic_map_alloc_div(bmap);
2431                 if (j < 0)
2432                         goto error;
2433                 isl_seq_clr(bmap->div[j], 1+1+isl_basic_map_total_dim(bmap));
2434         }
2435         return bmap;
2436 error:
2437         isl_basic_map_free(bmap);
2438         return NULL;
2439 }
2440
2441 struct isl_basic_map *isl_basic_map_apply_range(
2442                 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
2443 {
2444         struct isl_dim *dim_result = NULL;
2445         struct isl_basic_map *bmap;
2446         unsigned n_in, n_out, n, nparam, total, pos;
2447         struct isl_dim_map *dim_map1, *dim_map2;
2448
2449         if (!bmap1 || !bmap2)
2450                 goto error;
2451
2452         dim_result = isl_dim_join(isl_dim_copy(bmap1->dim),
2453                                   isl_dim_copy(bmap2->dim));
2454
2455         n_in = isl_basic_map_n_in(bmap1);
2456         n_out = isl_basic_map_n_out(bmap2);
2457         n = isl_basic_map_n_out(bmap1);
2458         nparam = isl_basic_map_n_param(bmap1);
2459
2460         total = nparam + n_in + n_out + bmap1->n_div + bmap2->n_div + n;
2461         dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
2462         dim_map2 = isl_dim_map_alloc(bmap1->ctx, total);
2463         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
2464         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos = 0);
2465         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
2466         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos += n_in);
2467         isl_dim_map_div(dim_map1, bmap1, pos += n_out);
2468         isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
2469         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += bmap2->n_div);
2470         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos);
2471
2472         bmap = isl_basic_map_alloc_dim(dim_result,
2473                         bmap1->n_div + bmap2->n_div + n,
2474                         bmap1->n_eq + bmap2->n_eq,
2475                         bmap1->n_ineq + bmap2->n_ineq);
2476         bmap = add_constraints_dim_map(bmap, bmap1, dim_map1);
2477         bmap = add_constraints_dim_map(bmap, bmap2, dim_map2);
2478         bmap = add_divs(bmap, n);
2479         bmap = isl_basic_map_simplify(bmap);
2480         bmap = isl_basic_map_drop_redundant_divs(bmap);
2481         return isl_basic_map_finalize(bmap);
2482 error:
2483         isl_basic_map_free(bmap1);
2484         isl_basic_map_free(bmap2);
2485         return NULL;
2486 }
2487
2488 struct isl_basic_set *isl_basic_set_apply(
2489                 struct isl_basic_set *bset, struct isl_basic_map *bmap)
2490 {
2491         if (!bset || !bmap)
2492                 goto error;
2493
2494         isl_assert(bset->ctx, isl_basic_map_compatible_domain(bmap, bset),
2495                     goto error);
2496
2497         return (struct isl_basic_set *)
2498                 isl_basic_map_apply_range((struct isl_basic_map *)bset, bmap);
2499 error:
2500         isl_basic_set_free(bset);
2501         isl_basic_map_free(bmap);
2502         return NULL;
2503 }
2504
2505 struct isl_basic_map *isl_basic_map_apply_domain(
2506                 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
2507 {
2508         if (!bmap1 || !bmap2)
2509                 goto error;
2510
2511         isl_assert(bmap1->ctx,
2512             isl_basic_map_n_in(bmap1) == isl_basic_map_n_in(bmap2), goto error);
2513         isl_assert(bmap1->ctx,
2514             isl_basic_map_n_param(bmap1) == isl_basic_map_n_param(bmap2),
2515             goto error);
2516
2517         bmap1 = isl_basic_map_reverse(bmap1);
2518         bmap1 = isl_basic_map_apply_range(bmap1, bmap2);
2519         return isl_basic_map_reverse(bmap1);
2520 error:
2521         isl_basic_map_free(bmap1);
2522         isl_basic_map_free(bmap2);
2523         return NULL;
2524 }
2525
2526 /* Given two basic maps A -> f(A) and B -> g(B), construct a basic map
2527  * A \cap B -> f(A) + f(B)
2528  */
2529 struct isl_basic_map *isl_basic_map_sum(
2530                 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
2531 {
2532         unsigned n_in, n_out, nparam, total, pos;
2533         struct isl_basic_map *bmap = NULL;
2534         struct isl_dim_map *dim_map1, *dim_map2;
2535         int i;
2536
2537         if (!bmap1 || !bmap2)
2538                 goto error;
2539
2540         isl_assert(bmap1->ctx, isl_dim_equal(bmap1->dim, bmap2->dim),
2541                 goto error);
2542
2543         nparam = isl_basic_map_n_param(bmap1);
2544         n_in = isl_basic_map_n_in(bmap1);
2545         n_out = isl_basic_map_n_out(bmap1);
2546
2547         total = nparam + n_in + n_out + bmap1->n_div + bmap2->n_div + 2 * n_out;
2548         dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
2549         dim_map2 = isl_dim_map_alloc(bmap2->ctx, total);
2550         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
2551         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos);
2552         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
2553         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos);
2554         isl_dim_map_div(dim_map1, bmap1, pos += n_in + n_out);
2555         isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
2556         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += bmap2->n_div);
2557         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos += n_out);
2558
2559         bmap = isl_basic_map_alloc_dim(isl_dim_copy(bmap1->dim),
2560                         bmap1->n_div + bmap2->n_div + 2 * n_out,
2561                         bmap1->n_eq + bmap2->n_eq + n_out,
2562                         bmap1->n_ineq + bmap2->n_ineq);
2563         for (i = 0; i < n_out; ++i) {
2564                 int j = isl_basic_map_alloc_equality(bmap);
2565                 if (j < 0)
2566                         goto error;
2567                 isl_seq_clr(bmap->eq[j], 1+total);
2568                 isl_int_set_si(bmap->eq[j][1+nparam+n_in+i], -1);
2569                 isl_int_set_si(bmap->eq[j][1+pos+i], 1);
2570                 isl_int_set_si(bmap->eq[j][1+pos-n_out+i], 1);
2571         }
2572         bmap = add_constraints_dim_map(bmap, bmap1, dim_map1);
2573         bmap = add_constraints_dim_map(bmap, bmap2, dim_map2);
2574         bmap = add_divs(bmap, 2 * n_out);
2575
2576         bmap = isl_basic_map_simplify(bmap);
2577         return isl_basic_map_finalize(bmap);
2578 error:
2579         isl_basic_map_free(bmap);
2580         isl_basic_map_free(bmap1);
2581         isl_basic_map_free(bmap2);
2582         return NULL;
2583 }
2584
2585 /* Given two maps A -> f(A) and B -> g(B), construct a map
2586  * A \cap B -> f(A) + f(B)
2587  */
2588 struct isl_map *isl_map_sum(struct isl_map *map1, struct isl_map *map2)
2589 {
2590         struct isl_map *result;
2591         int i, j;
2592
2593         if (!map1 || !map2)
2594                 goto error;
2595
2596         isl_assert(map1->ctx, isl_dim_equal(map1->dim, map2->dim), goto error);
2597
2598         result = isl_map_alloc_dim(isl_dim_copy(map1->dim),
2599                                 map1->n * map2->n, 0);
2600         if (!result)
2601                 goto error;
2602         for (i = 0; i < map1->n; ++i)
2603                 for (j = 0; j < map2->n; ++j) {
2604                         struct isl_basic_map *part;
2605                         part = isl_basic_map_sum(
2606                                     isl_basic_map_copy(map1->p[i]),
2607                                     isl_basic_map_copy(map2->p[j]));
2608                         if (isl_basic_map_is_empty(part))
2609                                 isl_basic_map_free(part);
2610                         else
2611                                 result = isl_map_add_basic_map(result, part);
2612                         if (!result)
2613                                 goto error;
2614                 }
2615         isl_map_free(map1);
2616         isl_map_free(map2);
2617         return result;
2618 error:
2619         isl_map_free(map1);
2620         isl_map_free(map2);
2621         return NULL;
2622 }
2623
2624 __isl_give isl_set *isl_set_sum(__isl_take isl_set *set1,
2625         __isl_take isl_set *set2)
2626 {
2627         return (isl_set *)isl_map_sum((isl_map *)set1, (isl_map *)set2);
2628 }
2629
2630 /* Given a basic map A -> f(A), construct A -> -f(A).
2631  */
2632 struct isl_basic_map *isl_basic_map_neg(struct isl_basic_map *bmap)
2633 {
2634         int i, j;
2635         unsigned off, n;
2636
2637         bmap = isl_basic_map_cow(bmap);
2638         if (!bmap)
2639                 return NULL;
2640
2641         n = isl_basic_map_dim(bmap, isl_dim_out);
2642         off = isl_basic_map_offset(bmap, isl_dim_out);
2643         for (i = 0; i < bmap->n_eq; ++i)
2644                 for (j = 0; j < n; ++j)
2645                         isl_int_neg(bmap->eq[i][off+j], bmap->eq[i][off+j]);
2646         for (i = 0; i < bmap->n_ineq; ++i)
2647                 for (j = 0; j < n; ++j)
2648                         isl_int_neg(bmap->ineq[i][off+j], bmap->ineq[i][off+j]);
2649         for (i = 0; i < bmap->n_div; ++i)
2650                 for (j = 0; j < n; ++j)
2651                         isl_int_neg(bmap->div[i][1+off+j], bmap->div[i][1+off+j]);
2652         return isl_basic_map_finalize(bmap);
2653 }
2654
2655 /* Given a map A -> f(A), construct A -> -f(A).
2656  */
2657 struct isl_map *isl_map_neg(struct isl_map *map)
2658 {
2659         int i;
2660
2661         map = isl_map_cow(map);
2662         if (!map)
2663                 return NULL;
2664
2665         for (i = 0; i < map->n; ++i) {
2666                 map->p[i] = isl_basic_map_neg(map->p[i]);
2667                 if (!map->p[i])
2668                         goto error;
2669         }
2670
2671         return map;
2672 error:
2673         isl_map_free(map);
2674         return NULL;
2675 }
2676
2677 __isl_give isl_set *isl_set_neg(__isl_take isl_set *set)
2678 {
2679         return (isl_set *)isl_map_neg((isl_map *)set);
2680 }
2681
2682 /* Given a basic map A -> f(A) and an integer d, construct a basic map
2683  * A -> floor(f(A)/d).
2684  */
2685 struct isl_basic_map *isl_basic_map_floordiv(struct isl_basic_map *bmap,
2686                 isl_int d)
2687 {
2688         unsigned n_in, n_out, nparam, total, pos;
2689         struct isl_basic_map *result = NULL;
2690         struct isl_dim_map *dim_map;
2691         int i;
2692
2693         if (!bmap)
2694                 return NULL;
2695
2696         nparam = isl_basic_map_n_param(bmap);
2697         n_in = isl_basic_map_n_in(bmap);
2698         n_out = isl_basic_map_n_out(bmap);
2699
2700         total = nparam + n_in + n_out + bmap->n_div + n_out;
2701         dim_map = isl_dim_map_alloc(bmap->ctx, total);
2702         isl_dim_map_dim(dim_map, bmap->dim, isl_dim_param, pos = 0);
2703         isl_dim_map_dim(dim_map, bmap->dim, isl_dim_in, pos += nparam);
2704         isl_dim_map_div(dim_map, bmap, pos += n_in + n_out);
2705         isl_dim_map_dim(dim_map, bmap->dim, isl_dim_out, pos += bmap->n_div);
2706
2707         result = isl_basic_map_alloc_dim(isl_dim_copy(bmap->dim),
2708                         bmap->n_div + n_out,
2709                         bmap->n_eq, bmap->n_ineq + 2 * n_out);
2710         result = add_constraints_dim_map(result, bmap, dim_map);
2711         result = add_divs(result, n_out);
2712         for (i = 0; i < n_out; ++i) {
2713                 int j;
2714                 j = isl_basic_map_alloc_inequality(result);
2715                 if (j < 0)
2716                         goto error;
2717                 isl_seq_clr(result->ineq[j], 1+total);
2718                 isl_int_neg(result->ineq[j][1+nparam+n_in+i], d);
2719                 isl_int_set_si(result->ineq[j][1+pos+i], 1);
2720                 j = isl_basic_map_alloc_inequality(result);
2721                 if (j < 0)
2722                         goto error;
2723                 isl_seq_clr(result->ineq[j], 1+total);
2724                 isl_int_set(result->ineq[j][1+nparam+n_in+i], d);
2725                 isl_int_set_si(result->ineq[j][1+pos+i], -1);
2726                 isl_int_sub_ui(result->ineq[j][0], d, 1);
2727         }
2728
2729         result = isl_basic_map_simplify(result);
2730         return isl_basic_map_finalize(result);
2731 error:
2732         isl_basic_map_free(result);
2733         return NULL;
2734 }
2735
2736 /* Given a map A -> f(A) and an integer d, construct a map
2737  * A -> floor(f(A)/d).
2738  */
2739 struct isl_map *isl_map_floordiv(struct isl_map *map, isl_int d)
2740 {
2741         int i;
2742
2743         map = isl_map_cow(map);
2744         if (!map)
2745                 return NULL;
2746
2747         ISL_F_CLR(map, ISL_MAP_DISJOINT);
2748         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
2749         for (i = 0; i < map->n; ++i) {
2750                 map->p[i] = isl_basic_map_floordiv(map->p[i], d);
2751                 if (!map->p[i])
2752                         goto error;
2753         }
2754
2755         return map;
2756 error:
2757         isl_map_free(map);
2758         return NULL;
2759 }
2760
2761 static struct isl_basic_map *var_equal(struct isl_basic_map *bmap, unsigned pos)
2762 {
2763         int i;
2764         unsigned nparam;
2765         unsigned n_in;
2766
2767         i = isl_basic_map_alloc_equality(bmap);
2768         if (i < 0)
2769                 goto error;
2770         nparam = isl_basic_map_n_param(bmap);
2771         n_in = isl_basic_map_n_in(bmap);
2772         isl_seq_clr(bmap->eq[i], 1 + isl_basic_map_total_dim(bmap));
2773         isl_int_set_si(bmap->eq[i][1+nparam+pos], -1);
2774         isl_int_set_si(bmap->eq[i][1+nparam+n_in+pos], 1);
2775         return isl_basic_map_finalize(bmap);
2776 error:
2777         isl_basic_map_free(bmap);
2778         return NULL;
2779 }
2780
2781 /* Add a constraints to "bmap" expressing i_pos < o_pos
2782  */
2783 static struct isl_basic_map *var_less(struct isl_basic_map *bmap, unsigned pos)
2784 {
2785         int i;
2786         unsigned nparam;
2787         unsigned n_in;
2788
2789         i = isl_basic_map_alloc_inequality(bmap);
2790         if (i < 0)
2791                 goto error;
2792         nparam = isl_basic_map_n_param(bmap);
2793         n_in = isl_basic_map_n_in(bmap);
2794         isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap));
2795         isl_int_set_si(bmap->ineq[i][0], -1);
2796         isl_int_set_si(bmap->ineq[i][1+nparam+pos], -1);
2797         isl_int_set_si(bmap->ineq[i][1+nparam+n_in+pos], 1);
2798         return isl_basic_map_finalize(bmap);
2799 error:
2800         isl_basic_map_free(bmap);
2801         return NULL;
2802 }
2803
2804 /* Add a constraint to "bmap" expressing i_pos <= o_pos
2805  */
2806 static __isl_give isl_basic_map *var_less_or_equal(
2807         __isl_take isl_basic_map *bmap, unsigned pos)
2808 {
2809         int i;
2810         unsigned nparam;
2811         unsigned n_in;
2812
2813         i = isl_basic_map_alloc_inequality(bmap);
2814         if (i < 0)
2815                 goto error;
2816         nparam = isl_basic_map_n_param(bmap);
2817         n_in = isl_basic_map_n_in(bmap);
2818         isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap));
2819         isl_int_set_si(bmap->ineq[i][1+nparam+pos], -1);
2820         isl_int_set_si(bmap->ineq[i][1+nparam+n_in+pos], 1);
2821         return isl_basic_map_finalize(bmap);
2822 error:
2823         isl_basic_map_free(bmap);
2824         return NULL;
2825 }
2826
2827 /* Add a constraints to "bmap" expressing i_pos > o_pos
2828  */
2829 static struct isl_basic_map *var_more(struct isl_basic_map *bmap, unsigned pos)
2830 {
2831         int i;
2832         unsigned nparam;
2833         unsigned n_in;
2834
2835         i = isl_basic_map_alloc_inequality(bmap);
2836         if (i < 0)
2837                 goto error;
2838         nparam = isl_basic_map_n_param(bmap);
2839         n_in = isl_basic_map_n_in(bmap);
2840         isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap));
2841         isl_int_set_si(bmap->ineq[i][0], -1);
2842         isl_int_set_si(bmap->ineq[i][1+nparam+pos], 1);
2843         isl_int_set_si(bmap->ineq[i][1+nparam+n_in+pos], -1);
2844         return isl_basic_map_finalize(bmap);
2845 error:
2846         isl_basic_map_free(bmap);
2847         return NULL;
2848 }
2849
2850 /* Add a constraint to "bmap" expressing i_pos >= o_pos
2851  */
2852 static __isl_give isl_basic_map *var_more_or_equal(
2853         __isl_take isl_basic_map *bmap, unsigned pos)
2854 {
2855         int i;
2856         unsigned nparam;
2857         unsigned n_in;
2858
2859         i = isl_basic_map_alloc_inequality(bmap);
2860         if (i < 0)
2861                 goto error;
2862         nparam = isl_basic_map_n_param(bmap);
2863         n_in = isl_basic_map_n_in(bmap);
2864         isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap));
2865         isl_int_set_si(bmap->ineq[i][1+nparam+pos], 1);
2866         isl_int_set_si(bmap->ineq[i][1+nparam+n_in+pos], -1);
2867         return isl_basic_map_finalize(bmap);
2868 error:
2869         isl_basic_map_free(bmap);
2870         return NULL;
2871 }
2872
2873 struct isl_basic_map *isl_basic_map_equal(struct isl_dim *dim, unsigned n_equal)
2874 {
2875         int i;
2876         struct isl_basic_map *bmap;
2877         bmap = isl_basic_map_alloc_dim(dim, 0, n_equal, 0);
2878         if (!bmap)
2879                 return NULL;
2880         for (i = 0; i < n_equal && bmap; ++i)
2881                 bmap = var_equal(bmap, i);
2882         return isl_basic_map_finalize(bmap);
2883 }
2884
2885 /* Return a relation on of dimension "dim" expressing i_[0..pos] << o_[0..pos]
2886  */
2887 struct isl_basic_map *isl_basic_map_less_at(struct isl_dim *dim, unsigned pos)
2888 {
2889         int i;
2890         struct isl_basic_map *bmap;
2891         bmap = isl_basic_map_alloc_dim(dim, 0, pos, 1);
2892         if (!bmap)
2893                 return NULL;
2894         for (i = 0; i < pos && bmap; ++i)
2895                 bmap = var_equal(bmap, i);
2896         if (bmap)
2897                 bmap = var_less(bmap, pos);
2898         return isl_basic_map_finalize(bmap);
2899 }
2900
2901 /* Return a relation on of dimension "dim" expressing i_[0..pos] <<= o_[0..pos]
2902  */
2903 __isl_give isl_basic_map *isl_basic_map_less_or_equal_at(
2904         __isl_take isl_dim *dim, unsigned pos)
2905 {
2906         int i;
2907         isl_basic_map *bmap;
2908
2909         bmap = isl_basic_map_alloc_dim(dim, 0, pos, 1);
2910         for (i = 0; i < pos; ++i)
2911                 bmap = var_equal(bmap, i);
2912         bmap = var_less_or_equal(bmap, pos);
2913         return isl_basic_map_finalize(bmap);
2914 }
2915
2916 /* Return a relation on pairs of sets of dimension "dim" expressing i_pos > o_pos
2917  */
2918 struct isl_basic_map *isl_basic_map_more_at(struct isl_dim *dim, unsigned pos)
2919 {
2920         int i;
2921         struct isl_basic_map *bmap;
2922         bmap = isl_basic_map_alloc_dim(dim, 0, pos, 1);
2923         if (!bmap)
2924                 return NULL;
2925         for (i = 0; i < pos && bmap; ++i)
2926                 bmap = var_equal(bmap, i);
2927         if (bmap)
2928                 bmap = var_more(bmap, pos);
2929         return isl_basic_map_finalize(bmap);
2930 }
2931
2932 /* Return a relation on of dimension "dim" expressing i_[0..pos] >>= o_[0..pos]
2933  */
2934 __isl_give isl_basic_map *isl_basic_map_more_or_equal_at(
2935         __isl_take isl_dim *dim, unsigned pos)
2936 {
2937         int i;
2938         isl_basic_map *bmap;
2939
2940         bmap = isl_basic_map_alloc_dim(dim, 0, pos, 1);
2941         for (i = 0; i < pos; ++i)
2942                 bmap = var_equal(bmap, i);
2943         bmap = var_more_or_equal(bmap, pos);
2944         return isl_basic_map_finalize(bmap);
2945 }
2946
2947 static __isl_give isl_map *map_lex_lte_first(__isl_take isl_dim *dims,
2948         unsigned n, int equal)
2949 {
2950         struct isl_map *map;
2951         int i;
2952
2953         map = isl_map_alloc_dim(isl_dim_copy(dims), n, ISL_MAP_DISJOINT);
2954
2955         for (i = 0; i + 1 < n; ++i)
2956                 map = isl_map_add_basic_map(map,
2957                                   isl_basic_map_less_at(isl_dim_copy(dims), i));
2958         if (n > 0) {
2959                 if (equal)
2960                         map = isl_map_add_basic_map(map,
2961                               isl_basic_map_less_or_equal_at(dims, n - 1));
2962                 else
2963                         map = isl_map_add_basic_map(map,
2964                               isl_basic_map_less_at(dims, n - 1));
2965         } else
2966                 isl_dim_free(dims);
2967
2968         return map;
2969 }
2970
2971 static __isl_give isl_map *map_lex_lte(__isl_take isl_dim *dims, int equal)
2972 {
2973         if (!dims)
2974                 return NULL;
2975         return map_lex_lte_first(dims, dims->n_out, equal);
2976 }
2977
2978 __isl_give isl_map *isl_map_lex_lt_first(__isl_take isl_dim *dim, unsigned n)
2979 {
2980         return map_lex_lte_first(dim, n, 0);
2981 }
2982
2983 __isl_give isl_map *isl_map_lex_le_first(__isl_take isl_dim *dim, unsigned n)
2984 {
2985         return map_lex_lte_first(dim, n, 1);
2986 }
2987
2988 __isl_give isl_map *isl_map_lex_lt(__isl_take isl_dim *set_dim)
2989 {
2990         return map_lex_lte(isl_dim_map(set_dim), 0);
2991 }
2992
2993 __isl_give isl_map *isl_map_lex_le(__isl_take isl_dim *set_dim)
2994 {
2995         return map_lex_lte(isl_dim_map(set_dim), 1);
2996 }
2997
2998 static __isl_give isl_map *map_lex_gte_first(__isl_take isl_dim *dims,
2999         unsigned n, int equal)
3000 {
3001         struct isl_map *map;
3002         int i;
3003
3004         map = isl_map_alloc_dim(isl_dim_copy(dims), n, ISL_MAP_DISJOINT);
3005
3006         for (i = 0; i + 1 < n; ++i)
3007                 map = isl_map_add_basic_map(map,
3008                                   isl_basic_map_more_at(isl_dim_copy(dims), i));
3009         if (n > 0) {
3010                 if (equal)
3011                         map = isl_map_add_basic_map(map,
3012                               isl_basic_map_more_or_equal_at(dims, n - 1));
3013                 else
3014                         map = isl_map_add_basic_map(map,
3015                               isl_basic_map_more_at(dims, n - 1));
3016         } else
3017                 isl_dim_free(dims);
3018
3019         return map;
3020 }
3021
3022 static __isl_give isl_map *map_lex_gte(__isl_take isl_dim *dims, int equal)
3023 {
3024         if (!dims)
3025                 return NULL;
3026         return map_lex_gte_first(dims, dims->n_out, equal);
3027 }
3028
3029 __isl_give isl_map *isl_map_lex_gt_first(__isl_take isl_dim *dim, unsigned n)
3030 {
3031         return map_lex_gte_first(dim, n, 0);
3032 }
3033
3034 __isl_give isl_map *isl_map_lex_ge_first(__isl_take isl_dim *dim, unsigned n)
3035 {
3036         return map_lex_gte_first(dim, n, 1);
3037 }
3038
3039 __isl_give isl_map *isl_map_lex_gt(__isl_take isl_dim *set_dim)
3040 {
3041         return map_lex_gte(isl_dim_map(set_dim), 0);
3042 }
3043
3044 __isl_give isl_map *isl_map_lex_ge(__isl_take isl_dim *set_dim)
3045 {
3046         return map_lex_gte(isl_dim_map(set_dim), 1);
3047 }
3048
3049 struct isl_basic_map *isl_basic_map_from_basic_set(
3050                 struct isl_basic_set *bset, struct isl_dim *dim)
3051 {
3052         struct isl_basic_map *bmap;
3053
3054         bset = isl_basic_set_cow(bset);
3055         if (!bset || !dim)
3056                 goto error;
3057
3058         isl_assert(bset->ctx, isl_dim_compatible(bset->dim, dim), goto error);
3059         isl_dim_free(bset->dim);
3060         bmap = (struct isl_basic_map *) bset;
3061         bmap->dim = dim;
3062         return isl_basic_map_finalize(bmap);
3063 error:
3064         isl_basic_set_free(bset);
3065         isl_dim_free(dim);
3066         return NULL;
3067 }
3068
3069 struct isl_basic_set *isl_basic_set_from_basic_map(struct isl_basic_map *bmap)
3070 {
3071         if (!bmap)
3072                 goto error;
3073         if (bmap->dim->n_in == 0)
3074                 return (struct isl_basic_set *)bmap;
3075         bmap = isl_basic_map_cow(bmap);
3076         if (!bmap)
3077                 goto error;
3078         bmap->dim = isl_dim_cow(bmap->dim);
3079         if (!bmap->dim)
3080                 goto error;
3081         bmap->dim->n_out += bmap->dim->n_in;
3082         bmap->dim->n_in = 0;
3083         bmap = isl_basic_map_finalize(bmap);
3084         return (struct isl_basic_set *)bmap;
3085 error:
3086         isl_basic_map_free(bmap);
3087         return NULL;
3088 }
3089
3090 /* For a div d = floor(f/m), add the constraints
3091  *
3092  *              f - m d >= 0
3093  *              -(f-(n-1)) + m d >= 0
3094  *
3095  * Note that the second constraint is the negation of
3096  *
3097  *              f - m d >= n
3098  */
3099 int isl_basic_map_add_div_constraints_var(__isl_keep isl_basic_map *bmap,
3100         unsigned pos, isl_int *div)
3101 {
3102         int i, j;
3103         unsigned total = isl_basic_map_total_dim(bmap);
3104
3105         i = isl_basic_map_alloc_inequality(bmap);
3106         if (i < 0)
3107                 return -1;
3108         isl_seq_cpy(bmap->ineq[i], div + 1, 1 + total);
3109         isl_int_neg(bmap->ineq[i][1 + pos], div[0]);
3110
3111         j = isl_basic_map_alloc_inequality(bmap);
3112         if (j < 0)
3113                 return -1;
3114         isl_seq_neg(bmap->ineq[j], bmap->ineq[i], 1 + total);
3115         isl_int_add(bmap->ineq[j][0], bmap->ineq[j][0], bmap->ineq[j][1 + pos]);
3116         isl_int_sub_ui(bmap->ineq[j][0], bmap->ineq[j][0], 1);
3117         return j;
3118 }
3119
3120 int isl_basic_set_add_div_constraints_var(__isl_keep isl_basic_set *bset,
3121         unsigned pos, isl_int *div)
3122 {
3123         return isl_basic_map_add_div_constraints_var((isl_basic_map *)bset,
3124                                                         pos, div);
3125 }
3126
3127 int isl_basic_map_add_div_constraints(struct isl_basic_map *bmap, unsigned div)
3128 {
3129         unsigned total = isl_basic_map_total_dim(bmap);
3130         unsigned div_pos = total - bmap->n_div + div;
3131
3132         return isl_basic_map_add_div_constraints_var(bmap, div_pos,
3133                                                         bmap->div[div]);
3134 }
3135
3136 struct isl_basic_set *isl_basic_map_underlying_set(
3137                 struct isl_basic_map *bmap)
3138 {
3139         if (!bmap)
3140                 goto error;
3141         if (bmap->dim->nparam == 0 && bmap->dim->n_in == 0 && bmap->n_div == 0)
3142                 return (struct isl_basic_set *)bmap;
3143         bmap = isl_basic_map_cow(bmap);
3144         if (!bmap)
3145                 goto error;
3146         bmap->dim = isl_dim_underlying(bmap->dim, bmap->n_div);
3147         if (!bmap->dim)
3148                 goto error;
3149         bmap->extra -= bmap->n_div;
3150         bmap->n_div = 0;
3151         bmap = isl_basic_map_finalize(bmap);
3152         return (struct isl_basic_set *)bmap;
3153 error:
3154         return NULL;
3155 }
3156
3157 __isl_give isl_basic_set *isl_basic_set_underlying_set(
3158                 __isl_take isl_basic_set *bset)
3159 {
3160         return isl_basic_map_underlying_set((isl_basic_map *)bset);
3161 }
3162
3163 struct isl_basic_map *isl_basic_map_overlying_set(
3164         struct isl_basic_set *bset, struct isl_basic_map *like)
3165 {
3166         struct isl_basic_map *bmap;
3167         struct isl_ctx *ctx;
3168         unsigned total;
3169         int i;
3170
3171         if (!bset || !like)
3172                 goto error;
3173         ctx = bset->ctx;
3174         isl_assert(ctx, bset->n_div == 0, goto error);
3175         isl_assert(ctx, isl_basic_set_n_param(bset) == 0, goto error);
3176         isl_assert(ctx, bset->dim->n_out == isl_basic_map_total_dim(like),
3177                         goto error);
3178         if (isl_dim_equal(bset->dim, like->dim) && like->n_div == 0) {
3179                 isl_basic_map_free(like);
3180                 return (struct isl_basic_map *)bset;
3181         }
3182         bset = isl_basic_set_cow(bset);
3183         if (!bset)
3184                 goto error;
3185         total = bset->dim->n_out + bset->extra;
3186         bmap = (struct isl_basic_map *)bset;
3187         isl_dim_free(bmap->dim);
3188         bmap->dim = isl_dim_copy(like->dim);
3189         if (!bmap->dim)
3190                 goto error;
3191         bmap->n_div = like->n_div;
3192         bmap->extra += like->n_div;
3193         if (bmap->extra) {
3194                 unsigned ltotal;
3195                 ltotal = total - bmap->extra + like->extra;
3196                 if (ltotal > total)
3197                         ltotal = total;
3198                 bmap->block2 = isl_blk_extend(ctx, bmap->block2,
3199                                         bmap->extra * (1 + 1 + total));
3200                 if (isl_blk_is_error(bmap->block2))
3201                         goto error;
3202                 bmap->div = isl_realloc_array(ctx, bmap->div, isl_int *,
3203                                                 bmap->extra);
3204                 if (!bmap->div)
3205                         goto error;
3206                 for (i = 0; i < bmap->extra; ++i)
3207                         bmap->div[i] = bmap->block2.data + i * (1 + 1 + total);
3208                 for (i = 0; i < like->n_div; ++i) {
3209                         isl_seq_cpy(bmap->div[i], like->div[i], 1 + 1 + ltotal);
3210                         isl_seq_clr(bmap->div[i]+1+1+ltotal, total - ltotal);
3211                 }
3212                 bmap = isl_basic_map_extend_constraints(bmap,
3213                                                         0, 2 * like->n_div);
3214                 for (i = 0; i < like->n_div; ++i) {
3215                         if (isl_int_is_zero(bmap->div[i][0]))
3216                                 continue;
3217                         if (isl_basic_map_add_div_constraints(bmap, i) < 0)
3218                                 goto error;
3219                 }
3220         }
3221         isl_basic_map_free(like);
3222         bmap = isl_basic_map_simplify(bmap);
3223         bmap = isl_basic_map_finalize(bmap);
3224         return bmap;
3225 error:
3226         isl_basic_map_free(like);
3227         isl_basic_set_free(bset);
3228         return NULL;
3229 }
3230
3231 struct isl_basic_set *isl_basic_set_from_underlying_set(
3232         struct isl_basic_set *bset, struct isl_basic_set *like)
3233 {
3234         return (struct isl_basic_set *)
3235                 isl_basic_map_overlying_set(bset, (struct isl_basic_map *)like);
3236 }
3237
3238 struct isl_set *isl_set_from_underlying_set(
3239         struct isl_set *set, struct isl_basic_set *like)
3240 {
3241         int i;
3242
3243         if (!set || !like)
3244                 goto error;
3245         isl_assert(set->ctx, set->dim->n_out == isl_basic_set_total_dim(like),
3246                     goto error);
3247         if (isl_dim_equal(set->dim, like->dim) && like->n_div == 0) {
3248                 isl_basic_set_free(like);
3249                 return set;
3250         }
3251         set = isl_set_cow(set);
3252         if (!set)
3253                 goto error;
3254         for (i = 0; i < set->n; ++i) {
3255                 set->p[i] = isl_basic_set_from_underlying_set(set->p[i],
3256                                                       isl_basic_set_copy(like));
3257                 if (!set->p[i])
3258                         goto error;
3259         }
3260         isl_dim_free(set->dim);
3261         set->dim = isl_dim_copy(like->dim);
3262         if (!set->dim)
3263                 goto error;
3264         isl_basic_set_free(like);
3265         return set;
3266 error:
3267         isl_basic_set_free(like);
3268         isl_set_free(set);
3269         return NULL;
3270 }
3271
3272 struct isl_set *isl_map_underlying_set(struct isl_map *map)
3273 {
3274         int i;
3275
3276         map = isl_map_cow(map);
3277         if (!map)
3278                 return NULL;
3279         map->dim = isl_dim_cow(map->dim);
3280         if (!map->dim)
3281                 goto error;
3282
3283         for (i = 1; i < map->n; ++i)
3284                 isl_assert(map->ctx, map->p[0]->n_div == map->p[i]->n_div,
3285                                 goto error);
3286         for (i = 0; i < map->n; ++i) {
3287                 map->p[i] = (struct isl_basic_map *)
3288                                 isl_basic_map_underlying_set(map->p[i]);
3289                 if (!map->p[i])
3290                         goto error;
3291         }
3292         if (map->n == 0)
3293                 map->dim = isl_dim_underlying(map->dim, 0);
3294         else {
3295                 isl_dim_free(map->dim);
3296                 map->dim = isl_dim_copy(map->p[0]->dim);
3297         }
3298         if (!map->dim)
3299                 goto error;
3300         return (struct isl_set *)map;
3301 error:
3302         isl_map_free(map);
3303         return NULL;
3304 }
3305
3306 struct isl_set *isl_set_to_underlying_set(struct isl_set *set)
3307 {
3308         return (struct isl_set *)isl_map_underlying_set((struct isl_map *)set);
3309 }
3310
3311 struct isl_basic_set *isl_basic_map_domain(struct isl_basic_map *bmap)
3312 {
3313         struct isl_basic_set *domain;
3314         unsigned n_in;
3315         unsigned n_out;
3316         if (!bmap)
3317                 return NULL;
3318         n_in = isl_basic_map_n_in(bmap);
3319         n_out = isl_basic_map_n_out(bmap);
3320         domain = isl_basic_set_from_basic_map(bmap);
3321         return isl_basic_set_project_out(domain, isl_dim_set, n_in, n_out);
3322 }
3323
3324 struct isl_basic_set *isl_basic_map_range(struct isl_basic_map *bmap)
3325 {
3326         return isl_basic_map_domain(isl_basic_map_reverse(bmap));
3327 }
3328
3329 struct isl_set *isl_map_range(struct isl_map *map)
3330 {
3331         int i;
3332         struct isl_set *set;
3333
3334         if (!map)
3335                 goto error;
3336         if (isl_map_dim(map, isl_dim_in) == 0)
3337                 return (isl_set *)map;
3338
3339         map = isl_map_cow(map);
3340         if (!map)
3341                 goto error;
3342
3343         set = (struct isl_set *) map;
3344         set->dim = isl_dim_drop_inputs(set->dim, 0, set->dim->n_in);
3345         if (!set->dim)
3346                 goto error;
3347         for (i = 0; i < map->n; ++i) {
3348                 set->p[i] = isl_basic_map_range(map->p[i]);
3349                 if (!set->p[i])
3350                         goto error;
3351         }
3352         ISL_F_CLR(set, ISL_MAP_DISJOINT);
3353         ISL_F_CLR(set, ISL_SET_NORMALIZED);
3354         return set;
3355 error:
3356         isl_map_free(map);
3357         return NULL;
3358 }
3359
3360 struct isl_map *isl_map_from_set(struct isl_set *set, struct isl_dim *dim)
3361 {
3362         int i;
3363         struct isl_map *map = NULL;
3364
3365         set = isl_set_cow(set);
3366         if (!set || !dim)
3367                 goto error;
3368         isl_assert(set->ctx, isl_dim_compatible(set->dim, dim), goto error);
3369         map = (struct isl_map *)set;
3370         for (i = 0; i < set->n; ++i) {
3371                 map->p[i] = isl_basic_map_from_basic_set(
3372                                 set->p[i], isl_dim_copy(dim));
3373                 if (!map->p[i])
3374                         goto error;
3375         }
3376         isl_dim_free(map->dim);
3377         map->dim = dim;
3378         return map;
3379 error:
3380         isl_dim_free(dim);
3381         isl_set_free(set);
3382         return NULL;
3383 }
3384
3385 struct isl_map *isl_map_from_range(struct isl_set *set)
3386 {
3387         return (struct isl_map *)set;
3388 }
3389
3390 __isl_give isl_map *isl_map_from_domain(__isl_take isl_set *set)
3391 {
3392         return isl_map_reverse(isl_map_from_range(set));;
3393 }
3394
3395 __isl_give isl_map *isl_map_from_domain_and_range(__isl_take isl_set *domain,
3396         __isl_take isl_set *range)
3397 {
3398         return isl_map_product(isl_map_from_domain(domain),
3399                                isl_map_from_range(range));
3400 }
3401
3402 struct isl_set *isl_set_from_map(struct isl_map *map)
3403 {
3404         int i;
3405         struct isl_set *set = NULL;
3406
3407         if (!map)
3408                 return NULL;
3409         map = isl_map_cow(map);
3410         if (!map)
3411                 return NULL;
3412         map->dim = isl_dim_cow(map->dim);
3413         if (!map->dim)
3414                 goto error;
3415         map->dim->n_out += map->dim->n_in;
3416         map->dim->n_in = 0;
3417         set = (struct isl_set *)map;
3418         for (i = 0; i < map->n; ++i) {
3419                 set->p[i] = isl_basic_set_from_basic_map(map->p[i]);
3420                 if (!set->p[i])
3421                         goto error;
3422         }
3423         return set;
3424 error:
3425         isl_map_free(map);
3426         return NULL;
3427 }
3428
3429 struct isl_map *isl_map_alloc_dim(struct isl_dim *dim, int n, unsigned flags)
3430 {
3431         struct isl_map *map;
3432
3433         if (!dim)
3434                 return NULL;
3435         isl_assert(dim->ctx, n >= 0, return NULL);
3436         map = isl_alloc(dim->ctx, struct isl_map,
3437                         sizeof(struct isl_map) +
3438                         (n - 1) * sizeof(struct isl_basic_map *));
3439         if (!map)
3440                 goto error;
3441
3442         map->ctx = dim->ctx;
3443         isl_ctx_ref(map->ctx);
3444         map->ref = 1;
3445         map->size = n;
3446         map->n = 0;
3447         map->dim = dim;
3448         map->flags = flags;
3449         return map;
3450 error:
3451         isl_dim_free(dim);
3452         return NULL;
3453 }
3454
3455 struct isl_map *isl_map_alloc(struct isl_ctx *ctx,
3456                 unsigned nparam, unsigned in, unsigned out, int n,
3457                 unsigned flags)
3458 {
3459         struct isl_map *map;
3460         struct isl_dim *dims;
3461
3462         dims = isl_dim_alloc(ctx, nparam, in, out);
3463         if (!dims)
3464                 return NULL;
3465
3466         map = isl_map_alloc_dim(dims, n, flags);
3467         return map;
3468 }
3469
3470 struct isl_basic_map *isl_basic_map_empty(struct isl_dim *dim)
3471 {
3472         struct isl_basic_map *bmap;
3473         bmap = isl_basic_map_alloc_dim(dim, 0, 1, 0);
3474         bmap = isl_basic_map_set_to_empty(bmap);
3475         return bmap;
3476 }
3477
3478 struct isl_basic_set *isl_basic_set_empty(struct isl_dim *dim)
3479 {
3480         struct isl_basic_set *bset;
3481         bset = isl_basic_set_alloc_dim(dim, 0, 1, 0);
3482         bset = isl_basic_set_set_to_empty(bset);
3483         return bset;
3484 }
3485
3486 struct isl_basic_map *isl_basic_map_empty_like(struct isl_basic_map *model)
3487 {
3488         struct isl_basic_map *bmap;
3489         if (!model)
3490                 return NULL;
3491         bmap = isl_basic_map_alloc_dim(isl_dim_copy(model->dim), 0, 1, 0);
3492         bmap = isl_basic_map_set_to_empty(bmap);
3493         return bmap;
3494 }
3495
3496 struct isl_basic_map *isl_basic_map_empty_like_map(struct isl_map *model)
3497 {
3498         struct isl_basic_map *bmap;
3499         if (!model)
3500                 return NULL;
3501         bmap = isl_basic_map_alloc_dim(isl_dim_copy(model->dim), 0, 1, 0);
3502         bmap = isl_basic_map_set_to_empty(bmap);
3503         return bmap;
3504 }
3505
3506 struct isl_basic_set *isl_basic_set_empty_like(struct isl_basic_set *model)
3507 {
3508         struct isl_basic_set *bset;
3509         if (!model)
3510                 return NULL;
3511         bset = isl_basic_set_alloc_dim(isl_dim_copy(model->dim), 0, 1, 0);
3512         bset = isl_basic_set_set_to_empty(bset);
3513         return bset;
3514 }
3515
3516 struct isl_basic_map *isl_basic_map_universe(struct isl_dim *dim)
3517 {
3518         struct isl_basic_map *bmap;
3519         bmap = isl_basic_map_alloc_dim(dim, 0, 0, 0);
3520         return bmap;
3521 }
3522
3523 struct isl_basic_set *isl_basic_set_universe(struct isl_dim *dim)
3524 {
3525         struct isl_basic_set *bset;
3526         bset = isl_basic_set_alloc_dim(dim, 0, 0, 0);
3527         return bset;
3528 }
3529
3530 __isl_give isl_basic_map *isl_basic_map_universe_like(
3531                 __isl_keep isl_basic_map *model)
3532 {
3533         if (!model)
3534                 return NULL;
3535         return isl_basic_map_alloc_dim(isl_dim_copy(model->dim), 0, 0, 0);
3536 }
3537
3538 struct isl_basic_set *isl_basic_set_universe_like(struct isl_basic_set *model)
3539 {
3540         if (!model)
3541                 return NULL;
3542         return isl_basic_set_alloc_dim(isl_dim_copy(model->dim), 0, 0, 0);
3543 }
3544
3545 __isl_give isl_basic_set *isl_basic_set_universe_like_set(
3546         __isl_keep isl_set *model)
3547 {
3548         if (!model)
3549                 return NULL;
3550         return isl_basic_set_alloc_dim(isl_dim_copy(model->dim), 0, 0, 0);
3551 }
3552
3553 struct isl_map *isl_map_empty(struct isl_dim *dim)
3554 {
3555         return isl_map_alloc_dim(dim, 0, ISL_MAP_DISJOINT);
3556 }
3557
3558 struct isl_map *isl_map_empty_like(struct isl_map *model)
3559 {
3560         if (!model)
3561                 return NULL;
3562         return isl_map_alloc_dim(isl_dim_copy(model->dim), 0, ISL_MAP_DISJOINT);
3563 }
3564
3565 struct isl_map *isl_map_empty_like_basic_map(struct isl_basic_map *model)
3566 {
3567         if (!model)
3568                 return NULL;
3569         return isl_map_alloc_dim(isl_dim_copy(model->dim), 0, ISL_MAP_DISJOINT);
3570 }
3571
3572 struct isl_set *isl_set_empty(struct isl_dim *dim)
3573 {
3574         return isl_set_alloc_dim(dim, 0, ISL_MAP_DISJOINT);
3575 }
3576
3577 struct isl_set *isl_set_empty_like(struct isl_set *model)
3578 {
3579         if (!model)
3580                 return NULL;
3581         return isl_set_empty(isl_dim_copy(model->dim));
3582 }
3583
3584 struct isl_map *isl_map_universe(struct isl_dim *dim)
3585 {
3586         struct isl_map *map;
3587         if (!dim)
3588                 return NULL;
3589         map = isl_map_alloc_dim(isl_dim_copy(dim), 1, ISL_MAP_DISJOINT);
3590         map = isl_map_add_basic_map(map, isl_basic_map_universe(dim));
3591         return map;
3592 }
3593
3594 struct isl_set *isl_set_universe(struct isl_dim *dim)
3595 {
3596         struct isl_set *set;
3597         if (!dim)
3598                 return NULL;
3599         set = isl_set_alloc_dim(isl_dim_copy(dim), 1, ISL_MAP_DISJOINT);
3600         set = isl_set_add_basic_set(set, isl_basic_set_universe(dim));
3601         return set;
3602 }
3603
3604 __isl_give isl_set *isl_set_universe_like(__isl_keep isl_set *model)
3605 {
3606         if (!model)
3607                 return NULL;
3608         return isl_set_universe(isl_dim_copy(model->dim));
3609 }
3610
3611 struct isl_map *isl_map_dup(struct isl_map *map)
3612 {
3613         int i;
3614         struct isl_map *dup;
3615
3616         if (!map)
3617                 return NULL;
3618         dup = isl_map_alloc_dim(isl_dim_copy(map->dim), map->n, map->flags);
3619         for (i = 0; i < map->n; ++i)
3620                 dup = isl_map_add_basic_map(dup, isl_basic_map_copy(map->p[i]));
3621         return dup;
3622 }
3623
3624 __isl_give isl_map *isl_map_add_basic_map(__isl_take isl_map *map,
3625                                                 __isl_take isl_basic_map *bmap)
3626 {
3627         if (!bmap || !map)
3628                 goto error;
3629         if (isl_basic_map_fast_is_empty(bmap)) {
3630                 isl_basic_map_free(bmap);
3631                 return map;
3632         }
3633         isl_assert(map->ctx, isl_dim_equal(map->dim, bmap->dim), goto error);
3634         isl_assert(map->ctx, map->n < map->size, goto error);
3635         map->p[map->n] = bmap;
3636         map->n++;
3637         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
3638         return map;
3639 error:
3640         if (map)
3641                 isl_map_free(map);
3642         if (bmap)
3643                 isl_basic_map_free(bmap);
3644         return NULL;
3645 }
3646
3647 void isl_map_free(struct isl_map *map)
3648 {
3649         int i;
3650
3651         if (!map)
3652                 return;
3653
3654         if (--map->ref > 0)
3655                 return;
3656
3657         isl_ctx_deref(map->ctx);
3658         for (i = 0; i < map->n; ++i)
3659                 isl_basic_map_free(map->p[i]);
3660         isl_dim_free(map->dim);
3661         free(map);
3662 }
3663
3664 struct isl_map *isl_map_extend(struct isl_map *base,
3665                 unsigned nparam, unsigned n_in, unsigned n_out)
3666 {
3667         int i;
3668
3669         base = isl_map_cow(base);
3670         if (!base)
3671                 return NULL;
3672
3673         base->dim = isl_dim_extend(base->dim, nparam, n_in, n_out);
3674         if (!base->dim)
3675                 goto error;
3676         for (i = 0; i < base->n; ++i) {
3677                 base->p[i] = isl_basic_map_extend_dim(base->p[i],
3678                                 isl_dim_copy(base->dim), 0, 0, 0);
3679                 if (!base->p[i])
3680                         goto error;
3681         }
3682         return base;
3683 error:
3684         isl_map_free(base);
3685         return NULL;
3686 }
3687
3688 struct isl_set *isl_set_extend(struct isl_set *base,
3689                 unsigned nparam, unsigned dim)
3690 {
3691         return (struct isl_set *)isl_map_extend((struct isl_map *)base,
3692                                                         nparam, 0, dim);
3693 }
3694
3695 static struct isl_basic_map *isl_basic_map_fix_pos_si(
3696         struct isl_basic_map *bmap, unsigned pos, int value)
3697 {
3698         int j;
3699
3700         bmap = isl_basic_map_cow(bmap);
3701         bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
3702         j = isl_basic_map_alloc_equality(bmap);
3703         if (j < 0)
3704                 goto error;
3705         isl_seq_clr(bmap->eq[j] + 1, isl_basic_map_total_dim(bmap));
3706         isl_int_set_si(bmap->eq[j][pos], -1);
3707         isl_int_set_si(bmap->eq[j][0], value);
3708         bmap = isl_basic_map_simplify(bmap);
3709         return isl_basic_map_finalize(bmap);
3710 error:
3711         isl_basic_map_free(bmap);
3712         return NULL;
3713 }
3714
3715 static __isl_give isl_basic_map *isl_basic_map_fix_pos(
3716         __isl_take isl_basic_map *bmap, unsigned pos, isl_int value)
3717 {
3718         int j;
3719
3720         bmap = isl_basic_map_cow(bmap);
3721         bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
3722         j = isl_basic_map_alloc_equality(bmap);
3723         if (j < 0)
3724                 goto error;
3725         isl_seq_clr(bmap->eq[j] + 1, isl_basic_map_total_dim(bmap));
3726         isl_int_set_si(bmap->eq[j][pos], -1);
3727         isl_int_set(bmap->eq[j][0], value);
3728         bmap = isl_basic_map_simplify(bmap);
3729         return isl_basic_map_finalize(bmap);
3730 error:
3731         isl_basic_map_free(bmap);
3732         return NULL;
3733 }
3734
3735 struct isl_basic_map *isl_basic_map_fix_si(struct isl_basic_map *bmap,
3736                 enum isl_dim_type type, unsigned pos, int value)
3737 {
3738         if (!bmap)
3739                 return NULL;
3740         isl_assert(bmap->ctx, pos < isl_basic_map_dim(bmap, type), goto error);
3741         return isl_basic_map_fix_pos_si(bmap,
3742                 isl_basic_map_offset(bmap, type) + pos, value);
3743 error:
3744         isl_basic_map_free(bmap);
3745         return NULL;
3746 }
3747
3748 __isl_give isl_basic_map *isl_basic_map_fix(__isl_take isl_basic_map *bmap,
3749                 enum isl_dim_type type, unsigned pos, isl_int value)
3750 {
3751         if (!bmap)
3752                 return NULL;
3753         isl_assert(bmap->ctx, pos < isl_basic_map_dim(bmap, type), goto error);
3754         return isl_basic_map_fix_pos(bmap,
3755                 isl_basic_map_offset(bmap, type) + pos, value);
3756 error:
3757         isl_basic_map_free(bmap);
3758         return NULL;
3759 }
3760
3761 struct isl_basic_set *isl_basic_set_fix_si(struct isl_basic_set *bset,
3762                 enum isl_dim_type type, unsigned pos, int value)
3763 {
3764         return (struct isl_basic_set *)
3765                 isl_basic_map_fix_si((struct isl_basic_map *)bset,
3766                                         type, pos, value);
3767 }
3768
3769 __isl_give isl_basic_set *isl_basic_set_fix(__isl_take isl_basic_set *bset,
3770                 enum isl_dim_type type, unsigned pos, isl_int value)
3771 {
3772         return (struct isl_basic_set *)
3773                 isl_basic_map_fix((struct isl_basic_map *)bset,
3774                                         type, pos, value);
3775 }
3776
3777 struct isl_basic_map *isl_basic_map_fix_input_si(struct isl_basic_map *bmap,
3778                 unsigned input, int value)
3779 {
3780         return isl_basic_map_fix_si(bmap, isl_dim_in, input, value);
3781 }
3782
3783 struct isl_basic_set *isl_basic_set_fix_dim_si(struct isl_basic_set *bset,
3784                 unsigned dim, int value)
3785 {
3786         return (struct isl_basic_set *)
3787                 isl_basic_map_fix_si((struct isl_basic_map *)bset,
3788                                         isl_dim_set, dim, value);
3789 }
3790
3791 struct isl_map *isl_map_fix_si(struct isl_map *map,
3792                 enum isl_dim_type type, unsigned pos, int value)
3793 {
3794         int i;
3795
3796         map = isl_map_cow(map);
3797         if (!map)
3798                 return NULL;
3799
3800         isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error);
3801         for (i = 0; i < map->n; ++i) {
3802                 map->p[i] = isl_basic_map_fix_si(map->p[i], type, pos, value);
3803                 if (!map->p[i])
3804                         goto error;
3805         }
3806         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
3807         return map;
3808 error:
3809         isl_map_free(map);
3810         return NULL;
3811 }
3812
3813 __isl_give isl_set *isl_set_fix_si(__isl_take isl_set *set,
3814                 enum isl_dim_type type, unsigned pos, int value)
3815 {
3816         return (struct isl_set *)
3817                 isl_map_fix_si((struct isl_map *)set, type, pos, value);
3818 }
3819
3820 __isl_give isl_map *isl_map_fix(__isl_take isl_map *map,
3821                 enum isl_dim_type type, unsigned pos, isl_int value)
3822 {
3823         int i;
3824
3825         map = isl_map_cow(map);
3826         if (!map)
3827                 return NULL;
3828
3829         isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error);
3830         for (i = 0; i < map->n; ++i) {
3831                 map->p[i] = isl_basic_map_fix(map->p[i], type, pos, value);
3832                 if (!map->p[i])
3833                         goto error;
3834         }
3835         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
3836         return map;
3837 error:
3838         isl_map_free(map);
3839         return NULL;
3840 }
3841
3842 __isl_give isl_set *isl_set_fix(__isl_take isl_set *set,
3843                 enum isl_dim_type type, unsigned pos, isl_int value)
3844 {
3845         return (struct isl_set *)isl_map_fix((isl_map *)set, type, pos, value);
3846 }
3847
3848 struct isl_map *isl_map_fix_input_si(struct isl_map *map,
3849                 unsigned input, int value)
3850 {
3851         return isl_map_fix_si(map, isl_dim_in, input, value);
3852 }
3853
3854 struct isl_set *isl_set_fix_dim_si(struct isl_set *set, unsigned dim, int value)
3855 {
3856         return (struct isl_set *)
3857                 isl_map_fix_si((struct isl_map *)set, isl_dim_set, dim, value);
3858 }
3859
3860 __isl_give isl_basic_map *isl_basic_map_lower_bound_si(
3861                 __isl_take isl_basic_map *bmap,
3862                 enum isl_dim_type type, unsigned pos, int value)
3863 {
3864         int j;
3865
3866         if (!bmap)
3867                 return NULL;
3868         isl_assert(bmap->ctx, pos < isl_basic_map_dim(bmap, type), goto error);
3869         pos += isl_basic_map_offset(bmap, type);
3870         bmap = isl_basic_map_cow(bmap);
3871         bmap = isl_basic_map_extend_constraints(bmap, 0, 1);
3872         j = isl_basic_map_alloc_inequality(bmap);
3873         if (j < 0)
3874                 goto error;
3875         isl_seq_clr(bmap->ineq[j], 1 + isl_basic_map_total_dim(bmap));
3876         isl_int_set_si(bmap->ineq[j][pos], 1);
3877         isl_int_set_si(bmap->ineq[j][0], -value);
3878         bmap = isl_basic_map_simplify(bmap);
3879         return isl_basic_map_finalize(bmap);
3880 error:
3881         isl_basic_map_free(bmap);
3882         return NULL;
3883 }
3884
3885 struct isl_basic_set *isl_basic_set_lower_bound_dim(struct isl_basic_set *bset,
3886         unsigned dim, isl_int value)
3887 {
3888         int j;
3889
3890         bset = isl_basic_set_cow(bset);
3891         bset = isl_basic_set_extend_constraints(bset, 0, 1);
3892         j = isl_basic_set_alloc_inequality(bset);
3893         if (j < 0)
3894                 goto error;
3895         isl_seq_clr(bset->ineq[j], 1 + isl_basic_set_total_dim(bset));
3896         isl_int_set_si(bset->ineq[j][1 + isl_basic_set_n_param(bset) + dim], 1);
3897         isl_int_neg(bset->ineq[j][0], value);
3898         bset = isl_basic_set_simplify(bset);
3899         return isl_basic_set_finalize(bset);
3900 error:
3901         isl_basic_set_free(bset);
3902         return NULL;
3903 }
3904
3905 __isl_give isl_map *isl_map_lower_bound_si(__isl_take isl_map *map,
3906                 enum isl_dim_type type, unsigned pos, int value)
3907 {
3908         int i;
3909
3910         map = isl_map_cow(map);
3911         if (!map)
3912                 return NULL;
3913
3914         isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error);
3915         for (i = 0; i < map->n; ++i) {
3916                 map->p[i] = isl_basic_map_lower_bound_si(map->p[i],
3917                                                          type, pos, value);
3918                 if (!map->p[i])
3919                         goto error;
3920         }
3921         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
3922         return map;
3923 error:
3924         isl_map_free(map);
3925         return NULL;
3926 }
3927
3928 __isl_give isl_set *isl_set_lower_bound_si(__isl_take isl_set *set,
3929                 enum isl_dim_type type, unsigned pos, int value)
3930 {
3931         return (struct isl_set *)
3932                 isl_map_lower_bound_si((struct isl_map *)set, type, pos, value);
3933 }
3934
3935 struct isl_set *isl_set_lower_bound_dim(struct isl_set *set, unsigned dim,
3936                                         isl_int value)
3937 {
3938         int i;
3939
3940         set = isl_set_cow(set);
3941         if (!set)
3942                 return NULL;
3943
3944         isl_assert(set->ctx, dim < isl_set_n_dim(set), goto error);
3945         for (i = 0; i < set->n; ++i) {
3946                 set->p[i] = isl_basic_set_lower_bound_dim(set->p[i], dim, value);
3947                 if (!set->p[i])
3948                         goto error;
3949         }
3950         return set;
3951 error:
3952         isl_set_free(set);
3953         return NULL;
3954 }
3955
3956 struct isl_map *isl_map_reverse(struct isl_map *map)
3957 {
3958         int i;
3959
3960         map = isl_map_cow(map);
3961         if (!map)
3962                 return NULL;
3963
3964         map->dim = isl_dim_reverse(map->dim);
3965         if (!map->dim)
3966                 goto error;
3967         for (i = 0; i < map->n; ++i) {
3968                 map->p[i] = isl_basic_map_reverse(map->p[i]);
3969                 if (!map->p[i])
3970                         goto error;
3971         }
3972         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
3973         return map;
3974 error:
3975         isl_map_free(map);
3976         return NULL;
3977 }
3978
3979 static struct isl_map *isl_basic_map_partial_lexopt(
3980                 struct isl_basic_map *bmap, struct isl_basic_set *dom,
3981                 struct isl_set **empty, int max)
3982 {
3983         if (!bmap)
3984                 goto error;
3985         if (bmap->ctx->opt->pip == ISL_PIP_PIP)
3986                 return isl_pip_basic_map_lexopt(bmap, dom, empty, max);
3987         else
3988                 return isl_tab_basic_map_partial_lexopt(bmap, dom, empty, max);
3989 error:
3990         isl_basic_map_free(bmap);
3991         isl_basic_set_free(dom);
3992         if (empty)
3993                 *empty = NULL;
3994         return NULL;
3995 }
3996
3997 struct isl_map *isl_basic_map_partial_lexmax(
3998                 struct isl_basic_map *bmap, struct isl_basic_set *dom,
3999                 struct isl_set **empty)
4000 {
4001         return isl_basic_map_partial_lexopt(bmap, dom, empty, 1);
4002 }
4003
4004 struct isl_map *isl_basic_map_partial_lexmin(
4005                 struct isl_basic_map *bmap, struct isl_basic_set *dom,
4006                 struct isl_set **empty)
4007 {
4008         return isl_basic_map_partial_lexopt(bmap, dom, empty, 0);
4009 }
4010
4011 struct isl_set *isl_basic_set_partial_lexmin(
4012                 struct isl_basic_set *bset, struct isl_basic_set *dom,
4013                 struct isl_set **empty)
4014 {
4015         return (struct isl_set *)
4016                 isl_basic_map_partial_lexmin((struct isl_basic_map *)bset,
4017                         dom, empty);
4018 }
4019
4020 struct isl_set *isl_basic_set_partial_lexmax(
4021                 struct isl_basic_set *bset, struct isl_basic_set *dom,
4022                 struct isl_set **empty)
4023 {
4024         return (struct isl_set *)
4025                 isl_basic_map_partial_lexmax((struct isl_basic_map *)bset,
4026                         dom, empty);
4027 }
4028
4029 /* Given a basic map "bmap", compute the lexicograhically minimal
4030  * (or maximal) image element for each domain element in dom.
4031  * Set *empty to those elements in dom that do not have an image element.
4032  *
4033  * We first make sure the basic sets in dom are disjoint and then
4034  * simply collect the results over each of the basic sets separately.
4035  * We could probably improve the efficiency a bit by moving the union
4036  * domain down into the parametric integer programming.
4037  */
4038 static __isl_give isl_map *basic_map_partial_lexopt(
4039                 __isl_take isl_basic_map *bmap, __isl_take isl_set *dom,
4040                 __isl_give isl_set **empty, int max)
4041 {
4042         int i;
4043         struct isl_map *res;
4044
4045         dom = isl_set_make_disjoint(dom);
4046         if (!dom)
4047                 goto error;
4048
4049         if (isl_set_fast_is_empty(dom)) {
4050                 res = isl_map_empty_like_basic_map(bmap);
4051                 *empty = isl_set_empty_like(dom);
4052                 isl_set_free(dom);
4053                 isl_basic_map_free(bmap);
4054                 return res;
4055         }
4056
4057         res = isl_basic_map_partial_lexopt(isl_basic_map_copy(bmap),
4058                         isl_basic_set_copy(dom->p[0]), empty, max);
4059
4060         for (i = 1; i < dom->n; ++i) {
4061                 struct isl_map *res_i;
4062                 struct isl_set *empty_i;
4063
4064                 res_i = isl_basic_map_partial_lexopt(isl_basic_map_copy(bmap),
4065                                 isl_basic_set_copy(dom->p[i]), &empty_i, max);
4066
4067                 res = isl_map_union_disjoint(res, res_i);
4068                 *empty = isl_set_union_disjoint(*empty, empty_i);
4069         }
4070
4071         isl_set_free(dom);
4072         isl_basic_map_free(bmap);
4073         return res;
4074 error:
4075         *empty = NULL;
4076         isl_set_free(dom);
4077         isl_basic_map_free(bmap);
4078         return NULL;
4079 }
4080
4081 /* Given a map "map", compute the lexicograhically minimal
4082  * (or maximal) image element for each domain element in dom.
4083  * Set *empty to those elements in dom that do not have an image element.
4084  *
4085  * We first compute the lexicographically minimal or maximal element
4086  * in the first basic map.  This results in a partial solution "res"
4087  * and a subset "todo" of dom that still need to be handled.
4088  * We then consider each of the remaining maps in "map" and successively
4089  * improve both "res" and "todo".
4090  *
4091  * Let res^k and todo^k be the results after k steps and let i = k + 1.
4092  * Assume we are computing the lexicographical maximum.
4093  * We first intersect basic map i with a relation that maps elements
4094  * to elements that are lexicographically larger than the image elements
4095  * in res^k and the compute the maximum image element of this intersection.
4096  * The result ("better") corresponds to those image elements in basic map i
4097  * that are better than what we had before.  The remainder ("keep") are the
4098  * domain elements for which the image element in res_k was better.
4099  * We also compute the lexicographical maximum of basic map i in todo^k.
4100  * res^i is the result of the operation + better + those elements in
4101  *              res^k that we should keep
4102  * todo^i is the remainder of the maximum operation on todo^k.
4103  */
4104 static __isl_give isl_map *isl_map_partial_lexopt(
4105                 __isl_take isl_map *map, __isl_take isl_set *dom,
4106                 __isl_give isl_set **empty, int max)
4107 {
4108         int i;
4109         struct isl_map *res;
4110         struct isl_set *todo;
4111
4112         if (!map || !dom)
4113                 goto error;
4114
4115         if (isl_map_fast_is_empty(map)) {
4116                 if (empty)
4117                         *empty = dom;
4118                 else
4119                         isl_set_free(dom);
4120                 return map;
4121         }
4122
4123         res = basic_map_partial_lexopt(isl_basic_map_copy(map->p[0]),
4124                                         isl_set_copy(dom), &todo, max);
4125
4126         for (i = 1; i < map->n; ++i) {
4127                 struct isl_map *lt;
4128                 struct isl_map *better;
4129                 struct isl_set *keep;
4130                 struct isl_map *res_i;
4131                 struct isl_set *todo_i;
4132                 struct isl_dim *dim = isl_map_get_dim(res);
4133
4134                 dim = isl_dim_range(dim);
4135                 if (max)
4136                         lt = isl_map_lex_lt(dim);
4137                 else
4138                         lt = isl_map_lex_gt(dim);
4139                 lt = isl_map_apply_range(isl_map_copy(res), lt);
4140                 lt = isl_map_intersect(lt,
4141                         isl_map_from_basic_map(isl_basic_map_copy(map->p[i])));
4142                 better = isl_map_partial_lexopt(lt,
4143                         isl_map_domain(isl_map_copy(res)),
4144                         &keep, max);
4145
4146                 res_i = basic_map_partial_lexopt(isl_basic_map_copy(map->p[i]),
4147                                                 todo, &todo_i, max);
4148
4149                 res = isl_map_intersect_domain(res, keep);
4150                 res = isl_map_union_disjoint(res, res_i);
4151                 res = isl_map_union_disjoint(res, better);
4152                 todo = todo_i;
4153         }
4154
4155         isl_set_free(dom);
4156         isl_map_free(map);
4157
4158         if (empty)
4159                 *empty = todo;
4160         else
4161                 isl_set_free(todo);
4162
4163         return res;
4164 error:
4165         if (empty)
4166                 *empty = NULL;
4167         isl_set_free(dom);
4168         isl_map_free(map);
4169         return NULL;
4170 }
4171
4172 __isl_give isl_map *isl_map_partial_lexmax(
4173                 __isl_take isl_map *map, __isl_take isl_set *dom,
4174                 __isl_give isl_set **empty)
4175 {
4176         return isl_map_partial_lexopt(map, dom, empty, 1);
4177 }
4178
4179 __isl_give isl_map *isl_map_partial_lexmin(
4180                 __isl_take isl_map *map, __isl_take isl_set *dom,
4181                 __isl_give isl_set **empty)
4182 {
4183         return isl_map_partial_lexopt(map, dom, empty, 0);
4184 }
4185
4186 __isl_give isl_set *isl_set_partial_lexmin(
4187                 __isl_take isl_set *set, __isl_take isl_set *dom,
4188                 __isl_give isl_set **empty)
4189 {
4190         return (struct isl_set *)
4191                 isl_map_partial_lexmin((struct isl_map *)set,
4192                         dom, empty);
4193 }
4194
4195 __isl_give isl_set *isl_set_partial_lexmax(
4196                 __isl_take isl_set *set, __isl_take isl_set *dom,
4197                 __isl_give isl_set **empty)
4198 {
4199         return (struct isl_set *)
4200                 isl_map_partial_lexmax((struct isl_map *)set,
4201                         dom, empty);
4202 }
4203
4204 __isl_give isl_map *isl_basic_map_lexopt(__isl_take isl_basic_map *bmap, int max)
4205 {
4206         struct isl_basic_set *dom = NULL;
4207         struct isl_dim *dom_dim;
4208
4209         if (!bmap)
4210                 goto error;
4211         dom_dim = isl_dim_domain(isl_dim_copy(bmap->dim));
4212         dom = isl_basic_set_universe(dom_dim);
4213         return isl_basic_map_partial_lexopt(bmap, dom, NULL, max);
4214 error:
4215         isl_basic_map_free(bmap);
4216         return NULL;
4217 }
4218
4219 __isl_give isl_map *isl_basic_map_lexmin(__isl_take isl_basic_map *bmap)
4220 {
4221         return isl_basic_map_lexopt(bmap, 0);
4222 }
4223
4224 __isl_give isl_map *isl_basic_map_lexmax(__isl_take isl_basic_map *bmap)
4225 {
4226         return isl_basic_map_lexopt(bmap, 1);
4227 }
4228
4229 __isl_give isl_set *isl_basic_set_lexmin(__isl_take isl_basic_set *bset)
4230 {
4231         return (isl_set *)isl_basic_map_lexmin((isl_basic_map *)bset);
4232 }
4233
4234 __isl_give isl_set *isl_basic_set_lexmax(__isl_take isl_basic_set *bset)
4235 {
4236         return (isl_set *)isl_basic_map_lexmax((isl_basic_map *)bset);
4237 }
4238
4239 __isl_give isl_map *isl_map_lexopt(__isl_take isl_map *map, int max)
4240 {
4241         struct isl_set *dom = NULL;
4242         struct isl_dim *dom_dim;
4243
4244         if (!map)
4245                 goto error;
4246         dom_dim = isl_dim_domain(isl_dim_copy(map->dim));
4247         dom = isl_set_universe(dom_dim);
4248         return isl_map_partial_lexopt(map, dom, NULL, max);
4249 error:
4250         isl_map_free(map);
4251         return NULL;
4252 }
4253
4254 __isl_give isl_map *isl_map_lexmin(__isl_take isl_map *map)
4255 {
4256         return isl_map_lexopt(map, 0);
4257 }
4258
4259 __isl_give isl_map *isl_map_lexmax(__isl_take isl_map *map)
4260 {
4261         return isl_map_lexopt(map, 1);
4262 }
4263
4264 __isl_give isl_set *isl_set_lexmin(__isl_take isl_set *set)
4265 {
4266         return (isl_set *)isl_map_lexmin((isl_map *)set);
4267 }
4268
4269 __isl_give isl_set *isl_set_lexmax(__isl_take isl_set *set)
4270 {
4271         return (isl_set *)isl_map_lexmax((isl_map *)set);
4272 }
4273
4274 static struct isl_map *isl_map_reset_dim(struct isl_map *map,
4275         struct isl_dim *dim)
4276 {
4277         int i;
4278
4279         if (!map || !dim)
4280                 goto error;
4281
4282         for (i = 0; i < map->n; ++i) {
4283                 isl_dim_free(map->p[i]->dim);
4284                 map->p[i]->dim = isl_dim_copy(dim);
4285         }
4286         isl_dim_free(map->dim);
4287         map->dim = dim;
4288
4289         return map;
4290 error:
4291         isl_map_free(map);
4292         isl_dim_free(dim);
4293         return NULL;
4294 }
4295
4296 static struct isl_set *isl_set_reset_dim(struct isl_set *set,
4297         struct isl_dim *dim)
4298 {
4299         return (struct isl_set *) isl_map_reset_dim((struct isl_map *)set, dim);
4300 }
4301
4302 /* Apply a preimage specified by "mat" on the parameters of "bset".
4303  * bset is assumed to have only parameters and divs.
4304  */
4305 static struct isl_basic_set *basic_set_parameter_preimage(
4306         struct isl_basic_set *bset, struct isl_mat *mat)
4307 {
4308         unsigned nparam;
4309
4310         if (!bset || !mat)
4311                 goto error;
4312
4313         bset->dim = isl_dim_cow(bset->dim);
4314         if (!bset->dim)
4315                 goto error;
4316
4317         nparam = isl_basic_set_dim(bset, isl_dim_param);
4318
4319         isl_assert(bset->ctx, mat->n_row == 1 + nparam, goto error);
4320
4321         bset->dim->nparam = 0;
4322         bset->dim->n_out = nparam;
4323         bset = isl_basic_set_preimage(bset, mat);
4324         if (bset) {
4325                 bset->dim->nparam = bset->dim->n_out;
4326                 bset->dim->n_out = 0;
4327         }
4328         return bset;
4329 error:
4330         isl_mat_free(mat);
4331         isl_basic_set_free(bset);
4332         return NULL;
4333 }
4334
4335 /* Apply a preimage specified by "mat" on the parameters of "set".
4336  * set is assumed to have only parameters and divs.
4337  */
4338 static struct isl_set *set_parameter_preimage(
4339         struct isl_set *set, struct isl_mat *mat)
4340 {
4341         struct isl_dim *dim = NULL;
4342         unsigned nparam;
4343
4344         if (!set || !mat)
4345                 goto error;
4346
4347         dim = isl_dim_copy(set->dim);
4348         dim = isl_dim_cow(dim);
4349         if (!dim)
4350                 goto error;
4351
4352         nparam = isl_set_dim(set, isl_dim_param);
4353
4354         isl_assert(set->ctx, mat->n_row == 1 + nparam, goto error);
4355
4356         dim->nparam = 0;
4357         dim->n_out = nparam;
4358         isl_set_reset_dim(set, dim);
4359         set = isl_set_preimage(set, mat);
4360         if (!set)
4361                 goto error2;
4362         dim = isl_dim_copy(set->dim);
4363         dim = isl_dim_cow(dim);
4364         if (!dim)
4365                 goto error2;
4366         dim->nparam = dim->n_out;
4367         dim->n_out = 0;
4368         isl_set_reset_dim(set, dim);
4369         return set;
4370 error:
4371         isl_dim_free(dim);
4372         isl_mat_free(mat);
4373 error2:
4374         isl_set_free(set);
4375         return NULL;
4376 }
4377
4378 /* Intersect the basic set "bset" with the affine space specified by the
4379  * equalities in "eq".
4380  */
4381 static struct isl_basic_set *basic_set_append_equalities(
4382         struct isl_basic_set *bset, struct isl_mat *eq)
4383 {
4384         int i, k;
4385         unsigned len;
4386
4387         if (!bset || !eq)
4388                 goto error;
4389
4390         bset = isl_basic_set_extend_dim(bset, isl_dim_copy(bset->dim), 0,
4391                                         eq->n_row, 0);
4392         if (!bset)
4393                 goto error;
4394
4395         len = 1 + isl_dim_total(bset->dim) + bset->extra;
4396         for (i = 0; i < eq->n_row; ++i) {
4397                 k = isl_basic_set_alloc_equality(bset);
4398                 if (k < 0)
4399                         goto error;
4400                 isl_seq_cpy(bset->eq[k], eq->row[i], eq->n_col);
4401                 isl_seq_clr(bset->eq[k] + eq->n_col, len - eq->n_col);
4402         }
4403         isl_mat_free(eq);
4404
4405         bset = isl_basic_set_gauss(bset, NULL);
4406         bset = isl_basic_set_finalize(bset);
4407
4408         return bset;
4409 error:
4410         isl_mat_free(eq);
4411         isl_basic_set_free(bset);
4412         return NULL;
4413 }
4414
4415 /* Intersect the set "set" with the affine space specified by the
4416  * equalities in "eq".
4417  */
4418 static struct isl_set *set_append_equalities(struct isl_set *set,
4419         struct isl_mat *eq)
4420 {
4421         int i;
4422
4423         if (!set || !eq)
4424                 goto error;
4425
4426         for (i = 0; i < set->n; ++i) {
4427                 set->p[i] = basic_set_append_equalities(set->p[i],
4428                                         isl_mat_copy(eq));
4429                 if (!set->p[i])
4430                         goto error;
4431         }
4432         isl_mat_free(eq);
4433         return set;
4434 error:
4435         isl_mat_free(eq);
4436         isl_set_free(set);
4437         return NULL;
4438 }
4439
4440 /* Project the given basic set onto its parameter domain, possibly introducing
4441  * new, explicit, existential variables in the constraints.
4442  * The input has parameters and (possibly implicit) existential variables.
4443  * The output has the same parameters, but only
4444  * explicit existentially quantified variables.
4445  *
4446  * The actual projection is performed by pip, but pip doesn't seem
4447  * to like equalities very much, so we first remove the equalities
4448  * among the parameters by performing a variable compression on
4449  * the parameters.  Afterward, an inverse transformation is performed
4450  * and the equalities among the parameters are inserted back in.
4451  */
4452 static struct isl_set *parameter_compute_divs(struct isl_basic_set *bset)
4453 {
4454         int i, j;
4455         struct isl_mat *eq;
4456         struct isl_mat *T, *T2;
4457         struct isl_set *set;
4458         unsigned nparam, n_div;
4459
4460         bset = isl_basic_set_cow(bset);
4461         if (!bset)
4462                 return NULL;
4463
4464         if (bset->n_eq == 0)
4465                 return isl_basic_set_lexmin(bset);
4466
4467         isl_basic_set_gauss(bset, NULL);
4468
4469         nparam = isl_basic_set_dim(bset, isl_dim_param);
4470         n_div = isl_basic_set_dim(bset, isl_dim_div);
4471
4472         for (i = 0, j = n_div - 1; i < bset->n_eq && j >= 0; --j) {
4473                 if (!isl_int_is_zero(bset->eq[i][1 + nparam + j]))
4474                         ++i;
4475         }
4476         if (i == bset->n_eq)
4477                 return isl_basic_set_lexmin(bset);
4478
4479         eq = isl_mat_sub_alloc(bset->ctx, bset->eq, i, bset->n_eq - i,
4480                 0, 1 + nparam);
4481         eq = isl_mat_cow(eq);
4482         T = isl_mat_variable_compression(isl_mat_copy(eq), &T2);
4483         if (T && T->n_col == 0) {
4484                 isl_mat_free(T);
4485                 isl_mat_free(T2);
4486                 isl_mat_free(eq);
4487                 bset = isl_basic_set_set_to_empty(bset);
4488                 return isl_set_from_basic_set(bset);
4489         }
4490         bset = basic_set_parameter_preimage(bset, T);
4491
4492         set = isl_basic_set_lexmin(bset);
4493         set = set_parameter_preimage(set, T2);
4494         set = set_append_equalities(set, eq);
4495         return set;
4496 }
4497
4498 /* Compute an explicit representation for all the existentially
4499  * quantified variables.
4500  * The input and output dimensions are first turned into parameters.
4501  * compute_divs then returns a map with the same parameters and
4502  * no input or output dimensions and the dimension specification
4503  * is reset to that of the input.
4504  */
4505 static struct isl_map *compute_divs(struct isl_basic_map *bmap)
4506 {
4507         struct isl_basic_set *bset;
4508         struct isl_set *set;
4509         struct isl_map *map;
4510         struct isl_dim *dim, *orig_dim = NULL;
4511         unsigned         nparam;
4512         unsigned         n_in;
4513         unsigned         n_out;
4514
4515         bmap = isl_basic_map_cow(bmap);
4516         if (!bmap)
4517                 return NULL;
4518
4519         nparam = isl_basic_map_dim(bmap, isl_dim_param);
4520         n_in = isl_basic_map_dim(bmap, isl_dim_in);
4521         n_out = isl_basic_map_dim(bmap, isl_dim_out);
4522         dim = isl_dim_set_alloc(bmap->ctx, nparam + n_in + n_out, 0);
4523         if (!dim)
4524                 goto error;
4525
4526         orig_dim = bmap->dim;
4527         bmap->dim = dim;
4528         bset = (struct isl_basic_set *)bmap;
4529
4530         set = parameter_compute_divs(bset);
4531         map = (struct isl_map *)set;
4532         map = isl_map_reset_dim(map, orig_dim);
4533
4534         return map;
4535 error:
4536         isl_basic_map_free(bmap);
4537         return NULL;
4538 }
4539
4540 static int basic_map_divs_known(__isl_keep isl_basic_map *bmap)
4541 {
4542         int i;
4543         unsigned off;
4544
4545         if (!bmap)
4546                 return -1;
4547
4548         off = isl_dim_total(bmap->dim);
4549         for (i = 0; i < bmap->n_div; ++i) {
4550                 if (isl_int_is_zero(bmap->div[i][0]))
4551                         return 0;
4552                 isl_assert(bmap->ctx, isl_int_is_zero(bmap->div[i][1+1+off+i]),
4553                                 return -1);
4554         }
4555         return 1;
4556 }
4557
4558 static int map_divs_known(__isl_keep isl_map *map)
4559 {
4560         int i;
4561
4562         if (!map)
4563                 return -1;
4564
4565         for (i = 0; i < map->n; ++i) {
4566                 int known = basic_map_divs_known(map->p[i]);
4567                 if (known <= 0)
4568                         return known;
4569         }
4570
4571         return 1;
4572 }
4573
4574 /* If bmap contains any unknown divs, then compute explicit
4575  * expressions for them.  However, this computation may be
4576  * quite expensive, so first try to remove divs that aren't
4577  * strictly needed.
4578  */
4579 struct isl_map *isl_basic_map_compute_divs(struct isl_basic_map *bmap)
4580 {
4581         int i;
4582         int known;
4583         struct isl_map *map;
4584
4585         known = basic_map_divs_known(bmap);
4586         if (known < 0)
4587                 goto error;
4588         if (known)
4589                 return isl_map_from_basic_map(bmap);
4590
4591         bmap = isl_basic_map_drop_redundant_divs(bmap);
4592
4593         known = basic_map_divs_known(bmap);
4594         if (known < 0)
4595                 goto error;
4596         if (known)
4597                 return isl_map_from_basic_map(bmap);
4598
4599         map = compute_divs(bmap);
4600         return map;
4601 error:
4602         isl_basic_map_free(bmap);
4603         return NULL;
4604 }
4605
4606 struct isl_map *isl_map_compute_divs(struct isl_map *map)
4607 {
4608         int i;
4609         int known;
4610         struct isl_map *res;
4611
4612         if (!map)
4613                 return NULL;
4614         if (map->n == 0)
4615                 return map;
4616
4617         known = map_divs_known(map);
4618         if (known < 0) {
4619                 isl_map_free(map);
4620                 return NULL;
4621         }
4622         if (known)
4623                 return map;
4624
4625         res = isl_basic_map_compute_divs(isl_basic_map_copy(map->p[0]));
4626         for (i = 1 ; i < map->n; ++i) {
4627                 struct isl_map *r2;
4628                 r2 = isl_basic_map_compute_divs(isl_basic_map_copy(map->p[i]));
4629                 if (ISL_F_ISSET(map, ISL_MAP_DISJOINT))
4630                         res = isl_map_union_disjoint(res, r2);
4631                 else
4632                         res = isl_map_union(res, r2);
4633         }
4634         isl_map_free(map);
4635
4636         return res;
4637 }
4638
4639 struct isl_set *isl_basic_set_compute_divs(struct isl_basic_set *bset)
4640 {
4641         return (struct isl_set *)
4642                 isl_basic_map_compute_divs((struct isl_basic_map *)bset);
4643 }
4644
4645 struct isl_set *isl_set_compute_divs(struct isl_set *set)
4646 {
4647         return (struct isl_set *)
4648                 isl_map_compute_divs((struct isl_map *)set);
4649 }
4650
4651 struct isl_set *isl_map_domain(struct isl_map *map)
4652 {
4653         int i;
4654         struct isl_set *set;
4655
4656         if (!map)
4657                 goto error;
4658
4659         map = isl_map_cow(map);
4660         if (!map)
4661                 return NULL;
4662
4663         set = (struct isl_set *)map;
4664         set->dim = isl_dim_domain(set->dim);
4665         if (!set->dim)
4666                 goto error;
4667         for (i = 0; i < map->n; ++i) {
4668                 set->p[i] = isl_basic_map_domain(map->p[i]);
4669                 if (!set->p[i])
4670                         goto error;
4671         }
4672         ISL_F_CLR(set, ISL_MAP_DISJOINT);
4673         ISL_F_CLR(set, ISL_SET_NORMALIZED);
4674         return set;
4675 error:
4676         isl_map_free(map);
4677         return NULL;
4678 }
4679
4680 struct isl_map *isl_map_union_disjoint(
4681                         struct isl_map *map1, struct isl_map *map2)
4682 {
4683         int i;
4684         unsigned flags = 0;
4685         struct isl_map *map = NULL;
4686
4687         if (!map1 || !map2)
4688                 goto error;
4689
4690         if (map1->n == 0) {
4691                 isl_map_free(map1);
4692                 return map2;
4693         }
4694         if (map2->n == 0) {
4695                 isl_map_free(map2);
4696                 return map1;
4697         }
4698
4699         isl_assert(map1->ctx, isl_dim_equal(map1->dim, map2->dim), goto error);
4700
4701         if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) &&
4702             ISL_F_ISSET(map2, ISL_MAP_DISJOINT))
4703                 ISL_FL_SET(flags, ISL_MAP_DISJOINT);
4704
4705         map = isl_map_alloc_dim(isl_dim_copy(map1->dim),
4706                                 map1->n + map2->n, flags);
4707         if (!map)
4708                 goto error;
4709         for (i = 0; i < map1->n; ++i) {
4710                 map = isl_map_add_basic_map(map,
4711                                   isl_basic_map_copy(map1->p[i]));
4712                 if (!map)
4713                         goto error;
4714         }
4715         for (i = 0; i < map2->n; ++i) {
4716                 map = isl_map_add_basic_map(map,
4717                                   isl_basic_map_copy(map2->p[i]));
4718                 if (!map)
4719                         goto error;
4720         }
4721         isl_map_free(map1);
4722         isl_map_free(map2);
4723         return map;
4724 error:
4725         isl_map_free(map);
4726         isl_map_free(map1);
4727         isl_map_free(map2);
4728         return NULL;
4729 }
4730
4731 struct isl_map *isl_map_union(struct isl_map *map1, struct isl_map *map2)
4732 {
4733         map1 = isl_map_union_disjoint(map1, map2);
4734         if (!map1)
4735                 return NULL;
4736         if (map1->n > 1)
4737                 ISL_F_CLR(map1, ISL_MAP_DISJOINT);
4738         return map1;
4739 }
4740
4741 struct isl_set *isl_set_union_disjoint(
4742                         struct isl_set *set1, struct isl_set *set2)
4743 {
4744         return (struct isl_set *)
4745                 isl_map_union_disjoint(
4746                         (struct isl_map *)set1, (struct isl_map *)set2);
4747 }
4748
4749 struct isl_set *isl_set_union(struct isl_set *set1, struct isl_set *set2)
4750 {
4751         return (struct isl_set *)
4752                 isl_map_union((struct isl_map *)set1, (struct isl_map *)set2);
4753 }
4754
4755 struct isl_map *isl_map_intersect_range(
4756                 struct isl_map *map, struct isl_set *set)
4757 {
4758         unsigned flags = 0;
4759         struct isl_map *result;
4760         int i, j;
4761
4762         if (!map || !set)
4763                 goto error;
4764
4765         if (ISL_F_ISSET(map, ISL_MAP_DISJOINT) &&
4766             ISL_F_ISSET(set, ISL_MAP_DISJOINT))
4767                 ISL_FL_SET(flags, ISL_MAP_DISJOINT);
4768
4769         result = isl_map_alloc_dim(isl_dim_copy(map->dim),
4770                                         map->n * set->n, flags);
4771         if (!result)
4772                 goto error;
4773         for (i = 0; i < map->n; ++i)
4774                 for (j = 0; j < set->n; ++j) {
4775                         result = isl_map_add_basic_map(result,
4776                             isl_basic_map_intersect_range(
4777                                 isl_basic_map_copy(map->p[i]),
4778                                 isl_basic_set_copy(set->p[j])));
4779                         if (!result)
4780                                 goto error;
4781                 }
4782         isl_map_free(map);
4783         isl_set_free(set);
4784         return result;
4785 error:
4786         isl_map_free(map);
4787         isl_set_free(set);
4788         return NULL;
4789 }
4790
4791 struct isl_map *isl_map_intersect_domain(
4792                 struct isl_map *map, struct isl_set *set)
4793 {
4794         return isl_map_reverse(
4795                 isl_map_intersect_range(isl_map_reverse(map), set));
4796 }
4797
4798 struct isl_map *isl_map_apply_domain(
4799                 struct isl_map *map1, struct isl_map *map2)
4800 {
4801         if (!map1 || !map2)
4802                 goto error;
4803         map1 = isl_map_reverse(map1);
4804         map1 = isl_map_apply_range(map1, map2);
4805         return isl_map_reverse(map1);
4806 error:
4807         isl_map_free(map1);
4808         isl_map_free(map2);
4809         return NULL;
4810 }
4811
4812 struct isl_map *isl_map_apply_range(
4813                 struct isl_map *map1, struct isl_map *map2)
4814 {
4815         struct isl_dim *dim_result;
4816         struct isl_map *result;
4817         int i, j;
4818
4819         if (!map1 || !map2)
4820                 goto error;
4821
4822         dim_result = isl_dim_join(isl_dim_copy(map1->dim),
4823                                   isl_dim_copy(map2->dim));
4824
4825         result = isl_map_alloc_dim(dim_result, map1->n * map2->n, 0);
4826         if (!result)
4827                 goto error;
4828         for (i = 0; i < map1->n; ++i)
4829                 for (j = 0; j < map2->n; ++j) {
4830                         result = isl_map_add_basic_map(result,
4831                             isl_basic_map_apply_range(
4832                                 isl_basic_map_copy(map1->p[i]),
4833                                 isl_basic_map_copy(map2->p[j])));
4834                         if (!result)
4835                                 goto error;
4836                 }
4837         isl_map_free(map1);
4838         isl_map_free(map2);
4839         if (result && result->n <= 1)
4840                 ISL_F_SET(result, ISL_MAP_DISJOINT);
4841         return result;
4842 error:
4843         isl_map_free(map1);
4844         isl_map_free(map2);
4845         return NULL;
4846 }
4847
4848 /*
4849  * returns range - domain
4850  */
4851 struct isl_basic_set *isl_basic_map_deltas(struct isl_basic_map *bmap)
4852 {
4853         isl_dim *dims;
4854         struct isl_basic_set *bset;
4855         unsigned dim;
4856         unsigned nparam;
4857         int i;
4858
4859         if (!bmap)
4860                 goto error;
4861         dim = isl_basic_map_n_in(bmap);
4862         nparam = isl_basic_map_n_param(bmap);
4863         isl_assert(bmap->ctx, dim == isl_basic_map_n_out(bmap), goto error);
4864         bset = isl_basic_set_from_basic_map(bmap);
4865         bset = isl_basic_set_cow(bset);
4866         dims = isl_basic_set_get_dim(bset);
4867         dims = isl_dim_add(dims, isl_dim_set, dim);
4868         bset = isl_basic_set_extend_dim(bset, dims, 0, dim, 0);
4869         bset = isl_basic_set_swap_vars(bset, 2*dim);
4870         for (i = 0; i < dim; ++i) {
4871                 int j = isl_basic_map_alloc_equality(
4872                                             (struct isl_basic_map *)bset);
4873                 if (j < 0)
4874                         goto error;
4875                 isl_seq_clr(bset->eq[j], 1 + isl_basic_set_total_dim(bset));
4876                 isl_int_set_si(bset->eq[j][1+nparam+i], 1);
4877                 isl_int_set_si(bset->eq[j][1+nparam+dim+i], 1);
4878                 isl_int_set_si(bset->eq[j][1+nparam+2*dim+i], -1);
4879         }
4880         return isl_basic_set_project_out(bset, isl_dim_set, dim, 2*dim);
4881 error:
4882         isl_basic_map_free(bmap);
4883         return NULL;
4884 }
4885
4886 /*
4887  * returns range - domain
4888  */
4889 struct isl_set *isl_map_deltas(struct isl_map *map)
4890 {
4891         int i;
4892         isl_dim *dim;
4893         struct isl_set *result;
4894
4895         if (!map)
4896                 return NULL;
4897
4898         isl_assert(map->ctx, isl_map_n_in(map) == isl_map_n_out(map), goto error);
4899         dim = isl_map_get_dim(map);
4900         dim = isl_dim_domain(dim);
4901         result = isl_set_alloc_dim(dim, map->n, map->flags);
4902         if (!result)
4903                 goto error;
4904         for (i = 0; i < map->n; ++i)
4905                 result = isl_set_add_basic_set(result,
4906                           isl_basic_map_deltas(isl_basic_map_copy(map->p[i])));
4907         isl_map_free(map);
4908         return result;
4909 error:
4910         isl_map_free(map);
4911         return NULL;
4912 }
4913
4914 static struct isl_basic_map *basic_map_identity(struct isl_dim *dims)
4915 {
4916         struct isl_basic_map *bmap;
4917         unsigned nparam;
4918         unsigned dim;
4919         int i;
4920
4921         if (!dims)
4922                 return NULL;
4923
4924         nparam = dims->nparam;
4925         dim = dims->n_out;
4926         bmap = isl_basic_map_alloc_dim(dims, 0, dim, 0);
4927         if (!bmap)
4928                 goto error;
4929
4930         for (i = 0; i < dim; ++i) {
4931                 int j = isl_basic_map_alloc_equality(bmap);
4932                 if (j < 0)
4933                         goto error;
4934                 isl_seq_clr(bmap->eq[j], 1 + isl_basic_map_total_dim(bmap));
4935                 isl_int_set_si(bmap->eq[j][1+nparam+i], 1);
4936                 isl_int_set_si(bmap->eq[j][1+nparam+dim+i], -1);
4937         }
4938         return isl_basic_map_finalize(bmap);
4939 error:
4940         isl_basic_map_free(bmap);
4941         return NULL;
4942 }
4943
4944 struct isl_basic_map *isl_basic_map_identity(struct isl_dim *set_dim)
4945 {
4946         struct isl_dim *dim = isl_dim_map(set_dim);
4947         if (!dim)
4948                 return NULL;
4949         return basic_map_identity(dim);
4950 }
4951
4952 struct isl_basic_map *isl_basic_map_identity_like(struct isl_basic_map *model)
4953 {
4954         if (!model || !model->dim)
4955                 return NULL;
4956         isl_assert(model->ctx,
4957                         model->dim->n_in == model->dim->n_out, return NULL);
4958         return basic_map_identity(isl_dim_copy(model->dim));
4959 }
4960
4961 static struct isl_map *map_identity(struct isl_dim *dim)
4962 {
4963         struct isl_map *map = isl_map_alloc_dim(dim, 1, ISL_MAP_DISJOINT);
4964         return isl_map_add_basic_map(map, basic_map_identity(isl_dim_copy(dim)));
4965 }
4966
4967 struct isl_map *isl_map_identity(struct isl_dim *set_dim)
4968 {
4969         struct isl_dim *dim = isl_dim_map(set_dim);
4970         if (!dim)
4971                 return NULL;
4972         return map_identity(dim);
4973 }
4974
4975 struct isl_map *isl_map_identity_like(struct isl_map *model)
4976 {
4977         if (!model || !model->dim)
4978                 return NULL;
4979         isl_assert(model->ctx,
4980                         model->dim->n_in == model->dim->n_out, return NULL);
4981         return map_identity(isl_dim_copy(model->dim));
4982 }
4983
4984 struct isl_map *isl_map_identity_like_basic_map(struct isl_basic_map *model)
4985 {
4986         if (!model || !model->dim)
4987                 return NULL;
4988         isl_assert(model->ctx,
4989                         model->dim->n_in == model->dim->n_out, return NULL);
4990         return map_identity(isl_dim_copy(model->dim));
4991 }
4992
4993 /* Construct a basic set with all set dimensions having only non-negative
4994  * values.
4995  */
4996 struct isl_basic_set *isl_basic_set_positive_orthant(struct isl_dim *dims)
4997 {
4998         int i;
4999         unsigned nparam;
5000         unsigned dim;
5001         struct isl_basic_set *bset;
5002
5003         if (!dims)
5004                 return NULL;
5005         nparam = dims->nparam;
5006         dim = dims->n_out;
5007         bset = isl_basic_set_alloc_dim(dims, 0, 0, dim);
5008         if (!bset)
5009                 return NULL;
5010         for (i = 0; i < dim; ++i) {
5011                 int k = isl_basic_set_alloc_inequality(bset);
5012                 if (k < 0)
5013                         goto error;
5014                 isl_seq_clr(bset->ineq[k], 1 + isl_basic_set_total_dim(bset));
5015                 isl_int_set_si(bset->ineq[k][1 + nparam + i], 1);
5016         }
5017         return bset;
5018 error:
5019         isl_basic_set_free(bset);
5020         return NULL;
5021 }
5022
5023 __isl_give isl_set *isl_set_split_dims(__isl_take isl_set *set,
5024         enum isl_dim_type type, unsigned first, unsigned n)
5025 {
5026         int i;
5027         isl_basic_set *nonneg = NULL;
5028         isl_basic_set *neg = NULL;
5029
5030         if (!set)
5031                 return NULL;
5032         if (n == 0)
5033                 return set;
5034
5035         isl_assert(set->ctx, first + n <= isl_set_dim(set, type), goto error);
5036
5037         for (i = 0; i < n; ++i) {
5038                 int k;
5039
5040                 neg = NULL;
5041                 nonneg = isl_basic_set_alloc_dim(isl_set_get_dim(set), 0, 0, 1);
5042                 k = isl_basic_set_alloc_inequality(nonneg);
5043                 if (k < 0)
5044                         goto error;
5045                 isl_seq_clr(nonneg->ineq[k], 1 + isl_basic_set_total_dim(nonneg));
5046                 isl_int_set_si(nonneg->ineq[k][pos(set->dim, type) + first + i], 1);
5047
5048                 neg = isl_basic_set_alloc_dim(isl_set_get_dim(set), 0, 0, 1);
5049                 k = isl_basic_set_alloc_inequality(neg);
5050                 if (k < 0)
5051                         goto error;
5052                 isl_seq_clr(neg->ineq[k], 1 + isl_basic_set_total_dim(neg));
5053                 isl_int_set_si(neg->ineq[k][0], -1);
5054                 isl_int_set_si(neg->ineq[k][pos(set->dim, type) + first + i], -1);
5055
5056                 set = isl_set_intersect(set, isl_basic_set_union(nonneg, neg));
5057         }
5058
5059         return set;
5060 error:
5061         isl_basic_set_free(nonneg);
5062         isl_basic_set_free(neg);
5063         isl_set_free(set);
5064         return NULL;
5065 }
5066
5067 int isl_set_is_equal(struct isl_set *set1, struct isl_set *set2)
5068 {
5069         return isl_map_is_equal((struct isl_map *)set1, (struct isl_map *)set2);
5070 }
5071
5072 int isl_basic_map_is_subset(
5073                 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
5074 {
5075         int is_subset;
5076         struct isl_map *map1;
5077         struct isl_map *map2;
5078
5079         if (!bmap1 || !bmap2)
5080                 return -1;
5081
5082         map1 = isl_map_from_basic_map(isl_basic_map_copy(bmap1));
5083         map2 = isl_map_from_basic_map(isl_basic_map_copy(bmap2));
5084
5085         is_subset = isl_map_is_subset(map1, map2);
5086
5087         isl_map_free(map1);
5088         isl_map_free(map2);
5089
5090         return is_subset;
5091 }
5092
5093 int isl_basic_map_is_equal(
5094                 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
5095 {
5096         int is_subset;
5097
5098         if (!bmap1 || !bmap2)
5099                 return -1;
5100         is_subset = isl_basic_map_is_subset(bmap1, bmap2);
5101         if (is_subset != 1)
5102                 return is_subset;
5103         is_subset = isl_basic_map_is_subset(bmap2, bmap1);
5104         return is_subset;
5105 }
5106
5107 int isl_basic_set_is_equal(
5108                 struct isl_basic_set *bset1, struct isl_basic_set *bset2)
5109 {
5110         return isl_basic_map_is_equal(
5111                 (struct isl_basic_map *)bset1, (struct isl_basic_map *)bset2);
5112 }
5113
5114 int isl_map_is_empty(struct isl_map *map)
5115 {
5116         int i;
5117         int is_empty;
5118
5119         if (!map)
5120                 return -1;
5121         for (i = 0; i < map->n; ++i) {
5122                 is_empty = isl_basic_map_is_empty(map->p[i]);
5123                 if (is_empty < 0)
5124                         return -1;
5125                 if (!is_empty)
5126                         return 0;
5127         }
5128         return 1;
5129 }
5130
5131 int isl_map_fast_is_empty(struct isl_map *map)
5132 {
5133         return map->n == 0;
5134 }
5135
5136 int isl_set_fast_is_empty(struct isl_set *set)
5137 {
5138         return set->n == 0;
5139 }
5140
5141 int isl_set_is_empty(struct isl_set *set)
5142 {
5143         return isl_map_is_empty((struct isl_map *)set);
5144 }
5145
5146 int isl_map_is_equal(struct isl_map *map1, struct isl_map *map2)
5147 {
5148         int is_subset;
5149
5150         if (!map1 || !map2)
5151                 return -1;
5152         is_subset = isl_map_is_subset(map1, map2);
5153         if (is_subset != 1)
5154                 return is_subset;
5155         is_subset = isl_map_is_subset(map2, map1);
5156         return is_subset;
5157 }
5158
5159 int isl_basic_map_is_strict_subset(
5160                 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
5161 {
5162         int is_subset;
5163
5164         if (!bmap1 || !bmap2)
5165                 return -1;
5166         is_subset = isl_basic_map_is_subset(bmap1, bmap2);
5167         if (is_subset != 1)
5168                 return is_subset;
5169         is_subset = isl_basic_map_is_subset(bmap2, bmap1);
5170         if (is_subset == -1)
5171                 return is_subset;
5172         return !is_subset;
5173 }
5174
5175 int isl_map_is_strict_subset(struct isl_map *map1, struct isl_map *map2)
5176 {
5177         int is_subset;
5178
5179         if (!map1 || !map2)
5180                 return -1;
5181         is_subset = isl_map_is_subset(map1, map2);
5182         if (is_subset != 1)
5183                 return is_subset;
5184         is_subset = isl_map_is_subset(map2, map1);
5185         if (is_subset == -1)
5186                 return is_subset;
5187         return !is_subset;
5188 }
5189
5190 int isl_set_is_strict_subset(__isl_keep isl_set *set1, __isl_keep isl_set *set2)
5191 {
5192         return isl_map_is_strict_subset((isl_map *)set1, (isl_map *)set2);
5193 }
5194
5195 int isl_basic_map_is_universe(struct isl_basic_map *bmap)
5196 {
5197         if (!bmap)
5198                 return -1;
5199         return bmap->n_eq == 0 && bmap->n_ineq == 0;
5200 }
5201
5202 int isl_basic_set_is_universe(struct isl_basic_set *bset)
5203 {
5204         if (!bset)
5205                 return -1;
5206         return bset->n_eq == 0 && bset->n_ineq == 0;
5207 }
5208
5209 int isl_map_fast_is_universe(__isl_keep isl_map *map)
5210 {
5211         if (!map)
5212                 return -1;
5213
5214         return map->n == 1 && isl_basic_map_is_universe(map->p[0]);
5215 }
5216
5217 int isl_set_fast_is_universe(__isl_keep isl_set *set)
5218 {
5219         return isl_map_fast_is_universe((isl_map *) set);
5220 }
5221
5222 int isl_basic_map_is_empty(struct isl_basic_map *bmap)
5223 {
5224         struct isl_basic_set *bset = NULL;
5225         struct isl_vec *sample = NULL;
5226         int empty;
5227         unsigned total;
5228
5229         if (!bmap)
5230                 return -1;
5231
5232         if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
5233                 return 1;
5234
5235         if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL)) {
5236                 struct isl_basic_map *copy = isl_basic_map_copy(bmap);
5237                 copy = isl_basic_map_convex_hull(copy);
5238                 empty = ISL_F_ISSET(copy, ISL_BASIC_MAP_EMPTY);
5239                 isl_basic_map_free(copy);
5240                 return empty;
5241         }
5242
5243         total = 1 + isl_basic_map_total_dim(bmap);
5244         if (bmap->sample && bmap->sample->size == total) {
5245                 int contains = isl_basic_map_contains(bmap, bmap->sample);
5246                 if (contains < 0)
5247                         return -1;
5248                 if (contains)
5249                         return 0;
5250         }
5251         isl_vec_free(bmap->sample);
5252         bmap->sample = NULL;
5253         bset = isl_basic_map_underlying_set(isl_basic_map_copy(bmap));
5254         if (!bset)
5255                 return -1;
5256         sample = isl_basic_set_sample_vec(bset);
5257         if (!sample)
5258                 return -1;
5259         empty = sample->size == 0;
5260         isl_vec_free(bmap->sample);
5261         bmap->sample = sample;
5262         if (empty)
5263                 ISL_F_SET(bmap, ISL_BASIC_MAP_EMPTY);
5264
5265         return empty;
5266 }
5267
5268 int isl_basic_map_fast_is_empty(struct isl_basic_map *bmap)
5269 {
5270         if (!bmap)
5271                 return -1;
5272         return ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY);
5273 }
5274
5275 int isl_basic_set_fast_is_empty(struct isl_basic_set *bset)
5276 {
5277         if (!bset)
5278                 return -1;
5279         return ISL_F_ISSET(bset, ISL_BASIC_SET_EMPTY);
5280 }
5281
5282 int isl_basic_set_is_empty(struct isl_basic_set *bset)
5283 {
5284         return isl_basic_map_is_empty((struct isl_basic_map *)bset);
5285 }
5286
5287 struct isl_map *isl_basic_map_union(
5288         struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
5289 {
5290         struct isl_map *map;
5291         if (!bmap1 || !bmap2)
5292                 return NULL;
5293
5294         isl_assert(bmap1->ctx, isl_dim_equal(bmap1->dim, bmap2->dim), goto error);
5295
5296         map = isl_map_alloc_dim(isl_dim_copy(bmap1->dim), 2, 0);
5297         if (!map)
5298                 goto error;
5299         map = isl_map_add_basic_map(map, bmap1);
5300         map = isl_map_add_basic_map(map, bmap2);
5301         return map;
5302 error:
5303         isl_basic_map_free(bmap1);
5304         isl_basic_map_free(bmap2);
5305         return NULL;
5306 }
5307
5308 struct isl_set *isl_basic_set_union(
5309                 struct isl_basic_set *bset1, struct isl_basic_set *bset2)
5310 {
5311         return (struct isl_set *)isl_basic_map_union(
5312                                             (struct isl_basic_map *)bset1,
5313                                             (struct isl_basic_map *)bset2);
5314 }
5315
5316 /* Order divs such that any div only depends on previous divs */
5317 struct isl_basic_map *isl_basic_map_order_divs(struct isl_basic_map *bmap)
5318 {
5319         int i;
5320         unsigned off = isl_dim_total(bmap->dim);
5321
5322         for (i = 0; i < bmap->n_div; ++i) {
5323                 int pos;
5324                 if (isl_int_is_zero(bmap->div[i][0]))
5325                         continue;
5326                 pos = isl_seq_first_non_zero(bmap->div[i]+1+1+off+i,
5327                                                             bmap->n_div-i);
5328                 if (pos == -1)
5329                         continue;
5330                 isl_basic_map_swap_div(bmap, i, i + pos);
5331                 --i;
5332         }
5333         return bmap;
5334 }
5335
5336 struct isl_basic_set *isl_basic_set_order_divs(struct isl_basic_set *bset)
5337 {
5338         return (struct isl_basic_set *)
5339                 isl_basic_map_order_divs((struct isl_basic_map *)bset);
5340 }
5341
5342 __isl_give isl_map *isl_map_order_divs(__isl_take isl_map *map)
5343 {
5344         int i;
5345
5346         if (!map)
5347                 return 0;
5348
5349         for (i = 0; i < map->n; ++i) {
5350                 map->p[i] = isl_basic_map_order_divs(map->p[i]);
5351                 if (!map->p[i])
5352                         goto error;
5353         }
5354
5355         return map;
5356 error:
5357         isl_map_free(map);
5358         return NULL;
5359 }
5360
5361 /* Look for a div in dst that corresponds to the div "div" in src.
5362  * The divs before "div" in src and dst are assumed to be the same.
5363  *
5364  * Returns -1 if no corresponding div was found and the position
5365  * of the corresponding div in dst otherwise.
5366  */
5367 static int find_div(struct isl_basic_map *dst,
5368                         struct isl_basic_map *src, unsigned div)
5369 {
5370         int i;
5371
5372         unsigned total = isl_dim_total(src->dim);
5373
5374         isl_assert(dst->ctx, div <= dst->n_div, return -1);
5375         for (i = div; i < dst->n_div; ++i)
5376                 if (isl_seq_eq(dst->div[i], src->div[div], 1+1+total+div) &&
5377                     isl_seq_first_non_zero(dst->div[i]+1+1+total+div,
5378                                                 dst->n_div - div) == -1)
5379                         return i;
5380         return -1;
5381 }
5382
5383 struct isl_basic_map *isl_basic_map_align_divs(
5384                 struct isl_basic_map *dst, struct isl_basic_map *src)
5385 {
5386         int i;
5387         unsigned total = isl_dim_total(src->dim);
5388
5389         if (!dst || !src)
5390                 goto error;
5391
5392         if (src->n_div == 0)
5393                 return dst;
5394
5395         for (i = 0; i < src->n_div; ++i)
5396                 isl_assert(src->ctx, !isl_int_is_zero(src->div[i][0]), goto error);
5397
5398         src = isl_basic_map_order_divs(src);
5399         dst = isl_basic_map_cow(dst);
5400         dst = isl_basic_map_extend_dim(dst, isl_dim_copy(dst->dim),
5401                         src->n_div, 0, 2 * src->n_div);
5402         if (!dst)
5403                 return NULL;
5404         for (i = 0; i < src->n_div; ++i) {
5405                 int j = find_div(dst, src, i);
5406                 if (j < 0) {
5407                         j = isl_basic_map_alloc_div(dst);
5408                         if (j < 0)
5409                                 goto error;
5410                         isl_seq_cpy(dst->div[j], src->div[i], 1+1+total+i);
5411                         isl_seq_clr(dst->div[j]+1+1+total+i, dst->n_div - i);
5412                         if (isl_basic_map_add_div_constraints(dst, j) < 0)
5413                                 goto error;
5414                 }
5415                 if (j != i)
5416                         isl_basic_map_swap_div(dst, i, j);
5417         }
5418         return dst;
5419 error:
5420         isl_basic_map_free(dst);
5421         return NULL;
5422 }
5423
5424 struct isl_basic_set *isl_basic_set_align_divs(
5425                 struct isl_basic_set *dst, struct isl_basic_set *src)
5426 {
5427         return (struct isl_basic_set *)isl_basic_map_align_divs(
5428                 (struct isl_basic_map *)dst, (struct isl_basic_map *)src);
5429 }
5430
5431 struct isl_map *isl_map_align_divs(struct isl_map *map)
5432 {
5433         int i;
5434
5435         if (!map)
5436                 return NULL;
5437         if (map->n == 0)
5438                 return map;
5439         map = isl_map_compute_divs(map);
5440         map = isl_map_cow(map);
5441         if (!map)
5442                 return NULL;
5443
5444         for (i = 1; i < map->n; ++i)
5445                 map->p[0] = isl_basic_map_align_divs(map->p[0], map->p[i]);
5446         for (i = 1; i < map->n; ++i)
5447                 map->p[i] = isl_basic_map_align_divs(map->p[i], map->p[0]);
5448
5449         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
5450         return map;
5451 }
5452
5453 struct isl_set *isl_set_align_divs(struct isl_set *set)
5454 {
5455         return (struct isl_set *)isl_map_align_divs((struct isl_map *)set);
5456 }
5457
5458 struct isl_set *isl_set_apply(struct isl_set *set, struct isl_map *map)
5459 {
5460         if (!set || !map)
5461                 goto error;
5462         isl_assert(set->ctx, isl_map_compatible_domain(map, set), goto error);
5463         map = isl_map_intersect_domain(map, set);
5464         set = isl_map_range(map);
5465         return set;
5466 error:
5467         isl_set_free(set);
5468         isl_map_free(map);
5469         return NULL;
5470 }
5471
5472 /* There is no need to cow as removing empty parts doesn't change
5473  * the meaning of the set.
5474  */
5475 struct isl_map *isl_map_remove_empty_parts(struct isl_map *map)
5476 {
5477         int i;
5478
5479         if (!map)
5480                 return NULL;
5481
5482         for (i = map->n-1; i >= 0; --i) {
5483                 if (!ISL_F_ISSET(map->p[i], ISL_BASIC_MAP_EMPTY))
5484                         continue;
5485                 isl_basic_map_free(map->p[i]);
5486                 if (i != map->n-1) {
5487                         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
5488                         map->p[i] = map->p[map->n-1];
5489                 }
5490                 map->n--;
5491         }
5492
5493         return map;
5494 }
5495
5496 struct isl_set *isl_set_remove_empty_parts(struct isl_set *set)
5497 {
5498         return (struct isl_set *)
5499                 isl_map_remove_empty_parts((struct isl_map *)set);
5500 }
5501
5502 struct isl_basic_map *isl_map_copy_basic_map(struct isl_map *map)
5503 {
5504         struct isl_basic_map *bmap;
5505         if (!map || map->n == 0)
5506                 return NULL;
5507         bmap = map->p[map->n-1];
5508         isl_assert(map->ctx, ISL_F_ISSET(bmap, ISL_BASIC_SET_FINAL), return NULL);
5509         return isl_basic_map_copy(bmap);
5510 }
5511
5512 struct isl_basic_set *isl_set_copy_basic_set(struct isl_set *set)
5513 {
5514         return (struct isl_basic_set *)
5515                 isl_map_copy_basic_map((struct isl_map *)set);
5516 }
5517
5518 __isl_give isl_map *isl_map_drop_basic_map(__isl_take isl_map *map,
5519                                                 __isl_keep isl_basic_map *bmap)
5520 {
5521         int i;
5522
5523         if (!map || !bmap)
5524                 goto error;
5525         for (i = map->n-1; i >= 0; --i) {
5526                 if (map->p[i] != bmap)
5527                         continue;
5528                 map = isl_map_cow(map);
5529                 if (!map)
5530                         goto error;
5531                 isl_basic_map_free(map->p[i]);
5532                 if (i != map->n-1) {
5533                         ISL_F_CLR(map, ISL_SET_NORMALIZED);
5534                         map->p[i] = map->p[map->n-1];
5535                 }
5536                 map->n--;
5537                 return map;
5538         }
5539         return map;
5540 error:
5541         isl_map_free(map);
5542         return NULL;
5543 }
5544
5545 struct isl_set *isl_set_drop_basic_set(struct isl_set *set,
5546                                                 struct isl_basic_set *bset)
5547 {
5548         return (struct isl_set *)isl_map_drop_basic_map((struct isl_map *)set,
5549                                                 (struct isl_basic_map *)bset);
5550 }
5551
5552 /* Given two basic sets bset1 and bset2, compute the maximal difference
5553  * between the values of dimension pos in bset1 and those in bset2
5554  * for any common value of the parameters and dimensions preceding pos.
5555  */
5556 static enum isl_lp_result basic_set_maximal_difference_at(
5557         __isl_keep isl_basic_set *bset1, __isl_keep isl_basic_set *bset2,
5558         int pos, isl_int *opt)
5559 {
5560         struct isl_dim *dims;
5561         struct isl_basic_map *bmap1 = NULL;
5562         struct isl_basic_map *bmap2 = NULL;
5563         struct isl_ctx *ctx;
5564         struct isl_vec *obj;
5565         unsigned total;
5566         unsigned nparam;
5567         unsigned dim1, dim2;
5568         enum isl_lp_result res;
5569
5570         if (!bset1 || !bset2)
5571                 return isl_lp_error;
5572
5573         nparam = isl_basic_set_n_param(bset1);
5574         dim1 = isl_basic_set_n_dim(bset1);
5575         dim2 = isl_basic_set_n_dim(bset2);
5576         dims = isl_dim_alloc(bset1->ctx, nparam, pos, dim1 - pos);
5577         bmap1 = isl_basic_map_from_basic_set(isl_basic_set_copy(bset1), dims);
5578         dims = isl_dim_alloc(bset2->ctx, nparam, pos, dim2 - pos);
5579         bmap2 = isl_basic_map_from_basic_set(isl_basic_set_copy(bset2), dims);
5580         if (!bmap1 || !bmap2)
5581                 goto error;
5582         bmap1 = isl_basic_map_cow(bmap1);
5583         bmap1 = isl_basic_map_extend(bmap1, nparam,
5584                         pos, (dim1 - pos) + (dim2 - pos),
5585                         bmap2->n_div, bmap2->n_eq, bmap2->n_ineq);
5586         bmap1 = add_constraints(bmap1, bmap2, 0, dim1 - pos);
5587         if (!bmap1)
5588                 goto error;
5589         total = isl_basic_map_total_dim(bmap1);
5590         ctx = bmap1->ctx;
5591         obj = isl_vec_alloc(ctx, 1 + total);
5592         isl_seq_clr(obj->block.data, 1 + total);
5593         isl_int_set_si(obj->block.data[1+nparam+pos], 1);
5594         isl_int_set_si(obj->block.data[1+nparam+pos+(dim1-pos)], -1);
5595         if (!obj)
5596                 goto error;
5597         res = isl_basic_map_solve_lp(bmap1, 1, obj->block.data, ctx->one,
5598                                         opt, NULL, NULL);
5599         isl_basic_map_free(bmap1);
5600         isl_vec_free(obj);
5601         return res;
5602 error:
5603         isl_basic_map_free(bmap1);
5604         isl_basic_map_free(bmap2);
5605         return isl_lp_error;
5606 }
5607
5608 /* Given two _disjoint_ basic sets bset1 and bset2, check whether
5609  * for any common value of the parameters and dimensions preceding pos
5610  * in both basic sets, the values of dimension pos in bset1 are
5611  * smaller or larger than those in bset2.
5612  *
5613  * Returns
5614  *       1 if bset1 follows bset2
5615  *      -1 if bset1 precedes bset2
5616  *       0 if bset1 and bset2 are incomparable
5617  *      -2 if some error occurred.
5618  */
5619 int isl_basic_set_compare_at(struct isl_basic_set *bset1,
5620         struct isl_basic_set *bset2, int pos)
5621 {
5622         isl_int opt;
5623         enum isl_lp_result res;
5624         int cmp;
5625
5626         isl_int_init(opt);
5627
5628         res = basic_set_maximal_difference_at(bset1, bset2, pos, &opt);
5629
5630         if (res == isl_lp_empty)
5631                 cmp = 0;
5632         else if ((res == isl_lp_ok && isl_int_is_pos(opt)) ||
5633                   res == isl_lp_unbounded)
5634                 cmp = 1;
5635         else if (res == isl_lp_ok && isl_int_is_neg(opt))
5636                 cmp = -1;
5637         else
5638                 cmp = -2;
5639
5640         isl_int_clear(opt);
5641         return cmp;
5642 }
5643
5644 /* Given two basic sets bset1 and bset2, check whether
5645  * for any common value of the parameters and dimensions preceding pos
5646  * there is a value of dimension pos in bset1 that is larger
5647  * than a value of the same dimension in bset2.
5648  *
5649  * Return
5650  *       1 if there exists such a pair
5651  *       0 if there is no such pair, but there is a pair of equal values
5652  *      -1 otherwise
5653  *      -2 if some error occurred.
5654  */
5655 int isl_basic_set_follows_at(__isl_keep isl_basic_set *bset1,
5656         __isl_keep isl_basic_set *bset2, int pos)
5657 {
5658         isl_int opt;
5659         enum isl_lp_result res;
5660         int cmp;
5661
5662         isl_int_init(opt);
5663
5664         res = basic_set_maximal_difference_at(bset1, bset2, pos, &opt);
5665
5666         if (res == isl_lp_empty)
5667                 cmp = -1;
5668         else if ((res == isl_lp_ok && isl_int_is_pos(opt)) ||
5669                   res == isl_lp_unbounded)
5670                 cmp = 1;
5671         else if (res == isl_lp_ok && isl_int_is_neg(opt))
5672                 cmp = -1;
5673         else if (res == isl_lp_ok)
5674                 cmp = 0;
5675         else
5676                 cmp = -2;
5677
5678         isl_int_clear(opt);
5679         return cmp;
5680 }
5681
5682 /* Given two sets set1 and set2, check whether
5683  * for any common value of the parameters and dimensions preceding pos
5684  * there is a value of dimension pos in set1 that is larger
5685  * than a value of the same dimension in set2.
5686  *
5687  * Return
5688  *       1 if there exists such a pair
5689  *       0 if there is no such pair, but there is a pair of equal values
5690  *      -1 otherwise
5691  *      -2 if some error occurred.
5692  */
5693 int isl_set_follows_at(__isl_keep isl_set *set1,
5694         __isl_keep isl_set *set2, int pos)
5695 {
5696         int i, j;
5697         int follows = -1;
5698
5699         if (!set1 || !set2)
5700                 return -2;
5701
5702         for (i = 0; i < set1->n; ++i)
5703                 for (j = 0; j < set2->n; ++j) {
5704                         int f;
5705                         f = isl_basic_set_follows_at(set1->p[i], set2->p[j], pos);
5706                         if (f == 1 || f == -2)
5707                                 return f;
5708                         if (f > follows)
5709                                 follows = f;
5710                 }
5711
5712         return follows;
5713 }
5714
5715 static int isl_basic_map_fast_has_fixed_var(struct isl_basic_map *bmap,
5716         unsigned pos, isl_int *val)
5717 {
5718         int i;
5719         int d;
5720         unsigned total;
5721
5722         if (!bmap)
5723                 return -1;
5724         total = isl_basic_map_total_dim(bmap);
5725         for (i = 0, d = total-1; i < bmap->n_eq && d+1 > pos; ++i) {
5726                 for (; d+1 > pos; --d)
5727                         if (!isl_int_is_zero(bmap->eq[i][1+d]))
5728                                 break;
5729                 if (d != pos)
5730                         continue;
5731                 if (isl_seq_first_non_zero(bmap->eq[i]+1, d) != -1)
5732                         return 0;
5733                 if (isl_seq_first_non_zero(bmap->eq[i]+1+d+1, total-d-1) != -1)
5734                         return 0;
5735                 if (!isl_int_is_one(bmap->eq[i][1+d]))
5736                         return 0;
5737                 if (val)
5738                         isl_int_neg(*val, bmap->eq[i][0]);
5739                 return 1;
5740         }
5741         return 0;
5742 }
5743
5744 static int isl_map_fast_has_fixed_var(struct isl_map *map,
5745         unsigned pos, isl_int *val)
5746 {
5747         int i;
5748         isl_int v;
5749         isl_int tmp;
5750         int fixed;
5751
5752         if (!map)
5753                 return -1;
5754         if (map->n == 0)
5755                 return 0;
5756         if (map->n == 1)
5757                 return isl_basic_map_fast_has_fixed_var(map->p[0], pos, val);
5758         isl_int_init(v);
5759         isl_int_init(tmp);
5760         fixed = isl_basic_map_fast_has_fixed_var(map->p[0], pos, &v);
5761         for (i = 1; fixed == 1 && i < map->n; ++i) {
5762                 fixed = isl_basic_map_fast_has_fixed_var(map->p[i], pos, &tmp);
5763                 if (fixed == 1 && isl_int_ne(tmp, v))
5764                         fixed = 0;
5765         }
5766         if (val)
5767                 isl_int_set(*val, v);
5768         isl_int_clear(tmp);
5769         isl_int_clear(v);
5770         return fixed;
5771 }
5772
5773 static int isl_basic_set_fast_has_fixed_var(struct isl_basic_set *bset,
5774         unsigned pos, isl_int *val)
5775 {
5776         return isl_basic_map_fast_has_fixed_var((struct isl_basic_map *)bset,
5777                                                 pos, val);
5778 }
5779
5780 static int isl_set_fast_has_fixed_var(struct isl_set *set, unsigned pos,
5781         isl_int *val)
5782 {
5783         return isl_map_fast_has_fixed_var((struct isl_map *)set, pos, val);
5784 }
5785
5786 int isl_basic_map_fast_is_fixed(struct isl_basic_map *bmap,
5787         enum isl_dim_type type, unsigned pos, isl_int *val)
5788 {
5789         if (pos >= isl_basic_map_dim(bmap, type))
5790                 return -1;
5791         return isl_basic_map_fast_has_fixed_var(bmap,
5792                 isl_basic_map_offset(bmap, type) - 1 + pos, val);
5793 }
5794
5795 int isl_map_fast_is_fixed(struct isl_map *map,
5796         enum isl_dim_type type, unsigned pos, isl_int *val)
5797 {
5798         if (pos >= isl_map_dim(map, type))
5799                 return -1;
5800         return isl_map_fast_has_fixed_var(map,
5801                 map_offset(map, type) - 1 + pos, val);
5802 }
5803
5804 /* Check if dimension dim has fixed value and if so and if val is not NULL,
5805  * then return this fixed value in *val.
5806  */
5807 int isl_basic_set_fast_dim_is_fixed(struct isl_basic_set *bset, unsigned dim,
5808         isl_int *val)
5809 {
5810         return isl_basic_set_fast_has_fixed_var(bset,
5811                                         isl_basic_set_n_param(bset) + dim, val);
5812 }
5813
5814 /* Check if dimension dim has fixed value and if so and if val is not NULL,
5815  * then return this fixed value in *val.
5816  */
5817 int isl_set_fast_dim_is_fixed(struct isl_set *set, unsigned dim, isl_int *val)
5818 {
5819         return isl_set_fast_has_fixed_var(set, isl_set_n_param(set) + dim, val);
5820 }
5821
5822 /* Check if input variable in has fixed value and if so and if val is not NULL,
5823  * then return this fixed value in *val.
5824  */
5825 int isl_map_fast_input_is_fixed(struct isl_map *map, unsigned in, isl_int *val)
5826 {
5827         return isl_map_fast_has_fixed_var(map, isl_map_n_param(map) + in, val);
5828 }
5829
5830 /* Check if dimension dim has an (obvious) fixed lower bound and if so
5831  * and if val is not NULL, then return this lower bound in *val.
5832  */
5833 int isl_basic_set_fast_dim_has_fixed_lower_bound(struct isl_basic_set *bset,
5834         unsigned dim, isl_int *val)
5835 {
5836         int i, i_eq = -1, i_ineq = -1;
5837         isl_int *c;
5838         unsigned total;
5839         unsigned nparam;
5840
5841         if (!bset)
5842                 return -1;
5843         total = isl_basic_set_total_dim(bset);
5844         nparam = isl_basic_set_n_param(bset);
5845         for (i = 0; i < bset->n_eq; ++i) {
5846                 if (isl_int_is_zero(bset->eq[i][1+nparam+dim]))
5847                         continue;
5848                 if (i_eq != -1)
5849                         return 0;
5850                 i_eq = i;
5851         }
5852         for (i = 0; i < bset->n_ineq; ++i) {
5853                 if (!isl_int_is_pos(bset->ineq[i][1+nparam+dim]))
5854                         continue;
5855                 if (i_eq != -1 || i_ineq != -1)
5856                         return 0;
5857                 i_ineq = i;
5858         }
5859         if (i_eq == -1 && i_ineq == -1)
5860                 return 0;
5861         c = i_eq != -1 ? bset->eq[i_eq] : bset->ineq[i_ineq];
5862         /* The coefficient should always be one due to normalization. */
5863         if (!isl_int_is_one(c[1+nparam+dim]))
5864                 return 0;
5865         if (isl_seq_first_non_zero(c+1, nparam+dim) != -1)
5866                 return 0;
5867         if (isl_seq_first_non_zero(c+1+nparam+dim+1,
5868                                         total - nparam - dim - 1) != -1)
5869                 return 0;
5870         if (val)
5871                 isl_int_neg(*val, c[0]);
5872         return 1;
5873 }
5874
5875 int isl_set_fast_dim_has_fixed_lower_bound(struct isl_set *set,
5876         unsigned dim, isl_int *val)
5877 {
5878         int i;
5879         isl_int v;
5880         isl_int tmp;
5881         int fixed;
5882
5883         if (!set)
5884                 return -1;
5885         if (set->n == 0)
5886                 return 0;
5887         if (set->n == 1)
5888                 return isl_basic_set_fast_dim_has_fixed_lower_bound(set->p[0],
5889                                                                 dim, val);
5890         isl_int_init(v);
5891         isl_int_init(tmp);
5892         fixed = isl_basic_set_fast_dim_has_fixed_lower_bound(set->p[0],
5893                                                                 dim, &v);
5894         for (i = 1; fixed == 1 && i < set->n; ++i) {
5895                 fixed = isl_basic_set_fast_dim_has_fixed_lower_bound(set->p[i],
5896                                                                 dim, &tmp);
5897                 if (fixed == 1 && isl_int_ne(tmp, v))
5898                         fixed = 0;
5899         }
5900         if (val)
5901                 isl_int_set(*val, v);
5902         isl_int_clear(tmp);
5903         isl_int_clear(v);
5904         return fixed;
5905 }
5906
5907 struct constraint {
5908         unsigned        size;
5909         isl_int         *c;
5910 };
5911
5912 static int qsort_constraint_cmp(const void *p1, const void *p2)
5913 {
5914         const struct constraint *c1 = (const struct constraint *)p1;
5915         const struct constraint *c2 = (const struct constraint *)p2;
5916         unsigned size = isl_min(c1->size, c2->size);
5917         return isl_seq_cmp(c1->c, c2->c, size);
5918 }
5919
5920 static struct isl_basic_map *isl_basic_map_sort_constraints(
5921         struct isl_basic_map *bmap)
5922 {
5923         int i;
5924         struct constraint *c;
5925         unsigned total;
5926
5927         if (!bmap)
5928                 return NULL;
5929         total = isl_basic_map_total_dim(bmap);
5930         c = isl_alloc_array(bmap->ctx, struct constraint, bmap->n_ineq);
5931         if (!c)
5932                 goto error;
5933         for (i = 0; i < bmap->n_ineq; ++i) {
5934                 c[i].size = total;
5935                 c[i].c = bmap->ineq[i];
5936         }
5937         qsort(c, bmap->n_ineq, sizeof(struct constraint), qsort_constraint_cmp);
5938         for (i = 0; i < bmap->n_ineq; ++i)
5939                 bmap->ineq[i] = c[i].c;
5940         free(c);
5941         return bmap;
5942 error:
5943         isl_basic_map_free(bmap);
5944         return NULL;
5945 }
5946
5947 struct isl_basic_map *isl_basic_map_normalize(struct isl_basic_map *bmap)
5948 {
5949         if (!bmap)
5950                 return NULL;
5951         if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_NORMALIZED))
5952                 return bmap;
5953         bmap = isl_basic_map_convex_hull(bmap);
5954         bmap = isl_basic_map_sort_constraints(bmap);
5955         ISL_F_SET(bmap, ISL_BASIC_MAP_NORMALIZED);
5956         return bmap;
5957 }
5958
5959 struct isl_basic_set *isl_basic_set_normalize(struct isl_basic_set *bset)
5960 {
5961         return (struct isl_basic_set *)isl_basic_map_normalize(
5962                                                 (struct isl_basic_map *)bset);
5963 }
5964
5965 static int isl_basic_map_fast_cmp(const struct isl_basic_map *bmap1,
5966         const struct isl_basic_map *bmap2)
5967 {
5968         int i, cmp;
5969         unsigned total;
5970
5971         if (bmap1 == bmap2)
5972                 return 0;
5973         if (isl_basic_map_n_param(bmap1) != isl_basic_map_n_param(bmap2))
5974                 return isl_basic_map_n_param(bmap1) - isl_basic_map_n_param(bmap2);
5975         if (isl_basic_map_n_in(bmap1) != isl_basic_map_n_in(bmap2))
5976                 return isl_basic_map_n_out(bmap1) - isl_basic_map_n_out(bmap2);
5977         if (isl_basic_map_n_out(bmap1) != isl_basic_map_n_out(bmap2))
5978                 return isl_basic_map_n_out(bmap1) - isl_basic_map_n_out(bmap2);
5979         if (ISL_F_ISSET(bmap1, ISL_BASIC_MAP_EMPTY) &&
5980             ISL_F_ISSET(bmap2, ISL_BASIC_MAP_EMPTY))
5981                 return 0;
5982         if (ISL_F_ISSET(bmap1, ISL_BASIC_MAP_EMPTY))
5983                 return 1;
5984         if (ISL_F_ISSET(bmap2, ISL_BASIC_MAP_EMPTY))
5985                 return -1;
5986         if (bmap1->n_eq != bmap2->n_eq)
5987                 return bmap1->n_eq - bmap2->n_eq;
5988         if (bmap1->n_ineq != bmap2->n_ineq)
5989                 return bmap1->n_ineq - bmap2->n_ineq;
5990         if (bmap1->n_div != bmap2->n_div)
5991                 return bmap1->n_div - bmap2->n_div;
5992         total = isl_basic_map_total_dim(bmap1);
5993         for (i = 0; i < bmap1->n_eq; ++i) {
5994                 cmp = isl_seq_cmp(bmap1->eq[i], bmap2->eq[i], 1+total);
5995                 if (cmp)
5996                         return cmp;
5997         }
5998         for (i = 0; i < bmap1->n_ineq; ++i) {
5999                 cmp = isl_seq_cmp(bmap1->ineq[i], bmap2->ineq[i], 1+total);
6000                 if (cmp)
6001                         return cmp;
6002         }
6003         for (i = 0; i < bmap1->n_div; ++i) {
6004                 cmp = isl_seq_cmp(bmap1->div[i], bmap2->div[i], 1+1+total);
6005                 if (cmp)
6006                         return cmp;
6007         }
6008         return 0;
6009 }
6010
6011 static int isl_basic_map_fast_is_equal(struct isl_basic_map *bmap1,
6012         struct isl_basic_map *bmap2)
6013 {
6014         return isl_basic_map_fast_cmp(bmap1, bmap2) == 0;
6015 }
6016
6017 static int qsort_bmap_cmp(const void *p1, const void *p2)
6018 {
6019         const struct isl_basic_map *bmap1 = *(const struct isl_basic_map **)p1;
6020         const struct isl_basic_map *bmap2 = *(const struct isl_basic_map **)p2;
6021
6022         return isl_basic_map_fast_cmp(bmap1, bmap2);
6023 }
6024
6025 /* We normalize in place, but if anything goes wrong we need
6026  * to return NULL, so we need to make sure we don't change the
6027  * meaning of any possible other copies of map.
6028  */
6029 struct isl_map *isl_map_normalize(struct isl_map *map)
6030 {
6031         int i, j;
6032         struct isl_basic_map *bmap;
6033
6034         if (!map)
6035                 return NULL;
6036         if (ISL_F_ISSET(map, ISL_MAP_NORMALIZED))
6037                 return map;
6038         for (i = 0; i < map->n; ++i) {
6039                 bmap = isl_basic_map_normalize(isl_basic_map_copy(map->p[i]));
6040                 if (!bmap)
6041                         goto error;
6042                 isl_basic_map_free(map->p[i]);
6043                 map->p[i] = bmap;
6044         }
6045         qsort(map->p, map->n, sizeof(struct isl_basic_map *), qsort_bmap_cmp);
6046         ISL_F_SET(map, ISL_MAP_NORMALIZED);
6047         map = isl_map_remove_empty_parts(map);
6048         if (!map)
6049                 return NULL;
6050         for (i = map->n - 1; i >= 1; --i) {
6051                 if (!isl_basic_map_fast_is_equal(map->p[i-1], map->p[i]))
6052                         continue;
6053                 isl_basic_map_free(map->p[i-1]);
6054                 for (j = i; j < map->n; ++j)
6055                         map->p[j-1] = map->p[j];
6056                 map->n--;
6057         }
6058         return map;
6059 error:
6060         isl_map_free(map);
6061         return NULL;
6062
6063 }
6064
6065 struct isl_set *isl_set_normalize(struct isl_set *set)
6066 {
6067         return (struct isl_set *)isl_map_normalize((struct isl_map *)set);
6068 }
6069
6070 int isl_map_fast_is_equal(struct isl_map *map1, struct isl_map *map2)
6071 {
6072         int i;
6073         int equal;
6074
6075         if (!map1 || !map2)
6076                 return -1;
6077
6078         if (map1 == map2)
6079                 return 1;
6080         if (!isl_dim_equal(map1->dim, map2->dim))
6081                 return 0;
6082
6083         map1 = isl_map_copy(map1);
6084         map2 = isl_map_copy(map2);
6085         map1 = isl_map_normalize(map1);
6086         map2 = isl_map_normalize(map2);
6087         if (!map1 || !map2)
6088                 goto error;
6089         equal = map1->n == map2->n;
6090         for (i = 0; equal && i < map1->n; ++i) {
6091                 equal = isl_basic_map_fast_is_equal(map1->p[i], map2->p[i]);
6092                 if (equal < 0)
6093                         goto error;
6094         }
6095         isl_map_free(map1);
6096         isl_map_free(map2);
6097         return equal;
6098 error:
6099         isl_map_free(map1);
6100         isl_map_free(map2);
6101         return -1;
6102 }
6103
6104 int isl_set_fast_is_equal(struct isl_set *set1, struct isl_set *set2)
6105 {
6106         return isl_map_fast_is_equal((struct isl_map *)set1,
6107                                                 (struct isl_map *)set2);
6108 }
6109
6110 /* Return an interval that ranges from min to max (inclusive)
6111  */
6112 struct isl_basic_set *isl_basic_set_interval(struct isl_ctx *ctx,
6113         isl_int min, isl_int max)
6114 {
6115         int k;
6116         struct isl_basic_set *bset = NULL;
6117
6118         bset = isl_basic_set_alloc(ctx, 0, 1, 0, 0, 2);
6119         if (!bset)
6120                 goto error;
6121
6122         k = isl_basic_set_alloc_inequality(bset);
6123         if (k < 0)
6124                 goto error;
6125         isl_int_set_si(bset->ineq[k][1], 1);
6126         isl_int_neg(bset->ineq[k][0], min);
6127
6128         k = isl_basic_set_alloc_inequality(bset);
6129         if (k < 0)
6130                 goto error;
6131         isl_int_set_si(bset->ineq[k][1], -1);
6132         isl_int_set(bset->ineq[k][0], max);
6133
6134         return bset;
6135 error:
6136         isl_basic_set_free(bset);
6137         return NULL;
6138 }
6139
6140 /* Return the Cartesian product of the basic sets in list (in the given order).
6141  */
6142 struct isl_basic_set *isl_basic_set_product(struct isl_basic_set_list *list)
6143 {
6144         int i;
6145         unsigned dim;
6146         unsigned nparam;
6147         unsigned extra;
6148         unsigned n_eq;
6149         unsigned n_ineq;
6150         struct isl_basic_set *product = NULL;
6151
6152         if (!list)
6153                 goto error;
6154         isl_assert(list->ctx, list->n > 0, goto error);
6155         isl_assert(list->ctx, list->p[0], goto error);
6156         nparam = isl_basic_set_n_param(list->p[0]);
6157         dim = isl_basic_set_n_dim(list->p[0]);
6158         extra = list->p[0]->n_div;
6159         n_eq = list->p[0]->n_eq;
6160         n_ineq = list->p[0]->n_ineq;
6161         for (i = 1; i < list->n; ++i) {
6162                 isl_assert(list->ctx, list->p[i], goto error);
6163                 isl_assert(list->ctx,
6164                     nparam == isl_basic_set_n_param(list->p[i]), goto error);
6165                 dim += isl_basic_set_n_dim(list->p[i]);
6166                 extra += list->p[i]->n_div;
6167                 n_eq += list->p[i]->n_eq;
6168                 n_ineq += list->p[i]->n_ineq;
6169         }
6170         product = isl_basic_set_alloc(list->ctx, nparam, dim, extra,
6171                                         n_eq, n_ineq);
6172         if (!product)
6173                 goto error;
6174         dim = 0;
6175         for (i = 0; i < list->n; ++i) {
6176                 isl_basic_set_add_constraints(product,
6177                                         isl_basic_set_copy(list->p[i]), dim);
6178                 dim += isl_basic_set_n_dim(list->p[i]);
6179         }
6180         isl_basic_set_list_free(list);
6181         return product;
6182 error:
6183         isl_basic_set_free(product);
6184         isl_basic_set_list_free(list);
6185         return NULL;
6186 }
6187
6188 struct isl_basic_map *isl_basic_map_product(
6189                 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
6190 {
6191         struct isl_dim *dim_result = NULL;
6192         struct isl_basic_map *bmap;
6193         unsigned in1, in2, out1, out2, nparam, total, pos;
6194         struct isl_dim_map *dim_map1, *dim_map2;
6195
6196         if (!bmap1 || !bmap2)
6197                 goto error;
6198
6199         isl_assert(bmap1->ctx, isl_dim_match(bmap1->dim, isl_dim_param,
6200                                      bmap2->dim, isl_dim_param), goto error);
6201         dim_result = isl_dim_product(isl_dim_copy(bmap1->dim),
6202                                                    isl_dim_copy(bmap2->dim));
6203
6204         in1 = isl_basic_map_n_in(bmap1);
6205         in2 = isl_basic_map_n_in(bmap2);
6206         out1 = isl_basic_map_n_out(bmap1);
6207         out2 = isl_basic_map_n_out(bmap2);
6208         nparam = isl_basic_map_n_param(bmap1);
6209
6210         total = nparam + in1 + in2 + out1 + out2 + bmap1->n_div + bmap2->n_div;
6211         dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
6212         dim_map2 = isl_dim_map_alloc(bmap1->ctx, total);
6213         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
6214         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos = 0);
6215         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
6216         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos += in1);
6217         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += in2);
6218         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos += out1);
6219         isl_dim_map_div(dim_map1, bmap1, pos += out2);
6220         isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
6221
6222         bmap = isl_basic_map_alloc_dim(dim_result,
6223                         bmap1->n_div + bmap2->n_div,
6224                         bmap1->n_eq + bmap2->n_eq,
6225                         bmap1->n_ineq + bmap2->n_ineq);
6226         bmap = add_constraints_dim_map(bmap, bmap1, dim_map1);
6227         bmap = add_constraints_dim_map(bmap, bmap2, dim_map2);
6228         bmap = isl_basic_map_simplify(bmap);
6229         return isl_basic_map_finalize(bmap);
6230 error:
6231         isl_basic_map_free(bmap1);
6232         isl_basic_map_free(bmap2);
6233         return NULL;
6234 }
6235
6236 /* Given two maps A -> B and C -> D, construct a map (A, C) -> (B, D)
6237  */
6238 struct isl_map *isl_map_product(struct isl_map *map1, struct isl_map *map2)
6239 {
6240         unsigned flags = 0;
6241         struct isl_map *result;
6242         int i, j;
6243
6244         if (!map1 || !map2)
6245                 goto error;
6246
6247         isl_assert(map1->ctx, isl_dim_match(map1->dim, isl_dim_param,
6248                                          map2->dim, isl_dim_param), goto error);
6249
6250         if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) &&
6251             ISL_F_ISSET(map2, ISL_MAP_DISJOINT))
6252                 ISL_FL_SET(flags, ISL_MAP_DISJOINT);
6253
6254         result = isl_map_alloc_dim(isl_dim_product(isl_dim_copy(map1->dim),
6255                                                    isl_dim_copy(map2->dim)),
6256                                 map1->n * map2->n, flags);
6257         if (!result)
6258                 goto error;
6259         for (i = 0; i < map1->n; ++i)
6260                 for (j = 0; j < map2->n; ++j) {
6261                         struct isl_basic_map *part;
6262                         part = isl_basic_map_product(
6263                                     isl_basic_map_copy(map1->p[i]),
6264                                     isl_basic_map_copy(map2->p[j]));
6265                         if (isl_basic_map_is_empty(part))
6266                                 isl_basic_map_free(part);
6267                         else
6268                                 result = isl_map_add_basic_map(result, part);
6269                         if (!result)
6270                                 goto error;
6271                 }
6272         isl_map_free(map1);
6273         isl_map_free(map2);
6274         return result;
6275 error:
6276         isl_map_free(map1);
6277         isl_map_free(map2);
6278         return NULL;
6279 }
6280
6281 /* Given two set A and B, construct its Cartesian product A x B.
6282  */
6283 struct isl_set *isl_set_product(struct isl_set *set1, struct isl_set *set2)
6284 {
6285         return (struct isl_set *)isl_map_product((struct isl_map *)set1,
6286                                                  (struct isl_map *)set2);
6287 }
6288
6289 uint32_t isl_basic_set_get_hash(struct isl_basic_set *bset)
6290 {
6291         int i;
6292         uint32_t hash = isl_hash_init();
6293         unsigned total;
6294
6295         if (!bset)
6296                 return 0;
6297         bset = isl_basic_set_copy(bset);
6298         bset = isl_basic_set_normalize(bset);
6299         if (!bset)
6300                 return 0;
6301         total = isl_basic_set_total_dim(bset);
6302         isl_hash_byte(hash, bset->n_eq & 0xFF);
6303         for (i = 0; i < bset->n_eq; ++i) {
6304                 uint32_t c_hash;
6305                 c_hash = isl_seq_get_hash(bset->eq[i], 1 + total);
6306                 isl_hash_hash(hash, c_hash);
6307         }
6308         isl_hash_byte(hash, bset->n_ineq & 0xFF);
6309         for (i = 0; i < bset->n_ineq; ++i) {
6310                 uint32_t c_hash;
6311                 c_hash = isl_seq_get_hash(bset->ineq[i], 1 + total);
6312                 isl_hash_hash(hash, c_hash);
6313         }
6314         isl_hash_byte(hash, bset->n_div & 0xFF);
6315         for (i = 0; i < bset->n_div; ++i) {
6316                 uint32_t c_hash;
6317                 if (isl_int_is_zero(bset->div[i][0]))
6318                         continue;
6319                 isl_hash_byte(hash, i & 0xFF);
6320                 c_hash = isl_seq_get_hash(bset->div[i], 1 + 1 + total);
6321                 isl_hash_hash(hash, c_hash);
6322         }
6323         isl_basic_set_free(bset);
6324         return hash;
6325 }
6326
6327 uint32_t isl_set_get_hash(struct isl_set *set)
6328 {
6329         int i;
6330         uint32_t hash;
6331
6332         if (!set)
6333                 return 0;
6334         set = isl_set_copy(set);
6335         set = isl_set_normalize(set);
6336         if (!set)
6337                 return 0;
6338
6339         hash = isl_hash_init();
6340         for (i = 0; i < set->n; ++i) {
6341                 uint32_t bset_hash;
6342                 bset_hash = isl_basic_set_get_hash(set->p[i]);
6343                 isl_hash_hash(hash, bset_hash);
6344         }
6345
6346         isl_set_free(set);
6347
6348         return hash;
6349 }
6350
6351 /* Check if the value for dimension dim is completely determined
6352  * by the values of the other parameters and variables.
6353  * That is, check if dimension dim is involved in an equality.
6354  */
6355 int isl_basic_set_dim_is_unique(struct isl_basic_set *bset, unsigned dim)
6356 {
6357         int i;
6358         unsigned nparam;
6359
6360         if (!bset)
6361                 return -1;
6362         nparam = isl_basic_set_n_param(bset);
6363         for (i = 0; i < bset->n_eq; ++i)
6364                 if (!isl_int_is_zero(bset->eq[i][1 + nparam + dim]))
6365                         return 1;
6366         return 0;
6367 }
6368
6369 /* Check if the value for dimension dim is completely determined
6370  * by the values of the other parameters and variables.
6371  * That is, check if dimension dim is involved in an equality
6372  * for each of the subsets.
6373  */
6374 int isl_set_dim_is_unique(struct isl_set *set, unsigned dim)
6375 {
6376         int i;
6377
6378         if (!set)
6379                 return -1;
6380         for (i = 0; i < set->n; ++i) {
6381                 int unique;
6382                 unique = isl_basic_set_dim_is_unique(set->p[i], dim);
6383                 if (unique != 1)
6384                         return unique;
6385         }
6386         return 1;
6387 }
6388
6389 int isl_map_foreach_basic_map(__isl_keep isl_map *map,
6390         int (*fn)(__isl_take isl_basic_map *bmap, void *user), void *user)
6391 {
6392         int i;
6393
6394         if (!map)
6395                 return -1;
6396
6397         for (i = 0; i < map->n; ++i)
6398                 if (fn(isl_basic_map_copy(map->p[i]), user) < 0)
6399                         return -1;
6400
6401         return 0;
6402 }
6403
6404 int isl_set_foreach_basic_set(__isl_keep isl_set *set,
6405         int (*fn)(__isl_take isl_basic_set *bset, void *user), void *user)
6406 {
6407         int i;
6408
6409         if (!set)
6410                 return -1;
6411
6412         for (i = 0; i < set->n; ++i)
6413                 if (fn(isl_basic_set_copy(set->p[i]), user) < 0)
6414                         return -1;
6415
6416         return 0;
6417 }
6418
6419 __isl_give isl_basic_set *isl_basic_set_lift(__isl_take isl_basic_set *bset)
6420 {
6421         struct isl_dim *dim;
6422
6423         if (!bset)
6424                 return NULL;
6425
6426         if (bset->n_div == 0)
6427                 return bset;
6428
6429         bset = isl_basic_set_cow(bset);
6430         if (!bset)
6431                 return NULL;
6432
6433         dim = isl_basic_set_get_dim(bset);
6434         dim = isl_dim_add(dim, isl_dim_set, bset->n_div);
6435         if (!dim)
6436                 goto error;
6437         isl_dim_free(bset->dim);
6438         bset->dim = dim;
6439         bset->n_div = 0;
6440
6441         return bset;
6442 error:
6443         isl_basic_set_free(bset);
6444         return NULL;
6445 }
6446
6447 __isl_give isl_set *isl_set_lift(__isl_take isl_set *set)
6448 {
6449         int i;
6450         struct isl_dim *dim;
6451         unsigned n_div;
6452
6453         set = isl_set_align_divs(set);
6454
6455         if (!set)
6456                 return NULL;
6457         if (set->n == 0 || set->p[0]->n_div == 0)
6458                 return set;
6459
6460         set = isl_set_cow(set);
6461         if (!set)
6462                 return NULL;
6463
6464         n_div = set->p[0]->n_div;
6465         dim = isl_set_get_dim(set);
6466         dim = isl_dim_add(dim, isl_dim_set, n_div);
6467         if (!dim)
6468                 goto error;
6469         isl_dim_free(set->dim);
6470         set->dim = dim;
6471
6472         for (i = 0; i < set->n; ++i) {
6473                 set->p[i] = isl_basic_set_lift(set->p[i]);
6474                 if (!set->p[i])
6475                         goto error;
6476         }
6477
6478         return set;
6479 error:
6480         isl_set_free(set);
6481         return NULL;
6482 }
6483
6484 __isl_give isl_map *isl_set_lifting(__isl_take isl_set *set)
6485 {
6486         struct isl_dim *dim;
6487         struct isl_basic_map *bmap;
6488         unsigned n_set;
6489         unsigned n_div;
6490         unsigned n_param;
6491         unsigned total;
6492         int i, k, l;
6493
6494         set = isl_set_align_divs(set);
6495
6496         if (!set)
6497                 return NULL;
6498
6499         dim = isl_set_get_dim(set);
6500         if (set->n == 0 || set->p[0]->n_div == 0) {
6501                 isl_set_free(set);
6502                 return isl_map_identity(dim);
6503         }
6504
6505         n_div = set->p[0]->n_div;
6506         dim = isl_dim_map(dim);
6507         n_param = isl_dim_size(dim, isl_dim_param);
6508         n_set = isl_dim_size(dim, isl_dim_in);
6509         dim = isl_dim_extend(dim, n_param, n_set, n_set + n_div);
6510         bmap = isl_basic_map_alloc_dim(dim, 0, n_set, 2 * n_div);
6511         for (i = 0; i < n_set; ++i)
6512                 bmap = var_equal(bmap, i);
6513
6514         total = n_param + n_set + n_set + n_div;
6515         for (i = 0; i < n_div; ++i) {
6516                 k = isl_basic_map_alloc_inequality(bmap);
6517                 if (k < 0)
6518                         goto error;
6519                 isl_seq_cpy(bmap->ineq[k], set->p[0]->div[i]+1, 1+n_param);
6520                 isl_seq_clr(bmap->ineq[k]+1+n_param, n_set);
6521                 isl_seq_cpy(bmap->ineq[k]+1+n_param+n_set,
6522                             set->p[0]->div[i]+1+1+n_param, n_set + n_div);
6523                 isl_int_neg(bmap->ineq[k][1+n_param+n_set+n_set+i],
6524                             set->p[0]->div[i][0]);
6525
6526                 l = isl_basic_map_alloc_inequality(bmap);
6527                 if (l < 0)
6528                         goto error;
6529                 isl_seq_neg(bmap->ineq[l], bmap->ineq[k], 1 + total);
6530                 isl_int_add(bmap->ineq[l][0], bmap->ineq[l][0],
6531                             set->p[0]->div[i][0]);
6532                 isl_int_sub_ui(bmap->ineq[l][0], bmap->ineq[l][0], 1);
6533         }
6534
6535         isl_set_free(set);
6536         return isl_map_from_basic_map(bmap);
6537 error:
6538         isl_set_free(set);
6539         isl_basic_map_free(bmap);
6540         return NULL;
6541 }
6542
6543 int isl_basic_set_size(__isl_keep isl_basic_set *bset)
6544 {
6545         unsigned dim;
6546         int size = 0;
6547
6548         if (!bset)
6549                 return -1;
6550
6551         dim = isl_basic_set_total_dim(bset);
6552         size += bset->n_eq * (1 + dim);
6553         size += bset->n_ineq * (1 + dim);
6554         size += bset->n_div * (2 + dim);
6555
6556         return size;
6557 }
6558
6559 int isl_set_size(__isl_keep isl_set *set)
6560 {
6561         int i;
6562         int size = 0;
6563
6564         if (!set)
6565                 return -1;
6566
6567         for (i = 0; i < set->n; ++i)
6568                 size += isl_basic_set_size(set->p[i]);
6569
6570         return size;
6571 }
6572
6573 int isl_basic_map_dim_is_bounded(__isl_keep isl_basic_map *bmap,
6574         enum isl_dim_type type, unsigned pos)
6575 {
6576         int i;
6577         int lower, upper;
6578
6579         if (!bmap)
6580                 return -1;
6581
6582         isl_assert(bmap->ctx, pos < isl_basic_map_dim(bmap, type), return -1);
6583
6584         pos += isl_basic_map_offset(bmap, type);
6585
6586         for (i = 0; i < bmap->n_eq; ++i)
6587                 if (!isl_int_is_zero(bmap->eq[i][pos]))
6588                         return 1;
6589
6590         lower = upper = 0;
6591         for (i = 0; i < bmap->n_ineq; ++i) {
6592                 int sgn = isl_int_sgn(bmap->ineq[i][pos]);
6593                 if (sgn > 0)
6594                         lower = 1;
6595                 if (sgn < 0)
6596                         upper = 1;
6597         }
6598
6599         return lower && upper;
6600 }
6601
6602 int isl_map_dim_is_bounded(__isl_keep isl_map *map,
6603         enum isl_dim_type type, unsigned pos)
6604 {
6605         int i;
6606
6607         if (!map)
6608                 return -1;
6609
6610         for (i = 0; i < map->n; ++i) {
6611                 int bounded;
6612                 bounded = isl_basic_map_dim_is_bounded(map->p[i], type, pos);
6613                 if (bounded < 0 || !bounded)
6614                         return bounded;
6615         }
6616
6617         return 1;
6618 }
6619
6620 /* Return 1 if the specified dim is involved in both an upper bound
6621  * and a lower bound.
6622  */
6623 int isl_set_dim_is_bounded(__isl_keep isl_set *set,
6624         enum isl_dim_type type, unsigned pos)
6625 {
6626         return isl_map_dim_is_bounded((isl_map *)set, type, pos);
6627 }
6628
6629 /* For each of the "n" variables starting at "first", determine
6630  * the sign of the variable and put the results in the first "n"
6631  * elements of the array "signs".
6632  * Sign
6633  *      1 means that the variable is non-negative
6634  *      -1 means that the variable is non-positive
6635  *      0 means the variable attains both positive and negative values.
6636  */
6637 int isl_basic_set_vars_get_sign(__isl_keep isl_basic_set *bset,
6638         unsigned first, unsigned n, int *signs)
6639 {
6640         isl_vec *bound = NULL;
6641         struct isl_tab *tab = NULL;
6642         struct isl_tab_undo *snap;
6643         int i;
6644
6645         if (!bset || !signs)
6646                 return -1;
6647
6648         bound = isl_vec_alloc(bset->ctx, 1 + isl_basic_set_total_dim(bset));
6649         tab = isl_tab_from_basic_set(bset);
6650         if (!bound || !tab)
6651                 goto error;
6652
6653         isl_seq_clr(bound->el, bound->size);
6654         isl_int_set_si(bound->el[0], -1);
6655
6656         snap = isl_tab_snap(tab);
6657         for (i = 0; i < n; ++i) {
6658                 int empty;
6659
6660                 isl_int_set_si(bound->el[1 + first + i], -1);
6661                 if (isl_tab_add_ineq(tab, bound->el) < 0)
6662                         goto error;
6663                 empty = tab->empty;
6664                 isl_int_set_si(bound->el[1 + first + i], 0);
6665                 if (isl_tab_rollback(tab, snap) < 0)
6666                         goto error;
6667
6668                 if (empty) {
6669                         signs[i] = 1;
6670                         continue;
6671                 }
6672
6673                 isl_int_set_si(bound->el[1 + first + i], 1);
6674                 if (isl_tab_add_ineq(tab, bound->el) < 0)
6675                         goto error;
6676                 empty = tab->empty;
6677                 isl_int_set_si(bound->el[1 + first + i], 0);
6678                 if (isl_tab_rollback(tab, snap) < 0)
6679                         goto error;
6680
6681                 signs[i] = empty ? -1 : 0;
6682         }
6683
6684         isl_tab_free(tab);
6685         isl_vec_free(bound);
6686         return 0;
6687 error:
6688         isl_tab_free(tab);
6689         isl_vec_free(bound);
6690         return -1;
6691 }
6692
6693 int isl_basic_set_dims_get_sign(__isl_keep isl_basic_set *bset,
6694         enum isl_dim_type type, unsigned first, unsigned n, int *signs)
6695 {
6696         if (!bset || !signs)
6697                 return -1;
6698         isl_assert(bset->ctx, first + n <= isl_basic_set_dim(bset, type),
6699                 return -1);
6700
6701         first += pos(bset->dim, type) - 1;
6702         return isl_basic_set_vars_get_sign(bset, first, n, signs);
6703 }