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