#include <isl_dim_map.h>
#include <isl_local_space_private.h>
#include <isl_aff_private.h>
+#include <isl_options_private.h>
static unsigned n(__isl_keep isl_space *dim, enum isl_dim_type type)
{
__isl_take isl_basic_map *bmap,
enum isl_dim_type type, unsigned pos, const char *s)
{
+ bmap = isl_basic_map_cow(bmap);
if (!bmap)
return NULL;
bmap->dim = isl_space_set_dim_name(bmap->dim, type, pos, s);
{
int i;
+ map = isl_map_cow(map);
if (!map)
return NULL;
return (isl_set *)isl_map_set_dim_name((isl_map *)set, type, pos, s);
}
+int isl_basic_map_has_dim_id(__isl_keep isl_basic_map *bmap,
+ enum isl_dim_type type, unsigned pos)
+{
+ return bmap ? isl_space_has_dim_id(bmap->dim, type, pos) : -1;
+}
+
int isl_map_has_dim_id(__isl_keep isl_map *map,
enum isl_dim_type type, unsigned pos)
{
return isl_map_find_dim_by_id(set, type, id);
}
+int isl_map_find_dim_by_name(__isl_keep isl_map *map, enum isl_dim_type type,
+ const char *name)
+{
+ if (!map)
+ return -1;
+ return isl_space_find_dim_by_name(map->dim, type, name);
+}
+
+int isl_set_find_dim_by_name(__isl_keep isl_set *set, enum isl_dim_type type,
+ const char *name)
+{
+ return isl_map_find_dim_by_name(set, type, name);
+}
+
int isl_basic_map_is_rational(__isl_keep isl_basic_map *bmap)
{
if (!bmap)
return isl_basic_map_is_rational(bset);
}
+/* Is this basic set a parameter domain?
+ */
+int isl_basic_set_is_params(__isl_keep isl_basic_set *bset)
+{
+ if (!bset)
+ return -1;
+ return isl_space_is_params(bset->dim);
+}
+
+/* Is this set a parameter domain?
+ */
+int isl_set_is_params(__isl_keep isl_set *set)
+{
+ if (!set)
+ return -1;
+ return isl_space_is_params(set->dim);
+}
+
+/* Is this map actually a parameter domain?
+ * Users should never call this function. Outside of isl,
+ * a map can never be a parameter domain.
+ */
+int isl_map_is_params(__isl_keep isl_map *map)
+{
+ if (!map)
+ return -1;
+ return isl_space_is_params(map->dim);
+}
+
static struct isl_basic_map *basic_map_init(struct isl_ctx *ctx,
struct isl_basic_map *bmap, unsigned extra,
unsigned n_eq, unsigned n_ineq)
return NULL;
}
-static int align_params_map_map_and_test(__isl_keep isl_map *map1,
+int isl_map_align_params_map_map_and_test(__isl_keep isl_map *map1,
__isl_keep isl_map *map2,
int (*fn)(__isl_keep isl_map *map1, __isl_keep isl_map *map2))
{
map = isl_map_cow(map);
if (!map)
return NULL;
- isl_assert(map->ctx, first + n <= isl_map_dim(map, type), goto error);
- first += pos(map->dim, type) - 1;
-
+
for (i = 0; i < map->n; ++i) {
- map->p[i] = isl_basic_map_eliminate_vars(map->p[i], first, n);
+ map->p[i] = isl_basic_map_eliminate(map->p[i], type, first, n);
if (!map->p[i])
goto error;
}
type, first, n);
}
+/* Does the desciption of "bmap" depend on the specified dimensions?
+ * We also check whether the dimensions appear in any of the div definitions.
+ * In principle there is no need for this check. If the dimensions appear
+ * in a div definition, they also appear in the defining constraints of that
+ * div.
+ */
int isl_basic_map_involves_dims(__isl_keep isl_basic_map *bmap,
enum isl_dim_type type, unsigned first, unsigned n)
{
for (i = 0; i < bmap->n_ineq; ++i)
if (isl_seq_first_non_zero(bmap->ineq[i] + first, n) >= 0)
return 1;
+ for (i = 0; i < bmap->n_div; ++i) {
+ if (isl_int_is_zero(bmap->div[i][0]))
+ continue;
+ if (isl_seq_first_non_zero(bmap->div[i] + 1 + first, n) >= 0)
+ return 1;
+ }
return 0;
}
for (i = 0; i < map->n; ++i) {
int involves = isl_basic_map_involves_dims(map->p[i],
type, first, n);
- if (involves < 0 || !involves)
+ if (involves < 0 || involves)
return involves;
}
- return 1;
+ return 0;
}
int isl_basic_set_involves_dims(__isl_keep isl_basic_set *bset,
if (!div_is_unknown(bmap, i))
continue;
bmap = isl_basic_map_remove_dims(bmap, isl_dim_div, i, 1);
+ if (!bmap)
+ return NULL;
+ i = bmap->n_div;
}
return bmap;
(struct isl_basic_map *)bset2);
}
+__isl_give isl_basic_set *isl_basic_set_intersect_params(
+ __isl_take isl_basic_set *bset1, __isl_take isl_basic_set *bset2)
+{
+ return isl_basic_set_intersect(bset1, bset2);
+}
+
/* Special case of isl_map_intersect, where both map1 and map2
* are convex, without any divs and such that either map1 or map2
* contains a single constraint. This constraint is then simply
return NULL;
}
-static __isl_give isl_map *map_intersect(__isl_take isl_map *map1,
+/* map2 may be either a parameter domain or a map living in the same
+ * space as map1.
+ */
+static __isl_give isl_map *map_intersect_internal(__isl_take isl_map *map1,
__isl_take isl_map *map2)
{
unsigned flags = 0;
(map1->p[0]->n_eq + map1->p[0]->n_ineq == 1 ||
map2->p[0]->n_eq + map2->p[0]->n_ineq == 1))
return map_intersect_add_constraint(map1, map2);
- if (isl_space_dim(map1->dim, isl_dim_all) ==
- isl_space_dim(map1->dim, isl_dim_param) &&
- isl_space_dim(map2->dim, isl_dim_all) !=
- isl_space_dim(map2->dim, isl_dim_param))
- return isl_map_intersect(map2, map1);
if (isl_space_dim(map2->dim, isl_dim_all) !=
isl_space_dim(map2->dim, isl_dim_param))
return NULL;
}
+static __isl_give isl_map *map_intersect(__isl_take isl_map *map1,
+ __isl_take isl_map *map2)
+{
+ if (!map1 || !map2)
+ goto error;
+ if (!isl_space_is_equal(map1->dim, map2->dim))
+ isl_die(isl_map_get_ctx(map1), isl_error_invalid,
+ "spaces don't match", goto error);
+ return map_intersect_internal(map1, map2);
+error:
+ isl_map_free(map1);
+ isl_map_free(map2);
+ return NULL;
+}
+
__isl_give isl_map *isl_map_intersect(__isl_take isl_map *map1,
__isl_take isl_map *map2)
{
(struct isl_map *)set2);
}
-/* The current implementation of isl_map_intersect accepts intersections
- * with parameter domains, so we can just call that for now.
+/* map_intersect_internal accepts intersections
+ * with parameter domains, so we can just call that function.
*/
static __isl_give isl_map *map_intersect_params(__isl_take isl_map *map,
__isl_take isl_set *params)
{
- return isl_map_intersect(map, params);
+ return map_intersect_internal(map, params);
}
__isl_give isl_map *isl_map_intersect_params(__isl_take isl_map *map1,
{
isl_space *space;
- if (!isl_space_is_named_or_nested(map->dim, type))
+ if (!map || !isl_space_is_named_or_nested(map->dim, type))
return map;
space = isl_map_get_space(map);
isl_int *old;
if (n == 0)
- return bmap;
+ return basic_map_space_reset(bmap, type);
if (!bmap)
return NULL;
return NULL;
if (n == 0)
- return map;
+ return map_space_reset(map, type);
isl_assert(map->ctx, first + n <= isl_map_dim(map, type), goto error);
isl_space *space;
unsigned n;
+ if (isl_basic_set_is_params(bset))
+ return bset;
+
n = isl_basic_set_dim(bset, isl_dim_set);
bset = isl_basic_set_project_out(bset, isl_dim_set, 0, n);
space = isl_basic_set_get_space(bset);
isl_space *space;
unsigned n;
+ if (isl_set_is_params(set))
+ return set;
+
n = isl_set_dim(set, isl_dim_set);
set = isl_set_project_out(set, isl_dim_set, 0, n);
space = isl_set_get_space(set);
return set;
}
+/* Construct a zero-dimensional set with the given parameter domain.
+ */
+__isl_give isl_set *isl_set_from_params(__isl_take isl_set *set)
+{
+ isl_space *space;
+ space = isl_set_get_space(set);
+ space = isl_space_set_from_params(space);
+ set = isl_set_reset_space(set, space);
+ return set;
+}
+
+/* Compute the parameter domain of the given map.
+ */
+__isl_give isl_set *isl_map_params(__isl_take isl_map *map)
+{
+ isl_space *space;
+ unsigned n;
+
+ n = isl_map_dim(map, isl_dim_in);
+ map = isl_map_project_out(map, isl_dim_in, 0, n);
+ n = isl_map_dim(map, isl_dim_out);
+ map = isl_map_project_out(map, isl_dim_out, 0, n);
+ space = isl_map_get_space(map);
+ space = isl_space_params(space);
+ map = isl_map_reset_space(map, space);
+ return map;
+}
+
struct isl_basic_set *isl_basic_map_domain(struct isl_basic_map *bmap)
{
isl_space *dim;
return isl_space_may_be_set(bmap->dim);
}
+/* Is this basic map actually a set?
+ * Users should never call this function. Outside of isl,
+ * the type should indicate whether something is a set or a map.
+ */
+int isl_basic_map_is_set(__isl_keep isl_basic_map *bmap)
+{
+ if (!bmap)
+ return -1;
+ return isl_space_is_set(bmap->dim);
+}
+
struct isl_basic_set *isl_basic_map_range(struct isl_basic_map *bmap)
{
if (!bmap)
return NULL;
- if (isl_basic_map_may_be_set(bmap))
+ if (isl_basic_map_is_set(bmap))
return bmap;
return isl_basic_map_domain(isl_basic_map_reverse(bmap));
}
return isl_space_may_be_set(map->dim);
}
+/* Is this map actually a set?
+ * Users should never call this function. Outside of isl,
+ * the type should indicate whether something is a set or a map.
+ */
+int isl_map_is_set(__isl_keep isl_map *map)
+{
+ if (!map)
+ return -1;
+ return isl_space_is_set(map->dim);
+}
+
struct isl_set *isl_map_range(struct isl_map *map)
{
int i;
if (!map)
goto error;
- if (isl_map_may_be_set(map))
+ if (isl_map_is_set(map))
return (isl_set *)map;
map = isl_map_cow(map);
__isl_give isl_basic_map *isl_basic_map_from_range(
__isl_take isl_basic_set *bset)
{
+ isl_space *space;
+ space = isl_basic_set_get_space(bset);
+ space = isl_space_from_range(space);
+ bset = isl_basic_set_reset_space(bset, space);
return (isl_basic_map *)bset;
}
struct isl_map *isl_map_from_range(struct isl_set *set)
{
+ isl_space *space;
+ space = isl_set_get_space(set);
+ space = isl_space_from_range(space);
+ set = isl_set_reset_space(set, space);
return (struct isl_map *)set;
}
__isl_give isl_basic_map *isl_basic_map_from_domain_and_range(
__isl_take isl_basic_set *domain, __isl_take isl_basic_set *range)
{
- return isl_basic_map_apply_range(isl_basic_map_from_domain(domain),
- isl_basic_map_from_range(range));
+ return isl_basic_map_apply_range(isl_basic_map_reverse(domain), range);
}
__isl_give isl_map *isl_map_from_domain_and_range(__isl_take isl_set *domain,
__isl_take isl_set *range)
{
- return isl_map_apply_range(isl_map_from_domain(domain),
- isl_map_from_range(range));
+ return isl_map_apply_range(isl_map_reverse(domain), range);
}
struct isl_set *isl_set_from_map(struct isl_map *map)
if (!dim)
return NULL;
- isl_assert(dim->ctx, n >= 0, return NULL);
+ if (n < 0)
+ isl_die(dim->ctx, isl_error_internal,
+ "negative number of basic maps", goto error);
map = isl_alloc(dim->ctx, struct isl_map,
sizeof(struct isl_map) +
(n - 1) * sizeof(struct isl_basic_map *));
isl_dim_set, dim, value);
}
+static int remove_if_empty(__isl_keep isl_map *map, int i)
+{
+ int empty = isl_basic_map_plain_is_empty(map->p[i]);
+
+ if (empty < 0)
+ return -1;
+ if (!empty)
+ return 0;
+
+ isl_basic_map_free(map->p[i]);
+ if (i != map->n - 1) {
+ ISL_F_CLR(map, ISL_MAP_NORMALIZED);
+ map->p[i] = map->p[map->n - 1];
+ }
+ map->n--;
+
+ return 0;
+}
+
struct isl_map *isl_map_fix_si(struct isl_map *map,
enum isl_dim_type type, unsigned pos, int value)
{
return NULL;
isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error);
- for (i = 0; i < map->n; ++i) {
+ for (i = map->n - 1; i >= 0; --i) {
map->p[i] = isl_basic_map_fix_si(map->p[i], type, pos, value);
- if (!map->p[i])
+ if (remove_if_empty(map, i) < 0)
goto error;
}
ISL_F_CLR(map, ISL_MAP_NORMALIZED);
isl_map_fix_si((struct isl_map *)set, isl_dim_set, dim, value);
}
-__isl_give isl_basic_map *isl_basic_map_lower_bound_si(
- __isl_take isl_basic_map *bmap,
- enum isl_dim_type type, unsigned pos, int value)
+static __isl_give isl_basic_map *basic_map_bound_si(
+ __isl_take isl_basic_map *bmap,
+ enum isl_dim_type type, unsigned pos, int value, int upper)
{
int j;
if (j < 0)
goto error;
isl_seq_clr(bmap->ineq[j], 1 + isl_basic_map_total_dim(bmap));
- isl_int_set_si(bmap->ineq[j][pos], 1);
- isl_int_set_si(bmap->ineq[j][0], -value);
+ if (upper) {
+ isl_int_set_si(bmap->ineq[j][pos], -1);
+ isl_int_set_si(bmap->ineq[j][0], value);
+ } else {
+ isl_int_set_si(bmap->ineq[j][pos], 1);
+ isl_int_set_si(bmap->ineq[j][0], -value);
+ }
bmap = isl_basic_map_simplify(bmap);
return isl_basic_map_finalize(bmap);
error:
return NULL;
}
+__isl_give isl_basic_map *isl_basic_map_lower_bound_si(
+ __isl_take isl_basic_map *bmap,
+ enum isl_dim_type type, unsigned pos, int value)
+{
+ return basic_map_bound_si(bmap, type, pos, value, 0);
+}
+
struct isl_basic_set *isl_basic_set_lower_bound_dim(struct isl_basic_set *bset,
unsigned dim, isl_int value)
{
return NULL;
}
-__isl_give isl_map *isl_map_lower_bound_si(__isl_take isl_map *map,
- enum isl_dim_type type, unsigned pos, int value)
+static __isl_give isl_map *map_bound_si(__isl_take isl_map *map,
+ enum isl_dim_type type, unsigned pos, int value, int upper)
{
int i;
isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error);
for (i = 0; i < map->n; ++i) {
- map->p[i] = isl_basic_map_lower_bound_si(map->p[i],
- type, pos, value);
+ map->p[i] = basic_map_bound_si(map->p[i],
+ type, pos, value, upper);
if (!map->p[i])
goto error;
}
return NULL;
}
+__isl_give isl_map *isl_map_lower_bound_si(__isl_take isl_map *map,
+ enum isl_dim_type type, unsigned pos, int value)
+{
+ return map_bound_si(map, type, pos, value, 0);
+}
+
+__isl_give isl_map *isl_map_upper_bound_si(__isl_take isl_map *map,
+ enum isl_dim_type type, unsigned pos, int value)
+{
+ return map_bound_si(map, type, pos, value, 1);
+}
+
__isl_give isl_set *isl_set_lower_bound_si(__isl_take isl_set *set,
enum isl_dim_type type, unsigned pos, int value)
{
isl_map_lower_bound_si((struct isl_map *)set, type, pos, value);
}
+__isl_give isl_set *isl_set_upper_bound_si(__isl_take isl_set *set,
+ enum isl_dim_type type, unsigned pos, int value)
+{
+ return isl_map_upper_bound_si(set, type, pos, value);
+}
+
struct isl_set *isl_set_lower_bound_dim(struct isl_set *set, unsigned dim,
isl_int value)
{
dom, empty);
}
+__isl_give isl_pw_multi_aff *isl_basic_map_partial_lexmin_pw_multi_aff(
+ __isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
+ __isl_give isl_set **empty)
+{
+ return isl_basic_map_partial_lexopt_pw_multi_aff(bmap, dom, empty, 0);
+}
+
+__isl_give isl_pw_multi_aff *isl_basic_map_partial_lexmax_pw_multi_aff(
+ __isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
+ __isl_give isl_set **empty)
+{
+ return isl_basic_map_partial_lexopt_pw_multi_aff(bmap, dom, empty, 1);
+}
+
+__isl_give isl_pw_multi_aff *isl_basic_set_partial_lexmin_pw_multi_aff(
+ __isl_take isl_basic_set *bset, __isl_take isl_basic_set *dom,
+ __isl_give isl_set **empty)
+{
+ return isl_basic_map_partial_lexmin_pw_multi_aff(bset, dom, empty);
+}
+
+__isl_give isl_pw_multi_aff *isl_basic_set_partial_lexmax_pw_multi_aff(
+ __isl_take isl_basic_set *bset, __isl_take isl_basic_set *dom,
+ __isl_give isl_set **empty)
+{
+ return isl_basic_map_partial_lexmax_pw_multi_aff(bset, dom, empty);
+}
+
+__isl_give isl_pw_multi_aff *isl_basic_map_lexopt_pw_multi_aff(
+ __isl_take isl_basic_map *bmap, int max)
+{
+ isl_basic_set *dom = NULL;
+ isl_space *dom_space;
+
+ if (!bmap)
+ goto error;
+ dom_space = isl_space_domain(isl_space_copy(bmap->dim));
+ dom = isl_basic_set_universe(dom_space);
+ return isl_basic_map_partial_lexopt_pw_multi_aff(bmap, dom, NULL, max);
+error:
+ isl_basic_map_free(bmap);
+ return NULL;
+}
+
+__isl_give isl_pw_multi_aff *isl_basic_map_lexmin_pw_multi_aff(
+ __isl_take isl_basic_map *bmap)
+{
+ return isl_basic_map_lexopt_pw_multi_aff(bmap, 0);
+}
+
/* Given a basic map "bmap", compute the lexicographically minimal
* (or maximal) image element for each domain element in dom.
* Set *empty to those elements in dom that do not have an image element.
return (isl_set *)isl_map_lexmax((isl_map *)set);
}
-/* Construct a map that equates the two given dimensions in the given space.
- */
-static __isl_give isl_map *equate(__isl_take isl_space *dim,
- enum isl_dim_type src_type, int src_pos,
- enum isl_dim_type dst_type, int dst_pos)
-{
- isl_basic_map *bmap;
- int k;
-
- bmap = isl_basic_map_alloc_space(dim, 0, 1, 0);
- k = isl_basic_map_alloc_equality(bmap);
- if (k < 0)
- goto error;
- isl_seq_clr(bmap->eq[k], 1 + isl_basic_map_total_dim(bmap));
- src_pos += isl_basic_map_offset(bmap, src_type);
- dst_pos += isl_basic_map_offset(bmap, dst_type);
- isl_int_set_si(bmap->eq[k][src_pos], 1);
- isl_int_set_si(bmap->eq[k][dst_pos], -1);
-
- return isl_map_from_basic_map(bmap);
-error:
- isl_basic_map_free(bmap);
- return NULL;
-}
-
/* Extract the first and only affine expression from list
* and then add it to *pwaff with the given dom.
* This domain is known to be disjoint from other domains
- * because of the way isl_basic_set_foreach_lexmax works.
+ * because of the way isl_basic_map_foreach_lexmax works.
*/
static int update_dim_opt(__isl_take isl_basic_set *dom,
__isl_take isl_aff_list *list, void *user)
return -1;
}
-/* Given a one-dimensional basic set, compute the minimum or maximum of that
- * dimension as an isl_pw_aff.
+/* Given a basic map with one output dimension, compute the minimum or
+ * maximum of that dimension as an isl_pw_aff.
*
- * The isl_pw_aff is constructed by having isl_basic_set_foreach_lexopt
+ * The isl_pw_aff is constructed by having isl_basic_map_foreach_lexopt
* call update_dim_opt on each leaf of the result.
*/
-static __isl_give isl_pw_aff *basic_set_dim_opt(__isl_keep isl_basic_set *bset,
+static __isl_give isl_pw_aff *basic_map_dim_opt(__isl_keep isl_basic_map *bmap,
int max)
{
- isl_space *dim = isl_basic_set_get_space(bset);
+ isl_space *dim = isl_basic_map_get_space(bmap);
isl_pw_aff *pwaff;
int r;
- dim = isl_space_domain(isl_space_from_range(dim));
+ dim = isl_space_from_domain(isl_space_domain(dim));
+ dim = isl_space_add_dims(dim, isl_dim_out, 1);
pwaff = isl_pw_aff_empty(dim);
- r = isl_basic_set_foreach_lexopt(bset, max, &update_dim_opt, &pwaff);
+ r = isl_basic_map_foreach_lexopt(bmap, max, &update_dim_opt, &pwaff);
if (r < 0)
return isl_pw_aff_free(pwaff);
return pwaff;
}
-/* Compute the minimum or maximum of the given set dimension
- * as a function of the parameters, but independently of
- * the other set dimensions.
+/* Compute the minimum or maximum of the given output dimension
+ * as a function of the parameters and the input dimensions,
+ * but independently of the other output dimensions.
*
- * We first project the set onto the given dimension and then compute
- * the "lexicographic" maximum in each basic set, combining the results
+ * We first project out the other output dimension and then compute
+ * the "lexicographic" maximum in each basic map, combining the results
* using isl_pw_aff_union_max.
*/
-static __isl_give isl_pw_aff *set_dim_opt(__isl_take isl_set *set, int pos,
+static __isl_give isl_pw_aff *map_dim_opt(__isl_take isl_map *map, int pos,
int max)
{
int i;
- isl_map *map;
isl_pw_aff *pwaff;
+ unsigned n_out;
- map = isl_map_from_domain(set);
- map = isl_map_add_dims(map, isl_dim_out, 1);
- map = isl_map_intersect(map,
- equate(isl_map_get_space(map), isl_dim_in, pos,
- isl_dim_out, 0));
- set = isl_map_range(map);
- if (!set)
+ n_out = isl_map_dim(map, isl_dim_out);
+ map = isl_map_project_out(map, isl_dim_out, pos + 1, n_out - (pos + 1));
+ map = isl_map_project_out(map, isl_dim_out, 0, pos);
+ if (!map)
return NULL;
- if (set->n == 0) {
- isl_space *dim = isl_set_get_space(set);
+ if (map->n == 0) {
+ isl_space *dim = isl_map_get_space(map);
dim = isl_space_domain(isl_space_from_range(dim));
- isl_set_free(set);
+ isl_map_free(map);
return isl_pw_aff_empty(dim);
}
- pwaff = basic_set_dim_opt(set->p[0], max);
- for (i = 1; i < set->n; ++i) {
+ pwaff = basic_map_dim_opt(map->p[0], max);
+ for (i = 1; i < map->n; ++i) {
isl_pw_aff *pwaff_i;
- pwaff_i = basic_set_dim_opt(set->p[i], max);
+ pwaff_i = basic_map_dim_opt(map->p[i], max);
pwaff = isl_pw_aff_union_opt(pwaff, pwaff_i, max);
}
- isl_set_free(set);
+ isl_map_free(map);
return pwaff;
}
+/* Compute the maximum of the given output dimension as a function of the
+ * parameters and input dimensions, but independently of
+ * the other output dimensions.
+ */
+__isl_give isl_pw_aff *isl_map_dim_max(__isl_take isl_map *map, int pos)
+{
+ return map_dim_opt(map, pos, 1);
+}
+
+/* Compute the minimum or maximum of the given set dimension
+ * as a function of the parameters,
+ * but independently of the other set dimensions.
+ */
+static __isl_give isl_pw_aff *set_dim_opt(__isl_take isl_set *set, int pos,
+ int max)
+{
+ return map_dim_opt(set, pos, max);
+}
+
/* Compute the maximum of the given set dimension as a function of the
* parameters, but independently of the other set dimensions.
*/
int isl_map_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2)
{
- return align_params_map_map_and_test(map1, map2, &map_is_equal);
+ return isl_map_align_params_map_map_and_test(map1, map2, &map_is_equal);
}
int isl_basic_map_is_strict_subset(
if (!map)
return NULL;
- for (i = map->n-1; i >= 0; --i) {
- if (!ISL_F_ISSET(map->p[i], ISL_BASIC_MAP_EMPTY))
- continue;
- isl_basic_map_free(map->p[i]);
- if (i != map->n-1) {
- ISL_F_CLR(map, ISL_MAP_NORMALIZED);
- map->p[i] = map->p[map->n-1];
- }
- map->n--;
- }
+ for (i = map->n - 1; i >= 0; --i)
+ remove_if_empty(map, i);
return map;
}
map_offset(map, type) - 1 + pos, val);
}
+int isl_set_plain_is_fixed(__isl_keep isl_set *set,
+ enum isl_dim_type type, unsigned pos, isl_int *val)
+{
+ return isl_map_plain_is_fixed(set, type, pos, val);
+}
+
int isl_map_fast_is_fixed(__isl_keep isl_map *map,
enum isl_dim_type type, unsigned pos, isl_int *val)
{
return 0;
}
+int isl_basic_set_plain_cmp(const __isl_keep isl_basic_set *bset1,
+ const __isl_keep isl_basic_set *bset2)
+{
+ return isl_basic_map_plain_cmp(bset1, bset2);
+}
+
+int isl_set_plain_cmp(const __isl_keep isl_set *set1,
+ const __isl_keep isl_set *set2)
+{
+ int i, cmp;
+
+ if (set1 == set2)
+ return 0;
+ if (set1->n != set2->n)
+ return set1->n - set2->n;
+
+ for (i = 0; i < set1->n; ++i) {
+ cmp = isl_basic_set_plain_cmp(set1->p[i], set2->p[i]);
+ if (cmp)
+ return cmp;
+ }
+
+ return 0;
+}
+
int isl_basic_map_plain_is_equal(__isl_keep isl_basic_map *bmap1,
__isl_keep isl_basic_map *bmap2)
{
return -1;
bound = isl_vec_alloc(bset->ctx, 1 + isl_basic_set_total_dim(bset));
- tab = isl_tab_from_basic_set(bset);
+ tab = isl_tab_from_basic_set(bset, 0);
if (!bound || !tab)
goto error;
__isl_take isl_space *dim, __isl_take struct isl_dim_map *dim_map)
{
isl_basic_map *res;
+ unsigned flags;
bmap = isl_basic_map_cow(bmap);
if (!bmap || !dim || !dim_map)
goto error;
+ flags = bmap->flags;
+ ISL_FL_CLR(flags, ISL_BASIC_MAP_FINAL);
+ ISL_FL_CLR(flags, ISL_BASIC_MAP_NORMALIZED);
+ ISL_FL_CLR(flags, ISL_BASIC_MAP_NORMALIZED_DIVS);
res = isl_basic_map_alloc_space(dim,
bmap->n_div, bmap->n_eq, bmap->n_ineq);
res = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map);
+ if (res)
+ res->flags = flags;
res = isl_basic_map_finalize(res);
return res;
error:
return NULL;
ls = isl_aff_get_local_space(aff);
- ls = isl_local_space_from_domain(ls);
- ls = isl_local_space_add_dims(ls, isl_dim_out, 1);
bmap = isl_basic_map_from_local_space(ls);
bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
k = isl_basic_map_alloc_equality(bmap);
return NULL;
}
+/* Construct a basic map mapping the domain the multi-affine expression
+ * to its range, with each dimension in the range equated to the
+ * corresponding affine expression.
+ */
+__isl_give isl_basic_map *isl_basic_map_from_multi_aff(
+ __isl_take isl_multi_aff *maff)
+{
+ int i;
+ isl_space *space;
+ isl_basic_map *bmap;
+
+ if (!maff)
+ return NULL;
+
+ if (isl_space_dim(maff->space, isl_dim_out) != maff->n)
+ isl_die(isl_multi_aff_get_ctx(maff), isl_error_internal,
+ "invalid space", return isl_multi_aff_free(maff));
+
+ space = isl_space_domain(isl_multi_aff_get_space(maff));
+ bmap = isl_basic_map_universe(isl_space_from_domain(space));
+
+ for (i = 0; i < maff->n; ++i) {
+ isl_aff *aff;
+ isl_basic_map *bmap_i;
+
+ aff = isl_aff_copy(maff->p[i]);
+ bmap_i = isl_basic_map_from_aff(aff);
+
+ bmap = isl_basic_map_flat_range_product(bmap, bmap_i);
+ }
+
+ bmap = isl_basic_map_reset_space(bmap, isl_multi_aff_get_space(maff));
+
+ isl_multi_aff_free(maff);
+ return bmap;
+}
+
/* Construct a basic map mapping a domain in the given space to
* to an n-dimensional range, with n the number of elements in the list,
* where each coordinate in the range is prescribed by the
isl_map_free(map);
return NULL;
}
+
+__isl_give isl_aff *isl_basic_map_get_div(__isl_keep isl_basic_map *bmap,
+ int pos)
+{
+ isl_aff *div;
+ isl_local_space *ls;
+
+ if (!bmap)
+ return NULL;
+
+ if (!isl_basic_map_divs_known(bmap))
+ isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
+ "some divs are unknown", return NULL);
+
+ ls = isl_basic_map_get_local_space(bmap);
+ div = isl_local_space_get_div(ls, pos);
+ isl_local_space_free(ls);
+
+ return div;
+}
+
+__isl_give isl_aff *isl_basic_set_get_div(__isl_keep isl_basic_set *bset,
+ int pos)
+{
+ return isl_basic_map_get_div(bset, pos);
+}
+
+/* Plug in "subs" for dimension "type", "pos" of "bset".
+ *
+ * Let i be the dimension to replace and let "subs" be of the form
+ *
+ * f/d
+ *
+ * Any integer division with a non-zero coefficient for i,
+ *
+ * floor((a i + g)/m)
+ *
+ * is replaced by
+ *
+ * floor((a f + d g)/(m d))
+ *
+ * Constraints of the form
+ *
+ * a i + g
+ *
+ * are replaced by
+ *
+ * a f + d g
+ */
+__isl_give isl_basic_set *isl_basic_set_substitute(
+ __isl_take isl_basic_set *bset,
+ enum isl_dim_type type, unsigned pos, __isl_keep isl_aff *subs)
+{
+ int i;
+ isl_int v;
+ isl_ctx *ctx;
+
+ if (bset && isl_basic_set_plain_is_empty(bset))
+ return bset;
+
+ bset = isl_basic_set_cow(bset);
+ if (!bset || !subs)
+ goto error;
+
+ ctx = isl_basic_set_get_ctx(bset);
+ if (!isl_space_is_equal(bset->dim, subs->ls->dim))
+ isl_die(ctx, isl_error_invalid,
+ "spaces don't match", goto error);
+ if (isl_local_space_dim(subs->ls, isl_dim_div) != 0)
+ isl_die(ctx, isl_error_unsupported,
+ "cannot handle divs yet", goto error);
+
+ pos += isl_basic_set_offset(bset, type);
+
+ isl_int_init(v);
+
+ for (i = 0; i < bset->n_eq; ++i) {
+ if (isl_int_is_zero(bset->eq[i][pos]))
+ continue;
+ isl_int_set(v, bset->eq[i][pos]);
+ isl_int_set_si(bset->eq[i][pos], 0);
+ isl_seq_combine(bset->eq[i], subs->v->el[0], bset->eq[i],
+ v, subs->v->el + 1, subs->v->size - 1);
+ }
+
+ for (i = 0; i < bset->n_ineq; ++i) {
+ if (isl_int_is_zero(bset->ineq[i][pos]))
+ continue;
+ isl_int_set(v, bset->ineq[i][pos]);
+ isl_int_set_si(bset->ineq[i][pos], 0);
+ isl_seq_combine(bset->ineq[i], subs->v->el[0], bset->ineq[i],
+ v, subs->v->el + 1, subs->v->size - 1);
+ }
+
+ for (i = 0; i < bset->n_div; ++i) {
+ if (isl_int_is_zero(bset->div[i][1 + pos]))
+ continue;
+ isl_int_set(v, bset->div[i][1 + pos]);
+ isl_int_set_si(bset->div[i][1 + pos], 0);
+ isl_seq_combine(bset->div[i] + 1,
+ subs->v->el[0], bset->div[i] + 1,
+ v, subs->v->el + 1, subs->v->size - 1);
+ isl_int_mul(bset->div[i][0], bset->div[i][0], subs->v->el[0]);
+ }
+
+ isl_int_clear(v);
+
+ bset = isl_basic_set_simplify(bset);
+ return isl_basic_set_finalize(bset);
+error:
+ isl_basic_set_free(bset);
+ return NULL;
+}
+
+/* Plug in "subs" for dimension "type", "pos" of "set".
+ */
+__isl_give isl_set *isl_set_substitute(__isl_take isl_set *set,
+ enum isl_dim_type type, unsigned pos, __isl_keep isl_aff *subs)
+{
+ int i;
+
+ if (set && isl_set_plain_is_empty(set))
+ return set;
+
+ set = isl_set_cow(set);
+ if (!set || !subs)
+ goto error;
+
+ for (i = set->n - 1; i >= 0; --i) {
+ set->p[i] = isl_basic_set_substitute(set->p[i], type, pos, subs);
+ if (remove_if_empty(set, i) < 0)
+ goto error;
+ }
+
+ return set;
+error:
+ isl_set_free(set);
+ return NULL;
+}
projects / platform / upstream / isl.git / blobdiff