isl_map.c

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