/*

 * Copyright 2010-2011 INRIA Saclay

 * Copyright 2013-2014 Ecole Normale Superieure

 * Copyright 2014      INRIA Rocquencourt

 *

 * Use of this software is governed by the MIT license

 *

 * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,

 * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,

 * 91893 Orsay, France 

 * and Inria Paris - Rocquencourt, Domaine de Voluceau - Rocquencourt,

 * B.P. 105 - 78153 Le Chesnay, France

 */

#define ISL_DIM_H

#include <isl_map_private.h>

#include <isl_union_map_private.h>

#include <isl/ctx.h>

#include <isl/hash.h>

#include <isl/aff.h>

#include <isl/map.h>

#include <isl/set.h>

#include <isl_space_private.h>

#include <isl/union_set.h>

#include <isl/deprecated/union_map_int.h>

/* Return the number of parameters of "umap", where "type"

 * is required to be set to isl_dim_param.

 */

unsigned isl_union_map_dim(__isl_keep isl_union_map *umap,

	enum isl_dim_type type)

{

	if (!umap)

		return 0;

	if (type != isl_dim_param)

		isl_die(isl_union_map_get_ctx(umap), isl_error_invalid,

			"can only reference parameters", return 0);

	return isl_space_dim(umap->dim, type);

}

/* Return the number of parameters of "uset", where "type"

 * is required to be set to isl_dim_param.

 */

unsigned isl_union_set_dim(__isl_keep isl_union_set *uset,

	enum isl_dim_type type)

{

	return isl_union_map_dim(uset, type);

}

/* Return the id of the specified dimension.

 */

__isl_give isl_id *isl_union_map_get_dim_id(__isl_keep isl_union_map *umap,

	enum isl_dim_type type, unsigned pos)

{

	if (!umap)

		return NULL;

	if (type != isl_dim_param)

		isl_die(isl_union_map_get_ctx(umap), isl_error_invalid,

			"can only reference parameters", return NULL);

	return isl_space_get_dim_id(umap->dim, type, pos);

}

/* Is this union set a parameter domain?

 */

isl_bool isl_union_set_is_params(__isl_keep isl_union_set *uset)

{

	isl_set *set;

	isl_bool params;

	if (!uset)

		return isl_bool_error;

	if (uset->table.n != 1)

		return isl_bool_false;

	set = isl_set_from_union_set(isl_union_set_copy(uset));

	params = isl_set_is_params(set);

	isl_set_free(set);

	return params;

}

static __isl_give isl_union_map *isl_union_map_alloc(

	__isl_take isl_space *space, int size)

{

	isl_union_map *umap;

	space = isl_space_params(space);

	if (!space)

		return NULL;

	umap = isl_calloc_type(space->ctx, isl_union_map);

	if (!umap) {

		isl_space_free(space);

		return NULL;

	}

	umap->ref = 1;

	umap->dim = space;

	if (isl_hash_table_init(space->ctx, &umap->table, size) < 0)

		return isl_union_map_free(umap);

	return umap;

}

__isl_give isl_union_map *isl_union_map_empty(__isl_take isl_space *dim)

{

	return isl_union_map_alloc(dim, 16);

}

__isl_give isl_union_set *isl_union_set_empty(__isl_take isl_space *dim)

{

	return isl_union_map_empty(dim);

}

isl_ctx *isl_union_map_get_ctx(__isl_keep isl_union_map *umap)

{

	return umap ? umap->dim->ctx : NULL;

}

isl_ctx *isl_union_set_get_ctx(__isl_keep isl_union_set *uset)

{

	return uset ? uset->dim->ctx : NULL;

}

__isl_give isl_space *isl_union_map_get_space(__isl_keep isl_union_map *umap)

{

	if (!umap)

		return NULL;

	return isl_space_copy(umap->dim);

}

/* Return the position of the parameter with the given name

 * in "umap".

 * Return -1 if no such dimension can be found.

 */

int isl_union_map_find_dim_by_name(__isl_keep isl_union_map *umap,

	enum isl_dim_type type, const char *name)

{

	if (!umap)

		return -1;

	return isl_space_find_dim_by_name(umap->dim, type, name);

}

__isl_give isl_space *isl_union_set_get_space(__isl_keep isl_union_set *uset)

