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