isl_union_map.c

   1 /*
   2  * Copyright 2010-2011 INRIA Saclay
   3  *
   4  * Use of this software is governed by the GNU LGPLv2.1 license
   5  *
   6  * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
   7  * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
   8  * 91893 Orsay, France
   9  */
  10
  11 #define ISL_DIM_H
  12 #include <isl_map_private.h>
  13 #include <isl/ctx.h>
  14 #include <isl/hash.h>
  15 #include <isl/map.h>
  16 #include <isl/set.h>
  17 #include <isl_space_private.h>
  18 #include <isl_union_map_private.h>
  19 #include <isl/union_set.h>
  20
  21 /* Is this union set a parameter domain?
  22  */
  23 int isl_union_set_is_params(__isl_keep isl_union_set *uset)
  24 {
  25         isl_set *set;
  26         int params;
  27
  28         if (!uset)
  29                 return -1;
  30         if (uset->table.n != 1)
  31                 return 0;
  32
  33         set = isl_set_from_union_set(isl_union_set_copy(uset));
  34         params = isl_set_is_params(set);
  35         isl_set_free(set);
  36         return params;
  37 }
  38
  39 static __isl_give isl_union_map *isl_union_map_alloc(__isl_take isl_space *dim,
  40         int size)
  41 {
  42         isl_union_map *umap;
  43
  44         if (!dim)
  45                 return NULL;
  46
  47         umap = isl_calloc_type(dim->ctx, isl_union_map);
  48         if (!umap)
  49                 return NULL;
  50
  51         umap->ref = 1;
  52         umap->dim = dim;
  53         if (isl_hash_table_init(dim->ctx, &umap->table, size) < 0)
  54                 goto error;
  55
  56         return umap;
  57 error:
  58         isl_space_free(dim);
  59         isl_union_map_free(umap);
  60         return NULL;
  61 }
  62
  63 __isl_give isl_union_map *isl_union_map_empty(__isl_take isl_space *dim)
  64 {
  65         return isl_union_map_alloc(dim, 16);
  66 }
  67
  68 __isl_give isl_union_set *isl_union_set_empty(__isl_take isl_space *dim)
  69 {
  70         return isl_union_map_empty(dim);
  71 }
  72
  73 isl_ctx *isl_union_map_get_ctx(__isl_keep isl_union_map *umap)
  74 {
  75         return umap ? umap->dim->ctx : NULL;
  76 }
  77
  78 isl_ctx *isl_union_set_get_ctx(__isl_keep isl_union_set *uset)
  79 {
  80         return uset ? uset->dim->ctx : NULL;
  81 }
  82
  83 __isl_give isl_space *isl_union_map_get_space(__isl_keep isl_union_map *umap)
  84 {
  85         if (!umap)
  86                 return NULL;
  87         return isl_space_copy(umap->dim);
  88 }
  89
  90 __isl_give isl_space *isl_union_set_get_space(__isl_keep isl_union_set *uset)
  91 {
  92         return isl_union_map_get_space(uset);
  93 }
  94
  95 static int free_umap_entry(void **entry, void *user)
  96 {
  97         isl_map *map = *entry;
  98         isl_map_free(map);
  99         return 0;
 100 }
 101
 102 static int add_map(__isl_take isl_map *map, void *user)
 103 {
 104         isl_union_map **umap = (isl_union_map **)user;
 105
 106         *umap = isl_union_map_add_map(*umap, map);
 107
 108         return 0;
 109 }
 110
 111 __isl_give isl_union_map *isl_union_map_dup(__isl_keep isl_union_map *umap)
 112 {
 113         isl_union_map *dup;
 114
 115         if (!umap)
 116                 return NULL;
 117
 118         dup = isl_union_map_empty(isl_space_copy(umap->dim));
 119         if (isl_union_map_foreach_map(umap, &add_map, &dup) < 0)
 120                 goto error;
 121         return dup;
 122 error:
 123         isl_union_map_free(dup);
 124         return NULL;
 125 }
 126
 127 __isl_give isl_union_map *isl_union_map_cow(__isl_take isl_union_map *umap)
 128 {
 129         if (!umap)
 130                 return NULL;
 131
 132         if (umap->ref == 1)
 133                 return umap;
 134         umap->ref--;
 135         return isl_union_map_dup(umap);
 136 }
 137
 138 struct isl_union_align {
 139         isl_reordering *exp;
 140         isl_union_map *res;
 141 };
 142
 143 static int align_entry(void **entry, void *user)
 144 {
 145         isl_map *map = *entry;
 146         isl_reordering *exp;
 147         struct isl_union_align *data = user;
 148
 149         exp = isl_reordering_extend_space(isl_reordering_copy(data->exp),
 150                                     isl_map_get_space(map));
 151
 152         data->res = isl_union_map_add_map(data->res,
 153                                         isl_map_realign(isl_map_copy(map), exp));
 154
 155         return 0;
 156 }
 157
 158 /* Align the parameters of umap along those of model.
 159  * The result has the parameters of model first, in the same order
 160  * as they appear in model, followed by any remaining parameters of
 161  * umap that do not appear in model.
 162  */
 163 __isl_give isl_union_map *isl_union_map_align_params(
 164         __isl_take isl_union_map *umap, __isl_take isl_space *model)
 165 {
 166         struct isl_union_align data = { NULL, NULL };
 167
 168         if (!umap || !model)
 169                 goto error;
 170
 171         if (isl_space_match(umap->dim, isl_dim_param, model, isl_dim_param)) {
 172                 isl_space_free(model);
 173                 return umap;
 174         }
 175
 176         model = isl_space_params(model);
 177         data.exp = isl_parameter_alignment_reordering(umap->dim, model);
 178         if (!data.exp)
 179                 goto error;
 180
 181         data.res = isl_union_map_alloc(isl_space_copy(data.exp->dim),
 182                                         umap->table.n);
 183         if (isl_hash_table_foreach(umap->dim->ctx, &umap->table,
 184                                         &align_entry, &data) < 0)
 185                 goto error;
 186
 187         isl_reordering_free(data.exp);
 188         isl_union_map_free(umap);
 189         isl_space_free(model);
 190         return data.res;
 191 error:
 192         isl_reordering_free(data.exp);
 193         isl_union_map_free(umap);
 194         isl_union_map_free(data.res);
 195         isl_space_free(model);
 196         return NULL;
 197 }
 198
 199 __isl_give isl_union_set *isl_union_set_align_params(
 200         __isl_take isl_union_set *uset, __isl_take isl_space *model)
 201 {
 202         return isl_union_map_align_params(uset, model);
 203 }
 204
 205 __isl_give isl_union_map *isl_union_map_union(__isl_take isl_union_map *umap1,
 206         __isl_take isl_union_map *umap2)
 207 {
 208         umap1 = isl_union_map_align_params(umap1, isl_union_map_get_space(umap2));
 209         umap2 = isl_union_map_align_params(umap2, isl_union_map_get_space(umap1));
 210
 211         umap1 = isl_union_map_cow(umap1);
 212
 213         if (!umap1 || !umap2)
 214                 goto error;
 215
 216         if (isl_union_map_foreach_map(umap2, &add_map, &umap1) < 0)
 217                 goto error;
 218
 219         isl_union_map_free(umap2);
 220
 221         return umap1;
 222 error:
 223         isl_union_map_free(umap1);
 224         isl_union_map_free(umap2);
 225         return NULL;
 226 }
 227
 228 __isl_give isl_union_set *isl_union_set_union(__isl_take isl_union_set *uset1,
 229         __isl_take isl_union_set *uset2)
 230 {
 231         return isl_union_map_union(uset1, uset2);
 232 }
 233
 234 __isl_give isl_union_map *isl_union_map_copy(__isl_keep isl_union_map *umap)
 235 {
 236         if (!umap)
 237                 return NULL;
 238
 239         umap->ref++;
 240         return umap;
 241 }
 242
 243 __isl_give isl_union_set *isl_union_set_copy(__isl_keep isl_union_set *uset)
 244 {
 245         return isl_union_map_copy(uset);
 246 }
 247
 248 void *isl_union_map_free(__isl_take isl_union_map *umap)
 249 {
 250         if (!umap)
 251                 return NULL;
 252
 253         if (--umap->ref > 0)
 254                 return NULL;
 255
 256         isl_hash_table_foreach(umap->dim->ctx, &umap->table,
 257                                &free_umap_entry, NULL);
 258         isl_hash_table_clear(&umap->table);
 259         isl_space_free(umap->dim);
 260         free(umap);
 261         return NULL;
 262 }
 263
 264 void *isl_union_set_free(__isl_take isl_union_set *uset)
 265 {
 266         return isl_union_map_free(uset);
 267 }
 268
 269 static int has_dim(const void *entry, const void *val)
 270 {
 271         isl_map *map = (isl_map *)entry;
 272         isl_space *dim = (isl_space *)val;
 273
 274         return isl_space_is_equal(map->dim, dim);
 275 }
 276
 277 __isl_give isl_union_map *isl_union_map_add_map(__isl_take isl_union_map *umap,
 278         __isl_take isl_map *map)
 279 {
 280         uint32_t hash;
 281         struct isl_hash_table_entry *entry;
 282
 283         if (!map || !umap)
 284                 goto error;
 285
 286         if (isl_map_plain_is_empty(map)) {
 287                 isl_map_free(map);
 288                 return umap;
 289         }
 290
 291         if (!isl_space_match(map->dim, isl_dim_param, umap->dim, isl_dim_param)) {
 292                 umap = isl_union_map_align_params(umap, isl_map_get_space(map));
 293                 map = isl_map_align_params(map, isl_union_map_get_space(umap));
 294         }
 295
 296         umap = isl_union_map_cow(umap);
 297
 298         if (!map || !umap)
 299                 goto error;
 300
 301         hash = isl_space_get_hash(map->dim);
 302         entry = isl_hash_table_find(umap->dim->ctx, &umap->table, hash,
 303                                     &has_dim, map->dim, 1);
 304         if (!entry)
 305                 goto error;
 306
 307         if (!entry->data)
 308                 entry->data = map;
 309         else {
 310                 entry->data = isl_map_union(entry->data, isl_map_copy(map));
 311                 if (!entry->data)
 312                         goto error;
 313                 isl_map_free(map);
 314         }
 315
 316         return umap;
 317 error:
 318         isl_map_free(map);
 319         isl_union_map_free(umap);
 320         return NULL;
 321 }
 322
 323 __isl_give isl_union_set *isl_union_set_add_set(__isl_take isl_union_set *uset,
 324         __isl_take isl_set *set)
 325 {
 326         return isl_union_map_add_map(uset, (isl_map *)set);
 327 }
 328
 329 __isl_give isl_union_map *isl_union_map_from_map(__isl_take isl_map *map)
 330 {
 331         isl_space *dim;
 332         isl_union_map *umap;
 333
 334         if (!map)
 335                 return NULL;
 336
 337         dim = isl_map_get_space(map);
 338         dim = isl_space_params(dim);
 339         umap = isl_union_map_empty(dim);
 340         umap = isl_union_map_add_map(umap, map);
 341
 342         return umap;
 343 }
 344
 345 __isl_give isl_union_set *isl_union_set_from_set(__isl_take isl_set *set)
 346 {
 347         return isl_union_map_from_map((isl_map *)set);
 348 }
 349
 350 struct isl_union_map_foreach_data
 351 {
 352         int (*fn)(__isl_take isl_map *map, void *user);
 353         void *user;
 354 };
 355
 356 static int call_on_copy(void **entry, void *user)
 357 {
 358         isl_map *map = *entry;
 359         struct isl_union_map_foreach_data *data;
 360         data = (struct isl_union_map_foreach_data *)user;
 361
 362         return data->fn(isl_map_copy(map), data->user);
 363 }
 364
 365 int isl_union_map_n_map(__isl_keep isl_union_map *umap)
 366 {
 367         return umap ? umap->table.n : 0;
 368 }
 369
 370 int isl_union_set_n_set(__isl_keep isl_union_set *uset)
 371 {
 372         return uset ? uset->table.n : 0;
 373 }
 374
 375 int isl_union_map_foreach_map(__isl_keep isl_union_map *umap,
 376         int (*fn)(__isl_take isl_map *map, void *user), void *user)
 377 {
 378         struct isl_union_map_foreach_data data = { fn, user };
 379
 380         if (!umap)
 381                 return -1;
 382
 383         return isl_hash_table_foreach(umap->dim->ctx, &umap->table,
 384                                       &call_on_copy, &data);
 385 }
 386
 387 static int copy_map(void **entry, void *user)
 388 {
 389         isl_map *map = *entry;
 390         isl_map **map_p = user;
 391
 392         *map_p = isl_map_copy(map);
 393
 394         return -1;
 395 }
 396
 397 __isl_give isl_map *isl_map_from_union_map(__isl_take isl_union_map *umap)
 398 {
 399         isl_ctx *ctx;
 400         isl_map *map = NULL;
 401
 402         if (!umap)
 403                 return NULL;
 404         ctx = isl_union_map_get_ctx(umap);
 405         if (umap->table.n != 1)
 406                 isl_die(ctx, isl_error_invalid,
 407                         "union map needs to contain elements in exactly "
 408                         "one space", return isl_union_map_free(umap));
 409
 410         isl_hash_table_foreach(ctx, &umap->table, &copy_map, &map);
 411
 412         isl_union_map_free(umap);
 413
 414         return map;
 415 }
 416
 417 __isl_give isl_set *isl_set_from_union_set(__isl_take isl_union_set *uset)
 418 {
 419         return isl_map_from_union_map(uset);
 420 }
 421
 422 __isl_give isl_map *isl_union_map_extract_map(__isl_keep isl_union_map *umap,
 423         __isl_take isl_space *dim)
 424 {
 425         uint32_t hash;
 426         struct isl_hash_table_entry *entry;
 427
 428         if (!umap || !dim)
 429                 goto error;
 430
 431         hash = isl_space_get_hash(dim);
 432         entry = isl_hash_table_find(umap->dim->ctx, &umap->table, hash,
 433                                     &has_dim, dim, 0);
 434         if (!entry)
 435                 return isl_map_empty(dim);
 436         isl_space_free(dim);
 437         return isl_map_copy(entry->data);
 438 error:
 439         isl_space_free(dim);
 440         return NULL;
 441 }
 442
 443 __isl_give isl_set *isl_union_set_extract_set(__isl_keep isl_union_set *uset,
 444         __isl_take isl_space *dim)
 445 {
 446         return (isl_set *)isl_union_map_extract_map(uset, dim);
 447 }
 448
 449 /* Check if umap contains a map in the given space.
 450  */
 451 __isl_give int isl_union_map_contains(__isl_keep isl_union_map *umap,
 452         __isl_keep isl_space *dim)
 453 {
 454         uint32_t hash;
 455         struct isl_hash_table_entry *entry;
 456
 457         if (!umap || !dim)
 458                 return -1;
 459
 460         hash = isl_space_get_hash(dim);
 461         entry = isl_hash_table_find(umap->dim->ctx, &umap->table, hash,
 462                                     &has_dim, dim, 0);
 463         return !!entry;
 464 }
 465
 466 __isl_give int isl_union_set_contains(__isl_keep isl_union_set *uset,
 467         __isl_keep isl_space *dim)
 468 {
 469         return isl_union_map_contains(uset, dim);
 470 }
 471
 472 int isl_union_set_foreach_set(__isl_keep isl_union_set *uset,
 473         int (*fn)(__isl_take isl_set *set, void *user), void *user)
 474 {
 475         return isl_union_map_foreach_map(uset,
 476                 (int(*)(__isl_take isl_map *, void*))fn, user);
 477 }
 478
 479 struct isl_union_set_foreach_point_data {
 480         int (*fn)(__isl_take isl_point *pnt, void *user);
 481         void *user;
 482 };
 483
 484 static int foreach_point(__isl_take isl_set *set, void *user)
 485 {
 486         struct isl_union_set_foreach_point_data *data = user;
 487         int r;
 488
 489         r = isl_set_foreach_point(set, data->fn, data->user);
 490         isl_set_free(set);
 491
 492         return r;
 493 }
 494
 495 int isl_union_set_foreach_point(__isl_keep isl_union_set *uset,
 496         int (*fn)(__isl_take isl_point *pnt, void *user), void *user)
 497 {
 498         struct isl_union_set_foreach_point_data data = { fn, user };
 499         return isl_union_set_foreach_set(uset, &foreach_point, &data);
 500 }
 501
 502 struct isl_union_map_gen_bin_data {
 503         isl_union_map *umap2;
 504         isl_union_map *res;
 505 };
 506
 507 static int subtract_entry(void **entry, void *user)
 508 {
 509         struct isl_union_map_gen_bin_data *data = user;
 510         uint32_t hash;
 511         struct isl_hash_table_entry *entry2;
 512         isl_map *map = *entry;
 513
 514         hash = isl_space_get_hash(map->dim);
 515         entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
 516                                      hash, &has_dim, map->dim, 0);
 517         map = isl_map_copy(map);
 518         if (entry2) {
 519                 int empty;
 520                 map = isl_map_subtract(map, isl_map_copy(entry2->data));
 521
 522                 empty = isl_map_is_empty(map);
 523                 if (empty < 0) {
 524                         isl_map_free(map);
 525                         return -1;
 526                 }
 527                 if (empty) {
 528                         isl_map_free(map);
 529                         return 0;
 530                 }
 531         }
 532         data->res = isl_union_map_add_map(data->res, map);
 533
 534         return 0;
 535 }
 536
 537 static __isl_give isl_union_map *gen_bin_op(__isl_take isl_union_map *umap1,
 538         __isl_take isl_union_map *umap2, int (*fn)(void **, void *))
 539 {
 540         struct isl_union_map_gen_bin_data data = { NULL, NULL };
 541
 542         umap1 = isl_union_map_align_params(umap1, isl_union_map_get_space(umap2));
 543         umap2 = isl_union_map_align_params(umap2, isl_union_map_get_space(umap1));
 544
 545         if (!umap1 || !umap2)
 546                 goto error;
 547
 548         data.umap2 = umap2;
 549         data.res = isl_union_map_alloc(isl_space_copy(umap1->dim),
 550                                        umap1->table.n);
 551         if (isl_hash_table_foreach(umap1->dim->ctx, &umap1->table,
 552                                    fn, &data) < 0)
 553                 goto error;
 554
 555         isl_union_map_free(umap1);
 556         isl_union_map_free(umap2);
 557         return data.res;
 558 error:
 559         isl_union_map_free(umap1);
 560         isl_union_map_free(umap2);
 561         isl_union_map_free(data.res);
 562         return NULL;
 563 }
 564
 565 __isl_give isl_union_map *isl_union_map_subtract(
 566         __isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2)
 567 {
 568         return gen_bin_op(umap1, umap2, &subtract_entry);
 569 }
 570
 571 __isl_give isl_union_set *isl_union_set_subtract(
 572         __isl_take isl_union_set *uset1, __isl_take isl_union_set *uset2)
 573 {
 574         return isl_union_map_subtract(uset1, uset2);
 575 }
 576
 577 struct isl_union_map_gen_bin_set_data {
 578         isl_set *set;
 579         isl_union_map *res;
 580 };
 581
 582 static int intersect_params_entry(void **entry, void *user)
 583 {
 584         struct isl_union_map_gen_bin_set_data *data = user;
 585         isl_map *map = *entry;
 586         int empty;
 587
 588         map = isl_map_copy(map);
 589         map = isl_map_intersect_params(map, isl_set_copy(data->set));
 590
 591         empty = isl_map_is_empty(map);
 592         if (empty < 0) {
 593                 isl_map_free(map);
 594                 return -1;
 595         }
 596
 597         data->res = isl_union_map_add_map(data->res, map);
 598
 599         return 0;
 600 }
 601
 602 static __isl_give isl_union_map *gen_bin_set_op(__isl_take isl_union_map *umap,
 603         __isl_take isl_set *set, int (*fn)(void **, void *))
 604 {
 605         struct isl_union_map_gen_bin_set_data data = { NULL, NULL };
 606
 607         umap = isl_union_map_align_params(umap, isl_set_get_space(set));
 608         set = isl_set_align_params(set, isl_union_map_get_space(umap));
 609
 610         if (!umap || !set)
 611                 goto error;
 612
 613         data.set = set;
 614         data.res = isl_union_map_alloc(isl_space_copy(umap->dim),
 615                                        umap->table.n);
 616         if (isl_hash_table_foreach(umap->dim->ctx, &umap->table,
 617                                    fn, &data) < 0)
 618                 goto error;
 619
 620         isl_union_map_free(umap);
 621         isl_set_free(set);
 622         return data.res;
 623 error:
 624         isl_union_map_free(umap);
 625         isl_set_free(set);
 626         isl_union_map_free(data.res);
 627         return NULL;
 628 }
 629
 630 __isl_give isl_union_map *isl_union_map_intersect_params(
 631         __isl_take isl_union_map *umap, __isl_take isl_set *set)
 632 {
 633         return gen_bin_set_op(umap, set, &intersect_params_entry);
 634 }
 635
 636 __isl_give isl_union_set *isl_union_set_intersect_params(
 637         __isl_take isl_union_set *uset, __isl_take isl_set *set)
 638 {
 639         return isl_union_map_intersect_params(uset, set);
 640 }
 641
 642 static __isl_give isl_union_map *union_map_intersect_params(
 643         __isl_take isl_union_map *umap, __isl_take isl_union_set *uset)
 644 {
 645         return isl_union_map_intersect_params(umap,
 646                                                 isl_set_from_union_set(uset));
 647 }
 648
 649 static __isl_give isl_union_map *union_map_gist_params(
 650         __isl_take isl_union_map *umap, __isl_take isl_union_set *uset)
 651 {
 652         return isl_union_map_gist_params(umap, isl_set_from_union_set(uset));
 653 }
 654
 655 struct isl_union_map_match_bin_data {
 656         isl_union_map *umap2;
 657         isl_union_map *res;
 658         __isl_give isl_map *(*fn)(__isl_take isl_map*, __isl_take isl_map*);
 659 };
 660
 661 static int match_bin_entry(void **entry, void *user)
 662 {
 663         struct isl_union_map_match_bin_data *data = user;
 664         uint32_t hash;
 665         struct isl_hash_table_entry *entry2;
 666         isl_map *map = *entry;
 667         int empty;
 668
 669         hash = isl_space_get_hash(map->dim);
 670         entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
 671                                      hash, &has_dim, map->dim, 0);
 672         if (!entry2)
 673                 return 0;
 674
 675         map = isl_map_copy(map);
 676         map = data->fn(map, isl_map_copy(entry2->data));
 677
 678         empty = isl_map_is_empty(map);
 679         if (empty < 0) {
 680                 isl_map_free(map);
 681                 return -1;
 682         }
 683         if (empty) {
 684                 isl_map_free(map);
 685                 return 0;
 686         }
 687
 688         data->res = isl_union_map_add_map(data->res, map);
 689
 690         return 0;
 691 }
 692
 693 static __isl_give isl_union_map *match_bin_op(__isl_take isl_union_map *umap1,
 694         __isl_take isl_union_map *umap2,
 695         __isl_give isl_map *(*fn)(__isl_take isl_map*, __isl_take isl_map*))
 696 {
 697         struct isl_union_map_match_bin_data data = { NULL, NULL, fn };
 698
 699         umap1 = isl_union_map_align_params(umap1, isl_union_map_get_space(umap2));
 700         umap2 = isl_union_map_align_params(umap2, isl_union_map_get_space(umap1));
 701
 702         if (!umap1 || !umap2)
 703                 goto error;
 704
 705         data.umap2 = umap2;
 706         data.res = isl_union_map_alloc(isl_space_copy(umap1->dim),
 707                                        umap1->table.n);
 708         if (isl_hash_table_foreach(umap1->dim->ctx, &umap1->table,
 709                                    &match_bin_entry, &data) < 0)
 710                 goto error;
 711
 712         isl_union_map_free(umap1);
 713         isl_union_map_free(umap2);
 714         return data.res;
 715 error:
 716         isl_union_map_free(umap1);
 717         isl_union_map_free(umap2);
 718         isl_union_map_free(data.res);
 719         return NULL;
 720 }
 721
 722 __isl_give isl_union_map *isl_union_map_intersect(
 723         __isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2)
 724 {
 725         return match_bin_op(umap1, umap2, &isl_map_intersect);
 726 }
 727
 728 /* Compute the intersection of the two union_sets.
 729  * As a special case, if exactly one of the two union_sets
 730  * is a parameter domain, then intersect the parameter domain
 731  * of the other one with this set.
 732  */
 733 __isl_give isl_union_set *isl_union_set_intersect(
 734         __isl_take isl_union_set *uset1, __isl_take isl_union_set *uset2)
 735 {
 736         int p1, p2;
 737
 738         p1 = isl_union_set_is_params(uset1);
 739         p2 = isl_union_set_is_params(uset2);
 740         if (p1 < 0 || p2 < 0)
 741                 goto error;
 742         if (!p1 && p2)
 743                 return union_map_intersect_params(uset1, uset2);
 744         if (p1 && !p2)
 745                 return union_map_intersect_params(uset2, uset1);
 746         return isl_union_map_intersect(uset1, uset2);
 747 error:
 748         isl_union_set_free(uset1);
 749         isl_union_set_free(uset2);
 750         return NULL;
 751 }
 752
 753 static int gist_params_entry(void **entry, void *user)
 754 {
 755         struct isl_union_map_gen_bin_set_data *data = user;
 756         isl_map *map = *entry;
 757         int empty;
 758
 759         map = isl_map_copy(map);
 760         map = isl_map_gist_params(map, isl_set_copy(data->set));
 761
 762         empty = isl_map_is_empty(map);
 763         if (empty < 0) {
 764                 isl_map_free(map);
 765                 return -1;
 766         }
 767
 768         data->res = isl_union_map_add_map(data->res, map);
 769
 770         return 0;
 771 }
 772
 773 __isl_give isl_union_map *isl_union_map_gist_params(
 774         __isl_take isl_union_map *umap, __isl_take isl_set *set)
 775 {
 776         return gen_bin_set_op(umap, set, &gist_params_entry);
 777 }
 778
 779 __isl_give isl_union_set *isl_union_set_gist_params(
 780         __isl_take isl_union_set *uset, __isl_take isl_set *set)
 781 {
 782         return isl_union_map_gist_params(uset, set);
 783 }
 784
 785 __isl_give isl_union_map *isl_union_map_gist(__isl_take isl_union_map *umap,
 786         __isl_take isl_union_map *context)
 787 {
 788         return match_bin_op(umap, context, &isl_map_gist);
 789 }
 790
 791 __isl_give isl_union_set *isl_union_set_gist(__isl_take isl_union_set *uset,
 792         __isl_take isl_union_set *context)
 793 {
 794         return isl_union_map_gist(uset, context);
 795 }
 796
 797 static __isl_give isl_map *lex_le_set(__isl_take isl_map *set1,
 798         __isl_take isl_map *set2)
 799 {
 800         return isl_set_lex_le_set((isl_set *)set1, (isl_set *)set2);
 801 }
 802
 803 static __isl_give isl_map *lex_lt_set(__isl_take isl_map *set1,
 804         __isl_take isl_map *set2)
 805 {
 806         return isl_set_lex_lt_set((isl_set *)set1, (isl_set *)set2);
 807 }
 808
 809 __isl_give isl_union_map *isl_union_set_lex_lt_union_set(
 810         __isl_take isl_union_set *uset1, __isl_take isl_union_set *uset2)
 811 {
 812         return match_bin_op(uset1, uset2, &lex_lt_set);
 813 }
 814
 815 __isl_give isl_union_map *isl_union_set_lex_le_union_set(
 816         __isl_take isl_union_set *uset1, __isl_take isl_union_set *uset2)
 817 {
 818         return match_bin_op(uset1, uset2, &lex_le_set);
 819 }
 820
 821 __isl_give isl_union_map *isl_union_set_lex_gt_union_set(
 822         __isl_take isl_union_set *uset1, __isl_take isl_union_set *uset2)
 823 {
 824         return isl_union_map_reverse(isl_union_set_lex_lt_union_set(uset2, uset1));
 825 }
 826
 827 __isl_give isl_union_map *isl_union_set_lex_ge_union_set(
 828         __isl_take isl_union_set *uset1, __isl_take isl_union_set *uset2)
 829 {
 830         return isl_union_map_reverse(isl_union_set_lex_le_union_set(uset2, uset1));
 831 }
 832
 833 __isl_give isl_union_map *isl_union_map_lex_gt_union_map(
 834         __isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2)
 835 {
 836         return isl_union_map_reverse(isl_union_map_lex_lt_union_map(umap2, umap1));
 837 }
 838
 839 __isl_give isl_union_map *isl_union_map_lex_ge_union_map(
 840         __isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2)
 841 {
 842         return isl_union_map_reverse(isl_union_map_lex_le_union_map(umap2, umap1));
 843 }
 844
 845 static int intersect_domain_entry(void **entry, void *user)
 846 {
 847         struct isl_union_map_gen_bin_data *data = user;
 848         uint32_t hash;
 849         struct isl_hash_table_entry *entry2;
 850         isl_space *dim;
 851         isl_map *map = *entry;
 852         int empty;
 853
 854         dim = isl_map_get_space(map);
 855         dim = isl_space_domain(dim);
 856         hash = isl_space_get_hash(dim);
 857         entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
 858                                      hash, &has_dim, dim, 0);
 859         isl_space_free(dim);
 860         if (!entry2)
 861                 return 0;
 862
 863         map = isl_map_copy(map);
 864         map = isl_map_intersect_domain(map, isl_set_copy(entry2->data));
 865
 866         empty = isl_map_is_empty(map);
 867         if (empty < 0) {
 868                 isl_map_free(map);
 869                 return -1;
 870         }
 871         if (empty) {
 872                 isl_map_free(map);
 873                 return 0;
 874         }
 875
 876         data->res = isl_union_map_add_map(data->res, map);
 877
 878         return 0;
 879 }
 880
 881 /* Intersect the domain of "umap" with "uset".
 882  * If "uset" is a parameters domain, then intersect the parameter
 883  * domain of "umap" with this set.
 884  */
 885 __isl_give isl_union_map *isl_union_map_intersect_domain(
 886         __isl_take isl_union_map *umap, __isl_take isl_union_set *uset)
 887 {
 888         if (isl_union_set_is_params(uset))
 889                 return union_map_intersect_params(umap, uset);
 890         return gen_bin_op(umap, uset, &intersect_domain_entry);
 891 }
 892
 893 static int gist_domain_entry(void **entry, void *user)
 894 {
 895         struct isl_union_map_gen_bin_data *data = user;
 896         uint32_t hash;
 897         struct isl_hash_table_entry *entry2;
 898         isl_space *dim;
 899         isl_map *map = *entry;
 900         int empty;
 901
 902         dim = isl_map_get_space(map);
 903         dim = isl_space_domain(dim);
 904         hash = isl_space_get_hash(dim);
 905         entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
 906                                      hash, &has_dim, dim, 0);
 907         isl_space_free(dim);
 908         if (!entry2)
 909                 return 0;
 910
 911         map = isl_map_copy(map);
 912         map = isl_map_gist_domain(map, isl_set_copy(entry2->data));
 913
 914         empty = isl_map_is_empty(map);
 915         if (empty < 0) {
 916                 isl_map_free(map);
 917                 return -1;
 918         }
 919
 920         data->res = isl_union_map_add_map(data->res, map);
 921
 922         return 0;
 923 }
 924
 925 /* Compute the gist of "umap" with respect to the domain "uset".
 926  * If "uset" is a parameters domain, then compute the gist
 927  * with respect to this parameter domain.
 928  */
 929 __isl_give isl_union_map *isl_union_map_gist_domain(
 930         __isl_take isl_union_map *umap, __isl_take isl_union_set *uset)
 931 {
 932         if (isl_union_set_is_params(uset))
 933                 return union_map_gist_params(umap, uset);
 934         return gen_bin_op(umap, uset, &gist_domain_entry);
 935 }
 936
 937 static int intersect_range_entry(void **entry, void *user)
 938 {
 939         struct isl_union_map_gen_bin_data *data = user;
 940         uint32_t hash;
 941         struct isl_hash_table_entry *entry2;
 942         isl_space *dim;
 943         isl_map *map = *entry;
 944         int empty;
 945
 946         dim = isl_map_get_space(map);
 947         dim = isl_space_range(dim);
 948         hash = isl_space_get_hash(dim);
 949         entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
 950                                      hash, &has_dim, dim, 0);
 951         isl_space_free(dim);
 952         if (!entry2)
 953                 return 0;
 954
 955         map = isl_map_copy(map);
 956         map = isl_map_intersect_range(map, isl_set_copy(entry2->data));
 957
 958         empty = isl_map_is_empty(map);
 959         if (empty < 0) {
 960                 isl_map_free(map);
 961                 return -1;
 962         }
 963         if (empty) {
 964                 isl_map_free(map);
 965                 return 0;
 966         }
 967
 968         data->res = isl_union_map_add_map(data->res, map);
 969
 970         return 0;
 971 }
 972
 973 __isl_give isl_union_map *isl_union_map_intersect_range(
 974         __isl_take isl_union_map *umap, __isl_take isl_union_set *uset)
 975 {
 976         return gen_bin_op(umap, uset, &intersect_range_entry);
 977 }
 978
 979 struct isl_union_map_bin_data {
 980         isl_union_map *umap2;
 981         isl_union_map *res;
 982         isl_map *map;
 983         int (*fn)(void **entry, void *user);
 984 };
 985
 986 static int apply_range_entry(void **entry, void *user)
 987 {
 988         struct isl_union_map_bin_data *data = user;
 989         isl_map *map2 = *entry;
 990         int empty;
 991
 992         if (!isl_space_tuple_match(data->map->dim, isl_dim_out,
 993                                  map2->dim, isl_dim_in))
 994                 return 0;
 995
 996         map2 = isl_map_apply_range(isl_map_copy(data->map), isl_map_copy(map2));
 997
 998         empty = isl_map_is_empty(map2);
 999         if (empty < 0) {
1000                 isl_map_free(map2);
1001                 return -1;
1002         }
1003         if (empty) {
1004                 isl_map_free(map2);
1005                 return 0;
1006         }
1007
1008         data->res = isl_union_map_add_map(data->res, map2);
1009
1010         return 0;
1011 }
1012
1013 static int bin_entry(void **entry, void *user)
1014 {
1015         struct isl_union_map_bin_data *data = user;
1016         isl_map *map = *entry;
1017
1018         data->map = map;
1019         if (isl_hash_table_foreach(data->umap2->dim->ctx, &data->umap2->table,
1020                                    data->fn, data) < 0)
1021                 return -1;
1022
1023         return 0;
1024 }
1025
1026 static __isl_give isl_union_map *bin_op(__isl_take isl_union_map *umap1,
1027         __isl_take isl_union_map *umap2, int (*fn)(void **entry, void *user))
1028 {
1029         struct isl_union_map_bin_data data = { NULL, NULL, NULL, fn };
1030
1031         umap1 = isl_union_map_align_params(umap1, isl_union_map_get_space(umap2));
1032         umap2 = isl_union_map_align_params(umap2, isl_union_map_get_space(umap1));
1033
1034         if (!umap1 || !umap2)
1035                 goto error;
1036
1037         data.umap2 = umap2;
1038         data.res = isl_union_map_alloc(isl_space_copy(umap1->dim),
1039                                        umap1->table.n);
1040         if (isl_hash_table_foreach(umap1->dim->ctx, &umap1->table,
1041                                    &bin_entry, &data) < 0)
1042                 goto error;
1043
1044         isl_union_map_free(umap1);
1045         isl_union_map_free(umap2);
1046         return data.res;
1047 error:
1048         isl_union_map_free(umap1);
1049         isl_union_map_free(umap2);
1050         isl_union_map_free(data.res);
1051         return NULL;
1052 }
1053
1054 __isl_give isl_union_map *isl_union_map_apply_range(
1055         __isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2)
1056 {
1057         return bin_op(umap1, umap2, &apply_range_entry);
1058 }
1059
1060 __isl_give isl_union_map *isl_union_map_apply_domain(
1061         __isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2)
1062 {
1063         umap1 = isl_union_map_reverse(umap1);
1064         umap1 = isl_union_map_apply_range(umap1, umap2);
1065         return isl_union_map_reverse(umap1);
1066 }
1067
1068 __isl_give isl_union_set *isl_union_set_apply(
1069         __isl_take isl_union_set *uset, __isl_take isl_union_map *umap)
1070 {
1071         return isl_union_map_apply_range(uset, umap);
1072 }
1073
1074 static int map_lex_lt_entry(void **entry, void *user)
1075 {
1076         struct isl_union_map_bin_data *data = user;
1077         isl_map *map2 = *entry;
1078
1079         if (!isl_space_tuple_match(data->map->dim, isl_dim_out,
1080                                  map2->dim, isl_dim_out))
1081                 return 0;
1082
1083         map2 = isl_map_lex_lt_map(isl_map_copy(data->map), isl_map_copy(map2));
1084
1085         data->res = isl_union_map_add_map(data->res, map2);
1086
1087         return 0;
1088 }
1089
1090 __isl_give isl_union_map *isl_union_map_lex_lt_union_map(
1091         __isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2)
1092 {
1093         return bin_op(umap1, umap2, &map_lex_lt_entry);
1094 }
1095
1096 static int map_lex_le_entry(void **entry, void *user)
1097 {
1098         struct isl_union_map_bin_data *data = user;
1099         isl_map *map2 = *entry;
1100
1101         if (!isl_space_tuple_match(data->map->dim, isl_dim_out,
1102                                  map2->dim, isl_dim_out))
1103                 return 0;
1104
1105         map2 = isl_map_lex_le_map(isl_map_copy(data->map), isl_map_copy(map2));
1106
1107         data->res = isl_union_map_add_map(data->res, map2);
1108
1109         return 0;
1110 }
1111
1112 __isl_give isl_union_map *isl_union_map_lex_le_union_map(
1113         __isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2)
1114 {
1115         return bin_op(umap1, umap2, &map_lex_le_entry);
1116 }
1117
1118 static int product_entry(void **entry, void *user)
1119 {
1120         struct isl_union_map_bin_data *data = user;
1121         isl_map *map2 = *entry;
1122
1123         map2 = isl_map_product(isl_map_copy(data->map), isl_map_copy(map2));
1124
1125         data->res = isl_union_map_add_map(data->res, map2);
1126
1127         return 0;
1128 }
1129
1130 __isl_give isl_union_map *isl_union_map_product(__isl_take isl_union_map *umap1,
1131         __isl_take isl_union_map *umap2)
1132 {
1133         return bin_op(umap1, umap2, &product_entry);
1134 }
1135
1136 __isl_give isl_union_set *isl_union_set_product(__isl_take isl_union_set *uset1,
1137         __isl_take isl_union_set *uset2)
1138 {
1139         return isl_union_map_product(uset1, uset2);
1140 }
1141
1142 static int range_product_entry(void **entry, void *user)
1143 {
1144         struct isl_union_map_bin_data *data = user;
1145         isl_map *map2 = *entry;
1146
1147         if (!isl_space_tuple_match(data->map->dim, isl_dim_in,
1148                                  map2->dim, isl_dim_in))
1149                 return 0;
1150
1151         map2 = isl_map_range_product(isl_map_copy(data->map),
1152                                      isl_map_copy(map2));
1153
1154         data->res = isl_union_map_add_map(data->res, map2);
1155
1156         return 0;
1157 }
1158
1159 __isl_give isl_union_map *isl_union_map_range_product(
1160         __isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2)
1161 {
1162         return bin_op(umap1, umap2, &range_product_entry);
1163 }
1164
1165 static int flat_range_product_entry(void **entry, void *user)
1166 {
1167         struct isl_union_map_bin_data *data = user;
1168         isl_map *map2 = *entry;
1169
1170         if (!isl_space_tuple_match(data->map->dim, isl_dim_in,
1171                                  map2->dim, isl_dim_in))
1172                 return 0;
1173
1174         map2 = isl_map_flat_range_product(isl_map_copy(data->map),
1175                                           isl_map_copy(map2));
1176
1177         data->res = isl_union_map_add_map(data->res, map2);
1178
1179         return 0;
1180 }
1181
1182 __isl_give isl_union_map *isl_union_map_flat_range_product(
1183         __isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2)
1184 {
1185         return bin_op(umap1, umap2, &flat_range_product_entry);
1186 }
1187
1188 static __isl_give isl_union_set *cond_un_op(__isl_take isl_union_map *umap,
1189         int (*fn)(void **, void *))
1190 {
1191         isl_union_set *res;
1192
1193         if (!umap)
1194                 return NULL;
1195
1196         res = isl_union_map_alloc(isl_space_copy(umap->dim), umap->table.n);
1197         if (isl_hash_table_foreach(umap->dim->ctx, &umap->table, fn, &res) < 0)
1198                 goto error;
1199
1200         isl_union_map_free(umap);
1201         return res;
1202 error:
1203         isl_union_map_free(umap);
1204         isl_union_set_free(res);
1205         return NULL;
1206 }
1207
1208 static int from_range_entry(void **entry, void *user)
1209 {
1210         isl_map *set = *entry;
1211         isl_union_set **res = user;
1212
1213         *res = isl_union_map_add_map(*res,
1214                                         isl_map_from_range(isl_set_copy(set)));
1215
1216         return 0;
1217 }
1218
1219 __isl_give isl_union_map *isl_union_map_from_range(
1220         __isl_take isl_union_set *uset)
1221 {
1222         return cond_un_op(uset, &from_range_entry);
1223 }
1224
1225 __isl_give isl_union_map *isl_union_map_from_domain(
1226         __isl_take isl_union_set *uset)
1227 {
1228         return isl_union_map_reverse(isl_union_map_from_range(uset));
1229 }
1230
1231 __isl_give isl_union_map *isl_union_map_from_domain_and_range(
1232         __isl_take isl_union_set *domain, __isl_take isl_union_set *range)
1233 {
1234         return isl_union_map_apply_range(isl_union_map_from_domain(domain),
1235                                          isl_union_map_from_range(range));
1236 }
1237
1238 static __isl_give isl_union_map *un_op(__isl_take isl_union_map *umap,
1239         int (*fn)(void **, void *))
1240 {
1241         umap = isl_union_map_cow(umap);
1242         if (!umap)
1243                 return NULL;
1244
1245         if (isl_hash_table_foreach(umap->dim->ctx, &umap->table, fn, NULL) < 0)
1246                 goto error;
1247
1248         return umap;
1249 error:
1250         isl_union_map_free(umap);
1251         return NULL;
1252 }
1253
1254 static int affine_entry(void **entry, void *user)
1255 {
1256         isl_map **map = (isl_map **)entry;
1257
1258         *map = isl_map_from_basic_map(isl_map_affine_hull(*map));
1259
1260         return *map ? 0 : -1;
1261 }
1262
1263 __isl_give isl_union_map *isl_union_map_affine_hull(
1264         __isl_take isl_union_map *umap)
1265 {
1266         return un_op(umap, &affine_entry);
1267 }
1268
1269 __isl_give isl_union_set *isl_union_set_affine_hull(
1270         __isl_take isl_union_set *uset)
1271 {
1272         return isl_union_map_affine_hull(uset);
1273 }
1274
1275 static int polyhedral_entry(void **entry, void *user)
1276 {
1277         isl_map **map = (isl_map **)entry;
1278
1279         *map = isl_map_from_basic_map(isl_map_polyhedral_hull(*map));
1280
1281         return *map ? 0 : -1;
1282 }
1283
1284 __isl_give isl_union_map *isl_union_map_polyhedral_hull(
1285         __isl_take isl_union_map *umap)
1286 {
1287         return un_op(umap, &polyhedral_entry);
1288 }
1289
1290 __isl_give isl_union_set *isl_union_set_polyhedral_hull(
1291         __isl_take isl_union_set *uset)
1292 {
1293         return isl_union_map_polyhedral_hull(uset);
1294 }
1295
1296 static int simple_entry(void **entry, void *user)
1297 {
1298         isl_map **map = (isl_map **)entry;
1299
1300         *map = isl_map_from_basic_map(isl_map_simple_hull(*map));
1301
1302         return *map ? 0 : -1;
1303 }
1304
1305 __isl_give isl_union_map *isl_union_map_simple_hull(
1306         __isl_take isl_union_map *umap)
1307 {
1308         return un_op(umap, &simple_entry);
1309 }
1310
1311 __isl_give isl_union_set *isl_union_set_simple_hull(
1312         __isl_take isl_union_set *uset)
1313 {
1314         return isl_union_map_simple_hull(uset);
1315 }
1316
1317 static int inplace_entry(void **entry, void *user)
1318 {
1319         __isl_give isl_map *(*fn)(__isl_take isl_map *);
1320         isl_map **map = (isl_map **)entry;
1321         isl_map *copy;
1322
1323         fn = *(__isl_give isl_map *(**)(__isl_take isl_map *)) user;
1324         copy = fn(isl_map_copy(*map));
1325         if (!copy)
1326                 return -1;
1327
1328         isl_map_free(*map);
1329         *map = copy;
1330
1331         return 0;
1332 }
1333
1334 static __isl_give isl_union_map *inplace(__isl_take isl_union_map *umap,
1335         __isl_give isl_map *(*fn)(__isl_take isl_map *))
1336 {
1337         if (!umap)
1338                 return NULL;
1339
1340         if (isl_hash_table_foreach(umap->dim->ctx, &umap->table,
1341                                     &inplace_entry, &fn) < 0)
1342                 goto error;
1343
1344         return umap;
1345 error:
1346         isl_union_map_free(umap);
1347         return NULL;
1348 }
1349
1350 __isl_give isl_union_map *isl_union_map_coalesce(
1351         __isl_take isl_union_map *umap)
1352 {
1353         return inplace(umap, &isl_map_coalesce);
1354 }
1355
1356 __isl_give isl_union_set *isl_union_set_coalesce(
1357         __isl_take isl_union_set *uset)
1358 {
1359         return isl_union_map_coalesce(uset);
1360 }
1361
1362 __isl_give isl_union_map *isl_union_map_detect_equalities(
1363         __isl_take isl_union_map *umap)
1364 {
1365         return inplace(umap, &isl_map_detect_equalities);
1366 }
1367
1368 __isl_give isl_union_set *isl_union_set_detect_equalities(
1369         __isl_take isl_union_set *uset)
1370 {
1371         return isl_union_map_detect_equalities(uset);
1372 }
1373
1374 __isl_give isl_union_map *isl_union_map_compute_divs(
1375         __isl_take isl_union_map *umap)
1376 {
1377         return inplace(umap, &isl_map_compute_divs);
1378 }
1379
1380 __isl_give isl_union_set *isl_union_set_compute_divs(
1381         __isl_take isl_union_set *uset)
1382 {
1383         return isl_union_map_compute_divs(uset);
1384 }
1385
1386 static int lexmin_entry(void **entry, void *user)
1387 {
1388         isl_map **map = (isl_map **)entry;
1389
1390         *map = isl_map_lexmin(*map);
1391
1392         return *map ? 0 : -1;
1393 }
1394
1395 __isl_give isl_union_map *isl_union_map_lexmin(
1396         __isl_take isl_union_map *umap)
1397 {
1398         return un_op(umap, &lexmin_entry);
1399 }
1400
1401 __isl_give isl_union_set *isl_union_set_lexmin(
1402         __isl_take isl_union_set *uset)
1403 {
1404         return isl_union_map_lexmin(uset);
1405 }
1406
1407 static int lexmax_entry(void **entry, void *user)
1408 {
1409         isl_map **map = (isl_map **)entry;
1410
1411         *map = isl_map_lexmax(*map);
1412
1413         return *map ? 0 : -1;
1414 }
1415
1416 __isl_give isl_union_map *isl_union_map_lexmax(
1417         __isl_take isl_union_map *umap)
1418 {
1419         return un_op(umap, &lexmax_entry);
1420 }
1421
1422 __isl_give isl_union_set *isl_union_set_lexmax(
1423         __isl_take isl_union_set *uset)
1424 {
1425         return isl_union_map_lexmax(uset);
1426 }
1427
1428 static int universe_entry(void **entry, void *user)
1429 {
1430         isl_map *map = *entry;
1431         isl_union_map **res = user;
1432
1433         map = isl_map_universe(isl_map_get_space(map));
1434         *res = isl_union_map_add_map(*res, map);
1435
1436         return 0;
1437 }
1438
1439 __isl_give isl_union_map *isl_union_map_universe(__isl_take isl_union_map *umap)
1440 {
1441         return cond_un_op(umap, &universe_entry);
1442 }
1443
1444 __isl_give isl_union_set *isl_union_set_universe(__isl_take isl_union_set *uset)
1445 {
1446         return isl_union_map_universe(uset);
1447 }
1448
1449 static int reverse_entry(void **entry, void *user)
1450 {
1451         isl_map *map = *entry;
1452         isl_union_map **res = user;
1453
1454         *res = isl_union_map_add_map(*res, isl_map_reverse(isl_map_copy(map)));
1455
1456         return 0;
1457 }
1458
1459 __isl_give isl_union_map *isl_union_map_reverse(__isl_take isl_union_map *umap)
1460 {
1461         return cond_un_op(umap, &reverse_entry);
1462 }
1463
1464 static int domain_entry(void **entry, void *user)
1465 {
1466         isl_map *map = *entry;
1467         isl_union_set **res = user;
1468
1469         *res = isl_union_set_add_set(*res, isl_map_domain(isl_map_copy(map)));
1470
1471         return 0;
1472 }
1473
1474 __isl_give isl_union_set *isl_union_map_domain(__isl_take isl_union_map *umap)
1475 {
1476         return cond_un_op(umap, &domain_entry);
1477 }
1478
1479 static int range_entry(void **entry, void *user)
1480 {
1481         isl_map *map = *entry;
1482         isl_union_set **res = user;
1483
1484         *res = isl_union_set_add_set(*res, isl_map_range(isl_map_copy(map)));
1485
1486         return 0;
1487 }
1488
1489 __isl_give isl_union_set *isl_union_map_range(__isl_take isl_union_map *umap)
1490 {
1491         return cond_un_op(umap, &range_entry);
1492 }
1493
1494 static int domain_map_entry(void **entry, void *user)
1495 {
1496         isl_map *map = *entry;
1497         isl_union_set **res = user;
1498
1499         *res = isl_union_map_add_map(*res,
1500                                         isl_map_domain_map(isl_map_copy(map)));
1501
1502         return 0;
1503 }
1504
1505 __isl_give isl_union_map *isl_union_map_domain_map(
1506         __isl_take isl_union_map *umap)
1507 {
1508         return cond_un_op(umap, &domain_map_entry);
1509 }
1510
1511 static int range_map_entry(void **entry, void *user)
1512 {
1513         isl_map *map = *entry;
1514         isl_union_set **res = user;
1515
1516         *res = isl_union_map_add_map(*res,
1517                                         isl_map_range_map(isl_map_copy(map)));
1518
1519         return 0;
1520 }
1521
1522 __isl_give isl_union_map *isl_union_map_range_map(
1523         __isl_take isl_union_map *umap)
1524 {
1525         return cond_un_op(umap, &range_map_entry);
1526 }
1527
1528 static int deltas_entry(void **entry, void *user)
1529 {
1530         isl_map *map = *entry;
1531         isl_union_set **res = user;
1532
1533         if (!isl_space_tuple_match(map->dim, isl_dim_in, map->dim, isl_dim_out))
1534                 return 0;
1535
1536         *res = isl_union_set_add_set(*res, isl_map_deltas(isl_map_copy(map)));
1537
1538         return 0;
1539 }
1540
1541 __isl_give isl_union_set *isl_union_map_deltas(__isl_take isl_union_map *umap)
1542 {
1543         return cond_un_op(umap, &deltas_entry);
1544 }
1545
1546 static int deltas_map_entry(void **entry, void *user)
1547 {
1548         isl_map *map = *entry;
1549         isl_union_map **res = user;
1550
1551         if (!isl_space_tuple_match(map->dim, isl_dim_in, map->dim, isl_dim_out))
1552                 return 0;
1553
1554         *res = isl_union_map_add_map(*res,
1555                                      isl_map_deltas_map(isl_map_copy(map)));
1556
1557         return 0;
1558 }
1559
1560 __isl_give isl_union_map *isl_union_map_deltas_map(
1561         __isl_take isl_union_map *umap)
1562 {
1563         return cond_un_op(umap, &deltas_map_entry);
1564 }
1565
1566 static int identity_entry(void **entry, void *user)
1567 {
1568         isl_set *set = *entry;
1569         isl_union_map **res = user;
1570
1571         *res = isl_union_map_add_map(*res, isl_set_identity(isl_set_copy(set)));
1572
1573         return 0;
1574 }
1575
1576 __isl_give isl_union_map *isl_union_set_identity(__isl_take isl_union_set *uset)
1577 {
1578         return cond_un_op(uset, &identity_entry);
1579 }
1580
1581 static int unwrap_entry(void **entry, void *user)
1582 {
1583         isl_set *set = *entry;
1584         isl_union_set **res = user;
1585
1586         if (!isl_set_is_wrapping(set))
1587                 return 0;
1588
1589         *res = isl_union_map_add_map(*res, isl_set_unwrap(isl_set_copy(set)));
1590
1591         return 0;
1592 }
1593
1594 __isl_give isl_union_map *isl_union_set_unwrap(__isl_take isl_union_set *uset)
1595 {
1596         return cond_un_op(uset, &unwrap_entry);
1597 }
1598
1599 static int wrap_entry(void **entry, void *user)
1600 {
1601         isl_map *map = *entry;
1602         isl_union_set **res = user;
1603
1604         *res = isl_union_set_add_set(*res, isl_map_wrap(isl_map_copy(map)));
1605
1606         return 0;
1607 }
1608
1609 __isl_give isl_union_set *isl_union_map_wrap(__isl_take isl_union_map *umap)
1610 {
1611         return cond_un_op(umap, &wrap_entry);
1612 }
1613
1614 struct isl_union_map_is_subset_data {
1615         isl_union_map *umap2;
1616         int is_subset;
1617 };
1618
1619 static int is_subset_entry(void **entry, void *user)
1620 {
1621         struct isl_union_map_is_subset_data *data = user;
1622         uint32_t hash;
1623         struct isl_hash_table_entry *entry2;
1624         isl_map *map = *entry;
1625
1626         hash = isl_space_get_hash(map->dim);
1627         entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
1628                                      hash, &has_dim, map->dim, 0);
1629         if (!entry2) {
1630                 data->is_subset = 0;
1631                 return -1;
1632         }
1633
1634         data->is_subset = isl_map_is_subset(map, entry2->data);
1635         if (data->is_subset < 0 || !data->is_subset)
1636                 return -1;
1637
1638         return 0;
1639 }
1640
1641 int isl_union_map_is_subset(__isl_keep isl_union_map *umap1,
1642         __isl_keep isl_union_map *umap2)
1643 {
1644         struct isl_union_map_is_subset_data data = { NULL, 1 };
1645
1646         umap1 = isl_union_map_copy(umap1);
1647         umap2 = isl_union_map_copy(umap2);
1648         umap1 = isl_union_map_align_params(umap1, isl_union_map_get_space(umap2));
1649         umap2 = isl_union_map_align_params(umap2, isl_union_map_get_space(umap1));
1650
1651         if (!umap1 || !umap2)
1652                 goto error;
1653
1654         data.umap2 = umap2;
1655         if (isl_hash_table_foreach(umap1->dim->ctx, &umap1->table,
1656                                    &is_subset_entry, &data) < 0 &&
1657             data.is_subset)
1658                 goto error;
1659
1660         isl_union_map_free(umap1);
1661         isl_union_map_free(umap2);
1662
1663         return data.is_subset;
1664 error:
1665         isl_union_map_free(umap1);
1666         isl_union_map_free(umap2);
1667         return -1;
1668 }
1669
1670 int isl_union_set_is_subset(__isl_keep isl_union_set *uset1,
1671         __isl_keep isl_union_set *uset2)
1672 {
1673         return isl_union_map_is_subset(uset1, uset2);
1674 }
1675
1676 int isl_union_map_is_equal(__isl_keep isl_union_map *umap1,
1677         __isl_keep isl_union_map *umap2)
1678 {
1679         int is_subset;
1680
1681         if (!umap1 || !umap2)
1682                 return -1;
1683         is_subset = isl_union_map_is_subset(umap1, umap2);
1684         if (is_subset != 1)
1685                 return is_subset;
1686         is_subset = isl_union_map_is_subset(umap2, umap1);
1687         return is_subset;
1688 }
1689
1690 int isl_union_set_is_equal(__isl_keep isl_union_set *uset1,
1691         __isl_keep isl_union_set *uset2)
1692 {
1693         return isl_union_map_is_equal(uset1, uset2);
1694 }
1695
1696 int isl_union_map_is_strict_subset(__isl_keep isl_union_map *umap1,
1697         __isl_keep isl_union_map *umap2)
1698 {
1699         int is_subset;
1700
1701         if (!umap1 || !umap2)
1702                 return -1;
1703         is_subset = isl_union_map_is_subset(umap1, umap2);
1704         if (is_subset != 1)
1705                 return is_subset;
1706         is_subset = isl_union_map_is_subset(umap2, umap1);
1707         if (is_subset == -1)
1708                 return is_subset;
1709         return !is_subset;
1710 }
1711
1712 int isl_union_set_is_strict_subset(__isl_keep isl_union_set *uset1,
1713         __isl_keep isl_union_set *uset2)
1714 {
1715         return isl_union_map_is_strict_subset(uset1, uset2);
1716 }
1717
1718 static int sample_entry(void **entry, void *user)
1719 {
1720         isl_basic_map **sample = (isl_basic_map **)user;
1721         isl_map *map = *entry;
1722
1723         *sample = isl_map_sample(isl_map_copy(map));
1724         if (!*sample)
1725                 return -1;
1726         if (!isl_basic_map_plain_is_empty(*sample))
1727                 return -1;
1728         return 0;
1729 }
1730
1731 __isl_give isl_basic_map *isl_union_map_sample(__isl_take isl_union_map *umap)
1732 {
1733         isl_basic_map *sample = NULL;
1734
1735         if (!umap)
1736                 return NULL;
1737
1738         if (isl_hash_table_foreach(umap->dim->ctx, &umap->table,
1739                                    &sample_entry, &sample) < 0 &&
1740             !sample)
1741                 goto error;
1742
1743         if (!sample)
1744                 sample = isl_basic_map_empty(isl_union_map_get_space(umap));
1745
1746         isl_union_map_free(umap);
1747
1748         return sample;
1749 error:
1750         isl_union_map_free(umap);
1751         return NULL;
1752 }
1753
1754 __isl_give isl_basic_set *isl_union_set_sample(__isl_take isl_union_set *uset)
1755 {
1756         return (isl_basic_set *)isl_union_map_sample(uset);
1757 }
1758
1759 struct isl_forall_data {
1760         int res;
1761         int (*fn)(__isl_keep isl_map *map);
1762 };
1763
1764 static int forall_entry(void **entry, void *user)
1765 {
1766         struct isl_forall_data *data = user;
1767         isl_map *map = *entry;
1768
1769         data->res = data->fn(map);
1770         if (data->res < 0)
1771                 return -1;
1772
1773         if (!data->res)
1774                 return -1;
1775
1776         return 0;
1777 }
1778
1779 static int union_map_forall(__isl_keep isl_union_map *umap,
1780         int (*fn)(__isl_keep isl_map *map))
1781 {
1782         struct isl_forall_data data = { 1, fn };
1783
1784         if (!umap)
1785                 return -1;
1786
1787         if (isl_hash_table_foreach(umap->dim->ctx, &umap->table,
1788                                    &forall_entry, &data) < 0 && data.res)
1789                 return -1;
1790
1791         return data.res;
1792 }
1793
1794 struct isl_forall_user_data {
1795         int res;
1796         int (*fn)(__isl_keep isl_map *map, void *user);
1797         void *user;
1798 };
1799
1800 static int forall_user_entry(void **entry, void *user)
1801 {
1802         struct isl_forall_user_data *data = user;
1803         isl_map *map = *entry;
1804
1805         data->res = data->fn(map, data->user);
1806         if (data->res < 0)
1807                 return -1;
1808
1809         if (!data->res)
1810                 return -1;
1811
1812         return 0;
1813 }
1814
1815 /* Check if fn(map, user) returns true for all maps "map" in umap.
1816  */
1817 static int union_map_forall_user(__isl_keep isl_union_map *umap,
1818         int (*fn)(__isl_keep isl_map *map, void *user), void *user)
1819 {
1820         struct isl_forall_user_data data = { 1, fn, user };
1821
1822         if (!umap)
1823                 return -1;
1824
1825         if (isl_hash_table_foreach(umap->dim->ctx, &umap->table,
1826                                    &forall_user_entry, &data) < 0 && data.res)
1827                 return -1;
1828
1829         return data.res;
1830 }
1831
1832 int isl_union_map_is_empty(__isl_keep isl_union_map *umap)
1833 {
1834         return union_map_forall(umap, &isl_map_is_empty);
1835 }
1836
1837 int isl_union_set_is_empty(__isl_keep isl_union_set *uset)
1838 {
1839         return isl_union_map_is_empty(uset);
1840 }
1841
1842 static int is_subset_of_identity(__isl_keep isl_map *map)
1843 {
1844         int is_subset;
1845         isl_space *dim;
1846         isl_map *id;
1847
1848         if (!map)
1849                 return -1;
1850
1851         if (!isl_space_tuple_match(map->dim, isl_dim_in, map->dim, isl_dim_out))
1852                 return 0;
1853
1854         dim = isl_map_get_space(map);
1855         id = isl_map_identity(dim);
1856
1857         is_subset = isl_map_is_subset(map, id);
1858
1859         isl_map_free(id);
1860
1861         return is_subset;
1862 }
1863
1864 /* Check if the given map is single-valued.
1865  * We simply compute
1866  *
1867  *      M \circ M^-1
1868  *
1869  * and check if the result is a subset of the identity mapping.
1870  */
1871 int isl_union_map_is_single_valued(__isl_keep isl_union_map *umap)
1872 {
1873         isl_union_map *test;
1874         int sv;
1875
1876         if (isl_union_map_n_map(umap) == 1) {
1877                 isl_map *map;
1878                 umap = isl_union_map_copy(umap);
1879                 map = isl_map_from_union_map(umap);
1880                 sv = isl_map_is_single_valued(map);
1881                 isl_map_free(map);
1882                 return sv;
1883         }
1884
1885         test = isl_union_map_reverse(isl_union_map_copy(umap));
1886         test = isl_union_map_apply_range(test, isl_union_map_copy(umap));
1887
1888         sv = union_map_forall(test, &is_subset_of_identity);
1889
1890         isl_union_map_free(test);
1891
1892         return sv;
1893 }
1894
1895 int isl_union_map_is_injective(__isl_keep isl_union_map *umap)
1896 {
1897         int in;
1898
1899         umap = isl_union_map_copy(umap);
1900         umap = isl_union_map_reverse(umap);
1901         in = isl_union_map_is_single_valued(umap);
1902         isl_union_map_free(umap);
1903
1904         return in;
1905 }
1906
1907 /* Represents a map that has a fixed value (v) for one of its
1908  * range dimensions.
1909  * The map in this structure is not reference counted, so it
1910  * is only valid while the isl_union_map from which it was
1911  * obtained is still alive.
1912  */
1913 struct isl_fixed_map {
1914         isl_int v;
1915         isl_map *map;
1916 };
1917
1918 static struct isl_fixed_map *alloc_isl_fixed_map_array(isl_ctx *ctx,
1919         int n)
1920 {
1921         int i;
1922         struct isl_fixed_map *v;
1923
1924         v = isl_calloc_array(ctx, struct isl_fixed_map, n);
1925         if (!v)
1926                 return NULL;
1927         for (i = 0; i < n; ++i)
1928                 isl_int_init(v[i].v);
1929         return v;
1930 }
1931
1932 static void free_isl_fixed_map_array(struct isl_fixed_map *v, int n)
1933 {
1934         int i;
1935
1936         if (!v)
1937                 return;
1938         for (i = 0; i < n; ++i)
1939                 isl_int_clear(v[i].v);
1940         free(v);
1941 }
1942
1943 /* Compare the "v" field of two isl_fixed_map structs.
1944  */
1945 static int qsort_fixed_map_cmp(const void *p1, const void *p2)
1946 {
1947         const struct isl_fixed_map *e1 = (const struct isl_fixed_map *) p1;
1948         const struct isl_fixed_map *e2 = (const struct isl_fixed_map *) p2;
1949
1950         return isl_int_cmp(e1->v, e2->v);
1951 }
1952
1953 /* Internal data structure used while checking whether all maps
1954  * in a union_map have a fixed value for a given output dimension.
1955  * v is the list of maps, with the fixed value for the dimension
1956  * n is the number of maps considered so far
1957  * pos is the output dimension under investigation
1958  */
1959 struct isl_fixed_dim_data {
1960         struct isl_fixed_map *v;
1961         int n;
1962         int pos;
1963 };
1964
1965 static int fixed_at_pos(__isl_keep isl_map *map, void *user)
1966 {
1967         struct isl_fixed_dim_data *data = user;
1968
1969         data->v[data->n].map = map;
1970         return isl_map_plain_is_fixed(map, isl_dim_out, data->pos,
1971                                       &data->v[data->n++].v);
1972 }
1973
1974 static int plain_injective_on_range(__isl_take isl_union_map *umap,
1975         int first, int n_range);
1976
1977 /* Given a list of the maps, with their fixed values at output dimension "pos",
1978  * check whether the ranges of the maps form an obvious partition.
1979  *
1980  * We first sort the maps according to their fixed values.
1981  * If all maps have a different value, then we know the ranges form
1982  * a partition.
1983  * Otherwise, we collect the maps with the same fixed value and
1984  * check whether each such collection is obviously injective
1985  * based on later dimensions.
1986  */
1987 static int separates(struct isl_fixed_map *v, int n,
1988         __isl_take isl_space *dim, int pos, int n_range)
1989 {
1990         int i;
1991
1992         if (!v)
1993                 goto error;
1994
1995         qsort(v, n, sizeof(*v), &qsort_fixed_map_cmp);
1996
1997         for (i = 0; i + 1 < n; ++i) {
1998                 int j, k;
1999                 isl_union_map *part;
2000                 int injective;
2001
2002                 for (j = i + 1; j < n; ++j)
2003                         if (isl_int_ne(v[i].v, v[j].v))
2004                                 break;
2005
2006                 if (j == i + 1)
2007                         continue;
2008
2009                 part = isl_union_map_alloc(isl_space_copy(dim), j - i);
2010                 for (k = i; k < j; ++k)
2011                         part = isl_union_map_add_map(part,
2012                                                      isl_map_copy(v[k].map));
2013
2014                 injective = plain_injective_on_range(part, pos + 1, n_range);
2015                 if (injective < 0)
2016                         goto error;
2017                 if (!injective)
2018                         break;
2019
2020                 i = j - 1;
2021         }
2022
2023         isl_space_free(dim);
2024         free_isl_fixed_map_array(v, n);
2025         return i + 1 >= n;
2026 error:
2027         isl_space_free(dim);
2028         free_isl_fixed_map_array(v, n);
2029         return -1;
2030 }
2031
2032 /* Check whether the maps in umap have obviously distinct ranges.
2033  * In particular, check for an output dimension in the range
2034  * [first,n_range) for which all maps have a fixed value
2035  * and then check if these values, possibly along with fixed values
2036  * at later dimensions, entail distinct ranges.
2037  */
2038 static int plain_injective_on_range(__isl_take isl_union_map *umap,
2039         int first, int n_range)
2040 {
2041         isl_ctx *ctx;
2042         int n;
2043         struct isl_fixed_dim_data data = { NULL };
2044
2045         ctx = isl_union_map_get_ctx(umap);
2046
2047         if (!umap)
2048                 goto error;
2049
2050         n = isl_union_map_n_map(umap);
2051         if (n <= 1) {
2052                 isl_union_map_free(umap);
2053                 return 1;
2054         }
2055
2056         if (first >= n_range) {
2057                 isl_union_map_free(umap);
2058                 return 0;
2059         }
2060
2061         data.v = alloc_isl_fixed_map_array(ctx, n);
2062         if (!data.v)
2063                 goto error;
2064
2065         for (data.pos = first; data.pos < n_range; ++data.pos) {
2066                 int fixed;
2067                 int injective;
2068                 isl_space *dim;
2069
2070                 data.n = 0;
2071                 fixed = union_map_forall_user(umap, &fixed_at_pos, &data);
2072                 if (fixed < 0)
2073                         goto error;
2074                 if (!fixed)
2075                         continue;
2076                 dim = isl_union_map_get_space(umap);
2077                 injective = separates(data.v, n, dim, data.pos, n_range);
2078                 isl_union_map_free(umap);
2079                 return injective;
2080         }
2081
2082         free_isl_fixed_map_array(data.v, n);
2083         isl_union_map_free(umap);
2084
2085         return 0;
2086 error:
2087         free_isl_fixed_map_array(data.v, n);
2088         isl_union_map_free(umap);
2089         return -1;
2090 }
2091
2092 /* Check whether the maps in umap that map to subsets of "ran"
2093  * have obviously distinct ranges.
2094  */
2095 static int plain_injective_on_range_wrap(__isl_keep isl_set *ran, void *user)
2096 {
2097         isl_union_map *umap = user;
2098
2099         umap = isl_union_map_copy(umap);
2100         umap = isl_union_map_intersect_range(umap,
2101                         isl_union_set_from_set(isl_set_copy(ran)));
2102         return plain_injective_on_range(umap, 0, isl_set_dim(ran, isl_dim_set));
2103 }
2104
2105 /* Check if the given union_map is obviously injective.
2106  *
2107  * In particular, we first check if all individual maps are obviously
2108  * injective and then check if all the ranges of these maps are
2109  * obviously disjoint.
2110  */
2111 int isl_union_map_plain_is_injective(__isl_keep isl_union_map *umap)
2112 {
2113         int in;
2114         isl_union_map *univ;
2115         isl_union_set *ran;
2116
2117         in = union_map_forall(umap, &isl_map_plain_is_injective);
2118         if (in < 0)
2119                 return -1;
2120         if (!in)
2121                 return 0;
2122
2123         univ = isl_union_map_universe(isl_union_map_copy(umap));
2124         ran = isl_union_map_range(univ);
2125
2126         in = union_map_forall_user(ran, &plain_injective_on_range_wrap, umap);
2127
2128         isl_union_set_free(ran);
2129
2130         return in;
2131 }
2132
2133 int isl_union_map_is_bijective(__isl_keep isl_union_map *umap)
2134 {
2135         int sv;
2136
2137         sv = isl_union_map_is_single_valued(umap);
2138         if (sv < 0 || !sv)
2139                 return sv;
2140
2141         return isl_union_map_is_injective(umap);
2142 }
2143
2144 static int zip_entry(void **entry, void *user)
2145 {
2146         isl_map *map = *entry;
2147         isl_union_map **res = user;
2148
2149         if (!isl_map_can_zip(map))
2150                 return 0;
2151
2152         *res = isl_union_map_add_map(*res, isl_map_zip(isl_map_copy(map)));
2153
2154         return 0;
2155 }
2156
2157 __isl_give isl_union_map *isl_union_map_zip(__isl_take isl_union_map *umap)
2158 {
2159         return cond_un_op(umap, &zip_entry);
2160 }
2161
2162 static int lift_entry(void **entry, void *user)
2163 {
2164         isl_set *set = *entry;
2165         isl_union_set **res = user;
2166
2167         *res = isl_union_set_add_set(*res, isl_set_lift(isl_set_copy(set)));
2168
2169         return 0;
2170 }
2171
2172 __isl_give isl_union_set *isl_union_set_lift(__isl_take isl_union_set *uset)
2173 {
2174         return cond_un_op(uset, &lift_entry);
2175 }
2176
2177 static int coefficients_entry(void **entry, void *user)
2178 {
2179         isl_set *set = *entry;
2180         isl_union_set **res = user;
2181
2182         set = isl_set_copy(set);
2183         set = isl_set_from_basic_set(isl_set_coefficients(set));
2184         *res = isl_union_set_add_set(*res, set);
2185
2186         return 0;
2187 }
2188
2189 __isl_give isl_union_set *isl_union_set_coefficients(
2190         __isl_take isl_union_set *uset)
2191 {
2192         isl_ctx *ctx;
2193         isl_space *dim;
2194         isl_union_set *res;
2195
2196         if (!uset)
2197                 return NULL;
2198
2199         ctx = isl_union_set_get_ctx(uset);
2200         dim = isl_space_set_alloc(ctx, 0, 0);
2201         res = isl_union_map_alloc(dim, uset->table.n);
2202         if (isl_hash_table_foreach(uset->dim->ctx, &uset->table,
2203                                    &coefficients_entry, &res) < 0)
2204                 goto error;
2205
2206         isl_union_set_free(uset);
2207         return res;
2208 error:
2209         isl_union_set_free(uset);
2210         isl_union_set_free(res);
2211         return NULL;
2212 }
2213
2214 static int solutions_entry(void **entry, void *user)
2215 {
2216         isl_set *set = *entry;
2217         isl_union_set **res = user;
2218
2219         set = isl_set_copy(set);
2220         set = isl_set_from_basic_set(isl_set_solutions(set));
2221         if (!*res)
2222                 *res = isl_union_set_from_set(set);
2223         else
2224                 *res = isl_union_set_add_set(*res, set);
2225
2226         if (!*res)
2227                 return -1;
2228
2229         return 0;
2230 }
2231
2232 __isl_give isl_union_set *isl_union_set_solutions(
2233         __isl_take isl_union_set *uset)
2234 {
2235         isl_union_set *res = NULL;
2236
2237         if (!uset)
2238                 return NULL;
2239
2240         if (uset->table.n == 0) {
2241                 res = isl_union_set_empty(isl_union_set_get_space(uset));
2242                 isl_union_set_free(uset);
2243                 return res;
2244         }
2245
2246         if (isl_hash_table_foreach(uset->dim->ctx, &uset->table,
2247                                    &solutions_entry, &res) < 0)
2248                 goto error;
2249
2250         isl_union_set_free(uset);
2251         return res;
2252 error:
2253         isl_union_set_free(uset);
2254         isl_union_set_free(res);
2255         return NULL;
2256 }