{

	return isl_union_map_get_space(uset);

}

static isl_stat free_umap_entry(void **entry, void *user)

{

	isl_map *map = *entry;

	isl_map_free(map);

	return isl_stat_ok;

}

static isl_stat add_map(__isl_take isl_map *map, void *user)

{

	isl_union_map **umap = (isl_union_map **)user;

	*umap = isl_union_map_add_map(*umap, map);

	return isl_stat_ok;

}

__isl_give isl_union_map *isl_union_map_dup(__isl_keep isl_union_map *umap)

{

	isl_union_map *dup;

	if (!umap)

		return NULL;

	dup = isl_union_map_empty(isl_space_copy(umap->dim));

	if (isl_union_map_foreach_map(umap, &add_map, &dup) < 0)

		goto error;

	return dup;

error:

	isl_union_map_free(dup);

	return NULL;

}

__isl_give isl_union_map *isl_union_map_cow(__isl_take isl_union_map *umap)

{

	if (!umap)

		return NULL;

	if (umap->ref == 1)

		return umap;

	umap->ref--;

	return isl_union_map_dup(umap);

}

struct isl_union_align {

	isl_reordering *exp;

	isl_union_map *res;

};

static isl_stat align_entry(void **entry, void *user)

{

	isl_map *map = *entry;

	isl_reordering *exp;

	struct isl_union_align *data = user;

	exp = isl_reordering_extend_space(isl_reordering_copy(data->exp),

				    isl_map_get_space(map));

	data->res = isl_union_map_add_map(data->res,

					isl_map_realign(isl_map_copy(map), exp));

	return isl_stat_ok;

}

/* Align the parameters of umap along those of model.

 * The result has the parameters of model first, in the same order

 * as they appear in model, followed by any remaining parameters of

 * umap that do not appear in model.

 */

__isl_give isl_union_map *isl_union_map_align_params(

	__isl_take isl_union_map *umap, __isl_take isl_space *model)

{

	struct isl_union_align data = { NULL, NULL };

	if (!umap || !model)

		goto error;

	if (isl_space_match(umap->dim, isl_dim_param, model, isl_dim_param)) {

		isl_space_free(model);

		return umap;

	}

	model = isl_space_params(model);

	data.exp = isl_parameter_alignment_reordering(umap->dim, model);

	if (!data.exp)

		goto error;

	data.res = isl_union_map_alloc(isl_space_copy(data.exp->dim),

					umap->table.n);

	if (isl_hash_table_foreach(umap->dim->ctx, &umap->table,

					&align_entry, &data) < 0)

		goto error;

	isl_reordering_free(data.exp);

	isl_union_map_free(umap);

	isl_space_free(model);

	return data.res;

error:

	isl_reordering_free(data.exp);

	isl_union_map_free(umap);

	isl_union_map_free(data.res);

	isl_space_free(model);

	return NULL;

}

__isl_give isl_union_set *isl_union_set_align_params(

	__isl_take isl_union_set *uset, __isl_take isl_space *model)

{

	return isl_union_map_align_params(uset, model);

}

__isl_give isl_union_map *isl_union_map_union(__isl_take isl_union_map *umap1,

	__isl_take isl_union_map *umap2)

{

	umap1 = isl_union_map_align_params(umap1, isl_union_map_get_space(umap2));

	umap2 = isl_union_map_align_params(umap2, isl_union_map_get_space(umap1));

	umap1 = isl_union_map_cow(umap1);

	if (!umap1 || !umap2)

		goto error;

	if (isl_union_map_foreach_map(umap2, &add_map, &umap1) < 0)

		goto error;

	isl_union_map_free(umap2);

	return umap1;

error:

	isl_union_map_free(umap1);

	isl_union_map_free(umap2);

	return NULL;

}

__isl_give isl_union_set *isl_union_set_union(__isl_take isl_union_set *uset1,

	__isl_take isl_union_set *uset2)

{

	return isl_union_map_union(uset1, uset2);

}

__isl_give isl_union_map *isl_union_map_copy(__isl_keep isl_union_map *umap)

{

	if (!umap)

		return NULL;

	umap->ref++;

	return umap;

}

__isl_give isl_union_set *isl_union_set_copy(__isl_keep isl_union_set *uset)

{

	return isl_union_map_copy(uset);

}

