add exported isl_map_domain_reverse
[isl.git] / doc / user.pod
blob278c47b296e7087032c9677ca5189ba3ae089bd0
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 =head3 Changes since isl-0.20
286 =over
288 =item * Several functions that used to return C<unsigned>
289 now return C<isl_size>.  This means that these functions may
290 now return a negative value in case an error occurred.
291 The same holds for functions that used to return C<int>,
292 although some of those were already returning
293 a negative value in case of error.
295 =item * The C<isl_ast_op_type> enumeration type has been
296 renamed to C<isl_ast_expr_op_type>.  The corresponding
297 enumeration constants have been similarly renamed.
298 The old names are defined to the new names for backward
299 compatibility.
301 =item * Several functions returning an extra boolean value
302 through an C<int *> argument now do so through an C<isl_bool *>
303 argument.  The returned values are the same, only the type
304 of the pointer has been changed.
306 =back
308 =head1 License
310 C<isl> is released under the MIT license.
312 =over
314 Permission is hereby granted, free of charge, to any person obtaining a copy of
315 this software and associated documentation files (the "Software"), to deal in
316 the Software without restriction, including without limitation the rights to
317 use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
318 of the Software, and to permit persons to whom the Software is furnished to do
319 so, subject to the following conditions:
321 The above copyright notice and this permission notice shall be included in all
322 copies or substantial portions of the Software.
324 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
325 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
326 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
327 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
328 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
329 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
330 SOFTWARE.
332 =back
334 Note that by default C<isl> requires C<GMP>, which is released
335 under the GNU Lesser General Public License (LGPL).  This means
336 that code linked against C<isl> is also linked against LGPL code.
338 When configuring with C<--with-int=imath> or C<--with-int=imath-32>, C<isl>
339 will link against C<imath>, a library for exact integer arithmetic released
340 under the MIT license.
342 =head1 Installation
344 The source of C<isl> can be obtained either as a tarball
345 or from the git repository.  Both are available from
346 L<https://libisl.sourceforge.io/>.
347 The installation process depends on how you obtained
348 the source.
350 =head2 Installation from the git repository
352 =over
354 =item 1 Clone or update the repository
356 The first time the source is obtained, you need to clone
357 the repository.
359         git clone git://repo.or.cz/isl.git
361 To obtain updates, you need to pull in the latest changes
363         git pull
365 =item 2 Optionally get C<imath> submodule
367 To build C<isl> with C<imath>, you need to obtain the C<imath>
368 submodule by running in the git source tree of C<isl>
370        git submodule init
371        git submodule update
373 This will fetch the required version of C<imath> in a subdirectory of C<isl>.
375 =item 2 Generate C<configure>
377         ./autogen.sh
379 =back
381 After performing the above steps, continue
382 with the L<Common installation instructions>.
384 =head2 Common installation instructions
386 =over
388 =item 1 Obtain C<GMP>
390 By default, building C<isl> requires C<GMP>, including its headers files.
391 Your distribution may not provide these header files by default
392 and you may need to install a package called C<gmp-devel> or something
393 similar.  Alternatively, C<GMP> can be built from
394 source, available from L<http://gmplib.org/>.
395 C<GMP> is not needed if you build C<isl> with C<imath>.
397 =item 2 Configure
399 C<isl> uses the standard C<autoconf> C<configure> script.
400 To run it, just type
402         ./configure
404 optionally followed by some configure options.
405 A complete list of options can be obtained by running
407         ./configure --help
409 Below we discuss some of the more common options.
411 =over
413 =item C<--prefix>
415 Installation prefix for C<isl>
417 =item C<--with-int=[gmp|imath|imath-32]>
419 Select the integer library to be used by C<isl>, the default is C<gmp>.
420 With C<imath-32>, C<isl> will use 32 bit integers, but fall back to C<imath>
421 for values out of the 32 bit range. In most applications, C<isl> will run
422 fastest with the C<imath-32> option, followed by C<gmp> and C<imath>, the
423 slowest.
425 =item C<--with-gmp-prefix=>I<path>
427 Installation prefix for C<GMP> (architecture-independent files).
429 =item C<--with-gmp-exec-prefix=>I<path>
431 Installation prefix for C<GMP> (architecture-dependent files).
433 =back
435 =item 3 Compile
437         make
439 =item 4 Test (optional)
441         make check
443 =item 5 Install (optional)
445         make install
447 =back
449 =head2 Building the foreign language bindings
451 The tarball already contains the generated foreign language bindings,
452 but they are not included in the git repository.
453 Building the C++ and Python bindings relies on the LLVM/clang libraries,
454 see C<http://clang.llvm.org/get_started.html>.
455 The C<configure> script will not assume that these are available
456 on the system.
457 To enable building the foreign language bindings,
458 one of the following options needs to be specified.
460 =over
462 =item C<--with-clang=system>
464 Use the system clang libraries (installed in a default location).
466 =item C<--with-clang-prefix=>I<path>
468 Use the system clang libraries installed in I<path>.
470 =back
472 It is best to use the latest release of the clang libraries (14.0),
473 although any release since 2.9 should work as well.
474 Note that if you build the clang libraries from source,
475 then you need to make sure they are also installed (using C<make install>).
476 If the compiler that was used to compile the clang libraries
477 is different from the default C++ compiler, then use C<CXX_FOR_BUILD>
478 to specify this non-default C++ compiler when running C<isl>'s C<./configure>.
480 =head1 Integer Set Library
482 =head2 Memory Management
484 Since a high-level operation on isl objects usually involves
485 several substeps and since the user is usually not interested in
486 the intermediate results, most functions that return a new object
487 will also release all the objects passed as arguments.
488 If the user still wants to use one or more of these arguments
489 after the function call, she should pass along a copy of the
490 object rather than the object itself.
491 The user is then responsible for making sure that the original
492 object gets used somewhere else or is explicitly freed.
494 The arguments and return values of all documented functions are
495 annotated to make clear which arguments are released and which
496 arguments are preserved.  In particular, the following annotations
497 are used
499 =over
501 =item C<__isl_give>
503 C<__isl_give> means that a new object is returned.
504 The user should make sure that the returned pointer is
505 used exactly once as a value for an C<__isl_take> argument.
506 In between, it can be used as a value for as many
507 C<__isl_keep> arguments as the user likes.
508 There is one exception, and that is the case where the
509 pointer returned is C<NULL>.  In this case, the user
510 is free to use it as an C<__isl_take> argument or not.
511 When applied to a C<char *>, the returned pointer needs to be
512 freed using C<free>.
514 =item C<__isl_null>
516 C<__isl_null> means that a C<NULL> value is returned.
518 =item C<__isl_take>
520 C<__isl_take> means that the object the argument points to
521 is taken over by the function and may no longer be used
522 by the user as an argument to any other function.
523 The pointer value must be one returned by a function
524 returning an C<__isl_give> pointer.
525 If the user passes in a C<NULL> value, then this will
526 be treated as an error in the sense that the function will
527 not perform its usual operation.  However, it will still
528 make sure that all the other C<__isl_take> arguments
529 are released.
531 =item C<__isl_keep>
533 C<__isl_keep> means that the function will only use the object
534 temporarily.  After the function has finished, the user
535 can still use it as an argument to other functions.
536 A C<NULL> value will be treated in the same way as
537 a C<NULL> value for an C<__isl_take> argument.
538 This annotation may also be used on return values of
539 type C<const char *>, in which case the returned pointer should
540 not be freed by the user and is only valid until the object
541 from which it was derived is updated or freed.
543 =back
545 =head2 Initialization
547 All manipulations of integer sets and relations occur within
548 the context of an C<isl_ctx>.
549 A given C<isl_ctx> can only be used within a single thread.
550 All arguments of a function are required to have been allocated
551 within the same context.
552 There are currently no functions available for moving an object
553 from one C<isl_ctx> to another C<isl_ctx>.  This means that
554 there is currently no way of safely moving an object from one
555 thread to another, unless the whole C<isl_ctx> is moved.
557 An C<isl_ctx> can be allocated using C<isl_ctx_alloc> and
558 freed using C<isl_ctx_free>.
559 All objects allocated within an C<isl_ctx> should be freed
560 before the C<isl_ctx> itself is freed.
562         isl_ctx *isl_ctx_alloc();
563         void isl_ctx_free(isl_ctx *ctx);
565 The user can impose a bound on the number of low-level I<operations>
566 that can be performed by an C<isl_ctx>.  This bound can be set and
567 retrieved using the following functions.  A bound of zero means that
568 no bound is imposed.  The number of operations performed can be
569 reset using C<isl_ctx_reset_operations>.  Note that the number
570 of low-level operations needed to perform a high-level computation
571 may differ significantly across different versions
572 of C<isl>, but it should be the same across different platforms
573 for the same version of C<isl>.
575 Warning: This feature is experimental.  C<isl> has good support to abort and
576 bail out during the computation, but this feature may exercise error code paths
577 that are normally not used that much. Consequently, it is not unlikely that
578 hidden bugs will be exposed.
580         void isl_ctx_set_max_operations(isl_ctx *ctx,
581                 unsigned long max_operations);
582         unsigned long isl_ctx_get_max_operations(isl_ctx *ctx);
583         void isl_ctx_reset_operations(isl_ctx *ctx);
585 In order to be able to create an object in the same context
586 as another object, most object types (described later in
587 this document) provide a function to obtain the context
588 in which the object was created.
590         #include <isl/val.h>
591         isl_ctx *isl_val_get_ctx(__isl_keep isl_val *val);
592         isl_ctx *isl_multi_val_get_ctx(
593                 __isl_keep isl_multi_val *mv);
595         #include <isl/id.h>
596         isl_ctx *isl_id_get_ctx(__isl_keep isl_id *id);
597         isl_ctx *isl_multi_id_get_ctx(
598                 __isl_keep isl_multi_id *mi);
600         #include <isl/local_space.h>
601         isl_ctx *isl_local_space_get_ctx(
602                 __isl_keep isl_local_space *ls);
604         #include <isl/set.h>
605         isl_ctx *isl_set_list_get_ctx(
606                 __isl_keep isl_set_list *list);
608         #include <isl/aff.h>
609         isl_ctx *isl_aff_get_ctx(__isl_keep isl_aff *aff);
610         isl_ctx *isl_multi_aff_get_ctx(
611                 __isl_keep isl_multi_aff *maff);
612         isl_ctx *isl_pw_aff_get_ctx(__isl_keep isl_pw_aff *pa);
613         isl_ctx *isl_pw_multi_aff_get_ctx(
614                 __isl_keep isl_pw_multi_aff *pma);
615         isl_ctx *isl_multi_pw_aff_get_ctx(
616                 __isl_keep isl_multi_pw_aff *mpa);
617         isl_ctx *isl_union_pw_aff_get_ctx(
618                 __isl_keep isl_union_pw_aff *upa);
619         isl_ctx *isl_union_pw_multi_aff_get_ctx(
620                 __isl_keep isl_union_pw_multi_aff *upma);
621         isl_ctx *isl_multi_union_pw_aff_get_ctx(
622                 __isl_keep isl_multi_union_pw_aff *mupa);
624         #include <isl/id_to_ast_expr.h>
625         isl_ctx *isl_id_to_ast_expr_get_ctx(
626                 __isl_keep isl_id_to_ast_expr *id2expr);
628         #include <isl/point.h>
629         isl_ctx *isl_point_get_ctx(__isl_keep isl_point *pnt);
631         #include <isl/vec.h>
632         isl_ctx *isl_vec_get_ctx(__isl_keep isl_vec *vec);
634         #include <isl/mat.h>
635         isl_ctx *isl_mat_get_ctx(__isl_keep isl_mat *mat);
637         #include <isl/vertices.h>
638         isl_ctx *isl_vertices_get_ctx(
639                 __isl_keep isl_vertices *vertices);
640         isl_ctx *isl_vertex_get_ctx(__isl_keep isl_vertex *vertex);
641         isl_ctx *isl_cell_get_ctx(__isl_keep isl_cell *cell);
643         #include <isl/flow.h>
644         isl_ctx *isl_restriction_get_ctx(
645                 __isl_keep isl_restriction *restr);
646         isl_ctx *isl_union_access_info_get_ctx(
647                 __isl_keep isl_union_access_info *access);
648         isl_ctx *isl_union_flow_get_ctx(
649                 __isl_keep isl_union_flow *flow);
651         #include <isl/schedule.h>
652         isl_ctx *isl_schedule_get_ctx(
653                 __isl_keep isl_schedule *sched);
654         isl_ctx *isl_schedule_constraints_get_ctx(
655                 __isl_keep isl_schedule_constraints *sc);
657         #include <isl/schedule_node.h>
658         isl_ctx *isl_schedule_node_get_ctx(
659                 __isl_keep isl_schedule_node *node);
661         #include <isl/ast_build.h>
662         isl_ctx *isl_ast_build_get_ctx(
663                 __isl_keep isl_ast_build *build);
665         #include <isl/ast.h>
666         isl_ctx *isl_ast_expr_get_ctx(
667                 __isl_keep isl_ast_expr *expr);
668         isl_ctx *isl_ast_node_get_ctx(
669                 __isl_keep isl_ast_node *node);
671         #include <isl/stride_info.h>
672         isl_ctx *isl_stride_info_get_ctx(
673                 __isl_keep isl_stride_info *si);
675         #include <isl/fixed_box.h>
676         isl_ctx *isl_fixed_box_get_ctx(
677                 __isl_keep isl_fixed_box *box);
679 =head2 Return Types
681 C<isl> uses the special return type C<isl_size> for functions
682 that return a non-negative value, typically a number or a position.
683 Besides the regular non-negative return values, a special (negative)
684 value C<isl_size_error> may be returned, indicating that something
685 went wrong.
687 C<isl> also uses two special return types for functions that either return
688 a boolean or that in principle do not return anything.
689 In particular, the C<isl_bool> type has three possible values:
690 C<isl_bool_true> (a positive integer value), indicating I<true> or I<yes>;
691 C<isl_bool_false> (the integer value zero), indicating I<false> or I<no>; and
692 C<isl_bool_error> (a negative integer value), indicating that something
693 went wrong.  The following operations are defined on C<isl_bool>. The function
694 C<isl_bool_not> can be used to negate an C<isl_bool>, where the negation of
695 C<isl_bool_error> is C<isl_bool_error> again. The function C<isl_bool_ok>
696 converts an integer to an C<isl_bool>. Any non-zero values yields
697 C<isl_bool_true> and zero yields C<isl_bool_false>.
699         #include <isl/ctx.h>
700         isl_bool isl_bool_not(isl_bool b);
701         isl_bool isl_bool_ok(int b);
703 The C<isl_stat> type has two possible values:
704 C<isl_stat_ok> (the integer value zero), indicating a successful
705 operation; and
706 C<isl_stat_error> (a negative integer value), indicating that something
707 went wrong.
708 The function C<isl_stat_non_null> converts an isl object pointer
709 to an C<isl_stat>, returning C<isl_stat_ok> if the object pointer is valid and
710 C<isl_stat_error> if it is C<NULL>.
712         #include <isl/ctx.h>
713         isl_stat isl_stat_non_null(void *obj);
715 See L</"Error Handling"> for more information on
716 C<isl_size_error>, C<isl_bool_error> and C<isl_stat_error>.
718 =head2 Values
720 An C<isl_val> represents an integer value, a rational value
721 or one of three special values, infinity, negative infinity and NaN.
722 Some predefined values can be created using the following functions.
724         #include <isl/val.h>
725         __isl_give isl_val *isl_val_zero(isl_ctx *ctx);
726         __isl_give isl_val *isl_val_one(isl_ctx *ctx);
727         __isl_give isl_val *isl_val_negone(isl_ctx *ctx);
728         __isl_give isl_val *isl_val_nan(isl_ctx *ctx);
729         __isl_give isl_val *isl_val_infty(isl_ctx *ctx);
730         __isl_give isl_val *isl_val_neginfty(isl_ctx *ctx);
732 Specific integer values can be created using the following functions.
734         #include <isl/val.h>
735         __isl_give isl_val *isl_val_int_from_si(isl_ctx *ctx,
736                 long i);
737         __isl_give isl_val *isl_val_int_from_ui(isl_ctx *ctx,
738                 unsigned long u);
739         __isl_give isl_val *isl_val_int_from_chunks(isl_ctx *ctx,
740                 size_t n, size_t size, const void *chunks);
742 The function C<isl_val_int_from_chunks> constructs an C<isl_val>
743 from the C<n> I<digits>, each consisting of C<size> bytes, stored at C<chunks>.
744 The least significant digit is assumed to be stored first.
746 Value objects can be copied and freed using the following functions.
748         #include <isl/val.h>
749         __isl_give isl_val *isl_val_copy(__isl_keep isl_val *v);
750         __isl_null isl_val *isl_val_free(__isl_take isl_val *v);
752 They can be inspected using the following functions.
754         #include <isl/val.h>
755         long isl_val_get_num_si(__isl_keep isl_val *v);
756         long isl_val_get_den_si(__isl_keep isl_val *v);
757         __isl_give isl_val *isl_val_get_den_val(
758                 __isl_keep isl_val *v);
759         double isl_val_get_d(__isl_keep isl_val *v);
760         isl_size isl_val_n_abs_num_chunks(__isl_keep isl_val *v,
761                 size_t size);
762         isl_stat isl_val_get_abs_num_chunks(__isl_keep isl_val *v,
763                 size_t size, void *chunks);
765 C<isl_val_n_abs_num_chunks> returns the number of I<digits>
766 of C<size> bytes needed to store the absolute value of the
767 numerator of C<v>.
768 C<isl_val_get_abs_num_chunks> stores these digits at C<chunks>,
769 which is assumed to have been preallocated by the caller.
770 The least significant digit is stored first.
771 Note that C<isl_val_get_num_si>, C<isl_val_get_den_si>,
772 C<isl_val_get_d>, C<isl_val_n_abs_num_chunks>
773 and C<isl_val_get_abs_num_chunks> can only be applied to rational values.
775 An C<isl_val> can be modified using the following function.
777         #include <isl/val.h>
778         __isl_give isl_val *isl_val_set_si(__isl_take isl_val *v,
779                 long i);
781 The following unary properties are defined on C<isl_val>s.
783         #include <isl/val.h>
784         int isl_val_sgn(__isl_keep isl_val *v);
785         isl_bool isl_val_is_zero(__isl_keep isl_val *v);
786         isl_bool isl_val_is_one(__isl_keep isl_val *v);
787         isl_bool isl_val_is_negone(__isl_keep isl_val *v);
788         isl_bool isl_val_is_nonneg(__isl_keep isl_val *v);
789         isl_bool isl_val_is_nonpos(__isl_keep isl_val *v);
790         isl_bool isl_val_is_pos(__isl_keep isl_val *v);
791         isl_bool isl_val_is_neg(__isl_keep isl_val *v);
792         isl_bool isl_val_is_int(__isl_keep isl_val *v);
793         isl_bool isl_val_is_rat(__isl_keep isl_val *v);
794         isl_bool isl_val_is_nan(__isl_keep isl_val *v);
795         isl_bool isl_val_is_infty(__isl_keep isl_val *v);
796         isl_bool isl_val_is_neginfty(__isl_keep isl_val *v);
798 Note that the sign of NaN is undefined.
800 The following binary properties are defined on pairs of C<isl_val>s.
802         #include <isl/val.h>
803         isl_bool isl_val_lt(__isl_keep isl_val *v1,
804                 __isl_keep isl_val *v2);
805         isl_bool isl_val_le(__isl_keep isl_val *v1,
806                 __isl_keep isl_val *v2);
807         isl_bool isl_val_gt(__isl_keep isl_val *v1,
808                 __isl_keep isl_val *v2);
809         isl_bool isl_val_ge(__isl_keep isl_val *v1,
810                 __isl_keep isl_val *v2);
811         isl_bool isl_val_eq(__isl_keep isl_val *v1,
812                 __isl_keep isl_val *v2);
813         isl_bool isl_val_ne(__isl_keep isl_val *v1,
814                 __isl_keep isl_val *v2);
815         isl_bool isl_val_abs_eq(__isl_keep isl_val *v1,
816                 __isl_keep isl_val *v2);
818 Comparisons to NaN always return false.
819 That is, a NaN is not considered to hold any relative position
820 with respect to any value.  In particular, a NaN
821 is neither considered to be equal to nor to be different from
822 any value (including another NaN).
823 The function C<isl_val_abs_eq> checks whether its two arguments
824 are equal in absolute value.
826 For integer C<isl_val>s we additionally have the following binary property.
828         #include <isl/val.h>
829         isl_bool isl_val_is_divisible_by(__isl_keep isl_val *v1,
830                 __isl_keep isl_val *v2);
832 An C<isl_val> can also be compared to an integer using the following
833 functions.  The result of C<isl_val_cmp_si> is undefined for NaN.
835         #include <isl/val.h>
836         isl_bool isl_val_gt_si(__isl_keep isl_val *v, long i);
837         isl_bool isl_val_eq_si(__isl_keep isl_val *v, long i);
838         int isl_val_cmp_si(__isl_keep isl_val *v, long i);
840 The following unary operations are available on C<isl_val>s.
842         #include <isl/val.h>
843         __isl_give isl_val *isl_val_abs(__isl_take isl_val *v);
844         __isl_give isl_val *isl_val_neg(__isl_take isl_val *v);
845         __isl_give isl_val *isl_val_floor(__isl_take isl_val *v);
846         __isl_give isl_val *isl_val_ceil(__isl_take isl_val *v);
847         __isl_give isl_val *isl_val_trunc(__isl_take isl_val *v);
848         __isl_give isl_val *isl_val_inv(__isl_take isl_val *v);
850 The following binary operations are available on C<isl_val>s.
852         #include <isl/val.h>
853         __isl_give isl_val *isl_val_min(__isl_take isl_val *v1,
854                 __isl_take isl_val *v2);
855         __isl_give isl_val *isl_val_max(__isl_take isl_val *v1,
856                 __isl_take isl_val *v2);
857         __isl_give isl_val *isl_val_add(__isl_take isl_val *v1,
858                 __isl_take isl_val *v2);
859         __isl_give isl_val *isl_val_add_ui(__isl_take isl_val *v1,
860                 unsigned long v2);
861         __isl_give isl_val *isl_val_sub(__isl_take isl_val *v1,
862                 __isl_take isl_val *v2);
863         __isl_give isl_val *isl_val_sub_ui(__isl_take isl_val *v1,
864                 unsigned long v2);
865         __isl_give isl_val *isl_val_mul(__isl_take isl_val *v1,
866                 __isl_take isl_val *v2);
867         __isl_give isl_val *isl_val_mul_ui(__isl_take isl_val *v1,
868                 unsigned long v2);
869         __isl_give isl_val *isl_val_div(__isl_take isl_val *v1,
870                 __isl_take isl_val *v2);
871         __isl_give isl_val *isl_val_div_ui(__isl_take isl_val *v1,
872                 unsigned long v2);
874 On integer values, we additionally have the following operations.
876         #include <isl/val.h>
877         __isl_give isl_val *isl_val_pow2(__isl_take isl_val *v);
878         __isl_give isl_val *isl_val_2exp(__isl_take isl_val *v);
879         __isl_give isl_val *isl_val_mod(__isl_take isl_val *v1,
880                 __isl_take isl_val *v2);
881         __isl_give isl_val *isl_val_gcd(__isl_take isl_val *v1,
882                 __isl_take isl_val *v2);
883         __isl_give isl_val *isl_val_gcdext(__isl_take isl_val *v1,
884                 __isl_take isl_val *v2, __isl_give isl_val **x,
885                 __isl_give isl_val **y);
887 C<isl_val_2exp> is an alternative name for C<isl_val_pow2>.
888 The function C<isl_val_gcdext> returns the greatest common divisor g
889 of C<v1> and C<v2> as well as two integers C<*x> and C<*y> such
890 that C<*x> * C<v1> + C<*y> * C<v2> = g.
892 =head3 GMP specific functions
894 These functions are only available if C<isl> has been compiled with C<GMP>
895 support.
897 Specific integer and rational values can be created from C<GMP> values using
898 the following functions.
900         #include <isl/val_gmp.h>
901         __isl_give isl_val *isl_val_int_from_gmp(isl_ctx *ctx,
902                 mpz_t z);
903         __isl_give isl_val *isl_val_from_gmp(isl_ctx *ctx,
904                 const mpz_t n, const mpz_t d);
906 The numerator and denominator of a rational value can be extracted as
907 C<GMP> values using the following functions.
909         #include <isl/val_gmp.h>
910         int isl_val_get_num_gmp(__isl_keep isl_val *v, mpz_t z);
911         int isl_val_get_den_gmp(__isl_keep isl_val *v, mpz_t z);
913 =head2 Sets and Relations
915 C<isl> uses six types of objects for representing sets and relations,
916 C<isl_basic_set>, C<isl_basic_map>, C<isl_set>, C<isl_map>,
917 C<isl_union_set> and C<isl_union_map>.
918 C<isl_basic_set> and C<isl_basic_map> represent sets and relations that
919 can be described as a conjunction of affine constraints, while
920 C<isl_set> and C<isl_map> represent unions of
921 C<isl_basic_set>s and C<isl_basic_map>s, respectively.
922 However, all C<isl_basic_set>s or C<isl_basic_map>s in the union need
923 to live in the same space.  C<isl_union_set>s and C<isl_union_map>s
924 represent unions of C<isl_set>s or C<isl_map>s in I<different> spaces,
925 where spaces are considered different if they have a different number
926 of dimensions and/or different names (see L<"Spaces">).
927 The difference between sets and relations (maps) is that sets have
928 one set of variables, while relations have two sets of variables,
929 input variables and output variables.
931 =head2 Error Handling
933 C<isl> supports different ways to react in case a runtime error is triggered.
934 Runtime errors arise, e.g., if a function such as C<isl_map_intersect> is called
935 with two maps that have incompatible spaces. There are three possible ways
936 to react on error: to warn, to continue or to abort.
938 The default behavior is to warn. In this mode, C<isl> prints a warning, stores
939 the last error in the corresponding C<isl_ctx> and the function in which the
940 error was triggered returns a value indicating that some error has
941 occurred.  In case of functions returning a pointer, this value is
942 C<NULL>.  In case of functions returning an C<isl_size>, C<isl_bool> or an
943 C<isl_stat>, this value is C<isl_size_error>,
944 C<isl_bool_error> or C<isl_stat_error>.
945 An error does not corrupt internal state,
946 such that isl can continue to be used. C<isl> also provides functions to
947 read the last error, including the specific error message,
948 the isl source file where the error occurred and the line number,
949 and to reset all information about the last error. The
950 last error is only stored for information purposes. Its presence does not
951 change the behavior of C<isl>. Hence, resetting an error is not required to
952 continue to use isl, but only to observe new errors.
954         #include <isl/ctx.h>
955         enum isl_error isl_ctx_last_error(isl_ctx *ctx);
956         const char *isl_ctx_last_error_msg(isl_ctx *ctx);
957         const char *isl_ctx_last_error_file(isl_ctx *ctx);
958         int isl_ctx_last_error_line(isl_ctx *ctx);
959         void isl_ctx_reset_error(isl_ctx *ctx);
961 If no error has occurred since the last call to C<isl_ctx_reset_error>,
962 then the functions C<isl_ctx_last_error_msg> and
963 C<isl_ctx_last_error_file> return C<NULL>.
965 Another option is to continue on error. This is similar to warn on error mode,
966 except that C<isl> does not print any warning. This allows a program to
967 implement its own error reporting.
969 The last option is to directly abort the execution of the program from within
970 the isl library. This makes it obviously impossible to recover from an error,
971 but it allows to directly spot the error location. By aborting on error,
972 debuggers break at the location the error occurred and can provide a stack
973 trace. Other tools that automatically provide stack traces on abort or that do
974 not want to continue execution after an error was triggered may also prefer to
975 abort on error.
977 The on error behavior of isl can be specified by calling
978 C<isl_options_set_on_error> or by setting the command line option
979 C<--isl-on-error>. Valid arguments for the function call are
980 C<ISL_ON_ERROR_WARN>, C<ISL_ON_ERROR_CONTINUE> and C<ISL_ON_ERROR_ABORT>. The
981 choices for the command line option are C<warn>, C<continue> and C<abort>.
982 It is also possible to query the current error mode.
984         #include <isl/options.h>
985         isl_stat isl_options_set_on_error(isl_ctx *ctx, int val);
986         int isl_options_get_on_error(isl_ctx *ctx);
988 =head2 Identifiers
990 Identifiers are used to identify both individual dimensions
991 and tuples of dimensions.  They consist of an optional name and an optional
992 user pointer.  The name and the user pointer cannot both be C<NULL>, however.
993 Identifiers with the same name but different pointer values
994 are considered to be distinct.
995 Similarly, identifiers with different names but the same pointer value
996 are also considered to be distinct.
997 Equal identifiers are represented using the same object.
998 Pairs of identifiers can therefore be tested for equality using the
999 C<==> operator.
1000 Identifiers can be constructed, copied, freed, inspected and printed
1001 using the following functions.
1003         #include <isl/id.h>
1004         __isl_give isl_id *isl_id_alloc(isl_ctx *ctx,
1005                 __isl_keep const char *name, void *user);
1006         __isl_give isl_id *isl_id_set_free_user(
1007                 __isl_take isl_id *id,
1008                 void (*free_user)(void *user));
1009         void (*isl_id_get_free_user(__isl_keep isl_id *id))
1010                 (void *user);
1011         __isl_give isl_id *isl_id_copy(isl_id *id);
1012         __isl_null isl_id *isl_id_free(__isl_take isl_id *id);
1014         void *isl_id_get_user(__isl_keep isl_id *id);
1015         __isl_keep const char *isl_id_get_name(__isl_keep isl_id *id);
1017         __isl_give isl_printer *isl_printer_print_id(
1018                 __isl_take isl_printer *p, __isl_keep isl_id *id);
1020 The callback set by C<isl_id_set_free_user> is called on the user
1021 pointer when the last reference to the C<isl_id> is freed.
1022 This callback can be retrieved using C<isl_id_get_free_user>.
1023 Note that C<isl_id_get_name> returns a pointer to some internal
1024 data structure, so the result can only be used while the
1025 corresponding C<isl_id> is alive.
1027 =head2 Spaces
1029 Whenever a new set, relation or similar object is created from scratch,
1030 the space in which it lives needs to be specified using an C<isl_space>.
1031 Each space involves zero or more parameters and zero, one or two
1032 tuples of set or input/output dimensions.  The parameters and dimensions
1033 are identified by an C<isl_dim_type> and a position.
1034 The type C<isl_dim_param> refers to parameters,
1035 the type C<isl_dim_set> refers to set dimensions (for spaces
1036 with a single tuple of dimensions) and the types C<isl_dim_in>
1037 and C<isl_dim_out> refer to input and output dimensions
1038 (for spaces with two tuples of dimensions).
1039 Local spaces (see L</"Local Spaces">) also contain dimensions
1040 of type C<isl_dim_div>.
1041 Note that parameters are only identified by their position within
1042 a given object.  Across different objects, parameters are (usually)
1043 identified by their names or identifiers.  Only unnamed parameters
1044 are identified by their positions across objects.  The use of unnamed
1045 parameters is discouraged.
1047         #include <isl/space.h>
1048         __isl_give isl_space *isl_space_unit(isl_ctx *ctx);
1049         __isl_give isl_space *isl_space_alloc(isl_ctx *ctx,
1050                 unsigned nparam, unsigned n_in, unsigned n_out);
1051         __isl_give isl_space *isl_space_params_alloc(isl_ctx *ctx,
1052                 unsigned nparam);
1053         __isl_give isl_space *isl_space_set_alloc(isl_ctx *ctx,
1054                 unsigned nparam, unsigned dim);
1055         __isl_give isl_space *isl_space_copy(__isl_keep isl_space *space);
1056         __isl_null isl_space *isl_space_free(__isl_take isl_space *space);
1058 The space used for creating a parameter domain
1059 needs to be created using C<isl_space_unit> or C<isl_space_params_alloc>.
1060 For other sets, the space
1061 needs to be created using C<isl_space_set_alloc>, while
1062 for a relation, the space
1063 needs to be created using C<isl_space_alloc>.
1064 The use of C<isl_space_params_alloc>,
1065 C<isl_space_set_alloc> and C<isl_space_alloc> is discouraged as they allow
1066 for the introduction of unnamed parameters.
1068 To check whether a given space is that of a set or a map
1069 or whether it is a parameter space, use these functions:
1071         #include <isl/space.h>
1072         isl_bool isl_space_is_params(__isl_keep isl_space *space);
1073         isl_bool isl_space_is_set(__isl_keep isl_space *space);
1074         isl_bool isl_space_is_map(__isl_keep isl_space *space);
1076 Spaces can be compared using the following functions:
1078         #include <isl/space.h>
1079         isl_bool isl_space_is_equal(__isl_keep isl_space *space1,
1080                 __isl_keep isl_space *space2);
1081         isl_bool isl_space_has_equal_params(
1082                 __isl_keep isl_space *space1,
1083                 __isl_keep isl_space *space2);
1084         isl_bool isl_space_has_equal_tuples(
1085                 __isl_keep isl_space *space1,
1086                 __isl_keep isl_space *space2);
1087         isl_bool isl_space_is_domain(__isl_keep isl_space *space1,
1088                 __isl_keep isl_space *space2);
1089         isl_bool isl_space_is_range(__isl_keep isl_space *space1,
1090                 __isl_keep isl_space *space2);
1091         isl_bool isl_space_tuple_is_equal(
1092                 __isl_keep isl_space *space1,
1093                 enum isl_dim_type type1,
1094                 __isl_keep isl_space *space2,
1095                 enum isl_dim_type type2);
1097 C<isl_space_is_domain> checks whether the first argument is equal
1098 to the domain of the second argument.  This requires in particular that
1099 the first argument is a set space and that the second argument
1100 is a map space.  C<isl_space_tuple_is_equal> checks whether the given
1101 tuples (C<isl_dim_in>, C<isl_dim_out> or C<isl_dim_set>) of the given
1102 spaces are the same.  That is, it checks if they have the same
1103 identifier (if any), the same dimension and the same internal structure
1104 (if any).
1105 The function
1106 C<isl_space_has_equal_params> checks whether two spaces
1107 have the same parameters in the same order.
1108 C<isl_space_has_equal_tuples> check whether two spaces have
1109 the same tuples.  In contrast to C<isl_space_is_equal> below,
1110 it does not check the
1111 parameters.  This is useful because many C<isl> functions align the
1112 parameters before they perform their operations, such that equivalence
1113 is not necessary.
1114 C<isl_space_is_equal> checks whether two spaces are identical,
1115 meaning that they have the same parameters and the same tuples.
1116 That is, it checks whether both C<isl_space_has_equal_params> and
1117 C<isl_space_has_equal_tuples> hold.
1119 It is often useful to create objects that live in the
1120 same space as some other object.  This can be accomplished
1121 by creating the new objects
1122 (see L</"Creating New Sets and Relations"> or
1123 L</"Functions">) based on the space
1124 of the original object.
1126         #include <isl/set.h>
1127         __isl_give isl_space *isl_basic_set_get_space(
1128                 __isl_keep isl_basic_set *bset);
1129         __isl_give isl_space *isl_set_get_space(__isl_keep isl_set *set);
1131         #include <isl/union_set.h>
1132         __isl_give isl_space *isl_union_set_get_space(
1133                 __isl_keep isl_union_set *uset);
1135         #include <isl/map.h>
1136         __isl_give isl_space *isl_basic_map_get_space(
1137                 __isl_keep isl_basic_map *bmap);
1138         __isl_give isl_space *isl_map_get_space(__isl_keep isl_map *map);
1140         #include <isl/union_map.h>
1141         __isl_give isl_space *isl_union_map_get_space(
1142                 __isl_keep isl_union_map *umap);
1144         #include <isl/constraint.h>
1145         __isl_give isl_space *isl_constraint_get_space(
1146                 __isl_keep isl_constraint *constraint);
1148         #include <isl/polynomial.h>
1149         __isl_give isl_space *isl_qpolynomial_get_domain_space(
1150                 __isl_keep isl_qpolynomial *qp);
1151         __isl_give isl_space *isl_qpolynomial_get_space(
1152                 __isl_keep isl_qpolynomial *qp);
1153         __isl_give isl_space *
1154         isl_qpolynomial_fold_get_domain_space(
1155                 __isl_keep isl_qpolynomial_fold *fold);
1156         __isl_give isl_space *isl_qpolynomial_fold_get_space(
1157                 __isl_keep isl_qpolynomial_fold *fold);
1158         __isl_give isl_space *isl_pw_qpolynomial_get_domain_space(
1159                 __isl_keep isl_pw_qpolynomial *pwqp);
1160         __isl_give isl_space *isl_pw_qpolynomial_get_space(
1161                 __isl_keep isl_pw_qpolynomial *pwqp);
1162         __isl_give isl_space *isl_pw_qpolynomial_fold_get_domain_space(
1163                 __isl_keep isl_pw_qpolynomial_fold *pwf);
1164         __isl_give isl_space *isl_pw_qpolynomial_fold_get_space(
1165                 __isl_keep isl_pw_qpolynomial_fold *pwf);
1166         __isl_give isl_space *isl_union_pw_qpolynomial_get_space(
1167                 __isl_keep isl_union_pw_qpolynomial *upwqp);
1168         __isl_give isl_space *isl_union_pw_qpolynomial_fold_get_space(
1169                 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
1171         #include <isl/id.h>
1172         __isl_give isl_space *isl_multi_id_get_space(
1173                 __isl_keep isl_multi_id *mi);
1175         #include <isl/val.h>
1176         __isl_give isl_space *isl_multi_val_get_space(
1177                 __isl_keep isl_multi_val *mv);
1179         #include <isl/aff.h>
1180         __isl_give isl_space *isl_aff_get_domain_space(
1181                 __isl_keep isl_aff *aff);
1182         __isl_give isl_space *isl_aff_get_space(
1183                 __isl_keep isl_aff *aff);
1184         __isl_give isl_space *isl_pw_aff_get_domain_space(
1185                 __isl_keep isl_pw_aff *pwaff);
1186         __isl_give isl_space *isl_pw_aff_get_space(
1187                 __isl_keep isl_pw_aff *pwaff);
1188         __isl_give isl_space *isl_multi_aff_get_domain_space(
1189                 __isl_keep isl_multi_aff *maff);
1190         __isl_give isl_space *isl_multi_aff_get_space(
1191                 __isl_keep isl_multi_aff *maff);
1192         __isl_give isl_space *isl_pw_multi_aff_get_domain_space(
1193                 __isl_keep isl_pw_multi_aff *pma);
1194         __isl_give isl_space *isl_pw_multi_aff_get_space(
1195                 __isl_keep isl_pw_multi_aff *pma);
1196         __isl_give isl_space *isl_union_pw_aff_get_space(
1197                 __isl_keep isl_union_pw_aff *upa);
1198         __isl_give isl_space *isl_union_pw_multi_aff_get_space(
1199                 __isl_keep isl_union_pw_multi_aff *upma);
1200         __isl_give isl_space *isl_multi_pw_aff_get_domain_space(
1201                 __isl_keep isl_multi_pw_aff *mpa);
1202         __isl_give isl_space *isl_multi_pw_aff_get_space(
1203                 __isl_keep isl_multi_pw_aff *mpa);
1204         __isl_give isl_space *
1205         isl_multi_union_pw_aff_get_domain_space(
1206                 __isl_keep isl_multi_union_pw_aff *mupa);
1207         __isl_give isl_space *
1208         isl_multi_union_pw_aff_get_space(
1209                 __isl_keep isl_multi_union_pw_aff *mupa);
1211         #include <isl/point.h>
1212         __isl_give isl_space *isl_point_get_space(
1213                 __isl_keep isl_point *pnt);
1215         #include <isl/fixed_box.h>
1216         __isl_give isl_space *isl_fixed_box_get_space(
1217                 __isl_keep isl_fixed_box *box);
1219 The number of dimensions of a given type of space
1220 may be read off from a space or an object that lives
1221 in a space using the following functions.
1222 In case of C<isl_space_dim>, type may be
1223 C<isl_dim_param>, C<isl_dim_in> (only for relations),
1224 C<isl_dim_out> (only for relations), C<isl_dim_set>
1225 (only for sets) or C<isl_dim_all>.
1227         #include <isl/space.h>
1228         isl_size isl_space_dim(__isl_keep isl_space *space,
1229                 enum isl_dim_type type);
1231         #include <isl/local_space.h>
1232         isl_size isl_local_space_dim(__isl_keep isl_local_space *ls,
1233                 enum isl_dim_type type);
1235         #include <isl/set.h>
1236         isl_size isl_basic_set_dim(__isl_keep isl_basic_set *bset,
1237                 enum isl_dim_type type);
1238         isl_size isl_set_tuple_dim(__isl_keep isl_set *set);
1239         isl_size isl_set_dim(__isl_keep isl_set *set,
1240                 enum isl_dim_type type);
1242         #include <isl/union_set.h>
1243         isl_size isl_union_set_dim(__isl_keep isl_union_set *uset,
1244                 enum isl_dim_type type);
1246         #include <isl/map.h>
1247         isl_size isl_basic_map_dim(__isl_keep isl_basic_map *bmap,
1248                 enum isl_dim_type type);
1249         isl_size isl_map_domain_tuple_dim(
1250                 __isl_keep isl_map *map);
1251         isl_size isl_map_range_tuple_dim(
1252                 __isl_keep isl_map *map);
1253         isl_size isl_map_dim(__isl_keep isl_map *map,
1254                 enum isl_dim_type type);
1256         #include <isl/union_map.h>
1257         isl_size isl_union_map_dim(__isl_keep isl_union_map *umap,
1258                 enum isl_dim_type type);
1260         #include <isl/val.h>
1261         isl_size isl_multi_val_dim(__isl_keep isl_multi_val *mv,
1262                 enum isl_dim_type type);
1264         #include <isl/aff.h>
1265         isl_size isl_aff_dim(__isl_keep isl_aff *aff,
1266                 enum isl_dim_type type);
1267         isl_size isl_multi_aff_dim(__isl_keep isl_multi_aff *maff,
1268                 enum isl_dim_type type);
1269         isl_size isl_pw_aff_dim(__isl_keep isl_pw_aff *pwaff,
1270                 enum isl_dim_type type);
1271         isl_size isl_pw_multi_aff_dim(
1272                 __isl_keep isl_pw_multi_aff *pma,
1273                 enum isl_dim_type type);
1274         isl_size isl_multi_pw_aff_dim(
1275                 __isl_keep isl_multi_pw_aff *mpa,
1276                 enum isl_dim_type type);
1277         isl_size isl_union_pw_aff_dim(
1278                 __isl_keep isl_union_pw_aff *upa,
1279                 enum isl_dim_type type);
1280         isl_size isl_union_pw_multi_aff_dim(
1281                 __isl_keep isl_union_pw_multi_aff *upma,
1282                 enum isl_dim_type type);
1283         isl_size isl_multi_union_pw_aff_dim(
1284                 __isl_keep isl_multi_union_pw_aff *mupa,
1285                 enum isl_dim_type type);
1287         #include <isl/polynomial.h>
1288         isl_size isl_union_pw_qpolynomial_dim(
1289                 __isl_keep isl_union_pw_qpolynomial *upwqp,
1290                 enum isl_dim_type type);
1291         isl_size isl_union_pw_qpolynomial_fold_dim(
1292                 __isl_keep isl_union_pw_qpolynomial_fold *upwf,
1293                 enum isl_dim_type type);
1295 Note that an C<isl_union_set>, an C<isl_union_map>,
1296 an C<isl_union_pw_multi_aff>,
1297 an C<isl_union_pw_qpolynomial> and
1298 an C<isl_union_pw_qpolynomial_fold>
1299 only have parameters.
1301 Additional parameters can be added to a space using the following function.
1303         #include <isl/space.h>
1304         __isl_give isl_space *isl_space_add_param_id(
1305                 __isl_take isl_space *space,
1306                 __isl_take isl_id *id);
1308 If a parameter with the given identifier already appears in the space,
1309 then it is not added again.
1311 Conversely, all parameters can be removed from a space
1312 using the following function.
1314         #include <isl/space.h>
1315         __isl_give isl_space *isl_space_drop_all_params(
1316                 __isl_take isl_space *space);
1318 The identifiers or names of the individual dimensions of spaces
1319 may be set or read off using the following functions on spaces
1320 or objects that live in spaces.
1321 These functions are mostly useful to obtain the identifiers, positions
1322 or names of the parameters.  Identifiers of individual dimensions are
1323 essentially only useful for printing.  They are ignored by all other
1324 operations and may not be preserved across those operations.
1325 To keep track of a space along with names/identifiers of
1326 the set dimensions, use an C<isl_multi_id> as described in
1327 L</"Functions">.
1329         #include <isl/space.h>
1330         __isl_give isl_space *isl_space_set_dim_id(
1331                 __isl_take isl_space *space,
1332                 enum isl_dim_type type, unsigned pos,
1333                 __isl_take isl_id *id);
1334         isl_bool isl_space_has_dim_id(__isl_keep isl_space *space,
1335                 enum isl_dim_type type, unsigned pos);
1336         __isl_give isl_id *isl_space_get_dim_id(
1337                 __isl_keep isl_space *space,
1338                 enum isl_dim_type type, unsigned pos);
1339         __isl_give isl_space *isl_space_set_dim_name(
1340                 __isl_take isl_space *space,
1341                  enum isl_dim_type type, unsigned pos,
1342                  __isl_keep const char *name);
1343         isl_bool isl_space_has_dim_name(__isl_keep isl_space *space,
1344                 enum isl_dim_type type, unsigned pos);
1345         __isl_keep const char *isl_space_get_dim_name(
1346                 __isl_keep isl_space *space,
1347                 enum isl_dim_type type, unsigned pos);
1349         #include <isl/local_space.h>
1350         __isl_give isl_local_space *isl_local_space_set_dim_id(
1351                 __isl_take isl_local_space *ls,
1352                 enum isl_dim_type type, unsigned pos,
1353                 __isl_take isl_id *id);
1354         isl_bool isl_local_space_has_dim_id(
1355                 __isl_keep isl_local_space *ls,
1356                 enum isl_dim_type type, unsigned pos);
1357         __isl_give isl_id *isl_local_space_get_dim_id(
1358                 __isl_keep isl_local_space *ls,
1359                 enum isl_dim_type type, unsigned pos);
1360         __isl_give isl_local_space *isl_local_space_set_dim_name(
1361                 __isl_take isl_local_space *ls,
1362                 enum isl_dim_type type, unsigned pos, const char *s);
1363         isl_bool isl_local_space_has_dim_name(
1364                 __isl_keep isl_local_space *ls,
1365                 enum isl_dim_type type, unsigned pos)
1366         const char *isl_local_space_get_dim_name(
1367                 __isl_keep isl_local_space *ls,
1368                 enum isl_dim_type type, unsigned pos);
1370         #include <isl/constraint.h>
1371         const char *isl_constraint_get_dim_name(
1372                 __isl_keep isl_constraint *constraint,
1373                 enum isl_dim_type type, unsigned pos);
1375         #include <isl/set.h>
1376         __isl_give isl_id *isl_basic_set_get_dim_id(
1377                 __isl_keep isl_basic_set *bset,
1378                 enum isl_dim_type type, unsigned pos);
1379         __isl_give isl_set *isl_set_set_dim_id(
1380                 __isl_take isl_set *set, enum isl_dim_type type,
1381                 unsigned pos, __isl_take isl_id *id);
1382         isl_bool isl_set_has_dim_id(__isl_keep isl_set *set,
1383                 enum isl_dim_type type, unsigned pos);
1384         __isl_give isl_id *isl_set_get_dim_id(
1385                 __isl_keep isl_set *set, enum isl_dim_type type,
1386                 unsigned pos);
1387         const char *isl_basic_set_get_dim_name(
1388                 __isl_keep isl_basic_set *bset,
1389                 enum isl_dim_type type, unsigned pos);
1390         isl_bool isl_set_has_dim_name(__isl_keep isl_set *set,
1391                 enum isl_dim_type type, unsigned pos);
1392         const char *isl_set_get_dim_name(
1393                 __isl_keep isl_set *set,
1394                 enum isl_dim_type type, unsigned pos);
1396         #include <isl/map.h>
1397         __isl_give isl_map *isl_map_set_dim_id(
1398                 __isl_take isl_map *map, enum isl_dim_type type,
1399                 unsigned pos, __isl_take isl_id *id);
1400         isl_bool isl_basic_map_has_dim_id(
1401                 __isl_keep isl_basic_map *bmap,
1402                 enum isl_dim_type type, unsigned pos);
1403         isl_bool isl_map_has_dim_id(__isl_keep isl_map *map,
1404                 enum isl_dim_type type, unsigned pos);
1405         __isl_give isl_id *isl_map_get_dim_id(
1406                 __isl_keep isl_map *map, enum isl_dim_type type,
1407                 unsigned pos);
1408         __isl_give isl_id *isl_union_map_get_dim_id(
1409                 __isl_keep isl_union_map *umap,
1410                 enum isl_dim_type type, unsigned pos);
1411         const char *isl_basic_map_get_dim_name(
1412                 __isl_keep isl_basic_map *bmap,
1413                 enum isl_dim_type type, unsigned pos);
1414         isl_bool isl_map_has_dim_name(__isl_keep isl_map *map,
1415                 enum isl_dim_type type, unsigned pos);
1416         const char *isl_map_get_dim_name(
1417                 __isl_keep isl_map *map,
1418                 enum isl_dim_type type, unsigned pos);
1420         #include <isl/val.h>
1421         __isl_give isl_multi_val *isl_multi_val_set_dim_id(
1422                 __isl_take isl_multi_val *mv,
1423                 enum isl_dim_type type, unsigned pos,
1424                 __isl_take isl_id *id);
1425         __isl_give isl_id *isl_multi_val_get_dim_id(
1426                 __isl_keep isl_multi_val *mv,
1427                 enum isl_dim_type type, unsigned pos);
1428         __isl_give isl_multi_val *isl_multi_val_set_dim_name(
1429                 __isl_take isl_multi_val *mv,
1430                 enum isl_dim_type type, unsigned pos, const char *s);
1432         #include <isl/aff.h>
1433         __isl_give isl_aff *isl_aff_set_dim_id(
1434                 __isl_take isl_aff *aff, enum isl_dim_type type,
1435                 unsigned pos, __isl_take isl_id *id);
1436         __isl_give isl_multi_aff *isl_multi_aff_set_dim_id(
1437                 __isl_take isl_multi_aff *maff,
1438                 enum isl_dim_type type, unsigned pos,
1439                 __isl_take isl_id *id);
1440         __isl_give isl_pw_aff *isl_pw_aff_set_dim_id(
1441                 __isl_take isl_pw_aff *pma,
1442                 enum isl_dim_type type, unsigned pos,
1443                 __isl_take isl_id *id);
1444         __isl_give isl_multi_pw_aff *
1445         isl_multi_pw_aff_set_dim_id(
1446                 __isl_take isl_multi_pw_aff *mpa,
1447                 enum isl_dim_type type, unsigned pos,
1448                 __isl_take isl_id *id);
1449         __isl_give isl_multi_union_pw_aff *
1450         isl_multi_union_pw_aff_set_dim_id(
1451                 __isl_take isl_multi_union_pw_aff *mupa,
1452                 enum isl_dim_type type, unsigned pos,
1453                 __isl_take isl_id *id);
1454         __isl_give isl_id *isl_multi_aff_get_dim_id(
1455                 __isl_keep isl_multi_aff *ma,
1456                 enum isl_dim_type type, unsigned pos);
1457         isl_bool isl_pw_aff_has_dim_id(__isl_keep isl_pw_aff *pa,
1458                 enum isl_dim_type type, unsigned pos);
1459         __isl_give isl_id *isl_pw_aff_get_dim_id(
1460                 __isl_keep isl_pw_aff *pa,
1461                 enum isl_dim_type type, unsigned pos);
1462         __isl_give isl_id *isl_pw_multi_aff_get_dim_id(
1463                 __isl_keep isl_pw_multi_aff *pma,
1464                 enum isl_dim_type type, unsigned pos);
1465         __isl_give isl_id *isl_multi_pw_aff_get_dim_id(
1466                 __isl_keep isl_multi_pw_aff *mpa,
1467                 enum isl_dim_type type, unsigned pos);
1468         __isl_give isl_id *isl_multi_union_pw_aff_get_dim_id(
1469                 __isl_keep isl_multi_union_pw_aff *mupa,
1470                 enum isl_dim_type type, unsigned pos);
1471         __isl_give isl_aff *isl_aff_set_dim_name(
1472                 __isl_take isl_aff *aff, enum isl_dim_type type,
1473                 unsigned pos, const char *s);
1474         __isl_give isl_multi_aff *isl_multi_aff_set_dim_name(
1475                 __isl_take isl_multi_aff *maff,
1476                 enum isl_dim_type type, unsigned pos, const char *s);
1477         __isl_give isl_multi_pw_aff *
1478         isl_multi_pw_aff_set_dim_name(
1479                 __isl_take isl_multi_pw_aff *mpa,
1480                 enum isl_dim_type type, unsigned pos, const char *s);
1481         __isl_give isl_union_pw_aff *
1482         isl_union_pw_aff_set_dim_name(
1483                 __isl_take isl_union_pw_aff *upa,
1484                 enum isl_dim_type type, unsigned pos,
1485                 const char *s);
1486         __isl_give isl_union_pw_multi_aff *
1487         isl_union_pw_multi_aff_set_dim_name(
1488                 __isl_take isl_union_pw_multi_aff *upma,
1489                 enum isl_dim_type type, unsigned pos,
1490                 const char *s);
1491         __isl_give isl_multi_union_pw_aff *
1492         isl_multi_union_pw_aff_set_dim_name(
1493                 __isl_take isl_multi_union_pw_aff *mupa,
1494                 enum isl_dim_type type, unsigned pos,
1495                 const char *s);
1496         const char *isl_aff_get_dim_name(__isl_keep isl_aff *aff,
1497                 enum isl_dim_type type, unsigned pos);
1498         const char *isl_pw_aff_get_dim_name(
1499                 __isl_keep isl_pw_aff *pa,
1500                 enum isl_dim_type type, unsigned pos);
1501         const char *isl_pw_multi_aff_get_dim_name(
1502                 __isl_keep isl_pw_multi_aff *pma,
1503                 enum isl_dim_type type, unsigned pos);
1505         #include <isl/polynomial.h>
1506         __isl_give isl_qpolynomial *isl_qpolynomial_set_dim_name(
1507                 __isl_take isl_qpolynomial *qp,
1508                 enum isl_dim_type type, unsigned pos,
1509                 const char *s);
1510         __isl_give isl_pw_qpolynomial *
1511         isl_pw_qpolynomial_set_dim_name(
1512                 __isl_take isl_pw_qpolynomial *pwqp,
1513                 enum isl_dim_type type, unsigned pos,
1514                 const char *s);
1515         __isl_give isl_pw_qpolynomial_fold *
1516         isl_pw_qpolynomial_fold_set_dim_name(
1517                 __isl_take isl_pw_qpolynomial_fold *pwf,
1518                 enum isl_dim_type type, unsigned pos,
1519                 const char *s);
1520         __isl_give isl_union_pw_qpolynomial *
1521         isl_union_pw_qpolynomial_set_dim_name(
1522                 __isl_take isl_union_pw_qpolynomial *upwqp,
1523                 enum isl_dim_type type, unsigned pos,
1524                 const char *s);
1525         __isl_give isl_union_pw_qpolynomial_fold *
1526         isl_union_pw_qpolynomial_fold_set_dim_name(
1527                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
1528                 enum isl_dim_type type, unsigned pos,
1529                 const char *s);
1531 Note that C<isl_space_get_name> returns a pointer to some internal
1532 data structure, so the result can only be used while the
1533 corresponding C<isl_space> is alive.
1534 Also note that every function that operates on two sets or relations
1535 requires that both arguments have the same parameters.  This also
1536 means that if one of the arguments has named parameters, then the
1537 other needs to have named parameters too and the names need to match.
1538 Pairs of C<isl_set>, C<isl_map>, C<isl_union_set> and/or C<isl_union_map>
1539 arguments may have different parameters (as long as they are named),
1540 in which case the result will have as parameters the union of the parameters of
1541 the arguments.
1543 Given the identifier or name of a dimension (typically a parameter),
1544 its position can be obtained from the following functions.
1546         #include <isl/space.h>
1547         int isl_space_find_dim_by_id(__isl_keep isl_space *space,
1548                 enum isl_dim_type type, __isl_keep isl_id *id);
1549         int isl_space_find_dim_by_name(__isl_keep isl_space *space,
1550                 enum isl_dim_type type, const char *name);
1552         #include <isl/local_space.h>
1553         int isl_local_space_find_dim_by_name(
1554                 __isl_keep isl_local_space *ls,
1555                 enum isl_dim_type type, const char *name);
1557         #include <isl/val.h>
1558         int isl_multi_val_find_dim_by_id(
1559                 __isl_keep isl_multi_val *mv,
1560                 enum isl_dim_type type, __isl_keep isl_id *id);
1561         int isl_multi_val_find_dim_by_name(
1562                 __isl_keep isl_multi_val *mv,
1563                 enum isl_dim_type type, const char *name);
1565         #include <isl/set.h>
1566         int isl_set_find_dim_by_id(__isl_keep isl_set *set,
1567                 enum isl_dim_type type, __isl_keep isl_id *id);
1568         int isl_set_find_dim_by_name(__isl_keep isl_set *set,
1569                 enum isl_dim_type type, const char *name);
1571         #include <isl/map.h>
1572         int isl_map_find_dim_by_id(__isl_keep isl_map *map,
1573                 enum isl_dim_type type, __isl_keep isl_id *id);
1574         int isl_basic_map_find_dim_by_name(
1575                 __isl_keep isl_basic_map *bmap,
1576                 enum isl_dim_type type, const char *name);
1577         int isl_map_find_dim_by_name(__isl_keep isl_map *map,
1578                 enum isl_dim_type type, const char *name);
1579         int isl_union_map_find_dim_by_name(
1580                 __isl_keep isl_union_map *umap,
1581                 enum isl_dim_type type, const char *name);
1583         #include <isl/aff.h>
1584         int isl_multi_aff_find_dim_by_id(
1585                 __isl_keep isl_multi_aff *ma,
1586                 enum isl_dim_type type, __isl_keep isl_id *id);
1587         int isl_multi_pw_aff_find_dim_by_id(
1588                 __isl_keep isl_multi_pw_aff *mpa,
1589                 enum isl_dim_type type, __isl_keep isl_id *id);
1590         int isl_multi_union_pw_aff_find_dim_by_id(
1591                 __isl_keep isl_multi_union_pw_aff *mupa,
1592                 enum isl_dim_type type, __isl_keep isl_id *id);
1593         int isl_aff_find_dim_by_name(__isl_keep isl_aff *aff,
1594                 enum isl_dim_type type, const char *name);
1595         int isl_multi_aff_find_dim_by_name(
1596                 __isl_keep isl_multi_aff *ma,
1597                 enum isl_dim_type type, const char *name);
1598         int isl_pw_aff_find_dim_by_name(__isl_keep isl_pw_aff *pa,
1599                 enum isl_dim_type type, const char *name);
1600         int isl_multi_pw_aff_find_dim_by_name(
1601                 __isl_keep isl_multi_pw_aff *mpa,
1602                 enum isl_dim_type type, const char *name);
1603         int isl_pw_multi_aff_find_dim_by_name(
1604                 __isl_keep isl_pw_multi_aff *pma,
1605                 enum isl_dim_type type, const char *name);
1606         int isl_union_pw_aff_find_dim_by_name(
1607                 __isl_keep isl_union_pw_aff *upa,
1608                 enum isl_dim_type type, const char *name);
1609         int isl_union_pw_multi_aff_find_dim_by_name(
1610                 __isl_keep isl_union_pw_multi_aff *upma,
1611                 enum isl_dim_type type, const char *name);
1612         int isl_multi_union_pw_aff_find_dim_by_name(
1613                 __isl_keep isl_multi_union_pw_aff *mupa,
1614                 enum isl_dim_type type, const char *name);
1616         #include <isl/polynomial.h>
1617         int isl_pw_qpolynomial_find_dim_by_name(
1618                 __isl_keep isl_pw_qpolynomial *pwqp,
1619                 enum isl_dim_type type, const char *name);
1620         int isl_pw_qpolynomial_fold_find_dim_by_name(
1621                 __isl_keep isl_pw_qpolynomial_fold *pwf,
1622                 enum isl_dim_type type, const char *name);
1623         int isl_union_pw_qpolynomial_find_dim_by_name(
1624                 __isl_keep isl_union_pw_qpolynomial *upwqp,
1625                 enum isl_dim_type type, const char *name);
1626         int isl_union_pw_qpolynomial_fold_find_dim_by_name(
1627                 __isl_keep isl_union_pw_qpolynomial_fold *upwf,
1628                 enum isl_dim_type type, const char *name);
1630 The identifiers or names of entire spaces may be set or read off
1631 using the following functions.
1633         #include <isl/space.h>
1634         __isl_give isl_space *isl_space_set_domain_tuple_id(
1635                 __isl_take isl_space *space,
1636                 __isl_take isl_id *id);
1637         __isl_give isl_space *isl_space_set_range_tuple_id(
1638                 __isl_take isl_space *space,
1639                 __isl_take isl_id *id);
1640         __isl_give isl_space *isl_space_set_tuple_id(
1641                 __isl_take isl_space *space,
1642                 enum isl_dim_type type, __isl_take isl_id *id);
1643         __isl_give isl_space *isl_space_reset_tuple_id(
1644                 __isl_take isl_space *space, enum isl_dim_type type);
1645         isl_bool isl_space_has_domain_tuple_id(
1646                 __isl_keep isl_space *space);
1647         isl_bool isl_space_has_range_tuple_id(
1648                 __isl_keep isl_space *space);
1649         isl_bool isl_space_has_tuple_id(
1650                 __isl_keep isl_space *space,
1651                 enum isl_dim_type type);
1652         __isl_give isl_id *isl_space_get_domain_tuple_id(
1653                 __isl_keep isl_space *space);
1654         __isl_give isl_id *isl_space_get_range_tuple_id(
1655                 __isl_keep isl_space *space);
1656         __isl_give isl_id *isl_space_get_tuple_id(
1657                 __isl_keep isl_space *space, enum isl_dim_type type);
1658         __isl_give isl_space *isl_space_set_tuple_name(
1659                 __isl_take isl_space *space,
1660                 enum isl_dim_type type, const char *s);
1661         isl_bool isl_space_has_tuple_name(
1662                 __isl_keep isl_space *space,
1663                 enum isl_dim_type type);
1664         __isl_keep const char *isl_space_get_tuple_name(
1665                 __isl_keep isl_space *space,
1666                 enum isl_dim_type type);
1668         #include <isl/local_space.h>
1669         __isl_give isl_local_space *isl_local_space_set_tuple_id(
1670                 __isl_take isl_local_space *ls,
1671                 enum isl_dim_type type, __isl_take isl_id *id);
1673         #include <isl/set.h>
1674         __isl_give isl_basic_set *isl_basic_set_set_tuple_id(
1675                 __isl_take isl_basic_set *bset,
1676                 __isl_take isl_id *id);
1677         __isl_give isl_set *isl_set_set_tuple_id(
1678                 __isl_take isl_set *set, __isl_take isl_id *id);
1679         __isl_give isl_set *isl_set_reset_tuple_id(
1680                 __isl_take isl_set *set);
1681         isl_bool isl_set_has_tuple_id(__isl_keep isl_set *set);
1682         __isl_give isl_id *isl_set_get_tuple_id(
1683                 __isl_keep isl_set *set);
1684         __isl_give isl_basic_set *isl_basic_set_set_tuple_name(
1685                 __isl_take isl_basic_set *set, const char *s);
1686         __isl_give isl_set *isl_set_set_tuple_name(
1687                 __isl_take isl_set *set, const char *s);
1688         const char *isl_basic_set_get_tuple_name(
1689                 __isl_keep isl_basic_set *bset);
1690         isl_bool isl_set_has_tuple_name(__isl_keep isl_set *set);
1691         const char *isl_set_get_tuple_name(
1692                 __isl_keep isl_set *set);
1694         #include <isl/map.h>
1695         __isl_give isl_basic_map *isl_basic_map_set_tuple_id(
1696                 __isl_take isl_basic_map *bmap,
1697                 enum isl_dim_type type, __isl_take isl_id *id);
1698         __isl_give isl_map *isl_map_set_domain_tuple_id(
1699                 __isl_take isl_map *map, __isl_take isl_id *id);
1700         __isl_give isl_map *isl_map_set_range_tuple_id(
1701                 __isl_take isl_map *map, __isl_take isl_id *id);
1702         __isl_give isl_map *isl_map_set_tuple_id(
1703                 __isl_take isl_map *map, enum isl_dim_type type,
1704                 __isl_take isl_id *id);
1705         __isl_give isl_map *isl_map_reset_tuple_id(
1706                 __isl_take isl_map *map, enum isl_dim_type type);
1707         isl_bool isl_map_has_domain_tuple_id(
1708                 __isl_keep isl_map *map);
1709         isl_bool isl_map_has_range_tuple_id(
1710                 __isl_keep isl_map *map);
1711         isl_bool isl_map_has_tuple_id(__isl_keep isl_map *map,
1712                 enum isl_dim_type type);
1713         __isl_give isl_id *isl_map_get_domain_tuple_id(
1714                 __isl_keep isl_map *map);
1715         __isl_give isl_id *isl_map_get_range_tuple_id(
1716                 __isl_keep isl_map *map);
1717         __isl_give isl_id *isl_map_get_tuple_id(
1718                 __isl_keep isl_map *map, enum isl_dim_type type);
1719         __isl_give isl_map *isl_map_set_tuple_name(
1720                 __isl_take isl_map *map,
1721                 enum isl_dim_type type, const char *s);
1722         const char *isl_basic_map_get_tuple_name(
1723                 __isl_keep isl_basic_map *bmap,
1724                 enum isl_dim_type type);
1725         __isl_give isl_basic_map *isl_basic_map_set_tuple_name(
1726                 __isl_take isl_basic_map *bmap,
1727                 enum isl_dim_type type, const char *s);
1728         isl_bool isl_map_has_tuple_name(__isl_keep isl_map *map,
1729                 enum isl_dim_type type);
1730         const char *isl_map_get_tuple_name(
1731                 __isl_keep isl_map *map,
1732                 enum isl_dim_type type);
1734         #include <isl/val.h>
1735         __isl_give isl_multi_val *isl_multi_val_set_range_tuple_id(
1736                 __isl_take isl_multi_val *mv,
1737                 __isl_take isl_id *id);
1738         __isl_give isl_multi_val *isl_multi_val_set_tuple_id(
1739                 __isl_take isl_multi_val *mv,
1740                 enum isl_dim_type type, __isl_take isl_id *id);
1741         __isl_give isl_multi_val *
1742         isl_multi_val_reset_range_tuple_id(
1743                 __isl_take isl_multi_val *mv);
1744         __isl_give isl_multi_val *isl_multi_val_reset_tuple_id(
1745                 __isl_take isl_multi_val *mv,
1746                 enum isl_dim_type type);
1747         isl_bool isl_multi_val_has_range_tuple_id(
1748                 __isl_keep isl_multi_val *mv);
1749         __isl_give isl_id *isl_multi_val_get_range_tuple_id(
1750                 __isl_keep isl_multi_val *mv);
1751         isl_bool isl_multi_val_has_tuple_id(
1752                 __isl_keep isl_multi_val *mv,
1753                 enum isl_dim_type type);
1754         __isl_give isl_id *isl_multi_val_get_tuple_id(
1755                 __isl_keep isl_multi_val *mv,
1756                 enum isl_dim_type type);
1757         __isl_give isl_multi_val *isl_multi_val_set_tuple_name(
1758                 __isl_take isl_multi_val *mv,
1759                 enum isl_dim_type type, const char *s);
1760         const char *isl_multi_val_get_tuple_name(
1761                 __isl_keep isl_multi_val *mv,
1762                 enum isl_dim_type type);
1764         #include <isl/aff.h>
1765         __isl_give isl_aff *isl_aff_set_tuple_id(
1766                 __isl_take isl_aff *aff,
1767                 enum isl_dim_type type, __isl_take isl_id *id);
1768         __isl_give isl_multi_aff *isl_multi_aff_set_range_tuple_id(
1769                 __isl_take isl_multi_aff *ma,
1770                 __isl_take isl_id *id);
1771         __isl_give isl_multi_aff *isl_multi_aff_set_tuple_id(
1772                 __isl_take isl_multi_aff *maff,
1773                 enum isl_dim_type type, __isl_take isl_id *id);
1774         __isl_give isl_pw_aff *isl_pw_aff_set_tuple_id(
1775                 __isl_take isl_pw_aff *pwaff,
1776                 enum isl_dim_type type, __isl_take isl_id *id);
1777         __isl_give isl_pw_multi_aff *
1778         isl_pw_multi_aff_set_range_tuple_id(
1779                 __isl_take isl_pw_multi_aff *pma,
1780                 __isl_take isl_id *id);
1781         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_tuple_id(
1782                 __isl_take isl_pw_multi_aff *pma,
1783                 enum isl_dim_type type, __isl_take isl_id *id);
1784         __isl_give isl_multi_pw_aff *
1785         isl_multi_pw_aff_set_range_tuple_id(
1786                 __isl_take isl_multi_pw_aff *mpa,
1787                 __isl_take isl_id *id);
1788         __isl_give isl_multi_union_pw_aff *
1789         isl_multi_union_pw_aff_set_range_tuple_id(
1790                 __isl_take isl_multi_union_pw_aff *mupa,
1791                 __isl_take isl_id *id);
1792         __isl_give isl_multi_union_pw_aff *
1793         isl_multi_union_pw_aff_set_tuple_id(
1794                 __isl_take isl_multi_union_pw_aff *mupa,
1795                 enum isl_dim_type type, __isl_take isl_id *id);
1796         __isl_give isl_multi_aff *
1797         isl_multi_aff_reset_range_tuple_id(
1798                 __isl_take isl_multi_aff *ma);
1799         __isl_give isl_multi_pw_aff *
1800         isl_multi_pw_aff_reset_range_tuple_id(
1801                 __isl_take isl_multi_pw_aff *mpa);
1802         __isl_give isl_multi_union_pw_aff *
1803         isl_multi_union_pw_aff_reset_range_tuple_id(
1804                 __isl_take isl_multi_union_pw_aff *mupa);
1805         __isl_give isl_multi_aff *isl_multi_aff_reset_tuple_id(
1806                 __isl_take isl_multi_aff *ma,
1807                 enum isl_dim_type type);
1808         __isl_give isl_pw_aff *isl_pw_aff_reset_tuple_id(
1809                 __isl_take isl_pw_aff *pa,
1810                 enum isl_dim_type type);
1811         __isl_give isl_multi_pw_aff *
1812         isl_multi_pw_aff_reset_tuple_id(
1813                 __isl_take isl_multi_pw_aff *mpa,
1814                 enum isl_dim_type type);
1815         __isl_give isl_pw_multi_aff *
1816         isl_pw_multi_aff_reset_tuple_id(
1817                 __isl_take isl_pw_multi_aff *pma,
1818                 enum isl_dim_type type);
1819         __isl_give isl_multi_union_pw_aff *
1820         isl_multi_union_pw_aff_reset_tuple_id(
1821                 __isl_take isl_multi_union_pw_aff *mupa,
1822                 enum isl_dim_type type);
1823         isl_bool isl_multi_aff_has_range_tuple_id(
1824                 __isl_keep isl_multi_aff *ma);
1825         __isl_give isl_id *isl_multi_aff_get_range_tuple_id(
1826                 __isl_keep isl_multi_aff *ma);
1827         isl_bool isl_multi_aff_has_tuple_id(
1828                 __isl_keep isl_multi_aff *ma,
1829                 enum isl_dim_type type);
1830         __isl_give isl_id *isl_multi_aff_get_tuple_id(
1831                 __isl_keep isl_multi_aff *ma,
1832                 enum isl_dim_type type);
1833         isl_bool isl_pw_aff_has_tuple_id(__isl_keep isl_pw_aff *pa,
1834                 enum isl_dim_type type);
1835         __isl_give isl_id *isl_pw_aff_get_tuple_id(
1836                 __isl_keep isl_pw_aff *pa,
1837                 enum isl_dim_type type);
1838         isl_bool isl_pw_multi_aff_has_range_tuple_id(
1839                 __isl_keep isl_pw_multi_aff *pma);
1840         isl_bool isl_pw_multi_aff_has_tuple_id(
1841                 __isl_keep isl_pw_multi_aff *pma,
1842                 enum isl_dim_type type);
1843         __isl_give isl_id *isl_pw_multi_aff_get_range_tuple_id(
1844                 __isl_keep isl_pw_multi_aff *pma);
1845         __isl_give isl_id *isl_pw_multi_aff_get_tuple_id(
1846                 __isl_keep isl_pw_multi_aff *pma,
1847                 enum isl_dim_type type);
1848         isl_bool isl_multi_pw_aff_has_range_tuple_id(
1849                 __isl_keep isl_multi_pw_aff *mpa);
1850         __isl_give isl_id *isl_multi_pw_aff_get_range_tuple_id(
1851                 __isl_keep isl_multi_pw_aff *mpa);
1852         isl_bool isl_multi_pw_aff_has_tuple_id(
1853                 __isl_keep isl_multi_pw_aff *mpa,
1854                 enum isl_dim_type type);
1855         __isl_give isl_id *isl_multi_pw_aff_get_tuple_id(
1856                 __isl_keep isl_multi_pw_aff *mpa,
1857                 enum isl_dim_type type);
1858         isl_bool isl_multi_union_pw_aff_has_range_tuple_id(
1859                 __isl_keep isl_multi_union_pw_aff *mupa);
1860         __isl_give isl_id *
1861         isl_multi_union_pw_aff_get_range_tuple_id(
1862                 __isl_keep isl_multi_union_pw_aff *mupa);
1863         isl_bool isl_multi_union_pw_aff_has_tuple_id(
1864                 __isl_keep isl_multi_union_pw_aff *mupa,
1865                 enum isl_dim_type type);
1866         __isl_give isl_id *isl_multi_union_pw_aff_get_tuple_id(
1867                 __isl_keep isl_multi_union_pw_aff *mupa,
1868                 enum isl_dim_type type);
1869         __isl_give isl_multi_aff *isl_multi_aff_set_tuple_name(
1870                 __isl_take isl_multi_aff *maff,
1871                 enum isl_dim_type type, const char *s);
1872         __isl_give isl_multi_pw_aff *
1873         isl_multi_pw_aff_set_tuple_name(
1874                 __isl_take isl_multi_pw_aff *mpa,
1875                 enum isl_dim_type type, const char *s);
1876         __isl_give isl_multi_union_pw_aff *
1877         isl_multi_union_pw_aff_set_tuple_name(
1878                 __isl_take isl_multi_union_pw_aff *mupa,
1879                 enum isl_dim_type type, const char *s);
1880         const char *isl_multi_aff_get_tuple_name(
1881                 __isl_keep isl_multi_aff *multi,
1882                 enum isl_dim_type type);
1883         isl_bool isl_pw_multi_aff_has_tuple_name(
1884                 __isl_keep isl_pw_multi_aff *pma,
1885                 enum isl_dim_type type);
1886         const char *isl_pw_multi_aff_get_tuple_name(
1887                 __isl_keep isl_pw_multi_aff *pma,
1888                 enum isl_dim_type type);
1889         const char *isl_multi_union_pw_aff_get_tuple_name(
1890                 __isl_keep isl_multi_union_pw_aff *mupa,
1891                 enum isl_dim_type type);
1893 The C<type> argument needs to be one of C<isl_dim_in>, C<isl_dim_out>
1894 or C<isl_dim_set>.  As with C<isl_space_get_name>,
1895 the C<isl_space_get_tuple_name> function returns a pointer to some internal
1896 data structure.
1897 Binary operations require the corresponding spaces of their arguments
1898 to have the same name.
1900 To keep the names of all parameters and tuples, but reset the user pointers
1901 of all the corresponding identifiers, use the following function.
1903         #include <isl/space.h>
1904         __isl_give isl_space *isl_space_reset_user(
1905                 __isl_take isl_space *space);
1907         #include <isl/set.h>
1908         __isl_give isl_set *isl_set_reset_user(
1909                 __isl_take isl_set *set);
1911         #include <isl/map.h>
1912         __isl_give isl_map *isl_map_reset_user(
1913                 __isl_take isl_map *map);
1915         #include <isl/union_set.h>
1916         __isl_give isl_union_set *isl_union_set_reset_user(
1917                 __isl_take isl_union_set *uset);
1919         #include <isl/union_map.h>
1920         __isl_give isl_union_map *isl_union_map_reset_user(
1921                 __isl_take isl_union_map *umap);
1923         #include <isl/id.h>
1924         __isl_give isl_multi_id *isl_multi_id_reset_user(
1925                 __isl_take isl_multi_id *mi);
1927         #include <isl/val.h>
1928         __isl_give isl_multi_val *isl_multi_val_reset_user(
1929                 __isl_take isl_multi_val *mv);
1931         #include <isl/aff.h>
1932         __isl_give isl_multi_aff *isl_multi_aff_reset_user(
1933                 __isl_take isl_multi_aff *ma);
1934         __isl_give isl_pw_aff *isl_pw_aff_reset_user(
1935                 __isl_take isl_pw_aff *pa);
1936         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_reset_user(
1937                 __isl_take isl_multi_pw_aff *mpa);
1938         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_reset_user(
1939                 __isl_take isl_pw_multi_aff *pma);
1940         __isl_give isl_union_pw_aff *isl_union_pw_aff_reset_user(
1941                 __isl_take isl_union_pw_aff *upa);
1942         __isl_give isl_multi_union_pw_aff *
1943         isl_multi_union_pw_aff_reset_user(
1944                 __isl_take isl_multi_union_pw_aff *mupa);
1945         __isl_give isl_union_pw_multi_aff *
1946         isl_union_pw_multi_aff_reset_user(
1947                 __isl_take isl_union_pw_multi_aff *upma);
1949         #include <isl/polynomial.h>
1950         __isl_give isl_pw_qpolynomial *
1951         isl_pw_qpolynomial_reset_user(
1952                 __isl_take isl_pw_qpolynomial *pwqp);
1953         __isl_give isl_union_pw_qpolynomial *
1954         isl_union_pw_qpolynomial_reset_user(
1955                 __isl_take isl_union_pw_qpolynomial *upwqp);
1956         __isl_give isl_pw_qpolynomial_fold *
1957         isl_pw_qpolynomial_fold_reset_user(
1958                 __isl_take isl_pw_qpolynomial_fold *pwf);
1959         __isl_give isl_union_pw_qpolynomial_fold *
1960         isl_union_pw_qpolynomial_fold_reset_user(
1961                 __isl_take isl_union_pw_qpolynomial_fold *upwf);
1963 Spaces can be nested.  In particular, the domain of a set or
1964 the domain or range of a relation can be a nested relation.
1965 This process is also called I<wrapping>.
1966 The functions for detecting, constructing and deconstructing
1967 such nested spaces can be found in the wrapping properties
1968 of L</"Unary Properties">, the wrapping operations
1969 of L</"Unary Operations"> and the Cartesian product operations
1970 of L</"Basic Operations">.
1972 Spaces can be created from other spaces
1973 using the functions described in L</"Unary Operations">
1974 and L</"Binary Operations">.
1976 =head2 Local Spaces
1978 A local space is essentially a space with
1979 zero or more existentially quantified variables.
1980 The local space of various objects can be obtained
1981 using the following functions.
1983         #include <isl/constraint.h>
1984         __isl_give isl_local_space *isl_constraint_get_local_space(
1985                 __isl_keep isl_constraint *constraint);
1987         #include <isl/set.h>
1988         __isl_give isl_local_space *isl_basic_set_get_local_space(
1989                 __isl_keep isl_basic_set *bset);
1991         #include <isl/map.h>
1992         __isl_give isl_local_space *isl_basic_map_get_local_space(
1993                 __isl_keep isl_basic_map *bmap);
1995         #include <isl/aff.h>
1996         __isl_give isl_local_space *isl_aff_get_domain_local_space(
1997                 __isl_keep isl_aff *aff);
1998         __isl_give isl_local_space *isl_aff_get_local_space(
1999                 __isl_keep isl_aff *aff);
2001 A new local space can be created from a space using
2003         #include <isl/local_space.h>
2004         __isl_give isl_local_space *isl_local_space_from_space(
2005                 __isl_take isl_space *space);
2007 They can be inspected, modified, copied and freed using the following functions.
2009         #include <isl/local_space.h>
2010         isl_bool isl_local_space_is_params(
2011                 __isl_keep isl_local_space *ls);
2012         isl_bool isl_local_space_is_set(
2013                 __isl_keep isl_local_space *ls);
2014         __isl_give isl_space *isl_local_space_get_space(
2015                 __isl_keep isl_local_space *ls);
2016         __isl_give isl_aff *isl_local_space_get_div(
2017                 __isl_keep isl_local_space *ls, int pos);
2018         __isl_give isl_local_space *isl_local_space_copy(
2019                 __isl_keep isl_local_space *ls);
2020         __isl_null isl_local_space *isl_local_space_free(
2021                 __isl_take isl_local_space *ls);
2023 Note that C<isl_local_space_get_div> can only be used on local spaces
2024 of sets.
2026 Two local spaces can be compared using
2028         isl_bool isl_local_space_is_equal(
2029                 __isl_keep isl_local_space *ls1,
2030                 __isl_keep isl_local_space *ls2);
2032 Local spaces can be created from other local spaces
2033 using the functions described in L</"Unary Operations">
2034 and L</"Binary Operations">.
2036 =head2 Creating New Sets and Relations
2038 C<isl> has functions for creating some standard sets and relations.
2040 =over
2042 =item * Empty sets and relations
2044         __isl_give isl_basic_set *isl_basic_set_empty(
2045                 __isl_take isl_space *space);
2046         __isl_give isl_basic_map *isl_basic_map_empty(
2047                 __isl_take isl_space *space);
2048         __isl_give isl_set *isl_set_empty(
2049                 __isl_take isl_space *space);
2050         __isl_give isl_map *isl_map_empty(
2051                 __isl_take isl_space *space);
2052         __isl_give isl_union_set *isl_union_set_empty_ctx(
2053                 isl_ctx *ctx);
2054         __isl_give isl_union_set *isl_union_set_empty_space(
2055                 __isl_take isl_space *space);
2056         __isl_give isl_union_set *isl_union_set_empty(
2057                 __isl_take isl_space *space);
2058         __isl_give isl_union_map *isl_union_map_empty_ctx(
2059                 isl_ctx *ctx);
2060         __isl_give isl_union_map *isl_union_map_empty_space(
2061                 __isl_take isl_space *space);
2062         __isl_give isl_union_map *isl_union_map_empty(
2063                 __isl_take isl_space *space);
2065 For C<isl_union_set>s and C<isl_union_map>s, the space
2066 is only used to specify the parameters.
2067 C<isl_union_set_empty> is an alternative name for
2068 C<isl_union_set_empty_space>.
2069 Similarly for the other pair of functions.
2071 =item * Universe sets and relations
2073         #include <isl/set.h>
2074         __isl_give isl_basic_set *isl_basic_set_universe(
2075                 __isl_take isl_space *space);
2076         __isl_give isl_set *isl_set_universe(
2077                 __isl_take isl_space *space);
2078         __isl_give isl_set *isl_space_universe_set(
2079                 __isl_take isl_space *space);
2081         #include <isl/map.h>
2082         __isl_give isl_basic_map *isl_basic_map_universe(
2083                 __isl_take isl_space *space);
2084         __isl_give isl_map *isl_map_universe(
2085                 __isl_take isl_space *space);
2086         __isl_give isl_map *isl_space_universe_map(
2087                 __isl_take isl_space *space);
2089         #include <isl/union_set.h>
2090         __isl_give isl_union_set *isl_union_set_universe(
2091                 __isl_take isl_union_set *uset);
2093         #include <isl/union_map.h>
2094         __isl_give isl_union_map *isl_union_map_universe(
2095                 __isl_take isl_union_map *umap);
2097 C<isl_set_universe> and C<isl_space_universe_set>
2098 perform the same operation.
2099 Similarly
2100 for the pair C<isl_map_universe> and C<isl_space_universe_map>.
2102 The sets and relations constructed by the functions above
2103 contain all integer values, while those constructed by the
2104 functions below only contain non-negative values.
2106         __isl_give isl_basic_set *isl_basic_set_nat_universe(
2107                 __isl_take isl_space *space);
2108         __isl_give isl_basic_map *isl_basic_map_nat_universe(
2109                 __isl_take isl_space *space);
2110         __isl_give isl_set *isl_set_nat_universe(
2111                 __isl_take isl_space *space);
2112         __isl_give isl_map *isl_map_nat_universe(
2113                 __isl_take isl_space *space);
2115 =item * Identity relations
2117         __isl_give isl_basic_map *isl_basic_map_identity(
2118                 __isl_take isl_space *space);
2119         __isl_give isl_map *isl_map_identity(
2120                 __isl_take isl_space *space);
2122 The number of input and output dimensions in C<space> needs
2123 to be the same.
2125 =item * Lexicographic order
2127         __isl_give isl_map *isl_map_lex_lt(
2128                 __isl_take isl_space *set_space);
2129         __isl_give isl_map *isl_map_lex_le(
2130                 __isl_take isl_space *set_space);
2131         __isl_give isl_map *isl_map_lex_gt(
2132                 __isl_take isl_space *set_space);
2133         __isl_give isl_map *isl_map_lex_ge(
2134                 __isl_take isl_space *set_space);
2135         __isl_give isl_map *isl_map_lex_lt_first(
2136                 __isl_take isl_space *space, unsigned n);
2137         __isl_give isl_map *isl_map_lex_le_first(
2138                 __isl_take isl_space *space, unsigned n);
2139         __isl_give isl_map *isl_map_lex_gt_first(
2140                 __isl_take isl_space *space, unsigned n);
2141         __isl_give isl_map *isl_map_lex_ge_first(
2142                 __isl_take isl_space *space, unsigned n);
2144 The first four functions take a space for a B<set>
2145 and return relations that express that the elements in the domain
2146 are lexicographically less
2147 (C<isl_map_lex_lt>), less or equal (C<isl_map_lex_le>),
2148 greater (C<isl_map_lex_gt>) or greater or equal (C<isl_map_lex_ge>)
2149 than the elements in the range.
2150 The last four functions take a space for a map
2151 and return relations that express that the first C<n> dimensions
2152 in the domain are lexicographically less
2153 (C<isl_map_lex_lt_first>), less or equal (C<isl_map_lex_le_first>),
2154 greater (C<isl_map_lex_gt_first>) or greater or equal (C<isl_map_lex_ge_first>)
2155 than the first C<n> dimensions in the range.
2157 =back
2159 A basic set or relation can be converted to a set or relation
2160 using the following functions.
2162         __isl_give isl_set *isl_basic_set_to_set(
2163                 __isl_take isl_basic_set *bset);
2164         __isl_give isl_set *isl_set_from_basic_set(
2165                 __isl_take isl_basic_set *bset);
2166         __isl_give isl_map *isl_map_from_basic_map(
2167                 __isl_take isl_basic_map *bmap);
2169 C<isl_basic_set_to_set> and C<isl_set_from_basic_set> perform
2170 the same operation.
2172 Sets and relations can be converted to union sets and relations
2173 using the following functions.
2175         __isl_give isl_union_set *isl_union_set_from_basic_set(
2176                 __isl_take isl_basic_set *bset);
2177         __isl_give isl_union_map *isl_union_map_from_basic_map(
2178                 __isl_take isl_basic_map *bmap);
2179         __isl_give isl_union_set *isl_set_to_union_set(
2180                 __isl_take isl_set *set);
2181         __isl_give isl_union_set *isl_union_set_from_set(
2182                 __isl_take isl_set *set);
2183         __isl_give isl_union_map *isl_map_to_union_map(
2184                 __isl_take isl_map *map);
2185         __isl_give isl_union_map *isl_union_map_from_map(
2186                 __isl_take isl_map *map);
2188 C<isl_map_to_union_map> and C<isl_union_map_from_map> perform
2189 the same operation.
2190 Similarly for C<isl_set_to_union_set> and C<isl_union_set_from_set>.
2192 The inverse conversions below can only be used if the input
2193 union set or relation is known to contain elements in exactly one
2194 space.
2196         #include <isl/union_set.h>
2197         isl_bool isl_union_set_isa_set(
2198                 __isl_keep isl_union_set *uset);
2199         __isl_give isl_set *isl_union_set_as_set(
2200                 __isl_take isl_union_set *uset);
2201         __isl_give isl_set *isl_set_from_union_set(
2202                 __isl_take isl_union_set *uset);
2204         #include <isl/union_map.h>
2205         isl_bool isl_union_map_isa_map(
2206                 __isl_keep isl_union_map *umap);
2207         __isl_give isl_map *isl_union_map_as_map(
2208                 __isl_take isl_union_map *umap);
2209         __isl_give isl_map *isl_map_from_union_map(
2210                 __isl_take isl_union_map *umap);
2212 C<isl_union_map_as_map> and C<isl_map_from_union_map> perform
2213 the same operation.
2214 Similarly for C<isl_union_set_as_set> and C<isl_set_from_union_set>.
2216 Sets and relations can be copied and freed again using the following
2217 functions.
2219         __isl_give isl_basic_set *isl_basic_set_copy(
2220                 __isl_keep isl_basic_set *bset);
2221         __isl_give isl_set *isl_set_copy(__isl_keep isl_set *set);
2222         __isl_give isl_union_set *isl_union_set_copy(
2223                 __isl_keep isl_union_set *uset);
2224         __isl_give isl_basic_map *isl_basic_map_copy(
2225                 __isl_keep isl_basic_map *bmap);
2226         __isl_give isl_map *isl_map_copy(__isl_keep isl_map *map);
2227         __isl_give isl_union_map *isl_union_map_copy(
2228                 __isl_keep isl_union_map *umap);
2229         __isl_null isl_basic_set *isl_basic_set_free(
2230                 __isl_take isl_basic_set *bset);
2231         __isl_null isl_set *isl_set_free(__isl_take isl_set *set);
2232         __isl_null isl_union_set *isl_union_set_free(
2233                 __isl_take isl_union_set *uset);
2234         __isl_null isl_basic_map *isl_basic_map_free(
2235                 __isl_take isl_basic_map *bmap);
2236         __isl_null isl_map *isl_map_free(__isl_take isl_map *map);
2237         __isl_null isl_union_map *isl_union_map_free(
2238                 __isl_take isl_union_map *umap);
2240 Other sets and relations can be constructed by starting
2241 from a universe set or relation, adding equality and/or
2242 inequality constraints and then projecting out the
2243 existentially quantified variables, if any.
2244 Constraints can be constructed, manipulated and
2245 added to (or removed from) (basic) sets and relations
2246 using the following functions.
2248         #include <isl/constraint.h>
2249         __isl_give isl_constraint *isl_constraint_alloc_equality(
2250                 __isl_take isl_local_space *ls);
2251         __isl_give isl_constraint *isl_constraint_alloc_inequality(
2252                 __isl_take isl_local_space *ls);
2253         __isl_give isl_constraint *isl_constraint_set_constant_si(
2254                 __isl_take isl_constraint *constraint, int v);
2255         __isl_give isl_constraint *isl_constraint_set_constant_val(
2256                 __isl_take isl_constraint *constraint,
2257                 __isl_take isl_val *v);
2258         __isl_give isl_constraint *isl_constraint_set_coefficient_si(
2259                 __isl_take isl_constraint *constraint,
2260                 enum isl_dim_type type, int pos, int v);
2261         __isl_give isl_constraint *
2262         isl_constraint_set_coefficient_val(
2263                 __isl_take isl_constraint *constraint,
2264                 enum isl_dim_type type, int pos,
2265                 __isl_take isl_val *v);
2266         __isl_give isl_basic_map *isl_basic_map_add_constraint(
2267                 __isl_take isl_basic_map *bmap,
2268                 __isl_take isl_constraint *constraint);
2269         __isl_give isl_basic_set *isl_basic_set_add_constraint(
2270                 __isl_take isl_basic_set *bset,
2271                 __isl_take isl_constraint *constraint);
2272         __isl_give isl_map *isl_map_add_constraint(
2273                 __isl_take isl_map *map,
2274                 __isl_take isl_constraint *constraint);
2275         __isl_give isl_set *isl_set_add_constraint(
2276                 __isl_take isl_set *set,
2277                 __isl_take isl_constraint *constraint);
2279 For example, to create a set containing the even integers
2280 between 10 and 42, you could use the following code.
2282         isl_space *space;
2283         isl_local_space *ls;
2284         isl_constraint *c;
2285         isl_basic_set *bset;
2287         space = isl_space_set_alloc(ctx, 0, 2);
2288         bset = isl_basic_set_universe(isl_space_copy(space));
2289         ls = isl_local_space_from_space(space);
2291         c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
2292         c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
2293         c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, 2);
2294         bset = isl_basic_set_add_constraint(bset, c);
2296         c = isl_constraint_alloc_inequality(isl_local_space_copy(ls));
2297         c = isl_constraint_set_constant_si(c, -10);
2298         c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
2299         bset = isl_basic_set_add_constraint(bset, c);
2301         c = isl_constraint_alloc_inequality(ls);
2302         c = isl_constraint_set_constant_si(c, 42);
2303         c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
2304         bset = isl_basic_set_add_constraint(bset, c);
2306         bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 1);
2308 However, this is considered to be a fairly low-level approach.
2309 It is more appropriate to construct a (basic) set by means
2310 of affine expressions (defined below in L</"Functions">).
2311 For example, the same set could be constructed as follows.
2313         isl_val *v, *two;
2314         isl_space *space;
2315         isl_multi_aff *ma;
2316         isl_aff *var, *cst;
2317         isl_basic_set *bset;
2319         space = isl_space_unit(ctx);
2320         space = isl_space_add_unnamed_tuple_ui(space, 1);
2321         ma = isl_multi_aff_identity_on_domain_space(
2322                 isl_space_copy(space));
2323         var = isl_multi_aff_get_at(ma, 0);
2324         v = isl_val_int_from_si(ctx, 10);
2325         cst = isl_aff_val_on_domain_space(isl_space_copy(space), v);
2326         bset = isl_aff_ge_basic_set(isl_aff_copy(var), cst);
2328         v = isl_val_int_from_si(ctx, 42);
2329         cst = isl_aff_val_on_domain_space(space, v);
2330         bset = isl_basic_set_intersect(bset,
2331                 isl_aff_le_basic_set(var, cst));
2333         two = isl_val_int_from_si(ctx, 2);
2334         ma = isl_multi_aff_scale_val(ma, isl_val_copy(two));
2335         bset = isl_basic_set_preimage_multi_aff(bset,
2336                 isl_multi_aff_copy(ma));
2337         ma = isl_multi_aff_scale_down_val(ma, isl_val_copy(two));
2338         ma = isl_multi_aff_scale_down_val(ma, two);
2339         bset = isl_basic_set_preimage_multi_aff(bset, ma);
2341 Alternatively, the set can be parsed from a string representation.
2343         isl_basic_set *bset;
2344         bset = isl_basic_set_read_from_str(ctx,
2345                 "{[i] : exists (a : i = 2a and i >= 10 and i <= 42)}");
2347 A basic set or relation can also be constructed from two matrices
2348 describing the equalities and the inequalities.
2350         __isl_give isl_basic_set *isl_basic_set_from_constraint_matrices(
2351                 __isl_take isl_space *space,
2352                 __isl_take isl_mat *eq, __isl_take isl_mat *ineq,
2353                 enum isl_dim_type c1,
2354                 enum isl_dim_type c2, enum isl_dim_type c3,
2355                 enum isl_dim_type c4);
2356         __isl_give isl_basic_map *isl_basic_map_from_constraint_matrices(
2357                 __isl_take isl_space *space,
2358                 __isl_take isl_mat *eq, __isl_take isl_mat *ineq,
2359                 enum isl_dim_type c1,
2360                 enum isl_dim_type c2, enum isl_dim_type c3,
2361                 enum isl_dim_type c4, enum isl_dim_type c5);
2363 The C<isl_dim_type> arguments indicate the order in which
2364 different kinds of variables appear in the input matrices
2365 and should be a permutation of C<isl_dim_cst> (the constant term),
2366 C<isl_dim_param>, C<isl_dim_set> and C<isl_dim_div> for sets and
2367 of C<isl_dim_cst>, C<isl_dim_param>,
2368 C<isl_dim_in>, C<isl_dim_out> and C<isl_dim_div> for relations.
2370 A (basic or union) set or relation can also be constructed from a
2371 (union) (piecewise) (multiple) affine expression
2372 or a list of affine expressions
2373 (See L</"Functions">), provided these affine expressions do not
2374 involve any NaN.
2376         #include <isl/set.h>
2377         __isl_give isl_basic_set *isl_basic_set_from_multi_aff(
2378                 __isl_take isl_multi_aff *ma);
2379         __isl_give isl_set *isl_multi_aff_as_set(
2380                 __isl_take isl_multi_aff *ma);
2381         __isl_give isl_set *isl_set_from_multi_aff(
2382                 __isl_take isl_multi_aff *ma);
2384         #include <isl/map.h>
2385         __isl_give isl_basic_map *isl_basic_map_from_aff(
2386                 __isl_take isl_aff *aff);
2387         __isl_give isl_map *isl_map_from_aff(
2388                 __isl_take isl_aff *aff);
2389         __isl_give isl_basic_map *isl_basic_map_from_aff_list(
2390                 __isl_take isl_space *domain_space,
2391                 __isl_take isl_aff_list *list);
2392         __isl_give isl_basic_map *isl_basic_map_from_multi_aff(
2393                 __isl_take isl_multi_aff *maff)
2394         __isl_give isl_map *isl_multi_aff_as_map(
2395                 __isl_take isl_multi_aff *ma);
2396         __isl_give isl_map *isl_map_from_multi_aff(
2397                 __isl_take isl_multi_aff *maff)
2399         #include <isl/aff.h>
2400         __isl_give isl_set *isl_set_from_pw_aff(
2401                 __isl_take isl_pw_aff *pwaff);
2402         __isl_give isl_map *isl_pw_aff_as_map(
2403                 __isl_take isl_pw_aff *pa);
2404         __isl_give isl_map *isl_map_from_pw_aff(
2405                 __isl_take isl_pw_aff *pwaff);
2406         __isl_give isl_set *isl_pw_multi_aff_as_set(
2407                 __isl_take isl_pw_multi_aff *pma);
2408         __isl_give isl_set *isl_set_from_pw_multi_aff(
2409                 __isl_take isl_pw_multi_aff *pma);
2410         __isl_give isl_map *isl_pw_multi_aff_as_map(
2411                 __isl_take isl_pw_multi_aff *pma);
2412         __isl_give isl_map *isl_map_from_pw_multi_aff(
2413                 __isl_take isl_pw_multi_aff *pma);
2414         __isl_give isl_set *isl_multi_pw_aff_as_set(
2415                 __isl_take isl_multi_pw_aff *mpa);
2416         __isl_give isl_set *isl_set_from_multi_pw_aff(
2417                 __isl_take isl_multi_pw_aff *mpa);
2418         __isl_give isl_map *isl_multi_pw_aff_as_map(
2419                 __isl_take isl_multi_pw_aff *mpa);
2420         __isl_give isl_map *isl_map_from_multi_pw_aff(
2421                 __isl_take isl_multi_pw_aff *mpa);
2422         __isl_give isl_union_map *isl_union_map_from_union_pw_aff(
2423                 __isl_take isl_union_pw_aff *upa);
2424         __isl_give isl_union_map *
2425         isl_union_pw_multi_aff_as_union_map(
2426                 __isl_take isl_union_pw_multi_aff *upma);
2427         __isl_give isl_union_map *
2428         isl_union_map_from_union_pw_multi_aff(
2429                 __isl_take isl_union_pw_multi_aff *upma);
2430         __isl_give isl_union_map *
2431         isl_union_map_from_multi_union_pw_aff(
2432                 __isl_take isl_multi_union_pw_aff *mupa);
2434 The C<domain_space> argument describes the domain of the resulting
2435 basic relation.  It is required because the C<list> may consist
2436 of zero affine expressions.
2437 The C<mupa> passed to C<isl_union_map_from_multi_union_pw_aff>
2438 is not allowed to be zero-dimensional.  The domain of the result
2439 is the shared domain of the union piecewise affine elements.
2440 C<isl_multi_aff_as_set> and C<isl_set_from_multi_aff> perform
2441 the same operation.
2442 Similarly for the pair C<isl_multi_aff_as_map> and C<isl_map_from_multi_aff>,
2443 for the pair C<isl_pw_aff_as_map> and C<isl_map_from_pw_aff>,
2444 for the pair C<isl_pw_multi_aff_as_set> and C<isl_set_from_pw_multi_aff>,
2445 for the pair C<isl_pw_multi_aff_as_map> and C<isl_map_from_pw_multi_aff>,
2446 the pair C<isl_multi_pw_aff_as_set> and C<isl_set_from_multi_pw_aff>,
2447 the pair C<isl_multi_pw_aff_as_map> and C<isl_map_from_multi_pw_aff>,
2449 C<isl_union_pw_multi_aff_as_union_map> and
2450 C<isl_union_map_from_union_pw_multi_aff>.
2452 =head2 Inspecting Sets and Relations
2454 Usually, the user should not have to care about the actual constraints
2455 of the sets and maps, but should instead apply the abstract operations
2456 explained in the following sections.
2457 Occasionally, however, it may be required to inspect the individual
2458 coefficients of the constraints.  This section explains how to do so.
2459 In these cases, it may also be useful to have C<isl> compute
2460 an explicit representation of the existentially quantified variables.
2462         __isl_give isl_set *isl_set_compute_divs(
2463                 __isl_take isl_set *set);
2464         __isl_give isl_map *isl_map_compute_divs(
2465                 __isl_take isl_map *map);
2466         __isl_give isl_union_set *isl_union_set_compute_divs(
2467                 __isl_take isl_union_set *uset);
2468         __isl_give isl_union_map *isl_union_map_compute_divs(
2469                 __isl_take isl_union_map *umap);
2471 This explicit representation defines the existentially quantified
2472 variables as integer divisions of the other variables, possibly
2473 including earlier existentially quantified variables.
2474 An explicitly represented existentially quantified variable therefore
2475 has a unique value when the values of the other variables are known.
2477 Alternatively, the existentially quantified variables can be removed
2478 using the following functions, which compute an overapproximation.
2480         #include <isl/set.h>
2481         __isl_give isl_basic_set *isl_basic_set_remove_divs(
2482                 __isl_take isl_basic_set *bset);
2483         __isl_give isl_set *isl_set_remove_divs(
2484                 __isl_take isl_set *set);
2486         #include <isl/map.h>
2487         __isl_give isl_basic_map *isl_basic_map_remove_divs(
2488                 __isl_take isl_basic_map *bmap);
2489         __isl_give isl_map *isl_map_remove_divs(
2490                 __isl_take isl_map *map);
2492         #include <isl/union_set.h>
2493         __isl_give isl_union_set *isl_union_set_remove_divs(
2494                 __isl_take isl_union_set *bset);
2496         #include <isl/union_map.h>
2497         __isl_give isl_union_map *isl_union_map_remove_divs(
2498                 __isl_take isl_union_map *bmap);
2500 It is also possible to only remove those divs that are defined
2501 in terms of a given range of dimensions or only those for which
2502 no explicit representation is known.
2504         __isl_give isl_basic_set *
2505         isl_basic_set_remove_divs_involving_dims(
2506                 __isl_take isl_basic_set *bset,
2507                 enum isl_dim_type type,
2508                 unsigned first, unsigned n);
2509         __isl_give isl_basic_map *
2510         isl_basic_map_remove_divs_involving_dims(
2511                 __isl_take isl_basic_map *bmap,
2512                 enum isl_dim_type type,
2513                 unsigned first, unsigned n);
2514         __isl_give isl_set *isl_set_remove_divs_involving_dims(
2515                 __isl_take isl_set *set, enum isl_dim_type type,
2516                 unsigned first, unsigned n);
2517         __isl_give isl_map *isl_map_remove_divs_involving_dims(
2518                 __isl_take isl_map *map, enum isl_dim_type type,
2519                 unsigned first, unsigned n);
2521         __isl_give isl_basic_set *
2522         isl_basic_set_remove_unknown_divs(
2523                 __isl_take isl_basic_set *bset);
2524         __isl_give isl_set *isl_set_remove_unknown_divs(
2525                 __isl_take isl_set *set);
2526         __isl_give isl_map *isl_map_remove_unknown_divs(
2527                 __isl_take isl_map *map);
2529 To iterate over all the sets or maps in a union set or map, use
2531         #include <isl/union_set.h>
2532         isl_stat isl_union_set_foreach_set(
2533                 __isl_keep isl_union_set *uset,
2534                 isl_stat (*fn)(__isl_take isl_set *set, void *user),
2535                 void *user);
2536         isl_bool isl_union_set_every_set(
2537                 __isl_keep isl_union_set *uset,
2538                 isl_bool (*test)(__isl_keep isl_set *set,
2539                         void *user),
2540                 void *user);
2542         #include <isl/union_map.h>
2543         isl_stat isl_union_map_foreach_map(
2544                 __isl_keep isl_union_map *umap,
2545                 isl_stat (*fn)(__isl_take isl_map *map, void *user),
2546                 void *user);
2547         isl_bool isl_union_map_every_map(
2548                 __isl_keep isl_union_map *umap,
2549                 isl_bool (*test)(__isl_keep isl_map *map,
2550                         void *user),
2551                 void *user);
2553 These functions call the callback function once for each
2554 (pair of) space(s) for which there are elements in the input.
2555 The argument to the callback contains all elements in the input
2556 with that (pair of) space(s).
2557 The C<isl_union_set_every_set> and
2558 C<isl_union_map_every_map> variants check whether each
2559 call to the callback returns true and stops checking as soon as one
2560 of these calls returns false.
2562 The number of sets or maps in a union set or map can be obtained
2563 from
2565         isl_size isl_union_set_n_set(__isl_keep isl_union_set *uset);
2566         isl_size isl_union_map_n_map(__isl_keep isl_union_map *umap);
2568 To extract the set or map in a given space from a union, use
2570         __isl_give isl_set *isl_union_set_extract_set(
2571                 __isl_keep isl_union_set *uset,
2572                 __isl_take isl_space *space);
2573         __isl_give isl_map *isl_union_map_extract_map(
2574                 __isl_keep isl_union_map *umap,
2575                 __isl_take isl_space *space);
2577 To iterate over all the basic sets or maps in a set or map, use
2579         isl_stat isl_set_foreach_basic_set(__isl_keep isl_set *set,
2580                 isl_stat (*fn)(__isl_take isl_basic_set *bset,
2581                         void *user),
2582                 void *user);
2583         isl_stat isl_map_foreach_basic_map(__isl_keep isl_map *map,
2584                 isl_stat (*fn)(__isl_take isl_basic_map *bmap,
2585                         void *user),
2586                 void *user);
2588 The callback function C<fn> should return C<isl_stat_ok> if successful and
2589 C<isl_stat_error> if an error occurs.  In the latter case, or if any other error
2590 occurs, the above functions will return C<isl_stat_error>.
2592 It should be noted that C<isl> does not guarantee that
2593 the basic sets or maps passed to C<fn> are disjoint.
2594 If this is required, then the user should call one of
2595 the following functions first.
2597         __isl_give isl_set *isl_set_make_disjoint(
2598                 __isl_take isl_set *set);
2599         __isl_give isl_map *isl_map_make_disjoint(
2600                 __isl_take isl_map *map);
2602 The number of basic sets in a set can be obtained
2603 or the number of basic maps in a map can be obtained
2604 from
2606         #include <isl/set.h>
2607         isl_size isl_set_n_basic_set(__isl_keep isl_set *set);
2609         #include <isl/map.h>
2610         isl_size isl_map_n_basic_map(__isl_keep isl_map *map);
2612 It is also possible to obtain a list of (basic) sets from a set
2613 or union set, a list of basic maps from a map and a list of maps from a union
2614 map.
2616         #include <isl/set.h>
2617         __isl_give isl_basic_set_list *isl_set_get_basic_set_list(
2618                 __isl_keep isl_set *set);
2620         #include <isl/union_set.h>
2621         __isl_give isl_basic_set_list *
2622         isl_union_set_get_basic_set_list(
2623                 __isl_keep isl_union_set *uset);
2624         __isl_give isl_set_list *isl_union_set_get_set_list(
2625                 __isl_keep isl_union_set *uset);
2627         #include <isl/map.h>
2628         __isl_give isl_basic_map_list *isl_map_get_basic_map_list(
2629                 __isl_keep isl_map *map);
2631         #include <isl/union_map.h>
2632         __isl_give isl_map_list *isl_union_map_get_map_list(
2633                 __isl_keep isl_union_map *umap);
2635 The returned list can be manipulated using the functions in L<"Lists">.
2637 To iterate over the constraints of a basic set or map, use
2639         #include <isl/constraint.h>
2641         isl_size isl_basic_set_n_constraint(
2642                 __isl_keep isl_basic_set *bset);
2643         isl_stat isl_basic_set_foreach_constraint(
2644                 __isl_keep isl_basic_set *bset,
2645                 isl_stat (*fn)(__isl_take isl_constraint *c,
2646                         void *user),
2647                 void *user);
2648         isl_size isl_basic_map_n_constraint(
2649                 __isl_keep isl_basic_map *bmap);
2650         isl_stat isl_basic_map_foreach_constraint(
2651                 __isl_keep isl_basic_map *bmap,
2652                 isl_stat (*fn)(__isl_take isl_constraint *c,
2653                         void *user),
2654                 void *user);
2655         __isl_null isl_constraint *isl_constraint_free(
2656                 __isl_take isl_constraint *c);
2658 Again, the callback function C<fn> should return C<isl_stat_ok>
2659 if successful and
2660 C<isl_stat_error> if an error occurs.  In the latter case, or if any other error
2661 occurs, the above functions will return C<isl_stat_error>.
2662 The constraint C<c> represents either an equality or an inequality.
2663 Use the following function to find out whether a constraint
2664 represents an equality.  If not, it represents an inequality.
2666         isl_bool isl_constraint_is_equality(
2667                 __isl_keep isl_constraint *constraint);
2669 It is also possible to obtain a list of constraints from a basic
2670 map or set
2672         #include <isl/constraint.h>
2673         __isl_give isl_constraint_list *
2674         isl_basic_map_get_constraint_list(
2675                 __isl_keep isl_basic_map *bmap);
2676         __isl_give isl_constraint_list *
2677         isl_basic_set_get_constraint_list(
2678                 __isl_keep isl_basic_set *bset);
2680 These functions require that all existentially quantified variables
2681 have an explicit representation.
2682 The returned list can be manipulated using the functions in L<"Lists">.
2684 The coefficients of the constraints can be inspected using
2685 the following functions.
2687         isl_bool isl_constraint_is_lower_bound(
2688                 __isl_keep isl_constraint *constraint,
2689                 enum isl_dim_type type, unsigned pos);
2690         isl_bool isl_constraint_is_upper_bound(
2691                 __isl_keep isl_constraint *constraint,
2692                 enum isl_dim_type type, unsigned pos);
2693         __isl_give isl_val *isl_constraint_get_constant_val(
2694                 __isl_keep isl_constraint *constraint);
2695         __isl_give isl_val *isl_constraint_get_coefficient_val(
2696                 __isl_keep isl_constraint *constraint,
2697                 enum isl_dim_type type, int pos);
2699 The explicit representations of the existentially quantified
2700 variables can be inspected using the following function.
2701 Note that the user is only allowed to use this function
2702 if the inspected set or map is the result of a call
2703 to C<isl_set_compute_divs> or C<isl_map_compute_divs>.
2704 The existentially quantified variable is equal to the floor
2705 of the returned affine expression.  The affine expression
2706 itself can be inspected using the functions in
2707 L</"Functions">.
2709         __isl_give isl_aff *isl_constraint_get_div(
2710                 __isl_keep isl_constraint *constraint, int pos);
2712 To obtain the constraints of a basic set or map in matrix
2713 form, use the following functions.
2715         __isl_give isl_mat *isl_basic_set_equalities_matrix(
2716                 __isl_keep isl_basic_set *bset,
2717                 enum isl_dim_type c1, enum isl_dim_type c2,
2718                 enum isl_dim_type c3, enum isl_dim_type c4);
2719         __isl_give isl_mat *isl_basic_set_inequalities_matrix(
2720                 __isl_keep isl_basic_set *bset,
2721                 enum isl_dim_type c1, enum isl_dim_type c2,
2722                 enum isl_dim_type c3, enum isl_dim_type c4);
2723         __isl_give isl_mat *isl_basic_map_equalities_matrix(
2724                 __isl_keep isl_basic_map *bmap,
2725                 enum isl_dim_type c1,
2726                 enum isl_dim_type c2, enum isl_dim_type c3,
2727                 enum isl_dim_type c4, enum isl_dim_type c5);
2728         __isl_give isl_mat *isl_basic_map_inequalities_matrix(
2729                 __isl_keep isl_basic_map *bmap,
2730                 enum isl_dim_type c1,
2731                 enum isl_dim_type c2, enum isl_dim_type c3,
2732                 enum isl_dim_type c4, enum isl_dim_type c5);
2734 The C<isl_dim_type> arguments dictate the order in which
2735 different kinds of variables appear in the resulting matrix.
2736 For set inputs, they should be a permutation of
2737 C<isl_dim_cst> (the constant term), C<isl_dim_param>, C<isl_dim_set> and
2738 C<isl_dim_div>.
2739 For map inputs, they should be a permutation of
2740 C<isl_dim_cst>, C<isl_dim_param>,
2741 C<isl_dim_in>, C<isl_dim_out> and C<isl_dim_div>.
2743 =head2 Points
2745 Points are elements of a set.  They can be used to construct
2746 simple sets (boxes) or they can be used to represent the
2747 individual elements of a set.
2748 The zero point (the origin) can be created using
2750         __isl_give isl_point *isl_point_zero(__isl_take isl_space *space);
2752 The coordinates of a point can be inspected, set and changed
2753 using
2755         #include <isl/point.h>
2756         __isl_give isl_multi_val *isl_point_get_multi_val(
2757                 __isl_keep isl_point *pnt);
2758         __isl_give isl_val *isl_point_get_coordinate_val(
2759                 __isl_keep isl_point *pnt,
2760                 enum isl_dim_type type, int pos);
2761         __isl_give isl_point *isl_point_set_coordinate_val(
2762                 __isl_take isl_point *pnt,
2763                 enum isl_dim_type type, int pos,
2764                 __isl_take isl_val *v);
2766         __isl_give isl_point *isl_point_add_ui(
2767                 __isl_take isl_point *pnt,
2768                 enum isl_dim_type type, int pos, unsigned val);
2769         __isl_give isl_point *isl_point_sub_ui(
2770                 __isl_take isl_point *pnt,
2771                 enum isl_dim_type type, int pos, unsigned val);
2773 Points can be copied or freed using
2775         __isl_give isl_point *isl_point_copy(
2776                 __isl_keep isl_point *pnt);
2777         __isl_null isl_point *isl_point_free(
2778                 __isl_take isl_point *pnt);
2780 A singleton set can be created from a point using the following functions.
2782         __isl_give isl_basic_set *isl_basic_set_from_point(
2783                 __isl_take isl_point *pnt);
2784         __isl_give isl_set *isl_point_to_set(
2785                 __isl_take isl_point *pnt);
2786         __isl_give isl_set *isl_set_from_point(
2787                 __isl_take isl_point *pnt);
2788         __isl_give isl_union_set *isl_union_set_from_point(
2789                 __isl_take isl_point *pnt);
2791 C<isl_point_to_set> and C<isl_set_from_point> perform
2792 the same operation.
2794 A box can be created from two opposite extremal points using
2796         __isl_give isl_basic_set *isl_basic_set_box_from_points(
2797                 __isl_take isl_point *pnt1,
2798                 __isl_take isl_point *pnt2);
2799         __isl_give isl_set *isl_set_box_from_points(
2800                 __isl_take isl_point *pnt1,
2801                 __isl_take isl_point *pnt2);
2803 All elements of a B<bounded> (union) set can be enumerated using
2804 the following functions.
2806         isl_stat isl_set_foreach_point(__isl_keep isl_set *set,
2807                 isl_stat (*fn)(__isl_take isl_point *pnt,
2808                         void *user),
2809                 void *user);
2810         isl_stat isl_union_set_foreach_point(
2811                 __isl_keep isl_union_set *uset,
2812                 isl_stat (*fn)(__isl_take isl_point *pnt,
2813                         void *user),
2814                 void *user);
2816 The function C<fn> is called for each integer point in
2817 C<set> with as second argument the last argument of
2818 the C<isl_set_foreach_point> call.  The function C<fn>
2819 should return C<isl_stat_ok> on success and C<isl_stat_error> on failure.
2820 In the latter case, C<isl_set_foreach_point> will stop
2821 enumerating and return C<isl_stat_error> as well.
2822 If the enumeration is performed successfully and to completion,
2823 then C<isl_set_foreach_point> returns C<isl_stat_ok>.
2825 To obtain a single point of a (basic or union) set, use
2827         __isl_give isl_point *isl_basic_set_sample_point(
2828                 __isl_take isl_basic_set *bset);
2829         __isl_give isl_point *isl_set_sample_point(
2830                 __isl_take isl_set *set);
2831         __isl_give isl_point *isl_union_set_sample_point(
2832                 __isl_take isl_union_set *uset);
2834 If C<set> does not contain any (integer) points, then the
2835 resulting point will be ``void'', a property that can be
2836 tested using
2838         isl_bool isl_point_is_void(__isl_keep isl_point *pnt);
2840 =head2 Functions
2842 Besides sets and relation, C<isl> also supports various types of functions.
2843 Each of these types is derived from the value type (see L</"Values">)
2844 or from one of two primitive function types
2845 through the application of zero or more type constructors.
2846 As a special case, a multiple expression can also be derived
2847 from an identifier (see L</"Identifiers">) although the result
2848 is not really a function.
2849 We first describe the primitive type and then we describe
2850 the types derived from these primitive types.
2852 =head3 Primitive Functions
2854 C<isl> support two primitive function types, quasi-affine
2855 expressions and quasipolynomials.
2856 A quasi-affine expression is defined either over a parameter
2857 space or over a set and is composed of integer constants,
2858 parameters and set variables, addition, subtraction and
2859 integer division by an integer constant.
2860 For example, the quasi-affine expression
2862         [n] -> { [x] -> [2*floor((4 n + x)/9)] }
2864 maps C<x> to C<2*floor((4 n + x)/9>.
2865 A quasipolynomial is a polynomial expression in quasi-affine
2866 expression.  That is, it additionally allows for multiplication.
2867 Note, though, that it is not allowed to construct an integer
2868 division of an expression involving multiplications.
2869 Here is an example of a quasipolynomial that is not
2870 quasi-affine expression
2872         [n] -> { [x] -> (n*floor((4 n + x)/9)) }
2874 Note that the external representations of quasi-affine expressions
2875 and quasipolynomials are different.  Quasi-affine expressions
2876 use a notation with square brackets just like binary relations,
2877 while quasipolynomials do not.  This might change at some point.
2879 If a primitive function is defined over a parameter space,
2880 then the space of the function itself is that of a set.
2881 If it is defined over a set, then the space of the function
2882 is that of a relation.  In both cases, the set space (or
2883 the output space) is single-dimensional, anonymous and unstructured.
2884 To create functions with multiple dimensions or with other kinds
2885 of set or output spaces, use multiple expressions
2886 (see L</"Multiple Expressions">).
2888 =over
2890 =item * Quasi-affine Expressions
2892 Besides the expressions described above, a quasi-affine
2893 expression can also be set to NaN.  Such expressions
2894 typically represent a failure to represent a result
2895 as a quasi-affine expression.
2897 The zero quasi affine expression or the quasi affine expression
2898 that is equal to a given value, parameter or
2899 a specified dimension on a given domain can be created using
2901         #include <isl/aff.h>
2902         __isl_give isl_aff *isl_aff_zero_on_domain_space(
2903                 __isl_take isl_space *space);
2904         __isl_give isl_aff *isl_space_zero_aff_on_domain(
2905                 __isl_take isl_space *space);
2906         __isl_give isl_aff *isl_aff_zero_on_domain(
2907                 __isl_take isl_local_space *ls);
2908         __isl_give isl_aff *isl_aff_val_on_domain_space(
2909                 __isl_take isl_space *space,
2910                 __isl_take isl_val *val);
2911         __isl_give isl_aff *isl_aff_val_on_domain(
2912                 __isl_take isl_local_space *ls,
2913                 __isl_take isl_val *val);
2914         __isl_give isl_aff *isl_aff_param_on_domain_space_id(
2915                 __isl_take isl_space *space,
2916                 __isl_take isl_id *id);
2917         __isl_give isl_aff *isl_space_param_aff_on_domain_id(
2918                 __isl_take isl_space *space,
2919                 __isl_take isl_id *id);
2920         __isl_give isl_aff *isl_aff_var_on_domain(
2921                 __isl_take isl_local_space *ls,
2922                 enum isl_dim_type type, unsigned pos);
2923         __isl_give isl_aff *isl_aff_nan_on_domain_space(
2924                 __isl_take isl_space *space);
2925         __isl_give isl_aff *isl_aff_nan_on_domain(
2926                 __isl_take isl_local_space *ls);
2928 The space passed to C<isl_aff_param_on_domain_space_id>
2929 is required to have a parameter with the given identifier.
2930 C<isl_aff_param_on_domain_space_id> and
2931 C<isl_space_param_aff_on_domain_id> perform the same operation.
2933 C<isl_aff_zero_on_domain_space> and C<isl_space_zero_aff_on_domain>
2934 perform the same operation.
2936 Quasi affine expressions can be copied and freed using
2938         #include <isl/aff.h>
2939         __isl_give isl_aff *isl_aff_copy(
2940                 __isl_keep isl_aff *aff);
2941         __isl_null isl_aff *isl_aff_free(
2942                 __isl_take isl_aff *aff);
2944 A (rational) bound on a dimension can be extracted from an C<isl_constraint>
2945 using the following function.  The constraint is required to have
2946 a non-zero coefficient for the specified dimension.
2948         #include <isl/constraint.h>
2949         __isl_give isl_aff *isl_constraint_get_bound(
2950                 __isl_keep isl_constraint *constraint,
2951                 enum isl_dim_type type, int pos);
2953 The entire affine expression of the constraint can also be extracted
2954 using the following function.
2956         #include <isl/constraint.h>
2957         __isl_give isl_aff *isl_constraint_get_aff(
2958                 __isl_keep isl_constraint *constraint);
2960 Conversely, an equality constraint equating
2961 the affine expression to zero or an inequality constraint enforcing
2962 the affine expression to be non-negative, can be constructed using
2964         __isl_give isl_constraint *isl_equality_from_aff(
2965                 __isl_take isl_aff *aff);
2966         __isl_give isl_constraint *isl_inequality_from_aff(
2967                 __isl_take isl_aff *aff);
2969 The coefficients and the integer divisions of an affine expression
2970 can be inspected using the following functions.
2972         #include <isl/aff.h>
2973         __isl_give isl_val *isl_aff_get_constant_val(
2974                 __isl_keep isl_aff *aff);
2975         __isl_give isl_val *isl_aff_get_coefficient_val(
2976                 __isl_keep isl_aff *aff,
2977                 enum isl_dim_type type, int pos);
2978         int isl_aff_coefficient_sgn(__isl_keep isl_aff *aff,
2979                 enum isl_dim_type type, int pos);
2980         __isl_give isl_val *isl_aff_get_denominator_val(
2981                 __isl_keep isl_aff *aff);
2982         __isl_give isl_aff *isl_aff_get_div(
2983                 __isl_keep isl_aff *aff, int pos);
2985 They can be modified using the following functions.
2987         #include <isl/aff.h>
2988         __isl_give isl_aff *isl_aff_set_constant_si(
2989                 __isl_take isl_aff *aff, int v);
2990         __isl_give isl_aff *isl_aff_set_constant_val(
2991                 __isl_take isl_aff *aff, __isl_take isl_val *v);
2992         __isl_give isl_aff *isl_aff_set_coefficient_si(
2993                 __isl_take isl_aff *aff,
2994                 enum isl_dim_type type, int pos, int v);
2995         __isl_give isl_aff *isl_aff_set_coefficient_val(
2996                 __isl_take isl_aff *aff,
2997                 enum isl_dim_type type, int pos,
2998                 __isl_take isl_val *v);
3000         __isl_give isl_aff *isl_aff_add_constant_si(
3001                 __isl_take isl_aff *aff, int v);
3002         __isl_give isl_aff *isl_aff_add_constant_val(
3003                 __isl_take isl_aff *aff, __isl_take isl_val *v);
3004         __isl_give isl_aff *isl_aff_add_constant_num_si(
3005                 __isl_take isl_aff *aff, int v);
3006         __isl_give isl_aff *isl_aff_add_coefficient_si(
3007                 __isl_take isl_aff *aff,
3008                 enum isl_dim_type type, int pos, int v);
3009         __isl_give isl_aff *isl_aff_add_coefficient_val(
3010                 __isl_take isl_aff *aff,
3011                 enum isl_dim_type type, int pos,
3012                 __isl_take isl_val *v);
3014 Note that C<isl_aff_set_constant_si> and C<isl_aff_set_coefficient_si>
3015 set the I<numerator> of the constant or coefficient, while
3016 C<isl_aff_set_constant_val> and C<isl_aff_set_coefficient_val> set
3017 the constant or coefficient as a whole.
3018 The C<add_constant> and C<add_coefficient> functions add an integer
3019 or rational value to
3020 the possibly rational constant or coefficient.
3021 The C<add_constant_num> functions add an integer value to
3022 the numerator.
3024 =item * Quasipolynomials
3026 Some simple quasipolynomials can be created using the following functions.
3028         #include <isl/polynomial.h>
3029         __isl_give isl_qpolynomial *isl_qpolynomial_zero_on_domain(
3030                 __isl_take isl_space *domain);
3031         __isl_give isl_qpolynomial *isl_qpolynomial_one_on_domain(
3032                 __isl_take isl_space *domain);
3033         __isl_give isl_qpolynomial *isl_qpolynomial_infty_on_domain(
3034                 __isl_take isl_space *domain);
3035         __isl_give isl_qpolynomial *isl_qpolynomial_neginfty_on_domain(
3036                 __isl_take isl_space *domain);
3037         __isl_give isl_qpolynomial *isl_qpolynomial_nan_on_domain(
3038                 __isl_take isl_space *domain);
3039         __isl_give isl_qpolynomial *isl_qpolynomial_val_on_domain(
3040                 __isl_take isl_space *domain,
3041                 __isl_take isl_val *val);
3042         __isl_give isl_qpolynomial *isl_qpolynomial_var_on_domain(
3043                 __isl_take isl_space *domain,
3044                 enum isl_dim_type type, unsigned pos);
3045         __isl_give isl_qpolynomial *isl_qpolynomial_from_aff(
3046                 __isl_take isl_aff *aff);
3048 Recall that the space in which a quasipolynomial lives is a map space
3049 with a one-dimensional range.  The C<domain> argument in some of
3050 the functions above corresponds to the domain of this map space.
3052 Quasipolynomials can be copied and freed again using the following
3053 functions.
3055         #include <isl/polynomial.h>
3056         __isl_give isl_qpolynomial *isl_qpolynomial_copy(
3057                 __isl_keep isl_qpolynomial *qp);
3058         __isl_null isl_qpolynomial *isl_qpolynomial_free(
3059                 __isl_take isl_qpolynomial *qp);
3061 The constant term of a quasipolynomial can be extracted using
3063         __isl_give isl_val *isl_qpolynomial_get_constant_val(
3064                 __isl_keep isl_qpolynomial *qp);
3066 To iterate over all terms in a quasipolynomial,
3069         isl_stat isl_qpolynomial_foreach_term(
3070                 __isl_keep isl_qpolynomial *qp,
3071                 isl_stat (*fn)(__isl_take isl_term *term,
3072                           void *user), void *user);
3074 The terms themselves can be inspected and freed using
3075 these functions
3077         isl_size isl_term_dim(__isl_keep isl_term *term,
3078                 enum isl_dim_type type);
3079         __isl_give isl_val *isl_term_get_coefficient_val(
3080                 __isl_keep isl_term *term);
3081         isl_size isl_term_get_exp(__isl_keep isl_term *term,
3082                 enum isl_dim_type type, unsigned pos);
3083         __isl_give isl_aff *isl_term_get_div(
3084                 __isl_keep isl_term *term, unsigned pos);
3085         __isl_null isl_term *isl_term_free(
3086                 __isl_take isl_term *term);
3088 Each term is a product of parameters, set variables and
3089 integer divisions.  The function C<isl_term_get_exp>
3090 returns the exponent of a given dimensions in the given term.
3092 =back
3094 =head3 Reductions
3096 A reduction represents a maximum or a minimum of its
3097 base expressions.
3098 The only reduction type defined by C<isl> is
3099 C<isl_qpolynomial_fold>.
3101 There are currently no functions to directly create such
3102 objects, but they do appear in the piecewise quasipolynomial
3103 reductions returned by the C<isl_pw_qpolynomial_bound> function.
3105 L</"Bounds on Piecewise Quasipolynomials and Piecewise Quasipolynomial Reductions">.
3107 Reductions can be copied and freed using
3108 the following functions.
3110         #include <isl/polynomial.h>
3111         __isl_give isl_qpolynomial_fold *
3112         isl_qpolynomial_fold_copy(
3113                 __isl_keep isl_qpolynomial_fold *fold);
3114         __isl_null isl_qpolynomial_fold *
3115         isl_qpolynomial_fold_free(
3116                 __isl_take isl_qpolynomial_fold *fold);
3118 The type of a (union piecewise) reduction
3119 can be obtained using the following functions.
3121         #include <isl/polynomial.h>
3122         enum isl_fold isl_qpolynomial_fold_get_type(
3123                 __isl_keep isl_qpolynomial_fold *fold);
3124         enum isl_fold isl_pw_qpolynomial_fold_get_type(
3125                 __isl_keep isl_pw_qpolynomial_fold *pwf);
3126         enum isl_fold isl_union_pw_qpolynomial_fold_get_type(
3127                 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
3129 The type may be either C<isl_fold_min> or C<isl_fold_max>
3130 (or C<isl_fold_error> in case of error).
3132 To iterate over all quasipolynomials in a reduction, use
3134         isl_stat isl_qpolynomial_fold_foreach_qpolynomial(
3135                 __isl_keep isl_qpolynomial_fold *fold,
3136                 isl_stat (*fn)(__isl_take isl_qpolynomial *qp,
3137                           void *user), void *user);
3139 =head3 Multiple Expressions
3141 A multiple expression represents a sequence of zero or
3142 more base expressions, all defined on the same domain space.
3143 The domain space of the multiple expression is the same
3144 as that of the base expressions, but the range space
3145 can be any space.  In case the base expressions have
3146 a set space, the corresponding multiple expression
3147 also has a set space.
3148 Objects of the value or identifier type do not have an associated space.
3149 The space of a multiple value or
3150 multiple identifier is therefore always a set space.
3151 Similarly, the space of a multiple union piecewise
3152 affine expression is always a set space.
3153 If the base expressions are not total, then
3154 a corresponding zero-dimensional multiple expression may
3155 have an explicit domain that keeps track of the domain
3156 outside of any base expressions.
3158 The multiple expression types defined by C<isl>
3159 are C<isl_multi_val>, C<isl_multi_id>, C<isl_multi_aff>, C<isl_multi_pw_aff>,
3160 C<isl_multi_union_pw_aff>.
3162 A multiple expression with the value zero for
3163 each output (or set) dimension can be created
3164 using the following functions.
3166         #include <isl/val.h>
3167         __isl_give isl_multi_val *isl_multi_val_zero(
3168                 __isl_take isl_space *space);
3169         __isl_give isl_multi_val *isl_space_zero_multi_val(
3170                 __isl_take isl_space *space);
3172         #include <isl/aff.h>
3173         __isl_give isl_multi_aff *isl_multi_aff_zero(
3174                 __isl_take isl_space *space);
3175         __isl_give isl_multi_aff *isl_space_zero_multi_aff(
3176                 __isl_take isl_space *space);
3177         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_zero(
3178                 __isl_take isl_space *space);
3179         __isl_give isl_multi_pw_aff *isl_space_zero_multi_pw_aff(
3180                 __isl_take isl_space *space);
3181         __isl_give isl_multi_union_pw_aff *
3182         isl_multi_union_pw_aff_zero(
3183                 __isl_take isl_space *space);
3184         __isl_give isl_multi_union_pw_aff *
3185         isl_space_zero_multi_union_pw_aff(
3186                 __isl_take isl_space *space);
3188 Since there is no canonical way of representing a zero
3189 value of type C<isl_union_pw_aff>, the space passed
3190 to C<isl_multi_union_pw_aff_zero> needs to be zero-dimensional.
3191 C<isl_multi_val_zero> and C<isl_space_zero_multi_val>
3192 perform the same operation.
3193 Similarly
3194 for the pair C<isl_multi_aff_zero> and C<isl_space_zero_multi_aff>,
3195 for the pair C<isl_multi_pw_aff_zero> and C<isl_space_zero_multi_pw_aff> and
3196 for the pair C<isl_multi_union_pw_aff_zero> and
3197 C<isl_space_zero_multi_union_pw_aff>.
3200 An identity function can be created using the following
3201 functions.
3202 For the first group of functions, the space needs to be that of a set.
3203 For the second group,
3204 the space needs to be that of a relation
3205 with the same number of input and output dimensions.
3206 For the third group, the input function needs to live in a space
3207 with the same number of input and output dimensions and
3208 the identity function is created in that space.
3210         #include <isl/aff.h>
3211         __isl_give isl_multi_aff *
3212         isl_multi_aff_identity_on_domain_space(
3213                 __isl_take isl_space *space);
3214         __isl_give isl_multi_aff *
3215         isl_space_identity_multi_aff_on_domain(
3216                 __isl_take isl_space *space);
3217         __isl_give isl_multi_pw_aff *
3218         isl_multi_pw_aff_identity_on_domain_space(
3219                 __isl_take isl_space *space);
3220         __isl_give isl_multi_pw_aff *
3221         isl_space_identity_multi_pw_aff_on_domain(
3222                 __isl_take isl_space *space);
3223         __isl_give isl_multi_aff *isl_multi_aff_identity(
3224                 __isl_take isl_space *space);
3225         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_identity(
3226                 __isl_take isl_space *space);
3227         __isl_give isl_multi_aff *
3228         isl_multi_aff_identity_multi_aff(
3229                 __isl_take isl_multi_aff *ma);
3230         __isl_give isl_multi_pw_aff *
3231         isl_multi_pw_aff_identity_multi_pw_aff(
3232                 __isl_take isl_multi_pw_aff *mpa);
3234 C<isl_multi_aff_identity_on_domain_space> and
3235 C<isl_space_identity_multi_aff_on_domain>
3236 perform the same operation.
3237 Similarly
3238 for the pair C<isl_multi_pw_aff_identity_on_domain_space> and
3239 C<isl_space_identity_multi_pw_aff_on_domain>.
3241 A function that performs a projection on a universe
3242 relation or set can be created using the following functions.
3243 See also the corresponding
3244 projection operations in L</"Unary Operations">.
3246         #include <isl/aff.h>
3247         __isl_give isl_multi_aff *isl_multi_aff_domain_map(
3248                 __isl_take isl_space *space);
3249         __isl_give isl_multi_aff *isl_space_domain_map_multi_aff(
3250                 __isl_take isl_space *space);
3251         __isl_give isl_multi_aff *isl_multi_aff_range_map(
3252                 __isl_take isl_space *space);
3253         __isl_give isl_multi_aff *isl_space_range_map_multi_aff(
3254                 __isl_take isl_space *space);
3255         __isl_give isl_multi_aff *isl_multi_aff_project_out_map(
3256                 __isl_take isl_space *space,
3257                 enum isl_dim_type type,
3258                 unsigned first, unsigned n);
3260 C<isl_multi_aff_domain_map> and C<isl_space_domain_map_multi_aff> perform
3261 the same operation.
3262 Similarly
3263 for the pair C<isl_multi_aff_range_map> and C<isl_space_range_map_multi_aff>.
3265 A multiple expression can be created from a single
3266 base expression using the following functions.
3267 The space of the created multiple expression is the same
3268 as that of the base expression, except for
3269 C<isl_multi_union_pw_aff_from_union_pw_aff> where the input
3270 lives in a parameter space and the output lives
3271 in a single-dimensional set space.
3273         #include <isl/aff.h>
3274         __isl_give isl_multi_aff *isl_multi_aff_from_aff(
3275                 __isl_take isl_aff *aff);
3276         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_pw_aff(
3277                 __isl_take isl_pw_aff *pa);
3278         __isl_give isl_multi_union_pw_aff *
3279         isl_multi_union_pw_aff_from_union_pw_aff(
3280                 __isl_take isl_union_pw_aff *upa);
3282 A multiple expression can be created from a list
3283 of base expression in a specified space.
3284 The domain of this space needs to be the same
3285 as the domains of the base expressions in the list.
3286 If the base expressions have a set space (or no associated space),
3287 then this space also needs to be a set space.
3289         #include <isl/id.h>
3290         __isl_give isl_multi_id *isl_multi_id_from_id_list(
3291                 __isl_take isl_space *space,
3292                 __isl_take isl_id_list *list);
3293         __isl_give isl_multi_id *isl_space_multi_id(
3294                 __isl_take isl_space *space,
3295                 __isl_take isl_id_list *list);
3297         #include <isl/val.h>
3298         __isl_give isl_multi_val *isl_multi_val_from_val_list(
3299                 __isl_take isl_space *space,
3300                 __isl_take isl_val_list *list);
3301         __isl_give isl_multi_val *isl_space_multi_val(
3302                 __isl_take isl_space *space,
3303                 __isl_take isl_val_list *list);
3305         #include <isl/aff.h>
3306         __isl_give isl_multi_aff *isl_multi_aff_from_aff_list(
3307                 __isl_take isl_space *space,
3308                 __isl_take isl_aff_list *list);
3309         __isl_give isl_multi_aff *isl_space_multi_aff(
3310                 __isl_take isl_space *space,
3311                 __isl_take isl_aff_list *list);
3312         __isl_give isl_multi_pw_aff *
3313         isl_multi_pw_aff_from_pw_aff_list(
3314                 __isl_take isl_space *space,
3315                 __isl_take isl_pw_aff_list *list);
3316         __isl_give isl_multi_pw_aff *
3317         isl_space_multi_pw_aff(
3318                 __isl_take isl_space *space,
3319                 __isl_take isl_pw_aff_list *list);
3320         __isl_give isl_multi_union_pw_aff *
3321         isl_multi_union_pw_aff_from_union_pw_aff_list(
3322                 __isl_take isl_space *space,
3323                 __isl_take isl_union_pw_aff_list *list);
3324         __isl_give isl_multi_union_pw_aff *
3325         isl_space_multi_union_pw_aff(
3326                 __isl_take isl_space *space,
3327                 __isl_take isl_union_pw_aff_list *list);
3329 C<isl_multi_id_from_id_list> and C<isl_space_multi_id> perform
3330 the same operation.
3331 Similarly for the pair C<isl_multi_val_from_val_list> and
3332 C<isl_space_multi_val>,
3333 for the pair C<isl_multi_aff_from_aff_list> and
3334 C<isl_space_multi_aff>,
3335 for the pair C<isl_multi_pw_aff_from_pw_aff_list> and
3336 C<isl_space_multi_pw_aff> and
3337 for the pair C<isl_multi_union_pw_aff_from_union_pw_aff_list> and
3338 C<isl_space_multi_union_pw_aff>.
3340 As a convenience, a multiple piecewise expression can
3341 also be created from a multiple expression,
3342 or even directly from a single base expression.
3343 Each piecewise expression in the result has a single
3344 universe cell.
3346         #include <isl/aff.h>
3347         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_aff(
3348                 __isl_take isl_aff *aff);
3349         __isl_give isl_multi_pw_aff *
3350         isl_multi_aff_to_multi_pw_aff(
3351                 __isl_take isl_multi_aff *ma);
3352         __isl_give isl_multi_pw_aff *
3353         isl_multi_pw_aff_from_multi_aff(
3354                 __isl_take isl_multi_aff *ma);
3356 C<isl_multi_aff_to_multi_pw_aff> and
3357 C<isl_multi_pw_aff_from_multi_aff> perform the same operation.
3359 Similarly, a multiple union expression can be
3360 created from a multiple expression.
3362         #include <isl/aff.h>
3363         __isl_give isl_multi_union_pw_aff *
3364         isl_multi_union_pw_aff_from_multi_aff(
3365                 __isl_take isl_multi_aff *ma);
3366         __isl_give isl_multi_union_pw_aff *
3367         isl_multi_aff_to_multi_union_pw_aff(
3368                 __isl_take isl_multi_aff *ma);
3369         __isl_give isl_multi_union_pw_aff *
3370         isl_multi_union_pw_aff_from_multi_pw_aff(
3371                 __isl_take isl_multi_pw_aff *mpa);
3373 C<isl_multi_aff_to_multi_union_pw_aff> and
3374 C<isl_multi_union_pw_aff_from_multi_aff> perform the same operation.
3376 A multiple quasi-affine expression can be created from
3377 a multiple value with a given domain space using the following
3378 function.
3380         #include <isl/aff.h>
3381         __isl_give isl_multi_aff *
3382         isl_multi_aff_multi_val_on_domain_space(
3383                 __isl_take isl_space *space,
3384                 __isl_take isl_multi_val *mv);
3385         __isl_give isl_multi_aff *
3386         isl_space_multi_aff_on_domain_multi_val(
3387                 __isl_take isl_space *space,
3388                 __isl_take isl_multi_val *mv);
3389         __isl_give isl_multi_aff *
3390         isl_multi_aff_multi_val_on_space(
3391                 __isl_take isl_space *space,
3392                 __isl_take isl_multi_val *mv);
3394 C<isl_space_multi_aff_on_domain_multi_val> and
3395 C<isl_multi_aff_multi_val_on_space> are alternative names
3396 for C<isl_multi_aff_multi_val_on_domain_space>.
3398 Similarly,
3399 a multiple union piecewise affine expression can be created from
3400 a multiple value with a given domain or
3401 a (piecewise) multiple affine expression with a given domain
3402 using the following functions.
3404         #include <isl/aff.h>
3405         __isl_give isl_multi_union_pw_aff *
3406         isl_multi_union_pw_aff_multi_val_on_domain(
3407                 __isl_take isl_union_set *domain,
3408                 __isl_take isl_multi_val *mv);
3409         __isl_give isl_multi_union_pw_aff *
3410         isl_multi_union_pw_aff_multi_aff_on_domain(
3411                 __isl_take isl_union_set *domain,
3412                 __isl_take isl_multi_aff *ma);
3413         __isl_give isl_multi_union_pw_aff *
3414         isl_multi_union_pw_aff_pw_multi_aff_on_domain(
3415                 __isl_take isl_union_set *domain,
3416                 __isl_take isl_pw_multi_aff *pma);
3418 Multiple expressions can be copied and freed using
3419 the following functions.
3421         #include <isl/id.h>
3422         __isl_give isl_multi_id *isl_multi_id_copy(
3423                 __isl_keep isl_multi_id *mi);
3424         __isl_null isl_multi_id *isl_multi_id_free(
3425                 __isl_take isl_multi_id *mi);
3427         #include <isl/val.h>
3428         __isl_give isl_multi_val *isl_multi_val_copy(
3429                 __isl_keep isl_multi_val *mv);
3430         __isl_null isl_multi_val *isl_multi_val_free(
3431                 __isl_take isl_multi_val *mv);
3433         #include <isl/aff.h>
3434         __isl_give isl_multi_aff *isl_multi_aff_copy(
3435                 __isl_keep isl_multi_aff *maff);
3436         __isl_null isl_multi_aff *isl_multi_aff_free(
3437                 __isl_take isl_multi_aff *maff);
3438         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_copy(
3439                 __isl_keep isl_multi_pw_aff *mpa);
3440         __isl_null isl_multi_pw_aff *isl_multi_pw_aff_free(
3441                 __isl_take isl_multi_pw_aff *mpa);
3442         __isl_give isl_multi_union_pw_aff *
3443         isl_multi_union_pw_aff_copy(
3444                 __isl_keep isl_multi_union_pw_aff *mupa);
3445         __isl_null isl_multi_union_pw_aff *
3446         isl_multi_union_pw_aff_free(
3447                 __isl_take isl_multi_union_pw_aff *mupa);
3449 The number of base expressions in a multiple
3450 expression can be obtained using the following functions.
3452         #include <isl/id.h>
3453         int isl_multi_id_size(__isl_keep isl_multi_id *mi);
3455         #include <isl/val.h>
3456         isl_size isl_multi_val_size(__isl_keep isl_multi_val *mv);
3458         #include <isl/aff.h>
3459         isl_size isl_multi_aff_size(
3460                 __isl_keep isl_multi_aff *multi);
3461         isl_size isl_multi_pw_aff_size(
3462                 __isl_keep isl_multi_pw_aff *mpa);
3463         isl_size isl_multi_union_pw_aff_size(
3464                 __isl_keep isl_multi_union_pw_aff *mupa);
3466 The base expression at a given position of a multiple
3467 expression can be extracted using the following functions.
3469         #include <isl/id.h>
3470         __isl_give isl_id *isl_multi_id_get_at(
3471                 __isl_keep isl_multi_id *mi, int pos);
3472         __isl_give isl_id *isl_multi_id_get_id(
3473                 __isl_keep isl_multi_id *mi, int pos);
3475         #include <isl/val.h>
3476         __isl_give isl_val *isl_multi_val_get_at(
3477                 __isl_keep isl_multi_val *mv, int pos);
3478         __isl_give isl_val *isl_multi_val_get_val(
3479                 __isl_keep isl_multi_val *mv, int pos);
3481         #include <isl/aff.h>
3482         __isl_give isl_aff *isl_multi_aff_get_at(
3483                 __isl_keep isl_multi_aff *ma, int pos);
3484         __isl_give isl_aff *isl_multi_aff_get_aff(
3485                 __isl_keep isl_multi_aff *multi, int pos);
3486         __isl_give isl_pw_aff *isl_multi_pw_aff_get_at(
3487                 __isl_keep isl_multi_pw_aff *mpa, int pos);
3488         __isl_give isl_pw_aff *isl_multi_pw_aff_get_pw_aff(
3489                 __isl_keep isl_multi_pw_aff *mpa, int pos);
3490         __isl_give isl_union_pw_aff *
3491         isl_multi_union_pw_aff_get_at(
3492                 __isl_keep isl_multi_union_pw_aff *mupa, int pos);
3493         __isl_give isl_union_pw_aff *
3494         isl_multi_union_pw_aff_get_union_pw_aff(
3495                 __isl_keep isl_multi_union_pw_aff *mupa, int pos);
3497 C<isl_multi_id_get_id> is an alternative name for C<isl_multi_id_get_at>.
3498 Similarly for the other pairs of functions.
3500 The base expression can be replaced using the following functions.
3502         #include <isl/id.h>
3503         __isl_give isl_multi_id *isl_multi_id_set_at(
3504                 __isl_take isl_multi_id *mi, int pos,
3505                 __isl_take isl_id *id);
3506         __isl_give isl_multi_id *isl_multi_id_set_id(
3507                 __isl_take isl_multi_id *mi, int pos,
3508                 __isl_take isl_id *id);
3510         #include <isl/val.h>
3511         __isl_give isl_multi_val *isl_multi_val_set_at(
3512                 __isl_take isl_multi_val *mv, int pos,
3513                 __isl_take isl_val *val);
3514         __isl_give isl_multi_val *isl_multi_val_set_val(
3515                 __isl_take isl_multi_val *mv, int pos,
3516                 __isl_take isl_val *val);
3518         #include <isl/aff.h>
3519         __isl_give isl_multi_aff *isl_multi_aff_set_at(
3520                 __isl_take isl_multi_aff *ma, int pos,
3521                 __isl_take isl_aff *aff);
3522         __isl_give isl_multi_aff *isl_multi_aff_set_aff(
3523                 __isl_take isl_multi_aff *multi, int pos,
3524                 __isl_take isl_aff *aff);
3525         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_set_at(
3526                 __isl_take isl_multi_pw_aff *mpa, int pos,
3527                 __isl_take isl_pw_aff *pa);
3528         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_set_pw_aff(
3529                 __isl_take isl_multi_pw_aff *mpa, int pos,
3530                 __isl_take isl_pw_aff *pa);
3531         __isl_give isl_multi_union_pw_aff *
3532         isl_multi_union_pw_aff_set_at(
3533                 __isl_take isl_multi_union_pw_aff *mupa, int pos,
3534                 __isl_take isl_union_pw_aff *upa);
3535         __isl_give isl_multi_union_pw_aff *
3536         isl_multi_union_pw_aff_set_union_pw_aff(
3537                 __isl_take isl_multi_union_pw_aff *mupa, int pos,
3538                 __isl_take isl_union_pw_aff *upa);
3540 C<isl_multi_id_set_id> is an alternative name for C<isl_multi_id_set_at>.
3541 Similarly for the other pairs of functions.
3543 A list of all base expressions of a multiple
3544 expression can be extracted using the following functions.
3546         #include <isl/id.h>
3547         __isl_give isl_id_list *isl_multi_id_get_list(
3548                 __isl_keep isl_multi_id *mi);
3550         #include <isl/val.h>
3551         __isl_give isl_val_list *isl_multi_val_get_list(
3552                 __isl_keep isl_multi_val *mv);
3554         #include <isl/aff.h>
3555         __isl_give isl_aff_list *isl_multi_aff_get_list(
3556                 __isl_keep isl_multi_aff *multi);
3557         __isl_give isl_pw_aff_list *isl_multi_pw_aff_get_list(
3558                 __isl_keep isl_multi_pw_aff *mpa);
3559         __isl_give isl_union_pw_aff_list *
3560         isl_multi_union_pw_aff_list(
3561                 __isl_keep isl_multi_union_pw_aff *mupa);
3563 The constant terms of the base expressions can be obtained using
3564 the following function.
3566         #include <isl/aff.h>
3567         __isl_give isl_multi_val *
3568         isl_multi_aff_get_constant_multi_val(
3569                 __isl_keep isl_multi_aff *ma);
3571 As a convenience, a sequence of base expressions that have
3572 their domains in a given space can be extracted from a sequence
3573 of union expressions using the following function.
3575         #include <isl/aff.h>
3576         __isl_give isl_multi_pw_aff *
3577         isl_multi_union_pw_aff_extract_multi_pw_aff(
3578                 __isl_keep isl_multi_union_pw_aff *mupa,
3579                 __isl_take isl_space *space);
3581 Note that there is a difference between C<isl_multi_union_pw_aff>
3582 and C<isl_union_pw_multi_aff> objects.  The first is a sequence
3583 of unions of piecewise expressions, while the second is a union
3584 of piecewise sequences.  In particular, multiple affine expressions
3585 in an C<isl_union_pw_multi_aff> may live in different spaces,
3586 while there is only a single multiple expression in
3587 an C<isl_multi_union_pw_aff>, which can therefore only live
3588 in a single space.  This means that not every
3589 C<isl_union_pw_multi_aff> can be converted to
3590 an C<isl_multi_union_pw_aff>.  Conversely, the elements
3591 of an C<isl_multi_union_pw_aff> may be defined over different domains,
3592 while each multiple expression inside an C<isl_union_pw_multi_aff>
3593 has a single domain.  The conversion of an C<isl_union_pw_multi_aff>
3594 of dimension greater than one may therefore not be exact.
3595 The following functions can
3596 be used to perform these conversions when they are possible.
3598         #include <isl/aff.h>
3599         __isl_give isl_multi_union_pw_aff *
3600         isl_union_pw_multi_aff_as_multi_union_pw_aff(
3601                 __isl_take isl_union_pw_multi_aff *upma);
3602         __isl_give isl_multi_union_pw_aff *
3603         isl_multi_union_pw_aff_from_union_pw_multi_aff(
3604                 __isl_take isl_union_pw_multi_aff *upma);
3605         __isl_give isl_union_pw_multi_aff *
3606         isl_union_pw_multi_aff_from_multi_union_pw_aff(
3607                 __isl_take isl_multi_union_pw_aff *mupa);
3609 C<isl_union_pw_multi_aff_as_multi_union_pw_aff> and
3610 C<isl_multi_union_pw_aff_from_union_pw_multi_aff>
3611 perform the same operation.
3613 =head3 Piecewise Expressions
3615 A piecewise expression is an expression that is described
3616 using zero or more base expression defined over the same
3617 number of cells in the domain space of the base expressions.
3618 All base expressions are defined over the same
3619 domain space and the cells are disjoint.
3620 The space of a piecewise expression is the same as
3621 that of the base expressions.
3622 If the union of the cells is a strict subset of the domain
3623 space, then the value of the piecewise expression outside
3624 this union is different for types derived from quasi-affine
3625 expressions and those derived from quasipolynomials.
3626 Piecewise expressions derived from quasi-affine expressions
3627 are considered to be undefined outside the union of their cells.
3628 Piecewise expressions derived from quasipolynomials
3629 are considered to be zero outside the union of their cells.
3631 Piecewise quasipolynomials are mainly used by the C<barvinok>
3632 library for representing the number of elements in a parametric set or map.
3633 For example, the piecewise quasipolynomial
3635         [n] -> { [x] -> ((1 + n) - x) : x <= n and x >= 0 }
3637 represents the number of points in the map
3639         [n] -> { [x] -> [y] : x,y >= 0 and 0 <= x + y <= n }
3641 The piecewise expression types defined by C<isl>
3642 are C<isl_pw_aff>, C<isl_pw_multi_aff>,
3643 C<isl_pw_qpolynomial> and C<isl_pw_qpolynomial_fold>.
3645 A piecewise expression with no cells can be created using
3646 the following functions.
3648         #include <isl/aff.h>
3649         __isl_give isl_pw_aff *isl_pw_aff_empty(
3650                 __isl_take isl_space *space);
3651         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_empty(
3652                 __isl_take isl_space *space);
3654 A piecewise expression with a single universe cell can be
3655 created using the following functions.
3657         #include <isl/aff.h>
3658         __isl_give isl_pw_aff *isl_pw_aff_from_aff(
3659                 __isl_take isl_aff *aff);
3660         __isl_give isl_pw_multi_aff *
3661         isl_multi_aff_to_pw_multi_aff(
3662                 __isl_take isl_multi_aff *ma);
3663         __isl_give isl_pw_multi_aff *
3664         isl_pw_multi_aff_from_multi_aff(
3665                 __isl_take isl_multi_aff *ma);
3667         #include <isl/polynomial.h>
3668         __isl_give isl_pw_qpolynomial *
3669         isl_pw_qpolynomial_from_qpolynomial(
3670                 __isl_take isl_qpolynomial *qp);
3671         __isl_give isl_pw_qpolynomial_fold *
3672         isl_pw_qpolynomial_fold_from_qpolynomial_fold(
3673                 __isl_take isl_qpolynomial_fold *fold);
3675 C<isl_multi_aff_to_pw_multi_aff> and C<isl_pw_multi_aff_from_multi_aff> perform
3676 the same operation.
3678 The inverse conversions below can only be used if the input
3679 expression is known to be defined over a single universe domain.
3681         #include <isl/aff.h>
3682         isl_bool isl_pw_aff_isa_aff(__isl_keep isl_pw_aff *pa);
3683         __isl_give isl_aff *isl_pw_aff_as_aff(
3684                 __isl_take isl_pw_aff *pa);
3685         isl_bool isl_multi_pw_aff_isa_multi_aff(
3686                 __isl_keep isl_multi_pw_aff *mpa);
3687         __isl_give isl_multi_aff *isl_multi_pw_aff_as_multi_aff(
3688                 __isl_take isl_multi_pw_aff *mpa);
3689         isl_bool isl_pw_multi_aff_isa_multi_aff(
3690                 __isl_keep isl_pw_multi_aff *pma);
3691         __isl_give isl_multi_aff *isl_pw_multi_aff_as_multi_aff(
3692                 __isl_take isl_pw_multi_aff *pma);
3694         #include <isl/polynomial.h>
3695         isl_bool isl_pw_qpolynomial_isa_qpolynomial(
3696                 __isl_keep isl_pw_qpolynomial *pwqp);
3697         __isl_give isl_qpolynomial *
3698         isl_pw_qpolynomial_as_qpolynomial(
3699                 __isl_take isl_pw_qpolynomial *pwqp);
3700         isl_bool isl_pw_qpolynomial_fold_isa_qpolynomial_fold(
3701                 __isl_keep isl_pw_qpolynomial_fold *pwf);
3702         __isl_give isl_qpolynomial_fold *
3703         isl_pw_qpolynomial_fold_as_qpolynomial_fold(
3704                 __isl_take isl_pw_qpolynomial_fold *pwf);
3706 A piecewise expression with a single specified cell can be
3707 created using the following functions.
3709         #include <isl/aff.h>
3710         __isl_give isl_pw_aff *isl_pw_aff_alloc(
3711                 __isl_take isl_set *set, __isl_take isl_aff *aff);
3712         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_alloc(
3713                 __isl_take isl_set *set,
3714                 __isl_take isl_multi_aff *maff);
3716         #include <isl/polynomial.h>
3717         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_alloc(
3718                 __isl_take isl_set *set,
3719                 __isl_take isl_qpolynomial *qp);
3721 The following convenience functions first create a base expression and
3722 then create a piecewise expression over a universe domain.
3724         #include <isl/aff.h>
3725         __isl_give isl_pw_aff *isl_pw_aff_zero_on_domain(
3726                 __isl_take isl_local_space *ls);
3727         __isl_give isl_pw_aff *isl_pw_aff_var_on_domain(
3728                 __isl_take isl_local_space *ls,
3729                 enum isl_dim_type type, unsigned pos);
3730         __isl_give isl_pw_aff *isl_pw_aff_nan_on_domain_space(
3731                 __isl_take isl_space *space);
3732         __isl_give isl_pw_aff *isl_pw_aff_nan_on_domain(
3733                 __isl_take isl_local_space *ls);
3734         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_zero(
3735                 __isl_take isl_space *space);
3736         __isl_give isl_pw_multi_aff *
3737         isl_pw_multi_aff_identity_on_domain_space(
3738                 __isl_take isl_space *space)
3739         __isl_give isl_pw_multi_aff *
3740         isl_space_identity_pw_multi_aff_on_domain(
3741                 __isl_take isl_space *space)
3742         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_identity(
3743                 __isl_take isl_space *space);
3744         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_domain_map(
3745                 __isl_take isl_space *space);
3746         __isl_give isl_pw_multi_aff *
3747         isl_space_domain_map_pw_multi_aff(
3748                 __isl_take isl_space *space);
3749         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_range_map(
3750                 __isl_take isl_space *space);
3751         __isl_give isl_pw_multi_aff *
3752         isl_space_range_map_pw_multi_aff(
3753                 __isl_take isl_space *space);
3754         __isl_give isl_pw_multi_aff *
3755         isl_pw_multi_aff_project_out_map(
3756                 __isl_take isl_space *space,
3757                 enum isl_dim_type type,
3758                 unsigned first, unsigned n);
3760         #include <isl/polynomial.h>
3761         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_zero(
3762                 __isl_take isl_space *space);
3764 C<isl_pw_multi_aff_identity_on_domain_space> and
3765 C<isl_space_identity_pw_multi_aff_on_domain>
3766 perform the same operation.
3767 Similarly
3768 for the pair C<isl_pw_multi_aff_domain_map> and
3769 C<isl_space_domain_map_pw_multi_aff> and
3770 for the pair C<isl_pw_multi_aff_range_map> and
3771 C<isl_space_range_map_pw_multi_aff>.
3773 The following convenience functions first create a base expression and
3774 then create a piecewise expression over a given domain.
3776         #include <isl/aff.h>
3777         __isl_give isl_pw_aff *isl_pw_aff_val_on_domain(
3778                 __isl_take isl_set *domain,
3779                 __isl_take isl_val *v);
3780         __isl_give isl_pw_aff *isl_set_pw_aff_on_domain_val(
3781                 __isl_take isl_set *domain,
3782                 __isl_take isl_val *v);
3783         __isl_give isl_pw_multi_aff *
3784         isl_pw_multi_aff_multi_val_on_domain(
3785                 __isl_take isl_set *domain,
3786                 __isl_take isl_multi_val *mv);
3787         __isl_give isl_pw_multi_aff *
3788         isl_set_pw_multi_aff_on_domain_multi_val(
3789                 __isl_take isl_set *domain,
3790                 __isl_take isl_multi_val *mv);
3791         __isl_give isl_pw_aff *isl_pw_aff_param_on_domain_id(
3792                 __isl_take isl_set *domain,
3793                 __isl_take isl_id *id);
3794         __isl_give isl_pw_aff *isl_set_param_pw_aff_on_domain_id(
3795                 __isl_take isl_set *domain,
3796                 __isl_take isl_id *id);
3798 C<isl_set_pw_aff_on_domain_val> is an alternative name
3799 for C<isl_pw_aff_val_on_domain>.
3800 Similarly for the pair
3801 C<isl_set_pw_multi_aff_on_domain_multi_val> and
3802 C<isl_pw_multi_aff_multi_val_on_domain> and
3803 for the pair C<isl_set_param_pw_aff_on_domain_id> and
3804 C<isl_pw_aff_param_on_domain_id>.
3806 As a convenience, a piecewise multiple expression can
3807 also be created from a piecewise expression.
3808 Each multiple expression in the result is derived
3809 from the corresponding base expression.
3811         #include <isl/aff.h>
3812         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_pw_aff(
3813                 __isl_take isl_pw_aff *pa);
3815 Similarly, a piecewise quasipolynomial can be
3816 created from a piecewise quasi-affine expression using
3817 the following function.
3819         #include <isl/polynomial.h>
3820         __isl_give isl_pw_qpolynomial *
3821         isl_pw_qpolynomial_from_pw_aff(
3822                 __isl_take isl_pw_aff *pwaff);
3824 Piecewise expressions can be copied and freed using the following functions.
3826         #include <isl/aff.h>
3827         __isl_give isl_pw_aff *isl_pw_aff_copy(
3828                 __isl_keep isl_pw_aff *pwaff);
3829         __isl_null isl_pw_aff *isl_pw_aff_free(
3830                 __isl_take isl_pw_aff *pwaff);
3831         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_copy(
3832                 __isl_keep isl_pw_multi_aff *pma);
3833         __isl_null isl_pw_multi_aff *isl_pw_multi_aff_free(
3834                 __isl_take isl_pw_multi_aff *pma);
3836         #include <isl/polynomial.h>
3837         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_copy(
3838                 __isl_keep isl_pw_qpolynomial *pwqp);
3839         __isl_null isl_pw_qpolynomial *isl_pw_qpolynomial_free(
3840                 __isl_take isl_pw_qpolynomial *pwqp);
3841         __isl_give isl_pw_qpolynomial_fold *
3842         isl_pw_qpolynomial_fold_copy(
3843                 __isl_keep isl_pw_qpolynomial_fold *pwf);
3844         __isl_null isl_pw_qpolynomial_fold *
3845         isl_pw_qpolynomial_fold_free(
3846                 __isl_take isl_pw_qpolynomial_fold *pwf);
3848 To iterate over the different cells of a piecewise expression,
3849 use the following functions.
3851         #include <isl/aff.h>
3852         isl_bool isl_pw_aff_is_empty(__isl_keep isl_pw_aff *pwaff);
3853         isl_size isl_pw_aff_n_piece(__isl_keep isl_pw_aff *pwaff);
3854         isl_stat isl_pw_aff_foreach_piece(
3855                 __isl_keep isl_pw_aff *pwaff,
3856                 isl_stat (*fn)(__isl_take isl_set *set,
3857                           __isl_take isl_aff *aff,
3858                           void *user), void *user);
3859         isl_bool isl_pw_aff_every_piece(__isl_keep isl_pw_aff *pa,
3860                 isl_bool (*test)(__isl_keep isl_set *set,
3861                         __isl_keep isl_aff *aff, void *user),
3862                         void *user);
3863         isl_size isl_pw_multi_aff_n_piece(
3864                 __isl_keep isl_pw_multi_aff *pma);
3865         isl_stat isl_pw_multi_aff_foreach_piece(
3866                 __isl_keep isl_pw_multi_aff *pma,
3867                 isl_stat (*fn)(__isl_take isl_set *set,
3868                             __isl_take isl_multi_aff *maff,
3869                             void *user), void *user);
3870         isl_bool isl_pw_multi_aff_every_piece(
3871                 __isl_keep isl_pw_multi_aff *pma,
3872                 isl_bool (*test)(__isl_keep isl_set *set,
3873                         __isl_keep isl_multi_aff *ma, void *user),
3874                         void *user);
3876         #include <isl/polynomial.h>
3877         isl_size isl_pw_qpolynomial_n_piece(
3878                 __isl_keep isl_pw_qpolynomial *pwqp);
3879         isl_stat isl_pw_qpolynomial_foreach_piece(
3880                 __isl_keep isl_pw_qpolynomial *pwqp,
3881                 isl_stat (*fn)(__isl_take isl_set *set,
3882                           __isl_take isl_qpolynomial *qp,
3883                           void *user), void *user);
3884         isl_bool isl_pw_qpolynomial_every_piece(
3885                 __isl_keep isl_pw_qpolynomial *pwqp,
3886                 isl_bool (*test)(__isl_keep isl_set *set,
3887                         __isl_keep isl_qpolynomial *qp,
3888                         void *user), void *user);
3889         isl_stat isl_pw_qpolynomial_foreach_lifted_piece(
3890                 __isl_keep isl_pw_qpolynomial *pwqp,
3891                 isl_stat (*fn)(__isl_take isl_set *set,
3892                           __isl_take isl_qpolynomial *qp,
3893                           void *user), void *user);
3894         isl_size isl_pw_qpolynomial_fold_n_piece(
3895                 __isl_keep isl_pw_qpolynomial_fold *pwf);
3896         isl_stat isl_pw_qpolynomial_fold_foreach_piece(
3897                 __isl_keep isl_pw_qpolynomial_fold *pwf,
3898                 isl_stat (*fn)(__isl_take isl_set *set,
3899                           __isl_take isl_qpolynomial_fold *fold,
3900                           void *user), void *user);
3901         isl_bool isl_pw_qpolynomial_fold_every_piece(
3902                 __isl_keep isl_pw_qpolynomial_fold *pwf,
3903                 isl_bool (*test)(__isl_keep isl_set *set,
3904                         __isl_keep isl_qpolynomial_fold *fold,
3905                         void *user), void *user);
3906         isl_stat isl_pw_qpolynomial_fold_foreach_lifted_piece(
3907                 __isl_keep isl_pw_qpolynomial_fold *pwf,
3908                 isl_stat (*fn)(__isl_take isl_set *set,
3909                           __isl_take isl_qpolynomial_fold *fold,
3910                           void *user), void *user);
3912 As usual, the function C<fn> should return C<isl_stat_ok> on success
3913 and C<isl_stat_error> on failure.  The difference between
3914 C<isl_pw_qpolynomial_foreach_piece> and
3915 C<isl_pw_qpolynomial_foreach_lifted_piece> is that
3916 C<isl_pw_qpolynomial_foreach_lifted_piece> will first
3917 compute unique representations for all existentially quantified
3918 variables and then turn these existentially quantified variables
3919 into extra set variables, adapting the associated quasipolynomial
3920 accordingly.  This means that the C<set> passed to C<fn>
3921 will not have any existentially quantified variables, but that
3922 the dimensions of the sets may be different for different
3923 invocations of C<fn>.
3924 Similarly for C<isl_pw_qpolynomial_fold_foreach_piece>
3925 and C<isl_pw_qpolynomial_fold_foreach_lifted_piece>.
3926 The function C<isl_pw_aff_every_piece> and its variants
3927 check whether each call to the callback returns true and
3928 stop checking as soon as one of these calls returns false (or error).
3930 A piecewise expression consisting of the expressions at a given
3931 position of a piecewise multiple expression can be extracted
3932 using the following function.
3934         #include <isl/aff.h>
3935         __isl_give isl_pw_aff *isl_pw_multi_aff_get_at(
3936                 __isl_keep isl_pw_multi_aff *pma, int pos);
3937         __isl_give isl_pw_aff *isl_pw_multi_aff_get_pw_aff(
3938                 __isl_keep isl_pw_multi_aff *pma, int pos);
3940 C<isl_pw_multi_aff_get_pw_aff> is an alternative name for
3941 C<isl_pw_multi_aff_get_at>.
3943 These expressions can be replaced using the following function.
3945         #include <isl/aff.h>
3946         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_pw_aff(
3947                 __isl_take isl_pw_multi_aff *pma, unsigned pos,
3948                 __isl_take isl_pw_aff *pa);
3950 Note that there is a difference between C<isl_multi_pw_aff> and
3951 C<isl_pw_multi_aff> objects.  The first is a sequence of piecewise
3952 affine expressions, while the second is a piecewise sequence
3953 of affine expressions.  In particular, each of the piecewise
3954 affine expressions in an C<isl_multi_pw_aff> may have a different
3955 domain, while all multiple expressions associated to a cell
3956 in an C<isl_pw_multi_aff> have the same domain.
3957 It is possible to convert between the two, but when converting
3958 an C<isl_multi_pw_aff> to an C<isl_pw_multi_aff>, the domain
3959 of the result is the intersection of the domains of the input.
3960 The reverse conversion is exact.
3962         #include <isl/aff.h>
3963         __isl_give isl_pw_multi_aff *
3964         isl_pw_multi_aff_from_multi_pw_aff(
3965                 __isl_take isl_multi_pw_aff *mpa);
3966         __isl_give isl_multi_pw_aff *
3967         isl_pw_multi_aff_to_multi_pw_aff(
3968                 __isl_take isl_pw_multi_aff *pma);
3969         __isl_give isl_multi_pw_aff *
3970         isl_multi_pw_aff_from_pw_multi_aff(
3971                 __isl_take isl_pw_multi_aff *pma);
3973 C<isl_pw_multi_aff_to_multi_pw_aff> and
3974 C<isl_multi_pw_aff_from_pw_multi_aff> perform the same operation.
3976 =head3 Union Expressions
3978 A union expression collects base expressions defined
3979 over different domains.  The space of a union expression
3980 is that of the shared parameter space.
3982 The union expression types defined by C<isl>
3983 are C<isl_union_pw_aff>, C<isl_union_pw_multi_aff>,
3984 C<isl_union_pw_qpolynomial> and C<isl_union_pw_qpolynomial_fold>.
3985 In case of
3986 C<isl_union_pw_aff>,
3987 C<isl_union_pw_qpolynomial> and C<isl_union_pw_qpolynomial_fold>,
3988 there can be at most one base expression for a given domain space.
3989 In case of
3990 C<isl_union_pw_multi_aff>,
3991 there can be multiple such expressions for a given domain space,
3992 but the domains of these expressions need to be disjoint.
3994 An empty union expression can be created using the following functions.
3996         #include <isl/aff.h>
3997         __isl_give isl_union_pw_aff *
3998         isl_union_pw_aff_empty_ctx(
3999                 isl_ctx *ctx);
4000         __isl_give isl_union_pw_aff *
4001         isl_union_pw_aff_empty_space(
4002                 __isl_take isl_space *space);
4003         __isl_give isl_union_pw_aff *isl_union_pw_aff_empty(
4004                 __isl_take isl_space *space);
4005         __isl_give isl_union_pw_multi_aff *
4006         isl_union_pw_multi_aff_empty_ctx(
4007                 isl_ctx *ctx);
4008         __isl_give isl_union_pw_multi_aff *
4009         isl_union_pw_multi_aff_empty_space(
4010                 __isl_take isl_space *space);
4011         __isl_give isl_union_pw_multi_aff *
4012         isl_union_pw_multi_aff_empty(
4013                 __isl_take isl_space *space);
4015         #include <isl/polynomial.h>
4016         __isl_give isl_union_pw_qpolynomial *
4017         isl_union_pw_qpolynomial_zero_ctx(
4018                 isl_ctx *ctx);
4019         __isl_give isl_union_pw_qpolynomial *
4020         isl_union_pw_qpolynomial_zero_space(
4021                 __isl_take isl_space *space);
4022         __isl_give isl_union_pw_qpolynomial *
4023         isl_union_pw_qpolynomial_zero(
4024                 __isl_take isl_space *space);
4026 C<isl_union_pw_aff_empty> is an alternative name for
4027 C<isl_union_pw_aff_empty_space>.
4028 Similarly for the other pairs of functions.
4030 A union expression containing a single base expression
4031 can be created using the following functions.
4033         #include <isl/aff.h>
4034         __isl_give isl_union_pw_aff *
4035         isl_pw_aff_to_union_pw_aff(
4036                 __isl_take isl_pw_aff *pa);
4037         __isl_give isl_union_pw_aff *
4038         isl_union_pw_aff_from_pw_aff(
4039                 __isl_take isl_pw_aff *pa);
4040         __isl_give isl_union_pw_multi_aff *
4041         isl_union_pw_multi_aff_from_aff(
4042                 __isl_take isl_aff *aff);
4043         __isl_give isl_union_pw_multi_aff *
4044         isl_pw_multi_aff_to_union_pw_multi_aff(
4045                 __isl_take isl_pw_multi_aff *pma);
4046         __isl_give isl_union_pw_multi_aff *
4047         isl_union_pw_multi_aff_from_pw_multi_aff(
4048                 __isl_take isl_pw_multi_aff *pma);
4050         #include <isl/polynomial.h>
4051         __isl_give isl_union_pw_qpolynomial *
4052         isl_pw_qpolynomial_to_union_pw_qpolynomial(
4053                 __isl_take isl_pw_qpolynomial *pwqp);
4054         __isl_give isl_union_pw_qpolynomial *
4055         isl_union_pw_qpolynomial_from_pw_qpolynomial(
4056                 __isl_take isl_pw_qpolynomial *pwqp);
4057         __isl_give isl_union_pw_qpolynomial_fold *
4058         isl_pw_qpolynomial_fold_to_union_pw_qpolynomial_fold(
4059                 __isl_take isl_pw_qpolynomial_fold *pwf);
4060         __isl_give isl_union_pw_qpolynomial_fold *
4061         isl_union_pw_qpolynomial_fold_from_pw_qpolynomial_fold(
4062                 __isl_take isl_pw_qpolynomial_fold *pwf);
4064 C<isl_pw_aff_to_union_pw_aff> and C<isl_union_pw_aff_from_pw_aff> perform
4065 the same operation.
4066 Similarly for C<isl_pw_multi_aff_to_union_pw_multi_aff> and
4067 C<isl_union_pw_multi_aff_from_pw_multi_aff>,
4069 C<isl_pw_qpolynomial_to_union_pw_qpolynomial> and
4070 C<isl_union_pw_qpolynomial_from_pw_qpolynomial>, and
4072 C<isl_pw_qpolynomial_fold_to_union_pw_qpolynomial_fold> and
4073 C<isl_union_pw_qpolynomial_fold_from_pw_qpolynomial_fold>.
4075 The inverse conversions below can only be used if the input
4076 expression is known to live in exactly one space.
4078         #include <isl/aff.h>
4079         isl_bool isl_union_pw_multi_aff_isa_pw_multi_aff(
4080                 __isl_keep isl_union_pw_multi_aff *upma);
4081         __isl_give isl_pw_multi_aff *
4082         isl_union_pw_multi_aff_as_pw_multi_aff(
4083                 __isl_take isl_union_pw_multi_aff *upma);
4085 A union piecewise expression containing a single base expression
4086 on a universe domain can also be created directly from
4087 a base expression using the following functions.
4089         #include <isl/aff.h>
4090         __isl_give isl_union_pw_aff *isl_union_pw_aff_from_aff(
4091                 __isl_take isl_aff *aff);
4092         __isl_give isl_union_pw_multi_aff *
4093         isl_union_pw_multi_aff_from_multi_aff(
4094                 __isl_take isl_multi_aff *ma);
4096 The following functions create a base expression on each
4097 of the sets in the union set and collect the results.
4099         #include <isl/aff.h>
4100         __isl_give isl_union_pw_multi_aff *
4101         isl_union_pw_multi_aff_from_union_pw_aff(
4102                 __isl_take isl_union_pw_aff *upa);
4103         __isl_give isl_union_pw_aff *
4104         isl_union_pw_multi_aff_get_union_pw_aff(
4105                 __isl_keep isl_union_pw_multi_aff *upma, int pos);
4106         __isl_give isl_union_pw_aff *
4107         isl_union_pw_aff_val_on_domain(
4108                 __isl_take isl_union_set *domain,
4109                 __isl_take isl_val *v);
4110         __isl_give isl_union_pw_multi_aff *
4111         isl_union_pw_multi_aff_multi_val_on_domain(
4112                 __isl_take isl_union_set *domain,
4113                 __isl_take isl_multi_val *mv);
4114         __isl_give isl_union_pw_aff *
4115         isl_union_pw_aff_param_on_domain_id(
4116                 __isl_take isl_union_set *domain,
4117                 __isl_take isl_id *id);
4119 The C<id> argument of C<isl_union_pw_aff_param_on_domain_id>
4120 is the identifier of a parameter that may or may not already
4121 be present in C<domain>.
4123 An C<isl_union_pw_aff> that is equal to a (parametric) affine
4124 or piecewise affine
4125 expression on a given domain can be created using the following
4126 functions.
4128         #include <isl/aff.h>
4129         __isl_give isl_union_pw_aff *
4130         isl_union_pw_aff_aff_on_domain(
4131                 __isl_take isl_union_set *domain,
4132                 __isl_take isl_aff *aff);
4133         __isl_give isl_union_pw_aff *
4134         isl_union_pw_aff_pw_aff_on_domain(
4135                 __isl_take isl_union_set *domain,
4136                 __isl_take isl_pw_aff *pa);
4138 A base expression can be added to a union expression using
4139 the following functions.
4141         #include <isl/aff.h>
4142         __isl_give isl_union_pw_aff *
4143         isl_union_pw_aff_add_pw_aff(
4144                 __isl_take isl_union_pw_aff *upa,
4145                 __isl_take isl_pw_aff *pa);
4146         __isl_give isl_union_pw_multi_aff *
4147         isl_union_pw_multi_aff_add_pw_multi_aff(
4148                 __isl_take isl_union_pw_multi_aff *upma,
4149                 __isl_take isl_pw_multi_aff *pma);
4151         #include <isl/polynomial.h>
4152         __isl_give isl_union_pw_qpolynomial *
4153         isl_union_pw_qpolynomial_add_pw_qpolynomial(
4154                 __isl_take isl_union_pw_qpolynomial *upwqp,
4155                 __isl_take isl_pw_qpolynomial *pwqp);
4157 Union expressions can be copied and freed using
4158 the following functions.
4160         #include <isl/aff.h>
4161         __isl_give isl_union_pw_aff *isl_union_pw_aff_copy(
4162                 __isl_keep isl_union_pw_aff *upa);
4163         __isl_null isl_union_pw_aff *isl_union_pw_aff_free(
4164                 __isl_take isl_union_pw_aff *upa);
4165         __isl_give isl_union_pw_multi_aff *
4166         isl_union_pw_multi_aff_copy(
4167                 __isl_keep isl_union_pw_multi_aff *upma);
4168         __isl_null isl_union_pw_multi_aff *
4169         isl_union_pw_multi_aff_free(
4170                 __isl_take isl_union_pw_multi_aff *upma);
4172         #include <isl/polynomial.h>
4173         __isl_give isl_union_pw_qpolynomial *
4174         isl_union_pw_qpolynomial_copy(
4175                 __isl_keep isl_union_pw_qpolynomial *upwqp);
4176         __isl_null isl_union_pw_qpolynomial *
4177         isl_union_pw_qpolynomial_free(
4178                 __isl_take isl_union_pw_qpolynomial *upwqp);
4179         __isl_give isl_union_pw_qpolynomial_fold *
4180         isl_union_pw_qpolynomial_fold_copy(
4181                 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
4182         __isl_null isl_union_pw_qpolynomial_fold *
4183         isl_union_pw_qpolynomial_fold_free(
4184                 __isl_take isl_union_pw_qpolynomial_fold *upwf);
4186 To iterate over the base expressions in a union expression,
4187 use the following functions.
4189         #include <isl/aff.h>
4190         isl_size isl_union_pw_aff_n_pw_aff(
4191                 __isl_keep isl_union_pw_aff *upa);
4192         isl_stat isl_union_pw_aff_foreach_pw_aff(
4193                 __isl_keep isl_union_pw_aff *upa,
4194                 isl_stat (*fn)(__isl_take isl_pw_aff *pa,
4195                         void *user), void *user);
4196         isl_bool isl_union_pw_aff_every_pw_aff(
4197                 __isl_keep isl_union_pw_aff *upa,
4198                 isl_bool (*test)(__isl_keep isl_pw_aff *pa,
4199                         void *user), void *user);
4200         isl_size isl_union_pw_multi_aff_n_pw_multi_aff(
4201                 __isl_keep isl_union_pw_multi_aff *upma);
4202         isl_stat isl_union_pw_multi_aff_foreach_pw_multi_aff(
4203                 __isl_keep isl_union_pw_multi_aff *upma,
4204                 isl_stat (*fn)(__isl_take isl_pw_multi_aff *pma,
4205                             void *user), void *user);
4206         isl_bool isl_union_pw_multi_aff_every_pw_multi_aff(
4207                 __isl_keep isl_union_pw_multi_aff *upma,
4208                 isl_bool (*test)(
4209                         __isl_keep isl_pw_multi_aff *pma,
4210                         void *user), void *user);
4212         #include <isl/polynomial.h>
4213         isl_size isl_union_pw_qpolynomial_n_pw_qpolynomial(
4214                 __isl_keep isl_union_pw_qpolynomial *upwqp);
4215         isl_stat isl_union_pw_qpolynomial_foreach_pw_qpolynomial(
4216                 __isl_keep isl_union_pw_qpolynomial *upwqp,
4217                 isl_stat (*fn)(__isl_take isl_pw_qpolynomial *pwqp,
4218                             void *user), void *user);
4219         isl_bool isl_union_pw_qpolynomial_every_pw_qpolynomial(
4220                 __isl_keep isl_union_pw_qpolynomial *upwqp,
4221                 isl_bool (*test)(
4222                         __isl_keep isl_pw_qpolynomial *pwqp,
4223                         void *user), void *user);
4224         isl_size isl_union_pw_qpolynomial_fold_n_pw_qpolynomial_fold(
4225                 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
4226         isl_stat isl_union_pw_qpolynomial_fold_foreach_pw_qpolynomial_fold(
4227                 __isl_keep isl_union_pw_qpolynomial_fold *upwf,
4228                 isl_stat (*fn)(__isl_take isl_pw_qpolynomial_fold *pwf,
4229                             void *user), void *user);
4230         isl_bool
4231         isl_union_pw_qpolynomial_fold_every_pw_qpolynomial_fold(
4232                 __isl_keep isl_union_pw_qpolynomial_fold *upwf,
4233                 isl_bool (*test)(
4234                         __isl_keep isl_pw_qpolynomial_fold *pwf,
4235                         void *user), void *user);
4237 To extract the base expression in a given space from a union, use
4238 the following functions.
4240         #include <isl/aff.h>
4241         __isl_give isl_pw_aff *isl_union_pw_aff_extract_pw_aff(
4242                 __isl_keep isl_union_pw_aff *upa,
4243                 __isl_take isl_space *space);
4244         __isl_give isl_pw_multi_aff *
4245         isl_union_pw_multi_aff_extract_pw_multi_aff(
4246                 __isl_keep isl_union_pw_multi_aff *upma,
4247                 __isl_take isl_space *space);
4249         #include <isl/polynomial.h>
4250         __isl_give isl_pw_qpolynomial *
4251         isl_union_pw_qpolynomial_extract_pw_qpolynomial(
4252                 __isl_keep isl_union_pw_qpolynomial *upwqp,
4253                 __isl_take isl_space *space);
4255 It is also possible to obtain a list of the base expressions using
4256 the following functions.
4258         #include <isl/aff.h>
4259         __isl_give isl_pw_aff_list *
4260         isl_union_pw_aff_get_pw_aff_list(
4261                 __isl_keep isl_union_pw_aff *upa);
4262         __isl_give isl_pw_multi_aff_list *
4263         isl_union_pw_multi_aff_get_pw_multi_aff_list(
4264                 __isl_keep isl_union_pw_multi_aff *upma);
4266         #include <isl/polynomial.h>
4267         __isl_give isl_pw_qpolynomial_list *
4268         isl_union_pw_qpolynomial_get_pw_qpolynomial_list(
4269                 __isl_keep isl_union_pw_qpolynomial *upwqp);
4270         __isl_give isl_pw_qpolynomial_fold_list *
4271         isl_union_pw_qpolynomial_fold_get_pw_qpolynomial_fold_list(
4272                 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
4274 The returned list can be manipulated using the functions in L<"Lists">.
4276 =head2 Input and Output
4278 For set and relation,
4279 C<isl> supports its own input/output format, which is similar
4280 to the C<Omega> format, but also supports the C<PolyLib> format
4281 in some cases.
4282 For other object types, typically only an C<isl> format is supported.
4284 =head3 C<isl> format
4286 The C<isl> format is similar to that of C<Omega>, but has a different
4287 syntax for describing the parameters and allows for the definition
4288 of an existentially quantified variable as the integer division
4289 of an affine expression.
4290 For example, the set of integers C<i> between C<0> and C<n>
4291 such that C<i % 10 <= 6> can be described as
4293         [n] -> { [i] : exists (a = [i/10] : 0 <= i and i <= n and
4294                                 i - 10 a <= 6) }
4296 A set or relation can have several disjuncts, separated
4297 by the keyword C<or>.  Each disjunct is either a conjunction
4298 of constraints or a projection (C<exists>) of a conjunction
4299 of constraints.  The constraints are separated by the keyword
4300 C<and>.
4302 =head3 C<PolyLib> format
4304 If the represented set is a union, then the first line
4305 contains a single number representing the number of disjuncts.
4306 Otherwise, a line containing the number C<1> is optional.
4308 Each disjunct is represented by a matrix of constraints.
4309 The first line contains two numbers representing
4310 the number of rows and columns,
4311 where the number of rows is equal to the number of constraints
4312 and the number of columns is equal to two plus the number of variables.
4313 The following lines contain the actual rows of the constraint matrix.
4314 In each row, the first column indicates whether the constraint
4315 is an equality (C<0>) or inequality (C<1>).  The final column
4316 corresponds to the constant term.
4318 If the set is parametric, then the coefficients of the parameters
4319 appear in the last columns before the constant column.
4320 The coefficients of any existentially quantified variables appear
4321 between those of the set variables and those of the parameters.
4323 =head3 Extended C<PolyLib> format
4325 The extended C<PolyLib> format is nearly identical to the
4326 C<PolyLib> format.  The only difference is that the line
4327 containing the number of rows and columns of a constraint matrix
4328 also contains four additional numbers:
4329 the number of output dimensions, the number of input dimensions,
4330 the number of local dimensions (i.e., the number of existentially
4331 quantified variables) and the number of parameters.
4332 For sets, the number of ``output'' dimensions is equal
4333 to the number of set dimensions, while the number of ``input''
4334 dimensions is zero.
4336 =head3 Input
4338 Objects can be read from input using the following functions.
4340         #include <isl/id.h>
4341         __isl_give isl_id *isl_id_read_from_str(isl_ctx *ctx,
4342                 const char *str);
4343         __isl_give isl_multi_id *isl_multi_id_read_from_str(
4344                 isl_ctx *ctx, const char *str);
4346         #include <isl/val.h>
4347         __isl_give isl_val *isl_val_read_from_str(isl_ctx *ctx,
4348                 const char *str);
4349         __isl_give isl_multi_val *isl_multi_val_read_from_str(
4350                 isl_ctx *ctx, const char *str);
4352         #include <isl/space.h>
4353         __isl_give isl_space *isl_space_read_from_str(
4354                 isl_ctx *ctx, const char *str);
4356         #include <isl/set.h>
4357         __isl_give isl_basic_set *isl_basic_set_read_from_file(
4358                 isl_ctx *ctx, FILE *input);
4359         __isl_give isl_basic_set *isl_basic_set_read_from_str(
4360                 isl_ctx *ctx, const char *str);
4361         __isl_give isl_set *isl_set_read_from_file(isl_ctx *ctx,
4362                 FILE *input);
4363         __isl_give isl_set *isl_set_read_from_str(isl_ctx *ctx,
4364                 const char *str);
4366         #include <isl/map.h>
4367         __isl_give isl_basic_map *isl_basic_map_read_from_file(
4368                 isl_ctx *ctx, FILE *input);
4369         __isl_give isl_basic_map *isl_basic_map_read_from_str(
4370                 isl_ctx *ctx, const char *str);
4371         __isl_give isl_map *isl_map_read_from_file(
4372                 isl_ctx *ctx, FILE *input);
4373         __isl_give isl_map *isl_map_read_from_str(isl_ctx *ctx,
4374                 const char *str);
4376         #include <isl/union_set.h>
4377         __isl_give isl_union_set *isl_union_set_read_from_file(
4378                 isl_ctx *ctx, FILE *input);
4379         __isl_give isl_union_set *isl_union_set_read_from_str(
4380                 isl_ctx *ctx, const char *str);
4382         #include <isl/union_map.h>
4383         __isl_give isl_union_map *isl_union_map_read_from_file(
4384                 isl_ctx *ctx, FILE *input);
4385         __isl_give isl_union_map *isl_union_map_read_from_str(
4386                 isl_ctx *ctx, const char *str);
4388         #include <isl/aff.h>
4389         __isl_give isl_aff *isl_aff_read_from_str(
4390                 isl_ctx *ctx, const char *str);
4391         __isl_give isl_multi_aff *isl_multi_aff_read_from_str(
4392                 isl_ctx *ctx, const char *str);
4393         __isl_give isl_pw_aff *isl_pw_aff_read_from_str(
4394                 isl_ctx *ctx, const char *str);
4395         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_read_from_str(
4396                 isl_ctx *ctx, const char *str);
4397         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_read_from_str(
4398                 isl_ctx *ctx, const char *str);
4399         __isl_give isl_union_pw_aff *
4400         isl_union_pw_aff_read_from_str(
4401                 isl_ctx *ctx, const char *str);
4402         __isl_give isl_union_pw_multi_aff *
4403         isl_union_pw_multi_aff_read_from_str(
4404                 isl_ctx *ctx, const char *str);
4405         __isl_give isl_multi_union_pw_aff *
4406         isl_multi_union_pw_aff_read_from_str(
4407                 isl_ctx *ctx, const char *str);
4409         #include <isl/polynomial.h>
4410         __isl_give isl_union_pw_qpolynomial *
4411         isl_union_pw_qpolynomial_read_from_str(
4412                 isl_ctx *ctx, const char *str);
4414         __isl_give isl_pw_qpolynomial_fold *
4415         isl_pw_qpolynomial_fold_read_from_str(
4416                 isl_ctx *ctx, const char *str);
4418 For sets and relations,
4419 the input format is autodetected and may be either the C<PolyLib> format
4420 or the C<isl> format.
4422 =head3 Output
4424 Before anything can be printed, an C<isl_printer> needs to
4425 be created.
4427         __isl_give isl_printer *isl_printer_to_file(isl_ctx *ctx,
4428                 FILE *file);
4429         __isl_give isl_printer *isl_printer_to_str(isl_ctx *ctx);
4430         __isl_null isl_printer *isl_printer_free(
4431                 __isl_take isl_printer *printer);
4433 C<isl_printer_to_file> prints to the given file, while
4434 C<isl_printer_to_str> prints to a string that can be extracted
4435 using the following function.
4437         #include <isl/printer.h>
4438         __isl_give char *isl_printer_get_str(
4439                 __isl_keep isl_printer *printer);
4441 The printer can be inspected using the following functions.
4443         FILE *isl_printer_get_file(
4444                 __isl_keep isl_printer *printer);
4445         int isl_printer_get_output_format(
4446                 __isl_keep isl_printer *p);
4447         int isl_printer_get_yaml_style(__isl_keep isl_printer *p);
4449 The behavior of the printer can be modified in various ways
4451         __isl_give isl_printer *isl_printer_set_output_format(
4452                 __isl_take isl_printer *p, int output_format);
4453         __isl_give isl_printer *isl_printer_set_indent(
4454                 __isl_take isl_printer *p, int indent);
4455         __isl_give isl_printer *isl_printer_set_indent_prefix(
4456                 __isl_take isl_printer *p, const char *prefix);
4457         __isl_give isl_printer *isl_printer_indent(
4458                 __isl_take isl_printer *p, int indent);
4459         __isl_give isl_printer *isl_printer_set_prefix(
4460                 __isl_take isl_printer *p, const char *prefix);
4461         __isl_give isl_printer *isl_printer_set_suffix(
4462                 __isl_take isl_printer *p, const char *suffix);
4463         __isl_give isl_printer *isl_printer_set_yaml_style(
4464                 __isl_take isl_printer *p, int yaml_style);
4466 The C<output_format> may be either C<ISL_FORMAT_ISL>, C<ISL_FORMAT_OMEGA>,
4467 C<ISL_FORMAT_POLYLIB>, C<ISL_FORMAT_EXT_POLYLIB> or C<ISL_FORMAT_LATEX>
4468 and defaults to C<ISL_FORMAT_ISL>.
4469 Each line in the output is prefixed by C<indent_prefix>,
4470 indented by C<indent> (set by C<isl_printer_set_indent>) spaces
4471 (default: 0), prefixed by C<prefix> and suffixed by C<suffix>.
4472 In the C<PolyLib> format output,
4473 the coefficients of the existentially quantified variables
4474 appear between those of the set variables and those
4475 of the parameters.
4476 The function C<isl_printer_indent> increases the indentation
4477 by the specified amount (which may be negative).
4478 The YAML style may be either C<ISL_YAML_STYLE_BLOCK> or
4479 C<ISL_YAML_STYLE_FLOW> and when we are printing something
4480 in YAML format.
4482 To actually print something, use
4484         #include <isl/printer.h>
4485         __isl_give isl_printer *isl_printer_print_double(
4486                 __isl_take isl_printer *p, double d);
4488         #include <isl/val.h>
4489         __isl_give isl_printer *isl_printer_print_val(
4490                 __isl_take isl_printer *p, __isl_keep isl_val *v);
4491         __isl_give isl_printer *isl_printer_print_multi_val(
4492                 __isl_take isl_printer *p,
4493                 __isl_keep isl_multi_val *mv);
4495         #include <isl/set.h>
4496         __isl_give isl_printer *isl_printer_print_basic_set(
4497                 __isl_take isl_printer *printer,
4498                 __isl_keep isl_basic_set *bset);
4499         __isl_give isl_printer *isl_printer_print_set(
4500                 __isl_take isl_printer *printer,
4501                 __isl_keep isl_set *set);
4503         #include <isl/map.h>
4504         __isl_give isl_printer *isl_printer_print_basic_map(
4505                 __isl_take isl_printer *printer,
4506                 __isl_keep isl_basic_map *bmap);
4507         __isl_give isl_printer *isl_printer_print_map(
4508                 __isl_take isl_printer *printer,
4509                 __isl_keep isl_map *map);
4511         #include <isl/union_set.h>
4512         __isl_give isl_printer *isl_printer_print_union_set(
4513                 __isl_take isl_printer *p,
4514                 __isl_keep isl_union_set *uset);
4516         #include <isl/union_map.h>
4517         __isl_give isl_printer *isl_printer_print_union_map(
4518                 __isl_take isl_printer *p,
4519                 __isl_keep isl_union_map *umap);
4521         #include <isl/id.h>
4522         __isl_give isl_printer *isl_printer_print_multi_id(
4523                 __isl_take isl_printer *p,
4524                 __isl_keep isl_multi_id *mi);
4526         #include <isl/aff.h>
4527         __isl_give isl_printer *isl_printer_print_aff(
4528                 __isl_take isl_printer *p, __isl_keep isl_aff *aff);
4529         __isl_give isl_printer *isl_printer_print_multi_aff(
4530                 __isl_take isl_printer *p,
4531                 __isl_keep isl_multi_aff *maff);
4532         __isl_give isl_printer *isl_printer_print_pw_aff(
4533                 __isl_take isl_printer *p,
4534                 __isl_keep isl_pw_aff *pwaff);
4535         __isl_give isl_printer *isl_printer_print_pw_multi_aff(
4536                 __isl_take isl_printer *p,
4537                 __isl_keep isl_pw_multi_aff *pma);
4538         __isl_give isl_printer *isl_printer_print_multi_pw_aff(
4539                 __isl_take isl_printer *p,
4540                 __isl_keep isl_multi_pw_aff *mpa);
4541         __isl_give isl_printer *isl_printer_print_union_pw_aff(
4542                 __isl_take isl_printer *p,
4543                 __isl_keep isl_union_pw_aff *upa);
4544         __isl_give isl_printer *isl_printer_print_union_pw_multi_aff(
4545                 __isl_take isl_printer *p,
4546                 __isl_keep isl_union_pw_multi_aff *upma);
4547         __isl_give isl_printer *
4548         isl_printer_print_multi_union_pw_aff(
4549                 __isl_take isl_printer *p,
4550                 __isl_keep isl_multi_union_pw_aff *mupa);
4552         #include <isl/polynomial.h>
4553         __isl_give isl_printer *isl_printer_print_qpolynomial(
4554                 __isl_take isl_printer *p,
4555                 __isl_keep isl_qpolynomial *qp);
4556         __isl_give isl_printer *isl_printer_print_pw_qpolynomial(
4557                 __isl_take isl_printer *p,
4558                 __isl_keep isl_pw_qpolynomial *pwqp);
4559         __isl_give isl_printer *isl_printer_print_union_pw_qpolynomial(
4560                 __isl_take isl_printer *p,
4561                 __isl_keep isl_union_pw_qpolynomial *upwqp);
4563         __isl_give isl_printer *
4564         isl_printer_print_pw_qpolynomial_fold(
4565                 __isl_take isl_printer *p,
4566                 __isl_keep isl_pw_qpolynomial_fold *pwf);
4567         __isl_give isl_printer *
4568         isl_printer_print_union_pw_qpolynomial_fold(
4569                 __isl_take isl_printer *p,
4570                 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
4572 For C<isl_printer_print_qpolynomial>,
4573 C<isl_printer_print_pw_qpolynomial> and
4574 C<isl_printer_print_pw_qpolynomial_fold>,
4575 the output format of the printer
4576 needs to be set to either C<ISL_FORMAT_ISL> or C<ISL_FORMAT_C>.
4577 For C<isl_printer_print_union_pw_qpolynomial> and
4578 C<isl_printer_print_union_pw_qpolynomial_fold>, only C<ISL_FORMAT_ISL>
4579 is supported.
4580 In case of printing in C<ISL_FORMAT_C>, the user may want
4581 to set the names of all dimensions first.
4583 C<isl> also provides limited support for printing YAML documents,
4584 just enough for the internal use for printing such documents.
4586         #include <isl/printer.h>
4587         __isl_give isl_printer *isl_printer_yaml_start_mapping(
4588                 __isl_take isl_printer *p);
4589         __isl_give isl_printer *isl_printer_yaml_end_mapping(
4590                 __isl_take isl_printer *p);
4591         __isl_give isl_printer *isl_printer_yaml_start_sequence(
4592                 __isl_take isl_printer *p);
4593         __isl_give isl_printer *isl_printer_yaml_end_sequence(
4594                 __isl_take isl_printer *p);
4595         __isl_give isl_printer *isl_printer_yaml_next(
4596                 __isl_take isl_printer *p);
4598 A document is started by a call to either
4599 C<isl_printer_yaml_start_mapping> or C<isl_printer_yaml_start_sequence>.
4600 Anything printed to the printer after such a call belong to the
4601 first key of the mapping or the first element in the sequence.
4602 The function C<isl_printer_yaml_next> moves to the value if
4603 we are currently printing a mapping key, the next key if we
4604 are printing a value or the next element if we are printing
4605 an element in a sequence.
4606 Nested mappings and sequences are initiated by the same
4607 C<isl_printer_yaml_start_mapping> or C<isl_printer_yaml_start_sequence>.
4608 Each call to these functions needs to have a corresponding call to
4609 C<isl_printer_yaml_end_mapping> or C<isl_printer_yaml_end_sequence>.
4611 When called on a file printer, the following function flushes
4612 the file.  When called on a string printer, the buffer is cleared.
4614         __isl_give isl_printer *isl_printer_flush(
4615                 __isl_take isl_printer *p);
4617 The following functions allow the user to attach
4618 notes to a printer in order to keep track of additional state.
4620         #include <isl/printer.h>
4621         isl_bool isl_printer_has_note(__isl_keep isl_printer *p,
4622                 __isl_keep isl_id *id);
4623         __isl_give isl_id *isl_printer_get_note(
4624                 __isl_keep isl_printer *p, __isl_take isl_id *id);
4625         __isl_give isl_printer *isl_printer_set_note(
4626                 __isl_take isl_printer *p,
4627                 __isl_take isl_id *id, __isl_take isl_id *note);
4629 C<isl_printer_set_note> associates the given note to the given
4630 identifier in the printer.
4631 C<isl_printer_get_note> retrieves a note associated to an
4632 identifier, while
4633 C<isl_printer_has_note> checks if there is such a note.
4634 C<isl_printer_get_note> fails if the requested note does not exist.
4636 Alternatively, a string representation can be obtained
4637 directly using the following functions, which always print
4638 in isl format.
4640         #include <isl/id.h>
4641         __isl_give char *isl_id_to_str(
4642                 __isl_keep isl_id *id);
4643         __isl_give char *isl_multi_id_to_str(
4644                 __isl_keep isl_multi_id *mi);
4646         #include <isl/space.h>
4647         __isl_give char *isl_space_to_str(
4648                 __isl_keep isl_space *space);
4650         #include <isl/val.h>
4651         __isl_give char *isl_val_to_str(__isl_keep isl_val *v);
4652         __isl_give char *isl_multi_val_to_str(
4653                 __isl_keep isl_multi_val *mv);
4655         #include <isl/set.h>
4656         __isl_give char *isl_basic_set_to_str(
4657                 __isl_keep isl_basic_set *bset);
4658         __isl_give char *isl_set_to_str(
4659                 __isl_keep isl_set *set);
4661         #include <isl/union_set.h>
4662         __isl_give char *isl_union_set_to_str(
4663                 __isl_keep isl_union_set *uset);
4665         #include <isl/map.h>
4666         __isl_give char *isl_basic_map_to_str(
4667                 __isl_keep isl_basic_map *bmap);
4668         __isl_give char *isl_map_to_str(
4669                 __isl_keep isl_map *map);
4671         #include <isl/union_map.h>
4672         __isl_give char *isl_union_map_to_str(
4673                 __isl_keep isl_union_map *umap);
4675         #include <isl/aff.h>
4676         __isl_give char *isl_aff_to_str(__isl_keep isl_aff *aff);
4677         __isl_give char *isl_pw_aff_to_str(
4678                 __isl_keep isl_pw_aff *pa);
4679         __isl_give char *isl_multi_aff_to_str(
4680                 __isl_keep isl_multi_aff *ma);
4681         __isl_give char *isl_pw_multi_aff_to_str(
4682                 __isl_keep isl_pw_multi_aff *pma);
4683         __isl_give char *isl_multi_pw_aff_to_str(
4684                 __isl_keep isl_multi_pw_aff *mpa);
4685         __isl_give char *isl_union_pw_aff_to_str(
4686                 __isl_keep isl_union_pw_aff *upa);
4687         __isl_give char *isl_union_pw_multi_aff_to_str(
4688                 __isl_keep isl_union_pw_multi_aff *upma);
4689         __isl_give char *isl_multi_union_pw_aff_to_str(
4690                 __isl_keep isl_multi_union_pw_aff *mupa);
4692         #include <isl/point.h>
4693         __isl_give char *isl_point_to_str(
4694                 __isl_keep isl_point *pnt);
4696         #include <isl/polynomial.h>
4697         __isl_give char *isl_pw_qpolynomial_to_str(
4698                 __isl_keep isl_pw_qpolynomial *pwqp);
4699         __isl_give char *isl_union_pw_qpolynomial_to_str(
4700                 __isl_keep isl_union_pw_qpolynomial *upwqp);
4702 =head2 Properties
4704 =head3 Unary Properties
4706 =over
4708 =item * Emptiness
4710 The following functions test whether the given set or relation
4711 contains any integer points.  The ``plain'' variants do not perform
4712 any computations, but simply check if the given set or relation
4713 is already known to be empty.
4715         #include <isl/set.h>
4716         isl_bool isl_basic_set_plain_is_empty(
4717                 __isl_keep isl_basic_set *bset);
4718         isl_bool isl_basic_set_is_empty(
4719                 __isl_keep isl_basic_set *bset);
4720         isl_bool isl_set_plain_is_empty(
4721                 __isl_keep isl_set *set);
4722         isl_bool isl_set_is_empty(__isl_keep isl_set *set);
4724         #include <isl/union_set.h>
4725         isl_bool isl_union_set_is_empty(
4726                 __isl_keep isl_union_set *uset);
4728         #include <isl/map.h>
4729         isl_bool isl_basic_map_plain_is_empty(
4730                 __isl_keep isl_basic_map *bmap);
4731         isl_bool isl_basic_map_is_empty(
4732                 __isl_keep isl_basic_map *bmap);
4733         isl_bool isl_map_plain_is_empty(
4734                 __isl_keep isl_map *map);
4735         isl_bool isl_map_is_empty(__isl_keep isl_map *map);
4737         #include <isl/union_map.h>
4738         isl_bool isl_union_map_plain_is_empty(
4739                 __isl_keep isl_union_map *umap);
4740         isl_bool isl_union_map_is_empty(
4741                 __isl_keep isl_union_map *umap);
4743         #include <isl/aff.h>
4744         isl_bool isl_union_pw_multi_aff_plain_is_empty(
4745                 __isl_keep isl_union_pw_multi_aff *upma);
4747 =item * Universality
4749         isl_bool isl_basic_set_plain_is_universe(
4750                 __isl_keep isl_basic_set *bset);
4751         isl_bool isl_basic_set_is_universe(
4752                 __isl_keep isl_basic_set *bset);
4753         isl_bool isl_basic_map_plain_is_universe(
4754                 __isl_keep isl_basic_map *bmap);
4755         isl_bool isl_basic_map_is_universe(
4756                 __isl_keep isl_basic_map *bmap);
4757         isl_bool isl_set_plain_is_universe(
4758                 __isl_keep isl_set *set);
4759         isl_bool isl_map_plain_is_universe(
4760                 __isl_keep isl_map *map);
4762 =item * Single-valuedness
4764         #include <isl/set.h>
4765         isl_bool isl_set_is_singleton(__isl_keep isl_set *set);
4767         #include <isl/map.h>
4768         isl_bool isl_basic_map_is_single_valued(
4769                 __isl_keep isl_basic_map *bmap);
4770         isl_bool isl_map_plain_is_single_valued(
4771                 __isl_keep isl_map *map);
4772         isl_bool isl_map_is_single_valued(__isl_keep isl_map *map);
4774         #include <isl/union_map.h>
4775         isl_bool isl_union_map_is_single_valued(
4776                 __isl_keep isl_union_map *umap);
4778 =item * Injectivity
4780         isl_bool isl_map_plain_is_injective(
4781                 __isl_keep isl_map *map);
4782         isl_bool isl_map_is_injective(
4783                 __isl_keep isl_map *map);
4784         isl_bool isl_union_map_plain_is_injective(
4785                 __isl_keep isl_union_map *umap);
4786         isl_bool isl_union_map_is_injective(
4787                 __isl_keep isl_union_map *umap);
4789 =item * Bijectivity
4791         isl_bool isl_map_is_bijective(
4792                 __isl_keep isl_map *map);
4793         isl_bool isl_union_map_is_bijective(
4794                 __isl_keep isl_union_map *umap);
4796 =item * Identity
4798 The following functions test whether the given relation
4799 only maps elements to themselves.
4801         #include <isl/map.h>
4802         isl_bool isl_map_is_identity(
4803                 __isl_keep isl_map *map);
4805         #include <isl/union_map.h>
4806         isl_bool isl_union_map_is_identity(
4807                 __isl_keep isl_union_map *umap);
4809 =item * Position
4811         __isl_give isl_val *
4812         isl_basic_map_plain_get_val_if_fixed(
4813                 __isl_keep isl_basic_map *bmap,
4814                 enum isl_dim_type type, unsigned pos);
4815         __isl_give isl_val *isl_set_plain_get_val_if_fixed(
4816                 __isl_keep isl_set *set,
4817                 enum isl_dim_type type, unsigned pos);
4818         __isl_give isl_multi_val *
4819         isl_set_get_plain_multi_val_if_fixed(
4820                 __isl_keep isl_set *set);
4821         __isl_give isl_val *isl_map_plain_get_val_if_fixed(
4822                 __isl_keep isl_map *map,
4823                 enum isl_dim_type type, unsigned pos);
4825 If the set or relation obviously lies on a hyperplane where the given dimension
4826 has a fixed value, then return that value.
4827 Otherwise return NaN.
4828 C<isl_set_get_plain_multi_val_if_fixed> collects the results over
4829 all set dimensions.
4831 =item * Stride
4833 Stride detection is based on heuristics.
4834 The strides returned by the functions below are always valid,
4835 but there may be larger valid strides that are not detected.
4837         isl_stat isl_set_dim_residue_class_val(
4838                 __isl_keep isl_set *set,
4839                 int pos, __isl_give isl_val **modulo,
4840                 __isl_give isl_val **residue);
4842 Check if the values of the given set dimension are equal to a fixed
4843 value modulo some integer value.  If so, assign the modulo to C<*modulo>
4844 and the fixed value to C<*residue>.  If the given dimension attains only
4845 a single value, then assign C<0> to C<*modulo> and the fixed value to
4846 C<*residue>.
4847 If the dimension does not attain only a single value and if no modulo
4848 can be found then assign C<1> to C<*modulo> and C<1> to C<*residue>.
4850         #include <isl/set.h>
4851         __isl_give isl_stride_info *isl_set_get_stride_info(
4852                 __isl_keep isl_set *set, int pos);
4853         __isl_give isl_val *isl_set_get_stride(
4854                 __isl_keep isl_set *set, int pos);
4855         __isl_give isl_fixed_box *isl_set_get_lattice_tile(
4856                 __isl_keep isl_set *set);
4858         #include <isl/map.h>
4859         __isl_give isl_stride_info *
4860         isl_map_get_range_stride_info(
4861                 __isl_keep isl_map *map, int pos);
4862         __isl_give isl_fixed_box *
4863         isl_map_get_range_lattice_tile(
4864                 __isl_keep isl_map *map);
4866 Check if the values of the given set dimension are equal to
4867 some affine expression of the other dimensions (the offset)
4868 modulo some integer stride or
4869 check if the values of the given output dimensions are equal to
4870 some affine expression of the input dimensions (the offset)
4871 modulo some integer stride.
4872 If no more specific information can be found, then the stride
4873 is taken to be one and the offset is taken to be the zero expression.
4874 The function C<isl_set_get_stride> performs the same
4875 computation as C<isl_set_get_stride_info> but only returns the stride.
4876 The function C<isl_map_get_range_lattice_tile> collects the stride
4877 information over all output dimensions.
4878 In particular, it returns a tile of a rectangular lattice
4879 (possibly of size 1 in all directions)
4880 containing the output in terms of the parameters and the input dimensions.
4881 The size and the offset of this tile correspond to
4882 the strides and the offsets of the stride information and
4883 can be extracted from the returned
4884 C<isl_fixed_box> using the functions described under "Box hull" in
4885 L</"Unary Operations">.  Note that the C<isl_fixed_box> object returned by
4886 C<isl_map_get_range_lattice_tile> is always valid.
4887 The function C<isl_set_get_lattice_tile> collects the same stride
4888 information over all set dimensions.
4889 For the other functions,
4890 the stride and offset can be extracted from the returned object
4891 using the following functions.
4893         #include <isl/stride_info.h>
4894         __isl_give isl_val *isl_stride_info_get_stride(
4895                 __isl_keep isl_stride_info *si);
4896         __isl_give isl_aff *isl_stride_info_get_offset(
4897                 __isl_keep isl_stride_info *si);
4899 The stride info object can be copied and released using the following
4900 functions.
4902         #include <isl/stride_info.h>
4903         __isl_give isl_stride_info *isl_stride_info_copy(
4904                 __isl_keep isl_stride_info *si);
4905         __isl_null isl_stride_info *isl_stride_info_free(
4906                 __isl_take isl_stride_info *si);
4908 =item * Dependence
4910 To check whether a function involves any local variables,
4911 i.e., integer divisions,
4912 the following functions can be used.
4914         #include <isl/set.h>
4915         isl_bool isl_set_involves_locals(
4916                 __isl_keep isl_set *set);
4918         #include <isl/aff.h>
4919         isl_bool isl_aff_involves_locals(
4920                 __isl_keep isl_aff *aff);
4921         isl_bool isl_multi_aff_involves_locals(
4922                 __isl_keep isl_multi_aff *ma);
4923         isl_bool isl_pw_multi_aff_involves_locals(
4924                 __isl_keep isl_pw_multi_aff *pma);
4925         isl_bool isl_union_pw_multi_aff_involves_locals(
4926                 __isl_keep isl_union_pw_multi_aff *upma);
4928 To check whether the description of a set, relation or function depends
4929 on a parameter or one or more given dimensions,
4930 the following functions can be used.
4932         #include <isl/constraint.h>
4933         isl_bool isl_constraint_involves_dims(
4934                 __isl_keep isl_constraint *constraint,
4935                 enum isl_dim_type type, unsigned first, unsigned n);
4937         #include <isl/set.h>
4938         isl_bool isl_basic_set_involves_dims(
4939                 __isl_keep isl_basic_set *bset,
4940                 enum isl_dim_type type, unsigned first, unsigned n);
4941         isl_bool isl_set_involves_dims(__isl_keep isl_set *set,
4942                 enum isl_dim_type type, unsigned first, unsigned n);
4944         #include <isl/map.h>
4945         isl_bool isl_basic_map_involves_dims(
4946                 __isl_keep isl_basic_map *bmap,
4947                 enum isl_dim_type type, unsigned first, unsigned n);
4948         isl_bool isl_map_involves_dims(__isl_keep isl_map *map,
4949                 enum isl_dim_type type, unsigned first, unsigned n);
4951         #include <isl/union_map.h>
4952         isl_bool isl_union_map_involves_dims(
4953                 __isl_keep isl_union_map *umap,
4954                 enum isl_dim_type type, unsigned first, unsigned n);
4956         #include <isl/aff.h>
4957         isl_bool isl_aff_involves_dims(__isl_keep isl_aff *aff,
4958                 enum isl_dim_type type, unsigned first, unsigned n);
4959         isl_bool isl_pw_aff_involves_param_id(
4960                 __isl_keep isl_pw_aff *pa,
4961                 __isl_keep isl_id *id);
4962         isl_bool isl_pw_aff_involves_dims(
4963                 __isl_keep isl_pw_aff *pwaff,
4964                 enum isl_dim_type type, unsigned first, unsigned n);
4965         isl_bool isl_multi_aff_involves_dims(
4966                 __isl_keep isl_multi_aff *ma,
4967                 enum isl_dim_type type, unsigned first, unsigned n);
4968         isl_bool isl_pw_multi_aff_involves_param_id(
4969                 __isl_keep isl_pw_multi_aff *pma,
4970                 __isl_keep isl_id *id);
4971         isl_bool isl_pw_multi_aff_involves_dims(
4972                 __isl_keep isl_pw_multi_aff *pma,
4973                 enum isl_dim_type type, unsigned first, unsigned n);
4974         isl_bool isl_multi_pw_aff_involves_dims(
4975                 __isl_keep isl_multi_pw_aff *mpa,
4976                 enum isl_dim_type type, unsigned first, unsigned n);
4977         isl_bool isl_multi_pw_aff_involves_param_id(
4978                 __isl_keep isl_multi_pw_aff *mpa,
4979                 __isl_keep isl_id *id);
4980         isl_bool isl_multi_pw_aff_involves_param_id_list(
4981                 __isl_keep isl_multi_pw_aff *mpa,
4982                 __isl_keep isl_id_list *list);
4984         #include <isl/polynomial.h>
4985         isl_bool isl_qpolynomial_involves_dims(
4986                 __isl_keep isl_qpolynomial *qp,
4987                 enum isl_dim_type type, unsigned first, unsigned n);
4988         isl_bool isl_pw_qpolynomial_involves_param_id(
4989                 __isl_keep isl_pw_qpolynomial *pwqp,
4990                 __isl_keep isl_id *id);
4991         isl_bool isl_pw_qpolynomial_fold_involves_param_id(
4992                 __isl_keep isl_pw_qpolynomial_fold *pwf,
4993                 __isl_keep isl_id *id);
4995 Similarly, the following functions can be used to check whether
4996 a given dimension is involved in any lower or upper bound.
4998         #include <isl/set.h>
4999         isl_bool isl_set_dim_has_any_lower_bound(
5000                 __isl_keep isl_set *set,
5001                 enum isl_dim_type type, unsigned pos);
5002         isl_bool isl_set_dim_has_any_upper_bound(
5003                 __isl_keep isl_set *set,
5004                 enum isl_dim_type type, unsigned pos);
5006 Note that these functions return true even if there is a bound on
5007 the dimension on only some of the basic sets of C<set>.
5008 To check if they have a bound for all of the basic sets in C<set>,
5009 use the following functions instead.
5011         #include <isl/set.h>
5012         isl_bool isl_set_dim_has_lower_bound(
5013                 __isl_keep isl_set *set,
5014                 enum isl_dim_type type, unsigned pos);
5015         isl_bool isl_set_dim_has_upper_bound(
5016                 __isl_keep isl_set *set,
5017                 enum isl_dim_type type, unsigned pos);
5019 =item * Space
5021 To check whether a set is a parameter domain, use this function:
5023         isl_bool isl_set_is_params(__isl_keep isl_set *set);
5024         isl_bool isl_union_set_is_params(
5025                 __isl_keep isl_union_set *uset);
5027 =item * Wrapping
5029 The following functions check whether the space of the given
5030 (basic) set or relation domain and/or range is a wrapped relation.
5032         #include <isl/space.h>
5033         isl_bool isl_space_is_wrapping(
5034                 __isl_keep isl_space *space);
5035         isl_bool isl_space_domain_is_wrapping(
5036                 __isl_keep isl_space *space);
5037         isl_bool isl_space_range_is_wrapping(
5038                 __isl_keep isl_space *space);
5039         isl_bool isl_space_is_product(
5040                 __isl_keep isl_space *space);
5042         #include <isl/set.h>
5043         isl_bool isl_basic_set_is_wrapping(
5044                 __isl_keep isl_basic_set *bset);
5045         isl_bool isl_set_is_wrapping(__isl_keep isl_set *set);
5047         #include <isl/map.h>
5048         isl_bool isl_map_domain_is_wrapping(
5049                 __isl_keep isl_map *map);
5050         isl_bool isl_map_range_is_wrapping(
5051                 __isl_keep isl_map *map);
5052         isl_bool isl_map_is_product(__isl_keep isl_map *map);
5054         #include <isl/id.h>
5055         isl_bool isl_multi_id_range_is_wrapping(
5056                 __isl_keep isl_multi_id *mi);
5058         #include <isl/val.h>
5059         isl_bool isl_multi_val_range_is_wrapping(
5060                 __isl_keep isl_multi_val *mv);
5062         #include <isl/aff.h>
5063         isl_bool isl_multi_aff_range_is_wrapping(
5064                 __isl_keep isl_multi_aff *ma);
5065         isl_bool isl_multi_pw_aff_range_is_wrapping(
5066                 __isl_keep isl_multi_pw_aff *mpa);
5067         isl_bool isl_multi_union_pw_aff_range_is_wrapping(
5068                 __isl_keep isl_multi_union_pw_aff *mupa);
5070 The input to C<isl_space_is_wrapping> should
5071 be the space of a set, while that of
5072 C<isl_space_domain_is_wrapping> and
5073 C<isl_space_range_is_wrapping> should be the space of a relation.
5074 The input to C<isl_space_is_product> can be either the space
5075 of a set or that of a binary relation.
5076 In case the input is the space of a binary relation, it checks
5077 whether both domain and range are wrapping.
5079 =item * Internal Product
5081         isl_bool isl_basic_map_can_zip(
5082                 __isl_keep isl_basic_map *bmap);
5083         isl_bool isl_map_can_zip(__isl_keep isl_map *map);
5085 Check whether the product of domain and range of the given relation
5086 can be computed,
5087 i.e., whether both domain and range are nested relations.
5089 =item * Currying
5091         #include <isl/space.h>
5092         isl_bool isl_space_can_curry(
5093                 __isl_keep isl_space *space);
5095         #include <isl/map.h>
5096         isl_bool isl_basic_map_can_curry(
5097                 __isl_keep isl_basic_map *bmap);
5098         isl_bool isl_map_can_curry(__isl_keep isl_map *map);
5100 Check whether the domain of the (basic) relation is a wrapped relation.
5102         #include <isl/space.h>
5103         isl_bool isl_space_can_uncurry(
5104                 __isl_keep isl_space *space);
5106         #include <isl/map.h>
5107         isl_bool isl_basic_map_can_uncurry(
5108                 __isl_keep isl_basic_map *bmap);
5109         isl_bool isl_map_can_uncurry(__isl_keep isl_map *map);
5111 Check whether the range of the (basic) relation is a wrapped relation.
5113         #include <isl/space.h>
5114         isl_bool isl_space_can_range_curry(
5115                 __isl_keep isl_space *space);
5117         #include <isl/map.h>
5118         isl_bool isl_map_can_range_curry(
5119                 __isl_keep isl_map *map);
5121 Check whether the domain of the relation wrapped in the range of
5122 the input is itself a wrapped relation.
5124 =item * Special Values
5126         #include <isl/aff.h>
5127         isl_bool isl_aff_is_cst(__isl_keep isl_aff *aff);
5128         isl_bool isl_pw_aff_is_cst(__isl_keep isl_pw_aff *pwaff);
5129         isl_bool isl_multi_pw_aff_is_cst(
5130                 __isl_keep isl_multi_pw_aff *mpa);
5132 Check whether the given expression is a constant.
5134         #include <isl/val.h>
5135         isl_bool isl_multi_val_involves_nan(
5136                 __isl_keep isl_multi_val *mv);
5138         #include <isl/aff.h>
5139         isl_bool isl_aff_is_nan(__isl_keep isl_aff *aff);
5140         isl_bool isl_multi_aff_involves_nan(
5141                 __isl_keep isl_multi_aff *ma);
5142         isl_bool isl_pw_aff_involves_nan(
5143                 __isl_keep isl_pw_aff *pa);
5144         isl_bool isl_pw_multi_aff_involves_nan(
5145                 __isl_keep isl_pw_multi_aff *pma);
5146         isl_bool isl_multi_pw_aff_involves_nan(
5147                 __isl_keep isl_multi_pw_aff *mpa);
5148         isl_bool isl_union_pw_aff_involves_nan(
5149                 __isl_keep isl_union_pw_aff *upa);
5150         isl_bool isl_union_pw_multi_aff_involves_nan(
5151                 __isl_keep isl_union_pw_multi_aff *upma);
5152         isl_bool isl_multi_union_pw_aff_involves_nan(
5153                 __isl_keep isl_multi_union_pw_aff *mupa);
5155         #include <isl/polynomial.h>
5156         isl_bool isl_qpolynomial_is_nan(
5157                 __isl_keep isl_qpolynomial *qp);
5158         isl_bool isl_qpolynomial_fold_is_nan(
5159                 __isl_keep isl_qpolynomial_fold *fold);
5160         isl_bool isl_pw_qpolynomial_involves_nan(
5161                 __isl_keep isl_pw_qpolynomial *pwqp);
5162         isl_bool isl_pw_qpolynomial_fold_involves_nan(
5163                 __isl_keep isl_pw_qpolynomial_fold *pwf);
5164         isl_bool isl_union_pw_qpolynomial_involves_nan(
5165                 __isl_keep isl_union_pw_qpolynomial *upwqp);
5166         isl_bool isl_union_pw_qpolynomial_fold_involves_nan(
5167                 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
5169 Check whether the given expression is equal to or involves NaN.
5171         #include <isl/val.h>
5172         isl_bool isl_multi_val_is_zero(
5173                 __isl_keep isl_multi_val *mv);
5175 Check whether the multiple value is zero.
5177         #include <isl/aff.h>
5178         isl_bool isl_aff_plain_is_zero(
5179                 __isl_keep isl_aff *aff);
5181 Check whether the affine expression is obviously zero.
5183 =back
5185 =head3 Binary Properties
5187 =over
5189 =item * Equality
5191 The following functions check whether two objects
5192 represent the same set, relation or function.
5193 The C<plain> variants only return true if the objects
5194 are obviously the same.  That is, they may return false
5195 even if the objects are the same, but they will never
5196 return true if the objects are not the same.
5198         #include <isl/set.h>
5199         isl_bool isl_basic_set_plain_is_equal(
5200                 __isl_keep isl_basic_set *bset1,
5201                 __isl_keep isl_basic_set *bset2);
5202         isl_bool isl_basic_set_is_equal(
5203                 __isl_keep isl_basic_set *bset1,
5204                 __isl_keep isl_basic_set *bset2);
5205         isl_bool isl_set_plain_is_equal(
5206                 __isl_keep isl_set *set1,
5207                 __isl_keep isl_set *set2);
5208         isl_bool isl_set_is_equal(__isl_keep isl_set *set1,
5209                 __isl_keep isl_set *set2);
5211         #include <isl/map.h>
5212         isl_bool isl_basic_map_is_equal(
5213                 __isl_keep isl_basic_map *bmap1,
5214                 __isl_keep isl_basic_map *bmap2);
5215         isl_bool isl_map_is_equal(__isl_keep isl_map *map1,
5216                 __isl_keep isl_map *map2);
5217         isl_bool isl_map_plain_is_equal(
5218                 __isl_keep isl_map *map1,
5219                 __isl_keep isl_map *map2);
5221         #include <isl/union_set.h>
5222         isl_bool isl_union_set_is_equal(
5223                 __isl_keep isl_union_set *uset1,
5224                 __isl_keep isl_union_set *uset2);
5226         #include <isl/union_map.h>
5227         isl_bool isl_union_map_is_equal(
5228                 __isl_keep isl_union_map *umap1,
5229                 __isl_keep isl_union_map *umap2);
5231         #include <isl/id.h>
5232         isl_bool isl_multi_id_plain_is_equal(
5233                 __isl_keep isl_multi_id *mi1,
5234                 __isl_keep isl_multi_id *mi2);
5236         #include <isl/val.h>
5237         isl_bool isl_multi_val_plain_is_equal(
5238                 __isl_keep isl_multi_val *mv1,
5239                 __isl_keep isl_multi_val *mv2);
5241         #include <isl/aff.h>
5242         isl_bool isl_aff_plain_is_equal(
5243                 __isl_keep isl_aff *aff1,
5244                 __isl_keep isl_aff *aff2);
5245         isl_bool isl_multi_aff_plain_is_equal(
5246                 __isl_keep isl_multi_aff *maff1,
5247                 __isl_keep isl_multi_aff *maff2);
5248         isl_bool isl_pw_aff_plain_is_equal(
5249                 __isl_keep isl_pw_aff *pwaff1,
5250                 __isl_keep isl_pw_aff *pwaff2);
5251         isl_bool isl_pw_aff_is_equal(
5252                 __isl_keep isl_pw_aff *pa1,
5253                 __isl_keep isl_pw_aff *pa2);
5254         isl_bool isl_pw_multi_aff_plain_is_equal(
5255                 __isl_keep isl_pw_multi_aff *pma1,
5256                 __isl_keep isl_pw_multi_aff *pma2);
5257         isl_bool isl_pw_multi_aff_is_equal(
5258                 __isl_keep isl_pw_multi_aff *pma1,
5259                 __isl_keep isl_pw_multi_aff *pma2);
5260         isl_bool isl_multi_pw_aff_plain_is_equal(
5261                 __isl_keep isl_multi_pw_aff *mpa1,
5262                 __isl_keep isl_multi_pw_aff *mpa2);
5263         isl_bool isl_multi_pw_aff_is_equal(
5264                 __isl_keep isl_multi_pw_aff *mpa1,
5265                 __isl_keep isl_multi_pw_aff *mpa2);
5266         isl_bool isl_union_pw_aff_plain_is_equal(
5267                 __isl_keep isl_union_pw_aff *upa1,
5268                 __isl_keep isl_union_pw_aff *upa2);
5269         isl_bool isl_union_pw_multi_aff_plain_is_equal(
5270                 __isl_keep isl_union_pw_multi_aff *upma1,
5271                 __isl_keep isl_union_pw_multi_aff *upma2);
5272         isl_bool isl_multi_union_pw_aff_plain_is_equal(
5273                 __isl_keep isl_multi_union_pw_aff *mupa1,
5274                 __isl_keep isl_multi_union_pw_aff *mupa2);
5276         #include <isl/polynomial.h>
5277         isl_bool isl_union_pw_qpolynomial_plain_is_equal(
5278                 __isl_keep isl_union_pw_qpolynomial *upwqp1,
5279                 __isl_keep isl_union_pw_qpolynomial *upwqp2);
5280         isl_bool isl_union_pw_qpolynomial_fold_plain_is_equal(
5281                 __isl_keep isl_union_pw_qpolynomial_fold *upwf1,
5282                 __isl_keep isl_union_pw_qpolynomial_fold *upwf2);
5284 =item * Disjointness
5286         #include <isl/set.h>
5287         isl_bool isl_basic_set_is_disjoint(
5288                 __isl_keep isl_basic_set *bset1,
5289                 __isl_keep isl_basic_set *bset2);
5290         isl_bool isl_set_plain_is_disjoint(
5291                 __isl_keep isl_set *set1,
5292                 __isl_keep isl_set *set2);
5293         isl_bool isl_set_is_disjoint(__isl_keep isl_set *set1,
5294                 __isl_keep isl_set *set2);
5296         #include <isl/map.h>
5297         isl_bool isl_basic_map_is_disjoint(
5298                 __isl_keep isl_basic_map *bmap1,
5299                 __isl_keep isl_basic_map *bmap2);
5300         isl_bool isl_map_is_disjoint(__isl_keep isl_map *map1,
5301                 __isl_keep isl_map *map2);
5303         #include <isl/union_set.h>
5304         isl_bool isl_union_set_is_disjoint(
5305                 __isl_keep isl_union_set *uset1,
5306                 __isl_keep isl_union_set *uset2);
5308         #include <isl/union_map.h>
5309         isl_bool isl_union_map_is_disjoint(
5310                 __isl_keep isl_union_map *umap1,
5311                 __isl_keep isl_union_map *umap2);
5313 =item * Subset
5315         isl_bool isl_basic_set_is_subset(
5316                 __isl_keep isl_basic_set *bset1,
5317                 __isl_keep isl_basic_set *bset2);
5318         isl_bool isl_set_is_subset(__isl_keep isl_set *set1,
5319                 __isl_keep isl_set *set2);
5320         isl_bool isl_set_is_strict_subset(
5321                 __isl_keep isl_set *set1,
5322                 __isl_keep isl_set *set2);
5323         isl_bool isl_union_set_is_subset(
5324                 __isl_keep isl_union_set *uset1,
5325                 __isl_keep isl_union_set *uset2);
5326         isl_bool isl_union_set_is_strict_subset(
5327                 __isl_keep isl_union_set *uset1,
5328                 __isl_keep isl_union_set *uset2);
5329         isl_bool isl_basic_map_is_subset(
5330                 __isl_keep isl_basic_map *bmap1,
5331                 __isl_keep isl_basic_map *bmap2);
5332         isl_bool isl_basic_map_is_strict_subset(
5333                 __isl_keep isl_basic_map *bmap1,
5334                 __isl_keep isl_basic_map *bmap2);
5335         isl_bool isl_map_is_subset(
5336                 __isl_keep isl_map *map1,
5337                 __isl_keep isl_map *map2);
5338         isl_bool isl_map_is_strict_subset(
5339                 __isl_keep isl_map *map1,
5340                 __isl_keep isl_map *map2);
5341         isl_bool isl_union_map_is_subset(
5342                 __isl_keep isl_union_map *umap1,
5343                 __isl_keep isl_union_map *umap2);
5344         isl_bool isl_union_map_is_strict_subset(
5345                 __isl_keep isl_union_map *umap1,
5346                 __isl_keep isl_union_map *umap2);
5348 Check whether the first argument is a (strict) subset of the
5349 second argument.
5351 =item * Order
5353 Every comparison function returns a negative value if the first
5354 argument is considered smaller than the second, a positive value
5355 if the first argument is considered greater and zero if the two
5356 constraints are considered the same by the comparison criterion.
5358         #include <isl/constraint.h>
5359         int isl_constraint_plain_cmp(
5360                 __isl_keep isl_constraint *c1,
5361                 __isl_keep isl_constraint *c2);
5363 This function is useful for sorting C<isl_constraint>s.
5364 The order depends on the internal representation of the inputs.
5365 The order is fixed over different calls to the function (assuming
5366 the internal representation of the inputs has not changed), but may
5367 change over different versions of C<isl>.
5369         #include <isl/constraint.h>
5370         int isl_constraint_cmp_last_non_zero(
5371                 __isl_keep isl_constraint *c1,
5372                 __isl_keep isl_constraint *c2);
5374 This function can be used to sort constraints that live in the same
5375 local space.  Constraints that involve ``earlier'' dimensions or
5376 that have a smaller coefficient for the shared latest dimension
5377 are considered smaller than other constraints.
5378 This function only defines a B<partial> order.
5380         #include <isl/set.h>
5381         int isl_set_plain_cmp(__isl_keep isl_set *set1,
5382                 __isl_keep isl_set *set2);
5384 This function is useful for sorting C<isl_set>s.
5385 The order depends on the internal representation of the inputs.
5386 The order is fixed over different calls to the function (assuming
5387 the internal representation of the inputs has not changed), but may
5388 change over different versions of C<isl>.
5390         #include <isl/aff.h>
5391         int isl_multi_aff_plain_cmp(
5392                 __isl_keep isl_multi_aff *ma1,
5393                 __isl_keep isl_multi_aff *ma2);
5394         int isl_pw_aff_plain_cmp(__isl_keep isl_pw_aff *pa1,
5395                 __isl_keep isl_pw_aff *pa2);
5397 The functions C<isl_multi_aff_plain_cmp> and
5398 C<isl_pw_aff_plain_cmp> can be used to sort C<isl_multi_aff>s and
5399 C<isl_pw_aff>s.  The order is not strictly defined.
5400 The current order sorts expressions that only involve
5401 earlier dimensions before those that involve later dimensions.
5403 =back
5405 =head2 Unary Operations
5407 =over
5409 =item * Complement
5411         __isl_give isl_set *isl_set_complement(
5412                 __isl_take isl_set *set);
5413         __isl_give isl_map *isl_map_complement(
5414                 __isl_take isl_map *map);
5416 =item * Inverse map
5418         #include <isl/space.h>
5419         __isl_give isl_space *isl_space_reverse(
5420                 __isl_take isl_space *space);
5421         __isl_give isl_space *isl_space_wrapped_reverse(
5422                 __isl_take isl_space *space);
5423         __isl_give isl_space *isl_space_domain_reverse(
5424                 __isl_take isl_space *space);
5425         __isl_give isl_space *isl_space_range_reverse(
5426                 __isl_take isl_space *space);
5428         #include <isl/aff.h>
5429         __isl_give isl_aff *isl_aff_domain_reverse(
5430                 __isl_take isl_aff *aff);
5431         __isl_give isl_multi_aff *
5432         isl_multi_aff_domain_reverse(
5433                 __isl_take isl_multi_aff *ma);
5434         __isl_give isl_pw_aff *isl_pw_aff_domain_reverse(
5435                 __isl_take isl_pw_aff *pa);
5436         __isl_give isl_pw_multi_aff *
5437         isl_pw_multi_aff_domain_reverse(
5438                 __isl_take isl_pw_multi_aff *pma);
5439         __isl_give isl_multi_pw_aff *
5440         isl_multi_pw_aff_domain_reverse(
5441                 __isl_take isl_multi_pw_aff *mpa);
5443         #include <isl/set.h>
5444         __isl_give isl_set *isl_set_wrapped_reverse(
5445                 __isl_take isl_set *set);
5447         #include <isl/map.h>
5448         __isl_give isl_basic_map *isl_basic_map_reverse(
5449                 __isl_take isl_basic_map *bmap);
5450         __isl_give isl_map *isl_map_reverse(
5451                 __isl_take isl_map *map);
5452         __isl_give isl_map *isl_map_domain_reverse(
5453                 __isl_take isl_map *map);
5454         __isl_give isl_map *isl_map_range_reverse(
5455                 __isl_take isl_map *map);
5457         #include <isl/union_map.h>
5458         __isl_give isl_union_map *isl_union_map_reverse(
5459                 __isl_take isl_union_map *umap);
5460         __isl_give isl_union_map *isl_union_map_range_reverse(
5461                 __isl_take isl_union_map *umap);
5463 The function C<isl_space_range_reverse> reverses the relation
5464 that is embedded in the range of the input map space.
5465 The identifier of the range, if any, is only preserved
5466 if this embedded relation has identical input and output tuples.
5467 Similarly for C<isl_space_domain_reverse>.
5468 Along the same lines, C<isl_space_wrapped_reverse> reverses
5469 the relation that is embedded in a set space.
5471 =item * Tuple binding
5473 The following function binds
5474 a tuple to a sequence of parameter identifiers, equating
5475 the tuple dimensions to the parameters with those identifiers and
5476 subsequently projecting out the tuple.
5477 If the original object did not reference any such parameters,
5478 then this means that the tuple dimensions are reinterpreted
5479 as parameters.
5480 The space of C<tuple> needs to match that of the bound tuple.
5482         #include <isl/set.h>
5483         __isl_give isl_set *isl_set_bind(
5484                 __isl_take isl_set *set,
5485                 __isl_take isl_multi_id *tuple);
5487         #include <isl/map.h>
5488         __isl_give isl_set *isl_map_bind_domain(
5489                 __isl_take isl_map *map,
5490                 __isl_take isl_multi_id *tuple);
5491         __isl_give isl_set *isl_map_bind_range(
5492                 __isl_take isl_map *map,
5493                 __isl_take isl_multi_id *tuple);
5495         #include <isl/union_map.h>
5496         __isl_give isl_union_set *isl_union_map_bind_range(
5497                 __isl_take isl_union_map *umap,
5498                 __isl_take isl_multi_id *tuple);
5500         #include <isl/aff.h>
5501         __isl_give isl_pw_aff *isl_pw_aff_bind_domain(
5502                 __isl_take isl_pw_aff *pa,
5503                 __isl_take isl_multi_id *tuple);
5504         __isl_give isl_multi_aff *isl_multi_aff_bind_domain(
5505                 __isl_take isl_multi_aff *ma,
5506                 __isl_take isl_multi_id *tuple);
5507         __isl_give isl_pw_multi_aff *
5508         isl_pw_multi_aff_bind_domain(
5509                 __isl_take isl_pw_multi_aff *pma,
5510                 __isl_take isl_multi_id *tuple);
5511         __isl_give isl_multi_pw_aff *
5512         isl_multi_pw_aff_bind_domain(
5513                 __isl_take isl_multi_pw_aff *mpa,
5514                 __isl_take isl_multi_id *tuple);
5515         __isl_give isl_pw_aff *
5516         isl_pw_aff_bind_domain_wrapped_domain(
5517                 __isl_take isl_pw_aff *pa,
5518                 __isl_take isl_multi_id *tuple);
5519         __isl_give isl_multi_aff *
5520         isl_multi_aff_bind_domain_wrapped_domain(
5521                 __isl_take isl_multi_aff *ma,
5522                 __isl_take isl_multi_id *tuple);
5523         __isl_give isl_pw_multi_aff *
5524         isl_pw_multi_aff_bind_domain_wrapped_domain(
5525                 __isl_take isl_pw_multi_aff *pma,
5526                 __isl_take isl_multi_id *tuple);
5527         __isl_give isl_multi_pw_aff *
5528         isl_multi_pw_aff_bind_domain_wrapped_domain(
5529                 __isl_take isl_multi_pw_aff *mpa,
5530                 __isl_take isl_multi_id *tuple);
5531         __isl_give isl_basic_set *isl_aff_bind_id(
5532                 __isl_take isl_aff *aff,
5533                 __isl_take isl_id *id);
5534         __isl_give isl_set *isl_pw_aff_bind_id(
5535                 __isl_take isl_pw_aff *pa,
5536                 __isl_take isl_id *id);
5537         __isl_give isl_basic_set *isl_multi_aff_bind(
5538                 __isl_take isl_multi_aff *ma,
5539                 __isl_take isl_multi_id *tuple);
5540         __isl_give isl_set *isl_multi_pw_aff_bind(
5541                 __isl_take isl_multi_pw_aff *mpa,
5542                 __isl_take isl_multi_id *tuple);
5543         __isl_give isl_union_set *isl_union_pw_aff_bind_id(
5544                 __isl_take isl_union_pw_aff *upa,
5545                 __isl_take isl_id *id);
5546         __isl_give isl_union_set *
5547         isl_multi_union_pw_aff_bind(
5548                 __isl_take isl_multi_union_pw_aff *mupa,
5549                 __isl_take isl_multi_id *tuple);
5551 Projecting out the domain of the wrapped relation in the domain
5552 of a function leaves the range of that wrapped relation
5553 in the domain of the resulting function.
5554 In the case of C<isl_aff_bind_id>, C<isl_pw_aff_bind_id>,
5555 C<isl_multi_aff_bind>, C<isl_multi_pw_aff_bind>,
5556 C<isl_union_pw_aff_bind_id> and
5557 C<isl_multi_union_pw_aff_bind>, the parameters
5558 are bound to the function values and the result lives
5559 in the domain of the input function.
5561 =item * Projection
5563         #include <isl/space.h>
5564         __isl_give isl_space *isl_space_domain(
5565                 __isl_take isl_space *space);
5566         __isl_give isl_space *isl_space_range(
5567                 __isl_take isl_space *space);
5568         __isl_give isl_space *isl_space_params(
5569                 __isl_take isl_space *space);
5570         __isl_give isl_space *
5571         isl_space_domain_wrapped_domain(
5572                 __isl_take isl_space *space);
5573         __isl_give isl_space *
5574         isl_space_domain_wrapped_range(
5575                 __isl_take isl_space *space);
5576         __isl_give isl_space *
5577         isl_space_range_wrapped_domain(
5578                 __isl_take isl_space *space);
5579         __isl_give isl_space *
5580         isl_space_range_wrapped_range(
5581                 __isl_take isl_space *space);
5583         #include <isl/local_space.h>
5584         __isl_give isl_local_space *isl_local_space_domain(
5585                 __isl_take isl_local_space *ls);
5586         __isl_give isl_local_space *isl_local_space_range(
5587                 __isl_take isl_local_space *ls);
5589         #include <isl/set.h>
5590         __isl_give isl_basic_set *isl_basic_set_project_out(
5591                 __isl_take isl_basic_set *bset,
5592                 enum isl_dim_type type, unsigned first, unsigned n);
5593         __isl_give isl_set *isl_set_project_out_param_id(
5594                 __isl_take isl_set *set,
5595                 __isl_take isl_id *id);
5596         __isl_give isl_set *
5597         isl_set_project_out_param_id_list(
5598                 __isl_take isl_set *set,
5599                 __isl_take isl_id_list *list);
5600         __isl_give isl_set *isl_set_project_out(__isl_take isl_set *set,
5601                 enum isl_dim_type type, unsigned first, unsigned n);
5602         __isl_give isl_set *isl_set_project_out_all_params(
5603                 __isl_take isl_set *set);
5604         __isl_give isl_map *isl_set_project_onto_map(
5605                 __isl_take isl_set *set,
5606                 enum isl_dim_type type, unsigned first,
5607                 unsigned n);
5608         __isl_give isl_basic_set *isl_basic_set_params(
5609                 __isl_take isl_basic_set *bset);
5610         __isl_give isl_set *isl_set_params(__isl_take isl_set *set);
5612 The function C<isl_space_domain_wrapped_domain> returns the domain
5613 of the binary relation wrapped inside the domain of the input.
5614 The function C<isl_set_project_onto_map> returns a relation
5615 that projects the input set onto the given set dimensions.
5617         #include <isl/map.h>
5618         __isl_give isl_basic_map *isl_basic_map_project_out(
5619                 __isl_take isl_basic_map *bmap,
5620                 enum isl_dim_type type, unsigned first, unsigned n);
5621         __isl_give isl_map *isl_map_project_out_param_id(
5622                 __isl_take isl_map *map,
5623                 __isl_take isl_id *id);
5624         __isl_give isl_map *isl_map_project_out_param_id_list(
5625                 __isl_take isl_map *map,
5626                 __isl_take isl_id_list *list);
5627         __isl_give isl_map *isl_map_project_out(__isl_take isl_map *map,
5628                 enum isl_dim_type type, unsigned first, unsigned n);
5629         __isl_give isl_map *isl_map_project_out_all_params(
5630                 __isl_take isl_map *map);
5631         __isl_give isl_basic_set *isl_basic_map_domain(
5632                 __isl_take isl_basic_map *bmap);
5633         __isl_give isl_basic_set *isl_basic_map_range(
5634                 __isl_take isl_basic_map *bmap);
5635         __isl_give isl_set *isl_map_params(__isl_take isl_map *map);
5636         __isl_give isl_set *isl_map_domain(
5637                 __isl_take isl_map *bmap);
5638         __isl_give isl_set *isl_map_range(
5639                 __isl_take isl_map *map);
5641         #include <isl/union_set.h>
5642         __isl_give isl_union_set *isl_union_set_project_out(
5643                 __isl_take isl_union_set *uset,
5644                 enum isl_dim_type type,
5645                 unsigned first, unsigned n);
5646         __isl_give isl_union_set *
5647         isl_union_set_project_out_all_params(
5648                 __isl_take isl_union_set *uset);
5649         __isl_give isl_set *isl_union_set_params(
5650                 __isl_take isl_union_set *uset);
5652 The function C<isl_union_set_project_out> can only project out
5653 parameters.
5655         #include <isl/union_map.h>
5656         __isl_give isl_union_map *
5657         isl_union_map_project_out_param_id(
5658                 __isl_take isl_union_map *umap,
5659                 __isl_take isl_id *id);
5660         __isl_give isl_union_map *
5661         isl_union_map_project_out_param_id_list(
5662                 __isl_take isl_union_map *umap,
5663                 __isl_take isl_id_list *list);
5664         __isl_give isl_union_map *isl_union_map_project_out(
5665                 __isl_take isl_union_map *umap,
5666                 enum isl_dim_type type, unsigned first, unsigned n);
5667         __isl_give isl_union_map *
5668         isl_union_map_project_out_all_params(
5669                 __isl_take isl_union_map *umap);
5670         __isl_give isl_set *isl_union_map_params(
5671                 __isl_take isl_union_map *umap);
5672         __isl_give isl_union_set *isl_union_map_domain(
5673                 __isl_take isl_union_map *umap);
5674         __isl_give isl_union_set *isl_union_map_range(
5675                 __isl_take isl_union_map *umap);
5677 The function C<isl_union_map_project_out> can only project out
5678 parameters.
5680         #include <isl/aff.h>
5681         __isl_give isl_aff *isl_aff_project_domain_on_params(
5682                 __isl_take isl_aff *aff);
5683         __isl_give isl_multi_aff *
5684         isl_multi_aff_project_domain_on_params(
5685                 __isl_take isl_multi_aff *ma);
5686         __isl_give isl_pw_aff *
5687         isl_pw_aff_project_domain_on_params(
5688                 __isl_take isl_pw_aff *pa);
5689         __isl_give isl_multi_pw_aff *
5690         isl_multi_pw_aff_project_domain_on_params(
5691                 __isl_take isl_multi_pw_aff *mpa);
5692         __isl_give isl_pw_multi_aff *
5693         isl_pw_multi_aff_project_domain_on_params(
5694                 __isl_take isl_pw_multi_aff *pma);
5695         __isl_give isl_set *isl_pw_aff_domain(
5696                 __isl_take isl_pw_aff *pwaff);
5697         __isl_give isl_set *isl_pw_multi_aff_domain(
5698                 __isl_take isl_pw_multi_aff *pma);
5699         __isl_give isl_set *isl_multi_pw_aff_domain(
5700                 __isl_take isl_multi_pw_aff *mpa);
5701         __isl_give isl_union_set *isl_union_pw_aff_domain(
5702                 __isl_take isl_union_pw_aff *upa);
5703         __isl_give isl_union_set *isl_union_pw_multi_aff_domain(
5704                 __isl_take isl_union_pw_multi_aff *upma);
5705         __isl_give isl_union_set *
5706         isl_multi_union_pw_aff_domain(
5707                 __isl_take isl_multi_union_pw_aff *mupa);
5708         __isl_give isl_set *isl_pw_aff_params(
5709                 __isl_take isl_pw_aff *pwa);
5711 If no explicit domain was set on a zero-dimensional input to
5712 C<isl_multi_union_pw_aff_domain>, then this function will
5713 return a parameter set.
5715         #include <isl/polynomial.h>
5716         __isl_give isl_qpolynomial *
5717         isl_qpolynomial_project_domain_on_params(
5718                 __isl_take isl_qpolynomial *qp);
5719         __isl_give isl_pw_qpolynomial *
5720         isl_pw_qpolynomial_project_domain_on_params(
5721                 __isl_take isl_pw_qpolynomial *pwqp);
5722         __isl_give isl_pw_qpolynomial_fold *
5723         isl_pw_qpolynomial_fold_project_domain_on_params(
5724                 __isl_take isl_pw_qpolynomial_fold *pwf);
5725         __isl_give isl_set *isl_pw_qpolynomial_domain(
5726                 __isl_take isl_pw_qpolynomial *pwqp);
5727         __isl_give isl_union_set *isl_union_pw_qpolynomial_fold_domain(
5728                 __isl_take isl_union_pw_qpolynomial_fold *upwf);
5729         __isl_give isl_union_set *isl_union_pw_qpolynomial_domain(
5730                 __isl_take isl_union_pw_qpolynomial *upwqp);
5732         #include <isl/space.h>
5733         __isl_give isl_space *isl_space_domain_map(
5734                 __isl_take isl_space *space);
5735         __isl_give isl_space *isl_space_range_map(
5736                 __isl_take isl_space *space);
5738         #include <isl/map.h>
5739         __isl_give isl_map *isl_set_wrapped_domain_map(
5740                 __isl_take isl_set *set);
5741         __isl_give isl_basic_map *isl_basic_map_domain_map(
5742                 __isl_take isl_basic_map *bmap);
5743         __isl_give isl_basic_map *isl_basic_map_range_map(
5744                 __isl_take isl_basic_map *bmap);
5745         __isl_give isl_map *isl_map_domain_map(__isl_take isl_map *map);
5746         __isl_give isl_map *isl_map_range_map(__isl_take isl_map *map);
5748         #include <isl/union_map.h>
5749         __isl_give isl_union_map *isl_union_map_domain_map(
5750                 __isl_take isl_union_map *umap);
5751         __isl_give isl_union_pw_multi_aff *
5752         isl_union_map_domain_map_union_pw_multi_aff(
5753                 __isl_take isl_union_map *umap);
5754         __isl_give isl_union_map *isl_union_map_range_map(
5755                 __isl_take isl_union_map *umap);
5756         __isl_give isl_union_map *
5757         isl_union_set_wrapped_domain_map(
5758                 __isl_take isl_union_set *uset);
5760 The functions above construct a (basic, regular or union) relation
5761 that maps (a wrapped version of) the input relation to its domain or range.
5762 C<isl_set_wrapped_domain_map> maps the input set to the domain
5763 of its wrapped relation.
5765 =item * Elimination
5767         __isl_give isl_basic_set *isl_basic_set_eliminate(
5768                 __isl_take isl_basic_set *bset,
5769                 enum isl_dim_type type,
5770                 unsigned first, unsigned n);
5771         __isl_give isl_set *isl_set_eliminate(
5772                 __isl_take isl_set *set, enum isl_dim_type type,
5773                 unsigned first, unsigned n);
5774         __isl_give isl_basic_map *isl_basic_map_eliminate(
5775                 __isl_take isl_basic_map *bmap,
5776                 enum isl_dim_type type,
5777                 unsigned first, unsigned n);
5778         __isl_give isl_map *isl_map_eliminate(
5779                 __isl_take isl_map *map, enum isl_dim_type type,
5780                 unsigned first, unsigned n);
5782 Eliminate the coefficients for the given dimensions from the constraints,
5783 without removing the dimensions.
5785 =item * Constructing a set from a parameter domain
5787 A set space of a given dimension and with an optional name
5788 can be created from a parameter space using the following functions.
5790         #include <isl/space.h>
5791         __isl_give isl_space *isl_space_add_unnamed_tuple_ui(
5792                 __isl_take isl_space *space, unsigned dim);
5793         __isl_give isl_space *
5794         isl_space_add_named_tuple_id_ui(
5795                 __isl_take isl_space *space,
5796                 __isl_take isl_id *tuple_id, unsigned dim);
5798 A set with a given tuple can be created from a parameter domain
5799 using the following function.
5801         #include <isl/set.h>
5802         __isl_give isl_set *isl_set_unbind_params(
5803                 __isl_take isl_set *set,
5804                 __isl_take isl_multi_id *tuple);
5806 Any parameters with identifiers in C<tuple> are reinterpreted
5807 as the corresponding set dimensions.
5809 A zero-dimensional (local) space or (basic) set can be constructed
5810 on a given parameter domain using the following functions.
5812         #include <isl/space.h>
5813         __isl_give isl_space *isl_space_set_from_params(
5814                 __isl_take isl_space *space);
5816         #include <isl/local_space.h>
5817         __isl_give isl_local_space *
5818         isl_local_space_set_from_params(
5819                 __isl_take isl_local_space *ls);
5821         #include <isl/set.h>
5822         __isl_give isl_basic_set *isl_basic_set_from_params(
5823                 __isl_take isl_basic_set *bset);
5824         __isl_give isl_set *isl_set_from_params(
5825                 __isl_take isl_set *set);
5827 =item * Constructing a relation from one or two sets
5829 A map space with a range of a given dimension and with an optional name
5830 can be created from a domain space using the functions
5831 C<isl_space_add_unnamed_tuple_ui> and C<isl_space_add_named_tuple_id_ui>
5832 described above.
5834 A relation with a given domain tuple can be created from a set
5835 that will become the range of the relation
5836 using the following function.
5838         #include <isl/set.h>
5839         __isl_give isl_map *
5840         isl_set_unbind_params_insert_domain(
5841                 __isl_take isl_set *set,
5842                 __isl_take isl_multi_id *domain);
5844 Any parameters with identifiers in C<domain> are reinterpreted
5845 as the corresponding input dimensions.
5847 Similarly, a function defined over a parameter domain can
5848 be converted into one defined over a set domain
5849 using the following functions.
5851         #include <isl/aff.h>
5852         __isl_give isl_aff *
5853         isl_aff_unbind_params_insert_domain(
5854                 __isl_take isl_aff *aff,
5855                 __isl_take isl_multi_id *domain);
5856         __isl_give isl_multi_aff *
5857         isl_multi_aff_unbind_params_insert_domain(
5858                 __isl_take isl_multi_aff *ma,
5859                 __isl_take isl_multi_id *domain);
5860         __isl_give isl_multi_pw_aff *
5861         isl_multi_pw_aff_unbind_params_insert_domain(
5862                 __isl_take isl_multi_pw_aff *mpa,
5863                 __isl_take isl_multi_id *domain);
5865 Again,
5866 any parameters with identifiers in C<domain> are reinterpreted
5867 as the corresponding input dimensions.
5869 Create a relation with the given set(s) as domain and/or range.
5870 If only the domain or the range is specified, then
5871 the range or domain of the created relation is a zero-dimensional
5872 flat anonymous space.
5873 If the case of C<isl_space_map_from_set>, the input space
5874 specifies both the domain and the range of the result.
5876         #include <isl/space.h>
5877         __isl_give isl_space *isl_space_from_domain(
5878                 __isl_take isl_space *space);
5879         __isl_give isl_space *isl_space_from_range(
5880                 __isl_take isl_space *space);
5881         __isl_give isl_space *isl_space_map_from_set(
5882                 __isl_take isl_space *space);
5883         __isl_give isl_space *isl_space_map_from_domain_and_range(
5884                 __isl_take isl_space *domain,
5885                 __isl_take isl_space *range);
5887         #include <isl/local_space.h>
5888         __isl_give isl_local_space *isl_local_space_from_domain(
5889                 __isl_take isl_local_space *ls);
5891         #include <isl/map.h>
5892         __isl_give isl_map *isl_set_insert_domain(
5893                 __isl_take isl_set *set,
5894                 __isl_take isl_space *domain);
5895         __isl_give isl_map *isl_map_from_domain(
5896                 __isl_take isl_set *set);
5897         __isl_give isl_map *isl_map_from_range(
5898                 __isl_take isl_set *set);
5900         #include <isl/union_map.h>
5901         __isl_give isl_union_map *isl_union_map_from_domain(
5902                 __isl_take isl_union_set *uset);
5903         __isl_give isl_union_map *isl_union_map_from_range(
5904                 __isl_take isl_union_set *uset);
5905         __isl_give isl_union_map *
5906         isl_union_map_from_domain_and_range(
5907                 __isl_take isl_union_set *domain,
5908                 __isl_take isl_union_set *range);
5910         #include <isl/id.h>
5911         __isl_give isl_multi_id *isl_multi_id_from_range(
5912                 __isl_take isl_multi_id *mi);
5914         #include <isl/val.h>
5915         __isl_give isl_multi_val *isl_multi_val_from_range(
5916                 __isl_take isl_multi_val *mv);
5918         #include <isl/aff.h>
5919         __isl_give isl_multi_aff *
5920         isl_multi_aff_insert_domain(
5921                 __isl_take isl_multi_aff *ma,
5922                 __isl_take isl_space *domain);
5923         __isl_give isl_pw_aff *isl_pw_aff_insert_domain(
5924                 __isl_take isl_pw_aff *pa,
5925                 __isl_take isl_space *domain);
5926         __isl_give isl_pw_multi_aff *
5927         isl_pw_multi_aff_insert_domain(
5928                 __isl_take isl_pw_multi_aff *pma,
5929                 __isl_take isl_space *domain);
5930         __isl_give isl_multi_pw_aff *
5931         isl_multi_pw_aff_insert_domain(
5932                 __isl_take isl_multi_pw_aff *mpa,
5933                 __isl_take isl_space *domain);
5934         __isl_give isl_aff *isl_aff_from_range(
5935                 __isl_take isl_aff *aff);
5936         __isl_give isl_multi_aff *isl_multi_aff_from_range(
5937                 __isl_take isl_multi_aff *ma);
5938         __isl_give isl_pw_aff *isl_pw_aff_from_range(
5939                 __isl_take isl_pw_aff *pwa);
5940         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_range(
5941                 __isl_take isl_multi_pw_aff *mpa);
5942         __isl_give isl_multi_union_pw_aff *
5943         isl_multi_union_pw_aff_from_range(
5944                 __isl_take isl_multi_union_pw_aff *mupa);
5945         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_domain(
5946                 __isl_take isl_set *set);
5947         __isl_give isl_union_pw_multi_aff *
5948         isl_union_pw_multi_aff_from_domain(
5949                 __isl_take isl_union_set *uset);
5951         #include <isl/polynomial.h>
5952         __isl_give isl_pw_qpolynomial *
5953         isl_pw_qpolynomial_from_range(
5954                 __isl_take isl_pw_qpolynomial *pwqp);
5955         __isl_give isl_pw_qpolynomial_fold *
5956         isl_pw_qpolynomial_fold_from_range(
5957                 __isl_take isl_pw_qpolynomial_fold *pwf);
5959 =item * Slicing
5961         #include <isl/set.h>
5962         __isl_give isl_basic_set *isl_basic_set_fix_si(
5963                 __isl_take isl_basic_set *bset,
5964                 enum isl_dim_type type, unsigned pos, int value);
5965         __isl_give isl_basic_set *isl_basic_set_fix_val(
5966                 __isl_take isl_basic_set *bset,
5967                 enum isl_dim_type type, unsigned pos,
5968                 __isl_take isl_val *v);
5969         __isl_give isl_set *isl_set_fix_si(__isl_take isl_set *set,
5970                 enum isl_dim_type type, unsigned pos, int value);
5971         __isl_give isl_set *isl_set_fix_val(
5972                 __isl_take isl_set *set,
5973                 enum isl_dim_type type, unsigned pos,
5974                 __isl_take isl_val *v);
5976         #include <isl/map.h>
5977         __isl_give isl_basic_map *isl_basic_map_fix_si(
5978                 __isl_take isl_basic_map *bmap,
5979                 enum isl_dim_type type, unsigned pos, int value);
5980         __isl_give isl_basic_map *isl_basic_map_fix_val(
5981                 __isl_take isl_basic_map *bmap,
5982                 enum isl_dim_type type, unsigned pos,
5983                 __isl_take isl_val *v);
5984         __isl_give isl_map *isl_map_fix_si(__isl_take isl_map *map,
5985                 enum isl_dim_type type, unsigned pos, int value);
5986         __isl_give isl_map *isl_map_fix_val(
5987                 __isl_take isl_map *map,
5988                 enum isl_dim_type type, unsigned pos,
5989                 __isl_take isl_val *v);
5991         #include <isl/aff.h>
5992         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_fix_si(
5993                 __isl_take isl_pw_multi_aff *pma,
5994                 enum isl_dim_type type, unsigned pos, int value);
5996         #include <isl/polynomial.h>
5997         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_fix_val(
5998                 __isl_take isl_pw_qpolynomial *pwqp,
5999                 enum isl_dim_type type, unsigned n,
6000                 __isl_take isl_val *v);
6001         __isl_give isl_pw_qpolynomial_fold *
6002         isl_pw_qpolynomial_fold_fix_val(
6003                 __isl_take isl_pw_qpolynomial_fold *pwf,
6004                 enum isl_dim_type type, unsigned n,
6005                 __isl_take isl_val *v);
6007 Intersect the set, relation or function domain
6008 with the hyperplane where the given
6009 dimension has the fixed given value.
6011         #include <isl/set.h>
6012         __isl_give isl_basic_set *
6013         isl_basic_set_lower_bound_val(
6014                 __isl_take isl_basic_set *bset,
6015                 enum isl_dim_type type, unsigned pos,
6016                 __isl_take isl_val *value);
6017         __isl_give isl_basic_set *
6018         isl_basic_set_upper_bound_val(
6019                 __isl_take isl_basic_set *bset,
6020                 enum isl_dim_type type, unsigned pos,
6021                 __isl_take isl_val *value);
6022         __isl_give isl_set *isl_set_lower_bound_si(
6023                 __isl_take isl_set *set,
6024                 enum isl_dim_type type, unsigned pos, int value);
6025         __isl_give isl_set *isl_set_lower_bound_val(
6026                 __isl_take isl_set *set,
6027                 enum isl_dim_type type, unsigned pos,
6028                 __isl_take isl_val *value);
6029         __isl_give isl_set *isl_set_upper_bound_si(
6030                 __isl_take isl_set *set,
6031                 enum isl_dim_type type, unsigned pos, int value);
6032         __isl_give isl_set *isl_set_upper_bound_val(
6033                 __isl_take isl_set *set,
6034                 enum isl_dim_type type, unsigned pos,
6035                 __isl_take isl_val *value);
6036         __isl_give isl_set *isl_set_lower_bound_multi_val(
6037                 __isl_take isl_set *set,
6038                 __isl_take isl_multi_val *lower);
6039         __isl_give isl_set *isl_set_upper_bound_multi_val(
6040                 __isl_take isl_set *set,
6041                 __isl_take isl_multi_val *upper);
6042         __isl_give isl_set *isl_set_lower_bound_multi_pw_aff(
6043                 __isl_take isl_set *set,
6044                 __isl_take isl_multi_pw_aff *lower);
6045         __isl_give isl_set *isl_set_upper_bound_multi_pw_aff(
6046                 __isl_take isl_set *set,
6047                 __isl_take isl_multi_pw_aff *upper);
6049         #include <isl/map.h>
6050         __isl_give isl_basic_map *isl_basic_map_lower_bound_si(
6051                 __isl_take isl_basic_map *bmap,
6052                 enum isl_dim_type type, unsigned pos, int value);
6053         __isl_give isl_basic_map *isl_basic_map_upper_bound_si(
6054                 __isl_take isl_basic_map *bmap,
6055                 enum isl_dim_type type, unsigned pos, int value);
6056         __isl_give isl_map *isl_map_lower_bound_si(
6057                 __isl_take isl_map *map,
6058                 enum isl_dim_type type, unsigned pos, int value);
6059         __isl_give isl_map *isl_map_upper_bound_si(
6060                 __isl_take isl_map *map,
6061                 enum isl_dim_type type, unsigned pos, int value);
6062         __isl_give isl_map *isl_map_lower_bound_val(
6063                 __isl_take isl_map *map,
6064                 enum isl_dim_type type, unsigned pos,
6065                 __isl_take isl_val *value);
6066         __isl_give isl_map *isl_map_upper_bound_val(
6067                 __isl_take isl_map *map,
6068                 enum isl_dim_type type, unsigned pos,
6069                 __isl_take isl_val *value);
6070         __isl_give isl_map *isl_map_lower_bound_multi_pw_aff(
6071                 __isl_take isl_map *map,
6072                 __isl_take isl_multi_pw_aff *lower);
6073         __isl_give isl_map *isl_map_upper_bound_multi_pw_aff(
6074                 __isl_take isl_map *map,
6075                 __isl_take isl_multi_pw_aff *upper);
6077 Intersect the set or relation with the half-space where the given
6078 dimension has a value bounded by the given fixed integer value or
6079 symbolic constant expression.
6080 For functions taking a multi expression,
6081 this applies to all set dimensions.
6082 Those that bound a map, bound the range of that map.
6083 If the multi expression is zero-dimensional but has an explicit domain,
6084 then the (parameter) domain of the set or map is intersected
6085 with this explicit domain.
6087         __isl_give isl_set *isl_set_equate(__isl_take isl_set *set,
6088                 enum isl_dim_type type1, int pos1,
6089                 enum isl_dim_type type2, int pos2);
6090         __isl_give isl_basic_map *isl_basic_map_equate(
6091                 __isl_take isl_basic_map *bmap,
6092                 enum isl_dim_type type1, int pos1,
6093                 enum isl_dim_type type2, int pos2);
6094         __isl_give isl_map *isl_map_equate(__isl_take isl_map *map,
6095                 enum isl_dim_type type1, int pos1,
6096                 enum isl_dim_type type2, int pos2);
6098 Intersect the set or relation with the hyperplane where the given
6099 dimensions are equal to each other.
6101         __isl_give isl_map *isl_map_oppose(__isl_take isl_map *map,
6102                 enum isl_dim_type type1, int pos1,
6103                 enum isl_dim_type type2, int pos2);
6105 Intersect the relation with the hyperplane where the given
6106 dimensions have opposite values.
6108         __isl_give isl_map *isl_map_order_le(
6109                 __isl_take isl_map *map,
6110                 enum isl_dim_type type1, int pos1,
6111                 enum isl_dim_type type2, int pos2);
6112         __isl_give isl_basic_map *isl_basic_map_order_ge(
6113                 __isl_take isl_basic_map *bmap,
6114                 enum isl_dim_type type1, int pos1,
6115                 enum isl_dim_type type2, int pos2);
6116         __isl_give isl_map *isl_map_order_ge(
6117                 __isl_take isl_map *map,
6118                 enum isl_dim_type type1, int pos1,
6119                 enum isl_dim_type type2, int pos2);
6120         __isl_give isl_map *isl_map_order_lt(__isl_take isl_map *map,
6121                 enum isl_dim_type type1, int pos1,
6122                 enum isl_dim_type type2, int pos2);
6123         __isl_give isl_basic_map *isl_basic_map_order_gt(
6124                 __isl_take isl_basic_map *bmap,
6125                 enum isl_dim_type type1, int pos1,
6126                 enum isl_dim_type type2, int pos2);
6127         __isl_give isl_map *isl_map_order_gt(__isl_take isl_map *map,
6128                 enum isl_dim_type type1, int pos1,
6129                 enum isl_dim_type type2, int pos2);
6131 Intersect the relation with the half-space where the given
6132 dimensions satisfy the given ordering.
6134         #include <isl/union_set.h>
6135         __isl_give isl_union_map *isl_union_map_remove_map_if(
6136                 __isl_take isl_union_map *umap,
6137                 isl_bool (*fn)(__isl_keep isl_map *map,
6138                         void *user), void *user);
6140 This function calls the callback function once for each
6141 pair of spaces for which there are elements in the input.
6142 If the callback returns C<isl_bool_true>, then all those elements
6143 are removed from the result.  The only remaining elements in the output
6144 are then those for which the callback returns C<isl_bool_false>.
6146 =item * Locus
6148         #include <isl/aff.h>
6149         __isl_give isl_basic_set *isl_aff_zero_basic_set(
6150                 __isl_take isl_aff *aff);
6151         __isl_give isl_basic_set *isl_aff_neg_basic_set(
6152                 __isl_take isl_aff *aff);
6153         __isl_give isl_set *isl_pw_aff_pos_set(
6154                 __isl_take isl_pw_aff *pa);
6155         __isl_give isl_set *isl_pw_aff_nonneg_set(
6156                 __isl_take isl_pw_aff *pwaff);
6157         __isl_give isl_set *isl_pw_aff_zero_set(
6158                 __isl_take isl_pw_aff *pwaff);
6159         __isl_give isl_set *isl_pw_aff_non_zero_set(
6160                 __isl_take isl_pw_aff *pwaff);
6161         __isl_give isl_union_set *
6162         isl_union_pw_aff_zero_union_set(
6163                 __isl_take isl_union_pw_aff *upa);
6164         __isl_give isl_union_set *
6165         isl_multi_union_pw_aff_zero_union_set(
6166                 __isl_take isl_multi_union_pw_aff *mupa);
6168 The function C<isl_aff_neg_basic_set> returns a basic set
6169 containing those elements in the domain space
6170 of C<aff> where C<aff> is negative.
6171 The function C<isl_pw_aff_nonneg_set> returns a set
6172 containing those elements in the domain
6173 of C<pwaff> where C<pwaff> is non-negative.
6174 The function C<isl_multi_union_pw_aff_zero_union_set>
6175 returns a union set containing those elements
6176 in the domains of its elements where they are all zero.
6178 =item * Identity
6180         __isl_give isl_map *isl_set_identity(
6181                 __isl_take isl_set *set);
6182         __isl_give isl_union_map *isl_union_set_identity(
6183                 __isl_take isl_union_set *uset);
6184         __isl_give isl_union_pw_multi_aff *
6185         isl_union_set_identity_union_pw_multi_aff(
6186                 __isl_take isl_union_set *uset);
6188 Construct an identity relation on the given (union) set.
6190 =item * Function Extraction
6192 A piecewise quasi affine expression that is equal to 1 on a set
6193 and 0 outside the set can be created using the following function.
6195         #include <isl/aff.h>
6196         __isl_give isl_pw_aff *isl_set_indicator_function(
6197                 __isl_take isl_set *set);
6199 A piecewise multiple quasi affine expression can be extracted
6200 from an C<isl_set> or C<isl_map>, provided the C<isl_set> is a singleton
6201 and the C<isl_map> is single-valued.
6202 In case of a conversion from an C<isl_union_map>
6203 to an C<isl_union_pw_multi_aff>, these properties need to hold
6204 in each domain space.
6205 A conversion to a C<isl_multi_union_pw_aff> additionally
6206 requires that the input is non-empty and involves only a single
6207 range space.
6209         #include <isl/aff.h>
6210         __isl_give isl_pw_multi_aff *isl_set_as_pw_multi_aff(
6211                 __isl_take isl_set *set);
6212         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_set(
6213                 __isl_take isl_set *set);
6214         __isl_give isl_pw_multi_aff *isl_map_as_pw_multi_aff(
6215                 __isl_take isl_map *map);
6216         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_map(
6217                 __isl_take isl_map *map);
6219         __isl_give isl_union_pw_multi_aff *
6220         isl_union_pw_multi_aff_from_union_set(
6221                 __isl_take isl_union_set *uset);
6222         __isl_give isl_union_pw_multi_aff *
6223         isl_union_map_as_union_pw_multi_aff(
6224                 __isl_take isl_union_map *umap);
6225         __isl_give isl_union_pw_multi_aff *
6226         isl_union_pw_multi_aff_from_union_map(
6227                 __isl_take isl_union_map *umap);
6229         __isl_give isl_multi_union_pw_aff *
6230         isl_union_map_as_multi_union_pw_aff(
6231                 __isl_take isl_union_map *umap);
6232         __isl_give isl_multi_union_pw_aff *
6233         isl_multi_union_pw_aff_from_union_map(
6234                 __isl_take isl_union_map *umap);
6236 C<isl_map_as_pw_multi_aff> and C<isl_pw_multi_aff_from_map> perform
6237 the same operation.
6238 Similarly for C<isl_set_as_pw_multi_aff> and
6239 C<isl_pw_multi_aff_from_set>,
6240 for C<isl_union_map_as_union_pw_multi_aff> and
6241 C<isl_union_pw_multi_aff_from_union_map> and
6242 for C<isl_union_map_as_multi_union_pw_aff> and
6243 C<isl_multi_union_pw_aff_from_union_map>.
6245 =item * Deltas
6247         __isl_give isl_basic_set *isl_basic_map_deltas(
6248                 __isl_take isl_basic_map *bmap);
6249         __isl_give isl_set *isl_map_deltas(__isl_take isl_map *map);
6250         __isl_give isl_union_set *isl_union_map_deltas(
6251                 __isl_take isl_union_map *umap);
6253 These functions return a (basic) set containing the differences
6254 between image elements and corresponding domain elements in the input.
6256         __isl_give isl_basic_map *isl_basic_map_deltas_map(
6257                 __isl_take isl_basic_map *bmap);
6258         __isl_give isl_map *isl_map_deltas_map(
6259                 __isl_take isl_map *map);
6260         __isl_give isl_union_map *isl_union_map_deltas_map(
6261                 __isl_take isl_union_map *umap);
6263 The functions above construct a (basic, regular or union) relation
6264 that maps (a wrapped version of) the input relation to its delta set.
6266 =item * Translation
6268         #include <isl/map.h>
6269         __isl_give isl_map *isl_set_translation(
6270                 __isl_take isl_set *deltas);
6272 This function performs essentially the opposite operation
6273 of C<isl_map_deltas>.  In particular, it returns pairs
6274 of elements in the same space that have a difference in C<deltas>.
6276 =item * Coalescing
6278 Simplify the representation of a set, relation or functions by trying
6279 to combine pairs of basic sets or relations into a single
6280 basic set or relation.
6282         #include <isl/set.h>
6283         __isl_give isl_set *isl_set_coalesce(__isl_take isl_set *set);
6285         #include <isl/map.h>
6286         __isl_give isl_map *isl_map_coalesce(__isl_take isl_map *map);
6288         #include <isl/union_set.h>
6289         __isl_give isl_union_set *isl_union_set_coalesce(
6290                 __isl_take isl_union_set *uset);
6292         #include <isl/union_map.h>
6293         __isl_give isl_union_map *isl_union_map_coalesce(
6294                 __isl_take isl_union_map *umap);
6296         #include <isl/aff.h>
6297         __isl_give isl_pw_aff *isl_pw_aff_coalesce(
6298                 __isl_take isl_pw_aff *pa);
6299         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_coalesce(
6300                 __isl_take isl_pw_multi_aff *pma);
6301         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_coalesce(
6302                 __isl_take isl_multi_pw_aff *mpa);
6303         __isl_give isl_union_pw_aff *isl_union_pw_aff_coalesce(
6304                 __isl_take isl_union_pw_aff *upa);
6305         __isl_give isl_union_pw_multi_aff *
6306         isl_union_pw_multi_aff_coalesce(
6307                 __isl_take isl_union_pw_multi_aff *upma);
6308         __isl_give isl_multi_union_pw_aff *
6309         isl_multi_union_pw_aff_coalesce(
6310                 __isl_take isl_multi_union_pw_aff *mupa);
6312         #include <isl/polynomial.h>
6313         __isl_give isl_pw_qpolynomial_fold *
6314         isl_pw_qpolynomial_fold_coalesce(
6315                 __isl_take isl_pw_qpolynomial_fold *pwf);
6316         __isl_give isl_union_pw_qpolynomial *
6317         isl_union_pw_qpolynomial_coalesce(
6318                 __isl_take isl_union_pw_qpolynomial *upwqp);
6319         __isl_give isl_union_pw_qpolynomial_fold *
6320         isl_union_pw_qpolynomial_fold_coalesce(
6321                 __isl_take isl_union_pw_qpolynomial_fold *upwf);
6323 One of the methods for combining pairs of basic sets or relations
6324 can result in coefficients that are much larger than those that appear
6325 in the constraints of the input.  By default, the coefficients are
6326 not allowed to grow larger, but this can be changed by unsetting
6327 the following option.
6329         isl_stat isl_options_set_coalesce_bounded_wrapping(
6330                 isl_ctx *ctx, int val);
6331         int isl_options_get_coalesce_bounded_wrapping(
6332                 isl_ctx *ctx);
6334 One of the other methods tries to combine pairs of basic sets
6335 with different local variables, treating them as existentially
6336 quantified variables even if they have known (but different)
6337 integer division expressions.  The result may then also have
6338 existentially quantified variables.  Turning on the following
6339 option prevents this from happening.
6341         isl_stat isl_options_set_coalesce_preserve_locals(
6342                 isl_ctx *ctx, int val);
6343         int isl_options_get_coalesce_preserve_locals(isl_ctx *ctx);
6345 =item * Detecting equalities
6347         __isl_give isl_basic_set *isl_basic_set_detect_equalities(
6348                 __isl_take isl_basic_set *bset);
6349         __isl_give isl_basic_map *isl_basic_map_detect_equalities(
6350                 __isl_take isl_basic_map *bmap);
6351         __isl_give isl_set *isl_set_detect_equalities(
6352                 __isl_take isl_set *set);
6353         __isl_give isl_map *isl_map_detect_equalities(
6354                 __isl_take isl_map *map);
6355         __isl_give isl_union_set *isl_union_set_detect_equalities(
6356                 __isl_take isl_union_set *uset);
6357         __isl_give isl_union_map *isl_union_map_detect_equalities(
6358                 __isl_take isl_union_map *umap);
6360 Simplify the representation of a set or relation by detecting implicit
6361 equalities.
6363 =item * Removing redundant constraints
6365         #include <isl/set.h>
6366         __isl_give isl_basic_set *isl_basic_set_remove_redundancies(
6367                 __isl_take isl_basic_set *bset);
6368         __isl_give isl_set *isl_set_remove_redundancies(
6369                 __isl_take isl_set *set);
6371         #include <isl/union_set.h>
6372         __isl_give isl_union_set *
6373         isl_union_set_remove_redundancies(
6374                 __isl_take isl_union_set *uset);
6376         #include <isl/map.h>
6377         __isl_give isl_basic_map *isl_basic_map_remove_redundancies(
6378                 __isl_take isl_basic_map *bmap);
6379         __isl_give isl_map *isl_map_remove_redundancies(
6380                 __isl_take isl_map *map);
6382         #include <isl/union_map.h>
6383         __isl_give isl_union_map *
6384         isl_union_map_remove_redundancies(
6385                 __isl_take isl_union_map *umap);
6387 =item * Convex hull
6389         __isl_give isl_basic_set *isl_set_convex_hull(
6390                 __isl_take isl_set *set);
6391         __isl_give isl_basic_map *isl_map_convex_hull(
6392                 __isl_take isl_map *map);
6394 If the input set or relation has any existentially quantified
6395 variables, then the result of these operations is currently undefined.
6397 =item * Simple hull
6399         #include <isl/set.h>
6400         __isl_give isl_basic_set *
6401         isl_set_unshifted_simple_hull(
6402                 __isl_take isl_set *set);
6403         __isl_give isl_basic_set *isl_set_simple_hull(
6404                 __isl_take isl_set *set);
6405         __isl_give isl_basic_set *
6406         isl_set_plain_unshifted_simple_hull(
6407                 __isl_take isl_set *set);
6408         __isl_give isl_basic_set *
6409         isl_set_unshifted_simple_hull_from_set_list(
6410                 __isl_take isl_set *set,
6411                 __isl_take isl_set_list *list);
6413         #include <isl/map.h>
6414         __isl_give isl_basic_map *
6415         isl_map_unshifted_simple_hull(
6416                 __isl_take isl_map *map);
6417         __isl_give isl_basic_map *isl_map_simple_hull(
6418                 __isl_take isl_map *map);
6419         __isl_give isl_basic_map *
6420         isl_map_plain_unshifted_simple_hull(
6421                 __isl_take isl_map *map);
6422                 __isl_give isl_basic_map *
6423         isl_map_unshifted_simple_hull_from_map_list(
6424                 __isl_take isl_map *map,
6425                 __isl_take isl_map_list *list);
6427         #include <isl/union_map.h>
6428         __isl_give isl_union_map *isl_union_map_simple_hull(
6429                 __isl_take isl_union_map *umap);
6431 These functions compute a single basic set or relation
6432 that contains the whole input set or relation.
6433 In particular, the output is described by translates
6434 of the constraints describing the basic sets or relations in the input.
6435 In case of C<isl_set_unshifted_simple_hull>, only the original
6436 constraints are used, without any translation.
6437 In case of C<isl_set_plain_unshifted_simple_hull> and
6438 C<isl_map_plain_unshifted_simple_hull>, the result is described
6439 by original constraints that are obviously satisfied
6440 by the entire input set or relation.
6441 In case of C<isl_set_unshifted_simple_hull_from_set_list> and
6442 C<isl_map_unshifted_simple_hull_from_map_list>, the
6443 constraints are taken from the elements of the second argument.
6445 =begin latex
6447 (See \autoref{s:simple hull}.)
6449 =end latex
6451 =item * Affine hull
6453         __isl_give isl_basic_set *isl_basic_set_affine_hull(
6454                 __isl_take isl_basic_set *bset);
6455         __isl_give isl_basic_set *isl_set_affine_hull(
6456                 __isl_take isl_set *set);
6457         __isl_give isl_union_set *isl_union_set_affine_hull(
6458                 __isl_take isl_union_set *uset);
6459         __isl_give isl_basic_map *isl_basic_map_affine_hull(
6460                 __isl_take isl_basic_map *bmap);
6461         __isl_give isl_basic_map *isl_map_affine_hull(
6462                 __isl_take isl_map *map);
6463         __isl_give isl_union_map *isl_union_map_affine_hull(
6464                 __isl_take isl_union_map *umap);
6466 In case of union sets and relations, the affine hull is computed
6467 per space.
6469 =item * Polyhedral hull
6471         __isl_give isl_basic_set *isl_set_polyhedral_hull(
6472                 __isl_take isl_set *set);
6473         __isl_give isl_basic_map *isl_map_polyhedral_hull(
6474                 __isl_take isl_map *map);
6475         __isl_give isl_union_set *isl_union_set_polyhedral_hull(
6476                 __isl_take isl_union_set *uset);
6477         __isl_give isl_union_map *isl_union_map_polyhedral_hull(
6478                 __isl_take isl_union_map *umap);
6480 These functions compute a single basic set or relation
6481 not involving any existentially quantified variables
6482 that contains the whole input set or relation.
6483 In case of union sets and relations, the polyhedral hull is computed
6484 per space.
6486 =item * Box hull
6488         #include <isl/set.h>
6489         __isl_give isl_fixed_box *
6490         isl_set_get_simple_fixed_box_hull(
6491                 __isl_keep isl_set *set)
6493         #include <isl/map.h>
6494         __isl_give isl_fixed_box *
6495         isl_map_get_range_simple_fixed_box_hull(
6496                 __isl_keep isl_map *map);
6498 These functions try to approximate the set or
6499 the range of the map by a box of fixed size.
6500 The box is described in terms of an offset living in the same space as
6501 the input and a size living in the set or range space.  For any element
6502 in the input map, the range value is greater than or equal to
6503 the offset applied to the domain value and the difference with
6504 this offset is strictly smaller than the size.
6505 The same holds for the elements of the input set, where
6506 the offset is a parametric constant value.
6507 If no fixed-size approximation can be found,
6508 an I<invalid> box is returned, i.e., one for which
6509 C<isl_fixed_box_is_valid> below returns false.
6511 The validity, the offset and the size of the box can be obtained using
6512 the following functions.
6514         #include <isl/fixed_box.h>
6515         isl_bool isl_fixed_box_is_valid(
6516                 __isl_keep isl_fixed_box *box);
6517         __isl_give isl_multi_aff *isl_fixed_box_get_offset(
6518                 __isl_keep isl_fixed_box *box);
6519         __isl_give isl_multi_val *isl_fixed_box_get_size(
6520                 __isl_keep isl_fixed_box *box);
6522 The box can be copied and freed using the following functions.
6524         #include <isl/fixed_box.h>
6525         __isl_give isl_fixed_box *isl_fixed_box_copy(
6526                 __isl_keep isl_fixed_box *box);
6527         __isl_null isl_fixed_box *isl_fixed_box_free(
6528                 __isl_take isl_fixed_box *box);
6530 An object of type C<isl_fixed_box> can be read from input
6531 using the following function.
6533         #include <isl/fixed_box.h>
6534         __isl_give isl_fixed_box *
6535         isl_fixed_box_read_from_str(isl_ctx *ctx,
6536                 const char *str);
6538 A representation of the information contained in an object
6539 of type C<isl_fixed_box> can be obtained using
6541         #include <isl/fixed_box.h>
6542         __isl_give isl_printer *isl_printer_print_fixed_box(
6543                 __isl_take isl_printer *p,
6544                 __isl_keep isl_fixed_box *box);
6545         __isl_give char *isl_fixed_box_to_str(
6546                 __isl_keep isl_fixed_box *box);
6548 C<isl_fixed_box_to_str> prints the information in flow format.
6550 =item * Other approximations
6552         #include <isl/set.h>
6553         __isl_give isl_basic_set *
6554         isl_basic_set_drop_constraints_involving_dims(
6555                 __isl_take isl_basic_set *bset,
6556                 enum isl_dim_type type,
6557                 unsigned first, unsigned n);
6558         __isl_give isl_basic_set *
6559         isl_basic_set_drop_constraints_not_involving_dims(
6560                 __isl_take isl_basic_set *bset,
6561                 enum isl_dim_type type,
6562                 unsigned first, unsigned n);
6563         __isl_give isl_set *
6564         isl_set_drop_constraints_involving_dims(
6565                 __isl_take isl_set *set,
6566                 enum isl_dim_type type,
6567                 unsigned first, unsigned n);
6568         __isl_give isl_set *
6569         isl_set_drop_constraints_not_involving_dims(
6570                 __isl_take isl_set *set,
6571                 enum isl_dim_type type,
6572                 unsigned first, unsigned n);
6574         #include <isl/map.h>
6575         __isl_give isl_basic_map *
6576         isl_basic_map_drop_constraints_involving_dims(
6577                 __isl_take isl_basic_map *bmap,
6578                 enum isl_dim_type type,
6579                 unsigned first, unsigned n);
6580         __isl_give isl_basic_map *
6581         isl_basic_map_drop_constraints_not_involving_dims(
6582                 __isl_take isl_basic_map *bmap,
6583                 enum isl_dim_type type,
6584                 unsigned first, unsigned n);
6585         __isl_give isl_map *
6586         isl_map_drop_constraints_involving_dims(
6587                 __isl_take isl_map *map,
6588                 enum isl_dim_type type,
6589                 unsigned first, unsigned n);
6590         __isl_give isl_map *
6591         isl_map_drop_constraints_not_involving_dims(
6592                 __isl_take isl_map *map,
6593                 enum isl_dim_type type,
6594                 unsigned first, unsigned n);
6596 These functions drop any constraints (not) involving the specified dimensions.
6597 Note that the result depends on the representation of the input.
6599         #include <isl/polynomial.h>
6600         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_to_polynomial(
6601                 __isl_take isl_pw_qpolynomial *pwqp, int sign);
6602         __isl_give isl_union_pw_qpolynomial *
6603         isl_union_pw_qpolynomial_to_polynomial(
6604                 __isl_take isl_union_pw_qpolynomial *upwqp, int sign);
6606 Approximate each quasipolynomial by a polynomial.  If C<sign> is positive,
6607 the polynomial will be an overapproximation.  If C<sign> is negative,
6608 it will be an underapproximation.  If C<sign> is zero, the approximation
6609 will lie somewhere in between.
6611 =item * Feasibility
6613         __isl_give isl_basic_set *isl_basic_set_sample(
6614                 __isl_take isl_basic_set *bset);
6615         __isl_give isl_basic_set *isl_set_sample(
6616                 __isl_take isl_set *set);
6617         __isl_give isl_basic_map *isl_basic_map_sample(
6618                 __isl_take isl_basic_map *bmap);
6619         __isl_give isl_basic_map *isl_map_sample(
6620                 __isl_take isl_map *map);
6622 If the input (basic) set or relation is non-empty, then return
6623 a singleton subset of the input.  Otherwise, return an empty set.
6625 =item * Optimization
6627         #include <isl/ilp.h>
6628         __isl_give isl_val *isl_basic_set_max_val(
6629                 __isl_keep isl_basic_set *bset,
6630                 __isl_keep isl_aff *obj);
6631         __isl_give isl_val *isl_set_min_val(
6632                 __isl_keep isl_set *set,
6633                 __isl_keep isl_aff *obj);
6634         __isl_give isl_val *isl_set_max_val(
6635                 __isl_keep isl_set *set,
6636                 __isl_keep isl_aff *obj);
6637         __isl_give isl_multi_val *
6638         isl_union_set_min_multi_union_pw_aff(
6639                 __isl_keep isl_union_set *uset,
6640                 __isl_keep isl_multi_union_pw_aff *obj);
6642 Compute the minimum or maximum of the integer affine expression C<obj>
6643 over the points in C<set>.
6644 The result is C<NULL> in case of an error, the optimal value in case
6645 there is one, negative infinity or infinity if the problem is unbounded and
6646 NaN if the problem is empty.
6648         #include <isl/ilp.h>
6649         __isl_give isl_val *isl_pw_aff_min_val(
6650                 __isl_take isl_pw_aff *pa);
6651         __isl_give isl_val *isl_pw_aff_max_val(
6652                 __isl_take isl_pw_aff *pa);
6653         __isl_give isl_multi_val *
6654         isl_pw_multi_aff_min_multi_val(
6655                 __isl_take isl_pw_multi_aff *pma);
6656         __isl_give isl_multi_val *
6657         isl_pw_multi_aff_max_multi_val(
6658                 __isl_take isl_pw_multi_aff *pma);
6659         __isl_give isl_multi_val *
6660         isl_multi_pw_aff_min_multi_val(
6661                 __isl_take isl_multi_pw_aff *mpa);
6662         __isl_give isl_multi_val *
6663         isl_multi_pw_aff_max_multi_val(
6664                 __isl_take isl_multi_pw_aff *mpa);
6665         __isl_give isl_val *isl_union_pw_aff_min_val(
6666                 __isl_take isl_union_pw_aff *upa);
6667         __isl_give isl_val *isl_union_pw_aff_max_val(
6668                 __isl_take isl_union_pw_aff *upa);
6669         __isl_give isl_multi_val *
6670         isl_multi_union_pw_aff_min_multi_val(
6671                 __isl_take isl_multi_union_pw_aff *mupa);
6672         __isl_give isl_multi_val *
6673         isl_multi_union_pw_aff_max_multi_val(
6674                 __isl_take isl_multi_union_pw_aff *mupa);
6676 Compute the minimum or maximum of the integer affine expression
6677 over its definition domain.
6678 The result is C<NULL> in case of an error, the optimal value in case
6679 there is one, negative infinity or infinity if the problem is unbounded and
6680 NaN if the problem is empty.
6682         #include <isl/ilp.h>
6683         __isl_give isl_val *isl_basic_set_dim_max_val(
6684                 __isl_take isl_basic_set *bset, int pos);
6685         __isl_give isl_val *isl_set_dim_min_val(
6686                 __isl_take isl_set *set, int pos);
6687         __isl_give isl_val *isl_set_dim_max_val(
6688                 __isl_take isl_set *set, int pos);
6690 Return the minimal or maximal value attained by the given set dimension,
6691 independently of the parameter values and of any other dimensions.
6692 The result is C<NULL> in case of an error, the optimal value in case
6693 there is one, (negative) infinity if the problem is unbounded and
6694 NaN if the input is empty.
6696 =item * Parametric optimization
6698         __isl_give isl_pw_aff *isl_set_dim_min(
6699                 __isl_take isl_set *set, int pos);
6700         __isl_give isl_pw_aff *isl_set_dim_max(
6701                 __isl_take isl_set *set, int pos);
6702         __isl_give isl_pw_aff *isl_map_dim_min(
6703                 __isl_take isl_map *map, int pos);
6704         __isl_give isl_pw_aff *isl_map_dim_max(
6705                 __isl_take isl_map *map, int pos);
6706         __isl_give isl_multi_pw_aff *
6707         isl_set_min_multi_pw_aff(
6708                 __isl_take isl_set *set);
6709         __isl_give isl_multi_pw_aff *
6710         isl_set_max_multi_pw_aff(
6711                 __isl_take isl_set *set);
6712         __isl_give isl_multi_pw_aff *
6713         isl_map_min_multi_pw_aff(
6714                 __isl_take isl_map *map);
6715         __isl_give isl_multi_pw_aff *
6716         isl_map_max_multi_pw_aff(
6717                 __isl_take isl_map *map);
6719 Compute the minimum or maximum of the (given) set or output dimension(s)
6720 as a function of the parameters (and input dimensions), but independently
6721 of the other set or output dimensions.
6722 For lexicographic optimization, see L<"Lexicographic Optimization">.
6724 =item * Dual
6726 The following functions compute either the set of (rational) coefficient
6727 values of valid constraints for the given set or the set of (rational)
6728 values satisfying the constraints with coefficients from the given set.
6729 Internally, these two sets of functions perform essentially the
6730 same operations, except that the set of coefficients is assumed to
6731 be a cone, while the set of values may be any polyhedron.
6732 The current implementation is based on the Farkas lemma and
6733 Fourier-Motzkin elimination, but this may change or be made optional
6734 in future.  In particular, future implementations may use different
6735 dualization algorithms or skip the elimination step.
6737         #include <isl/set.h>
6738         __isl_give isl_basic_set *isl_basic_set_coefficients(
6739                 __isl_take isl_basic_set *bset);
6740         __isl_give isl_basic_set_list *
6741         isl_basic_set_list_coefficients(
6742                 __isl_take isl_basic_set_list *list);
6743         __isl_give isl_basic_set *isl_set_coefficients(
6744                 __isl_take isl_set *set);
6745         __isl_give isl_union_set *isl_union_set_coefficients(
6746                 __isl_take isl_union_set *bset);
6747         __isl_give isl_basic_set *isl_basic_set_solutions(
6748                 __isl_take isl_basic_set *bset);
6749         __isl_give isl_basic_set *isl_set_solutions(
6750                 __isl_take isl_set *set);
6751         __isl_give isl_union_set *isl_union_set_solutions(
6752                 __isl_take isl_union_set *bset);
6754 =item * Power
6756         __isl_give isl_map *isl_map_fixed_power_val(
6757                 __isl_take isl_map *map,
6758                 __isl_take isl_val *exp);
6759         __isl_give isl_union_map *
6760         isl_union_map_fixed_power_val(
6761                 __isl_take isl_union_map *umap,
6762                 __isl_take isl_val *exp);
6764 Compute the given power of C<map>, where C<exp> is assumed to be non-zero.
6765 If the exponent C<exp> is negative, then the -C<exp> th power of the inverse
6766 of C<map> is computed.
6768         __isl_give isl_map *isl_map_power(__isl_take isl_map *map,
6769                 isl_bool *exact);
6770         __isl_give isl_union_map *isl_union_map_power(
6771                 __isl_take isl_union_map *umap, isl_bool *exact);
6773 Compute a parametric representation for all positive powers I<k> of C<map>.
6774 The result maps I<k> to a nested relation corresponding to the
6775 I<k>th power of C<map>.
6776 The result may be an overapproximation.  If the result is known to be exact,
6777 then C<*exact> is set to C<1>.
6779 =item * Transitive closure
6781         __isl_give isl_map *isl_map_transitive_closure(
6782                 __isl_take isl_map *map, isl_bool *exact);
6783         __isl_give isl_union_map *isl_union_map_transitive_closure(
6784                 __isl_take isl_union_map *umap, isl_bool *exact);
6786 Compute the transitive closure of C<map>.
6787 The result may be an overapproximation.  If the result is known to be exact,
6788 then C<*exact> is set to C<1>.
6790 =item * Reaching path lengths
6792         __isl_give isl_map *isl_map_reaching_path_lengths(
6793                 __isl_take isl_map *map, isl_bool *exact);
6795 Compute a relation that maps each element in the range of C<map>
6796 to the lengths of all paths composed of edges in C<map> that
6797 end up in the given element.
6798 The result may be an overapproximation.  If the result is known to be exact,
6799 then C<*exact> is set to C<1>.
6800 To compute the I<maximal> path length, the resulting relation
6801 should be postprocessed by C<isl_map_lexmax>.
6802 In particular, if the input relation is a dependence relation
6803 (mapping sources to sinks), then the maximal path length corresponds
6804 to the free schedule.
6805 Note, however, that C<isl_map_lexmax> expects the maximum to be
6806 finite, so if the path lengths are unbounded (possibly due to
6807 the overapproximation), then you will get an error message.
6809 =item * Wrapping
6811         #include <isl/space.h>
6812         __isl_give isl_space *isl_space_wrap(
6813                 __isl_take isl_space *space);
6814         __isl_give isl_space *isl_space_unwrap(
6815                 __isl_take isl_space *space);
6817         #include <isl/local_space.h>
6818         __isl_give isl_local_space *isl_local_space_wrap(
6819                 __isl_take isl_local_space *ls);
6821         #include <isl/set.h>
6822         __isl_give isl_basic_map *isl_basic_set_unwrap(
6823                 __isl_take isl_basic_set *bset);
6824         __isl_give isl_map *isl_set_unwrap(
6825                 __isl_take isl_set *set);
6827         #include <isl/map.h>
6828         __isl_give isl_basic_set *isl_basic_map_wrap(
6829                 __isl_take isl_basic_map *bmap);
6830         __isl_give isl_set *isl_map_wrap(
6831                 __isl_take isl_map *map);
6833         #include <isl/union_set.h>
6834         __isl_give isl_union_map *isl_union_set_unwrap(
6835                 __isl_take isl_union_set *uset);
6837         #include <isl/union_map.h>
6838         __isl_give isl_union_set *isl_union_map_wrap(
6839                 __isl_take isl_union_map *umap);
6841 The input to C<isl_space_unwrap> should
6842 be the space of a set, while that of
6843 C<isl_space_wrap> should be the space of a relation.
6844 Conversely, the output of C<isl_space_unwrap> is the space
6845 of a relation, while that of C<isl_space_wrap> is the space of a set.
6847 =item * Flattening
6849 Remove any internal structure of domain (and range) of the given
6850 set or relation.  If there is any such internal structure in the input,
6851 then the name of the space is also removed.
6853         #include <isl/space.h>
6854         __isl_give isl_space *isl_space_flatten_domain(
6855                 __isl_take isl_space *space);
6856         __isl_give isl_space *isl_space_flatten_range(
6857                 __isl_take isl_space *space);
6859         #include <isl/local_space.h>
6860         __isl_give isl_local_space *
6861         isl_local_space_flatten_domain(
6862                 __isl_take isl_local_space *ls);
6863         __isl_give isl_local_space *
6864         isl_local_space_flatten_range(
6865                 __isl_take isl_local_space *ls);
6867         #include <isl/set.h>
6868         __isl_give isl_basic_set *isl_basic_set_flatten(
6869                 __isl_take isl_basic_set *bset);
6870         __isl_give isl_set *isl_set_flatten(
6871                 __isl_take isl_set *set);
6873         #include <isl/map.h>
6874         __isl_give isl_basic_map *isl_basic_map_flatten_domain(
6875                 __isl_take isl_basic_map *bmap);
6876         __isl_give isl_basic_map *isl_basic_map_flatten_range(
6877                 __isl_take isl_basic_map *bmap);
6878         __isl_give isl_map *isl_map_flatten_range(
6879                 __isl_take isl_map *map);
6880         __isl_give isl_map *isl_map_flatten_domain(
6881                 __isl_take isl_map *map);
6882         __isl_give isl_basic_map *isl_basic_map_flatten(
6883                 __isl_take isl_basic_map *bmap);
6884         __isl_give isl_map *isl_map_flatten(
6885                 __isl_take isl_map *map);
6887         #include <isl/id.h>
6888         __isl_give isl_multi_id *isl_multi_id_flatten_range(
6889                 __isl_take isl_multi_id *mi);
6891         #include <isl/val.h>
6892         __isl_give isl_multi_val *isl_multi_val_flatten_range(
6893                 __isl_take isl_multi_val *mv);
6895         #include <isl/aff.h>
6896         __isl_give isl_multi_aff *isl_multi_aff_flatten_domain(
6897                 __isl_take isl_multi_aff *ma);
6898         __isl_give isl_multi_aff *isl_multi_aff_flatten_range(
6899                 __isl_take isl_multi_aff *ma);
6900         __isl_give isl_multi_pw_aff *
6901         isl_multi_pw_aff_flatten_range(
6902                 __isl_take isl_multi_pw_aff *mpa);
6903         __isl_give isl_multi_union_pw_aff *
6904         isl_multi_union_pw_aff_flatten_range(
6905                 __isl_take isl_multi_union_pw_aff *mupa);
6907         #include <isl/map.h>
6908         __isl_give isl_map *isl_set_flatten_map(
6909                 __isl_take isl_set *set);
6911 The function above constructs a relation
6912 that maps the input set to a flattened version of the set.
6914 =item * Lifting
6916 Lift the input set to a space with extra dimensions corresponding
6917 to the existentially quantified variables in the input.
6918 In particular, the result lives in a wrapped map where the domain
6919 is the original space and the range corresponds to the original
6920 existentially quantified variables.
6922         #include <isl/set.h>
6923         __isl_give isl_basic_set *isl_basic_set_lift(
6924                 __isl_take isl_basic_set *bset);
6925         __isl_give isl_set *isl_set_lift(
6926                 __isl_take isl_set *set);
6927         __isl_give isl_union_set *isl_union_set_lift(
6928                 __isl_take isl_union_set *uset);
6930 Given a local space that contains the existentially quantified
6931 variables of a set, a basic relation that, when applied to
6932 a basic set, has essentially the same effect as C<isl_basic_set_lift>,
6933 can be constructed using the following function.
6935         #include <isl/local_space.h>
6936         __isl_give isl_basic_map *isl_local_space_lifting(
6937                 __isl_take isl_local_space *ls);
6939         #include <isl/aff.h>
6940         __isl_give isl_multi_aff *isl_multi_aff_lift(
6941                 __isl_take isl_multi_aff *maff,
6942                 __isl_give isl_local_space **ls);
6944 If the C<ls> argument of C<isl_multi_aff_lift> is not C<NULL>,
6945 then it is assigned the local space that lies at the basis of
6946 the lifting applied.
6948 =item * Internal Product
6950         #include <isl/space.h>
6951         __isl_give isl_space *isl_space_zip(
6952                 __isl_take isl_space *space);
6954         #include <isl/map.h>
6955         __isl_give isl_basic_map *isl_basic_map_zip(
6956                 __isl_take isl_basic_map *bmap);
6957         __isl_give isl_map *isl_map_zip(
6958                 __isl_take isl_map *map);
6960         #include <isl/union_map.h>
6961         __isl_give isl_union_map *isl_union_map_zip(
6962                 __isl_take isl_union_map *umap);
6964 Given a relation with nested relations for domain and range,
6965 interchange the range of the domain with the domain of the range.
6967 =item * Currying
6969         #include <isl/space.h>
6970         __isl_give isl_space *isl_space_curry(
6971                 __isl_take isl_space *space);
6972         __isl_give isl_space *isl_space_uncurry(
6973                 __isl_take isl_space *space);
6975         #include <isl/map.h>
6976         __isl_give isl_basic_map *isl_basic_map_curry(
6977                 __isl_take isl_basic_map *bmap);
6978         __isl_give isl_basic_map *isl_basic_map_uncurry(
6979                 __isl_take isl_basic_map *bmap);
6980         __isl_give isl_map *isl_map_curry(
6981                 __isl_take isl_map *map);
6982         __isl_give isl_map *isl_map_uncurry(
6983                 __isl_take isl_map *map);
6985         #include <isl/union_map.h>
6986         __isl_give isl_union_map *isl_union_map_curry(
6987                 __isl_take isl_union_map *umap);
6988         __isl_give isl_union_map *isl_union_map_uncurry(
6989                 __isl_take isl_union_map *umap);
6991 Given a relation with a nested relation for domain,
6992 the C<curry> functions
6993 move the range of the nested relation out of the domain
6994 and use it as the domain of a nested relation in the range,
6995 with the original range as range of this nested relation.
6996 The C<uncurry> functions perform the inverse operation.
6998         #include <isl/space.h>
6999         __isl_give isl_space *isl_space_range_curry(
7000                 __isl_take isl_space *space);
7002         #include <isl/map.h>
7003         __isl_give isl_map *isl_map_range_curry(
7004                 __isl_take isl_map *map);
7006         #include <isl/union_map.h>
7007         __isl_give isl_union_map *isl_union_map_range_curry(
7008                 __isl_take isl_union_map *umap);
7010 These functions apply the currying to the relation that
7011 is nested inside the range of the input.
7013 =item * Aligning parameters
7015 Change the order of the parameters of the given set, relation
7016 or function
7017 such that the first parameters match those of C<model>.
7018 This may involve the introduction of extra parameters.
7019 All parameters need to be named.
7021         #include <isl/space.h>
7022         __isl_give isl_space *isl_space_align_params(
7023                 __isl_take isl_space *space1,
7024                 __isl_take isl_space *space2)
7026         #include <isl/set.h>
7027         __isl_give isl_basic_set *isl_basic_set_align_params(
7028                 __isl_take isl_basic_set *bset,
7029                 __isl_take isl_space *model);
7030         __isl_give isl_set *isl_set_align_params(
7031                 __isl_take isl_set *set,
7032                 __isl_take isl_space *model);
7034         #include <isl/map.h>
7035         __isl_give isl_basic_map *isl_basic_map_align_params(
7036                 __isl_take isl_basic_map *bmap,
7037                 __isl_take isl_space *model);
7038         __isl_give isl_map *isl_map_align_params(
7039                 __isl_take isl_map *map,
7040                 __isl_take isl_space *model);
7042         #include <isl/id.h>
7043         __isl_give isl_multi_id *isl_multi_id_align_params(
7044                 __isl_take isl_multi_id *mi,
7045                 __isl_take isl_space *model);
7047         #include <isl/val.h>
7048         __isl_give isl_multi_val *isl_multi_val_align_params(
7049                 __isl_take isl_multi_val *mv,
7050                 __isl_take isl_space *model);
7052         #include <isl/aff.h>
7053         __isl_give isl_aff *isl_aff_align_params(
7054                 __isl_take isl_aff *aff,
7055                 __isl_take isl_space *model);
7056         __isl_give isl_multi_aff *isl_multi_aff_align_params(
7057                 __isl_take isl_multi_aff *multi,
7058                 __isl_take isl_space *model);
7059         __isl_give isl_pw_aff *isl_pw_aff_align_params(
7060                 __isl_take isl_pw_aff *pwaff,
7061                 __isl_take isl_space *model);
7062         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_align_params(
7063                 __isl_take isl_pw_multi_aff *pma,
7064                 __isl_take isl_space *model);
7065         __isl_give isl_union_pw_aff *
7066         isl_union_pw_aff_align_params(
7067                 __isl_take isl_union_pw_aff *upa,
7068                 __isl_take isl_space *model);
7069         __isl_give isl_union_pw_multi_aff *
7070         isl_union_pw_multi_aff_align_params(
7071                 __isl_take isl_union_pw_multi_aff *upma,
7072                 __isl_take isl_space *model);
7073         __isl_give isl_multi_union_pw_aff *
7074         isl_multi_union_pw_aff_align_params(
7075                 __isl_take isl_multi_union_pw_aff *mupa,
7076                 __isl_take isl_space *model);
7078         #include <isl/polynomial.h>
7079         __isl_give isl_qpolynomial *isl_qpolynomial_align_params(
7080                 __isl_take isl_qpolynomial *qp,
7081                 __isl_take isl_space *model);
7083 =item * Drop unused parameters
7085 Drop parameters that are not referenced by the isl object.
7086 All parameters need to be named.
7088         #include <isl/set.h>
7089         __isl_give isl_basic_set *
7090         isl_basic_set_drop_unused_params(
7091                 __isl_take isl_basic_set *bset);
7092         __isl_give isl_set *isl_set_drop_unused_params(
7093                 __isl_take isl_set *set);
7095         #include <isl/map.h>
7096         __isl_give isl_basic_map *
7097         isl_basic_map_drop_unused_params(
7098                 __isl_take isl_basic_map *bmap);
7099         __isl_give isl_map *isl_map_drop_unused_params(
7100                 __isl_take isl_map *map);
7102         #include <isl/union_set.h>
7103         __isl_give isl_union_set *
7104         isl_union_set_drop_unused_params(
7105                 __isl_take isl_union_set *uset);
7107         #include <isl/union_map.h>
7108         __isl_give isl_union_map *
7109         isl_union_map_drop_unused_params(
7110                 __isl_take isl_union_map *umap);
7112         #include <isl/aff.h>
7113         __isl_give isl_pw_aff *isl_pw_aff_drop_unused_params(
7114                 __isl_take isl_pw_aff *pa);
7115         __isl_give isl_pw_multi_aff *
7116         isl_pw_multi_aff_drop_unused_params(
7117                 __isl_take isl_pw_multi_aff *pma);
7118         __isl_give isl_union_pw_aff *
7119         isl_union_pw_aff_drop_unused_params(
7120                 __isl_take isl_union_pw_aff *upa);
7121         __isl_give isl_union_pw_multi_aff *
7122         isl_union_pw_multi_aff_drop_unused_params(
7123                 __isl_take isl_union_pw_multi_aff *upma);
7125         #include <isl/polynomial.h>
7126         __isl_give isl_pw_qpolynomial *
7127         isl_pw_qpolynomial_drop_unused_params(
7128                 __isl_take isl_pw_qpolynomial *pwqp);
7129         __isl_give isl_pw_qpolynomial_fold *
7130         isl_pw_qpolynomial_fold_drop_unused_params(
7131                 __isl_take isl_pw_qpolynomial_fold *pwf);
7132         __isl_give isl_union_pw_qpolynomial *
7133         isl_union_pw_qpolynomial_drop_unused_params(
7134                 __isl_take isl_union_pw_qpolynomial *upwqp);
7135         __isl_give isl_union_pw_qpolynomial_fold *
7136         isl_union_pw_qpolynomial_fold_drop_unused_params(
7137                 __isl_take isl_union_pw_qpolynomial_fold *upwf);
7139 =item * Unary Arithmetic Operations
7141         #include <isl/set.h>
7142         __isl_give isl_set *isl_set_neg(
7143                 __isl_take isl_set *set);
7144         #include <isl/map.h>
7145         __isl_give isl_map *isl_map_neg(
7146                 __isl_take isl_map *map);
7148 C<isl_set_neg> constructs a set containing the opposites of
7149 the elements in its argument.
7150 The domain of the result of C<isl_map_neg> is the same
7151 as the domain of its argument.  The corresponding range
7152 elements are the opposites of the corresponding range
7153 elements in the argument.
7155         #include <isl/val.h>
7156         __isl_give isl_multi_val *isl_multi_val_neg(
7157                 __isl_take isl_multi_val *mv);
7159         #include <isl/aff.h>
7160         __isl_give isl_aff *isl_aff_neg(
7161                 __isl_take isl_aff *aff);
7162         __isl_give isl_multi_aff *isl_multi_aff_neg(
7163                 __isl_take isl_multi_aff *ma);
7164         __isl_give isl_pw_aff *isl_pw_aff_neg(
7165                 __isl_take isl_pw_aff *pwaff);
7166         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_neg(
7167                 __isl_take isl_pw_multi_aff *pma);
7168         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_neg(
7169                 __isl_take isl_multi_pw_aff *mpa);
7170         __isl_give isl_union_pw_aff *isl_union_pw_aff_neg(
7171                 __isl_take isl_union_pw_aff *upa);
7172         __isl_give isl_union_pw_multi_aff *
7173         isl_union_pw_multi_aff_neg(
7174                 __isl_take isl_union_pw_multi_aff *upma);
7175         __isl_give isl_multi_union_pw_aff *
7176         isl_multi_union_pw_aff_neg(
7177                 __isl_take isl_multi_union_pw_aff *mupa);
7178         __isl_give isl_aff *isl_aff_ceil(
7179                 __isl_take isl_aff *aff);
7180         __isl_give isl_pw_aff *isl_pw_aff_ceil(
7181                 __isl_take isl_pw_aff *pwaff);
7182         __isl_give isl_aff *isl_aff_floor(
7183                 __isl_take isl_aff *aff);
7184         __isl_give isl_multi_aff *isl_multi_aff_floor(
7185                 __isl_take isl_multi_aff *ma);
7186         __isl_give isl_pw_aff *isl_pw_aff_floor(
7187                 __isl_take isl_pw_aff *pwaff);
7188         __isl_give isl_union_pw_aff *isl_union_pw_aff_floor(
7189                 __isl_take isl_union_pw_aff *upa);
7190         __isl_give isl_multi_union_pw_aff *
7191         isl_multi_union_pw_aff_floor(
7192                 __isl_take isl_multi_union_pw_aff *mupa);
7194         #include <isl/aff.h>
7195         __isl_give isl_pw_aff *isl_pw_aff_list_min(
7196                 __isl_take isl_pw_aff_list *list);
7197         __isl_give isl_pw_aff *isl_pw_aff_list_max(
7198                 __isl_take isl_pw_aff_list *list);
7200         #include <isl/polynomial.h>
7201         __isl_give isl_qpolynomial *isl_qpolynomial_neg(
7202                 __isl_take isl_qpolynomial *qp);
7203         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_neg(
7204                 __isl_take isl_pw_qpolynomial *pwqp);
7205         __isl_give isl_union_pw_qpolynomial *
7206         isl_union_pw_qpolynomial_neg(
7207                 __isl_take isl_union_pw_qpolynomial *upwqp);
7208         __isl_give isl_qpolynomial *isl_qpolynomial_pow(
7209                 __isl_take isl_qpolynomial *qp,
7210                 unsigned exponent);
7211         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_pow(
7212                 __isl_take isl_pw_qpolynomial *pwqp,
7213                 unsigned exponent);
7215 =item * Evaluation
7217 The following functions evaluate a function in a point.
7219         #include <isl/aff.h>
7220         __isl_give isl_val *isl_aff_eval(
7221                 __isl_take isl_aff *aff,
7222                 __isl_take isl_point *pnt);
7223         __isl_give isl_val *isl_pw_aff_eval(
7224                 __isl_take isl_pw_aff *pa,
7225                 __isl_take isl_point *pnt);
7227         #include <isl/polynomial.h>
7228         __isl_give isl_val *isl_pw_qpolynomial_eval(
7229                 __isl_take isl_pw_qpolynomial *pwqp,
7230                 __isl_take isl_point *pnt);
7231         __isl_give isl_val *isl_pw_qpolynomial_fold_eval(
7232                 __isl_take isl_pw_qpolynomial_fold *pwf,
7233                 __isl_take isl_point *pnt);
7234         __isl_give isl_val *isl_union_pw_qpolynomial_eval(
7235                 __isl_take isl_union_pw_qpolynomial *upwqp,
7236                 __isl_take isl_point *pnt);
7237         __isl_give isl_val *isl_union_pw_qpolynomial_fold_eval(
7238                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
7239                 __isl_take isl_point *pnt);
7241 These functions return NaN when evaluated at a void point.
7242 Note that C<isl_pw_aff_eval> returns NaN when the function is evaluated outside
7243 its definition domain, while C<isl_pw_qpolynomial_eval> returns zero
7244 when the function is evaluated outside its explicit domain.
7246 =item * Dimension manipulation
7248 It is usually not advisable to directly change the (input or output)
7249 space of a set or a relation as this removes the name and the internal
7250 structure of the space.  However, the functions below can be useful
7251 to add new parameters, assuming
7252 C<isl_set_align_params> and C<isl_map_align_params>
7253 are not sufficient.
7255         #include <isl/space.h>
7256         __isl_give isl_space *isl_space_add_dims(
7257                 __isl_take isl_space *space,
7258                 enum isl_dim_type type, unsigned n);
7259         __isl_give isl_space *isl_space_insert_dims(
7260                 __isl_take isl_space *space,
7261                 enum isl_dim_type type, unsigned pos, unsigned n);
7262         __isl_give isl_space *isl_space_drop_dims(
7263                 __isl_take isl_space *space,
7264                 enum isl_dim_type type, unsigned first, unsigned n);
7265         __isl_give isl_space *isl_space_move_dims(
7266                 __isl_take isl_space *space,
7267                 enum isl_dim_type dst_type, unsigned dst_pos,
7268                 enum isl_dim_type src_type, unsigned src_pos,
7269                 unsigned n);
7271         #include <isl/local_space.h>
7272         __isl_give isl_local_space *isl_local_space_add_dims(
7273                 __isl_take isl_local_space *ls,
7274                 enum isl_dim_type type, unsigned n);
7275         __isl_give isl_local_space *isl_local_space_insert_dims(
7276                 __isl_take isl_local_space *ls,
7277                 enum isl_dim_type type, unsigned first, unsigned n);
7278         __isl_give isl_local_space *isl_local_space_drop_dims(
7279                 __isl_take isl_local_space *ls,
7280                 enum isl_dim_type type, unsigned first, unsigned n);
7282         #include <isl/set.h>
7283         __isl_give isl_basic_set *isl_basic_set_add_dims(
7284                 __isl_take isl_basic_set *bset,
7285                 enum isl_dim_type type, unsigned n);
7286         __isl_give isl_set *isl_set_add_dims(
7287                 __isl_take isl_set *set,
7288                 enum isl_dim_type type, unsigned n);
7289         __isl_give isl_basic_set *isl_basic_set_insert_dims(
7290                 __isl_take isl_basic_set *bset,
7291                 enum isl_dim_type type, unsigned pos,
7292                 unsigned n);
7293         __isl_give isl_set *isl_set_insert_dims(
7294                 __isl_take isl_set *set,
7295                 enum isl_dim_type type, unsigned pos, unsigned n);
7296         __isl_give isl_basic_set *isl_basic_set_move_dims(
7297                 __isl_take isl_basic_set *bset,
7298                 enum isl_dim_type dst_type, unsigned dst_pos,
7299                 enum isl_dim_type src_type, unsigned src_pos,
7300                 unsigned n);
7301         __isl_give isl_set *isl_set_move_dims(
7302                 __isl_take isl_set *set,
7303                 enum isl_dim_type dst_type, unsigned dst_pos,
7304                 enum isl_dim_type src_type, unsigned src_pos,
7305                 unsigned n);
7307         #include <isl/map.h>
7308         __isl_give isl_basic_map *isl_basic_map_add_dims(
7309                 __isl_take isl_basic_map *bmap,
7310                 enum isl_dim_type type, unsigned n);
7311         __isl_give isl_map *isl_map_add_dims(
7312                 __isl_take isl_map *map,
7313                 enum isl_dim_type type, unsigned n);
7314         __isl_give isl_basic_map *isl_basic_map_insert_dims(
7315                 __isl_take isl_basic_map *bmap,
7316                 enum isl_dim_type type, unsigned pos,
7317                 unsigned n);
7318         __isl_give isl_map *isl_map_insert_dims(
7319                 __isl_take isl_map *map,
7320                 enum isl_dim_type type, unsigned pos, unsigned n);
7321         __isl_give isl_basic_map *isl_basic_map_move_dims(
7322                 __isl_take isl_basic_map *bmap,
7323                 enum isl_dim_type dst_type, unsigned dst_pos,
7324                 enum isl_dim_type src_type, unsigned src_pos,
7325                 unsigned n);
7326         __isl_give isl_map *isl_map_move_dims(
7327                 __isl_take isl_map *map,
7328                 enum isl_dim_type dst_type, unsigned dst_pos,
7329                 enum isl_dim_type src_type, unsigned src_pos,
7330                 unsigned n);
7332         #include <isl/val.h>
7333         __isl_give isl_multi_val *isl_multi_val_insert_dims(
7334                 __isl_take isl_multi_val *mv,
7335                 enum isl_dim_type type, unsigned first, unsigned n);
7336         __isl_give isl_multi_val *isl_multi_val_add_dims(
7337                 __isl_take isl_multi_val *mv,
7338                 enum isl_dim_type type, unsigned n);
7339         __isl_give isl_multi_val *isl_multi_val_drop_dims(
7340                 __isl_take isl_multi_val *mv,
7341                 enum isl_dim_type type, unsigned first, unsigned n);
7343         #include <isl/aff.h>
7344         __isl_give isl_aff *isl_aff_insert_dims(
7345                 __isl_take isl_aff *aff,
7346                 enum isl_dim_type type, unsigned first, unsigned n);
7347         __isl_give isl_multi_aff *isl_multi_aff_insert_dims(
7348                 __isl_take isl_multi_aff *ma,
7349                 enum isl_dim_type type, unsigned first, unsigned n);
7350         __isl_give isl_pw_aff *isl_pw_aff_insert_dims(
7351                 __isl_take isl_pw_aff *pwaff,
7352                 enum isl_dim_type type, unsigned first, unsigned n);
7353         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_insert_dims(
7354                 __isl_take isl_multi_pw_aff *mpa,
7355                 enum isl_dim_type type, unsigned first, unsigned n);
7356         __isl_give isl_aff *isl_aff_add_dims(
7357                 __isl_take isl_aff *aff,
7358                 enum isl_dim_type type, unsigned n);
7359         __isl_give isl_multi_aff *isl_multi_aff_add_dims(
7360                 __isl_take isl_multi_aff *ma,
7361                 enum isl_dim_type type, unsigned n);
7362         __isl_give isl_pw_aff *isl_pw_aff_add_dims(
7363                 __isl_take isl_pw_aff *pwaff,
7364                 enum isl_dim_type type, unsigned n);
7365         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_add_dims(
7366                 __isl_take isl_multi_pw_aff *mpa,
7367                 enum isl_dim_type type, unsigned n);
7368         __isl_give isl_aff *isl_aff_drop_dims(
7369                 __isl_take isl_aff *aff,
7370                 enum isl_dim_type type, unsigned first, unsigned n);
7371         __isl_give isl_multi_aff *isl_multi_aff_drop_dims(
7372                 __isl_take isl_multi_aff *maff,
7373                 enum isl_dim_type type, unsigned first, unsigned n);
7374         __isl_give isl_pw_aff *isl_pw_aff_drop_dims(
7375                 __isl_take isl_pw_aff *pwaff,
7376                 enum isl_dim_type type, unsigned first, unsigned n);
7377         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_drop_dims(
7378                 __isl_take isl_pw_multi_aff *pma,
7379                 enum isl_dim_type type, unsigned first, unsigned n);
7380         __isl_give isl_union_pw_aff *isl_union_pw_aff_drop_dims(
7381                 __isl_take isl_union_pw_aff *upa,
7382                 enum isl_dim_type type, unsigned first, unsigned n);
7383         __isl_give isl_union_pw_multi_aff *
7384                 isl_union_pw_multi_aff_drop_dims(
7385                 __isl_take isl_union_pw_multi_aff *upma,
7386                 enum isl_dim_type type,
7387                 unsigned first, unsigned n);
7388         __isl_give isl_multi_union_pw_aff *
7389         isl_multi_union_pw_aff_drop_dims(
7390                 __isl_take isl_multi_union_pw_aff *mupa,
7391                 enum isl_dim_type type, unsigned first,
7392                 unsigned n);
7393         __isl_give isl_aff *isl_aff_move_dims(
7394                 __isl_take isl_aff *aff,
7395                 enum isl_dim_type dst_type, unsigned dst_pos,
7396                 enum isl_dim_type src_type, unsigned src_pos,
7397                 unsigned n);
7398         __isl_give isl_multi_aff *isl_multi_aff_move_dims(
7399                 __isl_take isl_multi_aff *ma,
7400                 enum isl_dim_type dst_type, unsigned dst_pos,
7401                 enum isl_dim_type src_type, unsigned src_pos,
7402                 unsigned n);
7403         __isl_give isl_pw_aff *isl_pw_aff_move_dims(
7404                 __isl_take isl_pw_aff *pa,
7405                 enum isl_dim_type dst_type, unsigned dst_pos,
7406                 enum isl_dim_type src_type, unsigned src_pos,
7407                 unsigned n);
7408         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_move_dims(
7409                 __isl_take isl_multi_pw_aff *pma,
7410                 enum isl_dim_type dst_type, unsigned dst_pos,
7411                 enum isl_dim_type src_type, unsigned src_pos,
7412                 unsigned n);
7414         #include <isl/polynomial.h>
7415         __isl_give isl_union_pw_qpolynomial *
7416         isl_union_pw_qpolynomial_drop_dims(
7417                 __isl_take isl_union_pw_qpolynomial *upwqp,
7418                 enum isl_dim_type type,
7419                 unsigned first, unsigned n);
7420         __isl_give isl_union_pw_qpolynomial_fold *
7421                 isl_union_pw_qpolynomial_fold_drop_dims(
7422                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
7423                 enum isl_dim_type type,
7424                 unsigned first, unsigned n);
7426 The operations on union expressions can only manipulate parameters.
7428 =back
7430 =head2 Binary Operations
7432 The two arguments of a binary operation not only need to live
7433 in the same C<isl_ctx>, they currently also need to have
7434 the same (number of) parameters.
7436 =head3 Basic Operations
7438 =over
7440 =item * Intersection
7442         #include <isl/local_space.h>
7443         __isl_give isl_local_space *isl_local_space_intersect(
7444                 __isl_take isl_local_space *ls1,
7445                 __isl_take isl_local_space *ls2);
7447         #include <isl/set.h>
7448         __isl_give isl_basic_set *isl_basic_set_intersect_params(
7449                 __isl_take isl_basic_set *bset1,
7450                 __isl_take isl_basic_set *bset2);
7451         __isl_give isl_basic_set *isl_basic_set_intersect(
7452                 __isl_take isl_basic_set *bset1,
7453                 __isl_take isl_basic_set *bset2);
7454         __isl_give isl_basic_set *isl_basic_set_list_intersect(
7455                 __isl_take struct isl_basic_set_list *list);
7456         __isl_give isl_set *isl_set_intersect_params(
7457                 __isl_take isl_set *set,
7458                 __isl_take isl_set *params);
7459         __isl_give isl_set *isl_set_intersect(
7460                 __isl_take isl_set *set1,
7461                 __isl_take isl_set *set2);
7462         __isl_give isl_set *isl_set_intersect_factor_domain(
7463                 __isl_take isl_set *set,
7464                 __isl_take isl_set *domain);
7465         __isl_give isl_set *isl_set_intersect_factor_range(
7466                 __isl_take isl_set *set,
7467                 __isl_take isl_set *range);
7469         #include <isl/map.h>
7470         __isl_give isl_basic_map *isl_basic_map_intersect_domain(
7471                 __isl_take isl_basic_map *bmap,
7472                 __isl_take isl_basic_set *bset);
7473         __isl_give isl_basic_map *isl_basic_map_intersect_range(
7474                 __isl_take isl_basic_map *bmap,
7475                 __isl_take isl_basic_set *bset);
7476         __isl_give isl_basic_map *isl_basic_map_intersect(
7477                 __isl_take isl_basic_map *bmap1,
7478                 __isl_take isl_basic_map *bmap2);
7479         __isl_give isl_basic_map *isl_basic_map_list_intersect(
7480                 __isl_take isl_basic_map_list *list);
7481         __isl_give isl_map *isl_map_intersect_params(
7482                 __isl_take isl_map *map,
7483                 __isl_take isl_set *params);
7484         __isl_give isl_map *isl_map_intersect_domain(
7485                 __isl_take isl_map *map,
7486                 __isl_take isl_set *set);
7487         __isl_give isl_map *isl_map_intersect_range(
7488                 __isl_take isl_map *map,
7489                 __isl_take isl_set *set);
7490         __isl_give isl_map *isl_map_intersect(
7491                 __isl_take isl_map *map1,
7492                 __isl_take isl_map *map2);
7493         __isl_give isl_map *
7494         isl_map_intersect_domain_factor_domain(
7495                 __isl_take isl_map *map,
7496                 __isl_take isl_map *factor);
7497         __isl_give isl_map *
7498         isl_map_intersect_domain_factor_range(
7499                 __isl_take isl_map *map,
7500                 __isl_take isl_map *factor);
7501         __isl_give isl_map *
7502         isl_map_intersect_range_factor_domain(
7503                 __isl_take isl_map *map,
7504                 __isl_take isl_map *factor);
7505         __isl_give isl_map *
7506         isl_map_intersect_range_factor_range(
7507                 __isl_take isl_map *map,
7508                 __isl_take isl_map *factor);
7509         __isl_give isl_map *
7510         isl_map_intersect_domain_wrapped_domain(
7511                 __isl_take isl_map *map,
7512                 __isl_take isl_set *domain);
7513         __isl_give isl_map *
7514         isl_map_intersect_range_wrapped_domain(
7515                 __isl_take isl_map *map,
7516                 __isl_take isl_set *domain);
7518         #include <isl/union_set.h>
7519         __isl_give isl_union_set *isl_union_set_intersect_params(
7520                 __isl_take isl_union_set *uset,
7521                 __isl_take isl_set *set);
7522         __isl_give isl_union_set *isl_union_set_intersect(
7523                 __isl_take isl_union_set *uset1,
7524                 __isl_take isl_union_set *uset2);
7526         #include <isl/union_map.h>
7527         __isl_give isl_union_map *isl_union_map_intersect_params(
7528                 __isl_take isl_union_map *umap,
7529                 __isl_take isl_set *set);
7530         __isl_give isl_union_map *
7531         isl_union_map_intersect_domain_union_set(
7532                 __isl_take isl_union_map *umap,
7533                 __isl_take isl_union_set *uset);
7534         __isl_give isl_union_map *
7535         isl_union_map_intersect_domain_space(
7536                 __isl_take isl_union_map *umap,
7537                 __isl_take isl_space *space);
7538         __isl_give isl_union_map *isl_union_map_intersect_domain(
7539                 __isl_take isl_union_map *umap,
7540                 __isl_take isl_union_set *uset);
7541         __isl_give isl_union_map *
7542         isl_union_map_intersect_range_union_set(
7543                 __isl_take isl_union_map *umap,
7544                 __isl_take isl_union_set *uset);
7545         __isl_give isl_union_map *
7546         isl_union_map_intersect_range_space(
7547                 __isl_take isl_union_map *umap,
7548                 __isl_take isl_space *space);
7549         __isl_give isl_union_map *isl_union_map_intersect_range(
7550                 __isl_take isl_union_map *umap,
7551                 __isl_take isl_union_set *uset);
7552         __isl_give isl_union_map *isl_union_map_intersect(
7553                 __isl_take isl_union_map *umap1,
7554                 __isl_take isl_union_map *umap2);
7555         __isl_give isl_union_map *
7556         isl_union_map_intersect_domain_factor_domain(
7557                 __isl_take isl_union_map *umap,
7558                 __isl_take isl_union_map *factor);
7559         __isl_give isl_union_map *
7560         isl_union_map_intersect_domain_factor_range(
7561                 __isl_take isl_union_map *umap,
7562                 __isl_take isl_union_map *factor);
7563         __isl_give isl_union_map *
7564         isl_union_map_intersect_range_factor_domain(
7565                 __isl_take isl_union_map *umap,
7566                 __isl_take isl_union_map *factor);
7567         __isl_give isl_union_map *
7568         isl_union_map_intersect_range_factor_range(
7569                 __isl_take isl_union_map *umap,
7570                 __isl_take isl_union_map *factor);
7571         __isl_give isl_union_map *
7572         isl_union_map_intersect_domain_wrapped_domain_union_set(
7573                 __isl_take isl_union_map *umap,
7574                 __isl_take isl_union_set *domain);
7575         __isl_give isl_union_map *
7576         isl_union_map_intersect_range_wrapped_domain_union_set(
7577                 __isl_take isl_union_map *umap,
7578                 __isl_take isl_union_set *domain);
7580         #include <isl/aff.h>
7581         __isl_give isl_pw_aff *isl_pw_aff_intersect_domain(
7582                 __isl_take isl_pw_aff *pa,
7583                 __isl_take isl_set *set);
7584         __isl_give isl_multi_pw_aff *
7585         isl_multi_pw_aff_intersect_domain(
7586                 __isl_take isl_multi_pw_aff *mpa,
7587                 __isl_take isl_set *domain);
7588         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_domain(
7589                 __isl_take isl_pw_multi_aff *pma,
7590                 __isl_take isl_set *set);
7591         __isl_give isl_union_pw_aff *
7592         isl_union_pw_aff_intersect_domain_space(
7593                 __isl_take isl_union_pw_aff *upa,
7594                 __isl_take isl_space *space);
7595         __isl_give isl_union_pw_aff *
7596         isl_union_pw_aff_intersect_domain_union_set(
7597                 __isl_take isl_union_pw_aff *upa,
7598                 __isl_take isl_union_set *uset);
7599         __isl_give isl_union_pw_aff *isl_union_pw_aff_intersect_domain(
7600                 __isl_take isl_union_pw_aff *upa,
7601                 __isl_take isl_union_set *uset);
7602         __isl_give isl_union_pw_multi_aff *
7603         isl_union_pw_multi_aff_intersect_domain_space(
7604                 __isl_take isl_union_pw_multi_aff *upma,
7605                 __isl_take isl_space *space);
7606         __isl_give isl_union_pw_multi_aff *
7607         isl_union_pw_multi_aff_intersect_domain_union_set(
7608                 __isl_take isl_union_pw_multi_aff *upma,
7609                 __isl_take isl_union_set *uset);
7610         __isl_give isl_union_pw_multi_aff *
7611         isl_union_pw_multi_aff_intersect_domain(
7612                 __isl_take isl_union_pw_multi_aff *upma,
7613                 __isl_take isl_union_set *uset);
7614         __isl_give isl_multi_union_pw_aff *
7615         isl_multi_union_pw_aff_intersect_domain(
7616                 __isl_take isl_multi_union_pw_aff *mupa,
7617                 __isl_take isl_union_set *uset);
7618         __isl_give isl_pw_aff *
7619         isl_pw_aff_intersect_domain_wrapped_domain(
7620                 __isl_take isl_pw_aff *pa,
7621                 __isl_take isl_set *set);
7622         __isl_give isl_pw_multi_aff *
7623         isl_pw_multi_aff_intersect_domain_wrapped_domain(
7624                 __isl_take isl_pw_multi_aff *pma,
7625                 __isl_take isl_set *set);
7626         __isl_give isl_union_pw_aff *
7627         isl_union_pw_aff_intersect_domain_wrapped_domain(
7628                 __isl_take isl_union_pw_aff *upa,
7629                 __isl_take isl_union_set *uset);
7630         __isl_give isl_union_pw_multi_aff *
7631         isl_union_pw_multi_aff_intersect_domain_wrapped_domain(
7632                 __isl_take isl_union_pw_multi_aff *upma,
7633                 __isl_take isl_union_set *uset);
7634         __isl_give isl_pw_aff *
7635         isl_pw_aff_intersect_domain_wrapped_range(
7636                 __isl_take isl_pw_aff *pa,
7637                 __isl_take isl_set *set);
7638         __isl_give isl_pw_multi_aff *
7639         isl_pw_multi_aff_intersect_domain_wrapped_range(
7640                 __isl_take isl_pw_multi_aff *pma,
7641                 __isl_take isl_set *set);
7642         __isl_give isl_union_pw_multi_aff *
7643         isl_union_pw_multi_aff_intersect_domain_wrapped_range(
7644                 __isl_take isl_union_pw_multi_aff *upma,
7645                 __isl_take isl_union_set *uset);
7646         __isl_give isl_union_pw_aff *
7647         isl_union_pw_aff_intersect_domain_wrapped_range(
7648                 __isl_take isl_union_pw_aff *upa,
7649                 __isl_take isl_union_set *uset);
7650         __isl_give isl_pw_aff *isl_pw_aff_intersect_params(
7651                 __isl_take isl_pw_aff *pa,
7652                 __isl_take isl_set *set);
7653         __isl_give isl_multi_pw_aff *
7654         isl_multi_pw_aff_intersect_params(
7655                 __isl_take isl_multi_pw_aff *mpa,
7656                 __isl_take isl_set *set);
7657         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_params(
7658                 __isl_take isl_pw_multi_aff *pma,
7659                 __isl_take isl_set *set);
7660         __isl_give isl_union_pw_aff *
7661         isl_union_pw_aff_intersect_params(
7662                 __isl_take isl_union_pw_aff *upa,
7663                 __isl_take isl_set *set);
7664         __isl_give isl_union_pw_multi_aff *
7665         isl_union_pw_multi_aff_intersect_params(
7666                 __isl_take isl_union_pw_multi_aff *upma,
7667                 __isl_take isl_set *set);
7668         __isl_give isl_multi_union_pw_aff *
7669         isl_multi_union_pw_aff_intersect_params(
7670                 __isl_take isl_multi_union_pw_aff *mupa,
7671                 __isl_take isl_set *params);
7672         __isl_give isl_multi_union_pw_aff *
7673         isl_multi_union_pw_aff_intersect_range(
7674                 __isl_take isl_multi_union_pw_aff *mupa,
7675                 __isl_take isl_set *set);
7677         #include <isl/polynomial.h>
7678         __isl_give isl_pw_qpolynomial *
7679         isl_pw_qpolynomial_intersect_domain(
7680                 __isl_take isl_pw_qpolynomial *pwpq,
7681                 __isl_take isl_set *set);
7682         __isl_give isl_union_pw_qpolynomial *
7683         isl_union_pw_qpolynomial_intersect_domain_space(
7684                 __isl_take isl_union_pw_qpolynomial *upwpq,
7685                 __isl_take isl_space *space);
7686         __isl_give isl_union_pw_qpolynomial *
7687         isl_union_pw_qpolynomial_intersect_domain_union_set(
7688                 __isl_take isl_union_pw_qpolynomial *upwpq,
7689                 __isl_take isl_union_set *uset);
7690         __isl_give isl_union_pw_qpolynomial *
7691         isl_union_pw_qpolynomial_intersect_domain(
7692                 __isl_take isl_union_pw_qpolynomial *upwpq,
7693                 __isl_take isl_union_set *uset);
7694         __isl_give isl_union_pw_qpolynomial_fold *
7695         isl_union_pw_qpolynomial_fold_intersect_domain_space(
7696                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
7697                 __isl_take isl_space *space);
7698         __isl_give isl_union_pw_qpolynomial_fold *
7699         isl_union_pw_qpolynomial_fold_intersect_domain_union_set(
7700                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
7701                 __isl_take isl_union_set *uset);
7702         __isl_give isl_union_pw_qpolynomial_fold *
7703         isl_union_pw_qpolynomial_fold_intersect_domain(
7704                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
7705                 __isl_take isl_union_set *uset);
7706         __isl_give isl_pw_qpolynomial *
7707         isl_pw_qpolynomial_intersect_domain_wrapped_domain(
7708                 __isl_take isl_pw_qpolynomial *pwpq,
7709                 __isl_take isl_set *set);
7710         __isl_give isl_pw_qpolynomial_fold *
7711         isl_pw_qpolynomial_fold_intersect_domain_wrapped_domain(
7712                 __isl_take isl_pw_qpolynomial_fold *pwf,
7713                 __isl_take isl_set *set);
7714         __isl_give isl_union_pw_qpolynomial *
7715         isl_union_pw_qpolynomial_intersect_domain_wrapped_domain(
7716                 __isl_take isl_union_pw_qpolynomial *upwpq,
7717                 __isl_take isl_union_set *uset);
7718         __isl_give isl_union_pw_qpolynomial_fold *
7719         isl_union_pw_qpolynomial_fold_intersect_domain_wrapped_domain(
7720                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
7721                 __isl_take isl_union_set *uset);
7722         __isl_give isl_pw_qpolynomial *
7723         isl_pw_qpolynomial_intersect_domain_wrapped_range(
7724                 __isl_take isl_pw_qpolynomial *pwpq,
7725                 __isl_take isl_set *set);
7726         __isl_give isl_pw_qpolynomial_fold *
7727         isl_pw_qpolynomial_fold_intersect_domain_wrapped_range(
7728                 __isl_take isl_pw_qpolynomial_fold *pwf,
7729                 __isl_take isl_set *set);
7730         __isl_give isl_union_pw_qpolynomial *
7731         isl_union_pw_qpolynomial_intersect_domain_wrapped_range(
7732                 __isl_take isl_union_pw_qpolynomial *upwpq,
7733                 __isl_take isl_union_set *uset);
7734         __isl_give isl_union_pw_qpolynomial_fold *
7735         isl_union_pw_qpolynomial_fold_intersect_domain_wrapped_range(
7736                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
7737                 __isl_take isl_union_set *uset);
7738         __isl_give isl_pw_qpolynomial *
7739         isl_pw_qpolynomial_intersect_params(
7740                 __isl_take isl_pw_qpolynomial *pwpq,
7741                 __isl_take isl_set *set);
7742         __isl_give isl_pw_qpolynomial_fold *
7743         isl_pw_qpolynomial_fold_intersect_params(
7744                 __isl_take isl_pw_qpolynomial_fold *pwf,
7745                 __isl_take isl_set *set);
7746         __isl_give isl_union_pw_qpolynomial *
7747         isl_union_pw_qpolynomial_intersect_params(
7748                 __isl_take isl_union_pw_qpolynomial *upwpq,
7749                 __isl_take isl_set *set);
7750         __isl_give isl_union_pw_qpolynomial_fold *
7751         isl_union_pw_qpolynomial_fold_intersect_params(
7752                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
7753                 __isl_take isl_set *set);
7755 The second argument to the C<_params> functions needs to be
7756 a parametric (basic) set.  For the other functions, a parametric set
7757 for either argument is only allowed if the other argument is
7758 a parametric set as well.
7759 The list passed to C<isl_basic_set_list_intersect> needs to have
7760 at least one element and all elements need to live in the same space.
7761 The function C<isl_multi_union_pw_aff_intersect_range>
7762 restricts the input function to those shared domain elements
7763 that map to the specified range.
7764 C<isl_union_map_intersect_domain> is an alternative name for
7765 C<isl_union_map_intersect_domain_union_set>.
7766 Similarly for the other pairs of functions.
7768 =item * Union
7770         #include <isl/set.h>
7771         __isl_give isl_set *isl_basic_set_union(
7772                 __isl_take isl_basic_set *bset1,
7773                 __isl_take isl_basic_set *bset2);
7774         __isl_give isl_set *isl_set_union(
7775                 __isl_take isl_set *set1,
7776                 __isl_take isl_set *set2);
7777         __isl_give isl_set *isl_set_list_union(
7778                 __isl_take isl_set_list *list);
7780         #include <isl/map.h>
7781         __isl_give isl_map *isl_basic_map_union(
7782                 __isl_take isl_basic_map *bmap1,
7783                 __isl_take isl_basic_map *bmap2);
7784         __isl_give isl_map *isl_map_union(
7785                 __isl_take isl_map *map1,
7786                 __isl_take isl_map *map2);
7788         #include <isl/union_set.h>
7789         __isl_give isl_union_set *isl_union_set_union(
7790                 __isl_take isl_union_set *uset1,
7791                 __isl_take isl_union_set *uset2);
7792         __isl_give isl_union_set *isl_union_set_list_union(
7793                 __isl_take isl_union_set_list *list);
7795         #include <isl/union_map.h>
7796         __isl_give isl_union_map *isl_union_map_union(
7797                 __isl_take isl_union_map *umap1,
7798                 __isl_take isl_union_map *umap2);
7800 The list passed to C<isl_set_list_union> needs to have
7801 at least one element and all elements need to live in the same space.
7803 =item * Set difference
7805         #include <isl/set.h>
7806         __isl_give isl_set *isl_set_subtract(
7807                 __isl_take isl_set *set1,
7808                 __isl_take isl_set *set2);
7810         #include <isl/map.h>
7811         __isl_give isl_map *isl_map_subtract(
7812                 __isl_take isl_map *map1,
7813                 __isl_take isl_map *map2);
7814         __isl_give isl_map *isl_map_subtract_domain(
7815                 __isl_take isl_map *map,
7816                 __isl_take isl_set *dom);
7817         __isl_give isl_map *isl_map_subtract_range(
7818                 __isl_take isl_map *map,
7819                 __isl_take isl_set *dom);
7821         #include <isl/union_set.h>
7822         __isl_give isl_union_set *isl_union_set_subtract(
7823                 __isl_take isl_union_set *uset1,
7824                 __isl_take isl_union_set *uset2);
7826         #include <isl/union_map.h>
7827         __isl_give isl_union_map *isl_union_map_subtract(
7828                 __isl_take isl_union_map *umap1,
7829                 __isl_take isl_union_map *umap2);
7830         __isl_give isl_union_map *isl_union_map_subtract_domain(
7831                 __isl_take isl_union_map *umap,
7832                 __isl_take isl_union_set *dom);
7833         __isl_give isl_union_map *isl_union_map_subtract_range(
7834                 __isl_take isl_union_map *umap,
7835                 __isl_take isl_union_set *dom);
7837         #include <isl/aff.h>
7838         __isl_give isl_pw_aff *isl_pw_aff_subtract_domain(
7839                 __isl_take isl_pw_aff *pa,
7840                 __isl_take isl_set *set);
7841         __isl_give isl_pw_multi_aff *
7842         isl_pw_multi_aff_subtract_domain(
7843                 __isl_take isl_pw_multi_aff *pma,
7844                 __isl_take isl_set *set);
7845         __isl_give isl_union_pw_aff *
7846         isl_union_pw_aff_subtract_domain_union_set(
7847                 __isl_take isl_union_pw_aff *upa,
7848                 __isl_take isl_union_set *uset);
7849         __isl_give isl_union_pw_aff *
7850         isl_union_pw_aff_subtract_domain_space(
7851                 __isl_take isl_union_pw_aff *upa,
7852                 __isl_take isl_space *space);
7853         __isl_give isl_union_pw_aff *
7854         isl_union_pw_aff_subtract_domain(
7855                 __isl_take isl_union_pw_aff *upa,
7856                 __isl_take isl_union_set *uset);
7857         __isl_give isl_union_pw_multi_aff *
7858         isl_union_pw_multi_aff_subtract_domain_union_set(
7859                 __isl_take isl_union_pw_multi_aff *upma,
7860                 __isl_take isl_set *set);
7861         __isl_give isl_union_pw_multi_aff *
7862         isl_union_pw_multi_aff_subtract_domain_space(
7863                 __isl_take isl_union_pw_multi_aff *upma,
7864                 __isl_take isl_space *space);
7865         __isl_give isl_union_pw_multi_aff *
7866         isl_union_pw_multi_aff_subtract_domain(
7867                 __isl_take isl_union_pw_multi_aff *upma,
7868                 __isl_take isl_union_set *uset);
7870         #include <isl/polynomial.h>
7871         __isl_give isl_pw_qpolynomial *
7872         isl_pw_qpolynomial_subtract_domain(
7873                 __isl_take isl_pw_qpolynomial *pwpq,
7874                 __isl_take isl_set *set);
7875         __isl_give isl_pw_qpolynomial_fold *
7876         isl_pw_qpolynomial_fold_subtract_domain(
7877                 __isl_take isl_pw_qpolynomial_fold *pwf,
7878                 __isl_take isl_set *set);
7879         __isl_give isl_union_pw_qpolynomial *
7880         isl_union_pw_qpolynomial_subtract_domain_union_set(
7881                 __isl_take isl_union_pw_qpolynomial *upwpq,
7882                 __isl_take isl_union_set *uset);
7883         __isl_give isl_union_pw_qpolynomial *
7884         isl_union_pw_qpolynomial_subtract_domain_space(
7885                 __isl_take isl_union_pw_qpolynomial *upwpq,
7886                 __isl_take isl_space *space);
7887         __isl_give isl_union_pw_qpolynomial *
7888         isl_union_pw_qpolynomial_subtract_domain(
7889                 __isl_take isl_union_pw_qpolynomial *upwpq,
7890                 __isl_take isl_union_set *uset);
7891         __isl_give isl_union_pw_qpolynomial_fold *
7892         isl_union_pw_qpolynomial_fold_subtract_domain_union_set(
7893                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
7894                 __isl_take isl_union_set *uset);
7895         __isl_give isl_union_pw_qpolynomial_fold *
7896         isl_union_pw_qpolynomial_fold_subtract_domain_space(
7897                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
7898                 __isl_take isl_space *space);
7899         __isl_give isl_union_pw_qpolynomial_fold *
7900         isl_union_pw_qpolynomial_fold_subtract_domain(
7901                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
7902                 __isl_take isl_union_set *uset);
7904 C<isl_union_pw_aff_subtract_domain> is an alternative name for
7905 C<isl_union_pw_aff_subtract_domain_union_set>.
7906 Similarly for the other pairs of functions.
7908 =item * Application
7910         #include <isl/space.h>
7911         __isl_give isl_space *isl_space_join(
7912                 __isl_take isl_space *left,
7913                 __isl_take isl_space *right);
7915         #include <isl/set.h>
7916         __isl_give isl_basic_set *isl_basic_set_apply(
7917                 __isl_take isl_basic_set *bset,
7918                 __isl_take isl_basic_map *bmap);
7919         __isl_give isl_set *isl_set_apply(
7920                 __isl_take isl_set *set,
7921                 __isl_take isl_map *map);
7923         #include <isl/union_set.h>
7924         __isl_give isl_union_set *isl_union_set_apply(
7925                 __isl_take isl_union_set *uset,
7926                 __isl_take isl_union_map *umap);
7928         #include <isl/map.h>
7929         __isl_give isl_basic_map *isl_basic_map_apply_domain(
7930                 __isl_take isl_basic_map *bmap1,
7931                 __isl_take isl_basic_map *bmap2);
7932         __isl_give isl_basic_map *isl_basic_map_apply_range(
7933                 __isl_take isl_basic_map *bmap1,
7934                 __isl_take isl_basic_map *bmap2);
7935         __isl_give isl_map *isl_map_apply_domain(
7936                 __isl_take isl_map *map1,
7937                 __isl_take isl_map *map2);
7938         __isl_give isl_map *isl_map_apply_range(
7939                 __isl_take isl_map *map1,
7940                 __isl_take isl_map *map2);
7942         #include <isl/union_map.h>
7943         __isl_give isl_union_map *isl_union_map_apply_domain(
7944                 __isl_take isl_union_map *umap1,
7945                 __isl_take isl_union_map *umap2);
7946         __isl_give isl_union_map *isl_union_map_apply_range(
7947                 __isl_take isl_union_map *umap1,
7948                 __isl_take isl_union_map *umap2);
7950         #include <isl/aff.h>
7951         __isl_give isl_union_pw_multi_aff *
7952         isl_union_pw_multi_aff_apply_union_pw_multi_aff(
7953                 __isl_take isl_union_pw_multi_aff *upma1,
7954                 __isl_take isl_union_pw_multi_aff *upma2);
7955         __isl_give isl_union_pw_aff *
7956         isl_multi_union_pw_aff_apply_aff(
7957                 __isl_take isl_multi_union_pw_aff *mupa,
7958                 __isl_take isl_aff *aff);
7959         __isl_give isl_union_pw_aff *
7960         isl_multi_union_pw_aff_apply_pw_aff(
7961                 __isl_take isl_multi_union_pw_aff *mupa,
7962                 __isl_take isl_pw_aff *pa);
7963         __isl_give isl_multi_union_pw_aff *
7964         isl_multi_union_pw_aff_apply_multi_aff(
7965                 __isl_take isl_multi_union_pw_aff *mupa,
7966                 __isl_take isl_multi_aff *ma);
7967         __isl_give isl_multi_union_pw_aff *
7968         isl_multi_union_pw_aff_apply_pw_multi_aff(
7969                 __isl_take isl_multi_union_pw_aff *mupa,
7970                 __isl_take isl_pw_multi_aff *pma);
7972 The result of C<isl_multi_union_pw_aff_apply_aff> is defined
7973 over the shared domain of the elements of the input.  The dimension is
7974 required to be greater than zero.
7975 The C<isl_multi_union_pw_aff> argument of
7976 C<isl_multi_union_pw_aff_apply_multi_aff> is allowed to be zero-dimensional,
7977 but only if the range of the C<isl_multi_aff> argument
7978 is also zero-dimensional.
7979 Similarly for C<isl_multi_union_pw_aff_apply_pw_multi_aff>.
7981         #include <isl/polynomial.h>
7982         __isl_give isl_pw_qpolynomial_fold *
7983         isl_set_apply_pw_qpolynomial_fold(
7984                 __isl_take isl_set *set,
7985                 __isl_take isl_pw_qpolynomial_fold *pwf,
7986                 isl_bool *tight);
7987         __isl_give isl_pw_qpolynomial_fold *
7988         isl_map_apply_pw_qpolynomial_fold(
7989                 __isl_take isl_map *map,
7990                 __isl_take isl_pw_qpolynomial_fold *pwf,
7991                 isl_bool *tight);
7992         __isl_give isl_union_pw_qpolynomial_fold *
7993         isl_union_set_apply_union_pw_qpolynomial_fold(
7994                 __isl_take isl_union_set *uset,
7995                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
7996                 isl_bool *tight);
7997         __isl_give isl_union_pw_qpolynomial_fold *
7998         isl_union_map_apply_union_pw_qpolynomial_fold(
7999                 __isl_take isl_union_map *umap,
8000                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
8001                 isl_bool *tight);
8003 The functions taking a map
8004 compose the given map with the given piecewise quasipolynomial reduction.
8005 That is, compute a bound (of the same type as C<pwf> or C<upwf> itself)
8006 over all elements in the intersection of the range of the map
8007 and the domain of the piecewise quasipolynomial reduction
8008 as a function of an element in the domain of the map.
8009 The functions taking a set compute a bound over all elements in the
8010 intersection of the set and the domain of the
8011 piecewise quasipolynomial reduction.
8013 =item * Preimage
8015         #include <isl/set.h>
8016         __isl_give isl_basic_set *
8017         isl_basic_set_preimage_multi_aff(
8018                 __isl_take isl_basic_set *bset,
8019                 __isl_take isl_multi_aff *ma);
8020         __isl_give isl_set *isl_set_preimage_multi_aff(
8021                 __isl_take isl_set *set,
8022                 __isl_take isl_multi_aff *ma);
8023         __isl_give isl_set *isl_set_preimage_pw_multi_aff(
8024                 __isl_take isl_set *set,
8025                 __isl_take isl_pw_multi_aff *pma);
8026         __isl_give isl_set *isl_set_preimage_multi_pw_aff(
8027                 __isl_take isl_set *set,
8028                 __isl_take isl_multi_pw_aff *mpa);
8030         #include <isl/union_set.h>
8031         __isl_give isl_union_set *
8032         isl_union_set_preimage_multi_aff(
8033                 __isl_take isl_union_set *uset,
8034                 __isl_take isl_multi_aff *ma);
8035         __isl_give isl_union_set *
8036         isl_union_set_preimage_pw_multi_aff(
8037                 __isl_take isl_union_set *uset,
8038                 __isl_take isl_pw_multi_aff *pma);
8039         __isl_give isl_union_set *
8040         isl_union_set_preimage_union_pw_multi_aff(
8041                 __isl_take isl_union_set *uset,
8042                 __isl_take isl_union_pw_multi_aff *upma);
8044         #include <isl/map.h>
8045         __isl_give isl_basic_map *
8046         isl_basic_map_preimage_domain_multi_aff(
8047                 __isl_take isl_basic_map *bmap,
8048                 __isl_take isl_multi_aff *ma);
8049         __isl_give isl_map *isl_map_preimage_domain_multi_aff(
8050                 __isl_take isl_map *map,
8051                 __isl_take isl_multi_aff *ma);
8052         __isl_give isl_map *isl_map_preimage_range_multi_aff(
8053                 __isl_take isl_map *map,
8054                 __isl_take isl_multi_aff *ma);
8055         __isl_give isl_map *
8056         isl_map_preimage_domain_pw_multi_aff(
8057                 __isl_take isl_map *map,
8058                 __isl_take isl_pw_multi_aff *pma);
8059         __isl_give isl_map *
8060         isl_map_preimage_range_pw_multi_aff(
8061                 __isl_take isl_map *map,
8062                 __isl_take isl_pw_multi_aff *pma);
8063         __isl_give isl_map *
8064         isl_map_preimage_domain_multi_pw_aff(
8065                 __isl_take isl_map *map,
8066                 __isl_take isl_multi_pw_aff *mpa);
8067         __isl_give isl_basic_map *
8068         isl_basic_map_preimage_range_multi_aff(
8069                 __isl_take isl_basic_map *bmap,
8070                 __isl_take isl_multi_aff *ma);
8072         #include <isl/union_map.h>
8073         __isl_give isl_union_map *
8074         isl_union_map_preimage_domain_multi_aff(
8075                 __isl_take isl_union_map *umap,
8076                 __isl_take isl_multi_aff *ma);
8077         __isl_give isl_union_map *
8078         isl_union_map_preimage_range_multi_aff(
8079                 __isl_take isl_union_map *umap,
8080                 __isl_take isl_multi_aff *ma);
8081         __isl_give isl_union_map *
8082         isl_union_map_preimage_domain_pw_multi_aff(
8083                 __isl_take isl_union_map *umap,
8084                 __isl_take isl_pw_multi_aff *pma);
8085         __isl_give isl_union_map *
8086         isl_union_map_preimage_range_pw_multi_aff(
8087                 __isl_take isl_union_map *umap,
8088                 __isl_take isl_pw_multi_aff *pma);
8089         __isl_give isl_union_map *
8090         isl_union_map_preimage_domain_union_pw_multi_aff(
8091                 __isl_take isl_union_map *umap,
8092                 __isl_take isl_union_pw_multi_aff *upma);
8093         __isl_give isl_union_map *
8094         isl_union_map_preimage_range_union_pw_multi_aff(
8095                 __isl_take isl_union_map *umap,
8096                 __isl_take isl_union_pw_multi_aff *upma);
8098         #include <isl/aff.h>
8099         __isl_give isl_pw_multi_aff *
8100         isl_pw_multi_aff_preimage_domain_wrapped_domain_pw_multi_aff(
8101                 __isl_take isl_pw_multi_aff *pma1,
8102                 __isl_take isl_pw_multi_aff *pma2);
8103         __isl_give isl_union_pw_multi_aff *
8104         isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff(
8105                 __isl_take isl_union_pw_multi_aff *upma1,
8106                 __isl_take isl_union_pw_multi_aff *upma2);
8108 These functions compute the preimage of the given set or map domain/range under
8109 the given function.  In other words, the expression is plugged
8110 into the set description or into the domain/range of the map or function.
8112 =item * Pullback
8114         #include <isl/aff.h>
8115         __isl_give isl_aff *isl_aff_pullback_aff(
8116                 __isl_take isl_aff *aff1,
8117                 __isl_take isl_aff *aff2);
8118         __isl_give isl_aff *isl_aff_pullback_multi_aff(
8119                 __isl_take isl_aff *aff,
8120                 __isl_take isl_multi_aff *ma);
8121         __isl_give isl_pw_aff *isl_pw_aff_pullback_multi_aff(
8122                 __isl_take isl_pw_aff *pa,
8123                 __isl_take isl_multi_aff *ma);
8124         __isl_give isl_pw_aff *isl_pw_aff_pullback_pw_multi_aff(
8125                 __isl_take isl_pw_aff *pa,
8126                 __isl_take isl_pw_multi_aff *pma);
8127         __isl_give isl_pw_aff *isl_pw_aff_pullback_multi_pw_aff(
8128                 __isl_take isl_pw_aff *pa,
8129                 __isl_take isl_multi_pw_aff *mpa);
8130         __isl_give isl_multi_aff *isl_multi_aff_pullback_multi_aff(
8131                 __isl_take isl_multi_aff *ma1,
8132                 __isl_take isl_multi_aff *ma2);
8133         __isl_give isl_pw_multi_aff *
8134         isl_pw_multi_aff_pullback_multi_aff(
8135                 __isl_take isl_pw_multi_aff *pma,
8136                 __isl_take isl_multi_aff *ma);
8137         __isl_give isl_multi_pw_aff *
8138         isl_multi_pw_aff_pullback_multi_aff(
8139                 __isl_take isl_multi_pw_aff *mpa,
8140                 __isl_take isl_multi_aff *ma);
8141         __isl_give isl_pw_multi_aff *
8142         isl_pw_multi_aff_pullback_pw_multi_aff(
8143                 __isl_take isl_pw_multi_aff *pma1,
8144                 __isl_take isl_pw_multi_aff *pma2);
8145         __isl_give isl_multi_pw_aff *
8146         isl_multi_pw_aff_pullback_pw_multi_aff(
8147                 __isl_take isl_multi_pw_aff *mpa,
8148                 __isl_take isl_pw_multi_aff *pma);
8149         __isl_give isl_multi_pw_aff *
8150         isl_multi_pw_aff_pullback_multi_pw_aff(
8151                 __isl_take isl_multi_pw_aff *mpa1,
8152                 __isl_take isl_multi_pw_aff *mpa2);
8153         __isl_give isl_union_pw_aff *
8154         isl_union_pw_aff_pullback_union_pw_multi_aff(
8155                 __isl_take isl_union_pw_aff *upa,
8156                 __isl_take isl_union_pw_multi_aff *upma);
8157         __isl_give isl_union_pw_multi_aff *
8158         isl_union_pw_multi_aff_pullback_union_pw_multi_aff(
8159                 __isl_take isl_union_pw_multi_aff *upma1,
8160                 __isl_take isl_union_pw_multi_aff *upma2);
8161         __isl_give isl_multi_union_pw_aff *
8162         isl_multi_union_pw_aff_pullback_union_pw_multi_aff(
8163                 __isl_take isl_multi_union_pw_aff *mupa,
8164                 __isl_take isl_union_pw_multi_aff *upma);
8166 These functions precompose the first expression by the second function.
8167 In other words, the second function is plugged
8168 into the first expression.
8170 =item * Locus
8172         #include <isl/aff.h>
8173         __isl_give isl_basic_set *isl_aff_eq_basic_set(
8174                 __isl_take isl_aff *aff1,
8175                 __isl_take isl_aff *aff2);
8176         __isl_give isl_set *isl_aff_eq_set(
8177                 __isl_take isl_aff *aff1,
8178                 __isl_take isl_aff *aff2);
8179         __isl_give isl_set *isl_aff_ne_set(
8180                 __isl_take isl_aff *aff1,
8181                 __isl_take isl_aff *aff2);
8182         __isl_give isl_basic_set *isl_aff_le_basic_set(
8183                 __isl_take isl_aff *aff1,
8184                 __isl_take isl_aff *aff2);
8185         __isl_give isl_set *isl_aff_le_set(
8186                 __isl_take isl_aff *aff1,
8187                 __isl_take isl_aff *aff2);
8188         __isl_give isl_basic_set *isl_aff_lt_basic_set(
8189                 __isl_take isl_aff *aff1,
8190                 __isl_take isl_aff *aff2);
8191         __isl_give isl_set *isl_aff_lt_set(
8192                 __isl_take isl_aff *aff1,
8193                 __isl_take isl_aff *aff2);
8194         __isl_give isl_basic_set *isl_aff_ge_basic_set(
8195                 __isl_take isl_aff *aff1,
8196                 __isl_take isl_aff *aff2);
8197         __isl_give isl_set *isl_aff_ge_set(
8198                 __isl_take isl_aff *aff1,
8199                 __isl_take isl_aff *aff2);
8200         __isl_give isl_basic_set *isl_aff_gt_basic_set(
8201                 __isl_take isl_aff *aff1,
8202                 __isl_take isl_aff *aff2);
8203         __isl_give isl_set *isl_aff_gt_set(
8204                 __isl_take isl_aff *aff1,
8205                 __isl_take isl_aff *aff2);
8206         __isl_give isl_set *isl_pw_aff_eq_set(
8207                 __isl_take isl_pw_aff *pwaff1,
8208                 __isl_take isl_pw_aff *pwaff2);
8209         __isl_give isl_set *isl_pw_aff_ne_set(
8210                 __isl_take isl_pw_aff *pwaff1,
8211                 __isl_take isl_pw_aff *pwaff2);
8212         __isl_give isl_set *isl_pw_aff_le_set(
8213                 __isl_take isl_pw_aff *pwaff1,
8214                 __isl_take isl_pw_aff *pwaff2);
8215         __isl_give isl_set *isl_pw_aff_lt_set(
8216                 __isl_take isl_pw_aff *pwaff1,
8217                 __isl_take isl_pw_aff *pwaff2);
8218         __isl_give isl_set *isl_pw_aff_ge_set(
8219                 __isl_take isl_pw_aff *pwaff1,
8220                 __isl_take isl_pw_aff *pwaff2);
8221         __isl_give isl_set *isl_pw_aff_gt_set(
8222                 __isl_take isl_pw_aff *pwaff1,
8223                 __isl_take isl_pw_aff *pwaff2);
8225         __isl_give isl_set *isl_multi_aff_lex_le_set(
8226                 __isl_take isl_multi_aff *ma1,
8227                 __isl_take isl_multi_aff *ma2);
8228         __isl_give isl_set *isl_multi_aff_lex_lt_set(
8229                 __isl_take isl_multi_aff *ma1,
8230                 __isl_take isl_multi_aff *ma2);
8231         __isl_give isl_set *isl_multi_aff_lex_ge_set(
8232                 __isl_take isl_multi_aff *ma1,
8233                 __isl_take isl_multi_aff *ma2);
8234         __isl_give isl_set *isl_multi_aff_lex_gt_set(
8235                 __isl_take isl_multi_aff *ma1,
8236                 __isl_take isl_multi_aff *ma2);
8238         __isl_give isl_set *isl_pw_aff_list_eq_set(
8239                 __isl_take isl_pw_aff_list *list1,
8240                 __isl_take isl_pw_aff_list *list2);
8241         __isl_give isl_set *isl_pw_aff_list_ne_set(
8242                 __isl_take isl_pw_aff_list *list1,
8243                 __isl_take isl_pw_aff_list *list2);
8244         __isl_give isl_set *isl_pw_aff_list_le_set(
8245                 __isl_take isl_pw_aff_list *list1,
8246                 __isl_take isl_pw_aff_list *list2);
8247         __isl_give isl_set *isl_pw_aff_list_lt_set(
8248                 __isl_take isl_pw_aff_list *list1,
8249                 __isl_take isl_pw_aff_list *list2);
8250         __isl_give isl_set *isl_pw_aff_list_ge_set(
8251                 __isl_take isl_pw_aff_list *list1,
8252                 __isl_take isl_pw_aff_list *list2);
8253         __isl_give isl_set *isl_pw_aff_list_gt_set(
8254                 __isl_take isl_pw_aff_list *list1,
8255                 __isl_take isl_pw_aff_list *list2);
8257 The function C<isl_aff_ge_basic_set> returns a basic set
8258 containing those elements in the shared space
8259 of C<aff1> and C<aff2> where C<aff1> is greater than or equal to C<aff2>.
8260 The function C<isl_pw_aff_ge_set> returns a set
8261 containing those elements in the shared domain
8262 of C<pwaff1> and C<pwaff2> where C<pwaff1> is
8263 greater than or equal to C<pwaff2>.
8264 The function C<isl_multi_aff_lex_le_set> returns a set
8265 containing those elements in the shared domain space
8266 where C<ma1> is lexicographically smaller than or
8267 equal to C<ma2>.
8268 The functions operating on C<isl_pw_aff_list> apply the corresponding
8269 C<isl_pw_aff> function to each pair of elements in the two lists.
8271         #include <isl/aff.h>
8272         __isl_give isl_map *isl_pw_aff_eq_map(
8273                 __isl_take isl_pw_aff *pa1,
8274                 __isl_take isl_pw_aff *pa2);
8275         __isl_give isl_map *isl_pw_aff_le_map(
8276                 __isl_take isl_pw_aff *pa1,
8277                 __isl_take isl_pw_aff *pa2);
8278         __isl_give isl_map *isl_pw_aff_lt_map(
8279                 __isl_take isl_pw_aff *pa1,
8280                 __isl_take isl_pw_aff *pa2);
8281         __isl_give isl_map *isl_pw_aff_ge_map(
8282                 __isl_take isl_pw_aff *pa1,
8283                 __isl_take isl_pw_aff *pa2);
8284         __isl_give isl_map *isl_pw_aff_gt_map(
8285                 __isl_take isl_pw_aff *pa1,
8286                 __isl_take isl_pw_aff *pa2);
8288         __isl_give isl_map *isl_multi_pw_aff_eq_map(
8289                 __isl_take isl_multi_pw_aff *mpa1,
8290                 __isl_take isl_multi_pw_aff *mpa2);
8291         __isl_give isl_map *isl_multi_pw_aff_lex_le_map(
8292                 __isl_take isl_multi_pw_aff *mpa1,
8293                 __isl_take isl_multi_pw_aff *mpa2);
8294         __isl_give isl_map *isl_multi_pw_aff_lex_lt_map(
8295                 __isl_take isl_multi_pw_aff *mpa1,
8296                 __isl_take isl_multi_pw_aff *mpa2);
8297         __isl_give isl_map *isl_multi_pw_aff_lex_ge_map(
8298                 __isl_take isl_multi_pw_aff *mpa1,
8299                 __isl_take isl_multi_pw_aff *mpa2);
8300         __isl_give isl_map *isl_multi_pw_aff_lex_gt_map(
8301                 __isl_take isl_multi_pw_aff *mpa1,
8302                 __isl_take isl_multi_pw_aff *mpa2);
8304 These functions return a map between domain elements of the arguments
8305 where the function values satisfy the given relation.
8307         #include <isl/map.h>
8308         __isl_give isl_map *isl_map_eq_at_multi_pw_aff(
8309                 __isl_take isl_map *map,
8310                 __isl_take isl_multi_pw_aff *mpa);
8311         __isl_give isl_map *isl_map_lex_lt_at_multi_pw_aff(
8312                 __isl_take isl_map *map,
8313                 __isl_take isl_multi_pw_aff *mpa);
8314         __isl_give isl_map *isl_map_lex_le_at_multi_pw_aff(
8315                 __isl_take isl_map *map,
8316                 __isl_take isl_multi_pw_aff *mpa);
8317         __isl_give isl_map *isl_map_lex_gt_at_multi_pw_aff(
8318                 __isl_take isl_map *map,
8319                 __isl_take isl_multi_pw_aff *mpa);
8320         __isl_give isl_map *isl_map_lex_ge_at_multi_pw_aff(
8321                 __isl_take isl_map *map,
8322                 __isl_take isl_multi_pw_aff *mpa);
8324         #include <isl/union_map.h>
8325         __isl_give isl_union_map *
8326         isl_union_map_eq_at_multi_union_pw_aff(
8327                 __isl_take isl_union_map *umap,
8328                 __isl_take isl_multi_union_pw_aff *mupa);
8329         __isl_give isl_union_map *
8330         isl_union_map_lex_lt_at_multi_union_pw_aff(
8331                 __isl_take isl_union_map *umap,
8332                 __isl_take isl_multi_union_pw_aff *mupa);
8333         __isl_give isl_union_map *
8334         isl_union_map_lex_le_at_multi_union_pw_aff(
8335                 __isl_take isl_union_map *umap,
8336                 __isl_take isl_multi_union_pw_aff *mupa);
8337         __isl_give isl_union_map *
8338         isl_union_map_lex_gt_at_multi_union_pw_aff(
8339                 __isl_take isl_union_map *umap,
8340                 __isl_take isl_multi_union_pw_aff *mupa);
8341         __isl_give isl_union_map *
8342         isl_union_map_lex_ge_at_multi_union_pw_aff(
8343                 __isl_take isl_union_map *umap,
8344                 __isl_take isl_multi_union_pw_aff *mupa);
8346 These functions select the subset of elements in the union map
8347 that have an equal or lexicographically smaller or greater function value.
8349 =item * Cartesian Product
8351         #include <isl/space.h>
8352         __isl_give isl_space *isl_space_product(
8353                 __isl_take isl_space *space1,
8354                 __isl_take isl_space *space2);
8355         __isl_give isl_space *isl_space_domain_product(
8356                 __isl_take isl_space *space1,
8357                 __isl_take isl_space *space2);
8358         __isl_give isl_space *isl_space_range_product(
8359                 __isl_take isl_space *space1,
8360                 __isl_take isl_space *space2);
8362 The functions
8363 C<isl_space_product>, C<isl_space_domain_product>
8364 and C<isl_space_range_product> take pairs or relation spaces and
8365 produce a single relations space, where either the domain, the range
8366 or both domain and range are wrapped spaces of relations between
8367 the domains and/or ranges of the input spaces.
8368 If the product is only constructed over the domain or the range
8369 then the ranges or the domains of the inputs should be the same.
8370 The function C<isl_space_product> also accepts a pair of set spaces,
8371 in which case it returns a wrapped space of a relation between the
8372 two input spaces.
8374         #include <isl/set.h>
8375         __isl_give isl_set *isl_set_product(
8376                 __isl_take isl_set *set1,
8377                 __isl_take isl_set *set2);
8379         #include <isl/map.h>
8380         __isl_give isl_basic_map *isl_basic_map_domain_product(
8381                 __isl_take isl_basic_map *bmap1,
8382                 __isl_take isl_basic_map *bmap2);
8383         __isl_give isl_basic_map *isl_basic_map_range_product(
8384                 __isl_take isl_basic_map *bmap1,
8385                 __isl_take isl_basic_map *bmap2);
8386         __isl_give isl_basic_map *isl_basic_map_product(
8387                 __isl_take isl_basic_map *bmap1,
8388                 __isl_take isl_basic_map *bmap2);
8389         __isl_give isl_map *isl_map_domain_product(
8390                 __isl_take isl_map *map1,
8391                 __isl_take isl_map *map2);
8392         __isl_give isl_map *isl_map_range_product(
8393                 __isl_take isl_map *map1,
8394                 __isl_take isl_map *map2);
8395         __isl_give isl_map *isl_map_product(
8396                 __isl_take isl_map *map1,
8397                 __isl_take isl_map *map2);
8399         #include <isl/union_set.h>
8400         __isl_give isl_union_set *isl_union_set_product(
8401                 __isl_take isl_union_set *uset1,
8402                 __isl_take isl_union_set *uset2);
8404         #include <isl/union_map.h>
8405         __isl_give isl_union_map *isl_union_map_domain_product(
8406                 __isl_take isl_union_map *umap1,
8407                 __isl_take isl_union_map *umap2);
8408         __isl_give isl_union_map *isl_union_map_range_product(
8409                 __isl_take isl_union_map *umap1,
8410                 __isl_take isl_union_map *umap2);
8411         __isl_give isl_union_map *isl_union_map_product(
8412                 __isl_take isl_union_map *umap1,
8413                 __isl_take isl_union_map *umap2);
8415         #include <isl/id.h>
8416         __isl_give isl_multi_id *isl_multi_id_range_product(
8417                 __isl_take isl_multi_id *mi1,
8418                 __isl_take isl_multi_id *mi2);
8420         #include <isl/val.h>
8421         __isl_give isl_multi_val *isl_multi_val_range_product(
8422                 __isl_take isl_multi_val *mv1,
8423                 __isl_take isl_multi_val *mv2);
8424         __isl_give isl_multi_val *isl_multi_val_product(
8425                 __isl_take isl_multi_val *mv1,
8426                 __isl_take isl_multi_val *mv2);
8428         #include <isl/aff.h>
8429         __isl_give isl_multi_aff *isl_multi_aff_range_product(
8430                 __isl_take isl_multi_aff *ma1,
8431                 __isl_take isl_multi_aff *ma2);
8432         __isl_give isl_multi_aff *isl_multi_aff_product(
8433                 __isl_take isl_multi_aff *ma1,
8434                 __isl_take isl_multi_aff *ma2);
8435         __isl_give isl_multi_pw_aff *
8436         isl_multi_pw_aff_range_product(
8437                 __isl_take isl_multi_pw_aff *mpa1,
8438                 __isl_take isl_multi_pw_aff *mpa2);
8439         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_product(
8440                 __isl_take isl_multi_pw_aff *mpa1,
8441                 __isl_take isl_multi_pw_aff *mpa2);
8442         __isl_give isl_pw_multi_aff *
8443         isl_pw_multi_aff_range_product(
8444                 __isl_take isl_pw_multi_aff *pma1,
8445                 __isl_take isl_pw_multi_aff *pma2);
8446         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_product(
8447                 __isl_take isl_pw_multi_aff *pma1,
8448                 __isl_take isl_pw_multi_aff *pma2);
8449         __isl_give isl_union_pw_multi_aff *
8450         isl_union_pw_multi_aff_range_product(
8451                 __isl_take isl_union_pw_multi_aff *upma1,
8452                 __isl_take isl_union_pw_multi_aff *upma2);
8453         __isl_give isl_multi_union_pw_aff *
8454         isl_multi_union_pw_aff_range_product(
8455                 __isl_take isl_multi_union_pw_aff *mupa1,
8456                 __isl_take isl_multi_union_pw_aff *mupa2);
8458 The above functions compute the cross product of the given
8459 sets, relations or functions.  The domains and ranges of the results
8460 are wrapped maps between domains and ranges of the inputs.
8461 To obtain a ``flat'' product, use the following functions
8462 instead.
8464         #include <isl/set.h>
8465         __isl_give isl_basic_set *isl_basic_set_flat_product(
8466                 __isl_take isl_basic_set *bset1,
8467                 __isl_take isl_basic_set *bset2);
8468         __isl_give isl_set *isl_set_flat_product(
8469                 __isl_take isl_set *set1,
8470                 __isl_take isl_set *set2);
8472         #include <isl/map.h>
8473         __isl_give isl_basic_map *isl_basic_map_flat_range_product(
8474                 __isl_take isl_basic_map *bmap1,
8475                 __isl_take isl_basic_map *bmap2);
8476         __isl_give isl_map *isl_map_flat_domain_product(
8477                 __isl_take isl_map *map1,
8478                 __isl_take isl_map *map2);
8479         __isl_give isl_map *isl_map_flat_range_product(
8480                 __isl_take isl_map *map1,
8481                 __isl_take isl_map *map2);
8482         __isl_give isl_basic_map *isl_basic_map_flat_product(
8483                 __isl_take isl_basic_map *bmap1,
8484                 __isl_take isl_basic_map *bmap2);
8485         __isl_give isl_map *isl_map_flat_product(
8486                 __isl_take isl_map *map1,
8487                 __isl_take isl_map *map2);
8489         #include <isl/union_map.h>
8490         __isl_give isl_union_map *
8491         isl_union_map_flat_domain_product(
8492                 __isl_take isl_union_map *umap1,
8493                 __isl_take isl_union_map *umap2);
8494         __isl_give isl_union_map *
8495         isl_union_map_flat_range_product(
8496                 __isl_take isl_union_map *umap1,
8497                 __isl_take isl_union_map *umap2);
8499         #include <isl/id.h>
8500         __isl_give isl_multi_id *
8501         isl_multi_id_flat_range_product(
8502                 __isl_take isl_multi_id *mi1,
8503                 __isl_take isl_multi_id *mi2);
8505         #include <isl/val.h>
8506         __isl_give isl_multi_val *isl_multi_val_flat_range_product(
8507                 __isl_take isl_multi_val *mv1,
8508                 __isl_take isl_multi_val *mv2);
8510         #include <isl/aff.h>
8511         __isl_give isl_multi_aff *isl_multi_aff_flat_range_product(
8512                 __isl_take isl_multi_aff *ma1,
8513                 __isl_take isl_multi_aff *ma2);
8514         __isl_give isl_pw_multi_aff *
8515         isl_pw_multi_aff_flat_range_product(
8516                 __isl_take isl_pw_multi_aff *pma1,
8517                 __isl_take isl_pw_multi_aff *pma2);
8518         __isl_give isl_multi_pw_aff *
8519         isl_multi_pw_aff_flat_range_product(
8520                 __isl_take isl_multi_pw_aff *mpa1,
8521                 __isl_take isl_multi_pw_aff *mpa2);
8522         __isl_give isl_union_pw_multi_aff *
8523         isl_union_pw_multi_aff_flat_range_product(
8524                 __isl_take isl_union_pw_multi_aff *upma1,
8525                 __isl_take isl_union_pw_multi_aff *upma2);
8526         __isl_give isl_multi_union_pw_aff *
8527         isl_multi_union_pw_aff_flat_range_product(
8528                 __isl_take isl_multi_union_pw_aff *mupa1,
8529                 __isl_take isl_multi_union_pw_aff *mupa2);
8531         #include <isl/space.h>
8532         __isl_give isl_space *isl_space_factor_domain(
8533                 __isl_take isl_space *space);
8534         __isl_give isl_space *isl_space_factor_range(
8535                 __isl_take isl_space *space);
8536         __isl_give isl_space *isl_space_domain_factor_domain(
8537                 __isl_take isl_space *space);
8538         __isl_give isl_space *isl_space_domain_factor_range(
8539                 __isl_take isl_space *space);
8540         __isl_give isl_space *isl_space_range_factor_domain(
8541                 __isl_take isl_space *space);
8542         __isl_give isl_space *isl_space_range_factor_range(
8543                 __isl_take isl_space *space);
8545 The functions C<isl_space_range_factor_domain> and
8546 C<isl_space_range_factor_range> extract the two arguments from
8547 the result of a call to C<isl_space_range_product>.
8549 The arguments of a call to a product can be extracted
8550 from the result using the following functions.
8552         #include <isl/map.h>
8553         __isl_give isl_map *isl_map_factor_domain(
8554                 __isl_take isl_map *map);
8555         __isl_give isl_map *isl_map_factor_range(
8556                 __isl_take isl_map *map);
8557         __isl_give isl_map *isl_map_domain_factor_domain(
8558                 __isl_take isl_map *map);
8559         __isl_give isl_map *isl_map_domain_factor_range(
8560                 __isl_take isl_map *map);
8561         __isl_give isl_map *isl_map_range_factor_domain(
8562                 __isl_take isl_map *map);
8563         __isl_give isl_map *isl_map_range_factor_range(
8564                 __isl_take isl_map *map);
8566         #include <isl/union_map.h>
8567         __isl_give isl_union_map *isl_union_map_factor_domain(
8568                 __isl_take isl_union_map *umap);
8569         __isl_give isl_union_map *isl_union_map_factor_range(
8570                 __isl_take isl_union_map *umap);
8571         __isl_give isl_union_map *
8572         isl_union_map_domain_factor_domain(
8573                 __isl_take isl_union_map *umap);
8574         __isl_give isl_union_map *
8575         isl_union_map_domain_factor_range(
8576                 __isl_take isl_union_map *umap);
8577         __isl_give isl_union_map *
8578         isl_union_map_range_factor_domain(
8579                 __isl_take isl_union_map *umap);
8580         __isl_give isl_union_map *
8581         isl_union_map_range_factor_range(
8582                 __isl_take isl_union_map *umap);
8584         #include <isl/id.h>
8585         __isl_give isl_multi_id *isl_multi_id_factor_range(
8586                 __isl_take isl_multi_id *mi);
8587         __isl_give isl_multi_id *
8588         isl_multi_id_range_factor_domain(
8589                 __isl_take isl_multi_id *mi);
8590         __isl_give isl_multi_id *
8591         isl_multi_id_range_factor_range(
8592                 __isl_take isl_multi_id *mi);
8594         #include <isl/val.h>
8595         __isl_give isl_multi_val *isl_multi_val_factor_range(
8596                 __isl_take isl_multi_val *mv);
8597         __isl_give isl_multi_val *
8598         isl_multi_val_range_factor_domain(
8599                 __isl_take isl_multi_val *mv);
8600         __isl_give isl_multi_val *
8601         isl_multi_val_range_factor_range(
8602                 __isl_take isl_multi_val *mv);
8604         #include <isl/aff.h>
8605         __isl_give isl_multi_aff *isl_multi_aff_factor_range(
8606                 __isl_take isl_multi_aff *ma);
8607         __isl_give isl_multi_aff *
8608         isl_multi_aff_range_factor_domain(
8609                 __isl_take isl_multi_aff *ma);
8610         __isl_give isl_multi_aff *
8611         isl_multi_aff_range_factor_range(
8612                 __isl_take isl_multi_aff *ma);
8613         __isl_give isl_multi_pw_aff *
8614         isl_multi_pw_aff_factor_range(
8615                 __isl_take isl_multi_pw_aff *mpa);
8616         __isl_give isl_multi_pw_aff *
8617         isl_multi_pw_aff_range_factor_domain(
8618                 __isl_take isl_multi_pw_aff *mpa);
8619         __isl_give isl_multi_pw_aff *
8620         isl_multi_pw_aff_range_factor_range(
8621                 __isl_take isl_multi_pw_aff *mpa);
8622         __isl_give isl_pw_multi_aff *
8623         isl_pw_multi_aff_range_factor_domain(
8624                 __isl_take isl_pw_multi_aff *pma);
8625         __isl_give isl_pw_multi_aff *
8626         isl_pw_multi_aff_range_factor_range(
8627                 __isl_take isl_pw_multi_aff *pma);
8628         __isl_give isl_union_pw_multi_aff *
8629         isl_union_pw_multi_aff_range_factor_domain(
8630                 __isl_take isl_union_pw_multi_aff *upma);
8631         __isl_give isl_union_pw_multi_aff *
8632         isl_union_pw_multi_aff_range_factor_range(
8633                 __isl_take isl_union_pw_multi_aff *upma);
8634         __isl_give isl_multi_union_pw_aff *
8635         isl_multi_union_pw_aff_factor_range(
8636                 __isl_take isl_multi_union_pw_aff *mupa);
8637         __isl_give isl_multi_union_pw_aff *
8638         isl_multi_union_pw_aff_range_factor_domain(
8639                 __isl_take isl_multi_union_pw_aff *mupa);
8640         __isl_give isl_multi_union_pw_aff *
8641         isl_multi_union_pw_aff_range_factor_range(
8642                 __isl_take isl_multi_union_pw_aff *mupa);
8644 The splice functions are a generalization of the flat product functions,
8645 where the second argument may be inserted at any position inside
8646 the first argument rather than being placed at the end.
8647 The functions C<isl_multi_val_factor_range>,
8648 C<isl_multi_aff_factor_range>,
8649 C<isl_multi_pw_aff_factor_range> and
8650 C<isl_multi_union_pw_aff_factor_range>
8651 take functions that live in a set space.
8653         #include <isl/id.h>
8654         __isl_give isl_multi_id *isl_multi_id_range_splice(
8655                 __isl_take isl_multi_id *mi1, unsigned pos,
8656                 __isl_take isl_multi_id *mi2);
8658         #include <isl/val.h>
8659         __isl_give isl_multi_val *isl_multi_val_range_splice(
8660                 __isl_take isl_multi_val *mv1, unsigned pos,
8661                 __isl_take isl_multi_val *mv2);
8663         #include <isl/aff.h>
8664         __isl_give isl_multi_aff *isl_multi_aff_range_splice(
8665                 __isl_take isl_multi_aff *ma1, unsigned pos,
8666                 __isl_take isl_multi_aff *ma2);
8667         __isl_give isl_multi_aff *isl_multi_aff_splice(
8668                 __isl_take isl_multi_aff *ma1,
8669                 unsigned in_pos, unsigned out_pos,
8670                 __isl_take isl_multi_aff *ma2);
8671         __isl_give isl_multi_pw_aff *
8672         isl_multi_pw_aff_range_splice(
8673                 __isl_take isl_multi_pw_aff *mpa1, unsigned pos,
8674                 __isl_take isl_multi_pw_aff *mpa2);
8675         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_splice(
8676                 __isl_take isl_multi_pw_aff *mpa1,
8677                 unsigned in_pos, unsigned out_pos,
8678                 __isl_take isl_multi_pw_aff *mpa2);
8679         __isl_give isl_multi_union_pw_aff *
8680         isl_multi_union_pw_aff_range_splice(
8681                 __isl_take isl_multi_union_pw_aff *mupa1,
8682                 unsigned pos,
8683                 __isl_take isl_multi_union_pw_aff *mupa2);
8685 =item * Simplification
8687 When applied to a set or relation,
8688 the gist operation returns a set or relation that has the
8689 same intersection with the context as the input set or relation.
8690 Any implicit equality in the intersection is made explicit in the result,
8691 while all inequalities that are redundant with respect to the intersection
8692 are removed.
8693 In case of union sets and relations, the gist operation is performed
8694 per space.
8696 When applied to a function,
8697 the gist operation applies the set gist operation to each of
8698 the cells in the domain of the input piecewise expression.
8699 The context is also exploited
8700 to simplify the expression associated to each cell.
8702         #include <isl/set.h>
8703         __isl_give isl_basic_set *isl_basic_set_gist(
8704                 __isl_take isl_basic_set *bset,
8705                 __isl_take isl_basic_set *context);
8706         __isl_give isl_set *isl_set_gist(__isl_take isl_set *set,
8707                 __isl_take isl_set *context);
8708         __isl_give isl_set *isl_set_gist_params(
8709                 __isl_take isl_set *set,
8710                 __isl_take isl_set *context);
8712         #include <isl/map.h>
8713         __isl_give isl_basic_map *isl_basic_map_gist(
8714                 __isl_take isl_basic_map *bmap,
8715                 __isl_take isl_basic_map *context);
8716         __isl_give isl_basic_map *isl_basic_map_gist_domain(
8717                 __isl_take isl_basic_map *bmap,
8718                 __isl_take isl_basic_set *context);
8719         __isl_give isl_map *isl_map_gist(__isl_take isl_map *map,
8720                 __isl_take isl_map *context);
8721         __isl_give isl_map *isl_map_gist_params(
8722                 __isl_take isl_map *map,
8723                 __isl_take isl_set *context);
8724         __isl_give isl_map *isl_map_gist_domain(
8725                 __isl_take isl_map *map,
8726                 __isl_take isl_set *context);
8727         __isl_give isl_map *isl_map_gist_range(
8728                 __isl_take isl_map *map,
8729                 __isl_take isl_set *context);
8731         #include <isl/union_set.h>
8732         __isl_give isl_union_set *isl_union_set_gist(
8733                 __isl_take isl_union_set *uset,
8734                 __isl_take isl_union_set *context);
8735         __isl_give isl_union_set *isl_union_set_gist_params(
8736                 __isl_take isl_union_set *uset,
8737                 __isl_take isl_set *set);
8739         #include <isl/union_map.h>
8740         __isl_give isl_union_map *isl_union_map_gist(
8741                 __isl_take isl_union_map *umap,
8742                 __isl_take isl_union_map *context);
8743         __isl_give isl_union_map *isl_union_map_gist_params(
8744                 __isl_take isl_union_map *umap,
8745                 __isl_take isl_set *set);
8746         __isl_give isl_union_map *isl_union_map_gist_domain(
8747                 __isl_take isl_union_map *umap,
8748                 __isl_take isl_union_set *uset);
8749         __isl_give isl_union_map *isl_union_map_gist_range(
8750                 __isl_take isl_union_map *umap,
8751                 __isl_take isl_union_set *uset);
8753         #include <isl/aff.h>
8754         __isl_give isl_aff *isl_aff_gist_params(
8755                 __isl_take isl_aff *aff,
8756                 __isl_take isl_set *context);
8757         __isl_give isl_aff *isl_aff_gist(__isl_take isl_aff *aff,
8758                 __isl_take isl_set *context);
8759         __isl_give isl_multi_aff *isl_multi_aff_gist_params(
8760                 __isl_take isl_multi_aff *maff,
8761                 __isl_take isl_set *context);
8762         __isl_give isl_multi_aff *isl_multi_aff_gist(
8763                 __isl_take isl_multi_aff *maff,
8764                 __isl_take isl_set *context);
8765         __isl_give isl_pw_aff *isl_pw_aff_gist_params(
8766                 __isl_take isl_pw_aff *pwaff,
8767                 __isl_take isl_set *context);
8768         __isl_give isl_pw_aff *isl_pw_aff_gist(
8769                 __isl_take isl_pw_aff *pwaff,
8770                 __isl_take isl_set *context);
8771         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_gist_params(
8772                 __isl_take isl_pw_multi_aff *pma,
8773                 __isl_take isl_set *set);
8774         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_gist(
8775                 __isl_take isl_pw_multi_aff *pma,
8776                 __isl_take isl_set *set);
8777         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_gist_params(
8778                 __isl_take isl_multi_pw_aff *mpa,
8779                 __isl_take isl_set *set);
8780         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_gist(
8781                 __isl_take isl_multi_pw_aff *mpa,
8782                 __isl_take isl_set *set);
8783         __isl_give isl_union_pw_aff *isl_union_pw_aff_gist(
8784                 __isl_take isl_union_pw_aff *upa,
8785                 __isl_take isl_union_set *context);
8786         __isl_give isl_union_pw_aff *isl_union_pw_aff_gist_params(
8787                 __isl_take isl_union_pw_aff *upa,
8788                 __isl_take isl_set *context);
8789         __isl_give isl_union_pw_multi_aff *
8790         isl_union_pw_multi_aff_gist_params(
8791                 __isl_take isl_union_pw_multi_aff *upma,
8792                 __isl_take isl_set *context);
8793         __isl_give isl_union_pw_multi_aff *
8794         isl_union_pw_multi_aff_gist(
8795                 __isl_take isl_union_pw_multi_aff *upma,
8796                 __isl_take isl_union_set *context);
8797         __isl_give isl_multi_union_pw_aff *
8798         isl_multi_union_pw_aff_gist_params(
8799                 __isl_take isl_multi_union_pw_aff *mupa,
8800                 __isl_take isl_set *context);
8801         __isl_give isl_multi_union_pw_aff *
8802         isl_multi_union_pw_aff_gist(
8803                 __isl_take isl_multi_union_pw_aff *mupa,
8804                 __isl_take isl_union_set *context);
8806         #include <isl/polynomial.h>
8807         __isl_give isl_qpolynomial *isl_qpolynomial_gist_params(
8808                 __isl_take isl_qpolynomial *qp,
8809                 __isl_take isl_set *context);
8810         __isl_give isl_qpolynomial *isl_qpolynomial_gist(
8811                 __isl_take isl_qpolynomial *qp,
8812                 __isl_take isl_set *context);
8813         __isl_give isl_qpolynomial_fold *
8814         isl_qpolynomial_fold_gist_params(
8815                 __isl_take isl_qpolynomial_fold *fold,
8816                 __isl_take isl_set *context);
8817         __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_gist(
8818                 __isl_take isl_qpolynomial_fold *fold,
8819                 __isl_take isl_set *context);
8820         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_gist_params(
8821                 __isl_take isl_pw_qpolynomial *pwqp,
8822                 __isl_take isl_set *context);
8823         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_gist(
8824                 __isl_take isl_pw_qpolynomial *pwqp,
8825                 __isl_take isl_set *context);
8826         __isl_give isl_pw_qpolynomial_fold *
8827         isl_pw_qpolynomial_fold_gist(
8828                 __isl_take isl_pw_qpolynomial_fold *pwf,
8829                 __isl_take isl_set *context);
8830         __isl_give isl_pw_qpolynomial_fold *
8831         isl_pw_qpolynomial_fold_gist_params(
8832                 __isl_take isl_pw_qpolynomial_fold *pwf,
8833                 __isl_take isl_set *context);
8834         __isl_give isl_union_pw_qpolynomial *
8835         isl_union_pw_qpolynomial_gist_params(
8836                 __isl_take isl_union_pw_qpolynomial *upwqp,
8837                 __isl_take isl_set *context);
8838         __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_gist(
8839                 __isl_take isl_union_pw_qpolynomial *upwqp,
8840                 __isl_take isl_union_set *context);
8841         __isl_give isl_union_pw_qpolynomial_fold *
8842         isl_union_pw_qpolynomial_fold_gist(
8843                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
8844                 __isl_take isl_union_set *context);
8845         __isl_give isl_union_pw_qpolynomial_fold *
8846         isl_union_pw_qpolynomial_fold_gist_params(
8847                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
8848                 __isl_take isl_set *context);
8850 =item * Binary Arithmetic Operations
8852         #include <isl/set.h>
8853         __isl_give isl_set *isl_set_sum(
8854                 __isl_take isl_set *set1,
8855                 __isl_take isl_set *set2);
8856         #include <isl/map.h>
8857         __isl_give isl_map *isl_map_sum(
8858                 __isl_take isl_map *map1,
8859                 __isl_take isl_map *map2);
8861 C<isl_set_sum> computes the Minkowski sum of its two arguments,
8862 i.e., the set containing the sums of pairs of elements from
8863 C<set1> and C<set2>.
8864 The domain of the result of C<isl_map_sum> is the intersection
8865 of the domains of its two arguments.  The corresponding range
8866 elements are the sums of the corresponding range elements
8867 in the two arguments.
8869         #include <isl/val.h>
8870         __isl_give isl_multi_val *isl_multi_val_add(
8871                 __isl_take isl_multi_val *mv1,
8872                 __isl_take isl_multi_val *mv2);
8873         __isl_give isl_multi_val *isl_multi_val_sub(
8874                 __isl_take isl_multi_val *mv1,
8875                 __isl_take isl_multi_val *mv2);
8876         __isl_give isl_multi_val *isl_multi_val_min(
8877                 __isl_take isl_multi_val *mv1,
8878                 __isl_take isl_multi_val *mv2);
8879         __isl_give isl_multi_val *isl_multi_val_max(
8880                 __isl_take isl_multi_val *mv1,
8881                 __isl_take isl_multi_val *mv2);
8883         #include <isl/aff.h>
8884         __isl_give isl_aff *isl_aff_add(
8885                 __isl_take isl_aff *aff1,
8886                 __isl_take isl_aff *aff2);
8887         __isl_give isl_multi_aff *isl_multi_aff_add(
8888                 __isl_take isl_multi_aff *maff1,
8889                 __isl_take isl_multi_aff *maff2);
8890         __isl_give isl_pw_aff *isl_pw_aff_add(
8891                 __isl_take isl_pw_aff *pwaff1,
8892                 __isl_take isl_pw_aff *pwaff2);
8893         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_add(
8894                 __isl_take isl_multi_pw_aff *mpa1,
8895                 __isl_take isl_multi_pw_aff *mpa2);
8896         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_add(
8897                 __isl_take isl_pw_multi_aff *pma1,
8898                 __isl_take isl_pw_multi_aff *pma2);
8899         __isl_give isl_union_pw_aff *isl_union_pw_aff_add(
8900                 __isl_take isl_union_pw_aff *upa1,
8901                 __isl_take isl_union_pw_aff *upa2);
8902         __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_add(
8903                 __isl_take isl_union_pw_multi_aff *upma1,
8904                 __isl_take isl_union_pw_multi_aff *upma2);
8905         __isl_give isl_multi_union_pw_aff *
8906         isl_multi_union_pw_aff_add(
8907                 __isl_take isl_multi_union_pw_aff *mupa1,
8908                 __isl_take isl_multi_union_pw_aff *mupa2);
8909         __isl_give isl_pw_aff *isl_pw_aff_add_constant_val(
8910                 __isl_take isl_pw_aff *pa,
8911                 __isl_take isl_val *v);
8912         __isl_give isl_multi_aff *
8913         isl_multi_aff_add_constant_val(
8914                 __isl_take isl_multi_aff *pa,
8915                 __isl_take isl_val *v);
8916         __isl_give isl_pw_multi_aff *
8917         isl_pw_multi_aff_add_constant_val(
8918                 __isl_take isl_pw_multi_aff *pma,
8919                 __isl_take isl_val *v);
8920         __isl_give isl_pw_multi_aff *
8921         isl_pw_multi_aff_add_constant_multi_val(
8922                 __isl_take isl_pw_multi_aff *pma,
8923                 __isl_take isl_multi_val *mv);
8924         __isl_give isl_multi_pw_aff *
8925         isl_multi_pw_aff_add_constant_val(
8926                 __isl_take isl_multi_pw_aff *mpa,
8927                 __isl_take isl_val *v);
8928         __isl_give isl_multi_aff *
8929         isl_multi_aff_add_constant_multi_val(
8930                 __isl_take isl_multi_aff *pa,
8931                 __isl_take isl_multi_val *mv);
8932         __isl_give isl_multi_pw_aff *
8933         isl_multi_pw_aff_add_constant_multi_val(
8934                 __isl_take isl_multi_pw_aff *mpa,
8935                 __isl_take isl_multi_val *mv);
8936         __isl_give isl_pw_aff *isl_pw_aff_min(
8937                 __isl_take isl_pw_aff *pwaff1,
8938                 __isl_take isl_pw_aff *pwaff2);
8939         __isl_give isl_pw_aff *isl_pw_aff_max(
8940                 __isl_take isl_pw_aff *pwaff1,
8941                 __isl_take isl_pw_aff *pwaff2);
8942         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_min(
8943                 __isl_take isl_multi_pw_aff *mpa1,
8944                 __isl_take isl_multi_pw_aff *mpa2);
8945         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_max(
8946                 __isl_take isl_multi_pw_aff *mpa1,
8947                 __isl_take isl_multi_pw_aff *mpa2);
8948         __isl_give isl_aff *isl_aff_sub(
8949                 __isl_take isl_aff *aff1,
8950                 __isl_take isl_aff *aff2);
8951         __isl_give isl_multi_aff *isl_multi_aff_sub(
8952                 __isl_take isl_multi_aff *ma1,
8953                 __isl_take isl_multi_aff *ma2);
8954         __isl_give isl_pw_aff *isl_pw_aff_sub(
8955                 __isl_take isl_pw_aff *pwaff1,
8956                 __isl_take isl_pw_aff *pwaff2);
8957         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_sub(
8958                 __isl_take isl_multi_pw_aff *mpa1,
8959                 __isl_take isl_multi_pw_aff *mpa2);
8960         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_sub(
8961                 __isl_take isl_pw_multi_aff *pma1,
8962                 __isl_take isl_pw_multi_aff *pma2);
8963         __isl_give isl_union_pw_aff *isl_union_pw_aff_sub(
8964                 __isl_take isl_union_pw_aff *upa1,
8965                 __isl_take isl_union_pw_aff *upa2);
8966         __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_sub(
8967                 __isl_take isl_union_pw_multi_aff *upma1,
8968                 __isl_take isl_union_pw_multi_aff *upma2);
8969         __isl_give isl_multi_union_pw_aff *
8970         isl_multi_union_pw_aff_sub(
8971                 __isl_take isl_multi_union_pw_aff *mupa1,
8972                 __isl_take isl_multi_union_pw_aff *mupa2);
8974 C<isl_aff_sub> subtracts the second argument from the first.
8976         #include <isl/polynomial.h>
8977         __isl_give isl_qpolynomial *isl_qpolynomial_add(
8978                 __isl_take isl_qpolynomial *qp1,
8979                 __isl_take isl_qpolynomial *qp2);
8980         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add(
8981                 __isl_take isl_pw_qpolynomial *pwqp1,
8982                 __isl_take isl_pw_qpolynomial *pwqp2);
8983         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add_disjoint(
8984                 __isl_take isl_pw_qpolynomial *pwqp1,
8985                 __isl_take isl_pw_qpolynomial *pwqp2);
8986         __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_add(
8987                 __isl_take isl_pw_qpolynomial_fold *pwf1,
8988                 __isl_take isl_pw_qpolynomial_fold *pwf2);
8989         __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_add(
8990                 __isl_take isl_union_pw_qpolynomial *upwqp1,
8991                 __isl_take isl_union_pw_qpolynomial *upwqp2);
8992         __isl_give isl_qpolynomial *isl_qpolynomial_sub(
8993                 __isl_take isl_qpolynomial *qp1,
8994                 __isl_take isl_qpolynomial *qp2);
8995         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_sub(
8996                 __isl_take isl_pw_qpolynomial *pwqp1,
8997                 __isl_take isl_pw_qpolynomial *pwqp2);
8998         __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_sub(
8999                 __isl_take isl_union_pw_qpolynomial *upwqp1,
9000                 __isl_take isl_union_pw_qpolynomial *upwqp2);
9001         __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_fold(
9002                 __isl_take isl_pw_qpolynomial_fold *pwf1,
9003                 __isl_take isl_pw_qpolynomial_fold *pwf2);
9004         __isl_give isl_union_pw_qpolynomial_fold *
9005         isl_union_pw_qpolynomial_fold_fold(
9006                 __isl_take isl_union_pw_qpolynomial_fold *upwf1,
9007                 __isl_take isl_union_pw_qpolynomial_fold *upwf2);
9009         #include <isl/aff.h>
9010         __isl_give isl_pw_aff *isl_pw_aff_union_add(
9011                 __isl_take isl_pw_aff *pwaff1,
9012                 __isl_take isl_pw_aff *pwaff2);
9013         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_union_add(
9014                 __isl_take isl_multi_pw_aff *mpa1,
9015                 __isl_take isl_multi_pw_aff *mpa2);
9016         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_add(
9017                 __isl_take isl_pw_multi_aff *pma1,
9018                 __isl_take isl_pw_multi_aff *pma2);
9019         __isl_give isl_union_pw_aff *isl_union_pw_aff_union_add(
9020                 __isl_take isl_union_pw_aff *upa1,
9021                 __isl_take isl_union_pw_aff *upa2);
9022         __isl_give isl_union_pw_multi_aff *
9023         isl_union_pw_multi_aff_union_add(
9024                 __isl_take isl_union_pw_multi_aff *upma1,
9025                 __isl_take isl_union_pw_multi_aff *upma2);
9026         __isl_give isl_multi_union_pw_aff *
9027         isl_multi_union_pw_aff_union_add(
9028                 __isl_take isl_multi_union_pw_aff *mupa1,
9029                 __isl_take isl_multi_union_pw_aff *mupa2);
9030         __isl_give isl_pw_aff *isl_pw_aff_union_min(
9031                 __isl_take isl_pw_aff *pwaff1,
9032                 __isl_take isl_pw_aff *pwaff2);
9033         __isl_give isl_pw_aff *isl_pw_aff_union_max(
9034                 __isl_take isl_pw_aff *pwaff1,
9035                 __isl_take isl_pw_aff *pwaff2);
9037 The function C<isl_pw_aff_union_max> computes a piecewise quasi-affine
9038 expression with a domain that is the union of those of C<pwaff1> and
9039 C<pwaff2> and such that on each cell, the quasi-affine expression is
9040 the maximum of those of C<pwaff1> and C<pwaff2>.  If only one of
9041 C<pwaff1> or C<pwaff2> is defined on a given cell, then the
9042 associated expression is the defined one.
9043 This in contrast to the C<isl_pw_aff_max> function, which is
9044 only defined on the shared definition domain of the arguments.
9046         #include <isl/val.h>
9047         __isl_give isl_multi_val *isl_multi_val_add_val(
9048                 __isl_take isl_multi_val *mv,
9049                 __isl_take isl_val *v);
9050         __isl_give isl_multi_val *isl_multi_val_mod_val(
9051                 __isl_take isl_multi_val *mv,
9052                 __isl_take isl_val *v);
9053         __isl_give isl_multi_val *isl_multi_val_scale_val(
9054                 __isl_take isl_multi_val *mv,
9055                 __isl_take isl_val *v);
9056         __isl_give isl_multi_val *isl_multi_val_scale_down_val(
9057                 __isl_take isl_multi_val *mv,
9058                 __isl_take isl_val *v);
9060         #include <isl/aff.h>
9061         __isl_give isl_aff *isl_aff_mod_val(__isl_take isl_aff *aff,
9062                 __isl_take isl_val *mod);
9063         __isl_give isl_pw_aff *isl_pw_aff_mod_val(
9064                 __isl_take isl_pw_aff *pa,
9065                 __isl_take isl_val *mod);
9066         __isl_give isl_union_pw_aff *isl_union_pw_aff_mod_val(
9067                 __isl_take isl_union_pw_aff *upa,
9068                 __isl_take isl_val *f);
9069         __isl_give isl_aff *isl_aff_scale_val(__isl_take isl_aff *aff,
9070                 __isl_take isl_val *v);
9071         __isl_give isl_multi_aff *isl_multi_aff_scale_val(
9072                 __isl_take isl_multi_aff *ma,
9073                 __isl_take isl_val *v);
9074         __isl_give isl_pw_aff *isl_pw_aff_scale_val(
9075                 __isl_take isl_pw_aff *pa, __isl_take isl_val *v);
9076         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_scale_val(
9077                 __isl_take isl_multi_pw_aff *mpa,
9078                 __isl_take isl_val *v);
9079         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_scale_val(
9080                 __isl_take isl_pw_multi_aff *pma,
9081                 __isl_take isl_val *v);
9082         __isl_give isl_union_pw_aff *isl_union_pw_aff_scale_val(
9083                 __isl_take isl_union_pw_aff *upa,
9084                 __isl_take isl_val *f);
9085         __isl_give isl_union_pw_multi_aff *
9086         isl_union_pw_multi_aff_scale_val(
9087                 __isl_take isl_union_pw_multi_aff *upma,
9088                 __isl_take isl_val *val);
9089         __isl_give isl_multi_union_pw_aff *
9090         isl_multi_union_pw_aff_scale_val(
9091                 __isl_take isl_multi_union_pw_aff *mupa,
9092                 __isl_take isl_val *v);
9093         __isl_give isl_aff *isl_aff_scale_down_ui(
9094                 __isl_take isl_aff *aff, unsigned f);
9095         __isl_give isl_aff *isl_aff_scale_down_val(
9096                 __isl_take isl_aff *aff, __isl_take isl_val *v);
9097         __isl_give isl_multi_aff *isl_multi_aff_scale_down_val(
9098                 __isl_take isl_multi_aff *ma,
9099                 __isl_take isl_val *v);
9100         __isl_give isl_pw_aff *isl_pw_aff_scale_down_val(
9101                 __isl_take isl_pw_aff *pa,
9102                 __isl_take isl_val *f);
9103         __isl_give isl_multi_pw_aff *isl_multi_pw_aff_scale_down_val(
9104                 __isl_take isl_multi_pw_aff *mpa,
9105                 __isl_take isl_val *v);
9106         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_scale_down_val(
9107                 __isl_take isl_pw_multi_aff *pma,
9108                 __isl_take isl_val *v);
9109         __isl_give isl_union_pw_aff *isl_union_pw_aff_scale_down_val(
9110                 __isl_take isl_union_pw_aff *upa,
9111                 __isl_take isl_val *v);
9112         __isl_give isl_union_pw_multi_aff *
9113         isl_union_pw_multi_aff_scale_down_val(
9114                 __isl_take isl_union_pw_multi_aff *upma,
9115                 __isl_take isl_val *val);
9116         __isl_give isl_multi_union_pw_aff *
9117         isl_multi_union_pw_aff_scale_down_val(
9118                 __isl_take isl_multi_union_pw_aff *mupa,
9119                 __isl_take isl_val *v);
9121         #include <isl/polynomial.h>
9122         __isl_give isl_qpolynomial *isl_qpolynomial_scale_val(
9123                 __isl_take isl_qpolynomial *qp,
9124                 __isl_take isl_val *v);
9125         __isl_give isl_qpolynomial_fold *
9126         isl_qpolynomial_fold_scale_val(
9127                 __isl_take isl_qpolynomial_fold *fold,
9128                 __isl_take isl_val *v);
9129         __isl_give isl_pw_qpolynomial *
9130         isl_pw_qpolynomial_scale_val(
9131                 __isl_take isl_pw_qpolynomial *pwqp,
9132                 __isl_take isl_val *v);
9133         __isl_give isl_pw_qpolynomial_fold *
9134         isl_pw_qpolynomial_fold_scale_val(
9135                 __isl_take isl_pw_qpolynomial_fold *pwf,
9136                 __isl_take isl_val *v);
9137         __isl_give isl_union_pw_qpolynomial *
9138         isl_union_pw_qpolynomial_scale_val(
9139                 __isl_take isl_union_pw_qpolynomial *upwqp,
9140                 __isl_take isl_val *v);
9141         __isl_give isl_union_pw_qpolynomial_fold *
9142         isl_union_pw_qpolynomial_fold_scale_val(
9143                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
9144                 __isl_take isl_val *v);
9145         __isl_give isl_qpolynomial *
9146         isl_qpolynomial_scale_down_val(
9147                 __isl_take isl_qpolynomial *qp,
9148                 __isl_take isl_val *v);
9149         __isl_give isl_qpolynomial_fold *
9150         isl_qpolynomial_fold_scale_down_val(
9151                 __isl_take isl_qpolynomial_fold *fold,
9152                 __isl_take isl_val *v);
9153         __isl_give isl_pw_qpolynomial *
9154         isl_pw_qpolynomial_scale_down_val(
9155                 __isl_take isl_pw_qpolynomial *pwqp,
9156                 __isl_take isl_val *v);
9157         __isl_give isl_pw_qpolynomial_fold *
9158         isl_pw_qpolynomial_fold_scale_down_val(
9159                 __isl_take isl_pw_qpolynomial_fold *pwf,
9160                 __isl_take isl_val *v);
9161         __isl_give isl_union_pw_qpolynomial *
9162         isl_union_pw_qpolynomial_scale_down_val(
9163                 __isl_take isl_union_pw_qpolynomial *upwqp,
9164                 __isl_take isl_val *v);
9165         __isl_give isl_union_pw_qpolynomial_fold *
9166         isl_union_pw_qpolynomial_fold_scale_down_val(
9167                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
9168                 __isl_take isl_val *v);
9170         #include <isl/val.h>
9171         __isl_give isl_multi_val *isl_multi_val_mod_multi_val(
9172                 __isl_take isl_multi_val *mv1,
9173                 __isl_take isl_multi_val *mv2);
9174         __isl_give isl_multi_val *isl_multi_val_scale_multi_val(
9175                 __isl_take isl_multi_val *mv1,
9176                 __isl_take isl_multi_val *mv2);
9177         __isl_give isl_multi_val *
9178         isl_multi_val_scale_down_multi_val(
9179                 __isl_take isl_multi_val *mv1,
9180                 __isl_take isl_multi_val *mv2);
9182         #include <isl/aff.h>
9183         __isl_give isl_multi_aff *isl_multi_aff_mod_multi_val(
9184                 __isl_take isl_multi_aff *ma,
9185                 __isl_take isl_multi_val *mv);
9186         __isl_give isl_multi_union_pw_aff *
9187         isl_multi_union_pw_aff_mod_multi_val(
9188                 __isl_take isl_multi_union_pw_aff *upma,
9189                 __isl_take isl_multi_val *mv);
9190         __isl_give isl_multi_pw_aff *
9191         isl_multi_pw_aff_mod_multi_val(
9192                 __isl_take isl_multi_pw_aff *mpa,
9193                 __isl_take isl_multi_val *mv);
9194         __isl_give isl_multi_aff *isl_multi_aff_scale_multi_val(
9195                 __isl_take isl_multi_aff *ma,
9196                 __isl_take isl_multi_val *mv);
9197         __isl_give isl_pw_multi_aff *
9198         isl_pw_multi_aff_scale_multi_val(
9199                 __isl_take isl_pw_multi_aff *pma,
9200                 __isl_take isl_multi_val *mv);
9201         __isl_give isl_multi_pw_aff *
9202         isl_multi_pw_aff_scale_multi_val(
9203                 __isl_take isl_multi_pw_aff *mpa,
9204                 __isl_take isl_multi_val *mv);
9205         __isl_give isl_multi_union_pw_aff *
9206         isl_multi_union_pw_aff_scale_multi_val(
9207                 __isl_take isl_multi_union_pw_aff *mupa,
9208                 __isl_take isl_multi_val *mv);
9209         __isl_give isl_union_pw_multi_aff *
9210         isl_union_pw_multi_aff_scale_multi_val(
9211                 __isl_take isl_union_pw_multi_aff *upma,
9212                 __isl_take isl_multi_val *mv);
9213         __isl_give isl_multi_aff *
9214         isl_multi_aff_scale_down_multi_val(
9215                 __isl_take isl_multi_aff *ma,
9216                 __isl_take isl_multi_val *mv);
9217         __isl_give isl_pw_multi_aff *
9218         isl_pw_multi_aff_scale_down_multi_val(
9219                 __isl_take isl_pw_multi_aff *pma,
9220                 __isl_take isl_multi_val *mv);
9221         __isl_give isl_multi_pw_aff *
9222         isl_multi_pw_aff_scale_down_multi_val(
9223                 __isl_take isl_multi_pw_aff *mpa,
9224                 __isl_take isl_multi_val *mv);
9225         __isl_give isl_multi_union_pw_aff *
9226         isl_multi_union_pw_aff_scale_down_multi_val(
9227                 __isl_take isl_multi_union_pw_aff *mupa,
9228                 __isl_take isl_multi_val *mv);
9230 C<isl_multi_aff_scale_multi_val> scales the elements of C<ma>
9231 by the corresponding elements of C<mv>.
9233         #include <isl/aff.h>
9234         __isl_give isl_aff *isl_aff_mul(
9235                 __isl_take isl_aff *aff1,
9236                 __isl_take isl_aff *aff2);
9237         __isl_give isl_aff *isl_aff_div(
9238                 __isl_take isl_aff *aff1,
9239                 __isl_take isl_aff *aff2);
9240         __isl_give isl_pw_aff *isl_pw_aff_mul(
9241                 __isl_take isl_pw_aff *pwaff1,
9242                 __isl_take isl_pw_aff *pwaff2);
9243         __isl_give isl_pw_aff *isl_pw_aff_div(
9244                 __isl_take isl_pw_aff *pa1,
9245                 __isl_take isl_pw_aff *pa2);
9246         __isl_give isl_pw_aff *isl_pw_aff_tdiv_q(
9247                 __isl_take isl_pw_aff *pa1,
9248                 __isl_take isl_pw_aff *pa2);
9249         __isl_give isl_pw_aff *isl_pw_aff_tdiv_r(
9250                 __isl_take isl_pw_aff *pa1,
9251                 __isl_take isl_pw_aff *pa2);
9253 When multiplying two affine expressions, at least one of the two needs
9254 to be a constant.  Similarly, when dividing an affine expression by another,
9255 the second expression needs to be a constant.
9256 C<isl_pw_aff_tdiv_q> computes the quotient of an integer division with
9257 rounding towards zero.  C<isl_pw_aff_tdiv_r> computes the corresponding
9258 remainder.
9260         #include <isl/polynomial.h>
9261         __isl_give isl_qpolynomial *isl_qpolynomial_mul(
9262                 __isl_take isl_qpolynomial *qp1,
9263                 __isl_take isl_qpolynomial *qp2);
9264         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_mul(
9265                 __isl_take isl_pw_qpolynomial *pwqp1,
9266                 __isl_take isl_pw_qpolynomial *pwqp2);
9267         __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_mul(
9268                 __isl_take isl_union_pw_qpolynomial *upwqp1,
9269                 __isl_take isl_union_pw_qpolynomial *upwqp2);
9271 =back
9273 =head3 Lexicographic Optimization
9275 Given a (basic) set C<set> (or C<bset>) and a zero-dimensional domain C<dom>,
9276 the following functions
9277 compute a set that contains the lexicographic minimum or maximum
9278 of the elements in C<set> (or C<bset>) for those values of the parameters
9279 that satisfy C<dom>.
9280 If C<empty> is not C<NULL>, then C<*empty> is assigned a set
9281 that contains the parameter values in C<dom> for which C<set> (or C<bset>)
9282 has no elements.
9283 In other words, the union of the parameter values
9284 for which the result is non-empty and of C<*empty>
9285 is equal to C<dom>.
9287         #include <isl/set.h>
9288         __isl_give isl_set *isl_basic_set_partial_lexmin(
9289                 __isl_take isl_basic_set *bset,
9290                 __isl_take isl_basic_set *dom,
9291                 __isl_give isl_set **empty);
9292         __isl_give isl_set *isl_basic_set_partial_lexmax(
9293                 __isl_take isl_basic_set *bset,
9294                 __isl_take isl_basic_set *dom,
9295                 __isl_give isl_set **empty);
9296         __isl_give isl_set *isl_set_partial_lexmin(
9297                 __isl_take isl_set *set, __isl_take isl_set *dom,
9298                 __isl_give isl_set **empty);
9299         __isl_give isl_set *isl_set_partial_lexmax(
9300                 __isl_take isl_set *set, __isl_take isl_set *dom,
9301                 __isl_give isl_set **empty);
9303 Given a (basic) set C<set> (or C<bset>), the following functions simply
9304 return a set containing the lexicographic minimum or maximum
9305 of the elements in C<set> (or C<bset>).
9306 In case of union sets, the optimum is computed per space.
9308         #include <isl/set.h>
9309         __isl_give isl_set *isl_basic_set_lexmin(
9310                 __isl_take isl_basic_set *bset);
9311         __isl_give isl_set *isl_basic_set_lexmax(
9312                 __isl_take isl_basic_set *bset);
9313         __isl_give isl_set *isl_set_lexmin(
9314                 __isl_take isl_set *set);
9315         __isl_give isl_set *isl_set_lexmax(
9316                 __isl_take isl_set *set);
9317         __isl_give isl_union_set *isl_union_set_lexmin(
9318                 __isl_take isl_union_set *uset);
9319         __isl_give isl_union_set *isl_union_set_lexmax(
9320                 __isl_take isl_union_set *uset);
9322 Given a (basic) relation C<map> (or C<bmap>) and a domain C<dom>,
9323 the following functions
9324 compute a relation that maps each element of C<dom>
9325 to the single lexicographic minimum or maximum
9326 of the elements that are associated to that same
9327 element in C<map> (or C<bmap>).
9328 If C<empty> is not C<NULL>, then C<*empty> is assigned a set
9329 that contains the elements in C<dom> that do not map
9330 to any elements in C<map> (or C<bmap>).
9331 In other words, the union of the domain of the result and of C<*empty>
9332 is equal to C<dom>.
9334         #include <isl/map.h>
9335         __isl_give isl_map *isl_basic_map_partial_lexmax(
9336                 __isl_take isl_basic_map *bmap,
9337                 __isl_take isl_basic_set *dom,
9338                 __isl_give isl_set **empty);
9339         __isl_give isl_map *isl_basic_map_partial_lexmin(
9340                 __isl_take isl_basic_map *bmap,
9341                 __isl_take isl_basic_set *dom,
9342                 __isl_give isl_set **empty);
9343         __isl_give isl_map *isl_map_partial_lexmax(
9344                 __isl_take isl_map *map, __isl_take isl_set *dom,
9345                 __isl_give isl_set **empty);
9346         __isl_give isl_map *isl_map_partial_lexmin(
9347                 __isl_take isl_map *map, __isl_take isl_set *dom,
9348                 __isl_give isl_set **empty);
9350 Given a (basic) map C<map> (or C<bmap>), the following functions simply
9351 return a map mapping each element in the domain of
9352 C<map> (or C<bmap>) to the lexicographic minimum or maximum
9353 of all elements associated to that element.
9354 In case of union relations, the optimum is computed per space.
9356         #include <isl/map.h>
9357         __isl_give isl_map *isl_basic_map_lexmin(
9358                 __isl_take isl_basic_map *bmap);
9359         __isl_give isl_map *isl_basic_map_lexmax(
9360                 __isl_take isl_basic_map *bmap);
9361         __isl_give isl_map *isl_map_lexmin(
9362                 __isl_take isl_map *map);
9363         __isl_give isl_map *isl_map_lexmax(
9364                 __isl_take isl_map *map);
9365         __isl_give isl_union_map *isl_union_map_lexmin(
9366                 __isl_take isl_union_map *umap);
9367         __isl_give isl_union_map *isl_union_map_lexmax(
9368                 __isl_take isl_union_map *umap);
9370 The following functions return their result in the form of
9371 a piecewise multi-affine expression,
9372 but are otherwise equivalent to the corresponding functions
9373 returning a basic set or relation.
9375         #include <isl/set.h>
9376         __isl_give isl_pw_multi_aff *
9377         isl_basic_set_partial_lexmin_pw_multi_aff(
9378                 __isl_take isl_basic_set *bset,
9379                 __isl_take isl_basic_set *dom,
9380                 __isl_give isl_set **empty);
9381         __isl_give isl_pw_multi_aff *
9382         isl_basic_set_partial_lexmax_pw_multi_aff(
9383                 __isl_take isl_basic_set *bset,
9384                 __isl_take isl_basic_set *dom,
9385                 __isl_give isl_set **empty);
9386         __isl_give isl_pw_multi_aff *isl_set_lexmin_pw_multi_aff(
9387                 __isl_take isl_set *set);
9388         __isl_give isl_pw_multi_aff *isl_set_lexmax_pw_multi_aff(
9389                 __isl_take isl_set *set);
9391         #include <isl/map.h>
9392         __isl_give isl_pw_multi_aff *
9393         isl_basic_map_lexmin_pw_multi_aff(
9394                 __isl_take isl_basic_map *bmap);
9395         __isl_give isl_pw_multi_aff *
9396         isl_basic_map_partial_lexmin_pw_multi_aff(
9397                 __isl_take isl_basic_map *bmap,
9398                 __isl_take isl_basic_set *dom,
9399                 __isl_give isl_set **empty);
9400         __isl_give isl_pw_multi_aff *
9401         isl_basic_map_partial_lexmax_pw_multi_aff(
9402                 __isl_take isl_basic_map *bmap,
9403                 __isl_take isl_basic_set *dom,
9404                 __isl_give isl_set **empty);
9405         __isl_give isl_pw_multi_aff *isl_map_lexmin_pw_multi_aff(
9406                 __isl_take isl_map *map);
9407         __isl_give isl_pw_multi_aff *isl_map_lexmax_pw_multi_aff(
9408                 __isl_take isl_map *map);
9410 The following functions return the lexicographic minimum or maximum
9411 on the shared domain of the inputs and the single defined function
9412 on those parts of the domain where only a single function is defined.
9414         #include <isl/aff.h>
9415         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_lexmin(
9416                 __isl_take isl_pw_multi_aff *pma1,
9417                 __isl_take isl_pw_multi_aff *pma2);
9418         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_lexmax(
9419                 __isl_take isl_pw_multi_aff *pma1,
9420                 __isl_take isl_pw_multi_aff *pma2);
9422 If the input to a lexicographic optimization problem has
9423 multiple constraints with the same coefficients for the optimized
9424 variables, then, by default, this symmetry is exploited by
9425 replacing those constraints by a single constraint with
9426 an abstract bound, which is in turn bounded by the corresponding terms
9427 in the original constraints.
9428 Without this optimization, the solver would typically consider
9429 all possible orderings of those original bounds, resulting in a needless
9430 decomposition of the domain.
9431 However, the optimization can also result in slowdowns since
9432 an extra parameter is introduced that may get used in additional
9433 integer divisions.
9434 The following option determines whether symmetry detection is applied
9435 during lexicographic optimization.
9437         #include <isl/options.h>
9438         isl_stat isl_options_set_pip_symmetry(isl_ctx *ctx,
9439                 int val);
9440         int isl_options_get_pip_symmetry(isl_ctx *ctx);
9442 =begin latex
9444 See also \autoref{s:offline}.
9446 =end latex
9448 =head2 Ternary Operations
9450         #include <isl/aff.h>
9451         __isl_give isl_pw_aff *isl_pw_aff_cond(
9452                 __isl_take isl_pw_aff *cond,
9453                 __isl_take isl_pw_aff *pwaff_true,
9454                 __isl_take isl_pw_aff *pwaff_false);
9456 The function C<isl_pw_aff_cond> performs a conditional operator
9457 and returns an expression that is equal to C<pwaff_true>
9458 for elements where C<cond> is non-zero and equal to C<pwaff_false> for elements
9459 where C<cond> is zero.
9461 =head2 Lists
9463 Lists are defined over several element types, including
9464 C<isl_val>, C<isl_id>, C<isl_aff>, C<isl_pw_aff>, C<isl_pw_multi_aff>,
9465 C<isl_union_pw_aff>,
9466 C<isl_union_pw_multi_aff>,
9467 C<isl_qpolynomial>, C<isl_pw_qpolynomial>, C<isl_pw_qpolynomial_fold>,
9468 C<isl_constraint>,
9469 C<isl_basic_set>, C<isl_set>, C<isl_basic_map>, C<isl_map>, C<isl_union_set>,
9470 C<isl_union_map>, C<isl_ast_expr> and C<isl_ast_node>.
9471 Here we take lists of C<isl_set>s as an example.
9472 Lists can be created, copied, modified and freed using the following functions.
9474         #include <isl/set.h>
9475         __isl_give isl_set_list *isl_set_to_list(
9476                 __isl_take isl_set *el);
9477         __isl_give isl_set_list *isl_set_list_from_set(
9478                 __isl_take isl_set *el);
9479         __isl_give isl_set_list *isl_set_list_alloc(
9480                 isl_ctx *ctx, int n);
9481         __isl_give isl_set_list *isl_set_list_copy(
9482                 __isl_keep isl_set_list *list);
9483         __isl_give isl_set_list *isl_set_list_insert(
9484                 __isl_take isl_set_list *list, unsigned pos,
9485                 __isl_take isl_set *el);
9486         __isl_give isl_set_list *isl_set_list_add(
9487                 __isl_take isl_set_list *list,
9488                 __isl_take isl_set *el);
9489         __isl_give isl_set_list *isl_set_list_drop(
9490                 __isl_take isl_set_list *list,
9491                 unsigned first, unsigned n);
9492         __isl_give isl_set_list *isl_set_list_clear(
9493                 __isl_take isl_set_list *list);
9494         __isl_give isl_set_list *isl_set_list_swap(
9495                 __isl_take isl_set_list *list,
9496                 unsigned pos1, unsigned pos2);
9497         __isl_give isl_set_list *isl_set_list_reverse(
9498                 __isl_take isl_set_list *list);
9499         __isl_give isl_set_list *isl_set_list_set_at(
9500                 __isl_take isl_set_list *list, int index,
9501                 __isl_take isl_set *set);
9502         __isl_give isl_set_list *isl_set_list_set_set(
9503                 __isl_take isl_set_list *list, int index,
9504                 __isl_take isl_set *set);
9505         __isl_give isl_set_list *isl_set_list_concat(
9506                 __isl_take isl_set_list *list1,
9507                 __isl_take isl_set_list *list2);
9508         __isl_give isl_set_list *isl_set_list_map(
9509                 __isl_take isl_set_list *list,
9510                 __isl_give isl_set *(*fn)(__isl_take isl_set *el,
9511                         void *user),
9512                 void *user);
9513         __isl_give isl_set_list *isl_set_list_sort(
9514                 __isl_take isl_set_list *list,
9515                 int (*cmp)(__isl_keep isl_set *a,
9516                         __isl_keep isl_set *b, void *user),
9517                 void *user);
9518         __isl_null isl_set_list *isl_set_list_free(
9519                 __isl_take isl_set_list *list);
9521 C<isl_set_list_alloc> creates an empty list with an initial capacity
9522 for C<n> elements.  C<isl_set_list_insert> and C<isl_set_list_add>
9523 add elements to a list, increasing its capacity as needed.
9524 C<isl_set_to_list> creates a list with a single element.
9525 C<isl_set_list_from_set> performs the same operation.
9526 C<isl_set_list_clear> removes all elements from a list.
9527 C<isl_set_list_swap> swaps the elements at the specified locations.
9528 C<isl_set_list_reverse> reverses the elements in the list.
9529 C<isl_set_list_set_set> is an alternative name for C<isl_set_list_set_at>.
9531 Lists can be inspected using the following functions.
9533         #include <isl/set.h>
9534         isl_size isl_set_list_size(__isl_keep isl_set_list *list);
9535         isl_size isl_set_list_n_set(__isl_keep isl_set_list *list);
9536         __isl_give isl_set *isl_set_list_get_at(
9537                 __isl_keep isl_set_list *list, int index);
9538         __isl_give isl_set *isl_set_list_get_set(
9539                 __isl_keep isl_set_list *list, int index);
9540         isl_stat isl_set_list_foreach(__isl_keep isl_set_list *list,
9541                 isl_stat (*fn)(__isl_take isl_set *el, void *user),
9542                 void *user);
9543         isl_bool isl_set_list_every(__isl_keep isl_set_list *list,
9544                 isl_bool (*test)(__isl_take isl_set *el,
9545                         void *user),
9546                 void *user);
9547         isl_stat isl_set_list_foreach_scc(
9548                 __isl_keep isl_set_list *list,
9549                 isl_bool (*follows)(__isl_keep isl_set *a,
9550                         __isl_keep isl_set *b, void *user),
9551                 void *follows_user,
9552                 isl_stat (*fn)(__isl_take isl_set_list *scc,
9553                         void *user),
9554                 void *fn_user);
9556 C<isl_set_list_n_set> is an alternative name for C<isl_set_list_size>.
9557 Similarly,
9558 C<isl_set_list_get_set> is an alternative name for C<isl_set_list_get_at>.
9559 The function C<isl_set_list_foreach_scc> calls C<fn> on each of the
9560 strongly connected components of the graph with as vertices the elements
9561 of C<list> and a directed edge from vertex C<b> to vertex C<a>
9562 iff C<follows(a, b)> returns C<isl_bool_true>.  The callbacks C<follows> and
9563 C<fn> should return C<isl_bool_error> or C<isl_stat_error> on error.
9565 Lists can be printed using
9567         #include <isl/set.h>
9568         __isl_give isl_printer *isl_printer_print_set_list(
9569                 __isl_take isl_printer *p,
9570                 __isl_keep isl_set_list *list);
9572 Alternatively, a string representation can be obtained
9573 directly using the following function, which always prints
9574 in isl format.
9576         #include <isl/set.h>
9577         __isl_give char *isl_set_list_to_str(
9578                 __isl_keep isl_set_list *list);
9580 An C<isl_val_list>, C<isl_id_list>,
9581 C<isl_aff_list>, C<isl_pw_aff_list>, C<isl_pw_multi_aff_list>,
9582 C<isl_union_pw_aff_list>,
9583 C<isl_set_list>, C<isl_map_list> or C<isl_union_set_list> object
9584 can also be read from input using the following functions.
9586         #include <isl/val.h>
9587         __isl_give isl_val_list *isl_val_list_read_from_str(
9588                 isl_ctx *ctx, const char *str);
9590         #include <isl/id.h>
9591         __isl_give isl_id_list *isl_id_list_read_from_str(
9592                 isl_ctx *ctx, const char *str);
9594         #include <isl/aff.h>
9595         __isl_give isl_aff_list *
9596         isl_aff_list_read_from_str(isl_ctx *ctx,
9597                 const char *str);
9598         __isl_give isl_pw_aff_list *
9599         isl_pw_aff_list_read_from_str(isl_ctx *ctx,
9600                 const char *str);
9601         __isl_give isl_pw_multi_aff_list *
9602         isl_pw_multi_aff_list_read_from_str(isl_ctx *ctx,
9603                 const char *str);
9604         __isl_give isl_union_pw_aff_list *
9605         isl_union_pw_aff_list_read_from_str(isl_ctx *ctx,
9606                 const char *str);
9608         #include <isl/set.h>
9609         __isl_give isl_set_list *isl_set_list_read_from_str(
9610                 isl_ctx *ctx, const char *str);
9612         #include <isl/map.h>
9613         __isl_give isl_map_list *isl_map_list_read_from_str(
9614                 isl_ctx *ctx, const char *str);
9616         #include <isl/union_set.h>
9617         __isl_give isl_union_set_list *
9618         isl_union_set_list_read_from_str(isl_ctx *ctx,
9619                 const char *str);
9621 =head2 Associative arrays
9623 Associative arrays map isl objects of a specific type to isl objects
9624 of some (other) specific type.  They are defined for several pairs
9625 of types, including (C<isl_map>, C<isl_basic_set>),
9626 (C<isl_id>, C<isl_ast_expr>),
9627 (C<isl_id>, C<isl_id>) and
9628 (C<isl_id>, C<isl_pw_aff>).
9629 Here, we take associative arrays that map C<isl_id>s to C<isl_ast_expr>s
9630 as an example.
9632 Associative arrays can be created, copied and freed using
9633 the following functions.
9635         #include <isl/id_to_ast_expr.h>
9636         __isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_alloc(
9637                 isl_ctx *ctx, int min_size);
9638         __isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_copy(
9639                 __isl_keep isl_id_to_ast_expr *id2expr);
9640         __isl_null isl_id_to_ast_expr *isl_id_to_ast_expr_free(
9641                 __isl_take isl_id_to_ast_expr *id2expr);
9643 The C<min_size> argument to C<isl_id_to_ast_expr_alloc> can be used
9644 to specify the expected size of the associative array.
9645 The associative array will be grown automatically as needed.
9647 Associative arrays can be inspected using the following functions.
9649         #include <isl/id_to_ast_expr.h>
9650         __isl_give isl_maybe_isl_ast_expr
9651         isl_id_to_ast_expr_try_get(
9652                 __isl_keep isl_id_to_ast_expr *id2expr,
9653                 __isl_keep isl_id *key);
9654         isl_bool isl_id_to_ast_expr_has(
9655                 __isl_keep isl_id_to_ast_expr *id2expr,
9656                 __isl_keep isl_id *key);
9657         __isl_give isl_ast_expr *isl_id_to_ast_expr_get(
9658                 __isl_keep isl_id_to_ast_expr *id2expr,
9659                 __isl_take isl_id *key);
9660         isl_stat isl_id_to_ast_expr_foreach(
9661                 __isl_keep isl_id_to_ast_expr *id2expr,
9662                 isl_stat (*fn)(__isl_take isl_id *key,
9663                         __isl_take isl_ast_expr *val, void *user),
9664                 void *user);
9665         isl_bool isl_id_to_ast_expr_every(
9666                 __isl_keep isl_id_to_ast_expr *id2expr,
9667                 isl_bool (*test)(__isl_keep isl_id *key,
9668                         __isl_keep isl_ast_expr *val, void *user),
9669                 void *user);
9671 The function C<isl_id_to_ast_expr_try_get> returns a structure
9672 containing two elements, C<valid> and C<value>.
9673 If there is a value associated to the key, then C<valid>
9674 is set to C<isl_bool_true> and C<value> contains a copy of
9675 the associated value.  Otherwise C<value> is C<NULL> and
9676 C<valid> may be C<isl_bool_error> or C<isl_bool_false> depending
9677 on whether some error has occurred or there simply is no associated value.
9678 The function C<isl_id_to_ast_expr_has> returns the C<valid> field
9679 in the structure and
9680 the function C<isl_id_to_ast_expr_get> returns the C<value> field.
9682 Associative arrays can be modified using the following functions.
9684         #include <isl/id_to_ast_expr.h>
9685         __isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_set(
9686                 __isl_take isl_id_to_ast_expr *id2expr,
9687                 __isl_take isl_id *key,
9688                 __isl_take isl_ast_expr *val);
9689         __isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_drop(
9690                 __isl_take isl_id_to_ast_expr *id2expr,
9691                 __isl_take isl_id *key);
9693 Associative arrays can be checked for (obvious) equality
9694 using the following function.
9696         #include <isl/id_to_ast_expr.h>
9697         isl_bool isl_id_to_ast_expr_is_equal(
9698                 __isl_take isl_id_to_ast_expr *id2expr1,
9699                 __isl_take isl_id_to_ast_expr *id2expr2);
9701 Note that depending on how the keys and values are being compared,
9702 for other types of keys and/or values, this function may be called
9703 C<plain_is_equal> rather than C<is_equal>.
9705 Associative arrays can be printed using the following functions.
9707         #include <isl/id_to_ast_expr.h>
9708         __isl_give isl_printer *isl_printer_print_id_to_ast_expr(
9709                 __isl_take isl_printer *p,
9710                 __isl_keep isl_id_to_ast_expr *id2expr);
9711         __isl_give char *isl_id_to_ast_expr_to_str(
9712                 __isl_keep isl_id_to_ast_expr *id2expr);
9714 They can be read from input using the following function.
9716         #include <isl/id_to_ast_expr.h>
9717         __isl_give isl_id_to_ast_expr *
9718         isl_id_to_ast_expr_read_from_str(isl_ctx *ctx,
9719                 const char *str);
9721 =head2 Vectors
9723 Vectors can be created, copied and freed using the following functions.
9725         #include <isl/vec.h>
9726         __isl_give isl_vec *isl_vec_alloc(isl_ctx *ctx,
9727                 unsigned size);
9728         __isl_give isl_vec *isl_vec_zero(isl_ctx *ctx,
9729                 unsigned size);
9730         __isl_give isl_vec *isl_vec_copy(__isl_keep isl_vec *vec);
9731         __isl_null isl_vec *isl_vec_free(__isl_take isl_vec *vec);
9733 Note that the elements of a vector created by C<isl_vec_alloc>
9734 may have arbitrary values.
9735 A vector created by C<isl_vec_zero> has elements with value zero.
9736 The elements can be changed and inspected using the following functions.
9738         isl_size isl_vec_size(__isl_keep isl_vec *vec);
9739         __isl_give isl_val *isl_vec_get_element_val(
9740                 __isl_keep isl_vec *vec, int pos);
9741         __isl_give isl_vec *isl_vec_set_element_si(
9742                 __isl_take isl_vec *vec, int pos, int v);
9743         __isl_give isl_vec *isl_vec_set_element_val(
9744                 __isl_take isl_vec *vec, int pos,
9745                 __isl_take isl_val *v);
9746         __isl_give isl_vec *isl_vec_set_si(__isl_take isl_vec *vec,
9747                 int v);
9748         __isl_give isl_vec *isl_vec_set_val(
9749                 __isl_take isl_vec *vec, __isl_take isl_val *v);
9750         int isl_vec_cmp_element(__isl_keep isl_vec *vec1,
9751                 __isl_keep isl_vec *vec2, int pos);
9753 C<isl_vec_get_element> will return a negative value if anything went wrong.
9754 In that case, the value of C<*v> is undefined.
9756 The following function can be used to concatenate two vectors.
9758         __isl_give isl_vec *isl_vec_concat(__isl_take isl_vec *vec1,
9759                 __isl_take isl_vec *vec2);
9761 =head2 Matrices
9763 Matrices can be created, copied and freed using the following functions.
9765         #include <isl/mat.h>
9766         __isl_give isl_mat *isl_mat_alloc(isl_ctx *ctx,
9767                 unsigned n_row, unsigned n_col);
9768         __isl_give isl_mat *isl_mat_copy(__isl_keep isl_mat *mat);
9769         __isl_null isl_mat *isl_mat_free(__isl_take isl_mat *mat);
9771 Note that the elements of a newly created matrix may have arbitrary values.
9772 The elements can be changed and inspected using the following functions.
9774         isl_size isl_mat_rows(__isl_keep isl_mat *mat);
9775         isl_size isl_mat_cols(__isl_keep isl_mat *mat);
9776         __isl_give isl_val *isl_mat_get_element_val(
9777                 __isl_keep isl_mat *mat, int row, int col);
9778         __isl_give isl_mat *isl_mat_set_element_si(__isl_take isl_mat *mat,
9779                 int row, int col, int v);
9780         __isl_give isl_mat *isl_mat_set_element_val(
9781                 __isl_take isl_mat *mat, int row, int col,
9782                 __isl_take isl_val *v);
9784 The following function computes the rank of a matrix.
9785 The return value may be -1 if some error occurred.
9787         #include <isl/mat.h>
9788         isl_size isl_mat_rank(__isl_keep isl_mat *mat);
9790 The following function can be used to compute the (right) inverse
9791 of a matrix, i.e., a matrix such that the product of the original
9792 and the inverse (in that order) is a multiple of the identity matrix.
9793 The input matrix is assumed to be of full row-rank.
9795         __isl_give isl_mat *isl_mat_right_inverse(__isl_take isl_mat *mat);
9797 The following function can be used to compute the (right) kernel
9798 (or null space) of a matrix, i.e., a matrix such that the product of
9799 the original and the kernel (in that order) is the zero matrix.
9801         __isl_give isl_mat *isl_mat_right_kernel(__isl_take isl_mat *mat);
9803 The following function computes a basis for the space spanned
9804 by the rows of a matrix.
9806         __isl_give isl_mat *isl_mat_row_basis(
9807                 __isl_take isl_mat *mat);
9809 The following function computes rows that extend a basis of C<mat1>
9810 to a basis that also covers C<mat2>.
9812         __isl_give isl_mat *isl_mat_row_basis_extension(
9813                 __isl_take isl_mat *mat1,
9814                 __isl_take isl_mat *mat2);
9816 The following function checks whether there is no linear dependence
9817 among the combined rows of "mat1" and "mat2" that is not already present
9818 in "mat1" or "mat2" individually.
9819 If "mat1" and "mat2" have linearly independent rows by themselves,
9820 then this means that there is no linear dependence among all rows together.
9822         isl_bool isl_mat_has_linearly_independent_rows(
9823                 __isl_keep isl_mat *mat1,
9824                 __isl_keep isl_mat *mat2);
9826 =head2 Bounds on Piecewise Quasipolynomials and Piecewise Quasipolynomial Reductions
9828 The following functions determine
9829 an upper or lower bound on a quasipolynomial over its domain.
9831         __isl_give isl_pw_qpolynomial_fold *
9832         isl_pw_qpolynomial_bound(
9833                 __isl_take isl_pw_qpolynomial *pwqp,
9834                 enum isl_fold type, isl_bool *tight);
9836         __isl_give isl_union_pw_qpolynomial_fold *
9837         isl_union_pw_qpolynomial_bound(
9838                 __isl_take isl_union_pw_qpolynomial *upwqp,
9839                 enum isl_fold type, isl_bool *tight);
9841 The C<type> argument may be either C<isl_fold_min> or C<isl_fold_max>.
9842 If C<tight> is not C<NULL>, then C<*tight> is set to C<1>
9843 is the returned bound is known be tight, i.e., for each value
9844 of the parameters there is at least
9845 one element in the domain that reaches the bound.
9846 If the domain of C<pwqp> is not wrapping, then the bound is computed
9847 over all elements in that domain and the result has a purely parametric
9848 domain.  If the domain of C<pwqp> is wrapping, then the bound is
9849 computed over the range of the wrapped relation.  The domain of the
9850 wrapped relation becomes the domain of the result.
9852 =head2 Parametric Vertex Enumeration
9854 The parametric vertex enumeration described in this section
9855 is mainly intended to be used internally and by the C<barvinok>
9856 library.
9858         #include <isl/vertices.h>
9859         __isl_give isl_vertices *isl_basic_set_compute_vertices(
9860                 __isl_keep isl_basic_set *bset);
9862 The function C<isl_basic_set_compute_vertices> performs the
9863 actual computation of the parametric vertices and the chamber
9864 decomposition and stores the result in an C<isl_vertices> object.
9865 This information can be queried by either iterating over all
9866 the vertices or iterating over all the chambers or cells
9867 and then iterating over all vertices that are active on the chamber.
9869         isl_stat isl_vertices_foreach_vertex(
9870                 __isl_keep isl_vertices *vertices,
9871                 isl_stat (*fn)(__isl_take isl_vertex *vertex,
9872                         void *user), void *user);
9874         isl_stat isl_vertices_foreach_cell(
9875                 __isl_keep isl_vertices *vertices,
9876                 isl_stat (*fn)(__isl_take isl_cell *cell,
9877                         void *user), void *user);
9878         isl_stat isl_cell_foreach_vertex(__isl_keep isl_cell *cell,
9879                 isl_stat (*fn)(__isl_take isl_vertex *vertex,
9880                         void *user), void *user);
9882 Other operations that can be performed on an C<isl_vertices> object are
9883 the following.
9885         isl_size isl_vertices_get_n_vertices(
9886                 __isl_keep isl_vertices *vertices);
9887         __isl_null isl_vertices *isl_vertices_free(
9888                 __isl_take isl_vertices *vertices);
9890 Vertices can be inspected and destroyed using the following functions.
9892         isl_size isl_vertex_get_id(__isl_keep isl_vertex *vertex);
9893         __isl_give isl_basic_set *isl_vertex_get_domain(
9894                 __isl_keep isl_vertex *vertex);
9895         __isl_give isl_multi_aff *isl_vertex_get_expr(
9896                 __isl_keep isl_vertex *vertex);
9897         __isl_null isl_vertex *isl_vertex_free(
9898                 __isl_take isl_vertex *vertex);
9900 C<isl_vertex_get_expr> returns a multiple quasi-affine expression
9901 describing the vertex in terms of the parameters,
9902 while C<isl_vertex_get_domain> returns the activity domain
9903 of the vertex.
9905 Chambers can be inspected and destroyed using the following functions.
9907         __isl_give isl_basic_set *isl_cell_get_domain(
9908                 __isl_keep isl_cell *cell);
9909         __isl_null isl_cell *isl_cell_free(
9910                 __isl_take isl_cell *cell);
9912 =head1 Polyhedral Compilation Library
9914 This section collects functionality in C<isl> that has been specifically
9915 designed for use during polyhedral compilation.
9917 =head2 Schedule Trees
9919 A schedule tree is a structured representation of a schedule,
9920 assigning a relative order to a set of domain elements.
9921 The relative order expressed by the schedule tree is
9922 defined recursively.  In particular, the order between
9923 two domain elements is determined by the node that is closest
9924 to the root that refers to both elements and that orders them apart.
9925 Each node in the tree is of one of several types.
9926 The root node is always of type C<isl_schedule_node_domain>
9927 (or C<isl_schedule_node_extension>)
9928 and it describes the (extra) domain elements to which the schedule applies.
9929 The other types of nodes are as follows.
9931 =over
9933 =item C<isl_schedule_node_band>
9935 A band of schedule dimensions.  Each schedule dimension is represented
9936 by a union piecewise quasi-affine expression.  If this expression
9937 assigns a different value to two domain elements, while all previous
9938 schedule dimensions in the same band assign them the same value,
9939 then the two domain elements are ordered according to these two
9940 different values.
9941 Each expression is required to be total in the domain elements
9942 that reach the band node.
9944 =item C<isl_schedule_node_expansion>
9946 An expansion node maps each of the domain elements that reach the node
9947 to one or more domain elements.  The image of this mapping forms
9948 the set of domain elements that reach the child of the expansion node.
9949 The function that maps each of the expanded domain elements
9950 to the original domain element from which it was expanded
9951 is called the contraction.
9953 =item C<isl_schedule_node_filter>
9955 A filter node does not impose any ordering, but rather intersects
9956 the set of domain elements that the current subtree refers to
9957 with a given union set.  The subtree of the filter node only
9958 refers to domain elements in the intersection.
9959 A filter node is typically only used as a child of a sequence or
9960 set node.
9962 =item C<isl_schedule_node_leaf>
9964 A leaf of the schedule tree.  Leaf nodes do not impose any ordering.
9966 =item C<isl_schedule_node_mark>
9968 A mark node can be used to attach any kind of information to a subtree
9969 of the schedule tree.
9971 =item C<isl_schedule_node_sequence>
9973 A sequence node has one or more children, each of which is a filter node.
9974 The filters on these filter nodes form a partition of
9975 the domain elements that the current subtree refers to.
9976 If two domain elements appear in distinct filters then the sequence
9977 node orders them according to the child positions of the corresponding
9978 filter nodes.
9980 =item C<isl_schedule_node_set>
9982 A set node is similar to a sequence node, except that
9983 it expresses that domain elements appearing in distinct filters
9984 may have any order.  The order of the children of a set node
9985 is therefore also immaterial.
9987 =back
9989 The following node types are only supported by the AST generator.
9991 =over
9993 =item C<isl_schedule_node_context>
9995 The context describes constraints on the parameters and
9996 the schedule dimensions of outer
9997 bands that the AST generator may assume to hold.  It is also the only
9998 kind of node that may introduce additional parameters.
9999 The space of the context is that of the flat product of the outer
10000 band nodes.  In particular, if there are no outer band nodes, then
10001 this space is the unnamed zero-dimensional space.
10002 Since a context node references the outer band nodes, any tree
10003 containing a context node is considered to be anchored.
10005 =item C<isl_schedule_node_extension>
10007 An extension node instructs the AST generator to add additional
10008 domain elements that need to be scheduled.
10009 The additional domain elements are described by the range of
10010 the extension map in terms of the outer schedule dimensions,
10011 i.e., the flat product of the outer band nodes.
10012 Note that domain elements are added whenever the AST generator
10013 reaches the extension node, meaning that there are still some
10014 active domain elements for which an AST needs to be generated.
10015 The conditions under which some domain elements are still active
10016 may however not be completely described by the outer AST nodes
10017 generated at that point.
10018 Since an extension node references the outer band nodes, any tree
10019 containing an extension node is considered to be anchored.
10021 An extension node may also appear as the root of a schedule tree,
10022 when it is intended to be inserted into another tree
10023 using C<isl_schedule_node_graft_before> or C<isl_schedule_node_graft_after>.
10024 In this case, the domain of the extension node should
10025 correspond to the flat product of the outer band nodes
10026 in this other schedule tree at the point where the extension tree
10027 will be inserted.
10029 =item C<isl_schedule_node_guard>
10031 The guard describes constraints on the parameters and
10032 the schedule dimensions of outer
10033 bands that need to be enforced by the outer nodes
10034 in the generated AST.
10035 That is, the part of the AST that is generated from descendants
10036 of the guard node can assume that these constraints are satisfied.
10037 The space of the guard is that of the flat product of the outer
10038 band nodes.  In particular, if there are no outer band nodes, then
10039 this space is the unnamed zero-dimensional space.
10040 Since a guard node references the outer band nodes, any tree
10041 containing a guard node is considered to be anchored.
10043 =back
10045 Except for the C<isl_schedule_node_context> nodes,
10046 none of the nodes may introduce any parameters that were not
10047 already present in the root domain node.
10049 A schedule tree is encapsulated in an C<isl_schedule> object.
10050 The simplest such objects, those with a tree consisting of single domain node,
10051 can be created using the following functions with either an empty
10052 domain or a given domain.
10054         #include <isl/schedule.h>
10055         __isl_give isl_schedule *isl_schedule_empty(
10056                 __isl_take isl_space *space);
10057         __isl_give isl_schedule *isl_schedule_from_domain(
10058                 __isl_take isl_union_set *domain);
10060 The function C<isl_schedule_constraints_compute_schedule> described
10061 in L</"Scheduling"> can also be used to construct schedules.
10063 C<isl_schedule> objects may be copied and freed using the following functions.
10065         #include <isl/schedule.h>
10066         __isl_give isl_schedule *isl_schedule_copy(
10067                 __isl_keep isl_schedule *sched);
10068         __isl_null isl_schedule *isl_schedule_free(
10069                 __isl_take isl_schedule *sched);
10071 The following functions checks whether two C<isl_schedule> objects
10072 are obviously the same.
10074         #include <isl/schedule.h>
10075         isl_bool isl_schedule_plain_is_equal(
10076                 __isl_keep isl_schedule *schedule1,
10077                 __isl_keep isl_schedule *schedule2);
10079 The domain of the schedule, i.e., the domain described by the root node,
10080 can be obtained using the following function.
10082         #include <isl/schedule.h>
10083         __isl_give isl_union_set *isl_schedule_get_domain(
10084                 __isl_keep isl_schedule *schedule);
10086 An extra top-level band node (right underneath the domain node) can
10087 be introduced into the schedule using the following function.
10088 The schedule tree is assumed not to have any anchored nodes.
10090         #include <isl/schedule.h>
10091         __isl_give isl_schedule *
10092         isl_schedule_insert_partial_schedule(
10093                 __isl_take isl_schedule *schedule,
10094                 __isl_take isl_multi_union_pw_aff *partial);
10096 A top-level context node (right underneath the domain node) can
10097 be introduced into the schedule using the following function.
10099         #include <isl/schedule.h>
10100         __isl_give isl_schedule *isl_schedule_insert_context(
10101                 __isl_take isl_schedule *schedule,
10102                 __isl_take isl_set *context)
10104 A top-level guard node (right underneath the domain node) can
10105 be introduced into the schedule using the following function.
10107         #include <isl/schedule.h>
10108         __isl_give isl_schedule *isl_schedule_insert_guard(
10109                 __isl_take isl_schedule *schedule,
10110                 __isl_take isl_set *guard)
10112 A schedule that combines two schedules either in the given
10113 order or in an arbitrary order, i.e., with an C<isl_schedule_node_sequence>
10114 or an C<isl_schedule_node_set> node,
10115 can be created using the following functions.
10117         #include <isl/schedule.h>
10118         __isl_give isl_schedule *isl_schedule_sequence(
10119                 __isl_take isl_schedule *schedule1,
10120                 __isl_take isl_schedule *schedule2);
10121         __isl_give isl_schedule *isl_schedule_set(
10122                 __isl_take isl_schedule *schedule1,
10123                 __isl_take isl_schedule *schedule2);
10125 The domains of the two input schedules need to be disjoint.
10127 The following function can be used to restrict the domain
10128 of a schedule with a domain node as root to be a subset of the given union set.
10129 This operation may remove nodes in the tree that have become
10130 redundant.
10132         #include <isl/schedule.h>
10133         __isl_give isl_schedule *isl_schedule_intersect_domain(
10134                 __isl_take isl_schedule *schedule,
10135                 __isl_take isl_union_set *domain);
10137 The following function can be used to simplify the domain
10138 of a schedule with a domain node as root with respect to the given
10139 parameter domain.
10141         #include <isl/schedule.h>
10142         __isl_give isl_schedule *isl_schedule_gist_domain_params(
10143                 __isl_take isl_schedule *schedule,
10144                 __isl_take isl_set *context);
10146 The following function resets the user pointers on all parameter
10147 and tuple identifiers referenced by the nodes of the given schedule.
10149         #include <isl/schedule.h>
10150         __isl_give isl_schedule *isl_schedule_reset_user(
10151                 __isl_take isl_schedule *schedule);
10153 The following function aligns the parameters of all nodes
10154 in the given schedule to the given space.
10156         #include <isl/schedule.h>
10157         __isl_give isl_schedule *isl_schedule_align_params(
10158                 __isl_take isl_schedule *schedule,
10159                 __isl_take isl_space *space);
10161 The following function allows the user to plug in a given function
10162 in the iteration domains.  The input schedule is not allowed to contain
10163 any expansion nodes.
10165         #include <isl/schedule.h>
10166         __isl_give isl_schedule *
10167         isl_schedule_pullback_union_pw_multi_aff(
10168                 __isl_take isl_schedule *schedule,
10169                 __isl_take isl_union_pw_multi_aff *upma);
10171 The following function can be used to plug in the schedule C<expansion>
10172 in the leaves of C<schedule>, where C<contraction> describes how
10173 the domain elements of C<expansion> map to the domain elements
10174 at the original leaves of C<schedule>.
10175 The resulting schedule will contain expansion nodes, unless
10176 C<contraction> is an identity function.
10178         #include <isl/schedule.h>
10179         __isl_give isl_schedule *isl_schedule_expand(
10180                 __isl_take isl_schedule *schedule,
10181                 __isl_take isl_union_pw_multi_aff *contraction,
10182                 __isl_take isl_schedule *expansion);
10184 An C<isl_union_map> representation of the schedule can be obtained
10185 from an C<isl_schedule> using the following function.
10187         #include <isl/schedule.h>
10188         __isl_give isl_union_map *isl_schedule_get_map(
10189                 __isl_keep isl_schedule *sched);
10191 The resulting relation encodes the same relative ordering as
10192 the schedule by mapping the domain elements to a common schedule space.
10193 If the schedule_separate_components option is set, then the order
10194 of the children of a set node is explicitly encoded in the result.
10195 If the tree contains any expansion nodes, then the relation
10196 is formulated in terms of the expanded domain elements.
10198 Schedules can be read from input using the following functions.
10200         #include <isl/schedule.h>
10201         __isl_give isl_schedule *isl_schedule_read_from_file(
10202                 isl_ctx *ctx, FILE *input);
10203         __isl_give isl_schedule *isl_schedule_read_from_str(
10204                 isl_ctx *ctx, const char *str);
10206 A representation of the schedule can be printed using
10208         #include <isl/schedule.h>
10209         __isl_give isl_printer *isl_printer_print_schedule(
10210                 __isl_take isl_printer *p,
10211                 __isl_keep isl_schedule *schedule);
10212         __isl_give char *isl_schedule_to_str(
10213                 __isl_keep isl_schedule *schedule);
10215 C<isl_schedule_to_str> prints the schedule in flow format.
10217 The schedule tree can be traversed through the use of
10218 C<isl_schedule_node> objects that point to a particular
10219 position in the schedule tree.  Whenever a C<isl_schedule_node>
10220 is used to modify a node in the schedule tree, the original schedule
10221 tree is left untouched and the modifications are performed to a copy
10222 of the tree.  The returned C<isl_schedule_node> then points to
10223 this modified copy of the tree.
10225 The root of the schedule tree can be obtained using the following function.
10227         #include <isl/schedule.h>
10228         __isl_give isl_schedule_node *isl_schedule_get_root(
10229                 __isl_keep isl_schedule *schedule);
10231 A pointer to a newly created schedule tree with a single domain
10232 node can be created using the following functions.
10234         #include <isl/schedule_node.h>
10235         __isl_give isl_schedule_node *
10236         isl_schedule_node_from_domain(
10237                 __isl_take isl_union_set *domain);
10238         __isl_give isl_schedule_node *
10239         isl_schedule_node_from_extension(
10240                 __isl_take isl_union_map *extension);
10242 C<isl_schedule_node_from_extension> creates a tree with an extension
10243 node as root.
10245 Schedule nodes can be copied and freed using the following functions.
10247         #include <isl/schedule_node.h>
10248         __isl_give isl_schedule_node *isl_schedule_node_copy(
10249                 __isl_keep isl_schedule_node *node);
10250         __isl_null isl_schedule_node *isl_schedule_node_free(
10251                 __isl_take isl_schedule_node *node);
10253 The following functions can be used to check if two schedule
10254 nodes point to the same position in the same schedule.
10256         #include <isl/schedule_node.h>
10257         isl_bool isl_schedule_node_is_equal(
10258                 __isl_keep isl_schedule_node *node1,
10259                 __isl_keep isl_schedule_node *node2);
10261 The following properties can be obtained from a schedule node.
10263         #include <isl/schedule_node.h>
10264         enum isl_schedule_node_type isl_schedule_node_get_type(
10265                 __isl_keep isl_schedule_node *node);
10266         enum isl_schedule_node_type
10267         isl_schedule_node_get_parent_type(
10268                 __isl_keep isl_schedule_node *node);
10269         __isl_give isl_schedule *isl_schedule_node_get_schedule(
10270                 __isl_keep isl_schedule_node *node);
10272 The function C<isl_schedule_node_get_type> returns the type of
10273 the node, while C<isl_schedule_node_get_parent_type> returns
10274 type of the parent of the node, which is required to exist.
10275 The function C<isl_schedule_node_get_schedule> returns a copy
10276 to the schedule to which the node belongs.
10278 The following functions can be used to move the schedule node
10279 to a different position in the tree or to check if such a position
10280 exists.
10282         #include <isl/schedule_node.h>
10283         isl_bool isl_schedule_node_has_parent(
10284                 __isl_keep isl_schedule_node *node);
10285         __isl_give isl_schedule_node *isl_schedule_node_parent(
10286                 __isl_take isl_schedule_node *node);
10287         __isl_give isl_schedule_node *
10288         isl_schedule_node_grandparent(
10289                 __isl_take isl_schedule_node *node);
10290         __isl_give isl_schedule_node *isl_schedule_node_root(
10291                 __isl_take isl_schedule_node *node);
10292         __isl_give isl_schedule_node *isl_schedule_node_ancestor(
10293                 __isl_take isl_schedule_node *node,
10294                 int generation);
10295         isl_size isl_schedule_node_n_children(
10296                 __isl_keep isl_schedule_node *node);
10297         __isl_give isl_schedule_node *isl_schedule_node_child(
10298                 __isl_take isl_schedule_node *node, int pos);
10299         isl_bool isl_schedule_node_has_children(
10300                 __isl_keep isl_schedule_node *node);
10301         __isl_give isl_schedule_node *
10302         isl_schedule_node_grandchild(
10303                 __isl_take isl_schedule_node *node,
10304                 int pos1, int pos2);
10305         __isl_give isl_schedule_node *isl_schedule_node_first_child(
10306                 __isl_take isl_schedule_node *node);
10307         isl_bool isl_schedule_node_has_previous_sibling(
10308                 __isl_keep isl_schedule_node *node);
10309         __isl_give isl_schedule_node *
10310         isl_schedule_node_previous_sibling(
10311                 __isl_take isl_schedule_node *node);
10312         isl_bool isl_schedule_node_has_next_sibling(
10313                 __isl_keep isl_schedule_node *node);
10314         __isl_give isl_schedule_node *
10315         isl_schedule_node_next_sibling(
10316                 __isl_take isl_schedule_node *node);
10318 For C<isl_schedule_node_ancestor>, the ancestor of generation 0
10319 is the node itself, the ancestor of generation 1 is its parent and so on.
10321 It is also possible to query the number of ancestors of a node,
10322 the position of the current node
10323 within the children of its parent, the position of the subtree
10324 containing a node within the children of an ancestor
10325 or to obtain a copy of a given
10326 child without destroying the current node.
10327 Given two nodes that point to the same schedule, their closest
10328 shared ancestor can be obtained using
10329 C<isl_schedule_node_get_shared_ancestor>.
10331         #include <isl/schedule_node.h>
10332         isl_size isl_schedule_node_get_tree_depth(
10333                 __isl_keep isl_schedule_node *node);
10334         isl_size isl_schedule_node_get_child_position(
10335                 __isl_keep isl_schedule_node *node);
10336         isl_size isl_schedule_node_get_ancestor_child_position(
10337                 __isl_keep isl_schedule_node *node,
10338                 __isl_keep isl_schedule_node *ancestor);
10339         __isl_give isl_schedule_node *isl_schedule_node_get_child(
10340                 __isl_keep isl_schedule_node *node, int pos);
10341         __isl_give isl_schedule_node *
10342         isl_schedule_node_get_shared_ancestor(
10343                 __isl_keep isl_schedule_node *node1,
10344                 __isl_keep isl_schedule_node *node2);
10346 All nodes in a schedule tree or
10347 all descendants of a specific node (including the node) can be visited
10348 in depth-first pre-order using the following functions.
10350         #include <isl/schedule.h>
10351         isl_stat isl_schedule_foreach_schedule_node_top_down(
10352                 __isl_keep isl_schedule *sched,
10353                 isl_bool (*fn)(__isl_keep isl_schedule_node *node,
10354                         void *user), void *user);
10356         #include <isl/schedule_node.h>
10357         isl_stat isl_schedule_node_foreach_descendant_top_down(
10358                 __isl_keep isl_schedule_node *node,
10359                 isl_bool (*fn)(__isl_keep isl_schedule_node *node,
10360                         void *user), void *user);
10362 The callback function is slightly different from the usual
10363 callbacks in that it not only indicates success (non-negative result)
10364 or failure (negative result), but also indicates whether the children
10365 of the given node should be visited.  In particular, if the callback
10366 returns a positive value, then the children are visited, but if
10367 the callback returns zero, then the children are not visited.
10369 The following functions checks whether
10370 all descendants of a specific node (including the node itself)
10371 satisfy a user-specified test.
10373         #include <isl/schedule_node.h>
10374         isl_bool isl_schedule_node_every_descendant(
10375                 __isl_keep isl_schedule_node *node,
10376                 isl_bool (*test)(__isl_keep isl_schedule_node *node,
10377                         void *user), void *user)
10379 The ancestors of a node in a schedule tree can be visited from
10380 the root down to and including the parent of the node using
10381 the following function.
10383         #include <isl/schedule_node.h>
10384         isl_stat isl_schedule_node_foreach_ancestor_top_down(
10385                 __isl_keep isl_schedule_node *node,
10386                 isl_stat (*fn)(__isl_keep isl_schedule_node *node,
10387                         void *user), void *user);
10389 The following functions allows for a depth-first post-order
10390 traversal of the nodes in a schedule tree or
10391 of the descendants of a specific node (including the node
10392 itself), where the user callback is allowed to modify the
10393 visited node.
10395         #include <isl/schedule.h>
10396         __isl_give isl_schedule *
10397         isl_schedule_map_schedule_node_bottom_up(
10398                 __isl_take isl_schedule *schedule,
10399                 __isl_give isl_schedule_node *(*fn)(
10400                         __isl_take isl_schedule_node *node,
10401                         void *user), void *user);
10403         #include <isl/schedule_node.h>
10404         __isl_give isl_schedule_node *
10405         isl_schedule_node_map_descendant_bottom_up(
10406                 __isl_take isl_schedule_node *node,
10407                 __isl_give isl_schedule_node *(*fn)(
10408                         __isl_take isl_schedule_node *node,
10409                         void *user), void *user);
10411 The traversal continues from the node returned by the callback function.
10412 It is the responsibility of the user to ensure that this does not
10413 lead to an infinite loop.  It is safest to always return a pointer
10414 to the same position (same ancestors and child positions) as the input node.
10416 The following function removes a node (along with its descendants)
10417 from a schedule tree and returns a pointer to the leaf at the
10418 same position in the updated tree.
10419 It is not allowed to remove the root of a schedule tree or
10420 a child of a set or sequence node.
10422         #include <isl/schedule_node.h>
10423         __isl_give isl_schedule_node *isl_schedule_node_cut(
10424                 __isl_take isl_schedule_node *node);
10426 The following function removes a single node
10427 from a schedule tree and returns a pointer to the child
10428 of the node, now located at the position of the original node
10429 or to a leaf node at that position if there was no child.
10430 It is not allowed to remove the root of a schedule tree,
10431 a set or sequence node, a child of a set or sequence node or
10432 a band node with an anchored subtree.
10434         #include <isl/schedule_node.h>
10435         __isl_give isl_schedule_node *isl_schedule_node_delete(
10436                 __isl_take isl_schedule_node *node);
10438 Most nodes in a schedule tree only contain local information.
10439 In some cases, however, a node may also refer to the schedule dimensions
10440 of its outer band nodes.
10441 This means that the position of the node within the tree should
10442 not be changed, or at least that no changes are performed to the
10443 outer band nodes.  The following function can be used to test
10444 whether the subtree rooted at a given node contains any such nodes.
10446         #include <isl/schedule_node.h>
10447         isl_bool isl_schedule_node_is_subtree_anchored(
10448                 __isl_keep isl_schedule_node *node);
10450 The following function resets the user pointers on all parameter
10451 and tuple identifiers referenced by the given schedule node.
10453         #include <isl/schedule_node.h>
10454         __isl_give isl_schedule_node *isl_schedule_node_reset_user(
10455                 __isl_take isl_schedule_node *node);
10457 The following function aligns the parameters of the given schedule
10458 node to the given space.
10460         #include <isl/schedule_node.h>
10461         __isl_give isl_schedule_node *
10462         isl_schedule_node_align_params(
10463                 __isl_take isl_schedule_node *node,
10464                 __isl_take isl_space *space);
10466 Several node types have their own functions for querying
10467 (and in some cases setting) some node type specific properties.
10469         #include <isl/schedule_node.h>
10470         __isl_give isl_space *isl_schedule_node_band_get_space(
10471                 __isl_keep isl_schedule_node *node);
10472         __isl_give isl_multi_union_pw_aff *
10473         isl_schedule_node_band_get_partial_schedule(
10474                 __isl_keep isl_schedule_node *node);
10475         __isl_give isl_union_map *
10476         isl_schedule_node_band_get_partial_schedule_union_map(
10477                 __isl_keep isl_schedule_node *node);
10478         isl_size isl_schedule_node_band_n_member(
10479                 __isl_keep isl_schedule_node *node);
10480         isl_bool isl_schedule_node_band_member_get_coincident(
10481                 __isl_keep isl_schedule_node *node, int pos);
10482         __isl_give isl_schedule_node *
10483         isl_schedule_node_band_member_set_coincident(
10484                 __isl_take isl_schedule_node *node, int pos,
10485                 int coincident);
10486         isl_bool isl_schedule_node_band_get_permutable(
10487                 __isl_keep isl_schedule_node *node);
10488         __isl_give isl_schedule_node *
10489         isl_schedule_node_band_set_permutable(
10490                 __isl_take isl_schedule_node *node, int permutable);
10491         enum isl_ast_loop_type
10492         isl_schedule_node_band_member_get_ast_loop_type(
10493                 __isl_keep isl_schedule_node *node, int pos);
10494         __isl_give isl_schedule_node *
10495         isl_schedule_node_band_member_set_ast_loop_type(
10496                 __isl_take isl_schedule_node *node, int pos,
10497                 enum isl_ast_loop_type type);
10498         enum isl_ast_loop_type
10499         isl_schedule_node_band_member_get_isolate_ast_loop_type(
10500                 __isl_keep isl_schedule_node *node, int pos);
10501         __isl_give isl_schedule_node *
10502         isl_schedule_node_band_member_set_isolate_ast_loop_type(
10503                 __isl_take isl_schedule_node *node, int pos,
10504                 enum isl_ast_loop_type type);
10505         __isl_give isl_union_set *
10506         isl_schedule_node_band_get_ast_build_options(
10507                 __isl_keep isl_schedule_node *node);
10508         __isl_give isl_schedule_node *
10509         isl_schedule_node_band_set_ast_build_options(
10510                 __isl_take isl_schedule_node *node,
10511                 __isl_take isl_union_set *options);
10512         __isl_give isl_set *
10513         isl_schedule_node_band_get_ast_isolate_option(
10514                 __isl_keep isl_schedule_node *node);
10516 The function C<isl_schedule_node_band_get_space> returns the space
10517 of the partial schedule of the band.
10518 The function C<isl_schedule_node_band_get_partial_schedule_union_map>
10519 returns a representation of the partial schedule of the band node
10520 in the form of an C<isl_union_map>.
10521 The coincident and permutable properties are set by
10522 C<isl_schedule_constraints_compute_schedule> on the schedule tree
10523 it produces.
10524 A scheduling dimension is considered to be ``coincident''
10525 if it satisfies the coincidence constraints within its band.
10526 That is, if the dependence distances of the coincidence
10527 constraints are all zero in that direction (for fixed
10528 iterations of outer bands).
10529 A band is marked permutable if it was produced using the Pluto-like scheduler.
10530 Note that the scheduler may have to resort to a Feautrier style scheduling
10531 step even if the default scheduler is used.
10532 An C<isl_ast_loop_type> is one of C<isl_ast_loop_default>,
10533 C<isl_ast_loop_atomic>, C<isl_ast_loop_unroll> or C<isl_ast_loop_separate>.
10534 For the meaning of these loop AST generation types and the difference
10535 between the regular loop AST generation type and the isolate
10536 loop AST generation type, see L</"AST Generation Options (Schedule Tree)">.
10537 The functions C<isl_schedule_node_band_member_get_ast_loop_type>
10538 and C<isl_schedule_node_band_member_get_isolate_ast_loop_type>
10539 may return C<isl_ast_loop_error> if an error occurs.
10540 The AST build options govern how an AST is generated for
10541 the individual schedule dimensions during AST generation.
10542 See L</"AST Generation Options (Schedule Tree)">.
10543 The isolate option for the given node can be extracted from these
10544 AST build options using the function
10545 C<isl_schedule_node_band_get_ast_isolate_option>.
10547         #include <isl/schedule_node.h>
10548         __isl_give isl_set *
10549         isl_schedule_node_context_get_context(
10550                 __isl_keep isl_schedule_node *node);
10552         #include <isl/schedule_node.h>
10553         __isl_give isl_union_set *
10554         isl_schedule_node_domain_get_domain(
10555                 __isl_keep isl_schedule_node *node);
10557         #include <isl/schedule_node.h>
10558         __isl_give isl_union_map *
10559         isl_schedule_node_expansion_get_expansion(
10560                 __isl_keep isl_schedule_node *node);
10561         __isl_give isl_union_pw_multi_aff *
10562         isl_schedule_node_expansion_get_contraction(
10563                 __isl_keep isl_schedule_node *node);
10565         #include <isl/schedule_node.h>
10566         __isl_give isl_union_map *
10567         isl_schedule_node_extension_get_extension(
10568                 __isl_keep isl_schedule_node *node);
10570         #include <isl/schedule_node.h>
10571         __isl_give isl_union_set *
10572         isl_schedule_node_filter_get_filter(
10573                 __isl_keep isl_schedule_node *node);
10575         #include <isl/schedule_node.h>
10576         __isl_give isl_set *isl_schedule_node_guard_get_guard(
10577                 __isl_keep isl_schedule_node *node);
10579         #include <isl/schedule_node.h>
10580         __isl_give isl_id *isl_schedule_node_mark_get_id(
10581                 __isl_keep isl_schedule_node *node);
10583 The following functions can be used to obtain an C<isl_multi_union_pw_aff>,
10584 an C<isl_union_pw_multi_aff> or C<isl_union_map> representation of
10585 partial schedules related to the node.
10587         #include <isl/schedule_node.h>
10588         __isl_give isl_multi_union_pw_aff *
10589         isl_schedule_node_get_prefix_schedule_multi_union_pw_aff(
10590                 __isl_keep isl_schedule_node *node);
10591         __isl_give isl_union_pw_multi_aff *
10592         isl_schedule_node_get_prefix_schedule_union_pw_multi_aff(
10593                 __isl_keep isl_schedule_node *node);
10594         __isl_give isl_union_map *
10595         isl_schedule_node_get_prefix_schedule_union_map(
10596                 __isl_keep isl_schedule_node *node);
10597         __isl_give isl_union_map *
10598         isl_schedule_node_get_prefix_schedule_relation(
10599                 __isl_keep isl_schedule_node *node);
10600         __isl_give isl_union_map *
10601         isl_schedule_node_get_subtree_schedule_union_map(
10602                 __isl_keep isl_schedule_node *node);
10604 In particular, the functions
10605 C<isl_schedule_node_get_prefix_schedule_multi_union_pw_aff>,
10606 C<isl_schedule_node_get_prefix_schedule_union_pw_multi_aff>
10607 and C<isl_schedule_node_get_prefix_schedule_union_map>
10608 return a relative ordering on the domain elements that reach the given
10609 node determined by its ancestors.
10610 The function C<isl_schedule_node_get_prefix_schedule_relation>
10611 additionally includes the domain constraints in the result.
10612 The function C<isl_schedule_node_get_subtree_schedule_union_map>
10613 returns a representation of the partial schedule defined by the
10614 subtree rooted at the given node.
10615 If the tree contains any expansion nodes, then the subtree schedule
10616 is formulated in terms of the expanded domain elements.
10617 The tree passed to functions returning a prefix schedule
10618 may only contain extension nodes if these would not affect
10619 the result of these functions.  That is, if one of the ancestors
10620 is an extension node, then all of the domain elements that were
10621 added by the extension node need to have been filtered out
10622 by filter nodes between the extension node and the input node.
10623 The tree passed to C<isl_schedule_node_get_subtree_schedule_union_map>
10624 may not contain in extension nodes in the selected subtree.
10626 The expansion/contraction defined by an entire subtree, combining
10627 the expansions/contractions
10628 on the expansion nodes in the subtree, can be obtained using
10629 the following functions.
10631         #include <isl/schedule_node.h>
10632         __isl_give isl_union_map *
10633         isl_schedule_node_get_subtree_expansion(
10634                 __isl_keep isl_schedule_node *node);
10635         __isl_give isl_union_pw_multi_aff *
10636         isl_schedule_node_get_subtree_contraction(
10637                 __isl_keep isl_schedule_node *node);
10639 The total number of outer band members of given node, i.e.,
10640 the shared output dimension of the maps in the result
10641 of C<isl_schedule_node_get_prefix_schedule_union_map> can be obtained
10642 using the following function.
10644         #include <isl/schedule_node.h>
10645         isl_size isl_schedule_node_get_schedule_depth(
10646                 __isl_keep isl_schedule_node *node);
10648 The following functions return the elements that reach the given node
10649 or the union of universes in the spaces that contain these elements.
10651         #include <isl/schedule_node.h>
10652         __isl_give isl_union_set *
10653         isl_schedule_node_get_domain(
10654                 __isl_keep isl_schedule_node *node);
10655         __isl_give isl_union_set *
10656         isl_schedule_node_get_universe_domain(
10657                 __isl_keep isl_schedule_node *node);
10659 The input tree of C<isl_schedule_node_get_domain>
10660 may only contain extension nodes if these would not affect
10661 the result of this function.  That is, if one of the ancestors
10662 is an extension node, then all of the domain elements that were
10663 added by the extension node need to have been filtered out
10664 by filter nodes between the extension node and the input node.
10666 The following functions can be used to introduce additional nodes
10667 in the schedule tree.  The new node is introduced at the point
10668 in the tree where the C<isl_schedule_node> points to and
10669 the results points to the new node.
10671         #include <isl/schedule_node.h>
10672         __isl_give isl_schedule_node *
10673         isl_schedule_node_insert_partial_schedule(
10674                 __isl_take isl_schedule_node *node,
10675                 __isl_take isl_multi_union_pw_aff *schedule);
10677 This function inserts a new band node with (the greatest integer
10678 part of) the given partial schedule.
10679 The subtree rooted at the given node is assumed not to have
10680 any anchored nodes.
10682         #include <isl/schedule_node.h>
10683         __isl_give isl_schedule_node *
10684         isl_schedule_node_insert_context(
10685                 __isl_take isl_schedule_node *node,
10686                 __isl_take isl_set *context);
10688 This function inserts a new context node with the given context constraints.
10690         #include <isl/schedule_node.h>
10691         __isl_give isl_schedule_node *
10692         isl_schedule_node_insert_filter(
10693                 __isl_take isl_schedule_node *node,
10694                 __isl_take isl_union_set *filter);
10696 This function inserts a new filter node with the given filter.
10697 If the original node already pointed to a filter node, then the
10698 two filter nodes are merged into one.
10700         #include <isl/schedule_node.h>
10701         __isl_give isl_schedule_node *
10702         isl_schedule_node_insert_guard(
10703                 __isl_take isl_schedule_node *node,
10704                 __isl_take isl_set *guard);
10706 This function inserts a new guard node with the given guard constraints.
10708         #include <isl/schedule_node.h>
10709         __isl_give isl_schedule_node *
10710         isl_schedule_node_insert_mark(
10711                 __isl_take isl_schedule_node *node,
10712                 __isl_take isl_id *mark);
10714 This function inserts a new mark node with the give mark identifier.
10716         #include <isl/schedule_node.h>
10717         __isl_give isl_schedule_node *
10718         isl_schedule_node_insert_sequence(
10719                 __isl_take isl_schedule_node *node,
10720                 __isl_take isl_union_set_list *filters);
10721         __isl_give isl_schedule_node *
10722         isl_schedule_node_insert_set(
10723                 __isl_take isl_schedule_node *node,
10724                 __isl_take isl_union_set_list *filters);
10726 These functions insert a new sequence or set node with the given
10727 filters as children.
10729         #include <isl/schedule_node.h>
10730         __isl_give isl_schedule_node *isl_schedule_node_group(
10731                 __isl_take isl_schedule_node *node,
10732                 __isl_take isl_id *group_id);
10734 This function introduces an expansion node in between the current
10735 node and its parent that expands instances of a space with tuple
10736 identifier C<group_id> to the original domain elements that reach
10737 the node.  The group instances are identified by the prefix schedule
10738 of those domain elements.  The ancestors of the node are adjusted
10739 to refer to the group instances instead of the original domain
10740 elements.  The return value points to the same node in the updated
10741 schedule tree as the input node, i.e., to the child of the newly
10742 introduced expansion node.  Grouping instances of different statements
10743 ensures that they will be treated as a single statement by the
10744 AST generator up to the point of the expansion node.
10746 The following functions can be used to flatten a nested
10747 sequence.
10749         #include <isl/schedule_node.h>
10750         __isl_give isl_schedule_node *
10751         isl_schedule_node_sequence_splice_child(
10752                 __isl_take isl_schedule_node *node, int pos);
10753         __isl_give isl_schedule_node *
10754         isl_schedule_node_sequence_splice_children(
10755                 __isl_take isl_schedule_node *node);
10757 That is, given a sequence node C<node> that has another sequence node
10758 in its child at position C<pos> (in particular, the child of that filter
10759 node is a sequence node), the function
10760 C<isl_schedule_node_sequence_splice_child>
10761 attaches the children of that other sequence
10762 node as children of C<node>, replacing the original child at position
10763 C<pos>.
10764 C<isl_schedule_node_sequence_splice_children> does this for all
10765 such children.
10767 The partial schedule of a band node can be scaled (down) or reduced using
10768 the following functions.
10770         #include <isl/schedule_node.h>
10771         __isl_give isl_schedule_node *
10772         isl_schedule_node_band_scale(
10773                 __isl_take isl_schedule_node *node,
10774                 __isl_take isl_multi_val *mv);
10775         __isl_give isl_schedule_node *
10776         isl_schedule_node_band_scale_down(
10777                 __isl_take isl_schedule_node *node,
10778                 __isl_take isl_multi_val *mv);
10779         __isl_give isl_schedule_node *
10780         isl_schedule_node_band_mod(
10781                 __isl_take isl_schedule_node *node,
10782                 __isl_take isl_multi_val *mv);
10784 The spaces of the two arguments need to match.
10785 After scaling, the partial schedule is replaced by its greatest
10786 integer part to ensure that the schedule remains integral.
10788 The partial schedule of a band node can be shifted by an
10789 C<isl_multi_union_pw_aff> with a domain that is a superset
10790 of the domain of the partial schedule using
10791 the following function.
10793         #include <isl/schedule_node.h>
10794         __isl_give isl_schedule_node *
10795         isl_schedule_node_band_shift(
10796                 __isl_take isl_schedule_node *node,
10797                 __isl_take isl_multi_union_pw_aff *shift);
10799 A band node can be tiled using the following function.
10801         #include <isl/schedule_node.h>
10802         __isl_give isl_schedule_node *isl_schedule_node_band_tile(
10803                 __isl_take isl_schedule_node *node,
10804                 __isl_take isl_multi_val *sizes);
10806         isl_stat isl_options_set_tile_scale_tile_loops(isl_ctx *ctx,
10807                 int val);
10808         int isl_options_get_tile_scale_tile_loops(isl_ctx *ctx);
10809         isl_stat isl_options_set_tile_shift_point_loops(isl_ctx *ctx,
10810                 int val);
10811         int isl_options_get_tile_shift_point_loops(isl_ctx *ctx);
10813 The C<isl_schedule_node_band_tile> function tiles
10814 the band using the given tile sizes inside its schedule.
10815 A new child band node is created to represent the point loops and it is
10816 inserted between the modified band and its children.
10817 The subtree rooted at the given node is assumed not to have
10818 any anchored nodes.
10819 The C<tile_scale_tile_loops> option specifies whether the tile
10820 loops iterators should be scaled by the tile sizes.
10821 If the C<tile_shift_point_loops> option is set, then the point loops
10822 are shifted to start at zero.
10824 A band node can be split into two nested band nodes
10825 using the following function.
10827         #include <isl/schedule_node.h>
10828         __isl_give isl_schedule_node *isl_schedule_node_band_split(
10829                 __isl_take isl_schedule_node *node, int pos);
10831 The resulting outer band node contains the first C<pos> dimensions of
10832 the schedule of C<node> while the inner band contains the remaining dimensions.
10833 The schedules of the two band nodes live in anonymous spaces.
10834 The loop AST generation type options and the isolate option
10835 are split over the two band nodes.
10837 A band node can be moved down to the leaves of the subtree rooted
10838 at the band node using the following function.
10840         #include <isl/schedule_node.h>
10841         __isl_give isl_schedule_node *isl_schedule_node_band_sink(
10842                 __isl_take isl_schedule_node *node);
10844 The subtree rooted at the given node is assumed not to have
10845 any anchored nodes.
10846 The result points to the node in the resulting tree that is in the same
10847 position as the node pointed to by C<node> in the original tree.
10849         #include <isl/schedule_node.h>
10850         __isl_give isl_schedule_node *
10851         isl_schedule_node_order_before(
10852                 __isl_take isl_schedule_node *node,
10853                 __isl_take isl_union_set *filter);
10854         __isl_give isl_schedule_node *
10855         isl_schedule_node_order_after(
10856                 __isl_take isl_schedule_node *node,
10857                 __isl_take isl_union_set *filter);
10859 These functions split the domain elements that reach C<node>
10860 into those that satisfy C<filter> and those that do not and
10861 arranges for the elements that do satisfy the filter to be
10862 executed before (in case of C<isl_schedule_node_order_before>)
10863 or after (in case of C<isl_schedule_node_order_after>)
10864 those that do not.  The order is imposed by
10865 a sequence node, possibly reusing the grandparent of C<node>
10866 on two copies of the subtree attached to the original C<node>.
10867 Both copies are simplified with respect to their filter.
10869 Return a pointer to the copy of the subtree that does not
10870 satisfy C<filter>.  If there is no such copy (because all
10871 reaching domain elements satisfy the filter), then return
10872 the original pointer.
10874         #include <isl/schedule_node.h>
10875         __isl_give isl_schedule_node *
10876         isl_schedule_node_graft_before(
10877                 __isl_take isl_schedule_node *node,
10878                 __isl_take isl_schedule_node *graft);
10879         __isl_give isl_schedule_node *
10880         isl_schedule_node_graft_after(
10881                 __isl_take isl_schedule_node *node,
10882                 __isl_take isl_schedule_node *graft);
10884 This function inserts the C<graft> tree into the tree containing C<node>
10885 such that it is executed before (in case of C<isl_schedule_node_graft_before>)
10886 or after (in case of C<isl_schedule_node_graft_after>) C<node>.
10887 The root node of C<graft>
10888 should be an extension node where the domain of the extension
10889 is the flat product of all outer band nodes of C<node>.
10890 The root node may also be a domain node.
10891 The elements of the domain or the range of the extension may not
10892 intersect with the domain elements that reach "node".
10893 The schedule tree of C<graft> may not be anchored.
10895 The schedule tree of C<node> is modified to include an extension node
10896 corresponding to the root node of C<graft> as a child of the original
10897 parent of C<node>.  The original node that C<node> points to and the
10898 child of the root node of C<graft> are attached to this extension node
10899 through a sequence, with appropriate filters and with the child
10900 of C<graft> appearing before or after the original C<node>.
10902 If C<node> already appears inside a sequence that is the child of
10903 an extension node and if the spaces of the new domain elements
10904 do not overlap with those of the original domain elements,
10905 then that extension node is extended with the new extension
10906 rather than introducing a new segment of extension and sequence nodes.
10908 Return a pointer to the same node in the modified tree that
10909 C<node> pointed to in the original tree.
10911 A representation of the schedule node can be printed using
10913         #include <isl/schedule_node.h>
10914         __isl_give isl_printer *isl_printer_print_schedule_node(
10915                 __isl_take isl_printer *p,
10916                 __isl_keep isl_schedule_node *node);
10917         __isl_give char *isl_schedule_node_to_str(
10918                 __isl_keep isl_schedule_node *node);
10920 C<isl_schedule_node_to_str> prints the schedule node in block format.
10922 =head2 Dependence Analysis
10924 C<isl> contains specialized functionality for performing
10925 array dataflow analysis.  That is, given a I<sink> access relation,
10926 a collection of possible I<source> accesses and
10927 a collection of I<kill> accesses,
10928 C<isl> can compute relations that describe
10929 for each iteration of the sink access, which iterations
10930 of which of the source access relations may have
10931 accessed the same data element before the given iteration
10932 of the sink access without any intermediate kill of that data element.
10933 The resulting dependence relations map source iterations
10934 to either the corresponding sink iterations or
10935 pairs of corresponding sink iterations and accessed data elements.
10936 To compute standard flow dependences, the sink should be
10937 a read, while the sources should be writes.
10938 If no kills are specified,
10939 then memory based dependence analysis is performed.
10940 If, on the other hand, all sources are also kills,
10941 then value based dependence analysis is performed.
10942 If any of the source accesses are marked as being I<must>
10943 accesses, then they are also treated as kills.
10944 Furthermore, the specification of must-sources results
10945 in the computation of must-dependences.
10946 Only dependences originating in a must access not coscheduled
10947 with any other access to the same element and without
10948 any may accesses between the must access and the sink access
10949 are considered to be must dependences.
10951 =head3 High-level Interface
10953 A high-level interface to dependence analysis is provided
10954 by the following function.
10956         #include <isl/flow.h>
10957         __isl_give isl_union_flow *
10958         isl_union_access_info_compute_flow(
10959                 __isl_take isl_union_access_info *access);
10961 The input C<isl_union_access_info> object describes the sink
10962 access relations, the source access relations and a schedule,
10963 while the output C<isl_union_flow> object describes
10964 the resulting dependence relations and the subsets of the
10965 sink relations for which no source was found.
10967 An C<isl_union_access_info> is created, modified, copied and freed using
10968 the following functions.
10970         #include <isl/flow.h>
10971         __isl_give isl_union_access_info *
10972         isl_union_access_info_from_sink(
10973                 __isl_take isl_union_map *sink);
10974         __isl_give isl_union_access_info *
10975         isl_union_access_info_set_kill(
10976                 __isl_take isl_union_access_info *access,
10977                 __isl_take isl_union_map *kill);
10978         __isl_give isl_union_access_info *
10979         isl_union_access_info_set_may_source(
10980                 __isl_take isl_union_access_info *access,
10981                 __isl_take isl_union_map *may_source);
10982         __isl_give isl_union_access_info *
10983         isl_union_access_info_set_must_source(
10984                 __isl_take isl_union_access_info *access,
10985                 __isl_take isl_union_map *must_source);
10986         __isl_give isl_union_access_info *
10987         isl_union_access_info_set_schedule(
10988                 __isl_take isl_union_access_info *access,
10989                 __isl_take isl_schedule *schedule);
10990         __isl_give isl_union_access_info *
10991         isl_union_access_info_set_schedule_map(
10992                 __isl_take isl_union_access_info *access,
10993                 __isl_take isl_union_map *schedule_map);
10994         __isl_give isl_union_access_info *
10995         isl_union_access_info_copy(
10996                 __isl_keep isl_union_access_info *access);
10997         __isl_null isl_union_access_info *
10998         isl_union_access_info_free(
10999                 __isl_take isl_union_access_info *access);
11001 The may sources set by C<isl_union_access_info_set_may_source>
11002 do not need to include the must sources set by
11003 C<isl_union_access_info_set_must_source> as a subset.
11004 The kills set by C<isl_union_access_info_set_kill> may overlap
11005 with the may-sources and/or must-sources.
11006 The user is free not to call one (or more) of these functions,
11007 in which case the corresponding set is kept to its empty default.
11008 Similarly, the default schedule initialized by
11009 C<isl_union_access_info_from_sink> is empty.
11010 The current schedule is determined by the last call to either
11011 C<isl_union_access_info_set_schedule> or
11012 C<isl_union_access_info_set_schedule_map>.
11013 The domain of the schedule corresponds to the domains of
11014 the access relations.  In particular, the domains of the access
11015 relations are effectively intersected with the domain of the schedule
11016 and only the resulting accesses are considered by the dependence analysis.
11018 An C<isl_union_access_info> object can be read from input
11019 using the following function.
11021         #include <isl/flow.h>
11022         __isl_give isl_union_access_info *
11023         isl_union_access_info_read_from_file(isl_ctx *ctx,
11024                 FILE *input);
11026 A representation of the information contained in an object
11027 of type C<isl_union_access_info> can be obtained using
11029         #include <isl/flow.h>
11030         __isl_give isl_printer *
11031         isl_printer_print_union_access_info(
11032                 __isl_take isl_printer *p,
11033                 __isl_keep isl_union_access_info *access);
11034         __isl_give char *isl_union_access_info_to_str(
11035                 __isl_keep isl_union_access_info *access);
11037 C<isl_union_access_info_to_str> prints the information in flow format.
11039 The output of C<isl_union_access_info_compute_flow> can be examined,
11040 copied, and freed using the following functions.
11042         #include <isl/flow.h>
11043         __isl_give isl_union_map *isl_union_flow_get_must_dependence(
11044                 __isl_keep isl_union_flow *flow);
11045         __isl_give isl_union_map *isl_union_flow_get_may_dependence(
11046                 __isl_keep isl_union_flow *flow);
11047         __isl_give isl_union_map *
11048         isl_union_flow_get_full_must_dependence(
11049                 __isl_keep isl_union_flow *flow);
11050         __isl_give isl_union_map *
11051         isl_union_flow_get_full_may_dependence(
11052                 __isl_keep isl_union_flow *flow);
11053         __isl_give isl_union_map *isl_union_flow_get_must_no_source(
11054                 __isl_keep isl_union_flow *flow);
11055         __isl_give isl_union_map *isl_union_flow_get_may_no_source(
11056                 __isl_keep isl_union_flow *flow);
11057         __isl_give isl_union_flow *isl_union_flow_copy(
11058                 __isl_keep isl_union_flow *flow);
11059         __isl_null isl_union_flow *isl_union_flow_free(
11060                 __isl_take isl_union_flow *flow);
11062 The relation returned by C<isl_union_flow_get_must_dependence>
11063 relates domain elements of must sources to domain elements of the sink.
11064 The relation returned by C<isl_union_flow_get_may_dependence>
11065 relates domain elements of must or may sources to domain elements of the sink
11066 and includes the previous relation as a subset.
11067 The relation returned by C<isl_union_flow_get_full_must_dependence>
11068 relates domain elements of must sources to pairs of domain elements of the sink
11069 and accessed data elements.
11070 The relation returned by C<isl_union_flow_get_full_may_dependence>
11071 relates domain elements of must or may sources to pairs of
11072 domain elements of the sink and accessed data elements.
11073 This relation includes the previous relation as a subset.
11074 The relation returned by C<isl_union_flow_get_must_no_source> is the subset
11075 of the sink relation for which no dependences have been found.
11076 The relation returned by C<isl_union_flow_get_may_no_source> is the subset
11077 of the sink relation for which no definite dependences have been found.
11078 That is, it contains those sink access that do not contribute to any
11079 of the elements in the relation returned
11080 by C<isl_union_flow_get_must_dependence>.
11082 A representation of the information contained in an object
11083 of type C<isl_union_flow> can be obtained using
11085         #include <isl/flow.h>
11086         __isl_give isl_printer *isl_printer_print_union_flow(
11087                 __isl_take isl_printer *p,
11088                 __isl_keep isl_union_flow *flow);
11089         __isl_give char *isl_union_flow_to_str(
11090                 __isl_keep isl_union_flow *flow);
11092 C<isl_union_flow_to_str> prints the information in flow format.
11094 =head3 Low-level Interface
11096 A lower-level interface is provided by the following functions.
11098         #include <isl/flow.h>
11100         typedef int (*isl_access_level_before)(void *first, void *second);
11102         __isl_give isl_access_info *isl_access_info_alloc(
11103                 __isl_take isl_map *sink,
11104                 void *sink_user, isl_access_level_before fn,
11105                 int max_source);
11106         __isl_give isl_access_info *isl_access_info_add_source(
11107                 __isl_take isl_access_info *acc,
11108                 __isl_take isl_map *source, int must,
11109                 void *source_user);
11110         __isl_null isl_access_info *isl_access_info_free(
11111                 __isl_take isl_access_info *acc);
11113         __isl_give isl_flow *isl_access_info_compute_flow(
11114                 __isl_take isl_access_info *acc);
11116         isl_stat isl_flow_foreach(__isl_keep isl_flow *deps,
11117                 isl_stat (*fn)(__isl_take isl_map *dep, int must,
11118                           void *dep_user, void *user),
11119                 void *user);
11120         __isl_give isl_map *isl_flow_get_no_source(
11121                 __isl_keep isl_flow *deps, int must);
11122         __isl_null isl_flow *isl_flow_free(
11123                 __isl_take isl_flow *deps);
11125 The function C<isl_access_info_compute_flow> performs the actual
11126 dependence analysis.  The other functions are used to construct
11127 the input for this function or to read off the output.
11129 The input is collected in an C<isl_access_info>, which can
11130 be created through a call to C<isl_access_info_alloc>.
11131 The arguments to this functions are the sink access relation
11132 C<sink>, a token C<sink_user> used to identify the sink
11133 access to the user, a callback function for specifying the
11134 relative order of source and sink accesses, and the number
11135 of source access relations that will be added.
11137 The callback function has type C<int (*)(void *first, void *second)>.
11138 The function is called with two user supplied tokens identifying
11139 either a source or the sink and it should return the shared nesting
11140 level and the relative order of the two accesses.
11141 In particular, let I<n> be the number of loops shared by
11142 the two accesses.  If C<first> precedes C<second> textually,
11143 then the function should return I<2 * n + 1>; otherwise,
11144 it should return I<2 * n>.
11145 The low-level interface assumes that no sources are coscheduled.
11146 If the information returned by the callback does not allow
11147 the relative order to be determined, then one of the sources
11148 is arbitrarily taken to be executed after the other(s).
11150 The sources can be added to the C<isl_access_info> object by performing
11151 (at most) C<max_source> calls to C<isl_access_info_add_source>.
11152 C<must> indicates whether the source is a I<must> access
11153 or a I<may> access.  Note that a multi-valued access relation
11154 should only be marked I<must> if every iteration in the domain
11155 of the relation accesses I<all> elements in its image.
11156 The C<source_user> token is again used to identify
11157 the source access.  The range of the source access relation
11158 C<source> should have the same dimension as the range
11159 of the sink access relation.
11160 The C<isl_access_info_free> function should usually not be
11161 called explicitly, because it is already called implicitly by
11162 C<isl_access_info_compute_flow>.
11164 The result of the dependence analysis is collected in an
11165 C<isl_flow>.  There may be elements of
11166 the sink access for which no preceding source access could be
11167 found or for which all preceding sources are I<may> accesses.
11168 The relations containing these elements can be obtained through
11169 calls to C<isl_flow_get_no_source>, the first with C<must> set
11170 and the second with C<must> unset.
11171 In the case of standard flow dependence analysis,
11172 with the sink a read and the sources I<must> writes,
11173 the first relation corresponds to the reads from uninitialized
11174 array elements and the second relation is empty.
11175 The actual flow dependences can be extracted using
11176 C<isl_flow_foreach>.  This function will call the user-specified
11177 callback function C<fn> for each B<non-empty> dependence between
11178 a source and the sink.  The callback function is called
11179 with four arguments, the actual flow dependence relation
11180 mapping source iterations to sink iterations, a boolean that
11181 indicates whether it is a I<must> or I<may> dependence, a token
11182 identifying the source and an additional C<void *> with value
11183 equal to the third argument of the C<isl_flow_foreach> call.
11184 A dependence is marked I<must> if it originates from a I<must>
11185 source and if it is not followed by any I<may> sources.
11187 After finishing with an C<isl_flow>, the user should call
11188 C<isl_flow_free> to free all associated memory.
11190 =head3 Interaction with the Low-level Interface
11192 During the dependence analysis, we frequently need to perform
11193 the following operation.  Given a relation between sink iterations
11194 and potential source iterations from a particular source domain,
11195 what is the last potential source iteration corresponding to each
11196 sink iteration.  It can sometimes be convenient to adjust
11197 the set of potential source iterations before or after each such operation.
11198 The prototypical example is fuzzy array dataflow analysis,
11199 where we need to analyze if, based on data-dependent constraints,
11200 the sink iteration can ever be executed without one or more of
11201 the corresponding potential source iterations being executed.
11202 If so, we can introduce extra parameters and select an unknown
11203 but fixed source iteration from the potential source iterations.
11204 To be able to perform such manipulations, C<isl> provides the following
11205 function.
11207         #include <isl/flow.h>
11209         typedef __isl_give isl_restriction *(*isl_access_restrict)(
11210                 __isl_keep isl_map *source_map,
11211                 __isl_keep isl_set *sink, void *source_user,
11212                 void *user);
11213         __isl_give isl_access_info *isl_access_info_set_restrict(
11214                 __isl_take isl_access_info *acc,
11215                 isl_access_restrict fn, void *user);
11217 The function C<isl_access_info_set_restrict> should be called
11218 before calling C<isl_access_info_compute_flow> and registers a callback function
11219 that will be called any time C<isl> is about to compute the last
11220 potential source.  The first argument is the (reverse) proto-dependence,
11221 mapping sink iterations to potential source iterations.
11222 The second argument represents the sink iterations for which
11223 we want to compute the last source iteration.
11224 The third argument is the token corresponding to the source
11225 and the final argument is the token passed to C<isl_access_info_set_restrict>.
11226 The callback is expected to return a restriction on either the input or
11227 the output of the operation computing the last potential source.
11228 If the input needs to be restricted then restrictions are needed
11229 for both the source and the sink iterations.  The sink iterations
11230 and the potential source iterations will be intersected with these sets.
11231 If the output needs to be restricted then only a restriction on the source
11232 iterations is required.
11233 If any error occurs, the callback should return C<NULL>.
11234 An C<isl_restriction> object can be created, freed and inspected
11235 using the following functions.
11237         #include <isl/flow.h>
11239         __isl_give isl_restriction *isl_restriction_input(
11240                 __isl_take isl_set *source_restr,
11241                 __isl_take isl_set *sink_restr);
11242         __isl_give isl_restriction *isl_restriction_output(
11243                 __isl_take isl_set *source_restr);
11244         __isl_give isl_restriction *isl_restriction_none(
11245                 __isl_take isl_map *source_map);
11246         __isl_give isl_restriction *isl_restriction_empty(
11247                 __isl_take isl_map *source_map);
11248         __isl_null isl_restriction *isl_restriction_free(
11249                 __isl_take isl_restriction *restr);
11251 C<isl_restriction_none> and C<isl_restriction_empty> are special
11252 cases of C<isl_restriction_input>.  C<isl_restriction_none>
11253 is essentially equivalent to
11255         isl_restriction_input(isl_set_universe(
11256             isl_space_range(isl_map_get_space(source_map))),
11257                             isl_set_universe(
11258             isl_space_domain(isl_map_get_space(source_map))));
11260 whereas C<isl_restriction_empty> is essentially equivalent to
11262         isl_restriction_input(isl_set_empty(
11263             isl_space_range(isl_map_get_space(source_map))),
11264                             isl_set_universe(
11265             isl_space_domain(isl_map_get_space(source_map))));
11267 =head2 Scheduling
11269         #include <isl/schedule.h>
11270         __isl_give isl_schedule *
11271         isl_schedule_constraints_compute_schedule(
11272                 __isl_take isl_schedule_constraints *sc);
11274 The function C<isl_schedule_constraints_compute_schedule> can be
11275 used to compute a schedule that satisfies the given schedule constraints.
11276 These schedule constraints include the iteration domain for which
11277 a schedule should be computed and dependences between pairs of
11278 iterations.  In particular, these dependences include
11279 I<validity> dependences and I<proximity> dependences.
11280 By default, the algorithm used to construct the schedule is similar
11281 to that of C<Pluto>.
11282 Alternatively, Feautrier's multi-dimensional scheduling algorithm can
11283 be selected.
11284 The generated schedule respects all validity dependences.
11285 That is, all dependence distances over these dependences in the
11286 scheduled space are lexicographically positive.
11288 The default algorithm tries to ensure that the dependence distances
11289 over coincidence constraints are zero and to minimize the
11290 dependence distances over proximity dependences.
11291 Moreover, it tries to obtain sequences (bands) of schedule dimensions
11292 for groups of domains where the dependence distances over validity
11293 dependences have only non-negative values.
11294 Note that when minimizing the maximal dependence distance
11295 over proximity dependences, a single affine expression in the parameters
11296 is constructed that bounds all dependence distances.  If no such expression
11297 exists, then the algorithm will fail and resort to an alternative
11298 scheduling algorithm.  In particular, this means that adding proximity
11299 dependences may eliminate valid solutions.  A typical example where this
11300 phenomenon may occur is when some subset of the proximity dependences
11301 has no restriction on some parameter, forcing the coefficient of that
11302 parameter to be zero, while some other subset forces the dependence
11303 distance to depend on that parameter, requiring the same coefficient
11304 to be non-zero.
11305 When using Feautrier's algorithm, the coincidence and proximity constraints
11306 are only taken into account during the extension to a
11307 full-dimensional schedule.
11309 An C<isl_schedule_constraints> object can be constructed
11310 and manipulated using the following functions.
11312         #include <isl/schedule.h>
11313         __isl_give isl_schedule_constraints *
11314         isl_schedule_constraints_copy(
11315                 __isl_keep isl_schedule_constraints *sc);
11316         __isl_give isl_schedule_constraints *
11317         isl_schedule_constraints_on_domain(
11318                 __isl_take isl_union_set *domain);
11319         __isl_give isl_schedule_constraints *
11320         isl_schedule_constraints_set_context(
11321                 __isl_take isl_schedule_constraints *sc,
11322                 __isl_take isl_set *context);
11323         __isl_give isl_schedule_constraints *
11324         isl_schedule_constraints_set_validity(
11325                 __isl_take isl_schedule_constraints *sc,
11326                 __isl_take isl_union_map *validity);
11327         __isl_give isl_schedule_constraints *
11328         isl_schedule_constraints_set_coincidence(
11329                 __isl_take isl_schedule_constraints *sc,
11330                 __isl_take isl_union_map *coincidence);
11331         __isl_give isl_schedule_constraints *
11332         isl_schedule_constraints_set_proximity(
11333                 __isl_take isl_schedule_constraints *sc,
11334                 __isl_take isl_union_map *proximity);
11335         __isl_give isl_schedule_constraints *
11336         isl_schedule_constraints_set_conditional_validity(
11337                 __isl_take isl_schedule_constraints *sc,
11338                 __isl_take isl_union_map *condition,
11339                 __isl_take isl_union_map *validity);
11340         __isl_give isl_schedule_constraints *
11341         isl_schedule_constraints_apply(
11342                 __isl_take isl_schedule_constraints *sc,
11343                 __isl_take isl_union_map *umap);
11344         __isl_null isl_schedule_constraints *
11345         isl_schedule_constraints_free(
11346                 __isl_take isl_schedule_constraints *sc);
11348 The initial C<isl_schedule_constraints> object created by
11349 C<isl_schedule_constraints_on_domain> does not impose any constraints.
11350 That is, it has an empty set of dependences.
11351 The function C<isl_schedule_constraints_set_context> allows the user
11352 to specify additional constraints on the parameters that may
11353 be assumed to hold during the construction of the schedule.
11354 The function C<isl_schedule_constraints_set_validity> replaces the
11355 validity dependences, mapping domain elements I<i> to domain
11356 elements that should be scheduled after I<i>.
11357 The function C<isl_schedule_constraints_set_coincidence> replaces the
11358 coincidence dependences, mapping domain elements I<i> to domain
11359 elements that should be scheduled together with I<I>, if possible.
11360 The function C<isl_schedule_constraints_set_proximity> replaces the
11361 proximity dependences, mapping domain elements I<i> to domain
11362 elements that should be scheduled either before I<I>
11363 or as early as possible after I<i>.
11365 The function C<isl_schedule_constraints_set_conditional_validity>
11366 replaces the conditional validity constraints.
11367 A conditional validity constraint is only imposed when any of the corresponding
11368 conditions is satisfied, i.e., when any of them is non-zero.
11369 That is, the scheduler ensures that within each band if the dependence
11370 distances over the condition constraints are not all zero
11371 then all corresponding conditional validity constraints are respected.
11372 A conditional validity constraint corresponds to a condition
11373 if the two are adjacent, i.e., if the domain of one relation intersect
11374 the range of the other relation.
11375 The typical use case of conditional validity constraints is
11376 to allow order constraints between live ranges to be violated
11377 as long as the live ranges themselves are local to the band.
11378 To allow more fine-grained control over which conditions correspond
11379 to which conditional validity constraints, the domains and ranges
11380 of these relations may include I<tags>.  That is, the domains and
11381 ranges of those relation may themselves be wrapped relations
11382 where the iteration domain appears in the domain of those wrapped relations
11383 and the range of the wrapped relations can be arbitrarily chosen
11384 by the user.  Conditions and conditional validity constraints are only
11385 considered adjacent to each other if the entire wrapped relation matches.
11386 In particular, a relation with a tag will never be considered adjacent
11387 to a relation without a tag.
11389 The function C<isl_schedule_constraints_apply> takes
11390 schedule constraints that are defined on some set of domain elements
11391 and transforms them to schedule constraints on the elements
11392 to which these domain elements are mapped by the given transformation.
11394 An C<isl_schedule_constraints> object can be inspected
11395 using the following functions.
11397         #include <isl/schedule.h>
11398         __isl_give isl_union_set *
11399         isl_schedule_constraints_get_domain(
11400                 __isl_keep isl_schedule_constraints *sc);
11401         __isl_give isl_set *isl_schedule_constraints_get_context(
11402                 __isl_keep isl_schedule_constraints *sc);
11403         __isl_give isl_union_map *
11404         isl_schedule_constraints_get_validity(
11405                 __isl_keep isl_schedule_constraints *sc);
11406         __isl_give isl_union_map *
11407         isl_schedule_constraints_get_coincidence(
11408                 __isl_keep isl_schedule_constraints *sc);
11409         __isl_give isl_union_map *
11410         isl_schedule_constraints_get_proximity(
11411                 __isl_keep isl_schedule_constraints *sc);
11412         __isl_give isl_union_map *
11413         isl_schedule_constraints_get_conditional_validity(
11414                 __isl_keep isl_schedule_constraints *sc);
11415         __isl_give isl_union_map *
11416         isl_schedule_constraints_get_conditional_validity_condition(
11417                 __isl_keep isl_schedule_constraints *sc);
11419 An C<isl_schedule_constraints> object can be read from input
11420 using the following functions.
11422         #include <isl/schedule.h>
11423         __isl_give isl_schedule_constraints *
11424         isl_schedule_constraints_read_from_str(isl_ctx *ctx,
11425                 const char *str);
11426         __isl_give isl_schedule_constraints *
11427         isl_schedule_constraints_read_from_file(isl_ctx *ctx,
11428                 FILE *input);
11430 The contents of an C<isl_schedule_constraints> object can be printed
11431 using the following functions.
11433         #include <isl/schedule.h>
11434         __isl_give isl_printer *
11435         isl_printer_print_schedule_constraints(
11436                 __isl_take isl_printer *p,
11437                 __isl_keep isl_schedule_constraints *sc);
11438         __isl_give char *isl_schedule_constraints_to_str(
11439                 __isl_keep isl_schedule_constraints *sc);
11441 The following function computes a schedule directly from
11442 an iteration domain and validity and proximity dependences
11443 and is implemented in terms of the functions described above.
11444 The use of C<isl_union_set_compute_schedule> is discouraged.
11446         #include <isl/schedule.h>
11447         __isl_give isl_schedule *isl_union_set_compute_schedule(
11448                 __isl_take isl_union_set *domain,
11449                 __isl_take isl_union_map *validity,
11450                 __isl_take isl_union_map *proximity);
11452 The generated schedule represents a schedule tree.
11453 For more information on schedule trees, see
11454 L</"Schedule Trees">.
11456 =head3 Options
11458         #include <isl/schedule.h>
11459         isl_stat isl_options_set_schedule_max_coefficient(
11460                 isl_ctx *ctx, int val);
11461         int isl_options_get_schedule_max_coefficient(
11462                 isl_ctx *ctx);
11463         isl_stat isl_options_set_schedule_max_constant_term(
11464                 isl_ctx *ctx, int val);
11465         int isl_options_get_schedule_max_constant_term(
11466                 isl_ctx *ctx);
11467         isl_stat isl_options_set_schedule_serialize_sccs(
11468                 isl_ctx *ctx, int val);
11469         int isl_options_get_schedule_serialize_sccs(isl_ctx *ctx);
11470         isl_stat isl_options_set_schedule_whole_component(
11471                 isl_ctx *ctx, int val);
11472         int isl_options_get_schedule_whole_component(
11473                 isl_ctx *ctx);
11474         isl_stat isl_options_set_schedule_maximize_band_depth(
11475                 isl_ctx *ctx, int val);
11476         int isl_options_get_schedule_maximize_band_depth(
11477                 isl_ctx *ctx);
11478         isl_stat isl_options_set_schedule_maximize_coincidence(
11479                 isl_ctx *ctx, int val);
11480         int isl_options_get_schedule_maximize_coincidence(
11481                 isl_ctx *ctx);
11482         isl_stat isl_options_set_schedule_outer_coincidence(
11483                 isl_ctx *ctx, int val);
11484         int isl_options_get_schedule_outer_coincidence(
11485                 isl_ctx *ctx);
11486         isl_stat isl_options_set_schedule_split_scaled(
11487                 isl_ctx *ctx, int val);
11488         int isl_options_get_schedule_split_scaled(
11489                 isl_ctx *ctx);
11490         isl_stat isl_options_set_schedule_treat_coalescing(
11491                 isl_ctx *ctx, int val);
11492         int isl_options_get_schedule_treat_coalescing(
11493                 isl_ctx *ctx);
11494         isl_stat isl_options_set_schedule_algorithm(
11495                 isl_ctx *ctx, int val);
11496         int isl_options_get_schedule_algorithm(
11497                 isl_ctx *ctx);
11498         isl_stat isl_options_set_schedule_carry_self_first(
11499                 isl_ctx *ctx, int val);
11500         int isl_options_get_schedule_carry_self_first(
11501                 isl_ctx *ctx);
11502         isl_stat isl_options_set_schedule_separate_components(
11503                 isl_ctx *ctx, int val);
11504         int isl_options_get_schedule_separate_components(
11505                 isl_ctx *ctx);
11507 =over
11509 =item * schedule_max_coefficient
11511 This option enforces that the coefficients for variable and parameter
11512 dimensions in the calculated schedule are not larger than the specified value.
11513 This option can significantly increase the speed of the scheduling calculation
11514 and may also prevent fusing of unrelated dimensions. A value of -1 means that
11515 this option does not introduce bounds on the variable or parameter
11516 coefficients.
11517 This option has no effect on the Feautrier style scheduler.
11519 =item * schedule_max_constant_term
11521 This option enforces that the constant coefficients in the calculated schedule
11522 are not larger than the maximal constant term. This option can significantly
11523 increase the speed of the scheduling calculation and may also prevent fusing of
11524 unrelated dimensions. A value of -1 means that this option does not introduce
11525 bounds on the constant coefficients.
11527 =item * schedule_serialize_sccs
11529 If this option is set, then all strongly connected components
11530 in the dependence graph are serialized as soon as they are detected.
11531 This means in particular that instances of statements will only
11532 appear in the same band node if these statements belong
11533 to the same strongly connected component at the point where
11534 the band node is constructed.
11536 =item * schedule_whole_component
11538 If this option is set, then entire (weakly) connected
11539 components in the dependence graph are scheduled together
11540 as a whole.
11541 Otherwise, each strongly connected component within
11542 such a weakly connected component is first scheduled separately
11543 and then combined with other strongly connected components.
11544 This option has no effect if C<schedule_serialize_sccs> is set.
11546 =item * schedule_maximize_band_depth
11548 If this option is set, then the scheduler tries to maximize
11549 the width of the bands.  Wider bands give more possibilities for tiling.
11550 In particular, if the C<schedule_whole_component> option is set,
11551 then bands are split if this might result in wider bands.
11552 Otherwise, the effect of this option is to only allow
11553 strongly connected components to be combined if this does
11554 not reduce the width of the bands.
11555 Note that if the C<schedule_serialize_sccs> options is set, then
11556 the C<schedule_maximize_band_depth> option therefore has no effect.
11558 =item * schedule_maximize_coincidence
11560 This option is only effective if the C<schedule_whole_component>
11561 option is turned off.
11562 If the C<schedule_maximize_coincidence> option is set, then (clusters of)
11563 strongly connected components are only combined with each other
11564 if this does not reduce the number of coincident band members.
11566 =item * schedule_outer_coincidence
11568 If this option is set, then we try to construct schedules
11569 where the outermost scheduling dimension in each band
11570 satisfies the coincidence constraints.
11572 =item * schedule_algorithm
11574 Selects the scheduling algorithm to be used.
11575 Available scheduling algorithms are C<ISL_SCHEDULE_ALGORITHM_ISL>
11576 and C<ISL_SCHEDULE_ALGORITHM_FEAUTRIER>.
11578 =item * schedule_split_scaled
11580 If this option is set, then we try to construct schedules in which the
11581 constant term is split off from the linear part if the linear parts of
11582 the scheduling rows for all nodes in the graph have a common non-trivial
11583 divisor.
11584 The constant term is then dropped and the linear
11585 part is reduced.
11586 This option is only effective when the Feautrier style scheduler is
11587 being used, either as the main scheduler or as a fallback for the
11588 Pluto-like scheduler.
11590 =item * schedule_treat_coalescing
11592 If this option is set, then the scheduler will try and avoid
11593 producing schedules that perform loop coalescing.
11594 In particular, for the Pluto-like scheduler, this option places
11595 bounds on the schedule coefficients based on the sizes of the instance sets.
11596 For the Feautrier style scheduler, this option detects potentially
11597 coalescing schedules and then tries to adjust the schedule to avoid
11598 the coalescing.
11600 =item * schedule_carry_self_first
11602 If this option is set, then the Feautrier style scheduler
11603 (when used as a fallback for the Pluto-like scheduler) will
11604 first try to only carry self-dependences.
11606 =item * schedule_separate_components
11608 If this option is set then the function C<isl_schedule_get_map>
11609 will treat set nodes in the same way as sequence nodes.
11611 =back
11613 =head2 AST Generation
11615 This section describes the C<isl> functionality for generating
11616 ASTs that visit all the elements
11617 in a domain in an order specified by a schedule tree or
11618 a schedule map.
11619 In case the schedule given as a C<isl_union_map>, an AST is generated
11620 that visits all the elements in the domain of the C<isl_union_map>
11621 according to the lexicographic order of the corresponding image
11622 element(s).  If the range of the C<isl_union_map> consists of
11623 elements in more than one space, then each of these spaces is handled
11624 separately in an arbitrary order.
11625 It should be noted that the schedule tree or the image elements
11626 in a schedule map only specify the I<order>
11627 in which the corresponding domain elements should be visited.
11628 No direct relation between the partial schedule values
11629 or the image elements on the one hand and the loop iterators
11630 in the generated AST on the other hand should be assumed.
11632 Each AST is generated within a build.  The initial build
11633 simply specifies the constraints on the parameters (if any)
11634 and can be created, inspected, copied and freed using the following functions.
11636         #include <isl/ast_build.h>
11637         __isl_give isl_ast_build *isl_ast_build_alloc(
11638                 isl_ctx *ctx);
11639         __isl_give isl_ast_build *isl_ast_build_from_context(
11640                 __isl_take isl_set *set);
11641         __isl_give isl_ast_build *isl_ast_build_copy(
11642                 __isl_keep isl_ast_build *build);
11643         __isl_null isl_ast_build *isl_ast_build_free(
11644                 __isl_take isl_ast_build *build);
11646 The C<set> argument is usually a parameter set with zero or more parameters.
11647 In fact, when creating an AST using C<isl_ast_build_node_from_schedule>,
11648 this set is required to be a parameter set.
11649 An C<isl_ast_build> created using C<isl_ast_build_alloc> does not
11650 specify any parameter constraints.
11651 More C<isl_ast_build> functions are described in L</"Nested AST Generation">
11652 and L</"Fine-grained Control over AST Generation">.
11653 Finally, the AST itself can be constructed using one of the following
11654 functions.
11656         #include <isl/ast_build.h>
11657         __isl_give isl_ast_node *isl_ast_build_node_from_schedule(
11658                 __isl_keep isl_ast_build *build,
11659                 __isl_take isl_schedule *schedule);
11660         __isl_give isl_ast_node *
11661         isl_ast_build_node_from_schedule_map(
11662                 __isl_keep isl_ast_build *build,
11663                 __isl_take isl_union_map *schedule);
11665 =head3 Inspecting the AST
11667 The basic properties of an AST node can be obtained as follows.
11669         #include <isl/ast.h>
11670         enum isl_ast_node_type isl_ast_node_get_type(
11671                 __isl_keep isl_ast_node *node);
11673 The type of an AST node is one of
11674 C<isl_ast_node_for>,
11675 C<isl_ast_node_if>,
11676 C<isl_ast_node_block>,
11677 C<isl_ast_node_mark> or
11678 C<isl_ast_node_user>.
11679 An C<isl_ast_node_for> represents a for node.
11680 An C<isl_ast_node_if> represents an if node.
11681 An C<isl_ast_node_block> represents a compound node.
11682 An C<isl_ast_node_mark> introduces a mark in the AST.
11683 An C<isl_ast_node_user> represents an expression statement.
11684 An expression statement typically corresponds to a domain element, i.e.,
11685 one of the elements that is visited by the AST.
11687 Each type of node has its own additional properties.
11689         #include <isl/ast.h>
11690         __isl_give isl_ast_expr *isl_ast_node_for_get_iterator(
11691                 __isl_keep isl_ast_node *node);
11692         __isl_give isl_ast_expr *isl_ast_node_for_get_init(
11693                 __isl_keep isl_ast_node *node);
11694         __isl_give isl_ast_expr *isl_ast_node_for_get_cond(
11695                 __isl_keep isl_ast_node *node);
11696         __isl_give isl_ast_expr *isl_ast_node_for_get_inc(
11697                 __isl_keep isl_ast_node *node);
11698         __isl_give isl_ast_node *isl_ast_node_for_get_body(
11699                 __isl_keep isl_ast_node *node);
11700         isl_bool isl_ast_node_for_is_degenerate(
11701                 __isl_keep isl_ast_node *node);
11703 An C<isl_ast_for> is considered degenerate if it is known to execute
11704 exactly once.
11706         #include <isl/ast.h>
11707         __isl_give isl_ast_expr *isl_ast_node_if_get_cond(
11708                 __isl_keep isl_ast_node *node);
11709         __isl_give isl_ast_node *isl_ast_node_if_get_then_node(
11710                 __isl_keep isl_ast_node *node);
11711         __isl_give isl_ast_node *isl_ast_node_if_get_then(
11712                 __isl_keep isl_ast_node *node);
11713         isl_bool isl_ast_node_if_has_else_node(
11714                 __isl_keep isl_ast_node *node);
11715         isl_bool isl_ast_node_if_has_else(
11716                 __isl_keep isl_ast_node *node);
11717         __isl_give isl_ast_node *isl_ast_node_if_get_else_node(
11718                 __isl_keep isl_ast_node *node);
11719         __isl_give isl_ast_node *isl_ast_node_if_get_else(
11720                 __isl_keep isl_ast_node *node);
11722 C<isl_ast_node_if_get_then>,
11723 C<isl_ast_node_if_has_else> and
11724 C<isl_ast_node_if_get_else>
11725 are alternative names for
11726 C<isl_ast_node_if_get_then_node>,
11727 C<isl_ast_node_if_has_else_node> and
11728 C<isl_ast_node_if_get_else_node>, respectively.
11730         __isl_give isl_ast_node_list *
11731         isl_ast_node_block_get_children(
11732                 __isl_keep isl_ast_node *node);
11734         __isl_give isl_id *isl_ast_node_mark_get_id(
11735                 __isl_keep isl_ast_node *node);
11736         __isl_give isl_ast_node *isl_ast_node_mark_get_node(
11737                 __isl_keep isl_ast_node *node);
11739 C<isl_ast_node_mark_get_id> returns the identifier of the mark.
11740 C<isl_ast_node_mark_get_node> returns the child node that is being marked.
11742         #include <isl/ast.h>
11743         __isl_give isl_ast_expr *isl_ast_node_user_get_expr(
11744                 __isl_keep isl_ast_node *node);
11746 All descendants of a specific node in the AST (including the node itself)
11747 can be visited
11748 in depth-first pre-order using the following function.
11750         #include <isl/ast.h>
11751         isl_stat isl_ast_node_foreach_descendant_top_down(
11752                 __isl_keep isl_ast_node *node,
11753                 isl_bool (*fn)(__isl_keep isl_ast_node *node,
11754                         void *user), void *user);
11756 The callback function should return C<isl_bool_true> if the children
11757 of the given node should be visited and C<isl_bool_false> if they should not.
11758 It should return C<isl_bool_error> in case of failure, in which case
11759 the entire traversal is aborted.
11761 Each of the returned C<isl_ast_expr>s can in turn be inspected using
11762 the following functions.
11764         #include <isl/ast.h>
11765         enum isl_ast_expr_type isl_ast_expr_get_type(
11766                 __isl_keep isl_ast_expr *expr);
11768 The type of an AST expression is one of
11769 C<isl_ast_expr_op>,
11770 C<isl_ast_expr_id> or
11771 C<isl_ast_expr_int>.
11772 An C<isl_ast_expr_op> represents the result of an operation.
11773 An C<isl_ast_expr_id> represents an identifier.
11774 An C<isl_ast_expr_int> represents an integer value.
11776 Each type of expression has its own additional properties.
11778         #include <isl/ast.h>
11779         enum isl_ast_expr_op_type isl_ast_expr_op_get_type(
11780                 __isl_keep isl_ast_expr *expr);
11781         enum isl_ast_expr_op_type isl_ast_expr_get_op_type(
11782                 __isl_keep isl_ast_expr *expr);
11783         isl_size isl_ast_expr_op_get_n_arg(__isl_keep isl_ast_expr *expr);
11784         isl_size isl_ast_expr_get_op_n_arg(__isl_keep isl_ast_expr *expr);
11785         __isl_give isl_ast_expr *isl_ast_expr_op_get_arg(
11786                 __isl_keep isl_ast_expr *expr, int pos);
11787         __isl_give isl_ast_expr *isl_ast_expr_get_op_arg(
11788                 __isl_keep isl_ast_expr *expr, int pos);
11789         isl_stat isl_ast_expr_foreach_ast_expr_op_type(
11790                 __isl_keep isl_ast_expr *expr,
11791                 isl_stat (*fn)(enum isl_ast_expr_op_type type,
11792                         void *user), void *user);
11793         isl_stat isl_ast_expr_foreach_ast_op_type(
11794                 __isl_keep isl_ast_expr *expr,
11795                 isl_stat (*fn)(enum isl_ast_expr_op_type type,
11796                         void *user), void *user);
11797         isl_stat isl_ast_node_foreach_ast_expr_op_type(
11798                 __isl_keep isl_ast_node *node,
11799                 isl_stat (*fn)(enum isl_ast_expr_op_type type,
11800                         void *user), void *user);
11801         isl_stat isl_ast_node_foreach_ast_op_type(
11802                 __isl_keep isl_ast_node *node,
11803                 isl_stat (*fn)(enum isl_ast_expr_op_type type,
11804                         void *user), void *user);
11806 C<isl_ast_expr_op_get_type> returns the type of the operation
11807 performed.  C<isl_ast_expr_op_get_n_arg> returns the number of
11808 arguments.  C<isl_ast_expr_get_op_arg> returns the specified
11809 argument.
11810 C<isl_ast_expr_get_op_type> is an alternative name for
11811 C<isl_ast_expr_op_get_type>.
11812 Similarly,
11813 C<isl_ast_expr_get_op_n_arg> is an alternative name for
11814 C<isl_ast_expr_op_get_n_arg> and
11815 C<isl_ast_expr_get_op_arg> is an alternative name for
11816 C<isl_ast_expr_op_get_arg>.
11818 C<isl_ast_expr_foreach_ast_expr_op_type> calls C<fn> for each distinct
11819 C<isl_ast_expr_op_type> that appears in C<expr>.
11820 C<isl_ast_expr_foreach_ast_op_type> is an alternative name for
11821 C<isl_ast_expr_foreach_ast_expr_op_type>.
11822 C<isl_ast_node_foreach_ast_expr_op_type> does the same for each distinct
11823 C<isl_ast_expr_op_type> that appears in C<node>.
11824 C<isl_ast_node_foreach_ast_op_type> is an alternative name for
11825 C<isl_ast_node_foreach_ast_expr_op_type>.
11826 The operation type is one of the following.
11828 =over
11830 =item C<isl_ast_expr_op_and>
11832 Logical I<and> of two arguments.
11833 Both arguments can be evaluated.
11835 =item C<isl_ast_expr_op_and_then>
11837 Logical I<and> of two arguments.
11838 The second argument can only be evaluated if the first evaluates to true.
11840 =item C<isl_ast_expr_op_or>
11842 Logical I<or> of two arguments.
11843 Both arguments can be evaluated.
11845 =item C<isl_ast_expr_op_or_else>
11847 Logical I<or> of two arguments.
11848 The second argument can only be evaluated if the first evaluates to false.
11850 =item C<isl_ast_expr_op_max>
11852 Maximum of two or more arguments.
11854 =item C<isl_ast_expr_op_min>
11856 Minimum of two or more arguments.
11858 =item C<isl_ast_expr_op_minus>
11860 Change sign.
11862 =item C<isl_ast_expr_op_add>
11864 Sum of two arguments.
11866 =item C<isl_ast_expr_op_sub>
11868 Difference of two arguments.
11870 =item C<isl_ast_expr_op_mul>
11872 Product of two arguments.
11874 =item C<isl_ast_expr_op_div>
11876 Exact division.  That is, the result is known to be an integer.
11878 =item C<isl_ast_expr_op_fdiv_q>
11880 Result of integer division, rounded towards negative
11881 infinity.
11882 The divisor is known to be positive.
11884 =item C<isl_ast_expr_op_pdiv_q>
11886 Result of integer division, where dividend is known to be non-negative.
11887 The divisor is known to be positive.
11889 =item C<isl_ast_expr_op_pdiv_r>
11891 Remainder of integer division, where dividend is known to be non-negative.
11892 The divisor is known to be positive.
11894 =item C<isl_ast_expr_op_zdiv_r>
11896 Equal to zero iff the remainder on integer division is zero.
11897 The divisor is known to be positive.
11899 =item C<isl_ast_expr_op_cond>
11901 Conditional operator defined on three arguments.
11902 If the first argument evaluates to true, then the result
11903 is equal to the second argument.  Otherwise, the result
11904 is equal to the third argument.
11905 The second and third argument may only be evaluated if
11906 the first argument evaluates to true and false, respectively.
11907 Corresponds to C<a ? b : c> in C.
11909 =item C<isl_ast_expr_op_select>
11911 Conditional operator defined on three arguments.
11912 If the first argument evaluates to true, then the result
11913 is equal to the second argument.  Otherwise, the result
11914 is equal to the third argument.
11915 The second and third argument may be evaluated independently
11916 of the value of the first argument.
11917 Corresponds to C<a * b + (1 - a) * c> in C.
11919 =item C<isl_ast_expr_op_eq>
11921 Equality relation.
11923 =item C<isl_ast_expr_op_le>
11925 Less than or equal relation.
11927 =item C<isl_ast_expr_op_lt>
11929 Less than relation.
11931 =item C<isl_ast_expr_op_ge>
11933 Greater than or equal relation.
11935 =item C<isl_ast_expr_op_gt>
11937 Greater than relation.
11939 =item C<isl_ast_expr_op_call>
11941 A function call.
11942 The number of arguments of the C<isl_ast_expr> is one more than
11943 the number of arguments in the function call, the first argument
11944 representing the function being called.
11946 =item C<isl_ast_expr_op_access>
11948 An array access.
11949 The number of arguments of the C<isl_ast_expr> is one more than
11950 the number of index expressions in the array access, the first argument
11951 representing the array being accessed.
11953 =item C<isl_ast_expr_op_member>
11955 A member access.
11956 This operation has two arguments, a structure and the name of
11957 the member of the structure being accessed.
11959 =item C<isl_ast_expr_op_address_of>
11961 The address of its single argument, which is always an array access.
11963 =back
11965         #include <isl/ast.h>
11966         __isl_give isl_id *isl_ast_expr_id_get_id(
11967                 __isl_keep isl_ast_expr *expr);
11968         __isl_give isl_id *isl_ast_expr_get_id(
11969                 __isl_keep isl_ast_expr *expr);
11971 Return the identifier represented by the AST expression.
11972 C<isl_ast_expr_get_id> is an alternative name for
11973 C<isl_ast_expr_id_get_id>.
11975         #include <isl/ast.h>
11976         __isl_give isl_val *isl_ast_expr_int_get_val(
11977                 __isl_keep isl_ast_expr *expr);
11978         __isl_give isl_val *isl_ast_expr_get_val(
11979                 __isl_keep isl_ast_expr *expr);
11981 Return the integer represented by the AST expression.
11982 C<isl_ast_expr_get_val> is an alternative name for
11983 C<isl_ast_expr_int_get_val>.
11985 =head3 Properties of ASTs
11987         #include <isl/ast.h>
11988         isl_bool isl_ast_expr_is_equal(
11989                 __isl_keep isl_ast_expr *expr1,
11990                 __isl_keep isl_ast_expr *expr2);
11992 Check if two C<isl_ast_expr>s are equal to each other.
11994 =head3 Manipulating and printing the AST
11996 AST nodes can be copied and freed using the following functions.
11998         #include <isl/ast.h>
11999         __isl_give isl_ast_node *isl_ast_node_copy(
12000                 __isl_keep isl_ast_node *node);
12001         __isl_null isl_ast_node *isl_ast_node_free(
12002                 __isl_take isl_ast_node *node);
12004 AST expressions can be copied and freed using the following functions.
12006         #include <isl/ast.h>
12007         __isl_give isl_ast_expr *isl_ast_expr_copy(
12008                 __isl_keep isl_ast_expr *expr);
12009         __isl_null isl_ast_expr *isl_ast_expr_free(
12010                 __isl_take isl_ast_expr *expr);
12012 New AST expressions can be created either directly or within
12013 the context of an C<isl_ast_build>.
12015         #include <isl/ast.h>
12016         __isl_give isl_ast_expr *isl_ast_expr_from_val(
12017                 __isl_take isl_val *v);
12018         __isl_give isl_ast_expr *isl_ast_expr_from_id(
12019                 __isl_take isl_id *id);
12020         __isl_give isl_ast_expr *isl_ast_expr_neg(
12021                 __isl_take isl_ast_expr *expr);
12022         __isl_give isl_ast_expr *isl_ast_expr_address_of(
12023                 __isl_take isl_ast_expr *expr);
12024         __isl_give isl_ast_expr *isl_ast_expr_add(
12025                 __isl_take isl_ast_expr *expr1,
12026                 __isl_take isl_ast_expr *expr2);
12027         __isl_give isl_ast_expr *isl_ast_expr_sub(
12028                 __isl_take isl_ast_expr *expr1,
12029                 __isl_take isl_ast_expr *expr2);
12030         __isl_give isl_ast_expr *isl_ast_expr_mul(
12031                 __isl_take isl_ast_expr *expr1,
12032                 __isl_take isl_ast_expr *expr2);
12033         __isl_give isl_ast_expr *isl_ast_expr_div(
12034                 __isl_take isl_ast_expr *expr1,
12035                 __isl_take isl_ast_expr *expr2);
12036         __isl_give isl_ast_expr *isl_ast_expr_pdiv_q(
12037                 __isl_take isl_ast_expr *expr1,
12038                 __isl_take isl_ast_expr *expr2);
12039         __isl_give isl_ast_expr *isl_ast_expr_pdiv_r(
12040                 __isl_take isl_ast_expr *expr1,
12041                 __isl_take isl_ast_expr *expr2);
12042         __isl_give isl_ast_expr *isl_ast_expr_and(
12043                 __isl_take isl_ast_expr *expr1,
12044                 __isl_take isl_ast_expr *expr2)
12045         __isl_give isl_ast_expr *isl_ast_expr_and_then(
12046                 __isl_take isl_ast_expr *expr1,
12047                 __isl_take isl_ast_expr *expr2)
12048         __isl_give isl_ast_expr *isl_ast_expr_or(
12049                 __isl_take isl_ast_expr *expr1,
12050                 __isl_take isl_ast_expr *expr2)
12051         __isl_give isl_ast_expr *isl_ast_expr_or_else(
12052                 __isl_take isl_ast_expr *expr1,
12053                 __isl_take isl_ast_expr *expr2)
12054         __isl_give isl_ast_expr *isl_ast_expr_eq(
12055                 __isl_take isl_ast_expr *expr1,
12056                 __isl_take isl_ast_expr *expr2);
12057         __isl_give isl_ast_expr *isl_ast_expr_le(
12058                 __isl_take isl_ast_expr *expr1,
12059                 __isl_take isl_ast_expr *expr2);
12060         __isl_give isl_ast_expr *isl_ast_expr_lt(
12061                 __isl_take isl_ast_expr *expr1,
12062                 __isl_take isl_ast_expr *expr2);
12063         __isl_give isl_ast_expr *isl_ast_expr_ge(
12064                 __isl_take isl_ast_expr *expr1,
12065                 __isl_take isl_ast_expr *expr2);
12066         __isl_give isl_ast_expr *isl_ast_expr_gt(
12067                 __isl_take isl_ast_expr *expr1,
12068                 __isl_take isl_ast_expr *expr2);
12069         __isl_give isl_ast_expr *isl_ast_expr_access(
12070                 __isl_take isl_ast_expr *array,
12071                 __isl_take isl_ast_expr_list *indices);
12072         __isl_give isl_ast_expr *isl_ast_expr_call(
12073                 __isl_take isl_ast_expr *function,
12074                 __isl_take isl_ast_expr_list *arguments);
12076 The function C<isl_ast_expr_address_of> can be applied to an
12077 C<isl_ast_expr> of type C<isl_ast_expr_op_access> only. It is meant
12078 to represent the address of the C<isl_ast_expr_access>.
12079 The second argument of the functions C<isl_ast_expr_pdiv_q> and
12080 C<isl_ast_expr_pdiv_r> should always evaluate to a positive number.
12081 The function
12082 C<isl_ast_expr_and_then> as well as C<isl_ast_expr_or_else> are short-circuit
12083 versions of C<isl_ast_expr_and> and C<isl_ast_expr_or>, respectively.
12085         #include <isl/ast_build.h>
12086         __isl_give isl_ast_expr *isl_ast_build_expr_from_set(
12087                 __isl_keep isl_ast_build *build,
12088                 __isl_take isl_set *set);
12089         __isl_give isl_ast_expr *isl_ast_build_expr_from_pw_aff(
12090                 __isl_keep isl_ast_build *build,
12091                 __isl_take isl_pw_aff *pa);
12092         __isl_give isl_ast_expr *
12093         isl_ast_build_access_from_pw_multi_aff(
12094                 __isl_keep isl_ast_build *build,
12095                 __isl_take isl_pw_multi_aff *pma);
12096         __isl_give isl_ast_expr *
12097         isl_ast_build_access_from_multi_pw_aff(
12098                 __isl_keep isl_ast_build *build,
12099                 __isl_take isl_multi_pw_aff *mpa);
12100         __isl_give isl_ast_expr *
12101         isl_ast_build_call_from_pw_multi_aff(
12102                 __isl_keep isl_ast_build *build,
12103                 __isl_take isl_pw_multi_aff *pma);
12104         __isl_give isl_ast_expr *
12105         isl_ast_build_call_from_multi_pw_aff(
12106                 __isl_keep isl_ast_build *build,
12107                 __isl_take isl_multi_pw_aff *mpa);
12109 The set C<set> and
12110 the domains of C<pa>, C<mpa> and C<pma> should correspond
12111 to the schedule space of C<build>.
12112 The tuple id of C<mpa> or C<pma> is used as the array being accessed or
12113 the function being called.
12114 If the accessed space is a nested relation, then it is taken
12115 to represent an access of the member specified by the range
12116 of this nested relation of the structure specified by the domain
12117 of the nested relation.
12119 The following functions can be used to modify an C<isl_ast_expr>.
12121         #include <isl/ast.h>
12122         __isl_give isl_ast_expr *isl_ast_expr_set_op_arg(
12123                 __isl_take isl_ast_expr *expr, int pos,
12124                 __isl_take isl_ast_expr *arg);
12126 Replace the argument of C<expr> at position C<pos> by C<arg>.
12128         #include <isl/ast.h>
12129         __isl_give isl_ast_expr *isl_ast_expr_substitute_ids(
12130                 __isl_take isl_ast_expr *expr,
12131                 __isl_take isl_id_to_ast_expr *id2expr);
12133 The function C<isl_ast_expr_substitute_ids> replaces the
12134 subexpressions of C<expr> of type C<isl_ast_expr_id>
12135 by the corresponding expression in C<id2expr>, if there is any.
12138 The following function can be used to modify the descendants
12139 of a specific node in an AST using a depth-first post-order
12140 traversal of those descendants (including the node itself).
12142         #include <isl/ast.h>
12143         __isl_give isl_ast_node *
12144         isl_ast_node_map_descendant_bottom_up(
12145                 __isl_take isl_ast_node *node,
12146                 __isl_give isl_ast_node *(*fn)(
12147                         __isl_take isl_ast_node *node,
12148                         void *user), void *user);
12150 User specified data can be attached to an C<isl_ast_node> and obtained
12151 from the same C<isl_ast_node> using the following functions.
12153         #include <isl/ast.h>
12154         __isl_give isl_ast_node *isl_ast_node_set_annotation(
12155                 __isl_take isl_ast_node *node,
12156                 __isl_take isl_id *annotation);
12157         __isl_give isl_id *isl_ast_node_get_annotation(
12158                 __isl_keep isl_ast_node *node);
12160 Basic printing can be performed using the following functions.
12162         #include <isl/ast.h>
12163         __isl_give isl_printer *isl_printer_print_ast_expr(
12164                 __isl_take isl_printer *p,
12165                 __isl_keep isl_ast_expr *expr);
12166         __isl_give isl_printer *isl_printer_print_ast_node(
12167                 __isl_take isl_printer *p,
12168                 __isl_keep isl_ast_node *node);
12169         __isl_give char *isl_ast_expr_to_str(
12170                 __isl_keep isl_ast_expr *expr);
12171         __isl_give char *isl_ast_node_to_str(
12172                 __isl_keep isl_ast_node *node);
12173         __isl_give char *isl_ast_expr_to_C_str(
12174                 __isl_keep isl_ast_expr *expr);
12175         __isl_give char *isl_ast_node_to_C_str(
12176                 __isl_keep isl_ast_node *node);
12178 The functions C<isl_ast_expr_to_C_str> and
12179 C<isl_ast_node_to_C_str> are convenience functions
12180 that return a string representation of the input in C format.
12182 More advanced printing can be performed using the following functions.
12184         #include <isl/ast.h>
12185         __isl_give isl_printer *
12186         isl_ast_expr_op_type_set_print_name(
12187                 __isl_take isl_printer *p,
12188                 enum isl_ast_expr_op_type type,
12189                 __isl_keep const char *name);
12190         __isl_give isl_printer *isl_ast_op_type_set_print_name(
12191                 __isl_take isl_printer *p,
12192                 enum isl_ast_expr_op_type type,
12193                 __isl_keep const char *name);
12194         isl_stat isl_options_set_ast_print_macro_once(
12195                 isl_ctx *ctx, int val);
12196         int isl_options_get_ast_print_macro_once(isl_ctx *ctx);
12197         __isl_give isl_printer *isl_ast_expr_op_type_print_macro(
12198                 enum isl_ast_expr_op_type type,
12199                 __isl_take isl_printer *p);
12200         __isl_give isl_printer *isl_ast_op_type_print_macro(
12201                 enum isl_ast_expr_op_type type,
12202                 __isl_take isl_printer *p);
12203         __isl_give isl_printer *isl_ast_expr_print_macros(
12204                 __isl_keep isl_ast_expr *expr,
12205                 __isl_take isl_printer *p);
12206         __isl_give isl_printer *isl_ast_node_print_macros(
12207                 __isl_keep isl_ast_node *node,
12208                 __isl_take isl_printer *p);
12209         __isl_give isl_printer *isl_ast_node_print(
12210                 __isl_keep isl_ast_node *node,
12211                 __isl_take isl_printer *p,
12212                 __isl_take isl_ast_print_options *options);
12213         __isl_give isl_printer *isl_ast_node_for_print(
12214                 __isl_keep isl_ast_node *node,
12215                 __isl_take isl_printer *p,
12216                 __isl_take isl_ast_print_options *options);
12217         __isl_give isl_printer *isl_ast_node_if_print(
12218                 __isl_keep isl_ast_node *node,
12219                 __isl_take isl_printer *p,
12220                 __isl_take isl_ast_print_options *options);
12222 While printing an C<isl_ast_node> in C<ISL_FORMAT_C>,
12223 C<isl> may print out an AST that makes use of macros such
12224 as C<floord>, C<min> and C<max>.
12225 The names of these macros may be modified by a call
12226 to C<isl_ast_expr_op_type_set_print_name>.  The user-specified
12227 names are associated to the printer object.
12228 C<isl_ast_op_type_set_print_name> is an alternative name for
12229 C<isl_ast_expr_op_type_set_print_name>.
12230 C<isl_ast_expr_op_type_print_macro> prints out the macro
12231 corresponding to a specific C<isl_ast_expr_op_type>.
12232 If the print-macro-once option is set, then a given macro definition
12233 is only printed once to any given printer object.
12234 C<isl_ast_op_type_print_macro> is an alternative name for
12235 C<isl_ast_expr_op_type_print_macro>.
12236 C<isl_ast_expr_print_macros> scans the C<isl_ast_expr>
12237 for subexpressions where these macros would be used and prints
12238 out the required macro definitions.
12239 Essentially, C<isl_ast_expr_print_macros> calls
12240 C<isl_ast_expr_foreach_ast_expr_op_type> with
12241 C<isl_ast_expr_op_type_print_macro>
12242 as function argument.
12243 C<isl_ast_node_print_macros> does the same
12244 for expressions in its C<isl_ast_node> argument.
12245 C<isl_ast_node_print>, C<isl_ast_node_for_print> and
12246 C<isl_ast_node_if_print> print an C<isl_ast_node>
12247 in C<ISL_FORMAT_C>, but allow for some extra control
12248 through an C<isl_ast_print_options> object.
12249 This object can be created using the following functions.
12251         #include <isl/ast.h>
12252         __isl_give isl_ast_print_options *
12253         isl_ast_print_options_alloc(isl_ctx *ctx);
12254         __isl_give isl_ast_print_options *
12255         isl_ast_print_options_copy(
12256                 __isl_keep isl_ast_print_options *options);
12257         __isl_null isl_ast_print_options *
12258         isl_ast_print_options_free(
12259                 __isl_take isl_ast_print_options *options);
12261         __isl_give isl_ast_print_options *
12262         isl_ast_print_options_set_print_user(
12263                 __isl_take isl_ast_print_options *options,
12264                 __isl_give isl_printer *(*print_user)(
12265                         __isl_take isl_printer *p,
12266                         __isl_take isl_ast_print_options *options,
12267                         __isl_keep isl_ast_node *node, void *user),
12268                 void *user);
12269         __isl_give isl_ast_print_options *
12270         isl_ast_print_options_set_print_for(
12271                 __isl_take isl_ast_print_options *options,
12272                 __isl_give isl_printer *(*print_for)(
12273                         __isl_take isl_printer *p,
12274                         __isl_take isl_ast_print_options *options,
12275                         __isl_keep isl_ast_node *node, void *user),
12276                 void *user);
12278 The callback set by C<isl_ast_print_options_set_print_user>
12279 is called whenever a node of type C<isl_ast_node_user> needs to
12280 be printed.
12281 The callback set by C<isl_ast_print_options_set_print_for>
12282 is called whenever a node of type C<isl_ast_node_for> needs to
12283 be printed.
12284 Note that C<isl_ast_node_for_print> will I<not> call the
12285 callback set by C<isl_ast_print_options_set_print_for> on the node
12286 on which C<isl_ast_node_for_print> is called, but only on nested
12287 nodes of type C<isl_ast_node_for>.  It is therefore safe to
12288 call C<isl_ast_node_for_print> from within the callback set by
12289 C<isl_ast_print_options_set_print_for>.
12291 The following option determines the type to be used for iterators
12292 while printing the AST.
12294         isl_stat isl_options_set_ast_iterator_type(
12295                 isl_ctx *ctx, const char *val);
12296         const char *isl_options_get_ast_iterator_type(
12297                 isl_ctx *ctx);
12299 The AST printer only prints body nodes of C<if> and C<for> nodes
12300 as blocks if these
12301 blocks cannot be safely omitted.
12302 For example, a C<for> node with one body node will not be
12303 surrounded with braces in C<ISL_FORMAT_C>.
12304 A block will always be printed by setting the following option.
12306         isl_stat isl_options_set_ast_always_print_block(isl_ctx *ctx,
12307                 int val);
12308         int isl_options_get_ast_always_print_block(isl_ctx *ctx);
12310 Explicit block nodes that appear inside the AST are always printed as blocks.
12311 If the block node appears as the outermost node,
12312 then it is only printed if the following option is set.
12314         isl_stat isl_options_set_ast_print_outermost_block(
12315                 isl_ctx *ctx, int val);
12316         int isl_options_get_ast_print_outermost_block(
12317                 isl_ctx *ctx);
12319 =head3 Options
12321         #include <isl/ast_build.h>
12322         isl_stat isl_options_set_ast_build_atomic_upper_bound(
12323                 isl_ctx *ctx, int val);
12324         int isl_options_get_ast_build_atomic_upper_bound(
12325                 isl_ctx *ctx);
12326         isl_stat isl_options_set_ast_build_prefer_pdiv(isl_ctx *ctx,
12327                 int val);
12328         int isl_options_get_ast_build_prefer_pdiv(isl_ctx *ctx);
12329         isl_stat isl_options_set_ast_build_detect_min_max(
12330                 isl_ctx *ctx, int val);
12331         int isl_options_get_ast_build_detect_min_max(
12332                 isl_ctx *ctx);
12333         isl_stat isl_options_set_ast_build_exploit_nested_bounds(
12334                 isl_ctx *ctx, int val);
12335         int isl_options_get_ast_build_exploit_nested_bounds(
12336                 isl_ctx *ctx);
12337         isl_stat isl_options_set_ast_build_group_coscheduled(
12338                 isl_ctx *ctx, int val);
12339         int isl_options_get_ast_build_group_coscheduled(
12340                 isl_ctx *ctx);
12341         isl_stat isl_options_set_ast_build_separation_bounds(
12342                 isl_ctx *ctx, int val);
12343         int isl_options_get_ast_build_separation_bounds(
12344                 isl_ctx *ctx);
12345         isl_stat isl_options_set_ast_build_scale_strides(
12346                 isl_ctx *ctx, int val);
12347         int isl_options_get_ast_build_scale_strides(
12348                 isl_ctx *ctx);
12349         isl_stat isl_options_set_ast_build_allow_else(isl_ctx *ctx,
12350                 int val);
12351         int isl_options_get_ast_build_allow_else(isl_ctx *ctx);
12352         isl_stat isl_options_set_ast_build_allow_or(isl_ctx *ctx,
12353                 int val);
12354         int isl_options_get_ast_build_allow_or(isl_ctx *ctx);
12356 =over
12358 =item * ast_build_atomic_upper_bound
12360 Generate loop upper bounds that consist of the current loop iterator,
12361 an operator and an expression not involving the iterator.
12362 If this option is not set, then the current loop iterator may appear
12363 several times in the upper bound.
12364 For example, when this option is turned off, AST generation
12365 for the schedule
12367         [n] -> { A[i] -> [i] : 0 <= i <= 100, n }
12369 produces
12371         for (int c0 = 0; c0 <= 100 && n >= c0; c0 += 1)
12372           A(c0);
12374 When the option is turned on, the following AST is generated
12376         for (int c0 = 0; c0 <= min(100, n); c0 += 1)
12377           A(c0);
12379 =item * ast_build_prefer_pdiv
12381 If this option is turned off, then the AST generation will
12382 produce ASTs that may only contain C<isl_ast_expr_op_fdiv_q>
12383 operators, but no C<isl_ast_expr_op_pdiv_q> or
12384 C<isl_ast_expr_op_pdiv_r> operators.
12385 If this option is turned on, then C<isl> will try to convert
12386 some of the C<isl_ast_expr_op_fdiv_q> operators to (expressions containing)
12387 C<isl_ast_expr_op_pdiv_q> or C<isl_ast_expr_op_pdiv_r> operators.
12389 =item * ast_build_detect_min_max
12391 If this option is turned on, then C<isl> will try and detect
12392 min or max-expressions when building AST expressions from
12393 piecewise affine expressions.
12395 =item * ast_build_exploit_nested_bounds
12397 Simplify conditions based on bounds of nested for loops.
12398 In particular, remove conditions that are implied by the fact
12399 that one or more nested loops have at least one iteration,
12400 meaning that the upper bound is at least as large as the lower bound.
12401 For example, when this option is turned off, AST generation
12402 for the schedule
12404         [N,M] -> { A[i,j] -> [i,j] : 0 <= i <= N and
12405                                         0 <= j <= M }
12407 produces
12409         if (M >= 0)
12410           for (int c0 = 0; c0 <= N; c0 += 1)
12411             for (int c1 = 0; c1 <= M; c1 += 1)
12412               A(c0, c1);
12414 When the option is turned on, the following AST is generated
12416         for (int c0 = 0; c0 <= N; c0 += 1)
12417           for (int c1 = 0; c1 <= M; c1 += 1)
12418             A(c0, c1);
12420 =item * ast_build_group_coscheduled
12422 If two domain elements are assigned the same schedule point, then
12423 they may be executed in any order and they may even appear in different
12424 loops.  If this options is set, then the AST generator will make
12425 sure that coscheduled domain elements do not appear in separate parts
12426 of the AST.  This is useful in case of nested AST generation
12427 if the outer AST generation is given only part of a schedule
12428 and the inner AST generation should handle the domains that are
12429 coscheduled by this initial part of the schedule together.
12430 For example if an AST is generated for a schedule
12432         { A[i] -> [0]; B[i] -> [0] }
12434 then the C<isl_ast_build_set_create_leaf> callback described
12435 below may get called twice, once for each domain.
12436 Setting this option ensures that the callback is only called once
12437 on both domains together.
12439 =item * ast_build_separation_bounds
12441 This option specifies which bounds to use during separation.
12442 If this option is set to C<ISL_AST_BUILD_SEPARATION_BOUNDS_IMPLICIT>
12443 then all (possibly implicit) bounds on the current dimension will
12444 be used during separation.
12445 If this option is set to C<ISL_AST_BUILD_SEPARATION_BOUNDS_EXPLICIT>
12446 then only those bounds that are explicitly available will
12447 be used during separation.
12449 =item * ast_build_scale_strides
12451 This option specifies whether the AST generator is allowed
12452 to scale down iterators of strided loops.
12454 =item * ast_build_allow_else
12456 This option specifies whether the AST generator is allowed
12457 to construct if statements with else branches.
12459 =item * ast_build_allow_or
12461 This option specifies whether the AST generator is allowed
12462 to construct if conditions with disjunctions.
12464 =back
12466 =head3 AST Generation Options (Schedule Tree)
12468 In case of AST construction from a schedule tree, the options
12469 that control how an AST is created from the individual schedule
12470 dimensions are stored in the band nodes of the tree
12471 (see L</"Schedule Trees">).
12473 In particular, a schedule dimension can be handled in four
12474 different ways, atomic, separate, unroll or the default.
12475 This loop AST generation type can be set using
12476 C<isl_schedule_node_band_member_set_ast_loop_type>.
12477 Alternatively,
12478 the first three can be selected by including a one-dimensional
12479 element with as value the position of the schedule dimension
12480 within the band and as name one of C<atomic>, C<separate>
12481 or C<unroll> in the options
12482 set by C<isl_schedule_node_band_set_ast_build_options>.
12483 Only one of these three may be specified for
12484 any given schedule dimension within a band node.
12485 If none of these is specified, then the default
12486 is used.  The meaning of the options is as follows.
12488 =over
12490 =item C<atomic>
12492 When this option is specified, the AST generator will make
12493 sure that a given domain space only appears in a single
12494 loop at the specified level.
12496 For example, for the schedule tree
12498         domain: "{ a[i] : 0 <= i < 10; b[i] : 0 <= i < 10 }"
12499         child:
12500           schedule: "[{ a[i] -> [i]; b[i] -> [i+1] }]"
12501           options: "{ atomic[x] }"
12503 the following AST will be generated
12505         for (int c0 = 0; c0 <= 10; c0 += 1) {
12506           if (c0 >= 1)
12507             b(c0 - 1);
12508           if (c0 <= 9)
12509             a(c0);
12510         }
12512 On the other hand, for the schedule tree
12514         domain: "{ a[i] : 0 <= i < 10; b[i] : 0 <= i < 10 }"
12515         child:
12516           schedule: "[{ a[i] -> [i]; b[i] -> [i+1] }]"
12517           options: "{ separate[x] }"
12519 the following AST will be generated
12521         {
12522           a(0);
12523           for (int c0 = 1; c0 <= 9; c0 += 1) {
12524             b(c0 - 1);
12525             a(c0);
12526           }
12527           b(9);
12528         }
12530 If neither C<atomic> nor C<separate> is specified, then the AST generator
12531 may produce either of these two results or some intermediate form.
12533 =item C<separate>
12535 When this option is specified, the AST generator will
12536 split the domain of the specified schedule dimension
12537 into pieces with a fixed set of statements for which
12538 instances need to be executed by the iterations in
12539 the schedule domain part.  This option tends to avoid
12540 the generation of guards inside the corresponding loops.
12541 See also the C<atomic> option.
12543 =item C<unroll>
12545 When this option is specified, the AST generator will
12546 I<completely> unroll the corresponding schedule dimension.
12547 It is the responsibility of the user to ensure that such
12548 unrolling is possible.
12549 To obtain a partial unrolling, the user should apply an additional
12550 strip-mining to the schedule and fully unroll the inner schedule
12551 dimension.
12553 =back
12555 The C<isolate> option is a bit more involved.  It allows the user
12556 to isolate a range of schedule dimension values from smaller and
12557 greater values.  Additionally, the user may specify a different
12558 atomic/separate/unroll choice for the isolated part and the remaining
12559 parts.  The typical use case of the C<isolate> option is to isolate
12560 full tiles from partial tiles.
12561 The part that needs to be isolated may depend on outer schedule dimensions.
12562 The option therefore needs to be able to reference those outer schedule
12563 dimensions.  In particular, the space of the C<isolate> option is that
12564 of a wrapped map with as domain the flat product of all outer band nodes
12565 and as range the space of the current band node.
12566 The atomic/separate/unroll choice for the isolated part is determined
12567 by an option that lives in an unnamed wrapped space with as domain
12568 a zero-dimensional C<isolate> space and as range the regular
12569 C<atomic>, C<separate> or C<unroll> space.
12570 This option may also be set directly using
12571 C<isl_schedule_node_band_member_set_isolate_ast_loop_type>.
12572 The atomic/separate/unroll choice for the remaining part is determined
12573 by the regular C<atomic>, C<separate> or C<unroll> option.
12574 Since the C<isolate> option references outer schedule dimensions,
12575 its use in a band node causes any tree containing the node
12576 to be considered anchored.
12578 As an example, consider the isolation of full tiles from partial tiles
12579 in a tiling of a triangular domain.  The original schedule is as follows.
12581         domain: "{ A[i,j] : 0 <= i,j and i + j <= 100 }"
12582         child:
12583           schedule: "[{ A[i,j] -> [floor(i/10)] }, \
12584                 { A[i,j] -> [floor(j/10)] }, \
12585                 { A[i,j] -> [i] }, { A[i,j] -> [j] }]"
12587 The output is
12589         for (int c0 = 0; c0 <= 10; c0 += 1)
12590           for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
12591             for (int c2 = 10 * c0;
12592                  c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
12593               for (int c3 = 10 * c1;
12594                    c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
12595                 A(c2, c3);
12597 Isolating the full tiles, we have the following input
12599         domain: "{ A[i,j] : 0 <= i,j and i + j <= 100 }"
12600         child:
12601           schedule: "[{ A[i,j] -> [floor(i/10)] }, \
12602                 { A[i,j] -> [floor(j/10)] }, \
12603                 { A[i,j] -> [i] }, { A[i,j] -> [j] }]"
12604           options: "{ isolate[[] -> [a,b,c,d]] : 0 <= 10a,10b and \
12605                 10a+9+10b+9 <= 100 }"
12607 and output
12609         {
12610           for (int c0 = 0; c0 <= 8; c0 += 1) {
12611             for (int c1 = 0; c1 <= -c0 + 8; c1 += 1)
12612               for (int c2 = 10 * c0;
12613                    c2 <= 10 * c0 + 9; c2 += 1)
12614                 for (int c3 = 10 * c1;
12615                      c3 <= 10 * c1 + 9; c3 += 1)
12616                   A(c2, c3);
12617             for (int c1 = -c0 + 9; c1 <= -c0 + 10; c1 += 1)
12618               for (int c2 = 10 * c0;
12619                    c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
12620                 for (int c3 = 10 * c1;
12621                      c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
12622                   A(c2, c3);
12623           }
12624           for (int c0 = 9; c0 <= 10; c0 += 1)
12625             for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
12626               for (int c2 = 10 * c0;
12627                    c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
12628                 for (int c3 = 10 * c1;
12629                      c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
12630                   A(c2, c3);
12631         }
12633 We may then additionally unroll the innermost loop of the isolated part
12635         domain: "{ A[i,j] : 0 <= i,j and i + j <= 100 }"
12636         child:
12637           schedule: "[{ A[i,j] -> [floor(i/10)] }, \
12638                 { A[i,j] -> [floor(j/10)] }, \
12639                 { A[i,j] -> [i] }, { A[i,j] -> [j] }]"
12640           options: "{ isolate[[] -> [a,b,c,d]] : 0 <= 10a,10b and \
12641                 10a+9+10b+9 <= 100; [isolate[] -> unroll[3]] }"
12643 to obtain
12645         {
12646           for (int c0 = 0; c0 <= 8; c0 += 1) {
12647             for (int c1 = 0; c1 <= -c0 + 8; c1 += 1)
12648               for (int c2 = 10 * c0; c2 <= 10 * c0 + 9; c2 += 1) {
12649                 A(c2, 10 * c1);
12650                 A(c2, 10 * c1 + 1);
12651                 A(c2, 10 * c1 + 2);
12652                 A(c2, 10 * c1 + 3);
12653                 A(c2, 10 * c1 + 4);
12654                 A(c2, 10 * c1 + 5);
12655                 A(c2, 10 * c1 + 6);
12656                 A(c2, 10 * c1 + 7);
12657                 A(c2, 10 * c1 + 8);
12658                 A(c2, 10 * c1 + 9);
12659               }
12660             for (int c1 = -c0 + 9; c1 <= -c0 + 10; c1 += 1)
12661               for (int c2 = 10 * c0;
12662                    c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
12663                 for (int c3 = 10 * c1;
12664                      c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
12665                   A(c2, c3);
12666           }
12667           for (int c0 = 9; c0 <= 10; c0 += 1)
12668             for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
12669               for (int c2 = 10 * c0;
12670                    c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
12671                 for (int c3 = 10 * c1;
12672                      c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
12673                   A(c2, c3);
12674         }
12677 =head3 AST Generation Options (Schedule Map)
12679 In case of AST construction using
12680 C<isl_ast_build_node_from_schedule_map>, the options
12681 that control how an AST is created from the individual schedule
12682 dimensions are stored in the C<isl_ast_build>.
12683 They can be set using the following function.
12685         #include <isl/ast_build.h>
12686         __isl_give isl_ast_build *
12687         isl_ast_build_set_options(
12688                 __isl_take isl_ast_build *build,
12689                 __isl_take isl_union_map *options);
12691 The options are encoded in an C<isl_union_map>.
12692 The domain of this union relation refers to the schedule domain,
12693 i.e., the range of the schedule passed
12694 to C<isl_ast_build_node_from_schedule_map>.
12695 In the case of nested AST generation (see L</"Nested AST Generation">),
12696 the domain of C<options> should refer to the extra piece of the schedule.
12697 That is, it should be equal to the range of the wrapped relation in the
12698 range of the schedule.
12699 The range of the options can consist of elements in one or more spaces,
12700 the names of which determine the effect of the option.
12701 The values of the range typically also refer to the schedule dimension
12702 to which the option applies, with value C<0> representing
12703 the outermost schedule dimension.  In case of nested AST generation
12704 (see L</"Nested AST Generation">), these values refer to the position
12705 of the schedule dimension within the innermost AST generation.
12706 The constraints on the domain elements of
12707 the option should only refer to this dimension and earlier dimensions.
12708 We consider the following spaces.
12710 =over
12712 =item C<separation_class>
12714 B<This option has been deprecated.  Use the isolate option on
12715 schedule trees instead.>
12717 This space is a wrapped relation between two one dimensional spaces.
12718 The input space represents the schedule dimension to which the option
12719 applies and the output space represents the separation class.
12720 While constructing a loop corresponding to the specified schedule
12721 dimension(s), the AST generator will try to generate separate loops
12722 for domain elements that are assigned different classes.
12723 If only some of the elements are assigned a class, then those elements
12724 that are not assigned any class will be treated as belonging to a class
12725 that is separate from the explicitly assigned classes.
12726 The typical use case for this option is to separate full tiles from
12727 partial tiles.
12728 The other options, described below, are applied after the separation
12729 into classes.
12731 As an example, consider the separation into full and partial tiles
12732 of a tiling of a triangular domain.
12733 Take, for example, the domain
12735         { A[i,j] : 0 <= i,j and i + j <= 100 }
12737 and a tiling into tiles of 10 by 10.  The input to the AST generator
12738 is then the schedule
12740         { A[i,j] -> [([i/10]),[j/10],i,j] : 0 <= i,j and
12741                                                 i + j <= 100 }
12743 Without any options, the following AST is generated
12745         for (int c0 = 0; c0 <= 10; c0 += 1)
12746           for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
12747             for (int c2 = 10 * c0;
12748                  c2 <= min(-10 * c1 + 100, 10 * c0 + 9);
12749                  c2 += 1)
12750               for (int c3 = 10 * c1;
12751                    c3 <= min(10 * c1 + 9, -c2 + 100);
12752                    c3 += 1)
12753                 A(c2, c3);
12755 Separation into full and partial tiles can be obtained by assigning
12756 a class, say C<0>, to the full tiles.  The full tiles are represented by those
12757 values of the first and second schedule dimensions for which there are
12758 values of the third and fourth dimensions to cover an entire tile.
12759 That is, we need to specify the following option
12761         { [a,b,c,d] -> separation_class[[0]->[0]] :
12762                 exists b': 0 <= 10a,10b' and
12763                            10a+9+10b'+9 <= 100;
12764           [a,b,c,d] -> separation_class[[1]->[0]] :
12765                 0 <= 10a,10b and 10a+9+10b+9 <= 100 }
12767 which simplifies to
12769         { [a, b, c, d] -> separation_class[[1] -> [0]] :
12770                 a >= 0 and b >= 0 and b <= 8 - a;
12771           [a, b, c, d] -> separation_class[[0] -> [0]] :
12772                 a >= 0 and a <= 8 }
12774 With this option, the generated AST is as follows
12776         {
12777           for (int c0 = 0; c0 <= 8; c0 += 1) {
12778             for (int c1 = 0; c1 <= -c0 + 8; c1 += 1)
12779               for (int c2 = 10 * c0;
12780                    c2 <= 10 * c0 + 9; c2 += 1)
12781                 for (int c3 = 10 * c1;
12782                      c3 <= 10 * c1 + 9; c3 += 1)
12783                   A(c2, c3);
12784             for (int c1 = -c0 + 9; c1 <= -c0 + 10; c1 += 1)
12785               for (int c2 = 10 * c0;
12786                    c2 <= min(-10 * c1 + 100, 10 * c0 + 9);
12787                    c2 += 1)
12788                 for (int c3 = 10 * c1;
12789                      c3 <= min(-c2 + 100, 10 * c1 + 9);
12790                      c3 += 1)
12791                   A(c2, c3);
12792           }
12793           for (int c0 = 9; c0 <= 10; c0 += 1)
12794             for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
12795               for (int c2 = 10 * c0;
12796                    c2 <= min(-10 * c1 + 100, 10 * c0 + 9);
12797                    c2 += 1)
12798                 for (int c3 = 10 * c1;
12799                      c3 <= min(10 * c1 + 9, -c2 + 100);
12800                      c3 += 1)
12801                   A(c2, c3);
12802         }
12804 =item C<separate>
12806 This is a single-dimensional space representing the schedule dimension(s)
12807 to which ``separation'' should be applied.  Separation tries to split
12808 a loop into several pieces if this can avoid the generation of guards
12809 inside the loop.
12810 See also the C<atomic> option.
12812 =item C<atomic>
12814 This is a single-dimensional space representing the schedule dimension(s)
12815 for which the domains should be considered ``atomic''.  That is, the
12816 AST generator will make sure that any given domain space will only appear
12817 in a single loop at the specified level.
12819 Consider the following schedule
12821         { a[i] -> [i] : 0 <= i < 10;
12822           b[i] -> [i+1] : 0 <= i < 10 }
12824 If the following option is specified
12826         { [i] -> separate[x] }
12828 then the following AST will be generated
12830         {
12831           a(0);
12832           for (int c0 = 1; c0 <= 9; c0 += 1) {
12833             a(c0);
12834             b(c0 - 1);
12835           }
12836           b(9);
12837         }
12839 If, on the other hand, the following option is specified
12841         { [i] -> atomic[x] }
12843 then the following AST will be generated
12845         for (int c0 = 0; c0 <= 10; c0 += 1) {
12846           if (c0 <= 9)
12847             a(c0);
12848           if (c0 >= 1)
12849             b(c0 - 1);
12850         }
12852 If neither C<atomic> nor C<separate> is specified, then the AST generator
12853 may produce either of these two results or some intermediate form.
12855 =item C<unroll>
12857 This is a single-dimensional space representing the schedule dimension(s)
12858 that should be I<completely> unrolled.
12859 To obtain a partial unrolling, the user should apply an additional
12860 strip-mining to the schedule and fully unroll the inner loop.
12862 =back
12864 =head3 Fine-grained Control over AST Generation
12866 Besides specifying the constraints on the parameters,
12867 an C<isl_ast_build> object can be used to control
12868 various aspects of the AST generation process.
12869 In case of AST construction using
12870 C<isl_ast_build_node_from_schedule_map>,
12871 the most prominent way of control is through ``options'',
12872 as explained above.
12874 Additional control is available through the following functions.
12876         #include <isl/ast_build.h>
12877         __isl_give isl_ast_build *
12878         isl_ast_build_set_iterators(
12879                 __isl_take isl_ast_build *build,
12880                 __isl_take isl_id_list *iterators);
12882 The function C<isl_ast_build_set_iterators> allows the user to
12883 specify a list of iterator C<isl_id>s to be used as iterators.
12884 If the input schedule is injective, then
12885 the number of elements in this list should be as large as the dimension
12886 of the schedule space, but no direct correspondence should be assumed
12887 between dimensions and elements.
12888 If the input schedule is not injective, then an additional number
12889 of C<isl_id>s equal to the largest dimension of the input domains
12890 may be required.
12891 If the number of provided C<isl_id>s is insufficient, then additional
12892 names are automatically generated.
12894         #include <isl/ast_build.h>
12895         __isl_give isl_ast_build *
12896         isl_ast_build_set_create_leaf(
12897                 __isl_take isl_ast_build *build,
12898                 __isl_give isl_ast_node *(*fn)(
12899                         __isl_take isl_ast_build *build,
12900                         void *user), void *user);
12903 C<isl_ast_build_set_create_leaf> function allows for the
12904 specification of a callback that should be called whenever the AST
12905 generator arrives at an element of the schedule domain.
12906 The callback should return an AST node that should be inserted
12907 at the corresponding position of the AST.  The default action (when
12908 the callback is not set) is to continue generating parts of the AST to scan
12909 all the domain elements associated to the schedule domain element
12910 and to insert user nodes, ``calling'' the domain element, for each of them.
12911 The C<build> argument contains the current state of the C<isl_ast_build>.
12912 To ease nested AST generation (see L</"Nested AST Generation">),
12913 all control information that is
12914 specific to the current AST generation such as the options and
12915 the callbacks has been removed from this C<isl_ast_build>.
12916 The callback would typically return the result of a nested
12917 AST generation or a
12918 user defined node created using the following function.
12920         #include <isl/ast.h>
12921         __isl_give isl_ast_node *isl_ast_node_user_from_expr(
12922                 __isl_take isl_ast_expr *expr);
12923         __isl_give isl_ast_node *isl_ast_node_alloc_user(
12924                 __isl_take isl_ast_expr *expr);
12926 C<isl_ast_node_alloc_user> is an alternative name for
12927 C<isl_ast_node_user_from_expr>.
12929 In some cases, a single user defined node is not enough,
12930 in which case the following function can be used
12931 to create a block node from multiple AST nodes.
12933         #include <isl/ast.h>
12934         __isl_give isl_ast_node *isl_ast_node_block_from_children(
12935                 __isl_take isl_ast_node_list *list);
12937         #include <isl/ast_build.h>
12938         __isl_give isl_ast_build *
12939         isl_ast_build_set_at_each_domain(
12940                 __isl_take isl_ast_build *build,
12941                 __isl_give isl_ast_node *(*fn)(
12942                         __isl_take isl_ast_node *node,
12943                         __isl_keep isl_ast_build *build,
12944                         void *user), void *user);
12945         __isl_give isl_ast_build *
12946         isl_ast_build_set_before_each_for(
12947                 __isl_take isl_ast_build *build,
12948                 __isl_give isl_id *(*fn)(
12949                         __isl_keep isl_ast_build *build,
12950                         void *user), void *user);
12951         __isl_give isl_ast_build *
12952         isl_ast_build_set_after_each_for(
12953                 __isl_take isl_ast_build *build,
12954                 __isl_give isl_ast_node *(*fn)(
12955                         __isl_take isl_ast_node *node,
12956                         __isl_keep isl_ast_build *build,
12957                         void *user), void *user);
12958         __isl_give isl_ast_build *
12959         isl_ast_build_set_before_each_mark(
12960                 __isl_take isl_ast_build *build,
12961                 isl_stat (*fn)(__isl_keep isl_id *mark,
12962                         __isl_keep isl_ast_build *build,
12963                         void *user), void *user);
12964         __isl_give isl_ast_build *
12965         isl_ast_build_set_after_each_mark(
12966                 __isl_take isl_ast_build *build,
12967                 __isl_give isl_ast_node *(*fn)(
12968                         __isl_take isl_ast_node *node,
12969                         __isl_keep isl_ast_build *build,
12970                         void *user), void *user);
12972 The callback set by C<isl_ast_build_set_at_each_domain> will
12973 be called for each domain AST node.
12974 The callbacks set by C<isl_ast_build_set_before_each_for>
12975 and C<isl_ast_build_set_after_each_for> will be called
12976 for each for AST node.  The first will be called in depth-first
12977 pre-order, while the second will be called in depth-first post-order.
12978 Since C<isl_ast_build_set_before_each_for> is called before the for
12979 node is actually constructed, it is only passed an C<isl_ast_build>.
12980 The returned C<isl_id> will be added as an annotation (using
12981 C<isl_ast_node_set_annotation>) to the constructed for node.
12982 In particular, if the user has also specified an C<after_each_for>
12983 callback, then the annotation can be retrieved from the node passed to
12984 that callback using C<isl_ast_node_get_annotation>.
12985 The callbacks set by C<isl_ast_build_set_before_each_mark>
12986 and C<isl_ast_build_set_after_each_mark> will be called for each
12987 mark AST node that is created, i.e., for each mark schedule node
12988 in the input schedule tree.  The first will be called in depth-first
12989 pre-order, while the second will be called in depth-first post-order.
12990 Since the callback set by C<isl_ast_build_set_before_each_mark>
12991 is called before the mark AST node is actually constructed, it is passed
12992 the identifier of the mark node.
12993 All callbacks should C<NULL> (or C<isl_stat_error>) on failure.
12994 The given C<isl_ast_build> can be used to create new
12995 C<isl_ast_expr> objects using C<isl_ast_build_expr_from_pw_aff>
12996 or C<isl_ast_build_call_from_pw_multi_aff>.
12998 =head3 Nested AST Generation
13000 C<isl> allows the user to create an AST within the context
13001 of another AST.  These nested ASTs are created using the
13002 same C<isl_ast_build_node_from_schedule_map> function that is used to create
13003 the outer AST.  The C<build> argument should be an C<isl_ast_build>
13004 passed to a callback set by
13005 C<isl_ast_build_set_create_leaf>.
13006 The space of the range of the C<schedule> argument should refer
13007 to this build.  In particular, the space should be a wrapped
13008 relation and the domain of this wrapped relation should be the
13009 same as that of the range of the schedule returned by
13010 C<isl_ast_build_get_schedule> below.
13011 In practice, the new schedule is typically
13012 created by calling C<isl_union_map_range_product> on the old schedule
13013 and some extra piece of the schedule.
13014 The space of the schedule domain is also available from
13015 the C<isl_ast_build>.
13017         #include <isl/ast_build.h>
13018         __isl_give isl_union_map *isl_ast_build_get_schedule(
13019                 __isl_keep isl_ast_build *build);
13020         __isl_give isl_space *isl_ast_build_get_schedule_space(
13021                 __isl_keep isl_ast_build *build);
13022         __isl_give isl_ast_build *isl_ast_build_restrict(
13023                 __isl_take isl_ast_build *build,
13024                 __isl_take isl_set *set);
13026 The C<isl_ast_build_get_schedule> function returns a (partial)
13027 schedule for the domains elements for which part of the AST still needs to
13028 be generated in the current build.
13029 In particular, the domain elements are mapped to those iterations of the loops
13030 enclosing the current point of the AST generation inside which
13031 the domain elements are executed.
13032 No direct correspondence between
13033 the input schedule and this schedule should be assumed.
13034 The space obtained from C<isl_ast_build_get_schedule_space> can be used
13035 to create a set for C<isl_ast_build_restrict> to intersect
13036 with the current build.  In particular, the set passed to
13037 C<isl_ast_build_restrict> can have additional parameters.
13038 The ids of the set dimensions in the space returned by
13039 C<isl_ast_build_get_schedule_space> correspond to the
13040 iterators of the already generated loops.
13041 The user should not rely on the ids of the output dimensions
13042 of the relations in the union relation returned by
13043 C<isl_ast_build_get_schedule> having any particular value.
13045 =head1 Applications
13047 Although C<isl> is mainly meant to be used as a library,
13048 it also contains some basic applications that use some
13049 of the functionality of C<isl>.
13050 For applications that take one or more polytopes or polyhedra
13051 as input, this input may be specified in either the L<isl format>
13052 or the L<PolyLib format>.
13054 =head2 C<isl_polyhedron_sample>
13056 C<isl_polyhedron_sample> takes a polyhedron as input and prints
13057 an integer element of the polyhedron, if there is any.
13058 The first column in the output is the denominator and is always
13059 equal to 1.  If the polyhedron contains no integer points,
13060 then a vector of length zero is printed.
13062 =head2 C<isl_pip>
13064 C<isl_pip> takes the same input as the C<example> program
13065 from the C<piplib> distribution, i.e., a set of constraints
13066 on the parameters, a line containing only -1 and finally a set
13067 of constraints on a parametric polyhedron.
13068 The coefficients of the parameters appear in the last columns
13069 (but before the final constant column).
13070 The output is the lexicographic minimum of the parametric polyhedron.
13071 As C<isl> currently does not have its own output format, the output
13072 is just a dump of the internal state.
13074 =head2 C<isl_polyhedron_minimize>
13076 C<isl_polyhedron_minimize> computes the minimum of some linear
13077 or affine objective function over the integer points in a polyhedron.
13078 If an affine objective function
13079 is given, then the constant should appear in the last column.
13081 =head2 C<isl_polytope_scan>
13083 Given a polytope, C<isl_polytope_scan> prints
13084 all integer points in the polytope.
13086 =head2 C<isl_flow>
13088 Given an C<isl_union_access_info> object as input,
13089 C<isl_flow> prints out the corresponding dependences,
13090 as computed by C<isl_union_access_info_compute_flow>.
13092 =head2 C<isl_codegen>
13094 Given either a schedule tree or a sequence consisting of
13095 a schedule map, a context set and an options relation,
13096 C<isl_codegen> prints out an AST that scans the domain elements
13097 of the schedule in the order of their image(s) taking into account
13098 the constraints in the context set.
13100 =head2 C<isl_schedule>
13102 Given an C<isl_schedule_constraints> object as input,
13103 C<isl_schedule> prints out a schedule that satisfies the given
13104 constraints.