doc: explicitly state that the divisor of an ?div_? operation is positive
[isl.git] / isl_map.c
blob0bce2e1e7a0aac96c787ca789256a3de91c9cc68
1 /*
2 * Copyright 2008-2009 Katholieke Universiteit Leuven
3 * Copyright 2010 INRIA Saclay
4 * Copyright 2012-2014 Ecole Normale Superieure
5 * Copyright 2014 INRIA Rocquencourt
6 * Copyright 2016 INRIA Paris
7 * Copyright 2016 Sven Verdoolaege
9 * Use of this software is governed by the MIT license
11 * Written by Sven Verdoolaege, K.U.Leuven, Departement
12 * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
13 * and INRIA Saclay - Ile-de-France, Parc Club Orsay Universite,
14 * ZAC des vignes, 4 rue Jacques Monod, 91893 Orsay, France
15 * and Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
16 * and Inria Paris - Rocquencourt, Domaine de Voluceau - Rocquencourt,
17 * B.P. 105 - 78153 Le Chesnay, France
18 * and Centre de Recherche Inria de Paris, 2 rue Simone Iff - Voie DQ12,
19 * CS 42112, 75589 Paris Cedex 12, France
22 #include <string.h>
23 #include <isl_ctx_private.h>
24 #include <isl_map_private.h>
25 #include <isl_blk.h>
26 #include <isl/id.h>
27 #include <isl/constraint.h>
28 #include "isl_space_private.h"
29 #include "isl_equalities.h"
30 #include <isl_lp_private.h>
31 #include <isl_seq.h>
32 #include <isl/set.h>
33 #include <isl/map.h>
34 #include <isl_reordering.h>
35 #include "isl_sample.h"
36 #include <isl_sort.h>
37 #include "isl_tab.h"
38 #include <isl/vec.h>
39 #include <isl_mat_private.h>
40 #include <isl_vec_private.h>
41 #include <isl_dim_map.h>
42 #include <isl_local_space_private.h>
43 #include <isl_aff_private.h>
44 #include <isl_options_private.h>
45 #include <isl_morph.h>
46 #include <isl_val_private.h>
48 #include <bset_to_bmap.c>
49 #include <bset_from_bmap.c>
50 #include <set_to_map.c>
51 #include <set_from_map.c>
53 static unsigned n(__isl_keep isl_space *dim, enum isl_dim_type type)
55 switch (type) {
56 case isl_dim_param: return dim->nparam;
57 case isl_dim_in: return dim->n_in;
58 case isl_dim_out: return dim->n_out;
59 case isl_dim_all: return dim->nparam + dim->n_in + dim->n_out;
60 default: return 0;
64 static unsigned pos(__isl_keep isl_space *dim, enum isl_dim_type type)
66 switch (type) {
67 case isl_dim_param: return 1;
68 case isl_dim_in: return 1 + dim->nparam;
69 case isl_dim_out: return 1 + dim->nparam + dim->n_in;
70 default: return 0;
74 unsigned isl_basic_map_dim(__isl_keep isl_basic_map *bmap,
75 enum isl_dim_type type)
77 if (!bmap)
78 return 0;
79 switch (type) {
80 case isl_dim_cst: return 1;
81 case isl_dim_param:
82 case isl_dim_in:
83 case isl_dim_out: return isl_space_dim(bmap->dim, type);
84 case isl_dim_div: return bmap->n_div;
85 case isl_dim_all: return isl_basic_map_total_dim(bmap);
86 default: return 0;
90 /* Return the space of "map".
92 __isl_keep isl_space *isl_map_peek_space(__isl_keep const isl_map *map)
94 return map ? map->dim : NULL;
97 unsigned isl_map_dim(__isl_keep isl_map *map, enum isl_dim_type type)
99 return map ? n(map->dim, type) : 0;
102 unsigned isl_set_dim(__isl_keep isl_set *set, enum isl_dim_type type)
104 return set ? n(set->dim, type) : 0;
107 unsigned isl_basic_map_offset(struct isl_basic_map *bmap,
108 enum isl_dim_type type)
110 isl_space *space;
112 if (!bmap)
113 return 0;
115 space = bmap->dim;
116 switch (type) {
117 case isl_dim_cst: return 0;
118 case isl_dim_param: return 1;
119 case isl_dim_in: return 1 + space->nparam;
120 case isl_dim_out: return 1 + space->nparam + space->n_in;
121 case isl_dim_div: return 1 + space->nparam + space->n_in +
122 space->n_out;
123 default: return 0;
127 unsigned isl_basic_set_offset(__isl_keep isl_basic_set *bset,
128 enum isl_dim_type type)
130 return isl_basic_map_offset(bset, type);
133 static unsigned map_offset(__isl_keep isl_map *map, enum isl_dim_type type)
135 return pos(map->dim, type);
138 unsigned isl_basic_set_dim(__isl_keep isl_basic_set *bset,
139 enum isl_dim_type type)
141 return isl_basic_map_dim(bset, type);
144 unsigned isl_basic_set_n_dim(__isl_keep isl_basic_set *bset)
146 return isl_basic_set_dim(bset, isl_dim_set);
149 unsigned isl_basic_set_n_param(__isl_keep isl_basic_set *bset)
151 return isl_basic_set_dim(bset, isl_dim_param);
154 unsigned isl_basic_set_total_dim(__isl_keep const isl_basic_set *bset)
156 if (!bset)
157 return 0;
158 return isl_space_dim(bset->dim, isl_dim_all) + bset->n_div;
161 unsigned isl_set_n_dim(__isl_keep isl_set *set)
163 return isl_set_dim(set, isl_dim_set);
166 unsigned isl_set_n_param(__isl_keep isl_set *set)
168 return isl_set_dim(set, isl_dim_param);
171 unsigned isl_basic_map_n_in(__isl_keep const isl_basic_map *bmap)
173 return bmap ? bmap->dim->n_in : 0;
176 unsigned isl_basic_map_n_out(__isl_keep const isl_basic_map *bmap)
178 return bmap ? bmap->dim->n_out : 0;
181 unsigned isl_basic_map_n_param(__isl_keep const isl_basic_map *bmap)
183 return bmap ? bmap->dim->nparam : 0;
186 unsigned isl_basic_map_n_div(__isl_keep const isl_basic_map *bmap)
188 return bmap ? bmap->n_div : 0;
191 unsigned isl_basic_map_total_dim(__isl_keep const isl_basic_map *bmap)
193 return bmap ? isl_space_dim(bmap->dim, isl_dim_all) + bmap->n_div : 0;
196 unsigned isl_map_n_in(__isl_keep const isl_map *map)
198 return map ? map->dim->n_in : 0;
201 unsigned isl_map_n_out(__isl_keep const isl_map *map)
203 return map ? map->dim->n_out : 0;
206 unsigned isl_map_n_param(__isl_keep const isl_map *map)
208 return map ? map->dim->nparam : 0;
211 /* Return the number of equality constraints in the description of "bmap".
212 * Return -1 on error.
214 int isl_basic_map_n_equality(__isl_keep isl_basic_map *bmap)
216 if (!bmap)
217 return -1;
218 return bmap->n_eq;
221 /* Return the number of equality constraints in the description of "bset".
222 * Return -1 on error.
224 int isl_basic_set_n_equality(__isl_keep isl_basic_set *bset)
226 return isl_basic_map_n_equality(bset_to_bmap(bset));
229 /* Return the number of inequality constraints in the description of "bmap".
230 * Return -1 on error.
232 int isl_basic_map_n_inequality(__isl_keep isl_basic_map *bmap)
234 if (!bmap)
235 return -1;
236 return bmap->n_ineq;
239 /* Return the number of inequality constraints in the description of "bset".
240 * Return -1 on error.
242 int isl_basic_set_n_inequality(__isl_keep isl_basic_set *bset)
244 return isl_basic_map_n_inequality(bset_to_bmap(bset));
247 /* Do "bmap1" and "bmap2" have the same parameters?
249 static isl_bool isl_basic_map_has_equal_params(__isl_keep isl_basic_map *bmap1,
250 __isl_keep isl_basic_map *bmap2)
252 isl_space *space1, *space2;
254 space1 = isl_basic_map_peek_space(bmap1);
255 space2 = isl_basic_map_peek_space(bmap2);
256 return isl_space_has_equal_params(space1, space2);
259 /* Do "map1" and "map2" have the same parameters?
261 isl_bool isl_map_has_equal_params(__isl_keep isl_map *map1,
262 __isl_keep isl_map *map2)
264 isl_space *space1, *space2;
266 space1 = isl_map_peek_space(map1);
267 space2 = isl_map_peek_space(map2);
268 return isl_space_has_equal_params(space1, space2);
271 /* Do "map" and "set" have the same parameters?
273 static isl_bool isl_map_set_has_equal_params(__isl_keep isl_map *map,
274 __isl_keep isl_set *set)
276 return isl_map_has_equal_params(map, set_to_map(set));
279 isl_bool isl_map_compatible_domain(__isl_keep isl_map *map,
280 __isl_keep isl_set *set)
282 isl_bool m;
283 if (!map || !set)
284 return isl_bool_error;
285 m = isl_map_has_equal_params(map, set_to_map(set));
286 if (m < 0 || !m)
287 return m;
288 return isl_space_tuple_is_equal(map->dim, isl_dim_in,
289 set->dim, isl_dim_set);
292 isl_bool isl_basic_map_compatible_domain(__isl_keep isl_basic_map *bmap,
293 __isl_keep isl_basic_set *bset)
295 isl_bool m;
296 if (!bmap || !bset)
297 return isl_bool_error;
298 m = isl_basic_map_has_equal_params(bmap, bset_to_bmap(bset));
299 if (m < 0 || !m)
300 return m;
301 return isl_space_tuple_is_equal(bmap->dim, isl_dim_in,
302 bset->dim, isl_dim_set);
305 isl_bool isl_map_compatible_range(__isl_keep isl_map *map,
306 __isl_keep isl_set *set)
308 isl_bool m;
309 if (!map || !set)
310 return isl_bool_error;
311 m = isl_map_has_equal_params(map, set_to_map(set));
312 if (m < 0 || !m)
313 return m;
314 return isl_space_tuple_is_equal(map->dim, isl_dim_out,
315 set->dim, isl_dim_set);
318 isl_bool isl_basic_map_compatible_range(__isl_keep isl_basic_map *bmap,
319 __isl_keep isl_basic_set *bset)
321 isl_bool m;
322 if (!bmap || !bset)
323 return isl_bool_error;
324 m = isl_basic_map_has_equal_params(bmap, bset_to_bmap(bset));
325 if (m < 0 || !m)
326 return m;
327 return isl_space_tuple_is_equal(bmap->dim, isl_dim_out,
328 bset->dim, isl_dim_set);
331 isl_ctx *isl_basic_map_get_ctx(__isl_keep isl_basic_map *bmap)
333 return bmap ? bmap->ctx : NULL;
336 isl_ctx *isl_basic_set_get_ctx(__isl_keep isl_basic_set *bset)
338 return bset ? bset->ctx : NULL;
341 isl_ctx *isl_map_get_ctx(__isl_keep isl_map *map)
343 return map ? map->ctx : NULL;
346 isl_ctx *isl_set_get_ctx(__isl_keep isl_set *set)
348 return set ? set->ctx : NULL;
351 /* Return the space of "bmap".
353 __isl_keep isl_space *isl_basic_map_peek_space(
354 __isl_keep const isl_basic_map *bmap)
356 return bmap ? bmap->dim : NULL;
359 /* Return the space of "bset".
361 __isl_keep isl_space *isl_basic_set_peek_space(__isl_keep isl_basic_set *bset)
363 return isl_basic_map_peek_space(bset_to_bmap(bset));
366 __isl_give isl_space *isl_basic_map_get_space(__isl_keep isl_basic_map *bmap)
368 return isl_space_copy(isl_basic_map_peek_space(bmap));
371 __isl_give isl_space *isl_basic_set_get_space(__isl_keep isl_basic_set *bset)
373 return isl_basic_map_get_space(bset_to_bmap(bset));
376 /* Extract the divs in "bmap" as a matrix.
378 __isl_give isl_mat *isl_basic_map_get_divs(__isl_keep isl_basic_map *bmap)
380 int i;
381 isl_ctx *ctx;
382 isl_mat *div;
383 unsigned total;
384 unsigned cols;
386 if (!bmap)
387 return NULL;
389 ctx = isl_basic_map_get_ctx(bmap);
390 total = isl_space_dim(bmap->dim, isl_dim_all);
391 cols = 1 + 1 + total + bmap->n_div;
392 div = isl_mat_alloc(ctx, bmap->n_div, cols);
393 if (!div)
394 return NULL;
396 for (i = 0; i < bmap->n_div; ++i)
397 isl_seq_cpy(div->row[i], bmap->div[i], cols);
399 return div;
402 /* Extract the divs in "bset" as a matrix.
404 __isl_give isl_mat *isl_basic_set_get_divs(__isl_keep isl_basic_set *bset)
406 return isl_basic_map_get_divs(bset);
409 __isl_give isl_local_space *isl_basic_map_get_local_space(
410 __isl_keep isl_basic_map *bmap)
412 isl_mat *div;
414 if (!bmap)
415 return NULL;
417 div = isl_basic_map_get_divs(bmap);
418 return isl_local_space_alloc_div(isl_space_copy(bmap->dim), div);
421 __isl_give isl_local_space *isl_basic_set_get_local_space(
422 __isl_keep isl_basic_set *bset)
424 return isl_basic_map_get_local_space(bset);
427 /* For each known div d = floor(f/m), add the constraints
429 * f - m d >= 0
430 * -(f-(m-1)) + m d >= 0
432 * Do not finalize the result.
434 static __isl_give isl_basic_map *add_known_div_constraints(
435 __isl_take isl_basic_map *bmap)
437 int i;
438 unsigned n_div;
440 if (!bmap)
441 return NULL;
442 n_div = isl_basic_map_dim(bmap, isl_dim_div);
443 if (n_div == 0)
444 return bmap;
445 bmap = isl_basic_map_cow(bmap);
446 bmap = isl_basic_map_extend_constraints(bmap, 0, 2 * n_div);
447 if (!bmap)
448 return NULL;
449 for (i = 0; i < n_div; ++i) {
450 if (isl_int_is_zero(bmap->div[i][0]))
451 continue;
452 if (isl_basic_map_add_div_constraints(bmap, i) < 0)
453 return isl_basic_map_free(bmap);
456 return bmap;
459 __isl_give isl_basic_map *isl_basic_map_from_local_space(
460 __isl_take isl_local_space *ls)
462 int i;
463 int n_div;
464 isl_basic_map *bmap;
466 if (!ls)
467 return NULL;
469 n_div = isl_local_space_dim(ls, isl_dim_div);
470 bmap = isl_basic_map_alloc_space(isl_local_space_get_space(ls),
471 n_div, 0, 2 * n_div);
473 for (i = 0; i < n_div; ++i)
474 if (isl_basic_map_alloc_div(bmap) < 0)
475 goto error;
477 for (i = 0; i < n_div; ++i)
478 isl_seq_cpy(bmap->div[i], ls->div->row[i], ls->div->n_col);
479 bmap = add_known_div_constraints(bmap);
481 isl_local_space_free(ls);
482 return bmap;
483 error:
484 isl_local_space_free(ls);
485 isl_basic_map_free(bmap);
486 return NULL;
489 __isl_give isl_basic_set *isl_basic_set_from_local_space(
490 __isl_take isl_local_space *ls)
492 return isl_basic_map_from_local_space(ls);
495 __isl_give isl_space *isl_map_get_space(__isl_keep isl_map *map)
497 return isl_space_copy(isl_map_peek_space(map));
500 __isl_give isl_space *isl_set_get_space(__isl_keep isl_set *set)
502 if (!set)
503 return NULL;
504 return isl_space_copy(set->dim);
507 __isl_give isl_basic_map *isl_basic_map_set_tuple_name(
508 __isl_take isl_basic_map *bmap, enum isl_dim_type type, const char *s)
510 bmap = isl_basic_map_cow(bmap);
511 if (!bmap)
512 return NULL;
513 bmap->dim = isl_space_set_tuple_name(bmap->dim, type, s);
514 if (!bmap->dim)
515 goto error;
516 bmap = isl_basic_map_finalize(bmap);
517 return bmap;
518 error:
519 isl_basic_map_free(bmap);
520 return NULL;
523 __isl_give isl_basic_set *isl_basic_set_set_tuple_name(
524 __isl_take isl_basic_set *bset, const char *s)
526 return isl_basic_map_set_tuple_name(bset, isl_dim_set, s);
529 const char *isl_basic_map_get_tuple_name(__isl_keep isl_basic_map *bmap,
530 enum isl_dim_type type)
532 return bmap ? isl_space_get_tuple_name(bmap->dim, type) : NULL;
535 __isl_give isl_map *isl_map_set_tuple_name(__isl_take isl_map *map,
536 enum isl_dim_type type, const char *s)
538 int i;
540 map = isl_map_cow(map);
541 if (!map)
542 return NULL;
544 map->dim = isl_space_set_tuple_name(map->dim, type, s);
545 if (!map->dim)
546 goto error;
548 for (i = 0; i < map->n; ++i) {
549 map->p[i] = isl_basic_map_set_tuple_name(map->p[i], type, s);
550 if (!map->p[i])
551 goto error;
554 return map;
555 error:
556 isl_map_free(map);
557 return NULL;
560 /* Replace the identifier of the tuple of type "type" by "id".
562 __isl_give isl_basic_map *isl_basic_map_set_tuple_id(
563 __isl_take isl_basic_map *bmap,
564 enum isl_dim_type type, __isl_take isl_id *id)
566 bmap = isl_basic_map_cow(bmap);
567 if (!bmap)
568 goto error;
569 bmap->dim = isl_space_set_tuple_id(bmap->dim, type, id);
570 if (!bmap->dim)
571 return isl_basic_map_free(bmap);
572 bmap = isl_basic_map_finalize(bmap);
573 return bmap;
574 error:
575 isl_id_free(id);
576 return NULL;
579 /* Replace the identifier of the tuple by "id".
581 __isl_give isl_basic_set *isl_basic_set_set_tuple_id(
582 __isl_take isl_basic_set *bset, __isl_take isl_id *id)
584 return isl_basic_map_set_tuple_id(bset, isl_dim_set, id);
587 /* Does the input or output tuple have a name?
589 isl_bool isl_map_has_tuple_name(__isl_keep isl_map *map, enum isl_dim_type type)
591 return map ? isl_space_has_tuple_name(map->dim, type) : isl_bool_error;
594 const char *isl_map_get_tuple_name(__isl_keep isl_map *map,
595 enum isl_dim_type type)
597 return map ? isl_space_get_tuple_name(map->dim, type) : NULL;
600 __isl_give isl_set *isl_set_set_tuple_name(__isl_take isl_set *set,
601 const char *s)
603 return set_from_map(isl_map_set_tuple_name(set_to_map(set),
604 isl_dim_set, s));
607 __isl_give isl_map *isl_map_set_tuple_id(__isl_take isl_map *map,
608 enum isl_dim_type type, __isl_take isl_id *id)
610 map = isl_map_cow(map);
611 if (!map)
612 goto error;
614 map->dim = isl_space_set_tuple_id(map->dim, type, id);
616 return isl_map_reset_space(map, isl_space_copy(map->dim));
617 error:
618 isl_id_free(id);
619 return NULL;
622 __isl_give isl_set *isl_set_set_tuple_id(__isl_take isl_set *set,
623 __isl_take isl_id *id)
625 return isl_map_set_tuple_id(set, isl_dim_set, id);
628 __isl_give isl_map *isl_map_reset_tuple_id(__isl_take isl_map *map,
629 enum isl_dim_type type)
631 map = isl_map_cow(map);
632 if (!map)
633 return NULL;
635 map->dim = isl_space_reset_tuple_id(map->dim, type);
637 return isl_map_reset_space(map, isl_space_copy(map->dim));
640 __isl_give isl_set *isl_set_reset_tuple_id(__isl_take isl_set *set)
642 return isl_map_reset_tuple_id(set, isl_dim_set);
645 isl_bool isl_map_has_tuple_id(__isl_keep isl_map *map, enum isl_dim_type type)
647 return map ? isl_space_has_tuple_id(map->dim, type) : isl_bool_error;
650 __isl_give isl_id *isl_map_get_tuple_id(__isl_keep isl_map *map,
651 enum isl_dim_type type)
653 return map ? isl_space_get_tuple_id(map->dim, type) : NULL;
656 isl_bool isl_set_has_tuple_id(__isl_keep isl_set *set)
658 return isl_map_has_tuple_id(set, isl_dim_set);
661 __isl_give isl_id *isl_set_get_tuple_id(__isl_keep isl_set *set)
663 return isl_map_get_tuple_id(set, isl_dim_set);
666 /* Does the set tuple have a name?
668 isl_bool isl_set_has_tuple_name(__isl_keep isl_set *set)
670 if (!set)
671 return isl_bool_error;
672 return isl_space_has_tuple_name(set->dim, isl_dim_set);
676 const char *isl_basic_set_get_tuple_name(__isl_keep isl_basic_set *bset)
678 return bset ? isl_space_get_tuple_name(bset->dim, isl_dim_set) : NULL;
681 const char *isl_set_get_tuple_name(__isl_keep isl_set *set)
683 return set ? isl_space_get_tuple_name(set->dim, isl_dim_set) : NULL;
686 const char *isl_basic_map_get_dim_name(__isl_keep isl_basic_map *bmap,
687 enum isl_dim_type type, unsigned pos)
689 return bmap ? isl_space_get_dim_name(bmap->dim, type, pos) : NULL;
692 const char *isl_basic_set_get_dim_name(__isl_keep isl_basic_set *bset,
693 enum isl_dim_type type, unsigned pos)
695 return bset ? isl_space_get_dim_name(bset->dim, type, pos) : NULL;
698 /* Does the given dimension have a name?
700 isl_bool isl_map_has_dim_name(__isl_keep isl_map *map,
701 enum isl_dim_type type, unsigned pos)
703 if (!map)
704 return isl_bool_error;
705 return isl_space_has_dim_name(map->dim, type, pos);
708 const char *isl_map_get_dim_name(__isl_keep isl_map *map,
709 enum isl_dim_type type, unsigned pos)
711 return map ? isl_space_get_dim_name(map->dim, type, pos) : NULL;
714 const char *isl_set_get_dim_name(__isl_keep isl_set *set,
715 enum isl_dim_type type, unsigned pos)
717 return set ? isl_space_get_dim_name(set->dim, type, pos) : NULL;
720 /* Does the given dimension have a name?
722 isl_bool isl_set_has_dim_name(__isl_keep isl_set *set,
723 enum isl_dim_type type, unsigned pos)
725 if (!set)
726 return isl_bool_error;
727 return isl_space_has_dim_name(set->dim, type, pos);
730 __isl_give isl_basic_map *isl_basic_map_set_dim_name(
731 __isl_take isl_basic_map *bmap,
732 enum isl_dim_type type, unsigned pos, const char *s)
734 bmap = isl_basic_map_cow(bmap);
735 if (!bmap)
736 return NULL;
737 bmap->dim = isl_space_set_dim_name(bmap->dim, type, pos, s);
738 if (!bmap->dim)
739 goto error;
740 return isl_basic_map_finalize(bmap);
741 error:
742 isl_basic_map_free(bmap);
743 return NULL;
746 __isl_give isl_map *isl_map_set_dim_name(__isl_take isl_map *map,
747 enum isl_dim_type type, unsigned pos, const char *s)
749 int i;
751 map = isl_map_cow(map);
752 if (!map)
753 return NULL;
755 map->dim = isl_space_set_dim_name(map->dim, type, pos, s);
756 if (!map->dim)
757 goto error;
759 for (i = 0; i < map->n; ++i) {
760 map->p[i] = isl_basic_map_set_dim_name(map->p[i], type, pos, s);
761 if (!map->p[i])
762 goto error;
765 return map;
766 error:
767 isl_map_free(map);
768 return NULL;
771 __isl_give isl_basic_set *isl_basic_set_set_dim_name(
772 __isl_take isl_basic_set *bset,
773 enum isl_dim_type type, unsigned pos, const char *s)
775 return bset_from_bmap(isl_basic_map_set_dim_name(bset_to_bmap(bset),
776 type, pos, s));
779 __isl_give isl_set *isl_set_set_dim_name(__isl_take isl_set *set,
780 enum isl_dim_type type, unsigned pos, const char *s)
782 return set_from_map(isl_map_set_dim_name(set_to_map(set),
783 type, pos, s));
786 isl_bool isl_basic_map_has_dim_id(__isl_keep isl_basic_map *bmap,
787 enum isl_dim_type type, unsigned pos)
789 if (!bmap)
790 return isl_bool_error;
791 return isl_space_has_dim_id(bmap->dim, type, pos);
794 __isl_give isl_id *isl_basic_set_get_dim_id(__isl_keep isl_basic_set *bset,
795 enum isl_dim_type type, unsigned pos)
797 return bset ? isl_space_get_dim_id(bset->dim, type, pos) : NULL;
800 isl_bool isl_map_has_dim_id(__isl_keep isl_map *map,
801 enum isl_dim_type type, unsigned pos)
803 return map ? isl_space_has_dim_id(map->dim, type, pos) : isl_bool_error;
806 __isl_give isl_id *isl_map_get_dim_id(__isl_keep isl_map *map,
807 enum isl_dim_type type, unsigned pos)
809 return map ? isl_space_get_dim_id(map->dim, type, pos) : NULL;
812 isl_bool isl_set_has_dim_id(__isl_keep isl_set *set,
813 enum isl_dim_type type, unsigned pos)
815 return isl_map_has_dim_id(set, type, pos);
818 __isl_give isl_id *isl_set_get_dim_id(__isl_keep isl_set *set,
819 enum isl_dim_type type, unsigned pos)
821 return isl_map_get_dim_id(set, type, pos);
824 __isl_give isl_map *isl_map_set_dim_id(__isl_take isl_map *map,
825 enum isl_dim_type type, unsigned pos, __isl_take isl_id *id)
827 map = isl_map_cow(map);
828 if (!map)
829 goto error;
831 map->dim = isl_space_set_dim_id(map->dim, type, pos, id);
833 return isl_map_reset_space(map, isl_space_copy(map->dim));
834 error:
835 isl_id_free(id);
836 return NULL;
839 __isl_give isl_set *isl_set_set_dim_id(__isl_take isl_set *set,
840 enum isl_dim_type type, unsigned pos, __isl_take isl_id *id)
842 return isl_map_set_dim_id(set, type, pos, id);
845 int isl_map_find_dim_by_id(__isl_keep isl_map *map, enum isl_dim_type type,
846 __isl_keep isl_id *id)
848 if (!map)
849 return -1;
850 return isl_space_find_dim_by_id(map->dim, type, id);
853 int isl_set_find_dim_by_id(__isl_keep isl_set *set, enum isl_dim_type type,
854 __isl_keep isl_id *id)
856 return isl_map_find_dim_by_id(set, type, id);
859 /* Return the position of the dimension of the given type and name
860 * in "bmap".
861 * Return -1 if no such dimension can be found.
863 int isl_basic_map_find_dim_by_name(__isl_keep isl_basic_map *bmap,
864 enum isl_dim_type type, const char *name)
866 if (!bmap)
867 return -1;
868 return isl_space_find_dim_by_name(bmap->dim, type, name);
871 int isl_map_find_dim_by_name(__isl_keep isl_map *map, enum isl_dim_type type,
872 const char *name)
874 if (!map)
875 return -1;
876 return isl_space_find_dim_by_name(map->dim, type, name);
879 int isl_set_find_dim_by_name(__isl_keep isl_set *set, enum isl_dim_type type,
880 const char *name)
882 return isl_map_find_dim_by_name(set, type, name);
885 /* Check whether equality i of bset is a pure stride constraint
886 * on a single dimension, i.e., of the form
888 * v = k e
890 * with k a constant and e an existentially quantified variable.
892 isl_bool isl_basic_set_eq_is_stride(__isl_keep isl_basic_set *bset, int i)
894 unsigned nparam;
895 unsigned d;
896 unsigned n_div;
897 int pos1;
898 int pos2;
900 if (!bset)
901 return isl_bool_error;
903 if (!isl_int_is_zero(bset->eq[i][0]))
904 return isl_bool_false;
906 nparam = isl_basic_set_dim(bset, isl_dim_param);
907 d = isl_basic_set_dim(bset, isl_dim_set);
908 n_div = isl_basic_set_dim(bset, isl_dim_div);
910 if (isl_seq_first_non_zero(bset->eq[i] + 1, nparam) != -1)
911 return isl_bool_false;
912 pos1 = isl_seq_first_non_zero(bset->eq[i] + 1 + nparam, d);
913 if (pos1 == -1)
914 return isl_bool_false;
915 if (isl_seq_first_non_zero(bset->eq[i] + 1 + nparam + pos1 + 1,
916 d - pos1 - 1) != -1)
917 return isl_bool_false;
919 pos2 = isl_seq_first_non_zero(bset->eq[i] + 1 + nparam + d, n_div);
920 if (pos2 == -1)
921 return isl_bool_false;
922 if (isl_seq_first_non_zero(bset->eq[i] + 1 + nparam + d + pos2 + 1,
923 n_div - pos2 - 1) != -1)
924 return isl_bool_false;
925 if (!isl_int_is_one(bset->eq[i][1 + nparam + pos1]) &&
926 !isl_int_is_negone(bset->eq[i][1 + nparam + pos1]))
927 return isl_bool_false;
929 return isl_bool_true;
932 /* Reset the user pointer on all identifiers of parameters and tuples
933 * of the space of "map".
935 __isl_give isl_map *isl_map_reset_user(__isl_take isl_map *map)
937 isl_space *space;
939 space = isl_map_get_space(map);
940 space = isl_space_reset_user(space);
941 map = isl_map_reset_space(map, space);
943 return map;
946 /* Reset the user pointer on all identifiers of parameters and tuples
947 * of the space of "set".
949 __isl_give isl_set *isl_set_reset_user(__isl_take isl_set *set)
951 return isl_map_reset_user(set);
954 isl_bool isl_basic_map_is_rational(__isl_keep isl_basic_map *bmap)
956 if (!bmap)
957 return isl_bool_error;
958 return ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL);
961 /* Has "map" been marked as a rational map?
962 * In particular, have all basic maps in "map" been marked this way?
963 * An empty map is not considered to be rational.
964 * Maps where only some of the basic maps are marked rational
965 * are not allowed.
967 isl_bool isl_map_is_rational(__isl_keep isl_map *map)
969 int i;
970 isl_bool rational;
972 if (!map)
973 return isl_bool_error;
974 if (map->n == 0)
975 return isl_bool_false;
976 rational = isl_basic_map_is_rational(map->p[0]);
977 if (rational < 0)
978 return rational;
979 for (i = 1; i < map->n; ++i) {
980 isl_bool rational_i;
982 rational_i = isl_basic_map_is_rational(map->p[i]);
983 if (rational_i < 0)
984 return rational_i;
985 if (rational != rational_i)
986 isl_die(isl_map_get_ctx(map), isl_error_unsupported,
987 "mixed rational and integer basic maps "
988 "not supported", return isl_bool_error);
991 return rational;
994 /* Has "set" been marked as a rational set?
995 * In particular, have all basic set in "set" been marked this way?
996 * An empty set is not considered to be rational.
997 * Sets where only some of the basic sets are marked rational
998 * are not allowed.
1000 isl_bool isl_set_is_rational(__isl_keep isl_set *set)
1002 return isl_map_is_rational(set);
1005 int isl_basic_set_is_rational(__isl_keep isl_basic_set *bset)
1007 return isl_basic_map_is_rational(bset);
1010 /* Does "bmap" contain any rational points?
1012 * If "bmap" has an equality for each dimension, equating the dimension
1013 * to an integer constant, then it has no rational points, even if it
1014 * is marked as rational.
1016 isl_bool isl_basic_map_has_rational(__isl_keep isl_basic_map *bmap)
1018 isl_bool has_rational = isl_bool_true;
1019 unsigned total;
1021 if (!bmap)
1022 return isl_bool_error;
1023 if (isl_basic_map_plain_is_empty(bmap))
1024 return isl_bool_false;
1025 if (!isl_basic_map_is_rational(bmap))
1026 return isl_bool_false;
1027 bmap = isl_basic_map_copy(bmap);
1028 bmap = isl_basic_map_implicit_equalities(bmap);
1029 if (!bmap)
1030 return isl_bool_error;
1031 total = isl_basic_map_total_dim(bmap);
1032 if (bmap->n_eq == total) {
1033 int i, j;
1034 for (i = 0; i < bmap->n_eq; ++i) {
1035 j = isl_seq_first_non_zero(bmap->eq[i] + 1, total);
1036 if (j < 0)
1037 break;
1038 if (!isl_int_is_one(bmap->eq[i][1 + j]) &&
1039 !isl_int_is_negone(bmap->eq[i][1 + j]))
1040 break;
1041 j = isl_seq_first_non_zero(bmap->eq[i] + 1 + j + 1,
1042 total - j - 1);
1043 if (j >= 0)
1044 break;
1046 if (i == bmap->n_eq)
1047 has_rational = isl_bool_false;
1049 isl_basic_map_free(bmap);
1051 return has_rational;
1054 /* Does "map" contain any rational points?
1056 isl_bool isl_map_has_rational(__isl_keep isl_map *map)
1058 int i;
1059 isl_bool has_rational;
1061 if (!map)
1062 return isl_bool_error;
1063 for (i = 0; i < map->n; ++i) {
1064 has_rational = isl_basic_map_has_rational(map->p[i]);
1065 if (has_rational < 0 || has_rational)
1066 return has_rational;
1068 return isl_bool_false;
1071 /* Does "set" contain any rational points?
1073 isl_bool isl_set_has_rational(__isl_keep isl_set *set)
1075 return isl_map_has_rational(set);
1078 /* Is this basic set a parameter domain?
1080 isl_bool isl_basic_set_is_params(__isl_keep isl_basic_set *bset)
1082 if (!bset)
1083 return isl_bool_error;
1084 return isl_space_is_params(bset->dim);
1087 /* Is this set a parameter domain?
1089 isl_bool isl_set_is_params(__isl_keep isl_set *set)
1091 if (!set)
1092 return isl_bool_error;
1093 return isl_space_is_params(set->dim);
1096 /* Is this map actually a parameter domain?
1097 * Users should never call this function. Outside of isl,
1098 * a map can never be a parameter domain.
1100 isl_bool isl_map_is_params(__isl_keep isl_map *map)
1102 if (!map)
1103 return isl_bool_error;
1104 return isl_space_is_params(map->dim);
1107 static struct isl_basic_map *basic_map_init(struct isl_ctx *ctx,
1108 struct isl_basic_map *bmap, unsigned extra,
1109 unsigned n_eq, unsigned n_ineq)
1111 int i;
1112 size_t row_size = 1 + isl_space_dim(bmap->dim, isl_dim_all) + extra;
1114 bmap->ctx = ctx;
1115 isl_ctx_ref(ctx);
1117 bmap->block = isl_blk_alloc(ctx, (n_ineq + n_eq) * row_size);
1118 if (isl_blk_is_error(bmap->block))
1119 goto error;
1121 bmap->ineq = isl_alloc_array(ctx, isl_int *, n_ineq + n_eq);
1122 if ((n_ineq + n_eq) && !bmap->ineq)
1123 goto error;
1125 if (extra == 0) {
1126 bmap->block2 = isl_blk_empty();
1127 bmap->div = NULL;
1128 } else {
1129 bmap->block2 = isl_blk_alloc(ctx, extra * (1 + row_size));
1130 if (isl_blk_is_error(bmap->block2))
1131 goto error;
1133 bmap->div = isl_alloc_array(ctx, isl_int *, extra);
1134 if (!bmap->div)
1135 goto error;
1138 for (i = 0; i < n_ineq + n_eq; ++i)
1139 bmap->ineq[i] = bmap->block.data + i * row_size;
1141 for (i = 0; i < extra; ++i)
1142 bmap->div[i] = bmap->block2.data + i * (1 + row_size);
1144 bmap->ref = 1;
1145 bmap->flags = 0;
1146 bmap->c_size = n_eq + n_ineq;
1147 bmap->eq = bmap->ineq + n_ineq;
1148 bmap->extra = extra;
1149 bmap->n_eq = 0;
1150 bmap->n_ineq = 0;
1151 bmap->n_div = 0;
1152 bmap->sample = NULL;
1154 return bmap;
1155 error:
1156 isl_basic_map_free(bmap);
1157 return NULL;
1160 struct isl_basic_set *isl_basic_set_alloc(struct isl_ctx *ctx,
1161 unsigned nparam, unsigned dim, unsigned extra,
1162 unsigned n_eq, unsigned n_ineq)
1164 struct isl_basic_map *bmap;
1165 isl_space *space;
1167 space = isl_space_set_alloc(ctx, nparam, dim);
1168 if (!space)
1169 return NULL;
1171 bmap = isl_basic_map_alloc_space(space, extra, n_eq, n_ineq);
1172 return bset_from_bmap(bmap);
1175 __isl_give isl_basic_set *isl_basic_set_alloc_space(__isl_take isl_space *dim,
1176 unsigned extra, unsigned n_eq, unsigned n_ineq)
1178 struct isl_basic_map *bmap;
1179 if (!dim)
1180 return NULL;
1181 isl_assert(dim->ctx, dim->n_in == 0, goto error);
1182 bmap = isl_basic_map_alloc_space(dim, extra, n_eq, n_ineq);
1183 return bset_from_bmap(bmap);
1184 error:
1185 isl_space_free(dim);
1186 return NULL;
1189 struct isl_basic_map *isl_basic_map_alloc_space(__isl_take isl_space *dim,
1190 unsigned extra, unsigned n_eq, unsigned n_ineq)
1192 struct isl_basic_map *bmap;
1194 if (!dim)
1195 return NULL;
1196 bmap = isl_calloc_type(dim->ctx, struct isl_basic_map);
1197 if (!bmap)
1198 goto error;
1199 bmap->dim = dim;
1201 return basic_map_init(dim->ctx, bmap, extra, n_eq, n_ineq);
1202 error:
1203 isl_space_free(dim);
1204 return NULL;
1207 struct isl_basic_map *isl_basic_map_alloc(struct isl_ctx *ctx,
1208 unsigned nparam, unsigned in, unsigned out, unsigned extra,
1209 unsigned n_eq, unsigned n_ineq)
1211 struct isl_basic_map *bmap;
1212 isl_space *dim;
1214 dim = isl_space_alloc(ctx, nparam, in, out);
1215 if (!dim)
1216 return NULL;
1218 bmap = isl_basic_map_alloc_space(dim, extra, n_eq, n_ineq);
1219 return bmap;
1222 static void dup_constraints(
1223 struct isl_basic_map *dst, struct isl_basic_map *src)
1225 int i;
1226 unsigned total = isl_basic_map_total_dim(src);
1228 for (i = 0; i < src->n_eq; ++i) {
1229 int j = isl_basic_map_alloc_equality(dst);
1230 isl_seq_cpy(dst->eq[j], src->eq[i], 1+total);
1233 for (i = 0; i < src->n_ineq; ++i) {
1234 int j = isl_basic_map_alloc_inequality(dst);
1235 isl_seq_cpy(dst->ineq[j], src->ineq[i], 1+total);
1238 for (i = 0; i < src->n_div; ++i) {
1239 int j = isl_basic_map_alloc_div(dst);
1240 isl_seq_cpy(dst->div[j], src->div[i], 1+1+total);
1242 ISL_F_SET(dst, ISL_BASIC_SET_FINAL);
1245 __isl_give isl_basic_map *isl_basic_map_dup(__isl_keep isl_basic_map *bmap)
1247 struct isl_basic_map *dup;
1249 if (!bmap)
1250 return NULL;
1251 dup = isl_basic_map_alloc_space(isl_space_copy(bmap->dim),
1252 bmap->n_div, bmap->n_eq, bmap->n_ineq);
1253 if (!dup)
1254 return NULL;
1255 dup_constraints(dup, bmap);
1256 dup->flags = bmap->flags;
1257 dup->sample = isl_vec_copy(bmap->sample);
1258 return dup;
1261 struct isl_basic_set *isl_basic_set_dup(struct isl_basic_set *bset)
1263 struct isl_basic_map *dup;
1265 dup = isl_basic_map_dup(bset_to_bmap(bset));
1266 return bset_from_bmap(dup);
1269 __isl_give isl_basic_set *isl_basic_set_copy(__isl_keep isl_basic_set *bset)
1271 if (!bset)
1272 return NULL;
1274 if (ISL_F_ISSET(bset, ISL_BASIC_SET_FINAL)) {
1275 bset->ref++;
1276 return bset;
1278 return isl_basic_set_dup(bset);
1281 __isl_give isl_set *isl_set_copy(__isl_keep isl_set *set)
1283 if (!set)
1284 return NULL;
1286 set->ref++;
1287 return set;
1290 __isl_give isl_basic_map *isl_basic_map_copy(__isl_keep isl_basic_map *bmap)
1292 if (!bmap)
1293 return NULL;
1295 if (ISL_F_ISSET(bmap, ISL_BASIC_SET_FINAL)) {
1296 bmap->ref++;
1297 return bmap;
1299 bmap = isl_basic_map_dup(bmap);
1300 if (bmap)
1301 ISL_F_SET(bmap, ISL_BASIC_SET_FINAL);
1302 return bmap;
1305 __isl_give isl_map *isl_map_copy(__isl_keep isl_map *map)
1307 if (!map)
1308 return NULL;
1310 map->ref++;
1311 return map;
1314 __isl_null isl_basic_map *isl_basic_map_free(__isl_take isl_basic_map *bmap)
1316 if (!bmap)
1317 return NULL;
1319 if (--bmap->ref > 0)
1320 return NULL;
1322 isl_ctx_deref(bmap->ctx);
1323 free(bmap->div);
1324 isl_blk_free(bmap->ctx, bmap->block2);
1325 free(bmap->ineq);
1326 isl_blk_free(bmap->ctx, bmap->block);
1327 isl_vec_free(bmap->sample);
1328 isl_space_free(bmap->dim);
1329 free(bmap);
1331 return NULL;
1334 __isl_null isl_basic_set *isl_basic_set_free(__isl_take isl_basic_set *bset)
1336 return isl_basic_map_free(bset_to_bmap(bset));
1339 static int room_for_con(struct isl_basic_map *bmap, unsigned n)
1341 return bmap->n_eq + bmap->n_ineq + n <= bmap->c_size;
1344 /* Check that "map" has only named parameters, reporting an error
1345 * if it does not.
1347 isl_stat isl_map_check_named_params(__isl_keep isl_map *map)
1349 return isl_space_check_named_params(isl_map_peek_space(map));
1352 /* Check that "bmap" has only named parameters, reporting an error
1353 * if it does not.
1355 static isl_stat isl_basic_map_check_named_params(__isl_keep isl_basic_map *bmap)
1357 return isl_space_check_named_params(isl_basic_map_peek_space(bmap));
1360 /* Check that "bmap1" and "bmap2" have the same parameters,
1361 * reporting an error if they do not.
1363 static isl_stat isl_basic_map_check_equal_params(
1364 __isl_keep isl_basic_map *bmap1, __isl_keep isl_basic_map *bmap2)
1366 isl_bool match;
1368 match = isl_basic_map_has_equal_params(bmap1, bmap2);
1369 if (match < 0)
1370 return isl_stat_error;
1371 if (!match)
1372 isl_die(isl_basic_map_get_ctx(bmap1), isl_error_invalid,
1373 "parameters don't match", return isl_stat_error);
1374 return isl_stat_ok;
1377 __isl_give isl_map *isl_map_align_params_map_map_and(
1378 __isl_take isl_map *map1, __isl_take isl_map *map2,
1379 __isl_give isl_map *(*fn)(__isl_take isl_map *map1,
1380 __isl_take isl_map *map2))
1382 if (!map1 || !map2)
1383 goto error;
1384 if (isl_map_has_equal_params(map1, map2))
1385 return fn(map1, map2);
1386 if (isl_map_check_named_params(map1) < 0)
1387 goto error;
1388 if (isl_map_check_named_params(map2) < 0)
1389 goto error;
1390 map1 = isl_map_align_params(map1, isl_map_get_space(map2));
1391 map2 = isl_map_align_params(map2, isl_map_get_space(map1));
1392 return fn(map1, map2);
1393 error:
1394 isl_map_free(map1);
1395 isl_map_free(map2);
1396 return NULL;
1399 isl_bool isl_map_align_params_map_map_and_test(__isl_keep isl_map *map1,
1400 __isl_keep isl_map *map2,
1401 isl_bool (*fn)(__isl_keep isl_map *map1, __isl_keep isl_map *map2))
1403 isl_bool r;
1405 if (!map1 || !map2)
1406 return isl_bool_error;
1407 if (isl_map_has_equal_params(map1, map2))
1408 return fn(map1, map2);
1409 if (isl_map_check_named_params(map1) < 0)
1410 return isl_bool_error;
1411 if (isl_map_check_named_params(map2) < 0)
1412 return isl_bool_error;
1413 map1 = isl_map_copy(map1);
1414 map2 = isl_map_copy(map2);
1415 map1 = isl_map_align_params(map1, isl_map_get_space(map2));
1416 map2 = isl_map_align_params(map2, isl_map_get_space(map1));
1417 r = fn(map1, map2);
1418 isl_map_free(map1);
1419 isl_map_free(map2);
1420 return r;
1423 int isl_basic_map_alloc_equality(struct isl_basic_map *bmap)
1425 struct isl_ctx *ctx;
1426 if (!bmap)
1427 return -1;
1428 ctx = bmap->ctx;
1429 isl_assert(ctx, room_for_con(bmap, 1), return -1);
1430 isl_assert(ctx, (bmap->eq - bmap->ineq) + bmap->n_eq <= bmap->c_size,
1431 return -1);
1432 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
1433 ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT);
1434 ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_IMPLICIT);
1435 ISL_F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES);
1436 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
1437 if ((bmap->eq - bmap->ineq) + bmap->n_eq == bmap->c_size) {
1438 isl_int *t;
1439 int j = isl_basic_map_alloc_inequality(bmap);
1440 if (j < 0)
1441 return -1;
1442 t = bmap->ineq[j];
1443 bmap->ineq[j] = bmap->ineq[bmap->n_ineq - 1];
1444 bmap->ineq[bmap->n_ineq - 1] = bmap->eq[-1];
1445 bmap->eq[-1] = t;
1446 bmap->n_eq++;
1447 bmap->n_ineq--;
1448 bmap->eq--;
1449 return 0;
1451 isl_seq_clr(bmap->eq[bmap->n_eq] + 1 + isl_basic_map_total_dim(bmap),
1452 bmap->extra - bmap->n_div);
1453 return bmap->n_eq++;
1456 int isl_basic_set_alloc_equality(struct isl_basic_set *bset)
1458 return isl_basic_map_alloc_equality(bset_to_bmap(bset));
1461 int isl_basic_map_free_equality(struct isl_basic_map *bmap, unsigned n)
1463 if (!bmap)
1464 return -1;
1465 isl_assert(bmap->ctx, n <= bmap->n_eq, return -1);
1466 bmap->n_eq -= n;
1467 return 0;
1470 int isl_basic_set_free_equality(struct isl_basic_set *bset, unsigned n)
1472 return isl_basic_map_free_equality(bset_to_bmap(bset), n);
1475 int isl_basic_map_drop_equality(struct isl_basic_map *bmap, unsigned pos)
1477 isl_int *t;
1478 if (!bmap)
1479 return -1;
1480 isl_assert(bmap->ctx, pos < bmap->n_eq, return -1);
1482 if (pos != bmap->n_eq - 1) {
1483 t = bmap->eq[pos];
1484 bmap->eq[pos] = bmap->eq[bmap->n_eq - 1];
1485 bmap->eq[bmap->n_eq - 1] = t;
1487 bmap->n_eq--;
1488 return 0;
1491 /* Turn inequality "pos" of "bmap" into an equality.
1493 * In particular, we move the inequality in front of the equalities
1494 * and move the last inequality in the position of the moved inequality.
1495 * Note that isl_tab_make_equalities_explicit depends on this particular
1496 * change in the ordering of the constraints.
1498 void isl_basic_map_inequality_to_equality(
1499 struct isl_basic_map *bmap, unsigned pos)
1501 isl_int *t;
1503 t = bmap->ineq[pos];
1504 bmap->ineq[pos] = bmap->ineq[bmap->n_ineq - 1];
1505 bmap->ineq[bmap->n_ineq - 1] = bmap->eq[-1];
1506 bmap->eq[-1] = t;
1507 bmap->n_eq++;
1508 bmap->n_ineq--;
1509 bmap->eq--;
1510 ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT);
1511 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
1512 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
1513 ISL_F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES);
1516 static int room_for_ineq(struct isl_basic_map *bmap, unsigned n)
1518 return bmap->n_ineq + n <= bmap->eq - bmap->ineq;
1521 int isl_basic_map_alloc_inequality(__isl_keep isl_basic_map *bmap)
1523 struct isl_ctx *ctx;
1524 if (!bmap)
1525 return -1;
1526 ctx = bmap->ctx;
1527 isl_assert(ctx, room_for_ineq(bmap, 1), return -1);
1528 ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_IMPLICIT);
1529 ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT);
1530 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
1531 ISL_F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES);
1532 isl_seq_clr(bmap->ineq[bmap->n_ineq] +
1533 1 + isl_basic_map_total_dim(bmap),
1534 bmap->extra - bmap->n_div);
1535 return bmap->n_ineq++;
1538 int isl_basic_set_alloc_inequality(__isl_keep isl_basic_set *bset)
1540 return isl_basic_map_alloc_inequality(bset_to_bmap(bset));
1543 int isl_basic_map_free_inequality(struct isl_basic_map *bmap, unsigned n)
1545 if (!bmap)
1546 return -1;
1547 isl_assert(bmap->ctx, n <= bmap->n_ineq, return -1);
1548 bmap->n_ineq -= n;
1549 return 0;
1552 int isl_basic_set_free_inequality(struct isl_basic_set *bset, unsigned n)
1554 return isl_basic_map_free_inequality(bset_to_bmap(bset), n);
1557 int isl_basic_map_drop_inequality(struct isl_basic_map *bmap, unsigned pos)
1559 isl_int *t;
1560 if (!bmap)
1561 return -1;
1562 isl_assert(bmap->ctx, pos < bmap->n_ineq, return -1);
1564 if (pos != bmap->n_ineq - 1) {
1565 t = bmap->ineq[pos];
1566 bmap->ineq[pos] = bmap->ineq[bmap->n_ineq - 1];
1567 bmap->ineq[bmap->n_ineq - 1] = t;
1568 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
1570 bmap->n_ineq--;
1571 return 0;
1574 int isl_basic_set_drop_inequality(struct isl_basic_set *bset, unsigned pos)
1576 return isl_basic_map_drop_inequality(bset_to_bmap(bset), pos);
1579 __isl_give isl_basic_map *isl_basic_map_add_eq(__isl_take isl_basic_map *bmap,
1580 isl_int *eq)
1582 int k;
1584 bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
1585 if (!bmap)
1586 return NULL;
1587 k = isl_basic_map_alloc_equality(bmap);
1588 if (k < 0)
1589 goto error;
1590 isl_seq_cpy(bmap->eq[k], eq, 1 + isl_basic_map_total_dim(bmap));
1591 return bmap;
1592 error:
1593 isl_basic_map_free(bmap);
1594 return NULL;
1597 __isl_give isl_basic_set *isl_basic_set_add_eq(__isl_take isl_basic_set *bset,
1598 isl_int *eq)
1600 return bset_from_bmap(isl_basic_map_add_eq(bset_to_bmap(bset), eq));
1603 __isl_give isl_basic_map *isl_basic_map_add_ineq(__isl_take isl_basic_map *bmap,
1604 isl_int *ineq)
1606 int k;
1608 bmap = isl_basic_map_extend_constraints(bmap, 0, 1);
1609 if (!bmap)
1610 return NULL;
1611 k = isl_basic_map_alloc_inequality(bmap);
1612 if (k < 0)
1613 goto error;
1614 isl_seq_cpy(bmap->ineq[k], ineq, 1 + isl_basic_map_total_dim(bmap));
1615 return bmap;
1616 error:
1617 isl_basic_map_free(bmap);
1618 return NULL;
1621 __isl_give isl_basic_set *isl_basic_set_add_ineq(__isl_take isl_basic_set *bset,
1622 isl_int *ineq)
1624 return bset_from_bmap(isl_basic_map_add_ineq(bset_to_bmap(bset), ineq));
1627 int isl_basic_map_alloc_div(struct isl_basic_map *bmap)
1629 if (!bmap)
1630 return -1;
1631 isl_assert(bmap->ctx, bmap->n_div < bmap->extra, return -1);
1632 isl_seq_clr(bmap->div[bmap->n_div] +
1633 1 + 1 + isl_basic_map_total_dim(bmap),
1634 bmap->extra - bmap->n_div);
1635 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
1636 return bmap->n_div++;
1639 int isl_basic_set_alloc_div(struct isl_basic_set *bset)
1641 return isl_basic_map_alloc_div(bset_to_bmap(bset));
1644 /* Check that there are "n" dimensions of type "type" starting at "first"
1645 * in "bmap".
1647 static isl_stat isl_basic_map_check_range(__isl_keep isl_basic_map *bmap,
1648 enum isl_dim_type type, unsigned first, unsigned n)
1650 unsigned dim;
1652 if (!bmap)
1653 return isl_stat_error;
1654 dim = isl_basic_map_dim(bmap, type);
1655 if (first + n > dim || first + n < first)
1656 isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
1657 "position or range out of bounds",
1658 return isl_stat_error);
1659 return isl_stat_ok;
1662 /* Insert an extra integer division, prescribed by "div", to "bmap"
1663 * at (integer division) position "pos".
1665 * The integer division is first added at the end and then moved
1666 * into the right position.
1668 __isl_give isl_basic_map *isl_basic_map_insert_div(
1669 __isl_take isl_basic_map *bmap, int pos, __isl_keep isl_vec *div)
1671 int i, k;
1673 bmap = isl_basic_map_cow(bmap);
1674 if (!bmap || !div)
1675 return isl_basic_map_free(bmap);
1677 if (div->size != 1 + 1 + isl_basic_map_dim(bmap, isl_dim_all))
1678 isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
1679 "unexpected size", return isl_basic_map_free(bmap));
1680 if (isl_basic_map_check_range(bmap, isl_dim_div, pos, 0) < 0)
1681 return isl_basic_map_free(bmap);
1683 bmap = isl_basic_map_extend_space(bmap,
1684 isl_basic_map_get_space(bmap), 1, 0, 2);
1685 k = isl_basic_map_alloc_div(bmap);
1686 if (k < 0)
1687 return isl_basic_map_free(bmap);
1688 isl_seq_cpy(bmap->div[k], div->el, div->size);
1689 isl_int_set_si(bmap->div[k][div->size], 0);
1691 for (i = k; i > pos; --i)
1692 isl_basic_map_swap_div(bmap, i, i - 1);
1694 return bmap;
1697 isl_stat isl_basic_map_free_div(struct isl_basic_map *bmap, unsigned n)
1699 if (!bmap)
1700 return isl_stat_error;
1701 isl_assert(bmap->ctx, n <= bmap->n_div, return isl_stat_error);
1702 bmap->n_div -= n;
1703 return isl_stat_ok;
1706 /* Copy constraint from src to dst, putting the vars of src at offset
1707 * dim_off in dst and the divs of src at offset div_off in dst.
1708 * If both sets are actually map, then dim_off applies to the input
1709 * variables.
1711 static void copy_constraint(struct isl_basic_map *dst_map, isl_int *dst,
1712 struct isl_basic_map *src_map, isl_int *src,
1713 unsigned in_off, unsigned out_off, unsigned div_off)
1715 unsigned src_nparam = isl_basic_map_dim(src_map, isl_dim_param);
1716 unsigned dst_nparam = isl_basic_map_dim(dst_map, isl_dim_param);
1717 unsigned src_in = isl_basic_map_dim(src_map, isl_dim_in);
1718 unsigned dst_in = isl_basic_map_dim(dst_map, isl_dim_in);
1719 unsigned src_out = isl_basic_map_dim(src_map, isl_dim_out);
1720 unsigned dst_out = isl_basic_map_dim(dst_map, isl_dim_out);
1721 isl_int_set(dst[0], src[0]);
1722 isl_seq_cpy(dst+1, src+1, isl_min(dst_nparam, src_nparam));
1723 if (dst_nparam > src_nparam)
1724 isl_seq_clr(dst+1+src_nparam,
1725 dst_nparam - src_nparam);
1726 isl_seq_clr(dst+1+dst_nparam, in_off);
1727 isl_seq_cpy(dst+1+dst_nparam+in_off,
1728 src+1+src_nparam,
1729 isl_min(dst_in-in_off, src_in));
1730 if (dst_in-in_off > src_in)
1731 isl_seq_clr(dst+1+dst_nparam+in_off+src_in,
1732 dst_in - in_off - src_in);
1733 isl_seq_clr(dst+1+dst_nparam+dst_in, out_off);
1734 isl_seq_cpy(dst+1+dst_nparam+dst_in+out_off,
1735 src+1+src_nparam+src_in,
1736 isl_min(dst_out-out_off, src_out));
1737 if (dst_out-out_off > src_out)
1738 isl_seq_clr(dst+1+dst_nparam+dst_in+out_off+src_out,
1739 dst_out - out_off - src_out);
1740 isl_seq_clr(dst+1+dst_nparam+dst_in+dst_out, div_off);
1741 isl_seq_cpy(dst+1+dst_nparam+dst_in+dst_out+div_off,
1742 src+1+src_nparam+src_in+src_out,
1743 isl_min(dst_map->extra-div_off, src_map->n_div));
1744 if (dst_map->n_div-div_off > src_map->n_div)
1745 isl_seq_clr(dst+1+dst_nparam+dst_in+dst_out+
1746 div_off+src_map->n_div,
1747 dst_map->n_div - div_off - src_map->n_div);
1750 static void copy_div(struct isl_basic_map *dst_map, isl_int *dst,
1751 struct isl_basic_map *src_map, isl_int *src,
1752 unsigned in_off, unsigned out_off, unsigned div_off)
1754 isl_int_set(dst[0], src[0]);
1755 copy_constraint(dst_map, dst+1, src_map, src+1, in_off, out_off, div_off);
1758 static __isl_give isl_basic_map *add_constraints(
1759 __isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2,
1760 unsigned i_pos, unsigned o_pos)
1762 int i;
1763 unsigned div_off;
1765 if (!bmap1 || !bmap2)
1766 goto error;
1768 div_off = bmap1->n_div;
1770 for (i = 0; i < bmap2->n_eq; ++i) {
1771 int i1 = isl_basic_map_alloc_equality(bmap1);
1772 if (i1 < 0)
1773 goto error;
1774 copy_constraint(bmap1, bmap1->eq[i1], bmap2, bmap2->eq[i],
1775 i_pos, o_pos, div_off);
1778 for (i = 0; i < bmap2->n_ineq; ++i) {
1779 int i1 = isl_basic_map_alloc_inequality(bmap1);
1780 if (i1 < 0)
1781 goto error;
1782 copy_constraint(bmap1, bmap1->ineq[i1], bmap2, bmap2->ineq[i],
1783 i_pos, o_pos, div_off);
1786 for (i = 0; i < bmap2->n_div; ++i) {
1787 int i1 = isl_basic_map_alloc_div(bmap1);
1788 if (i1 < 0)
1789 goto error;
1790 copy_div(bmap1, bmap1->div[i1], bmap2, bmap2->div[i],
1791 i_pos, o_pos, div_off);
1794 isl_basic_map_free(bmap2);
1796 return bmap1;
1798 error:
1799 isl_basic_map_free(bmap1);
1800 isl_basic_map_free(bmap2);
1801 return NULL;
1804 struct isl_basic_set *isl_basic_set_add_constraints(struct isl_basic_set *bset1,
1805 struct isl_basic_set *bset2, unsigned pos)
1807 return bset_from_bmap(add_constraints(bset_to_bmap(bset1),
1808 bset_to_bmap(bset2), 0, pos));
1811 __isl_give isl_basic_map *isl_basic_map_extend_space(
1812 __isl_take isl_basic_map *base, __isl_take isl_space *dim,
1813 unsigned extra, unsigned n_eq, unsigned n_ineq)
1815 struct isl_basic_map *ext;
1816 unsigned flags;
1817 int dims_ok;
1819 if (!dim)
1820 goto error;
1822 if (!base)
1823 goto error;
1825 dims_ok = isl_space_is_equal(base->dim, dim) &&
1826 base->extra >= base->n_div + extra;
1828 if (dims_ok && room_for_con(base, n_eq + n_ineq) &&
1829 room_for_ineq(base, n_ineq)) {
1830 isl_space_free(dim);
1831 return base;
1834 isl_assert(base->ctx, base->dim->nparam <= dim->nparam, goto error);
1835 isl_assert(base->ctx, base->dim->n_in <= dim->n_in, goto error);
1836 isl_assert(base->ctx, base->dim->n_out <= dim->n_out, goto error);
1837 extra += base->extra;
1838 n_eq += base->n_eq;
1839 n_ineq += base->n_ineq;
1841 ext = isl_basic_map_alloc_space(dim, extra, n_eq, n_ineq);
1842 dim = NULL;
1843 if (!ext)
1844 goto error;
1846 if (dims_ok)
1847 ext->sample = isl_vec_copy(base->sample);
1848 flags = base->flags;
1849 ext = add_constraints(ext, base, 0, 0);
1850 if (ext) {
1851 ext->flags = flags;
1852 ISL_F_CLR(ext, ISL_BASIC_SET_FINAL);
1855 return ext;
1857 error:
1858 isl_space_free(dim);
1859 isl_basic_map_free(base);
1860 return NULL;
1863 __isl_give isl_basic_set *isl_basic_set_extend_space(
1864 __isl_take isl_basic_set *base,
1865 __isl_take isl_space *dim, unsigned extra,
1866 unsigned n_eq, unsigned n_ineq)
1868 return bset_from_bmap(isl_basic_map_extend_space(bset_to_bmap(base),
1869 dim, extra, n_eq, n_ineq));
1872 struct isl_basic_map *isl_basic_map_extend_constraints(
1873 struct isl_basic_map *base, unsigned n_eq, unsigned n_ineq)
1875 if (!base)
1876 return NULL;
1877 return isl_basic_map_extend_space(base, isl_space_copy(base->dim),
1878 0, n_eq, n_ineq);
1881 struct isl_basic_map *isl_basic_map_extend(struct isl_basic_map *base,
1882 unsigned nparam, unsigned n_in, unsigned n_out, unsigned extra,
1883 unsigned n_eq, unsigned n_ineq)
1885 struct isl_basic_map *bmap;
1886 isl_space *dim;
1888 if (!base)
1889 return NULL;
1890 dim = isl_space_alloc(base->ctx, nparam, n_in, n_out);
1891 if (!dim)
1892 goto error;
1894 bmap = isl_basic_map_extend_space(base, dim, extra, n_eq, n_ineq);
1895 return bmap;
1896 error:
1897 isl_basic_map_free(base);
1898 return NULL;
1901 struct isl_basic_set *isl_basic_set_extend(struct isl_basic_set *base,
1902 unsigned nparam, unsigned dim, unsigned extra,
1903 unsigned n_eq, unsigned n_ineq)
1905 return bset_from_bmap(isl_basic_map_extend(bset_to_bmap(base),
1906 nparam, 0, dim, extra, n_eq, n_ineq));
1909 struct isl_basic_set *isl_basic_set_extend_constraints(
1910 struct isl_basic_set *base, unsigned n_eq, unsigned n_ineq)
1912 isl_basic_map *bmap = bset_to_bmap(base);
1913 bmap = isl_basic_map_extend_constraints(bmap, n_eq, n_ineq);
1914 return bset_from_bmap(bmap);
1917 __isl_give isl_basic_set *isl_basic_set_cow(__isl_take isl_basic_set *bset)
1919 return bset_from_bmap(isl_basic_map_cow(bset_to_bmap(bset)));
1922 __isl_give isl_basic_map *isl_basic_map_cow(__isl_take isl_basic_map *bmap)
1924 if (!bmap)
1925 return NULL;
1927 if (bmap->ref > 1) {
1928 bmap->ref--;
1929 bmap = isl_basic_map_dup(bmap);
1931 if (bmap) {
1932 ISL_F_CLR(bmap, ISL_BASIC_SET_FINAL);
1933 ISL_F_CLR(bmap, ISL_BASIC_MAP_REDUCED_COEFFICIENTS);
1935 return bmap;
1938 /* Clear all cached information in "map", either because it is about
1939 * to be modified or because it is being freed.
1940 * Always return the same pointer that is passed in.
1941 * This is needed for the use in isl_map_free.
1943 static __isl_give isl_map *clear_caches(__isl_take isl_map *map)
1945 isl_basic_map_free(map->cached_simple_hull[0]);
1946 isl_basic_map_free(map->cached_simple_hull[1]);
1947 map->cached_simple_hull[0] = NULL;
1948 map->cached_simple_hull[1] = NULL;
1949 return map;
1952 __isl_give isl_set *isl_set_cow(__isl_take isl_set *set)
1954 return isl_map_cow(set);
1957 /* Return an isl_map that is equal to "map" and that has only
1958 * a single reference.
1960 * If the original input already has only one reference, then
1961 * simply return it, but clear all cached information, since
1962 * it may be rendered invalid by the operations that will be
1963 * performed on the result.
1965 * Otherwise, create a duplicate (without any cached information).
1967 __isl_give isl_map *isl_map_cow(__isl_take isl_map *map)
1969 if (!map)
1970 return NULL;
1972 if (map->ref == 1)
1973 return clear_caches(map);
1974 map->ref--;
1975 return isl_map_dup(map);
1978 static void swap_vars(struct isl_blk blk, isl_int *a,
1979 unsigned a_len, unsigned b_len)
1981 isl_seq_cpy(blk.data, a+a_len, b_len);
1982 isl_seq_cpy(blk.data+b_len, a, a_len);
1983 isl_seq_cpy(a, blk.data, b_len+a_len);
1986 static __isl_give isl_basic_map *isl_basic_map_swap_vars(
1987 __isl_take isl_basic_map *bmap, unsigned pos, unsigned n1, unsigned n2)
1989 int i;
1990 struct isl_blk blk;
1992 if (!bmap)
1993 goto error;
1995 isl_assert(bmap->ctx,
1996 pos + n1 + n2 <= 1 + isl_basic_map_total_dim(bmap), goto error);
1998 if (n1 == 0 || n2 == 0)
1999 return bmap;
2001 bmap = isl_basic_map_cow(bmap);
2002 if (!bmap)
2003 return NULL;
2005 blk = isl_blk_alloc(bmap->ctx, n1 + n2);
2006 if (isl_blk_is_error(blk))
2007 goto error;
2009 for (i = 0; i < bmap->n_eq; ++i)
2010 swap_vars(blk,
2011 bmap->eq[i] + pos, n1, n2);
2013 for (i = 0; i < bmap->n_ineq; ++i)
2014 swap_vars(blk,
2015 bmap->ineq[i] + pos, n1, n2);
2017 for (i = 0; i < bmap->n_div; ++i)
2018 swap_vars(blk,
2019 bmap->div[i]+1 + pos, n1, n2);
2021 isl_blk_free(bmap->ctx, blk);
2023 ISL_F_CLR(bmap, ISL_BASIC_SET_NORMALIZED);
2024 bmap = isl_basic_map_gauss(bmap, NULL);
2025 return isl_basic_map_finalize(bmap);
2026 error:
2027 isl_basic_map_free(bmap);
2028 return NULL;
2031 __isl_give isl_basic_map *isl_basic_map_set_to_empty(
2032 __isl_take isl_basic_map *bmap)
2034 int i = 0;
2035 unsigned total;
2036 if (!bmap)
2037 goto error;
2038 total = isl_basic_map_total_dim(bmap);
2039 if (isl_basic_map_free_div(bmap, bmap->n_div) < 0)
2040 return isl_basic_map_free(bmap);
2041 isl_basic_map_free_inequality(bmap, bmap->n_ineq);
2042 if (bmap->n_eq > 0)
2043 isl_basic_map_free_equality(bmap, bmap->n_eq-1);
2044 else {
2045 i = isl_basic_map_alloc_equality(bmap);
2046 if (i < 0)
2047 goto error;
2049 isl_int_set_si(bmap->eq[i][0], 1);
2050 isl_seq_clr(bmap->eq[i]+1, total);
2051 ISL_F_SET(bmap, ISL_BASIC_MAP_EMPTY);
2052 isl_vec_free(bmap->sample);
2053 bmap->sample = NULL;
2054 return isl_basic_map_finalize(bmap);
2055 error:
2056 isl_basic_map_free(bmap);
2057 return NULL;
2060 __isl_give isl_basic_set *isl_basic_set_set_to_empty(
2061 __isl_take isl_basic_set *bset)
2063 return bset_from_bmap(isl_basic_map_set_to_empty(bset_to_bmap(bset)));
2066 __isl_give isl_basic_map *isl_basic_map_set_rational(
2067 __isl_take isl_basic_map *bmap)
2069 if (!bmap)
2070 return NULL;
2072 if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
2073 return bmap;
2075 bmap = isl_basic_map_cow(bmap);
2076 if (!bmap)
2077 return NULL;
2079 ISL_F_SET(bmap, ISL_BASIC_MAP_RATIONAL);
2081 return isl_basic_map_finalize(bmap);
2084 __isl_give isl_basic_set *isl_basic_set_set_rational(
2085 __isl_take isl_basic_set *bset)
2087 return isl_basic_map_set_rational(bset);
2090 __isl_give isl_basic_set *isl_basic_set_set_integral(
2091 __isl_take isl_basic_set *bset)
2093 if (!bset)
2094 return NULL;
2096 if (!ISL_F_ISSET(bset, ISL_BASIC_MAP_RATIONAL))
2097 return bset;
2099 bset = isl_basic_set_cow(bset);
2100 if (!bset)
2101 return NULL;
2103 ISL_F_CLR(bset, ISL_BASIC_MAP_RATIONAL);
2105 return isl_basic_set_finalize(bset);
2108 __isl_give isl_map *isl_map_set_rational(__isl_take isl_map *map)
2110 int i;
2112 map = isl_map_cow(map);
2113 if (!map)
2114 return NULL;
2115 for (i = 0; i < map->n; ++i) {
2116 map->p[i] = isl_basic_map_set_rational(map->p[i]);
2117 if (!map->p[i])
2118 goto error;
2120 return map;
2121 error:
2122 isl_map_free(map);
2123 return NULL;
2126 __isl_give isl_set *isl_set_set_rational(__isl_take isl_set *set)
2128 return isl_map_set_rational(set);
2131 /* Swap divs "a" and "b" in "bmap" (without modifying any of the constraints
2132 * of "bmap").
2134 static void swap_div(__isl_keep isl_basic_map *bmap, int a, int b)
2136 isl_int *t = bmap->div[a];
2137 bmap->div[a] = bmap->div[b];
2138 bmap->div[b] = t;
2141 /* Swap divs "a" and "b" in "bmap" and adjust the constraints and
2142 * div definitions accordingly.
2144 void isl_basic_map_swap_div(struct isl_basic_map *bmap, int a, int b)
2146 int i;
2147 unsigned off = isl_space_dim(bmap->dim, isl_dim_all);
2149 swap_div(bmap, a, b);
2151 for (i = 0; i < bmap->n_eq; ++i)
2152 isl_int_swap(bmap->eq[i][1+off+a], bmap->eq[i][1+off+b]);
2154 for (i = 0; i < bmap->n_ineq; ++i)
2155 isl_int_swap(bmap->ineq[i][1+off+a], bmap->ineq[i][1+off+b]);
2157 for (i = 0; i < bmap->n_div; ++i)
2158 isl_int_swap(bmap->div[i][1+1+off+a], bmap->div[i][1+1+off+b]);
2159 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
2162 /* Swap divs "a" and "b" in "bset" and adjust the constraints and
2163 * div definitions accordingly.
2165 void isl_basic_set_swap_div(__isl_keep isl_basic_set *bset, int a, int b)
2167 isl_basic_map_swap_div(bset, a, b);
2170 static void constraint_drop_vars(isl_int *c, unsigned n, unsigned rem)
2172 isl_seq_cpy(c, c + n, rem);
2173 isl_seq_clr(c + rem, n);
2176 /* Drop n dimensions starting at first.
2178 * In principle, this frees up some extra variables as the number
2179 * of columns remains constant, but we would have to extend
2180 * the div array too as the number of rows in this array is assumed
2181 * to be equal to extra.
2183 __isl_give isl_basic_set *isl_basic_set_drop_dims(
2184 __isl_take isl_basic_set *bset, unsigned first, unsigned n)
2186 return isl_basic_map_drop(bset_to_bmap(bset), isl_dim_set, first, n);
2189 /* Move "n" divs starting at "first" to the end of the list of divs.
2191 static struct isl_basic_map *move_divs_last(struct isl_basic_map *bmap,
2192 unsigned first, unsigned n)
2194 isl_int **div;
2195 int i;
2197 if (first + n == bmap->n_div)
2198 return bmap;
2200 div = isl_alloc_array(bmap->ctx, isl_int *, n);
2201 if (!div)
2202 goto error;
2203 for (i = 0; i < n; ++i)
2204 div[i] = bmap->div[first + i];
2205 for (i = 0; i < bmap->n_div - first - n; ++i)
2206 bmap->div[first + i] = bmap->div[first + n + i];
2207 for (i = 0; i < n; ++i)
2208 bmap->div[bmap->n_div - n + i] = div[i];
2209 free(div);
2210 return bmap;
2211 error:
2212 isl_basic_map_free(bmap);
2213 return NULL;
2216 /* Check that there are "n" dimensions of type "type" starting at "first"
2217 * in "map".
2219 static isl_stat isl_map_check_range(__isl_keep isl_map *map,
2220 enum isl_dim_type type, unsigned first, unsigned n)
2222 if (!map)
2223 return isl_stat_error;
2224 if (first + n > isl_map_dim(map, type) || first + n < first)
2225 isl_die(isl_map_get_ctx(map), isl_error_invalid,
2226 "position or range out of bounds",
2227 return isl_stat_error);
2228 return isl_stat_ok;
2231 /* Drop "n" dimensions of type "type" starting at "first".
2233 * In principle, this frees up some extra variables as the number
2234 * of columns remains constant, but we would have to extend
2235 * the div array too as the number of rows in this array is assumed
2236 * to be equal to extra.
2238 __isl_give isl_basic_map *isl_basic_map_drop(__isl_take isl_basic_map *bmap,
2239 enum isl_dim_type type, unsigned first, unsigned n)
2241 int i;
2242 unsigned dim;
2243 unsigned offset;
2244 unsigned left;
2246 if (!bmap)
2247 goto error;
2249 dim = isl_basic_map_dim(bmap, type);
2250 isl_assert(bmap->ctx, first + n <= dim, goto error);
2252 if (n == 0 && !isl_space_is_named_or_nested(bmap->dim, type))
2253 return bmap;
2255 bmap = isl_basic_map_cow(bmap);
2256 if (!bmap)
2257 return NULL;
2259 offset = isl_basic_map_offset(bmap, type) + first;
2260 left = isl_basic_map_total_dim(bmap) - (offset - 1) - n;
2261 for (i = 0; i < bmap->n_eq; ++i)
2262 constraint_drop_vars(bmap->eq[i]+offset, n, left);
2264 for (i = 0; i < bmap->n_ineq; ++i)
2265 constraint_drop_vars(bmap->ineq[i]+offset, n, left);
2267 for (i = 0; i < bmap->n_div; ++i)
2268 constraint_drop_vars(bmap->div[i]+1+offset, n, left);
2270 if (type == isl_dim_div) {
2271 bmap = move_divs_last(bmap, first, n);
2272 if (!bmap)
2273 goto error;
2274 if (isl_basic_map_free_div(bmap, n) < 0)
2275 return isl_basic_map_free(bmap);
2276 } else
2277 bmap->dim = isl_space_drop_dims(bmap->dim, type, first, n);
2278 if (!bmap->dim)
2279 goto error;
2281 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
2282 bmap = isl_basic_map_simplify(bmap);
2283 return isl_basic_map_finalize(bmap);
2284 error:
2285 isl_basic_map_free(bmap);
2286 return NULL;
2289 __isl_give isl_basic_set *isl_basic_set_drop(__isl_take isl_basic_set *bset,
2290 enum isl_dim_type type, unsigned first, unsigned n)
2292 return bset_from_bmap(isl_basic_map_drop(bset_to_bmap(bset),
2293 type, first, n));
2296 /* No longer consider "map" to be normalized.
2298 static __isl_give isl_map *isl_map_unmark_normalized(__isl_take isl_map *map)
2300 if (!map)
2301 return NULL;
2302 ISL_F_CLR(map, ISL_MAP_NORMALIZED);
2303 return map;
2306 __isl_give isl_map *isl_map_drop(__isl_take isl_map *map,
2307 enum isl_dim_type type, unsigned first, unsigned n)
2309 int i;
2311 if (isl_map_check_range(map, type, first, n) < 0)
2312 return isl_map_free(map);
2314 if (n == 0 && !isl_space_is_named_or_nested(map->dim, type))
2315 return map;
2316 map = isl_map_cow(map);
2317 if (!map)
2318 goto error;
2319 map->dim = isl_space_drop_dims(map->dim, type, first, n);
2320 if (!map->dim)
2321 goto error;
2323 for (i = 0; i < map->n; ++i) {
2324 map->p[i] = isl_basic_map_drop(map->p[i], type, first, n);
2325 if (!map->p[i])
2326 goto error;
2328 map = isl_map_unmark_normalized(map);
2330 return map;
2331 error:
2332 isl_map_free(map);
2333 return NULL;
2336 __isl_give isl_set *isl_set_drop(__isl_take isl_set *set,
2337 enum isl_dim_type type, unsigned first, unsigned n)
2339 return set_from_map(isl_map_drop(set_to_map(set), type, first, n));
2343 * We don't cow, as the div is assumed to be redundant.
2345 __isl_give isl_basic_map *isl_basic_map_drop_div(
2346 __isl_take isl_basic_map *bmap, unsigned div)
2348 int i;
2349 unsigned pos;
2351 if (!bmap)
2352 goto error;
2354 pos = 1 + isl_space_dim(bmap->dim, isl_dim_all) + div;
2356 isl_assert(bmap->ctx, div < bmap->n_div, goto error);
2358 for (i = 0; i < bmap->n_eq; ++i)
2359 constraint_drop_vars(bmap->eq[i]+pos, 1, bmap->extra-div-1);
2361 for (i = 0; i < bmap->n_ineq; ++i) {
2362 if (!isl_int_is_zero(bmap->ineq[i][pos])) {
2363 isl_basic_map_drop_inequality(bmap, i);
2364 --i;
2365 continue;
2367 constraint_drop_vars(bmap->ineq[i]+pos, 1, bmap->extra-div-1);
2370 for (i = 0; i < bmap->n_div; ++i)
2371 constraint_drop_vars(bmap->div[i]+1+pos, 1, bmap->extra-div-1);
2373 if (div != bmap->n_div - 1) {
2374 int j;
2375 isl_int *t = bmap->div[div];
2377 for (j = div; j < bmap->n_div - 1; ++j)
2378 bmap->div[j] = bmap->div[j+1];
2380 bmap->div[bmap->n_div - 1] = t;
2382 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
2383 if (isl_basic_map_free_div(bmap, 1) < 0)
2384 return isl_basic_map_free(bmap);
2386 return bmap;
2387 error:
2388 isl_basic_map_free(bmap);
2389 return NULL;
2392 /* Eliminate the specified n dimensions starting at first from the
2393 * constraints, without removing the dimensions from the space.
2394 * If the set is rational, the dimensions are eliminated using Fourier-Motzkin.
2396 __isl_give isl_map *isl_map_eliminate(__isl_take isl_map *map,
2397 enum isl_dim_type type, unsigned first, unsigned n)
2399 int i;
2401 if (n == 0)
2402 return map;
2404 if (isl_map_check_range(map, type, first, n) < 0)
2405 return isl_map_free(map);
2407 map = isl_map_cow(map);
2408 if (!map)
2409 return NULL;
2411 for (i = 0; i < map->n; ++i) {
2412 map->p[i] = isl_basic_map_eliminate(map->p[i], type, first, n);
2413 if (!map->p[i])
2414 goto error;
2416 return map;
2417 error:
2418 isl_map_free(map);
2419 return NULL;
2422 /* Eliminate the specified n dimensions starting at first from the
2423 * constraints, without removing the dimensions from the space.
2424 * If the set is rational, the dimensions are eliminated using Fourier-Motzkin.
2426 __isl_give isl_set *isl_set_eliminate(__isl_take isl_set *set,
2427 enum isl_dim_type type, unsigned first, unsigned n)
2429 return set_from_map(isl_map_eliminate(set_to_map(set), type, first, n));
2432 /* Eliminate the specified n dimensions starting at first from the
2433 * constraints, without removing the dimensions from the space.
2434 * If the set is rational, the dimensions are eliminated using Fourier-Motzkin.
2436 __isl_give isl_set *isl_set_eliminate_dims(__isl_take isl_set *set,
2437 unsigned first, unsigned n)
2439 return isl_set_eliminate(set, isl_dim_set, first, n);
2442 __isl_give isl_basic_map *isl_basic_map_remove_divs(
2443 __isl_take isl_basic_map *bmap)
2445 if (!bmap)
2446 return NULL;
2447 bmap = isl_basic_map_eliminate_vars(bmap,
2448 isl_space_dim(bmap->dim, isl_dim_all), bmap->n_div);
2449 if (!bmap)
2450 return NULL;
2451 bmap->n_div = 0;
2452 return isl_basic_map_finalize(bmap);
2455 __isl_give isl_basic_set *isl_basic_set_remove_divs(
2456 __isl_take isl_basic_set *bset)
2458 return bset_from_bmap(isl_basic_map_remove_divs(bset_to_bmap(bset)));
2461 __isl_give isl_map *isl_map_remove_divs(__isl_take isl_map *map)
2463 int i;
2465 if (!map)
2466 return NULL;
2467 if (map->n == 0)
2468 return map;
2470 map = isl_map_cow(map);
2471 if (!map)
2472 return NULL;
2474 for (i = 0; i < map->n; ++i) {
2475 map->p[i] = isl_basic_map_remove_divs(map->p[i]);
2476 if (!map->p[i])
2477 goto error;
2479 return map;
2480 error:
2481 isl_map_free(map);
2482 return NULL;
2485 __isl_give isl_set *isl_set_remove_divs(__isl_take isl_set *set)
2487 return isl_map_remove_divs(set);
2490 __isl_give isl_basic_map *isl_basic_map_remove_dims(
2491 __isl_take isl_basic_map *bmap, enum isl_dim_type type,
2492 unsigned first, unsigned n)
2494 if (isl_basic_map_check_range(bmap, type, first, n) < 0)
2495 return isl_basic_map_free(bmap);
2496 if (n == 0 && !isl_space_is_named_or_nested(bmap->dim, type))
2497 return bmap;
2498 bmap = isl_basic_map_eliminate_vars(bmap,
2499 isl_basic_map_offset(bmap, type) - 1 + first, n);
2500 if (!bmap)
2501 return bmap;
2502 if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY) && type == isl_dim_div)
2503 return bmap;
2504 bmap = isl_basic_map_drop(bmap, type, first, n);
2505 return bmap;
2508 /* Return true if the definition of the given div (recursively) involves
2509 * any of the given variables.
2511 static isl_bool div_involves_vars(__isl_keep isl_basic_map *bmap, int div,
2512 unsigned first, unsigned n)
2514 int i;
2515 unsigned div_offset = isl_basic_map_offset(bmap, isl_dim_div);
2517 if (isl_int_is_zero(bmap->div[div][0]))
2518 return isl_bool_false;
2519 if (isl_seq_first_non_zero(bmap->div[div] + 1 + first, n) >= 0)
2520 return isl_bool_true;
2522 for (i = bmap->n_div - 1; i >= 0; --i) {
2523 isl_bool involves;
2525 if (isl_int_is_zero(bmap->div[div][1 + div_offset + i]))
2526 continue;
2527 involves = div_involves_vars(bmap, i, first, n);
2528 if (involves < 0 || involves)
2529 return involves;
2532 return isl_bool_false;
2535 /* Try and add a lower and/or upper bound on "div" to "bmap"
2536 * based on inequality "i".
2537 * "total" is the total number of variables (excluding the divs).
2538 * "v" is a temporary object that can be used during the calculations.
2539 * If "lb" is set, then a lower bound should be constructed.
2540 * If "ub" is set, then an upper bound should be constructed.
2542 * The calling function has already checked that the inequality does not
2543 * reference "div", but we still need to check that the inequality is
2544 * of the right form. We'll consider the case where we want to construct
2545 * a lower bound. The construction of upper bounds is similar.
2547 * Let "div" be of the form
2549 * q = floor((a + f(x))/d)
2551 * We essentially check if constraint "i" is of the form
2553 * b + f(x) >= 0
2555 * so that we can use it to derive a lower bound on "div".
2556 * However, we allow a slightly more general form
2558 * b + g(x) >= 0
2560 * with the condition that the coefficients of g(x) - f(x) are all
2561 * divisible by d.
2562 * Rewriting this constraint as
2564 * 0 >= -b - g(x)
2566 * adding a + f(x) to both sides and dividing by d, we obtain
2568 * (a + f(x))/d >= (a-b)/d + (f(x)-g(x))/d
2570 * Taking the floor on both sides, we obtain
2572 * q >= floor((a-b)/d) + (f(x)-g(x))/d
2574 * or
2576 * (g(x)-f(x))/d + ceil((b-a)/d) + q >= 0
2578 * In the case of an upper bound, we construct the constraint
2580 * (g(x)+f(x))/d + floor((b+a)/d) - q >= 0
2583 static __isl_give isl_basic_map *insert_bounds_on_div_from_ineq(
2584 __isl_take isl_basic_map *bmap, int div, int i,
2585 unsigned total, isl_int v, int lb, int ub)
2587 int j;
2589 for (j = 0; (lb || ub) && j < total + bmap->n_div; ++j) {
2590 if (lb) {
2591 isl_int_sub(v, bmap->ineq[i][1 + j],
2592 bmap->div[div][1 + 1 + j]);
2593 lb = isl_int_is_divisible_by(v, bmap->div[div][0]);
2595 if (ub) {
2596 isl_int_add(v, bmap->ineq[i][1 + j],
2597 bmap->div[div][1 + 1 + j]);
2598 ub = isl_int_is_divisible_by(v, bmap->div[div][0]);
2601 if (!lb && !ub)
2602 return bmap;
2604 bmap = isl_basic_map_cow(bmap);
2605 bmap = isl_basic_map_extend_constraints(bmap, 0, lb + ub);
2606 if (lb) {
2607 int k = isl_basic_map_alloc_inequality(bmap);
2608 if (k < 0)
2609 goto error;
2610 for (j = 0; j < 1 + total + bmap->n_div; ++j) {
2611 isl_int_sub(bmap->ineq[k][j], bmap->ineq[i][j],
2612 bmap->div[div][1 + j]);
2613 isl_int_cdiv_q(bmap->ineq[k][j],
2614 bmap->ineq[k][j], bmap->div[div][0]);
2616 isl_int_set_si(bmap->ineq[k][1 + total + div], 1);
2618 if (ub) {
2619 int k = isl_basic_map_alloc_inequality(bmap);
2620 if (k < 0)
2621 goto error;
2622 for (j = 0; j < 1 + total + bmap->n_div; ++j) {
2623 isl_int_add(bmap->ineq[k][j], bmap->ineq[i][j],
2624 bmap->div[div][1 + j]);
2625 isl_int_fdiv_q(bmap->ineq[k][j],
2626 bmap->ineq[k][j], bmap->div[div][0]);
2628 isl_int_set_si(bmap->ineq[k][1 + total + div], -1);
2631 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
2632 return bmap;
2633 error:
2634 isl_basic_map_free(bmap);
2635 return NULL;
2638 /* This function is called right before "div" is eliminated from "bmap"
2639 * using Fourier-Motzkin.
2640 * Look through the constraints of "bmap" for constraints on the argument
2641 * of the integer division and use them to construct constraints on the
2642 * integer division itself. These constraints can then be combined
2643 * during the Fourier-Motzkin elimination.
2644 * Note that it is only useful to introduce lower bounds on "div"
2645 * if "bmap" already contains upper bounds on "div" as the newly
2646 * introduce lower bounds can then be combined with the pre-existing
2647 * upper bounds. Similarly for upper bounds.
2648 * We therefore first check if "bmap" contains any lower and/or upper bounds
2649 * on "div".
2651 * It is interesting to note that the introduction of these constraints
2652 * can indeed lead to more accurate results, even when compared to
2653 * deriving constraints on the argument of "div" from constraints on "div".
2654 * Consider, for example, the set
2656 * { [i,j,k] : 3 + i + 2j >= 0 and 2 * [(i+2j)/4] <= k }
2658 * The second constraint can be rewritten as
2660 * 2 * [(-i-2j+3)/4] + k >= 0
2662 * from which we can derive
2664 * -i - 2j + 3 >= -2k
2666 * or
2668 * i + 2j <= 3 + 2k
2670 * Combined with the first constraint, we obtain
2672 * -3 <= 3 + 2k or k >= -3
2674 * If, on the other hand we derive a constraint on [(i+2j)/4] from
2675 * the first constraint, we obtain
2677 * [(i + 2j)/4] >= [-3/4] = -1
2679 * Combining this constraint with the second constraint, we obtain
2681 * k >= -2
2683 static __isl_give isl_basic_map *insert_bounds_on_div(
2684 __isl_take isl_basic_map *bmap, int div)
2686 int i;
2687 int check_lb, check_ub;
2688 isl_int v;
2689 unsigned total;
2691 if (!bmap)
2692 return NULL;
2694 if (isl_int_is_zero(bmap->div[div][0]))
2695 return bmap;
2697 total = isl_space_dim(bmap->dim, isl_dim_all);
2699 check_lb = 0;
2700 check_ub = 0;
2701 for (i = 0; (!check_lb || !check_ub) && i < bmap->n_ineq; ++i) {
2702 int s = isl_int_sgn(bmap->ineq[i][1 + total + div]);
2703 if (s > 0)
2704 check_ub = 1;
2705 if (s < 0)
2706 check_lb = 1;
2709 if (!check_lb && !check_ub)
2710 return bmap;
2712 isl_int_init(v);
2714 for (i = 0; bmap && i < bmap->n_ineq; ++i) {
2715 if (!isl_int_is_zero(bmap->ineq[i][1 + total + div]))
2716 continue;
2718 bmap = insert_bounds_on_div_from_ineq(bmap, div, i, total, v,
2719 check_lb, check_ub);
2722 isl_int_clear(v);
2724 return bmap;
2727 /* Remove all divs (recursively) involving any of the given dimensions
2728 * in their definitions.
2730 __isl_give isl_basic_map *isl_basic_map_remove_divs_involving_dims(
2731 __isl_take isl_basic_map *bmap,
2732 enum isl_dim_type type, unsigned first, unsigned n)
2734 int i;
2736 if (isl_basic_map_check_range(bmap, type, first, n) < 0)
2737 return isl_basic_map_free(bmap);
2738 first += isl_basic_map_offset(bmap, type);
2740 for (i = bmap->n_div - 1; i >= 0; --i) {
2741 isl_bool involves;
2743 involves = div_involves_vars(bmap, i, first, n);
2744 if (involves < 0)
2745 return isl_basic_map_free(bmap);
2746 if (!involves)
2747 continue;
2748 bmap = insert_bounds_on_div(bmap, i);
2749 bmap = isl_basic_map_remove_dims(bmap, isl_dim_div, i, 1);
2750 if (!bmap)
2751 return NULL;
2752 i = bmap->n_div;
2755 return bmap;
2758 __isl_give isl_basic_set *isl_basic_set_remove_divs_involving_dims(
2759 __isl_take isl_basic_set *bset,
2760 enum isl_dim_type type, unsigned first, unsigned n)
2762 return isl_basic_map_remove_divs_involving_dims(bset, type, first, n);
2765 __isl_give isl_map *isl_map_remove_divs_involving_dims(__isl_take isl_map *map,
2766 enum isl_dim_type type, unsigned first, unsigned n)
2768 int i;
2770 if (!map)
2771 return NULL;
2772 if (map->n == 0)
2773 return map;
2775 map = isl_map_cow(map);
2776 if (!map)
2777 return NULL;
2779 for (i = 0; i < map->n; ++i) {
2780 map->p[i] = isl_basic_map_remove_divs_involving_dims(map->p[i],
2781 type, first, n);
2782 if (!map->p[i])
2783 goto error;
2785 return map;
2786 error:
2787 isl_map_free(map);
2788 return NULL;
2791 __isl_give isl_set *isl_set_remove_divs_involving_dims(__isl_take isl_set *set,
2792 enum isl_dim_type type, unsigned first, unsigned n)
2794 return set_from_map(isl_map_remove_divs_involving_dims(set_to_map(set),
2795 type, first, n));
2798 /* Does the description of "bmap" depend on the specified dimensions?
2799 * We also check whether the dimensions appear in any of the div definitions.
2800 * In principle there is no need for this check. If the dimensions appear
2801 * in a div definition, they also appear in the defining constraints of that
2802 * div.
2804 isl_bool isl_basic_map_involves_dims(__isl_keep isl_basic_map *bmap,
2805 enum isl_dim_type type, unsigned first, unsigned n)
2807 int i;
2809 if (isl_basic_map_check_range(bmap, type, first, n) < 0)
2810 return isl_bool_error;
2812 first += isl_basic_map_offset(bmap, type);
2813 for (i = 0; i < bmap->n_eq; ++i)
2814 if (isl_seq_first_non_zero(bmap->eq[i] + first, n) >= 0)
2815 return isl_bool_true;
2816 for (i = 0; i < bmap->n_ineq; ++i)
2817 if (isl_seq_first_non_zero(bmap->ineq[i] + first, n) >= 0)
2818 return isl_bool_true;
2819 for (i = 0; i < bmap->n_div; ++i) {
2820 if (isl_int_is_zero(bmap->div[i][0]))
2821 continue;
2822 if (isl_seq_first_non_zero(bmap->div[i] + 1 + first, n) >= 0)
2823 return isl_bool_true;
2826 return isl_bool_false;
2829 isl_bool isl_map_involves_dims(__isl_keep isl_map *map,
2830 enum isl_dim_type type, unsigned first, unsigned n)
2832 int i;
2834 if (isl_map_check_range(map, type, first, n) < 0)
2835 return isl_bool_error;
2837 for (i = 0; i < map->n; ++i) {
2838 isl_bool involves = isl_basic_map_involves_dims(map->p[i],
2839 type, first, n);
2840 if (involves < 0 || involves)
2841 return involves;
2844 return isl_bool_false;
2847 isl_bool isl_basic_set_involves_dims(__isl_keep isl_basic_set *bset,
2848 enum isl_dim_type type, unsigned first, unsigned n)
2850 return isl_basic_map_involves_dims(bset, type, first, n);
2853 isl_bool isl_set_involves_dims(__isl_keep isl_set *set,
2854 enum isl_dim_type type, unsigned first, unsigned n)
2856 return isl_map_involves_dims(set, type, first, n);
2859 /* Drop all constraints in bmap that involve any of the dimensions
2860 * first to first+n-1.
2862 static __isl_give isl_basic_map *isl_basic_map_drop_constraints_involving(
2863 __isl_take isl_basic_map *bmap, unsigned first, unsigned n)
2865 int i;
2867 if (n == 0)
2868 return bmap;
2870 bmap = isl_basic_map_cow(bmap);
2872 if (!bmap)
2873 return NULL;
2875 for (i = bmap->n_eq - 1; i >= 0; --i) {
2876 if (isl_seq_first_non_zero(bmap->eq[i] + 1 + first, n) == -1)
2877 continue;
2878 isl_basic_map_drop_equality(bmap, i);
2881 for (i = bmap->n_ineq - 1; i >= 0; --i) {
2882 if (isl_seq_first_non_zero(bmap->ineq[i] + 1 + first, n) == -1)
2883 continue;
2884 isl_basic_map_drop_inequality(bmap, i);
2887 bmap = isl_basic_map_add_known_div_constraints(bmap);
2888 return bmap;
2891 /* Drop all constraints in bset that involve any of the dimensions
2892 * first to first+n-1.
2894 __isl_give isl_basic_set *isl_basic_set_drop_constraints_involving(
2895 __isl_take isl_basic_set *bset, unsigned first, unsigned n)
2897 return isl_basic_map_drop_constraints_involving(bset, first, n);
2900 /* Drop all constraints in bmap that do not involve any of the dimensions
2901 * first to first + n - 1 of the given type.
2903 __isl_give isl_basic_map *isl_basic_map_drop_constraints_not_involving_dims(
2904 __isl_take isl_basic_map *bmap,
2905 enum isl_dim_type type, unsigned first, unsigned n)
2907 int i;
2909 if (n == 0) {
2910 isl_space *space = isl_basic_map_get_space(bmap);
2911 isl_basic_map_free(bmap);
2912 return isl_basic_map_universe(space);
2914 bmap = isl_basic_map_cow(bmap);
2915 if (!bmap)
2916 return NULL;
2918 if (isl_basic_map_check_range(bmap, type, first, n) < 0)
2919 return isl_basic_map_free(bmap);
2921 first += isl_basic_map_offset(bmap, type) - 1;
2923 for (i = bmap->n_eq - 1; i >= 0; --i) {
2924 if (isl_seq_first_non_zero(bmap->eq[i] + 1 + first, n) != -1)
2925 continue;
2926 isl_basic_map_drop_equality(bmap, i);
2929 for (i = bmap->n_ineq - 1; i >= 0; --i) {
2930 if (isl_seq_first_non_zero(bmap->ineq[i] + 1 + first, n) != -1)
2931 continue;
2932 isl_basic_map_drop_inequality(bmap, i);
2935 bmap = isl_basic_map_add_known_div_constraints(bmap);
2936 return bmap;
2939 /* Drop all constraints in bset that do not involve any of the dimensions
2940 * first to first + n - 1 of the given type.
2942 __isl_give isl_basic_set *isl_basic_set_drop_constraints_not_involving_dims(
2943 __isl_take isl_basic_set *bset,
2944 enum isl_dim_type type, unsigned first, unsigned n)
2946 return isl_basic_map_drop_constraints_not_involving_dims(bset,
2947 type, first, n);
2950 /* Drop all constraints in bmap that involve any of the dimensions
2951 * first to first + n - 1 of the given type.
2953 __isl_give isl_basic_map *isl_basic_map_drop_constraints_involving_dims(
2954 __isl_take isl_basic_map *bmap,
2955 enum isl_dim_type type, unsigned first, unsigned n)
2957 if (!bmap)
2958 return NULL;
2959 if (n == 0)
2960 return bmap;
2962 if (isl_basic_map_check_range(bmap, type, first, n) < 0)
2963 return isl_basic_map_free(bmap);
2965 bmap = isl_basic_map_remove_divs_involving_dims(bmap, type, first, n);
2966 first += isl_basic_map_offset(bmap, type) - 1;
2967 return isl_basic_map_drop_constraints_involving(bmap, first, n);
2970 /* Drop all constraints in bset that involve any of the dimensions
2971 * first to first + n - 1 of the given type.
2973 __isl_give isl_basic_set *isl_basic_set_drop_constraints_involving_dims(
2974 __isl_take isl_basic_set *bset,
2975 enum isl_dim_type type, unsigned first, unsigned n)
2977 return isl_basic_map_drop_constraints_involving_dims(bset,
2978 type, first, n);
2981 /* Drop constraints from "map" by applying "drop" to each basic map.
2983 static __isl_give isl_map *drop_constraints(__isl_take isl_map *map,
2984 enum isl_dim_type type, unsigned first, unsigned n,
2985 __isl_give isl_basic_map *(*drop)(__isl_take isl_basic_map *bmap,
2986 enum isl_dim_type type, unsigned first, unsigned n))
2988 int i;
2990 if (isl_map_check_range(map, type, first, n) < 0)
2991 return isl_map_free(map);
2993 map = isl_map_cow(map);
2994 if (!map)
2995 return NULL;
2997 for (i = 0; i < map->n; ++i) {
2998 map->p[i] = drop(map->p[i], type, first, n);
2999 if (!map->p[i])
3000 return isl_map_free(map);
3003 if (map->n > 1)
3004 ISL_F_CLR(map, ISL_MAP_DISJOINT);
3006 return map;
3009 /* Drop all constraints in map that involve any of the dimensions
3010 * first to first + n - 1 of the given type.
3012 __isl_give isl_map *isl_map_drop_constraints_involving_dims(
3013 __isl_take isl_map *map,
3014 enum isl_dim_type type, unsigned first, unsigned n)
3016 if (n == 0)
3017 return map;
3018 return drop_constraints(map, type, first, n,
3019 &isl_basic_map_drop_constraints_involving_dims);
3022 /* Drop all constraints in "map" that do not involve any of the dimensions
3023 * first to first + n - 1 of the given type.
3025 __isl_give isl_map *isl_map_drop_constraints_not_involving_dims(
3026 __isl_take isl_map *map,
3027 enum isl_dim_type type, unsigned first, unsigned n)
3029 if (n == 0) {
3030 isl_space *space = isl_map_get_space(map);
3031 isl_map_free(map);
3032 return isl_map_universe(space);
3034 return drop_constraints(map, type, first, n,
3035 &isl_basic_map_drop_constraints_not_involving_dims);
3038 /* Drop all constraints in set that involve any of the dimensions
3039 * first to first + n - 1 of the given type.
3041 __isl_give isl_set *isl_set_drop_constraints_involving_dims(
3042 __isl_take isl_set *set,
3043 enum isl_dim_type type, unsigned first, unsigned n)
3045 return isl_map_drop_constraints_involving_dims(set, type, first, n);
3048 /* Drop all constraints in "set" that do not involve any of the dimensions
3049 * first to first + n - 1 of the given type.
3051 __isl_give isl_set *isl_set_drop_constraints_not_involving_dims(
3052 __isl_take isl_set *set,
3053 enum isl_dim_type type, unsigned first, unsigned n)
3055 return isl_map_drop_constraints_not_involving_dims(set, type, first, n);
3058 /* Does local variable "div" of "bmap" have a complete explicit representation?
3059 * Having a complete explicit representation requires not only
3060 * an explicit representation, but also that all local variables
3061 * that appear in this explicit representation in turn have
3062 * a complete explicit representation.
3064 isl_bool isl_basic_map_div_is_known(__isl_keep isl_basic_map *bmap, int div)
3066 int i;
3067 unsigned div_offset = isl_basic_map_offset(bmap, isl_dim_div);
3068 isl_bool marked;
3070 marked = isl_basic_map_div_is_marked_unknown(bmap, div);
3071 if (marked < 0 || marked)
3072 return isl_bool_not(marked);
3074 for (i = bmap->n_div - 1; i >= 0; --i) {
3075 isl_bool known;
3077 if (isl_int_is_zero(bmap->div[div][1 + div_offset + i]))
3078 continue;
3079 known = isl_basic_map_div_is_known(bmap, i);
3080 if (known < 0 || !known)
3081 return known;
3084 return isl_bool_true;
3087 /* Remove all divs that are unknown or defined in terms of unknown divs.
3089 __isl_give isl_basic_map *isl_basic_map_remove_unknown_divs(
3090 __isl_take isl_basic_map *bmap)
3092 int i;
3094 if (!bmap)
3095 return NULL;
3097 for (i = bmap->n_div - 1; i >= 0; --i) {
3098 if (isl_basic_map_div_is_known(bmap, i))
3099 continue;
3100 bmap = isl_basic_map_remove_dims(bmap, isl_dim_div, i, 1);
3101 if (!bmap)
3102 return NULL;
3103 i = bmap->n_div;
3106 return bmap;
3109 /* Remove all divs that are unknown or defined in terms of unknown divs.
3111 __isl_give isl_basic_set *isl_basic_set_remove_unknown_divs(
3112 __isl_take isl_basic_set *bset)
3114 return isl_basic_map_remove_unknown_divs(bset);
3117 __isl_give isl_map *isl_map_remove_unknown_divs(__isl_take isl_map *map)
3119 int i;
3121 if (!map)
3122 return NULL;
3123 if (map->n == 0)
3124 return map;
3126 map = isl_map_cow(map);
3127 if (!map)
3128 return NULL;
3130 for (i = 0; i < map->n; ++i) {
3131 map->p[i] = isl_basic_map_remove_unknown_divs(map->p[i]);
3132 if (!map->p[i])
3133 goto error;
3135 return map;
3136 error:
3137 isl_map_free(map);
3138 return NULL;
3141 __isl_give isl_set *isl_set_remove_unknown_divs(__isl_take isl_set *set)
3143 return set_from_map(isl_map_remove_unknown_divs(set_to_map(set)));
3146 __isl_give isl_basic_set *isl_basic_set_remove_dims(
3147 __isl_take isl_basic_set *bset,
3148 enum isl_dim_type type, unsigned first, unsigned n)
3150 isl_basic_map *bmap = bset_to_bmap(bset);
3151 bmap = isl_basic_map_remove_dims(bmap, type, first, n);
3152 return bset_from_bmap(bmap);
3155 __isl_give isl_map *isl_map_remove_dims(__isl_take isl_map *map,
3156 enum isl_dim_type type, unsigned first, unsigned n)
3158 int i;
3160 if (n == 0)
3161 return map;
3163 map = isl_map_cow(map);
3164 if (isl_map_check_range(map, type, first, n) < 0)
3165 return isl_map_free(map);
3167 for (i = 0; i < map->n; ++i) {
3168 map->p[i] = isl_basic_map_eliminate_vars(map->p[i],
3169 isl_basic_map_offset(map->p[i], type) - 1 + first, n);
3170 if (!map->p[i])
3171 goto error;
3173 map = isl_map_drop(map, type, first, n);
3174 return map;
3175 error:
3176 isl_map_free(map);
3177 return NULL;
3180 __isl_give isl_set *isl_set_remove_dims(__isl_take isl_set *bset,
3181 enum isl_dim_type type, unsigned first, unsigned n)
3183 return set_from_map(isl_map_remove_dims(set_to_map(bset),
3184 type, first, n));
3187 /* Project out n inputs starting at first using Fourier-Motzkin */
3188 struct isl_map *isl_map_remove_inputs(struct isl_map *map,
3189 unsigned first, unsigned n)
3191 return isl_map_remove_dims(map, isl_dim_in, first, n);
3194 static void dump_term(struct isl_basic_map *bmap,
3195 isl_int c, int pos, FILE *out)
3197 const char *name;
3198 unsigned in = isl_basic_map_dim(bmap, isl_dim_in);
3199 unsigned dim = in + isl_basic_map_dim(bmap, isl_dim_out);
3200 unsigned nparam = isl_basic_map_dim(bmap, isl_dim_param);
3201 if (!pos)
3202 isl_int_print(out, c, 0);
3203 else {
3204 if (!isl_int_is_one(c))
3205 isl_int_print(out, c, 0);
3206 if (pos < 1 + nparam) {
3207 name = isl_space_get_dim_name(bmap->dim,
3208 isl_dim_param, pos - 1);
3209 if (name)
3210 fprintf(out, "%s", name);
3211 else
3212 fprintf(out, "p%d", pos - 1);
3213 } else if (pos < 1 + nparam + in)
3214 fprintf(out, "i%d", pos - 1 - nparam);
3215 else if (pos < 1 + nparam + dim)
3216 fprintf(out, "o%d", pos - 1 - nparam - in);
3217 else
3218 fprintf(out, "e%d", pos - 1 - nparam - dim);
3222 static void dump_constraint_sign(struct isl_basic_map *bmap, isl_int *c,
3223 int sign, FILE *out)
3225 int i;
3226 int first;
3227 unsigned len = 1 + isl_basic_map_total_dim(bmap);
3228 isl_int v;
3230 isl_int_init(v);
3231 for (i = 0, first = 1; i < len; ++i) {
3232 if (isl_int_sgn(c[i]) * sign <= 0)
3233 continue;
3234 if (!first)
3235 fprintf(out, " + ");
3236 first = 0;
3237 isl_int_abs(v, c[i]);
3238 dump_term(bmap, v, i, out);
3240 isl_int_clear(v);
3241 if (first)
3242 fprintf(out, "0");
3245 static void dump_constraint(struct isl_basic_map *bmap, isl_int *c,
3246 const char *op, FILE *out, int indent)
3248 int i;
3250 fprintf(out, "%*s", indent, "");
3252 dump_constraint_sign(bmap, c, 1, out);
3253 fprintf(out, " %s ", op);
3254 dump_constraint_sign(bmap, c, -1, out);
3256 fprintf(out, "\n");
3258 for (i = bmap->n_div; i < bmap->extra; ++i) {
3259 if (isl_int_is_zero(c[1+isl_space_dim(bmap->dim, isl_dim_all)+i]))
3260 continue;
3261 fprintf(out, "%*s", indent, "");
3262 fprintf(out, "ERROR: unused div coefficient not zero\n");
3263 abort();
3267 static void dump_constraints(struct isl_basic_map *bmap,
3268 isl_int **c, unsigned n,
3269 const char *op, FILE *out, int indent)
3271 int i;
3273 for (i = 0; i < n; ++i)
3274 dump_constraint(bmap, c[i], op, out, indent);
3277 static void dump_affine(struct isl_basic_map *bmap, isl_int *exp, FILE *out)
3279 int j;
3280 int first = 1;
3281 unsigned total = isl_basic_map_total_dim(bmap);
3283 for (j = 0; j < 1 + total; ++j) {
3284 if (isl_int_is_zero(exp[j]))
3285 continue;
3286 if (!first && isl_int_is_pos(exp[j]))
3287 fprintf(out, "+");
3288 dump_term(bmap, exp[j], j, out);
3289 first = 0;
3293 static void dump(struct isl_basic_map *bmap, FILE *out, int indent)
3295 int i;
3297 dump_constraints(bmap, bmap->eq, bmap->n_eq, "=", out, indent);
3298 dump_constraints(bmap, bmap->ineq, bmap->n_ineq, ">=", out, indent);
3300 for (i = 0; i < bmap->n_div; ++i) {
3301 fprintf(out, "%*s", indent, "");
3302 fprintf(out, "e%d = [(", i);
3303 dump_affine(bmap, bmap->div[i]+1, out);
3304 fprintf(out, ")/");
3305 isl_int_print(out, bmap->div[i][0], 0);
3306 fprintf(out, "]\n");
3310 void isl_basic_set_print_internal(struct isl_basic_set *bset,
3311 FILE *out, int indent)
3313 if (!bset) {
3314 fprintf(out, "null basic set\n");
3315 return;
3318 fprintf(out, "%*s", indent, "");
3319 fprintf(out, "ref: %d, nparam: %d, dim: %d, extra: %d, flags: %x\n",
3320 bset->ref, bset->dim->nparam, bset->dim->n_out,
3321 bset->extra, bset->flags);
3322 dump(bset_to_bmap(bset), out, indent);
3325 void isl_basic_map_print_internal(struct isl_basic_map *bmap,
3326 FILE *out, int indent)
3328 if (!bmap) {
3329 fprintf(out, "null basic map\n");
3330 return;
3333 fprintf(out, "%*s", indent, "");
3334 fprintf(out, "ref: %d, nparam: %d, in: %d, out: %d, extra: %d, "
3335 "flags: %x, n_name: %d\n",
3336 bmap->ref,
3337 bmap->dim->nparam, bmap->dim->n_in, bmap->dim->n_out,
3338 bmap->extra, bmap->flags, bmap->dim->n_id);
3339 dump(bmap, out, indent);
3342 int isl_inequality_negate(struct isl_basic_map *bmap, unsigned pos)
3344 unsigned total;
3345 if (!bmap)
3346 return -1;
3347 total = isl_basic_map_total_dim(bmap);
3348 isl_assert(bmap->ctx, pos < bmap->n_ineq, return -1);
3349 isl_seq_neg(bmap->ineq[pos], bmap->ineq[pos], 1 + total);
3350 isl_int_sub_ui(bmap->ineq[pos][0], bmap->ineq[pos][0], 1);
3351 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
3352 return 0;
3355 __isl_give isl_set *isl_set_alloc_space(__isl_take isl_space *space, int n,
3356 unsigned flags)
3358 if (!space)
3359 return NULL;
3360 if (isl_space_dim(space, isl_dim_in) != 0)
3361 isl_die(isl_space_get_ctx(space), isl_error_invalid,
3362 "set cannot have input dimensions", goto error);
3363 return isl_map_alloc_space(space, n, flags);
3364 error:
3365 isl_space_free(space);
3366 return NULL;
3369 /* Make sure "map" has room for at least "n" more basic maps.
3371 __isl_give isl_map *isl_map_grow(__isl_take isl_map *map, int n)
3373 int i;
3374 struct isl_map *grown = NULL;
3376 if (!map)
3377 return NULL;
3378 isl_assert(map->ctx, n >= 0, goto error);
3379 if (map->n + n <= map->size)
3380 return map;
3381 grown = isl_map_alloc_space(isl_map_get_space(map), map->n + n, map->flags);
3382 if (!grown)
3383 goto error;
3384 for (i = 0; i < map->n; ++i) {
3385 grown->p[i] = isl_basic_map_copy(map->p[i]);
3386 if (!grown->p[i])
3387 goto error;
3388 grown->n++;
3390 isl_map_free(map);
3391 return grown;
3392 error:
3393 isl_map_free(grown);
3394 isl_map_free(map);
3395 return NULL;
3398 /* Make sure "set" has room for at least "n" more basic sets.
3400 struct isl_set *isl_set_grow(struct isl_set *set, int n)
3402 return set_from_map(isl_map_grow(set_to_map(set), n));
3405 __isl_give isl_set *isl_set_from_basic_set(__isl_take isl_basic_set *bset)
3407 return isl_map_from_basic_map(bset);
3410 __isl_give isl_map *isl_map_from_basic_map(__isl_take isl_basic_map *bmap)
3412 struct isl_map *map;
3414 if (!bmap)
3415 return NULL;
3417 map = isl_map_alloc_space(isl_space_copy(bmap->dim), 1, ISL_MAP_DISJOINT);
3418 return isl_map_add_basic_map(map, bmap);
3421 __isl_give isl_set *isl_set_add_basic_set(__isl_take isl_set *set,
3422 __isl_take isl_basic_set *bset)
3424 return set_from_map(isl_map_add_basic_map(set_to_map(set),
3425 bset_to_bmap(bset)));
3428 __isl_null isl_set *isl_set_free(__isl_take isl_set *set)
3430 return isl_map_free(set);
3433 void isl_set_print_internal(struct isl_set *set, FILE *out, int indent)
3435 int i;
3437 if (!set) {
3438 fprintf(out, "null set\n");
3439 return;
3442 fprintf(out, "%*s", indent, "");
3443 fprintf(out, "ref: %d, n: %d, nparam: %d, dim: %d, flags: %x\n",
3444 set->ref, set->n, set->dim->nparam, set->dim->n_out,
3445 set->flags);
3446 for (i = 0; i < set->n; ++i) {
3447 fprintf(out, "%*s", indent, "");
3448 fprintf(out, "basic set %d:\n", i);
3449 isl_basic_set_print_internal(set->p[i], out, indent+4);
3453 void isl_map_print_internal(struct isl_map *map, FILE *out, int indent)
3455 int i;
3457 if (!map) {
3458 fprintf(out, "null map\n");
3459 return;
3462 fprintf(out, "%*s", indent, "");
3463 fprintf(out, "ref: %d, n: %d, nparam: %d, in: %d, out: %d, "
3464 "flags: %x, n_name: %d\n",
3465 map->ref, map->n, map->dim->nparam, map->dim->n_in,
3466 map->dim->n_out, map->flags, map->dim->n_id);
3467 for (i = 0; i < map->n; ++i) {
3468 fprintf(out, "%*s", indent, "");
3469 fprintf(out, "basic map %d:\n", i);
3470 isl_basic_map_print_internal(map->p[i], out, indent+4);
3474 __isl_give isl_basic_map *isl_basic_map_intersect_domain(
3475 __isl_take isl_basic_map *bmap, __isl_take isl_basic_set *bset)
3477 struct isl_basic_map *bmap_domain;
3479 if (isl_basic_map_check_equal_params(bmap, bset_to_bmap(bset)) < 0)
3480 goto error;
3482 if (isl_space_dim(bset->dim, isl_dim_set) != 0)
3483 isl_assert(bset->ctx,
3484 isl_basic_map_compatible_domain(bmap, bset), goto error);
3486 bmap = isl_basic_map_cow(bmap);
3487 if (!bmap)
3488 goto error;
3489 bmap = isl_basic_map_extend_space(bmap, isl_space_copy(bmap->dim),
3490 bset->n_div, bset->n_eq, bset->n_ineq);
3491 bmap_domain = isl_basic_map_from_domain(bset);
3492 bmap = add_constraints(bmap, bmap_domain, 0, 0);
3494 bmap = isl_basic_map_simplify(bmap);
3495 return isl_basic_map_finalize(bmap);
3496 error:
3497 isl_basic_map_free(bmap);
3498 isl_basic_set_free(bset);
3499 return NULL;
3502 /* Check that the space of "bset" is the same as that of the range of "bmap".
3504 static isl_stat isl_basic_map_check_compatible_range(
3505 __isl_keep isl_basic_map *bmap, __isl_keep isl_basic_set *bset)
3507 isl_bool ok;
3509 ok = isl_basic_map_compatible_range(bmap, bset);
3510 if (ok < 0)
3511 return isl_stat_error;
3512 if (!ok)
3513 isl_die(isl_basic_set_get_ctx(bset), isl_error_invalid,
3514 "incompatible spaces", return isl_stat_error);
3516 return isl_stat_ok;
3519 __isl_give isl_basic_map *isl_basic_map_intersect_range(
3520 __isl_take isl_basic_map *bmap, __isl_take isl_basic_set *bset)
3522 struct isl_basic_map *bmap_range;
3524 if (isl_basic_map_check_equal_params(bmap, bset_to_bmap(bset)) < 0)
3525 goto error;
3527 if (isl_space_dim(bset->dim, isl_dim_set) != 0 &&
3528 isl_basic_map_check_compatible_range(bmap, bset) < 0)
3529 goto error;
3531 if (isl_basic_set_plain_is_universe(bset)) {
3532 isl_basic_set_free(bset);
3533 return bmap;
3536 bmap = isl_basic_map_cow(bmap);
3537 if (!bmap)
3538 goto error;
3539 bmap = isl_basic_map_extend_space(bmap, isl_space_copy(bmap->dim),
3540 bset->n_div, bset->n_eq, bset->n_ineq);
3541 bmap_range = bset_to_bmap(bset);
3542 bmap = add_constraints(bmap, bmap_range, 0, 0);
3544 bmap = isl_basic_map_simplify(bmap);
3545 return isl_basic_map_finalize(bmap);
3546 error:
3547 isl_basic_map_free(bmap);
3548 isl_basic_set_free(bset);
3549 return NULL;
3552 isl_bool isl_basic_map_contains(__isl_keep isl_basic_map *bmap,
3553 __isl_keep isl_vec *vec)
3555 int i;
3556 unsigned total;
3557 isl_int s;
3559 if (!bmap || !vec)
3560 return isl_bool_error;
3562 total = 1 + isl_basic_map_total_dim(bmap);
3563 if (total != vec->size)
3564 return isl_bool_false;
3566 isl_int_init(s);
3568 for (i = 0; i < bmap->n_eq; ++i) {
3569 isl_seq_inner_product(vec->el, bmap->eq[i], total, &s);
3570 if (!isl_int_is_zero(s)) {
3571 isl_int_clear(s);
3572 return isl_bool_false;
3576 for (i = 0; i < bmap->n_ineq; ++i) {
3577 isl_seq_inner_product(vec->el, bmap->ineq[i], total, &s);
3578 if (isl_int_is_neg(s)) {
3579 isl_int_clear(s);
3580 return isl_bool_false;
3584 isl_int_clear(s);
3586 return isl_bool_true;
3589 isl_bool isl_basic_set_contains(__isl_keep isl_basic_set *bset,
3590 __isl_keep isl_vec *vec)
3592 return isl_basic_map_contains(bset_to_bmap(bset), vec);
3595 __isl_give isl_basic_map *isl_basic_map_intersect(
3596 __isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2)
3598 struct isl_vec *sample = NULL;
3600 if (isl_basic_map_check_equal_params(bmap1, bmap2) < 0)
3601 goto error;
3602 if (isl_space_dim(bmap1->dim, isl_dim_all) ==
3603 isl_space_dim(bmap1->dim, isl_dim_param) &&
3604 isl_space_dim(bmap2->dim, isl_dim_all) !=
3605 isl_space_dim(bmap2->dim, isl_dim_param))
3606 return isl_basic_map_intersect(bmap2, bmap1);
3608 if (isl_space_dim(bmap2->dim, isl_dim_all) !=
3609 isl_space_dim(bmap2->dim, isl_dim_param))
3610 isl_assert(bmap1->ctx,
3611 isl_space_is_equal(bmap1->dim, bmap2->dim), goto error);
3613 if (isl_basic_map_plain_is_empty(bmap1)) {
3614 isl_basic_map_free(bmap2);
3615 return bmap1;
3617 if (isl_basic_map_plain_is_empty(bmap2)) {
3618 isl_basic_map_free(bmap1);
3619 return bmap2;
3622 if (bmap1->sample &&
3623 isl_basic_map_contains(bmap1, bmap1->sample) > 0 &&
3624 isl_basic_map_contains(bmap2, bmap1->sample) > 0)
3625 sample = isl_vec_copy(bmap1->sample);
3626 else if (bmap2->sample &&
3627 isl_basic_map_contains(bmap1, bmap2->sample) > 0 &&
3628 isl_basic_map_contains(bmap2, bmap2->sample) > 0)
3629 sample = isl_vec_copy(bmap2->sample);
3631 bmap1 = isl_basic_map_cow(bmap1);
3632 if (!bmap1)
3633 goto error;
3634 bmap1 = isl_basic_map_extend_space(bmap1, isl_space_copy(bmap1->dim),
3635 bmap2->n_div, bmap2->n_eq, bmap2->n_ineq);
3636 bmap1 = add_constraints(bmap1, bmap2, 0, 0);
3638 if (!bmap1)
3639 isl_vec_free(sample);
3640 else if (sample) {
3641 isl_vec_free(bmap1->sample);
3642 bmap1->sample = sample;
3645 bmap1 = isl_basic_map_simplify(bmap1);
3646 return isl_basic_map_finalize(bmap1);
3647 error:
3648 if (sample)
3649 isl_vec_free(sample);
3650 isl_basic_map_free(bmap1);
3651 isl_basic_map_free(bmap2);
3652 return NULL;
3655 struct isl_basic_set *isl_basic_set_intersect(
3656 struct isl_basic_set *bset1, struct isl_basic_set *bset2)
3658 return bset_from_bmap(isl_basic_map_intersect(bset_to_bmap(bset1),
3659 bset_to_bmap(bset2)));
3662 __isl_give isl_basic_set *isl_basic_set_intersect_params(
3663 __isl_take isl_basic_set *bset1, __isl_take isl_basic_set *bset2)
3665 return isl_basic_set_intersect(bset1, bset2);
3668 /* Special case of isl_map_intersect, where both map1 and map2
3669 * are convex, without any divs and such that either map1 or map2
3670 * contains a single constraint. This constraint is then simply
3671 * added to the other map.
3673 static __isl_give isl_map *map_intersect_add_constraint(
3674 __isl_take isl_map *map1, __isl_take isl_map *map2)
3676 isl_assert(map1->ctx, map1->n == 1, goto error);
3677 isl_assert(map2->ctx, map1->n == 1, goto error);
3678 isl_assert(map1->ctx, map1->p[0]->n_div == 0, goto error);
3679 isl_assert(map2->ctx, map1->p[0]->n_div == 0, goto error);
3681 if (map2->p[0]->n_eq + map2->p[0]->n_ineq != 1)
3682 return isl_map_intersect(map2, map1);
3684 map1 = isl_map_cow(map1);
3685 if (!map1)
3686 goto error;
3687 if (isl_map_plain_is_empty(map1)) {
3688 isl_map_free(map2);
3689 return map1;
3691 map1->p[0] = isl_basic_map_cow(map1->p[0]);
3692 if (map2->p[0]->n_eq == 1)
3693 map1->p[0] = isl_basic_map_add_eq(map1->p[0], map2->p[0]->eq[0]);
3694 else
3695 map1->p[0] = isl_basic_map_add_ineq(map1->p[0],
3696 map2->p[0]->ineq[0]);
3698 map1->p[0] = isl_basic_map_simplify(map1->p[0]);
3699 map1->p[0] = isl_basic_map_finalize(map1->p[0]);
3700 if (!map1->p[0])
3701 goto error;
3703 if (isl_basic_map_plain_is_empty(map1->p[0])) {
3704 isl_basic_map_free(map1->p[0]);
3705 map1->n = 0;
3708 isl_map_free(map2);
3710 return map1;
3711 error:
3712 isl_map_free(map1);
3713 isl_map_free(map2);
3714 return NULL;
3717 /* map2 may be either a parameter domain or a map living in the same
3718 * space as map1.
3720 static __isl_give isl_map *map_intersect_internal(__isl_take isl_map *map1,
3721 __isl_take isl_map *map2)
3723 unsigned flags = 0;
3724 isl_map *result;
3725 int i, j;
3727 if (!map1 || !map2)
3728 goto error;
3730 if ((isl_map_plain_is_empty(map1) ||
3731 isl_map_plain_is_universe(map2)) &&
3732 isl_space_is_equal(map1->dim, map2->dim)) {
3733 isl_map_free(map2);
3734 return map1;
3736 if ((isl_map_plain_is_empty(map2) ||
3737 isl_map_plain_is_universe(map1)) &&
3738 isl_space_is_equal(map1->dim, map2->dim)) {
3739 isl_map_free(map1);
3740 return map2;
3743 if (map1->n == 1 && map2->n == 1 &&
3744 map1->p[0]->n_div == 0 && map2->p[0]->n_div == 0 &&
3745 isl_space_is_equal(map1->dim, map2->dim) &&
3746 (map1->p[0]->n_eq + map1->p[0]->n_ineq == 1 ||
3747 map2->p[0]->n_eq + map2->p[0]->n_ineq == 1))
3748 return map_intersect_add_constraint(map1, map2);
3750 if (isl_space_dim(map2->dim, isl_dim_all) !=
3751 isl_space_dim(map2->dim, isl_dim_param))
3752 isl_assert(map1->ctx,
3753 isl_space_is_equal(map1->dim, map2->dim), goto error);
3755 if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) &&
3756 ISL_F_ISSET(map2, ISL_MAP_DISJOINT))
3757 ISL_FL_SET(flags, ISL_MAP_DISJOINT);
3759 result = isl_map_alloc_space(isl_space_copy(map1->dim),
3760 map1->n * map2->n, flags);
3761 if (!result)
3762 goto error;
3763 for (i = 0; i < map1->n; ++i)
3764 for (j = 0; j < map2->n; ++j) {
3765 struct isl_basic_map *part;
3766 part = isl_basic_map_intersect(
3767 isl_basic_map_copy(map1->p[i]),
3768 isl_basic_map_copy(map2->p[j]));
3769 if (isl_basic_map_is_empty(part) < 0)
3770 part = isl_basic_map_free(part);
3771 result = isl_map_add_basic_map(result, part);
3772 if (!result)
3773 goto error;
3775 isl_map_free(map1);
3776 isl_map_free(map2);
3777 return result;
3778 error:
3779 isl_map_free(map1);
3780 isl_map_free(map2);
3781 return NULL;
3784 static __isl_give isl_map *map_intersect(__isl_take isl_map *map1,
3785 __isl_take isl_map *map2)
3787 if (!map1 || !map2)
3788 goto error;
3789 if (!isl_space_is_equal(map1->dim, map2->dim))
3790 isl_die(isl_map_get_ctx(map1), isl_error_invalid,
3791 "spaces don't match", goto error);
3792 return map_intersect_internal(map1, map2);
3793 error:
3794 isl_map_free(map1);
3795 isl_map_free(map2);
3796 return NULL;
3799 __isl_give isl_map *isl_map_intersect(__isl_take isl_map *map1,
3800 __isl_take isl_map *map2)
3802 return isl_map_align_params_map_map_and(map1, map2, &map_intersect);
3805 struct isl_set *isl_set_intersect(struct isl_set *set1, struct isl_set *set2)
3807 return set_from_map(isl_map_intersect(set_to_map(set1),
3808 set_to_map(set2)));
3811 /* map_intersect_internal accepts intersections
3812 * with parameter domains, so we can just call that function.
3814 static __isl_give isl_map *map_intersect_params(__isl_take isl_map *map,
3815 __isl_take isl_set *params)
3817 return map_intersect_internal(map, params);
3820 __isl_give isl_map *isl_map_intersect_params(__isl_take isl_map *map1,
3821 __isl_take isl_map *map2)
3823 return isl_map_align_params_map_map_and(map1, map2, &map_intersect_params);
3826 __isl_give isl_set *isl_set_intersect_params(__isl_take isl_set *set,
3827 __isl_take isl_set *params)
3829 return isl_map_intersect_params(set, params);
3832 __isl_give isl_basic_map *isl_basic_map_reverse(__isl_take isl_basic_map *bmap)
3834 isl_space *space;
3835 unsigned pos, n1, n2;
3837 if (!bmap)
3838 return NULL;
3839 bmap = isl_basic_map_cow(bmap);
3840 if (!bmap)
3841 return NULL;
3842 space = isl_space_reverse(isl_space_copy(bmap->dim));
3843 pos = isl_basic_map_offset(bmap, isl_dim_in);
3844 n1 = isl_basic_map_dim(bmap, isl_dim_in);
3845 n2 = isl_basic_map_dim(bmap, isl_dim_out);
3846 bmap = isl_basic_map_swap_vars(bmap, pos, n1, n2);
3847 return isl_basic_map_reset_space(bmap, space);
3850 static __isl_give isl_basic_map *basic_map_space_reset(
3851 __isl_take isl_basic_map *bmap, enum isl_dim_type type)
3853 isl_space *space;
3855 if (!bmap)
3856 return NULL;
3857 if (!isl_space_is_named_or_nested(bmap->dim, type))
3858 return bmap;
3860 space = isl_basic_map_get_space(bmap);
3861 space = isl_space_reset(space, type);
3862 bmap = isl_basic_map_reset_space(bmap, space);
3863 return bmap;
3866 __isl_give isl_basic_map *isl_basic_map_insert_dims(
3867 __isl_take isl_basic_map *bmap, enum isl_dim_type type,
3868 unsigned pos, unsigned n)
3870 isl_bool rational;
3871 isl_space *res_dim;
3872 struct isl_basic_map *res;
3873 struct isl_dim_map *dim_map;
3874 unsigned total, off;
3875 enum isl_dim_type t;
3877 if (n == 0)
3878 return basic_map_space_reset(bmap, type);
3880 if (!bmap)
3881 return NULL;
3883 res_dim = isl_space_insert_dims(isl_basic_map_get_space(bmap), type, pos, n);
3885 total = isl_basic_map_total_dim(bmap) + n;
3886 dim_map = isl_dim_map_alloc(bmap->ctx, total);
3887 off = 0;
3888 for (t = isl_dim_param; t <= isl_dim_out; ++t) {
3889 if (t != type) {
3890 isl_dim_map_dim(dim_map, bmap->dim, t, off);
3891 } else {
3892 unsigned size = isl_basic_map_dim(bmap, t);
3893 isl_dim_map_dim_range(dim_map, bmap->dim, t,
3894 0, pos, off);
3895 isl_dim_map_dim_range(dim_map, bmap->dim, t,
3896 pos, size - pos, off + pos + n);
3898 off += isl_space_dim(res_dim, t);
3900 isl_dim_map_div(dim_map, bmap, off);
3902 res = isl_basic_map_alloc_space(res_dim,
3903 bmap->n_div, bmap->n_eq, bmap->n_ineq);
3904 rational = isl_basic_map_is_rational(bmap);
3905 if (rational < 0)
3906 res = isl_basic_map_free(res);
3907 if (rational)
3908 res = isl_basic_map_set_rational(res);
3909 if (isl_basic_map_plain_is_empty(bmap)) {
3910 isl_basic_map_free(bmap);
3911 free(dim_map);
3912 return isl_basic_map_set_to_empty(res);
3914 res = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map);
3915 return isl_basic_map_finalize(res);
3918 __isl_give isl_basic_set *isl_basic_set_insert_dims(
3919 __isl_take isl_basic_set *bset,
3920 enum isl_dim_type type, unsigned pos, unsigned n)
3922 return isl_basic_map_insert_dims(bset, type, pos, n);
3925 __isl_give isl_basic_map *isl_basic_map_add_dims(__isl_take isl_basic_map *bmap,
3926 enum isl_dim_type type, unsigned n)
3928 if (!bmap)
3929 return NULL;
3930 return isl_basic_map_insert_dims(bmap, type,
3931 isl_basic_map_dim(bmap, type), n);
3934 __isl_give isl_basic_set *isl_basic_set_add_dims(__isl_take isl_basic_set *bset,
3935 enum isl_dim_type type, unsigned n)
3937 if (!bset)
3938 return NULL;
3939 isl_assert(bset->ctx, type != isl_dim_in, goto error);
3940 return isl_basic_map_add_dims(bset, type, n);
3941 error:
3942 isl_basic_set_free(bset);
3943 return NULL;
3946 static __isl_give isl_map *map_space_reset(__isl_take isl_map *map,
3947 enum isl_dim_type type)
3949 isl_space *space;
3951 if (!map || !isl_space_is_named_or_nested(map->dim, type))
3952 return map;
3954 space = isl_map_get_space(map);
3955 space = isl_space_reset(space, type);
3956 map = isl_map_reset_space(map, space);
3957 return map;
3960 __isl_give isl_map *isl_map_insert_dims(__isl_take isl_map *map,
3961 enum isl_dim_type type, unsigned pos, unsigned n)
3963 int i;
3965 if (n == 0)
3966 return map_space_reset(map, type);
3968 map = isl_map_cow(map);
3969 if (!map)
3970 return NULL;
3972 map->dim = isl_space_insert_dims(map->dim, type, pos, n);
3973 if (!map->dim)
3974 goto error;
3976 for (i = 0; i < map->n; ++i) {
3977 map->p[i] = isl_basic_map_insert_dims(map->p[i], type, pos, n);
3978 if (!map->p[i])
3979 goto error;
3982 return map;
3983 error:
3984 isl_map_free(map);
3985 return NULL;
3988 __isl_give isl_set *isl_set_insert_dims(__isl_take isl_set *set,
3989 enum isl_dim_type type, unsigned pos, unsigned n)
3991 return isl_map_insert_dims(set, type, pos, n);
3994 __isl_give isl_map *isl_map_add_dims(__isl_take isl_map *map,
3995 enum isl_dim_type type, unsigned n)
3997 if (!map)
3998 return NULL;
3999 return isl_map_insert_dims(map, type, isl_map_dim(map, type), n);
4002 __isl_give isl_set *isl_set_add_dims(__isl_take isl_set *set,
4003 enum isl_dim_type type, unsigned n)
4005 if (!set)
4006 return NULL;
4007 isl_assert(set->ctx, type != isl_dim_in, goto error);
4008 return set_from_map(isl_map_add_dims(set_to_map(set), type, n));
4009 error:
4010 isl_set_free(set);
4011 return NULL;
4014 __isl_give isl_basic_map *isl_basic_map_move_dims(
4015 __isl_take isl_basic_map *bmap,
4016 enum isl_dim_type dst_type, unsigned dst_pos,
4017 enum isl_dim_type src_type, unsigned src_pos, unsigned n)
4019 struct isl_dim_map *dim_map;
4020 struct isl_basic_map *res;
4021 enum isl_dim_type t;
4022 unsigned total, off;
4024 if (!bmap)
4025 return NULL;
4026 if (n == 0) {
4027 bmap = isl_basic_map_reset(bmap, src_type);
4028 bmap = isl_basic_map_reset(bmap, dst_type);
4029 return bmap;
4032 if (isl_basic_map_check_range(bmap, src_type, src_pos, n) < 0)
4033 return isl_basic_map_free(bmap);
4035 if (dst_type == src_type && dst_pos == src_pos)
4036 return bmap;
4038 isl_assert(bmap->ctx, dst_type != src_type, goto error);
4040 if (pos(bmap->dim, dst_type) + dst_pos ==
4041 pos(bmap->dim, src_type) + src_pos +
4042 ((src_type < dst_type) ? n : 0)) {
4043 bmap = isl_basic_map_cow(bmap);
4044 if (!bmap)
4045 return NULL;
4047 bmap->dim = isl_space_move_dims(bmap->dim, dst_type, dst_pos,
4048 src_type, src_pos, n);
4049 if (!bmap->dim)
4050 goto error;
4052 bmap = isl_basic_map_finalize(bmap);
4054 return bmap;
4057 total = isl_basic_map_total_dim(bmap);
4058 dim_map = isl_dim_map_alloc(bmap->ctx, total);
4060 off = 0;
4061 for (t = isl_dim_param; t <= isl_dim_out; ++t) {
4062 unsigned size = isl_space_dim(bmap->dim, t);
4063 if (t == dst_type) {
4064 isl_dim_map_dim_range(dim_map, bmap->dim, t,
4065 0, dst_pos, off);
4066 off += dst_pos;
4067 isl_dim_map_dim_range(dim_map, bmap->dim, src_type,
4068 src_pos, n, off);
4069 off += n;
4070 isl_dim_map_dim_range(dim_map, bmap->dim, t,
4071 dst_pos, size - dst_pos, off);
4072 off += size - dst_pos;
4073 } else if (t == src_type) {
4074 isl_dim_map_dim_range(dim_map, bmap->dim, t,
4075 0, src_pos, off);
4076 off += src_pos;
4077 isl_dim_map_dim_range(dim_map, bmap->dim, t,
4078 src_pos + n, size - src_pos - n, off);
4079 off += size - src_pos - n;
4080 } else {
4081 isl_dim_map_dim(dim_map, bmap->dim, t, off);
4082 off += size;
4085 isl_dim_map_div(dim_map, bmap, off);
4087 res = isl_basic_map_alloc_space(isl_basic_map_get_space(bmap),
4088 bmap->n_div, bmap->n_eq, bmap->n_ineq);
4089 bmap = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map);
4090 if (!bmap)
4091 goto error;
4093 bmap->dim = isl_space_move_dims(bmap->dim, dst_type, dst_pos,
4094 src_type, src_pos, n);
4095 if (!bmap->dim)
4096 goto error;
4098 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
4099 bmap = isl_basic_map_gauss(bmap, NULL);
4100 bmap = isl_basic_map_finalize(bmap);
4102 return bmap;
4103 error:
4104 isl_basic_map_free(bmap);
4105 return NULL;
4108 __isl_give isl_basic_set *isl_basic_set_move_dims(__isl_take isl_basic_set *bset,
4109 enum isl_dim_type dst_type, unsigned dst_pos,
4110 enum isl_dim_type src_type, unsigned src_pos, unsigned n)
4112 isl_basic_map *bmap = bset_to_bmap(bset);
4113 bmap = isl_basic_map_move_dims(bmap, dst_type, dst_pos,
4114 src_type, src_pos, n);
4115 return bset_from_bmap(bmap);
4118 __isl_give isl_set *isl_set_move_dims(__isl_take isl_set *set,
4119 enum isl_dim_type dst_type, unsigned dst_pos,
4120 enum isl_dim_type src_type, unsigned src_pos, unsigned n)
4122 if (!set)
4123 return NULL;
4124 isl_assert(set->ctx, dst_type != isl_dim_in, goto error);
4125 return set_from_map(isl_map_move_dims(set_to_map(set),
4126 dst_type, dst_pos, src_type, src_pos, n));
4127 error:
4128 isl_set_free(set);
4129 return NULL;
4132 __isl_give isl_map *isl_map_move_dims(__isl_take isl_map *map,
4133 enum isl_dim_type dst_type, unsigned dst_pos,
4134 enum isl_dim_type src_type, unsigned src_pos, unsigned n)
4136 int i;
4138 if (n == 0) {
4139 map = isl_map_reset(map, src_type);
4140 map = isl_map_reset(map, dst_type);
4141 return map;
4144 if (isl_map_check_range(map, src_type, src_pos, n))
4145 return isl_map_free(map);
4147 if (dst_type == src_type && dst_pos == src_pos)
4148 return map;
4150 isl_assert(map->ctx, dst_type != src_type, goto error);
4152 map = isl_map_cow(map);
4153 if (!map)
4154 return NULL;
4156 map->dim = isl_space_move_dims(map->dim, dst_type, dst_pos, src_type, src_pos, n);
4157 if (!map->dim)
4158 goto error;
4160 for (i = 0; i < map->n; ++i) {
4161 map->p[i] = isl_basic_map_move_dims(map->p[i],
4162 dst_type, dst_pos,
4163 src_type, src_pos, n);
4164 if (!map->p[i])
4165 goto error;
4168 return map;
4169 error:
4170 isl_map_free(map);
4171 return NULL;
4174 /* Move the specified dimensions to the last columns right before
4175 * the divs. Don't change the dimension specification of bmap.
4176 * That's the responsibility of the caller.
4178 static __isl_give isl_basic_map *move_last(__isl_take isl_basic_map *bmap,
4179 enum isl_dim_type type, unsigned first, unsigned n)
4181 struct isl_dim_map *dim_map;
4182 struct isl_basic_map *res;
4183 enum isl_dim_type t;
4184 unsigned total, off;
4186 if (!bmap)
4187 return NULL;
4188 if (pos(bmap->dim, type) + first + n ==
4189 1 + isl_space_dim(bmap->dim, isl_dim_all))
4190 return bmap;
4192 total = isl_basic_map_total_dim(bmap);
4193 dim_map = isl_dim_map_alloc(bmap->ctx, total);
4195 off = 0;
4196 for (t = isl_dim_param; t <= isl_dim_out; ++t) {
4197 unsigned size = isl_space_dim(bmap->dim, t);
4198 if (t == type) {
4199 isl_dim_map_dim_range(dim_map, bmap->dim, t,
4200 0, first, off);
4201 off += first;
4202 isl_dim_map_dim_range(dim_map, bmap->dim, t,
4203 first, n, total - bmap->n_div - n);
4204 isl_dim_map_dim_range(dim_map, bmap->dim, t,
4205 first + n, size - (first + n), off);
4206 off += size - (first + n);
4207 } else {
4208 isl_dim_map_dim(dim_map, bmap->dim, t, off);
4209 off += size;
4212 isl_dim_map_div(dim_map, bmap, off + n);
4214 res = isl_basic_map_alloc_space(isl_basic_map_get_space(bmap),
4215 bmap->n_div, bmap->n_eq, bmap->n_ineq);
4216 res = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map);
4217 return res;
4220 /* Insert "n" rows in the divs of "bmap".
4222 * The number of columns is not changed, which means that the last
4223 * dimensions of "bmap" are being reintepreted as the new divs.
4224 * The space of "bmap" is not adjusted, however, which means
4225 * that "bmap" is left in an inconsistent state. Removing "n" dimensions
4226 * from the space of "bmap" is the responsibility of the caller.
4228 static __isl_give isl_basic_map *insert_div_rows(__isl_take isl_basic_map *bmap,
4229 int n)
4231 int i;
4232 size_t row_size;
4233 isl_int **new_div;
4234 isl_int *old;
4236 bmap = isl_basic_map_cow(bmap);
4237 if (!bmap)
4238 return NULL;
4240 row_size = 1 + isl_space_dim(bmap->dim, isl_dim_all) + bmap->extra;
4241 old = bmap->block2.data;
4242 bmap->block2 = isl_blk_extend(bmap->ctx, bmap->block2,
4243 (bmap->extra + n) * (1 + row_size));
4244 if (!bmap->block2.data)
4245 return isl_basic_map_free(bmap);
4246 new_div = isl_alloc_array(bmap->ctx, isl_int *, bmap->extra + n);
4247 if (!new_div)
4248 return isl_basic_map_free(bmap);
4249 for (i = 0; i < n; ++i) {
4250 new_div[i] = bmap->block2.data +
4251 (bmap->extra + i) * (1 + row_size);
4252 isl_seq_clr(new_div[i], 1 + row_size);
4254 for (i = 0; i < bmap->extra; ++i)
4255 new_div[n + i] = bmap->block2.data + (bmap->div[i] - old);
4256 free(bmap->div);
4257 bmap->div = new_div;
4258 bmap->n_div += n;
4259 bmap->extra += n;
4261 return bmap;
4264 /* Drop constraints from "bmap" that only involve the variables
4265 * of "type" in the range [first, first + n] that are not related
4266 * to any of the variables outside that interval.
4267 * These constraints cannot influence the values for the variables
4268 * outside the interval, except in case they cause "bmap" to be empty.
4269 * Only drop the constraints if "bmap" is known to be non-empty.
4271 static __isl_give isl_basic_map *drop_irrelevant_constraints(
4272 __isl_take isl_basic_map *bmap, enum isl_dim_type type,
4273 unsigned first, unsigned n)
4275 int i;
4276 int *groups;
4277 unsigned dim, n_div;
4278 isl_bool non_empty;
4280 non_empty = isl_basic_map_plain_is_non_empty(bmap);
4281 if (non_empty < 0)
4282 return isl_basic_map_free(bmap);
4283 if (!non_empty)
4284 return bmap;
4286 dim = isl_basic_map_dim(bmap, isl_dim_all);
4287 n_div = isl_basic_map_dim(bmap, isl_dim_div);
4288 groups = isl_calloc_array(isl_basic_map_get_ctx(bmap), int, dim);
4289 if (!groups)
4290 return isl_basic_map_free(bmap);
4291 first += isl_basic_map_offset(bmap, type) - 1;
4292 for (i = 0; i < first; ++i)
4293 groups[i] = -1;
4294 for (i = first + n; i < dim - n_div; ++i)
4295 groups[i] = -1;
4297 bmap = isl_basic_map_drop_unrelated_constraints(bmap, groups);
4299 return bmap;
4302 /* Turn the n dimensions of type type, starting at first
4303 * into existentially quantified variables.
4305 * If a subset of the projected out variables are unrelated
4306 * to any of the variables that remain, then the constraints
4307 * involving this subset are simply dropped first.
4309 __isl_give isl_basic_map *isl_basic_map_project_out(
4310 __isl_take isl_basic_map *bmap,
4311 enum isl_dim_type type, unsigned first, unsigned n)
4313 isl_bool empty;
4315 if (n == 0)
4316 return basic_map_space_reset(bmap, type);
4317 if (type == isl_dim_div)
4318 isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
4319 "cannot project out existentially quantified variables",
4320 return isl_basic_map_free(bmap));
4322 empty = isl_basic_map_plain_is_empty(bmap);
4323 if (empty < 0)
4324 return isl_basic_map_free(bmap);
4325 if (empty)
4326 bmap = isl_basic_map_set_to_empty(bmap);
4328 bmap = drop_irrelevant_constraints(bmap, type, first, n);
4329 if (!bmap)
4330 return NULL;
4332 if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
4333 return isl_basic_map_remove_dims(bmap, type, first, n);
4335 if (isl_basic_map_check_range(bmap, type, first, n) < 0)
4336 return isl_basic_map_free(bmap);
4338 bmap = move_last(bmap, type, first, n);
4339 bmap = isl_basic_map_cow(bmap);
4340 bmap = insert_div_rows(bmap, n);
4341 if (!bmap)
4342 return NULL;
4344 bmap->dim = isl_space_drop_dims(bmap->dim, type, first, n);
4345 if (!bmap->dim)
4346 goto error;
4347 bmap = isl_basic_map_simplify(bmap);
4348 bmap = isl_basic_map_drop_redundant_divs(bmap);
4349 return isl_basic_map_finalize(bmap);
4350 error:
4351 isl_basic_map_free(bmap);
4352 return NULL;
4355 /* Turn the n dimensions of type type, starting at first
4356 * into existentially quantified variables.
4358 struct isl_basic_set *isl_basic_set_project_out(struct isl_basic_set *bset,
4359 enum isl_dim_type type, unsigned first, unsigned n)
4361 return bset_from_bmap(isl_basic_map_project_out(bset_to_bmap(bset),
4362 type, first, n));
4365 /* Turn the n dimensions of type type, starting at first
4366 * into existentially quantified variables.
4368 __isl_give isl_map *isl_map_project_out(__isl_take isl_map *map,
4369 enum isl_dim_type type, unsigned first, unsigned n)
4371 int i;
4373 if (n == 0)
4374 return map_space_reset(map, type);
4376 if (isl_map_check_range(map, type, first, n) < 0)
4377 return isl_map_free(map);
4379 map = isl_map_cow(map);
4380 if (!map)
4381 return NULL;
4383 map->dim = isl_space_drop_dims(map->dim, type, first, n);
4384 if (!map->dim)
4385 goto error;
4387 for (i = 0; i < map->n; ++i) {
4388 map->p[i] = isl_basic_map_project_out(map->p[i], type, first, n);
4389 if (!map->p[i])
4390 goto error;
4393 return map;
4394 error:
4395 isl_map_free(map);
4396 return NULL;
4399 /* Turn all the dimensions of type "type", except the "n" starting at "first"
4400 * into existentially quantified variables.
4402 __isl_give isl_map *isl_map_project_onto(__isl_take isl_map *map,
4403 enum isl_dim_type type, unsigned first, unsigned n)
4405 unsigned dim;
4407 if (isl_map_check_range(map, type, first, n) < 0)
4408 return isl_map_free(map);
4409 dim = isl_map_dim(map, type);
4410 map = isl_map_project_out(map, type, first + n, dim - (first + n));
4411 map = isl_map_project_out(map, type, 0, first);
4412 return map;
4415 /* Turn the n dimensions of type type, starting at first
4416 * into existentially quantified variables.
4418 __isl_give isl_set *isl_set_project_out(__isl_take isl_set *set,
4419 enum isl_dim_type type, unsigned first, unsigned n)
4421 return set_from_map(isl_map_project_out(set_to_map(set),
4422 type, first, n));
4425 /* Return a map that projects the elements in "set" onto their
4426 * "n" set dimensions starting at "first".
4427 * "type" should be equal to isl_dim_set.
4429 __isl_give isl_map *isl_set_project_onto_map(__isl_take isl_set *set,
4430 enum isl_dim_type type, unsigned first, unsigned n)
4432 int i;
4433 int dim;
4434 isl_map *map;
4436 if (!set)
4437 return NULL;
4438 if (type != isl_dim_set)
4439 isl_die(isl_set_get_ctx(set), isl_error_invalid,
4440 "only set dimensions can be projected out", goto error);
4441 dim = isl_set_dim(set, isl_dim_set);
4442 if (first + n > dim || first + n < first)
4443 isl_die(isl_set_get_ctx(set), isl_error_invalid,
4444 "index out of bounds", goto error);
4446 map = isl_map_from_domain(set);
4447 map = isl_map_add_dims(map, isl_dim_out, n);
4448 for (i = 0; i < n; ++i)
4449 map = isl_map_equate(map, isl_dim_in, first + i,
4450 isl_dim_out, i);
4451 return map;
4452 error:
4453 isl_set_free(set);
4454 return NULL;
4457 static struct isl_basic_map *add_divs(struct isl_basic_map *bmap, unsigned n)
4459 int i, j;
4461 for (i = 0; i < n; ++i) {
4462 j = isl_basic_map_alloc_div(bmap);
4463 if (j < 0)
4464 goto error;
4465 isl_seq_clr(bmap->div[j], 1+1+isl_basic_map_total_dim(bmap));
4467 return bmap;
4468 error:
4469 isl_basic_map_free(bmap);
4470 return NULL;
4473 struct isl_basic_map *isl_basic_map_apply_range(
4474 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
4476 isl_space *dim_result = NULL;
4477 struct isl_basic_map *bmap;
4478 unsigned n_in, n_out, n, nparam, total, pos;
4479 struct isl_dim_map *dim_map1, *dim_map2;
4481 if (isl_basic_map_check_equal_params(bmap1, bmap2) < 0)
4482 goto error;
4483 if (!isl_space_tuple_is_equal(bmap1->dim, isl_dim_out,
4484 bmap2->dim, isl_dim_in))
4485 isl_die(isl_basic_map_get_ctx(bmap1), isl_error_invalid,
4486 "spaces don't match", goto error);
4488 dim_result = isl_space_join(isl_space_copy(bmap1->dim),
4489 isl_space_copy(bmap2->dim));
4491 n_in = isl_basic_map_dim(bmap1, isl_dim_in);
4492 n_out = isl_basic_map_dim(bmap2, isl_dim_out);
4493 n = isl_basic_map_dim(bmap1, isl_dim_out);
4494 nparam = isl_basic_map_dim(bmap1, isl_dim_param);
4496 total = nparam + n_in + n_out + bmap1->n_div + bmap2->n_div + n;
4497 dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
4498 dim_map2 = isl_dim_map_alloc(bmap1->ctx, total);
4499 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
4500 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos = 0);
4501 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
4502 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos += n_in);
4503 isl_dim_map_div(dim_map1, bmap1, pos += n_out);
4504 isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
4505 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += bmap2->n_div);
4506 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos);
4508 bmap = isl_basic_map_alloc_space(dim_result,
4509 bmap1->n_div + bmap2->n_div + n,
4510 bmap1->n_eq + bmap2->n_eq,
4511 bmap1->n_ineq + bmap2->n_ineq);
4512 bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap1, dim_map1);
4513 bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap2, dim_map2);
4514 bmap = add_divs(bmap, n);
4515 bmap = isl_basic_map_simplify(bmap);
4516 bmap = isl_basic_map_drop_redundant_divs(bmap);
4517 return isl_basic_map_finalize(bmap);
4518 error:
4519 isl_basic_map_free(bmap1);
4520 isl_basic_map_free(bmap2);
4521 return NULL;
4524 struct isl_basic_set *isl_basic_set_apply(
4525 struct isl_basic_set *bset, struct isl_basic_map *bmap)
4527 if (!bset || !bmap)
4528 goto error;
4530 isl_assert(bset->ctx, isl_basic_map_compatible_domain(bmap, bset),
4531 goto error);
4533 return bset_from_bmap(isl_basic_map_apply_range(bset_to_bmap(bset),
4534 bmap));
4535 error:
4536 isl_basic_set_free(bset);
4537 isl_basic_map_free(bmap);
4538 return NULL;
4541 struct isl_basic_map *isl_basic_map_apply_domain(
4542 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
4544 if (isl_basic_map_check_equal_params(bmap1, bmap2) < 0)
4545 goto error;
4546 if (!isl_space_tuple_is_equal(bmap1->dim, isl_dim_in,
4547 bmap2->dim, isl_dim_in))
4548 isl_die(isl_basic_map_get_ctx(bmap1), isl_error_invalid,
4549 "spaces don't match", goto error);
4551 bmap1 = isl_basic_map_reverse(bmap1);
4552 bmap1 = isl_basic_map_apply_range(bmap1, bmap2);
4553 return isl_basic_map_reverse(bmap1);
4554 error:
4555 isl_basic_map_free(bmap1);
4556 isl_basic_map_free(bmap2);
4557 return NULL;
4560 /* Given two basic maps A -> f(A) and B -> g(B), construct a basic map
4561 * A \cap B -> f(A) + f(B)
4563 __isl_give isl_basic_map *isl_basic_map_sum(__isl_take isl_basic_map *bmap1,
4564 __isl_take isl_basic_map *bmap2)
4566 unsigned n_in, n_out, nparam, total, pos;
4567 struct isl_basic_map *bmap = NULL;
4568 struct isl_dim_map *dim_map1, *dim_map2;
4569 int i;
4571 if (!bmap1 || !bmap2)
4572 goto error;
4574 isl_assert(bmap1->ctx, isl_space_is_equal(bmap1->dim, bmap2->dim),
4575 goto error);
4577 nparam = isl_basic_map_dim(bmap1, isl_dim_param);
4578 n_in = isl_basic_map_dim(bmap1, isl_dim_in);
4579 n_out = isl_basic_map_dim(bmap1, isl_dim_out);
4581 total = nparam + n_in + n_out + bmap1->n_div + bmap2->n_div + 2 * n_out;
4582 dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
4583 dim_map2 = isl_dim_map_alloc(bmap2->ctx, total);
4584 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
4585 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos);
4586 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
4587 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos);
4588 isl_dim_map_div(dim_map1, bmap1, pos += n_in + n_out);
4589 isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
4590 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += bmap2->n_div);
4591 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos += n_out);
4593 bmap = isl_basic_map_alloc_space(isl_space_copy(bmap1->dim),
4594 bmap1->n_div + bmap2->n_div + 2 * n_out,
4595 bmap1->n_eq + bmap2->n_eq + n_out,
4596 bmap1->n_ineq + bmap2->n_ineq);
4597 for (i = 0; i < n_out; ++i) {
4598 int j = isl_basic_map_alloc_equality(bmap);
4599 if (j < 0)
4600 goto error;
4601 isl_seq_clr(bmap->eq[j], 1+total);
4602 isl_int_set_si(bmap->eq[j][1+nparam+n_in+i], -1);
4603 isl_int_set_si(bmap->eq[j][1+pos+i], 1);
4604 isl_int_set_si(bmap->eq[j][1+pos-n_out+i], 1);
4606 bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap1, dim_map1);
4607 bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap2, dim_map2);
4608 bmap = add_divs(bmap, 2 * n_out);
4610 bmap = isl_basic_map_simplify(bmap);
4611 return isl_basic_map_finalize(bmap);
4612 error:
4613 isl_basic_map_free(bmap);
4614 isl_basic_map_free(bmap1);
4615 isl_basic_map_free(bmap2);
4616 return NULL;
4619 /* Given two maps A -> f(A) and B -> g(B), construct a map
4620 * A \cap B -> f(A) + f(B)
4622 __isl_give isl_map *isl_map_sum(__isl_take isl_map *map1,
4623 __isl_take isl_map *map2)
4625 struct isl_map *result;
4626 int i, j;
4628 if (!map1 || !map2)
4629 goto error;
4631 isl_assert(map1->ctx, isl_space_is_equal(map1->dim, map2->dim), goto error);
4633 result = isl_map_alloc_space(isl_space_copy(map1->dim),
4634 map1->n * map2->n, 0);
4635 if (!result)
4636 goto error;
4637 for (i = 0; i < map1->n; ++i)
4638 for (j = 0; j < map2->n; ++j) {
4639 struct isl_basic_map *part;
4640 part = isl_basic_map_sum(
4641 isl_basic_map_copy(map1->p[i]),
4642 isl_basic_map_copy(map2->p[j]));
4643 if (isl_basic_map_is_empty(part))
4644 isl_basic_map_free(part);
4645 else
4646 result = isl_map_add_basic_map(result, part);
4647 if (!result)
4648 goto error;
4650 isl_map_free(map1);
4651 isl_map_free(map2);
4652 return result;
4653 error:
4654 isl_map_free(map1);
4655 isl_map_free(map2);
4656 return NULL;
4659 __isl_give isl_set *isl_set_sum(__isl_take isl_set *set1,
4660 __isl_take isl_set *set2)
4662 return set_from_map(isl_map_sum(set_to_map(set1), set_to_map(set2)));
4665 /* Given a basic map A -> f(A), construct A -> -f(A).
4667 __isl_give isl_basic_map *isl_basic_map_neg(__isl_take isl_basic_map *bmap)
4669 int i, j;
4670 unsigned off, n;
4672 bmap = isl_basic_map_cow(bmap);
4673 if (!bmap)
4674 return NULL;
4676 n = isl_basic_map_dim(bmap, isl_dim_out);
4677 off = isl_basic_map_offset(bmap, isl_dim_out);
4678 for (i = 0; i < bmap->n_eq; ++i)
4679 for (j = 0; j < n; ++j)
4680 isl_int_neg(bmap->eq[i][off+j], bmap->eq[i][off+j]);
4681 for (i = 0; i < bmap->n_ineq; ++i)
4682 for (j = 0; j < n; ++j)
4683 isl_int_neg(bmap->ineq[i][off+j], bmap->ineq[i][off+j]);
4684 for (i = 0; i < bmap->n_div; ++i)
4685 for (j = 0; j < n; ++j)
4686 isl_int_neg(bmap->div[i][1+off+j], bmap->div[i][1+off+j]);
4687 bmap = isl_basic_map_gauss(bmap, NULL);
4688 return isl_basic_map_finalize(bmap);
4691 __isl_give isl_basic_set *isl_basic_set_neg(__isl_take isl_basic_set *bset)
4693 return isl_basic_map_neg(bset);
4696 /* Given a map A -> f(A), construct A -> -f(A).
4698 __isl_give isl_map *isl_map_neg(__isl_take isl_map *map)
4700 int i;
4702 map = isl_map_cow(map);
4703 if (!map)
4704 return NULL;
4706 for (i = 0; i < map->n; ++i) {
4707 map->p[i] = isl_basic_map_neg(map->p[i]);
4708 if (!map->p[i])
4709 goto error;
4712 return map;
4713 error:
4714 isl_map_free(map);
4715 return NULL;
4718 __isl_give isl_set *isl_set_neg(__isl_take isl_set *set)
4720 return set_from_map(isl_map_neg(set_to_map(set)));
4723 /* Given a basic map A -> f(A) and an integer d, construct a basic map
4724 * A -> floor(f(A)/d).
4726 __isl_give isl_basic_map *isl_basic_map_floordiv(__isl_take isl_basic_map *bmap,
4727 isl_int d)
4729 unsigned n_in, n_out, nparam, total, pos;
4730 struct isl_basic_map *result = NULL;
4731 struct isl_dim_map *dim_map;
4732 int i;
4734 if (!bmap)
4735 return NULL;
4737 nparam = isl_basic_map_dim(bmap, isl_dim_param);
4738 n_in = isl_basic_map_dim(bmap, isl_dim_in);
4739 n_out = isl_basic_map_dim(bmap, isl_dim_out);
4741 total = nparam + n_in + n_out + bmap->n_div + n_out;
4742 dim_map = isl_dim_map_alloc(bmap->ctx, total);
4743 isl_dim_map_dim(dim_map, bmap->dim, isl_dim_param, pos = 0);
4744 isl_dim_map_dim(dim_map, bmap->dim, isl_dim_in, pos += nparam);
4745 isl_dim_map_div(dim_map, bmap, pos += n_in + n_out);
4746 isl_dim_map_dim(dim_map, bmap->dim, isl_dim_out, pos += bmap->n_div);
4748 result = isl_basic_map_alloc_space(isl_space_copy(bmap->dim),
4749 bmap->n_div + n_out,
4750 bmap->n_eq, bmap->n_ineq + 2 * n_out);
4751 result = isl_basic_map_add_constraints_dim_map(result, bmap, dim_map);
4752 result = add_divs(result, n_out);
4753 for (i = 0; i < n_out; ++i) {
4754 int j;
4755 j = isl_basic_map_alloc_inequality(result);
4756 if (j < 0)
4757 goto error;
4758 isl_seq_clr(result->ineq[j], 1+total);
4759 isl_int_neg(result->ineq[j][1+nparam+n_in+i], d);
4760 isl_int_set_si(result->ineq[j][1+pos+i], 1);
4761 j = isl_basic_map_alloc_inequality(result);
4762 if (j < 0)
4763 goto error;
4764 isl_seq_clr(result->ineq[j], 1+total);
4765 isl_int_set(result->ineq[j][1+nparam+n_in+i], d);
4766 isl_int_set_si(result->ineq[j][1+pos+i], -1);
4767 isl_int_sub_ui(result->ineq[j][0], d, 1);
4770 result = isl_basic_map_simplify(result);
4771 return isl_basic_map_finalize(result);
4772 error:
4773 isl_basic_map_free(result);
4774 return NULL;
4777 /* Given a map A -> f(A) and an integer d, construct a map
4778 * A -> floor(f(A)/d).
4780 __isl_give isl_map *isl_map_floordiv(__isl_take isl_map *map, isl_int d)
4782 int i;
4784 map = isl_map_cow(map);
4785 if (!map)
4786 return NULL;
4788 ISL_F_CLR(map, ISL_MAP_DISJOINT);
4789 for (i = 0; i < map->n; ++i) {
4790 map->p[i] = isl_basic_map_floordiv(map->p[i], d);
4791 if (!map->p[i])
4792 goto error;
4794 map = isl_map_unmark_normalized(map);
4796 return map;
4797 error:
4798 isl_map_free(map);
4799 return NULL;
4802 /* Given a map A -> f(A) and an integer d, construct a map
4803 * A -> floor(f(A)/d).
4805 __isl_give isl_map *isl_map_floordiv_val(__isl_take isl_map *map,
4806 __isl_take isl_val *d)
4808 if (!map || !d)
4809 goto error;
4810 if (!isl_val_is_int(d))
4811 isl_die(isl_val_get_ctx(d), isl_error_invalid,
4812 "expecting integer denominator", goto error);
4813 map = isl_map_floordiv(map, d->n);
4814 isl_val_free(d);
4815 return map;
4816 error:
4817 isl_map_free(map);
4818 isl_val_free(d);
4819 return NULL;
4822 static __isl_give isl_basic_map *var_equal(__isl_take isl_basic_map *bmap,
4823 unsigned pos)
4825 int i;
4826 unsigned nparam;
4827 unsigned n_in;
4829 i = isl_basic_map_alloc_equality(bmap);
4830 if (i < 0)
4831 goto error;
4832 nparam = isl_basic_map_dim(bmap, isl_dim_param);
4833 n_in = isl_basic_map_dim(bmap, isl_dim_in);
4834 isl_seq_clr(bmap->eq[i], 1 + isl_basic_map_total_dim(bmap));
4835 isl_int_set_si(bmap->eq[i][1+nparam+pos], -1);
4836 isl_int_set_si(bmap->eq[i][1+nparam+n_in+pos], 1);
4837 return isl_basic_map_finalize(bmap);
4838 error:
4839 isl_basic_map_free(bmap);
4840 return NULL;
4843 /* Add a constraint to "bmap" expressing i_pos < o_pos
4845 static __isl_give isl_basic_map *var_less(__isl_take isl_basic_map *bmap,
4846 unsigned pos)
4848 int i;
4849 unsigned nparam;
4850 unsigned n_in;
4852 i = isl_basic_map_alloc_inequality(bmap);
4853 if (i < 0)
4854 goto error;
4855 nparam = isl_basic_map_dim(bmap, isl_dim_param);
4856 n_in = isl_basic_map_dim(bmap, isl_dim_in);
4857 isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap));
4858 isl_int_set_si(bmap->ineq[i][0], -1);
4859 isl_int_set_si(bmap->ineq[i][1+nparam+pos], -1);
4860 isl_int_set_si(bmap->ineq[i][1+nparam+n_in+pos], 1);
4861 return isl_basic_map_finalize(bmap);
4862 error:
4863 isl_basic_map_free(bmap);
4864 return NULL;
4867 /* Add a constraint to "bmap" expressing i_pos <= o_pos
4869 static __isl_give isl_basic_map *var_less_or_equal(
4870 __isl_take isl_basic_map *bmap, unsigned pos)
4872 int i;
4873 unsigned nparam;
4874 unsigned n_in;
4876 i = isl_basic_map_alloc_inequality(bmap);
4877 if (i < 0)
4878 goto error;
4879 nparam = isl_basic_map_dim(bmap, isl_dim_param);
4880 n_in = isl_basic_map_dim(bmap, isl_dim_in);
4881 isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap));
4882 isl_int_set_si(bmap->ineq[i][1+nparam+pos], -1);
4883 isl_int_set_si(bmap->ineq[i][1+nparam+n_in+pos], 1);
4884 return isl_basic_map_finalize(bmap);
4885 error:
4886 isl_basic_map_free(bmap);
4887 return NULL;
4890 /* Add a constraint to "bmap" expressing i_pos > o_pos
4892 static __isl_give isl_basic_map *var_more(__isl_take isl_basic_map *bmap,
4893 unsigned pos)
4895 int i;
4896 unsigned nparam;
4897 unsigned n_in;
4899 i = isl_basic_map_alloc_inequality(bmap);
4900 if (i < 0)
4901 goto error;
4902 nparam = isl_basic_map_dim(bmap, isl_dim_param);
4903 n_in = isl_basic_map_dim(bmap, isl_dim_in);
4904 isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap));
4905 isl_int_set_si(bmap->ineq[i][0], -1);
4906 isl_int_set_si(bmap->ineq[i][1+nparam+pos], 1);
4907 isl_int_set_si(bmap->ineq[i][1+nparam+n_in+pos], -1);
4908 return isl_basic_map_finalize(bmap);
4909 error:
4910 isl_basic_map_free(bmap);
4911 return NULL;
4914 /* Add a constraint to "bmap" expressing i_pos >= o_pos
4916 static __isl_give isl_basic_map *var_more_or_equal(
4917 __isl_take isl_basic_map *bmap, unsigned pos)
4919 int i;
4920 unsigned nparam;
4921 unsigned n_in;
4923 i = isl_basic_map_alloc_inequality(bmap);
4924 if (i < 0)
4925 goto error;
4926 nparam = isl_basic_map_dim(bmap, isl_dim_param);
4927 n_in = isl_basic_map_dim(bmap, isl_dim_in);
4928 isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap));
4929 isl_int_set_si(bmap->ineq[i][1+nparam+pos], 1);
4930 isl_int_set_si(bmap->ineq[i][1+nparam+n_in+pos], -1);
4931 return isl_basic_map_finalize(bmap);
4932 error:
4933 isl_basic_map_free(bmap);
4934 return NULL;
4937 __isl_give isl_basic_map *isl_basic_map_equal(
4938 __isl_take isl_space *dim, unsigned n_equal)
4940 int i;
4941 struct isl_basic_map *bmap;
4942 bmap = isl_basic_map_alloc_space(dim, 0, n_equal, 0);
4943 if (!bmap)
4944 return NULL;
4945 for (i = 0; i < n_equal && bmap; ++i)
4946 bmap = var_equal(bmap, i);
4947 return isl_basic_map_finalize(bmap);
4950 /* Return a relation on of dimension "dim" expressing i_[0..pos] << o_[0..pos]
4952 __isl_give isl_basic_map *isl_basic_map_less_at(__isl_take isl_space *dim,
4953 unsigned pos)
4955 int i;
4956 struct isl_basic_map *bmap;
4957 bmap = isl_basic_map_alloc_space(dim, 0, pos, 1);
4958 if (!bmap)
4959 return NULL;
4960 for (i = 0; i < pos && bmap; ++i)
4961 bmap = var_equal(bmap, i);
4962 if (bmap)
4963 bmap = var_less(bmap, pos);
4964 return isl_basic_map_finalize(bmap);
4967 /* Return a relation on "dim" expressing i_[0..pos] <<= o_[0..pos]
4969 __isl_give isl_basic_map *isl_basic_map_less_or_equal_at(
4970 __isl_take isl_space *dim, unsigned pos)
4972 int i;
4973 isl_basic_map *bmap;
4975 bmap = isl_basic_map_alloc_space(dim, 0, pos, 1);
4976 for (i = 0; i < pos; ++i)
4977 bmap = var_equal(bmap, i);
4978 bmap = var_less_or_equal(bmap, pos);
4979 return isl_basic_map_finalize(bmap);
4982 /* Return a relation on "dim" expressing i_pos > o_pos
4984 __isl_give isl_basic_map *isl_basic_map_more_at(__isl_take isl_space *dim,
4985 unsigned pos)
4987 int i;
4988 struct isl_basic_map *bmap;
4989 bmap = isl_basic_map_alloc_space(dim, 0, pos, 1);
4990 if (!bmap)
4991 return NULL;
4992 for (i = 0; i < pos && bmap; ++i)
4993 bmap = var_equal(bmap, i);
4994 if (bmap)
4995 bmap = var_more(bmap, pos);
4996 return isl_basic_map_finalize(bmap);
4999 /* Return a relation on "dim" expressing i_[0..pos] >>= o_[0..pos]
5001 __isl_give isl_basic_map *isl_basic_map_more_or_equal_at(
5002 __isl_take isl_space *dim, unsigned pos)
5004 int i;
5005 isl_basic_map *bmap;
5007 bmap = isl_basic_map_alloc_space(dim, 0, pos, 1);
5008 for (i = 0; i < pos; ++i)
5009 bmap = var_equal(bmap, i);
5010 bmap = var_more_or_equal(bmap, pos);
5011 return isl_basic_map_finalize(bmap);
5014 static __isl_give isl_map *map_lex_lte_first(__isl_take isl_space *dims,
5015 unsigned n, int equal)
5017 struct isl_map *map;
5018 int i;
5020 if (n == 0 && equal)
5021 return isl_map_universe(dims);
5023 map = isl_map_alloc_space(isl_space_copy(dims), n, ISL_MAP_DISJOINT);
5025 for (i = 0; i + 1 < n; ++i)
5026 map = isl_map_add_basic_map(map,
5027 isl_basic_map_less_at(isl_space_copy(dims), i));
5028 if (n > 0) {
5029 if (equal)
5030 map = isl_map_add_basic_map(map,
5031 isl_basic_map_less_or_equal_at(dims, n - 1));
5032 else
5033 map = isl_map_add_basic_map(map,
5034 isl_basic_map_less_at(dims, n - 1));
5035 } else
5036 isl_space_free(dims);
5038 return map;
5041 static __isl_give isl_map *map_lex_lte(__isl_take isl_space *dims, int equal)
5043 if (!dims)
5044 return NULL;
5045 return map_lex_lte_first(dims, dims->n_out, equal);
5048 __isl_give isl_map *isl_map_lex_lt_first(__isl_take isl_space *dim, unsigned n)
5050 return map_lex_lte_first(dim, n, 0);
5053 __isl_give isl_map *isl_map_lex_le_first(__isl_take isl_space *dim, unsigned n)
5055 return map_lex_lte_first(dim, n, 1);
5058 __isl_give isl_map *isl_map_lex_lt(__isl_take isl_space *set_dim)
5060 return map_lex_lte(isl_space_map_from_set(set_dim), 0);
5063 __isl_give isl_map *isl_map_lex_le(__isl_take isl_space *set_dim)
5065 return map_lex_lte(isl_space_map_from_set(set_dim), 1);
5068 static __isl_give isl_map *map_lex_gte_first(__isl_take isl_space *dims,
5069 unsigned n, int equal)
5071 struct isl_map *map;
5072 int i;
5074 if (n == 0 && equal)
5075 return isl_map_universe(dims);
5077 map = isl_map_alloc_space(isl_space_copy(dims), n, ISL_MAP_DISJOINT);
5079 for (i = 0; i + 1 < n; ++i)
5080 map = isl_map_add_basic_map(map,
5081 isl_basic_map_more_at(isl_space_copy(dims), i));
5082 if (n > 0) {
5083 if (equal)
5084 map = isl_map_add_basic_map(map,
5085 isl_basic_map_more_or_equal_at(dims, n - 1));
5086 else
5087 map = isl_map_add_basic_map(map,
5088 isl_basic_map_more_at(dims, n - 1));
5089 } else
5090 isl_space_free(dims);
5092 return map;
5095 static __isl_give isl_map *map_lex_gte(__isl_take isl_space *dims, int equal)
5097 if (!dims)
5098 return NULL;
5099 return map_lex_gte_first(dims, dims->n_out, equal);
5102 __isl_give isl_map *isl_map_lex_gt_first(__isl_take isl_space *dim, unsigned n)
5104 return map_lex_gte_first(dim, n, 0);
5107 __isl_give isl_map *isl_map_lex_ge_first(__isl_take isl_space *dim, unsigned n)
5109 return map_lex_gte_first(dim, n, 1);
5112 __isl_give isl_map *isl_map_lex_gt(__isl_take isl_space *set_dim)
5114 return map_lex_gte(isl_space_map_from_set(set_dim), 0);
5117 __isl_give isl_map *isl_map_lex_ge(__isl_take isl_space *set_dim)
5119 return map_lex_gte(isl_space_map_from_set(set_dim), 1);
5122 __isl_give isl_map *isl_set_lex_le_set(__isl_take isl_set *set1,
5123 __isl_take isl_set *set2)
5125 isl_map *map;
5126 map = isl_map_lex_le(isl_set_get_space(set1));
5127 map = isl_map_intersect_domain(map, set1);
5128 map = isl_map_intersect_range(map, set2);
5129 return map;
5132 __isl_give isl_map *isl_set_lex_lt_set(__isl_take isl_set *set1,
5133 __isl_take isl_set *set2)
5135 isl_map *map;
5136 map = isl_map_lex_lt(isl_set_get_space(set1));
5137 map = isl_map_intersect_domain(map, set1);
5138 map = isl_map_intersect_range(map, set2);
5139 return map;
5142 __isl_give isl_map *isl_set_lex_ge_set(__isl_take isl_set *set1,
5143 __isl_take isl_set *set2)
5145 isl_map *map;
5146 map = isl_map_lex_ge(isl_set_get_space(set1));
5147 map = isl_map_intersect_domain(map, set1);
5148 map = isl_map_intersect_range(map, set2);
5149 return map;
5152 __isl_give isl_map *isl_set_lex_gt_set(__isl_take isl_set *set1,
5153 __isl_take isl_set *set2)
5155 isl_map *map;
5156 map = isl_map_lex_gt(isl_set_get_space(set1));
5157 map = isl_map_intersect_domain(map, set1);
5158 map = isl_map_intersect_range(map, set2);
5159 return map;
5162 __isl_give isl_map *isl_map_lex_le_map(__isl_take isl_map *map1,
5163 __isl_take isl_map *map2)
5165 isl_map *map;
5166 map = isl_map_lex_le(isl_space_range(isl_map_get_space(map1)));
5167 map = isl_map_apply_domain(map, isl_map_reverse(map1));
5168 map = isl_map_apply_range(map, isl_map_reverse(map2));
5169 return map;
5172 __isl_give isl_map *isl_map_lex_lt_map(__isl_take isl_map *map1,
5173 __isl_take isl_map *map2)
5175 isl_map *map;
5176 map = isl_map_lex_lt(isl_space_range(isl_map_get_space(map1)));
5177 map = isl_map_apply_domain(map, isl_map_reverse(map1));
5178 map = isl_map_apply_range(map, isl_map_reverse(map2));
5179 return map;
5182 __isl_give isl_map *isl_map_lex_ge_map(__isl_take isl_map *map1,
5183 __isl_take isl_map *map2)
5185 isl_map *map;
5186 map = isl_map_lex_ge(isl_space_range(isl_map_get_space(map1)));
5187 map = isl_map_apply_domain(map, isl_map_reverse(map1));
5188 map = isl_map_apply_range(map, isl_map_reverse(map2));
5189 return map;
5192 __isl_give isl_map *isl_map_lex_gt_map(__isl_take isl_map *map1,
5193 __isl_take isl_map *map2)
5195 isl_map *map;
5196 map = isl_map_lex_gt(isl_space_range(isl_map_get_space(map1)));
5197 map = isl_map_apply_domain(map, isl_map_reverse(map1));
5198 map = isl_map_apply_range(map, isl_map_reverse(map2));
5199 return map;
5202 /* For a div d = floor(f/m), add the constraint
5204 * f - m d >= 0
5206 static isl_stat add_upper_div_constraint(__isl_keep isl_basic_map *bmap,
5207 unsigned pos, isl_int *div)
5209 int i;
5210 unsigned total = isl_basic_map_total_dim(bmap);
5212 i = isl_basic_map_alloc_inequality(bmap);
5213 if (i < 0)
5214 return isl_stat_error;
5215 isl_seq_cpy(bmap->ineq[i], div + 1, 1 + total);
5216 isl_int_neg(bmap->ineq[i][1 + pos], div[0]);
5218 return isl_stat_ok;
5221 /* For a div d = floor(f/m), add the constraint
5223 * -(f-(m-1)) + m d >= 0
5225 static isl_stat add_lower_div_constraint(__isl_keep isl_basic_map *bmap,
5226 unsigned pos, isl_int *div)
5228 int i;
5229 unsigned total = isl_basic_map_total_dim(bmap);
5231 i = isl_basic_map_alloc_inequality(bmap);
5232 if (i < 0)
5233 return isl_stat_error;
5234 isl_seq_neg(bmap->ineq[i], div + 1, 1 + total);
5235 isl_int_set(bmap->ineq[i][1 + pos], div[0]);
5236 isl_int_add(bmap->ineq[i][0], bmap->ineq[i][0], bmap->ineq[i][1 + pos]);
5237 isl_int_sub_ui(bmap->ineq[i][0], bmap->ineq[i][0], 1);
5239 return isl_stat_ok;
5242 /* For a div d = floor(f/m), add the constraints
5244 * f - m d >= 0
5245 * -(f-(m-1)) + m d >= 0
5247 * Note that the second constraint is the negation of
5249 * f - m d >= m
5251 int isl_basic_map_add_div_constraints_var(__isl_keep isl_basic_map *bmap,
5252 unsigned pos, isl_int *div)
5254 if (add_upper_div_constraint(bmap, pos, div) < 0)
5255 return -1;
5256 if (add_lower_div_constraint(bmap, pos, div) < 0)
5257 return -1;
5258 return 0;
5261 int isl_basic_set_add_div_constraints_var(__isl_keep isl_basic_set *bset,
5262 unsigned pos, isl_int *div)
5264 return isl_basic_map_add_div_constraints_var(bset_to_bmap(bset),
5265 pos, div);
5268 int isl_basic_map_add_div_constraints(struct isl_basic_map *bmap, unsigned div)
5270 unsigned total = isl_basic_map_total_dim(bmap);
5271 unsigned div_pos = total - bmap->n_div + div;
5273 return isl_basic_map_add_div_constraints_var(bmap, div_pos,
5274 bmap->div[div]);
5277 /* For each known div d = floor(f/m), add the constraints
5279 * f - m d >= 0
5280 * -(f-(m-1)) + m d >= 0
5282 * Remove duplicate constraints in case of some these div constraints
5283 * already appear in "bmap".
5285 __isl_give isl_basic_map *isl_basic_map_add_known_div_constraints(
5286 __isl_take isl_basic_map *bmap)
5288 unsigned n_div;
5290 if (!bmap)
5291 return NULL;
5292 n_div = isl_basic_map_dim(bmap, isl_dim_div);
5293 if (n_div == 0)
5294 return bmap;
5296 bmap = add_known_div_constraints(bmap);
5297 bmap = isl_basic_map_remove_duplicate_constraints(bmap, NULL, 0);
5298 bmap = isl_basic_map_finalize(bmap);
5299 return bmap;
5302 /* Add the div constraint of sign "sign" for div "div" of "bmap".
5304 * In particular, if this div is of the form d = floor(f/m),
5305 * then add the constraint
5307 * f - m d >= 0
5309 * if sign < 0 or the constraint
5311 * -(f-(m-1)) + m d >= 0
5313 * if sign > 0.
5315 int isl_basic_map_add_div_constraint(__isl_keep isl_basic_map *bmap,
5316 unsigned div, int sign)
5318 unsigned total;
5319 unsigned div_pos;
5321 if (!bmap)
5322 return -1;
5324 total = isl_basic_map_total_dim(bmap);
5325 div_pos = total - bmap->n_div + div;
5327 if (sign < 0)
5328 return add_upper_div_constraint(bmap, div_pos, bmap->div[div]);
5329 else
5330 return add_lower_div_constraint(bmap, div_pos, bmap->div[div]);
5333 __isl_give isl_basic_set *isl_basic_map_underlying_set(
5334 __isl_take isl_basic_map *bmap)
5336 if (!bmap)
5337 goto error;
5338 if (bmap->dim->nparam == 0 && bmap->dim->n_in == 0 &&
5339 bmap->n_div == 0 &&
5340 !isl_space_is_named_or_nested(bmap->dim, isl_dim_in) &&
5341 !isl_space_is_named_or_nested(bmap->dim, isl_dim_out))
5342 return bset_from_bmap(bmap);
5343 bmap = isl_basic_map_cow(bmap);
5344 if (!bmap)
5345 goto error;
5346 bmap->dim = isl_space_underlying(bmap->dim, bmap->n_div);
5347 if (!bmap->dim)
5348 goto error;
5349 bmap->extra -= bmap->n_div;
5350 bmap->n_div = 0;
5351 bmap = isl_basic_map_finalize(bmap);
5352 return bset_from_bmap(bmap);
5353 error:
5354 isl_basic_map_free(bmap);
5355 return NULL;
5358 __isl_give isl_basic_set *isl_basic_set_underlying_set(
5359 __isl_take isl_basic_set *bset)
5361 return isl_basic_map_underlying_set(bset_to_bmap(bset));
5364 /* Replace each element in "list" by the result of applying
5365 * isl_basic_map_underlying_set to the element.
5367 __isl_give isl_basic_set_list *isl_basic_map_list_underlying_set(
5368 __isl_take isl_basic_map_list *list)
5370 int i, n;
5372 if (!list)
5373 return NULL;
5375 n = isl_basic_map_list_n_basic_map(list);
5376 for (i = 0; i < n; ++i) {
5377 isl_basic_map *bmap;
5378 isl_basic_set *bset;
5380 bmap = isl_basic_map_list_get_basic_map(list, i);
5381 bset = isl_basic_set_underlying_set(bmap);
5382 list = isl_basic_set_list_set_basic_set(list, i, bset);
5385 return list;
5388 __isl_give isl_basic_map *isl_basic_map_overlying_set(
5389 __isl_take isl_basic_set *bset, __isl_take isl_basic_map *like)
5391 struct isl_basic_map *bmap;
5392 struct isl_ctx *ctx;
5393 unsigned total;
5394 int i;
5396 if (!bset || !like)
5397 goto error;
5398 ctx = bset->ctx;
5399 isl_assert(ctx, bset->n_div == 0, goto error);
5400 isl_assert(ctx, isl_basic_set_n_param(bset) == 0, goto error);
5401 isl_assert(ctx, bset->dim->n_out == isl_basic_map_total_dim(like),
5402 goto error);
5403 if (like->n_div == 0) {
5404 isl_space *space = isl_basic_map_get_space(like);
5405 isl_basic_map_free(like);
5406 return isl_basic_map_reset_space(bset, space);
5408 bset = isl_basic_set_cow(bset);
5409 if (!bset)
5410 goto error;
5411 total = bset->dim->n_out + bset->extra;
5412 bmap = bset_to_bmap(bset);
5413 isl_space_free(bmap->dim);
5414 bmap->dim = isl_space_copy(like->dim);
5415 if (!bmap->dim)
5416 goto error;
5417 bmap->n_div = like->n_div;
5418 bmap->extra += like->n_div;
5419 if (bmap->extra) {
5420 unsigned ltotal;
5421 isl_int **div;
5422 ltotal = total - bmap->extra + like->extra;
5423 if (ltotal > total)
5424 ltotal = total;
5425 bmap->block2 = isl_blk_extend(ctx, bmap->block2,
5426 bmap->extra * (1 + 1 + total));
5427 if (isl_blk_is_error(bmap->block2))
5428 goto error;
5429 div = isl_realloc_array(ctx, bmap->div, isl_int *, bmap->extra);
5430 if (!div)
5431 goto error;
5432 bmap->div = div;
5433 for (i = 0; i < bmap->extra; ++i)
5434 bmap->div[i] = bmap->block2.data + i * (1 + 1 + total);
5435 for (i = 0; i < like->n_div; ++i) {
5436 isl_seq_cpy(bmap->div[i], like->div[i], 1 + 1 + ltotal);
5437 isl_seq_clr(bmap->div[i]+1+1+ltotal, total - ltotal);
5439 bmap = isl_basic_map_add_known_div_constraints(bmap);
5441 isl_basic_map_free(like);
5442 bmap = isl_basic_map_simplify(bmap);
5443 bmap = isl_basic_map_finalize(bmap);
5444 return bmap;
5445 error:
5446 isl_basic_map_free(like);
5447 isl_basic_set_free(bset);
5448 return NULL;
5451 struct isl_basic_set *isl_basic_set_from_underlying_set(
5452 struct isl_basic_set *bset, struct isl_basic_set *like)
5454 return bset_from_bmap(isl_basic_map_overlying_set(bset,
5455 bset_to_bmap(like)));
5458 __isl_give isl_set *isl_map_underlying_set(__isl_take isl_map *map)
5460 int i;
5462 map = isl_map_cow(map);
5463 if (!map)
5464 return NULL;
5465 map->dim = isl_space_cow(map->dim);
5466 if (!map->dim)
5467 goto error;
5469 for (i = 1; i < map->n; ++i)
5470 isl_assert(map->ctx, map->p[0]->n_div == map->p[i]->n_div,
5471 goto error);
5472 for (i = 0; i < map->n; ++i) {
5473 map->p[i] = bset_to_bmap(
5474 isl_basic_map_underlying_set(map->p[i]));
5475 if (!map->p[i])
5476 goto error;
5478 if (map->n == 0)
5479 map->dim = isl_space_underlying(map->dim, 0);
5480 else {
5481 isl_space_free(map->dim);
5482 map->dim = isl_space_copy(map->p[0]->dim);
5484 if (!map->dim)
5485 goto error;
5486 return set_from_map(map);
5487 error:
5488 isl_map_free(map);
5489 return NULL;
5492 /* Replace the space of "bmap" by "space".
5494 * If the space of "bmap" is identical to "space" (including the identifiers
5495 * of the input and output dimensions), then simply return the original input.
5497 __isl_give isl_basic_map *isl_basic_map_reset_space(
5498 __isl_take isl_basic_map *bmap, __isl_take isl_space *space)
5500 isl_bool equal;
5501 isl_space *bmap_space;
5503 bmap_space = isl_basic_map_peek_space(bmap);
5504 equal = isl_space_is_equal(bmap_space, space);
5505 if (equal >= 0 && equal)
5506 equal = isl_space_has_equal_ids(bmap_space, space);
5507 if (equal < 0)
5508 goto error;
5509 if (equal) {
5510 isl_space_free(space);
5511 return bmap;
5513 bmap = isl_basic_map_cow(bmap);
5514 if (!bmap || !space)
5515 goto error;
5517 isl_space_free(bmap->dim);
5518 bmap->dim = space;
5520 bmap = isl_basic_map_finalize(bmap);
5522 return bmap;
5523 error:
5524 isl_basic_map_free(bmap);
5525 isl_space_free(space);
5526 return NULL;
5529 __isl_give isl_basic_set *isl_basic_set_reset_space(
5530 __isl_take isl_basic_set *bset, __isl_take isl_space *dim)
5532 return bset_from_bmap(isl_basic_map_reset_space(bset_to_bmap(bset),
5533 dim));
5536 /* Check that the total dimensions of "map" and "space" are the same.
5538 static isl_stat check_map_space_equal_total_dim(__isl_keep isl_map *map,
5539 __isl_keep isl_space *space)
5541 unsigned dim1, dim2;
5543 if (!map || !space)
5544 return isl_stat_error;
5545 dim1 = isl_map_dim(map, isl_dim_all);
5546 dim2 = isl_space_dim(space, isl_dim_all);
5547 if (dim1 == dim2)
5548 return isl_stat_ok;
5549 isl_die(isl_map_get_ctx(map), isl_error_invalid,
5550 "total dimensions do not match", return isl_stat_error);
5553 __isl_give isl_map *isl_map_reset_space(__isl_take isl_map *map,
5554 __isl_take isl_space *dim)
5556 int i;
5558 map = isl_map_cow(map);
5559 if (!map || !dim)
5560 goto error;
5562 for (i = 0; i < map->n; ++i) {
5563 map->p[i] = isl_basic_map_reset_space(map->p[i],
5564 isl_space_copy(dim));
5565 if (!map->p[i])
5566 goto error;
5568 isl_space_free(map->dim);
5569 map->dim = dim;
5571 return map;
5572 error:
5573 isl_map_free(map);
5574 isl_space_free(dim);
5575 return NULL;
5578 /* Replace the space of "map" by "space", without modifying
5579 * the dimension of "map".
5581 * If the space of "map" is identical to "space" (including the identifiers
5582 * of the input and output dimensions), then simply return the original input.
5584 __isl_give isl_map *isl_map_reset_equal_dim_space(__isl_take isl_map *map,
5585 __isl_take isl_space *space)
5587 isl_bool equal;
5588 isl_space *map_space;
5590 map_space = isl_map_peek_space(map);
5591 equal = isl_space_is_equal(map_space, space);
5592 if (equal >= 0 && equal)
5593 equal = isl_space_has_equal_ids(map_space, space);
5594 if (equal < 0)
5595 goto error;
5596 if (equal) {
5597 isl_space_free(space);
5598 return map;
5600 if (check_map_space_equal_total_dim(map, space) < 0)
5601 goto error;
5602 return isl_map_reset_space(map, space);
5603 error:
5604 isl_map_free(map);
5605 isl_space_free(space);
5606 return NULL;
5609 __isl_give isl_set *isl_set_reset_space(__isl_take isl_set *set,
5610 __isl_take isl_space *dim)
5612 return set_from_map(isl_map_reset_space(set_to_map(set), dim));
5615 /* Compute the parameter domain of the given basic set.
5617 __isl_give isl_basic_set *isl_basic_set_params(__isl_take isl_basic_set *bset)
5619 isl_bool is_params;
5620 isl_space *space;
5621 unsigned n;
5623 is_params = isl_basic_set_is_params(bset);
5624 if (is_params < 0)
5625 return isl_basic_set_free(bset);
5626 if (is_params)
5627 return bset;
5629 n = isl_basic_set_dim(bset, isl_dim_set);
5630 bset = isl_basic_set_project_out(bset, isl_dim_set, 0, n);
5631 space = isl_basic_set_get_space(bset);
5632 space = isl_space_params(space);
5633 bset = isl_basic_set_reset_space(bset, space);
5634 return bset;
5637 /* Construct a zero-dimensional basic set with the given parameter domain.
5639 __isl_give isl_basic_set *isl_basic_set_from_params(
5640 __isl_take isl_basic_set *bset)
5642 isl_space *space;
5643 space = isl_basic_set_get_space(bset);
5644 space = isl_space_set_from_params(space);
5645 bset = isl_basic_set_reset_space(bset, space);
5646 return bset;
5649 /* Compute the parameter domain of the given set.
5651 __isl_give isl_set *isl_set_params(__isl_take isl_set *set)
5653 isl_space *space;
5654 unsigned n;
5656 if (isl_set_is_params(set))
5657 return set;
5659 n = isl_set_dim(set, isl_dim_set);
5660 set = isl_set_project_out(set, isl_dim_set, 0, n);
5661 space = isl_set_get_space(set);
5662 space = isl_space_params(space);
5663 set = isl_set_reset_space(set, space);
5664 return set;
5667 /* Construct a zero-dimensional set with the given parameter domain.
5669 __isl_give isl_set *isl_set_from_params(__isl_take isl_set *set)
5671 isl_space *space;
5672 space = isl_set_get_space(set);
5673 space = isl_space_set_from_params(space);
5674 set = isl_set_reset_space(set, space);
5675 return set;
5678 /* Compute the parameter domain of the given map.
5680 __isl_give isl_set *isl_map_params(__isl_take isl_map *map)
5682 isl_space *space;
5683 unsigned n;
5685 n = isl_map_dim(map, isl_dim_in);
5686 map = isl_map_project_out(map, isl_dim_in, 0, n);
5687 n = isl_map_dim(map, isl_dim_out);
5688 map = isl_map_project_out(map, isl_dim_out, 0, n);
5689 space = isl_map_get_space(map);
5690 space = isl_space_params(space);
5691 map = isl_map_reset_space(map, space);
5692 return map;
5695 struct isl_basic_set *isl_basic_map_domain(struct isl_basic_map *bmap)
5697 isl_space *space;
5698 unsigned n_out;
5700 if (!bmap)
5701 return NULL;
5702 space = isl_space_domain(isl_basic_map_get_space(bmap));
5704 n_out = isl_basic_map_dim(bmap, isl_dim_out);
5705 bmap = isl_basic_map_project_out(bmap, isl_dim_out, 0, n_out);
5707 return isl_basic_map_reset_space(bmap, space);
5710 isl_bool isl_basic_map_may_be_set(__isl_keep isl_basic_map *bmap)
5712 if (!bmap)
5713 return isl_bool_error;
5714 return isl_space_may_be_set(bmap->dim);
5717 /* Is this basic map actually a set?
5718 * Users should never call this function. Outside of isl,
5719 * the type should indicate whether something is a set or a map.
5721 isl_bool isl_basic_map_is_set(__isl_keep isl_basic_map *bmap)
5723 if (!bmap)
5724 return isl_bool_error;
5725 return isl_space_is_set(bmap->dim);
5728 struct isl_basic_set *isl_basic_map_range(struct isl_basic_map *bmap)
5730 isl_bool is_set;
5732 is_set = isl_basic_map_is_set(bmap);
5733 if (is_set < 0)
5734 goto error;
5735 if (is_set)
5736 return bmap;
5737 return isl_basic_map_domain(isl_basic_map_reverse(bmap));
5738 error:
5739 isl_basic_map_free(bmap);
5740 return NULL;
5743 __isl_give isl_basic_map *isl_basic_map_domain_map(
5744 __isl_take isl_basic_map *bmap)
5746 int i;
5747 isl_space *dim;
5748 isl_basic_map *domain;
5749 int nparam, n_in, n_out;
5751 nparam = isl_basic_map_dim(bmap, isl_dim_param);
5752 n_in = isl_basic_map_dim(bmap, isl_dim_in);
5753 n_out = isl_basic_map_dim(bmap, isl_dim_out);
5755 dim = isl_space_from_range(isl_space_domain(isl_basic_map_get_space(bmap)));
5756 domain = isl_basic_map_universe(dim);
5758 bmap = isl_basic_map_from_domain(isl_basic_map_wrap(bmap));
5759 bmap = isl_basic_map_apply_range(bmap, domain);
5760 bmap = isl_basic_map_extend_constraints(bmap, n_in, 0);
5762 for (i = 0; i < n_in; ++i)
5763 bmap = isl_basic_map_equate(bmap, isl_dim_in, i,
5764 isl_dim_out, i);
5766 bmap = isl_basic_map_gauss(bmap, NULL);
5767 return isl_basic_map_finalize(bmap);
5770 __isl_give isl_basic_map *isl_basic_map_range_map(
5771 __isl_take isl_basic_map *bmap)
5773 int i;
5774 isl_space *dim;
5775 isl_basic_map *range;
5776 int nparam, n_in, n_out;
5778 nparam = isl_basic_map_dim(bmap, isl_dim_param);
5779 n_in = isl_basic_map_dim(bmap, isl_dim_in);
5780 n_out = isl_basic_map_dim(bmap, isl_dim_out);
5782 dim = isl_space_from_range(isl_space_range(isl_basic_map_get_space(bmap)));
5783 range = isl_basic_map_universe(dim);
5785 bmap = isl_basic_map_from_domain(isl_basic_map_wrap(bmap));
5786 bmap = isl_basic_map_apply_range(bmap, range);
5787 bmap = isl_basic_map_extend_constraints(bmap, n_out, 0);
5789 for (i = 0; i < n_out; ++i)
5790 bmap = isl_basic_map_equate(bmap, isl_dim_in, n_in + i,
5791 isl_dim_out, i);
5793 bmap = isl_basic_map_gauss(bmap, NULL);
5794 return isl_basic_map_finalize(bmap);
5797 int isl_map_may_be_set(__isl_keep isl_map *map)
5799 if (!map)
5800 return -1;
5801 return isl_space_may_be_set(map->dim);
5804 /* Is this map actually a set?
5805 * Users should never call this function. Outside of isl,
5806 * the type should indicate whether something is a set or a map.
5808 isl_bool isl_map_is_set(__isl_keep isl_map *map)
5810 if (!map)
5811 return isl_bool_error;
5812 return isl_space_is_set(map->dim);
5815 __isl_give isl_set *isl_map_range(__isl_take isl_map *map)
5817 int i;
5818 isl_bool is_set;
5819 struct isl_set *set;
5821 is_set = isl_map_is_set(map);
5822 if (is_set < 0)
5823 goto error;
5824 if (is_set)
5825 return set_from_map(map);
5827 map = isl_map_cow(map);
5828 if (!map)
5829 goto error;
5831 set = set_from_map(map);
5832 set->dim = isl_space_range(set->dim);
5833 if (!set->dim)
5834 goto error;
5835 for (i = 0; i < map->n; ++i) {
5836 set->p[i] = isl_basic_map_range(map->p[i]);
5837 if (!set->p[i])
5838 goto error;
5840 ISL_F_CLR(set, ISL_MAP_DISJOINT);
5841 ISL_F_CLR(set, ISL_SET_NORMALIZED);
5842 return set;
5843 error:
5844 isl_map_free(map);
5845 return NULL;
5848 __isl_give isl_map *isl_map_domain_map(__isl_take isl_map *map)
5850 int i;
5852 map = isl_map_cow(map);
5853 if (!map)
5854 return NULL;
5856 map->dim = isl_space_domain_map(map->dim);
5857 if (!map->dim)
5858 goto error;
5859 for (i = 0; i < map->n; ++i) {
5860 map->p[i] = isl_basic_map_domain_map(map->p[i]);
5861 if (!map->p[i])
5862 goto error;
5864 ISL_F_CLR(map, ISL_MAP_DISJOINT);
5865 map = isl_map_unmark_normalized(map);
5866 return map;
5867 error:
5868 isl_map_free(map);
5869 return NULL;
5872 __isl_give isl_map *isl_map_range_map(__isl_take isl_map *map)
5874 int i;
5875 isl_space *range_dim;
5877 map = isl_map_cow(map);
5878 if (!map)
5879 return NULL;
5881 range_dim = isl_space_range(isl_map_get_space(map));
5882 range_dim = isl_space_from_range(range_dim);
5883 map->dim = isl_space_from_domain(isl_space_wrap(map->dim));
5884 map->dim = isl_space_join(map->dim, range_dim);
5885 if (!map->dim)
5886 goto error;
5887 for (i = 0; i < map->n; ++i) {
5888 map->p[i] = isl_basic_map_range_map(map->p[i]);
5889 if (!map->p[i])
5890 goto error;
5892 ISL_F_CLR(map, ISL_MAP_DISJOINT);
5893 map = isl_map_unmark_normalized(map);
5894 return map;
5895 error:
5896 isl_map_free(map);
5897 return NULL;
5900 /* Given a wrapped map of the form A[B -> C],
5901 * return the map A[B -> C] -> B.
5903 __isl_give isl_map *isl_set_wrapped_domain_map(__isl_take isl_set *set)
5905 isl_id *id;
5906 isl_map *map;
5908 if (!set)
5909 return NULL;
5910 if (!isl_set_has_tuple_id(set))
5911 return isl_map_domain_map(isl_set_unwrap(set));
5913 id = isl_set_get_tuple_id(set);
5914 map = isl_map_domain_map(isl_set_unwrap(set));
5915 map = isl_map_set_tuple_id(map, isl_dim_in, id);
5917 return map;
5920 __isl_give isl_basic_map *isl_basic_map_from_domain(
5921 __isl_take isl_basic_set *bset)
5923 return isl_basic_map_reverse(isl_basic_map_from_range(bset));
5926 __isl_give isl_basic_map *isl_basic_map_from_range(
5927 __isl_take isl_basic_set *bset)
5929 isl_space *space;
5930 space = isl_basic_set_get_space(bset);
5931 space = isl_space_from_range(space);
5932 bset = isl_basic_set_reset_space(bset, space);
5933 return bset_to_bmap(bset);
5936 /* Create a relation with the given set as range.
5937 * The domain of the created relation is a zero-dimensional
5938 * flat anonymous space.
5940 __isl_give isl_map *isl_map_from_range(__isl_take isl_set *set)
5942 isl_space *space;
5943 space = isl_set_get_space(set);
5944 space = isl_space_from_range(space);
5945 set = isl_set_reset_space(set, space);
5946 return set_to_map(set);
5949 /* Create a relation with the given set as domain.
5950 * The range of the created relation is a zero-dimensional
5951 * flat anonymous space.
5953 __isl_give isl_map *isl_map_from_domain(__isl_take isl_set *set)
5955 return isl_map_reverse(isl_map_from_range(set));
5958 __isl_give isl_basic_map *isl_basic_map_from_domain_and_range(
5959 __isl_take isl_basic_set *domain, __isl_take isl_basic_set *range)
5961 return isl_basic_map_apply_range(isl_basic_map_reverse(domain), range);
5964 __isl_give isl_map *isl_map_from_domain_and_range(__isl_take isl_set *domain,
5965 __isl_take isl_set *range)
5967 return isl_map_apply_range(isl_map_reverse(domain), range);
5970 /* Return a newly allocated isl_map with given space and flags and
5971 * room for "n" basic maps.
5972 * Make sure that all cached information is cleared.
5974 __isl_give isl_map *isl_map_alloc_space(__isl_take isl_space *space, int n,
5975 unsigned flags)
5977 struct isl_map *map;
5979 if (!space)
5980 return NULL;
5981 if (n < 0)
5982 isl_die(space->ctx, isl_error_internal,
5983 "negative number of basic maps", goto error);
5984 map = isl_calloc(space->ctx, struct isl_map,
5985 sizeof(struct isl_map) +
5986 (n - 1) * sizeof(struct isl_basic_map *));
5987 if (!map)
5988 goto error;
5990 map->ctx = space->ctx;
5991 isl_ctx_ref(map->ctx);
5992 map->ref = 1;
5993 map->size = n;
5994 map->n = 0;
5995 map->dim = space;
5996 map->flags = flags;
5997 return map;
5998 error:
5999 isl_space_free(space);
6000 return NULL;
6003 __isl_give isl_basic_map *isl_basic_map_empty(__isl_take isl_space *space)
6005 struct isl_basic_map *bmap;
6006 bmap = isl_basic_map_alloc_space(space, 0, 1, 0);
6007 bmap = isl_basic_map_set_to_empty(bmap);
6008 return bmap;
6011 __isl_give isl_basic_set *isl_basic_set_empty(__isl_take isl_space *space)
6013 struct isl_basic_set *bset;
6014 bset = isl_basic_set_alloc_space(space, 0, 1, 0);
6015 bset = isl_basic_set_set_to_empty(bset);
6016 return bset;
6019 __isl_give isl_basic_map *isl_basic_map_universe(__isl_take isl_space *space)
6021 struct isl_basic_map *bmap;
6022 bmap = isl_basic_map_alloc_space(space, 0, 0, 0);
6023 bmap = isl_basic_map_finalize(bmap);
6024 return bmap;
6027 __isl_give isl_basic_set *isl_basic_set_universe(__isl_take isl_space *space)
6029 struct isl_basic_set *bset;
6030 bset = isl_basic_set_alloc_space(space, 0, 0, 0);
6031 bset = isl_basic_set_finalize(bset);
6032 return bset;
6035 __isl_give isl_basic_map *isl_basic_map_nat_universe(__isl_take isl_space *dim)
6037 int i;
6038 unsigned total = isl_space_dim(dim, isl_dim_all);
6039 isl_basic_map *bmap;
6041 bmap= isl_basic_map_alloc_space(dim, 0, 0, total);
6042 for (i = 0; i < total; ++i) {
6043 int k = isl_basic_map_alloc_inequality(bmap);
6044 if (k < 0)
6045 goto error;
6046 isl_seq_clr(bmap->ineq[k], 1 + total);
6047 isl_int_set_si(bmap->ineq[k][1 + i], 1);
6049 return bmap;
6050 error:
6051 isl_basic_map_free(bmap);
6052 return NULL;
6055 __isl_give isl_basic_set *isl_basic_set_nat_universe(__isl_take isl_space *dim)
6057 return isl_basic_map_nat_universe(dim);
6060 __isl_give isl_map *isl_map_nat_universe(__isl_take isl_space *dim)
6062 return isl_map_from_basic_map(isl_basic_map_nat_universe(dim));
6065 __isl_give isl_set *isl_set_nat_universe(__isl_take isl_space *dim)
6067 return isl_map_nat_universe(dim);
6070 __isl_give isl_map *isl_map_empty(__isl_take isl_space *space)
6072 return isl_map_alloc_space(space, 0, ISL_MAP_DISJOINT);
6075 __isl_give isl_set *isl_set_empty(__isl_take isl_space *space)
6077 return isl_set_alloc_space(space, 0, ISL_MAP_DISJOINT);
6080 __isl_give isl_map *isl_map_universe(__isl_take isl_space *space)
6082 struct isl_map *map;
6083 if (!space)
6084 return NULL;
6085 map = isl_map_alloc_space(isl_space_copy(space), 1, ISL_MAP_DISJOINT);
6086 map = isl_map_add_basic_map(map, isl_basic_map_universe(space));
6087 return map;
6090 __isl_give isl_set *isl_set_universe(__isl_take isl_space *space)
6092 struct isl_set *set;
6093 if (!space)
6094 return NULL;
6095 set = isl_set_alloc_space(isl_space_copy(space), 1, ISL_MAP_DISJOINT);
6096 set = isl_set_add_basic_set(set, isl_basic_set_universe(space));
6097 return set;
6100 struct isl_map *isl_map_dup(struct isl_map *map)
6102 int i;
6103 struct isl_map *dup;
6105 if (!map)
6106 return NULL;
6107 dup = isl_map_alloc_space(isl_space_copy(map->dim), map->n, map->flags);
6108 for (i = 0; i < map->n; ++i)
6109 dup = isl_map_add_basic_map(dup, isl_basic_map_copy(map->p[i]));
6110 return dup;
6113 __isl_give isl_map *isl_map_add_basic_map(__isl_take isl_map *map,
6114 __isl_take isl_basic_map *bmap)
6116 if (!bmap || !map)
6117 goto error;
6118 if (isl_basic_map_plain_is_empty(bmap)) {
6119 isl_basic_map_free(bmap);
6120 return map;
6122 isl_assert(map->ctx, isl_space_is_equal(map->dim, bmap->dim), goto error);
6123 isl_assert(map->ctx, map->n < map->size, goto error);
6124 map->p[map->n] = bmap;
6125 map->n++;
6126 map = isl_map_unmark_normalized(map);
6127 return map;
6128 error:
6129 if (map)
6130 isl_map_free(map);
6131 if (bmap)
6132 isl_basic_map_free(bmap);
6133 return NULL;
6136 __isl_null isl_map *isl_map_free(__isl_take isl_map *map)
6138 int i;
6140 if (!map)
6141 return NULL;
6143 if (--map->ref > 0)
6144 return NULL;
6146 clear_caches(map);
6147 isl_ctx_deref(map->ctx);
6148 for (i = 0; i < map->n; ++i)
6149 isl_basic_map_free(map->p[i]);
6150 isl_space_free(map->dim);
6151 free(map);
6153 return NULL;
6156 static struct isl_basic_map *isl_basic_map_fix_pos_si(
6157 struct isl_basic_map *bmap, unsigned pos, int value)
6159 int j;
6161 bmap = isl_basic_map_cow(bmap);
6162 bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
6163 j = isl_basic_map_alloc_equality(bmap);
6164 if (j < 0)
6165 goto error;
6166 isl_seq_clr(bmap->eq[j] + 1, isl_basic_map_total_dim(bmap));
6167 isl_int_set_si(bmap->eq[j][pos], -1);
6168 isl_int_set_si(bmap->eq[j][0], value);
6169 bmap = isl_basic_map_simplify(bmap);
6170 return isl_basic_map_finalize(bmap);
6171 error:
6172 isl_basic_map_free(bmap);
6173 return NULL;
6176 static __isl_give isl_basic_map *isl_basic_map_fix_pos(
6177 __isl_take isl_basic_map *bmap, unsigned pos, isl_int value)
6179 int j;
6181 bmap = isl_basic_map_cow(bmap);
6182 bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
6183 j = isl_basic_map_alloc_equality(bmap);
6184 if (j < 0)
6185 goto error;
6186 isl_seq_clr(bmap->eq[j] + 1, isl_basic_map_total_dim(bmap));
6187 isl_int_set_si(bmap->eq[j][pos], -1);
6188 isl_int_set(bmap->eq[j][0], value);
6189 bmap = isl_basic_map_simplify(bmap);
6190 return isl_basic_map_finalize(bmap);
6191 error:
6192 isl_basic_map_free(bmap);
6193 return NULL;
6196 __isl_give isl_basic_map *isl_basic_map_fix_si(__isl_take isl_basic_map *bmap,
6197 enum isl_dim_type type, unsigned pos, int value)
6199 if (isl_basic_map_check_range(bmap, type, pos, 1) < 0)
6200 return isl_basic_map_free(bmap);
6201 return isl_basic_map_fix_pos_si(bmap,
6202 isl_basic_map_offset(bmap, type) + pos, value);
6205 __isl_give isl_basic_map *isl_basic_map_fix(__isl_take isl_basic_map *bmap,
6206 enum isl_dim_type type, unsigned pos, isl_int value)
6208 if (isl_basic_map_check_range(bmap, type, pos, 1) < 0)
6209 return isl_basic_map_free(bmap);
6210 return isl_basic_map_fix_pos(bmap,
6211 isl_basic_map_offset(bmap, type) + pos, value);
6214 /* Fix the value of the variable at position "pos" of type "type" of "bmap"
6215 * to be equal to "v".
6217 __isl_give isl_basic_map *isl_basic_map_fix_val(__isl_take isl_basic_map *bmap,
6218 enum isl_dim_type type, unsigned pos, __isl_take isl_val *v)
6220 if (!bmap || !v)
6221 goto error;
6222 if (!isl_val_is_int(v))
6223 isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
6224 "expecting integer value", goto error);
6225 if (isl_basic_map_check_range(bmap, type, pos, 1) < 0)
6226 goto error;
6227 pos += isl_basic_map_offset(bmap, type);
6228 bmap = isl_basic_map_fix_pos(bmap, pos, v->n);
6229 isl_val_free(v);
6230 return bmap;
6231 error:
6232 isl_basic_map_free(bmap);
6233 isl_val_free(v);
6234 return NULL;
6237 /* Fix the value of the variable at position "pos" of type "type" of "bset"
6238 * to be equal to "v".
6240 __isl_give isl_basic_set *isl_basic_set_fix_val(__isl_take isl_basic_set *bset,
6241 enum isl_dim_type type, unsigned pos, __isl_take isl_val *v)
6243 return isl_basic_map_fix_val(bset, type, pos, v);
6246 struct isl_basic_set *isl_basic_set_fix_si(struct isl_basic_set *bset,
6247 enum isl_dim_type type, unsigned pos, int value)
6249 return bset_from_bmap(isl_basic_map_fix_si(bset_to_bmap(bset),
6250 type, pos, value));
6253 __isl_give isl_basic_set *isl_basic_set_fix(__isl_take isl_basic_set *bset,
6254 enum isl_dim_type type, unsigned pos, isl_int value)
6256 return bset_from_bmap(isl_basic_map_fix(bset_to_bmap(bset),
6257 type, pos, value));
6260 struct isl_basic_map *isl_basic_map_fix_input_si(struct isl_basic_map *bmap,
6261 unsigned input, int value)
6263 return isl_basic_map_fix_si(bmap, isl_dim_in, input, value);
6266 struct isl_basic_set *isl_basic_set_fix_dim_si(struct isl_basic_set *bset,
6267 unsigned dim, int value)
6269 return bset_from_bmap(isl_basic_map_fix_si(bset_to_bmap(bset),
6270 isl_dim_set, dim, value));
6273 /* Remove the basic map at position "i" from "map" if this basic map
6274 * is (obviously) empty.
6276 static __isl_give isl_map *remove_if_empty(__isl_take isl_map *map, int i)
6278 isl_bool empty;
6280 if (!map)
6281 return NULL;
6283 empty = isl_basic_map_plain_is_empty(map->p[i]);
6284 if (empty < 0)
6285 return isl_map_free(map);
6286 if (!empty)
6287 return map;
6289 isl_basic_map_free(map->p[i]);
6290 map->n--;
6291 if (i != map->n) {
6292 map->p[i] = map->p[map->n];
6293 map = isl_map_unmark_normalized(map);
6297 return map;
6300 /* Perform "fn" on each basic map of "map", where we may not be holding
6301 * the only reference to "map".
6302 * In particular, "fn" should be a semantics preserving operation
6303 * that we want to apply to all copies of "map". We therefore need
6304 * to be careful not to modify "map" in a way that breaks "map"
6305 * in case anything goes wrong.
6307 __isl_give isl_map *isl_map_inline_foreach_basic_map(__isl_take isl_map *map,
6308 __isl_give isl_basic_map *(*fn)(__isl_take isl_basic_map *bmap))
6310 struct isl_basic_map *bmap;
6311 int i;
6313 if (!map)
6314 return NULL;
6316 for (i = map->n - 1; i >= 0; --i) {
6317 bmap = isl_basic_map_copy(map->p[i]);
6318 bmap = fn(bmap);
6319 if (!bmap)
6320 goto error;
6321 isl_basic_map_free(map->p[i]);
6322 map->p[i] = bmap;
6323 map = remove_if_empty(map, i);
6324 if (!map)
6325 return NULL;
6328 return map;
6329 error:
6330 isl_map_free(map);
6331 return NULL;
6334 __isl_give isl_map *isl_map_fix_si(__isl_take isl_map *map,
6335 enum isl_dim_type type, unsigned pos, int value)
6337 int i;
6339 map = isl_map_cow(map);
6340 if (!map)
6341 return NULL;
6343 isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error);
6344 for (i = map->n - 1; i >= 0; --i) {
6345 map->p[i] = isl_basic_map_fix_si(map->p[i], type, pos, value);
6346 map = remove_if_empty(map, i);
6347 if (!map)
6348 return NULL;
6350 map = isl_map_unmark_normalized(map);
6351 return map;
6352 error:
6353 isl_map_free(map);
6354 return NULL;
6357 __isl_give isl_set *isl_set_fix_si(__isl_take isl_set *set,
6358 enum isl_dim_type type, unsigned pos, int value)
6360 return set_from_map(isl_map_fix_si(set_to_map(set), type, pos, value));
6363 __isl_give isl_map *isl_map_fix(__isl_take isl_map *map,
6364 enum isl_dim_type type, unsigned pos, isl_int value)
6366 int i;
6368 map = isl_map_cow(map);
6369 if (!map)
6370 return NULL;
6372 isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error);
6373 for (i = 0; i < map->n; ++i) {
6374 map->p[i] = isl_basic_map_fix(map->p[i], type, pos, value);
6375 if (!map->p[i])
6376 goto error;
6378 map = isl_map_unmark_normalized(map);
6379 return map;
6380 error:
6381 isl_map_free(map);
6382 return NULL;
6385 __isl_give isl_set *isl_set_fix(__isl_take isl_set *set,
6386 enum isl_dim_type type, unsigned pos, isl_int value)
6388 return set_from_map(isl_map_fix(set_to_map(set), type, pos, value));
6391 /* Fix the value of the variable at position "pos" of type "type" of "map"
6392 * to be equal to "v".
6394 __isl_give isl_map *isl_map_fix_val(__isl_take isl_map *map,
6395 enum isl_dim_type type, unsigned pos, __isl_take isl_val *v)
6397 int i;
6399 map = isl_map_cow(map);
6400 if (!map || !v)
6401 goto error;
6403 if (!isl_val_is_int(v))
6404 isl_die(isl_map_get_ctx(map), isl_error_invalid,
6405 "expecting integer value", goto error);
6406 if (pos >= isl_map_dim(map, type))
6407 isl_die(isl_map_get_ctx(map), isl_error_invalid,
6408 "index out of bounds", goto error);
6409 for (i = map->n - 1; i >= 0; --i) {
6410 map->p[i] = isl_basic_map_fix_val(map->p[i], type, pos,
6411 isl_val_copy(v));
6412 map = remove_if_empty(map, i);
6413 if (!map)
6414 goto error;
6416 map = isl_map_unmark_normalized(map);
6417 isl_val_free(v);
6418 return map;
6419 error:
6420 isl_map_free(map);
6421 isl_val_free(v);
6422 return NULL;
6425 /* Fix the value of the variable at position "pos" of type "type" of "set"
6426 * to be equal to "v".
6428 __isl_give isl_set *isl_set_fix_val(__isl_take isl_set *set,
6429 enum isl_dim_type type, unsigned pos, __isl_take isl_val *v)
6431 return isl_map_fix_val(set, type, pos, v);
6434 struct isl_map *isl_map_fix_input_si(struct isl_map *map,
6435 unsigned input, int value)
6437 return isl_map_fix_si(map, isl_dim_in, input, value);
6440 struct isl_set *isl_set_fix_dim_si(struct isl_set *set, unsigned dim, int value)
6442 return set_from_map(isl_map_fix_si(set_to_map(set),
6443 isl_dim_set, dim, value));
6446 static __isl_give isl_basic_map *basic_map_bound_si(
6447 __isl_take isl_basic_map *bmap,
6448 enum isl_dim_type type, unsigned pos, int value, int upper)
6450 int j;
6452 if (isl_basic_map_check_range(bmap, type, pos, 1) < 0)
6453 return isl_basic_map_free(bmap);
6454 pos += isl_basic_map_offset(bmap, type);
6455 bmap = isl_basic_map_cow(bmap);
6456 bmap = isl_basic_map_extend_constraints(bmap, 0, 1);
6457 j = isl_basic_map_alloc_inequality(bmap);
6458 if (j < 0)
6459 goto error;
6460 isl_seq_clr(bmap->ineq[j], 1 + isl_basic_map_total_dim(bmap));
6461 if (upper) {
6462 isl_int_set_si(bmap->ineq[j][pos], -1);
6463 isl_int_set_si(bmap->ineq[j][0], value);
6464 } else {
6465 isl_int_set_si(bmap->ineq[j][pos], 1);
6466 isl_int_set_si(bmap->ineq[j][0], -value);
6468 bmap = isl_basic_map_simplify(bmap);
6469 return isl_basic_map_finalize(bmap);
6470 error:
6471 isl_basic_map_free(bmap);
6472 return NULL;
6475 __isl_give isl_basic_map *isl_basic_map_lower_bound_si(
6476 __isl_take isl_basic_map *bmap,
6477 enum isl_dim_type type, unsigned pos, int value)
6479 return basic_map_bound_si(bmap, type, pos, value, 0);
6482 /* Constrain the values of the given dimension to be no greater than "value".
6484 __isl_give isl_basic_map *isl_basic_map_upper_bound_si(
6485 __isl_take isl_basic_map *bmap,
6486 enum isl_dim_type type, unsigned pos, int value)
6488 return basic_map_bound_si(bmap, type, pos, value, 1);
6491 static __isl_give isl_map *map_bound_si(__isl_take isl_map *map,
6492 enum isl_dim_type type, unsigned pos, int value, int upper)
6494 int i;
6496 map = isl_map_cow(map);
6497 if (!map)
6498 return NULL;
6500 isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error);
6501 for (i = 0; i < map->n; ++i) {
6502 map->p[i] = basic_map_bound_si(map->p[i],
6503 type, pos, value, upper);
6504 if (!map->p[i])
6505 goto error;
6507 map = isl_map_unmark_normalized(map);
6508 return map;
6509 error:
6510 isl_map_free(map);
6511 return NULL;
6514 __isl_give isl_map *isl_map_lower_bound_si(__isl_take isl_map *map,
6515 enum isl_dim_type type, unsigned pos, int value)
6517 return map_bound_si(map, type, pos, value, 0);
6520 __isl_give isl_map *isl_map_upper_bound_si(__isl_take isl_map *map,
6521 enum isl_dim_type type, unsigned pos, int value)
6523 return map_bound_si(map, type, pos, value, 1);
6526 __isl_give isl_set *isl_set_lower_bound_si(__isl_take isl_set *set,
6527 enum isl_dim_type type, unsigned pos, int value)
6529 return set_from_map(isl_map_lower_bound_si(set_to_map(set),
6530 type, pos, value));
6533 __isl_give isl_set *isl_set_upper_bound_si(__isl_take isl_set *set,
6534 enum isl_dim_type type, unsigned pos, int value)
6536 return isl_map_upper_bound_si(set, type, pos, value);
6539 /* Bound the given variable of "bmap" from below (or above is "upper"
6540 * is set) to "value".
6542 static __isl_give isl_basic_map *basic_map_bound(
6543 __isl_take isl_basic_map *bmap,
6544 enum isl_dim_type type, unsigned pos, isl_int value, int upper)
6546 int j;
6548 if (isl_basic_map_check_range(bmap, type, pos, 1) < 0)
6549 return isl_basic_map_free(bmap);
6550 pos += isl_basic_map_offset(bmap, type);
6551 bmap = isl_basic_map_cow(bmap);
6552 bmap = isl_basic_map_extend_constraints(bmap, 0, 1);
6553 j = isl_basic_map_alloc_inequality(bmap);
6554 if (j < 0)
6555 goto error;
6556 isl_seq_clr(bmap->ineq[j], 1 + isl_basic_map_total_dim(bmap));
6557 if (upper) {
6558 isl_int_set_si(bmap->ineq[j][pos], -1);
6559 isl_int_set(bmap->ineq[j][0], value);
6560 } else {
6561 isl_int_set_si(bmap->ineq[j][pos], 1);
6562 isl_int_neg(bmap->ineq[j][0], value);
6564 bmap = isl_basic_map_simplify(bmap);
6565 return isl_basic_map_finalize(bmap);
6566 error:
6567 isl_basic_map_free(bmap);
6568 return NULL;
6571 /* Bound the given variable of "map" from below (or above is "upper"
6572 * is set) to "value".
6574 static __isl_give isl_map *map_bound(__isl_take isl_map *map,
6575 enum isl_dim_type type, unsigned pos, isl_int value, int upper)
6577 int i;
6579 map = isl_map_cow(map);
6580 if (!map)
6581 return NULL;
6583 if (pos >= isl_map_dim(map, type))
6584 isl_die(map->ctx, isl_error_invalid,
6585 "index out of bounds", goto error);
6586 for (i = map->n - 1; i >= 0; --i) {
6587 map->p[i] = basic_map_bound(map->p[i], type, pos, value, upper);
6588 map = remove_if_empty(map, i);
6589 if (!map)
6590 return NULL;
6592 map = isl_map_unmark_normalized(map);
6593 return map;
6594 error:
6595 isl_map_free(map);
6596 return NULL;
6599 __isl_give isl_map *isl_map_lower_bound(__isl_take isl_map *map,
6600 enum isl_dim_type type, unsigned pos, isl_int value)
6602 return map_bound(map, type, pos, value, 0);
6605 __isl_give isl_map *isl_map_upper_bound(__isl_take isl_map *map,
6606 enum isl_dim_type type, unsigned pos, isl_int value)
6608 return map_bound(map, type, pos, value, 1);
6611 __isl_give isl_set *isl_set_lower_bound(__isl_take isl_set *set,
6612 enum isl_dim_type type, unsigned pos, isl_int value)
6614 return isl_map_lower_bound(set, type, pos, value);
6617 __isl_give isl_set *isl_set_upper_bound(__isl_take isl_set *set,
6618 enum isl_dim_type type, unsigned pos, isl_int value)
6620 return isl_map_upper_bound(set, type, pos, value);
6623 /* Force the values of the variable at position "pos" of type "type" of "set"
6624 * to be no smaller than "value".
6626 __isl_give isl_set *isl_set_lower_bound_val(__isl_take isl_set *set,
6627 enum isl_dim_type type, unsigned pos, __isl_take isl_val *value)
6629 if (!value)
6630 goto error;
6631 if (!isl_val_is_int(value))
6632 isl_die(isl_set_get_ctx(set), isl_error_invalid,
6633 "expecting integer value", goto error);
6634 set = isl_set_lower_bound(set, type, pos, value->n);
6635 isl_val_free(value);
6636 return set;
6637 error:
6638 isl_val_free(value);
6639 isl_set_free(set);
6640 return NULL;
6643 /* Force the values of the variable at position "pos" of type "type" of "set"
6644 * to be no greater than "value".
6646 __isl_give isl_set *isl_set_upper_bound_val(__isl_take isl_set *set,
6647 enum isl_dim_type type, unsigned pos, __isl_take isl_val *value)
6649 if (!value)
6650 goto error;
6651 if (!isl_val_is_int(value))
6652 isl_die(isl_set_get_ctx(set), isl_error_invalid,
6653 "expecting integer value", goto error);
6654 set = isl_set_upper_bound(set, type, pos, value->n);
6655 isl_val_free(value);
6656 return set;
6657 error:
6658 isl_val_free(value);
6659 isl_set_free(set);
6660 return NULL;
6663 /* Bound the given variable of "bset" from below (or above is "upper"
6664 * is set) to "value".
6666 static __isl_give isl_basic_set *isl_basic_set_bound(
6667 __isl_take isl_basic_set *bset, enum isl_dim_type type, unsigned pos,
6668 isl_int value, int upper)
6670 return bset_from_bmap(basic_map_bound(bset_to_bmap(bset),
6671 type, pos, value, upper));
6674 /* Bound the given variable of "bset" from below (or above is "upper"
6675 * is set) to "value".
6677 static __isl_give isl_basic_set *isl_basic_set_bound_val(
6678 __isl_take isl_basic_set *bset, enum isl_dim_type type, unsigned pos,
6679 __isl_take isl_val *value, int upper)
6681 if (!value)
6682 goto error;
6683 if (!isl_val_is_int(value))
6684 isl_die(isl_basic_set_get_ctx(bset), isl_error_invalid,
6685 "expecting integer value", goto error);
6686 bset = isl_basic_set_bound(bset, type, pos, value->n, upper);
6687 isl_val_free(value);
6688 return bset;
6689 error:
6690 isl_val_free(value);
6691 isl_basic_set_free(bset);
6692 return NULL;
6695 /* Bound the given variable of "bset" from below to "value".
6697 __isl_give isl_basic_set *isl_basic_set_lower_bound_val(
6698 __isl_take isl_basic_set *bset, enum isl_dim_type type, unsigned pos,
6699 __isl_take isl_val *value)
6701 return isl_basic_set_bound_val(bset, type, pos, value, 0);
6704 /* Bound the given variable of "bset" from above to "value".
6706 __isl_give isl_basic_set *isl_basic_set_upper_bound_val(
6707 __isl_take isl_basic_set *bset, enum isl_dim_type type, unsigned pos,
6708 __isl_take isl_val *value)
6710 return isl_basic_set_bound_val(bset, type, pos, value, 1);
6713 __isl_give isl_map *isl_map_reverse(__isl_take isl_map *map)
6715 int i;
6717 map = isl_map_cow(map);
6718 if (!map)
6719 return NULL;
6721 map->dim = isl_space_reverse(map->dim);
6722 if (!map->dim)
6723 goto error;
6724 for (i = 0; i < map->n; ++i) {
6725 map->p[i] = isl_basic_map_reverse(map->p[i]);
6726 if (!map->p[i])
6727 goto error;
6729 map = isl_map_unmark_normalized(map);
6730 return map;
6731 error:
6732 isl_map_free(map);
6733 return NULL;
6736 #undef TYPE
6737 #define TYPE isl_pw_multi_aff
6738 #undef SUFFIX
6739 #define SUFFIX _pw_multi_aff
6740 #undef EMPTY
6741 #define EMPTY isl_pw_multi_aff_empty
6742 #undef ADD
6743 #define ADD isl_pw_multi_aff_union_add
6744 #include "isl_map_lexopt_templ.c"
6746 /* Given a map "map", compute the lexicographically minimal
6747 * (or maximal) image element for each domain element in dom,
6748 * in the form of an isl_pw_multi_aff.
6749 * If "empty" is not NULL, then set *empty to those elements in dom that
6750 * do not have an image element.
6751 * If "flags" includes ISL_OPT_FULL, then "dom" is NULL and the optimum
6752 * should be computed over the domain of "map". "empty" is also NULL
6753 * in this case.
6755 * We first compute the lexicographically minimal or maximal element
6756 * in the first basic map. This results in a partial solution "res"
6757 * and a subset "todo" of dom that still need to be handled.
6758 * We then consider each of the remaining maps in "map" and successively
6759 * update both "res" and "todo".
6760 * If "empty" is NULL, then the todo sets are not needed and therefore
6761 * also not computed.
6763 static __isl_give isl_pw_multi_aff *isl_map_partial_lexopt_aligned_pw_multi_aff(
6764 __isl_take isl_map *map, __isl_take isl_set *dom,
6765 __isl_give isl_set **empty, unsigned flags)
6767 int i;
6768 int full;
6769 isl_pw_multi_aff *res;
6770 isl_set *todo;
6772 full = ISL_FL_ISSET(flags, ISL_OPT_FULL);
6773 if (!map || (!full && !dom))
6774 goto error;
6776 if (isl_map_plain_is_empty(map)) {
6777 if (empty)
6778 *empty = dom;
6779 else
6780 isl_set_free(dom);
6781 return isl_pw_multi_aff_from_map(map);
6784 res = basic_map_partial_lexopt_pw_multi_aff(
6785 isl_basic_map_copy(map->p[0]),
6786 isl_set_copy(dom), empty, flags);
6788 if (empty)
6789 todo = *empty;
6790 for (i = 1; i < map->n; ++i) {
6791 isl_pw_multi_aff *res_i;
6793 res_i = basic_map_partial_lexopt_pw_multi_aff(
6794 isl_basic_map_copy(map->p[i]),
6795 isl_set_copy(dom), empty, flags);
6797 if (ISL_FL_ISSET(flags, ISL_OPT_MAX))
6798 res = isl_pw_multi_aff_union_lexmax(res, res_i);
6799 else
6800 res = isl_pw_multi_aff_union_lexmin(res, res_i);
6802 if (empty)
6803 todo = isl_set_intersect(todo, *empty);
6806 isl_set_free(dom);
6807 isl_map_free(map);
6809 if (empty)
6810 *empty = todo;
6812 return res;
6813 error:
6814 if (empty)
6815 *empty = NULL;
6816 isl_set_free(dom);
6817 isl_map_free(map);
6818 return NULL;
6821 #undef TYPE
6822 #define TYPE isl_map
6823 #undef SUFFIX
6824 #define SUFFIX
6825 #undef EMPTY
6826 #define EMPTY isl_map_empty
6827 #undef ADD
6828 #define ADD isl_map_union_disjoint
6829 #include "isl_map_lexopt_templ.c"
6831 /* Given a map "map", compute the lexicographically minimal
6832 * (or maximal) image element for each domain element in "dom",
6833 * in the form of an isl_map.
6834 * If "empty" is not NULL, then set *empty to those elements in "dom" that
6835 * do not have an image element.
6836 * If "flags" includes ISL_OPT_FULL, then "dom" is NULL and the optimum
6837 * should be computed over the domain of "map". "empty" is also NULL
6838 * in this case.
6840 * If the input consists of more than one disjunct, then first
6841 * compute the desired result in the form of an isl_pw_multi_aff and
6842 * then convert that into an isl_map.
6844 * This function used to have an explicit implementation in terms
6845 * of isl_maps, but it would continually intersect the domains of
6846 * partial results with the complement of the domain of the next
6847 * partial solution, potentially leading to an explosion in the number
6848 * of disjuncts if there are several disjuncts in the input.
6849 * An even earlier implementation of this function would look for
6850 * better results in the domain of the partial result and for extra
6851 * results in the complement of this domain, which would lead to
6852 * even more splintering.
6854 static __isl_give isl_map *isl_map_partial_lexopt_aligned(
6855 __isl_take isl_map *map, __isl_take isl_set *dom,
6856 __isl_give isl_set **empty, unsigned flags)
6858 int full;
6859 struct isl_map *res;
6860 isl_pw_multi_aff *pma;
6862 full = ISL_FL_ISSET(flags, ISL_OPT_FULL);
6863 if (!map || (!full && !dom))
6864 goto error;
6866 if (isl_map_plain_is_empty(map)) {
6867 if (empty)
6868 *empty = dom;
6869 else
6870 isl_set_free(dom);
6871 return map;
6874 if (map->n == 1) {
6875 res = basic_map_partial_lexopt(isl_basic_map_copy(map->p[0]),
6876 dom, empty, flags);
6877 isl_map_free(map);
6878 return res;
6881 pma = isl_map_partial_lexopt_aligned_pw_multi_aff(map, dom, empty,
6882 flags);
6883 return isl_map_from_pw_multi_aff(pma);
6884 error:
6885 if (empty)
6886 *empty = NULL;
6887 isl_set_free(dom);
6888 isl_map_free(map);
6889 return NULL;
6892 __isl_give isl_map *isl_map_partial_lexmax(
6893 __isl_take isl_map *map, __isl_take isl_set *dom,
6894 __isl_give isl_set **empty)
6896 return isl_map_partial_lexopt(map, dom, empty, ISL_OPT_MAX);
6899 __isl_give isl_map *isl_map_partial_lexmin(
6900 __isl_take isl_map *map, __isl_take isl_set *dom,
6901 __isl_give isl_set **empty)
6903 return isl_map_partial_lexopt(map, dom, empty, 0);
6906 __isl_give isl_set *isl_set_partial_lexmin(
6907 __isl_take isl_set *set, __isl_take isl_set *dom,
6908 __isl_give isl_set **empty)
6910 return set_from_map(isl_map_partial_lexmin(set_to_map(set),
6911 dom, empty));
6914 __isl_give isl_set *isl_set_partial_lexmax(
6915 __isl_take isl_set *set, __isl_take isl_set *dom,
6916 __isl_give isl_set **empty)
6918 return set_from_map(isl_map_partial_lexmax(set_to_map(set),
6919 dom, empty));
6922 /* Compute the lexicographic minimum (or maximum if "flags" includes
6923 * ISL_OPT_MAX) of "bset" over its parametric domain.
6925 __isl_give isl_set *isl_basic_set_lexopt(__isl_take isl_basic_set *bset,
6926 unsigned flags)
6928 return isl_basic_map_lexopt(bset, flags);
6931 __isl_give isl_map *isl_basic_map_lexmax(__isl_take isl_basic_map *bmap)
6933 return isl_basic_map_lexopt(bmap, ISL_OPT_MAX);
6936 __isl_give isl_set *isl_basic_set_lexmin(__isl_take isl_basic_set *bset)
6938 return set_from_map(isl_basic_map_lexmin(bset_to_bmap(bset)));
6941 __isl_give isl_set *isl_basic_set_lexmax(__isl_take isl_basic_set *bset)
6943 return set_from_map(isl_basic_map_lexmax(bset_to_bmap(bset)));
6946 /* Compute the lexicographic minimum of "bset" over its parametric domain
6947 * for the purpose of quantifier elimination.
6948 * That is, find an explicit representation for all the existentially
6949 * quantified variables in "bset" by computing their lexicographic
6950 * minimum.
6952 static __isl_give isl_set *isl_basic_set_lexmin_compute_divs(
6953 __isl_take isl_basic_set *bset)
6955 return isl_basic_set_lexopt(bset, ISL_OPT_QE);
6958 /* Given a basic map with one output dimension, compute the minimum or
6959 * maximum of that dimension as an isl_pw_aff.
6961 * Compute the optimum as a lexicographic optimum over the single
6962 * output dimension and extract the single isl_pw_aff from the result.
6964 static __isl_give isl_pw_aff *basic_map_dim_opt(__isl_keep isl_basic_map *bmap,
6965 int max)
6967 isl_pw_multi_aff *pma;
6968 isl_pw_aff *pwaff;
6970 bmap = isl_basic_map_copy(bmap);
6971 pma = isl_basic_map_lexopt_pw_multi_aff(bmap, max ? ISL_OPT_MAX : 0);
6972 pwaff = isl_pw_multi_aff_get_pw_aff(pma, 0);
6973 isl_pw_multi_aff_free(pma);
6975 return pwaff;
6978 /* Compute the minimum or maximum of the given output dimension
6979 * as a function of the parameters and the input dimensions,
6980 * but independently of the other output dimensions.
6982 * We first project out the other output dimension and then compute
6983 * the "lexicographic" maximum in each basic map, combining the results
6984 * using isl_pw_aff_union_max.
6986 static __isl_give isl_pw_aff *map_dim_opt(__isl_take isl_map *map, int pos,
6987 int max)
6989 int i;
6990 isl_pw_aff *pwaff;
6991 unsigned n_out;
6993 n_out = isl_map_dim(map, isl_dim_out);
6994 map = isl_map_project_out(map, isl_dim_out, pos + 1, n_out - (pos + 1));
6995 map = isl_map_project_out(map, isl_dim_out, 0, pos);
6996 if (!map)
6997 return NULL;
6999 if (map->n == 0) {
7000 isl_space *dim = isl_map_get_space(map);
7001 isl_map_free(map);
7002 return isl_pw_aff_empty(dim);
7005 pwaff = basic_map_dim_opt(map->p[0], max);
7006 for (i = 1; i < map->n; ++i) {
7007 isl_pw_aff *pwaff_i;
7009 pwaff_i = basic_map_dim_opt(map->p[i], max);
7010 pwaff = isl_pw_aff_union_opt(pwaff, pwaff_i, max);
7013 isl_map_free(map);
7015 return pwaff;
7018 /* Compute the minimum of the given output dimension as a function of the
7019 * parameters and input dimensions, but independently of
7020 * the other output dimensions.
7022 __isl_give isl_pw_aff *isl_map_dim_min(__isl_take isl_map *map, int pos)
7024 return map_dim_opt(map, pos, 0);
7027 /* Compute the maximum of the given output dimension as a function of the
7028 * parameters and input dimensions, but independently of
7029 * the other output dimensions.
7031 __isl_give isl_pw_aff *isl_map_dim_max(__isl_take isl_map *map, int pos)
7033 return map_dim_opt(map, pos, 1);
7036 /* Compute the minimum or maximum of the given set dimension
7037 * as a function of the parameters,
7038 * but independently of the other set dimensions.
7040 static __isl_give isl_pw_aff *set_dim_opt(__isl_take isl_set *set, int pos,
7041 int max)
7043 return map_dim_opt(set, pos, max);
7046 /* Compute the maximum of the given set dimension as a function of the
7047 * parameters, but independently of the other set dimensions.
7049 __isl_give isl_pw_aff *isl_set_dim_max(__isl_take isl_set *set, int pos)
7051 return set_dim_opt(set, pos, 1);
7054 /* Compute the minimum of the given set dimension as a function of the
7055 * parameters, but independently of the other set dimensions.
7057 __isl_give isl_pw_aff *isl_set_dim_min(__isl_take isl_set *set, int pos)
7059 return set_dim_opt(set, pos, 0);
7062 /* Apply a preimage specified by "mat" on the parameters of "bset".
7063 * bset is assumed to have only parameters and divs.
7065 static __isl_give isl_basic_set *basic_set_parameter_preimage(
7066 __isl_take isl_basic_set *bset, __isl_take isl_mat *mat)
7068 unsigned nparam;
7070 if (!bset || !mat)
7071 goto error;
7073 bset->dim = isl_space_cow(bset->dim);
7074 if (!bset->dim)
7075 goto error;
7077 nparam = isl_basic_set_dim(bset, isl_dim_param);
7079 isl_assert(bset->ctx, mat->n_row == 1 + nparam, goto error);
7081 bset->dim->nparam = 0;
7082 bset->dim->n_out = nparam;
7083 bset = isl_basic_set_preimage(bset, mat);
7084 if (bset) {
7085 bset->dim->nparam = bset->dim->n_out;
7086 bset->dim->n_out = 0;
7088 return bset;
7089 error:
7090 isl_mat_free(mat);
7091 isl_basic_set_free(bset);
7092 return NULL;
7095 /* Apply a preimage specified by "mat" on the parameters of "set".
7096 * set is assumed to have only parameters and divs.
7098 static __isl_give isl_set *set_parameter_preimage(__isl_take isl_set *set,
7099 __isl_take isl_mat *mat)
7101 isl_space *space;
7102 unsigned nparam;
7104 if (!set || !mat)
7105 goto error;
7107 nparam = isl_set_dim(set, isl_dim_param);
7109 if (mat->n_row != 1 + nparam)
7110 isl_die(isl_set_get_ctx(set), isl_error_internal,
7111 "unexpected number of rows", goto error);
7113 space = isl_set_get_space(set);
7114 space = isl_space_move_dims(space, isl_dim_set, 0,
7115 isl_dim_param, 0, nparam);
7116 set = isl_set_reset_space(set, space);
7117 set = isl_set_preimage(set, mat);
7118 nparam = isl_set_dim(set, isl_dim_out);
7119 space = isl_set_get_space(set);
7120 space = isl_space_move_dims(space, isl_dim_param, 0,
7121 isl_dim_out, 0, nparam);
7122 set = isl_set_reset_space(set, space);
7123 return set;
7124 error:
7125 isl_mat_free(mat);
7126 isl_set_free(set);
7127 return NULL;
7130 /* Intersect the basic set "bset" with the affine space specified by the
7131 * equalities in "eq".
7133 static __isl_give isl_basic_set *basic_set_append_equalities(
7134 __isl_take isl_basic_set *bset, __isl_take isl_mat *eq)
7136 int i, k;
7137 unsigned len;
7139 if (!bset || !eq)
7140 goto error;
7142 bset = isl_basic_set_extend_space(bset, isl_space_copy(bset->dim), 0,
7143 eq->n_row, 0);
7144 if (!bset)
7145 goto error;
7147 len = 1 + isl_space_dim(bset->dim, isl_dim_all) + bset->extra;
7148 for (i = 0; i < eq->n_row; ++i) {
7149 k = isl_basic_set_alloc_equality(bset);
7150 if (k < 0)
7151 goto error;
7152 isl_seq_cpy(bset->eq[k], eq->row[i], eq->n_col);
7153 isl_seq_clr(bset->eq[k] + eq->n_col, len - eq->n_col);
7155 isl_mat_free(eq);
7157 bset = isl_basic_set_gauss(bset, NULL);
7158 bset = isl_basic_set_finalize(bset);
7160 return bset;
7161 error:
7162 isl_mat_free(eq);
7163 isl_basic_set_free(bset);
7164 return NULL;
7167 /* Intersect the set "set" with the affine space specified by the
7168 * equalities in "eq".
7170 static struct isl_set *set_append_equalities(struct isl_set *set,
7171 struct isl_mat *eq)
7173 int i;
7175 if (!set || !eq)
7176 goto error;
7178 for (i = 0; i < set->n; ++i) {
7179 set->p[i] = basic_set_append_equalities(set->p[i],
7180 isl_mat_copy(eq));
7181 if (!set->p[i])
7182 goto error;
7184 isl_mat_free(eq);
7185 return set;
7186 error:
7187 isl_mat_free(eq);
7188 isl_set_free(set);
7189 return NULL;
7192 /* Given a basic set "bset" that only involves parameters and existentially
7193 * quantified variables, return the index of the first equality
7194 * that only involves parameters. If there is no such equality then
7195 * return bset->n_eq.
7197 * This function assumes that isl_basic_set_gauss has been called on "bset".
7199 static int first_parameter_equality(__isl_keep isl_basic_set *bset)
7201 int i, j;
7202 unsigned nparam, n_div;
7204 if (!bset)
7205 return -1;
7207 nparam = isl_basic_set_dim(bset, isl_dim_param);
7208 n_div = isl_basic_set_dim(bset, isl_dim_div);
7210 for (i = 0, j = n_div - 1; i < bset->n_eq && j >= 0; --j) {
7211 if (!isl_int_is_zero(bset->eq[i][1 + nparam + j]))
7212 ++i;
7215 return i;
7218 /* Compute an explicit representation for the existentially quantified
7219 * variables in "bset" by computing the "minimal value" of the set
7220 * variables. Since there are no set variables, the computation of
7221 * the minimal value essentially computes an explicit representation
7222 * of the non-empty part(s) of "bset".
7224 * The input only involves parameters and existentially quantified variables.
7225 * All equalities among parameters have been removed.
7227 * Since the existentially quantified variables in the result are in general
7228 * going to be different from those in the input, we first replace
7229 * them by the minimal number of variables based on their equalities.
7230 * This should simplify the parametric integer programming.
7232 static __isl_give isl_set *base_compute_divs(__isl_take isl_basic_set *bset)
7234 isl_morph *morph1, *morph2;
7235 isl_set *set;
7236 unsigned n;
7238 if (!bset)
7239 return NULL;
7240 if (bset->n_eq == 0)
7241 return isl_basic_set_lexmin_compute_divs(bset);
7243 morph1 = isl_basic_set_parameter_compression(bset);
7244 bset = isl_morph_basic_set(isl_morph_copy(morph1), bset);
7245 bset = isl_basic_set_lift(bset);
7246 morph2 = isl_basic_set_variable_compression(bset, isl_dim_set);
7247 bset = isl_morph_basic_set(morph2, bset);
7248 n = isl_basic_set_dim(bset, isl_dim_set);
7249 bset = isl_basic_set_project_out(bset, isl_dim_set, 0, n);
7251 set = isl_basic_set_lexmin_compute_divs(bset);
7253 set = isl_morph_set(isl_morph_inverse(morph1), set);
7255 return set;
7258 /* Project the given basic set onto its parameter domain, possibly introducing
7259 * new, explicit, existential variables in the constraints.
7260 * The input has parameters and (possibly implicit) existential variables.
7261 * The output has the same parameters, but only
7262 * explicit existentially quantified variables.
7264 * The actual projection is performed by pip, but pip doesn't seem
7265 * to like equalities very much, so we first remove the equalities
7266 * among the parameters by performing a variable compression on
7267 * the parameters. Afterward, an inverse transformation is performed
7268 * and the equalities among the parameters are inserted back in.
7270 * The variable compression on the parameters may uncover additional
7271 * equalities that were only implicit before. We therefore check
7272 * if there are any new parameter equalities in the result and
7273 * if so recurse. The removal of parameter equalities is required
7274 * for the parameter compression performed by base_compute_divs.
7276 static struct isl_set *parameter_compute_divs(struct isl_basic_set *bset)
7278 int i;
7279 struct isl_mat *eq;
7280 struct isl_mat *T, *T2;
7281 struct isl_set *set;
7282 unsigned nparam;
7284 bset = isl_basic_set_cow(bset);
7285 if (!bset)
7286 return NULL;
7288 if (bset->n_eq == 0)
7289 return base_compute_divs(bset);
7291 bset = isl_basic_set_gauss(bset, NULL);
7292 if (!bset)
7293 return NULL;
7294 if (isl_basic_set_plain_is_empty(bset))
7295 return isl_set_from_basic_set(bset);
7297 i = first_parameter_equality(bset);
7298 if (i == bset->n_eq)
7299 return base_compute_divs(bset);
7301 nparam = isl_basic_set_dim(bset, isl_dim_param);
7302 eq = isl_mat_sub_alloc6(bset->ctx, bset->eq, i, bset->n_eq - i,
7303 0, 1 + nparam);
7304 eq = isl_mat_cow(eq);
7305 T = isl_mat_variable_compression(isl_mat_copy(eq), &T2);
7306 if (T && T->n_col == 0) {
7307 isl_mat_free(T);
7308 isl_mat_free(T2);
7309 isl_mat_free(eq);
7310 bset = isl_basic_set_set_to_empty(bset);
7311 return isl_set_from_basic_set(bset);
7313 bset = basic_set_parameter_preimage(bset, T);
7315 i = first_parameter_equality(bset);
7316 if (!bset)
7317 set = NULL;
7318 else if (i == bset->n_eq)
7319 set = base_compute_divs(bset);
7320 else
7321 set = parameter_compute_divs(bset);
7322 set = set_parameter_preimage(set, T2);
7323 set = set_append_equalities(set, eq);
7324 return set;
7327 /* Insert the divs from "ls" before those of "bmap".
7329 * The number of columns is not changed, which means that the last
7330 * dimensions of "bmap" are being reintepreted as the divs from "ls".
7331 * The caller is responsible for removing the same number of dimensions
7332 * from the space of "bmap".
7334 static __isl_give isl_basic_map *insert_divs_from_local_space(
7335 __isl_take isl_basic_map *bmap, __isl_keep isl_local_space *ls)
7337 int i;
7338 int n_div;
7339 int old_n_div;
7341 n_div = isl_local_space_dim(ls, isl_dim_div);
7342 if (n_div == 0)
7343 return bmap;
7345 old_n_div = bmap->n_div;
7346 bmap = insert_div_rows(bmap, n_div);
7347 if (!bmap)
7348 return NULL;
7350 for (i = 0; i < n_div; ++i) {
7351 isl_seq_cpy(bmap->div[i], ls->div->row[i], ls->div->n_col);
7352 isl_seq_clr(bmap->div[i] + ls->div->n_col, old_n_div);
7355 return bmap;
7358 /* Replace the space of "bmap" by the space and divs of "ls".
7360 * If "ls" has any divs, then we simplify the result since we may
7361 * have discovered some additional equalities that could simplify
7362 * the div expressions.
7364 static __isl_give isl_basic_map *basic_replace_space_by_local_space(
7365 __isl_take isl_basic_map *bmap, __isl_take isl_local_space *ls)
7367 int n_div;
7369 bmap = isl_basic_map_cow(bmap);
7370 if (!bmap || !ls)
7371 goto error;
7373 n_div = isl_local_space_dim(ls, isl_dim_div);
7374 bmap = insert_divs_from_local_space(bmap, ls);
7375 if (!bmap)
7376 goto error;
7378 isl_space_free(bmap->dim);
7379 bmap->dim = isl_local_space_get_space(ls);
7380 if (!bmap->dim)
7381 goto error;
7383 isl_local_space_free(ls);
7384 if (n_div > 0)
7385 bmap = isl_basic_map_simplify(bmap);
7386 bmap = isl_basic_map_finalize(bmap);
7387 return bmap;
7388 error:
7389 isl_basic_map_free(bmap);
7390 isl_local_space_free(ls);
7391 return NULL;
7394 /* Replace the space of "map" by the space and divs of "ls".
7396 static __isl_give isl_map *replace_space_by_local_space(__isl_take isl_map *map,
7397 __isl_take isl_local_space *ls)
7399 int i;
7401 map = isl_map_cow(map);
7402 if (!map || !ls)
7403 goto error;
7405 for (i = 0; i < map->n; ++i) {
7406 map->p[i] = basic_replace_space_by_local_space(map->p[i],
7407 isl_local_space_copy(ls));
7408 if (!map->p[i])
7409 goto error;
7411 isl_space_free(map->dim);
7412 map->dim = isl_local_space_get_space(ls);
7413 if (!map->dim)
7414 goto error;
7416 isl_local_space_free(ls);
7417 return map;
7418 error:
7419 isl_local_space_free(ls);
7420 isl_map_free(map);
7421 return NULL;
7424 /* Compute an explicit representation for the existentially
7425 * quantified variables for which do not know any explicit representation yet.
7427 * We first sort the existentially quantified variables so that the
7428 * existentially quantified variables for which we already have an explicit
7429 * representation are placed before those for which we do not.
7430 * The input dimensions, the output dimensions and the existentially
7431 * quantified variables for which we already have an explicit
7432 * representation are then turned into parameters.
7433 * compute_divs returns a map with the same parameters and
7434 * no input or output dimensions and the dimension specification
7435 * is reset to that of the input, including the existentially quantified
7436 * variables for which we already had an explicit representation.
7438 static struct isl_map *compute_divs(struct isl_basic_map *bmap)
7440 struct isl_basic_set *bset;
7441 struct isl_set *set;
7442 struct isl_map *map;
7443 isl_space *dim;
7444 isl_local_space *ls;
7445 unsigned nparam;
7446 unsigned n_in;
7447 unsigned n_out;
7448 int n_known;
7449 int i;
7451 bmap = isl_basic_map_sort_divs(bmap);
7452 bmap = isl_basic_map_cow(bmap);
7453 if (!bmap)
7454 return NULL;
7456 n_known = isl_basic_map_first_unknown_div(bmap);
7457 if (n_known < 0)
7458 return isl_map_from_basic_map(isl_basic_map_free(bmap));
7460 nparam = isl_basic_map_dim(bmap, isl_dim_param);
7461 n_in = isl_basic_map_dim(bmap, isl_dim_in);
7462 n_out = isl_basic_map_dim(bmap, isl_dim_out);
7463 dim = isl_space_set_alloc(bmap->ctx,
7464 nparam + n_in + n_out + n_known, 0);
7465 if (!dim)
7466 goto error;
7468 ls = isl_basic_map_get_local_space(bmap);
7469 ls = isl_local_space_drop_dims(ls, isl_dim_div,
7470 n_known, bmap->n_div - n_known);
7471 if (n_known > 0) {
7472 for (i = n_known; i < bmap->n_div; ++i)
7473 swap_div(bmap, i - n_known, i);
7474 bmap->n_div -= n_known;
7475 bmap->extra -= n_known;
7477 bmap = isl_basic_map_reset_space(bmap, dim);
7478 bset = bset_from_bmap(bmap);
7480 set = parameter_compute_divs(bset);
7481 map = set_to_map(set);
7482 map = replace_space_by_local_space(map, ls);
7484 return map;
7485 error:
7486 isl_basic_map_free(bmap);
7487 return NULL;
7490 /* Remove the explicit representation of local variable "div",
7491 * if there is any.
7493 __isl_give isl_basic_map *isl_basic_map_mark_div_unknown(
7494 __isl_take isl_basic_map *bmap, int div)
7496 isl_bool unknown;
7498 unknown = isl_basic_map_div_is_marked_unknown(bmap, div);
7499 if (unknown < 0)
7500 return isl_basic_map_free(bmap);
7501 if (unknown)
7502 return bmap;
7504 bmap = isl_basic_map_cow(bmap);
7505 if (!bmap)
7506 return NULL;
7507 isl_int_set_si(bmap->div[div][0], 0);
7508 return bmap;
7511 /* Is local variable "div" of "bmap" marked as not having an explicit
7512 * representation?
7513 * Note that even if "div" is not marked in this way and therefore
7514 * has an explicit representation, this representation may still
7515 * depend (indirectly) on other local variables that do not
7516 * have an explicit representation.
7518 isl_bool isl_basic_map_div_is_marked_unknown(__isl_keep isl_basic_map *bmap,
7519 int div)
7521 if (isl_basic_map_check_range(bmap, isl_dim_div, div, 1) < 0)
7522 return isl_bool_error;
7523 return isl_int_is_zero(bmap->div[div][0]);
7526 /* Return the position of the first local variable that does not
7527 * have an explicit representation.
7528 * Return the total number of local variables if they all have
7529 * an explicit representation.
7530 * Return -1 on error.
7532 int isl_basic_map_first_unknown_div(__isl_keep isl_basic_map *bmap)
7534 int i;
7536 if (!bmap)
7537 return -1;
7539 for (i = 0; i < bmap->n_div; ++i) {
7540 if (!isl_basic_map_div_is_known(bmap, i))
7541 return i;
7543 return bmap->n_div;
7546 /* Return the position of the first local variable that does not
7547 * have an explicit representation.
7548 * Return the total number of local variables if they all have
7549 * an explicit representation.
7550 * Return -1 on error.
7552 int isl_basic_set_first_unknown_div(__isl_keep isl_basic_set *bset)
7554 return isl_basic_map_first_unknown_div(bset);
7557 /* Does "bmap" have an explicit representation for all local variables?
7559 isl_bool isl_basic_map_divs_known(__isl_keep isl_basic_map *bmap)
7561 int first, n;
7563 n = isl_basic_map_dim(bmap, isl_dim_div);
7564 first = isl_basic_map_first_unknown_div(bmap);
7565 if (first < 0)
7566 return isl_bool_error;
7567 return first == n;
7570 /* Do all basic maps in "map" have an explicit representation
7571 * for all local variables?
7573 isl_bool isl_map_divs_known(__isl_keep isl_map *map)
7575 int i;
7577 if (!map)
7578 return isl_bool_error;
7580 for (i = 0; i < map->n; ++i) {
7581 int known = isl_basic_map_divs_known(map->p[i]);
7582 if (known <= 0)
7583 return known;
7586 return isl_bool_true;
7589 /* If bmap contains any unknown divs, then compute explicit
7590 * expressions for them. However, this computation may be
7591 * quite expensive, so first try to remove divs that aren't
7592 * strictly needed.
7594 __isl_give isl_map *isl_basic_map_compute_divs(__isl_take isl_basic_map *bmap)
7596 int known;
7597 struct isl_map *map;
7599 known = isl_basic_map_divs_known(bmap);
7600 if (known < 0)
7601 goto error;
7602 if (known)
7603 return isl_map_from_basic_map(bmap);
7605 bmap = isl_basic_map_drop_redundant_divs(bmap);
7607 known = isl_basic_map_divs_known(bmap);
7608 if (known < 0)
7609 goto error;
7610 if (known)
7611 return isl_map_from_basic_map(bmap);
7613 map = compute_divs(bmap);
7614 return map;
7615 error:
7616 isl_basic_map_free(bmap);
7617 return NULL;
7620 __isl_give isl_map *isl_map_compute_divs(__isl_take isl_map *map)
7622 int i;
7623 int known;
7624 struct isl_map *res;
7626 if (!map)
7627 return NULL;
7628 if (map->n == 0)
7629 return map;
7631 known = isl_map_divs_known(map);
7632 if (known < 0) {
7633 isl_map_free(map);
7634 return NULL;
7636 if (known)
7637 return map;
7639 res = isl_basic_map_compute_divs(isl_basic_map_copy(map->p[0]));
7640 for (i = 1 ; i < map->n; ++i) {
7641 struct isl_map *r2;
7642 r2 = isl_basic_map_compute_divs(isl_basic_map_copy(map->p[i]));
7643 if (ISL_F_ISSET(map, ISL_MAP_DISJOINT))
7644 res = isl_map_union_disjoint(res, r2);
7645 else
7646 res = isl_map_union(res, r2);
7648 isl_map_free(map);
7650 return res;
7653 __isl_give isl_set *isl_basic_set_compute_divs(__isl_take isl_basic_set *bset)
7655 return set_from_map(isl_basic_map_compute_divs(bset_to_bmap(bset)));
7658 struct isl_set *isl_set_compute_divs(struct isl_set *set)
7660 return set_from_map(isl_map_compute_divs(set_to_map(set)));
7663 __isl_give isl_set *isl_map_domain(__isl_take isl_map *map)
7665 int i;
7666 struct isl_set *set;
7668 if (!map)
7669 goto error;
7671 map = isl_map_cow(map);
7672 if (!map)
7673 return NULL;
7675 set = set_from_map(map);
7676 set->dim = isl_space_domain(set->dim);
7677 if (!set->dim)
7678 goto error;
7679 for (i = 0; i < map->n; ++i) {
7680 set->p[i] = isl_basic_map_domain(map->p[i]);
7681 if (!set->p[i])
7682 goto error;
7684 ISL_F_CLR(set, ISL_MAP_DISJOINT);
7685 ISL_F_CLR(set, ISL_SET_NORMALIZED);
7686 return set;
7687 error:
7688 isl_map_free(map);
7689 return NULL;
7692 /* Return the union of "map1" and "map2", where we assume for now that
7693 * "map1" and "map2" are disjoint. Note that the basic maps inside
7694 * "map1" or "map2" may not be disjoint from each other.
7695 * Also note that this function is also called from isl_map_union,
7696 * which takes care of handling the situation where "map1" and "map2"
7697 * may not be disjoint.
7699 * If one of the inputs is empty, we can simply return the other input.
7700 * Similarly, if one of the inputs is universal, then it is equal to the union.
7702 static __isl_give isl_map *map_union_disjoint(__isl_take isl_map *map1,
7703 __isl_take isl_map *map2)
7705 int i;
7706 unsigned flags = 0;
7707 struct isl_map *map = NULL;
7708 int is_universe;
7710 if (!map1 || !map2)
7711 goto error;
7713 if (!isl_space_is_equal(map1->dim, map2->dim))
7714 isl_die(isl_map_get_ctx(map1), isl_error_invalid,
7715 "spaces don't match", goto error);
7717 if (map1->n == 0) {
7718 isl_map_free(map1);
7719 return map2;
7721 if (map2->n == 0) {
7722 isl_map_free(map2);
7723 return map1;
7726 is_universe = isl_map_plain_is_universe(map1);
7727 if (is_universe < 0)
7728 goto error;
7729 if (is_universe) {
7730 isl_map_free(map2);
7731 return map1;
7734 is_universe = isl_map_plain_is_universe(map2);
7735 if (is_universe < 0)
7736 goto error;
7737 if (is_universe) {
7738 isl_map_free(map1);
7739 return map2;
7742 if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) &&
7743 ISL_F_ISSET(map2, ISL_MAP_DISJOINT))
7744 ISL_FL_SET(flags, ISL_MAP_DISJOINT);
7746 map = isl_map_alloc_space(isl_space_copy(map1->dim),
7747 map1->n + map2->n, flags);
7748 if (!map)
7749 goto error;
7750 for (i = 0; i < map1->n; ++i) {
7751 map = isl_map_add_basic_map(map,
7752 isl_basic_map_copy(map1->p[i]));
7753 if (!map)
7754 goto error;
7756 for (i = 0; i < map2->n; ++i) {
7757 map = isl_map_add_basic_map(map,
7758 isl_basic_map_copy(map2->p[i]));
7759 if (!map)
7760 goto error;
7762 isl_map_free(map1);
7763 isl_map_free(map2);
7764 return map;
7765 error:
7766 isl_map_free(map);
7767 isl_map_free(map1);
7768 isl_map_free(map2);
7769 return NULL;
7772 /* Return the union of "map1" and "map2", where "map1" and "map2" are
7773 * guaranteed to be disjoint by the caller.
7775 * Note that this functions is called from within isl_map_make_disjoint,
7776 * so we have to be careful not to touch the constraints of the inputs
7777 * in any way.
7779 __isl_give isl_map *isl_map_union_disjoint(__isl_take isl_map *map1,
7780 __isl_take isl_map *map2)
7782 return isl_map_align_params_map_map_and(map1, map2, &map_union_disjoint);
7785 /* Return the union of "map1" and "map2", where "map1" and "map2" may
7786 * not be disjoint. The parameters are assumed to have been aligned.
7788 * We currently simply call map_union_disjoint, the internal operation
7789 * of which does not really depend on the inputs being disjoint.
7790 * If the result contains more than one basic map, then we clear
7791 * the disjoint flag since the result may contain basic maps from
7792 * both inputs and these are not guaranteed to be disjoint.
7794 * As a special case, if "map1" and "map2" are obviously equal,
7795 * then we simply return "map1".
7797 static __isl_give isl_map *map_union_aligned(__isl_take isl_map *map1,
7798 __isl_take isl_map *map2)
7800 int equal;
7802 if (!map1 || !map2)
7803 goto error;
7805 equal = isl_map_plain_is_equal(map1, map2);
7806 if (equal < 0)
7807 goto error;
7808 if (equal) {
7809 isl_map_free(map2);
7810 return map1;
7813 map1 = map_union_disjoint(map1, map2);
7814 if (!map1)
7815 return NULL;
7816 if (map1->n > 1)
7817 ISL_F_CLR(map1, ISL_MAP_DISJOINT);
7818 return map1;
7819 error:
7820 isl_map_free(map1);
7821 isl_map_free(map2);
7822 return NULL;
7825 /* Return the union of "map1" and "map2", where "map1" and "map2" may
7826 * not be disjoint.
7828 __isl_give isl_map *isl_map_union(__isl_take isl_map *map1,
7829 __isl_take isl_map *map2)
7831 return isl_map_align_params_map_map_and(map1, map2, &map_union_aligned);
7834 __isl_give isl_set *isl_set_union_disjoint(
7835 __isl_take isl_set *set1, __isl_take isl_set *set2)
7837 return set_from_map(isl_map_union_disjoint(set_to_map(set1),
7838 set_to_map(set2)));
7841 struct isl_set *isl_set_union(struct isl_set *set1, struct isl_set *set2)
7843 return set_from_map(isl_map_union(set_to_map(set1), set_to_map(set2)));
7846 /* Apply "fn" to pairs of elements from "map" and "set" and collect
7847 * the results.
7849 * "map" and "set" are assumed to be compatible and non-NULL.
7851 static __isl_give isl_map *map_intersect_set(__isl_take isl_map *map,
7852 __isl_take isl_set *set,
7853 __isl_give isl_basic_map *fn(__isl_take isl_basic_map *bmap,
7854 __isl_take isl_basic_set *bset))
7856 unsigned flags = 0;
7857 struct isl_map *result;
7858 int i, j;
7860 if (isl_set_plain_is_universe(set)) {
7861 isl_set_free(set);
7862 return map;
7865 if (ISL_F_ISSET(map, ISL_MAP_DISJOINT) &&
7866 ISL_F_ISSET(set, ISL_MAP_DISJOINT))
7867 ISL_FL_SET(flags, ISL_MAP_DISJOINT);
7869 result = isl_map_alloc_space(isl_space_copy(map->dim),
7870 map->n * set->n, flags);
7871 for (i = 0; result && i < map->n; ++i)
7872 for (j = 0; j < set->n; ++j) {
7873 result = isl_map_add_basic_map(result,
7874 fn(isl_basic_map_copy(map->p[i]),
7875 isl_basic_set_copy(set->p[j])));
7876 if (!result)
7877 break;
7880 isl_map_free(map);
7881 isl_set_free(set);
7882 return result;
7885 static __isl_give isl_map *map_intersect_range(__isl_take isl_map *map,
7886 __isl_take isl_set *set)
7888 isl_bool ok;
7890 ok = isl_map_compatible_range(map, set);
7891 if (ok < 0)
7892 goto error;
7893 if (!ok)
7894 isl_die(set->ctx, isl_error_invalid,
7895 "incompatible spaces", goto error);
7897 return map_intersect_set(map, set, &isl_basic_map_intersect_range);
7898 error:
7899 isl_map_free(map);
7900 isl_set_free(set);
7901 return NULL;
7904 __isl_give isl_map *isl_map_intersect_range(__isl_take isl_map *map,
7905 __isl_take isl_set *set)
7907 return isl_map_align_params_map_map_and(map, set, &map_intersect_range);
7910 static __isl_give isl_map *map_intersect_domain(__isl_take isl_map *map,
7911 __isl_take isl_set *set)
7913 isl_bool ok;
7915 ok = isl_map_compatible_domain(map, set);
7916 if (ok < 0)
7917 goto error;
7918 if (!ok)
7919 isl_die(set->ctx, isl_error_invalid,
7920 "incompatible spaces", goto error);
7922 return map_intersect_set(map, set, &isl_basic_map_intersect_domain);
7923 error:
7924 isl_map_free(map);
7925 isl_set_free(set);
7926 return NULL;
7929 __isl_give isl_map *isl_map_intersect_domain(__isl_take isl_map *map,
7930 __isl_take isl_set *set)
7932 return isl_map_align_params_map_map_and(map, set,
7933 &map_intersect_domain);
7936 /* Given a map "map" in a space [A -> B] -> C and a map "factor"
7937 * in the space B -> C, return the intersection.
7938 * The parameters are assumed to have been aligned.
7940 * The map "factor" is first extended to a map living in the space
7941 * [A -> B] -> C and then a regular intersection is computed.
7943 static __isl_give isl_map *map_intersect_domain_factor_range(
7944 __isl_take isl_map *map, __isl_take isl_map *factor)
7946 isl_space *space;
7947 isl_map *ext_factor;
7949 space = isl_space_domain_factor_domain(isl_map_get_space(map));
7950 ext_factor = isl_map_universe(space);
7951 ext_factor = isl_map_domain_product(ext_factor, factor);
7952 return map_intersect(map, ext_factor);
7955 /* Given a map "map" in a space [A -> B] -> C and a map "factor"
7956 * in the space B -> C, return the intersection.
7958 __isl_give isl_map *isl_map_intersect_domain_factor_range(
7959 __isl_take isl_map *map, __isl_take isl_map *factor)
7961 return isl_map_align_params_map_map_and(map, factor,
7962 &map_intersect_domain_factor_range);
7965 /* Given a map "map" in a space A -> [B -> C] and a map "factor"
7966 * in the space A -> C, return the intersection.
7968 * The map "factor" is first extended to a map living in the space
7969 * A -> [B -> C] and then a regular intersection is computed.
7971 static __isl_give isl_map *map_intersect_range_factor_range(
7972 __isl_take isl_map *map, __isl_take isl_map *factor)
7974 isl_space *space;
7975 isl_map *ext_factor;
7977 space = isl_space_range_factor_domain(isl_map_get_space(map));
7978 ext_factor = isl_map_universe(space);
7979 ext_factor = isl_map_range_product(ext_factor, factor);
7980 return isl_map_intersect(map, ext_factor);
7983 /* Given a map "map" in a space A -> [B -> C] and a map "factor"
7984 * in the space A -> C, return the intersection.
7986 __isl_give isl_map *isl_map_intersect_range_factor_range(
7987 __isl_take isl_map *map, __isl_take isl_map *factor)
7989 return isl_map_align_params_map_map_and(map, factor,
7990 &map_intersect_range_factor_range);
7993 static __isl_give isl_map *map_apply_domain(__isl_take isl_map *map1,
7994 __isl_take isl_map *map2)
7996 if (!map1 || !map2)
7997 goto error;
7998 map1 = isl_map_reverse(map1);
7999 map1 = isl_map_apply_range(map1, map2);
8000 return isl_map_reverse(map1);
8001 error:
8002 isl_map_free(map1);
8003 isl_map_free(map2);
8004 return NULL;
8007 __isl_give isl_map *isl_map_apply_domain(__isl_take isl_map *map1,
8008 __isl_take isl_map *map2)
8010 return isl_map_align_params_map_map_and(map1, map2, &map_apply_domain);
8013 static __isl_give isl_map *map_apply_range(__isl_take isl_map *map1,
8014 __isl_take isl_map *map2)
8016 isl_space *dim_result;
8017 struct isl_map *result;
8018 int i, j;
8020 if (!map1 || !map2)
8021 goto error;
8023 dim_result = isl_space_join(isl_space_copy(map1->dim),
8024 isl_space_copy(map2->dim));
8026 result = isl_map_alloc_space(dim_result, map1->n * map2->n, 0);
8027 if (!result)
8028 goto error;
8029 for (i = 0; i < map1->n; ++i)
8030 for (j = 0; j < map2->n; ++j) {
8031 result = isl_map_add_basic_map(result,
8032 isl_basic_map_apply_range(
8033 isl_basic_map_copy(map1->p[i]),
8034 isl_basic_map_copy(map2->p[j])));
8035 if (!result)
8036 goto error;
8038 isl_map_free(map1);
8039 isl_map_free(map2);
8040 if (result && result->n <= 1)
8041 ISL_F_SET(result, ISL_MAP_DISJOINT);
8042 return result;
8043 error:
8044 isl_map_free(map1);
8045 isl_map_free(map2);
8046 return NULL;
8049 __isl_give isl_map *isl_map_apply_range(__isl_take isl_map *map1,
8050 __isl_take isl_map *map2)
8052 return isl_map_align_params_map_map_and(map1, map2, &map_apply_range);
8056 * returns range - domain
8058 __isl_give isl_basic_set *isl_basic_map_deltas(__isl_take isl_basic_map *bmap)
8060 isl_space *target_space;
8061 struct isl_basic_set *bset;
8062 unsigned dim;
8063 unsigned nparam;
8064 int i;
8066 if (!bmap)
8067 goto error;
8068 isl_assert(bmap->ctx, isl_space_tuple_is_equal(bmap->dim, isl_dim_in,
8069 bmap->dim, isl_dim_out),
8070 goto error);
8071 target_space = isl_space_domain(isl_basic_map_get_space(bmap));
8072 dim = isl_basic_map_dim(bmap, isl_dim_in);
8073 nparam = isl_basic_map_dim(bmap, isl_dim_param);
8074 bmap = isl_basic_map_from_range(isl_basic_map_wrap(bmap));
8075 bmap = isl_basic_map_add_dims(bmap, isl_dim_in, dim);
8076 bmap = isl_basic_map_extend_constraints(bmap, dim, 0);
8077 for (i = 0; i < dim; ++i) {
8078 int j = isl_basic_map_alloc_equality(bmap);
8079 if (j < 0) {
8080 bmap = isl_basic_map_free(bmap);
8081 break;
8083 isl_seq_clr(bmap->eq[j], 1 + isl_basic_map_total_dim(bmap));
8084 isl_int_set_si(bmap->eq[j][1+nparam+i], 1);
8085 isl_int_set_si(bmap->eq[j][1+nparam+dim+i], 1);
8086 isl_int_set_si(bmap->eq[j][1+nparam+2*dim+i], -1);
8088 bset = isl_basic_map_domain(bmap);
8089 bset = isl_basic_set_reset_space(bset, target_space);
8090 return bset;
8091 error:
8092 isl_basic_map_free(bmap);
8093 return NULL;
8097 * returns range - domain
8099 __isl_give isl_set *isl_map_deltas(__isl_take isl_map *map)
8101 int i;
8102 isl_space *dim;
8103 struct isl_set *result;
8105 if (!map)
8106 return NULL;
8108 isl_assert(map->ctx, isl_space_tuple_is_equal(map->dim, isl_dim_in,
8109 map->dim, isl_dim_out),
8110 goto error);
8111 dim = isl_map_get_space(map);
8112 dim = isl_space_domain(dim);
8113 result = isl_set_alloc_space(dim, map->n, 0);
8114 if (!result)
8115 goto error;
8116 for (i = 0; i < map->n; ++i)
8117 result = isl_set_add_basic_set(result,
8118 isl_basic_map_deltas(isl_basic_map_copy(map->p[i])));
8119 isl_map_free(map);
8120 return result;
8121 error:
8122 isl_map_free(map);
8123 return NULL;
8127 * returns [domain -> range] -> range - domain
8129 __isl_give isl_basic_map *isl_basic_map_deltas_map(
8130 __isl_take isl_basic_map *bmap)
8132 int i, k;
8133 isl_space *dim;
8134 isl_basic_map *domain;
8135 int nparam, n;
8136 unsigned total;
8138 if (!isl_space_tuple_is_equal(bmap->dim, isl_dim_in,
8139 bmap->dim, isl_dim_out))
8140 isl_die(bmap->ctx, isl_error_invalid,
8141 "domain and range don't match", goto error);
8143 nparam = isl_basic_map_dim(bmap, isl_dim_param);
8144 n = isl_basic_map_dim(bmap, isl_dim_in);
8146 dim = isl_space_from_range(isl_space_domain(isl_basic_map_get_space(bmap)));
8147 domain = isl_basic_map_universe(dim);
8149 bmap = isl_basic_map_from_domain(isl_basic_map_wrap(bmap));
8150 bmap = isl_basic_map_apply_range(bmap, domain);
8151 bmap = isl_basic_map_extend_constraints(bmap, n, 0);
8153 total = isl_basic_map_total_dim(bmap);
8155 for (i = 0; i < n; ++i) {
8156 k = isl_basic_map_alloc_equality(bmap);
8157 if (k < 0)
8158 goto error;
8159 isl_seq_clr(bmap->eq[k], 1 + total);
8160 isl_int_set_si(bmap->eq[k][1 + nparam + i], 1);
8161 isl_int_set_si(bmap->eq[k][1 + nparam + n + i], -1);
8162 isl_int_set_si(bmap->eq[k][1 + nparam + n + n + i], 1);
8165 bmap = isl_basic_map_gauss(bmap, NULL);
8166 return isl_basic_map_finalize(bmap);
8167 error:
8168 isl_basic_map_free(bmap);
8169 return NULL;
8173 * returns [domain -> range] -> range - domain
8175 __isl_give isl_map *isl_map_deltas_map(__isl_take isl_map *map)
8177 int i;
8178 isl_space *domain_dim;
8180 if (!map)
8181 return NULL;
8183 if (!isl_space_tuple_is_equal(map->dim, isl_dim_in,
8184 map->dim, isl_dim_out))
8185 isl_die(map->ctx, isl_error_invalid,
8186 "domain and range don't match", goto error);
8188 map = isl_map_cow(map);
8189 if (!map)
8190 return NULL;
8192 domain_dim = isl_space_from_range(isl_space_domain(isl_map_get_space(map)));
8193 map->dim = isl_space_from_domain(isl_space_wrap(map->dim));
8194 map->dim = isl_space_join(map->dim, domain_dim);
8195 if (!map->dim)
8196 goto error;
8197 for (i = 0; i < map->n; ++i) {
8198 map->p[i] = isl_basic_map_deltas_map(map->p[i]);
8199 if (!map->p[i])
8200 goto error;
8202 map = isl_map_unmark_normalized(map);
8203 return map;
8204 error:
8205 isl_map_free(map);
8206 return NULL;
8209 static __isl_give isl_basic_map *basic_map_identity(__isl_take isl_space *dims)
8211 struct isl_basic_map *bmap;
8212 unsigned nparam;
8213 unsigned dim;
8214 int i;
8216 if (!dims)
8217 return NULL;
8219 nparam = dims->nparam;
8220 dim = dims->n_out;
8221 bmap = isl_basic_map_alloc_space(dims, 0, dim, 0);
8222 if (!bmap)
8223 goto error;
8225 for (i = 0; i < dim; ++i) {
8226 int j = isl_basic_map_alloc_equality(bmap);
8227 if (j < 0)
8228 goto error;
8229 isl_seq_clr(bmap->eq[j], 1 + isl_basic_map_total_dim(bmap));
8230 isl_int_set_si(bmap->eq[j][1+nparam+i], 1);
8231 isl_int_set_si(bmap->eq[j][1+nparam+dim+i], -1);
8233 return isl_basic_map_finalize(bmap);
8234 error:
8235 isl_basic_map_free(bmap);
8236 return NULL;
8239 __isl_give isl_basic_map *isl_basic_map_identity(__isl_take isl_space *dim)
8241 if (!dim)
8242 return NULL;
8243 if (dim->n_in != dim->n_out)
8244 isl_die(dim->ctx, isl_error_invalid,
8245 "number of input and output dimensions needs to be "
8246 "the same", goto error);
8247 return basic_map_identity(dim);
8248 error:
8249 isl_space_free(dim);
8250 return NULL;
8253 __isl_give isl_map *isl_map_identity(__isl_take isl_space *dim)
8255 return isl_map_from_basic_map(isl_basic_map_identity(dim));
8258 __isl_give isl_map *isl_set_identity(__isl_take isl_set *set)
8260 isl_space *dim = isl_set_get_space(set);
8261 isl_map *id;
8262 id = isl_map_identity(isl_space_map_from_set(dim));
8263 return isl_map_intersect_range(id, set);
8266 /* Construct a basic set with all set dimensions having only non-negative
8267 * values.
8269 __isl_give isl_basic_set *isl_basic_set_positive_orthant(
8270 __isl_take isl_space *space)
8272 int i;
8273 unsigned nparam;
8274 unsigned dim;
8275 struct isl_basic_set *bset;
8277 if (!space)
8278 return NULL;
8279 nparam = space->nparam;
8280 dim = space->n_out;
8281 bset = isl_basic_set_alloc_space(space, 0, 0, dim);
8282 if (!bset)
8283 return NULL;
8284 for (i = 0; i < dim; ++i) {
8285 int k = isl_basic_set_alloc_inequality(bset);
8286 if (k < 0)
8287 goto error;
8288 isl_seq_clr(bset->ineq[k], 1 + isl_basic_set_total_dim(bset));
8289 isl_int_set_si(bset->ineq[k][1 + nparam + i], 1);
8291 return bset;
8292 error:
8293 isl_basic_set_free(bset);
8294 return NULL;
8297 /* Construct the half-space x_pos >= 0.
8299 static __isl_give isl_basic_set *nonneg_halfspace(__isl_take isl_space *dim,
8300 int pos)
8302 int k;
8303 isl_basic_set *nonneg;
8305 nonneg = isl_basic_set_alloc_space(dim, 0, 0, 1);
8306 k = isl_basic_set_alloc_inequality(nonneg);
8307 if (k < 0)
8308 goto error;
8309 isl_seq_clr(nonneg->ineq[k], 1 + isl_basic_set_total_dim(nonneg));
8310 isl_int_set_si(nonneg->ineq[k][pos], 1);
8312 return isl_basic_set_finalize(nonneg);
8313 error:
8314 isl_basic_set_free(nonneg);
8315 return NULL;
8318 /* Construct the half-space x_pos <= -1.
8320 static __isl_give isl_basic_set *neg_halfspace(__isl_take isl_space *dim, int pos)
8322 int k;
8323 isl_basic_set *neg;
8325 neg = isl_basic_set_alloc_space(dim, 0, 0, 1);
8326 k = isl_basic_set_alloc_inequality(neg);
8327 if (k < 0)
8328 goto error;
8329 isl_seq_clr(neg->ineq[k], 1 + isl_basic_set_total_dim(neg));
8330 isl_int_set_si(neg->ineq[k][0], -1);
8331 isl_int_set_si(neg->ineq[k][pos], -1);
8333 return isl_basic_set_finalize(neg);
8334 error:
8335 isl_basic_set_free(neg);
8336 return NULL;
8339 __isl_give isl_set *isl_set_split_dims(__isl_take isl_set *set,
8340 enum isl_dim_type type, unsigned first, unsigned n)
8342 int i;
8343 unsigned offset;
8344 isl_basic_set *nonneg;
8345 isl_basic_set *neg;
8347 if (!set)
8348 return NULL;
8349 if (n == 0)
8350 return set;
8352 isl_assert(set->ctx, first + n <= isl_set_dim(set, type), goto error);
8354 offset = pos(set->dim, type);
8355 for (i = 0; i < n; ++i) {
8356 nonneg = nonneg_halfspace(isl_set_get_space(set),
8357 offset + first + i);
8358 neg = neg_halfspace(isl_set_get_space(set), offset + first + i);
8360 set = isl_set_intersect(set, isl_basic_set_union(nonneg, neg));
8363 return set;
8364 error:
8365 isl_set_free(set);
8366 return NULL;
8369 static isl_stat foreach_orthant(__isl_take isl_set *set, int *signs, int first,
8370 int len,
8371 isl_stat (*fn)(__isl_take isl_set *orthant, int *signs, void *user),
8372 void *user)
8374 isl_set *half;
8376 if (!set)
8377 return isl_stat_error;
8378 if (isl_set_plain_is_empty(set)) {
8379 isl_set_free(set);
8380 return isl_stat_ok;
8382 if (first == len)
8383 return fn(set, signs, user);
8385 signs[first] = 1;
8386 half = isl_set_from_basic_set(nonneg_halfspace(isl_set_get_space(set),
8387 1 + first));
8388 half = isl_set_intersect(half, isl_set_copy(set));
8389 if (foreach_orthant(half, signs, first + 1, len, fn, user) < 0)
8390 goto error;
8392 signs[first] = -1;
8393 half = isl_set_from_basic_set(neg_halfspace(isl_set_get_space(set),
8394 1 + first));
8395 half = isl_set_intersect(half, set);
8396 return foreach_orthant(half, signs, first + 1, len, fn, user);
8397 error:
8398 isl_set_free(set);
8399 return isl_stat_error;
8402 /* Call "fn" on the intersections of "set" with each of the orthants
8403 * (except for obviously empty intersections). The orthant is identified
8404 * by the signs array, with each entry having value 1 or -1 according
8405 * to the sign of the corresponding variable.
8407 isl_stat isl_set_foreach_orthant(__isl_keep isl_set *set,
8408 isl_stat (*fn)(__isl_take isl_set *orthant, int *signs, void *user),
8409 void *user)
8411 unsigned nparam;
8412 unsigned nvar;
8413 int *signs;
8414 isl_stat r;
8416 if (!set)
8417 return isl_stat_error;
8418 if (isl_set_plain_is_empty(set))
8419 return isl_stat_ok;
8421 nparam = isl_set_dim(set, isl_dim_param);
8422 nvar = isl_set_dim(set, isl_dim_set);
8424 signs = isl_alloc_array(set->ctx, int, nparam + nvar);
8426 r = foreach_orthant(isl_set_copy(set), signs, 0, nparam + nvar,
8427 fn, user);
8429 free(signs);
8431 return r;
8434 isl_bool isl_set_is_equal(__isl_keep isl_set *set1, __isl_keep isl_set *set2)
8436 return isl_map_is_equal(set_to_map(set1), set_to_map(set2));
8439 isl_bool isl_basic_map_is_subset(__isl_keep isl_basic_map *bmap1,
8440 __isl_keep isl_basic_map *bmap2)
8442 int is_subset;
8443 struct isl_map *map1;
8444 struct isl_map *map2;
8446 if (!bmap1 || !bmap2)
8447 return isl_bool_error;
8449 map1 = isl_map_from_basic_map(isl_basic_map_copy(bmap1));
8450 map2 = isl_map_from_basic_map(isl_basic_map_copy(bmap2));
8452 is_subset = isl_map_is_subset(map1, map2);
8454 isl_map_free(map1);
8455 isl_map_free(map2);
8457 return is_subset;
8460 isl_bool isl_basic_set_is_subset(__isl_keep isl_basic_set *bset1,
8461 __isl_keep isl_basic_set *bset2)
8463 return isl_basic_map_is_subset(bset1, bset2);
8466 isl_bool isl_basic_map_is_equal(__isl_keep isl_basic_map *bmap1,
8467 __isl_keep isl_basic_map *bmap2)
8469 isl_bool is_subset;
8471 if (!bmap1 || !bmap2)
8472 return isl_bool_error;
8473 is_subset = isl_basic_map_is_subset(bmap1, bmap2);
8474 if (is_subset != isl_bool_true)
8475 return is_subset;
8476 is_subset = isl_basic_map_is_subset(bmap2, bmap1);
8477 return is_subset;
8480 isl_bool isl_basic_set_is_equal(__isl_keep isl_basic_set *bset1,
8481 __isl_keep isl_basic_set *bset2)
8483 return isl_basic_map_is_equal(
8484 bset_to_bmap(bset1), bset_to_bmap(bset2));
8487 isl_bool isl_map_is_empty(__isl_keep isl_map *map)
8489 int i;
8490 int is_empty;
8492 if (!map)
8493 return isl_bool_error;
8494 for (i = 0; i < map->n; ++i) {
8495 is_empty = isl_basic_map_is_empty(map->p[i]);
8496 if (is_empty < 0)
8497 return isl_bool_error;
8498 if (!is_empty)
8499 return isl_bool_false;
8501 return isl_bool_true;
8504 isl_bool isl_map_plain_is_empty(__isl_keep isl_map *map)
8506 return map ? map->n == 0 : isl_bool_error;
8509 isl_bool isl_set_plain_is_empty(__isl_keep isl_set *set)
8511 return set ? set->n == 0 : isl_bool_error;
8514 isl_bool isl_set_is_empty(__isl_keep isl_set *set)
8516 return isl_map_is_empty(set_to_map(set));
8519 isl_bool isl_map_has_equal_space(__isl_keep isl_map *map1,
8520 __isl_keep isl_map *map2)
8522 if (!map1 || !map2)
8523 return isl_bool_error;
8525 return isl_space_is_equal(map1->dim, map2->dim);
8528 isl_bool isl_set_has_equal_space(__isl_keep isl_set *set1,
8529 __isl_keep isl_set *set2)
8531 if (!set1 || !set2)
8532 return isl_bool_error;
8534 return isl_space_is_equal(set1->dim, set2->dim);
8537 static isl_bool map_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2)
8539 isl_bool is_subset;
8541 if (!map1 || !map2)
8542 return isl_bool_error;
8543 is_subset = isl_map_is_subset(map1, map2);
8544 if (is_subset != isl_bool_true)
8545 return is_subset;
8546 is_subset = isl_map_is_subset(map2, map1);
8547 return is_subset;
8550 /* Is "map1" equal to "map2"?
8552 * First check if they are obviously equal.
8553 * If not, then perform a more detailed analysis.
8555 isl_bool isl_map_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2)
8557 isl_bool equal;
8559 equal = isl_map_plain_is_equal(map1, map2);
8560 if (equal < 0 || equal)
8561 return equal;
8562 return isl_map_align_params_map_map_and_test(map1, map2, &map_is_equal);
8565 isl_bool isl_basic_map_is_strict_subset(
8566 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
8568 isl_bool is_subset;
8570 if (!bmap1 || !bmap2)
8571 return isl_bool_error;
8572 is_subset = isl_basic_map_is_subset(bmap1, bmap2);
8573 if (is_subset != isl_bool_true)
8574 return is_subset;
8575 is_subset = isl_basic_map_is_subset(bmap2, bmap1);
8576 if (is_subset == isl_bool_error)
8577 return is_subset;
8578 return !is_subset;
8581 isl_bool isl_map_is_strict_subset(__isl_keep isl_map *map1,
8582 __isl_keep isl_map *map2)
8584 isl_bool is_subset;
8586 if (!map1 || !map2)
8587 return isl_bool_error;
8588 is_subset = isl_map_is_subset(map1, map2);
8589 if (is_subset != isl_bool_true)
8590 return is_subset;
8591 is_subset = isl_map_is_subset(map2, map1);
8592 if (is_subset == isl_bool_error)
8593 return is_subset;
8594 return !is_subset;
8597 isl_bool isl_set_is_strict_subset(__isl_keep isl_set *set1,
8598 __isl_keep isl_set *set2)
8600 return isl_map_is_strict_subset(set_to_map(set1), set_to_map(set2));
8603 /* Is "bmap" obviously equal to the universe with the same space?
8605 * That is, does it not have any constraints?
8607 isl_bool isl_basic_map_plain_is_universe(__isl_keep isl_basic_map *bmap)
8609 if (!bmap)
8610 return isl_bool_error;
8611 return bmap->n_eq == 0 && bmap->n_ineq == 0;
8614 /* Is "bset" obviously equal to the universe with the same space?
8616 isl_bool isl_basic_set_plain_is_universe(__isl_keep isl_basic_set *bset)
8618 return isl_basic_map_plain_is_universe(bset);
8621 /* If "c" does not involve any existentially quantified variables,
8622 * then set *univ to false and abort
8624 static isl_stat involves_divs(__isl_take isl_constraint *c, void *user)
8626 isl_bool *univ = user;
8627 unsigned n;
8629 n = isl_constraint_dim(c, isl_dim_div);
8630 *univ = isl_constraint_involves_dims(c, isl_dim_div, 0, n);
8631 isl_constraint_free(c);
8632 if (*univ < 0 || !*univ)
8633 return isl_stat_error;
8634 return isl_stat_ok;
8637 /* Is "bmap" equal to the universe with the same space?
8639 * First check if it is obviously equal to the universe.
8640 * If not and if there are any constraints not involving
8641 * existentially quantified variables, then it is certainly
8642 * not equal to the universe.
8643 * Otherwise, check if the universe is a subset of "bmap".
8645 isl_bool isl_basic_map_is_universe(__isl_keep isl_basic_map *bmap)
8647 isl_bool univ;
8648 isl_basic_map *test;
8650 univ = isl_basic_map_plain_is_universe(bmap);
8651 if (univ < 0 || univ)
8652 return univ;
8653 if (isl_basic_map_dim(bmap, isl_dim_div) == 0)
8654 return isl_bool_false;
8655 univ = isl_bool_true;
8656 if (isl_basic_map_foreach_constraint(bmap, &involves_divs, &univ) < 0 &&
8657 univ)
8658 return isl_bool_error;
8659 if (univ < 0 || !univ)
8660 return univ;
8661 test = isl_basic_map_universe(isl_basic_map_get_space(bmap));
8662 univ = isl_basic_map_is_subset(test, bmap);
8663 isl_basic_map_free(test);
8664 return univ;
8667 /* Is "bset" equal to the universe with the same space?
8669 isl_bool isl_basic_set_is_universe(__isl_keep isl_basic_set *bset)
8671 return isl_basic_map_is_universe(bset);
8674 isl_bool isl_map_plain_is_universe(__isl_keep isl_map *map)
8676 int i;
8678 if (!map)
8679 return isl_bool_error;
8681 for (i = 0; i < map->n; ++i) {
8682 isl_bool r = isl_basic_map_plain_is_universe(map->p[i]);
8683 if (r < 0 || r)
8684 return r;
8687 return isl_bool_false;
8690 isl_bool isl_set_plain_is_universe(__isl_keep isl_set *set)
8692 return isl_map_plain_is_universe(set_to_map(set));
8695 isl_bool isl_basic_map_is_empty(__isl_keep isl_basic_map *bmap)
8697 struct isl_basic_set *bset = NULL;
8698 struct isl_vec *sample = NULL;
8699 isl_bool empty, non_empty;
8701 if (!bmap)
8702 return isl_bool_error;
8704 if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
8705 return isl_bool_true;
8707 if (isl_basic_map_plain_is_universe(bmap))
8708 return isl_bool_false;
8710 if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL)) {
8711 struct isl_basic_map *copy = isl_basic_map_copy(bmap);
8712 copy = isl_basic_map_remove_redundancies(copy);
8713 empty = isl_basic_map_plain_is_empty(copy);
8714 isl_basic_map_free(copy);
8715 return empty;
8718 non_empty = isl_basic_map_plain_is_non_empty(bmap);
8719 if (non_empty < 0)
8720 return isl_bool_error;
8721 if (non_empty)
8722 return isl_bool_false;
8723 isl_vec_free(bmap->sample);
8724 bmap->sample = NULL;
8725 bset = isl_basic_map_underlying_set(isl_basic_map_copy(bmap));
8726 if (!bset)
8727 return isl_bool_error;
8728 sample = isl_basic_set_sample_vec(bset);
8729 if (!sample)
8730 return isl_bool_error;
8731 empty = sample->size == 0;
8732 isl_vec_free(bmap->sample);
8733 bmap->sample = sample;
8734 if (empty)
8735 ISL_F_SET(bmap, ISL_BASIC_MAP_EMPTY);
8737 return empty;
8740 isl_bool isl_basic_map_plain_is_empty(__isl_keep isl_basic_map *bmap)
8742 if (!bmap)
8743 return isl_bool_error;
8744 return ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY);
8747 isl_bool isl_basic_set_plain_is_empty(__isl_keep isl_basic_set *bset)
8749 if (!bset)
8750 return isl_bool_error;
8751 return ISL_F_ISSET(bset, ISL_BASIC_SET_EMPTY);
8754 /* Is "bmap" known to be non-empty?
8756 * That is, is the cached sample still valid?
8758 isl_bool isl_basic_map_plain_is_non_empty(__isl_keep isl_basic_map *bmap)
8760 unsigned total;
8762 if (!bmap)
8763 return isl_bool_error;
8764 if (!bmap->sample)
8765 return isl_bool_false;
8766 total = 1 + isl_basic_map_total_dim(bmap);
8767 if (bmap->sample->size != total)
8768 return isl_bool_false;
8769 return isl_basic_map_contains(bmap, bmap->sample);
8772 isl_bool isl_basic_set_is_empty(__isl_keep isl_basic_set *bset)
8774 return isl_basic_map_is_empty(bset_to_bmap(bset));
8777 __isl_give isl_map *isl_basic_map_union(__isl_take isl_basic_map *bmap1,
8778 __isl_take isl_basic_map *bmap2)
8780 struct isl_map *map;
8781 if (!bmap1 || !bmap2)
8782 goto error;
8784 isl_assert(bmap1->ctx, isl_space_is_equal(bmap1->dim, bmap2->dim), goto error);
8786 map = isl_map_alloc_space(isl_space_copy(bmap1->dim), 2, 0);
8787 if (!map)
8788 goto error;
8789 map = isl_map_add_basic_map(map, bmap1);
8790 map = isl_map_add_basic_map(map, bmap2);
8791 return map;
8792 error:
8793 isl_basic_map_free(bmap1);
8794 isl_basic_map_free(bmap2);
8795 return NULL;
8798 struct isl_set *isl_basic_set_union(
8799 struct isl_basic_set *bset1, struct isl_basic_set *bset2)
8801 return set_from_map(isl_basic_map_union(bset_to_bmap(bset1),
8802 bset_to_bmap(bset2)));
8805 /* Order divs such that any div only depends on previous divs */
8806 __isl_give isl_basic_map *isl_basic_map_order_divs(
8807 __isl_take isl_basic_map *bmap)
8809 int i;
8810 unsigned off;
8812 if (!bmap)
8813 return NULL;
8815 off = isl_space_dim(bmap->dim, isl_dim_all);
8817 for (i = 0; i < bmap->n_div; ++i) {
8818 int pos;
8819 if (isl_int_is_zero(bmap->div[i][0]))
8820 continue;
8821 pos = isl_seq_first_non_zero(bmap->div[i]+1+1+off+i,
8822 bmap->n_div-i);
8823 if (pos == -1)
8824 continue;
8825 if (pos == 0)
8826 isl_die(isl_basic_map_get_ctx(bmap), isl_error_internal,
8827 "integer division depends on itself",
8828 return isl_basic_map_free(bmap));
8829 isl_basic_map_swap_div(bmap, i, i + pos);
8830 --i;
8832 return bmap;
8835 struct isl_basic_set *isl_basic_set_order_divs(struct isl_basic_set *bset)
8837 return bset_from_bmap(isl_basic_map_order_divs(bset_to_bmap(bset)));
8840 __isl_give isl_map *isl_map_order_divs(__isl_take isl_map *map)
8842 int i;
8844 if (!map)
8845 return 0;
8847 for (i = 0; i < map->n; ++i) {
8848 map->p[i] = isl_basic_map_order_divs(map->p[i]);
8849 if (!map->p[i])
8850 goto error;
8853 return map;
8854 error:
8855 isl_map_free(map);
8856 return NULL;
8859 /* Sort the local variables of "bset".
8861 __isl_give isl_basic_set *isl_basic_set_sort_divs(
8862 __isl_take isl_basic_set *bset)
8864 return bset_from_bmap(isl_basic_map_sort_divs(bset_to_bmap(bset)));
8867 /* Apply the expansion computed by isl_merge_divs.
8868 * The expansion itself is given by "exp" while the resulting
8869 * list of divs is given by "div".
8871 * Move the integer divisions of "bmap" into the right position
8872 * according to "exp" and then introduce the additional integer
8873 * divisions, adding div constraints.
8874 * The moving should be done first to avoid moving coefficients
8875 * in the definitions of the extra integer divisions.
8877 __isl_give isl_basic_map *isl_basic_map_expand_divs(
8878 __isl_take isl_basic_map *bmap, __isl_take isl_mat *div, int *exp)
8880 int i, j;
8881 int n_div;
8883 bmap = isl_basic_map_cow(bmap);
8884 if (!bmap || !div)
8885 goto error;
8887 if (div->n_row < bmap->n_div)
8888 isl_die(isl_mat_get_ctx(div), isl_error_invalid,
8889 "not an expansion", goto error);
8891 n_div = bmap->n_div;
8892 bmap = isl_basic_map_extend_space(bmap, isl_space_copy(bmap->dim),
8893 div->n_row - n_div, 0,
8894 2 * (div->n_row - n_div));
8896 for (i = n_div; i < div->n_row; ++i)
8897 if (isl_basic_map_alloc_div(bmap) < 0)
8898 goto error;
8900 for (j = n_div - 1; j >= 0; --j) {
8901 if (exp[j] == j)
8902 break;
8903 isl_basic_map_swap_div(bmap, j, exp[j]);
8905 j = 0;
8906 for (i = 0; i < div->n_row; ++i) {
8907 if (j < n_div && exp[j] == i) {
8908 j++;
8909 } else {
8910 isl_seq_cpy(bmap->div[i], div->row[i], div->n_col);
8911 if (isl_basic_map_div_is_marked_unknown(bmap, i))
8912 continue;
8913 if (isl_basic_map_add_div_constraints(bmap, i) < 0)
8914 goto error;
8918 isl_mat_free(div);
8919 return bmap;
8920 error:
8921 isl_basic_map_free(bmap);
8922 isl_mat_free(div);
8923 return NULL;
8926 /* Apply the expansion computed by isl_merge_divs.
8927 * The expansion itself is given by "exp" while the resulting
8928 * list of divs is given by "div".
8930 __isl_give isl_basic_set *isl_basic_set_expand_divs(
8931 __isl_take isl_basic_set *bset, __isl_take isl_mat *div, int *exp)
8933 return isl_basic_map_expand_divs(bset, div, exp);
8936 /* Look for a div in dst that corresponds to the div "div" in src.
8937 * The divs before "div" in src and dst are assumed to be the same.
8939 * Returns -1 if no corresponding div was found and the position
8940 * of the corresponding div in dst otherwise.
8942 static int find_div(__isl_keep isl_basic_map *dst,
8943 __isl_keep isl_basic_map *src, unsigned div)
8945 int i;
8947 unsigned total = isl_space_dim(src->dim, isl_dim_all);
8949 isl_assert(dst->ctx, div <= dst->n_div, return -1);
8950 for (i = div; i < dst->n_div; ++i)
8951 if (isl_seq_eq(dst->div[i], src->div[div], 1+1+total+div) &&
8952 isl_seq_first_non_zero(dst->div[i]+1+1+total+div,
8953 dst->n_div - div) == -1)
8954 return i;
8955 return -1;
8958 /* Align the divs of "dst" to those of "src", adding divs from "src"
8959 * if needed. That is, make sure that the first src->n_div divs
8960 * of the result are equal to those of src.
8962 * The result is not finalized as by design it will have redundant
8963 * divs if any divs from "src" were copied.
8965 __isl_give isl_basic_map *isl_basic_map_align_divs(
8966 __isl_take isl_basic_map *dst, __isl_keep isl_basic_map *src)
8968 int i;
8969 int known, extended;
8970 unsigned total;
8972 if (!dst || !src)
8973 return isl_basic_map_free(dst);
8975 if (src->n_div == 0)
8976 return dst;
8978 known = isl_basic_map_divs_known(src);
8979 if (known < 0)
8980 return isl_basic_map_free(dst);
8981 if (!known)
8982 isl_die(isl_basic_map_get_ctx(src), isl_error_invalid,
8983 "some src divs are unknown",
8984 return isl_basic_map_free(dst));
8986 src = isl_basic_map_order_divs(src);
8988 extended = 0;
8989 total = isl_space_dim(src->dim, isl_dim_all);
8990 for (i = 0; i < src->n_div; ++i) {
8991 int j = find_div(dst, src, i);
8992 if (j < 0) {
8993 if (!extended) {
8994 int extra = src->n_div - i;
8995 dst = isl_basic_map_cow(dst);
8996 if (!dst)
8997 return NULL;
8998 dst = isl_basic_map_extend_space(dst,
8999 isl_space_copy(dst->dim),
9000 extra, 0, 2 * extra);
9001 extended = 1;
9003 j = isl_basic_map_alloc_div(dst);
9004 if (j < 0)
9005 return isl_basic_map_free(dst);
9006 isl_seq_cpy(dst->div[j], src->div[i], 1+1+total+i);
9007 isl_seq_clr(dst->div[j]+1+1+total+i, dst->n_div - i);
9008 if (isl_basic_map_add_div_constraints(dst, j) < 0)
9009 return isl_basic_map_free(dst);
9011 if (j != i)
9012 isl_basic_map_swap_div(dst, i, j);
9014 return dst;
9017 __isl_give isl_map *isl_map_align_divs_internal(__isl_take isl_map *map)
9019 int i;
9021 if (!map)
9022 return NULL;
9023 if (map->n == 0)
9024 return map;
9025 map = isl_map_compute_divs(map);
9026 map = isl_map_cow(map);
9027 if (!map)
9028 return NULL;
9030 for (i = 1; i < map->n; ++i)
9031 map->p[0] = isl_basic_map_align_divs(map->p[0], map->p[i]);
9032 for (i = 1; i < map->n; ++i) {
9033 map->p[i] = isl_basic_map_align_divs(map->p[i], map->p[0]);
9034 if (!map->p[i])
9035 return isl_map_free(map);
9038 map = isl_map_unmark_normalized(map);
9039 return map;
9042 __isl_give isl_map *isl_map_align_divs(__isl_take isl_map *map)
9044 return isl_map_align_divs_internal(map);
9047 struct isl_set *isl_set_align_divs(struct isl_set *set)
9049 return set_from_map(isl_map_align_divs_internal(set_to_map(set)));
9052 /* Align the divs of the basic maps in "map" to those
9053 * of the basic maps in "list", as well as to the other basic maps in "map".
9054 * The elements in "list" are assumed to have known divs.
9056 __isl_give isl_map *isl_map_align_divs_to_basic_map_list(
9057 __isl_take isl_map *map, __isl_keep isl_basic_map_list *list)
9059 int i, n;
9061 map = isl_map_compute_divs(map);
9062 map = isl_map_cow(map);
9063 if (!map || !list)
9064 return isl_map_free(map);
9065 if (map->n == 0)
9066 return map;
9068 n = isl_basic_map_list_n_basic_map(list);
9069 for (i = 0; i < n; ++i) {
9070 isl_basic_map *bmap;
9072 bmap = isl_basic_map_list_get_basic_map(list, i);
9073 map->p[0] = isl_basic_map_align_divs(map->p[0], bmap);
9074 isl_basic_map_free(bmap);
9076 if (!map->p[0])
9077 return isl_map_free(map);
9079 return isl_map_align_divs_internal(map);
9082 /* Align the divs of each element of "list" to those of "bmap".
9083 * Both "bmap" and the elements of "list" are assumed to have known divs.
9085 __isl_give isl_basic_map_list *isl_basic_map_list_align_divs_to_basic_map(
9086 __isl_take isl_basic_map_list *list, __isl_keep isl_basic_map *bmap)
9088 int i, n;
9090 if (!list || !bmap)
9091 return isl_basic_map_list_free(list);
9093 n = isl_basic_map_list_n_basic_map(list);
9094 for (i = 0; i < n; ++i) {
9095 isl_basic_map *bmap_i;
9097 bmap_i = isl_basic_map_list_get_basic_map(list, i);
9098 bmap_i = isl_basic_map_align_divs(bmap_i, bmap);
9099 list = isl_basic_map_list_set_basic_map(list, i, bmap_i);
9102 return list;
9105 static __isl_give isl_set *set_apply( __isl_take isl_set *set,
9106 __isl_take isl_map *map)
9108 isl_bool ok;
9110 ok = isl_map_compatible_domain(map, set);
9111 if (ok < 0)
9112 goto error;
9113 if (!ok)
9114 isl_die(isl_set_get_ctx(set), isl_error_invalid,
9115 "incompatible spaces", goto error);
9116 map = isl_map_intersect_domain(map, set);
9117 set = isl_map_range(map);
9118 return set;
9119 error:
9120 isl_set_free(set);
9121 isl_map_free(map);
9122 return NULL;
9125 __isl_give isl_set *isl_set_apply( __isl_take isl_set *set,
9126 __isl_take isl_map *map)
9128 return isl_map_align_params_map_map_and(set, map, &set_apply);
9131 /* There is no need to cow as removing empty parts doesn't change
9132 * the meaning of the set.
9134 __isl_give isl_map *isl_map_remove_empty_parts(__isl_take isl_map *map)
9136 int i;
9138 if (!map)
9139 return NULL;
9141 for (i = map->n - 1; i >= 0; --i)
9142 map = remove_if_empty(map, i);
9144 return map;
9147 struct isl_set *isl_set_remove_empty_parts(struct isl_set *set)
9149 return set_from_map(isl_map_remove_empty_parts(set_to_map(set)));
9152 /* Create a binary relation that maps the shared initial "pos" dimensions
9153 * of "bset1" and "bset2" to the remaining dimensions of "bset1" and "bset2".
9155 static __isl_give isl_basic_map *join_initial(__isl_keep isl_basic_set *bset1,
9156 __isl_keep isl_basic_set *bset2, int pos)
9158 isl_basic_map *bmap1;
9159 isl_basic_map *bmap2;
9161 bmap1 = isl_basic_map_from_range(isl_basic_set_copy(bset1));
9162 bmap2 = isl_basic_map_from_range(isl_basic_set_copy(bset2));
9163 bmap1 = isl_basic_map_move_dims(bmap1, isl_dim_in, 0,
9164 isl_dim_out, 0, pos);
9165 bmap2 = isl_basic_map_move_dims(bmap2, isl_dim_in, 0,
9166 isl_dim_out, 0, pos);
9167 return isl_basic_map_range_product(bmap1, bmap2);
9170 /* Given two basic sets bset1 and bset2, compute the maximal difference
9171 * between the values of dimension pos in bset1 and those in bset2
9172 * for any common value of the parameters and dimensions preceding pos.
9174 static enum isl_lp_result basic_set_maximal_difference_at(
9175 __isl_keep isl_basic_set *bset1, __isl_keep isl_basic_set *bset2,
9176 int pos, isl_int *opt)
9178 isl_basic_map *bmap1;
9179 struct isl_ctx *ctx;
9180 struct isl_vec *obj;
9181 unsigned total;
9182 unsigned nparam;
9183 unsigned dim1;
9184 enum isl_lp_result res;
9186 if (!bset1 || !bset2)
9187 return isl_lp_error;
9189 nparam = isl_basic_set_n_param(bset1);
9190 dim1 = isl_basic_set_n_dim(bset1);
9192 bmap1 = join_initial(bset1, bset2, pos);
9193 if (!bmap1)
9194 return isl_lp_error;
9196 total = isl_basic_map_total_dim(bmap1);
9197 ctx = bmap1->ctx;
9198 obj = isl_vec_alloc(ctx, 1 + total);
9199 if (!obj)
9200 goto error;
9201 isl_seq_clr(obj->block.data, 1 + total);
9202 isl_int_set_si(obj->block.data[1+nparam+pos], 1);
9203 isl_int_set_si(obj->block.data[1+nparam+pos+(dim1-pos)], -1);
9204 res = isl_basic_map_solve_lp(bmap1, 1, obj->block.data, ctx->one,
9205 opt, NULL, NULL);
9206 isl_basic_map_free(bmap1);
9207 isl_vec_free(obj);
9208 return res;
9209 error:
9210 isl_basic_map_free(bmap1);
9211 return isl_lp_error;
9214 /* Given two _disjoint_ basic sets bset1 and bset2, check whether
9215 * for any common value of the parameters and dimensions preceding pos
9216 * in both basic sets, the values of dimension pos in bset1 are
9217 * smaller or larger than those in bset2.
9219 * Returns
9220 * 1 if bset1 follows bset2
9221 * -1 if bset1 precedes bset2
9222 * 0 if bset1 and bset2 are incomparable
9223 * -2 if some error occurred.
9225 int isl_basic_set_compare_at(struct isl_basic_set *bset1,
9226 struct isl_basic_set *bset2, int pos)
9228 isl_int opt;
9229 enum isl_lp_result res;
9230 int cmp;
9232 isl_int_init(opt);
9234 res = basic_set_maximal_difference_at(bset1, bset2, pos, &opt);
9236 if (res == isl_lp_empty)
9237 cmp = 0;
9238 else if ((res == isl_lp_ok && isl_int_is_pos(opt)) ||
9239 res == isl_lp_unbounded)
9240 cmp = 1;
9241 else if (res == isl_lp_ok && isl_int_is_neg(opt))
9242 cmp = -1;
9243 else
9244 cmp = -2;
9246 isl_int_clear(opt);
9247 return cmp;
9250 /* Given two basic sets bset1 and bset2, check whether
9251 * for any common value of the parameters and dimensions preceding pos
9252 * there is a value of dimension pos in bset1 that is larger
9253 * than a value of the same dimension in bset2.
9255 * Return
9256 * 1 if there exists such a pair
9257 * 0 if there is no such pair, but there is a pair of equal values
9258 * -1 otherwise
9259 * -2 if some error occurred.
9261 int isl_basic_set_follows_at(__isl_keep isl_basic_set *bset1,
9262 __isl_keep isl_basic_set *bset2, int pos)
9264 isl_bool empty;
9265 isl_basic_map *bmap;
9266 unsigned dim1;
9268 dim1 = isl_basic_set_dim(bset1, isl_dim_set);
9269 bmap = join_initial(bset1, bset2, pos);
9270 bmap = isl_basic_map_order_ge(bmap, isl_dim_out, 0,
9271 isl_dim_out, dim1 - pos);
9272 empty = isl_basic_map_is_empty(bmap);
9273 if (empty < 0)
9274 goto error;
9275 if (empty) {
9276 isl_basic_map_free(bmap);
9277 return -1;
9279 bmap = isl_basic_map_order_gt(bmap, isl_dim_out, 0,
9280 isl_dim_out, dim1 - pos);
9281 empty = isl_basic_map_is_empty(bmap);
9282 if (empty < 0)
9283 goto error;
9284 isl_basic_map_free(bmap);
9285 if (empty)
9286 return 0;
9287 return 1;
9288 error:
9289 isl_basic_map_free(bmap);
9290 return -2;
9293 /* Given two sets set1 and set2, check whether
9294 * for any common value of the parameters and dimensions preceding pos
9295 * there is a value of dimension pos in set1 that is larger
9296 * than a value of the same dimension in set2.
9298 * Return
9299 * 1 if there exists such a pair
9300 * 0 if there is no such pair, but there is a pair of equal values
9301 * -1 otherwise
9302 * -2 if some error occurred.
9304 int isl_set_follows_at(__isl_keep isl_set *set1,
9305 __isl_keep isl_set *set2, int pos)
9307 int i, j;
9308 int follows = -1;
9310 if (!set1 || !set2)
9311 return -2;
9313 for (i = 0; i < set1->n; ++i)
9314 for (j = 0; j < set2->n; ++j) {
9315 int f;
9316 f = isl_basic_set_follows_at(set1->p[i], set2->p[j], pos);
9317 if (f == 1 || f == -2)
9318 return f;
9319 if (f > follows)
9320 follows = f;
9323 return follows;
9326 static isl_bool isl_basic_map_plain_has_fixed_var(
9327 __isl_keep isl_basic_map *bmap, unsigned pos, isl_int *val)
9329 int i;
9330 int d;
9331 unsigned total;
9333 if (!bmap)
9334 return isl_bool_error;
9335 total = isl_basic_map_total_dim(bmap);
9336 for (i = 0, d = total-1; i < bmap->n_eq && d+1 > pos; ++i) {
9337 for (; d+1 > pos; --d)
9338 if (!isl_int_is_zero(bmap->eq[i][1+d]))
9339 break;
9340 if (d != pos)
9341 continue;
9342 if (isl_seq_first_non_zero(bmap->eq[i]+1, d) != -1)
9343 return isl_bool_false;
9344 if (isl_seq_first_non_zero(bmap->eq[i]+1+d+1, total-d-1) != -1)
9345 return isl_bool_false;
9346 if (!isl_int_is_one(bmap->eq[i][1+d]))
9347 return isl_bool_false;
9348 if (val)
9349 isl_int_neg(*val, bmap->eq[i][0]);
9350 return isl_bool_true;
9352 return isl_bool_false;
9355 static isl_bool isl_map_plain_has_fixed_var(__isl_keep isl_map *map,
9356 unsigned pos, isl_int *val)
9358 int i;
9359 isl_int v;
9360 isl_int tmp;
9361 isl_bool fixed;
9363 if (!map)
9364 return isl_bool_error;
9365 if (map->n == 0)
9366 return isl_bool_false;
9367 if (map->n == 1)
9368 return isl_basic_map_plain_has_fixed_var(map->p[0], pos, val);
9369 isl_int_init(v);
9370 isl_int_init(tmp);
9371 fixed = isl_basic_map_plain_has_fixed_var(map->p[0], pos, &v);
9372 for (i = 1; fixed == isl_bool_true && i < map->n; ++i) {
9373 fixed = isl_basic_map_plain_has_fixed_var(map->p[i], pos, &tmp);
9374 if (fixed == isl_bool_true && isl_int_ne(tmp, v))
9375 fixed = isl_bool_false;
9377 if (val)
9378 isl_int_set(*val, v);
9379 isl_int_clear(tmp);
9380 isl_int_clear(v);
9381 return fixed;
9384 static isl_bool isl_basic_set_plain_has_fixed_var(
9385 __isl_keep isl_basic_set *bset, unsigned pos, isl_int *val)
9387 return isl_basic_map_plain_has_fixed_var(bset_to_bmap(bset),
9388 pos, val);
9391 isl_bool isl_basic_map_plain_is_fixed(__isl_keep isl_basic_map *bmap,
9392 enum isl_dim_type type, unsigned pos, isl_int *val)
9394 if (isl_basic_map_check_range(bmap, type, pos, 1) < 0)
9395 return isl_bool_error;
9396 return isl_basic_map_plain_has_fixed_var(bmap,
9397 isl_basic_map_offset(bmap, type) - 1 + pos, val);
9400 /* If "bmap" obviously lies on a hyperplane where the given dimension
9401 * has a fixed value, then return that value.
9402 * Otherwise return NaN.
9404 __isl_give isl_val *isl_basic_map_plain_get_val_if_fixed(
9405 __isl_keep isl_basic_map *bmap,
9406 enum isl_dim_type type, unsigned pos)
9408 isl_ctx *ctx;
9409 isl_val *v;
9410 isl_bool fixed;
9412 if (!bmap)
9413 return NULL;
9414 ctx = isl_basic_map_get_ctx(bmap);
9415 v = isl_val_alloc(ctx);
9416 if (!v)
9417 return NULL;
9418 fixed = isl_basic_map_plain_is_fixed(bmap, type, pos, &v->n);
9419 if (fixed < 0)
9420 return isl_val_free(v);
9421 if (fixed) {
9422 isl_int_set_si(v->d, 1);
9423 return v;
9425 isl_val_free(v);
9426 return isl_val_nan(ctx);
9429 isl_bool isl_map_plain_is_fixed(__isl_keep isl_map *map,
9430 enum isl_dim_type type, unsigned pos, isl_int *val)
9432 if (pos >= isl_map_dim(map, type))
9433 isl_die(isl_map_get_ctx(map), isl_error_invalid,
9434 "position out of bounds", return isl_bool_error);
9435 return isl_map_plain_has_fixed_var(map,
9436 map_offset(map, type) - 1 + pos, val);
9439 /* If "map" obviously lies on a hyperplane where the given dimension
9440 * has a fixed value, then return that value.
9441 * Otherwise return NaN.
9443 __isl_give isl_val *isl_map_plain_get_val_if_fixed(__isl_keep isl_map *map,
9444 enum isl_dim_type type, unsigned pos)
9446 isl_ctx *ctx;
9447 isl_val *v;
9448 isl_bool fixed;
9450 if (!map)
9451 return NULL;
9452 ctx = isl_map_get_ctx(map);
9453 v = isl_val_alloc(ctx);
9454 if (!v)
9455 return NULL;
9456 fixed = isl_map_plain_is_fixed(map, type, pos, &v->n);
9457 if (fixed < 0)
9458 return isl_val_free(v);
9459 if (fixed) {
9460 isl_int_set_si(v->d, 1);
9461 return v;
9463 isl_val_free(v);
9464 return isl_val_nan(ctx);
9467 /* If "set" obviously lies on a hyperplane where the given dimension
9468 * has a fixed value, then return that value.
9469 * Otherwise return NaN.
9471 __isl_give isl_val *isl_set_plain_get_val_if_fixed(__isl_keep isl_set *set,
9472 enum isl_dim_type type, unsigned pos)
9474 return isl_map_plain_get_val_if_fixed(set, type, pos);
9477 /* Check if dimension dim has fixed value and if so and if val is not NULL,
9478 * then return this fixed value in *val.
9480 isl_bool isl_basic_set_plain_dim_is_fixed(__isl_keep isl_basic_set *bset,
9481 unsigned dim, isl_int *val)
9483 return isl_basic_set_plain_has_fixed_var(bset,
9484 isl_basic_set_n_param(bset) + dim, val);
9487 /* Return -1 if the constraint "c1" should be sorted before "c2"
9488 * and 1 if it should be sorted after "c2".
9489 * Return 0 if the two constraints are the same (up to the constant term).
9491 * In particular, if a constraint involves later variables than another
9492 * then it is sorted after this other constraint.
9493 * uset_gist depends on constraints without existentially quantified
9494 * variables sorting first.
9496 * For constraints that have the same latest variable, those
9497 * with the same coefficient for this latest variable (first in absolute value
9498 * and then in actual value) are grouped together.
9499 * This is useful for detecting pairs of constraints that can
9500 * be chained in their printed representation.
9502 * Finally, within a group, constraints are sorted according to
9503 * their coefficients (excluding the constant term).
9505 static int sort_constraint_cmp(const void *p1, const void *p2, void *arg)
9507 isl_int **c1 = (isl_int **) p1;
9508 isl_int **c2 = (isl_int **) p2;
9509 int l1, l2;
9510 unsigned size = *(unsigned *) arg;
9511 int cmp;
9513 l1 = isl_seq_last_non_zero(*c1 + 1, size);
9514 l2 = isl_seq_last_non_zero(*c2 + 1, size);
9516 if (l1 != l2)
9517 return l1 - l2;
9519 cmp = isl_int_abs_cmp((*c1)[1 + l1], (*c2)[1 + l1]);
9520 if (cmp != 0)
9521 return cmp;
9522 cmp = isl_int_cmp((*c1)[1 + l1], (*c2)[1 + l1]);
9523 if (cmp != 0)
9524 return -cmp;
9526 return isl_seq_cmp(*c1 + 1, *c2 + 1, size);
9529 /* Return -1 if the constraint "c1" of "bmap" is sorted before "c2"
9530 * by isl_basic_map_sort_constraints, 1 if it is sorted after "c2"
9531 * and 0 if the two constraints are the same (up to the constant term).
9533 int isl_basic_map_constraint_cmp(__isl_keep isl_basic_map *bmap,
9534 isl_int *c1, isl_int *c2)
9536 unsigned total;
9538 if (!bmap)
9539 return -2;
9540 total = isl_basic_map_total_dim(bmap);
9541 return sort_constraint_cmp(&c1, &c2, &total);
9544 __isl_give isl_basic_map *isl_basic_map_sort_constraints(
9545 __isl_take isl_basic_map *bmap)
9547 unsigned total;
9549 if (!bmap)
9550 return NULL;
9551 if (bmap->n_ineq == 0)
9552 return bmap;
9553 if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_NORMALIZED))
9554 return bmap;
9555 total = isl_basic_map_total_dim(bmap);
9556 if (isl_sort(bmap->ineq, bmap->n_ineq, sizeof(isl_int *),
9557 &sort_constraint_cmp, &total) < 0)
9558 return isl_basic_map_free(bmap);
9559 return bmap;
9562 __isl_give isl_basic_set *isl_basic_set_sort_constraints(
9563 __isl_take isl_basic_set *bset)
9565 isl_basic_map *bmap = bset_to_bmap(bset);
9566 return bset_from_bmap(isl_basic_map_sort_constraints(bmap));
9569 __isl_give isl_basic_map *isl_basic_map_normalize(
9570 __isl_take isl_basic_map *bmap)
9572 if (!bmap)
9573 return NULL;
9574 if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_NORMALIZED))
9575 return bmap;
9576 bmap = isl_basic_map_remove_redundancies(bmap);
9577 bmap = isl_basic_map_sort_constraints(bmap);
9578 if (bmap)
9579 ISL_F_SET(bmap, ISL_BASIC_MAP_NORMALIZED);
9580 return bmap;
9582 int isl_basic_map_plain_cmp(__isl_keep isl_basic_map *bmap1,
9583 __isl_keep isl_basic_map *bmap2)
9585 int i, cmp;
9586 unsigned total;
9587 isl_space *space1, *space2;
9589 if (!bmap1 || !bmap2)
9590 return -1;
9592 if (bmap1 == bmap2)
9593 return 0;
9594 space1 = isl_basic_map_peek_space(bmap1);
9595 space2 = isl_basic_map_peek_space(bmap2);
9596 cmp = isl_space_cmp(space1, space2);
9597 if (cmp)
9598 return cmp;
9599 if (ISL_F_ISSET(bmap1, ISL_BASIC_MAP_RATIONAL) !=
9600 ISL_F_ISSET(bmap2, ISL_BASIC_MAP_RATIONAL))
9601 return ISL_F_ISSET(bmap1, ISL_BASIC_MAP_RATIONAL) ? -1 : 1;
9602 if (ISL_F_ISSET(bmap1, ISL_BASIC_MAP_EMPTY) &&
9603 ISL_F_ISSET(bmap2, ISL_BASIC_MAP_EMPTY))
9604 return 0;
9605 if (ISL_F_ISSET(bmap1, ISL_BASIC_MAP_EMPTY))
9606 return 1;
9607 if (ISL_F_ISSET(bmap2, ISL_BASIC_MAP_EMPTY))
9608 return -1;
9609 if (bmap1->n_eq != bmap2->n_eq)
9610 return bmap1->n_eq - bmap2->n_eq;
9611 if (bmap1->n_ineq != bmap2->n_ineq)
9612 return bmap1->n_ineq - bmap2->n_ineq;
9613 if (bmap1->n_div != bmap2->n_div)
9614 return bmap1->n_div - bmap2->n_div;
9615 total = isl_basic_map_total_dim(bmap1);
9616 for (i = 0; i < bmap1->n_eq; ++i) {
9617 cmp = isl_seq_cmp(bmap1->eq[i], bmap2->eq[i], 1+total);
9618 if (cmp)
9619 return cmp;
9621 for (i = 0; i < bmap1->n_ineq; ++i) {
9622 cmp = isl_seq_cmp(bmap1->ineq[i], bmap2->ineq[i], 1+total);
9623 if (cmp)
9624 return cmp;
9626 for (i = 0; i < bmap1->n_div; ++i) {
9627 cmp = isl_seq_cmp(bmap1->div[i], bmap2->div[i], 1+1+total);
9628 if (cmp)
9629 return cmp;
9631 return 0;
9634 int isl_basic_set_plain_cmp(__isl_keep isl_basic_set *bset1,
9635 __isl_keep isl_basic_set *bset2)
9637 return isl_basic_map_plain_cmp(bset1, bset2);
9640 int isl_set_plain_cmp(__isl_keep isl_set *set1, __isl_keep isl_set *set2)
9642 int i, cmp;
9644 if (set1 == set2)
9645 return 0;
9646 if (set1->n != set2->n)
9647 return set1->n - set2->n;
9649 for (i = 0; i < set1->n; ++i) {
9650 cmp = isl_basic_set_plain_cmp(set1->p[i], set2->p[i]);
9651 if (cmp)
9652 return cmp;
9655 return 0;
9658 isl_bool isl_basic_map_plain_is_equal(__isl_keep isl_basic_map *bmap1,
9659 __isl_keep isl_basic_map *bmap2)
9661 if (!bmap1 || !bmap2)
9662 return isl_bool_error;
9663 return isl_basic_map_plain_cmp(bmap1, bmap2) == 0;
9666 isl_bool isl_basic_set_plain_is_equal(__isl_keep isl_basic_set *bset1,
9667 __isl_keep isl_basic_set *bset2)
9669 return isl_basic_map_plain_is_equal(bset_to_bmap(bset1),
9670 bset_to_bmap(bset2));
9673 static int qsort_bmap_cmp(const void *p1, const void *p2)
9675 isl_basic_map *bmap1 = *(isl_basic_map **) p1;
9676 isl_basic_map *bmap2 = *(isl_basic_map **) p2;
9678 return isl_basic_map_plain_cmp(bmap1, bmap2);
9681 /* Sort the basic maps of "map" and remove duplicate basic maps.
9683 * While removing basic maps, we make sure that the basic maps remain
9684 * sorted because isl_map_normalize expects the basic maps of the result
9685 * to be sorted.
9687 static __isl_give isl_map *sort_and_remove_duplicates(__isl_take isl_map *map)
9689 int i, j;
9691 map = isl_map_remove_empty_parts(map);
9692 if (!map)
9693 return NULL;
9694 qsort(map->p, map->n, sizeof(struct isl_basic_map *), qsort_bmap_cmp);
9695 for (i = map->n - 1; i >= 1; --i) {
9696 if (!isl_basic_map_plain_is_equal(map->p[i - 1], map->p[i]))
9697 continue;
9698 isl_basic_map_free(map->p[i-1]);
9699 for (j = i; j < map->n; ++j)
9700 map->p[j - 1] = map->p[j];
9701 map->n--;
9704 return map;
9707 /* Remove obvious duplicates among the basic maps of "map".
9709 * Unlike isl_map_normalize, this function does not remove redundant
9710 * constraints and only removes duplicates that have exactly the same
9711 * constraints in the input. It does sort the constraints and
9712 * the basic maps to ease the detection of duplicates.
9714 * If "map" has already been normalized or if the basic maps are
9715 * disjoint, then there can be no duplicates.
9717 __isl_give isl_map *isl_map_remove_obvious_duplicates(__isl_take isl_map *map)
9719 int i;
9720 isl_basic_map *bmap;
9722 if (!map)
9723 return NULL;
9724 if (map->n <= 1)
9725 return map;
9726 if (ISL_F_ISSET(map, ISL_MAP_NORMALIZED | ISL_MAP_DISJOINT))
9727 return map;
9728 for (i = 0; i < map->n; ++i) {
9729 bmap = isl_basic_map_copy(map->p[i]);
9730 bmap = isl_basic_map_sort_constraints(bmap);
9731 if (!bmap)
9732 return isl_map_free(map);
9733 isl_basic_map_free(map->p[i]);
9734 map->p[i] = bmap;
9737 map = sort_and_remove_duplicates(map);
9738 return map;
9741 /* We normalize in place, but if anything goes wrong we need
9742 * to return NULL, so we need to make sure we don't change the
9743 * meaning of any possible other copies of map.
9745 __isl_give isl_map *isl_map_normalize(__isl_take isl_map *map)
9747 int i;
9748 struct isl_basic_map *bmap;
9750 if (!map)
9751 return NULL;
9752 if (ISL_F_ISSET(map, ISL_MAP_NORMALIZED))
9753 return map;
9754 for (i = 0; i < map->n; ++i) {
9755 bmap = isl_basic_map_normalize(isl_basic_map_copy(map->p[i]));
9756 if (!bmap)
9757 goto error;
9758 isl_basic_map_free(map->p[i]);
9759 map->p[i] = bmap;
9762 map = sort_and_remove_duplicates(map);
9763 if (map)
9764 ISL_F_SET(map, ISL_MAP_NORMALIZED);
9765 return map;
9766 error:
9767 isl_map_free(map);
9768 return NULL;
9771 struct isl_set *isl_set_normalize(struct isl_set *set)
9773 return set_from_map(isl_map_normalize(set_to_map(set)));
9776 isl_bool isl_map_plain_is_equal(__isl_keep isl_map *map1,
9777 __isl_keep isl_map *map2)
9779 int i;
9780 isl_bool equal;
9782 if (!map1 || !map2)
9783 return isl_bool_error;
9785 if (map1 == map2)
9786 return isl_bool_true;
9787 if (!isl_space_is_equal(map1->dim, map2->dim))
9788 return isl_bool_false;
9790 map1 = isl_map_copy(map1);
9791 map2 = isl_map_copy(map2);
9792 map1 = isl_map_normalize(map1);
9793 map2 = isl_map_normalize(map2);
9794 if (!map1 || !map2)
9795 goto error;
9796 equal = map1->n == map2->n;
9797 for (i = 0; equal && i < map1->n; ++i) {
9798 equal = isl_basic_map_plain_is_equal(map1->p[i], map2->p[i]);
9799 if (equal < 0)
9800 goto error;
9802 isl_map_free(map1);
9803 isl_map_free(map2);
9804 return equal;
9805 error:
9806 isl_map_free(map1);
9807 isl_map_free(map2);
9808 return isl_bool_error;
9811 isl_bool isl_set_plain_is_equal(__isl_keep isl_set *set1,
9812 __isl_keep isl_set *set2)
9814 return isl_map_plain_is_equal(set_to_map(set1), set_to_map(set2));
9817 /* Return the basic maps in "map" as a list.
9819 __isl_give isl_basic_map_list *isl_map_get_basic_map_list(
9820 __isl_keep isl_map *map)
9822 int i;
9823 isl_ctx *ctx;
9824 isl_basic_map_list *list;
9826 if (!map)
9827 return NULL;
9828 ctx = isl_map_get_ctx(map);
9829 list = isl_basic_map_list_alloc(ctx, map->n);
9831 for (i = 0; i < map->n; ++i) {
9832 isl_basic_map *bmap;
9834 bmap = isl_basic_map_copy(map->p[i]);
9835 list = isl_basic_map_list_add(list, bmap);
9838 return list;
9841 /* Return the intersection of the elements in the non-empty list "list".
9842 * All elements are assumed to live in the same space.
9844 __isl_give isl_basic_map *isl_basic_map_list_intersect(
9845 __isl_take isl_basic_map_list *list)
9847 int i, n;
9848 isl_basic_map *bmap;
9850 if (!list)
9851 return NULL;
9852 n = isl_basic_map_list_n_basic_map(list);
9853 if (n < 1)
9854 isl_die(isl_basic_map_list_get_ctx(list), isl_error_invalid,
9855 "expecting non-empty list", goto error);
9857 bmap = isl_basic_map_list_get_basic_map(list, 0);
9858 for (i = 1; i < n; ++i) {
9859 isl_basic_map *bmap_i;
9861 bmap_i = isl_basic_map_list_get_basic_map(list, i);
9862 bmap = isl_basic_map_intersect(bmap, bmap_i);
9865 isl_basic_map_list_free(list);
9866 return bmap;
9867 error:
9868 isl_basic_map_list_free(list);
9869 return NULL;
9872 /* Return the intersection of the elements in the non-empty list "list".
9873 * All elements are assumed to live in the same space.
9875 __isl_give isl_basic_set *isl_basic_set_list_intersect(
9876 __isl_take isl_basic_set_list *list)
9878 return isl_basic_map_list_intersect(list);
9881 /* Return the union of the elements of "list".
9882 * The list is required to have at least one element.
9884 __isl_give isl_set *isl_basic_set_list_union(
9885 __isl_take isl_basic_set_list *list)
9887 int i, n;
9888 isl_space *space;
9889 isl_basic_set *bset;
9890 isl_set *set;
9892 if (!list)
9893 return NULL;
9894 n = isl_basic_set_list_n_basic_set(list);
9895 if (n < 1)
9896 isl_die(isl_basic_set_list_get_ctx(list), isl_error_invalid,
9897 "expecting non-empty list", goto error);
9899 bset = isl_basic_set_list_get_basic_set(list, 0);
9900 space = isl_basic_set_get_space(bset);
9901 isl_basic_set_free(bset);
9903 set = isl_set_alloc_space(space, n, 0);
9904 for (i = 0; i < n; ++i) {
9905 bset = isl_basic_set_list_get_basic_set(list, i);
9906 set = isl_set_add_basic_set(set, bset);
9909 isl_basic_set_list_free(list);
9910 return set;
9911 error:
9912 isl_basic_set_list_free(list);
9913 return NULL;
9916 /* Return the union of the elements in the non-empty list "list".
9917 * All elements are assumed to live in the same space.
9919 __isl_give isl_set *isl_set_list_union(__isl_take isl_set_list *list)
9921 int i, n;
9922 isl_set *set;
9924 if (!list)
9925 return NULL;
9926 n = isl_set_list_n_set(list);
9927 if (n < 1)
9928 isl_die(isl_set_list_get_ctx(list), isl_error_invalid,
9929 "expecting non-empty list", goto error);
9931 set = isl_set_list_get_set(list, 0);
9932 for (i = 1; i < n; ++i) {
9933 isl_set *set_i;
9935 set_i = isl_set_list_get_set(list, i);
9936 set = isl_set_union(set, set_i);
9939 isl_set_list_free(list);
9940 return set;
9941 error:
9942 isl_set_list_free(list);
9943 return NULL;
9946 __isl_give isl_basic_map *isl_basic_map_product(
9947 __isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2)
9949 isl_space *dim_result = NULL;
9950 struct isl_basic_map *bmap;
9951 unsigned in1, in2, out1, out2, nparam, total, pos;
9952 struct isl_dim_map *dim_map1, *dim_map2;
9954 if (isl_basic_map_check_equal_params(bmap1, bmap2) < 0)
9955 goto error;
9956 dim_result = isl_space_product(isl_space_copy(bmap1->dim),
9957 isl_space_copy(bmap2->dim));
9959 in1 = isl_basic_map_dim(bmap1, isl_dim_in);
9960 in2 = isl_basic_map_dim(bmap2, isl_dim_in);
9961 out1 = isl_basic_map_dim(bmap1, isl_dim_out);
9962 out2 = isl_basic_map_dim(bmap2, isl_dim_out);
9963 nparam = isl_basic_map_dim(bmap1, isl_dim_param);
9965 total = nparam + in1 + in2 + out1 + out2 + bmap1->n_div + bmap2->n_div;
9966 dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
9967 dim_map2 = isl_dim_map_alloc(bmap1->ctx, total);
9968 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
9969 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos = 0);
9970 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
9971 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos += in1);
9972 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += in2);
9973 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos += out1);
9974 isl_dim_map_div(dim_map1, bmap1, pos += out2);
9975 isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
9977 bmap = isl_basic_map_alloc_space(dim_result,
9978 bmap1->n_div + bmap2->n_div,
9979 bmap1->n_eq + bmap2->n_eq,
9980 bmap1->n_ineq + bmap2->n_ineq);
9981 bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap1, dim_map1);
9982 bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap2, dim_map2);
9983 bmap = isl_basic_map_simplify(bmap);
9984 return isl_basic_map_finalize(bmap);
9985 error:
9986 isl_basic_map_free(bmap1);
9987 isl_basic_map_free(bmap2);
9988 return NULL;
9991 __isl_give isl_basic_map *isl_basic_map_flat_product(
9992 __isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2)
9994 isl_basic_map *prod;
9996 prod = isl_basic_map_product(bmap1, bmap2);
9997 prod = isl_basic_map_flatten(prod);
9998 return prod;
10001 __isl_give isl_basic_set *isl_basic_set_flat_product(
10002 __isl_take isl_basic_set *bset1, __isl_take isl_basic_set *bset2)
10004 return isl_basic_map_flat_range_product(bset1, bset2);
10007 __isl_give isl_basic_map *isl_basic_map_domain_product(
10008 __isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2)
10010 isl_space *space_result = NULL;
10011 isl_basic_map *bmap;
10012 unsigned in1, in2, out, nparam, total, pos;
10013 struct isl_dim_map *dim_map1, *dim_map2;
10015 if (!bmap1 || !bmap2)
10016 goto error;
10018 space_result = isl_space_domain_product(isl_space_copy(bmap1->dim),
10019 isl_space_copy(bmap2->dim));
10021 in1 = isl_basic_map_dim(bmap1, isl_dim_in);
10022 in2 = isl_basic_map_dim(bmap2, isl_dim_in);
10023 out = isl_basic_map_dim(bmap1, isl_dim_out);
10024 nparam = isl_basic_map_dim(bmap1, isl_dim_param);
10026 total = nparam + in1 + in2 + out + bmap1->n_div + bmap2->n_div;
10027 dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
10028 dim_map2 = isl_dim_map_alloc(bmap1->ctx, total);
10029 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
10030 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos = 0);
10031 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
10032 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos += in1);
10033 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += in2);
10034 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos);
10035 isl_dim_map_div(dim_map1, bmap1, pos += out);
10036 isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
10038 bmap = isl_basic_map_alloc_space(space_result,
10039 bmap1->n_div + bmap2->n_div,
10040 bmap1->n_eq + bmap2->n_eq,
10041 bmap1->n_ineq + bmap2->n_ineq);
10042 bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap1, dim_map1);
10043 bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap2, dim_map2);
10044 bmap = isl_basic_map_simplify(bmap);
10045 return isl_basic_map_finalize(bmap);
10046 error:
10047 isl_basic_map_free(bmap1);
10048 isl_basic_map_free(bmap2);
10049 return NULL;
10052 __isl_give isl_basic_map *isl_basic_map_range_product(
10053 __isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2)
10055 isl_bool rational;
10056 isl_space *dim_result = NULL;
10057 isl_basic_map *bmap;
10058 unsigned in, out1, out2, nparam, total, pos;
10059 struct isl_dim_map *dim_map1, *dim_map2;
10061 rational = isl_basic_map_is_rational(bmap1);
10062 if (rational >= 0 && rational)
10063 rational = isl_basic_map_is_rational(bmap2);
10064 if (!bmap1 || !bmap2 || rational < 0)
10065 goto error;
10067 if (isl_basic_map_check_equal_params(bmap1, bmap2) < 0)
10068 goto error;
10070 dim_result = isl_space_range_product(isl_space_copy(bmap1->dim),
10071 isl_space_copy(bmap2->dim));
10073 in = isl_basic_map_dim(bmap1, isl_dim_in);
10074 out1 = isl_basic_map_dim(bmap1, isl_dim_out);
10075 out2 = isl_basic_map_dim(bmap2, isl_dim_out);
10076 nparam = isl_basic_map_dim(bmap1, isl_dim_param);
10078 total = nparam + in + out1 + out2 + bmap1->n_div + bmap2->n_div;
10079 dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
10080 dim_map2 = isl_dim_map_alloc(bmap1->ctx, total);
10081 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
10082 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos = 0);
10083 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
10084 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos);
10085 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += in);
10086 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos += out1);
10087 isl_dim_map_div(dim_map1, bmap1, pos += out2);
10088 isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
10090 bmap = isl_basic_map_alloc_space(dim_result,
10091 bmap1->n_div + bmap2->n_div,
10092 bmap1->n_eq + bmap2->n_eq,
10093 bmap1->n_ineq + bmap2->n_ineq);
10094 bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap1, dim_map1);
10095 bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap2, dim_map2);
10096 if (rational)
10097 bmap = isl_basic_map_set_rational(bmap);
10098 bmap = isl_basic_map_simplify(bmap);
10099 return isl_basic_map_finalize(bmap);
10100 error:
10101 isl_basic_map_free(bmap1);
10102 isl_basic_map_free(bmap2);
10103 return NULL;
10106 __isl_give isl_basic_map *isl_basic_map_flat_range_product(
10107 __isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2)
10109 isl_basic_map *prod;
10111 prod = isl_basic_map_range_product(bmap1, bmap2);
10112 prod = isl_basic_map_flatten_range(prod);
10113 return prod;
10116 /* Apply "basic_map_product" to each pair of basic maps in "map1" and "map2"
10117 * and collect the results.
10118 * The result live in the space obtained by calling "space_product"
10119 * on the spaces of "map1" and "map2".
10120 * If "remove_duplicates" is set then the result may contain duplicates
10121 * (even if the inputs do not) and so we try and remove the obvious
10122 * duplicates.
10124 static __isl_give isl_map *map_product(__isl_take isl_map *map1,
10125 __isl_take isl_map *map2,
10126 __isl_give isl_space *(*space_product)(__isl_take isl_space *left,
10127 __isl_take isl_space *right),
10128 __isl_give isl_basic_map *(*basic_map_product)(
10129 __isl_take isl_basic_map *left,
10130 __isl_take isl_basic_map *right),
10131 int remove_duplicates)
10133 unsigned flags = 0;
10134 struct isl_map *result;
10135 int i, j;
10136 isl_bool m;
10138 m = isl_map_has_equal_params(map1, map2);
10139 if (m < 0)
10140 goto error;
10141 if (!m)
10142 isl_die(isl_map_get_ctx(map1), isl_error_invalid,
10143 "parameters don't match", goto error);
10145 if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) &&
10146 ISL_F_ISSET(map2, ISL_MAP_DISJOINT))
10147 ISL_FL_SET(flags, ISL_MAP_DISJOINT);
10149 result = isl_map_alloc_space(space_product(isl_space_copy(map1->dim),
10150 isl_space_copy(map2->dim)),
10151 map1->n * map2->n, flags);
10152 if (!result)
10153 goto error;
10154 for (i = 0; i < map1->n; ++i)
10155 for (j = 0; j < map2->n; ++j) {
10156 struct isl_basic_map *part;
10157 part = basic_map_product(isl_basic_map_copy(map1->p[i]),
10158 isl_basic_map_copy(map2->p[j]));
10159 if (isl_basic_map_is_empty(part))
10160 isl_basic_map_free(part);
10161 else
10162 result = isl_map_add_basic_map(result, part);
10163 if (!result)
10164 goto error;
10166 if (remove_duplicates)
10167 result = isl_map_remove_obvious_duplicates(result);
10168 isl_map_free(map1);
10169 isl_map_free(map2);
10170 return result;
10171 error:
10172 isl_map_free(map1);
10173 isl_map_free(map2);
10174 return NULL;
10177 /* Given two maps A -> B and C -> D, construct a map [A -> C] -> [B -> D]
10179 static __isl_give isl_map *map_product_aligned(__isl_take isl_map *map1,
10180 __isl_take isl_map *map2)
10182 return map_product(map1, map2, &isl_space_product,
10183 &isl_basic_map_product, 0);
10186 __isl_give isl_map *isl_map_product(__isl_take isl_map *map1,
10187 __isl_take isl_map *map2)
10189 return isl_map_align_params_map_map_and(map1, map2, &map_product_aligned);
10192 /* Given two maps A -> B and C -> D, construct a map (A, C) -> (B, D)
10194 __isl_give isl_map *isl_map_flat_product(__isl_take isl_map *map1,
10195 __isl_take isl_map *map2)
10197 isl_map *prod;
10199 prod = isl_map_product(map1, map2);
10200 prod = isl_map_flatten(prod);
10201 return prod;
10204 /* Given two set A and B, construct its Cartesian product A x B.
10206 struct isl_set *isl_set_product(struct isl_set *set1, struct isl_set *set2)
10208 return isl_map_range_product(set1, set2);
10211 __isl_give isl_set *isl_set_flat_product(__isl_take isl_set *set1,
10212 __isl_take isl_set *set2)
10214 return isl_map_flat_range_product(set1, set2);
10217 /* Given two maps A -> B and C -> D, construct a map [A -> C] -> (B * D)
10219 static __isl_give isl_map *map_domain_product_aligned(__isl_take isl_map *map1,
10220 __isl_take isl_map *map2)
10222 return map_product(map1, map2, &isl_space_domain_product,
10223 &isl_basic_map_domain_product, 1);
10226 /* Given two maps A -> B and C -> D, construct a map (A * C) -> [B -> D]
10228 static __isl_give isl_map *map_range_product_aligned(__isl_take isl_map *map1,
10229 __isl_take isl_map *map2)
10231 return map_product(map1, map2, &isl_space_range_product,
10232 &isl_basic_map_range_product, 1);
10235 __isl_give isl_map *isl_map_domain_product(__isl_take isl_map *map1,
10236 __isl_take isl_map *map2)
10238 return isl_map_align_params_map_map_and(map1, map2,
10239 &map_domain_product_aligned);
10242 __isl_give isl_map *isl_map_range_product(__isl_take isl_map *map1,
10243 __isl_take isl_map *map2)
10245 return isl_map_align_params_map_map_and(map1, map2,
10246 &map_range_product_aligned);
10249 /* Given a map of the form [A -> B] -> [C -> D], return the map A -> C.
10251 __isl_give isl_map *isl_map_factor_domain(__isl_take isl_map *map)
10253 isl_space *space;
10254 int total1, keep1, total2, keep2;
10256 if (!map)
10257 return NULL;
10258 if (!isl_space_domain_is_wrapping(map->dim) ||
10259 !isl_space_range_is_wrapping(map->dim))
10260 isl_die(isl_map_get_ctx(map), isl_error_invalid,
10261 "not a product", return isl_map_free(map));
10263 space = isl_map_get_space(map);
10264 total1 = isl_space_dim(space, isl_dim_in);
10265 total2 = isl_space_dim(space, isl_dim_out);
10266 space = isl_space_factor_domain(space);
10267 keep1 = isl_space_dim(space, isl_dim_in);
10268 keep2 = isl_space_dim(space, isl_dim_out);
10269 map = isl_map_project_out(map, isl_dim_in, keep1, total1 - keep1);
10270 map = isl_map_project_out(map, isl_dim_out, keep2, total2 - keep2);
10271 map = isl_map_reset_space(map, space);
10273 return map;
10276 /* Given a map of the form [A -> B] -> [C -> D], return the map B -> D.
10278 __isl_give isl_map *isl_map_factor_range(__isl_take isl_map *map)
10280 isl_space *space;
10281 int total1, keep1, total2, keep2;
10283 if (!map)
10284 return NULL;
10285 if (!isl_space_domain_is_wrapping(map->dim) ||
10286 !isl_space_range_is_wrapping(map->dim))
10287 isl_die(isl_map_get_ctx(map), isl_error_invalid,
10288 "not a product", return isl_map_free(map));
10290 space = isl_map_get_space(map);
10291 total1 = isl_space_dim(space, isl_dim_in);
10292 total2 = isl_space_dim(space, isl_dim_out);
10293 space = isl_space_factor_range(space);
10294 keep1 = isl_space_dim(space, isl_dim_in);
10295 keep2 = isl_space_dim(space, isl_dim_out);
10296 map = isl_map_project_out(map, isl_dim_in, 0, total1 - keep1);
10297 map = isl_map_project_out(map, isl_dim_out, 0, total2 - keep2);
10298 map = isl_map_reset_space(map, space);
10300 return map;
10303 /* Given a map of the form [A -> B] -> C, return the map A -> C.
10305 __isl_give isl_map *isl_map_domain_factor_domain(__isl_take isl_map *map)
10307 isl_space *space;
10308 int total, keep;
10310 if (!map)
10311 return NULL;
10312 if (!isl_space_domain_is_wrapping(map->dim))
10313 isl_die(isl_map_get_ctx(map), isl_error_invalid,
10314 "domain is not a product", return isl_map_free(map));
10316 space = isl_map_get_space(map);
10317 total = isl_space_dim(space, isl_dim_in);
10318 space = isl_space_domain_factor_domain(space);
10319 keep = isl_space_dim(space, isl_dim_in);
10320 map = isl_map_project_out(map, isl_dim_in, keep, total - keep);
10321 map = isl_map_reset_space(map, space);
10323 return map;
10326 /* Given a map of the form [A -> B] -> C, return the map B -> C.
10328 __isl_give isl_map *isl_map_domain_factor_range(__isl_take isl_map *map)
10330 isl_space *space;
10331 int total, keep;
10333 if (!map)
10334 return NULL;
10335 if (!isl_space_domain_is_wrapping(map->dim))
10336 isl_die(isl_map_get_ctx(map), isl_error_invalid,
10337 "domain is not a product", return isl_map_free(map));
10339 space = isl_map_get_space(map);
10340 total = isl_space_dim(space, isl_dim_in);
10341 space = isl_space_domain_factor_range(space);
10342 keep = isl_space_dim(space, isl_dim_in);
10343 map = isl_map_project_out(map, isl_dim_in, 0, total - keep);
10344 map = isl_map_reset_space(map, space);
10346 return map;
10349 /* Given a map A -> [B -> C], extract the map A -> B.
10351 __isl_give isl_map *isl_map_range_factor_domain(__isl_take isl_map *map)
10353 isl_space *space;
10354 int total, keep;
10356 if (!map)
10357 return NULL;
10358 if (!isl_space_range_is_wrapping(map->dim))
10359 isl_die(isl_map_get_ctx(map), isl_error_invalid,
10360 "range is not a product", return isl_map_free(map));
10362 space = isl_map_get_space(map);
10363 total = isl_space_dim(space, isl_dim_out);
10364 space = isl_space_range_factor_domain(space);
10365 keep = isl_space_dim(space, isl_dim_out);
10366 map = isl_map_project_out(map, isl_dim_out, keep, total - keep);
10367 map = isl_map_reset_space(map, space);
10369 return map;
10372 /* Given a map A -> [B -> C], extract the map A -> C.
10374 __isl_give isl_map *isl_map_range_factor_range(__isl_take isl_map *map)
10376 isl_space *space;
10377 int total, keep;
10379 if (!map)
10380 return NULL;
10381 if (!isl_space_range_is_wrapping(map->dim))
10382 isl_die(isl_map_get_ctx(map), isl_error_invalid,
10383 "range is not a product", return isl_map_free(map));
10385 space = isl_map_get_space(map);
10386 total = isl_space_dim(space, isl_dim_out);
10387 space = isl_space_range_factor_range(space);
10388 keep = isl_space_dim(space, isl_dim_out);
10389 map = isl_map_project_out(map, isl_dim_out, 0, total - keep);
10390 map = isl_map_reset_space(map, space);
10392 return map;
10395 /* Given two maps A -> B and C -> D, construct a map (A, C) -> (B * D)
10397 __isl_give isl_map *isl_map_flat_domain_product(__isl_take isl_map *map1,
10398 __isl_take isl_map *map2)
10400 isl_map *prod;
10402 prod = isl_map_domain_product(map1, map2);
10403 prod = isl_map_flatten_domain(prod);
10404 return prod;
10407 /* Given two maps A -> B and C -> D, construct a map (A * C) -> (B, D)
10409 __isl_give isl_map *isl_map_flat_range_product(__isl_take isl_map *map1,
10410 __isl_take isl_map *map2)
10412 isl_map *prod;
10414 prod = isl_map_range_product(map1, map2);
10415 prod = isl_map_flatten_range(prod);
10416 return prod;
10419 uint32_t isl_basic_map_get_hash(__isl_keep isl_basic_map *bmap)
10421 int i;
10422 uint32_t hash = isl_hash_init();
10423 unsigned total;
10425 if (!bmap)
10426 return 0;
10427 bmap = isl_basic_map_copy(bmap);
10428 bmap = isl_basic_map_normalize(bmap);
10429 if (!bmap)
10430 return 0;
10431 total = isl_basic_map_total_dim(bmap);
10432 isl_hash_byte(hash, bmap->n_eq & 0xFF);
10433 for (i = 0; i < bmap->n_eq; ++i) {
10434 uint32_t c_hash;
10435 c_hash = isl_seq_get_hash(bmap->eq[i], 1 + total);
10436 isl_hash_hash(hash, c_hash);
10438 isl_hash_byte(hash, bmap->n_ineq & 0xFF);
10439 for (i = 0; i < bmap->n_ineq; ++i) {
10440 uint32_t c_hash;
10441 c_hash = isl_seq_get_hash(bmap->ineq[i], 1 + total);
10442 isl_hash_hash(hash, c_hash);
10444 isl_hash_byte(hash, bmap->n_div & 0xFF);
10445 for (i = 0; i < bmap->n_div; ++i) {
10446 uint32_t c_hash;
10447 if (isl_int_is_zero(bmap->div[i][0]))
10448 continue;
10449 isl_hash_byte(hash, i & 0xFF);
10450 c_hash = isl_seq_get_hash(bmap->div[i], 1 + 1 + total);
10451 isl_hash_hash(hash, c_hash);
10453 isl_basic_map_free(bmap);
10454 return hash;
10457 uint32_t isl_basic_set_get_hash(__isl_keep isl_basic_set *bset)
10459 return isl_basic_map_get_hash(bset_to_bmap(bset));
10462 uint32_t isl_map_get_hash(__isl_keep isl_map *map)
10464 int i;
10465 uint32_t hash;
10467 if (!map)
10468 return 0;
10469 map = isl_map_copy(map);
10470 map = isl_map_normalize(map);
10471 if (!map)
10472 return 0;
10474 hash = isl_hash_init();
10475 for (i = 0; i < map->n; ++i) {
10476 uint32_t bmap_hash;
10477 bmap_hash = isl_basic_map_get_hash(map->p[i]);
10478 isl_hash_hash(hash, bmap_hash);
10481 isl_map_free(map);
10483 return hash;
10486 uint32_t isl_set_get_hash(__isl_keep isl_set *set)
10488 return isl_map_get_hash(set_to_map(set));
10491 /* Return the number of basic maps in the (current) representation of "map".
10493 int isl_map_n_basic_map(__isl_keep isl_map *map)
10495 return map ? map->n : 0;
10498 int isl_set_n_basic_set(__isl_keep isl_set *set)
10500 return set ? set->n : 0;
10503 isl_stat isl_map_foreach_basic_map(__isl_keep isl_map *map,
10504 isl_stat (*fn)(__isl_take isl_basic_map *bmap, void *user), void *user)
10506 int i;
10508 if (!map)
10509 return isl_stat_error;
10511 for (i = 0; i < map->n; ++i)
10512 if (fn(isl_basic_map_copy(map->p[i]), user) < 0)
10513 return isl_stat_error;
10515 return isl_stat_ok;
10518 isl_stat isl_set_foreach_basic_set(__isl_keep isl_set *set,
10519 isl_stat (*fn)(__isl_take isl_basic_set *bset, void *user), void *user)
10521 int i;
10523 if (!set)
10524 return isl_stat_error;
10526 for (i = 0; i < set->n; ++i)
10527 if (fn(isl_basic_set_copy(set->p[i]), user) < 0)
10528 return isl_stat_error;
10530 return isl_stat_ok;
10533 /* Return a list of basic sets, the union of which is equal to "set".
10535 __isl_give isl_basic_set_list *isl_set_get_basic_set_list(
10536 __isl_keep isl_set *set)
10538 int i;
10539 isl_basic_set_list *list;
10541 if (!set)
10542 return NULL;
10544 list = isl_basic_set_list_alloc(isl_set_get_ctx(set), set->n);
10545 for (i = 0; i < set->n; ++i) {
10546 isl_basic_set *bset;
10548 bset = isl_basic_set_copy(set->p[i]);
10549 list = isl_basic_set_list_add(list, bset);
10552 return list;
10555 __isl_give isl_basic_set *isl_basic_set_lift(__isl_take isl_basic_set *bset)
10557 isl_space *dim;
10559 if (!bset)
10560 return NULL;
10562 bset = isl_basic_set_cow(bset);
10563 if (!bset)
10564 return NULL;
10566 dim = isl_basic_set_get_space(bset);
10567 dim = isl_space_lift(dim, bset->n_div);
10568 if (!dim)
10569 goto error;
10570 isl_space_free(bset->dim);
10571 bset->dim = dim;
10572 bset->extra -= bset->n_div;
10573 bset->n_div = 0;
10575 bset = isl_basic_set_finalize(bset);
10577 return bset;
10578 error:
10579 isl_basic_set_free(bset);
10580 return NULL;
10583 __isl_give isl_set *isl_set_lift(__isl_take isl_set *set)
10585 int i;
10586 isl_space *dim;
10587 unsigned n_div;
10589 set = set_from_map(isl_map_align_divs_internal(set_to_map(set)));
10591 if (!set)
10592 return NULL;
10594 set = isl_set_cow(set);
10595 if (!set)
10596 return NULL;
10598 n_div = set->p[0]->n_div;
10599 dim = isl_set_get_space(set);
10600 dim = isl_space_lift(dim, n_div);
10601 if (!dim)
10602 goto error;
10603 isl_space_free(set->dim);
10604 set->dim = dim;
10606 for (i = 0; i < set->n; ++i) {
10607 set->p[i] = isl_basic_set_lift(set->p[i]);
10608 if (!set->p[i])
10609 goto error;
10612 return set;
10613 error:
10614 isl_set_free(set);
10615 return NULL;
10618 int isl_basic_set_size(__isl_keep isl_basic_set *bset)
10620 unsigned dim;
10621 int size = 0;
10623 if (!bset)
10624 return -1;
10626 dim = isl_basic_set_total_dim(bset);
10627 size += bset->n_eq * (1 + dim);
10628 size += bset->n_ineq * (1 + dim);
10629 size += bset->n_div * (2 + dim);
10631 return size;
10634 int isl_set_size(__isl_keep isl_set *set)
10636 int i;
10637 int size = 0;
10639 if (!set)
10640 return -1;
10642 for (i = 0; i < set->n; ++i)
10643 size += isl_basic_set_size(set->p[i]);
10645 return size;
10648 /* Check if there is any lower bound (if lower == 0) and/or upper
10649 * bound (if upper == 0) on the specified dim.
10651 static isl_bool basic_map_dim_is_bounded(__isl_keep isl_basic_map *bmap,
10652 enum isl_dim_type type, unsigned pos, int lower, int upper)
10654 int i;
10656 if (isl_basic_map_check_range(bmap, type, pos, 1) < 0)
10657 return isl_bool_error;
10659 pos += isl_basic_map_offset(bmap, type);
10661 for (i = 0; i < bmap->n_div; ++i) {
10662 if (isl_int_is_zero(bmap->div[i][0]))
10663 continue;
10664 if (!isl_int_is_zero(bmap->div[i][1 + pos]))
10665 return isl_bool_true;
10668 for (i = 0; i < bmap->n_eq; ++i)
10669 if (!isl_int_is_zero(bmap->eq[i][pos]))
10670 return isl_bool_true;
10672 for (i = 0; i < bmap->n_ineq; ++i) {
10673 int sgn = isl_int_sgn(bmap->ineq[i][pos]);
10674 if (sgn > 0)
10675 lower = 1;
10676 if (sgn < 0)
10677 upper = 1;
10680 return lower && upper;
10683 isl_bool isl_basic_map_dim_is_bounded(__isl_keep isl_basic_map *bmap,
10684 enum isl_dim_type type, unsigned pos)
10686 return basic_map_dim_is_bounded(bmap, type, pos, 0, 0);
10689 isl_bool isl_basic_map_dim_has_lower_bound(__isl_keep isl_basic_map *bmap,
10690 enum isl_dim_type type, unsigned pos)
10692 return basic_map_dim_is_bounded(bmap, type, pos, 0, 1);
10695 isl_bool isl_basic_map_dim_has_upper_bound(__isl_keep isl_basic_map *bmap,
10696 enum isl_dim_type type, unsigned pos)
10698 return basic_map_dim_is_bounded(bmap, type, pos, 1, 0);
10701 isl_bool isl_map_dim_is_bounded(__isl_keep isl_map *map,
10702 enum isl_dim_type type, unsigned pos)
10704 int i;
10706 if (!map)
10707 return isl_bool_error;
10709 for (i = 0; i < map->n; ++i) {
10710 isl_bool bounded;
10711 bounded = isl_basic_map_dim_is_bounded(map->p[i], type, pos);
10712 if (bounded < 0 || !bounded)
10713 return bounded;
10716 return isl_bool_true;
10719 /* Return true if the specified dim is involved in both an upper bound
10720 * and a lower bound.
10722 isl_bool isl_set_dim_is_bounded(__isl_keep isl_set *set,
10723 enum isl_dim_type type, unsigned pos)
10725 return isl_map_dim_is_bounded(set_to_map(set), type, pos);
10728 /* Does "map" have a bound (according to "fn") for any of its basic maps?
10730 static isl_bool has_any_bound(__isl_keep isl_map *map,
10731 enum isl_dim_type type, unsigned pos,
10732 isl_bool (*fn)(__isl_keep isl_basic_map *bmap,
10733 enum isl_dim_type type, unsigned pos))
10735 int i;
10737 if (!map)
10738 return isl_bool_error;
10740 for (i = 0; i < map->n; ++i) {
10741 isl_bool bounded;
10742 bounded = fn(map->p[i], type, pos);
10743 if (bounded < 0 || bounded)
10744 return bounded;
10747 return isl_bool_false;
10750 /* Return 1 if the specified dim is involved in any lower bound.
10752 isl_bool isl_set_dim_has_any_lower_bound(__isl_keep isl_set *set,
10753 enum isl_dim_type type, unsigned pos)
10755 return has_any_bound(set, type, pos,
10756 &isl_basic_map_dim_has_lower_bound);
10759 /* Return 1 if the specified dim is involved in any upper bound.
10761 isl_bool isl_set_dim_has_any_upper_bound(__isl_keep isl_set *set,
10762 enum isl_dim_type type, unsigned pos)
10764 return has_any_bound(set, type, pos,
10765 &isl_basic_map_dim_has_upper_bound);
10768 /* Does "map" have a bound (according to "fn") for all of its basic maps?
10770 static isl_bool has_bound(__isl_keep isl_map *map,
10771 enum isl_dim_type type, unsigned pos,
10772 isl_bool (*fn)(__isl_keep isl_basic_map *bmap,
10773 enum isl_dim_type type, unsigned pos))
10775 int i;
10777 if (!map)
10778 return isl_bool_error;
10780 for (i = 0; i < map->n; ++i) {
10781 isl_bool bounded;
10782 bounded = fn(map->p[i], type, pos);
10783 if (bounded < 0 || !bounded)
10784 return bounded;
10787 return isl_bool_true;
10790 /* Return 1 if the specified dim has a lower bound (in each of its basic sets).
10792 isl_bool isl_set_dim_has_lower_bound(__isl_keep isl_set *set,
10793 enum isl_dim_type type, unsigned pos)
10795 return has_bound(set, type, pos, &isl_basic_map_dim_has_lower_bound);
10798 /* Return 1 if the specified dim has an upper bound (in each of its basic sets).
10800 isl_bool isl_set_dim_has_upper_bound(__isl_keep isl_set *set,
10801 enum isl_dim_type type, unsigned pos)
10803 return has_bound(set, type, pos, &isl_basic_map_dim_has_upper_bound);
10806 /* For each of the "n" variables starting at "first", determine
10807 * the sign of the variable and put the results in the first "n"
10808 * elements of the array "signs".
10809 * Sign
10810 * 1 means that the variable is non-negative
10811 * -1 means that the variable is non-positive
10812 * 0 means the variable attains both positive and negative values.
10814 isl_stat isl_basic_set_vars_get_sign(__isl_keep isl_basic_set *bset,
10815 unsigned first, unsigned n, int *signs)
10817 isl_vec *bound = NULL;
10818 struct isl_tab *tab = NULL;
10819 struct isl_tab_undo *snap;
10820 int i;
10822 if (!bset || !signs)
10823 return isl_stat_error;
10825 bound = isl_vec_alloc(bset->ctx, 1 + isl_basic_set_total_dim(bset));
10826 tab = isl_tab_from_basic_set(bset, 0);
10827 if (!bound || !tab)
10828 goto error;
10830 isl_seq_clr(bound->el, bound->size);
10831 isl_int_set_si(bound->el[0], -1);
10833 snap = isl_tab_snap(tab);
10834 for (i = 0; i < n; ++i) {
10835 int empty;
10837 isl_int_set_si(bound->el[1 + first + i], -1);
10838 if (isl_tab_add_ineq(tab, bound->el) < 0)
10839 goto error;
10840 empty = tab->empty;
10841 isl_int_set_si(bound->el[1 + first + i], 0);
10842 if (isl_tab_rollback(tab, snap) < 0)
10843 goto error;
10845 if (empty) {
10846 signs[i] = 1;
10847 continue;
10850 isl_int_set_si(bound->el[1 + first + i], 1);
10851 if (isl_tab_add_ineq(tab, bound->el) < 0)
10852 goto error;
10853 empty = tab->empty;
10854 isl_int_set_si(bound->el[1 + first + i], 0);
10855 if (isl_tab_rollback(tab, snap) < 0)
10856 goto error;
10858 signs[i] = empty ? -1 : 0;
10861 isl_tab_free(tab);
10862 isl_vec_free(bound);
10863 return isl_stat_ok;
10864 error:
10865 isl_tab_free(tab);
10866 isl_vec_free(bound);
10867 return isl_stat_error;
10870 isl_stat isl_basic_set_dims_get_sign(__isl_keep isl_basic_set *bset,
10871 enum isl_dim_type type, unsigned first, unsigned n, int *signs)
10873 if (!bset || !signs)
10874 return isl_stat_error;
10875 isl_assert(bset->ctx, first + n <= isl_basic_set_dim(bset, type),
10876 return isl_stat_error);
10878 first += pos(bset->dim, type) - 1;
10879 return isl_basic_set_vars_get_sign(bset, first, n, signs);
10882 /* Is it possible for the integer division "div" to depend (possibly
10883 * indirectly) on any output dimensions?
10885 * If the div is undefined, then we conservatively assume that it
10886 * may depend on them.
10887 * Otherwise, we check if it actually depends on them or on any integer
10888 * divisions that may depend on them.
10890 static isl_bool div_may_involve_output(__isl_keep isl_basic_map *bmap, int div)
10892 int i;
10893 unsigned n_out, o_out;
10894 unsigned n_div, o_div;
10896 if (isl_int_is_zero(bmap->div[div][0]))
10897 return isl_bool_true;
10899 n_out = isl_basic_map_dim(bmap, isl_dim_out);
10900 o_out = isl_basic_map_offset(bmap, isl_dim_out);
10902 if (isl_seq_first_non_zero(bmap->div[div] + 1 + o_out, n_out) != -1)
10903 return isl_bool_true;
10905 n_div = isl_basic_map_dim(bmap, isl_dim_div);
10906 o_div = isl_basic_map_offset(bmap, isl_dim_div);
10908 for (i = 0; i < n_div; ++i) {
10909 isl_bool may_involve;
10911 if (isl_int_is_zero(bmap->div[div][1 + o_div + i]))
10912 continue;
10913 may_involve = div_may_involve_output(bmap, i);
10914 if (may_involve < 0 || may_involve)
10915 return may_involve;
10918 return isl_bool_false;
10921 /* Return the first integer division of "bmap" in the range
10922 * [first, first + n[ that may depend on any output dimensions and
10923 * that has a non-zero coefficient in "c" (where the first coefficient
10924 * in "c" corresponds to integer division "first").
10926 static int first_div_may_involve_output(__isl_keep isl_basic_map *bmap,
10927 isl_int *c, int first, int n)
10929 int k;
10931 if (!bmap)
10932 return -1;
10934 for (k = first; k < first + n; ++k) {
10935 isl_bool may_involve;
10937 if (isl_int_is_zero(c[k]))
10938 continue;
10939 may_involve = div_may_involve_output(bmap, k);
10940 if (may_involve < 0)
10941 return -1;
10942 if (may_involve)
10943 return k;
10946 return first + n;
10949 /* Look for a pair of inequality constraints in "bmap" of the form
10951 * -l + i >= 0 or i >= l
10952 * and
10953 * n + l - i >= 0 or i <= l + n
10955 * with n < "m" and i the output dimension at position "pos".
10956 * (Note that n >= 0 as otherwise the two constraints would conflict.)
10957 * Furthermore, "l" is only allowed to involve parameters, input dimensions
10958 * and earlier output dimensions, as well as integer divisions that do
10959 * not involve any of the output dimensions.
10961 * Return the index of the first inequality constraint or bmap->n_ineq
10962 * if no such pair can be found.
10964 static int find_modulo_constraint_pair(__isl_keep isl_basic_map *bmap,
10965 int pos, isl_int m)
10967 int i, j;
10968 isl_ctx *ctx;
10969 unsigned total;
10970 unsigned n_div, o_div;
10971 unsigned n_out, o_out;
10972 int less;
10974 if (!bmap)
10975 return -1;
10977 ctx = isl_basic_map_get_ctx(bmap);
10978 total = isl_basic_map_total_dim(bmap);
10979 n_out = isl_basic_map_dim(bmap, isl_dim_out);
10980 o_out = isl_basic_map_offset(bmap, isl_dim_out);
10981 n_div = isl_basic_map_dim(bmap, isl_dim_div);
10982 o_div = isl_basic_map_offset(bmap, isl_dim_div);
10983 for (i = 0; i < bmap->n_ineq; ++i) {
10984 if (!isl_int_abs_eq(bmap->ineq[i][o_out + pos], ctx->one))
10985 continue;
10986 if (isl_seq_first_non_zero(bmap->ineq[i] + o_out + pos + 1,
10987 n_out - (pos + 1)) != -1)
10988 continue;
10989 if (first_div_may_involve_output(bmap, bmap->ineq[i] + o_div,
10990 0, n_div) < n_div)
10991 continue;
10992 for (j = i + 1; j < bmap->n_ineq; ++j) {
10993 if (!isl_int_abs_eq(bmap->ineq[j][o_out + pos],
10994 ctx->one))
10995 continue;
10996 if (!isl_seq_is_neg(bmap->ineq[i] + 1,
10997 bmap->ineq[j] + 1, total))
10998 continue;
10999 break;
11001 if (j >= bmap->n_ineq)
11002 continue;
11003 isl_int_add(bmap->ineq[i][0],
11004 bmap->ineq[i][0], bmap->ineq[j][0]);
11005 less = isl_int_abs_lt(bmap->ineq[i][0], m);
11006 isl_int_sub(bmap->ineq[i][0],
11007 bmap->ineq[i][0], bmap->ineq[j][0]);
11008 if (!less)
11009 continue;
11010 if (isl_int_is_one(bmap->ineq[i][o_out + pos]))
11011 return i;
11012 else
11013 return j;
11016 return bmap->n_ineq;
11019 /* Return the index of the equality of "bmap" that defines
11020 * the output dimension "pos" in terms of earlier dimensions.
11021 * The equality may also involve integer divisions, as long
11022 * as those integer divisions are defined in terms of
11023 * parameters or input dimensions.
11024 * In this case, *div is set to the number of integer divisions and
11025 * *ineq is set to the number of inequality constraints (provided
11026 * div and ineq are not NULL).
11028 * The equality may also involve a single integer division involving
11029 * the output dimensions (typically only output dimension "pos") as
11030 * long as the coefficient of output dimension "pos" is 1 or -1 and
11031 * there is a pair of constraints i >= l and i <= l + n, with i referring
11032 * to output dimension "pos", l an expression involving only earlier
11033 * dimensions and n smaller than the coefficient of the integer division
11034 * in the equality. In this case, the output dimension can be defined
11035 * in terms of a modulo expression that does not involve the integer division.
11036 * *div is then set to this single integer division and
11037 * *ineq is set to the index of constraint i >= l.
11039 * Return bmap->n_eq if there is no such equality.
11040 * Return -1 on error.
11042 int isl_basic_map_output_defining_equality(__isl_keep isl_basic_map *bmap,
11043 int pos, int *div, int *ineq)
11045 int j, k, l;
11046 unsigned n_out, o_out;
11047 unsigned n_div, o_div;
11049 if (!bmap)
11050 return -1;
11052 n_out = isl_basic_map_dim(bmap, isl_dim_out);
11053 o_out = isl_basic_map_offset(bmap, isl_dim_out);
11054 n_div = isl_basic_map_dim(bmap, isl_dim_div);
11055 o_div = isl_basic_map_offset(bmap, isl_dim_div);
11057 if (ineq)
11058 *ineq = bmap->n_ineq;
11059 if (div)
11060 *div = n_div;
11061 for (j = 0; j < bmap->n_eq; ++j) {
11062 if (isl_int_is_zero(bmap->eq[j][o_out + pos]))
11063 continue;
11064 if (isl_seq_first_non_zero(bmap->eq[j] + o_out + pos + 1,
11065 n_out - (pos + 1)) != -1)
11066 continue;
11067 k = first_div_may_involve_output(bmap, bmap->eq[j] + o_div,
11068 0, n_div);
11069 if (k >= n_div)
11070 return j;
11071 if (!isl_int_is_one(bmap->eq[j][o_out + pos]) &&
11072 !isl_int_is_negone(bmap->eq[j][o_out + pos]))
11073 continue;
11074 if (first_div_may_involve_output(bmap, bmap->eq[j] + o_div,
11075 k + 1, n_div - (k+1)) < n_div)
11076 continue;
11077 l = find_modulo_constraint_pair(bmap, pos,
11078 bmap->eq[j][o_div + k]);
11079 if (l < 0)
11080 return -1;
11081 if (l >= bmap->n_ineq)
11082 continue;
11083 if (div)
11084 *div = k;
11085 if (ineq)
11086 *ineq = l;
11087 return j;
11090 return bmap->n_eq;
11093 /* Check if the given basic map is obviously single-valued.
11094 * In particular, for each output dimension, check that there is
11095 * an equality that defines the output dimension in terms of
11096 * earlier dimensions.
11098 isl_bool isl_basic_map_plain_is_single_valued(__isl_keep isl_basic_map *bmap)
11100 int i;
11101 unsigned n_out;
11103 if (!bmap)
11104 return isl_bool_error;
11106 n_out = isl_basic_map_dim(bmap, isl_dim_out);
11108 for (i = 0; i < n_out; ++i) {
11109 int eq;
11111 eq = isl_basic_map_output_defining_equality(bmap, i,
11112 NULL, NULL);
11113 if (eq < 0)
11114 return isl_bool_error;
11115 if (eq >= bmap->n_eq)
11116 return isl_bool_false;
11119 return isl_bool_true;
11122 /* Check if the given basic map is single-valued.
11123 * We simply compute
11125 * M \circ M^-1
11127 * and check if the result is a subset of the identity mapping.
11129 isl_bool isl_basic_map_is_single_valued(__isl_keep isl_basic_map *bmap)
11131 isl_space *space;
11132 isl_basic_map *test;
11133 isl_basic_map *id;
11134 isl_bool sv;
11136 sv = isl_basic_map_plain_is_single_valued(bmap);
11137 if (sv < 0 || sv)
11138 return sv;
11140 test = isl_basic_map_reverse(isl_basic_map_copy(bmap));
11141 test = isl_basic_map_apply_range(test, isl_basic_map_copy(bmap));
11143 space = isl_basic_map_get_space(bmap);
11144 space = isl_space_map_from_set(isl_space_range(space));
11145 id = isl_basic_map_identity(space);
11147 sv = isl_basic_map_is_subset(test, id);
11149 isl_basic_map_free(test);
11150 isl_basic_map_free(id);
11152 return sv;
11155 /* Check if the given map is obviously single-valued.
11157 isl_bool isl_map_plain_is_single_valued(__isl_keep isl_map *map)
11159 if (!map)
11160 return isl_bool_error;
11161 if (map->n == 0)
11162 return isl_bool_true;
11163 if (map->n >= 2)
11164 return isl_bool_false;
11166 return isl_basic_map_plain_is_single_valued(map->p[0]);
11169 /* Check if the given map is single-valued.
11170 * We simply compute
11172 * M \circ M^-1
11174 * and check if the result is a subset of the identity mapping.
11176 isl_bool isl_map_is_single_valued(__isl_keep isl_map *map)
11178 isl_space *dim;
11179 isl_map *test;
11180 isl_map *id;
11181 isl_bool sv;
11183 sv = isl_map_plain_is_single_valued(map);
11184 if (sv < 0 || sv)
11185 return sv;
11187 test = isl_map_reverse(isl_map_copy(map));
11188 test = isl_map_apply_range(test, isl_map_copy(map));
11190 dim = isl_space_map_from_set(isl_space_range(isl_map_get_space(map)));
11191 id = isl_map_identity(dim);
11193 sv = isl_map_is_subset(test, id);
11195 isl_map_free(test);
11196 isl_map_free(id);
11198 return sv;
11201 isl_bool isl_map_is_injective(__isl_keep isl_map *map)
11203 isl_bool in;
11205 map = isl_map_copy(map);
11206 map = isl_map_reverse(map);
11207 in = isl_map_is_single_valued(map);
11208 isl_map_free(map);
11210 return in;
11213 /* Check if the given map is obviously injective.
11215 isl_bool isl_map_plain_is_injective(__isl_keep isl_map *map)
11217 isl_bool in;
11219 map = isl_map_copy(map);
11220 map = isl_map_reverse(map);
11221 in = isl_map_plain_is_single_valued(map);
11222 isl_map_free(map);
11224 return in;
11227 isl_bool isl_map_is_bijective(__isl_keep isl_map *map)
11229 isl_bool sv;
11231 sv = isl_map_is_single_valued(map);
11232 if (sv < 0 || !sv)
11233 return sv;
11235 return isl_map_is_injective(map);
11238 isl_bool isl_set_is_singleton(__isl_keep isl_set *set)
11240 return isl_map_is_single_valued(set_to_map(set));
11243 /* Does "map" only map elements to themselves?
11245 * If the domain and range spaces are different, then "map"
11246 * is considered not to be an identity relation, even if it is empty.
11247 * Otherwise, construct the maximal identity relation and
11248 * check whether "map" is a subset of this relation.
11250 isl_bool isl_map_is_identity(__isl_keep isl_map *map)
11252 isl_space *space;
11253 isl_map *id;
11254 isl_bool equal, is_identity;
11256 space = isl_map_get_space(map);
11257 equal = isl_space_tuple_is_equal(space, isl_dim_in, space, isl_dim_out);
11258 isl_space_free(space);
11259 if (equal < 0 || !equal)
11260 return equal;
11262 id = isl_map_identity(isl_map_get_space(map));
11263 is_identity = isl_map_is_subset(map, id);
11264 isl_map_free(id);
11266 return is_identity;
11269 int isl_map_is_translation(__isl_keep isl_map *map)
11271 int ok;
11272 isl_set *delta;
11274 delta = isl_map_deltas(isl_map_copy(map));
11275 ok = isl_set_is_singleton(delta);
11276 isl_set_free(delta);
11278 return ok;
11281 static int unique(isl_int *p, unsigned pos, unsigned len)
11283 if (isl_seq_first_non_zero(p, pos) != -1)
11284 return 0;
11285 if (isl_seq_first_non_zero(p + pos + 1, len - pos - 1) != -1)
11286 return 0;
11287 return 1;
11290 isl_bool isl_basic_set_is_box(__isl_keep isl_basic_set *bset)
11292 int i, j;
11293 unsigned nvar;
11294 unsigned ovar;
11296 if (!bset)
11297 return isl_bool_error;
11299 if (isl_basic_set_dim(bset, isl_dim_div) != 0)
11300 return isl_bool_false;
11302 nvar = isl_basic_set_dim(bset, isl_dim_set);
11303 ovar = isl_space_offset(bset->dim, isl_dim_set);
11304 for (j = 0; j < nvar; ++j) {
11305 int lower = 0, upper = 0;
11306 for (i = 0; i < bset->n_eq; ++i) {
11307 if (isl_int_is_zero(bset->eq[i][1 + ovar + j]))
11308 continue;
11309 if (!unique(bset->eq[i] + 1 + ovar, j, nvar))
11310 return isl_bool_false;
11311 break;
11313 if (i < bset->n_eq)
11314 continue;
11315 for (i = 0; i < bset->n_ineq; ++i) {
11316 if (isl_int_is_zero(bset->ineq[i][1 + ovar + j]))
11317 continue;
11318 if (!unique(bset->ineq[i] + 1 + ovar, j, nvar))
11319 return isl_bool_false;
11320 if (isl_int_is_pos(bset->ineq[i][1 + ovar + j]))
11321 lower = 1;
11322 else
11323 upper = 1;
11325 if (!lower || !upper)
11326 return isl_bool_false;
11329 return isl_bool_true;
11332 isl_bool isl_set_is_box(__isl_keep isl_set *set)
11334 if (!set)
11335 return isl_bool_error;
11336 if (set->n != 1)
11337 return isl_bool_false;
11339 return isl_basic_set_is_box(set->p[0]);
11342 isl_bool isl_basic_set_is_wrapping(__isl_keep isl_basic_set *bset)
11344 if (!bset)
11345 return isl_bool_error;
11347 return isl_space_is_wrapping(bset->dim);
11350 isl_bool isl_set_is_wrapping(__isl_keep isl_set *set)
11352 if (!set)
11353 return isl_bool_error;
11355 return isl_space_is_wrapping(set->dim);
11358 /* Modify the space of "map" through a call to "change".
11359 * If "can_change" is set (not NULL), then first call it to check
11360 * if the modification is allowed, printing the error message "cannot_change"
11361 * if it is not.
11363 static __isl_give isl_map *isl_map_change_space(__isl_take isl_map *map,
11364 isl_bool (*can_change)(__isl_keep isl_map *map),
11365 const char *cannot_change,
11366 __isl_give isl_space *(*change)(__isl_take isl_space *space))
11368 isl_bool ok;
11369 isl_space *space;
11371 if (!map)
11372 return NULL;
11374 ok = can_change ? can_change(map) : isl_bool_true;
11375 if (ok < 0)
11376 return isl_map_free(map);
11377 if (!ok)
11378 isl_die(isl_map_get_ctx(map), isl_error_invalid, cannot_change,
11379 return isl_map_free(map));
11381 space = change(isl_map_get_space(map));
11382 map = isl_map_reset_space(map, space);
11384 return map;
11387 /* Is the domain of "map" a wrapped relation?
11389 isl_bool isl_map_domain_is_wrapping(__isl_keep isl_map *map)
11391 if (!map)
11392 return isl_bool_error;
11394 return isl_space_domain_is_wrapping(map->dim);
11397 /* Does "map" have a wrapped relation in both domain and range?
11399 isl_bool isl_map_is_product(__isl_keep isl_map *map)
11401 return isl_space_is_product(isl_map_peek_space(map));
11404 /* Is the range of "map" a wrapped relation?
11406 isl_bool isl_map_range_is_wrapping(__isl_keep isl_map *map)
11408 if (!map)
11409 return isl_bool_error;
11411 return isl_space_range_is_wrapping(map->dim);
11414 __isl_give isl_basic_set *isl_basic_map_wrap(__isl_take isl_basic_map *bmap)
11416 bmap = isl_basic_map_cow(bmap);
11417 if (!bmap)
11418 return NULL;
11420 bmap->dim = isl_space_wrap(bmap->dim);
11421 if (!bmap->dim)
11422 goto error;
11424 bmap = isl_basic_map_finalize(bmap);
11426 return bset_from_bmap(bmap);
11427 error:
11428 isl_basic_map_free(bmap);
11429 return NULL;
11432 /* Given a map A -> B, return the set (A -> B).
11434 __isl_give isl_set *isl_map_wrap(__isl_take isl_map *map)
11436 return isl_map_change_space(map, NULL, NULL, &isl_space_wrap);
11439 __isl_give isl_basic_map *isl_basic_set_unwrap(__isl_take isl_basic_set *bset)
11441 bset = isl_basic_set_cow(bset);
11442 if (!bset)
11443 return NULL;
11445 bset->dim = isl_space_unwrap(bset->dim);
11446 if (!bset->dim)
11447 goto error;
11449 bset = isl_basic_set_finalize(bset);
11451 return bset_to_bmap(bset);
11452 error:
11453 isl_basic_set_free(bset);
11454 return NULL;
11457 /* Given a set (A -> B), return the map A -> B.
11458 * Error out if "set" is not of the form (A -> B).
11460 __isl_give isl_map *isl_set_unwrap(__isl_take isl_set *set)
11462 return isl_map_change_space(set, &isl_set_is_wrapping,
11463 "not a wrapping set", &isl_space_unwrap);
11466 __isl_give isl_basic_map *isl_basic_map_reset(__isl_take isl_basic_map *bmap,
11467 enum isl_dim_type type)
11469 if (!bmap)
11470 return NULL;
11472 if (!isl_space_is_named_or_nested(bmap->dim, type))
11473 return bmap;
11475 bmap = isl_basic_map_cow(bmap);
11476 if (!bmap)
11477 return NULL;
11479 bmap->dim = isl_space_reset(bmap->dim, type);
11480 if (!bmap->dim)
11481 goto error;
11483 bmap = isl_basic_map_finalize(bmap);
11485 return bmap;
11486 error:
11487 isl_basic_map_free(bmap);
11488 return NULL;
11491 __isl_give isl_map *isl_map_reset(__isl_take isl_map *map,
11492 enum isl_dim_type type)
11494 int i;
11496 if (!map)
11497 return NULL;
11499 if (!isl_space_is_named_or_nested(map->dim, type))
11500 return map;
11502 map = isl_map_cow(map);
11503 if (!map)
11504 return NULL;
11506 for (i = 0; i < map->n; ++i) {
11507 map->p[i] = isl_basic_map_reset(map->p[i], type);
11508 if (!map->p[i])
11509 goto error;
11511 map->dim = isl_space_reset(map->dim, type);
11512 if (!map->dim)
11513 goto error;
11515 return map;
11516 error:
11517 isl_map_free(map);
11518 return NULL;
11521 __isl_give isl_basic_map *isl_basic_map_flatten(__isl_take isl_basic_map *bmap)
11523 if (!bmap)
11524 return NULL;
11526 if (!bmap->dim->nested[0] && !bmap->dim->nested[1])
11527 return bmap;
11529 bmap = isl_basic_map_cow(bmap);
11530 if (!bmap)
11531 return NULL;
11533 bmap->dim = isl_space_flatten(bmap->dim);
11534 if (!bmap->dim)
11535 goto error;
11537 bmap = isl_basic_map_finalize(bmap);
11539 return bmap;
11540 error:
11541 isl_basic_map_free(bmap);
11542 return NULL;
11545 __isl_give isl_basic_set *isl_basic_set_flatten(__isl_take isl_basic_set *bset)
11547 return bset_from_bmap(isl_basic_map_flatten(bset_to_bmap(bset)));
11550 __isl_give isl_basic_map *isl_basic_map_flatten_domain(
11551 __isl_take isl_basic_map *bmap)
11553 if (!bmap)
11554 return NULL;
11556 if (!bmap->dim->nested[0])
11557 return bmap;
11559 bmap = isl_basic_map_cow(bmap);
11560 if (!bmap)
11561 return NULL;
11563 bmap->dim = isl_space_flatten_domain(bmap->dim);
11564 if (!bmap->dim)
11565 goto error;
11567 bmap = isl_basic_map_finalize(bmap);
11569 return bmap;
11570 error:
11571 isl_basic_map_free(bmap);
11572 return NULL;
11575 __isl_give isl_basic_map *isl_basic_map_flatten_range(
11576 __isl_take isl_basic_map *bmap)
11578 if (!bmap)
11579 return NULL;
11581 if (!bmap->dim->nested[1])
11582 return bmap;
11584 bmap = isl_basic_map_cow(bmap);
11585 if (!bmap)
11586 return NULL;
11588 bmap->dim = isl_space_flatten_range(bmap->dim);
11589 if (!bmap->dim)
11590 goto error;
11592 bmap = isl_basic_map_finalize(bmap);
11594 return bmap;
11595 error:
11596 isl_basic_map_free(bmap);
11597 return NULL;
11600 /* Remove any internal structure from the spaces of domain and range of "map".
11602 __isl_give isl_map *isl_map_flatten(__isl_take isl_map *map)
11604 if (!map)
11605 return NULL;
11607 if (!map->dim->nested[0] && !map->dim->nested[1])
11608 return map;
11610 return isl_map_change_space(map, NULL, NULL, &isl_space_flatten);
11613 __isl_give isl_set *isl_set_flatten(__isl_take isl_set *set)
11615 return set_from_map(isl_map_flatten(set_to_map(set)));
11618 __isl_give isl_map *isl_set_flatten_map(__isl_take isl_set *set)
11620 isl_space *dim, *flat_dim;
11621 isl_map *map;
11623 dim = isl_set_get_space(set);
11624 flat_dim = isl_space_flatten(isl_space_copy(dim));
11625 map = isl_map_identity(isl_space_join(isl_space_reverse(dim), flat_dim));
11626 map = isl_map_intersect_domain(map, set);
11628 return map;
11631 /* Remove any internal structure from the space of the domain of "map".
11633 __isl_give isl_map *isl_map_flatten_domain(__isl_take isl_map *map)
11635 if (!map)
11636 return NULL;
11638 if (!map->dim->nested[0])
11639 return map;
11641 return isl_map_change_space(map, NULL, NULL, &isl_space_flatten_domain);
11644 /* Remove any internal structure from the space of the range of "map".
11646 __isl_give isl_map *isl_map_flatten_range(__isl_take isl_map *map)
11648 if (!map)
11649 return NULL;
11651 if (!map->dim->nested[1])
11652 return map;
11654 return isl_map_change_space(map, NULL, NULL, &isl_space_flatten_range);
11657 /* Reorder the dimensions of "bmap" according to the given dim_map
11658 * and set the dimension specification to "space" and
11659 * perform Gaussian elimination on the result.
11661 __isl_give isl_basic_map *isl_basic_map_realign(__isl_take isl_basic_map *bmap,
11662 __isl_take isl_space *space, __isl_take struct isl_dim_map *dim_map)
11664 isl_basic_map *res;
11665 unsigned flags;
11666 unsigned n_div;
11668 if (!bmap || !space || !dim_map)
11669 goto error;
11671 flags = bmap->flags;
11672 ISL_FL_CLR(flags, ISL_BASIC_MAP_FINAL);
11673 ISL_FL_CLR(flags, ISL_BASIC_MAP_NORMALIZED);
11674 ISL_FL_CLR(flags, ISL_BASIC_MAP_NORMALIZED_DIVS);
11675 n_div = isl_basic_map_dim(bmap, isl_dim_div);
11676 res = isl_basic_map_alloc_space(space, n_div, bmap->n_eq, bmap->n_ineq);
11677 res = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map);
11678 if (res)
11679 res->flags = flags;
11680 res = isl_basic_map_gauss(res, NULL);
11681 res = isl_basic_map_finalize(res);
11682 return res;
11683 error:
11684 free(dim_map);
11685 isl_basic_map_free(bmap);
11686 isl_space_free(space);
11687 return NULL;
11690 /* Reorder the dimensions of "map" according to given reordering.
11692 __isl_give isl_map *isl_map_realign(__isl_take isl_map *map,
11693 __isl_take isl_reordering *r)
11695 int i;
11696 struct isl_dim_map *dim_map;
11698 map = isl_map_cow(map);
11699 dim_map = isl_dim_map_from_reordering(r);
11700 if (!map || !r || !dim_map)
11701 goto error;
11703 for (i = 0; i < map->n; ++i) {
11704 struct isl_dim_map *dim_map_i;
11705 isl_space *space;
11707 dim_map_i = isl_dim_map_extend(dim_map, map->p[i]);
11709 space = isl_reordering_get_space(r);
11710 map->p[i] = isl_basic_map_realign(map->p[i], space, dim_map_i);
11712 if (!map->p[i])
11713 goto error;
11716 map = isl_map_reset_space(map, isl_reordering_get_space(r));
11717 map = isl_map_unmark_normalized(map);
11719 isl_reordering_free(r);
11720 free(dim_map);
11721 return map;
11722 error:
11723 free(dim_map);
11724 isl_map_free(map);
11725 isl_reordering_free(r);
11726 return NULL;
11729 __isl_give isl_set *isl_set_realign(__isl_take isl_set *set,
11730 __isl_take isl_reordering *r)
11732 return set_from_map(isl_map_realign(set_to_map(set), r));
11735 __isl_give isl_map *isl_map_align_params(__isl_take isl_map *map,
11736 __isl_take isl_space *model)
11738 isl_ctx *ctx;
11739 isl_bool aligned;
11741 if (!map || !model)
11742 goto error;
11744 ctx = isl_space_get_ctx(model);
11745 if (!isl_space_has_named_params(model))
11746 isl_die(ctx, isl_error_invalid,
11747 "model has unnamed parameters", goto error);
11748 if (isl_map_check_named_params(map) < 0)
11749 goto error;
11750 aligned = isl_map_space_has_equal_params(map, model);
11751 if (aligned < 0)
11752 goto error;
11753 if (!aligned) {
11754 isl_reordering *exp;
11756 model = isl_space_drop_dims(model, isl_dim_in,
11757 0, isl_space_dim(model, isl_dim_in));
11758 model = isl_space_drop_dims(model, isl_dim_out,
11759 0, isl_space_dim(model, isl_dim_out));
11760 exp = isl_parameter_alignment_reordering(map->dim, model);
11761 exp = isl_reordering_extend_space(exp, isl_map_get_space(map));
11762 map = isl_map_realign(map, exp);
11765 isl_space_free(model);
11766 return map;
11767 error:
11768 isl_space_free(model);
11769 isl_map_free(map);
11770 return NULL;
11773 __isl_give isl_set *isl_set_align_params(__isl_take isl_set *set,
11774 __isl_take isl_space *model)
11776 return isl_map_align_params(set, model);
11779 /* Align the parameters of "bmap" to those of "model", introducing
11780 * additional parameters if needed.
11782 __isl_give isl_basic_map *isl_basic_map_align_params(
11783 __isl_take isl_basic_map *bmap, __isl_take isl_space *model)
11785 isl_ctx *ctx;
11786 isl_bool equal_params;
11788 if (!bmap || !model)
11789 goto error;
11791 ctx = isl_space_get_ctx(model);
11792 if (!isl_space_has_named_params(model))
11793 isl_die(ctx, isl_error_invalid,
11794 "model has unnamed parameters", goto error);
11795 if (isl_basic_map_check_named_params(bmap) < 0)
11796 goto error;
11797 equal_params = isl_space_has_equal_params(bmap->dim, model);
11798 if (equal_params < 0)
11799 goto error;
11800 if (!equal_params) {
11801 isl_reordering *exp;
11802 struct isl_dim_map *dim_map;
11804 model = isl_space_drop_dims(model, isl_dim_in,
11805 0, isl_space_dim(model, isl_dim_in));
11806 model = isl_space_drop_dims(model, isl_dim_out,
11807 0, isl_space_dim(model, isl_dim_out));
11808 exp = isl_parameter_alignment_reordering(bmap->dim, model);
11809 exp = isl_reordering_extend_space(exp,
11810 isl_basic_map_get_space(bmap));
11811 dim_map = isl_dim_map_from_reordering(exp);
11812 bmap = isl_basic_map_realign(bmap,
11813 isl_reordering_get_space(exp),
11814 isl_dim_map_extend(dim_map, bmap));
11815 isl_reordering_free(exp);
11816 free(dim_map);
11819 isl_space_free(model);
11820 return bmap;
11821 error:
11822 isl_space_free(model);
11823 isl_basic_map_free(bmap);
11824 return NULL;
11827 /* Do "bset" and "space" have the same parameters?
11829 isl_bool isl_basic_set_space_has_equal_params(__isl_keep isl_basic_set *bset,
11830 __isl_keep isl_space *space)
11832 isl_space *bset_space;
11834 bset_space = isl_basic_set_peek_space(bset);
11835 return isl_space_has_equal_params(bset_space, space);
11838 /* Do "map" and "space" have the same parameters?
11840 isl_bool isl_map_space_has_equal_params(__isl_keep isl_map *map,
11841 __isl_keep isl_space *space)
11843 isl_space *map_space;
11845 map_space = isl_map_peek_space(map);
11846 return isl_space_has_equal_params(map_space, space);
11849 /* Do "set" and "space" have the same parameters?
11851 isl_bool isl_set_space_has_equal_params(__isl_keep isl_set *set,
11852 __isl_keep isl_space *space)
11854 return isl_map_space_has_equal_params(set_to_map(set), space);
11857 /* Align the parameters of "bset" to those of "model", introducing
11858 * additional parameters if needed.
11860 __isl_give isl_basic_set *isl_basic_set_align_params(
11861 __isl_take isl_basic_set *bset, __isl_take isl_space *model)
11863 return isl_basic_map_align_params(bset, model);
11866 /* Drop all parameters not referenced by "map".
11868 __isl_give isl_map *isl_map_drop_unused_params(__isl_take isl_map *map)
11870 int i;
11872 if (isl_map_check_named_params(map) < 0)
11873 return isl_map_free(map);
11875 for (i = isl_map_dim(map, isl_dim_param) - 1; i >= 0; i--) {
11876 isl_bool involves;
11878 involves = isl_map_involves_dims(map, isl_dim_param, i, 1);
11879 if (involves < 0)
11880 return isl_map_free(map);
11881 if (!involves)
11882 map = isl_map_project_out(map, isl_dim_param, i, 1);
11885 return map;
11888 /* Drop all parameters not referenced by "set".
11890 __isl_give isl_set *isl_set_drop_unused_params(
11891 __isl_take isl_set *set)
11893 return set_from_map(isl_map_drop_unused_params(set_to_map(set)));
11896 /* Drop all parameters not referenced by "bmap".
11898 __isl_give isl_basic_map *isl_basic_map_drop_unused_params(
11899 __isl_take isl_basic_map *bmap)
11901 int i;
11903 if (isl_basic_map_check_named_params(bmap) < 0)
11904 return isl_basic_map_free(bmap);
11906 for (i = isl_basic_map_dim(bmap, isl_dim_param) - 1; i >= 0; i--) {
11907 isl_bool involves;
11909 involves = isl_basic_map_involves_dims(bmap,
11910 isl_dim_param, i, 1);
11911 if (involves < 0)
11912 return isl_basic_map_free(bmap);
11913 if (!involves)
11914 bmap = isl_basic_map_drop(bmap, isl_dim_param, i, 1);
11917 return bmap;
11920 /* Drop all parameters not referenced by "bset".
11922 __isl_give isl_basic_set *isl_basic_set_drop_unused_params(
11923 __isl_take isl_basic_set *bset)
11925 return bset_from_bmap(isl_basic_map_drop_unused_params(
11926 bset_to_bmap(bset)));
11929 __isl_give isl_mat *isl_basic_map_equalities_matrix(
11930 __isl_keep isl_basic_map *bmap, enum isl_dim_type c1,
11931 enum isl_dim_type c2, enum isl_dim_type c3,
11932 enum isl_dim_type c4, enum isl_dim_type c5)
11934 enum isl_dim_type c[5] = { c1, c2, c3, c4, c5 };
11935 struct isl_mat *mat;
11936 int i, j, k;
11937 int pos;
11939 if (!bmap)
11940 return NULL;
11941 mat = isl_mat_alloc(bmap->ctx, bmap->n_eq,
11942 isl_basic_map_total_dim(bmap) + 1);
11943 if (!mat)
11944 return NULL;
11945 for (i = 0; i < bmap->n_eq; ++i)
11946 for (j = 0, pos = 0; j < 5; ++j) {
11947 int off = isl_basic_map_offset(bmap, c[j]);
11948 for (k = 0; k < isl_basic_map_dim(bmap, c[j]); ++k) {
11949 isl_int_set(mat->row[i][pos],
11950 bmap->eq[i][off + k]);
11951 ++pos;
11955 return mat;
11958 __isl_give isl_mat *isl_basic_map_inequalities_matrix(
11959 __isl_keep isl_basic_map *bmap, enum isl_dim_type c1,
11960 enum isl_dim_type c2, enum isl_dim_type c3,
11961 enum isl_dim_type c4, enum isl_dim_type c5)
11963 enum isl_dim_type c[5] = { c1, c2, c3, c4, c5 };
11964 struct isl_mat *mat;
11965 int i, j, k;
11966 int pos;
11968 if (!bmap)
11969 return NULL;
11970 mat = isl_mat_alloc(bmap->ctx, bmap->n_ineq,
11971 isl_basic_map_total_dim(bmap) + 1);
11972 if (!mat)
11973 return NULL;
11974 for (i = 0; i < bmap->n_ineq; ++i)
11975 for (j = 0, pos = 0; j < 5; ++j) {
11976 int off = isl_basic_map_offset(bmap, c[j]);
11977 for (k = 0; k < isl_basic_map_dim(bmap, c[j]); ++k) {
11978 isl_int_set(mat->row[i][pos],
11979 bmap->ineq[i][off + k]);
11980 ++pos;
11984 return mat;
11987 __isl_give isl_basic_map *isl_basic_map_from_constraint_matrices(
11988 __isl_take isl_space *dim,
11989 __isl_take isl_mat *eq, __isl_take isl_mat *ineq, enum isl_dim_type c1,
11990 enum isl_dim_type c2, enum isl_dim_type c3,
11991 enum isl_dim_type c4, enum isl_dim_type c5)
11993 enum isl_dim_type c[5] = { c1, c2, c3, c4, c5 };
11994 isl_basic_map *bmap;
11995 unsigned total;
11996 unsigned extra;
11997 int i, j, k, l;
11998 int pos;
12000 if (!dim || !eq || !ineq)
12001 goto error;
12003 if (eq->n_col != ineq->n_col)
12004 isl_die(dim->ctx, isl_error_invalid,
12005 "equalities and inequalities matrices should have "
12006 "same number of columns", goto error);
12008 total = 1 + isl_space_dim(dim, isl_dim_all);
12010 if (eq->n_col < total)
12011 isl_die(dim->ctx, isl_error_invalid,
12012 "number of columns too small", goto error);
12014 extra = eq->n_col - total;
12016 bmap = isl_basic_map_alloc_space(isl_space_copy(dim), extra,
12017 eq->n_row, ineq->n_row);
12018 if (!bmap)
12019 goto error;
12020 for (i = 0; i < extra; ++i) {
12021 k = isl_basic_map_alloc_div(bmap);
12022 if (k < 0)
12023 goto error;
12024 isl_int_set_si(bmap->div[k][0], 0);
12026 for (i = 0; i < eq->n_row; ++i) {
12027 l = isl_basic_map_alloc_equality(bmap);
12028 if (l < 0)
12029 goto error;
12030 for (j = 0, pos = 0; j < 5; ++j) {
12031 int off = isl_basic_map_offset(bmap, c[j]);
12032 for (k = 0; k < isl_basic_map_dim(bmap, c[j]); ++k) {
12033 isl_int_set(bmap->eq[l][off + k],
12034 eq->row[i][pos]);
12035 ++pos;
12039 for (i = 0; i < ineq->n_row; ++i) {
12040 l = isl_basic_map_alloc_inequality(bmap);
12041 if (l < 0)
12042 goto error;
12043 for (j = 0, pos = 0; j < 5; ++j) {
12044 int off = isl_basic_map_offset(bmap, c[j]);
12045 for (k = 0; k < isl_basic_map_dim(bmap, c[j]); ++k) {
12046 isl_int_set(bmap->ineq[l][off + k],
12047 ineq->row[i][pos]);
12048 ++pos;
12053 isl_space_free(dim);
12054 isl_mat_free(eq);
12055 isl_mat_free(ineq);
12057 bmap = isl_basic_map_simplify(bmap);
12058 return isl_basic_map_finalize(bmap);
12059 error:
12060 isl_space_free(dim);
12061 isl_mat_free(eq);
12062 isl_mat_free(ineq);
12063 return NULL;
12066 __isl_give isl_mat *isl_basic_set_equalities_matrix(
12067 __isl_keep isl_basic_set *bset, enum isl_dim_type c1,
12068 enum isl_dim_type c2, enum isl_dim_type c3, enum isl_dim_type c4)
12070 return isl_basic_map_equalities_matrix(bset_to_bmap(bset),
12071 c1, c2, c3, c4, isl_dim_in);
12074 __isl_give isl_mat *isl_basic_set_inequalities_matrix(
12075 __isl_keep isl_basic_set *bset, enum isl_dim_type c1,
12076 enum isl_dim_type c2, enum isl_dim_type c3, enum isl_dim_type c4)
12078 return isl_basic_map_inequalities_matrix(bset_to_bmap(bset),
12079 c1, c2, c3, c4, isl_dim_in);
12082 __isl_give isl_basic_set *isl_basic_set_from_constraint_matrices(
12083 __isl_take isl_space *dim,
12084 __isl_take isl_mat *eq, __isl_take isl_mat *ineq, enum isl_dim_type c1,
12085 enum isl_dim_type c2, enum isl_dim_type c3, enum isl_dim_type c4)
12087 isl_basic_map *bmap;
12088 bmap = isl_basic_map_from_constraint_matrices(dim, eq, ineq,
12089 c1, c2, c3, c4, isl_dim_in);
12090 return bset_from_bmap(bmap);
12093 isl_bool isl_basic_map_can_zip(__isl_keep isl_basic_map *bmap)
12095 if (!bmap)
12096 return isl_bool_error;
12098 return isl_space_can_zip(bmap->dim);
12101 isl_bool isl_map_can_zip(__isl_keep isl_map *map)
12103 if (!map)
12104 return isl_bool_error;
12106 return isl_space_can_zip(map->dim);
12109 /* Given a basic map (A -> B) -> (C -> D), return the corresponding basic map
12110 * (A -> C) -> (B -> D).
12112 __isl_give isl_basic_map *isl_basic_map_zip(__isl_take isl_basic_map *bmap)
12114 unsigned pos;
12115 unsigned n1;
12116 unsigned n2;
12118 if (!bmap)
12119 return NULL;
12121 if (!isl_basic_map_can_zip(bmap))
12122 isl_die(bmap->ctx, isl_error_invalid,
12123 "basic map cannot be zipped", goto error);
12124 pos = isl_basic_map_offset(bmap, isl_dim_in) +
12125 isl_space_dim(bmap->dim->nested[0], isl_dim_in);
12126 n1 = isl_space_dim(bmap->dim->nested[0], isl_dim_out);
12127 n2 = isl_space_dim(bmap->dim->nested[1], isl_dim_in);
12128 bmap = isl_basic_map_cow(bmap);
12129 bmap = isl_basic_map_swap_vars(bmap, pos, n1, n2);
12130 if (!bmap)
12131 return NULL;
12132 bmap->dim = isl_space_zip(bmap->dim);
12133 if (!bmap->dim)
12134 goto error;
12135 bmap = isl_basic_map_mark_final(bmap);
12136 return bmap;
12137 error:
12138 isl_basic_map_free(bmap);
12139 return NULL;
12142 /* Given a map (A -> B) -> (C -> D), return the corresponding map
12143 * (A -> C) -> (B -> D).
12145 __isl_give isl_map *isl_map_zip(__isl_take isl_map *map)
12147 int i;
12149 if (!map)
12150 return NULL;
12152 if (!isl_map_can_zip(map))
12153 isl_die(map->ctx, isl_error_invalid, "map cannot be zipped",
12154 goto error);
12156 map = isl_map_cow(map);
12157 if (!map)
12158 return NULL;
12160 for (i = 0; i < map->n; ++i) {
12161 map->p[i] = isl_basic_map_zip(map->p[i]);
12162 if (!map->p[i])
12163 goto error;
12166 map->dim = isl_space_zip(map->dim);
12167 if (!map->dim)
12168 goto error;
12170 return map;
12171 error:
12172 isl_map_free(map);
12173 return NULL;
12176 /* Can we apply isl_basic_map_curry to "bmap"?
12177 * That is, does it have a nested relation in its domain?
12179 isl_bool isl_basic_map_can_curry(__isl_keep isl_basic_map *bmap)
12181 if (!bmap)
12182 return isl_bool_error;
12184 return isl_space_can_curry(bmap->dim);
12187 /* Can we apply isl_map_curry to "map"?
12188 * That is, does it have a nested relation in its domain?
12190 isl_bool isl_map_can_curry(__isl_keep isl_map *map)
12192 if (!map)
12193 return isl_bool_error;
12195 return isl_space_can_curry(map->dim);
12198 /* Given a basic map (A -> B) -> C, return the corresponding basic map
12199 * A -> (B -> C).
12201 __isl_give isl_basic_map *isl_basic_map_curry(__isl_take isl_basic_map *bmap)
12204 if (!bmap)
12205 return NULL;
12207 if (!isl_basic_map_can_curry(bmap))
12208 isl_die(bmap->ctx, isl_error_invalid,
12209 "basic map cannot be curried", goto error);
12210 bmap = isl_basic_map_cow(bmap);
12211 if (!bmap)
12212 return NULL;
12213 bmap->dim = isl_space_curry(bmap->dim);
12214 if (!bmap->dim)
12215 goto error;
12216 bmap = isl_basic_map_mark_final(bmap);
12217 return bmap;
12218 error:
12219 isl_basic_map_free(bmap);
12220 return NULL;
12223 /* Given a map (A -> B) -> C, return the corresponding map
12224 * A -> (B -> C).
12226 __isl_give isl_map *isl_map_curry(__isl_take isl_map *map)
12228 return isl_map_change_space(map, &isl_map_can_curry,
12229 "map cannot be curried", &isl_space_curry);
12232 /* Can isl_map_range_curry be applied to "map"?
12233 * That is, does it have a nested relation in its range,
12234 * the domain of which is itself a nested relation?
12236 isl_bool isl_map_can_range_curry(__isl_keep isl_map *map)
12238 if (!map)
12239 return isl_bool_error;
12241 return isl_space_can_range_curry(map->dim);
12244 /* Given a map A -> ((B -> C) -> D), return the corresponding map
12245 * A -> (B -> (C -> D)).
12247 __isl_give isl_map *isl_map_range_curry(__isl_take isl_map *map)
12249 return isl_map_change_space(map, &isl_map_can_range_curry,
12250 "map range cannot be curried",
12251 &isl_space_range_curry);
12254 /* Can we apply isl_basic_map_uncurry to "bmap"?
12255 * That is, does it have a nested relation in its domain?
12257 isl_bool isl_basic_map_can_uncurry(__isl_keep isl_basic_map *bmap)
12259 if (!bmap)
12260 return isl_bool_error;
12262 return isl_space_can_uncurry(bmap->dim);
12265 /* Can we apply isl_map_uncurry to "map"?
12266 * That is, does it have a nested relation in its domain?
12268 isl_bool isl_map_can_uncurry(__isl_keep isl_map *map)
12270 if (!map)
12271 return isl_bool_error;
12273 return isl_space_can_uncurry(map->dim);
12276 /* Given a basic map A -> (B -> C), return the corresponding basic map
12277 * (A -> B) -> C.
12279 __isl_give isl_basic_map *isl_basic_map_uncurry(__isl_take isl_basic_map *bmap)
12282 if (!bmap)
12283 return NULL;
12285 if (!isl_basic_map_can_uncurry(bmap))
12286 isl_die(bmap->ctx, isl_error_invalid,
12287 "basic map cannot be uncurried",
12288 return isl_basic_map_free(bmap));
12289 bmap = isl_basic_map_cow(bmap);
12290 if (!bmap)
12291 return NULL;
12292 bmap->dim = isl_space_uncurry(bmap->dim);
12293 if (!bmap->dim)
12294 return isl_basic_map_free(bmap);
12295 bmap = isl_basic_map_mark_final(bmap);
12296 return bmap;
12299 /* Given a map A -> (B -> C), return the corresponding map
12300 * (A -> B) -> C.
12302 __isl_give isl_map *isl_map_uncurry(__isl_take isl_map *map)
12304 return isl_map_change_space(map, &isl_map_can_uncurry,
12305 "map cannot be uncurried", &isl_space_uncurry);
12308 /* Construct a basic map mapping the domain of the affine expression
12309 * to a one-dimensional range prescribed by the affine expression.
12310 * If "rational" is set, then construct a rational basic map.
12312 * A NaN affine expression cannot be converted to a basic map.
12314 static __isl_give isl_basic_map *isl_basic_map_from_aff2(
12315 __isl_take isl_aff *aff, int rational)
12317 int k;
12318 int pos;
12319 isl_bool is_nan;
12320 isl_local_space *ls;
12321 isl_basic_map *bmap = NULL;
12323 if (!aff)
12324 return NULL;
12325 is_nan = isl_aff_is_nan(aff);
12326 if (is_nan < 0)
12327 goto error;
12328 if (is_nan)
12329 isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
12330 "cannot convert NaN", goto error);
12332 ls = isl_aff_get_local_space(aff);
12333 bmap = isl_basic_map_from_local_space(ls);
12334 bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
12335 k = isl_basic_map_alloc_equality(bmap);
12336 if (k < 0)
12337 goto error;
12339 pos = isl_basic_map_offset(bmap, isl_dim_out);
12340 isl_seq_cpy(bmap->eq[k], aff->v->el + 1, pos);
12341 isl_int_neg(bmap->eq[k][pos], aff->v->el[0]);
12342 isl_seq_cpy(bmap->eq[k] + pos + 1, aff->v->el + 1 + pos,
12343 aff->v->size - (pos + 1));
12345 isl_aff_free(aff);
12346 if (rational)
12347 bmap = isl_basic_map_set_rational(bmap);
12348 bmap = isl_basic_map_gauss(bmap, NULL);
12349 bmap = isl_basic_map_finalize(bmap);
12350 return bmap;
12351 error:
12352 isl_aff_free(aff);
12353 isl_basic_map_free(bmap);
12354 return NULL;
12357 /* Construct a basic map mapping the domain of the affine expression
12358 * to a one-dimensional range prescribed by the affine expression.
12360 __isl_give isl_basic_map *isl_basic_map_from_aff(__isl_take isl_aff *aff)
12362 return isl_basic_map_from_aff2(aff, 0);
12365 /* Construct a map mapping the domain of the affine expression
12366 * to a one-dimensional range prescribed by the affine expression.
12368 __isl_give isl_map *isl_map_from_aff(__isl_take isl_aff *aff)
12370 isl_basic_map *bmap;
12372 bmap = isl_basic_map_from_aff(aff);
12373 return isl_map_from_basic_map(bmap);
12376 /* Construct a basic map mapping the domain the multi-affine expression
12377 * to its range, with each dimension in the range equated to the
12378 * corresponding affine expression.
12379 * If "rational" is set, then construct a rational basic map.
12381 __isl_give isl_basic_map *isl_basic_map_from_multi_aff2(
12382 __isl_take isl_multi_aff *maff, int rational)
12384 int i;
12385 isl_space *space;
12386 isl_basic_map *bmap;
12388 if (!maff)
12389 return NULL;
12391 if (isl_space_dim(maff->space, isl_dim_out) != maff->n)
12392 isl_die(isl_multi_aff_get_ctx(maff), isl_error_internal,
12393 "invalid space", goto error);
12395 space = isl_space_domain(isl_multi_aff_get_space(maff));
12396 bmap = isl_basic_map_universe(isl_space_from_domain(space));
12397 if (rational)
12398 bmap = isl_basic_map_set_rational(bmap);
12400 for (i = 0; i < maff->n; ++i) {
12401 isl_aff *aff;
12402 isl_basic_map *bmap_i;
12404 aff = isl_aff_copy(maff->u.p[i]);
12405 bmap_i = isl_basic_map_from_aff2(aff, rational);
12407 bmap = isl_basic_map_flat_range_product(bmap, bmap_i);
12410 bmap = isl_basic_map_reset_space(bmap, isl_multi_aff_get_space(maff));
12412 isl_multi_aff_free(maff);
12413 return bmap;
12414 error:
12415 isl_multi_aff_free(maff);
12416 return NULL;
12419 /* Construct a basic map mapping the domain the multi-affine expression
12420 * to its range, with each dimension in the range equated to the
12421 * corresponding affine expression.
12423 __isl_give isl_basic_map *isl_basic_map_from_multi_aff(
12424 __isl_take isl_multi_aff *ma)
12426 return isl_basic_map_from_multi_aff2(ma, 0);
12429 /* Construct a map mapping the domain the multi-affine expression
12430 * to its range, with each dimension in the range equated to the
12431 * corresponding affine expression.
12433 __isl_give isl_map *isl_map_from_multi_aff(__isl_take isl_multi_aff *maff)
12435 isl_basic_map *bmap;
12437 bmap = isl_basic_map_from_multi_aff(maff);
12438 return isl_map_from_basic_map(bmap);
12441 /* Construct a basic map mapping a domain in the given space to
12442 * to an n-dimensional range, with n the number of elements in the list,
12443 * where each coordinate in the range is prescribed by the
12444 * corresponding affine expression.
12445 * The domains of all affine expressions in the list are assumed to match
12446 * domain_dim.
12448 __isl_give isl_basic_map *isl_basic_map_from_aff_list(
12449 __isl_take isl_space *domain_dim, __isl_take isl_aff_list *list)
12451 int i;
12452 isl_space *dim;
12453 isl_basic_map *bmap;
12455 if (!list)
12456 return NULL;
12458 dim = isl_space_from_domain(domain_dim);
12459 bmap = isl_basic_map_universe(dim);
12461 for (i = 0; i < list->n; ++i) {
12462 isl_aff *aff;
12463 isl_basic_map *bmap_i;
12465 aff = isl_aff_copy(list->p[i]);
12466 bmap_i = isl_basic_map_from_aff(aff);
12468 bmap = isl_basic_map_flat_range_product(bmap, bmap_i);
12471 isl_aff_list_free(list);
12472 return bmap;
12475 __isl_give isl_set *isl_set_equate(__isl_take isl_set *set,
12476 enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
12478 return isl_map_equate(set, type1, pos1, type2, pos2);
12481 /* Construct a basic map where the given dimensions are equal to each other.
12483 static __isl_give isl_basic_map *equator(__isl_take isl_space *space,
12484 enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
12486 isl_basic_map *bmap = NULL;
12487 int i;
12489 if (!space)
12490 return NULL;
12492 if (pos1 >= isl_space_dim(space, type1))
12493 isl_die(isl_space_get_ctx(space), isl_error_invalid,
12494 "index out of bounds", goto error);
12495 if (pos2 >= isl_space_dim(space, type2))
12496 isl_die(isl_space_get_ctx(space), isl_error_invalid,
12497 "index out of bounds", goto error);
12499 if (type1 == type2 && pos1 == pos2)
12500 return isl_basic_map_universe(space);
12502 bmap = isl_basic_map_alloc_space(isl_space_copy(space), 0, 1, 0);
12503 i = isl_basic_map_alloc_equality(bmap);
12504 if (i < 0)
12505 goto error;
12506 isl_seq_clr(bmap->eq[i], 1 + isl_basic_map_total_dim(bmap));
12507 pos1 += isl_basic_map_offset(bmap, type1);
12508 pos2 += isl_basic_map_offset(bmap, type2);
12509 isl_int_set_si(bmap->eq[i][pos1], -1);
12510 isl_int_set_si(bmap->eq[i][pos2], 1);
12511 bmap = isl_basic_map_finalize(bmap);
12512 isl_space_free(space);
12513 return bmap;
12514 error:
12515 isl_space_free(space);
12516 isl_basic_map_free(bmap);
12517 return NULL;
12520 /* Add a constraint imposing that the given two dimensions are equal.
12522 __isl_give isl_basic_map *isl_basic_map_equate(__isl_take isl_basic_map *bmap,
12523 enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
12525 isl_basic_map *eq;
12527 eq = equator(isl_basic_map_get_space(bmap), type1, pos1, type2, pos2);
12529 bmap = isl_basic_map_intersect(bmap, eq);
12531 return bmap;
12534 /* Add a constraint imposing that the given two dimensions are equal.
12536 __isl_give isl_map *isl_map_equate(__isl_take isl_map *map,
12537 enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
12539 isl_basic_map *bmap;
12541 bmap = equator(isl_map_get_space(map), type1, pos1, type2, pos2);
12543 map = isl_map_intersect(map, isl_map_from_basic_map(bmap));
12545 return map;
12548 /* Add a constraint imposing that the given two dimensions have opposite values.
12550 __isl_give isl_map *isl_map_oppose(__isl_take isl_map *map,
12551 enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
12553 isl_basic_map *bmap = NULL;
12554 int i;
12556 if (!map)
12557 return NULL;
12559 if (pos1 >= isl_map_dim(map, type1))
12560 isl_die(map->ctx, isl_error_invalid,
12561 "index out of bounds", goto error);
12562 if (pos2 >= isl_map_dim(map, type2))
12563 isl_die(map->ctx, isl_error_invalid,
12564 "index out of bounds", goto error);
12566 bmap = isl_basic_map_alloc_space(isl_map_get_space(map), 0, 1, 0);
12567 i = isl_basic_map_alloc_equality(bmap);
12568 if (i < 0)
12569 goto error;
12570 isl_seq_clr(bmap->eq[i], 1 + isl_basic_map_total_dim(bmap));
12571 pos1 += isl_basic_map_offset(bmap, type1);
12572 pos2 += isl_basic_map_offset(bmap, type2);
12573 isl_int_set_si(bmap->eq[i][pos1], 1);
12574 isl_int_set_si(bmap->eq[i][pos2], 1);
12575 bmap = isl_basic_map_finalize(bmap);
12577 map = isl_map_intersect(map, isl_map_from_basic_map(bmap));
12579 return map;
12580 error:
12581 isl_basic_map_free(bmap);
12582 isl_map_free(map);
12583 return NULL;
12586 /* Construct a constraint imposing that the value of the first dimension is
12587 * greater than or equal to that of the second.
12589 static __isl_give isl_constraint *constraint_order_ge(
12590 __isl_take isl_space *space, enum isl_dim_type type1, int pos1,
12591 enum isl_dim_type type2, int pos2)
12593 isl_constraint *c;
12595 if (!space)
12596 return NULL;
12598 c = isl_constraint_alloc_inequality(isl_local_space_from_space(space));
12600 if (pos1 >= isl_constraint_dim(c, type1))
12601 isl_die(isl_constraint_get_ctx(c), isl_error_invalid,
12602 "index out of bounds", return isl_constraint_free(c));
12603 if (pos2 >= isl_constraint_dim(c, type2))
12604 isl_die(isl_constraint_get_ctx(c), isl_error_invalid,
12605 "index out of bounds", return isl_constraint_free(c));
12607 if (type1 == type2 && pos1 == pos2)
12608 return c;
12610 c = isl_constraint_set_coefficient_si(c, type1, pos1, 1);
12611 c = isl_constraint_set_coefficient_si(c, type2, pos2, -1);
12613 return c;
12616 /* Add a constraint imposing that the value of the first dimension is
12617 * greater than or equal to that of the second.
12619 __isl_give isl_basic_map *isl_basic_map_order_ge(__isl_take isl_basic_map *bmap,
12620 enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
12622 isl_constraint *c;
12623 isl_space *space;
12625 if (type1 == type2 && pos1 == pos2)
12626 return bmap;
12627 space = isl_basic_map_get_space(bmap);
12628 c = constraint_order_ge(space, type1, pos1, type2, pos2);
12629 bmap = isl_basic_map_add_constraint(bmap, c);
12631 return bmap;
12634 /* Add a constraint imposing that the value of the first dimension is
12635 * greater than or equal to that of the second.
12637 __isl_give isl_map *isl_map_order_ge(__isl_take isl_map *map,
12638 enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
12640 isl_constraint *c;
12641 isl_space *space;
12643 if (type1 == type2 && pos1 == pos2)
12644 return map;
12645 space = isl_map_get_space(map);
12646 c = constraint_order_ge(space, type1, pos1, type2, pos2);
12647 map = isl_map_add_constraint(map, c);
12649 return map;
12652 /* Add a constraint imposing that the value of the first dimension is
12653 * less than or equal to that of the second.
12655 __isl_give isl_map *isl_map_order_le(__isl_take isl_map *map,
12656 enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
12658 return isl_map_order_ge(map, type2, pos2, type1, pos1);
12661 /* Construct a basic map where the value of the first dimension is
12662 * greater than that of the second.
12664 static __isl_give isl_basic_map *greator(__isl_take isl_space *space,
12665 enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
12667 isl_basic_map *bmap = NULL;
12668 int i;
12670 if (!space)
12671 return NULL;
12673 if (pos1 >= isl_space_dim(space, type1))
12674 isl_die(isl_space_get_ctx(space), isl_error_invalid,
12675 "index out of bounds", goto error);
12676 if (pos2 >= isl_space_dim(space, type2))
12677 isl_die(isl_space_get_ctx(space), isl_error_invalid,
12678 "index out of bounds", goto error);
12680 if (type1 == type2 && pos1 == pos2)
12681 return isl_basic_map_empty(space);
12683 bmap = isl_basic_map_alloc_space(space, 0, 0, 1);
12684 i = isl_basic_map_alloc_inequality(bmap);
12685 if (i < 0)
12686 return isl_basic_map_free(bmap);
12687 isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap));
12688 pos1 += isl_basic_map_offset(bmap, type1);
12689 pos2 += isl_basic_map_offset(bmap, type2);
12690 isl_int_set_si(bmap->ineq[i][pos1], 1);
12691 isl_int_set_si(bmap->ineq[i][pos2], -1);
12692 isl_int_set_si(bmap->ineq[i][0], -1);
12693 bmap = isl_basic_map_finalize(bmap);
12695 return bmap;
12696 error:
12697 isl_space_free(space);
12698 isl_basic_map_free(bmap);
12699 return NULL;
12702 /* Add a constraint imposing that the value of the first dimension is
12703 * greater than that of the second.
12705 __isl_give isl_basic_map *isl_basic_map_order_gt(__isl_take isl_basic_map *bmap,
12706 enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
12708 isl_basic_map *gt;
12710 gt = greator(isl_basic_map_get_space(bmap), type1, pos1, type2, pos2);
12712 bmap = isl_basic_map_intersect(bmap, gt);
12714 return bmap;
12717 /* Add a constraint imposing that the value of the first dimension is
12718 * greater than that of the second.
12720 __isl_give isl_map *isl_map_order_gt(__isl_take isl_map *map,
12721 enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
12723 isl_basic_map *bmap;
12725 bmap = greator(isl_map_get_space(map), type1, pos1, type2, pos2);
12727 map = isl_map_intersect(map, isl_map_from_basic_map(bmap));
12729 return map;
12732 /* Add a constraint imposing that the value of the first dimension is
12733 * smaller than that of the second.
12735 __isl_give isl_map *isl_map_order_lt(__isl_take isl_map *map,
12736 enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
12738 return isl_map_order_gt(map, type2, pos2, type1, pos1);
12741 __isl_give isl_aff *isl_basic_map_get_div(__isl_keep isl_basic_map *bmap,
12742 int pos)
12744 isl_aff *div;
12745 isl_local_space *ls;
12747 if (!bmap)
12748 return NULL;
12750 if (!isl_basic_map_divs_known(bmap))
12751 isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
12752 "some divs are unknown", return NULL);
12754 ls = isl_basic_map_get_local_space(bmap);
12755 div = isl_local_space_get_div(ls, pos);
12756 isl_local_space_free(ls);
12758 return div;
12761 __isl_give isl_aff *isl_basic_set_get_div(__isl_keep isl_basic_set *bset,
12762 int pos)
12764 return isl_basic_map_get_div(bset, pos);
12767 /* Plug in "subs" for dimension "type", "pos" of "bset".
12769 * Let i be the dimension to replace and let "subs" be of the form
12771 * f/d
12773 * Any integer division with a non-zero coefficient for i,
12775 * floor((a i + g)/m)
12777 * is replaced by
12779 * floor((a f + d g)/(m d))
12781 * Constraints of the form
12783 * a i + g
12785 * are replaced by
12787 * a f + d g
12789 * We currently require that "subs" is an integral expression.
12790 * Handling rational expressions may require us to add stride constraints
12791 * as we do in isl_basic_set_preimage_multi_aff.
12793 __isl_give isl_basic_set *isl_basic_set_substitute(
12794 __isl_take isl_basic_set *bset,
12795 enum isl_dim_type type, unsigned pos, __isl_keep isl_aff *subs)
12797 int i;
12798 isl_int v;
12799 isl_ctx *ctx;
12801 if (bset && isl_basic_set_plain_is_empty(bset))
12802 return bset;
12804 bset = isl_basic_set_cow(bset);
12805 if (!bset || !subs)
12806 goto error;
12808 ctx = isl_basic_set_get_ctx(bset);
12809 if (!isl_space_is_equal(bset->dim, subs->ls->dim))
12810 isl_die(ctx, isl_error_invalid,
12811 "spaces don't match", goto error);
12812 if (isl_local_space_dim(subs->ls, isl_dim_div) != 0)
12813 isl_die(ctx, isl_error_unsupported,
12814 "cannot handle divs yet", goto error);
12815 if (!isl_int_is_one(subs->v->el[0]))
12816 isl_die(ctx, isl_error_invalid,
12817 "can only substitute integer expressions", goto error);
12819 pos += isl_basic_set_offset(bset, type);
12821 isl_int_init(v);
12823 for (i = 0; i < bset->n_eq; ++i) {
12824 if (isl_int_is_zero(bset->eq[i][pos]))
12825 continue;
12826 isl_int_set(v, bset->eq[i][pos]);
12827 isl_int_set_si(bset->eq[i][pos], 0);
12828 isl_seq_combine(bset->eq[i], subs->v->el[0], bset->eq[i],
12829 v, subs->v->el + 1, subs->v->size - 1);
12832 for (i = 0; i < bset->n_ineq; ++i) {
12833 if (isl_int_is_zero(bset->ineq[i][pos]))
12834 continue;
12835 isl_int_set(v, bset->ineq[i][pos]);
12836 isl_int_set_si(bset->ineq[i][pos], 0);
12837 isl_seq_combine(bset->ineq[i], subs->v->el[0], bset->ineq[i],
12838 v, subs->v->el + 1, subs->v->size - 1);
12841 for (i = 0; i < bset->n_div; ++i) {
12842 if (isl_int_is_zero(bset->div[i][1 + pos]))
12843 continue;
12844 isl_int_set(v, bset->div[i][1 + pos]);
12845 isl_int_set_si(bset->div[i][1 + pos], 0);
12846 isl_seq_combine(bset->div[i] + 1,
12847 subs->v->el[0], bset->div[i] + 1,
12848 v, subs->v->el + 1, subs->v->size - 1);
12849 isl_int_mul(bset->div[i][0], bset->div[i][0], subs->v->el[0]);
12852 isl_int_clear(v);
12854 bset = isl_basic_set_simplify(bset);
12855 return isl_basic_set_finalize(bset);
12856 error:
12857 isl_basic_set_free(bset);
12858 return NULL;
12861 /* Plug in "subs" for dimension "type", "pos" of "set".
12863 __isl_give isl_set *isl_set_substitute(__isl_take isl_set *set,
12864 enum isl_dim_type type, unsigned pos, __isl_keep isl_aff *subs)
12866 int i;
12868 if (set && isl_set_plain_is_empty(set))
12869 return set;
12871 set = isl_set_cow(set);
12872 if (!set || !subs)
12873 goto error;
12875 for (i = set->n - 1; i >= 0; --i) {
12876 set->p[i] = isl_basic_set_substitute(set->p[i], type, pos, subs);
12877 set = set_from_map(remove_if_empty(set_to_map(set), i));
12878 if (!set)
12879 return NULL;
12882 return set;
12883 error:
12884 isl_set_free(set);
12885 return NULL;
12888 /* Check if the range of "ma" is compatible with the domain or range
12889 * (depending on "type") of "bmap".
12891 static isl_stat check_basic_map_compatible_range_multi_aff(
12892 __isl_keep isl_basic_map *bmap, enum isl_dim_type type,
12893 __isl_keep isl_multi_aff *ma)
12895 isl_bool m;
12896 isl_space *ma_space;
12898 ma_space = isl_multi_aff_get_space(ma);
12900 m = isl_space_has_equal_params(bmap->dim, ma_space);
12901 if (m < 0)
12902 goto error;
12903 if (!m)
12904 isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
12905 "parameters don't match", goto error);
12906 m = isl_space_tuple_is_equal(bmap->dim, type, ma_space, isl_dim_out);
12907 if (m < 0)
12908 goto error;
12909 if (!m)
12910 isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
12911 "spaces don't match", goto error);
12913 isl_space_free(ma_space);
12914 return isl_stat_ok;
12915 error:
12916 isl_space_free(ma_space);
12917 return isl_stat_error;
12920 /* Copy the divs from "ma" to "bmap", adding zeros for the "n_before"
12921 * coefficients before the transformed range of dimensions,
12922 * the "n_after" coefficients after the transformed range of dimensions
12923 * and the coefficients of the other divs in "bmap".
12925 static int set_ma_divs(__isl_keep isl_basic_map *bmap,
12926 __isl_keep isl_multi_aff *ma, int n_before, int n_after, int n_div)
12928 int i;
12929 int n_param;
12930 int n_set;
12931 isl_local_space *ls;
12933 if (n_div == 0)
12934 return 0;
12936 ls = isl_aff_get_domain_local_space(ma->u.p[0]);
12937 if (!ls)
12938 return -1;
12940 n_param = isl_local_space_dim(ls, isl_dim_param);
12941 n_set = isl_local_space_dim(ls, isl_dim_set);
12942 for (i = 0; i < n_div; ++i) {
12943 int o_bmap = 0, o_ls = 0;
12945 isl_seq_cpy(bmap->div[i], ls->div->row[i], 1 + 1 + n_param);
12946 o_bmap += 1 + 1 + n_param;
12947 o_ls += 1 + 1 + n_param;
12948 isl_seq_clr(bmap->div[i] + o_bmap, n_before);
12949 o_bmap += n_before;
12950 isl_seq_cpy(bmap->div[i] + o_bmap,
12951 ls->div->row[i] + o_ls, n_set);
12952 o_bmap += n_set;
12953 o_ls += n_set;
12954 isl_seq_clr(bmap->div[i] + o_bmap, n_after);
12955 o_bmap += n_after;
12956 isl_seq_cpy(bmap->div[i] + o_bmap,
12957 ls->div->row[i] + o_ls, n_div);
12958 o_bmap += n_div;
12959 o_ls += n_div;
12960 isl_seq_clr(bmap->div[i] + o_bmap, bmap->n_div - n_div);
12961 if (isl_basic_map_add_div_constraints(bmap, i) < 0)
12962 goto error;
12965 isl_local_space_free(ls);
12966 return 0;
12967 error:
12968 isl_local_space_free(ls);
12969 return -1;
12972 /* How many stride constraints does "ma" enforce?
12973 * That is, how many of the affine expressions have a denominator
12974 * different from one?
12976 static int multi_aff_strides(__isl_keep isl_multi_aff *ma)
12978 int i;
12979 int strides = 0;
12981 for (i = 0; i < ma->n; ++i)
12982 if (!isl_int_is_one(ma->u.p[i]->v->el[0]))
12983 strides++;
12985 return strides;
12988 /* For each affine expression in ma of the form
12990 * x_i = (f_i y + h_i)/m_i
12992 * with m_i different from one, add a constraint to "bmap"
12993 * of the form
12995 * f_i y + h_i = m_i alpha_i
12997 * with alpha_i an additional existentially quantified variable.
12999 * The input variables of "ma" correspond to a subset of the variables
13000 * of "bmap". There are "n_before" variables in "bmap" before this
13001 * subset and "n_after" variables after this subset.
13002 * The integer divisions of the affine expressions in "ma" are assumed
13003 * to have been aligned. There are "n_div_ma" of them and
13004 * they appear first in "bmap", straight after the "n_after" variables.
13006 static __isl_give isl_basic_map *add_ma_strides(
13007 __isl_take isl_basic_map *bmap, __isl_keep isl_multi_aff *ma,
13008 int n_before, int n_after, int n_div_ma)
13010 int i, k;
13011 int div;
13012 int total;
13013 int n_param;
13014 int n_in;
13016 total = isl_basic_map_total_dim(bmap);
13017 n_param = isl_multi_aff_dim(ma, isl_dim_param);
13018 n_in = isl_multi_aff_dim(ma, isl_dim_in);
13019 for (i = 0; i < ma->n; ++i) {
13020 int o_bmap = 0, o_ma = 1;
13022 if (isl_int_is_one(ma->u.p[i]->v->el[0]))
13023 continue;
13024 div = isl_basic_map_alloc_div(bmap);
13025 k = isl_basic_map_alloc_equality(bmap);
13026 if (div < 0 || k < 0)
13027 goto error;
13028 isl_int_set_si(bmap->div[div][0], 0);
13029 isl_seq_cpy(bmap->eq[k] + o_bmap,
13030 ma->u.p[i]->v->el + o_ma, 1 + n_param);
13031 o_bmap += 1 + n_param;
13032 o_ma += 1 + n_param;
13033 isl_seq_clr(bmap->eq[k] + o_bmap, n_before);
13034 o_bmap += n_before;
13035 isl_seq_cpy(bmap->eq[k] + o_bmap,
13036 ma->u.p[i]->v->el + o_ma, n_in);
13037 o_bmap += n_in;
13038 o_ma += n_in;
13039 isl_seq_clr(bmap->eq[k] + o_bmap, n_after);
13040 o_bmap += n_after;
13041 isl_seq_cpy(bmap->eq[k] + o_bmap,
13042 ma->u.p[i]->v->el + o_ma, n_div_ma);
13043 o_bmap += n_div_ma;
13044 o_ma += n_div_ma;
13045 isl_seq_clr(bmap->eq[k] + o_bmap, 1 + total - o_bmap);
13046 isl_int_neg(bmap->eq[k][1 + total], ma->u.p[i]->v->el[0]);
13047 total++;
13050 return bmap;
13051 error:
13052 isl_basic_map_free(bmap);
13053 return NULL;
13056 /* Replace the domain or range space (depending on "type) of "space" by "set".
13058 static __isl_give isl_space *isl_space_set(__isl_take isl_space *space,
13059 enum isl_dim_type type, __isl_take isl_space *set)
13061 if (type == isl_dim_in) {
13062 space = isl_space_range(space);
13063 space = isl_space_map_from_domain_and_range(set, space);
13064 } else {
13065 space = isl_space_domain(space);
13066 space = isl_space_map_from_domain_and_range(space, set);
13069 return space;
13072 /* Compute the preimage of the domain or range (depending on "type")
13073 * of "bmap" under the function represented by "ma".
13074 * In other words, plug in "ma" in the domain or range of "bmap".
13075 * The result is a basic map that lives in the same space as "bmap"
13076 * except that the domain or range has been replaced by
13077 * the domain space of "ma".
13079 * If bmap is represented by
13081 * A(p) + S u + B x + T v + C(divs) >= 0,
13083 * where u and x are input and output dimensions if type == isl_dim_out
13084 * while x and v are input and output dimensions if type == isl_dim_in,
13085 * and ma is represented by
13087 * x = D(p) + F(y) + G(divs')
13089 * then the result is
13091 * A(p) + B D(p) + S u + B F(y) + T v + B G(divs') + C(divs) >= 0
13093 * The divs in the input set are similarly adjusted.
13094 * In particular
13096 * floor((a_i(p) + s u + b_i x + t v + c_i(divs))/n_i)
13098 * becomes
13100 * floor((a_i(p) + b_i D(p) + s u + b_i F(y) + t v +
13101 * B_i G(divs') + c_i(divs))/n_i)
13103 * If bmap is not a rational map and if F(y) involves any denominators
13105 * x_i = (f_i y + h_i)/m_i
13107 * then additional constraints are added to ensure that we only
13108 * map back integer points. That is we enforce
13110 * f_i y + h_i = m_i alpha_i
13112 * with alpha_i an additional existentially quantified variable.
13114 * We first copy over the divs from "ma".
13115 * Then we add the modified constraints and divs from "bmap".
13116 * Finally, we add the stride constraints, if needed.
13118 __isl_give isl_basic_map *isl_basic_map_preimage_multi_aff(
13119 __isl_take isl_basic_map *bmap, enum isl_dim_type type,
13120 __isl_take isl_multi_aff *ma)
13122 int i, k;
13123 isl_space *space;
13124 isl_basic_map *res = NULL;
13125 int n_before, n_after, n_div_bmap, n_div_ma;
13126 isl_int f, c1, c2, g;
13127 isl_bool rational;
13128 int strides;
13130 isl_int_init(f);
13131 isl_int_init(c1);
13132 isl_int_init(c2);
13133 isl_int_init(g);
13135 ma = isl_multi_aff_align_divs(ma);
13136 if (!bmap || !ma)
13137 goto error;
13138 if (check_basic_map_compatible_range_multi_aff(bmap, type, ma) < 0)
13139 goto error;
13141 if (type == isl_dim_in) {
13142 n_before = 0;
13143 n_after = isl_basic_map_dim(bmap, isl_dim_out);
13144 } else {
13145 n_before = isl_basic_map_dim(bmap, isl_dim_in);
13146 n_after = 0;
13148 n_div_bmap = isl_basic_map_dim(bmap, isl_dim_div);
13149 n_div_ma = ma->n ? isl_aff_dim(ma->u.p[0], isl_dim_div) : 0;
13151 space = isl_multi_aff_get_domain_space(ma);
13152 space = isl_space_set(isl_basic_map_get_space(bmap), type, space);
13153 rational = isl_basic_map_is_rational(bmap);
13154 strides = rational ? 0 : multi_aff_strides(ma);
13155 res = isl_basic_map_alloc_space(space, n_div_ma + n_div_bmap + strides,
13156 bmap->n_eq + strides, bmap->n_ineq + 2 * n_div_ma);
13157 if (rational)
13158 res = isl_basic_map_set_rational(res);
13160 for (i = 0; i < n_div_ma + n_div_bmap; ++i)
13161 if (isl_basic_map_alloc_div(res) < 0)
13162 goto error;
13164 if (set_ma_divs(res, ma, n_before, n_after, n_div_ma) < 0)
13165 goto error;
13167 for (i = 0; i < bmap->n_eq; ++i) {
13168 k = isl_basic_map_alloc_equality(res);
13169 if (k < 0)
13170 goto error;
13171 isl_seq_preimage(res->eq[k], bmap->eq[i], ma, n_before,
13172 n_after, n_div_ma, n_div_bmap, f, c1, c2, g, 0);
13175 for (i = 0; i < bmap->n_ineq; ++i) {
13176 k = isl_basic_map_alloc_inequality(res);
13177 if (k < 0)
13178 goto error;
13179 isl_seq_preimage(res->ineq[k], bmap->ineq[i], ma, n_before,
13180 n_after, n_div_ma, n_div_bmap, f, c1, c2, g, 0);
13183 for (i = 0; i < bmap->n_div; ++i) {
13184 if (isl_int_is_zero(bmap->div[i][0])) {
13185 isl_int_set_si(res->div[n_div_ma + i][0], 0);
13186 continue;
13188 isl_seq_preimage(res->div[n_div_ma + i], bmap->div[i], ma,
13189 n_before, n_after, n_div_ma, n_div_bmap,
13190 f, c1, c2, g, 1);
13193 if (strides)
13194 res = add_ma_strides(res, ma, n_before, n_after, n_div_ma);
13196 isl_int_clear(f);
13197 isl_int_clear(c1);
13198 isl_int_clear(c2);
13199 isl_int_clear(g);
13200 isl_basic_map_free(bmap);
13201 isl_multi_aff_free(ma);
13202 res = isl_basic_map_simplify(res);
13203 return isl_basic_map_finalize(res);
13204 error:
13205 isl_int_clear(f);
13206 isl_int_clear(c1);
13207 isl_int_clear(c2);
13208 isl_int_clear(g);
13209 isl_basic_map_free(bmap);
13210 isl_multi_aff_free(ma);
13211 isl_basic_map_free(res);
13212 return NULL;
13215 /* Compute the preimage of "bset" under the function represented by "ma".
13216 * In other words, plug in "ma" in "bset". The result is a basic set
13217 * that lives in the domain space of "ma".
13219 __isl_give isl_basic_set *isl_basic_set_preimage_multi_aff(
13220 __isl_take isl_basic_set *bset, __isl_take isl_multi_aff *ma)
13222 return isl_basic_map_preimage_multi_aff(bset, isl_dim_set, ma);
13225 /* Compute the preimage of the domain of "bmap" under the function
13226 * represented by "ma".
13227 * In other words, plug in "ma" in the domain of "bmap".
13228 * The result is a basic map that lives in the same space as "bmap"
13229 * except that the domain has been replaced by the domain space of "ma".
13231 __isl_give isl_basic_map *isl_basic_map_preimage_domain_multi_aff(
13232 __isl_take isl_basic_map *bmap, __isl_take isl_multi_aff *ma)
13234 return isl_basic_map_preimage_multi_aff(bmap, isl_dim_in, ma);
13237 /* Compute the preimage of the range of "bmap" under the function
13238 * represented by "ma".
13239 * In other words, plug in "ma" in the range of "bmap".
13240 * The result is a basic map that lives in the same space as "bmap"
13241 * except that the range has been replaced by the domain space of "ma".
13243 __isl_give isl_basic_map *isl_basic_map_preimage_range_multi_aff(
13244 __isl_take isl_basic_map *bmap, __isl_take isl_multi_aff *ma)
13246 return isl_basic_map_preimage_multi_aff(bmap, isl_dim_out, ma);
13249 /* Check if the range of "ma" is compatible with the domain or range
13250 * (depending on "type") of "map".
13251 * Return isl_stat_error if anything is wrong.
13253 static isl_stat check_map_compatible_range_multi_aff(
13254 __isl_keep isl_map *map, enum isl_dim_type type,
13255 __isl_keep isl_multi_aff *ma)
13257 isl_bool m;
13258 isl_space *ma_space;
13260 ma_space = isl_multi_aff_get_space(ma);
13261 m = isl_space_tuple_is_equal(map->dim, type, ma_space, isl_dim_out);
13262 isl_space_free(ma_space);
13263 if (m < 0)
13264 return isl_stat_error;
13265 if (!m)
13266 isl_die(isl_map_get_ctx(map), isl_error_invalid,
13267 "spaces don't match", return isl_stat_error);
13268 return isl_stat_ok;
13271 /* Compute the preimage of the domain or range (depending on "type")
13272 * of "map" under the function represented by "ma".
13273 * In other words, plug in "ma" in the domain or range of "map".
13274 * The result is a map that lives in the same space as "map"
13275 * except that the domain or range has been replaced by
13276 * the domain space of "ma".
13278 * The parameters are assumed to have been aligned.
13280 static __isl_give isl_map *map_preimage_multi_aff(__isl_take isl_map *map,
13281 enum isl_dim_type type, __isl_take isl_multi_aff *ma)
13283 int i;
13284 isl_space *space;
13286 map = isl_map_cow(map);
13287 ma = isl_multi_aff_align_divs(ma);
13288 if (!map || !ma)
13289 goto error;
13290 if (check_map_compatible_range_multi_aff(map, type, ma) < 0)
13291 goto error;
13293 for (i = 0; i < map->n; ++i) {
13294 map->p[i] = isl_basic_map_preimage_multi_aff(map->p[i], type,
13295 isl_multi_aff_copy(ma));
13296 if (!map->p[i])
13297 goto error;
13300 space = isl_multi_aff_get_domain_space(ma);
13301 space = isl_space_set(isl_map_get_space(map), type, space);
13303 isl_space_free(map->dim);
13304 map->dim = space;
13305 if (!map->dim)
13306 goto error;
13308 isl_multi_aff_free(ma);
13309 if (map->n > 1)
13310 ISL_F_CLR(map, ISL_MAP_DISJOINT);
13311 ISL_F_CLR(map, ISL_SET_NORMALIZED);
13312 return map;
13313 error:
13314 isl_multi_aff_free(ma);
13315 isl_map_free(map);
13316 return NULL;
13319 /* Compute the preimage of the domain or range (depending on "type")
13320 * of "map" under the function represented by "ma".
13321 * In other words, plug in "ma" in the domain or range of "map".
13322 * The result is a map that lives in the same space as "map"
13323 * except that the domain or range has been replaced by
13324 * the domain space of "ma".
13326 __isl_give isl_map *isl_map_preimage_multi_aff(__isl_take isl_map *map,
13327 enum isl_dim_type type, __isl_take isl_multi_aff *ma)
13329 isl_bool aligned;
13331 if (!map || !ma)
13332 goto error;
13334 aligned = isl_map_space_has_equal_params(map, ma->space);
13335 if (aligned < 0)
13336 goto error;
13337 if (aligned)
13338 return map_preimage_multi_aff(map, type, ma);
13340 if (isl_map_check_named_params(map) < 0)
13341 goto error;
13342 if (!isl_space_has_named_params(ma->space))
13343 isl_die(map->ctx, isl_error_invalid,
13344 "unaligned unnamed parameters", goto error);
13345 map = isl_map_align_params(map, isl_multi_aff_get_space(ma));
13346 ma = isl_multi_aff_align_params(ma, isl_map_get_space(map));
13348 return map_preimage_multi_aff(map, type, ma);
13349 error:
13350 isl_multi_aff_free(ma);
13351 return isl_map_free(map);
13354 /* Compute the preimage of "set" under the function represented by "ma".
13355 * In other words, plug in "ma" in "set". The result is a set
13356 * that lives in the domain space of "ma".
13358 __isl_give isl_set *isl_set_preimage_multi_aff(__isl_take isl_set *set,
13359 __isl_take isl_multi_aff *ma)
13361 return isl_map_preimage_multi_aff(set, isl_dim_set, ma);
13364 /* Compute the preimage of the domain of "map" under the function
13365 * represented by "ma".
13366 * In other words, plug in "ma" in the domain of "map".
13367 * The result is a map that lives in the same space as "map"
13368 * except that the domain has been replaced by the domain space of "ma".
13370 __isl_give isl_map *isl_map_preimage_domain_multi_aff(__isl_take isl_map *map,
13371 __isl_take isl_multi_aff *ma)
13373 return isl_map_preimage_multi_aff(map, isl_dim_in, ma);
13376 /* Compute the preimage of the range of "map" under the function
13377 * represented by "ma".
13378 * In other words, plug in "ma" in the range of "map".
13379 * The result is a map that lives in the same space as "map"
13380 * except that the range has been replaced by the domain space of "ma".
13382 __isl_give isl_map *isl_map_preimage_range_multi_aff(__isl_take isl_map *map,
13383 __isl_take isl_multi_aff *ma)
13385 return isl_map_preimage_multi_aff(map, isl_dim_out, ma);
13388 /* Compute the preimage of "map" under the function represented by "pma".
13389 * In other words, plug in "pma" in the domain or range of "map".
13390 * The result is a map that lives in the same space as "map",
13391 * except that the space of type "type" has been replaced by
13392 * the domain space of "pma".
13394 * The parameters of "map" and "pma" are assumed to have been aligned.
13396 static __isl_give isl_map *isl_map_preimage_pw_multi_aff_aligned(
13397 __isl_take isl_map *map, enum isl_dim_type type,
13398 __isl_take isl_pw_multi_aff *pma)
13400 int i;
13401 isl_map *res;
13403 if (!pma)
13404 goto error;
13406 if (pma->n == 0) {
13407 isl_pw_multi_aff_free(pma);
13408 res = isl_map_empty(isl_map_get_space(map));
13409 isl_map_free(map);
13410 return res;
13413 res = isl_map_preimage_multi_aff(isl_map_copy(map), type,
13414 isl_multi_aff_copy(pma->p[0].maff));
13415 if (type == isl_dim_in)
13416 res = isl_map_intersect_domain(res,
13417 isl_map_copy(pma->p[0].set));
13418 else
13419 res = isl_map_intersect_range(res,
13420 isl_map_copy(pma->p[0].set));
13422 for (i = 1; i < pma->n; ++i) {
13423 isl_map *res_i;
13425 res_i = isl_map_preimage_multi_aff(isl_map_copy(map), type,
13426 isl_multi_aff_copy(pma->p[i].maff));
13427 if (type == isl_dim_in)
13428 res_i = isl_map_intersect_domain(res_i,
13429 isl_map_copy(pma->p[i].set));
13430 else
13431 res_i = isl_map_intersect_range(res_i,
13432 isl_map_copy(pma->p[i].set));
13433 res = isl_map_union(res, res_i);
13436 isl_pw_multi_aff_free(pma);
13437 isl_map_free(map);
13438 return res;
13439 error:
13440 isl_pw_multi_aff_free(pma);
13441 isl_map_free(map);
13442 return NULL;
13445 /* Compute the preimage of "map" under the function represented by "pma".
13446 * In other words, plug in "pma" in the domain or range of "map".
13447 * The result is a map that lives in the same space as "map",
13448 * except that the space of type "type" has been replaced by
13449 * the domain space of "pma".
13451 __isl_give isl_map *isl_map_preimage_pw_multi_aff(__isl_take isl_map *map,
13452 enum isl_dim_type type, __isl_take isl_pw_multi_aff *pma)
13454 isl_bool aligned;
13456 if (!map || !pma)
13457 goto error;
13459 aligned = isl_map_space_has_equal_params(map, pma->dim);
13460 if (aligned < 0)
13461 goto error;
13462 if (aligned)
13463 return isl_map_preimage_pw_multi_aff_aligned(map, type, pma);
13465 if (isl_map_check_named_params(map) < 0)
13466 goto error;
13467 if (isl_pw_multi_aff_check_named_params(pma) < 0)
13468 goto error;
13469 map = isl_map_align_params(map, isl_pw_multi_aff_get_space(pma));
13470 pma = isl_pw_multi_aff_align_params(pma, isl_map_get_space(map));
13472 return isl_map_preimage_pw_multi_aff_aligned(map, type, pma);
13473 error:
13474 isl_pw_multi_aff_free(pma);
13475 return isl_map_free(map);
13478 /* Compute the preimage of "set" under the function represented by "pma".
13479 * In other words, plug in "pma" in "set". The result is a set
13480 * that lives in the domain space of "pma".
13482 __isl_give isl_set *isl_set_preimage_pw_multi_aff(__isl_take isl_set *set,
13483 __isl_take isl_pw_multi_aff *pma)
13485 return isl_map_preimage_pw_multi_aff(set, isl_dim_set, pma);
13488 /* Compute the preimage of the domain of "map" under the function
13489 * represented by "pma".
13490 * In other words, plug in "pma" in the domain of "map".
13491 * The result is a map that lives in the same space as "map",
13492 * except that domain space has been replaced by the domain space of "pma".
13494 __isl_give isl_map *isl_map_preimage_domain_pw_multi_aff(
13495 __isl_take isl_map *map, __isl_take isl_pw_multi_aff *pma)
13497 return isl_map_preimage_pw_multi_aff(map, isl_dim_in, pma);
13500 /* Compute the preimage of the range of "map" under the function
13501 * represented by "pma".
13502 * In other words, plug in "pma" in the range of "map".
13503 * The result is a map that lives in the same space as "map",
13504 * except that range space has been replaced by the domain space of "pma".
13506 __isl_give isl_map *isl_map_preimage_range_pw_multi_aff(
13507 __isl_take isl_map *map, __isl_take isl_pw_multi_aff *pma)
13509 return isl_map_preimage_pw_multi_aff(map, isl_dim_out, pma);
13512 /* Compute the preimage of "map" under the function represented by "mpa".
13513 * In other words, plug in "mpa" in the domain or range of "map".
13514 * The result is a map that lives in the same space as "map",
13515 * except that the space of type "type" has been replaced by
13516 * the domain space of "mpa".
13518 * If the map does not involve any constraints that refer to the
13519 * dimensions of the substituted space, then the only possible
13520 * effect of "mpa" on the map is to map the space to a different space.
13521 * We create a separate isl_multi_aff to effectuate this change
13522 * in order to avoid spurious splitting of the map along the pieces
13523 * of "mpa".
13524 * If "mpa" has a non-trivial explicit domain, however,
13525 * then the full substitution should be performed.
13527 __isl_give isl_map *isl_map_preimage_multi_pw_aff(__isl_take isl_map *map,
13528 enum isl_dim_type type, __isl_take isl_multi_pw_aff *mpa)
13530 int n;
13531 isl_bool full;
13532 isl_pw_multi_aff *pma;
13534 if (!map || !mpa)
13535 goto error;
13537 n = isl_map_dim(map, type);
13538 full = isl_map_involves_dims(map, type, 0, n);
13539 if (full >= 0 && !full)
13540 full = isl_multi_pw_aff_has_non_trivial_domain(mpa);
13541 if (full < 0)
13542 goto error;
13543 if (!full) {
13544 isl_space *space;
13545 isl_multi_aff *ma;
13547 space = isl_multi_pw_aff_get_space(mpa);
13548 isl_multi_pw_aff_free(mpa);
13549 ma = isl_multi_aff_zero(space);
13550 return isl_map_preimage_multi_aff(map, type, ma);
13553 pma = isl_pw_multi_aff_from_multi_pw_aff(mpa);
13554 return isl_map_preimage_pw_multi_aff(map, type, pma);
13555 error:
13556 isl_map_free(map);
13557 isl_multi_pw_aff_free(mpa);
13558 return NULL;
13561 /* Compute the preimage of "map" under the function represented by "mpa".
13562 * In other words, plug in "mpa" in the domain "map".
13563 * The result is a map that lives in the same space as "map",
13564 * except that domain space has been replaced by the domain space of "mpa".
13566 __isl_give isl_map *isl_map_preimage_domain_multi_pw_aff(
13567 __isl_take isl_map *map, __isl_take isl_multi_pw_aff *mpa)
13569 return isl_map_preimage_multi_pw_aff(map, isl_dim_in, mpa);
13572 /* Compute the preimage of "set" by the function represented by "mpa".
13573 * In other words, plug in "mpa" in "set".
13575 __isl_give isl_set *isl_set_preimage_multi_pw_aff(__isl_take isl_set *set,
13576 __isl_take isl_multi_pw_aff *mpa)
13578 return isl_map_preimage_multi_pw_aff(set, isl_dim_set, mpa);
13581 /* Return a copy of the equality constraints of "bset" as a matrix.
13583 __isl_give isl_mat *isl_basic_set_extract_equalities(
13584 __isl_keep isl_basic_set *bset)
13586 isl_ctx *ctx;
13587 unsigned total;
13589 if (!bset)
13590 return NULL;
13592 ctx = isl_basic_set_get_ctx(bset);
13593 total = 1 + isl_basic_set_dim(bset, isl_dim_all);
13594 return isl_mat_sub_alloc6(ctx, bset->eq, 0, bset->n_eq, 0, total);
13597 /* Are the "n" "coefficients" starting at "first" of the integer division
13598 * expressions at position "pos1" in "bmap1" and "pos2" in "bmap2" equal
13599 * to each other?
13600 * The "coefficient" at position 0 is the denominator.
13601 * The "coefficient" at position 1 is the constant term.
13603 isl_bool isl_basic_map_equal_div_expr_part(__isl_keep isl_basic_map *bmap1,
13604 int pos1, __isl_keep isl_basic_map *bmap2, int pos2,
13605 unsigned first, unsigned n)
13607 if (isl_basic_map_check_range(bmap1, isl_dim_div, pos1, 1) < 0)
13608 return isl_bool_error;
13609 if (isl_basic_map_check_range(bmap2, isl_dim_div, pos2, 1) < 0)
13610 return isl_bool_error;
13611 return isl_seq_eq(bmap1->div[pos1] + first,
13612 bmap2->div[pos2] + first, n);
13615 /* Are the integer division expressions at position "pos1" in "bmap1" and
13616 * "pos2" in "bmap2" equal to each other, except that the constant terms
13617 * are different?
13619 isl_bool isl_basic_map_equal_div_expr_except_constant(
13620 __isl_keep isl_basic_map *bmap1, int pos1,
13621 __isl_keep isl_basic_map *bmap2, int pos2)
13623 isl_bool equal;
13624 unsigned total;
13626 if (!bmap1 || !bmap2)
13627 return isl_bool_error;
13628 total = isl_basic_map_total_dim(bmap1);
13629 if (total != isl_basic_map_total_dim(bmap2))
13630 isl_die(isl_basic_map_get_ctx(bmap1), isl_error_invalid,
13631 "incomparable div expressions", return isl_bool_error);
13632 equal = isl_basic_map_equal_div_expr_part(bmap1, pos1, bmap2, pos2,
13633 0, 1);
13634 if (equal < 0 || !equal)
13635 return equal;
13636 equal = isl_basic_map_equal_div_expr_part(bmap1, pos1, bmap2, pos2,
13637 1, 1);
13638 if (equal < 0 || equal)
13639 return isl_bool_not(equal);
13640 return isl_basic_map_equal_div_expr_part(bmap1, pos1, bmap2, pos2,
13641 2, total);
13644 /* Replace the numerator of the constant term of the integer division
13645 * expression at position "div" in "bmap" by "value".
13646 * The caller guarantees that this does not change the meaning
13647 * of the input.
13649 __isl_give isl_basic_map *isl_basic_map_set_div_expr_constant_num_si_inplace(
13650 __isl_take isl_basic_map *bmap, int div, int value)
13652 if (isl_basic_map_check_range(bmap, isl_dim_div, div, 1) < 0)
13653 return isl_basic_map_free(bmap);
13655 isl_int_set_si(bmap->div[div][1], value);
13657 return bmap;
13660 /* Is the point "inner" internal to inequality constraint "ineq"
13661 * of "bset"?
13662 * The point is considered to be internal to the inequality constraint,
13663 * if it strictly lies on the positive side of the inequality constraint,
13664 * or if it lies on the constraint and the constraint is lexico-positive.
13666 static isl_bool is_internal(__isl_keep isl_vec *inner,
13667 __isl_keep isl_basic_set *bset, int ineq)
13669 isl_ctx *ctx;
13670 int pos;
13671 unsigned total;
13673 if (!inner || !bset)
13674 return isl_bool_error;
13676 ctx = isl_basic_set_get_ctx(bset);
13677 isl_seq_inner_product(inner->el, bset->ineq[ineq], inner->size,
13678 &ctx->normalize_gcd);
13679 if (!isl_int_is_zero(ctx->normalize_gcd))
13680 return isl_int_is_nonneg(ctx->normalize_gcd);
13682 total = isl_basic_set_dim(bset, isl_dim_all);
13683 pos = isl_seq_first_non_zero(bset->ineq[ineq] + 1, total);
13684 return isl_int_is_pos(bset->ineq[ineq][1 + pos]);
13687 /* Tighten the inequality constraints of "bset" that are outward with respect
13688 * to the point "vec".
13689 * That is, tighten the constraints that are not satisfied by "vec".
13691 * "vec" is a point internal to some superset S of "bset" that is used
13692 * to make the subsets of S disjoint, by tightening one half of the constraints
13693 * that separate two subsets. In particular, the constraints of S
13694 * are all satisfied by "vec" and should not be tightened.
13695 * Of the internal constraints, those that have "vec" on the outside
13696 * are tightened. The shared facet is included in the adjacent subset
13697 * with the opposite constraint.
13698 * For constraints that saturate "vec", this criterion cannot be used
13699 * to determine which of the two sides should be tightened.
13700 * Instead, the sign of the first non-zero coefficient is used
13701 * to make this choice. Note that this second criterion is never used
13702 * on the constraints of S since "vec" is interior to "S".
13704 __isl_give isl_basic_set *isl_basic_set_tighten_outward(
13705 __isl_take isl_basic_set *bset, __isl_keep isl_vec *vec)
13707 int j;
13709 bset = isl_basic_set_cow(bset);
13710 if (!bset)
13711 return NULL;
13712 for (j = 0; j < bset->n_ineq; ++j) {
13713 isl_bool internal;
13715 internal = is_internal(vec, bset, j);
13716 if (internal < 0)
13717 return isl_basic_set_free(bset);
13718 if (internal)
13719 continue;
13720 isl_int_sub_ui(bset->ineq[j][0], bset->ineq[j][0], 1);
13723 return bset;
13726 /* Replace the variables x of type "type" starting at "first" in "bmap"
13727 * by x' with x = M x' with M the matrix trans.
13728 * That is, replace the corresponding coefficients c by c M.
13730 * The transformation matrix should be a square matrix.
13732 __isl_give isl_basic_map *isl_basic_map_transform_dims(
13733 __isl_take isl_basic_map *bmap, enum isl_dim_type type, unsigned first,
13734 __isl_take isl_mat *trans)
13736 unsigned pos;
13738 bmap = isl_basic_map_cow(bmap);
13739 if (!bmap || !trans)
13740 goto error;
13742 if (trans->n_row != trans->n_col)
13743 isl_die(trans->ctx, isl_error_invalid,
13744 "expecting square transformation matrix", goto error);
13745 if (first + trans->n_row > isl_basic_map_dim(bmap, type))
13746 isl_die(trans->ctx, isl_error_invalid,
13747 "oversized transformation matrix", goto error);
13749 pos = isl_basic_map_offset(bmap, type) + first;
13751 if (isl_mat_sub_transform(bmap->eq, bmap->n_eq, pos,
13752 isl_mat_copy(trans)) < 0)
13753 goto error;
13754 if (isl_mat_sub_transform(bmap->ineq, bmap->n_ineq, pos,
13755 isl_mat_copy(trans)) < 0)
13756 goto error;
13757 if (isl_mat_sub_transform(bmap->div, bmap->n_div, 1 + pos,
13758 isl_mat_copy(trans)) < 0)
13759 goto error;
13761 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
13762 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
13764 isl_mat_free(trans);
13765 return bmap;
13766 error:
13767 isl_mat_free(trans);
13768 isl_basic_map_free(bmap);
13769 return NULL;
13772 /* Replace the variables x of type "type" starting at "first" in "bset"
13773 * by x' with x = M x' with M the matrix trans.
13774 * That is, replace the corresponding coefficients c by c M.
13776 * The transformation matrix should be a square matrix.
13778 __isl_give isl_basic_set *isl_basic_set_transform_dims(
13779 __isl_take isl_basic_set *bset, enum isl_dim_type type, unsigned first,
13780 __isl_take isl_mat *trans)
13782 return isl_basic_map_transform_dims(bset, type, first, trans);