__isl_null isl_union_map *isl_union_map_free(__isl_take isl_union_map *umap)

{

	if (!umap)

		return NULL;

	if (--umap->ref > 0)

		return NULL;

	isl_hash_table_foreach(umap->dim->ctx, &umap->table,

			       &free_umap_entry, NULL);

	isl_hash_table_clear(&umap->table);

	isl_space_free(umap->dim);

	free(umap);

	return NULL;

}

__isl_null isl_union_set *isl_union_set_free(__isl_take isl_union_set *uset)

{

	return isl_union_map_free(uset);

}

static int has_dim(const void *entry, const void *val)

{

	isl_map *map = (isl_map *)entry;

	isl_space *dim = (isl_space *)val;

	return isl_space_is_equal(map->dim, dim);

}

__isl_give isl_union_map *isl_union_map_add_map(__isl_take isl_union_map *umap,

	__isl_take isl_map *map)

{

	uint32_t hash;

	struct isl_hash_table_entry *entry;

	if (!map || !umap)

		goto error;

	if (isl_map_plain_is_empty(map)) {

		isl_map_free(map);

		return umap;

	}

	if (!isl_space_match(map->dim, isl_dim_param, umap->dim, isl_dim_param)) {

		umap = isl_union_map_align_params(umap, isl_map_get_space(map));

		map = isl_map_align_params(map, isl_union_map_get_space(umap));

	}

	umap = isl_union_map_cow(umap);

	if (!map || !umap)

		goto error;

	hash = isl_space_get_hash(map->dim);

	entry = isl_hash_table_find(umap->dim->ctx, &umap->table, hash,

				    &has_dim, map->dim, 1);

	if (!entry)

		goto error;

	if (!entry->data)

		entry->data = map;

	else {

		entry->data = isl_map_union(entry->data, isl_map_copy(map));

		if (!entry->data)

			goto error;

		isl_map_free(map);

	}

	return umap;

error:

	isl_map_free(map);

	isl_union_map_free(umap);

	return NULL;

}

__isl_give isl_union_set *isl_union_set_add_set(__isl_take isl_union_set *uset,

	__isl_take isl_set *set)

{

	return isl_union_map_add_map(uset, (isl_map *)set);

}

__isl_give isl_union_map *isl_union_map_from_map(__isl_take isl_map *map)

{

	isl_space *dim;

	isl_union_map *umap;

	if (!map)

		return NULL;

	dim = isl_map_get_space(map);

	dim = isl_space_params(dim);

	umap = isl_union_map_empty(dim);

	umap = isl_union_map_add_map(umap, map);

	return umap;

}

__isl_give isl_union_set *isl_union_set_from_set(__isl_take isl_set *set)

{

	return isl_union_map_from_map((isl_map *)set);

}

__isl_give isl_union_map *isl_union_map_from_basic_map(

	__isl_take isl_basic_map *bmap)

{

	return isl_union_map_from_map(isl_map_from_basic_map(bmap));

}

__isl_give isl_union_set *isl_union_set_from_basic_set(

	__isl_take isl_basic_set *bset)

{

	return isl_union_map_from_basic_map(bset);

}

struct isl_union_map_foreach_data

{

	isl_stat (*fn)(__isl_take isl_map *map, void *user);

	void *user;

};

static isl_stat call_on_copy(void **entry, void *user)

{

	isl_map *map = *entry;

	struct isl_union_map_foreach_data *data;

	data = (struct isl_union_map_foreach_data *)user;

	return data->fn(isl_map_copy(map), data->user);

}

int isl_union_map_n_map(__isl_keep isl_union_map *umap)

{

	return umap ? umap->table.n : 0;

}

int isl_union_set_n_set(__isl_keep isl_union_set *uset)

{

	return uset ? uset->table.n : 0;

}

isl_stat isl_union_map_foreach_map(__isl_keep isl_union_map *umap,

	isl_stat (*fn)(__isl_take isl_map *map, void *user), void *user)

{

	struct isl_union_map_foreach_data data = { fn, user };

	if (!umap)

		return isl_stat_error;

	return isl_hash_table_foreach(umap->dim->ctx, &umap->table,

				      &call_on_copy, &data);

}

static isl_stat copy_map(void **entry, void *user)

