File: | build/source/polly/lib/External/isl/isl_aff.c |
Warning: | line 5953, column 3 Value stored to 'o_src' is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
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_BASEunion_pw_aff |
40 | #define EL_BASEunion_pw_aff aff |
41 | |
42 | #include <isl_list_templ.c> |
43 | #include <isl_list_read_templ.c> |
44 | |
45 | #undef EL_BASEunion_pw_aff |
46 | #define EL_BASEunion_pw_aff pw_aff |
47 | |
48 | #include <isl_list_templ.c> |
49 | #include <isl_list_read_templ.c> |
50 | |
51 | #undef EL_BASEunion_pw_aff |
52 | #define EL_BASEunion_pw_aff pw_multi_aff |
53 | |
54 | #include <isl_list_templ.c> |
55 | #include <isl_list_read_templ.c> |
56 | |
57 | #undef EL_BASEunion_pw_aff |
58 | #define EL_BASEunion_pw_aff union_pw_aff |
59 | |
60 | #include <isl_list_templ.c> |
61 | #include <isl_list_read_templ.c> |
62 | |
63 | #undef EL_BASEunion_pw_aff |
64 | #define EL_BASEunion_pw_aff 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 | */ |
72 | static __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)((struct isl_aff *)isl_calloc_or_die(v->ctx, 1, sizeof(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; |
89 | error: |
90 | isl_local_space_free(ls); |
91 | isl_vec_free(v); |
92 | return NULL((void*)0); |
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((void*)0); |
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",do { isl_handle_error(ctx, isl_error_invalid, "local space has unknown divs" , "polly/lib/External/isl/isl_aff.c", 112); goto error; } while (0) |
112 | goto error)do { isl_handle_error(ctx, isl_error_invalid, "local space has unknown divs" , "polly/lib/External/isl/isl_aff.c", 112); goto error; } while (0); |
113 | if (!isl_local_space_is_set(ls)) |
114 | isl_die(ctx, isl_error_invalid,do { isl_handle_error(ctx, isl_error_invalid, "domain of affine expression should be a set" , "polly/lib/External/isl/isl_aff.c", 116); goto error; } while (0) |
115 | "domain of affine expression should be a set",do { isl_handle_error(ctx, isl_error_invalid, "domain of affine expression should be a set" , "polly/lib/External/isl/isl_aff.c", 116); goto error; } while (0) |
116 | goto error)do { isl_handle_error(ctx, isl_error_invalid, "domain of affine expression should be a set" , "polly/lib/External/isl/isl_aff.c", 116); goto error; } while (0); |
117 | return isl_aff_alloc_vec_validated(ls, v); |
118 | error: |
119 | isl_local_space_free(ls); |
120 | isl_vec_free(v); |
121 | return NULL((void*)0); |
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((void*)0); |
132 | |
133 | ctx = isl_local_space_get_ctx(ls); |
134 | |
135 | total = isl_local_space_dim(ls, isl_dim_all); |
136 | if (total < 0) |
137 | goto error; |
138 | v = isl_vec_alloc(ctx, 1 + 1 + total); |
139 | return isl_aff_alloc_vec(ls, v); |
140 | error: |
141 | isl_local_space_free(ls); |
142 | return NULL((void*)0); |
143 | } |
144 | |
145 | __isl_give isl_aff *isl_aff_copy(__isl_keep isl_aff *aff) |
146 | { |
147 | if (!aff) |
148 | return NULL((void*)0); |
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((void*)0); |
158 | |
159 | return isl_aff_alloc_vec_validated(isl_local_space_copy(aff->ls), |
160 | isl_vec_copy(aff->v)); |
161 | } |
162 | |
163 | __isl_give isl_aff *isl_aff_cow(__isl_take isl_aff *aff) |
164 | { |
165 | if (!aff) |
166 | return NULL((void*)0); |
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((void*)0); |
181 | |
182 | isl_int_set_si(aff->v->el[0], 1)isl_sioimath_set_si((aff->v->el[0]), 1); |
183 | isl_seq_clr(aff->v->el + 1, 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(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(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 | */ |
216 | static __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((void*)0); |
221 | |
222 | aff->v = isl_vec_clr(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(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(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(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(val) && !isl_val_is_nan(val)) |
280 | isl_die(isl_val_get_ctx(val), isl_error_invalid,do { isl_handle_error(isl_val_get_ctx(val), isl_error_invalid , "expecting rational value or NaN", "polly/lib/External/isl/isl_aff.c" , 281); goto error; } while (0) |
281 | "expecting rational value or NaN", goto error)do { isl_handle_error(isl_val_get_ctx(val), isl_error_invalid , "expecting rational value or NaN", "polly/lib/External/isl/isl_aff.c" , 281); goto error; } while (0); |
282 | |
283 | aff = isl_aff_alloc(isl_local_space_copy(ls)); |
284 | if (!aff) |
285 | goto error; |
286 | |
287 | isl_seq_clr(aff->v->el + 2, aff->v->size - 2); |
288 | isl_int_set(aff->v->el[1], val->n)isl_sioimath_set((aff->v->el[1]), *(val->n)); |
289 | isl_int_set(aff->v->el[0], val->d)isl_sioimath_set((aff->v->el[0]), *(val->d)); |
290 | |
291 | isl_local_space_free(ls); |
292 | isl_val_free(val); |
293 | return aff; |
294 | error: |
295 | isl_local_space_free(ls); |
296 | isl_val_free(val); |
297 | return NULL((void*)0); |
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(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((void*)0); |
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,do { isl_handle_error(isl_space_get_ctx(space), isl_error_invalid , "expecting (parameter) set space", "polly/lib/External/isl/isl_aff.c" , 325); goto error; } while (0) |
325 | "expecting (parameter) set space", goto error)do { isl_handle_error(isl_space_get_ctx(space), isl_error_invalid , "expecting (parameter) set space", "polly/lib/External/isl/isl_aff.c" , 325); goto error; } while (0); |
326 | if (isl_local_space_check_range(ls, type, pos, 1) < 0) |
327 | goto error; |
328 | |
329 | isl_space_free(space); |
330 | aff = isl_aff_alloc(ls); |
331 | if (!aff) |
332 | return NULL((void*)0); |
333 | |
334 | pos += isl_local_space_offset(aff->ls, type); |
335 | |
336 | isl_int_set_si(aff->v->el[0], 1)isl_sioimath_set_si((aff->v->el[0]), 1); |
337 | isl_seq_clr(aff->v->el + 1, aff->v->size - 1); |
338 | isl_int_set_si(aff->v->el[1 + pos], 1)isl_sioimath_set_si((aff->v->el[1 + pos]), 1); |
339 | |
340 | return aff; |
341 | error: |
342 | isl_local_space_free(ls); |
343 | isl_space_free(space); |
344 | return NULL((void*)0); |
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(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, isl_dim_param, id); |
368 | if (pos < 0) |
369 | isl_die(isl_space_get_ctx(space), isl_error_invalid,do { isl_handle_error(isl_space_get_ctx(space), isl_error_invalid , "parameter not found in space", "polly/lib/External/isl/isl_aff.c" , 370); goto error; } while (0) |
370 | "parameter not found in space", goto error)do { isl_handle_error(isl_space_get_ctx(space), isl_error_invalid , "parameter not found in space", "polly/lib/External/isl/isl_aff.c" , 370); goto error; } while (0); |
371 | isl_id_free(id); |
372 | ls = isl_local_space_from_space(space); |
373 | return isl_aff_var_on_domain(ls, isl_dim_param, pos); |
374 | error: |
375 | isl_space_free(space); |
376 | isl_id_free(id); |
377 | return NULL((void*)0); |
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((void*)0); |
394 | |
395 | if (--aff->ref > 0) |
396 | return NULL((void*)0); |
397 | |
398 | isl_local_space_free(aff->ls); |
399 | isl_vec_free(aff->v); |
400 | |
401 | free(aff); |
402 | |
403 | return NULL((void*)0); |
404 | } |
405 | |
406 | isl_ctx *isl_aff_get_ctx(__isl_keep isl_aff *aff) |
407 | { |
408 | return aff ? isl_local_space_get_ctx(aff->ls) : NULL((void*)0); |
409 | } |
410 | |
411 | /* Return a hash value that digests "aff". |
412 | */ |
413 | uint32_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()(2166136261u); |
421 | ls_hash = isl_local_space_get_hash(aff->ls); |
422 | isl_hash_hash(hash, ls_hash)do { do { hash *= 16777619; hash ^= (ls_hash) & 0xFF; } while (0); do { hash *= 16777619; hash ^= ((ls_hash) >> 8) & 0xFF; } while(0); do { hash *= 16777619; hash ^= ((ls_hash) >> 16) & 0xFF; } while(0); do { hash *= 16777619; hash ^= ( (ls_hash) >> 24) & 0xFF; } while(0); } while(0); |
423 | v_hash = isl_vec_get_hash(aff->v); |
424 | isl_hash_hash(hash, v_hash)do { do { hash *= 16777619; hash ^= (v_hash) & 0xFF; } while (0); do { hash *= 16777619; hash ^= ((v_hash) >> 8) & 0xFF; } while(0); do { hash *= 16777619; hash ^= ((v_hash) >> 16) & 0xFF; } while(0); do { hash *= 16777619; hash ^= ( (v_hash) >> 24) & 0xFF; } while(0); } while(0); |
425 | |
426 | return hash; |
427 | } |
428 | |
429 | /* Return the domain local space of "aff". |
430 | */ |
431 | static __isl_keep isl_local_space *isl_aff_peek_domain_local_space( |
432 | __isl_keep isl_aff *aff) |
433 | { |
434 | return aff ? aff->ls : NULL((void*)0); |
435 | } |
436 | |
437 | /* Return the number of variables of the given type in the domain of "aff". |
438 | */ |
439 | isl_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 | */ |
450 | isl_size isl_aff_dim(__isl_keep isl_aff *aff, enum isl_dim_type type) |
451 | { |
452 | if (!aff) |
453 | return isl_size_error((int) -1); |
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 | */ |
464 | isl_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 | */ |
476 | int 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(aff->ls, type, name); |
486 | } |
487 | |
488 | /* Return the domain space of "aff". |
489 | */ |
490 | static __isl_keep isl_space *isl_aff_peek_domain_space(__isl_keep isl_aff *aff) |
491 | { |
492 | return aff ? isl_local_space_peek_space(aff->ls) : NULL((void*)0); |
493 | } |
494 | |
495 | __isl_give isl_space *isl_aff_get_domain_space(__isl_keep isl_aff *aff) |
496 | { |
497 | return isl_space_copy(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((void*)0); |
505 | space = isl_local_space_get_space(aff->ls); |
506 | space = isl_space_from_domain(space); |
507 | space = isl_space_add_dims(space, isl_dim_out, 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(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((void*)0); |
524 | ls = isl_local_space_copy(aff->ls); |
525 | ls = isl_local_space_from_domain(ls); |
526 | ls = isl_local_space_add_dims(ls, isl_dim_out, 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((void*)0); |
546 | if (aff->ref != 1) |
547 | return isl_aff_get_domain_local_space(aff); |
548 | ls = aff->ls; |
549 | aff->ls = NULL((void*)0); |
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(aff->ls); |
574 | aff->ls = ls; |
575 | |
576 | return aff; |
577 | error: |
578 | isl_aff_free(aff); |
579 | isl_local_space_free(ls); |
580 | return NULL((void*)0); |
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 | */ |
586 | const 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((void*)0); |
591 | if (type == isl_dim_out) |
592 | return NULL((void*)0); |
593 | if (type == isl_dim_in) |
594 | type = isl_dim_set; |
595 | return isl_local_space_get_dim_name(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(aff->ls, space); |
606 | if (!aff->ls) |
607 | return isl_aff_free(aff); |
608 | |
609 | return aff; |
610 | error: |
611 | isl_aff_free(aff); |
612 | isl_space_free(space); |
613 | return NULL((void*)0); |
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, 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(r, aff->ls->div->n_row); |
638 | aff->v = isl_vec_reorder(aff->v, 2, isl_reordering_copy(r)); |
639 | aff->ls = isl_local_space_realign(aff->ls, r); |
640 | |
641 | if (!aff->v || !aff->ls) |
642 | return isl_aff_free(aff); |
643 | |
644 | return aff; |
645 | error: |
646 | isl_aff_free(aff); |
647 | isl_reordering_free(r); |
648 | return NULL((void*)0); |
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(domain_space, model); |
659 | if (equal_params < 0) |
660 | goto error; |
661 | if (!equal_params) { |
662 | isl_reordering *exp; |
663 | |
664 | exp = isl_parameter_alignment_reordering(domain_space, model); |
665 | aff = isl_aff_realign_domain(aff, exp); |
666 | } |
667 | |
668 | isl_space_free(model); |
669 | return aff; |
670 | error: |
671 | isl_space_free(model); |
672 | isl_aff_free(aff); |
673 | return NULL((void*)0); |
674 | } |
675 | |
676 | #undef TYPEisl_multi_union_pw_aff |
677 | #define TYPEisl_multi_union_pw_aff 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 | */ |
684 | isl_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])(isl_sioimath_sgn(*(aff->v->el[0])) == 0)) |
692 | return isl_bool_false; |
693 | pos = isl_seq_first_non_zero(aff->v->el + 1, aff->v->size - 1); |
694 | return isl_bool_ok(pos < 0); |
695 | } |
696 | |
697 | /* Does "aff" represent NaN? |
698 | */ |
699 | isl_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(isl_seq_first_non_zero(aff->v->el, 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 | */ |
711 | isl_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(aff1) || isl_aff_is_nan(aff2)) |
720 | return isl_bool_false; |
721 | |
722 | equal = isl_local_space_is_equal(aff1->ls, aff2->ls); |
723 | if (equal < 0 || !equal) |
724 | return equal; |
725 | |
726 | return isl_vec_is_equal(aff1->v, 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 | */ |
733 | isl_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,do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "cannot get denominator of NaN", "polly/lib/External/isl/isl_aff.c" , 739); return isl_stat_error; } while (0) |
739 | "cannot get denominator of NaN", return isl_stat_error)do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "cannot get denominator of NaN", "polly/lib/External/isl/isl_aff.c" , 739); return isl_stat_error; } while (0); |
740 | isl_int_set(*v, aff->v->el[0])isl_sioimath_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((void*)0); |
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, 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((void*)0); |
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, aff->v->el[1], 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((void*)0); |
787 | |
788 | ctx = isl_aff_get_ctx(aff); |
789 | if (type == isl_dim_out) |
790 | isl_die(ctx, isl_error_invalid,do { isl_handle_error(ctx, isl_error_invalid, "output/set dimension does not have a coefficient" , "polly/lib/External/isl/isl_aff.c", 792); return ((void*)0) ; } while (0) |
791 | "output/set dimension does not have a coefficient",do { isl_handle_error(ctx, isl_error_invalid, "output/set dimension does not have a coefficient" , "polly/lib/External/isl/isl_aff.c", 792); return ((void*)0) ; } while (0) |
792 | return NULL)do { isl_handle_error(ctx, isl_error_invalid, "output/set dimension does not have a coefficient" , "polly/lib/External/isl/isl_aff.c", 792); return ((void*)0) ; } while (0); |
793 | if (type == isl_dim_in) |
794 | type = isl_dim_set; |
795 | |
796 | if (isl_local_space_check_range(aff->ls, type, pos, 1) < 0) |
797 | return NULL((void*)0); |
798 | |
799 | if (isl_aff_is_nan(aff)) |
800 | return isl_val_nan(ctx); |
801 | pos += isl_local_space_offset(aff->ls, type); |
802 | v = isl_val_rat_from_isl_int(ctx, aff->v->el[1 + pos], 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 | */ |
809 | int 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,do { isl_handle_error(ctx, isl_error_invalid, "output/set dimension does not have a coefficient" , "polly/lib/External/isl/isl_aff.c", 821); return 0; } while (0) |
820 | "output/set dimension does not have a coefficient",do { isl_handle_error(ctx, isl_error_invalid, "output/set dimension does not have a coefficient" , "polly/lib/External/isl/isl_aff.c", 821); return 0; } while (0) |
821 | return 0)do { isl_handle_error(ctx, isl_error_invalid, "output/set dimension does not have a coefficient" , "polly/lib/External/isl/isl_aff.c", 821); return 0; } while (0); |
822 | if (type == isl_dim_in) |
823 | type = isl_dim_set; |
824 | |
825 | if (isl_local_space_check_range(aff->ls, type, pos, 1) < 0) |
826 | return 0; |
827 | |
828 | pos += isl_local_space_offset(aff->ls, type); |
829 | return isl_int_sgn(aff->v->el[1 + pos])isl_sioimath_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((void*)0); |
840 | if (isl_aff_is_nan(aff)) |
841 | return aff; |
842 | aff = isl_aff_cow(aff); |
843 | if (!aff) |
844 | return NULL((void*)0); |
845 | |
846 | aff->v = isl_vec_cow(aff->v); |
847 | if (!aff->v) |
848 | return isl_aff_free(aff); |
849 | |
850 | isl_int_set(aff->v->el[1], v)isl_sioimath_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,do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "expecting rational value", "polly/lib/External/isl/isl_aff.c" , 872); goto error; } while (0) |
872 | "expecting rational value", goto error)do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "expecting rational value", "polly/lib/External/isl/isl_aff.c" , 872); goto error; } while (0); |
873 | |
874 | if (isl_int_eq(aff->v->el[1], v->n)(isl_sioimath_cmp(*(aff->v->el[1]), *(v->n)) == 0) && |
875 | isl_int_eq(aff->v->el[0], v->d)(isl_sioimath_cmp(*(aff->v->el[0]), *(v->d)) == 0)) { |
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(aff->v); |
884 | if (!aff->v) |
885 | goto error; |
886 | |
887 | if (isl_int_eq(aff->v->el[0], v->d)(isl_sioimath_cmp(*(aff->v->el[0]), *(v->d)) == 0)) { |
888 | isl_int_set(aff->v->el[1], v->n)isl_sioimath_set((aff->v->el[1]), *(v->n)); |
889 | } else if (isl_int_is_one(v->d)(isl_sioimath_cmp_si(*(v->d), 1) == 0)) { |
890 | isl_int_mul(aff->v->el[1], aff->v->el[0], v->n)isl_sioimath_mul((aff->v->el[1]), *(aff->v->el[0] ), *(v->n)); |
891 | } else { |
892 | isl_seq_scale(aff->v->el + 1, |
893 | aff->v->el + 1, v->d, aff->v->size - 1); |
894 | isl_int_mul(aff->v->el[1], aff->v->el[0], v->n)isl_sioimath_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)isl_sioimath_mul((aff->v->el[0]), *(aff->v->el[0] ), *(v->d)); |
896 | aff->v = isl_vec_normalize(aff->v); |
897 | if (!aff->v) |
898 | goto error; |
899 | } |
900 | |
901 | isl_val_free(v); |
902 | return aff; |
903 | error: |
904 | isl_aff_free(aff); |
905 | isl_val_free(v); |
906 | return NULL((void*)0); |
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)(isl_sioimath_sgn(*(v)) == 0)) |
916 | return aff; |
917 | |
918 | if (!aff) |
919 | return NULL((void*)0); |
920 | if (isl_aff_is_nan(aff)) |
921 | return aff; |
922 | aff = isl_aff_cow(aff); |
923 | if (!aff) |
924 | return NULL((void*)0); |
925 | |
926 | aff->v = isl_vec_cow(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)isl_sioimath_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 | */ |
938 | static __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(aff->v); |
946 | if (!aff->v) |
947 | goto error; |
948 | |
949 | if (isl_int_is_one(v->d)(isl_sioimath_cmp_si(*(v->d), 1) == 0)) { |
950 | isl_int_addmul(aff->v->el[1], aff->v->el[0], v->n)isl_sioimath_addmul((aff->v->el[1]), *(aff->v->el [0]), *(v->n)); |
951 | } else if (isl_int_eq(aff->v->el[0], v->d)(isl_sioimath_cmp(*(aff->v->el[0]), *(v->d)) == 0)) { |
952 | isl_int_add(aff->v->el[1], aff->v->el[1], v->n)isl_sioimath_add((aff->v->el[1]), *(aff->v->el[1] ), *(v->n)); |
953 | aff->v = isl_vec_normalize(aff->v); |
954 | if (!aff->v) |
955 | goto error; |
956 | } else { |
957 | isl_seq_scale(aff->v->el + 1, |
958 | aff->v->el + 1, v->d, aff->v->size - 1); |
959 | isl_int_addmul(aff->v->el[1], aff->v->el[0], v->n)isl_sioimath_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)isl_sioimath_mul((aff->v->el[0]), *(aff->v->el[0] ), *(v->d)); |
961 | aff->v = isl_vec_normalize(aff->v); |
962 | if (!aff->v) |
963 | goto error; |
964 | } |
965 | |
966 | isl_val_free(v); |
967 | return aff; |
968 | error: |
969 | isl_aff_free(aff); |
970 | isl_val_free(v); |
971 | return NULL((void*)0); |
972 | } |
973 | |
974 | /* Return the first argument and free the second. |
975 | */ |
976 | static __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 | */ |
985 | static __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,do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "expecting rational value or NaN", "polly/lib/External/isl/isl_aff.c" , 1017); goto error; } while (0) |
1017 | "expecting rational value or NaN", goto error)do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "expecting rational value or NaN", "polly/lib/External/isl/isl_aff.c" , 1017); goto error; } while (0); |
1018 | |
1019 | return isl_aff_add_rat_constant_val(aff, v); |
1020 | error: |
1021 | isl_aff_free(aff); |
1022 | isl_val_free(v); |
1023 | return NULL((void*)0); |
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)isl_sioimath_init((t)); |
1031 | isl_int_set_si(t, v)isl_sioimath_set_si((t), v); |
1032 | aff = isl_aff_add_constant(aff, t); |
1033 | isl_int_clear(t)isl_sioimath_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)(isl_sioimath_sgn(*(v)) == 0)) |
1045 | return aff; |
1046 | |
1047 | if (!aff) |
1048 | return NULL((void*)0); |
1049 | if (isl_aff_is_nan(aff)) |
1050 | return aff; |
1051 | aff = isl_aff_cow(aff); |
1052 | if (!aff) |
1053 | return NULL((void*)0); |
1054 | |
1055 | aff->v = isl_vec_cow(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)isl_sioimath_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)isl_sioimath_init((t)); |
1076 | isl_int_set_si(t, v)isl_sioimath_set_si((t), v); |
1077 | aff = isl_aff_add_constant_num(aff, t); |
1078 | isl_int_clear(t)isl_sioimath_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((void*)0); |
1091 | if (isl_aff_is_nan(aff)) |
1092 | return aff; |
1093 | aff = isl_aff_cow(aff); |
1094 | if (!aff) |
1095 | return NULL((void*)0); |
1096 | |
1097 | aff->v = isl_vec_cow(aff->v); |
1098 | if (!aff->v) |
1099 | return isl_aff_free(aff); |
1100 | |
1101 | isl_int_set_si(aff->v->el[1], v)isl_sioimath_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((void*)0); |
1116 | |
1117 | if (type == isl_dim_out) |
1118 | isl_die(aff->v->ctx, isl_error_invalid,do { isl_handle_error(aff->v->ctx, isl_error_invalid, "output/set dimension does not have a coefficient" , "polly/lib/External/isl/isl_aff.c", 1120); return isl_aff_free (aff); } while (0) |
1119 | "output/set dimension does not have a coefficient",do { isl_handle_error(aff->v->ctx, isl_error_invalid, "output/set dimension does not have a coefficient" , "polly/lib/External/isl/isl_aff.c", 1120); return isl_aff_free (aff); } while (0) |
1120 | return isl_aff_free(aff))do { isl_handle_error(aff->v->ctx, isl_error_invalid, "output/set dimension does not have a coefficient" , "polly/lib/External/isl/isl_aff.c", 1120); return isl_aff_free (aff); } while (0); |
1121 | if (type == isl_dim_in) |
1122 | type = isl_dim_set; |
1123 | |
1124 | if (isl_local_space_check_range(aff->ls, type, pos, 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((void*)0); |
1132 | |
1133 | aff->v = isl_vec_cow(aff->v); |
1134 | if (!aff->v) |
1135 | return isl_aff_free(aff); |
1136 | |
1137 | pos += isl_local_space_offset(aff->ls, type); |
1138 | isl_int_set(aff->v->el[1 + pos], v)isl_sioimath_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((void*)0); |
1153 | |
1154 | if (type == isl_dim_out) |
1155 | isl_die(aff->v->ctx, isl_error_invalid,do { isl_handle_error(aff->v->ctx, isl_error_invalid, "output/set dimension does not have a coefficient" , "polly/lib/External/isl/isl_aff.c", 1157); return isl_aff_free (aff); } while (0) |
1156 | "output/set dimension does not have a coefficient",do { isl_handle_error(aff->v->ctx, isl_error_invalid, "output/set dimension does not have a coefficient" , "polly/lib/External/isl/isl_aff.c", 1157); return isl_aff_free (aff); } while (0) |
1157 | return isl_aff_free(aff))do { isl_handle_error(aff->v->ctx, isl_error_invalid, "output/set dimension does not have a coefficient" , "polly/lib/External/isl/isl_aff.c", 1157); return isl_aff_free (aff); } while (0); |
1158 | if (type == isl_dim_in) |
1159 | type = isl_dim_set; |
1160 | |
1161 | if (isl_local_space_check_range(aff->ls, type, pos, 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(aff->ls, type); |
1167 | if (isl_int_cmp_si(aff->v->el[1 + pos], v)isl_sioimath_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((void*)0); |
1173 | |
1174 | aff->v = isl_vec_cow(aff->v); |
1175 | if (!aff->v) |
1176 | return isl_aff_free(aff); |
1177 | |
1178 | isl_int_set_si(aff->v->el[1 + pos], v)isl_sioimath_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,do { isl_handle_error(aff->v->ctx, isl_error_invalid, "output/set dimension does not have a coefficient" , "polly/lib/External/isl/isl_aff.c", 1197); goto error; } while (0) |
1196 | "output/set dimension does not have a coefficient",do { isl_handle_error(aff->v->ctx, isl_error_invalid, "output/set dimension does not have a coefficient" , "polly/lib/External/isl/isl_aff.c", 1197); goto error; } while (0) |
1197 | goto error)do { isl_handle_error(aff->v->ctx, isl_error_invalid, "output/set dimension does not have a coefficient" , "polly/lib/External/isl/isl_aff.c", 1197); goto error; } while (0); |
1198 | if (type == isl_dim_in) |
1199 | type = isl_dim_set; |
1200 | |
1201 | if (isl_local_space_check_range(aff->ls, type, pos, 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,do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "expecting rational value", "polly/lib/External/isl/isl_aff.c" , 1210); goto error; } while (0) |
1210 | "expecting rational value", goto error)do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "expecting rational value", "polly/lib/External/isl/isl_aff.c" , 1210); goto error; } while (0); |
1211 | |
1212 | pos += isl_local_space_offset(aff->ls, type); |
1213 | if (isl_int_eq(aff->v->el[1 + pos], v->n)(isl_sioimath_cmp(*(aff->v->el[1 + pos]), *(v->n)) == 0) && |
1214 | isl_int_eq(aff->v->el[0], v->d)(isl_sioimath_cmp(*(aff->v->el[0]), *(v->d)) == 0)) { |
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(aff->v); |
1223 | if (!aff->v) |
1224 | goto error; |
1225 | |
1226 | if (isl_int_eq(aff->v->el[0], v->d)(isl_sioimath_cmp(*(aff->v->el[0]), *(v->d)) == 0)) { |
1227 | isl_int_set(aff->v->el[1 + pos], v->n)isl_sioimath_set((aff->v->el[1 + pos]), *(v->n)); |
1228 | } else if (isl_int_is_one(v->d)(isl_sioimath_cmp_si(*(v->d), 1) == 0)) { |
1229 | isl_int_mul(aff->v->el[1 + pos], aff->v->el[0], v->n)isl_sioimath_mul((aff->v->el[1 + pos]), *(aff->v-> el[0]), *(v->n)); |
1230 | } else { |
1231 | isl_seq_scale(aff->v->el + 1, |
1232 | aff->v->el + 1, v->d, aff->v->size - 1); |
1233 | isl_int_mul(aff->v->el[1 + pos], aff->v->el[0], v->n)isl_sioimath_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)isl_sioimath_mul((aff->v->el[0]), *(aff->v->el[0] ), *(v->d)); |
1235 | aff->v = isl_vec_normalize(aff->v); |
1236 | if (!aff->v) |
1237 | goto error; |
1238 | } |
1239 | |
1240 | isl_val_free(v); |
1241 | return aff; |
1242 | error: |
1243 | isl_aff_free(aff); |
1244 | isl_val_free(v); |
1245 | return NULL((void*)0); |
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((void*)0); |
1258 | |
1259 | if (type == isl_dim_out) |
1260 | isl_die(aff->v->ctx, isl_error_invalid,do { isl_handle_error(aff->v->ctx, isl_error_invalid, "output/set dimension does not have a coefficient" , "polly/lib/External/isl/isl_aff.c", 1262); return isl_aff_free (aff); } while (0) |
1261 | "output/set dimension does not have a coefficient",do { isl_handle_error(aff->v->ctx, isl_error_invalid, "output/set dimension does not have a coefficient" , "polly/lib/External/isl/isl_aff.c", 1262); return isl_aff_free (aff); } while (0) |
1262 | return isl_aff_free(aff))do { isl_handle_error(aff->v->ctx, isl_error_invalid, "output/set dimension does not have a coefficient" , "polly/lib/External/isl/isl_aff.c", 1262); return isl_aff_free (aff); } while (0); |
1263 | if (type == isl_dim_in) |
1264 | type = isl_dim_set; |
1265 | |
1266 | if (isl_local_space_check_range(aff->ls, type, pos, 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((void*)0); |
1274 | |
1275 | aff->v = isl_vec_cow(aff->v); |
1276 | if (!aff->v) |
1277 | return isl_aff_free(aff); |
1278 | |
1279 | pos += isl_local_space_offset(aff->ls, type); |
1280 | isl_int_addmul(aff->v->el[1 + pos], aff->v->el[0], v)isl_sioimath_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,do { isl_handle_error(aff->v->ctx, isl_error_invalid, "output/set dimension does not have a coefficient" , "polly/lib/External/isl/isl_aff.c", 1304); goto error; } while (0) |
1303 | "output/set dimension does not have a coefficient",do { isl_handle_error(aff->v->ctx, isl_error_invalid, "output/set dimension does not have a coefficient" , "polly/lib/External/isl/isl_aff.c", 1304); goto error; } while (0) |
1304 | goto error)do { isl_handle_error(aff->v->ctx, isl_error_invalid, "output/set dimension does not have a coefficient" , "polly/lib/External/isl/isl_aff.c", 1304); goto error; } while (0); |
1305 | if (type == isl_dim_in) |
1306 | type = isl_dim_set; |
1307 | |
1308 | if (isl_local_space_check_range(aff->ls, type, pos, 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,do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "expecting rational value", "polly/lib/External/isl/isl_aff.c" , 1317); goto error; } while (0) |
1317 | "expecting rational value", goto error)do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "expecting rational value", "polly/lib/External/isl/isl_aff.c" , 1317); goto error; } while (0); |
1318 | |
1319 | aff = isl_aff_cow(aff); |
1320 | if (!aff) |
1321 | goto error; |
1322 | |
1323 | aff->v = isl_vec_cow(aff->v); |
1324 | if (!aff->v) |
1325 | goto error; |
1326 | |
1327 | pos += isl_local_space_offset(aff->ls, type); |
1328 | if (isl_int_is_one(v->d)(isl_sioimath_cmp_si(*(v->d), 1) == 0)) { |
1329 | isl_int_addmul(aff->v->el[1 + pos], aff->v->el[0], v->n)isl_sioimath_addmul((aff->v->el[1 + pos]), *(aff->v-> el[0]), *(v->n)); |
1330 | } else if (isl_int_eq(aff->v->el[0], v->d)(isl_sioimath_cmp(*(aff->v->el[0]), *(v->d)) == 0)) { |
1331 | isl_int_add(aff->v->el[1 + pos], aff->v->el[1 + pos], v->n)isl_sioimath_add((aff->v->el[1 + pos]), *(aff->v-> el[1 + pos]), *(v->n)); |
1332 | aff->v = isl_vec_normalize(aff->v); |
1333 | if (!aff->v) |
1334 | goto error; |
1335 | } else { |
1336 | isl_seq_scale(aff->v->el + 1, |
1337 | aff->v->el + 1, v->d, aff->v->size - 1); |
1338 | isl_int_addmul(aff->v->el[1 + pos], aff->v->el[0], v->n)isl_sioimath_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)isl_sioimath_mul((aff->v->el[0]), *(aff->v->el[0] ), *(v->d)); |
1340 | aff->v = isl_vec_normalize(aff->v); |
1341 | if (!aff->v) |
1342 | goto error; |
1343 | } |
1344 | |
1345 | isl_val_free(v); |
1346 | return aff; |
1347 | error: |
1348 | isl_aff_free(aff); |
1349 | isl_val_free(v); |
1350 | return NULL((void*)0); |
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)isl_sioimath_init((t)); |
1359 | isl_int_set_si(t, v)isl_sioimath_set_si((t), v); |
1360 | aff = isl_aff_add_coefficient(aff, type, pos, t); |
1361 | isl_int_clear(t)isl_sioimath_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((void*)0); |
1370 | |
1371 | return isl_local_space_get_div(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((void*)0); |
1382 | if (isl_aff_is_nan(aff)) |
1383 | return aff; |
1384 | aff = isl_aff_cow(aff); |
1385 | if (!aff) |
1386 | return NULL((void*)0); |
1387 | aff->v = isl_vec_cow(aff->v); |
1388 | if (!aff->v) |
1389 | return isl_aff_free(aff); |
1390 | |
1391 | isl_seq_neg(aff->v->el + 1, aff->v->el + 1, 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, isl_dim_div); |
1410 | off = isl_aff_domain_offset(aff, isl_dim_div); |
1411 | if (n < 0 || off < 0) |
1412 | return isl_aff_free(aff); |
1413 | |
1414 | pos = isl_seq_last_non_zero(aff->v->el + 1 + off, n) + 1; |
1415 | if (pos == n) |
1416 | return aff; |
1417 | |
1418 | aff = isl_aff_cow(aff); |
1419 | if (!aff) |
1420 | return NULL((void*)0); |
1421 | |
1422 | aff->ls = isl_local_space_drop_dims(aff->ls, isl_dim_div, pos, n - pos); |
1423 | aff->v = isl_vec_drop_els(aff->v, 1 + off + pos, 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 | */ |
1434 | static __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, isl_dim_div); |
1445 | off = isl_aff_domain_offset(aff, 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])(isl_sioimath_cmp_si(*(aff->ls->div->row[i][0]), 1) == 0)) |
1451 | continue; |
1452 | ls = isl_local_space_copy(aff->ls); |
1453 | ls = isl_local_space_substitute_seq(ls, isl_dim_div, i, |
1454 | aff->ls->div->row[i], len, i + 1, n - (i + 1)); |
1455 | vec = isl_vec_copy(aff->v); |
1456 | vec = isl_vec_cow(vec); |
1457 | if (!ls || !vec) |
1458 | goto error; |
1459 | |
1460 | isl_int_init(v)isl_sioimath_init((v)); |
1461 | |
1462 | isl_seq_substitute(vec->el, off + i, aff->ls->div->row[i], |
1463 | len, len, v); |
1464 | |
1465 | isl_int_clear(v)isl_sioimath_clear((v)); |
1466 | |
1467 | isl_vec_free(aff->v); |
1468 | aff->v = vec; |
1469 | isl_local_space_free(aff->ls); |
1470 | aff->ls = ls; |
1471 | } |
1472 | |
1473 | return aff; |
1474 | error: |
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 | */ |
1499 | static __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, isl_dim_div); |
1506 | off = isl_aff_domain_offset(aff, 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])(isl_sioimath_cmp_si(*(aff->ls->div->row[i][1 + off + j]), 1) == 0)) |
1512 | continue; |
1513 | aff->ls = isl_local_space_substitute_seq(aff->ls, |
1514 | isl_dim_div, j, aff->ls->div->row[j], |
1515 | aff->v->size, i, 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 | */ |
1529 | static __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, 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(aff->ls); |
1539 | ls = isl_local_space_swap_div(ls, a, b); |
1540 | v = isl_vec_copy(aff->v); |
1541 | v = isl_vec_cow(v); |
1542 | if (!ls || !v) |
1543 | goto error; |
1544 | |
1545 | isl_int_swap(v->el[1 + off + a], v->el[1 + off + b])isl_sioimath_swap((v->el[1 + off + a]), (v->el[1 + off + b])); |
1546 | isl_vec_free(aff->v); |
1547 | aff->v = v; |
1548 | isl_local_space_free(aff->ls); |
1549 | aff->ls = ls; |
1550 | |
1551 | return aff; |
1552 | error: |
1553 | isl_vec_free(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 | */ |
1563 | static __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, 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])(isl_sioimath_sgn(*(aff->v->el[1 + off + b])) == 0)) |
1571 | return aff; |
1572 | |
1573 | aff->v = isl_vec_cow(aff->v); |
1574 | if (!aff->v) |
1575 | return isl_aff_free(aff); |
1576 | |
1577 | isl_int_add(aff->v->el[1 + off + a],isl_sioimath_add((aff->v->el[1 + off + a]), *(aff->v ->el[1 + off + a]), *(aff->v->el[1 + off + b])) |
1578 | aff->v->el[1 + off + a], aff->v->el[1 + off + b])isl_sioimath_add((aff->v->el[1 + off + a]), *(aff->v ->el[1 + off + a]), *(aff->v->el[1 + off + b])); |
1579 | isl_int_set_si(aff->v->el[1 + off + b], 0)isl_sioimath_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 | */ |
1593 | static __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, 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(aff->ls->div, j, j + 1); |
1604 | if (cmp < 0) |
1605 | break; |
1606 | if (cmp == 0) |
1607 | aff = merge_divs(aff, j, j + 1); |
1608 | else |
1609 | aff = swap_div(aff, j, j + 1); |
1610 | if (!aff) |
1611 | return NULL((void*)0); |
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((void*)0); |
1628 | aff->v = isl_vec_normalize(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((void*)0); |
1658 | |
1659 | if (isl_aff_is_nan(aff)) |
1660 | return aff; |
1661 | if (isl_int_is_one(aff->v->el[0])(isl_sioimath_cmp_si(*(aff->v->el[0]), 1) == 0)) |
1662 | return aff; |
1663 | |
1664 | aff = isl_aff_cow(aff); |
1665 | if (!aff) |
1666 | return NULL((void*)0); |
1667 | |
1668 | aff->v = isl_vec_cow(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])isl_sioimath_fdiv_q((aff->v->el[1]), *(aff->v->el [1]), *(aff->v->el[0])); |
1674 | isl_int_set_si(aff->v->el[0], 1)isl_sioimath_set_si((aff->v->el[0]), 1); |
1675 | return aff; |
1676 | } |
1677 | |
1678 | div = isl_vec_copy(aff->v); |
1679 | div = isl_vec_cow(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)isl_sioimath_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])isl_sioimath_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])isl_sioimath_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])(isl_sioimath_cmp(*(div->el[i]), *(aff->v->el[0])) > 0)) { |
1689 | isl_int_sub(div->el[i], div->el[i], div->el[0])isl_sioimath_sub((div->el[i]), *(div->el[i]), *(div-> el[0])); |
1690 | isl_int_add_ui(aff->v->el[i], aff->v->el[i], 1)isl_sioimath_add_ui((aff->v->el[i]), *(aff->v->el [i]), 1); |
1691 | } |
1692 | } |
1693 | |
1694 | aff->ls = isl_local_space_add_div(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(aff->v, size + 1); |
1700 | if (!aff->v) |
1701 | return isl_aff_free(aff); |
1702 | isl_int_set_si(aff->v->el[0], 1)isl_sioimath_set_si((aff->v->el[0]), 1); |
1703 | isl_int_set_si(aff->v->el[size], 1)isl_sioimath_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(m)) |
1725 | isl_die(isl_val_get_ctx(m), isl_error_invalid,do { isl_handle_error(isl_val_get_ctx(m), isl_error_invalid, "expecting integer modulo" , "polly/lib/External/isl/isl_aff.c", 1726); goto error; } while (0) |
1726 | "expecting integer modulo", goto error)do { isl_handle_error(isl_val_get_ctx(m), isl_error_invalid, "expecting integer modulo" , "polly/lib/External/isl/isl_aff.c", 1726); goto error; } while (0); |
1727 | |
1728 | res = isl_aff_copy(aff); |
1729 | aff = isl_aff_scale_down_val(aff, isl_val_copy(m)); |
1730 | aff = isl_aff_floor(aff); |
1731 | aff = isl_aff_scale_val(aff, m); |
1732 | res = isl_aff_sub(res, aff); |
1733 | |
1734 | return res; |
1735 | error: |
1736 | isl_aff_free(aff); |
1737 | isl_val_free(m); |
1738 | return NULL((void*)0); |
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, m); |
1751 | pwaff = isl_pw_aff_floor(pwaff); |
1752 | pwaff = isl_pw_aff_scale(pwaff, m); |
1753 | res = isl_pw_aff_sub(res, 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(m)) |
1770 | isl_die(isl_pw_aff_get_ctx(pa), isl_error_invalid,do { isl_handle_error(isl_pw_aff_get_ctx(pa), isl_error_invalid , "expecting integer modulo", "polly/lib/External/isl/isl_aff.c" , 1771); goto error; } while (0) |
1771 | "expecting integer modulo", goto error)do { isl_handle_error(isl_pw_aff_get_ctx(pa), isl_error_invalid , "expecting integer modulo", "polly/lib/External/isl/isl_aff.c" , 1771); goto error; } while (0); |
1772 | pa = isl_pw_aff_mod(pa, m->n); |
1773 | isl_val_free(m); |
1774 | return pa; |
1775 | error: |
1776 | isl_pw_aff_free(pa); |
1777 | isl_val_free(m); |
1778 | return NULL((void*)0); |
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((void*)0); |
1797 | |
1798 | if (isl_aff_is_nan(aff)) |
1799 | return aff; |
1800 | if (isl_int_is_one(aff->v->el[0])(isl_sioimath_cmp_si(*(aff->v->el[0]), 1) == 0)) |
1801 | return aff; |
1802 | |
1803 | aff = isl_aff_cow(aff); |
1804 | if (!aff) |
1805 | return NULL((void*)0); |
1806 | aff->v = isl_vec_cow(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])isl_sioimath_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)isl_sioimath_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, isl_dim_div); |
1831 | old_n_div = isl_aff_domain_dim(aff, isl_dim_div); |
1832 | new_n_div = isl_mat_rows(div); |
1833 | if (offset < 0 || old_n_div < 0 || new_n_div < 0) |
1834 | goto error; |
1835 | |
1836 | aff->v = isl_vec_expand(aff->v, 1 + offset, old_n_div, exp, new_n_div); |
1837 | aff->ls = isl_local_space_replace_divs(aff->ls, div); |
1838 | if (!aff->v || !aff->ls) |
1839 | return isl_aff_free(aff); |
1840 | return aff; |
1841 | error: |
1842 | isl_aff_free(aff); |
1843 | isl_mat_free(div); |
1844 | return NULL((void*)0); |
1845 | } |
1846 | |
1847 | /* Add two affine expressions that live in the same local space. |
1848 | */ |
1849 | static __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(aff1); |
1855 | if (!aff1 || !aff2) |
1856 | goto error; |
1857 | |
1858 | aff1->v = isl_vec_cow(aff1->v); |
1859 | if (!aff1->v) |
1860 | goto error; |
1861 | |
1862 | isl_int_init(gcd)isl_sioimath_init((gcd)); |
1863 | isl_int_init(f)isl_sioimath_init((f)); |
1864 | isl_int_gcd(gcd, aff1->v->el[0], aff2->v->el[0])isl_sioimath_gcd((gcd), *(aff1->v->el[0]), *(aff2->v ->el[0])); |
1865 | isl_int_divexact(f, aff2->v->el[0], gcd)isl_sioimath_tdiv_q((f), *(aff2->v->el[0]), *(gcd)); |
1866 | isl_seq_scale(aff1->v->el + 1, aff1->v->el + 1, f, aff1->v->size - 1); |
1867 | isl_int_divexact(f, aff1->v->el[0], gcd)isl_sioimath_tdiv_q((f), *(aff1->v->el[0]), *(gcd)); |
1868 | isl_seq_addmul(aff1->v->el + 1, f, aff2->v->el + 1, aff1->v->size - 1); |
1869 | isl_int_divexact(f, aff2->v->el[0], gcd)isl_sioimath_tdiv_q((f), *(aff2->v->el[0]), *(gcd)); |
1870 | isl_int_mul(aff1->v->el[0], aff1->v->el[0], f)isl_sioimath_mul((aff1->v->el[0]), *(aff1->v->el[ 0]), *(f)); |
1871 | isl_int_clear(f)isl_sioimath_clear((f)); |
1872 | isl_int_clear(gcd)isl_sioimath_clear((gcd)); |
1873 | |
1874 | isl_aff_free(aff2); |
1875 | aff1 = isl_aff_normalize(aff1); |
1876 | return aff1; |
1877 | error: |
1878 | isl_aff_free(aff1); |
1879 | isl_aff_free(aff2); |
1880 | return NULL((void*)0); |
1881 | } |
1882 | |
1883 | /* Replace one of the arguments by a NaN and free the other one. |
1884 | */ |
1885 | static __isl_give isl_aff *set_nan_free(__isl_take isl_aff *aff1, |
1886 | __isl_take isl_aff *aff2) |
1887 | { |
1888 | isl_aff_free(aff2); |
1889 | return isl_aff_set_nan(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((void*)0); |
1901 | int *exp2 = NULL((void*)0); |
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(aff1); |
1909 | if (!isl_space_is_equal(aff1->ls->dim, aff2->ls->dim)) |
1910 | isl_die(ctx, isl_error_invalid,do { isl_handle_error(ctx, isl_error_invalid, "spaces don't match" , "polly/lib/External/isl/isl_aff.c", 1911); goto error; } while (0) |
1911 | "spaces don't match", goto error)do { isl_handle_error(ctx, isl_error_invalid, "spaces don't match" , "polly/lib/External/isl/isl_aff.c", 1911); goto error; } while (0); |
1912 | |
1913 | if (isl_aff_is_nan(aff1)) { |
1914 | isl_aff_free(aff2); |
1915 | return aff1; |
1916 | } |
1917 | if (isl_aff_is_nan(aff2)) { |
1918 | isl_aff_free(aff1); |
1919 | return aff2; |
1920 | } |
1921 | |
1922 | n_div1 = isl_aff_dim(aff1, isl_dim_div); |
1923 | n_div2 = isl_aff_dim(aff2, 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)((int *)isl_malloc_or_die(ctx, (n_div1)*sizeof(int))); |
1930 | exp2 = isl_alloc_array(ctx, int, n_div2)((int *)isl_malloc_or_die(ctx, (n_div2)*sizeof(int))); |
1931 | if ((n_div1 && !exp1) || (n_div2 && !exp2)) |
1932 | goto error; |
1933 | |
1934 | div = isl_merge_divs(aff1->ls->div, aff2->ls->div, exp1, exp2); |
1935 | aff1 = isl_aff_expand_divs(aff1, isl_mat_copy(div), exp1); |
1936 | aff2 = isl_aff_expand_divs(aff2, div, exp2); |
1937 | free(exp1); |
1938 | free(exp2); |
1939 | |
1940 | return add_expanded(aff1, aff2); |
1941 | error: |
1942 | free(exp1); |
1943 | free(exp2); |
1944 | isl_aff_free(aff1); |
1945 | isl_aff_free(aff2); |
1946 | return NULL((void*)0); |
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, isl_aff_neg(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((void*)0); |
1965 | if (isl_aff_is_nan(aff)) |
1966 | return aff; |
1967 | |
1968 | if (isl_int_is_one(f)(isl_sioimath_cmp_si(*(f), 1) == 0)) |
1969 | return aff; |
1970 | |
1971 | aff = isl_aff_cow(aff); |
1972 | if (!aff) |
1973 | return NULL((void*)0); |
1974 | aff->v = isl_vec_cow(aff->v); |
1975 | if (!aff->v) |
1976 | return isl_aff_free(aff); |
1977 | |
1978 | if (isl_int_is_pos(f)(isl_sioimath_sgn(*(f)) > 0) && isl_int_is_divisible_by(aff->v->el[0], f)isl_sioimath_is_divisible_by(*(aff->v->el[0]), *(f))) { |
1979 | isl_int_divexact(aff->v->el[0], aff->v->el[0], f)isl_sioimath_tdiv_q((aff->v->el[0]), *(aff->v->el [0]), *(f)); |
1980 | return aff; |
1981 | } |
1982 | |
1983 | isl_int_init(gcd)isl_sioimath_init((gcd)); |
1984 | isl_int_gcd(gcd, aff->v->el[0], f)isl_sioimath_gcd((gcd), *(aff->v->el[0]), *(f)); |
1985 | isl_int_divexact(aff->v->el[0], aff->v->el[0], gcd)isl_sioimath_tdiv_q((aff->v->el[0]), *(aff->v->el [0]), *(gcd)); |
1986 | isl_int_divexact(gcd, f, gcd)isl_sioimath_tdiv_q((gcd), *(f), *(gcd)); |
1987 | isl_seq_scale(aff->v->el + 1, aff->v->el + 1, gcd, aff->v->size - 1); |
1988 | isl_int_clear(gcd)isl_sioimath_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,do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "expecting rational factor", "polly/lib/External/isl/isl_aff.c" , 2008); goto error; } while (0) |
2008 | "expecting rational factor", goto error)do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "expecting rational factor", "polly/lib/External/isl/isl_aff.c" , 2008); goto error; } while (0); |
2009 | |
2010 | aff = isl_aff_scale(aff, v->n); |
2011 | aff = isl_aff_scale_down(aff, v->d); |
2012 | |
2013 | isl_val_free(v); |
2014 | return aff; |
2015 | error: |
2016 | isl_aff_free(aff); |
2017 | isl_val_free(v); |
2018 | return NULL((void*)0); |
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((void*)0); |
2031 | if (isl_aff_is_nan(aff)) |
2032 | return aff; |
2033 | |
2034 | if (isl_int_is_one(f)(isl_sioimath_cmp_si(*(f), 1) == 0)) |
2035 | return aff; |
2036 | |
2037 | aff = isl_aff_cow(aff); |
2038 | if (!aff) |
2039 | return NULL((void*)0); |
2040 | |
2041 | if (isl_int_is_zero(f)(isl_sioimath_sgn(*(f)) == 0)) |
2042 | isl_die(isl_aff_get_ctx(aff), isl_error_invalid,do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "cannot scale down by zero", "polly/lib/External/isl/isl_aff.c" , 2043); return isl_aff_free(aff); } while (0) |
2043 | "cannot scale down by zero", return isl_aff_free(aff))do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "cannot scale down by zero", "polly/lib/External/isl/isl_aff.c" , 2043); return isl_aff_free(aff); } while (0); |
2044 | |
2045 | aff->v = isl_vec_cow(aff->v); |
2046 | if (!aff->v) |
2047 | return isl_aff_free(aff); |
2048 | |
2049 | isl_int_init(gcd)isl_sioimath_init((gcd)); |
2050 | isl_seq_gcd(aff->v->el + 1, aff->v->size - 1, &gcd); |
2051 | isl_int_gcd(gcd, gcd, f)isl_sioimath_gcd((gcd), *(gcd), *(f)); |
2052 | isl_seq_scale_down(aff->v->el + 1, aff->v->el + 1, gcd, aff->v->size - 1); |
2053 | isl_int_divexact(gcd, f, gcd)isl_sioimath_tdiv_q((gcd), *(f), *(gcd)); |
2054 | isl_int_mul(aff->v->el[0], aff->v->el[0], gcd)isl_sioimath_mul((aff->v->el[0]), *(aff->v->el[0] ), *(gcd)); |
2055 | isl_int_clear(gcd)isl_sioimath_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,do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "expecting rational factor", "polly/lib/External/isl/isl_aff.c" , 2075); goto error; } while (0) |
2075 | "expecting rational factor", goto error)do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "expecting rational factor", "polly/lib/External/isl/isl_aff.c" , 2075); goto error; } while (0); |
2076 | if (!isl_val_is_pos(v)) |
2077 | isl_die(isl_aff_get_ctx(aff), isl_error_invalid,do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "factor needs to be positive", "polly/lib/External/isl/isl_aff.c" , 2078); goto error; } while (0) |
2078 | "factor needs to be positive", goto error)do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "factor needs to be positive", "polly/lib/External/isl/isl_aff.c" , 2078); goto error; } while (0); |
2079 | |
2080 | aff = isl_aff_scale(aff, v->d); |
2081 | aff = isl_aff_scale_down(aff, v->n); |
2082 | |
2083 | isl_val_free(v); |
2084 | return aff; |
2085 | error: |
2086 | isl_aff_free(aff); |
2087 | isl_val_free(v); |
2088 | return NULL((void*)0); |
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)isl_sioimath_init((v)); |
2099 | isl_int_set_ui(v, f)isl_sioimath_set_ui((v), f); |
2100 | aff = isl_aff_scale_down(aff, v); |
2101 | isl_int_clear(v)isl_sioimath_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((void*)0); |
2112 | if (type == isl_dim_out) |
2113 | isl_die(aff->v->ctx, isl_error_invalid,do { isl_handle_error(aff->v->ctx, isl_error_invalid, "cannot set name of output/set dimension" , "polly/lib/External/isl/isl_aff.c", 2115); return isl_aff_free (aff); } while (0) |
2114 | "cannot set name of output/set dimension",do { isl_handle_error(aff->v->ctx, isl_error_invalid, "cannot set name of output/set dimension" , "polly/lib/External/isl/isl_aff.c", 2115); return isl_aff_free (aff); } while (0) |
2115 | return isl_aff_free(aff))do { isl_handle_error(aff->v->ctx, isl_error_invalid, "cannot set name of output/set dimension" , "polly/lib/External/isl/isl_aff.c", 2115); return isl_aff_free (aff); } while (0); |
2116 | if (type == isl_dim_in) |
2117 | type = isl_dim_set; |
2118 | aff->ls = isl_local_space_set_dim_name(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,do { isl_handle_error(aff->v->ctx, isl_error_invalid, "cannot set name of output/set dimension" , "polly/lib/External/isl/isl_aff.c", 2134); goto error; } while (0) |
2133 | "cannot set name of output/set dimension",do { isl_handle_error(aff->v->ctx, isl_error_invalid, "cannot set name of output/set dimension" , "polly/lib/External/isl/isl_aff.c", 2134); goto error; } while (0) |
2134 | goto error)do { isl_handle_error(aff->v->ctx, isl_error_invalid, "cannot set name of output/set dimension" , "polly/lib/External/isl/isl_aff.c", 2134); goto error; } while (0); |
2135 | if (type == isl_dim_in) |
2136 | type = isl_dim_set; |
2137 | aff->ls = isl_local_space_set_dim_id(aff->ls, type, pos, id); |
2138 | if (!aff->ls) |
2139 | return isl_aff_free(aff); |
2140 | |
2141 | return aff; |
2142 | error: |
2143 | isl_id_free(id); |
2144 | isl_aff_free(aff); |
2145 | return NULL((void*)0); |
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,do { isl_handle_error(aff->v->ctx, isl_error_invalid, "cannot only set id of input tuple" , "polly/lib/External/isl/isl_aff.c", 2159); goto error; } while (0) |
2159 | "cannot only set id of input tuple", goto error)do { isl_handle_error(aff->v->ctx, isl_error_invalid, "cannot only set id of input tuple" , "polly/lib/External/isl/isl_aff.c", 2159); goto error; } while (0); |
2160 | aff->ls = isl_local_space_set_tuple_id(aff->ls, isl_dim_set, id); |
2161 | if (!aff->ls) |
2162 | return isl_aff_free(aff); |
2163 | |
2164 | return aff; |
2165 | error: |
2166 | isl_id_free(id); |
2167 | isl_aff_free(aff); |
2168 | return NULL((void*)0); |
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 | */ |
2176 | static __isl_give isl_aff *isl_aff_substitute_equalities_lifted( |
2177 | __isl_take isl_aff *aff, __isl_take isl_basic_setisl_basic_map *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(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(aff->ls, |
2195 | isl_basic_set_copy(eq)); |
2196 | aff->v = isl_vec_cow(aff->v); |
2197 | if (!aff->ls || !aff->v) |
2198 | goto error; |
2199 | |
2200 | o_div = isl_basic_set_offset(eq, 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(eq->eq[i], o_div + n_div); |
2204 | if (j < 0 || j == 0 || j >= o_div) |
2205 | continue; |
2206 | |
2207 | isl_seq_elim(aff->v->el + 1, eq->eq[i], j, o_div, |
2208 | &aff->v->el[0]); |
2209 | } |
2210 | |
2211 | isl_basic_set_free(eq); |
2212 | aff = isl_aff_normalize(aff); |
2213 | return aff; |
2214 | error: |
2215 | isl_basic_set_free(eq); |
2216 | isl_aff_free(aff); |
2217 | return NULL((void*)0); |
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_setisl_basic_map *eq) |
2225 | { |
2226 | isl_size n_div; |
2227 | |
2228 | n_div = isl_aff_domain_dim(aff, isl_dim_div); |
2229 | if (n_div < 0) |
2230 | goto error; |
2231 | if (n_div > 0) |
2232 | eq = isl_basic_set_add_dims(eq, isl_dim_set, n_div); |
2233 | return isl_aff_substitute_equalities_lifted(aff, eq); |
2234 | error: |
2235 | isl_basic_set_free(eq); |
2236 | isl_aff_free(aff); |
2237 | return NULL((void*)0); |
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_setisl_map *context) |
2247 | { |
2248 | isl_local_space *ls; |
2249 | isl_basic_setisl_basic_map *hull; |
2250 | |
2251 | ls = isl_aff_get_domain_local_space(aff); |
2252 | context = isl_local_space_lift_set(ls, context); |
2253 | |
2254 | hull = isl_set_affine_hull(context); |
2255 | return isl_aff_substitute_equalities_lifted(aff, hull); |
2256 | } |
2257 | |
2258 | __isl_give isl_aff *isl_aff_gist_params(__isl_take isl_aff *aff, |
2259 | __isl_take isl_setisl_map *context) |
2260 | { |
2261 | isl_setisl_map *dom_context = isl_set_universe(isl_aff_get_domain_space(aff)); |
2262 | dom_context = isl_set_intersect_params(dom_context, context); |
2263 | return isl_aff_gist(aff, 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 | */ |
2271 | static __isl_give isl_basic_setisl_basic_map *aff_pos_basic_set(__isl_take isl_aff *aff, |
2272 | int rational, void *user) |
2273 | { |
2274 | isl_constraint *ineq; |
2275 | isl_basic_setisl_basic_map *bset; |
2276 | isl_val *c; |
2277 | |
2278 | if (!aff) |
2279 | return NULL((void*)0); |
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,do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_unsupported , "rational sets not supported", "polly/lib/External/isl/isl_aff.c" , 2287); goto error; } while (0) |
2287 | "rational sets not supported", goto error)do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_unsupported , "rational sets not supported", "polly/lib/External/isl/isl_aff.c" , 2287); goto error; } while (0); |
2288 | |
2289 | ineq = isl_inequality_from_aff(aff); |
2290 | c = isl_constraint_get_constant_val(ineq); |
2291 | c = isl_val_sub_ui(c, 1); |
2292 | ineq = isl_constraint_set_constant_val(ineq, c); |
2293 | |
2294 | bset = isl_basic_set_from_constraint(ineq); |
2295 | bset = isl_basic_set_simplify(bset); |
2296 | return bset; |
2297 | error: |
2298 | isl_aff_free(aff); |
2299 | return NULL((void*)0); |
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 | */ |
2308 | static __isl_give isl_basic_setisl_basic_map *aff_nonneg_basic_set( |
2309 | __isl_take isl_aff *aff, int rational, void *user) |
2310 | { |
2311 | isl_constraint *ineq; |
2312 | isl_basic_setisl_basic_map *bset; |
2313 | |
2314 | if (!aff) |
2315 | return NULL((void*)0); |
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(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_setisl_basic_map *isl_aff_nonneg_basic_set(__isl_take isl_aff *aff) |
2335 | { |
2336 | return aff_nonneg_basic_set(aff, 0, NULL((void*)0)); |
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_setisl_basic_map *isl_aff_pos_basic_set(__isl_take isl_aff *aff) |
2343 | { |
2344 | aff = isl_aff_add_constant_num_si(aff, -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_setisl_basic_map *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 | */ |
2363 | static __isl_give isl_basic_setisl_basic_map *aff_zero_basic_set(__isl_take isl_aff *aff, |
2364 | int rational, void *user) |
2365 | { |
2366 | isl_constraint *ineq; |
2367 | isl_basic_setisl_basic_map *bset; |
2368 | |
2369 | if (!aff) |
2370 | return NULL((void*)0); |
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(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_setisl_basic_map *isl_aff_zero_basic_set(__isl_take isl_aff *aff) |
2390 | { |
2391 | return aff_zero_basic_set(aff, 0, NULL((void*)0)); |
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_setisl_basic_map *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(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_setisl_basic_map *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(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_setisl_map *isl_aff_ge_set(__isl_take isl_aff *aff1, |
2420 | __isl_take isl_aff *aff2) |
2421 | { |
2422 | return isl_set_from_basic_set(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_setisl_map *isl_aff_gt_set(__isl_take isl_aff *aff1, |
2432 | __isl_take isl_aff *aff2) |
2433 | { |
2434 | return isl_set_from_basic_set(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_setisl_basic_map *isl_aff_le_basic_set(__isl_take isl_aff *aff1, |
2441 | __isl_take isl_aff *aff2) |
2442 | { |
2443 | return isl_aff_ge_basic_set(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_setisl_basic_map *isl_aff_lt_basic_set(__isl_take isl_aff *aff1, |
2450 | __isl_take isl_aff *aff2) |
2451 | { |
2452 | return isl_aff_gt_basic_set(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_setisl_map *isl_aff_le_set(__isl_take isl_aff *aff1, |
2459 | __isl_take isl_aff *aff2) |
2460 | { |
2461 | return isl_aff_ge_set(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_setisl_map *isl_aff_lt_set(__isl_take isl_aff *aff1, |
2468 | __isl_take isl_aff *aff2) |
2469 | { |
2470 | return isl_set_from_basic_set(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_setisl_basic_map *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(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_setisl_map *isl_aff_eq_set(__isl_take isl_aff *aff1, |
2488 | __isl_take isl_aff *aff2) |
2489 | { |
2490 | return isl_set_from_basic_set(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_setisl_map *isl_aff_ne_set(__isl_take isl_aff *aff1, |
2500 | __isl_take isl_aff *aff2) |
2501 | { |
2502 | isl_setisl_map *set_lt, *set_gt; |
2503 | |
2504 | set_lt = isl_aff_lt_set(isl_aff_copy(aff1), |
2505 | isl_aff_copy(aff2)); |
2506 | set_gt = isl_aff_gt_set(aff1, aff2); |
2507 | return isl_set_union_disjoint(set_lt, set_gt); |
2508 | } |
2509 | |
2510 | __isl_give isl_aff *isl_aff_add_on_domain(__isl_keep isl_setisl_map *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(aff1, isl_set_copy(dom)); |
2515 | return aff1; |
2516 | } |
2517 | |
2518 | isl_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 TYPEisl_multi_union_pw_aff |
2527 | #define TYPEisl_multi_union_pw_aff isl_aff |
2528 | static |
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 | */ |
2536 | isl_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((void*)0); |
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(aff, type, first, n) < 0) |
2548 | return isl_bool_error; |
2549 | |
2550 | active = isl_local_space_get_active(aff->ls, aff->v->el + 2); |
2551 | if (!active) |
2552 | goto error; |
2553 | |
2554 | first += isl_local_space_offset(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(active); |
2562 | |
2563 | return involves; |
2564 | error: |
2565 | free(active); |
2566 | return isl_bool_error; |
2567 | } |
2568 | |
2569 | /* Does "aff" involve any local variables, i.e., integer divisions? |
2570 | */ |
2571 | isl_bool isl_aff_involves_locals(__isl_keep isl_aff *aff) |
2572 | { |
2573 | isl_size n; |
2574 | |
2575 | n = isl_aff_dim(aff, isl_dim_div); |
2576 | if (n < 0) |
2577 | return isl_bool_error; |
2578 | return isl_bool_ok(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((void*)0); |
2586 | if (type == isl_dim_out) |
2587 | isl_die(isl_aff_get_ctx(aff), isl_error_invalid,do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "cannot drop output/set dimension", "polly/lib/External/isl/isl_aff.c" , 2589); return isl_aff_free(aff); } while (0) |
2588 | "cannot drop output/set dimension",do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "cannot drop output/set dimension", "polly/lib/External/isl/isl_aff.c" , 2589); return isl_aff_free(aff); } while (0) |
2589 | return isl_aff_free(aff))do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "cannot drop output/set dimension", "polly/lib/External/isl/isl_aff.c" , 2589); return isl_aff_free(aff); } while (0); |
2590 | if (type == isl_dim_in) |
2591 | type = isl_dim_set; |
2592 | if (n == 0 && !isl_local_space_is_named_or_nested(aff->ls, type)) |
2593 | return aff; |
2594 | |
2595 | if (isl_local_space_check_range(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((void*)0); |
2601 | |
2602 | aff->ls = isl_local_space_drop_dims(aff->ls, type, first, n); |
2603 | if (!aff->ls) |
2604 | return isl_aff_free(aff); |
2605 | |
2606 | first += 1 + isl_local_space_offset(aff->ls, type); |
2607 | aff->v = isl_vec_drop_els(aff->v, 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 | */ |
2616 | static isl_bool isl_aff_domain_is_product(__isl_keep isl_aff *aff) |
2617 | { |
2618 | return isl_space_is_product(isl_aff_peek_domain_space(aff)); |
2619 | } |
2620 | |
2621 | #undef TYPEisl_multi_union_pw_aff |
2622 | #define TYPEisl_multi_union_pw_aff 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, isl_dim_in); |
2634 | if (n < 0) |
2635 | return isl_aff_free(aff); |
2636 | aff = isl_aff_drop_domain(aff, 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((void*)0); |
2662 | if (type == isl_dim_out) |
2663 | isl_die(isl_aff_get_ctx(aff), isl_error_invalid,do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "cannot insert output/set dimensions", "polly/lib/External/isl/isl_aff.c" , 2665); return isl_aff_free(aff); } while (0) |
2664 | "cannot insert output/set dimensions",do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "cannot insert output/set dimensions", "polly/lib/External/isl/isl_aff.c" , 2665); return isl_aff_free(aff); } while (0) |
2665 | return isl_aff_free(aff))do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "cannot insert output/set dimensions", "polly/lib/External/isl/isl_aff.c" , 2665); return isl_aff_free(aff); } while (0); |
2666 | if (type == isl_dim_in) |
2667 | type = isl_dim_set; |
2668 | if (n == 0 && !isl_local_space_is_named_or_nested(aff->ls, type)) |
2669 | return aff; |
2670 | |
2671 | if (isl_local_space_check_range(aff->ls, type, first, 0) < 0) |
2672 | return isl_aff_free(aff); |
2673 | |
2674 | aff = isl_aff_cow(aff); |
2675 | if (!aff) |
2676 | return NULL((void*)0); |
2677 | |
2678 | aff->ls = isl_local_space_insert_dims(aff->ls, type, first, n); |
2679 | if (!aff->ls) |
2680 | return isl_aff_free(aff); |
2681 | |
2682 | first += 1 + isl_local_space_offset(aff->ls, type); |
2683 | aff->v = isl_vec_insert_zero_els(aff->v, 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, 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((void*)0); |
2717 | if (n == 0 && |
2718 | !isl_local_space_is_named_or_nested(aff->ls, src_type) && |
2719 | !isl_local_space_is_named_or_nested(aff->ls, 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,do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "cannot move output/set dimension", "polly/lib/External/isl/isl_aff.c" , 2725); return isl_aff_free(aff); } while (0) |
2724 | "cannot move output/set dimension",do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "cannot move output/set dimension", "polly/lib/External/isl/isl_aff.c" , 2725); return isl_aff_free(aff); } while (0) |
2725 | return isl_aff_free(aff))do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "cannot move output/set dimension", "polly/lib/External/isl/isl_aff.c" , 2725); return isl_aff_free(aff); } while (0); |
2726 | if (dst_type == isl_dim_div || src_type == isl_dim_div) |
2727 | isl_die(isl_aff_get_ctx(aff), isl_error_invalid,do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "cannot move divs", "polly/lib/External/isl/isl_aff.c", 2728 ); return isl_aff_free(aff); } while (0) |
2728 | "cannot move divs", return isl_aff_free(aff))do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "cannot move divs", "polly/lib/External/isl/isl_aff.c", 2728 ); return isl_aff_free(aff); } while (0); |
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(aff->ls, src_type, 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,do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_unsupported , "moving dims within the same type not supported", "polly/lib/External/isl/isl_aff.c" , 2739); return isl_aff_free(aff); } while (0) |
2738 | "moving dims within the same type not supported",do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_unsupported , "moving dims within the same type not supported", "polly/lib/External/isl/isl_aff.c" , 2739); return isl_aff_free(aff); } while (0) |
2739 | return isl_aff_free(aff))do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_unsupported , "moving dims within the same type not supported", "polly/lib/External/isl/isl_aff.c" , 2739); return isl_aff_free(aff); } while (0); |
2740 | |
2741 | aff = isl_aff_cow(aff); |
2742 | src_off = isl_aff_domain_offset(aff, src_type); |
2743 | dst_off = isl_aff_domain_offset(aff, 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(aff->v, g_dst_pos, g_src_pos, n); |
2753 | aff->ls = isl_local_space_move_dims(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 | */ |
2768 | static __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(isl_space_domain(space)); |
2773 | return isl_aff_zero_on_domain(ls); |
2774 | } |
2775 | |
2776 | #define isl_aff_involves_nanisl_aff_is_nan isl_aff_is_nan |
2777 | |
2778 | #undef PWisl_pw_union_pw_aff |
2779 | #define PWisl_pw_union_pw_aff isl_pw_aff |
2780 | #undef BASEunion_pw_aff |
2781 | #define BASEunion_pw_aff aff |
2782 | #undef EL_IS_ZEROis_empty |
2783 | #define EL_IS_ZEROis_empty is_empty |
2784 | #undef ZEROempty |
2785 | #define ZEROempty empty |
2786 | #undef IS_ZEROis_empty |
2787 | #define IS_ZEROis_empty is_empty |
2788 | #undef FIELDmaff |
2789 | #define FIELDmaff aff |
2790 | #undef DEFAULT_IS_ZERO0 |
2791 | #define DEFAULT_IS_ZERO0 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 BASEunion_pw_aff |
2812 | #define BASEunion_pw_aff 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 BASEunion_pw_aff |
2819 | #define BASEunion_pw_aff 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(&pwaff1, &pwaff2); |
2833 | return isl_pw_aff_union_opt_cmp(pwaff1, pwaff2, &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(&pwaff1, &pwaff2); |
2846 | return isl_pw_aff_union_opt_cmp(pwaff1, pwaff2, &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 | */ |
2860 | static isl_bool isl_pw_aff_domain_is_product(__isl_keep isl_pw_aff *pa) |
2861 | { |
2862 | return isl_space_domain_is_wrapping(isl_pw_aff_peek_space(pa)); |
2863 | } |
2864 | |
2865 | #undef TYPEisl_multi_union_pw_aff |
2866 | #define TYPEisl_multi_union_pw_aff 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 | */ |
2876 | static __isl_give isl_setisl_map *pw_aff_locus(__isl_take isl_pw_aff *pwaff, |
2877 | __isl_give isl_basic_setisl_basic_map *(*fn)(__isl_take isl_aff *aff, int rational, |
2878 | void *user), |
2879 | int complement, void *user) |
2880 | { |
2881 | int i; |
2882 | isl_setisl_map *set; |
2883 | |
2884 | if (!pwaff) |
2885 | return NULL((void*)0); |
2886 | |
2887 | set = isl_set_empty(isl_pw_aff_get_domain_space(pwaff)); |
2888 | |
2889 | for (i = 0; i < pwaff->n; ++i) { |
2890 | isl_basic_setisl_basic_map *bset; |
2891 | isl_setisl_map *set_i, *locus; |
2892 | isl_bool rational; |
2893 | |
2894 | if (isl_aff_is_nan(pwaff->p[i].aff)) |
2895 | continue; |
2896 | |
2897 | rational = isl_set_has_rational(pwaff->p[i].set); |
2898 | bset = fn(isl_aff_copy(pwaff->p[i].aff), rational, user); |
2899 | locus = isl_set_from_basic_set(bset); |
2900 | set_i = isl_set_copy(pwaff->p[i].set); |
2901 | if (complement) |
2902 | set_i = isl_set_subtract(set_i, locus); |
2903 | else |
2904 | set_i = isl_set_intersect(set_i, locus); |
2905 | set = isl_set_union_disjoint(set, set_i); |
2906 | } |
2907 | |
2908 | isl_pw_aff_free(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_setisl_map *isl_pw_aff_pos_set(__isl_take isl_pw_aff *pa) |
2917 | { |
2918 | return pw_aff_locus(pa, &aff_pos_basic_set, 0, NULL((void*)0)); |
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_setisl_map *isl_pw_aff_nonneg_set(__isl_take isl_pw_aff *pwaff) |
2925 | { |
2926 | return pw_aff_locus(pwaff, &aff_nonneg_basic_set, 0, NULL((void*)0)); |
2927 | } |
2928 | |
2929 | /* Return a set containing those elements in the domain |
2930 | * of pwaff where it is zero. |
2931 | */ |
2932 | __isl_give isl_setisl_map *isl_pw_aff_zero_set(__isl_take isl_pw_aff *pwaff) |
2933 | { |
2934 | return pw_aff_locus(pwaff, &aff_zero_basic_set, 0, NULL((void*)0)); |
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_setisl_map *isl_pw_aff_non_zero_set(__isl_take isl_pw_aff *pwaff) |
2941 | { |
2942 | return pw_aff_locus(pwaff, &aff_zero_basic_set, 1, NULL((void*)0)); |
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_setisl_basic_map *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, isl_id_copy(id)); |
2957 | |
2958 | aff = isl_aff_align_params(aff, isl_space_copy(space)); |
2959 | aff_id = isl_aff_param_on_domain_space_id(space, id); |
2960 | |
2961 | return isl_aff_eq_basic_set(aff, 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 | */ |
2967 | static __isl_give isl_basic_setisl_basic_map *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((void*)0); |
2974 | if (rational) |
2975 | isl_die(isl_aff_get_ctx(aff), isl_error_unsupported,do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_unsupported , "rational binding not supported", "polly/lib/External/isl/isl_aff.c" , 2976); goto error; } while (0) |
2976 | "rational binding not supported", goto error)do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_unsupported , "rational binding not supported", "polly/lib/External/isl/isl_aff.c" , 2976); goto error; } while (0); |
2977 | return isl_aff_bind_id(aff, isl_id_copy(id)); |
2978 | error: |
2979 | isl_aff_free(aff); |
2980 | return NULL((void*)0); |
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_setisl_map *isl_pw_aff_bind_id(__isl_take isl_pw_aff *pa, |
2988 | __isl_take isl_id *id) |
2989 | { |
2990 | isl_setisl_map *bound; |
2991 | |
2992 | bound = pw_aff_locus(pa, &aff_bind_id, 0, 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 | */ |
3007 | static __isl_give isl_setisl_map *pw_aff_gte_set(__isl_take isl_pw_aff *pwaff1, |
3008 | __isl_take isl_pw_aff *pwaff2, int strict, int equal) |
3009 | { |
3010 | isl_setisl_map *set1, *set2; |
3011 | |
3012 | set1 = isl_pw_aff_domain(isl_pw_aff_copy(pwaff1)); |
3013 | set2 = isl_pw_aff_domain(isl_pw_aff_copy(pwaff2)); |
3014 | set1 = isl_set_intersect(set1, set2); |
3015 | pwaff1 = isl_pw_aff_intersect_domain(pwaff1, isl_set_copy(set1)); |
3016 | pwaff2 = isl_pw_aff_intersect_domain(pwaff2, isl_set_copy(set1)); |
3017 | pwaff1 = isl_pw_aff_add(pwaff1, isl_pw_aff_neg(pwaff2)); |
3018 | |
3019 | if (strict) { |
3020 | isl_space *space = isl_set_get_space(set1); |
3021 | isl_aff *aff; |
3022 | aff = isl_aff_zero_on_domain(isl_local_space_from_space(space)); |
3023 | aff = isl_aff_add_constant_si(aff, -1); |
3024 | pwaff1 = isl_pw_aff_add(pwaff1, isl_pw_aff_alloc(set1, aff)); |
3025 | } else |
3026 | isl_set_free(set1); |
3027 | |
3028 | if (equal) |
3029 | return isl_pw_aff_zero_set(pwaff1); |
3030 | return isl_pw_aff_nonneg_set(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_setisl_map *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(&pwaff1, &pwaff2); |
3040 | return pw_aff_gte_set(pwaff1, pwaff2, 0, 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_setisl_map *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(&pwaff1, &pwaff2); |
3050 | return pw_aff_gte_set(pwaff1, pwaff2, 0, 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_setisl_map *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(&pwaff1, &pwaff2); |
3060 | return pw_aff_gte_set(pwaff1, pwaff2, 1, 0); |
3061 | } |
3062 | |
3063 | __isl_give isl_setisl_map *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(pwaff2, pwaff1); |
3067 | } |
3068 | |
3069 | __isl_give isl_setisl_map *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(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 | */ |
3085 | static __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_setisl_map *(*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_setisl_map *set; |
3093 | |
3094 | isl_pw_aff_align_params_bin(&pa1, &pa2); |
3095 | space1 = isl_space_domain(isl_pw_aff_get_space(pa1)); |
3096 | space2 = isl_space_domain(isl_pw_aff_get_space(pa2)); |
3097 | space1 = isl_space_map_from_domain_and_range(space1, space2); |
3098 | ma = isl_multi_aff_domain_map(isl_space_copy(space1)); |
3099 | pa1 = isl_pw_aff_pullback_multi_aff(pa1, ma); |
3100 | ma = isl_multi_aff_range_map(space1); |
3101 | pa2 = isl_pw_aff_pullback_multi_aff(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, &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, &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, &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, &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, &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 | */ |
3159 | static __isl_give isl_setisl_map *pw_aff_list_set(__isl_take isl_pw_aff_list *list1, |
3160 | __isl_take isl_pw_aff_list *list2, |
3161 | __isl_give isl_setisl_map *(*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_setisl_map *set; |
3167 | |
3168 | if (!list1 || !list2) |
3169 | goto error; |
3170 | |
3171 | ctx = isl_pw_aff_list_get_ctx(list1); |
3172 | if (list1->n < 1 || list2->n < 1) |
3173 | isl_die(ctx, isl_error_invalid,do { isl_handle_error(ctx, isl_error_invalid, "list should contain at least one element" , "polly/lib/External/isl/isl_aff.c", 3174); goto error; } while (0) |
3174 | "list should contain at least one element", goto error)do { isl_handle_error(ctx, isl_error_invalid, "list should contain at least one element" , "polly/lib/External/isl/isl_aff.c", 3174); goto error; } while (0); |
3175 | |
3176 | set = isl_set_universe(isl_pw_aff_get_domain_space(list1->p[0])); |
3177 | for (i = 0; i < list1->n; ++i) |
3178 | for (j = 0; j < list2->n; ++j) { |
3179 | isl_setisl_map *set_ij; |
3180 | |
3181 | set_ij = fn(isl_pw_aff_copy(list1->p[i]), |
3182 | isl_pw_aff_copy(list2->p[j])); |
3183 | set = isl_set_intersect(set, set_ij); |
3184 | } |
3185 | |
3186 | isl_pw_aff_list_free(list1); |
3187 | isl_pw_aff_list_free(list2); |
3188 | return set; |
3189 | error: |
3190 | isl_pw_aff_list_free(list1); |
3191 | isl_pw_aff_list_free(list2); |
3192 | return NULL((void*)0); |
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_setisl_map *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, &isl_pw_aff_eq_set); |
3203 | } |
3204 | |
3205 | __isl_give isl_setisl_map *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, &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_setisl_map *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, &isl_pw_aff_le_set); |
3219 | } |
3220 | |
3221 | __isl_give isl_setisl_map *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, &isl_pw_aff_lt_set); |
3225 | } |
3226 | |
3227 | __isl_give isl_setisl_map *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, &isl_pw_aff_ge_set); |
3231 | } |
3232 | |
3233 | __isl_give isl_setisl_map *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, &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_setisl_map *isl_pw_aff_ne_set(__isl_take isl_pw_aff *pwaff1, |
3244 | __isl_take isl_pw_aff *pwaff2) |
3245 | { |
3246 | isl_setisl_map *set_lt, *set_gt; |
3247 | |
3248 | isl_pw_aff_align_params_bin(&pwaff1, &pwaff2); |
3249 | set_lt = isl_pw_aff_lt_set(isl_pw_aff_copy(pwaff1), |
3250 | isl_pw_aff_copy(pwaff2)); |
3251 | set_gt = isl_pw_aff_gt_set(pwaff1, pwaff2); |
3252 | return isl_set_union_disjoint(set_lt, 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)(isl_sioimath_cmp_si(*(v), 1) == 0)) |
3261 | return pwaff; |
3262 | if (!isl_int_is_pos(v)(isl_sioimath_sgn(*(v)) > 0)) |
3263 | isl_die(isl_pw_aff_get_ctx(pwaff), isl_error_invalid,do { isl_handle_error(isl_pw_aff_get_ctx(pwaff), isl_error_invalid , "factor needs to be positive", "polly/lib/External/isl/isl_aff.c" , 3265); return isl_pw_aff_free(pwaff); } while (0) |
3264 | "factor needs to be positive",do { isl_handle_error(isl_pw_aff_get_ctx(pwaff), isl_error_invalid , "factor needs to be positive", "polly/lib/External/isl/isl_aff.c" , 3265); return isl_pw_aff_free(pwaff); } while (0) |
3265 | return isl_pw_aff_free(pwaff))do { isl_handle_error(isl_pw_aff_get_ctx(pwaff), isl_error_invalid , "factor needs to be positive", "polly/lib/External/isl/isl_aff.c" , 3265); return isl_pw_aff_free(pwaff); } while (0); |
3266 | pwaff = isl_pw_aff_cow(pwaff); |
3267 | if (!pwaff) |
3268 | return NULL((void*)0); |
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(pwaff->p[i].aff, v); |
3274 | if (!pwaff->p[i].aff) |
3275 | return isl_pw_aff_free(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(pwaff, &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(pwaff, &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 | */ |
3295 | static __isl_give isl_pw_aff *isl_pw_aff_select( |
3296 | __isl_take isl_setisl_map *cond1, __isl_take isl_pw_aff *pwaff1, |
3297 | __isl_take isl_setisl_map *cond2, __isl_take isl_pw_aff *pwaff2) |
3298 | { |
3299 | pwaff1 = isl_pw_aff_intersect_domain(pwaff1, cond1); |
3300 | pwaff2 = isl_pw_aff_intersect_domain(pwaff2, cond2); |
3301 | |
3302 | return isl_pw_aff_add_disjoint(pwaff1, 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_setisl_map *cond_true, *cond_false; |
3321 | isl_bool equal; |
3322 | |
3323 | if (!cond) |
3324 | goto error; |
3325 | if (isl_pw_aff_involves_nan(cond)) { |
3326 | isl_space *space = isl_pw_aff_get_domain_space(cond); |
3327 | isl_local_space *ls = isl_local_space_from_space(space); |
3328 | isl_pw_aff_free(cond); |
3329 | isl_pw_aff_free(pwaff_true); |
3330 | isl_pw_aff_free(pwaff_false); |
3331 | return isl_pw_aff_nan_on_domain(ls); |
3332 | } |
3333 | |
3334 | pwaff_true = isl_pw_aff_align_params(pwaff_true, |
3335 | isl_pw_aff_get_space(pwaff_false)); |
3336 | pwaff_false = isl_pw_aff_align_params(pwaff_false, |
3337 | isl_pw_aff_get_space(pwaff_true)); |
3338 | equal = isl_pw_aff_plain_is_equal(pwaff_true, pwaff_false); |
3339 | if (equal < 0) |
3340 | goto error; |
3341 | if (equal) { |
3342 | isl_setisl_map *dom; |
3343 | |
3344 | dom = isl_set_coalesce(isl_pw_aff_domain(cond)); |
3345 | isl_pw_aff_free(pwaff_false); |
3346 | return isl_pw_aff_intersect_domain(pwaff_true, dom); |
3347 | } |
3348 | |
3349 | cond_true = isl_pw_aff_non_zero_set(isl_pw_aff_copy(cond)); |
3350 | cond_false = isl_pw_aff_zero_set(cond); |
3351 | return isl_pw_aff_select(cond_true, pwaff_true, |
3352 | cond_false, pwaff_false); |
3353 | error: |
3354 | isl_pw_aff_free(cond); |
3355 | isl_pw_aff_free(pwaff_true); |
3356 | isl_pw_aff_free(pwaff_false); |
3357 | return NULL((void*)0); |
3358 | } |
3359 | |
3360 | isl_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(aff->v->el + 2, aff->v->size - 2); |
3368 | return isl_bool_ok(pos == -1); |
3369 | } |
3370 | |
3371 | /* Check whether pwaff is a piecewise constant. |
3372 | */ |
3373 | isl_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(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(aff1)) { |
3402 | isl_aff_free(aff2); |
3403 | return aff1; |
3404 | } |
3405 | if (isl_aff_is_nan(aff2)) { |
3406 | isl_aff_free(aff1); |
3407 | return aff2; |
3408 | } |
3409 | |
3410 | if (!isl_aff_is_cst(aff2) && isl_aff_is_cst(aff1)) |
3411 | return isl_aff_mul(aff2, aff1); |
3412 | |
3413 | if (!isl_aff_is_cst(aff2)) |
3414 | isl_die(isl_aff_get_ctx(aff1), isl_error_invalid,do { isl_handle_error(isl_aff_get_ctx(aff1), isl_error_invalid , "at least one affine expression should be constant", "polly/lib/External/isl/isl_aff.c" , 3416); goto error; } while (0) |
3415 | "at least one affine expression should be constant",do { isl_handle_error(isl_aff_get_ctx(aff1), isl_error_invalid , "at least one affine expression should be constant", "polly/lib/External/isl/isl_aff.c" , 3416); goto error; } while (0) |
3416 | goto error)do { isl_handle_error(isl_aff_get_ctx(aff1), isl_error_invalid , "at least one affine expression should be constant", "polly/lib/External/isl/isl_aff.c" , 3416); goto error; } while (0); |
3417 | |
3418 | aff1 = isl_aff_cow(aff1); |
3419 | if (!aff1 || !aff2) |
3420 | goto error; |
3421 | |
3422 | aff1 = isl_aff_scale(aff1, aff2->v->el[1]); |
3423 | aff1 = isl_aff_scale_down(aff1, aff2->v->el[0]); |
3424 | |
3425 | isl_aff_free(aff2); |
3426 | return aff1; |
3427 | error: |
3428 | isl_aff_free(aff1); |
3429 | isl_aff_free(aff2); |
3430 | return NULL((void*)0); |
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(aff1)) { |
3448 | isl_aff_free(aff2); |
3449 | return aff1; |
3450 | } |
3451 | if (isl_aff_is_nan(aff2)) { |
3452 | isl_aff_free(aff1); |
3453 | return aff2; |
3454 | } |
3455 | |
3456 | is_cst = isl_aff_is_cst(aff2); |
3457 | if (is_cst < 0) |
3458 | goto error; |
3459 | if (!is_cst) |
3460 | isl_die(isl_aff_get_ctx(aff2), isl_error_invalid,do { isl_handle_error(isl_aff_get_ctx(aff2), isl_error_invalid , "second argument should be a constant", "polly/lib/External/isl/isl_aff.c" , 3461); goto error; } while (0) |
3461 | "second argument should be a constant", goto error)do { isl_handle_error(isl_aff_get_ctx(aff2), isl_error_invalid , "second argument should be a constant", "polly/lib/External/isl/isl_aff.c" , 3461); goto error; } while (0); |
3462 | is_zero = isl_aff_plain_is_zero(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])(isl_sioimath_sgn(*(aff2->v->el[1])) < 0); |
3469 | if (neg) { |
3470 | isl_int_neg(aff2->v->el[0], aff2->v->el[0])isl_sioimath_neg((aff2->v->el[0]), *(aff2->v->el[ 0])); |
3471 | isl_int_neg(aff2->v->el[1], aff2->v->el[1])isl_sioimath_neg((aff2->v->el[1]), *(aff2->v->el[ 1])); |
3472 | } |
3473 | |
3474 | aff1 = isl_aff_scale(aff1, aff2->v->el[0]); |
3475 | aff1 = isl_aff_scale_down(aff1, aff2->v->el[1]); |
3476 | |
3477 | if (neg) { |
3478 | isl_int_neg(aff2->v->el[0], aff2->v->el[0])isl_sioimath_neg((aff2->v->el[0]), *(aff2->v->el[ 0])); |
3479 | isl_int_neg(aff2->v->el[1], aff2->v->el[1])isl_sioimath_neg((aff2->v->el[1]), *(aff2->v->el[ 1])); |
3480 | } |
3481 | |
3482 | isl_aff_free(aff2); |
3483 | return aff1; |
3484 | error: |
3485 | isl_aff_free(aff1); |
3486 | isl_aff_free(aff2); |
3487 | return NULL((void*)0); |
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(&pwaff1, &pwaff2); |
3494 | return isl_pw_aff_on_shared_domain(pwaff1, pwaff2, &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(&pwaff1, &pwaff2); |
3501 | return isl_pw_aff_on_shared_domain(pwaff1, pwaff2, &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(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,do { isl_handle_error(isl_pw_aff_get_ctx(pa2), isl_error_invalid , "second argument should be a piecewise constant", "polly/lib/External/isl/isl_aff.c" , 3517); goto error; } while (0) |
3516 | "second argument should be a piecewise constant",do { isl_handle_error(isl_pw_aff_get_ctx(pa2), isl_error_invalid , "second argument should be a piecewise constant", "polly/lib/External/isl/isl_aff.c" , 3517); goto error; } while (0) |
3517 | goto error)do { isl_handle_error(isl_pw_aff_get_ctx(pa2), isl_error_invalid , "second argument should be a piecewise constant", "polly/lib/External/isl/isl_aff.c" , 3517); goto error; } while (0); |
3518 | isl_pw_aff_align_params_bin(&pa1, &pa2); |
3519 | return isl_pw_aff_on_shared_domain(pa1, pa2, &isl_aff_div); |
3520 | error: |
3521 | isl_pw_aff_free(pa1); |
3522 | isl_pw_aff_free(pa2); |
3523 | return NULL((void*)0); |
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_setisl_map *cond; |
3540 | isl_pw_aff *f, *c; |
3541 | |
3542 | is_cst = isl_pw_aff_is_cst(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,do { isl_handle_error(isl_pw_aff_get_ctx(pa2), isl_error_invalid , "second argument should be a piecewise constant", "polly/lib/External/isl/isl_aff.c" , 3548); goto error; } while (0) |
3547 | "second argument should be a piecewise constant",do { isl_handle_error(isl_pw_aff_get_ctx(pa2), isl_error_invalid , "second argument should be a piecewise constant", "polly/lib/External/isl/isl_aff.c" , 3548); goto error; } while (0) |
3548 | goto error)do { isl_handle_error(isl_pw_aff_get_ctx(pa2), isl_error_invalid , "second argument should be a piecewise constant", "polly/lib/External/isl/isl_aff.c" , 3548); goto error; } while (0); |
3549 | |
3550 | pa1 = isl_pw_aff_div(pa1, pa2); |
3551 | |
3552 | cond = isl_pw_aff_nonneg_set(isl_pw_aff_copy(pa1)); |
3553 | f = isl_pw_aff_floor(isl_pw_aff_copy(pa1)); |
3554 | c = isl_pw_aff_ceil(pa1); |
3555 | return isl_pw_aff_cond(isl_set_indicator_function(cond), f, c); |
3556 | error: |
3557 | isl_pw_aff_free(pa1); |
3558 | isl_pw_aff_free(pa2); |
3559 | return NULL((void*)0); |
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(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,do { isl_handle_error(isl_pw_aff_get_ctx(pa2), isl_error_invalid , "second argument should be a piecewise constant", "polly/lib/External/isl/isl_aff.c" , 3583); goto error; } while (0) |
3582 | "second argument should be a piecewise constant",do { isl_handle_error(isl_pw_aff_get_ctx(pa2), isl_error_invalid , "second argument should be a piecewise constant", "polly/lib/External/isl/isl_aff.c" , 3583); goto error; } while (0) |
3583 | goto error)do { isl_handle_error(isl_pw_aff_get_ctx(pa2), isl_error_invalid , "second argument should be a piecewise constant", "polly/lib/External/isl/isl_aff.c" , 3583); goto error; } while (0); |
3584 | res = isl_pw_aff_tdiv_q(isl_pw_aff_copy(pa1), isl_pw_aff_copy(pa2)); |
3585 | res = isl_pw_aff_mul(pa2, res); |
3586 | res = isl_pw_aff_sub(pa1, res); |
3587 | return res; |
3588 | error: |
3589 | isl_pw_aff_free(pa1); |
3590 | isl_pw_aff_free(pa2); |
3591 | return NULL((void*)0); |
3592 | } |
3593 | |
3594 | /* Does either of "pa1" or "pa2" involve any NaN? |
3595 | */ |
3596 | static 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(pa1); |
3602 | if (has_nan < 0 || has_nan) |
3603 | return has_nan; |
3604 | return isl_pw_aff_involves_nan(pa2); |
3605 | } |
3606 | |
3607 | /* Return a piecewise affine expression defined on the specified domain |
3608 | * that represents NaN. |
3609 | */ |
3610 | static __isl_give isl_pw_aff *nan_on_domain_set(__isl_take isl_setisl_map *dom) |
3611 | { |
3612 | isl_local_space *ls; |
3613 | isl_pw_aff *pa; |
3614 | |
3615 | ls = isl_local_space_from_space(isl_set_get_space(dom)); |
3616 | pa = isl_pw_aff_nan_on_domain(ls); |
3617 | pa = isl_pw_aff_intersect_domain(pa, 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 | */ |
3628 | static __isl_give isl_pw_aff *replace_by_nan(__isl_take isl_pw_aff *pa1, |
3629 | __isl_take isl_pw_aff *pa2) |
3630 | { |
3631 | isl_setisl_map *dom; |
3632 | |
3633 | dom = isl_set_intersect(isl_pw_aff_domain(pa1), isl_pw_aff_domain(pa2)); |
3634 | return nan_on_domain_set(dom); |
3635 | } |
3636 | |
3637 | static __isl_give isl_pw_aff *pw_aff_min(__isl_take isl_pw_aff *pwaff1, |
3638 | __isl_take isl_pw_aff *pwaff2) |
3639 | { |
3640 | isl_setisl_map *le; |
3641 | isl_setisl_map *dom; |
3642 | |
3643 | dom = isl_set_intersect(isl_pw_aff_domain(isl_pw_aff_copy(pwaff1)), |
3644 | isl_pw_aff_domain(isl_pw_aff_copy(pwaff2))); |
3645 | le = isl_pw_aff_le_set(isl_pw_aff_copy(pwaff1), |
3646 | isl_pw_aff_copy(pwaff2)); |
3647 | dom = isl_set_subtract(dom, isl_set_copy(le)); |
3648 | return isl_pw_aff_select(le, pwaff1, dom, pwaff2); |
3649 | } |
3650 | |
3651 | static __isl_give isl_pw_aff *pw_aff_max(__isl_take isl_pw_aff *pwaff1, |
3652 | __isl_take isl_pw_aff *pwaff2) |
3653 | { |
3654 | isl_setisl_map *ge; |
3655 | isl_setisl_map *dom; |
3656 | |
3657 | dom = isl_set_intersect(isl_pw_aff_domain(isl_pw_aff_copy(pwaff1)), |
3658 | isl_pw_aff_domain(isl_pw_aff_copy(pwaff2))); |
3659 | ge = isl_pw_aff_ge_set(isl_pw_aff_copy(pwaff1), |
3660 | isl_pw_aff_copy(pwaff2)); |
3661 | dom = isl_set_subtract(dom, isl_set_copy(ge)); |
3662 | return isl_pw_aff_select(ge, pwaff1, 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 | */ |
3670 | static __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(pa1); |
3678 | else if (has_nan) |
3679 | return replace_by_nan(pa1, pa2); |
3680 | |
3681 | isl_pw_aff_align_params_bin(&pa1, &pa2); |
3682 | if (max) |
3683 | return pw_aff_max(pa1, pa2); |
3684 | else |
3685 | return pw_aff_min(pa1, 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(pwaff1, pwaff2, 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(pwaff1, pwaff2, 1); |
3702 | } |
3703 | |
3704 | /* Does "pa" not involve any NaN? |
3705 | */ |
3706 | static isl_bool pw_aff_no_nan(__isl_keep isl_pw_aff *pa, void *user) |
3707 | { |
3708 | return isl_bool_not(isl_pw_aff_involves_nan(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 | */ |
3715 | static isl_bool isl_pw_aff_list_involves_nan(__isl_keep isl_pw_aff_list *list) |
3716 | { |
3717 | return isl_bool_not(isl_pw_aff_list_every(list, &pw_aff_no_nan, NULL((void*)0))); |
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 | */ |
3727 | static __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_setisl_map *dom; |
3732 | |
3733 | dom = isl_pw_aff_domain(isl_pw_aff_list_get_at(list, 0)); |
3734 | for (i = 1; i < n; ++i) { |
3735 | isl_setisl_map *dom_i; |
3736 | |
3737 | dom_i = isl_pw_aff_domain(isl_pw_aff_list_get_at(list, i)); |
3738 | dom = isl_set_intersect(dom, 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 | */ |
3749 | static __isl_give isl_setisl_map *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, pos1); |
3755 | pa2 = isl_pw_aff_list_get_at(list, pos2); |
3756 | |
3757 | if (pos1 < pos2) |
3758 | return isl_pw_aff_le_set(pa1, pa2); |
3759 | else |
3760 | return isl_pw_aff_lt_set(pa1, 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 | */ |
3788 | static __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,do { isl_handle_error(isl_pw_aff_list_get_ctx(list), isl_error_invalid , "list should contain at least one element", "polly/lib/External/isl/isl_aff.c" , 3802); goto error; } while (0) |
3802 | "list should contain at least one element", goto error)do { isl_handle_error(isl_pw_aff_list_get_ctx(list), isl_error_invalid , "list should contain at least one element", "polly/lib/External/isl/isl_aff.c" , 3802); goto error; } while (0); |
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, 0); |
3811 | space = isl_pw_aff_get_space(pa); |
3812 | isl_pw_aff_free(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, i); |
3817 | for (j = 0; j < n; ++j) { |
3818 | isl_setisl_map *dom; |
3819 | |
3820 | if (j == i) |
3821 | continue; |
3822 | if (max) |
3823 | dom = less(list, j, i); |
3824 | else |
3825 | dom = less(list, i, j); |
3826 | |
3827 | pa = isl_pw_aff_intersect_domain(pa, dom); |
3828 | } |
3829 | res = isl_pw_aff_add_disjoint(res, pa); |
3830 | } |
3831 | |
3832 | isl_pw_aff_list_free(list); |
3833 | return res; |
3834 | error: |
3835 | isl_pw_aff_list_free(list); |
3836 | return NULL((void*)0); |
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, 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, 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(pwaff); |
3864 | if (!pwaff) |
3865 | return NULL((void*)0); |
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(pwaff->p[i].set); |
3871 | if (!pwaff->p[i].set) |
3872 | return isl_pw_aff_free(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((void*)0); |
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, i); |
3895 | pa = isl_pw_aff_set_rational(pa); |
3896 | list = isl_pw_aff_list_set_pw_aff(list, i, pa); |
3897 | } |
3898 | |
3899 | return list; |
3900 | } |
3901 | |
3902 | /* Do the parameters of "aff" match those of "space"? |
3903 | */ |
3904 | isl_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(space, aff_space); |
3916 | |
3917 | isl_space_free(aff_space); |
3918 | return match; |
3919 | } |
3920 | |
3921 | /* Check that the domain space of "aff" matches "space". |
3922 | */ |
3923 | isl_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(space, aff_space); |
3935 | if (match < 0) |
3936 | goto error; |
3937 | if (!match) |
3938 | isl_die(isl_aff_get_ctx(aff), isl_error_invalid,do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "parameters don't match", "polly/lib/External/isl/isl_aff.c" , 3939); goto error; } while (0) |
3939 | "parameters don't match", goto error)do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "parameters don't match", "polly/lib/External/isl/isl_aff.c" , 3939); goto error; } while (0); |
3940 | match = isl_space_tuple_is_equal(space, isl_dim_in, |
3941 | aff_space, isl_dim_set); |
3942 | if (match < 0) |
3943 | goto error; |
3944 | if (!match) |
3945 | isl_die(isl_aff_get_ctx(aff), isl_error_invalid,do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "domains don't match", "polly/lib/External/isl/isl_aff.c", 3946 ); goto error; } while (0) |
3946 | "domains don't match", goto error)do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid , "domains don't match", "polly/lib/External/isl/isl_aff.c", 3946 ); goto error; } while (0); |
3947 | isl_space_free(aff_space); |
3948 | return isl_stat_ok; |
3949 | error: |
3950 | isl_space_free(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 | */ |
3960 | static __isl_give isl_basic_setisl_basic_map *isl_multi_aff_domain( |
3961 | __isl_take isl_multi_aff *ma) |
3962 | { |
3963 | isl_space *space; |
3964 | |
3965 | space = isl_multi_aff_get_space(ma); |
3966 | isl_multi_aff_free(ma); |
3967 | |
3968 | return isl_basic_set_universe(isl_space_domain(space)); |
3969 | } |
3970 | |
3971 | #undef BASEunion_pw_aff |
3972 | #define BASEunion_pw_aff 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 DOMBASEunion_set |
3999 | #define DOMBASEunion_set set |
4000 | #include <isl_multi_gist.c> |
4001 | |
4002 | #undef DOMBASEunion_set |
4003 | #define DOMBASEunion_set 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((void*)0); |
4014 | isl_multi_aff *ma = NULL((void*)0); |
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, isl_dim_out); |
4026 | total = isl_space_dim(space, 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,do { isl_handle_error(ctx, isl_error_invalid, "insufficient number of rows" , "polly/lib/External/isl/isl_aff.c", 4031); goto error; } while (0) |
4031 | "insufficient number of rows", goto error)do { isl_handle_error(ctx, isl_error_invalid, "insufficient number of rows" , "polly/lib/External/isl/isl_aff.c", 4031); goto error; } while (0); |
4032 | if (n_col < 1) |
4033 | isl_die(ctx, isl_error_invalid,do { isl_handle_error(ctx, isl_error_invalid, "insufficient number of columns" , "polly/lib/External/isl/isl_aff.c", 4034); goto error; } while (0) |
4034 | "insufficient number of columns", goto error)do { isl_handle_error(ctx, isl_error_invalid, "insufficient number of columns" , "polly/lib/External/isl/isl_aff.c", 4034); goto error; } while (0); |
4035 | if (1 + n_out != n_row || 2 + total != n_row + n_col) |
4036 | isl_die(ctx, isl_error_invalid,do { isl_handle_error(ctx, isl_error_invalid, "dimension mismatch" , "polly/lib/External/isl/isl_aff.c", 4037); goto error; } while (0) |
4037 | "dimension mismatch", goto error)do { isl_handle_error(ctx, isl_error_invalid, "dimension mismatch" , "polly/lib/External/isl/isl_aff.c", 4037); goto error; } while (0); |
4038 | |
4039 | ma = isl_multi_aff_zero(isl_space_copy(space)); |
4040 | space = isl_space_domain(space); |
4041 | ls = isl_local_space_from_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, 1 + n_col); |
4048 | if (!v) |
4049 | goto error; |
4050 | isl_int_set(v->el[0], mat->row[0][0])isl_sioimath_set((v->el[0]), *(mat->row[0][0])); |
4051 | isl_seq_cpy(v->el + 1, mat->row[1 + i], n_col); |
4052 | v = isl_vec_normalize(v); |
4053 | aff = isl_aff_alloc_vec_validated(isl_local_space_copy(ls), v); |
4054 | ma = isl_multi_aff_set_aff(ma, i, aff); |
4055 | } |
4056 | |
4057 | isl_space_free(space); |
4058 | isl_local_space_free(ls); |
4059 | isl_mat_free(mat); |
4060 | return ma; |
4061 | error: |
4062 | isl_space_free(space); |
4063 | isl_local_space_free(ls); |
4064 | isl_mat_free(mat); |
4065 | isl_multi_aff_free(ma); |
4066 | return NULL((void*)0); |
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(ma); |
4080 | if (n < 0) |
4081 | return NULL((void*)0); |
4082 | space = isl_space_range(isl_multi_aff_get_space(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(ma, i); |
4091 | val = isl_aff_get_constant_val(aff); |
4092 | isl_aff_free(aff); |
4093 | mv = isl_multi_val_set_at(mv, i, 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((void*)0); |
4110 | |
4111 | if (!ma->space->nested[0]) |
4112 | return ma; |
4113 | |
4114 | space = isl_multi_aff_get_space(ma); |
4115 | space = isl_space_flatten_domain(space); |
4116 | ma = isl_multi_aff_reset_space(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((void*)0); |
4133 | if (!isl_space_is_map(space)) |
4134 | isl_die(isl_space_get_ctx(space), isl_error_invalid,do { isl_handle_error(isl_space_get_ctx(space), isl_error_invalid , "not a map space", "polly/lib/External/isl/isl_aff.c", 4135 ); goto error; } while (0) |
4135 | "not a map space", goto error)do { isl_handle_error(isl_space_get_ctx(space), isl_error_invalid , "not a map space", "polly/lib/External/isl/isl_aff.c", 4135 ); goto error; } while (0); |
4136 | |
4137 | n_in = isl_space_dim(space, 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(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(isl_local_space_copy(ls), |
4154 | isl_dim_set, i); |
4155 | ma = isl_multi_aff_set_aff(ma, i, aff); |
4156 | } |
4157 | isl_local_space_free(ls); |
4158 | return ma; |
4159 | error: |
4160 | isl_space_free(space); |
4161 | return NULL((void*)0); |
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((void*)0); |
4185 | if (!isl_space_is_map(space)) |
4186 | isl_die(isl_space_get_ctx(space), isl_error_invalid,do { isl_handle_error(isl_space_get_ctx(space), isl_error_invalid , "not a map space", "polly/lib/External/isl/isl_aff.c", 4187 ); goto error; } while (0) |
4187 | "not a map space", goto error)do { isl_handle_error(isl_space_get_ctx(space), isl_error_invalid , "not a map space", "polly/lib/External/isl/isl_aff.c", 4187 ); goto error; } while (0); |
4188 | |
4189 | n_in = isl_space_dim(space, isl_dim_in); |
4190 | n_out = isl_space_dim(space, 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(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(isl_local_space_copy(ls), |
4207 | isl_dim_set, n_in + i); |
4208 | ma = isl_multi_aff_set_aff(ma, i, aff); |
4209 | } |
4210 | isl_local_space_free(ls); |
4211 | return ma; |
4212 | error: |
4213 | isl_space_free(space); |
4214 | return NULL((void*)0); |
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(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(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((void*)0); |
4276 | if (!isl_space_is_set(space)) |
4277 | isl_die(isl_space_get_ctx(space), isl_error_unsupported,do { isl_handle_error(isl_space_get_ctx(space), isl_error_unsupported , "expecting set space", "polly/lib/External/isl/isl_aff.c", 4278 ); goto error; } while (0) |
4278 | "expecting set space", goto error)do { isl_handle_error(isl_space_get_ctx(space), isl_error_unsupported , "expecting set space", "polly/lib/External/isl/isl_aff.c", 4278 ); goto error; } while (0); |
4279 | if (type != isl_dim_set) |
4280 | isl_die(isl_space_get_ctx(space), isl_error_invalid,do { isl_handle_error(isl_space_get_ctx(space), isl_error_invalid , "only set dimensions can be projected out", "polly/lib/External/isl/isl_aff.c" , 4281); goto error; } while (0) |
4281 | "only set dimensions can be projected out", goto error)do { isl_handle_error(isl_space_get_ctx(space), isl_error_invalid , "only set dimensions can be projected out", "polly/lib/External/isl/isl_aff.c" , 4281); goto error; } while (0); |
4282 | if (isl_space_check_range(space, type, first, n) < 0) |
4283 | goto error; |
4284 | |
4285 | dim = isl_space_dim(space, 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, isl_dim_out, dim - n); |
4291 | |
4292 | if (dim == n) |
4293 | return isl_multi_aff_alloc(space); |
4294 | |
4295 | ma = isl_multi_aff_alloc(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(isl_local_space_copy(ls), |
4303 | isl_dim_set, i); |
4304 | ma = isl_multi_aff_set_aff(ma, i, aff); |
4305 | } |
4306 | |
4307 | for (i = 0; i < dim - (first + n); ++i) { |
4308 | isl_aff *aff; |
4309 | |
4310 | aff = isl_aff_var_on_domain(isl_local_space_copy(ls), |
4311 | isl_dim_set, first + n + i); |
4312 | ma = isl_multi_aff_set_aff(ma, first + i, aff); |
4313 | } |
4314 | |
4315 | isl_local_space_free(ls); |
4316 | return ma; |
4317 | error: |
4318 | isl_space_free(space); |
4319 | return NULL((void*)0); |
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(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 | */ |
4377 | static __isl_give isl_multi_aff *isl_multi_aff_substitute_equalities( |
4378 | __isl_take isl_multi_aff *maff, __isl_take isl_basic_setisl_basic_map *eq) |
4379 | { |
4380 | isl_size n; |
4381 | int i; |
4382 | |
4383 | n = isl_multi_aff_size(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(maff, i); |
4391 | aff = isl_aff_substitute_equalities(aff, |
4392 | isl_basic_set_copy(eq)); |
4393 | maff = isl_multi_aff_restore_at(maff, i, aff); |
4394 | } |
4395 | |
4396 | isl_basic_set_free(eq); |
4397 | return maff; |
4398 | error: |
4399 | isl_basic_set_free(eq); |
4400 | isl_multi_aff_free(maff); |
4401 | return NULL((void*)0); |
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(maff); |
4411 | if (n < 0) |
4412 | return isl_multi_aff_free(maff); |
4413 | |
4414 | for (i = 0; i < n; ++i) { |
4415 | isl_aff *aff; |
4416 | |
4417 | aff = isl_multi_aff_take_at(maff, i); |
4418 | aff = isl_aff_scale(aff, f); |
4419 | maff = isl_multi_aff_restore_at(maff, i, aff); |
4420 | } |
4421 | |
4422 | return maff; |
4423 | } |
4424 | |
4425 | __isl_give isl_multi_aff *isl_multi_aff_add_on_domain(__isl_keep isl_setisl_map *dom, |
4426 | __isl_take isl_multi_aff *maff1, __isl_take isl_multi_aff *maff2) |
4427 | { |
4428 | maff1 = isl_multi_aff_add(maff1, maff2); |
4429 | maff1 = isl_multi_aff_gist(maff1, isl_set_copy(dom)); |
4430 | return maff1; |
4431 | } |
4432 | |
4433 | isl_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_setisl_map *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(ma2, ma1); |
4448 | } |
4449 | |
4450 | /* Return the set of domain elements where "ma1" is lexicographically |
4451 | * smaller than "ma2". |
4452 | */ |
4453 | __isl_give isl_setisl_map *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(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 | */ |
4466 | static __isl_give isl_setisl_map *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(ma1); |
4472 | |
4473 | isl_multi_aff_free(ma1); |
4474 | isl_multi_aff_free(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 | */ |
4485 | static __isl_give isl_setisl_map *isl_multi_aff_order_at(__isl_keep isl_multi_aff *ma1, |
4486 | __isl_keep isl_multi_aff *ma2, int i, |
4487 | __isl_give isl_setisl_map *(*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(ma1, i); |
4493 | aff2 = isl_multi_aff_get_at(ma2, 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 | */ |
4509 | static __isl_give isl_setisl_map *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_setisl_map *res; |
4516 | isl_setisl_map *equal_set; |
4517 | isl_setisl_map *gte; |
4518 | |
4519 | if (isl_multi_aff_check_equal_space(ma1, ma2) < 0) |
4520 | goto error; |
4521 | n = isl_multi_aff_size(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(ma1); |
4528 | res = isl_set_empty(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_setisl_map *gt, *eq; |
4534 | |
4535 | gt = isl_multi_aff_order_at(ma1, ma2, i, &isl_aff_gt_set); |
4536 | gt = isl_set_intersect(gt, isl_set_copy(equal_set)); |
4537 | res = isl_set_union(res, gt); |
4538 | eq = isl_multi_aff_order_at(ma1, ma2, i, &isl_aff_eq_set); |
4539 | equal_set = isl_set_intersect(equal_set, eq); |
4540 | |
4541 | empty = isl_set_is_empty(equal_set); |
4542 | if (empty >= 0 && empty) |
4543 | break; |
4544 | } |
4545 | |
4546 | if (equal) |
4547 | gte = isl_multi_aff_order_at(ma1, ma2, n - 1, &isl_aff_ge_set); |
4548 | else |
4549 | gte = isl_multi_aff_order_at(ma1, ma2, n - 1, &isl_aff_gt_set); |
4550 | isl_multi_aff_free(ma1); |
4551 | isl_multi_aff_free(ma2); |
4552 | |
4553 | gte = isl_set_intersect(gte, equal_set); |
4554 | return isl_set_union(res, gte); |
4555 | error: |
4556 | isl_multi_aff_free(ma1); |
4557 | isl_multi_aff_free(ma2); |
4558 | return NULL((void*)0); |
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_setisl_map *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, 1); |
4568 | } |
4569 | |
4570 | /* Return the set of domain elements where "ma1" is lexicographically |
4571 | * greater than "ma2". |
4572 | */ |
4573 | __isl_give isl_setisl_map *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, 0); |
4577 | } |
4578 | |
4579 | #define isl_multi_aff_zero_in_spaceisl_multi_aff_zero isl_multi_aff_zero |
4580 | |
4581 | #undef PWisl_pw_union_pw_aff |
4582 | #define PWisl_pw_union_pw_aff isl_pw_multi_aff |
4583 | #undef BASEunion_pw_aff |
4584 | #define BASEunion_pw_aff multi_aff |
4585 | #undef EL_IS_ZEROis_empty |
4586 | #define EL_IS_ZEROis_empty is_empty |
4587 | #undef ZEROempty |
4588 | #define ZEROempty empty |
4589 | #undef IS_ZEROis_empty |
4590 | #define IS_ZEROis_empty is_empty |
4591 | #undef FIELDmaff |
4592 | #define FIELDmaff maff |
4593 | #undef DEFAULT_IS_ZERO0 |
4594 | #define DEFAULT_IS_ZERO0 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 BASEunion_pw_aff |
4614 | #define BASEunion_pw_aff 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 BASEunion_pw_aff |
4622 | #define BASEunion_pw_aff 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 | */ |
4631 | static __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(pma); |
4643 | |
4644 | space = isl_pw_multi_aff_take_space(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(pma, i); |
4651 | ma = multi_aff_factor(ma); |
4652 | pma = isl_pw_multi_aff_restore_base_at(pma, i, ma); |
4653 | } |
4654 | |
4655 | pma = isl_pw_multi_aff_restore_space(pma, space); |
4656 | |
4657 | return pma; |
4658 | } |
4659 | |
4660 | /* Is the range of "pma" a wrapped relation? |
4661 | */ |
4662 | static 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(isl_pw_multi_aff_peek_space(pma)); |
4666 | } |
4667 | |
4668 | /* Check that the range of "pma" is a product. |
4669 | */ |
4670 | static 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,do { isl_handle_error(isl_pw_multi_aff_get_ctx(pma), isl_error_invalid , "range is not a product", "polly/lib/External/isl/isl_aff.c" , 4680); return isl_stat_error; } while (0) |
4680 | "range is not a product", return isl_stat_error)do { isl_handle_error(isl_pw_multi_aff_get_ctx(pma), isl_error_invalid , "range is not a product", "polly/lib/External/isl/isl_aff.c" , 4680); return isl_stat_error; } while (0); |
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, &pw_multi_aff_check_range_product, |
4690 | &isl_space_range_factor_domain, |
4691 | &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, &pw_multi_aff_check_range_product, |
4700 | &isl_space_range_factor_range, |
4701 | &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(&pma1, &pma2); |
4715 | return isl_pw_multi_aff_union_opt_cmp(pma1, pma2, |
4716 | &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(&pma1, &pma2); |
4730 | return isl_pw_multi_aff_union_opt_cmp(pma1, pma2, |
4731 | &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(&pma1, &pma2); |
4738 | return isl_pw_multi_aff_on_shared_domain(pma1, pma2, |
4739 | &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(&pma1, &pma2); |
4748 | return isl_pw_multi_aff_on_shared_domain(pma1, pma2, |
4749 | &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(&pma1, &pma2) < 0) |
4763 | goto error; |
4764 | |
4765 | n = pma1->n * pma2->n; |
4766 | space = isl_space_product(isl_space_copy(pma1->dim), |
4767 | isl_space_copy(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_setisl_map *domain; |
4773 | isl_multi_aff *ma; |
4774 | |
4775 | domain = isl_set_product(isl_set_copy(pma1->p[i].set), |
4776 | isl_set_copy(pma2->p[j].set)); |
4777 | ma = isl_multi_aff_product( |
4778 | isl_multi_aff_copy(pma1->p[i].maff), |
4779 | isl_multi_aff_copy(pma2->p[j].maff)); |
4780 | res = isl_pw_multi_aff_add_piece(res, domain, ma); |
4781 | } |
4782 | } |
4783 | |
4784 | isl_pw_multi_aff_free(pma1); |
4785 | isl_pw_multi_aff_free(pma2); |
4786 | return res; |
4787 | error: |
4788 | isl_pw_multi_aff_free(pma1); |
4789 | isl_pw_multi_aff_free(pma2); |
4790 | return NULL((void*)0); |
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 | */ |
4798 | static __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(c, n); |
4806 | if (first == -1) |
4807 | return aff; |
4808 | |
4809 | sign = isl_int_sgn(denom)isl_sioimath_sgn(*(denom)); |
4810 | isl_int_init(d)isl_sioimath_init((d)); |
4811 | isl_int_abs(d, denom)isl_sioimath_abs((d), *(denom)); |
4812 | for (i = first; i < n; ++i) { |
4813 | isl_aff *aff_i; |
4814 | |
4815 | if (isl_int_is_zero(c[i])(isl_sioimath_sgn(*(c[i])) == 0)) |
4816 | continue; |
4817 | aff_i = isl_multi_aff_get_aff(ma, i); |
4818 | aff_i = isl_aff_scale(aff_i, c[i]); |
4819 | aff_i = isl_aff_scale_down(aff_i, d); |
4820 | if (sign >= 0) |
4821 | aff = isl_aff_sub(aff, aff_i); |
4822 | else |
4823 | aff = isl_aff_add(aff, aff_i); |
4824 | } |
4825 | isl_int_clear(d)isl_sioimath_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 | */ |
4897 | static __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(isl_local_space_copy(ls)); |
4912 | if (!aff) |
4913 | goto error; |
4914 | o_out = isl_basic_map_offset(bmap, isl_dim_out); |
4915 | n_out = isl_basic_map_dim(bmap, isl_dim_out); |
4916 | n_div = isl_basic_map_dim(bmap, 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])(isl_sioimath_sgn(*(bmap->eq[eq][o_out + pos])) < 0)) { |
4920 | isl_seq_cpy(aff->v->el + 1, bmap->eq[eq], o_out); |
4921 | isl_seq_cpy(aff->v->el + 1 + o_out, |
4922 | bmap->eq[eq] + o_out + n_out, n_div); |
4923 | } else { |
4924 | isl_seq_neg(aff->v->el + 1, bmap->eq[eq], o_out); |
4925 | isl_seq_neg(aff->v->el + 1 + o_out, |
4926 | bmap->eq[eq] + o_out + n_out, n_div); |
4927 | } |
4928 | if (div < n_div) |
4929 | isl_int_set_si(aff->v->el[1 + o_out + div], 0)isl_sioimath_set_si((aff->v->el[1 + o_out + div]), 0); |
4930 | isl_int_abs(aff->v->el[0], bmap->eq[eq][o_out + pos])isl_sioimath_abs((aff->v->el[0]), *(bmap->eq[eq][o_out + pos])); |
4931 | aff = subtract_initial(aff, ma, pos, bmap->eq[eq] + o_out, |
4932 | bmap->eq[eq][o_out + pos]); |
4933 | if (div < n_div) { |
4934 | shift = isl_aff_alloc(isl_local_space_copy(ls)); |
4935 | if (!shift) |
4936 | goto error; |
4937 | isl_seq_cpy(shift->v->el + 1, bmap->ineq[ineq], o_out); |
4938 | isl_seq_cpy(shift->v->el + 1 + o_out, |
4939 | bmap->ineq[ineq] + o_out + n_out, n_div); |
4940 | isl_int_set_si(shift->v->el[0], 1)isl_sioimath_set_si((shift->v->el[0]), 1); |
4941 | shift = subtract_initial(shift, ma, pos, |
4942 | bmap->ineq[ineq] + o_out, ctx->negone); |
4943 | aff = isl_aff_add(aff, isl_aff_copy(shift)); |
4944 | mod = isl_val_int_from_isl_int(ctx, |
4945 | bmap->eq[eq][o_out + n_out + div]); |
4946 | mod = isl_val_abs(mod); |
4947 | aff = isl_aff_mod_val(aff, mod); |
4948 | aff = isl_aff_sub(aff, shift); |
4949 | } |
4950 | |
4951 | isl_local_space_free(ls); |
4952 | return aff; |
4953 | error: |
4954 | isl_local_space_free(ls); |
4955 | isl_aff_free(aff); |
4956 | return NULL((void*)0); |
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 | */ |
4971 | static __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((void*)0); |
4979 | eq = isl_basic_map_output_defining_equality(bmap, pos, &div, &ineq); |
4980 | if (eq >= bmap->n_eq) |
4981 | isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,do { isl_handle_error(isl_basic_map_get_ctx(bmap), isl_error_invalid , "unable to find suitable equality", "polly/lib/External/isl/isl_aff.c" , 4982); return ((void*)0); } while (0) |
4982 | "unable to find suitable equality", return NULL)do { isl_handle_error(isl_basic_map_get_ctx(bmap), isl_error_invalid , "unable to find suitable equality", "polly/lib/External/isl/isl_aff.c" , 4982); return ((void*)0); } while (0); |
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 | */ |
4994 | static __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((void*)0); |
5003 | |
5004 | ma = isl_multi_aff_alloc(isl_basic_map_get_space(bmap)); |
5005 | n_out = isl_basic_map_dim(bmap, isl_dim_out); |
5006 | if (n_out < 0) |
5007 | ma = isl_multi_aff_free(ma); |
5008 | |
5009 | for (i = 0; i < n_out; ++i) { |
5010 | isl_aff *aff; |
5011 | |
5012 | aff = extract_isl_aff_from_basic_map(bmap, i, ma); |
5013 | ma = isl_multi_aff_set_aff(ma, i, 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_setisl_basic_map *bset) |
5028 | { |
5029 | return extract_isl_multi_aff_from_basic_map(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 | */ |
5050 | static __isl_give isl_pw_multi_aff *plain_pw_multi_aff_from_map( |
5051 | __isl_take isl_setisl_map *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(ma); |
5058 | return isl_pw_multi_aff_alloc(domain, 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 | */ |
5068 | static __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,do { isl_handle_error(isl_map_get_ctx(map), isl_error_invalid , "map is not single-valued", "polly/lib/External/isl/isl_aff.c" , 5080); goto error; } while (0) |
5080 | "map is not single-valued", goto error)do { isl_handle_error(isl_map_get_ctx(map), isl_error_invalid , "map is not single-valued", "polly/lib/External/isl/isl_aff.c" , 5080); goto error; } while (0); |
5081 | map = isl_map_make_disjoint(map); |
5082 | if (!map) |
5083 | return NULL((void*)0); |
5084 | |
5085 | pma = isl_pw_multi_aff_empty(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(map->p[i]); |
5091 | pma_i = isl_basic_map_lexmin_pw_multi_aff(bmap); |
5092 | pma = isl_pw_multi_aff_add_disjoint(pma, pma_i); |
5093 | } |
5094 | |
5095 | isl_map_free(map); |
5096 | return pma; |
5097 | error: |
5098 | isl_map_free(map); |
5099 | return NULL((void*)0); |
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 | */ |
5129 | static __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((void*)0); |
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(hull, isl_dim_out); |
5150 | ctx = isl_map_get_ctx(map); |
5151 | space = isl_space_domain(isl_map_get_space(map)); |
5152 | n_in = isl_space_dim(space, isl_dim_set); |
5153 | n = isl_space_dim(space, isl_dim_all); |
5154 | if (n_in < 0 || n < 0) |
5155 | goto error; |
5156 | |
5157 | v = isl_vec_alloc(ctx, 1 + 1 + n); |
5158 | if (v) { |
5159 | isl_int_neg(v->el[0], hull->ineq[i][offset + d])isl_sioimath_neg((v->el[0]), *(hull->ineq[i][offset + d ])); |
5160 | isl_seq_cpy(v->el + 1, hull->ineq[i], 1 + n); |
5161 | } |
5162 | isl_basic_map_free(hull); |
5163 | |
5164 | ls = isl_local_space_from_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(aff); |
5170 | } else { |
5171 | ma = isl_multi_aff_identity(isl_space_map_from_set(space)); |
5172 | ma = isl_multi_aff_range_product(ma, |
5173 | isl_multi_aff_from_aff(aff)); |
5174 | } |
5175 | |
5176 | insert = isl_map_from_multi_aff_internal(isl_multi_aff_copy(ma)); |
5177 | map = isl_map_apply_domain(map, insert); |
5178 | map = isl_map_equate(map, isl_dim_in, n_in, isl_dim_out, d); |
5179 | pma = isl_pw_multi_aff_from_map(map); |
5180 | pma = isl_pw_multi_aff_pullback_multi_aff(pma, ma); |
5181 | |
5182 | return pma; |
5183 | error: |
5184 | isl_space_free(space); |
5185 | isl_map_free(map); |
5186 | isl_basic_map_free(hull); |
5187 | return NULL((void*)0); |
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 | */ |
5203 | static int is_potential_div_constraint(isl_int *c, int offset, int d, int total) |
5204 | { |
5205 | if (isl_int_is_zero(c[offset + d])(isl_sioimath_sgn(*(c[offset + d])) == 0)) |
5206 | return 0; |
5207 | if (isl_int_is_one(c[offset + d])(isl_sioimath_cmp_si(*(c[offset + d]), 1) == 0)) |
5208 | return 0; |
5209 | if (isl_int_is_negone(c[offset + d])(isl_sioimath_cmp_si(*(c[offset + d]), -1) == 0)) |
5210 | return 0; |
5211 | if (isl_seq_first_non_zero(c + offset, d) != -1) |
5212 | return 0; |
5213 | if (isl_seq_first_non_zero(c + offset + d + 1, |
5214 | 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 | */ |
5252 | static __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(isl_map_copy(map)); |
5264 | dim = isl_map_dim(map, isl_dim_out); |
5265 | total = isl_basic_map_dim(hull, isl_dim_all); |
5266 | if (dim < 0 || total < 0) |
5267 | goto error; |
5268 | |
5269 | isl_int_init(sum)isl_sioimath_init((sum)); |
5270 | offset = isl_basic_map_offset(hull, 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(hull->ineq[i], |
5275 | offset, d, 1 + total)) |
5276 | continue; |
5277 | for (j = i + 1; j < n; ++j) { |
5278 | if (!isl_seq_is_neg(hull->ineq[i] + 1, |
5279 | hull->ineq[j] + 1, total)) |
5280 | continue; |
5281 | isl_int_add(sum, hull->ineq[i][0],isl_sioimath_add((sum), *(hull->ineq[i][0]), *(hull->ineq [j][0])) |
5282 | hull->ineq[j][0])isl_sioimath_add((sum), *(hull->ineq[i][0]), *(hull->ineq [j][0])); |
5283 | if (isl_int_abs_lt(sum,(isl_sioimath_abs_cmp(*(sum), *(hull->ineq[i][offset + d]) ) < 0) |
5284 | hull->ineq[i][offset + d])(isl_sioimath_abs_cmp(*(sum), *(hull->ineq[i][offset + d]) ) < 0)) |
5285 | break; |
5286 | |
5287 | } |
5288 | if (j >= n) |
5289 | continue; |
5290 | isl_int_clear(sum)isl_sioimath_clear((sum)); |
5291 | if (isl_int_is_pos(hull->ineq[j][offset + d])(isl_sioimath_sgn(*(hull->ineq[j][offset + d])) > 0)) |
5292 | j = i; |
5293 | return pw_multi_aff_from_map_div(map, hull, d, j); |
5294 | } |
5295 | } |
5296 | isl_int_clear(sum)isl_sioimath_clear((sum)); |
5297 | isl_basic_map_free(hull); |
5298 | return pw_multi_aff_from_map_base(map); |
5299 | error: |
5300 | isl_map_free(map); |
5301 | isl_basic_map_free(hull); |
5302 | return NULL((void*)0); |
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 | */ |
5326 | static __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(isl_space_copy(space)); |
5336 | space2 = isl_space_copy(space); |
5337 | if (!is_set) |
5338 | space2 = isl_space_range(isl_space_unwrap(space2)); |
5339 | space = isl_space_map_from_domain_and_range(space, space2); |
5340 | ma = isl_multi_aff_alloc(space); |
5341 | ma = isl_multi_aff_set_aff(ma, d, aff); |
5342 | |
5343 | for (i = 0; i < n_out; ++i) { |
5344 | if (i == d) |
5345 | continue; |
5346 | aff = isl_aff_var_on_domain(isl_local_space_copy(ls), |
5347 | isl_dim_set, n_in + i); |
5348 | ma = isl_multi_aff_set_aff(ma, i, 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 | */ |
5412 | static __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_setisl_map *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(hull, isl_dim_in); |
5432 | n_out = isl_basic_map_dim(hull, isl_dim_out); |
5433 | if (n_in < 0 || n_out < 0) |
5434 | goto error; |
5435 | o_out = isl_basic_map_offset(hull, 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(isl_set_get_space(set)); |
5442 | ma = isl_multi_aff_identity(space); |
5443 | ls = isl_local_space_from_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)isl_sioimath_set_si((aff->v->el[0]), 1); |
5447 | if (isl_int_is_one(hull->eq[i][o_out + d])(isl_sioimath_cmp_si(*(hull->eq[i][o_out + d]), 1) == 0)) |
5448 | isl_seq_neg(aff->v->el + 1, hull->eq[i], |
5449 | aff->v->size - 1); |
5450 | else |
5451 | isl_seq_cpy(aff->v->el + 1, hull->eq[i], |
5452 | aff->v->size - 1); |
5453 | isl_int_set(aff->v->el[1 + o_out + d], gcd)isl_sioimath_set((aff->v->el[1 + o_out + d]), *(gcd)); |
5454 | } |
5455 | ma = isl_multi_aff_set_aff(ma, n_in + d, 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(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(id, pma); |
5471 | } |
5472 | id = isl_pw_multi_aff_from_multi_aff(ma); |
5473 | pma = isl_pw_multi_aff_pullback_pw_multi_aff(id, pma); |
5474 | |
5475 | isl_basic_map_free(hull); |
5476 | return pma; |
5477 | error: |
5478 | isl_map_free(map); |
5479 | isl_basic_map_free(hull); |
5480 | return NULL((void*)0); |
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 | */ |
5498 | static __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(hull, isl_dim_div); |
5509 | n_out = isl_basic_map_dim(hull, 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(hull); |
5515 | return pw_multi_aff_from_map_check_div(map); |
5516 | } |
5517 | |
5518 | isl_int_init(gcd)isl_sioimath_init((gcd)); |
5519 | |
5520 | o_div = isl_basic_map_offset(hull, isl_dim_div); |
5521 | o_out = isl_basic_map_offset(hull, 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])(isl_sioimath_cmp_si(*(eq[o_out + i]), 1) == 0) && |
5529 | !isl_int_is_negone(eq[o_out + i])(isl_sioimath_cmp_si(*(eq[o_out + i]), -1) == 0)) |
5530 | continue; |
5531 | if (isl_seq_first_non_zero(eq + o_out, i) != -1) |
5532 | continue; |
5533 | if (isl_seq_first_non_zero(eq + o_out + i + 1, |
5534 | n_out - (i + 1)) != -1) |
5535 | continue; |
5536 | isl_seq_gcd(eq + o_div, n_div, &gcd); |
5537 | if (isl_int_is_zero(gcd)(isl_sioimath_sgn(*(gcd)) == 0)) |
5538 | continue; |
5539 | if (isl_int_is_one(gcd)(isl_sioimath_cmp_si(*(gcd), 1) == 0)) |
5540 | continue; |
5541 | |
5542 | res = pw_multi_aff_from_map_stride(map, hull, |
5543 | i, j, gcd); |
5544 | isl_int_clear(gcd)isl_sioimath_clear((gcd)); |
5545 | return res; |
5546 | } |
5547 | } |
5548 | |
5549 | isl_int_clear(gcd)isl_sioimath_clear((gcd)); |
5550 | isl_basic_map_free(hull); |
5551 | return pw_multi_aff_from_map_check_div(map); |
5552 | error: |
5553 | isl_map_free(map); |
5554 | isl_basic_map_free(hull); |
5555 | return NULL((void*)0); |
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(isl_map_copy(map)); |
5580 | hull = isl_basic_map_plain_affine_hull(hull); |
5581 | sv = isl_basic_map_plain_is_single_valued(hull); |
5582 | if (sv >= 0 && sv) |
5583 | return plain_pw_multi_aff_from_map(isl_map_domain(map), |
5584 | hull); |
5585 | isl_basic_map_free(hull); |
5586 | } |
5587 | map = isl_map_detect_equalities(map); |
5588 | hull = isl_map_unshifted_simple_hull(isl_map_copy(map)); |
5589 | sv = isl_basic_map_plain_is_single_valued(hull); |
5590 | if (sv >= 0 && sv) |
5591 | return plain_pw_multi_aff_from_map(isl_map_domain(map), hull); |
5592 | if (sv >= 0) |
5593 | return pw_multi_aff_from_map_check_strides(map, hull); |
5594 | isl_basic_map_free(hull); |
5595 | error: |
5596 | isl_map_free(map); |
5597 | return NULL((void*)0); |
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_setisl_map *set) |
5609 | { |
5610 | return isl_pw_multi_aff_from_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_setisl_map *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 | */ |
5624 | static 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(*upma, 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(aff); |
5645 | pma = isl_pw_multi_aff_from_multi_aff(ma); |
5646 | return isl_union_pw_multi_aff_from_pw_multi_aff(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, &pw_multi_aff_from_map, &upma) < 0) |
5663 | upma = isl_union_pw_multi_aff_free(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_setisl_union_map *uset) |
5686 | { |
5687 | return isl_union_pw_multi_aff_from_union_map(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_setisl_map *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(isl_local_space_copy(ls)); |
5698 | isl_aff *one = isl_aff_zero_on_domain(ls); |
5699 | |
5700 | one = isl_aff_add_constant_si(one, 1); |
5701 | pa = isl_pw_aff_alloc(isl_set_copy(set), one); |
5702 | set = isl_set_complement(set); |
5703 | pa = isl_pw_aff_add_disjoint(pa, isl_pw_aff_alloc(set, 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(aff->ls->dim, subs->ls->dim)) |
5738 | isl_die(ctx, isl_error_invalid,do { isl_handle_error(ctx, isl_error_invalid, "spaces don't match" , "polly/lib/External/isl/isl_aff.c", 5739); return isl_aff_free (aff); } while (0) |
5739 | "spaces don't match", return isl_aff_free(aff))do { isl_handle_error(ctx, isl_error_invalid, "spaces don't match" , "polly/lib/External/isl/isl_aff.c", 5739); return isl_aff_free (aff); } while (0); |
5740 | n_div = isl_aff_domain_dim(subs, 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,do { isl_handle_error(ctx, isl_error_unsupported, "cannot handle divs yet" , "polly/lib/External/isl/isl_aff.c", 5745); return isl_aff_free (aff); } while (0) |
5745 | "cannot handle divs yet", return isl_aff_free(aff))do { isl_handle_error(ctx, isl_error_unsupported, "cannot handle divs yet" , "polly/lib/External/isl/isl_aff.c", 5745); return isl_aff_free (aff); } while (0); |
5746 | |
5747 | aff->ls = isl_local_space_substitute(aff->ls, type, pos, subs); |
5748 | if (!aff->ls) |
5749 | return isl_aff_free(aff); |
5750 | |
5751 | aff->v = isl_vec_cow(aff->v); |
5752 | if (!aff->v) |
5753 | return isl_aff_free(aff); |
5754 | |
5755 | pos += isl_local_space_offset(aff->ls, type); |
5756 | |
5757 | isl_int_init(v)isl_sioimath_init((v)); |
5758 | isl_seq_substitute(aff->v->el, pos, subs->v->el, |
5759 | aff->v->size, subs->v->size, v); |
5760 | isl_int_clear(v)isl_sioimath_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(maff); |
5776 | if (n < 0 || !subs) |
5777 | return isl_multi_aff_free(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(maff, i); |
5786 | aff = isl_aff_substitute(aff, type, pos, subs); |
5787 | maff = isl_multi_aff_restore_at(maff, i, 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(pma); |
5820 | |
5821 | n = pma->n * subs->n; |
5822 | res = isl_pw_multi_aff_alloc_size(isl_space_copy(pma->dim), n); |
5823 | |
5824 | for (i = 0; i < pma->n; ++i) { |
5825 | for (j = 0; j < subs->n; ++j) { |
5826 | isl_setisl_map *common; |
5827 | isl_multi_aff *res_ij; |
5828 | int empty; |
5829 | |
5830 | common = isl_set_intersect( |
5831 | isl_set_copy(pma->p[i].set), |
5832 | isl_set_copy(subs->p[j].set)); |
5833 | common = isl_set_substitute(common, |
5834 | pos, subs->p[j].aff); |
5835 | empty = isl_set_plain_is_empty(common); |
5836 | if (empty < 0 || empty) { |
5837 | isl_set_free(common); |
5838 | if (empty < 0) |
5839 | goto error; |
5840 | continue; |
5841 | } |
5842 | |
5843 | res_ij = isl_multi_aff_substitute( |
5844 | isl_multi_aff_copy(pma->p[i].maff), |
5845 | isl_dim_in, pos, subs->p[j].aff); |
5846 | |
5847 | res = isl_pw_multi_aff_add_piece(res, common, res_ij); |
5848 | } |
5849 | } |
5850 | |
5851 | isl_pw_multi_aff_free(pma); |
5852 | return res; |
5853 | error: |
5854 | isl_pw_multi_aff_free(pma); |
5855 | isl_pw_multi_aff_free(res); |
5856 | return NULL((void*)0); |
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 | */ |
5895 | isl_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(ma, isl_dim_param); |
5905 | n_in = isl_multi_aff_dim(ma, isl_dim_in); |
5906 | n_out = isl_multi_aff_dim(ma, 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, has_denom + 1 + n_param + n_before); |
5911 | o_dst = o_src = has_denom + 1 + n_param + n_before; |
5912 | isl_seq_clr(dst + o_dst, n_in); |
5913 | o_dst += n_in; |
5914 | o_src += n_out; |
5915 | isl_seq_cpy(dst + o_dst, src + o_src, n_after); |
5916 | o_dst += n_after; |
5917 | o_src += n_after; |
5918 | isl_seq_clr(dst + o_dst, n_div_ma); |
5919 | o_dst += n_div_ma; |
5920 | isl_seq_cpy(dst + o_dst, src + o_src, n_div_bmap); |
5921 | |
5922 | isl_int_set_si(f, 1)isl_sioimath_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])(isl_sioimath_sgn(*(src[offset])) == 0)) |
5928 | continue; |
5929 | isl_int_set(c1, ma->u.p[i]->v->el[0])isl_sioimath_set((c1), *(ma->u.p[i]->v->el[0])); |
5930 | isl_int_mul(c2, f, src[offset])isl_sioimath_mul((c2), *(f), *(src[offset])); |
5931 | isl_int_gcd(g, c1, c2)isl_sioimath_gcd((g), *(c1), *(c2)); |
5932 | isl_int_divexact(c1, c1, g)isl_sioimath_tdiv_q((c1), *(c1), *(g)); |
5933 | isl_int_divexact(c2, c2, g)isl_sioimath_tdiv_q((c2), *(c2), *(g)); |
5934 | |
5935 | isl_int_mul(f, f, c1)isl_sioimath_mul((f), *(f), *(c1)); |
5936 | o_dst = has_denom; |
5937 | o_src = 1; |
5938 | isl_seq_combine(dst + o_dst, c1, dst + o_dst, |
5939 | c2, ma->u.p[i]->v->el + o_src, 1 + n_param); |
5940 | o_dst += 1 + n_param; |
5941 | o_src += 1 + n_param; |
5942 | isl_seq_scale(dst + o_dst, dst + o_dst, c1, n_before); |
5943 | o_dst += n_before; |
5944 | isl_seq_combine(dst + o_dst, c1, dst + o_dst, |
5945 | c2, ma->u.p[i]->v->el + o_src, n_in); |
5946 | o_dst += n_in; |
5947 | o_src += n_in; |
5948 | isl_seq_scale(dst + o_dst, dst + o_dst, c1, n_after); |
5949 | o_dst += n_after; |
5950 | isl_seq_combine(dst + o_dst, c1, dst + o_dst, |
5951 | c2, ma->u.p[i]->v->el + o_src, n_div_ma); |
5952 | o_dst += n_div_ma; |
5953 | o_src += n_div_ma; |
Value stored to 'o_src' is never read | |
5954 | isl_seq_scale(dst + o_dst, dst + o_dst, c1, n_div_bmap); |
5955 | if (has_denom) |
5956 | isl_int_mul(dst[0], dst[0], c1)isl_sioimath_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((void*)0); |
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(ma); |
5990 | if (!aff || !ma) |
5991 | goto error; |
5992 | |
5993 | n_div_aff = isl_aff_dim(aff, isl_dim_div); |
5994 | n_div_ma = ma->n ? isl_aff_dim(ma->u.p[0], 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, isl_multi_aff_copy(ma)); |
6000 | res = isl_aff_alloc(ls); |
6001 | if (!res) |
6002 | goto error; |
6003 | |
6004 | isl_int_init(f)isl_sioimath_init((f)); |
6005 | isl_int_init(c1)isl_sioimath_init((c1)); |
6006 | isl_int_init(c2)isl_sioimath_init((c2)); |
6007 | isl_int_init(g)isl_sioimath_init((g)); |
6008 | |
6009 | if (isl_seq_preimage(res->v->el, aff->v->el, ma, 0, 0, |
6010 | n_div_ma, n_div_aff, f, c1, c2, g, 1) < 0) |
6011 | res = isl_aff_free(res); |
6012 | |
6013 | isl_int_clear(f)isl_sioimath_clear((f)); |
6014 | isl_int_clear(c1)isl_sioimath_clear((c1)); |
6015 | isl_int_clear(c2)isl_sioimath_clear((c2)); |
6016 | isl_int_clear(g)isl_sioimath_clear((g)); |
6017 | |
6018 | isl_aff_free(aff); |
6019 | isl_multi_aff_free(ma); |
6020 | res = isl_aff_normalize(res); |
6021 | return res; |
6022 | error: |
6023 | isl_aff_free(aff); |
6024 | isl_multi_aff_free(ma); |
6025 | isl_aff_free(res); |
6026 | return NULL((void*)0); |
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(aff2); |
6042 | return isl_aff_pullback_multi_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((void*)0); |
6054 | |
6055 | isl_multi_aff_align_params_bin(&ma1, &ma2); |
6056 | ma2 = isl_multi_aff_align_divs(ma2); |
6057 | n = isl_multi_aff_size(ma1); |
6058 | if (n < 0 || !ma2) |
6059 | goto error; |
6060 | |
6061 | space = isl_space_join(isl_multi_aff_get_space(ma2), |
6062 | isl_multi_aff_get_space(ma1)); |
6063 | |
6064 | for (i = 0; i < n; ++i) { |
6065 | isl_aff *aff; |
6066 | |
6067 | aff = isl_multi_aff_take_at(ma1, i); |
6068 | aff = isl_aff_pullback_multi_aff(aff, isl_multi_aff_copy(ma2)); |
6069 | ma1 = isl_multi_aff_restore_at(ma1, i, aff); |
6070 | } |
6071 | |
6072 | ma1 = isl_multi_aff_reset_space(ma1, space); |
6073 | isl_multi_aff_free(ma2); |
6074 | return ma1; |
6075 | error: |
6076 | isl_space_free(space); |
6077 | isl_multi_aff_free(ma2); |
6078 | isl_multi_aff_free(ma1); |
6079 | return NULL((void*)0); |
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((void*)0); |
6094 | int *exp2 = NULL((void*)0); |
6095 | isl_bool equal; |
6096 | isl_mat *div; |
6097 | |
6098 | if (!src || !dst) |
6099 | return isl_aff_free(dst); |
6100 | |
6101 | ctx = isl_aff_get_ctx(src); |
6102 | equal = isl_local_space_has_equal_space(src->ls, dst->ls); |
6103 | if (equal < 0) |
6104 | return isl_aff_free(dst); |
6105 | if (!equal) |
6106 | isl_die(ctx, isl_error_invalid,do { isl_handle_error(ctx, isl_error_invalid, "spaces don't match" , "polly/lib/External/isl/isl_aff.c", 6107); goto error; } while (0) |
6107 | "spaces don't match", goto error)do { isl_handle_error(ctx, isl_error_invalid, "spaces don't match" , "polly/lib/External/isl/isl_aff.c", 6107); goto error; } while (0); |
6108 | |
6109 | src_n_div = isl_aff_domain_dim(src, isl_dim_div); |
6110 | dst_n_div = isl_aff_domain_dim(dst, isl_dim_div); |
6111 | if (src_n_div == 0) |
6112 | return dst; |
6113 | equal = isl_local_space_is_equal(src->ls, dst->ls); |
6114 | if (equal < 0 || src_n_div < 0 || dst_n_div < 0) |
6115 | return isl_aff_free(dst); |
6116 | if (equal) |
6117 | return dst; |
6118 | |
6119 | exp1 = isl_alloc_array(ctx, int, src_n_div)((int *)isl_malloc_or_die(ctx, (src_n_div)*sizeof(int))); |
6120 | exp2 = isl_alloc_array(ctx, int, dst_n_div)((int *)isl_malloc_or_die(ctx, (dst_n_div)*sizeof(int))); |
6121 | if (!exp1 || (dst_n_div && !exp2)) |
6122 | goto error; |
6123 | |
6124 | div = isl_merge_divs(src->ls->div, dst->ls->div, exp1, exp2); |
6125 | dst = isl_aff_expand_divs(dst, div, exp2); |
6126 | free(exp1); |
6127 | free(exp2); |
6128 | |
6129 | return dst; |
6130 | error: |
6131 | free(exp1); |
6132 | free(exp2); |
6133 | return isl_aff_free(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(maff); |
6147 | if (n < 0) |
6148 | return isl_multi_aff_free(maff); |
6149 | if (n <= 1) |
6150 | return maff; |
6151 | |
6152 | aff_0 = isl_multi_aff_take_at(maff, 0); |
6153 | for (i = 1; i < n; ++i) { |
6154 | isl_aff *aff_i; |
6155 | |
6156 | aff_i = isl_multi_aff_peek_at(maff, i); |
6157 | aff_0 = isl_aff_align_divs(aff_0, aff_i); |
6158 | } |
6159 | maff = isl_multi_aff_restore_at(maff, 0, aff_0); |
6160 | |
6161 | aff_0 = isl_multi_aff_peek_at(maff, 0); |
6162 | for (i = 1; i < n; ++i) { |
6163 | isl_aff *aff_i; |
6164 | |
6165 | aff_i = isl_multi_aff_take_at(maff, i); |
6166 | aff_i = isl_aff_align_divs(aff_i, aff_0); |
6167 | maff = isl_multi_aff_restore_at(maff, i, 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((void*)0); |
6178 | |
6179 | aff->ls = isl_local_space_lift(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((void*)0); |
6201 | |
6202 | n = isl_multi_aff_size(maff); |
6203 | if (n < 0) |
6204 | return isl_multi_aff_free(maff); |
6205 | |
6206 | if (n == 0) { |
6207 | if (ls) { |
6208 | isl_space *space = isl_multi_aff_get_domain_space(maff); |
6209 | *ls = isl_local_space_from_space(space); |
6210 | if (!*ls) |
6211 | return isl_multi_aff_free(maff); |
6212 | } |
6213 | return maff; |
6214 | } |
6215 | |
6216 | maff = isl_multi_aff_align_divs(maff); |
6217 | |
6218 | aff = isl_multi_aff_peek_at(maff, 0); |
6219 | n_div = isl_aff_dim(aff, isl_dim_div); |
6220 | if (n_div < 0) |
6221 | return isl_multi_aff_free(maff); |
6222 | space = isl_multi_aff_get_space(maff); |
6223 | space = isl_space_lift(isl_space_domain(space), n_div); |
6224 | space = isl_space_extend_domain_with_range(space, |
6225 | isl_multi_aff_get_space(maff)); |
6226 | maff = isl_multi_aff_restore_space(maff, space); |
6227 | |
6228 | if (ls) { |
6229 | aff = isl_multi_aff_peek_at(maff, 0); |
6230 | *ls = isl_aff_get_domain_local_space(aff); |
6231 | if (!*ls) |
6232 | return isl_multi_aff_free(maff); |
6233 | } |
6234 | |
6235 | for (i = 0; i < n; ++i) { |
6236 | aff = isl_multi_aff_take_at(maff, i); |
6237 | aff = isl_aff_lift(aff); |
6238 | maff = isl_multi_aff_restore_at(maff, i, aff); |
6239 | } |
6240 | |
6241 | return maff; |
6242 | } |
6243 | |
6244 | #undef TYPEisl_multi_union_pw_aff |
6245 | #define TYPEisl_multi_union_pw_aff isl_pw_multi_aff |
6246 | static |
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(pma, isl_dim_out, pos, 1) < 0) |
6260 | return NULL((void*)0); |
6261 | |
6262 | n_out = isl_pw_multi_aff_dim(pma, isl_dim_out); |
6263 | if (n_out < 0) |
6264 | return NULL((void*)0); |
6265 | |
6266 | space = isl_pw_multi_aff_get_space(pma); |
6267 | space = isl_space_drop_dims(space, isl_dim_out, |
6268 | pos + 1, n_out - pos - 1); |
6269 | space = isl_space_drop_dims(space, isl_dim_out, 0, pos); |
6270 | |
6271 | pa = isl_pw_aff_alloc_size(space, pma->n); |
6272 | for (i = 0; i < pma->n; ++i) { |
6273 | isl_aff *aff; |
6274 | aff = isl_multi_aff_get_aff(pma->p[i].maff, pos); |
6275 | pa = isl_pw_aff_add_piece(pa, isl_set_copy(pma->p[i].set), 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_setisl_map *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, 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 | */ |
6307 | static isl_stat add_pw_multi_aff_from_domain(__isl_take isl_setisl_map *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(*upma, 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_setisl_union_map *uset) |
6324 | { |
6325 | isl_space *space; |
6326 | isl_union_pw_multi_aff *upma; |
6327 | |
6328 | if (!uset) |
6329 | return NULL((void*)0); |
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 | &add_pw_multi_aff_from_domain, &upma) < 0) |
6336 | goto error; |
6337 | |
6338 | isl_union_set_free(uset); |
6339 | return upma; |
6340 | error: |
6341 | isl_union_set_free(uset); |
6342 | isl_union_pw_multi_aff_free(upma); |
6343 | return NULL((void*)0); |
6344 | } |
6345 | |
6346 | /* Local data for bin_entry and the callback "fn". |
6347 | */ |
6348 | struct 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 | */ |
6358 | static 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(data->upma2, |
6365 | data->fn, data); |
6366 | isl_pw_multi_aff_free(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 | */ |
6376 | static __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((void*)0), NULL((void*)0), NULL((void*)0), fn }; |
6383 | |
6384 | space = isl_union_pw_multi_aff_get_space(upma2); |
6385 | upma1 = isl_union_pw_multi_aff_align_params(upma1, space); |
6386 | space = isl_union_pw_multi_aff_get_space(upma1); |
6387 | upma2 = isl_union_pw_multi_aff_align_params(upma2, 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(upma1); |
6394 | if (isl_union_pw_multi_aff_foreach_pw_multi_aff(upma1, |
6395 | &bin_entry, &data) < 0) |
6396 | goto error; |
6397 | |
6398 | isl_union_pw_multi_aff_free(upma1); |
6399 | isl_union_pw_multi_aff_free(upma2); |
6400 | return data.res; |
6401 | error: |
6402 | isl_union_pw_multi_aff_free(upma1); |
6403 | isl_union_pw_multi_aff_free(upma2); |
6404 | isl_union_pw_multi_aff_free(data.res); |
6405 | return NULL((void*)0); |
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(&pma1, &pma2); |
6417 | space = isl_space_range_product(isl_pw_multi_aff_get_space(pma1), |
6418 | isl_pw_multi_aff_get_space(pma2)); |
6419 | return isl_pw_multi_aff_on_shared_domain_in(pma1, pma2, space, |
6420 | &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( |