2 * Copyright 2010-2011 INRIA Saclay
3 * Copyright 2014 Ecole Normale Superieure
5 * Use of this software is governed by the MIT license
7 * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
8 * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
10 * and Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
13 #include <isl_map_private.h>
14 #include <isl_aff_private.h>
15 #include <isl_morph.h>
17 #include <isl_mat_private.h>
18 #include <isl_space_private.h>
19 #include <isl_equalities.h>
20 #include <isl_id_private.h>
22 isl_ctx
*isl_morph_get_ctx(__isl_keep isl_morph
*morph
)
26 return isl_basic_set_get_ctx(morph
->dom
);
29 __isl_give isl_morph
*isl_morph_alloc(
30 __isl_take isl_basic_set
*dom
, __isl_take isl_basic_set
*ran
,
31 __isl_take isl_mat
*map
, __isl_take isl_mat
*inv
)
35 if (!dom
|| !ran
|| !map
|| !inv
)
38 morph
= isl_alloc_type(dom
->ctx
, struct isl_morph
);
50 isl_basic_set_free(dom
);
51 isl_basic_set_free(ran
);
57 __isl_give isl_morph
*isl_morph_copy(__isl_keep isl_morph
*morph
)
66 __isl_give isl_morph
*isl_morph_dup(__isl_keep isl_morph
*morph
)
71 return isl_morph_alloc(isl_basic_set_copy(morph
->dom
),
72 isl_basic_set_copy(morph
->ran
),
73 isl_mat_copy(morph
->map
), isl_mat_copy(morph
->inv
));
76 __isl_give isl_morph
*isl_morph_cow(__isl_take isl_morph
*morph
)
84 return isl_morph_dup(morph
);
87 __isl_null isl_morph
*isl_morph_free(__isl_take isl_morph
*morph
)
95 isl_basic_set_free(morph
->dom
);
96 isl_basic_set_free(morph
->ran
);
97 isl_mat_free(morph
->map
);
98 isl_mat_free(morph
->inv
);
104 /* Is "morph" an identity on the parameters?
106 static isl_bool
identity_on_parameters(__isl_keep isl_morph
*morph
)
108 isl_bool is_identity
;
109 isl_size nparam
, nparam_ran
;
112 nparam
= isl_morph_dom_dim(morph
, isl_dim_param
);
113 nparam_ran
= isl_morph_ran_dim(morph
, isl_dim_param
);
114 if (nparam
< 0 || nparam_ran
< 0)
115 return isl_bool_error
;
116 if (nparam
!= nparam_ran
)
117 return isl_bool_false
;
119 return isl_bool_true
;
120 sub
= isl_mat_sub_alloc(morph
->map
, 0, 1 + nparam
, 0, 1 + nparam
);
121 is_identity
= isl_mat_is_scaled_identity(sub
);
127 /* Return an affine expression of the variables of the range of "morph"
128 * in terms of the parameters and the variables of the domain on "morph".
130 * In order for the space manipulations to make sense, we require
131 * that the parameters are not modified by "morph".
133 __isl_give isl_multi_aff
*isl_morph_get_var_multi_aff(
134 __isl_keep isl_morph
*morph
)
136 isl_space
*dom
, *ran
, *space
;
139 isl_size nparam
, nvar
;
141 isl_bool is_identity
;
146 is_identity
= identity_on_parameters(morph
);
150 isl_die(isl_morph_get_ctx(morph
), isl_error_invalid
,
151 "cannot handle parameter compression", return NULL
);
153 dom
= isl_morph_get_dom_space(morph
);
154 ls
= isl_local_space_from_space(isl_space_copy(dom
));
155 ran
= isl_morph_get_ran_space(morph
);
156 space
= isl_space_map_from_domain_and_range(dom
, ran
);
157 ma
= isl_multi_aff_zero(space
);
159 nparam
= isl_multi_aff_dim(ma
, isl_dim_param
);
160 nvar
= isl_multi_aff_dim(ma
, isl_dim_out
);
161 if (nparam
< 0 || nvar
< 0)
162 ma
= isl_multi_aff_free(ma
);
163 for (i
= 0; i
< nvar
; ++i
) {
168 v
= isl_mat_get_row(morph
->map
, 1 + nparam
+ i
);
169 v
= isl_vec_insert_els(v
, 0, 1);
170 val
= isl_mat_get_element_val(morph
->map
, 0, 0);
171 v
= isl_vec_set_element_val(v
, 0, val
);
172 aff
= isl_aff_alloc_vec(isl_local_space_copy(ls
), v
);
173 ma
= isl_multi_aff_set_aff(ma
, i
, aff
);
176 isl_local_space_free(ls
);
180 /* Return the domain space of "morph".
182 __isl_give isl_space
*isl_morph_get_dom_space(__isl_keep isl_morph
*morph
)
187 return isl_basic_set_get_space(morph
->dom
);
190 __isl_give isl_space
*isl_morph_get_ran_space(__isl_keep isl_morph
*morph
)
195 return isl_space_copy(morph
->ran
->dim
);
198 isl_size
isl_morph_dom_dim(__isl_keep isl_morph
*morph
, enum isl_dim_type type
)
201 return isl_size_error
;
203 return isl_basic_set_dim(morph
->dom
, type
);
206 isl_size
isl_morph_ran_dim(__isl_keep isl_morph
*morph
, enum isl_dim_type type
)
209 return isl_size_error
;
211 return isl_basic_set_dim(morph
->ran
, type
);
214 __isl_give isl_morph
*isl_morph_remove_dom_dims(__isl_take isl_morph
*morph
,
215 enum isl_dim_type type
, unsigned first
, unsigned n
)
222 morph
= isl_morph_cow(morph
);
226 dom_offset
= 1 + isl_space_offset(morph
->dom
->dim
, type
);
228 morph
->dom
= isl_basic_set_remove_dims(morph
->dom
, type
, first
, n
);
230 morph
->map
= isl_mat_drop_cols(morph
->map
, dom_offset
+ first
, n
);
232 morph
->inv
= isl_mat_drop_rows(morph
->inv
, dom_offset
+ first
, n
);
234 if (morph
->dom
&& morph
->ran
&& morph
->map
&& morph
->inv
)
237 isl_morph_free(morph
);
241 __isl_give isl_morph
*isl_morph_remove_ran_dims(__isl_take isl_morph
*morph
,
242 enum isl_dim_type type
, unsigned first
, unsigned n
)
249 morph
= isl_morph_cow(morph
);
253 ran_offset
= 1 + isl_space_offset(morph
->ran
->dim
, type
);
255 morph
->ran
= isl_basic_set_remove_dims(morph
->ran
, type
, first
, n
);
257 morph
->map
= isl_mat_drop_rows(morph
->map
, ran_offset
+ first
, n
);
259 morph
->inv
= isl_mat_drop_cols(morph
->inv
, ran_offset
+ first
, n
);
261 if (morph
->dom
&& morph
->ran
&& morph
->map
&& morph
->inv
)
264 isl_morph_free(morph
);
268 /* Project domain of morph onto its parameter domain.
270 __isl_give isl_morph
*isl_morph_dom_params(__isl_take isl_morph
*morph
)
274 morph
= isl_morph_cow(morph
);
277 n
= isl_basic_set_dim(morph
->dom
, isl_dim_set
);
279 return isl_morph_free(morph
);
280 morph
= isl_morph_remove_dom_dims(morph
, isl_dim_set
, 0, n
);
283 morph
->dom
= isl_basic_set_params(morph
->dom
);
287 isl_morph_free(morph
);
291 /* Project range of morph onto its parameter domain.
293 __isl_give isl_morph
*isl_morph_ran_params(__isl_take isl_morph
*morph
)
297 morph
= isl_morph_cow(morph
);
300 n
= isl_basic_set_dim(morph
->ran
, isl_dim_set
);
302 return isl_morph_free(morph
);
303 morph
= isl_morph_remove_ran_dims(morph
, isl_dim_set
, 0, n
);
306 morph
->ran
= isl_basic_set_params(morph
->ran
);
310 isl_morph_free(morph
);
314 /* Replace the identifier of the tuple of the range of the morph by "id".
316 static __isl_give isl_morph
*isl_morph_set_ran_tuple_id(
317 __isl_take isl_morph
*morph
, __isl_keep isl_id
*id
)
319 morph
= isl_morph_cow(morph
);
322 morph
->ran
= isl_basic_set_set_tuple_id(morph
->ran
, isl_id_copy(id
));
324 return isl_morph_free(morph
);
328 void isl_morph_print_internal(__isl_take isl_morph
*morph
, FILE *out
)
333 isl_basic_set_dump(morph
->dom
);
334 isl_basic_set_dump(morph
->ran
);
335 isl_mat_print_internal(morph
->map
, out
, 4);
336 isl_mat_print_internal(morph
->inv
, out
, 4);
339 void isl_morph_dump(__isl_take isl_morph
*morph
)
341 isl_morph_print_internal(morph
, stderr
);
344 __isl_give isl_morph
*isl_morph_identity(__isl_keep isl_basic_set
*bset
)
347 isl_basic_set
*universe
;
350 total
= isl_basic_set_dim(bset
, isl_dim_all
);
354 id
= isl_mat_identity(bset
->ctx
, 1 + total
);
355 universe
= isl_basic_set_universe(isl_space_copy(bset
->dim
));
357 return isl_morph_alloc(universe
, isl_basic_set_copy(universe
),
358 id
, isl_mat_copy(id
));
361 /* Create a(n identity) morphism between empty sets of the same dimension
364 __isl_give isl_morph
*isl_morph_empty(__isl_keep isl_basic_set
*bset
)
367 isl_basic_set
*empty
;
370 total
= isl_basic_set_dim(bset
, isl_dim_all
);
374 id
= isl_mat_identity(bset
->ctx
, 1 + total
);
375 empty
= isl_basic_set_empty(isl_space_copy(bset
->dim
));
377 return isl_morph_alloc(empty
, isl_basic_set_copy(empty
),
378 id
, isl_mat_copy(id
));
381 /* Construct a basic set described by the "n" equalities of "bset" starting
384 static __isl_give isl_basic_set
*copy_equalities(__isl_keep isl_basic_set
*bset
,
385 unsigned first
, unsigned n
)
391 total
= isl_basic_set_dim(bset
, isl_dim_all
);
392 if (total
< 0 || isl_basic_set_check_no_locals(bset
) < 0)
395 eq
= isl_basic_set_alloc_space(isl_basic_set_get_space(bset
), 0, n
, 0);
398 for (i
= 0; i
< n
; ++i
) {
399 k
= isl_basic_set_alloc_equality(eq
);
402 isl_seq_cpy(eq
->eq
[k
], bset
->eq
[first
+ i
], 1 + total
);
407 isl_basic_set_free(eq
);
411 /* Given a basic set, exploit the equalities in the basic set to construct
412 * a morphism that maps the basic set to a lower-dimensional space.
413 * Specifically, the morphism reduces the number of dimensions of type "type".
415 * We first select the equalities of interest, that is those that involve
416 * variables of type "type" and no later variables.
417 * Denote those equalities as
421 * where C(p) depends on the parameters if type == isl_dim_set and
422 * is a constant if type == isl_dim_param.
424 * Use isl_mat_final_variable_compression to construct a compression
430 * If T is a zero-column matrix, then the set of equality constraints
431 * do not admit a solution. In this case, an empty morphism is returned.
433 * Both matrices are extended to map the full original space to the full
436 __isl_give isl_morph
*isl_basic_set_variable_compression(
437 __isl_keep isl_basic_set
*bset
, enum isl_dim_type type
)
447 isl_basic_set
*dom
, *ran
;
452 if (isl_basic_set_plain_is_empty(bset
))
453 return isl_morph_empty(bset
);
455 if (isl_basic_set_check_no_locals(bset
) < 0)
458 ntype
= isl_basic_set_dim(bset
, type
);
459 total
= isl_basic_set_dim(bset
, isl_dim_all
);
460 if (ntype
< 0 || total
< 0)
462 otype
= isl_basic_set_offset(bset
, type
);
463 orest
= otype
+ ntype
;
464 nrest
= total
- (orest
- 1);
466 for (f_eq
= 0; f_eq
< bset
->n_eq
; ++f_eq
)
467 if (isl_seq_first_non_zero(bset
->eq
[f_eq
] + orest
, nrest
) == -1)
469 for (n_eq
= 0; f_eq
+ n_eq
< bset
->n_eq
; ++n_eq
)
470 if (isl_seq_first_non_zero(bset
->eq
[f_eq
+ n_eq
] + otype
, ntype
) == -1)
473 return isl_morph_identity(bset
);
475 E
= isl_mat_sub_alloc6(bset
->ctx
, bset
->eq
, f_eq
, n_eq
, 0, orest
);
476 C
= isl_mat_final_variable_compression(E
, otype
- 1, &Q
);
479 if (C
&& C
->n_col
== 0) {
482 return isl_morph_empty(bset
);
485 Q
= isl_mat_diagonal(Q
, isl_mat_identity(bset
->ctx
, nrest
));
486 C
= isl_mat_diagonal(C
, isl_mat_identity(bset
->ctx
, nrest
));
488 space
= isl_space_copy(bset
->dim
);
489 space
= isl_space_drop_dims(space
, type
, 0, ntype
);
490 space
= isl_space_add_dims(space
, type
, ntype
- n_eq
);
491 ran
= isl_basic_set_universe(space
);
492 dom
= copy_equalities(bset
, f_eq
, n_eq
);
494 return isl_morph_alloc(dom
, ran
, Q
, C
);
497 /* Given a basic set, exploit the equalities in the basic set to construct
498 * a morphism that maps the basic set to a lower-dimensional space
499 * with identifier "id".
500 * Specifically, the morphism reduces the number of set dimensions.
502 __isl_give isl_morph
*isl_basic_set_variable_compression_with_id(
503 __isl_keep isl_basic_set
*bset
, __isl_keep isl_id
*id
)
507 morph
= isl_basic_set_variable_compression(bset
, isl_dim_set
);
508 morph
= isl_morph_set_ran_tuple_id(morph
, id
);
512 /* Construct a parameter compression for "bset".
513 * We basically just call isl_mat_parameter_compression with the right input
514 * and then extend the resulting matrix to include the variables.
516 * The implementation assumes that "bset" does not have any equalities
517 * that only involve the parameters and that isl_basic_set_gauss has
518 * been applied to "bset".
520 * Let the equalities be given as
524 * We use isl_mat_parameter_compression_ext to compute the compression
528 __isl_give isl_morph
*isl_basic_set_parameter_compression(
529 __isl_keep isl_basic_set
*bset
)
537 isl_basic_set
*dom
, *ran
;
542 if (isl_basic_set_plain_is_empty(bset
))
543 return isl_morph_empty(bset
);
545 return isl_morph_identity(bset
);
548 nparam
= isl_basic_set_dim(bset
, isl_dim_param
);
549 nvar
= isl_basic_set_dim(bset
, isl_dim_set
);
550 n_div
= isl_basic_set_dim(bset
, isl_dim_div
);
551 if (nparam
< 0 || nvar
< 0 || n_div
< 0)
554 if (isl_seq_first_non_zero(bset
->eq
[bset
->n_eq
- 1] + 1 + nparam
,
556 isl_die(isl_basic_set_get_ctx(bset
), isl_error_invalid
,
557 "input not allowed to have parameter equalities",
559 if (n_eq
> nvar
+ n_div
)
560 isl_die(isl_basic_set_get_ctx(bset
), isl_error_invalid
,
561 "input not gaussed", return NULL
);
563 B
= isl_mat_sub_alloc6(bset
->ctx
, bset
->eq
, 0, n_eq
, 0, 1 + nparam
);
564 H
= isl_mat_sub_alloc6(bset
->ctx
, bset
->eq
,
565 0, n_eq
, 1 + nparam
, nvar
+ n_div
);
566 inv
= isl_mat_parameter_compression_ext(B
, H
);
567 inv
= isl_mat_diagonal(inv
, isl_mat_identity(bset
->ctx
, nvar
));
568 map
= isl_mat_right_inverse(isl_mat_copy(inv
));
570 dom
= isl_basic_set_universe(isl_space_copy(bset
->dim
));
571 ran
= isl_basic_set_universe(isl_space_copy(bset
->dim
));
573 return isl_morph_alloc(dom
, ran
, map
, inv
);
576 /* Add stride constraints to "bset" based on the inverse mapping
577 * that was plugged in. In particular, if morph maps x' to x,
578 * the constraints of the original input
582 * have been rewritten to
586 * However, this substitution may loose information on the integrality of x',
587 * so we need to impose that
591 * is integral. If inv = B/d, this means that we need to impose that
597 * exists alpha in Z^m: B x = d alpha
599 * This function is similar to add_strides in isl_affine_hull.c
601 static __isl_give isl_basic_set
*add_strides(__isl_take isl_basic_set
*bset
,
602 __isl_keep isl_morph
*morph
)
607 if (isl_int_is_one(morph
->inv
->row
[0][0]))
612 for (i
= 0; 1 + i
< morph
->inv
->n_row
; ++i
) {
613 isl_seq_gcd(morph
->inv
->row
[1 + i
], morph
->inv
->n_col
, &gcd
);
614 if (isl_int_is_divisible_by(gcd
, morph
->inv
->row
[0][0]))
616 div
= isl_basic_set_alloc_div(bset
);
619 isl_int_set_si(bset
->div
[div
][0], 0);
620 k
= isl_basic_set_alloc_equality(bset
);
623 isl_seq_cpy(bset
->eq
[k
], morph
->inv
->row
[1 + i
],
625 isl_seq_clr(bset
->eq
[k
] + morph
->inv
->n_col
, bset
->n_div
);
626 isl_int_set(bset
->eq
[k
][morph
->inv
->n_col
+ div
],
627 morph
->inv
->row
[0][0]);
635 isl_basic_set_free(bset
);
639 /* Apply the morphism to the basic set.
640 * We basically just compute the preimage of "bset" under the inverse mapping
641 * in morph, add in stride constraints and intersect with the range
644 __isl_give isl_basic_set
*isl_morph_basic_set(__isl_take isl_morph
*morph
,
645 __isl_take isl_basic_set
*bset
)
647 isl_basic_set
*res
= NULL
;
652 if (!morph
|| isl_basic_set_check_equal_space(bset
, morph
->dom
) < 0)
655 max_stride
= morph
->inv
->n_row
- 1;
656 if (isl_int_is_one(morph
->inv
->row
[0][0]))
658 res
= isl_basic_set_alloc_space(isl_space_copy(morph
->ran
->dim
),
659 bset
->n_div
+ max_stride
, bset
->n_eq
+ max_stride
, bset
->n_ineq
);
661 for (i
= 0; i
< bset
->n_div
; ++i
)
662 if (isl_basic_set_alloc_div(res
) < 0)
665 mat
= isl_mat_sub_alloc6(bset
->ctx
, bset
->eq
, 0, bset
->n_eq
,
666 0, morph
->inv
->n_row
);
667 mat
= isl_mat_product(mat
, isl_mat_copy(morph
->inv
));
670 for (i
= 0; i
< bset
->n_eq
; ++i
) {
671 k
= isl_basic_set_alloc_equality(res
);
674 isl_seq_cpy(res
->eq
[k
], mat
->row
[i
], mat
->n_col
);
675 isl_seq_scale(res
->eq
[k
] + mat
->n_col
, bset
->eq
[i
] + mat
->n_col
,
676 morph
->inv
->row
[0][0], bset
->n_div
);
680 mat
= isl_mat_sub_alloc6(bset
->ctx
, bset
->ineq
, 0, bset
->n_ineq
,
681 0, morph
->inv
->n_row
);
682 mat
= isl_mat_product(mat
, isl_mat_copy(morph
->inv
));
685 for (i
= 0; i
< bset
->n_ineq
; ++i
) {
686 k
= isl_basic_set_alloc_inequality(res
);
689 isl_seq_cpy(res
->ineq
[k
], mat
->row
[i
], mat
->n_col
);
690 isl_seq_scale(res
->ineq
[k
] + mat
->n_col
,
691 bset
->ineq
[i
] + mat
->n_col
,
692 morph
->inv
->row
[0][0], bset
->n_div
);
696 mat
= isl_mat_sub_alloc6(bset
->ctx
, bset
->div
, 0, bset
->n_div
,
697 1, morph
->inv
->n_row
);
698 mat
= isl_mat_product(mat
, isl_mat_copy(morph
->inv
));
701 for (i
= 0; i
< bset
->n_div
; ++i
) {
702 isl_int_mul(res
->div
[i
][0],
703 morph
->inv
->row
[0][0], bset
->div
[i
][0]);
704 isl_seq_cpy(res
->div
[i
] + 1, mat
->row
[i
], mat
->n_col
);
705 isl_seq_scale(res
->div
[i
] + 1 + mat
->n_col
,
706 bset
->div
[i
] + 1 + mat
->n_col
,
707 morph
->inv
->row
[0][0], bset
->n_div
);
711 res
= add_strides(res
, morph
);
713 if (isl_basic_set_is_rational(bset
))
714 res
= isl_basic_set_set_rational(res
);
716 res
= isl_basic_set_simplify(res
);
717 res
= isl_basic_set_finalize(res
);
719 res
= isl_basic_set_intersect(res
, isl_basic_set_copy(morph
->ran
));
721 isl_morph_free(morph
);
722 isl_basic_set_free(bset
);
726 isl_morph_free(morph
);
727 isl_basic_set_free(bset
);
728 isl_basic_set_free(res
);
732 /* Apply the morphism to the set.
734 __isl_give isl_set
*isl_morph_set(__isl_take isl_morph
*morph
,
735 __isl_take isl_set
*set
)
739 if (!morph
|| isl_set_basic_set_check_equal_space(set
, morph
->dom
) < 0)
742 set
= isl_set_cow(set
);
746 isl_space_free(set
->dim
);
747 set
->dim
= isl_space_copy(morph
->ran
->dim
);
751 for (i
= 0; i
< set
->n
; ++i
) {
752 set
->p
[i
] = isl_morph_basic_set(isl_morph_copy(morph
), set
->p
[i
]);
757 isl_morph_free(morph
);
759 ISL_F_CLR(set
, ISL_SET_NORMALIZED
);
764 isl_morph_free(morph
);
768 /* Construct a morphism that first does morph2 and then morph1.
770 __isl_give isl_morph
*isl_morph_compose(__isl_take isl_morph
*morph1
,
771 __isl_take isl_morph
*morph2
)
774 isl_basic_set
*dom
, *ran
;
776 if (!morph1
|| !morph2
)
779 map
= isl_mat_product(isl_mat_copy(morph1
->map
), isl_mat_copy(morph2
->map
));
780 inv
= isl_mat_product(isl_mat_copy(morph2
->inv
), isl_mat_copy(morph1
->inv
));
781 dom
= isl_morph_basic_set(isl_morph_inverse(isl_morph_copy(morph2
)),
782 isl_basic_set_copy(morph1
->dom
));
783 dom
= isl_basic_set_intersect(dom
, isl_basic_set_copy(morph2
->dom
));
784 ran
= isl_morph_basic_set(isl_morph_copy(morph1
),
785 isl_basic_set_copy(morph2
->ran
));
786 ran
= isl_basic_set_intersect(ran
, isl_basic_set_copy(morph1
->ran
));
788 isl_morph_free(morph1
);
789 isl_morph_free(morph2
);
791 return isl_morph_alloc(dom
, ran
, map
, inv
);
793 isl_morph_free(morph1
);
794 isl_morph_free(morph2
);
798 __isl_give isl_morph
*isl_morph_inverse(__isl_take isl_morph
*morph
)
803 morph
= isl_morph_cow(morph
);
808 morph
->dom
= morph
->ran
;
812 morph
->map
= morph
->inv
;
818 /* We detect all the equalities first to avoid implicit equalities
819 * being discovered during the computations. In particular,
820 * the compression on the variables could expose additional stride
821 * constraints on the parameters. This would result in existentially
822 * quantified variables after applying the resulting morph, which
823 * in turn could break invariants of the calling functions.
825 __isl_give isl_morph
*isl_basic_set_full_compression(
826 __isl_keep isl_basic_set
*bset
)
828 isl_morph
*morph
, *morph2
;
830 bset
= isl_basic_set_copy(bset
);
831 bset
= isl_basic_set_detect_equalities(bset
);
833 morph
= isl_basic_set_variable_compression(bset
, isl_dim_param
);
834 bset
= isl_morph_basic_set(isl_morph_copy(morph
), bset
);
836 morph2
= isl_basic_set_parameter_compression(bset
);
837 bset
= isl_morph_basic_set(isl_morph_copy(morph2
), bset
);
839 morph
= isl_morph_compose(morph2
, morph
);
841 morph2
= isl_basic_set_variable_compression(bset
, isl_dim_set
);
842 isl_basic_set_free(bset
);
844 morph
= isl_morph_compose(morph2
, morph
);
849 __isl_give isl_vec
*isl_morph_vec(__isl_take isl_morph
*morph
,
850 __isl_take isl_vec
*vec
)
855 vec
= isl_mat_vec_product(isl_mat_copy(morph
->map
), vec
);
857 isl_morph_free(morph
);
860 isl_morph_free(morph
);