{

	isl_map *map = *entry;

	isl_map **map_p = user;

	*map_p = isl_map_copy(map);

	return isl_stat_error;

}

__isl_give isl_map *isl_map_from_union_map(__isl_take isl_union_map *umap)

{

	isl_ctx *ctx;

	isl_map *map = NULL;

	if (!umap)

		return NULL;

	ctx = isl_union_map_get_ctx(umap);

	if (umap->table.n != 1)

		isl_die(ctx, isl_error_invalid,

			"union map needs to contain elements in exactly "

			"one space", goto error);

	isl_hash_table_foreach(ctx, &umap->table, &copy_map, &map);

	isl_union_map_free(umap);

	return map;

error:

	isl_union_map_free(umap);

	return NULL;

}

__isl_give isl_set *isl_set_from_union_set(__isl_take isl_union_set *uset)

{

	return isl_map_from_union_map(uset);

}

/* Extract the map in "umap" that lives in the given space (ignoring

 * parameters).

 */

__isl_give isl_map *isl_union_map_extract_map(__isl_keep isl_union_map *umap,

	__isl_take isl_space *space)

{

	uint32_t hash;

	struct isl_hash_table_entry *entry;

	space = isl_space_drop_dims(space, isl_dim_param,

					0, isl_space_dim(space, isl_dim_param));

	space = isl_space_align_params(space, isl_union_map_get_space(umap));

	if (!umap || !space)

		goto error;

	hash = isl_space_get_hash(space);

	entry = isl_hash_table_find(umap->dim->ctx, &umap->table, hash,

				    &has_dim, space, 0);

	if (!entry)

		return isl_map_empty(space);

	isl_space_free(space);

	return isl_map_copy(entry->data);

error:

	isl_space_free(space);

	return NULL;

}

__isl_give isl_set *isl_union_set_extract_set(__isl_keep isl_union_set *uset,

	__isl_take isl_space *dim)

{

	return (isl_set *)isl_union_map_extract_map(uset, dim);

}

/* Check if umap contains a map in the given space.

 */

__isl_give int isl_union_map_contains(__isl_keep isl_union_map *umap,

	__isl_keep isl_space *dim)

{

	uint32_t hash;

	struct isl_hash_table_entry *entry;

	if (!umap || !dim)

		return -1;

	hash = isl_space_get_hash(dim);

	entry = isl_hash_table_find(umap->dim->ctx, &umap->table, hash,

				    &has_dim, dim, 0);

	return !!entry;

}

__isl_give int isl_union_set_contains(__isl_keep isl_union_set *uset,

	__isl_keep isl_space *dim)

{

	return isl_union_map_contains(uset, dim);

}

isl_stat isl_union_set_foreach_set(__isl_keep isl_union_set *uset,

	isl_stat (*fn)(__isl_take isl_set *set, void *user), void *user)

{

	return isl_union_map_foreach_map(uset,

		(isl_stat(*)(__isl_take isl_map *, void*))fn, user);

}

struct isl_union_set_foreach_point_data {

	isl_stat (*fn)(__isl_take isl_point *pnt, void *user);

	void *user;

};

static isl_stat foreach_point(__isl_take isl_set *set, void *user)

{

	struct isl_union_set_foreach_point_data *data = user;

	isl_stat r;

	r = isl_set_foreach_point(set, data->fn, data->user);

	isl_set_free(set);

	return r;

}

isl_stat isl_union_set_foreach_point(__isl_keep isl_union_set *uset,

	isl_stat (*fn)(__isl_take isl_point *pnt, void *user), void *user)

{

	struct isl_union_set_foreach_point_data data = { fn, user };

	return isl_union_set_foreach_set(uset, &foreach_point, &data);

}

struct isl_union_map_gen_bin_data {

	isl_union_map *umap2;

	isl_union_map *res;

};

static isl_stat subtract_entry(void **entry, void *user)

{

	struct isl_union_map_gen_bin_data *data = user;

	uint32_t hash;

	struct isl_hash_table_entry *entry2;

	isl_map *map = *entry;

	hash = isl_space_get_hash(map->dim);

	entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,

				     hash, &has_dim, map->dim, 0);

	map = isl_map_copy(map);

	if (entry2) {

		int empty;

		map = isl_map_subtract(map, isl_map_copy(entry2->data));

		empty = isl_map_is_empty(map);

		if (empty < 0) {

			isl_map_free(map);

			return isl_stat_error;

		}

		if (empty) {

			isl_map_free(map);

			return isl_stat_ok;

		}

	}

	data->res = isl_union_map_add_map(data->res, map);

	return isl_stat_ok;

}

