Català-Valencià – Catalan中文 – Chinese (Simplified)中文 – Chinese (Traditional)Česky – CzechDansk – DanishNederlands – DutchEnglish – EnglishSuomi – FinnishFrançais – FrenchDeutsch – Germanעברית – Hebrewहिंदी – HindiMagyar – HungarianBahasa Indonesia – IndonesianItaliano – Italian日本語 – Japanese한국어 – KoreanМакедонски – Macedonianमराठी – MarathiNorsk – NorwegianPolski – PolishPortuguês – PortuguesePortuguês – Portuguese (Brazil)Русский – RussianSlovenčina – SlovakSlovenščina – SlovenianEspañol – SpanishSvenska – SwedishTürkçe – TurkishУкраїнська – UkrainianOëzbekcha – Uzbek

nexmon – Blame information for rev 1

Rev	Author	Line No.	Line
1	office	1	/*
		2	* Copyright 2008-2009 Katholieke Universiteit Leuven
		3	* Copyright 2010 INRIA Saclay
		4	*
		5	* Use of this software is governed by the GNU LGPLv2.1 license
		6	*
		7	* Written by Sven Verdoolaege, K.U.Leuven, Departement
		8	* Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
		9	* and INRIA Saclay - Ile-de-France, Parc Club Orsay Universite,
		10	* ZAC des vignes, 4 rue Jacques Monod, 91893 Orsay, France
		11	*/
		12
		13	#include <string.h>
		14	#include <isl_ctx_private.h>
		15	#include <isl_map_private.h>
		16	#include <isl/blk.h>
		17	#include "isl_space_private.h"
		18	#include "isl_equalities.h"
		19	#include <isl_list_private.h>
		20	#include <isl/lp.h>
		21	#include <isl/seq.h>
		22	#include <isl/set.h>
		23	#include <isl/map.h>
		24	#include "isl_map_piplib.h"
		25	#include <isl_reordering.h>
		26	#include "isl_sample.h"
		27	#include "isl_tab.h"
		28	#include <isl/vec.h>
		29	#include <isl_mat_private.h>
		30	#include <isl_dim_map.h>
		31	#include <isl_local_space_private.h>
		32	#include <isl_aff_private.h>
		33	#include <isl_options_private.h>
		34
		35	static unsigned n(__isl_keep isl_space *dim, enum isl_dim_type type)
		36	{
		37	switch (type) {
		38	case isl_dim_param: return dim->nparam;
		39	case isl_dim_in: return dim->n_in;
		40	case isl_dim_out: return dim->n_out;
		41	case isl_dim_all: return dim->nparam + dim->n_in + dim->n_out;
		42	default: return 0;
		43	}
		44	}
		45
		46	static unsigned pos(__isl_keep isl_space *dim, enum isl_dim_type type)
		47	{
		48	switch (type) {
		49	case isl_dim_param: return 1;
		50	case isl_dim_in: return 1 + dim->nparam;
		51	case isl_dim_out: return 1 + dim->nparam + dim->n_in;
		52	default: return 0;
		53	}
		54	}
		55
		56	unsigned isl_basic_map_dim(__isl_keep isl_basic_map *bmap,
		57	enum isl_dim_type type)
		58	{
		59	if (!bmap)
		60	return 0;
		61	switch (type) {
		62	case isl_dim_cst: return 1;
		63	case isl_dim_param:
		64	case isl_dim_in:
		65	case isl_dim_out: return isl_space_dim(bmap->dim, type);
		66	case isl_dim_div: return bmap->n_div;
		67	case isl_dim_all: return isl_basic_map_total_dim(bmap);
		68	default: return 0;
		69	}
		70	}
		71
		72	unsigned isl_map_dim(__isl_keep isl_map *map, enum isl_dim_type type)
		73	{
		74	return map ? n(map->dim, type) : 0;
		75	}
		76
		77	unsigned isl_set_dim(__isl_keep isl_set *set, enum isl_dim_type type)
		78	{
		79	return set ? n(set->dim, type) : 0;
		80	}
		81
		82	unsigned isl_basic_map_offset(struct isl_basic_map *bmap,
		83	enum isl_dim_type type)
		84	{
		85	isl_space *dim = bmap->dim;
		86	switch (type) {
		87	case isl_dim_cst: return 0;
		88	case isl_dim_param: return 1;
		89	case isl_dim_in: return 1 + dim->nparam;
		90	case isl_dim_out: return 1 + dim->nparam + dim->n_in;
		91	case isl_dim_div: return 1 + dim->nparam + dim->n_in + dim->n_out;
		92	default: return 0;
		93	}
		94	}
		95
		96	unsigned isl_basic_set_offset(struct isl_basic_set *bset,
		97	enum isl_dim_type type)
		98	{
		99	return isl_basic_map_offset(bset, type);
		100	}
		101
		102	static unsigned map_offset(struct isl_map *map, enum isl_dim_type type)
		103	{
		104	return pos(map->dim, type);
		105	}
		106
		107	unsigned isl_basic_set_dim(__isl_keep isl_basic_set *bset,
		108	enum isl_dim_type type)
		109	{
		110	return isl_basic_map_dim(bset, type);
		111	}
		112
		113	unsigned isl_basic_set_n_dim(__isl_keep isl_basic_set *bset)
		114	{
		115	return isl_basic_set_dim(bset, isl_dim_set);
		116	}
		117
		118	unsigned isl_basic_set_n_param(__isl_keep isl_basic_set *bset)
		119	{
		120	return isl_basic_set_dim(bset, isl_dim_param);
		121	}
		122
		123	unsigned isl_basic_set_total_dim(const struct isl_basic_set *bset)
		124	{
		125	if (!bset)
		126	return 0;
		127	return isl_space_dim(bset->dim, isl_dim_all) + bset->n_div;
		128	}
		129
		130	unsigned isl_set_n_dim(__isl_keep isl_set *set)
		131	{
		132	return isl_set_dim(set, isl_dim_set);
		133	}
		134
		135	unsigned isl_set_n_param(__isl_keep isl_set *set)
		136	{
		137	return isl_set_dim(set, isl_dim_param);
		138	}
		139
		140	unsigned isl_basic_map_n_in(const struct isl_basic_map *bmap)
		141	{
		142	return bmap ? bmap->dim->n_in : 0;
		143	}
		144
		145	unsigned isl_basic_map_n_out(const struct isl_basic_map *bmap)
		146	{
		147	return bmap ? bmap->dim->n_out : 0;
		148	}
		149
		150	unsigned isl_basic_map_n_param(const struct isl_basic_map *bmap)
		151	{
		152	return bmap ? bmap->dim->nparam : 0;
		153	}
		154
		155	unsigned isl_basic_map_n_div(const struct isl_basic_map *bmap)
		156	{
		157	return bmap ? bmap->n_div : 0;
		158	}
		159
		160	unsigned isl_basic_map_total_dim(const struct isl_basic_map *bmap)
		161	{
		162	return bmap ? isl_space_dim(bmap->dim, isl_dim_all) + bmap->n_div : 0;
		163	}
		164
		165	unsigned isl_map_n_in(const struct isl_map *map)
		166	{
		167	return map ? map->dim->n_in : 0;
		168	}
		169
		170	unsigned isl_map_n_out(const struct isl_map *map)
		171	{
		172	return map ? map->dim->n_out : 0;
		173	}
		174
		175	unsigned isl_map_n_param(const struct isl_map *map)
		176	{
		177	return map ? map->dim->nparam : 0;
		178	}
		179
		180	int isl_map_compatible_domain(struct isl_map *map, struct isl_set *set)
		181	{
		182	int m;
		183	if (!map || !set)
		184	return -1;
		185	m = isl_space_match(map->dim, isl_dim_param, set->dim, isl_dim_param);
		186	if (m < 0 || !m)
		187	return m;
		188	return isl_space_tuple_match(map->dim, isl_dim_in, set->dim, isl_dim_set);
		189	}
		190
		191	int isl_basic_map_compatible_domain(struct isl_basic_map *bmap,
		192	struct isl_basic_set *bset)
		193	{
		194	int m;
		195	if (!bmap || !bset)
		196	return -1;
		197	m = isl_space_match(bmap->dim, isl_dim_param, bset->dim, isl_dim_param);
		198	if (m < 0 || !m)
		199	return m;
		200	return isl_space_tuple_match(bmap->dim, isl_dim_in, bset->dim, isl_dim_set);
		201	}
		202
		203	int isl_map_compatible_range(__isl_keep isl_map *map, __isl_keep isl_set *set)
		204	{
		205	int m;
		206	if (!map || !set)
		207	return -1;
		208	m = isl_space_match(map->dim, isl_dim_param, set->dim, isl_dim_param);
		209	if (m < 0 || !m)
		210	return m;
		211	return isl_space_tuple_match(map->dim, isl_dim_out, set->dim, isl_dim_set);
		212	}
		213
		214	int isl_basic_map_compatible_range(struct isl_basic_map *bmap,
		215	struct isl_basic_set *bset)
		216	{
		217	int m;
		218	if (!bmap || !bset)
		219	return -1;
		220	m = isl_space_match(bmap->dim, isl_dim_param, bset->dim, isl_dim_param);
		221	if (m < 0 || !m)
		222	return m;
		223	return isl_space_tuple_match(bmap->dim, isl_dim_out, bset->dim, isl_dim_set);
		224	}
		225
		226	isl_ctx *isl_basic_map_get_ctx(__isl_keep isl_basic_map *bmap)
		227	{
		228	return bmap ? bmap->ctx : NULL;
		229	}
		230
		231	isl_ctx *isl_basic_set_get_ctx(__isl_keep isl_basic_set *bset)
		232	{
		233	return bset ? bset->ctx : NULL;
		234	}
		235
		236	isl_ctx *isl_map_get_ctx(__isl_keep isl_map *map)
		237	{
		238	return map ? map->ctx : NULL;
		239	}
		240
		241	isl_ctx *isl_set_get_ctx(__isl_keep isl_set *set)
		242	{
		243	return set ? set->ctx : NULL;
		244	}
		245
		246	__isl_give isl_space *isl_basic_map_get_space(__isl_keep isl_basic_map *bmap)
		247	{
		248	if (!bmap)
		249	return NULL;
		250	return isl_space_copy(bmap->dim);
		251	}
		252
		253	__isl_give isl_space *isl_basic_set_get_space(__isl_keep isl_basic_set *bset)
		254	{
		255	if (!bset)
		256	return NULL;
		257	return isl_space_copy(bset->dim);
		258	}
		259
		260	/* Extract the divs in "bmap" as a matrix.
		261	*/
		262	__isl_give isl_mat *isl_basic_map_get_divs(__isl_keep isl_basic_map *bmap)
		263	{
		264	int i;
		265	isl_ctx *ctx;
		266	isl_mat *div;
		267	unsigned total;
		268	unsigned cols;
		269
		270	if (!bmap)
		271	return NULL;
		272
		273	ctx = isl_basic_map_get_ctx(bmap);
		274	total = isl_space_dim(bmap->dim, isl_dim_all);
		275	cols = 1 + 1 + total + bmap->n_div;
		276	div = isl_mat_alloc(ctx, bmap->n_div, cols);
		277	if (!div)
		278	return NULL;
		279
		280	for (i = 0; i < bmap->n_div; ++i)
		281	isl_seq_cpy(div->row[i], bmap->div[i], cols);
		282
		283	return div;
		284	}
		285
		286	__isl_give isl_local_space *isl_basic_map_get_local_space(
		287	__isl_keep isl_basic_map *bmap)
		288	{
		289	isl_mat *div;
		290
		291	if (!bmap)
		292	return NULL;
		293
		294	div = isl_basic_map_get_divs(bmap);
		295	return isl_local_space_alloc_div(isl_space_copy(bmap->dim), div);
		296	}
		297
		298	__isl_give isl_local_space *isl_basic_set_get_local_space(
		299	__isl_keep isl_basic_set *bset)
		300	{
		301	return isl_basic_map_get_local_space(bset);
		302	}
		303
		304	__isl_give isl_basic_map *isl_basic_map_from_local_space(
		305	__isl_take isl_local_space *ls)
		306	{
		307	int i;
		308	int n_div;
		309	isl_basic_map *bmap;
		310
		311	if (!ls)
		312	return NULL;
		313
		314	n_div = isl_local_space_dim(ls, isl_dim_div);
		315	bmap = isl_basic_map_alloc_space(isl_local_space_get_space(ls),
		316	n_div, 0, 2 * n_div);
		317
		318	for (i = 0; i < n_div; ++i)
		319	if (isl_basic_map_alloc_div(bmap) < 0)
		320	goto error;
		321
		322	for (i = 0; i < n_div; ++i) {
		323	isl_seq_cpy(bmap->div[i], ls->div->row[i], ls->div->n_col);
		324	if (isl_basic_map_add_div_constraints(bmap, i) < 0)
		325	goto error;
		326	}
		327
		328	isl_local_space_free(ls);
		329	return bmap;
		330	error:
		331	isl_local_space_free(ls);
		332	isl_basic_map_free(bmap);
		333	return NULL;
		334	}
		335
		336	__isl_give isl_basic_set *isl_basic_set_from_local_space(
		337	__isl_take isl_local_space *ls)
		338	{
		339	return isl_basic_map_from_local_space(ls);
		340	}
		341
		342	__isl_give isl_space *isl_map_get_space(__isl_keep isl_map *map)
		343	{
		344	if (!map)
		345	return NULL;
		346	return isl_space_copy(map->dim);
		347	}
		348
		349	__isl_give isl_space *isl_set_get_space(__isl_keep isl_set *set)
		350	{
		351	if (!set)
		352	return NULL;
		353	return isl_space_copy(set->dim);
		354	}
		355
		356	__isl_give isl_basic_map *isl_basic_map_set_tuple_name(
		357	__isl_take isl_basic_map *bmap, enum isl_dim_type type, const char *s)
		358	{
		359	bmap = isl_basic_map_cow(bmap);
		360	if (!bmap)
		361	return NULL;
		362	bmap->dim = isl_space_set_tuple_name(bmap->dim, type, s);
		363	if (!bmap->dim)
		364	goto error;
		365	bmap = isl_basic_map_finalize(bmap);
		366	return bmap;
		367	error:
		368	isl_basic_map_free(bmap);
		369	return NULL;
		370	}
		371
		372	__isl_give isl_basic_set *isl_basic_set_set_tuple_name(
		373	__isl_take isl_basic_set *bset, const char *s)
		374	{
		375	return isl_basic_map_set_tuple_name(bset, isl_dim_set, s);
		376	}
		377
		378	const char *isl_basic_map_get_tuple_name(__isl_keep isl_basic_map *bmap,
		379	enum isl_dim_type type)
		380	{
		381	return bmap ? isl_space_get_tuple_name(bmap->dim, type) : NULL;
		382	}
		383
		384	__isl_give isl_map *isl_map_set_tuple_name(__isl_take isl_map *map,
		385	enum isl_dim_type type, const char *s)
		386	{
		387	int i;
		388
		389	map = isl_map_cow(map);
		390	if (!map)
		391	return NULL;
		392
		393	map->dim = isl_space_set_tuple_name(map->dim, type, s);
		394	if (!map->dim)
		395	goto error;
		396
		397	for (i = 0; i < map->n; ++i) {
		398	map->p[i] = isl_basic_map_set_tuple_name(map->p[i], type, s);
		399	if (!map->p[i])
		400	goto error;
		401	}
		402
		403	return map;
		404	error:
		405	isl_map_free(map);
		406	return NULL;
		407	}
		408
		409	const char *isl_map_get_tuple_name(__isl_keep isl_map *map,
		410	enum isl_dim_type type)
		411	{
		412	return map ? isl_space_get_tuple_name(map->dim, type) : NULL;
		413	}
		414
		415	__isl_give isl_set *isl_set_set_tuple_name(__isl_take isl_set *set,
		416	const char *s)
		417	{
		418	return (isl_set *)isl_map_set_tuple_name((isl_map *)set, isl_dim_set, s);
		419	}
		420
		421	__isl_give isl_map *isl_map_set_tuple_id(__isl_take isl_map *map,
		422	enum isl_dim_type type, __isl_take isl_id *id)
		423	{
		424	map = isl_map_cow(map);
		425	if (!map)
		426	return isl_id_free(id);
		427
		428	map->dim = isl_space_set_tuple_id(map->dim, type, id);
		429
		430	return isl_map_reset_space(map, isl_space_copy(map->dim));
		431	}
		432
		433	__isl_give isl_set *isl_set_set_tuple_id(__isl_take isl_set *set,
		434	__isl_take isl_id *id)
		435	{
		436	return isl_map_set_tuple_id(set, isl_dim_set, id);
		437	}
		438
		439	__isl_give isl_map *isl_map_reset_tuple_id(__isl_take isl_map *map,
		440	enum isl_dim_type type)
		441	{
		442	map = isl_map_cow(map);
		443	if (!map)
		444	return NULL;
		445
		446	map->dim = isl_space_reset_tuple_id(map->dim, type);
		447
		448	return isl_map_reset_space(map, isl_space_copy(map->dim));
		449	}
		450
		451	__isl_give isl_set *isl_set_reset_tuple_id(__isl_take isl_set *set)
		452	{
		453	return isl_map_reset_tuple_id(set, isl_dim_set);
		454	}
		455
		456	int isl_map_has_tuple_id(__isl_keep isl_map *map, enum isl_dim_type type)
		457	{
		458	return map ? isl_space_has_tuple_id(map->dim, type) : -1;
		459	}
		460
		461	__isl_give isl_id *isl_map_get_tuple_id(__isl_keep isl_map *map,
		462	enum isl_dim_type type)
		463	{
		464	return map ? isl_space_get_tuple_id(map->dim, type) : NULL;
		465	}
		466
		467	int isl_set_has_tuple_id(__isl_keep isl_set *set)
		468	{
		469	return isl_map_has_tuple_id(set, isl_dim_set);
		470	}
		471
		472	__isl_give isl_id *isl_set_get_tuple_id(__isl_keep isl_set *set)
		473	{
		474	return isl_map_get_tuple_id(set, isl_dim_set);
		475	}
		476
		477	/* Does the set tuple have a name?
		478	*/
		479	int isl_set_has_tuple_name(__isl_keep isl_set *set)
		480	{
		481	return set ? isl_space_has_tuple_name(set->dim, isl_dim_set) : -1;
		482	}
		483
		484
		485	const char *isl_basic_set_get_tuple_name(__isl_keep isl_basic_set *bset)
		486	{
		487	return bset ? isl_space_get_tuple_name(bset->dim, isl_dim_set) : NULL;
		488	}
		489
		490	const char *isl_set_get_tuple_name(__isl_keep isl_set *set)
		491	{
		492	return set ? isl_space_get_tuple_name(set->dim, isl_dim_set) : NULL;
		493	}
		494
		495	const char *isl_basic_map_get_dim_name(__isl_keep isl_basic_map *bmap,
		496	enum isl_dim_type type, unsigned pos)
		497	{
		498	return bmap ? isl_space_get_dim_name(bmap->dim, type, pos) : NULL;
		499	}
		500
		501	const char *isl_basic_set_get_dim_name(__isl_keep isl_basic_set *bset,
		502	enum isl_dim_type type, unsigned pos)
		503	{
		504	return bset ? isl_space_get_dim_name(bset->dim, type, pos) : NULL;
		505	}
		506
		507	const char *isl_map_get_dim_name(__isl_keep isl_map *map,
		508	enum isl_dim_type type, unsigned pos)
		509	{
		510	return map ? isl_space_get_dim_name(map->dim, type, pos) : NULL;
		511	}
		512
		513	const char *isl_set_get_dim_name(__isl_keep isl_set *set,
		514	enum isl_dim_type type, unsigned pos)
		515	{
		516	return set ? isl_space_get_dim_name(set->dim, type, pos) : NULL;
		517	}
		518
		519	/* Does the given dimension have a name?
		520	*/
		521	int isl_set_has_dim_name(__isl_keep isl_set *set,
		522	enum isl_dim_type type, unsigned pos)
		523	{
		524	return set ? isl_space_has_dim_name(set->dim, type, pos) : -1;
		525	}
		526
		527	__isl_give isl_basic_map *isl_basic_map_set_dim_name(
		528	__isl_take isl_basic_map *bmap,
		529	enum isl_dim_type type, unsigned pos, const char *s)
		530	{
		531	bmap = isl_basic_map_cow(bmap);
		532	if (!bmap)
		533	return NULL;
		534	bmap->dim = isl_space_set_dim_name(bmap->dim, type, pos, s);
		535	if (!bmap->dim)
		536	goto error;
		537	return isl_basic_map_finalize(bmap);
		538	error:
		539	isl_basic_map_free(bmap);
		540	return NULL;
		541	}
		542
		543	__isl_give isl_map *isl_map_set_dim_name(__isl_take isl_map *map,
		544	enum isl_dim_type type, unsigned pos, const char *s)
		545	{
		546	int i;
		547
		548	map = isl_map_cow(map);
		549	if (!map)
		550	return NULL;
		551
		552	map->dim = isl_space_set_dim_name(map->dim, type, pos, s);
		553	if (!map->dim)
		554	goto error;
		555
		556	for (i = 0; i < map->n; ++i) {
		557	map->p[i] = isl_basic_map_set_dim_name(map->p[i], type, pos, s);
		558	if (!map->p[i])
		559	goto error;
		560	}
		561
		562	return map;
		563	error:
		564	isl_map_free(map);
		565	return NULL;
		566	}
		567
		568	__isl_give isl_basic_set *isl_basic_set_set_dim_name(
		569	__isl_take isl_basic_set *bset,
		570	enum isl_dim_type type, unsigned pos, const char *s)
		571	{
		572	return (isl_basic_set *)isl_basic_map_set_dim_name(
		573	(isl_basic_map *)bset, type, pos, s);
		574	}
		575
		576	__isl_give isl_set *isl_set_set_dim_name(__isl_take isl_set *set,
		577	enum isl_dim_type type, unsigned pos, const char *s)
		578	{
		579	return (isl_set *)isl_map_set_dim_name((isl_map *)set, type, pos, s);
		580	}
		581
		582	int isl_basic_map_has_dim_id(__isl_keep isl_basic_map *bmap,
		583	enum isl_dim_type type, unsigned pos)
		584	{
		585	return bmap ? isl_space_has_dim_id(bmap->dim, type, pos) : -1;
		586	}
		587
		588	__isl_give isl_id *isl_basic_set_get_dim_id(__isl_keep isl_basic_set *bset,
		589	enum isl_dim_type type, unsigned pos)
		590	{
		591	return bset ? isl_space_get_dim_id(bset->dim, type, pos) : NULL;
		592	}
		593
		594	int isl_map_has_dim_id(__isl_keep isl_map *map,
		595	enum isl_dim_type type, unsigned pos)
		596	{
		597	return map ? isl_space_has_dim_id(map->dim, type, pos) : -1;
		598	}
		599
		600	__isl_give isl_id *isl_map_get_dim_id(__isl_keep isl_map *map,
		601	enum isl_dim_type type, unsigned pos)
		602	{
		603	return map ? isl_space_get_dim_id(map->dim, type, pos) : NULL;
		604	}
		605
		606	int isl_set_has_dim_id(__isl_keep isl_set *set,
		607	enum isl_dim_type type, unsigned pos)
		608	{
		609	return isl_map_has_dim_id(set, type, pos);
		610	}
		611
		612	__isl_give isl_id *isl_set_get_dim_id(__isl_keep isl_set *set,
		613	enum isl_dim_type type, unsigned pos)
		614	{
		615	return isl_map_get_dim_id(set, type, pos);
		616	}
		617
		618	__isl_give isl_map *isl_map_set_dim_id(__isl_take isl_map *map,
		619	enum isl_dim_type type, unsigned pos, __isl_take isl_id *id)
		620	{
		621	map = isl_map_cow(map);
		622	if (!map)
		623	return isl_id_free(id);
		624
		625	map->dim = isl_space_set_dim_id(map->dim, type, pos, id);
		626
		627	return isl_map_reset_space(map, isl_space_copy(map->dim));
		628	}
		629
		630	__isl_give isl_set *isl_set_set_dim_id(__isl_take isl_set *set,
		631	enum isl_dim_type type, unsigned pos, __isl_take isl_id *id)
		632	{
		633	return isl_map_set_dim_id(set, type, pos, id);
		634	}
		635
		636	int isl_map_find_dim_by_id(__isl_keep isl_map *map, enum isl_dim_type type,
		637	__isl_keep isl_id *id)
		638	{
		639	if (!map)
		640	return -1;
		641	return isl_space_find_dim_by_id(map->dim, type, id);
		642	}
		643
		644	int isl_set_find_dim_by_id(__isl_keep isl_set *set, enum isl_dim_type type,
		645	__isl_keep isl_id *id)
		646	{
		647	return isl_map_find_dim_by_id(set, type, id);
		648	}
		649
		650	int isl_map_find_dim_by_name(__isl_keep isl_map *map, enum isl_dim_type type,
		651	const char *name)
		652	{
		653	if (!map)
		654	return -1;
		655	return isl_space_find_dim_by_name(map->dim, type, name);
		656	}
		657
		658	int isl_set_find_dim_by_name(__isl_keep isl_set *set, enum isl_dim_type type,
		659	const char *name)
		660	{
		661	return isl_map_find_dim_by_name(set, type, name);
		662	}
		663
		664	int isl_basic_map_is_rational(__isl_keep isl_basic_map *bmap)
		665	{
		666	if (!bmap)
		667	return -1;
		668	return ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL);
		669	}
		670
		671	int isl_basic_set_is_rational(__isl_keep isl_basic_set *bset)
		672	{
		673	return isl_basic_map_is_rational(bset);
		674	}
		675
		676	/* Is this basic set a parameter domain?
		677	*/
		678	int isl_basic_set_is_params(__isl_keep isl_basic_set *bset)
		679	{
		680	if (!bset)
		681	return -1;
		682	return isl_space_is_params(bset->dim);
		683	}
		684
		685	/* Is this set a parameter domain?
		686	*/
		687	int isl_set_is_params(__isl_keep isl_set *set)
		688	{
		689	if (!set)
		690	return -1;
		691	return isl_space_is_params(set->dim);
		692	}
		693
		694	/* Is this map actually a parameter domain?
		695	* Users should never call this function. Outside of isl,
		696	* a map can never be a parameter domain.
		697	*/
		698	int isl_map_is_params(__isl_keep isl_map *map)
		699	{
		700	if (!map)
		701	return -1;
		702	return isl_space_is_params(map->dim);
		703	}
		704
		705	static struct isl_basic_map *basic_map_init(struct isl_ctx *ctx,
		706	struct isl_basic_map *bmap, unsigned extra,
		707	unsigned n_eq, unsigned n_ineq)
		708	{
		709	int i;
		710	size_t row_size = 1 + isl_space_dim(bmap->dim, isl_dim_all) + extra;
		711
		712	bmap->ctx = ctx;
		713	isl_ctx_ref(ctx);
		714
		715	bmap->block = isl_blk_alloc(ctx, (n_ineq + n_eq) * row_size);
		716	if (isl_blk_is_error(bmap->block))
		717	goto error;
		718
		719	bmap->ineq = isl_alloc_array(ctx, isl_int *, n_ineq + n_eq);
		720	if (!bmap->ineq)
		721	goto error;
		722
		723	if (extra == 0) {
		724	bmap->block2 = isl_blk_empty();
		725	bmap->div = NULL;
		726	} else {
		727	bmap->block2 = isl_blk_alloc(ctx, extra * (1 + row_size));
		728	if (isl_blk_is_error(bmap->block2))
		729	goto error;
		730
		731	bmap->div = isl_alloc_array(ctx, isl_int *, extra);
		732	if (!bmap->div)
		733	goto error;
		734	}
		735
		736	for (i = 0; i < n_ineq + n_eq; ++i)
		737	bmap->ineq[i] = bmap->block.data + i * row_size;
		738
		739	for (i = 0; i < extra; ++i)
		740	bmap->div[i] = bmap->block2.data + i * (1 + row_size);
		741
		742	bmap->ref = 1;
		743	bmap->flags = 0;
		744	bmap->c_size = n_eq + n_ineq;
		745	bmap->eq = bmap->ineq + n_ineq;
		746	bmap->extra = extra;
		747	bmap->n_eq = 0;
		748	bmap->n_ineq = 0;
		749	bmap->n_div = 0;
		750	bmap->sample = NULL;
		751
		752	return bmap;
		753	error:
		754	isl_basic_map_free(bmap);
		755	return NULL;
		756	}
		757
		758	struct isl_basic_set *isl_basic_set_alloc(struct isl_ctx *ctx,
		759	unsigned nparam, unsigned dim, unsigned extra,
		760	unsigned n_eq, unsigned n_ineq)
		761	{
		762	struct isl_basic_map *bmap;
		763	isl_space *space;
		764
		765	space = isl_space_set_alloc(ctx, nparam, dim);
		766	if (!space)
		767	return NULL;
		768
		769	bmap = isl_basic_map_alloc_space(space, extra, n_eq, n_ineq);
		770	return (struct isl_basic_set *)bmap;
		771	}
		772
		773	struct isl_basic_set *isl_basic_set_alloc_space(__isl_take isl_space *dim,
		774	unsigned extra, unsigned n_eq, unsigned n_ineq)
		775	{
		776	struct isl_basic_map *bmap;
		777	if (!dim)
		778	return NULL;
		779	isl_assert(dim->ctx, dim->n_in == 0, goto error);
		780	bmap = isl_basic_map_alloc_space(dim, extra, n_eq, n_ineq);
		781	return (struct isl_basic_set *)bmap;
		782	error:
		783	isl_space_free(dim);
		784	return NULL;
		785	}
		786
		787	struct isl_basic_map *isl_basic_map_alloc_space(__isl_take isl_space *dim,
		788	unsigned extra, unsigned n_eq, unsigned n_ineq)
		789	{
		790	struct isl_basic_map *bmap;
		791
		792	if (!dim)
		793	return NULL;
		794	bmap = isl_calloc_type(dim->ctx, struct isl_basic_map);
		795	if (!bmap)
		796	goto error;
		797	bmap->dim = dim;
		798
		799	return basic_map_init(dim->ctx, bmap, extra, n_eq, n_ineq);
		800	error:
		801	isl_space_free(dim);
		802	return NULL;
		803	}
		804
		805	struct isl_basic_map *isl_basic_map_alloc(struct isl_ctx *ctx,
		806	unsigned nparam, unsigned in, unsigned out, unsigned extra,
		807	unsigned n_eq, unsigned n_ineq)
		808	{
		809	struct isl_basic_map *bmap;
		810	isl_space *dim;
		811
		812	dim = isl_space_alloc(ctx, nparam, in, out);
		813	if (!dim)
		814	return NULL;
		815
		816	bmap = isl_basic_map_alloc_space(dim, extra, n_eq, n_ineq);
		817	return bmap;
		818	}
		819
		820	static void dup_constraints(
		821	struct isl_basic_map *dst, struct isl_basic_map *src)
		822	{
		823	int i;
		824	unsigned total = isl_basic_map_total_dim(src);
		825
		826	for (i = 0; i < src->n_eq; ++i) {
		827	int j = isl_basic_map_alloc_equality(dst);
		828	isl_seq_cpy(dst->eq[j], src->eq[i], 1+total);
		829	}
		830
		831	for (i = 0; i < src->n_ineq; ++i) {
		832	int j = isl_basic_map_alloc_inequality(dst);
		833	isl_seq_cpy(dst->ineq[j], src->ineq[i], 1+total);
		834	}
		835
		836	for (i = 0; i < src->n_div; ++i) {
		837	int j = isl_basic_map_alloc_div(dst);
		838	isl_seq_cpy(dst->div[j], src->div[i], 1+1+total);
		839	}
		840	ISL_F_SET(dst, ISL_BASIC_SET_FINAL);
		841	}
		842
		843	struct isl_basic_map *isl_basic_map_dup(struct isl_basic_map *bmap)
		844	{
		845	struct isl_basic_map *dup;
		846
		847	if (!bmap)
		848	return NULL;
		849	dup = isl_basic_map_alloc_space(isl_space_copy(bmap->dim),
		850	bmap->n_div, bmap->n_eq, bmap->n_ineq);
		851	if (!dup)
		852	return NULL;
		853	dup_constraints(dup, bmap);
		854	dup->flags = bmap->flags;
		855	dup->sample = isl_vec_copy(bmap->sample);
		856	return dup;
		857	}
		858
		859	struct isl_basic_set *isl_basic_set_dup(struct isl_basic_set *bset)
		860	{
		861	struct isl_basic_map *dup;
		862
		863	dup = isl_basic_map_dup((struct isl_basic_map *)bset);
		864	return (struct isl_basic_set *)dup;
		865	}
		866
		867	struct isl_basic_set *isl_basic_set_copy(struct isl_basic_set *bset)
		868	{
		869	if (!bset)
		870	return NULL;
		871
		872	if (ISL_F_ISSET(bset, ISL_BASIC_SET_FINAL)) {
		873	bset->ref++;
		874	return bset;
		875	}
		876	return isl_basic_set_dup(bset);
		877	}
		878
		879	struct isl_set *isl_set_copy(struct isl_set *set)
		880	{
		881	if (!set)
		882	return NULL;
		883
		884	set->ref++;
		885	return set;
		886	}
		887
		888	struct isl_basic_map *isl_basic_map_copy(struct isl_basic_map *bmap)
		889	{
		890	if (!bmap)
		891	return NULL;
		892
		893	if (ISL_F_ISSET(bmap, ISL_BASIC_SET_FINAL)) {
		894	bmap->ref++;
		895	return bmap;
		896	}
		897	bmap = isl_basic_map_dup(bmap);
		898	if (bmap)
		899	ISL_F_SET(bmap, ISL_BASIC_SET_FINAL);
		900	return bmap;
		901	}
		902
		903	struct isl_map *isl_map_copy(struct isl_map *map)
		904	{
		905	if (!map)
		906	return NULL;
		907
		908	map->ref++;
		909	return map;
		910	}
		911
		912	void isl_basic_map_free(struct isl_basic_map *bmap)
		913	{
		914	if (!bmap)
		915	return;
		916
		917	if (--bmap->ref > 0)
		918	return;
		919
		920	isl_ctx_deref(bmap->ctx);
		921	free(bmap->div);
		922	isl_blk_free(bmap->ctx, bmap->block2);
		923	free(bmap->ineq);
		924	isl_blk_free(bmap->ctx, bmap->block);
		925	isl_vec_free(bmap->sample);
		926	isl_space_free(bmap->dim);
		927	free(bmap);
		928	}
		929
		930	void isl_basic_set_free(struct isl_basic_set *bset)
		931	{
		932	isl_basic_map_free((struct isl_basic_map *)bset);
		933	}
		934
		935	static int room_for_con(struct isl_basic_map *bmap, unsigned n)
		936	{
		937	return bmap->n_eq + bmap->n_ineq + n <= bmap->c_size;
		938	}
		939
		940	__isl_give isl_map *isl_map_align_params_map_map_and(
		941	__isl_take isl_map *map1, __isl_take isl_map *map2,
		942	__isl_give isl_map *(*fn)(__isl_take isl_map *map1,
		943	__isl_take isl_map *map2))
		944	{
		945	if (!map1 || !map2)
		946	goto error;
		947	if (isl_space_match(map1->dim, isl_dim_param, map2->dim, isl_dim_param))
		948	return fn(map1, map2);
		949	if (!isl_space_has_named_params(map1->dim) ||
		950	!isl_space_has_named_params(map2->dim))
		951	isl_die(map1->ctx, isl_error_invalid,
		952	"unaligned unnamed parameters", goto error);
		953	map1 = isl_map_align_params(map1, isl_map_get_space(map2));
		954	map2 = isl_map_align_params(map2, isl_map_get_space(map1));
		955	return fn(map1, map2);
		956	error:
		957	isl_map_free(map1);
		958	isl_map_free(map2);
		959	return NULL;
		960	}
		961
		962	int isl_map_align_params_map_map_and_test(__isl_keep isl_map *map1,
		963	__isl_keep isl_map *map2,
		964	int (*fn)(__isl_keep isl_map *map1, __isl_keep isl_map *map2))
		965	{
		966	int r;
		967
		968	if (!map1 || !map2)
		969	return -1;
		970	if (isl_space_match(map1->dim, isl_dim_param, map2->dim, isl_dim_param))
		971	return fn(map1, map2);
		972	if (!isl_space_has_named_params(map1->dim) ||
		973	!isl_space_has_named_params(map2->dim))
		974	isl_die(map1->ctx, isl_error_invalid,
		975	"unaligned unnamed parameters", return -1);
		976	map1 = isl_map_copy(map1);
		977	map2 = isl_map_copy(map2);
		978	map1 = isl_map_align_params(map1, isl_map_get_space(map2));
		979	map2 = isl_map_align_params(map2, isl_map_get_space(map1));
		980	r = fn(map1, map2);
		981	isl_map_free(map1);
		982	isl_map_free(map2);
		983	return r;
		984	}
		985
		986	int isl_basic_map_alloc_equality(struct isl_basic_map *bmap)
		987	{
		988	struct isl_ctx *ctx;
		989	if (!bmap)
		990	return -1;
		991	ctx = bmap->ctx;
		992	isl_assert(ctx, room_for_con(bmap, 1), return -1);
		993	isl_assert(ctx, (bmap->eq - bmap->ineq) + bmap->n_eq <= bmap->c_size,
		994	return -1);
		995	ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
		996	ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT);
		997	ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_IMPLICIT);
		998	ISL_F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES);
		999	ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
		1000	if ((bmap->eq - bmap->ineq) + bmap->n_eq == bmap->c_size) {
		1001	isl_int *t;
		1002	int j = isl_basic_map_alloc_inequality(bmap);
		1003	if (j < 0)
		1004	return -1;
		1005	t = bmap->ineq[j];
		1006	bmap->ineq[j] = bmap->ineq[bmap->n_ineq - 1];
		1007	bmap->ineq[bmap->n_ineq - 1] = bmap->eq[-1];
		1008	bmap->eq[-1] = t;
		1009	bmap->n_eq++;
		1010	bmap->n_ineq--;
		1011	bmap->eq--;
		1012	return 0;
		1013	}
		1014	isl_seq_clr(bmap->eq[bmap->n_eq] + 1 + isl_basic_map_total_dim(bmap),
		1015	bmap->extra - bmap->n_div);
		1016	return bmap->n_eq++;
		1017	}
		1018
		1019	int isl_basic_set_alloc_equality(struct isl_basic_set *bset)
		1020	{
		1021	return isl_basic_map_alloc_equality((struct isl_basic_map *)bset);
		1022	}
		1023
		1024	int isl_basic_map_free_equality(struct isl_basic_map *bmap, unsigned n)
		1025	{
		1026	if (!bmap)
		1027	return -1;
		1028	isl_assert(bmap->ctx, n <= bmap->n_eq, return -1);
		1029	bmap->n_eq -= n;
		1030	return 0;
		1031	}
		1032
		1033	int isl_basic_set_free_equality(struct isl_basic_set *bset, unsigned n)
		1034	{
		1035	return isl_basic_map_free_equality((struct isl_basic_map *)bset, n);
		1036	}
		1037
		1038	int isl_basic_map_drop_equality(struct isl_basic_map *bmap, unsigned pos)
		1039	{
		1040	isl_int *t;
		1041	if (!bmap)
		1042	return -1;
		1043	isl_assert(bmap->ctx, pos < bmap->n_eq, return -1);
		1044
		1045	if (pos != bmap->n_eq - 1) {
		1046	t = bmap->eq[pos];
		1047	bmap->eq[pos] = bmap->eq[bmap->n_eq - 1];
		1048	bmap->eq[bmap->n_eq - 1] = t;
		1049	}
		1050	bmap->n_eq--;
		1051	return 0;
		1052	}
		1053
		1054	int isl_basic_set_drop_equality(struct isl_basic_set *bset, unsigned pos)
		1055	{
		1056	return isl_basic_map_drop_equality((struct isl_basic_map *)bset, pos);
		1057	}
		1058
		1059	void isl_basic_map_inequality_to_equality(
		1060	struct isl_basic_map *bmap, unsigned pos)
		1061	{
		1062	isl_int *t;
		1063
		1064	t = bmap->ineq[pos];
		1065	bmap->ineq[pos] = bmap->ineq[bmap->n_ineq - 1];
		1066	bmap->ineq[bmap->n_ineq - 1] = bmap->eq[-1];
		1067	bmap->eq[-1] = t;
		1068	bmap->n_eq++;
		1069	bmap->n_ineq--;
		1070	bmap->eq--;
		1071	ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT);
		1072	ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
		1073	ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
		1074	ISL_F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES);
		1075	}
		1076
		1077	static int room_for_ineq(struct isl_basic_map *bmap, unsigned n)
		1078	{
		1079	return bmap->n_ineq + n <= bmap->eq - bmap->ineq;
		1080	}
		1081
		1082	int isl_basic_map_alloc_inequality(struct isl_basic_map *bmap)
		1083	{
		1084	struct isl_ctx *ctx;
		1085	if (!bmap)
		1086	return -1;
		1087	ctx = bmap->ctx;
		1088	isl_assert(ctx, room_for_ineq(bmap, 1), return -1);
		1089	ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_IMPLICIT);
		1090	ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT);
		1091	ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
		1092	ISL_F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES);
		1093	isl_seq_clr(bmap->ineq[bmap->n_ineq] +
		1094	1 + isl_basic_map_total_dim(bmap),
		1095	bmap->extra - bmap->n_div);
		1096	return bmap->n_ineq++;
		1097	}
		1098
		1099	int isl_basic_set_alloc_inequality(struct isl_basic_set *bset)
		1100	{
		1101	return isl_basic_map_alloc_inequality((struct isl_basic_map *)bset);
		1102	}
		1103
		1104	int isl_basic_map_free_inequality(struct isl_basic_map *bmap, unsigned n)
		1105	{
		1106	if (!bmap)
		1107	return -1;
		1108	isl_assert(bmap->ctx, n <= bmap->n_ineq, return -1);
		1109	bmap->n_ineq -= n;
		1110	return 0;
		1111	}
		1112
		1113	int isl_basic_set_free_inequality(struct isl_basic_set *bset, unsigned n)
		1114	{
		1115	return isl_basic_map_free_inequality((struct isl_basic_map *)bset, n);
		1116	}
		1117
		1118	int isl_basic_map_drop_inequality(struct isl_basic_map *bmap, unsigned pos)
		1119	{
		1120	isl_int *t;
		1121	if (!bmap)
		1122	return -1;
		1123	isl_assert(bmap->ctx, pos < bmap->n_ineq, return -1);
		1124
		1125	if (pos != bmap->n_ineq - 1) {
		1126	t = bmap->ineq[pos];
		1127	bmap->ineq[pos] = bmap->ineq[bmap->n_ineq - 1];
		1128	bmap->ineq[bmap->n_ineq - 1] = t;
		1129	ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
		1130	}
		1131	bmap->n_ineq--;
		1132	return 0;
		1133	}
		1134
		1135	int isl_basic_set_drop_inequality(struct isl_basic_set *bset, unsigned pos)
		1136	{
		1137	return isl_basic_map_drop_inequality((struct isl_basic_map *)bset, pos);
		1138	}
		1139
		1140	__isl_give isl_basic_map *isl_basic_map_add_eq(__isl_take isl_basic_map *bmap,
		1141	isl_int *eq)
		1142	{
		1143	int k;
		1144
		1145	bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
		1146	if (!bmap)
		1147	return NULL;
		1148	k = isl_basic_map_alloc_equality(bmap);
		1149	if (k < 0)
		1150	goto error;
		1151	isl_seq_cpy(bmap->eq[k], eq, 1 + isl_basic_map_total_dim(bmap));
		1152	return bmap;
		1153	error:
		1154	isl_basic_map_free(bmap);
		1155	return NULL;
		1156	}
		1157
		1158	__isl_give isl_basic_set *isl_basic_set_add_eq(__isl_take isl_basic_set *bset,
		1159	isl_int *eq)
		1160	{
		1161	return (isl_basic_set *)
		1162	isl_basic_map_add_eq((isl_basic_map *)bset, eq);
		1163	}
		1164
		1165	__isl_give isl_basic_map *isl_basic_map_add_ineq(__isl_take isl_basic_map *bmap,
		1166	isl_int *ineq)
		1167	{
		1168	int k;
		1169
		1170	bmap = isl_basic_map_extend_constraints(bmap, 0, 1);
		1171	if (!bmap)
		1172	return NULL;
		1173	k = isl_basic_map_alloc_inequality(bmap);
		1174	if (k < 0)
		1175	goto error;
		1176	isl_seq_cpy(bmap->ineq[k], ineq, 1 + isl_basic_map_total_dim(bmap));
		1177	return bmap;
		1178	error:
		1179	isl_basic_map_free(bmap);
		1180	return NULL;
		1181	}
		1182
		1183	__isl_give isl_basic_set *isl_basic_set_add_ineq(__isl_take isl_basic_set *bset,
		1184	isl_int *ineq)
		1185	{
		1186	return (isl_basic_set *)
		1187	isl_basic_map_add_ineq((isl_basic_map *)bset, ineq);
		1188	}
		1189
		1190	int isl_basic_map_alloc_div(struct isl_basic_map *bmap)
		1191	{
		1192	if (!bmap)
		1193	return -1;
		1194	isl_assert(bmap->ctx, bmap->n_div < bmap->extra, return -1);
		1195	isl_seq_clr(bmap->div[bmap->n_div] +
		1196	1 + 1 + isl_basic_map_total_dim(bmap),
		1197	bmap->extra - bmap->n_div);
		1198	ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
		1199	return bmap->n_div++;
		1200	}
		1201
		1202	int isl_basic_set_alloc_div(struct isl_basic_set *bset)
		1203	{
		1204	return isl_basic_map_alloc_div((struct isl_basic_map *)bset);
		1205	}
		1206
		1207	int isl_basic_map_free_div(struct isl_basic_map *bmap, unsigned n)
		1208	{
		1209	if (!bmap)
		1210	return -1;
		1211	isl_assert(bmap->ctx, n <= bmap->n_div, return -1);
		1212	bmap->n_div -= n;
		1213	return 0;
		1214	}
		1215
		1216	int isl_basic_set_free_div(struct isl_basic_set *bset, unsigned n)
		1217	{
		1218	return isl_basic_map_free_div((struct isl_basic_map *)bset, n);
		1219	}
		1220
		1221	/* Copy constraint from src to dst, putting the vars of src at offset
		1222	* dim_off in dst and the divs of src at offset div_off in dst.
		1223	* If both sets are actually map, then dim_off applies to the input
		1224	* variables.
		1225	*/
		1226	static void copy_constraint(struct isl_basic_map *dst_map, isl_int *dst,
		1227	struct isl_basic_map *src_map, isl_int *src,
		1228	unsigned in_off, unsigned out_off, unsigned div_off)
		1229	{
		1230	unsigned src_nparam = isl_basic_map_n_param(src_map);
		1231	unsigned dst_nparam = isl_basic_map_n_param(dst_map);
		1232	unsigned src_in = isl_basic_map_n_in(src_map);
		1233	unsigned dst_in = isl_basic_map_n_in(dst_map);
		1234	unsigned src_out = isl_basic_map_n_out(src_map);
		1235	unsigned dst_out = isl_basic_map_n_out(dst_map);
		1236	isl_int_set(dst[0], src[0]);
		1237	isl_seq_cpy(dst+1, src+1, isl_min(dst_nparam, src_nparam));
		1238	if (dst_nparam > src_nparam)
		1239	isl_seq_clr(dst+1+src_nparam,
		1240	dst_nparam - src_nparam);
		1241	isl_seq_clr(dst+1+dst_nparam, in_off);
		1242	isl_seq_cpy(dst+1+dst_nparam+in_off,
		1243	src+1+src_nparam,
		1244	isl_min(dst_in-in_off, src_in));
		1245	if (dst_in-in_off > src_in)
		1246	isl_seq_clr(dst+1+dst_nparam+in_off+src_in,
		1247	dst_in - in_off - src_in);
		1248	isl_seq_clr(dst+1+dst_nparam+dst_in, out_off);
		1249	isl_seq_cpy(dst+1+dst_nparam+dst_in+out_off,
		1250	src+1+src_nparam+src_in,
		1251	isl_min(dst_out-out_off, src_out));
		1252	if (dst_out-out_off > src_out)
		1253	isl_seq_clr(dst+1+dst_nparam+dst_in+out_off+src_out,
		1254	dst_out - out_off - src_out);
		1255	isl_seq_clr(dst+1+dst_nparam+dst_in+dst_out, div_off);
		1256	isl_seq_cpy(dst+1+dst_nparam+dst_in+dst_out+div_off,
		1257	src+1+src_nparam+src_in+src_out,
		1258	isl_min(dst_map->extra-div_off, src_map->n_div));
		1259	if (dst_map->n_div-div_off > src_map->n_div)
		1260	isl_seq_clr(dst+1+dst_nparam+dst_in+dst_out+
		1261	div_off+src_map->n_div,
		1262	dst_map->n_div - div_off - src_map->n_div);
		1263	}
		1264
		1265	static void copy_div(struct isl_basic_map *dst_map, isl_int *dst,
		1266	struct isl_basic_map *src_map, isl_int *src,
		1267	unsigned in_off, unsigned out_off, unsigned div_off)
		1268	{
		1269	isl_int_set(dst[0], src[0]);
		1270	copy_constraint(dst_map, dst+1, src_map, src+1, in_off, out_off, div_off);
		1271	}
		1272
		1273	static struct isl_basic_map *add_constraints(struct isl_basic_map *bmap1,
		1274	struct isl_basic_map *bmap2, unsigned i_pos, unsigned o_pos)
		1275	{
		1276	int i;
		1277	unsigned div_off;
		1278
		1279	if (!bmap1 || !bmap2)
		1280	goto error;
		1281
		1282	div_off = bmap1->n_div;
		1283
		1284	for (i = 0; i < bmap2->n_eq; ++i) {
		1285	int i1 = isl_basic_map_alloc_equality(bmap1);
		1286	if (i1 < 0)
		1287	goto error;
		1288	copy_constraint(bmap1, bmap1->eq[i1], bmap2, bmap2->eq[i],
		1289	i_pos, o_pos, div_off);
		1290	}
		1291
		1292	for (i = 0; i < bmap2->n_ineq; ++i) {
		1293	int i1 = isl_basic_map_alloc_inequality(bmap1);
		1294	if (i1 < 0)
		1295	goto error;
		1296	copy_constraint(bmap1, bmap1->ineq[i1], bmap2, bmap2->ineq[i],
		1297	i_pos, o_pos, div_off);
		1298	}
		1299
		1300	for (i = 0; i < bmap2->n_div; ++i) {
		1301	int i1 = isl_basic_map_alloc_div(bmap1);
		1302	if (i1 < 0)
		1303	goto error;
		1304	copy_div(bmap1, bmap1->div[i1], bmap2, bmap2->div[i],
		1305	i_pos, o_pos, div_off);
		1306	}
		1307
		1308	isl_basic_map_free(bmap2);
		1309
		1310	return bmap1;
		1311
		1312	error:
		1313	isl_basic_map_free(bmap1);
		1314	isl_basic_map_free(bmap2);
		1315	return NULL;
		1316	}
		1317
		1318	struct isl_basic_set *isl_basic_set_add_constraints(struct isl_basic_set *bset1,
		1319	struct isl_basic_set *bset2, unsigned pos)
		1320	{
		1321	return (struct isl_basic_set *)
		1322	add_constraints((struct isl_basic_map *)bset1,
		1323	(struct isl_basic_map *)bset2, 0, pos);
		1324	}
		1325
		1326	struct isl_basic_map *isl_basic_map_extend_space(struct isl_basic_map *base,
		1327	__isl_take isl_space *dim, unsigned extra,
		1328	unsigned n_eq, unsigned n_ineq)
		1329	{
		1330	struct isl_basic_map *ext;
		1331	unsigned flags;
		1332	int dims_ok;
		1333
		1334	if (!dim)
		1335	goto error;
		1336
		1337	if (!base)
		1338	goto error;
		1339
		1340	dims_ok = isl_space_is_equal(base->dim, dim) &&
		1341	base->extra >= base->n_div + extra;
		1342
		1343	if (dims_ok && room_for_con(base, n_eq + n_ineq) &&
		1344	room_for_ineq(base, n_ineq)) {
		1345	isl_space_free(dim);
		1346	return base;
		1347	}
		1348
		1349	isl_assert(base->ctx, base->dim->nparam <= dim->nparam, goto error);
		1350	isl_assert(base->ctx, base->dim->n_in <= dim->n_in, goto error);
		1351	isl_assert(base->ctx, base->dim->n_out <= dim->n_out, goto error);
		1352	extra += base->extra;
		1353	n_eq += base->n_eq;
		1354	n_ineq += base->n_ineq;
		1355
		1356	ext = isl_basic_map_alloc_space(dim, extra, n_eq, n_ineq);
		1357	dim = NULL;
		1358	if (!ext)
		1359	goto error;
		1360
		1361	if (dims_ok)
		1362	ext->sample = isl_vec_copy(base->sample);
		1363	flags = base->flags;
		1364	ext = add_constraints(ext, base, 0, 0);
		1365	if (ext) {
		1366	ext->flags = flags;
		1367	ISL_F_CLR(ext, ISL_BASIC_SET_FINAL);
		1368	}
		1369
		1370	return ext;
		1371
		1372	error:
		1373	isl_space_free(dim);
		1374	isl_basic_map_free(base);
		1375	return NULL;
		1376	}
		1377
		1378	struct isl_basic_set *isl_basic_set_extend_space(struct isl_basic_set *base,
		1379	__isl_take isl_space *dim, unsigned extra,
		1380	unsigned n_eq, unsigned n_ineq)
		1381	{
		1382	return (struct isl_basic_set *)
		1383	isl_basic_map_extend_space((struct isl_basic_map *)base, dim,
		1384	extra, n_eq, n_ineq);
		1385	}
		1386
		1387	struct isl_basic_map *isl_basic_map_extend_constraints(
		1388	struct isl_basic_map *base, unsigned n_eq, unsigned n_ineq)
		1389	{
		1390	if (!base)
		1391	return NULL;
		1392	return isl_basic_map_extend_space(base, isl_space_copy(base->dim),
		1393	0, n_eq, n_ineq);
		1394	}
		1395
		1396	struct isl_basic_map *isl_basic_map_extend(struct isl_basic_map *base,
		1397	unsigned nparam, unsigned n_in, unsigned n_out, unsigned extra,
		1398	unsigned n_eq, unsigned n_ineq)
		1399	{
		1400	struct isl_basic_map *bmap;
		1401	isl_space *dim;
		1402
		1403	if (!base)
		1404	return NULL;
		1405	dim = isl_space_alloc(base->ctx, nparam, n_in, n_out);
		1406	if (!dim)
		1407	goto error;
		1408
		1409	bmap = isl_basic_map_extend_space(base, dim, extra, n_eq, n_ineq);
		1410	return bmap;
		1411	error:
		1412	isl_basic_map_free(base);
		1413	return NULL;
		1414	}
		1415
		1416	struct isl_basic_set *isl_basic_set_extend(struct isl_basic_set *base,
		1417	unsigned nparam, unsigned dim, unsigned extra,
		1418	unsigned n_eq, unsigned n_ineq)
		1419	{
		1420	return (struct isl_basic_set *)
		1421	isl_basic_map_extend((struct isl_basic_map *)base,
		1422	nparam, 0, dim, extra, n_eq, n_ineq);
		1423	}
		1424
		1425	struct isl_basic_set *isl_basic_set_extend_constraints(
		1426	struct isl_basic_set *base, unsigned n_eq, unsigned n_ineq)
		1427	{
		1428	return (struct isl_basic_set *)
		1429	isl_basic_map_extend_constraints((struct isl_basic_map *)base,
		1430	n_eq, n_ineq);
		1431	}
		1432
		1433	struct isl_basic_set *isl_basic_set_cow(struct isl_basic_set *bset)
		1434	{
		1435	return (struct isl_basic_set *)
		1436	isl_basic_map_cow((struct isl_basic_map *)bset);
		1437	}
		1438
		1439	struct isl_basic_map *isl_basic_map_cow(struct isl_basic_map *bmap)
		1440	{
		1441	if (!bmap)
		1442	return NULL;
		1443
		1444	if (bmap->ref > 1) {
		1445	bmap->ref--;
		1446	bmap = isl_basic_map_dup(bmap);
		1447	}
		1448	if (bmap)
		1449	ISL_F_CLR(bmap, ISL_BASIC_SET_FINAL);
		1450	return bmap;
		1451	}
		1452
		1453	struct isl_set *isl_set_cow(struct isl_set *set)
		1454	{
		1455	if (!set)
		1456	return NULL;
		1457
		1458	if (set->ref == 1)
		1459	return set;
		1460	set->ref--;
		1461	return isl_set_dup(set);
		1462	}
		1463
		1464	struct isl_map *isl_map_cow(struct isl_map *map)
		1465	{
		1466	if (!map)
		1467	return NULL;
		1468
		1469	if (map->ref == 1)
		1470	return map;
		1471	map->ref--;
		1472	return isl_map_dup(map);
		1473	}
		1474
		1475	static void swap_vars(struct isl_blk blk, isl_int *a,
		1476	unsigned a_len, unsigned b_len)
		1477	{
		1478	isl_seq_cpy(blk.data, a+a_len, b_len);
		1479	isl_seq_cpy(blk.data+b_len, a, a_len);
		1480	isl_seq_cpy(a, blk.data, b_len+a_len);
		1481	}
		1482
		1483	static __isl_give isl_basic_map *isl_basic_map_swap_vars(
		1484	__isl_take isl_basic_map *bmap, unsigned pos, unsigned n1, unsigned n2)
		1485	{
		1486	int i;
		1487	struct isl_blk blk;
		1488
		1489	if (!bmap)
		1490	goto error;
		1491
		1492	isl_assert(bmap->ctx,
		1493	pos + n1 + n2 <= 1 + isl_basic_map_total_dim(bmap), goto error);
		1494
		1495	if (n1 == 0 || n2 == 0)
		1496	return bmap;
		1497
		1498	bmap = isl_basic_map_cow(bmap);
		1499	if (!bmap)
		1500	return NULL;
		1501
		1502	blk = isl_blk_alloc(bmap->ctx, n1 + n2);
		1503	if (isl_blk_is_error(blk))
		1504	goto error;
		1505
		1506	for (i = 0; i < bmap->n_eq; ++i)
		1507	swap_vars(blk,
		1508	bmap->eq[i] + pos, n1, n2);
		1509
		1510	for (i = 0; i < bmap->n_ineq; ++i)
		1511	swap_vars(blk,
		1512	bmap->ineq[i] + pos, n1, n2);
		1513
		1514	for (i = 0; i < bmap->n_div; ++i)
		1515	swap_vars(blk,
		1516	bmap->div[i]+1 + pos, n1, n2);
		1517
		1518	isl_blk_free(bmap->ctx, blk);
		1519
		1520	ISL_F_CLR(bmap, ISL_BASIC_SET_NORMALIZED);
		1521	bmap = isl_basic_map_gauss(bmap, NULL);
		1522	return isl_basic_map_finalize(bmap);
		1523	error:
		1524	isl_basic_map_free(bmap);
		1525	return NULL;
		1526	}
		1527
		1528	static __isl_give isl_basic_set *isl_basic_set_swap_vars(
		1529	__isl_take isl_basic_set *bset, unsigned n)
		1530	{
		1531	unsigned dim;
		1532	unsigned nparam;
		1533
		1534	nparam = isl_basic_set_n_param(bset);
		1535	dim = isl_basic_set_n_dim(bset);
		1536	isl_assert(bset->ctx, n <= dim, goto error);
		1537
		1538	return isl_basic_map_swap_vars(bset, 1 + nparam, n, dim - n);
		1539	error:
		1540	isl_basic_set_free(bset);
		1541	return NULL;
		1542	}
		1543
		1544	struct isl_basic_map *isl_basic_map_set_to_empty(struct isl_basic_map *bmap)
		1545	{
		1546	int i = 0;
		1547	unsigned total;
		1548	if (!bmap)
		1549	goto error;
		1550	total = isl_basic_map_total_dim(bmap);
		1551	isl_basic_map_free_div(bmap, bmap->n_div);
		1552	isl_basic_map_free_inequality(bmap, bmap->n_ineq);
		1553	if (bmap->n_eq > 0)
		1554	isl_basic_map_free_equality(bmap, bmap->n_eq-1);
		1555	else {
		1556	i = isl_basic_map_alloc_equality(bmap);
		1557	if (i < 0)
		1558	goto error;
		1559	}
		1560	isl_int_set_si(bmap->eq[i][0], 1);
		1561	isl_seq_clr(bmap->eq[i]+1, total);
		1562	ISL_F_SET(bmap, ISL_BASIC_MAP_EMPTY);
		1563	isl_vec_free(bmap->sample);
		1564	bmap->sample = NULL;
		1565	return isl_basic_map_finalize(bmap);
		1566	error:
		1567	isl_basic_map_free(bmap);
		1568	return NULL;
		1569	}
		1570
		1571	struct isl_basic_set *isl_basic_set_set_to_empty(struct isl_basic_set *bset)
		1572	{
		1573	return (struct isl_basic_set *)
		1574	isl_basic_map_set_to_empty((struct isl_basic_map *)bset);
		1575	}
		1576
		1577	void isl_basic_map_swap_div(struct isl_basic_map *bmap, int a, int b)
		1578	{
		1579	int i;
		1580	unsigned off = isl_space_dim(bmap->dim, isl_dim_all);
		1581	isl_int *t = bmap->div[a];
		1582	bmap->div[a] = bmap->div[b];
		1583	bmap->div[b] = t;
		1584
		1585	for (i = 0; i < bmap->n_eq; ++i)
		1586	isl_int_swap(bmap->eq[i][1+off+a], bmap->eq[i][1+off+b]);
		1587
		1588	for (i = 0; i < bmap->n_ineq; ++i)
		1589	isl_int_swap(bmap->ineq[i][1+off+a], bmap->ineq[i][1+off+b]);
		1590
		1591	for (i = 0; i < bmap->n_div; ++i)
		1592	isl_int_swap(bmap->div[i][1+1+off+a], bmap->div[i][1+1+off+b]);
		1593	ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
		1594	}
		1595
		1596	/* Eliminate the specified n dimensions starting at first from the
		1597	* constraints using Fourier-Motzkin. The dimensions themselves
		1598	* are not removed.
		1599	*/
		1600	__isl_give isl_map *isl_map_eliminate(__isl_take isl_map *map,
		1601	enum isl_dim_type type, unsigned first, unsigned n)
		1602	{
		1603	int i;
		1604
		1605	if (!map)
		1606	return NULL;
		1607	if (n == 0)
		1608	return map;
		1609
		1610	map = isl_map_cow(map);
		1611	if (!map)
		1612	return NULL;
		1613
		1614	for (i = 0; i < map->n; ++i) {
		1615	map->p[i] = isl_basic_map_eliminate(map->p[i], type, first, n);
		1616	if (!map->p[i])
		1617	goto error;
		1618	}
		1619	return map;
		1620	error:
		1621	isl_map_free(map);
		1622	return NULL;
		1623	}
		1624
		1625	/* Eliminate the specified n dimensions starting at first from the
		1626	* constraints using Fourier-Motzkin. The dimensions themselves
		1627	* are not removed.
		1628	*/
		1629	__isl_give isl_set *isl_set_eliminate(__isl_take isl_set *set,
		1630	enum isl_dim_type type, unsigned first, unsigned n)
		1631	{
		1632	return (isl_set *)isl_map_eliminate((isl_map *)set, type, first, n);
		1633	}
		1634
		1635	/* Eliminate the specified n dimensions starting at first from the
		1636	* constraints using Fourier-Motzkin. The dimensions themselves
		1637	* are not removed.
		1638	*/
		1639	__isl_give isl_set *isl_set_eliminate_dims(__isl_take isl_set *set,
		1640	unsigned first, unsigned n)
		1641	{
		1642	return isl_set_eliminate(set, isl_dim_set, first, n);
		1643	}
		1644
		1645	__isl_give isl_basic_map *isl_basic_map_remove_divs(
		1646	__isl_take isl_basic_map *bmap)
		1647	{
		1648	if (!bmap)
		1649	return NULL;
		1650	bmap = isl_basic_map_eliminate_vars(bmap,
		1651	isl_space_dim(bmap->dim, isl_dim_all), bmap->n_div);
		1652	if (!bmap)
		1653	return NULL;
		1654	bmap->n_div = 0;
		1655	return isl_basic_map_finalize(bmap);
		1656	}
		1657
		1658	__isl_give isl_basic_set *isl_basic_set_remove_divs(
		1659	__isl_take isl_basic_set *bset)
		1660	{
		1661	return (struct isl_basic_set *)isl_basic_map_remove_divs(
		1662	(struct isl_basic_map *)bset);
		1663	}
		1664
		1665	__isl_give isl_map *isl_map_remove_divs(__isl_take isl_map *map)
		1666	{
		1667	int i;
		1668
		1669	if (!map)
		1670	return NULL;
		1671	if (map->n == 0)
		1672	return map;
		1673
		1674	map = isl_map_cow(map);
		1675	if (!map)
		1676	return NULL;
		1677
		1678	for (i = 0; i < map->n; ++i) {
		1679	map->p[i] = isl_basic_map_remove_divs(map->p[i]);
		1680	if (!map->p[i])
		1681	goto error;
		1682	}
		1683	return map;
		1684	error:
		1685	isl_map_free(map);
		1686	return NULL;
		1687	}
		1688
		1689	__isl_give isl_set *isl_set_remove_divs(__isl_take isl_set *set)
		1690	{
		1691	return isl_map_remove_divs(set);
		1692	}
		1693
		1694	struct isl_basic_map *isl_basic_map_remove_dims(struct isl_basic_map *bmap,
		1695	enum isl_dim_type type, unsigned first, unsigned n)
		1696	{
		1697	if (!bmap)
		1698	return NULL;
		1699	isl_assert(bmap->ctx, first + n <= isl_basic_map_dim(bmap, type),
		1700	goto error);
		1701	if (n == 0 && !isl_space_is_named_or_nested(bmap->dim, type))
		1702	return bmap;
		1703	bmap = isl_basic_map_eliminate_vars(bmap,
		1704	isl_basic_map_offset(bmap, type) - 1 + first, n);
		1705	if (!bmap)
		1706	return bmap;
		1707	if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY) && type == isl_dim_div)
		1708	return bmap;
		1709	bmap = isl_basic_map_drop(bmap, type, first, n);
		1710	return bmap;
		1711	error:
		1712	isl_basic_map_free(bmap);
		1713	return NULL;
		1714	}
		1715
		1716	/* Return true if the definition of the given div (recursively) involves
		1717	* any of the given variables.
		1718	*/
		1719	static int div_involves_vars(__isl_keep isl_basic_map *bmap, int div,
		1720	unsigned first, unsigned n)
		1721	{
		1722	int i;
		1723	unsigned div_offset = isl_basic_map_offset(bmap, isl_dim_div);
		1724
		1725	if (isl_int_is_zero(bmap->div[div][0]))
		1726	return 0;
		1727	if (isl_seq_first_non_zero(bmap->div[div] + 1 + first, n) >= 0)
		1728	return 1;
		1729
		1730	for (i = bmap->n_div - 1; i >= 0; --i) {
		1731	if (isl_int_is_zero(bmap->div[div][1 + div_offset + i]))
		1732	continue;
		1733	if (div_involves_vars(bmap, i, first, n))
		1734	return 1;
		1735	}
		1736
		1737	return 0;
		1738	}
		1739
		1740	/* Remove all divs (recursively) involving any of the given dimensions
		1741	* in their definitions.
		1742	*/
		1743	__isl_give isl_basic_map *isl_basic_map_remove_divs_involving_dims(
		1744	__isl_take isl_basic_map *bmap,
		1745	enum isl_dim_type type, unsigned first, unsigned n)
		1746	{
		1747	int i;
		1748
		1749	if (!bmap)
		1750	return NULL;
		1751	isl_assert(bmap->ctx, first + n <= isl_basic_map_dim(bmap, type),
		1752	goto error);
		1753	first += isl_basic_map_offset(bmap, type);
		1754
		1755	for (i = bmap->n_div - 1; i >= 0; --i) {
		1756	if (!div_involves_vars(bmap, i, first, n))
		1757	continue;
		1758	bmap = isl_basic_map_remove_dims(bmap, isl_dim_div, i, 1);
		1759	if (!bmap)
		1760	return NULL;
		1761	i = bmap->n_div;
		1762	}
		1763
		1764	return bmap;
		1765	error:
		1766	isl_basic_map_free(bmap);
		1767	return NULL;
		1768	}
		1769
		1770	__isl_give isl_map *isl_map_remove_divs_involving_dims(__isl_take isl_map *map,
		1771	enum isl_dim_type type, unsigned first, unsigned n)
		1772	{
		1773	int i;
		1774
		1775	if (!map)
		1776	return NULL;
		1777	if (map->n == 0)
		1778	return map;
		1779
		1780	map = isl_map_cow(map);
		1781	if (!map)
		1782	return NULL;
		1783
		1784	for (i = 0; i < map->n; ++i) {
		1785	map->p[i] = isl_basic_map_remove_divs_involving_dims(map->p[i],
		1786	type, first, n);
		1787	if (!map->p[i])
		1788	goto error;
		1789	}
		1790	return map;
		1791	error:
		1792	isl_map_free(map);
		1793	return NULL;
		1794	}
		1795
		1796	__isl_give isl_set *isl_set_remove_divs_involving_dims(__isl_take isl_set *set,
		1797	enum isl_dim_type type, unsigned first, unsigned n)
		1798	{
		1799	return (isl_set *)isl_map_remove_divs_involving_dims((isl_map *)set,
		1800	type, first, n);
		1801	}
		1802
		1803	/* Does the desciption of "bmap" depend on the specified dimensions?
		1804	* We also check whether the dimensions appear in any of the div definitions.
		1805	* In principle there is no need for this check. If the dimensions appear
		1806	* in a div definition, they also appear in the defining constraints of that
		1807	* div.
		1808	*/
		1809	int isl_basic_map_involves_dims(__isl_keep isl_basic_map *bmap,
		1810	enum isl_dim_type type, unsigned first, unsigned n)
		1811	{
		1812	int i;
		1813
		1814	if (!bmap)
		1815	return -1;
		1816
		1817	if (first + n > isl_basic_map_dim(bmap, type))
		1818	isl_die(bmap->ctx, isl_error_invalid,
		1819	"index out of bounds", return -1);
		1820
		1821	first += isl_basic_map_offset(bmap, type);
		1822	for (i = 0; i < bmap->n_eq; ++i)
		1823	if (isl_seq_first_non_zero(bmap->eq[i] + first, n) >= 0)
		1824	return 1;
		1825	for (i = 0; i < bmap->n_ineq; ++i)
		1826	if (isl_seq_first_non_zero(bmap->ineq[i] + first, n) >= 0)
		1827	return 1;
		1828	for (i = 0; i < bmap->n_div; ++i) {
		1829	if (isl_int_is_zero(bmap->div[i][0]))
		1830	continue;
		1831	if (isl_seq_first_non_zero(bmap->div[i] + 1 + first, n) >= 0)
		1832	return 1;
		1833	}
		1834
		1835	return 0;
		1836	}
		1837
		1838	int isl_map_involves_dims(__isl_keep isl_map *map,
		1839	enum isl_dim_type type, unsigned first, unsigned n)
		1840	{
		1841	int i;
		1842
		1843	if (!map)
		1844	return -1;
		1845
		1846	if (first + n > isl_map_dim(map, type))
		1847	isl_die(map->ctx, isl_error_invalid,
		1848	"index out of bounds", return -1);
		1849
		1850	for (i = 0; i < map->n; ++i) {
		1851	int involves = isl_basic_map_involves_dims(map->p[i],
		1852	type, first, n);
		1853	if (involves < 0 || involves)
		1854	return involves;
		1855	}
		1856
		1857	return 0;
		1858	}
		1859
		1860	int isl_basic_set_involves_dims(__isl_keep isl_basic_set *bset,
		1861	enum isl_dim_type type, unsigned first, unsigned n)
		1862	{
		1863	return isl_basic_map_involves_dims(bset, type, first, n);
		1864	}
		1865
		1866	int isl_set_involves_dims(__isl_keep isl_set *set,
		1867	enum isl_dim_type type, unsigned first, unsigned n)
		1868	{
		1869	return isl_map_involves_dims(set, type, first, n);
		1870	}
		1871
		1872	/* Return true if the definition of the given div is unknown or depends
		1873	* on unknown divs.
		1874	*/
		1875	static int div_is_unknown(__isl_keep isl_basic_map *bmap, int div)
		1876	{
		1877	int i;
		1878	unsigned div_offset = isl_basic_map_offset(bmap, isl_dim_div);
		1879
		1880	if (isl_int_is_zero(bmap->div[div][0]))
		1881	return 1;
		1882
		1883	for (i = bmap->n_div - 1; i >= 0; --i) {
		1884	if (isl_int_is_zero(bmap->div[div][1 + div_offset + i]))
		1885	continue;
		1886	if (div_is_unknown(bmap, i))
		1887	return 1;
		1888	}
		1889
		1890	return 0;
		1891	}
		1892
		1893	/* Remove all divs that are unknown or defined in terms of unknown divs.
		1894	*/
		1895	__isl_give isl_basic_map *isl_basic_map_remove_unknown_divs(
		1896	__isl_take isl_basic_map *bmap)
		1897	{
		1898	int i;
		1899
		1900	if (!bmap)
		1901	return NULL;
		1902
		1903	for (i = bmap->n_div - 1; i >= 0; --i) {
		1904	if (!div_is_unknown(bmap, i))
		1905	continue;
		1906	bmap = isl_basic_map_remove_dims(bmap, isl_dim_div, i, 1);
		1907	if (!bmap)
		1908	return NULL;
		1909	i = bmap->n_div;
		1910	}
		1911
		1912	return bmap;
		1913	}
		1914
		1915	__isl_give isl_map *isl_map_remove_unknown_divs(__isl_take isl_map *map)
		1916	{
		1917	int i;
		1918
		1919	if (!map)
		1920	return NULL;
		1921	if (map->n == 0)
		1922	return map;
		1923
		1924	map = isl_map_cow(map);
		1925	if (!map)
		1926	return NULL;
		1927
		1928	for (i = 0; i < map->n; ++i) {
		1929	map->p[i] = isl_basic_map_remove_unknown_divs(map->p[i]);
		1930	if (!map->p[i])
		1931	goto error;
		1932	}
		1933	return map;
		1934	error:
		1935	isl_map_free(map);
		1936	return NULL;
		1937	}
		1938
		1939	__isl_give isl_set *isl_set_remove_unknown_divs(__isl_take isl_set *set)
		1940	{
		1941	return (isl_set *)isl_map_remove_unknown_divs((isl_map *)set);
		1942	}
		1943
		1944	__isl_give isl_basic_set *isl_basic_set_remove_dims(
		1945	__isl_take isl_basic_set *bset,
		1946	enum isl_dim_type type, unsigned first, unsigned n)
		1947	{
		1948	return (isl_basic_set *)
		1949	isl_basic_map_remove_dims((isl_basic_map *)bset, type, first, n);
		1950	}
		1951
		1952	struct isl_map *isl_map_remove_dims(struct isl_map *map,
		1953	enum isl_dim_type type, unsigned first, unsigned n)
		1954	{
		1955	int i;
		1956
		1957	if (n == 0)
		1958	return map;
		1959
		1960	map = isl_map_cow(map);
		1961	if (!map)
		1962	return NULL;
		1963	isl_assert(map->ctx, first + n <= isl_map_dim(map, type), goto error);
		1964
		1965	for (i = 0; i < map->n; ++i) {
		1966	map->p[i] = isl_basic_map_eliminate_vars(map->p[i],
		1967	isl_basic_map_offset(map->p[i], type) - 1 + first, n);
		1968	if (!map->p[i])
		1969	goto error;
		1970	}
		1971	map = isl_map_drop(map, type, first, n);
		1972	return map;
		1973	error:
		1974	isl_map_free(map);
		1975	return NULL;
		1976	}
		1977
		1978	__isl_give isl_set *isl_set_remove_dims(__isl_take isl_set *bset,
		1979	enum isl_dim_type type, unsigned first, unsigned n)
		1980	{
		1981	return (isl_set *)isl_map_remove_dims((isl_map *)bset, type, first, n);
		1982	}
		1983
		1984	/* Project out n inputs starting at first using Fourier-Motzkin */
		1985	struct isl_map *isl_map_remove_inputs(struct isl_map *map,
		1986	unsigned first, unsigned n)
		1987	{
		1988	return isl_map_remove_dims(map, isl_dim_in, first, n);
		1989	}
		1990
		1991	static void dump_term(struct isl_basic_map *bmap,
		1992	isl_int c, int pos, FILE *out)
		1993	{
		1994	const char *name;
		1995	unsigned in = isl_basic_map_n_in(bmap);
		1996	unsigned dim = in + isl_basic_map_n_out(bmap);
		1997	unsigned nparam = isl_basic_map_n_param(bmap);
		1998	if (!pos)
		1999	isl_int_print(out, c, 0);
		2000	else {
		2001	if (!isl_int_is_one(c))
		2002	isl_int_print(out, c, 0);
		2003	if (pos < 1 + nparam) {
		2004	name = isl_space_get_dim_name(bmap->dim,
		2005	isl_dim_param, pos - 1);
		2006	if (name)
		2007	fprintf(out, "%s", name);
		2008	else
		2009	fprintf(out, "p%d", pos - 1);
		2010	} else if (pos < 1 + nparam + in)
		2011	fprintf(out, "i%d", pos - 1 - nparam);
		2012	else if (pos < 1 + nparam + dim)
		2013	fprintf(out, "o%d", pos - 1 - nparam - in);
		2014	else
		2015	fprintf(out, "e%d", pos - 1 - nparam - dim);
		2016	}
		2017	}
		2018
		2019	static void dump_constraint_sign(struct isl_basic_map *bmap, isl_int *c,
		2020	int sign, FILE *out)
		2021	{
		2022	int i;
		2023	int first;
		2024	unsigned len = 1 + isl_basic_map_total_dim(bmap);
		2025	isl_int v;
		2026
		2027	isl_int_init(v);
		2028	for (i = 0, first = 1; i < len; ++i) {
		2029	if (isl_int_sgn(c[i]) * sign <= 0)
		2030	continue;
		2031	if (!first)
		2032	fprintf(out, " + ");
		2033	first = 0;
		2034	isl_int_abs(v, c[i]);
		2035	dump_term(bmap, v, i, out);
		2036	}
		2037	isl_int_clear(v);
		2038	if (first)
		2039	fprintf(out, "0");
		2040	}
		2041
		2042	static void dump_constraint(struct isl_basic_map *bmap, isl_int *c,
		2043	const char *op, FILE *out, int indent)
		2044	{
		2045	int i;
		2046
		2047	fprintf(out, "%*s", indent, "");
		2048
		2049	dump_constraint_sign(bmap, c, 1, out);
		2050	fprintf(out, " %s ", op);
		2051	dump_constraint_sign(bmap, c, -1, out);
		2052
		2053	fprintf(out, "\n");
		2054
		2055	for (i = bmap->n_div; i < bmap->extra; ++i) {
		2056	if (isl_int_is_zero(c[1+isl_space_dim(bmap->dim, isl_dim_all)+i]))
		2057	continue;
		2058	fprintf(out, "%*s", indent, "");
		2059	fprintf(out, "ERROR: unused div coefficient not zero\n");
		2060	abort();
		2061	}
		2062	}
		2063
		2064	static void dump_constraints(struct isl_basic_map *bmap,
		2065	isl_int **c, unsigned n,
		2066	const char *op, FILE *out, int indent)
		2067	{
		2068	int i;
		2069
		2070	for (i = 0; i < n; ++i)
		2071	dump_constraint(bmap, c[i], op, out, indent);
		2072	}
		2073
		2074	static void dump_affine(struct isl_basic_map *bmap, isl_int *exp, FILE *out)
		2075	{
		2076	int j;
		2077	int first = 1;
		2078	unsigned total = isl_basic_map_total_dim(bmap);
		2079
		2080	for (j = 0; j < 1 + total; ++j) {
		2081	if (isl_int_is_zero(exp[j]))
		2082	continue;
		2083	if (!first && isl_int_is_pos(exp[j]))
		2084	fprintf(out, "+");
		2085	dump_term(bmap, exp[j], j, out);
		2086	first = 0;
		2087	}
		2088	}
		2089
		2090	static void dump(struct isl_basic_map *bmap, FILE *out, int indent)
		2091	{
		2092	int i;
		2093
		2094	dump_constraints(bmap, bmap->eq, bmap->n_eq, "=", out, indent);
		2095	dump_constraints(bmap, bmap->ineq, bmap->n_ineq, ">=", out, indent);
		2096
		2097	for (i = 0; i < bmap->n_div; ++i) {
		2098	fprintf(out, "%*s", indent, "");
		2099	fprintf(out, "e%d = [(", i);
		2100	dump_affine(bmap, bmap->div[i]+1, out);
		2101	fprintf(out, ")/");
		2102	isl_int_print(out, bmap->div[i][0], 0);
		2103	fprintf(out, "]\n");
		2104	}
		2105	}
		2106
		2107	void isl_basic_set_print_internal(struct isl_basic_set *bset,
		2108	FILE *out, int indent)
		2109	{
		2110	if (!bset) {
		2111	fprintf(out, "null basic set\n");
		2112	return;
		2113	}
		2114
		2115	fprintf(out, "%*s", indent, "");
		2116	fprintf(out, "ref: %d, nparam: %d, dim: %d, extra: %d, flags: %x\n",
		2117	bset->ref, bset->dim->nparam, bset->dim->n_out,
		2118	bset->extra, bset->flags);
		2119	dump((struct isl_basic_map *)bset, out, indent);
		2120	}
		2121
		2122	void isl_basic_map_print_internal(struct isl_basic_map *bmap,
		2123	FILE *out, int indent)
		2124	{
		2125	if (!bmap) {
		2126	fprintf(out, "null basic map\n");
		2127	return;
		2128	}
		2129
		2130	fprintf(out, "%*s", indent, "");
		2131	fprintf(out, "ref: %d, nparam: %d, in: %d, out: %d, extra: %d, "
		2132	"flags: %x, n_name: %d\n",
		2133	bmap->ref,
		2134	bmap->dim->nparam, bmap->dim->n_in, bmap->dim->n_out,
		2135	bmap->extra, bmap->flags, bmap->dim->n_id);
		2136	dump(bmap, out, indent);
		2137	}
		2138
		2139	int isl_inequality_negate(struct isl_basic_map *bmap, unsigned pos)
		2140	{
		2141	unsigned total;
		2142	if (!bmap)
		2143	return -1;
		2144	total = isl_basic_map_total_dim(bmap);
		2145	isl_assert(bmap->ctx, pos < bmap->n_ineq, return -1);
		2146	isl_seq_neg(bmap->ineq[pos], bmap->ineq[pos], 1 + total);
		2147	isl_int_sub_ui(bmap->ineq[pos][0], bmap->ineq[pos][0], 1);
		2148	ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
		2149	return 0;
		2150	}
		2151
		2152	__isl_give isl_set *isl_set_alloc_space(__isl_take isl_space *dim, int n,
		2153	unsigned flags)
		2154	{
		2155	struct isl_set *set;
		2156
		2157	if (!dim)
		2158	return NULL;
		2159	isl_assert(dim->ctx, dim->n_in == 0, goto error);
		2160	isl_assert(dim->ctx, n >= 0, goto error);
		2161	set = isl_alloc(dim->ctx, struct isl_set,
		2162	sizeof(struct isl_set) +
		2163	(n - 1) * sizeof(struct isl_basic_set *));
		2164	if (!set)
		2165	goto error;
		2166
		2167	set->ctx = dim->ctx;
		2168	isl_ctx_ref(set->ctx);
		2169	set->ref = 1;
		2170	set->size = n;
		2171	set->n = 0;
		2172	set->dim = dim;
		2173	set->flags = flags;
		2174	return set;
		2175	error:
		2176	isl_space_free(dim);
		2177	return NULL;
		2178	}
		2179
		2180	struct isl_set *isl_set_alloc(struct isl_ctx *ctx,
		2181	unsigned nparam, unsigned dim, int n, unsigned flags)
		2182	{
		2183	struct isl_set *set;
		2184	isl_space *dims;
		2185
		2186	dims = isl_space_alloc(ctx, nparam, 0, dim);
		2187	if (!dims)
		2188	return NULL;
		2189
		2190	set = isl_set_alloc_space(dims, n, flags);
		2191	return set;
		2192	}
		2193
		2194	/* Make sure "map" has room for at least "n" more basic maps.
		2195	*/
		2196	struct isl_map *isl_map_grow(struct isl_map *map, int n)
		2197	{
		2198	int i;
		2199	struct isl_map *grown = NULL;
		2200
		2201	if (!map)
		2202	return NULL;
		2203	isl_assert(map->ctx, n >= 0, goto error);
		2204	if (map->n + n <= map->size)
		2205	return map;
		2206	grown = isl_map_alloc_space(isl_map_get_space(map), map->n + n, map->flags);
		2207	if (!grown)
		2208	goto error;
		2209	for (i = 0; i < map->n; ++i) {
		2210	grown->p[i] = isl_basic_map_copy(map->p[i]);
		2211	if (!grown->p[i])
		2212	goto error;
		2213	grown->n++;
		2214	}
		2215	isl_map_free(map);
		2216	return grown;
		2217	error:
		2218	isl_map_free(grown);
		2219	isl_map_free(map);
		2220	return NULL;
		2221	}
		2222
		2223	/* Make sure "set" has room for at least "n" more basic sets.
		2224	*/
		2225	struct isl_set *isl_set_grow(struct isl_set *set, int n)
		2226	{
		2227	return (struct isl_set *)isl_map_grow((struct isl_map *)set, n);
		2228	}
		2229
		2230	struct isl_set *isl_set_dup(struct isl_set *set)
		2231	{
		2232	int i;
		2233	struct isl_set *dup;
		2234
		2235	if (!set)
		2236	return NULL;
		2237
		2238	dup = isl_set_alloc_space(isl_space_copy(set->dim), set->n, set->flags);
		2239	if (!dup)
		2240	return NULL;
		2241	for (i = 0; i < set->n; ++i)
		2242	dup = isl_set_add_basic_set(dup, isl_basic_set_copy(set->p[i]));
		2243	return dup;
		2244	}
		2245
		2246	struct isl_set *isl_set_from_basic_set(struct isl_basic_set *bset)
		2247	{
		2248	return isl_map_from_basic_map(bset);
		2249	}
		2250
		2251	struct isl_map *isl_map_from_basic_map(struct isl_basic_map *bmap)
		2252	{
		2253	struct isl_map *map;
		2254
		2255	if (!bmap)
		2256	return NULL;
		2257
		2258	map = isl_map_alloc_space(isl_space_copy(bmap->dim), 1, ISL_MAP_DISJOINT);
		2259	return isl_map_add_basic_map(map, bmap);
		2260	}
		2261
		2262	__isl_give isl_set *isl_set_add_basic_set(__isl_take isl_set *set,
		2263	__isl_take isl_basic_set *bset)
		2264	{
		2265	return (struct isl_set *)isl_map_add_basic_map((struct isl_map *)set,
		2266	(struct isl_basic_map *)bset);
		2267	}
		2268
		2269	void isl_set_free(struct isl_set *set)
		2270	{
		2271	int i;
		2272
		2273	if (!set)
		2274	return;
		2275
		2276	if (--set->ref > 0)
		2277	return;
		2278
		2279	isl_ctx_deref(set->ctx);
		2280	for (i = 0; i < set->n; ++i)
		2281	isl_basic_set_free(set->p[i]);
		2282	isl_space_free(set->dim);
		2283	free(set);
		2284	}
		2285
		2286	void isl_set_print_internal(struct isl_set *set, FILE *out, int indent)
		2287	{
		2288	int i;
		2289
		2290	if (!set) {
		2291	fprintf(out, "null set\n");
		2292	return;
		2293	}
		2294
		2295	fprintf(out, "%*s", indent, "");
		2296	fprintf(out, "ref: %d, n: %d, nparam: %d, dim: %d, flags: %x\n",
		2297	set->ref, set->n, set->dim->nparam, set->dim->n_out,
		2298	set->flags);
		2299	for (i = 0; i < set->n; ++i) {
		2300	fprintf(out, "%*s", indent, "");
		2301	fprintf(out, "basic set %d:\n", i);
		2302	isl_basic_set_print_internal(set->p[i], out, indent+4);
		2303	}
		2304	}
		2305
		2306	void isl_map_print_internal(struct isl_map *map, FILE *out, int indent)
		2307	{
		2308	int i;
		2309
		2310	if (!map) {
		2311	fprintf(out, "null map\n");
		2312	return;
		2313	}
		2314
		2315	fprintf(out, "%*s", indent, "");
		2316	fprintf(out, "ref: %d, n: %d, nparam: %d, in: %d, out: %d, "
		2317	"flags: %x, n_name: %d\n",
		2318	map->ref, map->n, map->dim->nparam, map->dim->n_in,
		2319	map->dim->n_out, map->flags, map->dim->n_id);
		2320	for (i = 0; i < map->n; ++i) {
		2321	fprintf(out, "%*s", indent, "");
		2322	fprintf(out, "basic map %d:\n", i);
		2323	isl_basic_map_print_internal(map->p[i], out, indent+4);
		2324	}
		2325	}
		2326
		2327	struct isl_basic_map *isl_basic_map_intersect_domain(
		2328	struct isl_basic_map *bmap, struct isl_basic_set *bset)
		2329	{
		2330	struct isl_basic_map *bmap_domain;
		2331
		2332	if (!bmap || !bset)
		2333	goto error;
		2334
		2335	isl_assert(bset->ctx, isl_space_match(bmap->dim, isl_dim_param,
		2336	bset->dim, isl_dim_param), goto error);
		2337
		2338	if (isl_space_dim(bset->dim, isl_dim_set) != 0)
		2339	isl_assert(bset->ctx,
		2340	isl_basic_map_compatible_domain(bmap, bset), goto error);
		2341
		2342	bmap = isl_basic_map_cow(bmap);
		2343	if (!bmap)
		2344	goto error;
		2345	bmap = isl_basic_map_extend_space(bmap, isl_space_copy(bmap->dim),
		2346	bset->n_div, bset->n_eq, bset->n_ineq);
		2347	bmap_domain = isl_basic_map_from_domain(bset);
		2348	bmap = add_constraints(bmap, bmap_domain, 0, 0);
		2349
		2350	bmap = isl_basic_map_simplify(bmap);
		2351	return isl_basic_map_finalize(bmap);
		2352	error:
		2353	isl_basic_map_free(bmap);
		2354	isl_basic_set_free(bset);
		2355	return NULL;
		2356	}
		2357
		2358	struct isl_basic_map *isl_basic_map_intersect_range(
		2359	struct isl_basic_map *bmap, struct isl_basic_set *bset)
		2360	{
		2361	struct isl_basic_map *bmap_range;
		2362
		2363	if (!bmap || !bset)
		2364	goto error;
		2365
		2366	isl_assert(bset->ctx, isl_space_match(bmap->dim, isl_dim_param,
		2367	bset->dim, isl_dim_param), goto error);
		2368
		2369	if (isl_space_dim(bset->dim, isl_dim_set) != 0)
		2370	isl_assert(bset->ctx,
		2371	isl_basic_map_compatible_range(bmap, bset), goto error);
		2372
		2373	if (isl_basic_set_is_universe(bset)) {
		2374	isl_basic_set_free(bset);
		2375	return bmap;
		2376	}
		2377
		2378	bmap = isl_basic_map_cow(bmap);
		2379	if (!bmap)
		2380	goto error;
		2381	bmap = isl_basic_map_extend_space(bmap, isl_space_copy(bmap->dim),
		2382	bset->n_div, bset->n_eq, bset->n_ineq);
		2383	bmap_range = isl_basic_map_from_basic_set(bset, isl_space_copy(bset->dim));
		2384	bmap = add_constraints(bmap, bmap_range, 0, 0);
		2385
		2386	bmap = isl_basic_map_simplify(bmap);
		2387	return isl_basic_map_finalize(bmap);
		2388	error:
		2389	isl_basic_map_free(bmap);
		2390	isl_basic_set_free(bset);
		2391	return NULL;
		2392	}
		2393
		2394	int isl_basic_map_contains(struct isl_basic_map *bmap, struct isl_vec *vec)
		2395	{
		2396	int i;
		2397	unsigned total;
		2398	isl_int s;
		2399
		2400	total = 1 + isl_basic_map_total_dim(bmap);
		2401	if (total != vec->size)
		2402	return -1;
		2403
		2404	isl_int_init(s);
		2405
		2406	for (i = 0; i < bmap->n_eq; ++i) {
		2407	isl_seq_inner_product(vec->el, bmap->eq[i], total, &s);
		2408	if (!isl_int_is_zero(s)) {
		2409	isl_int_clear(s);
		2410	return 0;
		2411	}
		2412	}
		2413
		2414	for (i = 0; i < bmap->n_ineq; ++i) {
		2415	isl_seq_inner_product(vec->el, bmap->ineq[i], total, &s);
		2416	if (isl_int_is_neg(s)) {
		2417	isl_int_clear(s);
		2418	return 0;
		2419	}
		2420	}
		2421
		2422	isl_int_clear(s);
		2423
		2424	return 1;
		2425	}
		2426
		2427	int isl_basic_set_contains(struct isl_basic_set *bset, struct isl_vec *vec)
		2428	{
		2429	return isl_basic_map_contains((struct isl_basic_map *)bset, vec);
		2430	}
		2431
		2432	struct isl_basic_map *isl_basic_map_intersect(
		2433	struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
		2434	{
		2435	struct isl_vec *sample = NULL;
		2436
		2437	if (!bmap1 || !bmap2)
		2438	goto error;
		2439
		2440	isl_assert(bmap1->ctx, isl_space_match(bmap1->dim, isl_dim_param,
		2441	bmap2->dim, isl_dim_param), goto error);
		2442	if (isl_space_dim(bmap1->dim, isl_dim_all) ==
		2443	isl_space_dim(bmap1->dim, isl_dim_param) &&
		2444	isl_space_dim(bmap2->dim, isl_dim_all) !=
		2445	isl_space_dim(bmap2->dim, isl_dim_param))
		2446	return isl_basic_map_intersect(bmap2, bmap1);
		2447
		2448	if (isl_space_dim(bmap2->dim, isl_dim_all) !=
		2449	isl_space_dim(bmap2->dim, isl_dim_param))
		2450	isl_assert(bmap1->ctx,
		2451	isl_space_is_equal(bmap1->dim, bmap2->dim), goto error);
		2452
		2453	if (bmap1->sample &&
		2454	isl_basic_map_contains(bmap1, bmap1->sample) > 0 &&
		2455	isl_basic_map_contains(bmap2, bmap1->sample) > 0)
		2456	sample = isl_vec_copy(bmap1->sample);
		2457	else if (bmap2->sample &&
		2458	isl_basic_map_contains(bmap1, bmap2->sample) > 0 &&
		2459	isl_basic_map_contains(bmap2, bmap2->sample) > 0)
		2460	sample = isl_vec_copy(bmap2->sample);
		2461
		2462	bmap1 = isl_basic_map_cow(bmap1);
		2463	if (!bmap1)
		2464	goto error;
		2465	bmap1 = isl_basic_map_extend_space(bmap1, isl_space_copy(bmap1->dim),
		2466	bmap2->n_div, bmap2->n_eq, bmap2->n_ineq);
		2467	bmap1 = add_constraints(bmap1, bmap2, 0, 0);
		2468
		2469	if (!bmap1)
		2470	isl_vec_free(sample);
		2471	else if (sample) {
		2472	isl_vec_free(bmap1->sample);
		2473	bmap1->sample = sample;
		2474	}
		2475
		2476	bmap1 = isl_basic_map_simplify(bmap1);
		2477	return isl_basic_map_finalize(bmap1);
		2478	error:
		2479	if (sample)
		2480	isl_vec_free(sample);
		2481	isl_basic_map_free(bmap1);
		2482	isl_basic_map_free(bmap2);
		2483	return NULL;
		2484	}
		2485
		2486	struct isl_basic_set *isl_basic_set_intersect(
		2487	struct isl_basic_set *bset1, struct isl_basic_set *bset2)
		2488	{
		2489	return (struct isl_basic_set *)
		2490	isl_basic_map_intersect(
		2491	(struct isl_basic_map *)bset1,
		2492	(struct isl_basic_map *)bset2);
		2493	}
		2494
		2495	__isl_give isl_basic_set *isl_basic_set_intersect_params(
		2496	__isl_take isl_basic_set *bset1, __isl_take isl_basic_set *bset2)
		2497	{
		2498	return isl_basic_set_intersect(bset1, bset2);
		2499	}
		2500
		2501	/* Special case of isl_map_intersect, where both map1 and map2
		2502	* are convex, without any divs and such that either map1 or map2
		2503	* contains a single constraint. This constraint is then simply
		2504	* added to the other map.
		2505	*/
		2506	static __isl_give isl_map *map_intersect_add_constraint(
		2507	__isl_take isl_map *map1, __isl_take isl_map *map2)
		2508	{
		2509	isl_assert(map1->ctx, map1->n == 1, goto error);
		2510	isl_assert(map2->ctx, map1->n == 1, goto error);
		2511	isl_assert(map1->ctx, map1->p[0]->n_div == 0, goto error);
		2512	isl_assert(map2->ctx, map1->p[0]->n_div == 0, goto error);
		2513
		2514	if (map2->p[0]->n_eq + map2->p[0]->n_ineq != 1)
		2515	return isl_map_intersect(map2, map1);
		2516
		2517	isl_assert(map2->ctx,
		2518	map2->p[0]->n_eq + map2->p[0]->n_ineq == 1, goto error);
		2519
		2520	map1 = isl_map_cow(map1);
		2521	if (!map1)
		2522	goto error;
		2523	if (isl_map_plain_is_empty(map1)) {
		2524	isl_map_free(map2);
		2525	return map1;
		2526	}
		2527	map1->p[0] = isl_basic_map_cow(map1->p[0]);
		2528	if (map2->p[0]->n_eq == 1)
		2529	map1->p[0] = isl_basic_map_add_eq(map1->p[0], map2->p[0]->eq[0]);
		2530	else
		2531	map1->p[0] = isl_basic_map_add_ineq(map1->p[0],
		2532	map2->p[0]->ineq[0]);
		2533
		2534	map1->p[0] = isl_basic_map_simplify(map1->p[0]);
		2535	map1->p[0] = isl_basic_map_finalize(map1->p[0]);
		2536	if (!map1->p[0])
		2537	goto error;
		2538
		2539	if (isl_basic_map_plain_is_empty(map1->p[0])) {
		2540	isl_basic_map_free(map1->p[0]);
		2541	map1->n = 0;
		2542	}
		2543
		2544	isl_map_free(map2);
		2545
		2546	return map1;
		2547	error:
		2548	isl_map_free(map1);
		2549	isl_map_free(map2);
		2550	return NULL;
		2551	}
		2552
		2553	/* map2 may be either a parameter domain or a map living in the same
		2554	* space as map1.
		2555	*/
		2556	static __isl_give isl_map *map_intersect_internal(__isl_take isl_map *map1,
		2557	__isl_take isl_map *map2)
		2558	{
		2559	unsigned flags = 0;
		2560	struct isl_map *result;
		2561	int i, j;
		2562
		2563	if (!map1 || !map2)
		2564	goto error;
		2565
		2566	if (isl_map_plain_is_empty(map1) &&
		2567	isl_space_is_equal(map1->dim, map2->dim)) {
		2568	isl_map_free(map2);
		2569	return map1;
		2570	}
		2571	if (isl_map_plain_is_empty(map2) &&
		2572	isl_space_is_equal(map1->dim, map2->dim)) {
		2573	isl_map_free(map1);
		2574	return map2;
		2575	}
		2576
		2577	if (map1->n == 1 && map2->n == 1 &&
		2578	map1->p[0]->n_div == 0 && map2->p[0]->n_div == 0 &&
		2579	isl_space_is_equal(map1->dim, map2->dim) &&
		2580	(map1->p[0]->n_eq + map1->p[0]->n_ineq == 1 ||
		2581	map2->p[0]->n_eq + map2->p[0]->n_ineq == 1))
		2582	return map_intersect_add_constraint(map1, map2);
		2583
		2584	if (isl_space_dim(map2->dim, isl_dim_all) !=
		2585	isl_space_dim(map2->dim, isl_dim_param))
		2586	isl_assert(map1->ctx,
		2587	isl_space_is_equal(map1->dim, map2->dim), goto error);
		2588
		2589	if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) &&
		2590	ISL_F_ISSET(map2, ISL_MAP_DISJOINT))
		2591	ISL_FL_SET(flags, ISL_MAP_DISJOINT);
		2592
		2593	result = isl_map_alloc_space(isl_space_copy(map1->dim),
		2594	map1->n * map2->n, flags);
		2595	if (!result)
		2596	goto error;
		2597	for (i = 0; i < map1->n; ++i)
		2598	for (j = 0; j < map2->n; ++j) {
		2599	struct isl_basic_map *part;
		2600	part = isl_basic_map_intersect(
		2601	isl_basic_map_copy(map1->p[i]),
		2602	isl_basic_map_copy(map2->p[j]));
		2603	if (isl_basic_map_is_empty(part))
		2604	isl_basic_map_free(part);
		2605	else
		2606	result = isl_map_add_basic_map(result, part);
		2607	if (!result)
		2608	goto error;
		2609	}
		2610	isl_map_free(map1);
		2611	isl_map_free(map2);
		2612	return result;
		2613	error:
		2614	isl_map_free(map1);
		2615	isl_map_free(map2);
		2616	return NULL;
		2617	}
		2618
		2619	static __isl_give isl_map *map_intersect(__isl_take isl_map *map1,
		2620	__isl_take isl_map *map2)
		2621	{
		2622	if (!map1 || !map2)
		2623	goto error;
		2624	if (!isl_space_is_equal(map1->dim, map2->dim))
		2625	isl_die(isl_map_get_ctx(map1), isl_error_invalid,
		2626	"spaces don't match", goto error);
		2627	return map_intersect_internal(map1, map2);
		2628	error:
		2629	isl_map_free(map1);
		2630	isl_map_free(map2);
		2631	return NULL;
		2632	}
		2633
		2634	__isl_give isl_map *isl_map_intersect(__isl_take isl_map *map1,
		2635	__isl_take isl_map *map2)
		2636	{
		2637	return isl_map_align_params_map_map_and(map1, map2, &map_intersect);
		2638	}
		2639
		2640	struct isl_set *isl_set_intersect(struct isl_set *set1, struct isl_set *set2)
		2641	{
		2642	return (struct isl_set *)
		2643	isl_map_intersect((struct isl_map *)set1,
		2644	(struct isl_map *)set2);
		2645	}
		2646
		2647	/* map_intersect_internal accepts intersections
		2648	* with parameter domains, so we can just call that function.
		2649	*/
		2650	static __isl_give isl_map *map_intersect_params(__isl_take isl_map *map,
		2651	__isl_take isl_set *params)
		2652	{
		2653	return map_intersect_internal(map, params);
		2654	}
		2655
		2656	__isl_give isl_map *isl_map_intersect_params(__isl_take isl_map *map1,
		2657	__isl_take isl_map *map2)
		2658	{
		2659	return isl_map_align_params_map_map_and(map1, map2, &map_intersect_params);
		2660	}
		2661
		2662	__isl_give isl_set *isl_set_intersect_params(__isl_take isl_set *set,
		2663	__isl_take isl_set *params)
		2664	{
		2665	return isl_map_intersect_params(set, params);
		2666	}
		2667
		2668	struct isl_basic_map *isl_basic_map_reverse(struct isl_basic_map *bmap)
		2669	{
		2670	isl_space *dim;
		2671	struct isl_basic_set *bset;
		2672	unsigned in;
		2673
		2674	if (!bmap)
		2675	return NULL;
		2676	bmap = isl_basic_map_cow(bmap);
		2677	if (!bmap)
		2678	return NULL;
		2679	dim = isl_space_reverse(isl_space_copy(bmap->dim));
		2680	in = isl_basic_map_n_in(bmap);
		2681	bset = isl_basic_set_from_basic_map(bmap);
		2682	bset = isl_basic_set_swap_vars(bset, in);
		2683	return isl_basic_map_from_basic_set(bset, dim);
		2684	}
		2685
		2686	static __isl_give isl_basic_map *basic_map_space_reset(
		2687	__isl_take isl_basic_map *bmap, enum isl_dim_type type)
		2688	{
		2689	isl_space *space;
		2690
		2691	if (!isl_space_is_named_or_nested(bmap->dim, type))
		2692	return bmap;
		2693
		2694	space = isl_basic_map_get_space(bmap);
		2695	space = isl_space_reset(space, type);
		2696	bmap = isl_basic_map_reset_space(bmap, space);
		2697	return bmap;
		2698	}
		2699
		2700	__isl_give isl_basic_map *isl_basic_map_insert(__isl_take isl_basic_map *bmap,
		2701	enum isl_dim_type type, unsigned pos, unsigned n)
		2702	{
		2703	isl_space *res_dim;
		2704	struct isl_basic_map *res;
		2705	struct isl_dim_map *dim_map;
		2706	unsigned total, off;
		2707	enum isl_dim_type t;
		2708
		2709	if (n == 0)
		2710	return basic_map_space_reset(bmap, type);
		2711
		2712	if (!bmap)
		2713	return NULL;
		2714
		2715	res_dim = isl_space_insert_dims(isl_basic_map_get_space(bmap), type, pos, n);
		2716
		2717	total = isl_basic_map_total_dim(bmap) + n;
		2718	dim_map = isl_dim_map_alloc(bmap->ctx, total);
		2719	off = 0;
		2720	for (t = isl_dim_param; t <= isl_dim_out; ++t) {
		2721	if (t != type) {
		2722	isl_dim_map_dim(dim_map, bmap->dim, t, off);
		2723	} else {
		2724	unsigned size = isl_basic_map_dim(bmap, t);
		2725	isl_dim_map_dim_range(dim_map, bmap->dim, t,
		2726	0, pos, off);
		2727	isl_dim_map_dim_range(dim_map, bmap->dim, t,
		2728	pos, size - pos, off + pos + n);
		2729	}
		2730	off += isl_space_dim(res_dim, t);
		2731	}
		2732	isl_dim_map_div(dim_map, bmap, off);
		2733
		2734	res = isl_basic_map_alloc_space(res_dim,
		2735	bmap->n_div, bmap->n_eq, bmap->n_ineq);
		2736	if (isl_basic_map_is_rational(bmap))
		2737	res = isl_basic_map_set_rational(res);
		2738	if (isl_basic_map_plain_is_empty(bmap)) {
		2739	isl_basic_map_free(bmap);
		2740	return isl_basic_map_set_to_empty(res);
		2741	}
		2742	res = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map);
		2743	return isl_basic_map_finalize(res);
		2744	}
		2745
		2746	__isl_give isl_basic_map *isl_basic_map_add(__isl_take isl_basic_map *bmap,
		2747	enum isl_dim_type type, unsigned n)
		2748	{
		2749	if (!bmap)
		2750	return NULL;
		2751	return isl_basic_map_insert(bmap, type,
		2752	isl_basic_map_dim(bmap, type), n);
		2753	}
		2754
		2755	__isl_give isl_basic_set *isl_basic_set_add(__isl_take isl_basic_set *bset,
		2756	enum isl_dim_type type, unsigned n)
		2757	{
		2758	if (!bset)
		2759	return NULL;
		2760	isl_assert(bset->ctx, type != isl_dim_in, goto error);
		2761	return (isl_basic_set *)isl_basic_map_add((isl_basic_map *)bset, type, n);
		2762	error:
		2763	isl_basic_set_free(bset);
		2764	return NULL;
		2765	}
		2766
		2767	static __isl_give isl_map *map_space_reset(__isl_take isl_map *map,
		2768	enum isl_dim_type type)
		2769	{
		2770	isl_space *space;
		2771
		2772	if (!map || !isl_space_is_named_or_nested(map->dim, type))
		2773	return map;
		2774
		2775	space = isl_map_get_space(map);
		2776	space = isl_space_reset(space, type);
		2777	map = isl_map_reset_space(map, space);
		2778	return map;
		2779	}
		2780
		2781	__isl_give isl_map *isl_map_insert_dims(__isl_take isl_map *map,
		2782	enum isl_dim_type type, unsigned pos, unsigned n)
		2783	{
		2784	int i;
		2785
		2786	if (n == 0)
		2787	return map_space_reset(map, type);
		2788
		2789	map = isl_map_cow(map);
		2790	if (!map)
		2791	return NULL;
		2792
		2793	map->dim = isl_space_insert_dims(map->dim, type, pos, n);
		2794	if (!map->dim)
		2795	goto error;
		2796
		2797	for (i = 0; i < map->n; ++i) {
		2798	map->p[i] = isl_basic_map_insert(map->p[i], type, pos, n);
		2799	if (!map->p[i])
		2800	goto error;
		2801	}
		2802
		2803	return map;
		2804	error:
		2805	isl_map_free(map);
		2806	return NULL;
		2807	}
		2808
		2809	__isl_give isl_set *isl_set_insert_dims(__isl_take isl_set *set,
		2810	enum isl_dim_type type, unsigned pos, unsigned n)
		2811	{
		2812	return isl_map_insert_dims(set, type, pos, n);
		2813	}
		2814
		2815	__isl_give isl_map *isl_map_add_dims(__isl_take isl_map *map,
		2816	enum isl_dim_type type, unsigned n)
		2817	{
		2818	if (!map)
		2819	return NULL;
		2820	return isl_map_insert_dims(map, type, isl_map_dim(map, type), n);
		2821	}
		2822
		2823	__isl_give isl_set *isl_set_add_dims(__isl_take isl_set *set,
		2824	enum isl_dim_type type, unsigned n)
		2825	{
		2826	if (!set)
		2827	return NULL;
		2828	isl_assert(set->ctx, type != isl_dim_in, goto error);
		2829	return (isl_set *)isl_map_add_dims((isl_map *)set, type, n);
		2830	error:
		2831	isl_set_free(set);
		2832	return NULL;
		2833	}
		2834
		2835	__isl_give isl_basic_map *isl_basic_map_move_dims(
		2836	__isl_take isl_basic_map *bmap,
		2837	enum isl_dim_type dst_type, unsigned dst_pos,
		2838	enum isl_dim_type src_type, unsigned src_pos, unsigned n)
		2839	{
		2840	struct isl_dim_map *dim_map;
		2841	struct isl_basic_map *res;
		2842	enum isl_dim_type t;
		2843	unsigned total, off;
		2844
		2845	if (!bmap)
		2846	return NULL;
		2847	if (n == 0)
		2848	return bmap;
		2849
		2850	isl_assert(bmap->ctx, src_pos + n <= isl_basic_map_dim(bmap, src_type),
		2851	goto error);
		2852
		2853	if (dst_type == src_type && dst_pos == src_pos)
		2854	return bmap;
		2855
		2856	isl_assert(bmap->ctx, dst_type != src_type, goto error);
		2857
		2858	if (pos(bmap->dim, dst_type) + dst_pos ==
		2859	pos(bmap->dim, src_type) + src_pos +
		2860	((src_type < dst_type) ? n : 0)) {
		2861	bmap = isl_basic_map_cow(bmap);
		2862	if (!bmap)
		2863	return NULL;
		2864
		2865	bmap->dim = isl_space_move_dims(bmap->dim, dst_type, dst_pos,
		2866	src_type, src_pos, n);
		2867	if (!bmap->dim)
		2868	goto error;
		2869
		2870	bmap = isl_basic_map_finalize(bmap);
		2871
		2872	return bmap;
		2873	}
		2874
		2875	total = isl_basic_map_total_dim(bmap);
		2876	dim_map = isl_dim_map_alloc(bmap->ctx, total);
		2877
		2878	off = 0;
		2879	for (t = isl_dim_param; t <= isl_dim_out; ++t) {
		2880	unsigned size = isl_space_dim(bmap->dim, t);
		2881	if (t == dst_type) {
		2882	isl_dim_map_dim_range(dim_map, bmap->dim, t,
		2883	0, dst_pos, off);
		2884	off += dst_pos;
		2885	isl_dim_map_dim_range(dim_map, bmap->dim, src_type,
		2886	src_pos, n, off);
		2887	off += n;
		2888	isl_dim_map_dim_range(dim_map, bmap->dim, t,
		2889	dst_pos, size - dst_pos, off);
		2890	off += size - dst_pos;
		2891	} else if (t == src_type) {
		2892	isl_dim_map_dim_range(dim_map, bmap->dim, t,
		2893	0, src_pos, off);
		2894	off += src_pos;
		2895	isl_dim_map_dim_range(dim_map, bmap->dim, t,
		2896	src_pos + n, size - src_pos - n, off);
		2897	off += size - src_pos - n;
		2898	} else {
		2899	isl_dim_map_dim(dim_map, bmap->dim, t, off);
		2900	off += size;
		2901	}
		2902	}
		2903	isl_dim_map_div(dim_map, bmap, off);
		2904
		2905	res = isl_basic_map_alloc_space(isl_basic_map_get_space(bmap),
		2906	bmap->n_div, bmap->n_eq, bmap->n_ineq);
		2907	bmap = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map);
		2908
		2909	bmap->dim = isl_space_move_dims(bmap->dim, dst_type, dst_pos,
		2910	src_type, src_pos, n);
		2911	if (!bmap->dim)
		2912	goto error;
		2913
		2914	ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
		2915	bmap = isl_basic_map_gauss(bmap, NULL);
		2916	bmap = isl_basic_map_finalize(bmap);
		2917
		2918	return bmap;
		2919	error:
		2920	isl_basic_map_free(bmap);
		2921	return NULL;
		2922	}
		2923
		2924	__isl_give isl_basic_set *isl_basic_set_move_dims(__isl_take isl_basic_set *bset,
		2925	enum isl_dim_type dst_type, unsigned dst_pos,
		2926	enum isl_dim_type src_type, unsigned src_pos, unsigned n)
		2927	{
		2928	return (isl_basic_set *)isl_basic_map_move_dims(
		2929	(isl_basic_map *)bset, dst_type, dst_pos, src_type, src_pos, n);
		2930	}
		2931
		2932	__isl_give isl_set *isl_set_move_dims(__isl_take isl_set *set,
		2933	enum isl_dim_type dst_type, unsigned dst_pos,
		2934	enum isl_dim_type src_type, unsigned src_pos, unsigned n)
		2935	{
		2936	if (!set)
		2937	return NULL;
		2938	isl_assert(set->ctx, dst_type != isl_dim_in, goto error);
		2939	return (isl_set *)isl_map_move_dims((isl_map *)set, dst_type, dst_pos,
		2940	src_type, src_pos, n);
		2941	error:
		2942	isl_set_free(set);
		2943	return NULL;
		2944	}
		2945
		2946	__isl_give isl_map *isl_map_move_dims(__isl_take isl_map *map,
		2947	enum isl_dim_type dst_type, unsigned dst_pos,
		2948	enum isl_dim_type src_type, unsigned src_pos, unsigned n)
		2949	{
		2950	int i;
		2951
		2952	if (!map)
		2953	return NULL;
		2954	if (n == 0)
		2955	return map;
		2956
		2957	isl_assert(map->ctx, src_pos + n <= isl_map_dim(map, src_type),
		2958	goto error);
		2959
		2960	if (dst_type == src_type && dst_pos == src_pos)
		2961	return map;
		2962
		2963	isl_assert(map->ctx, dst_type != src_type, goto error);
		2964
		2965	map = isl_map_cow(map);
		2966	if (!map)
		2967	return NULL;
		2968
		2969	map->dim = isl_space_move_dims(map->dim, dst_type, dst_pos, src_type, src_pos, n);
		2970	if (!map->dim)
		2971	goto error;
		2972
		2973	for (i = 0; i < map->n; ++i) {
		2974	map->p[i] = isl_basic_map_move_dims(map->p[i],
		2975	dst_type, dst_pos,
		2976	src_type, src_pos, n);
		2977	if (!map->p[i])
		2978	goto error;
		2979	}
		2980
		2981	return map;
		2982	error:
		2983	isl_map_free(map);
		2984	return NULL;
		2985	}
		2986
		2987	/* Move the specified dimensions to the last columns right before
		2988	* the divs. Don't change the dimension specification of bmap.
		2989	* That's the responsibility of the caller.
		2990	*/
		2991	static __isl_give isl_basic_map *move_last(__isl_take isl_basic_map *bmap,
		2992	enum isl_dim_type type, unsigned first, unsigned n)
		2993	{
		2994	struct isl_dim_map *dim_map;
		2995	struct isl_basic_map *res;
		2996	enum isl_dim_type t;
		2997	unsigned total, off;
		2998
		2999	if (!bmap)
		3000	return NULL;
		3001	if (pos(bmap->dim, type) + first + n ==
		3002	1 + isl_space_dim(bmap->dim, isl_dim_all))
		3003	return bmap;
		3004
		3005	total = isl_basic_map_total_dim(bmap);
		3006	dim_map = isl_dim_map_alloc(bmap->ctx, total);
		3007
		3008	off = 0;
		3009	for (t = isl_dim_param; t <= isl_dim_out; ++t) {
		3010	unsigned size = isl_space_dim(bmap->dim, t);
		3011	if (t == type) {
		3012	isl_dim_map_dim_range(dim_map, bmap->dim, t,
		3013	0, first, off);
		3014	off += first;
		3015	isl_dim_map_dim_range(dim_map, bmap->dim, t,
		3016	first, n, total - bmap->n_div - n);
		3017	isl_dim_map_dim_range(dim_map, bmap->dim, t,
		3018	first + n, size - (first + n), off);
		3019	off += size - (first + n);
		3020	} else {
		3021	isl_dim_map_dim(dim_map, bmap->dim, t, off);
		3022	off += size;
		3023	}
		3024	}
		3025	isl_dim_map_div(dim_map, bmap, off + n);
		3026
		3027	res = isl_basic_map_alloc_space(isl_basic_map_get_space(bmap),
		3028	bmap->n_div, bmap->n_eq, bmap->n_ineq);
		3029	res = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map);
		3030	return res;
		3031	}
		3032
		3033	/* Turn the n dimensions of type type, starting at first
		3034	* into existentially quantified variables.
		3035	*/
		3036	__isl_give isl_basic_map *isl_basic_map_project_out(
		3037	__isl_take isl_basic_map *bmap,
		3038	enum isl_dim_type type, unsigned first, unsigned n)
		3039	{
		3040	int i;
		3041	size_t row_size;
		3042	isl_int **new_div;
		3043	isl_int *old;
		3044
		3045	if (n == 0)
		3046	return basic_map_space_reset(bmap, type);
		3047
		3048	if (!bmap)
		3049	return NULL;
		3050
		3051	if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
		3052	return isl_basic_map_remove_dims(bmap, type, first, n);
		3053
		3054	isl_assert(bmap->ctx, first + n <= isl_basic_map_dim(bmap, type),
		3055	goto error);
		3056
		3057	bmap = move_last(bmap, type, first, n);
		3058	bmap = isl_basic_map_cow(bmap);
		3059	if (!bmap)
		3060	return NULL;
		3061
		3062	row_size = 1 + isl_space_dim(bmap->dim, isl_dim_all) + bmap->extra;
		3063	old = bmap->block2.data;
		3064	bmap->block2 = isl_blk_extend(bmap->ctx, bmap->block2,
		3065	(bmap->extra + n) * (1 + row_size));
		3066	if (!bmap->block2.data)
		3067	goto error;
		3068	new_div = isl_alloc_array(bmap->ctx, isl_int *, bmap->extra + n);
		3069	if (!new_div)
		3070	goto error;
		3071	for (i = 0; i < n; ++i) {
		3072	new_div[i] = bmap->block2.data +
		3073	(bmap->extra + i) * (1 + row_size);
		3074	isl_seq_clr(new_div[i], 1 + row_size);
		3075	}
		3076	for (i = 0; i < bmap->extra; ++i)
		3077	new_div[n + i] = bmap->block2.data + (bmap->div[i] - old);
		3078	free(bmap->div);
		3079	bmap->div = new_div;
		3080	bmap->n_div += n;
		3081	bmap->extra += n;
		3082
		3083	bmap->dim = isl_space_drop_dims(bmap->dim, type, first, n);
		3084	if (!bmap->dim)
		3085	goto error;
		3086	bmap = isl_basic_map_simplify(bmap);
		3087	bmap = isl_basic_map_drop_redundant_divs(bmap);
		3088	return isl_basic_map_finalize(bmap);
		3089	error:
		3090	isl_basic_map_free(bmap);
		3091	return NULL;
		3092	}
		3093
		3094	/* Turn the n dimensions of type type, starting at first
		3095	* into existentially quantified variables.
		3096	*/
		3097	struct isl_basic_set *isl_basic_set_project_out(struct isl_basic_set *bset,
		3098	enum isl_dim_type type, unsigned first, unsigned n)
		3099	{
		3100	return (isl_basic_set *)isl_basic_map_project_out(
		3101	(isl_basic_map *)bset, type, first, n);
		3102	}
		3103
		3104	/* Turn the n dimensions of type type, starting at first
		3105	* into existentially quantified variables.
		3106	*/
		3107	__isl_give isl_map *isl_map_project_out(__isl_take isl_map *map,
		3108	enum isl_dim_type type, unsigned first, unsigned n)
		3109	{
		3110	int i;
		3111
		3112	if (!map)
		3113	return NULL;
		3114
		3115	if (n == 0)
		3116	return map_space_reset(map, type);
		3117
		3118	isl_assert(map->ctx, first + n <= isl_map_dim(map, type), goto error);
		3119
		3120	map = isl_map_cow(map);
		3121	if (!map)
		3122	return NULL;
		3123
		3124	map->dim = isl_space_drop_dims(map->dim, type, first, n);
		3125	if (!map->dim)
		3126	goto error;
		3127
		3128	for (i = 0; i < map->n; ++i) {
		3129	map->p[i] = isl_basic_map_project_out(map->p[i], type, first, n);
		3130	if (!map->p[i])
		3131	goto error;
		3132	}
		3133
		3134	return map;
		3135	error:
		3136	isl_map_free(map);
		3137	return NULL;
		3138	}
		3139
		3140	/* Turn the n dimensions of type type, starting at first
		3141	* into existentially quantified variables.
		3142	*/
		3143	__isl_give isl_set *isl_set_project_out(__isl_take isl_set *set,
		3144	enum isl_dim_type type, unsigned first, unsigned n)
		3145	{
		3146	return (isl_set *)isl_map_project_out((isl_map *)set, type, first, n);
		3147	}
		3148
		3149	static struct isl_basic_map *add_divs(struct isl_basic_map *bmap, unsigned n)
		3150	{
		3151	int i, j;
		3152
		3153	for (i = 0; i < n; ++i) {
		3154	j = isl_basic_map_alloc_div(bmap);
		3155	if (j < 0)
		3156	goto error;
		3157	isl_seq_clr(bmap->div[j], 1+1+isl_basic_map_total_dim(bmap));
		3158	}
		3159	return bmap;
		3160	error:
		3161	isl_basic_map_free(bmap);
		3162	return NULL;
		3163	}
		3164
		3165	struct isl_basic_map *isl_basic_map_apply_range(
		3166	struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
		3167	{
		3168	isl_space *dim_result = NULL;
		3169	struct isl_basic_map *bmap;
		3170	unsigned n_in, n_out, n, nparam, total, pos;
		3171	struct isl_dim_map *dim_map1, *dim_map2;
		3172
		3173	if (!bmap1 || !bmap2)
		3174	goto error;
		3175
		3176	dim_result = isl_space_join(isl_space_copy(bmap1->dim),
		3177	isl_space_copy(bmap2->dim));
		3178
		3179	n_in = isl_basic_map_n_in(bmap1);
		3180	n_out = isl_basic_map_n_out(bmap2);
		3181	n = isl_basic_map_n_out(bmap1);
		3182	nparam = isl_basic_map_n_param(bmap1);
		3183
		3184	total = nparam + n_in + n_out + bmap1->n_div + bmap2->n_div + n;
		3185	dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
		3186	dim_map2 = isl_dim_map_alloc(bmap1->ctx, total);
		3187	isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
		3188	isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos = 0);
		3189	isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
		3190	isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos += n_in);
		3191	isl_dim_map_div(dim_map1, bmap1, pos += n_out);
		3192	isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
		3193	isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += bmap2->n_div);
		3194	isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos);
		3195
		3196	bmap = isl_basic_map_alloc_space(dim_result,
		3197	bmap1->n_div + bmap2->n_div + n,
		3198	bmap1->n_eq + bmap2->n_eq,
		3199	bmap1->n_ineq + bmap2->n_ineq);
		3200	bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap1, dim_map1);
		3201	bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap2, dim_map2);
		3202	bmap = add_divs(bmap, n);
		3203	bmap = isl_basic_map_simplify(bmap);
		3204	bmap = isl_basic_map_drop_redundant_divs(bmap);
		3205	return isl_basic_map_finalize(bmap);
		3206	error:
		3207	isl_basic_map_free(bmap1);
		3208	isl_basic_map_free(bmap2);
		3209	return NULL;
		3210	}
		3211
		3212	struct isl_basic_set *isl_basic_set_apply(
		3213	struct isl_basic_set *bset, struct isl_basic_map *bmap)
		3214	{
		3215	if (!bset || !bmap)
		3216	goto error;
		3217
		3218	isl_assert(bset->ctx, isl_basic_map_compatible_domain(bmap, bset),
		3219	goto error);
		3220
		3221	return (struct isl_basic_set *)
		3222	isl_basic_map_apply_range((struct isl_basic_map *)bset, bmap);
		3223	error:
		3224	isl_basic_set_free(bset);
		3225	isl_basic_map_free(bmap);
		3226	return NULL;
		3227	}
		3228
		3229	struct isl_basic_map *isl_basic_map_apply_domain(
		3230	struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
		3231	{
		3232	if (!bmap1 || !bmap2)
		3233	goto error;
		3234
		3235	isl_assert(bmap1->ctx,
		3236	isl_basic_map_n_in(bmap1) == isl_basic_map_n_in(bmap2), goto error);
		3237	isl_assert(bmap1->ctx,
		3238	isl_basic_map_n_param(bmap1) == isl_basic_map_n_param(bmap2),
		3239	goto error);
		3240
		3241	bmap1 = isl_basic_map_reverse(bmap1);
		3242	bmap1 = isl_basic_map_apply_range(bmap1, bmap2);
		3243	return isl_basic_map_reverse(bmap1);
		3244	error:
		3245	isl_basic_map_free(bmap1);
		3246	isl_basic_map_free(bmap2);
		3247	return NULL;
		3248	}
		3249
		3250	/* Given two basic maps A -> f(A) and B -> g(B), construct a basic map
		3251	* A \cap B -> f(A) + f(B)
		3252	*/
		3253	struct isl_basic_map *isl_basic_map_sum(
		3254	struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
		3255	{
		3256	unsigned n_in, n_out, nparam, total, pos;
		3257	struct isl_basic_map *bmap = NULL;
		3258	struct isl_dim_map *dim_map1, *dim_map2;
		3259	int i;
		3260
		3261	if (!bmap1 || !bmap2)
		3262	goto error;
		3263
		3264	isl_assert(bmap1->ctx, isl_space_is_equal(bmap1->dim, bmap2->dim),
		3265	goto error);
		3266
		3267	nparam = isl_basic_map_n_param(bmap1);
		3268	n_in = isl_basic_map_n_in(bmap1);
		3269	n_out = isl_basic_map_n_out(bmap1);
		3270
		3271	total = nparam + n_in + n_out + bmap1->n_div + bmap2->n_div + 2 * n_out;
		3272	dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
		3273	dim_map2 = isl_dim_map_alloc(bmap2->ctx, total);
		3274	isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
		3275	isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos);
		3276	isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
		3277	isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos);
		3278	isl_dim_map_div(dim_map1, bmap1, pos += n_in + n_out);
		3279	isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
		3280	isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += bmap2->n_div);
		3281	isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos += n_out);
		3282
		3283	bmap = isl_basic_map_alloc_space(isl_space_copy(bmap1->dim),
		3284	bmap1->n_div + bmap2->n_div + 2 * n_out,
		3285	bmap1->n_eq + bmap2->n_eq + n_out,
		3286	bmap1->n_ineq + bmap2->n_ineq);
		3287	for (i = 0; i < n_out; ++i) {
		3288	int j = isl_basic_map_alloc_equality(bmap);
		3289	if (j < 0)
		3290	goto error;
		3291	isl_seq_clr(bmap->eq[j], 1+total);
		3292	isl_int_set_si(bmap->eq[j][1+nparam+n_in+i], -1);
		3293	isl_int_set_si(bmap->eq[j][1+pos+i], 1);
		3294	isl_int_set_si(bmap->eq[j][1+pos-n_out+i], 1);
		3295	}
		3296	bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap1, dim_map1);
		3297	bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap2, dim_map2);
		3298	bmap = add_divs(bmap, 2 * n_out);
		3299
		3300	bmap = isl_basic_map_simplify(bmap);
		3301	return isl_basic_map_finalize(bmap);
		3302	error:
		3303	isl_basic_map_free(bmap);
		3304	isl_basic_map_free(bmap1);
		3305	isl_basic_map_free(bmap2);
		3306	return NULL;
		3307	}
		3308
		3309	/* Given two maps A -> f(A) and B -> g(B), construct a map
		3310	* A \cap B -> f(A) + f(B)
		3311	*/
		3312	struct isl_map *isl_map_sum(struct isl_map *map1, struct isl_map *map2)
		3313	{
		3314	struct isl_map *result;
		3315	int i, j;
		3316
		3317	if (!map1 || !map2)
		3318	goto error;
		3319
		3320	isl_assert(map1->ctx, isl_space_is_equal(map1->dim, map2->dim), goto error);
		3321
		3322	result = isl_map_alloc_space(isl_space_copy(map1->dim),
		3323	map1->n * map2->n, 0);
		3324	if (!result)
		3325	goto error;
		3326	for (i = 0; i < map1->n; ++i)
		3327	for (j = 0; j < map2->n; ++j) {
		3328	struct isl_basic_map *part;
		3329	part = isl_basic_map_sum(
		3330	isl_basic_map_copy(map1->p[i]),
		3331	isl_basic_map_copy(map2->p[j]));
		3332	if (isl_basic_map_is_empty(part))
		3333	isl_basic_map_free(part);
		3334	else
		3335	result = isl_map_add_basic_map(result, part);
		3336	if (!result)
		3337	goto error;
		3338	}
		3339	isl_map_free(map1);
		3340	isl_map_free(map2);
		3341	return result;
		3342	error:
		3343	isl_map_free(map1);
		3344	isl_map_free(map2);
		3345	return NULL;
		3346	}
		3347
		3348	__isl_give isl_set *isl_set_sum(__isl_take isl_set *set1,
		3349	__isl_take isl_set *set2)
		3350	{
		3351	return (isl_set *)isl_map_sum((isl_map *)set1, (isl_map *)set2);
		3352	}
		3353
		3354	/* Given a basic map A -> f(A), construct A -> -f(A).
		3355	*/
		3356	struct isl_basic_map *isl_basic_map_neg(struct isl_basic_map *bmap)
		3357	{
		3358	int i, j;
		3359	unsigned off, n;
		3360
		3361	bmap = isl_basic_map_cow(bmap);
		3362	if (!bmap)
		3363	return NULL;
		3364
		3365	n = isl_basic_map_dim(bmap, isl_dim_out);
		3366	off = isl_basic_map_offset(bmap, isl_dim_out);
		3367	for (i = 0; i < bmap->n_eq; ++i)
		3368	for (j = 0; j < n; ++j)
		3369	isl_int_neg(bmap->eq[i][off+j], bmap->eq[i][off+j]);
		3370	for (i = 0; i < bmap->n_ineq; ++i)
		3371	for (j = 0; j < n; ++j)
		3372	isl_int_neg(bmap->ineq[i][off+j], bmap->ineq[i][off+j]);
		3373	for (i = 0; i < bmap->n_div; ++i)
		3374	for (j = 0; j < n; ++j)
		3375	isl_int_neg(bmap->div[i][1+off+j], bmap->div[i][1+off+j]);
		3376	bmap = isl_basic_map_gauss(bmap, NULL);
		3377	return isl_basic_map_finalize(bmap);
		3378	}
		3379
		3380	__isl_give isl_basic_set *isl_basic_set_neg(__isl_take isl_basic_set *bset)
		3381	{
		3382	return isl_basic_map_neg(bset);
		3383	}
		3384
		3385	/* Given a map A -> f(A), construct A -> -f(A).
		3386	*/
		3387	struct isl_map *isl_map_neg(struct isl_map *map)
		3388	{
		3389	int i;
		3390
		3391	map = isl_map_cow(map);
		3392	if (!map)
		3393	return NULL;
		3394
		3395	for (i = 0; i < map->n; ++i) {
		3396	map->p[i] = isl_basic_map_neg(map->p[i]);
		3397	if (!map->p[i])
		3398	goto error;
		3399	}
		3400
		3401	return map;
		3402	error:
		3403	isl_map_free(map);
		3404	return NULL;
		3405	}
		3406
		3407	__isl_give isl_set *isl_set_neg(__isl_take isl_set *set)
		3408	{
		3409	return (isl_set *)isl_map_neg((isl_map *)set);
		3410	}
		3411
		3412	/* Given a basic map A -> f(A) and an integer d, construct a basic map
		3413	* A -> floor(f(A)/d).
		3414	*/
		3415	struct isl_basic_map *isl_basic_map_floordiv(struct isl_basic_map *bmap,
		3416	isl_int d)
		3417	{
		3418	unsigned n_in, n_out, nparam, total, pos;
		3419	struct isl_basic_map *result = NULL;
		3420	struct isl_dim_map *dim_map;
		3421	int i;
		3422
		3423	if (!bmap)
		3424	return NULL;
		3425
		3426	nparam = isl_basic_map_n_param(bmap);
		3427	n_in = isl_basic_map_n_in(bmap);
		3428	n_out = isl_basic_map_n_out(bmap);
		3429
		3430	total = nparam + n_in + n_out + bmap->n_div + n_out;
		3431	dim_map = isl_dim_map_alloc(bmap->ctx, total);
		3432	isl_dim_map_dim(dim_map, bmap->dim, isl_dim_param, pos = 0);
		3433	isl_dim_map_dim(dim_map, bmap->dim, isl_dim_in, pos += nparam);
		3434	isl_dim_map_div(dim_map, bmap, pos += n_in + n_out);
		3435	isl_dim_map_dim(dim_map, bmap->dim, isl_dim_out, pos += bmap->n_div);
		3436
		3437	result = isl_basic_map_alloc_space(isl_space_copy(bmap->dim),
		3438	bmap->n_div + n_out,
		3439	bmap->n_eq, bmap->n_ineq + 2 * n_out);
		3440	result = isl_basic_map_add_constraints_dim_map(result, bmap, dim_map);
		3441	result = add_divs(result, n_out);
		3442	for (i = 0; i < n_out; ++i) {
		3443	int j;
		3444	j = isl_basic_map_alloc_inequality(result);
		3445	if (j < 0)
		3446	goto error;
		3447	isl_seq_clr(result->ineq[j], 1+total);
		3448	isl_int_neg(result->ineq[j][1+nparam+n_in+i], d);
		3449	isl_int_set_si(result->ineq[j][1+pos+i], 1);
		3450	j = isl_basic_map_alloc_inequality(result);
		3451	if (j < 0)
		3452	goto error;
		3453	isl_seq_clr(result->ineq[j], 1+total);
		3454	isl_int_set(result->ineq[j][1+nparam+n_in+i], d);
		3455	isl_int_set_si(result->ineq[j][1+pos+i], -1);
		3456	isl_int_sub_ui(result->ineq[j][0], d, 1);
		3457	}
		3458
		3459	result = isl_basic_map_simplify(result);
		3460	return isl_basic_map_finalize(result);
		3461	error:
		3462	isl_basic_map_free(result);
		3463	return NULL;
		3464	}
		3465
		3466	/* Given a map A -> f(A) and an integer d, construct a map
		3467	* A -> floor(f(A)/d).
		3468	*/
		3469	struct isl_map *isl_map_floordiv(struct isl_map *map, isl_int d)
		3470	{
		3471	int i;
		3472
		3473	map = isl_map_cow(map);
		3474	if (!map)
		3475	return NULL;
		3476
		3477	ISL_F_CLR(map, ISL_MAP_DISJOINT);
		3478	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
		3479	for (i = 0; i < map->n; ++i) {
		3480	map->p[i] = isl_basic_map_floordiv(map->p[i], d);
		3481	if (!map->p[i])
		3482	goto error;
		3483	}
		3484
		3485	return map;
		3486	error:
		3487	isl_map_free(map);
		3488	return NULL;
		3489	}
		3490
		3491	static struct isl_basic_map *var_equal(struct isl_basic_map *bmap, unsigned pos)
		3492	{
		3493	int i;
		3494	unsigned nparam;
		3495	unsigned n_in;
		3496
		3497	i = isl_basic_map_alloc_equality(bmap);
		3498	if (i < 0)
		3499	goto error;
		3500	nparam = isl_basic_map_n_param(bmap);
		3501	n_in = isl_basic_map_n_in(bmap);
		3502	isl_seq_clr(bmap->eq[i], 1 + isl_basic_map_total_dim(bmap));
		3503	isl_int_set_si(bmap->eq[i][1+nparam+pos], -1);
		3504	isl_int_set_si(bmap->eq[i][1+nparam+n_in+pos], 1);
		3505	return isl_basic_map_finalize(bmap);
		3506	error:
		3507	isl_basic_map_free(bmap);
		3508	return NULL;
		3509	}
		3510
		3511	/* Add a constraints to "bmap" expressing i_pos < o_pos
		3512	*/
		3513	static struct isl_basic_map *var_less(struct isl_basic_map *bmap, unsigned pos)
		3514	{
		3515	int i;
		3516	unsigned nparam;
		3517	unsigned n_in;
		3518
		3519	i = isl_basic_map_alloc_inequality(bmap);
		3520	if (i < 0)
		3521	goto error;
		3522	nparam = isl_basic_map_n_param(bmap);
		3523	n_in = isl_basic_map_n_in(bmap);
		3524	isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap));
		3525	isl_int_set_si(bmap->ineq[i][0], -1);
		3526	isl_int_set_si(bmap->ineq[i][1+nparam+pos], -1);
		3527	isl_int_set_si(bmap->ineq[i][1+nparam+n_in+pos], 1);
		3528	return isl_basic_map_finalize(bmap);
		3529	error:
		3530	isl_basic_map_free(bmap);
		3531	return NULL;
		3532	}
		3533
		3534	/* Add a constraint to "bmap" expressing i_pos <= o_pos
		3535	*/
		3536	static __isl_give isl_basic_map *var_less_or_equal(
		3537	__isl_take isl_basic_map *bmap, unsigned pos)
		3538	{
		3539	int i;
		3540	unsigned nparam;
		3541	unsigned n_in;
		3542
		3543	i = isl_basic_map_alloc_inequality(bmap);
		3544	if (i < 0)
		3545	goto error;
		3546	nparam = isl_basic_map_n_param(bmap);
		3547	n_in = isl_basic_map_n_in(bmap);
		3548	isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap));
		3549	isl_int_set_si(bmap->ineq[i][1+nparam+pos], -1);
		3550	isl_int_set_si(bmap->ineq[i][1+nparam+n_in+pos], 1);
		3551	return isl_basic_map_finalize(bmap);
		3552	error:
		3553	isl_basic_map_free(bmap);
		3554	return NULL;
		3555	}
		3556
		3557	/* Add a constraints to "bmap" expressing i_pos > o_pos
		3558	*/
		3559	static struct isl_basic_map *var_more(struct isl_basic_map *bmap, unsigned pos)
		3560	{
		3561	int i;
		3562	unsigned nparam;
		3563	unsigned n_in;
		3564
		3565	i = isl_basic_map_alloc_inequality(bmap);
		3566	if (i < 0)
		3567	goto error;
		3568	nparam = isl_basic_map_n_param(bmap);
		3569	n_in = isl_basic_map_n_in(bmap);
		3570	isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap));
		3571	isl_int_set_si(bmap->ineq[i][0], -1);
		3572	isl_int_set_si(bmap->ineq[i][1+nparam+pos], 1);
		3573	isl_int_set_si(bmap->ineq[i][1+nparam+n_in+pos], -1);
		3574	return isl_basic_map_finalize(bmap);
		3575	error:
		3576	isl_basic_map_free(bmap);
		3577	return NULL;
		3578	}
		3579
		3580	/* Add a constraint to "bmap" expressing i_pos >= o_pos
		3581	*/
		3582	static __isl_give isl_basic_map *var_more_or_equal(
		3583	__isl_take isl_basic_map *bmap, unsigned pos)
		3584	{
		3585	int i;
		3586	unsigned nparam;
		3587	unsigned n_in;
		3588
		3589	i = isl_basic_map_alloc_inequality(bmap);
		3590	if (i < 0)
		3591	goto error;
		3592	nparam = isl_basic_map_n_param(bmap);
		3593	n_in = isl_basic_map_n_in(bmap);
		3594	isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap));
		3595	isl_int_set_si(bmap->ineq[i][1+nparam+pos], 1);
		3596	isl_int_set_si(bmap->ineq[i][1+nparam+n_in+pos], -1);
		3597	return isl_basic_map_finalize(bmap);
		3598	error:
		3599	isl_basic_map_free(bmap);
		3600	return NULL;
		3601	}
		3602
		3603	__isl_give isl_basic_map *isl_basic_map_equal(
		3604	__isl_take isl_space *dim, unsigned n_equal)
		3605	{
		3606	int i;
		3607	struct isl_basic_map *bmap;
		3608	bmap = isl_basic_map_alloc_space(dim, 0, n_equal, 0);
		3609	if (!bmap)
		3610	return NULL;
		3611	for (i = 0; i < n_equal && bmap; ++i)
		3612	bmap = var_equal(bmap, i);
		3613	return isl_basic_map_finalize(bmap);
		3614	}
		3615
		3616	/* Return a relation on of dimension "dim" expressing i_[0..pos] << o_[0..pos]
		3617	*/
		3618	__isl_give isl_basic_map *isl_basic_map_less_at(__isl_take isl_space *dim,
		3619	unsigned pos)
		3620	{
		3621	int i;
		3622	struct isl_basic_map *bmap;
		3623	bmap = isl_basic_map_alloc_space(dim, 0, pos, 1);
		3624	if (!bmap)
		3625	return NULL;
		3626	for (i = 0; i < pos && bmap; ++i)
		3627	bmap = var_equal(bmap, i);
		3628	if (bmap)
		3629	bmap = var_less(bmap, pos);
		3630	return isl_basic_map_finalize(bmap);
		3631	}
		3632
		3633	/* Return a relation on of dimension "dim" expressing i_[0..pos] <<= o_[0..pos]
		3634	*/
		3635	__isl_give isl_basic_map *isl_basic_map_less_or_equal_at(
		3636	__isl_take isl_space *dim, unsigned pos)
		3637	{
		3638	int i;
		3639	isl_basic_map *bmap;
		3640
		3641	bmap = isl_basic_map_alloc_space(dim, 0, pos, 1);
		3642	for (i = 0; i < pos; ++i)
		3643	bmap = var_equal(bmap, i);
		3644	bmap = var_less_or_equal(bmap, pos);
		3645	return isl_basic_map_finalize(bmap);
		3646	}
		3647
		3648	/* Return a relation on pairs of sets of dimension "dim" expressing i_pos > o_pos
		3649	*/
		3650	__isl_give isl_basic_map *isl_basic_map_more_at(__isl_take isl_space *dim,
		3651	unsigned pos)
		3652	{
		3653	int i;
		3654	struct isl_basic_map *bmap;
		3655	bmap = isl_basic_map_alloc_space(dim, 0, pos, 1);
		3656	if (!bmap)
		3657	return NULL;
		3658	for (i = 0; i < pos && bmap; ++i)
		3659	bmap = var_equal(bmap, i);
		3660	if (bmap)
		3661	bmap = var_more(bmap, pos);
		3662	return isl_basic_map_finalize(bmap);
		3663	}
		3664
		3665	/* Return a relation on of dimension "dim" expressing i_[0..pos] >>= o_[0..pos]
		3666	*/
		3667	__isl_give isl_basic_map *isl_basic_map_more_or_equal_at(
		3668	__isl_take isl_space *dim, unsigned pos)
		3669	{
		3670	int i;
		3671	isl_basic_map *bmap;
		3672
		3673	bmap = isl_basic_map_alloc_space(dim, 0, pos, 1);
		3674	for (i = 0; i < pos; ++i)
		3675	bmap = var_equal(bmap, i);
		3676	bmap = var_more_or_equal(bmap, pos);
		3677	return isl_basic_map_finalize(bmap);
		3678	}
		3679
		3680	static __isl_give isl_map *map_lex_lte_first(__isl_take isl_space *dims,
		3681	unsigned n, int equal)
		3682	{
		3683	struct isl_map *map;
		3684	int i;
		3685
		3686	if (n == 0 && equal)
		3687	return isl_map_universe(dims);
		3688
		3689	map = isl_map_alloc_space(isl_space_copy(dims), n, ISL_MAP_DISJOINT);
		3690
		3691	for (i = 0; i + 1 < n; ++i)
		3692	map = isl_map_add_basic_map(map,
		3693	isl_basic_map_less_at(isl_space_copy(dims), i));
		3694	if (n > 0) {
		3695	if (equal)
		3696	map = isl_map_add_basic_map(map,
		3697	isl_basic_map_less_or_equal_at(dims, n - 1));
		3698	else
		3699	map = isl_map_add_basic_map(map,
		3700	isl_basic_map_less_at(dims, n - 1));
		3701	} else
		3702	isl_space_free(dims);
		3703
		3704	return map;
		3705	}
		3706
		3707	static __isl_give isl_map *map_lex_lte(__isl_take isl_space *dims, int equal)
		3708	{
		3709	if (!dims)
		3710	return NULL;
		3711	return map_lex_lte_first(dims, dims->n_out, equal);
		3712	}
		3713
		3714	__isl_give isl_map *isl_map_lex_lt_first(__isl_take isl_space *dim, unsigned n)
		3715	{
		3716	return map_lex_lte_first(dim, n, 0);
		3717	}
		3718
		3719	__isl_give isl_map *isl_map_lex_le_first(__isl_take isl_space *dim, unsigned n)
		3720	{
		3721	return map_lex_lte_first(dim, n, 1);
		3722	}
		3723
		3724	__isl_give isl_map *isl_map_lex_lt(__isl_take isl_space *set_dim)
		3725	{
		3726	return map_lex_lte(isl_space_map_from_set(set_dim), 0);
		3727	}
		3728
		3729	__isl_give isl_map *isl_map_lex_le(__isl_take isl_space *set_dim)
		3730	{
		3731	return map_lex_lte(isl_space_map_from_set(set_dim), 1);
		3732	}
		3733
		3734	static __isl_give isl_map *map_lex_gte_first(__isl_take isl_space *dims,
		3735	unsigned n, int equal)
		3736	{
		3737	struct isl_map *map;
		3738	int i;
		3739
		3740	if (n == 0 && equal)
		3741	return isl_map_universe(dims);
		3742
		3743	map = isl_map_alloc_space(isl_space_copy(dims), n, ISL_MAP_DISJOINT);
		3744
		3745	for (i = 0; i + 1 < n; ++i)
		3746	map = isl_map_add_basic_map(map,
		3747	isl_basic_map_more_at(isl_space_copy(dims), i));
		3748	if (n > 0) {
		3749	if (equal)
		3750	map = isl_map_add_basic_map(map,
		3751	isl_basic_map_more_or_equal_at(dims, n - 1));
		3752	else
		3753	map = isl_map_add_basic_map(map,
		3754	isl_basic_map_more_at(dims, n - 1));
		3755	} else
		3756	isl_space_free(dims);
		3757
		3758	return map;
		3759	}
		3760
		3761	static __isl_give isl_map *map_lex_gte(__isl_take isl_space *dims, int equal)
		3762	{
		3763	if (!dims)
		3764	return NULL;
		3765	return map_lex_gte_first(dims, dims->n_out, equal);
		3766	}
		3767
		3768	__isl_give isl_map *isl_map_lex_gt_first(__isl_take isl_space *dim, unsigned n)
		3769	{
		3770	return map_lex_gte_first(dim, n, 0);
		3771	}
		3772
		3773	__isl_give isl_map *isl_map_lex_ge_first(__isl_take isl_space *dim, unsigned n)
		3774	{
		3775	return map_lex_gte_first(dim, n, 1);
		3776	}
		3777
		3778	__isl_give isl_map *isl_map_lex_gt(__isl_take isl_space *set_dim)
		3779	{
		3780	return map_lex_gte(isl_space_map_from_set(set_dim), 0);
		3781	}
		3782
		3783	__isl_give isl_map *isl_map_lex_ge(__isl_take isl_space *set_dim)
		3784	{
		3785	return map_lex_gte(isl_space_map_from_set(set_dim), 1);
		3786	}
		3787
		3788	__isl_give isl_map *isl_set_lex_le_set(__isl_take isl_set *set1,
		3789	__isl_take isl_set *set2)
		3790	{
		3791	isl_map *map;
		3792	map = isl_map_lex_le(isl_set_get_space(set1));
		3793	map = isl_map_intersect_domain(map, set1);
		3794	map = isl_map_intersect_range(map, set2);
		3795	return map;
		3796	}
		3797
		3798	__isl_give isl_map *isl_set_lex_lt_set(__isl_take isl_set *set1,
		3799	__isl_take isl_set *set2)
		3800	{
		3801	isl_map *map;
		3802	map = isl_map_lex_lt(isl_set_get_space(set1));
		3803	map = isl_map_intersect_domain(map, set1);
		3804	map = isl_map_intersect_range(map, set2);
		3805	return map;
		3806	}
		3807
		3808	__isl_give isl_map *isl_set_lex_ge_set(__isl_take isl_set *set1,
		3809	__isl_take isl_set *set2)
		3810	{
		3811	isl_map *map;
		3812	map = isl_map_lex_ge(isl_set_get_space(set1));
		3813	map = isl_map_intersect_domain(map, set1);
		3814	map = isl_map_intersect_range(map, set2);
		3815	return map;
		3816	}
		3817
		3818	__isl_give isl_map *isl_set_lex_gt_set(__isl_take isl_set *set1,
		3819	__isl_take isl_set *set2)
		3820	{
		3821	isl_map *map;
		3822	map = isl_map_lex_gt(isl_set_get_space(set1));
		3823	map = isl_map_intersect_domain(map, set1);
		3824	map = isl_map_intersect_range(map, set2);
		3825	return map;
		3826	}
		3827
		3828	__isl_give isl_map *isl_map_lex_le_map(__isl_take isl_map *map1,
		3829	__isl_take isl_map *map2)
		3830	{
		3831	isl_map *map;
		3832	map = isl_map_lex_le(isl_space_range(isl_map_get_space(map1)));
		3833	map = isl_map_apply_domain(map, isl_map_reverse(map1));
		3834	map = isl_map_apply_range(map, isl_map_reverse(map2));
		3835	return map;
		3836	}
		3837
		3838	__isl_give isl_map *isl_map_lex_lt_map(__isl_take isl_map *map1,
		3839	__isl_take isl_map *map2)
		3840	{
		3841	isl_map *map;
		3842	map = isl_map_lex_lt(isl_space_range(isl_map_get_space(map1)));
		3843	map = isl_map_apply_domain(map, isl_map_reverse(map1));
		3844	map = isl_map_apply_range(map, isl_map_reverse(map2));
		3845	return map;
		3846	}
		3847
		3848	__isl_give isl_map *isl_map_lex_ge_map(__isl_take isl_map *map1,
		3849	__isl_take isl_map *map2)
		3850	{
		3851	isl_map *map;
		3852	map = isl_map_lex_ge(isl_space_range(isl_map_get_space(map1)));
		3853	map = isl_map_apply_domain(map, isl_map_reverse(map1));
		3854	map = isl_map_apply_range(map, isl_map_reverse(map2));
		3855	return map;
		3856	}
		3857
		3858	__isl_give isl_map *isl_map_lex_gt_map(__isl_take isl_map *map1,
		3859	__isl_take isl_map *map2)
		3860	{
		3861	isl_map *map;
		3862	map = isl_map_lex_gt(isl_space_range(isl_map_get_space(map1)));
		3863	map = isl_map_apply_domain(map, isl_map_reverse(map1));
		3864	map = isl_map_apply_range(map, isl_map_reverse(map2));
		3865	return map;
		3866	}
		3867
		3868	__isl_give isl_basic_map *isl_basic_map_from_basic_set(
		3869	__isl_take isl_basic_set *bset, __isl_take isl_space *dim)
		3870	{
		3871	struct isl_basic_map *bmap;
		3872
		3873	bset = isl_basic_set_cow(bset);
		3874	if (!bset || !dim)
		3875	goto error;
		3876
		3877	isl_assert(bset->ctx, isl_space_compatible(bset->dim, dim), goto error);
		3878	isl_space_free(bset->dim);
		3879	bmap = (struct isl_basic_map *) bset;
		3880	bmap->dim = dim;
		3881	return isl_basic_map_finalize(bmap);
		3882	error:
		3883	isl_basic_set_free(bset);
		3884	isl_space_free(dim);
		3885	return NULL;
		3886	}
		3887
		3888	struct isl_basic_set *isl_basic_set_from_basic_map(struct isl_basic_map *bmap)
		3889	{
		3890	if (!bmap)
		3891	goto error;
		3892	if (bmap->dim->n_in == 0)
		3893	return (struct isl_basic_set *)bmap;
		3894	bmap = isl_basic_map_cow(bmap);
		3895	if (!bmap)
		3896	goto error;
		3897	bmap->dim = isl_space_as_set_space(bmap->dim);
		3898	if (!bmap->dim)
		3899	goto error;
		3900	bmap = isl_basic_map_finalize(bmap);
		3901	return (struct isl_basic_set *)bmap;
		3902	error:
		3903	isl_basic_map_free(bmap);
		3904	return NULL;
		3905	}
		3906
		3907	/* For a div d = floor(f/m), add the constraints
		3908	*
		3909	* f - m d >= 0
		3910	* -(f-(n-1)) + m d >= 0
		3911	*
		3912	* Note that the second constraint is the negation of
		3913	*
		3914	* f - m d >= n
		3915	*/
		3916	int isl_basic_map_add_div_constraints_var(__isl_keep isl_basic_map *bmap,
		3917	unsigned pos, isl_int *div)
		3918	{
		3919	int i, j;
		3920	unsigned total = isl_basic_map_total_dim(bmap);
		3921
		3922	i = isl_basic_map_alloc_inequality(bmap);
		3923	if (i < 0)
		3924	return -1;
		3925	isl_seq_cpy(bmap->ineq[i], div + 1, 1 + total);
		3926	isl_int_neg(bmap->ineq[i][1 + pos], div[0]);
		3927
		3928	j = isl_basic_map_alloc_inequality(bmap);
		3929	if (j < 0)
		3930	return -1;
		3931	isl_seq_neg(bmap->ineq[j], bmap->ineq[i], 1 + total);
		3932	isl_int_add(bmap->ineq[j][0], bmap->ineq[j][0], bmap->ineq[j][1 + pos]);
		3933	isl_int_sub_ui(bmap->ineq[j][0], bmap->ineq[j][0], 1);
		3934	return j;
		3935	}
		3936
		3937	int isl_basic_set_add_div_constraints_var(__isl_keep isl_basic_set *bset,
		3938	unsigned pos, isl_int *div)
		3939	{
		3940	return isl_basic_map_add_div_constraints_var((isl_basic_map *)bset,
		3941	pos, div);
		3942	}
		3943
		3944	int isl_basic_map_add_div_constraints(struct isl_basic_map *bmap, unsigned div)
		3945	{
		3946	unsigned total = isl_basic_map_total_dim(bmap);
		3947	unsigned div_pos = total - bmap->n_div + div;
		3948
		3949	return isl_basic_map_add_div_constraints_var(bmap, div_pos,
		3950	bmap->div[div]);
		3951	}
		3952
		3953	struct isl_basic_set *isl_basic_map_underlying_set(
		3954	struct isl_basic_map *bmap)
		3955	{
		3956	if (!bmap)
		3957	goto error;
		3958	if (bmap->dim->nparam == 0 && bmap->dim->n_in == 0 &&
		3959	bmap->n_div == 0 &&
		3960	!isl_space_is_named_or_nested(bmap->dim, isl_dim_in) &&
		3961	!isl_space_is_named_or_nested(bmap->dim, isl_dim_out))
		3962	return (struct isl_basic_set *)bmap;
		3963	bmap = isl_basic_map_cow(bmap);
		3964	if (!bmap)
		3965	goto error;
		3966	bmap->dim = isl_space_underlying(bmap->dim, bmap->n_div);
		3967	if (!bmap->dim)
		3968	goto error;
		3969	bmap->extra -= bmap->n_div;
		3970	bmap->n_div = 0;
		3971	bmap = isl_basic_map_finalize(bmap);
		3972	return (struct isl_basic_set *)bmap;
		3973	error:
		3974	return NULL;
		3975	}
		3976
		3977	__isl_give isl_basic_set *isl_basic_set_underlying_set(
		3978	__isl_take isl_basic_set *bset)
		3979	{
		3980	return isl_basic_map_underlying_set((isl_basic_map *)bset);
		3981	}
		3982
		3983	struct isl_basic_map *isl_basic_map_overlying_set(
		3984	struct isl_basic_set *bset, struct isl_basic_map *like)
		3985	{
		3986	struct isl_basic_map *bmap;
		3987	struct isl_ctx *ctx;
		3988	unsigned total;
		3989	int i;
		3990
		3991	if (!bset || !like)
		3992	goto error;
		3993	ctx = bset->ctx;
		3994	isl_assert(ctx, bset->n_div == 0, goto error);
		3995	isl_assert(ctx, isl_basic_set_n_param(bset) == 0, goto error);
		3996	isl_assert(ctx, bset->dim->n_out == isl_basic_map_total_dim(like),
		3997	goto error);
		3998	if (isl_space_is_equal(bset->dim, like->dim) && like->n_div == 0) {
		3999	isl_basic_map_free(like);
		4000	return (struct isl_basic_map *)bset;
		4001	}
		4002	bset = isl_basic_set_cow(bset);
		4003	if (!bset)
		4004	goto error;
		4005	total = bset->dim->n_out + bset->extra;
		4006	bmap = (struct isl_basic_map *)bset;
		4007	isl_space_free(bmap->dim);
		4008	bmap->dim = isl_space_copy(like->dim);
		4009	if (!bmap->dim)
		4010	goto error;
		4011	bmap->n_div = like->n_div;
		4012	bmap->extra += like->n_div;
		4013	if (bmap->extra) {
		4014	unsigned ltotal;
		4015	isl_int **div;
		4016	ltotal = total - bmap->extra + like->extra;
		4017	if (ltotal > total)
		4018	ltotal = total;
		4019	bmap->block2 = isl_blk_extend(ctx, bmap->block2,
		4020	bmap->extra * (1 + 1 + total));
		4021	if (isl_blk_is_error(bmap->block2))
		4022	goto error;
		4023	div = isl_realloc_array(ctx, bmap->div, isl_int *, bmap->extra);
		4024	if (!div)
		4025	goto error;
		4026	bmap->div = div;
		4027	for (i = 0; i < bmap->extra; ++i)
		4028	bmap->div[i] = bmap->block2.data + i * (1 + 1 + total);
		4029	for (i = 0; i < like->n_div; ++i) {
		4030	isl_seq_cpy(bmap->div[i], like->div[i], 1 + 1 + ltotal);
		4031	isl_seq_clr(bmap->div[i]+1+1+ltotal, total - ltotal);
		4032	}
		4033	bmap = isl_basic_map_extend_constraints(bmap,
		4034	0, 2 * like->n_div);
		4035	for (i = 0; i < like->n_div; ++i) {
		4036	if (isl_int_is_zero(bmap->div[i][0]))
		4037	continue;
		4038	if (isl_basic_map_add_div_constraints(bmap, i) < 0)
		4039	goto error;
		4040	}
		4041	}
		4042	isl_basic_map_free(like);
		4043	bmap = isl_basic_map_simplify(bmap);
		4044	bmap = isl_basic_map_finalize(bmap);
		4045	return bmap;
		4046	error:
		4047	isl_basic_map_free(like);
		4048	isl_basic_set_free(bset);
		4049	return NULL;
		4050	}
		4051
		4052	struct isl_basic_set *isl_basic_set_from_underlying_set(
		4053	struct isl_basic_set *bset, struct isl_basic_set *like)
		4054	{
		4055	return (struct isl_basic_set *)
		4056	isl_basic_map_overlying_set(bset, (struct isl_basic_map *)like);
		4057	}
		4058
		4059	struct isl_set *isl_set_from_underlying_set(
		4060	struct isl_set *set, struct isl_basic_set *like)
		4061	{
		4062	int i;
		4063
		4064	if (!set || !like)
		4065	goto error;
		4066	isl_assert(set->ctx, set->dim->n_out == isl_basic_set_total_dim(like),
		4067	goto error);
		4068	if (isl_space_is_equal(set->dim, like->dim) && like->n_div == 0) {
		4069	isl_basic_set_free(like);
		4070	return set;
		4071	}
		4072	set = isl_set_cow(set);
		4073	if (!set)
		4074	goto error;
		4075	for (i = 0; i < set->n; ++i) {
		4076	set->p[i] = isl_basic_set_from_underlying_set(set->p[i],
		4077	isl_basic_set_copy(like));
		4078	if (!set->p[i])
		4079	goto error;
		4080	}
		4081	isl_space_free(set->dim);
		4082	set->dim = isl_space_copy(like->dim);
		4083	if (!set->dim)
		4084	goto error;
		4085	isl_basic_set_free(like);
		4086	return set;
		4087	error:
		4088	isl_basic_set_free(like);
		4089	isl_set_free(set);
		4090	return NULL;
		4091	}
		4092
		4093	struct isl_set *isl_map_underlying_set(struct isl_map *map)
		4094	{
		4095	int i;
		4096
		4097	map = isl_map_cow(map);
		4098	if (!map)
		4099	return NULL;
		4100	map->dim = isl_space_cow(map->dim);
		4101	if (!map->dim)
		4102	goto error;
		4103
		4104	for (i = 1; i < map->n; ++i)
		4105	isl_assert(map->ctx, map->p[0]->n_div == map->p[i]->n_div,
		4106	goto error);
		4107	for (i = 0; i < map->n; ++i) {
		4108	map->p[i] = (struct isl_basic_map *)
		4109	isl_basic_map_underlying_set(map->p[i]);
		4110	if (!map->p[i])
		4111	goto error;
		4112	}
		4113	if (map->n == 0)
		4114	map->dim = isl_space_underlying(map->dim, 0);
		4115	else {
		4116	isl_space_free(map->dim);
		4117	map->dim = isl_space_copy(map->p[0]->dim);
		4118	}
		4119	if (!map->dim)
		4120	goto error;
		4121	return (struct isl_set *)map;
		4122	error:
		4123	isl_map_free(map);
		4124	return NULL;
		4125	}
		4126
		4127	struct isl_set *isl_set_to_underlying_set(struct isl_set *set)
		4128	{
		4129	return (struct isl_set *)isl_map_underlying_set((struct isl_map *)set);
		4130	}
		4131
		4132	__isl_give isl_basic_map *isl_basic_map_reset_space(
		4133	__isl_take isl_basic_map *bmap, __isl_take isl_space *dim)
		4134	{
		4135	bmap = isl_basic_map_cow(bmap);
		4136	if (!bmap || !dim)
		4137	goto error;
		4138
		4139	isl_space_free(bmap->dim);
		4140	bmap->dim = dim;
		4141
		4142	bmap = isl_basic_map_finalize(bmap);
		4143
		4144	return bmap;
		4145	error:
		4146	isl_basic_map_free(bmap);
		4147	isl_space_free(dim);
		4148	return NULL;
		4149	}
		4150
		4151	__isl_give isl_basic_set *isl_basic_set_reset_space(
		4152	__isl_take isl_basic_set *bset, __isl_take isl_space *dim)
		4153	{
		4154	return (isl_basic_set *)isl_basic_map_reset_space((isl_basic_map *)bset,
		4155	dim);
		4156	}
		4157
		4158	__isl_give isl_map *isl_map_reset_space(__isl_take isl_map *map,
		4159	__isl_take isl_space *dim)
		4160	{
		4161	int i;
		4162
		4163	map = isl_map_cow(map);
		4164	if (!map || !dim)
		4165	goto error;
		4166
		4167	for (i = 0; i < map->n; ++i) {
		4168	map->p[i] = isl_basic_map_reset_space(map->p[i],
		4169	isl_space_copy(dim));
		4170	if (!map->p[i])
		4171	goto error;
		4172	}
		4173	isl_space_free(map->dim);
		4174	map->dim = dim;
		4175
		4176	return map;
		4177	error:
		4178	isl_map_free(map);
		4179	isl_space_free(dim);
		4180	return NULL;
		4181	}
		4182
		4183	__isl_give isl_set *isl_set_reset_space(__isl_take isl_set *set,
		4184	__isl_take isl_space *dim)
		4185	{
		4186	return (struct isl_set *) isl_map_reset_space((struct isl_map *)set, dim);
		4187	}
		4188
		4189	/* Compute the parameter domain of the given basic set.
		4190	*/
		4191	__isl_give isl_basic_set *isl_basic_set_params(__isl_take isl_basic_set *bset)
		4192	{
		4193	isl_space *space;
		4194	unsigned n;
		4195
		4196	if (isl_basic_set_is_params(bset))
		4197	return bset;
		4198
		4199	n = isl_basic_set_dim(bset, isl_dim_set);
		4200	bset = isl_basic_set_project_out(bset, isl_dim_set, 0, n);
		4201	space = isl_basic_set_get_space(bset);
		4202	space = isl_space_params(space);
		4203	bset = isl_basic_set_reset_space(bset, space);
		4204	return bset;
		4205	}
		4206
		4207	/* Compute the parameter domain of the given set.
		4208	*/
		4209	__isl_give isl_set *isl_set_params(__isl_take isl_set *set)
		4210	{
		4211	isl_space *space;
		4212	unsigned n;
		4213
		4214	if (isl_set_is_params(set))
		4215	return set;
		4216
		4217	n = isl_set_dim(set, isl_dim_set);
		4218	set = isl_set_project_out(set, isl_dim_set, 0, n);
		4219	space = isl_set_get_space(set);
		4220	space = isl_space_params(space);
		4221	set = isl_set_reset_space(set, space);
		4222	return set;
		4223	}
		4224
		4225	/* Construct a zero-dimensional set with the given parameter domain.
		4226	*/
		4227	__isl_give isl_set *isl_set_from_params(__isl_take isl_set *set)
		4228	{
		4229	isl_space *space;
		4230	space = isl_set_get_space(set);
		4231	space = isl_space_set_from_params(space);
		4232	set = isl_set_reset_space(set, space);
		4233	return set;
		4234	}
		4235
		4236	/* Compute the parameter domain of the given map.
		4237	*/
		4238	__isl_give isl_set *isl_map_params(__isl_take isl_map *map)
		4239	{
		4240	isl_space *space;
		4241	unsigned n;
		4242
		4243	n = isl_map_dim(map, isl_dim_in);
		4244	map = isl_map_project_out(map, isl_dim_in, 0, n);
		4245	n = isl_map_dim(map, isl_dim_out);
		4246	map = isl_map_project_out(map, isl_dim_out, 0, n);
		4247	space = isl_map_get_space(map);
		4248	space = isl_space_params(space);
		4249	map = isl_map_reset_space(map, space);
		4250	return map;
		4251	}
		4252
		4253	struct isl_basic_set *isl_basic_map_domain(struct isl_basic_map *bmap)
		4254	{
		4255	isl_space *dim;
		4256	struct isl_basic_set *domain;
		4257	unsigned n_in;
		4258	unsigned n_out;
		4259
		4260	if (!bmap)
		4261	return NULL;
		4262	dim = isl_space_domain(isl_basic_map_get_space(bmap));
		4263
		4264	n_in = isl_basic_map_n_in(bmap);
		4265	n_out = isl_basic_map_n_out(bmap);
		4266	domain = isl_basic_set_from_basic_map(bmap);
		4267	domain = isl_basic_set_project_out(domain, isl_dim_set, n_in, n_out);
		4268
		4269	domain = isl_basic_set_reset_space(domain, dim);
		4270
		4271	return domain;
		4272	}
		4273
		4274	int isl_basic_map_may_be_set(__isl_keep isl_basic_map *bmap)
		4275	{
		4276	if (!bmap)
		4277	return -1;
		4278	return isl_space_may_be_set(bmap->dim);
		4279	}
		4280
		4281	/* Is this basic map actually a set?
		4282	* Users should never call this function. Outside of isl,
		4283	* the type should indicate whether something is a set or a map.
		4284	*/
		4285	int isl_basic_map_is_set(__isl_keep isl_basic_map *bmap)
		4286	{
		4287	if (!bmap)
		4288	return -1;
		4289	return isl_space_is_set(bmap->dim);
		4290	}
		4291
		4292	struct isl_basic_set *isl_basic_map_range(struct isl_basic_map *bmap)
		4293	{
		4294	if (!bmap)
		4295	return NULL;
		4296	if (isl_basic_map_is_set(bmap))
		4297	return bmap;
		4298	return isl_basic_map_domain(isl_basic_map_reverse(bmap));
		4299	}
		4300
		4301	__isl_give isl_basic_map *isl_basic_map_domain_map(
		4302	__isl_take isl_basic_map *bmap)
		4303	{
		4304	int i, k;
		4305	isl_space *dim;
		4306	isl_basic_map *domain;
		4307	int nparam, n_in, n_out;
		4308	unsigned total;
		4309
		4310	nparam = isl_basic_map_dim(bmap, isl_dim_param);
		4311	n_in = isl_basic_map_dim(bmap, isl_dim_in);
		4312	n_out = isl_basic_map_dim(bmap, isl_dim_out);
		4313
		4314	dim = isl_space_from_range(isl_space_domain(isl_basic_map_get_space(bmap)));
		4315	domain = isl_basic_map_universe(dim);
		4316
		4317	bmap = isl_basic_map_from_domain(isl_basic_map_wrap(bmap));
		4318	bmap = isl_basic_map_apply_range(bmap, domain);
		4319	bmap = isl_basic_map_extend_constraints(bmap, n_in, 0);
		4320
		4321	total = isl_basic_map_total_dim(bmap);
		4322
		4323	for (i = 0; i < n_in; ++i) {
		4324	k = isl_basic_map_alloc_equality(bmap);
		4325	if (k < 0)
		4326	goto error;
		4327	isl_seq_clr(bmap->eq[k], 1 + total);
		4328	isl_int_set_si(bmap->eq[k][1 + nparam + i], -1);
		4329	isl_int_set_si(bmap->eq[k][1 + nparam + n_in + n_out + i], 1);
		4330	}
		4331
		4332	bmap = isl_basic_map_gauss(bmap, NULL);
		4333	return isl_basic_map_finalize(bmap);
		4334	error:
		4335	isl_basic_map_free(bmap);
		4336	return NULL;
		4337	}
		4338
		4339	__isl_give isl_basic_map *isl_basic_map_range_map(
		4340	__isl_take isl_basic_map *bmap)
		4341	{
		4342	int i, k;
		4343	isl_space *dim;
		4344	isl_basic_map *range;
		4345	int nparam, n_in, n_out;
		4346	unsigned total;
		4347
		4348	nparam = isl_basic_map_dim(bmap, isl_dim_param);
		4349	n_in = isl_basic_map_dim(bmap, isl_dim_in);
		4350	n_out = isl_basic_map_dim(bmap, isl_dim_out);
		4351
		4352	dim = isl_space_from_range(isl_space_range(isl_basic_map_get_space(bmap)));
		4353	range = isl_basic_map_universe(dim);
		4354
		4355	bmap = isl_basic_map_from_domain(isl_basic_map_wrap(bmap));
		4356	bmap = isl_basic_map_apply_range(bmap, range);
		4357	bmap = isl_basic_map_extend_constraints(bmap, n_out, 0);
		4358
		4359	total = isl_basic_map_total_dim(bmap);
		4360
		4361	for (i = 0; i < n_out; ++i) {
		4362	k = isl_basic_map_alloc_equality(bmap);
		4363	if (k < 0)
		4364	goto error;
		4365	isl_seq_clr(bmap->eq[k], 1 + total);
		4366	isl_int_set_si(bmap->eq[k][1 + nparam + n_in + i], -1);
		4367	isl_int_set_si(bmap->eq[k][1 + nparam + n_in + n_out + i], 1);
		4368	}
		4369
		4370	bmap = isl_basic_map_gauss(bmap, NULL);
		4371	return isl_basic_map_finalize(bmap);
		4372	error:
		4373	isl_basic_map_free(bmap);
		4374	return NULL;
		4375	}
		4376
		4377	int isl_map_may_be_set(__isl_keep isl_map *map)
		4378	{
		4379	if (!map)
		4380	return -1;
		4381	return isl_space_may_be_set(map->dim);
		4382	}
		4383
		4384	/* Is this map actually a set?
		4385	* Users should never call this function. Outside of isl,
		4386	* the type should indicate whether something is a set or a map.
		4387	*/
		4388	int isl_map_is_set(__isl_keep isl_map *map)
		4389	{
		4390	if (!map)
		4391	return -1;
		4392	return isl_space_is_set(map->dim);
		4393	}
		4394
		4395	struct isl_set *isl_map_range(struct isl_map *map)
		4396	{
		4397	int i;
		4398	struct isl_set *set;
		4399
		4400	if (!map)
		4401	goto error;
		4402	if (isl_map_is_set(map))
		4403	return (isl_set *)map;
		4404
		4405	map = isl_map_cow(map);
		4406	if (!map)
		4407	goto error;
		4408
		4409	set = (struct isl_set *) map;
		4410	set->dim = isl_space_range(set->dim);
		4411	if (!set->dim)
		4412	goto error;
		4413	for (i = 0; i < map->n; ++i) {
		4414	set->p[i] = isl_basic_map_range(map->p[i]);
		4415	if (!set->p[i])
		4416	goto error;
		4417	}
		4418	ISL_F_CLR(set, ISL_MAP_DISJOINT);
		4419	ISL_F_CLR(set, ISL_SET_NORMALIZED);
		4420	return set;
		4421	error:
		4422	isl_map_free(map);
		4423	return NULL;
		4424	}
		4425
		4426	__isl_give isl_map *isl_map_domain_map(__isl_take isl_map *map)
		4427	{
		4428	int i;
		4429	isl_space *domain_dim;
		4430
		4431	map = isl_map_cow(map);
		4432	if (!map)
		4433	return NULL;
		4434
		4435	domain_dim = isl_space_from_range(isl_space_domain(isl_map_get_space(map)));
		4436	map->dim = isl_space_from_domain(isl_space_wrap(map->dim));
		4437	map->dim = isl_space_join(map->dim, domain_dim);
		4438	if (!map->dim)
		4439	goto error;
		4440	for (i = 0; i < map->n; ++i) {
		4441	map->p[i] = isl_basic_map_domain_map(map->p[i]);
		4442	if (!map->p[i])
		4443	goto error;
		4444	}
		4445	ISL_F_CLR(map, ISL_MAP_DISJOINT);
		4446	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
		4447	return map;
		4448	error:
		4449	isl_map_free(map);
		4450	return NULL;
		4451	}
		4452
		4453	__isl_give isl_map *isl_map_range_map(__isl_take isl_map *map)
		4454	{
		4455	int i;
		4456	isl_space *range_dim;
		4457
		4458	map = isl_map_cow(map);
		4459	if (!map)
		4460	return NULL;
		4461
		4462	range_dim = isl_space_range(isl_map_get_space(map));
		4463	range_dim = isl_space_from_range(range_dim);
		4464	map->dim = isl_space_from_domain(isl_space_wrap(map->dim));
		4465	map->dim = isl_space_join(map->dim, range_dim);
		4466	if (!map->dim)
		4467	goto error;
		4468	for (i = 0; i < map->n; ++i) {
		4469	map->p[i] = isl_basic_map_range_map(map->p[i]);
		4470	if (!map->p[i])
		4471	goto error;
		4472	}
		4473	ISL_F_CLR(map, ISL_MAP_DISJOINT);
		4474	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
		4475	return map;
		4476	error:
		4477	isl_map_free(map);
		4478	return NULL;
		4479	}
		4480
		4481	__isl_give isl_map *isl_map_from_set(__isl_take isl_set *set,
		4482	__isl_take isl_space *dim)
		4483	{
		4484	int i;
		4485	struct isl_map *map = NULL;
		4486
		4487	set = isl_set_cow(set);
		4488	if (!set || !dim)
		4489	goto error;
		4490	isl_assert(set->ctx, isl_space_compatible(set->dim, dim), goto error);
		4491	map = (struct isl_map *)set;
		4492	for (i = 0; i < set->n; ++i) {
		4493	map->p[i] = isl_basic_map_from_basic_set(
		4494	set->p[i], isl_space_copy(dim));
		4495	if (!map->p[i])
		4496	goto error;
		4497	}
		4498	isl_space_free(map->dim);
		4499	map->dim = dim;
		4500	return map;
		4501	error:
		4502	isl_space_free(dim);
		4503	isl_set_free(set);
		4504	return NULL;
		4505	}
		4506
		4507	__isl_give isl_basic_map *isl_basic_map_from_domain(
		4508	__isl_take isl_basic_set *bset)
		4509	{
		4510	return isl_basic_map_reverse(isl_basic_map_from_range(bset));
		4511	}
		4512
		4513	__isl_give isl_basic_map *isl_basic_map_from_range(
		4514	__isl_take isl_basic_set *bset)
		4515	{
		4516	isl_space *space;
		4517	space = isl_basic_set_get_space(bset);
		4518	space = isl_space_from_range(space);
		4519	bset = isl_basic_set_reset_space(bset, space);
		4520	return (isl_basic_map *)bset;
		4521	}
		4522
		4523	struct isl_map *isl_map_from_range(struct isl_set *set)
		4524	{
		4525	isl_space *space;
		4526	space = isl_set_get_space(set);
		4527	space = isl_space_from_range(space);
		4528	set = isl_set_reset_space(set, space);
		4529	return (struct isl_map *)set;
		4530	}
		4531
		4532	__isl_give isl_map *isl_map_from_domain(__isl_take isl_set *set)
		4533	{
		4534	return isl_map_reverse(isl_map_from_range(set));
		4535	}
		4536
		4537	__isl_give isl_basic_map *isl_basic_map_from_domain_and_range(
		4538	__isl_take isl_basic_set *domain, __isl_take isl_basic_set *range)
		4539	{
		4540	return isl_basic_map_apply_range(isl_basic_map_reverse(domain), range);
		4541	}
		4542
		4543	__isl_give isl_map *isl_map_from_domain_and_range(__isl_take isl_set *domain,
		4544	__isl_take isl_set *range)
		4545	{
		4546	return isl_map_apply_range(isl_map_reverse(domain), range);
		4547	}
		4548
		4549	struct isl_set *isl_set_from_map(struct isl_map *map)
		4550	{
		4551	int i;
		4552	struct isl_set *set = NULL;
		4553
		4554	if (!map)
		4555	return NULL;
		4556	map = isl_map_cow(map);
		4557	if (!map)
		4558	return NULL;
		4559	map->dim = isl_space_as_set_space(map->dim);
		4560	if (!map->dim)
		4561	goto error;
		4562	set = (struct isl_set *)map;
		4563	for (i = 0; i < map->n; ++i) {
		4564	set->p[i] = isl_basic_set_from_basic_map(map->p[i]);
		4565	if (!set->p[i])
		4566	goto error;
		4567	}
		4568	return set;
		4569	error:
		4570	isl_map_free(map);
		4571	return NULL;
		4572	}
		4573
		4574	__isl_give isl_map *isl_map_alloc_space(__isl_take isl_space *dim, int n,
		4575	unsigned flags)
		4576	{
		4577	struct isl_map *map;
		4578
		4579	if (!dim)
		4580	return NULL;
		4581	if (n < 0)
		4582	isl_die(dim->ctx, isl_error_internal,
		4583	"negative number of basic maps", goto error);
		4584	map = isl_alloc(dim->ctx, struct isl_map,
		4585	sizeof(struct isl_map) +
		4586	(n - 1) * sizeof(struct isl_basic_map *));
		4587	if (!map)
		4588	goto error;
		4589
		4590	map->ctx = dim->ctx;
		4591	isl_ctx_ref(map->ctx);
		4592	map->ref = 1;
		4593	map->size = n;
		4594	map->n = 0;
		4595	map->dim = dim;
		4596	map->flags = flags;
		4597	return map;
		4598	error:
		4599	isl_space_free(dim);
		4600	return NULL;
		4601	}
		4602
		4603	struct isl_map *isl_map_alloc(struct isl_ctx *ctx,
		4604	unsigned nparam, unsigned in, unsigned out, int n,
		4605	unsigned flags)
		4606	{
		4607	struct isl_map *map;
		4608	isl_space *dims;
		4609
		4610	dims = isl_space_alloc(ctx, nparam, in, out);
		4611	if (!dims)
		4612	return NULL;
		4613
		4614	map = isl_map_alloc_space(dims, n, flags);
		4615	return map;
		4616	}
		4617
		4618	__isl_give isl_basic_map *isl_basic_map_empty(__isl_take isl_space *dim)
		4619	{
		4620	struct isl_basic_map *bmap;
		4621	bmap = isl_basic_map_alloc_space(dim, 0, 1, 0);
		4622	bmap = isl_basic_map_set_to_empty(bmap);
		4623	return bmap;
		4624	}
		4625
		4626	__isl_give isl_basic_set *isl_basic_set_empty(__isl_take isl_space *dim)
		4627	{
		4628	struct isl_basic_set *bset;
		4629	bset = isl_basic_set_alloc_space(dim, 0, 1, 0);
		4630	bset = isl_basic_set_set_to_empty(bset);
		4631	return bset;
		4632	}
		4633
		4634	struct isl_basic_map *isl_basic_map_empty_like(struct isl_basic_map *model)
		4635	{
		4636	struct isl_basic_map *bmap;
		4637	if (!model)
		4638	return NULL;
		4639	bmap = isl_basic_map_alloc_space(isl_space_copy(model->dim), 0, 1, 0);
		4640	bmap = isl_basic_map_set_to_empty(bmap);
		4641	return bmap;
		4642	}
		4643
		4644	struct isl_basic_map *isl_basic_map_empty_like_map(struct isl_map *model)
		4645	{
		4646	struct isl_basic_map *bmap;
		4647	if (!model)
		4648	return NULL;
		4649	bmap = isl_basic_map_alloc_space(isl_space_copy(model->dim), 0, 1, 0);
		4650	bmap = isl_basic_map_set_to_empty(bmap);
		4651	return bmap;
		4652	}
		4653
		4654	struct isl_basic_set *isl_basic_set_empty_like(struct isl_basic_set *model)
		4655	{
		4656	struct isl_basic_set *bset;
		4657	if (!model)
		4658	return NULL;
		4659	bset = isl_basic_set_alloc_space(isl_space_copy(model->dim), 0, 1, 0);
		4660	bset = isl_basic_set_set_to_empty(bset);
		4661	return bset;
		4662	}
		4663
		4664	__isl_give isl_basic_map *isl_basic_map_universe(__isl_take isl_space *dim)
		4665	{
		4666	struct isl_basic_map *bmap;
		4667	bmap = isl_basic_map_alloc_space(dim, 0, 0, 0);
		4668	bmap = isl_basic_map_finalize(bmap);
		4669	return bmap;
		4670	}
		4671
		4672	__isl_give isl_basic_set *isl_basic_set_universe(__isl_take isl_space *dim)
		4673	{
		4674	struct isl_basic_set *bset;
		4675	bset = isl_basic_set_alloc_space(dim, 0, 0, 0);
		4676	bset = isl_basic_set_finalize(bset);
		4677	return bset;
		4678	}
		4679
		4680	__isl_give isl_basic_map *isl_basic_map_nat_universe(__isl_take isl_space *dim)
		4681	{
		4682	int i;
		4683	unsigned total = isl_space_dim(dim, isl_dim_all);
		4684	isl_basic_map *bmap;
		4685
		4686	bmap= isl_basic_map_alloc_space(dim, 0, 0, total);
		4687	for (i = 0; i < total; ++i) {
		4688	int k = isl_basic_map_alloc_inequality(bmap);
		4689	if (k < 0)
		4690	goto error;
		4691	isl_seq_clr(bmap->ineq[k], 1 + total);
		4692	isl_int_set_si(bmap->ineq[k][1 + i], 1);
		4693	}
		4694	return bmap;
		4695	error:
		4696	isl_basic_map_free(bmap);
		4697	return NULL;
		4698	}
		4699
		4700	__isl_give isl_basic_set *isl_basic_set_nat_universe(__isl_take isl_space *dim)
		4701	{
		4702	return isl_basic_map_nat_universe(dim);
		4703	}
		4704
		4705	__isl_give isl_map *isl_map_nat_universe(__isl_take isl_space *dim)
		4706	{
		4707	return isl_map_from_basic_map(isl_basic_map_nat_universe(dim));
		4708	}
		4709
		4710	__isl_give isl_set *isl_set_nat_universe(__isl_take isl_space *dim)
		4711	{
		4712	return isl_map_nat_universe(dim);
		4713	}
		4714
		4715	__isl_give isl_basic_map *isl_basic_map_universe_like(
		4716	__isl_keep isl_basic_map *model)
		4717	{
		4718	if (!model)
		4719	return NULL;
		4720	return isl_basic_map_alloc_space(isl_space_copy(model->dim), 0, 0, 0);
		4721	}
		4722
		4723	struct isl_basic_set *isl_basic_set_universe_like(struct isl_basic_set *model)
		4724	{
		4725	if (!model)
		4726	return NULL;
		4727	return isl_basic_set_alloc_space(isl_space_copy(model->dim), 0, 0, 0);
		4728	}
		4729
		4730	__isl_give isl_basic_set *isl_basic_set_universe_like_set(
		4731	__isl_keep isl_set *model)
		4732	{
		4733	if (!model)
		4734	return NULL;
		4735	return isl_basic_set_alloc_space(isl_space_copy(model->dim), 0, 0, 0);
		4736	}
		4737
		4738	__isl_give isl_map *isl_map_empty(__isl_take isl_space *dim)
		4739	{
		4740	return isl_map_alloc_space(dim, 0, ISL_MAP_DISJOINT);
		4741	}
		4742
		4743	struct isl_map *isl_map_empty_like(struct isl_map *model)
		4744	{
		4745	if (!model)
		4746	return NULL;
		4747	return isl_map_alloc_space(isl_space_copy(model->dim), 0, ISL_MAP_DISJOINT);
		4748	}
		4749
		4750	struct isl_map *isl_map_empty_like_basic_map(struct isl_basic_map *model)
		4751	{
		4752	if (!model)
		4753	return NULL;
		4754	return isl_map_alloc_space(isl_space_copy(model->dim), 0, ISL_MAP_DISJOINT);
		4755	}
		4756
		4757	__isl_give isl_set *isl_set_empty(__isl_take isl_space *dim)
		4758	{
		4759	return isl_set_alloc_space(dim, 0, ISL_MAP_DISJOINT);
		4760	}
		4761
		4762	struct isl_set *isl_set_empty_like(struct isl_set *model)
		4763	{
		4764	if (!model)
		4765	return NULL;
		4766	return isl_set_empty(isl_space_copy(model->dim));
		4767	}
		4768
		4769	__isl_give isl_map *isl_map_universe(__isl_take isl_space *dim)
		4770	{
		4771	struct isl_map *map;
		4772	if (!dim)
		4773	return NULL;
		4774	map = isl_map_alloc_space(isl_space_copy(dim), 1, ISL_MAP_DISJOINT);
		4775	map = isl_map_add_basic_map(map, isl_basic_map_universe(dim));
		4776	return map;
		4777	}
		4778
		4779	__isl_give isl_set *isl_set_universe(__isl_take isl_space *dim)
		4780	{
		4781	struct isl_set *set;
		4782	if (!dim)
		4783	return NULL;
		4784	set = isl_set_alloc_space(isl_space_copy(dim), 1, ISL_MAP_DISJOINT);
		4785	set = isl_set_add_basic_set(set, isl_basic_set_universe(dim));
		4786	return set;
		4787	}
		4788
		4789	__isl_give isl_set *isl_set_universe_like(__isl_keep isl_set *model)
		4790	{
		4791	if (!model)
		4792	return NULL;
		4793	return isl_set_universe(isl_space_copy(model->dim));
		4794	}
		4795
		4796	struct isl_map *isl_map_dup(struct isl_map *map)
		4797	{
		4798	int i;
		4799	struct isl_map *dup;
		4800
		4801	if (!map)
		4802	return NULL;
		4803	dup = isl_map_alloc_space(isl_space_copy(map->dim), map->n, map->flags);
		4804	for (i = 0; i < map->n; ++i)
		4805	dup = isl_map_add_basic_map(dup, isl_basic_map_copy(map->p[i]));
		4806	return dup;
		4807	}
		4808
		4809	__isl_give isl_map *isl_map_add_basic_map(__isl_take isl_map *map,
		4810	__isl_take isl_basic_map *bmap)
		4811	{
		4812	if (!bmap || !map)
		4813	goto error;
		4814	if (isl_basic_map_plain_is_empty(bmap)) {
		4815	isl_basic_map_free(bmap);
		4816	return map;
		4817	}
		4818	isl_assert(map->ctx, isl_space_is_equal(map->dim, bmap->dim), goto error);
		4819	isl_assert(map->ctx, map->n < map->size, goto error);
		4820	map->p[map->n] = bmap;
		4821	map->n++;
		4822	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
		4823	return map;
		4824	error:
		4825	if (map)
		4826	isl_map_free(map);
		4827	if (bmap)
		4828	isl_basic_map_free(bmap);
		4829	return NULL;
		4830	}
		4831
		4832	void isl_map_free(struct isl_map *map)
		4833	{
		4834	int i;
		4835
		4836	if (!map)
		4837	return;
		4838
		4839	if (--map->ref > 0)
		4840	return;
		4841
		4842	isl_ctx_deref(map->ctx);
		4843	for (i = 0; i < map->n; ++i)
		4844	isl_basic_map_free(map->p[i]);
		4845	isl_space_free(map->dim);
		4846	free(map);
		4847	}
		4848
		4849	struct isl_map *isl_map_extend(struct isl_map *base,
		4850	unsigned nparam, unsigned n_in, unsigned n_out)
		4851	{
		4852	int i;
		4853
		4854	base = isl_map_cow(base);
		4855	if (!base)
		4856	return NULL;
		4857
		4858	base->dim = isl_space_extend(base->dim, nparam, n_in, n_out);
		4859	if (!base->dim)
		4860	goto error;
		4861	for (i = 0; i < base->n; ++i) {
		4862	base->p[i] = isl_basic_map_extend_space(base->p[i],
		4863	isl_space_copy(base->dim), 0, 0, 0);
		4864	if (!base->p[i])
		4865	goto error;
		4866	}
		4867	return base;
		4868	error:
		4869	isl_map_free(base);
		4870	return NULL;
		4871	}
		4872
		4873	struct isl_set *isl_set_extend(struct isl_set *base,
		4874	unsigned nparam, unsigned dim)
		4875	{
		4876	return (struct isl_set *)isl_map_extend((struct isl_map *)base,
		4877	nparam, 0, dim);
		4878	}
		4879
		4880	static struct isl_basic_map *isl_basic_map_fix_pos_si(
		4881	struct isl_basic_map *bmap, unsigned pos, int value)
		4882	{
		4883	int j;
		4884
		4885	bmap = isl_basic_map_cow(bmap);
		4886	bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
		4887	j = isl_basic_map_alloc_equality(bmap);
		4888	if (j < 0)
		4889	goto error;
		4890	isl_seq_clr(bmap->eq[j] + 1, isl_basic_map_total_dim(bmap));
		4891	isl_int_set_si(bmap->eq[j][pos], -1);
		4892	isl_int_set_si(bmap->eq[j][0], value);
		4893	bmap = isl_basic_map_simplify(bmap);
		4894	return isl_basic_map_finalize(bmap);
		4895	error:
		4896	isl_basic_map_free(bmap);
		4897	return NULL;
		4898	}
		4899
		4900	static __isl_give isl_basic_map *isl_basic_map_fix_pos(
		4901	__isl_take isl_basic_map *bmap, unsigned pos, isl_int value)
		4902	{
		4903	int j;
		4904
		4905	bmap = isl_basic_map_cow(bmap);
		4906	bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
		4907	j = isl_basic_map_alloc_equality(bmap);
		4908	if (j < 0)
		4909	goto error;
		4910	isl_seq_clr(bmap->eq[j] + 1, isl_basic_map_total_dim(bmap));
		4911	isl_int_set_si(bmap->eq[j][pos], -1);
		4912	isl_int_set(bmap->eq[j][0], value);
		4913	bmap = isl_basic_map_simplify(bmap);
		4914	return isl_basic_map_finalize(bmap);
		4915	error:
		4916	isl_basic_map_free(bmap);
		4917	return NULL;
		4918	}
		4919
		4920	struct isl_basic_map *isl_basic_map_fix_si(struct isl_basic_map *bmap,
		4921	enum isl_dim_type type, unsigned pos, int value)
		4922	{
		4923	if (!bmap)
		4924	return NULL;
		4925	isl_assert(bmap->ctx, pos < isl_basic_map_dim(bmap, type), goto error);
		4926	return isl_basic_map_fix_pos_si(bmap,
		4927	isl_basic_map_offset(bmap, type) + pos, value);
		4928	error:
		4929	isl_basic_map_free(bmap);
		4930	return NULL;
		4931	}
		4932
		4933	__isl_give isl_basic_map *isl_basic_map_fix(__isl_take isl_basic_map *bmap,
		4934	enum isl_dim_type type, unsigned pos, isl_int value)
		4935	{
		4936	if (!bmap)
		4937	return NULL;
		4938	isl_assert(bmap->ctx, pos < isl_basic_map_dim(bmap, type), goto error);
		4939	return isl_basic_map_fix_pos(bmap,
		4940	isl_basic_map_offset(bmap, type) + pos, value);
		4941	error:
		4942	isl_basic_map_free(bmap);
		4943	return NULL;
		4944	}
		4945
		4946	struct isl_basic_set *isl_basic_set_fix_si(struct isl_basic_set *bset,
		4947	enum isl_dim_type type, unsigned pos, int value)
		4948	{
		4949	return (struct isl_basic_set *)
		4950	isl_basic_map_fix_si((struct isl_basic_map *)bset,
		4951	type, pos, value);
		4952	}
		4953
		4954	__isl_give isl_basic_set *isl_basic_set_fix(__isl_take isl_basic_set *bset,
		4955	enum isl_dim_type type, unsigned pos, isl_int value)
		4956	{
		4957	return (struct isl_basic_set *)
		4958	isl_basic_map_fix((struct isl_basic_map *)bset,
		4959	type, pos, value);
		4960	}
		4961
		4962	struct isl_basic_map *isl_basic_map_fix_input_si(struct isl_basic_map *bmap,
		4963	unsigned input, int value)
		4964	{
		4965	return isl_basic_map_fix_si(bmap, isl_dim_in, input, value);
		4966	}
		4967
		4968	struct isl_basic_set *isl_basic_set_fix_dim_si(struct isl_basic_set *bset,
		4969	unsigned dim, int value)
		4970	{
		4971	return (struct isl_basic_set *)
		4972	isl_basic_map_fix_si((struct isl_basic_map *)bset,
		4973	isl_dim_set, dim, value);
		4974	}
		4975
		4976	static int remove_if_empty(__isl_keep isl_map *map, int i)
		4977	{
		4978	int empty = isl_basic_map_plain_is_empty(map->p[i]);
		4979
		4980	if (empty < 0)
		4981	return -1;
		4982	if (!empty)
		4983	return 0;
		4984
		4985	isl_basic_map_free(map->p[i]);
		4986	if (i != map->n - 1) {
		4987	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
		4988	map->p[i] = map->p[map->n - 1];
		4989	}
		4990	map->n--;
		4991
		4992	return 0;
		4993	}
		4994
		4995	struct isl_map *isl_map_fix_si(struct isl_map *map,
		4996	enum isl_dim_type type, unsigned pos, int value)
		4997	{
		4998	int i;
		4999
		5000	map = isl_map_cow(map);
		5001	if (!map)
		5002	return NULL;
		5003
		5004	isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error);
		5005	for (i = map->n - 1; i >= 0; --i) {
		5006	map->p[i] = isl_basic_map_fix_si(map->p[i], type, pos, value);
		5007	if (remove_if_empty(map, i) < 0)
		5008	goto error;
		5009	}
		5010	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
		5011	return map;
		5012	error:
		5013	isl_map_free(map);
		5014	return NULL;
		5015	}
		5016
		5017	__isl_give isl_set *isl_set_fix_si(__isl_take isl_set *set,
		5018	enum isl_dim_type type, unsigned pos, int value)
		5019	{
		5020	return (struct isl_set *)
		5021	isl_map_fix_si((struct isl_map *)set, type, pos, value);
		5022	}
		5023
		5024	__isl_give isl_map *isl_map_fix(__isl_take isl_map *map,
		5025	enum isl_dim_type type, unsigned pos, isl_int value)
		5026	{
		5027	int i;
		5028
		5029	map = isl_map_cow(map);
		5030	if (!map)
		5031	return NULL;
		5032
		5033	isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error);
		5034	for (i = 0; i < map->n; ++i) {
		5035	map->p[i] = isl_basic_map_fix(map->p[i], type, pos, value);
		5036	if (!map->p[i])
		5037	goto error;
		5038	}
		5039	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
		5040	return map;
		5041	error:
		5042	isl_map_free(map);
		5043	return NULL;
		5044	}
		5045
		5046	__isl_give isl_set *isl_set_fix(__isl_take isl_set *set,
		5047	enum isl_dim_type type, unsigned pos, isl_int value)
		5048	{
		5049	return (struct isl_set *)isl_map_fix((isl_map *)set, type, pos, value);
		5050	}
		5051
		5052	struct isl_map *isl_map_fix_input_si(struct isl_map *map,
		5053	unsigned input, int value)
		5054	{
		5055	return isl_map_fix_si(map, isl_dim_in, input, value);
		5056	}
		5057
		5058	struct isl_set *isl_set_fix_dim_si(struct isl_set *set, unsigned dim, int value)
		5059	{
		5060	return (struct isl_set *)
		5061	isl_map_fix_si((struct isl_map *)set, isl_dim_set, dim, value);
		5062	}
		5063
		5064	static __isl_give isl_basic_map *basic_map_bound_si(
		5065	__isl_take isl_basic_map *bmap,
		5066	enum isl_dim_type type, unsigned pos, int value, int upper)
		5067	{
		5068	int j;
		5069
		5070	if (!bmap)
		5071	return NULL;
		5072	isl_assert(bmap->ctx, pos < isl_basic_map_dim(bmap, type), goto error);
		5073	pos += isl_basic_map_offset(bmap, type);
		5074	bmap = isl_basic_map_cow(bmap);
		5075	bmap = isl_basic_map_extend_constraints(bmap, 0, 1);
		5076	j = isl_basic_map_alloc_inequality(bmap);
		5077	if (j < 0)
		5078	goto error;
		5079	isl_seq_clr(bmap->ineq[j], 1 + isl_basic_map_total_dim(bmap));
		5080	if (upper) {
		5081	isl_int_set_si(bmap->ineq[j][pos], -1);
		5082	isl_int_set_si(bmap->ineq[j][0], value);
		5083	} else {
		5084	isl_int_set_si(bmap->ineq[j][pos], 1);
		5085	isl_int_set_si(bmap->ineq[j][0], -value);
		5086	}
		5087	bmap = isl_basic_map_simplify(bmap);
		5088	return isl_basic_map_finalize(bmap);
		5089	error:
		5090	isl_basic_map_free(bmap);
		5091	return NULL;
		5092	}
		5093
		5094	__isl_give isl_basic_map *isl_basic_map_lower_bound_si(
		5095	__isl_take isl_basic_map *bmap,
		5096	enum isl_dim_type type, unsigned pos, int value)
		5097	{
		5098	return basic_map_bound_si(bmap, type, pos, value, 0);
		5099	}
		5100
		5101	struct isl_basic_set *isl_basic_set_lower_bound_dim(struct isl_basic_set *bset,
		5102	unsigned dim, isl_int value)
		5103	{
		5104	int j;
		5105
		5106	bset = isl_basic_set_cow(bset);
		5107	bset = isl_basic_set_extend_constraints(bset, 0, 1);
		5108	j = isl_basic_set_alloc_inequality(bset);
		5109	if (j < 0)
		5110	goto error;
		5111	isl_seq_clr(bset->ineq[j], 1 + isl_basic_set_total_dim(bset));
		5112	isl_int_set_si(bset->ineq[j][1 + isl_basic_set_n_param(bset) + dim], 1);
		5113	isl_int_neg(bset->ineq[j][0], value);
		5114	bset = isl_basic_set_simplify(bset);
		5115	return isl_basic_set_finalize(bset);
		5116	error:
		5117	isl_basic_set_free(bset);
		5118	return NULL;
		5119	}
		5120
		5121	static __isl_give isl_map *map_bound_si(__isl_take isl_map *map,
		5122	enum isl_dim_type type, unsigned pos, int value, int upper)
		5123	{
		5124	int i;
		5125
		5126	map = isl_map_cow(map);
		5127	if (!map)
		5128	return NULL;
		5129
		5130	isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error);
		5131	for (i = 0; i < map->n; ++i) {
		5132	map->p[i] = basic_map_bound_si(map->p[i],
		5133	type, pos, value, upper);
		5134	if (!map->p[i])
		5135	goto error;
		5136	}
		5137	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
		5138	return map;
		5139	error:
		5140	isl_map_free(map);
		5141	return NULL;
		5142	}
		5143
		5144	__isl_give isl_map *isl_map_lower_bound_si(__isl_take isl_map *map,
		5145	enum isl_dim_type type, unsigned pos, int value)
		5146	{
		5147	return map_bound_si(map, type, pos, value, 0);
		5148	}
		5149
		5150	__isl_give isl_map *isl_map_upper_bound_si(__isl_take isl_map *map,
		5151	enum isl_dim_type type, unsigned pos, int value)
		5152	{
		5153	return map_bound_si(map, type, pos, value, 1);
		5154	}
		5155
		5156	__isl_give isl_set *isl_set_lower_bound_si(__isl_take isl_set *set,
		5157	enum isl_dim_type type, unsigned pos, int value)
		5158	{
		5159	return (struct isl_set *)
		5160	isl_map_lower_bound_si((struct isl_map *)set, type, pos, value);
		5161	}
		5162
		5163	__isl_give isl_set *isl_set_upper_bound_si(__isl_take isl_set *set,
		5164	enum isl_dim_type type, unsigned pos, int value)
		5165	{
		5166	return isl_map_upper_bound_si(set, type, pos, value);
		5167	}
		5168
		5169	/* Bound the given variable of "bmap" from below (or above is "upper"
		5170	* is set) to "value".
		5171	*/
		5172	static __isl_give isl_basic_map *basic_map_bound(
		5173	__isl_take isl_basic_map *bmap,
		5174	enum isl_dim_type type, unsigned pos, isl_int value, int upper)
		5175	{
		5176	int j;
		5177
		5178	if (!bmap)
		5179	return NULL;
		5180	if (pos >= isl_basic_map_dim(bmap, type))
		5181	isl_die(bmap->ctx, isl_error_invalid,
		5182	"index out of bounds", goto error);
		5183	pos += isl_basic_map_offset(bmap, type);
		5184	bmap = isl_basic_map_cow(bmap);
		5185	bmap = isl_basic_map_extend_constraints(bmap, 0, 1);
		5186	j = isl_basic_map_alloc_inequality(bmap);
		5187	if (j < 0)
		5188	goto error;
		5189	isl_seq_clr(bmap->ineq[j], 1 + isl_basic_map_total_dim(bmap));
		5190	if (upper) {
		5191	isl_int_set_si(bmap->ineq[j][pos], -1);
		5192	isl_int_set(bmap->ineq[j][0], value);
		5193	} else {
		5194	isl_int_set_si(bmap->ineq[j][pos], 1);
		5195	isl_int_neg(bmap->ineq[j][0], value);
		5196	}
		5197	bmap = isl_basic_map_simplify(bmap);
		5198	return isl_basic_map_finalize(bmap);
		5199	error:
		5200	isl_basic_map_free(bmap);
		5201	return NULL;
		5202	}
		5203
		5204	/* Bound the given variable of "map" from below (or above is "upper"
		5205	* is set) to "value".
		5206	*/
		5207	static __isl_give isl_map *map_bound(__isl_take isl_map *map,
		5208	enum isl_dim_type type, unsigned pos, isl_int value, int upper)
		5209	{
		5210	int i;
		5211
		5212	map = isl_map_cow(map);
		5213	if (!map)
		5214	return NULL;
		5215
		5216	if (pos >= isl_map_dim(map, type))
		5217	isl_die(map->ctx, isl_error_invalid,
		5218	"index out of bounds", goto error);
		5219	for (i = map->n - 1; i >= 0; --i) {
		5220	map->p[i] = basic_map_bound(map->p[i], type, pos, value, upper);
		5221	if (remove_if_empty(map, i) < 0)
		5222	goto error;
		5223	}
		5224	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
		5225	return map;
		5226	error:
		5227	isl_map_free(map);
		5228	return NULL;
		5229	}
		5230
		5231	__isl_give isl_map *isl_map_lower_bound(__isl_take isl_map *map,
		5232	enum isl_dim_type type, unsigned pos, isl_int value)
		5233	{
		5234	return map_bound(map, type, pos, value, 0);
		5235	}
		5236
		5237	__isl_give isl_map *isl_map_upper_bound(__isl_take isl_map *map,
		5238	enum isl_dim_type type, unsigned pos, isl_int value)
		5239	{
		5240	return map_bound(map, type, pos, value, 1);
		5241	}
		5242
		5243	__isl_give isl_set *isl_set_lower_bound(__isl_take isl_set *set,
		5244	enum isl_dim_type type, unsigned pos, isl_int value)
		5245	{
		5246	return isl_map_lower_bound(set, type, pos, value);
		5247	}
		5248
		5249	__isl_give isl_set *isl_set_upper_bound(__isl_take isl_set *set,
		5250	enum isl_dim_type type, unsigned pos, isl_int value)
		5251	{
		5252	return isl_map_upper_bound(set, type, pos, value);
		5253	}
		5254
		5255	struct isl_set *isl_set_lower_bound_dim(struct isl_set *set, unsigned dim,
		5256	isl_int value)
		5257	{
		5258	int i;
		5259
		5260	set = isl_set_cow(set);
		5261	if (!set)
		5262	return NULL;
		5263
		5264	isl_assert(set->ctx, dim < isl_set_n_dim(set), goto error);
		5265	for (i = 0; i < set->n; ++i) {
		5266	set->p[i] = isl_basic_set_lower_bound_dim(set->p[i], dim, value);
		5267	if (!set->p[i])
		5268	goto error;
		5269	}
		5270	return set;
		5271	error:
		5272	isl_set_free(set);
		5273	return NULL;
		5274	}
		5275
		5276	struct isl_map *isl_map_reverse(struct isl_map *map)
		5277	{
		5278	int i;
		5279
		5280	map = isl_map_cow(map);
		5281	if (!map)
		5282	return NULL;
		5283
		5284	map->dim = isl_space_reverse(map->dim);
		5285	if (!map->dim)
		5286	goto error;
		5287	for (i = 0; i < map->n; ++i) {
		5288	map->p[i] = isl_basic_map_reverse(map->p[i]);
		5289	if (!map->p[i])
		5290	goto error;
		5291	}
		5292	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
		5293	return map;
		5294	error:
		5295	isl_map_free(map);
		5296	return NULL;
		5297	}
		5298
		5299	static struct isl_map *isl_basic_map_partial_lexopt(
		5300	struct isl_basic_map *bmap, struct isl_basic_set *dom,
		5301	struct isl_set **empty, int max)
		5302	{
		5303	if (!bmap)
		5304	goto error;
		5305	if (bmap->ctx->opt->pip == ISL_PIP_PIP)
		5306	return isl_pip_basic_map_lexopt(bmap, dom, empty, max);
		5307	else
		5308	return isl_tab_basic_map_partial_lexopt(bmap, dom, empty, max);
		5309	error:
		5310	isl_basic_map_free(bmap);
		5311	isl_basic_set_free(dom);
		5312	if (empty)
		5313	*empty = NULL;
		5314	return NULL;
		5315	}
		5316
		5317	struct isl_map *isl_basic_map_partial_lexmax(
		5318	struct isl_basic_map *bmap, struct isl_basic_set *dom,
		5319	struct isl_set **empty)
		5320	{
		5321	return isl_basic_map_partial_lexopt(bmap, dom, empty, 1);
		5322	}
		5323
		5324	struct isl_map *isl_basic_map_partial_lexmin(
		5325	struct isl_basic_map *bmap, struct isl_basic_set *dom,
		5326	struct isl_set **empty)
		5327	{
		5328	return isl_basic_map_partial_lexopt(bmap, dom, empty, 0);
		5329	}
		5330
		5331	struct isl_set *isl_basic_set_partial_lexmin(
		5332	struct isl_basic_set *bset, struct isl_basic_set *dom,
		5333	struct isl_set **empty)
		5334	{
		5335	return (struct isl_set *)
		5336	isl_basic_map_partial_lexmin((struct isl_basic_map *)bset,
		5337	dom, empty);
		5338	}
		5339
		5340	struct isl_set *isl_basic_set_partial_lexmax(
		5341	struct isl_basic_set *bset, struct isl_basic_set *dom,
		5342	struct isl_set **empty)
		5343	{
		5344	return (struct isl_set *)
		5345	isl_basic_map_partial_lexmax((struct isl_basic_map *)bset,
		5346	dom, empty);
		5347	}
		5348
		5349	__isl_give isl_pw_multi_aff *isl_basic_map_partial_lexmin_pw_multi_aff(
		5350	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
		5351	__isl_give isl_set **empty)
		5352	{
		5353	return isl_basic_map_partial_lexopt_pw_multi_aff(bmap, dom, empty, 0);
		5354	}
		5355
		5356	__isl_give isl_pw_multi_aff *isl_basic_map_partial_lexmax_pw_multi_aff(
		5357	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
		5358	__isl_give isl_set **empty)
		5359	{
		5360	return isl_basic_map_partial_lexopt_pw_multi_aff(bmap, dom, empty, 1);
		5361	}
		5362
		5363	__isl_give isl_pw_multi_aff *isl_basic_set_partial_lexmin_pw_multi_aff(
		5364	__isl_take isl_basic_set *bset, __isl_take isl_basic_set *dom,
		5365	__isl_give isl_set **empty)
		5366	{
		5367	return isl_basic_map_partial_lexmin_pw_multi_aff(bset, dom, empty);
		5368	}
		5369
		5370	__isl_give isl_pw_multi_aff *isl_basic_set_partial_lexmax_pw_multi_aff(
		5371	__isl_take isl_basic_set *bset, __isl_take isl_basic_set *dom,
		5372	__isl_give isl_set **empty)
		5373	{
		5374	return isl_basic_map_partial_lexmax_pw_multi_aff(bset, dom, empty);
		5375	}
		5376
		5377	__isl_give isl_pw_multi_aff *isl_basic_map_lexopt_pw_multi_aff(
		5378	__isl_take isl_basic_map *bmap, int max)
		5379	{
		5380	isl_basic_set *dom = NULL;
		5381	isl_space *dom_space;
		5382
		5383	if (!bmap)
		5384	goto error;
		5385	dom_space = isl_space_domain(isl_space_copy(bmap->dim));
		5386	dom = isl_basic_set_universe(dom_space);
		5387	return isl_basic_map_partial_lexopt_pw_multi_aff(bmap, dom, NULL, max);
		5388	error:
		5389	isl_basic_map_free(bmap);
		5390	return NULL;
		5391	}
		5392
		5393	__isl_give isl_pw_multi_aff *isl_basic_map_lexmin_pw_multi_aff(
		5394	__isl_take isl_basic_map *bmap)
		5395	{
		5396	return isl_basic_map_lexopt_pw_multi_aff(bmap, 0);
		5397	}
		5398
		5399	/* Given a basic map "bmap", compute the lexicographically minimal
		5400	* (or maximal) image element for each domain element in dom.
		5401	* Set *empty to those elements in dom that do not have an image element.
		5402	*
		5403	* We first make sure the basic sets in dom are disjoint and then
		5404	* simply collect the results over each of the basic sets separately.
		5405	* We could probably improve the efficiency a bit by moving the union
		5406	* domain down into the parametric integer programming.
		5407	*/
		5408	static __isl_give isl_map *basic_map_partial_lexopt(
		5409	__isl_take isl_basic_map *bmap, __isl_take isl_set *dom,
		5410	__isl_give isl_set **empty, int max)
		5411	{
		5412	int i;
		5413	struct isl_map *res;
		5414
		5415	dom = isl_set_make_disjoint(dom);
		5416	if (!dom)
		5417	goto error;
		5418
		5419	if (isl_set_plain_is_empty(dom)) {
		5420	res = isl_map_empty_like_basic_map(bmap);
		5421	*empty = isl_set_empty_like(dom);
		5422	isl_set_free(dom);
		5423	isl_basic_map_free(bmap);
		5424	return res;
		5425	}
		5426
		5427	res = isl_basic_map_partial_lexopt(isl_basic_map_copy(bmap),
		5428	isl_basic_set_copy(dom->p[0]), empty, max);
		5429
		5430	for (i = 1; i < dom->n; ++i) {
		5431	struct isl_map *res_i;
		5432	struct isl_set *empty_i;
		5433
		5434	res_i = isl_basic_map_partial_lexopt(isl_basic_map_copy(bmap),
		5435	isl_basic_set_copy(dom->p[i]), &empty_i, max);
		5436
		5437	res = isl_map_union_disjoint(res, res_i);
		5438	*empty = isl_set_union_disjoint(*empty, empty_i);
		5439	}
		5440
		5441	isl_set_free(dom);
		5442	isl_basic_map_free(bmap);
		5443	return res;
		5444	error:
		5445	*empty = NULL;
		5446	isl_set_free(dom);
		5447	isl_basic_map_free(bmap);
		5448	return NULL;
		5449	}
		5450
		5451	/* Given a map "map", compute the lexicographically minimal
		5452	* (or maximal) image element for each domain element in dom.
		5453	* Set *empty to those elements in dom that do not have an image element.
		5454	*
		5455	* We first compute the lexicographically minimal or maximal element
		5456	* in the first basic map. This results in a partial solution "res"
		5457	* and a subset "todo" of dom that still need to be handled.
		5458	* We then consider each of the remaining maps in "map" and successively
		5459	* improve both "res" and "todo".
		5460	*
		5461	* Let res^k and todo^k be the results after k steps and let i = k + 1.
		5462	* Assume we are computing the lexicographical maximum.
		5463	* We first compute the lexicographically maximal element in basic map i.
		5464	* This results in a partial solution res_i and a subset todo_i.
		5465	* Then we combine these results with those obtain for the first k basic maps
		5466	* to obtain a result that is valid for the first k+1 basic maps.
		5467	* In particular, the set where there is no solution is the set where
		5468	* there is no solution for the first k basic maps and also no solution
		5469	* for the ith basic map, i.e.,
		5470	*
		5471	* todo^i = todo^k * todo_i
		5472	*
		5473	* On dom(res^k) * dom(res_i), we need to pick the larger of the two
		5474	* solutions, arbitrarily breaking ties in favor of res^k.
		5475	* That is, when res^k(a) >= res_i(a), we pick res^k and
		5476	* when res^k(a) < res_i(a), we pick res_i. (Here, ">=" and "<" denote
		5477	* the lexicographic order.)
		5478	* In practice, we compute
		5479	*
		5480	* res^k * (res_i . "<=")
		5481	*
		5482	* and
		5483	*
		5484	* res_i * (res^k . "<")
		5485	*
		5486	* Finally, we consider the symmetric difference of dom(res^k) and dom(res_i),
		5487	* where only one of res^k and res_i provides a solution and we simply pick
		5488	* that one, i.e.,
		5489	*
		5490	* res^k * todo_i
		5491	* and
		5492	* res_i * todo^k
		5493	*
		5494	* Note that we only compute these intersections when dom(res^k) intersects
		5495	* dom(res_i). Otherwise, the only effect of these intersections is to
		5496	* potentially break up res^k and res_i into smaller pieces.
		5497	* We want to avoid such splintering as much as possible.
		5498	* In fact, an earlier implementation of this function would look for
		5499	* better results in the domain of res^k and for extra results in todo^k,
		5500	* but this would always result in a splintering according to todo^k,
		5501	* even when the domain of basic map i is disjoint from the domains of
		5502	* the previous basic maps.
		5503	*/
		5504	static __isl_give isl_map *isl_map_partial_lexopt_aligned(
		5505	__isl_take isl_map *map, __isl_take isl_set *dom,
		5506	__isl_give isl_set **empty, int max)
		5507	{
		5508	int i;
		5509	struct isl_map *res;
		5510	struct isl_set *todo;
		5511
		5512	if (!map || !dom)
		5513	goto error;
		5514
		5515	if (isl_map_plain_is_empty(map)) {
		5516	if (empty)
		5517	*empty = dom;
		5518	else
		5519	isl_set_free(dom);
		5520	return map;
		5521	}
		5522
		5523	res = basic_map_partial_lexopt(isl_basic_map_copy(map->p[0]),
		5524	isl_set_copy(dom), &todo, max);
		5525
		5526	for (i = 1; i < map->n; ++i) {
		5527	isl_map *lt, *le;
		5528	isl_map *res_i;
		5529	isl_set *todo_i;
		5530	isl_space *dim = isl_space_range(isl_map_get_space(res));
		5531
		5532	res_i = basic_map_partial_lexopt(isl_basic_map_copy(map->p[i]),
		5533	isl_set_copy(dom), &todo_i, max);
		5534
		5535	if (max) {
		5536	lt = isl_map_lex_lt(isl_space_copy(dim));
		5537	le = isl_map_lex_le(dim);
		5538	} else {
		5539	lt = isl_map_lex_gt(isl_space_copy(dim));
		5540	le = isl_map_lex_ge(dim);
		5541	}
		5542	lt = isl_map_apply_range(isl_map_copy(res), lt);
		5543	lt = isl_map_intersect(lt, isl_map_copy(res_i));
		5544	le = isl_map_apply_range(isl_map_copy(res_i), le);
		5545	le = isl_map_intersect(le, isl_map_copy(res));
		5546
		5547	if (!isl_map_is_empty(lt) || !isl_map_is_empty(le)) {
		5548	res = isl_map_intersect_domain(res,
		5549	isl_set_copy(todo_i));
		5550	res_i = isl_map_intersect_domain(res_i,
		5551	isl_set_copy(todo));
		5552	}
		5553
		5554	res = isl_map_union_disjoint(res, res_i);
		5555	res = isl_map_union_disjoint(res, lt);
		5556	res = isl_map_union_disjoint(res, le);
		5557
		5558	todo = isl_set_intersect(todo, todo_i);
		5559	}
		5560
		5561	isl_set_free(dom);
		5562	isl_map_free(map);
		5563
		5564	if (empty)
		5565	*empty = todo;
		5566	else
		5567	isl_set_free(todo);
		5568
		5569	return res;
		5570	error:
		5571	if (empty)
		5572	*empty = NULL;
		5573	isl_set_free(dom);
		5574	isl_map_free(map);
		5575	return NULL;
		5576	}
		5577
		5578	/* Given a map "map", compute the lexicographically minimal
		5579	* (or maximal) image element for each domain element in dom.
		5580	* Set *empty to those elements in dom that do not have an image element.
		5581	*
		5582	* Align parameters if needed and then call isl_map_partial_lexopt_aligned.
		5583	*/
		5584	static __isl_give isl_map *isl_map_partial_lexopt(
		5585	__isl_take isl_map *map, __isl_take isl_set *dom,
		5586	__isl_give isl_set **empty, int max)
		5587	{
		5588	if (!map || !dom)
		5589	goto error;
		5590	if (isl_space_match(map->dim, isl_dim_param, dom->dim, isl_dim_param))
		5591	return isl_map_partial_lexopt_aligned(map, dom, empty, max);
		5592	if (!isl_space_has_named_params(map->dim) ||
		5593	!isl_space_has_named_params(dom->dim))
		5594	isl_die(map->ctx, isl_error_invalid,
		5595	"unaligned unnamed parameters", goto error);
		5596	map = isl_map_align_params(map, isl_map_get_space(dom));
		5597	dom = isl_map_align_params(dom, isl_map_get_space(map));
		5598	return isl_map_partial_lexopt_aligned(map, dom, empty, max);
		5599	error:
		5600	if (empty)
		5601	*empty = NULL;
		5602	isl_set_free(dom);
		5603	isl_map_free(map);
		5604	return NULL;
		5605	}
		5606
		5607	__isl_give isl_map *isl_map_partial_lexmax(
		5608	__isl_take isl_map *map, __isl_take isl_set *dom,
		5609	__isl_give isl_set **empty)
		5610	{
		5611	return isl_map_partial_lexopt(map, dom, empty, 1);
		5612	}
		5613
		5614	__isl_give isl_map *isl_map_partial_lexmin(
		5615	__isl_take isl_map *map, __isl_take isl_set *dom,
		5616	__isl_give isl_set **empty)
		5617	{
		5618	return isl_map_partial_lexopt(map, dom, empty, 0);
		5619	}
		5620
		5621	__isl_give isl_set *isl_set_partial_lexmin(
		5622	__isl_take isl_set *set, __isl_take isl_set *dom,
		5623	__isl_give isl_set **empty)
		5624	{
		5625	return (struct isl_set *)
		5626	isl_map_partial_lexmin((struct isl_map *)set,
		5627	dom, empty);
		5628	}
		5629
		5630	__isl_give isl_set *isl_set_partial_lexmax(
		5631	__isl_take isl_set *set, __isl_take isl_set *dom,
		5632	__isl_give isl_set **empty)
		5633	{
		5634	return (struct isl_set *)
		5635	isl_map_partial_lexmax((struct isl_map *)set,
		5636	dom, empty);
		5637	}
		5638
		5639	__isl_give isl_map *isl_basic_map_lexopt(__isl_take isl_basic_map *bmap, int max)
		5640	{
		5641	struct isl_basic_set *dom = NULL;
		5642	isl_space *dom_dim;
		5643
		5644	if (!bmap)
		5645	goto error;
		5646	dom_dim = isl_space_domain(isl_space_copy(bmap->dim));
		5647	dom = isl_basic_set_universe(dom_dim);
		5648	return isl_basic_map_partial_lexopt(bmap, dom, NULL, max);
		5649	error:
		5650	isl_basic_map_free(bmap);
		5651	return NULL;
		5652	}
		5653
		5654	__isl_give isl_map *isl_basic_map_lexmin(__isl_take isl_basic_map *bmap)
		5655	{
		5656	return isl_basic_map_lexopt(bmap, 0);
		5657	}
		5658
		5659	__isl_give isl_map *isl_basic_map_lexmax(__isl_take isl_basic_map *bmap)
		5660	{
		5661	return isl_basic_map_lexopt(bmap, 1);
		5662	}
		5663
		5664	__isl_give isl_set *isl_basic_set_lexmin(__isl_take isl_basic_set *bset)
		5665	{
		5666	return (isl_set *)isl_basic_map_lexmin((isl_basic_map *)bset);
		5667	}
		5668
		5669	__isl_give isl_set *isl_basic_set_lexmax(__isl_take isl_basic_set *bset)
		5670	{
		5671	return (isl_set *)isl_basic_map_lexmax((isl_basic_map *)bset);
		5672	}
		5673
		5674	__isl_give isl_map *isl_map_lexopt(__isl_take isl_map *map, int max)
		5675	{
		5676	struct isl_set *dom = NULL;
		5677	isl_space *dom_dim;
		5678
		5679	if (!map)
		5680	goto error;
		5681	dom_dim = isl_space_domain(isl_space_copy(map->dim));
		5682	dom = isl_set_universe(dom_dim);
		5683	return isl_map_partial_lexopt(map, dom, NULL, max);
		5684	error:
		5685	isl_map_free(map);
		5686	return NULL;
		5687	}
		5688
		5689	__isl_give isl_map *isl_map_lexmin(__isl_take isl_map *map)
		5690	{
		5691	return isl_map_lexopt(map, 0);
		5692	}
		5693
		5694	__isl_give isl_map *isl_map_lexmax(__isl_take isl_map *map)
		5695	{
		5696	return isl_map_lexopt(map, 1);
		5697	}
		5698
		5699	__isl_give isl_set *isl_set_lexmin(__isl_take isl_set *set)
		5700	{
		5701	return (isl_set *)isl_map_lexmin((isl_map *)set);
		5702	}
		5703
		5704	__isl_give isl_set *isl_set_lexmax(__isl_take isl_set *set)
		5705	{
		5706	return (isl_set *)isl_map_lexmax((isl_map *)set);
		5707	}
		5708
		5709	/* Extract the first and only affine expression from list
		5710	* and then add it to *pwaff with the given dom.
		5711	* This domain is known to be disjoint from other domains
		5712	* because of the way isl_basic_map_foreach_lexmax works.
		5713	*/
		5714	static int update_dim_opt(__isl_take isl_basic_set *dom,
		5715	__isl_take isl_aff_list *list, void *user)
		5716	{
		5717	isl_ctx *ctx = isl_basic_set_get_ctx(dom);
		5718	isl_aff *aff;
		5719	isl_pw_aff **pwaff = user;
		5720	isl_pw_aff *pwaff_i;
		5721
		5722	if (isl_aff_list_n_aff(list) != 1)
		5723	isl_die(ctx, isl_error_internal,
		5724	"expecting single element list", goto error);
		5725
		5726	aff = isl_aff_list_get_aff(list, 0);
		5727	pwaff_i = isl_pw_aff_alloc(isl_set_from_basic_set(dom), aff);
		5728
		5729	*pwaff = isl_pw_aff_add_disjoint(*pwaff, pwaff_i);
		5730
		5731	isl_aff_list_free(list);
		5732
		5733	return 0;
		5734	error:
		5735	isl_basic_set_free(dom);
		5736	isl_aff_list_free(list);
		5737	return -1;
		5738	}
		5739
		5740	/* Given a basic map with one output dimension, compute the minimum or
		5741	* maximum of that dimension as an isl_pw_aff.
		5742	*
		5743	* The isl_pw_aff is constructed by having isl_basic_map_foreach_lexopt
		5744	* call update_dim_opt on each leaf of the result.
		5745	*/
		5746	static __isl_give isl_pw_aff *basic_map_dim_opt(__isl_keep isl_basic_map *bmap,
		5747	int max)
		5748	{
		5749	isl_space *dim = isl_basic_map_get_space(bmap);
		5750	isl_pw_aff *pwaff;
		5751	int r;
		5752
		5753	dim = isl_space_from_domain(isl_space_domain(dim));
		5754	dim = isl_space_add_dims(dim, isl_dim_out, 1);
		5755	pwaff = isl_pw_aff_empty(dim);
		5756
		5757	r = isl_basic_map_foreach_lexopt(bmap, max, &update_dim_opt, &pwaff);
		5758	if (r < 0)
		5759	return isl_pw_aff_free(pwaff);
		5760
		5761	return pwaff;
		5762	}
		5763
		5764	/* Compute the minimum or maximum of the given output dimension
		5765	* as a function of the parameters and the input dimensions,
		5766	* but independently of the other output dimensions.
		5767	*
		5768	* We first project out the other output dimension and then compute
		5769	* the "lexicographic" maximum in each basic map, combining the results
		5770	* using isl_pw_aff_union_max.
		5771	*/
		5772	static __isl_give isl_pw_aff *map_dim_opt(__isl_take isl_map *map, int pos,
		5773	int max)
		5774	{
		5775	int i;
		5776	isl_pw_aff *pwaff;
		5777	unsigned n_out;
		5778
		5779	n_out = isl_map_dim(map, isl_dim_out);
		5780	map = isl_map_project_out(map, isl_dim_out, pos + 1, n_out - (pos + 1));
		5781	map = isl_map_project_out(map, isl_dim_out, 0, pos);
		5782	if (!map)
		5783	return NULL;
		5784
		5785	if (map->n == 0) {
		5786	isl_space *dim = isl_map_get_space(map);
		5787	dim = isl_space_domain(isl_space_from_range(dim));
		5788	isl_map_free(map);
		5789	return isl_pw_aff_empty(dim);
		5790	}
		5791
		5792	pwaff = basic_map_dim_opt(map->p[0], max);
		5793	for (i = 1; i < map->n; ++i) {
		5794	isl_pw_aff *pwaff_i;
		5795
		5796	pwaff_i = basic_map_dim_opt(map->p[i], max);
		5797	pwaff = isl_pw_aff_union_opt(pwaff, pwaff_i, max);
		5798	}
		5799
		5800	isl_map_free(map);
		5801
		5802	return pwaff;
		5803	}
		5804
		5805	/* Compute the maximum of the given output dimension as a function of the
		5806	* parameters and input dimensions, but independently of
		5807	* the other output dimensions.
		5808	*/
		5809	__isl_give isl_pw_aff *isl_map_dim_max(__isl_take isl_map *map, int pos)
		5810	{
		5811	return map_dim_opt(map, pos, 1);
		5812	}
		5813
		5814	/* Compute the minimum or maximum of the given set dimension
		5815	* as a function of the parameters,
		5816	* but independently of the other set dimensions.
		5817	*/
		5818	static __isl_give isl_pw_aff *set_dim_opt(__isl_take isl_set *set, int pos,
		5819	int max)
		5820	{
		5821	return map_dim_opt(set, pos, max);
		5822	}
		5823
		5824	/* Compute the maximum of the given set dimension as a function of the
		5825	* parameters, but independently of the other set dimensions.
		5826	*/
		5827	__isl_give isl_pw_aff *isl_set_dim_max(__isl_take isl_set *set, int pos)
		5828	{
		5829	return set_dim_opt(set, pos, 1);
		5830	}
		5831
		5832	/* Compute the minimum of the given set dimension as a function of the
		5833	* parameters, but independently of the other set dimensions.
		5834	*/
		5835	__isl_give isl_pw_aff *isl_set_dim_min(__isl_take isl_set *set, int pos)
		5836	{
		5837	return set_dim_opt(set, pos, 0);
		5838	}
		5839
		5840	/* Apply a preimage specified by "mat" on the parameters of "bset".
		5841	* bset is assumed to have only parameters and divs.
		5842	*/
		5843	static struct isl_basic_set *basic_set_parameter_preimage(
		5844	struct isl_basic_set *bset, struct isl_mat *mat)
		5845	{
		5846	unsigned nparam;
		5847
		5848	if (!bset || !mat)
		5849	goto error;
		5850
		5851	bset->dim = isl_space_cow(bset->dim);
		5852	if (!bset->dim)
		5853	goto error;
		5854
		5855	nparam = isl_basic_set_dim(bset, isl_dim_param);
		5856
		5857	isl_assert(bset->ctx, mat->n_row == 1 + nparam, goto error);
		5858
		5859	bset->dim->nparam = 0;
		5860	bset->dim->n_out = nparam;
		5861	bset = isl_basic_set_preimage(bset, mat);
		5862	if (bset) {
		5863	bset->dim->nparam = bset->dim->n_out;
		5864	bset->dim->n_out = 0;
		5865	}
		5866	return bset;
		5867	error:
		5868	isl_mat_free(mat);
		5869	isl_basic_set_free(bset);
		5870	return NULL;
		5871	}
		5872
		5873	/* Apply a preimage specified by "mat" on the parameters of "set".
		5874	* set is assumed to have only parameters and divs.
		5875	*/
		5876	static struct isl_set *set_parameter_preimage(
		5877	struct isl_set *set, struct isl_mat *mat)
		5878	{
		5879	isl_space *dim = NULL;
		5880	unsigned nparam;
		5881
		5882	if (!set || !mat)
		5883	goto error;
		5884
		5885	dim = isl_space_copy(set->dim);
		5886	dim = isl_space_cow(dim);
		5887	if (!dim)
		5888	goto error;
		5889
		5890	nparam = isl_set_dim(set, isl_dim_param);
		5891
		5892	isl_assert(set->ctx, mat->n_row == 1 + nparam, goto error);
		5893
		5894	dim->nparam = 0;
		5895	dim->n_out = nparam;
		5896	isl_set_reset_space(set, dim);
		5897	set = isl_set_preimage(set, mat);
		5898	if (!set)
		5899	goto error2;
		5900	dim = isl_space_copy(set->dim);
		5901	dim = isl_space_cow(dim);
		5902	if (!dim)
		5903	goto error2;
		5904	dim->nparam = dim->n_out;
		5905	dim->n_out = 0;
		5906	isl_set_reset_space(set, dim);
		5907	return set;
		5908	error:
		5909	isl_space_free(dim);
		5910	isl_mat_free(mat);
		5911	error2:
		5912	isl_set_free(set);
		5913	return NULL;
		5914	}
		5915
		5916	/* Intersect the basic set "bset" with the affine space specified by the
		5917	* equalities in "eq".
		5918	*/
		5919	static struct isl_basic_set *basic_set_append_equalities(
		5920	struct isl_basic_set *bset, struct isl_mat *eq)
		5921	{
		5922	int i, k;
		5923	unsigned len;
		5924
		5925	if (!bset || !eq)
		5926	goto error;
		5927
		5928	bset = isl_basic_set_extend_space(bset, isl_space_copy(bset->dim), 0,
		5929	eq->n_row, 0);
		5930	if (!bset)
		5931	goto error;
		5932
		5933	len = 1 + isl_space_dim(bset->dim, isl_dim_all) + bset->extra;
		5934	for (i = 0; i < eq->n_row; ++i) {
		5935	k = isl_basic_set_alloc_equality(bset);
		5936	if (k < 0)
		5937	goto error;
		5938	isl_seq_cpy(bset->eq[k], eq->row[i], eq->n_col);
		5939	isl_seq_clr(bset->eq[k] + eq->n_col, len - eq->n_col);
		5940	}
		5941	isl_mat_free(eq);
		5942
		5943	bset = isl_basic_set_gauss(bset, NULL);
		5944	bset = isl_basic_set_finalize(bset);
		5945
		5946	return bset;
		5947	error:
		5948	isl_mat_free(eq);
		5949	isl_basic_set_free(bset);
		5950	return NULL;
		5951	}
		5952
		5953	/* Intersect the set "set" with the affine space specified by the
		5954	* equalities in "eq".
		5955	*/
		5956	static struct isl_set *set_append_equalities(struct isl_set *set,
		5957	struct isl_mat *eq)
		5958	{
		5959	int i;
		5960
		5961	if (!set || !eq)
		5962	goto error;
		5963
		5964	for (i = 0; i < set->n; ++i) {
		5965	set->p[i] = basic_set_append_equalities(set->p[i],
		5966	isl_mat_copy(eq));
		5967	if (!set->p[i])
		5968	goto error;
		5969	}
		5970	isl_mat_free(eq);
		5971	return set;
		5972	error:
		5973	isl_mat_free(eq);
		5974	isl_set_free(set);
		5975	return NULL;
		5976	}
		5977
		5978	/* Project the given basic set onto its parameter domain, possibly introducing
		5979	* new, explicit, existential variables in the constraints.
		5980	* The input has parameters and (possibly implicit) existential variables.
		5981	* The output has the same parameters, but only
		5982	* explicit existentially quantified variables.
		5983	*
		5984	* The actual projection is performed by pip, but pip doesn't seem
		5985	* to like equalities very much, so we first remove the equalities
		5986	* among the parameters by performing a variable compression on
		5987	* the parameters. Afterward, an inverse transformation is performed
		5988	* and the equalities among the parameters are inserted back in.
		5989	*/
		5990	static struct isl_set *parameter_compute_divs(struct isl_basic_set *bset)
		5991	{
		5992	int i, j;
		5993	struct isl_mat *eq;
		5994	struct isl_mat *T, *T2;
		5995	struct isl_set *set;
		5996	unsigned nparam, n_div;
		5997
		5998	bset = isl_basic_set_cow(bset);
		5999	if (!bset)
		6000	return NULL;
		6001
		6002	if (bset->n_eq == 0)
		6003	return isl_basic_set_lexmin(bset);
		6004
		6005	isl_basic_set_gauss(bset, NULL);
		6006
		6007	nparam = isl_basic_set_dim(bset, isl_dim_param);
		6008	n_div = isl_basic_set_dim(bset, isl_dim_div);
		6009
		6010	for (i = 0, j = n_div - 1; i < bset->n_eq && j >= 0; --j) {
		6011	if (!isl_int_is_zero(bset->eq[i][1 + nparam + j]))
		6012	++i;
		6013	}
		6014	if (i == bset->n_eq)
		6015	return isl_basic_set_lexmin(bset);
		6016
		6017	eq = isl_mat_sub_alloc6(bset->ctx, bset->eq, i, bset->n_eq - i,
		6018	0, 1 + nparam);
		6019	eq = isl_mat_cow(eq);
		6020	T = isl_mat_variable_compression(isl_mat_copy(eq), &T2);
		6021	if (T && T->n_col == 0) {
		6022	isl_mat_free(T);
		6023	isl_mat_free(T2);
		6024	isl_mat_free(eq);
		6025	bset = isl_basic_set_set_to_empty(bset);
		6026	return isl_set_from_basic_set(bset);
		6027	}
		6028	bset = basic_set_parameter_preimage(bset, T);
		6029
		6030	set = isl_basic_set_lexmin(bset);
		6031	set = set_parameter_preimage(set, T2);
		6032	set = set_append_equalities(set, eq);
		6033	return set;
		6034	}
		6035
		6036	/* Compute an explicit representation for all the existentially
		6037	* quantified variables.
		6038	* The input and output dimensions are first turned into parameters.
		6039	* compute_divs then returns a map with the same parameters and
		6040	* no input or output dimensions and the dimension specification
		6041	* is reset to that of the input.
		6042	*/
		6043	static struct isl_map *compute_divs(struct isl_basic_map *bmap)
		6044	{
		6045	struct isl_basic_set *bset;
		6046	struct isl_set *set;
		6047	struct isl_map *map;
		6048	isl_space *dim, *orig_dim = NULL;
		6049	unsigned nparam;
		6050	unsigned n_in;
		6051	unsigned n_out;
		6052
		6053	bmap = isl_basic_map_cow(bmap);
		6054	if (!bmap)
		6055	return NULL;
		6056
		6057	nparam = isl_basic_map_dim(bmap, isl_dim_param);
		6058	n_in = isl_basic_map_dim(bmap, isl_dim_in);
		6059	n_out = isl_basic_map_dim(bmap, isl_dim_out);
		6060	dim = isl_space_set_alloc(bmap->ctx, nparam + n_in + n_out, 0);
		6061	if (!dim)
		6062	goto error;
		6063
		6064	orig_dim = bmap->dim;
		6065	bmap->dim = dim;
		6066	bset = (struct isl_basic_set *)bmap;
		6067
		6068	set = parameter_compute_divs(bset);
		6069	map = (struct isl_map *)set;
		6070	map = isl_map_reset_space(map, orig_dim);
		6071
		6072	return map;
		6073	error:
		6074	isl_basic_map_free(bmap);
		6075	return NULL;
		6076	}
		6077
		6078	int isl_basic_map_divs_known(__isl_keep isl_basic_map *bmap)
		6079	{
		6080	int i;
		6081	unsigned off;
		6082
		6083	if (!bmap)
		6084	return -1;
		6085
		6086	off = isl_space_dim(bmap->dim, isl_dim_all);
		6087	for (i = 0; i < bmap->n_div; ++i) {
		6088	if (isl_int_is_zero(bmap->div[i][0]))
		6089	return 0;
		6090	isl_assert(bmap->ctx, isl_int_is_zero(bmap->div[i][1+1+off+i]),
		6091	return -1);
		6092	}
		6093	return 1;
		6094	}
		6095
		6096	static int map_divs_known(__isl_keep isl_map *map)
		6097	{
		6098	int i;
		6099
		6100	if (!map)
		6101	return -1;
		6102
		6103	for (i = 0; i < map->n; ++i) {
		6104	int known = isl_basic_map_divs_known(map->p[i]);
		6105	if (known <= 0)
		6106	return known;
		6107	}
		6108
		6109	return 1;
		6110	}
		6111
		6112	/* If bmap contains any unknown divs, then compute explicit
		6113	* expressions for them. However, this computation may be
		6114	* quite expensive, so first try to remove divs that aren't
		6115	* strictly needed.
		6116	*/
		6117	struct isl_map *isl_basic_map_compute_divs(struct isl_basic_map *bmap)
		6118	{
		6119	int known;
		6120	struct isl_map *map;
		6121
		6122	known = isl_basic_map_divs_known(bmap);
		6123	if (known < 0)
		6124	goto error;
		6125	if (known)
		6126	return isl_map_from_basic_map(bmap);
		6127
		6128	bmap = isl_basic_map_drop_redundant_divs(bmap);
		6129
		6130	known = isl_basic_map_divs_known(bmap);
		6131	if (known < 0)
		6132	goto error;
		6133	if (known)
		6134	return isl_map_from_basic_map(bmap);
		6135
		6136	map = compute_divs(bmap);
		6137	return map;
		6138	error:
		6139	isl_basic_map_free(bmap);
		6140	return NULL;
		6141	}
		6142
		6143	struct isl_map *isl_map_compute_divs(struct isl_map *map)
		6144	{
		6145	int i;
		6146	int known;
		6147	struct isl_map *res;
		6148
		6149	if (!map)
		6150	return NULL;
		6151	if (map->n == 0)
		6152	return map;
		6153
		6154	known = map_divs_known(map);
		6155	if (known < 0) {
		6156	isl_map_free(map);
		6157	return NULL;
		6158	}
		6159	if (known)
		6160	return map;
		6161
		6162	res = isl_basic_map_compute_divs(isl_basic_map_copy(map->p[0]));
		6163	for (i = 1 ; i < map->n; ++i) {
		6164	struct isl_map *r2;
		6165	r2 = isl_basic_map_compute_divs(isl_basic_map_copy(map->p[i]));
		6166	if (ISL_F_ISSET(map, ISL_MAP_DISJOINT))
		6167	res = isl_map_union_disjoint(res, r2);
		6168	else
		6169	res = isl_map_union(res, r2);
		6170	}
		6171	isl_map_free(map);
		6172
		6173	return res;
		6174	}
		6175
		6176	struct isl_set *isl_basic_set_compute_divs(struct isl_basic_set *bset)
		6177	{
		6178	return (struct isl_set *)
		6179	isl_basic_map_compute_divs((struct isl_basic_map *)bset);
		6180	}
		6181
		6182	struct isl_set *isl_set_compute_divs(struct isl_set *set)
		6183	{
		6184	return (struct isl_set *)
		6185	isl_map_compute_divs((struct isl_map *)set);
		6186	}
		6187
		6188	struct isl_set *isl_map_domain(struct isl_map *map)
		6189	{
		6190	int i;
		6191	struct isl_set *set;
		6192
		6193	if (!map)
		6194	goto error;
		6195
		6196	map = isl_map_cow(map);
		6197	if (!map)
		6198	return NULL;
		6199
		6200	set = (struct isl_set *)map;
		6201	set->dim = isl_space_domain(set->dim);
		6202	if (!set->dim)
		6203	goto error;
		6204	for (i = 0; i < map->n; ++i) {
		6205	set->p[i] = isl_basic_map_domain(map->p[i]);
		6206	if (!set->p[i])
		6207	goto error;
		6208	}
		6209	ISL_F_CLR(set, ISL_MAP_DISJOINT);
		6210	ISL_F_CLR(set, ISL_SET_NORMALIZED);
		6211	return set;
		6212	error:
		6213	isl_map_free(map);
		6214	return NULL;
		6215	}
		6216
		6217	static __isl_give isl_map *map_union_disjoint(__isl_take isl_map *map1,
		6218	__isl_take isl_map *map2)
		6219	{
		6220	int i;
		6221	unsigned flags = 0;
		6222	struct isl_map *map = NULL;
		6223
		6224	if (!map1 || !map2)
		6225	goto error;
		6226
		6227	if (map1->n == 0) {
		6228	isl_map_free(map1);
		6229	return map2;
		6230	}
		6231	if (map2->n == 0) {
		6232	isl_map_free(map2);
		6233	return map1;
		6234	}
		6235
		6236	isl_assert(map1->ctx, isl_space_is_equal(map1->dim, map2->dim), goto error);
		6237
		6238	if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) &&
		6239	ISL_F_ISSET(map2, ISL_MAP_DISJOINT))
		6240	ISL_FL_SET(flags, ISL_MAP_DISJOINT);
		6241
		6242	map = isl_map_alloc_space(isl_space_copy(map1->dim),
		6243	map1->n + map2->n, flags);
		6244	if (!map)
		6245	goto error;
		6246	for (i = 0; i < map1->n; ++i) {
		6247	map = isl_map_add_basic_map(map,
		6248	isl_basic_map_copy(map1->p[i]));
		6249	if (!map)
		6250	goto error;
		6251	}
		6252	for (i = 0; i < map2->n; ++i) {
		6253	map = isl_map_add_basic_map(map,
		6254	isl_basic_map_copy(map2->p[i]));
		6255	if (!map)
		6256	goto error;
		6257	}
		6258	isl_map_free(map1);
		6259	isl_map_free(map2);
		6260	return map;
		6261	error:
		6262	isl_map_free(map);
		6263	isl_map_free(map1);
		6264	isl_map_free(map2);
		6265	return NULL;
		6266	}
		6267
		6268	__isl_give isl_map *isl_map_union_disjoint(__isl_take isl_map *map1,
		6269	__isl_take isl_map *map2)
		6270	{
		6271	return isl_map_align_params_map_map_and(map1, map2, &map_union_disjoint);
		6272	}
		6273
		6274	struct isl_map *isl_map_union(struct isl_map *map1, struct isl_map *map2)
		6275	{
		6276	map1 = isl_map_union_disjoint(map1, map2);
		6277	if (!map1)
		6278	return NULL;
		6279	if (map1->n > 1)
		6280	ISL_F_CLR(map1, ISL_MAP_DISJOINT);
		6281	return map1;
		6282	}
		6283
		6284	struct isl_set *isl_set_union_disjoint(
		6285	struct isl_set *set1, struct isl_set *set2)
		6286	{
		6287	return (struct isl_set *)
		6288	isl_map_union_disjoint(
		6289	(struct isl_map *)set1, (struct isl_map *)set2);
		6290	}
		6291
		6292	struct isl_set *isl_set_union(struct isl_set *set1, struct isl_set *set2)
		6293	{
		6294	return (struct isl_set *)
		6295	isl_map_union((struct isl_map *)set1, (struct isl_map *)set2);
		6296	}
		6297
		6298	static __isl_give isl_map *map_intersect_range(__isl_take isl_map *map,
		6299	__isl_take isl_set *set)
		6300	{
		6301	unsigned flags = 0;
		6302	struct isl_map *result;
		6303	int i, j;
		6304
		6305	if (!map || !set)
		6306	goto error;
		6307
		6308	if (!isl_space_match(map->dim, isl_dim_param, set->dim, isl_dim_param))
		6309	isl_die(set->ctx, isl_error_invalid,
		6310	"parameters don't match", goto error);
		6311
		6312	if (isl_space_dim(set->dim, isl_dim_set) != 0 &&
		6313	!isl_map_compatible_range(map, set))
		6314	isl_die(set->ctx, isl_error_invalid,
		6315	"incompatible spaces", goto error);
		6316
		6317	if (isl_set_plain_is_universe(set)) {
		6318	isl_set_free(set);
		6319	return map;
		6320	}
		6321
		6322	if (ISL_F_ISSET(map, ISL_MAP_DISJOINT) &&
		6323	ISL_F_ISSET(set, ISL_MAP_DISJOINT))
		6324	ISL_FL_SET(flags, ISL_MAP_DISJOINT);
		6325
		6326	result = isl_map_alloc_space(isl_space_copy(map->dim),
		6327	map->n * set->n, flags);
		6328	if (!result)
		6329	goto error;
		6330	for (i = 0; i < map->n; ++i)
		6331	for (j = 0; j < set->n; ++j) {
		6332	result = isl_map_add_basic_map(result,
		6333	isl_basic_map_intersect_range(
		6334	isl_basic_map_copy(map->p[i]),
		6335	isl_basic_set_copy(set->p[j])));
		6336	if (!result)
		6337	goto error;
		6338	}
		6339	isl_map_free(map);
		6340	isl_set_free(set);
		6341	return result;
		6342	error:
		6343	isl_map_free(map);
		6344	isl_set_free(set);
		6345	return NULL;
		6346	}
		6347
		6348	__isl_give isl_map *isl_map_intersect_range(__isl_take isl_map *map,
		6349	__isl_take isl_set *set)
		6350	{
		6351	return isl_map_align_params_map_map_and(map, set, &map_intersect_range);
		6352	}
		6353
		6354	struct isl_map *isl_map_intersect_domain(
		6355	struct isl_map *map, struct isl_set *set)
		6356	{
		6357	return isl_map_reverse(
		6358	isl_map_intersect_range(isl_map_reverse(map), set));
		6359	}
		6360
		6361	static __isl_give isl_map *map_apply_domain(__isl_take isl_map *map1,
		6362	__isl_take isl_map *map2)
		6363	{
		6364	if (!map1 || !map2)
		6365	goto error;
		6366	map1 = isl_map_reverse(map1);
		6367	map1 = isl_map_apply_range(map1, map2);
		6368	return isl_map_reverse(map1);
		6369	error:
		6370	isl_map_free(map1);
		6371	isl_map_free(map2);
		6372	return NULL;
		6373	}
		6374
		6375	__isl_give isl_map *isl_map_apply_domain(__isl_take isl_map *map1,
		6376	__isl_take isl_map *map2)
		6377	{
		6378	return isl_map_align_params_map_map_and(map1, map2, &map_apply_domain);
		6379	}
		6380
		6381	static __isl_give isl_map *map_apply_range(__isl_take isl_map *map1,
		6382	__isl_take isl_map *map2)
		6383	{
		6384	isl_space *dim_result;
		6385	struct isl_map *result;
		6386	int i, j;
		6387
		6388	if (!map1 || !map2)
		6389	goto error;
		6390
		6391	dim_result = isl_space_join(isl_space_copy(map1->dim),
		6392	isl_space_copy(map2->dim));
		6393
		6394	result = isl_map_alloc_space(dim_result, map1->n * map2->n, 0);
		6395	if (!result)
		6396	goto error;
		6397	for (i = 0; i < map1->n; ++i)
		6398	for (j = 0; j < map2->n; ++j) {
		6399	result = isl_map_add_basic_map(result,
		6400	isl_basic_map_apply_range(
		6401	isl_basic_map_copy(map1->p[i]),
		6402	isl_basic_map_copy(map2->p[j])));
		6403	if (!result)
		6404	goto error;
		6405	}
		6406	isl_map_free(map1);
		6407	isl_map_free(map2);
		6408	if (result && result->n <= 1)
		6409	ISL_F_SET(result, ISL_MAP_DISJOINT);
		6410	return result;
		6411	error:
		6412	isl_map_free(map1);
		6413	isl_map_free(map2);
		6414	return NULL;
		6415	}
		6416
		6417	__isl_give isl_map *isl_map_apply_range(__isl_take isl_map *map1,
		6418	__isl_take isl_map *map2)
		6419	{
		6420	return isl_map_align_params_map_map_and(map1, map2, &map_apply_range);
		6421	}
		6422
		6423	/*
		6424	* returns range - domain
		6425	*/
		6426	struct isl_basic_set *isl_basic_map_deltas(struct isl_basic_map *bmap)
		6427	{
		6428	isl_space *dims, *target_dim;
		6429	struct isl_basic_set *bset;
		6430	unsigned dim;
		6431	unsigned nparam;
		6432	int i;
		6433
		6434	if (!bmap)
		6435	goto error;
		6436	isl_assert(bmap->ctx, isl_space_tuple_match(bmap->dim, isl_dim_in,
		6437	bmap->dim, isl_dim_out),
		6438	goto error);
		6439	target_dim = isl_space_domain(isl_basic_map_get_space(bmap));
		6440	dim = isl_basic_map_n_in(bmap);
		6441	nparam = isl_basic_map_n_param(bmap);
		6442	bset = isl_basic_set_from_basic_map(bmap);
		6443	bset = isl_basic_set_cow(bset);
		6444	dims = isl_basic_set_get_space(bset);
		6445	dims = isl_space_add_dims(dims, isl_dim_set, dim);
		6446	bset = isl_basic_set_extend_space(bset, dims, 0, dim, 0);
		6447	bset = isl_basic_set_swap_vars(bset, 2*dim);
		6448	for (i = 0; i < dim; ++i) {
		6449	int j = isl_basic_map_alloc_equality(
		6450	(struct isl_basic_map *)bset);
		6451	if (j < 0)
		6452	goto error;
		6453	isl_seq_clr(bset->eq[j], 1 + isl_basic_set_total_dim(bset));
		6454	isl_int_set_si(bset->eq[j][1+nparam+i], 1);
		6455	isl_int_set_si(bset->eq[j][1+nparam+dim+i], 1);
		6456	isl_int_set_si(bset->eq[j][1+nparam+2*dim+i], -1);
		6457	}
		6458	bset = isl_basic_set_project_out(bset, isl_dim_set, dim, 2*dim);
		6459	bset = isl_basic_set_reset_space(bset, target_dim);
		6460	return bset;
		6461	error:
		6462	isl_basic_map_free(bmap);
		6463	return NULL;
		6464	}
		6465
		6466	/*
		6467	* returns range - domain
		6468	*/
		6469	__isl_give isl_set *isl_map_deltas(__isl_take isl_map *map)
		6470	{
		6471	int i;
		6472	isl_space *dim;
		6473	struct isl_set *result;
		6474
		6475	if (!map)
		6476	return NULL;
		6477
		6478	isl_assert(map->ctx, isl_space_tuple_match(map->dim, isl_dim_in,
		6479	map->dim, isl_dim_out),
		6480	goto error);
		6481	dim = isl_map_get_space(map);
		6482	dim = isl_space_domain(dim);
		6483	result = isl_set_alloc_space(dim, map->n, 0);
		6484	if (!result)
		6485	goto error;
		6486	for (i = 0; i < map->n; ++i)
		6487	result = isl_set_add_basic_set(result,
		6488	isl_basic_map_deltas(isl_basic_map_copy(map->p[i])));
		6489	isl_map_free(map);
		6490	return result;
		6491	error:
		6492	isl_map_free(map);
		6493	return NULL;
		6494	}
		6495
		6496	/*
		6497	* returns [domain -> range] -> range - domain
		6498	*/
		6499	__isl_give isl_basic_map *isl_basic_map_deltas_map(
		6500	__isl_take isl_basic_map *bmap)
		6501	{
		6502	int i, k;
		6503	isl_space *dim;
		6504	isl_basic_map *domain;
		6505	int nparam, n;
		6506	unsigned total;
		6507
		6508	if (!isl_space_tuple_match(bmap->dim, isl_dim_in, bmap->dim, isl_dim_out))
		6509	isl_die(bmap->ctx, isl_error_invalid,
		6510	"domain and range don't match", goto error);
		6511
		6512	nparam = isl_basic_map_dim(bmap, isl_dim_param);
		6513	n = isl_basic_map_dim(bmap, isl_dim_in);
		6514
		6515	dim = isl_space_from_range(isl_space_domain(isl_basic_map_get_space(bmap)));
		6516	domain = isl_basic_map_universe(dim);
		6517
		6518	bmap = isl_basic_map_from_domain(isl_basic_map_wrap(bmap));
		6519	bmap = isl_basic_map_apply_range(bmap, domain);
		6520	bmap = isl_basic_map_extend_constraints(bmap, n, 0);
		6521
		6522	total = isl_basic_map_total_dim(bmap);
		6523
		6524	for (i = 0; i < n; ++i) {
		6525	k = isl_basic_map_alloc_equality(bmap);
		6526	if (k < 0)
		6527	goto error;
		6528	isl_seq_clr(bmap->eq[k], 1 + total);
		6529	isl_int_set_si(bmap->eq[k][1 + nparam + i], 1);
		6530	isl_int_set_si(bmap->eq[k][1 + nparam + n + i], -1);
		6531	isl_int_set_si(bmap->eq[k][1 + nparam + n + n + i], 1);
		6532	}
		6533
		6534	bmap = isl_basic_map_gauss(bmap, NULL);
		6535	return isl_basic_map_finalize(bmap);
		6536	error:
		6537	isl_basic_map_free(bmap);
		6538	return NULL;
		6539	}
		6540
		6541	/*
		6542	* returns [domain -> range] -> range - domain
		6543	*/
		6544	__isl_give isl_map *isl_map_deltas_map(__isl_take isl_map *map)
		6545	{
		6546	int i;
		6547	isl_space *domain_dim;
		6548
		6549	if (!map)
		6550	return NULL;
		6551
		6552	if (!isl_space_tuple_match(map->dim, isl_dim_in, map->dim, isl_dim_out))
		6553	isl_die(map->ctx, isl_error_invalid,
		6554	"domain and range don't match", goto error);
		6555
		6556	map = isl_map_cow(map);
		6557	if (!map)
		6558	return NULL;
		6559
		6560	domain_dim = isl_space_from_range(isl_space_domain(isl_map_get_space(map)));
		6561	map->dim = isl_space_from_domain(isl_space_wrap(map->dim));
		6562	map->dim = isl_space_join(map->dim, domain_dim);
		6563	if (!map->dim)
		6564	goto error;
		6565	for (i = 0; i < map->n; ++i) {
		6566	map->p[i] = isl_basic_map_deltas_map(map->p[i]);
		6567	if (!map->p[i])
		6568	goto error;
		6569	}
		6570	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
		6571	return map;
		6572	error:
		6573	isl_map_free(map);
		6574	return NULL;
		6575	}
		6576
		6577	__isl_give struct isl_basic_map *basic_map_identity(__isl_take isl_space *dims)
		6578	{
		6579	struct isl_basic_map *bmap;
		6580	unsigned nparam;
		6581	unsigned dim;
		6582	int i;
		6583
		6584	if (!dims)
		6585	return NULL;
		6586
		6587	nparam = dims->nparam;
		6588	dim = dims->n_out;
		6589	bmap = isl_basic_map_alloc_space(dims, 0, dim, 0);
		6590	if (!bmap)
		6591	goto error;
		6592
		6593	for (i = 0; i < dim; ++i) {
		6594	int j = isl_basic_map_alloc_equality(bmap);
		6595	if (j < 0)
		6596	goto error;
		6597	isl_seq_clr(bmap->eq[j], 1 + isl_basic_map_total_dim(bmap));
		6598	isl_int_set_si(bmap->eq[j][1+nparam+i], 1);
		6599	isl_int_set_si(bmap->eq[j][1+nparam+dim+i], -1);
		6600	}
		6601	return isl_basic_map_finalize(bmap);
		6602	error:
		6603	isl_basic_map_free(bmap);
		6604	return NULL;
		6605	}
		6606
		6607	__isl_give isl_basic_map *isl_basic_map_identity(__isl_take isl_space *dim)
		6608	{
		6609	if (!dim)
		6610	return NULL;
		6611	if (dim->n_in != dim->n_out)
		6612	isl_die(dim->ctx, isl_error_invalid,
		6613	"number of input and output dimensions needs to be "
		6614	"the same", goto error);
		6615	return basic_map_identity(dim);
		6616	error:
		6617	isl_space_free(dim);
		6618	return NULL;
		6619	}
		6620
		6621	struct isl_basic_map *isl_basic_map_identity_like(struct isl_basic_map *model)
		6622	{
		6623	if (!model || !model->dim)
		6624	return NULL;
		6625	return isl_basic_map_identity(isl_space_copy(model->dim));
		6626	}
		6627
		6628	__isl_give isl_map *isl_map_identity(__isl_take isl_space *dim)
		6629	{
		6630	return isl_map_from_basic_map(isl_basic_map_identity(dim));
		6631	}
		6632
		6633	struct isl_map *isl_map_identity_like(struct isl_map *model)
		6634	{
		6635	if (!model || !model->dim)
		6636	return NULL;
		6637	return isl_map_identity(isl_space_copy(model->dim));
		6638	}
		6639
		6640	struct isl_map *isl_map_identity_like_basic_map(struct isl_basic_map *model)
		6641	{
		6642	if (!model || !model->dim)
		6643	return NULL;
		6644	return isl_map_identity(isl_space_copy(model->dim));
		6645	}
		6646
		6647	__isl_give isl_map *isl_set_identity(__isl_take isl_set *set)
		6648	{
		6649	isl_space *dim = isl_set_get_space(set);
		6650	isl_map *id;
		6651	id = isl_map_identity(isl_space_map_from_set(dim));
		6652	return isl_map_intersect_range(id, set);
		6653	}
		6654
		6655	/* Construct a basic set with all set dimensions having only non-negative
		6656	* values.
		6657	*/
		6658	__isl_give isl_basic_set *isl_basic_set_positive_orthant(
		6659	__isl_take isl_space *space)
		6660	{
		6661	int i;
		6662	unsigned nparam;
		6663	unsigned dim;
		6664	struct isl_basic_set *bset;
		6665
		6666	if (!space)
		6667	return NULL;
		6668	nparam = space->nparam;
		6669	dim = space->n_out;
		6670	bset = isl_basic_set_alloc_space(space, 0, 0, dim);
		6671	if (!bset)
		6672	return NULL;
		6673	for (i = 0; i < dim; ++i) {
		6674	int k = isl_basic_set_alloc_inequality(bset);
		6675	if (k < 0)
		6676	goto error;
		6677	isl_seq_clr(bset->ineq[k], 1 + isl_basic_set_total_dim(bset));
		6678	isl_int_set_si(bset->ineq[k][1 + nparam + i], 1);
		6679	}
		6680	return bset;
		6681	error:
		6682	isl_basic_set_free(bset);
		6683	return NULL;
		6684	}
		6685
		6686	/* Construct the half-space x_pos >= 0.
		6687	*/
		6688	static __isl_give isl_basic_set *nonneg_halfspace(__isl_take isl_space *dim,
		6689	int pos)
		6690	{
		6691	int k;
		6692	isl_basic_set *nonneg;
		6693
		6694	nonneg = isl_basic_set_alloc_space(dim, 0, 0, 1);
		6695	k = isl_basic_set_alloc_inequality(nonneg);
		6696	if (k < 0)
		6697	goto error;
		6698	isl_seq_clr(nonneg->ineq[k], 1 + isl_basic_set_total_dim(nonneg));
		6699	isl_int_set_si(nonneg->ineq[k][pos], 1);
		6700
		6701	return isl_basic_set_finalize(nonneg);
		6702	error:
		6703	isl_basic_set_free(nonneg);
		6704	return NULL;
		6705	}
		6706
		6707	/* Construct the half-space x_pos <= -1.
		6708	*/
		6709	static __isl_give isl_basic_set *neg_halfspace(__isl_take isl_space *dim, int pos)
		6710	{
		6711	int k;
		6712	isl_basic_set *neg;
		6713
		6714	neg = isl_basic_set_alloc_space(dim, 0, 0, 1);
		6715	k = isl_basic_set_alloc_inequality(neg);
		6716	if (k < 0)
		6717	goto error;
		6718	isl_seq_clr(neg->ineq[k], 1 + isl_basic_set_total_dim(neg));
		6719	isl_int_set_si(neg->ineq[k][0], -1);
		6720	isl_int_set_si(neg->ineq[k][pos], -1);
		6721
		6722	return isl_basic_set_finalize(neg);
		6723	error:
		6724	isl_basic_set_free(neg);
		6725	return NULL;
		6726	}
		6727
		6728	__isl_give isl_set *isl_set_split_dims(__isl_take isl_set *set,
		6729	enum isl_dim_type type, unsigned first, unsigned n)
		6730	{
		6731	int i;
		6732	isl_basic_set *nonneg;
		6733	isl_basic_set *neg;
		6734
		6735	if (!set)
		6736	return NULL;
		6737	if (n == 0)
		6738	return set;
		6739
		6740	isl_assert(set->ctx, first + n <= isl_set_dim(set, type), goto error);
		6741
		6742	for (i = 0; i < n; ++i) {
		6743	nonneg = nonneg_halfspace(isl_set_get_space(set),
		6744	pos(set->dim, type) + first + i);
		6745	neg = neg_halfspace(isl_set_get_space(set),
		6746	pos(set->dim, type) + first + i);
		6747
		6748	set = isl_set_intersect(set, isl_basic_set_union(nonneg, neg));
		6749	}
		6750
		6751	return set;
		6752	error:
		6753	isl_set_free(set);
		6754	return NULL;
		6755	}
		6756
		6757	static int foreach_orthant(__isl_take isl_set *set, int *signs, int first,
		6758	int len, int (*fn)(__isl_take isl_set *orthant, int *signs, void *user),
		6759	void *user)
		6760	{
		6761	isl_set *half;
		6762
		6763	if (!set)
		6764	return -1;
		6765	if (isl_set_plain_is_empty(set)) {
		6766	isl_set_free(set);
		6767	return 0;
		6768	}
		6769	if (first == len)
		6770	return fn(set, signs, user);
		6771
		6772	signs[first] = 1;
		6773	half = isl_set_from_basic_set(nonneg_halfspace(isl_set_get_space(set),
		6774	1 + first));
		6775	half = isl_set_intersect(half, isl_set_copy(set));
		6776	if (foreach_orthant(half, signs, first + 1, len, fn, user) < 0)
		6777	goto error;
		6778
		6779	signs[first] = -1;
		6780	half = isl_set_from_basic_set(neg_halfspace(isl_set_get_space(set),
		6781	1 + first));
		6782	half = isl_set_intersect(half, set);
		6783	return foreach_orthant(half, signs, first + 1, len, fn, user);
		6784	error:
		6785	isl_set_free(set);
		6786	return -1;
		6787	}
		6788
		6789	/* Call "fn" on the intersections of "set" with each of the orthants
		6790	* (except for obviously empty intersections). The orthant is identified
		6791	* by the signs array, with each entry having value 1 or -1 according
		6792	* to the sign of the corresponding variable.
		6793	*/
		6794	int isl_set_foreach_orthant(__isl_keep isl_set *set,
		6795	int (*fn)(__isl_take isl_set *orthant, int *signs, void *user),
		6796	void *user)
		6797	{
		6798	unsigned nparam;
		6799	unsigned nvar;
		6800	int *signs;
		6801	int r;
		6802
		6803	if (!set)
		6804	return -1;
		6805	if (isl_set_plain_is_empty(set))
		6806	return 0;
		6807
		6808	nparam = isl_set_dim(set, isl_dim_param);
		6809	nvar = isl_set_dim(set, isl_dim_set);
		6810
		6811	signs = isl_alloc_array(set->ctx, int, nparam + nvar);
		6812
		6813	r = foreach_orthant(isl_set_copy(set), signs, 0, nparam + nvar,
		6814	fn, user);
		6815
		6816	free(signs);
		6817
		6818	return r;
		6819	}
		6820
		6821	int isl_set_is_equal(struct isl_set *set1, struct isl_set *set2)
		6822	{
		6823	return isl_map_is_equal((struct isl_map *)set1, (struct isl_map *)set2);
		6824	}
		6825
		6826	int isl_basic_map_is_subset(
		6827	struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
		6828	{
		6829	int is_subset;
		6830	struct isl_map *map1;
		6831	struct isl_map *map2;
		6832
		6833	if (!bmap1 || !bmap2)
		6834	return -1;
		6835
		6836	map1 = isl_map_from_basic_map(isl_basic_map_copy(bmap1));
		6837	map2 = isl_map_from_basic_map(isl_basic_map_copy(bmap2));
		6838
		6839	is_subset = isl_map_is_subset(map1, map2);
		6840
		6841	isl_map_free(map1);
		6842	isl_map_free(map2);
		6843
		6844	return is_subset;
		6845	}
		6846
		6847	int isl_basic_set_is_subset(__isl_keep isl_basic_set *bset1,
		6848	__isl_keep isl_basic_set *bset2)
		6849	{
		6850	return isl_basic_map_is_subset(bset1, bset2);
		6851	}
		6852
		6853	int isl_basic_map_is_equal(
		6854	struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
		6855	{
		6856	int is_subset;
		6857
		6858	if (!bmap1 || !bmap2)
		6859	return -1;
		6860	is_subset = isl_basic_map_is_subset(bmap1, bmap2);
		6861	if (is_subset != 1)
		6862	return is_subset;
		6863	is_subset = isl_basic_map_is_subset(bmap2, bmap1);
		6864	return is_subset;
		6865	}
		6866
		6867	int isl_basic_set_is_equal(
		6868	struct isl_basic_set *bset1, struct isl_basic_set *bset2)
		6869	{
		6870	return isl_basic_map_is_equal(
		6871	(struct isl_basic_map *)bset1, (struct isl_basic_map *)bset2);
		6872	}
		6873
		6874	int isl_map_is_empty(struct isl_map *map)
		6875	{
		6876	int i;
		6877	int is_empty;
		6878
		6879	if (!map)
		6880	return -1;
		6881	for (i = 0; i < map->n; ++i) {
		6882	is_empty = isl_basic_map_is_empty(map->p[i]);
		6883	if (is_empty < 0)
		6884	return -1;
		6885	if (!is_empty)
		6886	return 0;
		6887	}
		6888	return 1;
		6889	}
		6890
		6891	int isl_map_plain_is_empty(__isl_keep isl_map *map)
		6892	{
		6893	return map ? map->n == 0 : -1;
		6894	}
		6895
		6896	int isl_map_fast_is_empty(__isl_keep isl_map *map)
		6897	{
		6898	return isl_map_plain_is_empty(map);
		6899	}
		6900
		6901	int isl_set_plain_is_empty(struct isl_set *set)
		6902	{
		6903	return set ? set->n == 0 : -1;
		6904	}
		6905
		6906	int isl_set_fast_is_empty(__isl_keep isl_set *set)
		6907	{
		6908	return isl_set_plain_is_empty(set);
		6909	}
		6910
		6911	int isl_set_is_empty(struct isl_set *set)
		6912	{
		6913	return isl_map_is_empty((struct isl_map *)set);
		6914	}
		6915
		6916	int isl_map_has_equal_space(__isl_keep isl_map *map1, __isl_keep isl_map *map2)
		6917	{
		6918	if (!map1 || !map2)
		6919	return -1;
		6920
		6921	return isl_space_is_equal(map1->dim, map2->dim);
		6922	}
		6923
		6924	int isl_set_has_equal_space(__isl_keep isl_set *set1, __isl_keep isl_set *set2)
		6925	{
		6926	if (!set1 || !set2)
		6927	return -1;
		6928
		6929	return isl_space_is_equal(set1->dim, set2->dim);
		6930	}
		6931
		6932	static int map_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2)
		6933	{
		6934	int is_subset;
		6935
		6936	if (!map1 || !map2)
		6937	return -1;
		6938	is_subset = isl_map_is_subset(map1, map2);
		6939	if (is_subset != 1)
		6940	return is_subset;
		6941	is_subset = isl_map_is_subset(map2, map1);
		6942	return is_subset;
		6943	}
		6944
		6945	int isl_map_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2)
		6946	{
		6947	return isl_map_align_params_map_map_and_test(map1, map2, &map_is_equal);
		6948	}
		6949
		6950	int isl_basic_map_is_strict_subset(
		6951	struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
		6952	{
		6953	int is_subset;
		6954
		6955	if (!bmap1 || !bmap2)
		6956	return -1;
		6957	is_subset = isl_basic_map_is_subset(bmap1, bmap2);
		6958	if (is_subset != 1)
		6959	return is_subset;
		6960	is_subset = isl_basic_map_is_subset(bmap2, bmap1);
		6961	if (is_subset == -1)
		6962	return is_subset;
		6963	return !is_subset;
		6964	}
		6965
		6966	int isl_map_is_strict_subset(struct isl_map *map1, struct isl_map *map2)
		6967	{
		6968	int is_subset;
		6969
		6970	if (!map1 || !map2)
		6971	return -1;
		6972	is_subset = isl_map_is_subset(map1, map2);
		6973	if (is_subset != 1)
		6974	return is_subset;
		6975	is_subset = isl_map_is_subset(map2, map1);
		6976	if (is_subset == -1)
		6977	return is_subset;
		6978	return !is_subset;
		6979	}
		6980
		6981	int isl_set_is_strict_subset(__isl_keep isl_set *set1, __isl_keep isl_set *set2)
		6982	{
		6983	return isl_map_is_strict_subset((isl_map *)set1, (isl_map *)set2);
		6984	}
		6985
		6986	int isl_basic_map_is_universe(struct isl_basic_map *bmap)
		6987	{
		6988	if (!bmap)
		6989	return -1;
		6990	return bmap->n_eq == 0 && bmap->n_ineq == 0;
		6991	}
		6992
		6993	int isl_basic_set_is_universe(struct isl_basic_set *bset)
		6994	{
		6995	if (!bset)
		6996	return -1;
		6997	return bset->n_eq == 0 && bset->n_ineq == 0;
		6998	}
		6999
		7000	int isl_map_plain_is_universe(__isl_keep isl_map *map)
		7001	{
		7002	int i;
		7003
		7004	if (!map)
		7005	return -1;
		7006
		7007	for (i = 0; i < map->n; ++i) {
		7008	int r = isl_basic_map_is_universe(map->p[i]);
		7009	if (r < 0 || r)
		7010	return r;
		7011	}
		7012
		7013	return 0;
		7014	}
		7015
		7016	int isl_set_plain_is_universe(__isl_keep isl_set *set)
		7017	{
		7018	return isl_map_plain_is_universe((isl_map *) set);
		7019	}
		7020
		7021	int isl_set_fast_is_universe(__isl_keep isl_set *set)
		7022	{
		7023	return isl_set_plain_is_universe(set);
		7024	}
		7025
		7026	int isl_basic_map_is_empty(struct isl_basic_map *bmap)
		7027	{
		7028	struct isl_basic_set *bset = NULL;
		7029	struct isl_vec *sample = NULL;
		7030	int empty;
		7031	unsigned total;
		7032
		7033	if (!bmap)
		7034	return -1;
		7035
		7036	if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
		7037	return 1;
		7038
		7039	if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL)) {
		7040	struct isl_basic_map *copy = isl_basic_map_copy(bmap);
		7041	copy = isl_basic_map_remove_redundancies(copy);
		7042	empty = ISL_F_ISSET(copy, ISL_BASIC_MAP_EMPTY);
		7043	isl_basic_map_free(copy);
		7044	return empty;
		7045	}
		7046
		7047	total = 1 + isl_basic_map_total_dim(bmap);
		7048	if (bmap->sample && bmap->sample->size == total) {
		7049	int contains = isl_basic_map_contains(bmap, bmap->sample);
		7050	if (contains < 0)
		7051	return -1;
		7052	if (contains)
		7053	return 0;
		7054	}
		7055	isl_vec_free(bmap->sample);
		7056	bmap->sample = NULL;
		7057	bset = isl_basic_map_underlying_set(isl_basic_map_copy(bmap));
		7058	if (!bset)
		7059	return -1;
		7060	sample = isl_basic_set_sample_vec(bset);
		7061	if (!sample)
		7062	return -1;
		7063	empty = sample->size == 0;
		7064	isl_vec_free(bmap->sample);
		7065	bmap->sample = sample;
		7066	if (empty)
		7067	ISL_F_SET(bmap, ISL_BASIC_MAP_EMPTY);
		7068
		7069	return empty;
		7070	}
		7071
		7072	int isl_basic_map_plain_is_empty(__isl_keep isl_basic_map *bmap)
		7073	{
		7074	if (!bmap)
		7075	return -1;
		7076	return ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY);
		7077	}
		7078
		7079	int isl_basic_map_fast_is_empty(__isl_keep isl_basic_map *bmap)
		7080	{
		7081	return isl_basic_map_plain_is_empty(bmap);
		7082	}
		7083
		7084	int isl_basic_set_plain_is_empty(__isl_keep isl_basic_set *bset)
		7085	{
		7086	if (!bset)
		7087	return -1;
		7088	return ISL_F_ISSET(bset, ISL_BASIC_SET_EMPTY);
		7089	}
		7090
		7091	int isl_basic_set_fast_is_empty(__isl_keep isl_basic_set *bset)
		7092	{
		7093	return isl_basic_set_plain_is_empty(bset);
		7094	}
		7095
		7096	int isl_basic_set_is_empty(struct isl_basic_set *bset)
		7097	{
		7098	return isl_basic_map_is_empty((struct isl_basic_map *)bset);
		7099	}
		7100
		7101	struct isl_map *isl_basic_map_union(
		7102	struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
		7103	{
		7104	struct isl_map *map;
		7105	if (!bmap1 || !bmap2)
		7106	goto error;
		7107
		7108	isl_assert(bmap1->ctx, isl_space_is_equal(bmap1->dim, bmap2->dim), goto error);
		7109
		7110	map = isl_map_alloc_space(isl_space_copy(bmap1->dim), 2, 0);
		7111	if (!map)
		7112	goto error;
		7113	map = isl_map_add_basic_map(map, bmap1);
		7114	map = isl_map_add_basic_map(map, bmap2);
		7115	return map;
		7116	error:
		7117	isl_basic_map_free(bmap1);
		7118	isl_basic_map_free(bmap2);
		7119	return NULL;
		7120	}
		7121
		7122	struct isl_set *isl_basic_set_union(
		7123	struct isl_basic_set *bset1, struct isl_basic_set *bset2)
		7124	{
		7125	return (struct isl_set *)isl_basic_map_union(
		7126	(struct isl_basic_map *)bset1,
		7127	(struct isl_basic_map *)bset2);
		7128	}
		7129
		7130	/* Order divs such that any div only depends on previous divs */
		7131	struct isl_basic_map *isl_basic_map_order_divs(struct isl_basic_map *bmap)
		7132	{
		7133	int i;
		7134	unsigned off;
		7135
		7136	if (!bmap)
		7137	return NULL;
		7138
		7139	off = isl_space_dim(bmap->dim, isl_dim_all);
		7140
		7141	for (i = 0; i < bmap->n_div; ++i) {
		7142	int pos;
		7143	if (isl_int_is_zero(bmap->div[i][0]))
		7144	continue;
		7145	pos = isl_seq_first_non_zero(bmap->div[i]+1+1+off+i,
		7146	bmap->n_div-i);
		7147	if (pos == -1)
		7148	continue;
		7149	isl_basic_map_swap_div(bmap, i, i + pos);
		7150	--i;
		7151	}
		7152	return bmap;
		7153	}
		7154
		7155	struct isl_basic_set *isl_basic_set_order_divs(struct isl_basic_set *bset)
		7156	{
		7157	return (struct isl_basic_set *)
		7158	isl_basic_map_order_divs((struct isl_basic_map *)bset);
		7159	}
		7160
		7161	__isl_give isl_map *isl_map_order_divs(__isl_take isl_map *map)
		7162	{
		7163	int i;
		7164
		7165	if (!map)
		7166	return 0;
		7167
		7168	for (i = 0; i < map->n; ++i) {
		7169	map->p[i] = isl_basic_map_order_divs(map->p[i]);
		7170	if (!map->p[i])
		7171	goto error;
		7172	}
		7173
		7174	return map;
		7175	error:
		7176	isl_map_free(map);
		7177	return NULL;
		7178	}
		7179
		7180	/* Apply the expansion computed by isl_merge_divs.
		7181	* The expansion itself is given by "exp" while the resulting
		7182	* list of divs is given by "div".
		7183	*/
		7184	__isl_give isl_basic_set *isl_basic_set_expand_divs(
		7185	__isl_take isl_basic_set *bset, __isl_take isl_mat *div, int *exp)
		7186	{
		7187	int i, j;
		7188	int n_div;
		7189
		7190	bset = isl_basic_set_cow(bset);
		7191	if (!bset || !div)
		7192	goto error;
		7193
		7194	if (div->n_row < bset->n_div)
		7195	isl_die(isl_mat_get_ctx(div), isl_error_invalid,
		7196	"not an expansion", goto error);
		7197
		7198	bset = isl_basic_map_extend_space(bset, isl_space_copy(bset->dim),
		7199	div->n_row - bset->n_div, 0,
		7200	2 * (div->n_row - bset->n_div));
		7201
		7202	n_div = bset->n_div;
		7203	for (i = n_div; i < div->n_row; ++i)
		7204	if (isl_basic_set_alloc_div(bset) < 0)
		7205	goto error;
		7206
		7207	j = n_div - 1;
		7208	for (i = div->n_row - 1; i >= 0; --i) {
		7209	if (j >= 0 && exp[j] == i) {
		7210	if (i != j)
		7211	isl_basic_map_swap_div(bset, i, j);
		7212	j--;
		7213	} else {
		7214	isl_seq_cpy(bset->div[i], div->row[i], div->n_col);
		7215	if (isl_basic_map_add_div_constraints(bset, i) < 0)
		7216	goto error;
		7217	}
		7218	}
		7219
		7220	isl_mat_free(div);
		7221	return bset;
		7222	error:
		7223	isl_basic_set_free(bset);
		7224	isl_mat_free(div);
		7225	return NULL;
		7226	}
		7227
		7228	/* Look for a div in dst that corresponds to the div "div" in src.
		7229	* The divs before "div" in src and dst are assumed to be the same.
		7230	*
		7231	* Returns -1 if no corresponding div was found and the position
		7232	* of the corresponding div in dst otherwise.
		7233	*/
		7234	static int find_div(struct isl_basic_map *dst,
		7235	struct isl_basic_map *src, unsigned div)
		7236	{
		7237	int i;
		7238
		7239	unsigned total = isl_space_dim(src->dim, isl_dim_all);
		7240
		7241	isl_assert(dst->ctx, div <= dst->n_div, return -1);
		7242	for (i = div; i < dst->n_div; ++i)
		7243	if (isl_seq_eq(dst->div[i], src->div[div], 1+1+total+div) &&
		7244	isl_seq_first_non_zero(dst->div[i]+1+1+total+div,
		7245	dst->n_div - div) == -1)
		7246	return i;
		7247	return -1;
		7248	}
		7249
		7250	struct isl_basic_map *isl_basic_map_align_divs(
		7251	struct isl_basic_map *dst, struct isl_basic_map *src)
		7252	{
		7253	int i;
		7254	unsigned total = isl_space_dim(src->dim, isl_dim_all);
		7255
		7256	if (!dst || !src)
		7257	goto error;
		7258
		7259	if (src->n_div == 0)
		7260	return dst;
		7261
		7262	for (i = 0; i < src->n_div; ++i)
		7263	isl_assert(src->ctx, !isl_int_is_zero(src->div[i][0]), goto error);
		7264
		7265	src = isl_basic_map_order_divs(src);
		7266	dst = isl_basic_map_cow(dst);
		7267	dst = isl_basic_map_extend_space(dst, isl_space_copy(dst->dim),
		7268	src->n_div, 0, 2 * src->n_div);
		7269	if (!dst)
		7270	return NULL;
		7271	for (i = 0; i < src->n_div; ++i) {
		7272	int j = find_div(dst, src, i);
		7273	if (j < 0) {
		7274	j = isl_basic_map_alloc_div(dst);
		7275	if (j < 0)
		7276	goto error;
		7277	isl_seq_cpy(dst->div[j], src->div[i], 1+1+total+i);
		7278	isl_seq_clr(dst->div[j]+1+1+total+i, dst->n_div - i);
		7279	if (isl_basic_map_add_div_constraints(dst, j) < 0)
		7280	goto error;
		7281	}
		7282	if (j != i)
		7283	isl_basic_map_swap_div(dst, i, j);
		7284	}
		7285	return dst;
		7286	error:
		7287	isl_basic_map_free(dst);
		7288	return NULL;
		7289	}
		7290
		7291	struct isl_basic_set *isl_basic_set_align_divs(
		7292	struct isl_basic_set *dst, struct isl_basic_set *src)
		7293	{
		7294	return (struct isl_basic_set *)isl_basic_map_align_divs(
		7295	(struct isl_basic_map *)dst, (struct isl_basic_map *)src);
		7296	}
		7297
		7298	struct isl_map *isl_map_align_divs(struct isl_map *map)
		7299	{
		7300	int i;
		7301
		7302	if (!map)
		7303	return NULL;
		7304	if (map->n == 0)
		7305	return map;
		7306	map = isl_map_compute_divs(map);
		7307	map = isl_map_cow(map);
		7308	if (!map)
		7309	return NULL;
		7310
		7311	for (i = 1; i < map->n; ++i)
		7312	map->p[0] = isl_basic_map_align_divs(map->p[0], map->p[i]);
		7313	for (i = 1; i < map->n; ++i)
		7314	map->p[i] = isl_basic_map_align_divs(map->p[i], map->p[0]);
		7315
		7316	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
		7317	return map;
		7318	}
		7319
		7320	struct isl_set *isl_set_align_divs(struct isl_set *set)
		7321	{
		7322	return (struct isl_set *)isl_map_align_divs((struct isl_map *)set);
		7323	}
		7324
		7325	static __isl_give isl_set *set_apply( __isl_take isl_set *set,
		7326	__isl_take isl_map *map)
		7327	{
		7328	if (!set || !map)
		7329	goto error;
		7330	isl_assert(set->ctx, isl_map_compatible_domain(map, set), goto error);
		7331	map = isl_map_intersect_domain(map, set);
		7332	set = isl_map_range(map);
		7333	return set;
		7334	error:
		7335	isl_set_free(set);
		7336	isl_map_free(map);
		7337	return NULL;
		7338	}
		7339
		7340	__isl_give isl_set *isl_set_apply( __isl_take isl_set *set,
		7341	__isl_take isl_map *map)
		7342	{
		7343	return isl_map_align_params_map_map_and(set, map, &set_apply);
		7344	}
		7345
		7346	/* There is no need to cow as removing empty parts doesn't change
		7347	* the meaning of the set.
		7348	*/
		7349	struct isl_map *isl_map_remove_empty_parts(struct isl_map *map)
		7350	{
		7351	int i;
		7352
		7353	if (!map)
		7354	return NULL;
		7355
		7356	for (i = map->n - 1; i >= 0; --i)
		7357	remove_if_empty(map, i);
		7358
		7359	return map;
		7360	}
		7361
		7362	struct isl_set *isl_set_remove_empty_parts(struct isl_set *set)
		7363	{
		7364	return (struct isl_set *)
		7365	isl_map_remove_empty_parts((struct isl_map *)set);
		7366	}
		7367
		7368	struct isl_basic_map *isl_map_copy_basic_map(struct isl_map *map)
		7369	{
		7370	struct isl_basic_map *bmap;
		7371	if (!map || map->n == 0)
		7372	return NULL;
		7373	bmap = map->p[map->n-1];
		7374	isl_assert(map->ctx, ISL_F_ISSET(bmap, ISL_BASIC_SET_FINAL), return NULL);
		7375	return isl_basic_map_copy(bmap);
		7376	}
		7377
		7378	struct isl_basic_set *isl_set_copy_basic_set(struct isl_set *set)
		7379	{
		7380	return (struct isl_basic_set *)
		7381	isl_map_copy_basic_map((struct isl_map *)set);
		7382	}
		7383
		7384	__isl_give isl_map *isl_map_drop_basic_map(__isl_take isl_map *map,
		7385	__isl_keep isl_basic_map *bmap)
		7386	{
		7387	int i;
		7388
		7389	if (!map || !bmap)
		7390	goto error;
		7391	for (i = map->n-1; i >= 0; --i) {
		7392	if (map->p[i] != bmap)
		7393	continue;
		7394	map = isl_map_cow(map);
		7395	if (!map)
		7396	goto error;
		7397	isl_basic_map_free(map->p[i]);
		7398	if (i != map->n-1) {
		7399	ISL_F_CLR(map, ISL_SET_NORMALIZED);
		7400	map->p[i] = map->p[map->n-1];
		7401	}
		7402	map->n--;
		7403	return map;
		7404	}
		7405	return map;
		7406	error:
		7407	isl_map_free(map);
		7408	return NULL;
		7409	}
		7410
		7411	struct isl_set *isl_set_drop_basic_set(struct isl_set *set,
		7412	struct isl_basic_set *bset)
		7413	{
		7414	return (struct isl_set *)isl_map_drop_basic_map((struct isl_map *)set,
		7415	(struct isl_basic_map *)bset);
		7416	}
		7417
		7418	/* Given two basic sets bset1 and bset2, compute the maximal difference
		7419	* between the values of dimension pos in bset1 and those in bset2
		7420	* for any common value of the parameters and dimensions preceding pos.
		7421	*/
		7422	static enum isl_lp_result basic_set_maximal_difference_at(
		7423	__isl_keep isl_basic_set *bset1, __isl_keep isl_basic_set *bset2,
		7424	int pos, isl_int *opt)
		7425	{
		7426	isl_space *dims;
		7427	struct isl_basic_map *bmap1 = NULL;
		7428	struct isl_basic_map *bmap2 = NULL;
		7429	struct isl_ctx *ctx;
		7430	struct isl_vec *obj;
		7431	unsigned total;
		7432	unsigned nparam;
		7433	unsigned dim1, dim2;
		7434	enum isl_lp_result res;
		7435
		7436	if (!bset1 || !bset2)
		7437	return isl_lp_error;
		7438
		7439	nparam = isl_basic_set_n_param(bset1);
		7440	dim1 = isl_basic_set_n_dim(bset1);
		7441	dim2 = isl_basic_set_n_dim(bset2);
		7442	dims = isl_space_alloc(bset1->ctx, nparam, pos, dim1 - pos);
		7443	bmap1 = isl_basic_map_from_basic_set(isl_basic_set_copy(bset1), dims);
		7444	dims = isl_space_alloc(bset2->ctx, nparam, pos, dim2 - pos);
		7445	bmap2 = isl_basic_map_from_basic_set(isl_basic_set_copy(bset2), dims);
		7446	if (!bmap1 || !bmap2)
		7447	goto error;
		7448	bmap1 = isl_basic_map_cow(bmap1);
		7449	bmap1 = isl_basic_map_extend(bmap1, nparam,
		7450	pos, (dim1 - pos) + (dim2 - pos),
		7451	bmap2->n_div, bmap2->n_eq, bmap2->n_ineq);
		7452	bmap1 = add_constraints(bmap1, bmap2, 0, dim1 - pos);
		7453	if (!bmap1)
		7454	goto error;
		7455	total = isl_basic_map_total_dim(bmap1);
		7456	ctx = bmap1->ctx;
		7457	obj = isl_vec_alloc(ctx, 1 + total);
		7458	isl_seq_clr(obj->block.data, 1 + total);
		7459	isl_int_set_si(obj->block.data[1+nparam+pos], 1);
		7460	isl_int_set_si(obj->block.data[1+nparam+pos+(dim1-pos)], -1);
		7461	if (!obj)
		7462	goto error;
		7463	res = isl_basic_map_solve_lp(bmap1, 1, obj->block.data, ctx->one,
		7464	opt, NULL, NULL);
		7465	isl_basic_map_free(bmap1);
		7466	isl_vec_free(obj);
		7467	return res;
		7468	error:
		7469	isl_basic_map_free(bmap1);
		7470	isl_basic_map_free(bmap2);
		7471	return isl_lp_error;
		7472	}
		7473
		7474	/* Given two _disjoint_ basic sets bset1 and bset2, check whether
		7475	* for any common value of the parameters and dimensions preceding pos
		7476	* in both basic sets, the values of dimension pos in bset1 are
		7477	* smaller or larger than those in bset2.
		7478	*
		7479	* Returns
		7480	* 1 if bset1 follows bset2
		7481	* -1 if bset1 precedes bset2
		7482	* 0 if bset1 and bset2 are incomparable
		7483	* -2 if some error occurred.
		7484	*/
		7485	int isl_basic_set_compare_at(struct isl_basic_set *bset1,
		7486	struct isl_basic_set *bset2, int pos)
		7487	{
		7488	isl_int opt;
		7489	enum isl_lp_result res;
		7490	int cmp;
		7491
		7492	isl_int_init(opt);
		7493
		7494	res = basic_set_maximal_difference_at(bset1, bset2, pos, &opt);
		7495
		7496	if (res == isl_lp_empty)
		7497	cmp = 0;
		7498	else if ((res == isl_lp_ok && isl_int_is_pos(opt)) ||
		7499	res == isl_lp_unbounded)
		7500	cmp = 1;
		7501	else if (res == isl_lp_ok && isl_int_is_neg(opt))
		7502	cmp = -1;
		7503	else
		7504	cmp = -2;
		7505
		7506	isl_int_clear(opt);
		7507	return cmp;
		7508	}
		7509
		7510	/* Given two basic sets bset1 and bset2, check whether
		7511	* for any common value of the parameters and dimensions preceding pos
		7512	* there is a value of dimension pos in bset1 that is larger
		7513	* than a value of the same dimension in bset2.
		7514	*
		7515	* Return
		7516	* 1 if there exists such a pair
		7517	* 0 if there is no such pair, but there is a pair of equal values
		7518	* -1 otherwise
		7519	* -2 if some error occurred.
		7520	*/
		7521	int isl_basic_set_follows_at(__isl_keep isl_basic_set *bset1,
		7522	__isl_keep isl_basic_set *bset2, int pos)
		7523	{
		7524	isl_int opt;
		7525	enum isl_lp_result res;
		7526	int cmp;
		7527
		7528	isl_int_init(opt);
		7529
		7530	res = basic_set_maximal_difference_at(bset1, bset2, pos, &opt);
		7531
		7532	if (res == isl_lp_empty)
		7533	cmp = -1;
		7534	else if ((res == isl_lp_ok && isl_int_is_pos(opt)) ||
		7535	res == isl_lp_unbounded)
		7536	cmp = 1;
		7537	else if (res == isl_lp_ok && isl_int_is_neg(opt))
		7538	cmp = -1;
		7539	else if (res == isl_lp_ok)
		7540	cmp = 0;
		7541	else
		7542	cmp = -2;
		7543
		7544	isl_int_clear(opt);
		7545	return cmp;
		7546	}
		7547
		7548	/* Given two sets set1 and set2, check whether
		7549	* for any common value of the parameters and dimensions preceding pos
		7550	* there is a value of dimension pos in set1 that is larger
		7551	* than a value of the same dimension in set2.
		7552	*
		7553	* Return
		7554	* 1 if there exists such a pair
		7555	* 0 if there is no such pair, but there is a pair of equal values
		7556	* -1 otherwise
		7557	* -2 if some error occurred.
		7558	*/
		7559	int isl_set_follows_at(__isl_keep isl_set *set1,
		7560	__isl_keep isl_set *set2, int pos)
		7561	{
		7562	int i, j;
		7563	int follows = -1;
		7564
		7565	if (!set1 || !set2)
		7566	return -2;
		7567
		7568	for (i = 0; i < set1->n; ++i)
		7569	for (j = 0; j < set2->n; ++j) {
		7570	int f;
		7571	f = isl_basic_set_follows_at(set1->p[i], set2->p[j], pos);
		7572	if (f == 1 || f == -2)
		7573	return f;
		7574	if (f > follows)
		7575	follows = f;
		7576	}
		7577
		7578	return follows;
		7579	}
		7580
		7581	static int isl_basic_map_plain_has_fixed_var(__isl_keep isl_basic_map *bmap,
		7582	unsigned pos, isl_int *val)
		7583	{
		7584	int i;
		7585	int d;
		7586	unsigned total;
		7587
		7588	if (!bmap)
		7589	return -1;
		7590	total = isl_basic_map_total_dim(bmap);
		7591	for (i = 0, d = total-1; i < bmap->n_eq && d+1 > pos; ++i) {
		7592	for (; d+1 > pos; --d)
		7593	if (!isl_int_is_zero(bmap->eq[i][1+d]))
		7594	break;
		7595	if (d != pos)
		7596	continue;
		7597	if (isl_seq_first_non_zero(bmap->eq[i]+1, d) != -1)
		7598	return 0;
		7599	if (isl_seq_first_non_zero(bmap->eq[i]+1+d+1, total-d-1) != -1)
		7600	return 0;
		7601	if (!isl_int_is_one(bmap->eq[i][1+d]))
		7602	return 0;
		7603	if (val)
		7604	isl_int_neg(*val, bmap->eq[i][0]);
		7605	return 1;
		7606	}
		7607	return 0;
		7608	}
		7609
		7610	static int isl_map_plain_has_fixed_var(__isl_keep isl_map *map,
		7611	unsigned pos, isl_int *val)
		7612	{
		7613	int i;
		7614	isl_int v;
		7615	isl_int tmp;
		7616	int fixed;
		7617
		7618	if (!map)
		7619	return -1;
		7620	if (map->n == 0)
		7621	return 0;
		7622	if (map->n == 1)
		7623	return isl_basic_map_plain_has_fixed_var(map->p[0], pos, val);
		7624	isl_int_init(v);
		7625	isl_int_init(tmp);
		7626	fixed = isl_basic_map_plain_has_fixed_var(map->p[0], pos, &v);
		7627	for (i = 1; fixed == 1 && i < map->n; ++i) {
		7628	fixed = isl_basic_map_plain_has_fixed_var(map->p[i], pos, &tmp);
		7629	if (fixed == 1 && isl_int_ne(tmp, v))
		7630	fixed = 0;
		7631	}
		7632	if (val)
		7633	isl_int_set(*val, v);
		7634	isl_int_clear(tmp);
		7635	isl_int_clear(v);
		7636	return fixed;
		7637	}
		7638
		7639	static int isl_basic_set_plain_has_fixed_var(__isl_keep isl_basic_set *bset,
		7640	unsigned pos, isl_int *val)
		7641	{
		7642	return isl_basic_map_plain_has_fixed_var((struct isl_basic_map *)bset,
		7643	pos, val);
		7644	}
		7645
		7646	static int isl_set_plain_has_fixed_var(__isl_keep isl_set *set, unsigned pos,
		7647	isl_int *val)
		7648	{
		7649	return isl_map_plain_has_fixed_var((struct isl_map *)set, pos, val);
		7650	}
		7651
		7652	int isl_basic_map_plain_is_fixed(__isl_keep isl_basic_map *bmap,
		7653	enum isl_dim_type type, unsigned pos, isl_int *val)
		7654	{
		7655	if (pos >= isl_basic_map_dim(bmap, type))
		7656	return -1;
		7657	return isl_basic_map_plain_has_fixed_var(bmap,
		7658	isl_basic_map_offset(bmap, type) - 1 + pos, val);
		7659	}
		7660
		7661	int isl_map_plain_is_fixed(__isl_keep isl_map *map,
		7662	enum isl_dim_type type, unsigned pos, isl_int *val)
		7663	{
		7664	if (pos >= isl_map_dim(map, type))
		7665	return -1;
		7666	return isl_map_plain_has_fixed_var(map,
		7667	map_offset(map, type) - 1 + pos, val);
		7668	}
		7669
		7670	int isl_set_plain_is_fixed(__isl_keep isl_set *set,
		7671	enum isl_dim_type type, unsigned pos, isl_int *val)
		7672	{
		7673	return isl_map_plain_is_fixed(set, type, pos, val);
		7674	}
		7675
		7676	int isl_map_fast_is_fixed(__isl_keep isl_map *map,
		7677	enum isl_dim_type type, unsigned pos, isl_int *val)
		7678	{
		7679	return isl_map_plain_is_fixed(map, type, pos, val);
		7680	}
		7681
		7682	/* Check if dimension dim has fixed value and if so and if val is not NULL,
		7683	* then return this fixed value in *val.
		7684	*/
		7685	int isl_basic_set_plain_dim_is_fixed(__isl_keep isl_basic_set *bset,
		7686	unsigned dim, isl_int *val)
		7687	{
		7688	return isl_basic_set_plain_has_fixed_var(bset,
		7689	isl_basic_set_n_param(bset) + dim, val);
		7690	}
		7691
		7692	/* Check if dimension dim has fixed value and if so and if val is not NULL,
		7693	* then return this fixed value in *val.
		7694	*/
		7695	int isl_set_plain_dim_is_fixed(__isl_keep isl_set *set,
		7696	unsigned dim, isl_int *val)
		7697	{
		7698	return isl_set_plain_has_fixed_var(set, isl_set_n_param(set) + dim, val);
		7699	}
		7700
		7701	int isl_set_fast_dim_is_fixed(__isl_keep isl_set *set,
		7702	unsigned dim, isl_int *val)
		7703	{
		7704	return isl_set_plain_dim_is_fixed(set, dim, val);
		7705	}
		7706
		7707	/* Check if input variable in has fixed value and if so and if val is not NULL,
		7708	* then return this fixed value in *val.
		7709	*/
		7710	int isl_map_plain_input_is_fixed(__isl_keep isl_map *map,
		7711	unsigned in, isl_int *val)
		7712	{
		7713	return isl_map_plain_has_fixed_var(map, isl_map_n_param(map) + in, val);
		7714	}
		7715
		7716	/* Check if dimension dim has an (obvious) fixed lower bound and if so
		7717	* and if val is not NULL, then return this lower bound in *val.
		7718	*/
		7719	int isl_basic_set_plain_dim_has_fixed_lower_bound(
		7720	__isl_keep isl_basic_set *bset, unsigned dim, isl_int *val)
		7721	{
		7722	int i, i_eq = -1, i_ineq = -1;
		7723	isl_int *c;
		7724	unsigned total;
		7725	unsigned nparam;
		7726
		7727	if (!bset)
		7728	return -1;
		7729	total = isl_basic_set_total_dim(bset);
		7730	nparam = isl_basic_set_n_param(bset);
		7731	for (i = 0; i < bset->n_eq; ++i) {
		7732	if (isl_int_is_zero(bset->eq[i][1+nparam+dim]))
		7733	continue;
		7734	if (i_eq != -1)
		7735	return 0;
		7736	i_eq = i;
		7737	}
		7738	for (i = 0; i < bset->n_ineq; ++i) {
		7739	if (!isl_int_is_pos(bset->ineq[i][1+nparam+dim]))
		7740	continue;
		7741	if (i_eq != -1 || i_ineq != -1)
		7742	return 0;
		7743	i_ineq = i;
		7744	}
		7745	if (i_eq == -1 && i_ineq == -1)
		7746	return 0;
		7747	c = i_eq != -1 ? bset->eq[i_eq] : bset->ineq[i_ineq];
		7748	/* The coefficient should always be one due to normalization. */
		7749	if (!isl_int_is_one(c[1+nparam+dim]))
		7750	return 0;
		7751	if (isl_seq_first_non_zero(c+1, nparam+dim) != -1)
		7752	return 0;
		7753	if (isl_seq_first_non_zero(c+1+nparam+dim+1,
		7754	total - nparam - dim - 1) != -1)
		7755	return 0;
		7756	if (val)
		7757	isl_int_neg(*val, c[0]);
		7758	return 1;
		7759	}
		7760
		7761	int isl_set_plain_dim_has_fixed_lower_bound(__isl_keep isl_set *set,
		7762	unsigned dim, isl_int *val)
		7763	{
		7764	int i;
		7765	isl_int v;
		7766	isl_int tmp;
		7767	int fixed;
		7768
		7769	if (!set)
		7770	return -1;
		7771	if (set->n == 0)
		7772	return 0;
		7773	if (set->n == 1)
		7774	return isl_basic_set_plain_dim_has_fixed_lower_bound(set->p[0],
		7775	dim, val);
		7776	isl_int_init(v);
		7777	isl_int_init(tmp);
		7778	fixed = isl_basic_set_plain_dim_has_fixed_lower_bound(set->p[0],
		7779	dim, &v);
		7780	for (i = 1; fixed == 1 && i < set->n; ++i) {
		7781	fixed = isl_basic_set_plain_dim_has_fixed_lower_bound(set->p[i],
		7782	dim, &tmp);
		7783	if (fixed == 1 && isl_int_ne(tmp, v))
		7784	fixed = 0;
		7785	}
		7786	if (val)
		7787	isl_int_set(*val, v);
		7788	isl_int_clear(tmp);
		7789	isl_int_clear(v);
		7790	return fixed;
		7791	}
		7792
		7793	struct constraint {
		7794	unsigned size;
		7795	isl_int *c;
		7796	};
		7797
		7798	/* uset_gist depends on constraints without existentially quantified
		7799	* variables sorting first.
		7800	*/
		7801	static int qsort_constraint_cmp(const void *p1, const void *p2)
		7802	{
		7803	const struct constraint *c1 = (const struct constraint *)p1;
		7804	const struct constraint *c2 = (const struct constraint *)p2;
		7805	int l1, l2;
		7806	unsigned size = isl_min(c1->size, c2->size);
		7807
		7808	l1 = isl_seq_last_non_zero(c1->c, size);
		7809	l2 = isl_seq_last_non_zero(c2->c, size);
		7810
		7811	if (l1 != l2)
		7812	return l1 - l2;
		7813
		7814	return isl_seq_cmp(c1->c, c2->c, size);
		7815	}
		7816
		7817	static struct isl_basic_map *isl_basic_map_sort_constraints(
		7818	struct isl_basic_map *bmap)
		7819	{
		7820	int i;
		7821	struct constraint *c;
		7822	unsigned total;
		7823
		7824	if (!bmap)
		7825	return NULL;
		7826	total = isl_basic_map_total_dim(bmap);
		7827	c = isl_alloc_array(bmap->ctx, struct constraint, bmap->n_ineq);
		7828	if (!c)
		7829	goto error;
		7830	for (i = 0; i < bmap->n_ineq; ++i) {
		7831	c[i].size = total;
		7832	c[i].c = bmap->ineq[i];
		7833	}
		7834	qsort(c, bmap->n_ineq, sizeof(struct constraint), qsort_constraint_cmp);
		7835	for (i = 0; i < bmap->n_ineq; ++i)
		7836	bmap->ineq[i] = c[i].c;
		7837	free(c);
		7838	return bmap;
		7839	error:
		7840	isl_basic_map_free(bmap);
		7841	return NULL;
		7842	}
		7843
		7844	__isl_give isl_basic_set *isl_basic_set_sort_constraints(
		7845	__isl_take isl_basic_set *bset)
		7846	{
		7847	return (struct isl_basic_set *)isl_basic_map_sort_constraints(
		7848	(struct isl_basic_map *)bset);
		7849	}
		7850
		7851	struct isl_basic_map *isl_basic_map_normalize(struct isl_basic_map *bmap)
		7852	{
		7853	if (!bmap)
		7854	return NULL;
		7855	if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_NORMALIZED))
		7856	return bmap;
		7857	bmap = isl_basic_map_remove_redundancies(bmap);
		7858	bmap = isl_basic_map_sort_constraints(bmap);
		7859	ISL_F_SET(bmap, ISL_BASIC_MAP_NORMALIZED);
		7860	return bmap;
		7861	}
		7862
		7863	struct isl_basic_set *isl_basic_set_normalize(struct isl_basic_set *bset)
		7864	{
		7865	return (struct isl_basic_set *)isl_basic_map_normalize(
		7866	(struct isl_basic_map *)bset);
		7867	}
		7868
		7869	int isl_basic_map_plain_cmp(const __isl_keep isl_basic_map *bmap1,
		7870	const __isl_keep isl_basic_map *bmap2)
		7871	{
		7872	int i, cmp;
		7873	unsigned total;
		7874
		7875	if (bmap1 == bmap2)
		7876	return 0;
		7877	if (ISL_F_ISSET(bmap1, ISL_BASIC_MAP_RATIONAL) !=
		7878	ISL_F_ISSET(bmap2, ISL_BASIC_MAP_RATIONAL))
		7879	return ISL_F_ISSET(bmap1, ISL_BASIC_MAP_RATIONAL) ? -1 : 1;
		7880	if (isl_basic_map_n_param(bmap1) != isl_basic_map_n_param(bmap2))
		7881	return isl_basic_map_n_param(bmap1) - isl_basic_map_n_param(bmap2);
		7882	if (isl_basic_map_n_in(bmap1) != isl_basic_map_n_in(bmap2))
		7883	return isl_basic_map_n_out(bmap1) - isl_basic_map_n_out(bmap2);
		7884	if (isl_basic_map_n_out(bmap1) != isl_basic_map_n_out(bmap2))
		7885	return isl_basic_map_n_out(bmap1) - isl_basic_map_n_out(bmap2);
		7886	if (ISL_F_ISSET(bmap1, ISL_BASIC_MAP_EMPTY) &&
		7887	ISL_F_ISSET(bmap2, ISL_BASIC_MAP_EMPTY))
		7888	return 0;
		7889	if (ISL_F_ISSET(bmap1, ISL_BASIC_MAP_EMPTY))
		7890	return 1;
		7891	if (ISL_F_ISSET(bmap2, ISL_BASIC_MAP_EMPTY))
		7892	return -1;
		7893	if (bmap1->n_eq != bmap2->n_eq)
		7894	return bmap1->n_eq - bmap2->n_eq;
		7895	if (bmap1->n_ineq != bmap2->n_ineq)
		7896	return bmap1->n_ineq - bmap2->n_ineq;
		7897	if (bmap1->n_div != bmap2->n_div)
		7898	return bmap1->n_div - bmap2->n_div;
		7899	total = isl_basic_map_total_dim(bmap1);
		7900	for (i = 0; i < bmap1->n_eq; ++i) {
		7901	cmp = isl_seq_cmp(bmap1->eq[i], bmap2->eq[i], 1+total);
		7902	if (cmp)
		7903	return cmp;
		7904	}
		7905	for (i = 0; i < bmap1->n_ineq; ++i) {
		7906	cmp = isl_seq_cmp(bmap1->ineq[i], bmap2->ineq[i], 1+total);
		7907	if (cmp)
		7908	return cmp;
		7909	}
		7910	for (i = 0; i < bmap1->n_div; ++i) {
		7911	cmp = isl_seq_cmp(bmap1->div[i], bmap2->div[i], 1+1+total);
		7912	if (cmp)
		7913	return cmp;
		7914	}
		7915	return 0;
		7916	}
		7917
		7918	int isl_basic_set_plain_cmp(const __isl_keep isl_basic_set *bset1,
		7919	const __isl_keep isl_basic_set *bset2)
		7920	{
		7921	return isl_basic_map_plain_cmp(bset1, bset2);
		7922	}
		7923
		7924	int isl_set_plain_cmp(const __isl_keep isl_set *set1,
		7925	const __isl_keep isl_set *set2)
		7926	{
		7927	int i, cmp;
		7928
		7929	if (set1 == set2)
		7930	return 0;
		7931	if (set1->n != set2->n)
		7932	return set1->n - set2->n;
		7933
		7934	for (i = 0; i < set1->n; ++i) {
		7935	cmp = isl_basic_set_plain_cmp(set1->p[i], set2->p[i]);
		7936	if (cmp)
		7937	return cmp;
		7938	}
		7939
		7940	return 0;
		7941	}
		7942
		7943	int isl_basic_map_plain_is_equal(__isl_keep isl_basic_map *bmap1,
		7944	__isl_keep isl_basic_map *bmap2)
		7945	{
		7946	return isl_basic_map_plain_cmp(bmap1, bmap2) == 0;
		7947	}
		7948
		7949	int isl_basic_set_plain_is_equal(__isl_keep isl_basic_set *bset1,
		7950	__isl_keep isl_basic_set *bset2)
		7951	{
		7952	return isl_basic_map_plain_is_equal((isl_basic_map *)bset1,
		7953	(isl_basic_map *)bset2);
		7954	}
		7955
		7956	static int qsort_bmap_cmp(const void *p1, const void *p2)
		7957	{
		7958	const struct isl_basic_map *bmap1 = *(const struct isl_basic_map **)p1;
		7959	const struct isl_basic_map *bmap2 = *(const struct isl_basic_map **)p2;
		7960
		7961	return isl_basic_map_plain_cmp(bmap1, bmap2);
		7962	}
		7963
		7964	/* We normalize in place, but if anything goes wrong we need
		7965	* to return NULL, so we need to make sure we don't change the
		7966	* meaning of any possible other copies of map.
		7967	*/
		7968	struct isl_map *isl_map_normalize(struct isl_map *map)
		7969	{
		7970	int i, j;
		7971	struct isl_basic_map *bmap;
		7972
		7973	if (!map)
		7974	return NULL;
		7975	if (ISL_F_ISSET(map, ISL_MAP_NORMALIZED))
		7976	return map;
		7977	for (i = 0; i < map->n; ++i) {
		7978	bmap = isl_basic_map_normalize(isl_basic_map_copy(map->p[i]));
		7979	if (!bmap)
		7980	goto error;
		7981	isl_basic_map_free(map->p[i]);
		7982	map->p[i] = bmap;
		7983	}
		7984	qsort(map->p, map->n, sizeof(struct isl_basic_map *), qsort_bmap_cmp);
		7985	ISL_F_SET(map, ISL_MAP_NORMALIZED);
		7986	map = isl_map_remove_empty_parts(map);
		7987	if (!map)
		7988	return NULL;
		7989	for (i = map->n - 1; i >= 1; --i) {
		7990	if (!isl_basic_map_plain_is_equal(map->p[i-1], map->p[i]))
		7991	continue;
		7992	isl_basic_map_free(map->p[i-1]);
		7993	for (j = i; j < map->n; ++j)
		7994	map->p[j-1] = map->p[j];
		7995	map->n--;
		7996	}
		7997	return map;
		7998	error:
		7999	isl_map_free(map);
		8000	return NULL;
		8001
		8002	}
		8003
		8004	struct isl_set *isl_set_normalize(struct isl_set *set)
		8005	{
		8006	return (struct isl_set *)isl_map_normalize((struct isl_map *)set);
		8007	}
		8008
		8009	int isl_map_plain_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2)
		8010	{
		8011	int i;
		8012	int equal;
		8013
		8014	if (!map1 || !map2)
		8015	return -1;
		8016
		8017	if (map1 == map2)
		8018	return 1;
		8019	if (!isl_space_is_equal(map1->dim, map2->dim))
		8020	return 0;
		8021
		8022	map1 = isl_map_copy(map1);
		8023	map2 = isl_map_copy(map2);
		8024	map1 = isl_map_normalize(map1);
		8025	map2 = isl_map_normalize(map2);
		8026	if (!map1 || !map2)
		8027	goto error;
		8028	equal = map1->n == map2->n;
		8029	for (i = 0; equal && i < map1->n; ++i) {
		8030	equal = isl_basic_map_plain_is_equal(map1->p[i], map2->p[i]);
		8031	if (equal < 0)
		8032	goto error;
		8033	}
		8034	isl_map_free(map1);
		8035	isl_map_free(map2);
		8036	return equal;
		8037	error:
		8038	isl_map_free(map1);
		8039	isl_map_free(map2);
		8040	return -1;
		8041	}
		8042
		8043	int isl_map_fast_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2)
		8044	{
		8045	return isl_map_plain_is_equal(map1, map2);
		8046	}
		8047
		8048	int isl_set_plain_is_equal(__isl_keep isl_set *set1, __isl_keep isl_set *set2)
		8049	{
		8050	return isl_map_plain_is_equal((struct isl_map *)set1,
		8051	(struct isl_map *)set2);
		8052	}
		8053
		8054	int isl_set_fast_is_equal(__isl_keep isl_set *set1, __isl_keep isl_set *set2)
		8055	{
		8056	return isl_set_plain_is_equal(set1, set2);
		8057	}
		8058
		8059	/* Return an interval that ranges from min to max (inclusive)
		8060	*/
		8061	struct isl_basic_set *isl_basic_set_interval(struct isl_ctx *ctx,
		8062	isl_int min, isl_int max)
		8063	{
		8064	int k;
		8065	struct isl_basic_set *bset = NULL;
		8066
		8067	bset = isl_basic_set_alloc(ctx, 0, 1, 0, 0, 2);
		8068	if (!bset)
		8069	goto error;
		8070
		8071	k = isl_basic_set_alloc_inequality(bset);
		8072	if (k < 0)
		8073	goto error;
		8074	isl_int_set_si(bset->ineq[k][1], 1);
		8075	isl_int_neg(bset->ineq[k][0], min);
		8076
		8077	k = isl_basic_set_alloc_inequality(bset);
		8078	if (k < 0)
		8079	goto error;
		8080	isl_int_set_si(bset->ineq[k][1], -1);
		8081	isl_int_set(bset->ineq[k][0], max);
		8082
		8083	return bset;
		8084	error:
		8085	isl_basic_set_free(bset);
		8086	return NULL;
		8087	}
		8088
		8089	/* Return the Cartesian product of the basic sets in list (in the given order).
		8090	*/
		8091	__isl_give isl_basic_set *isl_basic_set_list_product(
		8092	__isl_take struct isl_basic_set_list *list)
		8093	{
		8094	int i;
		8095	unsigned dim;
		8096	unsigned nparam;
		8097	unsigned extra;
		8098	unsigned n_eq;
		8099	unsigned n_ineq;
		8100	struct isl_basic_set *product = NULL;
		8101
		8102	if (!list)
		8103	goto error;
		8104	isl_assert(list->ctx, list->n > 0, goto error);
		8105	isl_assert(list->ctx, list->p[0], goto error);
		8106	nparam = isl_basic_set_n_param(list->p[0]);
		8107	dim = isl_basic_set_n_dim(list->p[0]);
		8108	extra = list->p[0]->n_div;
		8109	n_eq = list->p[0]->n_eq;
		8110	n_ineq = list->p[0]->n_ineq;
		8111	for (i = 1; i < list->n; ++i) {
		8112	isl_assert(list->ctx, list->p[i], goto error);
		8113	isl_assert(list->ctx,
		8114	nparam == isl_basic_set_n_param(list->p[i]), goto error);
		8115	dim += isl_basic_set_n_dim(list->p[i]);
		8116	extra += list->p[i]->n_div;
		8117	n_eq += list->p[i]->n_eq;
		8118	n_ineq += list->p[i]->n_ineq;
		8119	}
		8120	product = isl_basic_set_alloc(list->ctx, nparam, dim, extra,
		8121	n_eq, n_ineq);
		8122	if (!product)
		8123	goto error;
		8124	dim = 0;
		8125	for (i = 0; i < list->n; ++i) {
		8126	isl_basic_set_add_constraints(product,
		8127	isl_basic_set_copy(list->p[i]), dim);
		8128	dim += isl_basic_set_n_dim(list->p[i]);
		8129	}
		8130	isl_basic_set_list_free(list);
		8131	return product;
		8132	error:
		8133	isl_basic_set_free(product);
		8134	isl_basic_set_list_free(list);
		8135	return NULL;
		8136	}
		8137
		8138	struct isl_basic_map *isl_basic_map_product(
		8139	struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
		8140	{
		8141	isl_space *dim_result = NULL;
		8142	struct isl_basic_map *bmap;
		8143	unsigned in1, in2, out1, out2, nparam, total, pos;
		8144	struct isl_dim_map *dim_map1, *dim_map2;
		8145
		8146	if (!bmap1 || !bmap2)
		8147	goto error;
		8148
		8149	isl_assert(bmap1->ctx, isl_space_match(bmap1->dim, isl_dim_param,
		8150	bmap2->dim, isl_dim_param), goto error);
		8151	dim_result = isl_space_product(isl_space_copy(bmap1->dim),
		8152	isl_space_copy(bmap2->dim));
		8153
		8154	in1 = isl_basic_map_n_in(bmap1);
		8155	in2 = isl_basic_map_n_in(bmap2);
		8156	out1 = isl_basic_map_n_out(bmap1);
		8157	out2 = isl_basic_map_n_out(bmap2);
		8158	nparam = isl_basic_map_n_param(bmap1);
		8159
		8160	total = nparam + in1 + in2 + out1 + out2 + bmap1->n_div + bmap2->n_div;
		8161	dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
		8162	dim_map2 = isl_dim_map_alloc(bmap1->ctx, total);
		8163	isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
		8164	isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos = 0);
		8165	isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
		8166	isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos += in1);
		8167	isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += in2);
		8168	isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos += out1);
		8169	isl_dim_map_div(dim_map1, bmap1, pos += out2);
		8170	isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
		8171
		8172	bmap = isl_basic_map_alloc_space(dim_result,
		8173	bmap1->n_div + bmap2->n_div,
		8174	bmap1->n_eq + bmap2->n_eq,
		8175	bmap1->n_ineq + bmap2->n_ineq);
		8176	bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap1, dim_map1);
		8177	bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap2, dim_map2);
		8178	bmap = isl_basic_map_simplify(bmap);
		8179	return isl_basic_map_finalize(bmap);
		8180	error:
		8181	isl_basic_map_free(bmap1);
		8182	isl_basic_map_free(bmap2);
		8183	return NULL;
		8184	}
		8185
		8186	__isl_give isl_basic_map *isl_basic_map_flat_product(
		8187	__isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2)
		8188	{
		8189	isl_basic_map *prod;
		8190
		8191	prod = isl_basic_map_product(bmap1, bmap2);
		8192	prod = isl_basic_map_flatten(prod);
		8193	return prod;
		8194	}
		8195
		8196	__isl_give isl_basic_set *isl_basic_set_flat_product(
		8197	__isl_take isl_basic_set *bset1, __isl_take isl_basic_set *bset2)
		8198	{
		8199	return isl_basic_map_flat_range_product(bset1, bset2);
		8200	}
		8201
		8202	__isl_give isl_basic_map *isl_basic_map_domain_product(
		8203	__isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2)
		8204	{
		8205	isl_space *space_result = NULL;
		8206	isl_basic_map *bmap;
		8207	unsigned in1, in2, out, nparam, total, pos;
		8208	struct isl_dim_map *dim_map1, *dim_map2;
		8209
		8210	if (!bmap1 || !bmap2)
		8211	goto error;
		8212
		8213	space_result = isl_space_domain_product(isl_space_copy(bmap1->dim),
		8214	isl_space_copy(bmap2->dim));
		8215
		8216	in1 = isl_basic_map_dim(bmap1, isl_dim_in);
		8217	in2 = isl_basic_map_dim(bmap2, isl_dim_in);
		8218	out = isl_basic_map_dim(bmap1, isl_dim_out);
		8219	nparam = isl_basic_map_dim(bmap1, isl_dim_param);
		8220
		8221	total = nparam + in1 + in2 + out + bmap1->n_div + bmap2->n_div;
		8222	dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
		8223	dim_map2 = isl_dim_map_alloc(bmap1->ctx, total);
		8224	isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
		8225	isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos = 0);
		8226	isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
		8227	isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos += in1);
		8228	isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += in2);
		8229	isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos);
		8230	isl_dim_map_div(dim_map1, bmap1, pos += out);
		8231	isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
		8232
		8233	bmap = isl_basic_map_alloc_space(space_result,
		8234	bmap1->n_div + bmap2->n_div,
		8235	bmap1->n_eq + bmap2->n_eq,
		8236	bmap1->n_ineq + bmap2->n_ineq);
		8237	bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap1, dim_map1);
		8238	bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap2, dim_map2);
		8239	bmap = isl_basic_map_simplify(bmap);
		8240	return isl_basic_map_finalize(bmap);
		8241	error:
		8242	isl_basic_map_free(bmap1);
		8243	isl_basic_map_free(bmap2);
		8244	return NULL;
		8245	}
		8246
		8247	__isl_give isl_basic_map *isl_basic_map_range_product(
		8248	__isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2)
		8249	{
		8250	isl_space *dim_result = NULL;
		8251	isl_basic_map *bmap;
		8252	unsigned in, out1, out2, nparam, total, pos;
		8253	struct isl_dim_map *dim_map1, *dim_map2;
		8254
		8255	if (!bmap1 || !bmap2)
		8256	goto error;
		8257
		8258	dim_result = isl_space_range_product(isl_space_copy(bmap1->dim),
		8259	isl_space_copy(bmap2->dim));
		8260
		8261	in = isl_basic_map_dim(bmap1, isl_dim_in);
		8262	out1 = isl_basic_map_n_out(bmap1);
		8263	out2 = isl_basic_map_n_out(bmap2);
		8264	nparam = isl_basic_map_n_param(bmap1);
		8265
		8266	total = nparam + in + out1 + out2 + bmap1->n_div + bmap2->n_div;
		8267	dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
		8268	dim_map2 = isl_dim_map_alloc(bmap1->ctx, total);
		8269	isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
		8270	isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos = 0);
		8271	isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
		8272	isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos);
		8273	isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += in);
		8274	isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos += out1);
		8275	isl_dim_map_div(dim_map1, bmap1, pos += out2);
		8276	isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
		8277
		8278	bmap = isl_basic_map_alloc_space(dim_result,
		8279	bmap1->n_div + bmap2->n_div,
		8280	bmap1->n_eq + bmap2->n_eq,
		8281	bmap1->n_ineq + bmap2->n_ineq);
		8282	bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap1, dim_map1);
		8283	bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap2, dim_map2);
		8284	bmap = isl_basic_map_simplify(bmap);
		8285	return isl_basic_map_finalize(bmap);
		8286	error:
		8287	isl_basic_map_free(bmap1);
		8288	isl_basic_map_free(bmap2);
		8289	return NULL;
		8290	}
		8291
		8292	__isl_give isl_basic_map *isl_basic_map_flat_range_product(
		8293	__isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2)
		8294	{
		8295	isl_basic_map *prod;
		8296
		8297	prod = isl_basic_map_range_product(bmap1, bmap2);
		8298	prod = isl_basic_map_flatten_range(prod);
		8299	return prod;
		8300	}
		8301
		8302	static __isl_give isl_map *map_product(__isl_take isl_map *map1,
		8303	__isl_take isl_map *map2,
		8304	__isl_give isl_space *(*dim_product)(__isl_take isl_space *left,
		8305	__isl_take isl_space *right),
		8306	__isl_give isl_basic_map *(*basic_map_product)(
		8307	__isl_take isl_basic_map *left, __isl_take isl_basic_map *right))
		8308	{
		8309	unsigned flags = 0;
		8310	struct isl_map *result;
		8311	int i, j;
		8312
		8313	if (!map1 || !map2)
		8314	goto error;
		8315
		8316	isl_assert(map1->ctx, isl_space_match(map1->dim, isl_dim_param,
		8317	map2->dim, isl_dim_param), goto error);
		8318
		8319	if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) &&
		8320	ISL_F_ISSET(map2, ISL_MAP_DISJOINT))
		8321	ISL_FL_SET(flags, ISL_MAP_DISJOINT);
		8322
		8323	result = isl_map_alloc_space(dim_product(isl_space_copy(map1->dim),
		8324	isl_space_copy(map2->dim)),
		8325	map1->n * map2->n, flags);
		8326	if (!result)
		8327	goto error;
		8328	for (i = 0; i < map1->n; ++i)
		8329	for (j = 0; j < map2->n; ++j) {
		8330	struct isl_basic_map *part;
		8331	part = basic_map_product(isl_basic_map_copy(map1->p[i]),
		8332	isl_basic_map_copy(map2->p[j]));
		8333	if (isl_basic_map_is_empty(part))
		8334	isl_basic_map_free(part);
		8335	else
		8336	result = isl_map_add_basic_map(result, part);
		8337	if (!result)
		8338	goto error;
		8339	}
		8340	isl_map_free(map1);
		8341	isl_map_free(map2);
		8342	return result;
		8343	error:
		8344	isl_map_free(map1);
		8345	isl_map_free(map2);
		8346	return NULL;
		8347	}
		8348
		8349	/* Given two maps A -> B and C -> D, construct a map [A -> C] -> [B -> D]
		8350	*/
		8351	static __isl_give isl_map *map_product_aligned(__isl_take isl_map *map1,
		8352	__isl_take isl_map *map2)
		8353	{
		8354	return map_product(map1, map2, &isl_space_product, &isl_basic_map_product);
		8355	}
		8356
		8357	__isl_give isl_map *isl_map_product(__isl_take isl_map *map1,
		8358	__isl_take isl_map *map2)
		8359	{
		8360	return isl_map_align_params_map_map_and(map1, map2, &map_product_aligned);
		8361	}
		8362
		8363	/* Given two maps A -> B and C -> D, construct a map (A, C) -> (B, D)
		8364	*/
		8365	__isl_give isl_map *isl_map_flat_product(__isl_take isl_map *map1,
		8366	__isl_take isl_map *map2)
		8367	{
		8368	isl_map *prod;
		8369
		8370	prod = isl_map_product(map1, map2);
		8371	prod = isl_map_flatten(prod);
		8372	return prod;
		8373	}
		8374
		8375	/* Given two set A and B, construct its Cartesian product A x B.
		8376	*/
		8377	struct isl_set *isl_set_product(struct isl_set *set1, struct isl_set *set2)
		8378	{
		8379	return isl_map_range_product(set1, set2);
		8380	}
		8381
		8382	__isl_give isl_set *isl_set_flat_product(__isl_take isl_set *set1,
		8383	__isl_take isl_set *set2)
		8384	{
		8385	return isl_map_flat_range_product(set1, set2);
		8386	}
		8387
		8388	/* Given two maps A -> B and C -> D, construct a map [A -> C] -> (B * D)
		8389	*/
		8390	static __isl_give isl_map *map_domain_product_aligned(__isl_take isl_map *map1,
		8391	__isl_take isl_map *map2)
		8392	{
		8393	return map_product(map1, map2, &isl_space_domain_product,
		8394	&isl_basic_map_domain_product);
		8395	}
		8396
		8397	/* Given two maps A -> B and C -> D, construct a map (A * C) -> [B -> D]
		8398	*/
		8399	static __isl_give isl_map *map_range_product_aligned(__isl_take isl_map *map1,
		8400	__isl_take isl_map *map2)
		8401	{
		8402	return map_product(map1, map2, &isl_space_range_product,
		8403	&isl_basic_map_range_product);
		8404	}
		8405
		8406	__isl_give isl_map *isl_map_domain_product(__isl_take isl_map *map1,
		8407	__isl_take isl_map *map2)
		8408	{
		8409	return isl_map_align_params_map_map_and(map1, map2,
		8410	&map_domain_product_aligned);
		8411	}
		8412
		8413	__isl_give isl_map *isl_map_range_product(__isl_take isl_map *map1,
		8414	__isl_take isl_map *map2)
		8415	{
		8416	return isl_map_align_params_map_map_and(map1, map2,
		8417	&map_range_product_aligned);
		8418	}
		8419
		8420	/* Given two maps A -> B and C -> D, construct a map (A, C) -> (B * D)
		8421	*/
		8422	__isl_give isl_map *isl_map_flat_domain_product(__isl_take isl_map *map1,
		8423	__isl_take isl_map *map2)
		8424	{
		8425	isl_map *prod;
		8426
		8427	prod = isl_map_domain_product(map1, map2);
		8428	prod = isl_map_flatten_domain(prod);
		8429	return prod;
		8430	}
		8431
		8432	/* Given two maps A -> B and C -> D, construct a map (A * C) -> (B, D)
		8433	*/
		8434	__isl_give isl_map *isl_map_flat_range_product(__isl_take isl_map *map1,
		8435	__isl_take isl_map *map2)
		8436	{
		8437	isl_map *prod;
		8438
		8439	prod = isl_map_range_product(map1, map2);
		8440	prod = isl_map_flatten_range(prod);
		8441	return prod;
		8442	}
		8443
		8444	uint32_t isl_basic_map_get_hash(__isl_keep isl_basic_map *bmap)
		8445	{
		8446	int i;
		8447	uint32_t hash = isl_hash_init();
		8448	unsigned total;
		8449
		8450	if (!bmap)
		8451	return 0;
		8452	bmap = isl_basic_map_copy(bmap);
		8453	bmap = isl_basic_map_normalize(bmap);
		8454	if (!bmap)
		8455	return 0;
		8456	total = isl_basic_map_total_dim(bmap);
		8457	isl_hash_byte(hash, bmap->n_eq & 0xFF);
		8458	for (i = 0; i < bmap->n_eq; ++i) {
		8459	uint32_t c_hash;
		8460	c_hash = isl_seq_get_hash(bmap->eq[i], 1 + total);
		8461	isl_hash_hash(hash, c_hash);
		8462	}
		8463	isl_hash_byte(hash, bmap->n_ineq & 0xFF);
		8464	for (i = 0; i < bmap->n_ineq; ++i) {
		8465	uint32_t c_hash;
		8466	c_hash = isl_seq_get_hash(bmap->ineq[i], 1 + total);
		8467	isl_hash_hash(hash, c_hash);
		8468	}
		8469	isl_hash_byte(hash, bmap->n_div & 0xFF);
		8470	for (i = 0; i < bmap->n_div; ++i) {
		8471	uint32_t c_hash;
		8472	if (isl_int_is_zero(bmap->div[i][0]))
		8473	continue;
		8474	isl_hash_byte(hash, i & 0xFF);
		8475	c_hash = isl_seq_get_hash(bmap->div[i], 1 + 1 + total);
		8476	isl_hash_hash(hash, c_hash);
		8477	}
		8478	isl_basic_map_free(bmap);
		8479	return hash;
		8480	}
		8481
		8482	uint32_t isl_basic_set_get_hash(__isl_keep isl_basic_set *bset)
		8483	{
		8484	return isl_basic_map_get_hash((isl_basic_map *)bset);
		8485	}
		8486
		8487	uint32_t isl_map_get_hash(__isl_keep isl_map *map)
		8488	{
		8489	int i;
		8490	uint32_t hash;
		8491
		8492	if (!map)
		8493	return 0;
		8494	map = isl_map_copy(map);
		8495	map = isl_map_normalize(map);
		8496	if (!map)
		8497	return 0;
		8498
		8499	hash = isl_hash_init();
		8500	for (i = 0; i < map->n; ++i) {
		8501	uint32_t bmap_hash;
		8502	bmap_hash = isl_basic_map_get_hash(map->p[i]);
		8503	isl_hash_hash(hash, bmap_hash);
		8504	}
		8505
		8506	isl_map_free(map);
		8507
		8508	return hash;
		8509	}
		8510
		8511	uint32_t isl_set_get_hash(__isl_keep isl_set *set)
		8512	{
		8513	return isl_map_get_hash((isl_map *)set);
		8514	}
		8515
		8516	/* Check if the value for dimension dim is completely determined
		8517	* by the values of the other parameters and variables.
		8518	* That is, check if dimension dim is involved in an equality.
		8519	*/
		8520	int isl_basic_set_dim_is_unique(struct isl_basic_set *bset, unsigned dim)
		8521	{
		8522	int i;
		8523	unsigned nparam;
		8524
		8525	if (!bset)
		8526	return -1;
		8527	nparam = isl_basic_set_n_param(bset);
		8528	for (i = 0; i < bset->n_eq; ++i)
		8529	if (!isl_int_is_zero(bset->eq[i][1 + nparam + dim]))
		8530	return 1;
		8531	return 0;
		8532	}
		8533
		8534	/* Check if the value for dimension dim is completely determined
		8535	* by the values of the other parameters and variables.
		8536	* That is, check if dimension dim is involved in an equality
		8537	* for each of the subsets.
		8538	*/
		8539	int isl_set_dim_is_unique(struct isl_set *set, unsigned dim)
		8540	{
		8541	int i;
		8542
		8543	if (!set)
		8544	return -1;
		8545	for (i = 0; i < set->n; ++i) {
		8546	int unique;
		8547	unique = isl_basic_set_dim_is_unique(set->p[i], dim);
		8548	if (unique != 1)
		8549	return unique;
		8550	}
		8551	return 1;
		8552	}
		8553
		8554	int isl_set_n_basic_set(__isl_keep isl_set *set)
		8555	{
		8556	return set ? set->n : 0;
		8557	}
		8558
		8559	int isl_map_foreach_basic_map(__isl_keep isl_map *map,
		8560	int (*fn)(__isl_take isl_basic_map *bmap, void *user), void *user)
		8561	{
		8562	int i;
		8563
		8564	if (!map)
		8565	return -1;
		8566
		8567	for (i = 0; i < map->n; ++i)
		8568	if (fn(isl_basic_map_copy(map->p[i]), user) < 0)
		8569	return -1;
		8570
		8571	return 0;
		8572	}
		8573
		8574	int isl_set_foreach_basic_set(__isl_keep isl_set *set,
		8575	int (*fn)(__isl_take isl_basic_set *bset, void *user), void *user)
		8576	{
		8577	int i;
		8578
		8579	if (!set)
		8580	return -1;
		8581
		8582	for (i = 0; i < set->n; ++i)
		8583	if (fn(isl_basic_set_copy(set->p[i]), user) < 0)
		8584	return -1;
		8585
		8586	return 0;
		8587	}
		8588
		8589	__isl_give isl_basic_set *isl_basic_set_lift(__isl_take isl_basic_set *bset)
		8590	{
		8591	isl_space *dim;
		8592
		8593	if (!bset)
		8594	return NULL;
		8595
		8596	bset = isl_basic_set_cow(bset);
		8597	if (!bset)
		8598	return NULL;
		8599
		8600	dim = isl_basic_set_get_space(bset);
		8601	dim = isl_space_lift(dim, bset->n_div);
		8602	if (!dim)
		8603	goto error;
		8604	isl_space_free(bset->dim);
		8605	bset->dim = dim;
		8606	bset->extra -= bset->n_div;
		8607	bset->n_div = 0;
		8608
		8609	bset = isl_basic_set_finalize(bset);
		8610
		8611	return bset;
		8612	error:
		8613	isl_basic_set_free(bset);
		8614	return NULL;
		8615	}
		8616
		8617	__isl_give isl_set *isl_set_lift(__isl_take isl_set *set)
		8618	{
		8619	int i;
		8620	isl_space *dim;
		8621	unsigned n_div;
		8622
		8623	set = isl_set_align_divs(set);
		8624
		8625	if (!set)
		8626	return NULL;
		8627
		8628	set = isl_set_cow(set);
		8629	if (!set)
		8630	return NULL;
		8631
		8632	n_div = set->p[0]->n_div;
		8633	dim = isl_set_get_space(set);
		8634	dim = isl_space_lift(dim, n_div);
		8635	if (!dim)
		8636	goto error;
		8637	isl_space_free(set->dim);
		8638	set->dim = dim;
		8639
		8640	for (i = 0; i < set->n; ++i) {
		8641	set->p[i] = isl_basic_set_lift(set->p[i]);
		8642	if (!set->p[i])
		8643	goto error;
		8644	}
		8645
		8646	return set;
		8647	error:
		8648	isl_set_free(set);
		8649	return NULL;
		8650	}
		8651
		8652	__isl_give isl_map *isl_set_lifting(__isl_take isl_set *set)
		8653	{
		8654	isl_space *dim;
		8655	struct isl_basic_map *bmap;
		8656	unsigned n_set;
		8657	unsigned n_div;
		8658	unsigned n_param;
		8659	unsigned total;
		8660	int i, k, l;
		8661
		8662	set = isl_set_align_divs(set);
		8663
		8664	if (!set)
		8665	return NULL;
		8666
		8667	dim = isl_set_get_space(set);
		8668	if (set->n == 0 || set->p[0]->n_div == 0) {
		8669	isl_set_free(set);
		8670	return isl_map_identity(isl_space_map_from_set(dim));
		8671	}
		8672
		8673	n_div = set->p[0]->n_div;
		8674	dim = isl_space_map_from_set(dim);
		8675	n_param = isl_space_dim(dim, isl_dim_param);
		8676	n_set = isl_space_dim(dim, isl_dim_in);
		8677	dim = isl_space_extend(dim, n_param, n_set, n_set + n_div);
		8678	bmap = isl_basic_map_alloc_space(dim, 0, n_set, 2 * n_div);
		8679	for (i = 0; i < n_set; ++i)
		8680	bmap = var_equal(bmap, i);
		8681
		8682	total = n_param + n_set + n_set + n_div;
		8683	for (i = 0; i < n_div; ++i) {
		8684	k = isl_basic_map_alloc_inequality(bmap);
		8685	if (k < 0)
		8686	goto error;
		8687	isl_seq_cpy(bmap->ineq[k], set->p[0]->div[i]+1, 1+n_param);
		8688	isl_seq_clr(bmap->ineq[k]+1+n_param, n_set);
		8689	isl_seq_cpy(bmap->ineq[k]+1+n_param+n_set,
		8690	set->p[0]->div[i]+1+1+n_param, n_set + n_div);
		8691	isl_int_neg(bmap->ineq[k][1+n_param+n_set+n_set+i],
		8692	set->p[0]->div[i][0]);
		8693
		8694	l = isl_basic_map_alloc_inequality(bmap);
		8695	if (l < 0)
		8696	goto error;
		8697	isl_seq_neg(bmap->ineq[l], bmap->ineq[k], 1 + total);
		8698	isl_int_add(bmap->ineq[l][0], bmap->ineq[l][0],
		8699	set->p[0]->div[i][0]);
		8700	isl_int_sub_ui(bmap->ineq[l][0], bmap->ineq[l][0], 1);
		8701	}
		8702
		8703	isl_set_free(set);
		8704	bmap = isl_basic_map_simplify(bmap);
		8705	bmap = isl_basic_map_finalize(bmap);
		8706	return isl_map_from_basic_map(bmap);
		8707	error:
		8708	isl_set_free(set);
		8709	isl_basic_map_free(bmap);
		8710	return NULL;
		8711	}
		8712
		8713	int isl_basic_set_size(__isl_keep isl_basic_set *bset)
		8714	{
		8715	unsigned dim;
		8716	int size = 0;
		8717
		8718	if (!bset)
		8719	return -1;
		8720
		8721	dim = isl_basic_set_total_dim(bset);
		8722	size += bset->n_eq * (1 + dim);
		8723	size += bset->n_ineq * (1 + dim);
		8724	size += bset->n_div * (2 + dim);
		8725
		8726	return size;
		8727	}
		8728
		8729	int isl_set_size(__isl_keep isl_set *set)
		8730	{
		8731	int i;
		8732	int size = 0;
		8733
		8734	if (!set)
		8735	return -1;
		8736
		8737	for (i = 0; i < set->n; ++i)
		8738	size += isl_basic_set_size(set->p[i]);
		8739
		8740	return size;
		8741	}
		8742
		8743	/* Check if there is any lower bound (if lower == 0) and/or upper
		8744	* bound (if upper == 0) on the specified dim.
		8745	*/
		8746	static int basic_map_dim_is_bounded(__isl_keep isl_basic_map *bmap,
		8747	enum isl_dim_type type, unsigned pos, int lower, int upper)
		8748	{
		8749	int i;
		8750
		8751	if (!bmap)
		8752	return -1;
		8753
		8754	isl_assert(bmap->ctx, pos < isl_basic_map_dim(bmap, type), return -1);
		8755
		8756	pos += isl_basic_map_offset(bmap, type);
		8757
		8758	for (i = 0; i < bmap->n_div; ++i) {
		8759	if (isl_int_is_zero(bmap->div[i][0]))
		8760	continue;
		8761	if (!isl_int_is_zero(bmap->div[i][1 + pos]))
		8762	return 1;
		8763	}
		8764
		8765	for (i = 0; i < bmap->n_eq; ++i)
		8766	if (!isl_int_is_zero(bmap->eq[i][pos]))
		8767	return 1;
		8768
		8769	for (i = 0; i < bmap->n_ineq; ++i) {
		8770	int sgn = isl_int_sgn(bmap->ineq[i][pos]);
		8771	if (sgn > 0)
		8772	lower = 1;
		8773	if (sgn < 0)
		8774	upper = 1;
		8775	}
		8776
		8777	return lower && upper;
		8778	}
		8779
		8780	int isl_basic_map_dim_is_bounded(__isl_keep isl_basic_map *bmap,
		8781	enum isl_dim_type type, unsigned pos)
		8782	{
		8783	return basic_map_dim_is_bounded(bmap, type, pos, 0, 0);
		8784	}
		8785
		8786	int isl_basic_map_dim_has_lower_bound(__isl_keep isl_basic_map *bmap,
		8787	enum isl_dim_type type, unsigned pos)
		8788	{
		8789	return basic_map_dim_is_bounded(bmap, type, pos, 0, 1);
		8790	}
		8791
		8792	int isl_basic_map_dim_has_upper_bound(__isl_keep isl_basic_map *bmap,
		8793	enum isl_dim_type type, unsigned pos)
		8794	{
		8795	return basic_map_dim_is_bounded(bmap, type, pos, 1, 0);
		8796	}
		8797
		8798	int isl_map_dim_is_bounded(__isl_keep isl_map *map,
		8799	enum isl_dim_type type, unsigned pos)
		8800	{
		8801	int i;
		8802
		8803	if (!map)
		8804	return -1;
		8805
		8806	for (i = 0; i < map->n; ++i) {
		8807	int bounded;
		8808	bounded = isl_basic_map_dim_is_bounded(map->p[i], type, pos);
		8809	if (bounded < 0 || !bounded)
		8810	return bounded;
		8811	}
		8812
		8813	return 1;
		8814	}
		8815
		8816	/* Return 1 if the specified dim is involved in both an upper bound
		8817	* and a lower bound.
		8818	*/
		8819	int isl_set_dim_is_bounded(__isl_keep isl_set *set,
		8820	enum isl_dim_type type, unsigned pos)
		8821	{
		8822	return isl_map_dim_is_bounded((isl_map *)set, type, pos);
		8823	}
		8824
		8825	static int has_bound(__isl_keep isl_map *map,
		8826	enum isl_dim_type type, unsigned pos,
		8827	int (*fn)(__isl_keep isl_basic_map *bmap,
		8828	enum isl_dim_type type, unsigned pos))
		8829	{
		8830	int i;
		8831
		8832	if (!map)
		8833	return -1;
		8834
		8835	for (i = 0; i < map->n; ++i) {
		8836	int bounded;
		8837	bounded = fn(map->p[i], type, pos);
		8838	if (bounded < 0 || bounded)
		8839	return bounded;
		8840	}
		8841
		8842	return 0;
		8843	}
		8844
		8845	/* Return 1 if the specified dim is involved in any lower bound.
		8846	*/
		8847	int isl_set_dim_has_lower_bound(__isl_keep isl_set *set,
		8848	enum isl_dim_type type, unsigned pos)
		8849	{
		8850	return has_bound(set, type, pos, &isl_basic_map_dim_has_lower_bound);
		8851	}
		8852
		8853	/* Return 1 if the specified dim is involved in any upper bound.
		8854	*/
		8855	int isl_set_dim_has_upper_bound(__isl_keep isl_set *set,
		8856	enum isl_dim_type type, unsigned pos)
		8857	{
		8858	return has_bound(set, type, pos, &isl_basic_map_dim_has_upper_bound);
		8859	}
		8860
		8861	/* For each of the "n" variables starting at "first", determine
		8862	* the sign of the variable and put the results in the first "n"
		8863	* elements of the array "signs".
		8864	* Sign
		8865	* 1 means that the variable is non-negative
		8866	* -1 means that the variable is non-positive
		8867	* 0 means the variable attains both positive and negative values.
		8868	*/
		8869	int isl_basic_set_vars_get_sign(__isl_keep isl_basic_set *bset,
		8870	unsigned first, unsigned n, int *signs)
		8871	{
		8872	isl_vec *bound = NULL;
		8873	struct isl_tab *tab = NULL;
		8874	struct isl_tab_undo *snap;
		8875	int i;
		8876
		8877	if (!bset || !signs)
		8878	return -1;
		8879
		8880	bound = isl_vec_alloc(bset->ctx, 1 + isl_basic_set_total_dim(bset));
		8881	tab = isl_tab_from_basic_set(bset, 0);
		8882	if (!bound || !tab)
		8883	goto error;
		8884
		8885	isl_seq_clr(bound->el, bound->size);
		8886	isl_int_set_si(bound->el[0], -1);
		8887
		8888	snap = isl_tab_snap(tab);
		8889	for (i = 0; i < n; ++i) {
		8890	int empty;
		8891
		8892	isl_int_set_si(bound->el[1 + first + i], -1);
		8893	if (isl_tab_add_ineq(tab, bound->el) < 0)
		8894	goto error;
		8895	empty = tab->empty;
		8896	isl_int_set_si(bound->el[1 + first + i], 0);
		8897	if (isl_tab_rollback(tab, snap) < 0)
		8898	goto error;
		8899
		8900	if (empty) {
		8901	signs[i] = 1;
		8902	continue;
		8903	}
		8904
		8905	isl_int_set_si(bound->el[1 + first + i], 1);
		8906	if (isl_tab_add_ineq(tab, bound->el) < 0)
		8907	goto error;
		8908	empty = tab->empty;
		8909	isl_int_set_si(bound->el[1 + first + i], 0);
		8910	if (isl_tab_rollback(tab, snap) < 0)
		8911	goto error;
		8912
		8913	signs[i] = empty ? -1 : 0;
		8914	}
		8915
		8916	isl_tab_free(tab);
		8917	isl_vec_free(bound);
		8918	return 0;
		8919	error:
		8920	isl_tab_free(tab);
		8921	isl_vec_free(bound);
		8922	return -1;
		8923	}
		8924
		8925	int isl_basic_set_dims_get_sign(__isl_keep isl_basic_set *bset,
		8926	enum isl_dim_type type, unsigned first, unsigned n, int *signs)
		8927	{
		8928	if (!bset || !signs)
		8929	return -1;
		8930	isl_assert(bset->ctx, first + n <= isl_basic_set_dim(bset, type),
		8931	return -1);
		8932
		8933	first += pos(bset->dim, type) - 1;
		8934	return isl_basic_set_vars_get_sign(bset, first, n, signs);
		8935	}
		8936
		8937	/* Check if the given basic map is obviously single-valued.
		8938	* In particular, for each output dimension, check that there is
		8939	* an equality that defines the output dimension in terms of
		8940	* earlier dimensions.
		8941	*/
		8942	int isl_basic_map_plain_is_single_valued(__isl_keep isl_basic_map *bmap)
		8943	{
		8944	int i, j;
		8945	unsigned total;
		8946	unsigned n_out;
		8947	unsigned o_out;
		8948
		8949	if (!bmap)
		8950	return -1;
		8951
		8952	total = 1 + isl_basic_map_total_dim(bmap);
		8953	n_out = isl_basic_map_dim(bmap, isl_dim_out);
		8954	o_out = isl_basic_map_offset(bmap, isl_dim_out);
		8955
		8956	for (i = 0; i < n_out; ++i) {
		8957	for (j = 0; j < bmap->n_eq; ++j) {
		8958	if (isl_int_is_zero(bmap->eq[j][o_out + i]))
		8959	continue;
		8960	if (isl_seq_first_non_zero(bmap->eq[j] + o_out + i + 1,
		8961	total - (o_out + i + 1)) == -1)
		8962	break;
		8963	}
		8964	if (j >= bmap->n_eq)
		8965	return 0;
		8966	}
		8967
		8968	return 1;
		8969	}
		8970
		8971	/* Check if the given basic map is single-valued.
		8972	* We simply compute
		8973	*
		8974	* M \circ M^-1
		8975	*
		8976	* and check if the result is a subset of the identity mapping.
		8977	*/
		8978	int isl_basic_map_is_single_valued(__isl_keep isl_basic_map *bmap)
		8979	{
		8980	isl_space *space;
		8981	isl_basic_map *test;
		8982	isl_basic_map *id;
		8983	int sv;
		8984
		8985	sv = isl_basic_map_plain_is_single_valued(bmap);
		8986	if (sv < 0 || sv)
		8987	return sv;
		8988
		8989	test = isl_basic_map_reverse(isl_basic_map_copy(bmap));
		8990	test = isl_basic_map_apply_range(test, isl_basic_map_copy(bmap));
		8991
		8992	space = isl_basic_map_get_space(bmap);
		8993	space = isl_space_map_from_set(isl_space_range(space));
		8994	id = isl_basic_map_identity(space);
		8995
		8996	sv = isl_basic_map_is_subset(test, id);
		8997
		8998	isl_basic_map_free(test);
		8999	isl_basic_map_free(id);
		9000
		9001	return sv;
		9002	}
		9003
		9004	/* Check if the given map is obviously single-valued.
		9005	*/
		9006	int isl_map_plain_is_single_valued(__isl_keep isl_map *map)
		9007	{
		9008	if (!map)
		9009	return -1;
		9010	if (map->n == 0)
		9011	return 1;
		9012	if (map->n >= 2)
		9013	return 0;
		9014
		9015	return isl_basic_map_plain_is_single_valued(map->p[0]);
		9016	}
		9017
		9018	/* Check if the given map is single-valued.
		9019	* We simply compute
		9020	*
		9021	* M \circ M^-1
		9022	*
		9023	* and check if the result is a subset of the identity mapping.
		9024	*/
		9025	int isl_map_is_single_valued(__isl_keep isl_map *map)
		9026	{
		9027	isl_space *dim;
		9028	isl_map *test;
		9029	isl_map *id;
		9030	int sv;
		9031
		9032	sv = isl_map_plain_is_single_valued(map);
		9033	if (sv < 0 || sv)
		9034	return sv;
		9035
		9036	test = isl_map_reverse(isl_map_copy(map));
		9037	test = isl_map_apply_range(test, isl_map_copy(map));
		9038
		9039	dim = isl_space_map_from_set(isl_space_range(isl_map_get_space(map)));
		9040	id = isl_map_identity(dim);
		9041
		9042	sv = isl_map_is_subset(test, id);
		9043
		9044	isl_map_free(test);
		9045	isl_map_free(id);
		9046
		9047	return sv;
		9048	}
		9049
		9050	int isl_map_is_injective(__isl_keep isl_map *map)
		9051	{
		9052	int in;
		9053
		9054	map = isl_map_copy(map);
		9055	map = isl_map_reverse(map);
		9056	in = isl_map_is_single_valued(map);
		9057	isl_map_free(map);
		9058
		9059	return in;
		9060	}
		9061
		9062	/* Check if the given map is obviously injective.
		9063	*/
		9064	int isl_map_plain_is_injective(__isl_keep isl_map *map)
		9065	{
		9066	int in;
		9067
		9068	map = isl_map_copy(map);
		9069	map = isl_map_reverse(map);
		9070	in = isl_map_plain_is_single_valued(map);
		9071	isl_map_free(map);
		9072
		9073	return in;
		9074	}
		9075
		9076	int isl_map_is_bijective(__isl_keep isl_map *map)
		9077	{
		9078	int sv;
		9079
		9080	sv = isl_map_is_single_valued(map);
		9081	if (sv < 0 || !sv)
		9082	return sv;
		9083
		9084	return isl_map_is_injective(map);
		9085	}
		9086
		9087	int isl_set_is_singleton(__isl_keep isl_set *set)
		9088	{
		9089	return isl_map_is_single_valued((isl_map *)set);
		9090	}
		9091
		9092	int isl_map_is_translation(__isl_keep isl_map *map)
		9093	{
		9094	int ok;
		9095	isl_set *delta;
		9096
		9097	delta = isl_map_deltas(isl_map_copy(map));
		9098	ok = isl_set_is_singleton(delta);
		9099	isl_set_free(delta);
		9100
		9101	return ok;
		9102	}
		9103
		9104	static int unique(isl_int *p, unsigned pos, unsigned len)
		9105	{
		9106	if (isl_seq_first_non_zero(p, pos) != -1)
		9107	return 0;
		9108	if (isl_seq_first_non_zero(p + pos + 1, len - pos - 1) != -1)
		9109	return 0;
		9110	return 1;
		9111	}
		9112
		9113	int isl_basic_set_is_box(__isl_keep isl_basic_set *bset)
		9114	{
		9115	int i, j;
		9116	unsigned nvar;
		9117	unsigned ovar;
		9118
		9119	if (!bset)
		9120	return -1;
		9121
		9122	if (isl_basic_set_dim(bset, isl_dim_div) != 0)
		9123	return 0;
		9124
		9125	nvar = isl_basic_set_dim(bset, isl_dim_set);
		9126	ovar = isl_space_offset(bset->dim, isl_dim_set);
		9127	for (j = 0; j < nvar; ++j) {
		9128	int lower = 0, upper = 0;
		9129	for (i = 0; i < bset->n_eq; ++i) {
		9130	if (isl_int_is_zero(bset->eq[i][1 + ovar + j]))
		9131	continue;
		9132	if (!unique(bset->eq[i] + 1 + ovar, j, nvar))
		9133	return 0;
		9134	break;
		9135	}
		9136	if (i < bset->n_eq)
		9137	continue;
		9138	for (i = 0; i < bset->n_ineq; ++i) {
		9139	if (isl_int_is_zero(bset->ineq[i][1 + ovar + j]))
		9140	continue;
		9141	if (!unique(bset->ineq[i] + 1 + ovar, j, nvar))
		9142	return 0;
		9143	if (isl_int_is_pos(bset->ineq[i][1 + ovar + j]))
		9144	lower = 1;
		9145	else
		9146	upper = 1;
		9147	}
		9148	if (!lower || !upper)
		9149	return 0;
		9150	}
		9151
		9152	return 1;
		9153	}
		9154
		9155	int isl_set_is_box(__isl_keep isl_set *set)
		9156	{
		9157	if (!set)
		9158	return -1;
		9159	if (set->n != 1)
		9160	return 0;
		9161
		9162	return isl_basic_set_is_box(set->p[0]);
		9163	}
		9164
		9165	int isl_basic_set_is_wrapping(__isl_keep isl_basic_set *bset)
		9166	{
		9167	if (!bset)
		9168	return -1;
		9169
		9170	return isl_space_is_wrapping(bset->dim);
		9171	}
		9172
		9173	int isl_set_is_wrapping(__isl_keep isl_set *set)
		9174	{
		9175	if (!set)
		9176	return -1;
		9177
		9178	return isl_space_is_wrapping(set->dim);
		9179	}
		9180
		9181	__isl_give isl_basic_set *isl_basic_map_wrap(__isl_take isl_basic_map *bmap)
		9182	{
		9183	bmap = isl_basic_map_cow(bmap);
		9184	if (!bmap)
		9185	return NULL;
		9186
		9187	bmap->dim = isl_space_wrap(bmap->dim);
		9188	if (!bmap->dim)
		9189	goto error;
		9190
		9191	bmap = isl_basic_map_finalize(bmap);
		9192
		9193	return (isl_basic_set *)bmap;
		9194	error:
		9195	isl_basic_map_free(bmap);
		9196	return NULL;
		9197	}
		9198
		9199	__isl_give isl_set *isl_map_wrap(__isl_take isl_map *map)
		9200	{
		9201	int i;
		9202
		9203	map = isl_map_cow(map);
		9204	if (!map)
		9205	return NULL;
		9206
		9207	for (i = 0; i < map->n; ++i) {
		9208	map->p[i] = (isl_basic_map *)isl_basic_map_wrap(map->p[i]);
		9209	if (!map->p[i])
		9210	goto error;
		9211	}
		9212	map->dim = isl_space_wrap(map->dim);
		9213	if (!map->dim)
		9214	goto error;
		9215
		9216	return (isl_set *)map;
		9217	error:
		9218	isl_map_free(map);
		9219	return NULL;
		9220	}
		9221
		9222	__isl_give isl_basic_map *isl_basic_set_unwrap(__isl_take isl_basic_set *bset)
		9223	{
		9224	bset = isl_basic_set_cow(bset);
		9225	if (!bset)
		9226	return NULL;
		9227
		9228	bset->dim = isl_space_unwrap(bset->dim);
		9229	if (!bset->dim)
		9230	goto error;
		9231
		9232	bset = isl_basic_set_finalize(bset);
		9233
		9234	return (isl_basic_map *)bset;
		9235	error:
		9236	isl_basic_set_free(bset);
		9237	return NULL;
		9238	}
		9239
		9240	__isl_give isl_map *isl_set_unwrap(__isl_take isl_set *set)
		9241	{
		9242	int i;
		9243
		9244	if (!set)
		9245	return NULL;
		9246
		9247	if (!isl_set_is_wrapping(set))
		9248	isl_die(set->ctx, isl_error_invalid, "not a wrapping set",
		9249	goto error);
		9250
		9251	set = isl_set_cow(set);
		9252	if (!set)
		9253	return NULL;
		9254
		9255	for (i = 0; i < set->n; ++i) {
		9256	set->p[i] = (isl_basic_set *)isl_basic_set_unwrap(set->p[i]);
		9257	if (!set->p[i])
		9258	goto error;
		9259	}
		9260
		9261	set->dim = isl_space_unwrap(set->dim);
		9262	if (!set->dim)
		9263	goto error;
		9264
		9265	return (isl_map *)set;
		9266	error:
		9267	isl_set_free(set);
		9268	return NULL;
		9269	}
		9270
		9271	__isl_give isl_basic_map *isl_basic_map_reset(__isl_take isl_basic_map *bmap,
		9272	enum isl_dim_type type)
		9273	{
		9274	if (!bmap)
		9275	return NULL;
		9276
		9277	if (!isl_space_is_named_or_nested(bmap->dim, type))
		9278	return bmap;
		9279
		9280	bmap = isl_basic_map_cow(bmap);
		9281	if (!bmap)
		9282	return NULL;
		9283
		9284	bmap->dim = isl_space_reset(bmap->dim, type);
		9285	if (!bmap->dim)
		9286	goto error;
		9287
		9288	bmap = isl_basic_map_finalize(bmap);
		9289
		9290	return bmap;
		9291	error:
		9292	isl_basic_map_free(bmap);
		9293	return NULL;
		9294	}
		9295
		9296	__isl_give isl_map *isl_map_reset(__isl_take isl_map *map,
		9297	enum isl_dim_type type)
		9298	{
		9299	int i;
		9300
		9301	if (!map)
		9302	return NULL;
		9303
		9304	if (!isl_space_is_named_or_nested(map->dim, type))
		9305	return map;
		9306
		9307	map = isl_map_cow(map);
		9308	if (!map)
		9309	return NULL;
		9310
		9311	for (i = 0; i < map->n; ++i) {
		9312	map->p[i] = isl_basic_map_reset(map->p[i], type);
		9313	if (!map->p[i])
		9314	goto error;
		9315	}
		9316	map->dim = isl_space_reset(map->dim, type);
		9317	if (!map->dim)
		9318	goto error;
		9319
		9320	return map;
		9321	error:
		9322	isl_map_free(map);
		9323	return NULL;
		9324	}
		9325
		9326	__isl_give isl_basic_map *isl_basic_map_flatten(__isl_take isl_basic_map *bmap)
		9327	{
		9328	if (!bmap)
		9329	return NULL;
		9330
		9331	if (!bmap->dim->nested[0] && !bmap->dim->nested[1])
		9332	return bmap;
		9333
		9334	bmap = isl_basic_map_cow(bmap);
		9335	if (!bmap)
		9336	return NULL;
		9337
		9338	bmap->dim = isl_space_flatten(bmap->dim);
		9339	if (!bmap->dim)
		9340	goto error;
		9341
		9342	bmap = isl_basic_map_finalize(bmap);
		9343
		9344	return bmap;
		9345	error:
		9346	isl_basic_map_free(bmap);
		9347	return NULL;
		9348	}
		9349
		9350	__isl_give isl_basic_set *isl_basic_set_flatten(__isl_take isl_basic_set *bset)
		9351	{
		9352	return (isl_basic_set *)isl_basic_map_flatten((isl_basic_map *)bset);
		9353	}
		9354
		9355	__isl_give isl_basic_map *isl_basic_map_flatten_domain(
		9356	__isl_take isl_basic_map *bmap)
		9357	{
		9358	if (!bmap)
		9359	return NULL;
		9360
		9361	if (!bmap->dim->nested[0])
		9362	return bmap;
		9363
		9364	bmap = isl_basic_map_cow(bmap);
		9365	if (!bmap)
		9366	return NULL;
		9367
		9368	bmap->dim = isl_space_flatten_domain(bmap->dim);
		9369	if (!bmap->dim)
		9370	goto error;
		9371
		9372	bmap = isl_basic_map_finalize(bmap);
		9373
		9374	return bmap;
		9375	error:
		9376	isl_basic_map_free(bmap);
		9377	return NULL;
		9378	}
		9379
		9380	__isl_give isl_basic_map *isl_basic_map_flatten_range(
		9381	__isl_take isl_basic_map *bmap)
		9382	{
		9383	if (!bmap)
		9384	return NULL;
		9385
		9386	if (!bmap->dim->nested[1])
		9387	return bmap;
		9388
		9389	bmap = isl_basic_map_cow(bmap);
		9390	if (!bmap)
		9391	return NULL;
		9392
		9393	bmap->dim = isl_space_flatten_range(bmap->dim);
		9394	if (!bmap->dim)
		9395	goto error;
		9396
		9397	bmap = isl_basic_map_finalize(bmap);
		9398
		9399	return bmap;
		9400	error:
		9401	isl_basic_map_free(bmap);
		9402	return NULL;
		9403	}
		9404
		9405	__isl_give isl_map *isl_map_flatten(__isl_take isl_map *map)
		9406	{
		9407	int i;
		9408
		9409	if (!map)
		9410	return NULL;
		9411
		9412	if (!map->dim->nested[0] && !map->dim->nested[1])
		9413	return map;
		9414
		9415	map = isl_map_cow(map);
		9416	if (!map)
		9417	return NULL;
		9418
		9419	for (i = 0; i < map->n; ++i) {
		9420	map->p[i] = isl_basic_map_flatten(map->p[i]);
		9421	if (!map->p[i])
		9422	goto error;
		9423	}
		9424	map->dim = isl_space_flatten(map->dim);
		9425	if (!map->dim)
		9426	goto error;
		9427
		9428	return map;
		9429	error:
		9430	isl_map_free(map);
		9431	return NULL;
		9432	}
		9433
		9434	__isl_give isl_set *isl_set_flatten(__isl_take isl_set *set)
		9435	{
		9436	return (isl_set *)isl_map_flatten((isl_map *)set);
		9437	}
		9438
		9439	__isl_give isl_map *isl_set_flatten_map(__isl_take isl_set *set)
		9440	{
		9441	isl_space *dim, *flat_dim;
		9442	isl_map *map;
		9443
		9444	dim = isl_set_get_space(set);
		9445	flat_dim = isl_space_flatten(isl_space_copy(dim));
		9446	map = isl_map_identity(isl_space_join(isl_space_reverse(dim), flat_dim));
		9447	map = isl_map_intersect_domain(map, set);
		9448
		9449	return map;
		9450	}
		9451
		9452	__isl_give isl_map *isl_map_flatten_domain(__isl_take isl_map *map)
		9453	{
		9454	int i;
		9455
		9456	if (!map)
		9457	return NULL;
		9458
		9459	if (!map->dim->nested[0])
		9460	return map;
		9461
		9462	map = isl_map_cow(map);
		9463	if (!map)
		9464	return NULL;
		9465
		9466	for (i = 0; i < map->n; ++i) {
		9467	map->p[i] = isl_basic_map_flatten_domain(map->p[i]);
		9468	if (!map->p[i])
		9469	goto error;
		9470	}
		9471	map->dim = isl_space_flatten_domain(map->dim);
		9472	if (!map->dim)
		9473	goto error;
		9474
		9475	return map;
		9476	error:
		9477	isl_map_free(map);
		9478	return NULL;
		9479	}
		9480
		9481	__isl_give isl_map *isl_map_flatten_range(__isl_take isl_map *map)
		9482	{
		9483	int i;
		9484
		9485	if (!map)
		9486	return NULL;
		9487
		9488	if (!map->dim->nested[1])
		9489	return map;
		9490
		9491	map = isl_map_cow(map);
		9492	if (!map)
		9493	return NULL;
		9494
		9495	for (i = 0; i < map->n; ++i) {
		9496	map->p[i] = isl_basic_map_flatten_range(map->p[i]);
		9497	if (!map->p[i])
		9498	goto error;
		9499	}
		9500	map->dim = isl_space_flatten_range(map->dim);
		9501	if (!map->dim)
		9502	goto error;
		9503
		9504	return map;
		9505	error:
		9506	isl_map_free(map);
		9507	return NULL;
		9508	}
		9509
		9510	/* Reorder the dimensions of "bmap" according to the given dim_map
		9511	* and set the dimension specification to "dim".
		9512	*/
		9513	__isl_give isl_basic_map *isl_basic_map_realign(__isl_take isl_basic_map *bmap,
		9514	__isl_take isl_space *dim, __isl_take struct isl_dim_map *dim_map)
		9515	{
		9516	isl_basic_map *res;
		9517	unsigned flags;
		9518
		9519	bmap = isl_basic_map_cow(bmap);
		9520	if (!bmap || !dim || !dim_map)
		9521	goto error;
		9522
		9523	flags = bmap->flags;
		9524	ISL_FL_CLR(flags, ISL_BASIC_MAP_FINAL);
		9525	ISL_FL_CLR(flags, ISL_BASIC_MAP_NORMALIZED);
		9526	ISL_FL_CLR(flags, ISL_BASIC_MAP_NORMALIZED_DIVS);
		9527	res = isl_basic_map_alloc_space(dim,
		9528	bmap->n_div, bmap->n_eq, bmap->n_ineq);
		9529	res = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map);
		9530	if (res)
		9531	res->flags = flags;
		9532	res = isl_basic_map_finalize(res);
		9533	return res;
		9534	error:
		9535	free(dim_map);
		9536	isl_basic_map_free(bmap);
		9537	isl_space_free(dim);
		9538	return NULL;
		9539	}
		9540
		9541	/* Reorder the dimensions of "map" according to given reordering.
		9542	*/
		9543	__isl_give isl_map *isl_map_realign(__isl_take isl_map *map,
		9544	__isl_take isl_reordering *r)
		9545	{
		9546	int i;
		9547	struct isl_dim_map *dim_map;
		9548
		9549	map = isl_map_cow(map);
		9550	dim_map = isl_dim_map_from_reordering(r);
		9551	if (!map || !r || !dim_map)
		9552	goto error;
		9553
		9554	for (i = 0; i < map->n; ++i) {
		9555	struct isl_dim_map *dim_map_i;
		9556
		9557	dim_map_i = isl_dim_map_extend(dim_map, map->p[i]);
		9558
		9559	map->p[i] = isl_basic_map_realign(map->p[i],
		9560	isl_space_copy(r->dim), dim_map_i);
		9561
		9562	if (!map->p[i])
		9563	goto error;
		9564	}
		9565
		9566	map = isl_map_reset_space(map, isl_space_copy(r->dim));
		9567
		9568	isl_reordering_free(r);
		9569	free(dim_map);
		9570	return map;
		9571	error:
		9572	free(dim_map);
		9573	isl_map_free(map);
		9574	isl_reordering_free(r);
		9575	return NULL;
		9576	}
		9577
		9578	__isl_give isl_set *isl_set_realign(__isl_take isl_set *set,
		9579	__isl_take isl_reordering *r)
		9580	{
		9581	return (isl_set *)isl_map_realign((isl_map *)set, r);
		9582	}
		9583
		9584	__isl_give isl_map *isl_map_align_params(__isl_take isl_map *map,
		9585	__isl_take isl_space *model)
		9586	{
		9587	isl_ctx *ctx;
		9588
		9589	if (!map || !model)
		9590	goto error;
		9591
		9592	ctx = isl_space_get_ctx(model);
		9593	if (!isl_space_has_named_params(model))
		9594	isl_die(ctx, isl_error_invalid,
		9595	"model has unnamed parameters", goto error);
		9596	if (!isl_space_has_named_params(map->dim))
		9597	isl_die(ctx, isl_error_invalid,
		9598	"relation has unnamed parameters", goto error);
		9599	if (!isl_space_match(map->dim, isl_dim_param, model, isl_dim_param)) {
		9600	isl_reordering *exp;
		9601
		9602	model = isl_space_drop_dims(model, isl_dim_in,
		9603	0, isl_space_dim(model, isl_dim_in));
		9604	model = isl_space_drop_dims(model, isl_dim_out,
		9605	0, isl_space_dim(model, isl_dim_out));
		9606	exp = isl_parameter_alignment_reordering(map->dim, model);
		9607	exp = isl_reordering_extend_space(exp, isl_map_get_space(map));
		9608	map = isl_map_realign(map, exp);
		9609	}
		9610
		9611	isl_space_free(model);
		9612	return map;
		9613	error:
		9614	isl_space_free(model);
		9615	isl_map_free(map);
		9616	return NULL;
		9617	}
		9618
		9619	__isl_give isl_set *isl_set_align_params(__isl_take isl_set *set,
		9620	__isl_take isl_space *model)
		9621	{
		9622	return isl_map_align_params(set, model);
		9623	}
		9624
		9625	__isl_give isl_mat *isl_basic_map_equalities_matrix(
		9626	__isl_keep isl_basic_map *bmap, enum isl_dim_type c1,
		9627	enum isl_dim_type c2, enum isl_dim_type c3,
		9628	enum isl_dim_type c4, enum isl_dim_type c5)
		9629	{
		9630	enum isl_dim_type c[5] = { c1, c2, c3, c4, c5 };
		9631	struct isl_mat *mat;
		9632	int i, j, k;
		9633	int pos;
		9634
		9635	if (!bmap)
		9636	return NULL;
		9637	mat = isl_mat_alloc(bmap->ctx, bmap->n_eq,
		9638	isl_basic_map_total_dim(bmap) + 1);
		9639	if (!mat)
		9640	return NULL;
		9641	for (i = 0; i < bmap->n_eq; ++i)
		9642	for (j = 0, pos = 0; j < 5; ++j) {
		9643	int off = isl_basic_map_offset(bmap, c[j]);
		9644	for (k = 0; k < isl_basic_map_dim(bmap, c[j]); ++k) {
		9645	isl_int_set(mat->row[i][pos],
		9646	bmap->eq[i][off + k]);
		9647	++pos;
		9648	}
		9649	}
		9650
		9651	return mat;
		9652	}
		9653
		9654	__isl_give isl_mat *isl_basic_map_inequalities_matrix(
		9655	__isl_keep isl_basic_map *bmap, enum isl_dim_type c1,
		9656	enum isl_dim_type c2, enum isl_dim_type c3,
		9657	enum isl_dim_type c4, enum isl_dim_type c5)
		9658	{
		9659	enum isl_dim_type c[5] = { c1, c2, c3, c4, c5 };
		9660	struct isl_mat *mat;
		9661	int i, j, k;
		9662	int pos;
		9663
		9664	if (!bmap)
		9665	return NULL;
		9666	mat = isl_mat_alloc(bmap->ctx, bmap->n_ineq,
		9667	isl_basic_map_total_dim(bmap) + 1);
		9668	if (!mat)
		9669	return NULL;
		9670	for (i = 0; i < bmap->n_ineq; ++i)
		9671	for (j = 0, pos = 0; j < 5; ++j) {
		9672	int off = isl_basic_map_offset(bmap, c[j]);
		9673	for (k = 0; k < isl_basic_map_dim(bmap, c[j]); ++k) {
		9674	isl_int_set(mat->row[i][pos],
		9675	bmap->ineq[i][off + k]);
		9676	++pos;
		9677	}
		9678	}
		9679
		9680	return mat;
		9681	}
		9682
		9683	__isl_give isl_basic_map *isl_basic_map_from_constraint_matrices(
		9684	__isl_take isl_space *dim,
		9685	__isl_take isl_mat *eq, __isl_take isl_mat *ineq, enum isl_dim_type c1,
		9686	enum isl_dim_type c2, enum isl_dim_type c3,
		9687	enum isl_dim_type c4, enum isl_dim_type c5)
		9688	{
		9689	enum isl_dim_type c[5] = { c1, c2, c3, c4, c5 };
		9690	isl_basic_map *bmap;
		9691	unsigned total;
		9692	unsigned extra;
		9693	int i, j, k, l;
		9694	int pos;
		9695
		9696	if (!dim || !eq || !ineq)
		9697	goto error;
		9698
		9699	if (eq->n_col != ineq->n_col)
		9700	isl_die(dim->ctx, isl_error_invalid,
		9701	"equalities and inequalities matrices should have "
		9702	"same number of columns", goto error);
		9703
		9704	total = 1 + isl_space_dim(dim, isl_dim_all);
		9705
		9706	if (eq->n_col < total)
		9707	isl_die(dim->ctx, isl_error_invalid,
		9708	"number of columns too small", goto error);
		9709
		9710	extra = eq->n_col - total;
		9711
		9712	bmap = isl_basic_map_alloc_space(isl_space_copy(dim), extra,
		9713	eq->n_row, ineq->n_row);
		9714	if (!bmap)
		9715	goto error;
		9716	for (i = 0; i < extra; ++i) {
		9717	k = isl_basic_map_alloc_div(bmap);
		9718	if (k < 0)
		9719	goto error;
		9720	isl_int_set_si(bmap->div[k][0], 0);
		9721	}
		9722	for (i = 0; i < eq->n_row; ++i) {
		9723	l = isl_basic_map_alloc_equality(bmap);
		9724	if (l < 0)
		9725	goto error;
		9726	for (j = 0, pos = 0; j < 5; ++j) {
		9727	int off = isl_basic_map_offset(bmap, c[j]);
		9728	for (k = 0; k < isl_basic_map_dim(bmap, c[j]); ++k) {
		9729	isl_int_set(bmap->eq[l][off + k],
		9730	eq->row[i][pos]);
		9731	++pos;
		9732	}
		9733	}
		9734	}
		9735	for (i = 0; i < ineq->n_row; ++i) {
		9736	l = isl_basic_map_alloc_inequality(bmap);
		9737	if (l < 0)
		9738	goto error;
		9739	for (j = 0, pos = 0; j < 5; ++j) {
		9740	int off = isl_basic_map_offset(bmap, c[j]);
		9741	for (k = 0; k < isl_basic_map_dim(bmap, c[j]); ++k) {
		9742	isl_int_set(bmap->ineq[l][off + k],
		9743	ineq->row[i][pos]);
		9744	++pos;
		9745	}
		9746	}
		9747	}
		9748
		9749	isl_space_free(dim);
		9750	isl_mat_free(eq);
		9751	isl_mat_free(ineq);
		9752
		9753	return bmap;
		9754	error:
		9755	isl_space_free(dim);
		9756	isl_mat_free(eq);
		9757	isl_mat_free(ineq);
		9758	return NULL;
		9759	}
		9760
		9761	__isl_give isl_mat *isl_basic_set_equalities_matrix(
		9762	__isl_keep isl_basic_set *bset, enum isl_dim_type c1,
		9763	enum isl_dim_type c2, enum isl_dim_type c3, enum isl_dim_type c4)
		9764	{
		9765	return isl_basic_map_equalities_matrix((isl_basic_map *)bset,
		9766	c1, c2, c3, c4, isl_dim_in);
		9767	}
		9768
		9769	__isl_give isl_mat *isl_basic_set_inequalities_matrix(
		9770	__isl_keep isl_basic_set *bset, enum isl_dim_type c1,
		9771	enum isl_dim_type c2, enum isl_dim_type c3, enum isl_dim_type c4)
		9772	{
		9773	return isl_basic_map_inequalities_matrix((isl_basic_map *)bset,
		9774	c1, c2, c3, c4, isl_dim_in);
		9775	}
		9776
		9777	__isl_give isl_basic_set *isl_basic_set_from_constraint_matrices(
		9778	__isl_take isl_space *dim,
		9779	__isl_take isl_mat *eq, __isl_take isl_mat *ineq, enum isl_dim_type c1,
		9780	enum isl_dim_type c2, enum isl_dim_type c3, enum isl_dim_type c4)
		9781	{
		9782	return (isl_basic_set*)
		9783	isl_basic_map_from_constraint_matrices(dim, eq, ineq,
		9784	c1, c2, c3, c4, isl_dim_in);
		9785	}
		9786
		9787	int isl_basic_map_can_zip(__isl_keep isl_basic_map *bmap)
		9788	{
		9789	if (!bmap)
		9790	return -1;
		9791
		9792	return isl_space_can_zip(bmap->dim);
		9793	}
		9794
		9795	int isl_map_can_zip(__isl_keep isl_map *map)
		9796	{
		9797	if (!map)
		9798	return -1;
		9799
		9800	return isl_space_can_zip(map->dim);
		9801	}
		9802
		9803	/* Given a basic map (A -> B) -> (C -> D), return the corresponding basic map
		9804	* (A -> C) -> (B -> D).
		9805	*/
		9806	__isl_give isl_basic_map *isl_basic_map_zip(__isl_take isl_basic_map *bmap)
		9807	{
		9808	unsigned pos;
		9809	unsigned n1;
		9810	unsigned n2;
		9811
		9812	if (!bmap)
		9813	return NULL;
		9814
		9815	if (!isl_basic_map_can_zip(bmap))
		9816	isl_die(bmap->ctx, isl_error_invalid,
		9817	"basic map cannot be zipped", goto error);
		9818	pos = isl_basic_map_offset(bmap, isl_dim_in) +
		9819	isl_space_dim(bmap->dim->nested[0], isl_dim_in);
		9820	n1 = isl_space_dim(bmap->dim->nested[0], isl_dim_out);
		9821	n2 = isl_space_dim(bmap->dim->nested[1], isl_dim_in);
		9822	bmap = isl_basic_map_cow(bmap);
		9823	bmap = isl_basic_map_swap_vars(bmap, pos, n1, n2);
		9824	if (!bmap)
		9825	return NULL;
		9826	bmap->dim = isl_space_zip(bmap->dim);
		9827	if (!bmap->dim)
		9828	goto error;
		9829	return bmap;
		9830	error:
		9831	isl_basic_map_free(bmap);
		9832	return NULL;
		9833	}
		9834
		9835	/* Given a map (A -> B) -> (C -> D), return the corresponding map
		9836	* (A -> C) -> (B -> D).
		9837	*/
		9838	__isl_give isl_map *isl_map_zip(__isl_take isl_map *map)
		9839	{
		9840	int i;
		9841
		9842	if (!map)
		9843	return NULL;
		9844
		9845	if (!isl_map_can_zip(map))
		9846	isl_die(map->ctx, isl_error_invalid, "map cannot be zipped",
		9847	goto error);
		9848
		9849	map = isl_map_cow(map);
		9850	if (!map)
		9851	return NULL;
		9852
		9853	for (i = 0; i < map->n; ++i) {
		9854	map->p[i] = isl_basic_map_zip(map->p[i]);
		9855	if (!map->p[i])
		9856	goto error;
		9857	}
		9858
		9859	map->dim = isl_space_zip(map->dim);
		9860	if (!map->dim)
		9861	goto error;
		9862
		9863	return map;
		9864	error:
		9865	isl_map_free(map);
		9866	return NULL;
		9867	}
		9868
		9869	/* Can we apply isl_basic_map_curry to "bmap"?
		9870	* That is, does it have a nested relation in its domain?
		9871	*/
		9872	int isl_basic_map_can_curry(__isl_keep isl_basic_map *bmap)
		9873	{
		9874	if (!bmap)
		9875	return -1;
		9876
		9877	return isl_space_can_curry(bmap->dim);
		9878	}
		9879
		9880	/* Can we apply isl_map_curry to "map"?
		9881	* That is, does it have a nested relation in its domain?
		9882	*/
		9883	int isl_map_can_curry(__isl_keep isl_map *map)
		9884	{
		9885	if (!map)
		9886	return -1;
		9887
		9888	return isl_space_can_curry(map->dim);
		9889	}
		9890
		9891	/* Given a basic map (A -> B) -> C, return the corresponding basic map
		9892	* A -> (B -> C).
		9893	*/
		9894	__isl_give isl_basic_map *isl_basic_map_curry(__isl_take isl_basic_map *bmap)
		9895	{
		9896
		9897	if (!bmap)
		9898	return NULL;
		9899
		9900	if (!isl_basic_map_can_curry(bmap))
		9901	isl_die(bmap->ctx, isl_error_invalid,
		9902	"basic map cannot be curried", goto error);
		9903	bmap->dim = isl_space_curry(bmap->dim);
		9904	if (!bmap->dim)
		9905	goto error;
		9906	return bmap;
		9907	error:
		9908	isl_basic_map_free(bmap);
		9909	return NULL;
		9910	}
		9911
		9912	/* Given a map (A -> B) -> C, return the corresponding map
		9913	* A -> (B -> C).
		9914	*/
		9915	__isl_give isl_map *isl_map_curry(__isl_take isl_map *map)
		9916	{
		9917	int i;
		9918
		9919	if (!map)
		9920	return NULL;
		9921
		9922	if (!isl_map_can_curry(map))
		9923	isl_die(map->ctx, isl_error_invalid, "map cannot be curried",
		9924	goto error);
		9925
		9926	map = isl_map_cow(map);
		9927	if (!map)
		9928	return NULL;
		9929
		9930	for (i = 0; i < map->n; ++i) {
		9931	map->p[i] = isl_basic_map_curry(map->p[i]);
		9932	if (!map->p[i])
		9933	goto error;
		9934	}
		9935
		9936	map->dim = isl_space_curry(map->dim);
		9937	if (!map->dim)
		9938	goto error;
		9939
		9940	return map;
		9941	error:
		9942	isl_map_free(map);
		9943	return NULL;
		9944	}
		9945
		9946	/* Construct a basic map mapping the domain of the affine expression
		9947	* to a one-dimensional range prescribed by the affine expression.
		9948	*/
		9949	__isl_give isl_basic_map *isl_basic_map_from_aff(__isl_take isl_aff *aff)
		9950	{
		9951	int k;
		9952	int pos;
		9953	isl_local_space *ls;
		9954	isl_basic_map *bmap;
		9955
		9956	if (!aff)
		9957	return NULL;
		9958
		9959	ls = isl_aff_get_local_space(aff);
		9960	bmap = isl_basic_map_from_local_space(ls);
		9961	bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
		9962	k = isl_basic_map_alloc_equality(bmap);
		9963	if (k < 0)
		9964	goto error;
		9965
		9966	pos = isl_basic_map_offset(bmap, isl_dim_out);
		9967	isl_seq_cpy(bmap->eq[k], aff->v->el + 1, pos);
		9968	isl_int_neg(bmap->eq[k][pos], aff->v->el[0]);
		9969	isl_seq_cpy(bmap->eq[k] + pos + 1, aff->v->el + 1 + pos,
		9970	aff->v->size - (pos + 1));
		9971
		9972	isl_aff_free(aff);
		9973	bmap = isl_basic_map_finalize(bmap);
		9974	return bmap;
		9975	error:
		9976	isl_aff_free(aff);
		9977	isl_basic_map_free(bmap);
		9978	return NULL;
		9979	}
		9980
		9981	/* Construct a map mapping the domain of the affine expression
		9982	* to a one-dimensional range prescribed by the affine expression.
		9983	*/
		9984	__isl_give isl_map *isl_map_from_aff(__isl_take isl_aff *aff)
		9985	{
		9986	isl_basic_map *bmap;
		9987
		9988	bmap = isl_basic_map_from_aff(aff);
		9989	return isl_map_from_basic_map(bmap);
		9990	}
		9991
		9992	/* Construct a basic map mapping the domain the multi-affine expression
		9993	* to its range, with each dimension in the range equated to the
		9994	* corresponding affine expression.
		9995	*/
		9996	__isl_give isl_basic_map *isl_basic_map_from_multi_aff(
		9997	__isl_take isl_multi_aff *maff)
		9998	{
		9999	int i;
		10000	isl_space *space;
		10001	isl_basic_map *bmap;
		10002
		10003	if (!maff)
		10004	return NULL;
		10005
		10006	if (isl_space_dim(maff->space, isl_dim_out) != maff->n)
		10007	isl_die(isl_multi_aff_get_ctx(maff), isl_error_internal,
		10008	"invalid space", return isl_multi_aff_free(maff));
		10009
		10010	space = isl_space_domain(isl_multi_aff_get_space(maff));
		10011	bmap = isl_basic_map_universe(isl_space_from_domain(space));
		10012
		10013	for (i = 0; i < maff->n; ++i) {
		10014	isl_aff *aff;
		10015	isl_basic_map *bmap_i;
		10016
		10017	aff = isl_aff_copy(maff->p[i]);
		10018	bmap_i = isl_basic_map_from_aff(aff);
		10019
		10020	bmap = isl_basic_map_flat_range_product(bmap, bmap_i);
		10021	}
		10022
		10023	bmap = isl_basic_map_reset_space(bmap, isl_multi_aff_get_space(maff));
		10024
		10025	isl_multi_aff_free(maff);
		10026	return bmap;
		10027	}
		10028
		10029	/* Construct a map mapping the domain the multi-affine expression
		10030	* to its range, with each dimension in the range equated to the
		10031	* corresponding affine expression.
		10032	*/
		10033	__isl_give isl_map *isl_map_from_multi_aff(__isl_take isl_multi_aff *maff)
		10034	{
		10035	isl_basic_map *bmap;
		10036
		10037	bmap = isl_basic_map_from_multi_aff(maff);
		10038	return isl_map_from_basic_map(bmap);
		10039	}
		10040
		10041	/* Construct a basic map mapping a domain in the given space to
		10042	* to an n-dimensional range, with n the number of elements in the list,
		10043	* where each coordinate in the range is prescribed by the
		10044	* corresponding affine expression.
		10045	* The domains of all affine expressions in the list are assumed to match
		10046	* domain_dim.
		10047	*/
		10048	__isl_give isl_basic_map *isl_basic_map_from_aff_list(
		10049	__isl_take isl_space *domain_dim, __isl_take isl_aff_list *list)
		10050	{
		10051	int i;
		10052	isl_space *dim;
		10053	isl_basic_map *bmap;
		10054
		10055	if (!list)
		10056	return NULL;
		10057
		10058	dim = isl_space_from_domain(domain_dim);
		10059	bmap = isl_basic_map_universe(dim);
		10060
		10061	for (i = 0; i < list->n; ++i) {
		10062	isl_aff *aff;
		10063	isl_basic_map *bmap_i;
		10064
		10065	aff = isl_aff_copy(list->p[i]);
		10066	bmap_i = isl_basic_map_from_aff(aff);
		10067
		10068	bmap = isl_basic_map_flat_range_product(bmap, bmap_i);
		10069	}
		10070
		10071	isl_aff_list_free(list);
		10072	return bmap;
		10073	}
		10074
		10075	__isl_give isl_set *isl_set_equate(__isl_take isl_set *set,
		10076	enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
		10077	{
		10078	return isl_map_equate(set, type1, pos1, type2, pos2);
		10079	}
		10080
		10081	/* Construct a basic map where the given dimensions are equal to each other.
		10082	*/
		10083	static __isl_give isl_basic_map *equator(__isl_take isl_space *space,
		10084	enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
		10085	{
		10086	isl_basic_map *bmap = NULL;
		10087	int i;
		10088
		10089	if (!space)
		10090	return NULL;
		10091
		10092	if (pos1 >= isl_space_dim(space, type1))
		10093	isl_die(isl_space_get_ctx(space), isl_error_invalid,
		10094	"index out of bounds", goto error);
		10095	if (pos2 >= isl_space_dim(space, type2))
		10096	isl_die(isl_space_get_ctx(space), isl_error_invalid,
		10097	"index out of bounds", goto error);
		10098
		10099	if (type1 == type2 && pos1 == pos2)
		10100	return isl_basic_map_universe(space);
		10101
		10102	bmap = isl_basic_map_alloc_space(isl_space_copy(space), 0, 1, 0);
		10103	i = isl_basic_map_alloc_equality(bmap);
		10104	if (i < 0)
		10105	goto error;
		10106	isl_seq_clr(bmap->eq[i], 1 + isl_basic_map_total_dim(bmap));
		10107	pos1 += isl_basic_map_offset(bmap, type1);
		10108	pos2 += isl_basic_map_offset(bmap, type2);
		10109	isl_int_set_si(bmap->eq[i][pos1], -1);
		10110	isl_int_set_si(bmap->eq[i][pos2], 1);
		10111	bmap = isl_basic_map_finalize(bmap);
		10112	isl_space_free(space);
		10113	return bmap;
		10114	error:
		10115	isl_space_free(space);
		10116	isl_basic_map_free(bmap);
		10117	return NULL;
		10118	}
		10119
		10120	/* Add a constraint imposing that the given two dimensions are equal.
		10121	*/
		10122	__isl_give isl_basic_map *isl_basic_map_equate(__isl_take isl_basic_map *bmap,
		10123	enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
		10124	{
		10125	isl_basic_map *eq;
		10126
		10127	eq = equator(isl_basic_map_get_space(bmap), type1, pos1, type2, pos2);
		10128
		10129	bmap = isl_basic_map_intersect(bmap, eq);
		10130
		10131	return bmap;
		10132	}
		10133
		10134	/* Add a constraint imposing that the given two dimensions are equal.
		10135	*/
		10136	__isl_give isl_map *isl_map_equate(__isl_take isl_map *map,
		10137	enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
		10138	{
		10139	isl_basic_map *bmap;
		10140
		10141	bmap = equator(isl_map_get_space(map), type1, pos1, type2, pos2);
		10142
		10143	map = isl_map_intersect(map, isl_map_from_basic_map(bmap));
		10144
		10145	return map;
		10146	}
		10147
		10148	/* Add a constraint imposing that the given two dimensions have opposite values.
		10149	*/
		10150	__isl_give isl_map *isl_map_oppose(__isl_take isl_map *map,
		10151	enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
		10152	{
		10153	isl_basic_map *bmap = NULL;
		10154	int i;
		10155
		10156	if (!map)
		10157	return NULL;
		10158
		10159	if (pos1 >= isl_map_dim(map, type1))
		10160	isl_die(map->ctx, isl_error_invalid,
		10161	"index out of bounds", goto error);
		10162	if (pos2 >= isl_map_dim(map, type2))
		10163	isl_die(map->ctx, isl_error_invalid,
		10164	"index out of bounds", goto error);
		10165
		10166	bmap = isl_basic_map_alloc_space(isl_map_get_space(map), 0, 1, 0);
		10167	i = isl_basic_map_alloc_equality(bmap);
		10168	if (i < 0)
		10169	goto error;
		10170	isl_seq_clr(bmap->eq[i], 1 + isl_basic_map_total_dim(bmap));
		10171	pos1 += isl_basic_map_offset(bmap, type1);
		10172	pos2 += isl_basic_map_offset(bmap, type2);
		10173	isl_int_set_si(bmap->eq[i][pos1], 1);
		10174	isl_int_set_si(bmap->eq[i][pos2], 1);
		10175	bmap = isl_basic_map_finalize(bmap);
		10176
		10177	map = isl_map_intersect(map, isl_map_from_basic_map(bmap));
		10178
		10179	return map;
		10180	error:
		10181	isl_basic_map_free(bmap);
		10182	isl_map_free(map);
		10183	return NULL;
		10184	}
		10185
		10186	/* Add a constraint imposing that the value of the first dimension is
		10187	* greater than that of the second.
		10188	*/
		10189	__isl_give isl_map *isl_map_order_gt(__isl_take isl_map *map,
		10190	enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
		10191	{
		10192	isl_basic_map *bmap = NULL;
		10193	int i;
		10194
		10195	if (!map)
		10196	return NULL;
		10197
		10198	if (pos1 >= isl_map_dim(map, type1))
		10199	isl_die(map->ctx, isl_error_invalid,
		10200	"index out of bounds", goto error);
		10201	if (pos2 >= isl_map_dim(map, type2))
		10202	isl_die(map->ctx, isl_error_invalid,
		10203	"index out of bounds", goto error);
		10204
		10205	if (type1 == type2 && pos1 == pos2) {
		10206	isl_space *space = isl_map_get_space(map);
		10207	isl_map_free(map);
		10208	return isl_map_empty(space);
		10209	}
		10210
		10211	bmap = isl_basic_map_alloc_space(isl_map_get_space(map), 0, 0, 1);
		10212	i = isl_basic_map_alloc_inequality(bmap);
		10213	if (i < 0)
		10214	goto error;
		10215	isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap));
		10216	pos1 += isl_basic_map_offset(bmap, type1);
		10217	pos2 += isl_basic_map_offset(bmap, type2);
		10218	isl_int_set_si(bmap->ineq[i][pos1], 1);
		10219	isl_int_set_si(bmap->ineq[i][pos2], -1);
		10220	isl_int_set_si(bmap->ineq[i][0], -1);
		10221	bmap = isl_basic_map_finalize(bmap);
		10222
		10223	map = isl_map_intersect(map, isl_map_from_basic_map(bmap));
		10224
		10225	return map;
		10226	error:
		10227	isl_basic_map_free(bmap);
		10228	isl_map_free(map);
		10229	return NULL;
		10230	}
		10231
		10232	/* Add a constraint imposing that the value of the first dimension is
		10233	* smaller than that of the second.
		10234	*/
		10235	__isl_give isl_map *isl_map_order_lt(__isl_take isl_map *map,
		10236	enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
		10237	{
		10238	return isl_map_order_gt(map, type2, pos2, type1, pos1);
		10239	}
		10240
		10241	__isl_give isl_aff *isl_basic_map_get_div(__isl_keep isl_basic_map *bmap,
		10242	int pos)
		10243	{
		10244	isl_aff *div;
		10245	isl_local_space *ls;
		10246
		10247	if (!bmap)
		10248	return NULL;
		10249
		10250	if (!isl_basic_map_divs_known(bmap))
		10251	isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
		10252	"some divs are unknown", return NULL);
		10253
		10254	ls = isl_basic_map_get_local_space(bmap);
		10255	div = isl_local_space_get_div(ls, pos);
		10256	isl_local_space_free(ls);
		10257
		10258	return div;
		10259	}
		10260
		10261	__isl_give isl_aff *isl_basic_set_get_div(__isl_keep isl_basic_set *bset,
		10262	int pos)
		10263	{
		10264	return isl_basic_map_get_div(bset, pos);
		10265	}
		10266
		10267	/* Plug in "subs" for dimension "type", "pos" of "bset".
		10268	*
		10269	* Let i be the dimension to replace and let "subs" be of the form
		10270	*
		10271	* f/d
		10272	*
		10273	* Any integer division with a non-zero coefficient for i,
		10274	*
		10275	* floor((a i + g)/m)
		10276	*
		10277	* is replaced by
		10278	*
		10279	* floor((a f + d g)/(m d))
		10280	*
		10281	* Constraints of the form
		10282	*
		10283	* a i + g
		10284	*
		10285	* are replaced by
		10286	*
		10287	* a f + d g
		10288	*/
		10289	__isl_give isl_basic_set *isl_basic_set_substitute(
		10290	__isl_take isl_basic_set *bset,
		10291	enum isl_dim_type type, unsigned pos, __isl_keep isl_aff *subs)
		10292	{
		10293	int i;
		10294	isl_int v;
		10295	isl_ctx *ctx;
		10296
		10297	if (bset && isl_basic_set_plain_is_empty(bset))
		10298	return bset;
		10299
		10300	bset = isl_basic_set_cow(bset);
		10301	if (!bset || !subs)
		10302	goto error;
		10303
		10304	ctx = isl_basic_set_get_ctx(bset);
		10305	if (!isl_space_is_equal(bset->dim, subs->ls->dim))
		10306	isl_die(ctx, isl_error_invalid,
		10307	"spaces don't match", goto error);
		10308	if (isl_local_space_dim(subs->ls, isl_dim_div) != 0)
		10309	isl_die(ctx, isl_error_unsupported,
		10310	"cannot handle divs yet", goto error);
		10311
		10312	pos += isl_basic_set_offset(bset, type);
		10313
		10314	isl_int_init(v);
		10315
		10316	for (i = 0; i < bset->n_eq; ++i) {
		10317	if (isl_int_is_zero(bset->eq[i][pos]))
		10318	continue;
		10319	isl_int_set(v, bset->eq[i][pos]);
		10320	isl_int_set_si(bset->eq[i][pos], 0);
		10321	isl_seq_combine(bset->eq[i], subs->v->el[0], bset->eq[i],
		10322	v, subs->v->el + 1, subs->v->size - 1);
		10323	}
		10324
		10325	for (i = 0; i < bset->n_ineq; ++i) {
		10326	if (isl_int_is_zero(bset->ineq[i][pos]))
		10327	continue;
		10328	isl_int_set(v, bset->ineq[i][pos]);
		10329	isl_int_set_si(bset->ineq[i][pos], 0);
		10330	isl_seq_combine(bset->ineq[i], subs->v->el[0], bset->ineq[i],
		10331	v, subs->v->el + 1, subs->v->size - 1);
		10332	}
		10333
		10334	for (i = 0; i < bset->n_div; ++i) {
		10335	if (isl_int_is_zero(bset->div[i][1 + pos]))
		10336	continue;
		10337	isl_int_set(v, bset->div[i][1 + pos]);
		10338	isl_int_set_si(bset->div[i][1 + pos], 0);
		10339	isl_seq_combine(bset->div[i] + 1,
		10340	subs->v->el[0], bset->div[i] + 1,
		10341	v, subs->v->el + 1, subs->v->size - 1);
		10342	isl_int_mul(bset->div[i][0], bset->div[i][0], subs->v->el[0]);
		10343	}
		10344
		10345	isl_int_clear(v);
		10346
		10347	bset = isl_basic_set_simplify(bset);
		10348	return isl_basic_set_finalize(bset);
		10349	error:
		10350	isl_basic_set_free(bset);
		10351	return NULL;
		10352	}
		10353
		10354	/* Plug in "subs" for dimension "type", "pos" of "set".
		10355	*/
		10356	__isl_give isl_set *isl_set_substitute(__isl_take isl_set *set,
		10357	enum isl_dim_type type, unsigned pos, __isl_keep isl_aff *subs)
		10358	{
		10359	int i;
		10360
		10361	if (set && isl_set_plain_is_empty(set))
		10362	return set;
		10363
		10364	set = isl_set_cow(set);
		10365	if (!set || !subs)
		10366	goto error;
		10367
		10368	for (i = set->n - 1; i >= 0; --i) {
		10369	set->p[i] = isl_basic_set_substitute(set->p[i], type, pos, subs);
		10370	if (remove_if_empty(set, i) < 0)
		10371	goto error;
		10372	}
		10373
		10374	return set;
		10375	error:
		10376	isl_set_free(set);
		10377	return NULL;
		10378	}