#include <isl/blk.h>
#include "isl_space_private.h"
#include "isl_equalities.h"
-#include <isl_list_private.h>
#include <isl/lp.h>
#include <isl/seq.h>
#include <isl/set.h>
res = isl_basic_map_set_rational(res);
if (isl_basic_map_plain_is_empty(bmap)) {
isl_basic_map_free(bmap);
+ free(dim_map);
return isl_basic_map_set_to_empty(res);
}
res = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map);
return bmap;
}
-/* Add a constraint imposing that the value of the first dimension is
+/* Construct a basic map where the value of the first dimension is
* greater than that of the second.
*/
-__isl_give isl_map *isl_map_order_gt(__isl_take isl_map *map,
+static __isl_give isl_basic_map *greator(__isl_take isl_space *space,
enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
{
isl_basic_map *bmap = NULL;
int i;
- if (!map)
+ if (!space)
return NULL;
- if (pos1 >= isl_map_dim(map, type1))
- isl_die(map->ctx, isl_error_invalid,
+ if (pos1 >= isl_space_dim(space, type1))
+ isl_die(isl_space_get_ctx(space), isl_error_invalid,
"index out of bounds", goto error);
- if (pos2 >= isl_map_dim(map, type2))
- isl_die(map->ctx, isl_error_invalid,
+ if (pos2 >= isl_space_dim(space, type2))
+ isl_die(isl_space_get_ctx(space), isl_error_invalid,
"index out of bounds", goto error);
- if (type1 == type2 && pos1 == pos2) {
- isl_space *space = isl_map_get_space(map);
- isl_map_free(map);
- return isl_map_empty(space);
- }
+ if (type1 == type2 && pos1 == pos2)
+ return isl_basic_map_empty(space);
- bmap = isl_basic_map_alloc_space(isl_map_get_space(map), 0, 0, 1);
+ bmap = isl_basic_map_alloc_space(space, 0, 0, 1);
i = isl_basic_map_alloc_inequality(bmap);
if (i < 0)
goto error;
isl_int_set_si(bmap->ineq[i][0], -1);
bmap = isl_basic_map_finalize(bmap);
- map = isl_map_intersect(map, isl_map_from_basic_map(bmap));
-
- return map;
+ return bmap;
error:
+ isl_space_free(space);
isl_basic_map_free(bmap);
- isl_map_free(map);
return NULL;
}
/* Add a constraint imposing that the value of the first dimension is
+ * greater than that of the second.
+ */
+__isl_give isl_basic_map *isl_basic_map_order_gt(__isl_take isl_basic_map *bmap,
+ enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
+{
+ isl_basic_map *gt;
+
+ gt = greator(isl_basic_map_get_space(bmap), type1, pos1, type2, pos2);
+
+ bmap = isl_basic_map_intersect(bmap, gt);
+
+ return bmap;
+}
+
+/* Add a constraint imposing that the value of the first dimension is
+ * greater than that of the second.
+ */
+__isl_give isl_map *isl_map_order_gt(__isl_take isl_map *map,
+ enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
+{
+ isl_basic_map *bmap;
+
+ bmap = greator(isl_map_get_space(map), type1, pos1, type2, pos2);
+
+ map = isl_map_intersect(map, isl_map_from_basic_map(bmap));
+
+ return map;
+}
+
+/* Add a constraint imposing that the value of the first dimension is
* smaller than that of the second.
*/
__isl_give isl_map *isl_map_order_lt(__isl_take isl_map *map,
return NULL;
}
-/* Check if the range of "ma" is compatible with "space".
+/* Check if the range of "ma" is compatible with the domain or range
+ * (depending on "type") of "bmap".
* Return -1 if anything is wrong.
*/
-static int check_space_compatible_range_multi_aff(
- __isl_keep isl_space *space, __isl_keep isl_multi_aff *ma)
+static int check_basic_map_compatible_range_multi_aff(
+ __isl_keep isl_basic_map *bmap, enum isl_dim_type type,
+ __isl_keep isl_multi_aff *ma)
{
int m;
isl_space *ma_space;
ma_space = isl_multi_aff_get_space(ma);
- m = isl_space_is_range_internal(space, ma_space);
+ m = isl_space_tuple_match(bmap->dim, type, ma_space, isl_dim_out);
isl_space_free(ma_space);
if (m >= 0 && !m)
- isl_die(isl_space_get_ctx(space), isl_error_invalid,
+ isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
"spaces don't match", return -1);
return m;
}
-/* Check if the range of "ma" is compatible with "bset".
- * Return -1 if anything is wrong.
+/* Copy the divs from "ma" to "bmap", adding zeros for the "n_before"
+ * coefficients before the transformed range of dimensions,
+ * the "n_after" coefficients after the transformed range of dimensions
+ * and the coefficients of the other divs in "bmap".
*/
-static int check_basic_set_compatible_range_multi_aff(
- __isl_keep isl_basic_set *bset, __isl_keep isl_multi_aff *ma)
-{
- return check_space_compatible_range_multi_aff(bset->dim, ma);
-}
-
-/* Copy the divs from "ma" to "bset", adding zeros for the coefficients
- * of the other divs in "bset".
- */
-static int set_ma_divs(__isl_keep isl_basic_set *bset,
- __isl_keep isl_multi_aff *ma, int n_div)
+static int set_ma_divs(__isl_keep isl_basic_map *bmap,
+ __isl_keep isl_multi_aff *ma, int n_before, int n_after, int n_div)
{
int i;
+ int n_param;
+ int n_set;
isl_local_space *ls;
if (n_div == 0)
if (!ls)
return -1;
+ n_param = isl_local_space_dim(ls, isl_dim_param);
+ n_set = isl_local_space_dim(ls, isl_dim_set);
for (i = 0; i < n_div; ++i) {
- isl_seq_cpy(bset->div[i], ls->div->row[i], ls->div->n_col);
- isl_seq_clr(bset->div[i] + ls->div->n_col, bset->n_div - n_div);
- if (isl_basic_set_add_div_constraints(bset, i) < 0)
+ int o_bmap = 0, o_ls = 0;
+
+ isl_seq_cpy(bmap->div[i], ls->div->row[i], 1 + 1 + n_param);
+ o_bmap += 1 + 1 + n_param;
+ o_ls += 1 + 1 + n_param;
+ isl_seq_clr(bmap->div[i] + o_bmap, n_before);
+ o_bmap += n_before;
+ isl_seq_cpy(bmap->div[i] + o_bmap,
+ ls->div->row[i] + o_ls, n_set);
+ o_bmap += n_set;
+ o_ls += n_set;
+ isl_seq_clr(bmap->div[i] + o_bmap, n_after);
+ o_bmap += n_after;
+ isl_seq_cpy(bmap->div[i] + o_bmap,
+ ls->div->row[i] + o_ls, n_div);
+ o_bmap += n_div;
+ o_ls += n_div;
+ isl_seq_clr(bmap->div[i] + o_bmap, bmap->n_div - n_div);
+ if (isl_basic_set_add_div_constraints(bmap, i) < 0)
goto error;
}
*
* x_i = (f_i y + h_i)/m_i
*
- * with m_i different from one, add a constraint to "bset"
+ * with m_i different from one, add a constraint to "bmap"
* of the form
*
* f_i y + h_i = m_i alpha_i
*
* with alpha_i an additional existentially quantified variable.
*/
-static __isl_give isl_basic_set *add_ma_strides(
- __isl_take isl_basic_set *bset, __isl_keep isl_multi_aff *ma)
+static __isl_give isl_basic_map *add_ma_strides(
+ __isl_take isl_basic_map *bmap, __isl_keep isl_multi_aff *ma,
+ int n_before, int n_after)
{
int i, k;
int div;
int total;
+ int n_param;
+ int n_in;
+ int n_div;
- total = isl_basic_set_total_dim(bset);
+ total = isl_basic_map_total_dim(bmap);
+ n_param = isl_multi_aff_dim(ma, isl_dim_param);
+ n_in = isl_multi_aff_dim(ma, isl_dim_in);
+ n_div = isl_multi_aff_dim(ma, isl_dim_div);
for (i = 0; i < ma->n; ++i) {
- int len;
+ int o_bmap = 0, o_ma = 1;
if (isl_int_is_one(ma->p[i]->v->el[0]))
continue;
- div = isl_basic_set_alloc_div(bset);
- k = isl_basic_set_alloc_equality(bset);
+ div = isl_basic_map_alloc_div(bmap);
+ k = isl_basic_map_alloc_equality(bmap);
if (div < 0 || k < 0)
goto error;
- isl_int_set_si(bset->div[div][0], 0);
- len = ma->p[i]->v->size;
- isl_seq_cpy(bset->eq[k], ma->p[i]->v->el + 1, len - 1);
- isl_seq_clr(bset->eq[k] + len - 1, 1 + total - (len - 1));
- isl_int_neg(bset->eq[k][1 + total], ma->p[i]->v->el[0]);
+ isl_int_set_si(bmap->div[div][0], 0);
+ isl_seq_cpy(bmap->eq[k] + o_bmap,
+ ma->p[i]->v->el + o_ma, 1 + n_param);
+ o_bmap += 1 + n_param;
+ o_ma += 1 + n_param;
+ isl_seq_clr(bmap->eq[k] + o_bmap, n_before);
+ o_bmap += n_before;
+ isl_seq_cpy(bmap->eq[k] + o_bmap,
+ ma->p[i]->v->el + o_ma, n_in);
+ o_bmap += n_in;
+ o_ma += n_in;
+ isl_seq_clr(bmap->eq[k] + o_bmap, n_after);
+ o_bmap += n_after;
+ isl_seq_cpy(bmap->eq[k] + o_bmap,
+ ma->p[i]->v->el + o_ma, n_div);
+ o_bmap += n_div;
+ o_ma += n_div;
+ isl_seq_clr(bmap->eq[k] + o_bmap, 1 + total - o_bmap);
+ isl_int_neg(bmap->eq[k][1 + total], ma->p[i]->v->el[0]);
total++;
}
- return bset;
+ return bmap;
error:
- isl_basic_set_free(bset);
+ isl_basic_map_free(bmap);
return NULL;
}
-/* Compute the preimage of "bset" under the function represented by "ma".
- * In other words, plug in "ma" in "bset". The result is a basic set
- * that lives in the domain space of "ma".
+/* Replace the domain or range space (depending on "type) of "space" by "set".
+ */
+static __isl_give isl_space *isl_space_set(__isl_take isl_space *space,
+ enum isl_dim_type type, __isl_take isl_space *set)
+{
+ if (type == isl_dim_in) {
+ space = isl_space_range(space);
+ space = isl_space_map_from_domain_and_range(set, space);
+ } else {
+ space = isl_space_domain(space);
+ space = isl_space_map_from_domain_and_range(space, set);
+ }
+
+ return space;
+}
+
+/* Compute the preimage of the domain or range (depending on "type")
+ * of "bmap" under the function represented by "ma".
+ * In other words, plug in "ma" in the domain or range of "bmap".
+ * The result is a basic map that lives in the same space as "bmap"
+ * except that the domain or range has been replaced by
+ * the domain space of "ma".
*
- * If bset is represented by
+ * If bmap is represented by
*
- * A(p) + B x + C(divs) >= 0
+ * A(p) + S u + B x + T v + C(divs) >= 0,
*
+ * where u and x are input and output dimensions if type == isl_dim_out
+ * while x and v are input and output dimensions if type == isl_dim_in,
* and ma is represented by
*
* x = D(p) + F(y) + G(divs')
*
* then the result is
*
- * A(p) + B D(p) + B F(y) + B G(divs') + C(divs) >= 0
+ * A(p) + B D(p) + S u + B F(y) + T v + B G(divs') + C(divs) >= 0
*
* The divs in the input set are similarly adjusted.
* In particular
*
- * floor((a_i(p) + b_i x + c_i(divs))/n_i)
+ * floor((a_i(p) + s u + b_i x + t v + c_i(divs))/n_i)
*
* becomes
*
- * floor((a_i(p) + b_i D(p) + b_i F(y) + B_i G(divs') + c_i(divs))/n_i)
+ * floor((a_i(p) + b_i D(p) + s u + b_i F(y) + t v +
+ * B_i G(divs') + c_i(divs))/n_i)
*
- * If bset is not a rational set and if F(y) involves any denominators
+ * If bmap is not a rational map and if F(y) involves any denominators
*
* x_i = (f_i y + h_i)/m_i
*
- * the additional constraints are added to ensure that we only
+ * then additional constraints are added to ensure that we only
* map back integer points. That is we enforce
*
* f_i y + h_i = m_i alpha_i
* with alpha_i an additional existentially quantified variable.
*
* We first copy over the divs from "ma".
- * Then we add the modified constraints and divs from "bset".
+ * Then we add the modified constraints and divs from "bmap".
* Finally, we add the stride constraints, if needed.
*/
-__isl_give isl_basic_set *isl_basic_set_preimage_multi_aff(
- __isl_take isl_basic_set *bset, __isl_take isl_multi_aff *ma)
+__isl_give isl_basic_map *isl_basic_map_preimage_multi_aff(
+ __isl_take isl_basic_map *bmap, enum isl_dim_type type,
+ __isl_take isl_multi_aff *ma)
{
int i, k;
isl_space *space;
- isl_basic_set *res = NULL;
- int n_div_bset, n_div_ma;
+ isl_basic_map *res = NULL;
+ int n_before, n_after, n_div_bmap, n_div_ma;
isl_int f, c1, c2, g;
int rational, strides;
isl_int_init(g);
ma = isl_multi_aff_align_divs(ma);
- if (!bset || !ma)
+ if (!bmap || !ma)
goto error;
- if (check_basic_set_compatible_range_multi_aff(bset, ma) < 0)
+ if (check_basic_map_compatible_range_multi_aff(bmap, type, ma) < 0)
goto error;
- n_div_bset = isl_basic_set_dim(bset, isl_dim_div);
+ if (type == isl_dim_in) {
+ n_before = 0;
+ n_after = isl_basic_map_dim(bmap, isl_dim_out);
+ } else {
+ n_before = isl_basic_map_dim(bmap, isl_dim_in);
+ n_after = 0;
+ }
+ n_div_bmap = isl_basic_map_dim(bmap, isl_dim_div);
n_div_ma = ma->n ? isl_aff_dim(ma->p[0], isl_dim_div) : 0;
- space = isl_space_domain(isl_multi_aff_get_space(ma));
- rational = isl_basic_set_is_rational(bset);
+ space = isl_multi_aff_get_domain_space(ma);
+ space = isl_space_set(isl_basic_map_get_space(bmap), type, space);
+ rational = isl_basic_map_is_rational(bmap);
strides = rational ? 0 : multi_aff_strides(ma);
- res = isl_basic_set_alloc_space(space, n_div_ma + n_div_bset + strides,
- bset->n_eq + strides, bset->n_ineq + 2 * n_div_ma);
+ res = isl_basic_map_alloc_space(space, n_div_ma + n_div_bmap + strides,
+ bmap->n_eq + strides, bmap->n_ineq + 2 * n_div_ma);
if (rational)
- res = isl_basic_set_set_rational(res);
+ res = isl_basic_map_set_rational(res);
- for (i = 0; i < n_div_ma + n_div_bset; ++i)
- if (isl_basic_set_alloc_div(res) < 0)
+ for (i = 0; i < n_div_ma + n_div_bmap; ++i)
+ if (isl_basic_map_alloc_div(res) < 0)
goto error;
- if (set_ma_divs(res, ma, n_div_ma) < 0)
+ if (set_ma_divs(res, ma, n_before, n_after, n_div_ma) < 0)
goto error;
- for (i = 0; i < bset->n_eq; ++i) {
- k = isl_basic_set_alloc_equality(res);
+ for (i = 0; i < bmap->n_eq; ++i) {
+ k = isl_basic_map_alloc_equality(res);
if (k < 0)
goto error;
- isl_seq_preimage(res->eq[k], bset->eq[i], ma, n_div_ma,
- n_div_bset, f, c1, c2, g, 0);
+ isl_seq_preimage(res->eq[k], bmap->eq[i], ma, n_before,
+ n_after, n_div_ma, n_div_bmap, f, c1, c2, g, 0);
}
- for (i = 0; i < bset->n_ineq; ++i) {
- k = isl_basic_set_alloc_inequality(res);
+ for (i = 0; i < bmap->n_ineq; ++i) {
+ k = isl_basic_map_alloc_inequality(res);
if (k < 0)
goto error;
- isl_seq_preimage(res->ineq[k], bset->ineq[i], ma, n_div_ma,
- n_div_bset, f, c1, c2, g, 0);
+ isl_seq_preimage(res->ineq[k], bmap->ineq[i], ma, n_before,
+ n_after, n_div_ma, n_div_bmap, f, c1, c2, g, 0);
}
- for (i = 0; i < bset->n_div; ++i) {
- if (isl_int_is_zero(bset->div[i][0])) {
+ for (i = 0; i < bmap->n_div; ++i) {
+ if (isl_int_is_zero(bmap->div[i][0])) {
isl_int_set_si(res->div[n_div_ma + i][0], 0);
continue;
}
- isl_seq_preimage(res->div[n_div_ma + i], bset->div[i],
- ma, n_div_ma, n_div_bset, f, c1, c2, g, 1);
+ isl_seq_preimage(res->div[n_div_ma + i], bmap->div[i], ma,
+ n_before, n_after, n_div_ma, n_div_bmap,
+ f, c1, c2, g, 1);
}
if (strides)
- res = add_ma_strides(res, ma);
+ res = add_ma_strides(res, ma, n_before, n_after);
isl_int_clear(f);
isl_int_clear(c1);
isl_int_clear(c2);
isl_int_clear(g);
- isl_basic_set_free(bset);
+ isl_basic_map_free(bmap);
isl_multi_aff_free(ma);
res = isl_basic_set_simplify(res);
- return isl_basic_set_finalize(res);
+ return isl_basic_map_finalize(res);
error:
isl_int_clear(f);
isl_int_clear(c1);
isl_int_clear(c2);
isl_int_clear(g);
- isl_basic_set_free(bset);
+ isl_basic_map_free(bmap);
isl_multi_aff_free(ma);
- isl_basic_set_free(res);
+ isl_basic_map_free(res);
return NULL;
}
-/* Check if the range of "ma" is compatible with "set".
+/* Compute the preimage of "bset" under the function represented by "ma".
+ * In other words, plug in "ma" in "bset". The result is a basic set
+ * that lives in the domain space of "ma".
+ */
+__isl_give isl_basic_set *isl_basic_set_preimage_multi_aff(
+ __isl_take isl_basic_set *bset, __isl_take isl_multi_aff *ma)
+{
+ return isl_basic_map_preimage_multi_aff(bset, isl_dim_set, ma);
+}
+
+/* Check if the range of "ma" is compatible with the domain or range
+ * (depending on "type") of "map".
* Return -1 if anything is wrong.
*/
-static int check_set_compatible_range_multi_aff(
- __isl_keep isl_set *set, __isl_keep isl_multi_aff *ma)
+static int check_map_compatible_range_multi_aff(
+ __isl_keep isl_map *map, enum isl_dim_type type,
+ __isl_keep isl_multi_aff *ma)
{
- return check_space_compatible_range_multi_aff(set->dim, ma);
+ int m;
+ isl_space *ma_space;
+
+ ma_space = isl_multi_aff_get_space(ma);
+ m = isl_space_tuple_match(map->dim, type, ma_space, isl_dim_out);
+ isl_space_free(ma_space);
+ if (m >= 0 && !m)
+ isl_die(isl_map_get_ctx(map), isl_error_invalid,
+ "spaces don't match", return -1);
+ return m;
}
-/* Compute the preimage of "set" under the function represented by "ma".
- * In other words, plug in "ma" in "set. The result is a set
- * that lives in the domain space of "ma".
+/* Compute the preimage of the domain or range (depending on "type")
+ * of "map" under the function represented by "ma".
+ * In other words, plug in "ma" in the domain or range of "map".
+ * The result is a map that lives in the same space as "map"
+ * except that the domain or range has been replaced by
+ * the domain space of "ma".
+ *
+ * The parameters are assumed to have been aligned.
*/
-static __isl_give isl_set *set_preimage_multi_aff(__isl_take isl_set *set,
- __isl_take isl_multi_aff *ma)
+static __isl_give isl_map *map_preimage_multi_aff(__isl_take isl_map *map,
+ enum isl_dim_type type, __isl_take isl_multi_aff *ma)
{
int i;
+ isl_space *space;
- set = isl_set_cow(set);
+ map = isl_map_cow(map);
ma = isl_multi_aff_align_divs(ma);
- if (!set || !ma)
+ if (!map || !ma)
goto error;
- if (check_set_compatible_range_multi_aff(set, ma) < 0)
+ if (check_map_compatible_range_multi_aff(map, type, ma) < 0)
goto error;
- for (i = 0; i < set->n; ++i) {
- set->p[i] = isl_basic_set_preimage_multi_aff(set->p[i],
+ for (i = 0; i < map->n; ++i) {
+ map->p[i] = isl_basic_map_preimage_multi_aff(map->p[i], type,
isl_multi_aff_copy(ma));
- if (!set->p[i])
+ if (!map->p[i])
goto error;
}
- isl_space_free(set->dim);
- set->dim = isl_multi_aff_get_domain_space(ma);
- if (!set->dim)
+ space = isl_multi_aff_get_domain_space(ma);
+ space = isl_space_set(isl_map_get_space(map), type, space);
+
+ isl_space_free(map->dim);
+ map->dim = space;
+ if (!map->dim)
goto error;
isl_multi_aff_free(ma);
- if (set->n > 1)
- ISL_F_CLR(set, ISL_MAP_DISJOINT);
- ISL_F_CLR(set, ISL_SET_NORMALIZED);
- return set;
+ if (map->n > 1)
+ ISL_F_CLR(map, ISL_MAP_DISJOINT);
+ ISL_F_CLR(map, ISL_SET_NORMALIZED);
+ return map;
error:
isl_multi_aff_free(ma);
- isl_set_free(set);
+ isl_map_free(map);
return NULL;
}
-__isl_give isl_set *isl_set_preimage_multi_aff(__isl_take isl_set *set,
- __isl_take isl_multi_aff *ma)
+/* Compute the preimage of the domain or range (depending on "type")
+ * of "map" under the function represented by "ma".
+ * In other words, plug in "ma" in the domain or range of "map".
+ * The result is a map that lives in the same space as "map"
+ * except that the domain or range has been replaced by
+ * the domain space of "ma".
+ */
+__isl_give isl_map *isl_map_preimage_multi_aff(__isl_take isl_map *map,
+ enum isl_dim_type type, __isl_take isl_multi_aff *ma)
{
- if (!set || !ma)
+ if (!map || !ma)
goto error;
- if (isl_space_match(set->dim, isl_dim_param, ma->space, isl_dim_param))
- return set_preimage_multi_aff(set, ma);
+ if (isl_space_match(map->dim, isl_dim_param, ma->space, isl_dim_param))
+ return map_preimage_multi_aff(map, type, ma);
- if (!isl_space_has_named_params(set->dim) ||
+ if (!isl_space_has_named_params(map->dim) ||
!isl_space_has_named_params(ma->space))
- isl_die(set->ctx, isl_error_invalid,
+ isl_die(map->ctx, isl_error_invalid,
"unaligned unnamed parameters", goto error);
- set = isl_set_align_params(set, isl_multi_aff_get_space(ma));
- ma = isl_multi_aff_align_params(ma, isl_set_get_space(set));
+ map = isl_map_align_params(map, isl_multi_aff_get_space(ma));
+ ma = isl_multi_aff_align_params(ma, isl_map_get_space(map));
- return set_preimage_multi_aff(set, ma);
+ return map_preimage_multi_aff(map, type, ma);
error:
isl_multi_aff_free(ma);
- return isl_set_free(set);
+ return isl_map_free(map);
+}
+
+/* Compute the preimage of "set" under the function represented by "ma".
+ * In other words, plug in "ma" "set". The result is a set
+ * that lives in the domain space of "ma".
+ */
+__isl_give isl_set *isl_set_preimage_multi_aff(__isl_take isl_set *set,
+ __isl_take isl_multi_aff *ma)
+{
+ return isl_map_preimage_multi_aff(set, isl_dim_set, ma);
+}
+
+/* Compute the preimage of the domain of "map" under the function
+ * represented by "ma".
+ * In other words, plug in "ma" in the domain of "map".
+ * The result is a map that lives in the same space as "map"
+ * except that the domain has been replaced by the domain space of "ma".
+ */
+__isl_give isl_map *isl_map_preimage_domain_multi_aff(__isl_take isl_map *map,
+ __isl_take isl_multi_aff *ma)
+{
+ return isl_map_preimage_multi_aff(map, isl_dim_in, ma);
}
/* Compute the preimage of "set" under the function represented by "pma".
projects / platform / upstream / isl.git / blobdiff