From 8c24c4106f28b02a178989408ef46fe917b10764 Mon Sep 17 00:00:00 2001 From: Sven Verdoolaege Date: Wed, 4 May 2011 11:27:31 +0200 Subject: [PATCH] rename *_fast_* functions to *_plain_* Although the *_fast_* functions are certainly meant to be faster than their unqualified alternatives, they are faster only because they are not complete. The "plain" qualification is hopefully better at conveying the idea that these functions only consider the obvious cases. We keep some of the *_fast_* names for backward compatibility. Signed-off-by: Sven Verdoolaege --- doc/user.pod | 17 ++--- include/isl/map.h | 15 +++-- include/isl/set.h | 20 ++++-- isl_affine_hull.c | 4 +- isl_convex_hull.c | 2 +- isl_equalities.c | 2 +- isl_flow.c | 22 +++---- isl_fold.c | 2 +- isl_hmap_map_basic_set.c | 2 +- isl_ilp.c | 2 +- isl_map.c | 161 ++++++++++++++++++++++++++++++----------------- isl_map_private.h | 6 +- isl_map_simplify.c | 39 +++++++----- isl_map_subtract.c | 12 ++-- isl_morph.c | 4 +- isl_output.c | 10 +-- isl_polynomial.c | 6 +- isl_pw_templ.c | 8 +-- isl_sample.c | 6 +- isl_schedule.c | 8 +-- isl_tab_pip.c | 6 +- isl_transitive_closure.c | 6 +- isl_union_map.c | 4 +- isl_vertices.c | 4 +- pip.c | 2 +- 25 files changed, 222 insertions(+), 148 deletions(-) diff --git a/doc/user.pod b/doc/user.pod index 9d8aa05..a2ebc66 100644 --- a/doc/user.pod +++ b/doc/user.pod @@ -1153,17 +1153,18 @@ of the parameters. =item * Emptiness The following functions test whether the given set or relation -contains any integer points. The ``fast'' variants do not perform +contains any integer points. The ``plain'' variants do not perform any computations, but simply check if the given set or relation is already known to be empty. - int isl_basic_set_fast_is_empty(__isl_keep isl_basic_set *bset); + int isl_basic_set_plain_is_empty(__isl_keep isl_basic_set *bset); int isl_basic_set_is_empty(__isl_keep isl_basic_set *bset); + int isl_set_plain_is_empty(__isl_keep isl_set *set); int isl_set_is_empty(__isl_keep isl_set *set); int isl_union_set_is_empty(__isl_keep isl_union_set *uset); - int isl_basic_map_fast_is_empty(__isl_keep isl_basic_map *bmap); + int isl_basic_map_plain_is_empty(__isl_keep isl_basic_map *bmap); int isl_basic_map_is_empty(__isl_keep isl_basic_map *bmap); - int isl_map_fast_is_empty(__isl_keep isl_map *map); + int isl_map_plain_is_empty(__isl_keep isl_map *map); int isl_map_is_empty(__isl_keep isl_map *map); int isl_union_map_is_empty(__isl_keep isl_union_map *umap); @@ -1171,7 +1172,7 @@ is already known to be empty. int isl_basic_set_is_universe(__isl_keep isl_basic_set *bset); int isl_basic_map_is_universe(__isl_keep isl_basic_map *bmap); - int isl_set_fast_is_universe(__isl_keep isl_set *set); + int isl_set_plain_is_universe(__isl_keep isl_set *set); =item * Single-valuedness @@ -1215,7 +1216,7 @@ i.e., whether both domain and range are nested relations. =item * Equality - int isl_set_fast_is_equal(__isl_keep isl_set *set1, + int isl_set_plain_is_equal(__isl_keep isl_set *set1, __isl_keep isl_set *set2); int isl_set_is_equal(__isl_keep isl_set *set1, __isl_keep isl_set *set2); @@ -1227,7 +1228,7 @@ i.e., whether both domain and range are nested relations. __isl_keep isl_basic_map *bmap2); int isl_map_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2); - int isl_map_fast_is_equal(__isl_keep isl_map *map1, + int isl_map_plain_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2); int isl_union_map_is_equal( __isl_keep isl_union_map *umap1, @@ -1235,7 +1236,7 @@ i.e., whether both domain and range are nested relations. =item * Disjointness - int isl_set_fast_is_disjoint(__isl_keep isl_set *set1, + int isl_set_plain_is_disjoint(__isl_keep isl_set *set1, __isl_keep isl_set *set2); =item * Subset diff --git a/include/isl/map.h b/include/isl/map.h index 5755d14..0343d98 100644 --- a/include/isl/map.h +++ b/include/isl/map.h @@ -220,11 +220,12 @@ struct isl_basic_map *isl_map_copy_basic_map(struct isl_map *map); __isl_give isl_map *isl_map_drop_basic_map(__isl_take isl_map *map, __isl_keep isl_basic_map *bmap); -int isl_basic_map_fast_is_fixed(struct isl_basic_map *bmap, +int isl_basic_map_plain_is_fixed(struct isl_basic_map *bmap, enum isl_dim_type type, unsigned pos, isl_int *val); int isl_basic_map_image_is_bounded(__isl_keep isl_basic_map *bmap); int isl_basic_map_is_universe(__isl_keep isl_basic_map *bmap); +int isl_basic_map_plain_is_empty(__isl_keep isl_basic_map *bmap); int isl_basic_map_fast_is_empty(__isl_keep isl_basic_map *bmap); int isl_basic_map_is_empty(__isl_keep isl_basic_map *bmap); int isl_basic_map_is_subset(__isl_keep isl_basic_map *bmap1, @@ -365,8 +366,9 @@ struct isl_map *isl_map_from_set(struct isl_set *set, struct isl_dim *dim); struct isl_set *isl_set_from_map(struct isl_map *map); __isl_give isl_basic_map *isl_map_sample(__isl_take isl_map *map); +int isl_map_plain_is_empty(__isl_keep isl_map *map); int isl_map_fast_is_empty(__isl_keep isl_map *map); -int isl_map_fast_is_universe(__isl_keep isl_map *map); +int isl_map_plain_is_universe(__isl_keep isl_map *map); int isl_map_is_empty(__isl_keep isl_map *map); int isl_map_is_subset(__isl_keep isl_map *map1, __isl_keep isl_map *map2); int isl_map_is_strict_subset(__isl_keep isl_map *map1, __isl_keep isl_map *map2); @@ -389,9 +391,13 @@ __isl_give isl_map *isl_map_align_divs(__isl_take isl_map *map); void isl_map_print_internal(__isl_keep isl_map *map, FILE *out, int indent); -int isl_map_fast_input_is_fixed(struct isl_map *map, +int isl_map_plain_input_is_fixed(__isl_keep isl_map *map, unsigned in, isl_int *val); -int isl_map_fast_is_fixed(struct isl_map *map, +int isl_map_fast_is_fixed(__isl_keep isl_map *map, + enum isl_dim_type type, unsigned pos, isl_int *val); +int isl_map_plain_is_fixed(struct isl_map *map, + enum isl_dim_type type, unsigned pos, isl_int *val); +int isl_map_fast_is_fixed(__isl_keep isl_map *map, enum isl_dim_type type, unsigned pos, isl_int *val); __isl_give isl_basic_map *isl_basic_map_gist(__isl_take isl_basic_map *bmap, @@ -403,6 +409,7 @@ __isl_give isl_map *isl_map_gist_basic_map(__isl_take isl_map *map, __isl_give isl_map *isl_map_coalesce(__isl_take isl_map *map); +int isl_map_plain_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2); int isl_map_fast_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2); uint32_t isl_map_get_hash(__isl_keep isl_map *map); diff --git a/include/isl/set.h b/include/isl/set.h index 1c3968c..6f09324 100644 --- a/include/isl/set.h +++ b/include/isl/set.h @@ -157,6 +157,7 @@ int isl_basic_set_dims_get_sign(__isl_keep isl_basic_set *bset, enum isl_dim_type type, unsigned pos, unsigned n, int *signs); int isl_basic_set_is_universe(__isl_keep isl_basic_set *bset); +int isl_basic_set_plain_is_empty(__isl_keep isl_basic_set *bset); int isl_basic_set_fast_is_empty(__isl_keep isl_basic_set *bset); int isl_basic_set_is_empty(__isl_keep isl_basic_set *bset); int isl_basic_set_is_bounded(__isl_keep isl_basic_set *bset); @@ -246,7 +247,9 @@ __isl_give isl_set *isl_set_split_dims(__isl_take isl_set *set, enum isl_dim_type type, unsigned first, unsigned n); void isl_set_print_internal(__isl_keep isl_set *set, FILE *out, int indent); +int isl_set_plain_is_empty(__isl_keep isl_set *set); int isl_set_fast_is_empty(__isl_keep isl_set *set); +int isl_set_plain_is_universe(__isl_keep isl_set *set); int isl_set_fast_is_universe(__isl_keep isl_set *set); int isl_set_is_empty(__isl_keep isl_set *set); int isl_set_is_bounded(__isl_keep isl_set *set); @@ -271,11 +274,14 @@ struct isl_basic_set *isl_set_copy_basic_set(struct isl_set *set); struct isl_set *isl_set_drop_basic_set(struct isl_set *set, struct isl_basic_set *bset); -int isl_basic_set_fast_dim_is_fixed(struct isl_basic_set *bset, unsigned dim, - isl_int *val); +int isl_basic_set_plain_dim_is_fixed(__isl_keep isl_basic_set *bset, + unsigned dim, isl_int *val); -int isl_set_fast_dim_is_fixed(struct isl_set *set, unsigned dim, isl_int *val); -int isl_set_fast_dim_has_fixed_lower_bound(struct isl_set *set, +int isl_set_plain_dim_is_fixed(__isl_keep isl_set *set, + unsigned dim, isl_int *val); +int isl_set_fast_dim_is_fixed(__isl_keep isl_set *set, + unsigned dim, isl_int *val); +int isl_set_plain_dim_has_fixed_lower_bound(__isl_keep isl_set *set, unsigned dim, isl_int *val); int isl_set_dim_is_bounded(__isl_keep isl_set *set, enum isl_dim_type type, unsigned pos); @@ -293,8 +299,12 @@ int isl_set_dim_residue_class(struct isl_set *set, __isl_give isl_set *isl_set_coalesce(__isl_take isl_set *set); +int isl_set_plain_is_equal(__isl_keep isl_set *set1, __isl_keep isl_set *set2); int isl_set_fast_is_equal(__isl_keep isl_set *set1, __isl_keep isl_set *set2); -int isl_set_fast_is_disjoint(__isl_keep isl_set *set1, __isl_keep isl_set *set2); +int isl_set_plain_is_disjoint(__isl_keep isl_set *set1, + __isl_keep isl_set *set2); +int isl_set_fast_is_disjoint(__isl_keep isl_set *set1, + __isl_keep isl_set *set2); uint32_t isl_set_get_hash(struct isl_set *set); diff --git a/isl_affine_hull.c b/isl_affine_hull.c index f9e0a78..7c1c547 100644 --- a/isl_affine_hull.c +++ b/isl_affine_hull.c @@ -461,7 +461,7 @@ static struct isl_basic_set *uset_affine_hull_bounded(struct isl_basic_set *bset struct isl_tab *tab = NULL; unsigned dim; - if (isl_basic_set_fast_is_empty(bset)) + if (isl_basic_set_plain_is_empty(bset)) return bset; dim = isl_basic_set_n_dim(bset); @@ -764,7 +764,7 @@ static struct isl_basic_set *uset_affine_hull(struct isl_basic_set *bset) { struct isl_basic_set *cone; - if (isl_basic_set_fast_is_empty(bset)) + if (isl_basic_set_plain_is_empty(bset)) return bset; cone = isl_basic_set_recession_cone(isl_basic_set_copy(bset)); diff --git a/isl_convex_hull.c b/isl_convex_hull.c index 8c04265..0bd82e6 100644 --- a/isl_convex_hull.c +++ b/isl_convex_hull.c @@ -899,7 +899,7 @@ int isl_basic_set_is_bounded(__isl_keep isl_basic_set *bset) if (!bset) return -1; - if (isl_basic_set_fast_is_empty(bset)) + if (isl_basic_set_plain_is_empty(bset)) return 1; tab = isl_tab_from_recession_cone(bset, 1); diff --git a/isl_equalities.c b/isl_equalities.c index fa8ee58..68d2c89 100644 --- a/isl_equalities.c +++ b/isl_equalities.c @@ -575,7 +575,7 @@ int isl_basic_set_dim_residue_class(struct isl_basic_set *bset, if (!bset || !modulo || !residue) return -1; - if (isl_basic_set_fast_dim_is_fixed(bset, pos, residue)) { + if (isl_basic_set_plain_dim_is_fixed(bset, pos, residue)) { isl_int_set_si(*modulo, 0); return 0; } diff --git a/isl_flow.c b/isl_flow.c index 821d8ef..d27937c 100644 --- a/isl_flow.c +++ b/isl_flow.c @@ -311,7 +311,7 @@ int isl_flow_foreach(__isl_keep isl_flow *deps, return -1; for (i = 0; i < deps->n_source; ++i) { - if (isl_map_fast_is_empty(deps->dep[i].map)) + if (isl_map_plain_is_empty(deps->dep[i].map)) continue; if (fn(isl_map_copy(deps->dep[i].map), deps->dep[i].must, deps->dep[i].data, user) < 0) @@ -475,7 +475,7 @@ static int intermediate_sources(__isl_keep isl_access_info *acc, int k, level; int depth = 2 * isl_map_dim(acc->source[j].map, isl_dim_in) + 1; - if (isl_map_fast_is_empty(temp_rel[j])) + if (isl_map_plain_is_empty(temp_rel[j])) return 0; for (k = j - 1; k >= 0; --k) { @@ -498,7 +498,7 @@ static int intermediate_sources(__isl_keep isl_access_info *acc, copy = isl_map_copy(temp_rel[j]); T = last_later_source(acc, copy, j, sink_level, k, level, &trest); - if (isl_map_fast_is_empty(T)) { + if (isl_map_plain_is_empty(T)) { isl_set_free(trest); isl_map_free(T); continue; @@ -588,8 +588,8 @@ static __isl_give isl_map *all_intermediate_sources( for (k = 0; k < acc->n_must; ++k) { int plevel; - if (isl_map_fast_is_empty(may_rel[k]) && - isl_map_fast_is_empty(must_rel[k])) + if (isl_map_plain_is_empty(may_rel[k]) && + isl_map_plain_is_empty(must_rel[k])) continue; plevel = acc->level_before(acc->source[k].data, @@ -741,7 +741,7 @@ static __isl_give isl_flow *compute_val_based_dependences( maydo = isl_set_empty_like(mustdo); if (!mustdo || !maydo) goto error; - if (isl_set_fast_is_empty(mustdo)) + if (isl_set_plain_is_empty(mustdo)) goto done; must_rel = isl_alloc_array(ctx, struct isl_map *, acc->n_must); @@ -777,8 +777,8 @@ static __isl_give isl_flow *compute_val_based_dependences( intermediate_sources(acc, may_rel, j, level); - if (isl_set_fast_is_empty(mustdo) && - isl_set_fast_is_empty(maydo)) + if (isl_set_plain_is_empty(mustdo) && + isl_set_plain_is_empty(maydo)) break; } for (j = j - 1; j >= 0; --j) { @@ -828,8 +828,8 @@ static __isl_give isl_flow *compute_val_based_dependences( may_rel[j]); } - if (isl_set_fast_is_empty(mustdo) && - isl_set_fast_is_empty(maydo)) + if (isl_set_plain_is_empty(mustdo) && + isl_set_plain_is_empty(maydo)) break; } @@ -962,7 +962,7 @@ static __isl_give struct isl_sched_info *sched_info_alloc( goto error; for (i = 0; i < n; ++i) - info->is_cst[i] = isl_map_fast_is_fixed(map, isl_dim_in, i, + info->is_cst[i] = isl_map_plain_is_fixed(map, isl_dim_in, i, &info->cst->el[i]); return info; diff --git a/isl_fold.c b/isl_fold.c index edd3817..8e6191c 100644 --- a/isl_fold.c +++ b/isl_fold.c @@ -789,7 +789,7 @@ __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_fold( isl_set_copy(pw2->p[j].set)); common = isl_set_intersect(isl_set_copy(pw1->p[i].set), isl_set_copy(pw2->p[j].set)); - if (isl_set_fast_is_empty(common)) { + if (isl_set_plain_is_empty(common)) { isl_set_free(common); continue; } diff --git a/isl_hmap_map_basic_set.c b/isl_hmap_map_basic_set.c index 7f9a922..b303516 100644 --- a/isl_hmap_map_basic_set.c +++ b/isl_hmap_map_basic_set.c @@ -35,7 +35,7 @@ static int has_key(const void *entry, const void *key) const struct isl_map_basic_set_pair *pair = entry; isl_map *map = (isl_map *)key; - return isl_map_fast_is_equal(pair->key, map); + return isl_map_plain_is_equal(pair->key, map); } int isl_hmap_map_basic_set_has(isl_ctx *ctx, diff --git a/isl_ilp.c b/isl_ilp.c index 3d3bb92..8c8d8fc 100644 --- a/isl_ilp.c +++ b/isl_ilp.c @@ -308,7 +308,7 @@ enum isl_lp_result isl_basic_set_solve_ilp(struct isl_basic_set *bset, int max, isl_assert(bset->ctx, isl_basic_set_n_param(bset) == 0, goto error); - if (isl_basic_set_fast_is_empty(bset)) + if (isl_basic_set_plain_is_empty(bset)) return isl_lp_empty; if (bset->n_eq) diff --git a/isl_map.c b/isl_map.c index cfb26fa..385ef35 100644 --- a/isl_map.c +++ b/isl_map.c @@ -2115,7 +2115,7 @@ static __isl_give isl_map *map_intersect_add_constraint( map1 = isl_map_cow(map1); if (!map1) goto error; - if (isl_map_fast_is_empty(map1)) { + if (isl_map_plain_is_empty(map1)) { isl_map_free(map2); return map1; } @@ -2131,7 +2131,7 @@ static __isl_give isl_map *map_intersect_add_constraint( if (!map1->p[0]) goto error; - if (isl_basic_map_fast_is_empty(map1->p[0])) { + if (isl_basic_map_plain_is_empty(map1->p[0])) { isl_basic_map_free(map1->p[0]); map1->n = 0; } @@ -2154,11 +2154,11 @@ struct isl_map *isl_map_intersect(struct isl_map *map1, struct isl_map *map2) if (!map1 || !map2) goto error; - if (isl_map_fast_is_empty(map1)) { + if (isl_map_plain_is_empty(map1)) { isl_map_free(map2); return map1; } - if (isl_map_fast_is_empty(map2)) { + if (isl_map_plain_is_empty(map2)) { isl_map_free(map1); return map2; } @@ -4215,7 +4215,7 @@ __isl_give isl_map *isl_map_add_basic_map(__isl_take isl_map *map, { if (!bmap || !map) goto error; - if (isl_basic_map_fast_is_empty(bmap)) { + if (isl_basic_map_plain_is_empty(bmap)) { isl_basic_map_free(bmap); return map; } @@ -4635,7 +4635,7 @@ static __isl_give isl_map *basic_map_partial_lexopt( if (!dom) goto error; - if (isl_set_fast_is_empty(dom)) { + if (isl_set_plain_is_empty(dom)) { res = isl_map_empty_like_basic_map(bmap); *empty = isl_set_empty_like(dom); isl_set_free(dom); @@ -4731,7 +4731,7 @@ static __isl_give isl_map *isl_map_partial_lexopt( if (!map || !dom) goto error; - if (isl_map_fast_is_empty(map)) { + if (isl_map_plain_is_empty(map)) { if (empty) *empty = dom; else @@ -5784,7 +5784,7 @@ static int foreach_orthant(__isl_take isl_set *set, int *signs, int first, if (!set) return -1; - if (isl_set_fast_is_empty(set)) { + if (isl_set_plain_is_empty(set)) { isl_set_free(set); return 0; } @@ -5824,7 +5824,7 @@ int isl_set_foreach_orthant(__isl_keep isl_set *set, if (!set) return -1; - if (isl_set_fast_is_empty(set)) + if (isl_set_plain_is_empty(set)) return 0; nparam = isl_set_dim(set, isl_dim_param); @@ -5904,16 +5904,26 @@ int isl_map_is_empty(struct isl_map *map) return 1; } -int isl_map_fast_is_empty(struct isl_map *map) +int isl_map_plain_is_empty(__isl_keep isl_map *map) { return map ? map->n == 0 : -1; } -int isl_set_fast_is_empty(struct isl_set *set) +int isl_map_fast_is_empty(__isl_keep isl_map *map) +{ + return isl_map_plain_is_empty(map); +} + +int isl_set_plain_is_empty(struct isl_set *set) { return set ? set->n == 0 : -1; } +int isl_set_fast_is_empty(__isl_keep isl_set *set) +{ + return isl_set_plain_is_empty(set); +} + int isl_set_is_empty(struct isl_set *set) { return isl_map_is_empty((struct isl_map *)set); @@ -5998,7 +6008,7 @@ int isl_basic_set_is_universe(struct isl_basic_set *bset) return bset->n_eq == 0 && bset->n_ineq == 0; } -int isl_map_fast_is_universe(__isl_keep isl_map *map) +int isl_map_plain_is_universe(__isl_keep isl_map *map) { int i; @@ -6014,9 +6024,14 @@ int isl_map_fast_is_universe(__isl_keep isl_map *map) return 0; } +int isl_set_plain_is_universe(__isl_keep isl_set *set) +{ + return isl_map_plain_is_universe((isl_map *) set); +} + int isl_set_fast_is_universe(__isl_keep isl_set *set) { - return isl_map_fast_is_universe((isl_map *) set); + return isl_set_plain_is_universe(set); } int isl_basic_map_is_empty(struct isl_basic_map *bmap) @@ -6065,20 +6080,30 @@ int isl_basic_map_is_empty(struct isl_basic_map *bmap) return empty; } -int isl_basic_map_fast_is_empty(struct isl_basic_map *bmap) +int isl_basic_map_plain_is_empty(__isl_keep isl_basic_map *bmap) { if (!bmap) return -1; return ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY); } -int isl_basic_set_fast_is_empty(struct isl_basic_set *bset) +int isl_basic_map_fast_is_empty(__isl_keep isl_basic_map *bmap) +{ + return isl_basic_map_plain_is_empty(bmap); +} + +int isl_basic_set_plain_is_empty(__isl_keep isl_basic_set *bset) { if (!bset) return -1; return ISL_F_ISSET(bset, ISL_BASIC_SET_EMPTY); } +int isl_basic_set_fast_is_empty(__isl_keep isl_basic_set *bset) +{ + return isl_basic_set_plain_is_empty(bset); +} + int isl_basic_set_is_empty(struct isl_basic_set *bset) { return isl_basic_map_is_empty((struct isl_basic_map *)bset); @@ -6517,7 +6542,7 @@ int isl_set_follows_at(__isl_keep isl_set *set1, return follows; } -static int isl_basic_map_fast_has_fixed_var(struct isl_basic_map *bmap, +static int isl_basic_map_plain_has_fixed_var(__isl_keep isl_basic_map *bmap, unsigned pos, isl_int *val) { int i; @@ -6546,7 +6571,7 @@ static int isl_basic_map_fast_has_fixed_var(struct isl_basic_map *bmap, return 0; } -static int isl_map_fast_has_fixed_var(struct isl_map *map, +static int isl_map_plain_has_fixed_var(__isl_keep isl_map *map, unsigned pos, isl_int *val) { int i; @@ -6559,12 +6584,12 @@ static int isl_map_fast_has_fixed_var(struct isl_map *map, if (map->n == 0) return 0; if (map->n == 1) - return isl_basic_map_fast_has_fixed_var(map->p[0], pos, val); + return isl_basic_map_plain_has_fixed_var(map->p[0], pos, val); isl_int_init(v); isl_int_init(tmp); - fixed = isl_basic_map_fast_has_fixed_var(map->p[0], pos, &v); + fixed = isl_basic_map_plain_has_fixed_var(map->p[0], pos, &v); for (i = 1; fixed == 1 && i < map->n; ++i) { - fixed = isl_basic_map_fast_has_fixed_var(map->p[i], pos, &tmp); + fixed = isl_basic_map_plain_has_fixed_var(map->p[i], pos, &tmp); if (fixed == 1 && isl_int_ne(tmp, v)) fixed = 0; } @@ -6575,68 +6600,82 @@ static int isl_map_fast_has_fixed_var(struct isl_map *map, return fixed; } -static int isl_basic_set_fast_has_fixed_var(struct isl_basic_set *bset, +static int isl_basic_set_plain_has_fixed_var(__isl_keep isl_basic_set *bset, unsigned pos, isl_int *val) { - return isl_basic_map_fast_has_fixed_var((struct isl_basic_map *)bset, + return isl_basic_map_plain_has_fixed_var((struct isl_basic_map *)bset, pos, val); } -static int isl_set_fast_has_fixed_var(struct isl_set *set, unsigned pos, +static int isl_set_plain_has_fixed_var(__isl_keep isl_set *set, unsigned pos, isl_int *val) { - return isl_map_fast_has_fixed_var((struct isl_map *)set, pos, val); + return isl_map_plain_has_fixed_var((struct isl_map *)set, pos, val); } -int isl_basic_map_fast_is_fixed(struct isl_basic_map *bmap, +int isl_basic_map_plain_is_fixed(__isl_keep isl_basic_map *bmap, enum isl_dim_type type, unsigned pos, isl_int *val) { if (pos >= isl_basic_map_dim(bmap, type)) return -1; - return isl_basic_map_fast_has_fixed_var(bmap, + return isl_basic_map_plain_has_fixed_var(bmap, isl_basic_map_offset(bmap, type) - 1 + pos, val); } -int isl_map_fast_is_fixed(struct isl_map *map, +int isl_map_plain_is_fixed(__isl_keep isl_map *map, enum isl_dim_type type, unsigned pos, isl_int *val) { if (pos >= isl_map_dim(map, type)) return -1; - return isl_map_fast_has_fixed_var(map, + return isl_map_plain_has_fixed_var(map, map_offset(map, type) - 1 + pos, val); } +int isl_map_fast_is_fixed(__isl_keep isl_map *map, + enum isl_dim_type type, unsigned pos, isl_int *val) +{ + return isl_map_plain_is_fixed(map, type, pos, val); +} + /* Check if dimension dim has fixed value and if so and if val is not NULL, * then return this fixed value in *val. */ -int isl_basic_set_fast_dim_is_fixed(struct isl_basic_set *bset, unsigned dim, - isl_int *val) +int isl_basic_set_plain_dim_is_fixed(__isl_keep isl_basic_set *bset, + unsigned dim, isl_int *val) { - return isl_basic_set_fast_has_fixed_var(bset, + return isl_basic_set_plain_has_fixed_var(bset, isl_basic_set_n_param(bset) + dim, val); } /* Check if dimension dim has fixed value and if so and if val is not NULL, * then return this fixed value in *val. */ -int isl_set_fast_dim_is_fixed(struct isl_set *set, unsigned dim, isl_int *val) +int isl_set_plain_dim_is_fixed(__isl_keep isl_set *set, + unsigned dim, isl_int *val) +{ + return isl_set_plain_has_fixed_var(set, isl_set_n_param(set) + dim, val); +} + +int isl_set_fast_dim_is_fixed(__isl_keep isl_set *set, + unsigned dim, isl_int *val) { - return isl_set_fast_has_fixed_var(set, isl_set_n_param(set) + dim, val); + return isl_set_plain_dim_is_fixed(set, dim, val); } /* Check if input variable in has fixed value and if so and if val is not NULL, * then return this fixed value in *val. */ -int isl_map_fast_input_is_fixed(struct isl_map *map, unsigned in, isl_int *val) +int isl_map_plain_input_is_fixed(__isl_keep isl_map *map, + unsigned in, isl_int *val) { - return isl_map_fast_has_fixed_var(map, isl_map_n_param(map) + in, val); + return isl_map_plain_has_fixed_var(map, isl_map_n_param(map) + in, val); } /* Check if dimension dim has an (obvious) fixed lower bound and if so * and if val is not NULL, then return this lower bound in *val. */ -int isl_basic_set_fast_dim_has_fixed_lower_bound(struct isl_basic_set *bset, - unsigned dim, isl_int *val) +int isl_basic_set_plain_dim_has_fixed_lower_bound( + __isl_keep isl_basic_set *bset, unsigned dim, isl_int *val) { int i, i_eq = -1, i_ineq = -1; isl_int *c; @@ -6677,7 +6716,7 @@ int isl_basic_set_fast_dim_has_fixed_lower_bound(struct isl_basic_set *bset, return 1; } -int isl_set_fast_dim_has_fixed_lower_bound(struct isl_set *set, +int isl_set_plain_dim_has_fixed_lower_bound(__isl_keep isl_set *set, unsigned dim, isl_int *val) { int i; @@ -6690,14 +6729,14 @@ int isl_set_fast_dim_has_fixed_lower_bound(struct isl_set *set, if (set->n == 0) return 0; if (set->n == 1) - return isl_basic_set_fast_dim_has_fixed_lower_bound(set->p[0], + return isl_basic_set_plain_dim_has_fixed_lower_bound(set->p[0], dim, val); isl_int_init(v); isl_int_init(tmp); - fixed = isl_basic_set_fast_dim_has_fixed_lower_bound(set->p[0], + fixed = isl_basic_set_plain_dim_has_fixed_lower_bound(set->p[0], dim, &v); for (i = 1; fixed == 1 && i < set->n; ++i) { - fixed = isl_basic_set_fast_dim_has_fixed_lower_bound(set->p[i], + fixed = isl_basic_set_plain_dim_has_fixed_lower_bound(set->p[i], dim, &tmp); if (fixed == 1 && isl_int_ne(tmp, v)) fixed = 0; @@ -6785,7 +6824,7 @@ struct isl_basic_set *isl_basic_set_normalize(struct isl_basic_set *bset) (struct isl_basic_map *)bset); } -int isl_basic_map_fast_cmp(const __isl_keep isl_basic_map *bmap1, +int isl_basic_map_plain_cmp(const __isl_keep isl_basic_map *bmap1, const __isl_keep isl_basic_map *bmap2) { int i, cmp; @@ -6834,16 +6873,16 @@ int isl_basic_map_fast_cmp(const __isl_keep isl_basic_map *bmap1, return 0; } -int isl_basic_map_fast_is_equal(__isl_keep isl_basic_map *bmap1, +int isl_basic_map_plain_is_equal(__isl_keep isl_basic_map *bmap1, __isl_keep isl_basic_map *bmap2) { - return isl_basic_map_fast_cmp(bmap1, bmap2) == 0; + return isl_basic_map_plain_cmp(bmap1, bmap2) == 0; } -int isl_basic_set_fast_is_equal(__isl_keep isl_basic_set *bset1, +int isl_basic_set_plain_is_equal(__isl_keep isl_basic_set *bset1, __isl_keep isl_basic_set *bset2) { - return isl_basic_map_fast_is_equal((isl_basic_map *)bset1, + return isl_basic_map_plain_is_equal((isl_basic_map *)bset1, (isl_basic_map *)bset2); } @@ -6852,7 +6891,7 @@ static int qsort_bmap_cmp(const void *p1, const void *p2) const struct isl_basic_map *bmap1 = *(const struct isl_basic_map **)p1; const struct isl_basic_map *bmap2 = *(const struct isl_basic_map **)p2; - return isl_basic_map_fast_cmp(bmap1, bmap2); + return isl_basic_map_plain_cmp(bmap1, bmap2); } /* We normalize in place, but if anything goes wrong we need @@ -6881,7 +6920,7 @@ struct isl_map *isl_map_normalize(struct isl_map *map) if (!map) return NULL; for (i = map->n - 1; i >= 1; --i) { - if (!isl_basic_map_fast_is_equal(map->p[i-1], map->p[i])) + if (!isl_basic_map_plain_is_equal(map->p[i-1], map->p[i])) continue; isl_basic_map_free(map->p[i-1]); for (j = i; j < map->n; ++j) @@ -6900,7 +6939,7 @@ struct isl_set *isl_set_normalize(struct isl_set *set) return (struct isl_set *)isl_map_normalize((struct isl_map *)set); } -int isl_map_fast_is_equal(struct isl_map *map1, struct isl_map *map2) +int isl_map_plain_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2) { int i; int equal; @@ -6921,7 +6960,7 @@ int isl_map_fast_is_equal(struct isl_map *map1, struct isl_map *map2) goto error; equal = map1->n == map2->n; for (i = 0; equal && i < map1->n; ++i) { - equal = isl_basic_map_fast_is_equal(map1->p[i], map2->p[i]); + equal = isl_basic_map_plain_is_equal(map1->p[i], map2->p[i]); if (equal < 0) goto error; } @@ -6934,12 +6973,22 @@ error: return -1; } -int isl_set_fast_is_equal(struct isl_set *set1, struct isl_set *set2) +int isl_map_fast_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2) +{ + return isl_map_plain_is_equal(map1, map2); +} + +int isl_set_plain_is_equal(__isl_keep isl_set *set1, __isl_keep isl_set *set2) { - return isl_map_fast_is_equal((struct isl_map *)set1, + return isl_map_plain_is_equal((struct isl_map *)set1, (struct isl_map *)set2); } +int isl_set_fast_is_equal(__isl_keep isl_set *set1, __isl_keep isl_set *set2) +{ + return isl_set_plain_is_equal(set1, set2); +} + /* Return an interval that ranges from min to max (inclusive) */ struct isl_basic_set *isl_basic_set_interval(struct isl_ctx *ctx, @@ -7653,7 +7702,7 @@ int isl_basic_set_dims_get_sign(__isl_keep isl_basic_set *bset, * an equality that defines the output dimension in terms of * earlier dimensions. */ -int isl_basic_map_fast_is_single_valued(__isl_keep isl_basic_map *bmap) +int isl_basic_map_plain_is_single_valued(__isl_keep isl_basic_map *bmap) { int i, j; unsigned total; @@ -7684,7 +7733,7 @@ int isl_basic_map_fast_is_single_valued(__isl_keep isl_basic_map *bmap) /* Check if the given map is obviously single-valued. */ -int isl_map_fast_is_single_valued(__isl_keep isl_map *map) +int isl_map_plain_is_single_valued(__isl_keep isl_map *map) { int sv; @@ -7695,7 +7744,7 @@ int isl_map_fast_is_single_valued(__isl_keep isl_map *map) if (map->n >= 2) return 0; - return isl_basic_map_fast_is_single_valued(map->p[0]); + return isl_basic_map_plain_is_single_valued(map->p[0]); } /* Check if the given map is single-valued. @@ -7712,7 +7761,7 @@ int isl_map_is_single_valued(__isl_keep isl_map *map) isl_map *id; int sv; - sv = isl_map_fast_is_single_valued(map); + sv = isl_map_plain_is_single_valued(map); if (sv < 0 || sv) return sv; diff --git a/isl_map_private.h b/isl_map_private.h index 03fd911..7dbd67d 100644 --- a/isl_map_private.h +++ b/isl_map_private.h @@ -194,11 +194,11 @@ struct isl_basic_set *isl_basic_set_gauss( struct isl_basic_set *bset, int *progress); __isl_give isl_basic_set *isl_basic_set_sort_constraints( __isl_take isl_basic_set *bset); -int isl_basic_map_fast_cmp(const __isl_keep isl_basic_map *bmap1, +int isl_basic_map_plain_cmp(const __isl_keep isl_basic_map *bmap1, const __isl_keep isl_basic_map *bmap2); -int isl_basic_set_fast_is_equal(__isl_keep isl_basic_set *bset1, +int isl_basic_set_plain_is_equal(__isl_keep isl_basic_set *bset1, __isl_keep isl_basic_set *bset2); -int isl_basic_map_fast_is_equal(__isl_keep isl_basic_map *bmap1, +int isl_basic_map_plain_is_equal(__isl_keep isl_basic_map *bmap1, __isl_keep isl_basic_map *bmap2); struct isl_basic_map *isl_basic_map_normalize_constraints( struct isl_basic_map *bmap); diff --git a/isl_map_simplify.c b/isl_map_simplify.c index e733cbd..984eb58 100644 --- a/isl_map_simplify.c +++ b/isl_map_simplify.c @@ -1724,7 +1724,7 @@ static __isl_give isl_basic_set *uset_gist(__isl_take isl_basic_set *bset, goto error; bset = isl_basic_set_intersect(bset, isl_basic_set_copy(context)); - if (isl_basic_set_fast_is_empty(bset)) { + if (isl_basic_set_plain_is_empty(bset)) { isl_basic_set_free(context); return bset; } @@ -1732,7 +1732,7 @@ static __isl_give isl_basic_set *uset_gist(__isl_take isl_basic_set *bset, aff = isl_basic_set_affine_hull(isl_basic_set_copy(bset)); if (!aff) goto error; - if (isl_basic_set_fast_is_empty(aff)) { + if (isl_basic_set_plain_is_empty(aff)) { isl_basic_set_free(aff); isl_basic_set_free(context); return bset; @@ -1824,13 +1824,13 @@ struct isl_basic_map *isl_basic_map_gist(struct isl_basic_map *bmap, isl_basic_map_free(context); return bmap; } - if (isl_basic_map_fast_is_empty(context)) { + if (isl_basic_map_plain_is_empty(context)) { struct isl_dim *dim = isl_dim_copy(bmap->dim); isl_basic_map_free(context); isl_basic_map_free(bmap); return isl_basic_map_universe(dim); } - if (isl_basic_map_fast_is_empty(bmap)) { + if (isl_basic_map_plain_is_empty(bmap)) { isl_basic_map_free(context); return bmap; } @@ -1865,7 +1865,7 @@ __isl_give isl_map *isl_map_gist_basic_map(__isl_take isl_map *map, if (!map || !context) goto error;; - if (isl_basic_map_fast_is_empty(context)) { + if (isl_basic_map_plain_is_empty(context)) { struct isl_dim *dim = isl_dim_copy(map->dim); isl_basic_map_free(context); isl_map_free(map); @@ -1885,7 +1885,7 @@ __isl_give isl_map *isl_map_gist_basic_map(__isl_take isl_map *map, isl_basic_map_copy(context)); if (!map->p[i]) goto error; - if (isl_basic_map_fast_is_empty(map->p[i])) { + if (isl_basic_map_plain_is_empty(map->p[i])) { isl_basic_map_free(map->p[i]); if (i != map->n - 1) map->p[i] = map->p[map->n - 1]; @@ -1934,8 +1934,8 @@ __isl_give isl_set *isl_set_gist(__isl_take isl_set *set, * one basic map in the context of the equalities of the other * basic map and check if we get a contradiction. */ -int isl_basic_map_fast_is_disjoint(struct isl_basic_map *bmap1, - struct isl_basic_map *bmap2) +int isl_basic_map_plain_is_disjoint(__isl_keep isl_basic_map *bmap1, + __isl_keep isl_basic_map *bmap2) { struct isl_vec *v = NULL; int *elim = NULL; @@ -1999,26 +1999,27 @@ error: return -1; } -int isl_basic_set_fast_is_disjoint(struct isl_basic_set *bset1, - struct isl_basic_set *bset2) +int isl_basic_set_plain_is_disjoint(__isl_keep isl_basic_set *bset1, + __isl_keep isl_basic_set *bset2) { - return isl_basic_map_fast_is_disjoint((struct isl_basic_map *)bset1, + return isl_basic_map_plain_is_disjoint((struct isl_basic_map *)bset1, (struct isl_basic_map *)bset2); } -int isl_map_fast_is_disjoint(struct isl_map *map1, struct isl_map *map2) +int isl_map_plain_is_disjoint(__isl_keep isl_map *map1, + __isl_keep isl_map *map2) { int i, j; if (!map1 || !map2) return -1; - if (isl_map_fast_is_equal(map1, map2)) + if (isl_map_plain_is_equal(map1, map2)) return 0; for (i = 0; i < map1->n; ++i) { for (j = 0; j < map2->n; ++j) { - int d = isl_basic_map_fast_is_disjoint(map1->p[i], + int d = isl_basic_map_plain_is_disjoint(map1->p[i], map2->p[j]); if (d != 1) return d; @@ -2027,12 +2028,18 @@ int isl_map_fast_is_disjoint(struct isl_map *map1, struct isl_map *map2) return 1; } -int isl_set_fast_is_disjoint(struct isl_set *set1, struct isl_set *set2) +int isl_set_plain_is_disjoint(__isl_keep isl_set *set1, + __isl_keep isl_set *set2) { - return isl_map_fast_is_disjoint((struct isl_map *)set1, + return isl_map_plain_is_disjoint((struct isl_map *)set1, (struct isl_map *)set2); } +int isl_set_fast_is_disjoint(__isl_keep isl_set *set1, __isl_keep isl_set *set2) +{ + return isl_set_plain_is_disjoint(set1, set2); +} + /* Check if we can combine a given div with lower bound l and upper * bound u with some other div and if so return that other div. * Otherwise return -1. diff --git a/isl_map_subtract.c b/isl_map_subtract.c index dc20d91..1cdd68e 100644 --- a/isl_map_subtract.c +++ b/isl_map_subtract.c @@ -560,7 +560,7 @@ static int basic_map_diff_is_empty(__isl_keep isl_basic_map *bmap, int r; struct isl_is_empty_diff_collector edc; - r = isl_basic_map_fast_is_empty(bmap); + r = isl_basic_map_plain_is_empty(bmap); if (r) return r; @@ -596,7 +596,7 @@ static int map_diff_is_empty(__isl_keep isl_map *map1, __isl_keep isl_map *map2) /* Return 1 if "bmap" contains a single element. */ -int isl_basic_map_fast_is_singleton(__isl_keep isl_basic_map *bmap) +int isl_basic_map_plain_is_singleton(__isl_keep isl_basic_map *bmap) { if (!bmap) return -1; @@ -609,14 +609,14 @@ int isl_basic_map_fast_is_singleton(__isl_keep isl_basic_map *bmap) /* Return 1 if "map" contains a single element. */ -int isl_map_fast_is_singleton(__isl_keep isl_map *map) +int isl_map_plain_is_singleton(__isl_keep isl_map *map) { if (!map) return -1; if (map->n != 1) return 0; - return isl_basic_map_fast_is_singleton(map->p[0]); + return isl_basic_map_plain_is_singleton(map->p[0]); } /* Given a singleton basic map, extract the single element @@ -717,11 +717,11 @@ int isl_map_is_subset(struct isl_map *map1, struct isl_map *map2) if (isl_map_is_empty(map2)) return 0; - if (isl_map_fast_is_universe(map2)) + if (isl_map_plain_is_universe(map2)) return 1; map2 = isl_map_compute_divs(isl_map_copy(map2)); - if (isl_map_fast_is_singleton(map1)) { + if (isl_map_plain_is_singleton(map1)) { is_subset = map_is_singleton_subset(map1, map2); isl_map_free(map2); return is_subset; diff --git a/isl_morph.c b/isl_morph.c index 24b1762..ed372ef 100644 --- a/isl_morph.c +++ b/isl_morph.c @@ -335,7 +335,7 @@ __isl_give isl_morph *isl_basic_set_variable_compression( if (!bset) return NULL; - if (isl_basic_set_fast_is_empty(bset)) + if (isl_basic_set_plain_is_empty(bset)) return isl_morph_empty(bset); isl_assert(bset->ctx, bset->n_div == 0, return NULL); @@ -452,7 +452,7 @@ __isl_give isl_morph *isl_basic_set_parameter_compression( if (!bset) return NULL; - if (isl_basic_set_fast_is_empty(bset)) + if (isl_basic_set_plain_is_empty(bset)) return isl_morph_empty(bset); if (bset->n_eq == 0) return isl_morph_identity(bset); diff --git a/isl_output.c b/isl_output.c index e0858de..03f9e1b 100644 --- a/isl_output.c +++ b/isl_output.c @@ -666,7 +666,7 @@ static __isl_give isl_printer *print_disjuncts(__isl_keep isl_map *map, { int i; - if (isl_map_fast_is_universe(map)) + if (isl_map_plain_is_universe(map)) return p; p = isl_printer_print_str(p, s_such_that[latex]); @@ -743,7 +743,7 @@ static int aff_split_cmp(const void *p1, const void *p2) s1 = (const struct isl_aff_split *) p1; s2 = (const struct isl_aff_split *) p2; - return isl_basic_map_fast_cmp(s1->aff, s2->aff); + return isl_basic_map_plain_cmp(s1->aff, s2->aff); } static __isl_give isl_basic_map *drop_aff(__isl_take isl_basic_map *bmap, @@ -801,7 +801,7 @@ static __isl_give struct isl_aff_split *split_aff(__isl_keep isl_map *map) n = map->n; for (i = n - 1; i >= 1; --i) { - if (!isl_basic_map_fast_is_equal(split[i - 1].aff, + if (!isl_basic_map_plain_is_equal(split[i - 1].aff, split[i].aff)) continue; isl_basic_map_free(split[i].aff); @@ -1821,7 +1821,7 @@ static __isl_give isl_printer *print_pw_qpolynomial_c( { int i; - if (pwqp->n == 1 && isl_set_fast_is_universe(pwqp->p[0].set)) + if (pwqp->n == 1 && isl_set_plain_is_universe(pwqp->p[0].set)) return print_qpolynomial_c(p, pwqp->dim, pwqp->p[0].qp); for (i = 0; i < pwqp->n; ++i) { @@ -1945,7 +1945,7 @@ static __isl_give isl_printer *print_pw_qpolynomial_fold_c( { int i; - if (pwf->n == 1 && isl_set_fast_is_universe(pwf->p[0].set)) + if (pwf->n == 1 && isl_set_plain_is_universe(pwf->p[0].set)) return print_qpolynomial_fold_c(p, pwf->dim, pwf->p[0].fold); for (i = 0; i < pwf->n; ++i) { diff --git a/isl_polynomial.c b/isl_polynomial.c index 4ac53ab..2a3b2c0 100644 --- a/isl_polynomial.c +++ b/isl_polynomial.c @@ -2472,7 +2472,7 @@ int isl_pw_qpolynomial_is_one(__isl_keep isl_pw_qpolynomial *pwqp) if (pwqp->n != -1) return 0; - if (!isl_set_fast_is_universe(pwqp->p[0].set)) + if (!isl_set_plain_is_universe(pwqp->p[0].set)) return 0; return isl_qpolynomial_is_one(pwqp->p[0].qp); @@ -2521,7 +2521,7 @@ __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_mul( struct isl_qpolynomial *prod; common = isl_set_intersect(isl_set_copy(pwqp1->p[i].set), isl_set_copy(pwqp2->p[j].set)); - if (isl_set_fast_is_empty(common)) { + if (isl_set_plain_is_empty(common)) { isl_set_free(common); continue; } @@ -4209,7 +4209,7 @@ __isl_give isl_pw_qpolynomial *isl_basic_set_multiplicative_call( if (!bset) return NULL; - if (isl_basic_set_fast_is_empty(bset)) + if (isl_basic_set_plain_is_empty(bset)) return constant_on_domain(bset, 0); orig_nvar = isl_basic_set_dim(bset, isl_dim_set); diff --git a/isl_pw_templ.c b/isl_pw_templ.c index da4b53e..f2fc508 100644 --- a/isl_pw_templ.c +++ b/isl_pw_templ.c @@ -51,7 +51,7 @@ __isl_give PW *FN(PW,add_piece)(__isl_take PW *pw, if (!pw || !set || !el) goto error; - if (isl_set_fast_is_empty(set) || FN(EL,IS_ZERO)(el)) { + if (isl_set_plain_is_empty(set) || FN(EL,IS_ZERO)(el)) { isl_set_free(set); FN(EL,free)(el); return pw; @@ -215,7 +215,7 @@ __isl_give PW *FN(PW,add)(__isl_take PW *pw1, __isl_take PW *pw2) isl_set_copy(pw2->p[j].set)); common = isl_set_intersect(isl_set_copy(pw1->p[i].set), isl_set_copy(pw2->p[j].set)); - if (isl_set_fast_is_empty(common)) { + if (isl_set_plain_is_empty(common)) { isl_set_free(common); continue; } @@ -371,7 +371,7 @@ __isl_give PW *FN(PW,intersect_domain)(__isl_take PW *pw, __isl_take isl_set *se aff = isl_set_affine_hull(isl_set_copy(pw->p[i].set)); pw->p[i].FIELD = FN(EL,substitute_equalities)(pw->p[i].FIELD, aff); - if (isl_set_fast_is_empty(pw->p[i].set)) { + if (isl_set_plain_is_empty(pw->p[i].set)) { isl_set_free(pw->p[i].set); FN(EL,free)(pw->p[i].FIELD); if (i != pw->n - 1) @@ -419,7 +419,7 @@ __isl_give PW *FN(PW,gist)(__isl_take PW *pw, __isl_take isl_set *context) isl_basic_set_copy(hull)); if (!pw->p[i].set) goto error; - if (isl_set_fast_is_empty(pw->p[i].set)) { + if (isl_set_plain_is_empty(pw->p[i].set)) { isl_set_free(pw->p[i].set); FN(EL,free)(pw->p[i].FIELD); if (i != pw->n - 1) diff --git a/isl_sample.c b/isl_sample.c index 80b0031..9c9fb6d 100644 --- a/isl_sample.c +++ b/isl_sample.c @@ -57,7 +57,7 @@ static struct isl_vec *interval_sample(struct isl_basic_set *bset) bset = isl_basic_set_simplify(bset); if (!bset) return NULL; - if (isl_basic_set_fast_is_empty(bset)) + if (isl_basic_set_plain_is_empty(bset)) return empty_sample(bset); if (bset->n_eq == 0 && bset->n_ineq == 0) return zero_sample(bset); @@ -636,7 +636,7 @@ static struct isl_vec *sample_bounded(struct isl_basic_set *bset) if (!bset) return NULL; - if (isl_basic_set_fast_is_empty(bset)) + if (isl_basic_set_plain_is_empty(bset)) return empty_sample(bset); dim = isl_basic_set_total_dim(bset); @@ -1178,7 +1178,7 @@ static struct isl_vec *basic_set_sample(struct isl_basic_set *bset, int bounded) return NULL; ctx = bset->ctx; - if (isl_basic_set_fast_is_empty(bset)) + if (isl_basic_set_plain_is_empty(bset)) return empty_sample(bset); dim = isl_basic_set_n_dim(bset); diff --git a/isl_schedule.c b/isl_schedule.c index 3c79dcb..66c0ed5 100644 --- a/isl_schedule.c +++ b/isl_schedule.c @@ -321,7 +321,7 @@ static int graph_has_edge(struct isl_sched_graph *graph, return 0; edge = entry->data; - empty = isl_map_fast_is_empty(edge->map); + empty = isl_map_plain_is_empty(edge->map); if (empty < 0) return -1; @@ -466,7 +466,7 @@ static int extract_edge(__isl_take isl_map *map, void *user) if (!entry) return 0; edge = entry->data; - is_equal = isl_map_fast_is_equal(map, edge->map); + is_equal = isl_map_plain_is_equal(map, edge->map); if (is_equal < 0) return -1; if (!is_equal) @@ -1424,7 +1424,7 @@ static int update_edges(isl_ctx *ctx, struct isl_sched_graph *graph) if (!edge->map) return -1; - if (isl_map_fast_is_empty(edge->map)) { + if (isl_map_plain_is_empty(edge->map)) { reset_table = 1; isl_map_free(edge->map); if (i != graph->n_edge - 1) @@ -1588,7 +1588,7 @@ static int copy_edges(isl_ctx *ctx, struct isl_sched_graph *dst, if (!edge_pred(edge, data)) continue; - if (isl_map_fast_is_empty(edge->map)) + if (isl_map_plain_is_empty(edge->map)) continue; map = isl_map_copy(edge->map); diff --git a/isl_tab_pip.c b/isl_tab_pip.c index d91e36b..62b4cd1 100644 --- a/isl_tab_pip.c +++ b/isl_tab_pip.c @@ -3985,9 +3985,9 @@ static __isl_give isl_map *basic_map_partial_lexopt_base( goto error; context = sol_map->sol.context; - if (isl_basic_set_fast_is_empty(context->op->peek_basic_set(context))) + if (isl_basic_set_plain_is_empty(context->op->peek_basic_set(context))) /* nothing */; - else if (isl_basic_map_fast_is_empty(bmap)) + else if (isl_basic_map_plain_is_empty(bmap)) sol_map_add_empty_if_needed(sol_map, isl_basic_set_copy(context->op->peek_basic_set(context))); else { @@ -4638,7 +4638,7 @@ int isl_basic_map_foreach_lexopt(__isl_keep isl_basic_map *bmap, int max, bmap = isl_basic_map_detect_equalities(bmap); sol_for = sol_for_init(bmap, max, fn, user); - if (isl_basic_map_fast_is_empty(bmap)) + if (isl_basic_map_plain_is_empty(bmap)) /* nothing */; else { struct isl_tab *tab; diff --git a/isl_transitive_closure.c b/isl_transitive_closure.c index 629eb74..d72c0c7 100644 --- a/isl_transitive_closure.c +++ b/isl_transitive_closure.c @@ -769,7 +769,7 @@ static __isl_give isl_map *construct_extended_path(__isl_take isl_dim *dim, for (j = 0; j < d; ++j) { int fixed; - fixed = isl_basic_set_fast_dim_is_fixed(delta, j, + fixed = isl_basic_set_plain_dim_is_fixed(delta, j, &steps->row[n][j]); if (fixed < 0) { isl_basic_set_free(delta); @@ -2161,7 +2161,7 @@ __isl_give isl_map *isl_map_power(__isl_take isl_map *map, int *exact) map = isl_map_compute_divs(map); map = isl_map_coalesce(map); - if (isl_map_fast_is_empty(map)) { + if (isl_map_plain_is_empty(map)) { map = isl_map_from_range(isl_map_wrap(map)); map = isl_map_add_dims(map, isl_dim_in, 1); map = isl_map_set_dim_name(map, isl_dim_in, 0, "k"); @@ -2215,7 +2215,7 @@ __isl_give isl_map *isl_map_reaching_path_lengths(__isl_take isl_map *map, map = isl_map_compute_divs(map); map = isl_map_coalesce(map); - if (isl_map_fast_is_empty(map)) { + if (isl_map_plain_is_empty(map)) { if (exact) *exact = 1; map = isl_map_project_out(map, isl_dim_out, 0, d); diff --git a/isl_union_map.c b/isl_union_map.c index f384fd5..530ec59 100644 --- a/isl_union_map.c +++ b/isl_union_map.c @@ -259,7 +259,7 @@ __isl_give isl_union_map *isl_union_map_add_map(__isl_take isl_union_map *umap, uint32_t hash; struct isl_hash_table_entry *entry; - if (isl_map_fast_is_empty(map)) { + if (isl_map_plain_is_empty(map)) { isl_map_free(map); return umap; } @@ -1452,7 +1452,7 @@ static int sample_entry(void **entry, void *user) *sample = isl_map_sample(isl_map_copy(map)); if (!*sample) return -1; - if (!isl_basic_map_fast_is_empty(*sample)) + if (!isl_basic_map_plain_is_empty(*sample)) return -1; return 0; } diff --git a/isl_vertices.c b/isl_vertices.c index 9c98330..1dd0f03 100644 --- a/isl_vertices.c +++ b/isl_vertices.c @@ -403,7 +403,7 @@ __isl_give isl_vertices *isl_basic_set_compute_vertices( if (!bset) return NULL; - if (isl_basic_set_fast_is_empty(bset)) + if (isl_basic_set_plain_is_empty(bset)) return vertices_empty(bset); if (bset->n_eq != 0) @@ -771,7 +771,7 @@ static int has_opposite(struct isl_facet_todo *todo, { for (; *list; list = &(*list)->next) { int eq; - eq = isl_basic_set_fast_is_equal(todo->bset, (*list)->bset); + eq = isl_basic_set_plain_is_equal(todo->bset, (*list)->bset); if (eq < 0) return -1; if (!eq) diff --git a/pip.c b/pip.c index eed7a3c..7977431 100644 --- a/pip.c +++ b/pip.c @@ -122,7 +122,7 @@ struct isl_vec *opt_at(struct isl_basic_set *bset, bset = plug_in_parameters(bset, params); - if (isl_basic_set_fast_is_empty(bset)) { + if (isl_basic_set_plain_is_empty(bset)) { opt = isl_vec_alloc(bset->ctx, 0); isl_basic_set_free(bset); return opt; -- 2.7.4