1/*
2 * Copyright 2011 INRIA Saclay
3 * Copyright 2011 Sven Verdoolaege
4 * Copyright 2012-2014 Ecole Normale Superieure
5 * Copyright 2014 INRIA Rocquencourt
6 * Copyright 2016 Sven Verdoolaege
7 * Copyright 2018,2020 Cerebras Systems
8 * Copyright 2021 Sven Verdoolaege
9 * Copyright 2022 Cerebras Systems
10 *
11 * Use of this software is governed by the MIT license
12 *
13 * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
14 * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
15 * 91893 Orsay, France
16 * and Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
17 * and Inria Paris - Rocquencourt, Domaine de Voluceau - Rocquencourt,
18 * B.P. 105 - 78153 Le Chesnay, France
19 * and Cerebras Systems, 175 S San Antonio Rd, Los Altos, CA, USA
20 * and Cerebras Systems, 1237 E Arques Ave, Sunnyvale, CA, USA
21 */
22
23#include <isl_ctx_private.h>
24#include <isl_map_private.h>
25#include <isl_union_map_private.h>
26#include <isl_aff_private.h>
27#include <isl_space_private.h>
28#include <isl_local_space_private.h>
29#include <isl_vec_private.h>
30#include <isl_mat_private.h>
31#include <isl_id_private.h>
32#include <isl/constraint.h>
33#include <isl_seq.h>
34#include <isl/set.h>
35#include <isl_val_private.h>
36#include <isl_point_private.h>
37#include <isl_config.h>
38
39#undef EL_BASE
40#define EL_BASE aff
41
42#include <isl_list_templ.c>
43#include <isl_list_read_templ.c>
44
45#undef EL_BASE
46#define EL_BASE pw_aff
47
48#include <isl_list_templ.c>
49#include <isl_list_read_templ.c>
50
51#undef EL_BASE
52#define EL_BASE pw_multi_aff
53
54#include <isl_list_templ.c>
55#include <isl_list_read_templ.c>
56
57#undef EL_BASE
58#define EL_BASE union_pw_aff
59
60#include <isl_list_templ.c>
61#include <isl_list_read_templ.c>
62
63#undef EL_BASE
64#define EL_BASE union_pw_multi_aff
65
66#include <isl_list_templ.c>
67
68/* Construct an isl_aff from the given domain local space "ls" and
69 * coefficients "v", where the local space is known to be valid
70 * for an affine expression.
71 */
72static __isl_give isl_aff *isl_aff_alloc_vec_validated(
73 __isl_take isl_local_space *ls, __isl_take isl_vec *v)
74{
75 isl_aff *aff;
76
77 if (!ls || !v)
78 goto error;
79
80 aff = isl_calloc_type(v->ctx, struct isl_aff);
81 if (!aff)
82 goto error;
83
84 aff->ref = 1;
85 aff->ls = ls;
86 aff->v = v;
87
88 return aff;
89error:
90 isl_local_space_free(ls);
91 isl_vec_free(vec: v);
92 return NULL;
93}
94
95/* Construct an isl_aff from the given domain local space "ls" and
96 * coefficients "v".
97 *
98 * First check that "ls" is a valid domain local space
99 * for an affine expression.
100 */
101__isl_give isl_aff *isl_aff_alloc_vec(__isl_take isl_local_space *ls,
102 __isl_take isl_vec *v)
103{
104 isl_ctx *ctx;
105
106 if (!ls)
107 return NULL;
108
109 ctx = isl_local_space_get_ctx(ls);
110 if (!isl_local_space_divs_known(ls))
111 isl_die(ctx, isl_error_invalid, "local space has unknown divs",
112 goto error);
113 if (!isl_local_space_is_set(ls))
114 isl_die(ctx, isl_error_invalid,
115 "domain of affine expression should be a set",
116 goto error);
117 return isl_aff_alloc_vec_validated(ls, v);
118error:
119 isl_local_space_free(ls);
120 isl_vec_free(vec: v);
121 return NULL;
122}
123
124__isl_give isl_aff *isl_aff_alloc(__isl_take isl_local_space *ls)
125{
126 isl_ctx *ctx;
127 isl_vec *v;
128 isl_size total;
129
130 if (!ls)
131 return NULL;
132
133 ctx = isl_local_space_get_ctx(ls);
134
135 total = isl_local_space_dim(ls, type: isl_dim_all);
136 if (total < 0)
137 goto error;
138 v = isl_vec_alloc(ctx, size: 1 + 1 + total);
139 return isl_aff_alloc_vec(ls, v);
140error:
141 isl_local_space_free(ls);
142 return NULL;
143}
144
145__isl_give isl_aff *isl_aff_copy(__isl_keep isl_aff *aff)
146{
147 if (!aff)
148 return NULL;
149
150 aff->ref++;
151 return aff;
152}
153
154__isl_give isl_aff *isl_aff_dup(__isl_keep isl_aff *aff)
155{
156 if (!aff)
157 return NULL;
158
159 return isl_aff_alloc_vec_validated(ls: isl_local_space_copy(ls: aff->ls),
160 v: isl_vec_copy(vec: aff->v));
161}
162
163__isl_give isl_aff *isl_aff_cow(__isl_take isl_aff *aff)
164{
165 if (!aff)
166 return NULL;
167
168 if (aff->ref == 1)
169 return aff;
170 aff->ref--;
171 return isl_aff_dup(aff);
172}
173
174__isl_give isl_aff *isl_aff_zero_on_domain(__isl_take isl_local_space *ls)
175{
176 isl_aff *aff;
177
178 aff = isl_aff_alloc(ls);
179 if (!aff)
180 return NULL;
181
182 isl_int_set_si(aff->v->el[0], 1);
183 isl_seq_clr(p: aff->v->el + 1, len: aff->v->size - 1);
184
185 return aff;
186}
187
188/* Return an affine expression that is equal to zero on domain space "space".
189 */
190__isl_give isl_aff *isl_aff_zero_on_domain_space(__isl_take isl_space *space)
191{
192 return isl_aff_zero_on_domain(ls: isl_local_space_from_space(space));
193}
194
195/* This function performs the same operation as isl_aff_zero_on_domain_space,
196 * but is considered as a function on an isl_space when exported.
197 */
198__isl_give isl_aff *isl_space_zero_aff_on_domain(__isl_take isl_space *space)
199{
200 return isl_aff_zero_on_domain_space(space);
201}
202
203/* Return a piecewise affine expression defined on the specified domain
204 * that is equal to zero.
205 */
206__isl_give isl_pw_aff *isl_pw_aff_zero_on_domain(__isl_take isl_local_space *ls)
207{
208 return isl_pw_aff_from_aff(aff: isl_aff_zero_on_domain(ls));
209}
210
211/* Change "aff" into a NaN.
212 *
213 * Note that this function gets called from isl_aff_nan_on_domain,
214 * so "aff" may not have been initialized yet.
215 */
216static __isl_give isl_aff *isl_aff_set_nan(__isl_take isl_aff *aff)
217{
218 aff = isl_aff_cow(aff);
219 if (!aff)
220 return NULL;
221
222 aff->v = isl_vec_clr(vec: aff->v);
223 if (!aff->v)
224 return isl_aff_free(aff);
225
226 return aff;
227}
228
229/* Return an affine expression defined on the specified domain
230 * that represents NaN.
231 */
232__isl_give isl_aff *isl_aff_nan_on_domain(__isl_take isl_local_space *ls)
233{
234 isl_aff *aff;
235
236 aff = isl_aff_alloc(ls);
237 return isl_aff_set_nan(aff);
238}
239
240/* Return an affine expression defined on the specified domain space
241 * that represents NaN.
242 */
243__isl_give isl_aff *isl_aff_nan_on_domain_space(__isl_take isl_space *space)
244{
245 return isl_aff_nan_on_domain(ls: isl_local_space_from_space(space));
246}
247
248/* Return a piecewise affine expression defined on the specified domain space
249 * that represents NaN.
250 */
251__isl_give isl_pw_aff *isl_pw_aff_nan_on_domain_space(
252 __isl_take isl_space *space)
253{
254 return isl_pw_aff_from_aff(aff: isl_aff_nan_on_domain_space(space));
255}
256
257/* Return a piecewise affine expression defined on the specified domain
258 * that represents NaN.
259 */
260__isl_give isl_pw_aff *isl_pw_aff_nan_on_domain(__isl_take isl_local_space *ls)
261{
262 return isl_pw_aff_from_aff(aff: isl_aff_nan_on_domain(ls));
263}
264
265/* Return an affine expression that is equal to "val" on
266 * domain local space "ls".
267 *
268 * Note that the encoding for the special value NaN
269 * is the same in isl_val and isl_aff, so this does not need
270 * to be treated in any special way.
271 */
272__isl_give isl_aff *isl_aff_val_on_domain(__isl_take isl_local_space *ls,
273 __isl_take isl_val *val)
274{
275 isl_aff *aff;
276
277 if (!ls || !val)
278 goto error;
279 if (!isl_val_is_rat(v: val) && !isl_val_is_nan(v: val))
280 isl_die(isl_val_get_ctx(val), isl_error_invalid,
281 "expecting rational value or NaN", goto error);
282
283 aff = isl_aff_alloc(ls: isl_local_space_copy(ls));
284 if (!aff)
285 goto error;
286
287 isl_seq_clr(p: aff->v->el + 2, len: aff->v->size - 2);
288 isl_int_set(aff->v->el[1], val->n);
289 isl_int_set(aff->v->el[0], val->d);
290
291 isl_local_space_free(ls);
292 isl_val_free(v: val);
293 return aff;
294error:
295 isl_local_space_free(ls);
296 isl_val_free(v: val);
297 return NULL;
298}
299
300/* Return an affine expression that is equal to "val" on domain space "space".
301 */
302__isl_give isl_aff *isl_aff_val_on_domain_space(__isl_take isl_space *space,
303 __isl_take isl_val *val)
304{
305 return isl_aff_val_on_domain(ls: isl_local_space_from_space(space), val);
306}
307
308/* Return an affine expression that is equal to the specified dimension
309 * in "ls".
310 */
311__isl_give isl_aff *isl_aff_var_on_domain(__isl_take isl_local_space *ls,
312 enum isl_dim_type type, unsigned pos)
313{
314 isl_space *space;
315 isl_aff *aff;
316
317 if (!ls)
318 return NULL;
319
320 space = isl_local_space_get_space(ls);
321 if (!space)
322 goto error;
323 if (isl_space_is_map(space))
324 isl_die(isl_space_get_ctx(space), isl_error_invalid,
325 "expecting (parameter) set space", goto error);
326 if (isl_local_space_check_range(ls, type, first: pos, n: 1) < 0)
327 goto error;
328
329 isl_space_free(space);
330 aff = isl_aff_alloc(ls);
331 if (!aff)
332 return NULL;
333
334 pos += isl_local_space_offset(ls: aff->ls, type);
335
336 isl_int_set_si(aff->v->el[0], 1);
337 isl_seq_clr(p: aff->v->el + 1, len: aff->v->size - 1);
338 isl_int_set_si(aff->v->el[1 + pos], 1);
339
340 return aff;
341error:
342 isl_local_space_free(ls);
343 isl_space_free(space);
344 return NULL;
345}
346
347/* Return a piecewise affine expression that is equal to
348 * the specified dimension in "ls".
349 */
350__isl_give isl_pw_aff *isl_pw_aff_var_on_domain(__isl_take isl_local_space *ls,
351 enum isl_dim_type type, unsigned pos)
352{
353 return isl_pw_aff_from_aff(aff: isl_aff_var_on_domain(ls, type, pos));
354}
355
356/* Return an affine expression that is equal to the parameter
357 * in the domain space "space" with identifier "id".
358 */
359__isl_give isl_aff *isl_aff_param_on_domain_space_id(
360 __isl_take isl_space *space, __isl_take isl_id *id)
361{
362 int pos;
363 isl_local_space *ls;
364
365 if (!space || !id)
366 goto error;
367 pos = isl_space_find_dim_by_id(space, type: isl_dim_param, id);
368 if (pos < 0)
369 isl_die(isl_space_get_ctx(space), isl_error_invalid,
370 "parameter not found in space", goto error);
371 isl_id_free(id);
372 ls = isl_local_space_from_space(space);
373 return isl_aff_var_on_domain(ls, type: isl_dim_param, pos);
374error:
375 isl_space_free(space);
376 isl_id_free(id);
377 return NULL;
378}
379
380/* This function performs the same operation as
381 * isl_aff_param_on_domain_space_id,
382 * but is considered as a function on an isl_space when exported.
383 */
384__isl_give isl_aff *isl_space_param_aff_on_domain_id(
385 __isl_take isl_space *space, __isl_take isl_id *id)
386{
387 return isl_aff_param_on_domain_space_id(space, id);
388}
389
390__isl_null isl_aff *isl_aff_free(__isl_take isl_aff *aff)
391{
392 if (!aff)
393 return NULL;
394
395 if (--aff->ref > 0)
396 return NULL;
397
398 isl_local_space_free(ls: aff->ls);
399 isl_vec_free(vec: aff->v);
400
401 free(ptr: aff);
402
403 return NULL;
404}
405
406isl_ctx *isl_aff_get_ctx(__isl_keep isl_aff *aff)
407{
408 return aff ? isl_local_space_get_ctx(ls: aff->ls) : NULL;
409}
410
411/* Return a hash value that digests "aff".
412 */
413uint32_t isl_aff_get_hash(__isl_keep isl_aff *aff)
414{
415 uint32_t hash, ls_hash, v_hash;
416
417 if (!aff)
418 return 0;
419
420 hash = isl_hash_init();
421 ls_hash = isl_local_space_get_hash(ls: aff->ls);
422 isl_hash_hash(hash, ls_hash);
423 v_hash = isl_vec_get_hash(vec: aff->v);
424 isl_hash_hash(hash, v_hash);
425
426 return hash;
427}
428
429/* Return the domain local space of "aff".
430 */
431static __isl_keep isl_local_space *isl_aff_peek_domain_local_space(
432 __isl_keep isl_aff *aff)
433{
434 return aff ? aff->ls : NULL;
435}
436
437/* Return the number of variables of the given type in the domain of "aff".
438 */
439isl_size isl_aff_domain_dim(__isl_keep isl_aff *aff, enum isl_dim_type type)
440{
441 isl_local_space *ls;
442
443 ls = isl_aff_peek_domain_local_space(aff);
444 return isl_local_space_dim(ls, type);
445}
446
447/* Externally, an isl_aff has a map space, but internally, the
448 * ls field corresponds to the domain of that space.
449 */
450isl_size isl_aff_dim(__isl_keep isl_aff *aff, enum isl_dim_type type)
451{
452 if (!aff)
453 return isl_size_error;
454 if (type == isl_dim_out)
455 return 1;
456 if (type == isl_dim_in)
457 type = isl_dim_set;
458 return isl_aff_domain_dim(aff, type);
459}
460
461/* Return the offset of the first coefficient of type "type" in
462 * the domain of "aff".
463 */
464isl_size isl_aff_domain_offset(__isl_keep isl_aff *aff, enum isl_dim_type type)
465{
466 isl_local_space *ls;
467
468 ls = isl_aff_peek_domain_local_space(aff);
469 return isl_local_space_offset(ls, type);
470}
471
472/* Return the position of the dimension of the given type and name
473 * in "aff".
474 * Return -1 if no such dimension can be found.
475 */
476int isl_aff_find_dim_by_name(__isl_keep isl_aff *aff, enum isl_dim_type type,
477 const char *name)
478{
479 if (!aff)
480 return -1;
481 if (type == isl_dim_out)
482 return -1;
483 if (type == isl_dim_in)
484 type = isl_dim_set;
485 return isl_local_space_find_dim_by_name(ls: aff->ls, type, name);
486}
487
488/* Return the domain space of "aff".
489 */
490static __isl_keep isl_space *isl_aff_peek_domain_space(__isl_keep isl_aff *aff)
491{
492 return aff ? isl_local_space_peek_space(ls: aff->ls) : NULL;
493}
494
495__isl_give isl_space *isl_aff_get_domain_space(__isl_keep isl_aff *aff)
496{
497 return isl_space_copy(space: isl_aff_peek_domain_space(aff));
498}
499
500__isl_give isl_space *isl_aff_get_space(__isl_keep isl_aff *aff)
501{
502 isl_space *space;
503 if (!aff)
504 return NULL;
505 space = isl_local_space_get_space(ls: aff->ls);
506 space = isl_space_from_domain(space);
507 space = isl_space_add_dims(space, type: isl_dim_out, n: 1);
508 return space;
509}
510
511/* Return a copy of the domain space of "aff".
512 */
513__isl_give isl_local_space *isl_aff_get_domain_local_space(
514 __isl_keep isl_aff *aff)
515{
516 return isl_local_space_copy(ls: isl_aff_peek_domain_local_space(aff));
517}
518
519__isl_give isl_local_space *isl_aff_get_local_space(__isl_keep isl_aff *aff)
520{
521 isl_local_space *ls;
522 if (!aff)
523 return NULL;
524 ls = isl_local_space_copy(ls: aff->ls);
525 ls = isl_local_space_from_domain(ls);
526 ls = isl_local_space_add_dims(ls, type: isl_dim_out, n: 1);
527 return ls;
528}
529
530/* Return the local space of the domain of "aff".
531 * This may be either a copy or the local space itself
532 * if there is only one reference to "aff".
533 * This allows the local space to be modified inplace
534 * if both the expression and its local space have only a single reference.
535 * The caller is not allowed to modify "aff" between this call and
536 * a subsequent call to isl_aff_restore_domain_local_space.
537 * The only exception is that isl_aff_free can be called instead.
538 */
539__isl_give isl_local_space *isl_aff_take_domain_local_space(
540 __isl_keep isl_aff *aff)
541{
542 isl_local_space *ls;
543
544 if (!aff)
545 return NULL;
546 if (aff->ref != 1)
547 return isl_aff_get_domain_local_space(aff);
548 ls = aff->ls;
549 aff->ls = NULL;
550 return ls;
551}
552
553/* Set the local space of the domain of "aff" to "ls",
554 * where the local space of "aff" may be missing
555 * due to a preceding call to isl_aff_take_domain_local_space.
556 * However, in this case, "aff" only has a single reference and
557 * then the call to isl_aff_cow has no effect.
558 */
559__isl_give isl_aff *isl_aff_restore_domain_local_space(
560 __isl_keep isl_aff *aff, __isl_take isl_local_space *ls)
561{
562 if (!aff || !ls)
563 goto error;
564
565 if (aff->ls == ls) {
566 isl_local_space_free(ls);
567 return aff;
568 }
569
570 aff = isl_aff_cow(aff);
571 if (!aff)
572 goto error;
573 isl_local_space_free(ls: aff->ls);
574 aff->ls = ls;
575
576 return aff;
577error:
578 isl_aff_free(aff);
579 isl_local_space_free(ls);
580 return NULL;
581}
582
583/* Externally, an isl_aff has a map space, but internally, the
584 * ls field corresponds to the domain of that space.
585 */
586const char *isl_aff_get_dim_name(__isl_keep isl_aff *aff,
587 enum isl_dim_type type, unsigned pos)
588{
589 if (!aff)
590 return NULL;
591 if (type == isl_dim_out)
592 return NULL;
593 if (type == isl_dim_in)
594 type = isl_dim_set;
595 return isl_local_space_get_dim_name(ls: aff->ls, type, pos);
596}
597
598__isl_give isl_aff *isl_aff_reset_domain_space(__isl_take isl_aff *aff,
599 __isl_take isl_space *space)
600{
601 aff = isl_aff_cow(aff);
602 if (!aff || !space)
603 goto error;
604
605 aff->ls = isl_local_space_reset_space(ls: aff->ls, space);
606 if (!aff->ls)
607 return isl_aff_free(aff);
608
609 return aff;
610error:
611 isl_aff_free(aff);
612 isl_space_free(space);
613 return NULL;
614}
615
616/* Reset the space of "aff". This function is called from isl_pw_templ.c
617 * and doesn't know if the space of an element object is represented
618 * directly or through its domain. It therefore passes along both.
619 */
620__isl_give isl_aff *isl_aff_reset_space_and_domain(__isl_take isl_aff *aff,
621 __isl_take isl_space *space, __isl_take isl_space *domain)
622{
623 isl_space_free(space);
624 return isl_aff_reset_domain_space(aff, space: domain);
625}
626
627/* Reorder the dimensions of the domain of "aff" according
628 * to the given reordering.
629 */
630__isl_give isl_aff *isl_aff_realign_domain(__isl_take isl_aff *aff,
631 __isl_take isl_reordering *r)
632{
633 aff = isl_aff_cow(aff);
634 if (!aff)
635 goto error;
636
637 r = isl_reordering_extend(exp: r, extra: aff->ls->div->n_row);
638 aff->v = isl_vec_reorder(vec: aff->v, offset: 2, r: isl_reordering_copy(exp: r));
639 aff->ls = isl_local_space_realign(ls: aff->ls, r);
640
641 if (!aff->v || !aff->ls)
642 return isl_aff_free(aff);
643
644 return aff;
645error:
646 isl_aff_free(aff);
647 isl_reordering_free(exp: r);
648 return NULL;
649}
650
651__isl_give isl_aff *isl_aff_align_params(__isl_take isl_aff *aff,
652 __isl_take isl_space *model)
653{
654 isl_space *domain_space;
655 isl_bool equal_params;
656
657 domain_space = isl_aff_peek_domain_space(aff);
658 equal_params = isl_space_has_equal_params(space1: domain_space, space2: model);
659 if (equal_params < 0)
660 goto error;
661 if (!equal_params) {
662 isl_reordering *exp;
663
664 exp = isl_parameter_alignment_reordering(alignee: domain_space, aligner: model);
665 aff = isl_aff_realign_domain(aff, r: exp);
666 }
667
668 isl_space_free(space: model);
669 return aff;
670error:
671 isl_space_free(space: model);
672 isl_aff_free(aff);
673 return NULL;
674}
675
676#undef TYPE
677#define TYPE isl_aff
678#include "isl_unbind_params_templ.c"
679
680/* Is "aff" obviously equal to zero?
681 *
682 * If the denominator is zero, then "aff" is not equal to zero.
683 */
684isl_bool isl_aff_plain_is_zero(__isl_keep isl_aff *aff)
685{
686 int pos;
687
688 if (!aff)
689 return isl_bool_error;
690
691 if (isl_int_is_zero(aff->v->el[0]))
692 return isl_bool_false;
693 pos = isl_seq_first_non_zero(p: aff->v->el + 1, len: aff->v->size - 1);
694 return isl_bool_ok(b: pos < 0);
695}
696
697/* Does "aff" represent NaN?
698 */
699isl_bool isl_aff_is_nan(__isl_keep isl_aff *aff)
700{
701 if (!aff)
702 return isl_bool_error;
703
704 return isl_bool_ok(b: isl_seq_first_non_zero(p: aff->v->el, len: 2) < 0);
705}
706
707/* Are "aff1" and "aff2" obviously equal?
708 *
709 * NaN is not equal to anything, not even to another NaN.
710 */
711isl_bool isl_aff_plain_is_equal(__isl_keep isl_aff *aff1,
712 __isl_keep isl_aff *aff2)
713{
714 isl_bool equal;
715
716 if (!aff1 || !aff2)
717 return isl_bool_error;
718
719 if (isl_aff_is_nan(aff: aff1) || isl_aff_is_nan(aff: aff2))
720 return isl_bool_false;
721
722 equal = isl_local_space_is_equal(ls1: aff1->ls, ls2: aff2->ls);
723 if (equal < 0 || !equal)
724 return equal;
725
726 return isl_vec_is_equal(vec1: aff1->v, vec2: aff2->v);
727}
728
729/* Return the common denominator of "aff" in "v".
730 *
731 * We cannot return anything meaningful in case of a NaN.
732 */
733isl_stat isl_aff_get_denominator(__isl_keep isl_aff *aff, isl_int *v)
734{
735 if (!aff)
736 return isl_stat_error;
737 if (isl_aff_is_nan(aff))
738 isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
739 "cannot get denominator of NaN", return isl_stat_error);
740 isl_int_set(*v, aff->v->el[0]);
741 return isl_stat_ok;
742}
743
744/* Return the common denominator of "aff".
745 */
746__isl_give isl_val *isl_aff_get_denominator_val(__isl_keep isl_aff *aff)
747{
748 isl_ctx *ctx;
749
750 if (!aff)
751 return NULL;
752
753 ctx = isl_aff_get_ctx(aff);
754 if (isl_aff_is_nan(aff))
755 return isl_val_nan(ctx);
756 return isl_val_int_from_isl_int(ctx, n: aff->v->el[0]);
757}
758
759/* Return the constant term of "aff".
760 */
761__isl_give isl_val *isl_aff_get_constant_val(__isl_keep isl_aff *aff)
762{
763 isl_ctx *ctx;
764 isl_val *v;
765
766 if (!aff)
767 return NULL;
768
769 ctx = isl_aff_get_ctx(aff);
770 if (isl_aff_is_nan(aff))
771 return isl_val_nan(ctx);
772 v = isl_val_rat_from_isl_int(ctx, n: aff->v->el[1], d: aff->v->el[0]);
773 return isl_val_normalize(v);
774}
775
776/* Return the coefficient of the variable of type "type" at position "pos"
777 * of "aff".
778 */
779__isl_give isl_val *isl_aff_get_coefficient_val(__isl_keep isl_aff *aff,
780 enum isl_dim_type type, int pos)
781{
782 isl_ctx *ctx;
783 isl_val *v;
784
785 if (!aff)
786 return NULL;
787
788 ctx = isl_aff_get_ctx(aff);
789 if (type == isl_dim_out)
790 isl_die(ctx, isl_error_invalid,
791 "output/set dimension does not have a coefficient",
792 return NULL);
793 if (type == isl_dim_in)
794 type = isl_dim_set;
795
796 if (isl_local_space_check_range(ls: aff->ls, type, first: pos, n: 1) < 0)
797 return NULL;
798
799 if (isl_aff_is_nan(aff))
800 return isl_val_nan(ctx);
801 pos += isl_local_space_offset(ls: aff->ls, type);
802 v = isl_val_rat_from_isl_int(ctx, n: aff->v->el[1 + pos], d: aff->v->el[0]);
803 return isl_val_normalize(v);
804}
805
806/* Return the sign of the coefficient of the variable of type "type"
807 * at position "pos" of "aff".
808 */
809int isl_aff_coefficient_sgn(__isl_keep isl_aff *aff, enum isl_dim_type type,
810 int pos)
811{
812 isl_ctx *ctx;
813
814 if (!aff)
815 return 0;
816
817 ctx = isl_aff_get_ctx(aff);
818 if (type == isl_dim_out)
819 isl_die(ctx, isl_error_invalid,
820 "output/set dimension does not have a coefficient",
821 return 0);
822 if (type == isl_dim_in)
823 type = isl_dim_set;
824
825 if (isl_local_space_check_range(ls: aff->ls, type, first: pos, n: 1) < 0)
826 return 0;
827
828 pos += isl_local_space_offset(ls: aff->ls, type);
829 return isl_int_sgn(aff->v->el[1 + pos]);
830}
831
832/* Replace the numerator of the constant term of "aff" by "v".
833 *
834 * A NaN is unaffected by this operation.
835 */
836__isl_give isl_aff *isl_aff_set_constant(__isl_take isl_aff *aff, isl_int v)
837{
838 if (!aff)
839 return NULL;
840 if (isl_aff_is_nan(aff))
841 return aff;
842 aff = isl_aff_cow(aff);
843 if (!aff)
844 return NULL;
845
846 aff->v = isl_vec_cow(vec: aff->v);
847 if (!aff->v)
848 return isl_aff_free(aff);
849
850 isl_int_set(aff->v->el[1], v);
851
852 return aff;
853}
854
855/* Replace the constant term of "aff" by "v".
856 *
857 * A NaN is unaffected by this operation.
858 */
859__isl_give isl_aff *isl_aff_set_constant_val(__isl_take isl_aff *aff,
860 __isl_take isl_val *v)
861{
862 if (!aff || !v)
863 goto error;
864
865 if (isl_aff_is_nan(aff)) {
866 isl_val_free(v);
867 return aff;
868 }
869
870 if (!isl_val_is_rat(v))
871 isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
872 "expecting rational value", goto error);
873
874 if (isl_int_eq(aff->v->el[1], v->n) &&
875 isl_int_eq(aff->v->el[0], v->d)) {
876 isl_val_free(v);
877 return aff;
878 }
879
880 aff = isl_aff_cow(aff);
881 if (!aff)
882 goto error;
883 aff->v = isl_vec_cow(vec: aff->v);
884 if (!aff->v)
885 goto error;
886
887 if (isl_int_eq(aff->v->el[0], v->d)) {
888 isl_int_set(aff->v->el[1], v->n);
889 } else if (isl_int_is_one(v->d)) {
890 isl_int_mul(aff->v->el[1], aff->v->el[0], v->n);
891 } else {
892 isl_seq_scale(dst: aff->v->el + 1,
893 src: aff->v->el + 1, f: v->d, len: aff->v->size - 1);
894 isl_int_mul(aff->v->el[1], aff->v->el[0], v->n);
895 isl_int_mul(aff->v->el[0], aff->v->el[0], v->d);
896 aff->v = isl_vec_normalize(vec: aff->v);
897 if (!aff->v)
898 goto error;
899 }
900
901 isl_val_free(v);
902 return aff;
903error:
904 isl_aff_free(aff);
905 isl_val_free(v);
906 return NULL;
907}
908
909/* Add "v" to the constant term of "aff".
910 *
911 * A NaN is unaffected by this operation.
912 */
913__isl_give isl_aff *isl_aff_add_constant(__isl_take isl_aff *aff, isl_int v)
914{
915 if (isl_int_is_zero(v))
916 return aff;
917
918 if (!aff)
919 return NULL;
920 if (isl_aff_is_nan(aff))
921 return aff;
922 aff = isl_aff_cow(aff);
923 if (!aff)
924 return NULL;
925
926 aff->v = isl_vec_cow(vec: aff->v);
927 if (!aff->v)
928 return isl_aff_free(aff);
929
930 isl_int_addmul(aff->v->el[1], aff->v->el[0], v);
931
932 return aff;
933}
934
935/* Add "v" to the constant term of "aff",
936 * in case "aff" is a rational expression.
937 */
938static __isl_give isl_aff *isl_aff_add_rat_constant_val(__isl_take isl_aff *aff,
939 __isl_take isl_val *v)
940{
941 aff = isl_aff_cow(aff);
942 if (!aff)
943 goto error;
944
945 aff->v = isl_vec_cow(vec: aff->v);
946 if (!aff->v)
947 goto error;
948
949 if (isl_int_is_one(v->d)) {
950 isl_int_addmul(aff->v->el[1], aff->v->el[0], v->n);
951 } else if (isl_int_eq(aff->v->el[0], v->d)) {
952 isl_int_add(aff->v->el[1], aff->v->el[1], v->n);
953 aff->v = isl_vec_normalize(vec: aff->v);
954 if (!aff->v)
955 goto error;
956 } else {
957 isl_seq_scale(dst: aff->v->el + 1,
958 src: aff->v->el + 1, f: v->d, len: aff->v->size - 1);
959 isl_int_addmul(aff->v->el[1], aff->v->el[0], v->n);
960 isl_int_mul(aff->v->el[0], aff->v->el[0], v->d);
961 aff->v = isl_vec_normalize(vec: aff->v);
962 if (!aff->v)
963 goto error;
964 }
965
966 isl_val_free(v);
967 return aff;
968error:
969 isl_aff_free(aff);
970 isl_val_free(v);
971 return NULL;
972}
973
974/* Return the first argument and free the second.
975 */
976static __isl_give isl_aff *pick_free(__isl_take isl_aff *aff,
977 __isl_take isl_val *v)
978{
979 isl_val_free(v);
980 return aff;
981}
982
983/* Replace the first argument by NaN and free the second argument.
984 */
985static __isl_give isl_aff *set_nan_free_val(__isl_take isl_aff *aff,
986 __isl_take isl_val *v)
987{
988 isl_val_free(v);
989 return isl_aff_set_nan(aff);
990}
991
992/* Add "v" to the constant term of "aff".
993 *
994 * A NaN is unaffected by this operation.
995 * Conversely, adding a NaN turns "aff" into a NaN.
996 */
997__isl_give isl_aff *isl_aff_add_constant_val(__isl_take isl_aff *aff,
998 __isl_take isl_val *v)
999{
1000 isl_bool is_nan, is_zero, is_rat;
1001
1002 is_nan = isl_aff_is_nan(aff);
1003 is_zero = isl_val_is_zero(v);
1004 if (is_nan < 0 || is_zero < 0)
1005 goto error;
1006 if (is_nan || is_zero)
1007 return pick_free(aff, v);
1008
1009 is_nan = isl_val_is_nan(v);
1010 is_rat = isl_val_is_rat(v);
1011 if (is_nan < 0 || is_rat < 0)
1012 goto error;
1013 if (is_nan)
1014 return set_nan_free_val(aff, v);
1015 if (!is_rat)
1016 isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
1017 "expecting rational value or NaN", goto error);
1018
1019 return isl_aff_add_rat_constant_val(aff, v);
1020error:
1021 isl_aff_free(aff);
1022 isl_val_free(v);
1023 return NULL;
1024}
1025
1026__isl_give isl_aff *isl_aff_add_constant_si(__isl_take isl_aff *aff, int v)
1027{
1028 isl_int t;
1029
1030 isl_int_init(t);
1031 isl_int_set_si(t, v);
1032 aff = isl_aff_add_constant(aff, v: t);
1033 isl_int_clear(t);
1034
1035 return aff;
1036}
1037
1038/* Add "v" to the numerator of the constant term of "aff".
1039 *
1040 * A NaN is unaffected by this operation.
1041 */
1042__isl_give isl_aff *isl_aff_add_constant_num(__isl_take isl_aff *aff, isl_int v)
1043{
1044 if (isl_int_is_zero(v))
1045 return aff;
1046
1047 if (!aff)
1048 return NULL;
1049 if (isl_aff_is_nan(aff))
1050 return aff;
1051 aff = isl_aff_cow(aff);
1052 if (!aff)
1053 return NULL;
1054
1055 aff->v = isl_vec_cow(vec: aff->v);
1056 if (!aff->v)
1057 return isl_aff_free(aff);
1058
1059 isl_int_add(aff->v->el[1], aff->v->el[1], v);
1060
1061 return aff;
1062}
1063
1064/* Add "v" to the numerator of the constant term of "aff".
1065 *
1066 * A NaN is unaffected by this operation.
1067 */
1068__isl_give isl_aff *isl_aff_add_constant_num_si(__isl_take isl_aff *aff, int v)
1069{
1070 isl_int t;
1071
1072 if (v == 0)
1073 return aff;
1074
1075 isl_int_init(t);
1076 isl_int_set_si(t, v);
1077 aff = isl_aff_add_constant_num(aff, v: t);
1078 isl_int_clear(t);
1079
1080 return aff;
1081}
1082
1083/* Replace the numerator of the constant term of "aff" by "v".
1084 *
1085 * A NaN is unaffected by this operation.
1086 */
1087__isl_give isl_aff *isl_aff_set_constant_si(__isl_take isl_aff *aff, int v)
1088{
1089 if (!aff)
1090 return NULL;
1091 if (isl_aff_is_nan(aff))
1092 return aff;
1093 aff = isl_aff_cow(aff);
1094 if (!aff)
1095 return NULL;
1096
1097 aff->v = isl_vec_cow(vec: aff->v);
1098 if (!aff->v)
1099 return isl_aff_free(aff);
1100
1101 isl_int_set_si(aff->v->el[1], v);
1102
1103 return aff;
1104}
1105
1106/* Replace the numerator of the coefficient of the variable of type "type"
1107 * at position "pos" of "aff" by "v".
1108 *
1109 * A NaN is unaffected by this operation.
1110 */
1111__isl_give isl_aff *isl_aff_set_coefficient(__isl_take isl_aff *aff,
1112 enum isl_dim_type type, int pos, isl_int v)
1113{
1114 if (!aff)
1115 return NULL;
1116
1117 if (type == isl_dim_out)
1118 isl_die(aff->v->ctx, isl_error_invalid,
1119 "output/set dimension does not have a coefficient",
1120 return isl_aff_free(aff));
1121 if (type == isl_dim_in)
1122 type = isl_dim_set;
1123
1124 if (isl_local_space_check_range(ls: aff->ls, type, first: pos, n: 1) < 0)
1125 return isl_aff_free(aff);
1126
1127 if (isl_aff_is_nan(aff))
1128 return aff;
1129 aff = isl_aff_cow(aff);
1130 if (!aff)
1131 return NULL;
1132
1133 aff->v = isl_vec_cow(vec: aff->v);
1134 if (!aff->v)
1135 return isl_aff_free(aff);
1136
1137 pos += isl_local_space_offset(ls: aff->ls, type);
1138 isl_int_set(aff->v->el[1 + pos], v);
1139
1140 return aff;
1141}
1142
1143/* Replace the numerator of the coefficient of the variable of type "type"
1144 * at position "pos" of "aff" by "v".
1145 *
1146 * A NaN is unaffected by this operation.
1147 */
1148__isl_give isl_aff *isl_aff_set_coefficient_si(__isl_take isl_aff *aff,
1149 enum isl_dim_type type, int pos, int v)
1150{
1151 if (!aff)
1152 return NULL;
1153
1154 if (type == isl_dim_out)
1155 isl_die(aff->v->ctx, isl_error_invalid,
1156 "output/set dimension does not have a coefficient",
1157 return isl_aff_free(aff));
1158 if (type == isl_dim_in)
1159 type = isl_dim_set;
1160
1161 if (isl_local_space_check_range(ls: aff->ls, type, first: pos, n: 1) < 0)
1162 return isl_aff_free(aff);
1163
1164 if (isl_aff_is_nan(aff))
1165 return aff;
1166 pos += isl_local_space_offset(ls: aff->ls, type);
1167 if (isl_int_cmp_si(aff->v->el[1 + pos], v) == 0)
1168 return aff;
1169
1170 aff = isl_aff_cow(aff);
1171 if (!aff)
1172 return NULL;
1173
1174 aff->v = isl_vec_cow(vec: aff->v);
1175 if (!aff->v)
1176 return isl_aff_free(aff);
1177
1178 isl_int_set_si(aff->v->el[1 + pos], v);
1179
1180 return aff;
1181}
1182
1183/* Replace the coefficient of the variable of type "type" at position "pos"
1184 * of "aff" by "v".
1185 *
1186 * A NaN is unaffected by this operation.
1187 */
1188__isl_give isl_aff *isl_aff_set_coefficient_val(__isl_take isl_aff *aff,
1189 enum isl_dim_type type, int pos, __isl_take isl_val *v)
1190{
1191 if (!aff || !v)
1192 goto error;
1193
1194 if (type == isl_dim_out)
1195 isl_die(aff->v->ctx, isl_error_invalid,
1196 "output/set dimension does not have a coefficient",
1197 goto error);
1198 if (type == isl_dim_in)
1199 type = isl_dim_set;
1200
1201 if (isl_local_space_check_range(ls: aff->ls, type, first: pos, n: 1) < 0)
1202 return isl_aff_free(aff);
1203
1204 if (isl_aff_is_nan(aff)) {
1205 isl_val_free(v);
1206 return aff;
1207 }
1208 if (!isl_val_is_rat(v))
1209 isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
1210 "expecting rational value", goto error);
1211
1212 pos += isl_local_space_offset(ls: aff->ls, type);
1213 if (isl_int_eq(aff->v->el[1 + pos], v->n) &&
1214 isl_int_eq(aff->v->el[0], v->d)) {
1215 isl_val_free(v);
1216 return aff;
1217 }
1218
1219 aff = isl_aff_cow(aff);
1220 if (!aff)
1221 goto error;
1222 aff->v = isl_vec_cow(vec: aff->v);
1223 if (!aff->v)
1224 goto error;
1225
1226 if (isl_int_eq(aff->v->el[0], v->d)) {
1227 isl_int_set(aff->v->el[1 + pos], v->n);
1228 } else if (isl_int_is_one(v->d)) {
1229 isl_int_mul(aff->v->el[1 + pos], aff->v->el[0], v->n);
1230 } else {
1231 isl_seq_scale(dst: aff->v->el + 1,
1232 src: aff->v->el + 1, f: v->d, len: aff->v->size - 1);
1233 isl_int_mul(aff->v->el[1 + pos], aff->v->el[0], v->n);
1234 isl_int_mul(aff->v->el[0], aff->v->el[0], v->d);
1235 aff->v = isl_vec_normalize(vec: aff->v);
1236 if (!aff->v)
1237 goto error;
1238 }
1239
1240 isl_val_free(v);
1241 return aff;
1242error:
1243 isl_aff_free(aff);
1244 isl_val_free(v);
1245 return NULL;
1246}
1247
1248/* Add "v" to the coefficient of the variable of type "type"
1249 * at position "pos" of "aff".
1250 *
1251 * A NaN is unaffected by this operation.
1252 */
1253__isl_give isl_aff *isl_aff_add_coefficient(__isl_take isl_aff *aff,
1254 enum isl_dim_type type, int pos, isl_int v)
1255{
1256 if (!aff)
1257 return NULL;
1258
1259 if (type == isl_dim_out)
1260 isl_die(aff->v->ctx, isl_error_invalid,
1261 "output/set dimension does not have a coefficient",
1262 return isl_aff_free(aff));
1263 if (type == isl_dim_in)
1264 type = isl_dim_set;
1265
1266 if (isl_local_space_check_range(ls: aff->ls, type, first: pos, n: 1) < 0)
1267 return isl_aff_free(aff);
1268
1269 if (isl_aff_is_nan(aff))
1270 return aff;
1271 aff = isl_aff_cow(aff);
1272 if (!aff)
1273 return NULL;
1274
1275 aff->v = isl_vec_cow(vec: aff->v);
1276 if (!aff->v)
1277 return isl_aff_free(aff);
1278
1279 pos += isl_local_space_offset(ls: aff->ls, type);
1280 isl_int_addmul(aff->v->el[1 + pos], aff->v->el[0], v);
1281
1282 return aff;
1283}
1284
1285/* Add "v" to the coefficient of the variable of type "type"
1286 * at position "pos" of "aff".
1287 *
1288 * A NaN is unaffected by this operation.
1289 */
1290__isl_give isl_aff *isl_aff_add_coefficient_val(__isl_take isl_aff *aff,
1291 enum isl_dim_type type, int pos, __isl_take isl_val *v)
1292{
1293 if (!aff || !v)
1294 goto error;
1295
1296 if (isl_val_is_zero(v)) {
1297 isl_val_free(v);
1298 return aff;
1299 }
1300
1301 if (type == isl_dim_out)
1302 isl_die(aff->v->ctx, isl_error_invalid,
1303 "output/set dimension does not have a coefficient",
1304 goto error);
1305 if (type == isl_dim_in)
1306 type = isl_dim_set;
1307
1308 if (isl_local_space_check_range(ls: aff->ls, type, first: pos, n: 1) < 0)
1309 goto error;
1310
1311 if (isl_aff_is_nan(aff)) {
1312 isl_val_free(v);
1313 return aff;
1314 }
1315 if (!isl_val_is_rat(v))
1316 isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
1317 "expecting rational value", goto error);
1318
1319 aff = isl_aff_cow(aff);
1320 if (!aff)
1321 goto error;
1322
1323 aff->v = isl_vec_cow(vec: aff->v);
1324 if (!aff->v)
1325 goto error;
1326
1327 pos += isl_local_space_offset(ls: aff->ls, type);
1328 if (isl_int_is_one(v->d)) {
1329 isl_int_addmul(aff->v->el[1 + pos], aff->v->el[0], v->n);
1330 } else if (isl_int_eq(aff->v->el[0], v->d)) {
1331 isl_int_add(aff->v->el[1 + pos], aff->v->el[1 + pos], v->n);
1332 aff->v = isl_vec_normalize(vec: aff->v);
1333 if (!aff->v)
1334 goto error;
1335 } else {
1336 isl_seq_scale(dst: aff->v->el + 1,
1337 src: aff->v->el + 1, f: v->d, len: aff->v->size - 1);
1338 isl_int_addmul(aff->v->el[1 + pos], aff->v->el[0], v->n);
1339 isl_int_mul(aff->v->el[0], aff->v->el[0], v->d);
1340 aff->v = isl_vec_normalize(vec: aff->v);
1341 if (!aff->v)
1342 goto error;
1343 }
1344
1345 isl_val_free(v);
1346 return aff;
1347error:
1348 isl_aff_free(aff);
1349 isl_val_free(v);
1350 return NULL;
1351}
1352
1353__isl_give isl_aff *isl_aff_add_coefficient_si(__isl_take isl_aff *aff,
1354 enum isl_dim_type type, int pos, int v)
1355{
1356 isl_int t;
1357
1358 isl_int_init(t);
1359 isl_int_set_si(t, v);
1360 aff = isl_aff_add_coefficient(aff, type, pos, v: t);
1361 isl_int_clear(t);
1362
1363 return aff;
1364}
1365
1366__isl_give isl_aff *isl_aff_get_div(__isl_keep isl_aff *aff, int pos)
1367{
1368 if (!aff)
1369 return NULL;
1370
1371 return isl_local_space_get_div(ls: aff->ls, pos);
1372}
1373
1374/* Return the negation of "aff".
1375 *
1376 * As a special case, -NaN = NaN.
1377 */
1378__isl_give isl_aff *isl_aff_neg(__isl_take isl_aff *aff)
1379{
1380 if (!aff)
1381 return NULL;
1382 if (isl_aff_is_nan(aff))
1383 return aff;
1384 aff = isl_aff_cow(aff);
1385 if (!aff)
1386 return NULL;
1387 aff->v = isl_vec_cow(vec: aff->v);
1388 if (!aff->v)
1389 return isl_aff_free(aff);
1390
1391 isl_seq_neg(dst: aff->v->el + 1, src: aff->v->el + 1, len: aff->v->size - 1);
1392
1393 return aff;
1394}
1395
1396/* Remove divs from the local space that do not appear in the affine
1397 * expression.
1398 * We currently only remove divs at the end.
1399 * Some intermediate divs may also not appear directly in the affine
1400 * expression, but we would also need to check that no other divs are
1401 * defined in terms of them.
1402 */
1403__isl_give isl_aff *isl_aff_remove_unused_divs(__isl_take isl_aff *aff)
1404{
1405 int pos;
1406 isl_size off;
1407 isl_size n;
1408
1409 n = isl_aff_domain_dim(aff, type: isl_dim_div);
1410 off = isl_aff_domain_offset(aff, type: isl_dim_div);
1411 if (n < 0 || off < 0)
1412 return isl_aff_free(aff);
1413
1414 pos = isl_seq_last_non_zero(p: aff->v->el + 1 + off, len: n) + 1;
1415 if (pos == n)
1416 return aff;
1417
1418 aff = isl_aff_cow(aff);
1419 if (!aff)
1420 return NULL;
1421
1422 aff->ls = isl_local_space_drop_dims(ls: aff->ls, type: isl_dim_div, first: pos, n: n - pos);
1423 aff->v = isl_vec_drop_els(vec: aff->v, pos: 1 + off + pos, n: n - pos);
1424 if (!aff->ls || !aff->v)
1425 return isl_aff_free(aff);
1426
1427 return aff;
1428}
1429
1430/* Look for any divs in the aff->ls with a denominator equal to one
1431 * and plug them into the affine expression and any subsequent divs
1432 * that may reference the div.
1433 */
1434static __isl_give isl_aff *plug_in_integral_divs(__isl_take isl_aff *aff)
1435{
1436 int i;
1437 isl_size n;
1438 int len;
1439 isl_int v;
1440 isl_vec *vec;
1441 isl_local_space *ls;
1442 isl_size off;
1443
1444 n = isl_aff_domain_dim(aff, type: isl_dim_div);
1445 off = isl_aff_domain_offset(aff, type: isl_dim_div);
1446 if (n < 0 || off < 0)
1447 return isl_aff_free(aff);
1448 len = aff->v->size;
1449 for (i = 0; i < n; ++i) {
1450 if (!isl_int_is_one(aff->ls->div->row[i][0]))
1451 continue;
1452 ls = isl_local_space_copy(ls: aff->ls);
1453 ls = isl_local_space_substitute_seq(ls, type: isl_dim_div, pos: i,
1454 subs: aff->ls->div->row[i], subs_len: len, first: i + 1, n: n - (i + 1));
1455 vec = isl_vec_copy(vec: aff->v);
1456 vec = isl_vec_cow(vec);
1457 if (!ls || !vec)
1458 goto error;
1459
1460 isl_int_init(v);
1461
1462 isl_seq_substitute(p: vec->el, pos: off + i, subs: aff->ls->div->row[i],
1463 p_len: len, subs_len: len, v);
1464
1465 isl_int_clear(v);
1466
1467 isl_vec_free(vec: aff->v);
1468 aff->v = vec;
1469 isl_local_space_free(ls: aff->ls);
1470 aff->ls = ls;
1471 }
1472
1473 return aff;
1474error:
1475 isl_vec_free(vec);
1476 isl_local_space_free(ls);
1477 return isl_aff_free(aff);
1478}
1479
1480/* Look for any divs j that appear with a unit coefficient inside
1481 * the definitions of other divs i and plug them into the definitions
1482 * of the divs i.
1483 *
1484 * In particular, an expression of the form
1485 *
1486 * floor((f(..) + floor(g(..)/n))/m)
1487 *
1488 * is simplified to
1489 *
1490 * floor((n * f(..) + g(..))/(n * m))
1491 *
1492 * This simplification is correct because we can move the expression
1493 * f(..) into the inner floor in the original expression to obtain
1494 *
1495 * floor(floor((n * f(..) + g(..))/n)/m)
1496 *
1497 * from which we can derive the simplified expression.
1498 */
1499static __isl_give isl_aff *plug_in_unit_divs(__isl_take isl_aff *aff)
1500{
1501 int i, j;
1502 isl_size n;
1503 isl_size off;
1504
1505 n = isl_aff_domain_dim(aff, type: isl_dim_div);
1506 off = isl_aff_domain_offset(aff, type: isl_dim_div);
1507 if (n < 0 || off < 0)
1508 return isl_aff_free(aff);
1509 for (i = 1; i < n; ++i) {
1510 for (j = 0; j < i; ++j) {
1511 if (!isl_int_is_one(aff->ls->div->row[i][1 + off + j]))
1512 continue;
1513 aff->ls = isl_local_space_substitute_seq(ls: aff->ls,
1514 type: isl_dim_div, pos: j, subs: aff->ls->div->row[j],
1515 subs_len: aff->v->size, first: i, n: 1);
1516 if (!aff->ls)
1517 return isl_aff_free(aff);
1518 }
1519 }
1520
1521 return aff;
1522}
1523
1524/* Swap divs "a" and "b" in "aff", which is assumed to be non-NULL.
1525 *
1526 * Even though this function is only called on isl_affs with a single
1527 * reference, we are careful to only change aff->v and aff->ls together.
1528 */
1529static __isl_give isl_aff *swap_div(__isl_take isl_aff *aff, int a, int b)
1530{
1531 isl_size off = isl_aff_domain_offset(aff, type: isl_dim_div);
1532 isl_local_space *ls;
1533 isl_vec *v;
1534
1535 if (off < 0)
1536 return isl_aff_free(aff);
1537
1538 ls = isl_local_space_copy(ls: aff->ls);
1539 ls = isl_local_space_swap_div(ls, a, b);
1540 v = isl_vec_copy(vec: aff->v);
1541 v = isl_vec_cow(vec: v);
1542 if (!ls || !v)
1543 goto error;
1544
1545 isl_int_swap(v->el[1 + off + a], v->el[1 + off + b]);
1546 isl_vec_free(vec: aff->v);
1547 aff->v = v;
1548 isl_local_space_free(ls: aff->ls);
1549 aff->ls = ls;
1550
1551 return aff;
1552error:
1553 isl_vec_free(vec: v);
1554 isl_local_space_free(ls);
1555 return isl_aff_free(aff);
1556}
1557
1558/* Merge divs "a" and "b" in "aff", which is assumed to be non-NULL.
1559 *
1560 * We currently do not actually remove div "b", but simply add its
1561 * coefficient to that of "a" and then zero it out.
1562 */
1563static __isl_give isl_aff *merge_divs(__isl_take isl_aff *aff, int a, int b)
1564{
1565 isl_size off = isl_aff_domain_offset(aff, type: isl_dim_div);
1566
1567 if (off < 0)
1568 return isl_aff_free(aff);
1569
1570 if (isl_int_is_zero(aff->v->el[1 + off + b]))
1571 return aff;
1572
1573 aff->v = isl_vec_cow(vec: aff->v);
1574 if (!aff->v)
1575 return isl_aff_free(aff);
1576
1577 isl_int_add(aff->v->el[1 + off + a],
1578 aff->v->el[1 + off + a], aff->v->el[1 + off + b]);
1579 isl_int_set_si(aff->v->el[1 + off + b], 0);
1580
1581 return aff;
1582}
1583
1584/* Sort the divs in the local space of "aff" according to
1585 * the comparison function "cmp_row" in isl_local_space.c,
1586 * combining the coefficients of identical divs.
1587 *
1588 * Reordering divs does not change the semantics of "aff",
1589 * so there is no need to call isl_aff_cow.
1590 * Moreover, this function is currently only called on isl_affs
1591 * with a single reference.
1592 */
1593static __isl_give isl_aff *sort_divs(__isl_take isl_aff *aff)
1594{
1595 isl_size n;
1596 int i, j;
1597
1598 n = isl_aff_dim(aff, type: isl_dim_div);
1599 if (n < 0)
1600 return isl_aff_free(aff);
1601 for (i = 1; i < n; ++i) {
1602 for (j = i - 1; j >= 0; --j) {
1603 int cmp = isl_mat_cmp_div(div: aff->ls->div, i: j, j: j + 1);
1604 if (cmp < 0)
1605 break;
1606 if (cmp == 0)
1607 aff = merge_divs(aff, a: j, b: j + 1);
1608 else
1609 aff = swap_div(aff, a: j, b: j + 1);
1610 if (!aff)
1611 return NULL;
1612 }
1613 }
1614
1615 return aff;
1616}
1617
1618/* Normalize the representation of "aff".
1619 *
1620 * This function should only be called on "new" isl_affs, i.e.,
1621 * with only a single reference. We therefore do not need to
1622 * worry about affecting other instances.
1623 */
1624__isl_give isl_aff *isl_aff_normalize(__isl_take isl_aff *aff)
1625{
1626 if (!aff)
1627 return NULL;
1628 aff->v = isl_vec_normalize(vec: aff->v);
1629 if (!aff->v)
1630 return isl_aff_free(aff);
1631 aff = plug_in_integral_divs(aff);
1632 aff = plug_in_unit_divs(aff);
1633 aff = sort_divs(aff);
1634 aff = isl_aff_remove_unused_divs(aff);
1635 return aff;
1636}
1637
1638/* Given f, return floor(f).
1639 * If f is an integer expression, then just return f.
1640 * If f is a constant, then return the constant floor(f).
1641 * Otherwise, if f = g/m, write g = q m + r,
1642 * create a new div d = [r/m] and return the expression q + d.
1643 * The coefficients in r are taken to lie between -m/2 and m/2.
1644 *
1645 * reduce_div_coefficients performs the same normalization.
1646 *
1647 * As a special case, floor(NaN) = NaN.
1648 */
1649__isl_give isl_aff *isl_aff_floor(__isl_take isl_aff *aff)
1650{
1651 int i;
1652 int size;
1653 isl_ctx *ctx;
1654 isl_vec *div;
1655
1656 if (!aff)
1657 return NULL;
1658
1659 if (isl_aff_is_nan(aff))
1660 return aff;
1661 if (isl_int_is_one(aff->v->el[0]))
1662 return aff;
1663
1664 aff = isl_aff_cow(aff);
1665 if (!aff)
1666 return NULL;
1667
1668 aff->v = isl_vec_cow(vec: aff->v);
1669 if (!aff->v)
1670 return isl_aff_free(aff);
1671
1672 if (isl_aff_is_cst(aff)) {
1673 isl_int_fdiv_q(aff->v->el[1], aff->v->el[1], aff->v->el[0]);
1674 isl_int_set_si(aff->v->el[0], 1);
1675 return aff;
1676 }
1677
1678 div = isl_vec_copy(vec: aff->v);
1679 div = isl_vec_cow(vec: div);
1680 if (!div)
1681 return isl_aff_free(aff);
1682
1683 ctx = isl_aff_get_ctx(aff);
1684 isl_int_fdiv_q(aff->v->el[0], aff->v->el[0], ctx->two);
1685 for (i = 1; i < aff->v->size; ++i) {
1686 isl_int_fdiv_r(div->el[i], div->el[i], div->el[0]);
1687 isl_int_fdiv_q(aff->v->el[i], aff->v->el[i], div->el[0]);
1688 if (isl_int_gt(div->el[i], aff->v->el[0])) {
1689 isl_int_sub(div->el[i], div->el[i], div->el[0]);
1690 isl_int_add_ui(aff->v->el[i], aff->v->el[i], 1);
1691 }
1692 }
1693
1694 aff->ls = isl_local_space_add_div(ls: aff->ls, div);
1695 if (!aff->ls)
1696 return isl_aff_free(aff);
1697
1698 size = aff->v->size;
1699 aff->v = isl_vec_extend(vec: aff->v, size: size + 1);
1700 if (!aff->v)
1701 return isl_aff_free(aff);
1702 isl_int_set_si(aff->v->el[0], 1);
1703 isl_int_set_si(aff->v->el[size], 1);
1704
1705 aff = isl_aff_normalize(aff);
1706
1707 return aff;
1708}
1709
1710/* Compute
1711 *
1712 * aff mod m = aff - m * floor(aff/m)
1713 *
1714 * with m an integer value.
1715 */
1716__isl_give isl_aff *isl_aff_mod_val(__isl_take isl_aff *aff,
1717 __isl_take isl_val *m)
1718{
1719 isl_aff *res;
1720
1721 if (!aff || !m)
1722 goto error;
1723
1724 if (!isl_val_is_int(v: m))
1725 isl_die(isl_val_get_ctx(m), isl_error_invalid,
1726 "expecting integer modulo", goto error);
1727
1728 res = isl_aff_copy(aff);
1729 aff = isl_aff_scale_down_val(aff, v: isl_val_copy(v: m));
1730 aff = isl_aff_floor(aff);
1731 aff = isl_aff_scale_val(aff, v: m);
1732 res = isl_aff_sub(aff1: res, aff2: aff);
1733
1734 return res;
1735error:
1736 isl_aff_free(aff);
1737 isl_val_free(v: m);
1738 return NULL;
1739}
1740
1741/* Compute
1742 *
1743 * pwaff mod m = pwaff - m * floor(pwaff/m)
1744 */
1745__isl_give isl_pw_aff *isl_pw_aff_mod(__isl_take isl_pw_aff *pwaff, isl_int m)
1746{
1747 isl_pw_aff *res;
1748
1749 res = isl_pw_aff_copy(pwaff);
1750 pwaff = isl_pw_aff_scale_down(pwaff, f: m);
1751 pwaff = isl_pw_aff_floor(pwaff);
1752 pwaff = isl_pw_aff_scale(pwaff, f: m);
1753 res = isl_pw_aff_sub(pwaff1: res, pwaff2: pwaff);
1754
1755 return res;
1756}
1757
1758/* Compute
1759 *
1760 * pa mod m = pa - m * floor(pa/m)
1761 *
1762 * with m an integer value.
1763 */
1764__isl_give isl_pw_aff *isl_pw_aff_mod_val(__isl_take isl_pw_aff *pa,
1765 __isl_take isl_val *m)
1766{
1767 if (!pa || !m)
1768 goto error;
1769 if (!isl_val_is_int(v: m))
1770 isl_die(isl_pw_aff_get_ctx(pa), isl_error_invalid,
1771 "expecting integer modulo", goto error);
1772 pa = isl_pw_aff_mod(pwaff: pa, m: m->n);
1773 isl_val_free(v: m);
1774 return pa;
1775error:
1776 isl_pw_aff_free(pwaff: pa);
1777 isl_val_free(v: m);
1778 return NULL;
1779}
1780
1781/* Given f, return ceil(f).
1782 * If f is an integer expression, then just return f.
1783 * Otherwise, let f be the expression
1784 *
1785 * e/m
1786 *
1787 * then return
1788 *
1789 * floor((e + m - 1)/m)
1790 *
1791 * As a special case, ceil(NaN) = NaN.
1792 */
1793__isl_give isl_aff *isl_aff_ceil(__isl_take isl_aff *aff)
1794{
1795 if (!aff)
1796 return NULL;
1797
1798 if (isl_aff_is_nan(aff))
1799 return aff;
1800 if (isl_int_is_one(aff->v->el[0]))
1801 return aff;
1802
1803 aff = isl_aff_cow(aff);
1804 if (!aff)
1805 return NULL;
1806 aff->v = isl_vec_cow(vec: aff->v);
1807 if (!aff->v)
1808 return isl_aff_free(aff);
1809
1810 isl_int_add(aff->v->el[1], aff->v->el[1], aff->v->el[0]);
1811 isl_int_sub_ui(aff->v->el[1], aff->v->el[1], 1);
1812 aff = isl_aff_floor(aff);
1813
1814 return aff;
1815}
1816
1817/* Apply the expansion computed by isl_merge_divs.
1818 * The expansion itself is given by "exp" while the resulting
1819 * list of divs is given by "div".
1820 */
1821__isl_give isl_aff *isl_aff_expand_divs(__isl_take isl_aff *aff,
1822 __isl_take isl_mat *div, int *exp)
1823{
1824 isl_size old_n_div;
1825 isl_size new_n_div;
1826 isl_size offset;
1827
1828 aff = isl_aff_cow(aff);
1829
1830 offset = isl_aff_domain_offset(aff, type: isl_dim_div);
1831 old_n_div = isl_aff_domain_dim(aff, type: isl_dim_div);
1832 new_n_div = isl_mat_rows(mat: div);
1833 if (offset < 0 || old_n_div < 0 || new_n_div < 0)
1834 goto error;
1835
1836 aff->v = isl_vec_expand(vec: aff->v, pos: 1 + offset, n: old_n_div, exp, expanded: new_n_div);
1837 aff->ls = isl_local_space_replace_divs(ls: aff->ls, div);
1838 if (!aff->v || !aff->ls)
1839 return isl_aff_free(aff);
1840 return aff;
1841error:
1842 isl_aff_free(aff);
1843 isl_mat_free(mat: div);
1844 return NULL;
1845}
1846
1847/* Add two affine expressions that live in the same local space.
1848 */
1849static __isl_give isl_aff *add_expanded(__isl_take isl_aff *aff1,
1850 __isl_take isl_aff *aff2)
1851{
1852 isl_int gcd, f;
1853
1854 aff1 = isl_aff_cow(aff: aff1);
1855 if (!aff1 || !aff2)
1856 goto error;
1857
1858 aff1->v = isl_vec_cow(vec: aff1->v);
1859 if (!aff1->v)
1860 goto error;
1861
1862 isl_int_init(gcd);
1863 isl_int_init(f);
1864 isl_int_gcd(gcd, aff1->v->el[0], aff2->v->el[0]);
1865 isl_int_divexact(f, aff2->v->el[0], gcd);
1866 isl_seq_scale(dst: aff1->v->el + 1, src: aff1->v->el + 1, f, len: aff1->v->size - 1);
1867 isl_int_divexact(f, aff1->v->el[0], gcd);
1868 isl_seq_addmul(dst: aff1->v->el + 1, f, src: aff2->v->el + 1, len: aff1->v->size - 1);
1869 isl_int_divexact(f, aff2->v->el[0], gcd);
1870 isl_int_mul(aff1->v->el[0], aff1->v->el[0], f);
1871 isl_int_clear(f);
1872 isl_int_clear(gcd);
1873
1874 isl_aff_free(aff: aff2);
1875 aff1 = isl_aff_normalize(aff: aff1);
1876 return aff1;
1877error:
1878 isl_aff_free(aff: aff1);
1879 isl_aff_free(aff: aff2);
1880 return NULL;
1881}
1882
1883/* Replace one of the arguments by a NaN and free the other one.
1884 */
1885static __isl_give isl_aff *set_nan_free(__isl_take isl_aff *aff1,
1886 __isl_take isl_aff *aff2)
1887{
1888 isl_aff_free(aff: aff2);
1889 return isl_aff_set_nan(aff: aff1);
1890}
1891
1892/* Return the sum of "aff1" and "aff2".
1893 *
1894 * If either of the two is NaN, then the result is NaN.
1895 */
1896__isl_give isl_aff *isl_aff_add(__isl_take isl_aff *aff1,
1897 __isl_take isl_aff *aff2)
1898{
1899 isl_ctx *ctx;
1900 int *exp1 = NULL;
1901 int *exp2 = NULL;
1902 isl_mat *div;
1903 isl_size n_div1, n_div2;
1904
1905 if (!aff1 || !aff2)
1906 goto error;
1907
1908 ctx = isl_aff_get_ctx(aff: aff1);
1909 if (!isl_space_is_equal(space1: aff1->ls->dim, space2: aff2->ls->dim))
1910 isl_die(ctx, isl_error_invalid,
1911 "spaces don't match", goto error);
1912
1913 if (isl_aff_is_nan(aff: aff1)) {
1914 isl_aff_free(aff: aff2);
1915 return aff1;
1916 }
1917 if (isl_aff_is_nan(aff: aff2)) {
1918 isl_aff_free(aff: aff1);
1919 return aff2;
1920 }
1921
1922 n_div1 = isl_aff_dim(aff: aff1, type: isl_dim_div);
1923 n_div2 = isl_aff_dim(aff: aff2, type: isl_dim_div);
1924 if (n_div1 < 0 || n_div2 < 0)
1925 goto error;
1926 if (n_div1 == 0 && n_div2 == 0)
1927 return add_expanded(aff1, aff2);
1928
1929 exp1 = isl_alloc_array(ctx, int, n_div1);
1930 exp2 = isl_alloc_array(ctx, int, n_div2);
1931 if ((n_div1 && !exp1) || (n_div2 && !exp2))
1932 goto error;
1933
1934 div = isl_merge_divs(div1: aff1->ls->div, div2: aff2->ls->div, exp1, exp2);
1935 aff1 = isl_aff_expand_divs(aff: aff1, div: isl_mat_copy(mat: div), exp: exp1);
1936 aff2 = isl_aff_expand_divs(aff: aff2, div, exp: exp2);
1937 free(ptr: exp1);
1938 free(ptr: exp2);
1939
1940 return add_expanded(aff1, aff2);
1941error:
1942 free(ptr: exp1);
1943 free(ptr: exp2);
1944 isl_aff_free(aff: aff1);
1945 isl_aff_free(aff: aff2);
1946 return NULL;
1947}
1948
1949__isl_give isl_aff *isl_aff_sub(__isl_take isl_aff *aff1,
1950 __isl_take isl_aff *aff2)
1951{
1952 return isl_aff_add(aff1, aff2: isl_aff_neg(aff: aff2));
1953}
1954
1955/* Return the result of scaling "aff" by a factor of "f".
1956 *
1957 * As a special case, f * NaN = NaN.
1958 */
1959__isl_give isl_aff *isl_aff_scale(__isl_take isl_aff *aff, isl_int f)
1960{
1961 isl_int gcd;
1962
1963 if (!aff)
1964 return NULL;
1965 if (isl_aff_is_nan(aff))
1966 return aff;
1967
1968 if (isl_int_is_one(f))
1969 return aff;
1970
1971 aff = isl_aff_cow(aff);
1972 if (!aff)
1973 return NULL;
1974 aff->v = isl_vec_cow(vec: aff->v);
1975 if (!aff->v)
1976 return isl_aff_free(aff);
1977
1978 if (isl_int_is_pos(f) && isl_int_is_divisible_by(aff->v->el[0], f)) {
1979 isl_int_divexact(aff->v->el[0], aff->v->el[0], f);
1980 return aff;
1981 }
1982
1983 isl_int_init(gcd);
1984 isl_int_gcd(gcd, aff->v->el[0], f);
1985 isl_int_divexact(aff->v->el[0], aff->v->el[0], gcd);
1986 isl_int_divexact(gcd, f, gcd);
1987 isl_seq_scale(dst: aff->v->el + 1, src: aff->v->el + 1, f: gcd, len: aff->v->size - 1);
1988 isl_int_clear(gcd);
1989
1990 return aff;
1991}
1992
1993/* Multiple "aff" by "v".
1994 */
1995__isl_give isl_aff *isl_aff_scale_val(__isl_take isl_aff *aff,
1996 __isl_take isl_val *v)
1997{
1998 if (!aff || !v)
1999 goto error;
2000
2001 if (isl_val_is_one(v)) {
2002 isl_val_free(v);
2003 return aff;
2004 }
2005
2006 if (!isl_val_is_rat(v))
2007 isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
2008 "expecting rational factor", goto error);
2009
2010 aff = isl_aff_scale(aff, f: v->n);
2011 aff = isl_aff_scale_down(aff, f: v->d);
2012
2013 isl_val_free(v);
2014 return aff;
2015error:
2016 isl_aff_free(aff);
2017 isl_val_free(v);
2018 return NULL;
2019}
2020
2021/* Return the result of scaling "aff" down by a factor of "f".
2022 *
2023 * As a special case, NaN/f = NaN.
2024 */
2025__isl_give isl_aff *isl_aff_scale_down(__isl_take isl_aff *aff, isl_int f)
2026{
2027 isl_int gcd;
2028
2029 if (!aff)
2030 return NULL;
2031 if (isl_aff_is_nan(aff))
2032 return aff;
2033
2034 if (isl_int_is_one(f))
2035 return aff;
2036
2037 aff = isl_aff_cow(aff);
2038 if (!aff)
2039 return NULL;
2040
2041 if (isl_int_is_zero(f))
2042 isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
2043 "cannot scale down by zero", return isl_aff_free(aff));
2044
2045 aff->v = isl_vec_cow(vec: aff->v);
2046 if (!aff->v)
2047 return isl_aff_free(aff);
2048
2049 isl_int_init(gcd);
2050 isl_seq_gcd(p: aff->v->el + 1, len: aff->v->size - 1, gcd: &gcd);
2051 isl_int_gcd(gcd, gcd, f);
2052 isl_seq_scale_down(dst: aff->v->el + 1, src: aff->v->el + 1, f: gcd, len: aff->v->size - 1);
2053 isl_int_divexact(gcd, f, gcd);
2054 isl_int_mul(aff->v->el[0], aff->v->el[0], gcd);
2055 isl_int_clear(gcd);
2056
2057 return aff;
2058}
2059
2060/* Divide "aff" by "v".
2061 */
2062__isl_give isl_aff *isl_aff_scale_down_val(__isl_take isl_aff *aff,
2063 __isl_take isl_val *v)
2064{
2065 if (!aff || !v)
2066 goto error;
2067
2068 if (isl_val_is_one(v)) {
2069 isl_val_free(v);
2070 return aff;
2071 }
2072
2073 if (!isl_val_is_rat(v))
2074 isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
2075 "expecting rational factor", goto error);
2076 if (!isl_val_is_pos(v))
2077 isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
2078 "factor needs to be positive", goto error);
2079
2080 aff = isl_aff_scale(aff, f: v->d);
2081 aff = isl_aff_scale_down(aff, f: v->n);
2082
2083 isl_val_free(v);
2084 return aff;
2085error:
2086 isl_aff_free(aff);
2087 isl_val_free(v);
2088 return NULL;
2089}
2090
2091__isl_give isl_aff *isl_aff_scale_down_ui(__isl_take isl_aff *aff, unsigned f)
2092{
2093 isl_int v;
2094
2095 if (f == 1)
2096 return aff;
2097
2098 isl_int_init(v);
2099 isl_int_set_ui(v, f);
2100 aff = isl_aff_scale_down(aff, f: v);
2101 isl_int_clear(v);
2102
2103 return aff;
2104}
2105
2106__isl_give isl_aff *isl_aff_set_dim_name(__isl_take isl_aff *aff,
2107 enum isl_dim_type type, unsigned pos, const char *s)
2108{
2109 aff = isl_aff_cow(aff);
2110 if (!aff)
2111 return NULL;
2112 if (type == isl_dim_out)
2113 isl_die(aff->v->ctx, isl_error_invalid,
2114 "cannot set name of output/set dimension",
2115 return isl_aff_free(aff));
2116 if (type == isl_dim_in)
2117 type = isl_dim_set;
2118 aff->ls = isl_local_space_set_dim_name(ls: aff->ls, type, pos, s);
2119 if (!aff->ls)
2120 return isl_aff_free(aff);
2121
2122 return aff;
2123}
2124
2125__isl_give isl_aff *isl_aff_set_dim_id(__isl_take isl_aff *aff,
2126 enum isl_dim_type type, unsigned pos, __isl_take isl_id *id)
2127{
2128 aff = isl_aff_cow(aff);
2129 if (!aff)
2130 goto error;
2131 if (type == isl_dim_out)
2132 isl_die(aff->v->ctx, isl_error_invalid,
2133 "cannot set name of output/set dimension",
2134 goto error);
2135 if (type == isl_dim_in)
2136 type = isl_dim_set;
2137 aff->ls = isl_local_space_set_dim_id(ls: aff->ls, type, pos, id);
2138 if (!aff->ls)
2139 return isl_aff_free(aff);
2140
2141 return aff;
2142error:
2143 isl_id_free(id);
2144 isl_aff_free(aff);
2145 return NULL;
2146}
2147
2148/* Replace the identifier of the input tuple of "aff" by "id".
2149 * type is currently required to be equal to isl_dim_in
2150 */
2151__isl_give isl_aff *isl_aff_set_tuple_id(__isl_take isl_aff *aff,
2152 enum isl_dim_type type, __isl_take isl_id *id)
2153{
2154 aff = isl_aff_cow(aff);
2155 if (!aff)
2156 goto error;
2157 if (type != isl_dim_in)
2158 isl_die(aff->v->ctx, isl_error_invalid,
2159 "cannot only set id of input tuple", goto error);
2160 aff->ls = isl_local_space_set_tuple_id(ls: aff->ls, type: isl_dim_set, id);
2161 if (!aff->ls)
2162 return isl_aff_free(aff);
2163
2164 return aff;
2165error:
2166 isl_id_free(id);
2167 isl_aff_free(aff);
2168 return NULL;
2169}
2170
2171/* Exploit the equalities in "eq" to simplify the affine expression
2172 * and the expressions of the integer divisions in the local space.
2173 * The integer divisions in this local space are assumed to appear
2174 * as regular dimensions in "eq".
2175 */
2176static __isl_give isl_aff *isl_aff_substitute_equalities_lifted(
2177 __isl_take isl_aff *aff, __isl_take isl_basic_set *eq)
2178{
2179 int i, j;
2180 unsigned o_div;
2181 unsigned n_div;
2182
2183 if (!eq)
2184 goto error;
2185 if (eq->n_eq == 0) {
2186 isl_basic_set_free(bset: eq);
2187 return aff;
2188 }
2189
2190 aff = isl_aff_cow(aff);
2191 if (!aff)
2192 goto error;
2193
2194 aff->ls = isl_local_space_substitute_equalities(ls: aff->ls,
2195 eq: isl_basic_set_copy(bset: eq));
2196 aff->v = isl_vec_cow(vec: aff->v);
2197 if (!aff->ls || !aff->v)
2198 goto error;
2199
2200 o_div = isl_basic_set_offset(bset: eq, type: isl_dim_div);
2201 n_div = eq->n_div;
2202 for (i = 0; i < eq->n_eq; ++i) {
2203 j = isl_seq_last_non_zero(p: eq->eq[i], len: o_div + n_div);
2204 if (j < 0 || j == 0 || j >= o_div)
2205 continue;
2206
2207 isl_seq_elim(dst: aff->v->el + 1, src: eq->eq[i], pos: j, len: o_div,
2208 m: &aff->v->el[0]);
2209 }
2210
2211 isl_basic_set_free(bset: eq);
2212 aff = isl_aff_normalize(aff);
2213 return aff;
2214error:
2215 isl_basic_set_free(bset: eq);
2216 isl_aff_free(aff);
2217 return NULL;
2218}
2219
2220/* Exploit the equalities in "eq" to simplify the affine expression
2221 * and the expressions of the integer divisions in the local space.
2222 */
2223__isl_give isl_aff *isl_aff_substitute_equalities(__isl_take isl_aff *aff,
2224 __isl_take isl_basic_set *eq)
2225{
2226 isl_size n_div;
2227
2228 n_div = isl_aff_domain_dim(aff, type: isl_dim_div);
2229 if (n_div < 0)
2230 goto error;
2231 if (n_div > 0)
2232 eq = isl_basic_set_add_dims(bset: eq, type: isl_dim_set, n: n_div);
2233 return isl_aff_substitute_equalities_lifted(aff, eq);
2234error:
2235 isl_basic_set_free(bset: eq);
2236 isl_aff_free(aff);
2237 return NULL;
2238}
2239
2240/* Look for equalities among the variables shared by context and aff
2241 * and the integer divisions of aff, if any.
2242 * The equalities are then used to eliminate coefficients and/or integer
2243 * divisions from aff.
2244 */
2245__isl_give isl_aff *isl_aff_gist(__isl_take isl_aff *aff,
2246 __isl_take isl_set *context)
2247{
2248 isl_local_space *ls;
2249 isl_basic_set *hull;
2250
2251 ls = isl_aff_get_domain_local_space(aff);
2252 context = isl_local_space_lift_set(ls, set: context);
2253
2254 hull = isl_set_affine_hull(set: context);
2255 return isl_aff_substitute_equalities_lifted(aff, eq: hull);
2256}
2257
2258__isl_give isl_aff *isl_aff_gist_params(__isl_take isl_aff *aff,
2259 __isl_take isl_set *context)
2260{
2261 isl_set *dom_context = isl_set_universe(space: isl_aff_get_domain_space(aff));
2262 dom_context = isl_set_intersect_params(set: dom_context, params: context);
2263 return isl_aff_gist(aff, context: dom_context);
2264}
2265
2266/* Return a basic set containing those elements in the space
2267 * of aff where it is positive. "rational" should not be set.
2268 *
2269 * If "aff" is NaN, then it is not positive.
2270 */
2271static __isl_give isl_basic_set *aff_pos_basic_set(__isl_take isl_aff *aff,
2272 int rational, void *user)
2273{
2274 isl_constraint *ineq;
2275 isl_basic_set *bset;
2276 isl_val *c;
2277
2278 if (!aff)
2279 return NULL;
2280 if (isl_aff_is_nan(aff)) {
2281 isl_space *space = isl_aff_get_domain_space(aff);
2282 isl_aff_free(aff);
2283 return isl_basic_set_empty(space);
2284 }
2285 if (rational)
2286 isl_die(isl_aff_get_ctx(aff), isl_error_unsupported,
2287 "rational sets not supported", goto error);
2288
2289 ineq = isl_inequality_from_aff(aff);
2290 c = isl_constraint_get_constant_val(constraint: ineq);
2291 c = isl_val_sub_ui(v1: c, v2: 1);
2292 ineq = isl_constraint_set_constant_val(constraint: ineq, v: c);
2293
2294 bset = isl_basic_set_from_constraint(constraint: ineq);
2295 bset = isl_basic_set_simplify(bset);
2296 return bset;
2297error:
2298 isl_aff_free(aff);
2299 return NULL;
2300}
2301
2302/* Return a basic set containing those elements in the space
2303 * of aff where it is non-negative.
2304 * If "rational" is set, then return a rational basic set.
2305 *
2306 * If "aff" is NaN, then it is not non-negative (it's not negative either).
2307 */
2308static __isl_give isl_basic_set *aff_nonneg_basic_set(
2309 __isl_take isl_aff *aff, int rational, void *user)
2310{
2311 isl_constraint *ineq;
2312 isl_basic_set *bset;
2313
2314 if (!aff)
2315 return NULL;
2316 if (isl_aff_is_nan(aff)) {
2317 isl_space *space = isl_aff_get_domain_space(aff);
2318 isl_aff_free(aff);
2319 return isl_basic_set_empty(space);
2320 }
2321
2322 ineq = isl_inequality_from_aff(aff);
2323
2324 bset = isl_basic_set_from_constraint(constraint: ineq);
2325 if (rational)
2326 bset = isl_basic_set_set_rational(bset);
2327 bset = isl_basic_set_simplify(bset);
2328 return bset;
2329}
2330
2331/* Return a basic set containing those elements in the space
2332 * of aff where it is non-negative.
2333 */
2334__isl_give isl_basic_set *isl_aff_nonneg_basic_set(__isl_take isl_aff *aff)
2335{
2336 return aff_nonneg_basic_set(aff, rational: 0, NULL);
2337}
2338
2339/* Return a basic set containing those elements in the domain space
2340 * of "aff" where it is positive.
2341 */
2342__isl_give isl_basic_set *isl_aff_pos_basic_set(__isl_take isl_aff *aff)
2343{
2344 aff = isl_aff_add_constant_num_si(aff, v: -1);
2345 return isl_aff_nonneg_basic_set(aff);
2346}
2347
2348/* Return a basic set containing those elements in the domain space
2349 * of aff where it is negative.
2350 */
2351__isl_give isl_basic_set *isl_aff_neg_basic_set(__isl_take isl_aff *aff)
2352{
2353 aff = isl_aff_neg(aff);
2354 return isl_aff_pos_basic_set(aff);
2355}
2356
2357/* Return a basic set containing those elements in the space
2358 * of aff where it is zero.
2359 * If "rational" is set, then return a rational basic set.
2360 *
2361 * If "aff" is NaN, then it is not zero.
2362 */
2363static __isl_give isl_basic_set *aff_zero_basic_set(__isl_take isl_aff *aff,
2364 int rational, void *user)
2365{
2366 isl_constraint *ineq;
2367 isl_basic_set *bset;
2368
2369 if (!aff)
2370 return NULL;
2371 if (isl_aff_is_nan(aff)) {
2372 isl_space *space = isl_aff_get_domain_space(aff);
2373 isl_aff_free(aff);
2374 return isl_basic_set_empty(space);
2375 }
2376
2377 ineq = isl_equality_from_aff(aff);
2378
2379 bset = isl_basic_set_from_constraint(constraint: ineq);
2380 if (rational)
2381 bset = isl_basic_set_set_rational(bset);
2382 bset = isl_basic_set_simplify(bset);
2383 return bset;
2384}
2385
2386/* Return a basic set containing those elements in the space
2387 * of aff where it is zero.
2388 */
2389__isl_give isl_basic_set *isl_aff_zero_basic_set(__isl_take isl_aff *aff)
2390{
2391 return aff_zero_basic_set(aff, rational: 0, NULL);
2392}
2393
2394/* Return a basic set containing those elements in the shared space
2395 * of aff1 and aff2 where aff1 is greater than or equal to aff2.
2396 */
2397__isl_give isl_basic_set *isl_aff_ge_basic_set(__isl_take isl_aff *aff1,
2398 __isl_take isl_aff *aff2)
2399{
2400 aff1 = isl_aff_sub(aff1, aff2);
2401
2402 return isl_aff_nonneg_basic_set(aff: aff1);
2403}
2404
2405/* Return a basic set containing those elements in the shared domain space
2406 * of "aff1" and "aff2" where "aff1" is greater than "aff2".
2407 */
2408__isl_give isl_basic_set *isl_aff_gt_basic_set(__isl_take isl_aff *aff1,
2409 __isl_take isl_aff *aff2)
2410{
2411 aff1 = isl_aff_sub(aff1, aff2);
2412
2413 return isl_aff_pos_basic_set(aff: aff1);
2414}
2415
2416/* Return a set containing those elements in the shared space
2417 * of aff1 and aff2 where aff1 is greater than or equal to aff2.
2418 */
2419__isl_give isl_set *isl_aff_ge_set(__isl_take isl_aff *aff1,
2420 __isl_take isl_aff *aff2)
2421{
2422 return isl_set_from_basic_set(bset: isl_aff_ge_basic_set(aff1, aff2));
2423}
2424
2425/* Return a set containing those elements in the shared domain space
2426 * of aff1 and aff2 where aff1 is greater than aff2.
2427 *
2428 * If either of the two inputs is NaN, then the result is empty,
2429 * as comparisons with NaN always return false.
2430 */
2431__isl_give isl_set *isl_aff_gt_set(__isl_take isl_aff *aff1,
2432 __isl_take isl_aff *aff2)
2433{
2434 return isl_set_from_basic_set(bset: isl_aff_gt_basic_set(aff1, aff2));
2435}
2436
2437/* Return a basic set containing those elements in the shared space
2438 * of aff1 and aff2 where aff1 is smaller than or equal to aff2.
2439 */
2440__isl_give isl_basic_set *isl_aff_le_basic_set(__isl_take isl_aff *aff1,
2441 __isl_take isl_aff *aff2)
2442{
2443 return isl_aff_ge_basic_set(aff1: aff2, aff2: aff1);
2444}
2445
2446/* Return a basic set containing those elements in the shared domain space
2447 * of "aff1" and "aff2" where "aff1" is smaller than "aff2".
2448 */
2449__isl_give isl_basic_set *isl_aff_lt_basic_set(__isl_take isl_aff *aff1,
2450 __isl_take isl_aff *aff2)
2451{
2452 return isl_aff_gt_basic_set(aff1: aff2, aff2: aff1);
2453}
2454
2455/* Return a set containing those elements in the shared space
2456 * of aff1 and aff2 where aff1 is smaller than or equal to aff2.
2457 */
2458__isl_give isl_set *isl_aff_le_set(__isl_take isl_aff *aff1,
2459 __isl_take isl_aff *aff2)
2460{
2461 return isl_aff_ge_set(aff1: aff2, aff2: aff1);
2462}
2463
2464/* Return a set containing those elements in the shared domain space
2465 * of "aff1" and "aff2" where "aff1" is smaller than "aff2".
2466 */
2467__isl_give isl_set *isl_aff_lt_set(__isl_take isl_aff *aff1,
2468 __isl_take isl_aff *aff2)
2469{
2470 return isl_set_from_basic_set(bset: isl_aff_lt_basic_set(aff1, aff2));
2471}
2472
2473/* Return a basic set containing those elements in the shared space
2474 * of aff1 and aff2 where aff1 and aff2 are equal.
2475 */
2476__isl_give isl_basic_set *isl_aff_eq_basic_set(__isl_take isl_aff *aff1,
2477 __isl_take isl_aff *aff2)
2478{
2479 aff1 = isl_aff_sub(aff1, aff2);
2480
2481 return isl_aff_zero_basic_set(aff: aff1);
2482}
2483
2484/* Return a set containing those elements in the shared space
2485 * of aff1 and aff2 where aff1 and aff2 are equal.
2486 */
2487__isl_give isl_set *isl_aff_eq_set(__isl_take isl_aff *aff1,
2488 __isl_take isl_aff *aff2)
2489{
2490 return isl_set_from_basic_set(bset: isl_aff_eq_basic_set(aff1, aff2));
2491}
2492
2493/* Return a set containing those elements in the shared domain space
2494 * of aff1 and aff2 where aff1 and aff2 are not equal.
2495 *
2496 * If either of the two inputs is NaN, then the result is empty,
2497 * as comparisons with NaN always return false.
2498 */
2499__isl_give isl_set *isl_aff_ne_set(__isl_take isl_aff *aff1,
2500 __isl_take isl_aff *aff2)
2501{
2502 isl_set *set_lt, *set_gt;
2503
2504 set_lt = isl_aff_lt_set(aff1: isl_aff_copy(aff: aff1),
2505 aff2: isl_aff_copy(aff: aff2));
2506 set_gt = isl_aff_gt_set(aff1, aff2);
2507 return isl_set_union_disjoint(set1: set_lt, set2: set_gt);
2508}
2509
2510__isl_give isl_aff *isl_aff_add_on_domain(__isl_keep isl_set *dom,
2511 __isl_take isl_aff *aff1, __isl_take isl_aff *aff2)
2512{
2513 aff1 = isl_aff_add(aff1, aff2);
2514 aff1 = isl_aff_gist(aff: aff1, context: isl_set_copy(set: dom));
2515 return aff1;
2516}
2517
2518isl_bool isl_aff_is_empty(__isl_keep isl_aff *aff)
2519{
2520 if (!aff)
2521 return isl_bool_error;
2522
2523 return isl_bool_false;
2524}
2525
2526#undef TYPE
2527#define TYPE isl_aff
2528static
2529#include "check_type_range_templ.c"
2530
2531/* Check whether the given affine expression has non-zero coefficient
2532 * for any dimension in the given range or if any of these dimensions
2533 * appear with non-zero coefficients in any of the integer divisions
2534 * involved in the affine expression.
2535 */
2536isl_bool isl_aff_involves_dims(__isl_keep isl_aff *aff,
2537 enum isl_dim_type type, unsigned first, unsigned n)
2538{
2539 int i;
2540 int *active = NULL;
2541 isl_bool involves = isl_bool_false;
2542
2543 if (!aff)
2544 return isl_bool_error;
2545 if (n == 0)
2546 return isl_bool_false;
2547 if (isl_aff_check_range(obj: aff, type, first, n) < 0)
2548 return isl_bool_error;
2549
2550 active = isl_local_space_get_active(ls: aff->ls, l: aff->v->el + 2);
2551 if (!active)
2552 goto error;
2553
2554 first += isl_local_space_offset(ls: aff->ls, type) - 1;
2555 for (i = 0; i < n; ++i)
2556 if (active[first + i]) {
2557 involves = isl_bool_true;
2558 break;
2559 }
2560
2561 free(ptr: active);
2562
2563 return involves;
2564error:
2565 free(ptr: active);
2566 return isl_bool_error;
2567}
2568
2569/* Does "aff" involve any local variables, i.e., integer divisions?
2570 */
2571isl_bool isl_aff_involves_locals(__isl_keep isl_aff *aff)
2572{
2573 isl_size n;
2574
2575 n = isl_aff_dim(aff, type: isl_dim_div);
2576 if (n < 0)
2577 return isl_bool_error;
2578 return isl_bool_ok(b: n > 0);
2579}
2580
2581__isl_give isl_aff *isl_aff_drop_dims(__isl_take isl_aff *aff,
2582 enum isl_dim_type type, unsigned first, unsigned n)
2583{
2584 if (!aff)
2585 return NULL;
2586 if (type == isl_dim_out)
2587 isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
2588 "cannot drop output/set dimension",
2589 return isl_aff_free(aff));
2590 if (type == isl_dim_in)
2591 type = isl_dim_set;
2592 if (n == 0 && !isl_local_space_is_named_or_nested(ls: aff->ls, type))
2593 return aff;
2594
2595 if (isl_local_space_check_range(ls: aff->ls, type, first, n) < 0)
2596 return isl_aff_free(aff);
2597
2598 aff = isl_aff_cow(aff);
2599 if (!aff)
2600 return NULL;
2601
2602 aff->ls = isl_local_space_drop_dims(ls: aff->ls, type, first, n);
2603 if (!aff->ls)
2604 return isl_aff_free(aff);
2605
2606 first += 1 + isl_local_space_offset(ls: aff->ls, type);
2607 aff->v = isl_vec_drop_els(vec: aff->v, pos: first, n);
2608 if (!aff->v)
2609 return isl_aff_free(aff);
2610
2611 return aff;
2612}
2613
2614/* Is the domain of "aff" a product?
2615 */
2616static isl_bool isl_aff_domain_is_product(__isl_keep isl_aff *aff)
2617{
2618 return isl_space_is_product(space: isl_aff_peek_domain_space(aff));
2619}
2620
2621#undef TYPE
2622#define TYPE isl_aff
2623#include <isl_domain_factor_templ.c>
2624
2625/* Project the domain of the affine expression onto its parameter space.
2626 * The affine expression may not involve any of the domain dimensions.
2627 */
2628__isl_give isl_aff *isl_aff_project_domain_on_params(__isl_take isl_aff *aff)
2629{
2630 isl_space *space;
2631 isl_size n;
2632
2633 n = isl_aff_dim(aff, type: isl_dim_in);
2634 if (n < 0)
2635 return isl_aff_free(aff);
2636 aff = isl_aff_drop_domain(obj: aff, first: 0, n);
2637 space = isl_aff_get_domain_space(aff);
2638 space = isl_space_params(space);
2639 aff = isl_aff_reset_domain_space(aff, space);
2640 return aff;
2641}
2642
2643/* Convert an affine expression defined over a parameter domain
2644 * into one that is defined over a zero-dimensional set.
2645 */
2646__isl_give isl_aff *isl_aff_from_range(__isl_take isl_aff *aff)
2647{
2648 isl_local_space *ls;
2649
2650 ls = isl_aff_take_domain_local_space(aff);
2651 ls = isl_local_space_set_from_params(ls);
2652 aff = isl_aff_restore_domain_local_space(aff, ls);
2653
2654 return aff;
2655}
2656
2657__isl_give isl_aff *isl_aff_insert_dims(__isl_take isl_aff *aff,
2658 enum isl_dim_type type, unsigned first, unsigned n)
2659{
2660 if (!aff)
2661 return NULL;
2662 if (type == isl_dim_out)
2663 isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
2664 "cannot insert output/set dimensions",
2665 return isl_aff_free(aff));
2666 if (type == isl_dim_in)
2667 type = isl_dim_set;
2668 if (n == 0 && !isl_local_space_is_named_or_nested(ls: aff->ls, type))
2669 return aff;
2670
2671 if (isl_local_space_check_range(ls: aff->ls, type, first, n: 0) < 0)
2672 return isl_aff_free(aff);
2673
2674 aff = isl_aff_cow(aff);
2675 if (!aff)
2676 return NULL;
2677
2678 aff->ls = isl_local_space_insert_dims(ls: aff->ls, type, first, n);
2679 if (!aff->ls)
2680 return isl_aff_free(aff);
2681
2682 first += 1 + isl_local_space_offset(ls: aff->ls, type);
2683 aff->v = isl_vec_insert_zero_els(vec: aff->v, pos: first, n);
2684 if (!aff->v)
2685 return isl_aff_free(aff);
2686
2687 return aff;
2688}
2689
2690__isl_give isl_aff *isl_aff_add_dims(__isl_take isl_aff *aff,
2691 enum isl_dim_type type, unsigned n)
2692{
2693 isl_size pos;
2694
2695 pos = isl_aff_dim(aff, type);
2696 if (pos < 0)
2697 return isl_aff_free(aff);
2698
2699 return isl_aff_insert_dims(aff, type, first: pos, n);
2700}
2701
2702/* Move the "n" dimensions of "src_type" starting at "src_pos" of "aff"
2703 * to dimensions of "dst_type" at "dst_pos".
2704 *
2705 * We only support moving input dimensions to parameters and vice versa.
2706 */
2707__isl_give isl_aff *isl_aff_move_dims(__isl_take isl_aff *aff,
2708 enum isl_dim_type dst_type, unsigned dst_pos,
2709 enum isl_dim_type src_type, unsigned src_pos, unsigned n)
2710{
2711 unsigned g_dst_pos;
2712 unsigned g_src_pos;
2713 isl_size src_off, dst_off;
2714
2715 if (!aff)
2716 return NULL;
2717 if (n == 0 &&
2718 !isl_local_space_is_named_or_nested(ls: aff->ls, type: src_type) &&
2719 !isl_local_space_is_named_or_nested(ls: aff->ls, type: dst_type))
2720 return aff;
2721
2722 if (dst_type == isl_dim_out || src_type == isl_dim_out)
2723 isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
2724 "cannot move output/set dimension",
2725 return isl_aff_free(aff));
2726 if (dst_type == isl_dim_div || src_type == isl_dim_div)
2727 isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
2728 "cannot move divs", return isl_aff_free(aff));
2729 if (dst_type == isl_dim_in)
2730 dst_type = isl_dim_set;
2731 if (src_type == isl_dim_in)
2732 src_type = isl_dim_set;
2733
2734 if (isl_local_space_check_range(ls: aff->ls, type: src_type, first: src_pos, n) < 0)
2735 return isl_aff_free(aff);
2736 if (dst_type == src_type)
2737 isl_die(isl_aff_get_ctx(aff), isl_error_unsupported,
2738 "moving dims within the same type not supported",
2739 return isl_aff_free(aff));
2740
2741 aff = isl_aff_cow(aff);
2742 src_off = isl_aff_domain_offset(aff, type: src_type);
2743 dst_off = isl_aff_domain_offset(aff, type: dst_type);
2744 if (src_off < 0 || dst_off < 0)
2745 return isl_aff_free(aff);
2746
2747 g_src_pos = 1 + src_off + src_pos;
2748 g_dst_pos = 1 + dst_off + dst_pos;
2749 if (dst_type > src_type)
2750 g_dst_pos -= n;
2751
2752 aff->v = isl_vec_move_els(vec: aff->v, dst_col: g_dst_pos, src_col: g_src_pos, n);
2753 aff->ls = isl_local_space_move_dims(ls: aff->ls, dst_type, dst_pos,
2754 src_type, src_pos, n);
2755 if (!aff->v || !aff->ls)
2756 return isl_aff_free(aff);
2757
2758 aff = sort_divs(aff);
2759
2760 return aff;
2761}
2762
2763/* Return a zero isl_aff in the given space.
2764 *
2765 * This is a helper function for isl_pw_*_as_* that ensures a uniform
2766 * interface over all piecewise types.
2767 */
2768static __isl_give isl_aff *isl_aff_zero_in_space(__isl_take isl_space *space)
2769{
2770 isl_local_space *ls;
2771
2772 ls = isl_local_space_from_space(space: isl_space_domain(space));
2773 return isl_aff_zero_on_domain(ls);
2774}
2775
2776#define isl_aff_involves_nan isl_aff_is_nan
2777
2778#undef PW
2779#define PW isl_pw_aff
2780#undef BASE
2781#define BASE aff
2782#undef EL_IS_ZERO
2783#define EL_IS_ZERO is_empty
2784#undef ZERO
2785#define ZERO empty
2786#undef IS_ZERO
2787#define IS_ZERO is_empty
2788#undef FIELD
2789#define FIELD aff
2790#undef DEFAULT_IS_ZERO
2791#define DEFAULT_IS_ZERO 0
2792
2793#include <isl_pw_templ.c>
2794#include <isl_pw_un_op_templ.c>
2795#include <isl_pw_add_constant_val_templ.c>
2796#include <isl_pw_add_disjoint_templ.c>
2797#include <isl_pw_bind_domain_templ.c>
2798#include <isl_pw_eval.c>
2799#include <isl_pw_hash.c>
2800#include <isl_pw_fix_templ.c>
2801#include <isl_pw_from_range_templ.c>
2802#include <isl_pw_insert_dims_templ.c>
2803#include <isl_pw_insert_domain_templ.c>
2804#include <isl_pw_move_dims_templ.c>
2805#include <isl_pw_neg_templ.c>
2806#include <isl_pw_pullback_templ.c>
2807#include <isl_pw_scale_templ.c>
2808#include <isl_pw_sub_templ.c>
2809#include <isl_pw_union_opt.c>
2810
2811#undef BASE
2812#define BASE pw_aff
2813
2814#include <isl_union_single.c>
2815#include <isl_union_neg.c>
2816#include <isl_union_sub_templ.c>
2817
2818#undef BASE
2819#define BASE aff
2820
2821#include <isl_union_pw_templ.c>
2822
2823/* Compute a piecewise quasi-affine expression with a domain that
2824 * is the union of those of pwaff1 and pwaff2 and such that on each
2825 * cell, the quasi-affine expression is the maximum of those of pwaff1
2826 * and pwaff2. If only one of pwaff1 or pwaff2 is defined on a given
2827 * cell, then the associated expression is the defined one.
2828 */
2829__isl_give isl_pw_aff *isl_pw_aff_union_max(__isl_take isl_pw_aff *pwaff1,
2830 __isl_take isl_pw_aff *pwaff2)
2831{
2832 isl_pw_aff_align_params_bin(obj1: &pwaff1, obj2: &pwaff2);
2833 return isl_pw_aff_union_opt_cmp(pw1: pwaff1, pw2: pwaff2, cmp: &isl_aff_ge_set);
2834}
2835
2836/* Compute a piecewise quasi-affine expression with a domain that
2837 * is the union of those of pwaff1 and pwaff2 and such that on each
2838 * cell, the quasi-affine expression is the minimum of those of pwaff1
2839 * and pwaff2. If only one of pwaff1 or pwaff2 is defined on a given
2840 * cell, then the associated expression is the defined one.
2841 */
2842__isl_give isl_pw_aff *isl_pw_aff_union_min(__isl_take isl_pw_aff *pwaff1,
2843 __isl_take isl_pw_aff *pwaff2)
2844{
2845 isl_pw_aff_align_params_bin(obj1: &pwaff1, obj2: &pwaff2);
2846 return isl_pw_aff_union_opt_cmp(pw1: pwaff1, pw2: pwaff2, cmp: &isl_aff_le_set);
2847}
2848
2849__isl_give isl_pw_aff *isl_pw_aff_union_opt(__isl_take isl_pw_aff *pwaff1,
2850 __isl_take isl_pw_aff *pwaff2, int max)
2851{
2852 if (max)
2853 return isl_pw_aff_union_max(pwaff1, pwaff2);
2854 else
2855 return isl_pw_aff_union_min(pwaff1, pwaff2);
2856}
2857
2858/* Is the domain of "pa" a product?
2859 */
2860static isl_bool isl_pw_aff_domain_is_product(__isl_keep isl_pw_aff *pa)
2861{
2862 return isl_space_domain_is_wrapping(space: isl_pw_aff_peek_space(pw: pa));
2863}
2864
2865#undef TYPE
2866#define TYPE isl_pw_aff
2867#include <isl_domain_factor_templ.c>
2868
2869/* Return a set containing those elements in the domain
2870 * of "pwaff" where it satisfies "fn" (if complement is 0) or
2871 * does not satisfy "fn" (if complement is 1).
2872 *
2873 * The pieces with a NaN never belong to the result since
2874 * NaN does not satisfy any property.
2875 */
2876static __isl_give isl_set *pw_aff_locus(__isl_take isl_pw_aff *pwaff,
2877 __isl_give isl_basic_set *(*fn)(__isl_take isl_aff *aff, int rational,
2878 void *user),
2879 int complement, void *user)
2880{
2881 int i;
2882 isl_set *set;
2883
2884 if (!pwaff)
2885 return NULL;
2886
2887 set = isl_set_empty(space: isl_pw_aff_get_domain_space(pw: pwaff));
2888
2889 for (i = 0; i < pwaff->n; ++i) {
2890 isl_basic_set *bset;
2891 isl_set *set_i, *locus;
2892 isl_bool rational;
2893
2894 if (isl_aff_is_nan(aff: pwaff->p[i].aff))
2895 continue;
2896
2897 rational = isl_set_has_rational(set: pwaff->p[i].set);
2898 bset = fn(isl_aff_copy(aff: pwaff->p[i].aff), rational, user);
2899 locus = isl_set_from_basic_set(bset);
2900 set_i = isl_set_copy(set: pwaff->p[i].set);
2901 if (complement)
2902 set_i = isl_set_subtract(set1: set_i, set2: locus);
2903 else
2904 set_i = isl_set_intersect(set1: set_i, set2: locus);
2905 set = isl_set_union_disjoint(set1: set, set2: set_i);
2906 }
2907
2908 isl_pw_aff_free(pw: pwaff);
2909
2910 return set;
2911}
2912
2913/* Return a set containing those elements in the domain
2914 * of "pa" where it is positive.
2915 */
2916__isl_give isl_set *isl_pw_aff_pos_set(__isl_take isl_pw_aff *pa)
2917{
2918 return pw_aff_locus(pwaff: pa, fn: &aff_pos_basic_set, complement: 0, NULL);
2919}
2920
2921/* Return a set containing those elements in the domain
2922 * of pwaff where it is non-negative.
2923 */
2924__isl_give isl_set *isl_pw_aff_nonneg_set(__isl_take isl_pw_aff *pwaff)
2925{
2926 return pw_aff_locus(pwaff, fn: &aff_nonneg_basic_set, complement: 0, NULL);
2927}
2928
2929/* Return a set containing those elements in the domain
2930 * of pwaff where it is zero.
2931 */
2932__isl_give isl_set *isl_pw_aff_zero_set(__isl_take isl_pw_aff *pwaff)
2933{
2934 return pw_aff_locus(pwaff, fn: &aff_zero_basic_set, complement: 0, NULL);
2935}
2936
2937/* Return a set containing those elements in the domain
2938 * of pwaff where it is not zero.
2939 */
2940__isl_give isl_set *isl_pw_aff_non_zero_set(__isl_take isl_pw_aff *pwaff)
2941{
2942 return pw_aff_locus(pwaff, fn: &aff_zero_basic_set, complement: 1, NULL);
2943}
2944
2945/* Bind the affine function "aff" to the parameter "id",
2946 * returning the elements in the domain where the affine expression
2947 * is equal to the parameter.
2948 */
2949__isl_give isl_basic_set *isl_aff_bind_id(__isl_take isl_aff *aff,
2950 __isl_take isl_id *id)
2951{
2952 isl_space *space;
2953 isl_aff *aff_id;
2954
2955 space = isl_aff_get_domain_space(aff);
2956 space = isl_space_add_param_id(space, id: isl_id_copy(id));
2957
2958 aff = isl_aff_align_params(aff, model: isl_space_copy(space));
2959 aff_id = isl_aff_param_on_domain_space_id(space, id);
2960
2961 return isl_aff_eq_basic_set(aff1: aff, aff2: aff_id);
2962}
2963
2964/* Wrapper around isl_aff_bind_id for use as pw_aff_locus callback.
2965 * "rational" should not be set.
2966 */
2967static __isl_give isl_basic_set *aff_bind_id(__isl_take isl_aff *aff,
2968 int rational, void *user)
2969{
2970 isl_id *id = user;
2971
2972 if (!aff)
2973 return NULL;
2974 if (rational)
2975 isl_die(isl_aff_get_ctx(aff), isl_error_unsupported,
2976 "rational binding not supported", goto error);
2977 return isl_aff_bind_id(aff, id: isl_id_copy(id));
2978error:
2979 isl_aff_free(aff);
2980 return NULL;
2981}
2982
2983/* Bind the piecewise affine function "pa" to the parameter "id",
2984 * returning the elements in the domain where the expression
2985 * is equal to the parameter.
2986 */
2987__isl_give isl_set *isl_pw_aff_bind_id(__isl_take isl_pw_aff *pa,
2988 __isl_take isl_id *id)
2989{
2990 isl_set *bound;
2991
2992 bound = pw_aff_locus(pwaff: pa, fn: &aff_bind_id, complement: 0, user: id);
2993 isl_id_free(id);
2994
2995 return bound;
2996}
2997
2998/* Return a set containing those elements in the shared domain
2999 * of pwaff1 and pwaff2 where pwaff1 is greater than (or equal) to pwaff2.
3000 *
3001 * We compute the difference on the shared domain and then construct
3002 * the set of values where this difference is non-negative.
3003 * If strict is set, we first subtract 1 from the difference.
3004 * If equal is set, we only return the elements where pwaff1 and pwaff2
3005 * are equal.
3006 */
3007static __isl_give isl_set *pw_aff_gte_set(__isl_take isl_pw_aff *pwaff1,
3008 __isl_take isl_pw_aff *pwaff2, int strict, int equal)
3009{
3010 isl_set *set1, *set2;
3011
3012 set1 = isl_pw_aff_domain(pw: isl_pw_aff_copy(pw: pwaff1));
3013 set2 = isl_pw_aff_domain(pw: isl_pw_aff_copy(pw: pwaff2));
3014 set1 = isl_set_intersect(set1, set2);
3015 pwaff1 = isl_pw_aff_intersect_domain(pw: pwaff1, context: isl_set_copy(set: set1));
3016 pwaff2 = isl_pw_aff_intersect_domain(pw: pwaff2, context: isl_set_copy(set: set1));
3017 pwaff1 = isl_pw_aff_add(pwaff1, pwaff2: isl_pw_aff_neg(pw: pwaff2));
3018
3019 if (strict) {
3020 isl_space *space = isl_set_get_space(set: set1);
3021 isl_aff *aff;
3022 aff = isl_aff_zero_on_domain(ls: isl_local_space_from_space(space));
3023 aff = isl_aff_add_constant_si(aff, v: -1);
3024 pwaff1 = isl_pw_aff_add(pwaff1, pwaff2: isl_pw_aff_alloc(set: set1, el: aff));
3025 } else
3026 isl_set_free(set: set1);
3027
3028 if (equal)
3029 return isl_pw_aff_zero_set(pwaff: pwaff1);
3030 return isl_pw_aff_nonneg_set(pwaff: pwaff1);
3031}
3032
3033/* Return a set containing those elements in the shared domain
3034 * of pwaff1 and pwaff2 where pwaff1 is equal to pwaff2.
3035 */
3036__isl_give isl_set *isl_pw_aff_eq_set(__isl_take isl_pw_aff *pwaff1,
3037 __isl_take isl_pw_aff *pwaff2)
3038{
3039 isl_pw_aff_align_params_bin(obj1: &pwaff1, obj2: &pwaff2);
3040 return pw_aff_gte_set(pwaff1, pwaff2, strict: 0, equal: 1);
3041}
3042
3043/* Return a set containing those elements in the shared domain
3044 * of pwaff1 and pwaff2 where pwaff1 is greater than or equal to pwaff2.
3045 */
3046__isl_give isl_set *isl_pw_aff_ge_set(__isl_take isl_pw_aff *pwaff1,
3047 __isl_take isl_pw_aff *pwaff2)
3048{
3049 isl_pw_aff_align_params_bin(obj1: &pwaff1, obj2: &pwaff2);
3050 return pw_aff_gte_set(pwaff1, pwaff2, strict: 0, equal: 0);
3051}
3052
3053/* Return a set containing those elements in the shared domain
3054 * of pwaff1 and pwaff2 where pwaff1 is strictly greater than pwaff2.
3055 */
3056__isl_give isl_set *isl_pw_aff_gt_set(__isl_take isl_pw_aff *pwaff1,
3057 __isl_take isl_pw_aff *pwaff2)
3058{
3059 isl_pw_aff_align_params_bin(obj1: &pwaff1, obj2: &pwaff2);
3060 return pw_aff_gte_set(pwaff1, pwaff2, strict: 1, equal: 0);
3061}
3062
3063__isl_give isl_set *isl_pw_aff_le_set(__isl_take isl_pw_aff *pwaff1,
3064 __isl_take isl_pw_aff *pwaff2)
3065{
3066 return isl_pw_aff_ge_set(pwaff1: pwaff2, pwaff2: pwaff1);
3067}
3068
3069__isl_give isl_set *isl_pw_aff_lt_set(__isl_take isl_pw_aff *pwaff1,
3070 __isl_take isl_pw_aff *pwaff2)
3071{
3072 return isl_pw_aff_gt_set(pwaff1: pwaff2, pwaff2: pwaff1);
3073}
3074
3075/* Return a map containing pairs of elements in the domains of "pa1" and "pa2"
3076 * where the function values are ordered in the same way as "order",
3077 * which returns a set in the shared domain of its two arguments.
3078 *
3079 * Let "pa1" and "pa2" be defined on domains A and B respectively.
3080 * We first pull back the two functions such that they are defined on
3081 * the domain [A -> B]. Then we apply "order", resulting in a set
3082 * in the space [A -> B]. Finally, we unwrap this set to obtain
3083 * a map in the space A -> B.
3084 */
3085static __isl_give isl_map *isl_pw_aff_order_map(
3086 __isl_take isl_pw_aff *pa1, __isl_take isl_pw_aff *pa2,
3087 __isl_give isl_set *(*order)(__isl_take isl_pw_aff *pa1,
3088 __isl_take isl_pw_aff *pa2))
3089{
3090 isl_space *space1, *space2;
3091 isl_multi_aff *ma;
3092 isl_set *set;
3093
3094 isl_pw_aff_align_params_bin(obj1: &pa1, obj2: &pa2);
3095 space1 = isl_space_domain(space: isl_pw_aff_get_space(pw: pa1));
3096 space2 = isl_space_domain(space: isl_pw_aff_get_space(pw: pa2));
3097 space1 = isl_space_map_from_domain_and_range(domain: space1, range: space2);
3098 ma = isl_multi_aff_domain_map(space: isl_space_copy(space: space1));
3099 pa1 = isl_pw_aff_pullback_multi_aff(pw: pa1, ma);
3100 ma = isl_multi_aff_range_map(space: space1);
3101 pa2 = isl_pw_aff_pullback_multi_aff(pw: pa2, ma);
3102 set = order(pa1, pa2);
3103
3104 return isl_set_unwrap(set);
3105}
3106
3107/* Return a map containing pairs of elements in the domains of "pa1" and "pa2"
3108 * where the function values are equal.
3109 */
3110__isl_give isl_map *isl_pw_aff_eq_map(__isl_take isl_pw_aff *pa1,
3111 __isl_take isl_pw_aff *pa2)
3112{
3113 return isl_pw_aff_order_map(pa1, pa2, order: &isl_pw_aff_eq_set);
3114}
3115
3116/* Return a map containing pairs of elements in the domains of "pa1" and "pa2"
3117 * where the function value of "pa1" is less than or equal to
3118 * the function value of "pa2".
3119 */
3120__isl_give isl_map *isl_pw_aff_le_map(__isl_take isl_pw_aff *pa1,
3121 __isl_take isl_pw_aff *pa2)
3122{
3123 return isl_pw_aff_order_map(pa1, pa2, order: &isl_pw_aff_le_set);
3124}
3125
3126/* Return a map containing pairs of elements in the domains of "pa1" and "pa2"
3127 * where the function value of "pa1" is less than the function value of "pa2".
3128 */
3129__isl_give isl_map *isl_pw_aff_lt_map(__isl_take isl_pw_aff *pa1,
3130 __isl_take isl_pw_aff *pa2)
3131{
3132 return isl_pw_aff_order_map(pa1, pa2, order: &isl_pw_aff_lt_set);
3133}
3134
3135/* Return a map containing pairs of elements in the domains of "pa1" and "pa2"
3136 * where the function value of "pa1" is greater than or equal to
3137 * the function value of "pa2".
3138 */
3139__isl_give isl_map *isl_pw_aff_ge_map(__isl_take isl_pw_aff *pa1,
3140 __isl_take isl_pw_aff *pa2)
3141{
3142 return isl_pw_aff_order_map(pa1, pa2, order: &isl_pw_aff_ge_set);
3143}
3144
3145/* Return a map containing pairs of elements in the domains of "pa1" and "pa2"
3146 * where the function value of "pa1" is greater than the function value
3147 * of "pa2".
3148 */
3149__isl_give isl_map *isl_pw_aff_gt_map(__isl_take isl_pw_aff *pa1,
3150 __isl_take isl_pw_aff *pa2)
3151{
3152 return isl_pw_aff_order_map(pa1, pa2, order: &isl_pw_aff_gt_set);
3153}
3154
3155/* Return a set containing those elements in the shared domain
3156 * of the elements of list1 and list2 where each element in list1
3157 * has the relation specified by "fn" with each element in list2.
3158 */
3159static __isl_give isl_set *pw_aff_list_set(__isl_take isl_pw_aff_list *list1,
3160 __isl_take isl_pw_aff_list *list2,
3161 __isl_give isl_set *(*fn)(__isl_take isl_pw_aff *pwaff1,
3162 __isl_take isl_pw_aff *pwaff2))
3163{
3164 int i, j;
3165 isl_ctx *ctx;
3166 isl_set *set;
3167
3168 if (!list1 || !list2)
3169 goto error;
3170
3171 ctx = isl_pw_aff_list_get_ctx(list: list1);
3172 if (list1->n < 1 || list2->n < 1)
3173 isl_die(ctx, isl_error_invalid,
3174 "list should contain at least one element", goto error);
3175
3176 set = isl_set_universe(space: isl_pw_aff_get_domain_space(pw: list1->p[0]));
3177 for (i = 0; i < list1->n; ++i)
3178 for (j = 0; j < list2->n; ++j) {
3179 isl_set *set_ij;
3180
3181 set_ij = fn(isl_pw_aff_copy(pw: list1->p[i]),
3182 isl_pw_aff_copy(pw: list2->p[j]));
3183 set = isl_set_intersect(set1: set, set2: set_ij);
3184 }
3185
3186 isl_pw_aff_list_free(list: list1);
3187 isl_pw_aff_list_free(list: list2);
3188 return set;
3189error:
3190 isl_pw_aff_list_free(list: list1);
3191 isl_pw_aff_list_free(list: list2);
3192 return NULL;
3193}
3194
3195/* Return a set containing those elements in the shared domain
3196 * of the elements of list1 and list2 where each element in list1
3197 * is equal to each element in list2.
3198 */
3199__isl_give isl_set *isl_pw_aff_list_eq_set(__isl_take isl_pw_aff_list *list1,
3200 __isl_take isl_pw_aff_list *list2)
3201{
3202 return pw_aff_list_set(list1, list2, fn: &isl_pw_aff_eq_set);
3203}
3204
3205__isl_give isl_set *isl_pw_aff_list_ne_set(__isl_take isl_pw_aff_list *list1,
3206 __isl_take isl_pw_aff_list *list2)
3207{
3208 return pw_aff_list_set(list1, list2, fn: &isl_pw_aff_ne_set);
3209}
3210
3211/* Return a set containing those elements in the shared domain
3212 * of the elements of list1 and list2 where each element in list1
3213 * is less than or equal to each element in list2.
3214 */
3215__isl_give isl_set *isl_pw_aff_list_le_set(__isl_take isl_pw_aff_list *list1,
3216 __isl_take isl_pw_aff_list *list2)
3217{
3218 return pw_aff_list_set(list1, list2, fn: &isl_pw_aff_le_set);
3219}
3220
3221__isl_give isl_set *isl_pw_aff_list_lt_set(__isl_take isl_pw_aff_list *list1,
3222 __isl_take isl_pw_aff_list *list2)
3223{
3224 return pw_aff_list_set(list1, list2, fn: &isl_pw_aff_lt_set);
3225}
3226
3227__isl_give isl_set *isl_pw_aff_list_ge_set(__isl_take isl_pw_aff_list *list1,
3228 __isl_take isl_pw_aff_list *list2)
3229{
3230 return pw_aff_list_set(list1, list2, fn: &isl_pw_aff_ge_set);
3231}
3232
3233__isl_give isl_set *isl_pw_aff_list_gt_set(__isl_take isl_pw_aff_list *list1,
3234 __isl_take isl_pw_aff_list *list2)
3235{
3236 return pw_aff_list_set(list1, list2, fn: &isl_pw_aff_gt_set);
3237}
3238
3239
3240/* Return a set containing those elements in the shared domain
3241 * of pwaff1 and pwaff2 where pwaff1 is not equal to pwaff2.
3242 */
3243__isl_give isl_set *isl_pw_aff_ne_set(__isl_take isl_pw_aff *pwaff1,
3244 __isl_take isl_pw_aff *pwaff2)
3245{
3246 isl_set *set_lt, *set_gt;
3247
3248 isl_pw_aff_align_params_bin(obj1: &pwaff1, obj2: &pwaff2);
3249 set_lt = isl_pw_aff_lt_set(pwaff1: isl_pw_aff_copy(pw: pwaff1),
3250 pwaff2: isl_pw_aff_copy(pw: pwaff2));
3251 set_gt = isl_pw_aff_gt_set(pwaff1, pwaff2);
3252 return isl_set_union_disjoint(set1: set_lt, set2: set_gt);
3253}
3254
3255__isl_give isl_pw_aff *isl_pw_aff_scale_down(__isl_take isl_pw_aff *pwaff,
3256 isl_int v)
3257{
3258 int i;
3259
3260 if (isl_int_is_one(v))
3261 return pwaff;
3262 if (!isl_int_is_pos(v))
3263 isl_die(isl_pw_aff_get_ctx(pwaff), isl_error_invalid,
3264 "factor needs to be positive",
3265 return isl_pw_aff_free(pwaff));
3266 pwaff = isl_pw_aff_cow(pw: pwaff);
3267 if (!pwaff)
3268 return NULL;
3269 if (pwaff->n == 0)
3270 return pwaff;
3271
3272 for (i = 0; i < pwaff->n; ++i) {
3273 pwaff->p[i].aff = isl_aff_scale_down(aff: pwaff->p[i].aff, f: v);
3274 if (!pwaff->p[i].aff)
3275 return isl_pw_aff_free(pw: pwaff);
3276 }
3277
3278 return pwaff;
3279}
3280
3281__isl_give isl_pw_aff *isl_pw_aff_floor(__isl_take isl_pw_aff *pwaff)
3282{
3283 return isl_pw_aff_un_op(pw: pwaff, fn: &isl_aff_floor);
3284}
3285
3286__isl_give isl_pw_aff *isl_pw_aff_ceil(__isl_take isl_pw_aff *pwaff)
3287{
3288 return isl_pw_aff_un_op(pw: pwaff, fn: &isl_aff_ceil);
3289}
3290
3291/* Assuming that "cond1" and "cond2" are disjoint,
3292 * return an affine expression that is equal to pwaff1 on cond1
3293 * and to pwaff2 on cond2.
3294 */
3295static __isl_give isl_pw_aff *isl_pw_aff_select(
3296 __isl_take isl_set *cond1, __isl_take isl_pw_aff *pwaff1,
3297 __isl_take isl_set *cond2, __isl_take isl_pw_aff *pwaff2)
3298{
3299 pwaff1 = isl_pw_aff_intersect_domain(pw: pwaff1, context: cond1);
3300 pwaff2 = isl_pw_aff_intersect_domain(pw: pwaff2, context: cond2);
3301
3302 return isl_pw_aff_add_disjoint(pw1: pwaff1, pw2: pwaff2);
3303}
3304
3305/* Return an affine expression that is equal to pwaff_true for elements
3306 * where "cond" is non-zero and to pwaff_false for elements where "cond"
3307 * is zero.
3308 * That is, return cond ? pwaff_true : pwaff_false;
3309 *
3310 * If "cond" involves and NaN, then we conservatively return a NaN
3311 * on its entire domain. In principle, we could consider the pieces
3312 * where it is NaN separately from those where it is not.
3313 *
3314 * If "pwaff_true" and "pwaff_false" are obviously equal to each other,
3315 * then only use the domain of "cond" to restrict the domain.
3316 */
3317__isl_give isl_pw_aff *isl_pw_aff_cond(__isl_take isl_pw_aff *cond,
3318 __isl_take isl_pw_aff *pwaff_true, __isl_take isl_pw_aff *pwaff_false)
3319{
3320 isl_set *cond_true, *cond_false;
3321 isl_bool equal;
3322
3323 if (!cond)
3324 goto error;
3325 if (isl_pw_aff_involves_nan(pw: cond)) {
3326 isl_space *space = isl_pw_aff_get_domain_space(pw: cond);
3327 isl_local_space *ls = isl_local_space_from_space(space);
3328 isl_pw_aff_free(pw: cond);
3329 isl_pw_aff_free(pw: pwaff_true);
3330 isl_pw_aff_free(pw: pwaff_false);
3331 return isl_pw_aff_nan_on_domain(ls);
3332 }
3333
3334 pwaff_true = isl_pw_aff_align_params(pw: pwaff_true,
3335 model: isl_pw_aff_get_space(pw: pwaff_false));
3336 pwaff_false = isl_pw_aff_align_params(pw: pwaff_false,
3337 model: isl_pw_aff_get_space(pw: pwaff_true));
3338 equal = isl_pw_aff_plain_is_equal(pw1: pwaff_true, pw2: pwaff_false);
3339 if (equal < 0)
3340 goto error;
3341 if (equal) {
3342 isl_set *dom;
3343
3344 dom = isl_set_coalesce(set: isl_pw_aff_domain(pw: cond));
3345 isl_pw_aff_free(pw: pwaff_false);
3346 return isl_pw_aff_intersect_domain(pw: pwaff_true, context: dom);
3347 }
3348
3349 cond_true = isl_pw_aff_non_zero_set(pwaff: isl_pw_aff_copy(pw: cond));
3350 cond_false = isl_pw_aff_zero_set(pwaff: cond);
3351 return isl_pw_aff_select(cond1: cond_true, pwaff1: pwaff_true,
3352 cond2: cond_false, pwaff2: pwaff_false);
3353error:
3354 isl_pw_aff_free(pw: cond);
3355 isl_pw_aff_free(pw: pwaff_true);
3356 isl_pw_aff_free(pw: pwaff_false);
3357 return NULL;
3358}
3359
3360isl_bool isl_aff_is_cst(__isl_keep isl_aff *aff)
3361{
3362 int pos;
3363
3364 if (!aff)
3365 return isl_bool_error;
3366
3367 pos = isl_seq_first_non_zero(p: aff->v->el + 2, len: aff->v->size - 2);
3368 return isl_bool_ok(b: pos == -1);
3369}
3370
3371/* Check whether pwaff is a piecewise constant.
3372 */
3373isl_bool isl_pw_aff_is_cst(__isl_keep isl_pw_aff *pwaff)
3374{
3375 int i;
3376
3377 if (!pwaff)
3378 return isl_bool_error;
3379
3380 for (i = 0; i < pwaff->n; ++i) {
3381 isl_bool is_cst = isl_aff_is_cst(aff: pwaff->p[i].aff);
3382 if (is_cst < 0 || !is_cst)
3383 return is_cst;
3384 }
3385
3386 return isl_bool_true;
3387}
3388
3389/* Return the product of "aff1" and "aff2".
3390 *
3391 * If either of the two is NaN, then the result is NaN.
3392 *
3393 * Otherwise, at least one of "aff1" or "aff2" needs to be a constant.
3394 */
3395__isl_give isl_aff *isl_aff_mul(__isl_take isl_aff *aff1,
3396 __isl_take isl_aff *aff2)
3397{
3398 if (!aff1 || !aff2)
3399 goto error;
3400
3401 if (isl_aff_is_nan(aff: aff1)) {
3402 isl_aff_free(aff: aff2);
3403 return aff1;
3404 }
3405 if (isl_aff_is_nan(aff: aff2)) {
3406 isl_aff_free(aff: aff1);
3407 return aff2;
3408 }
3409
3410 if (!isl_aff_is_cst(aff: aff2) && isl_aff_is_cst(aff: aff1))
3411 return isl_aff_mul(aff1: aff2, aff2: aff1);
3412
3413 if (!isl_aff_is_cst(aff: aff2))
3414 isl_die(isl_aff_get_ctx(aff1), isl_error_invalid,
3415 "at least one affine expression should be constant",
3416 goto error);
3417
3418 aff1 = isl_aff_cow(aff: aff1);
3419 if (!aff1 || !aff2)
3420 goto error;
3421
3422 aff1 = isl_aff_scale(aff: aff1, f: aff2->v->el[1]);
3423 aff1 = isl_aff_scale_down(aff: aff1, f: aff2->v->el[0]);
3424
3425 isl_aff_free(aff: aff2);
3426 return aff1;
3427error:
3428 isl_aff_free(aff: aff1);
3429 isl_aff_free(aff: aff2);
3430 return NULL;
3431}
3432
3433/* Divide "aff1" by "aff2", assuming "aff2" is a constant.
3434 *
3435 * If either of the two is NaN, then the result is NaN.
3436 * A division by zero also results in NaN.
3437 */
3438__isl_give isl_aff *isl_aff_div(__isl_take isl_aff *aff1,
3439 __isl_take isl_aff *aff2)
3440{
3441 isl_bool is_cst, is_zero;
3442 int neg;
3443
3444 if (!aff1 || !aff2)
3445 goto error;
3446
3447 if (isl_aff_is_nan(aff: aff1)) {
3448 isl_aff_free(aff: aff2);
3449 return aff1;
3450 }
3451 if (isl_aff_is_nan(aff: aff2)) {
3452 isl_aff_free(aff: aff1);
3453 return aff2;
3454 }
3455
3456 is_cst = isl_aff_is_cst(aff: aff2);
3457 if (is_cst < 0)
3458 goto error;
3459 if (!is_cst)
3460 isl_die(isl_aff_get_ctx(aff2), isl_error_invalid,
3461 "second argument should be a constant", goto error);
3462 is_zero = isl_aff_plain_is_zero(aff: aff2);
3463 if (is_zero < 0)
3464 goto error;
3465 if (is_zero)
3466 return set_nan_free(aff1, aff2);
3467
3468 neg = isl_int_is_neg(aff2->v->el[1]);
3469 if (neg) {
3470 isl_int_neg(aff2->v->el[0], aff2->v->el[0]);
3471 isl_int_neg(aff2->v->el[1], aff2->v->el[1]);
3472 }
3473
3474 aff1 = isl_aff_scale(aff: aff1, f: aff2->v->el[0]);
3475 aff1 = isl_aff_scale_down(aff: aff1, f: aff2->v->el[1]);
3476
3477 if (neg) {
3478 isl_int_neg(aff2->v->el[0], aff2->v->el[0]);
3479 isl_int_neg(aff2->v->el[1], aff2->v->el[1]);
3480 }
3481
3482 isl_aff_free(aff: aff2);
3483 return aff1;
3484error:
3485 isl_aff_free(aff: aff1);
3486 isl_aff_free(aff: aff2);
3487 return NULL;
3488}
3489
3490__isl_give isl_pw_aff *isl_pw_aff_add(__isl_take isl_pw_aff *pwaff1,
3491 __isl_take isl_pw_aff *pwaff2)
3492{
3493 isl_pw_aff_align_params_bin(obj1: &pwaff1, obj2: &pwaff2);
3494 return isl_pw_aff_on_shared_domain(pw1: pwaff1, pw2: pwaff2, fn: &isl_aff_add);
3495}
3496
3497__isl_give isl_pw_aff *isl_pw_aff_mul(__isl_take isl_pw_aff *pwaff1,
3498 __isl_take isl_pw_aff *pwaff2)
3499{
3500 isl_pw_aff_align_params_bin(obj1: &pwaff1, obj2: &pwaff2);
3501 return isl_pw_aff_on_shared_domain(pw1: pwaff1, pw2: pwaff2, fn: &isl_aff_mul);
3502}
3503
3504/* Divide "pa1" by "pa2", assuming "pa2" is a piecewise constant.
3505 */
3506__isl_give isl_pw_aff *isl_pw_aff_div(__isl_take isl_pw_aff *pa1,
3507 __isl_take isl_pw_aff *pa2)
3508{
3509 int is_cst;
3510
3511 is_cst = isl_pw_aff_is_cst(pwaff: pa2);
3512 if (is_cst < 0)
3513 goto error;
3514 if (!is_cst)
3515 isl_die(isl_pw_aff_get_ctx(pa2), isl_error_invalid,
3516 "second argument should be a piecewise constant",
3517 goto error);
3518 isl_pw_aff_align_params_bin(obj1: &pa1, obj2: &pa2);
3519 return isl_pw_aff_on_shared_domain(pw1: pa1, pw2: pa2, fn: &isl_aff_div);
3520error:
3521 isl_pw_aff_free(pw: pa1);
3522 isl_pw_aff_free(pw: pa2);
3523 return NULL;
3524}
3525
3526/* Compute the quotient of the integer division of "pa1" by "pa2"
3527 * with rounding towards zero.
3528 * "pa2" is assumed to be a piecewise constant.
3529 *
3530 * In particular, return
3531 *
3532 * pa1 >= 0 ? floor(pa1/pa2) : ceil(pa1/pa2)
3533 *
3534 */
3535__isl_give isl_pw_aff *isl_pw_aff_tdiv_q(__isl_take isl_pw_aff *pa1,
3536 __isl_take isl_pw_aff *pa2)
3537{
3538 int is_cst;
3539 isl_set *cond;
3540 isl_pw_aff *f, *c;
3541
3542 is_cst = isl_pw_aff_is_cst(pwaff: pa2);
3543 if (is_cst < 0)
3544 goto error;
3545 if (!is_cst)
3546 isl_die(isl_pw_aff_get_ctx(pa2), isl_error_invalid,
3547 "second argument should be a piecewise constant",
3548 goto error);
3549
3550 pa1 = isl_pw_aff_div(pa1, pa2);
3551
3552 cond = isl_pw_aff_nonneg_set(pwaff: isl_pw_aff_copy(pw: pa1));
3553 f = isl_pw_aff_floor(pwaff: isl_pw_aff_copy(pw: pa1));
3554 c = isl_pw_aff_ceil(pwaff: pa1);
3555 return isl_pw_aff_cond(cond: isl_set_indicator_function(set: cond), pwaff_true: f, pwaff_false: c);
3556error:
3557 isl_pw_aff_free(pw: pa1);
3558 isl_pw_aff_free(pw: pa2);
3559 return NULL;
3560}
3561
3562/* Compute the remainder of the integer division of "pa1" by "pa2"
3563 * with rounding towards zero.
3564 * "pa2" is assumed to be a piecewise constant.
3565 *
3566 * In particular, return
3567 *
3568 * pa1 - pa2 * (pa1 >= 0 ? floor(pa1/pa2) : ceil(pa1/pa2))
3569 *
3570 */
3571__isl_give isl_pw_aff *isl_pw_aff_tdiv_r(__isl_take isl_pw_aff *pa1,
3572 __isl_take isl_pw_aff *pa2)
3573{
3574 int is_cst;
3575 isl_pw_aff *res;
3576
3577 is_cst = isl_pw_aff_is_cst(pwaff: pa2);
3578 if (is_cst < 0)
3579 goto error;
3580 if (!is_cst)
3581 isl_die(isl_pw_aff_get_ctx(pa2), isl_error_invalid,
3582 "second argument should be a piecewise constant",
3583 goto error);
3584 res = isl_pw_aff_tdiv_q(pa1: isl_pw_aff_copy(pw: pa1), pa2: isl_pw_aff_copy(pw: pa2));
3585 res = isl_pw_aff_mul(pwaff1: pa2, pwaff2: res);
3586 res = isl_pw_aff_sub(pw1: pa1, pw2: res);
3587 return res;
3588error:
3589 isl_pw_aff_free(pw: pa1);
3590 isl_pw_aff_free(pw: pa2);
3591 return NULL;
3592}
3593
3594/* Does either of "pa1" or "pa2" involve any NaN?
3595 */
3596static isl_bool either_involves_nan(__isl_keep isl_pw_aff *pa1,
3597 __isl_keep isl_pw_aff *pa2)
3598{
3599 isl_bool has_nan;
3600
3601 has_nan = isl_pw_aff_involves_nan(pw: pa1);
3602 if (has_nan < 0 || has_nan)
3603 return has_nan;
3604 return isl_pw_aff_involves_nan(pw: pa2);
3605}
3606
3607/* Return a piecewise affine expression defined on the specified domain
3608 * that represents NaN.
3609 */
3610static __isl_give isl_pw_aff *nan_on_domain_set(__isl_take isl_set *dom)
3611{
3612 isl_local_space *ls;
3613 isl_pw_aff *pa;
3614
3615 ls = isl_local_space_from_space(space: isl_set_get_space(set: dom));
3616 pa = isl_pw_aff_nan_on_domain(ls);
3617 pa = isl_pw_aff_intersect_domain(pw: pa, context: dom);
3618
3619 return pa;
3620}
3621
3622/* Replace "pa1" and "pa2" (at least one of which involves a NaN)
3623 * by a NaN on their shared domain.
3624 *
3625 * In principle, the result could be refined to only being NaN
3626 * on the parts of this domain where at least one of "pa1" or "pa2" is NaN.
3627 */
3628static __isl_give isl_pw_aff *replace_by_nan(__isl_take isl_pw_aff *pa1,
3629 __isl_take isl_pw_aff *pa2)
3630{
3631 isl_set *dom;
3632
3633 dom = isl_set_intersect(set1: isl_pw_aff_domain(pw: pa1), set2: isl_pw_aff_domain(pw: pa2));
3634 return nan_on_domain_set(dom);
3635}
3636
3637static __isl_give isl_pw_aff *pw_aff_min(__isl_take isl_pw_aff *pwaff1,
3638 __isl_take isl_pw_aff *pwaff2)
3639{
3640 isl_set *le;
3641 isl_set *dom;
3642
3643 dom = isl_set_intersect(set1: isl_pw_aff_domain(pw: isl_pw_aff_copy(pw: pwaff1)),
3644 set2: isl_pw_aff_domain(pw: isl_pw_aff_copy(pw: pwaff2)));
3645 le = isl_pw_aff_le_set(pwaff1: isl_pw_aff_copy(pw: pwaff1),
3646 pwaff2: isl_pw_aff_copy(pw: pwaff2));
3647 dom = isl_set_subtract(set1: dom, set2: isl_set_copy(set: le));
3648 return isl_pw_aff_select(cond1: le, pwaff1, cond2: dom, pwaff2);
3649}
3650
3651static __isl_give isl_pw_aff *pw_aff_max(__isl_take isl_pw_aff *pwaff1,
3652 __isl_take isl_pw_aff *pwaff2)
3653{
3654 isl_set *ge;
3655 isl_set *dom;
3656
3657 dom = isl_set_intersect(set1: isl_pw_aff_domain(pw: isl_pw_aff_copy(pw: pwaff1)),
3658 set2: isl_pw_aff_domain(pw: isl_pw_aff_copy(pw: pwaff2)));
3659 ge = isl_pw_aff_ge_set(pwaff1: isl_pw_aff_copy(pw: pwaff1),
3660 pwaff2: isl_pw_aff_copy(pw: pwaff2));
3661 dom = isl_set_subtract(set1: dom, set2: isl_set_copy(set: ge));
3662 return isl_pw_aff_select(cond1: ge, pwaff1, cond2: dom, pwaff2);
3663}
3664
3665/* Return an expression for the minimum (if "max" is not set) or
3666 * the maximum (if "max" is set) of "pa1" and "pa2".
3667 * If either expression involves any NaN, then return a NaN
3668 * on the shared domain as result.
3669 */
3670static __isl_give isl_pw_aff *pw_aff_min_max(__isl_take isl_pw_aff *pa1,
3671 __isl_take isl_pw_aff *pa2, int max)
3672{
3673 isl_bool has_nan;
3674
3675 has_nan = either_involves_nan(pa1, pa2);
3676 if (has_nan < 0)
3677 pa1 = isl_pw_aff_free(pw: pa1);
3678 else if (has_nan)
3679 return replace_by_nan(pa1, pa2);
3680
3681 isl_pw_aff_align_params_bin(obj1: &pa1, obj2: &pa2);
3682 if (max)
3683 return pw_aff_max(pwaff1: pa1, pwaff2: pa2);
3684 else
3685 return pw_aff_min(pwaff1: pa1, pwaff2: pa2);
3686}
3687
3688/* Return an expression for the minimum of "pwaff1" and "pwaff2".
3689 */
3690__isl_give isl_pw_aff *isl_pw_aff_min(__isl_take isl_pw_aff *pwaff1,
3691 __isl_take isl_pw_aff *pwaff2)
3692{
3693 return pw_aff_min_max(pa1: pwaff1, pa2: pwaff2, max: 0);
3694}
3695
3696/* Return an expression for the maximum of "pwaff1" and "pwaff2".
3697 */
3698__isl_give isl_pw_aff *isl_pw_aff_max(__isl_take isl_pw_aff *pwaff1,
3699 __isl_take isl_pw_aff *pwaff2)
3700{
3701 return pw_aff_min_max(pa1: pwaff1, pa2: pwaff2, max: 1);
3702}
3703
3704/* Does "pa" not involve any NaN?
3705 */
3706static isl_bool pw_aff_no_nan(__isl_keep isl_pw_aff *pa, void *user)
3707{
3708 return isl_bool_not(b: isl_pw_aff_involves_nan(pw: pa));
3709}
3710
3711/* Does any element of "list" involve any NaN?
3712 *
3713 * That is, is it not the case that every element does not involve any NaN?
3714 */
3715static isl_bool isl_pw_aff_list_involves_nan(__isl_keep isl_pw_aff_list *list)
3716{
3717 return isl_bool_not(b: isl_pw_aff_list_every(list, test: &pw_aff_no_nan, NULL));
3718}
3719
3720/* Replace "list" (consisting of "n" elements, of which
3721 * at least one element involves a NaN)
3722 * by a NaN on the shared domain of the elements.
3723 *
3724 * In principle, the result could be refined to only being NaN
3725 * on the parts of this domain where at least one of the elements is NaN.
3726 */
3727static __isl_give isl_pw_aff *replace_list_by_nan(
3728 __isl_take isl_pw_aff_list *list, int n)
3729{
3730 int i;
3731 isl_set *dom;
3732
3733 dom = isl_pw_aff_domain(pw: isl_pw_aff_list_get_at(list, index: 0));
3734 for (i = 1; i < n; ++i) {
3735 isl_set *dom_i;
3736
3737 dom_i = isl_pw_aff_domain(pw: isl_pw_aff_list_get_at(list, index: i));
3738 dom = isl_set_intersect(set1: dom, set2: dom_i);
3739 }
3740
3741 isl_pw_aff_list_free(list);
3742 return nan_on_domain_set(dom);
3743}
3744
3745/* Return the set where the element at "pos1" of "list" is less than or
3746 * equal to the element at "pos2".
3747 * Equality is only allowed if "pos1" is smaller than "pos2".
3748 */
3749static __isl_give isl_set *less(__isl_keep isl_pw_aff_list *list,
3750 int pos1, int pos2)
3751{
3752 isl_pw_aff *pa1, *pa2;
3753
3754 pa1 = isl_pw_aff_list_get_at(list, index: pos1);
3755 pa2 = isl_pw_aff_list_get_at(list, index: pos2);
3756
3757 if (pos1 < pos2)
3758 return isl_pw_aff_le_set(pwaff1: pa1, pwaff2: pa2);
3759 else
3760 return isl_pw_aff_lt_set(pwaff1: pa1, pwaff2: pa2);
3761}
3762
3763/* Return an isl_pw_aff that maps each element in the intersection of the
3764 * domains of the piecewise affine expressions in "list"
3765 * to the maximal (if "max" is set) or minimal (if "max" is not set)
3766 * expression in "list" at that element.
3767 * If any expression involves any NaN, then return a NaN
3768 * on the shared domain as result.
3769 *
3770 * If "list" has n elements, then the result consists of n pieces,
3771 * where, in the case of a minimum, each piece has as value expression
3772 * the value expression of one of the elements and as domain
3773 * the set of elements where that value expression
3774 * is less than (or equal) to the other value expressions.
3775 * In the case of a maximum, the condition is
3776 * that all the other value expressions are less than (or equal)
3777 * to the given value expression.
3778 *
3779 * In order to produce disjoint pieces, a pair of elements
3780 * in the original domain is only allowed to be equal to each other
3781 * on exactly one of the two pieces corresponding to the two elements.
3782 * The position in the list is used to break ties.
3783 * In particular, in the case of a minimum,
3784 * in the piece corresponding to a given element,
3785 * this element is allowed to be equal to any later element in the list,
3786 * but not to any earlier element in the list.
3787 */
3788static __isl_give isl_pw_aff *isl_pw_aff_list_opt(
3789 __isl_take isl_pw_aff_list *list, int max)
3790{
3791 int i, j;
3792 isl_bool has_nan;
3793 isl_size n;
3794 isl_space *space;
3795 isl_pw_aff *pa, *res;
3796
3797 n = isl_pw_aff_list_size(list);
3798 if (n < 0)
3799 goto error;
3800 if (n < 1)
3801 isl_die(isl_pw_aff_list_get_ctx(list), isl_error_invalid,
3802 "list should contain at least one element", goto error);
3803
3804 has_nan = isl_pw_aff_list_involves_nan(list);
3805 if (has_nan < 0)
3806 goto error;
3807 if (has_nan)
3808 return replace_list_by_nan(list, n);
3809
3810 pa = isl_pw_aff_list_get_at(list, index: 0);
3811 space = isl_pw_aff_get_space(pw: pa);
3812 isl_pw_aff_free(pw: pa);
3813 res = isl_pw_aff_empty(space);
3814
3815 for (i = 0; i < n; ++i) {
3816 pa = isl_pw_aff_list_get_at(list, index: i);
3817 for (j = 0; j < n; ++j) {
3818 isl_set *dom;
3819
3820 if (j == i)
3821 continue;
3822 if (max)
3823 dom = less(list, pos1: j, pos2: i);
3824 else
3825 dom = less(list, pos1: i, pos2: j);
3826
3827 pa = isl_pw_aff_intersect_domain(pw: pa, context: dom);
3828 }
3829 res = isl_pw_aff_add_disjoint(pw1: res, pw2: pa);
3830 }
3831
3832 isl_pw_aff_list_free(list);
3833 return res;
3834error:
3835 isl_pw_aff_list_free(list);
3836 return NULL;
3837}
3838
3839/* Return an isl_pw_aff that maps each element in the intersection of the
3840 * domains of the elements of list to the minimal corresponding affine
3841 * expression.
3842 */
3843__isl_give isl_pw_aff *isl_pw_aff_list_min(__isl_take isl_pw_aff_list *list)
3844{
3845 return isl_pw_aff_list_opt(list, max: 0);
3846}
3847
3848/* Return an isl_pw_aff that maps each element in the intersection of the
3849 * domains of the elements of list to the maximal corresponding affine
3850 * expression.
3851 */
3852__isl_give isl_pw_aff *isl_pw_aff_list_max(__isl_take isl_pw_aff_list *list)
3853{
3854 return isl_pw_aff_list_opt(list, max: 1);
3855}
3856
3857/* Mark the domains of "pwaff" as rational.
3858 */
3859__isl_give isl_pw_aff *isl_pw_aff_set_rational(__isl_take isl_pw_aff *pwaff)
3860{
3861 int i;
3862
3863 pwaff = isl_pw_aff_cow(pw: pwaff);
3864 if (!pwaff)
3865 return NULL;
3866 if (pwaff->n == 0)
3867 return pwaff;
3868
3869 for (i = 0; i < pwaff->n; ++i) {
3870 pwaff->p[i].set = isl_set_set_rational(set: pwaff->p[i].set);
3871 if (!pwaff->p[i].set)
3872 return isl_pw_aff_free(pw: pwaff);
3873 }
3874
3875 return pwaff;
3876}
3877
3878/* Mark the domains of the elements of "list" as rational.
3879 */
3880__isl_give isl_pw_aff_list *isl_pw_aff_list_set_rational(
3881 __isl_take isl_pw_aff_list *list)
3882{
3883 int i, n;
3884
3885 if (!list)
3886 return NULL;
3887 if (list->n == 0)
3888 return list;
3889
3890 n = list->n;
3891 for (i = 0; i < n; ++i) {
3892 isl_pw_aff *pa;
3893
3894 pa = isl_pw_aff_list_get_pw_aff(list, index: i);
3895 pa = isl_pw_aff_set_rational(pwaff: pa);
3896 list = isl_pw_aff_list_set_pw_aff(list, index: i, el: pa);
3897 }
3898
3899 return list;
3900}
3901
3902/* Do the parameters of "aff" match those of "space"?
3903 */
3904isl_bool isl_aff_matching_params(__isl_keep isl_aff *aff,
3905 __isl_keep isl_space *space)
3906{
3907 isl_space *aff_space;
3908 isl_bool match;
3909
3910 if (!aff || !space)
3911 return isl_bool_error;
3912
3913 aff_space = isl_aff_get_domain_space(aff);
3914
3915 match = isl_space_has_equal_params(space1: space, space2: aff_space);
3916
3917 isl_space_free(space: aff_space);
3918 return match;
3919}
3920
3921/* Check that the domain space of "aff" matches "space".
3922 */
3923isl_stat isl_aff_check_match_domain_space(__isl_keep isl_aff *aff,
3924 __isl_keep isl_space *space)
3925{
3926 isl_space *aff_space;
3927 isl_bool match;
3928
3929 if (!aff || !space)
3930 return isl_stat_error;
3931
3932 aff_space = isl_aff_get_domain_space(aff);
3933
3934 match = isl_space_has_equal_params(space1: space, space2: aff_space);
3935 if (match < 0)
3936 goto error;
3937 if (!match)
3938 isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
3939 "parameters don't match", goto error);
3940 match = isl_space_tuple_is_equal(space1: space, type1: isl_dim_in,
3941 space2: aff_space, type2: isl_dim_set);
3942 if (match < 0)
3943 goto error;
3944 if (!match)
3945 isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
3946 "domains don't match", goto error);
3947 isl_space_free(space: aff_space);
3948 return isl_stat_ok;
3949error:
3950 isl_space_free(space: aff_space);
3951 return isl_stat_error;
3952}
3953
3954/* Return the shared (universe) domain of the elements of "ma".
3955 *
3956 * Since an isl_multi_aff (and an isl_aff) is always total,
3957 * the domain is always the universe set in its domain space.
3958 * This is a helper function for use in the generic isl_multi_*_bind.
3959 */
3960static __isl_give isl_basic_set *isl_multi_aff_domain(
3961 __isl_take isl_multi_aff *ma)
3962{
3963 isl_space *space;
3964
3965 space = isl_multi_aff_get_space(multi: ma);
3966 isl_multi_aff_free(multi: ma);
3967
3968 return isl_basic_set_universe(space: isl_space_domain(space));
3969}
3970
3971#undef BASE
3972#define BASE aff
3973
3974#include <isl_multi_no_explicit_domain.c>
3975#include <isl_multi_templ.c>
3976#include <isl_multi_un_op_templ.c>
3977#include <isl_multi_bin_val_templ.c>
3978#include <isl_multi_add_constant_templ.c>
3979#include <isl_multi_apply_set.c>
3980#include <isl_multi_arith_templ.c>
3981#include <isl_multi_bind_domain_templ.c>
3982#include <isl_multi_cmp.c>
3983#include <isl_multi_dim_id_templ.c>
3984#include <isl_multi_dims.c>
3985#include <isl_multi_floor.c>
3986#include <isl_multi_from_base_templ.c>
3987#include <isl_multi_identity_templ.c>
3988#include <isl_multi_insert_domain_templ.c>
3989#include <isl_multi_locals_templ.c>
3990#include <isl_multi_move_dims_templ.c>
3991#include <isl_multi_nan_templ.c>
3992#include <isl_multi_product_templ.c>
3993#include <isl_multi_splice_templ.c>
3994#include <isl_multi_tuple_id_templ.c>
3995#include <isl_multi_unbind_params_templ.c>
3996#include <isl_multi_zero_templ.c>
3997
3998#undef DOMBASE
3999#define DOMBASE set
4000#include <isl_multi_gist.c>
4001
4002#undef DOMBASE
4003#define DOMBASE basic_set
4004#include <isl_multi_bind_templ.c>
4005
4006/* Construct an isl_multi_aff living in "space" that corresponds
4007 * to the affine transformation matrix "mat".
4008 */
4009__isl_give isl_multi_aff *isl_multi_aff_from_aff_mat(
4010 __isl_take isl_space *space, __isl_take isl_mat *mat)
4011{
4012 isl_ctx *ctx;
4013 isl_local_space *ls = NULL;
4014 isl_multi_aff *ma = NULL;
4015 isl_size n_row, n_col, n_out, total;
4016 int i;
4017
4018 if (!space || !mat)
4019 goto error;
4020
4021 ctx = isl_mat_get_ctx(mat);
4022
4023 n_row = isl_mat_rows(mat);
4024 n_col = isl_mat_cols(mat);
4025 n_out = isl_space_dim(space, type: isl_dim_out);
4026 total = isl_space_dim(space, type: isl_dim_all);
4027 if (n_row < 0 || n_col < 0 || n_out < 0 || total < 0)
4028 goto error;
4029 if (n_row < 1)
4030 isl_die(ctx, isl_error_invalid,
4031 "insufficient number of rows", goto error);
4032 if (n_col < 1)
4033 isl_die(ctx, isl_error_invalid,
4034 "insufficient number of columns", goto error);
4035 if (1 + n_out != n_row || 2 + total != n_row + n_col)
4036 isl_die(ctx, isl_error_invalid,
4037 "dimension mismatch", goto error);
4038
4039 ma = isl_multi_aff_zero(space: isl_space_copy(space));
4040 space = isl_space_domain(space);
4041 ls = isl_local_space_from_space(space: isl_space_copy(space));
4042
4043 for (i = 0; i < n_row - 1; ++i) {
4044 isl_vec *v;
4045 isl_aff *aff;
4046
4047 v = isl_vec_alloc(ctx, size: 1 + n_col);
4048 if (!v)
4049 goto error;
4050 isl_int_set(v->el[0], mat->row[0][0]);
4051 isl_seq_cpy(dst: v->el + 1, src: mat->row[1 + i], len: n_col);
4052 v = isl_vec_normalize(vec: v);
4053 aff = isl_aff_alloc_vec_validated(ls: isl_local_space_copy(ls), v);
4054 ma = isl_multi_aff_set_aff(multi: ma, pos: i, el: aff);
4055 }
4056
4057 isl_space_free(space);
4058 isl_local_space_free(ls);
4059 isl_mat_free(mat);
4060 return ma;
4061error:
4062 isl_space_free(space);
4063 isl_local_space_free(ls);
4064 isl_mat_free(mat);
4065 isl_multi_aff_free(multi: ma);
4066 return NULL;
4067}
4068
4069/* Return the constant terms of the affine expressions of "ma".
4070 */
4071__isl_give isl_multi_val *isl_multi_aff_get_constant_multi_val(
4072 __isl_keep isl_multi_aff *ma)
4073{
4074 int i;
4075 isl_size n;
4076 isl_space *space;
4077 isl_multi_val *mv;
4078
4079 n = isl_multi_aff_size(multi: ma);
4080 if (n < 0)
4081 return NULL;
4082 space = isl_space_range(space: isl_multi_aff_get_space(multi: ma));
4083 space = isl_space_drop_all_params(space);
4084 mv = isl_multi_val_zero(space);
4085
4086 for (i = 0; i < n; ++i) {
4087 isl_aff *aff;
4088 isl_val *val;
4089
4090 aff = isl_multi_aff_get_at(multi: ma, pos: i);
4091 val = isl_aff_get_constant_val(aff);
4092 isl_aff_free(aff);
4093 mv = isl_multi_val_set_at(multi: mv, pos: i, el: val);
4094 }
4095
4096 return mv;
4097}
4098
4099/* Remove any internal structure of the domain of "ma".
4100 * If there is any such internal structure in the input,
4101 * then the name of the corresponding space is also removed.
4102 */
4103__isl_give isl_multi_aff *isl_multi_aff_flatten_domain(
4104 __isl_take isl_multi_aff *ma)
4105{
4106 isl_space *space;
4107
4108 if (!ma)
4109 return NULL;
4110
4111 if (!ma->space->nested[0])
4112 return ma;
4113
4114 space = isl_multi_aff_get_space(multi: ma);
4115 space = isl_space_flatten_domain(space);
4116 ma = isl_multi_aff_reset_space(multi: ma, space);
4117
4118 return ma;
4119}
4120
4121/* Given a map space, return an isl_multi_aff that maps a wrapped copy
4122 * of the space to its domain.
4123 */
4124__isl_give isl_multi_aff *isl_multi_aff_domain_map(__isl_take isl_space *space)
4125{
4126 int i;
4127 isl_size n_in;
4128 isl_local_space *ls;
4129 isl_multi_aff *ma;
4130
4131 if (!space)
4132 return NULL;
4133 if (!isl_space_is_map(space))
4134 isl_die(isl_space_get_ctx(space), isl_error_invalid,
4135 "not a map space", goto error);
4136
4137 n_in = isl_space_dim(space, type: isl_dim_in);
4138 if (n_in < 0)
4139 goto error;
4140 space = isl_space_domain_map(space);
4141
4142 ma = isl_multi_aff_alloc(space: isl_space_copy(space));
4143 if (n_in == 0) {
4144 isl_space_free(space);
4145 return ma;
4146 }
4147
4148 space = isl_space_domain(space);
4149 ls = isl_local_space_from_space(space);
4150 for (i = 0; i < n_in; ++i) {
4151 isl_aff *aff;
4152
4153 aff = isl_aff_var_on_domain(ls: isl_local_space_copy(ls),
4154 type: isl_dim_set, pos: i);
4155 ma = isl_multi_aff_set_aff(multi: ma, pos: i, el: aff);
4156 }
4157 isl_local_space_free(ls);
4158 return ma;
4159error:
4160 isl_space_free(space);
4161 return NULL;
4162}
4163
4164/* This function performs the same operation as isl_multi_aff_domain_map,
4165 * but is considered as a function on an isl_space when exported.
4166 */
4167__isl_give isl_multi_aff *isl_space_domain_map_multi_aff(
4168 __isl_take isl_space *space)
4169{
4170 return isl_multi_aff_domain_map(space);
4171}
4172
4173/* Given a map space, return an isl_multi_aff that maps a wrapped copy
4174 * of the space to its range.
4175 */
4176__isl_give isl_multi_aff *isl_multi_aff_range_map(__isl_take isl_space *space)
4177{
4178 int i;
4179 isl_size n_in, n_out;
4180 isl_local_space *ls;
4181 isl_multi_aff *ma;
4182
4183 if (!space)
4184 return NULL;
4185 if (!isl_space_is_map(space))
4186 isl_die(isl_space_get_ctx(space), isl_error_invalid,
4187 "not a map space", goto error);
4188
4189 n_in = isl_space_dim(space, type: isl_dim_in);
4190 n_out = isl_space_dim(space, type: isl_dim_out);
4191 if (n_in < 0 || n_out < 0)
4192 goto error;
4193 space = isl_space_range_map(space);
4194
4195 ma = isl_multi_aff_alloc(space: isl_space_copy(space));
4196 if (n_out == 0) {
4197 isl_space_free(space);
4198 return ma;
4199 }
4200
4201 space = isl_space_domain(space);
4202 ls = isl_local_space_from_space(space);
4203 for (i = 0; i < n_out; ++i) {
4204 isl_aff *aff;
4205
4206 aff = isl_aff_var_on_domain(ls: isl_local_space_copy(ls),
4207 type: isl_dim_set, pos: n_in + i);
4208 ma = isl_multi_aff_set_aff(multi: ma, pos: i, el: aff);
4209 }
4210 isl_local_space_free(ls);
4211 return ma;
4212error:
4213 isl_space_free(space);
4214 return NULL;
4215}
4216
4217/* This function performs the same operation as isl_multi_aff_range_map,
4218 * but is considered as a function on an isl_space when exported.
4219 */
4220__isl_give isl_multi_aff *isl_space_range_map_multi_aff(
4221 __isl_take isl_space *space)
4222{
4223 return isl_multi_aff_range_map(space);
4224}
4225
4226/* Given a map space, return an isl_pw_multi_aff that maps a wrapped copy
4227 * of the space to its domain.
4228 */
4229__isl_give isl_pw_multi_aff *isl_pw_multi_aff_domain_map(
4230 __isl_take isl_space *space)
4231{
4232 return isl_pw_multi_aff_from_multi_aff(ma: isl_multi_aff_domain_map(space));
4233}
4234
4235/* This function performs the same operation as isl_pw_multi_aff_domain_map,
4236 * but is considered as a function on an isl_space when exported.
4237 */
4238__isl_give isl_pw_multi_aff *isl_space_domain_map_pw_multi_aff(
4239 __isl_take isl_space *space)
4240{
4241 return isl_pw_multi_aff_domain_map(space);
4242}
4243
4244/* Given a map space, return an isl_pw_multi_aff that maps a wrapped copy
4245 * of the space to its range.
4246 */
4247__isl_give isl_pw_multi_aff *isl_pw_multi_aff_range_map(
4248 __isl_take isl_space *space)
4249{
4250 return isl_pw_multi_aff_from_multi_aff(ma: isl_multi_aff_range_map(space));
4251}
4252
4253/* This function performs the same operation as isl_pw_multi_aff_range_map,
4254 * but is considered as a function on an isl_space when exported.
4255 */
4256__isl_give isl_pw_multi_aff *isl_space_range_map_pw_multi_aff(
4257 __isl_take isl_space *space)
4258{
4259 return isl_pw_multi_aff_range_map(space);
4260}
4261
4262/* Given the space of a set and a range of set dimensions,
4263 * construct an isl_multi_aff that projects out those dimensions.
4264 */
4265__isl_give isl_multi_aff *isl_multi_aff_project_out_map(
4266 __isl_take isl_space *space, enum isl_dim_type type,
4267 unsigned first, unsigned n)
4268{
4269 int i;
4270 isl_size dim;
4271 isl_local_space *ls;
4272 isl_multi_aff *ma;
4273
4274 if (!space)
4275 return NULL;
4276 if (!isl_space_is_set(space))
4277 isl_die(isl_space_get_ctx(space), isl_error_unsupported,
4278 "expecting set space", goto error);
4279 if (type != isl_dim_set)
4280 isl_die(isl_space_get_ctx(space), isl_error_invalid,
4281 "only set dimensions can be projected out", goto error);
4282 if (isl_space_check_range(space, type, first, n) < 0)
4283 goto error;
4284
4285 dim = isl_space_dim(space, type: isl_dim_set);
4286 if (dim < 0)
4287 goto error;
4288
4289 space = isl_space_from_domain(space);
4290 space = isl_space_add_dims(space, type: isl_dim_out, n: dim - n);
4291
4292 if (dim == n)
4293 return isl_multi_aff_alloc(space);
4294
4295 ma = isl_multi_aff_alloc(space: isl_space_copy(space));
4296 space = isl_space_domain(space);
4297 ls = isl_local_space_from_space(space);
4298
4299 for (i = 0; i < first; ++i) {
4300 isl_aff *aff;
4301
4302 aff = isl_aff_var_on_domain(ls: isl_local_space_copy(ls),
4303 type: isl_dim_set, pos: i);
4304 ma = isl_multi_aff_set_aff(multi: ma, pos: i, el: aff);
4305 }
4306
4307 for (i = 0; i < dim - (first + n); ++i) {
4308 isl_aff *aff;
4309
4310 aff = isl_aff_var_on_domain(ls: isl_local_space_copy(ls),
4311 type: isl_dim_set, pos: first + n + i);
4312 ma = isl_multi_aff_set_aff(multi: ma, pos: first + i, el: aff);
4313 }
4314
4315 isl_local_space_free(ls);
4316 return ma;
4317error:
4318 isl_space_free(space);
4319 return NULL;
4320}
4321
4322/* Given the space of a set and a range of set dimensions,
4323 * construct an isl_pw_multi_aff that projects out those dimensions.
4324 */
4325__isl_give isl_pw_multi_aff *isl_pw_multi_aff_project_out_map(
4326 __isl_take isl_space *space, enum isl_dim_type type,
4327 unsigned first, unsigned n)
4328{
4329 isl_multi_aff *ma;
4330
4331 ma = isl_multi_aff_project_out_map(space, type, first, n);
4332 return isl_pw_multi_aff_from_multi_aff(ma);
4333}
4334
4335/* This function performs the same operation as isl_pw_multi_aff_from_multi_aff,
4336 * but is considered as a function on an isl_multi_aff when exported.
4337 */
4338__isl_give isl_pw_multi_aff *isl_multi_aff_to_pw_multi_aff(
4339 __isl_take isl_multi_aff *ma)
4340{
4341 return isl_pw_multi_aff_from_multi_aff(ma);
4342}
4343
4344/* Create a piecewise multi-affine expression in the given space that maps each
4345 * input dimension to the corresponding output dimension.
4346 */
4347__isl_give isl_pw_multi_aff *isl_pw_multi_aff_identity(
4348 __isl_take isl_space *space)
4349{
4350 return isl_pw_multi_aff_from_multi_aff(ma: isl_multi_aff_identity(space));
4351}
4352
4353/* Create a piecewise multi expression that maps elements in the given space
4354 * to themselves.
4355 */
4356__isl_give isl_pw_multi_aff *isl_pw_multi_aff_identity_on_domain_space(
4357 __isl_take isl_space *space)
4358{
4359 isl_multi_aff *ma;
4360
4361 ma = isl_multi_aff_identity_on_domain_space(space);
4362 return isl_pw_multi_aff_from_multi_aff(ma);
4363}
4364
4365/* This function performs the same operation as
4366 * isl_pw_multi_aff_identity_on_domain_space,
4367 * but is considered as a function on an isl_space when exported.
4368 */
4369__isl_give isl_pw_multi_aff *isl_space_identity_pw_multi_aff_on_domain(
4370 __isl_take isl_space *space)
4371{
4372 return isl_pw_multi_aff_identity_on_domain_space(space);
4373}
4374
4375/* Exploit the equalities in "eq" to simplify the affine expressions.
4376 */
4377static __isl_give isl_multi_aff *isl_multi_aff_substitute_equalities(
4378 __isl_take isl_multi_aff *maff, __isl_take isl_basic_set *eq)
4379{
4380 isl_size n;
4381 int i;
4382
4383 n = isl_multi_aff_size(multi: maff);
4384 if (n < 0 || !eq)
4385 goto error;
4386
4387 for (i = 0; i < n; ++i) {
4388 isl_aff *aff;
4389
4390 aff = isl_multi_aff_take_at(multi: maff, pos: i);
4391 aff = isl_aff_substitute_equalities(aff,
4392 eq: isl_basic_set_copy(bset: eq));
4393 maff = isl_multi_aff_restore_at(multi: maff, pos: i, el: aff);
4394 }
4395
4396 isl_basic_set_free(bset: eq);
4397 return maff;
4398error:
4399 isl_basic_set_free(bset: eq);
4400 isl_multi_aff_free(multi: maff);
4401 return NULL;
4402}
4403
4404__isl_give isl_multi_aff *isl_multi_aff_scale(__isl_take isl_multi_aff *maff,
4405 isl_int f)
4406{
4407 isl_size n;
4408 int i;
4409
4410 n = isl_multi_aff_size(multi: maff);
4411 if (n < 0)
4412 return isl_multi_aff_free(multi: maff);
4413
4414 for (i = 0; i < n; ++i) {
4415 isl_aff *aff;
4416
4417 aff = isl_multi_aff_take_at(multi: maff, pos: i);
4418 aff = isl_aff_scale(aff, f);
4419 maff = isl_multi_aff_restore_at(multi: maff, pos: i, el: aff);
4420 }
4421
4422 return maff;
4423}
4424
4425__isl_give isl_multi_aff *isl_multi_aff_add_on_domain(__isl_keep isl_set *dom,
4426 __isl_take isl_multi_aff *maff1, __isl_take isl_multi_aff *maff2)
4427{
4428 maff1 = isl_multi_aff_add(multi1: maff1, multi2: maff2);
4429 maff1 = isl_multi_aff_gist(multi: maff1, context: isl_set_copy(set: dom));
4430 return maff1;
4431}
4432
4433isl_bool isl_multi_aff_is_empty(__isl_keep isl_multi_aff *maff)
4434{
4435 if (!maff)
4436 return isl_bool_error;
4437
4438 return isl_bool_false;
4439}
4440
4441/* Return the set of domain elements where "ma1" is lexicographically
4442 * smaller than or equal to "ma2".
4443 */
4444__isl_give isl_set *isl_multi_aff_lex_le_set(__isl_take isl_multi_aff *ma1,
4445 __isl_take isl_multi_aff *ma2)
4446{
4447 return isl_multi_aff_lex_ge_set(ma1: ma2, ma2: ma1);
4448}
4449
4450/* Return the set of domain elements where "ma1" is lexicographically
4451 * smaller than "ma2".
4452 */
4453__isl_give isl_set *isl_multi_aff_lex_lt_set(__isl_take isl_multi_aff *ma1,
4454 __isl_take isl_multi_aff *ma2)
4455{
4456 return isl_multi_aff_lex_gt_set(ma1: ma2, ma2: ma1);
4457}
4458
4459/* Return the set of domain elements where "ma1" is lexicographically
4460 * greater than to "ma2". If "equal" is set, then include the domain
4461 * elements where they are equal.
4462 * Do this for the case where there are no entries.
4463 * In this case, "ma1" cannot be greater than "ma2",
4464 * but it is (greater than or) equal to "ma2".
4465 */
4466static __isl_give isl_set *isl_multi_aff_lex_gte_set_0d(
4467 __isl_take isl_multi_aff *ma1, __isl_take isl_multi_aff *ma2, int equal)
4468{
4469 isl_space *space;
4470
4471 space = isl_multi_aff_get_domain_space(multi: ma1);
4472
4473 isl_multi_aff_free(multi: ma1);
4474 isl_multi_aff_free(multi: ma2);
4475
4476 if (equal)
4477 return isl_set_universe(space);
4478 else
4479 return isl_set_empty(space);
4480}
4481
4482/* Return the set where entry "i" of "ma1" and "ma2"
4483 * satisfy the relation prescribed by "cmp".
4484 */
4485static __isl_give isl_set *isl_multi_aff_order_at(__isl_keep isl_multi_aff *ma1,
4486 __isl_keep isl_multi_aff *ma2, int i,
4487 __isl_give isl_set *(*cmp)(__isl_take isl_aff *aff1,
4488 __isl_take isl_aff *aff2))
4489{
4490 isl_aff *aff1, *aff2;
4491
4492 aff1 = isl_multi_aff_get_at(multi: ma1, pos: i);
4493 aff2 = isl_multi_aff_get_at(multi: ma2, pos: i);
4494 return cmp(aff1, aff2);
4495}
4496
4497/* Return the set of domain elements where "ma1" is lexicographically
4498 * greater than to "ma2". If "equal" is set, then include the domain
4499 * elements where they are equal.
4500 *
4501 * In particular, for all but the final entry,
4502 * include the set of elements where this entry is strictly greater in "ma1"
4503 * and all previous entries are equal.
4504 * The final entry is also allowed to be equal in the two functions
4505 * if "equal" is set.
4506 *
4507 * The case where there are no entries is handled separately.
4508 */
4509static __isl_give isl_set *isl_multi_aff_lex_gte_set(
4510 __isl_take isl_multi_aff *ma1, __isl_take isl_multi_aff *ma2, int equal)
4511{
4512 int i;
4513 isl_size n;
4514 isl_space *space;
4515 isl_set *res;
4516 isl_set *equal_set;
4517 isl_set *gte;
4518
4519 if (isl_multi_aff_check_equal_space(obj1: ma1, obj2: ma2) < 0)
4520 goto error;
4521 n = isl_multi_aff_size(multi: ma1);
4522 if (n < 0)
4523 goto error;
4524 if (n == 0)
4525 return isl_multi_aff_lex_gte_set_0d(ma1, ma2, equal);
4526
4527 space = isl_multi_aff_get_domain_space(multi: ma1);
4528 res = isl_set_empty(space: isl_space_copy(space));
4529 equal_set = isl_set_universe(space);
4530
4531 for (i = 0; i + 1 < n; ++i) {
4532 isl_bool empty;
4533 isl_set *gt, *eq;
4534
4535 gt = isl_multi_aff_order_at(ma1, ma2, i, cmp: &isl_aff_gt_set);
4536 gt = isl_set_intersect(set1: gt, set2: isl_set_copy(set: equal_set));
4537 res = isl_set_union(set1: res, set2: gt);
4538 eq = isl_multi_aff_order_at(ma1, ma2, i, cmp: &isl_aff_eq_set);
4539 equal_set = isl_set_intersect(set1: equal_set, set2: eq);
4540
4541 empty = isl_set_is_empty(set: equal_set);
4542 if (empty >= 0 && empty)
4543 break;
4544 }
4545
4546 if (equal)
4547 gte = isl_multi_aff_order_at(ma1, ma2, i: n - 1, cmp: &isl_aff_ge_set);
4548 else
4549 gte = isl_multi_aff_order_at(ma1, ma2, i: n - 1, cmp: &isl_aff_gt_set);
4550 isl_multi_aff_free(multi: ma1);
4551 isl_multi_aff_free(multi: ma2);
4552
4553 gte = isl_set_intersect(set1: gte, set2: equal_set);
4554 return isl_set_union(set1: res, set2: gte);
4555error:
4556 isl_multi_aff_free(multi: ma1);
4557 isl_multi_aff_free(multi: ma2);
4558 return NULL;
4559}
4560
4561/* Return the set of domain elements where "ma1" is lexicographically
4562 * greater than or equal to "ma2".
4563 */
4564__isl_give isl_set *isl_multi_aff_lex_ge_set(__isl_take isl_multi_aff *ma1,
4565 __isl_take isl_multi_aff *ma2)
4566{
4567 return isl_multi_aff_lex_gte_set(ma1, ma2, equal: 1);
4568}
4569
4570/* Return the set of domain elements where "ma1" is lexicographically
4571 * greater than "ma2".
4572 */
4573__isl_give isl_set *isl_multi_aff_lex_gt_set(__isl_take isl_multi_aff *ma1,
4574 __isl_take isl_multi_aff *ma2)
4575{
4576 return isl_multi_aff_lex_gte_set(ma1, ma2, equal: 0);
4577}
4578
4579#define isl_multi_aff_zero_in_space isl_multi_aff_zero
4580
4581#undef PW
4582#define PW isl_pw_multi_aff
4583#undef BASE
4584#define BASE multi_aff
4585#undef EL_IS_ZERO
4586#define EL_IS_ZERO is_empty
4587#undef ZERO
4588#define ZERO empty
4589#undef IS_ZERO
4590#define IS_ZERO is_empty
4591#undef FIELD
4592#define FIELD maff
4593#undef DEFAULT_IS_ZERO
4594#define DEFAULT_IS_ZERO 0
4595
4596#include <isl_pw_templ.c>
4597#include <isl_pw_un_op_templ.c>
4598#include <isl_pw_add_constant_multi_val_templ.c>
4599#include <isl_pw_add_constant_val_templ.c>
4600#include <isl_pw_add_disjoint_templ.c>
4601#include <isl_pw_bind_domain_templ.c>
4602#include <isl_pw_fix_templ.c>
4603#include <isl_pw_from_range_templ.c>
4604#include <isl_pw_insert_dims_templ.c>
4605#include <isl_pw_insert_domain_templ.c>
4606#include <isl_pw_locals_templ.c>
4607#include <isl_pw_move_dims_templ.c>
4608#include <isl_pw_neg_templ.c>
4609#include <isl_pw_pullback_templ.c>
4610#include <isl_pw_range_tuple_id_templ.c>
4611#include <isl_pw_union_opt.c>
4612
4613#undef BASE
4614#define BASE pw_multi_aff
4615
4616#include <isl_union_multi.c>
4617#include "isl_union_locals_templ.c"
4618#include <isl_union_neg.c>
4619#include <isl_union_sub_templ.c>
4620
4621#undef BASE
4622#define BASE multi_aff
4623
4624#include <isl_union_pw_templ.c>
4625
4626/* Generic function for extracting a factor from a product "pma".
4627 * "check_space" checks that the space is that of the right kind of product.
4628 * "space_factor" extracts the factor from the space.
4629 * "multi_aff_factor" extracts the factor from the constituent functions.
4630 */
4631static __isl_give isl_pw_multi_aff *pw_multi_aff_factor(
4632 __isl_take isl_pw_multi_aff *pma,
4633 isl_stat (*check_space)(__isl_keep isl_pw_multi_aff *pma),
4634 __isl_give isl_space *(*space_factor)(__isl_take isl_space *space),
4635 __isl_give isl_multi_aff *(*multi_aff_factor)(
4636 __isl_take isl_multi_aff *ma))
4637{
4638 int i;
4639 isl_space *space;
4640
4641 if (check_space(pma) < 0)
4642 return isl_pw_multi_aff_free(pw: pma);
4643
4644 space = isl_pw_multi_aff_take_space(pw: pma);
4645 space = space_factor(space);
4646
4647 for (i = 0; pma && i < pma->n; ++i) {
4648 isl_multi_aff *ma;
4649
4650 ma = isl_pw_multi_aff_take_base_at(pw: pma, pos: i);
4651 ma = multi_aff_factor(ma);
4652 pma = isl_pw_multi_aff_restore_base_at(pw: pma, pos: i, el: ma);
4653 }
4654
4655 pma = isl_pw_multi_aff_restore_space(pw: pma, space);
4656
4657 return pma;
4658}
4659
4660/* Is the range of "pma" a wrapped relation?
4661 */
4662static isl_bool isl_pw_multi_aff_range_is_wrapping(
4663 __isl_keep isl_pw_multi_aff *pma)
4664{
4665 return isl_space_range_is_wrapping(space: isl_pw_multi_aff_peek_space(pw: pma));
4666}
4667
4668/* Check that the range of "pma" is a product.
4669 */
4670static isl_stat pw_multi_aff_check_range_product(
4671 __isl_keep isl_pw_multi_aff *pma)
4672{
4673 isl_bool wraps;
4674
4675 wraps = isl_pw_multi_aff_range_is_wrapping(pma);
4676 if (wraps < 0)
4677 return isl_stat_error;
4678 if (!wraps)
4679 isl_die(isl_pw_multi_aff_get_ctx(pma), isl_error_invalid,
4680 "range is not a product", return isl_stat_error);
4681 return isl_stat_ok;
4682}
4683
4684/* Given a function A -> [B -> C], extract the function A -> B.
4685 */
4686__isl_give isl_pw_multi_aff *isl_pw_multi_aff_range_factor_domain(
4687 __isl_take isl_pw_multi_aff *pma)
4688{
4689 return pw_multi_aff_factor(pma, check_space: &pw_multi_aff_check_range_product,
4690 space_factor: &isl_space_range_factor_domain,
4691 multi_aff_factor: &isl_multi_aff_range_factor_domain);
4692}
4693
4694/* Given a function A -> [B -> C], extract the function A -> C.
4695 */
4696__isl_give isl_pw_multi_aff *isl_pw_multi_aff_range_factor_range(
4697 __isl_take isl_pw_multi_aff *pma)
4698{
4699 return pw_multi_aff_factor(pma, check_space: &pw_multi_aff_check_range_product,
4700 space_factor: &isl_space_range_factor_range,
4701 multi_aff_factor: &isl_multi_aff_range_factor_range);
4702}
4703
4704/* Given two piecewise multi affine expressions, return a piecewise
4705 * multi-affine expression defined on the union of the definition domains
4706 * of the inputs that is equal to the lexicographic maximum of the two
4707 * inputs on each cell. If only one of the two inputs is defined on
4708 * a given cell, then it is considered to be the maximum.
4709 */
4710__isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_lexmax(
4711 __isl_take isl_pw_multi_aff *pma1,
4712 __isl_take isl_pw_multi_aff *pma2)
4713{
4714 isl_pw_multi_aff_align_params_bin(obj1: &pma1, obj2: &pma2);
4715 return isl_pw_multi_aff_union_opt_cmp(pw1: pma1, pw2: pma2,
4716 cmp: &isl_multi_aff_lex_ge_set);
4717}
4718
4719/* Given two piecewise multi affine expressions, return a piecewise
4720 * multi-affine expression defined on the union of the definition domains
4721 * of the inputs that is equal to the lexicographic minimum of the two
4722 * inputs on each cell. If only one of the two inputs is defined on
4723 * a given cell, then it is considered to be the minimum.
4724 */
4725__isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_lexmin(
4726 __isl_take isl_pw_multi_aff *pma1,
4727 __isl_take isl_pw_multi_aff *pma2)
4728{
4729 isl_pw_multi_aff_align_params_bin(obj1: &pma1, obj2: &pma2);
4730 return isl_pw_multi_aff_union_opt_cmp(pw1: pma1, pw2: pma2,
4731 cmp: &isl_multi_aff_lex_le_set);
4732}
4733
4734__isl_give isl_pw_multi_aff *isl_pw_multi_aff_add(
4735 __isl_take isl_pw_multi_aff *pma1, __isl_take isl_pw_multi_aff *pma2)
4736{
4737 isl_pw_multi_aff_align_params_bin(obj1: &pma1, obj2: &pma2);
4738 return isl_pw_multi_aff_on_shared_domain(pw1: pma1, pw2: pma2,
4739 fn: &isl_multi_aff_add);
4740}
4741
4742/* Subtract "pma2" from "pma1" and return the result.
4743 */
4744__isl_give isl_pw_multi_aff *isl_pw_multi_aff_sub(
4745 __isl_take isl_pw_multi_aff *pma1, __isl_take isl_pw_multi_aff *pma2)
4746{
4747 isl_pw_multi_aff_align_params_bin(obj1: &pma1, obj2: &pma2);
4748 return isl_pw_multi_aff_on_shared_domain(pw1: pma1, pw2: pma2,
4749 fn: &isl_multi_aff_sub);
4750}
4751
4752/* Given two piecewise multi-affine expressions A -> B and C -> D,
4753 * construct a piecewise multi-affine expression [A -> C] -> [B -> D].
4754 */
4755__isl_give isl_pw_multi_aff *isl_pw_multi_aff_product(
4756 __isl_take isl_pw_multi_aff *pma1, __isl_take isl_pw_multi_aff *pma2)
4757{
4758 int i, j, n;
4759 isl_space *space;
4760 isl_pw_multi_aff *res;
4761
4762 if (isl_pw_multi_aff_align_params_bin(obj1: &pma1, obj2: &pma2) < 0)
4763 goto error;
4764
4765 n = pma1->n * pma2->n;
4766 space = isl_space_product(left: isl_space_copy(space: pma1->dim),
4767 right: isl_space_copy(space: pma2->dim));
4768 res = isl_pw_multi_aff_alloc_size(space, n);
4769
4770 for (i = 0; i < pma1->n; ++i) {
4771 for (j = 0; j < pma2->n; ++j) {
4772 isl_set *domain;
4773 isl_multi_aff *ma;
4774
4775 domain = isl_set_product(set1: isl_set_copy(set: pma1->p[i].set),
4776 set2: isl_set_copy(set: pma2->p[j].set));
4777 ma = isl_multi_aff_product(
4778 multi1: isl_multi_aff_copy(multi: pma1->p[i].maff),
4779 multi2: isl_multi_aff_copy(multi: pma2->p[j].maff));
4780 res = isl_pw_multi_aff_add_piece(pw: res, set: domain, el: ma);
4781 }
4782 }
4783
4784 isl_pw_multi_aff_free(pw: pma1);
4785 isl_pw_multi_aff_free(pw: pma2);
4786 return res;
4787error:
4788 isl_pw_multi_aff_free(pw: pma1);
4789 isl_pw_multi_aff_free(pw: pma2);
4790 return NULL;
4791}
4792
4793/* Subtract the initial "n" elements in "ma" with coefficients in "c" and
4794 * denominator "denom".
4795 * "denom" is allowed to be negative, in which case the actual denominator
4796 * is -denom and the expressions are added instead.
4797 */
4798static __isl_give isl_aff *subtract_initial(__isl_take isl_aff *aff,
4799 __isl_keep isl_multi_aff *ma, int n, isl_int *c, isl_int denom)
4800{
4801 int i, first;
4802 int sign;
4803 isl_int d;
4804
4805 first = isl_seq_first_non_zero(p: c, len: n);
4806 if (first == -1)
4807 return aff;
4808
4809 sign = isl_int_sgn(denom);
4810 isl_int_init(d);
4811 isl_int_abs(d, denom);
4812 for (i = first; i < n; ++i) {
4813 isl_aff *aff_i;
4814
4815 if (isl_int_is_zero(c[i]))
4816 continue;
4817 aff_i = isl_multi_aff_get_aff(multi: ma, pos: i);
4818 aff_i = isl_aff_scale(aff: aff_i, f: c[i]);
4819 aff_i = isl_aff_scale_down(aff: aff_i, f: d);
4820 if (sign >= 0)
4821 aff = isl_aff_sub(aff1: aff, aff2: aff_i);
4822 else
4823 aff = isl_aff_add(aff1: aff, aff2: aff_i);
4824 }
4825 isl_int_clear(d);
4826
4827 return aff;
4828}
4829
4830/* Extract an affine expression that expresses the output dimension "pos"
4831 * of "bmap" in terms of the parameters and input dimensions from
4832 * equality "eq".
4833 * Note that this expression may involve integer divisions defined
4834 * in terms of parameters and input dimensions.
4835 * The equality may also involve references to earlier (but not later)
4836 * output dimensions. These are replaced by the corresponding elements
4837 * in "ma".
4838 *
4839 * If the equality is of the form
4840 *
4841 * f(i) + h(j) + a x + g(i) = 0,
4842 *
4843 * with f(i) a linear combinations of the parameters and input dimensions,
4844 * g(i) a linear combination of integer divisions defined in terms of the same
4845 * and h(j) a linear combinations of earlier output dimensions,
4846 * then the affine expression is
4847 *
4848 * (-f(i) - g(i))/a - h(j)/a
4849 *
4850 * If the equality is of the form
4851 *
4852 * f(i) + h(j) - a x + g(i) = 0,
4853 *
4854 * then the affine expression is
4855 *
4856 * (f(i) + g(i))/a - h(j)/(-a)
4857 *
4858 *
4859 * If "div" refers to an integer division (i.e., it is smaller than
4860 * the number of integer divisions), then the equality constraint
4861 * does involve an integer division (the one at position "div") that
4862 * is defined in terms of output dimensions. However, this integer
4863 * division can be eliminated by exploiting a pair of constraints
4864 * x >= l and x <= l + n, with n smaller than the coefficient of "div"
4865 * in the equality constraint. "ineq" refers to inequality x >= l, i.e.,
4866 * -l + x >= 0.
4867 * In particular, let
4868 *
4869 * x = e(i) + m floor(...)
4870 *
4871 * with e(i) the expression derived above and floor(...) the integer
4872 * division involving output dimensions.
4873 * From
4874 *
4875 * l <= x <= l + n,
4876 *
4877 * we have
4878 *
4879 * 0 <= x - l <= n
4880 *
4881 * This means
4882 *
4883 * e(i) + m floor(...) - l = (e(i) + m floor(...) - l) mod m
4884 * = (e(i) - l) mod m
4885 *
4886 * Therefore,
4887 *
4888 * x - l = (e(i) - l) mod m
4889 *
4890 * or
4891 *
4892 * x = ((e(i) - l) mod m) + l
4893 *
4894 * The variable "shift" below contains the expression -l, which may
4895 * also involve a linear combination of earlier output dimensions.
4896 */
4897static __isl_give isl_aff *extract_aff_from_equality(
4898 __isl_keep isl_basic_map *bmap, int pos, int eq, int div, int ineq,
4899 __isl_keep isl_multi_aff *ma)
4900{
4901 unsigned o_out;
4902 isl_size n_div, n_out;
4903 isl_ctx *ctx;
4904 isl_local_space *ls;
4905 isl_aff *aff, *shift;
4906 isl_val *mod;
4907
4908 ctx = isl_basic_map_get_ctx(bmap);
4909 ls = isl_basic_map_get_local_space(bmap);
4910 ls = isl_local_space_domain(ls);
4911 aff = isl_aff_alloc(ls: isl_local_space_copy(ls));
4912 if (!aff)
4913 goto error;
4914 o_out = isl_basic_map_offset(bmap, type: isl_dim_out);
4915 n_out = isl_basic_map_dim(bmap, type: isl_dim_out);
4916 n_div = isl_basic_map_dim(bmap, type: isl_dim_div);
4917 if (n_out < 0 || n_div < 0)
4918 goto error;
4919 if (isl_int_is_neg(bmap->eq[eq][o_out + pos])) {
4920 isl_seq_cpy(dst: aff->v->el + 1, src: bmap->eq[eq], len: o_out);
4921 isl_seq_cpy(dst: aff->v->el + 1 + o_out,
4922 src: bmap->eq[eq] + o_out + n_out, len: n_div);
4923 } else {
4924 isl_seq_neg(dst: aff->v->el + 1, src: bmap->eq[eq], len: o_out);
4925 isl_seq_neg(dst: aff->v->el + 1 + o_out,
4926 src: bmap->eq[eq] + o_out + n_out, len: n_div);
4927 }
4928 if (div < n_div)
4929 isl_int_set_si(aff->v->el[1 + o_out + div], 0);
4930 isl_int_abs(aff->v->el[0], bmap->eq[eq][o_out + pos]);
4931 aff = subtract_initial(aff, ma, n: pos, c: bmap->eq[eq] + o_out,
4932 denom: bmap->eq[eq][o_out + pos]);
4933 if (div < n_div) {
4934 shift = isl_aff_alloc(ls: isl_local_space_copy(ls));
4935 if (!shift)
4936 goto error;
4937 isl_seq_cpy(dst: shift->v->el + 1, src: bmap->ineq[ineq], len: o_out);
4938 isl_seq_cpy(dst: shift->v->el + 1 + o_out,
4939 src: bmap->ineq[ineq] + o_out + n_out, len: n_div);
4940 isl_int_set_si(shift->v->el[0], 1);
4941 shift = subtract_initial(aff: shift, ma, n: pos,
4942 c: bmap->ineq[ineq] + o_out, denom: ctx->negone);
4943 aff = isl_aff_add(aff1: aff, aff2: isl_aff_copy(aff: shift));
4944 mod = isl_val_int_from_isl_int(ctx,
4945 n: bmap->eq[eq][o_out + n_out + div]);
4946 mod = isl_val_abs(v: mod);
4947 aff = isl_aff_mod_val(aff, m: mod);
4948 aff = isl_aff_sub(aff1: aff, aff2: shift);
4949 }
4950
4951 isl_local_space_free(ls);
4952 return aff;
4953error:
4954 isl_local_space_free(ls);
4955 isl_aff_free(aff);
4956 return NULL;
4957}
4958
4959/* Given a basic map with output dimensions defined
4960 * in terms of the parameters input dimensions and earlier
4961 * output dimensions using an equality (and possibly a pair on inequalities),
4962 * extract an isl_aff that expresses output dimension "pos" in terms
4963 * of the parameters and input dimensions.
4964 * Note that this expression may involve integer divisions defined
4965 * in terms of parameters and input dimensions.
4966 * "ma" contains the expressions corresponding to earlier output dimensions.
4967 *
4968 * This function shares some similarities with
4969 * isl_basic_map_has_defining_equality and isl_constraint_get_bound.
4970 */
4971static __isl_give isl_aff *extract_isl_aff_from_basic_map(
4972 __isl_keep isl_basic_map *bmap, int pos, __isl_keep isl_multi_aff *ma)
4973{
4974 int eq, div, ineq;
4975 isl_aff *aff;
4976
4977 if (!bmap)
4978 return NULL;
4979 eq = isl_basic_map_output_defining_equality(bmap, pos, div: &div, ineq: &ineq);
4980 if (eq >= bmap->n_eq)
4981 isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
4982 "unable to find suitable equality", return NULL);
4983 aff = extract_aff_from_equality(bmap, pos, eq, div, ineq, ma);
4984
4985 aff = isl_aff_remove_unused_divs(aff);
4986 return aff;
4987}
4988
4989/* Given a basic map where each output dimension is defined
4990 * in terms of the parameters and input dimensions using an equality,
4991 * extract an isl_multi_aff that expresses the output dimensions in terms
4992 * of the parameters and input dimensions.
4993 */
4994static __isl_give isl_multi_aff *extract_isl_multi_aff_from_basic_map(
4995 __isl_take isl_basic_map *bmap)
4996{
4997 int i;
4998 isl_size n_out;
4999 isl_multi_aff *ma;
5000
5001 if (!bmap)
5002 return NULL;
5003
5004 ma = isl_multi_aff_alloc(space: isl_basic_map_get_space(bmap));
5005 n_out = isl_basic_map_dim(bmap, type: isl_dim_out);
5006 if (n_out < 0)
5007 ma = isl_multi_aff_free(multi: ma);
5008
5009 for (i = 0; i < n_out; ++i) {
5010 isl_aff *aff;
5011
5012 aff = extract_isl_aff_from_basic_map(bmap, pos: i, ma);
5013 ma = isl_multi_aff_set_aff(multi: ma, pos: i, el: aff);
5014 }
5015
5016 isl_basic_map_free(bmap);
5017
5018 return ma;
5019}
5020
5021/* Given a basic set where each set dimension is defined
5022 * in terms of the parameters using an equality,
5023 * extract an isl_multi_aff that expresses the set dimensions in terms
5024 * of the parameters.
5025 */
5026__isl_give isl_multi_aff *isl_multi_aff_from_basic_set_equalities(
5027 __isl_take isl_basic_set *bset)
5028{
5029 return extract_isl_multi_aff_from_basic_map(bmap: bset);
5030}
5031
5032/* Create an isl_pw_multi_aff that is equivalent to
5033 * isl_map_intersect_domain(isl_map_from_basic_map(bmap), domain).
5034 * The given basic map is such that each output dimension is defined
5035 * in terms of the parameters and input dimensions using an equality.
5036 *
5037 * Since some applications expect the result of isl_pw_multi_aff_from_map
5038 * to only contain integer affine expressions, we compute the floor
5039 * of the expression before returning.
5040 *
5041 * Remove all constraints involving local variables without
5042 * an explicit representation (resulting in the removal of those
5043 * local variables) prior to the actual extraction to ensure
5044 * that the local spaces in which the resulting affine expressions
5045 * are created do not contain any unknown local variables.
5046 * Removing such constraints is safe because constraints involving
5047 * unknown local variables are not used to determine whether
5048 * a basic map is obviously single-valued.
5049 */
5050static __isl_give isl_pw_multi_aff *plain_pw_multi_aff_from_map(
5051 __isl_take isl_set *domain, __isl_take isl_basic_map *bmap)
5052{
5053 isl_multi_aff *ma;
5054
5055 bmap = isl_basic_map_drop_constraints_involving_unknown_divs(bmap);
5056 ma = extract_isl_multi_aff_from_basic_map(bmap);
5057 ma = isl_multi_aff_floor(multi: ma);
5058 return isl_pw_multi_aff_alloc(set: domain, el: ma);
5059}
5060
5061/* Try and create an isl_pw_multi_aff that is equivalent to the given isl_map.
5062 * This obviously only works if the input "map" is single-valued.
5063 * If so, we compute the lexicographic minimum of the image in the form
5064 * of an isl_pw_multi_aff. Since the image is unique, it is equal
5065 * to its lexicographic minimum.
5066 * If the input is not single-valued, we produce an error.
5067 */
5068static __isl_give isl_pw_multi_aff *pw_multi_aff_from_map_base(
5069 __isl_take isl_map *map)
5070{
5071 int i;
5072 int sv;
5073 isl_pw_multi_aff *pma;
5074
5075 sv = isl_map_is_single_valued(map);
5076 if (sv < 0)
5077 goto error;
5078 if (!sv)
5079 isl_die(isl_map_get_ctx(map), isl_error_invalid,
5080 "map is not single-valued", goto error);
5081 map = isl_map_make_disjoint(map);
5082 if (!map)
5083 return NULL;
5084
5085 pma = isl_pw_multi_aff_empty(space: isl_map_get_space(map));
5086
5087 for (i = 0; i < map->n; ++i) {
5088 isl_pw_multi_aff *pma_i;
5089 isl_basic_map *bmap;
5090 bmap = isl_basic_map_copy(bmap: map->p[i]);
5091 pma_i = isl_basic_map_lexmin_pw_multi_aff(bmap);
5092 pma = isl_pw_multi_aff_add_disjoint(pw1: pma, pw2: pma_i);
5093 }
5094
5095 isl_map_free(map);
5096 return pma;
5097error:
5098 isl_map_free(map);
5099 return NULL;
5100}
5101
5102/* Try and create an isl_pw_multi_aff that is equivalent to the given isl_map,
5103 * taking into account that the output dimension at position "d"
5104 * can be represented as
5105 *
5106 * x = floor((e(...) + c1) / m)
5107 *
5108 * given that constraint "i" is of the form
5109 *
5110 * e(...) + c1 - m x >= 0
5111 *
5112 *
5113 * Let "map" be of the form
5114 *
5115 * A -> B
5116 *
5117 * We construct a mapping
5118 *
5119 * A -> [A -> x = floor(...)]
5120 *
5121 * apply that to the map, obtaining
5122 *
5123 * [A -> x = floor(...)] -> B
5124 *
5125 * and equate dimension "d" to x.
5126 * We then compute a isl_pw_multi_aff representation of the resulting map
5127 * and plug in the mapping above.
5128 */
5129static __isl_give isl_pw_multi_aff *pw_multi_aff_from_map_div(
5130 __isl_take isl_map *map, __isl_take isl_basic_map *hull, int d, int i)
5131{
5132 isl_ctx *ctx;
5133 isl_space *space = NULL;
5134 isl_local_space *ls;
5135 isl_multi_aff *ma;
5136 isl_aff *aff;
5137 isl_vec *v;
5138 isl_map *insert;
5139 int offset;
5140 isl_size n;
5141 isl_size n_in;
5142 isl_pw_multi_aff *pma;
5143 isl_bool is_set;
5144
5145 is_set = isl_map_is_set(map);
5146 if (is_set < 0)
5147 goto error;
5148
5149 offset = isl_basic_map_offset(bmap: hull, type: isl_dim_out);
5150 ctx = isl_map_get_ctx(map);
5151 space = isl_space_domain(space: isl_map_get_space(map));
5152 n_in = isl_space_dim(space, type: isl_dim_set);
5153 n = isl_space_dim(space, type: isl_dim_all);
5154 if (n_in < 0 || n < 0)
5155 goto error;
5156
5157 v = isl_vec_alloc(ctx, size: 1 + 1 + n);
5158 if (v) {
5159 isl_int_neg(v->el[0], hull->ineq[i][offset + d]);
5160 isl_seq_cpy(dst: v->el + 1, src: hull->ineq[i], len: 1 + n);
5161 }
5162 isl_basic_map_free(bmap: hull);
5163
5164 ls = isl_local_space_from_space(space: isl_space_copy(space));
5165 aff = isl_aff_alloc_vec_validated(ls, v);
5166 aff = isl_aff_floor(aff);
5167 if (is_set) {
5168 isl_space_free(space);
5169 ma = isl_multi_aff_from_aff(el: aff);
5170 } else {
5171 ma = isl_multi_aff_identity(space: isl_space_map_from_set(space));
5172 ma = isl_multi_aff_range_product(multi1: ma,
5173 multi2: isl_multi_aff_from_aff(el: aff));
5174 }
5175
5176 insert = isl_map_from_multi_aff_internal(ma: isl_multi_aff_copy(multi: ma));
5177 map = isl_map_apply_domain(map1: map, map2: insert);
5178 map = isl_map_equate(map, type1: isl_dim_in, pos1: n_in, type2: isl_dim_out, pos2: d);
5179 pma = isl_pw_multi_aff_from_map(map);
5180 pma = isl_pw_multi_aff_pullback_multi_aff(pw: pma, ma);
5181
5182 return pma;
5183error:
5184 isl_space_free(space);
5185 isl_map_free(map);
5186 isl_basic_map_free(bmap: hull);
5187 return NULL;
5188}
5189
5190/* Is constraint "c" of the form
5191 *
5192 * e(...) + c1 - m x >= 0
5193 *
5194 * or
5195 *
5196 * -e(...) + c2 + m x >= 0
5197 *
5198 * where m > 1 and e only depends on parameters and input dimensions?
5199 *
5200 * "offset" is the offset of the output dimensions
5201 * "pos" is the position of output dimension x.
5202 */
5203static int is_potential_div_constraint(isl_int *c, int offset, int d, int total)
5204{
5205 if (isl_int_is_zero(c[offset + d]))
5206 return 0;
5207 if (isl_int_is_one(c[offset + d]))
5208 return 0;
5209 if (isl_int_is_negone(c[offset + d]))
5210 return 0;
5211 if (isl_seq_first_non_zero(p: c + offset, len: d) != -1)
5212 return 0;
5213 if (isl_seq_first_non_zero(p: c + offset + d + 1,
5214 len: total - (offset + d + 1)) != -1)
5215 return 0;
5216 return 1;
5217}
5218
5219/* Try and create an isl_pw_multi_aff that is equivalent to the given isl_map.
5220 *
5221 * As a special case, we first check if there is any pair of constraints,
5222 * shared by all the basic maps in "map" that force a given dimension
5223 * to be equal to the floor of some affine combination of the input dimensions.
5224 *
5225 * In particular, if we can find two constraints
5226 *
5227 * e(...) + c1 - m x >= 0 i.e., m x <= e(...) + c1
5228 *
5229 * and
5230 *
5231 * -e(...) + c2 + m x >= 0 i.e., m x >= e(...) - c2
5232 *
5233 * where m > 1 and e only depends on parameters and input dimensions,
5234 * and such that
5235 *
5236 * c1 + c2 < m i.e., -c2 >= c1 - (m - 1)
5237 *
5238 * then we know that we can take
5239 *
5240 * x = floor((e(...) + c1) / m)
5241 *
5242 * without having to perform any computation.
5243 *
5244 * Note that we know that
5245 *
5246 * c1 + c2 >= 1
5247 *
5248 * If c1 + c2 were 0, then we would have detected an equality during
5249 * simplification. If c1 + c2 were negative, then we would have detected
5250 * a contradiction.
5251 */
5252static __isl_give isl_pw_multi_aff *pw_multi_aff_from_map_check_div(
5253 __isl_take isl_map *map)
5254{
5255 int d;
5256 isl_size dim;
5257 int i, j, n;
5258 int offset;
5259 isl_size total;
5260 isl_int sum;
5261 isl_basic_map *hull;
5262
5263 hull = isl_map_unshifted_simple_hull(map: isl_map_copy(map));
5264 dim = isl_map_dim(map, type: isl_dim_out);
5265 total = isl_basic_map_dim(bmap: hull, type: isl_dim_all);
5266 if (dim < 0 || total < 0)
5267 goto error;
5268
5269 isl_int_init(sum);
5270 offset = isl_basic_map_offset(bmap: hull, type: isl_dim_out);
5271 n = hull->n_ineq;
5272 for (d = 0; d < dim; ++d) {
5273 for (i = 0; i < n; ++i) {
5274 if (!is_potential_div_constraint(c: hull->ineq[i],
5275 offset, d, total: 1 + total))
5276 continue;
5277 for (j = i + 1; j < n; ++j) {
5278 if (!isl_seq_is_neg(p1: hull->ineq[i] + 1,
5279 p2: hull->ineq[j] + 1, len: total))
5280 continue;
5281 isl_int_add(sum, hull->ineq[i][0],
5282 hull->ineq[j][0]);
5283 if (isl_int_abs_lt(sum,
5284 hull->ineq[i][offset + d]))
5285 break;
5286
5287 }
5288 if (j >= n)
5289 continue;
5290 isl_int_clear(sum);
5291 if (isl_int_is_pos(hull->ineq[j][offset + d]))
5292 j = i;
5293 return pw_multi_aff_from_map_div(map, hull, d, i: j);
5294 }
5295 }
5296 isl_int_clear(sum);
5297 isl_basic_map_free(bmap: hull);
5298 return pw_multi_aff_from_map_base(map);
5299error:
5300 isl_map_free(map);
5301 isl_basic_map_free(bmap: hull);
5302 return NULL;
5303}
5304
5305/* Given an affine expression
5306 *
5307 * [A -> B] -> f(A,B)
5308 *
5309 * construct an isl_multi_aff
5310 *
5311 * [A -> B] -> B'
5312 *
5313 * such that dimension "d" in B' is set to "aff" and the remaining
5314 * dimensions are set equal to the corresponding dimensions in B.
5315 * "n_in" is the dimension of the space A.
5316 * "n_out" is the dimension of the space B.
5317 *
5318 * If "is_set" is set, then the affine expression is of the form
5319 *
5320 * [B] -> f(B)
5321 *
5322 * and we construct an isl_multi_aff
5323 *
5324 * B -> B'
5325 */
5326static __isl_give isl_multi_aff *range_map(__isl_take isl_aff *aff, int d,
5327 unsigned n_in, unsigned n_out, int is_set)
5328{
5329 int i;
5330 isl_multi_aff *ma;
5331 isl_space *space, *space2;
5332 isl_local_space *ls;
5333
5334 space = isl_aff_get_domain_space(aff);
5335 ls = isl_local_space_from_space(space: isl_space_copy(space));
5336 space2 = isl_space_copy(space);
5337 if (!is_set)
5338 space2 = isl_space_range(space: isl_space_unwrap(space: space2));
5339 space = isl_space_map_from_domain_and_range(domain: space, range: space2);
5340 ma = isl_multi_aff_alloc(space);
5341 ma = isl_multi_aff_set_aff(multi: ma, pos: d, el: aff);
5342
5343 for (i = 0; i < n_out; ++i) {
5344 if (i == d)
5345 continue;
5346 aff = isl_aff_var_on_domain(ls: isl_local_space_copy(ls),
5347 type: isl_dim_set, pos: n_in + i);
5348 ma = isl_multi_aff_set_aff(multi: ma, pos: i, el: aff);
5349 }
5350
5351 isl_local_space_free(ls);
5352
5353 return ma;
5354}
5355
5356/* Try and create an isl_pw_multi_aff that is equivalent to the given isl_map,
5357 * taking into account that the dimension at position "d" can be written as
5358 *
5359 * x = m a + f(..) (1)
5360 *
5361 * where m is equal to "gcd".
5362 * "i" is the index of the equality in "hull" that defines f(..).
5363 * In particular, the equality is of the form
5364 *
5365 * f(..) - x + m g(existentials) = 0
5366 *
5367 * or
5368 *
5369 * -f(..) + x + m g(existentials) = 0
5370 *
5371 * We basically plug (1) into "map", resulting in a map with "a"
5372 * in the range instead of "x". The corresponding isl_pw_multi_aff
5373 * defining "a" is then plugged back into (1) to obtain a definition for "x".
5374 *
5375 * Specifically, given the input map
5376 *
5377 * A -> B
5378 *
5379 * We first wrap it into a set
5380 *
5381 * [A -> B]
5382 *
5383 * and define (1) on top of the corresponding space, resulting in "aff".
5384 * We use this to create an isl_multi_aff that maps the output position "d"
5385 * from "a" to "x", leaving all other (intput and output) dimensions unchanged.
5386 * We plug this into the wrapped map, unwrap the result and compute the
5387 * corresponding isl_pw_multi_aff.
5388 * The result is an expression
5389 *
5390 * A -> T(A)
5391 *
5392 * We adjust that to
5393 *
5394 * A -> [A -> T(A)]
5395 *
5396 * so that we can plug that into "aff", after extending the latter to
5397 * a mapping
5398 *
5399 * [A -> B] -> B'
5400 *
5401 *
5402 * If "map" is actually a set, then there is no "A" space, meaning
5403 * that we do not need to perform any wrapping, and that the result
5404 * of the recursive call is of the form
5405 *
5406 * [T]
5407 *
5408 * which is plugged into a mapping of the form
5409 *
5410 * B -> B'
5411 */
5412static __isl_give isl_pw_multi_aff *pw_multi_aff_from_map_stride(
5413 __isl_take isl_map *map, __isl_take isl_basic_map *hull, int d, int i,
5414 isl_int gcd)
5415{
5416 isl_set *set;
5417 isl_space *space;
5418 isl_local_space *ls;
5419 isl_aff *aff;
5420 isl_multi_aff *ma;
5421 isl_pw_multi_aff *pma, *id;
5422 isl_size n_in;
5423 unsigned o_out;
5424 isl_size n_out;
5425 isl_bool is_set;
5426
5427 is_set = isl_map_is_set(map);
5428 if (is_set < 0)
5429 goto error;
5430
5431 n_in = isl_basic_map_dim(bmap: hull, type: isl_dim_in);
5432 n_out = isl_basic_map_dim(bmap: hull, type: isl_dim_out);
5433 if (n_in < 0 || n_out < 0)
5434 goto error;
5435 o_out = isl_basic_map_offset(bmap: hull, type: isl_dim_out);
5436
5437 if (is_set)
5438 set = map;
5439 else
5440 set = isl_map_wrap(map);
5441 space = isl_space_map_from_set(space: isl_set_get_space(set));
5442 ma = isl_multi_aff_identity(space);
5443 ls = isl_local_space_from_space(space: isl_set_get_space(set));
5444 aff = isl_aff_alloc(ls);
5445 if (aff) {
5446 isl_int_set_si(aff->v->el[0], 1);
5447 if (isl_int_is_one(hull->eq[i][o_out + d]))
5448 isl_seq_neg(dst: aff->v->el + 1, src: hull->eq[i],
5449 len: aff->v->size - 1);
5450 else
5451 isl_seq_cpy(dst: aff->v->el + 1, src: hull->eq[i],
5452 len: aff->v->size - 1);
5453 isl_int_set(aff->v->el[1 + o_out + d], gcd);
5454 }
5455 ma = isl_multi_aff_set_aff(multi: ma, pos: n_in + d, el: isl_aff_copy(aff));
5456 set = isl_set_preimage_multi_aff(set, ma);
5457
5458 ma = range_map(aff, d, n_in, n_out, is_set);
5459
5460 if (is_set)
5461 map = set;
5462 else
5463 map = isl_set_unwrap(set);
5464 pma = isl_pw_multi_aff_from_map(map);
5465
5466 if (!is_set) {
5467 space = isl_pw_multi_aff_get_domain_space(pw: pma);
5468 space = isl_space_map_from_set(space);
5469 id = isl_pw_multi_aff_identity(space);
5470 pma = isl_pw_multi_aff_range_product(pma1: id, pma2: pma);
5471 }
5472 id = isl_pw_multi_aff_from_multi_aff(el: ma);
5473 pma = isl_pw_multi_aff_pullback_pw_multi_aff(pw: id, pma);
5474
5475 isl_basic_map_free(bmap: hull);
5476 return pma;
5477error:
5478 isl_map_free(map);
5479 isl_basic_map_free(bmap: hull);
5480 return NULL;
5481}
5482
5483/* Try and create an isl_pw_multi_aff that is equivalent to the given isl_map.
5484 * "hull" contains the equalities valid for "map".
5485 *
5486 * Check if any of the output dimensions is "strided".
5487 * That is, we check if it can be written as
5488 *
5489 * x = m a + f(..)
5490 *
5491 * with m greater than 1, a some combination of existentially quantified
5492 * variables and f an expression in the parameters and input dimensions.
5493 * If so, we remove the stride in pw_multi_aff_from_map_stride.
5494 *
5495 * Otherwise, we continue with pw_multi_aff_from_map_check_div for a further
5496 * special case.
5497 */
5498static __isl_give isl_pw_multi_aff *pw_multi_aff_from_map_check_strides(
5499 __isl_take isl_map *map, __isl_take isl_basic_map *hull)
5500{
5501 int i, j;
5502 isl_size n_out;
5503 unsigned o_out;
5504 isl_size n_div;
5505 unsigned o_div;
5506 isl_int gcd;
5507
5508 n_div = isl_basic_map_dim(bmap: hull, type: isl_dim_div);
5509 n_out = isl_basic_map_dim(bmap: hull, type: isl_dim_out);
5510 if (n_div < 0 || n_out < 0)
5511 goto error;
5512
5513 if (n_div == 0) {
5514 isl_basic_map_free(bmap: hull);
5515 return pw_multi_aff_from_map_check_div(map);
5516 }
5517
5518 isl_int_init(gcd);
5519
5520 o_div = isl_basic_map_offset(bmap: hull, type: isl_dim_div);
5521 o_out = isl_basic_map_offset(bmap: hull, type: isl_dim_out);
5522
5523 for (i = 0; i < n_out; ++i) {
5524 for (j = 0; j < hull->n_eq; ++j) {
5525 isl_int *eq = hull->eq[j];
5526 isl_pw_multi_aff *res;
5527
5528 if (!isl_int_is_one(eq[o_out + i]) &&
5529 !isl_int_is_negone(eq[o_out + i]))
5530 continue;
5531 if (isl_seq_first_non_zero(p: eq + o_out, len: i) != -1)
5532 continue;
5533 if (isl_seq_first_non_zero(p: eq + o_out + i + 1,
5534 len: n_out - (i + 1)) != -1)
5535 continue;
5536 isl_seq_gcd(p: eq + o_div, len: n_div, gcd: &gcd);
5537 if (isl_int_is_zero(gcd))
5538 continue;
5539 if (isl_int_is_one(gcd))
5540 continue;
5541
5542 res = pw_multi_aff_from_map_stride(map, hull,
5543 d: i, i: j, gcd);
5544 isl_int_clear(gcd);
5545 return res;
5546 }
5547 }
5548
5549 isl_int_clear(gcd);
5550 isl_basic_map_free(bmap: hull);
5551 return pw_multi_aff_from_map_check_div(map);
5552error:
5553 isl_map_free(map);
5554 isl_basic_map_free(bmap: hull);
5555 return NULL;
5556}
5557
5558/* Try and create an isl_pw_multi_aff that is equivalent to the given isl_map.
5559 *
5560 * As a special case, we first check if all output dimensions are uniquely
5561 * defined in terms of the parameters and input dimensions over the entire
5562 * domain. If so, we extract the desired isl_pw_multi_aff directly
5563 * from the affine hull of "map" and its domain.
5564 *
5565 * Otherwise, continue with pw_multi_aff_from_map_check_strides for more
5566 * special cases.
5567 */
5568__isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_map(__isl_take isl_map *map)
5569{
5570 isl_bool sv;
5571 isl_size n;
5572 isl_basic_map *hull;
5573
5574 n = isl_map_n_basic_map(map);
5575 if (n < 0)
5576 goto error;
5577
5578 if (n == 1) {
5579 hull = isl_map_unshifted_simple_hull(map: isl_map_copy(map));
5580 hull = isl_basic_map_plain_affine_hull(bmap: hull);
5581 sv = isl_basic_map_plain_is_single_valued(bmap: hull);
5582 if (sv >= 0 && sv)
5583 return plain_pw_multi_aff_from_map(domain: isl_map_domain(bmap: map),
5584 bmap: hull);
5585 isl_basic_map_free(bmap: hull);
5586 }
5587 map = isl_map_detect_equalities(map);
5588 hull = isl_map_unshifted_simple_hull(map: isl_map_copy(map));
5589 sv = isl_basic_map_plain_is_single_valued(bmap: hull);
5590 if (sv >= 0 && sv)
5591 return plain_pw_multi_aff_from_map(domain: isl_map_domain(bmap: map), bmap: hull);
5592 if (sv >= 0)
5593 return pw_multi_aff_from_map_check_strides(map, hull);
5594 isl_basic_map_free(bmap: hull);
5595error:
5596 isl_map_free(map);
5597 return NULL;
5598}
5599
5600/* This function performs the same operation as isl_pw_multi_aff_from_map,
5601 * but is considered as a function on an isl_map when exported.
5602 */
5603__isl_give isl_pw_multi_aff *isl_map_as_pw_multi_aff(__isl_take isl_map *map)
5604{
5605 return isl_pw_multi_aff_from_map(map);
5606}
5607
5608__isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_set(__isl_take isl_set *set)
5609{
5610 return isl_pw_multi_aff_from_map(map: set);
5611}
5612
5613/* This function performs the same operation as isl_pw_multi_aff_from_set,
5614 * but is considered as a function on an isl_set when exported.
5615 */
5616__isl_give isl_pw_multi_aff *isl_set_as_pw_multi_aff(__isl_take isl_set *set)
5617{
5618 return isl_pw_multi_aff_from_set(set);
5619}
5620
5621/* Convert "map" into an isl_pw_multi_aff (if possible) and
5622 * add it to *user.
5623 */
5624static isl_stat pw_multi_aff_from_map(__isl_take isl_map *map, void *user)
5625{
5626 isl_union_pw_multi_aff **upma = user;
5627 isl_pw_multi_aff *pma;
5628
5629 pma = isl_pw_multi_aff_from_map(map);
5630 *upma = isl_union_pw_multi_aff_add_pw_multi_aff(u: *upma, part: pma);
5631
5632 return *upma ? isl_stat_ok : isl_stat_error;
5633}
5634
5635/* Create an isl_union_pw_multi_aff with the given isl_aff on a universe
5636 * domain.
5637 */
5638__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_from_aff(
5639 __isl_take isl_aff *aff)
5640{
5641 isl_multi_aff *ma;
5642 isl_pw_multi_aff *pma;
5643
5644 ma = isl_multi_aff_from_aff(el: aff);
5645 pma = isl_pw_multi_aff_from_multi_aff(el: ma);
5646 return isl_union_pw_multi_aff_from_pw_multi_aff(part: pma);
5647}
5648
5649/* Try and create an isl_union_pw_multi_aff that is equivalent
5650 * to the given isl_union_map.
5651 * The isl_union_map is required to be single-valued in each space.
5652 * Otherwise, an error is produced.
5653 */
5654__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_from_union_map(
5655 __isl_take isl_union_map *umap)
5656{
5657 isl_space *space;
5658 isl_union_pw_multi_aff *upma;
5659
5660 space = isl_union_map_get_space(umap);
5661 upma = isl_union_pw_multi_aff_empty(space);
5662 if (isl_union_map_foreach_map(umap, fn: &pw_multi_aff_from_map, user: &upma) < 0)
5663 upma = isl_union_pw_multi_aff_free(u: upma);
5664 isl_union_map_free(umap);
5665
5666 return upma;
5667}
5668
5669/* This function performs the same operation as
5670 * isl_union_pw_multi_aff_from_union_map,
5671 * but is considered as a function on an isl_union_map when exported.
5672 */
5673__isl_give isl_union_pw_multi_aff *isl_union_map_as_union_pw_multi_aff(
5674 __isl_take isl_union_map *umap)
5675{
5676 return isl_union_pw_multi_aff_from_union_map(umap);
5677}
5678
5679/* Try and create an isl_union_pw_multi_aff that is equivalent
5680 * to the given isl_union_set.
5681 * The isl_union_set is required to be a singleton in each space.
5682 * Otherwise, an error is produced.
5683 */
5684__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_from_union_set(
5685 __isl_take isl_union_set *uset)
5686{
5687 return isl_union_pw_multi_aff_from_union_map(umap: uset);
5688}
5689
5690/* Return the piecewise affine expression "set ? 1 : 0".
5691 */
5692__isl_give isl_pw_aff *isl_set_indicator_function(__isl_take isl_set *set)
5693{
5694 isl_pw_aff *pa;
5695 isl_space *space = isl_set_get_space(set);
5696 isl_local_space *ls = isl_local_space_from_space(space);
5697 isl_aff *zero = isl_aff_zero_on_domain(ls: isl_local_space_copy(ls));
5698 isl_aff *one = isl_aff_zero_on_domain(ls);
5699
5700 one = isl_aff_add_constant_si(aff: one, v: 1);
5701 pa = isl_pw_aff_alloc(set: isl_set_copy(set), el: one);
5702 set = isl_set_complement(set);
5703 pa = isl_pw_aff_add_disjoint(pw1: pa, pw2: isl_pw_aff_alloc(set, el: zero));
5704
5705 return pa;
5706}
5707
5708/* Plug in "subs" for dimension "type", "pos" of "aff".
5709 *
5710 * Let i be the dimension to replace and let "subs" be of the form
5711 *
5712 * f/d
5713 *
5714 * and "aff" of the form
5715 *
5716 * (a i + g)/m
5717 *
5718 * The result is
5719 *
5720 * (a f + d g')/(m d)
5721 *
5722 * where g' is the result of plugging in "subs" in each of the integer
5723 * divisions in g.
5724 */
5725__isl_give isl_aff *isl_aff_substitute(__isl_take isl_aff *aff,
5726 enum isl_dim_type type, unsigned pos, __isl_keep isl_aff *subs)
5727{
5728 isl_ctx *ctx;
5729 isl_int v;
5730 isl_size n_div;
5731
5732 aff = isl_aff_cow(aff);
5733 if (!aff || !subs)
5734 return isl_aff_free(aff);
5735
5736 ctx = isl_aff_get_ctx(aff);
5737 if (!isl_space_is_equal(space1: aff->ls->dim, space2: subs->ls->dim))
5738 isl_die(ctx, isl_error_invalid,
5739 "spaces don't match", return isl_aff_free(aff));
5740 n_div = isl_aff_domain_dim(aff: subs, type: isl_dim_div);
5741 if (n_div < 0)
5742 return isl_aff_free(aff);
5743 if (n_div != 0)
5744 isl_die(ctx, isl_error_unsupported,
5745 "cannot handle divs yet", return isl_aff_free(aff));
5746
5747 aff->ls = isl_local_space_substitute(ls: aff->ls, type, pos, subs);
5748 if (!aff->ls)
5749 return isl_aff_free(aff);
5750
5751 aff->v = isl_vec_cow(vec: aff->v);
5752 if (!aff->v)
5753 return isl_aff_free(aff);
5754
5755 pos += isl_local_space_offset(ls: aff->ls, type);
5756
5757 isl_int_init(v);
5758 isl_seq_substitute(p: aff->v->el, pos, subs: subs->v->el,
5759 p_len: aff->v->size, subs_len: subs->v->size, v);
5760 isl_int_clear(v);
5761
5762 return aff;
5763}
5764
5765/* Plug in "subs" for dimension "type", "pos" in each of the affine
5766 * expressions in "maff".
5767 */
5768__isl_give isl_multi_aff *isl_multi_aff_substitute(
5769 __isl_take isl_multi_aff *maff, enum isl_dim_type type, unsigned pos,
5770 __isl_keep isl_aff *subs)
5771{
5772 isl_size n;
5773 int i;
5774
5775 n = isl_multi_aff_size(multi: maff);
5776 if (n < 0 || !subs)
5777 return isl_multi_aff_free(multi: maff);
5778
5779 if (type == isl_dim_in)
5780 type = isl_dim_set;
5781
5782 for (i = 0; i < n; ++i) {
5783 isl_aff *aff;
5784
5785 aff = isl_multi_aff_take_at(multi: maff, pos: i);
5786 aff = isl_aff_substitute(aff, type, pos, subs);
5787 maff = isl_multi_aff_restore_at(multi: maff, pos: i, el: aff);
5788 }
5789
5790 return maff;
5791}
5792
5793/* Plug in "subs" for input dimension "pos" of "pma".
5794 *
5795 * pma is of the form
5796 *
5797 * A_i(v) -> M_i(v)
5798 *
5799 * while subs is of the form
5800 *
5801 * v' = B_j(v) -> S_j
5802 *
5803 * Each pair i,j such that C_ij = A_i \cap B_i is non-empty
5804 * has a contribution in the result, in particular
5805 *
5806 * C_ij(S_j) -> M_i(S_j)
5807 *
5808 * Note that plugging in S_j in C_ij may also result in an empty set
5809 * and this contribution should simply be discarded.
5810 */
5811__isl_give isl_pw_multi_aff *isl_pw_multi_aff_substitute(
5812 __isl_take isl_pw_multi_aff *pma, unsigned pos,
5813 __isl_keep isl_pw_aff *subs)
5814{
5815 int i, j, n;
5816 isl_pw_multi_aff *res;
5817
5818 if (!pma || !subs)
5819 return isl_pw_multi_aff_free(pw: pma);
5820
5821 n = pma->n * subs->n;
5822 res = isl_pw_multi_aff_alloc_size(space: isl_space_copy(space: pma->dim), n);
5823
5824 for (i = 0; i < pma->n; ++i) {
5825 for (j = 0; j < subs->n; ++j) {
5826 isl_set *common;
5827 isl_multi_aff *res_ij;
5828 int empty;
5829
5830 common = isl_set_intersect(
5831 set1: isl_set_copy(set: pma->p[i].set),
5832 set2: isl_set_copy(set: subs->p[j].set));
5833 common = isl_set_substitute(set: common,
5834 pos, subs: subs->p[j].aff);
5835 empty = isl_set_plain_is_empty(set: common);
5836 if (empty < 0 || empty) {
5837 isl_set_free(set: common);
5838 if (empty < 0)
5839 goto error;
5840 continue;
5841 }
5842
5843 res_ij = isl_multi_aff_substitute(
5844 maff: isl_multi_aff_copy(multi: pma->p[i].maff),
5845 type: isl_dim_in, pos, subs: subs->p[j].aff);
5846
5847 res = isl_pw_multi_aff_add_piece(pw: res, set: common, el: res_ij);
5848 }
5849 }
5850
5851 isl_pw_multi_aff_free(pw: pma);
5852 return res;
5853error:
5854 isl_pw_multi_aff_free(pw: pma);
5855 isl_pw_multi_aff_free(pw: res);
5856 return NULL;
5857}
5858
5859/* Compute the preimage of a range of dimensions in the affine expression "src"
5860 * under "ma" and put the result in "dst". The number of dimensions in "src"
5861 * that precede the range is given by "n_before". The number of dimensions
5862 * in the range is given by the number of output dimensions of "ma".
5863 * The number of dimensions that follow the range is given by "n_after".
5864 * If "has_denom" is set (to one),
5865 * then "src" and "dst" have an extra initial denominator.
5866 * "n_div_ma" is the number of existentials in "ma"
5867 * "n_div_bset" is the number of existentials in "src"
5868 * The resulting "dst" (which is assumed to have been allocated by
5869 * the caller) contains coefficients for both sets of existentials,
5870 * first those in "ma" and then those in "src".
5871 * f, c1, c2 and g are temporary objects that have been initialized
5872 * by the caller.
5873 *
5874 * Let src represent the expression
5875 *
5876 * (a(p) + f_u u + b v + f_w w + c(divs))/d
5877 *
5878 * and let ma represent the expressions
5879 *
5880 * v_i = (r_i(p) + s_i(y) + t_i(divs'))/m_i
5881 *
5882 * We start out with the following expression for dst:
5883 *
5884 * (a(p) + f_u u + 0 y + f_w w + 0 divs' + c(divs) + f \sum_i b_i v_i)/d
5885 *
5886 * with the multiplication factor f initially equal to 1
5887 * and f \sum_i b_i v_i kept separately.
5888 * For each x_i that we substitute, we multiply the numerator
5889 * (and denominator) of dst by c_1 = m_i and add the numerator
5890 * of the x_i expression multiplied by c_2 = f b_i,
5891 * after removing the common factors of c_1 and c_2.
5892 * The multiplication factor f also needs to be multiplied by c_1
5893 * for the next x_j, j > i.
5894 */
5895isl_stat isl_seq_preimage(isl_int *dst, isl_int *src,
5896 __isl_keep isl_multi_aff *ma, int n_before, int n_after,
5897 int n_div_ma, int n_div_bmap,
5898 isl_int f, isl_int c1, isl_int c2, isl_int g, int has_denom)
5899{
5900 int i;
5901 isl_size n_param, n_in, n_out;
5902 int o_dst, o_src;
5903
5904 n_param = isl_multi_aff_dim(multi: ma, type: isl_dim_param);
5905 n_in = isl_multi_aff_dim(multi: ma, type: isl_dim_in);
5906 n_out = isl_multi_aff_dim(multi: ma, type: isl_dim_out);
5907 if (n_param < 0 || n_in < 0 || n_out < 0)
5908 return isl_stat_error;
5909
5910 isl_seq_cpy(dst, src, len: has_denom + 1 + n_param + n_before);
5911 o_dst = o_src = has_denom + 1 + n_param + n_before;
5912 isl_seq_clr(p: dst + o_dst, len: n_in);
5913 o_dst += n_in;
5914 o_src += n_out;
5915 isl_seq_cpy(dst: dst + o_dst, src: src + o_src, len: n_after);
5916 o_dst += n_after;
5917 o_src += n_after;
5918 isl_seq_clr(p: dst + o_dst, len: n_div_ma);
5919 o_dst += n_div_ma;
5920 isl_seq_cpy(dst: dst + o_dst, src: src + o_src, len: n_div_bmap);
5921
5922 isl_int_set_si(f, 1);
5923
5924 for (i = 0; i < n_out; ++i) {
5925 int offset = has_denom + 1 + n_param + n_before + i;
5926
5927 if (isl_int_is_zero(src[offset]))
5928 continue;
5929 isl_int_set(c1, ma->u.p[i]->v->el[0]);
5930 isl_int_mul(c2, f, src[offset]);
5931 isl_int_gcd(g, c1, c2);
5932 isl_int_divexact(c1, c1, g);
5933 isl_int_divexact(c2, c2, g);
5934
5935 isl_int_mul(f, f, c1);
5936 o_dst = has_denom;
5937 o_src = 1;
5938 isl_seq_combine(dst: dst + o_dst, m1: c1, src1: dst + o_dst,
5939 m2: c2, src2: ma->u.p[i]->v->el + o_src, len: 1 + n_param);
5940 o_dst += 1 + n_param;
5941 o_src += 1 + n_param;
5942 isl_seq_scale(dst: dst + o_dst, src: dst + o_dst, f: c1, len: n_before);
5943 o_dst += n_before;
5944 isl_seq_combine(dst: dst + o_dst, m1: c1, src1: dst + o_dst,
5945 m2: c2, src2: ma->u.p[i]->v->el + o_src, len: n_in);
5946 o_dst += n_in;
5947 o_src += n_in;
5948 isl_seq_scale(dst: dst + o_dst, src: dst + o_dst, f: c1, len: n_after);
5949 o_dst += n_after;
5950 isl_seq_combine(dst: dst + o_dst, m1: c1, src1: dst + o_dst,
5951 m2: c2, src2: ma->u.p[i]->v->el + o_src, len: n_div_ma);
5952 o_dst += n_div_ma;
5953 o_src += n_div_ma;
5954 isl_seq_scale(dst: dst + o_dst, src: dst + o_dst, f: c1, len: n_div_bmap);
5955 if (has_denom)
5956 isl_int_mul(dst[0], dst[0], c1);
5957 }
5958
5959 return isl_stat_ok;
5960}
5961
5962/* Compute the pullback of "aff" by the function represented by "ma".
5963 * In other words, plug in "ma" in "aff". The result is an affine expression
5964 * defined over the domain space of "ma".
5965 *
5966 * If "aff" is represented by
5967 *
5968 * (a(p) + b x + c(divs))/d
5969 *
5970 * and ma is represented by
5971 *
5972 * x = D(p) + F(y) + G(divs')
5973 *
5974 * then the result is
5975 *
5976 * (a(p) + b D(p) + b F(y) + b G(divs') + c(divs))/d
5977 *
5978 * The divs in the local space of the input are similarly adjusted
5979 * through a call to isl_local_space_preimage_multi_aff.
5980 */
5981__isl_give isl_aff *isl_aff_pullback_multi_aff(__isl_take isl_aff *aff,
5982 __isl_take isl_multi_aff *ma)
5983{
5984 isl_aff *res = NULL;
5985 isl_local_space *ls;
5986 isl_size n_div_aff, n_div_ma;
5987 isl_int f, c1, c2, g;
5988
5989 ma = isl_multi_aff_align_divs(maff: ma);
5990 if (!aff || !ma)
5991 goto error;
5992
5993 n_div_aff = isl_aff_dim(aff, type: isl_dim_div);
5994 n_div_ma = ma->n ? isl_aff_dim(aff: ma->u.p[0], type: isl_dim_div) : 0;
5995 if (n_div_aff < 0 || n_div_ma < 0)
5996 goto error;
5997
5998 ls = isl_aff_get_domain_local_space(aff);
5999 ls = isl_local_space_preimage_multi_aff(ls, ma: isl_multi_aff_copy(multi: ma));
6000 res = isl_aff_alloc(ls);
6001 if (!res)
6002 goto error;
6003
6004 isl_int_init(f);
6005 isl_int_init(c1);
6006 isl_int_init(c2);
6007 isl_int_init(g);
6008
6009 if (isl_seq_preimage(dst: res->v->el, src: aff->v->el, ma, n_before: 0, n_after: 0,
6010 n_div_ma, n_div_bmap: n_div_aff, f, c1, c2, g, has_denom: 1) < 0)
6011 res = isl_aff_free(aff: res);
6012
6013 isl_int_clear(f);
6014 isl_int_clear(c1);
6015 isl_int_clear(c2);
6016 isl_int_clear(g);
6017
6018 isl_aff_free(aff);
6019 isl_multi_aff_free(multi: ma);
6020 res = isl_aff_normalize(aff: res);
6021 return res;
6022error:
6023 isl_aff_free(aff);
6024 isl_multi_aff_free(multi: ma);
6025 isl_aff_free(aff: res);
6026 return NULL;
6027}
6028
6029/* Compute the pullback of "aff1" by the function represented by "aff2".
6030 * In other words, plug in "aff2" in "aff1". The result is an affine expression
6031 * defined over the domain space of "aff1".
6032 *
6033 * The domain of "aff1" should match the range of "aff2", which means
6034 * that it should be single-dimensional.
6035 */
6036__isl_give isl_aff *isl_aff_pullback_aff(__isl_take isl_aff *aff1,
6037 __isl_take isl_aff *aff2)
6038{
6039 isl_multi_aff *ma;
6040
6041 ma = isl_multi_aff_from_aff(el: aff2);
6042 return isl_aff_pullback_multi_aff(aff: aff1, ma);
6043}
6044
6045/* Compute the pullback of "ma1" by the function represented by "ma2".
6046 * In other words, plug in "ma2" in "ma1".
6047 */
6048__isl_give isl_multi_aff *isl_multi_aff_pullback_multi_aff(
6049 __isl_take isl_multi_aff *ma1, __isl_take isl_multi_aff *ma2)
6050{
6051 int i;
6052 isl_size n;
6053 isl_space *space = NULL;
6054
6055 isl_multi_aff_align_params_bin(obj1: &ma1, obj2: &ma2);
6056 ma2 = isl_multi_aff_align_divs(maff: ma2);
6057 n = isl_multi_aff_size(multi: ma1);
6058 if (n < 0 || !ma2)
6059 goto error;
6060
6061 space = isl_space_join(left: isl_multi_aff_get_space(multi: ma2),
6062 right: isl_multi_aff_get_space(multi: ma1));
6063
6064 for (i = 0; i < n; ++i) {
6065 isl_aff *aff;
6066
6067 aff = isl_multi_aff_take_at(multi: ma1, pos: i);
6068 aff = isl_aff_pullback_multi_aff(aff, ma: isl_multi_aff_copy(multi: ma2));
6069 ma1 = isl_multi_aff_restore_at(multi: ma1, pos: i, el: aff);
6070 }
6071
6072 ma1 = isl_multi_aff_reset_space(multi: ma1, space);
6073 isl_multi_aff_free(multi: ma2);
6074 return ma1;
6075error:
6076 isl_space_free(space);
6077 isl_multi_aff_free(multi: ma2);
6078 isl_multi_aff_free(multi: ma1);
6079 return NULL;
6080}
6081
6082/* Extend the local space of "dst" to include the divs
6083 * in the local space of "src".
6084 *
6085 * If "src" does not have any divs or if the local spaces of "dst" and
6086 * "src" are the same, then no extension is required.
6087 */
6088__isl_give isl_aff *isl_aff_align_divs(__isl_take isl_aff *dst,
6089 __isl_keep isl_aff *src)
6090{
6091 isl_ctx *ctx;
6092 isl_size src_n_div, dst_n_div;
6093 int *exp1 = NULL;
6094 int *exp2 = NULL;
6095 isl_bool equal;
6096 isl_mat *div;
6097
6098 if (!src || !dst)
6099 return isl_aff_free(aff: dst);
6100
6101 ctx = isl_aff_get_ctx(aff: src);
6102 equal = isl_local_space_has_equal_space(ls1: src->ls, ls2: dst->ls);
6103 if (equal < 0)
6104 return isl_aff_free(aff: dst);
6105 if (!equal)
6106 isl_die(ctx, isl_error_invalid,
6107 "spaces don't match", goto error);
6108
6109 src_n_div = isl_aff_domain_dim(aff: src, type: isl_dim_div);
6110 dst_n_div = isl_aff_domain_dim(aff: dst, type: isl_dim_div);
6111 if (src_n_div == 0)
6112 return dst;
6113 equal = isl_local_space_is_equal(ls1: src->ls, ls2: dst->ls);
6114 if (equal < 0 || src_n_div < 0 || dst_n_div < 0)
6115 return isl_aff_free(aff: dst);
6116 if (equal)
6117 return dst;
6118
6119 exp1 = isl_alloc_array(ctx, int, src_n_div);
6120 exp2 = isl_alloc_array(ctx, int, dst_n_div);
6121 if (!exp1 || (dst_n_div && !exp2))
6122 goto error;
6123
6124 div = isl_merge_divs(div1: src->ls->div, div2: dst->ls->div, exp1, exp2);
6125 dst = isl_aff_expand_divs(aff: dst, div, exp: exp2);
6126 free(ptr: exp1);
6127 free(ptr: exp2);
6128
6129 return dst;
6130error:
6131 free(ptr: exp1);
6132 free(ptr: exp2);
6133 return isl_aff_free(aff: dst);
6134}
6135
6136/* Adjust the local spaces of the affine expressions in "maff"
6137 * such that they all have the save divs.
6138 */
6139__isl_give isl_multi_aff *isl_multi_aff_align_divs(
6140 __isl_take isl_multi_aff *maff)
6141{
6142 isl_aff *aff_0;
6143 isl_size n;
6144 int i;
6145
6146 n = isl_multi_aff_size(multi: maff);
6147 if (n < 0)
6148 return isl_multi_aff_free(multi: maff);
6149 if (n <= 1)
6150 return maff;
6151
6152 aff_0 = isl_multi_aff_take_at(multi: maff, pos: 0);
6153 for (i = 1; i < n; ++i) {
6154 isl_aff *aff_i;
6155
6156 aff_i = isl_multi_aff_peek_at(multi: maff, pos: i);
6157 aff_0 = isl_aff_align_divs(dst: aff_0, src: aff_i);
6158 }
6159 maff = isl_multi_aff_restore_at(multi: maff, pos: 0, el: aff_0);
6160
6161 aff_0 = isl_multi_aff_peek_at(multi: maff, pos: 0);
6162 for (i = 1; i < n; ++i) {
6163 isl_aff *aff_i;
6164
6165 aff_i = isl_multi_aff_take_at(multi: maff, pos: i);
6166 aff_i = isl_aff_align_divs(dst: aff_i, src: aff_0);
6167 maff = isl_multi_aff_restore_at(multi: maff, pos: i, el: aff_i);
6168 }
6169
6170 return maff;
6171}
6172
6173__isl_give isl_aff *isl_aff_lift(__isl_take isl_aff *aff)
6174{
6175 aff = isl_aff_cow(aff);
6176 if (!aff)
6177 return NULL;
6178
6179 aff->ls = isl_local_space_lift(ls: aff->ls);
6180 if (!aff->ls)
6181 return isl_aff_free(aff);
6182
6183 return aff;
6184}
6185
6186/* Lift "maff" to a space with extra dimensions such that the result
6187 * has no more existentially quantified variables.
6188 * If "ls" is not NULL, then *ls is assigned the local space that lies
6189 * at the basis of the lifting applied to "maff".
6190 */
6191__isl_give isl_multi_aff *isl_multi_aff_lift(__isl_take isl_multi_aff *maff,
6192 __isl_give isl_local_space **ls)
6193{
6194 int i;
6195 isl_space *space;
6196 isl_aff *aff;
6197 isl_size n, n_div;
6198
6199 if (ls)
6200 *ls = NULL;
6201
6202 n = isl_multi_aff_size(multi: maff);
6203 if (n < 0)
6204 return isl_multi_aff_free(multi: maff);
6205
6206 if (n == 0) {
6207 if (ls) {
6208 isl_space *space = isl_multi_aff_get_domain_space(multi: maff);
6209 *ls = isl_local_space_from_space(space);
6210 if (!*ls)
6211 return isl_multi_aff_free(multi: maff);
6212 }
6213 return maff;
6214 }
6215
6216 maff = isl_multi_aff_align_divs(maff);
6217
6218 aff = isl_multi_aff_peek_at(multi: maff, pos: 0);
6219 n_div = isl_aff_dim(aff, type: isl_dim_div);
6220 if (n_div < 0)
6221 return isl_multi_aff_free(multi: maff);
6222 space = isl_multi_aff_get_space(multi: maff);
6223 space = isl_space_lift(space: isl_space_domain(space), n_local: n_div);
6224 space = isl_space_extend_domain_with_range(domain: space,
6225 model: isl_multi_aff_get_space(multi: maff));
6226 maff = isl_multi_aff_restore_space(multi: maff, space);
6227
6228 if (ls) {
6229 aff = isl_multi_aff_peek_at(multi: maff, pos: 0);
6230 *ls = isl_aff_get_domain_local_space(aff);
6231 if (!*ls)
6232 return isl_multi_aff_free(multi: maff);
6233 }
6234
6235 for (i = 0; i < n; ++i) {
6236 aff = isl_multi_aff_take_at(multi: maff, pos: i);
6237 aff = isl_aff_lift(aff);
6238 maff = isl_multi_aff_restore_at(multi: maff, pos: i, el: aff);
6239 }
6240
6241 return maff;
6242}
6243
6244#undef TYPE
6245#define TYPE isl_pw_multi_aff
6246static
6247#include "check_type_range_templ.c"
6248
6249/* Extract an isl_pw_aff corresponding to output dimension "pos" of "pma".
6250 */
6251__isl_give isl_pw_aff *isl_pw_multi_aff_get_at(
6252 __isl_keep isl_pw_multi_aff *pma, int pos)
6253{
6254 int i;
6255 isl_size n_out;
6256 isl_space *space;
6257 isl_pw_aff *pa;
6258
6259 if (isl_pw_multi_aff_check_range(obj: pma, type: isl_dim_out, first: pos, n: 1) < 0)
6260 return NULL;
6261
6262 n_out = isl_pw_multi_aff_dim(pw: pma, type: isl_dim_out);
6263 if (n_out < 0)
6264 return NULL;
6265
6266 space = isl_pw_multi_aff_get_space(pw: pma);
6267 space = isl_space_drop_dims(space, type: isl_dim_out,
6268 first: pos + 1, num: n_out - pos - 1);
6269 space = isl_space_drop_dims(space, type: isl_dim_out, first: 0, num: pos);
6270
6271 pa = isl_pw_aff_alloc_size(space, n: pma->n);
6272 for (i = 0; i < pma->n; ++i) {
6273 isl_aff *aff;
6274 aff = isl_multi_aff_get_aff(multi: pma->p[i].maff, pos);
6275 pa = isl_pw_aff_add_piece(pw: pa, set: isl_set_copy(set: pma->p[i].set), el: aff);
6276 }
6277
6278 return pa;
6279}
6280
6281/* This is an alternative name for the function above.
6282 */
6283__isl_give isl_pw_aff *isl_pw_multi_aff_get_pw_aff(
6284 __isl_keep isl_pw_multi_aff *pma, int pos)
6285{
6286 return isl_pw_multi_aff_get_at(pma, pos);
6287}
6288
6289/* Return an isl_pw_multi_aff with the given "set" as domain and
6290 * an unnamed zero-dimensional range.
6291 */
6292__isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_domain(
6293 __isl_take isl_set *set)
6294{
6295 isl_multi_aff *ma;
6296 isl_space *space;
6297
6298 space = isl_set_get_space(set);
6299 space = isl_space_from_domain(space);
6300 ma = isl_multi_aff_zero(space);
6301 return isl_pw_multi_aff_alloc(set, el: ma);
6302}
6303
6304/* Add an isl_pw_multi_aff with the given "set" as domain and
6305 * an unnamed zero-dimensional range to *user.
6306 */
6307static isl_stat add_pw_multi_aff_from_domain(__isl_take isl_set *set,
6308 void *user)
6309{
6310 isl_union_pw_multi_aff **upma = user;
6311 isl_pw_multi_aff *pma;
6312
6313 pma = isl_pw_multi_aff_from_domain(set);
6314 *upma = isl_union_pw_multi_aff_add_pw_multi_aff(u: *upma, part: pma);
6315
6316 return isl_stat_ok;
6317}
6318
6319/* Return an isl_union_pw_multi_aff with the given "uset" as domain and
6320 * an unnamed zero-dimensional range.
6321 */
6322__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_from_domain(
6323 __isl_take isl_union_set *uset)
6324{
6325 isl_space *space;
6326 isl_union_pw_multi_aff *upma;
6327
6328 if (!uset)
6329 return NULL;
6330
6331 space = isl_union_set_get_space(uset);
6332 upma = isl_union_pw_multi_aff_empty(space);
6333
6334 if (isl_union_set_foreach_set(uset,
6335 fn: &add_pw_multi_aff_from_domain, user: &upma) < 0)
6336 goto error;
6337
6338 isl_union_set_free(uset);
6339 return upma;
6340error:
6341 isl_union_set_free(uset);
6342 isl_union_pw_multi_aff_free(u: upma);
6343 return NULL;
6344}
6345
6346/* Local data for bin_entry and the callback "fn".
6347 */
6348struct isl_union_pw_multi_aff_bin_data {
6349 isl_union_pw_multi_aff *upma2;
6350 isl_union_pw_multi_aff *res;
6351 isl_pw_multi_aff *pma;
6352 isl_stat (*fn)(__isl_take isl_pw_multi_aff *pma, void *user);
6353};
6354
6355/* Given an isl_pw_multi_aff from upma1, store it in data->pma
6356 * and call data->fn for each isl_pw_multi_aff in data->upma2.
6357 */
6358static isl_stat bin_entry(__isl_take isl_pw_multi_aff *pma, void *user)
6359{
6360 struct isl_union_pw_multi_aff_bin_data *data = user;
6361 isl_stat r;
6362
6363 data->pma = pma;
6364 r = isl_union_pw_multi_aff_foreach_pw_multi_aff(u: data->upma2,
6365 fn: data->fn, user: data);
6366 isl_pw_multi_aff_free(pw: pma);
6367
6368 return r;
6369}
6370
6371/* Call "fn" on each pair of isl_pw_multi_affs in "upma1" and "upma2".
6372 * The isl_pw_multi_aff from upma1 is stored in data->pma (where data is
6373 * passed as user field) and the isl_pw_multi_aff from upma2 is available
6374 * as *entry. The callback should adjust data->res if desired.
6375 */
6376static __isl_give isl_union_pw_multi_aff *bin_op(
6377 __isl_take isl_union_pw_multi_aff *upma1,
6378 __isl_take isl_union_pw_multi_aff *upma2,
6379 isl_stat (*fn)(__isl_take isl_pw_multi_aff *pma, void *user))
6380{
6381 isl_space *space;
6382 struct isl_union_pw_multi_aff_bin_data data = { NULL, NULL, NULL, fn };
6383
6384 space = isl_union_pw_multi_aff_get_space(u: upma2);
6385 upma1 = isl_union_pw_multi_aff_align_params(u: upma1, model: space);
6386 space = isl_union_pw_multi_aff_get_space(u: upma1);
6387 upma2 = isl_union_pw_multi_aff_align_params(u: upma2, model: space);
6388
6389 if (!upma1 || !upma2)
6390 goto error;
6391
6392 data.upma2 = upma2;
6393 data.res = isl_union_pw_multi_aff_alloc_same_size(u: upma1);
6394 if (isl_union_pw_multi_aff_foreach_pw_multi_aff(u: upma1,
6395 fn: &bin_entry, user: &data) < 0)
6396 goto error;
6397
6398 isl_union_pw_multi_aff_free(u: upma1);
6399 isl_union_pw_multi_aff_free(u: upma2);
6400 return data.res;
6401error:
6402 isl_union_pw_multi_aff_free(u: upma1);
6403 isl_union_pw_multi_aff_free(u: upma2);
6404 isl_union_pw_multi_aff_free(u: data.res);
6405 return NULL;
6406}
6407
6408/* Given two isl_pw_multi_affs A -> B and C -> D,
6409 * construct an isl_pw_multi_aff (A * C) -> [B -> D].
6410 */
6411__isl_give isl_pw_multi_aff *isl_pw_multi_aff_range_product(
6412 __isl_take isl_pw_multi_aff *pma1, __isl_take isl_pw_multi_aff *pma2)
6413{
6414 isl_space *space;
6415
6416 isl_pw_multi_aff_align_params_bin(obj1: &pma1, obj2: &pma2);
6417 space = isl_space_range_product(left: isl_pw_multi_aff_get_space(pw: pma1),
6418 right: isl_pw_multi_aff_get_space(pw: pma2));
6419 return isl_pw_multi_aff_on_shared_domain_in(pw1: pma1, pw2: pma2, space,
6420 fn: &isl_multi_aff_range_product);
6421}
6422
6423/* Given two isl_pw_multi_affs A -> B and C -> D,
6424 * construct an isl_pw_multi_aff (A * C) -> (B, D).
6425 */
6426__isl_give isl_pw_multi_aff *isl_pw_multi_aff_flat_range_product(
6427 __isl_take isl_pw_multi_aff *pma1, __isl_take isl_pw_multi_aff *pma2)
6428{
6429 isl_space *space;
6430
6431 isl_pw_multi_aff_align_params_bin(obj1: &pma1, obj2: &pma2);
6432 space = isl_space_range_product(left: isl_pw_multi_aff_get_space(pw: pma1),
6433 right: isl_pw_multi_aff_get_space(pw: pma2));
6434 space = isl_space_flatten_range(space);
6435 return isl_pw_multi_aff_on_shared_domain_in(pw1: pma1, pw2: pma2, space,
6436 fn: &isl_multi_aff_flat_range_product);
6437}
6438
6439/* If data->pma and "pma2" have the same domain space, then use "range_product"
6440 * to compute some form of range product and add the result to data->res.
6441 */
6442static isl_stat gen_range_product_entry(__isl_take isl_pw_multi_aff *pma2,
6443 __isl_give isl_pw_multi_aff *(*range_product)(
6444 __isl_take isl_pw_multi_aff *pma1,
6445 __isl_take isl_pw_multi_aff *pma2),
6446 void *user)
6447{
6448 struct isl_union_pw_multi_aff_bin_data *data = user;
6449 isl_bool match;
6450 isl_space *space1, *space2;
6451
6452 space1 = isl_pw_multi_aff_peek_space(pw: data->pma);
6453 space2 = isl_pw_multi_aff_peek_space(pw: pma2);
6454 match = isl_space_tuple_is_equal(space1, type1: isl_dim_in,
6455 space2, type2: isl_dim_in);
6456 if (match < 0 || !match) {
6457 isl_pw_multi_aff_free(pw: pma2);
6458 return match < 0 ? isl_stat_error : isl_stat_ok;
6459 }
6460
6461 pma2 = range_product(isl_pw_multi_aff_copy(pw: data->pma), pma2);
6462
6463 data->res = isl_union_pw_multi_aff_add_pw_multi_aff(u: data->res, part: pma2);
6464
6465 return isl_stat_ok;
6466}
6467
6468/* If data->pma and "pma2" have the same domain space, then compute
6469 * their flat range product and add the result to data->res.
6470 */
6471static isl_stat flat_range_product_entry(__isl_take isl_pw_multi_aff *pma2,
6472 void *user)
6473{
6474 return gen_range_product_entry(pma2,
6475 range_product: &isl_pw_multi_aff_flat_range_product, user);
6476}
6477
6478/* Given two isl_union_pw_multi_affs A -> B and C -> D,
6479 * construct an isl_union_pw_multi_aff (A * C) -> (B, D).
6480 */
6481__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_flat_range_product(
6482 __isl_take isl_union_pw_multi_aff *upma1,
6483 __isl_take isl_union_pw_multi_aff *upma2)
6484{
6485 return bin_op(upma1, upma2, fn: &flat_range_product_entry);
6486}
6487
6488/* If data->pma and "pma2" have the same domain space, then compute
6489 * their range product and add the result to data->res.
6490 */
6491static isl_stat range_product_entry(__isl_take isl_pw_multi_aff *pma2,
6492 void *user)
6493{
6494 return gen_range_product_entry(pma2,
6495 range_product: &isl_pw_multi_aff_range_product, user);
6496}
6497
6498/* Given two isl_union_pw_multi_affs A -> B and C -> D,
6499 * construct an isl_union_pw_multi_aff (A * C) -> [B -> D].
6500 */
6501__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_range_product(
6502 __isl_take isl_union_pw_multi_aff *upma1,
6503 __isl_take isl_union_pw_multi_aff *upma2)
6504{
6505 return bin_op(upma1, upma2, fn: &range_product_entry);
6506}
6507
6508/* Replace the affine expressions at position "pos" in "pma" by "pa".
6509 * The parameters are assumed to have been aligned.
6510 *
6511 * The implementation essentially performs an isl_pw_*_on_shared_domain,
6512 * except that it works on two different isl_pw_* types.
6513 */
6514static __isl_give isl_pw_multi_aff *pw_multi_aff_set_pw_aff(
6515 __isl_take isl_pw_multi_aff *pma, unsigned pos,
6516 __isl_take isl_pw_aff *pa)
6517{
6518 int i, j, n;
6519 isl_pw_multi_aff *res = NULL;
6520
6521 if (!pma || !pa)
6522 goto error;
6523
6524 if (!isl_space_tuple_is_equal(space1: pma->dim, type1: isl_dim_in,
6525 space2: pa->dim, type2: isl_dim_in))
6526 isl_die(isl_pw_multi_aff_get_ctx(pma), isl_error_invalid,
6527 "domains don't match", goto error);
6528 if (isl_pw_multi_aff_check_range(obj: pma, type: isl_dim_out, first: pos, n: 1) < 0)
6529 goto error;
6530
6531 n = pma->n * pa->n;
6532 res = isl_pw_multi_aff_alloc_size(space: isl_pw_multi_aff_get_space(pw: pma), n);
6533
6534 for (i = 0; i < pma->n; ++i) {
6535 for (j = 0; j < pa->n; ++j) {
6536 isl_set *common;
6537 isl_multi_aff *res_ij;
6538 int empty;
6539
6540 common = isl_set_intersect(set1: isl_set_copy(set: pma->p[i].set),
6541 set2: isl_set_copy(set: pa->p[j].set));
6542 empty = isl_set_plain_is_empty(set: common);
6543 if (empty < 0 || empty) {
6544 isl_set_free(set: common);
6545 if (empty < 0)
6546 goto error;
6547 continue;
6548 }
6549
6550 res_ij = isl_multi_aff_set_aff(
6551 multi: isl_multi_aff_copy(multi: pma->p[i].maff), pos,
6552 el: isl_aff_copy(aff: pa->p[j].aff));
6553 res_ij = isl_multi_aff_gist(multi: res_ij,
6554 context: isl_set_copy(set: common));
6555
6556 res = isl_pw_multi_aff_add_piece(pw: res, set: common, el: res_ij);
6557 }
6558 }
6559
6560 isl_pw_multi_aff_free(pw: pma);
6561 isl_pw_aff_free(pw: pa);
6562 return res;
6563error:
6564 isl_pw_multi_aff_free(pw: pma);
6565 isl_pw_aff_free(pw: pa);
6566 return isl_pw_multi_aff_free(pw: res);
6567}
6568
6569/* Replace the affine expressions at position "pos" in "pma" by "pa".
6570 */
6571__isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_pw_aff(
6572 __isl_take isl_pw_multi_aff *pma, unsigned pos,
6573 __isl_take isl_pw_aff *pa)
6574{
6575 isl_bool equal_params;
6576
6577 if (!pma || !pa)
6578 goto error;
6579 equal_params = isl_space_has_equal_params(space1: pma->dim, space2: pa->dim);
6580 if (equal_params < 0)
6581 goto error;
6582 if (equal_params)
6583 return pw_multi_aff_set_pw_aff(pma, pos, pa);
6584 if (isl_pw_multi_aff_check_named_params(obj: pma) < 0 ||
6585 isl_pw_aff_check_named_params(obj: pa) < 0)
6586 goto error;
6587 pma = isl_pw_multi_aff_align_params(pw: pma, model: isl_pw_aff_get_space(pw: pa));
6588 pa = isl_pw_aff_align_params(pw: pa, model: isl_pw_multi_aff_get_space(pw: pma));
6589 return pw_multi_aff_set_pw_aff(pma, pos, pa);
6590error:
6591 isl_pw_multi_aff_free(pw: pma);
6592 isl_pw_aff_free(pw: pa);
6593 return NULL;
6594}
6595
6596/* Do the parameters of "pa" match those of "space"?
6597 */
6598isl_bool isl_pw_aff_matching_params(__isl_keep isl_pw_aff *pa,
6599 __isl_keep isl_space *space)
6600{
6601 isl_space *pa_space;
6602 isl_bool match;
6603
6604 if (!pa || !space)
6605 return isl_bool_error;
6606
6607 pa_space = isl_pw_aff_get_space(pw: pa);
6608
6609 match = isl_space_has_equal_params(space1: space, space2: pa_space);
6610
6611 isl_space_free(space: pa_space);
6612 return match;
6613}
6614
6615/* Check that the domain space of "pa" matches "space".
6616 */
6617isl_stat isl_pw_aff_check_match_domain_space(__isl_keep isl_pw_aff *pa,
6618 __isl_keep isl_space *space)
6619{
6620 isl_space *pa_space;
6621 isl_bool match;
6622
6623 if (!pa || !space)
6624 return isl_stat_error;
6625
6626 pa_space = isl_pw_aff_get_space(pw: pa);
6627
6628 match = isl_space_has_equal_params(space1: space, space2: pa_space);
6629 if (match < 0)
6630 goto error;
6631 if (!match)
6632 isl_die(isl_pw_aff_get_ctx(pa), isl_error_invalid,
6633 "parameters don't match", goto error);
6634 match = isl_space_tuple_is_equal(space1: space, type1: isl_dim_in,
6635 space2: pa_space, type2: isl_dim_in);
6636 if (match < 0)
6637 goto error;
6638 if (!match)
6639 isl_die(isl_pw_aff_get_ctx(pa), isl_error_invalid,
6640 "domains don't match", goto error);
6641 isl_space_free(space: pa_space);
6642 return isl_stat_ok;
6643error:
6644 isl_space_free(space: pa_space);
6645 return isl_stat_error;
6646}
6647
6648#undef BASE
6649#define BASE pw_aff
6650#undef DOMBASE
6651#define DOMBASE set
6652
6653#include <isl_multi_explicit_domain.c>
6654#include <isl_multi_pw_aff_explicit_domain.c>
6655#include <isl_multi_templ.c>
6656#include <isl_multi_un_op_templ.c>
6657#include <isl_multi_bin_val_templ.c>
6658#include <isl_multi_add_constant_templ.c>
6659#include <isl_multi_apply_set.c>
6660#include <isl_multi_arith_templ.c>
6661#include <isl_multi_bind_templ.c>
6662#include <isl_multi_bind_domain_templ.c>
6663#include <isl_multi_coalesce.c>
6664#include <isl_multi_domain_templ.c>
6665#include <isl_multi_dim_id_templ.c>
6666#include <isl_multi_dims.c>
6667#include <isl_multi_from_base_templ.c>
6668#include <isl_multi_gist.c>
6669#include <isl_multi_hash.c>
6670#include <isl_multi_identity_templ.c>
6671#include <isl_multi_align_set.c>
6672#include <isl_multi_insert_domain_templ.c>
6673#include <isl_multi_intersect.c>
6674#include <isl_multi_min_max_templ.c>
6675#include <isl_multi_move_dims_templ.c>
6676#include <isl_multi_nan_templ.c>
6677#include <isl_multi_param_templ.c>
6678#include <isl_multi_product_templ.c>
6679#include <isl_multi_splice_templ.c>
6680#include <isl_multi_tuple_id_templ.c>
6681#include <isl_multi_union_add_templ.c>
6682#include <isl_multi_zero_templ.c>
6683#include <isl_multi_unbind_params_templ.c>
6684
6685/* Is every element of "mpa" defined over a single universe domain?
6686 */
6687isl_bool isl_multi_pw_aff_isa_multi_aff(__isl_keep isl_multi_pw_aff *mpa)
6688{
6689 return isl_multi_pw_aff_every(multi: mpa, test: &isl_pw_aff_isa_aff);
6690}
6691
6692/* Given that every element of "mpa" is defined over a single universe domain,
6693 * return the corresponding base expressions.
6694 */
6695__isl_give isl_multi_aff *isl_multi_pw_aff_as_multi_aff(
6696 __isl_take isl_multi_pw_aff *mpa)
6697{
6698 int i;
6699 isl_size n;
6700 isl_multi_aff *ma;
6701
6702 n = isl_multi_pw_aff_size(multi: mpa);
6703 if (n < 0)
6704 mpa = isl_multi_pw_aff_free(multi: mpa);
6705 ma = isl_multi_aff_alloc(space: isl_multi_pw_aff_get_space(multi: mpa));
6706 for (i = 0; i < n; ++i) {
6707 isl_aff *aff;
6708
6709 aff = isl_pw_aff_as_aff(pw: isl_multi_pw_aff_get_at(multi: mpa, pos: i));
6710 ma = isl_multi_aff_set_aff(multi: ma, pos: i, el: aff);
6711 }
6712 isl_multi_pw_aff_free(multi: mpa);
6713 return ma;
6714}
6715
6716/* If "mpa" has an explicit domain, then intersect the domain of "map"
6717 * with this explicit domain.
6718 */
6719__isl_give isl_map *isl_map_intersect_multi_pw_aff_explicit_domain(
6720 __isl_take isl_map *map, __isl_keep isl_multi_pw_aff *mpa)
6721{
6722 isl_set *dom;
6723
6724 if (!isl_multi_pw_aff_has_explicit_domain(multi: mpa))
6725 return map;
6726
6727 dom = isl_multi_pw_aff_domain(multi: isl_multi_pw_aff_copy(multi: mpa));
6728 map = isl_map_intersect_domain(map, set: dom);
6729
6730 return map;
6731}
6732
6733/* Are all elements of "mpa" piecewise constants?
6734 */
6735isl_bool isl_multi_pw_aff_is_cst(__isl_keep isl_multi_pw_aff *mpa)
6736{
6737 return isl_multi_pw_aff_every(multi: mpa, test: &isl_pw_aff_is_cst);
6738}
6739
6740/* Does "mpa" have a non-trivial explicit domain?
6741 *
6742 * The explicit domain, if present, is trivial if it represents
6743 * an (obviously) universe set.
6744 */
6745isl_bool isl_multi_pw_aff_has_non_trivial_domain(
6746 __isl_keep isl_multi_pw_aff *mpa)
6747{
6748 if (!mpa)
6749 return isl_bool_error;
6750 if (!isl_multi_pw_aff_has_explicit_domain(multi: mpa))
6751 return isl_bool_false;
6752 return isl_bool_not(b: isl_set_plain_is_universe(set: mpa->u.dom));
6753}
6754
6755#undef BASE
6756#define BASE set
6757
6758#include "isl_opt_mpa_templ.c"
6759
6760/* Compute the minima of the set dimensions as a function of the
6761 * parameters, but independently of the other set dimensions.
6762 */
6763__isl_give isl_multi_pw_aff *isl_set_min_multi_pw_aff(__isl_take isl_set *set)
6764{
6765 return set_opt_mpa(obj: set, opt: &isl_set_dim_min);
6766}
6767
6768/* Compute the maxima of the set dimensions as a function of the
6769 * parameters, but independently of the other set dimensions.
6770 */
6771__isl_give isl_multi_pw_aff *isl_set_max_multi_pw_aff(__isl_take isl_set *set)
6772{
6773 return set_opt_mpa(obj: set, opt: &isl_set_dim_max);
6774}
6775
6776#undef BASE
6777#define BASE map
6778
6779#include "isl_opt_mpa_templ.c"
6780
6781/* Compute the minima of the output dimensions as a function of the
6782 * parameters and input dimensions, but independently of
6783 * the other output dimensions.
6784 */
6785__isl_give isl_multi_pw_aff *isl_map_min_multi_pw_aff(__isl_take isl_map *map)
6786{
6787 return map_opt_mpa(obj: map, opt: &isl_map_dim_min);
6788}
6789
6790/* Compute the maxima of the output dimensions as a function of the
6791 * parameters and input dimensions, but independently of
6792 * the other output dimensions.
6793 */
6794__isl_give isl_multi_pw_aff *isl_map_max_multi_pw_aff(__isl_take isl_map *map)
6795{
6796 return map_opt_mpa(obj: map, opt: &isl_map_dim_max);
6797}
6798
6799#undef TYPE
6800#define TYPE isl_pw_multi_aff
6801#include "isl_type_check_match_range_multi_val.c"
6802
6803/* Apply "fn" to the base expressions of "pma" and "mv".
6804 */
6805static __isl_give isl_pw_multi_aff *isl_pw_multi_aff_op_multi_val(
6806 __isl_take isl_pw_multi_aff *pma, __isl_take isl_multi_val *mv,
6807 __isl_give isl_multi_aff *(*fn)(__isl_take isl_multi_aff *ma,
6808 __isl_take isl_multi_val *mv))
6809{
6810 int i;
6811 isl_size n;
6812
6813 if (isl_pw_multi_aff_check_match_range_multi_val(obj: pma, mv) < 0)
6814 goto error;
6815
6816 n = isl_pw_multi_aff_n_piece(pw: pma);
6817 if (n < 0)
6818 goto error;
6819
6820 for (i = 0; i < n; ++i) {
6821 isl_multi_aff *ma;
6822
6823 ma = isl_pw_multi_aff_take_base_at(pw: pma, pos: i);
6824 ma = fn(ma, isl_multi_val_copy(multi: mv));
6825 pma = isl_pw_multi_aff_restore_base_at(pw: pma, pos: i, el: ma);
6826 }
6827
6828 isl_multi_val_free(multi: mv);
6829 return pma;
6830error:
6831 isl_multi_val_free(multi: mv);
6832 isl_pw_multi_aff_free(pw: pma);
6833 return NULL;
6834}
6835
6836/* Scale the elements of "pma" by the corresponding elements of "mv".
6837 */
6838__isl_give isl_pw_multi_aff *isl_pw_multi_aff_scale_multi_val(
6839 __isl_take isl_pw_multi_aff *pma, __isl_take isl_multi_val *mv)
6840{
6841 return isl_pw_multi_aff_op_multi_val(pma, mv,
6842 fn: &isl_multi_aff_scale_multi_val);
6843}
6844
6845/* Scale the elements of "pma" down by the corresponding elements of "mv".
6846 */
6847__isl_give isl_pw_multi_aff *isl_pw_multi_aff_scale_down_multi_val(
6848 __isl_take isl_pw_multi_aff *pma, __isl_take isl_multi_val *mv)
6849{
6850 return isl_pw_multi_aff_op_multi_val(pma, mv,
6851 fn: &isl_multi_aff_scale_down_multi_val);
6852}
6853
6854/* This function is called for each entry of an isl_union_pw_multi_aff.
6855 * If the space of the entry matches that of data->mv,
6856 * then apply isl_pw_multi_aff_scale_multi_val and return the result.
6857 * Otherwise, return an empty isl_pw_multi_aff.
6858 */
6859static __isl_give isl_pw_multi_aff *union_pw_multi_aff_scale_multi_val_entry(
6860 __isl_take isl_pw_multi_aff *pma, void *user)
6861{
6862 isl_bool equal;
6863 isl_multi_val *mv = user;
6864
6865 equal = isl_pw_multi_aff_match_range_multi_val(obj: pma, mv);
6866 if (equal < 0)
6867 return isl_pw_multi_aff_free(pw: pma);
6868 if (!equal) {
6869 isl_space *space = isl_pw_multi_aff_get_space(pw: pma);
6870 isl_pw_multi_aff_free(pw: pma);
6871 return isl_pw_multi_aff_empty(space);
6872 }
6873
6874 return isl_pw_multi_aff_scale_multi_val(pma, mv: isl_multi_val_copy(multi: mv));
6875}
6876
6877/* Scale the elements of "upma" by the corresponding elements of "mv",
6878 * for those entries that match the space of "mv".
6879 */
6880__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_scale_multi_val(
6881 __isl_take isl_union_pw_multi_aff *upma, __isl_take isl_multi_val *mv)
6882{
6883 struct isl_union_pw_multi_aff_transform_control control = {
6884 .fn = &union_pw_multi_aff_scale_multi_val_entry,
6885 .fn_user = mv,
6886 };
6887
6888 upma = isl_union_pw_multi_aff_align_params(u: upma,
6889 model: isl_multi_val_get_space(multi: mv));
6890 mv = isl_multi_val_align_params(multi: mv,
6891 model: isl_union_pw_multi_aff_get_space(u: upma));
6892 if (!upma || !mv)
6893 goto error;
6894
6895 return isl_union_pw_multi_aff_transform(u: upma, control: &control);
6896
6897 isl_multi_val_free(multi: mv);
6898 return upma;
6899error:
6900 isl_multi_val_free(multi: mv);
6901 isl_union_pw_multi_aff_free(u: upma);
6902 return NULL;
6903}
6904
6905/* Construct and return a piecewise multi affine expression
6906 * in the given space with value zero in each of the output dimensions and
6907 * a universe domain.
6908 */
6909__isl_give isl_pw_multi_aff *isl_pw_multi_aff_zero(__isl_take isl_space *space)
6910{
6911 return isl_pw_multi_aff_from_multi_aff(el: isl_multi_aff_zero(space));
6912}
6913
6914/* Construct and return a piecewise multi affine expression
6915 * that is equal to the given piecewise affine expression.
6916 */
6917__isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_pw_aff(
6918 __isl_take isl_pw_aff *pa)
6919{
6920 int i;
6921 isl_space *space;
6922 isl_pw_multi_aff *pma;
6923
6924 if (!pa)
6925 return NULL;
6926
6927 space = isl_pw_aff_get_space(pw: pa);
6928 pma = isl_pw_multi_aff_alloc_size(space, n: pa->n);
6929
6930 for (i = 0; i < pa->n; ++i) {
6931 isl_set *set;
6932 isl_multi_aff *ma;
6933
6934 set = isl_set_copy(set: pa->p[i].set);
6935 ma = isl_multi_aff_from_aff(el: isl_aff_copy(aff: pa->p[i].aff));
6936 pma = isl_pw_multi_aff_add_piece(pw: pma, set, el: ma);
6937 }
6938
6939 isl_pw_aff_free(pw: pa);
6940 return pma;
6941}
6942
6943/* Construct and return a piecewise multi affine expression
6944 * that is equal to the given multi piecewise affine expression
6945 * on the shared domain of the piecewise affine expressions,
6946 * in the special case of a 0D multi piecewise affine expression.
6947 *
6948 * Create a piecewise multi affine expression with the explicit domain of
6949 * the 0D multi piecewise affine expression as domain.
6950 */
6951static __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_multi_pw_aff_0D(
6952 __isl_take isl_multi_pw_aff *mpa)
6953{
6954 isl_space *space;
6955 isl_set *dom;
6956 isl_multi_aff *ma;
6957
6958 space = isl_multi_pw_aff_get_space(multi: mpa);
6959 dom = isl_multi_pw_aff_get_explicit_domain(multi: mpa);
6960 isl_multi_pw_aff_free(multi: mpa);
6961
6962 ma = isl_multi_aff_zero(space);
6963 return isl_pw_multi_aff_alloc(set: dom, el: ma);
6964}
6965
6966/* Construct and return a piecewise multi affine expression
6967 * that is equal to the given multi piecewise affine expression
6968 * on the shared domain of the piecewise affine expressions.
6969 */
6970__isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_multi_pw_aff(
6971 __isl_take isl_multi_pw_aff *mpa)
6972{
6973 int i;
6974 isl_space *space;
6975 isl_pw_aff *pa;
6976 isl_pw_multi_aff *pma;
6977
6978 if (!mpa)
6979 return NULL;
6980
6981 if (mpa->n == 0)
6982 return isl_pw_multi_aff_from_multi_pw_aff_0D(mpa);
6983
6984 space = isl_multi_pw_aff_get_space(multi: mpa);
6985 pa = isl_multi_pw_aff_get_pw_aff(multi: mpa, pos: 0);
6986 pma = isl_pw_multi_aff_from_pw_aff(pa);
6987
6988 for (i = 1; i < mpa->n; ++i) {
6989 isl_pw_multi_aff *pma_i;
6990
6991 pa = isl_multi_pw_aff_get_pw_aff(multi: mpa, pos: i);
6992 pma_i = isl_pw_multi_aff_from_pw_aff(pa);
6993 pma = isl_pw_multi_aff_range_product(pma1: pma, pma2: pma_i);
6994 }
6995
6996 pma = isl_pw_multi_aff_reset_space(pw: pma, space);
6997
6998 isl_multi_pw_aff_free(multi: mpa);
6999 return pma;
7000}
7001
7002/* Convenience function that constructs an isl_multi_pw_aff
7003 * directly from an isl_aff.
7004 */
7005__isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_aff(__isl_take isl_aff *aff)
7006{
7007 return isl_multi_pw_aff_from_pw_aff(el: isl_pw_aff_from_aff(el: aff));
7008}
7009
7010/* Construct and return a multi piecewise affine expression
7011 * that is equal to the given multi affine expression.
7012 */
7013__isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_multi_aff(
7014 __isl_take isl_multi_aff *ma)
7015{
7016 int i;
7017 isl_size n;
7018 isl_multi_pw_aff *mpa;
7019
7020 n = isl_multi_aff_dim(multi: ma, type: isl_dim_out);
7021 if (n < 0)
7022 ma = isl_multi_aff_free(multi: ma);
7023 if (!ma)
7024 return NULL;
7025
7026 mpa = isl_multi_pw_aff_alloc(space: isl_multi_aff_get_space(multi: ma));
7027
7028 for (i = 0; i < n; ++i) {
7029 isl_pw_aff *pa;
7030
7031 pa = isl_pw_aff_from_aff(el: isl_multi_aff_get_aff(multi: ma, pos: i));
7032 mpa = isl_multi_pw_aff_set_pw_aff(multi: mpa, pos: i, el: pa);
7033 }
7034
7035 isl_multi_aff_free(multi: ma);
7036 return mpa;
7037}
7038
7039/* This function performs the same operation as isl_multi_pw_aff_from_multi_aff,
7040 * but is considered as a function on an isl_multi_aff when exported.
7041 */
7042__isl_give isl_multi_pw_aff *isl_multi_aff_to_multi_pw_aff(
7043 __isl_take isl_multi_aff *ma)
7044{
7045 return isl_multi_pw_aff_from_multi_aff(ma);
7046}
7047
7048/* Construct and return a multi piecewise affine expression
7049 * that is equal to the given piecewise multi affine expression.
7050 *
7051 * If the resulting multi piecewise affine expression has
7052 * an explicit domain, then assign it the domain of the input.
7053 * In other cases, the domain is stored in the individual elements.
7054 */
7055__isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_pw_multi_aff(
7056 __isl_take isl_pw_multi_aff *pma)
7057{
7058 int i;
7059 isl_size n;
7060 isl_space *space;
7061 isl_multi_pw_aff *mpa;
7062
7063 n = isl_pw_multi_aff_dim(pw: pma, type: isl_dim_out);
7064 if (n < 0)
7065 pma = isl_pw_multi_aff_free(pw: pma);
7066 space = isl_pw_multi_aff_get_space(pw: pma);
7067 mpa = isl_multi_pw_aff_alloc(space);
7068
7069 for (i = 0; i < n; ++i) {
7070 isl_pw_aff *pa;
7071
7072 pa = isl_pw_multi_aff_get_pw_aff(pma, pos: i);
7073 mpa = isl_multi_pw_aff_set_pw_aff(multi: mpa, pos: i, el: pa);
7074 }
7075 if (isl_multi_pw_aff_has_explicit_domain(multi: mpa)) {
7076 isl_set *dom;
7077
7078 dom = isl_pw_multi_aff_domain(pw: isl_pw_multi_aff_copy(pw: pma));
7079 mpa = isl_multi_pw_aff_intersect_domain(multi: mpa, domain: dom);
7080 }
7081
7082 isl_pw_multi_aff_free(pw: pma);
7083 return mpa;
7084}
7085
7086/* This function performs the same operation as
7087 * isl_multi_pw_aff_from_pw_multi_aff,
7088 * but is considered as a function on an isl_pw_multi_aff when exported.
7089 */
7090__isl_give isl_multi_pw_aff *isl_pw_multi_aff_to_multi_pw_aff(
7091 __isl_take isl_pw_multi_aff *pma)
7092{
7093 return isl_multi_pw_aff_from_pw_multi_aff(pma);
7094}
7095
7096/* Do "pa1" and "pa2" represent the same function?
7097 *
7098 * We first check if they are obviously equal.
7099 * If not, we convert them to maps and check if those are equal.
7100 *
7101 * If "pa1" or "pa2" contain any NaNs, then they are considered
7102 * not to be the same. A NaN is not equal to anything, not even
7103 * to another NaN.
7104 */
7105isl_bool isl_pw_aff_is_equal(__isl_keep isl_pw_aff *pa1,
7106 __isl_keep isl_pw_aff *pa2)
7107{
7108 isl_bool equal;
7109 isl_bool has_nan;
7110 isl_map *map1, *map2;
7111
7112 if (!pa1 || !pa2)
7113 return isl_bool_error;
7114
7115 equal = isl_pw_aff_plain_is_equal(pw1: pa1, pw2: pa2);
7116 if (equal < 0 || equal)
7117 return equal;
7118 has_nan = either_involves_nan(pa1, pa2);
7119 if (has_nan < 0)
7120 return isl_bool_error;
7121 if (has_nan)
7122 return isl_bool_false;
7123
7124 map1 = isl_map_from_pw_aff_internal(pa: isl_pw_aff_copy(pw: pa1));
7125 map2 = isl_map_from_pw_aff_internal(pa: isl_pw_aff_copy(pw: pa2));
7126 equal = isl_map_is_equal(map1, map2);
7127 isl_map_free(map: map1);
7128 isl_map_free(map: map2);
7129
7130 return equal;
7131}
7132
7133/* Do "mpa1" and "mpa2" represent the same function?
7134 *
7135 * Note that we cannot convert the entire isl_multi_pw_aff
7136 * to a map because the domains of the piecewise affine expressions
7137 * may not be the same.
7138 */
7139isl_bool isl_multi_pw_aff_is_equal(__isl_keep isl_multi_pw_aff *mpa1,
7140 __isl_keep isl_multi_pw_aff *mpa2)
7141{
7142 int i;
7143 isl_bool equal, equal_params;
7144
7145 if (!mpa1 || !mpa2)
7146 return isl_bool_error;
7147
7148 equal_params = isl_space_has_equal_params(space1: mpa1->space, space2: mpa2->space);
7149 if (equal_params < 0)
7150 return isl_bool_error;
7151 if (!equal_params) {
7152 if (!isl_space_has_named_params(space: mpa1->space))
7153 return isl_bool_false;
7154 if (!isl_space_has_named_params(space: mpa2->space))
7155 return isl_bool_false;
7156 mpa1 = isl_multi_pw_aff_copy(multi: mpa1);
7157 mpa2 = isl_multi_pw_aff_copy(multi: mpa2);
7158 mpa1 = isl_multi_pw_aff_align_params(multi: mpa1,
7159 model: isl_multi_pw_aff_get_space(multi: mpa2));
7160 mpa2 = isl_multi_pw_aff_align_params(multi: mpa2,
7161 model: isl_multi_pw_aff_get_space(multi: mpa1));
7162 equal = isl_multi_pw_aff_is_equal(mpa1, mpa2);
7163 isl_multi_pw_aff_free(multi: mpa1);
7164 isl_multi_pw_aff_free(multi: mpa2);
7165 return equal;
7166 }
7167
7168 equal = isl_space_is_equal(space1: mpa1->space, space2: mpa2->space);
7169 if (equal < 0 || !equal)
7170 return equal;
7171
7172 for (i = 0; i < mpa1->n; ++i) {
7173 equal = isl_pw_aff_is_equal(pa1: mpa1->u.p[i], pa2: mpa2->u.p[i]);
7174 if (equal < 0 || !equal)
7175 return equal;
7176 }
7177
7178 return isl_bool_true;
7179}
7180
7181/* Do "pma1" and "pma2" represent the same function?
7182 *
7183 * First check if they are obviously equal.
7184 * If not, then convert them to maps and check if those are equal.
7185 *
7186 * If "pa1" or "pa2" contain any NaNs, then they are considered
7187 * not to be the same. A NaN is not equal to anything, not even
7188 * to another NaN.
7189 */
7190isl_bool isl_pw_multi_aff_is_equal(__isl_keep isl_pw_multi_aff *pma1,
7191 __isl_keep isl_pw_multi_aff *pma2)
7192{
7193 isl_bool equal;
7194 isl_bool has_nan;
7195 isl_map *map1, *map2;
7196
7197 if (!pma1 || !pma2)
7198 return isl_bool_error;
7199
7200 equal = isl_pw_multi_aff_plain_is_equal(pw1: pma1, pw2: pma2);
7201 if (equal < 0 || equal)
7202 return equal;
7203 has_nan = isl_pw_multi_aff_involves_nan(pw: pma1);
7204 if (has_nan >= 0 && !has_nan)
7205 has_nan = isl_pw_multi_aff_involves_nan(pw: pma2);
7206 if (has_nan < 0 || has_nan)
7207 return isl_bool_not(b: has_nan);
7208
7209 map1 = isl_map_from_pw_multi_aff_internal(pma: isl_pw_multi_aff_copy(pw: pma1));
7210 map2 = isl_map_from_pw_multi_aff_internal(pma: isl_pw_multi_aff_copy(pw: pma2));
7211 equal = isl_map_is_equal(map1, map2);
7212 isl_map_free(map: map1);
7213 isl_map_free(map: map2);
7214
7215 return equal;
7216}
7217
7218#undef BASE
7219#define BASE multi_aff
7220
7221#include "isl_multi_pw_aff_pullback_templ.c"
7222
7223#undef BASE
7224#define BASE pw_multi_aff
7225
7226#include "isl_multi_pw_aff_pullback_templ.c"
7227
7228/* Apply "aff" to "mpa". The range of "mpa" needs to be compatible
7229 * with the domain of "aff". The domain of the result is the same
7230 * as that of "mpa".
7231 * "mpa" and "aff" are assumed to have been aligned.
7232 *
7233 * We first extract the parametric constant from "aff", defined
7234 * over the correct domain.
7235 * Then we add the appropriate combinations of the members of "mpa".
7236 * Finally, we add the integer divisions through recursive calls.
7237 */
7238static __isl_give isl_pw_aff *isl_multi_pw_aff_apply_aff_aligned(
7239 __isl_take isl_multi_pw_aff *mpa, __isl_take isl_aff *aff)
7240{
7241 int i;
7242 isl_size n_in, n_div, n_mpa_in;
7243 isl_space *space;
7244 isl_val *v;
7245 isl_pw_aff *pa;
7246 isl_aff *tmp;
7247
7248 n_in = isl_aff_dim(aff, type: isl_dim_in);
7249 n_div = isl_aff_dim(aff, type: isl_dim_div);
7250 n_mpa_in = isl_multi_pw_aff_dim(multi: mpa, type: isl_dim_in);
7251 if (n_in < 0 || n_div < 0 || n_mpa_in < 0)
7252 goto error;
7253
7254 space = isl_space_domain(space: isl_multi_pw_aff_get_space(multi: mpa));
7255 tmp = isl_aff_copy(aff);
7256 tmp = isl_aff_drop_dims(aff: tmp, type: isl_dim_div, first: 0, n: n_div);
7257 tmp = isl_aff_drop_dims(aff: tmp, type: isl_dim_in, first: 0, n: n_in);
7258 tmp = isl_aff_add_dims(aff: tmp, type: isl_dim_in, n: n_mpa_in);
7259 tmp = isl_aff_reset_domain_space(aff: tmp, space);
7260 pa = isl_pw_aff_from_aff(el: tmp);
7261
7262 for (i = 0; i < n_in; ++i) {
7263 isl_pw_aff *pa_i;
7264
7265 if (!isl_aff_involves_dims(aff, type: isl_dim_in, first: i, n: 1))
7266 continue;
7267 v = isl_aff_get_coefficient_val(aff, type: isl_dim_in, pos: i);
7268 pa_i = isl_multi_pw_aff_get_pw_aff(multi: mpa, pos: i);
7269 pa_i = isl_pw_aff_scale_val(pw: pa_i, v);
7270 pa = isl_pw_aff_add(pwaff1: pa, pwaff2: pa_i);
7271 }
7272
7273 for (i = 0; i < n_div; ++i) {
7274 isl_aff *div;
7275 isl_pw_aff *pa_i;
7276
7277 if (!isl_aff_involves_dims(aff, type: isl_dim_div, first: i, n: 1))
7278 continue;
7279 div = isl_aff_get_div(aff, pos: i);
7280 pa_i = isl_multi_pw_aff_apply_aff_aligned(
7281 mpa: isl_multi_pw_aff_copy(multi: mpa), aff: div);
7282 pa_i = isl_pw_aff_floor(pwaff: pa_i);
7283 v = isl_aff_get_coefficient_val(aff, type: isl_dim_div, pos: i);
7284 pa_i = isl_pw_aff_scale_val(pw: pa_i, v);
7285 pa = isl_pw_aff_add(pwaff1: pa, pwaff2: pa_i);
7286 }
7287
7288 isl_multi_pw_aff_free(multi: mpa);
7289 isl_aff_free(aff);
7290
7291 return pa;
7292error:
7293 isl_multi_pw_aff_free(multi: mpa);
7294 isl_aff_free(aff);
7295 return NULL;
7296}
7297
7298/* Apply "aff" to "mpa". The range of "mpa" needs to be compatible
7299 * with the domain of "aff". The domain of the result is the same
7300 * as that of "mpa".
7301 */
7302__isl_give isl_pw_aff *isl_multi_pw_aff_apply_aff(
7303 __isl_take isl_multi_pw_aff *mpa, __isl_take isl_aff *aff)
7304{
7305 isl_bool equal_params;
7306
7307 if (!aff || !mpa)
7308 goto error;
7309 equal_params = isl_space_has_equal_params(space1: aff->ls->dim, space2: mpa->space);
7310 if (equal_params < 0)
7311 goto error;
7312 if (equal_params)
7313 return isl_multi_pw_aff_apply_aff_aligned(mpa, aff);
7314
7315 aff = isl_aff_align_params(aff, model: isl_multi_pw_aff_get_space(multi: mpa));
7316 mpa = isl_multi_pw_aff_align_params(multi: mpa, model: isl_aff_get_space(aff));
7317
7318 return isl_multi_pw_aff_apply_aff_aligned(mpa, aff);
7319error:
7320 isl_aff_free(aff);
7321 isl_multi_pw_aff_free(multi: mpa);
7322 return NULL;
7323}
7324
7325/* Apply "pa" to "mpa". The range of "mpa" needs to be compatible
7326 * with the domain of "pa". The domain of the result is the same
7327 * as that of "mpa".
7328 * "mpa" and "pa" are assumed to have been aligned.
7329 *
7330 * We consider each piece in turn. Note that the domains of the
7331 * pieces are assumed to be disjoint and they remain disjoint
7332 * after taking the preimage (over the same function).
7333 */
7334static __isl_give isl_pw_aff *isl_multi_pw_aff_apply_pw_aff_aligned(
7335 __isl_take isl_multi_pw_aff *mpa, __isl_take isl_pw_aff *pa)
7336{
7337 isl_space *space;
7338 isl_pw_aff *res;
7339 int i;
7340
7341 if (!mpa || !pa)
7342 goto error;
7343
7344 space = isl_space_join(left: isl_multi_pw_aff_get_space(multi: mpa),
7345 right: isl_pw_aff_get_space(pw: pa));
7346 res = isl_pw_aff_empty(space);
7347
7348 for (i = 0; i < pa->n; ++i) {
7349 isl_pw_aff *pa_i;
7350 isl_set *domain;
7351
7352 pa_i = isl_multi_pw_aff_apply_aff_aligned(
7353 mpa: isl_multi_pw_aff_copy(multi: mpa),
7354 aff: isl_aff_copy(aff: pa->p[i].aff));
7355 domain = isl_set_copy(set: pa->p[i].set);
7356 domain = isl_set_preimage_multi_pw_aff(set: domain,
7357 mpa: isl_multi_pw_aff_copy(multi: mpa));
7358 pa_i = isl_pw_aff_intersect_domain(pw: pa_i, context: domain);
7359 res = isl_pw_aff_add_disjoint(pw1: res, pw2: pa_i);
7360 }
7361
7362 isl_pw_aff_free(pw: pa);
7363 isl_multi_pw_aff_free(multi: mpa);
7364 return res;
7365error:
7366 isl_pw_aff_free(pw: pa);
7367 isl_multi_pw_aff_free(multi: mpa);
7368 return NULL;
7369}
7370
7371/* Apply "pa" to "mpa". The range of "mpa" needs to be compatible
7372 * with the domain of "pa". The domain of the result is the same
7373 * as that of "mpa".
7374 */
7375__isl_give isl_pw_aff *isl_multi_pw_aff_apply_pw_aff(
7376 __isl_take isl_multi_pw_aff *mpa, __isl_take isl_pw_aff *pa)
7377{
7378 isl_bool equal_params;
7379
7380 if (!pa || !mpa)
7381 goto error;
7382 equal_params = isl_space_has_equal_params(space1: pa->dim, space2: mpa->space);
7383 if (equal_params < 0)
7384 goto error;
7385 if (equal_params)
7386 return isl_multi_pw_aff_apply_pw_aff_aligned(mpa, pa);
7387
7388 pa = isl_pw_aff_align_params(pw: pa, model: isl_multi_pw_aff_get_space(multi: mpa));
7389 mpa = isl_multi_pw_aff_align_params(multi: mpa, model: isl_pw_aff_get_space(pw: pa));
7390
7391 return isl_multi_pw_aff_apply_pw_aff_aligned(mpa, pa);
7392error:
7393 isl_pw_aff_free(pw: pa);
7394 isl_multi_pw_aff_free(multi: mpa);
7395 return NULL;
7396}
7397
7398/* Compute the pullback of "pa" by the function represented by "mpa".
7399 * In other words, plug in "mpa" in "pa".
7400 *
7401 * The pullback is computed by applying "pa" to "mpa".
7402 */
7403__isl_give isl_pw_aff *isl_pw_aff_pullback_multi_pw_aff(
7404 __isl_take isl_pw_aff *pa, __isl_take isl_multi_pw_aff *mpa)
7405{
7406 return isl_multi_pw_aff_apply_pw_aff(mpa, pa);
7407}
7408
7409#undef BASE
7410#define BASE multi_pw_aff
7411
7412#include "isl_multi_pw_aff_pullback_templ.c"
7413
7414/* Align the parameters of "mpa1" and "mpa2", check that the ranges
7415 * of "mpa1" and "mpa2" live in the same space, construct map space
7416 * between the domain spaces of "mpa1" and "mpa2" and call "order"
7417 * with this map space as extract argument.
7418 */
7419static __isl_give isl_map *isl_multi_pw_aff_order_map(
7420 __isl_take isl_multi_pw_aff *mpa1, __isl_take isl_multi_pw_aff *mpa2,
7421 __isl_give isl_map *(*order)(__isl_keep isl_multi_pw_aff *mpa1,
7422 __isl_keep isl_multi_pw_aff *mpa2, __isl_take isl_space *space))
7423{
7424 int match;
7425 isl_space *space1, *space2;
7426 isl_map *res;
7427
7428 mpa1 = isl_multi_pw_aff_align_params(multi: mpa1,
7429 model: isl_multi_pw_aff_get_space(multi: mpa2));
7430 mpa2 = isl_multi_pw_aff_align_params(multi: mpa2,
7431 model: isl_multi_pw_aff_get_space(multi: mpa1));
7432 if (!mpa1 || !mpa2)
7433 goto error;
7434 match = isl_space_tuple_is_equal(space1: mpa1->space, type1: isl_dim_out,
7435 space2: mpa2->space, type2: isl_dim_out);
7436 if (match < 0)
7437 goto error;
7438 if (!match)
7439 isl_die(isl_multi_pw_aff_get_ctx(mpa1), isl_error_invalid,
7440 "range spaces don't match", goto error);
7441 space1 = isl_space_domain(space: isl_multi_pw_aff_get_space(multi: mpa1));
7442 space2 = isl_space_domain(space: isl_multi_pw_aff_get_space(multi: mpa2));
7443 space1 = isl_space_map_from_domain_and_range(domain: space1, range: space2);
7444
7445 res = order(mpa1, mpa2, space1);
7446 isl_multi_pw_aff_free(multi: mpa1);
7447 isl_multi_pw_aff_free(multi: mpa2);
7448 return res;
7449error:
7450 isl_multi_pw_aff_free(multi: mpa1);
7451 isl_multi_pw_aff_free(multi: mpa2);
7452 return NULL;
7453}
7454
7455/* Return a map containing pairs of elements in the domains of "mpa1" and "mpa2"
7456 * where the function values are equal. "space" is the space of the result.
7457 * The parameters of "mpa1" and "mpa2" are assumed to have been aligned.
7458 *
7459 * "mpa1" and "mpa2" are equal when each of the pairs of elements
7460 * in the sequences are equal.
7461 */
7462static __isl_give isl_map *isl_multi_pw_aff_eq_map_on_space(
7463 __isl_keep isl_multi_pw_aff *mpa1, __isl_keep isl_multi_pw_aff *mpa2,
7464 __isl_take isl_space *space)
7465{
7466 int i;
7467 isl_size n;
7468 isl_map *res;
7469
7470 n = isl_multi_pw_aff_dim(multi: mpa1, type: isl_dim_out);
7471 if (n < 0)
7472 space = isl_space_free(space);
7473 res = isl_map_universe(space);
7474
7475 for (i = 0; i < n; ++i) {
7476 isl_pw_aff *pa1, *pa2;
7477 isl_map *map;
7478
7479 pa1 = isl_multi_pw_aff_get_pw_aff(multi: mpa1, pos: i);
7480 pa2 = isl_multi_pw_aff_get_pw_aff(multi: mpa2, pos: i);
7481 map = isl_pw_aff_eq_map(pa1, pa2);
7482 res = isl_map_intersect(map1: res, map2: map);
7483 }
7484
7485 return res;
7486}
7487
7488/* Return a map containing pairs of elements in the domains of "mpa1" and "mpa2"
7489 * where the function values are equal.
7490 */
7491__isl_give isl_map *isl_multi_pw_aff_eq_map(__isl_take isl_multi_pw_aff *mpa1,
7492 __isl_take isl_multi_pw_aff *mpa2)
7493{
7494 return isl_multi_pw_aff_order_map(mpa1, mpa2,
7495 order: &isl_multi_pw_aff_eq_map_on_space);
7496}
7497
7498/* Intersect "map" with the result of applying "order"
7499 * on two copies of "mpa".
7500 */
7501static __isl_give isl_map *isl_map_order_at_multi_pw_aff(
7502 __isl_take isl_map *map, __isl_take isl_multi_pw_aff *mpa,
7503 __isl_give isl_map *(*order)(__isl_take isl_multi_pw_aff *mpa1,
7504 __isl_take isl_multi_pw_aff *mpa2))
7505{
7506 return isl_map_intersect(map1: map, map2: order(mpa, isl_multi_pw_aff_copy(multi: mpa)));
7507}
7508
7509/* Return the subset of "map" where the domain and the range
7510 * have equal "mpa" values.
7511 */
7512__isl_give isl_map *isl_map_eq_at_multi_pw_aff(__isl_take isl_map *map,
7513 __isl_take isl_multi_pw_aff *mpa)
7514{
7515 return isl_map_order_at_multi_pw_aff(map, mpa,
7516 order: &isl_multi_pw_aff_eq_map);
7517}
7518
7519/* Return a map containing pairs of elements in the domains of "mpa1" and "mpa2"
7520 * where the function values of "mpa1" lexicographically satisfies
7521 * "strict_base"/"base" compared to that of "mpa2".
7522 * "space" is the space of the result.
7523 * The parameters of "mpa1" and "mpa2" are assumed to have been aligned.
7524 *
7525 * "mpa1" lexicographically satisfies "strict_base"/"base" compared to "mpa2"
7526 * if, for some i, the i-th element of "mpa1" satisfies "strict_base"/"base"
7527 * when compared to the i-th element of "mpa2" while all previous elements are
7528 * pairwise equal.
7529 * In particular, if i corresponds to the final elements
7530 * then they need to satisfy "base", while "strict_base" needs to be satisfied
7531 * for other values of i.
7532 * If "base" is a strict order, then "base" and "strict_base" are the same.
7533 */
7534static __isl_give isl_map *isl_multi_pw_aff_lex_map_on_space(
7535 __isl_keep isl_multi_pw_aff *mpa1, __isl_keep isl_multi_pw_aff *mpa2,
7536 __isl_give isl_map *(*strict_base)(__isl_take isl_pw_aff *pa1,
7537 __isl_take isl_pw_aff *pa2),
7538 __isl_give isl_map *(*base)(__isl_take isl_pw_aff *pa1,
7539 __isl_take isl_pw_aff *pa2),
7540 __isl_take isl_space *space)
7541{
7542 int i;
7543 isl_size n;
7544 isl_map *res, *rest;
7545
7546 n = isl_multi_pw_aff_dim(multi: mpa1, type: isl_dim_out);
7547 if (n < 0)
7548 space = isl_space_free(space);
7549 res = isl_map_empty(space: isl_space_copy(space));
7550 rest = isl_map_universe(space);
7551
7552 for (i = 0; i < n; ++i) {
7553 int last;
7554 isl_pw_aff *pa1, *pa2;
7555 isl_map *map;
7556
7557 last = i == n - 1;
7558
7559 pa1 = isl_multi_pw_aff_get_pw_aff(multi: mpa1, pos: i);
7560 pa2 = isl_multi_pw_aff_get_pw_aff(multi: mpa2, pos: i);
7561 map = last ? base(pa1, pa2) : strict_base(pa1, pa2);
7562 map = isl_map_intersect(map1: map, map2: isl_map_copy(map: rest));
7563 res = isl_map_union(map1: res, map2: map);
7564
7565 if (last)
7566 continue;
7567
7568 pa1 = isl_multi_pw_aff_get_pw_aff(multi: mpa1, pos: i);
7569 pa2 = isl_multi_pw_aff_get_pw_aff(multi: mpa2, pos: i);
7570 map = isl_pw_aff_eq_map(pa1, pa2);
7571 rest = isl_map_intersect(map1: rest, map2: map);
7572 }
7573
7574 isl_map_free(map: rest);
7575 return res;
7576}
7577
7578#undef ORDER
7579#define ORDER le
7580#undef STRICT_ORDER
7581#define STRICT_ORDER lt
7582#include "isl_aff_lex_templ.c"
7583
7584#undef ORDER
7585#define ORDER lt
7586#undef STRICT_ORDER
7587#define STRICT_ORDER lt
7588#include "isl_aff_lex_templ.c"
7589
7590#undef ORDER
7591#define ORDER ge
7592#undef STRICT_ORDER
7593#define STRICT_ORDER gt
7594#include "isl_aff_lex_templ.c"
7595
7596#undef ORDER
7597#define ORDER gt
7598#undef STRICT_ORDER
7599#define STRICT_ORDER gt
7600#include "isl_aff_lex_templ.c"
7601
7602/* Compare two isl_affs.
7603 *
7604 * Return -1 if "aff1" is "smaller" than "aff2", 1 if "aff1" is "greater"
7605 * than "aff2" and 0 if they are equal.
7606 *
7607 * The order is fairly arbitrary. We do consider expressions that only involve
7608 * earlier dimensions as "smaller".
7609 */
7610int isl_aff_plain_cmp(__isl_keep isl_aff *aff1, __isl_keep isl_aff *aff2)
7611{
7612 int cmp;
7613 int last1, last2;
7614
7615 if (aff1 == aff2)
7616 return 0;
7617
7618 if (!aff1)
7619 return -1;
7620 if (!aff2)
7621 return 1;
7622
7623 cmp = isl_local_space_cmp(ls1: aff1->ls, ls2: aff2->ls);
7624 if (cmp != 0)
7625 return cmp;
7626
7627 last1 = isl_seq_last_non_zero(p: aff1->v->el + 1, len: aff1->v->size - 1);
7628 last2 = isl_seq_last_non_zero(p: aff2->v->el + 1, len: aff1->v->size - 1);
7629 if (last1 != last2)
7630 return last1 - last2;
7631
7632 return isl_seq_cmp(p1: aff1->v->el, p2: aff2->v->el, len: aff1->v->size);
7633}
7634
7635/* Compare two isl_pw_affs.
7636 *
7637 * Return -1 if "pa1" is "smaller" than "pa2", 1 if "pa1" is "greater"
7638 * than "pa2" and 0 if they are equal.
7639 *
7640 * The order is fairly arbitrary. We do consider expressions that only involve
7641 * earlier dimensions as "smaller".
7642 */
7643int isl_pw_aff_plain_cmp(__isl_keep isl_pw_aff *pa1,
7644 __isl_keep isl_pw_aff *pa2)
7645{
7646 int i;
7647 int cmp;
7648
7649 if (pa1 == pa2)
7650 return 0;
7651
7652 if (!pa1)
7653 return -1;
7654 if (!pa2)
7655 return 1;
7656
7657 cmp = isl_space_cmp(space1: pa1->dim, space2: pa2->dim);
7658 if (cmp != 0)
7659 return cmp;
7660
7661 if (pa1->n != pa2->n)
7662 return pa1->n - pa2->n;
7663
7664 for (i = 0; i < pa1->n; ++i) {
7665 cmp = isl_set_plain_cmp(set1: pa1->p[i].set, set2: pa2->p[i].set);
7666 if (cmp != 0)
7667 return cmp;
7668 cmp = isl_aff_plain_cmp(aff1: pa1->p[i].aff, aff2: pa2->p[i].aff);
7669 if (cmp != 0)
7670 return cmp;
7671 }
7672
7673 return 0;
7674}
7675
7676/* Return a piecewise affine expression that is equal to "v" on "domain".
7677 */
7678__isl_give isl_pw_aff *isl_pw_aff_val_on_domain(__isl_take isl_set *domain,
7679 __isl_take isl_val *v)
7680{
7681 isl_space *space;
7682 isl_local_space *ls;
7683 isl_aff *aff;
7684
7685 space = isl_set_get_space(set: domain);
7686 ls = isl_local_space_from_space(space);
7687 aff = isl_aff_val_on_domain(ls, val: v);
7688
7689 return isl_pw_aff_alloc(set: domain, el: aff);
7690}
7691
7692/* This function performs the same operation as isl_pw_aff_val_on_domain,
7693 * but is considered as a function on an isl_set when exported.
7694 */
7695__isl_give isl_pw_aff *isl_set_pw_aff_on_domain_val(__isl_take isl_set *domain,
7696 __isl_take isl_val *v)
7697{
7698 return isl_pw_aff_val_on_domain(domain, v);
7699}
7700
7701/* Return a piecewise affine expression that is equal to the parameter
7702 * with identifier "id" on "domain".
7703 */
7704__isl_give isl_pw_aff *isl_pw_aff_param_on_domain_id(
7705 __isl_take isl_set *domain, __isl_take isl_id *id)
7706{
7707 isl_space *space;
7708 isl_aff *aff;
7709
7710 space = isl_set_get_space(set: domain);
7711 space = isl_space_add_param_id(space, id: isl_id_copy(id));
7712 domain = isl_set_align_params(set: domain, model: isl_space_copy(space));
7713 aff = isl_aff_param_on_domain_space_id(space, id);
7714
7715 return isl_pw_aff_alloc(set: domain, el: aff);
7716}
7717
7718/* This function performs the same operation as
7719 * isl_pw_aff_param_on_domain_id,
7720 * but is considered as a function on an isl_set when exported.
7721 */
7722__isl_give isl_pw_aff *isl_set_param_pw_aff_on_domain_id(
7723 __isl_take isl_set *domain, __isl_take isl_id *id)
7724{
7725 return isl_pw_aff_param_on_domain_id(domain, id);
7726}
7727
7728/* Return a multi affine expression that is equal to "mv" on domain
7729 * space "space".
7730 */
7731__isl_give isl_multi_aff *isl_multi_aff_multi_val_on_domain_space(
7732 __isl_take isl_space *space, __isl_take isl_multi_val *mv)
7733{
7734 int i;
7735 isl_size n;
7736 isl_space *space2;
7737 isl_local_space *ls;
7738 isl_multi_aff *ma;
7739
7740 n = isl_multi_val_dim(multi: mv, type: isl_dim_set);
7741 if (!space || n < 0)
7742 goto error;
7743
7744 space2 = isl_multi_val_get_space(multi: mv);
7745 space2 = isl_space_align_params(space1: space2, space2: isl_space_copy(space));
7746 space = isl_space_align_params(space1: space, space2: isl_space_copy(space: space2));
7747 space = isl_space_map_from_domain_and_range(domain: space, range: space2);
7748 ma = isl_multi_aff_alloc(space: isl_space_copy(space));
7749 ls = isl_local_space_from_space(space: isl_space_domain(space));
7750 for (i = 0; i < n; ++i) {
7751 isl_val *v;
7752 isl_aff *aff;
7753
7754 v = isl_multi_val_get_val(multi: mv, pos: i);
7755 aff = isl_aff_val_on_domain(ls: isl_local_space_copy(ls), val: v);
7756 ma = isl_multi_aff_set_aff(multi: ma, pos: i, el: aff);
7757 }
7758 isl_local_space_free(ls);
7759
7760 isl_multi_val_free(multi: mv);
7761 return ma;
7762error:
7763 isl_space_free(space);
7764 isl_multi_val_free(multi: mv);
7765 return NULL;
7766}
7767
7768/* This is an alternative name for the function above.
7769 */
7770__isl_give isl_multi_aff *isl_multi_aff_multi_val_on_space(
7771 __isl_take isl_space *space, __isl_take isl_multi_val *mv)
7772{
7773 return isl_multi_aff_multi_val_on_domain_space(space, mv);
7774}
7775
7776/* This function performs the same operation as
7777 * isl_multi_aff_multi_val_on_domain_space,
7778 * but is considered as a function on an isl_space when exported.
7779 */
7780__isl_give isl_multi_aff *isl_space_multi_aff_on_domain_multi_val(
7781 __isl_take isl_space *space, __isl_take isl_multi_val *mv)
7782{
7783 return isl_multi_aff_multi_val_on_domain_space(space, mv);
7784}
7785
7786/* Return a piecewise multi-affine expression
7787 * that is equal to "mv" on "domain".
7788 */
7789__isl_give isl_pw_multi_aff *isl_pw_multi_aff_multi_val_on_domain(
7790 __isl_take isl_set *domain, __isl_take isl_multi_val *mv)
7791{
7792 isl_space *space;
7793 isl_multi_aff *ma;
7794
7795 space = isl_set_get_space(set: domain);
7796 ma = isl_multi_aff_multi_val_on_space(space, mv);
7797
7798 return isl_pw_multi_aff_alloc(set: domain, el: ma);
7799}
7800
7801/* This function performs the same operation as
7802 * isl_pw_multi_aff_multi_val_on_domain,
7803 * but is considered as a function on an isl_set when exported.
7804 */
7805__isl_give isl_pw_multi_aff *isl_set_pw_multi_aff_on_domain_multi_val(
7806 __isl_take isl_set *domain, __isl_take isl_multi_val *mv)
7807{
7808 return isl_pw_multi_aff_multi_val_on_domain(domain, mv);
7809}
7810
7811/* Internal data structure for isl_union_pw_multi_aff_multi_val_on_domain.
7812 * mv is the value that should be attained on each domain set
7813 * res collects the results
7814 */
7815struct isl_union_pw_multi_aff_multi_val_on_domain_data {
7816 isl_multi_val *mv;
7817 isl_union_pw_multi_aff *res;
7818};
7819
7820/* Create an isl_pw_multi_aff equal to data->mv on "domain"
7821 * and add it to data->res.
7822 */
7823static isl_stat pw_multi_aff_multi_val_on_domain(__isl_take isl_set *domain,
7824 void *user)
7825{
7826 struct isl_union_pw_multi_aff_multi_val_on_domain_data *data = user;
7827 isl_pw_multi_aff *pma;
7828 isl_multi_val *mv;
7829
7830 mv = isl_multi_val_copy(multi: data->mv);
7831 pma = isl_pw_multi_aff_multi_val_on_domain(domain, mv);
7832 data->res = isl_union_pw_multi_aff_add_pw_multi_aff(u: data->res, part: pma);
7833
7834 return data->res ? isl_stat_ok : isl_stat_error;
7835}
7836
7837/* Return a union piecewise multi-affine expression
7838 * that is equal to "mv" on "domain".
7839 */
7840__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_multi_val_on_domain(
7841 __isl_take isl_union_set *domain, __isl_take isl_multi_val *mv)
7842{
7843 struct isl_union_pw_multi_aff_multi_val_on_domain_data data;
7844 isl_space *space;
7845
7846 space = isl_union_set_get_space(uset: domain);
7847 data.res = isl_union_pw_multi_aff_empty(space);
7848 data.mv = mv;
7849 if (isl_union_set_foreach_set(uset: domain,
7850 fn: &pw_multi_aff_multi_val_on_domain, user: &data) < 0)
7851 data.res = isl_union_pw_multi_aff_free(u: data.res);
7852 isl_union_set_free(uset: domain);
7853 isl_multi_val_free(multi: mv);
7854 return data.res;
7855}
7856
7857/* Compute the pullback of data->pma by the function represented by "pma2",
7858 * provided the spaces match, and add the results to data->res.
7859 */
7860static isl_stat pullback_entry(__isl_take isl_pw_multi_aff *pma2, void *user)
7861{
7862 struct isl_union_pw_multi_aff_bin_data *data = user;
7863
7864 if (!isl_space_tuple_is_equal(space1: data->pma->dim, type1: isl_dim_in,
7865 space2: pma2->dim, type2: isl_dim_out)) {
7866 isl_pw_multi_aff_free(pw: pma2);
7867 return isl_stat_ok;
7868 }
7869
7870 pma2 = isl_pw_multi_aff_pullback_pw_multi_aff(
7871 pw: isl_pw_multi_aff_copy(pw: data->pma), pma: pma2);
7872
7873 data->res = isl_union_pw_multi_aff_add_pw_multi_aff(u: data->res, part: pma2);
7874 if (!data->res)
7875 return isl_stat_error;
7876
7877 return isl_stat_ok;
7878}
7879
7880/* Compute the pullback of "upma1" by the function represented by "upma2".
7881 */
7882__isl_give isl_union_pw_multi_aff *
7883isl_union_pw_multi_aff_pullback_union_pw_multi_aff(
7884 __isl_take isl_union_pw_multi_aff *upma1,
7885 __isl_take isl_union_pw_multi_aff *upma2)
7886{
7887 return bin_op(upma1, upma2, fn: &pullback_entry);
7888}
7889
7890/* Apply "upma2" to "upma1".
7891 *
7892 * That is, compute the pullback of "upma2" by "upma1".
7893 */
7894__isl_give isl_union_pw_multi_aff *
7895isl_union_pw_multi_aff_apply_union_pw_multi_aff(
7896 __isl_take isl_union_pw_multi_aff *upma1,
7897 __isl_take isl_union_pw_multi_aff *upma2)
7898{
7899 return isl_union_pw_multi_aff_pullback_union_pw_multi_aff(upma1: upma2, upma2: upma1);
7900}
7901
7902#undef TYPE
7903#define TYPE isl_pw_multi_aff
7904static
7905#include "isl_copy_tuple_id_templ.c"
7906
7907/* Given a function "pma1" of the form A[B -> C] -> D and
7908 * a function "pma2" of the form E -> B,
7909 * replace the domain of the wrapped relation inside the domain of "pma1"
7910 * by the preimage with respect to "pma2".
7911 * In other words, plug in "pma2" in this nested domain.
7912 * The result is of the form A[E -> C] -> D.
7913 *
7914 * In particular, extend E -> B to A[E -> C] -> A[B -> C] and
7915 * plug that into "pma1".
7916 */
7917__isl_give isl_pw_multi_aff *
7918isl_pw_multi_aff_preimage_domain_wrapped_domain_pw_multi_aff(
7919 __isl_take isl_pw_multi_aff *pma1, __isl_take isl_pw_multi_aff *pma2)
7920{
7921 isl_space *pma1_space, *pma2_space;
7922 isl_space *space;
7923 isl_pw_multi_aff *id;
7924
7925 pma1_space = isl_pw_multi_aff_peek_space(pw: pma1);
7926 pma2_space = isl_pw_multi_aff_peek_space(pw: pma2);
7927
7928 if (isl_space_check_domain_is_wrapping(space: pma1_space) < 0)
7929 goto error;
7930 if (isl_space_check_wrapped_tuple_is_equal(space1: pma1_space,
7931 outer: isl_dim_in, inner: isl_dim_in, space2: pma2_space, type2: isl_dim_out) < 0)
7932 goto error;
7933
7934 space = isl_space_domain(space: isl_space_copy(space: pma1_space));
7935 space = isl_space_range(space: isl_space_unwrap(space));
7936 id = isl_pw_multi_aff_identity_on_domain_space(space);
7937 pma2 = isl_pw_multi_aff_product(pma1: pma2, pma2: id);
7938
7939 pma2 = isl_pw_multi_aff_copy_tuple_id(dst: pma2, dst_type: isl_dim_in,
7940 src: pma1_space, src_type: isl_dim_in);
7941 pma2 = isl_pw_multi_aff_copy_tuple_id(dst: pma2, dst_type: isl_dim_out,
7942 src: pma1_space, src_type: isl_dim_in);
7943
7944 return isl_pw_multi_aff_pullback_pw_multi_aff(pw: pma1, pma: pma2);
7945error:
7946 isl_pw_multi_aff_free(pw: pma1);
7947 isl_pw_multi_aff_free(pw: pma2);
7948 return NULL;
7949}
7950
7951/* If data->pma and "pma2" are such that
7952 * data->pma is of the form A[B -> C] -> D and
7953 * "pma2" is of the form E -> B,
7954 * then replace the domain of the wrapped relation
7955 * inside the domain of data->pma by the preimage with respect to "pma2" and
7956 * add the result to data->res.
7957 */
7958static isl_stat preimage_domain_wrapped_domain_entry(
7959 __isl_take isl_pw_multi_aff *pma2, void *user)
7960{
7961 struct isl_union_pw_multi_aff_bin_data *data = user;
7962 isl_space *pma1_space, *pma2_space;
7963 isl_bool match;
7964
7965 pma1_space = isl_pw_multi_aff_peek_space(pw: data->pma);
7966 pma2_space = isl_pw_multi_aff_peek_space(pw: pma2);
7967
7968 match = isl_space_domain_is_wrapping(space: pma1_space);
7969 if (match >= 0 && match)
7970 match = isl_space_wrapped_tuple_is_equal(space1: pma1_space, outer: isl_dim_in,
7971 inner: isl_dim_in, space2: pma2_space, type2: isl_dim_out);
7972 if (match < 0 || !match) {
7973 isl_pw_multi_aff_free(pw: pma2);
7974 return match < 0 ? isl_stat_error : isl_stat_ok;
7975 }
7976
7977 pma2 = isl_pw_multi_aff_preimage_domain_wrapped_domain_pw_multi_aff(
7978 pma1: isl_pw_multi_aff_copy(pw: data->pma), pma2);
7979
7980 data->res = isl_union_pw_multi_aff_add_pw_multi_aff(u: data->res, part: pma2);
7981
7982 return isl_stat_non_null(obj: data->res);
7983}
7984
7985/* For each pair of functions A[B -> C] -> D in "upma1" and
7986 * E -> B in "upma2",
7987 * replace the domain of the wrapped relation inside the domain of the first
7988 * by the preimage with respect to the second and collect the results.
7989 * In other words, plug in the second function in this nested domain.
7990 * The results are of the form A[E -> C] -> D.
7991 */
7992__isl_give isl_union_pw_multi_aff *
7993isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff(
7994 __isl_take isl_union_pw_multi_aff *upma1,
7995 __isl_take isl_union_pw_multi_aff *upma2)
7996{
7997 return bin_op(upma1, upma2, fn: &preimage_domain_wrapped_domain_entry);
7998}
7999
8000/* Check that the domain space of "upa" matches "space".
8001 *
8002 * This function is called from isl_multi_union_pw_aff_set_union_pw_aff and
8003 * can in principle never fail since the space "space" is that
8004 * of the isl_multi_union_pw_aff and is a set space such that
8005 * there is no domain space to match.
8006 *
8007 * We check the parameters and double-check that "space" is
8008 * indeed that of a set.
8009 */
8010static isl_stat isl_union_pw_aff_check_match_domain_space(
8011 __isl_keep isl_union_pw_aff *upa, __isl_keep isl_space *space)
8012{
8013 isl_space *upa_space;
8014 isl_bool match;
8015
8016 if (!upa || !space)
8017 return isl_stat_error;
8018
8019 match = isl_space_is_set(space);
8020 if (match < 0)
8021 return isl_stat_error;
8022 if (!match)
8023 isl_die(isl_space_get_ctx(space), isl_error_invalid,
8024 "expecting set space", return isl_stat_error);
8025
8026 upa_space = isl_union_pw_aff_get_space(u: upa);
8027 match = isl_space_has_equal_params(space1: space, space2: upa_space);
8028 if (match < 0)
8029 goto error;
8030 if (!match)
8031 isl_die(isl_space_get_ctx(space), isl_error_invalid,
8032 "parameters don't match", goto error);
8033
8034 isl_space_free(space: upa_space);
8035 return isl_stat_ok;
8036error:
8037 isl_space_free(space: upa_space);
8038 return isl_stat_error;
8039}
8040
8041/* Do the parameters of "upa" match those of "space"?
8042 */
8043static isl_bool isl_union_pw_aff_matching_params(
8044 __isl_keep isl_union_pw_aff *upa, __isl_keep isl_space *space)
8045{
8046 isl_space *upa_space;
8047 isl_bool match;
8048
8049 if (!upa || !space)
8050 return isl_bool_error;
8051
8052 upa_space = isl_union_pw_aff_get_space(u: upa);
8053
8054 match = isl_space_has_equal_params(space1: space, space2: upa_space);
8055
8056 isl_space_free(space: upa_space);
8057 return match;
8058}
8059
8060/* Internal data structure for isl_union_pw_aff_reset_domain_space.
8061 * space represents the new parameters.
8062 * res collects the results.
8063 */
8064struct isl_union_pw_aff_reset_params_data {
8065 isl_space *space;
8066 isl_union_pw_aff *res;
8067};
8068
8069/* Replace the parameters of "pa" by data->space and
8070 * add the result to data->res.
8071 */
8072static isl_stat reset_params(__isl_take isl_pw_aff *pa, void *user)
8073{
8074 struct isl_union_pw_aff_reset_params_data *data = user;
8075 isl_space *space;
8076
8077 space = isl_pw_aff_get_space(pw: pa);
8078 space = isl_space_replace_params(dst: space, src: data->space);
8079 pa = isl_pw_aff_reset_space(pw: pa, space);
8080 data->res = isl_union_pw_aff_add_pw_aff(u: data->res, part: pa);
8081
8082 return data->res ? isl_stat_ok : isl_stat_error;
8083}
8084
8085/* Replace the domain space of "upa" by "space".
8086 * Since a union expression does not have a (single) domain space,
8087 * "space" is necessarily a parameter space.
8088 *
8089 * Since the order and the names of the parameters determine
8090 * the hash value, we need to create a new hash table.
8091 */
8092static __isl_give isl_union_pw_aff *isl_union_pw_aff_reset_domain_space(
8093 __isl_take isl_union_pw_aff *upa, __isl_take isl_space *space)
8094{
8095 struct isl_union_pw_aff_reset_params_data data = { space };
8096 isl_bool match;
8097
8098 match = isl_union_pw_aff_matching_params(upa, space);
8099 if (match < 0)
8100 upa = isl_union_pw_aff_free(u: upa);
8101 else if (match) {
8102 isl_space_free(space);
8103 return upa;
8104 }
8105
8106 data.res = isl_union_pw_aff_empty(space: isl_space_copy(space));
8107 if (isl_union_pw_aff_foreach_pw_aff(u: upa, fn: &reset_params, user: &data) < 0)
8108 data.res = isl_union_pw_aff_free(u: data.res);
8109
8110 isl_union_pw_aff_free(u: upa);
8111 isl_space_free(space);
8112 return data.res;
8113}
8114
8115/* Return the floor of "pa".
8116 */
8117static __isl_give isl_pw_aff *floor_entry(__isl_take isl_pw_aff *pa, void *user)
8118{
8119 return isl_pw_aff_floor(pwaff: pa);
8120}
8121
8122/* Given f, return floor(f).
8123 */
8124__isl_give isl_union_pw_aff *isl_union_pw_aff_floor(
8125 __isl_take isl_union_pw_aff *upa)
8126{
8127 return isl_union_pw_aff_transform_inplace(u: upa, fn: &floor_entry, NULL);
8128}
8129
8130/* Compute
8131 *
8132 * upa mod m = upa - m * floor(upa/m)
8133 *
8134 * with m an integer value.
8135 */
8136__isl_give isl_union_pw_aff *isl_union_pw_aff_mod_val(
8137 __isl_take isl_union_pw_aff *upa, __isl_take isl_val *m)
8138{
8139 isl_union_pw_aff *res;
8140
8141 if (!upa || !m)
8142 goto error;
8143
8144 if (!isl_val_is_int(v: m))
8145 isl_die(isl_val_get_ctx(m), isl_error_invalid,
8146 "expecting integer modulo", goto error);
8147 if (!isl_val_is_pos(v: m))
8148 isl_die(isl_val_get_ctx(m), isl_error_invalid,
8149 "expecting positive modulo", goto error);
8150
8151 res = isl_union_pw_aff_copy(u: upa);
8152 upa = isl_union_pw_aff_scale_down_val(u: upa, v: isl_val_copy(v: m));
8153 upa = isl_union_pw_aff_floor(upa);
8154 upa = isl_union_pw_aff_scale_val(u: upa, v: m);
8155 res = isl_union_pw_aff_sub(u1: res, u2: upa);
8156
8157 return res;
8158error:
8159 isl_val_free(v: m);
8160 isl_union_pw_aff_free(u: upa);
8161 return NULL;
8162}
8163
8164/* Internal data structure for isl_union_pw_multi_aff_get_union_pw_aff.
8165 * pos is the output position that needs to be extracted.
8166 * res collects the results.
8167 */
8168struct isl_union_pw_multi_aff_get_union_pw_aff_data {
8169 int pos;
8170 isl_union_pw_aff *res;
8171};
8172
8173/* Extract an isl_pw_aff corresponding to output dimension "pos" of "pma"
8174 * (assuming it has such a dimension) and add it to data->res.
8175 */
8176static isl_stat get_union_pw_aff(__isl_take isl_pw_multi_aff *pma, void *user)
8177{
8178 struct isl_union_pw_multi_aff_get_union_pw_aff_data *data = user;
8179 isl_size n_out;
8180 isl_pw_aff *pa;
8181
8182 n_out = isl_pw_multi_aff_dim(pw: pma, type: isl_dim_out);
8183 if (n_out < 0)
8184 return isl_stat_error;
8185 if (data->pos >= n_out) {
8186 isl_pw_multi_aff_free(pw: pma);
8187 return isl_stat_ok;
8188 }
8189
8190 pa = isl_pw_multi_aff_get_pw_aff(pma, pos: data->pos);
8191 isl_pw_multi_aff_free(pw: pma);
8192
8193 data->res = isl_union_pw_aff_add_pw_aff(u: data->res, part: pa);
8194
8195 return data->res ? isl_stat_ok : isl_stat_error;
8196}
8197
8198/* Extract an isl_union_pw_aff corresponding to
8199 * output dimension "pos" of "upma".
8200 */
8201__isl_give isl_union_pw_aff *isl_union_pw_multi_aff_get_union_pw_aff(
8202 __isl_keep isl_union_pw_multi_aff *upma, int pos)
8203{
8204 struct isl_union_pw_multi_aff_get_union_pw_aff_data data;
8205 isl_space *space;
8206
8207 if (!upma)
8208 return NULL;
8209
8210 if (pos < 0)
8211 isl_die(isl_union_pw_multi_aff_get_ctx(upma), isl_error_invalid,
8212 "cannot extract at negative position", return NULL);
8213
8214 space = isl_union_pw_multi_aff_get_space(u: upma);
8215 data.res = isl_union_pw_aff_empty(space);
8216 data.pos = pos;
8217 if (isl_union_pw_multi_aff_foreach_pw_multi_aff(u: upma,
8218 fn: &get_union_pw_aff, user: &data) < 0)
8219 data.res = isl_union_pw_aff_free(u: data.res);
8220
8221 return data.res;
8222}
8223
8224/* Return a union piecewise affine expression
8225 * that is equal to "aff" on "domain".
8226 */
8227__isl_give isl_union_pw_aff *isl_union_pw_aff_aff_on_domain(
8228 __isl_take isl_union_set *domain, __isl_take isl_aff *aff)
8229{
8230 isl_pw_aff *pa;
8231
8232 pa = isl_pw_aff_from_aff(el: aff);
8233 return isl_union_pw_aff_pw_aff_on_domain(domain, pa);
8234}
8235
8236/* Return a union piecewise affine expression
8237 * that is equal to the parameter identified by "id" on "domain".
8238 *
8239 * Make sure the parameter appears in the space passed to
8240 * isl_aff_param_on_domain_space_id.
8241 */
8242__isl_give isl_union_pw_aff *isl_union_pw_aff_param_on_domain_id(
8243 __isl_take isl_union_set *domain, __isl_take isl_id *id)
8244{
8245 isl_space *space;
8246 isl_aff *aff;
8247
8248 space = isl_union_set_get_space(uset: domain);
8249 space = isl_space_add_param_id(space, id: isl_id_copy(id));
8250 aff = isl_aff_param_on_domain_space_id(space, id);
8251 return isl_union_pw_aff_aff_on_domain(domain, aff);
8252}
8253
8254/* Internal data structure for isl_union_pw_aff_pw_aff_on_domain.
8255 * "pa" is the piecewise symbolic value that the resulting isl_union_pw_aff
8256 * needs to attain.
8257 * "res" collects the results.
8258 */
8259struct isl_union_pw_aff_pw_aff_on_domain_data {
8260 isl_pw_aff *pa;
8261 isl_union_pw_aff *res;
8262};
8263
8264/* Construct a piecewise affine expression that is equal to data->pa
8265 * on "domain" and add the result to data->res.
8266 */
8267static isl_stat pw_aff_on_domain(__isl_take isl_set *domain, void *user)
8268{
8269 struct isl_union_pw_aff_pw_aff_on_domain_data *data = user;
8270 isl_pw_aff *pa;
8271 isl_size dim;
8272
8273 pa = isl_pw_aff_copy(pw: data->pa);
8274 dim = isl_set_dim(set: domain, type: isl_dim_set);
8275 if (dim < 0)
8276 pa = isl_pw_aff_free(pw: pa);
8277 pa = isl_pw_aff_from_range(obj: pa);
8278 pa = isl_pw_aff_add_dims(pw: pa, type: isl_dim_in, n: dim);
8279 pa = isl_pw_aff_reset_domain_space(pw: pa, domain: isl_set_get_space(set: domain));
8280 pa = isl_pw_aff_intersect_domain(pw: pa, context: domain);
8281 data->res = isl_union_pw_aff_add_pw_aff(u: data->res, part: pa);
8282
8283 return data->res ? isl_stat_ok : isl_stat_error;
8284}
8285
8286/* Return a union piecewise affine expression
8287 * that is equal to "pa" on "domain", assuming "domain" and "pa"
8288 * have been aligned.
8289 *
8290 * Construct an isl_pw_aff on each of the sets in "domain" and
8291 * collect the results.
8292 */
8293static __isl_give isl_union_pw_aff *isl_union_pw_aff_pw_aff_on_domain_aligned(
8294 __isl_take isl_union_set *domain, __isl_take isl_pw_aff *pa)
8295{
8296 struct isl_union_pw_aff_pw_aff_on_domain_data data;
8297 isl_space *space;
8298
8299 space = isl_union_set_get_space(uset: domain);
8300 data.res = isl_union_pw_aff_empty(space);
8301 data.pa = pa;
8302 if (isl_union_set_foreach_set(uset: domain, fn: &pw_aff_on_domain, user: &data) < 0)
8303 data.res = isl_union_pw_aff_free(u: data.res);
8304 isl_union_set_free(uset: domain);
8305 isl_pw_aff_free(pw: pa);
8306 return data.res;
8307}
8308
8309/* Return a union piecewise affine expression
8310 * that is equal to "pa" on "domain".
8311 *
8312 * Check that "pa" is a parametric expression,
8313 * align the parameters if needed and call
8314 * isl_union_pw_aff_pw_aff_on_domain_aligned.
8315 */
8316__isl_give isl_union_pw_aff *isl_union_pw_aff_pw_aff_on_domain(
8317 __isl_take isl_union_set *domain, __isl_take isl_pw_aff *pa)
8318{
8319 isl_bool is_set;
8320 isl_bool equal_params;
8321 isl_space *domain_space, *pa_space;
8322
8323 pa_space = isl_pw_aff_peek_space(pw: pa);
8324 is_set = isl_space_is_set(space: pa_space);
8325 if (is_set < 0)
8326 goto error;
8327 if (!is_set)
8328 isl_die(isl_pw_aff_get_ctx(pa), isl_error_invalid,
8329 "expecting parametric expression", goto error);
8330
8331 domain_space = isl_union_set_get_space(uset: domain);
8332 pa_space = isl_pw_aff_get_space(pw: pa);
8333 equal_params = isl_space_has_equal_params(space1: domain_space, space2: pa_space);
8334 if (equal_params >= 0 && !equal_params) {
8335 isl_space *space;
8336
8337 space = isl_space_align_params(space1: domain_space, space2: pa_space);
8338 pa = isl_pw_aff_align_params(pw: pa, model: isl_space_copy(space));
8339 domain = isl_union_set_align_params(uset: domain, model: space);
8340 } else {
8341 isl_space_free(space: domain_space);
8342 isl_space_free(space: pa_space);
8343 }
8344
8345 if (equal_params < 0)
8346 goto error;
8347 return isl_union_pw_aff_pw_aff_on_domain_aligned(domain, pa);
8348error:
8349 isl_union_set_free(uset: domain);
8350 isl_pw_aff_free(pw: pa);
8351 return NULL;
8352}
8353
8354/* Internal data structure for isl_union_pw_aff_val_on_domain.
8355 * "v" is the value that the resulting isl_union_pw_aff needs to attain.
8356 * "res" collects the results.
8357 */
8358struct isl_union_pw_aff_val_on_domain_data {
8359 isl_val *v;
8360 isl_union_pw_aff *res;
8361};
8362
8363/* Construct a piecewise affine expression that is equal to data->v
8364 * on "domain" and add the result to data->res.
8365 */
8366static isl_stat pw_aff_val_on_domain(__isl_take isl_set *domain, void *user)
8367{
8368 struct isl_union_pw_aff_val_on_domain_data *data = user;
8369 isl_pw_aff *pa;
8370 isl_val *v;
8371
8372 v = isl_val_copy(v: data->v);
8373 pa = isl_pw_aff_val_on_domain(domain, v);
8374 data->res = isl_union_pw_aff_add_pw_aff(u: data->res, part: pa);
8375
8376 return data->res ? isl_stat_ok : isl_stat_error;
8377}
8378
8379/* Return a union piecewise affine expression
8380 * that is equal to "v" on "domain".
8381 *
8382 * Construct an isl_pw_aff on each of the sets in "domain" and
8383 * collect the results.
8384 */
8385__isl_give isl_union_pw_aff *isl_union_pw_aff_val_on_domain(
8386 __isl_take isl_union_set *domain, __isl_take isl_val *v)
8387{
8388 struct isl_union_pw_aff_val_on_domain_data data;
8389 isl_space *space;
8390
8391 space = isl_union_set_get_space(uset: domain);
8392 data.res = isl_union_pw_aff_empty(space);
8393 data.v = v;
8394 if (isl_union_set_foreach_set(uset: domain, fn: &pw_aff_val_on_domain, user: &data) < 0)
8395 data.res = isl_union_pw_aff_free(u: data.res);
8396 isl_union_set_free(uset: domain);
8397 isl_val_free(v);
8398 return data.res;
8399}
8400
8401/* Construct a piecewise multi affine expression
8402 * that is equal to "pa" and add it to upma.
8403 */
8404static isl_stat pw_multi_aff_from_pw_aff_entry(__isl_take isl_pw_aff *pa,
8405 void *user)
8406{
8407 isl_union_pw_multi_aff **upma = user;
8408 isl_pw_multi_aff *pma;
8409
8410 pma = isl_pw_multi_aff_from_pw_aff(pa);
8411 *upma = isl_union_pw_multi_aff_add_pw_multi_aff(u: *upma, part: pma);
8412
8413 return *upma ? isl_stat_ok : isl_stat_error;
8414}
8415
8416/* Construct and return a union piecewise multi affine expression
8417 * that is equal to the given union piecewise affine expression.
8418 */
8419__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_from_union_pw_aff(
8420 __isl_take isl_union_pw_aff *upa)
8421{
8422 isl_space *space;
8423 isl_union_pw_multi_aff *upma;
8424
8425 if (!upa)
8426 return NULL;
8427
8428 space = isl_union_pw_aff_get_space(u: upa);
8429 upma = isl_union_pw_multi_aff_empty(space);
8430
8431 if (isl_union_pw_aff_foreach_pw_aff(u: upa,
8432 fn: &pw_multi_aff_from_pw_aff_entry, user: &upma) < 0)
8433 upma = isl_union_pw_multi_aff_free(u: upma);
8434
8435 isl_union_pw_aff_free(u: upa);
8436 return upma;
8437}
8438
8439/* Compute the set of elements in the domain of "pa" where it is zero and
8440 * add this set to "uset".
8441 */
8442static isl_stat zero_union_set(__isl_take isl_pw_aff *pa, void *user)
8443{
8444 isl_union_set **uset = (isl_union_set **)user;
8445
8446 *uset = isl_union_set_add_set(uset: *uset, set: isl_pw_aff_zero_set(pwaff: pa));
8447
8448 return *uset ? isl_stat_ok : isl_stat_error;
8449}
8450
8451/* Return a union set containing those elements in the domain
8452 * of "upa" where it is zero.
8453 */
8454__isl_give isl_union_set *isl_union_pw_aff_zero_union_set(
8455 __isl_take isl_union_pw_aff *upa)
8456{
8457 isl_union_set *zero;
8458
8459 zero = isl_union_set_empty(space: isl_union_pw_aff_get_space(u: upa));
8460 if (isl_union_pw_aff_foreach_pw_aff(u: upa, fn: &zero_union_set, user: &zero) < 0)
8461 zero = isl_union_set_free(uset: zero);
8462
8463 isl_union_pw_aff_free(u: upa);
8464 return zero;
8465}
8466
8467/* Internal data structure for isl_union_pw_aff_bind_id,
8468 * storing the parameter that needs to be bound and
8469 * the accumulated results.
8470 */
8471struct isl_bind_id_data {
8472 isl_id *id;
8473 isl_union_set *bound;
8474};
8475
8476/* Bind the piecewise affine function "pa" to the parameter data->id,
8477 * adding the resulting elements in the domain where the expression
8478 * is equal to the parameter to data->bound.
8479 */
8480static isl_stat bind_id(__isl_take isl_pw_aff *pa, void *user)
8481{
8482 struct isl_bind_id_data *data = user;
8483 isl_set *bound;
8484
8485 bound = isl_pw_aff_bind_id(pa, id: isl_id_copy(id: data->id));
8486 data->bound = isl_union_set_add_set(uset: data->bound, set: bound);
8487
8488 return data->bound ? isl_stat_ok : isl_stat_error;
8489}
8490
8491/* Bind the union piecewise affine function "upa" to the parameter "id",
8492 * returning the elements in the domain where the expression
8493 * is equal to the parameter.
8494 */
8495__isl_give isl_union_set *isl_union_pw_aff_bind_id(
8496 __isl_take isl_union_pw_aff *upa, __isl_take isl_id *id)
8497{
8498 struct isl_bind_id_data data = { id };
8499
8500 data.bound = isl_union_set_empty(space: isl_union_pw_aff_get_space(u: upa));
8501 if (isl_union_pw_aff_foreach_pw_aff(u: upa, fn: &bind_id, user: &data) < 0)
8502 data.bound = isl_union_set_free(uset: data.bound);
8503
8504 isl_union_pw_aff_free(u: upa);
8505 isl_id_free(id);
8506 return data.bound;
8507}
8508
8509/* Internal data structure for isl_union_pw_aff_pullback_union_pw_multi_aff.
8510 * upma is the function that is plugged in.
8511 * pa is the current part of the function in which upma is plugged in.
8512 * res collects the results.
8513 */
8514struct isl_union_pw_aff_pullback_upma_data {
8515 isl_union_pw_multi_aff *upma;
8516 isl_pw_aff *pa;
8517 isl_union_pw_aff *res;
8518};
8519
8520/* Check if "pma" can be plugged into data->pa.
8521 * If so, perform the pullback and add the result to data->res.
8522 */
8523static isl_stat pa_pb_pma(__isl_take isl_pw_multi_aff *pma, void *user)
8524{
8525 struct isl_union_pw_aff_pullback_upma_data *data = user;
8526 isl_pw_aff *pa;
8527
8528 if (!isl_space_tuple_is_equal(space1: data->pa->dim, type1: isl_dim_in,
8529 space2: pma->dim, type2: isl_dim_out)) {
8530 isl_pw_multi_aff_free(pw: pma);
8531 return isl_stat_ok;
8532 }
8533
8534 pa = isl_pw_aff_copy(pw: data->pa);
8535 pa = isl_pw_aff_pullback_pw_multi_aff(pw: pa, pma);
8536
8537 data->res = isl_union_pw_aff_add_pw_aff(u: data->res, part: pa);
8538
8539 return data->res ? isl_stat_ok : isl_stat_error;
8540}
8541
8542/* Check if any of the elements of data->upma can be plugged into pa,
8543 * add if so add the result to data->res.
8544 */
8545static isl_stat upa_pb_upma(__isl_take isl_pw_aff *pa, void *user)
8546{
8547 struct isl_union_pw_aff_pullback_upma_data *data = user;
8548 isl_stat r;
8549
8550 data->pa = pa;
8551 r = isl_union_pw_multi_aff_foreach_pw_multi_aff(u: data->upma,
8552 fn: &pa_pb_pma, user: data);
8553 isl_pw_aff_free(pw: pa);
8554
8555 return r;
8556}
8557
8558/* Compute the pullback of "upa" by the function represented by "upma".
8559 * In other words, plug in "upma" in "upa". The result contains
8560 * expressions defined over the domain space of "upma".
8561 *
8562 * Run over all pairs of elements in "upa" and "upma", perform
8563 * the pullback when appropriate and collect the results.
8564 * If the hash value were based on the domain space rather than
8565 * the function space, then we could run through all elements
8566 * of "upma" and directly pick out the corresponding element of "upa".
8567 */
8568__isl_give isl_union_pw_aff *isl_union_pw_aff_pullback_union_pw_multi_aff(
8569 __isl_take isl_union_pw_aff *upa,
8570 __isl_take isl_union_pw_multi_aff *upma)
8571{
8572 struct isl_union_pw_aff_pullback_upma_data data = { NULL, NULL };
8573 isl_space *space;
8574
8575 space = isl_union_pw_multi_aff_get_space(u: upma);
8576 upa = isl_union_pw_aff_align_params(u: upa, model: space);
8577 space = isl_union_pw_aff_get_space(u: upa);
8578 upma = isl_union_pw_multi_aff_align_params(u: upma, model: space);
8579
8580 if (!upa || !upma)
8581 goto error;
8582
8583 data.upma = upma;
8584 data.res = isl_union_pw_aff_alloc_same_size(u: upa);
8585 if (isl_union_pw_aff_foreach_pw_aff(u: upa, fn: &upa_pb_upma, user: &data) < 0)
8586 data.res = isl_union_pw_aff_free(u: data.res);
8587
8588 isl_union_pw_aff_free(u: upa);
8589 isl_union_pw_multi_aff_free(u: upma);
8590 return data.res;
8591error:
8592 isl_union_pw_aff_free(u: upa);
8593 isl_union_pw_multi_aff_free(u: upma);
8594 return NULL;
8595}
8596
8597#undef BASE
8598#define BASE union_pw_aff
8599#undef DOMBASE
8600#define DOMBASE union_set
8601
8602#include <isl_multi_explicit_domain.c>
8603#include <isl_multi_union_pw_aff_explicit_domain.c>
8604#include <isl_multi_templ.c>
8605#include <isl_multi_un_op_templ.c>
8606#include <isl_multi_bin_val_templ.c>
8607#include <isl_multi_apply_set.c>
8608#include <isl_multi_apply_union_set.c>
8609#include <isl_multi_arith_templ.c>
8610#include <isl_multi_bind_templ.c>
8611#include <isl_multi_coalesce.c>
8612#include <isl_multi_dim_id_templ.c>
8613#include <isl_multi_floor.c>
8614#include <isl_multi_from_base_templ.c>
8615#include <isl_multi_gist.c>
8616#include <isl_multi_align_set.c>
8617#include <isl_multi_align_union_set.c>
8618#include <isl_multi_intersect.c>
8619#include <isl_multi_nan_templ.c>
8620#include <isl_multi_tuple_id_templ.c>
8621#include <isl_multi_union_add_templ.c>
8622#include <isl_multi_zero_space_templ.c>
8623
8624/* Does "mupa" have a non-trivial explicit domain?
8625 *
8626 * The explicit domain, if present, is trivial if it represents
8627 * an (obviously) universe parameter set.
8628 */
8629isl_bool isl_multi_union_pw_aff_has_non_trivial_domain(
8630 __isl_keep isl_multi_union_pw_aff *mupa)
8631{
8632 isl_bool is_params, trivial;
8633 isl_set *set;
8634
8635 if (!mupa)
8636 return isl_bool_error;
8637 if (!isl_multi_union_pw_aff_has_explicit_domain(multi: mupa))
8638 return isl_bool_false;
8639 is_params = isl_union_set_is_params(uset: mupa->u.dom);
8640 if (is_params < 0 || !is_params)
8641 return isl_bool_not(b: is_params);
8642 set = isl_set_from_union_set(uset: isl_union_set_copy(uset: mupa->u.dom));
8643 trivial = isl_set_plain_is_universe(set);
8644 isl_set_free(set);
8645 return isl_bool_not(b: trivial);
8646}
8647
8648/* Construct a multiple union piecewise affine expression
8649 * in the given space with value zero in each of the output dimensions.
8650 *
8651 * Since there is no canonical zero value for
8652 * a union piecewise affine expression, we can only construct
8653 * a zero-dimensional "zero" value.
8654 */
8655__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_zero(
8656 __isl_take isl_space *space)
8657{
8658 isl_bool params;
8659 isl_size dim;
8660
8661 if (!space)
8662 return NULL;
8663
8664 params = isl_space_is_params(space);
8665 if (params < 0)
8666 goto error;
8667 if (params)
8668 isl_die(isl_space_get_ctx(space), isl_error_invalid,
8669 "expecting proper set space", goto error);
8670 if (!isl_space_is_set(space))
8671 isl_die(isl_space_get_ctx(space), isl_error_invalid,
8672 "expecting set space", goto error);
8673 dim = isl_space_dim(space, type: isl_dim_out);
8674 if (dim < 0)
8675 goto error;
8676 if (dim != 0)
8677 isl_die(isl_space_get_ctx(space), isl_error_invalid,
8678 "expecting 0D space", goto error);
8679
8680 return isl_multi_union_pw_aff_alloc(space);
8681error:
8682 isl_space_free(space);
8683 return NULL;
8684}
8685
8686/* Construct and return a multi union piecewise affine expression
8687 * that is equal to the given multi affine expression.
8688 */
8689__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_from_multi_aff(
8690 __isl_take isl_multi_aff *ma)
8691{
8692 isl_multi_pw_aff *mpa;
8693
8694 mpa = isl_multi_pw_aff_from_multi_aff(ma);
8695 return isl_multi_union_pw_aff_from_multi_pw_aff(mpa);
8696}
8697
8698/* This function performs the same operation as
8699 * isl_multi_union_pw_aff_from_multi_aff, but is considered as a function on an
8700 * isl_multi_aff when exported.
8701 */
8702__isl_give isl_multi_union_pw_aff *isl_multi_aff_to_multi_union_pw_aff(
8703 __isl_take isl_multi_aff *ma)
8704{
8705 return isl_multi_union_pw_aff_from_multi_aff(ma);
8706}
8707
8708/* Construct and return a multi union piecewise affine expression
8709 * that is equal to the given multi piecewise affine expression.
8710 *
8711 * If the resulting multi union piecewise affine expression has
8712 * an explicit domain, then assign it the domain of the input.
8713 * In other cases, the domain is stored in the individual elements.
8714 */
8715__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_from_multi_pw_aff(
8716 __isl_take isl_multi_pw_aff *mpa)
8717{
8718 int i;
8719 isl_size n;
8720 isl_space *space;
8721 isl_multi_union_pw_aff *mupa;
8722
8723 n = isl_multi_pw_aff_dim(multi: mpa, type: isl_dim_out);
8724 if (n < 0)
8725 mpa = isl_multi_pw_aff_free(multi: mpa);
8726 if (!mpa)
8727 return NULL;
8728
8729 space = isl_multi_pw_aff_get_space(multi: mpa);
8730 space = isl_space_range(space);
8731 mupa = isl_multi_union_pw_aff_alloc(space);
8732
8733 for (i = 0; i < n; ++i) {
8734 isl_pw_aff *pa;
8735 isl_union_pw_aff *upa;
8736
8737 pa = isl_multi_pw_aff_get_pw_aff(multi: mpa, pos: i);
8738 upa = isl_union_pw_aff_from_pw_aff(part: pa);
8739 mupa = isl_multi_union_pw_aff_restore_check_space(multi: mupa, pos: i, el: upa);
8740 }
8741 if (isl_multi_union_pw_aff_has_explicit_domain(multi: mupa)) {
8742 isl_union_set *dom;
8743 isl_multi_pw_aff *copy;
8744
8745 copy = isl_multi_pw_aff_copy(multi: mpa);
8746 dom = isl_union_set_from_set(set: isl_multi_pw_aff_domain(multi: copy));
8747 mupa = isl_multi_union_pw_aff_intersect_domain(multi: mupa, domain: dom);
8748 }
8749
8750 isl_multi_pw_aff_free(multi: mpa);
8751
8752 return mupa;
8753}
8754
8755/* Extract the range space of "pma" and assign it to *space.
8756 * If *space has already been set (through a previous call to this function),
8757 * then check that the range space is the same.
8758 */
8759static isl_stat extract_space(__isl_take isl_pw_multi_aff *pma, void *user)
8760{
8761 isl_space **space = user;
8762 isl_space *pma_space;
8763 isl_bool equal;
8764
8765 pma_space = isl_space_range(space: isl_pw_multi_aff_get_space(pw: pma));
8766 isl_pw_multi_aff_free(pw: pma);
8767
8768 if (!pma_space)
8769 return isl_stat_error;
8770 if (!*space) {
8771 *space = pma_space;
8772 return isl_stat_ok;
8773 }
8774
8775 equal = isl_space_is_equal(space1: pma_space, space2: *space);
8776 isl_space_free(space: pma_space);
8777
8778 if (equal < 0)
8779 return isl_stat_error;
8780 if (!equal)
8781 isl_die(isl_space_get_ctx(*space), isl_error_invalid,
8782 "range spaces not the same", return isl_stat_error);
8783 return isl_stat_ok;
8784}
8785
8786/* Construct and return a multi union piecewise affine expression
8787 * that is equal to the given union piecewise multi affine expression.
8788 *
8789 * In order to be able to perform the conversion, the input
8790 * needs to be non-empty and may only involve a single range space.
8791 *
8792 * If the resulting multi union piecewise affine expression has
8793 * an explicit domain, then assign it the domain of the input.
8794 * In other cases, the domain is stored in the individual elements.
8795 */
8796__isl_give isl_multi_union_pw_aff *
8797isl_multi_union_pw_aff_from_union_pw_multi_aff(
8798 __isl_take isl_union_pw_multi_aff *upma)
8799{
8800 isl_space *space = NULL;
8801 isl_multi_union_pw_aff *mupa;
8802 int i;
8803 isl_size n;
8804
8805 n = isl_union_pw_multi_aff_n_pw_multi_aff(u: upma);
8806 if (n < 0)
8807 goto error;
8808 if (n == 0)
8809 isl_die(isl_union_pw_multi_aff_get_ctx(upma), isl_error_invalid,
8810 "cannot extract range space from empty input",
8811 goto error);
8812 if (isl_union_pw_multi_aff_foreach_pw_multi_aff(u: upma, fn: &extract_space,
8813 user: &space) < 0)
8814 goto error;
8815
8816 if (!space)
8817 goto error;
8818
8819 n = isl_space_dim(space, type: isl_dim_set);
8820 if (n < 0)
8821 space = isl_space_free(space);
8822 mupa = isl_multi_union_pw_aff_alloc(space);
8823
8824 for (i = 0; i < n; ++i) {
8825 isl_union_pw_aff *upa;
8826
8827 upa = isl_union_pw_multi_aff_get_union_pw_aff(upma, pos: i);
8828 mupa = isl_multi_union_pw_aff_set_union_pw_aff(multi: mupa, pos: i, el: upa);
8829 }
8830 if (isl_multi_union_pw_aff_has_explicit_domain(multi: mupa)) {
8831 isl_union_set *dom;
8832 isl_union_pw_multi_aff *copy;
8833
8834 copy = isl_union_pw_multi_aff_copy(u: upma);
8835 dom = isl_union_pw_multi_aff_domain(u: copy);
8836 mupa = isl_multi_union_pw_aff_intersect_domain(multi: mupa, domain: dom);
8837 }
8838
8839 isl_union_pw_multi_aff_free(u: upma);
8840 return mupa;
8841error:
8842 isl_space_free(space);
8843 isl_union_pw_multi_aff_free(u: upma);
8844 return NULL;
8845}
8846
8847/* This function performs the same operation as
8848 * isl_multi_union_pw_aff_from_union_pw_multi_aff,
8849 * but is considered as a function on an isl_union_pw_multi_aff when exported.
8850 */
8851__isl_give isl_multi_union_pw_aff *
8852isl_union_pw_multi_aff_as_multi_union_pw_aff(
8853 __isl_take isl_union_pw_multi_aff *upma)
8854{
8855 return isl_multi_union_pw_aff_from_union_pw_multi_aff(upma);
8856}
8857
8858/* Try and create an isl_multi_union_pw_aff that is equivalent
8859 * to the given isl_union_map.
8860 * The isl_union_map is required to be single-valued in each space.
8861 * Moreover, it cannot be empty and all range spaces need to be the same.
8862 * Otherwise, an error is produced.
8863 */
8864__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_from_union_map(
8865 __isl_take isl_union_map *umap)
8866{
8867 isl_union_pw_multi_aff *upma;
8868
8869 upma = isl_union_pw_multi_aff_from_union_map(umap);
8870 return isl_multi_union_pw_aff_from_union_pw_multi_aff(upma);
8871}
8872
8873/* This function performs the same operation as
8874 * isl_multi_union_pw_aff_from_union_map,
8875 * but is considered as a function on an isl_union_map when exported.
8876 */
8877__isl_give isl_multi_union_pw_aff *isl_union_map_as_multi_union_pw_aff(
8878 __isl_take isl_union_map *umap)
8879{
8880 return isl_multi_union_pw_aff_from_union_map(umap);
8881}
8882
8883/* Return a multiple union piecewise affine expression
8884 * that is equal to "mv" on "domain", assuming "domain" and "mv"
8885 * have been aligned.
8886 *
8887 * If the resulting multi union piecewise affine expression has
8888 * an explicit domain, then assign it the input domain.
8889 * In other cases, the domain is stored in the individual elements.
8890 */
8891static __isl_give isl_multi_union_pw_aff *
8892isl_multi_union_pw_aff_multi_val_on_domain_aligned(
8893 __isl_take isl_union_set *domain, __isl_take isl_multi_val *mv)
8894{
8895 int i;
8896 isl_size n;
8897 isl_space *space;
8898 isl_multi_union_pw_aff *mupa;
8899
8900 n = isl_multi_val_dim(multi: mv, type: isl_dim_set);
8901 if (!domain || n < 0)
8902 goto error;
8903
8904 space = isl_multi_val_get_space(multi: mv);
8905 mupa = isl_multi_union_pw_aff_alloc(space);
8906 for (i = 0; i < n; ++i) {
8907 isl_val *v;
8908 isl_union_pw_aff *upa;
8909
8910 v = isl_multi_val_get_val(multi: mv, pos: i);
8911 upa = isl_union_pw_aff_val_on_domain(domain: isl_union_set_copy(uset: domain),
8912 v);
8913 mupa = isl_multi_union_pw_aff_set_union_pw_aff(multi: mupa, pos: i, el: upa);
8914 }
8915 if (isl_multi_union_pw_aff_has_explicit_domain(multi: mupa))
8916 mupa = isl_multi_union_pw_aff_intersect_domain(multi: mupa,
8917 domain: isl_union_set_copy(uset: domain));
8918
8919 isl_union_set_free(uset: domain);
8920 isl_multi_val_free(multi: mv);
8921 return mupa;
8922error:
8923 isl_union_set_free(uset: domain);
8924 isl_multi_val_free(multi: mv);
8925 return NULL;
8926}
8927
8928/* Return a multiple union piecewise affine expression
8929 * that is equal to "mv" on "domain".
8930 */
8931__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_multi_val_on_domain(
8932 __isl_take isl_union_set *domain, __isl_take isl_multi_val *mv)
8933{
8934 isl_bool equal_params;
8935
8936 if (!domain || !mv)
8937 goto error;
8938 equal_params = isl_space_has_equal_params(space1: domain->dim, space2: mv->space);
8939 if (equal_params < 0)
8940 goto error;
8941 if (equal_params)
8942 return isl_multi_union_pw_aff_multi_val_on_domain_aligned(
8943 domain, mv);
8944 domain = isl_union_set_align_params(uset: domain,
8945 model: isl_multi_val_get_space(multi: mv));
8946 mv = isl_multi_val_align_params(multi: mv, model: isl_union_set_get_space(uset: domain));
8947 return isl_multi_union_pw_aff_multi_val_on_domain_aligned(domain, mv);
8948error:
8949 isl_union_set_free(uset: domain);
8950 isl_multi_val_free(multi: mv);
8951 return NULL;
8952}
8953
8954/* Return a multiple union piecewise affine expression
8955 * that is equal to "ma" on "domain".
8956 */
8957__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_multi_aff_on_domain(
8958 __isl_take isl_union_set *domain, __isl_take isl_multi_aff *ma)
8959{
8960 isl_pw_multi_aff *pma;
8961
8962 pma = isl_pw_multi_aff_from_multi_aff(el: ma);
8963 return isl_multi_union_pw_aff_pw_multi_aff_on_domain(domain, pma);
8964}
8965
8966/* Return a multiple union piecewise affine expression
8967 * that is equal to "pma" on "domain", assuming "domain" and "pma"
8968 * have been aligned.
8969 *
8970 * If the resulting multi union piecewise affine expression has
8971 * an explicit domain, then assign it the input domain.
8972 * In other cases, the domain is stored in the individual elements.
8973 */
8974static __isl_give isl_multi_union_pw_aff *
8975isl_multi_union_pw_aff_pw_multi_aff_on_domain_aligned(
8976 __isl_take isl_union_set *domain, __isl_take isl_pw_multi_aff *pma)
8977{
8978 int i;
8979 isl_size n;
8980 isl_space *space;
8981 isl_multi_union_pw_aff *mupa;
8982
8983 n = isl_pw_multi_aff_dim(pw: pma, type: isl_dim_set);
8984 if (!domain || n < 0)
8985 goto error;
8986 space = isl_pw_multi_aff_get_space(pw: pma);
8987 mupa = isl_multi_union_pw_aff_alloc(space);
8988 for (i = 0; i < n; ++i) {
8989 isl_pw_aff *pa;
8990 isl_union_pw_aff *upa;
8991
8992 pa = isl_pw_multi_aff_get_pw_aff(pma, pos: i);
8993 upa = isl_union_pw_aff_pw_aff_on_domain(
8994 domain: isl_union_set_copy(uset: domain), pa);
8995 mupa = isl_multi_union_pw_aff_set_union_pw_aff(multi: mupa, pos: i, el: upa);
8996 }
8997 if (isl_multi_union_pw_aff_has_explicit_domain(multi: mupa))
8998 mupa = isl_multi_union_pw_aff_intersect_domain(multi: mupa,
8999 domain: isl_union_set_copy(uset: domain));
9000
9001 isl_union_set_free(uset: domain);
9002 isl_pw_multi_aff_free(pw: pma);
9003 return mupa;
9004error:
9005 isl_union_set_free(uset: domain);
9006 isl_pw_multi_aff_free(pw: pma);
9007 return NULL;
9008}
9009
9010/* Return a multiple union piecewise affine expression
9011 * that is equal to "pma" on "domain".
9012 */
9013__isl_give isl_multi_union_pw_aff *
9014isl_multi_union_pw_aff_pw_multi_aff_on_domain(__isl_take isl_union_set *domain,
9015 __isl_take isl_pw_multi_aff *pma)
9016{
9017 isl_bool equal_params;
9018 isl_space *space;
9019
9020 space = isl_pw_multi_aff_peek_space(pw: pma);
9021 equal_params = isl_union_set_space_has_equal_params(uset: domain, space);
9022 if (equal_params < 0)
9023 goto error;
9024 if (equal_params)
9025 return isl_multi_union_pw_aff_pw_multi_aff_on_domain_aligned(
9026 domain, pma);
9027 domain = isl_union_set_align_params(uset: domain,
9028 model: isl_pw_multi_aff_get_space(pw: pma));
9029 pma = isl_pw_multi_aff_align_params(pw: pma,
9030 model: isl_union_set_get_space(uset: domain));
9031 return isl_multi_union_pw_aff_pw_multi_aff_on_domain_aligned(domain,
9032 pma);
9033error:
9034 isl_union_set_free(uset: domain);
9035 isl_pw_multi_aff_free(pw: pma);
9036 return NULL;
9037}
9038
9039/* Return a union set containing those elements in the domains
9040 * of the elements of "mupa" where they are all zero.
9041 *
9042 * If there are no elements, then simply return the entire domain.
9043 */
9044__isl_give isl_union_set *isl_multi_union_pw_aff_zero_union_set(
9045 __isl_take isl_multi_union_pw_aff *mupa)
9046{
9047 int i;
9048 isl_size n;
9049 isl_union_pw_aff *upa;
9050 isl_union_set *zero;
9051
9052 n = isl_multi_union_pw_aff_dim(multi: mupa, type: isl_dim_set);
9053 if (n < 0)
9054 mupa = isl_multi_union_pw_aff_free(multi: mupa);
9055 if (!mupa)
9056 return NULL;
9057
9058 if (n == 0)
9059 return isl_multi_union_pw_aff_domain(mupa);
9060
9061 upa = isl_multi_union_pw_aff_get_union_pw_aff(multi: mupa, pos: 0);
9062 zero = isl_union_pw_aff_zero_union_set(upa);
9063
9064 for (i = 1; i < n; ++i) {
9065 isl_union_set *zero_i;
9066
9067 upa = isl_multi_union_pw_aff_get_union_pw_aff(multi: mupa, pos: i);
9068 zero_i = isl_union_pw_aff_zero_union_set(upa);
9069
9070 zero = isl_union_set_intersect(uset1: zero, uset2: zero_i);
9071 }
9072
9073 isl_multi_union_pw_aff_free(multi: mupa);
9074 return zero;
9075}
9076
9077/* Construct a union map mapping the shared domain
9078 * of the union piecewise affine expressions to the range of "mupa"
9079 * in the special case of a 0D multi union piecewise affine expression.
9080 *
9081 * Construct a map between the explicit domain of "mupa" and
9082 * the range space.
9083 * Note that this assumes that the domain consists of explicit elements.
9084 */
9085static __isl_give isl_union_map *isl_union_map_from_multi_union_pw_aff_0D(
9086 __isl_take isl_multi_union_pw_aff *mupa)
9087{
9088 isl_bool is_params;
9089 isl_space *space;
9090 isl_union_set *dom, *ran;
9091
9092 space = isl_multi_union_pw_aff_get_space(multi: mupa);
9093 dom = isl_multi_union_pw_aff_domain(mupa);
9094 ran = isl_union_set_from_set(set: isl_set_universe(space));
9095
9096 is_params = isl_union_set_is_params(uset: dom);
9097 if (is_params < 0)
9098 dom = isl_union_set_free(uset: dom);
9099 else if (is_params)
9100 isl_die(isl_union_set_get_ctx(dom), isl_error_invalid,
9101 "cannot create union map from expression without "
9102 "explicit domain elements",
9103 dom = isl_union_set_free(dom));
9104
9105 return isl_union_map_from_domain_and_range(domain: dom, range: ran);
9106}
9107
9108/* Construct a union map mapping the shared domain
9109 * of the union piecewise affine expressions to the range of "mupa"
9110 * with each dimension in the range equated to the
9111 * corresponding union piecewise affine expression.
9112 *
9113 * If the input is zero-dimensional, then construct a mapping
9114 * from its explicit domain.
9115 */
9116__isl_give isl_union_map *isl_union_map_from_multi_union_pw_aff(
9117 __isl_take isl_multi_union_pw_aff *mupa)
9118{
9119 int i;
9120 isl_size n;
9121 isl_space *space;
9122 isl_union_map *umap;
9123 isl_union_pw_aff *upa;
9124
9125 n = isl_multi_union_pw_aff_dim(multi: mupa, type: isl_dim_set);
9126 if (n < 0)
9127 mupa = isl_multi_union_pw_aff_free(multi: mupa);
9128 if (!mupa)
9129 return NULL;
9130
9131 if (n == 0)
9132 return isl_union_map_from_multi_union_pw_aff_0D(mupa);
9133
9134 upa = isl_multi_union_pw_aff_get_union_pw_aff(multi: mupa, pos: 0);
9135 umap = isl_union_map_from_union_pw_aff(upa);
9136
9137 for (i = 1; i < n; ++i) {
9138 isl_union_map *umap_i;
9139
9140 upa = isl_multi_union_pw_aff_get_union_pw_aff(multi: mupa, pos: i);
9141 umap_i = isl_union_map_from_union_pw_aff(upa);
9142 umap = isl_union_map_flat_range_product(umap1: umap, umap2: umap_i);
9143 }
9144
9145 space = isl_multi_union_pw_aff_get_space(multi: mupa);
9146 umap = isl_union_map_reset_range_space(umap, space);
9147
9148 isl_multi_union_pw_aff_free(multi: mupa);
9149 return umap;
9150}
9151
9152/* Internal data structure for isl_union_pw_multi_aff_reset_range_space.
9153 * "range" is the space from which to set the range space.
9154 * "res" collects the results.
9155 */
9156struct isl_union_pw_multi_aff_reset_range_space_data {
9157 isl_space *range;
9158 isl_union_pw_multi_aff *res;
9159};
9160
9161/* Replace the range space of "pma" by the range space of data->range and
9162 * add the result to data->res.
9163 */
9164static isl_stat reset_range_space(__isl_take isl_pw_multi_aff *pma, void *user)
9165{
9166 struct isl_union_pw_multi_aff_reset_range_space_data *data = user;
9167 isl_space *space;
9168
9169 space = isl_pw_multi_aff_get_space(pw: pma);
9170 space = isl_space_domain(space);
9171 space = isl_space_extend_domain_with_range(domain: space,
9172 model: isl_space_copy(space: data->range));
9173 pma = isl_pw_multi_aff_reset_space(pw: pma, space);
9174 data->res = isl_union_pw_multi_aff_add_pw_multi_aff(u: data->res, part: pma);
9175
9176 return data->res ? isl_stat_ok : isl_stat_error;
9177}
9178
9179/* Replace the range space of all the piecewise affine expressions in "upma" by
9180 * the range space of "space".
9181 *
9182 * This assumes that all these expressions have the same output dimension.
9183 *
9184 * Since the spaces of the expressions change, so do their hash values.
9185 * We therefore need to create a new isl_union_pw_multi_aff.
9186 * Note that the hash value is currently computed based on the entire
9187 * space even though there can only be a single expression with a given
9188 * domain space.
9189 */
9190static __isl_give isl_union_pw_multi_aff *
9191isl_union_pw_multi_aff_reset_range_space(
9192 __isl_take isl_union_pw_multi_aff *upma, __isl_take isl_space *space)
9193{
9194 struct isl_union_pw_multi_aff_reset_range_space_data data = { space };
9195 isl_space *space_upma;
9196
9197 space_upma = isl_union_pw_multi_aff_get_space(u: upma);
9198 data.res = isl_union_pw_multi_aff_empty(space: space_upma);
9199 if (isl_union_pw_multi_aff_foreach_pw_multi_aff(u: upma,
9200 fn: &reset_range_space, user: &data) < 0)
9201 data.res = isl_union_pw_multi_aff_free(u: data.res);
9202
9203 isl_space_free(space);
9204 isl_union_pw_multi_aff_free(u: upma);
9205 return data.res;
9206}
9207
9208/* Construct and return a union piecewise multi affine expression
9209 * that is equal to the given multi union piecewise affine expression,
9210 * in the special case of a 0D multi union piecewise affine expression.
9211 *
9212 * Construct a union piecewise multi affine expression
9213 * on top of the explicit domain of the input.
9214 */
9215__isl_give isl_union_pw_multi_aff *
9216isl_union_pw_multi_aff_from_multi_union_pw_aff_0D(
9217 __isl_take isl_multi_union_pw_aff *mupa)
9218{
9219 isl_space *space;
9220 isl_multi_val *mv;
9221 isl_union_set *domain;
9222
9223 space = isl_multi_union_pw_aff_get_space(multi: mupa);
9224 mv = isl_multi_val_zero(space);
9225 domain = isl_multi_union_pw_aff_domain(mupa);
9226 return isl_union_pw_multi_aff_multi_val_on_domain(domain, mv);
9227}
9228
9229/* Construct and return a union piecewise multi affine expression
9230 * that is equal to the given multi union piecewise affine expression.
9231 *
9232 * If the input is zero-dimensional, then
9233 * construct a union piecewise multi affine expression
9234 * on top of the explicit domain of the input.
9235 */
9236__isl_give isl_union_pw_multi_aff *
9237isl_union_pw_multi_aff_from_multi_union_pw_aff(
9238 __isl_take isl_multi_union_pw_aff *mupa)
9239{
9240 int i;
9241 isl_size n;
9242 isl_space *space;
9243 isl_union_pw_multi_aff *upma;
9244 isl_union_pw_aff *upa;
9245
9246 n = isl_multi_union_pw_aff_dim(multi: mupa, type: isl_dim_set);
9247 if (n < 0)
9248 mupa = isl_multi_union_pw_aff_free(multi: mupa);
9249 if (!mupa)
9250 return NULL;
9251
9252 if (n == 0)
9253 return isl_union_pw_multi_aff_from_multi_union_pw_aff_0D(mupa);
9254
9255 space = isl_multi_union_pw_aff_get_space(multi: mupa);
9256 upa = isl_multi_union_pw_aff_get_union_pw_aff(multi: mupa, pos: 0);
9257 upma = isl_union_pw_multi_aff_from_union_pw_aff(upa);
9258
9259 for (i = 1; i < n; ++i) {
9260 isl_union_pw_multi_aff *upma_i;
9261
9262 upa = isl_multi_union_pw_aff_get_union_pw_aff(multi: mupa, pos: i);
9263 upma_i = isl_union_pw_multi_aff_from_union_pw_aff(upa);
9264 upma = isl_union_pw_multi_aff_flat_range_product(upma1: upma, upma2: upma_i);
9265 }
9266
9267 upma = isl_union_pw_multi_aff_reset_range_space(upma, space);
9268
9269 isl_multi_union_pw_aff_free(multi: mupa);
9270 return upma;
9271}
9272
9273/* Intersect the range of "mupa" with "range",
9274 * in the special case where "mupa" is 0D.
9275 *
9276 * Intersect the domain of "mupa" with the constraints on the parameters
9277 * of "range".
9278 */
9279static __isl_give isl_multi_union_pw_aff *mupa_intersect_range_0D(
9280 __isl_take isl_multi_union_pw_aff *mupa, __isl_take isl_set *range)
9281{
9282 range = isl_set_params(set: range);
9283 mupa = isl_multi_union_pw_aff_intersect_params(multi: mupa, domain: range);
9284 return mupa;
9285}
9286
9287/* Intersect the range of "mupa" with "range".
9288 * That is, keep only those domain elements that have a function value
9289 * in "range".
9290 */
9291__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_intersect_range(
9292 __isl_take isl_multi_union_pw_aff *mupa, __isl_take isl_set *range)
9293{
9294 isl_union_pw_multi_aff *upma;
9295 isl_union_set *domain;
9296 isl_space *space;
9297 isl_size n;
9298 int match;
9299
9300 n = isl_multi_union_pw_aff_dim(multi: mupa, type: isl_dim_set);
9301 if (n < 0 || !range)
9302 goto error;
9303
9304 space = isl_set_get_space(set: range);
9305 match = isl_space_tuple_is_equal(space1: mupa->space, type1: isl_dim_set,
9306 space2: space, type2: isl_dim_set);
9307 isl_space_free(space);
9308 if (match < 0)
9309 goto error;
9310 if (!match)
9311 isl_die(isl_multi_union_pw_aff_get_ctx(mupa), isl_error_invalid,
9312 "space don't match", goto error);
9313 if (n == 0)
9314 return mupa_intersect_range_0D(mupa, range);
9315
9316 upma = isl_union_pw_multi_aff_from_multi_union_pw_aff(
9317 mupa: isl_multi_union_pw_aff_copy(multi: mupa));
9318 domain = isl_union_set_from_set(set: range);
9319 domain = isl_union_set_preimage_union_pw_multi_aff(uset: domain, upma);
9320 mupa = isl_multi_union_pw_aff_intersect_domain(multi: mupa, domain);
9321
9322 return mupa;
9323error:
9324 isl_multi_union_pw_aff_free(multi: mupa);
9325 isl_set_free(set: range);
9326 return NULL;
9327}
9328
9329/* Return the shared domain of the elements of "mupa",
9330 * in the special case where "mupa" is zero-dimensional.
9331 *
9332 * Return the explicit domain of "mupa".
9333 * Note that this domain may be a parameter set, either
9334 * because "mupa" is meant to live in a set space or
9335 * because no explicit domain has been set.
9336 */
9337__isl_give isl_union_set *isl_multi_union_pw_aff_domain_0D(
9338 __isl_take isl_multi_union_pw_aff *mupa)
9339{
9340 isl_union_set *dom;
9341
9342 dom = isl_multi_union_pw_aff_get_explicit_domain(multi: mupa);
9343 isl_multi_union_pw_aff_free(multi: mupa);
9344
9345 return dom;
9346}
9347
9348/* Return the shared domain of the elements of "mupa".
9349 *
9350 * If "mupa" is zero-dimensional, then return its explicit domain.
9351 */
9352__isl_give isl_union_set *isl_multi_union_pw_aff_domain(
9353 __isl_take isl_multi_union_pw_aff *mupa)
9354{
9355 int i;
9356 isl_size n;
9357 isl_union_pw_aff *upa;
9358 isl_union_set *dom;
9359
9360 n = isl_multi_union_pw_aff_dim(multi: mupa, type: isl_dim_set);
9361 if (n < 0)
9362 mupa = isl_multi_union_pw_aff_free(multi: mupa);
9363 if (!mupa)
9364 return NULL;
9365
9366 if (n == 0)
9367 return isl_multi_union_pw_aff_domain_0D(mupa);
9368
9369 upa = isl_multi_union_pw_aff_get_union_pw_aff(multi: mupa, pos: 0);
9370 dom = isl_union_pw_aff_domain(u: upa);
9371 for (i = 1; i < n; ++i) {
9372 isl_union_set *dom_i;
9373
9374 upa = isl_multi_union_pw_aff_get_union_pw_aff(multi: mupa, pos: i);
9375 dom_i = isl_union_pw_aff_domain(u: upa);
9376 dom = isl_union_set_intersect(uset1: dom, uset2: dom_i);
9377 }
9378
9379 isl_multi_union_pw_aff_free(multi: mupa);
9380 return dom;
9381}
9382
9383/* Apply "aff" to "mupa". The space of "mupa" is equal to the domain of "aff".
9384 * In particular, the spaces have been aligned.
9385 * The result is defined over the shared domain of the elements of "mupa"
9386 *
9387 * We first extract the parametric constant part of "aff" and
9388 * define that over the shared domain.
9389 * Then we iterate over all input dimensions of "aff" and add the corresponding
9390 * multiples of the elements of "mupa".
9391 * Finally, we consider the integer divisions, calling the function
9392 * recursively to obtain an isl_union_pw_aff corresponding to the
9393 * integer division argument.
9394 */
9395static __isl_give isl_union_pw_aff *multi_union_pw_aff_apply_aff(
9396 __isl_take isl_multi_union_pw_aff *mupa, __isl_take isl_aff *aff)
9397{
9398 int i;
9399 isl_size n_in, n_div;
9400 isl_union_pw_aff *upa;
9401 isl_union_set *uset;
9402 isl_val *v;
9403 isl_aff *cst;
9404
9405 n_in = isl_aff_dim(aff, type: isl_dim_in);
9406 n_div = isl_aff_dim(aff, type: isl_dim_div);
9407 if (n_in < 0 || n_div < 0)
9408 goto error;
9409
9410 uset = isl_multi_union_pw_aff_domain(mupa: isl_multi_union_pw_aff_copy(multi: mupa));
9411 cst = isl_aff_copy(aff);
9412 cst = isl_aff_drop_dims(aff: cst, type: isl_dim_div, first: 0, n: n_div);
9413 cst = isl_aff_drop_dims(aff: cst, type: isl_dim_in, first: 0, n: n_in);
9414 cst = isl_aff_project_domain_on_params(aff: cst);
9415 upa = isl_union_pw_aff_aff_on_domain(domain: uset, aff: cst);
9416
9417 for (i = 0; i < n_in; ++i) {
9418 isl_union_pw_aff *upa_i;
9419
9420 if (!isl_aff_involves_dims(aff, type: isl_dim_in, first: i, n: 1))
9421 continue;
9422 v = isl_aff_get_coefficient_val(aff, type: isl_dim_in, pos: i);
9423 upa_i = isl_multi_union_pw_aff_get_union_pw_aff(multi: mupa, pos: i);
9424 upa_i = isl_union_pw_aff_scale_val(u: upa_i, v);
9425 upa = isl_union_pw_aff_add(u1: upa, u2: upa_i);
9426 }
9427
9428 for (i = 0; i < n_div; ++i) {
9429 isl_aff *div;
9430 isl_union_pw_aff *upa_i;
9431
9432 if (!isl_aff_involves_dims(aff, type: isl_dim_div, first: i, n: 1))
9433 continue;
9434 div = isl_aff_get_div(aff, pos: i);
9435 upa_i = multi_union_pw_aff_apply_aff(
9436 mupa: isl_multi_union_pw_aff_copy(multi: mupa), aff: div);
9437 upa_i = isl_union_pw_aff_floor(upa: upa_i);
9438 v = isl_aff_get_coefficient_val(aff, type: isl_dim_div, pos: i);
9439 upa_i = isl_union_pw_aff_scale_val(u: upa_i, v);
9440 upa = isl_union_pw_aff_add(u1: upa, u2: upa_i);
9441 }
9442
9443 isl_multi_union_pw_aff_free(multi: mupa);
9444 isl_aff_free(aff);
9445
9446 return upa;
9447error:
9448 isl_multi_union_pw_aff_free(multi: mupa);
9449 isl_aff_free(aff);
9450 return NULL;
9451}
9452
9453/* Apply "aff" to "mupa". The space of "mupa" needs to be compatible
9454 * with the domain of "aff".
9455 * Furthermore, the dimension of this space needs to be greater than zero.
9456 * The result is defined over the shared domain of the elements of "mupa"
9457 *
9458 * We perform these checks and then hand over control to
9459 * multi_union_pw_aff_apply_aff.
9460 */
9461__isl_give isl_union_pw_aff *isl_multi_union_pw_aff_apply_aff(
9462 __isl_take isl_multi_union_pw_aff *mupa, __isl_take isl_aff *aff)
9463{
9464 isl_size dim;
9465 isl_space *space1, *space2;
9466 isl_bool equal;
9467
9468 mupa = isl_multi_union_pw_aff_align_params(multi: mupa,
9469 model: isl_aff_get_space(aff));
9470 aff = isl_aff_align_params(aff, model: isl_multi_union_pw_aff_get_space(multi: mupa));
9471 if (!mupa || !aff)
9472 goto error;
9473
9474 space1 = isl_multi_union_pw_aff_get_space(multi: mupa);
9475 space2 = isl_aff_get_domain_space(aff);
9476 equal = isl_space_is_equal(space1, space2);
9477 isl_space_free(space: space1);
9478 isl_space_free(space: space2);
9479 if (equal < 0)
9480 goto error;
9481 if (!equal)
9482 isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
9483 "spaces don't match", goto error);
9484 dim = isl_aff_dim(aff, type: isl_dim_in);
9485 if (dim < 0)
9486 goto error;
9487 if (dim == 0)
9488 isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
9489 "cannot determine domains", goto error);
9490
9491 return multi_union_pw_aff_apply_aff(mupa, aff);
9492error:
9493 isl_multi_union_pw_aff_free(multi: mupa);
9494 isl_aff_free(aff);
9495 return NULL;
9496}
9497
9498/* Apply "ma" to "mupa", in the special case where "mupa" is 0D.
9499 * The space of "mupa" is known to be compatible with the domain of "ma".
9500 *
9501 * Construct an isl_multi_union_pw_aff that is equal to "ma"
9502 * on the domain of "mupa".
9503 */
9504static __isl_give isl_multi_union_pw_aff *mupa_apply_multi_aff_0D(
9505 __isl_take isl_multi_union_pw_aff *mupa, __isl_take isl_multi_aff *ma)
9506{
9507 isl_union_set *dom;
9508
9509 dom = isl_multi_union_pw_aff_domain(mupa);
9510 ma = isl_multi_aff_project_domain_on_params(multi: ma);
9511
9512 return isl_multi_union_pw_aff_multi_aff_on_domain(domain: dom, ma);
9513}
9514
9515/* Apply "ma" to "mupa". The space of "mupa" needs to be compatible
9516 * with the domain of "ma".
9517 * The result is defined over the shared domain of the elements of "mupa"
9518 */
9519__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_apply_multi_aff(
9520 __isl_take isl_multi_union_pw_aff *mupa, __isl_take isl_multi_aff *ma)
9521{
9522 isl_space *space1, *space2;
9523 isl_multi_union_pw_aff *res;
9524 isl_bool equal;
9525 int i;
9526 isl_size n_in, n_out;
9527
9528 mupa = isl_multi_union_pw_aff_align_params(multi: mupa,
9529 model: isl_multi_aff_get_space(multi: ma));
9530 ma = isl_multi_aff_align_params(multi: ma,
9531 model: isl_multi_union_pw_aff_get_space(multi: mupa));
9532 n_in = isl_multi_aff_dim(multi: ma, type: isl_dim_in);
9533 n_out = isl_multi_aff_dim(multi: ma, type: isl_dim_out);
9534 if (!mupa || n_in < 0 || n_out < 0)
9535 goto error;
9536
9537 space1 = isl_multi_union_pw_aff_get_space(multi: mupa);
9538 space2 = isl_multi_aff_get_domain_space(multi: ma);
9539 equal = isl_space_is_equal(space1, space2);
9540 isl_space_free(space: space1);
9541 isl_space_free(space: space2);
9542 if (equal < 0)
9543 goto error;
9544 if (!equal)
9545 isl_die(isl_multi_aff_get_ctx(ma), isl_error_invalid,
9546 "spaces don't match", goto error);
9547 if (n_in == 0)
9548 return mupa_apply_multi_aff_0D(mupa, ma);
9549
9550 space1 = isl_space_range(space: isl_multi_aff_get_space(multi: ma));
9551 res = isl_multi_union_pw_aff_alloc(space: space1);
9552
9553 for (i = 0; i < n_out; ++i) {
9554 isl_aff *aff;
9555 isl_union_pw_aff *upa;
9556
9557 aff = isl_multi_aff_get_aff(multi: ma, pos: i);
9558 upa = multi_union_pw_aff_apply_aff(
9559 mupa: isl_multi_union_pw_aff_copy(multi: mupa), aff);
9560 res = isl_multi_union_pw_aff_set_union_pw_aff(multi: res, pos: i, el: upa);
9561 }
9562
9563 isl_multi_aff_free(multi: ma);
9564 isl_multi_union_pw_aff_free(multi: mupa);
9565 return res;
9566error:
9567 isl_multi_union_pw_aff_free(multi: mupa);
9568 isl_multi_aff_free(multi: ma);
9569 return NULL;
9570}
9571
9572/* Apply "pa" to "mupa", in the special case where "mupa" is 0D.
9573 * The space of "mupa" is known to be compatible with the domain of "pa".
9574 *
9575 * Construct an isl_multi_union_pw_aff that is equal to "pa"
9576 * on the domain of "mupa".
9577 */
9578static __isl_give isl_union_pw_aff *isl_multi_union_pw_aff_apply_pw_aff_0D(
9579 __isl_take isl_multi_union_pw_aff *mupa, __isl_take isl_pw_aff *pa)
9580{
9581 isl_union_set *dom;
9582
9583 dom = isl_multi_union_pw_aff_domain(mupa);
9584 pa = isl_pw_aff_project_domain_on_params(pw: pa);
9585
9586 return isl_union_pw_aff_pw_aff_on_domain(domain: dom, pa);
9587}
9588
9589/* Apply "pa" to "mupa". The space of "mupa" needs to be compatible
9590 * with the domain of "pa".
9591 * Furthermore, the dimension of this space needs to be greater than zero.
9592 * The result is defined over the shared domain of the elements of "mupa"
9593 */
9594__isl_give isl_union_pw_aff *isl_multi_union_pw_aff_apply_pw_aff(
9595 __isl_take isl_multi_union_pw_aff *mupa, __isl_take isl_pw_aff *pa)
9596{
9597 int i;
9598 isl_bool equal;
9599 isl_size n_in;
9600 isl_space *space, *space2;
9601 isl_union_pw_aff *upa;
9602
9603 mupa = isl_multi_union_pw_aff_align_params(multi: mupa,
9604 model: isl_pw_aff_get_space(pw: pa));
9605 pa = isl_pw_aff_align_params(pw: pa,
9606 model: isl_multi_union_pw_aff_get_space(multi: mupa));
9607 if (!mupa || !pa)
9608 goto error;
9609
9610 space = isl_multi_union_pw_aff_get_space(multi: mupa);
9611 space2 = isl_pw_aff_get_domain_space(pw: pa);
9612 equal = isl_space_is_equal(space1: space, space2);
9613 isl_space_free(space);
9614 isl_space_free(space: space2);
9615 if (equal < 0)
9616 goto error;
9617 if (!equal)
9618 isl_die(isl_pw_aff_get_ctx(pa), isl_error_invalid,
9619 "spaces don't match", goto error);
9620 n_in = isl_pw_aff_dim(pw: pa, type: isl_dim_in);
9621 if (n_in < 0)
9622 goto error;
9623 if (n_in == 0)
9624 return isl_multi_union_pw_aff_apply_pw_aff_0D(mupa, pa);
9625
9626 space = isl_space_params(space: isl_multi_union_pw_aff_get_space(multi: mupa));
9627 upa = isl_union_pw_aff_empty(space);
9628
9629 for (i = 0; i < pa->n; ++i) {
9630 isl_aff *aff;
9631 isl_set *domain;
9632 isl_multi_union_pw_aff *mupa_i;
9633 isl_union_pw_aff *upa_i;
9634
9635 mupa_i = isl_multi_union_pw_aff_copy(multi: mupa);
9636 domain = isl_set_copy(set: pa->p[i].set);
9637 mupa_i = isl_multi_union_pw_aff_intersect_range(mupa: mupa_i, range: domain);
9638 aff = isl_aff_copy(aff: pa->p[i].aff);
9639 upa_i = multi_union_pw_aff_apply_aff(mupa: mupa_i, aff);
9640 upa = isl_union_pw_aff_union_add(u1: upa, u2: upa_i);
9641 }
9642
9643 isl_multi_union_pw_aff_free(multi: mupa);
9644 isl_pw_aff_free(pw: pa);
9645 return upa;
9646error:
9647 isl_multi_union_pw_aff_free(multi: mupa);
9648 isl_pw_aff_free(pw: pa);
9649 return NULL;
9650}
9651
9652/* Apply "pma" to "mupa", in the special case where "mupa" is 0D.
9653 * The space of "mupa" is known to be compatible with the domain of "pma".
9654 *
9655 * Construct an isl_multi_union_pw_aff that is equal to "pma"
9656 * on the domain of "mupa".
9657 */
9658static __isl_give isl_multi_union_pw_aff *mupa_apply_pw_multi_aff_0D(
9659 __isl_take isl_multi_union_pw_aff *mupa,
9660 __isl_take isl_pw_multi_aff *pma)
9661{
9662 isl_union_set *dom;
9663
9664 dom = isl_multi_union_pw_aff_domain(mupa);
9665 pma = isl_pw_multi_aff_project_domain_on_params(pw: pma);
9666
9667 return isl_multi_union_pw_aff_pw_multi_aff_on_domain(domain: dom, pma);
9668}
9669
9670/* Apply "pma" to "mupa". The space of "mupa" needs to be compatible
9671 * with the domain of "pma".
9672 * The result is defined over the shared domain of the elements of "mupa"
9673 */
9674__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_apply_pw_multi_aff(
9675 __isl_take isl_multi_union_pw_aff *mupa,
9676 __isl_take isl_pw_multi_aff *pma)
9677{
9678 isl_space *space1, *space2;
9679 isl_multi_union_pw_aff *res;
9680 isl_bool equal;
9681 int i;
9682 isl_size n_in, n_out;
9683
9684 mupa = isl_multi_union_pw_aff_align_params(multi: mupa,
9685 model: isl_pw_multi_aff_get_space(pw: pma));
9686 pma = isl_pw_multi_aff_align_params(pw: pma,
9687 model: isl_multi_union_pw_aff_get_space(multi: mupa));
9688 if (!mupa || !pma)
9689 goto error;
9690
9691 space1 = isl_multi_union_pw_aff_get_space(multi: mupa);
9692 space2 = isl_pw_multi_aff_get_domain_space(pw: pma);
9693 equal = isl_space_is_equal(space1, space2);
9694 isl_space_free(space: space1);
9695 isl_space_free(space: space2);
9696 if (equal < 0)
9697 goto error;
9698 if (!equal)
9699 isl_die(isl_pw_multi_aff_get_ctx(pma), isl_error_invalid,
9700 "spaces don't match", goto error);
9701 n_in = isl_pw_multi_aff_dim(pw: pma, type: isl_dim_in);
9702 n_out = isl_pw_multi_aff_dim(pw: pma, type: isl_dim_out);
9703 if (n_in < 0 || n_out < 0)
9704 goto error;
9705 if (n_in == 0)
9706 return mupa_apply_pw_multi_aff_0D(mupa, pma);
9707
9708 space1 = isl_space_range(space: isl_pw_multi_aff_get_space(pw: pma));
9709 res = isl_multi_union_pw_aff_alloc(space: space1);
9710
9711 for (i = 0; i < n_out; ++i) {
9712 isl_pw_aff *pa;
9713 isl_union_pw_aff *upa;
9714
9715 pa = isl_pw_multi_aff_get_pw_aff(pma, pos: i);
9716 upa = isl_multi_union_pw_aff_apply_pw_aff(
9717 mupa: isl_multi_union_pw_aff_copy(multi: mupa), pa);
9718 res = isl_multi_union_pw_aff_set_union_pw_aff(multi: res, pos: i, el: upa);
9719 }
9720
9721 isl_pw_multi_aff_free(pw: pma);
9722 isl_multi_union_pw_aff_free(multi: mupa);
9723 return res;
9724error:
9725 isl_multi_union_pw_aff_free(multi: mupa);
9726 isl_pw_multi_aff_free(pw: pma);
9727 return NULL;
9728}
9729
9730/* Replace the explicit domain of "mupa" by its preimage under "upma".
9731 * If the explicit domain only keeps track of constraints on the parameters,
9732 * then only update those constraints.
9733 */
9734static __isl_give isl_multi_union_pw_aff *preimage_explicit_domain(
9735 __isl_take isl_multi_union_pw_aff *mupa,
9736 __isl_keep isl_union_pw_multi_aff *upma)
9737{
9738 isl_bool is_params;
9739
9740 if (isl_multi_union_pw_aff_check_has_explicit_domain(multi: mupa) < 0)
9741 return isl_multi_union_pw_aff_free(multi: mupa);
9742
9743 mupa = isl_multi_union_pw_aff_cow(multi: mupa);
9744 if (!mupa)
9745 return NULL;
9746
9747 is_params = isl_union_set_is_params(uset: mupa->u.dom);
9748 if (is_params < 0)
9749 return isl_multi_union_pw_aff_free(multi: mupa);
9750
9751 upma = isl_union_pw_multi_aff_copy(u: upma);
9752 if (is_params)
9753 mupa->u.dom = isl_union_set_intersect_params(uset: mupa->u.dom,
9754 set: isl_union_set_params(uset: isl_union_pw_multi_aff_domain(u: upma)));
9755 else
9756 mupa->u.dom = isl_union_set_preimage_union_pw_multi_aff(
9757 uset: mupa->u.dom, upma);
9758 if (!mupa->u.dom)
9759 return isl_multi_union_pw_aff_free(multi: mupa);
9760 return mupa;
9761}
9762
9763/* Compute the pullback of "mupa" by the function represented by "upma".
9764 * In other words, plug in "upma" in "mupa". The result contains
9765 * expressions defined over the domain space of "upma".
9766 *
9767 * Run over all elements of "mupa" and plug in "upma" in each of them.
9768 *
9769 * If "mupa" has an explicit domain, then it is this domain
9770 * that needs to undergo a pullback instead, i.e., a preimage.
9771 */
9772__isl_give isl_multi_union_pw_aff *
9773isl_multi_union_pw_aff_pullback_union_pw_multi_aff(
9774 __isl_take isl_multi_union_pw_aff *mupa,
9775 __isl_take isl_union_pw_multi_aff *upma)
9776{
9777 int i;
9778 isl_size n;
9779
9780 mupa = isl_multi_union_pw_aff_align_params(multi: mupa,
9781 model: isl_union_pw_multi_aff_get_space(u: upma));
9782 upma = isl_union_pw_multi_aff_align_params(u: upma,
9783 model: isl_multi_union_pw_aff_get_space(multi: mupa));
9784 mupa = isl_multi_union_pw_aff_cow(multi: mupa);
9785 n = isl_multi_union_pw_aff_dim(multi: mupa, type: isl_dim_set);
9786 if (n < 0 || !upma)
9787 goto error;
9788
9789 for (i = 0; i < n; ++i) {
9790 isl_union_pw_aff *upa;
9791
9792 upa = isl_multi_union_pw_aff_get_union_pw_aff(multi: mupa, pos: i);
9793 upa = isl_union_pw_aff_pullback_union_pw_multi_aff(upa,
9794 upma: isl_union_pw_multi_aff_copy(u: upma));
9795 mupa = isl_multi_union_pw_aff_set_union_pw_aff(multi: mupa, pos: i, el: upa);
9796 }
9797
9798 if (isl_multi_union_pw_aff_has_explicit_domain(multi: mupa))
9799 mupa = preimage_explicit_domain(mupa, upma);
9800
9801 isl_union_pw_multi_aff_free(u: upma);
9802 return mupa;
9803error:
9804 isl_multi_union_pw_aff_free(multi: mupa);
9805 isl_union_pw_multi_aff_free(u: upma);
9806 return NULL;
9807}
9808
9809/* Extract the sequence of elements in "mupa" with domain space "space"
9810 * (ignoring parameters).
9811 *
9812 * For the elements of "mupa" that are not defined on the specified space,
9813 * the corresponding element in the result is empty.
9814 */
9815__isl_give isl_multi_pw_aff *isl_multi_union_pw_aff_extract_multi_pw_aff(
9816 __isl_keep isl_multi_union_pw_aff *mupa, __isl_take isl_space *space)
9817{
9818 int i;
9819 isl_size n;
9820 isl_space *space_mpa;
9821 isl_multi_pw_aff *mpa;
9822
9823 n = isl_multi_union_pw_aff_dim(multi: mupa, type: isl_dim_set);
9824 if (n < 0 || !space)
9825 goto error;
9826
9827 space_mpa = isl_multi_union_pw_aff_get_space(multi: mupa);
9828 space = isl_space_replace_params(dst: space, src: space_mpa);
9829 space_mpa = isl_space_map_from_domain_and_range(domain: isl_space_copy(space),
9830 range: space_mpa);
9831 mpa = isl_multi_pw_aff_alloc(space: space_mpa);
9832
9833 space = isl_space_from_domain(space);
9834 space = isl_space_add_dims(space, type: isl_dim_out, n: 1);
9835 for (i = 0; i < n; ++i) {
9836 isl_union_pw_aff *upa;
9837 isl_pw_aff *pa;
9838
9839 upa = isl_multi_union_pw_aff_get_union_pw_aff(multi: mupa, pos: i);
9840 pa = isl_union_pw_aff_extract_pw_aff(u: upa,
9841 space: isl_space_copy(space));
9842 mpa = isl_multi_pw_aff_set_pw_aff(multi: mpa, pos: i, el: pa);
9843 isl_union_pw_aff_free(u: upa);
9844 }
9845
9846 isl_space_free(space);
9847 return mpa;
9848error:
9849 isl_space_free(space);
9850 return NULL;
9851}
9852
9853/* Data structure that specifies how isl_union_pw_multi_aff_un_op
9854 * should modify the base expressions in the input.
9855 *
9856 * If "filter" is not NULL, then only the base expressions that satisfy "filter"
9857 * are taken into account.
9858 * "fn" is applied to each entry in the input.
9859 */
9860struct isl_union_pw_multi_aff_un_op_control {
9861 isl_bool (*filter)(__isl_keep isl_pw_multi_aff *part);
9862 __isl_give isl_pw_multi_aff *(*fn)(__isl_take isl_pw_multi_aff *pma);
9863};
9864
9865/* Wrapper for isl_union_pw_multi_aff_un_op filter functions (which do not take
9866 * a second argument) for use as an isl_union_pw_multi_aff_transform
9867 * filter function (which does take a second argument).
9868 * Simply call control->filter without the second argument.
9869 */
9870static isl_bool isl_union_pw_multi_aff_un_op_filter_drop_user(
9871 __isl_take isl_pw_multi_aff *pma, void *user)
9872{
9873 struct isl_union_pw_multi_aff_un_op_control *control = user;
9874
9875 return control->filter(pma);
9876}
9877
9878/* Wrapper for isl_union_pw_multi_aff_un_op base functions (which do not take
9879 * a second argument) for use as an isl_union_pw_multi_aff_transform
9880 * base function (which does take a second argument).
9881 * Simply call control->fn without the second argument.
9882 */
9883static __isl_give isl_pw_multi_aff *isl_union_pw_multi_aff_un_op_drop_user(
9884 __isl_take isl_pw_multi_aff *pma, void *user)
9885{
9886 struct isl_union_pw_multi_aff_un_op_control *control = user;
9887
9888 return control->fn(pma);
9889}
9890
9891/* Construct an isl_union_pw_multi_aff that is obtained by
9892 * modifying "upma" according to "control".
9893 *
9894 * isl_union_pw_multi_aff_transform performs essentially
9895 * the same operation, but takes a filter and a callback function
9896 * of a different form (with an extra argument).
9897 * Call isl_union_pw_multi_aff_transform with wrappers
9898 * that remove this extra argument.
9899 */
9900static __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_un_op(
9901 __isl_take isl_union_pw_multi_aff *upma,
9902 struct isl_union_pw_multi_aff_un_op_control *control)
9903{
9904 struct isl_union_pw_multi_aff_transform_control t_control = {
9905 .filter = &isl_union_pw_multi_aff_un_op_filter_drop_user,
9906 .filter_user = control,
9907 .fn = &isl_union_pw_multi_aff_un_op_drop_user,
9908 .fn_user = control,
9909 };
9910
9911 return isl_union_pw_multi_aff_transform(u: upma, control: &t_control);
9912}
9913
9914/* For each function in "upma" of the form A -> [B -> C],
9915 * extract the function A -> B and collect the results.
9916 */
9917__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_range_factor_domain(
9918 __isl_take isl_union_pw_multi_aff *upma)
9919{
9920 struct isl_union_pw_multi_aff_un_op_control control = {
9921 .filter = &isl_pw_multi_aff_range_is_wrapping,
9922 .fn = &isl_pw_multi_aff_range_factor_domain,
9923 };
9924 return isl_union_pw_multi_aff_un_op(upma, control: &control);
9925}
9926
9927/* For each function in "upma" of the form A -> [B -> C],
9928 * extract the function A -> C and collect the results.
9929 */
9930__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_range_factor_range(
9931 __isl_take isl_union_pw_multi_aff *upma)
9932{
9933 struct isl_union_pw_multi_aff_un_op_control control = {
9934 .filter = &isl_pw_multi_aff_range_is_wrapping,
9935 .fn = &isl_pw_multi_aff_range_factor_range,
9936 };
9937 return isl_union_pw_multi_aff_un_op(upma, control: &control);
9938}
9939
9940/* Evaluate the affine function "aff" in the void point "pnt".
9941 * In particular, return the value NaN.
9942 */
9943static __isl_give isl_val *eval_void(__isl_take isl_aff *aff,
9944 __isl_take isl_point *pnt)
9945{
9946 isl_ctx *ctx;
9947
9948 ctx = isl_point_get_ctx(pnt);
9949 isl_aff_free(aff);
9950 isl_point_free(pnt);
9951 return isl_val_nan(ctx);
9952}
9953
9954/* Evaluate the affine expression "aff"
9955 * in the coordinates (with denominator) "pnt".
9956 */
9957static __isl_give isl_val *eval(__isl_keep isl_vec *aff,
9958 __isl_keep isl_vec *pnt)
9959{
9960 isl_int n, d;
9961 isl_ctx *ctx;
9962 isl_val *v;
9963
9964 if (!aff || !pnt)
9965 return NULL;
9966
9967 ctx = isl_vec_get_ctx(vec: aff);
9968 isl_int_init(n);
9969 isl_int_init(d);
9970 isl_seq_inner_product(p1: aff->el + 1, p2: pnt->el, len: pnt->size, prod: &n);
9971 isl_int_mul(d, aff->el[0], pnt->el[0]);
9972 v = isl_val_rat_from_isl_int(ctx, n, d);
9973 v = isl_val_normalize(v);
9974 isl_int_clear(n);
9975 isl_int_clear(d);
9976
9977 return v;
9978}
9979
9980/* Check that the domain space of "aff" is equal to "space".
9981 */
9982static isl_stat isl_aff_check_has_domain_space(__isl_keep isl_aff *aff,
9983 __isl_keep isl_space *space)
9984{
9985 isl_bool ok;
9986
9987 ok = isl_space_is_equal(space1: isl_aff_peek_domain_space(aff), space2: space);
9988 if (ok < 0)
9989 return isl_stat_error;
9990 if (!ok)
9991 isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
9992 "incompatible spaces", return isl_stat_error);
9993 return isl_stat_ok;
9994}
9995
9996/* Evaluate the affine function "aff" in "pnt".
9997 */
9998__isl_give isl_val *isl_aff_eval(__isl_take isl_aff *aff,
9999 __isl_take isl_point *pnt)
10000{
10001 isl_bool is_void;
10002 isl_val *v;
10003 isl_local_space *ls;
10004
10005 if (isl_aff_check_has_domain_space(aff, space: isl_point_peek_space(pnt)) < 0)
10006 goto error;
10007 is_void = isl_point_is_void(pnt);
10008 if (is_void < 0)
10009 goto error;
10010 if (is_void)
10011 return eval_void(aff, pnt);
10012
10013 ls = isl_aff_get_domain_local_space(aff);
10014 pnt = isl_local_space_lift_point(ls, pnt);
10015
10016 v = eval(aff: aff->v, pnt: isl_point_peek_vec(pnt));
10017
10018 isl_aff_free(aff);
10019 isl_point_free(pnt);
10020
10021 return v;
10022error:
10023 isl_aff_free(aff);
10024 isl_point_free(pnt);
10025 return NULL;
10026}
10027

source code of polly/lib/External/isl/isl_aff.c