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