2 * Copyright 2010 INRIA Saclay
4 * Use of this software is governed by the GNU LGPLv2.1 license
6 * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
7 * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
11 #include <isl_map_private.h>
14 #include <isl_dim_private.h>
16 #include <isl/union_map.h>
17 #include <isl_mat_private.h>
19 int isl_map_is_transitively_closed(__isl_keep isl_map *map)
24 map2 = isl_map_apply_range(isl_map_copy(map), isl_map_copy(map));
25 closed = isl_map_is_subset(map2, map);
31 int isl_union_map_is_transitively_closed(__isl_keep isl_union_map *umap)
36 umap2 = isl_union_map_apply_range(isl_union_map_copy(umap),
37 isl_union_map_copy(umap));
38 closed = isl_union_map_is_subset(umap2, umap);
39 isl_union_map_free(umap2);
44 /* Given a map that represents a path with the length of the path
45 * encoded as the difference between the last output coordindate
46 * and the last input coordinate, set this length to either
47 * exactly "length" (if "exactly" is set) or at least "length"
48 * (if "exactly" is not set).
50 static __isl_give isl_map *set_path_length(__isl_take isl_map *map,
51 int exactly, int length)
54 struct isl_basic_map *bmap;
63 dim = isl_map_get_dim(map);
64 d = isl_dim_size(dim, isl_dim_in);
65 nparam = isl_dim_size(dim, isl_dim_param);
66 bmap = isl_basic_map_alloc_dim(dim, 0, 1, 1);
68 k = isl_basic_map_alloc_equality(bmap);
71 k = isl_basic_map_alloc_inequality(bmap);
76 isl_seq_clr(c, 1 + isl_basic_map_total_dim(bmap));
77 isl_int_set_si(c[0], -length);
78 isl_int_set_si(c[1 + nparam + d - 1], -1);
79 isl_int_set_si(c[1 + nparam + d + d - 1], 1);
81 bmap = isl_basic_map_finalize(bmap);
82 map = isl_map_intersect(map, isl_map_from_basic_map(bmap));
86 isl_basic_map_free(bmap);
91 /* Check whether the overapproximation of the power of "map" is exactly
92 * the power of "map". Let R be "map" and A_k the overapproximation.
93 * The approximation is exact if
96 * A_k = A_{k-1} \circ R k >= 2
98 * Since A_k is known to be an overapproximation, we only need to check
101 * A_k \subset A_{k-1} \circ R k >= 2
103 * In practice, "app" has an extra input and output coordinate
104 * to encode the length of the path. So, we first need to add
105 * this coordinate to "map" and set the length of the path to
108 static int check_power_exactness(__isl_take isl_map *map,
109 __isl_take isl_map *app)
115 map = isl_map_add_dims(map, isl_dim_in, 1);
116 map = isl_map_add_dims(map, isl_dim_out, 1);
117 map = set_path_length(map, 1, 1);
119 app_1 = set_path_length(isl_map_copy(app), 1, 1);
121 exact = isl_map_is_subset(app_1, map);
124 if (!exact || exact < 0) {
130 app_1 = set_path_length(isl_map_copy(app), 0, 1);
131 app_2 = set_path_length(app, 0, 2);
132 app_1 = isl_map_apply_range(map, app_1);
134 exact = isl_map_is_subset(app_2, app_1);
142 /* Check whether the overapproximation of the power of "map" is exactly
143 * the power of "map", possibly after projecting out the power (if "project"
146 * If "project" is set and if "steps" can only result in acyclic paths,
149 * A = R \cup (A \circ R)
151 * where A is the overapproximation with the power projected out, i.e.,
152 * an overapproximation of the transitive closure.
153 * More specifically, since A is known to be an overapproximation, we check
155 * A \subset R \cup (A \circ R)
157 * Otherwise, we check if the power is exact.
159 * Note that "app" has an extra input and output coordinate to encode
160 * the length of the part. If we are only interested in the transitive
161 * closure, then we can simply project out these coordinates first.
163 static int check_exactness(__isl_take isl_map *map, __isl_take isl_map *app,
171 return check_power_exactness(map, app);
173 d = isl_map_dim(map, isl_dim_in);
174 app = set_path_length(app, 0, 1);
175 app = isl_map_project_out(app, isl_dim_in, d, 1);
176 app = isl_map_project_out(app, isl_dim_out, d, 1);
178 app = isl_map_reset_dim(app, isl_map_get_dim(map));
180 test = isl_map_apply_range(isl_map_copy(map), isl_map_copy(app));
181 test = isl_map_union(test, isl_map_copy(map));
183 exact = isl_map_is_subset(app, test);
194 * The transitive closure implementation is based on the paper
195 * "Computing the Transitive Closure of a Union of Affine Integer
196 * Tuple Relations" by Anna Beletska, Denis Barthou, Wlodzimierz Bielecki and
200 /* Given a set of n offsets v_i (the rows of "steps"), construct a relation
201 * of the given dimension specification (Z^{n+1} -> Z^{n+1})
202 * that maps an element x to any element that can be reached
203 * by taking a non-negative number of steps along any of
204 * the extended offsets v'_i = [v_i 1].
207 * { [x] -> [y] : exists k_i >= 0, y = x + \sum_i k_i v'_i }
209 * For any element in this relation, the number of steps taken
210 * is equal to the difference in the final coordinates.
212 static __isl_give isl_map *path_along_steps(__isl_take isl_dim *dim,
213 __isl_keep isl_mat *steps)
216 struct isl_basic_map *path = NULL;
224 d = isl_dim_size(dim, isl_dim_in);
226 nparam = isl_dim_size(dim, isl_dim_param);
228 path = isl_basic_map_alloc_dim(isl_dim_copy(dim), n, d, n);
230 for (i = 0; i < n; ++i) {
231 k = isl_basic_map_alloc_div(path);
234 isl_assert(steps->ctx, i == k, goto error);
235 isl_int_set_si(path->div[k][0], 0);
238 for (i = 0; i < d; ++i) {
239 k = isl_basic_map_alloc_equality(path);
242 isl_seq_clr(path->eq[k], 1 + isl_basic_map_total_dim(path));
243 isl_int_set_si(path->eq[k][1 + nparam + i], 1);
244 isl_int_set_si(path->eq[k][1 + nparam + d + i], -1);
246 for (j = 0; j < n; ++j)
247 isl_int_set_si(path->eq[k][1 + nparam + 2 * d + j], 1);
249 for (j = 0; j < n; ++j)
250 isl_int_set(path->eq[k][1 + nparam + 2 * d + j],
254 for (i = 0; i < n; ++i) {
255 k = isl_basic_map_alloc_inequality(path);
258 isl_seq_clr(path->ineq[k], 1 + isl_basic_map_total_dim(path));
259 isl_int_set_si(path->ineq[k][1 + nparam + 2 * d + i], 1);
264 path = isl_basic_map_simplify(path);
265 path = isl_basic_map_finalize(path);
266 return isl_map_from_basic_map(path);
269 isl_basic_map_free(path);
278 /* Check whether the parametric constant term of constraint c is never
279 * positive in "bset".
281 static int parametric_constant_never_positive(__isl_keep isl_basic_set *bset,
282 isl_int *c, int *div_purity)
291 n_div = isl_basic_set_dim(bset, isl_dim_div);
292 d = isl_basic_set_dim(bset, isl_dim_set);
293 nparam = isl_basic_set_dim(bset, isl_dim_param);
295 bset = isl_basic_set_copy(bset);
296 bset = isl_basic_set_cow(bset);
297 bset = isl_basic_set_extend_constraints(bset, 0, 1);
298 k = isl_basic_set_alloc_inequality(bset);
301 isl_seq_clr(bset->ineq[k], 1 + isl_basic_set_total_dim(bset));
302 isl_seq_cpy(bset->ineq[k], c, 1 + nparam);
303 for (i = 0; i < n_div; ++i) {
304 if (div_purity[i] != PURE_PARAM)
306 isl_int_set(bset->ineq[k][1 + nparam + d + i],
307 c[1 + nparam + d + i]);
309 isl_int_sub_ui(bset->ineq[k][0], bset->ineq[k][0], 1);
310 empty = isl_basic_set_is_empty(bset);
311 isl_basic_set_free(bset);
315 isl_basic_set_free(bset);
319 /* Return PURE_PARAM if only the coefficients of the parameters are non-zero.
320 * Return PURE_VAR if only the coefficients of the set variables are non-zero.
321 * Return MIXED if only the coefficients of the parameters and the set
322 * variables are non-zero and if moreover the parametric constant
323 * can never attain positive values.
324 * Return IMPURE otherwise.
326 * If div_purity is NULL then we are dealing with a non-parametric set
327 * and so the constraint is obviously PURE_VAR.
329 static int purity(__isl_keep isl_basic_set *bset, isl_int *c, int *div_purity,
342 n_div = isl_basic_set_dim(bset, isl_dim_div);
343 d = isl_basic_set_dim(bset, isl_dim_set);
344 nparam = isl_basic_set_dim(bset, isl_dim_param);
346 for (i = 0; i < n_div; ++i) {
347 if (isl_int_is_zero(c[1 + nparam + d + i]))
349 switch (div_purity[i]) {
350 case PURE_PARAM: p = 1; break;
351 case PURE_VAR: v = 1; break;
352 default: return IMPURE;
355 if (!p && isl_seq_first_non_zero(c + 1, nparam) == -1)
357 if (!v && isl_seq_first_non_zero(c + 1 + nparam, d) == -1)
360 empty = parametric_constant_never_positive(bset, c, div_purity);
361 if (eq && empty >= 0 && !empty) {
362 isl_seq_neg(c, c, 1 + nparam + d + n_div);
363 empty = parametric_constant_never_positive(bset, c, div_purity);
366 return empty < 0 ? -1 : empty ? MIXED : IMPURE;
369 /* Return an array of integers indicating the type of each div in bset.
370 * If the div is (recursively) defined in terms of only the parameters,
371 * then the type is PURE_PARAM.
372 * If the div is (recursively) defined in terms of only the set variables,
373 * then the type is PURE_VAR.
374 * Otherwise, the type is IMPURE.
376 static __isl_give int *get_div_purity(__isl_keep isl_basic_set *bset)
387 n_div = isl_basic_set_dim(bset, isl_dim_div);
388 d = isl_basic_set_dim(bset, isl_dim_set);
389 nparam = isl_basic_set_dim(bset, isl_dim_param);
391 div_purity = isl_alloc_array(bset->ctx, int, n_div);
395 for (i = 0; i < bset->n_div; ++i) {
397 if (isl_int_is_zero(bset->div[i][0])) {
398 div_purity[i] = IMPURE;
401 if (isl_seq_first_non_zero(bset->div[i] + 2, nparam) != -1)
403 if (isl_seq_first_non_zero(bset->div[i] + 2 + nparam, d) != -1)
405 for (j = 0; j < i; ++j) {
406 if (isl_int_is_zero(bset->div[i][2 + nparam + d + j]))
408 switch (div_purity[j]) {
409 case PURE_PARAM: p = 1; break;
410 case PURE_VAR: v = 1; break;
411 default: p = v = 1; break;
414 div_purity[i] = v ? p ? IMPURE : PURE_VAR : PURE_PARAM;
420 /* Given a path with the as yet unconstrained length at position "pos",
421 * check if setting the length to zero results in only the identity
424 static int empty_path_is_identity(__isl_keep isl_basic_map *path, unsigned pos)
426 isl_basic_map *test = NULL;
427 isl_basic_map *id = NULL;
431 test = isl_basic_map_copy(path);
432 test = isl_basic_map_extend_constraints(test, 1, 0);
433 k = isl_basic_map_alloc_equality(test);
436 isl_seq_clr(test->eq[k], 1 + isl_basic_map_total_dim(test));
437 isl_int_set_si(test->eq[k][pos], 1);
438 id = isl_basic_map_identity(isl_basic_map_get_dim(path));
439 is_id = isl_basic_map_is_equal(test, id);
440 isl_basic_map_free(test);
441 isl_basic_map_free(id);
444 isl_basic_map_free(test);
448 /* If any of the constraints is found to be impure then this function
449 * sets *impurity to 1.
451 static __isl_give isl_basic_map *add_delta_constraints(
452 __isl_take isl_basic_map *path,
453 __isl_keep isl_basic_set *delta, unsigned off, unsigned nparam,
454 unsigned d, int *div_purity, int eq, int *impurity)
457 int n = eq ? delta->n_eq : delta->n_ineq;
458 isl_int **delta_c = eq ? delta->eq : delta->ineq;
461 n_div = isl_basic_set_dim(delta, isl_dim_div);
463 for (i = 0; i < n; ++i) {
465 int p = purity(delta, delta_c[i], div_purity, eq);
468 if (p != PURE_VAR && p != PURE_PARAM && !*impurity)
472 if (eq && p != MIXED) {
473 k = isl_basic_map_alloc_equality(path);
474 path_c = path->eq[k];
476 k = isl_basic_map_alloc_inequality(path);
477 path_c = path->ineq[k];
481 isl_seq_clr(path_c, 1 + isl_basic_map_total_dim(path));
483 isl_seq_cpy(path_c + off,
484 delta_c[i] + 1 + nparam, d);
485 isl_int_set(path_c[off + d], delta_c[i][0]);
486 } else if (p == PURE_PARAM) {
487 isl_seq_cpy(path_c, delta_c[i], 1 + nparam);
489 isl_seq_cpy(path_c + off,
490 delta_c[i] + 1 + nparam, d);
491 isl_seq_cpy(path_c, delta_c[i], 1 + nparam);
493 isl_seq_cpy(path_c + off - n_div,
494 delta_c[i] + 1 + nparam + d, n_div);
499 isl_basic_map_free(path);
503 /* Given a set of offsets "delta", construct a relation of the
504 * given dimension specification (Z^{n+1} -> Z^{n+1}) that
505 * is an overapproximation of the relations that
506 * maps an element x to any element that can be reached
507 * by taking a non-negative number of steps along any of
508 * the elements in "delta".
509 * That is, construct an approximation of
511 * { [x] -> [y] : exists f \in \delta, k \in Z :
512 * y = x + k [f, 1] and k >= 0 }
514 * For any element in this relation, the number of steps taken
515 * is equal to the difference in the final coordinates.
517 * In particular, let delta be defined as
519 * \delta = [p] -> { [x] : A x + a >= 0 and B p + b >= 0 and
520 * C x + C'p + c >= 0 and
521 * D x + D'p + d >= 0 }
523 * where the constraints C x + C'p + c >= 0 are such that the parametric
524 * constant term of each constraint j, "C_j x + C'_j p + c_j",
525 * can never attain positive values, then the relation is constructed as
527 * { [x] -> [y] : exists [f, k] \in Z^{n+1} : y = x + f and
528 * A f + k a >= 0 and B p + b >= 0 and
529 * C f + C'p + c >= 0 and k >= 1 }
530 * union { [x] -> [x] }
532 * If the zero-length paths happen to correspond exactly to the identity
533 * mapping, then we return
535 * { [x] -> [y] : exists [f, k] \in Z^{n+1} : y = x + f and
536 * A f + k a >= 0 and B p + b >= 0 and
537 * C f + C'p + c >= 0 and k >= 0 }
541 * Existentially quantified variables in \delta are handled by
542 * classifying them as independent of the parameters, purely
543 * parameter dependent and others. Constraints containing
544 * any of the other existentially quantified variables are removed.
545 * This is safe, but leads to an additional overapproximation.
547 * If there are any impure constraints, then we also eliminate
548 * the parameters from \delta, resulting in a set
550 * \delta' = { [x] : E x + e >= 0 }
552 * and add the constraints
556 * to the constructed relation.
558 static __isl_give isl_map *path_along_delta(__isl_take isl_dim *dim,
559 __isl_take isl_basic_set *delta)
561 isl_basic_map *path = NULL;
568 int *div_purity = NULL;
573 n_div = isl_basic_set_dim(delta, isl_dim_div);
574 d = isl_basic_set_dim(delta, isl_dim_set);
575 nparam = isl_basic_set_dim(delta, isl_dim_param);
576 path = isl_basic_map_alloc_dim(isl_dim_copy(dim), n_div + d + 1,
577 d + 1 + delta->n_eq, delta->n_eq + delta->n_ineq + 1);
578 off = 1 + nparam + 2 * (d + 1) + n_div;
580 for (i = 0; i < n_div + d + 1; ++i) {
581 k = isl_basic_map_alloc_div(path);
584 isl_int_set_si(path->div[k][0], 0);
587 for (i = 0; i < d + 1; ++i) {
588 k = isl_basic_map_alloc_equality(path);
591 isl_seq_clr(path->eq[k], 1 + isl_basic_map_total_dim(path));
592 isl_int_set_si(path->eq[k][1 + nparam + i], 1);
593 isl_int_set_si(path->eq[k][1 + nparam + d + 1 + i], -1);
594 isl_int_set_si(path->eq[k][off + i], 1);
597 div_purity = get_div_purity(delta);
601 path = add_delta_constraints(path, delta, off, nparam, d,
602 div_purity, 1, &impurity);
603 path = add_delta_constraints(path, delta, off, nparam, d,
604 div_purity, 0, &impurity);
606 isl_dim *dim = isl_basic_set_get_dim(delta);
607 delta = isl_basic_set_project_out(delta,
608 isl_dim_param, 0, nparam);
609 delta = isl_basic_set_add(delta, isl_dim_param, nparam);
610 delta = isl_basic_set_reset_dim(delta, dim);
613 path = isl_basic_map_extend_constraints(path, delta->n_eq,
615 path = add_delta_constraints(path, delta, off, nparam, d,
617 path = add_delta_constraints(path, delta, off, nparam, d,
619 path = isl_basic_map_gauss(path, NULL);
622 is_id = empty_path_is_identity(path, off + d);
626 k = isl_basic_map_alloc_inequality(path);
629 isl_seq_clr(path->ineq[k], 1 + isl_basic_map_total_dim(path));
631 isl_int_set_si(path->ineq[k][0], -1);
632 isl_int_set_si(path->ineq[k][off + d], 1);
635 isl_basic_set_free(delta);
636 path = isl_basic_map_finalize(path);
639 return isl_map_from_basic_map(path);
641 return isl_basic_map_union(path, isl_basic_map_identity(dim));
645 isl_basic_set_free(delta);
646 isl_basic_map_free(path);
650 /* Given a dimension specification Z^{n+1} -> Z^{n+1} and a parameter "param",
651 * construct a map that equates the parameter to the difference
652 * in the final coordinates and imposes that this difference is positive.
655 * { [x,x_s] -> [y,y_s] : k = y_s - x_s > 0 }
657 static __isl_give isl_map *equate_parameter_to_length(__isl_take isl_dim *dim,
660 struct isl_basic_map *bmap;
665 d = isl_dim_size(dim, isl_dim_in);
666 nparam = isl_dim_size(dim, isl_dim_param);
667 bmap = isl_basic_map_alloc_dim(dim, 0, 1, 1);
668 k = isl_basic_map_alloc_equality(bmap);
671 isl_seq_clr(bmap->eq[k], 1 + isl_basic_map_total_dim(bmap));
672 isl_int_set_si(bmap->eq[k][1 + param], -1);
673 isl_int_set_si(bmap->eq[k][1 + nparam + d - 1], -1);
674 isl_int_set_si(bmap->eq[k][1 + nparam + d + d - 1], 1);
676 k = isl_basic_map_alloc_inequality(bmap);
679 isl_seq_clr(bmap->ineq[k], 1 + isl_basic_map_total_dim(bmap));
680 isl_int_set_si(bmap->ineq[k][1 + param], 1);
681 isl_int_set_si(bmap->ineq[k][0], -1);
683 bmap = isl_basic_map_finalize(bmap);
684 return isl_map_from_basic_map(bmap);
686 isl_basic_map_free(bmap);
690 /* Check whether "path" is acyclic, where the last coordinates of domain
691 * and range of path encode the number of steps taken.
692 * That is, check whether
694 * { d | d = y - x and (x,y) in path }
696 * does not contain any element with positive last coordinate (positive length)
697 * and zero remaining coordinates (cycle).
699 static int is_acyclic(__isl_take isl_map *path)
704 struct isl_set *delta;
706 delta = isl_map_deltas(path);
707 dim = isl_set_dim(delta, isl_dim_set);
708 for (i = 0; i < dim; ++i) {
710 delta = isl_set_lower_bound_si(delta, isl_dim_set, i, 1);
712 delta = isl_set_fix_si(delta, isl_dim_set, i, 0);
715 acyclic = isl_set_is_empty(delta);
721 /* Given a union of basic maps R = \cup_i R_i \subseteq D \times D
722 * and a dimension specification (Z^{n+1} -> Z^{n+1}),
723 * construct a map that is an overapproximation of the map
724 * that takes an element from the space D \times Z to another
725 * element from the same space, such that the first n coordinates of the
726 * difference between them is a sum of differences between images
727 * and pre-images in one of the R_i and such that the last coordinate
728 * is equal to the number of steps taken.
731 * \Delta_i = { y - x | (x, y) in R_i }
733 * then the constructed map is an overapproximation of
735 * { (x) -> (x + d) | \exists k_i >= 0, \delta_i \in \Delta_i :
736 * d = (\sum_i k_i \delta_i, \sum_i k_i) }
738 * The elements of the singleton \Delta_i's are collected as the
739 * rows of the steps matrix. For all these \Delta_i's together,
740 * a single path is constructed.
741 * For each of the other \Delta_i's, we compute an overapproximation
742 * of the paths along elements of \Delta_i.
743 * Since each of these paths performs an addition, composition is
744 * symmetric and we can simply compose all resulting paths in any order.
746 static __isl_give isl_map *construct_extended_path(__isl_take isl_dim *dim,
747 __isl_keep isl_map *map, int *project)
749 struct isl_mat *steps = NULL;
750 struct isl_map *path = NULL;
754 d = isl_map_dim(map, isl_dim_in);
756 path = isl_map_identity(isl_dim_copy(dim));
758 steps = isl_mat_alloc(map->ctx, map->n, d);
763 for (i = 0; i < map->n; ++i) {
764 struct isl_basic_set *delta;
766 delta = isl_basic_map_deltas(isl_basic_map_copy(map->p[i]));
768 for (j = 0; j < d; ++j) {
771 fixed = isl_basic_set_fast_dim_is_fixed(delta, j,
774 isl_basic_set_free(delta);
783 path = isl_map_apply_range(path,
784 path_along_delta(isl_dim_copy(dim), delta));
785 path = isl_map_coalesce(path);
787 isl_basic_set_free(delta);
794 path = isl_map_apply_range(path,
795 path_along_steps(isl_dim_copy(dim), steps));
798 if (project && *project) {
799 *project = is_acyclic(isl_map_copy(path));
814 static int isl_set_overlaps(__isl_keep isl_set *set1, __isl_keep isl_set *set2)
819 if (!isl_dim_tuple_match(set1->dim, isl_dim_set, set2->dim, isl_dim_set))
822 i = isl_set_intersect(isl_set_copy(set1), isl_set_copy(set2));
823 no_overlap = isl_set_is_empty(i);
826 return no_overlap < 0 ? -1 : !no_overlap;
829 /* Given a union of basic maps R = \cup_i R_i \subseteq D \times D
830 * and a dimension specification (Z^{n+1} -> Z^{n+1}),
831 * construct a map that is an overapproximation of the map
832 * that takes an element from the dom R \times Z to an
833 * element from ran R \times Z, such that the first n coordinates of the
834 * difference between them is a sum of differences between images
835 * and pre-images in one of the R_i and such that the last coordinate
836 * is equal to the number of steps taken.
839 * \Delta_i = { y - x | (x, y) in R_i }
841 * then the constructed map is an overapproximation of
843 * { (x) -> (x + d) | \exists k_i >= 0, \delta_i \in \Delta_i :
844 * d = (\sum_i k_i \delta_i, \sum_i k_i) and
845 * x in dom R and x + d in ran R and
848 static __isl_give isl_map *construct_component(__isl_take isl_dim *dim,
849 __isl_keep isl_map *map, int *exact, int project)
851 struct isl_set *domain = NULL;
852 struct isl_set *range = NULL;
853 struct isl_map *app = NULL;
854 struct isl_map *path = NULL;
856 domain = isl_map_domain(isl_map_copy(map));
857 domain = isl_set_coalesce(domain);
858 range = isl_map_range(isl_map_copy(map));
859 range = isl_set_coalesce(range);
860 if (!isl_set_overlaps(domain, range)) {
861 isl_set_free(domain);
865 map = isl_map_copy(map);
866 map = isl_map_add_dims(map, isl_dim_in, 1);
867 map = isl_map_add_dims(map, isl_dim_out, 1);
868 map = set_path_length(map, 1, 1);
871 app = isl_map_from_domain_and_range(domain, range);
872 app = isl_map_add_dims(app, isl_dim_in, 1);
873 app = isl_map_add_dims(app, isl_dim_out, 1);
875 path = construct_extended_path(isl_dim_copy(dim), map,
876 exact && *exact ? &project : NULL);
877 app = isl_map_intersect(app, path);
879 if (exact && *exact &&
880 (*exact = check_exactness(isl_map_copy(map), isl_map_copy(app),
885 app = set_path_length(app, 0, 1);
893 /* Call construct_component and, if "project" is set, project out
894 * the final coordinates.
896 static __isl_give isl_map *construct_projected_component(
897 __isl_take isl_dim *dim,
898 __isl_keep isl_map *map, int *exact, int project)
905 d = isl_dim_size(dim, isl_dim_in);
907 app = construct_component(dim, map, exact, project);
909 app = isl_map_project_out(app, isl_dim_in, d - 1, 1);
910 app = isl_map_project_out(app, isl_dim_out, d - 1, 1);
915 /* Compute an extended version, i.e., with path lengths, of
916 * an overapproximation of the transitive closure of "bmap"
917 * with path lengths greater than or equal to zero and with
918 * domain and range equal to "dom".
920 static __isl_give isl_map *q_closure(__isl_take isl_dim *dim,
921 __isl_take isl_set *dom, __isl_keep isl_basic_map *bmap, int *exact)
928 dom = isl_set_add_dims(dom, isl_dim_set, 1);
929 app = isl_map_from_domain_and_range(dom, isl_set_copy(dom));
930 map = isl_map_from_basic_map(isl_basic_map_copy(bmap));
931 path = construct_extended_path(dim, map, &project);
932 app = isl_map_intersect(app, path);
934 if ((*exact = check_exactness(map, isl_map_copy(app), project)) < 0)
943 /* Check whether qc has any elements of length at least one
944 * with domain and/or range outside of dom and ran.
946 static int has_spurious_elements(__isl_keep isl_map *qc,
947 __isl_keep isl_set *dom, __isl_keep isl_set *ran)
953 if (!qc || !dom || !ran)
956 d = isl_map_dim(qc, isl_dim_in);
958 qc = isl_map_copy(qc);
959 qc = set_path_length(qc, 0, 1);
960 qc = isl_map_project_out(qc, isl_dim_in, d - 1, 1);
961 qc = isl_map_project_out(qc, isl_dim_out, d - 1, 1);
963 s = isl_map_domain(isl_map_copy(qc));
964 subset = isl_set_is_subset(s, dom);
973 s = isl_map_range(qc);
974 subset = isl_set_is_subset(s, ran);
977 return subset < 0 ? -1 : !subset;
986 /* For each basic map in "map", except i, check whether it combines
987 * with the transitive closure that is reflexive on C combines
988 * to the left and to the right.
992 * dom map_j \subseteq C
994 * then right[j] is set to 1. Otherwise, if
996 * ran map_i \cap dom map_j = \emptyset
998 * then right[j] is set to 0. Otherwise, composing to the right
1001 * Similar, for composing to the left, we have if
1003 * ran map_j \subseteq C
1005 * then left[j] is set to 1. Otherwise, if
1007 * dom map_i \cap ran map_j = \emptyset
1009 * then left[j] is set to 0. Otherwise, composing to the left
1012 * The return value is or'd with LEFT if composing to the left
1013 * is possible and with RIGHT if composing to the right is possible.
1015 static int composability(__isl_keep isl_set *C, int i,
1016 isl_set **dom, isl_set **ran, int *left, int *right,
1017 __isl_keep isl_map *map)
1023 for (j = 0; j < map->n && ok; ++j) {
1024 int overlaps, subset;
1030 dom[j] = isl_set_from_basic_set(
1031 isl_basic_map_domain(
1032 isl_basic_map_copy(map->p[j])));
1035 overlaps = isl_set_overlaps(ran[i], dom[j]);
1041 subset = isl_set_is_subset(dom[j], C);
1053 ran[j] = isl_set_from_basic_set(
1054 isl_basic_map_range(
1055 isl_basic_map_copy(map->p[j])));
1058 overlaps = isl_set_overlaps(dom[i], ran[j]);
1064 subset = isl_set_is_subset(ran[j], C);
1078 static __isl_give isl_map *anonymize(__isl_take isl_map *map)
1080 map = isl_map_reset(map, isl_dim_in);
1081 map = isl_map_reset(map, isl_dim_out);
1085 /* Return a map that is a union of the basic maps in "map", except i,
1086 * composed to left and right with qc based on the entries of "left"
1089 static __isl_give isl_map *compose(__isl_keep isl_map *map, int i,
1090 __isl_take isl_map *qc, int *left, int *right)
1095 comp = isl_map_empty(isl_map_get_dim(map));
1096 for (j = 0; j < map->n; ++j) {
1102 map_j = isl_map_from_basic_map(isl_basic_map_copy(map->p[j]));
1103 map_j = anonymize(map_j);
1104 if (left && left[j])
1105 map_j = isl_map_apply_range(map_j, isl_map_copy(qc));
1106 if (right && right[j])
1107 map_j = isl_map_apply_range(isl_map_copy(qc), map_j);
1108 comp = isl_map_union(comp, map_j);
1111 comp = isl_map_compute_divs(comp);
1112 comp = isl_map_coalesce(comp);
1119 /* Compute the transitive closure of "map" incrementally by
1126 * map_i^+ \cup ((id \cup map_i^) \circ qc^+)
1130 * map_i^+ \cup (qc^+ \circ (id \cup map_i^))
1132 * depending on whether left or right are NULL.
1134 static __isl_give isl_map *compute_incremental(
1135 __isl_take isl_dim *dim, __isl_keep isl_map *map,
1136 int i, __isl_take isl_map *qc, int *left, int *right, int *exact)
1140 isl_map *rtc = NULL;
1144 isl_assert(map->ctx, left || right, goto error);
1146 map_i = isl_map_from_basic_map(isl_basic_map_copy(map->p[i]));
1147 tc = construct_projected_component(isl_dim_copy(dim), map_i,
1149 isl_map_free(map_i);
1152 qc = isl_map_transitive_closure(qc, exact);
1158 return isl_map_universe(isl_map_get_dim(map));
1161 if (!left || !right)
1162 rtc = isl_map_union(isl_map_copy(tc),
1163 isl_map_identity(isl_map_get_dim(tc)));
1165 qc = isl_map_apply_range(rtc, qc);
1167 qc = isl_map_apply_range(qc, rtc);
1168 qc = isl_map_union(tc, qc);
1179 /* Given a map "map", try to find a basic map such that
1180 * map^+ can be computed as
1182 * map^+ = map_i^+ \cup
1183 * \bigcup_j ((map_i^+ \cup Id_C)^+ \circ map_j \circ (map_i^+ \cup Id_C))^+
1185 * with C the simple hull of the domain and range of the input map.
1186 * map_i^ \cup Id_C is computed by allowing the path lengths to be zero
1187 * and by intersecting domain and range with C.
1188 * Of course, we need to check that this is actually equal to map_i^ \cup Id_C.
1189 * Also, we only use the incremental computation if all the transitive
1190 * closures are exact and if the number of basic maps in the union,
1191 * after computing the integer divisions, is smaller than the number
1192 * of basic maps in the input map.
1194 static int incemental_on_entire_domain(__isl_keep isl_dim *dim,
1195 __isl_keep isl_map *map,
1196 isl_set **dom, isl_set **ran, int *left, int *right,
1197 __isl_give isl_map **res)
1205 C = isl_set_union(isl_map_domain(isl_map_copy(map)),
1206 isl_map_range(isl_map_copy(map)));
1207 C = isl_set_from_basic_set(isl_set_simple_hull(C));
1215 d = isl_map_dim(map, isl_dim_in);
1217 for (i = 0; i < map->n; ++i) {
1219 int exact_i, spurious;
1221 dom[i] = isl_set_from_basic_set(isl_basic_map_domain(
1222 isl_basic_map_copy(map->p[i])));
1223 ran[i] = isl_set_from_basic_set(isl_basic_map_range(
1224 isl_basic_map_copy(map->p[i])));
1225 qc = q_closure(isl_dim_copy(dim), isl_set_copy(C),
1226 map->p[i], &exact_i);
1233 spurious = has_spurious_elements(qc, dom[i], ran[i]);
1240 qc = isl_map_project_out(qc, isl_dim_in, d, 1);
1241 qc = isl_map_project_out(qc, isl_dim_out, d, 1);
1242 qc = isl_map_compute_divs(qc);
1243 for (j = 0; j < map->n; ++j)
1244 left[j] = right[j] = 1;
1245 qc = compose(map, i, qc, left, right);
1248 if (qc->n >= map->n) {
1252 *res = compute_incremental(isl_dim_copy(dim), map, i, qc,
1253 left, right, &exact_i);
1264 return *res != NULL;
1270 /* Try and compute the transitive closure of "map" as
1272 * map^+ = map_i^+ \cup
1273 * \bigcup_j ((map_i^+ \cup Id_C)^+ \circ map_j \circ (map_i^+ \cup Id_C))^+
1275 * with C either the simple hull of the domain and range of the entire
1276 * map or the simple hull of domain and range of map_i.
1278 static __isl_give isl_map *incremental_closure(__isl_take isl_dim *dim,
1279 __isl_keep isl_map *map, int *exact, int project)
1282 isl_set **dom = NULL;
1283 isl_set **ran = NULL;
1288 isl_map *res = NULL;
1291 return construct_projected_component(dim, map, exact, project);
1296 return construct_projected_component(dim, map, exact, project);
1298 d = isl_map_dim(map, isl_dim_in);
1300 dom = isl_calloc_array(map->ctx, isl_set *, map->n);
1301 ran = isl_calloc_array(map->ctx, isl_set *, map->n);
1302 left = isl_calloc_array(map->ctx, int, map->n);
1303 right = isl_calloc_array(map->ctx, int, map->n);
1304 if (!ran || !dom || !left || !right)
1307 if (incemental_on_entire_domain(dim, map, dom, ran, left, right, &res) < 0)
1310 for (i = 0; !res && i < map->n; ++i) {
1312 int exact_i, spurious, comp;
1314 dom[i] = isl_set_from_basic_set(
1315 isl_basic_map_domain(
1316 isl_basic_map_copy(map->p[i])));
1320 ran[i] = isl_set_from_basic_set(
1321 isl_basic_map_range(
1322 isl_basic_map_copy(map->p[i])));
1325 C = isl_set_union(isl_set_copy(dom[i]),
1326 isl_set_copy(ran[i]));
1327 C = isl_set_from_basic_set(isl_set_simple_hull(C));
1334 comp = composability(C, i, dom, ran, left, right, map);
1335 if (!comp || comp < 0) {
1341 qc = q_closure(isl_dim_copy(dim), C, map->p[i], &exact_i);
1348 spurious = has_spurious_elements(qc, dom[i], ran[i]);
1355 qc = isl_map_project_out(qc, isl_dim_in, d, 1);
1356 qc = isl_map_project_out(qc, isl_dim_out, d, 1);
1357 qc = isl_map_compute_divs(qc);
1358 qc = compose(map, i, qc, (comp & LEFT) ? left : NULL,
1359 (comp & RIGHT) ? right : NULL);
1362 if (qc->n >= map->n) {
1366 res = compute_incremental(isl_dim_copy(dim), map, i, qc,
1367 (comp & LEFT) ? left : NULL,
1368 (comp & RIGHT) ? right : NULL, &exact_i);
1377 for (i = 0; i < map->n; ++i) {
1378 isl_set_free(dom[i]);
1379 isl_set_free(ran[i]);
1391 return construct_projected_component(dim, map, exact, project);
1394 for (i = 0; i < map->n; ++i)
1395 isl_set_free(dom[i]);
1398 for (i = 0; i < map->n; ++i)
1399 isl_set_free(ran[i]);
1407 /* Given an array of sets "set", add "dom" at position "pos"
1408 * and search for elements at earlier positions that overlap with "dom".
1409 * If any can be found, then merge all of them, together with "dom", into
1410 * a single set and assign the union to the first in the array,
1411 * which becomes the new group leader for all groups involved in the merge.
1412 * During the search, we only consider group leaders, i.e., those with
1413 * group[i] = i, as the other sets have already been combined
1414 * with one of the group leaders.
1416 static int merge(isl_set **set, int *group, __isl_take isl_set *dom, int pos)
1421 set[pos] = isl_set_copy(dom);
1423 for (i = pos - 1; i >= 0; --i) {
1429 o = isl_set_overlaps(set[i], dom);
1435 set[i] = isl_set_union(set[i], set[group[pos]]);
1436 set[group[pos]] = NULL;
1439 group[group[pos]] = i;
1450 /* Replace each entry in the n by n grid of maps by the cross product
1451 * with the relation { [i] -> [i + 1] }.
1453 static int add_length(__isl_keep isl_map *map, isl_map ***grid, int n)
1457 isl_basic_map *bstep;
1464 dim = isl_map_get_dim(map);
1465 nparam = isl_dim_size(dim, isl_dim_param);
1466 dim = isl_dim_drop(dim, isl_dim_in, 0, isl_dim_size(dim, isl_dim_in));
1467 dim = isl_dim_drop(dim, isl_dim_out, 0, isl_dim_size(dim, isl_dim_out));
1468 dim = isl_dim_add(dim, isl_dim_in, 1);
1469 dim = isl_dim_add(dim, isl_dim_out, 1);
1470 bstep = isl_basic_map_alloc_dim(dim, 0, 1, 0);
1471 k = isl_basic_map_alloc_equality(bstep);
1473 isl_basic_map_free(bstep);
1476 isl_seq_clr(bstep->eq[k], 1 + isl_basic_map_total_dim(bstep));
1477 isl_int_set_si(bstep->eq[k][0], 1);
1478 isl_int_set_si(bstep->eq[k][1 + nparam], 1);
1479 isl_int_set_si(bstep->eq[k][1 + nparam + 1], -1);
1480 bstep = isl_basic_map_finalize(bstep);
1481 step = isl_map_from_basic_map(bstep);
1483 for (i = 0; i < n; ++i)
1484 for (j = 0; j < n; ++j)
1485 grid[i][j] = isl_map_product(grid[i][j],
1486 isl_map_copy(step));
1493 /* The core of the Floyd-Warshall algorithm.
1494 * Updates the given n x x matrix of relations in place.
1496 * The algorithm iterates over all vertices. In each step, the whole
1497 * matrix is updated to include all paths that go to the current vertex,
1498 * possibly stay there a while (including passing through earlier vertices)
1499 * and then come back. At the start of each iteration, the diagonal
1500 * element corresponding to the current vertex is replaced by its
1501 * transitive closure to account for all indirect paths that stay
1502 * in the current vertex.
1504 static void floyd_warshall_iterate(isl_map ***grid, int n, int *exact)
1508 for (r = 0; r < n; ++r) {
1510 grid[r][r] = isl_map_transitive_closure(grid[r][r],
1511 (exact && *exact) ? &r_exact : NULL);
1512 if (exact && *exact && !r_exact)
1515 for (p = 0; p < n; ++p)
1516 for (q = 0; q < n; ++q) {
1518 if (p == r && q == r)
1520 loop = isl_map_apply_range(
1521 isl_map_copy(grid[p][r]),
1522 isl_map_copy(grid[r][q]));
1523 grid[p][q] = isl_map_union(grid[p][q], loop);
1524 loop = isl_map_apply_range(
1525 isl_map_copy(grid[p][r]),
1526 isl_map_apply_range(
1527 isl_map_copy(grid[r][r]),
1528 isl_map_copy(grid[r][q])));
1529 grid[p][q] = isl_map_union(grid[p][q], loop);
1530 grid[p][q] = isl_map_coalesce(grid[p][q]);
1535 /* Given a partition of the domains and ranges of the basic maps in "map",
1536 * apply the Floyd-Warshall algorithm with the elements in the partition
1539 * In particular, there are "n" elements in the partition and "group" is
1540 * an array of length 2 * map->n with entries in [0,n-1].
1542 * We first construct a matrix of relations based on the partition information,
1543 * apply Floyd-Warshall on this matrix of relations and then take the
1544 * union of all entries in the matrix as the final result.
1546 * If we are actually computing the power instead of the transitive closure,
1547 * i.e., when "project" is not set, then the result should have the
1548 * path lengths encoded as the difference between an extra pair of
1549 * coordinates. We therefore apply the nested transitive closures
1550 * to relations that include these lengths. In particular, we replace
1551 * the input relation by the cross product with the unit length relation
1552 * { [i] -> [i + 1] }.
1554 static __isl_give isl_map *floyd_warshall_with_groups(__isl_take isl_dim *dim,
1555 __isl_keep isl_map *map, int *exact, int project, int *group, int n)
1558 isl_map ***grid = NULL;
1566 return incremental_closure(dim, map, exact, project);
1569 grid = isl_calloc_array(map->ctx, isl_map **, n);
1572 for (i = 0; i < n; ++i) {
1573 grid[i] = isl_calloc_array(map->ctx, isl_map *, n);
1576 for (j = 0; j < n; ++j)
1577 grid[i][j] = isl_map_empty(isl_map_get_dim(map));
1580 for (k = 0; k < map->n; ++k) {
1582 j = group[2 * k + 1];
1583 grid[i][j] = isl_map_union(grid[i][j],
1584 isl_map_from_basic_map(
1585 isl_basic_map_copy(map->p[k])));
1588 if (!project && add_length(map, grid, n) < 0)
1591 floyd_warshall_iterate(grid, n, exact);
1593 app = isl_map_empty(isl_map_get_dim(map));
1595 for (i = 0; i < n; ++i) {
1596 for (j = 0; j < n; ++j)
1597 app = isl_map_union(app, grid[i][j]);
1608 for (i = 0; i < n; ++i) {
1611 for (j = 0; j < n; ++j)
1612 isl_map_free(grid[i][j]);
1621 /* Partition the domains and ranges of the n basic relations in list
1622 * into disjoint cells.
1624 * To find the partition, we simply consider all of the domains
1625 * and ranges in turn and combine those that overlap.
1626 * "set" contains the partition elements and "group" indicates
1627 * to which partition element a given domain or range belongs.
1628 * The domain of basic map i corresponds to element 2 * i in these arrays,
1629 * while the domain corresponds to element 2 * i + 1.
1630 * During the construction group[k] is either equal to k,
1631 * in which case set[k] contains the union of all the domains and
1632 * ranges in the corresponding group, or is equal to some l < k,
1633 * with l another domain or range in the same group.
1635 static int *setup_groups(isl_ctx *ctx, __isl_keep isl_basic_map **list, int n,
1636 isl_set ***set, int *n_group)
1642 *set = isl_calloc_array(ctx, isl_set *, 2 * n);
1643 group = isl_alloc_array(ctx, int, 2 * n);
1645 if (!*set || !group)
1648 for (i = 0; i < n; ++i) {
1650 dom = isl_set_from_basic_set(isl_basic_map_domain(
1651 isl_basic_map_copy(list[i])));
1652 if (merge(*set, group, dom, 2 * i) < 0)
1654 dom = isl_set_from_basic_set(isl_basic_map_range(
1655 isl_basic_map_copy(list[i])));
1656 if (merge(*set, group, dom, 2 * i + 1) < 0)
1661 for (i = 0; i < 2 * n; ++i)
1662 if (group[i] == i) {
1664 (*set)[g] = (*set)[i];
1669 group[i] = group[group[i]];
1676 for (i = 0; i < 2 * n; ++i)
1677 isl_set_free((*set)[i]);
1685 /* Check if the domains and ranges of the basic maps in "map" can
1686 * be partitioned, and if so, apply Floyd-Warshall on the elements
1687 * of the partition. Note that we also apply this algorithm
1688 * if we want to compute the power, i.e., when "project" is not set.
1689 * However, the results are unlikely to be exact since the recursive
1690 * calls inside the Floyd-Warshall algorithm typically result in
1691 * non-linear path lengths quite quickly.
1693 static __isl_give isl_map *floyd_warshall(__isl_take isl_dim *dim,
1694 __isl_keep isl_map *map, int *exact, int project)
1697 isl_set **set = NULL;
1704 return incremental_closure(dim, map, exact, project);
1706 group = setup_groups(map->ctx, map->p, map->n, &set, &n);
1710 for (i = 0; i < 2 * map->n; ++i)
1711 isl_set_free(set[i]);
1715 return floyd_warshall_with_groups(dim, map, exact, project, group, n);
1721 /* Structure for representing the nodes in the graph being traversed
1722 * using Tarjan's algorithm.
1723 * index represents the order in which nodes are visited.
1724 * min_index is the index of the root of a (sub)component.
1725 * on_stack indicates whether the node is currently on the stack.
1727 struct basic_map_sort_node {
1732 /* Structure for representing the graph being traversed
1733 * using Tarjan's algorithm.
1734 * len is the number of nodes
1735 * node is an array of nodes
1736 * stack contains the nodes on the path from the root to the current node
1737 * sp is the stack pointer
1738 * index is the index of the last node visited
1739 * order contains the elements of the components separated by -1
1740 * op represents the current position in order
1742 * check_closed is set if we may have used the fact that
1743 * a pair of basic maps can be interchanged
1745 struct basic_map_sort {
1747 struct basic_map_sort_node *node;
1756 static void basic_map_sort_free(struct basic_map_sort *s)
1766 static struct basic_map_sort *basic_map_sort_alloc(struct isl_ctx *ctx, int len)
1768 struct basic_map_sort *s;
1771 s = isl_calloc_type(ctx, struct basic_map_sort);
1775 s->node = isl_alloc_array(ctx, struct basic_map_sort_node, len);
1778 for (i = 0; i < len; ++i)
1779 s->node[i].index = -1;
1780 s->stack = isl_alloc_array(ctx, int, len);
1783 s->order = isl_alloc_array(ctx, int, 2 * len);
1791 s->check_closed = 0;
1795 basic_map_sort_free(s);
1799 /* Check whether in the computation of the transitive closure
1800 * "bmap1" (R_1) should follow (or be part of the same component as)
1803 * That is check whether
1811 * If so, then there is no reason for R_1 to immediately follow R_2
1814 * *check_closed is set if the subset relation holds while
1815 * R_1 \circ R_2 is not empty.
1817 static int basic_map_follows(__isl_keep isl_basic_map *bmap1,
1818 __isl_keep isl_basic_map *bmap2, int *check_closed)
1820 struct isl_map *map12 = NULL;
1821 struct isl_map *map21 = NULL;
1824 if (!isl_dim_tuple_match(bmap1->dim, isl_dim_in, bmap2->dim, isl_dim_out))
1827 map21 = isl_map_from_basic_map(
1828 isl_basic_map_apply_range(
1829 isl_basic_map_copy(bmap2),
1830 isl_basic_map_copy(bmap1)));
1831 subset = isl_map_is_empty(map21);
1835 isl_map_free(map21);
1839 if (!isl_dim_tuple_match(bmap1->dim, isl_dim_in, bmap1->dim, isl_dim_out) ||
1840 !isl_dim_tuple_match(bmap2->dim, isl_dim_in, bmap2->dim, isl_dim_out)) {
1841 isl_map_free(map21);
1845 map12 = isl_map_from_basic_map(
1846 isl_basic_map_apply_range(
1847 isl_basic_map_copy(bmap1),
1848 isl_basic_map_copy(bmap2)));
1850 subset = isl_map_is_subset(map21, map12);
1852 isl_map_free(map12);
1853 isl_map_free(map21);
1858 return subset < 0 ? -1 : !subset;
1860 isl_map_free(map21);
1864 /* Perform Tarjan's algorithm for computing the strongly connected components
1865 * in the graph with the disjuncts of "map" as vertices and with an
1866 * edge between any pair of disjuncts such that the first has
1867 * to be applied after the second.
1869 static int power_components_tarjan(struct basic_map_sort *s,
1870 __isl_keep isl_basic_map **list, int i)
1874 s->node[i].index = s->index;
1875 s->node[i].min_index = s->index;
1876 s->node[i].on_stack = 1;
1878 s->stack[s->sp++] = i;
1880 for (j = s->len - 1; j >= 0; --j) {
1885 if (s->node[j].index >= 0 &&
1886 (!s->node[j].on_stack ||
1887 s->node[j].index > s->node[i].min_index))
1890 f = basic_map_follows(list[i], list[j], &s->check_closed);
1896 if (s->node[j].index < 0) {
1897 power_components_tarjan(s, list, j);
1898 if (s->node[j].min_index < s->node[i].min_index)
1899 s->node[i].min_index = s->node[j].min_index;
1900 } else if (s->node[j].index < s->node[i].min_index)
1901 s->node[i].min_index = s->node[j].index;
1904 if (s->node[i].index != s->node[i].min_index)
1908 j = s->stack[--s->sp];
1909 s->node[j].on_stack = 0;
1910 s->order[s->op++] = j;
1912 s->order[s->op++] = -1;
1917 /* Decompose the "len" basic relations in "list" into strongly connected
1920 static struct basic_map_sort *basic_map_sort_init(isl_ctx *ctx, int len,
1921 __isl_keep isl_basic_map **list)
1924 struct basic_map_sort *s = NULL;
1926 s = basic_map_sort_alloc(ctx, len);
1929 for (i = len - 1; i >= 0; --i) {
1930 if (s->node[i].index >= 0)
1932 if (power_components_tarjan(s, list, i) < 0)
1938 basic_map_sort_free(s);
1942 /* Given a union of basic maps R = \cup_i R_i \subseteq D \times D
1943 * and a dimension specification (Z^{n+1} -> Z^{n+1}),
1944 * construct a map that is an overapproximation of the map
1945 * that takes an element from the dom R \times Z to an
1946 * element from ran R \times Z, such that the first n coordinates of the
1947 * difference between them is a sum of differences between images
1948 * and pre-images in one of the R_i and such that the last coordinate
1949 * is equal to the number of steps taken.
1950 * If "project" is set, then these final coordinates are not included,
1951 * i.e., a relation of type Z^n -> Z^n is returned.
1954 * \Delta_i = { y - x | (x, y) in R_i }
1956 * then the constructed map is an overapproximation of
1958 * { (x) -> (x + d) | \exists k_i >= 0, \delta_i \in \Delta_i :
1959 * d = (\sum_i k_i \delta_i, \sum_i k_i) and
1960 * x in dom R and x + d in ran R }
1964 * { (x) -> (x + d) | \exists k_i >= 0, \delta_i \in \Delta_i :
1965 * d = (\sum_i k_i \delta_i) and
1966 * x in dom R and x + d in ran R }
1968 * if "project" is set.
1970 * We first split the map into strongly connected components, perform
1971 * the above on each component and then join the results in the correct
1972 * order, at each join also taking in the union of both arguments
1973 * to allow for paths that do not go through one of the two arguments.
1975 static __isl_give isl_map *construct_power_components(__isl_take isl_dim *dim,
1976 __isl_keep isl_map *map, int *exact, int project)
1979 struct isl_map *path = NULL;
1980 struct basic_map_sort *s = NULL;
1987 return floyd_warshall(dim, map, exact, project);
1989 s = basic_map_sort_init(map->ctx, map->n, map->p);
1994 if (s->check_closed && !exact)
1995 exact = &local_exact;
2001 path = isl_map_empty(isl_map_get_dim(map));
2003 path = isl_map_empty(isl_dim_copy(dim));
2004 path = anonymize(path);
2006 struct isl_map *comp;
2007 isl_map *path_comp, *path_comb;
2008 comp = isl_map_alloc_dim(isl_map_get_dim(map), n, 0);
2009 while (s->order[i] != -1) {
2010 comp = isl_map_add_basic_map(comp,
2011 isl_basic_map_copy(map->p[s->order[i]]));
2015 path_comp = floyd_warshall(isl_dim_copy(dim),
2016 comp, exact, project);
2017 path_comp = anonymize(path_comp);
2018 path_comb = isl_map_apply_range(isl_map_copy(path),
2019 isl_map_copy(path_comp));
2020 path = isl_map_union(path, path_comp);
2021 path = isl_map_union(path, path_comb);
2027 if (c > 1 && s->check_closed && !*exact) {
2030 closed = isl_map_is_transitively_closed(path);
2034 basic_map_sort_free(s);
2036 return floyd_warshall(dim, map, orig_exact, project);
2040 basic_map_sort_free(s);
2045 basic_map_sort_free(s);
2051 /* Given a union of basic maps R = \cup_i R_i \subseteq D \times D,
2052 * construct a map that is an overapproximation of the map
2053 * that takes an element from the space D to another
2054 * element from the same space, such that the difference between
2055 * them is a strictly positive sum of differences between images
2056 * and pre-images in one of the R_i.
2057 * The number of differences in the sum is equated to parameter "param".
2060 * \Delta_i = { y - x | (x, y) in R_i }
2062 * then the constructed map is an overapproximation of
2064 * { (x) -> (x + d) | \exists k_i >= 0, \delta_i \in \Delta_i :
2065 * d = \sum_i k_i \delta_i and k = \sum_i k_i > 0 }
2068 * { (x) -> (x + d) | \exists k_i >= 0, \delta_i \in \Delta_i :
2069 * d = \sum_i k_i \delta_i and \sum_i k_i > 0 }
2071 * if "project" is set.
2073 * If "project" is not set, then
2074 * we construct an extended mapping with an extra coordinate
2075 * that indicates the number of steps taken. In particular,
2076 * the difference in the last coordinate is equal to the number
2077 * of steps taken to move from a domain element to the corresponding
2080 static __isl_give isl_map *construct_power(__isl_keep isl_map *map,
2081 int *exact, int project)
2083 struct isl_map *app = NULL;
2084 struct isl_dim *dim = NULL;
2090 dim = isl_map_get_dim(map);
2092 d = isl_dim_size(dim, isl_dim_in);
2093 dim = isl_dim_add(dim, isl_dim_in, 1);
2094 dim = isl_dim_add(dim, isl_dim_out, 1);
2096 app = construct_power_components(isl_dim_copy(dim), map,
2104 /* Compute the positive powers of "map", or an overapproximation.
2105 * If the result is exact, then *exact is set to 1.
2107 * If project is set, then we are actually interested in the transitive
2108 * closure, so we can use a more relaxed exactness check.
2109 * The lengths of the paths are also projected out instead of being
2110 * encoded as the difference between an extra pair of final coordinates.
2112 static __isl_give isl_map *map_power(__isl_take isl_map *map,
2113 int *exact, int project)
2115 struct isl_map *app = NULL;
2123 isl_assert(map->ctx,
2124 isl_map_dim(map, isl_dim_in) == isl_map_dim(map, isl_dim_out),
2127 app = construct_power(map, exact, project);
2137 /* Compute the positive powers of "map", or an overapproximation.
2138 * The result maps the exponent to a nested copy of the corresponding power.
2139 * If the result is exact, then *exact is set to 1.
2140 * map_power constructs an extended relation with the path lengths
2141 * encoded as the difference between the final coordinates.
2142 * In the final step, this difference is equated to an extra parameter
2143 * and made positive. The extra coordinates are subsequently projected out
2144 * and the parameter is turned into the domain of the result.
2146 __isl_give isl_map *isl_map_power(__isl_take isl_map *map, int *exact)
2148 isl_dim *target_dim;
2157 d = isl_map_dim(map, isl_dim_in);
2158 param = isl_map_dim(map, isl_dim_param);
2160 map = isl_map_compute_divs(map);
2161 map = isl_map_coalesce(map);
2163 if (isl_map_fast_is_empty(map)) {
2164 map = isl_map_from_range(isl_map_wrap(map));
2165 map = isl_map_add_dims(map, isl_dim_in, 1);
2166 map = isl_map_set_dim_name(map, isl_dim_in, 0, "k");
2170 target_dim = isl_map_get_dim(map);
2171 target_dim = isl_dim_from_range(isl_dim_wrap(target_dim));
2172 target_dim = isl_dim_add(target_dim, isl_dim_in, 1);
2173 target_dim = isl_dim_set_name(target_dim, isl_dim_in, 0, "k");
2175 map = map_power(map, exact, 0);
2177 map = isl_map_add_dims(map, isl_dim_param, 1);
2178 dim = isl_map_get_dim(map);
2179 diff = equate_parameter_to_length(dim, param);
2180 map = isl_map_intersect(map, diff);
2181 map = isl_map_project_out(map, isl_dim_in, d, 1);
2182 map = isl_map_project_out(map, isl_dim_out, d, 1);
2183 map = isl_map_from_range(isl_map_wrap(map));
2184 map = isl_map_move_dims(map, isl_dim_in, 0, isl_dim_param, param, 1);
2186 map = isl_map_reset_dim(map, target_dim);
2191 /* Compute a relation that maps each element in the range of the input
2192 * relation to the lengths of all paths composed of edges in the input
2193 * relation that end up in the given range element.
2194 * The result may be an overapproximation, in which case *exact is set to 0.
2195 * The resulting relation is very similar to the power relation.
2196 * The difference are that the domain has been projected out, the
2197 * range has become the domain and the exponent is the range instead
2200 __isl_give isl_map *isl_map_reaching_path_lengths(__isl_take isl_map *map,
2211 d = isl_map_dim(map, isl_dim_in);
2212 param = isl_map_dim(map, isl_dim_param);
2214 map = isl_map_compute_divs(map);
2215 map = isl_map_coalesce(map);
2217 if (isl_map_fast_is_empty(map)) {
2220 map = isl_map_project_out(map, isl_dim_out, 0, d);
2221 map = isl_map_add_dims(map, isl_dim_out, 1);
2225 map = map_power(map, exact, 0);
2227 map = isl_map_add_dims(map, isl_dim_param, 1);
2228 dim = isl_map_get_dim(map);
2229 diff = equate_parameter_to_length(dim, param);
2230 map = isl_map_intersect(map, diff);
2231 map = isl_map_project_out(map, isl_dim_in, 0, d + 1);
2232 map = isl_map_project_out(map, isl_dim_out, d, 1);
2233 map = isl_map_reverse(map);
2234 map = isl_map_move_dims(map, isl_dim_out, 0, isl_dim_param, param, 1);
2239 /* Check whether equality i of bset is a pure stride constraint
2240 * on a single dimensions, i.e., of the form
2244 * with k a constant and e an existentially quantified variable.
2246 static int is_eq_stride(__isl_keep isl_basic_set *bset, int i)
2258 if (!isl_int_is_zero(bset->eq[i][0]))
2261 nparam = isl_basic_set_dim(bset, isl_dim_param);
2262 d = isl_basic_set_dim(bset, isl_dim_set);
2263 n_div = isl_basic_set_dim(bset, isl_dim_div);
2265 if (isl_seq_first_non_zero(bset->eq[i] + 1, nparam) != -1)
2267 pos1 = isl_seq_first_non_zero(bset->eq[i] + 1 + nparam, d);
2270 if (isl_seq_first_non_zero(bset->eq[i] + 1 + nparam + pos1 + 1,
2271 d - pos1 - 1) != -1)
2274 pos2 = isl_seq_first_non_zero(bset->eq[i] + 1 + nparam + d, n_div);
2277 if (isl_seq_first_non_zero(bset->eq[i] + 1 + nparam + d + pos2 + 1,
2278 n_div - pos2 - 1) != -1)
2280 if (!isl_int_is_one(bset->eq[i][1 + nparam + pos1]) &&
2281 !isl_int_is_negone(bset->eq[i][1 + nparam + pos1]))
2287 /* Given a map, compute the smallest superset of this map that is of the form
2289 * { i -> j : L <= j - i <= U and exists a_p: j_p - i_p = M_p a_p }
2291 * (where p ranges over the (non-parametric) dimensions),
2292 * compute the transitive closure of this map, i.e.,
2294 * { i -> j : exists k > 0:
2295 * k L <= j - i <= k U and exists a: j_p - i_p = M_p a_p }
2297 * and intersect domain and range of this transitive closure with
2298 * the given domain and range.
2300 * If with_id is set, then try to include as much of the identity mapping
2301 * as possible, by computing
2303 * { i -> j : exists k >= 0:
2304 * k L <= j - i <= k U and exists a: j_p - i_p = M_p a_p }
2306 * instead (i.e., allow k = 0).
2308 * In practice, we compute the difference set
2310 * delta = { j - i | i -> j in map },
2312 * look for stride constraint on the individual dimensions and compute
2313 * (constant) lower and upper bounds for each individual dimension,
2314 * adding a constraint for each bound not equal to infinity.
2316 static __isl_give isl_map *box_closure_on_domain(__isl_take isl_map *map,
2317 __isl_take isl_set *dom, __isl_take isl_set *ran, int with_id)
2326 isl_map *app = NULL;
2327 isl_basic_set *aff = NULL;
2328 isl_basic_map *bmap = NULL;
2329 isl_vec *obj = NULL;
2334 delta = isl_map_deltas(isl_map_copy(map));
2336 aff = isl_set_affine_hull(isl_set_copy(delta));
2339 dim = isl_map_get_dim(map);
2340 d = isl_dim_size(dim, isl_dim_in);
2341 nparam = isl_dim_size(dim, isl_dim_param);
2342 total = isl_dim_total(dim);
2343 bmap = isl_basic_map_alloc_dim(dim,
2344 aff->n_div + 1, aff->n_div, 2 * d + 1);
2345 for (i = 0; i < aff->n_div + 1; ++i) {
2346 k = isl_basic_map_alloc_div(bmap);
2349 isl_int_set_si(bmap->div[k][0], 0);
2351 for (i = 0; i < aff->n_eq; ++i) {
2352 if (!is_eq_stride(aff, i))
2354 k = isl_basic_map_alloc_equality(bmap);
2357 isl_seq_clr(bmap->eq[k], 1 + nparam);
2358 isl_seq_cpy(bmap->eq[k] + 1 + nparam + d,
2359 aff->eq[i] + 1 + nparam, d);
2360 isl_seq_neg(bmap->eq[k] + 1 + nparam,
2361 aff->eq[i] + 1 + nparam, d);
2362 isl_seq_cpy(bmap->eq[k] + 1 + nparam + 2 * d,
2363 aff->eq[i] + 1 + nparam + d, aff->n_div);
2364 isl_int_set_si(bmap->eq[k][1 + total + aff->n_div], 0);
2366 obj = isl_vec_alloc(map->ctx, 1 + nparam + d);
2369 isl_seq_clr(obj->el, 1 + nparam + d);
2370 for (i = 0; i < d; ++ i) {
2371 enum isl_lp_result res;
2373 isl_int_set_si(obj->el[1 + nparam + i], 1);
2375 res = isl_set_solve_lp(delta, 0, obj->el, map->ctx->one, &opt,
2377 if (res == isl_lp_error)
2379 if (res == isl_lp_ok) {
2380 k = isl_basic_map_alloc_inequality(bmap);
2383 isl_seq_clr(bmap->ineq[k],
2384 1 + nparam + 2 * d + bmap->n_div);
2385 isl_int_set_si(bmap->ineq[k][1 + nparam + i], -1);
2386 isl_int_set_si(bmap->ineq[k][1 + nparam + d + i], 1);
2387 isl_int_neg(bmap->ineq[k][1 + nparam + 2 * d + aff->n_div], opt);
2390 res = isl_set_solve_lp(delta, 1, obj->el, map->ctx->one, &opt,
2392 if (res == isl_lp_error)
2394 if (res == isl_lp_ok) {
2395 k = isl_basic_map_alloc_inequality(bmap);
2398 isl_seq_clr(bmap->ineq[k],
2399 1 + nparam + 2 * d + bmap->n_div);
2400 isl_int_set_si(bmap->ineq[k][1 + nparam + i], 1);
2401 isl_int_set_si(bmap->ineq[k][1 + nparam + d + i], -1);
2402 isl_int_set(bmap->ineq[k][1 + nparam + 2 * d + aff->n_div], opt);
2405 isl_int_set_si(obj->el[1 + nparam + i], 0);
2407 k = isl_basic_map_alloc_inequality(bmap);
2410 isl_seq_clr(bmap->ineq[k],
2411 1 + nparam + 2 * d + bmap->n_div);
2413 isl_int_set_si(bmap->ineq[k][0], -1);
2414 isl_int_set_si(bmap->ineq[k][1 + nparam + 2 * d + aff->n_div], 1);
2416 app = isl_map_from_domain_and_range(dom, ran);
2419 isl_basic_set_free(aff);
2421 bmap = isl_basic_map_finalize(bmap);
2422 isl_set_free(delta);
2425 map = isl_map_from_basic_map(bmap);
2426 map = isl_map_intersect(map, app);
2431 isl_basic_map_free(bmap);
2432 isl_basic_set_free(aff);
2436 isl_set_free(delta);
2441 /* Given a map, compute the smallest superset of this map that is of the form
2443 * { i -> j : L <= j - i <= U and exists a_p: j_p - i_p = M_p a_p }
2445 * (where p ranges over the (non-parametric) dimensions),
2446 * compute the transitive closure of this map, i.e.,
2448 * { i -> j : exists k > 0:
2449 * k L <= j - i <= k U and exists a: j_p - i_p = M_p a_p }
2451 * and intersect domain and range of this transitive closure with
2452 * domain and range of the original map.
2454 static __isl_give isl_map *box_closure(__isl_take isl_map *map)
2459 domain = isl_map_domain(isl_map_copy(map));
2460 domain = isl_set_coalesce(domain);
2461 range = isl_map_range(isl_map_copy(map));
2462 range = isl_set_coalesce(range);
2464 return box_closure_on_domain(map, domain, range, 0);
2467 /* Given a map, compute the smallest superset of this map that is of the form
2469 * { i -> j : L <= j - i <= U and exists a_p: j_p - i_p = M_p a_p }
2471 * (where p ranges over the (non-parametric) dimensions),
2472 * compute the transitive and partially reflexive closure of this map, i.e.,
2474 * { i -> j : exists k >= 0:
2475 * k L <= j - i <= k U and exists a: j_p - i_p = M_p a_p }
2477 * and intersect domain and range of this transitive closure with
2480 static __isl_give isl_map *box_closure_with_identity(__isl_take isl_map *map,
2481 __isl_take isl_set *dom)
2483 return box_closure_on_domain(map, dom, isl_set_copy(dom), 1);
2486 /* Check whether app is the transitive closure of map.
2487 * In particular, check that app is acyclic and, if so,
2490 * app \subset (map \cup (map \circ app))
2492 static int check_exactness_omega(__isl_keep isl_map *map,
2493 __isl_keep isl_map *app)
2497 int is_empty, is_exact;
2501 delta = isl_map_deltas(isl_map_copy(app));
2502 d = isl_set_dim(delta, isl_dim_set);
2503 for (i = 0; i < d; ++i)
2504 delta = isl_set_fix_si(delta, isl_dim_set, i, 0);
2505 is_empty = isl_set_is_empty(delta);
2506 isl_set_free(delta);
2512 test = isl_map_apply_range(isl_map_copy(app), isl_map_copy(map));
2513 test = isl_map_union(test, isl_map_copy(map));
2514 is_exact = isl_map_is_subset(app, test);
2520 /* Check if basic map M_i can be combined with all the other
2521 * basic maps such that
2525 * can be computed as
2527 * M_i \cup (\cup_{j \ne i} M_i^* \circ M_j \circ M_i^*)^+
2529 * In particular, check if we can compute a compact representation
2532 * M_i^* \circ M_j \circ M_i^*
2535 * Let M_i^? be an extension of M_i^+ that allows paths
2536 * of length zero, i.e., the result of box_closure(., 1).
2537 * The criterion, as proposed by Kelly et al., is that
2538 * id = M_i^? - M_i^+ can be represented as a basic map
2541 * id \circ M_j \circ id = M_j
2545 * If this function returns 1, then tc and qc are set to
2546 * M_i^+ and M_i^?, respectively.
2548 static int can_be_split_off(__isl_keep isl_map *map, int i,
2549 __isl_give isl_map **tc, __isl_give isl_map **qc)
2551 isl_map *map_i, *id = NULL;
2558 C = isl_set_union(isl_map_domain(isl_map_copy(map)),
2559 isl_map_range(isl_map_copy(map)));
2560 C = isl_set_from_basic_set(isl_set_simple_hull(C));
2564 map_i = isl_map_from_basic_map(isl_basic_map_copy(map->p[i]));
2565 *tc = box_closure(isl_map_copy(map_i));
2566 *qc = box_closure_with_identity(map_i, C);
2567 id = isl_map_subtract(isl_map_copy(*qc), isl_map_copy(*tc));
2571 if (id->n != 1 || (*qc)->n != 1)
2574 for (j = 0; j < map->n; ++j) {
2575 isl_map *map_j, *test;
2580 map_j = isl_map_from_basic_map(
2581 isl_basic_map_copy(map->p[j]));
2582 test = isl_map_apply_range(isl_map_copy(id),
2583 isl_map_copy(map_j));
2584 test = isl_map_apply_range(test, isl_map_copy(id));
2585 is_ok = isl_map_is_equal(test, map_j);
2586 isl_map_free(map_j);
2614 static __isl_give isl_map *box_closure_with_check(__isl_take isl_map *map,
2619 app = box_closure(isl_map_copy(map));
2621 *exact = check_exactness_omega(map, app);
2627 /* Compute an overapproximation of the transitive closure of "map"
2628 * using a variation of the algorithm from
2629 * "Transitive Closure of Infinite Graphs and its Applications"
2632 * We first check whether we can can split of any basic map M_i and
2639 * M_i \cup (\cup_{j \ne i} M_i^* \circ M_j \circ M_i^*)^+
2641 * using a recursive call on the remaining map.
2643 * If not, we simply call box_closure on the whole map.
2645 static __isl_give isl_map *transitive_closure_omega(__isl_take isl_map *map,
2655 return box_closure_with_check(map, exact);
2657 for (i = 0; i < map->n; ++i) {
2660 ok = can_be_split_off(map, i, &tc, &qc);
2666 app = isl_map_alloc_dim(isl_map_get_dim(map), map->n - 1, 0);
2668 for (j = 0; j < map->n; ++j) {
2671 app = isl_map_add_basic_map(app,
2672 isl_basic_map_copy(map->p[j]));
2675 app = isl_map_apply_range(isl_map_copy(qc), app);
2676 app = isl_map_apply_range(app, qc);
2678 app = isl_map_union(tc, transitive_closure_omega(app, NULL));
2679 exact_i = check_exactness_omega(map, app);
2691 return box_closure_with_check(map, exact);
2697 /* Compute the transitive closure of "map", or an overapproximation.
2698 * If the result is exact, then *exact is set to 1.
2699 * Simply use map_power to compute the powers of map, but tell
2700 * it to project out the lengths of the paths instead of equating
2701 * the length to a parameter.
2703 __isl_give isl_map *isl_map_transitive_closure(__isl_take isl_map *map,
2706 isl_dim *target_dim;
2712 if (map->ctx->opt->closure == ISL_CLOSURE_BOX)
2713 return transitive_closure_omega(map, exact);
2715 map = isl_map_compute_divs(map);
2716 map = isl_map_coalesce(map);
2717 closed = isl_map_is_transitively_closed(map);
2726 target_dim = isl_map_get_dim(map);
2727 map = map_power(map, exact, 1);
2728 map = isl_map_reset_dim(map, target_dim);
2736 static int inc_count(__isl_take isl_map *map, void *user)
2747 static int collect_basic_map(__isl_take isl_map *map, void *user)
2750 isl_basic_map ***next = user;
2752 for (i = 0; i < map->n; ++i) {
2753 **next = isl_basic_map_copy(map->p[i]);
2766 /* Perform Floyd-Warshall on the given list of basic relations.
2767 * The basic relations may live in different dimensions,
2768 * but basic relations that get assigned to the diagonal of the
2769 * grid have domains and ranges of the same dimension and so
2770 * the standard algorithm can be used because the nested transitive
2771 * closures are only applied to diagonal elements and because all
2772 * compositions are peformed on relations with compatible domains and ranges.
2774 static __isl_give isl_union_map *union_floyd_warshall_on_list(isl_ctx *ctx,
2775 __isl_keep isl_basic_map **list, int n, int *exact)
2780 isl_set **set = NULL;
2781 isl_map ***grid = NULL;
2784 group = setup_groups(ctx, list, n, &set, &n_group);
2788 grid = isl_calloc_array(ctx, isl_map **, n_group);
2791 for (i = 0; i < n_group; ++i) {
2792 grid[i] = isl_calloc_array(map->ctx, isl_map *, n_group);
2795 for (j = 0; j < n_group; ++j) {
2796 isl_dim *dim1, *dim2, *dim;
2797 dim1 = isl_dim_reverse(isl_set_get_dim(set[i]));
2798 dim2 = isl_set_get_dim(set[j]);
2799 dim = isl_dim_join(dim1, dim2);
2800 grid[i][j] = isl_map_empty(dim);
2804 for (k = 0; k < n; ++k) {
2806 j = group[2 * k + 1];
2807 grid[i][j] = isl_map_union(grid[i][j],
2808 isl_map_from_basic_map(
2809 isl_basic_map_copy(list[k])));
2812 floyd_warshall_iterate(grid, n_group, exact);
2814 app = isl_union_map_empty(isl_map_get_dim(grid[0][0]));
2816 for (i = 0; i < n_group; ++i) {
2817 for (j = 0; j < n_group; ++j)
2818 app = isl_union_map_add_map(app, grid[i][j]);
2823 for (i = 0; i < 2 * n; ++i)
2824 isl_set_free(set[i]);
2831 for (i = 0; i < n_group; ++i) {
2834 for (j = 0; j < n_group; ++j)
2835 isl_map_free(grid[i][j]);
2840 for (i = 0; i < 2 * n; ++i)
2841 isl_set_free(set[i]);
2848 /* Perform Floyd-Warshall on the given union relation.
2849 * The implementation is very similar to that for non-unions.
2850 * The main difference is that it is applied unconditionally.
2851 * We first extract a list of basic maps from the union map
2852 * and then perform the algorithm on this list.
2854 static __isl_give isl_union_map *union_floyd_warshall(
2855 __isl_take isl_union_map *umap, int *exact)
2859 isl_basic_map **list;
2860 isl_basic_map **next;
2864 if (isl_union_map_foreach_map(umap, inc_count, &n) < 0)
2867 ctx = isl_union_map_get_ctx(umap);
2868 list = isl_calloc_array(ctx, isl_basic_map *, n);
2873 if (isl_union_map_foreach_map(umap, collect_basic_map, &next) < 0)
2876 res = union_floyd_warshall_on_list(ctx, list, n, exact);
2879 for (i = 0; i < n; ++i)
2880 isl_basic_map_free(list[i]);
2884 isl_union_map_free(umap);
2888 for (i = 0; i < n; ++i)
2889 isl_basic_map_free(list[i]);
2892 isl_union_map_free(umap);
2896 /* Decompose the give union relation into strongly connected components.
2897 * The implementation is essentially the same as that of
2898 * construct_power_components with the major difference that all
2899 * operations are performed on union maps.
2901 static __isl_give isl_union_map *union_components(
2902 __isl_take isl_union_map *umap, int *exact)
2907 isl_basic_map **list;
2908 isl_basic_map **next;
2909 isl_union_map *path = NULL;
2910 struct basic_map_sort *s = NULL;
2915 if (isl_union_map_foreach_map(umap, inc_count, &n) < 0)
2919 return union_floyd_warshall(umap, exact);
2921 ctx = isl_union_map_get_ctx(umap);
2922 list = isl_calloc_array(ctx, isl_basic_map *, n);
2927 if (isl_union_map_foreach_map(umap, collect_basic_map, &next) < 0)
2930 s = basic_map_sort_init(ctx, n, list);
2937 path = isl_union_map_empty(isl_union_map_get_dim(umap));
2939 isl_union_map *comp;
2940 isl_union_map *path_comp, *path_comb;
2941 comp = isl_union_map_empty(isl_union_map_get_dim(umap));
2942 while (s->order[i] != -1) {
2943 comp = isl_union_map_add_map(comp,
2944 isl_map_from_basic_map(
2945 isl_basic_map_copy(list[s->order[i]])));
2949 path_comp = union_floyd_warshall(comp, exact);
2950 path_comb = isl_union_map_apply_range(isl_union_map_copy(path),
2951 isl_union_map_copy(path_comp));
2952 path = isl_union_map_union(path, path_comp);
2953 path = isl_union_map_union(path, path_comb);
2958 if (c > 1 && s->check_closed && !*exact) {
2961 closed = isl_union_map_is_transitively_closed(path);
2967 basic_map_sort_free(s);
2969 for (i = 0; i < n; ++i)
2970 isl_basic_map_free(list[i]);
2974 isl_union_map_free(path);
2975 return union_floyd_warshall(umap, exact);
2978 isl_union_map_free(umap);
2982 basic_map_sort_free(s);
2984 for (i = 0; i < n; ++i)
2985 isl_basic_map_free(list[i]);
2988 isl_union_map_free(umap);
2989 isl_union_map_free(path);
2993 /* Compute the transitive closure of "umap", or an overapproximation.
2994 * If the result is exact, then *exact is set to 1.
2996 __isl_give isl_union_map *isl_union_map_transitive_closure(
2997 __isl_take isl_union_map *umap, int *exact)
3007 umap = isl_union_map_compute_divs(umap);
3008 umap = isl_union_map_coalesce(umap);
3009 closed = isl_union_map_is_transitively_closed(umap);
3014 umap = union_components(umap, exact);
3017 isl_union_map_free(umap);