#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>
#include <isl_aff_private.h>
#include <isl_options_private.h>
#include <isl_morph.h>
+#include <isl_val_private.h>
static unsigned n(__isl_keep isl_space *dim, enum isl_dim_type type)
{
return div;
}
+/* Extract the divs in "bset" as a matrix.
+ */
+__isl_give isl_mat *isl_basic_set_get_divs(__isl_keep isl_basic_set *bset)
+{
+ return isl_basic_map_get_divs(bset);
+}
+
__isl_give isl_local_space *isl_basic_map_get_local_space(
__isl_keep isl_basic_map *bmap)
{
return NULL;
}
+/* Given a map A -> f(A) and an integer d, construct a map
+ * A -> floor(f(A)/d).
+ */
+__isl_give isl_map *isl_map_floordiv_val(__isl_take isl_map *map,
+ __isl_take isl_val *d)
+{
+ if (!map || !d)
+ goto error;
+ if (!isl_val_is_int(d))
+ isl_die(isl_val_get_ctx(d), isl_error_invalid,
+ "expecting integer denominator", goto error);
+ map = isl_map_floordiv(map, d->n);
+ isl_val_free(d);
+ return map;
+error:
+ isl_map_free(map);
+ isl_val_free(d);
+ return NULL;
+}
+
static struct isl_basic_map *var_equal(struct isl_basic_map *bmap, unsigned pos)
{
int i;
return NULL;
}
+/* Fix the value of the variable at position "pos" of type "type" of "bmap"
+ * to be equal to "v".
+ */
+__isl_give isl_basic_map *isl_basic_map_fix_val(__isl_take isl_basic_map *bmap,
+ enum isl_dim_type type, unsigned pos, __isl_take isl_val *v)
+{
+ if (!bmap || !v)
+ goto error;
+ if (!isl_val_is_int(v))
+ isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
+ "expecting integer value", goto error);
+ if (pos >= isl_basic_map_dim(bmap, type))
+ isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
+ "index out of bounds", goto error);
+ pos += isl_basic_map_offset(bmap, type);
+ bmap = isl_basic_map_fix_pos(bmap, pos, v->n);
+ isl_val_free(v);
+ return bmap;
+error:
+ isl_basic_map_free(bmap);
+ isl_val_free(v);
+ return NULL;
+}
+
+/* Fix the value of the variable at position "pos" of type "type" of "bset"
+ * to be equal to "v".
+ */
+__isl_give isl_basic_set *isl_basic_set_fix_val(__isl_take isl_basic_set *bset,
+ enum isl_dim_type type, unsigned pos, __isl_take isl_val *v)
+{
+ return isl_basic_map_fix_val(bset, type, pos, v);
+}
+
struct isl_basic_set *isl_basic_set_fix_si(struct isl_basic_set *bset,
enum isl_dim_type type, unsigned pos, int value)
{
return (struct isl_set *)isl_map_fix((isl_map *)set, type, pos, value);
}
+/* Fix the value of the variable at position "pos" of type "type" of "map"
+ * to be equal to "v".
+ */
+__isl_give isl_map *isl_map_fix_val(__isl_take isl_map *map,
+ enum isl_dim_type type, unsigned pos, __isl_take isl_val *v)
+{
+ int i;
+
+ map = isl_map_cow(map);
+ if (!map || !v)
+ goto error;
+
+ if (!isl_val_is_int(v))
+ isl_die(isl_map_get_ctx(map), isl_error_invalid,
+ "expecting integer value", goto error);
+ if (pos >= isl_map_dim(map, type))
+ isl_die(isl_map_get_ctx(map), isl_error_invalid,
+ "index out of bounds", goto error);
+ for (i = map->n - 1; i >= 0; --i) {
+ map->p[i] = isl_basic_map_fix_val(map->p[i], type, pos,
+ isl_val_copy(v));
+ if (remove_if_empty(map, i) < 0)
+ goto error;
+ }
+ ISL_F_CLR(map, ISL_MAP_NORMALIZED);
+ isl_val_free(v);
+ return map;
+error:
+ isl_map_free(map);
+ isl_val_free(v);
+ return NULL;
+}
+
+/* Fix the value of the variable at position "pos" of type "type" of "set"
+ * to be equal to "v".
+ */
+__isl_give isl_set *isl_set_fix_val(__isl_take isl_set *set,
+ enum isl_dim_type type, unsigned pos, __isl_take isl_val *v)
+{
+ return isl_map_fix_val(set, type, pos, v);
+}
+
struct isl_map *isl_map_fix_input_si(struct isl_map *map,
unsigned input, int value)
{
return isl_map_upper_bound(set, type, pos, value);
}
+/* Force the values of the variable at position "pos" of type "type" of "set"
+ * to be no smaller than "value".
+ */
+__isl_give isl_set *isl_set_lower_bound_val(__isl_take isl_set *set,
+ enum isl_dim_type type, unsigned pos, __isl_take isl_val *value)
+{
+ if (!value)
+ goto error;
+ if (!isl_val_is_int(value))
+ isl_die(isl_set_get_ctx(set), isl_error_invalid,
+ "expecting integer value", goto error);
+ set = isl_set_lower_bound(set, type, pos, value->n);
+ isl_val_free(value);
+ return set;
+error:
+ isl_val_free(value);
+ isl_set_free(set);
+ return NULL;
+}
+
+/* Force the values of the variable at position "pos" of type "type" of "set"
+ * to be no greater than "value".
+ */
+__isl_give isl_set *isl_set_upper_bound_val(__isl_take isl_set *set,
+ enum isl_dim_type type, unsigned pos, __isl_take isl_val *value)
+{
+ if (!value)
+ goto error;
+ if (!isl_val_is_int(value))
+ isl_die(isl_set_get_ctx(set), isl_error_invalid,
+ "expecting integer value", goto error);
+ set = isl_set_upper_bound(set, type, pos, value->n);
+ isl_val_free(value);
+ return set;
+error:
+ isl_val_free(value);
+ isl_set_free(set);
+ return NULL;
+}
+
struct isl_set *isl_set_lower_bound_dim(struct isl_set *set, unsigned dim,
isl_int value)
{
isl_basic_map_offset(bmap, type) - 1 + pos, val);
}
+/* If "bmap" obviously lies on a hyperplane where the given dimension
+ * has a fixed value, then return that value.
+ * Otherwise return NaN.
+ */
+__isl_give isl_val *isl_basic_map_plain_get_val_if_fixed(
+ __isl_keep isl_basic_map *bmap,
+ enum isl_dim_type type, unsigned pos)
+{
+ isl_ctx *ctx;
+ isl_val *v;
+ int fixed;
+
+ if (!bmap)
+ return NULL;
+ ctx = isl_basic_map_get_ctx(bmap);
+ v = isl_val_alloc(ctx);
+ if (!v)
+ return NULL;
+ fixed = isl_basic_map_plain_is_fixed(bmap, type, pos, &v->n);
+ if (fixed < 0)
+ return isl_val_free(v);
+ if (fixed) {
+ isl_int_set_si(v->d, 1);
+ return v;
+ }
+ isl_val_free(v);
+ return isl_val_nan(ctx);
+}
+
int isl_map_plain_is_fixed(__isl_keep isl_map *map,
enum isl_dim_type type, unsigned pos, isl_int *val)
{
map_offset(map, type) - 1 + pos, val);
}
+/* If "map" obviously lies on a hyperplane where the given dimension
+ * has a fixed value, then return that value.
+ * Otherwise return NaN.
+ */
+__isl_give isl_val *isl_map_plain_get_val_if_fixed(__isl_keep isl_map *map,
+ enum isl_dim_type type, unsigned pos)
+{
+ isl_ctx *ctx;
+ isl_val *v;
+ int fixed;
+
+ if (!map)
+ return NULL;
+ ctx = isl_map_get_ctx(map);
+ v = isl_val_alloc(ctx);
+ if (!v)
+ return NULL;
+ fixed = isl_map_plain_is_fixed(map, type, pos, &v->n);
+ if (fixed < 0)
+ return isl_val_free(v);
+ if (fixed) {
+ isl_int_set_si(v->d, 1);
+ return v;
+ }
+ isl_val_free(v);
+ return isl_val_nan(ctx);
+}
+
+/* If "set" obviously lies on a hyperplane where the given dimension
+ * has a fixed value, then return that value.
+ * Otherwise return NaN.
+ */
+__isl_give isl_val *isl_set_plain_get_val_if_fixed(__isl_keep isl_set *set,
+ enum isl_dim_type type, unsigned pos)
+{
+ return isl_map_plain_get_val_if_fixed(set, type, pos);
+}
+
int isl_set_plain_is_fixed(__isl_keep isl_set *set,
enum isl_dim_type type, unsigned pos, isl_int *val)
{
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".
- * 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)
-{
- int m;
- isl_space *ma_space;
-
- ma_space = isl_multi_aff_get_space(ma);
- m = isl_space_is_range_internal(space, ma_space);
- isl_space_free(ma_space);
- if (m >= 0 && !m)
- isl_die(isl_space_get_ctx(space), isl_error_invalid,
- "spaces don't match", return -1);
- return m;
-}
-
/* Check if the range of "ma" is compatible with the domain or range
* (depending on "type") of "bmap".
* Return -1 if anything is wrong.
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));
+ 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);
return isl_basic_map_preimage_multi_aff(bset, isl_dim_set, ma);
}
-/* Check if the range of "ma" is compatible with "set".
+/* 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