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 struct isl_union_map_match_bin_data {
 650         isl_union_map *umap2;
 651         isl_union_map *res;
 652         __isl_give isl_map *(*fn)(__isl_take isl_map*, __isl_take isl_map*);
 653 };
 654
 655 static int match_bin_entry(void **entry, void *user)
 656 {
 657         struct isl_union_map_match_bin_data *data = user;
 658         uint32_t hash;
 659         struct isl_hash_table_entry *entry2;
 660         isl_map *map = *entry;
 661         int empty;
 662
 663         hash = isl_space_get_hash(map->dim);
 664         entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
 665                                      hash, &has_dim, map->dim, 0);
 666         if (!entry2)
 667                 return 0;
 668
 669         map = isl_map_copy(map);
 670         map = data->fn(map, isl_map_copy(entry2->data));
 671
 672         empty = isl_map_is_empty(map);
 673         if (empty < 0) {
 674                 isl_map_free(map);
 675                 return -1;
 676         }
 677         if (empty) {
 678                 isl_map_free(map);
 679                 return 0;
 680         }
 681
 682         data->res = isl_union_map_add_map(data->res, map);
 683
 684         return 0;
 685 }
 686
 687 static __isl_give isl_union_map *match_bin_op(__isl_take isl_union_map *umap1,
 688         __isl_take isl_union_map *umap2,
 689         __isl_give isl_map *(*fn)(__isl_take isl_map*, __isl_take isl_map*))
 690 {
 691         struct isl_union_map_match_bin_data data = { NULL, NULL, fn };
 692
 693         umap1 = isl_union_map_align_params(umap1, isl_union_map_get_space(umap2));
 694         umap2 = isl_union_map_align_params(umap2, isl_union_map_get_space(umap1));
 695
 696         if (!umap1 || !umap2)
 697                 goto error;
 698
 699         data.umap2 = umap2;
 700         data.res = isl_union_map_alloc(isl_space_copy(umap1->dim),
 701                                        umap1->table.n);
 702         if (isl_hash_table_foreach(umap1->dim->ctx, &umap1->table,
 703                                    &match_bin_entry, &data) < 0)
 704                 goto error;
 705
 706         isl_union_map_free(umap1);
 707         isl_union_map_free(umap2);
 708         return data.res;
 709 error:
 710         isl_union_map_free(umap1);
 711         isl_union_map_free(umap2);
 712         isl_union_map_free(data.res);
 713         return NULL;
 714 }
 715
 716 __isl_give isl_union_map *isl_union_map_intersect(
 717         __isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2)
 718 {
 719         return match_bin_op(umap1, umap2, &isl_map_intersect);
 720 }
 721
 722 /* Compute the intersection of the two union_sets.
 723  * As a special case, if exactly one of the two union_sets
 724  * is a parameter domain, then intersect the parameter domain
 725  * of the other one with this set.
 726  */
 727 __isl_give isl_union_set *isl_union_set_intersect(
 728         __isl_take isl_union_set *uset1, __isl_take isl_union_set *uset2)
 729 {
 730         int p1, p2;
 731
 732         p1 = isl_union_set_is_params(uset1);
 733         p2 = isl_union_set_is_params(uset2);
 734         if (p1 < 0 || p2 < 0)
 735                 goto error;
 736         if (!p1 && p2)
 737                 return union_map_intersect_params(uset1, uset2);
 738         if (p1 && !p2)
 739                 return union_map_intersect_params(uset2, uset1);
 740         return isl_union_map_intersect(uset1, uset2);
 741 error:
 742         isl_union_set_free(uset1);
 743         isl_union_set_free(uset2);
 744         return NULL;
 745 }
 746
 747 __isl_give isl_union_map *isl_union_map_gist(__isl_take isl_union_map *umap,
 748         __isl_take isl_union_map *context)
 749 {
 750         return match_bin_op(umap, context, &isl_map_gist);
 751 }
 752
 753 __isl_give isl_union_set *isl_union_set_gist(__isl_take isl_union_set *uset,
 754         __isl_take isl_union_set *context)
 755 {
 756         return isl_union_map_gist(uset, context);
 757 }
 758
 759 static __isl_give isl_map *lex_le_set(__isl_take isl_map *set1,
 760         __isl_take isl_map *set2)
 761 {
 762         return isl_set_lex_le_set((isl_set *)set1, (isl_set *)set2);
 763 }
 764
 765 static __isl_give isl_map *lex_lt_set(__isl_take isl_map *set1,
 766         __isl_take isl_map *set2)
 767 {
 768         return isl_set_lex_lt_set((isl_set *)set1, (isl_set *)set2);
 769 }
 770
 771 __isl_give isl_union_map *isl_union_set_lex_lt_union_set(
 772         __isl_take isl_union_set *uset1, __isl_take isl_union_set *uset2)
 773 {
 774         return match_bin_op(uset1, uset2, &lex_lt_set);
 775 }
 776
 777 __isl_give isl_union_map *isl_union_set_lex_le_union_set(
 778         __isl_take isl_union_set *uset1, __isl_take isl_union_set *uset2)
 779 {
 780         return match_bin_op(uset1, uset2, &lex_le_set);
 781 }
 782
 783 __isl_give isl_union_map *isl_union_set_lex_gt_union_set(
 784         __isl_take isl_union_set *uset1, __isl_take isl_union_set *uset2)
 785 {
 786         return isl_union_map_reverse(isl_union_set_lex_lt_union_set(uset2, uset1));
 787 }
 788
 789 __isl_give isl_union_map *isl_union_set_lex_ge_union_set(
 790         __isl_take isl_union_set *uset1, __isl_take isl_union_set *uset2)
 791 {
 792         return isl_union_map_reverse(isl_union_set_lex_le_union_set(uset2, uset1));
 793 }
 794
 795 __isl_give isl_union_map *isl_union_map_lex_gt_union_map(
 796         __isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2)
 797 {
 798         return isl_union_map_reverse(isl_union_map_lex_lt_union_map(umap2, umap1));
 799 }
 800
 801 __isl_give isl_union_map *isl_union_map_lex_ge_union_map(
 802         __isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2)
 803 {
 804         return isl_union_map_reverse(isl_union_map_lex_le_union_map(umap2, umap1));
 805 }
 806
 807 static int intersect_domain_entry(void **entry, void *user)
 808 {
 809         struct isl_union_map_gen_bin_data *data = user;
 810         uint32_t hash;
 811         struct isl_hash_table_entry *entry2;
 812         isl_space *dim;
 813         isl_map *map = *entry;
 814         int empty;
 815
 816         dim = isl_map_get_space(map);
 817         dim = isl_space_domain(dim);
 818         hash = isl_space_get_hash(dim);
 819         entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
 820                                      hash, &has_dim, dim, 0);
 821         isl_space_free(dim);
 822         if (!entry2)
 823                 return 0;
 824
 825         map = isl_map_copy(map);
 826         map = isl_map_intersect_domain(map, isl_set_copy(entry2->data));
 827
 828         empty = isl_map_is_empty(map);
 829         if (empty < 0) {
 830                 isl_map_free(map);
 831                 return -1;
 832         }
 833         if (empty) {
 834                 isl_map_free(map);
 835                 return 0;
 836         }
 837
 838         data->res = isl_union_map_add_map(data->res, map);
 839
 840         return 0;
 841 }
 842
 843 /* Intersect the domain of "umap" with "uset".
 844  * If "uset" is a parameters domain, then intersect the parameter
 845  * domain of "umap" with this set.
 846  */
 847 __isl_give isl_union_map *isl_union_map_intersect_domain(
 848         __isl_take isl_union_map *umap, __isl_take isl_union_set *uset)
 849 {
 850         if (isl_union_set_is_params(uset))
 851                 return union_map_intersect_params(umap, uset);
 852         return gen_bin_op(umap, uset, &intersect_domain_entry);
 853 }
 854
 855 static int intersect_range_entry(void **entry, void *user)
 856 {
 857         struct isl_union_map_gen_bin_data *data = user;
 858         uint32_t hash;
 859         struct isl_hash_table_entry *entry2;
 860         isl_space *dim;
 861         isl_map *map = *entry;
 862         int empty;
 863
 864         dim = isl_map_get_space(map);
 865         dim = isl_space_range(dim);
 866         hash = isl_space_get_hash(dim);
 867         entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
 868                                      hash, &has_dim, dim, 0);
 869         isl_space_free(dim);
 870         if (!entry2)
 871                 return 0;
 872
 873         map = isl_map_copy(map);
 874         map = isl_map_intersect_range(map, isl_set_copy(entry2->data));
 875
 876         empty = isl_map_is_empty(map);
 877         if (empty < 0) {
 878                 isl_map_free(map);
 879                 return -1;
 880         }
 881         if (empty) {
 882                 isl_map_free(map);
 883                 return 0;
 884         }
 885
 886         data->res = isl_union_map_add_map(data->res, map);
 887
 888         return 0;
 889 }
 890
 891 __isl_give isl_union_map *isl_union_map_intersect_range(
 892         __isl_take isl_union_map *umap, __isl_take isl_union_set *uset)
 893 {
 894         return gen_bin_op(umap, uset, &intersect_range_entry);
 895 }
 896
 897 struct isl_union_map_bin_data {
 898         isl_union_map *umap2;
 899         isl_union_map *res;
 900         isl_map *map;
 901         int (*fn)(void **entry, void *user);
 902 };
 903
 904 static int apply_range_entry(void **entry, void *user)
 905 {
 906         struct isl_union_map_bin_data *data = user;
 907         isl_map *map2 = *entry;
 908         int empty;
 909
 910         if (!isl_space_tuple_match(data->map->dim, isl_dim_out,
 911                                  map2->dim, isl_dim_in))
 912                 return 0;
 913
 914         map2 = isl_map_apply_range(isl_map_copy(data->map), isl_map_copy(map2));
 915
 916         empty = isl_map_is_empty(map2);
 917         if (empty < 0) {
 918                 isl_map_free(map2);
 919                 return -1;
 920         }
 921         if (empty) {
 922                 isl_map_free(map2);
 923                 return 0;
 924         }
 925
 926         data->res = isl_union_map_add_map(data->res, map2);
 927
 928         return 0;
 929 }
 930
 931 static int bin_entry(void **entry, void *user)
 932 {
 933         struct isl_union_map_bin_data *data = user;
 934         isl_map *map = *entry;
 935
 936         data->map = map;
 937         if (isl_hash_table_foreach(data->umap2->dim->ctx, &data->umap2->table,
 938                                    data->fn, data) < 0)
 939                 return -1;
 940
 941         return 0;
 942 }
 943
 944 static __isl_give isl_union_map *bin_op(__isl_take isl_union_map *umap1,
 945         __isl_take isl_union_map *umap2, int (*fn)(void **entry, void *user))
 946 {
 947         struct isl_union_map_bin_data data = { NULL, NULL, NULL, fn };
 948
 949         umap1 = isl_union_map_align_params(umap1, isl_union_map_get_space(umap2));
 950         umap2 = isl_union_map_align_params(umap2, isl_union_map_get_space(umap1));
 951
 952         if (!umap1 || !umap2)
 953                 goto error;
 954
 955         data.umap2 = umap2;
 956         data.res = isl_union_map_alloc(isl_space_copy(umap1->dim),
 957                                        umap1->table.n);
 958         if (isl_hash_table_foreach(umap1->dim->ctx, &umap1->table,
 959                                    &bin_entry, &data) < 0)
 960                 goto error;
 961
 962         isl_union_map_free(umap1);
 963         isl_union_map_free(umap2);
 964         return data.res;
 965 error:
 966         isl_union_map_free(umap1);
 967         isl_union_map_free(umap2);
 968         isl_union_map_free(data.res);
 969         return NULL;
 970 }
 971
 972 __isl_give isl_union_map *isl_union_map_apply_range(
 973         __isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2)
 974 {
 975         return bin_op(umap1, umap2, &apply_range_entry);
 976 }
 977
 978 __isl_give isl_union_map *isl_union_map_apply_domain(
 979         __isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2)
 980 {
 981         umap1 = isl_union_map_reverse(umap1);
 982         umap1 = isl_union_map_apply_range(umap1, umap2);
 983         return isl_union_map_reverse(umap1);
 984 }
 985
 986 __isl_give isl_union_set *isl_union_set_apply(
 987         __isl_take isl_union_set *uset, __isl_take isl_union_map *umap)
 988 {
 989         return isl_union_map_apply_range(uset, umap);
 990 }
 991
 992 static int map_lex_lt_entry(void **entry, void *user)
 993 {
 994         struct isl_union_map_bin_data *data = user;
 995         isl_map *map2 = *entry;
 996
 997         if (!isl_space_tuple_match(data->map->dim, isl_dim_out,
 998                                  map2->dim, isl_dim_out))
 999                 return 0;
1000
1001         map2 = isl_map_lex_lt_map(isl_map_copy(data->map), isl_map_copy(map2));
1002
1003         data->res = isl_union_map_add_map(data->res, map2);
1004
1005         return 0;
1006 }
1007
1008 __isl_give isl_union_map *isl_union_map_lex_lt_union_map(
1009         __isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2)
1010 {
1011         return bin_op(umap1, umap2, &map_lex_lt_entry);
1012 }
1013
1014 static int map_lex_le_entry(void **entry, void *user)
1015 {
1016         struct isl_union_map_bin_data *data = user;
1017         isl_map *map2 = *entry;
1018
1019         if (!isl_space_tuple_match(data->map->dim, isl_dim_out,
1020                                  map2->dim, isl_dim_out))
1021                 return 0;
1022
1023         map2 = isl_map_lex_le_map(isl_map_copy(data->map), isl_map_copy(map2));
1024
1025         data->res = isl_union_map_add_map(data->res, map2);
1026
1027         return 0;
1028 }
1029
1030 __isl_give isl_union_map *isl_union_map_lex_le_union_map(
1031         __isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2)
1032 {
1033         return bin_op(umap1, umap2, &map_lex_le_entry);
1034 }
1035
1036 static int product_entry(void **entry, void *user)
1037 {
1038         struct isl_union_map_bin_data *data = user;
1039         isl_map *map2 = *entry;
1040
1041         map2 = isl_map_product(isl_map_copy(data->map), isl_map_copy(map2));
1042
1043         data->res = isl_union_map_add_map(data->res, map2);
1044
1045         return 0;
1046 }
1047
1048 __isl_give isl_union_map *isl_union_map_product(__isl_take isl_union_map *umap1,
1049         __isl_take isl_union_map *umap2)
1050 {
1051         return bin_op(umap1, umap2, &product_entry);
1052 }
1053
1054 __isl_give isl_union_set *isl_union_set_product(__isl_take isl_union_set *uset1,
1055         __isl_take isl_union_set *uset2)
1056 {
1057         return isl_union_map_product(uset1, uset2);
1058 }
1059
1060 static int range_product_entry(void **entry, void *user)
1061 {
1062         struct isl_union_map_bin_data *data = user;
1063         isl_map *map2 = *entry;
1064
1065         if (!isl_space_tuple_match(data->map->dim, isl_dim_in,
1066                                  map2->dim, isl_dim_in))
1067                 return 0;
1068
1069         map2 = isl_map_range_product(isl_map_copy(data->map),
1070                                      isl_map_copy(map2));
1071
1072         data->res = isl_union_map_add_map(data->res, map2);
1073
1074         return 0;
1075 }
1076
1077 __isl_give isl_union_map *isl_union_map_range_product(
1078         __isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2)
1079 {
1080         return bin_op(umap1, umap2, &range_product_entry);
1081 }
1082
1083 static int flat_range_product_entry(void **entry, void *user)
1084 {
1085         struct isl_union_map_bin_data *data = user;
1086         isl_map *map2 = *entry;
1087
1088         if (!isl_space_tuple_match(data->map->dim, isl_dim_in,
1089                                  map2->dim, isl_dim_in))
1090                 return 0;
1091
1092         map2 = isl_map_flat_range_product(isl_map_copy(data->map),
1093                                           isl_map_copy(map2));
1094
1095         data->res = isl_union_map_add_map(data->res, map2);
1096
1097         return 0;
1098 }
1099
1100 __isl_give isl_union_map *isl_union_map_flat_range_product(
1101         __isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2)
1102 {
1103         return bin_op(umap1, umap2, &flat_range_product_entry);
1104 }
1105
1106 static __isl_give isl_union_set *cond_un_op(__isl_take isl_union_map *umap,
1107         int (*fn)(void **, void *))
1108 {
1109         isl_union_set *res;
1110
1111         if (!umap)
1112                 return NULL;
1113
1114         res = isl_union_map_alloc(isl_space_copy(umap->dim), umap->table.n);
1115         if (isl_hash_table_foreach(umap->dim->ctx, &umap->table, fn, &res) < 0)
1116                 goto error;
1117
1118         isl_union_map_free(umap);
1119         return res;
1120 error:
1121         isl_union_map_free(umap);
1122         isl_union_set_free(res);
1123         return NULL;
1124 }
1125
1126 static int from_range_entry(void **entry, void *user)
1127 {
1128         isl_map *set = *entry;
1129         isl_union_set **res = user;
1130
1131         *res = isl_union_map_add_map(*res,
1132                                         isl_map_from_range(isl_set_copy(set)));
1133
1134         return 0;
1135 }
1136
1137 __isl_give isl_union_map *isl_union_map_from_range(
1138         __isl_take isl_union_set *uset)
1139 {
1140         return cond_un_op(uset, &from_range_entry);
1141 }
1142
1143 __isl_give isl_union_map *isl_union_map_from_domain(
1144         __isl_take isl_union_set *uset)
1145 {
1146         return isl_union_map_reverse(isl_union_map_from_range(uset));
1147 }
1148
1149 __isl_give isl_union_map *isl_union_map_from_domain_and_range(
1150         __isl_take isl_union_set *domain, __isl_take isl_union_set *range)
1151 {
1152         return isl_union_map_apply_range(isl_union_map_from_domain(domain),
1153                                          isl_union_map_from_range(range));
1154 }
1155
1156 static __isl_give isl_union_map *un_op(__isl_take isl_union_map *umap,
1157         int (*fn)(void **, void *))
1158 {
1159         umap = isl_union_map_cow(umap);
1160         if (!umap)
1161                 return NULL;
1162
1163         if (isl_hash_table_foreach(umap->dim->ctx, &umap->table, fn, NULL) < 0)
1164                 goto error;
1165
1166         return umap;
1167 error:
1168         isl_union_map_free(umap);
1169         return NULL;
1170 }
1171
1172 static int affine_entry(void **entry, void *user)
1173 {
1174         isl_map **map = (isl_map **)entry;
1175
1176         *map = isl_map_from_basic_map(isl_map_affine_hull(*map));
1177
1178         return *map ? 0 : -1;
1179 }
1180
1181 __isl_give isl_union_map *isl_union_map_affine_hull(
1182         __isl_take isl_union_map *umap)
1183 {
1184         return un_op(umap, &affine_entry);
1185 }
1186
1187 __isl_give isl_union_set *isl_union_set_affine_hull(
1188         __isl_take isl_union_set *uset)
1189 {
1190         return isl_union_map_affine_hull(uset);
1191 }
1192
1193 static int polyhedral_entry(void **entry, void *user)
1194 {
1195         isl_map **map = (isl_map **)entry;
1196
1197         *map = isl_map_from_basic_map(isl_map_polyhedral_hull(*map));
1198
1199         return *map ? 0 : -1;
1200 }
1201
1202 __isl_give isl_union_map *isl_union_map_polyhedral_hull(
1203         __isl_take isl_union_map *umap)
1204 {
1205         return un_op(umap, &polyhedral_entry);
1206 }
1207
1208 __isl_give isl_union_set *isl_union_set_polyhedral_hull(
1209         __isl_take isl_union_set *uset)
1210 {
1211         return isl_union_map_polyhedral_hull(uset);
1212 }
1213
1214 static int simple_entry(void **entry, void *user)
1215 {
1216         isl_map **map = (isl_map **)entry;
1217
1218         *map = isl_map_from_basic_map(isl_map_simple_hull(*map));
1219
1220         return *map ? 0 : -1;
1221 }
1222
1223 __isl_give isl_union_map *isl_union_map_simple_hull(
1224         __isl_take isl_union_map *umap)
1225 {
1226         return un_op(umap, &simple_entry);
1227 }
1228
1229 __isl_give isl_union_set *isl_union_set_simple_hull(
1230         __isl_take isl_union_set *uset)
1231 {
1232         return isl_union_map_simple_hull(uset);
1233 }
1234
1235 static int inplace_entry(void **entry, void *user)
1236 {
1237         __isl_give isl_map *(*fn)(__isl_take isl_map *);
1238         isl_map **map = (isl_map **)entry;
1239         isl_map *copy;
1240
1241         fn = *(__isl_give isl_map *(**)(__isl_take isl_map *)) user;
1242         copy = fn(isl_map_copy(*map));
1243         if (!copy)
1244                 return -1;
1245
1246         isl_map_free(*map);
1247         *map = copy;
1248
1249         return 0;
1250 }
1251
1252 static __isl_give isl_union_map *inplace(__isl_take isl_union_map *umap,
1253         __isl_give isl_map *(*fn)(__isl_take isl_map *))
1254 {
1255         if (!umap)
1256                 return NULL;
1257
1258         if (isl_hash_table_foreach(umap->dim->ctx, &umap->table,
1259                                     &inplace_entry, &fn) < 0)
1260                 goto error;
1261
1262         return umap;
1263 error:
1264         isl_union_map_free(umap);
1265         return NULL;
1266 }
1267
1268 __isl_give isl_union_map *isl_union_map_coalesce(
1269         __isl_take isl_union_map *umap)
1270 {
1271         return inplace(umap, &isl_map_coalesce);
1272 }
1273
1274 __isl_give isl_union_set *isl_union_set_coalesce(
1275         __isl_take isl_union_set *uset)
1276 {
1277         return isl_union_map_coalesce(uset);
1278 }
1279
1280 __isl_give isl_union_map *isl_union_map_detect_equalities(
1281         __isl_take isl_union_map *umap)
1282 {
1283         return inplace(umap, &isl_map_detect_equalities);
1284 }
1285
1286 __isl_give isl_union_set *isl_union_set_detect_equalities(
1287         __isl_take isl_union_set *uset)
1288 {
1289         return isl_union_map_detect_equalities(uset);
1290 }
1291
1292 __isl_give isl_union_map *isl_union_map_compute_divs(
1293         __isl_take isl_union_map *umap)
1294 {
1295         return inplace(umap, &isl_map_compute_divs);
1296 }
1297
1298 __isl_give isl_union_set *isl_union_set_compute_divs(
1299         __isl_take isl_union_set *uset)
1300 {
1301         return isl_union_map_compute_divs(uset);
1302 }
1303
1304 static int lexmin_entry(void **entry, void *user)
1305 {
1306         isl_map **map = (isl_map **)entry;
1307
1308         *map = isl_map_lexmin(*map);
1309
1310         return *map ? 0 : -1;
1311 }
1312
1313 __isl_give isl_union_map *isl_union_map_lexmin(
1314         __isl_take isl_union_map *umap)
1315 {
1316         return un_op(umap, &lexmin_entry);
1317 }
1318
1319 __isl_give isl_union_set *isl_union_set_lexmin(
1320         __isl_take isl_union_set *uset)
1321 {
1322         return isl_union_map_lexmin(uset);
1323 }
1324
1325 static int lexmax_entry(void **entry, void *user)
1326 {
1327         isl_map **map = (isl_map **)entry;
1328
1329         *map = isl_map_lexmax(*map);
1330
1331         return *map ? 0 : -1;
1332 }
1333
1334 __isl_give isl_union_map *isl_union_map_lexmax(
1335         __isl_take isl_union_map *umap)
1336 {
1337         return un_op(umap, &lexmax_entry);
1338 }
1339
1340 __isl_give isl_union_set *isl_union_set_lexmax(
1341         __isl_take isl_union_set *uset)
1342 {
1343         return isl_union_map_lexmax(uset);
1344 }
1345
1346 static int universe_entry(void **entry, void *user)
1347 {
1348         isl_map *map = *entry;
1349         isl_union_map **res = user;
1350
1351         map = isl_map_universe(isl_map_get_space(map));
1352         *res = isl_union_map_add_map(*res, map);
1353
1354         return 0;
1355 }
1356
1357 __isl_give isl_union_map *isl_union_map_universe(__isl_take isl_union_map *umap)
1358 {
1359         return cond_un_op(umap, &universe_entry);
1360 }
1361
1362 __isl_give isl_union_set *isl_union_set_universe(__isl_take isl_union_set *uset)
1363 {
1364         return isl_union_map_universe(uset);
1365 }
1366
1367 static int reverse_entry(void **entry, void *user)
1368 {
1369         isl_map *map = *entry;
1370         isl_union_map **res = user;
1371
1372         *res = isl_union_map_add_map(*res, isl_map_reverse(isl_map_copy(map)));
1373
1374         return 0;
1375 }
1376
1377 __isl_give isl_union_map *isl_union_map_reverse(__isl_take isl_union_map *umap)
1378 {
1379         return cond_un_op(umap, &reverse_entry);
1380 }
1381
1382 static int domain_entry(void **entry, void *user)
1383 {
1384         isl_map *map = *entry;
1385         isl_union_set **res = user;
1386
1387         *res = isl_union_set_add_set(*res, isl_map_domain(isl_map_copy(map)));
1388
1389         return 0;
1390 }
1391
1392 __isl_give isl_union_set *isl_union_map_domain(__isl_take isl_union_map *umap)
1393 {
1394         return cond_un_op(umap, &domain_entry);
1395 }
1396
1397 static int range_entry(void **entry, void *user)
1398 {
1399         isl_map *map = *entry;
1400         isl_union_set **res = user;
1401
1402         *res = isl_union_set_add_set(*res, isl_map_range(isl_map_copy(map)));
1403
1404         return 0;
1405 }
1406
1407 __isl_give isl_union_set *isl_union_map_range(__isl_take isl_union_map *umap)
1408 {
1409         return cond_un_op(umap, &range_entry);
1410 }
1411
1412 static int domain_map_entry(void **entry, void *user)
1413 {
1414         isl_map *map = *entry;
1415         isl_union_set **res = user;
1416
1417         *res = isl_union_map_add_map(*res,
1418                                         isl_map_domain_map(isl_map_copy(map)));
1419
1420         return 0;
1421 }
1422
1423 __isl_give isl_union_map *isl_union_map_domain_map(
1424         __isl_take isl_union_map *umap)
1425 {
1426         return cond_un_op(umap, &domain_map_entry);
1427 }
1428
1429 static int range_map_entry(void **entry, void *user)
1430 {
1431         isl_map *map = *entry;
1432         isl_union_set **res = user;
1433
1434         *res = isl_union_map_add_map(*res,
1435                                         isl_map_range_map(isl_map_copy(map)));
1436
1437         return 0;
1438 }
1439
1440 __isl_give isl_union_map *isl_union_map_range_map(
1441         __isl_take isl_union_map *umap)
1442 {
1443         return cond_un_op(umap, &range_map_entry);
1444 }
1445
1446 static int deltas_entry(void **entry, void *user)
1447 {
1448         isl_map *map = *entry;
1449         isl_union_set **res = user;
1450
1451         if (!isl_space_tuple_match(map->dim, isl_dim_in, map->dim, isl_dim_out))
1452                 return 0;
1453
1454         *res = isl_union_set_add_set(*res, isl_map_deltas(isl_map_copy(map)));
1455
1456         return 0;
1457 }
1458
1459 __isl_give isl_union_set *isl_union_map_deltas(__isl_take isl_union_map *umap)
1460 {
1461         return cond_un_op(umap, &deltas_entry);
1462 }
1463
1464 static int deltas_map_entry(void **entry, void *user)
1465 {
1466         isl_map *map = *entry;
1467         isl_union_map **res = user;
1468
1469         if (!isl_space_tuple_match(map->dim, isl_dim_in, map->dim, isl_dim_out))
1470                 return 0;
1471
1472         *res = isl_union_map_add_map(*res,
1473                                      isl_map_deltas_map(isl_map_copy(map)));
1474
1475         return 0;
1476 }
1477
1478 __isl_give isl_union_map *isl_union_map_deltas_map(
1479         __isl_take isl_union_map *umap)
1480 {
1481         return cond_un_op(umap, &deltas_map_entry);
1482 }
1483
1484 static int identity_entry(void **entry, void *user)
1485 {
1486         isl_set *set = *entry;
1487         isl_union_map **res = user;
1488
1489         *res = isl_union_map_add_map(*res, isl_set_identity(isl_set_copy(set)));
1490
1491         return 0;
1492 }
1493
1494 __isl_give isl_union_map *isl_union_set_identity(__isl_take isl_union_set *uset)
1495 {
1496         return cond_un_op(uset, &identity_entry);
1497 }
1498
1499 static int unwrap_entry(void **entry, void *user)
1500 {
1501         isl_set *set = *entry;
1502         isl_union_set **res = user;
1503
1504         if (!isl_set_is_wrapping(set))
1505                 return 0;
1506
1507         *res = isl_union_map_add_map(*res, isl_set_unwrap(isl_set_copy(set)));
1508
1509         return 0;
1510 }
1511
1512 __isl_give isl_union_map *isl_union_set_unwrap(__isl_take isl_union_set *uset)
1513 {
1514         return cond_un_op(uset, &unwrap_entry);
1515 }
1516
1517 static int wrap_entry(void **entry, void *user)
1518 {
1519         isl_map *map = *entry;
1520         isl_union_set **res = user;
1521
1522         *res = isl_union_set_add_set(*res, isl_map_wrap(isl_map_copy(map)));
1523
1524         return 0;
1525 }
1526
1527 __isl_give isl_union_set *isl_union_map_wrap(__isl_take isl_union_map *umap)
1528 {
1529         return cond_un_op(umap, &wrap_entry);
1530 }
1531
1532 struct isl_union_map_is_subset_data {
1533         isl_union_map *umap2;
1534         int is_subset;
1535 };
1536
1537 static int is_subset_entry(void **entry, void *user)
1538 {
1539         struct isl_union_map_is_subset_data *data = user;
1540         uint32_t hash;
1541         struct isl_hash_table_entry *entry2;
1542         isl_map *map = *entry;
1543
1544         hash = isl_space_get_hash(map->dim);
1545         entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
1546                                      hash, &has_dim, map->dim, 0);
1547         if (!entry2) {
1548                 data->is_subset = 0;
1549                 return -1;
1550         }
1551
1552         data->is_subset = isl_map_is_subset(map, entry2->data);
1553         if (data->is_subset < 0 || !data->is_subset)
1554                 return -1;
1555
1556         return 0;
1557 }
1558
1559 int isl_union_map_is_subset(__isl_keep isl_union_map *umap1,
1560         __isl_keep isl_union_map *umap2)
1561 {
1562         struct isl_union_map_is_subset_data data = { NULL, 1 };
1563
1564         umap1 = isl_union_map_copy(umap1);
1565         umap2 = isl_union_map_copy(umap2);
1566         umap1 = isl_union_map_align_params(umap1, isl_union_map_get_space(umap2));
1567         umap2 = isl_union_map_align_params(umap2, isl_union_map_get_space(umap1));
1568
1569         if (!umap1 || !umap2)
1570                 goto error;
1571
1572         data.umap2 = umap2;
1573         if (isl_hash_table_foreach(umap1->dim->ctx, &umap1->table,
1574                                    &is_subset_entry, &data) < 0 &&
1575             data.is_subset)
1576                 goto error;
1577
1578         isl_union_map_free(umap1);
1579         isl_union_map_free(umap2);
1580
1581         return data.is_subset;
1582 error:
1583         isl_union_map_free(umap1);
1584         isl_union_map_free(umap2);
1585         return -1;
1586 }
1587
1588 int isl_union_set_is_subset(__isl_keep isl_union_set *uset1,
1589         __isl_keep isl_union_set *uset2)
1590 {
1591         return isl_union_map_is_subset(uset1, uset2);
1592 }
1593
1594 int isl_union_map_is_equal(__isl_keep isl_union_map *umap1,
1595         __isl_keep isl_union_map *umap2)
1596 {
1597         int is_subset;
1598
1599         if (!umap1 || !umap2)
1600                 return -1;
1601         is_subset = isl_union_map_is_subset(umap1, umap2);
1602         if (is_subset != 1)
1603                 return is_subset;
1604         is_subset = isl_union_map_is_subset(umap2, umap1);
1605         return is_subset;
1606 }
1607
1608 int isl_union_set_is_equal(__isl_keep isl_union_set *uset1,
1609         __isl_keep isl_union_set *uset2)
1610 {
1611         return isl_union_map_is_equal(uset1, uset2);
1612 }
1613
1614 int isl_union_map_is_strict_subset(__isl_keep isl_union_map *umap1,
1615         __isl_keep isl_union_map *umap2)
1616 {
1617         int is_subset;
1618
1619         if (!umap1 || !umap2)
1620                 return -1;
1621         is_subset = isl_union_map_is_subset(umap1, umap2);
1622         if (is_subset != 1)
1623                 return is_subset;
1624         is_subset = isl_union_map_is_subset(umap2, umap1);
1625         if (is_subset == -1)
1626                 return is_subset;
1627         return !is_subset;
1628 }
1629
1630 int isl_union_set_is_strict_subset(__isl_keep isl_union_set *uset1,
1631         __isl_keep isl_union_set *uset2)
1632 {
1633         return isl_union_map_is_strict_subset(uset1, uset2);
1634 }
1635
1636 static int sample_entry(void **entry, void *user)
1637 {
1638         isl_basic_map **sample = (isl_basic_map **)user;
1639         isl_map *map = *entry;
1640
1641         *sample = isl_map_sample(isl_map_copy(map));
1642         if (!*sample)
1643                 return -1;
1644         if (!isl_basic_map_plain_is_empty(*sample))
1645                 return -1;
1646         return 0;
1647 }
1648
1649 __isl_give isl_basic_map *isl_union_map_sample(__isl_take isl_union_map *umap)
1650 {
1651         isl_basic_map *sample = NULL;
1652
1653         if (!umap)
1654                 return NULL;
1655
1656         if (isl_hash_table_foreach(umap->dim->ctx, &umap->table,
1657                                    &sample_entry, &sample) < 0 &&
1658             !sample)
1659                 goto error;
1660
1661         if (!sample)
1662                 sample = isl_basic_map_empty(isl_union_map_get_space(umap));
1663
1664         isl_union_map_free(umap);
1665
1666         return sample;
1667 error:
1668         isl_union_map_free(umap);
1669         return NULL;
1670 }
1671
1672 __isl_give isl_basic_set *isl_union_set_sample(__isl_take isl_union_set *uset)
1673 {
1674         return (isl_basic_set *)isl_union_map_sample(uset);
1675 }
1676
1677 struct isl_forall_data {
1678         int res;
1679         int (*fn)(__isl_keep isl_map *map);
1680 };
1681
1682 static int forall_entry(void **entry, void *user)
1683 {
1684         struct isl_forall_data *data = user;
1685         isl_map *map = *entry;
1686
1687         data->res = data->fn(map);
1688         if (data->res < 0)
1689                 return -1;
1690
1691         if (!data->res)
1692                 return -1;
1693
1694         return 0;
1695 }
1696
1697 static int union_map_forall(__isl_keep isl_union_map *umap,
1698         int (*fn)(__isl_keep isl_map *map))
1699 {
1700         struct isl_forall_data data = { 1, fn };
1701
1702         if (!umap)
1703                 return -1;
1704
1705         if (isl_hash_table_foreach(umap->dim->ctx, &umap->table,
1706                                    &forall_entry, &data) < 0 && data.res)
1707                 return -1;
1708
1709         return data.res;
1710 }
1711
1712 struct isl_forall_user_data {
1713         int res;
1714         int (*fn)(__isl_keep isl_map *map, void *user);
1715         void *user;
1716 };
1717
1718 static int forall_user_entry(void **entry, void *user)
1719 {
1720         struct isl_forall_user_data *data = user;
1721         isl_map *map = *entry;
1722
1723         data->res = data->fn(map, data->user);
1724         if (data->res < 0)
1725                 return -1;
1726
1727         if (!data->res)
1728                 return -1;
1729
1730         return 0;
1731 }
1732
1733 /* Check if fn(map, user) returns true for all maps "map" in umap.
1734  */
1735 static int union_map_forall_user(__isl_keep isl_union_map *umap,
1736         int (*fn)(__isl_keep isl_map *map, void *user), void *user)
1737 {
1738         struct isl_forall_user_data data = { 1, fn, user };
1739
1740         if (!umap)
1741                 return -1;
1742
1743         if (isl_hash_table_foreach(umap->dim->ctx, &umap->table,
1744                                    &forall_user_entry, &data) < 0 && data.res)
1745                 return -1;
1746
1747         return data.res;
1748 }
1749
1750 int isl_union_map_is_empty(__isl_keep isl_union_map *umap)
1751 {
1752         return union_map_forall(umap, &isl_map_is_empty);
1753 }
1754
1755 int isl_union_set_is_empty(__isl_keep isl_union_set *uset)
1756 {
1757         return isl_union_map_is_empty(uset);
1758 }
1759
1760 static int is_subset_of_identity(__isl_keep isl_map *map)
1761 {
1762         int is_subset;
1763         isl_space *dim;
1764         isl_map *id;
1765
1766         if (!map)
1767                 return -1;
1768
1769         if (!isl_space_tuple_match(map->dim, isl_dim_in, map->dim, isl_dim_out))
1770                 return 0;
1771
1772         dim = isl_map_get_space(map);
1773         id = isl_map_identity(dim);
1774
1775         is_subset = isl_map_is_subset(map, id);
1776
1777         isl_map_free(id);
1778
1779         return is_subset;
1780 }
1781
1782 /* Check if the given map is single-valued.
1783  * We simply compute
1784  *
1785  *      M \circ M^-1
1786  *
1787  * and check if the result is a subset of the identity mapping.
1788  */
1789 int isl_union_map_is_single_valued(__isl_keep isl_union_map *umap)
1790 {
1791         isl_union_map *test;
1792         int sv;
1793
1794         if (isl_union_map_n_map(umap) == 1) {
1795                 isl_map *map;
1796                 umap = isl_union_map_copy(umap);
1797                 map = isl_map_from_union_map(umap);
1798                 sv = isl_map_is_single_valued(map);
1799                 isl_map_free(map);
1800                 return sv;
1801         }
1802
1803         test = isl_union_map_reverse(isl_union_map_copy(umap));
1804         test = isl_union_map_apply_range(test, isl_union_map_copy(umap));
1805
1806         sv = union_map_forall(test, &is_subset_of_identity);
1807
1808         isl_union_map_free(test);
1809
1810         return sv;
1811 }
1812
1813 int isl_union_map_is_injective(__isl_keep isl_union_map *umap)
1814 {
1815         int in;
1816
1817         umap = isl_union_map_copy(umap);
1818         umap = isl_union_map_reverse(umap);
1819         in = isl_union_map_is_single_valued(umap);
1820         isl_union_map_free(umap);
1821
1822         return in;
1823 }
1824
1825 /* Represents a map that has a fixed value (v) for one of its
1826  * range dimensions.
1827  * The map in this structure is not reference counted, so it
1828  * is only valid while the isl_union_map from which it was
1829  * obtained is still alive.
1830  */
1831 struct isl_fixed_map {
1832         isl_int v;
1833         isl_map *map;
1834 };
1835
1836 static struct isl_fixed_map *alloc_isl_fixed_map_array(isl_ctx *ctx,
1837         int n)
1838 {
1839         int i;
1840         struct isl_fixed_map *v;
1841
1842         v = isl_calloc_array(ctx, struct isl_fixed_map, n);
1843         if (!v)
1844                 return NULL;
1845         for (i = 0; i < n; ++i)
1846                 isl_int_init(v[i].v);
1847         return v;
1848 }
1849
1850 static void free_isl_fixed_map_array(struct isl_fixed_map *v, int n)
1851 {
1852         int i;
1853
1854         if (!v)
1855                 return;
1856         for (i = 0; i < n; ++i)
1857                 isl_int_clear(v[i].v);
1858         free(v);
1859 }
1860
1861 /* Compare the "v" field of two isl_fixed_map structs.
1862  */
1863 static int qsort_fixed_map_cmp(const void *p1, const void *p2)
1864 {
1865         const struct isl_fixed_map *e1 = (const struct isl_fixed_map *) p1;
1866         const struct isl_fixed_map *e2 = (const struct isl_fixed_map *) p2;
1867
1868         return isl_int_cmp(e1->v, e2->v);
1869 }
1870
1871 /* Internal data structure used while checking whether all maps
1872  * in a union_map have a fixed value for a given output dimension.
1873  * v is the list of maps, with the fixed value for the dimension
1874  * n is the number of maps considered so far
1875  * pos is the output dimension under investigation
1876  */
1877 struct isl_fixed_dim_data {
1878         struct isl_fixed_map *v;
1879         int n;
1880         int pos;
1881 };
1882
1883 static int fixed_at_pos(__isl_keep isl_map *map, void *user)
1884 {
1885         struct isl_fixed_dim_data *data = user;
1886
1887         data->v[data->n].map = map;
1888         return isl_map_plain_is_fixed(map, isl_dim_out, data->pos,
1889                                       &data->v[data->n++].v);
1890 }
1891
1892 static int plain_injective_on_range(__isl_take isl_union_map *umap,
1893         int first, int n_range);
1894
1895 /* Given a list of the maps, with their fixed values at output dimension "pos",
1896  * check whether the ranges of the maps form an obvious partition.
1897  *
1898  * We first sort the maps according to their fixed values.
1899  * If all maps have a different value, then we know the ranges form
1900  * a partition.
1901  * Otherwise, we collect the maps with the same fixed value and
1902  * check whether each such collection is obviously injective
1903  * based on later dimensions.
1904  */
1905 static int separates(struct isl_fixed_map *v, int n,
1906         __isl_take isl_space *dim, int pos, int n_range)
1907 {
1908         int i;
1909
1910         if (!v)
1911                 goto error;
1912
1913         qsort(v, n, sizeof(*v), &qsort_fixed_map_cmp);
1914
1915         for (i = 0; i + 1 < n; ++i) {
1916                 int j, k;
1917                 isl_union_map *part;
1918                 int injective;
1919
1920                 for (j = i + 1; j < n; ++j)
1921                         if (isl_int_ne(v[i].v, v[j].v))
1922                                 break;
1923
1924                 if (j == i + 1)
1925                         continue;
1926
1927                 part = isl_union_map_alloc(isl_space_copy(dim), j - i);
1928                 for (k = i; k < j; ++k)
1929                         part = isl_union_map_add_map(part,
1930                                                      isl_map_copy(v[k].map));
1931
1932                 injective = plain_injective_on_range(part, pos + 1, n_range);
1933                 if (injective < 0)
1934                         goto error;
1935                 if (!injective)
1936                         break;
1937
1938                 i = j - 1;
1939         }
1940
1941         isl_space_free(dim);
1942         free_isl_fixed_map_array(v, n);
1943         return i + 1 >= n;
1944 error:
1945         isl_space_free(dim);
1946         free_isl_fixed_map_array(v, n);
1947         return -1;
1948 }
1949
1950 /* Check whether the maps in umap have obviously distinct ranges.
1951  * In particular, check for an output dimension in the range
1952  * [first,n_range) for which all maps have a fixed value
1953  * and then check if these values, possibly along with fixed values
1954  * at later dimensions, entail distinct ranges.
1955  */
1956 static int plain_injective_on_range(__isl_take isl_union_map *umap,
1957         int first, int n_range)
1958 {
1959         isl_ctx *ctx;
1960         int n;
1961         struct isl_fixed_dim_data data = { NULL };
1962
1963         ctx = isl_union_map_get_ctx(umap);
1964
1965         if (!umap)
1966                 goto error;
1967
1968         n = isl_union_map_n_map(umap);
1969         if (n <= 1) {
1970                 isl_union_map_free(umap);
1971                 return 1;
1972         }
1973
1974         if (first >= n_range) {
1975                 isl_union_map_free(umap);
1976                 return 0;
1977         }
1978
1979         data.v = alloc_isl_fixed_map_array(ctx, n);
1980         if (!data.v)
1981                 goto error;
1982
1983         for (data.pos = first; data.pos < n_range; ++data.pos) {
1984                 int fixed;
1985                 int injective;
1986                 isl_space *dim;
1987
1988                 data.n = 0;
1989                 fixed = union_map_forall_user(umap, &fixed_at_pos, &data);
1990                 if (fixed < 0)
1991                         goto error;
1992                 if (!fixed)
1993                         continue;
1994                 dim = isl_union_map_get_space(umap);
1995                 injective = separates(data.v, n, dim, data.pos, n_range);
1996                 isl_union_map_free(umap);
1997                 return injective;
1998         }
1999
2000         free_isl_fixed_map_array(data.v, n);
2001         isl_union_map_free(umap);
2002
2003         return 0;
2004 error:
2005         free_isl_fixed_map_array(data.v, n);
2006         isl_union_map_free(umap);
2007         return -1;
2008 }
2009
2010 /* Check whether the maps in umap that map to subsets of "ran"
2011  * have obviously distinct ranges.
2012  */
2013 static int plain_injective_on_range_wrap(__isl_keep isl_set *ran, void *user)
2014 {
2015         isl_union_map *umap = user;
2016
2017         umap = isl_union_map_copy(umap);
2018         umap = isl_union_map_intersect_range(umap,
2019                         isl_union_set_from_set(isl_set_copy(ran)));
2020         return plain_injective_on_range(umap, 0, isl_set_dim(ran, isl_dim_set));
2021 }
2022
2023 /* Check if the given union_map is obviously injective.
2024  *
2025  * In particular, we first check if all individual maps are obviously
2026  * injective and then check if all the ranges of these maps are
2027  * obviously disjoint.
2028  */
2029 int isl_union_map_plain_is_injective(__isl_keep isl_union_map *umap)
2030 {
2031         int in;
2032         isl_union_map *univ;
2033         isl_union_set *ran;
2034
2035         in = union_map_forall(umap, &isl_map_plain_is_injective);
2036         if (in < 0)
2037                 return -1;
2038         if (!in)
2039                 return 0;
2040
2041         univ = isl_union_map_universe(isl_union_map_copy(umap));
2042         ran = isl_union_map_range(univ);
2043
2044         in = union_map_forall_user(ran, &plain_injective_on_range_wrap, umap);
2045
2046         isl_union_set_free(ran);
2047
2048         return in;
2049 }
2050
2051 int isl_union_map_is_bijective(__isl_keep isl_union_map *umap)
2052 {
2053         int sv;
2054
2055         sv = isl_union_map_is_single_valued(umap);
2056         if (sv < 0 || !sv)
2057                 return sv;
2058
2059         return isl_union_map_is_injective(umap);
2060 }
2061
2062 static int zip_entry(void **entry, void *user)
2063 {
2064         isl_map *map = *entry;
2065         isl_union_map **res = user;
2066
2067         if (!isl_map_can_zip(map))
2068                 return 0;
2069
2070         *res = isl_union_map_add_map(*res, isl_map_zip(isl_map_copy(map)));
2071
2072         return 0;
2073 }
2074
2075 __isl_give isl_union_map *isl_union_map_zip(__isl_take isl_union_map *umap)
2076 {
2077         return cond_un_op(umap, &zip_entry);
2078 }
2079
2080 static int lift_entry(void **entry, void *user)
2081 {
2082         isl_set *set = *entry;
2083         isl_union_set **res = user;
2084
2085         *res = isl_union_set_add_set(*res, isl_set_lift(isl_set_copy(set)));
2086
2087         return 0;
2088 }
2089
2090 __isl_give isl_union_set *isl_union_set_lift(__isl_take isl_union_set *uset)
2091 {
2092         return cond_un_op(uset, &lift_entry);
2093 }
2094
2095 static int coefficients_entry(void **entry, void *user)
2096 {
2097         isl_set *set = *entry;
2098         isl_union_set **res = user;
2099
2100         set = isl_set_copy(set);
2101         set = isl_set_from_basic_set(isl_set_coefficients(set));
2102         *res = isl_union_set_add_set(*res, set);
2103
2104         return 0;
2105 }
2106
2107 __isl_give isl_union_set *isl_union_set_coefficients(
2108         __isl_take isl_union_set *uset)
2109 {
2110         isl_ctx *ctx;
2111         isl_space *dim;
2112         isl_union_set *res;
2113
2114         if (!uset)
2115                 return NULL;
2116
2117         ctx = isl_union_set_get_ctx(uset);
2118         dim = isl_space_set_alloc(ctx, 0, 0);
2119         res = isl_union_map_alloc(dim, uset->table.n);
2120         if (isl_hash_table_foreach(uset->dim->ctx, &uset->table,
2121                                    &coefficients_entry, &res) < 0)
2122                 goto error;
2123
2124         isl_union_set_free(uset);
2125         return res;
2126 error:
2127         isl_union_set_free(uset);
2128         isl_union_set_free(res);
2129         return NULL;
2130 }
2131
2132 static int solutions_entry(void **entry, void *user)
2133 {
2134         isl_set *set = *entry;
2135         isl_union_set **res = user;
2136
2137         set = isl_set_copy(set);
2138         set = isl_set_from_basic_set(isl_set_solutions(set));
2139         if (!*res)
2140                 *res = isl_union_set_from_set(set);
2141         else
2142                 *res = isl_union_set_add_set(*res, set);
2143
2144         if (!*res)
2145                 return -1;
2146
2147         return 0;
2148 }
2149
2150 __isl_give isl_union_set *isl_union_set_solutions(
2151         __isl_take isl_union_set *uset)
2152 {
2153         isl_union_set *res = NULL;
2154
2155         if (!uset)
2156                 return NULL;
2157
2158         if (uset->table.n == 0) {
2159                 res = isl_union_set_empty(isl_union_set_get_space(uset));
2160                 isl_union_set_free(uset);
2161                 return res;
2162         }
2163
2164         if (isl_hash_table_foreach(uset->dim->ctx, &uset->table,
2165                                    &solutions_entry, &res) < 0)
2166                 goto error;
2167
2168         isl_union_set_free(uset);
2169         return res;
2170 error:
2171         isl_union_set_free(uset);
2172         isl_union_set_free(res);
2173         return NULL;
2174 }