2 * Copyright 2008-2009 Katholieke Universiteit Leuven
3 * Copyright 2010 INRIA Saclay
5 * Use of this software is governed by the GNU LGPLv2.1 license
7 * Written by Sven Verdoolaege, K.U.Leuven, Departement
8 * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
9 * and INRIA Saclay - Ile-de-France, Parc Club Orsay Universite,
10 * ZAC des vignes, 4 rue Jacques Monod, 91893 Orsay, France
14 #include <isl_space_private.h>
15 #include <isl_id_private.h>
16 #include <isl_reordering.h>
18 isl_ctx
*isl_space_get_ctx(__isl_keep isl_space
*dim
)
20 return dim
? dim
->ctx
: NULL
;
23 __isl_give isl_space
*isl_space_alloc(isl_ctx
*ctx
,
24 unsigned nparam
, unsigned n_in
, unsigned n_out
)
28 dim
= isl_alloc_type(ctx
, struct isl_space
);
39 dim
->tuple_id
[0] = NULL
;
40 dim
->tuple_id
[1] = NULL
;
42 dim
->nested
[0] = NULL
;
43 dim
->nested
[1] = NULL
;
51 /* Mark the space as being that of a set, by setting the domain tuple
54 static __isl_give isl_space
*mark_as_set(__isl_take isl_space
*space
)
56 space
= isl_space_cow(space
);
59 space
= isl_space_set_tuple_id(space
, isl_dim_in
, &isl_id_none
);
63 /* Is the space that of a set?
65 int isl_space_is_set(__isl_keep isl_space
*space
)
69 if (space
->n_in
!= 0 || space
->nested
[0])
71 if (space
->tuple_id
[0] != &isl_id_none
)
76 __isl_give isl_space
*isl_space_set_alloc(isl_ctx
*ctx
,
77 unsigned nparam
, unsigned dim
)
80 space
= isl_space_alloc(ctx
, nparam
, 0, dim
);
81 space
= mark_as_set(space
);
85 /* Mark the space as being that of a parameter domain, by setting
86 * both tuples to isl_id_none.
88 static __isl_give isl_space
*mark_as_params(isl_space
*space
)
92 space
= isl_space_set_tuple_id(space
, isl_dim_in
, &isl_id_none
);
93 space
= isl_space_set_tuple_id(space
, isl_dim_out
, &isl_id_none
);
97 /* Is the space that of a parameter domain?
99 int isl_space_is_params(__isl_keep isl_space
*space
)
103 if (space
->n_in
!= 0 || space
->nested
[0] ||
104 space
->n_out
!= 0 || space
->nested
[1])
106 if (space
->tuple_id
[0] != &isl_id_none
)
108 if (space
->tuple_id
[1] != &isl_id_none
)
113 /* Create a space for a parameter domain.
115 __isl_give isl_space
*isl_space_params_alloc(isl_ctx
*ctx
, unsigned nparam
)
118 space
= isl_space_alloc(ctx
, nparam
, 0, 0);
119 space
= mark_as_params(space
);
123 static unsigned global_pos(__isl_keep isl_space
*dim
,
124 enum isl_dim_type type
, unsigned pos
)
126 struct isl_ctx
*ctx
= dim
->ctx
;
130 isl_assert(ctx
, pos
< dim
->nparam
,
131 return isl_space_dim(dim
, isl_dim_all
));
134 isl_assert(ctx
, pos
< dim
->n_in
,
135 return isl_space_dim(dim
, isl_dim_all
));
136 return pos
+ dim
->nparam
;
138 isl_assert(ctx
, pos
< dim
->n_out
,
139 return isl_space_dim(dim
, isl_dim_all
));
140 return pos
+ dim
->nparam
+ dim
->n_in
;
142 isl_assert(ctx
, 0, return isl_space_dim(dim
, isl_dim_all
));
144 return isl_space_dim(dim
, isl_dim_all
);
147 /* Extend length of ids array to the total number of dimensions.
149 static __isl_give isl_space
*extend_ids(__isl_take isl_space
*dim
)
154 if (isl_space_dim(dim
, isl_dim_all
) <= dim
->n_id
)
158 dim
->ids
= isl_calloc_array(dim
->ctx
,
159 isl_id
*, isl_space_dim(dim
, isl_dim_all
));
163 ids
= isl_realloc_array(dim
->ctx
, dim
->ids
,
164 isl_id
*, isl_space_dim(dim
, isl_dim_all
));
168 for (i
= dim
->n_id
; i
< isl_space_dim(dim
, isl_dim_all
); ++i
)
172 dim
->n_id
= isl_space_dim(dim
, isl_dim_all
);
180 static __isl_give isl_space
*set_id(__isl_take isl_space
*dim
,
181 enum isl_dim_type type
, unsigned pos
, __isl_take isl_id
*id
)
183 dim
= isl_space_cow(dim
);
188 pos
= global_pos(dim
, type
, pos
);
189 if (pos
== isl_space_dim(dim
, isl_dim_all
))
192 if (pos
>= dim
->n_id
) {
195 dim
= extend_ids(dim
);
209 static __isl_keep isl_id
*get_id(__isl_keep isl_space
*dim
,
210 enum isl_dim_type type
, unsigned pos
)
215 pos
= global_pos(dim
, type
, pos
);
216 if (pos
== isl_space_dim(dim
, isl_dim_all
))
218 if (pos
>= dim
->n_id
)
220 return dim
->ids
[pos
];
223 static unsigned offset(__isl_keep isl_space
*dim
, enum isl_dim_type type
)
226 case isl_dim_param
: return 0;
227 case isl_dim_in
: return dim
->nparam
;
228 case isl_dim_out
: return dim
->nparam
+ dim
->n_in
;
233 static unsigned n(__isl_keep isl_space
*dim
, enum isl_dim_type type
)
236 case isl_dim_param
: return dim
->nparam
;
237 case isl_dim_in
: return dim
->n_in
;
238 case isl_dim_out
: return dim
->n_out
;
239 case isl_dim_all
: return dim
->nparam
+ dim
->n_in
+ dim
->n_out
;
244 unsigned isl_space_dim(__isl_keep isl_space
*dim
, enum isl_dim_type type
)
251 unsigned isl_space_offset(__isl_keep isl_space
*dim
, enum isl_dim_type type
)
255 return offset(dim
, type
);
258 static __isl_give isl_space
*copy_ids(__isl_take isl_space
*dst
,
259 enum isl_dim_type dst_type
, unsigned offset
, __isl_keep isl_space
*src
,
260 enum isl_dim_type src_type
)
268 for (i
= 0; i
< n(src
, src_type
); ++i
) {
269 id
= get_id(src
, src_type
, i
);
272 dst
= set_id(dst
, dst_type
, offset
+ i
, isl_id_copy(id
));
279 __isl_take isl_space
*isl_space_dup(__isl_keep isl_space
*dim
)
284 dup
= isl_space_alloc(dim
->ctx
, dim
->nparam
, dim
->n_in
, dim
->n_out
);
285 if (dim
->tuple_id
[0] &&
286 !(dup
->tuple_id
[0] = isl_id_copy(dim
->tuple_id
[0])))
288 if (dim
->tuple_id
[1] &&
289 !(dup
->tuple_id
[1] = isl_id_copy(dim
->tuple_id
[1])))
291 if (dim
->nested
[0] && !(dup
->nested
[0] = isl_space_copy(dim
->nested
[0])))
293 if (dim
->nested
[1] && !(dup
->nested
[1] = isl_space_copy(dim
->nested
[1])))
297 dup
= copy_ids(dup
, isl_dim_param
, 0, dim
, isl_dim_param
);
298 dup
= copy_ids(dup
, isl_dim_in
, 0, dim
, isl_dim_in
);
299 dup
= copy_ids(dup
, isl_dim_out
, 0, dim
, isl_dim_out
);
306 __isl_give isl_space
*isl_space_cow(__isl_take isl_space
*dim
)
314 return isl_space_dup(dim
);
317 __isl_give isl_space
*isl_space_copy(__isl_keep isl_space
*dim
)
326 void isl_space_free(__isl_take isl_space
*dim
)
336 isl_id_free(dim
->tuple_id
[0]);
337 isl_id_free(dim
->tuple_id
[1]);
339 isl_space_free(dim
->nested
[0]);
340 isl_space_free(dim
->nested
[1]);
342 for (i
= 0; i
< dim
->n_id
; ++i
)
343 isl_id_free(dim
->ids
[i
]);
345 isl_ctx_deref(dim
->ctx
);
350 /* Check if "s" is a valid dimension or tuple name.
351 * We currently only forbid names that look like a number.
353 * s is assumed to be non-NULL.
355 static int name_ok(isl_ctx
*ctx
, const char *s
)
360 dummy
= strtol(s
, &p
, 0);
362 isl_die(ctx
, isl_error_invalid
, "name looks like a number",
368 /* Is it possible for the given dimension type to have a tuple id?
370 static int space_can_have_id(__isl_keep isl_space
*space
,
371 enum isl_dim_type type
)
375 if (isl_space_is_params(space
))
376 isl_die(space
->ctx
, isl_error_invalid
,
377 "parameter spaces don't have tuple ids", return 0);
378 if (isl_space_is_set(space
) && type
!= isl_dim_set
)
379 isl_die(space
->ctx
, isl_error_invalid
,
380 "set spaces can only have a set id", return 0);
381 if (type
!= isl_dim_in
&& type
!= isl_dim_out
)
382 isl_die(space
->ctx
, isl_error_invalid
,
383 "only input, output and set tuples can have ids",
389 /* Does the tuple have an id?
391 int isl_space_has_tuple_id(__isl_keep isl_space
*dim
, enum isl_dim_type type
)
393 if (!space_can_have_id(dim
, type
))
395 return dim
->tuple_id
[type
- isl_dim_in
] != NULL
;
398 __isl_give isl_id
*isl_space_get_tuple_id(__isl_keep isl_space
*dim
,
399 enum isl_dim_type type
)
405 has_id
= isl_space_has_tuple_id(dim
, type
);
409 isl_die(dim
->ctx
, isl_error_invalid
,
410 "tuple has no id", return NULL
);
411 return isl_id_copy(dim
->tuple_id
[type
- isl_dim_in
]);
414 __isl_give isl_space
*isl_space_set_tuple_id(__isl_take isl_space
*dim
,
415 enum isl_dim_type type
, __isl_take isl_id
*id
)
417 dim
= isl_space_cow(dim
);
420 if (type
!= isl_dim_in
&& type
!= isl_dim_out
)
421 isl_die(dim
->ctx
, isl_error_invalid
,
422 "only input, output and set tuples can have names",
425 isl_id_free(dim
->tuple_id
[type
- isl_dim_in
]);
426 dim
->tuple_id
[type
- isl_dim_in
] = id
;
435 __isl_give isl_space
*isl_space_reset_tuple_id(__isl_take isl_space
*dim
,
436 enum isl_dim_type type
)
438 dim
= isl_space_cow(dim
);
441 if (type
!= isl_dim_in
&& type
!= isl_dim_out
)
442 isl_die(dim
->ctx
, isl_error_invalid
,
443 "only input, output and set tuples can have names",
446 isl_id_free(dim
->tuple_id
[type
- isl_dim_in
]);
447 dim
->tuple_id
[type
- isl_dim_in
] = NULL
;
455 /* Set the id of the given dimension of "space" to "id".
456 * If the dimension already has an id, then it is replaced.
457 * If the dimension is a parameter, then we need to change it
458 * in the nested spaces (if any) as well.
460 __isl_give isl_space
*isl_space_set_dim_id(__isl_take isl_space
*space
,
461 enum isl_dim_type type
, unsigned pos
, __isl_take isl_id
*id
)
463 space
= isl_space_cow(space
);
467 if (type
== isl_dim_param
) {
470 for (i
= 0; i
< 2; ++i
) {
471 if (!space
->nested
[i
])
474 isl_space_set_dim_id(space
->nested
[i
],
475 type
, pos
, isl_id_copy(id
));
476 if (!space
->nested
[i
])
481 isl_id_free(get_id(space
, type
, pos
));
482 return set_id(space
, type
, pos
, id
);
485 isl_space_free(space
);
489 /* Reset the id of the given dimension of "space".
490 * If the dimension already has an id, then it is removed.
491 * If the dimension is a parameter, then we need to reset it
492 * in the nested spaces (if any) as well.
494 __isl_give isl_space
*isl_space_reset_dim_id(__isl_take isl_space
*space
,
495 enum isl_dim_type type
, unsigned pos
)
497 space
= isl_space_cow(space
);
501 if (type
== isl_dim_param
) {
504 for (i
= 0; i
< 2; ++i
) {
505 if (!space
->nested
[i
])
508 isl_space_reset_dim_id(space
->nested
[i
],
510 if (!space
->nested
[i
])
515 isl_id_free(get_id(space
, type
, pos
));
516 return set_id(space
, type
, pos
, NULL
);
518 isl_space_free(space
);
522 int isl_space_has_dim_id(__isl_keep isl_space
*dim
,
523 enum isl_dim_type type
, unsigned pos
)
527 return get_id(dim
, type
, pos
) != NULL
;
530 __isl_give isl_id
*isl_space_get_dim_id(__isl_keep isl_space
*dim
,
531 enum isl_dim_type type
, unsigned pos
)
535 if (!get_id(dim
, type
, pos
))
536 isl_die(dim
->ctx
, isl_error_invalid
,
537 "dim has no id", return NULL
);
538 return isl_id_copy(get_id(dim
, type
, pos
));
541 __isl_give isl_space
*isl_space_set_tuple_name(__isl_take isl_space
*dim
,
542 enum isl_dim_type type
, const char *s
)
550 return isl_space_reset_tuple_id(dim
, type
);
552 if (!name_ok(dim
->ctx
, s
))
555 id
= isl_id_alloc(dim
->ctx
, s
, NULL
);
556 return isl_space_set_tuple_id(dim
, type
, id
);
562 /* Does the tuple have a name?
564 int isl_space_has_tuple_name(__isl_keep isl_space
*space
,
565 enum isl_dim_type type
)
569 if (!space_can_have_id(space
, type
))
571 id
= space
->tuple_id
[type
- isl_dim_in
];
572 return id
&& id
->name
;
575 const char *isl_space_get_tuple_name(__isl_keep isl_space
*dim
,
576 enum isl_dim_type type
)
581 if (type
!= isl_dim_in
&& type
!= isl_dim_out
)
583 id
= dim
->tuple_id
[type
- isl_dim_in
];
584 return id
? id
->name
: NULL
;
587 __isl_give isl_space
*isl_space_set_dim_name(__isl_take isl_space
*dim
,
588 enum isl_dim_type type
, unsigned pos
,
596 return isl_space_reset_dim_id(dim
, type
, pos
);
597 if (!name_ok(dim
->ctx
, s
))
599 id
= isl_id_alloc(dim
->ctx
, s
, NULL
);
600 return isl_space_set_dim_id(dim
, type
, pos
, id
);
606 /* Does the given dimension have a name?
608 int isl_space_has_dim_name(__isl_keep isl_space
*space
,
609 enum isl_dim_type type
, unsigned pos
)
615 id
= get_id(space
, type
, pos
);
616 return id
&& id
->name
;
619 __isl_keep
const char *isl_space_get_dim_name(__isl_keep isl_space
*dim
,
620 enum isl_dim_type type
, unsigned pos
)
622 isl_id
*id
= get_id(dim
, type
, pos
);
623 return id
? id
->name
: NULL
;
626 int isl_space_find_dim_by_id(__isl_keep isl_space
*dim
, enum isl_dim_type type
,
627 __isl_keep isl_id
*id
)
636 offset
= isl_space_offset(dim
, type
);
637 n
= isl_space_dim(dim
, type
);
638 for (i
= 0; i
< n
&& offset
+ i
< dim
->n_id
; ++i
)
639 if (dim
->ids
[offset
+ i
] == id
)
645 int isl_space_find_dim_by_name(__isl_keep isl_space
*space
,
646 enum isl_dim_type type
, const char *name
)
655 offset
= isl_space_offset(space
, type
);
656 n
= isl_space_dim(space
, type
);
657 for (i
= 0; i
< n
&& offset
+ i
< space
->n_id
; ++i
)
658 if (space
->ids
[offset
+ i
]->name
&&
659 !strcmp(space
->ids
[offset
+ i
]->name
, name
))
665 static __isl_keep isl_id
*tuple_id(__isl_keep isl_space
*dim
,
666 enum isl_dim_type type
)
670 if (type
== isl_dim_in
)
671 return dim
->tuple_id
[0];
672 if (type
== isl_dim_out
)
673 return dim
->tuple_id
[1];
677 static __isl_keep isl_space
*nested(__isl_keep isl_space
*dim
,
678 enum isl_dim_type type
)
682 if (type
== isl_dim_in
)
683 return dim
->nested
[0];
684 if (type
== isl_dim_out
)
685 return dim
->nested
[1];
689 int isl_space_tuple_match(__isl_keep isl_space
*dim1
, enum isl_dim_type dim1_type
,
690 __isl_keep isl_space
*dim2
, enum isl_dim_type dim2_type
)
693 isl_space
*nested1
, *nested2
;
698 if (dim1
== dim2
&& dim1_type
== dim2_type
)
701 if (n(dim1
, dim1_type
) != n(dim2
, dim2_type
))
703 id1
= tuple_id(dim1
, dim1_type
);
704 id2
= tuple_id(dim2
, dim2_type
);
707 if (id1
&& id1
!= id2
)
709 nested1
= nested(dim1
, dim1_type
);
710 nested2
= nested(dim2
, dim2_type
);
711 if (!nested1
^ !nested2
)
713 if (nested1
&& !isl_space_is_equal(nested1
, nested2
))
718 static int match(__isl_keep isl_space
*dim1
, enum isl_dim_type dim1_type
,
719 __isl_keep isl_space
*dim2
, enum isl_dim_type dim2_type
)
723 if (dim1
== dim2
&& dim1_type
== dim2_type
)
726 if (!isl_space_tuple_match(dim1
, dim1_type
, dim2
, dim2_type
))
729 if (!dim1
->ids
&& !dim2
->ids
)
732 for (i
= 0; i
< n(dim1
, dim1_type
); ++i
) {
733 if (get_id(dim1
, dim1_type
, i
) != get_id(dim2
, dim2_type
, i
))
739 int isl_space_match(__isl_keep isl_space
*dim1
, enum isl_dim_type dim1_type
,
740 __isl_keep isl_space
*dim2
, enum isl_dim_type dim2_type
)
745 return match(dim1
, dim1_type
, dim2
, dim2_type
);
748 static void get_ids(__isl_keep isl_space
*dim
, enum isl_dim_type type
,
749 unsigned first
, unsigned n
, __isl_keep isl_id
**ids
)
753 for (i
= 0; i
< n
; ++i
)
754 ids
[i
] = get_id(dim
, type
, first
+ i
);
757 __isl_give isl_space
*isl_space_extend(__isl_take isl_space
*dim
,
758 unsigned nparam
, unsigned n_in
, unsigned n_out
)
764 if (dim
->nparam
== nparam
&& dim
->n_in
== n_in
&& dim
->n_out
== n_out
)
767 isl_assert(dim
->ctx
, dim
->nparam
<= nparam
, goto error
);
768 isl_assert(dim
->ctx
, dim
->n_in
<= n_in
, goto error
);
769 isl_assert(dim
->ctx
, dim
->n_out
<= n_out
, goto error
);
771 dim
= isl_space_cow(dim
);
774 ids
= isl_calloc_array(dim
->ctx
, isl_id
*,
775 nparam
+ n_in
+ n_out
);
778 get_ids(dim
, isl_dim_param
, 0, dim
->nparam
, ids
);
779 get_ids(dim
, isl_dim_in
, 0, dim
->n_in
, ids
+ nparam
);
780 get_ids(dim
, isl_dim_out
, 0, dim
->n_out
, ids
+ nparam
+ n_in
);
783 dim
->n_id
= nparam
+ n_in
+ n_out
;
785 dim
->nparam
= nparam
;
796 __isl_give isl_space
*isl_space_add_dims(__isl_take isl_space
*dim
,
797 enum isl_dim_type type
, unsigned n
)
801 dim
= isl_space_reset(dim
, type
);
804 dim
= isl_space_extend(dim
,
805 dim
->nparam
+ n
, dim
->n_in
, dim
->n_out
);
806 if (dim
&& dim
->nested
[0] &&
807 !(dim
->nested
[0] = isl_space_add_dims(dim
->nested
[0],
810 if (dim
&& dim
->nested
[1] &&
811 !(dim
->nested
[1] = isl_space_add_dims(dim
->nested
[1],
816 return isl_space_extend(dim
,
817 dim
->nparam
, dim
->n_in
+ n
, dim
->n_out
);
819 return isl_space_extend(dim
,
820 dim
->nparam
, dim
->n_in
, dim
->n_out
+ n
);
822 isl_die(dim
->ctx
, isl_error_invalid
,
823 "cannot add dimensions of specified type", goto error
);
830 static int valid_dim_type(enum isl_dim_type type
)
842 /* Insert "n" dimensions of type "type" at position "pos".
843 * If we are inserting parameters, then they are also inserted in
846 __isl_give isl_space
*isl_space_insert_dims(__isl_take isl_space
*dim
,
847 enum isl_dim_type type
, unsigned pos
, unsigned n
)
854 return isl_space_reset(dim
, type
);
856 if (!valid_dim_type(type
))
857 isl_die(dim
->ctx
, isl_error_invalid
,
858 "cannot insert dimensions of specified type",
861 isl_assert(dim
->ctx
, pos
<= isl_space_dim(dim
, type
), goto error
);
863 dim
= isl_space_cow(dim
);
868 enum isl_dim_type t
, o
= isl_dim_param
;
871 ids
= isl_calloc_array(dim
->ctx
, isl_id
*,
872 dim
->nparam
+ dim
->n_in
+ dim
->n_out
+ n
);
876 s
[isl_dim_param
- o
] = dim
->nparam
;
877 s
[isl_dim_in
- o
] = dim
->n_in
;
878 s
[isl_dim_out
- o
] = dim
->n_out
;
879 for (t
= isl_dim_param
; t
<= isl_dim_out
; ++t
) {
881 get_ids(dim
, t
, 0, s
[t
- o
], ids
+ off
);
884 get_ids(dim
, t
, 0, pos
, ids
+ off
);
886 get_ids(dim
, t
, pos
, s
[t
- o
] - pos
, ids
+ off
);
887 off
+= s
[t
- o
] - pos
;
892 dim
->n_id
= dim
->nparam
+ dim
->n_in
+ dim
->n_out
+ n
;
895 case isl_dim_param
: dim
->nparam
+= n
; break;
896 case isl_dim_in
: dim
->n_in
+= n
; break;
897 case isl_dim_out
: dim
->n_out
+= n
; break;
900 dim
= isl_space_reset(dim
, type
);
902 if (type
== isl_dim_param
) {
903 if (dim
&& dim
->nested
[0] &&
904 !(dim
->nested
[0] = isl_space_insert_dims(dim
->nested
[0],
905 isl_dim_param
, pos
, n
)))
907 if (dim
&& dim
->nested
[1] &&
908 !(dim
->nested
[1] = isl_space_insert_dims(dim
->nested
[1],
909 isl_dim_param
, pos
, n
)))
919 __isl_give isl_space
*isl_space_move_dims(__isl_take isl_space
*dim
,
920 enum isl_dim_type dst_type
, unsigned dst_pos
,
921 enum isl_dim_type src_type
, unsigned src_pos
, unsigned n
)
930 isl_assert(dim
->ctx
, src_pos
+ n
<= isl_space_dim(dim
, src_type
),
933 if (dst_type
== src_type
&& dst_pos
== src_pos
)
936 isl_assert(dim
->ctx
, dst_type
!= src_type
, goto error
);
938 dim
= isl_space_reset(dim
, src_type
);
939 dim
= isl_space_reset(dim
, dst_type
);
941 dim
= isl_space_cow(dim
);
947 enum isl_dim_type t
, o
= isl_dim_param
;
950 ids
= isl_calloc_array(dim
->ctx
, isl_id
*,
951 dim
->nparam
+ dim
->n_in
+ dim
->n_out
);
955 s
[isl_dim_param
- o
] = dim
->nparam
;
956 s
[isl_dim_in
- o
] = dim
->n_in
;
957 s
[isl_dim_out
- o
] = dim
->n_out
;
958 for (t
= isl_dim_param
; t
<= isl_dim_out
; ++t
) {
960 get_ids(dim
, t
, 0, dst_pos
, ids
+ off
);
962 get_ids(dim
, src_type
, src_pos
, n
, ids
+ off
);
964 get_ids(dim
, t
, dst_pos
, s
[t
- o
] - dst_pos
,
966 off
+= s
[t
- o
] - dst_pos
;
967 } else if (t
== src_type
) {
968 get_ids(dim
, t
, 0, src_pos
, ids
+ off
);
970 get_ids(dim
, t
, src_pos
+ n
,
971 s
[t
- o
] - src_pos
- n
, ids
+ off
);
972 off
+= s
[t
- o
] - src_pos
- n
;
974 get_ids(dim
, t
, 0, s
[t
- o
], ids
+ off
);
980 dim
->n_id
= dim
->nparam
+ dim
->n_in
+ dim
->n_out
;
984 case isl_dim_param
: dim
->nparam
+= n
; break;
985 case isl_dim_in
: dim
->n_in
+= n
; break;
986 case isl_dim_out
: dim
->n_out
+= n
; break;
991 case isl_dim_param
: dim
->nparam
-= n
; break;
992 case isl_dim_in
: dim
->n_in
-= n
; break;
993 case isl_dim_out
: dim
->n_out
-= n
; break;
997 if (dst_type
!= isl_dim_param
&& src_type
!= isl_dim_param
)
1000 for (i
= 0; i
< 2; ++i
) {
1001 if (!dim
->nested
[i
])
1003 dim
->nested
[i
] = isl_space_replace(dim
->nested
[i
],
1004 isl_dim_param
, dim
);
1005 if (!dim
->nested
[i
])
1011 isl_space_free(dim
);
1015 __isl_give isl_space
*isl_space_join(__isl_take isl_space
*left
,
1016 __isl_take isl_space
*right
)
1020 if (!left
|| !right
)
1023 isl_assert(left
->ctx
, match(left
, isl_dim_param
, right
, isl_dim_param
),
1025 isl_assert(left
->ctx
,
1026 isl_space_tuple_match(left
, isl_dim_out
, right
, isl_dim_in
),
1029 dim
= isl_space_alloc(left
->ctx
, left
->nparam
, left
->n_in
, right
->n_out
);
1033 dim
= copy_ids(dim
, isl_dim_param
, 0, left
, isl_dim_param
);
1034 dim
= copy_ids(dim
, isl_dim_in
, 0, left
, isl_dim_in
);
1035 dim
= copy_ids(dim
, isl_dim_out
, 0, right
, isl_dim_out
);
1037 if (dim
&& left
->tuple_id
[0] &&
1038 !(dim
->tuple_id
[0] = isl_id_copy(left
->tuple_id
[0])))
1040 if (dim
&& right
->tuple_id
[1] &&
1041 !(dim
->tuple_id
[1] = isl_id_copy(right
->tuple_id
[1])))
1043 if (dim
&& left
->nested
[0] &&
1044 !(dim
->nested
[0] = isl_space_copy(left
->nested
[0])))
1046 if (dim
&& right
->nested
[1] &&
1047 !(dim
->nested
[1] = isl_space_copy(right
->nested
[1])))
1050 isl_space_free(left
);
1051 isl_space_free(right
);
1055 isl_space_free(left
);
1056 isl_space_free(right
);
1060 __isl_give isl_space
*isl_space_product(__isl_take isl_space
*left
,
1061 __isl_take isl_space
*right
)
1063 isl_space
*dom1
, *dom2
, *nest1
, *nest2
;
1065 if (!left
|| !right
)
1068 isl_assert(left
->ctx
, match(left
, isl_dim_param
, right
, isl_dim_param
),
1071 dom1
= isl_space_domain(isl_space_copy(left
));
1072 dom2
= isl_space_domain(isl_space_copy(right
));
1073 nest1
= isl_space_wrap(isl_space_join(isl_space_reverse(dom1
), dom2
));
1075 dom1
= isl_space_range(left
);
1076 dom2
= isl_space_range(right
);
1077 nest2
= isl_space_wrap(isl_space_join(isl_space_reverse(dom1
), dom2
));
1079 return isl_space_join(isl_space_reverse(nest1
), nest2
);
1081 isl_space_free(left
);
1082 isl_space_free(right
);
1086 /* Given two spaces { A -> C } and { B -> C }, construct the space
1089 __isl_give isl_space
*isl_space_domain_product(__isl_take isl_space
*left
,
1090 __isl_take isl_space
*right
)
1092 isl_space
*ran
, *dom1
, *dom2
, *nest
;
1094 if (!left
|| !right
)
1097 if (!match(left
, isl_dim_param
, right
, isl_dim_param
))
1098 isl_die(left
->ctx
, isl_error_invalid
,
1099 "parameters need to match", goto error
);
1100 if (!isl_space_tuple_match(left
, isl_dim_out
, right
, isl_dim_out
))
1101 isl_die(left
->ctx
, isl_error_invalid
,
1102 "ranges need to match", goto error
);
1104 ran
= isl_space_range(isl_space_copy(left
));
1106 dom1
= isl_space_domain(left
);
1107 dom2
= isl_space_domain(right
);
1108 nest
= isl_space_wrap(isl_space_join(isl_space_reverse(dom1
), dom2
));
1110 return isl_space_join(isl_space_reverse(nest
), ran
);
1112 isl_space_free(left
);
1113 isl_space_free(right
);
1117 __isl_give isl_space
*isl_space_range_product(__isl_take isl_space
*left
,
1118 __isl_take isl_space
*right
)
1120 isl_space
*dom
, *ran1
, *ran2
, *nest
;
1122 if (!left
|| !right
)
1125 isl_assert(left
->ctx
, match(left
, isl_dim_param
, right
, isl_dim_param
),
1127 if (!isl_space_tuple_match(left
, isl_dim_in
, right
, isl_dim_in
))
1128 isl_die(left
->ctx
, isl_error_invalid
,
1129 "domains need to match", goto error
);
1131 dom
= isl_space_domain(isl_space_copy(left
));
1133 ran1
= isl_space_range(left
);
1134 ran2
= isl_space_range(right
);
1135 nest
= isl_space_wrap(isl_space_join(isl_space_reverse(ran1
), ran2
));
1137 return isl_space_join(isl_space_reverse(dom
), nest
);
1139 isl_space_free(left
);
1140 isl_space_free(right
);
1144 __isl_give isl_space
*isl_space_map_from_set(__isl_take isl_space
*dim
)
1147 isl_id
**ids
= NULL
;
1151 ctx
= isl_space_get_ctx(dim
);
1152 if (!isl_space_is_set(dim
))
1153 isl_die(ctx
, isl_error_invalid
, "not a set space", goto error
);
1154 dim
= isl_space_cow(dim
);
1158 ids
= isl_calloc_array(dim
->ctx
, isl_id
*,
1159 dim
->nparam
+ dim
->n_out
+ dim
->n_out
);
1162 get_ids(dim
, isl_dim_param
, 0, dim
->nparam
, ids
);
1163 get_ids(dim
, isl_dim_out
, 0, dim
->n_out
, ids
+ dim
->nparam
);
1165 dim
->n_in
= dim
->n_out
;
1169 dim
->n_id
= dim
->nparam
+ dim
->n_out
+ dim
->n_out
;
1170 dim
= copy_ids(dim
, isl_dim_out
, 0, dim
, isl_dim_in
);
1172 isl_id_free(dim
->tuple_id
[0]);
1173 dim
->tuple_id
[0] = isl_id_copy(dim
->tuple_id
[1]);
1174 isl_space_free(dim
->nested
[0]);
1175 dim
->nested
[0] = isl_space_copy(dim
->nested
[1]);
1178 isl_space_free(dim
);
1182 __isl_give isl_space
*isl_space_map_from_domain_and_range(
1183 __isl_take isl_space
*domain
, __isl_take isl_space
*range
)
1185 if (!domain
|| !range
)
1187 if (!isl_space_is_set(domain
))
1188 isl_die(isl_space_get_ctx(domain
), isl_error_invalid
,
1189 "domain is not a set space", goto error
);
1190 if (!isl_space_is_set(range
))
1191 isl_die(isl_space_get_ctx(range
), isl_error_invalid
,
1192 "range is not a set space", goto error
);
1193 return isl_space_join(isl_space_reverse(domain
), range
);
1195 isl_space_free(domain
);
1196 isl_space_free(range
);
1200 static __isl_give isl_space
*set_ids(__isl_take isl_space
*dim
,
1201 enum isl_dim_type type
,
1202 unsigned first
, unsigned n
, __isl_take isl_id
**ids
)
1206 for (i
= 0; i
< n
; ++i
)
1207 dim
= set_id(dim
, type
, first
+ i
, ids
[i
]);
1212 __isl_give isl_space
*isl_space_reverse(__isl_take isl_space
*dim
)
1216 isl_id
**ids
= NULL
;
1221 if (match(dim
, isl_dim_in
, dim
, isl_dim_out
))
1224 dim
= isl_space_cow(dim
);
1228 id
= dim
->tuple_id
[0];
1229 dim
->tuple_id
[0] = dim
->tuple_id
[1];
1230 dim
->tuple_id
[1] = id
;
1232 nested
= dim
->nested
[0];
1233 dim
->nested
[0] = dim
->nested
[1];
1234 dim
->nested
[1] = nested
;
1237 ids
= isl_alloc_array(dim
->ctx
, isl_id
*,
1238 dim
->n_in
+ dim
->n_out
);
1241 get_ids(dim
, isl_dim_in
, 0, dim
->n_in
, ids
);
1242 get_ids(dim
, isl_dim_out
, 0, dim
->n_out
, ids
+ dim
->n_in
);
1246 dim
->n_in
= dim
->n_out
;
1250 dim
= set_ids(dim
, isl_dim_out
, 0, dim
->n_out
, ids
);
1251 dim
= set_ids(dim
, isl_dim_in
, 0, dim
->n_in
, ids
+ dim
->n_out
);
1258 isl_space_free(dim
);
1262 __isl_give isl_space
*isl_space_drop_dims(__isl_take isl_space
*dim
,
1263 enum isl_dim_type type
, unsigned first
, unsigned num
)
1271 return isl_space_reset(dim
, type
);
1273 if (!valid_dim_type(type
))
1274 isl_die(dim
->ctx
, isl_error_invalid
,
1275 "cannot drop dimensions of specified type", goto error
);
1277 isl_assert(dim
->ctx
, first
+ num
<= n(dim
, type
), goto error
);
1278 dim
= isl_space_cow(dim
);
1282 dim
= extend_ids(dim
);
1285 for (i
= 0; i
< num
; ++i
)
1286 isl_id_free(get_id(dim
, type
, first
+ i
));
1287 for (i
= first
+num
; i
< n(dim
, type
); ++i
)
1288 set_id(dim
, type
, i
- num
, get_id(dim
, type
, i
));
1291 get_ids(dim
, isl_dim_in
, 0, dim
->n_in
,
1292 dim
->ids
+ offset(dim
, isl_dim_in
) - num
);
1294 get_ids(dim
, isl_dim_out
, 0, dim
->n_out
,
1295 dim
->ids
+ offset(dim
, isl_dim_out
) - num
);
1302 case isl_dim_param
: dim
->nparam
-= num
; break;
1303 case isl_dim_in
: dim
->n_in
-= num
; break;
1304 case isl_dim_out
: dim
->n_out
-= num
; break;
1307 dim
= isl_space_reset(dim
, type
);
1308 if (type
== isl_dim_param
) {
1309 if (dim
&& dim
->nested
[0] &&
1310 !(dim
->nested
[0] = isl_space_drop_dims(dim
->nested
[0],
1311 isl_dim_param
, first
, num
)))
1313 if (dim
&& dim
->nested
[1] &&
1314 !(dim
->nested
[1] = isl_space_drop_dims(dim
->nested
[1],
1315 isl_dim_param
, first
, num
)))
1320 isl_space_free(dim
);
1324 __isl_give isl_space
*isl_space_drop_inputs(__isl_take isl_space
*dim
,
1325 unsigned first
, unsigned n
)
1329 return isl_space_drop_dims(dim
, isl_dim_in
, first
, n
);
1332 __isl_give isl_space
*isl_space_drop_outputs(__isl_take isl_space
*dim
,
1333 unsigned first
, unsigned n
)
1337 return isl_space_drop_dims(dim
, isl_dim_out
, first
, n
);
1340 __isl_give isl_space
*isl_space_domain(__isl_take isl_space
*dim
)
1344 dim
= isl_space_drop_outputs(dim
, 0, dim
->n_out
);
1345 dim
= isl_space_reverse(dim
);
1346 dim
= mark_as_set(dim
);
1350 __isl_give isl_space
*isl_space_from_domain(__isl_take isl_space
*dim
)
1354 if (!isl_space_is_set(dim
))
1355 isl_die(isl_space_get_ctx(dim
), isl_error_invalid
,
1356 "not a set space", goto error
);
1357 dim
= isl_space_reverse(dim
);
1358 dim
= isl_space_reset(dim
, isl_dim_out
);
1361 isl_space_free(dim
);
1365 __isl_give isl_space
*isl_space_range(__isl_take isl_space
*dim
)
1369 dim
= isl_space_drop_inputs(dim
, 0, dim
->n_in
);
1370 dim
= mark_as_set(dim
);
1374 __isl_give isl_space
*isl_space_from_range(__isl_take isl_space
*dim
)
1378 if (!isl_space_is_set(dim
))
1379 isl_die(isl_space_get_ctx(dim
), isl_error_invalid
,
1380 "not a set space", goto error
);
1381 return isl_space_reset(dim
, isl_dim_in
);
1383 isl_space_free(dim
);
1387 __isl_give isl_space
*isl_space_params(__isl_take isl_space
*space
)
1389 if (isl_space_is_params(space
))
1391 space
= isl_space_drop_dims(space
,
1392 isl_dim_in
, 0, isl_space_dim(space
, isl_dim_in
));
1393 space
= isl_space_drop_dims(space
,
1394 isl_dim_out
, 0, isl_space_dim(space
, isl_dim_out
));
1395 space
= mark_as_params(space
);
1399 __isl_give isl_space
*isl_space_set_from_params(__isl_take isl_space
*space
)
1403 if (!isl_space_is_params(space
))
1404 isl_die(isl_space_get_ctx(space
), isl_error_invalid
,
1405 "not a parameter space", goto error
);
1406 return isl_space_reset(space
, isl_dim_set
);
1408 isl_space_free(space
);
1412 __isl_give isl_space
*isl_space_as_set_space(__isl_take isl_space
*dim
)
1414 dim
= isl_space_cow(dim
);
1418 dim
->n_out
+= dim
->n_in
;
1420 dim
= isl_space_reset(dim
, isl_dim_in
);
1421 dim
= isl_space_reset(dim
, isl_dim_out
);
1426 __isl_give isl_space
*isl_space_underlying(__isl_take isl_space
*dim
,
1434 dim
->nparam
== 0 && dim
->n_in
== 0 && dim
->n_id
== 0)
1435 return isl_space_reset(isl_space_reset(dim
, isl_dim_in
), isl_dim_out
);
1436 dim
= isl_space_cow(dim
);
1439 dim
->n_out
+= dim
->nparam
+ dim
->n_in
+ n_div
;
1443 for (i
= 0; i
< dim
->n_id
; ++i
)
1444 isl_id_free(get_id(dim
, isl_dim_out
, i
));
1446 dim
= isl_space_reset(dim
, isl_dim_in
);
1447 dim
= isl_space_reset(dim
, isl_dim_out
);
1452 int isl_space_is_equal(__isl_keep isl_space
*dim1
, __isl_keep isl_space
*dim2
)
1458 return match(dim1
, isl_dim_param
, dim2
, isl_dim_param
) &&
1459 isl_space_tuple_match(dim1
, isl_dim_in
, dim2
, isl_dim_in
) &&
1460 isl_space_tuple_match(dim1
, isl_dim_out
, dim2
, isl_dim_out
);
1463 /* Is space1 equal to the domain of space2?
1465 int isl_space_is_domain(__isl_keep isl_space
*space1
,
1466 __isl_keep isl_space
*space2
)
1468 if (!space1
|| !space2
)
1470 if (!isl_space_is_set(space1
))
1472 return match(space1
, isl_dim_param
, space2
, isl_dim_param
) &&
1473 isl_space_tuple_match(space1
, isl_dim_set
, space2
, isl_dim_in
);
1476 int isl_space_compatible(__isl_keep isl_space
*dim1
,
1477 __isl_keep isl_space
*dim2
)
1479 return dim1
->nparam
== dim2
->nparam
&&
1480 dim1
->n_in
+ dim1
->n_out
== dim2
->n_in
+ dim2
->n_out
;
1483 static uint32_t isl_hash_dim(uint32_t hash
, __isl_keep isl_space
*dim
)
1491 hash
= isl_hash_builtin(hash
, dim
->nparam
);
1492 hash
= isl_hash_builtin(hash
, dim
->n_in
);
1493 hash
= isl_hash_builtin(hash
, dim
->n_out
);
1495 for (i
= 0; i
< dim
->nparam
; ++i
) {
1496 id
= get_id(dim
, isl_dim_param
, i
);
1497 hash
= isl_hash_id(hash
, id
);
1500 id
= tuple_id(dim
, isl_dim_in
);
1501 hash
= isl_hash_id(hash
, id
);
1502 id
= tuple_id(dim
, isl_dim_out
);
1503 hash
= isl_hash_id(hash
, id
);
1505 hash
= isl_hash_dim(hash
, dim
->nested
[0]);
1506 hash
= isl_hash_dim(hash
, dim
->nested
[1]);
1511 uint32_t isl_space_get_hash(__isl_keep isl_space
*dim
)
1518 hash
= isl_hash_init();
1519 hash
= isl_hash_dim(hash
, dim
);
1524 int isl_space_is_wrapping(__isl_keep isl_space
*dim
)
1529 if (!isl_space_is_set(dim
))
1532 return dim
->nested
[1] != NULL
;
1535 __isl_give isl_space
*isl_space_wrap(__isl_take isl_space
*dim
)
1542 wrap
= isl_space_set_alloc(dim
->ctx
,
1543 dim
->nparam
, dim
->n_in
+ dim
->n_out
);
1545 wrap
= copy_ids(wrap
, isl_dim_param
, 0, dim
, isl_dim_param
);
1546 wrap
= copy_ids(wrap
, isl_dim_set
, 0, dim
, isl_dim_in
);
1547 wrap
= copy_ids(wrap
, isl_dim_set
, dim
->n_in
, dim
, isl_dim_out
);
1552 wrap
->nested
[1] = dim
;
1556 isl_space_free(dim
);
1560 __isl_give isl_space
*isl_space_unwrap(__isl_take isl_space
*dim
)
1567 if (!isl_space_is_wrapping(dim
))
1568 isl_die(dim
->ctx
, isl_error_invalid
, "not a wrapping space",
1571 unwrap
= isl_space_copy(dim
->nested
[1]);
1572 isl_space_free(dim
);
1576 isl_space_free(dim
);
1580 int isl_space_is_named_or_nested(__isl_keep isl_space
*dim
, enum isl_dim_type type
)
1582 if (type
!= isl_dim_in
&& type
!= isl_dim_out
)
1586 if (dim
->tuple_id
[type
- isl_dim_in
])
1588 if (dim
->nested
[type
- isl_dim_in
])
1593 int isl_space_may_be_set(__isl_keep isl_space
*dim
)
1597 if (isl_space_is_set(dim
))
1599 if (isl_space_dim(dim
, isl_dim_in
) != 0)
1601 if (isl_space_is_named_or_nested(dim
, isl_dim_in
))
1606 __isl_give isl_space
*isl_space_reset(__isl_take isl_space
*dim
,
1607 enum isl_dim_type type
)
1609 if (!isl_space_is_named_or_nested(dim
, type
))
1612 dim
= isl_space_cow(dim
);
1616 isl_id_free(dim
->tuple_id
[type
- isl_dim_in
]);
1617 dim
->tuple_id
[type
- isl_dim_in
] = NULL
;
1618 isl_space_free(dim
->nested
[type
- isl_dim_in
]);
1619 dim
->nested
[type
- isl_dim_in
] = NULL
;
1624 __isl_give isl_space
*isl_space_flatten(__isl_take isl_space
*dim
)
1628 if (!dim
->nested
[0] && !dim
->nested
[1])
1632 dim
= isl_space_reset(dim
, isl_dim_in
);
1633 if (dim
&& dim
->nested
[1])
1634 dim
= isl_space_reset(dim
, isl_dim_out
);
1639 __isl_give isl_space
*isl_space_flatten_domain(__isl_take isl_space
*dim
)
1643 if (!dim
->nested
[0])
1646 return isl_space_reset(dim
, isl_dim_in
);
1649 __isl_give isl_space
*isl_space_flatten_range(__isl_take isl_space
*dim
)
1653 if (!dim
->nested
[1])
1656 return isl_space_reset(dim
, isl_dim_out
);
1659 /* Replace the dimensions of the given type of dst by those of src.
1661 __isl_give isl_space
*isl_space_replace(__isl_take isl_space
*dst
,
1662 enum isl_dim_type type
, __isl_keep isl_space
*src
)
1664 dst
= isl_space_cow(dst
);
1669 dst
= isl_space_drop_dims(dst
, type
, 0, isl_space_dim(dst
, type
));
1670 dst
= isl_space_add_dims(dst
, type
, isl_space_dim(src
, type
));
1671 dst
= copy_ids(dst
, type
, 0, src
, type
);
1673 if (dst
&& type
== isl_dim_param
) {
1675 for (i
= 0; i
<= 1; ++i
) {
1676 if (!dst
->nested
[i
])
1678 dst
->nested
[i
] = isl_space_replace(dst
->nested
[i
],
1680 if (!dst
->nested
[i
])
1687 isl_space_free(dst
);
1691 /* Given a dimension specification "dim" of a set, create a dimension
1692 * specification for the lift of the set. In particular, the result
1693 * is of the form [dim -> local[..]], with n_local variables in the
1694 * range of the wrapped map.
1696 __isl_give isl_space
*isl_space_lift(__isl_take isl_space
*dim
, unsigned n_local
)
1698 isl_space
*local_dim
;
1703 local_dim
= isl_space_dup(dim
);
1704 local_dim
= isl_space_drop_dims(local_dim
, isl_dim_set
, 0, dim
->n_out
);
1705 local_dim
= isl_space_add_dims(local_dim
, isl_dim_set
, n_local
);
1706 local_dim
= isl_space_set_tuple_name(local_dim
, isl_dim_set
, "local");
1707 dim
= isl_space_join(isl_space_from_domain(dim
),
1708 isl_space_from_range(local_dim
));
1709 dim
= isl_space_wrap(dim
);
1710 dim
= isl_space_set_tuple_name(dim
, isl_dim_set
, "lifted");
1715 int isl_space_can_zip(__isl_keep isl_space
*dim
)
1720 return dim
->nested
[0] && dim
->nested
[1];
1723 __isl_give isl_space
*isl_space_zip(__isl_take isl_space
*dim
)
1725 isl_space
*dom
, *ran
;
1726 isl_space
*dom_dom
, *dom_ran
, *ran_dom
, *ran_ran
;
1728 if (!isl_space_can_zip(dim
))
1729 isl_die(dim
->ctx
, isl_error_invalid
, "dim cannot be zipped",
1734 dom
= isl_space_unwrap(isl_space_domain(isl_space_copy(dim
)));
1735 ran
= isl_space_unwrap(isl_space_range(dim
));
1736 dom_dom
= isl_space_domain(isl_space_copy(dom
));
1737 dom_ran
= isl_space_range(dom
);
1738 ran_dom
= isl_space_domain(isl_space_copy(ran
));
1739 ran_ran
= isl_space_range(ran
);
1740 dom
= isl_space_join(isl_space_from_domain(dom_dom
),
1741 isl_space_from_range(ran_dom
));
1742 ran
= isl_space_join(isl_space_from_domain(dom_ran
),
1743 isl_space_from_range(ran_ran
));
1744 return isl_space_join(isl_space_from_domain(isl_space_wrap(dom
)),
1745 isl_space_from_range(isl_space_wrap(ran
)));
1747 isl_space_free(dim
);
1751 /* Can we apply isl_space_curry to "space"?
1752 * That is, does it have a nested relation in its domain?
1754 int isl_space_can_curry(__isl_keep isl_space
*space
)
1759 return !!space
->nested
[0];
1762 /* Given a space (A -> B) -> C, return the corresponding space
1765 __isl_give isl_space
*isl_space_curry(__isl_take isl_space
*space
)
1767 isl_space
*dom
, *ran
;
1768 isl_space
*dom_dom
, *dom_ran
;
1773 if (!isl_space_can_curry(space
))
1774 isl_die(space
->ctx
, isl_error_invalid
,
1775 "space cannot be curried", goto error
);
1777 dom
= isl_space_unwrap(isl_space_domain(isl_space_copy(space
)));
1778 ran
= isl_space_range(space
);
1779 dom_dom
= isl_space_domain(isl_space_copy(dom
));
1780 dom_ran
= isl_space_range(dom
);
1781 ran
= isl_space_join(isl_space_from_domain(dom_ran
),
1782 isl_space_from_range(ran
));
1783 return isl_space_join(isl_space_from_domain(dom_dom
),
1784 isl_space_from_range(isl_space_wrap(ran
)));
1786 isl_space_free(space
);
1790 int isl_space_has_named_params(__isl_keep isl_space
*dim
)
1797 if (dim
->nparam
== 0)
1799 off
= isl_space_offset(dim
, isl_dim_param
);
1800 if (off
+ dim
->nparam
> dim
->n_id
)
1802 for (i
= 0; i
< dim
->nparam
; ++i
)
1803 if (!dim
->ids
[off
+ i
])
1808 /* Align the initial parameters of dim1 to match the order in dim2.
1810 __isl_give isl_space
*isl_space_align_params(__isl_take isl_space
*dim1
,
1811 __isl_take isl_space
*dim2
)
1813 isl_reordering
*exp
;
1815 if (!isl_space_has_named_params(dim1
) || !isl_space_has_named_params(dim2
))
1816 isl_die(isl_space_get_ctx(dim1
), isl_error_invalid
,
1817 "parameter alignment requires named parameters",
1820 dim2
= isl_space_params(dim2
);
1821 exp
= isl_parameter_alignment_reordering(dim1
, dim2
);
1822 exp
= isl_reordering_extend_space(exp
, dim1
);
1823 isl_space_free(dim2
);
1826 dim1
= isl_space_copy(exp
->dim
);
1827 isl_reordering_free(exp
);
1830 isl_space_free(dim1
);
1831 isl_space_free(dim2
);
1835 /* Given the space of set (domain), construct a space for a map
1836 * with as domain the given space and as range the range of "model".
1838 __isl_give isl_space
*isl_space_extend_domain_with_range(
1839 __isl_take isl_space
*space
, __isl_take isl_space
*model
)
1844 space
= isl_space_from_domain(space
);
1845 space
= isl_space_add_dims(space
, isl_dim_out
,
1846 isl_space_dim(model
, isl_dim_out
));
1847 if (isl_space_has_tuple_id(model
, isl_dim_out
))
1848 space
= isl_space_set_tuple_id(space
, isl_dim_out
,
1849 isl_space_get_tuple_id(model
, isl_dim_out
));
1852 if (model
->nested
[1]) {
1853 isl_space
*nested
= isl_space_copy(model
->nested
[1]);
1854 int n_nested
, n_space
;
1855 nested
= isl_space_align_params(nested
, isl_space_copy(space
));
1856 n_nested
= isl_space_dim(nested
, isl_dim_param
);
1857 n_space
= isl_space_dim(space
, isl_dim_param
);
1858 if (n_nested
> n_space
)
1859 nested
= isl_space_drop_dims(nested
, isl_dim_param
,
1860 n_space
, n_nested
- n_space
);
1863 space
->nested
[1] = nested
;
1865 isl_space_free(model
);
1868 isl_space_free(model
);
1869 isl_space_free(space
);