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