if (!bmap)
return bmap;
- if (F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
+ if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
return bmap;
- if (F_ISSET(bmap, ISL_BASIC_MAP_NO_IMPLICIT))
+ if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_NO_IMPLICIT))
return bmap;
ctx = bmap->ctx;
- rational = F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL);
+ rational = ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL);
isl_int_init(opt);
isl_int_init(opt_denom);
if (!rational)
isl_int_clear(opt_denom);
isl_int_clear(opt);
- F_SET(bmap, ISL_BASIC_MAP_NO_IMPLICIT);
+ ISL_F_SET(bmap, ISL_BASIC_MAP_NO_IMPLICIT);
return bmap;
error:
isl_int_clear(opt);
dim = isl_basic_set_n_dim(bset);
for (i = 0; i < dim; ++i) {
struct isl_basic_set *point;
- if (F_ISSET(hull, ISL_BASIC_SET_EMPTY))
+ if (ISL_F_ISSET(hull, ISL_BASIC_SET_EMPTY))
break;
for (j = 0; j < hull->n_eq; ++j) {
point = outside_point(ctx, bset, hull->eq[j], 1);
if (!point)
goto error;
- if (!F_ISSET(point, ISL_BASIC_SET_EMPTY))
+ if (!ISL_F_ISSET(point, ISL_BASIC_SET_EMPTY))
break;
isl_basic_set_free(point);
point = outside_point(ctx, bset, hull->eq[j], 0);
if (!point)
goto error;
- if (!F_ISSET(point, ISL_BASIC_SET_EMPTY))
+ if (!ISL_F_ISSET(point, ISL_BASIC_SET_EMPTY))
break;
isl_basic_set_free(point);
}
return NULL;
if (bmap->n_ineq == 0)
return bmap;
- if (F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
+ if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
return bmap;
- if (F_ISSET(bmap, ISL_BASIC_MAP_ALL_EQUALITIES))
+ if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_ALL_EQUALITIES))
return bmap;
- if (F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
+ if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
return isl_basic_map_implicit_equalities(bmap);
hull = equalities_in_underlying_set(isl_basic_map_copy(bmap));
1 + isl_basic_set_total_dim(hull));
}
isl_basic_set_free(hull);
- F_SET(bmap, ISL_BASIC_MAP_NO_IMPLICIT | ISL_BASIC_MAP_ALL_EQUALITIES);
+ ISL_F_SET(bmap, ISL_BASIC_MAP_NO_IMPLICIT | ISL_BASIC_MAP_ALL_EQUALITIES);
bmap = isl_basic_map_simplify(bmap);
return isl_basic_map_finalize(bmap);
error:
if (bmap->n_ineq == 0)
return bmap;
- if (F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL)) {
+ if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL)) {
bmap = isl_basic_map_cow(bmap);
isl_basic_map_free_inequality(bmap, bmap->n_ineq);
return bmap;
int j = isl_basic_map_alloc_div(dst);
isl_seq_cpy(dst->div[j], src->div[i], 1+1+total);
}
- F_SET(dst, ISL_BASIC_SET_FINAL);
+ ISL_F_SET(dst, ISL_BASIC_SET_FINAL);
}
struct isl_basic_map *isl_basic_map_dup(struct isl_basic_map *bmap)
if (!bset)
return NULL;
- if (F_ISSET(bset, ISL_BASIC_SET_FINAL)) {
+ if (ISL_F_ISSET(bset, ISL_BASIC_SET_FINAL)) {
bset->ref++;
return bset;
}
if (!bmap)
return NULL;
- if (F_ISSET(bmap, ISL_BASIC_SET_FINAL)) {
+ if (ISL_F_ISSET(bmap, ISL_BASIC_SET_FINAL)) {
bmap->ref++;
return bmap;
}
isl_seq_clr(bmap->eq[bmap->n_eq] +
1 + isl_basic_map_total_dim(bmap),
bmap->extra - bmap->n_div);
- F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
+ ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
return bmap->n_eq++;
}
bmap->n_eq++;
bmap->n_ineq--;
bmap->ineq++;
- F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
- F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
- F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES);
+ ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
+ ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
+ ISL_F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES);
}
int isl_basic_map_alloc_inequality(struct isl_basic_map *bmap)
ctx = bmap->ctx;
isl_assert(ctx, (bmap->ineq - bmap->eq) + bmap->n_ineq < bmap->c_size,
return -1);
- F_CLR(bmap, ISL_BASIC_MAP_NO_IMPLICIT);
- F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT);
- F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
- F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES);
+ ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_IMPLICIT);
+ ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT);
+ ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
+ ISL_F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES);
isl_seq_clr(bmap->ineq[bmap->n_ineq] +
1 + isl_basic_map_total_dim(bmap),
bmap->extra - bmap->n_div);
t = bmap->ineq[pos];
bmap->ineq[pos] = bmap->ineq[bmap->n_ineq - 1];
bmap->ineq[bmap->n_ineq - 1] = t;
- F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
+ ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
}
bmap->n_ineq--;
return 0;
isl_seq_clr(bmap->div[bmap->n_div] +
1 + 1 + isl_basic_map_total_dim(bmap),
bmap->extra - bmap->n_div);
- F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
+ ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
return bmap->n_div++;
}
ext = add_constraints(ext, base, 0, 0);
if (ext) {
ext->flags = flags;
- F_CLR(ext, ISL_BASIC_SET_FINAL);
+ ISL_F_CLR(ext, ISL_BASIC_SET_FINAL);
}
return ext;
bmap->ref--;
bmap = isl_basic_map_dup(bmap);
}
- F_CLR(bmap, ISL_BASIC_SET_FINAL);
+ ISL_F_CLR(bmap, ISL_BASIC_SET_FINAL);
return bmap;
}
isl_blk_free(bset->ctx, blk);
- F_CLR(bset, ISL_BASIC_SET_NORMALIZED);
+ ISL_F_CLR(bset, ISL_BASIC_SET_NORMALIZED);
return bset;
error:
return NULL;
}
}
- F_CLR(set, ISL_SET_NORMALIZED);
+ ISL_F_CLR(set, ISL_SET_NORMALIZED);
return set;
}
}
isl_int_set_si(bmap->eq[i][0], 1);
isl_seq_clr(bmap->eq[i]+1, total);
- F_SET(bmap, ISL_BASIC_MAP_EMPTY);
+ ISL_F_SET(bmap, ISL_BASIC_MAP_EMPTY);
return isl_basic_map_finalize(bmap);
error:
isl_basic_map_free(bmap);
for (i = 0; i < bmap->n_div; ++i)
isl_int_swap(bmap->div[i][1+1+off+a], bmap->div[i][1+1+off+b]);
- F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
+ ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
}
/* Eliminate the specified n dimensions starting at first from the
isl_assert(bmap->ctx, pos < bmap->n_ineq, return -1);
isl_seq_neg(bmap->ineq[pos], bmap->ineq[pos], 1 + total);
isl_int_sub_ui(bmap->ineq[pos][0], bmap->ineq[pos][0], 1);
- F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
+ ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
return 0;
}
isl_assert(map1->ctx,
isl_dim_equal(map1->dim, map2->dim), goto error);
- if (F_ISSET(map1, ISL_MAP_DISJOINT) &&
- F_ISSET(map2, ISL_MAP_DISJOINT))
- FL_SET(flags, ISL_MAP_DISJOINT);
+ if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) &&
+ ISL_F_ISSET(map2, ISL_MAP_DISJOINT))
+ ISL_FL_SET(flags, ISL_MAP_DISJOINT);
result = isl_map_alloc_dim(isl_dim_copy(map1->dim),
map1->n * map2->n, flags);
if (!set->p[i])
goto error;
}
- F_CLR(set, ISL_MAP_DISJOINT);
- F_CLR(set, ISL_SET_NORMALIZED);
+ ISL_F_CLR(set, ISL_MAP_DISJOINT);
+ ISL_F_CLR(set, ISL_SET_NORMALIZED);
return set;
error:
isl_map_free(map);
isl_assert(map->ctx, map->n < map->size, goto error);
map->p[map->n] = bmap;
map->n++;
- F_CLR(map, ISL_MAP_NORMALIZED);
+ ISL_F_CLR(map, ISL_MAP_NORMALIZED);
return map;
error:
if (map)
if (!map->p[i])
goto error;
}
- F_CLR(map, ISL_MAP_NORMALIZED);
+ ISL_F_CLR(map, ISL_MAP_NORMALIZED);
return map;
error:
isl_map_free(map);
if (!map->p[i])
goto error;
}
- F_CLR(map, ISL_MAP_NORMALIZED);
+ ISL_F_CLR(map, ISL_MAP_NORMALIZED);
return map;
error:
isl_map_free(map);
for (i = 1 ; i < map->n; ++i) {
struct isl_map *r2;
r2 = isl_basic_map_compute_divs(isl_basic_map_copy(map->p[i]));
- if (F_ISSET(map, ISL_MAP_DISJOINT))
+ if (ISL_F_ISSET(map, ISL_MAP_DISJOINT))
res = isl_map_union_disjoint(res, r2);
else
res = isl_map_union(res, r2);
if (!set->p[i])
goto error;
}
- F_CLR(set, ISL_MAP_DISJOINT);
- F_CLR(set, ISL_SET_NORMALIZED);
+ ISL_F_CLR(set, ISL_MAP_DISJOINT);
+ ISL_F_CLR(set, ISL_SET_NORMALIZED);
return set;
error:
isl_map_free(map);
isl_assert(map1->ctx, isl_dim_equal(map1->dim, map2->dim), goto error);
- if (F_ISSET(map1, ISL_MAP_DISJOINT) &&
- F_ISSET(map2, ISL_MAP_DISJOINT))
- FL_SET(flags, ISL_MAP_DISJOINT);
+ if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) &&
+ ISL_F_ISSET(map2, ISL_MAP_DISJOINT))
+ ISL_FL_SET(flags, ISL_MAP_DISJOINT);
map = isl_map_alloc_dim(isl_dim_copy(map1->dim),
map1->n + map2->n, flags);
if (!map1)
return NULL;
if (map1->n > 1)
- F_CLR(map1, ISL_MAP_DISJOINT);
+ ISL_F_CLR(map1, ISL_MAP_DISJOINT);
return map1;
}
if (!map || !set)
goto error;
- if (F_ISSET(map, ISL_MAP_DISJOINT) &&
- F_ISSET(set, ISL_MAP_DISJOINT))
- FL_SET(flags, ISL_MAP_DISJOINT);
+ if (ISL_F_ISSET(map, ISL_MAP_DISJOINT) &&
+ ISL_F_ISSET(set, ISL_MAP_DISJOINT))
+ ISL_FL_SET(flags, ISL_MAP_DISJOINT);
result = isl_map_alloc_dim(isl_dim_copy(map->dim),
map->n * set->n, flags);
isl_map_free(map1);
isl_map_free(map2);
if (result && result->n <= 1)
- F_SET(result, ISL_MAP_DISJOINT);
+ ISL_F_SET(result, ISL_MAP_DISJOINT);
return result;
error:
isl_map_free(map1);
if (!bmap)
return -1;
- if (F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
+ if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
return 1;
- if (F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL)) {
+ if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL)) {
struct isl_basic_map *copy = isl_basic_map_copy(bmap);
copy = isl_basic_map_convex_hull(copy);
- empty = F_ISSET(copy, ISL_BASIC_MAP_EMPTY);
+ empty = ISL_F_ISSET(copy, ISL_BASIC_MAP_EMPTY);
isl_basic_map_free(copy);
return empty;
}
for (i = 1; i < map->n; ++i)
map->p[i] = isl_basic_map_align_divs(map->p[i], map->p[0]);
- F_CLR(map, ISL_MAP_NORMALIZED);
+ ISL_F_CLR(map, ISL_MAP_NORMALIZED);
return map;
}
if (!map)
goto error;
- if (F_ISSET(map, ISL_MAP_DISJOINT))
- FL_SET(flags, ISL_MAP_DISJOINT);
+ if (ISL_F_ISSET(map, ISL_MAP_DISJOINT))
+ ISL_FL_SET(flags, ISL_MAP_DISJOINT);
max = map->n * (2 * bmap->n_eq + bmap->n_ineq);
rest = isl_map_alloc_dim(isl_dim_copy(map->dim), max, flags);
return NULL;
for (i = map->n-1; i >= 0; --i) {
- if (!F_ISSET(map->p[i], ISL_BASIC_MAP_EMPTY))
+ if (!ISL_F_ISSET(map->p[i], ISL_BASIC_MAP_EMPTY))
continue;
isl_basic_map_free(map->p[i]);
if (i != map->n-1) {
- F_CLR(map, ISL_MAP_NORMALIZED);
+ ISL_F_CLR(map, ISL_MAP_NORMALIZED);
map->p[i] = map->p[map->n-1];
}
map->n--;
if (!map || map->n == 0)
return NULL;
bmap = map->p[map->n-1];
- isl_assert(map->ctx, F_ISSET(bmap, ISL_BASIC_SET_FINAL), return NULL);
+ isl_assert(map->ctx, ISL_F_ISSET(bmap, ISL_BASIC_SET_FINAL), return NULL);
return isl_basic_map_copy(bmap);
}
goto error;
isl_basic_map_free(map->p[i]);
if (i != map->n-1) {
- F_CLR(map, ISL_SET_NORMALIZED);
+ ISL_F_CLR(map, ISL_SET_NORMALIZED);
map->p[i] = map->p[map->n-1];
}
map->n--;
{
if (!bmap)
return NULL;
- if (F_ISSET(bmap, ISL_BASIC_MAP_NORMALIZED))
+ if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_NORMALIZED))
return bmap;
bmap = isl_basic_map_convex_hull(bmap);
bmap = isl_basic_map_sort_constraints(bmap);
- F_SET(bmap, ISL_BASIC_MAP_NORMALIZED);
+ ISL_F_SET(bmap, ISL_BASIC_MAP_NORMALIZED);
return bmap;
}
return isl_basic_map_n_out(bmap1) - isl_basic_map_n_out(bmap2);
if (isl_basic_map_n_out(bmap1) != isl_basic_map_n_out(bmap2))
return isl_basic_map_n_out(bmap1) - isl_basic_map_n_out(bmap2);
- if (F_ISSET(bmap1, ISL_BASIC_MAP_EMPTY) &&
- F_ISSET(bmap2, ISL_BASIC_MAP_EMPTY))
+ if (ISL_F_ISSET(bmap1, ISL_BASIC_MAP_EMPTY) &&
+ ISL_F_ISSET(bmap2, ISL_BASIC_MAP_EMPTY))
return 0;
- if (F_ISSET(bmap1, ISL_BASIC_MAP_EMPTY))
+ if (ISL_F_ISSET(bmap1, ISL_BASIC_MAP_EMPTY))
return 1;
- if (F_ISSET(bmap2, ISL_BASIC_MAP_EMPTY))
+ if (ISL_F_ISSET(bmap2, ISL_BASIC_MAP_EMPTY))
return -1;
if (bmap1->n_eq != bmap2->n_eq)
return bmap1->n_eq - bmap2->n_eq;
if (!map)
return NULL;
- if (F_ISSET(map, ISL_MAP_NORMALIZED))
+ if (ISL_F_ISSET(map, ISL_MAP_NORMALIZED))
return map;
for (i = 0; i < map->n; ++i) {
bmap = isl_basic_map_normalize(isl_basic_map_copy(map->p[i]));
map->p[i] = bmap;
}
qsort(map->p, map->n, sizeof(struct isl_basic_map *), qsort_bmap_cmp);
- F_SET(map, ISL_MAP_NORMALIZED);
+ ISL_F_SET(map, ISL_MAP_NORMALIZED);
map = isl_map_remove_empty_parts(map);
if (!map)
return NULL;
isl_assert(map1->ctx, isl_dim_match(map1->dim, isl_dim_param,
map2->dim, isl_dim_param), goto error);
- if (F_ISSET(map1, ISL_MAP_DISJOINT) &&
- F_ISSET(map2, ISL_MAP_DISJOINT))
- FL_SET(flags, ISL_MAP_DISJOINT);
+ if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) &&
+ ISL_F_ISSET(map2, ISL_MAP_DISJOINT))
+ ISL_FL_SET(flags, ISL_MAP_DISJOINT);
result = isl_map_alloc_dim(isl_dim_product(isl_dim_copy(map1->dim),
isl_dim_copy(map2->dim)),
if (!bset->dim)
goto error;
- F_CLR(bset, ISL_BASIC_SET_NORMALIZED);
+ ISL_F_CLR(bset, ISL_BASIC_SET_NORMALIZED);
bset = isl_basic_set_simplify(bset);
return isl_basic_set_finalize(bset);
error:
goto error;
}
- F_CLR(set, ISL_SET_NORMALIZED);
+ ISL_F_CLR(set, ISL_SET_NORMALIZED);
return set;
error:
isl_set_free(set);
if (!bmap->dim)
goto error;
- F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
+ ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
bmap = isl_basic_map_simplify(bmap);
return isl_basic_map_finalize(bmap);
error:
if (!map->p[i])
goto error;
}
- F_CLR(map, ISL_MAP_NORMALIZED);
+ ISL_F_CLR(map, ISL_MAP_NORMALIZED);
return map;
error:
bmap->div[bmap->n_div - 1] = t;
}
- F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
+ ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
isl_basic_map_free_div(bmap, 1);
return bmap;
isl_basic_map_drop_equality(bmap, i);
continue;
}
- if (F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
+ if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
isl_int_gcd(gcd, gcd, bmap->eq[i][0]);
if (isl_int_is_one(gcd))
continue;
isl_basic_map_drop_inequality(bmap, i);
continue;
}
- if (F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
+ if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
isl_int_gcd(gcd, gcd, bmap->ineq[i][0]);
if (isl_int_is_one(gcd))
continue;
continue;
*progress = 1;
bmap = isl_basic_map_eliminate_vars(bmap, (off-1)+d, 1);
- if (F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
+ if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
break;
bmap = isl_basic_map_drop_div(bmap, d);
if (!bmap)
if (progress)
*progress = 1;
isl_seq_elim(bmap->ineq[k], eq, 1+pos, 1+total, NULL);
- F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
+ ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
}
for (k = 0; k < bmap->n_div; ++k) {
else
isl_seq_elim(bmap->div[k]+1, eq,
1+pos, 1+total, &bmap->div[k][0]);
- F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
+ ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
}
}
isl_int_set_si(bmap->div[div][1+1+last_var], 0);
isl_int_set(bmap->div[div][0],
bmap->eq[done][1+last_var]);
- F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
+ ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
}
}
if (done == bmap->n_eq)
if (bmap->n_eq == 0)
return bmap;
- if (F_ISSET(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS))
+ if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS))
return bmap;
total = isl_dim_total(bmap->dim);
*progress = 1;
done:
- F_SET(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
+ ISL_F_SET(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
return bmap;
error:
bmap = remove_redundant_divs(bmap);
if (!bmap)
return NULL;
- F_SET(bmap, ISL_BASIC_SET_FINAL);
+ ISL_F_SET(bmap, ISL_BASIC_SET_FINAL);
return bmap;
}
if (!map->p[i])
goto error;
}
- F_CLR(map, ISL_MAP_NORMALIZED);
+ ISL_F_CLR(map, ISL_MAP_NORMALIZED);
return map;
error:
isl_map_free(map);
bmap = isl_basic_map_convex_hull(bmap);
if (!bmap)
goto error;
- if (F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
+ if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
break;
}
}
- F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
+ ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
return bmap;
error:
isl_basic_map_free(bmap);
isl_int_clear(opt);
goto error;
}
- if (F_ISSET(context, ISL_BASIC_MAP_EMPTY)) {
+ if (ISL_F_ISSET(context, ISL_BASIC_MAP_EMPTY)) {
bset = isl_basic_set_set_to_empty(bset);
break;
}
goto error;
}
isl_basic_map_free(context);
- F_CLR(map, ISL_MAP_NORMALIZED);
+ ISL_F_CLR(map, ISL_MAP_NORMALIZED);
return map;
error:
isl_map_free(map);