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,
12 #include "isl_map_private.h"
15 /* Given a map that represents a path with the length of the path
16 * encoded as the difference between the last output coordindate
17 * and the last input coordinate, set this length to either
18 * exactly "length" (if "exactly" is set) or at least "length"
19 * (if "exactly" is not set).
21 static __isl_give isl_map
*set_path_length(__isl_take isl_map
*map
,
22 int exactly
, int length
)
25 struct isl_basic_map
*bmap
;
34 dim
= isl_map_get_dim(map
);
35 d
= isl_dim_size(dim
, isl_dim_in
);
36 nparam
= isl_dim_size(dim
, isl_dim_param
);
37 bmap
= isl_basic_map_alloc_dim(dim
, 0, 1, 1);
39 k
= isl_basic_map_alloc_equality(bmap
);
42 k
= isl_basic_map_alloc_inequality(bmap
);
47 isl_seq_clr(c
, 1 + isl_basic_map_total_dim(bmap
));
48 isl_int_set_si(c
[0], -length
);
49 isl_int_set_si(c
[1 + nparam
+ d
- 1], -1);
50 isl_int_set_si(c
[1 + nparam
+ d
+ d
- 1], 1);
52 bmap
= isl_basic_map_finalize(bmap
);
53 map
= isl_map_intersect(map
, isl_map_from_basic_map(bmap
));
57 isl_basic_map_free(bmap
);
62 /* Check whether the overapproximation of the power of "map" is exactly
63 * the power of "map". Let R be "map" and A_k the overapproximation.
64 * The approximation is exact if
67 * A_k = A_{k-1} \circ R k >= 2
69 * Since A_k is known to be an overapproximation, we only need to check
72 * A_k \subset A_{k-1} \circ R k >= 2
74 * In practice, "app" has an extra input and output coordinate
75 * to encode the length of the path. So, we first need to add
76 * this coordinate to "map" and set the length of the path to
79 static int check_power_exactness(__isl_take isl_map
*map
,
80 __isl_take isl_map
*app
)
86 map
= isl_map_add(map
, isl_dim_in
, 1);
87 map
= isl_map_add(map
, isl_dim_out
, 1);
88 map
= set_path_length(map
, 1, 1);
90 app_1
= set_path_length(isl_map_copy(app
), 1, 1);
92 exact
= isl_map_is_subset(app_1
, map
);
95 if (!exact
|| exact
< 0) {
101 app_1
= set_path_length(isl_map_copy(app
), 0, 1);
102 app_2
= set_path_length(app
, 0, 2);
103 app_1
= isl_map_apply_range(map
, app_1
);
105 exact
= isl_map_is_subset(app_2
, app_1
);
113 /* Check whether the overapproximation of the power of "map" is exactly
114 * the power of "map", possibly after projecting out the power (if "project"
117 * If "project" is set and if "steps" can only result in acyclic paths,
120 * A = R \cup (A \circ R)
122 * where A is the overapproximation with the power projected out, i.e.,
123 * an overapproximation of the transitive closure.
124 * More specifically, since A is known to be an overapproximation, we check
126 * A \subset R \cup (A \circ R)
128 * Otherwise, we check if the power is exact.
130 * Note that "app" has an extra input and output coordinate to encode
131 * the length of the part. If we are only interested in the transitive
132 * closure, then we can simply project out these coordinates first.
134 static int check_exactness(__isl_take isl_map
*map
, __isl_take isl_map
*app
,
142 return check_power_exactness(map
, app
);
144 d
= isl_map_dim(map
, isl_dim_in
);
145 app
= set_path_length(app
, 0, 1);
146 app
= isl_map_project_out(app
, isl_dim_in
, d
, 1);
147 app
= isl_map_project_out(app
, isl_dim_out
, d
, 1);
149 test
= isl_map_apply_range(isl_map_copy(map
), isl_map_copy(app
));
150 test
= isl_map_union(test
, isl_map_copy(map
));
152 exact
= isl_map_is_subset(app
, test
);
167 * The transitive closure implementation is based on the paper
168 * "Computing the Transitive Closure of a Union of Affine Integer
169 * Tuple Relations" by Anna Beletska, Denis Barthou, Wlodzimierz Bielecki and
173 /* Given a set of n offsets v_i (the rows of "steps"), construct a relation
174 * of the given dimension specification (Z^{n+1} -> Z^{n+1})
175 * that maps an element x to any element that can be reached
176 * by taking a non-negative number of steps along any of
177 * the extended offsets v'_i = [v_i 1].
180 * { [x] -> [y] : exists k_i >= 0, y = x + \sum_i k_i v'_i }
182 * For any element in this relation, the number of steps taken
183 * is equal to the difference in the final coordinates.
185 static __isl_give isl_map
*path_along_steps(__isl_take isl_dim
*dim
,
186 __isl_keep isl_mat
*steps
)
189 struct isl_basic_map
*path
= NULL
;
197 d
= isl_dim_size(dim
, isl_dim_in
);
199 nparam
= isl_dim_size(dim
, isl_dim_param
);
201 path
= isl_basic_map_alloc_dim(isl_dim_copy(dim
), n
, d
, n
);
203 for (i
= 0; i
< n
; ++i
) {
204 k
= isl_basic_map_alloc_div(path
);
207 isl_assert(steps
->ctx
, i
== k
, goto error
);
208 isl_int_set_si(path
->div
[k
][0], 0);
211 for (i
= 0; i
< d
; ++i
) {
212 k
= isl_basic_map_alloc_equality(path
);
215 isl_seq_clr(path
->eq
[k
], 1 + isl_basic_map_total_dim(path
));
216 isl_int_set_si(path
->eq
[k
][1 + nparam
+ i
], 1);
217 isl_int_set_si(path
->eq
[k
][1 + nparam
+ d
+ i
], -1);
219 for (j
= 0; j
< n
; ++j
)
220 isl_int_set_si(path
->eq
[k
][1 + nparam
+ 2 * d
+ j
], 1);
222 for (j
= 0; j
< n
; ++j
)
223 isl_int_set(path
->eq
[k
][1 + nparam
+ 2 * d
+ j
],
227 for (i
= 0; i
< n
; ++i
) {
228 k
= isl_basic_map_alloc_inequality(path
);
231 isl_seq_clr(path
->ineq
[k
], 1 + isl_basic_map_total_dim(path
));
232 isl_int_set_si(path
->ineq
[k
][1 + nparam
+ 2 * d
+ i
], 1);
237 path
= isl_basic_map_simplify(path
);
238 path
= isl_basic_map_finalize(path
);
239 return isl_map_from_basic_map(path
);
242 isl_basic_map_free(path
);
250 /* Return PURE_PARAM if only the coefficients of the parameters are non-zero.
251 * Return PURE_VAR if only the coefficients of the set variables are non-zero.
252 * Return IMPURE otherwise.
254 static int purity(__isl_keep isl_basic_set
*bset
, isl_int
*c
)
260 n_div
= isl_basic_set_dim(bset
, isl_dim_div
);
261 d
= isl_basic_set_dim(bset
, isl_dim_set
);
262 nparam
= isl_basic_set_dim(bset
, isl_dim_param
);
264 if (isl_seq_first_non_zero(c
+ 1 + nparam
+ d
, n_div
) != -1)
266 if (isl_seq_first_non_zero(c
+ 1, nparam
) == -1)
268 if (isl_seq_first_non_zero(c
+ 1 + nparam
, d
) == -1)
273 /* Given a set of offsets "delta", construct a relation of the
274 * given dimension specification (Z^{n+1} -> Z^{n+1}) that
275 * is an overapproximation of the relations that
276 * maps an element x to any element that can be reached
277 * by taking a non-negative number of steps along any of
278 * the elements in "delta".
279 * That is, construct an approximation of
281 * { [x] -> [y] : exists f \in \delta, k \in Z :
282 * y = x + k [f, 1] and k >= 0 }
284 * For any element in this relation, the number of steps taken
285 * is equal to the difference in the final coordinates.
287 * In particular, let delta be defined as
289 * \delta = [p] -> { [x] : A x + a >= and B p + b >= 0 and
290 * C x + C'p + c >= 0 }
292 * then the relation is constructed as
294 * { [x] -> [y] : exists [f, k] \in Z^{n+1} : y = x + f and
295 * A f + k a >= 0 and B p + b >= 0 and k >= 1 }
296 * union { [x] -> [x] }
298 * Existentially quantified variables in \delta are currently ignored.
299 * This is safe, but leads to an additional overapproximation.
301 static __isl_give isl_map
*path_along_delta(__isl_take isl_dim
*dim
,
302 __isl_take isl_basic_set
*delta
)
304 isl_basic_map
*path
= NULL
;
313 n_div
= isl_basic_set_dim(delta
, isl_dim_div
);
314 d
= isl_basic_set_dim(delta
, isl_dim_set
);
315 nparam
= isl_basic_set_dim(delta
, isl_dim_param
);
316 path
= isl_basic_map_alloc_dim(isl_dim_copy(dim
), n_div
+ d
+ 1,
317 d
+ 1 + delta
->n_eq
, delta
->n_ineq
+ 1);
318 off
= 1 + nparam
+ 2 * (d
+ 1) + n_div
;
320 for (i
= 0; i
< n_div
+ d
+ 1; ++i
) {
321 k
= isl_basic_map_alloc_div(path
);
324 isl_int_set_si(path
->div
[k
][0], 0);
327 for (i
= 0; i
< d
+ 1; ++i
) {
328 k
= isl_basic_map_alloc_equality(path
);
331 isl_seq_clr(path
->eq
[k
], 1 + isl_basic_map_total_dim(path
));
332 isl_int_set_si(path
->eq
[k
][1 + nparam
+ i
], 1);
333 isl_int_set_si(path
->eq
[k
][1 + nparam
+ d
+ 1 + i
], -1);
334 isl_int_set_si(path
->eq
[k
][off
+ i
], 1);
337 for (i
= 0; i
< delta
->n_eq
; ++i
) {
338 int p
= purity(delta
, delta
->eq
[i
]);
341 k
= isl_basic_map_alloc_equality(path
);
344 isl_seq_clr(path
->eq
[k
], 1 + isl_basic_map_total_dim(path
));
346 isl_seq_cpy(path
->eq
[k
] + off
,
347 delta
->eq
[i
] + 1 + nparam
, d
);
348 isl_int_set(path
->eq
[k
][off
+ d
], delta
->eq
[i
][0]);
350 isl_seq_cpy(path
->eq
[k
], delta
->eq
[i
], 1 + nparam
);
353 for (i
= 0; i
< delta
->n_ineq
; ++i
) {
354 int p
= purity(delta
, delta
->ineq
[i
]);
357 k
= isl_basic_map_alloc_inequality(path
);
360 isl_seq_clr(path
->ineq
[k
], 1 + isl_basic_map_total_dim(path
));
362 isl_seq_cpy(path
->ineq
[k
] + off
,
363 delta
->ineq
[i
] + 1 + nparam
, d
);
364 isl_int_set(path
->ineq
[k
][off
+ d
], delta
->ineq
[i
][0]);
366 isl_seq_cpy(path
->ineq
[k
], delta
->ineq
[i
], 1 + nparam
);
369 k
= isl_basic_map_alloc_inequality(path
);
372 isl_seq_clr(path
->ineq
[k
], 1 + isl_basic_map_total_dim(path
));
373 isl_int_set_si(path
->ineq
[k
][0], -1);
374 isl_int_set_si(path
->ineq
[k
][off
+ d
], 1);
376 isl_basic_set_free(delta
);
377 path
= isl_basic_map_finalize(path
);
378 return isl_basic_map_union(path
,
379 isl_basic_map_identity(isl_dim_domain(dim
)));
382 isl_basic_set_free(delta
);
383 isl_basic_map_free(path
);
387 /* Given a dimenion specification Z^{n+1} -> Z^{n+1} and a parameter "param",
388 * construct a map that equates the parameter to the difference
389 * in the final coordinates and imposes that this difference is positive.
392 * { [x,x_s] -> [y,y_s] : k = y_s - x_s > 0 }
394 static __isl_give isl_map
*equate_parameter_to_length(__isl_take isl_dim
*dim
,
397 struct isl_basic_map
*bmap
;
402 d
= isl_dim_size(dim
, isl_dim_in
);
403 nparam
= isl_dim_size(dim
, isl_dim_param
);
404 bmap
= isl_basic_map_alloc_dim(dim
, 0, 1, 1);
405 k
= isl_basic_map_alloc_equality(bmap
);
408 isl_seq_clr(bmap
->eq
[k
], 1 + isl_basic_map_total_dim(bmap
));
409 isl_int_set_si(bmap
->eq
[k
][1 + param
], -1);
410 isl_int_set_si(bmap
->eq
[k
][1 + nparam
+ d
- 1], -1);
411 isl_int_set_si(bmap
->eq
[k
][1 + nparam
+ d
+ d
- 1], 1);
413 k
= isl_basic_map_alloc_inequality(bmap
);
416 isl_seq_clr(bmap
->ineq
[k
], 1 + isl_basic_map_total_dim(bmap
));
417 isl_int_set_si(bmap
->ineq
[k
][1 + param
], 1);
418 isl_int_set_si(bmap
->ineq
[k
][0], -1);
420 bmap
= isl_basic_map_finalize(bmap
);
421 return isl_map_from_basic_map(bmap
);
423 isl_basic_map_free(bmap
);
427 /* Check whether "path" is acyclic, where the last coordinates of domain
428 * and range of path encode the number of steps taken.
429 * That is, check whether
431 * { d | d = y - x and (x,y) in path }
433 * does not contain any element with positive last coordinate (positive length)
434 * and zero remaining coordinates (cycle).
436 static int is_acyclic(__isl_take isl_map
*path
)
441 struct isl_set
*delta
;
443 delta
= isl_map_deltas(path
);
444 dim
= isl_set_dim(delta
, isl_dim_set
);
445 for (i
= 0; i
< dim
; ++i
) {
447 delta
= isl_set_lower_bound_si(delta
, isl_dim_set
, i
, 1);
449 delta
= isl_set_fix_si(delta
, isl_dim_set
, i
, 0);
452 acyclic
= isl_set_is_empty(delta
);
458 /* Given a union of basic maps R = \cup_i R_i \subseteq D \times D
459 * and a dimension specification (Z^{n+1} -> Z^{n+1}),
460 * construct a map that is an overapproximation of the map
461 * that takes an element from the space D \times Z to another
462 * element from the same space, such that the first n coordinates of the
463 * difference between them is a sum of differences between images
464 * and pre-images in one of the R_i and such that the last coordinate
465 * is equal to the number of steps taken.
468 * \Delta_i = { y - x | (x, y) in R_i }
470 * then the constructed map is an overapproximation of
472 * { (x) -> (x + d) | \exists k_i >= 0, \delta_i \in \Delta_i :
473 * d = (\sum_i k_i \delta_i, \sum_i k_i) }
475 * The elements of the singleton \Delta_i's are collected as the
476 * rows of the steps matrix. For all these \Delta_i's together,
477 * a single path is constructed.
478 * For each of the other \Delta_i's, we compute an overapproximation
479 * of the paths along elements of \Delta_i.
480 * Since each of these paths performs an addition, composition is
481 * symmetric and we can simply compose all resulting paths in any order.
483 static __isl_give isl_map
*construct_extended_path(__isl_take isl_dim
*dim
,
484 __isl_keep isl_map
*map
, int *project
)
486 struct isl_mat
*steps
= NULL
;
487 struct isl_map
*path
= NULL
;
491 d
= isl_map_dim(map
, isl_dim_in
);
493 path
= isl_map_identity(isl_dim_domain(isl_dim_copy(dim
)));
495 steps
= isl_mat_alloc(map
->ctx
, map
->n
, d
);
500 for (i
= 0; i
< map
->n
; ++i
) {
501 struct isl_basic_set
*delta
;
503 delta
= isl_basic_map_deltas(isl_basic_map_copy(map
->p
[i
]));
505 for (j
= 0; j
< d
; ++j
) {
508 fixed
= isl_basic_set_fast_dim_is_fixed(delta
, j
,
511 isl_basic_set_free(delta
);
520 path
= isl_map_apply_range(path
,
521 path_along_delta(isl_dim_copy(dim
), delta
));
523 isl_basic_set_free(delta
);
530 path
= isl_map_apply_range(path
,
531 path_along_steps(isl_dim_copy(dim
), steps
));
534 if (project
&& *project
) {
535 *project
= is_acyclic(isl_map_copy(path
));
550 /* Given a union of basic maps R = \cup_i R_i \subseteq D \times D
551 * and a dimension specification (Z^{n+1} -> Z^{n+1}),
552 * construct a map that is the union of the identity map and
553 * an overapproximation of the map
554 * that takes an element from the dom R \times Z to an
555 * element from ran R \times Z, such that the first n coordinates of the
556 * difference between them is a sum of differences between images
557 * and pre-images in one of the R_i and such that the last coordinate
558 * is equal to the number of steps taken.
561 * \Delta_i = { y - x | (x, y) in R_i }
563 * then the constructed map is an overapproximation of
565 * { (x) -> (x + d) | \exists k_i >= 0, \delta_i \in \Delta_i :
566 * d = (\sum_i k_i \delta_i, \sum_i k_i) and
567 * x in dom R and x + d in ran R } union
570 static __isl_give isl_map
*construct_component(__isl_take isl_dim
*dim
,
571 __isl_keep isl_map
*map
, int *project
)
573 struct isl_set
*domain
= NULL
;
574 struct isl_set
*range
= NULL
;
575 struct isl_map
*app
= NULL
;
576 struct isl_map
*path
= NULL
;
578 domain
= isl_map_domain(isl_map_copy(map
));
579 domain
= isl_set_coalesce(domain
);
580 range
= isl_map_range(isl_map_copy(map
));
581 range
= isl_set_coalesce(range
);
582 app
= isl_map_from_domain_and_range(domain
, range
);
583 app
= isl_map_add(app
, isl_dim_in
, 1);
584 app
= isl_map_add(app
, isl_dim_out
, 1);
586 path
= construct_extended_path(isl_dim_copy(dim
), map
, project
);
587 app
= isl_map_intersect(app
, path
);
589 return isl_map_union(app
, isl_map_identity(isl_dim_domain(dim
)));
592 /* Structure for representing the nodes in the graph being traversed
593 * using Tarjan's algorithm.
594 * index represents the order in which nodes are visited.
595 * min_index is the index of the root of a (sub)component.
596 * on_stack indicates whether the node is currently on the stack.
598 struct basic_map_sort_node
{
603 /* Structure for representing the graph being traversed
604 * using Tarjan's algorithm.
605 * len is the number of nodes
606 * node is an array of nodes
607 * stack contains the nodes on the path from the root to the current node
608 * sp is the stack pointer
609 * index is the index of the last node visited
610 * order contains the elements of the components separated by -1
611 * op represents the current position in order
613 struct basic_map_sort
{
615 struct basic_map_sort_node
*node
;
623 static void basic_map_sort_free(struct basic_map_sort
*s
)
633 static struct basic_map_sort
*basic_map_sort_alloc(struct isl_ctx
*ctx
, int len
)
635 struct basic_map_sort
*s
;
638 s
= isl_calloc_type(ctx
, struct basic_map_sort
);
642 s
->node
= isl_alloc_array(ctx
, struct basic_map_sort_node
, len
);
645 for (i
= 0; i
< len
; ++i
)
646 s
->node
[i
].index
= -1;
647 s
->stack
= isl_alloc_array(ctx
, int, len
);
650 s
->order
= isl_alloc_array(ctx
, int, 2 * len
);
660 basic_map_sort_free(s
);
664 /* Check whether in the computation of the transitive closure
665 * "bmap1" (R_1) should follow (or be part of the same component as)
668 * That is check whether
672 * is non-empty and that moreover, it is non-empty on the set
673 * of elements that do not get mapped to the same set of elements
674 * by both "R_1 \circ R_2" and "R_2 \circ R_1".
675 * For elements that do get mapped to the same elements by these
676 * two compositions, R_1 and R_2 are commutative, so if these
677 * elements are the only ones for which R_1 \circ R_2 is non-empty,
678 * then you may just as well apply R_1 first.
680 static int basic_map_follows(__isl_keep isl_basic_map
*bmap1
,
681 __isl_keep isl_basic_map
*bmap2
)
683 struct isl_map
*map12
= NULL
;
684 struct isl_map
*map21
= NULL
;
685 struct isl_map
*d
= NULL
;
686 struct isl_set
*dom
= NULL
;
689 map21
= isl_map_from_basic_map(
690 isl_basic_map_apply_range(
691 isl_basic_map_copy(bmap2
),
692 isl_basic_map_copy(bmap1
)));
693 empty
= isl_map_is_empty(map21
);
701 map12
= isl_map_from_basic_map(
702 isl_basic_map_apply_range(
703 isl_basic_map_copy(bmap1
),
704 isl_basic_map_copy(bmap2
)));
705 d
= isl_map_subtract(isl_map_copy(map12
), isl_map_copy(map21
));
707 isl_map_subtract(isl_map_copy(map21
), isl_map_copy(map12
)));
708 dom
= isl_map_domain(d
);
710 map21
= isl_map_intersect_domain(map21
, dom
);
711 empty
= isl_map_is_empty(map21
);
716 return empty
< 0 ? -1 : !empty
;
722 /* Perform Tarjan's algorithm for computing the strongly connected components
723 * in the graph with the disjuncts of "map" as vertices and with an
724 * edge between any pair of disjuncts such that the first has
725 * to be applied after the second.
727 static int power_components_tarjan(struct basic_map_sort
*s
,
728 __isl_keep isl_map
*map
, int i
)
732 s
->node
[i
].index
= s
->index
;
733 s
->node
[i
].min_index
= s
->index
;
734 s
->node
[i
].on_stack
= 1;
736 s
->stack
[s
->sp
++] = i
;
738 for (j
= s
->len
- 1; j
>= 0; --j
) {
743 if (s
->node
[j
].index
>= 0 &&
744 (!s
->node
[j
].on_stack
||
745 s
->node
[j
].index
> s
->node
[i
].min_index
))
748 f
= basic_map_follows(map
->p
[i
], map
->p
[j
]);
754 if (s
->node
[j
].index
< 0) {
755 power_components_tarjan(s
, map
, j
);
756 if (s
->node
[j
].min_index
< s
->node
[i
].min_index
)
757 s
->node
[i
].min_index
= s
->node
[j
].min_index
;
758 } else if (s
->node
[j
].index
< s
->node
[i
].min_index
)
759 s
->node
[i
].min_index
= s
->node
[j
].index
;
762 if (s
->node
[i
].index
!= s
->node
[i
].min_index
)
766 j
= s
->stack
[--s
->sp
];
767 s
->node
[j
].on_stack
= 0;
768 s
->order
[s
->op
++] = j
;
770 s
->order
[s
->op
++] = -1;
775 /* Given a union of basic maps R = \cup_i R_i \subseteq D \times D
776 * and a dimension specification (Z^{n+1} -> Z^{n+1}),
777 * construct a map that is the union of the identity map and
778 * an overapproximation of the map
779 * that takes an element from the dom R \times Z to an
780 * element from ran R \times Z, such that the first n coordinates of the
781 * difference between them is a sum of differences between images
782 * and pre-images in one of the R_i and such that the last coordinate
783 * is equal to the number of steps taken.
786 * \Delta_i = { y - x | (x, y) in R_i }
788 * then the constructed map is an overapproximation of
790 * { (x) -> (x + d) | \exists k_i >= 0, \delta_i \in \Delta_i :
791 * d = (\sum_i k_i \delta_i, \sum_i k_i) and
792 * x in dom R and x + d in ran R } union
795 * We first split the map into strongly connected components, perform
796 * the above on each component and the join the results in the correct
797 * order. The power of each of the components needs to be extended
798 * with the identity map because a path in the global result need
799 * not go through every component.
800 * The final result will then also contain the identity map, but
801 * this part will be removed when the length of the path is forced
802 * to be strictly positive.
804 static __isl_give isl_map
*construct_power_components(__isl_take isl_dim
*dim
,
805 __isl_keep isl_map
*map
, int *project
)
808 struct isl_map
*path
= NULL
;
809 struct basic_map_sort
*s
= NULL
;
814 return construct_component(dim
, map
, project
);
816 s
= basic_map_sort_alloc(map
->ctx
, map
->n
);
819 for (i
= map
->n
- 1; i
>= 0; --i
) {
820 if (s
->node
[i
].index
>= 0)
822 if (power_components_tarjan(s
, map
, i
) < 0)
828 path
= isl_map_identity(isl_dim_domain(isl_dim_copy(dim
)));
830 struct isl_map
*comp
;
831 comp
= isl_map_alloc_dim(isl_map_get_dim(map
), n
, 0);
832 while (s
->order
[i
] != -1) {
833 comp
= isl_map_add_basic_map(comp
,
834 isl_basic_map_copy(map
->p
[s
->order
[i
]]));
838 path
= isl_map_apply_range(path
,
839 construct_component(isl_dim_copy(dim
), comp
, project
));
844 basic_map_sort_free(s
);
849 basic_map_sort_free(s
);
854 /* Given a union of basic maps R = \cup_i R_i \subseteq D \times D,
855 * construct a map that is an overapproximation of the map
856 * that takes an element from the space D to another
857 * element from the same space, such that the difference between
858 * them is a strictly positive sum of differences between images
859 * and pre-images in one of the R_i.
860 * The number of differences in the sum is equated to parameter "param".
863 * \Delta_i = { y - x | (x, y) in R_i }
865 * then the constructed map is an overapproximation of
867 * { (x) -> (x + d) | \exists k_i >= 0, \delta_i \in \Delta_i :
868 * d = \sum_i k_i \delta_i and k = \sum_i k_i > 0 }
870 * We first construct an extended mapping with an extra coordinate
871 * that indicates the number of steps taken. In particular,
872 * the difference in the last coordinate is equal to the number
873 * of steps taken to move from a domain element to the corresponding
875 * In the final step, this difference is equated to the parameter "param"
876 * and made positive. The extra coordinates are subsequently projected out.
878 static __isl_give isl_map
*construct_power(__isl_keep isl_map
*map
,
879 unsigned param
, int *exact
, int project
)
881 struct isl_map
*app
= NULL
;
882 struct isl_map
*diff
;
883 struct isl_dim
*dim
= NULL
;
889 dim
= isl_map_get_dim(map
);
891 d
= isl_dim_size(dim
, isl_dim_in
);
892 dim
= isl_dim_add(dim
, isl_dim_in
, 1);
893 dim
= isl_dim_add(dim
, isl_dim_out
, 1);
895 app
= construct_power_components(isl_dim_copy(dim
), map
,
896 exact
? &project
: NULL
);
899 (*exact
= check_exactness(isl_map_copy(map
), isl_map_copy(app
),
903 diff
= equate_parameter_to_length(dim
, param
);
904 app
= isl_map_intersect(app
, diff
);
905 app
= isl_map_project_out(app
, isl_dim_in
, d
, 1);
906 app
= isl_map_project_out(app
, isl_dim_out
, d
, 1);
915 /* Compute the positive powers of "map", or an overapproximation.
916 * The power is given by parameter "param". If the result is exact,
917 * then *exact is set to 1.
918 * If project is set, then we are actually interested in the transitive
919 * closure, so we can use a more relaxed exactness check.
921 static __isl_give isl_map
*map_power(__isl_take isl_map
*map
, unsigned param
,
922 int *exact
, int project
)
924 struct isl_map
*app
= NULL
;
929 map
= isl_map_remove_empty_parts(map
);
933 if (isl_map_fast_is_empty(map
))
936 isl_assert(map
->ctx
, param
< isl_map_dim(map
, isl_dim_param
), goto error
);
938 isl_map_dim(map
, isl_dim_in
) == isl_map_dim(map
, isl_dim_out
),
941 app
= construct_power(map
, param
, exact
, project
);
951 /* Compute the positive powers of "map", or an overapproximation.
952 * The power is given by parameter "param". If the result is exact,
953 * then *exact is set to 1.
955 __isl_give isl_map
*isl_map_power(__isl_take isl_map
*map
, unsigned param
,
958 return map_power(map
, param
, exact
, 0);
961 /* Compute the transitive closure of "map", or an overapproximation.
962 * If the result is exact, then *exact is set to 1.
963 * Simply compute the powers of map and then project out the parameter
964 * describing the power.
966 __isl_give isl_map
*isl_map_transitive_closure(__isl_take isl_map
*map
,
974 param
= isl_map_dim(map
, isl_dim_param
);
975 map
= isl_map_add(map
, isl_dim_param
, 1);
976 map
= map_power(map
, param
, exact
, 1);
977 map
= isl_map_project_out(map
, isl_dim_param
, param
, 1);