-#include <isl_point_private.h>
-#include <isl_set.h>
#include <isl_map_private.h>
+#include <isl_point_private.h>
+#include <isl/set.h>
#include <isl_sample.h>
#include <isl_scan.h>
-#include <isl_seq.h>
+#include <isl/seq.h>
+#include <isl_space_private.h>
+#include <isl_val_private.h>
+
+isl_ctx *isl_point_get_ctx(__isl_keep isl_point *pnt)
+{
+ return pnt ? isl_space_get_ctx(pnt->dim) : NULL;
+}
-__isl_give isl_point *isl_point_alloc(__isl_take isl_dim *dim,
+__isl_give isl_space *isl_point_get_space(__isl_keep isl_point *pnt)
+{
+ return pnt ? isl_space_copy(pnt->dim) : NULL;
+}
+
+__isl_give isl_point *isl_point_alloc(__isl_take isl_space *dim,
__isl_take isl_vec *vec)
{
struct isl_point *pnt;
if (!dim || !vec)
goto error;
- pnt = isl_alloc_type(dim->ctx, struct isl_point);
- if (!pnt)
- goto error;
-
- if (vec->size > 1 + isl_dim_total(dim)) {
+ if (vec->size > 1 + isl_space_dim(dim, isl_dim_all)) {
vec = isl_vec_cow(vec);
if (!vec)
goto error;
- vec->size = 1 + isl_dim_total(dim);
+ vec->size = 1 + isl_space_dim(dim, isl_dim_all);
}
+ pnt = isl_alloc_type(dim->ctx, struct isl_point);
+ if (!pnt)
+ goto error;
+
pnt->ref = 1;
pnt->dim = dim;
pnt->vec = vec;
return pnt;
error:
- isl_dim_free(dim);
+ isl_space_free(dim);
isl_vec_free(vec);
return NULL;
}
-__isl_give isl_point *isl_point_zero(__isl_take isl_dim *dim)
+__isl_give isl_point *isl_point_zero(__isl_take isl_space *dim)
{
isl_vec *vec;
if (!dim)
return NULL;
- vec = isl_vec_alloc(dim->ctx, 1 + isl_dim_total(dim));
+ vec = isl_vec_alloc(dim->ctx, 1 + isl_space_dim(dim, isl_dim_all));
if (!vec)
goto error;
isl_int_set_si(vec->el[0], 1);
isl_seq_clr(vec->el + 1, vec->size - 1);
return isl_point_alloc(dim, vec);
error:
- isl_dim_free(dim);
+ isl_space_free(dim);
return NULL;
}
if (!pnt)
return NULL;
- pnt2 = isl_point_alloc(isl_dim_copy(pnt->dim), isl_vec_copy(pnt->vec));
+ pnt2 = isl_point_alloc(isl_space_copy(pnt->dim), isl_vec_copy(pnt->vec));
return pnt2;
}
if (--pnt->ref > 0)
return;
- isl_dim_free(pnt->dim);
+ isl_space_free(pnt->dim);
isl_vec_free(pnt->vec);
free(pnt);
}
-__isl_give isl_point *isl_point_void(__isl_take isl_dim *dim)
+__isl_give isl_point *isl_point_void(__isl_take isl_space *dim)
{
if (!dim)
return NULL;
return pnt->vec->size == 0;
}
-void isl_point_get_coordinate(__isl_keep isl_point *pnt,
+int isl_point_get_coordinate(__isl_keep isl_point *pnt,
enum isl_dim_type type, int pos, isl_int *v)
{
if (!pnt || isl_point_is_void(pnt))
- return;
+ return -1;
+
+ if (pos < 0 || pos >= isl_space_dim(pnt->dim, type))
+ isl_die(isl_point_get_ctx(pnt), isl_error_invalid,
+ "position out of bounds", return -1);
+
if (type == isl_dim_set)
- pos += isl_dim_size(pnt->dim, isl_dim_param);
+ pos += isl_space_dim(pnt->dim, isl_dim_param);
isl_int_set(*v, pnt->vec->el[1 + pos]);
+
+ return 0;
+}
+
+/* Return the value of coordinate "pos" of type "type" of "pnt".
+ */
+__isl_give isl_val *isl_point_get_coordinate_val(__isl_keep isl_point *pnt,
+ enum isl_dim_type type, int pos)
+{
+ isl_ctx *ctx;
+ isl_val *v;
+
+ if (!pnt)
+ return NULL;
+
+ ctx = isl_point_get_ctx(pnt);
+ if (isl_point_is_void(pnt))
+ isl_die(ctx, isl_error_invalid,
+ "void point does not have coordinates", return NULL);
+ if (pos < 0 || pos >= isl_space_dim(pnt->dim, type))
+ isl_die(ctx, isl_error_invalid,
+ "position out of bounds", return NULL);
+
+ if (type == isl_dim_set)
+ pos += isl_space_dim(pnt->dim, isl_dim_param);
+
+ v = isl_val_rat_from_isl_int(ctx, pnt->vec->el[1 + pos],
+ pnt->vec->el[0]);
+ return isl_val_normalize(v);
}
__isl_give isl_point *isl_point_set_coordinate(__isl_take isl_point *pnt,
goto error;
if (type == isl_dim_set)
- pos += isl_dim_size(pnt->dim, isl_dim_param);
+ pos += isl_space_dim(pnt->dim, isl_dim_param);
isl_int_set(pnt->vec->el[1 + pos], v);
return NULL;
}
+/* Replace coordinate "pos" of type "type" of "pnt" by "v".
+ */
+__isl_give isl_point *isl_point_set_coordinate_val(__isl_take isl_point *pnt,
+ enum isl_dim_type type, int pos, __isl_take isl_val *v)
+{
+ if (!pnt || !v)
+ goto error;
+ if (isl_point_is_void(pnt))
+ isl_die(isl_point_get_ctx(pnt), isl_error_invalid,
+ "void point does not have coordinates", goto error);
+ if (pos < 0 || pos >= isl_space_dim(pnt->dim, type))
+ isl_die(isl_point_get_ctx(pnt), isl_error_invalid,
+ "position out of bounds", goto error);
+ if (!isl_val_is_rat(v))
+ isl_die(isl_point_get_ctx(pnt), isl_error_invalid,
+ "expecting rational value", goto error);
+
+ if (isl_int_eq(pnt->vec->el[1 + pos], v->n) &&
+ isl_int_eq(pnt->vec->el[0], v->d)) {
+ isl_val_free(v);
+ return pnt;
+ }
+
+ pnt = isl_point_cow(pnt);
+ if (!pnt)
+ goto error;
+ pnt->vec = isl_vec_cow(pnt->vec);
+ if (!pnt->vec)
+ goto error;
+
+ if (isl_int_eq(pnt->vec->el[0], v->d)) {
+ isl_int_set(pnt->vec->el[1 + pos], v->n);
+ } else if (isl_int_is_one(v->d)) {
+ isl_int_mul(pnt->vec->el[1 + pos], pnt->vec->el[0], v->n);
+ } else {
+ isl_seq_scale(pnt->vec->el + 1,
+ pnt->vec->el + 1, v->d, pnt->vec->size - 1);
+ isl_int_mul(pnt->vec->el[1 + pos], pnt->vec->el[0], v->n);
+ isl_int_mul(pnt->vec->el[0], pnt->vec->el[0], v->d);
+ pnt->vec = isl_vec_normalize(pnt->vec);
+ if (!pnt->vec)
+ goto error;
+ }
+
+ isl_val_free(v);
+ return pnt;
+error:
+ isl_val_free(v);
+ isl_point_free(pnt);
+ return NULL;
+}
+
__isl_give isl_point *isl_point_add_ui(__isl_take isl_point *pnt,
enum isl_dim_type type, int pos, unsigned val)
{
goto error;
if (type == isl_dim_set)
- pos += isl_dim_size(pnt->dim, isl_dim_param);
+ pos += isl_space_dim(pnt->dim, isl_dim_param);
isl_int_add_ui(pnt->vec->el[1 + pos], pnt->vec->el[1 + pos], val);
goto error;
if (type == isl_dim_set)
- pos += isl_dim_size(pnt->dim, isl_dim_param);
+ pos += isl_space_dim(pnt->dim, isl_dim_param);
isl_int_sub_ui(pnt->vec->el[1 + pos], pnt->vec->el[1 + pos], val);
struct isl_scan_callback callback;
int (*fn)(__isl_take isl_point *pnt, void *user);
void *user;
- isl_dim *dim;
+ isl_space *dim;
};
static int foreach_point(struct isl_scan_callback *cb, __isl_take isl_vec *sample)
struct isl_foreach_point *fp = (struct isl_foreach_point *)cb;
isl_point *pnt;
- pnt = isl_point_alloc(isl_dim_copy(fp->dim), sample);
+ pnt = isl_point_alloc(isl_space_copy(fp->dim), sample);
return fp->fn(pnt, fp->user);
}
if (!set)
return -1;
- fp.dim = isl_set_get_dim(set);
+ fp.dim = isl_set_get_space(set);
if (!fp.dim)
return -1;
goto error;
isl_set_free(set);
- isl_dim_free(fp.dim);
+ isl_space_free(fp.dim);
return 0;
error:
isl_set_free(set);
- isl_dim_free(fp.dim);
+ isl_space_free(fp.dim);
return -1;
}
if (!bmap || !point)
return -1;
- isl_assert(bmap->ctx, isl_dim_equal(bmap->dim, point->dim), return -1);
+ isl_assert(bmap->ctx, isl_space_is_equal(bmap->dim, point->dim), return -1);
if (bmap->n_div == 0)
return isl_basic_map_contains(bmap, point->vec);
return isl_map_contains_point((isl_map *)set, point);
}
-__isl_give isl_set *isl_set_from_point(__isl_take isl_point *pnt)
+__isl_give isl_basic_set *isl_basic_set_from_point(__isl_take isl_point *pnt)
{
isl_basic_set *bset;
isl_basic_set *model;
- model = isl_basic_set_empty(isl_dim_copy(pnt->dim));
+ model = isl_basic_set_empty(isl_space_copy(pnt->dim));
bset = isl_basic_set_from_vec(isl_vec_copy(pnt->vec));
bset = isl_basic_set_from_underlying_set(bset, model);
isl_point_free(pnt);
+ return bset;
+}
+
+__isl_give isl_set *isl_set_from_point(__isl_take isl_point *pnt)
+{
+ isl_basic_set *bset;
+ bset = isl_basic_set_from_point(pnt);
return isl_set_from_basic_set(bset);
}
-__isl_give isl_set *isl_set_box_from_points(__isl_take isl_point *pnt1,
- __isl_take isl_point *pnt2)
+__isl_give isl_basic_set *isl_basic_set_box_from_points(
+ __isl_take isl_point *pnt1, __isl_take isl_point *pnt2)
{
isl_basic_set *bset;
unsigned total;
goto error;
isl_assert(pnt1->dim->ctx,
- isl_dim_equal(pnt1->dim, pnt2->dim), goto error);
+ isl_space_is_equal(pnt1->dim, pnt2->dim), goto error);
if (isl_point_is_void(pnt1) && isl_point_is_void(pnt2)) {
- isl_dim *dim = isl_dim_copy(pnt1->dim);
+ isl_space *dim = isl_space_copy(pnt1->dim);
isl_point_free(pnt1);
isl_point_free(pnt2);
isl_int_clear(t);
- return isl_set_empty(dim);
+ return isl_basic_set_empty(dim);
}
if (isl_point_is_void(pnt1)) {
isl_point_free(pnt1);
isl_int_clear(t);
- return isl_set_from_point(pnt2);
+ return isl_basic_set_from_point(pnt2);
}
if (isl_point_is_void(pnt2)) {
isl_point_free(pnt2);
isl_int_clear(t);
- return isl_set_from_point(pnt1);
+ return isl_basic_set_from_point(pnt1);
}
- total = isl_dim_total(pnt1->dim);
- bset = isl_basic_set_alloc_dim(isl_dim_copy(pnt1->dim), 0, 0, 2 * total);
+ total = isl_space_dim(pnt1->dim, isl_dim_all);
+ bset = isl_basic_set_alloc_space(isl_space_copy(pnt1->dim), 0, 0, 2 * total);
for (i = 0; i < total; ++i) {
isl_int_mul(t, pnt1->vec->el[1 + i], pnt2->vec->el[0]);
isl_int_clear(t);
- return isl_set_from_basic_set(bset);
+ return bset;
error:
isl_point_free(pnt1);
isl_point_free(pnt2);
return NULL;
}
-void isl_point_print(__isl_keep isl_point *pnt, FILE *out)
+__isl_give isl_set *isl_set_box_from_points(__isl_take isl_point *pnt1,
+ __isl_take isl_point *pnt2)
+{
+ isl_basic_set *bset;
+ bset = isl_basic_set_box_from_points(pnt1, pnt2);
+ return isl_set_from_basic_set(bset);
+}
+
+__isl_give isl_printer *isl_printer_print_point(
+ __isl_take isl_printer *p, __isl_keep isl_point *pnt)
{
int i;
unsigned nparam;
unsigned dim;
if (!pnt)
- return;
+ return p;
if (isl_point_is_void(pnt)) {
- fprintf(out, "void\n");
- return;
+ p = isl_printer_print_str(p, "void");
+ return p;
}
- nparam = isl_dim_size(pnt->dim, isl_dim_param);
- dim = isl_dim_size(pnt->dim, isl_dim_set);
+ nparam = isl_space_dim(pnt->dim, isl_dim_param);
+ dim = isl_space_dim(pnt->dim, isl_dim_set);
if (nparam > 0) {
- fprintf(out, "[");
+ p = isl_printer_print_str(p, "[");
for (i = 0; i < nparam; ++i) {
const char *name;
if (i)
- fprintf(out, ", ");
- name = isl_dim_get_name(pnt->dim, isl_dim_param, i);
- if (name)
- fprintf(out, "%s = ", name);
- isl_int_print(out, pnt->vec->el[1 + i], 0);
+ p = isl_printer_print_str(p, ", ");
+ name = isl_space_get_dim_name(pnt->dim, isl_dim_param, i);
+ if (name) {
+ p = isl_printer_print_str(p, name);
+ p = isl_printer_print_str(p, " = ");
+ }
+ p = isl_printer_print_isl_int(p, pnt->vec->el[1 + i]);
if (!isl_int_is_one(pnt->vec->el[0])) {
- fprintf(out, "/");
- isl_int_print(out, pnt->vec->el[0], 0);
+ p = isl_printer_print_str(p, "/");
+ p = isl_printer_print_isl_int(p, pnt->vec->el[0]);
}
}
- fprintf(out, "] -> ");
+ p = isl_printer_print_str(p, "]");
+ p = isl_printer_print_str(p, " -> ");
}
- fprintf(out, "[");
+ p = isl_printer_print_str(p, "[");
for (i = 0; i < dim; ++i) {
if (i)
- fprintf(out, ", ");
- isl_int_print(out, pnt->vec->el[1 + nparam + i], 0);
+ p = isl_printer_print_str(p, ", ");
+ p = isl_printer_print_isl_int(p, pnt->vec->el[1 + nparam + i]);
if (!isl_int_is_one(pnt->vec->el[0])) {
- fprintf(out, "/");
- isl_int_print(out, pnt->vec->el[0], 0);
+ p = isl_printer_print_str(p, "/");
+ p = isl_printer_print_isl_int(p, pnt->vec->el[0]);
}
}
- fprintf(out, "]\n");
+ p = isl_printer_print_str(p, "]");
+ return p;
}
projects / platform / upstream / isl.git / blobdiff