static __isl_give isl_union_map *gen_bin_op(__isl_take isl_union_map *umap1,

	__isl_take isl_union_map *umap2, isl_stat (*fn)(void **, void *))

{

	struct isl_union_map_gen_bin_data data = { NULL, NULL };

	umap1 = isl_union_map_align_params(umap1, isl_union_map_get_space(umap2));

	umap2 = isl_union_map_align_params(umap2, isl_union_map_get_space(umap1));

	if (!umap1 || !umap2)

		goto error;

	data.umap2 = umap2;

	data.res = isl_union_map_alloc(isl_space_copy(umap1->dim),

				       umap1->table.n);

	if (isl_hash_table_foreach(umap1->dim->ctx, &umap1->table,

				   fn, &data) < 0)

		goto error;

	isl_union_map_free(umap1);

	isl_union_map_free(umap2);

	return data.res;

error:

	isl_union_map_free(umap1);

	isl_union_map_free(umap2);

	isl_union_map_free(data.res);

	return NULL;

}

__isl_give isl_union_map *isl_union_map_subtract(

	__isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2)

{

	return gen_bin_op(umap1, umap2, &subtract_entry);

}

__isl_give isl_union_set *isl_union_set_subtract(

	__isl_take isl_union_set *uset1, __isl_take isl_union_set *uset2)

{

	return isl_union_map_subtract(uset1, uset2);

}

struct isl_union_map_gen_bin_set_data {

	isl_set *set;

	isl_union_map *res;

};

static isl_stat intersect_params_entry(void **entry, void *user)

{

	struct isl_union_map_gen_bin_set_data *data = user;

	isl_map *map = *entry;

	int empty;

	map = isl_map_copy(map);

	map = isl_map_intersect_params(map, isl_set_copy(data->set));

	empty = isl_map_is_empty(map);

	if (empty < 0) {

		isl_map_free(map);

		return isl_stat_error;

	}

	data->res = isl_union_map_add_map(data->res, map);

	return isl_stat_ok;

}

static __isl_give isl_union_map *gen_bin_set_op(__isl_take isl_union_map *umap,

	__isl_take isl_set *set, isl_stat (*fn)(void **, void *))

{

	struct isl_union_map_gen_bin_set_data data = { NULL, NULL };

	umap = isl_union_map_align_params(umap, isl_set_get_space(set));

	set = isl_set_align_params(set, isl_union_map_get_space(umap));

	if (!umap || !set)

		goto error;

	data.set = set;

	data.res = isl_union_map_alloc(isl_space_copy(umap->dim),

				       umap->table.n);

	if (isl_hash_table_foreach(umap->dim->ctx, &umap->table,

				   fn, &data) < 0)

		goto error;

	isl_union_map_free(umap);

	isl_set_free(set);

	return data.res;

error:

	isl_union_map_free(umap);

	isl_set_free(set);

	isl_union_map_free(data.res);

	return NULL;

}

/* Intersect "umap" with the parameter domain "set".

 *

 * If "set" does not have any constraints, then we can return immediately.

 */

__isl_give isl_union_map *isl_union_map_intersect_params(

	__isl_take isl_union_map *umap, __isl_take isl_set *set)

{

	int is_universe;

	is_universe = isl_set_plain_is_universe(set);

	if (is_universe < 0)

		goto error;

	if (is_universe) {

		isl_set_free(set);

		return umap;

	}

	return gen_bin_set_op(umap, set, &intersect_params_entry);

error:

	isl_union_map_free(umap);

	isl_set_free(set);

	return NULL;

}

__isl_give isl_union_set *isl_union_set_intersect_params(

	__isl_take isl_union_set *uset, __isl_take isl_set *set)

{

	return isl_union_map_intersect_params(uset, set);

}

static __isl_give isl_union_map *union_map_intersect_params(

	__isl_take isl_union_map *umap, __isl_take isl_union_set *uset)

{

	return isl_union_map_intersect_params(umap,

						isl_set_from_union_set(uset));

}

