add isl_multi_aff_lift

[platform/upstream/isl.git] / isl_local_space.c

diff --git a/isl_local_space.c b/isl_local_space.c
index 42527c7..8a27e81 100644 (file)
--- a/isl_local_space.c
+++ b/isl_local_space.c
@@ -451,6 +451,59 @@ __isl_give isl_mat *isl_merge_divs(__isl_keep isl_mat *div1,
        return div;
 }
 
+/* Construct a local space that contains all the divs in either
+ * "ls1" or "ls2".
+ */
+__isl_give isl_local_space *isl_local_space_intersect(
+       __isl_take isl_local_space *ls1, __isl_take isl_local_space *ls2)
+{
+       isl_ctx *ctx;
+       int *exp1 = NULL;
+       int *exp2 = NULL;
+       isl_mat *div;
+
+       if (!ls1 || !ls2)
+               goto error;
+
+       ctx = isl_local_space_get_ctx(ls1);
+       if (!isl_space_is_equal(ls1->dim, ls2->dim))
+               isl_die(ctx, isl_error_invalid,
+                       "spaces should be identical", goto error);
+
+       if (ls2->div->n_row == 0) {
+               isl_local_space_free(ls2);
+               return ls1;
+       }
+
+       if (ls1->div->n_row == 0) {
+               isl_local_space_free(ls1);
+               return ls2;
+       }
+
+       exp1 = isl_alloc_array(ctx, int, ls1->div->n_row);
+       exp2 = isl_alloc_array(ctx, int, ls2->div->n_row);
+       if (!exp1 || !exp2)
+               goto error;
+
+       div = isl_merge_divs(ls1->div, ls2->div, exp1, exp2);
+       if (!div)
+               goto error;
+
+       free(exp1);
+       free(exp2);
+       isl_local_space_free(ls2);
+       isl_mat_free(ls1->div);
+       ls1->div = div;
+
+       return ls1;
+error:
+       free(exp1);
+       free(exp2);
+       isl_local_space_free(ls1);
+       isl_local_space_free(ls2);
+       return NULL;
+}
+
 int isl_local_space_divs_known(__isl_keep isl_local_space *ls)
 {
        int i;
@@ -570,6 +623,60 @@ error:
        return NULL;
 }
 
+/* Plug in "subs" for dimension "type", "pos" in the integer divisions
+ * of "ls".
+ *
+ * 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))
+ */
+__isl_give isl_local_space *isl_local_space_substitute(
+       __isl_take isl_local_space *ls,
+       enum isl_dim_type type, unsigned pos, __isl_keep isl_aff *subs)
+{
+       int i;
+       isl_int v;
+
+       ls = isl_local_space_cow(ls);
+       if (!ls || !subs)
+               return isl_local_space_free(ls);
+
+       if (!isl_space_is_equal(ls->dim, subs->ls->dim))
+               isl_die(isl_local_space_get_ctx(ls), isl_error_invalid,
+                       "spaces don't match", return isl_local_space_free(ls));
+       if (isl_local_space_dim(subs->ls, isl_dim_div) != 0)
+               isl_die(isl_local_space_get_ctx(ls), isl_error_unsupported,
+                       "cannot handle divs yet",
+                       return isl_local_space_free(ls));
+
+       pos += isl_local_space_offset(ls, type);
+
+       isl_int_init(v);
+       for (i = 0; i < ls->div->n_row; ++i) {
+               if (isl_int_is_zero(ls->div->row[i][1 + pos]))
+                       continue;
+               isl_int_set(v, ls->div->row[i][1 + pos]);
+               isl_int_set_si(ls->div->row[i][1 + pos], 0);
+               isl_seq_combine(ls->div->row[i] + 1,
+                               subs->v->el[0], ls->div->row[i] + 1,
+                               v, subs->v->el + 1, subs->v->size - 1);
+               isl_int_mul(ls->div->row[i][0],
+                           ls->div->row[i][0], subs->v->el[0]);
+               normalize_div(ls, i);
+       }
+       isl_int_clear(v);
+
+       return ls;
+}
+
 int isl_local_space_is_named_or_nested(__isl_keep isl_local_space *ls,
        enum isl_dim_type type)
 {
@@ -729,3 +836,47 @@ int *isl_local_space_get_active(__isl_keep isl_local_space *ls, isl_int *l)
 
        return active;
 }
+
+/* Given a local space "ls" of a set, create a local space
+ * for the lift of the set.  In particular, the result
+ * is of the form [dim -> local[..]], with ls->div->n_row variables in the
+ * range of the wrapped map.
+ */
+__isl_give isl_local_space *isl_local_space_lift(
+       __isl_take isl_local_space *ls)
+{
+       ls = isl_local_space_cow(ls);
+       if (!ls)
+               return NULL;
+
+       ls->dim = isl_space_lift(ls->dim, ls->div->n_row);
+       ls->div = isl_mat_drop_rows(ls->div, 0, ls->div->n_row);
+       if (!ls->dim || !ls->div)
+               return isl_local_space_free(ls);
+
+       return ls;
+}
+
+/* Construct a basic map that maps a set living in local space "ls"
+ * to the corresponding lifted local space.
+ */
+__isl_give isl_basic_map *isl_local_space_lifting(
+       __isl_take isl_local_space *ls)
+{
+       isl_basic_map *lifting;
+       isl_basic_set *bset;
+
+       if (!ls)
+               return NULL;
+       if (!isl_local_space_is_set(ls))
+               isl_die(isl_local_space_get_ctx(ls), isl_error_invalid,
+                       "lifting only defined on set spaces",
+                       return isl_local_space_free(ls));
+
+       bset = isl_basic_set_from_local_space(ls);
+       lifting = isl_basic_set_unwrap(isl_basic_set_lift(bset));
+       lifting = isl_basic_map_domain_map(lifting);
+       lifting = isl_basic_map_reverse(lifting);
+
+       return lifting;
+}