privately export isl_mat_unimodular_complete

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

diff --git a/isl_mat.c b/isl_mat.c
index e2566d5..4947c3d 100644 (file)
--- a/isl_mat.c
+++ b/isl_mat.c
@@ -36,6 +36,55 @@ error:
        return NULL;
 }
 
+struct isl_mat *isl_mat_extend(struct isl_ctx *ctx, struct isl_mat *mat,
+       unsigned n_row, unsigned n_col)
+{
+       int i;
+       isl_int *old;
+
+       if (!mat)
+               return NULL;
+
+       if (mat->n_col >= n_col && mat->n_row >= n_row)
+               return mat;
+
+       if (mat->n_col < n_col) {
+               struct isl_mat *new_mat;
+
+               new_mat = isl_mat_alloc(ctx, n_row, n_col);
+               if (!new_mat)
+                       goto error;
+               for (i = 0; i < mat->n_row; ++i)
+                       isl_seq_cpy(new_mat->row[i], mat->row[i], mat->n_col);
+               isl_mat_free(ctx, mat);
+               return new_mat;
+       }
+
+       mat = isl_mat_cow(ctx, mat);
+       if (!mat)
+               goto error;
+
+       assert(mat->ref == 1);
+       old = mat->block.data;
+       mat->block = isl_blk_extend(ctx, mat->block, n_row * mat->n_col);
+       if (isl_blk_is_error(mat->block))
+               goto error;
+       mat->row = isl_realloc_array(ctx, mat->row, isl_int *, n_row);
+       if (!mat->row)
+               goto error;
+
+       for (i = 0; i < mat->n_row; ++i)
+               mat->row[i] = mat->block.data + (mat->row[i] - old);
+       for (i = mat->n_row; i < n_row; ++i)
+               mat->row[i] = mat->block.data + i * mat->n_col;
+       mat->n_row = n_row;
+
+       return mat;
+error:
+       isl_mat_free(ctx, mat);
+       return NULL;
+}
+
 struct isl_mat *isl_mat_sub_alloc(struct isl_ctx *ctx, isl_int **row,
        unsigned first_row, unsigned n_row, unsigned first_col, unsigned n_col)
 {
@@ -109,7 +158,7 @@ struct isl_mat *isl_mat_cow(struct isl_ctx *ctx, struct isl_mat *mat)
        if (!mat)
                return NULL;
 
-       if (mat->ref == 1 && !F_ISSET(mat, ISL_MAT_BORROWED))
+       if (mat->ref == 1 && !ISL_F_ISSET(mat, ISL_MAT_BORROWED))
                return mat;
 
        mat2 = isl_mat_dup(ctx, mat);
@@ -125,7 +174,7 @@ void isl_mat_free(struct isl_ctx *ctx, struct isl_mat *mat)
        if (--mat->ref > 0)
                return;
 
-       if (!F_ISSET(mat, ISL_MAT_BORROWED))
+       if (!ISL_F_ISSET(mat, ISL_MAT_BORROWED))
                isl_blk_free(ctx, mat->block);
        free(mat->row);
        free(mat);
@@ -655,16 +704,26 @@ error:
 
 struct isl_mat *isl_mat_transpose(struct isl_ctx *ctx, struct isl_mat *mat)
 {
+       struct isl_mat *transpose = NULL;
        int i, j;
 
-       mat = isl_mat_cow(ctx, mat);
-       if (!mat)
-               return NULL;
-       isl_assert(ctx, mat->n_col == mat->n_row, goto error);
+       if (mat->n_col == mat->n_row) {
+               mat = isl_mat_cow(ctx, mat);
+               if (!mat)
+                       return NULL;
+               for (i = 0; i < mat->n_row; ++i)
+                       for (j = i + 1; j < mat->n_col; ++j)
+                               isl_int_swap(mat->row[i][j], mat->row[j][i]);
+               return mat;
+       }
+       transpose = isl_mat_alloc(ctx, mat->n_col, mat->n_row);
+       if (!transpose)
+               goto error;
        for (i = 0; i < mat->n_row; ++i)
-               for (j = i + 1; j < mat->n_col; ++j)
-                       isl_int_swap(mat->row[i][j], mat->row[j][i]);
-       return mat;
+               for (j = 0; j < mat->n_col; ++j)
+                       isl_int_set(transpose->row[j][i], mat->row[i][j]);
+       isl_mat_free(ctx, mat);
+       return transpose;
 error:
        isl_mat_free(ctx, mat);
        return NULL;
@@ -750,15 +809,17 @@ error:
  * the div array too as the number of rows in this array is assumed
  * to be equal to extra.
  */
-struct isl_basic_set *isl_basic_set_preimage(struct isl_ctx *ctx,
-       struct isl_basic_set *bset, struct isl_mat *mat)
+struct isl_basic_set *isl_basic_set_preimage(struct isl_basic_set *bset,
+       struct isl_mat *mat)
 {
+       struct isl_ctx *ctx;
        struct isl_mat *t;
        int i;
 
        if (!bset || !mat)
                goto error;
 
+       ctx = bset->ctx;
        bset = isl_basic_set_cow(bset);
        if (!bset)
                goto error;
@@ -797,6 +858,12 @@ struct isl_basic_set *isl_basic_set_preimage(struct isl_ctx *ctx,
        }
        isl_mat_free(ctx, t);
 
+       ISL_F_CLR(bset, ISL_BASIC_SET_NO_IMPLICIT);
+       ISL_F_CLR(bset, ISL_BASIC_SET_NO_REDUNDANT);
+       ISL_F_CLR(bset, ISL_BASIC_SET_NORMALIZED);
+       ISL_F_CLR(bset, ISL_BASIC_SET_NORMALIZED_DIVS);
+       ISL_F_CLR(bset, ISL_BASIC_SET_ALL_EQUALITIES);
+
        bset = isl_basic_set_simplify(bset);
        bset = isl_basic_set_finalize(bset);
 
@@ -808,9 +875,9 @@ error2:
        return NULL;
 }
 
-struct isl_set *isl_set_preimage(struct isl_ctx *ctx,
-       struct isl_set *set, struct isl_mat *mat)
+struct isl_set *isl_set_preimage(struct isl_set *set, struct isl_mat *mat)
 {
+       struct isl_ctx *ctx;
        int i;
 
        set = isl_set_cow(set);
@@ -819,7 +886,7 @@ struct isl_set *isl_set_preimage(struct isl_ctx *ctx,
 
        ctx = set->ctx;
        for (i = 0; i < set->n; ++i) {
-               set->p[i] = isl_basic_set_preimage(ctx, set->p[i],
+               set->p[i] = isl_basic_set_preimage(set->p[i],
                                                    isl_mat_copy(ctx, mat));
                if (!set->p[i])
                        goto error;
@@ -832,7 +899,7 @@ struct isl_set *isl_set_preimage(struct isl_ctx *ctx,
                set->dim->n_out -= mat->n_row;
        }
        isl_mat_free(ctx, mat);
-       F_CLR(set, ISL_SET_NORMALIZED);
+       ISL_F_CLR(set, ISL_SET_NORMALIZED);
        return set;
 error:
        isl_set_free(set);
@@ -920,3 +987,29 @@ void isl_mat_col_mul(struct isl_mat *mat, int dst_col, isl_int f, int src_col)
        for (i = 0; i < mat->n_row; ++i)
                isl_int_mul(mat->row[i][dst_col], f, mat->row[i][src_col]);
 }
+
+struct isl_mat *isl_mat_unimodular_complete(struct isl_ctx *ctx,
+                                               struct isl_mat *M, int row)
+{
+       int r;
+       struct isl_mat *H = NULL, *Q = NULL;
+
+       isl_assert(ctx, M->n_row == M->n_col, goto error);
+       M->n_row = row;
+       H = isl_mat_left_hermite(ctx, isl_mat_copy(ctx, M), 0, NULL, &Q);
+       M->n_row = M->n_col;
+       if (!H)
+               goto error;
+       for (r = 0; r < row; ++r)
+               isl_assert(ctx, isl_int_is_one(H->row[r][r]), goto error);
+       for (r = row; r < M->n_row; ++r)
+               isl_seq_cpy(M->row[r], Q->row[r], M->n_col);
+       isl_mat_free(ctx, H);
+       isl_mat_free(ctx, Q);
+       return M;
+error:
+       isl_mat_free(ctx, H);
+       isl_mat_free(ctx, Q);
+       isl_mat_free(ctx, M);
+       return NULL;
+}