add isl_basic_set_from_multi_aff
[isl.git] / doc / user.pod
blob786ded8ae531a885ce5e417c84b2e6705e5e37c4
1 =head1 Introduction
3 C<isl> is a thread-safe C library for manipulating
4 sets and relations of integer points bounded by affine constraints.
5 The descriptions of the sets and relations may involve
6 both parameters and existentially quantified variables.
7 All computations are performed in exact integer arithmetic
8 using C<GMP> or C<imath>.
9 The C<isl> library offers functionality that is similar
10 to that offered by the C<Omega> and C<Omega+> libraries,
11 but the underlying algorithms are in most cases completely different.
13 The library is by no means complete and some fairly basic
14 functionality is still missing.
15 Still, even in its current form, the library has been successfully
16 used as a backend polyhedral library for the polyhedral
17 scanner C<CLooG> and as part of an equivalence checker of
18 static affine programs.
19 For bug reports, feature requests and questions,
20 visit the discussion group at
21 L<http://groups.google.com/group/isl-development>.
23 =head2 Backward Incompatible Changes
25 =head3 Changes since isl-0.02
27 =over
29 =item * The old printing functions have been deprecated
30 and replaced by C<isl_printer> functions, see L<Input and Output>.
32 =item * Most functions related to dependence analysis have acquired
33 an extra C<must> argument.  To obtain the old behavior, this argument
34 should be given the value 1.  See L<Dependence Analysis>.
36 =back
38 =head3 Changes since isl-0.03
40 =over
42 =item * The function C<isl_pw_qpolynomial_fold_add> has been
43 renamed to C<isl_pw_qpolynomial_fold_fold>.
44 Similarly, C<isl_union_pw_qpolynomial_fold_add> has been
45 renamed to C<isl_union_pw_qpolynomial_fold_fold>.
47 =back
49 =head3 Changes since isl-0.04
51 =over
53 =item * All header files have been renamed from C<isl_header.h>
54 to C<isl/header.h>.
56 =back
58 =head3 Changes since isl-0.05
60 =over
62 =item * The functions C<isl_printer_print_basic_set> and
63 C<isl_printer_print_basic_map> no longer print a newline.
65 =item * The functions C<isl_flow_get_no_source>
66 and C<isl_union_map_compute_flow> now return
67 the accesses for which no source could be found instead of
68 the iterations where those accesses occur.
70 =item * The functions C<isl_basic_map_identity> and
71 C<isl_map_identity> now take a B<map> space as input.  An old call
72 C<isl_map_identity(space)> can be rewritten to
73 C<isl_map_identity(isl_space_map_from_set(space))>.
75 =item * The function C<isl_map_power> no longer takes
76 a parameter position as input.  Instead, the exponent
77 is now expressed as the domain of the resulting relation.
79 =back
81 =head3 Changes since isl-0.06
83 =over
85 =item * The format of C<isl_printer_print_qpolynomial>'s
86 C<ISL_FORMAT_ISL> output has changed.
87 Use C<ISL_FORMAT_C> to obtain the old output.
89 =item * The C<*_fast_*> functions have been renamed to C<*_plain_*>.
90 Some of the old names have been kept for backward compatibility,
91 but they will be removed in the future.
93 =back
95 =head3 Changes since isl-0.07
97 =over
99 =item * The function C<isl_pw_aff_max> has been renamed to
100 C<isl_pw_aff_union_max>.
101 Similarly, the function C<isl_pw_aff_add> has been renamed to
102 C<isl_pw_aff_union_add>.
104 =item * The C<isl_dim> type has been renamed to C<isl_space>
105 along with the associated functions.
106 Some of the old names have been kept for backward compatibility,
107 but they will be removed in the future.
109 =item * Spaces of maps, sets and parameter domains are now
110 treated differently.  The distinction between map spaces and set spaces
111 has always been made on a conceptual level, but proper use of such spaces
112 was never checked.  Furthermore, up until isl-0.07 there was no way
113 of explicitly creating a parameter space.  These can now be created
114 directly using C<isl_space_params_alloc> or from other spaces using
115 C<isl_space_params>.
117 =item * The space in which C<isl_aff>, C<isl_pw_aff>, C<isl_qpolynomial>,
118 C<isl_pw_qpolynomial>, C<isl_qpolynomial_fold> and C<isl_pw_qpolynomial_fold>
119 objects live is now a map space
120 instead of a set space.  This means, for example, that the dimensions
121 of the domain of an C<isl_aff> are now considered to be of type
122 C<isl_dim_in> instead of C<isl_dim_set>.  Extra functions have been
123 added to obtain the domain space.  Some of the constructors still
124 take a domain space and have therefore been renamed.
126 =item * The functions C<isl_equality_alloc> and C<isl_inequality_alloc>
127 now take an C<isl_local_space> instead of an C<isl_space>.
128 An C<isl_local_space> can be created from an C<isl_space>
129 using C<isl_local_space_from_space>.
131 =item * The C<isl_div> type has been removed.  Functions that used
132 to return an C<isl_div> now return an C<isl_aff>.
133 Note that the space of an C<isl_aff> is that of relation.
134 When replacing a call to C<isl_div_get_coefficient> by a call to
135 C<isl_aff_get_coefficient> any C<isl_dim_set> argument needs
136 to be replaced by C<isl_dim_in>.
137 A call to C<isl_aff_from_div> can be replaced by a call
138 to C<isl_aff_floor>.
139 A call to C<isl_qpolynomial_div(div)> call be replaced by
140 the nested call
142         isl_qpolynomial_from_aff(isl_aff_floor(div))
144 The function C<isl_constraint_div> has also been renamed
145 to C<isl_constraint_get_div>.
147 =item * The C<nparam> argument has been removed from
148 C<isl_map_read_from_str> and similar functions.
149 When reading input in the original PolyLib format,
150 the result will have no parameters.
151 If parameters are expected, the caller may want to perform
152 dimension manipulation on the result.
154 =back
156 =head3 Changes since isl-0.09
158 =over
160 =item * The C<schedule_split_parallel> option has been replaced
161 by the C<schedule_split_scaled> option.
163 =item * The first argument of C<isl_pw_aff_cond> is now
164 an C<isl_pw_aff> instead of an C<isl_set>.
165 A call C<isl_pw_aff_cond(a, b, c)> can be replaced by
167         isl_pw_aff_cond(isl_set_indicator_function(a), b, c)
169 =back
171 =head3 Changes since isl-0.10
173 =over
175 =item * The functions C<isl_set_dim_has_lower_bound> and
176 C<isl_set_dim_has_upper_bound> have been renamed to
177 C<isl_set_dim_has_any_lower_bound> and
178 C<isl_set_dim_has_any_upper_bound>.
179 The new C<isl_set_dim_has_lower_bound> and
180 C<isl_set_dim_has_upper_bound> have slightly different meanings.
182 =back
184 =head3 Changes since isl-0.12
186 =over
188 =item * C<isl_int> has been replaced by C<isl_val>.
189 Some of the old functions are still available in C<isl/deprecated/*.h>
190 but they will be removed in the future.
192 =item * The functions C<isl_pw_qpolynomial_eval>,
193 C<isl_union_pw_qpolynomial_eval>, C<isl_pw_qpolynomial_fold_eval>
194 and C<isl_union_pw_qpolynomial_fold_eval> have been changed to return
195 an C<isl_val> instead of an C<isl_qpolynomial>.
197 =item * The function C<isl_band_member_is_zero_distance>
198 has been removed.  Essentially the same functionality is available
199 through C<isl_band_member_is_coincident>, except that it requires
200 setting up coincidence constraints.
201 The option C<schedule_outer_zero_distance> has accordingly been
202 replaced by the option C<schedule_outer_coincidence>.
204 =item * The function C<isl_vertex_get_expr> has been changed
205 to return an C<isl_multi_aff> instead of a rational C<isl_basic_set>.
206 The function C<isl_vertex_get_domain> has been changed to return
207 a regular basic set, rather than a rational basic set.
209 =back
211 =head3 Changes since isl-0.14
213 =over
215 =item * The function C<isl_union_pw_multi_aff_add> now consistently
216 computes the sum on the shared definition domain.
217 The function C<isl_union_pw_multi_aff_union_add> has been added
218 to compute the sum on the union of definition domains.
219 The original behavior of C<isl_union_pw_multi_aff_add> was
220 confused and is no longer available.
222 =item * Band forests have been replaced by schedule trees.
224 =item * The function C<isl_union_map_compute_flow> has been
225 replaced by the function C<isl_union_access_info_compute_flow>.
226 Note that the may dependence relation returned by
227 C<isl_union_flow_get_may_dependence> is the union of
228 the two dependence relations returned by
229 C<isl_union_map_compute_flow>.  Similarly for the no source relations.
230 The function C<isl_union_map_compute_flow> is still available
231 for backward compatibility, but it will be removed in the future.
233 =item * The function C<isl_basic_set_drop_constraint> has been
234 deprecated.
236 =item * The function C<isl_ast_build_ast_from_schedule> has been
237 renamed to C<isl_ast_build_node_from_schedule_map>.
238 The original name is still available
239 for backward compatibility, but it will be removed in the future.
241 =item * The C<separation_class> AST generation option has been
242 deprecated.
244 =item * The functions C<isl_equality_alloc> and C<isl_inequality_alloc>
245 have been renamed to C<isl_constraint_alloc_equality> and
246 C<isl_constraint_alloc_inequality>.  The original names have been
247 kept for backward compatibility, but they will be removed in the future.
249 =item * The C<schedule_fuse> option has been replaced
250 by the C<schedule_serialize_sccs> option.  The effect
251 of setting the C<schedule_fuse> option to C<ISL_SCHEDULE_FUSE_MIN>
252 is now obtained by turning on the C<schedule_serialize_sccs> option.
254 =back
256 =head3 Changes since isl-0.17
258 =over
260 =item * The function C<isl_printer_print_ast_expr> no longer prints
261 in C format by default.  To print in C format, the output format
262 of the printer needs to have been explicitly set to C<ISL_FORMAT_C>.
263 As a result, the function C<isl_ast_expr_to_str> no longer prints
264 the expression in C format.  Use C<isl_ast_expr_to_C_str> instead.
266 =item * The functions C<isl_set_align_divs> and C<isl_map_align_divs>
267 have been deprecated.  The function C<isl_set_lift> has an effect
268 that is similar to C<isl_set_align_divs> and could in some cases
269 be used as an alternative.
271 =back
273 =head3 Changes since isl-0.19
275 =over
277 =item * Zero-dimensional objects of type C<isl_multi_pw_aff> or
278 C<isl_multi_union_pw_aff> can now keep track of an explicit domain.
279 This explicit domain, if present, is taken into account
280 by various operations that take such objects as input.
282 =back
284 =head1 License
286 C<isl> is released under the MIT license.
288 =over
290 Permission is hereby granted, free of charge, to any person obtaining a copy of
291 this software and associated documentation files (the "Software"), to deal in
292 the Software without restriction, including without limitation the rights to
293 use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
294 of the Software, and to permit persons to whom the Software is furnished to do
295 so, subject to the following conditions:
297 The above copyright notice and this permission notice shall be included in all
298 copies or substantial portions of the Software.
300 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
301 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
302 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
303 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
304 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
305 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
306 SOFTWARE.
308 =back
310 Note that by default C<isl> requires C<GMP>, which is released
311 under the GNU Lesser General Public License (LGPL).  This means
312 that code linked against C<isl> is also linked against LGPL code.
314 When configuring with C<--with-int=imath> or C<--with-int=imath-32>, C<isl>
315 will link against C<imath>, a library for exact integer arithmetic released
316 under the MIT license.
318 =head1 Installation
320 The source of C<isl> can be obtained either as a tarball
321 or from the git repository.  Both are available from
322 L<http://isl.gforge.inria.fr/>.
323 The installation process depends on how you obtained
324 the source.
326 =head2 Installation from the git repository
328 =over
330 =item 1 Clone or update the repository
332 The first time the source is obtained, you need to clone
333 the repository.
335         git clone git://repo.or.cz/isl.git
337 To obtain updates, you need to pull in the latest changes
339         git pull
341 =item 2 Optionally get C<imath> submodule
343 To build C<isl> with C<imath>, you need to obtain the C<imath>
344 submodule by running in the git source tree of C<isl>
346        git submodule init
347        git submodule update
349 This will fetch the required version of C<imath> in a subdirectory of C<isl>.
351 =item 2 Generate C<configure>
353         ./autogen.sh
355 =back
357 After performing the above steps, continue
358 with the L<Common installation instructions>.
360 =head2 Common installation instructions
362 =over
364 =item 1 Obtain C<GMP>
366 By default, building C<isl> requires C<GMP>, including its headers files.
367 Your distribution may not provide these header files by default
368 and you may need to install a package called C<gmp-devel> or something
369 similar.  Alternatively, C<GMP> can be built from
370 source, available from L<http://gmplib.org/>.
371 C<GMP> is not needed if you build C<isl> with C<imath>.
373 =item 2 Configure
375 C<isl> uses the standard C<autoconf> C<configure> script.
376 To run it, just type
378         ./configure
380 optionally followed by some configure options.
381 A complete list of options can be obtained by running
383         ./configure --help
385 Below we discuss some of the more common options.
387 =over
389 =item C<--prefix>
391 Installation prefix for C<isl>
393 =item C<--with-int=[gmp|imath|imath-32]>
395 Select the integer library to be used by C<isl>, the default is C<gmp>.
396 With C<imath-32>, C<isl> will use 32 bit integers, but fall back to C<imath>
397 for values out of the 32 bit range. In most applications, C<isl> will run
398 fastest with the C<imath-32> option, followed by C<gmp> and C<imath>, the
399 slowest.
401 =item C<--with-gmp-prefix>
403 Installation prefix for C<GMP> (architecture-independent files).
405 =item C<--with-gmp-exec-prefix>
407 Installation prefix for C<GMP> (architecture-dependent files).
409 =back
411 =item 3 Compile
413         make
415 =item 4 Install (optional)
417         make install
419 =back
421 =head1 Integer Set Library
423 =head2 Memory Management
425 Since a high-level operation on isl objects usually involves
426 several substeps and since the user is usually not interested in
427 the intermediate results, most functions that return a new object
428 will also release all the objects passed as arguments.
429 If the user still wants to use one or more of these arguments
430 after the function call, she should pass along a copy of the
431 object rather than the object itself.
432 The user is then responsible for making sure that the original
433 object gets used somewhere else or is explicitly freed.
435 The arguments and return values of all documented functions are
436 annotated to make clear which arguments are released and which
437 arguments are preserved.  In particular, the following annotations
438 are used
440 =over
442 =item C<__isl_give>
444 C<__isl_give> means that a new object is returned.
445 The user should make sure that the returned pointer is
446 used exactly once as a value for an C<__isl_take> argument.
447 In between, it can be used as a value for as many
448 C<__isl_keep> arguments as the user likes.
449 There is one exception, and that is the case where the
450 pointer returned is C<NULL>.  Is this case, the user
451 is free to use it as an C<__isl_take> argument or not.
452 When applied to a C<char *>, the returned pointer needs to be
453 freed using C<free>.
455 =item C<__isl_null>
457 C<__isl_null> means that a C<NULL> value is returned.
459 =item C<__isl_take>
461 C<__isl_take> means that the object the argument points to
462 is taken over by the function and may no longer be used
463 by the user as an argument to any other function.
464 The pointer value must be one returned by a function
465 returning an C<__isl_give> pointer.
466 If the user passes in a C<NULL> value, then this will
467 be treated as an error in the sense that the function will
468 not perform its usual operation.  However, it will still
469 make sure that all the other C<__isl_take> arguments
470 are released.
472 =item C<__isl_keep>
474 C<__isl_keep> means that the function will only use the object
475 temporarily.  After the function has finished, the user
476 can still use it as an argument to other functions.
477 A C<NULL> value will be treated in the same way as
478 a C<NULL> value for an C<__isl_take> argument.
479 This annotation may also be used on return values of
480 type C<const char *>, in which case the returned pointer should
481 not be freed by the user and is only valid until the object
482 from which it was derived is updated or freed.
484 =back
486 =head2 Initialization
488 All manipulations of integer sets and relations occur within
489 the context of an C<isl_ctx>.
490 A given C<isl_ctx> can only be used within a single thread.
491 All arguments of a function are required to have been allocated
492 within the same context.
493 There are currently no functions available for moving an object
494 from one C<isl_ctx> to another C<isl_ctx>.  This means that
495 there is currently no way of safely moving an object from one
496 thread to another, unless the whole C<isl_ctx> is moved.
498 An C<isl_ctx> can be allocated using C<isl_ctx_alloc> and
499 freed using C<isl_ctx_free>.
500 All objects allocated within an C<isl_ctx> should be freed
501 before the C<isl_ctx> itself is freed.
503         isl_ctx *isl_ctx_alloc();
504         void isl_ctx_free(isl_ctx *ctx);
506 The user can impose a bound on the number of low-level I<operations>
507 that can be performed by an C<isl_ctx>.  This bound can be set and
508 retrieved using the following functions.  A bound of zero means that
509 no bound is imposed.  The number of operations performed can be
510 reset using C<isl_ctx_reset_operations>.  Note that the number
511 of low-level operations needed to perform a high-level computation
512 may differ significantly across different versions
513 of C<isl>, but it should be the same across different platforms
514 for the same version of C<isl>.
516 Warning: This feature is experimental.  C<isl> has good support to abort and
517 bail out during the computation, but this feature may exercise error code paths
518 that are normally not used that much. Consequently, it is not unlikely that
519 hidden bugs will be exposed.
521         void isl_ctx_set_max_operations(isl_ctx *ctx,
522                 unsigned long max_operations);
523         unsigned long isl_ctx_get_max_operations(isl_ctx *ctx);
524         void isl_ctx_reset_operations(isl_ctx *ctx);
526 In order to be able to create an object in the same context
527 as another object, most object types (described later in
528 this document) provide a function to obtain the context
529 in which the object was created.
531         #include <isl/val.h>
532         isl_ctx *isl_val_get_ctx(__isl_keep isl_val *val);
533         isl_ctx *isl_multi_val_get_ctx(
534                 __isl_keep isl_multi_val *mv);
536         #include <isl/id.h>
537         isl_ctx *isl_id_get_ctx(__isl_keep isl_id *id);
539         #include <isl/local_space.h>
540         isl_ctx *isl_local_space_get_ctx(
541                 __isl_keep isl_local_space *ls);
543         #include <isl/set.h>
544         isl_ctx *isl_set_list_get_ctx(
545                 __isl_keep isl_set_list *list);
547         #include <isl/aff.h>
548         isl_ctx *isl_aff_get_ctx(__isl_keep isl_aff *aff);
549         isl_ctx *isl_multi_aff_get_ctx(
550                 __isl_keep isl_multi_aff *maff);
551         isl_ctx *isl_pw_aff_get_ctx(__isl_keep isl_pw_aff *pa);
552         isl_ctx *isl_pw_multi_aff_get_ctx(
553                 __isl_keep isl_pw_multi_aff *pma);
554         isl_ctx *isl_multi_pw_aff_get_ctx(
555                 __isl_keep isl_multi_pw_aff *mpa);
556         isl_ctx *isl_union_pw_aff_get_ctx(
557                 __isl_keep isl_union_pw_aff *upa);
558         isl_ctx *isl_union_pw_multi_aff_get_ctx(
559                 __isl_keep isl_union_pw_multi_aff *upma);
560         isl_ctx *isl_multi_union_pw_aff_get_ctx(
561                 __isl_keep isl_multi_union_pw_aff *mupa);
563         #include <isl/id_to_ast_expr.h>
564         isl_ctx *isl_id_to_ast_expr_get_ctx(
565                 __isl_keep isl_id_to_ast_expr *id2expr);
567         #include <isl/point.h>
568         isl_ctx *isl_point_get_ctx(__isl_keep isl_point *pnt);
570         #include <isl/vec.h>
571         isl_ctx *isl_vec_get_ctx(__isl_keep isl_vec *vec);
573         #include <isl/mat.h>
574         isl_ctx *isl_mat_get_ctx(__isl_keep isl_mat *mat);
576         #include <isl/vertices.h>
577         isl_ctx *isl_vertices_get_ctx(
578                 __isl_keep isl_vertices *vertices);
579         isl_ctx *isl_vertex_get_ctx(__isl_keep isl_vertex *vertex);
580         isl_ctx *isl_cell_get_ctx(__isl_keep isl_cell *cell);
582         #include <isl/flow.h>
583         isl_ctx *isl_restriction_get_ctx(
584                 __isl_keep isl_restriction *restr);
585         isl_ctx *isl_union_access_info_get_ctx(
586                 __isl_keep isl_union_access_info *access);
587         isl_ctx *isl_union_flow_get_ctx(
588                 __isl_keep isl_union_flow *flow);
590         #include <isl/schedule.h>
591         isl_ctx *isl_schedule_get_ctx(
592                 __isl_keep isl_schedule *sched);
593         isl_ctx *isl_schedule_constraints_get_ctx(
594                 __isl_keep isl_schedule_constraints *sc);
596         #include <isl/schedule_node.h>
597         isl_ctx *isl_schedule_node_get_ctx(
598                 __isl_keep isl_schedule_node *node);
600         #include <isl/ast_build.h>
601         isl_ctx *isl_ast_build_get_ctx(
602                 __isl_keep isl_ast_build *build);
604         #include <isl/ast.h>
605         isl_ctx *isl_ast_expr_get_ctx(
606                 __isl_keep isl_ast_expr *expr);
607         isl_ctx *isl_ast_node_get_ctx(
608                 __isl_keep isl_ast_node *node);
610         #include <isl/stride_info.h>
611         isl_ctx *isl_stride_info_get_ctx(
612                 __isl_keep isl_stride_info *si);
614         #include <isl/fixed_box.h>
615         isl_ctx *isl_fixed_box_get_ctx(
616                 __isl_keep isl_fixed_box *box);
618 =head2 Return Types
620 C<isl> uses two special return types for functions that either return
621 a boolean or that in principle do not return anything.
622 In particular, the C<isl_bool> type has three possible values:
623 C<isl_bool_true> (a positive integer value), indicating I<true> or I<yes>;
624 C<isl_bool_false> (the integer value zero), indicating I<false> or I<no>; and
625 C<isl_bool_error> (a negative integer value), indicating that something
626 went wrong.  The following function can be used to negate an C<isl_bool>,
627 where the negation of C<isl_bool_error> is C<isl_bool_error> again.
629         #include <isl/val.h>
630         isl_bool isl_bool_not(isl_bool b);
632 The C<isl_stat> type has two possible values:
633 C<isl_stat_ok> (the integer value zero), indicating a successful
634 operation; and
635 C<isl_stat_error> (a negative integer value), indicating that something
636 went wrong.
637 See L</"Error Handling"> for more information on
638 C<isl_bool_error> and C<isl_stat_error>.
640 =head2 Values
642 An C<isl_val> represents an integer value, a rational value
643 or one of three special values, infinity, negative infinity and NaN.
644 Some predefined values can be created using the following functions.
646         #include <isl/val.h>
647         __isl_give isl_val *isl_val_zero(isl_ctx *ctx);
648         __isl_give isl_val *isl_val_one(isl_ctx *ctx);
649         __isl_give isl_val *isl_val_negone(isl_ctx *ctx);
650         __isl_give isl_val *isl_val_nan(isl_ctx *ctx);
651         __isl_give isl_val *isl_val_infty(isl_ctx *ctx);
652         __isl_give isl_val *isl_val_neginfty(isl_ctx *ctx);
654 Specific integer values can be created using the following functions.
656         #include <isl/val.h>
657         __isl_give isl_val *isl_val_int_from_si(isl_ctx *ctx,
658                 long i);
659         __isl_give isl_val *isl_val_int_from_ui(isl_ctx *ctx,
660                 unsigned long u);
661         __isl_give isl_val *isl_val_int_from_chunks(isl_ctx *ctx,
662                 size_t n, size_t size, const void *chunks);
664 The function C<isl_val_int_from_chunks> constructs an C<isl_val>
665 from the C<n> I<digits>, each consisting of C<size> bytes, stored at C<chunks>.
666 The least significant digit is assumed to be stored first.
668 Value objects can be copied and freed using the following functions.
670         #include <isl/val.h>
671         __isl_give isl_val *isl_val_copy(__isl_keep isl_val *v);
672         __isl_null isl_val *isl_val_free(__isl_take isl_val *v);
674 They can be inspected using the following functions.
676         #include <isl/val.h>
677         long isl_val_get_num_si(__isl_keep isl_val *v);
678         long isl_val_get_den_si(__isl_keep isl_val *v);
679         __isl_give isl_val *isl_val_get_den_val(
680                 __isl_keep isl_val *v);
681         double isl_val_get_d(__isl_keep isl_val *v);
682         size_t isl_val_n_abs_num_chunks(__isl_keep isl_val *v,
683                 size_t size);
684         int isl_val_get_abs_num_chunks(__isl_keep isl_val *v,
685                 size_t size, void *chunks);
687 C<isl_val_n_abs_num_chunks> returns the number of I<digits>
688 of C<size> bytes needed to store the absolute value of the
689 numerator of C<v>.
690 C<isl_val_get_abs_num_chunks> stores these digits at C<chunks>,
691 which is assumed to have been preallocated by the caller.
692 The least significant digit is stored first.
693 Note that C<isl_val_get_num_si>, C<isl_val_get_den_si>,
694 C<isl_val_get_d>, C<isl_val_n_abs_num_chunks>
695 and C<isl_val_get_abs_num_chunks> can only be applied to rational values.
697 An C<isl_val> can be modified using the following function.
699         #include <isl/val.h>
700         __isl_give isl_val *isl_val_set_si(__isl_take isl_val *v,
701                 long i);
703 The following unary properties are defined on C<isl_val>s.
705         #include <isl/val.h>
706         int isl_val_sgn(__isl_keep isl_val *v);
707         isl_bool isl_val_is_zero(__isl_keep isl_val *v);
708         isl_bool isl_val_is_one(__isl_keep isl_val *v);
709         isl_bool isl_val_is_negone(__isl_keep isl_val *v);
710         isl_bool isl_val_is_nonneg(__isl_keep isl_val *v);
711         isl_bool isl_val_is_nonpos(__isl_keep isl_val *v);
712         isl_bool isl_val_is_pos(__isl_keep isl_val *v);
713         isl_bool isl_val_is_neg(__isl_keep isl_val *v);
714         isl_bool isl_val_is_int(__isl_keep isl_val *v);
715         isl_bool isl_val_is_rat(__isl_keep isl_val *v);
716         isl_bool isl_val_is_nan(__isl_keep isl_val *v);
717         isl_bool isl_val_is_infty(__isl_keep isl_val *v);
718         isl_bool isl_val_is_neginfty(__isl_keep isl_val *v);
720 Note that the sign of NaN is undefined.
722 The following binary properties are defined on pairs of C<isl_val>s.
724         #include <isl/val.h>
725         isl_bool isl_val_lt(__isl_keep isl_val *v1,
726                 __isl_keep isl_val *v2);
727         isl_bool isl_val_le(__isl_keep isl_val *v1,
728                 __isl_keep isl_val *v2);
729         isl_bool isl_val_gt(__isl_keep isl_val *v1,
730                 __isl_keep isl_val *v2);
731         isl_bool isl_val_ge(__isl_keep isl_val *v1,
732                 __isl_keep isl_val *v2);
733         isl_bool isl_val_eq(__isl_keep isl_val *v1,
734                 __isl_keep isl_val *v2);
735         isl_bool isl_val_ne(__isl_keep isl_val *v1,
736                 __isl_keep isl_val *v2);
737         isl_bool isl_val_abs_eq(__isl_keep isl_val *v1,
738                 __isl_keep isl_val *v2);
740 Comparisons to NaN always return false.
741 That is, a NaN is not considered to hold any relative position
742 with respect to any value.  In particular, a NaN
743 is neither considered to be equal to nor to be different from
744 any value (including another NaN).
745 The function C<isl_val_abs_eq> checks whether its two arguments
746 are equal in absolute value.
748 For integer C<isl_val>s we additionally have the following binary property.
750         #include <isl/val.h>
751         isl_bool isl_val_is_divisible_by(__isl_keep isl_val *v1,
752                 __isl_keep isl_val *v2);
754 An C<isl_val> can also be compared to an integer using the following
755 functions.  The result of C<isl_val_cmp_si> undefined for NaN.
757         #include <isl/val.h>
758         isl_bool isl_val_gt_si(__isl_keep isl_val *v, long i);
759         int isl_val_cmp_si(__isl_keep isl_val *v, long i);
761 The following unary operations are available on C<isl_val>s.
763         #include <isl/val.h>
764         __isl_give isl_val *isl_val_abs(__isl_take isl_val *v);
765         __isl_give isl_val *isl_val_neg(__isl_take isl_val *v);
766         __isl_give isl_val *isl_val_floor(__isl_take isl_val *v);
767         __isl_give isl_val *isl_val_ceil(__isl_take isl_val *v);
768         __isl_give isl_val *isl_val_trunc(__isl_take isl_val *v);
769         __isl_give isl_val *isl_val_inv(__isl_take isl_val *v);
770         __isl_give isl_val *isl_val_2exp(__isl_take isl_val *v);
772 The following binary operations are available on C<isl_val>s.
774         #include <isl/val.h>
775         __isl_give isl_val *isl_val_min(__isl_take isl_val *v1,
776                 __isl_take isl_val *v2);
777         __isl_give isl_val *isl_val_max(__isl_take isl_val *v1,
778                 __isl_take isl_val *v2);
779         __isl_give isl_val *isl_val_add(__isl_take isl_val *v1,
780                 __isl_take isl_val *v2);
781         __isl_give isl_val *isl_val_add_ui(__isl_take isl_val *v1,
782                 unsigned long v2);
783         __isl_give isl_val *isl_val_sub(__isl_take isl_val *v1,
784                 __isl_take isl_val *v2);
785         __isl_give isl_val *isl_val_sub_ui(__isl_take isl_val *v1,
786                 unsigned long v2);
787         __isl_give isl_val *isl_val_mul(__isl_take isl_val *v1,
788                 __isl_take isl_val *v2);
789         __isl_give isl_val *isl_val_mul_ui(__isl_take isl_val *v1,
790                 unsigned long v2);
791         __isl_give isl_val *isl_val_div(__isl_take isl_val *v1,
792                 __isl_take isl_val *v2);
793         __isl_give isl_val *isl_val_div_ui(__isl_take isl_val *v1,
794                 unsigned long v2);
796 On integer values, we additionally have the following operations.
798         #include <isl/val.h>
799         __isl_give isl_val *isl_val_2exp(__isl_take isl_val *v);
800         __isl_give isl_val *isl_val_mod(__isl_take isl_val *v1,
801                 __isl_take isl_val *v2);
802         __isl_give isl_val *isl_val_gcd(__isl_take isl_val *v1,
803                 __isl_take isl_val *v2);
804         __isl_give isl_val *isl_val_gcdext(__isl_take isl_val *v1,
805                 __isl_take isl_val *v2, __isl_give isl_val **x,
806                 __isl_give isl_val **y);
808 The function C<isl_val_gcdext> returns the greatest common divisor g
809 of C<v1> and C<v2> as well as two integers C<*x> and C<*y> such
810 that C<*x> * C<v1> + C<*y> * C<v2> = g.
812 =head3 GMP specific functions
814 These functions are only available if C<isl> has been compiled with C<GMP>
815 support.
817 Specific integer and rational values can be created from C<GMP> values using
818 the following functions.
820         #include <isl/val_gmp.h>
821         __isl_give isl_val *isl_val_int_from_gmp(isl_ctx *ctx,
822                 mpz_t z);
823         __isl_give isl_val *isl_val_from_gmp(isl_ctx *ctx,
824                 const mpz_t n, const mpz_t d);
826 The numerator and denominator of a rational value can be extracted as
827 C<GMP> values using the following functions.
829         #include <isl/val_gmp.h>
830         int isl_val_get_num_gmp(__isl_keep isl_val *v, mpz_t z);
831         int isl_val_get_den_gmp(__isl_keep isl_val *v, mpz_t z);
833 =head2 Sets and Relations
835 C<isl> uses six types of objects for representing sets and relations,
836 C<isl_basic_set>, C<isl_basic_map>, C<isl_set>, C<isl_map>,
837 C<isl_union_set> and C<isl_union_map>.
838 C<isl_basic_set> and C<isl_basic_map> represent sets and relations that
839 can be described as a conjunction of affine constraints, while
840 C<isl_set> and C<isl_map> represent unions of
841 C<isl_basic_set>s and C<isl_basic_map>s, respectively.
842 However, all C<isl_basic_set>s or C<isl_basic_map>s in the union need
843 to live in the same space.  C<isl_union_set>s and C<isl_union_map>s
844 represent unions of C<isl_set>s or C<isl_map>s in I<different> spaces,
845 where spaces are considered different if they have a different number
846 of dimensions and/or different names (see L<"Spaces">).
847 The difference between sets and relations (maps) is that sets have
848 one set of variables, while relations have two sets of variables,
849 input variables and output variables.
851 =head2 Error Handling
853 C<isl> supports different ways to react in case a runtime error is triggered.
854 Runtime errors arise, e.g., if a function such as C<isl_map_intersect> is called
855 with two maps that have incompatible spaces. There are three possible ways
856 to react on error: to warn, to continue or to abort.
858 The default behavior is to warn. In this mode, C<isl> prints a warning, stores
859 the last error in the corresponding C<isl_ctx> and the function in which the
860 error was triggered returns a value indicating that some error has
861 occurred.  In case of functions returning a pointer, this value is
862 C<NULL>.  In case of functions returning an C<isl_bool> or an
863 C<isl_stat>, this value is C<isl_bool_error> or C<isl_stat_error>.
864 An error does not corrupt internal state,
865 such that isl can continue to be used. C<isl> also provides functions to
866 read the last error, including the specific error message,
867 the isl source file where the error occurred and the line number,
868 and to reset all information about the last error. The
869 last error is only stored for information purposes. Its presence does not
870 change the behavior of C<isl>. Hence, resetting an error is not required to
871 continue to use isl, but only to observe new errors.
873         #include <isl/ctx.h>
874         enum isl_error isl_ctx_last_error(isl_ctx *ctx);
875         const char *isl_ctx_last_error_msg(isl_ctx *ctx);
876         const char *isl_ctx_last_error_file(isl_ctx *ctx);
877         int isl_ctx_last_error_line(isl_ctx *ctx);
878         void isl_ctx_reset_error(isl_ctx *ctx);
880 If no error has occurred since the last call to C<isl_ctx_reset_error>,
881 then the functions C<isl_ctx_last_error_msg> and
882 C<isl_ctx_last_error_file> return C<NULL>.
884 Another option is to continue on error. This is similar to warn on error mode,
885 except that C<isl> does not print any warning. This allows a program to
886 implement its own error reporting.
888 The last option is to directly abort the execution of the program from within
889 the isl library. This makes it obviously impossible to recover from an error,
890 but it allows to directly spot the error location. By aborting on error,
891 debuggers break at the location the error occurred and can provide a stack
892 trace. Other tools that automatically provide stack traces on abort or that do
893 not want to continue execution after an error was triggered may also prefer to
894 abort on error.
896 The on error behavior of isl can be specified by calling
897 C<isl_options_set_on_error> or by setting the command line option
898 C<--isl-on-error>. Valid arguments for the function call are
899 C<ISL_ON_ERROR_WARN>, C<ISL_ON_ERROR_CONTINUE> and C<ISL_ON_ERROR_ABORT>. The
900 choices for the command line option are C<warn>, C<continue> and C<abort>.
901 It is also possible to query the current error mode.
903         #include <isl/options.h>
904         isl_stat isl_options_set_on_error(isl_ctx *ctx, int val);
905         int isl_options_get_on_error(isl_ctx *ctx);
907 =head2 Identifiers
909 Identifiers are used to identify both individual dimensions
910 and tuples of dimensions.  They consist of an optional name and an optional
911 user pointer.  The name and the user pointer cannot both be C<NULL>, however.
912 Identifiers with the same name but different pointer values
913 are considered to be distinct.
914 Similarly, identifiers with different names but the same pointer value
915 are also considered to be distinct.
916 Equal identifiers are represented using the same object.
917 Pairs of identifiers can therefore be tested for equality using the
918 C<==> operator.
919 Identifiers can be constructed, copied, freed, inspected and printed
920 using the following functions.
922         #include <isl/id.h>
923         __isl_give isl_id *isl_id_alloc(isl_ctx *ctx,
924                 __isl_keep const char *name, void *user);
925         __isl_give isl_id *isl_id_set_free_user(
926                 __isl_take isl_id *id,
927                 void (*free_user)(void *user));
928         __isl_give isl_id *isl_id_copy(isl_id *id);
929         __isl_null isl_id *isl_id_free(__isl_take isl_id *id);
931         void *isl_id_get_user(__isl_keep isl_id *id);
932         __isl_keep const char *isl_id_get_name(__isl_keep isl_id *id);
934         __isl_give isl_printer *isl_printer_print_id(
935                 __isl_take isl_printer *p, __isl_keep isl_id *id);
937 The callback set by C<isl_id_set_free_user> is called on the user
938 pointer when the last reference to the C<isl_id> is freed.
939 Note that C<isl_id_get_name> returns a pointer to some internal
940 data structure, so the result can only be used while the
941 corresponding C<isl_id> is alive.
943 =head2 Spaces
945 Whenever a new set, relation or similar object is created from scratch,
946 the space in which it lives needs to be specified using an C<isl_space>.
947 Each space involves zero or more parameters and zero, one or two
948 tuples of set or input/output dimensions.  The parameters and dimensions
949 are identified by an C<isl_dim_type> and a position.
950 The type C<isl_dim_param> refers to parameters,
951 the type C<isl_dim_set> refers to set dimensions (for spaces
952 with a single tuple of dimensions) and the types C<isl_dim_in>
953 and C<isl_dim_out> refer to input and output dimensions
954 (for spaces with two tuples of dimensions).
955 Local spaces (see L</"Local Spaces">) also contain dimensions
956 of type C<isl_dim_div>.
957 Note that parameters are only identified by their position within
958 a given object.  Across different objects, parameters are (usually)
959 identified by their names or identifiers.  Only unnamed parameters
960 are identified by their positions across objects.  The use of unnamed
961 parameters is discouraged.
963         #include <isl/space.h>
964         __isl_give isl_space *isl_space_alloc(isl_ctx *ctx,
965                 unsigned nparam, unsigned n_in, unsigned n_out);
966         __isl_give isl_space *isl_space_params_alloc(isl_ctx *ctx,
967                 unsigned nparam);
968         __isl_give isl_space *isl_space_set_alloc(isl_ctx *ctx,
969                 unsigned nparam, unsigned dim);
970         __isl_give isl_space *isl_space_copy(__isl_keep isl_space *space);
971         __isl_null isl_space *isl_space_free(__isl_take isl_space *space);
973 The space used for creating a parameter domain
974 needs to be created using C<isl_space_params_alloc>.
975 For other sets, the space
976 needs to be created using C<isl_space_set_alloc>, while
977 for a relation, the space
978 needs to be created using C<isl_space_alloc>.
980 To check whether a given space is that of a set or a map
981 or whether it is a parameter space, use these functions:
983         #include <isl/space.h>
984         isl_bool isl_space_is_params(__isl_keep isl_space *space);
985         isl_bool isl_space_is_set(__isl_keep isl_space *space);
986         isl_bool isl_space_is_map(__isl_keep isl_space *space);
988 Spaces can be compared using the following functions:
990         #include <isl/space.h>
991         isl_bool isl_space_is_equal(__isl_keep isl_space *space1,
992                 __isl_keep isl_space *space2);
993         isl_bool isl_space_has_equal_params(
994                 __isl_keep isl_space *space1,
995                 __isl_keep isl_space *space2);
996         isl_bool isl_space_has_equal_tuples(
997                 __isl_keep isl_space *space1,
998                 __isl_keep isl_space *space2);
999         isl_bool isl_space_is_domain(__isl_keep isl_space *space1,
1000                 __isl_keep isl_space *space2);
1001         isl_bool isl_space_is_range(__isl_keep isl_space *space1,
1002                 __isl_keep isl_space *space2);
1003         isl_bool isl_space_tuple_is_equal(
1004                 __isl_keep isl_space *space1,
1005                 enum isl_dim_type type1,
1006                 __isl_keep isl_space *space2,
1007                 enum isl_dim_type type2);
1009 C<isl_space_is_domain> checks whether the first argument is equal
1010 to the domain of the second argument.  This requires in particular that
1011 the first argument is a set space and that the second argument
1012 is a map space.  C<isl_space_tuple_is_equal> checks whether the given
1013 tuples (C<isl_dim_in>, C<isl_dim_out> or C<isl_dim_set>) of the given
1014 spaces are the same.  That is, it checks if they have the same
1015 identifier (if any), the same dimension and the same internal structure
1016 (if any).
1017 The function
1018 C<isl_space_has_equal_params> checks whether two spaces
1019 have the same parameters in the same order.
1020 C<isl_space_has_equal_tuples> check whether two spaces have
1021 the same tuples.  In contrast to C<isl_space_is_equal> below,
1022 it does not check the
1023 parameters.  This is useful because many C<isl> functions align the
1024 parameters before they perform their operations, such that equivalence
1025 is not necessary.
1026 C<isl_space_is_equal> checks whether two spaces are identical,
1027 meaning that they have the same parameters and the same tuples.
1028 That is, it checks whether both C<isl_space_has_equal_params> and
1029 C<isl_space_has_equal_tuples> hold.
1031 It is often useful to create objects that live in the
1032 same space as some other object.  This can be accomplished
1033 by creating the new objects
1034 (see L</"Creating New Sets and Relations"> or
1035 L</"Functions">) based on the space
1036 of the original object.
1038         #include <isl/set.h>
1039         __isl_give isl_space *isl_basic_set_get_space(
1040                 __isl_keep isl_basic_set *bset);
1041         __isl_give isl_space *isl_set_get_space(__isl_keep isl_set *set);
1043         #include <isl/union_set.h>
1044         __isl_give isl_space *isl_union_set_get_space(
1045                 __isl_keep isl_union_set *uset);
1047         #include <isl/map.h>
1048         __isl_give isl_space *isl_basic_map_get_space(
1049                 __isl_keep isl_basic_map *bmap);
1050         __isl_give isl_space *isl_map_get_space(__isl_keep isl_map *map);
1052         #include <isl/union_map.h>
1053         __isl_give isl_space *isl_union_map_get_space(
1054                 __isl_keep isl_union_map *umap);
1056         #include <isl/constraint.h>
1057         __isl_give isl_space *isl_constraint_get_space(
1058                 __isl_keep isl_constraint *constraint);
1060         #include <isl/polynomial.h>
1061         __isl_give isl_space *isl_qpolynomial_get_domain_space(
1062                 __isl_keep isl_qpolynomial *qp);
1063         __isl_give isl_space *isl_qpolynomial_get_space(
1064                 __isl_keep isl_qpolynomial *qp);
1065         __isl_give isl_space *
1066         isl_qpolynomial_fold_get_domain_space(
1067                 __isl_keep isl_qpolynomial_fold *fold);
1068         __isl_give isl_space *isl_qpolynomial_fold_get_space(
1069                 __isl_keep isl_qpolynomial_fold *fold);
1070         __isl_give isl_space *isl_pw_qpolynomial_get_domain_space(
1071                 __isl_keep isl_pw_qpolynomial *pwqp);
1072         __isl_give isl_space *isl_pw_qpolynomial_get_space(
1073                 __isl_keep isl_pw_qpolynomial *pwqp);
1074         __isl_give isl_space *isl_pw_qpolynomial_fold_get_domain_space(
1075                 __isl_keep isl_pw_qpolynomial_fold *pwf);
1076         __isl_give isl_space *isl_pw_qpolynomial_fold_get_space(
1077                 __isl_keep isl_pw_qpolynomial_fold *pwf);
1078         __isl_give isl_space *isl_union_pw_qpolynomial_get_space(
1079                 __isl_keep isl_union_pw_qpolynomial *upwqp);
1080         __isl_give isl_space *isl_union_pw_qpolynomial_fold_get_space(
1081                 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
1083         #include <isl/val.h>
1084         __isl_give isl_space *isl_multi_val_get_space(
1085                 __isl_keep isl_multi_val *mv);
1087         #include <isl/aff.h>
1088         __isl_give isl_space *isl_aff_get_domain_space(
1089                 __isl_keep isl_aff *aff);
1090         __isl_give isl_space *isl_aff_get_space(
1091                 __isl_keep isl_aff *aff);
1092         __isl_give isl_space *isl_pw_aff_get_domain_space(
1093                 __isl_keep isl_pw_aff *pwaff);
1094         __isl_give isl_space *isl_pw_aff_get_space(
1095                 __isl_keep isl_pw_aff *pwaff);
1096         __isl_give isl_space *isl_multi_aff_get_domain_space(
1097                 __isl_keep isl_multi_aff *maff);
1098         __isl_give isl_space *isl_multi_aff_get_space(
1099                 __isl_keep isl_multi_aff *maff);
1100         __isl_give isl_space *isl_pw_multi_aff_get_domain_space(
1101                 __isl_keep isl_pw_multi_aff *pma);
1102         __isl_give isl_space *isl_pw_multi_aff_get_space(
1103                 __isl_keep isl_pw_multi_aff *pma);
1104         __isl_give isl_space *isl_union_pw_aff_get_space(
1105                 __isl_keep isl_union_pw_aff *upa);
1106         __isl_give isl_space *isl_union_pw_multi_aff_get_space(
1107                 __isl_keep isl_union_pw_multi_aff *upma);
1108         __isl_give isl_space *isl_multi_pw_aff_get_domain_space(
1109                 __isl_keep isl_multi_pw_aff *mpa);
1110         __isl_give isl_space *isl_multi_pw_aff_get_space(
1111                 __isl_keep isl_multi_pw_aff *mpa);
1112         __isl_give isl_space *
1113         isl_multi_union_pw_aff_get_domain_space(
1114                 __isl_keep isl_multi_union_pw_aff *mupa);
1115         __isl_give isl_space *
1116         isl_multi_union_pw_aff_get_space(
1117                 __isl_keep isl_multi_union_pw_aff *mupa);
1119         #include <isl/point.h>
1120         __isl_give isl_space *isl_point_get_space(
1121                 __isl_keep isl_point *pnt);
1123         #include <isl/fixed_box.h>
1124         __isl_give isl_space *isl_fixed_box_get_space(
1125                 __isl_keep isl_fixed_box *box);
1127 The number of dimensions of a given type of space
1128 may be read off from a space or an object that lives
1129 in a space using the following functions.
1130 In case of C<isl_space_dim>, type may be
1131 C<isl_dim_param>, C<isl_dim_in> (only for relations),
1132 C<isl_dim_out> (only for relations), C<isl_dim_set>
1133 (only for sets) or C<isl_dim_all>.
1135         #include <isl/space.h>
1136         unsigned isl_space_dim(__isl_keep isl_space *space,
1137                 enum isl_dim_type type);
1139         #include <isl/local_space.h>
1140         int isl_local_space_dim(__isl_keep isl_local_space *ls,
1141                 enum isl_dim_type type);
1143         #include <isl/set.h>
1144         unsigned isl_basic_set_dim(__isl_keep isl_basic_set *bset,
1145                 enum isl_dim_type type);
1146         unsigned isl_set_dim(__isl_keep isl_set *set,
1147                 enum isl_dim_type type);
1149         #include <isl/union_set.h>
1150         unsigned isl_union_set_dim(__isl_keep isl_union_set *uset,
1151                 enum isl_dim_type type);
1153         #include <isl/map.h>
1154         unsigned isl_basic_map_dim(__isl_keep isl_basic_map *bmap,
1155                 enum isl_dim_type type);
1156         unsigned isl_map_dim(__isl_keep isl_map *map,
1157                 enum isl_dim_type type);
1159         #include <isl/union_map.h>
1160         unsigned isl_union_map_dim(__isl_keep isl_union_map *umap,
1161                 enum isl_dim_type type);
1163         #include <isl/val.h>
1164         unsigned isl_multi_val_dim(__isl_keep isl_multi_val *mv,
1165                 enum isl_dim_type type);
1167         #include <isl/aff.h>
1168         int isl_aff_dim(__isl_keep isl_aff *aff,
1169                 enum isl_dim_type type);
1170         unsigned isl_multi_aff_dim(__isl_keep isl_multi_aff *maff,
1171                 enum isl_dim_type type);
1172         unsigned isl_pw_aff_dim(__isl_keep isl_pw_aff *pwaff,
1173                 enum isl_dim_type type);
1174         unsigned isl_pw_multi_aff_dim(
1175                 __isl_keep isl_pw_multi_aff *pma,
1176                 enum isl_dim_type type);
1177         unsigned isl_multi_pw_aff_dim(
1178                 __isl_keep isl_multi_pw_aff *mpa,
1179                 enum isl_dim_type type);
1180         unsigned isl_union_pw_aff_dim(
1181                 __isl_keep isl_union_pw_aff *upa,
1182                 enum isl_dim_type type);
1183         unsigned isl_union_pw_multi_aff_dim(
1184                 __isl_keep isl_union_pw_multi_aff *upma,
1185                 enum isl_dim_type type);
1186         unsigned isl_multi_union_pw_aff_dim(
1187                 __isl_keep isl_multi_union_pw_aff *mupa,
1188                 enum isl_dim_type type);
1190         #include <isl/polynomial.h>
1191         unsigned isl_union_pw_qpolynomial_dim(
1192                 __isl_keep isl_union_pw_qpolynomial *upwqp,
1193                 enum isl_dim_type type);
1194         unsigned isl_union_pw_qpolynomial_fold_dim(
1195                 __isl_keep isl_union_pw_qpolynomial_fold *upwf,
1196                 enum isl_dim_type type);
1198 Note that an C<isl_union_set>, an C<isl_union_map>,
1199 an C<isl_union_pw_multi_aff>,
1200 an C<isl_union_pw_qpolynomial> and
1201 an C<isl_union_pw_qpolynomial_fold>
1202 only have parameters.
1204 Additional parameters can be added to a space using the following function.
1206         #include <isl/space.h>
1207         __isl_give isl_space *isl_space_add_param_id(
1208                 __isl_take isl_space *space,
1209                 __isl_take isl_id *id);
1211 If a parameter with the given identifier already appears in the space,
1212 then it is not added again.
1214 The identifiers or names of the individual dimensions of spaces
1215 may be set or read off using the following functions on spaces
1216 or objects that live in spaces.
1217 These functions are mostly useful to obtain the identifiers, positions
1218 or names of the parameters.  Identifiers of individual dimensions are
1219 essentially only useful for printing.  They are ignored by all other
1220 operations and may not be preserved across those operations.
1222         #include <isl/space.h>
1223         __isl_give isl_space *isl_space_set_dim_id(
1224                 __isl_take isl_space *space,
1225                 enum isl_dim_type type, unsigned pos,
1226                 __isl_take isl_id *id);
1227         isl_bool isl_space_has_dim_id(__isl_keep isl_space *space,
1228                 enum isl_dim_type type, unsigned pos);
1229         __isl_give isl_id *isl_space_get_dim_id(
1230                 __isl_keep isl_space *space,
1231                 enum isl_dim_type type, unsigned pos);
1232         __isl_give isl_space *isl_space_set_dim_name(
1233                 __isl_take isl_space *space,
1234                  enum isl_dim_type type, unsigned pos,
1235                  __isl_keep const char *name);
1236         isl_bool isl_space_has_dim_name(__isl_keep isl_space *space,
1237                 enum isl_dim_type type, unsigned pos);
1238         __isl_keep const char *isl_space_get_dim_name(
1239                 __isl_keep isl_space *space,
1240                 enum isl_dim_type type, unsigned pos);
1242         #include <isl/local_space.h>
1243         __isl_give isl_local_space *isl_local_space_set_dim_id(
1244                 __isl_take isl_local_space *ls,
1245                 enum isl_dim_type type, unsigned pos,
1246                 __isl_take isl_id *id);
1247         isl_bool isl_local_space_has_dim_id(
1248                 __isl_keep isl_local_space *ls,
1249                 enum isl_dim_type type, unsigned pos);
1250         __isl_give isl_id *isl_local_space_get_dim_id(
1251                 __isl_keep isl_local_space *ls,
1252                 enum isl_dim_type type, unsigned pos);
1253         __isl_give isl_local_space *isl_local_space_set_dim_name(
1254                 __isl_take isl_local_space *ls,
1255                 enum isl_dim_type type, unsigned pos, const char *s);
1256         isl_bool isl_local_space_has_dim_name(
1257                 __isl_keep isl_local_space *ls,
1258                 enum isl_dim_type type, unsigned pos)
1259         const char *isl_local_space_get_dim_name(
1260                 __isl_keep isl_local_space *ls,
1261                 enum isl_dim_type type, unsigned pos);
1263         #include <isl/constraint.h>
1264         const char *isl_constraint_get_dim_name(
1265                 __isl_keep isl_constraint *constraint,
1266                 enum isl_dim_type type, unsigned pos);
1268         #include <isl/set.h>
1269         __isl_give isl_id *isl_basic_set_get_dim_id(
1270                 __isl_keep isl_basic_set *bset,
1271                 enum isl_dim_type type, unsigned pos);
1272         __isl_give isl_set *isl_set_set_dim_id(
1273                 __isl_take isl_set *set, enum isl_dim_type type,
1274                 unsigned pos, __isl_take isl_id *id);
1275         isl_bool isl_set_has_dim_id(__isl_keep isl_set *set,
1276                 enum isl_dim_type type, unsigned pos);
1277         __isl_give isl_id *isl_set_get_dim_id(
1278                 __isl_keep isl_set *set, enum isl_dim_type type,
1279                 unsigned pos);
1280         const char *isl_basic_set_get_dim_name(
1281                 __isl_keep isl_basic_set *bset,
1282                 enum isl_dim_type type, unsigned pos);
1283         isl_bool isl_set_has_dim_name(__isl_keep isl_set *set,
1284                 enum isl_dim_type type, unsigned pos);
1285         const char *isl_set_get_dim_name(
1286                 __isl_keep isl_set *set,
1287                 enum isl_dim_type type, unsigned pos);
1289         #include <isl/map.h>
1290         __isl_give isl_map *isl_map_set_dim_id(
1291                 __isl_take isl_map *map, enum isl_dim_type type,
1292                 unsigned pos, __isl_take isl_id *id);
1293         isl_bool isl_basic_map_has_dim_id(
1294                 __isl_keep isl_basic_map *bmap,
1295                 enum isl_dim_type type, unsigned pos);
1296         isl_bool isl_map_has_dim_id(__isl_keep isl_map *map,
1297                 enum isl_dim_type type, unsigned pos);
1298         __isl_give isl_id *isl_map_get_dim_id(
1299                 __isl_keep isl_map *map, enum isl_dim_type type,
1300                 unsigned pos);
1301         __isl_give isl_id *isl_union_map_get_dim_id(
1302                 __isl_keep isl_union_map *umap,
1303                 enum isl_dim_type type, unsigned pos);
1304         const char *isl_basic_map_get_dim_name(
1305                 __isl_keep isl_basic_map *bmap,
1306                 enum isl_dim_type type, unsigned pos);
1307         isl_bool isl_map_has_dim_name(__isl_keep isl_map *map,
1308                 enum isl_dim_type type, unsigned pos);
1309         const char *isl_map_get_dim_name(
1310                 __isl_keep isl_map *map,
1311                 enum isl_dim_type type, unsigned pos);
1313         #include <isl/val.h>
1314         __isl_give isl_multi_val *isl_multi_val_set_dim_id(
1315                 __isl_take isl_multi_val *mv,
1316                 enum isl_dim_type type, unsigned pos,
1317                 __isl_take isl_id *id);
1318         __isl_give isl_id *isl_multi_val_get_dim_id(
1319                 __isl_keep isl_multi_val *mv,
1320                 enum isl_dim_type type, unsigned pos);
1321         __isl_give isl_multi_val *isl_multi_val_set_dim_name(
1322                 __isl_take isl_multi_val *mv,
1323                 enum isl_dim_type type, unsigned pos, const char *s);
1325         #include <isl/aff.h>
1326         __isl_give isl_aff *isl_aff_set_dim_id(
1327                 __isl_take isl_aff *aff, enum isl_dim_type type,
1328                 unsigned pos, __isl_take isl_id *id);
1329         __isl_give isl_multi_aff *isl_multi_aff_set_dim_id(
1330                 __isl_take isl_multi_aff *maff,
1331                 enum isl_dim_type type, unsigned pos,
1332                 __isl_take isl_id *id);
1333         __isl_give isl_pw_aff *isl_pw_aff_set_dim_id(
1334                 __isl_take isl_pw_aff *pma,
1335                 enum isl_dim_type type, unsigned pos,
1336                 __isl_take isl_id *id);
1337         __isl_give isl_multi_pw_aff *
1338         isl_multi_pw_aff_set_dim_id(
1339                 __isl_take isl_multi_pw_aff *mpa,
1340                 enum isl_dim_type type, unsigned pos,
1341                 __isl_take isl_id *id);
1342         __isl_give isl_multi_union_pw_aff *
1343         isl_multi_union_pw_aff_set_dim_id(
1344                 __isl_take isl_multi_union_pw_aff *mupa,
1345                 enum isl_dim_type type, unsigned pos,
1346                 __isl_take isl_id *id);
1347         __isl_give isl_id *isl_multi_aff_get_dim_id(
1348                 __isl_keep isl_multi_aff *ma,
1349                 enum isl_dim_type type, unsigned pos);
1350         isl_bool isl_pw_aff_has_dim_id(__isl_keep isl_pw_aff *pa,
1351                 enum isl_dim_type type, unsigned pos);
1352         __isl_give isl_id *isl_pw_aff_get_dim_id(
1353                 __isl_keep isl_pw_aff *pa,
1354                 enum isl_dim_type type, unsigned pos);
1355         __isl_give isl_id *isl_pw_multi_aff_get_dim_id(
1356                 __isl_keep isl_pw_multi_aff *pma,
1357                 enum isl_dim_type type, unsigned pos);
1358         __isl_give isl_id *isl_multi_pw_aff_get_dim_id(
1359                 __isl_keep isl_multi_pw_aff *mpa,
1360                 enum isl_dim_type type, unsigned pos);
1361         __isl_give isl_id *isl_multi_union_pw_aff_get_dim_id(
1362                 __isl_keep isl_multi_union_pw_aff *mupa,
1363                 enum isl_dim_type type, unsigned pos);
1364         __isl_give isl_aff *isl_aff_set_dim_name(
1365                 __isl_take isl_aff *aff, enum isl_dim_type type,
1366                 unsigned pos, const char *s);
1367         __isl_give isl_multi_aff *isl_multi_aff_set_dim_name(
1368                 __isl_take isl_multi_aff *maff,
1369                 enum isl_dim_type type, unsigned pos, const char *s);
1370         __isl_give isl_multi_pw_aff *
1371         isl_multi_pw_aff_set_dim_name(
1372                 __isl_take isl_multi_pw_aff *mpa,
1373                 enum isl_dim_type type, unsigned pos, const char *s);
1374         __isl_give isl_union_pw_aff *
1375         isl_union_pw_aff_set_dim_name(
1376                 __isl_take isl_union_pw_aff *upa,
1377                 enum isl_dim_type type, unsigned pos,
1378                 const char *s);
1379         __isl_give isl_union_pw_multi_aff *
1380         isl_union_pw_multi_aff_set_dim_name(
1381                 __isl_take isl_union_pw_multi_aff *upma,
1382                 enum isl_dim_type type, unsigned pos,
1383                 const char *s);
1384         __isl_give isl_multi_union_pw_aff *
1385         isl_multi_union_pw_aff_set_dim_name(
1386                 __isl_take isl_multi_union_pw_aff *mupa,
1387                 enum isl_dim_type type, unsigned pos,
1388         const char *isl_aff_get_dim_name(__isl_keep isl_aff *aff,
1389                 enum isl_dim_type type, unsigned pos);
1390         const char *isl_pw_aff_get_dim_name(
1391                 __isl_keep isl_pw_aff *pa,
1392                 enum isl_dim_type type, unsigned pos);
1393         const char *isl_pw_multi_aff_get_dim_name(
1394                 __isl_keep isl_pw_multi_aff *pma,
1395                 enum isl_dim_type type, unsigned pos);
1397         #include <isl/polynomial.h>
1398         __isl_give isl_qpolynomial *isl_qpolynomial_set_dim_name(
1399                 __isl_take isl_qpolynomial *qp,
1400                 enum isl_dim_type type, unsigned pos,
1401                 const char *s);
1402         __isl_give isl_pw_qpolynomial *
1403         isl_pw_qpolynomial_set_dim_name(
1404                 __isl_take isl_pw_qpolynomial *pwqp,
1405                 enum isl_dim_type type, unsigned pos,
1406                 const char *s);
1407         __isl_give isl_pw_qpolynomial_fold *
1408         isl_pw_qpolynomial_fold_set_dim_name(
1409                 __isl_take isl_pw_qpolynomial_fold *pwf,
1410                 enum isl_dim_type type, unsigned pos,
1411                 const char *s);
1412         __isl_give isl_union_pw_qpolynomial *
1413         isl_union_pw_qpolynomial_set_dim_name(
1414                 __isl_take isl_union_pw_qpolynomial *upwqp,
1415                 enum isl_dim_type type, unsigned pos,
1416                 const char *s);
1417         __isl_give isl_union_pw_qpolynomial_fold *
1418         isl_union_pw_qpolynomial_fold_set_dim_name(
1419                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
1420                 enum isl_dim_type type, unsigned pos,
1421                 const char *s);
1423 Note that C<isl_space_get_name> returns a pointer to some internal
1424 data structure, so the result can only be used while the
1425 corresponding C<isl_space> is alive.
1426 Also note that every function that operates on two sets or relations
1427 requires that both arguments have the same parameters.  This also
1428 means that if one of the arguments has named parameters, then the
1429 other needs to have named parameters too and the names need to match.
1430 Pairs of C<isl_set>, C<isl_map>, C<isl_union_set> and/or C<isl_union_map>
1431 arguments may have different parameters (as long as they are named),
1432 in which case the result will have as parameters the union of the parameters of
1433 the arguments.
1435 Given the identifier or name of a dimension (typically a parameter),
1436 its position can be obtained from the following functions.
1438         #include <isl/space.h>
1439         int isl_space_find_dim_by_id(__isl_keep isl_space *space,
1440                 enum isl_dim_type type, __isl_keep isl_id *id);
1441         int isl_space_find_dim_by_name(__isl_keep isl_space *space,
1442                 enum isl_dim_type type, const char *name);
1444         #include <isl/local_space.h>
1445         int isl_local_space_find_dim_by_name(
1446                 __isl_keep isl_local_space *ls,
1447                 enum isl_dim_type type, const char *name);
1449         #include <isl/val.h>
1450         int isl_multi_val_find_dim_by_id(
1451                 __isl_keep isl_multi_val *mv,
1452                 enum isl_dim_type type, __isl_keep isl_id *id);
1453         int isl_multi_val_find_dim_by_name(
1454                 __isl_keep isl_multi_val *mv,
1455                 enum isl_dim_type type, const char *name);
1457         #include <isl/set.h>
1458         int isl_set_find_dim_by_id(__isl_keep isl_set *set,
1459                 enum isl_dim_type type, __isl_keep isl_id *id);
1460         int isl_set_find_dim_by_name(__isl_keep isl_set *set,
1461                 enum isl_dim_type type, const char *name);
1463         #include <isl/map.h>
1464         int isl_map_find_dim_by_id(__isl_keep isl_map *map,
1465                 enum isl_dim_type type, __isl_keep isl_id *id);
1466         int isl_basic_map_find_dim_by_name(
1467                 __isl_keep isl_basic_map *bmap,
1468                 enum isl_dim_type type, const char *name);
1469         int isl_map_find_dim_by_name(__isl_keep isl_map *map,
1470                 enum isl_dim_type type, const char *name);
1471         int isl_union_map_find_dim_by_name(
1472                 __isl_keep isl_union_map *umap,
1473                 enum isl_dim_type type, const char *name);
1475         #include <isl/aff.h>
1476         int isl_multi_aff_find_dim_by_id(
1477                 __isl_keep isl_multi_aff *ma,
1478                 enum isl_dim_type type, __isl_keep isl_id *id);
1479         int isl_multi_pw_aff_find_dim_by_id(
1480                 __isl_keep isl_multi_pw_aff *mpa,
1481                 enum isl_dim_type type, __isl_keep isl_id *id);
1482         int isl_multi_union_pw_aff_find_dim_by_id(
1483                 __isl_keep isl_union_multi_pw_aff *mupa,
1484                 enum isl_dim_type type, __isl_keep isl_id *id);
1485         int isl_aff_find_dim_by_name(__isl_keep isl_aff *aff,
1486                 enum isl_dim_type type, const char *name);
1487         int isl_multi_aff_find_dim_by_name(
1488                 __isl_keep isl_multi_aff *ma,
1489                 enum isl_dim_type type, const char *name);
1490         int isl_pw_aff_find_dim_by_name(__isl_keep isl_pw_aff *pa,
1491                 enum isl_dim_type type, const char *name);
1492         int isl_multi_pw_aff_find_dim_by_name(
1493                 __isl_keep isl_multi_pw_aff *mpa,
1494                 enum isl_dim_type type, const char *name);
1495         int isl_pw_multi_aff_find_dim_by_name(
1496                 __isl_keep isl_pw_multi_aff *pma,
1497                 enum isl_dim_type type, const char *name);
1498         int isl_union_pw_aff_find_dim_by_name(
1499                 __isl_keep isl_union_pw_aff *upa,
1500                 enum isl_dim_type type, const char *name);
1501         int isl_union_pw_multi_aff_find_dim_by_name(
1502                 __isl_keep isl_union_pw_multi_aff *upma,
1503                 enum isl_dim_type type, const char *name);
1504         int isl_multi_union_pw_aff_find_dim_by_name(
1505                 __isl_keep isl_multi_union_pw_aff *mupa,
1506                 enum isl_dim_type type, const char *name);
1508         #include <isl/polynomial.h>
1509         int isl_pw_qpolynomial_find_dim_by_name(
1510                 __isl_keep isl_pw_qpolynomial *pwqp,
1511                 enum isl_dim_type type, const char *name);
1512         int isl_pw_qpolynomial_fold_find_dim_by_name(
1513                 __isl_keep isl_pw_qpolynomial_fold *pwf,
1514                 enum isl_dim_type type, const char *name);
1515         int isl_union_pw_qpolynomial_find_dim_by_name(
1516                 __isl_keep isl_union_pw_qpolynomial *upwqp,
1517                 enum isl_dim_type type, const char *name);
1518         int isl_union_pw_qpolynomial_fold_find_dim_by_name(
1519                 __isl_keep isl_union_pw_qpolynomial_fold *upwf,
1520                 enum isl_dim_type type, const char *name);
1522 The identifiers or names of entire spaces may be set or read off
1523 using the following functions.
1525         #include <isl/space.h>
1526         __isl_give isl_space *isl_space_set_tuple_id(
1527                 __isl_take isl_space *space,
1528                 enum isl_dim_type type, __isl_take isl_id *id);
1529         __isl_give isl_space *isl_space_reset_tuple_id(
1530                 __isl_take isl_space *space, enum isl_dim_type type);
1531         isl_bool isl_space_has_tuple_id(
1532                 __isl_keep isl_space *space,
1533                 enum isl_dim_type type);
1534         __isl_give isl_id *isl_space_get_tuple_id(
1535                 __isl_keep isl_space *space, enum isl_dim_type type);
1536         __isl_give isl_space *isl_space_set_tuple_name(
1537                 __isl_take isl_space *space,
1538                 enum isl_dim_type type, const char *s);
1539         isl_bool isl_space_has_tuple_name(
1540                 __isl_keep isl_space *space,
1541                 enum isl_dim_type type);
1542         __isl_keep const char *isl_space_get_tuple_name(
1543                 __isl_keep isl_space *space,
1544                 enum isl_dim_type type);
1546         #include <isl/local_space.h>
1547         __isl_give isl_local_space *isl_local_space_set_tuple_id(
1548                 __isl_take isl_local_space *ls,
1549                 enum isl_dim_type type, __isl_take isl_id *id);
1551         #include <isl/set.h>
1552         __isl_give isl_basic_set *isl_basic_set_set_tuple_id(
1553                 __isl_take isl_basic_set *bset,
1554                 __isl_take isl_id *id);
1555         __isl_give isl_set *isl_set_set_tuple_id(
1556                 __isl_take isl_set *set, __isl_take isl_id *id);
1557         __isl_give isl_set *isl_set_reset_tuple_id(
1558                 __isl_take isl_set *set);
1559         isl_bool isl_set_has_tuple_id(__isl_keep isl_set *set);
1560         __isl_give isl_id *isl_set_get_tuple_id(
1561                 __isl_keep isl_set *set);
1562         __isl_give isl_basic_set *isl_basic_set_set_tuple_name(
1563                 __isl_take isl_basic_set *set, const char *s);
1564         __isl_give isl_set *isl_set_set_tuple_name(
1565                 __isl_take isl_set *set, const char *s);
1566         const char *isl_basic_set_get_tuple_name(
1567                 __isl_keep isl_basic_set *bset);
1568         isl_bool isl_set_has_tuple_name(__isl_keep isl_set *set);
1569         const char *isl_set_get_tuple_name(
1570                 __isl_keep isl_set *set);
1572         #include <isl/map.h>
1573         __isl_give isl_basic_map *isl_basic_map_set_tuple_id(
1574                 __isl_take isl_basic_map *bmap,
1575                 enum isl_dim_type type, __isl_take isl_id *id);
1576         __isl_give isl_map *isl_map_set_tuple_id(
1577                 __isl_take isl_map *map, enum isl_dim_type type,
1578                 __isl_take isl_id *id);
1579         __isl_give isl_map *isl_map_reset_tuple_id(
1580                 __isl_take isl_map *map, enum isl_dim_type type);
1581         isl_bool isl_map_has_tuple_id(__isl_keep isl_map *map,
1582                 enum isl_dim_type type);
1583         __isl_give isl_id *isl_map_get_tuple_id(
1584                 __isl_keep isl_map *map, enum isl_dim_type type);
1585         __isl_give isl_map *isl_map_set_tuple_name(
1586                 __isl_take isl_map *map,
1587                 enum isl_dim_type type, const char *s);
1588         const char *isl_basic_map_get_tuple_name(
1589                 __isl_keep isl_basic_map *bmap,
1590                 enum isl_dim_type type);
1591         __isl_give isl_basic_map *isl_basic_map_set_tuple_name(
1592                 __isl_take isl_basic_map *bmap,
1593                 enum isl_dim_type type, const char *s);
1594         isl_bool isl_map_has_tuple_name(__isl_keep isl_map *map,
1595                 enum isl_dim_type type);
1596         const char *isl_map_get_tuple_name(
1597                 __isl_keep isl_map *map,
1598                 enum isl_dim_type type);
1600         #include <isl/val.h>
1601         __isl_give isl_multi_val *isl_multi_val_set_tuple_id(
1602                 __isl_take isl_multi_val *mv,
1603                 enum isl_dim_type type, __isl_take isl_id *id);
1604         __isl_give isl_multi_val *isl_multi_val_reset_tuple_id(
1605                 __isl_take isl_multi_val *mv,
1606                 enum isl_dim_type type);
1607         isl_bool isl_multi_val_has_tuple_id(
1608                 __isl_keep isl_multi_val *mv,
1609                 enum isl_dim_type type);
1610         __isl_give isl_id *isl_multi_val_get_tuple_id(
1611                 __isl_keep isl_multi_val *mv,
1612                 enum isl_dim_type type);
1613         __isl_give isl_multi_val *isl_multi_val_set_tuple_name(
1614                 __isl_take isl_multi_val *mv,
1615                 enum isl_dim_type type, const char *s);
1616         const char *isl_multi_val_get_tuple_name(
1617                 __isl_keep isl_multi_val *mv,
1618                 enum isl_dim_type type);
1620         #include <isl/aff.h>
1621         __isl_give isl_aff *isl_aff_set_tuple_id(
1622                 __isl_take isl_aff *aff,
1623                 enum isl_dim_type type, __isl_take isl_id *id);
1624         __isl_give isl_multi_aff *isl_multi_aff_set_tuple_id(
1625                 __isl_take isl_multi_aff *maff,
1626                 enum isl_dim_type type, __isl_take isl_id *id);
1627         __isl_give isl_pw_aff *isl_pw_aff_set_tuple_id(
1628                 __isl_take isl_pw_aff *pwaff,
1629                 enum isl_dim_type type, __isl_take isl_id *id);
1630         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_tuple_id(
1631                 __isl_take isl_pw_multi_aff *pma,
1632                 enum isl_dim_type type, __isl_take isl_id *id);
1633         __isl_give isl_multi_union_pw_aff *
1634         isl_multi_union_pw_aff_set_tuple_id(
1635                 __isl_take isl_multi_union_pw_aff *mupa,
1636                 enum isl_dim_type type, __isl_take isl_id *id);
1637         __isl_give isl_multi_aff *isl_multi_aff_reset_tuple_id(
1638                 __isl_take isl_multi_aff *ma,
1639                 enum isl_dim_type type);
1640         __isl_give isl_pw_aff *isl_pw_aff_reset_tuple_id(
1641                 __isl_take isl_pw_aff *pa,
1642                 enum isl_dim_type type);
1643         __isl_give isl_multi_pw_aff *
1644         isl_multi_pw_aff_reset_tuple_id(
1645                 __isl_take isl_multi_pw_aff *mpa,
1646                 enum isl_dim_type type);
1647         __isl_give isl_pw_multi_aff *
1648         isl_pw_multi_aff_reset_tuple_id(
1649                 __isl_take isl_pw_multi_aff *pma,
1650                 enum isl_dim_type type);
1651         __isl_give isl_multi_union_pw_aff *
1652         isl_multi_union_pw_aff_reset_tuple_id(
1653                 __isl_take isl_multi_union_pw_aff *mupa,
1654                 enum isl_dim_type type);
1655         isl_bool isl_multi_aff_has_tuple_id(
1656                 __isl_keep isl_multi_aff *ma,
1657                 enum isl_dim_type type);
1658         __isl_give isl_id *isl_multi_aff_get_tuple_id(
1659                 __isl_keep isl_multi_aff *ma,
1660                 enum isl_dim_type type);
1661         isl_bool isl_pw_aff_has_tuple_id(__isl_keep isl_pw_aff *pa,
1662                 enum isl_dim_type type);
1663         __isl_give isl_id *isl_pw_aff_get_tuple_id(
1664                 __isl_keep isl_pw_aff *pa,
1665                 enum isl_dim_type type);
1666         isl_bool isl_pw_multi_aff_has_tuple_id(
1667                 __isl_keep isl_pw_multi_aff *pma,
1668                 enum isl_dim_type type);
1669         __isl_give isl_id *isl_pw_multi_aff_get_tuple_id(
1670                 __isl_keep isl_pw_multi_aff *pma,
1671                 enum isl_dim_type type);
1672         isl_bool isl_multi_pw_aff_has_tuple_id(
1673                 __isl_keep isl_multi_pw_aff *mpa,
1674                 enum isl_dim_type type);
1675         __isl_give isl_id *isl_multi_pw_aff_get_tuple_id(
1676                 __isl_keep isl_multi_pw_aff *mpa,
1677                 enum isl_dim_type type);
1678         isl_bool isl_multi_union_pw_aff_has_tuple_id(
1679                 __isl_keep isl_multi_union_pw_aff *mupa,
1680                 enum isl_dim_type type);
1681         __isl_give isl_id *isl_multi_union_pw_aff_get_tuple_id(
1682                 __isl_keep isl_multi_union_pw_aff *mupa,
1683                 enum isl_dim_type type);
1684         __isl_give isl_multi_aff *isl_multi_aff_set_tuple_name(
1685                 __isl_take isl_multi_aff *maff,
1686                 enum isl_dim_type type, const char *s);
1687         __isl_give isl_multi_pw_aff *
1688         isl_multi_pw_aff_set_tuple_name(
1689                 __isl_take isl_multi_pw_aff *mpa,
1690                 enum isl_dim_type type, const char *s);
1691         __isl_give isl_multi_union_pw_aff *
1692         isl_multi_union_pw_aff_set_tuple_name(
1693                 __isl_take isl_multi_union_pw_aff *mupa,
1694                 enum isl_dim_type type, const char *s);
1695         const char *isl_multi_aff_get_tuple_name(
1696                 __isl_keep isl_multi_aff *multi,
1697                 enum isl_dim_type type);
1698         isl_bool isl_pw_multi_aff_has_tuple_name(
1699                 __isl_keep isl_pw_multi_aff *pma,
1700                 enum isl_dim_type type);
1701         const char *isl_pw_multi_aff_get_tuple_name(
1702                 __isl_keep isl_pw_multi_aff *pma,
1703                 enum isl_dim_type type);
1704         const char *isl_multi_union_pw_aff_get_tuple_name(
1705                 __isl_keep isl_multi_union_pw_aff *mupa,
1706                 enum isl_dim_type type);
1708 The C<type> argument needs to be one of C<isl_dim_in>, C<isl_dim_out>
1709 or C<isl_dim_set>.  As with C<isl_space_get_name>,
1710 the C<isl_space_get_tuple_name> function returns a pointer to some internal
1711 data structure.
1712 Binary operations require the corresponding spaces of their arguments
1713 to have the same name.
1715 To keep the names of all parameters and tuples, but reset the user pointers
1716 of all the corresponding identifiers, use the following function.
1718         #include <isl/space.h>
1719         __isl_give isl_space *isl_space_reset_user(
1720                 __isl_take isl_space *space);
1722         #include <isl/set.h>
1723         __isl_give isl_set *isl_set_reset_user(
1724                 __isl_take isl_set *set);
1726         #include <isl/map.h>
1727         __isl_give isl_map *isl_map_reset_user(
1728                 __isl_take isl_map *map);
1730         #include <isl/union_set.h>
1731         __isl_give isl_union_set *isl_union_set_reset_user(
1732                 __isl_take isl_union_set *uset);
1734         #include <isl/union_map.h>
1735         __isl_give isl_union_map *isl_union_map_reset_user(
1736                 __isl_take isl_union_map *umap);
1738         #include <isl/val.h>
1739         __isl_give isl_multi_val *isl_multi_val_reset_user(
1740                 __isl_take isl_multi_val *mv);
1742         #include <isl/aff.h>
1743         __isl_give isl_multi_aff *isl_multi_aff_reset_user(
1744                 __isl_take isl_multi_aff *ma);
1745         __isl_give isl_pw_aff *isl_pw_aff_reset_user(
1746                 __isl_take isl_pw_aff *pa);
1747         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_reset_user(
1748                 __isl_take isl_multi_pw_aff *mpa);
1749         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_reset_user(
1750                 __isl_take isl_pw_multi_aff *pma);
1751         __isl_give isl_union_pw_aff *isl_union_pw_aff_reset_user(
1752                 __isl_take isl_union_pw_aff *upa);
1753         __isl_give isl_multi_union_pw_aff *
1754         isl_multi_union_pw_aff_reset_user(
1755                 __isl_take isl_multi_union_pw_aff *mupa);
1756         __isl_give isl_union_pw_multi_aff *
1757         isl_union_pw_multi_aff_reset_user(
1758                 __isl_take isl_union_pw_multi_aff *upma);
1760         #include <isl/polynomial.h>
1761         __isl_give isl_pw_qpolynomial *
1762         isl_pw_qpolynomial_reset_user(
1763                 __isl_take isl_pw_qpolynomial *pwqp);
1764         __isl_give isl_union_pw_qpolynomial *
1765         isl_union_pw_qpolynomial_reset_user(
1766                 __isl_take isl_union_pw_qpolynomial *upwqp);
1767         __isl_give isl_pw_qpolynomial_fold *
1768         isl_pw_qpolynomial_fold_reset_user(
1769                 __isl_take isl_pw_qpolynomial_fold *pwf);
1770         __isl_give isl_union_pw_qpolynomial_fold *
1771         isl_union_pw_qpolynomial_fold_reset_user(
1772                 __isl_take isl_union_pw_qpolynomial_fold *upwf);
1774 Spaces can be nested.  In particular, the domain of a set or
1775 the domain or range of a relation can be a nested relation.
1776 This process is also called I<wrapping>.
1777 The functions for detecting, constructing and deconstructing
1778 such nested spaces can be found in the wrapping properties
1779 of L</"Unary Properties">, the wrapping operations
1780 of L</"Unary Operations"> and the Cartesian product operations
1781 of L</"Basic Operations">.
1783 Spaces can be created from other spaces
1784 using the functions described in L</"Unary Operations">
1785 and L</"Binary Operations">.
1787 =head2 Local Spaces
1789 A local space is essentially a space with
1790 zero or more existentially quantified variables.
1791 The local space of various objects can be obtained
1792 using the following functions.
1794         #include <isl/constraint.h>
1795         __isl_give isl_local_space *isl_constraint_get_local_space(
1796                 __isl_keep isl_constraint *constraint);
1798         #include <isl/set.h>
1799         __isl_give isl_local_space *isl_basic_set_get_local_space(
1800                 __isl_keep isl_basic_set *bset);
1802         #include <isl/map.h>
1803         __isl_give isl_local_space *isl_basic_map_get_local_space(
1804                 __isl_keep isl_basic_map *bmap);
1806         #include <isl/aff.h>
1807         __isl_give isl_local_space *isl_aff_get_domain_local_space(
1808                 __isl_keep isl_aff *aff);
1809         __isl_give isl_local_space *isl_aff_get_local_space(
1810                 __isl_keep isl_aff *aff);
1812 A new local space can be created from a space using
1814         #include <isl/local_space.h>
1815         __isl_give isl_local_space *isl_local_space_from_space(
1816                 __isl_take isl_space *space);
1818 They can be inspected, modified, copied and freed using the following functions.
1820         #include <isl/local_space.h>
1821         isl_bool isl_local_space_is_params(
1822                 __isl_keep isl_local_space *ls);
1823         isl_bool isl_local_space_is_set(
1824                 __isl_keep isl_local_space *ls);
1825         __isl_give isl_space *isl_local_space_get_space(
1826                 __isl_keep isl_local_space *ls);
1827         __isl_give isl_aff *isl_local_space_get_div(
1828                 __isl_keep isl_local_space *ls, int pos);
1829         __isl_give isl_local_space *isl_local_space_copy(
1830                 __isl_keep isl_local_space *ls);
1831         __isl_null isl_local_space *isl_local_space_free(
1832                 __isl_take isl_local_space *ls);
1834 Note that C<isl_local_space_get_div> can only be used on local spaces
1835 of sets.
1837 Two local spaces can be compared using
1839         isl_bool isl_local_space_is_equal(
1840                 __isl_keep isl_local_space *ls1,
1841                 __isl_keep isl_local_space *ls2);
1843 Local spaces can be created from other local spaces
1844 using the functions described in L</"Unary Operations">
1845 and L</"Binary Operations">.
1847 =head2 Creating New Sets and Relations
1849 C<isl> has functions for creating some standard sets and relations.
1851 =over
1853 =item * Empty sets and relations
1855         __isl_give isl_basic_set *isl_basic_set_empty(
1856                 __isl_take isl_space *space);
1857         __isl_give isl_basic_map *isl_basic_map_empty(
1858                 __isl_take isl_space *space);
1859         __isl_give isl_set *isl_set_empty(
1860                 __isl_take isl_space *space);
1861         __isl_give isl_map *isl_map_empty(
1862                 __isl_take isl_space *space);
1863         __isl_give isl_union_set *isl_union_set_empty(
1864                 __isl_take isl_space *space);
1865         __isl_give isl_union_map *isl_union_map_empty(
1866                 __isl_take isl_space *space);
1868 For C<isl_union_set>s and C<isl_union_map>s, the space
1869 is only used to specify the parameters.
1871 =item * Universe sets and relations
1873         __isl_give isl_basic_set *isl_basic_set_universe(
1874                 __isl_take isl_space *space);
1875         __isl_give isl_basic_map *isl_basic_map_universe(
1876                 __isl_take isl_space *space);
1877         __isl_give isl_set *isl_set_universe(
1878                 __isl_take isl_space *space);
1879         __isl_give isl_map *isl_map_universe(
1880                 __isl_take isl_space *space);
1881         __isl_give isl_union_set *isl_union_set_universe(
1882                 __isl_take isl_union_set *uset);
1883         __isl_give isl_union_map *isl_union_map_universe(
1884                 __isl_take isl_union_map *umap);
1886 The sets and relations constructed by the functions above
1887 contain all integer values, while those constructed by the
1888 functions below only contain non-negative values.
1890         __isl_give isl_basic_set *isl_basic_set_nat_universe(
1891                 __isl_take isl_space *space);
1892         __isl_give isl_basic_map *isl_basic_map_nat_universe(
1893                 __isl_take isl_space *space);
1894         __isl_give isl_set *isl_set_nat_universe(
1895                 __isl_take isl_space *space);
1896         __isl_give isl_map *isl_map_nat_universe(
1897                 __isl_take isl_space *space);
1899 =item * Identity relations
1901         __isl_give isl_basic_map *isl_basic_map_identity(
1902                 __isl_take isl_space *space);
1903         __isl_give isl_map *isl_map_identity(
1904                 __isl_take isl_space *space);
1906 The number of input and output dimensions in C<space> needs
1907 to be the same.
1909 =item * Lexicographic order
1911         __isl_give isl_map *isl_map_lex_lt(
1912                 __isl_take isl_space *set_space);
1913         __isl_give isl_map *isl_map_lex_le(
1914                 __isl_take isl_space *set_space);
1915         __isl_give isl_map *isl_map_lex_gt(
1916                 __isl_take isl_space *set_space);
1917         __isl_give isl_map *isl_map_lex_ge(
1918                 __isl_take isl_space *set_space);
1919         __isl_give isl_map *isl_map_lex_lt_first(
1920                 __isl_take isl_space *space, unsigned n);
1921         __isl_give isl_map *isl_map_lex_le_first(
1922                 __isl_take isl_space *space, unsigned n);
1923         __isl_give isl_map *isl_map_lex_gt_first(
1924                 __isl_take isl_space *space, unsigned n);
1925         __isl_give isl_map *isl_map_lex_ge_first(
1926                 __isl_take isl_space *space, unsigned n);
1928 The first four functions take a space for a B<set>
1929 and return relations that express that the elements in the domain
1930 are lexicographically less
1931 (C<isl_map_lex_lt>), less or equal (C<isl_map_lex_le>),
1932 greater (C<isl_map_lex_gt>) or greater or equal (C<isl_map_lex_ge>)
1933 than the elements in the range.
1934 The last four functions take a space for a map
1935 and return relations that express that the first C<n> dimensions
1936 in the domain are lexicographically less
1937 (C<isl_map_lex_lt_first>), less or equal (C<isl_map_lex_le_first>),
1938 greater (C<isl_map_lex_gt_first>) or greater or equal (C<isl_map_lex_ge_first>)
1939 than the first C<n> dimensions in the range.
1941 =back
1943 A basic set or relation can be converted to a set or relation
1944 using the following functions.
1946         __isl_give isl_set *isl_set_from_basic_set(
1947                 __isl_take isl_basic_set *bset);
1948         __isl_give isl_map *isl_map_from_basic_map(
1949                 __isl_take isl_basic_map *bmap);
1951 Sets and relations can be converted to union sets and relations
1952 using the following functions.
1954         __isl_give isl_union_set *isl_union_set_from_basic_set(
1955                 __isl_take isl_basic_set *bset);
1956         __isl_give isl_union_map *isl_union_map_from_basic_map(
1957                 __isl_take isl_basic_map *bmap);
1958         __isl_give isl_union_set *isl_union_set_from_set(
1959                 __isl_take isl_set *set);
1960         __isl_give isl_union_map *isl_union_map_from_map(
1961                 __isl_take isl_map *map);
1963 The inverse conversions below can only be used if the input
1964 union set or relation is known to contain elements in exactly one
1965 space.
1967         __isl_give isl_set *isl_set_from_union_set(
1968                 __isl_take isl_union_set *uset);
1969         __isl_give isl_map *isl_map_from_union_map(
1970                 __isl_take isl_union_map *umap);
1972 Sets and relations can be copied and freed again using the following
1973 functions.
1975         __isl_give isl_basic_set *isl_basic_set_copy(
1976                 __isl_keep isl_basic_set *bset);
1977         __isl_give isl_set *isl_set_copy(__isl_keep isl_set *set);
1978         __isl_give isl_union_set *isl_union_set_copy(
1979                 __isl_keep isl_union_set *uset);
1980         __isl_give isl_basic_map *isl_basic_map_copy(
1981                 __isl_keep isl_basic_map *bmap);
1982         __isl_give isl_map *isl_map_copy(__isl_keep isl_map *map);
1983         __isl_give isl_union_map *isl_union_map_copy(
1984                 __isl_keep isl_union_map *umap);
1985         __isl_null isl_basic_set *isl_basic_set_free(
1986                 __isl_take isl_basic_set *bset);
1987         __isl_null isl_set *isl_set_free(__isl_take isl_set *set);
1988         __isl_null isl_union_set *isl_union_set_free(
1989                 __isl_take isl_union_set *uset);
1990         __isl_null isl_basic_map *isl_basic_map_free(
1991                 __isl_take isl_basic_map *bmap);
1992         __isl_null isl_map *isl_map_free(__isl_take isl_map *map);
1993         __isl_null isl_union_map *isl_union_map_free(
1994                 __isl_take isl_union_map *umap);
1996 Other sets and relations can be constructed by starting
1997 from a universe set or relation, adding equality and/or
1998 inequality constraints and then projecting out the
1999 existentially quantified variables, if any.
2000 Constraints can be constructed, manipulated and
2001 added to (or removed from) (basic) sets and relations
2002 using the following functions.
2004         #include <isl/constraint.h>
2005         __isl_give isl_constraint *isl_constraint_alloc_equality(
2006                 __isl_take isl_local_space *ls);
2007         __isl_give isl_constraint *isl_constraint_alloc_inequality(
2008                 __isl_take isl_local_space *ls);
2009         __isl_give isl_constraint *isl_constraint_set_constant_si(
2010                 __isl_take isl_constraint *constraint, int v);
2011         __isl_give isl_constraint *isl_constraint_set_constant_val(
2012                 __isl_take isl_constraint *constraint,
2013                 __isl_take isl_val *v);
2014         __isl_give isl_constraint *isl_constraint_set_coefficient_si(
2015                 __isl_take isl_constraint *constraint,
2016                 enum isl_dim_type type, int pos, int v);
2017         __isl_give isl_constraint *
2018         isl_constraint_set_coefficient_val(
2019                 __isl_take isl_constraint *constraint,
2020                 enum isl_dim_type type, int pos,
2021                 __isl_take isl_val *v);
2022         __isl_give isl_basic_map *isl_basic_map_add_constraint(
2023                 __isl_take isl_basic_map *bmap,
2024                 __isl_take isl_constraint *constraint);
2025         __isl_give isl_basic_set *isl_basic_set_add_constraint(
2026                 __isl_take isl_basic_set *bset,
2027                 __isl_take isl_constraint *constraint);
2028         __isl_give isl_map *isl_map_add_constraint(
2029                 __isl_take isl_map *map,
2030                 __isl_take isl_constraint *constraint);
2031         __isl_give isl_set *isl_set_add_constraint(
2032                 __isl_take isl_set *set,
2033                 __isl_take isl_constraint *constraint);
2035 For example, to create a set containing the even integers
2036 between 10 and 42, you would use the following code.
2038         isl_space *space;
2039         isl_local_space *ls;
2040         isl_constraint *c;
2041         isl_basic_set *bset;
2043         space = isl_space_set_alloc(ctx, 0, 2);
2044         bset = isl_basic_set_universe(isl_space_copy(space));
2045         ls = isl_local_space_from_space(space);
2047         c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
2048         c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
2049         c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, 2);
2050         bset = isl_basic_set_add_constraint(bset, c);
2052         c = isl_constraint_alloc_inequality(isl_local_space_copy(ls));
2053         c = isl_constraint_set_constant_si(c, -10);
2054         c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
2055         bset = isl_basic_set_add_constraint(bset, c);
2057         c = isl_constraint_alloc_inequality(ls);
2058         c = isl_constraint_set_constant_si(c, 42);
2059         c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
2060         bset = isl_basic_set_add_constraint(bset, c);
2062         bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 1);
2064 Or, alternatively,
2066         isl_basic_set *bset;
2067         bset = isl_basic_set_read_from_str(ctx,
2068                 "{[i] : exists (a : i = 2a and i >= 10 and i <= 42)}");
2070 A basic set or relation can also be constructed from two matrices
2071 describing the equalities and the inequalities.
2073         __isl_give isl_basic_set *isl_basic_set_from_constraint_matrices(
2074                 __isl_take isl_space *space,
2075                 __isl_take isl_mat *eq, __isl_take isl_mat *ineq,
2076                 enum isl_dim_type c1,
2077                 enum isl_dim_type c2, enum isl_dim_type c3,
2078                 enum isl_dim_type c4);
2079         __isl_give isl_basic_map *isl_basic_map_from_constraint_matrices(
2080                 __isl_take isl_space *space,
2081                 __isl_take isl_mat *eq, __isl_take isl_mat *ineq,
2082                 enum isl_dim_type c1,
2083                 enum isl_dim_type c2, enum isl_dim_type c3,
2084                 enum isl_dim_type c4, enum isl_dim_type c5);
2086 The C<isl_dim_type> arguments indicate the order in which
2087 different kinds of variables appear in the input matrices
2088 and should be a permutation of C<isl_dim_cst>, C<isl_dim_param>,
2089 C<isl_dim_set> and C<isl_dim_div> for sets and
2090 of C<isl_dim_cst>, C<isl_dim_param>,
2091 C<isl_dim_in>, C<isl_dim_out> and C<isl_dim_div> for relations.
2093 A (basic or union) set or relation can also be constructed from a
2094 (union) (piecewise) (multiple) affine expression
2095 or a list of affine expressions
2096 (See L</"Functions">), provided these affine expressions do not
2097 involve any NaN.
2099         #include <isl/set.h>
2100         __isl_give isl_basic_set *isl_basic_set_from_multi_aff(
2101                 __isl_take isl_multi_aff *ma);
2103         #include <isl/map.h>
2104         __isl_give isl_basic_map *isl_basic_map_from_aff(
2105                 __isl_take isl_aff *aff);
2106         __isl_give isl_map *isl_map_from_aff(
2107                 __isl_take isl_aff *aff);
2108         __isl_give isl_basic_map *isl_basic_map_from_aff_list(
2109                 __isl_take isl_space *domain_space,
2110                 __isl_take isl_aff_list *list);
2111         __isl_give isl_basic_map *isl_basic_map_from_multi_aff(
2112                 __isl_take isl_multi_aff *maff)
2113         __isl_give isl_map *isl_map_from_multi_aff(
2114                 __isl_take isl_multi_aff *maff)
2116         #include <isl/aff.h>
2117         __isl_give isl_set *isl_set_from_pw_aff(
2118                 __isl_take isl_pw_aff *pwaff);
2119         __isl_give isl_map *isl_map_from_pw_aff(
2120                 __isl_take isl_pw_aff *pwaff);
2121         __isl_give isl_set *isl_set_from_pw_multi_aff(
2122                 __isl_take isl_pw_multi_aff *pma);
2123         __isl_give isl_map *isl_map_from_pw_multi_aff(
2124                 __isl_take isl_pw_multi_aff *pma);
2125         __isl_give isl_set *isl_set_from_multi_pw_aff(
2126                 __isl_take isl_multi_pw_aff *mpa);
2127         __isl_give isl_map *isl_map_from_multi_pw_aff(
2128                 __isl_take isl_multi_pw_aff *mpa);
2129         __isl_give isl_union_map *isl_union_map_from_union_pw_aff(
2130                 __isl_take isl_union_pw_aff *upa);
2131         __isl_give isl_union_map *
2132         isl_union_map_from_union_pw_multi_aff(
2133                 __isl_take isl_union_pw_multi_aff *upma);
2134         __isl_give isl_union_map *
2135         isl_union_map_from_multi_union_pw_aff(
2136                 __isl_take isl_multi_union_pw_aff *mupa);
2138 The C<domain_space> argument describes the domain of the resulting
2139 basic relation.  It is required because the C<list> may consist
2140 of zero affine expressions.
2141 The C<mupa> passed to C<isl_union_map_from_multi_union_pw_aff>
2142 is not allowed to be zero-dimensional.  The domain of the result
2143 is the shared domain of the union piecewise affine elements.
2145 =head2 Inspecting Sets and Relations
2147 Usually, the user should not have to care about the actual constraints
2148 of the sets and maps, but should instead apply the abstract operations
2149 explained in the following sections.
2150 Occasionally, however, it may be required to inspect the individual
2151 coefficients of the constraints.  This section explains how to do so.
2152 In these cases, it may also be useful to have C<isl> compute
2153 an explicit representation of the existentially quantified variables.
2155         __isl_give isl_set *isl_set_compute_divs(
2156                 __isl_take isl_set *set);
2157         __isl_give isl_map *isl_map_compute_divs(
2158                 __isl_take isl_map *map);
2159         __isl_give isl_union_set *isl_union_set_compute_divs(
2160                 __isl_take isl_union_set *uset);
2161         __isl_give isl_union_map *isl_union_map_compute_divs(
2162                 __isl_take isl_union_map *umap);
2164 This explicit representation defines the existentially quantified
2165 variables as integer divisions of the other variables, possibly
2166 including earlier existentially quantified variables.
2167 An explicitly represented existentially quantified variable therefore
2168 has a unique value when the values of the other variables are known.
2170 Alternatively, the existentially quantified variables can be removed
2171 using the following functions, which compute an overapproximation.
2173         #include <isl/set.h>
2174         __isl_give isl_basic_set *isl_basic_set_remove_divs(
2175                 __isl_take isl_basic_set *bset);
2176         __isl_give isl_set *isl_set_remove_divs(
2177                 __isl_take isl_set *set);
2179         #include <isl/map.h>
2180         __isl_give isl_basic_map *isl_basic_map_remove_divs(
2181                 __isl_take isl_basic_map *bmap);
2182         __isl_give isl_map *isl_map_remove_divs(
2183                 __isl_take isl_map *map);
2185         #include <isl/union_set.h>
2186         __isl_give isl_union_set *isl_union_set_remove_divs(
2187                 __isl_take isl_union_set *bset);
2189         #include <isl/union_map.h>
2190         __isl_give isl_union_map *isl_union_map_remove_divs(
2191                 __isl_take isl_union_map *bmap);
2193 It is also possible to only remove those divs that are defined
2194 in terms of a given range of dimensions or only those for which
2195 no explicit representation is known.
2197         __isl_give isl_basic_set *
2198         isl_basic_set_remove_divs_involving_dims(
2199                 __isl_take isl_basic_set *bset,
2200                 enum isl_dim_type type,
2201                 unsigned first, unsigned n);
2202         __isl_give isl_basic_map *
2203         isl_basic_map_remove_divs_involving_dims(
2204                 __isl_take isl_basic_map *bmap,
2205                 enum isl_dim_type type,
2206                 unsigned first, unsigned n);
2207         __isl_give isl_set *isl_set_remove_divs_involving_dims(
2208                 __isl_take isl_set *set, enum isl_dim_type type,
2209                 unsigned first, unsigned n);
2210         __isl_give isl_map *isl_map_remove_divs_involving_dims(
2211                 __isl_take isl_map *map, enum isl_dim_type type,
2212                 unsigned first, unsigned n);
2214         __isl_give isl_basic_set *
2215         isl_basic_set_remove_unknown_divs(
2216                 __isl_take isl_basic_set *bset);
2217         __isl_give isl_set *isl_set_remove_unknown_divs(
2218                 __isl_take isl_set *set);
2219         __isl_give isl_map *isl_map_remove_unknown_divs(
2220                 __isl_take isl_map *map);
2222 To iterate over all the sets or maps in a union set or map, use
2224         #include <isl/union_set.h>
2225         isl_stat isl_union_set_foreach_set(
2226                 __isl_keep isl_union_set *uset,
2227                 isl_stat (*fn)(__isl_take isl_set *set, void *user),
2228                 void *user);
2230         #include <isl/union_map.h>
2231         isl_stat isl_union_map_foreach_map(
2232                 __isl_keep isl_union_map *umap,
2233                 isl_stat (*fn)(__isl_take isl_map *map, void *user),
2234                 void *user);
2235         isl_bool isl_union_map_every_map(
2236                 __isl_keep isl_union_map *umap,
2237                 isl_bool (*test)(__isl_keep isl_map *map,
2238                         void *user),
2239                 void *user);
2241 These functions call the callback function once for each
2242 (pair of) space(s) for which there are elements in the input.
2243 The argument to the callback contains all elements in the input
2244 with that (pair of) space(s).
2245 The C<isl_union_map_every_map> variant check whether each
2246 call to the callback returns true and stops checking as soon as one
2247 of these calls returns false.
2249 The number of sets or maps in a union set or map can be obtained
2250 from
2252         int isl_union_set_n_set(__isl_keep isl_union_set *uset);
2253         int isl_union_map_n_map(__isl_keep isl_union_map *umap);
2255 To extract the set or map in a given space from a union, use
2257         __isl_give isl_set *isl_union_set_extract_set(
2258                 __isl_keep isl_union_set *uset,
2259                 __isl_take isl_space *space);
2260         __isl_give isl_map *isl_union_map_extract_map(
2261                 __isl_keep isl_union_map *umap,
2262                 __isl_take isl_space *space);
2264 To iterate over all the basic sets or maps in a set or map, use
2266         isl_stat isl_set_foreach_basic_set(__isl_keep isl_set *set,
2267                 isl_stat (*fn)(__isl_take isl_basic_set *bset,
2268                         void *user),
2269                 void *user);
2270         isl_stat isl_map_foreach_basic_map(__isl_keep isl_map *map,
2271                 isl_stat (*fn)(__isl_take isl_basic_map *bmap,
2272                         void *user),
2273                 void *user);
2275 The callback function C<fn> should return C<isl_stat_ok> if successful and
2276 C<isl_stat_error> if an error occurs.  In the latter case, or if any other error
2277 occurs, the above functions will return C<isl_stat_error>.
2279 It should be noted that C<isl> does not guarantee that
2280 the basic sets or maps passed to C<fn> are disjoint.
2281 If this is required, then the user should call one of
2282 the following functions first.
2284         __isl_give isl_set *isl_set_make_disjoint(
2285                 __isl_take isl_set *set);
2286         __isl_give isl_map *isl_map_make_disjoint(
2287                 __isl_take isl_map *map);
2289 The number of basic sets in a set can be obtained
2290 or the number of basic maps in a map can be obtained
2291 from
2293         #include <isl/set.h>
2294         int isl_set_n_basic_set(__isl_keep isl_set *set);
2296         #include <isl/map.h>
2297         int isl_map_n_basic_map(__isl_keep isl_map *map);
2299 It is also possible to obtain a list of (basic) sets from a set
2300 or union set, a list of basic maps from a map and a list of maps from a union
2301 map.
2303         #include <isl/set.h>
2304         __isl_give isl_basic_set_list *isl_set_get_basic_set_list(
2305                 __isl_keep isl_set *set);
2307         #include <isl/union_set.h>
2308         __isl_give isl_basic_set_list *
2309         isl_union_set_get_basic_set_list(
2310                 __isl_keep isl_union_set *uset);
2311         __isl_give isl_set_list *isl_union_set_get_set_list(
2312                 __isl_keep isl_union_set *uset);
2314         #include <isl/map.h>
2315         __isl_give isl_basic_map_list *isl_map_get_basic_map_list(
2316                 __isl_keep isl_map *map);
2318         #include <isl/union_map.h>
2319         __isl_give isl_map_list *isl_union_map_get_map_list(
2320                 __isl_keep isl_union_map *umap);
2322 The returned list can be manipulated using the functions in L<"Lists">.
2324 To iterate over the constraints of a basic set or map, use
2326         #include <isl/constraint.h>
2328         int isl_basic_set_n_constraint(
2329                 __isl_keep isl_basic_set *bset);
2330         isl_stat isl_basic_set_foreach_constraint(
2331                 __isl_keep isl_basic_set *bset,
2332                 isl_stat (*fn)(__isl_take isl_constraint *c,
2333                         void *user),
2334                 void *user);
2335         int isl_basic_map_n_constraint(
2336                 __isl_keep isl_basic_map *bmap);
2337         isl_stat isl_basic_map_foreach_constraint(
2338                 __isl_keep isl_basic_map *bmap,
2339                 isl_stat (*fn)(__isl_take isl_constraint *c,
2340                         void *user),
2341                 void *user);
2342         __isl_null isl_constraint *isl_constraint_free(
2343                 __isl_take isl_constraint *c);
2345 Again, the callback function C<fn> should return C<isl_stat_ok>
2346 if successful and
2347 C<isl_stat_error> if an error occurs.  In the latter case, or if any other error
2348 occurs, the above functions will return C<isl_stat_error>.
2349 The constraint C<c> represents either an equality or an inequality.
2350 Use the following function to find out whether a constraint
2351 represents an equality.  If not, it represents an inequality.
2353         isl_bool isl_constraint_is_equality(
2354                 __isl_keep isl_constraint *constraint);
2356 It is also possible to obtain a list of constraints from a basic
2357 map or set
2359         #include <isl/constraint.h>
2360         __isl_give isl_constraint_list *
2361         isl_basic_map_get_constraint_list(
2362                 __isl_keep isl_basic_map *bmap);
2363         __isl_give isl_constraint_list *
2364         isl_basic_set_get_constraint_list(
2365                 __isl_keep isl_basic_set *bset);
2367 These functions require that all existentially quantified variables
2368 have an explicit representation.
2369 The returned list can be manipulated using the functions in L<"Lists">.
2371 The coefficients of the constraints can be inspected using
2372 the following functions.
2374         isl_bool isl_constraint_is_lower_bound(
2375                 __isl_keep isl_constraint *constraint,
2376                 enum isl_dim_type type, unsigned pos);
2377         isl_bool isl_constraint_is_upper_bound(
2378                 __isl_keep isl_constraint *constraint,
2379                 enum isl_dim_type type, unsigned pos);
2380         __isl_give isl_val *isl_constraint_get_constant_val(
2381                 __isl_keep isl_constraint *constraint);
2382         __isl_give isl_val *isl_constraint_get_coefficient_val(
2383                 __isl_keep isl_constraint *constraint,
2384                 enum isl_dim_type type, int pos);
2386 The explicit representations of the existentially quantified
2387 variables can be inspected using the following function.
2388 Note that the user is only allowed to use this function
2389 if the inspected set or map is the result of a call
2390 to C<isl_set_compute_divs> or C<isl_map_compute_divs>.
2391 The existentially quantified variable is equal to the floor
2392 of the returned affine expression.  The affine expression
2393 itself can be inspected using the functions in
2394 L</"Functions">.
2396         __isl_give isl_aff *isl_constraint_get_div(
2397                 __isl_keep isl_constraint *constraint, int pos);
2399 To obtain the constraints of a basic set or map in matrix
2400 form, use the following functions.
2402         __isl_give isl_mat *isl_basic_set_equalities_matrix(
2403                 __isl_keep isl_basic_set *bset,
2404                 enum isl_dim_type c1, enum isl_dim_type c2,
2405                 enum isl_dim_type c3, enum isl_dim_type c4);
2406         __isl_give isl_mat *isl_basic_set_inequalities_matrix(
2407                 __isl_keep isl_basic_set *bset,
2408                 enum isl_dim_type c1, enum isl_dim_type c2,
2409                 enum isl_dim_type c3, enum isl_dim_type c4);
2410         __isl_give isl_mat *isl_basic_map_equalities_matrix(
2411                 __isl_keep isl_basic_map *bmap,
2412                 enum isl_dim_type c1,
2413                 enum isl_dim_type c2, enum isl_dim_type c3,
2414                 enum isl_dim_type c4, enum isl_dim_type c5);
2415         __isl_give isl_mat *isl_basic_map_inequalities_matrix(
2416                 __isl_keep isl_basic_map *bmap,
2417                 enum isl_dim_type c1,
2418                 enum isl_dim_type c2, enum isl_dim_type c3,
2419                 enum isl_dim_type c4, enum isl_dim_type c5);
2421 The C<isl_dim_type> arguments dictate the order in which
2422 different kinds of variables appear in the resulting matrix.
2423 For set inputs, they should be a permutation of
2424 C<isl_dim_cst>, C<isl_dim_param>, C<isl_dim_set> and C<isl_dim_div>.
2425 For map inputs, they should be a permutation of
2426 C<isl_dim_cst>, C<isl_dim_param>,
2427 C<isl_dim_in>, C<isl_dim_out> and C<isl_dim_div>.
2429 =head2 Points
2431 Points are elements of a set.  They can be used to construct
2432 simple sets (boxes) or they can be used to represent the
2433 individual elements of a set.
2434 The zero point (the origin) can be created using
2436         __isl_give isl_point *isl_point_zero(__isl_take isl_space *space);
2438 The coordinates of a point can be inspected, set and changed
2439 using
2441         __isl_give isl_val *isl_point_get_coordinate_val(
2442                 __isl_keep isl_point *pnt,
2443                 enum isl_dim_type type, int pos);
2444         __isl_give isl_point *isl_point_set_coordinate_val(
2445                 __isl_take isl_point *pnt,
2446                 enum isl_dim_type type, int pos,
2447                 __isl_take isl_val *v);
2449         __isl_give isl_point *isl_point_add_ui(
2450                 __isl_take isl_point *pnt,
2451                 enum isl_dim_type type, int pos, unsigned val);
2452         __isl_give isl_point *isl_point_sub_ui(
2453                 __isl_take isl_point *pnt,
2454                 enum isl_dim_type type, int pos, unsigned val);
2456 Points can be copied or freed using
2458         __isl_give isl_point *isl_point_copy(
2459                 __isl_keep isl_point *pnt);
2460         __isl_null isl_point *isl_point_free(
2461                 __isl_take isl_point *pnt);
2463 A singleton set can be created from a point using
2465         __isl_give isl_basic_set *isl_basic_set_from_point(
2466                 __isl_take isl_point *pnt);
2467         __isl_give isl_set *isl_set_from_point(
2468                 __isl_take isl_point *pnt);
2469         __isl_give isl_union_set *isl_union_set_from_point(
2470                 __isl_take isl_point *pnt);
2472 and a box can be created from two opposite extremal points using
2474         __isl_give isl_basic_set *isl_basic_set_box_from_points(
2475                 __isl_take isl_point *pnt1,
2476                 __isl_take isl_point *pnt2);
2477         __isl_give isl_set *isl_set_box_from_points(
2478                 __isl_take isl_point *pnt1,
2479                 __isl_take isl_point *pnt2);
2481 All elements of a B<bounded> (union) set can be enumerated using
2482 the following functions.
2484         isl_stat isl_set_foreach_point(__isl_keep isl_set *set,
2485                 isl_stat (*fn)(__isl_take isl_point *pnt,
2486                         void *user),
2487                 void *user);
2488         isl_stat isl_union_set_foreach_point(
2489                 __isl_keep isl_union_set *uset,
2490                 isl_stat (*fn)(__isl_take isl_point *pnt,
2491                         void *user),
2492                 void *user);
2494 The function C<fn> is called for each integer point in
2495 C<set> with as second argument the last argument of
2496 the C<isl_set_foreach_point> call.  The function C<fn>
2497 should return C<isl_stat_ok> on success and C<isl_stat_error> on failure.
2498 In the latter case, C<isl_set_foreach_point> will stop
2499 enumerating and return C<isl_stat_error> as well.
2500 If the enumeration is performed successfully and to completion,
2501 then C<isl_set_foreach_point> returns C<isl_stat_ok>.
2503 To obtain a single point of a (basic or union) set, use
2505         __isl_give isl_point *isl_basic_set_sample_point(
2506                 __isl_take isl_basic_set *bset);
2507         __isl_give isl_point *isl_set_sample_point(
2508                 __isl_take isl_set *set);
2509         __isl_give isl_point *isl_union_set_sample_point(
2510                 __isl_take isl_union_set *uset);
2512 If C<set> does not contain any (integer) points, then the
2513 resulting point will be ``void'', a property that can be
2514 tested using
2516         isl_bool isl_point_is_void(__isl_keep isl_point *pnt);
2518 =head2 Functions
2520 Besides sets and relation, C<isl> also supports various types of functions.
2521 Each of these types is derived from the value type (see L</"Values">)
2522 or from one of two primitive function types
2523 through the application of zero or more type constructors.
2524 We first describe the primitive type and then we describe
2525 the types derived from these primitive types.
2527 =head3 Primitive Functions
2529 C<isl> support two primitive function types, quasi-affine
2530 expressions and quasipolynomials.
2531 A quasi-affine expression is defined either over a parameter
2532 space or over a set and is composed of integer constants,
2533 parameters and set variables, addition, subtraction and
2534 integer division by an integer constant.
2535 For example, the quasi-affine expression
2537         [n] -> { [x] -> [2*floor((4 n + x)/9)] }
2539 maps C<x> to C<2*floor((4 n + x)/9>.
2540 A quasipolynomial is a polynomial expression in quasi-affine
2541 expression.  That is, it additionally allows for multiplication.
2542 Note, though, that it is not allowed to construct an integer
2543 division of an expression involving multiplications.
2544 Here is an example of a quasipolynomial that is not
2545 quasi-affine expression
2547         [n] -> { [x] -> (n*floor((4 n + x)/9)) }
2549 Note that the external representations of quasi-affine expressions
2550 and quasipolynomials are different.  Quasi-affine expressions
2551 use a notation with square brackets just like binary relations,
2552 while quasipolynomials do not.  This might change at some point.
2554 If a primitive function is defined over a parameter space,
2555 then the space of the function itself is that of a set.
2556 If it is defined over a set, then the space of the function
2557 is that of a relation.  In both cases, the set space (or
2558 the output space) is single-dimensional, anonymous and unstructured.
2559 To create functions with multiple dimensions or with other kinds
2560 of set or output spaces, use multiple expressions
2561 (see L</"Multiple Expressions">).
2563 =over
2565 =item * Quasi-affine Expressions
2567 Besides the expressions described above, a quasi-affine
2568 expression can also be set to NaN.  Such expressions
2569 typically represent a failure to represent a result
2570 as a quasi-affine expression.
2572 The zero quasi affine expression or the quasi affine expression
2573 that is equal to a given value, parameter or
2574 a specified dimension on a given domain can be created using
2576         #include <isl/aff.h>
2577         __isl_give isl_aff *isl_aff_zero_on_domain(
2578                 __isl_take isl_local_space *ls);
2579         __isl_give isl_aff *isl_aff_val_on_domain(
2580                 __isl_take isl_local_space *ls,
2581                 __isl_take isl_val *val);
2582         __isl_give isl_aff *isl_aff_param_on_domain_space_id(
2583                 __isl_take isl_space *space,
2584                 __isl_take isl_id *id);
2585         __isl_give isl_aff *isl_aff_var_on_domain(
2586                 __isl_take isl_local_space *ls,
2587                 enum isl_dim_type type, unsigned pos);
2588         __isl_give isl_aff *isl_aff_nan_on_domain(
2589                 __isl_take isl_local_space *ls);
2591 The space passed to C<isl_aff_param_on_domain_space_id>
2592 is required to have a parameter with the given identifier.
2594 Quasi affine expressions can be copied and freed using
2596         #include <isl/aff.h>
2597         __isl_give isl_aff *isl_aff_copy(
2598                 __isl_keep isl_aff *aff);
2599         __isl_null isl_aff *isl_aff_free(
2600                 __isl_take isl_aff *aff);
2602 A (rational) bound on a dimension can be extracted from an C<isl_constraint>
2603 using the following function.  The constraint is required to have
2604 a non-zero coefficient for the specified dimension.
2606         #include <isl/constraint.h>
2607         __isl_give isl_aff *isl_constraint_get_bound(
2608                 __isl_keep isl_constraint *constraint,
2609                 enum isl_dim_type type, int pos);
2611 The entire affine expression of the constraint can also be extracted
2612 using the following function.
2614         #include <isl/constraint.h>
2615         __isl_give isl_aff *isl_constraint_get_aff(
2616                 __isl_keep isl_constraint *constraint);
2618 Conversely, an equality constraint equating
2619 the affine expression to zero or an inequality constraint enforcing
2620 the affine expression to be non-negative, can be constructed using
2622         __isl_give isl_constraint *isl_equality_from_aff(
2623                 __isl_take isl_aff *aff);
2624         __isl_give isl_constraint *isl_inequality_from_aff(
2625                 __isl_take isl_aff *aff);
2627 The coefficients and the integer divisions of an affine expression
2628 can be inspected using the following functions.
2630         #include <isl/aff.h>
2631         __isl_give isl_val *isl_aff_get_constant_val(
2632                 __isl_keep isl_aff *aff);
2633         __isl_give isl_val *isl_aff_get_coefficient_val(
2634                 __isl_keep isl_aff *aff,
2635                 enum isl_dim_type type, int pos);
2636         int isl_aff_coefficient_sgn(__isl_keep isl_aff *aff,
2637                 enum isl_dim_type type, int pos);
2638         __isl_give isl_val *isl_aff_get_denominator_val(
2639                 __isl_keep isl_aff *aff);
2640         __isl_give isl_aff *isl_aff_get_div(
2641                 __isl_keep isl_aff *aff, int pos);
2643 They can be modified using the following functions.
2645         #include <isl/aff.h>
2646         __isl_give isl_aff *isl_aff_set_constant_si(
2647                 __isl_take isl_aff *aff, int v);
2648         __isl_give isl_aff *isl_aff_set_constant_val(
2649                 __isl_take isl_aff *aff, __isl_take isl_val *v);
2650         __isl_give isl_aff *isl_aff_set_coefficient_si(
2651                 __isl_take isl_aff *aff,
2652                 enum isl_dim_type type, int pos, int v);
2653         __isl_give isl_aff *isl_aff_set_coefficient_val(
2654                 __isl_take isl_aff *aff,
2655                 enum isl_dim_type type, int pos,
2656                 __isl_take isl_val *v);
2658         __isl_give isl_aff *isl_aff_add_constant_si(
2659                 __isl_take isl_aff *aff, int v);
2660         __isl_give isl_aff *isl_aff_add_constant_val(
2661                 __isl_take isl_aff *aff, __isl_take isl_val *v);
2662         __isl_give isl_aff *isl_aff_add_constant_num_si(
2663                 __isl_take isl_aff *aff, int v);
2664         __isl_give isl_aff *isl_aff_add_coefficient_si(
2665                 __isl_take isl_aff *aff,
2666                 enum isl_dim_type type, int pos, int v);
2667         __isl_give isl_aff *isl_aff_add_coefficient_val(
2668                 __isl_take isl_aff *aff,
2669                 enum isl_dim_type type, int pos,
2670                 __isl_take isl_val *v);
2672 Note that C<isl_aff_set_constant_si> and C<isl_aff_set_coefficient_si>
2673 set the I<numerator> of the constant or coefficient, while
2674 C<isl_aff_set_constant_val> and C<isl_aff_set_coefficient_val> set
2675 the constant or coefficient as a whole.
2676 The C<add_constant> and C<add_coefficient> functions add an integer
2677 or rational value to
2678 the possibly rational constant or coefficient.
2679 The C<add_constant_num> functions add an integer value to
2680 the numerator.
2682 =item * Quasipolynomials
2684 Some simple quasipolynomials can be created using the following functions.
2686         #include <isl/polynomial.h>
2687         __isl_give isl_qpolynomial *isl_qpolynomial_zero_on_domain(
2688                 __isl_take isl_space *domain);
2689         __isl_give isl_qpolynomial *isl_qpolynomial_one_on_domain(
2690                 __isl_take isl_space *domain);
2691         __isl_give isl_qpolynomial *isl_qpolynomial_infty_on_domain(
2692                 __isl_take isl_space *domain);
2693         __isl_give isl_qpolynomial *isl_qpolynomial_neginfty_on_domain(
2694                 __isl_take isl_space *domain);
2695         __isl_give isl_qpolynomial *isl_qpolynomial_nan_on_domain(
2696                 __isl_take isl_space *domain);
2697         __isl_give isl_qpolynomial *isl_qpolynomial_val_on_domain(
2698                 __isl_take isl_space *domain,
2699                 __isl_take isl_val *val);
2700         __isl_give isl_qpolynomial *isl_qpolynomial_var_on_domain(
2701                 __isl_take isl_space *domain,
2702                 enum isl_dim_type type, unsigned pos);
2703         __isl_give isl_qpolynomial *isl_qpolynomial_from_aff(
2704                 __isl_take isl_aff *aff);
2706 Recall that the space in which a quasipolynomial lives is a map space
2707 with a one-dimensional range.  The C<domain> argument in some of
2708 the functions above corresponds to the domain of this map space.
2710 Quasipolynomials can be copied and freed again using the following
2711 functions.
2713         #include <isl/polynomial.h>
2714         __isl_give isl_qpolynomial *isl_qpolynomial_copy(
2715                 __isl_keep isl_qpolynomial *qp);
2716         __isl_null isl_qpolynomial *isl_qpolynomial_free(
2717                 __isl_take isl_qpolynomial *qp);
2719 The constant term of a quasipolynomial can be extracted using
2721         __isl_give isl_val *isl_qpolynomial_get_constant_val(
2722                 __isl_keep isl_qpolynomial *qp);
2724 To iterate over all terms in a quasipolynomial,
2727         isl_stat isl_qpolynomial_foreach_term(
2728                 __isl_keep isl_qpolynomial *qp,
2729                 isl_stat (*fn)(__isl_take isl_term *term,
2730                           void *user), void *user);
2732 The terms themselves can be inspected and freed using
2733 these functions
2735         unsigned isl_term_dim(__isl_keep isl_term *term,
2736                 enum isl_dim_type type);
2737         __isl_give isl_val *isl_term_get_coefficient_val(
2738                 __isl_keep isl_term *term);
2739         int isl_term_get_exp(__isl_keep isl_term *term,
2740                 enum isl_dim_type type, unsigned pos);
2741         __isl_give isl_aff *isl_term_get_div(
2742                 __isl_keep isl_term *term, unsigned pos);
2743         void isl_term_free(__isl_take isl_term *term);
2745 Each term is a product of parameters, set variables and
2746 integer divisions.  The function C<isl_term_get_exp>
2747 returns the exponent of a given dimensions in the given term.
2749 =back
2751 =head3 Reductions
2753 A reduction represents a maximum or a minimum of its
2754 base expressions.
2755 The only reduction type defined by C<isl> is
2756 C<isl_qpolynomial_fold>.
2758 There are currently no functions to directly create such
2759 objects, but they do appear in the piecewise quasipolynomial
2760 reductions returned by the C<isl_pw_qpolynomial_bound> function.
2762 L</"Bounds on Piecewise Quasipolynomials and Piecewise Quasipolynomial Reductions">.
2764 Reductions can be copied and freed using
2765 the following functions.
2767         #include <isl/polynomial.h>
2768         __isl_give isl_qpolynomial_fold *
2769         isl_qpolynomial_fold_copy(
2770                 __isl_keep isl_qpolynomial_fold *fold);
2771         void isl_qpolynomial_fold_free(
2772                 __isl_take isl_qpolynomial_fold *fold);
2774 To iterate over all quasipolynomials in a reduction, use
2776         isl_stat isl_qpolynomial_fold_foreach_qpolynomial(
2777                 __isl_keep isl_qpolynomial_fold *fold,
2778                 isl_stat (*fn)(__isl_take isl_qpolynomial *qp,
2779                           void *user), void *user);
2781 =head3 Multiple Expressions
2783 A multiple expression represents a sequence of zero or
2784 more base expressions, all defined on the same domain space.
2785 The domain space of the multiple expression is the same
2786 as that of the base expressions, but the range space
2787 can be any space.  In case the base expressions have
2788 a set space, the corresponding multiple expression
2789 also has a set space.
2790 Objects of the value type do not have an associated space.
2791 The space of a multiple value is therefore always a set space.
2792 Similarly, the space of a multiple union piecewise
2793 affine expression is always a set space.
2794 If the base expressions are not total, then
2795 a corresponding zero-dimensional multiple expression may
2796 have an explicit domain that keeps track of the domain
2797 outside of any base expressions.
2799 The multiple expression types defined by C<isl>
2800 are C<isl_multi_val>, C<isl_multi_aff>, C<isl_multi_pw_aff>,
2801 C<isl_multi_union_pw_aff>.
2803 A multiple expression with the value zero for
2804 each output (or set) dimension can be created
2805 using the following functions.
2807         #include <isl/val.h>
2808         __isl_give isl_multi_val *isl_multi_val_zero(
2809                 __isl_take isl_space *space);
2811         #include <isl/aff.h>
2812         __isl_give isl_multi_aff *isl_multi_aff_zero(
2813                 __isl_take isl_space *space);
2814         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_zero(
2815                 __isl_take isl_space *space);
2816         __isl_give isl_multi_union_pw_aff *
2817         isl_multi_union_pw_aff_zero(
2818                 __isl_take isl_space *space);
2820 Since there is no canonical way of representing a zero
2821 value of type C<isl_union_pw_aff>, the space passed
2822 to C<isl_multi_union_pw_aff_zero> needs to be zero-dimensional.
2824 An identity function can be created using the following
2825 functions.  The space needs to be that of a relation
2826 with the same number of input and output dimensions.
2828         #include <isl/aff.h>
2829         __isl_give isl_multi_aff *isl_multi_aff_identity(
2830                 __isl_take isl_space *space);
2831         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_identity(
2832                 __isl_take isl_space *space);
2834 A function that performs a projection on a universe
2835 relation or set can be created using the following functions.
2836 See also the corresponding
2837 projection operations in L</"Unary Operations">.
2839         #include <isl/aff.h>
2840         __isl_give isl_multi_aff *isl_multi_aff_domain_map(
2841                 __isl_take isl_space *space);
2842         __isl_give isl_multi_aff *isl_multi_aff_range_map(
2843                 __isl_take isl_space *space);
2844         __isl_give isl_multi_aff *isl_multi_aff_project_out_map(
2845                 __isl_take isl_space *space,
2846                 enum isl_dim_type type,
2847                 unsigned first, unsigned n);
2849 A multiple expression can be created from a single
2850 base expression using the following functions.
2851 The space of the created multiple expression is the same
2852 as that of the base expression, except for
2853 C<isl_multi_union_pw_aff_from_union_pw_aff> where the input
2854 lives in a parameter space and the output lives
2855 in a single-dimensional set space.
2857         #include <isl/aff.h>
2858         __isl_give isl_multi_aff *isl_multi_aff_from_aff(
2859                 __isl_take isl_aff *aff);
2860         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_pw_aff(
2861                 __isl_take isl_pw_aff *pa);
2862         __isl_give isl_multi_union_pw_aff *
2863         isl_multi_union_pw_aff_from_union_pw_aff(
2864                 __isl_take isl_union_pw_aff *upa);
2866 A multiple expression can be created from a list
2867 of base expression in a specified space.
2868 The domain of this space needs to be the same
2869 as the domains of the base expressions in the list.
2870 If the base expressions have a set space (or no associated space),
2871 then this space also needs to be a set space.
2873         #include <isl/val.h>
2874         __isl_give isl_multi_val *isl_multi_val_from_val_list(
2875                 __isl_take isl_space *space,
2876                 __isl_take isl_val_list *list);
2878         #include <isl/aff.h>
2879         __isl_give isl_multi_aff *isl_multi_aff_from_aff_list(
2880                 __isl_take isl_space *space,
2881                 __isl_take isl_aff_list *list);
2882         __isl_give isl_multi_pw_aff *
2883         isl_multi_pw_aff_from_pw_aff_list(
2884                 __isl_take isl_space *space,
2885                 __isl_take isl_pw_aff_list *list);
2886         __isl_give isl_multi_union_pw_aff *
2887         isl_multi_union_pw_aff_from_union_pw_aff_list(
2888                 __isl_take isl_space *space,
2889                 __isl_take isl_union_pw_aff_list *list);
2891 As a convenience, a multiple piecewise expression can
2892 also be created from a multiple expression.
2893 Each piecewise expression in the result has a single
2894 universe cell.
2896         #include <isl/aff.h>
2897         __isl_give isl_multi_pw_aff *
2898         isl_multi_pw_aff_from_multi_aff(
2899                 __isl_take isl_multi_aff *ma);
2901 Similarly, a multiple union expression can be
2902 created from a multiple expression.
2904         #include <isl/aff.h>
2905         __isl_give isl_multi_union_pw_aff *
2906         isl_multi_union_pw_aff_from_multi_aff(
2907                 __isl_take isl_multi_aff *ma);
2908         __isl_give isl_multi_union_pw_aff *
2909         isl_multi_union_pw_aff_from_multi_pw_aff(
2910                 __isl_take isl_multi_pw_aff *mpa);
2912 A multiple quasi-affine expression can be created from
2913 a multiple value with a given domain space using the following
2914 function.
2916         #include <isl/aff.h>
2917         __isl_give isl_multi_aff *
2918         isl_multi_aff_multi_val_on_space(
2919                 __isl_take isl_space *space,
2920                 __isl_take isl_multi_val *mv);
2922 Similarly,
2923 a multiple union piecewise affine expression can be created from
2924 a multiple value with a given domain or
2925 a (piecewise) multiple affine expression with a given domain
2926 using the following functions.
2928         #include <isl/aff.h>
2929         __isl_give isl_multi_union_pw_aff *
2930         isl_multi_union_pw_aff_multi_val_on_domain(
2931                 __isl_take isl_union_set *domain,
2932                 __isl_take isl_multi_val *mv);
2933         __isl_give isl_multi_union_pw_aff *
2934         isl_multi_union_pw_aff_multi_aff_on_domain(
2935                 __isl_take isl_union_set *domain,
2936                 __isl_take isl_multi_aff *ma);
2937         __isl_give isl_multi_union_pw_aff *
2938         isl_multi_union_pw_aff_pw_multi_aff_on_domain(
2939                 __isl_take isl_union_set *domain,
2940                 __isl_take isl_pw_multi_aff *pma);
2942 Multiple expressions can be copied and freed using
2943 the following functions.
2945         #include <isl/val.h>
2946         __isl_give isl_multi_val *isl_multi_val_copy(
2947                 __isl_keep isl_multi_val *mv);
2948         __isl_null isl_multi_val *isl_multi_val_free(
2949                 __isl_take isl_multi_val *mv);
2951         #include <isl/aff.h>
2952         __isl_give isl_multi_aff *isl_multi_aff_copy(
2953                 __isl_keep isl_multi_aff *maff);
2954         __isl_null isl_multi_aff *isl_multi_aff_free(
2955                 __isl_take isl_multi_aff *maff);
2956         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_copy(
2957                 __isl_keep isl_multi_pw_aff *mpa);
2958         __isl_null isl_multi_pw_aff *isl_multi_pw_aff_free(
2959                 __isl_take isl_multi_pw_aff *mpa);
2960         __isl_give isl_multi_union_pw_aff *
2961         isl_multi_union_pw_aff_copy(
2962                 __isl_keep isl_multi_union_pw_aff *mupa);
2963         __isl_null isl_multi_union_pw_aff *
2964         isl_multi_union_pw_aff_free(
2965                 __isl_take isl_multi_union_pw_aff *mupa);
2967 The base expression at a given position of a multiple
2968 expression can be extracted using the following functions.
2970         #include <isl/val.h>
2971         __isl_give isl_val *isl_multi_val_get_val(
2972                 __isl_keep isl_multi_val *mv, int pos);
2974         #include <isl/aff.h>
2975         __isl_give isl_aff *isl_multi_aff_get_aff(
2976                 __isl_keep isl_multi_aff *multi, int pos);
2977         __isl_give isl_pw_aff *isl_multi_pw_aff_get_pw_aff(
2978                 __isl_keep isl_multi_pw_aff *mpa, int pos);
2979         __isl_give isl_union_pw_aff *
2980         isl_multi_union_pw_aff_get_union_pw_aff(
2981                 __isl_keep isl_multi_union_pw_aff *mupa, int pos);
2983 It can be replaced using the following functions.
2985         #include <isl/val.h>
2986         __isl_give isl_multi_val *isl_multi_val_set_val(
2987                 __isl_take isl_multi_val *mv, int pos,
2988                 __isl_take isl_val *val);
2990         #include <isl/aff.h>
2991         __isl_give isl_multi_aff *isl_multi_aff_set_aff(
2992                 __isl_take isl_multi_aff *multi, int pos,
2993                 __isl_take isl_aff *aff);
2994         __isl_give isl_multi_union_pw_aff *
2995         isl_multi_union_pw_aff_set_union_pw_aff(
2996                 __isl_take isl_multi_union_pw_aff *mupa, int pos,
2997                 __isl_take isl_union_pw_aff *upa);
2999 As a convenience, a sequence of base expressions that have
3000 their domains in a given space can be extracted from a sequence
3001 of union expressions using the following function.
3003         #include <isl/aff.h>
3004         __isl_give isl_multi_pw_aff *
3005         isl_multi_union_pw_aff_extract_multi_pw_aff(
3006                 __isl_keep isl_multi_union_pw_aff *mupa,
3007                 __isl_take isl_space *space);
3009 Note that there is a difference between C<isl_multi_union_pw_aff>
3010 and C<isl_union_pw_multi_aff> objects.  The first is a sequence
3011 of unions of piecewise expressions, while the second is a union
3012 of piecewise sequences.  In particular, multiple affine expressions
3013 in an C<isl_union_pw_multi_aff> may live in different spaces,
3014 while there is only a single multiple expression in
3015 an C<isl_multi_union_pw_aff>, which can therefore only live
3016 in a single space.  This means that not every
3017 C<isl_union_pw_multi_aff> can be converted to
3018 an C<isl_multi_union_pw_aff>.  Conversely, the elements
3019 of an C<isl_multi_union_pw_aff> may be defined over different domains,
3020 while each multiple expression inside an C<isl_union_pw_multi_aff>
3021 has a single domain.  The conversion of an C<isl_union_pw_multi_aff>
3022 of dimension greater than one may therefore not be exact.
3023 The following functions can
3024 be used to perform these conversions when they are possible.
3026         #include <isl/aff.h>
3027         __isl_give isl_multi_union_pw_aff *
3028         isl_multi_union_pw_aff_from_union_pw_multi_aff(
3029                 __isl_take isl_union_pw_multi_aff *upma);
3030         __isl_give isl_union_pw_multi_aff *
3031         isl_union_pw_multi_aff_from_multi_union_pw_aff(
3032                 __isl_take isl_multi_union_pw_aff *mupa);
3034 =head3 Piecewise Expressions
3036 A piecewise expression is an expression that is described
3037 using zero or more base expression defined over the same
3038 number of cells in the domain space of the base expressions.
3039 All base expressions are defined over the same
3040 domain space and the cells are disjoint.
3041 The space of a piecewise expression is the same as
3042 that of the base expressions.
3043 If the union of the cells is a strict subset of the domain
3044 space, then the value of the piecewise expression outside
3045 this union is different for types derived from quasi-affine
3046 expressions and those derived from quasipolynomials.
3047 Piecewise expressions derived from quasi-affine expressions
3048 are considered to be undefined outside the union of their cells.
3049 Piecewise expressions derived from quasipolynomials
3050 are considered to be zero outside the union of their cells.
3052 Piecewise quasipolynomials are mainly used by the C<barvinok>
3053 library for representing the number of elements in a parametric set or map.
3054 For example, the piecewise quasipolynomial
3056         [n] -> { [x] -> ((1 + n) - x) : x <= n and x >= 0 }
3058 represents the number of points in the map
3060         [n] -> { [x] -> [y] : x,y >= 0 and 0 <= x + y <= n }
3062 The piecewise expression types defined by C<isl>
3063 are C<isl_pw_aff>, C<isl_pw_multi_aff>,
3064 C<isl_pw_qpolynomial> and C<isl_pw_qpolynomial_fold>.
3066 A piecewise expression with no cells can be created using
3067 the following functions.
3069         #include <isl/aff.h>
3070         __isl_give isl_pw_aff *isl_pw_aff_empty(
3071                 __isl_take isl_space *space);
3072         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_empty(
3073                 __isl_take isl_space *space);
3075 A piecewise expression with a single universe cell can be
3076 created using the following functions.
3078         #include <isl/aff.h>
3079         __isl_give isl_pw_aff *isl_pw_aff_from_aff(
3080                 __isl_take isl_aff *aff);
3081         __isl_give isl_pw_multi_aff *
3082         isl_pw_multi_aff_from_multi_aff(
3083                 __isl_take isl_multi_aff *ma);
3085         #include <isl/polynomial.h>
3086         __isl_give isl_pw_qpolynomial *
3087         isl_pw_qpolynomial_from_qpolynomial(
3088                 __isl_take isl_qpolynomial *qp);
3090 A piecewise expression with a single specified cell can be
3091 created using the following functions.
3093         #include <isl/aff.h>
3094         __isl_give isl_pw_aff *isl_pw_aff_alloc(
3095                 __isl_take isl_set *set, __isl_take isl_aff *aff);
3096         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_alloc(
3097                 __isl_take isl_set *set,
3098                 __isl_take isl_multi_aff *maff);
3100         #include <isl/polynomial.h>
3101         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_alloc(
3102                 __isl_take isl_set *set,
3103                 __isl_take isl_qpolynomial *qp);
3105 The following convenience functions first create a base expression and
3106 then create a piecewise expression over a universe domain.
3108         #include <isl/aff.h>
3109         __isl_give isl_pw_aff *isl_pw_aff_zero_on_domain(
3110                 __isl_take isl_local_space *ls);
3111         __isl_give isl_pw_aff *isl_pw_aff_var_on_domain(
3112                 __isl_take isl_local_space *ls,
3113                 enum isl_dim_type type, unsigned pos);
3114         __isl_give isl_pw_aff *isl_pw_aff_nan_on_domain(
3115                 __isl_take isl_local_space *ls);
3116         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_zero(
3117                 __isl_take isl_space *space);
3118         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_identity(
3119                 __isl_take isl_space *space);
3120         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_range_map(
3121                 __isl_take isl_space *space);
3122         __isl_give isl_pw_multi_aff *
3123         isl_pw_multi_aff_project_out_map(
3124                 __isl_take isl_space *space,
3125                 enum isl_dim_type type,
3126                 unsigned first, unsigned n);
3128         #include <isl/polynomial.h>
3129         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_zero(
3130                 __isl_take isl_space *space);
3132 The following convenience functions first create a base expression and
3133 then create a piecewise expression over a given domain.
3135         #include <isl/aff.h>
3136         __isl_give isl_pw_aff *isl_pw_aff_val_on_domain(
3137                 __isl_take isl_set *domain,
3138                 __isl_take isl_val *v);
3139         __isl_give isl_pw_multi_aff *
3140         isl_pw_multi_aff_multi_val_on_domain(
3141                 __isl_take isl_set *domain,
3142                 __isl_take isl_multi_val *mv);
3144 As a convenience, a piecewise multiple expression can
3145 also be created from a piecewise expression.
3146 Each multiple expression in the result is derived
3147 from the corresponding base expression.
3149         #include <isl/aff.h>
3150         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_pw_aff(
3151                 __isl_take isl_pw_aff *pa);
3153 Similarly, a piecewise quasipolynomial can be
3154 created from a piecewise quasi-affine expression using
3155 the following function.
3157         #include <isl/polynomial.h>
3158         __isl_give isl_pw_qpolynomial *
3159         isl_pw_qpolynomial_from_pw_aff(
3160                 __isl_take isl_pw_aff *pwaff);
3162 Piecewise expressions can be copied and freed using the following functions.
3164         #include <isl/aff.h>
3165         __isl_give isl_pw_aff *isl_pw_aff_copy(
3166                 __isl_keep isl_pw_aff *pwaff);
3167         __isl_null isl_pw_aff *isl_pw_aff_free(
3168                 __isl_take isl_pw_aff *pwaff);
3169         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_copy(
3170                 __isl_keep isl_pw_multi_aff *pma);
3171         __isl_null isl_pw_multi_aff *isl_pw_multi_aff_free(
3172                 __isl_take isl_pw_multi_aff *pma);
3174         #include <isl/polynomial.h>
3175         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_copy(
3176                 __isl_keep isl_pw_qpolynomial *pwqp);
3177         __isl_null isl_pw_qpolynomial *isl_pw_qpolynomial_free(
3178                 __isl_take isl_pw_qpolynomial *pwqp);
3179         __isl_give isl_pw_qpolynomial_fold *
3180         isl_pw_qpolynomial_fold_copy(
3181                 __isl_keep isl_pw_qpolynomial_fold *pwf);
3182         __isl_null isl_pw_qpolynomial_fold *
3183         isl_pw_qpolynomial_fold_free(
3184                 __isl_take isl_pw_qpolynomial_fold *pwf);
3186 To iterate over the different cells of a piecewise expression,
3187 use the following functions.
3189         #include <isl/aff.h>
3190         isl_bool isl_pw_aff_is_empty(__isl_keep isl_pw_aff *pwaff);
3191         int isl_pw_aff_n_piece(__isl_keep isl_pw_aff *pwaff);
3192         isl_stat isl_pw_aff_foreach_piece(
3193                 __isl_keep isl_pw_aff *pwaff,
3194                 isl_stat (*fn)(__isl_take isl_set *set,
3195                           __isl_take isl_aff *aff,
3196                           void *user), void *user);
3197         int isl_pw_multi_aff_n_piece(
3198                 __isl_keep isl_pw_multi_aff *pma);
3199         isl_stat isl_pw_multi_aff_foreach_piece(
3200                 __isl_keep isl_pw_multi_aff *pma,
3201                 isl_stat (*fn)(__isl_take isl_set *set,
3202                             __isl_take isl_multi_aff *maff,
3203                             void *user), void *user);
3205         #include <isl/polynomial.h>
3206         int isl_pw_qpolynomial_n_piece(
3207                 __isl_keep isl_pw_qpolynomial *pwqp);
3208         isl_stat isl_pw_qpolynomial_foreach_piece(
3209                 __isl_keep isl_pw_qpolynomial *pwqp,
3210                 isl_stat (*fn)(__isl_take isl_set *set,
3211                           __isl_take isl_qpolynomial *qp,
3212                           void *user), void *user);
3213         isl_stat isl_pw_qpolynomial_foreach_lifted_piece(
3214                 __isl_keep isl_pw_qpolynomial *pwqp,
3215                 isl_stat (*fn)(__isl_take isl_set *set,
3216                           __isl_take isl_qpolynomial *qp,
3217                           void *user), void *user);
3218         int isl_pw_qpolynomial_fold_n_piece(
3219                 __isl_keep isl_pw_qpolynomial_fold *pwf);
3220         isl_stat isl_pw_qpolynomial_fold_foreach_piece(
3221                 __isl_keep isl_pw_qpolynomial_fold *pwf,
3222                 isl_stat (*fn)(__isl_take isl_set *set,
3223                           __isl_take isl_qpolynomial_fold *fold,
3224                           void *user), void *user);
3225         isl_stat isl_pw_qpolynomial_fold_foreach_lifted_piece(
3226                 __isl_keep isl_pw_qpolynomial_fold *pwf,
3227                 isl_stat (*fn)(__isl_take isl_set *set,
3228                           __isl_take isl_qpolynomial_fold *fold,
3229                           void *user), void *user);
3231 As usual, the function C<fn> should return C<isl_stat_ok> on success
3232 and C<isl_stat_error> on failure.  The difference between
3233 C<isl_pw_qpolynomial_foreach_piece> and
3234 C<isl_pw_qpolynomial_foreach_lifted_piece> is that
3235 C<isl_pw_qpolynomial_foreach_lifted_piece> will first
3236 compute unique representations for all existentially quantified
3237 variables and then turn these existentially quantified variables
3238 into extra set variables, adapting the associated quasipolynomial
3239 accordingly.  This means that the C<set> passed to C<fn>
3240 will not have any existentially quantified variables, but that
3241 the dimensions of the sets may be different for different
3242 invocations of C<fn>.
3243 Similarly for C<isl_pw_qpolynomial_fold_foreach_piece>
3244 and C<isl_pw_qpolynomial_fold_foreach_lifted_piece>.
3246 A piecewise expression consisting of the expressions at a given
3247 position of a piecewise multiple expression can be extracted
3248 using the following function.
3250         #include <isl/aff.h>
3251         __isl_give isl_pw_aff *isl_pw_multi_aff_get_pw_aff(
3252                 __isl_keep isl_pw_multi_aff *pma, int pos);
3254 These expressions can be replaced using the following function.
3256         #include <isl/aff.h>
3257         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_pw_aff(
3258                 __isl_take isl_pw_multi_aff *pma, unsigned pos,
3259                 __isl_take isl_pw_aff *pa);
3261 Note that there is a difference between C<isl_multi_pw_aff> and
3262 C<isl_pw_multi_aff> objects.  The first is a sequence of piecewise
3263 affine expressions, while the second is a piecewise sequence
3264 of affine expressions.  In particular, each of the piecewise
3265 affine expressions in an C<isl_multi_pw_aff> may have a different
3266 domain, while all multiple expressions associated to a cell
3267 in an C<isl_pw_multi_aff> have the same domain.
3268 It is possible to convert between the two, but when converting
3269 an C<isl_multi_pw_aff> to an C<isl_pw_multi_aff>, the domain
3270 of the result is the intersection of the domains of the input.
3271 The reverse conversion is exact.
3273         #include <isl/aff.h>
3274         __isl_give isl_pw_multi_aff *
3275         isl_pw_multi_aff_from_multi_pw_aff(
3276                 __isl_take isl_multi_pw_aff *mpa);
3277         __isl_give isl_multi_pw_aff *
3278         isl_multi_pw_aff_from_pw_multi_aff(
3279                 __isl_take isl_pw_multi_aff *pma);
3281 =head3 Union Expressions
3283 A union expression collects base expressions defined
3284 over different domains.  The space of a union expression
3285 is that of the shared parameter space.
3287 The union expression types defined by C<isl>
3288 are C<isl_union_pw_aff>, C<isl_union_pw_multi_aff>,
3289 C<isl_union_pw_qpolynomial> and C<isl_union_pw_qpolynomial_fold>.
3290 In case of
3291 C<isl_union_pw_aff>,
3292 C<isl_union_pw_qpolynomial> and C<isl_union_pw_qpolynomial_fold>,
3293 there can be at most one base expression for a given domain space.
3294 In case of
3295 C<isl_union_pw_multi_aff>,
3296 there can be multiple such expressions for a given domain space,
3297 but the domains of these expressions need to be disjoint.
3299 An empty union expression can be created using the following functions.
3301         #include <isl/aff.h>
3302         __isl_give isl_union_pw_aff *isl_union_pw_aff_empty(
3303                 __isl_take isl_space *space);
3304         __isl_give isl_union_pw_multi_aff *
3305         isl_union_pw_multi_aff_empty(
3306                 __isl_take isl_space *space);
3308         #include <isl/polynomial.h>
3309         __isl_give isl_union_pw_qpolynomial *
3310         isl_union_pw_qpolynomial_zero(
3311                 __isl_take isl_space *space);
3313 A union expression containing a single base expression
3314 can be created using the following functions.
3316         #include <isl/aff.h>
3317         __isl_give isl_union_pw_aff *
3318         isl_union_pw_aff_from_pw_aff(
3319                 __isl_take isl_pw_aff *pa);
3320         __isl_give isl_union_pw_multi_aff *
3321         isl_union_pw_multi_aff_from_aff(
3322                 __isl_take isl_aff *aff);
3323         __isl_give isl_union_pw_multi_aff *
3324         isl_union_pw_multi_aff_from_pw_multi_aff(
3325                 __isl_take isl_pw_multi_aff *pma);
3327         #include <isl/polynomial.h>
3328         __isl_give isl_union_pw_qpolynomial *
3329         isl_union_pw_qpolynomial_from_pw_qpolynomial(
3330                 __isl_take isl_pw_qpolynomial *pwqp);
3332 The following functions create a base expression on each
3333 of the sets in the union set and collect the results.
3335         #include <isl/aff.h>
3336         __isl_give isl_union_pw_multi_aff *
3337         isl_union_pw_multi_aff_from_union_pw_aff(
3338                 __isl_take isl_union_pw_aff *upa);
3339         __isl_give isl_union_pw_aff *
3340         isl_union_pw_multi_aff_get_union_pw_aff(
3341                 __isl_keep isl_union_pw_multi_aff *upma, int pos);
3342         __isl_give isl_union_pw_aff *
3343         isl_union_pw_aff_val_on_domain(
3344                 __isl_take isl_union_set *domain,
3345                 __isl_take isl_val *v);
3346         __isl_give isl_union_pw_multi_aff *
3347         isl_union_pw_multi_aff_multi_val_on_domain(
3348                 __isl_take isl_union_set *domain,
3349                 __isl_take isl_multi_val *mv);
3350         __isl_give isl_union_pw_aff *
3351         isl_union_pw_aff_param_on_domain_id(
3352                 __isl_take isl_union_set *domain,
3353                 __isl_take isl_id *id);
3355 The C<id> argument of C<isl_union_pw_aff_param_on_domain_id>
3356 is the identifier of a parameter that may or may not already
3357 be present in C<domain>.
3359 An C<isl_union_pw_aff> that is equal to a (parametric) affine
3360 or piecewise affine
3361 expression on a given domain can be created using the following
3362 functions.
3364         #include <isl/aff.h>
3365         __isl_give isl_union_pw_aff *
3366         isl_union_pw_aff_aff_on_domain(
3367                 __isl_take isl_union_set *domain,
3368                 __isl_take isl_aff *aff);
3369         __isl_give isl_union_pw_aff *
3370         isl_union_pw_aff_pw_aff_on_domain(
3371                 __isl_take isl_union_set *domain,
3372                 __isl_take isl_pw_aff *pa);
3374 A base expression can be added to a union expression using
3375 the following functions.
3377         #include <isl/aff.h>
3378         __isl_give isl_union_pw_aff *
3379         isl_union_pw_aff_add_pw_aff(
3380                 __isl_take isl_union_pw_aff *upa,
3381                 __isl_take isl_pw_aff *pa);
3382         __isl_give isl_union_pw_multi_aff *
3383         isl_union_pw_multi_aff_add_pw_multi_aff(
3384                 __isl_take isl_union_pw_multi_aff *upma,
3385                 __isl_take isl_pw_multi_aff *pma);
3387         #include <isl/polynomial.h>
3388         __isl_give isl_union_pw_qpolynomial *
3389         isl_union_pw_qpolynomial_add_pw_qpolynomial(
3390                 __isl_take isl_union_pw_qpolynomial *upwqp,
3391                 __isl_take isl_pw_qpolynomial *pwqp);
3393 Union expressions can be copied and freed using
3394 the following functions.
3396         #include <isl/aff.h>
3397         __isl_give isl_union_pw_aff *isl_union_pw_aff_copy(
3398                 __isl_keep isl_union_pw_aff *upa);
3399         __isl_null isl_union_pw_aff *isl_union_pw_aff_free(
3400                 __isl_take isl_union_pw_aff *upa);
3401         __isl_give isl_union_pw_multi_aff *
3402         isl_union_pw_multi_aff_copy(
3403                 __isl_keep isl_union_pw_multi_aff *upma);
3404         __isl_null isl_union_pw_multi_aff *
3405         isl_union_pw_multi_aff_free(
3406                 __isl_take isl_union_pw_multi_aff *upma);
3408         #include <isl/polynomial.h>
3409         __isl_give isl_union_pw_qpolynomial *
3410         isl_union_pw_qpolynomial_copy(
3411                 __isl_keep isl_union_pw_qpolynomial *upwqp);
3412         __isl_null isl_union_pw_qpolynomial *
3413         isl_union_pw_qpolynomial_free(
3414                 __isl_take isl_union_pw_qpolynomial *upwqp);
3415         __isl_give isl_union_pw_qpolynomial_fold *
3416         isl_union_pw_qpolynomial_fold_copy(
3417                 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
3418         __isl_null isl_union_pw_qpolynomial_fold *
3419         isl_union_pw_qpolynomial_fold_free(
3420                 __isl_take isl_union_pw_qpolynomial_fold *upwf);
3422 To iterate over the base expressions in a union expression,
3423 use the following functions.
3425         #include <isl/aff.h>
3426         int isl_union_pw_aff_n_pw_aff(
3427                 __isl_keep isl_union_pw_aff *upa);
3428         isl_stat isl_union_pw_aff_foreach_pw_aff(
3429                 __isl_keep isl_union_pw_aff *upa,
3430                 isl_stat (*fn)(__isl_take isl_pw_aff *pa,
3431                         void *user), void *user);
3432         int isl_union_pw_multi_aff_n_pw_multi_aff(
3433                 __isl_keep isl_union_pw_multi_aff *upma);
3434         isl_stat isl_union_pw_multi_aff_foreach_pw_multi_aff(
3435                 __isl_keep isl_union_pw_multi_aff *upma,
3436                 isl_stat (*fn)(__isl_take isl_pw_multi_aff *pma,
3437                             void *user), void *user);
3439         #include <isl/polynomial.h>
3440         int isl_union_pw_qpolynomial_n_pw_qpolynomial(
3441                 __isl_keep isl_union_pw_qpolynomial *upwqp);
3442         isl_stat isl_union_pw_qpolynomial_foreach_pw_qpolynomial(
3443                 __isl_keep isl_union_pw_qpolynomial *upwqp,
3444                 isl_stat (*fn)(__isl_take isl_pw_qpolynomial *pwqp,
3445                             void *user), void *user);
3446         int isl_union_pw_qpolynomial_fold_n_pw_qpolynomial_fold(
3447                 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
3448         isl_stat isl_union_pw_qpolynomial_fold_foreach_pw_qpolynomial_fold(
3449                 __isl_keep isl_union_pw_qpolynomial_fold *upwf,
3450                 isl_stat (*fn)(__isl_take isl_pw_qpolynomial_fold *pwf,
3451                             void *user), void *user);
3453 To extract the base expression in a given space from a union, use
3454 the following functions.
3456         #include <isl/aff.h>
3457         __isl_give isl_pw_aff *isl_union_pw_aff_extract_pw_aff(
3458                 __isl_keep isl_union_pw_aff *upa,
3459                 __isl_take isl_space *space);
3460         __isl_give isl_pw_multi_aff *
3461         isl_union_pw_multi_aff_extract_pw_multi_aff(
3462                 __isl_keep isl_union_pw_multi_aff *upma,
3463                 __isl_take isl_space *space);
3465         #include <isl/polynomial.h>
3466         __isl_give isl_pw_qpolynomial *
3467         isl_union_pw_qpolynomial_extract_pw_qpolynomial(
3468                 __isl_keep isl_union_pw_qpolynomial *upwqp,
3469                 __isl_take isl_space *space);
3471 It is also possible to obtain a list of the base expressions using
3472 the following functions.
3474         #include <isl/aff.h>
3475         __isl_give isl_pw_aff_list *
3476         isl_union_pw_aff_get_pw_aff_list(
3477                 __isl_keep isl_union_pw_aff *upa);
3478         __isl_give isl_pw_multi_aff_list *
3479         isl_union_pw_multi_aff_get_pw_multi_aff_list(
3480                 __isl_keep isl_union_pw_multi_aff *upma);
3482         #include <isl/polynomial.h>
3483         __isl_give isl_pw_qpolynomial_list *
3484         isl_union_pw_qpolynomial_get_pw_qpolynomial_list(
3485                 __isl_keep isl_union_pw_qpolynomial *upwqp);
3486         __isl_give isl_pw_qpolynomial_fold_list *
3487         isl_union_pw_qpolynomial_fold_get_pw_qpolynomial_fold_list(
3488                 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
3490 The returned list can be manipulated using the functions in L<"Lists">.
3492 =head2 Input and Output
3494 For set and relation,
3495 C<isl> supports its own input/output format, which is similar
3496 to the C<Omega> format, but also supports the C<PolyLib> format
3497 in some cases.
3498 For other object types, typically only an C<isl> format is supported.
3500 =head3 C<isl> format
3502 The C<isl> format is similar to that of C<Omega>, but has a different
3503 syntax for describing the parameters and allows for the definition
3504 of an existentially quantified variable as the integer division
3505 of an affine expression.
3506 For example, the set of integers C<i> between C<0> and C<n>
3507 such that C<i % 10 <= 6> can be described as
3509         [n] -> { [i] : exists (a = [i/10] : 0 <= i and i <= n and
3510                                 i - 10 a <= 6) }
3512 A set or relation can have several disjuncts, separated
3513 by the keyword C<or>.  Each disjunct is either a conjunction
3514 of constraints or a projection (C<exists>) of a conjunction
3515 of constraints.  The constraints are separated by the keyword
3516 C<and>.
3518 =head3 C<PolyLib> format
3520 If the represented set is a union, then the first line
3521 contains a single number representing the number of disjuncts.
3522 Otherwise, a line containing the number C<1> is optional.
3524 Each disjunct is represented by a matrix of constraints.
3525 The first line contains two numbers representing
3526 the number of rows and columns,
3527 where the number of rows is equal to the number of constraints
3528 and the number of columns is equal to two plus the number of variables.
3529 The following lines contain the actual rows of the constraint matrix.
3530 In each row, the first column indicates whether the constraint
3531 is an equality (C<0>) or inequality (C<1>).  The final column
3532 corresponds to the constant term.
3534 If the set is parametric, then the coefficients of the parameters
3535 appear in the last columns before the constant column.
3536 The coefficients of any existentially quantified variables appear
3537 between those of the set variables and those of the parameters.
3539 =head3 Extended C<PolyLib> format
3541 The extended C<PolyLib> format is nearly identical to the
3542 C<PolyLib> format.  The only difference is that the line
3543 containing the number of rows and columns of a constraint matrix
3544 also contains four additional numbers:
3545 the number of output dimensions, the number of input dimensions,
3546 the number of local dimensions (i.e., the number of existentially
3547 quantified variables) and the number of parameters.
3548 For sets, the number of ``output'' dimensions is equal
3549 to the number of set dimensions, while the number of ``input''
3550 dimensions is zero.
3552 =head3 Input
3554 Objects can be read from input using the following functions.
3556         #include <isl/val.h>
3557         __isl_give isl_val *isl_val_read_from_str(isl_ctx *ctx,
3558                 const char *str);
3559         __isl_give isl_multi_val *isl_multi_val_read_from_str(
3560                 isl_ctx *ctx, const char *str);
3562         #include <isl/set.h>
3563         __isl_give isl_basic_set *isl_basic_set_read_from_file(
3564                 isl_ctx *ctx, FILE *input);
3565         __isl_give isl_basic_set *isl_basic_set_read_from_str(
3566                 isl_ctx *ctx, const char *str);
3567         __isl_give isl_set *isl_set_read_from_file(isl_ctx *ctx,
3568                 FILE *input);
3569         __isl_give isl_set *isl_set_read_from_str(isl_ctx *ctx,
3570                 const char *str);
3572         #include <isl/map.h>
3573         __isl_give isl_basic_map *isl_basic_map_read_from_file(
3574                 isl_ctx *ctx, FILE *input);
3575         __isl_give isl_basic_map *isl_basic_map_read_from_str(
3576                 isl_ctx *ctx, const char *str);
3577         __isl_give isl_map *isl_map_read_from_file(
3578                 isl_ctx *ctx, FILE *input);
3579         __isl_give isl_map *isl_map_read_from_str(isl_ctx *ctx,
3580                 const char *str);
3582         #include <isl/union_set.h>
3583         __isl_give isl_union_set *isl_union_set_read_from_file(
3584                 isl_ctx *ctx, FILE *input);
3585         __isl_give isl_union_set *isl_union_set_read_from_str(
3586                 isl_ctx *ctx, const char *str);
3588         #include <isl/union_map.h>
3589         __isl_give isl_union_map *isl_union_map_read_from_file(
3590                 isl_ctx *ctx, FILE *input);
3591         __isl_give isl_union_map *isl_union_map_read_from_str(
3592                 isl_ctx *ctx, const char *str);
3594         #include <isl/aff.h>
3595         __isl_give isl_aff *isl_aff_read_from_str(
3596                 isl_ctx *ctx, const char *str);
3597         __isl_give isl_multi_aff *isl_multi_aff_read_from_str(
3598                 isl_ctx *ctx, const char *str);
3599         __isl_give isl_pw_aff *isl_pw_aff_read_from_str(
3600                 isl_ctx *ctx, const char *str);
3601         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_read_from_str(
3602                 isl_ctx *ctx, const char *str);
3603         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_read_from_str(
3604                 isl_ctx *ctx, const char *str);
3605         __isl_give isl_union_pw_aff *
3606         isl_union_pw_aff_read_from_str(
3607                 isl_ctx *ctx, const char *str);
3608         __isl_give isl_union_pw_multi_aff *
3609         isl_union_pw_multi_aff_read_from_str(
3610                 isl_ctx *ctx, const char *str);
3611         __isl_give isl_multi_union_pw_aff *
3612         isl_multi_union_pw_aff_read_from_str(
3613                 isl_ctx *ctx, const char *str);
3615         #include <isl/polynomial.h>
3616         __isl_give isl_union_pw_qpolynomial *
3617         isl_union_pw_qpolynomial_read_from_str(
3618                 isl_ctx *ctx, const char *str);
3620 For sets and relations,
3621 the input format is autodetected and may be either the C<PolyLib> format
3622 or the C<isl> format.
3624 =head3 Output
3626 Before anything can be printed, an C<isl_printer> needs to
3627 be created.
3629         __isl_give isl_printer *isl_printer_to_file(isl_ctx *ctx,
3630                 FILE *file);
3631         __isl_give isl_printer *isl_printer_to_str(isl_ctx *ctx);
3632         __isl_null isl_printer *isl_printer_free(
3633                 __isl_take isl_printer *printer);
3635 C<isl_printer_to_file> prints to the given file, while
3636 C<isl_printer_to_str> prints to a string that can be extracted
3637 using the following function.
3639         #include <isl/printer.h>
3640         __isl_give char *isl_printer_get_str(
3641                 __isl_keep isl_printer *printer);
3643 The printer can be inspected using the following functions.
3645         FILE *isl_printer_get_file(
3646                 __isl_keep isl_printer *printer);
3647         int isl_printer_get_output_format(
3648                 __isl_keep isl_printer *p);
3649         int isl_printer_get_yaml_style(__isl_keep isl_printer *p);
3651 The behavior of the printer can be modified in various ways
3653         __isl_give isl_printer *isl_printer_set_output_format(
3654                 __isl_take isl_printer *p, int output_format);
3655         __isl_give isl_printer *isl_printer_set_indent(
3656                 __isl_take isl_printer *p, int indent);
3657         __isl_give isl_printer *isl_printer_set_indent_prefix(
3658                 __isl_take isl_printer *p, const char *prefix);
3659         __isl_give isl_printer *isl_printer_indent(
3660                 __isl_take isl_printer *p, int indent);
3661         __isl_give isl_printer *isl_printer_set_prefix(
3662                 __isl_take isl_printer *p, const char *prefix);
3663         __isl_give isl_printer *isl_printer_set_suffix(
3664                 __isl_take isl_printer *p, const char *suffix);
3665         __isl_give isl_printer *isl_printer_set_yaml_style(
3666                 __isl_take isl_printer *p, int yaml_style);
3668 The C<output_format> may be either C<ISL_FORMAT_ISL>, C<ISL_FORMAT_OMEGA>,
3669 C<ISL_FORMAT_POLYLIB>, C<ISL_FORMAT_EXT_POLYLIB> or C<ISL_FORMAT_LATEX>
3670 and defaults to C<ISL_FORMAT_ISL>.
3671 Each line in the output is prefixed by C<indent_prefix>,
3672 indented by C<indent> (set by C<isl_printer_set_indent>) spaces
3673 (default: 0), prefixed by C<prefix> and suffixed by C<suffix>.
3674 In the C<PolyLib> format output,
3675 the coefficients of the existentially quantified variables
3676 appear between those of the set variables and those
3677 of the parameters.
3678 The function C<isl_printer_indent> increases the indentation
3679 by the specified amount (which may be negative).
3680 The YAML style may be either C<ISL_YAML_STYLE_BLOCK> or
3681 C<ISL_YAML_STYLE_FLOW> and when we are printing something
3682 in YAML format.
3684 To actually print something, use
3686         #include <isl/printer.h>
3687         __isl_give isl_printer *isl_printer_print_double(
3688                 __isl_take isl_printer *p, double d);
3690         #include <isl/val.h>
3691         __isl_give isl_printer *isl_printer_print_val(
3692                 __isl_take isl_printer *p, __isl_keep isl_val *v);
3694         #include <isl/set.h>
3695         __isl_give isl_printer *isl_printer_print_basic_set(
3696                 __isl_take isl_printer *printer,
3697                 __isl_keep isl_basic_set *bset);
3698         __isl_give isl_printer *isl_printer_print_set(
3699                 __isl_take isl_printer *printer,
3700                 __isl_keep isl_set *set);
3702         #include <isl/map.h>
3703         __isl_give isl_printer *isl_printer_print_basic_map(
3704                 __isl_take isl_printer *printer,
3705                 __isl_keep isl_basic_map *bmap);
3706         __isl_give isl_printer *isl_printer_print_map(
3707                 __isl_take isl_printer *printer,
3708                 __isl_keep isl_map *map);
3710         #include <isl/union_set.h>
3711         __isl_give isl_printer *isl_printer_print_union_set(
3712                 __isl_take isl_printer *p,
3713                 __isl_keep isl_union_set *uset);
3715         #include <isl/union_map.h>
3716         __isl_give isl_printer *isl_printer_print_union_map(
3717                 __isl_take isl_printer *p,
3718                 __isl_keep isl_union_map *umap);
3720         #include <isl/val.h>
3721         __isl_give isl_printer *isl_printer_print_multi_val(
3722                 __isl_take isl_printer *p,
3723                 __isl_keep isl_multi_val *mv);
3725         #include <isl/aff.h>
3726         __isl_give isl_printer *isl_printer_print_aff(
3727                 __isl_take isl_printer *p, __isl_keep isl_aff *aff);
3728         __isl_give isl_printer *isl_printer_print_multi_aff(
3729                 __isl_take isl_printer *p,
3730                 __isl_keep isl_multi_aff *maff);
3731         __isl_give isl_printer *isl_printer_print_pw_aff(
3732                 __isl_take isl_printer *p,
3733                 __isl_keep isl_pw_aff *pwaff);
3734         __isl_give isl_printer *isl_printer_print_pw_multi_aff(
3735                 __isl_take isl_printer *p,
3736                 __isl_keep isl_pw_multi_aff *pma);
3737         __isl_give isl_printer *isl_printer_print_multi_pw_aff(
3738                 __isl_take isl_printer *p,
3739                 __isl_keep isl_multi_pw_aff *mpa);
3740         __isl_give isl_printer *isl_printer_print_union_pw_aff(
3741                 __isl_take isl_printer *p,
3742                 __isl_keep isl_union_pw_aff *upa);
3743         __isl_give isl_printer *isl_printer_print_union_pw_multi_aff(
3744                 __isl_take isl_printer *p,
3745                 __isl_keep isl_union_pw_multi_aff *upma);
3746         __isl_give isl_printer *
3747         isl_printer_print_multi_union_pw_aff(
3748                 __isl_take isl_printer *p,
3749                 __isl_keep isl_multi_union_pw_aff *mupa);
3751         #include <isl/polynomial.h>
3752         __isl_give isl_printer *isl_printer_print_qpolynomial(
3753                 __isl_take isl_printer *p,
3754                 __isl_keep isl_qpolynomial *qp);
3755         __isl_give isl_printer *isl_printer_print_pw_qpolynomial(
3756                 __isl_take isl_printer *p,
3757                 __isl_keep isl_pw_qpolynomial *pwqp);
3758         __isl_give isl_printer *isl_printer_print_union_pw_qpolynomial(
3759                 __isl_take isl_printer *p,
3760                 __isl_keep isl_union_pw_qpolynomial *upwqp);
3762         __isl_give isl_printer *
3763         isl_printer_print_pw_qpolynomial_fold(
3764                 __isl_take isl_printer *p,
3765                 __isl_keep isl_pw_qpolynomial_fold *pwf);
3766         __isl_give isl_printer *
3767         isl_printer_print_union_pw_qpolynomial_fold(
3768                 __isl_take isl_printer *p,
3769                 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
3771 For C<isl_printer_print_qpolynomial>,
3772 C<isl_printer_print_pw_qpolynomial> and
3773 C<isl_printer_print_pw_qpolynomial_fold>,
3774 the output format of the printer
3775 needs to be set to either C<ISL_FORMAT_ISL> or C<ISL_FORMAT_C>.
3776 For C<isl_printer_print_union_pw_qpolynomial> and
3777 C<isl_printer_print_union_pw_qpolynomial_fold>, only C<ISL_FORMAT_ISL>
3778 is supported.
3779 In case of printing in C<ISL_FORMAT_C>, the user may want
3780 to set the names of all dimensions first.
3782 C<isl> also provides limited support for printing YAML documents,
3783 just enough for the internal use for printing such documents.
3785         #include <isl/printer.h>
3786         __isl_give isl_printer *isl_printer_yaml_start_mapping(
3787                 __isl_take isl_printer *p);
3788         __isl_give isl_printer *isl_printer_yaml_end_mapping(
3789                 __isl_take isl_printer *p);
3790         __isl_give isl_printer *isl_printer_yaml_start_sequence(
3791                 __isl_take isl_printer *p);
3792         __isl_give isl_printer *isl_printer_yaml_end_sequence(
3793                 __isl_take isl_printer *p);
3794         __isl_give isl_printer *isl_printer_yaml_next(
3795                 __isl_take isl_printer *p);
3797 A document is started by a call to either
3798 C<isl_printer_yaml_start_mapping> or C<isl_printer_yaml_start_sequence>.
3799 Anything printed to the printer after such a call belong to the
3800 first key of the mapping or the first element in the sequence.
3801 The function C<isl_printer_yaml_next> moves to the value if
3802 we are currently printing a mapping key, the next key if we
3803 are printing a value or the next element if we are printing
3804 an element in a sequence.
3805 Nested mappings and sequences are initiated by the same
3806 C<isl_printer_yaml_start_mapping> or C<isl_printer_yaml_start_sequence>.
3807 Each call to these functions needs to have a corresponding call to
3808 C<isl_printer_yaml_end_mapping> or C<isl_printer_yaml_end_sequence>.
3810 When called on a file printer, the following function flushes
3811 the file.  When called on a string printer, the buffer is cleared.
3813         __isl_give isl_printer *isl_printer_flush(
3814                 __isl_take isl_printer *p);
3816 The following functions allow the user to attach
3817 notes to a printer in order to keep track of additional state.
3819         #include <isl/printer.h>
3820         isl_bool isl_printer_has_note(__isl_keep isl_printer *p,
3821                 __isl_keep isl_id *id);
3822         __isl_give isl_id *isl_printer_get_note(
3823                 __isl_keep isl_printer *p, __isl_take isl_id *id);
3824         __isl_give isl_printer *isl_printer_set_note(
3825                 __isl_take isl_printer *p,
3826                 __isl_take isl_id *id, __isl_take isl_id *note);
3828 C<isl_printer_set_note> associates the given note to the given
3829 identifier in the printer.
3830 C<isl_printer_get_note> retrieves a note associated to an
3831 identifier, while
3832 C<isl_printer_has_note> checks if there is such a note.
3833 C<isl_printer_get_note> fails if the requested note does not exist.
3835 Alternatively, a string representation can be obtained
3836 directly using the following functions, which always print
3837 in isl format.
3839         #include <isl/id.h>
3840         __isl_give char *isl_id_to_str(
3841                 __isl_keep isl_id *id);
3843         #include <isl/space.h>
3844         __isl_give char *isl_space_to_str(
3845                 __isl_keep isl_space *space);
3847         #include <isl/val.h>
3848         __isl_give char *isl_val_to_str(__isl_keep isl_val *v);
3849         __isl_give char *isl_multi_val_to_str(
3850                 __isl_keep isl_multi_val *mv);
3852         #include <isl/set.h>
3853         __isl_give char *isl_basic_set_to_str(
3854                 __isl_keep isl_basic_set *bset);
3855         __isl_give char *isl_set_to_str(
3856                 __isl_keep isl_set *set);
3858         #include <isl/union_set.h>
3859         __isl_give char *isl_union_set_to_str(
3860                 __isl_keep isl_union_set *uset);
3862         #include <isl/map.h>
3863         __isl_give char *isl_basic_map_to_str(
3864                 __isl_keep isl_basic_map *bmap);
3865         __isl_give char *isl_map_to_str(
3866                 __isl_keep isl_map *map);
3868         #include <isl/union_map.h>
3869         __isl_give char *isl_union_map_to_str(
3870                 __isl_keep isl_union_map *umap);
3872         #include <isl/aff.h>
3873         __isl_give char *isl_aff_to_str(__isl_keep isl_aff *aff);
3874         __isl_give char *isl_pw_aff_to_str(
3875                 __isl_keep isl_pw_aff *pa);
3876         __isl_give char *isl_multi_aff_to_str(
3877                 __isl_keep isl_multi_aff *ma);
3878         __isl_give char *isl_pw_multi_aff_to_str(
3879                 __isl_keep isl_pw_multi_aff *pma);
3880         __isl_give char *isl_multi_pw_aff_to_str(
3881                 __isl_keep isl_multi_pw_aff *mpa);
3882         __isl_give char *isl_union_pw_aff_to_str(
3883                 __isl_keep isl_union_pw_aff *upa);
3884         __isl_give char *isl_union_pw_multi_aff_to_str(
3885                 __isl_keep isl_union_pw_multi_aff *upma);
3886         __isl_give char *isl_multi_union_pw_aff_to_str(
3887                 __isl_keep isl_multi_union_pw_aff *mupa);
3889         #include <isl/point.h>
3890         __isl_give char *isl_point_to_str(
3891                 __isl_keep isl_point *pnt);
3893         #include <isl/polynomial.h>
3894         __isl_give char *isl_pw_qpolynomial_to_str(
3895                 __isl_keep isl_pw_qpolynomial *pwqp);
3896         __isl_give char *isl_union_pw_qpolynomial_to_str(
3897                 __isl_keep isl_union_pw_qpolynomial *upwqp);
3899 =head2 Properties
3901 =head3 Unary Properties
3903 =over
3905 =item * Emptiness
3907 The following functions test whether the given set or relation
3908 contains any integer points.  The ``plain'' variants do not perform
3909 any computations, but simply check if the given set or relation
3910 is already known to be empty.
3912         #include <isl/set.h>
3913         isl_bool isl_basic_set_plain_is_empty(
3914                 __isl_keep isl_basic_set *bset);
3915         isl_bool isl_basic_set_is_empty(
3916                 __isl_keep isl_basic_set *bset);
3917         isl_bool isl_set_plain_is_empty(
3918                 __isl_keep isl_set *set);
3919         isl_bool isl_set_is_empty(__isl_keep isl_set *set);
3921         #include <isl/union_set.h>
3922         isl_bool isl_union_set_is_empty(
3923                 __isl_keep isl_union_set *uset);
3925         #include <isl/map.h>
3926         isl_bool isl_basic_map_plain_is_empty(
3927                 __isl_keep isl_basic_map *bmap);
3928         isl_bool isl_basic_map_is_empty(
3929                 __isl_keep isl_basic_map *bmap);
3930         isl_bool isl_map_plain_is_empty(
3931                 __isl_keep isl_map *map);
3932         isl_bool isl_map_is_empty(__isl_keep isl_map *map);
3934         #include <isl/union_map.h>
3935         isl_bool isl_union_map_plain_is_empty(
3936                 __isl_keep isl_union_map *umap);
3937         isl_bool isl_union_map_is_empty(
3938                 __isl_keep isl_union_map *umap);
3940 =item * Universality
3942         isl_bool isl_basic_set_plain_is_universe(
3943                 __isl_keep isl_basic_set *bset);
3944         isl_bool isl_basic_set_is_universe(
3945                 __isl_keep isl_basic_set *bset);
3946         isl_bool isl_basic_map_plain_is_universe(
3947                 __isl_keep isl_basic_map *bmap);
3948         isl_bool isl_basic_map_is_universe(
3949                 __isl_keep isl_basic_map *bmap);
3950         isl_bool isl_set_plain_is_universe(
3951                 __isl_keep isl_set *set);
3952         isl_bool isl_map_plain_is_universe(
3953                 __isl_keep isl_map *map);
3955 =item * Single-valuedness
3957         #include <isl/set.h>
3958         isl_bool isl_set_is_singleton(__isl_keep isl_set *set);
3960         #include <isl/map.h>
3961         isl_bool isl_basic_map_is_single_valued(
3962                 __isl_keep isl_basic_map *bmap);
3963         isl_bool isl_map_plain_is_single_valued(
3964                 __isl_keep isl_map *map);
3965         isl_bool isl_map_is_single_valued(__isl_keep isl_map *map);
3967         #include <isl/union_map.h>
3968         isl_bool isl_union_map_is_single_valued(
3969                 __isl_keep isl_union_map *umap);
3971 =item * Injectivity
3973         isl_bool isl_map_plain_is_injective(
3974                 __isl_keep isl_map *map);
3975         isl_bool isl_map_is_injective(
3976                 __isl_keep isl_map *map);
3977         isl_bool isl_union_map_plain_is_injective(
3978                 __isl_keep isl_union_map *umap);
3979         isl_bool isl_union_map_is_injective(
3980                 __isl_keep isl_union_map *umap);
3982 =item * Bijectivity
3984         isl_bool isl_map_is_bijective(
3985                 __isl_keep isl_map *map);
3986         isl_bool isl_union_map_is_bijective(
3987                 __isl_keep isl_union_map *umap);
3989 =item * Identity
3991 The following functions test whether the given relation
3992 only maps elements to themselves.
3994         #include <isl/map.h>
3995         isl_bool isl_map_is_identity(
3996                 __isl_keep isl_map *map);
3998         #include <isl/union_map.h>
3999         isl_bool isl_union_map_is_identity(
4000                 __isl_keep isl_union_map *umap);
4002 =item * Position
4004         __isl_give isl_val *
4005         isl_basic_map_plain_get_val_if_fixed(
4006                 __isl_keep isl_basic_map *bmap,
4007                 enum isl_dim_type type, unsigned pos);
4008         __isl_give isl_val *isl_set_plain_get_val_if_fixed(
4009                 __isl_keep isl_set *set,
4010                 enum isl_dim_type type, unsigned pos);
4011         __isl_give isl_val *isl_map_plain_get_val_if_fixed(
4012                 __isl_keep isl_map *map,
4013                 enum isl_dim_type type, unsigned pos);
4015 If the set or relation obviously lies on a hyperplane where the given dimension
4016 has a fixed value, then return that value.
4017 Otherwise return NaN.
4019 =item * Stride
4021         isl_stat isl_set_dim_residue_class_val(
4022                 __isl_keep isl_set *set,
4023                 int pos, __isl_give isl_val **modulo,
4024                 __isl_give isl_val **residue);
4026 Check if the values of the given set dimension are equal to a fixed
4027 value modulo some integer value.  If so, assign the modulo to C<*modulo>
4028 and the fixed value to C<*residue>.  If the given dimension attains only
4029 a single value, then assign C<0> to C<*modulo> and the fixed value to
4030 C<*residue>.
4031 If the dimension does not attain only a single value and if no modulo
4032 can be found then assign C<1> to C<*modulo> and C<1> to C<*residue>.
4034         #include <isl/set.h>
4035         __isl_give isl_stride_info *isl_set_get_stride_info(
4036                 __isl_keep isl_set *set, int pos);
4037         __isl_give isl_val *isl_set_get_stride(
4038                 __isl_keep isl_set *set, int pos);
4040         #include <isl/map.h>
4041         __isl_give isl_stride_info *
4042         isl_map_get_range_stride_info(
4043                 __isl_keep isl_map *map, int pos);
4045 Check if the values of the given set dimension are equal to
4046 some affine expression of the other dimensions (the offset)
4047 modulo some integer stride or
4048 check if the values of the given output dimensions are equal to
4049 some affine expression of the input dimensions (the offset)
4050 modulo some integer stride.
4051 If no more specific information can be found, then the stride
4052 is taken to be one and the offset is taken to be the zero expression.
4053 The function C<isl_set_get_stride> performs the same
4054 computation as C<isl_set_get_stride_info> but only returns the stride.
4055 For the other functions,
4056 the stride and offset can be extracted from the returned object
4057 using the following functions.
4059         #include <isl/stride_info.h>
4060         __isl_give isl_val *isl_stride_info_get_stride(
4061                 __isl_keep isl_stride_info *si);
4062         __isl_give isl_aff *isl_stride_info_get_offset(
4063                 __isl_keep isl_stride_info *si);
4065 The stride info object can be copied and released using the following
4066 functions.
4068         #include <isl/stride_info.h>
4069         __isl_give isl_stride_info *isl_stride_info_copy(
4070                 __isl_keep isl_stride_info *si);
4071         __isl_null isl_stride_info *isl_stride_info_free(
4072                 __isl_take isl_stride_info *si);
4074 =item * Dependence
4076 To check whether the description of a set, relation or function depends
4077 on one or more given dimensions,
4078 the following functions can be used.
4080         #include <isl/constraint.h>
4081         isl_bool isl_constraint_involves_dims(
4082                 __isl_keep isl_constraint *constraint,
4083                 enum isl_dim_type type, unsigned first, unsigned n);
4085         #include <isl/set.h>
4086         isl_bool isl_basic_set_involves_dims(
4087                 __isl_keep isl_basic_set *bset,
4088                 enum isl_dim_type type, unsigned first, unsigned n);
4089         isl_bool isl_set_involves_dims(__isl_keep isl_set *set,
4090                 enum isl_dim_type type, unsigned first, unsigned n);
4092         #include <isl/map.h>
4093         isl_bool isl_basic_map_involves_dims(
4094                 __isl_keep isl_basic_map *bmap,
4095                 enum isl_dim_type type, unsigned first, unsigned n);
4096         isl_bool isl_map_involves_dims(__isl_keep isl_map *map,
4097                 enum isl_dim_type type, unsigned first, unsigned n);
4099         #include <isl/union_map.h>
4100         isl_bool isl_union_map_involves_dims(
4101                 __isl_keep isl_union_map *umap,
4102                 enum isl_dim_type type, unsigned first, unsigned n);
4104         #include <isl/aff.h>
4105         isl_bool isl_aff_involves_dims(__isl_keep isl_aff *aff,
4106                 enum isl_dim_type type, unsigned first, unsigned n);
4107         isl_bool isl_pw_aff_involves_dims(
4108                 __isl_keep isl_pw_aff *pwaff,
4109                 enum isl_dim_type type, unsigned first, unsigned n);
4110         isl_bool isl_multi_aff_involves_dims(
4111                 __isl_keep isl_multi_aff *ma,
4112                 enum isl_dim_type type, unsigned first, unsigned n);
4113         isl_bool isl_pw_multi_aff_involves_dims(
4114                 __isl_keep isl_pw_multi_aff *pma,
4115                 enum isl_dim_type type, unsigned first, unsigned n);
4116         isl_bool isl_multi_pw_aff_involves_dims(
4117                 __isl_keep isl_multi_pw_aff *mpa,
4118                 enum isl_dim_type type, unsigned first, unsigned n);
4120         #include <isl/polynomial.h>
4121         isl_bool isl_qpolynomial_involves_dims(
4122                 __isl_keep isl_qpolynomial *qp,
4123                 enum isl_dim_type type, unsigned first, unsigned n);
4125 Similarly, the following functions can be used to check whether
4126 a given dimension is involved in any lower or upper bound.
4128         #include <isl/set.h>
4129         isl_bool isl_set_dim_has_any_lower_bound(
4130                 __isl_keep isl_set *set,
4131                 enum isl_dim_type type, unsigned pos);
4132         isl_bool isl_set_dim_has_any_upper_bound(
4133                 __isl_keep isl_set *set,
4134                 enum isl_dim_type type, unsigned pos);
4136 Note that these functions return true even if there is a bound on
4137 the dimension on only some of the basic sets of C<set>.
4138 To check if they have a bound for all of the basic sets in C<set>,
4139 use the following functions instead.
4141         #include <isl/set.h>
4142         isl_bool isl_set_dim_has_lower_bound(
4143                 __isl_keep isl_set *set,
4144                 enum isl_dim_type type, unsigned pos);
4145         isl_bool isl_set_dim_has_upper_bound(
4146                 __isl_keep isl_set *set,
4147                 enum isl_dim_type type, unsigned pos);
4149 =item * Space
4151 To check whether a set is a parameter domain, use this function:
4153         isl_bool isl_set_is_params(__isl_keep isl_set *set);
4154         isl_bool isl_union_set_is_params(
4155                 __isl_keep isl_union_set *uset);
4157 =item * Wrapping
4159 The following functions check whether the space of the given
4160 (basic) set or relation domain and/or range is a wrapped relation.
4162         #include <isl/space.h>
4163         isl_bool isl_space_is_wrapping(
4164                 __isl_keep isl_space *space);
4165         isl_bool isl_space_domain_is_wrapping(
4166                 __isl_keep isl_space *space);
4167         isl_bool isl_space_range_is_wrapping(
4168                 __isl_keep isl_space *space);
4169         isl_bool isl_space_is_product(
4170                 __isl_keep isl_space *space);
4172         #include <isl/set.h>
4173         isl_bool isl_basic_set_is_wrapping(
4174                 __isl_keep isl_basic_set *bset);
4175         isl_bool isl_set_is_wrapping(__isl_keep isl_set *set);
4177         #include <isl/map.h>
4178         isl_bool isl_map_domain_is_wrapping(
4179                 __isl_keep isl_map *map);
4180         isl_bool isl_map_range_is_wrapping(
4181                 __isl_keep isl_map *map);
4182         isl_bool isl_map_is_product(__isl_keep isl_map *map);
4184         #include <isl/val.h>
4185         isl_bool isl_multi_val_range_is_wrapping(
4186                 __isl_keep isl_multi_val *mv);
4188         #include <isl/aff.h>
4189         isl_bool isl_multi_aff_range_is_wrapping(
4190                 __isl_keep isl_multi_aff *ma);
4191         isl_bool isl_multi_pw_aff_range_is_wrapping(
4192                 __isl_keep isl_multi_pw_aff *mpa);
4193         isl_bool isl_multi_union_pw_aff_range_is_wrapping(
4194                 __isl_keep isl_multi_union_pw_aff *mupa);
4196 The input to C<isl_space_is_wrapping> should
4197 be the space of a set, while that of
4198 C<isl_space_domain_is_wrapping> and
4199 C<isl_space_range_is_wrapping> should be the space of a relation.
4200 The input to C<isl_space_is_product> can be either the space
4201 of a set or that of a binary relation.
4202 In case the input is the space of a binary relation, it checks
4203 whether both domain and range are wrapping.
4205 =item * Internal Product
4207         isl_bool isl_basic_map_can_zip(
4208                 __isl_keep isl_basic_map *bmap);
4209         isl_bool isl_map_can_zip(__isl_keep isl_map *map);
4211 Check whether the product of domain and range of the given relation
4212 can be computed,
4213 i.e., whether both domain and range are nested relations.
4215 =item * Currying
4217         #include <isl/space.h>
4218         isl_bool isl_space_can_curry(
4219                 __isl_keep isl_space *space);
4221         #include <isl/map.h>
4222         isl_bool isl_basic_map_can_curry(
4223                 __isl_keep isl_basic_map *bmap);
4224         isl_bool isl_map_can_curry(__isl_keep isl_map *map);
4226 Check whether the domain of the (basic) relation is a wrapped relation.
4228         #include <isl/space.h>
4229         __isl_give isl_space *isl_space_uncurry(
4230                 __isl_take isl_space *space);
4232         #include <isl/map.h>
4233         isl_bool isl_basic_map_can_uncurry(
4234                 __isl_keep isl_basic_map *bmap);
4235         isl_bool isl_map_can_uncurry(__isl_keep isl_map *map);
4237 Check whether the range of the (basic) relation is a wrapped relation.
4239         #include <isl/space.h>
4240         isl_bool isl_space_can_range_curry(
4241                 __isl_keep isl_space *space);
4243         #include <isl/map.h>
4244         isl_bool isl_map_can_range_curry(
4245                 __isl_keep isl_map *map);
4247 Check whether the domain of the relation wrapped in the range of
4248 the input is itself a wrapped relation.
4250 =item * Special Values
4252         #include <isl/aff.h>
4253         isl_bool isl_aff_is_cst(__isl_keep isl_aff *aff);
4254         isl_bool isl_pw_aff_is_cst(__isl_keep isl_pw_aff *pwaff);
4255         isl_bool isl_multi_pw_aff_is_cst(
4256                 __isl_keep isl_multi_pw_aff *mpa);
4258 Check whether the given expression is a constant.
4260         #include <isl/val.h>
4261         isl_bool isl_multi_val_involves_nan(
4262                 __isl_keep isl_multi_val *mv);
4264         #include <isl/aff.h>
4265         isl_bool isl_aff_is_nan(__isl_keep isl_aff *aff);
4266         isl_bool isl_multi_aff_involves_nan(
4267                 __isl_keep isl_multi_aff *ma);
4268         isl_bool isl_pw_aff_involves_nan(
4269                 __isl_keep isl_pw_aff *pa);
4270         isl_bool isl_pw_multi_aff_involves_nan(
4271                 __isl_keep isl_pw_multi_aff *pma);
4272         isl_bool isl_multi_pw_aff_involves_nan(
4273                 __isl_keep isl_multi_pw_aff *mpa);
4274         isl_bool isl_union_pw_aff_involves_nan(
4275                 __isl_keep isl_union_pw_aff *upa);
4276         isl_bool isl_union_pw_multi_aff_involves_nan(
4277                 __isl_keep isl_union_pw_multi_aff *upma);
4278         isl_bool isl_multi_union_pw_aff_involves_nan(
4279                 __isl_keep isl_multi_union_pw_aff *mupa);
4281         #include <isl/polynomial.h>
4282         isl_bool isl_qpolynomial_is_nan(
4283                 __isl_keep isl_qpolynomial *qp);
4284         isl_bool isl_qpolynomial_fold_is_nan(
4285                 __isl_keep isl_qpolynomial_fold *fold);
4286         isl_bool isl_pw_qpolynomial_involves_nan(
4287                 __isl_keep isl_pw_qpolynomial *pwqp);
4288         isl_bool isl_pw_qpolynomial_fold_involves_nan(
4289                 __isl_keep isl_pw_qpolynomial_fold *pwf);
4290         isl_bool isl_union_pw_qpolynomial_involves_nan(
4291                 __isl_keep isl_union_pw_qpolynomial *upwqp);
4292         isl_bool isl_union_pw_qpolynomial_fold_involves_nan(
4293                 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
4295 Check whether the given expression is equal to or involves NaN.
4297         #include <isl/aff.h>
4298         isl_bool isl_aff_plain_is_zero(
4299                 __isl_keep isl_aff *aff);
4301 Check whether the affine expression is obviously zero.
4303 =back
4305 =head3 Binary Properties
4307 =over
4309 =item * Equality
4311 The following functions check whether two objects
4312 represent the same set, relation or function.
4313 The C<plain> variants only return true if the objects
4314 are obviously the same.  That is, they may return false
4315 even if the objects are the same, but they will never
4316 return true if the objects are not the same.
4318         #include <isl/set.h>
4319         isl_bool isl_basic_set_plain_is_equal(
4320                 __isl_keep isl_basic_set *bset1,
4321                 __isl_keep isl_basic_set *bset2);
4322         isl_bool isl_basic_set_is_equal(
4323                 __isl_keep isl_basic_set *bset1,
4324                 __isl_keep isl_basic_set *bset2);
4325         isl_bool isl_set_plain_is_equal(
4326                 __isl_keep isl_set *set1,
4327                 __isl_keep isl_set *set2);
4328         isl_bool isl_set_is_equal(__isl_keep isl_set *set1,
4329                 __isl_keep isl_set *set2);
4331         #include <isl/map.h>
4332         isl_bool isl_basic_map_is_equal(
4333                 __isl_keep isl_basic_map *bmap1,
4334                 __isl_keep isl_basic_map *bmap2);
4335         isl_bool isl_map_is_equal(__isl_keep isl_map *map1,
4336                 __isl_keep isl_map *map2);
4337         isl_bool isl_map_plain_is_equal(
4338                 __isl_keep isl_map *map1,
4339                 __isl_keep isl_map *map2);
4341         #include <isl/union_set.h>
4342         isl_bool isl_union_set_is_equal(
4343                 __isl_keep isl_union_set *uset1,
4344                 __isl_keep isl_union_set *uset2);
4346         #include <isl/union_map.h>
4347         isl_bool isl_union_map_is_equal(
4348                 __isl_keep isl_union_map *umap1,
4349                 __isl_keep isl_union_map *umap2);
4351         #include <isl/val.h>
4352         isl_bool isl_multi_val_plain_is_equal(
4353                 __isl_keep isl_multi_val *mv1,
4354                 __isl_keep isl_multi_val *mv2);
4356         #include <isl/aff.h>
4357         isl_bool isl_aff_plain_is_equal(
4358                 __isl_keep isl_aff *aff1,
4359                 __isl_keep isl_aff *aff2);
4360         isl_bool isl_multi_aff_plain_is_equal(
4361                 __isl_keep isl_multi_aff *maff1,
4362                 __isl_keep isl_multi_aff *maff2);
4363         isl_bool isl_pw_aff_plain_is_equal(
4364                 __isl_keep isl_pw_aff *pwaff1,
4365                 __isl_keep isl_pw_aff *pwaff2);
4366         isl_bool isl_pw_aff_is_equal(
4367                 __isl_keep isl_pw_aff *pa1,
4368                 __isl_keep isl_pw_aff *pa2);
4369         isl_bool isl_pw_multi_aff_plain_is_equal(
4370                 __isl_keep isl_pw_multi_aff *pma1,
4371                 __isl_keep isl_pw_multi_aff *pma2);
4372         isl_bool isl_pw_multi_aff_is_equal(
4373                 __isl_keep isl_pw_multi_aff *pma1,
4374                 __isl_keep isl_pw_multi_aff *pma2);
4375         isl_bool isl_multi_pw_aff_plain_is_equal(
4376                 __isl_keep isl_multi_pw_aff *mpa1,
4377                 __isl_keep isl_multi_pw_aff *mpa2);
4378         isl_bool isl_multi_pw_aff_is_equal(
4379                 __isl_keep isl_multi_pw_aff *mpa1,
4380                 __isl_keep isl_multi_pw_aff *mpa2);
4381         isl_bool isl_union_pw_aff_plain_is_equal(
4382                 __isl_keep isl_union_pw_aff *upa1,
4383                 __isl_keep isl_union_pw_aff *upa2);
4384         isl_bool isl_union_pw_multi_aff_plain_is_equal(
4385                 __isl_keep isl_union_pw_multi_aff *upma1,
4386                 __isl_keep isl_union_pw_multi_aff *upma2);
4387         isl_bool isl_multi_union_pw_aff_plain_is_equal(
4388                 __isl_keep isl_multi_union_pw_aff *mupa1,
4389                 __isl_keep isl_multi_union_pw_aff *mupa2);
4391         #include <isl/polynomial.h>
4392         isl_bool isl_union_pw_qpolynomial_plain_is_equal(
4393                 __isl_keep isl_union_pw_qpolynomial *upwqp1,
4394                 __isl_keep isl_union_pw_qpolynomial *upwqp2);
4395         isl_bool isl_union_pw_qpolynomial_fold_plain_is_equal(
4396                 __isl_keep isl_union_pw_qpolynomial_fold *upwf1,
4397                 __isl_keep isl_union_pw_qpolynomial_fold *upwf2);
4399 =item * Disjointness
4401         #include <isl/set.h>
4402         isl_bool isl_basic_set_is_disjoint(
4403                 __isl_keep isl_basic_set *bset1,
4404                 __isl_keep isl_basic_set *bset2);
4405         isl_bool isl_set_plain_is_disjoint(
4406                 __isl_keep isl_set *set1,
4407                 __isl_keep isl_set *set2);
4408         isl_bool isl_set_is_disjoint(__isl_keep isl_set *set1,
4409                 __isl_keep isl_set *set2);
4411         #include <isl/map.h>
4412         isl_bool isl_basic_map_is_disjoint(
4413                 __isl_keep isl_basic_map *bmap1,
4414                 __isl_keep isl_basic_map *bmap2);
4415         isl_bool isl_map_is_disjoint(__isl_keep isl_map *map1,
4416                 __isl_keep isl_map *map2);
4418         #include <isl/union_set.h>
4419         isl_bool isl_union_set_is_disjoint(
4420                 __isl_keep isl_union_set *uset1,
4421                 __isl_keep isl_union_set *uset2);
4423         #include <isl/union_map.h>
4424         isl_bool isl_union_map_is_disjoint(
4425                 __isl_keep isl_union_map *umap1,
4426                 __isl_keep isl_union_map *umap2);
4428 =item * Subset
4430         isl_bool isl_basic_set_is_subset(
4431                 __isl_keep isl_basic_set *bset1,
4432                 __isl_keep isl_basic_set *bset2);
4433         isl_bool isl_set_is_subset(__isl_keep isl_set *set1,
4434                 __isl_keep isl_set *set2);
4435         isl_bool isl_set_is_strict_subset(
4436                 __isl_keep isl_set *set1,
4437                 __isl_keep isl_set *set2);
4438         isl_bool isl_union_set_is_subset(
4439                 __isl_keep isl_union_set *uset1,
4440                 __isl_keep isl_union_set *uset2);
4441         isl_bool isl_union_set_is_strict_subset(
4442                 __isl_keep isl_union_set *uset1,
4443                 __isl_keep isl_union_set *uset2);
4444         isl_bool isl_basic_map_is_subset(
4445                 __isl_keep isl_basic_map *bmap1,
4446                 __isl_keep isl_basic_map *bmap2);
4447         isl_bool isl_basic_map_is_strict_subset(
4448                 __isl_keep isl_basic_map *bmap1,
4449                 __isl_keep isl_basic_map *bmap2);
4450         isl_bool isl_map_is_subset(
4451                 __isl_keep isl_map *map1,
4452                 __isl_keep isl_map *map2);
4453         isl_bool isl_map_is_strict_subset(
4454                 __isl_keep isl_map *map1,
4455                 __isl_keep isl_map *map2);
4456         isl_bool isl_union_map_is_subset(
4457                 __isl_keep isl_union_map *umap1,
4458                 __isl_keep isl_union_map *umap2);
4459         isl_bool isl_union_map_is_strict_subset(
4460                 __isl_keep isl_union_map *umap1,
4461                 __isl_keep isl_union_map *umap2);
4463 Check whether the first argument is a (strict) subset of the
4464 second argument.
4466 =item * Order
4468 Every comparison function returns a negative value if the first
4469 argument is considered smaller than the second, a positive value
4470 if the first argument is considered greater and zero if the two
4471 constraints are considered the same by the comparison criterion.
4473         #include <isl/constraint.h>
4474         int isl_constraint_plain_cmp(
4475                 __isl_keep isl_constraint *c1,
4476                 __isl_keep isl_constraint *c2);
4478 This function is useful for sorting C<isl_constraint>s.
4479 The order depends on the internal representation of the inputs.
4480 The order is fixed over different calls to the function (assuming
4481 the internal representation of the inputs has not changed), but may
4482 change over different versions of C<isl>.
4484         #include <isl/constraint.h>
4485         int isl_constraint_cmp_last_non_zero(
4486                 __isl_keep isl_constraint *c1,
4487                 __isl_keep isl_constraint *c2);
4489 This function can be used to sort constraints that live in the same
4490 local space.  Constraints that involve ``earlier'' dimensions or
4491 that have a smaller coefficient for the shared latest dimension
4492 are considered smaller than other constraints.
4493 This function only defines a B<partial> order.
4495         #include <isl/set.h>
4496         int isl_set_plain_cmp(__isl_keep isl_set *set1,
4497                 __isl_keep isl_set *set2);
4499 This function is useful for sorting C<isl_set>s.
4500 The order depends on the internal representation of the inputs.
4501 The order is fixed over different calls to the function (assuming
4502 the internal representation of the inputs has not changed), but may
4503 change over different versions of C<isl>.
4505         #include <isl/aff.h>
4506         int isl_multi_aff_plain_cmp(
4507                 __isl_keep isl_multi_aff *ma1,
4508                 __isl_keep isl_multi_aff *ma2);
4509         int isl_pw_aff_plain_cmp(__isl_keep isl_pw_aff *pa1,
4510                 __isl_keep isl_pw_aff *pa2);
4512 The functions C<isl_multi_aff_plain_cmp> and
4513 C<isl_pw_aff_plain_cmp> can be used to sort C<isl_multi_aff>s and
4514 C<isl_pw_aff>s.  The order is not strictly defined.
4515 The current order sorts expressions that only involve
4516 earlier dimensions before those that involve later dimensions.
4518 =back
4520 =head2 Unary Operations
4522 =over
4524 =item * Complement
4526         __isl_give isl_set *isl_set_complement(
4527                 __isl_take isl_set *set);
4528         __isl_give isl_map *isl_map_complement(
4529                 __isl_take isl_map *map);
4531 =item * Inverse map
4533         #include <isl/space.h>
4534         __isl_give isl_space *isl_space_reverse(
4535                 __isl_take isl_space *space);
4537         #include <isl/map.h>
4538         __isl_give isl_basic_map *isl_basic_map_reverse(
4539                 __isl_take isl_basic_map *bmap);
4540         __isl_give isl_map *isl_map_reverse(
4541                 __isl_take isl_map *map);
4543         #include <isl/union_map.h>
4544         __isl_give isl_union_map *isl_union_map_reverse(
4545                 __isl_take isl_union_map *umap);
4547 =item * Projection
4549         #include <isl/space.h>
4550         __isl_give isl_space *isl_space_domain(
4551                 __isl_take isl_space *space);
4552         __isl_give isl_space *isl_space_range(
4553                 __isl_take isl_space *space);
4554         __isl_give isl_space *isl_space_params(
4555                 __isl_take isl_space *space);
4557         #include <isl/local_space.h>
4558         __isl_give isl_local_space *isl_local_space_domain(
4559                 __isl_take isl_local_space *ls);
4560         __isl_give isl_local_space *isl_local_space_range(
4561                 __isl_take isl_local_space *ls);
4563         #include <isl/set.h>
4564         __isl_give isl_basic_set *isl_basic_set_project_out(
4565                 __isl_take isl_basic_set *bset,
4566                 enum isl_dim_type type, unsigned first, unsigned n);
4567         __isl_give isl_set *isl_set_project_out(__isl_take isl_set *set,
4568                 enum isl_dim_type type, unsigned first, unsigned n);
4569         __isl_give isl_map *isl_set_project_onto_map(
4570                 __isl_take isl_set *set,
4571                 enum isl_dim_type type, unsigned first,
4572                 unsigned n);
4573         __isl_give isl_basic_set *isl_basic_set_params(
4574                 __isl_take isl_basic_set *bset);
4575         __isl_give isl_set *isl_set_params(__isl_take isl_set *set);
4577 The function C<isl_set_project_onto_map> returns a relation
4578 that projects the input set onto the given set dimensions.
4580         #include <isl/map.h>
4581         __isl_give isl_basic_map *isl_basic_map_project_out(
4582                 __isl_take isl_basic_map *bmap,
4583                 enum isl_dim_type type, unsigned first, unsigned n);
4584         __isl_give isl_map *isl_map_project_out(__isl_take isl_map *map,
4585                 enum isl_dim_type type, unsigned first, unsigned n);
4586         __isl_give isl_basic_set *isl_basic_map_domain(
4587                 __isl_take isl_basic_map *bmap);
4588         __isl_give isl_basic_set *isl_basic_map_range(
4589                 __isl_take isl_basic_map *bmap);
4590         __isl_give isl_set *isl_map_params(__isl_take isl_map *map);
4591         __isl_give isl_set *isl_map_domain(
4592                 __isl_take isl_map *bmap);
4593         __isl_give isl_set *isl_map_range(
4594                 __isl_take isl_map *map);
4596         #include <isl/union_set.h>
4597         __isl_give isl_union_set *isl_union_set_project_out(
4598                 __isl_take isl_union_set *uset,
4599                 enum isl_dim_type type,
4600                 unsigned first, unsigned n);
4601         __isl_give isl_set *isl_union_set_params(
4602                 __isl_take isl_union_set *uset);
4604 The function C<isl_union_set_project_out> can only project out
4605 parameters.
4607         #include <isl/union_map.h>
4608         __isl_give isl_union_map *isl_union_map_project_out(
4609                 __isl_take isl_union_map *umap,
4610                 enum isl_dim_type type, unsigned first, unsigned n);
4611         __isl_give isl_union_map *
4612         isl_union_map_project_out_all_params(
4613                 __isl_take isl_union_map *umap);
4614         __isl_give isl_set *isl_union_map_params(
4615                 __isl_take isl_union_map *umap);
4616         __isl_give isl_union_set *isl_union_map_domain(
4617                 __isl_take isl_union_map *umap);
4618         __isl_give isl_union_set *isl_union_map_range(
4619                 __isl_take isl_union_map *umap);
4621 The function C<isl_union_map_project_out> can only project out
4622 parameters.
4624         #include <isl/aff.h>
4625         __isl_give isl_aff *isl_aff_project_domain_on_params(
4626                 __isl_take isl_aff *aff);
4627         __isl_give isl_multi_aff *
4628         isl_multi_aff_project_domain_on_params(
4629                 __isl_take isl_multi_aff *ma);
4630         __isl_give isl_pw_aff *
4631         isl_pw_aff_project_domain_on_params(
4632                 __isl_take isl_pw_aff *pa);
4633         __isl_give isl_multi_pw_aff *
4634         isl_multi_pw_aff_project_domain_on_params(
4635                 __isl_take isl_multi_pw_aff *mpa);
4636         __isl_give isl_pw_multi_aff *
4637         isl_pw_multi_aff_project_domain_on_params(
4638                 __isl_take isl_pw_multi_aff *pma);
4639         __isl_give isl_set *isl_pw_aff_domain(
4640                 __isl_take isl_pw_aff *pwaff);
4641         __isl_give isl_set *isl_pw_multi_aff_domain(
4642                 __isl_take isl_pw_multi_aff *pma);
4643         __isl_give isl_set *isl_multi_pw_aff_domain(
4644                 __isl_take isl_multi_pw_aff *mpa);
4645         __isl_give isl_union_set *isl_union_pw_aff_domain(
4646                 __isl_take isl_union_pw_aff *upa);
4647         __isl_give isl_union_set *isl_union_pw_multi_aff_domain(
4648                 __isl_take isl_union_pw_multi_aff *upma);
4649         __isl_give isl_union_set *
4650         isl_multi_union_pw_aff_domain(
4651                 __isl_take isl_multi_union_pw_aff *mupa);
4652         __isl_give isl_set *isl_pw_aff_params(
4653                 __isl_take isl_pw_aff *pwa);
4655 If no explicit domain was set on a zero-dimensional input to
4656 C<isl_multi_union_pw_aff_domain>, then this function will
4657 return a parameter set.
4659         #include <isl/polynomial.h>
4660         __isl_give isl_qpolynomial *
4661         isl_qpolynomial_project_domain_on_params(
4662                 __isl_take isl_qpolynomial *qp);
4663         __isl_give isl_pw_qpolynomial *
4664         isl_pw_qpolynomial_project_domain_on_params(
4665                 __isl_take isl_pw_qpolynomial *pwqp);
4666         __isl_give isl_pw_qpolynomial_fold *
4667         isl_pw_qpolynomial_fold_project_domain_on_params(
4668                 __isl_take isl_pw_qpolynomial_fold *pwf);
4669         __isl_give isl_set *isl_pw_qpolynomial_domain(
4670                 __isl_take isl_pw_qpolynomial *pwqp);
4671         __isl_give isl_union_set *isl_union_pw_qpolynomial_fold_domain(
4672                 __isl_take isl_union_pw_qpolynomial_fold *upwf);
4673         __isl_give isl_union_set *isl_union_pw_qpolynomial_domain(
4674                 __isl_take isl_union_pw_qpolynomial *upwqp);
4676         #include <isl/space.h>
4677         __isl_give isl_space *isl_space_domain_map(
4678                 __isl_take isl_space *space);
4679         __isl_give isl_space *isl_space_range_map(
4680                 __isl_take isl_space *space);
4682         #include <isl/map.h>
4683         __isl_give isl_map *isl_set_wrapped_domain_map(
4684                 __isl_take isl_set *set);
4685         __isl_give isl_basic_map *isl_basic_map_domain_map(
4686                 __isl_take isl_basic_map *bmap);
4687         __isl_give isl_basic_map *isl_basic_map_range_map(
4688                 __isl_take isl_basic_map *bmap);
4689         __isl_give isl_map *isl_map_domain_map(__isl_take isl_map *map);
4690         __isl_give isl_map *isl_map_range_map(__isl_take isl_map *map);
4692         #include <isl/union_map.h>
4693         __isl_give isl_union_map *isl_union_map_domain_map(
4694                 __isl_take isl_union_map *umap);
4695         __isl_give isl_union_pw_multi_aff *
4696         isl_union_map_domain_map_union_pw_multi_aff(
4697                 __isl_take isl_union_map *umap);
4698         __isl_give isl_union_map *isl_union_map_range_map(
4699                 __isl_take isl_union_map *umap);
4700         __isl_give isl_union_map *
4701         isl_union_set_wrapped_domain_map(
4702                 __isl_take isl_union_set *uset);
4704 The functions above construct a (basic, regular or union) relation
4705 that maps (a wrapped version of) the input relation to its domain or range.
4706 C<isl_set_wrapped_domain_map> maps the input set to the domain
4707 of its wrapped relation.
4709 =item * Elimination
4711         __isl_give isl_basic_set *isl_basic_set_eliminate(
4712                 __isl_take isl_basic_set *bset,
4713                 enum isl_dim_type type,
4714                 unsigned first, unsigned n);
4715         __isl_give isl_set *isl_set_eliminate(
4716                 __isl_take isl_set *set, enum isl_dim_type type,
4717                 unsigned first, unsigned n);
4718         __isl_give isl_basic_map *isl_basic_map_eliminate(
4719                 __isl_take isl_basic_map *bmap,
4720                 enum isl_dim_type type,
4721                 unsigned first, unsigned n);
4722         __isl_give isl_map *isl_map_eliminate(
4723                 __isl_take isl_map *map, enum isl_dim_type type,
4724                 unsigned first, unsigned n);
4726 Eliminate the coefficients for the given dimensions from the constraints,
4727 without removing the dimensions.
4729 =item * Constructing a set from a parameter domain
4731 A zero-dimensional (local) space or (basic) set can be constructed
4732 on a given parameter domain using the following functions.
4734         #include <isl/space.h>
4735         __isl_give isl_space *isl_space_set_from_params(
4736                 __isl_take isl_space *space);
4738         #include <isl/local_space.h>
4739         __isl_give isl_local_space *
4740         isl_local_space_set_from_params(
4741                 __isl_take isl_local_space *ls);
4743         #include <isl/set.h>
4744         __isl_give isl_basic_set *isl_basic_set_from_params(
4745                 __isl_take isl_basic_set *bset);
4746         __isl_give isl_set *isl_set_from_params(
4747                 __isl_take isl_set *set);
4749 =item * Constructing a relation from one or two sets
4751 Create a relation with the given set(s) as domain and/or range.
4752 If only the domain or the range is specified, then
4753 the range or domain of the created relation is a zero-dimensional
4754 flat anonymous space.
4756         #include <isl/space.h>
4757         __isl_give isl_space *isl_space_from_domain(
4758                 __isl_take isl_space *space);
4759         __isl_give isl_space *isl_space_from_range(
4760                 __isl_take isl_space *space);
4761         __isl_give isl_space *isl_space_map_from_set(
4762                 __isl_take isl_space *space);
4763         __isl_give isl_space *isl_space_map_from_domain_and_range(
4764                 __isl_take isl_space *domain,
4765                 __isl_take isl_space *range);
4767         #include <isl/local_space.h>
4768         __isl_give isl_local_space *isl_local_space_from_domain(
4769                 __isl_take isl_local_space *ls);
4771         #include <isl/map.h>
4772         __isl_give isl_map *isl_map_from_domain(
4773                 __isl_take isl_set *set);
4774         __isl_give isl_map *isl_map_from_range(
4775                 __isl_take isl_set *set);
4777         #include <isl/union_map.h>
4778         __isl_give isl_union_map *isl_union_map_from_domain(
4779                 __isl_take isl_union_set *uset);
4780         __isl_give isl_union_map *isl_union_map_from_range(
4781                 __isl_take isl_union_set *uset);
4782         __isl_give isl_union_map *
4783         isl_union_map_from_domain_and_range(
4784                 __isl_take isl_union_set *domain,
4785                 __isl_take isl_union_set *range);
4787         #include <isl/val.h>
4788         __isl_give isl_multi_val *isl_multi_val_from_range(
4789                 __isl_take isl_multi_val *mv);
4791         #include <isl/aff.h>
4792         __isl_give isl_aff *isl_aff_from_range(
4793                 __isl_take isl_aff *aff);
4794         __isl_give isl_multi_aff *isl_multi_aff_from_range(
4795                 __isl_take isl_multi_aff *ma);
4796         __isl_give isl_pw_aff *isl_pw_aff_from_range(
4797                 __isl_take isl_pw_aff *pwa);
4798         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_range(
4799                 __isl_take isl_multi_pw_aff *mpa);
4800         __isl_give isl_multi_union_pw_aff *
4801         isl_multi_union_pw_aff_from_range(
4802                 __isl_take isl_multi_union_pw_aff *mupa);
4803         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_domain(
4804                 __isl_take isl_set *set);
4805         __isl_give isl_union_pw_multi_aff *
4806         isl_union_pw_multi_aff_from_domain(
4807                 __isl_take isl_union_set *uset);
4809         #include <isl/polynomial.h>
4810         __isl_give isl_pw_qpolynomial *
4811         isl_pw_qpolynomial_from_range(
4812                 __isl_take isl_pw_qpolynomial *pwqp);
4813         __isl_give isl_pw_qpolynomial_fold *
4814         isl_pw_qpolynomial_fold_from_range(
4815                 __isl_take isl_pw_qpolynomial_fold *pwf);
4817 =item * Slicing
4819         #include <isl/set.h>
4820         __isl_give isl_basic_set *isl_basic_set_fix_si(
4821                 __isl_take isl_basic_set *bset,
4822                 enum isl_dim_type type, unsigned pos, int value);
4823         __isl_give isl_basic_set *isl_basic_set_fix_val(
4824                 __isl_take isl_basic_set *bset,
4825                 enum isl_dim_type type, unsigned pos,
4826                 __isl_take isl_val *v);
4827         __isl_give isl_set *isl_set_fix_si(__isl_take isl_set *set,
4828                 enum isl_dim_type type, unsigned pos, int value);
4829         __isl_give isl_set *isl_set_fix_val(
4830                 __isl_take isl_set *set,
4831                 enum isl_dim_type type, unsigned pos,
4832                 __isl_take isl_val *v);
4834         #include <isl/map.h>
4835         __isl_give isl_basic_map *isl_basic_map_fix_si(
4836                 __isl_take isl_basic_map *bmap,
4837                 enum isl_dim_type type, unsigned pos, int value);
4838         __isl_give isl_basic_map *isl_basic_map_fix_val(
4839                 __isl_take isl_basic_map *bmap,
4840                 enum isl_dim_type type, unsigned pos,
4841                 __isl_take isl_val *v);
4842         __isl_give isl_map *isl_map_fix_si(__isl_take isl_map *map,
4843                 enum isl_dim_type type, unsigned pos, int value);
4844         __isl_give isl_map *isl_map_fix_val(
4845                 __isl_take isl_map *map,
4846                 enum isl_dim_type type, unsigned pos,
4847                 __isl_take isl_val *v);
4849         #include <isl/aff.h>
4850         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_fix_si(
4851                 __isl_take isl_pw_multi_aff *pma,
4852                 enum isl_dim_type type, unsigned pos, int value);
4854         #include <isl/polynomial.h>
4855         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_fix_val(
4856                 __isl_take isl_pw_qpolynomial *pwqp,
4857                 enum isl_dim_type type, unsigned n,
4858                 __isl_take isl_val *v);
4859         __isl_give isl_pw_qpolynomial_fold *
4860         isl_pw_qpolynomial_fold_fix_val(
4861                 __isl_take isl_pw_qpolynomial_fold *pwf,
4862                 enum isl_dim_type type, unsigned n,
4863                 __isl_take isl_val *v);
4865 Intersect the set, relation or function domain
4866 with the hyperplane where the given
4867 dimension has the fixed given value.
4869         #include <isl/set.h>
4870         __isl_give isl_basic_set *
4871         isl_basic_set_lower_bound_val(
4872                 __isl_take isl_basic_set *bset,
4873                 enum isl_dim_type type, unsigned pos,
4874                 __isl_take isl_val *value);
4875         __isl_give isl_basic_set *
4876         isl_basic_set_upper_bound_val(
4877                 __isl_take isl_basic_set *bset,
4878                 enum isl_dim_type type, unsigned pos,
4879                 __isl_take isl_val *value);
4880         __isl_give isl_set *isl_set_lower_bound_si(
4881                 __isl_take isl_set *set,
4882                 enum isl_dim_type type, unsigned pos, int value);
4883         __isl_give isl_set *isl_set_lower_bound_val(
4884                 __isl_take isl_set *set,
4885                 enum isl_dim_type type, unsigned pos,
4886                 __isl_take isl_val *value);
4887         __isl_give isl_set *isl_set_upper_bound_si(
4888                 __isl_take isl_set *set,
4889                 enum isl_dim_type type, unsigned pos, int value);
4890         __isl_give isl_set *isl_set_upper_bound_val(
4891                 __isl_take isl_set *set,
4892                 enum isl_dim_type type, unsigned pos,
4893                 __isl_take isl_val *value);
4895         #include <isl/map.h>
4896         __isl_give isl_basic_map *isl_basic_map_lower_bound_si(
4897                 __isl_take isl_basic_map *bmap,
4898                 enum isl_dim_type type, unsigned pos, int value);
4899         __isl_give isl_basic_map *isl_basic_map_upper_bound_si(
4900                 __isl_take isl_basic_map *bmap,
4901                 enum isl_dim_type type, unsigned pos, int value);
4902         __isl_give isl_map *isl_map_lower_bound_si(
4903                 __isl_take isl_map *map,
4904                 enum isl_dim_type type, unsigned pos, int value);
4905         __isl_give isl_map *isl_map_upper_bound_si(
4906                 __isl_take isl_map *map,
4907                 enum isl_dim_type type, unsigned pos, int value);
4909 Intersect the set or relation with the half-space where the given
4910 dimension has a value bounded by the fixed given integer value.
4912         __isl_give isl_set *isl_set_equate(__isl_take isl_set *set,
4913                 enum isl_dim_type type1, int pos1,
4914                 enum isl_dim_type type2, int pos2);
4915         __isl_give isl_basic_map *isl_basic_map_equate(
4916                 __isl_take isl_basic_map *bmap,
4917                 enum isl_dim_type type1, int pos1,
4918                 enum isl_dim_type type2, int pos2);
4919         __isl_give isl_map *isl_map_equate(__isl_take isl_map *map,
4920                 enum isl_dim_type type1, int pos1,
4921                 enum isl_dim_type type2, int pos2);
4923 Intersect the set or relation with the hyperplane where the given
4924 dimensions are equal to each other.
4926         __isl_give isl_map *isl_map_oppose(__isl_take isl_map *map,
4927                 enum isl_dim_type type1, int pos1,
4928                 enum isl_dim_type type2, int pos2);
4930 Intersect the relation with the hyperplane where the given
4931 dimensions have opposite values.
4933         __isl_give isl_map *isl_map_order_le(
4934                 __isl_take isl_map *map,
4935                 enum isl_dim_type type1, int pos1,
4936                 enum isl_dim_type type2, int pos2);
4937         __isl_give isl_basic_map *isl_basic_map_order_ge(
4938                 __isl_take isl_basic_map *bmap,
4939                 enum isl_dim_type type1, int pos1,
4940                 enum isl_dim_type type2, int pos2);
4941         __isl_give isl_map *isl_map_order_ge(
4942                 __isl_take isl_map *map,
4943                 enum isl_dim_type type1, int pos1,
4944                 enum isl_dim_type type2, int pos2);
4945         __isl_give isl_map *isl_map_order_lt(__isl_take isl_map *map,
4946                 enum isl_dim_type type1, int pos1,
4947                 enum isl_dim_type type2, int pos2);
4948         __isl_give isl_basic_map *isl_basic_map_order_gt(
4949                 __isl_take isl_basic_map *bmap,
4950                 enum isl_dim_type type1, int pos1,
4951                 enum isl_dim_type type2, int pos2);
4952         __isl_give isl_map *isl_map_order_gt(__isl_take isl_map *map,
4953                 enum isl_dim_type type1, int pos1,
4954                 enum isl_dim_type type2, int pos2);
4956 Intersect the relation with the half-space where the given
4957 dimensions satisfy the given ordering.
4959         #include <isl/union_set.h>
4960         __isl_give isl_union_map *isl_union_map_remove_map_if(
4961                 __isl_take isl_union_map *umap,
4962                 isl_bool (*fn)(__isl_keep isl_map *map,
4963                         void *user), void *user);
4965 This function calls the callback function once for each
4966 pair of spaces for which there are elements in the input.
4967 If the callback returns C<isl_bool_true>, then all those elements
4968 are removed from the result.  The only remaining elements in the output
4969 are then those for which the callback returns C<isl_bool_false>.
4971 =item * Locus
4973         #include <isl/aff.h>
4974         __isl_give isl_basic_set *isl_aff_zero_basic_set(
4975                 __isl_take isl_aff *aff);
4976         __isl_give isl_basic_set *isl_aff_neg_basic_set(
4977                 __isl_take isl_aff *aff);
4978         __isl_give isl_set *isl_pw_aff_pos_set(
4979                 __isl_take isl_pw_aff *pa);
4980         __isl_give isl_set *isl_pw_aff_nonneg_set(
4981                 __isl_take isl_pw_aff *pwaff);
4982         __isl_give isl_set *isl_pw_aff_zero_set(
4983                 __isl_take isl_pw_aff *pwaff);
4984         __isl_give isl_set *isl_pw_aff_non_zero_set(
4985                 __isl_take isl_pw_aff *pwaff);
4986         __isl_give isl_union_set *
4987         isl_union_pw_aff_zero_union_set(
4988                 __isl_take isl_union_pw_aff *upa);
4989         __isl_give isl_union_set *
4990         isl_multi_union_pw_aff_zero_union_set(
4991                 __isl_take isl_multi_union_pw_aff *mupa);
4993 The function C<isl_aff_neg_basic_set> returns a basic set
4994 containing those elements in the domain space
4995 of C<aff> where C<aff> is negative.
4996 The function C<isl_pw_aff_nonneg_set> returns a set
4997 containing those elements in the domain
4998 of C<pwaff> where C<pwaff> is non-negative.
4999 The function C<isl_multi_union_pw_aff_zero_union_set>
5000 returns a union set containing those elements
5001 in the domains of its elements where they are all zero.
5003 =item * Identity
5005         __isl_give isl_map *isl_set_identity(
5006                 __isl_take isl_set *set);
5007         __isl_give isl_union_map *isl_union_set_identity(
5008                 __isl_take isl_union_set *uset);
5009         __isl_give isl_union_pw_multi_aff *
5010         isl_union_set_identity_union_pw_multi_aff(
5011                 __isl_take isl_union_set *uset);
5013 Construct an identity relation on the given (union) set.
5015 =item * Function Extraction
5017 A piecewise quasi affine expression that is equal to 1 on a set
5018 and 0 outside the set can be created using the following function.
5020         #include <isl/aff.h>
5021         __isl_give isl_pw_aff *isl_set_indicator_function(
5022                 __isl_take isl_set *set);
5024 A piecewise multiple quasi affine expression can be extracted
5025 from an C<isl_set> or C<isl_map>, provided the C<isl_set> is a singleton
5026 and the C<isl_map> is single-valued.
5027 In case of a conversion from an C<isl_union_map>
5028 to an C<isl_union_pw_multi_aff>, these properties need to hold
5029 in each domain space.
5030 A conversion to a C<isl_multi_union_pw_aff> additionally
5031 requires that the input is non-empty and involves only a single
5032 range space.
5034         #include <isl/aff.h>
5035         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_set(
5036                 __isl_take isl_set *set);
5037         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_map(
5038                 __isl_take isl_map *map);
5040         __isl_give isl_union_pw_multi_aff *
5041         isl_union_pw_multi_aff_from_union_set(
5042                 __isl_take isl_union_set *uset);
5043         __isl_give isl_union_pw_multi_aff *
5044         isl_union_pw_multi_aff_from_union_map(
5045                 __isl_take isl_union_map *umap);
5047         __isl_give isl_multi_union_pw_aff *
5048         isl_multi_union_pw_aff_from_union_map(
5049                 __isl_take isl_union_map *umap);
5051 =item * Deltas
5053         __isl_give isl_basic_set *isl_basic_map_deltas(
5054                 __isl_take isl_basic_map *bmap);
5055         __isl_give isl_set *isl_map_deltas(__isl_take isl_map *map);
5056         __isl_give isl_union_set *isl_union_map_deltas(
5057                 __isl_take isl_union_map *umap);
5059 These functions return a (basic) set containing the differences
5060 between image elements and corresponding domain elements in the input.
5062         __isl_give isl_basic_map *isl_basic_map_deltas_map(
5063                 __isl_take isl_basic_map *bmap);
5064         __isl_give isl_map *isl_map_deltas_map(
5065                 __isl_take isl_map *map);
5066         __isl_give isl_union_map *isl_union_map_deltas_map(
5067                 __isl_take isl_union_map *umap);
5069 The functions above construct a (basic, regular or union) relation
5070 that maps (a wrapped version of) the input relation to its delta set.
5072 =item * Coalescing
5074 Simplify the representation of a set, relation or functions by trying
5075 to combine pairs of basic sets or relations into a single
5076 basic set or relation.
5078         #include <isl/set.h>
5079         __isl_give isl_set *isl_set_coalesce(__isl_take isl_set *set);
5081         #include <isl/map.h>
5082         __isl_give isl_map *isl_map_coalesce(__isl_take isl_map *map);
5084         #include <isl/union_set.h>
5085         __isl_give isl_union_set *isl_union_set_coalesce(
5086                 __isl_take isl_union_set *uset);
5088         #include <isl/union_map.h>
5089         __isl_give isl_union_map *isl_union_map_coalesce(
5090                 __isl_take isl_union_map *umap);
5092         #include <isl/aff.h>
5093         __isl_give isl_pw_aff *isl_pw_aff_coalesce(
5094                 __isl_take isl_pw_aff *pwqp);
5095         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_coalesce(
5096                 __isl_take isl_pw_multi_aff *pma);
5097         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_coalesce(
5098                 __isl_take isl_multi_pw_aff *mpa);
5099         __isl_give isl_union_pw_aff *isl_union_pw_aff_coalesce(
5100                 __isl_take isl_union_pw_aff *upa);
5101         __isl_give isl_union_pw_multi_aff *
5102         isl_union_pw_multi_aff_coalesce(
5103                 __isl_take isl_union_pw_multi_aff *upma);
5104         __isl_give isl_multi_union_pw_aff *
5105         isl_multi_union_pw_aff_coalesce(
5106                 __isl_take isl_multi_union_pw_aff *aff);
5108         #include <isl/polynomial.h>
5109         __isl_give isl_pw_qpolynomial_fold *
5110         isl_pw_qpolynomial_fold_coalesce(
5111                 __isl_take isl_pw_qpolynomial_fold *pwf);
5112         __isl_give isl_union_pw_qpolynomial *
5113         isl_union_pw_qpolynomial_coalesce(
5114                 __isl_take isl_union_pw_qpolynomial *upwqp);
5115         __isl_give isl_union_pw_qpolynomial_fold *
5116         isl_union_pw_qpolynomial_fold_coalesce(
5117                 __isl_take isl_union_pw_qpolynomial_fold *upwf);
5119 One of the methods for combining pairs of basic sets or relations
5120 can result in coefficients that are much larger than those that appear
5121 in the constraints of the input.  By default, the coefficients are
5122 not allowed to grow larger, but this can be changed by unsetting
5123 the following option.
5125         isl_stat isl_options_set_coalesce_bounded_wrapping(
5126                 isl_ctx *ctx, int val);
5127         int isl_options_get_coalesce_bounded_wrapping(
5128                 isl_ctx *ctx);
5130 =item * Detecting equalities
5132         __isl_give isl_basic_set *isl_basic_set_detect_equalities(
5133                 __isl_take isl_basic_set *bset);
5134         __isl_give isl_basic_map *isl_basic_map_detect_equalities(
5135                 __isl_take isl_basic_map *bmap);
5136         __isl_give isl_set *isl_set_detect_equalities(
5137                 __isl_take isl_set *set);
5138         __isl_give isl_map *isl_map_detect_equalities(
5139                 __isl_take isl_map *map);
5140         __isl_give isl_union_set *isl_union_set_detect_equalities(
5141                 __isl_take isl_union_set *uset);
5142         __isl_give isl_union_map *isl_union_map_detect_equalities(
5143                 __isl_take isl_union_map *umap);
5145 Simplify the representation of a set or relation by detecting implicit
5146 equalities.
5148 =item * Removing redundant constraints
5150         #include <isl/set.h>
5151         __isl_give isl_basic_set *isl_basic_set_remove_redundancies(
5152                 __isl_take isl_basic_set *bset);
5153         __isl_give isl_set *isl_set_remove_redundancies(
5154                 __isl_take isl_set *set);
5156         #include <isl/union_set.h>
5157         __isl_give isl_union_set *
5158         isl_union_set_remove_redundancies(
5159                 __isl_take isl_union_set *uset);
5161         #include <isl/map.h>
5162         __isl_give isl_basic_map *isl_basic_map_remove_redundancies(
5163                 __isl_take isl_basic_map *bmap);
5164         __isl_give isl_map *isl_map_remove_redundancies(
5165                 __isl_take isl_map *map);
5167         #include <isl/union_map.h>
5168         __isl_give isl_union_map *
5169         isl_union_map_remove_redundancies(
5170                 __isl_take isl_union_map *umap);
5172 =item * Convex hull
5174         __isl_give isl_basic_set *isl_set_convex_hull(
5175                 __isl_take isl_set *set);
5176         __isl_give isl_basic_map *isl_map_convex_hull(
5177                 __isl_take isl_map *map);
5179 If the input set or relation has any existentially quantified
5180 variables, then the result of these operations is currently undefined.
5182 =item * Simple hull
5184         #include <isl/set.h>
5185         __isl_give isl_basic_set *
5186         isl_set_unshifted_simple_hull(
5187                 __isl_take isl_set *set);
5188         __isl_give isl_basic_set *isl_set_simple_hull(
5189                 __isl_take isl_set *set);
5190         __isl_give isl_basic_set *
5191         isl_set_plain_unshifted_simple_hull(
5192                 __isl_take isl_set *set);
5193         __isl_give isl_basic_set *
5194         isl_set_unshifted_simple_hull_from_set_list(
5195                 __isl_take isl_set *set,
5196                 __isl_take isl_set_list *list);
5198         #include <isl/map.h>
5199         __isl_give isl_basic_map *
5200         isl_map_unshifted_simple_hull(
5201                 __isl_take isl_map *map);
5202         __isl_give isl_basic_map *isl_map_simple_hull(
5203                 __isl_take isl_map *map);
5204         __isl_give isl_basic_map *
5205         isl_map_plain_unshifted_simple_hull(
5206                 __isl_take isl_map *map);
5207                 __isl_give isl_basic_map *
5208         isl_map_unshifted_simple_hull_from_map_list(
5209                 __isl_take isl_map *map,
5210                 __isl_take isl_map_list *list);
5212         #include <isl/union_map.h>
5213         __isl_give isl_union_map *isl_union_map_simple_hull(
5214                 __isl_take isl_union_map *umap);
5216 These functions compute a single basic set or relation
5217 that contains the whole input set or relation.
5218 In particular, the output is described by translates
5219 of the constraints describing the basic sets or relations in the input.
5220 In case of C<isl_set_unshifted_simple_hull>, only the original
5221 constraints are used, without any translation.
5222 In case of C<isl_set_plain_unshifted_simple_hull> and
5223 C<isl_map_plain_unshifted_simple_hull>, the result is described
5224 by original constraints that are obviously satisfied
5225 by the entire input set or relation.
5226 In case of C<isl_set_unshifted_simple_hull_from_set_list> and
5227 C<isl_map_unshifted_simple_hull_from_map_list>, the
5228 constraints are taken from the elements of the second argument.
5230 =begin latex
5232 (See \autoref{s:simple hull}.)
5234 =end latex
5236 =item * Affine hull
5238         __isl_give isl_basic_set *isl_basic_set_affine_hull(
5239                 __isl_take isl_basic_set *bset);
5240         __isl_give isl_basic_set *isl_set_affine_hull(
5241                 __isl_take isl_set *set);
5242         __isl_give isl_union_set *isl_union_set_affine_hull(
5243                 __isl_take isl_union_set *uset);
5244         __isl_give isl_basic_map *isl_basic_map_affine_hull(
5245                 __isl_take isl_basic_map *bmap);
5246         __isl_give isl_basic_map *isl_map_affine_hull(
5247                 __isl_take isl_map *map);
5248         __isl_give isl_union_map *isl_union_map_affine_hull(
5249                 __isl_take isl_union_map *umap);
5251 In case of union sets and relations, the affine hull is computed
5252 per space.
5254 =item * Polyhedral hull
5256         __isl_give isl_basic_set *isl_set_polyhedral_hull(
5257                 __isl_take isl_set *set);
5258         __isl_give isl_basic_map *isl_map_polyhedral_hull(
5259                 __isl_take isl_map *map);
5260         __isl_give isl_union_set *isl_union_set_polyhedral_hull(
5261                 __isl_take isl_union_set *uset);
5262         __isl_give isl_union_map *isl_union_map_polyhedral_hull(
5263                 __isl_take isl_union_map *umap);
5265 These functions compute a single basic set or relation
5266 not involving any existentially quantified variables
5267 that contains the whole input set or relation.
5268 In case of union sets and relations, the polyhedral hull is computed
5269 per space.
5271 =item * Box hull
5273         #include <isl/map.h>
5274         __isl_give isl_fixed_box *
5275         isl_map_get_range_simple_fixed_box_hull(
5276                 __isl_keep isl_map *map);
5278 This function tries to approximate the range of the map by a box of fixed size.
5279 The box is described in terms of an offset living in the same space as
5280 the input map and a size living in the range space.  For any element
5281 in the input map, the range value is greater than or equal to
5282 the offset applied to the domain value and the difference with
5283 this offset is strictly smaller than the size.
5284 If no fixed-size approximation of the range can be found,
5285 an I<invalid> box is returned, i.e., one for which
5286 C<isl_fixed_box_is_valid> below returns false.
5288 The validity, the offset and the size of the box can be obtained using
5289 the following functions.
5291         #include <isl/fixed_box.h>
5292         isl_bool isl_fixed_box_is_valid(
5293                 __isl_keep isl_fixed_box *box);
5294         __isl_give isl_multi_aff *isl_fixed_box_get_offset(
5295                 __isl_keep isl_fixed_box *box);
5296         __isl_give isl_multi_val *isl_fixed_box_get_size(
5297                 __isl_keep isl_fixed_box *box);
5299 The box can be copied and freed using the following functions.
5301         #include <isl/fixed_box.h>
5302         __isl_give isl_fixed_box *isl_fixed_box_copy(
5303                 __isl_keep isl_fixed_box *box);
5304         __isl_null isl_fixed_box *isl_fixed_box_free(
5305                 __isl_take isl_fixed_box *box);
5307 =item * Other approximations
5309         #include <isl/set.h>
5310         __isl_give isl_basic_set *
5311         isl_basic_set_drop_constraints_involving_dims(
5312                 __isl_take isl_basic_set *bset,
5313                 enum isl_dim_type type,
5314                 unsigned first, unsigned n);
5315         __isl_give isl_basic_set *
5316         isl_basic_set_drop_constraints_not_involving_dims(
5317                 __isl_take isl_basic_set *bset,
5318                 enum isl_dim_type type,
5319                 unsigned first, unsigned n);
5320         __isl_give isl_set *
5321         isl_set_drop_constraints_involving_dims(
5322                 __isl_take isl_set *set,
5323                 enum isl_dim_type type,
5324                 unsigned first, unsigned n);
5325         __isl_give isl_set *
5326         isl_set_drop_constraints_not_involving_dims(
5327                 __isl_take isl_set *set,
5328                 enum isl_dim_type type,
5329                 unsigned first, unsigned n);
5331         #include <isl/map.h>
5332         __isl_give isl_basic_map *
5333         isl_basic_map_drop_constraints_involving_dims(
5334                 __isl_take isl_basic_map *bmap,
5335                 enum isl_dim_type type,
5336                 unsigned first, unsigned n);
5337         __isl_give isl_basic_map *
5338         isl_basic_map_drop_constraints_not_involving_dims(
5339                 __isl_take isl_basic_map *bmap,
5340                 enum isl_dim_type type,
5341                 unsigned first, unsigned n);
5342         __isl_give isl_map *
5343         isl_map_drop_constraints_involving_dims(
5344                 __isl_take isl_map *map,
5345                 enum isl_dim_type type,
5346                 unsigned first, unsigned n);
5347         __isl_give isl_map *
5348         isl_map_drop_constraints_not_involving_dims(
5349                 __isl_take isl_map *map,
5350                 enum isl_dim_type type,
5351                 unsigned first, unsigned n);
5353 These functions drop any constraints (not) involving the specified dimensions.
5354 Note that the result depends on the representation of the input.
5356         #include <isl/polynomial.h>
5357         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_to_polynomial(
5358                 __isl_take isl_pw_qpolynomial *pwqp, int sign);
5359         __isl_give isl_union_pw_qpolynomial *
5360         isl_union_pw_qpolynomial_to_polynomial(
5361                 __isl_take isl_union_pw_qpolynomial *upwqp, int sign);
5363 Approximate each quasipolynomial by a polynomial.  If C<sign> is positive,
5364 the polynomial will be an overapproximation.  If C<sign> is negative,
5365 it will be an underapproximation.  If C<sign> is zero, the approximation
5366 will lie somewhere in between.
5368 =item * Feasibility
5370         __isl_give isl_basic_set *isl_basic_set_sample(
5371                 __isl_take isl_basic_set *bset);
5372         __isl_give isl_basic_set *isl_set_sample(
5373                 __isl_take isl_set *set);
5374         __isl_give isl_basic_map *isl_basic_map_sample(
5375                 __isl_take isl_basic_map *bmap);
5376         __isl_give isl_basic_map *isl_map_sample(
5377                 __isl_take isl_map *map);
5379 If the input (basic) set or relation is non-empty, then return
5380 a singleton subset of the input.  Otherwise, return an empty set.
5382 =item * Optimization
5384         #include <isl/ilp.h>
5385         __isl_give isl_val *isl_basic_set_max_val(
5386                 __isl_keep isl_basic_set *bset,
5387                 __isl_keep isl_aff *obj);
5388         __isl_give isl_val *isl_set_min_val(
5389                 __isl_keep isl_set *set,
5390                 __isl_keep isl_aff *obj);
5391         __isl_give isl_val *isl_set_max_val(
5392                 __isl_keep isl_set *set,
5393                 __isl_keep isl_aff *obj);
5394         __isl_give isl_multi_val *
5395         isl_union_set_min_multi_union_pw_aff(
5396                 __isl_keep isl_union_set *set,
5397                 __isl_keep isl_multi_union_pw_aff *obj);
5399 Compute the minimum or maximum of the integer affine expression C<obj>
5400 over the points in C<set>, returning the result in C<opt>.
5401 The result is C<NULL> in case of an error, the optimal value in case
5402 there is one, negative infinity or infinity if the problem is unbounded and
5403 NaN if the problem is empty.
5405         #include <isl/ilp.h>
5406         __isl_give isl_val *isl_basic_set_dim_max_val(
5407                 __isl_take isl_basic_set *bset, int pos);
5409 Return the maximal value attained by the given set dimension,
5410 independently of the parameter values and of any other dimensions.
5411 The result is C<NULL> in case of an error, the optimal value in case
5412 there is one, infinity if the problem is unbounded and
5413 NaN if the input is empty.
5415 =item * Parametric optimization
5417         __isl_give isl_pw_aff *isl_set_dim_min(
5418                 __isl_take isl_set *set, int pos);
5419         __isl_give isl_pw_aff *isl_set_dim_max(
5420                 __isl_take isl_set *set, int pos);
5421         __isl_give isl_pw_aff *isl_map_dim_min(
5422                 __isl_take isl_map *map, int pos);
5423         __isl_give isl_pw_aff *isl_map_dim_max(
5424                 __isl_take isl_map *map, int pos);
5426 Compute the minimum or maximum of the given set or output dimension
5427 as a function of the parameters (and input dimensions), but independently
5428 of the other set or output dimensions.
5429 For lexicographic optimization, see L<"Lexicographic Optimization">.
5431 =item * Dual
5433 The following functions compute either the set of (rational) coefficient
5434 values of valid constraints for the given set or the set of (rational)
5435 values satisfying the constraints with coefficients from the given set.
5436 Internally, these two sets of functions perform essentially the
5437 same operations, except that the set of coefficients is assumed to
5438 be a cone, while the set of values may be any polyhedron.
5439 The current implementation is based on the Farkas lemma and
5440 Fourier-Motzkin elimination, but this may change or be made optional
5441 in future.  In particular, future implementations may use different
5442 dualization algorithms or skip the elimination step.
5444         #include <isl/set.h>
5445         __isl_give isl_basic_set *isl_basic_set_coefficients(
5446                 __isl_take isl_basic_set *bset);
5447         __isl_give isl_basic_set_list *
5448         isl_basic_set_list_coefficients(
5449                 __isl_take isl_basic_set_list *list);
5450         __isl_give isl_basic_set *isl_set_coefficients(
5451                 __isl_take isl_set *set);
5452         __isl_give isl_union_set *isl_union_set_coefficients(
5453                 __isl_take isl_union_set *bset);
5454         __isl_give isl_basic_set *isl_basic_set_solutions(
5455                 __isl_take isl_basic_set *bset);
5456         __isl_give isl_basic_set *isl_set_solutions(
5457                 __isl_take isl_set *set);
5458         __isl_give isl_union_set *isl_union_set_solutions(
5459                 __isl_take isl_union_set *bset);
5461 =item * Power
5463         __isl_give isl_map *isl_map_fixed_power_val(
5464                 __isl_take isl_map *map,
5465                 __isl_take isl_val *exp);
5466         __isl_give isl_union_map *
5467         isl_union_map_fixed_power_val(
5468                 __isl_take isl_union_map *umap,
5469                 __isl_take isl_val *exp);
5471 Compute the given power of C<map>, where C<exp> is assumed to be non-zero.
5472 If the exponent C<exp> is negative, then the -C<exp> th power of the inverse
5473 of C<map> is computed.
5475         __isl_give isl_map *isl_map_power(__isl_take isl_map *map,
5476                 int *exact);
5477         __isl_give isl_union_map *isl_union_map_power(
5478                 __isl_take isl_union_map *umap, int *exact);
5480 Compute a parametric representation for all positive powers I<k> of C<map>.
5481 The result maps I<k> to a nested relation corresponding to the
5482 I<k>th power of C<map>.
5483 The result may be an overapproximation.  If the result is known to be exact,
5484 then C<*exact> is set to C<1>.
5486 =item * Transitive closure
5488         __isl_give isl_map *isl_map_transitive_closure(
5489                 __isl_take isl_map *map, int *exact);
5490         __isl_give isl_union_map *isl_union_map_transitive_closure(
5491                 __isl_take isl_union_map *umap, int *exact);
5493 Compute the transitive closure of C<map>.
5494 The result may be an overapproximation.  If the result is known to be exact,
5495 then C<*exact> is set to C<1>.
5497 =item * Reaching path lengths
5499         __isl_give isl_map *isl_map_reaching_path_lengths(
5500                 __isl_take isl_map *map, int *exact);
5502 Compute a relation that maps each element in the range of C<map>
5503 to the lengths of all paths composed of edges in C<map> that
5504 end up in the given element.
5505 The result may be an overapproximation.  If the result is known to be exact,
5506 then C<*exact> is set to C<1>.
5507 To compute the I<maximal> path length, the resulting relation
5508 should be postprocessed by C<isl_map_lexmax>.
5509 In particular, if the input relation is a dependence relation
5510 (mapping sources to sinks), then the maximal path length corresponds
5511 to the free schedule.
5512 Note, however, that C<isl_map_lexmax> expects the maximum to be
5513 finite, so if the path lengths are unbounded (possibly due to
5514 the overapproximation), then you will get an error message.
5516 =item * Wrapping
5518         #include <isl/space.h>
5519         __isl_give isl_space *isl_space_wrap(
5520                 __isl_take isl_space *space);
5521         __isl_give isl_space *isl_space_unwrap(
5522                 __isl_take isl_space *space);
5524         #include <isl/local_space.h>
5525         __isl_give isl_local_space *isl_local_space_wrap(
5526                 __isl_take isl_local_space *ls);
5528         #include <isl/set.h>
5529         __isl_give isl_basic_map *isl_basic_set_unwrap(
5530                 __isl_take isl_basic_set *bset);
5531         __isl_give isl_map *isl_set_unwrap(
5532                 __isl_take isl_set *set);
5534         #include <isl/map.h>
5535         __isl_give isl_basic_set *isl_basic_map_wrap(
5536                 __isl_take isl_basic_map *bmap);
5537         __isl_give isl_set *isl_map_wrap(
5538                 __isl_take isl_map *map);
5540         #include <isl/union_set.h>
5541         __isl_give isl_union_map *isl_union_set_unwrap(
5542                 __isl_take isl_union_set *uset);
5544         #include <isl/union_map.h>
5545         __isl_give isl_union_set *isl_union_map_wrap(
5546                 __isl_take isl_union_map *umap);
5548 The input to C<isl_space_unwrap> should
5549 be the space of a set, while that of
5550 C<isl_space_wrap> should be the space of a relation.
5551 Conversely, the output of C<isl_space_unwrap> is the space
5552 of a relation, while that of C<isl_space_wrap> is the space of a set.
5554 =item * Flattening
5556 Remove any internal structure of domain (and range) of the given
5557 set or relation.  If there is any such internal structure in the input,
5558 then the name of the space is also removed.
5560         #include <isl/space.h>
5561         __isl_give isl_space *isl_space_flatten_domain(
5562                 __isl_take isl_space *space);
5563         __isl_give isl_space *isl_space_flatten_range(
5564                 __isl_take isl_space *space);
5566         #include <isl/local_space.h>
5567         __isl_give isl_local_space *
5568         isl_local_space_flatten_domain(
5569                 __isl_take isl_local_space *ls);
5570         __isl_give isl_local_space *
5571         isl_local_space_flatten_range(
5572                 __isl_take isl_local_space *ls);
5574         #include <isl/set.h>
5575         __isl_give isl_basic_set *isl_basic_set_flatten(
5576                 __isl_take isl_basic_set *bset);
5577         __isl_give isl_set *isl_set_flatten(
5578                 __isl_take isl_set *set);
5580         #include <isl/map.h>
5581         __isl_give isl_basic_map *isl_basic_map_flatten_domain(
5582                 __isl_take isl_basic_map *bmap);
5583         __isl_give isl_basic_map *isl_basic_map_flatten_range(
5584                 __isl_take isl_basic_map *bmap);
5585         __isl_give isl_map *isl_map_flatten_range(
5586                 __isl_take isl_map *map);
5587         __isl_give isl_map *isl_map_flatten_domain(
5588                 __isl_take isl_map *map);
5589         __isl_give isl_basic_map *isl_basic_map_flatten(
5590                 __isl_take isl_basic_map *bmap);
5591         __isl_give isl_map *isl_map_flatten(
5592                 __isl_take isl_map *map);
5594         #include <isl/val.h>
5595         __isl_give isl_multi_val *isl_multi_val_flatten_range(
5596                 __isl_take isl_multi_val *mv);
5598         #include <isl/aff.h>
5599         __isl_give isl_multi_aff *isl_multi_aff_flatten_domain(
5600                 __isl_take isl_multi_aff *ma);
5601         __isl_give isl_multi_aff *isl_multi_aff_flatten_range(
5602                 __isl_take isl_multi_aff *ma);
5603         __isl_give isl_multi_pw_aff *
5604         isl_multi_pw_aff_flatten_range(
5605                 __isl_take isl_multi_pw_aff *mpa);
5606         __isl_give isl_multi_union_pw_aff *
5607         isl_multi_union_pw_aff_flatten_range(
5608                 __isl_take isl_multi_union_pw_aff *mupa);
5610         #include <isl/map.h>
5611         __isl_give isl_map *isl_set_flatten_map(
5612                 __isl_take isl_set *set);
5614 The function above constructs a relation
5615 that maps the input set to a flattened version of the set.
5617 =item * Lifting
5619 Lift the input set to a space with extra dimensions corresponding
5620 to the existentially quantified variables in the input.
5621 In particular, the result lives in a wrapped map where the domain
5622 is the original space and the range corresponds to the original
5623 existentially quantified variables.
5625         #include <isl/set.h>
5626         __isl_give isl_basic_set *isl_basic_set_lift(
5627                 __isl_take isl_basic_set *bset);
5628         __isl_give isl_set *isl_set_lift(
5629                 __isl_take isl_set *set);
5630         __isl_give isl_union_set *isl_union_set_lift(
5631                 __isl_take isl_union_set *uset);
5633 Given a local space that contains the existentially quantified
5634 variables of a set, a basic relation that, when applied to
5635 a basic set, has essentially the same effect as C<isl_basic_set_lift>,
5636 can be constructed using the following function.
5638         #include <isl/local_space.h>
5639         __isl_give isl_basic_map *isl_local_space_lifting(
5640                 __isl_take isl_local_space *ls);
5642         #include <isl/aff.h>
5643         __isl_give isl_multi_aff *isl_multi_aff_lift(
5644                 __isl_take isl_multi_aff *maff,
5645                 __isl_give isl_local_space **ls);
5647 If the C<ls> argument of C<isl_multi_aff_lift> is not C<NULL>,
5648 then it is assigned the local space that lies at the basis of
5649 the lifting applied.
5651 =item * Internal Product
5653         #include <isl/space.h>
5654         __isl_give isl_space *isl_space_zip(
5655                 __isl_take isl_space *space);
5657         #include <isl/map.h>
5658         __isl_give isl_basic_map *isl_basic_map_zip(
5659                 __isl_take isl_basic_map *bmap);
5660         __isl_give isl_map *isl_map_zip(
5661                 __isl_take isl_map *map);
5663         #include <isl/union_map.h>
5664         __isl_give isl_union_map *isl_union_map_zip(
5665                 __isl_take isl_union_map *umap);
5667 Given a relation with nested relations for domain and range,
5668 interchange the range of the domain with the domain of the range.
5670 =item * Currying
5672         #include <isl/space.h>
5673         __isl_give isl_space *isl_space_curry(
5674                 __isl_take isl_space *space);
5675         __isl_give isl_space *isl_space_uncurry(
5676                 __isl_take isl_space *space);
5678         #include <isl/map.h>
5679         __isl_give isl_basic_map *isl_basic_map_curry(
5680                 __isl_take isl_basic_map *bmap);
5681         __isl_give isl_basic_map *isl_basic_map_uncurry(
5682                 __isl_take isl_basic_map *bmap);
5683         __isl_give isl_map *isl_map_curry(
5684                 __isl_take isl_map *map);
5685         __isl_give isl_map *isl_map_uncurry(
5686                 __isl_take isl_map *map);
5688         #include <isl/union_map.h>
5689         __isl_give isl_union_map *isl_union_map_curry(
5690                 __isl_take isl_union_map *umap);
5691         __isl_give isl_union_map *isl_union_map_uncurry(
5692                 __isl_take isl_union_map *umap);
5694 Given a relation with a nested relation for domain,
5695 the C<curry> functions
5696 move the range of the nested relation out of the domain
5697 and use it as the domain of a nested relation in the range,
5698 with the original range as range of this nested relation.
5699 The C<uncurry> functions perform the inverse operation.
5701         #include <isl/space.h>
5702         __isl_give isl_space *isl_space_range_curry(
5703                 __isl_take isl_space *space);
5705         #include <isl/map.h>
5706         __isl_give isl_map *isl_map_range_curry(
5707                 __isl_take isl_map *map);
5709         #include <isl/union_map.h>
5710         __isl_give isl_union_map *isl_union_map_range_curry(
5711                 __isl_take isl_union_map *umap);
5713 These functions apply the currying to the relation that
5714 is nested inside the range of the input.
5716 =item * Aligning parameters
5718 Change the order of the parameters of the given set, relation
5719 or function
5720 such that the first parameters match those of C<model>.
5721 This may involve the introduction of extra parameters.
5722 All parameters need to be named.
5724         #include <isl/space.h>
5725         __isl_give isl_space *isl_space_align_params(
5726                 __isl_take isl_space *space1,
5727                 __isl_take isl_space *space2)
5729         #include <isl/set.h>
5730         __isl_give isl_basic_set *isl_basic_set_align_params(
5731                 __isl_take isl_basic_set *bset,
5732                 __isl_take isl_space *model);
5733         __isl_give isl_set *isl_set_align_params(
5734                 __isl_take isl_set *set,
5735                 __isl_take isl_space *model);
5737         #include <isl/map.h>
5738         __isl_give isl_basic_map *isl_basic_map_align_params(
5739                 __isl_take isl_basic_map *bmap,
5740                 __isl_take isl_space *model);
5741         __isl_give isl_map *isl_map_align_params(
5742                 __isl_take isl_map *map,
5743                 __isl_take isl_space *model);
5745         #include <isl/val.h>
5746         __isl_give isl_multi_val *isl_multi_val_align_params(
5747                 __isl_take isl_multi_val *mv,
5748                 __isl_take isl_space *model);
5750         #include <isl/aff.h>
5751         __isl_give isl_aff *isl_aff_align_params(
5752                 __isl_take isl_aff *aff,
5753                 __isl_take isl_space *model);
5754         __isl_give isl_multi_aff *isl_multi_aff_align_params(
5755                 __isl_take isl_multi_aff *multi,
5756                 __isl_take isl_space *model);
5757         __isl_give isl_pw_aff *isl_pw_aff_align_params(
5758                 __isl_take isl_pw_aff *pwaff,
5759                 __isl_take isl_space *model);
5760         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_align_params(
5761                 __isl_take isl_pw_multi_aff *pma,
5762                 __isl_take isl_space *model);
5763         __isl_give isl_union_pw_aff *
5764         isl_union_pw_aff_align_params(
5765                 __isl_take isl_union_pw_aff *upa,
5766                 __isl_take isl_space *model);
5767         __isl_give isl_union_pw_multi_aff *
5768         isl_union_pw_multi_aff_align_params(
5769                 __isl_take isl_union_pw_multi_aff *upma,
5770                 __isl_take isl_space *model);
5771         __isl_give isl_multi_union_pw_aff *
5772         isl_multi_union_pw_aff_align_params(
5773                 __isl_take isl_multi_union_pw_aff *mupa,
5774                 __isl_take isl_space *model);
5776         #include <isl/polynomial.h>
5777         __isl_give isl_qpolynomial *isl_qpolynomial_align_params(
5778                 __isl_take isl_qpolynomial *qp,
5779                 __isl_take isl_space *model);
5781 =item * Drop unused parameters
5783 Drop parameters that are not referenced by the isl object.
5784 All parameters need to be named.
5786         #include <isl/set.h>
5787         __isl_give isl_basic_set *
5788         isl_basic_set_drop_unused_params(
5789                 __isl_take isl_basic_set *bset);
5790         __isl_give isl_set *isl_set_drop_unused_params(
5791                 __isl_take isl_set *set);
5793         #include <isl/map.h>
5794         __isl_give isl_basic_map *
5795         isl_basic_map_drop_unused_params(
5796                 __isl_take isl_basic_map *bmap);
5797         __isl_give isl_map *isl_map_drop_unused_params(
5798                 __isl_take isl_map *map);
5800         #include <isl/aff.h>
5801         __isl_give isl_pw_aff *isl_pw_aff_drop_unused_params(
5802                 __isl_take isl_pw_aff *pa);
5803         __isl_give isl_pw_multi_aff *
5804         isl_pw_multi_aff_drop_unused_params(
5805                 __isl_take isl_pw_multi_aff *pma);
5807         #include <isl/polynomial.h>
5808         __isl_give isl_pw_qpolynomial *
5809         isl_pw_qpolynomial_drop_unused_params(
5810                 __isl_take isl_pw_qpolynomial *pwqp);
5811         __isl_give isl_pw_qpolynomial_fold *
5812         isl_pw_qpolynomial_fold_drop_unused_params(
5813                 __isl_take isl_pw_qpolynomial_fold *pwf);
5815 =item * Unary Arithmetic Operations
5817         #include <isl/set.h>
5818         __isl_give isl_set *isl_set_neg(
5819                 __isl_take isl_set *set);
5820         #include <isl/map.h>
5821         __isl_give isl_map *isl_map_neg(
5822                 __isl_take isl_map *map);
5824 C<isl_set_neg> constructs a set containing the opposites of
5825 the elements in its argument.
5826 The domain of the result of C<isl_map_neg> is the same
5827 as the domain of its argument.  The corresponding range
5828 elements are the opposites of the corresponding range
5829 elements in the argument.
5831         #include <isl/val.h>
5832         __isl_give isl_multi_val *isl_multi_val_neg(
5833                 __isl_take isl_multi_val *mv);
5835         #include <isl/aff.h>
5836         __isl_give isl_aff *isl_aff_neg(
5837                 __isl_take isl_aff *aff);
5838         __isl_give isl_multi_aff *isl_multi_aff_neg(
5839                 __isl_take isl_multi_aff *ma);
5840         __isl_give isl_pw_aff *isl_pw_aff_neg(
5841                 __isl_take isl_pw_aff *pwaff);
5842         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_neg(
5843                 __isl_take isl_pw_multi_aff *pma);
5844         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_neg(
5845                 __isl_take isl_multi_pw_aff *mpa);
5846         __isl_give isl_union_pw_aff *isl_union_pw_aff_neg(
5847                 __isl_take isl_union_pw_aff *upa);
5848         __isl_give isl_union_pw_multi_aff *
5849         isl_union_pw_multi_aff_neg(
5850                 __isl_take isl_union_pw_multi_aff *upma);
5851         __isl_give isl_multi_union_pw_aff *
5852         isl_multi_union_pw_aff_neg(
5853                 __isl_take isl_multi_union_pw_aff *mupa);
5854         __isl_give isl_aff *isl_aff_ceil(
5855                 __isl_take isl_aff *aff);
5856         __isl_give isl_pw_aff *isl_pw_aff_ceil(
5857                 __isl_take isl_pw_aff *pwaff);
5858         __isl_give isl_aff *isl_aff_floor(
5859                 __isl_take isl_aff *aff);
5860         __isl_give isl_multi_aff *isl_multi_aff_floor(
5861                 __isl_take isl_multi_aff *ma);
5862         __isl_give isl_pw_aff *isl_pw_aff_floor(
5863                 __isl_take isl_pw_aff *pwaff);
5864         __isl_give isl_union_pw_aff *isl_union_pw_aff_floor(
5865                 __isl_take isl_union_pw_aff *upa);
5866         __isl_give isl_multi_union_pw_aff *
5867         isl_multi_union_pw_aff_floor(
5868                 __isl_take isl_multi_union_pw_aff *mupa);
5870         #include <isl/aff.h>
5871         __isl_give isl_pw_aff *isl_pw_aff_list_min(
5872                 __isl_take isl_pw_aff_list *list);
5873         __isl_give isl_pw_aff *isl_pw_aff_list_max(
5874                 __isl_take isl_pw_aff_list *list);
5876         #include <isl/polynomial.h>
5877         __isl_give isl_qpolynomial *isl_qpolynomial_neg(
5878                 __isl_take isl_qpolynomial *qp);
5879         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_neg(
5880                 __isl_take isl_pw_qpolynomial *pwqp);
5881         __isl_give isl_union_pw_qpolynomial *
5882         isl_union_pw_qpolynomial_neg(
5883                 __isl_take isl_union_pw_qpolynomial *upwqp);
5884         __isl_give isl_qpolynomial *isl_qpolynomial_pow(
5885                 __isl_take isl_qpolynomial *qp,
5886                 unsigned exponent);
5887         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_pow(
5888                 __isl_take isl_pw_qpolynomial *pwqp,
5889                 unsigned exponent);
5891 =item * Evaluation
5893 The following functions evaluate a function in a point.
5895         #include <isl/aff.h>
5896         __isl_give isl_val *isl_aff_eval(
5897                 __isl_take isl_aff *aff,
5898                 __isl_take isl_point *pnt);
5899         __isl_give isl_val *isl_pw_aff_eval(
5900                 __isl_take isl_pw_aff *pa,
5901                 __isl_take isl_point *pnt);
5903         #include <isl/polynomial.h>
5904         __isl_give isl_val *isl_pw_qpolynomial_eval(
5905                 __isl_take isl_pw_qpolynomial *pwqp,
5906                 __isl_take isl_point *pnt);
5907         __isl_give isl_val *isl_pw_qpolynomial_fold_eval(
5908                 __isl_take isl_pw_qpolynomial_fold *pwf,
5909                 __isl_take isl_point *pnt);
5910         __isl_give isl_val *isl_union_pw_qpolynomial_eval(
5911                 __isl_take isl_union_pw_qpolynomial *upwqp,
5912                 __isl_take isl_point *pnt);
5913         __isl_give isl_val *isl_union_pw_qpolynomial_fold_eval(
5914                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
5915                 __isl_take isl_point *pnt);
5917 These functions return NaN when evaluated at a void point.
5918 Note that C<isl_pw_aff_eval> returns NaN when the function is evaluated outside
5919 its definition domain, while C<isl_pw_qpolynomial_eval> returns zero
5920 when the function is evaluated outside its explicit domain.
5922 =item * Dimension manipulation
5924 It is usually not advisable to directly change the (input or output)
5925 space of a set or a relation as this removes the name and the internal
5926 structure of the space.  However, the functions below can be useful
5927 to add new parameters, assuming
5928 C<isl_set_align_params> and C<isl_map_align_params>
5929 are not sufficient.
5931         #include <isl/space.h>
5932         __isl_give isl_space *isl_space_add_dims(
5933                 __isl_take isl_space *space,
5934                 enum isl_dim_type type, unsigned n);
5935         __isl_give isl_space *isl_space_insert_dims(
5936                 __isl_take isl_space *space,
5937                 enum isl_dim_type type, unsigned pos, unsigned n);
5938         __isl_give isl_space *isl_space_drop_dims(
5939                 __isl_take isl_space *space,
5940                 enum isl_dim_type type, unsigned first, unsigned n);
5941         __isl_give isl_space *isl_space_move_dims(
5942                 __isl_take isl_space *space,
5943                 enum isl_dim_type dst_type, unsigned dst_pos,
5944                 enum isl_dim_type src_type, unsigned src_pos,
5945                 unsigned n);
5947         #include <isl/local_space.h>
5948         __isl_give isl_local_space *isl_local_space_add_dims(
5949                 __isl_take isl_local_space *ls,
5950                 enum isl_dim_type type, unsigned n);
5951         __isl_give isl_local_space *isl_local_space_insert_dims(
5952                 __isl_take isl_local_space *ls,
5953                 enum isl_dim_type type, unsigned first, unsigned n);
5954         __isl_give isl_local_space *isl_local_space_drop_dims(
5955                 __isl_take isl_local_space *ls,
5956                 enum isl_dim_type type, unsigned first, unsigned n);
5958         #include <isl/set.h>
5959         __isl_give isl_basic_set *isl_basic_set_add_dims(
5960                 __isl_take isl_basic_set *bset,
5961                 enum isl_dim_type type, unsigned n);
5962         __isl_give isl_set *isl_set_add_dims(
5963                 __isl_take isl_set *set,
5964                 enum isl_dim_type type, unsigned n);
5965         __isl_give isl_basic_set *isl_basic_set_insert_dims(
5966                 __isl_take isl_basic_set *bset,
5967                 enum isl_dim_type type, unsigned pos,
5968                 unsigned n);
5969         __isl_give isl_set *isl_set_insert_dims(
5970                 __isl_take isl_set *set,
5971                 enum isl_dim_type type, unsigned pos, unsigned n);
5972         __isl_give isl_basic_set *isl_basic_set_move_dims(
5973                 __isl_take isl_basic_set *bset,
5974                 enum isl_dim_type dst_type, unsigned dst_pos,
5975                 enum isl_dim_type src_type, unsigned src_pos,
5976                 unsigned n);
5977         __isl_give isl_set *isl_set_move_dims(
5978                 __isl_take isl_set *set,
5979                 enum isl_dim_type dst_type, unsigned dst_pos,
5980                 enum isl_dim_type src_type, unsigned src_pos,
5981                 unsigned n);
5983         #include <isl/map.h>
5984         __isl_give isl_basic_map *isl_basic_map_add_dims(
5985                 __isl_take isl_basic_map *bmap,
5986                 enum isl_dim_type type, unsigned n);
5987         __isl_give isl_map *isl_map_add_dims(
5988                 __isl_take isl_map *map,
5989                 enum isl_dim_type type, unsigned n);
5990         __isl_give isl_basic_map *isl_basic_map_insert_dims(
5991                 __isl_take isl_basic_map *bmap,
5992                 enum isl_dim_type type, unsigned pos,
5993                 unsigned n);
5994         __isl_give isl_map *isl_map_insert_dims(
5995                 __isl_take isl_map *map,
5996                 enum isl_dim_type type, unsigned pos, unsigned n);
5997         __isl_give isl_basic_map *isl_basic_map_move_dims(
5998                 __isl_take isl_basic_map *bmap,
5999                 enum isl_dim_type dst_type, unsigned dst_pos,
6000                 enum isl_dim_type src_type, unsigned src_pos,
6001                 unsigned n);
6002         __isl_give isl_map *isl_map_move_dims(
6003                 __isl_take isl_map *map,
6004                 enum isl_dim_type dst_type, unsigned dst_pos,
6005                 enum isl_dim_type src_type, unsigned src_pos,
6006                 unsigned n);
6008         #include <isl/val.h>
6009         __isl_give isl_multi_val *isl_multi_val_insert_dims(
6010                 __isl_take isl_multi_val *mv,
6011                 enum isl_dim_type type, unsigned first, unsigned n);
6012         __isl_give isl_multi_val *isl_multi_val_add_dims(
6013                 __isl_take isl_multi_val *mv,
6014                 enum isl_dim_type type, unsigned n);
6015         __isl_give isl_multi_val *isl_multi_val_drop_dims(
6016                 __isl_take isl_multi_val *mv,
6017                 enum isl_dim_type type, unsigned first, unsigned n);
6019         #include <isl/aff.h>
6020         __isl_give isl_aff *isl_aff_insert_dims(
6021                 __isl_take isl_aff *aff,
6022                 enum isl_dim_type type, unsigned first, unsigned n);
6023         __isl_give isl_multi_aff *isl_multi_aff_insert_dims(
6024                 __isl_take isl_multi_aff *ma,
6025                 enum isl_dim_type type, unsigned first, unsigned n);
6026         __isl_give isl_pw_aff *isl_pw_aff_insert_dims(
6027                 __isl_take isl_pw_aff *pwaff,
6028                 enum isl_dim_type type, unsigned first, unsigned n);
6029         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_insert_dims(
6030                 __isl_take isl_multi_pw_aff *mpa,
6031                 enum isl_dim_type type, unsigned first, unsigned n);
6032         __isl_give isl_aff *isl_aff_add_dims(
6033                 __isl_take isl_aff *aff,
6034                 enum isl_dim_type type, unsigned n);
6035         __isl_give isl_multi_aff *isl_multi_aff_add_dims(
6036                 __isl_take isl_multi_aff *ma,
6037                 enum isl_dim_type type, unsigned n);
6038         __isl_give isl_pw_aff *isl_pw_aff_add_dims(
6039                 __isl_take isl_pw_aff *pwaff,
6040                 enum isl_dim_type type, unsigned n);
6041         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_add_dims(
6042                 __isl_take isl_multi_pw_aff *mpa,
6043                 enum isl_dim_type type, unsigned n);
6044         __isl_give isl_aff *isl_aff_drop_dims(
6045                 __isl_take isl_aff *aff,
6046                 enum isl_dim_type type, unsigned first, unsigned n);
6047         __isl_give isl_multi_aff *isl_multi_aff_drop_dims(
6048                 __isl_take isl_multi_aff *maff,
6049                 enum isl_dim_type type, unsigned first, unsigned n);
6050         __isl_give isl_pw_aff *isl_pw_aff_drop_dims(
6051                 __isl_take isl_pw_aff *pwaff,
6052                 enum isl_dim_type type, unsigned first, unsigned n);
6053         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_drop_dims(
6054                 __isl_take isl_pw_multi_aff *pma,
6055                 enum isl_dim_type type, unsigned first, unsigned n);
6056         __isl_give isl_union_pw_aff *isl_union_pw_aff_drop_dims(
6057                 __isl_take isl_union_pw_aff *upa,
6058                 enum isl_dim_type type, unsigned first, unsigned n);
6059         __isl_give isl_union_pw_multi_aff *
6060                 isl_union_pw_multi_aff_drop_dims(
6061                 __isl_take isl_union_pw_multi_aff *upma,
6062                 enum isl_dim_type type,
6063                 unsigned first, unsigned n);
6064         __isl_give isl_multi_union_pw_aff *
6065         isl_multi_union_pw_aff_drop_dims(
6066                 __isl_take isl_multi_union_pw_aff *mupa,
6067                 enum isl_dim_type type, unsigned first,
6068                 unsigned n);
6069         __isl_give isl_aff *isl_aff_move_dims(
6070                 __isl_take isl_aff *aff,
6071                 enum isl_dim_type dst_type, unsigned dst_pos,
6072                 enum isl_dim_type src_type, unsigned src_pos,
6073                 unsigned n);
6074         __isl_give isl_multi_aff *isl_multi_aff_move_dims(
6075                 __isl_take isl_multi_aff *ma,
6076                 enum isl_dim_type dst_type, unsigned dst_pos,
6077                 enum isl_dim_type src_type, unsigned src_pos,
6078                 unsigned n);
6079         __isl_give isl_pw_aff *isl_pw_aff_move_dims(
6080                 __isl_take isl_pw_aff *pa,
6081                 enum isl_dim_type dst_type, unsigned dst_pos,
6082                 enum isl_dim_type src_type, unsigned src_pos,
6083                 unsigned n);
6084         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_move_dims(
6085                 __isl_take isl_multi_pw_aff *pma,
6086                 enum isl_dim_type dst_type, unsigned dst_pos,
6087                 enum isl_dim_type src_type, unsigned src_pos,
6088                 unsigned n);
6090         #include <isl/polynomial.h>
6091         __isl_give isl_union_pw_qpolynomial *
6092         isl_union_pw_qpolynomial_drop_dims(
6093                 __isl_take isl_union_pw_qpolynomial *upwqp,
6094                 enum isl_dim_type type,
6095                 unsigned first, unsigned n);
6096         __isl_give isl_union_pw_qpolynomial_fold *
6097                 isl_union_pw_qpolynomial_fold_drop_dims(
6098                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
6099                 enum isl_dim_type type,
6100                 unsigned first, unsigned n);
6102 The operations on union expressions can only manipulate parameters.
6104 =back
6106 =head2 Binary Operations
6108 The two arguments of a binary operation not only need to live
6109 in the same C<isl_ctx>, they currently also need to have
6110 the same (number of) parameters.
6112 =head3 Basic Operations
6114 =over
6116 =item * Intersection
6118         #include <isl/local_space.h>
6119         __isl_give isl_local_space *isl_local_space_intersect(
6120                 __isl_take isl_local_space *ls1,
6121                 __isl_take isl_local_space *ls2);
6123         #include <isl/set.h>
6124         __isl_give isl_basic_set *isl_basic_set_intersect_params(
6125                 __isl_take isl_basic_set *bset1,
6126                 __isl_take isl_basic_set *bset2);
6127         __isl_give isl_basic_set *isl_basic_set_intersect(
6128                 __isl_take isl_basic_set *bset1,
6129                 __isl_take isl_basic_set *bset2);
6130         __isl_give isl_basic_set *isl_basic_set_list_intersect(
6131                 __isl_take struct isl_basic_set_list *list);
6132         __isl_give isl_set *isl_set_intersect_params(
6133                 __isl_take isl_set *set,
6134                 __isl_take isl_set *params);
6135         __isl_give isl_set *isl_set_intersect(
6136                 __isl_take isl_set *set1,
6137                 __isl_take isl_set *set2);
6139         #include <isl/map.h>
6140         __isl_give isl_basic_map *isl_basic_map_intersect_domain(
6141                 __isl_take isl_basic_map *bmap,
6142                 __isl_take isl_basic_set *bset);
6143         __isl_give isl_basic_map *isl_basic_map_intersect_range(
6144                 __isl_take isl_basic_map *bmap,
6145                 __isl_take isl_basic_set *bset);
6146         __isl_give isl_basic_map *isl_basic_map_intersect(
6147                 __isl_take isl_basic_map *bmap1,
6148                 __isl_take isl_basic_map *bmap2);
6149         __isl_give isl_basic_map *isl_basic_map_list_intersect(
6150                 __isl_take isl_basic_map_list *list);
6151         __isl_give isl_map *isl_map_intersect_params(
6152                 __isl_take isl_map *map,
6153                 __isl_take isl_set *params);
6154         __isl_give isl_map *isl_map_intersect_domain(
6155                 __isl_take isl_map *map,
6156                 __isl_take isl_set *set);
6157         __isl_give isl_map *isl_map_intersect_range(
6158                 __isl_take isl_map *map,
6159                 __isl_take isl_set *set);
6160         __isl_give isl_map *isl_map_intersect(
6161                 __isl_take isl_map *map1,
6162                 __isl_take isl_map *map2);
6163         __isl_give isl_map *
6164         isl_map_intersect_domain_factor_range(
6165                 __isl_take isl_map *map,
6166                 __isl_take isl_map *factor);
6167         __isl_give isl_map *
6168         isl_map_intersect_range_factor_range(
6169                 __isl_take isl_map *map,
6170                 __isl_take isl_map *factor);
6172         #include <isl/union_set.h>
6173         __isl_give isl_union_set *isl_union_set_intersect_params(
6174                 __isl_take isl_union_set *uset,
6175                 __isl_take isl_set *set);
6176         __isl_give isl_union_set *isl_union_set_intersect(
6177                 __isl_take isl_union_set *uset1,
6178                 __isl_take isl_union_set *uset2);
6180         #include <isl/union_map.h>
6181         __isl_give isl_union_map *isl_union_map_intersect_params(
6182                 __isl_take isl_union_map *umap,
6183                 __isl_take isl_set *set);
6184         __isl_give isl_union_map *isl_union_map_intersect_domain(
6185                 __isl_take isl_union_map *umap,
6186                 __isl_take isl_union_set *uset);
6187         __isl_give isl_union_map *isl_union_map_intersect_range(
6188                 __isl_take isl_union_map *umap,
6189                 __isl_take isl_union_set *uset);
6190         __isl_give isl_union_map *isl_union_map_intersect(
6191                 __isl_take isl_union_map *umap1,
6192                 __isl_take isl_union_map *umap2);
6193         __isl_give isl_union_map *
6194         isl_union_map_intersect_range_factor_range(
6195                 __isl_take isl_union_map *umap,
6196                 __isl_take isl_union_map *factor);
6198         #include <isl/aff.h>
6199         __isl_give isl_pw_aff *isl_pw_aff_intersect_domain(
6200                 __isl_take isl_pw_aff *pa,
6201                 __isl_take isl_set *set);
6202         __isl_give isl_multi_pw_aff *
6203         isl_multi_pw_aff_intersect_domain(
6204                 __isl_take isl_multi_pw_aff *mpa,
6205                 __isl_take isl_set *domain);
6206         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_domain(
6207                 __isl_take isl_pw_multi_aff *pma,
6208                 __isl_take isl_set *set);
6209         __isl_give isl_union_pw_aff *isl_union_pw_aff_intersect_domain(
6210                 __isl_take isl_union_pw_aff *upa,
6211                 __isl_take isl_union_set *uset);
6212         __isl_give isl_union_pw_multi_aff *
6213         isl_union_pw_multi_aff_intersect_domain(
6214                 __isl_take isl_union_pw_multi_aff *upma,
6215                 __isl_take isl_union_set *uset);
6216         __isl_give isl_multi_union_pw_aff *
6217         isl_multi_union_pw_aff_intersect_domain(
6218                 __isl_take isl_multi_union_pw_aff *mupa,
6219                 __isl_take isl_union_set *uset);
6220         __isl_give isl_pw_aff *isl_pw_aff_intersect_params(
6221                 __isl_take isl_pw_aff *pa,
6222                 __isl_take isl_set *set);
6223         __isl_give isl_multi_pw_aff *
6224         isl_multi_pw_aff_intersect_params(
6225                 __isl_take isl_multi_pw_aff *mpa,
6226                 __isl_take isl_set *set);
6227         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_params(
6228                 __isl_take isl_pw_multi_aff *pma,
6229                 __isl_take isl_set *set);
6230         __isl_give isl_union_pw_aff *
6231         isl_union_pw_aff_intersect_params(
6232                 __isl_take isl_union_pw_aff *upa,
6233         __isl_give isl_union_pw_multi_aff *
6234         isl_union_pw_multi_aff_intersect_params(
6235                 __isl_take isl_union_pw_multi_aff *upma,
6236                 __isl_take isl_set *set);
6237         __isl_give isl_multi_union_pw_aff *
6238         isl_multi_union_pw_aff_intersect_params(
6239                 __isl_take isl_multi_union_pw_aff *mupa,
6240                 __isl_take isl_set *params);
6241         isl_multi_union_pw_aff_intersect_range(
6242                 __isl_take isl_multi_union_pw_aff *mupa,
6243                 __isl_take isl_set *set);
6245         #include <isl/polynomial.h>
6246         __isl_give isl_pw_qpolynomial *
6247         isl_pw_qpolynomial_intersect_domain(
6248                 __isl_take isl_pw_qpolynomial *pwpq,
6249                 __isl_take isl_set *set);
6250         __isl_give isl_union_pw_qpolynomial *
6251         isl_union_pw_qpolynomial_intersect_domain(
6252                 __isl_take isl_union_pw_qpolynomial *upwpq,
6253                 __isl_take isl_union_set *uset);
6254         __isl_give isl_union_pw_qpolynomial_fold *
6255         isl_union_pw_qpolynomial_fold_intersect_domain(
6256                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
6257                 __isl_take isl_union_set *uset);
6258         __isl_give isl_pw_qpolynomial *
6259         isl_pw_qpolynomial_intersect_params(
6260                 __isl_take isl_pw_qpolynomial *pwpq,
6261                 __isl_take isl_set *set);
6262         __isl_give isl_pw_qpolynomial_fold *
6263         isl_pw_qpolynomial_fold_intersect_params(
6264                 __isl_take isl_pw_qpolynomial_fold *pwf,
6265                 __isl_take isl_set *set);
6266         __isl_give isl_union_pw_qpolynomial *
6267         isl_union_pw_qpolynomial_intersect_params(
6268                 __isl_take isl_union_pw_qpolynomial *upwpq,
6269                 __isl_take isl_set *set);
6270         __isl_give isl_union_pw_qpolynomial_fold *
6271         isl_union_pw_qpolynomial_fold_intersect_params(
6272                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
6273                 __isl_take isl_set *set);
6275 The second argument to the C<_params> functions needs to be
6276 a parametric (basic) set.  For the other functions, a parametric set
6277 for either argument is only allowed if the other argument is
6278 a parametric set as well.
6279 The list passed to C<isl_basic_set_list_intersect> needs to have
6280 at least one element and all elements need to live in the same space.
6281 The function C<isl_multi_union_pw_aff_intersect_range>
6282 restricts the input function to those shared domain elements
6283 that map to the specified range.
6285 =item * Union
6287         #include <isl/set.h>
6288         __isl_give isl_set *isl_basic_set_union(
6289                 __isl_take isl_basic_set *bset1,
6290                 __isl_take isl_basic_set *bset2);
6291         __isl_give isl_set *isl_set_union(
6292                 __isl_take isl_set *set1,
6293                 __isl_take isl_set *set2);
6294         __isl_give isl_set *isl_set_list_union(
6295                 __isl_take isl_set_list *list);
6297         #include <isl/map.h>
6298         __isl_give isl_map *isl_basic_map_union(
6299                 __isl_take isl_basic_map *bmap1,
6300                 __isl_take isl_basic_map *bmap2);
6301         __isl_give isl_map *isl_map_union(
6302                 __isl_take isl_map *map1,
6303                 __isl_take isl_map *map2);
6305         #include <isl/union_set.h>
6306         __isl_give isl_union_set *isl_union_set_union(
6307                 __isl_take isl_union_set *uset1,
6308                 __isl_take isl_union_set *uset2);
6309         __isl_give isl_union_set *isl_union_set_list_union(
6310                 __isl_take isl_union_set_list *list);
6312         #include <isl/union_map.h>
6313         __isl_give isl_union_map *isl_union_map_union(
6314                 __isl_take isl_union_map *umap1,
6315                 __isl_take isl_union_map *umap2);
6317 The list passed to C<isl_set_list_union> needs to have
6318 at least one element and all elements need to live in the same space.
6320 =item * Set difference
6322         #include <isl/set.h>
6323         __isl_give isl_set *isl_set_subtract(
6324                 __isl_take isl_set *set1,
6325                 __isl_take isl_set *set2);
6327         #include <isl/map.h>
6328         __isl_give isl_map *isl_map_subtract(
6329                 __isl_take isl_map *map1,
6330                 __isl_take isl_map *map2);
6331         __isl_give isl_map *isl_map_subtract_domain(
6332                 __isl_take isl_map *map,
6333                 __isl_take isl_set *dom);
6334         __isl_give isl_map *isl_map_subtract_range(
6335                 __isl_take isl_map *map,
6336                 __isl_take isl_set *dom);
6338         #include <isl/union_set.h>
6339         __isl_give isl_union_set *isl_union_set_subtract(
6340                 __isl_take isl_union_set *uset1,
6341                 __isl_take isl_union_set *uset2);
6343         #include <isl/union_map.h>
6344         __isl_give isl_union_map *isl_union_map_subtract(
6345                 __isl_take isl_union_map *umap1,
6346                 __isl_take isl_union_map *umap2);
6347         __isl_give isl_union_map *isl_union_map_subtract_domain(
6348                 __isl_take isl_union_map *umap,
6349                 __isl_take isl_union_set *dom);
6350         __isl_give isl_union_map *isl_union_map_subtract_range(
6351                 __isl_take isl_union_map *umap,
6352                 __isl_take isl_union_set *dom);
6354         #include <isl/aff.h>
6355         __isl_give isl_pw_aff *isl_pw_aff_subtract_domain(
6356                 __isl_take isl_pw_aff *pa,
6357                 __isl_take isl_set *set);
6358         __isl_give isl_pw_multi_aff *
6359         isl_pw_multi_aff_subtract_domain(
6360                 __isl_take isl_pw_multi_aff *pma,
6361                 __isl_take isl_set *set);
6362         __isl_give isl_union_pw_aff *
6363         isl_union_pw_aff_subtract_domain(
6364                 __isl_take isl_union_pw_aff *upa,
6365                 __isl_take isl_union_set *uset);
6366         __isl_give isl_union_pw_multi_aff *
6367         isl_union_pw_multi_aff_subtract_domain(
6368                 __isl_take isl_union_pw_multi_aff *upma,
6369                 __isl_take isl_set *set);
6371         #include <isl/polynomial.h>
6372         __isl_give isl_pw_qpolynomial *
6373         isl_pw_qpolynomial_subtract_domain(
6374                 __isl_take isl_pw_qpolynomial *pwpq,
6375                 __isl_take isl_set *set);
6376         __isl_give isl_pw_qpolynomial_fold *
6377         isl_pw_qpolynomial_fold_subtract_domain(
6378                 __isl_take isl_pw_qpolynomial_fold *pwf,
6379                 __isl_take isl_set *set);
6380         __isl_give isl_union_pw_qpolynomial *
6381         isl_union_pw_qpolynomial_subtract_domain(
6382                 __isl_take isl_union_pw_qpolynomial *upwpq,
6383                 __isl_take isl_union_set *uset);
6384         __isl_give isl_union_pw_qpolynomial_fold *
6385         isl_union_pw_qpolynomial_fold_subtract_domain(
6386                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
6387                 __isl_take isl_union_set *uset);
6389 =item * Application
6391         #include <isl/space.h>
6392         __isl_give isl_space *isl_space_join(
6393                 __isl_take isl_space *left,
6394                 __isl_take isl_space *right);
6396         #include <isl/map.h>
6397         __isl_give isl_basic_set *isl_basic_set_apply(
6398                 __isl_take isl_basic_set *bset,
6399                 __isl_take isl_basic_map *bmap);
6400         __isl_give isl_set *isl_set_apply(
6401                 __isl_take isl_set *set,
6402                 __isl_take isl_map *map);
6403         __isl_give isl_union_set *isl_union_set_apply(
6404                 __isl_take isl_union_set *uset,
6405                 __isl_take isl_union_map *umap);
6406         __isl_give isl_basic_map *isl_basic_map_apply_domain(
6407                 __isl_take isl_basic_map *bmap1,
6408                 __isl_take isl_basic_map *bmap2);
6409         __isl_give isl_basic_map *isl_basic_map_apply_range(
6410                 __isl_take isl_basic_map *bmap1,
6411                 __isl_take isl_basic_map *bmap2);
6412         __isl_give isl_map *isl_map_apply_domain(
6413                 __isl_take isl_map *map1,
6414                 __isl_take isl_map *map2);
6415         __isl_give isl_map *isl_map_apply_range(
6416                 __isl_take isl_map *map1,
6417                 __isl_take isl_map *map2);
6419         #include <isl/union_map.h>
6420         __isl_give isl_union_map *isl_union_map_apply_domain(
6421                 __isl_take isl_union_map *umap1,
6422                 __isl_take isl_union_map *umap2);
6423         __isl_give isl_union_map *isl_union_map_apply_range(
6424                 __isl_take isl_union_map *umap1,
6425                 __isl_take isl_union_map *umap2);
6427         #include <isl/aff.h>
6428         __isl_give isl_union_pw_aff *
6429         isl_multi_union_pw_aff_apply_aff(
6430                 __isl_take isl_multi_union_pw_aff *mupa,
6431                 __isl_take isl_aff *aff);
6432         __isl_give isl_union_pw_aff *
6433         isl_multi_union_pw_aff_apply_pw_aff(
6434                 __isl_take isl_multi_union_pw_aff *mupa,
6435                 __isl_take isl_pw_aff *pa);
6436         __isl_give isl_multi_union_pw_aff *
6437         isl_multi_union_pw_aff_apply_multi_aff(
6438                 __isl_take isl_multi_union_pw_aff *mupa,
6439                 __isl_take isl_multi_aff *ma);
6440         __isl_give isl_multi_union_pw_aff *
6441         isl_multi_union_pw_aff_apply_pw_multi_aff(
6442                 __isl_take isl_multi_union_pw_aff *mupa,
6443                 __isl_take isl_pw_multi_aff *pma);
6445 The result of C<isl_multi_union_pw_aff_apply_aff> is defined
6446 over the shared domain of the elements of the input.  The dimension is
6447 required to be greater than zero.
6448 The C<isl_multi_union_pw_aff> argument of
6449 C<isl_multi_union_pw_aff_apply_multi_aff> is allowed to be zero-dimensional,
6450 but only if the range of the C<isl_multi_aff> argument
6451 is also zero-dimensional.
6452 Similarly for C<isl_multi_union_pw_aff_apply_pw_multi_aff>.
6454         #include <isl/polynomial.h>
6455         __isl_give isl_pw_qpolynomial_fold *
6456         isl_set_apply_pw_qpolynomial_fold(
6457                 __isl_take isl_set *set,
6458                 __isl_take isl_pw_qpolynomial_fold *pwf,
6459                 int *tight);
6460         __isl_give isl_pw_qpolynomial_fold *
6461         isl_map_apply_pw_qpolynomial_fold(
6462                 __isl_take isl_map *map,
6463                 __isl_take isl_pw_qpolynomial_fold *pwf,
6464                 int *tight);
6465         __isl_give isl_union_pw_qpolynomial_fold *
6466         isl_union_set_apply_union_pw_qpolynomial_fold(
6467                 __isl_take isl_union_set *uset,
6468                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
6469                 int *tight);
6470         __isl_give isl_union_pw_qpolynomial_fold *
6471         isl_union_map_apply_union_pw_qpolynomial_fold(
6472                 __isl_take isl_union_map *umap,
6473                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
6474                 int *tight);
6476 The functions taking a map
6477 compose the given map with the given piecewise quasipolynomial reduction.
6478 That is, compute a bound (of the same type as C<pwf> or C<upwf> itself)
6479 over all elements in the intersection of the range of the map
6480 and the domain of the piecewise quasipolynomial reduction
6481 as a function of an element in the domain of the map.
6482 The functions taking a set compute a bound over all elements in the
6483 intersection of the set and the domain of the
6484 piecewise quasipolynomial reduction.
6486 =item * Preimage
6488         #include <isl/set.h>
6489         __isl_give isl_basic_set *
6490         isl_basic_set_preimage_multi_aff(
6491                 __isl_take isl_basic_set *bset,
6492                 __isl_take isl_multi_aff *ma);
6493         __isl_give isl_set *isl_set_preimage_multi_aff(
6494                 __isl_take isl_set *set,
6495                 __isl_take isl_multi_aff *ma);
6496         __isl_give isl_set *isl_set_preimage_pw_multi_aff(
6497                 __isl_take isl_set *set,
6498                 __isl_take isl_pw_multi_aff *pma);
6499         __isl_give isl_set *isl_set_preimage_multi_pw_aff(
6500                 __isl_take isl_set *set,
6501                 __isl_take isl_multi_pw_aff *mpa);
6503         #include <isl/union_set.h>
6504         __isl_give isl_union_set *
6505         isl_union_set_preimage_multi_aff(
6506                 __isl_take isl_union_set *uset,
6507                 __isl_take isl_multi_aff *ma);
6508         __isl_give isl_union_set *
6509         isl_union_set_preimage_pw_multi_aff(
6510                 __isl_take isl_union_set *uset,
6511                 __isl_take isl_pw_multi_aff *pma);
6512         __isl_give isl_union_set *
6513         isl_union_set_preimage_union_pw_multi_aff(
6514                 __isl_take isl_union_set *uset,
6515                 __isl_take isl_union_pw_multi_aff *upma);
6517         #include <isl/map.h>
6518         __isl_give isl_basic_map *
6519         isl_basic_map_preimage_domain_multi_aff(
6520                 __isl_take isl_basic_map *bmap,
6521                 __isl_take isl_multi_aff *ma);
6522         __isl_give isl_map *isl_map_preimage_domain_multi_aff(
6523                 __isl_take isl_map *map,
6524                 __isl_take isl_multi_aff *ma);
6525         __isl_give isl_map *isl_map_preimage_range_multi_aff(
6526                 __isl_take isl_map *map,
6527                 __isl_take isl_multi_aff *ma);
6528         __isl_give isl_map *
6529         isl_map_preimage_domain_pw_multi_aff(
6530                 __isl_take isl_map *map,
6531                 __isl_take isl_pw_multi_aff *pma);
6532         __isl_give isl_map *
6533         isl_map_preimage_range_pw_multi_aff(
6534                 __isl_take isl_map *map,
6535                 __isl_take isl_pw_multi_aff *pma);
6536         __isl_give isl_map *
6537         isl_map_preimage_domain_multi_pw_aff(
6538                 __isl_take isl_map *map,
6539                 __isl_take isl_multi_pw_aff *mpa);
6540         __isl_give isl_basic_map *
6541         isl_basic_map_preimage_range_multi_aff(
6542                 __isl_take isl_basic_map *bmap,
6543                 __isl_take isl_multi_aff *ma);
6545         #include <isl/union_map.h>
6546         __isl_give isl_union_map *
6547         isl_union_map_preimage_domain_multi_aff(
6548                 __isl_take isl_union_map *umap,
6549                 __isl_take isl_multi_aff *ma);
6550         __isl_give isl_union_map *
6551         isl_union_map_preimage_range_multi_aff(
6552                 __isl_take isl_union_map *umap,
6553                 __isl_take isl_multi_aff *ma);
6554         __isl_give isl_union_map *
6555         isl_union_map_preimage_domain_pw_multi_aff(
6556                 __isl_take isl_union_map *umap,
6557                 __isl_take isl_pw_multi_aff *pma);
6558         __isl_give isl_union_map *
6559         isl_union_map_preimage_range_pw_multi_aff(
6560                 __isl_take isl_union_map *umap,
6561                 __isl_take isl_pw_multi_aff *pma);
6562         __isl_give isl_union_map *
6563         isl_union_map_preimage_domain_union_pw_multi_aff(
6564                 __isl_take isl_union_map *umap,
6565                 __isl_take isl_union_pw_multi_aff *upma);
6566         __isl_give isl_union_map *
6567         isl_union_map_preimage_range_union_pw_multi_aff(
6568                 __isl_take isl_union_map *umap,
6569                 __isl_take isl_union_pw_multi_aff *upma);
6571 These functions compute the preimage of the given set or map domain/range under
6572 the given function.  In other words, the expression is plugged
6573 into the set description or into the domain/range of the map.
6575 =item * Pullback
6577         #include <isl/aff.h>
6578         __isl_give isl_aff *isl_aff_pullback_aff(
6579                 __isl_take isl_aff *aff1,
6580                 __isl_take isl_aff *aff2);
6581         __isl_give isl_aff *isl_aff_pullback_multi_aff(
6582                 __isl_take isl_aff *aff,
6583                 __isl_take isl_multi_aff *ma);
6584         __isl_give isl_pw_aff *isl_pw_aff_pullback_multi_aff(
6585                 __isl_take isl_pw_aff *pa,
6586                 __isl_take isl_multi_aff *ma);
6587         __isl_give isl_pw_aff *isl_pw_aff_pullback_pw_multi_aff(
6588                 __isl_take isl_pw_aff *pa,
6589                 __isl_take isl_pw_multi_aff *pma);
6590         __isl_give isl_pw_aff *isl_pw_aff_pullback_multi_pw_aff(
6591                 __isl_take isl_pw_aff *pa,
6592                 __isl_take isl_multi_pw_aff *mpa);
6593         __isl_give isl_multi_aff *isl_multi_aff_pullback_multi_aff(
6594                 __isl_take isl_multi_aff *ma1,
6595                 __isl_take isl_multi_aff *ma2);
6596         __isl_give isl_pw_multi_aff *
6597         isl_pw_multi_aff_pullback_multi_aff(
6598                 __isl_take isl_pw_multi_aff *pma,
6599                 __isl_take isl_multi_aff *ma);
6600         __isl_give isl_multi_pw_aff *
6601         isl_multi_pw_aff_pullback_multi_aff(
6602                 __isl_take isl_multi_pw_aff *mpa,
6603                 __isl_take isl_multi_aff *ma);
6604         __isl_give isl_pw_multi_aff *
6605         isl_pw_multi_aff_pullback_pw_multi_aff(
6606                 __isl_take isl_pw_multi_aff *pma1,
6607                 __isl_take isl_pw_multi_aff *pma2);
6608         __isl_give isl_multi_pw_aff *
6609         isl_multi_pw_aff_pullback_pw_multi_aff(
6610                 __isl_take isl_multi_pw_aff *mpa,
6611                 __isl_take isl_pw_multi_aff *pma);
6612         __isl_give isl_multi_pw_aff *
6613         isl_multi_pw_aff_pullback_multi_pw_aff(
6614                 __isl_take isl_multi_pw_aff *mpa1,
6615                 __isl_take isl_multi_pw_aff *mpa2);
6616         __isl_give isl_union_pw_aff *
6617         isl_union_pw_aff_pullback_union_pw_multi_aff(
6618                 __isl_take isl_union_pw_aff *upa,
6619                 __isl_take isl_union_pw_multi_aff *upma);
6620         __isl_give isl_union_pw_multi_aff *
6621         isl_union_pw_multi_aff_pullback_union_pw_multi_aff(
6622                 __isl_take isl_union_pw_multi_aff *upma1,
6623                 __isl_take isl_union_pw_multi_aff *upma2);
6624         __isl_give isl_multi_union_pw_aff *
6625         isl_multi_union_pw_aff_pullback_union_pw_multi_aff(
6626                 __isl_take isl_multi_union_pw_aff *mupa,
6627                 __isl_take isl_union_pw_multi_aff *upma);
6629 These functions precompose the first expression by the second function.
6630 In other words, the second function is plugged
6631 into the first expression.
6633 =item * Locus
6635         #include <isl/aff.h>
6636         __isl_give isl_basic_set *isl_aff_eq_basic_set(
6637                 __isl_take isl_aff *aff1,
6638                 __isl_take isl_aff *aff2);
6639         __isl_give isl_set *isl_aff_eq_set(
6640                 __isl_take isl_aff *aff1,
6641                 __isl_take isl_aff *aff2);
6642         __isl_give isl_set *isl_aff_ne_set(
6643                 __isl_take isl_aff *aff1,
6644                 __isl_take isl_aff *aff2);
6645         __isl_give isl_basic_set *isl_aff_le_basic_set(
6646                 __isl_take isl_aff *aff1,
6647                 __isl_take isl_aff *aff2);
6648         __isl_give isl_set *isl_aff_le_set(
6649                 __isl_take isl_aff *aff1,
6650                 __isl_take isl_aff *aff2);
6651         __isl_give isl_basic_set *isl_aff_lt_basic_set(
6652                 __isl_take isl_aff *aff1,
6653                 __isl_take isl_aff *aff2);
6654         __isl_give isl_set *isl_aff_lt_set(
6655                 __isl_take isl_aff *aff1,
6656                 __isl_take isl_aff *aff2);
6657         __isl_give isl_basic_set *isl_aff_ge_basic_set(
6658                 __isl_take isl_aff *aff1,
6659                 __isl_take isl_aff *aff2);
6660         __isl_give isl_set *isl_aff_ge_set(
6661                 __isl_take isl_aff *aff1,
6662                 __isl_take isl_aff *aff2);
6663         __isl_give isl_basic_set *isl_aff_gt_basic_set(
6664                 __isl_take isl_aff *aff1,
6665                 __isl_take isl_aff *aff2);
6666         __isl_give isl_set *isl_aff_gt_set(
6667                 __isl_take isl_aff *aff1,
6668                 __isl_take isl_aff *aff2);
6669         __isl_give isl_set *isl_pw_aff_eq_set(
6670                 __isl_take isl_pw_aff *pwaff1,
6671                 __isl_take isl_pw_aff *pwaff2);
6672         __isl_give isl_set *isl_pw_aff_ne_set(
6673                 __isl_take isl_pw_aff *pwaff1,
6674                 __isl_take isl_pw_aff *pwaff2);
6675         __isl_give isl_set *isl_pw_aff_le_set(
6676                 __isl_take isl_pw_aff *pwaff1,
6677                 __isl_take isl_pw_aff *pwaff2);
6678         __isl_give isl_set *isl_pw_aff_lt_set(
6679                 __isl_take isl_pw_aff *pwaff1,
6680                 __isl_take isl_pw_aff *pwaff2);
6681         __isl_give isl_set *isl_pw_aff_ge_set(
6682                 __isl_take isl_pw_aff *pwaff1,
6683                 __isl_take isl_pw_aff *pwaff2);
6684         __isl_give isl_set *isl_pw_aff_gt_set(
6685                 __isl_take isl_pw_aff *pwaff1,
6686                 __isl_take isl_pw_aff *pwaff2);
6688         __isl_give isl_set *isl_multi_aff_lex_le_set(
6689                 __isl_take isl_multi_aff *ma1,
6690                 __isl_take isl_multi_aff *ma2);
6691         __isl_give isl_set *isl_multi_aff_lex_lt_set(
6692                 __isl_take isl_multi_aff *ma1,
6693                 __isl_take isl_multi_aff *ma2);
6694         __isl_give isl_set *isl_multi_aff_lex_ge_set(
6695                 __isl_take isl_multi_aff *ma1,
6696                 __isl_take isl_multi_aff *ma2);
6697         __isl_give isl_set *isl_multi_aff_lex_gt_set(
6698                 __isl_take isl_multi_aff *ma1,
6699                 __isl_take isl_multi_aff *ma2);
6701         __isl_give isl_set *isl_pw_aff_list_eq_set(
6702                 __isl_take isl_pw_aff_list *list1,
6703                 __isl_take isl_pw_aff_list *list2);
6704         __isl_give isl_set *isl_pw_aff_list_ne_set(
6705                 __isl_take isl_pw_aff_list *list1,
6706                 __isl_take isl_pw_aff_list *list2);
6707         __isl_give isl_set *isl_pw_aff_list_le_set(
6708                 __isl_take isl_pw_aff_list *list1,
6709                 __isl_take isl_pw_aff_list *list2);
6710         __isl_give isl_set *isl_pw_aff_list_lt_set(
6711                 __isl_take isl_pw_aff_list *list1,
6712                 __isl_take isl_pw_aff_list *list2);
6713         __isl_give isl_set *isl_pw_aff_list_ge_set(
6714                 __isl_take isl_pw_aff_list *list1,
6715                 __isl_take isl_pw_aff_list *list2);
6716         __isl_give isl_set *isl_pw_aff_list_gt_set(
6717                 __isl_take isl_pw_aff_list *list1,
6718                 __isl_take isl_pw_aff_list *list2);
6720 The function C<isl_aff_ge_basic_set> returns a basic set
6721 containing those elements in the shared space
6722 of C<aff1> and C<aff2> where C<aff1> is greater than or equal to C<aff2>.
6723 The function C<isl_pw_aff_ge_set> returns a set
6724 containing those elements in the shared domain
6725 of C<pwaff1> and C<pwaff2> where C<pwaff1> is
6726 greater than or equal to C<pwaff2>.
6727 The function C<isl_multi_aff_lex_le_set> returns a set
6728 containing those elements in the shared domain space
6729 where C<ma1> is lexicographically smaller than or
6730 equal to C<ma2>.
6731 The functions operating on C<isl_pw_aff_list> apply the corresponding
6732 C<isl_pw_aff> function to each pair of elements in the two lists.
6734         #include <isl/aff.h>
6735         __isl_give isl_map *isl_pw_aff_eq_map(
6736                 __isl_take isl_pw_aff *pa1,
6737                 __isl_take isl_pw_aff *pa2);
6738         __isl_give isl_map *isl_pw_aff_lt_map(
6739                 __isl_take isl_pw_aff *pa1,
6740                 __isl_take isl_pw_aff *pa2);
6741         __isl_give isl_map *isl_pw_aff_gt_map(
6742                 __isl_take isl_pw_aff *pa1,
6743                 __isl_take isl_pw_aff *pa2);
6745         __isl_give isl_map *isl_multi_pw_aff_eq_map(
6746                 __isl_take isl_multi_pw_aff *mpa1,
6747                 __isl_take isl_multi_pw_aff *mpa2);
6748         __isl_give isl_map *isl_multi_pw_aff_lex_lt_map(
6749                 __isl_take isl_multi_pw_aff *mpa1,
6750                 __isl_take isl_multi_pw_aff *mpa2);
6751         __isl_give isl_map *isl_multi_pw_aff_lex_gt_map(
6752                 __isl_take isl_multi_pw_aff *mpa1,
6753                 __isl_take isl_multi_pw_aff *mpa2);
6755 These functions return a map between domain elements of the arguments
6756 where the function values satisfy the given relation.
6758         #include <isl/union_map.h>
6759         __isl_give isl_union_map *
6760         isl_union_map_eq_at_multi_union_pw_aff(
6761                 __isl_take isl_union_map *umap,
6762                 __isl_take isl_multi_union_pw_aff *mupa);
6763         __isl_give isl_union_map *
6764         isl_union_map_lex_lt_at_multi_union_pw_aff(
6765                 __isl_take isl_union_map *umap,
6766                 __isl_take isl_multi_union_pw_aff *mupa);
6767         __isl_give isl_union_map *
6768         isl_union_map_lex_gt_at_multi_union_pw_aff(
6769                 __isl_take isl_union_map *umap,
6770                 __isl_take isl_multi_union_pw_aff *mupa);
6772 These functions select the subset of elements in the union map
6773 that have an equal or lexicographically smaller function value.
6775 =item * Cartesian Product
6777         #include <isl/space.h>
6778         __isl_give isl_space *isl_space_product(
6779                 __isl_take isl_space *space1,
6780                 __isl_take isl_space *space2);
6781         __isl_give isl_space *isl_space_domain_product(
6782                 __isl_take isl_space *space1,
6783                 __isl_take isl_space *space2);
6784         __isl_give isl_space *isl_space_range_product(
6785                 __isl_take isl_space *space1,
6786                 __isl_take isl_space *space2);
6788 The functions
6789 C<isl_space_product>, C<isl_space_domain_product>
6790 and C<isl_space_range_product> take pairs or relation spaces and
6791 produce a single relations space, where either the domain, the range
6792 or both domain and range are wrapped spaces of relations between
6793 the domains and/or ranges of the input spaces.
6794 If the product is only constructed over the domain or the range
6795 then the ranges or the domains of the inputs should be the same.
6796 The function C<isl_space_product> also accepts a pair of set spaces,
6797 in which case it returns a wrapped space of a relation between the
6798 two input spaces.
6800         #include <isl/set.h>
6801         __isl_give isl_set *isl_set_product(
6802                 __isl_take isl_set *set1,
6803                 __isl_take isl_set *set2);
6805         #include <isl/map.h>
6806         __isl_give isl_basic_map *isl_basic_map_domain_product(
6807                 __isl_take isl_basic_map *bmap1,
6808                 __isl_take isl_basic_map *bmap2);
6809         __isl_give isl_basic_map *isl_basic_map_range_product(
6810                 __isl_take isl_basic_map *bmap1,
6811                 __isl_take isl_basic_map *bmap2);
6812         __isl_give isl_basic_map *isl_basic_map_product(
6813                 __isl_take isl_basic_map *bmap1,
6814                 __isl_take isl_basic_map *bmap2);
6815         __isl_give isl_map *isl_map_domain_product(
6816                 __isl_take isl_map *map1,
6817                 __isl_take isl_map *map2);
6818         __isl_give isl_map *isl_map_range_product(
6819                 __isl_take isl_map *map1,
6820                 __isl_take isl_map *map2);
6821         __isl_give isl_map *isl_map_product(
6822                 __isl_take isl_map *map1,
6823                 __isl_take isl_map *map2);
6825         #include <isl/union_set.h>
6826         __isl_give isl_union_set *isl_union_set_product(
6827                 __isl_take isl_union_set *uset1,
6828                 __isl_take isl_union_set *uset2);
6830         #include <isl/union_map.h>
6831         __isl_give isl_union_map *isl_union_map_domain_product(
6832                 __isl_take isl_union_map *umap1,
6833                 __isl_take isl_union_map *umap2);
6834         __isl_give isl_union_map *isl_union_map_range_product(
6835                 __isl_take isl_union_map *umap1,
6836                 __isl_take isl_union_map *umap2);
6837         __isl_give isl_union_map *isl_union_map_product(
6838                 __isl_take isl_union_map *umap1,
6839                 __isl_take isl_union_map *umap2);
6841         #include <isl/val.h>
6842         __isl_give isl_multi_val *isl_multi_val_range_product(
6843                 __isl_take isl_multi_val *mv1,
6844                 __isl_take isl_multi_val *mv2);
6845         __isl_give isl_multi_val *isl_multi_val_product(
6846                 __isl_take isl_multi_val *mv1,
6847                 __isl_take isl_multi_val *mv2);
6849         #include <isl/aff.h>
6850         __isl_give isl_multi_aff *isl_multi_aff_range_product(
6851                 __isl_take isl_multi_aff *ma1,
6852                 __isl_take isl_multi_aff *ma2);
6853         __isl_give isl_multi_aff *isl_multi_aff_product(
6854                 __isl_take isl_multi_aff *ma1,
6855                 __isl_take isl_multi_aff *ma2);
6856         __isl_give isl_multi_pw_aff *
6857         isl_multi_pw_aff_range_product(
6858                 __isl_take isl_multi_pw_aff *mpa1,
6859                 __isl_take isl_multi_pw_aff *mpa2);
6860         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_product(
6861                 __isl_take isl_multi_pw_aff *mpa1,
6862                 __isl_take isl_multi_pw_aff *mpa2);
6863         __isl_give isl_pw_multi_aff *
6864         isl_pw_multi_aff_range_product(
6865                 __isl_take isl_pw_multi_aff *pma1,
6866                 __isl_take isl_pw_multi_aff *pma2);
6867         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_product(
6868                 __isl_take isl_pw_multi_aff *pma1,
6869                 __isl_take isl_pw_multi_aff *pma2);
6870         __isl_give isl_multi_union_pw_aff *
6871         isl_multi_union_pw_aff_range_product(
6872                 __isl_take isl_multi_union_pw_aff *mupa1,
6873                 __isl_take isl_multi_union_pw_aff *mupa2);
6875 The above functions compute the cross product of the given
6876 sets, relations or functions.  The domains and ranges of the results
6877 are wrapped maps between domains and ranges of the inputs.
6878 To obtain a ``flat'' product, use the following functions
6879 instead.
6881         #include <isl/set.h>
6882         __isl_give isl_basic_set *isl_basic_set_flat_product(
6883                 __isl_take isl_basic_set *bset1,
6884                 __isl_take isl_basic_set *bset2);
6885         __isl_give isl_set *isl_set_flat_product(
6886                 __isl_take isl_set *set1,
6887                 __isl_take isl_set *set2);
6889         #include <isl/map.h>
6890         __isl_give isl_basic_map *isl_basic_map_flat_range_product(
6891                 __isl_take isl_basic_map *bmap1,
6892                 __isl_take isl_basic_map *bmap2);
6893         __isl_give isl_map *isl_map_flat_domain_product(
6894                 __isl_take isl_map *map1,
6895                 __isl_take isl_map *map2);
6896         __isl_give isl_map *isl_map_flat_range_product(
6897                 __isl_take isl_map *map1,
6898                 __isl_take isl_map *map2);
6899         __isl_give isl_basic_map *isl_basic_map_flat_product(
6900                 __isl_take isl_basic_map *bmap1,
6901                 __isl_take isl_basic_map *bmap2);
6902         __isl_give isl_map *isl_map_flat_product(
6903                 __isl_take isl_map *map1,
6904                 __isl_take isl_map *map2);
6906         #include <isl/union_map.h>
6907         __isl_give isl_union_map *
6908         isl_union_map_flat_domain_product(
6909                 __isl_take isl_union_map *umap1,
6910                 __isl_take isl_union_map *umap2);
6911         __isl_give isl_union_map *
6912         isl_union_map_flat_range_product(
6913                 __isl_take isl_union_map *umap1,
6914                 __isl_take isl_union_map *umap2);
6916         #include <isl/val.h>
6917         __isl_give isl_multi_val *isl_multi_val_flat_range_product(
6918                 __isl_take isl_multi_val *mv1,
6919                 __isl_take isl_multi_val *mv2);
6921         #include <isl/aff.h>
6922         __isl_give isl_multi_aff *isl_multi_aff_flat_range_product(
6923                 __isl_take isl_multi_aff *ma1,
6924                 __isl_take isl_multi_aff *ma2);
6925         __isl_give isl_pw_multi_aff *
6926         isl_pw_multi_aff_flat_range_product(
6927                 __isl_take isl_pw_multi_aff *pma1,
6928                 __isl_take isl_pw_multi_aff *pma2);
6929         __isl_give isl_multi_pw_aff *
6930         isl_multi_pw_aff_flat_range_product(
6931                 __isl_take isl_multi_pw_aff *mpa1,
6932                 __isl_take isl_multi_pw_aff *mpa2);
6933         __isl_give isl_union_pw_multi_aff *
6934         isl_union_pw_multi_aff_flat_range_product(
6935                 __isl_take isl_union_pw_multi_aff *upma1,
6936                 __isl_take isl_union_pw_multi_aff *upma2);
6937         __isl_give isl_multi_union_pw_aff *
6938         isl_multi_union_pw_aff_flat_range_product(
6939                 __isl_take isl_multi_union_pw_aff *mupa1,
6940                 __isl_take isl_multi_union_pw_aff *mupa2);
6942         #include <isl/space.h>
6943         __isl_give isl_space *isl_space_factor_domain(
6944                 __isl_take isl_space *space);
6945         __isl_give isl_space *isl_space_factor_range(
6946                 __isl_take isl_space *space);
6947         __isl_give isl_space *isl_space_domain_factor_domain(
6948                 __isl_take isl_space *space);
6949         __isl_give isl_space *isl_space_domain_factor_range(
6950                 __isl_take isl_space *space);
6951         __isl_give isl_space *isl_space_range_factor_domain(
6952                 __isl_take isl_space *space);
6953         __isl_give isl_space *isl_space_range_factor_range(
6954                 __isl_take isl_space *space);
6956 The functions C<isl_space_range_factor_domain> and
6957 C<isl_space_range_factor_range> extract the two arguments from
6958 the result of a call to C<isl_space_range_product>.
6960 The arguments of a call to a product can be extracted
6961 from the result using the following functions.
6963         #include <isl/map.h>
6964         __isl_give isl_map *isl_map_factor_domain(
6965                 __isl_take isl_map *map);
6966         __isl_give isl_map *isl_map_factor_range(
6967                 __isl_take isl_map *map);
6968         __isl_give isl_map *isl_map_domain_factor_domain(
6969                 __isl_take isl_map *map);
6970         __isl_give isl_map *isl_map_domain_factor_range(
6971                 __isl_take isl_map *map);
6972         __isl_give isl_map *isl_map_range_factor_domain(
6973                 __isl_take isl_map *map);
6974         __isl_give isl_map *isl_map_range_factor_range(
6975                 __isl_take isl_map *map);
6977         #include <isl/union_map.h>
6978         __isl_give isl_union_map *isl_union_map_factor_domain(
6979                 __isl_take isl_union_map *umap);
6980         __isl_give isl_union_map *isl_union_map_factor_range(
6981                 __isl_take isl_union_map *umap);
6982         __isl_give isl_union_map *
6983         isl_union_map_domain_factor_domain(
6984                 __isl_take isl_union_map *umap);
6985         __isl_give isl_union_map *
6986         isl_union_map_domain_factor_range(
6987                 __isl_take isl_union_map *umap);
6988         __isl_give isl_union_map *
6989         isl_union_map_range_factor_domain(
6990                 __isl_take isl_union_map *umap);
6991         __isl_give isl_union_map *
6992         isl_union_map_range_factor_range(
6993                 __isl_take isl_union_map *umap);
6995         #include <isl/val.h>
6996         __isl_give isl_multi_val *isl_multi_val_factor_range(
6997                 __isl_take isl_multi_val *mv);
6998         __isl_give isl_multi_val *
6999         isl_multi_val_range_factor_domain(
7000                 __isl_take isl_multi_val *mv);
7001         __isl_give isl_multi_val *
7002         isl_multi_val_range_factor_range(
7003                 __isl_take isl_multi_val *mv);
7005         #include <isl/aff.h>
7006         __isl_give isl_multi_aff *isl_multi_aff_factor_range(
7007                 __isl_take isl_multi_aff *ma);
7008         __isl_give isl_multi_aff *
7009         isl_multi_aff_range_factor_domain(
7010                 __isl_take isl_multi_aff *ma);
7011         __isl_give isl_multi_aff *
7012         isl_multi_aff_range_factor_range(
7013                 __isl_take isl_multi_aff *ma);
7014         __isl_give isl_multi_pw_aff *
7015         isl_multi_pw_aff_factor_range(
7016                 __isl_take isl_multi_pw_aff *mpa);
7017         __isl_give isl_multi_pw_aff *
7018         isl_multi_pw_aff_range_factor_domain(
7019                 __isl_take isl_multi_pw_aff *mpa);
7020         __isl_give isl_multi_pw_aff *
7021         isl_multi_pw_aff_range_factor_range(
7022                 __isl_take isl_multi_pw_aff *mpa);
7023         __isl_give isl_multi_union_pw_aff *
7024         isl_multi_union_pw_aff_factor_range(
7025                 __isl_take isl_multi_union_pw_aff *mupa);
7026         __isl_give isl_multi_union_pw_aff *
7027         isl_multi_union_pw_aff_range_factor_domain(
7028                 __isl_take isl_multi_union_pw_aff *mupa);
7029         __isl_give isl_multi_union_pw_aff *
7030         isl_multi_union_pw_aff_range_factor_range(
7031                 __isl_take isl_multi_union_pw_aff *mupa);
7033 The splice functions are a generalization of the flat product functions,
7034 where the second argument may be inserted at any position inside
7035 the first argument rather than being placed at the end.
7036 The functions C<isl_multi_val_factor_range>,
7037 C<isl_multi_aff_factor_range>,
7038 C<isl_multi_pw_aff_factor_range> and
7039 C<isl_multi_union_pw_aff_factor_range>
7040 take functions that live in a set space.
7042         #include <isl/val.h>
7043         __isl_give isl_multi_val *isl_multi_val_range_splice(
7044                 __isl_take isl_multi_val *mv1, unsigned pos,
7045                 __isl_take isl_multi_val *mv2);
7047         #include <isl/aff.h>
7048         __isl_give isl_multi_aff *isl_multi_aff_range_splice(
7049                 __isl_take isl_multi_aff *ma1, unsigned pos,
7050                 __isl_take isl_multi_aff *ma2);
7051         __isl_give isl_multi_aff *isl_multi_aff_splice(
7052                 __isl_take isl_multi_aff *ma1,
7053                 unsigned in_pos, unsigned out_pos,
7054                 __isl_take isl_multi_aff *ma2);
7055         __isl_give isl_multi_pw_aff *
7056         isl_multi_pw_aff_range_splice(
7057                 __isl_take isl_multi_pw_aff *mpa1, unsigned pos,
7058                 __isl_take isl_multi_pw_aff *mpa2);
7059         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_splice(
7060                 __isl_take isl_multi_pw_aff *mpa1,
7061                 unsigned in_pos, unsigned out_pos,
7062                 __isl_take isl_multi_pw_aff *mpa2);
7063         __isl_give isl_multi_union_pw_aff *
7064         isl_multi_union_pw_aff_range_splice(
7065                 __isl_take isl_multi_union_pw_aff *mupa1,
7066                 unsigned pos,
7067                 __isl_take isl_multi_union_pw_aff *mupa2);
7069 =item * Simplification
7071 When applied to a set or relation,
7072 the gist operation returns a set or relation that has the
7073 same intersection with the context as the input set or relation.
7074 Any implicit equality in the intersection is made explicit in the result,
7075 while all inequalities that are redundant with respect to the intersection
7076 are removed.
7077 In case of union sets and relations, the gist operation is performed
7078 per space.
7080 When applied to a function,
7081 the gist operation applies the set gist operation to each of
7082 the cells in the domain of the input piecewise expression.
7083 The context is also exploited
7084 to simplify the expression associated to each cell.
7086         #include <isl/set.h>
7087         __isl_give isl_basic_set *isl_basic_set_gist(
7088                 __isl_take isl_basic_set *bset,
7089                 __isl_take isl_basic_set *context);
7090         __isl_give isl_set *isl_set_gist(__isl_take isl_set *set,
7091                 __isl_take isl_set *context);
7092         __isl_give isl_set *isl_set_gist_params(
7093                 __isl_take isl_set *set,
7094                 __isl_take isl_set *context);
7096         #include <isl/map.h>
7097         __isl_give isl_basic_map *isl_basic_map_gist(
7098                 __isl_take isl_basic_map *bmap,
7099                 __isl_take isl_basic_map *context);
7100         __isl_give isl_basic_map *isl_basic_map_gist_domain(
7101                 __isl_take isl_basic_map *bmap,
7102                 __isl_take isl_basic_set *context);
7103         __isl_give isl_map *isl_map_gist(__isl_take isl_map *map,
7104                 __isl_take isl_map *context);
7105         __isl_give isl_map *isl_map_gist_params(
7106                 __isl_take isl_map *map,
7107                 __isl_take isl_set *context);
7108         __isl_give isl_map *isl_map_gist_domain(
7109                 __isl_take isl_map *map,
7110                 __isl_take isl_set *context);
7111         __isl_give isl_map *isl_map_gist_range(
7112                 __isl_take isl_map *map,
7113                 __isl_take isl_set *context);
7115         #include <isl/union_set.h>
7116         __isl_give isl_union_set *isl_union_set_gist(
7117                 __isl_take isl_union_set *uset,
7118                 __isl_take isl_union_set *context);
7119         __isl_give isl_union_set *isl_union_set_gist_params(
7120                 __isl_take isl_union_set *uset,
7121                 __isl_take isl_set *set);
7123         #include <isl/union_map.h>
7124         __isl_give isl_union_map *isl_union_map_gist(
7125                 __isl_take isl_union_map *umap,
7126                 __isl_take isl_union_map *context);
7127         __isl_give isl_union_map *isl_union_map_gist_params(
7128                 __isl_take isl_union_map *umap,
7129                 __isl_take isl_set *set);
7130         __isl_give isl_union_map *isl_union_map_gist_domain(
7131                 __isl_take isl_union_map *umap,
7132                 __isl_take isl_union_set *uset);
7133         __isl_give isl_union_map *isl_union_map_gist_range(
7134                 __isl_take isl_union_map *umap,
7135                 __isl_take isl_union_set *uset);
7137         #include <isl/aff.h>
7138         __isl_give isl_aff *isl_aff_gist_params(
7139                 __isl_take isl_aff *aff,
7140                 __isl_take isl_set *context);
7141         __isl_give isl_aff *isl_aff_gist(__isl_take isl_aff *aff,
7142                 __isl_take isl_set *context);
7143         __isl_give isl_multi_aff *isl_multi_aff_gist_params(
7144                 __isl_take isl_multi_aff *maff,
7145                 __isl_take isl_set *context);
7146         __isl_give isl_multi_aff *isl_multi_aff_gist(
7147                 __isl_take isl_multi_aff *maff,
7148                 __isl_take isl_set *context);
7149         __isl_give isl_pw_aff *isl_pw_aff_gist_params(
7150                 __isl_take isl_pw_aff *pwaff,
7151                 __isl_take isl_set *context);
7152         __isl_give isl_pw_aff *isl_pw_aff_gist(
7153                 __isl_take isl_pw_aff *pwaff,
7154                 __isl_take isl_set *context);
7155         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_gist_params(
7156                 __isl_take isl_pw_multi_aff *pma,
7157                 __isl_take isl_set *set);
7158         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_gist(
7159                 __isl_take isl_pw_multi_aff *pma,
7160                 __isl_take isl_set *set);
7161         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_gist_params(
7162                 __isl_take isl_multi_pw_aff *mpa,
7163                 __isl_take isl_set *set);
7164         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_gist(
7165                 __isl_take isl_multi_pw_aff *mpa,
7166                 __isl_take isl_set *set);
7167         __isl_give isl_union_pw_aff *isl_union_pw_aff_gist(
7168                 __isl_take isl_union_pw_aff *upa,
7169                 __isl_take isl_union_set *context);
7170         __isl_give isl_union_pw_aff *isl_union_pw_aff_gist_params(
7171                 __isl_take isl_union_pw_aff *upa,
7172                 __isl_take isl_set *context);
7173         __isl_give isl_union_pw_multi_aff *
7174         isl_union_pw_multi_aff_gist_params(
7175                 __isl_take isl_union_pw_multi_aff *upma,
7176                 __isl_take isl_set *context);
7177         __isl_give isl_union_pw_multi_aff *
7178         isl_union_pw_multi_aff_gist(
7179                 __isl_take isl_union_pw_multi_aff *upma,
7180                 __isl_take isl_union_set *context);
7181         __isl_give isl_multi_union_pw_aff *
7182         isl_multi_union_pw_aff_gist_params(
7183                 __isl_take isl_multi_union_pw_aff *aff,
7184                 __isl_take isl_set *context);
7185         __isl_give isl_multi_union_pw_aff *
7186         isl_multi_union_pw_aff_gist(
7187                 __isl_take isl_multi_union_pw_aff *aff,
7188                 __isl_take isl_union_set *context);
7190         #include <isl/polynomial.h>
7191         __isl_give isl_qpolynomial *isl_qpolynomial_gist_params(
7192                 __isl_take isl_qpolynomial *qp,
7193                 __isl_take isl_set *context);
7194         __isl_give isl_qpolynomial *isl_qpolynomial_gist(
7195                 __isl_take isl_qpolynomial *qp,
7196                 __isl_take isl_set *context);
7197         __isl_give isl_qpolynomial_fold *
7198         isl_qpolynomial_fold_gist_params(
7199                 __isl_take isl_qpolynomial_fold *fold,
7200                 __isl_take isl_set *context);
7201         __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_gist(
7202                 __isl_take isl_qpolynomial_fold *fold,
7203                 __isl_take isl_set *context);
7204         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_gist_params(
7205                 __isl_take isl_pw_qpolynomial *pwqp,
7206                 __isl_take isl_set *context);
7207         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_gist(
7208                 __isl_take isl_pw_qpolynomial *pwqp,
7209                 __isl_take isl_set *context);
7210         __isl_give isl_pw_qpolynomial_fold *
7211         isl_pw_qpolynomial_fold_gist(
7212                 __isl_take isl_pw_qpolynomial_fold *pwf,
7213                 __isl_take isl_set *context);
7214         __isl_give isl_pw_qpolynomial_fold *
7215         isl_pw_qpolynomial_fold_gist_params(
7216                 __isl_take isl_pw_qpolynomial_fold *pwf,
7217                 __isl_take isl_set *context);
7218         __isl_give isl_union_pw_qpolynomial *
7219         isl_union_pw_qpolynomial_gist_params(
7220                 __isl_take isl_union_pw_qpolynomial *upwqp,
7221                 __isl_take isl_set *context);
7222         __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_gist(
7223                 __isl_take isl_union_pw_qpolynomial *upwqp,
7224                 __isl_take isl_union_set *context);
7225         __isl_give isl_union_pw_qpolynomial_fold *
7226         isl_union_pw_qpolynomial_fold_gist(
7227                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
7228                 __isl_take isl_union_set *context);
7229         __isl_give isl_union_pw_qpolynomial_fold *
7230         isl_union_pw_qpolynomial_fold_gist_params(
7231                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
7232                 __isl_take isl_set *context);
7234 =item * Binary Arithmetic Operations
7236         #include <isl/set.h>
7237         __isl_give isl_set *isl_set_sum(
7238                 __isl_take isl_set *set1,
7239                 __isl_take isl_set *set2);
7240         #include <isl/map.h>
7241         __isl_give isl_map *isl_map_sum(
7242                 __isl_take isl_map *map1,
7243                 __isl_take isl_map *map2);
7245 C<isl_set_sum> computes the Minkowski sum of its two arguments,
7246 i.e., the set containing the sums of pairs of elements from
7247 C<set1> and C<set2>.
7248 The domain of the result of C<isl_map_sum> is the intersection
7249 of the domains of its two arguments.  The corresponding range
7250 elements are the sums of the corresponding range elements
7251 in the two arguments.
7253         #include <isl/val.h>
7254         __isl_give isl_multi_val *isl_multi_val_add(
7255                 __isl_take isl_multi_val *mv1,
7256                 __isl_take isl_multi_val *mv2);
7257         __isl_give isl_multi_val *isl_multi_val_sub(
7258                 __isl_take isl_multi_val *mv1,
7259                 __isl_take isl_multi_val *mv2);
7261         #include <isl/aff.h>
7262         __isl_give isl_aff *isl_aff_add(
7263                 __isl_take isl_aff *aff1,
7264                 __isl_take isl_aff *aff2);
7265         __isl_give isl_multi_aff *isl_multi_aff_add(
7266                 __isl_take isl_multi_aff *maff1,
7267                 __isl_take isl_multi_aff *maff2);
7268         __isl_give isl_pw_aff *isl_pw_aff_add(
7269                 __isl_take isl_pw_aff *pwaff1,
7270                 __isl_take isl_pw_aff *pwaff2);
7271         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_add(
7272                 __isl_take isl_multi_pw_aff *mpa1,
7273                 __isl_take isl_multi_pw_aff *mpa2);
7274         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_add(
7275                 __isl_take isl_pw_multi_aff *pma1,
7276                 __isl_take isl_pw_multi_aff *pma2);
7277         __isl_give isl_union_pw_aff *isl_union_pw_aff_add(
7278                 __isl_take isl_union_pw_aff *upa1,
7279                 __isl_take isl_union_pw_aff *upa2);
7280         __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_add(
7281                 __isl_take isl_union_pw_multi_aff *upma1,
7282                 __isl_take isl_union_pw_multi_aff *upma2);
7283         __isl_give isl_multi_union_pw_aff *
7284         isl_multi_union_pw_aff_add(
7285                 __isl_take isl_multi_union_pw_aff *mupa1,
7286                 __isl_take isl_multi_union_pw_aff *mupa2);
7287         __isl_give isl_pw_aff *isl_pw_aff_min(
7288                 __isl_take isl_pw_aff *pwaff1,
7289                 __isl_take isl_pw_aff *pwaff2);
7290         __isl_give isl_pw_aff *isl_pw_aff_max(
7291                 __isl_take isl_pw_aff *pwaff1,
7292                 __isl_take isl_pw_aff *pwaff2);
7293         __isl_give isl_aff *isl_aff_sub(
7294                 __isl_take isl_aff *aff1,
7295                 __isl_take isl_aff *aff2);
7296         __isl_give isl_multi_aff *isl_multi_aff_sub(
7297                 __isl_take isl_multi_aff *ma1,
7298                 __isl_take isl_multi_aff *ma2);
7299         __isl_give isl_pw_aff *isl_pw_aff_sub(
7300                 __isl_take isl_pw_aff *pwaff1,
7301                 __isl_take isl_pw_aff *pwaff2);
7302         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_sub(
7303                 __isl_take isl_multi_pw_aff *mpa1,
7304                 __isl_take isl_multi_pw_aff *mpa2);
7305         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_sub(
7306                 __isl_take isl_pw_multi_aff *pma1,
7307                 __isl_take isl_pw_multi_aff *pma2);
7308         __isl_give isl_union_pw_aff *isl_union_pw_aff_sub(
7309                 __isl_take isl_union_pw_aff *upa1,
7310                 __isl_take isl_union_pw_aff *upa2);
7311         __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_sub(
7312                 __isl_take isl_union_pw_multi_aff *upma1,
7313                 __isl_take isl_union_pw_multi_aff *upma2);
7314         __isl_give isl_multi_union_pw_aff *
7315         isl_multi_union_pw_aff_sub(
7316                 __isl_take isl_multi_union_pw_aff *mupa1,
7317                 __isl_take isl_multi_union_pw_aff *mupa2);
7319 C<isl_aff_sub> subtracts the second argument from the first.
7321         #include <isl/polynomial.h>
7322         __isl_give isl_qpolynomial *isl_qpolynomial_add(
7323                 __isl_take isl_qpolynomial *qp1,
7324                 __isl_take isl_qpolynomial *qp2);
7325         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add(
7326                 __isl_take isl_pw_qpolynomial *pwqp1,
7327                 __isl_take isl_pw_qpolynomial *pwqp2);
7328         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add_disjoint(
7329                 __isl_take isl_pw_qpolynomial *pwqp1,
7330                 __isl_take isl_pw_qpolynomial *pwqp2);
7331         __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_add(
7332                 __isl_take isl_pw_qpolynomial_fold *pwf1,
7333                 __isl_take isl_pw_qpolynomial_fold *pwf2);
7334         __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_add(
7335                 __isl_take isl_union_pw_qpolynomial *upwqp1,
7336                 __isl_take isl_union_pw_qpolynomial *upwqp2);
7337         __isl_give isl_qpolynomial *isl_qpolynomial_sub(
7338                 __isl_take isl_qpolynomial *qp1,
7339                 __isl_take isl_qpolynomial *qp2);
7340         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_sub(
7341                 __isl_take isl_pw_qpolynomial *pwqp1,
7342                 __isl_take isl_pw_qpolynomial *pwqp2);
7343         __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_sub(
7344                 __isl_take isl_union_pw_qpolynomial *upwqp1,
7345                 __isl_take isl_union_pw_qpolynomial *upwqp2);
7346         __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_fold(
7347                 __isl_take isl_pw_qpolynomial_fold *pwf1,
7348                 __isl_take isl_pw_qpolynomial_fold *pwf2);
7349         __isl_give isl_union_pw_qpolynomial_fold *
7350         isl_union_pw_qpolynomial_fold_fold(
7351                 __isl_take isl_union_pw_qpolynomial_fold *upwf1,
7352                 __isl_take isl_union_pw_qpolynomial_fold *upwf2);
7354         #include <isl/aff.h>
7355         __isl_give isl_pw_aff *isl_pw_aff_union_add(
7356                 __isl_take isl_pw_aff *pwaff1,
7357                 __isl_take isl_pw_aff *pwaff2);
7358         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_add(
7359                 __isl_take isl_pw_multi_aff *pma1,
7360                 __isl_take isl_pw_multi_aff *pma2);
7361         __isl_give isl_union_pw_aff *isl_union_pw_aff_union_add(
7362                 __isl_take isl_union_pw_aff *upa1,
7363                 __isl_take isl_union_pw_aff *upa2);
7364         __isl_give isl_union_pw_multi_aff *
7365         isl_union_pw_multi_aff_union_add(
7366                 __isl_take isl_union_pw_multi_aff *upma1,
7367                 __isl_take isl_union_pw_multi_aff *upma2);
7368         __isl_give isl_multi_union_pw_aff *
7369         isl_multi_union_pw_aff_union_add(
7370                 __isl_take isl_multi_union_pw_aff *mupa1,
7371                 __isl_take isl_multi_union_pw_aff *mupa2);
7372         __isl_give isl_pw_aff *isl_pw_aff_union_min(
7373                 __isl_take isl_pw_aff *pwaff1,
7374                 __isl_take isl_pw_aff *pwaff2);
7375         __isl_give isl_pw_aff *isl_pw_aff_union_max(
7376                 __isl_take isl_pw_aff *pwaff1,
7377                 __isl_take isl_pw_aff *pwaff2);
7379 The function C<isl_pw_aff_union_max> computes a piecewise quasi-affine
7380 expression with a domain that is the union of those of C<pwaff1> and
7381 C<pwaff2> and such that on each cell, the quasi-affine expression is
7382 the maximum of those of C<pwaff1> and C<pwaff2>.  If only one of
7383 C<pwaff1> or C<pwaff2> is defined on a given cell, then the
7384 associated expression is the defined one.
7385 This in contrast to the C<isl_pw_aff_max> function, which is
7386 only defined on the shared definition domain of the arguments.
7388         #include <isl/val.h>
7389         __isl_give isl_multi_val *isl_multi_val_add_val(
7390                 __isl_take isl_multi_val *mv,
7391                 __isl_take isl_val *v);
7392         __isl_give isl_multi_val *isl_multi_val_mod_val(
7393                 __isl_take isl_multi_val *mv,
7394                 __isl_take isl_val *v);
7395         __isl_give isl_multi_val *isl_multi_val_scale_val(
7396                 __isl_take isl_multi_val *mv,
7397                 __isl_take isl_val *v);
7398         __isl_give isl_multi_val *isl_multi_val_scale_down_val(
7399                 __isl_take isl_multi_val *mv,
7400                 __isl_take isl_val *v);
7402         #include <isl/aff.h>
7403         __isl_give isl_aff *isl_aff_mod_val(__isl_take isl_aff *aff,
7404                 __isl_take isl_val *mod);
7405         __isl_give isl_pw_aff *isl_pw_aff_mod_val(
7406                 __isl_take isl_pw_aff *pa,
7407                 __isl_take isl_val *mod);
7408         __isl_give isl_union_pw_aff *isl_union_pw_aff_mod_val(
7409                 __isl_take isl_union_pw_aff *upa,
7410                 __isl_take isl_val *f);
7411         __isl_give isl_aff *isl_aff_scale_val(__isl_take isl_aff *aff,
7412                 __isl_take isl_val *v);
7413         __isl_give isl_multi_aff *isl_multi_aff_scale_val(
7414                 __isl_take isl_multi_aff *ma,
7415                 __isl_take isl_val *v);
7416         __isl_give isl_pw_aff *isl_pw_aff_scale_val(
7417                 __isl_take isl_pw_aff *pa, __isl_take isl_val *v);
7418         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_scale_val(
7419                 __isl_take isl_multi_pw_aff *mpa,
7420                 __isl_take isl_val *v);
7421         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_scale_val(
7422                 __isl_take isl_pw_multi_aff *pma,
7423                 __isl_take isl_val *v);
7424         __isl_give isl_union_pw_multi_aff *
7425         __isl_give isl_union_pw_aff *isl_union_pw_aff_scale_val(
7426                 __isl_take isl_union_pw_aff *upa,
7427                 __isl_take isl_val *f);
7428         isl_union_pw_multi_aff_scale_val(
7429                 __isl_take isl_union_pw_multi_aff *upma,
7430                 __isl_take isl_val *val);
7431         __isl_give isl_multi_union_pw_aff *
7432         isl_multi_union_pw_aff_scale_val(
7433                 __isl_take isl_multi_union_pw_aff *mupa,
7434                 __isl_take isl_val *v);
7435         __isl_give isl_aff *isl_aff_scale_down_ui(
7436                 __isl_take isl_aff *aff, unsigned f);
7437         __isl_give isl_aff *isl_aff_scale_down_val(
7438                 __isl_take isl_aff *aff, __isl_take isl_val *v);
7439         __isl_give isl_multi_aff *isl_multi_aff_scale_down_val(
7440                 __isl_take isl_multi_aff *ma,
7441                 __isl_take isl_val *v);
7442         __isl_give isl_pw_aff *isl_pw_aff_scale_down_val(
7443                 __isl_take isl_pw_aff *pa,
7444                 __isl_take isl_val *f);
7445         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_scale_down_val(
7446                 __isl_take isl_multi_pw_aff *mpa,
7447                 __isl_take isl_val *v);
7448         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_scale_down_val(
7449                 __isl_take isl_pw_multi_aff *pma,
7450                 __isl_take isl_val *v);
7451         __isl_give isl_union_pw_aff *isl_union_pw_aff_scale_down_val(
7452                 __isl_take isl_union_pw_aff *upa,
7453                 __isl_take isl_val *v);
7454         __isl_give isl_union_pw_multi_aff *
7455         isl_union_pw_multi_aff_scale_down_val(
7456                 __isl_take isl_union_pw_multi_aff *upma,
7457                 __isl_take isl_val *val);
7458         __isl_give isl_multi_union_pw_aff *
7459         isl_multi_union_pw_aff_scale_down_val(
7460                 __isl_take isl_multi_union_pw_aff *mupa,
7461                 __isl_take isl_val *v);
7463         #include <isl/polynomial.h>
7464         __isl_give isl_qpolynomial *isl_qpolynomial_scale_val(
7465                 __isl_take isl_qpolynomial *qp,
7466                 __isl_take isl_val *v);
7467         __isl_give isl_qpolynomial_fold *
7468         isl_qpolynomial_fold_scale_val(
7469                 __isl_take isl_qpolynomial_fold *fold,
7470                 __isl_take isl_val *v);
7471         __isl_give isl_pw_qpolynomial *
7472         isl_pw_qpolynomial_scale_val(
7473                 __isl_take isl_pw_qpolynomial *pwqp,
7474                 __isl_take isl_val *v);
7475         __isl_give isl_pw_qpolynomial_fold *
7476         isl_pw_qpolynomial_fold_scale_val(
7477                 __isl_take isl_pw_qpolynomial_fold *pwf,
7478                 __isl_take isl_val *v);
7479         __isl_give isl_union_pw_qpolynomial *
7480         isl_union_pw_qpolynomial_scale_val(
7481                 __isl_take isl_union_pw_qpolynomial *upwqp,
7482                 __isl_take isl_val *v);
7483         __isl_give isl_union_pw_qpolynomial_fold *
7484         isl_union_pw_qpolynomial_fold_scale_val(
7485                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
7486                 __isl_take isl_val *v);
7487         __isl_give isl_qpolynomial *
7488         isl_qpolynomial_scale_down_val(
7489                 __isl_take isl_qpolynomial *qp,
7490                 __isl_take isl_val *v);
7491         __isl_give isl_qpolynomial_fold *
7492         isl_qpolynomial_fold_scale_down_val(
7493                 __isl_take isl_qpolynomial_fold *fold,
7494                 __isl_take isl_val *v);
7495         __isl_give isl_pw_qpolynomial *
7496         isl_pw_qpolynomial_scale_down_val(
7497                 __isl_take isl_pw_qpolynomial *pwqp,
7498                 __isl_take isl_val *v);
7499         __isl_give isl_pw_qpolynomial_fold *
7500         isl_pw_qpolynomial_fold_scale_down_val(
7501                 __isl_take isl_pw_qpolynomial_fold *pwf,
7502                 __isl_take isl_val *v);
7503         __isl_give isl_union_pw_qpolynomial *
7504         isl_union_pw_qpolynomial_scale_down_val(
7505                 __isl_take isl_union_pw_qpolynomial *upwqp,
7506                 __isl_take isl_val *v);
7507         __isl_give isl_union_pw_qpolynomial_fold *
7508         isl_union_pw_qpolynomial_fold_scale_down_val(
7509                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
7510                 __isl_take isl_val *v);
7512         #include <isl/val.h>
7513         __isl_give isl_multi_val *isl_multi_val_mod_multi_val(
7514                 __isl_take isl_multi_val *mv1,
7515                 __isl_take isl_multi_val *mv2);
7516         __isl_give isl_multi_val *isl_multi_val_scale_multi_val(
7517                 __isl_take isl_multi_val *mv1,
7518                 __isl_take isl_multi_val *mv2);
7519         __isl_give isl_multi_val *
7520         isl_multi_val_scale_down_multi_val(
7521                 __isl_take isl_multi_val *mv1,
7522                 __isl_take isl_multi_val *mv2);
7524         #include <isl/aff.h>
7525         __isl_give isl_multi_aff *isl_multi_aff_mod_multi_val(
7526                 __isl_take isl_multi_aff *ma,
7527                 __isl_take isl_multi_val *mv);
7528         __isl_give isl_multi_union_pw_aff *
7529         isl_multi_union_pw_aff_mod_multi_val(
7530                 __isl_take isl_multi_union_pw_aff *upma,
7531                 __isl_take isl_multi_val *mv);
7532         __isl_give isl_multi_pw_aff *
7533         isl_multi_pw_aff_mod_multi_val(
7534                 __isl_take isl_multi_pw_aff *mpa,
7535                 __isl_take isl_multi_val *mv);
7536         __isl_give isl_multi_aff *isl_multi_aff_scale_multi_val(
7537                 __isl_take isl_multi_aff *ma,
7538                 __isl_take isl_multi_val *mv);
7539         __isl_give isl_pw_multi_aff *
7540         isl_pw_multi_aff_scale_multi_val(
7541                 __isl_take isl_pw_multi_aff *pma,
7542                 __isl_take isl_multi_val *mv);
7543         __isl_give isl_multi_pw_aff *
7544         isl_multi_pw_aff_scale_multi_val(
7545                 __isl_take isl_multi_pw_aff *mpa,
7546                 __isl_take isl_multi_val *mv);
7547         __isl_give isl_multi_union_pw_aff *
7548         isl_multi_union_pw_aff_scale_multi_val(
7549                 __isl_take isl_multi_union_pw_aff *mupa,
7550                 __isl_take isl_multi_val *mv);
7551         __isl_give isl_union_pw_multi_aff *
7552         isl_union_pw_multi_aff_scale_multi_val(
7553                 __isl_take isl_union_pw_multi_aff *upma,
7554                 __isl_take isl_multi_val *mv);
7555         __isl_give isl_multi_aff *
7556         isl_multi_aff_scale_down_multi_val(
7557                 __isl_take isl_multi_aff *ma,
7558                 __isl_take isl_multi_val *mv);
7559         __isl_give isl_multi_pw_aff *
7560         isl_multi_pw_aff_scale_down_multi_val(
7561                 __isl_take isl_multi_pw_aff *mpa,
7562                 __isl_take isl_multi_val *mv);
7563         __isl_give isl_multi_union_pw_aff *
7564         isl_multi_union_pw_aff_scale_down_multi_val(
7565                 __isl_take isl_multi_union_pw_aff *mupa,
7566                 __isl_take isl_multi_val *mv);
7568 C<isl_multi_aff_scale_multi_val> scales the elements of C<ma>
7569 by the corresponding elements of C<mv>.
7571         #include <isl/aff.h>
7572         __isl_give isl_aff *isl_aff_mul(
7573                 __isl_take isl_aff *aff1,
7574                 __isl_take isl_aff *aff2);
7575         __isl_give isl_aff *isl_aff_div(
7576                 __isl_take isl_aff *aff1,
7577                 __isl_take isl_aff *aff2);
7578         __isl_give isl_pw_aff *isl_pw_aff_mul(
7579                 __isl_take isl_pw_aff *pwaff1,
7580                 __isl_take isl_pw_aff *pwaff2);
7581         __isl_give isl_pw_aff *isl_pw_aff_div(
7582                 __isl_take isl_pw_aff *pa1,
7583                 __isl_take isl_pw_aff *pa2);
7584         __isl_give isl_pw_aff *isl_pw_aff_tdiv_q(
7585                 __isl_take isl_pw_aff *pa1,
7586                 __isl_take isl_pw_aff *pa2);
7587         __isl_give isl_pw_aff *isl_pw_aff_tdiv_r(
7588                 __isl_take isl_pw_aff *pa1,
7589                 __isl_take isl_pw_aff *pa2);
7591 When multiplying two affine expressions, at least one of the two needs
7592 to be a constant.  Similarly, when dividing an affine expression by another,
7593 the second expression needs to be a constant.
7594 C<isl_pw_aff_tdiv_q> computes the quotient of an integer division with
7595 rounding towards zero.  C<isl_pw_aff_tdiv_r> computes the corresponding
7596 remainder.
7598         #include <isl/polynomial.h>
7599         __isl_give isl_qpolynomial *isl_qpolynomial_mul(
7600                 __isl_take isl_qpolynomial *qp1,
7601                 __isl_take isl_qpolynomial *qp2);
7602         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_mul(
7603                 __isl_take isl_pw_qpolynomial *pwqp1,
7604                 __isl_take isl_pw_qpolynomial *pwqp2);
7605         __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_mul(
7606                 __isl_take isl_union_pw_qpolynomial *upwqp1,
7607                 __isl_take isl_union_pw_qpolynomial *upwqp2);
7609 =back
7611 =head3 Lexicographic Optimization
7613 Given a (basic) set C<set> (or C<bset>) and a zero-dimensional domain C<dom>,
7614 the following functions
7615 compute a set that contains the lexicographic minimum or maximum
7616 of the elements in C<set> (or C<bset>) for those values of the parameters
7617 that satisfy C<dom>.
7618 If C<empty> is not C<NULL>, then C<*empty> is assigned a set
7619 that contains the parameter values in C<dom> for which C<set> (or C<bset>)
7620 has no elements.
7621 In other words, the union of the parameter values
7622 for which the result is non-empty and of C<*empty>
7623 is equal to C<dom>.
7625         #include <isl/set.h>
7626         __isl_give isl_set *isl_basic_set_partial_lexmin(
7627                 __isl_take isl_basic_set *bset,
7628                 __isl_take isl_basic_set *dom,
7629                 __isl_give isl_set **empty);
7630         __isl_give isl_set *isl_basic_set_partial_lexmax(
7631                 __isl_take isl_basic_set *bset,
7632                 __isl_take isl_basic_set *dom,
7633                 __isl_give isl_set **empty);
7634         __isl_give isl_set *isl_set_partial_lexmin(
7635                 __isl_take isl_set *set, __isl_take isl_set *dom,
7636                 __isl_give isl_set **empty);
7637         __isl_give isl_set *isl_set_partial_lexmax(
7638                 __isl_take isl_set *set, __isl_take isl_set *dom,
7639                 __isl_give isl_set **empty);
7641 Given a (basic) set C<set> (or C<bset>), the following functions simply
7642 return a set containing the lexicographic minimum or maximum
7643 of the elements in C<set> (or C<bset>).
7644 In case of union sets, the optimum is computed per space.
7646         #include <isl/set.h>
7647         __isl_give isl_set *isl_basic_set_lexmin(
7648                 __isl_take isl_basic_set *bset);
7649         __isl_give isl_set *isl_basic_set_lexmax(
7650                 __isl_take isl_basic_set *bset);
7651         __isl_give isl_set *isl_set_lexmin(
7652                 __isl_take isl_set *set);
7653         __isl_give isl_set *isl_set_lexmax(
7654                 __isl_take isl_set *set);
7655         __isl_give isl_union_set *isl_union_set_lexmin(
7656                 __isl_take isl_union_set *uset);
7657         __isl_give isl_union_set *isl_union_set_lexmax(
7658                 __isl_take isl_union_set *uset);
7660 Given a (basic) relation C<map> (or C<bmap>) and a domain C<dom>,
7661 the following functions
7662 compute a relation that maps each element of C<dom>
7663 to the single lexicographic minimum or maximum
7664 of the elements that are associated to that same
7665 element in C<map> (or C<bmap>).
7666 If C<empty> is not C<NULL>, then C<*empty> is assigned a set
7667 that contains the elements in C<dom> that do not map
7668 to any elements in C<map> (or C<bmap>).
7669 In other words, the union of the domain of the result and of C<*empty>
7670 is equal to C<dom>.
7672         #include <isl/map.h>
7673         __isl_give isl_map *isl_basic_map_partial_lexmax(
7674                 __isl_take isl_basic_map *bmap,
7675                 __isl_take isl_basic_set *dom,
7676                 __isl_give isl_set **empty);
7677         __isl_give isl_map *isl_basic_map_partial_lexmin(
7678                 __isl_take isl_basic_map *bmap,
7679                 __isl_take isl_basic_set *dom,
7680                 __isl_give isl_set **empty);
7681         __isl_give isl_map *isl_map_partial_lexmax(
7682                 __isl_take isl_map *map, __isl_take isl_set *dom,
7683                 __isl_give isl_set **empty);
7684         __isl_give isl_map *isl_map_partial_lexmin(
7685                 __isl_take isl_map *map, __isl_take isl_set *dom,
7686                 __isl_give isl_set **empty);
7688 Given a (basic) map C<map> (or C<bmap>), the following functions simply
7689 return a map mapping each element in the domain of
7690 C<map> (or C<bmap>) to the lexicographic minimum or maximum
7691 of all elements associated to that element.
7692 In case of union relations, the optimum is computed per space.
7694         #include <isl/map.h>
7695         __isl_give isl_map *isl_basic_map_lexmin(
7696                 __isl_take isl_basic_map *bmap);
7697         __isl_give isl_map *isl_basic_map_lexmax(
7698                 __isl_take isl_basic_map *bmap);
7699         __isl_give isl_map *isl_map_lexmin(
7700                 __isl_take isl_map *map);
7701         __isl_give isl_map *isl_map_lexmax(
7702                 __isl_take isl_map *map);
7703         __isl_give isl_union_map *isl_union_map_lexmin(
7704                 __isl_take isl_union_map *umap);
7705         __isl_give isl_union_map *isl_union_map_lexmax(
7706                 __isl_take isl_union_map *umap);
7708 The following functions return their result in the form of
7709 a piecewise multi-affine expression,
7710 but are otherwise equivalent to the corresponding functions
7711 returning a basic set or relation.
7713         #include <isl/set.h>
7714         __isl_give isl_pw_multi_aff *
7715         isl_basic_set_partial_lexmin_pw_multi_aff(
7716                 __isl_take isl_basic_set *bset,
7717                 __isl_take isl_basic_set *dom,
7718                 __isl_give isl_set **empty);
7719         __isl_give isl_pw_multi_aff *
7720         isl_basic_set_partial_lexmax_pw_multi_aff(
7721                 __isl_take isl_basic_set *bset,
7722                 __isl_take isl_basic_set *dom,
7723                 __isl_give isl_set **empty);
7724         __isl_give isl_pw_multi_aff *isl_set_lexmin_pw_multi_aff(
7725                 __isl_take isl_set *set);
7726         __isl_give isl_pw_multi_aff *isl_set_lexmax_pw_multi_aff(
7727                 __isl_take isl_set *set);
7729         #include <isl/map.h>
7730         __isl_give isl_pw_multi_aff *
7731         isl_basic_map_lexmin_pw_multi_aff(
7732                 __isl_take isl_basic_map *bmap);
7733         __isl_give isl_pw_multi_aff *
7734         isl_basic_map_partial_lexmin_pw_multi_aff(
7735                 __isl_take isl_basic_map *bmap,
7736                 __isl_take isl_basic_set *dom,
7737                 __isl_give isl_set **empty);
7738         __isl_give isl_pw_multi_aff *
7739         isl_basic_map_partial_lexmax_pw_multi_aff(
7740                 __isl_take isl_basic_map *bmap,
7741                 __isl_take isl_basic_set *dom,
7742                 __isl_give isl_set **empty);
7743         __isl_give isl_pw_multi_aff *isl_map_lexmin_pw_multi_aff(
7744                 __isl_take isl_map *map);
7745         __isl_give isl_pw_multi_aff *isl_map_lexmax_pw_multi_aff(
7746                 __isl_take isl_map *map);
7748 The following functions return the lexicographic minimum or maximum
7749 on the shared domain of the inputs and the single defined function
7750 on those parts of the domain where only a single function is defined.
7752         #include <isl/aff.h>
7753         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_lexmin(
7754                 __isl_take isl_pw_multi_aff *pma1,
7755                 __isl_take isl_pw_multi_aff *pma2);
7756         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_lexmax(
7757                 __isl_take isl_pw_multi_aff *pma1,
7758                 __isl_take isl_pw_multi_aff *pma2);
7760 If the input to a lexicographic optimization problem has
7761 multiple constraints with the same coefficients for the optimized
7762 variables, then, by default, this symmetry is exploited by
7763 replacing those constraints by a single constraint with
7764 an abstract bound, which is in turn bounded by the corresponding terms
7765 in the original constraints.
7766 Without this optimization, the solver would typically consider
7767 all possible orderings of those original bounds, resulting in a needless
7768 decomposition of the domain.
7769 However, the optimization can also result in slowdowns since
7770 an extra parameter is introduced that may get used in additional
7771 integer divisions.
7772 The following option determines whether symmetry detection is applied
7773 during lexicographic optimization.
7775         #include <isl/options.h>
7776         isl_stat isl_options_set_pip_symmetry(isl_ctx *ctx,
7777                 int val);
7778         int isl_options_get_pip_symmetry(isl_ctx *ctx);
7780 =begin latex
7782 See also \autoref{s:offline}.
7784 =end latex
7786 =head2 Ternary Operations
7788         #include <isl/aff.h>
7789         __isl_give isl_pw_aff *isl_pw_aff_cond(
7790                 __isl_take isl_pw_aff *cond,
7791                 __isl_take isl_pw_aff *pwaff_true,
7792                 __isl_take isl_pw_aff *pwaff_false);
7794 The function C<isl_pw_aff_cond> performs a conditional operator
7795 and returns an expression that is equal to C<pwaff_true>
7796 for elements where C<cond> is non-zero and equal to C<pwaff_false> for elements
7797 where C<cond> is zero.
7799 =head2 Lists
7801 Lists are defined over several element types, including
7802 C<isl_val>, C<isl_id>, C<isl_aff>, C<isl_pw_aff>, C<isl_pw_multi_aff>,
7803 C<isl_union_pw_aff>,
7804 C<isl_union_pw_multi_aff>,
7805 C<isl_pw_qpolynomial>, C<isl_pw_qpolynomial_fold>,
7806 C<isl_constraint>,
7807 C<isl_basic_set>, C<isl_set>, C<isl_basic_map>, C<isl_map>, C<isl_union_set>,
7808 C<isl_union_map>, C<isl_ast_expr> and C<isl_ast_node>.
7809 Here we take lists of C<isl_set>s as an example.
7810 Lists can be created, copied, modified and freed using the following functions.
7812         #include <isl/set.h>
7813         __isl_give isl_set_list *isl_set_list_from_set(
7814                 __isl_take isl_set *el);
7815         __isl_give isl_set_list *isl_set_list_alloc(
7816                 isl_ctx *ctx, int n);
7817         __isl_give isl_set_list *isl_set_list_copy(
7818                 __isl_keep isl_set_list *list);
7819         __isl_give isl_set_list *isl_set_list_insert(
7820                 __isl_take isl_set_list *list, unsigned pos,
7821                 __isl_take isl_set *el);
7822         __isl_give isl_set_list *isl_set_list_add(
7823                 __isl_take isl_set_list *list,
7824                 __isl_take isl_set *el);
7825         __isl_give isl_set_list *isl_set_list_drop(
7826                 __isl_take isl_set_list *list,
7827                 unsigned first, unsigned n);
7828         __isl_give isl_set_list *isl_set_list_set_set(
7829                 __isl_take isl_set_list *list, int index,
7830                 __isl_take isl_set *set);
7831         __isl_give isl_set_list *isl_set_list_concat(
7832                 __isl_take isl_set_list *list1,
7833                 __isl_take isl_set_list *list2);
7834         __isl_give isl_set_list *isl_set_list_map(
7835                 __isl_take isl_set_list *list,
7836                 __isl_give isl_set *(*fn)(__isl_take isl_set *el,
7837                         void *user),
7838                 void *user);
7839         __isl_give isl_set_list *isl_set_list_sort(
7840                 __isl_take isl_set_list *list,
7841                 int (*cmp)(__isl_keep isl_set *a,
7842                         __isl_keep isl_set *b, void *user),
7843                 void *user);
7844         __isl_null isl_set_list *isl_set_list_free(
7845                 __isl_take isl_set_list *list);
7847 C<isl_set_list_alloc> creates an empty list with an initial capacity
7848 for C<n> elements.  C<isl_set_list_insert> and C<isl_set_list_add>
7849 add elements to a list, increasing its capacity as needed.
7850 C<isl_set_list_from_set> creates a list with a single element.
7852 Lists can be inspected using the following functions.
7854         #include <isl/set.h>
7855         int isl_set_list_n_set(__isl_keep isl_set_list *list);
7856         __isl_give isl_set *isl_set_list_get_set(
7857                 __isl_keep isl_set_list *list, int index);
7858         isl_stat isl_set_list_foreach(__isl_keep isl_set_list *list,
7859                 isl_stat (*fn)(__isl_take isl_set *el, void *user),
7860                 void *user);
7861         isl_stat isl_set_list_foreach_scc(
7862                 __isl_keep isl_set_list *list,
7863                 isl_bool (*follows)(__isl_keep isl_set *a,
7864                         __isl_keep isl_set *b, void *user),
7865                 void *follows_user,
7866                 isl_stat (*fn)(__isl_take isl_set *el, void *user),
7867                 void *fn_user);
7869 The function C<isl_set_list_foreach_scc> calls C<fn> on each of the
7870 strongly connected components of the graph with as vertices the elements
7871 of C<list> and a directed edge from vertex C<b> to vertex C<a>
7872 iff C<follows(a, b)> returns C<isl_bool_true>.  The callbacks C<follows> and
7873 C<fn> should return C<isl_bool_error> or C<isl_stat_error> on error.
7875 Lists can be printed using
7877         #include <isl/set.h>
7878         __isl_give isl_printer *isl_printer_print_set_list(
7879                 __isl_take isl_printer *p,
7880                 __isl_keep isl_set_list *list);
7882 =head2 Associative arrays
7884 Associative arrays map isl objects of a specific type to isl objects
7885 of some (other) specific type.  They are defined for several pairs
7886 of types, including (C<isl_map>, C<isl_basic_set>),
7887 (C<isl_id>, C<isl_ast_expr>),
7888 (C<isl_id>, C<isl_id>) and
7889 (C<isl_id>, C<isl_pw_aff>).
7890 Here, we take associative arrays that map C<isl_id>s to C<isl_ast_expr>s
7891 as an example.
7893 Associative arrays can be created, copied and freed using
7894 the following functions.
7896         #include <isl/id_to_ast_expr.h>
7897         __isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_alloc(
7898                 isl_ctx *ctx, int min_size);
7899         __isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_copy(
7900                 __isl_keep isl_id_to_ast_expr *id2expr);
7901         __isl_null isl_id_to_ast_expr *isl_id_to_ast_expr_free(
7902                 __isl_take isl_id_to_ast_expr *id2expr);
7904 The C<min_size> argument to C<isl_id_to_ast_expr_alloc> can be used
7905 to specify the expected size of the associative array.
7906 The associative array will be grown automatically as needed.
7908 Associative arrays can be inspected using the following functions.
7910         #include <isl/id_to_ast_expr.h>
7911         __isl_give isl_maybe_isl_ast_expr
7912         isl_id_to_ast_expr_try_get(
7913                 __isl_keep isl_id_to_ast_expr *id2expr,
7914                 __isl_keep isl_id *key);
7915         isl_bool isl_id_to_ast_expr_has(
7916                 __isl_keep isl_id_to_ast_expr *id2expr,
7917                 __isl_keep isl_id *key);
7918         __isl_give isl_ast_expr *isl_id_to_ast_expr_get(
7919                 __isl_keep isl_id_to_ast_expr *id2expr,
7920                 __isl_take isl_id *key);
7921         isl_stat isl_id_to_ast_expr_foreach(
7922                 __isl_keep isl_id_to_ast_expr *id2expr,
7923                 isl_stat (*fn)(__isl_take isl_id *key,
7924                         __isl_take isl_ast_expr *val, void *user),
7925                 void *user);
7927 The function C<isl_id_to_ast_expr_try_get> returns a structure
7928 containing two elements, C<valid> and C<value>.
7929 If there is a value associated to the key, then C<valid>
7930 is set to C<isl_bool_true> and C<value> contains a copy of
7931 the associated value.  Otherwise C<value> is C<NULL> and
7932 C<valid> may be C<isl_bool_error> or C<isl_bool_false> depending
7933 on whether some error has occurred or there simply is no associated value.
7934 The function C<isl_id_to_ast_expr_has> returns the C<valid> field
7935 in the structure and
7936 the function C<isl_id_to_ast_expr_get> returns the C<value> field.
7938 Associative arrays can be modified using the following functions.
7940         #include <isl/id_to_ast_expr.h>
7941         __isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_set(
7942                 __isl_take isl_id_to_ast_expr *id2expr,
7943                 __isl_take isl_id *key,
7944                 __isl_take isl_ast_expr *val);
7945         __isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_drop(
7946                 __isl_take isl_id_to_ast_expr *id2expr,
7947                 __isl_take isl_id *key);
7949 Associative arrays can be printed using the following function.
7951         #include <isl/id_to_ast_expr.h>
7952         __isl_give isl_printer *isl_printer_print_id_to_ast_expr(
7953                 __isl_take isl_printer *p,
7954                 __isl_keep isl_id_to_ast_expr *id2expr);
7956 =head2 Vectors
7958 Vectors can be created, copied and freed using the following functions.
7960         #include <isl/vec.h>
7961         __isl_give isl_vec *isl_vec_alloc(isl_ctx *ctx,
7962                 unsigned size);
7963         __isl_give isl_vec *isl_vec_zero(isl_ctx *ctx,
7964                 unsigned size);
7965         __isl_give isl_vec *isl_vec_copy(__isl_keep isl_vec *vec);
7966         __isl_null isl_vec *isl_vec_free(__isl_take isl_vec *vec);
7968 Note that the elements of a vector created by C<isl_vec_alloc>
7969 may have arbitrary values.
7970 A vector created by C<isl_vec_zero> has elements with value zero.
7971 The elements can be changed and inspected using the following functions.
7973         int isl_vec_size(__isl_keep isl_vec *vec);
7974         __isl_give isl_val *isl_vec_get_element_val(
7975                 __isl_keep isl_vec *vec, int pos);
7976         __isl_give isl_vec *isl_vec_set_element_si(
7977                 __isl_take isl_vec *vec, int pos, int v);
7978         __isl_give isl_vec *isl_vec_set_element_val(
7979                 __isl_take isl_vec *vec, int pos,
7980                 __isl_take isl_val *v);
7981         __isl_give isl_vec *isl_vec_set_si(__isl_take isl_vec *vec,
7982                 int v);
7983         __isl_give isl_vec *isl_vec_set_val(
7984                 __isl_take isl_vec *vec, __isl_take isl_val *v);
7985         int isl_vec_cmp_element(__isl_keep isl_vec *vec1,
7986                 __isl_keep isl_vec *vec2, int pos);
7988 C<isl_vec_get_element> will return a negative value if anything went wrong.
7989 In that case, the value of C<*v> is undefined.
7991 The following function can be used to concatenate two vectors.
7993         __isl_give isl_vec *isl_vec_concat(__isl_take isl_vec *vec1,
7994                 __isl_take isl_vec *vec2);
7996 =head2 Matrices
7998 Matrices can be created, copied and freed using the following functions.
8000         #include <isl/mat.h>
8001         __isl_give isl_mat *isl_mat_alloc(isl_ctx *ctx,
8002                 unsigned n_row, unsigned n_col);
8003         __isl_give isl_mat *isl_mat_copy(__isl_keep isl_mat *mat);
8004         __isl_null isl_mat *isl_mat_free(__isl_take isl_mat *mat);
8006 Note that the elements of a newly created matrix may have arbitrary values.
8007 The elements can be changed and inspected using the following functions.
8009         int isl_mat_rows(__isl_keep isl_mat *mat);
8010         int isl_mat_cols(__isl_keep isl_mat *mat);
8011         __isl_give isl_val *isl_mat_get_element_val(
8012                 __isl_keep isl_mat *mat, int row, int col);
8013         __isl_give isl_mat *isl_mat_set_element_si(__isl_take isl_mat *mat,
8014                 int row, int col, int v);
8015         __isl_give isl_mat *isl_mat_set_element_val(
8016                 __isl_take isl_mat *mat, int row, int col,
8017                 __isl_take isl_val *v);
8019 The following function computes the rank of a matrix.
8020 The return value may be -1 if some error occurred.
8022         #include <isl/mat.h>
8023         int isl_mat_rank(__isl_keep isl_mat *mat);
8025 The following function can be used to compute the (right) inverse
8026 of a matrix, i.e., a matrix such that the product of the original
8027 and the inverse (in that order) is a multiple of the identity matrix.
8028 The input matrix is assumed to be of full row-rank.
8030         __isl_give isl_mat *isl_mat_right_inverse(__isl_take isl_mat *mat);
8032 The following function can be used to compute the (right) kernel
8033 (or null space) of a matrix, i.e., a matrix such that the product of
8034 the original and the kernel (in that order) is the zero matrix.
8036         __isl_give isl_mat *isl_mat_right_kernel(__isl_take isl_mat *mat);
8038 The following function computes a basis for the space spanned
8039 by the rows of a matrix.
8041         __isl_give isl_mat *isl_mat_row_basis(
8042                 __isl_take isl_mat *mat);
8044 The following function computes rows that extend a basis of C<mat1>
8045 to a basis that also covers C<mat2>.
8047         __isl_give isl_mat *isl_mat_row_basis_extension(
8048                 __isl_take isl_mat *mat1,
8049                 __isl_take isl_mat *mat2);
8051 The following function checks whether there is no linear dependence
8052 among the combined rows of "mat1" and "mat2" that is not already present
8053 in "mat1" or "mat2" individually.
8054 If "mat1" and "mat2" have linearly independent rows by themselves,
8055 then this means that there is no linear dependence among all rows together.
8057         isl_bool isl_mat_has_linearly_independent_rows(
8058                 __isl_keep isl_mat *mat1,
8059                 __isl_keep isl_mat *mat2);
8061 =head2 Bounds on Piecewise Quasipolynomials and Piecewise Quasipolynomial Reductions
8063 The following functions determine
8064 an upper or lower bound on a quasipolynomial over its domain.
8066         __isl_give isl_pw_qpolynomial_fold *
8067         isl_pw_qpolynomial_bound(
8068                 __isl_take isl_pw_qpolynomial *pwqp,
8069                 enum isl_fold type, int *tight);
8071         __isl_give isl_union_pw_qpolynomial_fold *
8072         isl_union_pw_qpolynomial_bound(
8073                 __isl_take isl_union_pw_qpolynomial *upwqp,
8074                 enum isl_fold type, int *tight);
8076 The C<type> argument may be either C<isl_fold_min> or C<isl_fold_max>.
8077 If C<tight> is not C<NULL>, then C<*tight> is set to C<1>
8078 is the returned bound is known be tight, i.e., for each value
8079 of the parameters there is at least
8080 one element in the domain that reaches the bound.
8081 If the domain of C<pwqp> is not wrapping, then the bound is computed
8082 over all elements in that domain and the result has a purely parametric
8083 domain.  If the domain of C<pwqp> is wrapping, then the bound is
8084 computed over the range of the wrapped relation.  The domain of the
8085 wrapped relation becomes the domain of the result.
8087 =head2 Parametric Vertex Enumeration
8089 The parametric vertex enumeration described in this section
8090 is mainly intended to be used internally and by the C<barvinok>
8091 library.
8093         #include <isl/vertices.h>
8094         __isl_give isl_vertices *isl_basic_set_compute_vertices(
8095                 __isl_keep isl_basic_set *bset);
8097 The function C<isl_basic_set_compute_vertices> performs the
8098 actual computation of the parametric vertices and the chamber
8099 decomposition and stores the result in an C<isl_vertices> object.
8100 This information can be queried by either iterating over all
8101 the vertices or iterating over all the chambers or cells
8102 and then iterating over all vertices that are active on the chamber.
8104         isl_stat isl_vertices_foreach_vertex(
8105                 __isl_keep isl_vertices *vertices,
8106                 isl_stat (*fn)(__isl_take isl_vertex *vertex,
8107                         void *user), void *user);
8109         isl_stat isl_vertices_foreach_cell(
8110                 __isl_keep isl_vertices *vertices,
8111                 isl_stat (*fn)(__isl_take isl_cell *cell,
8112                         void *user), void *user);
8113         isl_stat isl_cell_foreach_vertex(__isl_keep isl_cell *cell,
8114                 isl_stat (*fn)(__isl_take isl_vertex *vertex,
8115                         void *user), void *user);
8117 Other operations that can be performed on an C<isl_vertices> object are
8118 the following.
8120         int isl_vertices_get_n_vertices(
8121                 __isl_keep isl_vertices *vertices);
8122         __isl_null isl_vertices *isl_vertices_free(
8123                 __isl_take isl_vertices *vertices);
8125 Vertices can be inspected and destroyed using the following functions.
8127         int isl_vertex_get_id(__isl_keep isl_vertex *vertex);
8128         __isl_give isl_basic_set *isl_vertex_get_domain(
8129                 __isl_keep isl_vertex *vertex);
8130         __isl_give isl_multi_aff *isl_vertex_get_expr(
8131                 __isl_keep isl_vertex *vertex);
8132         void isl_vertex_free(__isl_take isl_vertex *vertex);
8134 C<isl_vertex_get_expr> returns a multiple quasi-affine expression
8135 describing the vertex in terms of the parameters,
8136 while C<isl_vertex_get_domain> returns the activity domain
8137 of the vertex.
8139 Chambers can be inspected and destroyed using the following functions.
8141         __isl_give isl_basic_set *isl_cell_get_domain(
8142                 __isl_keep isl_cell *cell);
8143         void isl_cell_free(__isl_take isl_cell *cell);
8145 =head1 Polyhedral Compilation Library
8147 This section collects functionality in C<isl> that has been specifically
8148 designed for use during polyhedral compilation.
8150 =head2 Schedule Trees
8152 A schedule tree is a structured representation of a schedule,
8153 assigning a relative order to a set of domain elements.
8154 The relative order expressed by the schedule tree is
8155 defined recursively.  In particular, the order between
8156 two domain elements is determined by the node that is closest
8157 to the root that refers to both elements and that orders them apart.
8158 Each node in the tree is of one of several types.
8159 The root node is always of type C<isl_schedule_node_domain>
8160 (or C<isl_schedule_node_extension>)
8161 and it describes the (extra) domain elements to which the schedule applies.
8162 The other types of nodes are as follows.
8164 =over
8166 =item C<isl_schedule_node_band>
8168 A band of schedule dimensions.  Each schedule dimension is represented
8169 by a union piecewise quasi-affine expression.  If this expression
8170 assigns a different value to two domain elements, while all previous
8171 schedule dimensions in the same band assign them the same value,
8172 then the two domain elements are ordered according to these two
8173 different values.
8174 Each expression is required to be total in the domain elements
8175 that reach the band node.
8177 =item C<isl_schedule_node_expansion>
8179 An expansion node maps each of the domain elements that reach the node
8180 to one or more domain elements.  The image of this mapping forms
8181 the set of domain elements that reach the child of the expansion node.
8182 The function that maps each of the expanded domain elements
8183 to the original domain element from which it was expanded
8184 is called the contraction.
8186 =item C<isl_schedule_node_filter>
8188 A filter node does not impose any ordering, but rather intersects
8189 the set of domain elements that the current subtree refers to
8190 with a given union set.  The subtree of the filter node only
8191 refers to domain elements in the intersection.
8192 A filter node is typically only used as a child of a sequence or
8193 set node.
8195 =item C<isl_schedule_node_leaf>
8197 A leaf of the schedule tree.  Leaf nodes do not impose any ordering.
8199 =item C<isl_schedule_node_mark>
8201 A mark node can be used to attach any kind of information to a subtree
8202 of the schedule tree.
8204 =item C<isl_schedule_node_sequence>
8206 A sequence node has one or more children, each of which is a filter node.
8207 The filters on these filter nodes form a partition of
8208 the domain elements that the current subtree refers to.
8209 If two domain elements appear in distinct filters then the sequence
8210 node orders them according to the child positions of the corresponding
8211 filter nodes.
8213 =item C<isl_schedule_node_set>
8215 A set node is similar to a sequence node, except that
8216 it expresses that domain elements appearing in distinct filters
8217 may have any order.  The order of the children of a set node
8218 is therefore also immaterial.
8220 =back
8222 The following node types are only supported by the AST generator.
8224 =over
8226 =item C<isl_schedule_node_context>
8228 The context describes constraints on the parameters and
8229 the schedule dimensions of outer
8230 bands that the AST generator may assume to hold.  It is also the only
8231 kind of node that may introduce additional parameters.
8232 The space of the context is that of the flat product of the outer
8233 band nodes.  In particular, if there are no outer band nodes, then
8234 this space is the unnamed zero-dimensional space.
8235 Since a context node references the outer band nodes, any tree
8236 containing a context node is considered to be anchored.
8238 =item C<isl_schedule_node_extension>
8240 An extension node instructs the AST generator to add additional
8241 domain elements that need to be scheduled.
8242 The additional domain elements are described by the range of
8243 the extension map in terms of the outer schedule dimensions,
8244 i.e., the flat product of the outer band nodes.
8245 Note that domain elements are added whenever the AST generator
8246 reaches the extension node, meaning that there are still some
8247 active domain elements for which an AST needs to be generated.
8248 The conditions under which some domain elements are still active
8249 may however not be completely described by the outer AST nodes
8250 generated at that point.
8251 Since an extension node references the outer band nodes, any tree
8252 containing an extension node is considered to be anchored.
8254 An extension node may also appear as the root of a schedule tree,
8255 when it is intended to be inserted into another tree
8256 using C<isl_schedule_node_graft_before> or C<isl_schedule_node_graft_after>.
8257 In this case, the domain of the extension node should
8258 correspond to the flat product of the outer band nodes
8259 in this other schedule tree at the point where the extension tree
8260 will be inserted.
8262 =item C<isl_schedule_node_guard>
8264 The guard describes constraints on the parameters and
8265 the schedule dimensions of outer
8266 bands that need to be enforced by the outer nodes
8267 in the generated AST.
8268 That is, the part of the AST that is generated from descendants
8269 of the guard node can assume that these constraints are satisfied.
8270 The space of the guard is that of the flat product of the outer
8271 band nodes.  In particular, if there are no outer band nodes, then
8272 this space is the unnamed zero-dimensional space.
8273 Since a guard node references the outer band nodes, any tree
8274 containing a guard node is considered to be anchored.
8276 =back
8278 Except for the C<isl_schedule_node_context> nodes,
8279 none of the nodes may introduce any parameters that were not
8280 already present in the root domain node.
8282 A schedule tree is encapsulated in an C<isl_schedule> object.
8283 The simplest such objects, those with a tree consisting of single domain node,
8284 can be created using the following functions with either an empty
8285 domain or a given domain.
8287         #include <isl/schedule.h>
8288         __isl_give isl_schedule *isl_schedule_empty(
8289                 __isl_take isl_space *space);
8290         __isl_give isl_schedule *isl_schedule_from_domain(
8291                 __isl_take isl_union_set *domain);
8293 The function C<isl_schedule_constraints_compute_schedule> described
8294 in L</"Scheduling"> can also be used to construct schedules.
8296 C<isl_schedule> objects may be copied and freed using the following functions.
8298         #include <isl/schedule.h>
8299         __isl_give isl_schedule *isl_schedule_copy(
8300                 __isl_keep isl_schedule *sched);
8301         __isl_null isl_schedule *isl_schedule_free(
8302                 __isl_take isl_schedule *sched);
8304 The following functions checks whether two C<isl_schedule> objects
8305 are obviously the same.
8307         #include <isl/schedule.h>
8308         isl_bool isl_schedule_plain_is_equal(
8309                 __isl_keep isl_schedule *schedule1,
8310                 __isl_keep isl_schedule *schedule2);
8312 The domain of the schedule, i.e., the domain described by the root node,
8313 can be obtained using the following function.
8315         #include <isl/schedule.h>
8316         __isl_give isl_union_set *isl_schedule_get_domain(
8317                 __isl_keep isl_schedule *schedule);
8319 An extra top-level band node (right underneath the domain node) can
8320 be introduced into the schedule using the following function.
8321 The schedule tree is assumed not to have any anchored nodes.
8323         #include <isl/schedule.h>
8324         __isl_give isl_schedule *
8325         isl_schedule_insert_partial_schedule(
8326                 __isl_take isl_schedule *schedule,
8327                 __isl_take isl_multi_union_pw_aff *partial);
8329 A top-level context node (right underneath the domain node) can
8330 be introduced into the schedule using the following function.
8332         #include <isl/schedule.h>
8333         __isl_give isl_schedule *isl_schedule_insert_context(
8334                 __isl_take isl_schedule *schedule,
8335                 __isl_take isl_set *context)
8337 A top-level guard node (right underneath the domain node) can
8338 be introduced into the schedule using the following function.
8340         #include <isl/schedule.h>
8341         __isl_give isl_schedule *isl_schedule_insert_guard(
8342                 __isl_take isl_schedule *schedule,
8343                 __isl_take isl_set *guard)
8345 A schedule that combines two schedules either in the given
8346 order or in an arbitrary order, i.e., with an C<isl_schedule_node_sequence>
8347 or an C<isl_schedule_node_set> node,
8348 can be created using the following functions.
8350         #include <isl/schedule.h>
8351         __isl_give isl_schedule *isl_schedule_sequence(
8352                 __isl_take isl_schedule *schedule1,
8353                 __isl_take isl_schedule *schedule2);
8354         __isl_give isl_schedule *isl_schedule_set(
8355                 __isl_take isl_schedule *schedule1,
8356                 __isl_take isl_schedule *schedule2);
8358 The domains of the two input schedules need to be disjoint.
8360 The following function can be used to restrict the domain
8361 of a schedule with a domain node as root to be a subset of the given union set.
8362 This operation may remove nodes in the tree that have become
8363 redundant.
8365         #include <isl/schedule.h>
8366         __isl_give isl_schedule *isl_schedule_intersect_domain(
8367                 __isl_take isl_schedule *schedule,
8368                 __isl_take isl_union_set *domain);
8370 The following function can be used to simplify the domain
8371 of a schedule with a domain node as root with respect to the given
8372 parameter domain.
8374         #include <isl/schedule.h>
8375         __isl_give isl_schedule *isl_schedule_gist_domain_params(
8376                 __isl_take isl_schedule *schedule,
8377                 __isl_take isl_set *context);
8379 The following function resets the user pointers on all parameter
8380 and tuple identifiers referenced by the nodes of the given schedule.
8382         #include <isl/schedule.h>
8383         __isl_give isl_schedule *isl_schedule_reset_user(
8384                 __isl_take isl_schedule *schedule);
8386 The following function aligns the parameters of all nodes
8387 in the given schedule to the given space.
8389         #include <isl/schedule.h>
8390         __isl_give isl_schedule *isl_schedule_align_params(
8391                 __isl_take isl_schedule *schedule,
8392                 __isl_take isl_space *space);
8394 The following function allows the user to plug in a given function
8395 in the iteration domains.  The input schedule is not allowed to contain
8396 any expansion nodes.
8398         #include <isl/schedule.h>
8399         __isl_give isl_schedule *
8400         isl_schedule_pullback_union_pw_multi_aff(
8401                 __isl_take isl_schedule *schedule,
8402                 __isl_take isl_union_pw_multi_aff *upma);
8404 The following function can be used to plug in the schedule C<expansion>
8405 in the leaves of C<schedule>, where C<contraction> describes how
8406 the domain elements of C<expansion> map to the domain elements
8407 at the original leaves of C<schedule>.
8408 The resulting schedule will contain expansion nodes, unless
8409 C<contraction> is an identity function.
8411         #include <isl/schedule.h>
8412         __isl_give isl_schedule *isl_schedule_expand(
8413                 __isl_take isl_schedule *schedule,
8414                 __isl_take isl_union_pw_multi_aff *contraction,
8415                 __isl_take isl_schedule *expansion);
8417 An C<isl_union_map> representation of the schedule can be obtained
8418 from an C<isl_schedule> using the following function.
8420         #include <isl/schedule.h>
8421         __isl_give isl_union_map *isl_schedule_get_map(
8422                 __isl_keep isl_schedule *sched);
8424 The resulting relation encodes the same relative ordering as
8425 the schedule by mapping the domain elements to a common schedule space.
8426 If the schedule_separate_components option is set, then the order
8427 of the children of a set node is explicitly encoded in the result.
8428 If the tree contains any expansion nodes, then the relation
8429 is formulated in terms of the expanded domain elements.
8431 Schedules can be read from input using the following functions.
8433         #include <isl/schedule.h>
8434         __isl_give isl_schedule *isl_schedule_read_from_file(
8435                 isl_ctx *ctx, FILE *input);
8436         __isl_give isl_schedule *isl_schedule_read_from_str(
8437                 isl_ctx *ctx, const char *str);
8439 A representation of the schedule can be printed using
8441         #include <isl/schedule.h>
8442         __isl_give isl_printer *isl_printer_print_schedule(
8443                 __isl_take isl_printer *p,
8444                 __isl_keep isl_schedule *schedule);
8445         __isl_give char *isl_schedule_to_str(
8446                 __isl_keep isl_schedule *schedule);
8448 C<isl_schedule_to_str> prints the schedule in flow format.
8450 The schedule tree can be traversed through the use of
8451 C<isl_schedule_node> objects that point to a particular
8452 position in the schedule tree.  Whenever a C<isl_schedule_node>
8453 is used to modify a node in the schedule tree, the original schedule
8454 tree is left untouched and the modifications are performed to a copy
8455 of the tree.  The returned C<isl_schedule_node> then points to
8456 this modified copy of the tree.
8458 The root of the schedule tree can be obtained using the following function.
8460         #include <isl/schedule.h>
8461         __isl_give isl_schedule_node *isl_schedule_get_root(
8462                 __isl_keep isl_schedule *schedule);
8464 A pointer to a newly created schedule tree with a single domain
8465 node can be created using the following functions.
8467         #include <isl/schedule_node.h>
8468         __isl_give isl_schedule_node *
8469         isl_schedule_node_from_domain(
8470                 __isl_take isl_union_set *domain);
8471         __isl_give isl_schedule_node *
8472         isl_schedule_node_from_extension(
8473                 __isl_take isl_union_map *extension);
8475 C<isl_schedule_node_from_extension> creates a tree with an extension
8476 node as root.
8478 Schedule nodes can be copied and freed using the following functions.
8480         #include <isl/schedule_node.h>
8481         __isl_give isl_schedule_node *isl_schedule_node_copy(
8482                 __isl_keep isl_schedule_node *node);
8483         __isl_null isl_schedule_node *isl_schedule_node_free(
8484                 __isl_take isl_schedule_node *node);
8486 The following functions can be used to check if two schedule
8487 nodes point to the same position in the same schedule.
8489         #include <isl/schedule_node.h>
8490         isl_bool isl_schedule_node_is_equal(
8491                 __isl_keep isl_schedule_node *node1,
8492                 __isl_keep isl_schedule_node *node2);
8494 The following properties can be obtained from a schedule node.
8496         #include <isl/schedule_node.h>
8497         enum isl_schedule_node_type isl_schedule_node_get_type(
8498                 __isl_keep isl_schedule_node *node);
8499         enum isl_schedule_node_type
8500         isl_schedule_node_get_parent_type(
8501                 __isl_keep isl_schedule_node *node);
8502         __isl_give isl_schedule *isl_schedule_node_get_schedule(
8503                 __isl_keep isl_schedule_node *node);
8505 The function C<isl_schedule_node_get_type> returns the type of
8506 the node, while C<isl_schedule_node_get_parent_type> returns
8507 type of the parent of the node, which is required to exist.
8508 The function C<isl_schedule_node_get_schedule> returns a copy
8509 to the schedule to which the node belongs.
8511 The following functions can be used to move the schedule node
8512 to a different position in the tree or to check if such a position
8513 exists.
8515         #include <isl/schedule_node.h>
8516         isl_bool isl_schedule_node_has_parent(
8517                 __isl_keep isl_schedule_node *node);
8518         __isl_give isl_schedule_node *isl_schedule_node_parent(
8519                 __isl_take isl_schedule_node *node);
8520         __isl_give isl_schedule_node *isl_schedule_node_root(
8521                 __isl_take isl_schedule_node *node);
8522         __isl_give isl_schedule_node *isl_schedule_node_ancestor(
8523                 __isl_take isl_schedule_node *node,
8524                 int generation);
8525         int isl_schedule_node_n_children(
8526                 __isl_keep isl_schedule_node *node);
8527         __isl_give isl_schedule_node *isl_schedule_node_child(
8528                 __isl_take isl_schedule_node *node, int pos);
8529         isl_bool isl_schedule_node_has_children(
8530                 __isl_keep isl_schedule_node *node);
8531         __isl_give isl_schedule_node *isl_schedule_node_first_child(
8532                 __isl_take isl_schedule_node *node);
8533         isl_bool isl_schedule_node_has_previous_sibling(
8534                 __isl_keep isl_schedule_node *node);
8535         __isl_give isl_schedule_node *
8536         isl_schedule_node_previous_sibling(
8537                 __isl_take isl_schedule_node *node);
8538         isl_bool isl_schedule_node_has_next_sibling(
8539                 __isl_keep isl_schedule_node *node);
8540         __isl_give isl_schedule_node *
8541         isl_schedule_node_next_sibling(
8542                 __isl_take isl_schedule_node *node);
8544 For C<isl_schedule_node_ancestor>, the ancestor of generation 0
8545 is the node itself, the ancestor of generation 1 is its parent and so on.
8547 It is also possible to query the number of ancestors of a node,
8548 the position of the current node
8549 within the children of its parent, the position of the subtree
8550 containing a node within the children of an ancestor
8551 or to obtain a copy of a given
8552 child without destroying the current node.
8553 Given two nodes that point to the same schedule, their closest
8554 shared ancestor can be obtained using
8555 C<isl_schedule_node_get_shared_ancestor>.
8557         #include <isl/schedule_node.h>
8558         int isl_schedule_node_get_tree_depth(
8559                 __isl_keep isl_schedule_node *node);
8560         int isl_schedule_node_get_child_position(
8561                 __isl_keep isl_schedule_node *node);
8562         int isl_schedule_node_get_ancestor_child_position(
8563                 __isl_keep isl_schedule_node *node,
8564                 __isl_keep isl_schedule_node *ancestor);
8565         __isl_give isl_schedule_node *isl_schedule_node_get_child(
8566                 __isl_keep isl_schedule_node *node, int pos);
8567         __isl_give isl_schedule_node *
8568         isl_schedule_node_get_shared_ancestor(
8569                 __isl_keep isl_schedule_node *node1,
8570                 __isl_keep isl_schedule_node *node2);
8572 All nodes in a schedule tree or
8573 all descendants of a specific node (including the node) can be visited
8574 in depth-first pre-order using the following functions.
8576         #include <isl/schedule.h>
8577         isl_stat isl_schedule_foreach_schedule_node_top_down(
8578                 __isl_keep isl_schedule *sched,
8579                 isl_bool (*fn)(__isl_keep isl_schedule_node *node,
8580                         void *user), void *user);
8582         #include <isl/schedule_node.h>
8583         isl_stat isl_schedule_node_foreach_descendant_top_down(
8584                 __isl_keep isl_schedule_node *node,
8585                 isl_bool (*fn)(__isl_keep isl_schedule_node *node,
8586                         void *user), void *user);
8588 The callback function is slightly different from the usual
8589 callbacks in that it not only indicates success (non-negative result)
8590 or failure (negative result), but also indicates whether the children
8591 of the given node should be visited.  In particular, if the callback
8592 returns a positive value, then the children are visited, but if
8593 the callback returns zero, then the children are not visited.
8595 The following functions checks whether
8596 all descendants of a specific node (including the node itself)
8597 satisfy a user-specified test.
8599         #include <isl/schedule_node.h>
8600         isl_bool isl_schedule_node_every_descendant(
8601                 __isl_keep isl_schedule_node *node,
8602                 isl_bool (*test)(__isl_keep isl_schedule_node *node,
8603                         void *user), void *user)
8605 The ancestors of a node in a schedule tree can be visited from
8606 the root down to and including the parent of the node using
8607 the following function.
8609         #include <isl/schedule_node.h>
8610         isl_stat isl_schedule_node_foreach_ancestor_top_down(
8611                 __isl_keep isl_schedule_node *node,
8612                 isl_stat (*fn)(__isl_keep isl_schedule_node *node,
8613                         void *user), void *user);
8615 The following functions allows for a depth-first post-order
8616 traversal of the nodes in a schedule tree or
8617 of the descendants of a specific node (including the node
8618 itself), where the user callback is allowed to modify the
8619 visited node.
8621         #include <isl/schedule.h>
8622         __isl_give isl_schedule *
8623         isl_schedule_map_schedule_node_bottom_up(
8624                 __isl_take isl_schedule *schedule,
8625                 __isl_give isl_schedule_node *(*fn)(
8626                         __isl_take isl_schedule_node *node,
8627                         void *user), void *user);
8629         #include <isl/schedule_node.h>
8630         __isl_give isl_schedule_node *
8631         isl_schedule_node_map_descendant_bottom_up(
8632                 __isl_take isl_schedule_node *node,
8633                 __isl_give isl_schedule_node *(*fn)(
8634                         __isl_take isl_schedule_node *node,
8635                         void *user), void *user);
8637 The traversal continues from the node returned by the callback function.
8638 It is the responsibility of the user to ensure that this does not
8639 lead to an infinite loop.  It is safest to always return a pointer
8640 to the same position (same ancestors and child positions) as the input node.
8642 The following function removes a node (along with its descendants)
8643 from a schedule tree and returns a pointer to the leaf at the
8644 same position in the updated tree.
8645 It is not allowed to remove the root of a schedule tree or
8646 a child of a set or sequence node.
8648         #include <isl/schedule_node.h>
8649         __isl_give isl_schedule_node *isl_schedule_node_cut(
8650                 __isl_take isl_schedule_node *node);
8652 The following function removes a single node
8653 from a schedule tree and returns a pointer to the child
8654 of the node, now located at the position of the original node
8655 or to a leaf node at that position if there was no child.
8656 It is not allowed to remove the root of a schedule tree,
8657 a set or sequence node, a child of a set or sequence node or
8658 a band node with an anchored subtree.
8660         #include <isl/schedule_node.h>
8661         __isl_give isl_schedule_node *isl_schedule_node_delete(
8662                 __isl_take isl_schedule_node *node);
8664 Most nodes in a schedule tree only contain local information.
8665 In some cases, however, a node may also refer to the schedule dimensions
8666 of its outer band nodes.
8667 This means that the position of the node within the tree should
8668 not be changed, or at least that no changes are performed to the
8669 outer band nodes.  The following function can be used to test
8670 whether the subtree rooted at a given node contains any such nodes.
8672         #include <isl/schedule_node.h>
8673         isl_bool isl_schedule_node_is_subtree_anchored(
8674                 __isl_keep isl_schedule_node *node);
8676 The following function resets the user pointers on all parameter
8677 and tuple identifiers referenced by the given schedule node.
8679         #include <isl/schedule_node.h>
8680         __isl_give isl_schedule_node *isl_schedule_node_reset_user(
8681                 __isl_take isl_schedule_node *node);
8683 The following function aligns the parameters of the given schedule
8684 node to the given space.
8686         #include <isl/schedule_node.h>
8687         __isl_give isl_schedule_node *
8688         isl_schedule_node_align_params(
8689                 __isl_take isl_schedule_node *node,
8690                 __isl_take isl_space *space);
8692 Several node types have their own functions for querying
8693 (and in some cases setting) some node type specific properties.
8695         #include <isl/schedule_node.h>
8696         __isl_give isl_space *isl_schedule_node_band_get_space(
8697                 __isl_keep isl_schedule_node *node);
8698         __isl_give isl_multi_union_pw_aff *
8699         isl_schedule_node_band_get_partial_schedule(
8700                 __isl_keep isl_schedule_node *node);
8701         __isl_give isl_union_map *
8702         isl_schedule_node_band_get_partial_schedule_union_map(
8703                 __isl_keep isl_schedule_node *node);
8704         unsigned isl_schedule_node_band_n_member(
8705                 __isl_keep isl_schedule_node *node);
8706         isl_bool isl_schedule_node_band_member_get_coincident(
8707                 __isl_keep isl_schedule_node *node, int pos);
8708         __isl_give isl_schedule_node *
8709         isl_schedule_node_band_member_set_coincident(
8710                 __isl_take isl_schedule_node *node, int pos,
8711                 int coincident);
8712         isl_bool isl_schedule_node_band_get_permutable(
8713                 __isl_keep isl_schedule_node *node);
8714         __isl_give isl_schedule_node *
8715         isl_schedule_node_band_set_permutable(
8716                 __isl_take isl_schedule_node *node, int permutable);
8717         enum isl_ast_loop_type
8718         isl_schedule_node_band_member_get_ast_loop_type(
8719                 __isl_keep isl_schedule_node *node, int pos);
8720         __isl_give isl_schedule_node *
8721         isl_schedule_node_band_member_set_ast_loop_type(
8722                 __isl_take isl_schedule_node *node, int pos,
8723                 enum isl_ast_loop_type type);
8724         __isl_give isl_union_set *
8725         enum isl_ast_loop_type
8726         isl_schedule_node_band_member_get_isolate_ast_loop_type(
8727                 __isl_keep isl_schedule_node *node, int pos);
8728         __isl_give isl_schedule_node *
8729         isl_schedule_node_band_member_set_isolate_ast_loop_type(
8730                 __isl_take isl_schedule_node *node, int pos,
8731                 enum isl_ast_loop_type type);
8732         isl_schedule_node_band_get_ast_build_options(
8733                 __isl_keep isl_schedule_node *node);
8734         __isl_give isl_schedule_node *
8735         isl_schedule_node_band_set_ast_build_options(
8736                 __isl_take isl_schedule_node *node,
8737                 __isl_take isl_union_set *options);
8738         __isl_give isl_set *
8739         isl_schedule_node_band_get_ast_isolate_option(
8740                 __isl_keep isl_schedule_node *node);
8742 The function C<isl_schedule_node_band_get_space> returns the space
8743 of the partial schedule of the band.
8744 The function C<isl_schedule_node_band_get_partial_schedule_union_map>
8745 returns a representation of the partial schedule of the band node
8746 in the form of an C<isl_union_map>.
8747 The coincident and permutable properties are set by
8748 C<isl_schedule_constraints_compute_schedule> on the schedule tree
8749 it produces.
8750 A scheduling dimension is considered to be ``coincident''
8751 if it satisfies the coincidence constraints within its band.
8752 That is, if the dependence distances of the coincidence
8753 constraints are all zero in that direction (for fixed
8754 iterations of outer bands).
8755 A band is marked permutable if it was produced using the Pluto-like scheduler.
8756 Note that the scheduler may have to resort to a Feautrier style scheduling
8757 step even if the default scheduler is used.
8758 An C<isl_ast_loop_type> is one of C<isl_ast_loop_default>,
8759 C<isl_ast_loop_atomic>, C<isl_ast_loop_unroll> or C<isl_ast_loop_separate>.
8760 For the meaning of these loop AST generation types and the difference
8761 between the regular loop AST generation type and the isolate
8762 loop AST generation type, see L</"AST Generation Options (Schedule Tree)">.
8763 The functions C<isl_schedule_node_band_member_get_ast_loop_type>
8764 and C<isl_schedule_node_band_member_get_isolate_ast_loop_type>
8765 may return C<isl_ast_loop_error> if an error occurs.
8766 The AST build options govern how an AST is generated for
8767 the individual schedule dimensions during AST generation.
8768 See L</"AST Generation Options (Schedule Tree)">.
8769 The isolate option for the given node can be extracted from these
8770 AST build options using the function
8771 C<isl_schedule_node_band_get_ast_isolate_option>.
8773         #include <isl/schedule_node.h>
8774         __isl_give isl_set *
8775         isl_schedule_node_context_get_context(
8776                 __isl_keep isl_schedule_node *node);
8778         #include <isl/schedule_node.h>
8779         __isl_give isl_union_set *
8780         isl_schedule_node_domain_get_domain(
8781                 __isl_keep isl_schedule_node *node);
8783         #include <isl/schedule_node.h>
8784         __isl_give isl_union_map *
8785         isl_schedule_node_expansion_get_expansion(
8786                 __isl_keep isl_schedule_node *node);
8787         __isl_give isl_union_pw_multi_aff *
8788         isl_schedule_node_expansion_get_contraction(
8789                 __isl_keep isl_schedule_node *node);
8791         #include <isl/schedule_node.h>
8792         __isl_give isl_union_map *
8793         isl_schedule_node_extension_get_extension(
8794                 __isl_keep isl_schedule_node *node);
8796         #include <isl/schedule_node.h>
8797         __isl_give isl_union_set *
8798         isl_schedule_node_filter_get_filter(
8799                 __isl_keep isl_schedule_node *node);
8801         #include <isl/schedule_node.h>
8802         __isl_give isl_set *isl_schedule_node_guard_get_guard(
8803                 __isl_keep isl_schedule_node *node);
8805         #include <isl/schedule_node.h>
8806         __isl_give isl_id *isl_schedule_node_mark_get_id(
8807                 __isl_keep isl_schedule_node *node);
8809 The following functions can be used to obtain an C<isl_multi_union_pw_aff>,
8810 an C<isl_union_pw_multi_aff> or C<isl_union_map> representation of
8811 partial schedules related to the node.
8813         #include <isl/schedule_node.h>
8814         __isl_give isl_multi_union_pw_aff *
8815         isl_schedule_node_get_prefix_schedule_multi_union_pw_aff(
8816                 __isl_keep isl_schedule_node *node);
8817         __isl_give isl_union_pw_multi_aff *
8818         isl_schedule_node_get_prefix_schedule_union_pw_multi_aff(
8819                 __isl_keep isl_schedule_node *node);
8820         __isl_give isl_union_map *
8821         isl_schedule_node_get_prefix_schedule_union_map(
8822                 __isl_keep isl_schedule_node *node);
8823         __isl_give isl_union_map *
8824         isl_schedule_node_get_prefix_schedule_relation(
8825                 __isl_keep isl_schedule_node *node);
8826         __isl_give isl_union_map *
8827         isl_schedule_node_get_subtree_schedule_union_map(
8828                 __isl_keep isl_schedule_node *node);
8830 In particular, the functions
8831 C<isl_schedule_node_get_prefix_schedule_multi_union_pw_aff>,
8832 C<isl_schedule_node_get_prefix_schedule_union_pw_multi_aff>
8833 and C<isl_schedule_node_get_prefix_schedule_union_map>
8834 return a relative ordering on the domain elements that reach the given
8835 node determined by its ancestors.
8836 The function C<isl_schedule_node_get_prefix_schedule_relation>
8837 additionally includes the domain constraints in the result.
8838 The function C<isl_schedule_node_get_subtree_schedule_union_map>
8839 returns a representation of the partial schedule defined by the
8840 subtree rooted at the given node.
8841 If the tree contains any expansion nodes, then the subtree schedule
8842 is formulated in terms of the expanded domain elements.
8843 The tree passed to functions returning a prefix schedule
8844 may only contain extension nodes if these would not affect
8845 the result of these functions.  That is, if one of the ancestors
8846 is an extension node, then all of the domain elements that were
8847 added by the extension node need to have been filtered out
8848 by filter nodes between the extension node and the input node.
8849 The tree passed to C<isl_schedule_node_get_subtree_schedule_union_map>
8850 may not contain in extension nodes in the selected subtree.
8852 The expansion/contraction defined by an entire subtree, combining
8853 the expansions/contractions
8854 on the expansion nodes in the subtree, can be obtained using
8855 the following functions.
8857         #include <isl/schedule_node.h>
8858         __isl_give isl_union_map *
8859         isl_schedule_node_get_subtree_expansion(
8860                 __isl_keep isl_schedule_node *node);
8861         __isl_give isl_union_pw_multi_aff *
8862         isl_schedule_node_get_subtree_contraction(
8863                 __isl_keep isl_schedule_node *node);
8865 The total number of outer band members of given node, i.e.,
8866 the shared output dimension of the maps in the result
8867 of C<isl_schedule_node_get_prefix_schedule_union_map> can be obtained
8868 using the following function.
8870         #include <isl/schedule_node.h>
8871         int isl_schedule_node_get_schedule_depth(
8872                 __isl_keep isl_schedule_node *node);
8874 The following functions return the elements that reach the given node
8875 or the union of universes in the spaces that contain these elements.
8877         #include <isl/schedule_node.h>
8878         __isl_give isl_union_set *
8879         isl_schedule_node_get_domain(
8880                 __isl_keep isl_schedule_node *node);
8881         __isl_give isl_union_set *
8882         isl_schedule_node_get_universe_domain(
8883                 __isl_keep isl_schedule_node *node);
8885 The input tree of C<isl_schedule_node_get_domain>
8886 may only contain extension nodes if these would not affect
8887 the result of this function.  That is, if one of the ancestors
8888 is an extension node, then all of the domain elements that were
8889 added by the extension node need to have been filtered out
8890 by filter nodes between the extension node and the input node.
8892 The following functions can be used to introduce additional nodes
8893 in the schedule tree.  The new node is introduced at the point
8894 in the tree where the C<isl_schedule_node> points to and
8895 the results points to the new node.
8897         #include <isl/schedule_node.h>
8898         __isl_give isl_schedule_node *
8899         isl_schedule_node_insert_partial_schedule(
8900                 __isl_take isl_schedule_node *node,
8901                 __isl_take isl_multi_union_pw_aff *schedule);
8903 This function inserts a new band node with (the greatest integer
8904 part of) the given partial schedule.
8905 The subtree rooted at the given node is assumed not to have
8906 any anchored nodes.
8908         #include <isl/schedule_node.h>
8909         __isl_give isl_schedule_node *
8910         isl_schedule_node_insert_context(
8911                 __isl_take isl_schedule_node *node,
8912                 __isl_take isl_set *context);
8914 This function inserts a new context node with the given context constraints.
8916         #include <isl/schedule_node.h>
8917         __isl_give isl_schedule_node *
8918         isl_schedule_node_insert_filter(
8919                 __isl_take isl_schedule_node *node,
8920                 __isl_take isl_union_set *filter);
8922 This function inserts a new filter node with the given filter.
8923 If the original node already pointed to a filter node, then the
8924 two filter nodes are merged into one.
8926         #include <isl/schedule_node.h>
8927         __isl_give isl_schedule_node *
8928         isl_schedule_node_insert_guard(
8929                 __isl_take isl_schedule_node *node,
8930                 __isl_take isl_set *guard);
8932 This function inserts a new guard node with the given guard constraints.
8934         #include <isl/schedule_node.h>
8935         __isl_give isl_schedule_node *
8936         isl_schedule_node_insert_mark(
8937                 __isl_take isl_schedule_node *node,
8938                 __isl_take isl_id *mark);
8940 This function inserts a new mark node with the give mark identifier.
8942         #include <isl/schedule_node.h>
8943         __isl_give isl_schedule_node *
8944         isl_schedule_node_insert_sequence(
8945                 __isl_take isl_schedule_node *node,
8946                 __isl_take isl_union_set_list *filters);
8947         __isl_give isl_schedule_node *
8948         isl_schedule_node_insert_set(
8949                 __isl_take isl_schedule_node *node,
8950                 __isl_take isl_union_set_list *filters);
8952 These functions insert a new sequence or set node with the given
8953 filters as children.
8955         #include <isl/schedule_node.h>
8956         __isl_give isl_schedule_node *isl_schedule_node_group(
8957                 __isl_take isl_schedule_node *node,
8958                 __isl_take isl_id *group_id);
8960 This function introduces an expansion node in between the current
8961 node and its parent that expands instances of a space with tuple
8962 identifier C<group_id> to the original domain elements that reach
8963 the node.  The group instances are identified by the prefix schedule
8964 of those domain elements.  The ancestors of the node are adjusted
8965 to refer to the group instances instead of the original domain
8966 elements.  The return value points to the same node in the updated
8967 schedule tree as the input node, i.e., to the child of the newly
8968 introduced expansion node.  Grouping instances of different statements
8969 ensures that they will be treated as a single statement by the
8970 AST generator up to the point of the expansion node.
8972 The following function can be used to flatten a nested
8973 sequence.
8975         #include <isl/schedule_node.h>
8976         __isl_give isl_schedule_node *
8977         isl_schedule_node_sequence_splice_child(
8978                 __isl_take isl_schedule_node *node, int pos);
8980 That is, given a sequence node C<node> that has another sequence node
8981 in its child at position C<pos> (in particular, the child of that filter
8982 node is a sequence node), attach the children of that other sequence
8983 node as children of C<node>, replacing the original child at position
8984 C<pos>.
8986 The partial schedule of a band node can be scaled (down) or reduced using
8987 the following functions.
8989         #include <isl/schedule_node.h>
8990         __isl_give isl_schedule_node *
8991         isl_schedule_node_band_scale(
8992                 __isl_take isl_schedule_node *node,
8993                 __isl_take isl_multi_val *mv);
8994         __isl_give isl_schedule_node *
8995         isl_schedule_node_band_scale_down(
8996                 __isl_take isl_schedule_node *node,
8997                 __isl_take isl_multi_val *mv);
8998         __isl_give isl_schedule_node *
8999         isl_schedule_node_band_mod(
9000                 __isl_take isl_schedule_node *node,
9001                 __isl_take isl_multi_val *mv);
9003 The spaces of the two arguments need to match.
9004 After scaling, the partial schedule is replaced by its greatest
9005 integer part to ensure that the schedule remains integral.
9007 The partial schedule of a band node can be shifted by an
9008 C<isl_multi_union_pw_aff> with a domain that is a superset
9009 of the domain of the partial schedule using
9010 the following function.
9012         #include <isl/schedule_node.h>
9013         __isl_give isl_schedule_node *
9014         isl_schedule_node_band_shift(
9015                 __isl_take isl_schedule_node *node,
9016                 __isl_take isl_multi_union_pw_aff *shift);
9018 A band node can be tiled using the following function.
9020         #include <isl/schedule_node.h>
9021         __isl_give isl_schedule_node *isl_schedule_node_band_tile(
9022                 __isl_take isl_schedule_node *node,
9023                 __isl_take isl_multi_val *sizes);
9025         isl_stat isl_options_set_tile_scale_tile_loops(isl_ctx *ctx,
9026                 int val);
9027         int isl_options_get_tile_scale_tile_loops(isl_ctx *ctx);
9028         isl_stat isl_options_set_tile_shift_point_loops(isl_ctx *ctx,
9029                 int val);
9030         int isl_options_get_tile_shift_point_loops(isl_ctx *ctx);
9032 The C<isl_schedule_node_band_tile> function tiles
9033 the band using the given tile sizes inside its schedule.
9034 A new child band node is created to represent the point loops and it is
9035 inserted between the modified band and its children.
9036 The subtree rooted at the given node is assumed not to have
9037 any anchored nodes.
9038 The C<tile_scale_tile_loops> option specifies whether the tile
9039 loops iterators should be scaled by the tile sizes.
9040 If the C<tile_shift_point_loops> option is set, then the point loops
9041 are shifted to start at zero.
9043 A band node can be split into two nested band nodes
9044 using the following function.
9046         #include <isl/schedule_node.h>
9047         __isl_give isl_schedule_node *isl_schedule_node_band_split(
9048                 __isl_take isl_schedule_node *node, int pos);
9050 The resulting outer band node contains the first C<pos> dimensions of
9051 the schedule of C<node> while the inner band contains the remaining dimensions.
9052 The schedules of the two band nodes live in anonymous spaces.
9053 The loop AST generation type options and the isolate option
9054 are split over the two band nodes.
9056 A band node can be moved down to the leaves of the subtree rooted
9057 at the band node using the following function.
9059         #include <isl/schedule_node.h>
9060         __isl_give isl_schedule_node *isl_schedule_node_band_sink(
9061                 __isl_take isl_schedule_node *node);
9063 The subtree rooted at the given node is assumed not to have
9064 any anchored nodes.
9065 The result points to the node in the resulting tree that is in the same
9066 position as the node pointed to by C<node> in the original tree.
9068         #include <isl/schedule_node.h>
9069         __isl_give isl_schedule_node *
9070         isl_schedule_node_order_before(
9071                 __isl_take isl_schedule_node *node,
9072                 __isl_take isl_union_set *filter);
9073         __isl_give isl_schedule_node *
9074         isl_schedule_node_order_after(
9075                 __isl_take isl_schedule_node *node,
9076                 __isl_take isl_union_set *filter);
9078 These functions split the domain elements that reach C<node>
9079 into those that satisfy C<filter> and those that do not and
9080 arranges for the elements that do satisfy the filter to be
9081 executed before (in case of C<isl_schedule_node_order_before>)
9082 or after (in case of C<isl_schedule_node_order_after>)
9083 those that do not.  The order is imposed by
9084 a sequence node, possibly reusing the grandparent of C<node>
9085 on two copies of the subtree attached to the original C<node>.
9086 Both copies are simplified with respect to their filter.
9088 Return a pointer to the copy of the subtree that does not
9089 satisfy C<filter>.  If there is no such copy (because all
9090 reaching domain elements satisfy the filter), then return
9091 the original pointer.
9093         #include <isl/schedule_node.h>
9094         __isl_give isl_schedule_node *
9095         isl_schedule_node_graft_before(
9096                 __isl_take isl_schedule_node *node,
9097                 __isl_take isl_schedule_node *graft);
9098         __isl_give isl_schedule_node *
9099         isl_schedule_node_graft_after(
9100                 __isl_take isl_schedule_node *node,
9101                 __isl_take isl_schedule_node *graft);
9103 This function inserts the C<graft> tree into the tree containing C<node>
9104 such that it is executed before (in case of C<isl_schedule_node_graft_before>)
9105 or after (in case of C<isl_schedule_node_graft_after>) C<node>.
9106 The root node of C<graft>
9107 should be an extension node where the domain of the extension
9108 is the flat product of all outer band nodes of C<node>.
9109 The root node may also be a domain node.
9110 The elements of the domain or the range of the extension may not
9111 intersect with the domain elements that reach "node".
9112 The schedule tree of C<graft> may not be anchored.
9114 The schedule tree of C<node> is modified to include an extension node
9115 corresponding to the root node of C<graft> as a child of the original
9116 parent of C<node>.  The original node that C<node> points to and the
9117 child of the root node of C<graft> are attached to this extension node
9118 through a sequence, with appropriate filters and with the child
9119 of C<graft> appearing before or after the original C<node>.
9121 If C<node> already appears inside a sequence that is the child of
9122 an extension node and if the spaces of the new domain elements
9123 do not overlap with those of the original domain elements,
9124 then that extension node is extended with the new extension
9125 rather than introducing a new segment of extension and sequence nodes.
9127 Return a pointer to the same node in the modified tree that
9128 C<node> pointed to in the original tree.
9130 A representation of the schedule node can be printed using
9132         #include <isl/schedule_node.h>
9133         __isl_give isl_printer *isl_printer_print_schedule_node(
9134                 __isl_take isl_printer *p,
9135                 __isl_keep isl_schedule_node *node);
9136         __isl_give char *isl_schedule_node_to_str(
9137                 __isl_keep isl_schedule_node *node);
9139 C<isl_schedule_node_to_str> prints the schedule node in block format.
9141 =head2 Dependence Analysis
9143 C<isl> contains specialized functionality for performing
9144 array dataflow analysis.  That is, given a I<sink> access relation,
9145 a collection of possible I<source> accesses and
9146 a collection of I<kill> accesses,
9147 C<isl> can compute relations that describe
9148 for each iteration of the sink access, which iterations
9149 of which of the source access relations may have
9150 accessed the same data element before the given iteration
9151 of the sink access without any intermediate kill of that data element.
9152 The resulting dependence relations map source iterations
9153 to either the corresponding sink iterations or
9154 pairs of corresponding sink iterations and accessed data elements.
9155 To compute standard flow dependences, the sink should be
9156 a read, while the sources should be writes.
9157 If no kills are specified,
9158 then memory based dependence analysis is performed.
9159 If, on the other hand, all sources are also kills,
9160 then value based dependence analysis is performed.
9161 If any of the source accesses are marked as being I<must>
9162 accesses, then they are also treated as kills.
9163 Furthermore, the specification of must-sources results
9164 in the computation of must-dependences.
9165 Only dependences originating in a must access not coscheduled
9166 with any other access to the same element and without
9167 any may accesses between the must access and the sink access
9168 are considered to be must dependences.
9170 =head3 High-level Interface
9172 A high-level interface to dependence analysis is provided
9173 by the following function.
9175         #include <isl/flow.h>
9176         __isl_give isl_union_flow *
9177         isl_union_access_info_compute_flow(
9178                 __isl_take isl_union_access_info *access);
9180 The input C<isl_union_access_info> object describes the sink
9181 access relations, the source access relations and a schedule,
9182 while the output C<isl_union_flow> object describes
9183 the resulting dependence relations and the subsets of the
9184 sink relations for which no source was found.
9186 An C<isl_union_access_info> is created, modified, copied and freed using
9187 the following functions.
9189         #include <isl/flow.h>
9190         __isl_give isl_union_access_info *
9191         isl_union_access_info_from_sink(
9192                 __isl_take isl_union_map *sink);
9193         __isl_give isl_union_access_info *
9194         isl_union_access_info_set_kill(
9195                 __isl_take isl_union_access_info *access,
9196                 __isl_take isl_union_map *kill);
9197         __isl_give isl_union_access_info *
9198         isl_union_access_info_set_may_source(
9199                 __isl_take isl_union_access_info *access,
9200                 __isl_take isl_union_map *may_source);
9201         __isl_give isl_union_access_info *
9202         isl_union_access_info_set_must_source(
9203                 __isl_take isl_union_access_info *access,
9204                 __isl_take isl_union_map *must_source);
9205         __isl_give isl_union_access_info *
9206         isl_union_access_info_set_schedule(
9207                 __isl_take isl_union_access_info *access,
9208                 __isl_take isl_schedule *schedule);
9209         __isl_give isl_union_access_info *
9210         isl_union_access_info_set_schedule_map(
9211                 __isl_take isl_union_access_info *access,
9212                 __isl_take isl_union_map *schedule_map);
9213         __isl_give isl_union_access_info *
9214         isl_union_access_info_copy(
9215                 __isl_keep isl_union_access_info *access);
9216         __isl_null isl_union_access_info *
9217         isl_union_access_info_free(
9218                 __isl_take isl_union_access_info *access);
9220 The may sources set by C<isl_union_access_info_set_may_source>
9221 do not need to include the must sources set by
9222 C<isl_union_access_info_set_must_source> as a subset.
9223 The kills set by C<isl_union_access_info_set_kill> may overlap
9224 with the may-sources and/or must-sources.
9225 The user is free not to call one (or more) of these functions,
9226 in which case the corresponding set is kept to its empty default.
9227 Similarly, the default schedule initialized by
9228 C<isl_union_access_info_from_sink> is empty.
9229 The current schedule is determined by the last call to either
9230 C<isl_union_access_info_set_schedule> or
9231 C<isl_union_access_info_set_schedule_map>.
9232 The domain of the schedule corresponds to the domains of
9233 the access relations.  In particular, the domains of the access
9234 relations are effectively intersected with the domain of the schedule
9235 and only the resulting accesses are considered by the dependence analysis.
9237 An C<isl_union_access_info> object can be read from input
9238 using the following function.
9240         #include <isl/flow.h>
9241         __isl_give isl_union_access_info *
9242         isl_union_access_info_read_from_file(isl_ctx *ctx,
9243                 FILE *input);
9245 A representation of the information contained in an object
9246 of type C<isl_union_access_info> can be obtained using
9248         #include <isl/flow.h>
9249         __isl_give isl_printer *
9250         isl_printer_print_union_access_info(
9251                 __isl_take isl_printer *p,
9252                 __isl_keep isl_union_access_info *access);
9253         __isl_give char *isl_union_access_info_to_str(
9254                 __isl_keep isl_union_access_info *access);
9256 C<isl_union_access_info_to_str> prints the information in flow format.
9258 The output of C<isl_union_access_info_compute_flow> can be examined,
9259 copied, and freed using the following functions.
9261         #include <isl/flow.h>
9262         __isl_give isl_union_map *isl_union_flow_get_must_dependence(
9263                 __isl_keep isl_union_flow *flow);
9264         __isl_give isl_union_map *isl_union_flow_get_may_dependence(
9265                 __isl_keep isl_union_flow *flow);
9266         __isl_give isl_union_map *
9267         isl_union_flow_get_full_must_dependence(
9268                 __isl_keep isl_union_flow *flow);
9269         __isl_give isl_union_map *
9270         isl_union_flow_get_full_may_dependence(
9271                 __isl_keep isl_union_flow *flow);
9272         __isl_give isl_union_map *isl_union_flow_get_must_no_source(
9273                 __isl_keep isl_union_flow *flow);
9274         __isl_give isl_union_map *isl_union_flow_get_may_no_source(
9275                 __isl_keep isl_union_flow *flow);
9276         __isl_give isl_union_flow *isl_union_flow_copy(
9277                 __isl_keep isl_union_flow *flow);
9278         __isl_null isl_union_flow *isl_union_flow_free(
9279                 __isl_take isl_union_flow *flow);
9281 The relation returned by C<isl_union_flow_get_must_dependence>
9282 relates domain elements of must sources to domain elements of the sink.
9283 The relation returned by C<isl_union_flow_get_may_dependence>
9284 relates domain elements of must or may sources to domain elements of the sink
9285 and includes the previous relation as a subset.
9286 The relation returned by C<isl_union_flow_get_full_must_dependence>
9287 relates domain elements of must sources to pairs of domain elements of the sink
9288 and accessed data elements.
9289 The relation returned by C<isl_union_flow_get_full_may_dependence>
9290 relates domain elements of must or may sources to pairs of
9291 domain elements of the sink and accessed data elements.
9292 This relation includes the previous relation as a subset.
9293 The relation returned by C<isl_union_flow_get_must_no_source> is the subset
9294 of the sink relation for which no dependences have been found.
9295 The relation returned by C<isl_union_flow_get_may_no_source> is the subset
9296 of the sink relation for which no definite dependences have been found.
9297 That is, it contains those sink access that do not contribute to any
9298 of the elements in the relation returned
9299 by C<isl_union_flow_get_must_dependence>.
9301 A representation of the information contained in an object
9302 of type C<isl_union_flow> can be obtained using
9304         #include <isl/flow.h>
9305         __isl_give isl_printer *isl_printer_print_union_flow(
9306                 __isl_take isl_printer *p,
9307                 __isl_keep isl_union_flow *flow);
9308         __isl_give char *isl_union_flow_to_str(
9309                 __isl_keep isl_union_flow *flow);
9311 C<isl_union_flow_to_str> prints the information in flow format.
9313 =head3 Low-level Interface
9315 A lower-level interface is provided by the following functions.
9317         #include <isl/flow.h>
9319         typedef int (*isl_access_level_before)(void *first, void *second);
9321         __isl_give isl_access_info *isl_access_info_alloc(
9322                 __isl_take isl_map *sink,
9323                 void *sink_user, isl_access_level_before fn,
9324                 int max_source);
9325         __isl_give isl_access_info *isl_access_info_add_source(
9326                 __isl_take isl_access_info *acc,
9327                 __isl_take isl_map *source, int must,
9328                 void *source_user);
9329         __isl_null isl_access_info *isl_access_info_free(
9330                 __isl_take isl_access_info *acc);
9332         __isl_give isl_flow *isl_access_info_compute_flow(
9333                 __isl_take isl_access_info *acc);
9335         isl_stat isl_flow_foreach(__isl_keep isl_flow *deps,
9336                 isl_stat (*fn)(__isl_take isl_map *dep, int must,
9337                           void *dep_user, void *user),
9338                 void *user);
9339         __isl_give isl_map *isl_flow_get_no_source(
9340                 __isl_keep isl_flow *deps, int must);
9341         void isl_flow_free(__isl_take isl_flow *deps);
9343 The function C<isl_access_info_compute_flow> performs the actual
9344 dependence analysis.  The other functions are used to construct
9345 the input for this function or to read off the output.
9347 The input is collected in an C<isl_access_info>, which can
9348 be created through a call to C<isl_access_info_alloc>.
9349 The arguments to this functions are the sink access relation
9350 C<sink>, a token C<sink_user> used to identify the sink
9351 access to the user, a callback function for specifying the
9352 relative order of source and sink accesses, and the number
9353 of source access relations that will be added.
9355 The callback function has type C<int (*)(void *first, void *second)>.
9356 The function is called with two user supplied tokens identifying
9357 either a source or the sink and it should return the shared nesting
9358 level and the relative order of the two accesses.
9359 In particular, let I<n> be the number of loops shared by
9360 the two accesses.  If C<first> precedes C<second> textually,
9361 then the function should return I<2 * n + 1>; otherwise,
9362 it should return I<2 * n>.
9363 The low-level interface assumes that no sources are coscheduled.
9364 If the information returned by the callback does not allow
9365 the relative order to be determined, then one of the sources
9366 is arbitrarily taken to be executed after the other(s).
9368 The sources can be added to the C<isl_access_info> object by performing
9369 (at most) C<max_source> calls to C<isl_access_info_add_source>.
9370 C<must> indicates whether the source is a I<must> access
9371 or a I<may> access.  Note that a multi-valued access relation
9372 should only be marked I<must> if every iteration in the domain
9373 of the relation accesses I<all> elements in its image.
9374 The C<source_user> token is again used to identify
9375 the source access.  The range of the source access relation
9376 C<source> should have the same dimension as the range
9377 of the sink access relation.
9378 The C<isl_access_info_free> function should usually not be
9379 called explicitly, because it is already called implicitly by
9380 C<isl_access_info_compute_flow>.
9382 The result of the dependence analysis is collected in an
9383 C<isl_flow>.  There may be elements of
9384 the sink access for which no preceding source access could be
9385 found or for which all preceding sources are I<may> accesses.
9386 The relations containing these elements can be obtained through
9387 calls to C<isl_flow_get_no_source>, the first with C<must> set
9388 and the second with C<must> unset.
9389 In the case of standard flow dependence analysis,
9390 with the sink a read and the sources I<must> writes,
9391 the first relation corresponds to the reads from uninitialized
9392 array elements and the second relation is empty.
9393 The actual flow dependences can be extracted using
9394 C<isl_flow_foreach>.  This function will call the user-specified
9395 callback function C<fn> for each B<non-empty> dependence between
9396 a source and the sink.  The callback function is called
9397 with four arguments, the actual flow dependence relation
9398 mapping source iterations to sink iterations, a boolean that
9399 indicates whether it is a I<must> or I<may> dependence, a token
9400 identifying the source and an additional C<void *> with value
9401 equal to the third argument of the C<isl_flow_foreach> call.
9402 A dependence is marked I<must> if it originates from a I<must>
9403 source and if it is not followed by any I<may> sources.
9405 After finishing with an C<isl_flow>, the user should call
9406 C<isl_flow_free> to free all associated memory.
9408 =head3 Interaction with the Low-level Interface
9410 During the dependence analysis, we frequently need to perform
9411 the following operation.  Given a relation between sink iterations
9412 and potential source iterations from a particular source domain,
9413 what is the last potential source iteration corresponding to each
9414 sink iteration.  It can sometimes be convenient to adjust
9415 the set of potential source iterations before or after each such operation.
9416 The prototypical example is fuzzy array dataflow analysis,
9417 where we need to analyze if, based on data-dependent constraints,
9418 the sink iteration can ever be executed without one or more of
9419 the corresponding potential source iterations being executed.
9420 If so, we can introduce extra parameters and select an unknown
9421 but fixed source iteration from the potential source iterations.
9422 To be able to perform such manipulations, C<isl> provides the following
9423 function.
9425         #include <isl/flow.h>
9427         typedef __isl_give isl_restriction *(*isl_access_restrict)(
9428                 __isl_keep isl_map *source_map,
9429                 __isl_keep isl_set *sink, void *source_user,
9430                 void *user);
9431         __isl_give isl_access_info *isl_access_info_set_restrict(
9432                 __isl_take isl_access_info *acc,
9433                 isl_access_restrict fn, void *user);
9435 The function C<isl_access_info_set_restrict> should be called
9436 before calling C<isl_access_info_compute_flow> and registers a callback function
9437 that will be called any time C<isl> is about to compute the last
9438 potential source.  The first argument is the (reverse) proto-dependence,
9439 mapping sink iterations to potential source iterations.
9440 The second argument represents the sink iterations for which
9441 we want to compute the last source iteration.
9442 The third argument is the token corresponding to the source
9443 and the final argument is the token passed to C<isl_access_info_set_restrict>.
9444 The callback is expected to return a restriction on either the input or
9445 the output of the operation computing the last potential source.
9446 If the input needs to be restricted then restrictions are needed
9447 for both the source and the sink iterations.  The sink iterations
9448 and the potential source iterations will be intersected with these sets.
9449 If the output needs to be restricted then only a restriction on the source
9450 iterations is required.
9451 If any error occurs, the callback should return C<NULL>.
9452 An C<isl_restriction> object can be created, freed and inspected
9453 using the following functions.
9455         #include <isl/flow.h>
9457         __isl_give isl_restriction *isl_restriction_input(
9458                 __isl_take isl_set *source_restr,
9459                 __isl_take isl_set *sink_restr);
9460         __isl_give isl_restriction *isl_restriction_output(
9461                 __isl_take isl_set *source_restr);
9462         __isl_give isl_restriction *isl_restriction_none(
9463                 __isl_take isl_map *source_map);
9464         __isl_give isl_restriction *isl_restriction_empty(
9465                 __isl_take isl_map *source_map);
9466         __isl_null isl_restriction *isl_restriction_free(
9467                 __isl_take isl_restriction *restr);
9469 C<isl_restriction_none> and C<isl_restriction_empty> are special
9470 cases of C<isl_restriction_input>.  C<isl_restriction_none>
9471 is essentially equivalent to
9473         isl_restriction_input(isl_set_universe(
9474             isl_space_range(isl_map_get_space(source_map))),
9475                             isl_set_universe(
9476             isl_space_domain(isl_map_get_space(source_map))));
9478 whereas C<isl_restriction_empty> is essentially equivalent to
9480         isl_restriction_input(isl_set_empty(
9481             isl_space_range(isl_map_get_space(source_map))),
9482                             isl_set_universe(
9483             isl_space_domain(isl_map_get_space(source_map))));
9485 =head2 Scheduling
9487         #include <isl/schedule.h>
9488         __isl_give isl_schedule *
9489         isl_schedule_constraints_compute_schedule(
9490                 __isl_take isl_schedule_constraints *sc);
9492 The function C<isl_schedule_constraints_compute_schedule> can be
9493 used to compute a schedule that satisfies the given schedule constraints.
9494 These schedule constraints include the iteration domain for which
9495 a schedule should be computed and dependences between pairs of
9496 iterations.  In particular, these dependences include
9497 I<validity> dependences and I<proximity> dependences.
9498 By default, the algorithm used to construct the schedule is similar
9499 to that of C<Pluto>.
9500 Alternatively, Feautrier's multi-dimensional scheduling algorithm can
9501 be selected.
9502 The generated schedule respects all validity dependences.
9503 That is, all dependence distances over these dependences in the
9504 scheduled space are lexicographically positive.
9506 The default algorithm tries to ensure that the dependence distances
9507 over coincidence constraints are zero and to minimize the
9508 dependence distances over proximity dependences.
9509 Moreover, it tries to obtain sequences (bands) of schedule dimensions
9510 for groups of domains where the dependence distances over validity
9511 dependences have only non-negative values.
9512 Note that when minimizing the maximal dependence distance
9513 over proximity dependences, a single affine expression in the parameters
9514 is constructed that bounds all dependence distances.  If no such expression
9515 exists, then the algorithm will fail and resort to an alternative
9516 scheduling algorithm.  In particular, this means that adding proximity
9517 dependences may eliminate valid solutions.  A typical example where this
9518 phenomenon may occur is when some subset of the proximity dependences
9519 has no restriction on some parameter, forcing the coefficient of that
9520 parameter to be zero, while some other subset forces the dependence
9521 distance to depend on that parameter, requiring the same coefficient
9522 to be non-zero.
9523 When using Feautrier's algorithm, the coincidence and proximity constraints
9524 are only taken into account during the extension to a
9525 full-dimensional schedule.
9527 An C<isl_schedule_constraints> object can be constructed
9528 and manipulated using the following functions.
9530         #include <isl/schedule.h>
9531         __isl_give isl_schedule_constraints *
9532         isl_schedule_constraints_copy(
9533                 __isl_keep isl_schedule_constraints *sc);
9534         __isl_give isl_schedule_constraints *
9535         isl_schedule_constraints_on_domain(
9536                 __isl_take isl_union_set *domain);
9537         __isl_give isl_schedule_constraints *
9538         isl_schedule_constraints_set_context(
9539                 __isl_take isl_schedule_constraints *sc,
9540                 __isl_take isl_set *context);
9541         __isl_give isl_schedule_constraints *
9542         isl_schedule_constraints_set_validity(
9543                 __isl_take isl_schedule_constraints *sc,
9544                 __isl_take isl_union_map *validity);
9545         __isl_give isl_schedule_constraints *
9546         isl_schedule_constraints_set_coincidence(
9547                 __isl_take isl_schedule_constraints *sc,
9548                 __isl_take isl_union_map *coincidence);
9549         __isl_give isl_schedule_constraints *
9550         isl_schedule_constraints_set_proximity(
9551                 __isl_take isl_schedule_constraints *sc,
9552                 __isl_take isl_union_map *proximity);
9553         __isl_give isl_schedule_constraints *
9554         isl_schedule_constraints_set_conditional_validity(
9555                 __isl_take isl_schedule_constraints *sc,
9556                 __isl_take isl_union_map *condition,
9557                 __isl_take isl_union_map *validity);
9558         __isl_give isl_schedule_constraints *
9559         isl_schedule_constraints_apply(
9560                 __isl_take isl_schedule_constraints *sc,
9561                 __isl_take isl_union_map *umap);
9562         __isl_null isl_schedule_constraints *
9563         isl_schedule_constraints_free(
9564                 __isl_take isl_schedule_constraints *sc);
9566 The initial C<isl_schedule_constraints> object created by
9567 C<isl_schedule_constraints_on_domain> does not impose any constraints.
9568 That is, it has an empty set of dependences.
9569 The function C<isl_schedule_constraints_set_context> allows the user
9570 to specify additional constraints on the parameters that may
9571 be assumed to hold during the construction of the schedule.
9572 The function C<isl_schedule_constraints_set_validity> replaces the
9573 validity dependences, mapping domain elements I<i> to domain
9574 elements that should be scheduled after I<i>.
9575 The function C<isl_schedule_constraints_set_coincidence> replaces the
9576 coincidence dependences, mapping domain elements I<i> to domain
9577 elements that should be scheduled together with I<I>, if possible.
9578 The function C<isl_schedule_constraints_set_proximity> replaces the
9579 proximity dependences, mapping domain elements I<i> to domain
9580 elements that should be scheduled either before I<I>
9581 or as early as possible after I<i>.
9583 The function C<isl_schedule_constraints_set_conditional_validity>
9584 replaces the conditional validity constraints.
9585 A conditional validity constraint is only imposed when any of the corresponding
9586 conditions is satisfied, i.e., when any of them is non-zero.
9587 That is, the scheduler ensures that within each band if the dependence
9588 distances over the condition constraints are not all zero
9589 then all corresponding conditional validity constraints are respected.
9590 A conditional validity constraint corresponds to a condition
9591 if the two are adjacent, i.e., if the domain of one relation intersect
9592 the range of the other relation.
9593 The typical use case of conditional validity constraints is
9594 to allow order constraints between live ranges to be violated
9595 as long as the live ranges themselves are local to the band.
9596 To allow more fine-grained control over which conditions correspond
9597 to which conditional validity constraints, the domains and ranges
9598 of these relations may include I<tags>.  That is, the domains and
9599 ranges of those relation may themselves be wrapped relations
9600 where the iteration domain appears in the domain of those wrapped relations
9601 and the range of the wrapped relations can be arbitrarily chosen
9602 by the user.  Conditions and conditional validity constraints are only
9603 considered adjacent to each other if the entire wrapped relation matches.
9604 In particular, a relation with a tag will never be considered adjacent
9605 to a relation without a tag.
9607 The function C<isl_schedule_constraints_apply> takes
9608 schedule constraints that are defined on some set of domain elements
9609 and transforms them to schedule constraints on the elements
9610 to which these domain elements are mapped by the given transformation.
9612 An C<isl_schedule_constraints> object can be inspected
9613 using the following functions.
9615         #include <isl/schedule.h>
9616         __isl_give isl_union_set *
9617         isl_schedule_constraints_get_domain(
9618                 __isl_keep isl_schedule_constraints *sc);
9619         __isl_give isl_set *isl_schedule_constraints_get_context(
9620                 __isl_keep isl_schedule_constraints *sc);
9621         __isl_give isl_union_map *
9622         isl_schedule_constraints_get_validity(
9623                 __isl_keep isl_schedule_constraints *sc);
9624         __isl_give isl_union_map *
9625         isl_schedule_constraints_get_coincidence(
9626                 __isl_keep isl_schedule_constraints *sc);
9627         __isl_give isl_union_map *
9628         isl_schedule_constraints_get_proximity(
9629                 __isl_keep isl_schedule_constraints *sc);
9630         __isl_give isl_union_map *
9631         isl_schedule_constraints_get_conditional_validity(
9632                 __isl_keep isl_schedule_constraints *sc);
9633         __isl_give isl_union_map *
9634         isl_schedule_constraints_get_conditional_validity_condition(
9635                 __isl_keep isl_schedule_constraints *sc);
9637 An C<isl_schedule_constraints> object can be read from input
9638 using the following functions.
9640         #include <isl/schedule.h>
9641         __isl_give isl_schedule_constraints *
9642         isl_schedule_constraints_read_from_str(isl_ctx *ctx,
9643                 const char *str);
9644         __isl_give isl_schedule_constraints *
9645         isl_schedule_constraints_read_from_file(isl_ctx *ctx,
9646                 FILE *input);
9648 The contents of an C<isl_schedule_constraints> object can be printed
9649 using the following functions.
9651         #include <isl/schedule.h>
9652         __isl_give isl_printer *
9653         isl_printer_print_schedule_constraints(
9654                 __isl_take isl_printer *p,
9655                 __isl_keep isl_schedule_constraints *sc);
9656         __isl_give char *isl_schedule_constraints_to_str(
9657                 __isl_keep isl_schedule_constraints *sc);
9659 The following function computes a schedule directly from
9660 an iteration domain and validity and proximity dependences
9661 and is implemented in terms of the functions described above.
9662 The use of C<isl_union_set_compute_schedule> is discouraged.
9664         #include <isl/schedule.h>
9665         __isl_give isl_schedule *isl_union_set_compute_schedule(
9666                 __isl_take isl_union_set *domain,
9667                 __isl_take isl_union_map *validity,
9668                 __isl_take isl_union_map *proximity);
9670 The generated schedule represents a schedule tree.
9671 For more information on schedule trees, see
9672 L</"Schedule Trees">.
9674 =head3 Options
9676         #include <isl/schedule.h>
9677         isl_stat isl_options_set_schedule_max_coefficient(
9678                 isl_ctx *ctx, int val);
9679         int isl_options_get_schedule_max_coefficient(
9680                 isl_ctx *ctx);
9681         isl_stat isl_options_set_schedule_max_constant_term(
9682                 isl_ctx *ctx, int val);
9683         int isl_options_get_schedule_max_constant_term(
9684                 isl_ctx *ctx);
9685         isl_stat isl_options_set_schedule_serialize_sccs(
9686                 isl_ctx *ctx, int val);
9687         int isl_options_get_schedule_serialize_sccs(isl_ctx *ctx);
9688         isl_stat isl_options_set_schedule_whole_component(
9689                 isl_ctx *ctx, int val);
9690         int isl_options_get_schedule_whole_component(
9691                 isl_ctx *ctx);
9692         isl_stat isl_options_set_schedule_maximize_band_depth(
9693                 isl_ctx *ctx, int val);
9694         int isl_options_get_schedule_maximize_band_depth(
9695                 isl_ctx *ctx);
9696         isl_stat isl_options_set_schedule_maximize_coincidence(
9697                 isl_ctx *ctx, int val);
9698         int isl_options_get_schedule_maximize_coincidence(
9699                 isl_ctx *ctx);
9700         isl_stat isl_options_set_schedule_outer_coincidence(
9701                 isl_ctx *ctx, int val);
9702         int isl_options_get_schedule_outer_coincidence(
9703                 isl_ctx *ctx);
9704         isl_stat isl_options_set_schedule_split_scaled(
9705                 isl_ctx *ctx, int val);
9706         int isl_options_get_schedule_split_scaled(
9707                 isl_ctx *ctx);
9708         isl_stat isl_options_set_schedule_treat_coalescing(
9709                 isl_ctx *ctx, int val);
9710         int isl_options_get_schedule_treat_coalescing(
9711                 isl_ctx *ctx);
9712         isl_stat isl_options_set_schedule_algorithm(
9713                 isl_ctx *ctx, int val);
9714         int isl_options_get_schedule_algorithm(
9715                 isl_ctx *ctx);
9716         isl_stat isl_options_set_schedule_carry_self_first(
9717                 isl_ctx *ctx, int val);
9718         int isl_options_get_schedule_carry_self_first(
9719                 isl_ctx *ctx);
9720         isl_stat isl_options_set_schedule_separate_components(
9721                 isl_ctx *ctx, int val);
9722         int isl_options_get_schedule_separate_components(
9723                 isl_ctx *ctx);
9725 =over
9727 =item * schedule_max_coefficient
9729 This option enforces that the coefficients for variable and parameter
9730 dimensions in the calculated schedule are not larger than the specified value.
9731 This option can significantly increase the speed of the scheduling calculation
9732 and may also prevent fusing of unrelated dimensions. A value of -1 means that
9733 this option does not introduce bounds on the variable or parameter
9734 coefficients.
9736 =item * schedule_max_constant_term
9738 This option enforces that the constant coefficients in the calculated schedule
9739 are not larger than the maximal constant term. This option can significantly
9740 increase the speed of the scheduling calculation and may also prevent fusing of
9741 unrelated dimensions. A value of -1 means that this option does not introduce
9742 bounds on the constant coefficients.
9744 =item * schedule_serialize_sccs
9746 If this option is set, then all strongly connected components
9747 in the dependence graph are serialized as soon as they are detected.
9748 This means in particular that instances of statements will only
9749 appear in the same band node if these statements belong
9750 to the same strongly connected component at the point where
9751 the band node is constructed.
9753 =item * schedule_whole_component
9755 If this option is set, then entire (weakly) connected
9756 components in the dependence graph are scheduled together
9757 as a whole.
9758 Otherwise, each strongly connected component within
9759 such a weakly connected component is first scheduled separately
9760 and then combined with other strongly connected components.
9761 This option has no effect if C<schedule_serialize_sccs> is set.
9763 =item * schedule_maximize_band_depth
9765 If this option is set, then the scheduler tries to maximize
9766 the width of the bands.  Wider bands give more possibilities for tiling.
9767 In particular, if the C<schedule_whole_component> option is set,
9768 then bands are split if this might result in wider bands.
9769 Otherwise, the effect of this option is to only allow
9770 strongly connected components to be combined if this does
9771 not reduce the width of the bands.
9772 Note that if the C<schedule_serialize_sccs> options is set, then
9773 the C<schedule_maximize_band_depth> option therefore has no effect.
9775 =item * schedule_maximize_coincidence
9777 This option is only effective if the C<schedule_whole_component>
9778 option is turned off.
9779 If the C<schedule_maximize_coincidence> option is set, then (clusters of)
9780 strongly connected components are only combined with each other
9781 if this does not reduce the number of coincident band members.
9783 =item * schedule_outer_coincidence
9785 If this option is set, then we try to construct schedules
9786 where the outermost scheduling dimension in each band
9787 satisfies the coincidence constraints.
9789 =item * schedule_algorithm
9791 Selects the scheduling algorithm to be used.
9792 Available scheduling algorithms are C<ISL_SCHEDULE_ALGORITHM_ISL>
9793 and C<ISL_SCHEDULE_ALGORITHM_FEAUTRIER>.
9795 =item * schedule_split_scaled
9797 If this option is set, then we try to construct schedules in which the
9798 constant term is split off from the linear part if the linear parts of
9799 the scheduling rows for all nodes in the graph have a common non-trivial
9800 divisor.
9801 The constant term is then dropped and the linear
9802 part is reduced.
9803 This option is only effective when the Feautrier style scheduler is
9804 being used, either as the main scheduler or as a fallback for the
9805 Pluto-like scheduler.
9807 =item * schedule_treat_coalescing
9809 If this option is set, then the scheduler will try and avoid
9810 producing schedules that perform loop coalescing.
9811 In particular, for the Pluto-like scheduler, this option places
9812 bounds on the schedule coefficients based on the sizes of the instance sets.
9813 For the Feautrier style scheduler, this option detects potentially
9814 coalescing schedules and then tries to adjust the schedule to avoid
9815 the coalescing.
9817 =item * schedule_carry_self_first
9819 If this option is set, then the Feautrier style scheduler
9820 (when used as a fallback for the Pluto-like scheduler) will
9821 first try to only carry self-dependences.
9823 =item * schedule_separate_components
9825 If this option is set then the function C<isl_schedule_get_map>
9826 will treat set nodes in the same way as sequence nodes.
9828 =back
9830 =head2 AST Generation
9832 This section describes the C<isl> functionality for generating
9833 ASTs that visit all the elements
9834 in a domain in an order specified by a schedule tree or
9835 a schedule map.
9836 In case the schedule given as a C<isl_union_map>, an AST is generated
9837 that visits all the elements in the domain of the C<isl_union_map>
9838 according to the lexicographic order of the corresponding image
9839 element(s).  If the range of the C<isl_union_map> consists of
9840 elements in more than one space, then each of these spaces is handled
9841 separately in an arbitrary order.
9842 It should be noted that the schedule tree or the image elements
9843 in a schedule map only specify the I<order>
9844 in which the corresponding domain elements should be visited.
9845 No direct relation between the partial schedule values
9846 or the image elements on the one hand and the loop iterators
9847 in the generated AST on the other hand should be assumed.
9849 Each AST is generated within a build.  The initial build
9850 simply specifies the constraints on the parameters (if any)
9851 and can be created, inspected, copied and freed using the following functions.
9853         #include <isl/ast_build.h>
9854         __isl_give isl_ast_build *isl_ast_build_alloc(
9855                 isl_ctx *ctx);
9856         __isl_give isl_ast_build *isl_ast_build_from_context(
9857                 __isl_take isl_set *set);
9858         __isl_give isl_ast_build *isl_ast_build_copy(
9859                 __isl_keep isl_ast_build *build);
9860         __isl_null isl_ast_build *isl_ast_build_free(
9861                 __isl_take isl_ast_build *build);
9863 The C<set> argument is usually a parameter set with zero or more parameters.
9864 In fact, when creating an AST using C<isl_ast_build_node_from_schedule>,
9865 this set is required to be a parameter set.
9866 An C<isl_ast_build> created using C<isl_ast_build_alloc> does not
9867 specify any parameter constraints.
9868 More C<isl_ast_build> functions are described in L</"Nested AST Generation">
9869 and L</"Fine-grained Control over AST Generation">.
9870 Finally, the AST itself can be constructed using one of the following
9871 functions.
9873         #include <isl/ast_build.h>
9874         __isl_give isl_ast_node *isl_ast_build_node_from_schedule(
9875                 __isl_keep isl_ast_build *build,
9876                 __isl_take isl_schedule *schedule);
9877         __isl_give isl_ast_node *
9878         isl_ast_build_node_from_schedule_map(
9879                 __isl_keep isl_ast_build *build,
9880                 __isl_take isl_union_map *schedule);
9882 =head3 Inspecting the AST
9884 The basic properties of an AST node can be obtained as follows.
9886         #include <isl/ast.h>
9887         enum isl_ast_node_type isl_ast_node_get_type(
9888                 __isl_keep isl_ast_node *node);
9890 The type of an AST node is one of
9891 C<isl_ast_node_for>,
9892 C<isl_ast_node_if>,
9893 C<isl_ast_node_block>,
9894 C<isl_ast_node_mark> or
9895 C<isl_ast_node_user>.
9896 An C<isl_ast_node_for> represents a for node.
9897 An C<isl_ast_node_if> represents an if node.
9898 An C<isl_ast_node_block> represents a compound node.
9899 An C<isl_ast_node_mark> introduces a mark in the AST.
9900 An C<isl_ast_node_user> represents an expression statement.
9901 An expression statement typically corresponds to a domain element, i.e.,
9902 one of the elements that is visited by the AST.
9904 Each type of node has its own additional properties.
9906         #include <isl/ast.h>
9907         __isl_give isl_ast_expr *isl_ast_node_for_get_iterator(
9908                 __isl_keep isl_ast_node *node);
9909         __isl_give isl_ast_expr *isl_ast_node_for_get_init(
9910                 __isl_keep isl_ast_node *node);
9911         __isl_give isl_ast_expr *isl_ast_node_for_get_cond(
9912                 __isl_keep isl_ast_node *node);
9913         __isl_give isl_ast_expr *isl_ast_node_for_get_inc(
9914                 __isl_keep isl_ast_node *node);
9915         __isl_give isl_ast_node *isl_ast_node_for_get_body(
9916                 __isl_keep isl_ast_node *node);
9917         isl_bool isl_ast_node_for_is_degenerate(
9918                 __isl_keep isl_ast_node *node);
9920 An C<isl_ast_for> is considered degenerate if it is known to execute
9921 exactly once.
9923         #include <isl/ast.h>
9924         __isl_give isl_ast_expr *isl_ast_node_if_get_cond(
9925                 __isl_keep isl_ast_node *node);
9926         __isl_give isl_ast_node *isl_ast_node_if_get_then(
9927                 __isl_keep isl_ast_node *node);
9928         isl_bool isl_ast_node_if_has_else(
9929                 __isl_keep isl_ast_node *node);
9930         __isl_give isl_ast_node *isl_ast_node_if_get_else(
9931                 __isl_keep isl_ast_node *node);
9933         __isl_give isl_ast_node_list *
9934         isl_ast_node_block_get_children(
9935                 __isl_keep isl_ast_node *node);
9937         __isl_give isl_id *isl_ast_node_mark_get_id(
9938                 __isl_keep isl_ast_node *node);
9939         __isl_give isl_ast_node *isl_ast_node_mark_get_node(
9940                 __isl_keep isl_ast_node *node);
9942 C<isl_ast_node_mark_get_id> returns the identifier of the mark.
9943 C<isl_ast_node_mark_get_node> returns the child node that is being marked.
9945         #include <isl/ast.h>
9946         __isl_give isl_ast_expr *isl_ast_node_user_get_expr(
9947                 __isl_keep isl_ast_node *node);
9949 All descendants of a specific node in the AST (including the node itself)
9950 can be visited
9951 in depth-first pre-order using the following function.
9953         #include <isl/ast.h>
9954         isl_stat isl_ast_node_foreach_descendant_top_down(
9955                 __isl_keep isl_ast_node *node,
9956                 isl_bool (*fn)(__isl_keep isl_ast_node *node,
9957                         void *user), void *user);
9959 The callback function should return C<isl_bool_true> if the children
9960 of the given node should be visited and C<isl_bool_false> if they should not.
9961 It should return C<isl_bool_error> in case of failure, in which case
9962 the entire traversal is aborted.
9964 Each of the returned C<isl_ast_expr>s can in turn be inspected using
9965 the following functions.
9967         #include <isl/ast.h>
9968         enum isl_ast_expr_type isl_ast_expr_get_type(
9969                 __isl_keep isl_ast_expr *expr);
9971 The type of an AST expression is one of
9972 C<isl_ast_expr_op>,
9973 C<isl_ast_expr_id> or
9974 C<isl_ast_expr_int>.
9975 An C<isl_ast_expr_op> represents the result of an operation.
9976 An C<isl_ast_expr_id> represents an identifier.
9977 An C<isl_ast_expr_int> represents an integer value.
9979 Each type of expression has its own additional properties.
9981         #include <isl/ast.h>
9982         enum isl_ast_op_type isl_ast_expr_get_op_type(
9983                 __isl_keep isl_ast_expr *expr);
9984         int isl_ast_expr_get_op_n_arg(__isl_keep isl_ast_expr *expr);
9985         __isl_give isl_ast_expr *isl_ast_expr_get_op_arg(
9986                 __isl_keep isl_ast_expr *expr, int pos);
9987         isl_stat isl_ast_expr_foreach_ast_op_type(
9988                 __isl_keep isl_ast_expr *expr,
9989                 isl_stat (*fn)(enum isl_ast_op_type type,
9990                         void *user), void *user);
9991         isl_stat isl_ast_node_foreach_ast_op_type(
9992                 __isl_keep isl_ast_node *node,
9993                 isl_stat (*fn)(enum isl_ast_op_type type,
9994                         void *user), void *user);
9996 C<isl_ast_expr_get_op_type> returns the type of the operation
9997 performed.  C<isl_ast_expr_get_op_n_arg> returns the number of
9998 arguments.  C<isl_ast_expr_get_op_arg> returns the specified
9999 argument.
10000 C<isl_ast_expr_foreach_ast_op_type> calls C<fn> for each distinct
10001 C<isl_ast_op_type> that appears in C<expr>.
10002 C<isl_ast_node_foreach_ast_op_type> does the same for each distinct
10003 C<isl_ast_op_type> that appears in C<node>.
10004 The operation type is one of the following.
10006 =over
10008 =item C<isl_ast_op_and>
10010 Logical I<and> of two arguments.
10011 Both arguments can be evaluated.
10013 =item C<isl_ast_op_and_then>
10015 Logical I<and> of two arguments.
10016 The second argument can only be evaluated if the first evaluates to true.
10018 =item C<isl_ast_op_or>
10020 Logical I<or> of two arguments.
10021 Both arguments can be evaluated.
10023 =item C<isl_ast_op_or_else>
10025 Logical I<or> of two arguments.
10026 The second argument can only be evaluated if the first evaluates to false.
10028 =item C<isl_ast_op_max>
10030 Maximum of two or more arguments.
10032 =item C<isl_ast_op_min>
10034 Minimum of two or more arguments.
10036 =item C<isl_ast_op_minus>
10038 Change sign.
10040 =item C<isl_ast_op_add>
10042 Sum of two arguments.
10044 =item C<isl_ast_op_sub>
10046 Difference of two arguments.
10048 =item C<isl_ast_op_mul>
10050 Product of two arguments.
10052 =item C<isl_ast_op_div>
10054 Exact division.  That is, the result is known to be an integer.
10056 =item C<isl_ast_op_fdiv_q>
10058 Result of integer division, rounded towards negative
10059 infinity.
10060 The divisor is known to be positive.
10062 =item C<isl_ast_op_pdiv_q>
10064 Result of integer division, where dividend is known to be non-negative.
10065 The divisor is known to be positive.
10067 =item C<isl_ast_op_pdiv_r>
10069 Remainder of integer division, where dividend is known to be non-negative.
10070 The divisor is known to be positive.
10072 =item C<isl_ast_op_zdiv_r>
10074 Equal to zero iff the remainder on integer division is zero.
10075 The divisor is known to be positive.
10077 =item C<isl_ast_op_cond>
10079 Conditional operator defined on three arguments.
10080 If the first argument evaluates to true, then the result
10081 is equal to the second argument.  Otherwise, the result
10082 is equal to the third argument.
10083 The second and third argument may only be evaluated if
10084 the first argument evaluates to true and false, respectively.
10085 Corresponds to C<a ? b : c> in C.
10087 =item C<isl_ast_op_select>
10089 Conditional operator defined on three arguments.
10090 If the first argument evaluates to true, then the result
10091 is equal to the second argument.  Otherwise, the result
10092 is equal to the third argument.
10093 The second and third argument may be evaluated independently
10094 of the value of the first argument.
10095 Corresponds to C<a * b + (1 - a) * c> in C.
10097 =item C<isl_ast_op_eq>
10099 Equality relation.
10101 =item C<isl_ast_op_le>
10103 Less than or equal relation.
10105 =item C<isl_ast_op_lt>
10107 Less than relation.
10109 =item C<isl_ast_op_ge>
10111 Greater than or equal relation.
10113 =item C<isl_ast_op_gt>
10115 Greater than relation.
10117 =item C<isl_ast_op_call>
10119 A function call.
10120 The number of arguments of the C<isl_ast_expr> is one more than
10121 the number of arguments in the function call, the first argument
10122 representing the function being called.
10124 =item C<isl_ast_op_access>
10126 An array access.
10127 The number of arguments of the C<isl_ast_expr> is one more than
10128 the number of index expressions in the array access, the first argument
10129 representing the array being accessed.
10131 =item C<isl_ast_op_member>
10133 A member access.
10134 This operation has two arguments, a structure and the name of
10135 the member of the structure being accessed.
10137 =back
10139         #include <isl/ast.h>
10140         __isl_give isl_id *isl_ast_expr_get_id(
10141                 __isl_keep isl_ast_expr *expr);
10143 Return the identifier represented by the AST expression.
10145         #include <isl/ast.h>
10146         __isl_give isl_val *isl_ast_expr_get_val(
10147                 __isl_keep isl_ast_expr *expr);
10149 Return the integer represented by the AST expression.
10151 =head3 Properties of ASTs
10153         #include <isl/ast.h>
10154         isl_bool isl_ast_expr_is_equal(
10155                 __isl_keep isl_ast_expr *expr1,
10156                 __isl_keep isl_ast_expr *expr2);
10158 Check if two C<isl_ast_expr>s are equal to each other.
10160 =head3 Manipulating and printing the AST
10162 AST nodes can be copied and freed using the following functions.
10164         #include <isl/ast.h>
10165         __isl_give isl_ast_node *isl_ast_node_copy(
10166                 __isl_keep isl_ast_node *node);
10167         __isl_null isl_ast_node *isl_ast_node_free(
10168                 __isl_take isl_ast_node *node);
10170 AST expressions can be copied and freed using the following functions.
10172         #include <isl/ast.h>
10173         __isl_give isl_ast_expr *isl_ast_expr_copy(
10174                 __isl_keep isl_ast_expr *expr);
10175         __isl_null isl_ast_expr *isl_ast_expr_free(
10176                 __isl_take isl_ast_expr *expr);
10178 New AST expressions can be created either directly or within
10179 the context of an C<isl_ast_build>.
10181         #include <isl/ast.h>
10182         __isl_give isl_ast_expr *isl_ast_expr_from_val(
10183                 __isl_take isl_val *v);
10184         __isl_give isl_ast_expr *isl_ast_expr_from_id(
10185                 __isl_take isl_id *id);
10186         __isl_give isl_ast_expr *isl_ast_expr_neg(
10187                 __isl_take isl_ast_expr *expr);
10188         __isl_give isl_ast_expr *isl_ast_expr_address_of(
10189                 __isl_take isl_ast_expr *expr);
10190         __isl_give isl_ast_expr *isl_ast_expr_add(
10191                 __isl_take isl_ast_expr *expr1,
10192                 __isl_take isl_ast_expr *expr2);
10193         __isl_give isl_ast_expr *isl_ast_expr_sub(
10194                 __isl_take isl_ast_expr *expr1,
10195                 __isl_take isl_ast_expr *expr2);
10196         __isl_give isl_ast_expr *isl_ast_expr_mul(
10197                 __isl_take isl_ast_expr *expr1,
10198                 __isl_take isl_ast_expr *expr2);
10199         __isl_give isl_ast_expr *isl_ast_expr_div(
10200                 __isl_take isl_ast_expr *expr1,
10201                 __isl_take isl_ast_expr *expr2);
10202         __isl_give isl_ast_expr *isl_ast_expr_pdiv_q(
10203                 __isl_take isl_ast_expr *expr1,
10204                 __isl_take isl_ast_expr *expr2);
10205         __isl_give isl_ast_expr *isl_ast_expr_pdiv_r(
10206                 __isl_take isl_ast_expr *expr1,
10207                 __isl_take isl_ast_expr *expr2);
10208         __isl_give isl_ast_expr *isl_ast_expr_and(
10209                 __isl_take isl_ast_expr *expr1,
10210                 __isl_take isl_ast_expr *expr2)
10211         __isl_give isl_ast_expr *isl_ast_expr_and_then(
10212                 __isl_take isl_ast_expr *expr1,
10213                 __isl_take isl_ast_expr *expr2)
10214         __isl_give isl_ast_expr *isl_ast_expr_or(
10215                 __isl_take isl_ast_expr *expr1,
10216                 __isl_take isl_ast_expr *expr2)
10217         __isl_give isl_ast_expr *isl_ast_expr_or_else(
10218                 __isl_take isl_ast_expr *expr1,
10219                 __isl_take isl_ast_expr *expr2)
10220         __isl_give isl_ast_expr *isl_ast_expr_eq(
10221                 __isl_take isl_ast_expr *expr1,
10222                 __isl_take isl_ast_expr *expr2);
10223         __isl_give isl_ast_expr *isl_ast_expr_le(
10224                 __isl_take isl_ast_expr *expr1,
10225                 __isl_take isl_ast_expr *expr2);
10226         __isl_give isl_ast_expr *isl_ast_expr_lt(
10227                 __isl_take isl_ast_expr *expr1,
10228                 __isl_take isl_ast_expr *expr2);
10229         __isl_give isl_ast_expr *isl_ast_expr_ge(
10230                 __isl_take isl_ast_expr *expr1,
10231                 __isl_take isl_ast_expr *expr2);
10232         __isl_give isl_ast_expr *isl_ast_expr_gt(
10233                 __isl_take isl_ast_expr *expr1,
10234                 __isl_take isl_ast_expr *expr2);
10235         __isl_give isl_ast_expr *isl_ast_expr_access(
10236                 __isl_take isl_ast_expr *array,
10237                 __isl_take isl_ast_expr_list *indices);
10238         __isl_give isl_ast_expr *isl_ast_expr_call(
10239                 __isl_take isl_ast_expr *function,
10240                 __isl_take isl_ast_expr_list *arguments);
10242 The function C<isl_ast_expr_address_of> can be applied to an
10243 C<isl_ast_expr> of type C<isl_ast_op_access> only. It is meant
10244 to represent the address of the C<isl_ast_expr_access>.
10245 The second argument of the functions C<isl_ast_expr_pdiv_q> and
10246 C<isl_ast_expr_pdiv_r> should always evaluate to a positive number.
10247 The function
10248 C<isl_ast_expr_and_then> as well as C<isl_ast_expr_or_else> are short-circuit
10249 versions of C<isl_ast_expr_and> and C<isl_ast_expr_or>, respectively.
10251         #include <isl/ast_build.h>
10252         __isl_give isl_ast_expr *isl_ast_build_expr_from_set(
10253                 __isl_keep isl_ast_build *build,
10254                 __isl_take isl_set *set);
10255         __isl_give isl_ast_expr *isl_ast_build_expr_from_pw_aff(
10256                 __isl_keep isl_ast_build *build,
10257                 __isl_take isl_pw_aff *pa);
10258         __isl_give isl_ast_expr *
10259         isl_ast_build_access_from_pw_multi_aff(
10260                 __isl_keep isl_ast_build *build,
10261                 __isl_take isl_pw_multi_aff *pma);
10262         __isl_give isl_ast_expr *
10263         isl_ast_build_access_from_multi_pw_aff(
10264                 __isl_keep isl_ast_build *build,
10265                 __isl_take isl_multi_pw_aff *mpa);
10266         __isl_give isl_ast_expr *
10267         isl_ast_build_call_from_pw_multi_aff(
10268                 __isl_keep isl_ast_build *build,
10269                 __isl_take isl_pw_multi_aff *pma);
10270         __isl_give isl_ast_expr *
10271         isl_ast_build_call_from_multi_pw_aff(
10272                 __isl_keep isl_ast_build *build,
10273                 __isl_take isl_multi_pw_aff *mpa);
10275 The set C<set> and
10276 the domains of C<pa>, C<mpa> and C<pma> should correspond
10277 to the schedule space of C<build>.
10278 The tuple id of C<mpa> or C<pma> is used as the array being accessed or
10279 the function being called.
10280 If the accessed space is a nested relation, then it is taken
10281 to represent an access of the member specified by the range
10282 of this nested relation of the structure specified by the domain
10283 of the nested relation.
10285 The following functions can be used to modify an C<isl_ast_expr>.
10287         #include <isl/ast.h>
10288         __isl_give isl_ast_expr *isl_ast_expr_set_op_arg(
10289                 __isl_take isl_ast_expr *expr, int pos,
10290                 __isl_take isl_ast_expr *arg);
10292 Replace the argument of C<expr> at position C<pos> by C<arg>.
10294         #include <isl/ast.h>
10295         __isl_give isl_ast_expr *isl_ast_expr_substitute_ids(
10296                 __isl_take isl_ast_expr *expr,
10297                 __isl_take isl_id_to_ast_expr *id2expr);
10299 The function C<isl_ast_expr_substitute_ids> replaces the
10300 subexpressions of C<expr> of type C<isl_ast_expr_id>
10301 by the corresponding expression in C<id2expr>, if there is any.
10304 User specified data can be attached to an C<isl_ast_node> and obtained
10305 from the same C<isl_ast_node> using the following functions.
10307         #include <isl/ast.h>
10308         __isl_give isl_ast_node *isl_ast_node_set_annotation(
10309                 __isl_take isl_ast_node *node,
10310                 __isl_take isl_id *annotation);
10311         __isl_give isl_id *isl_ast_node_get_annotation(
10312                 __isl_keep isl_ast_node *node);
10314 Basic printing can be performed using the following functions.
10316         #include <isl/ast.h>
10317         __isl_give isl_printer *isl_printer_print_ast_expr(
10318                 __isl_take isl_printer *p,
10319                 __isl_keep isl_ast_expr *expr);
10320         __isl_give isl_printer *isl_printer_print_ast_node(
10321                 __isl_take isl_printer *p,
10322                 __isl_keep isl_ast_node *node);
10323         __isl_give char *isl_ast_expr_to_str(
10324                 __isl_keep isl_ast_expr *expr);
10325         __isl_give char *isl_ast_node_to_str(
10326                 __isl_keep isl_ast_node *node);
10327         __isl_give char *isl_ast_expr_to_C_str(
10328                 __isl_keep isl_ast_expr *expr);
10329         __isl_give char *isl_ast_node_to_C_str(
10330                 __isl_keep isl_ast_node *node);
10332 The functions C<isl_ast_expr_to_C_str> and
10333 C<isl_ast_node_to_C_str> are convenience functions
10334 that return a string representation of the input in C format.
10336 More advanced printing can be performed using the following functions.
10338         #include <isl/ast.h>
10339         __isl_give isl_printer *isl_ast_op_type_set_print_name(
10340                 __isl_take isl_printer *p,
10341                 enum isl_ast_op_type type,
10342                 __isl_keep const char *name);
10343         isl_stat isl_options_set_ast_print_macro_once(
10344                 isl_ctx *ctx, int val);
10345         int isl_options_get_ast_print_macro_once(isl_ctx *ctx);
10346         __isl_give isl_printer *isl_ast_op_type_print_macro(
10347                 enum isl_ast_op_type type,
10348                 __isl_take isl_printer *p);
10349         __isl_give isl_printer *isl_ast_expr_print_macros(
10350                 __isl_keep isl_ast_expr *expr,
10351                 __isl_take isl_printer *p);
10352         __isl_give isl_printer *isl_ast_node_print_macros(
10353                 __isl_keep isl_ast_node *node,
10354                 __isl_take isl_printer *p);
10355         __isl_give isl_printer *isl_ast_node_print(
10356                 __isl_keep isl_ast_node *node,
10357                 __isl_take isl_printer *p,
10358                 __isl_take isl_ast_print_options *options);
10359         __isl_give isl_printer *isl_ast_node_for_print(
10360                 __isl_keep isl_ast_node *node,
10361                 __isl_take isl_printer *p,
10362                 __isl_take isl_ast_print_options *options);
10363         __isl_give isl_printer *isl_ast_node_if_print(
10364                 __isl_keep isl_ast_node *node,
10365                 __isl_take isl_printer *p,
10366                 __isl_take isl_ast_print_options *options);
10368 While printing an C<isl_ast_node> in C<ISL_FORMAT_C>,
10369 C<isl> may print out an AST that makes use of macros such
10370 as C<floord>, C<min> and C<max>.
10371 The names of these macros may be modified by a call
10372 to C<isl_ast_op_type_set_print_name>.  The user-specified
10373 names are associated to the printer object.
10374 C<isl_ast_op_type_print_macro> prints out the macro
10375 corresponding to a specific C<isl_ast_op_type>.
10376 If the print-macro-once option is set, then a given macro definition
10377 is only printed once to any given printer object.
10378 C<isl_ast_expr_print_macros> scans the C<isl_ast_expr>
10379 for subexpressions where these macros would be used and prints
10380 out the required macro definitions.
10381 Essentially, C<isl_ast_expr_print_macros> calls
10382 C<isl_ast_expr_foreach_ast_op_type> with C<isl_ast_op_type_print_macro>
10383 as function argument.
10384 C<isl_ast_node_print_macros> does the same
10385 for expressions in its C<isl_ast_node> argument.
10386 C<isl_ast_node_print>, C<isl_ast_node_for_print> and
10387 C<isl_ast_node_if_print> print an C<isl_ast_node>
10388 in C<ISL_FORMAT_C>, but allow for some extra control
10389 through an C<isl_ast_print_options> object.
10390 This object can be created using the following functions.
10392         #include <isl/ast.h>
10393         __isl_give isl_ast_print_options *
10394         isl_ast_print_options_alloc(isl_ctx *ctx);
10395         __isl_give isl_ast_print_options *
10396         isl_ast_print_options_copy(
10397                 __isl_keep isl_ast_print_options *options);
10398         __isl_null isl_ast_print_options *
10399         isl_ast_print_options_free(
10400                 __isl_take isl_ast_print_options *options);
10402         __isl_give isl_ast_print_options *
10403         isl_ast_print_options_set_print_user(
10404                 __isl_take isl_ast_print_options *options,
10405                 __isl_give isl_printer *(*print_user)(
10406                         __isl_take isl_printer *p,
10407                         __isl_take isl_ast_print_options *options,
10408                         __isl_keep isl_ast_node *node, void *user),
10409                 void *user);
10410         __isl_give isl_ast_print_options *
10411         isl_ast_print_options_set_print_for(
10412                 __isl_take isl_ast_print_options *options,
10413                 __isl_give isl_printer *(*print_for)(
10414                         __isl_take isl_printer *p,
10415                         __isl_take isl_ast_print_options *options,
10416                         __isl_keep isl_ast_node *node, void *user),
10417                 void *user);
10419 The callback set by C<isl_ast_print_options_set_print_user>
10420 is called whenever a node of type C<isl_ast_node_user> needs to
10421 be printed.
10422 The callback set by C<isl_ast_print_options_set_print_for>
10423 is called whenever a node of type C<isl_ast_node_for> needs to
10424 be printed.
10425 Note that C<isl_ast_node_for_print> will I<not> call the
10426 callback set by C<isl_ast_print_options_set_print_for> on the node
10427 on which C<isl_ast_node_for_print> is called, but only on nested
10428 nodes of type C<isl_ast_node_for>.  It is therefore safe to
10429 call C<isl_ast_node_for_print> from within the callback set by
10430 C<isl_ast_print_options_set_print_for>.
10432 The following option determines the type to be used for iterators
10433 while printing the AST.
10435         isl_stat isl_options_set_ast_iterator_type(
10436                 isl_ctx *ctx, const char *val);
10437         const char *isl_options_get_ast_iterator_type(
10438                 isl_ctx *ctx);
10440 The AST printer only prints body nodes as blocks if these
10441 blocks cannot be safely omitted.
10442 For example, a C<for> node with one body node will not be
10443 surrounded with braces in C<ISL_FORMAT_C>.
10444 A block will always be printed by setting the following option.
10446         isl_stat isl_options_set_ast_always_print_block(isl_ctx *ctx,
10447                 int val);
10448         int isl_options_get_ast_always_print_block(isl_ctx *ctx);
10450 =head3 Options
10452         #include <isl/ast_build.h>
10453         isl_stat isl_options_set_ast_build_atomic_upper_bound(
10454                 isl_ctx *ctx, int val);
10455         int isl_options_get_ast_build_atomic_upper_bound(
10456                 isl_ctx *ctx);
10457         isl_stat isl_options_set_ast_build_prefer_pdiv(isl_ctx *ctx,
10458                 int val);
10459         int isl_options_get_ast_build_prefer_pdiv(isl_ctx *ctx);
10460         isl_stat isl_options_set_ast_build_detect_min_max(
10461                 isl_ctx *ctx, int val);
10462         int isl_options_get_ast_build_detect_min_max(
10463                 isl_ctx *ctx);
10464         isl_stat isl_options_set_ast_build_exploit_nested_bounds(
10465                 isl_ctx *ctx, int val);
10466         int isl_options_get_ast_build_exploit_nested_bounds(
10467                 isl_ctx *ctx);
10468         isl_stat isl_options_set_ast_build_group_coscheduled(
10469                 isl_ctx *ctx, int val);
10470         int isl_options_get_ast_build_group_coscheduled(
10471                 isl_ctx *ctx);
10472         isl_stat isl_options_set_ast_build_separation_bounds(
10473                 isl_ctx *ctx, int val);
10474         int isl_options_get_ast_build_separation_bounds(
10475                 isl_ctx *ctx);
10476         isl_stat isl_options_set_ast_build_scale_strides(
10477                 isl_ctx *ctx, int val);
10478         int isl_options_get_ast_build_scale_strides(
10479                 isl_ctx *ctx);
10480         isl_stat isl_options_set_ast_build_allow_else(isl_ctx *ctx,
10481                 int val);
10482         int isl_options_get_ast_build_allow_else(isl_ctx *ctx);
10483         isl_stat isl_options_set_ast_build_allow_or(isl_ctx *ctx,
10484                 int val);
10485         int isl_options_get_ast_build_allow_or(isl_ctx *ctx);
10487 =over
10489 =item * ast_build_atomic_upper_bound
10491 Generate loop upper bounds that consist of the current loop iterator,
10492 an operator and an expression not involving the iterator.
10493 If this option is not set, then the current loop iterator may appear
10494 several times in the upper bound.
10495 For example, when this option is turned off, AST generation
10496 for the schedule
10498         [n] -> { A[i] -> [i] : 0 <= i <= 100, n }
10500 produces
10502         for (int c0 = 0; c0 <= 100 && n >= c0; c0 += 1)
10503           A(c0);
10505 When the option is turned on, the following AST is generated
10507         for (int c0 = 0; c0 <= min(100, n); c0 += 1)
10508           A(c0);
10510 =item * ast_build_prefer_pdiv
10512 If this option is turned off, then the AST generation will
10513 produce ASTs that may only contain C<isl_ast_op_fdiv_q>
10514 operators, but no C<isl_ast_op_pdiv_q> or
10515 C<isl_ast_op_pdiv_r> operators.
10516 If this option is turned on, then C<isl> will try to convert
10517 some of the C<isl_ast_op_fdiv_q> operators to (expressions containing)
10518 C<isl_ast_op_pdiv_q> or C<isl_ast_op_pdiv_r> operators.
10520 =item * ast_build_detect_min_max
10522 If this option is turned on, then C<isl> will try and detect
10523 min or max-expressions when building AST expressions from
10524 piecewise affine expressions.
10526 =item * ast_build_exploit_nested_bounds
10528 Simplify conditions based on bounds of nested for loops.
10529 In particular, remove conditions that are implied by the fact
10530 that one or more nested loops have at least one iteration,
10531 meaning that the upper bound is at least as large as the lower bound.
10532 For example, when this option is turned off, AST generation
10533 for the schedule
10535         [N,M] -> { A[i,j] -> [i,j] : 0 <= i <= N and
10536                                         0 <= j <= M }
10538 produces
10540         if (M >= 0)
10541           for (int c0 = 0; c0 <= N; c0 += 1)
10542             for (int c1 = 0; c1 <= M; c1 += 1)
10543               A(c0, c1);
10545 When the option is turned on, the following AST is generated
10547         for (int c0 = 0; c0 <= N; c0 += 1)
10548           for (int c1 = 0; c1 <= M; c1 += 1)
10549             A(c0, c1);
10551 =item * ast_build_group_coscheduled
10553 If two domain elements are assigned the same schedule point, then
10554 they may be executed in any order and they may even appear in different
10555 loops.  If this options is set, then the AST generator will make
10556 sure that coscheduled domain elements do not appear in separate parts
10557 of the AST.  This is useful in case of nested AST generation
10558 if the outer AST generation is given only part of a schedule
10559 and the inner AST generation should handle the domains that are
10560 coscheduled by this initial part of the schedule together.
10561 For example if an AST is generated for a schedule
10563         { A[i] -> [0]; B[i] -> [0] }
10565 then the C<isl_ast_build_set_create_leaf> callback described
10566 below may get called twice, once for each domain.
10567 Setting this option ensures that the callback is only called once
10568 on both domains together.
10570 =item * ast_build_separation_bounds
10572 This option specifies which bounds to use during separation.
10573 If this option is set to C<ISL_AST_BUILD_SEPARATION_BOUNDS_IMPLICIT>
10574 then all (possibly implicit) bounds on the current dimension will
10575 be used during separation.
10576 If this option is set to C<ISL_AST_BUILD_SEPARATION_BOUNDS_EXPLICIT>
10577 then only those bounds that are explicitly available will
10578 be used during separation.
10580 =item * ast_build_scale_strides
10582 This option specifies whether the AST generator is allowed
10583 to scale down iterators of strided loops.
10585 =item * ast_build_allow_else
10587 This option specifies whether the AST generator is allowed
10588 to construct if statements with else branches.
10590 =item * ast_build_allow_or
10592 This option specifies whether the AST generator is allowed
10593 to construct if conditions with disjunctions.
10595 =back
10597 =head3 AST Generation Options (Schedule Tree)
10599 In case of AST construction from a schedule tree, the options
10600 that control how an AST is created from the individual schedule
10601 dimensions are stored in the band nodes of the tree
10602 (see L</"Schedule Trees">).
10604 In particular, a schedule dimension can be handled in four
10605 different ways, atomic, separate, unroll or the default.
10606 This loop AST generation type can be set using
10607 C<isl_schedule_node_band_member_set_ast_loop_type>.
10608 Alternatively,
10609 the first three can be selected by including a one-dimensional
10610 element with as value the position of the schedule dimension
10611 within the band and as name one of C<atomic>, C<separate>
10612 or C<unroll> in the options
10613 set by C<isl_schedule_node_band_set_ast_build_options>.
10614 Only one of these three may be specified for
10615 any given schedule dimension within a band node.
10616 If none of these is specified, then the default
10617 is used.  The meaning of the options is as follows.
10619 =over
10621 =item C<atomic>
10623 When this option is specified, the AST generator will make
10624 sure that a given domains space only appears in a single
10625 loop at the specified level.
10627 For example, for the schedule tree
10629         domain: "{ a[i] : 0 <= i < 10; b[i] : 0 <= i < 10 }"
10630         child:
10631           schedule: "[{ a[i] -> [i]; b[i] -> [i+1] }]"
10632           options: "{ atomic[x] }"
10634 the following AST will be generated
10636         for (int c0 = 0; c0 <= 10; c0 += 1) {
10637           if (c0 >= 1)
10638             b(c0 - 1);
10639           if (c0 <= 9)
10640             a(c0);
10641         }
10643 On the other hand, for the schedule tree
10645         domain: "{ a[i] : 0 <= i < 10; b[i] : 0 <= i < 10 }"
10646         child:
10647           schedule: "[{ a[i] -> [i]; b[i] -> [i+1] }]"
10648           options: "{ separate[x] }"
10650 the following AST will be generated
10652         {
10653           a(0);
10654           for (int c0 = 1; c0 <= 9; c0 += 1) {
10655             b(c0 - 1);
10656             a(c0);
10657           }
10658           b(9);
10659         }
10661 If neither C<atomic> nor C<separate> is specified, then the AST generator
10662 may produce either of these two results or some intermediate form.
10664 =item C<separate>
10666 When this option is specified, the AST generator will
10667 split the domain of the specified schedule dimension
10668 into pieces with a fixed set of statements for which
10669 instances need to be executed by the iterations in
10670 the schedule domain part.  This option tends to avoid
10671 the generation of guards inside the corresponding loops.
10672 See also the C<atomic> option.
10674 =item C<unroll>
10676 When this option is specified, the AST generator will
10677 I<completely> unroll the corresponding schedule dimension.
10678 It is the responsibility of the user to ensure that such
10679 unrolling is possible.
10680 To obtain a partial unrolling, the user should apply an additional
10681 strip-mining to the schedule and fully unroll the inner schedule
10682 dimension.
10684 =back
10686 The C<isolate> option is a bit more involved.  It allows the user
10687 to isolate a range of schedule dimension values from smaller and
10688 greater values.  Additionally, the user may specify a different
10689 atomic/separate/unroll choice for the isolated part and the remaining
10690 parts.  The typical use case of the C<isolate> option is to isolate
10691 full tiles from partial tiles.
10692 The part that needs to be isolated may depend on outer schedule dimensions.
10693 The option therefore needs to be able to reference those outer schedule
10694 dimensions.  In particular, the space of the C<isolate> option is that
10695 of a wrapped map with as domain the flat product of all outer band nodes
10696 and as range the space of the current band node.
10697 The atomic/separate/unroll choice for the isolated part is determined
10698 by an option that lives in an unnamed wrapped space with as domain
10699 a zero-dimensional C<isolate> space and as range the regular
10700 C<atomic>, C<separate> or C<unroll> space.
10701 This option may also be set directly using
10702 C<isl_schedule_node_band_member_set_isolate_ast_loop_type>.
10703 The atomic/separate/unroll choice for the remaining part is determined
10704 by the regular C<atomic>, C<separate> or C<unroll> option.
10705 Since the C<isolate> option references outer schedule dimensions,
10706 its use in a band node causes any tree containing the node
10707 to be considered anchored.
10709 As an example, consider the isolation of full tiles from partial tiles
10710 in a tiling of a triangular domain.  The original schedule is as follows.
10712         domain: "{ A[i,j] : 0 <= i,j and i + j <= 100 }"
10713         child:
10714           schedule: "[{ A[i,j] -> [floor(i/10)] }, \
10715                 { A[i,j] -> [floor(j/10)] }, \
10716                 { A[i,j] -> [i] }, { A[i,j] -> [j] }]"
10718 The output is
10720         for (int c0 = 0; c0 <= 10; c0 += 1)
10721           for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
10722             for (int c2 = 10 * c0;
10723                  c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
10724               for (int c3 = 10 * c1;
10725                    c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
10726                 A(c2, c3);
10728 Isolating the full tiles, we have the following input
10730         domain: "{ A[i,j] : 0 <= i,j and i + j <= 100 }"
10731         child:
10732           schedule: "[{ A[i,j] -> [floor(i/10)] }, \
10733                 { A[i,j] -> [floor(j/10)] }, \
10734                 { A[i,j] -> [i] }, { A[i,j] -> [j] }]"
10735           options: "{ isolate[[] -> [a,b,c,d]] : 0 <= 10a,10b and \
10736                 10a+9+10b+9 <= 100 }"
10738 and output
10740         {
10741           for (int c0 = 0; c0 <= 8; c0 += 1) {
10742             for (int c1 = 0; c1 <= -c0 + 8; c1 += 1)
10743               for (int c2 = 10 * c0;
10744                    c2 <= 10 * c0 + 9; c2 += 1)
10745                 for (int c3 = 10 * c1;
10746                      c3 <= 10 * c1 + 9; c3 += 1)
10747                   A(c2, c3);
10748             for (int c1 = -c0 + 9; c1 <= -c0 + 10; c1 += 1)
10749               for (int c2 = 10 * c0;
10750                    c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
10751                 for (int c3 = 10 * c1;
10752                      c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
10753                   A(c2, c3);
10754           }
10755           for (int c0 = 9; c0 <= 10; c0 += 1)
10756             for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
10757               for (int c2 = 10 * c0;
10758                    c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
10759                 for (int c3 = 10 * c1;
10760                      c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
10761                   A(c2, c3);
10762         }
10764 We may then additionally unroll the innermost loop of the isolated part
10766         domain: "{ A[i,j] : 0 <= i,j and i + j <= 100 }"
10767         child:
10768           schedule: "[{ A[i,j] -> [floor(i/10)] }, \
10769                 { A[i,j] -> [floor(j/10)] }, \
10770                 { A[i,j] -> [i] }, { A[i,j] -> [j] }]"
10771           options: "{ isolate[[] -> [a,b,c,d]] : 0 <= 10a,10b and \
10772                 10a+9+10b+9 <= 100; [isolate[] -> unroll[3]] }"
10774 to obtain
10776         {
10777           for (int c0 = 0; c0 <= 8; c0 += 1) {
10778             for (int c1 = 0; c1 <= -c0 + 8; c1 += 1)
10779               for (int c2 = 10 * c0; c2 <= 10 * c0 + 9; c2 += 1) {
10780                 A(c2, 10 * c1);
10781                 A(c2, 10 * c1 + 1);
10782                 A(c2, 10 * c1 + 2);
10783                 A(c2, 10 * c1 + 3);
10784                 A(c2, 10 * c1 + 4);
10785                 A(c2, 10 * c1 + 5);
10786                 A(c2, 10 * c1 + 6);
10787                 A(c2, 10 * c1 + 7);
10788                 A(c2, 10 * c1 + 8);
10789                 A(c2, 10 * c1 + 9);
10790               }
10791             for (int c1 = -c0 + 9; c1 <= -c0 + 10; c1 += 1)
10792               for (int c2 = 10 * c0;
10793                    c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
10794                 for (int c3 = 10 * c1;
10795                      c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
10796                   A(c2, c3);
10797           }
10798           for (int c0 = 9; c0 <= 10; c0 += 1)
10799             for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
10800               for (int c2 = 10 * c0;
10801                    c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
10802                 for (int c3 = 10 * c1;
10803                      c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
10804                   A(c2, c3);
10805         }
10808 =head3 AST Generation Options (Schedule Map)
10810 In case of AST construction using
10811 C<isl_ast_build_node_from_schedule_map>, the options
10812 that control how an AST is created from the individual schedule
10813 dimensions are stored in the C<isl_ast_build>.
10814 They can be set using the following function.
10816         #include <isl/ast_build.h>
10817         __isl_give isl_ast_build *
10818         isl_ast_build_set_options(
10819                 __isl_take isl_ast_build *build,
10820                 __isl_take isl_union_map *options);
10822 The options are encoded in an C<isl_union_map>.
10823 The domain of this union relation refers to the schedule domain,
10824 i.e., the range of the schedule passed
10825 to C<isl_ast_build_node_from_schedule_map>.
10826 In the case of nested AST generation (see L</"Nested AST Generation">),
10827 the domain of C<options> should refer to the extra piece of the schedule.
10828 That is, it should be equal to the range of the wrapped relation in the
10829 range of the schedule.
10830 The range of the options can consist of elements in one or more spaces,
10831 the names of which determine the effect of the option.
10832 The values of the range typically also refer to the schedule dimension
10833 to which the option applies, with value C<0> representing
10834 the outermost schedule dimension.  In case of nested AST generation
10835 (see L</"Nested AST Generation">), these values refer to the position
10836 of the schedule dimension within the innermost AST generation.
10837 The constraints on the domain elements of
10838 the option should only refer to this dimension and earlier dimensions.
10839 We consider the following spaces.
10841 =over
10843 =item C<separation_class>
10845 B<This option has been deprecated.  Use the isolate option on
10846 schedule trees instead.>
10848 This space is a wrapped relation between two one dimensional spaces.
10849 The input space represents the schedule dimension to which the option
10850 applies and the output space represents the separation class.
10851 While constructing a loop corresponding to the specified schedule
10852 dimension(s), the AST generator will try to generate separate loops
10853 for domain elements that are assigned different classes.
10854 If only some of the elements are assigned a class, then those elements
10855 that are not assigned any class will be treated as belonging to a class
10856 that is separate from the explicitly assigned classes.
10857 The typical use case for this option is to separate full tiles from
10858 partial tiles.
10859 The other options, described below, are applied after the separation
10860 into classes.
10862 As an example, consider the separation into full and partial tiles
10863 of a tiling of a triangular domain.
10864 Take, for example, the domain
10866         { A[i,j] : 0 <= i,j and i + j <= 100 }
10868 and a tiling into tiles of 10 by 10.  The input to the AST generator
10869 is then the schedule
10871         { A[i,j] -> [([i/10]),[j/10],i,j] : 0 <= i,j and
10872                                                 i + j <= 100 }
10874 Without any options, the following AST is generated
10876         for (int c0 = 0; c0 <= 10; c0 += 1)
10877           for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
10878             for (int c2 = 10 * c0;
10879                  c2 <= min(-10 * c1 + 100, 10 * c0 + 9);
10880                  c2 += 1)
10881               for (int c3 = 10 * c1;
10882                    c3 <= min(10 * c1 + 9, -c2 + 100);
10883                    c3 += 1)
10884                 A(c2, c3);
10886 Separation into full and partial tiles can be obtained by assigning
10887 a class, say C<0>, to the full tiles.  The full tiles are represented by those
10888 values of the first and second schedule dimensions for which there are
10889 values of the third and fourth dimensions to cover an entire tile.
10890 That is, we need to specify the following option
10892         { [a,b,c,d] -> separation_class[[0]->[0]] :
10893                 exists b': 0 <= 10a,10b' and
10894                            10a+9+10b'+9 <= 100;
10895           [a,b,c,d] -> separation_class[[1]->[0]] :
10896                 0 <= 10a,10b and 10a+9+10b+9 <= 100 }
10898 which simplifies to
10900         { [a, b, c, d] -> separation_class[[1] -> [0]] :
10901                 a >= 0 and b >= 0 and b <= 8 - a;
10902           [a, b, c, d] -> separation_class[[0] -> [0]] :
10903                 a >= 0 and a <= 8 }
10905 With this option, the generated AST is as follows
10907         {
10908           for (int c0 = 0; c0 <= 8; c0 += 1) {
10909             for (int c1 = 0; c1 <= -c0 + 8; c1 += 1)
10910               for (int c2 = 10 * c0;
10911                    c2 <= 10 * c0 + 9; c2 += 1)
10912                 for (int c3 = 10 * c1;
10913                      c3 <= 10 * c1 + 9; c3 += 1)
10914                   A(c2, c3);
10915             for (int c1 = -c0 + 9; c1 <= -c0 + 10; c1 += 1)
10916               for (int c2 = 10 * c0;
10917                    c2 <= min(-10 * c1 + 100, 10 * c0 + 9);
10918                    c2 += 1)
10919                 for (int c3 = 10 * c1;
10920                      c3 <= min(-c2 + 100, 10 * c1 + 9);
10921                      c3 += 1)
10922                   A(c2, c3);
10923           }
10924           for (int c0 = 9; c0 <= 10; c0 += 1)
10925             for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
10926               for (int c2 = 10 * c0;
10927                    c2 <= min(-10 * c1 + 100, 10 * c0 + 9);
10928                    c2 += 1)
10929                 for (int c3 = 10 * c1;
10930                      c3 <= min(10 * c1 + 9, -c2 + 100);
10931                      c3 += 1)
10932                   A(c2, c3);
10933         }
10935 =item C<separate>
10937 This is a single-dimensional space representing the schedule dimension(s)
10938 to which ``separation'' should be applied.  Separation tries to split
10939 a loop into several pieces if this can avoid the generation of guards
10940 inside the loop.
10941 See also the C<atomic> option.
10943 =item C<atomic>
10945 This is a single-dimensional space representing the schedule dimension(s)
10946 for which the domains should be considered ``atomic''.  That is, the
10947 AST generator will make sure that any given domain space will only appear
10948 in a single loop at the specified level.
10950 Consider the following schedule
10952         { a[i] -> [i] : 0 <= i < 10;
10953           b[i] -> [i+1] : 0 <= i < 10 }
10955 If the following option is specified
10957         { [i] -> separate[x] }
10959 then the following AST will be generated
10961         {
10962           a(0);
10963           for (int c0 = 1; c0 <= 9; c0 += 1) {
10964             a(c0);
10965             b(c0 - 1);
10966           }
10967           b(9);
10968         }
10970 If, on the other hand, the following option is specified
10972         { [i] -> atomic[x] }
10974 then the following AST will be generated
10976         for (int c0 = 0; c0 <= 10; c0 += 1) {
10977           if (c0 <= 9)
10978             a(c0);
10979           if (c0 >= 1)
10980             b(c0 - 1);
10981         }
10983 If neither C<atomic> nor C<separate> is specified, then the AST generator
10984 may produce either of these two results or some intermediate form.
10986 =item C<unroll>
10988 This is a single-dimensional space representing the schedule dimension(s)
10989 that should be I<completely> unrolled.
10990 To obtain a partial unrolling, the user should apply an additional
10991 strip-mining to the schedule and fully unroll the inner loop.
10993 =back
10995 =head3 Fine-grained Control over AST Generation
10997 Besides specifying the constraints on the parameters,
10998 an C<isl_ast_build> object can be used to control
10999 various aspects of the AST generation process.
11000 In case of AST construction using
11001 C<isl_ast_build_node_from_schedule_map>,
11002 the most prominent way of control is through ``options'',
11003 as explained above.
11005 Additional control is available through the following functions.
11007         #include <isl/ast_build.h>
11008         __isl_give isl_ast_build *
11009         isl_ast_build_set_iterators(
11010                 __isl_take isl_ast_build *build,
11011                 __isl_take isl_id_list *iterators);
11013 The function C<isl_ast_build_set_iterators> allows the user to
11014 specify a list of iterator C<isl_id>s to be used as iterators.
11015 If the input schedule is injective, then
11016 the number of elements in this list should be as large as the dimension
11017 of the schedule space, but no direct correspondence should be assumed
11018 between dimensions and elements.
11019 If the input schedule is not injective, then an additional number
11020 of C<isl_id>s equal to the largest dimension of the input domains
11021 may be required.
11022 If the number of provided C<isl_id>s is insufficient, then additional
11023 names are automatically generated.
11025         #include <isl/ast_build.h>
11026         __isl_give isl_ast_build *
11027         isl_ast_build_set_create_leaf(
11028                 __isl_take isl_ast_build *build,
11029                 __isl_give isl_ast_node *(*fn)(
11030                         __isl_take isl_ast_build *build,
11031                         void *user), void *user);
11034 C<isl_ast_build_set_create_leaf> function allows for the
11035 specification of a callback that should be called whenever the AST
11036 generator arrives at an element of the schedule domain.
11037 The callback should return an AST node that should be inserted
11038 at the corresponding position of the AST.  The default action (when
11039 the callback is not set) is to continue generating parts of the AST to scan
11040 all the domain elements associated to the schedule domain element
11041 and to insert user nodes, ``calling'' the domain element, for each of them.
11042 The C<build> argument contains the current state of the C<isl_ast_build>.
11043 To ease nested AST generation (see L</"Nested AST Generation">),
11044 all control information that is
11045 specific to the current AST generation such as the options and
11046 the callbacks has been removed from this C<isl_ast_build>.
11047 The callback would typically return the result of a nested
11048 AST generation or a
11049 user defined node created using the following function.
11051         #include <isl/ast.h>
11052         __isl_give isl_ast_node *isl_ast_node_alloc_user(
11053                 __isl_take isl_ast_expr *expr);
11055         #include <isl/ast_build.h>
11056         __isl_give isl_ast_build *
11057         isl_ast_build_set_at_each_domain(
11058                 __isl_take isl_ast_build *build,
11059                 __isl_give isl_ast_node *(*fn)(
11060                         __isl_take isl_ast_node *node,
11061                         __isl_keep isl_ast_build *build,
11062                         void *user), void *user);
11063         __isl_give isl_ast_build *
11064         isl_ast_build_set_before_each_for(
11065                 __isl_take isl_ast_build *build,
11066                 __isl_give isl_id *(*fn)(
11067                         __isl_keep isl_ast_build *build,
11068                         void *user), void *user);
11069         __isl_give isl_ast_build *
11070         isl_ast_build_set_after_each_for(
11071                 __isl_take isl_ast_build *build,
11072                 __isl_give isl_ast_node *(*fn)(
11073                         __isl_take isl_ast_node *node,
11074                         __isl_keep isl_ast_build *build,
11075                         void *user), void *user);
11076         __isl_give isl_ast_build *
11077         isl_ast_build_set_before_each_mark(
11078                 __isl_take isl_ast_build *build,
11079                 isl_stat (*fn)(__isl_keep isl_id *mark,
11080                         __isl_keep isl_ast_build *build,
11081                         void *user), void *user);
11082         __isl_give isl_ast_build *
11083         isl_ast_build_set_after_each_mark(
11084                 __isl_take isl_ast_build *build,
11085                 __isl_give isl_ast_node *(*fn)(
11086                         __isl_take isl_ast_node *node,
11087                         __isl_keep isl_ast_build *build,
11088                         void *user), void *user);
11090 The callback set by C<isl_ast_build_set_at_each_domain> will
11091 be called for each domain AST node.
11092 The callbacks set by C<isl_ast_build_set_before_each_for>
11093 and C<isl_ast_build_set_after_each_for> will be called
11094 for each for AST node.  The first will be called in depth-first
11095 pre-order, while the second will be called in depth-first post-order.
11096 Since C<isl_ast_build_set_before_each_for> is called before the for
11097 node is actually constructed, it is only passed an C<isl_ast_build>.
11098 The returned C<isl_id> will be added as an annotation (using
11099 C<isl_ast_node_set_annotation>) to the constructed for node.
11100 In particular, if the user has also specified an C<after_each_for>
11101 callback, then the annotation can be retrieved from the node passed to
11102 that callback using C<isl_ast_node_get_annotation>.
11103 The callbacks set by C<isl_ast_build_set_before_each_mark>
11104 and C<isl_ast_build_set_after_each_mark> will be called for each
11105 mark AST node that is created, i.e., for each mark schedule node
11106 in the input schedule tree.  The first will be called in depth-first
11107 pre-order, while the second will be called in depth-first post-order.
11108 Since the callback set by C<isl_ast_build_set_before_each_mark>
11109 is called before the mark AST node is actually constructed, it is passed
11110 the identifier of the mark node.
11111 All callbacks should C<NULL> (or C<isl_stat_error>) on failure.
11112 The given C<isl_ast_build> can be used to create new
11113 C<isl_ast_expr> objects using C<isl_ast_build_expr_from_pw_aff>
11114 or C<isl_ast_build_call_from_pw_multi_aff>.
11116 =head3 Nested AST Generation
11118 C<isl> allows the user to create an AST within the context
11119 of another AST.  These nested ASTs are created using the
11120 same C<isl_ast_build_node_from_schedule_map> function that is used to create
11121 the outer AST.  The C<build> argument should be an C<isl_ast_build>
11122 passed to a callback set by
11123 C<isl_ast_build_set_create_leaf>.
11124 The space of the range of the C<schedule> argument should refer
11125 to this build.  In particular, the space should be a wrapped
11126 relation and the domain of this wrapped relation should be the
11127 same as that of the range of the schedule returned by
11128 C<isl_ast_build_get_schedule> below.
11129 In practice, the new schedule is typically
11130 created by calling C<isl_union_map_range_product> on the old schedule
11131 and some extra piece of the schedule.
11132 The space of the schedule domain is also available from
11133 the C<isl_ast_build>.
11135         #include <isl/ast_build.h>
11136         __isl_give isl_union_map *isl_ast_build_get_schedule(
11137                 __isl_keep isl_ast_build *build);
11138         __isl_give isl_space *isl_ast_build_get_schedule_space(
11139                 __isl_keep isl_ast_build *build);
11140         __isl_give isl_ast_build *isl_ast_build_restrict(
11141                 __isl_take isl_ast_build *build,
11142                 __isl_take isl_set *set);
11144 The C<isl_ast_build_get_schedule> function returns a (partial)
11145 schedule for the domains elements for which part of the AST still needs to
11146 be generated in the current build.
11147 In particular, the domain elements are mapped to those iterations of the loops
11148 enclosing the current point of the AST generation inside which
11149 the domain elements are executed.
11150 No direct correspondence between
11151 the input schedule and this schedule should be assumed.
11152 The space obtained from C<isl_ast_build_get_schedule_space> can be used
11153 to create a set for C<isl_ast_build_restrict> to intersect
11154 with the current build.  In particular, the set passed to
11155 C<isl_ast_build_restrict> can have additional parameters.
11156 The ids of the set dimensions in the space returned by
11157 C<isl_ast_build_get_schedule_space> correspond to the
11158 iterators of the already generated loops.
11159 The user should not rely on the ids of the output dimensions
11160 of the relations in the union relation returned by
11161 C<isl_ast_build_get_schedule> having any particular value.
11163 =head1 Applications
11165 Although C<isl> is mainly meant to be used as a library,
11166 it also contains some basic applications that use some
11167 of the functionality of C<isl>.
11168 For applications that take one or more polytopes or polyhedra
11169 as input, this input may be specified in either the L<isl format>
11170 or the L<PolyLib format>.
11172 =head2 C<isl_polyhedron_sample>
11174 C<isl_polyhedron_sample> takes a polyhedron as input and prints
11175 an integer element of the polyhedron, if there is any.
11176 The first column in the output is the denominator and is always
11177 equal to 1.  If the polyhedron contains no integer points,
11178 then a vector of length zero is printed.
11180 =head2 C<isl_pip>
11182 C<isl_pip> takes the same input as the C<example> program
11183 from the C<piplib> distribution, i.e., a set of constraints
11184 on the parameters, a line containing only -1 and finally a set
11185 of constraints on a parametric polyhedron.
11186 The coefficients of the parameters appear in the last columns
11187 (but before the final constant column).
11188 The output is the lexicographic minimum of the parametric polyhedron.
11189 As C<isl> currently does not have its own output format, the output
11190 is just a dump of the internal state.
11192 =head2 C<isl_polyhedron_minimize>
11194 C<isl_polyhedron_minimize> computes the minimum of some linear
11195 or affine objective function over the integer points in a polyhedron.
11196 If an affine objective function
11197 is given, then the constant should appear in the last column.
11199 =head2 C<isl_polytope_scan>
11201 Given a polytope, C<isl_polytope_scan> prints
11202 all integer points in the polytope.
11204 =head2 C<isl_flow>
11206 Given an C<isl_union_access_info> object as input,
11207 C<isl_flow> prints out the corresponding dependences,
11208 as computed by C<isl_union_access_info_compute_flow>.
11210 =head2 C<isl_codegen>
11212 Given either a schedule tree or a sequence consisting of
11213 a schedule map, a context set and an options relation,
11214 C<isl_codegen> prints out an AST that scans the domain elements
11215 of the schedule in the order of their image(s) taking into account
11216 the constraints in the context set.
11218 =head2 C<isl_schedule>
11220 Given an C<isl_schedule_constraints> object as input,
11221 C<isl_schedule> prints out a schedule that satisfies the given
11222 constraints.