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