nexmon – Blame information for rev 1

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