static __isl_give isl_union_map *union_map_gist_params(

	__isl_take isl_union_map *umap, __isl_take isl_union_set *uset)

{

	return isl_union_map_gist_params(umap, isl_set_from_union_set(uset));

}

struct isl_union_map_match_bin_data {

	isl_union_map *umap2;

	isl_union_map *res;

	__isl_give isl_map *(*fn)(__isl_take isl_map*, __isl_take isl_map*);

};

static isl_stat match_bin_entry(void **entry, void *user)

{

	struct isl_union_map_match_bin_data *data = user;

	uint32_t hash;

	struct isl_hash_table_entry *entry2;

	isl_map *map = *entry;

	int empty;

	hash = isl_space_get_hash(map->dim);

	entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,

				     hash, &has_dim, map->dim, 0);

	if (!entry2)

		return isl_stat_ok;

	map = isl_map_copy(map);

	map = data->fn(map, isl_map_copy(entry2->data));

	empty = isl_map_is_empty(map);

	if (empty < 0) {

		isl_map_free(map);

		return isl_stat_error;

	}

	if (empty) {

		isl_map_free(map);

		return isl_stat_ok;

	}

	data->res = isl_union_map_add_map(data->res, map);

	return isl_stat_ok;

}

static __isl_give isl_union_map *match_bin_op(__isl_take isl_union_map *umap1,

	__isl_take isl_union_map *umap2,

	__isl_give isl_map *(*fn)(__isl_take isl_map*, __isl_take isl_map*))

{

	struct isl_union_map_match_bin_data data = { NULL, NULL, fn };

	umap1 = isl_union_map_align_params(umap1, isl_union_map_get_space(umap2));

	umap2 = isl_union_map_align_params(umap2, isl_union_map_get_space(umap1));

	if (!umap1 || !umap2)

		goto error;

	data.umap2 = umap2;

	data.res = isl_union_map_alloc(isl_space_copy(umap1->dim),

				       umap1->table.n);

	if (isl_hash_table_foreach(umap1->dim->ctx, &umap1->table,

				   &match_bin_entry, &data) < 0)

		goto error;

	isl_union_map_free(umap1);

	isl_union_map_free(umap2);

	return data.res;

error:

	isl_union_map_free(umap1);

	isl_union_map_free(umap2);

	isl_union_map_free(data.res);

	return NULL;

}

__isl_give isl_union_map *isl_union_map_intersect(

	__isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2)

{

	return match_bin_op(umap1, umap2, &isl_map_intersect);

}

/* Compute the intersection of the two union_sets.

 * As a special case, if exactly one of the two union_sets

 * is a parameter domain, then intersect the parameter domain

 * of the other one with this set.

 */

__isl_give isl_union_set *isl_union_set_intersect(

	__isl_take isl_union_set *uset1, __isl_take isl_union_set *uset2)

{

	int p1, p2;

	p1 = isl_union_set_is_params(uset1);

	p2 = isl_union_set_is_params(uset2);

	if (p1 < 0 || p2 < 0)

		goto error;

	if (!p1 && p2)

		return union_map_intersect_params(uset1, uset2);

	if (p1 && !p2)

		return union_map_intersect_params(uset2, uset1);

	return isl_union_map_intersect(uset1, uset2);

error:

	isl_union_set_free(uset1);

	isl_union_set_free(uset2);

	return NULL;

}

static isl_stat gist_params_entry(void **entry, void *user)

{

	struct isl_union_map_gen_bin_set_data *data = user;

	isl_map *map = *entry;

	int empty;

	map = isl_map_copy(map);

	map = isl_map_gist_params(map, isl_set_copy(data->set));

	empty = isl_map_is_empty(map);

	if (empty < 0) {

		isl_map_free(map);

		return isl_stat_error;

	}

	data->res = isl_union_map_add_map(data->res, map);

	return isl_stat_ok;

}

__isl_give isl_union_map *isl_union_map_gist_params(

	__isl_take isl_union_map *umap, __isl_take isl_set *set)

{

	return gen_bin_set_op(umap, set, &gist_params_entry);

}

__isl_give isl_union_set *isl_union_set_gist_params(

	__isl_take isl_union_set *uset, __isl_take isl_set *set)

{

	return isl_union_map_gist_params(uset, set);

}