File: | tools/polly/lib/External/isl/isl_val.c |
Warning: | line 1699, column 2 Use of memory after it is freed |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* | |||
2 | * Copyright 2013 Ecole Normale Superieure | |||
3 | * | |||
4 | * Use of this software is governed by the MIT license | |||
5 | * | |||
6 | * Written by Sven Verdoolaege, | |||
7 | * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France | |||
8 | */ | |||
9 | ||||
10 | #include <isl_int.h> | |||
11 | #include <isl_ctx_private.h> | |||
12 | #include <isl_val_private.h> | |||
13 | ||||
14 | #undef BASEval | |||
15 | #define BASEval val | |||
16 | ||||
17 | #include <isl_list_templ.c> | |||
18 | ||||
19 | /* Allocate an isl_val object with indeterminate value. | |||
20 | */ | |||
21 | __isl_give isl_val *isl_val_alloc(isl_ctx *ctx) | |||
22 | { | |||
23 | isl_val *v; | |||
24 | ||||
25 | v = isl_alloc_type(ctx, struct isl_val)((struct isl_val *)isl_malloc_or_die(ctx, sizeof(struct isl_val ))); | |||
26 | if (!v) | |||
27 | return NULL((void*)0); | |||
28 | ||||
29 | v->ctx = ctx; | |||
30 | isl_ctx_ref(ctx); | |||
31 | v->ref = 1; | |||
32 | isl_int_init(v->n)isl_sioimath_init((v->n)); | |||
33 | isl_int_init(v->d)isl_sioimath_init((v->d)); | |||
34 | ||||
35 | return v; | |||
36 | } | |||
37 | ||||
38 | /* Return a reference to an isl_val representing zero. | |||
39 | */ | |||
40 | __isl_give isl_val *isl_val_zero(isl_ctx *ctx) | |||
41 | { | |||
42 | return isl_val_int_from_si(ctx, 0); | |||
43 | } | |||
44 | ||||
45 | /* Return a reference to an isl_val representing one. | |||
46 | */ | |||
47 | __isl_give isl_val *isl_val_one(isl_ctx *ctx) | |||
48 | { | |||
49 | return isl_val_int_from_si(ctx, 1); | |||
50 | } | |||
51 | ||||
52 | /* Return a reference to an isl_val representing negative one. | |||
53 | */ | |||
54 | __isl_give isl_val *isl_val_negone(isl_ctx *ctx) | |||
55 | { | |||
56 | return isl_val_int_from_si(ctx, -1); | |||
57 | } | |||
58 | ||||
59 | /* Return a reference to an isl_val representing NaN. | |||
60 | */ | |||
61 | __isl_give isl_val *isl_val_nan(isl_ctx *ctx) | |||
62 | { | |||
63 | isl_val *v; | |||
64 | ||||
65 | v = isl_val_alloc(ctx); | |||
66 | if (!v) | |||
67 | return NULL((void*)0); | |||
68 | ||||
69 | isl_int_set_si(v->n, 0)isl_sioimath_set_si((v->n), 0); | |||
70 | isl_int_set_si(v->d, 0)isl_sioimath_set_si((v->d), 0); | |||
71 | ||||
72 | return v; | |||
73 | } | |||
74 | ||||
75 | /* Change "v" into a NaN. | |||
76 | */ | |||
77 | __isl_give isl_val *isl_val_set_nan(__isl_take isl_val *v) | |||
78 | { | |||
79 | if (!v) | |||
80 | return NULL((void*)0); | |||
81 | if (isl_val_is_nan(v)) | |||
82 | return v; | |||
83 | v = isl_val_cow(v); | |||
84 | if (!v) | |||
85 | return NULL((void*)0); | |||
86 | ||||
87 | isl_int_set_si(v->n, 0)isl_sioimath_set_si((v->n), 0); | |||
88 | isl_int_set_si(v->d, 0)isl_sioimath_set_si((v->d), 0); | |||
89 | ||||
90 | return v; | |||
91 | } | |||
92 | ||||
93 | /* Return a reference to an isl_val representing +infinity. | |||
94 | */ | |||
95 | __isl_give isl_val *isl_val_infty(isl_ctx *ctx) | |||
96 | { | |||
97 | isl_val *v; | |||
98 | ||||
99 | v = isl_val_alloc(ctx); | |||
100 | if (!v) | |||
101 | return NULL((void*)0); | |||
102 | ||||
103 | isl_int_set_si(v->n, 1)isl_sioimath_set_si((v->n), 1); | |||
104 | isl_int_set_si(v->d, 0)isl_sioimath_set_si((v->d), 0); | |||
105 | ||||
106 | return v; | |||
107 | } | |||
108 | ||||
109 | /* Return a reference to an isl_val representing -infinity. | |||
110 | */ | |||
111 | __isl_give isl_val *isl_val_neginfty(isl_ctx *ctx) | |||
112 | { | |||
113 | isl_val *v; | |||
114 | ||||
115 | v = isl_val_alloc(ctx); | |||
116 | if (!v) | |||
117 | return NULL((void*)0); | |||
118 | ||||
119 | isl_int_set_si(v->n, -1)isl_sioimath_set_si((v->n), -1); | |||
120 | isl_int_set_si(v->d, 0)isl_sioimath_set_si((v->d), 0); | |||
121 | ||||
122 | return v; | |||
123 | } | |||
124 | ||||
125 | /* Return a reference to an isl_val representing the integer "i". | |||
126 | */ | |||
127 | __isl_give isl_val *isl_val_int_from_si(isl_ctx *ctx, long i) | |||
128 | { | |||
129 | isl_val *v; | |||
130 | ||||
131 | v = isl_val_alloc(ctx); | |||
132 | if (!v) | |||
133 | return NULL((void*)0); | |||
134 | ||||
135 | isl_int_set_si(v->n, i)isl_sioimath_set_si((v->n), i); | |||
136 | isl_int_set_si(v->d, 1)isl_sioimath_set_si((v->d), 1); | |||
137 | ||||
138 | return v; | |||
139 | } | |||
140 | ||||
141 | /* Change the value of "v" to be equal to the integer "i". | |||
142 | */ | |||
143 | __isl_give isl_val *isl_val_set_si(__isl_take isl_val *v, long i) | |||
144 | { | |||
145 | if (!v) | |||
146 | return NULL((void*)0); | |||
147 | if (isl_val_is_int(v) && isl_int_cmp_si(v->n, i)isl_sioimath_cmp_si(*(v->n), i) == 0) | |||
148 | return v; | |||
149 | v = isl_val_cow(v); | |||
150 | if (!v) | |||
151 | return NULL((void*)0); | |||
152 | ||||
153 | isl_int_set_si(v->n, i)isl_sioimath_set_si((v->n), i); | |||
154 | isl_int_set_si(v->d, 1)isl_sioimath_set_si((v->d), 1); | |||
155 | ||||
156 | return v; | |||
157 | } | |||
158 | ||||
159 | /* Change the value of "v" to be equal to zero. | |||
160 | */ | |||
161 | __isl_give isl_val *isl_val_set_zero(__isl_take isl_val *v) | |||
162 | { | |||
163 | return isl_val_set_si(v, 0); | |||
164 | } | |||
165 | ||||
166 | /* Return a reference to an isl_val representing the unsigned integer "u". | |||
167 | */ | |||
168 | __isl_give isl_val *isl_val_int_from_ui(isl_ctx *ctx, unsigned long u) | |||
169 | { | |||
170 | isl_val *v; | |||
171 | ||||
172 | v = isl_val_alloc(ctx); | |||
173 | if (!v) | |||
174 | return NULL((void*)0); | |||
175 | ||||
176 | isl_int_set_ui(v->n, u)isl_sioimath_set_ui((v->n), u); | |||
177 | isl_int_set_si(v->d, 1)isl_sioimath_set_si((v->d), 1); | |||
178 | ||||
179 | return v; | |||
180 | } | |||
181 | ||||
182 | /* Return a reference to an isl_val representing the integer "n". | |||
183 | */ | |||
184 | __isl_give isl_val *isl_val_int_from_isl_int(isl_ctx *ctx, isl_int n) | |||
185 | { | |||
186 | isl_val *v; | |||
187 | ||||
188 | v = isl_val_alloc(ctx); | |||
189 | if (!v) | |||
190 | return NULL((void*)0); | |||
191 | ||||
192 | isl_int_set(v->n, n)isl_sioimath_set((v->n), *(n)); | |||
193 | isl_int_set_si(v->d, 1)isl_sioimath_set_si((v->d), 1); | |||
194 | ||||
195 | return v; | |||
196 | } | |||
197 | ||||
198 | /* Return a reference to an isl_val representing the rational value "n"/"d". | |||
199 | * Normalizing the isl_val (if needed) is left to the caller. | |||
200 | */ | |||
201 | __isl_give isl_val *isl_val_rat_from_isl_int(isl_ctx *ctx, | |||
202 | isl_int n, isl_int d) | |||
203 | { | |||
204 | isl_val *v; | |||
205 | ||||
206 | v = isl_val_alloc(ctx); | |||
207 | if (!v) | |||
208 | return NULL((void*)0); | |||
209 | ||||
210 | isl_int_set(v->n, n)isl_sioimath_set((v->n), *(n)); | |||
211 | isl_int_set(v->d, d)isl_sioimath_set((v->d), *(d)); | |||
212 | ||||
213 | return v; | |||
214 | } | |||
215 | ||||
216 | /* Return a new reference to "v". | |||
217 | */ | |||
218 | __isl_give isl_val *isl_val_copy(__isl_keep isl_val *v) | |||
219 | { | |||
220 | if (!v) | |||
221 | return NULL((void*)0); | |||
222 | ||||
223 | v->ref++; | |||
224 | return v; | |||
225 | } | |||
226 | ||||
227 | /* Return a fresh copy of "val". | |||
228 | */ | |||
229 | __isl_give isl_val *isl_val_dup(__isl_keep isl_val *val) | |||
230 | { | |||
231 | isl_val *dup; | |||
232 | ||||
233 | if (!val) | |||
234 | return NULL((void*)0); | |||
235 | ||||
236 | dup = isl_val_alloc(isl_val_get_ctx(val)); | |||
237 | if (!dup) | |||
238 | return NULL((void*)0); | |||
239 | ||||
240 | isl_int_set(dup->n, val->n)isl_sioimath_set((dup->n), *(val->n)); | |||
241 | isl_int_set(dup->d, val->d)isl_sioimath_set((dup->d), *(val->d)); | |||
242 | ||||
243 | return dup; | |||
244 | } | |||
245 | ||||
246 | /* Return an isl_val that is equal to "val" and that has only | |||
247 | * a single reference. | |||
248 | */ | |||
249 | __isl_give isl_val *isl_val_cow(__isl_take isl_val *val) | |||
250 | { | |||
251 | if (!val) | |||
252 | return NULL((void*)0); | |||
253 | ||||
254 | if (val->ref == 1) | |||
255 | return val; | |||
256 | val->ref--; | |||
257 | return isl_val_dup(val); | |||
258 | } | |||
259 | ||||
260 | /* Free "v" and return NULL. | |||
261 | */ | |||
262 | __isl_null isl_val *isl_val_free(__isl_take isl_val *v) | |||
263 | { | |||
264 | if (!v) | |||
265 | return NULL((void*)0); | |||
266 | ||||
267 | if (--v->ref > 0) | |||
268 | return NULL((void*)0); | |||
269 | ||||
270 | isl_ctx_deref(v->ctx); | |||
271 | isl_int_clear(v->n)isl_sioimath_clear((v->n)); | |||
272 | isl_int_clear(v->d)isl_sioimath_clear((v->d)); | |||
273 | free(v); | |||
274 | return NULL((void*)0); | |||
275 | } | |||
276 | ||||
277 | /* Extract the numerator of a rational value "v" as an integer. | |||
278 | * | |||
279 | * If "v" is not a rational value, then the result is undefined. | |||
280 | */ | |||
281 | long isl_val_get_num_si(__isl_keep isl_val *v) | |||
282 | { | |||
283 | if (!v) | |||
284 | return 0; | |||
285 | if (!isl_val_is_rat(v)) | |||
286 | isl_die(isl_val_get_ctx(v), isl_error_invalid,do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "expecting rational value" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/polly/lib/External/isl/isl_val.c" , 287); return 0; } while (0) | |||
287 | "expecting rational value", return 0)do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "expecting rational value" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/polly/lib/External/isl/isl_val.c" , 287); return 0; } while (0); | |||
288 | if (!isl_int_fits_slong(v->n)isl_sioimath_fits_slong(*(v->n))) | |||
289 | isl_die(isl_val_get_ctx(v), isl_error_invalid,do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "numerator too large" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/polly/lib/External/isl/isl_val.c" , 290); return 0; } while (0) | |||
290 | "numerator too large", return 0)do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "numerator too large" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/polly/lib/External/isl/isl_val.c" , 290); return 0; } while (0); | |||
291 | return isl_int_get_si(v->n)isl_sioimath_get_si(*(v->n)); | |||
292 | } | |||
293 | ||||
294 | /* Extract the numerator of a rational value "v" as an isl_int. | |||
295 | * | |||
296 | * If "v" is not a rational value, then the result is undefined. | |||
297 | */ | |||
298 | isl_stat isl_val_get_num_isl_int(__isl_keep isl_val *v, isl_int *n) | |||
299 | { | |||
300 | if (!v) | |||
301 | return isl_stat_error; | |||
302 | if (!isl_val_is_rat(v)) | |||
303 | isl_die(isl_val_get_ctx(v), isl_error_invalid,do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "expecting rational value" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/polly/lib/External/isl/isl_val.c" , 304); return isl_stat_error; } while (0) | |||
304 | "expecting rational value", return isl_stat_error)do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "expecting rational value" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/polly/lib/External/isl/isl_val.c" , 304); return isl_stat_error; } while (0); | |||
305 | isl_int_set(*n, v->n)isl_sioimath_set((*n), *(v->n)); | |||
306 | return isl_stat_ok; | |||
307 | } | |||
308 | ||||
309 | /* Extract the denominator of a rational value "v" as an integer. | |||
310 | * | |||
311 | * If "v" is not a rational value, then the result is undefined. | |||
312 | */ | |||
313 | long isl_val_get_den_si(__isl_keep isl_val *v) | |||
314 | { | |||
315 | if (!v) | |||
316 | return 0; | |||
317 | if (!isl_val_is_rat(v)) | |||
318 | isl_die(isl_val_get_ctx(v), isl_error_invalid,do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "expecting rational value" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/polly/lib/External/isl/isl_val.c" , 319); return 0; } while (0) | |||
319 | "expecting rational value", return 0)do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "expecting rational value" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/polly/lib/External/isl/isl_val.c" , 319); return 0; } while (0); | |||
320 | if (!isl_int_fits_slong(v->d)isl_sioimath_fits_slong(*(v->d))) | |||
321 | isl_die(isl_val_get_ctx(v), isl_error_invalid,do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "denominator too large" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/polly/lib/External/isl/isl_val.c" , 322); return 0; } while (0) | |||
322 | "denominator too large", return 0)do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "denominator too large" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/polly/lib/External/isl/isl_val.c" , 322); return 0; } while (0); | |||
323 | return isl_int_get_si(v->d)isl_sioimath_get_si(*(v->d)); | |||
324 | } | |||
325 | ||||
326 | /* Extract the denominator of a rational value "v" as an isl_val. | |||
327 | * | |||
328 | * If "v" is not a rational value, then the result is undefined. | |||
329 | */ | |||
330 | __isl_give isl_val *isl_val_get_den_val(__isl_keep isl_val *v) | |||
331 | { | |||
332 | if (!v) | |||
333 | return NULL((void*)0); | |||
334 | if (!isl_val_is_rat(v)) | |||
335 | isl_die(isl_val_get_ctx(v), isl_error_invalid,do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "expecting rational value" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/polly/lib/External/isl/isl_val.c" , 336); return ((void*)0); } while (0) | |||
336 | "expecting rational value", return NULL)do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "expecting rational value" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/polly/lib/External/isl/isl_val.c" , 336); return ((void*)0); } while (0); | |||
337 | return isl_val_int_from_isl_int(isl_val_get_ctx(v), v->d); | |||
338 | } | |||
339 | ||||
340 | /* Return an approximation of "v" as a double. | |||
341 | */ | |||
342 | double isl_val_get_d(__isl_keep isl_val *v) | |||
343 | { | |||
344 | if (!v) | |||
345 | return 0; | |||
346 | if (!isl_val_is_rat(v)) | |||
347 | isl_die(isl_val_get_ctx(v), isl_error_invalid,do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "expecting rational value" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/polly/lib/External/isl/isl_val.c" , 348); return 0; } while (0) | |||
348 | "expecting rational value", return 0)do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "expecting rational value" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/polly/lib/External/isl/isl_val.c" , 348); return 0; } while (0); | |||
349 | return isl_int_get_d(v->n)isl_sioimath_get_d(*(v->n)) / isl_int_get_d(v->d)isl_sioimath_get_d(*(v->d)); | |||
350 | } | |||
351 | ||||
352 | /* Return the isl_ctx to which "val" belongs. | |||
353 | */ | |||
354 | isl_ctx *isl_val_get_ctx(__isl_keep isl_val *val) | |||
355 | { | |||
356 | return val ? val->ctx : NULL((void*)0); | |||
357 | } | |||
358 | ||||
359 | /* Return a hash value that digests "val". | |||
360 | */ | |||
361 | uint32_t isl_val_get_hash(__isl_keep isl_val *val) | |||
362 | { | |||
363 | uint32_t hash; | |||
364 | ||||
365 | if (!val) | |||
366 | return 0; | |||
367 | ||||
368 | hash = isl_hash_init()(2166136261u); | |||
369 | hash = isl_int_hash(val->n, hash)isl_sioimath_hash(*(val->n), hash); | |||
370 | hash = isl_int_hash(val->d, hash)isl_sioimath_hash(*(val->d), hash); | |||
371 | ||||
372 | return hash; | |||
373 | } | |||
374 | ||||
375 | /* Normalize "v". | |||
376 | * | |||
377 | * In particular, make sure that the denominator of a rational value | |||
378 | * is positive and the numerator and denominator do not have any | |||
379 | * common divisors. | |||
380 | * | |||
381 | * This function should not be called by an external user | |||
382 | * since it will only be given normalized values. | |||
383 | */ | |||
384 | __isl_give isl_val *isl_val_normalize(__isl_take isl_val *v) | |||
385 | { | |||
386 | isl_ctx *ctx; | |||
387 | ||||
388 | if (!v) | |||
389 | return NULL((void*)0); | |||
390 | if (isl_val_is_int(v)) | |||
391 | return v; | |||
392 | if (!isl_val_is_rat(v)) | |||
393 | return v; | |||
394 | if (isl_int_is_neg(v->d)(isl_sioimath_sgn(*(v->d)) < 0)) { | |||
395 | isl_int_neg(v->d, v->d)isl_sioimath_neg((v->d), *(v->d)); | |||
396 | isl_int_neg(v->n, v->n)isl_sioimath_neg((v->n), *(v->n)); | |||
397 | } | |||
398 | ctx = isl_val_get_ctx(v); | |||
399 | isl_int_gcd(ctx->normalize_gcd, v->n, v->d)isl_sioimath_gcd((ctx->normalize_gcd), *(v->n), *(v-> d)); | |||
400 | if (isl_int_is_one(ctx->normalize_gcd)(isl_sioimath_cmp_si(*(ctx->normalize_gcd), 1) == 0)) | |||
401 | return v; | |||
402 | isl_int_divexact(v->n, v->n, ctx->normalize_gcd)isl_sioimath_tdiv_q((v->n), *(v->n), *(ctx->normalize_gcd )); | |||
403 | isl_int_divexact(v->d, v->d, ctx->normalize_gcd)isl_sioimath_tdiv_q((v->d), *(v->d), *(ctx->normalize_gcd )); | |||
404 | return v; | |||
405 | } | |||
406 | ||||
407 | /* Return the opposite of "v". | |||
408 | */ | |||
409 | __isl_give isl_val *isl_val_neg(__isl_take isl_val *v) | |||
410 | { | |||
411 | if (!v) | |||
412 | return NULL((void*)0); | |||
413 | if (isl_val_is_nan(v)) | |||
414 | return v; | |||
415 | if (isl_val_is_zero(v)) | |||
416 | return v; | |||
417 | ||||
418 | v = isl_val_cow(v); | |||
419 | if (!v) | |||
420 | return NULL((void*)0); | |||
421 | isl_int_neg(v->n, v->n)isl_sioimath_neg((v->n), *(v->n)); | |||
422 | ||||
423 | return v; | |||
424 | } | |||
425 | ||||
426 | /* Return the inverse of "v". | |||
427 | */ | |||
428 | __isl_give isl_val *isl_val_inv(__isl_take isl_val *v) | |||
429 | { | |||
430 | if (!v) | |||
431 | return NULL((void*)0); | |||
432 | if (isl_val_is_nan(v)) | |||
433 | return v; | |||
434 | if (isl_val_is_zero(v)) { | |||
435 | isl_ctx *ctx = isl_val_get_ctx(v); | |||
436 | isl_val_free(v); | |||
437 | return isl_val_nan(ctx); | |||
438 | } | |||
439 | if (isl_val_is_infty(v) || isl_val_is_neginfty(v)) { | |||
440 | isl_ctx *ctx = isl_val_get_ctx(v); | |||
441 | isl_val_free(v); | |||
442 | return isl_val_zero(ctx); | |||
443 | } | |||
444 | ||||
445 | v = isl_val_cow(v); | |||
446 | if (!v) | |||
447 | return NULL((void*)0); | |||
448 | isl_int_swap(v->n, v->d)isl_sioimath_swap((v->n), (v->d)); | |||
449 | ||||
450 | return isl_val_normalize(v); | |||
451 | } | |||
452 | ||||
453 | /* Return the absolute value of "v". | |||
454 | */ | |||
455 | __isl_give isl_val *isl_val_abs(__isl_take isl_val *v) | |||
456 | { | |||
457 | if (!v) | |||
458 | return NULL((void*)0); | |||
459 | if (isl_val_is_nan(v)) | |||
460 | return v; | |||
461 | if (isl_val_is_nonneg(v)) | |||
462 | return v; | |||
463 | return isl_val_neg(v); | |||
464 | } | |||
465 | ||||
466 | /* Return the "floor" (greatest integer part) of "v". | |||
467 | * That is, return the result of rounding towards -infinity. | |||
468 | */ | |||
469 | __isl_give isl_val *isl_val_floor(__isl_take isl_val *v) | |||
470 | { | |||
471 | if (!v) | |||
472 | return NULL((void*)0); | |||
473 | if (isl_val_is_int(v)) | |||
474 | return v; | |||
475 | if (!isl_val_is_rat(v)) | |||
476 | return v; | |||
477 | ||||
478 | v = isl_val_cow(v); | |||
479 | if (!v) | |||
480 | return NULL((void*)0); | |||
481 | isl_int_fdiv_q(v->n, v->n, v->d)isl_sioimath_fdiv_q((v->n), *(v->n), *(v->d)); | |||
482 | isl_int_set_si(v->d, 1)isl_sioimath_set_si((v->d), 1); | |||
483 | ||||
484 | return v; | |||
485 | } | |||
486 | ||||
487 | /* Return the "ceiling" of "v". | |||
488 | * That is, return the result of rounding towards +infinity. | |||
489 | */ | |||
490 | __isl_give isl_val *isl_val_ceil(__isl_take isl_val *v) | |||
491 | { | |||
492 | if (!v) | |||
493 | return NULL((void*)0); | |||
494 | if (isl_val_is_int(v)) | |||
495 | return v; | |||
496 | if (!isl_val_is_rat(v)) | |||
497 | return v; | |||
498 | ||||
499 | v = isl_val_cow(v); | |||
500 | if (!v) | |||
501 | return NULL((void*)0); | |||
502 | isl_int_cdiv_q(v->n, v->n, v->d)isl_sioimath_cdiv_q((v->n), *(v->n), *(v->d)); | |||
503 | isl_int_set_si(v->d, 1)isl_sioimath_set_si((v->d), 1); | |||
504 | ||||
505 | return v; | |||
506 | } | |||
507 | ||||
508 | /* Truncate "v". | |||
509 | * That is, return the result of rounding towards zero. | |||
510 | */ | |||
511 | __isl_give isl_val *isl_val_trunc(__isl_take isl_val *v) | |||
512 | { | |||
513 | if (!v) | |||
514 | return NULL((void*)0); | |||
515 | if (isl_val_is_int(v)) | |||
516 | return v; | |||
517 | if (!isl_val_is_rat(v)) | |||
518 | return v; | |||
519 | ||||
520 | v = isl_val_cow(v); | |||
521 | if (!v) | |||
522 | return NULL((void*)0); | |||
523 | isl_int_tdiv_q(v->n, v->n, v->d)isl_sioimath_tdiv_q((v->n), *(v->n), *(v->d)); | |||
524 | isl_int_set_si(v->d, 1)isl_sioimath_set_si((v->d), 1); | |||
525 | ||||
526 | return v; | |||
527 | } | |||
528 | ||||
529 | /* Return 2^v, where v is an integer (that is not too large). | |||
530 | */ | |||
531 | __isl_give isl_val *isl_val_pow2(__isl_take isl_val *v) | |||
532 | { | |||
533 | unsigned long exp; | |||
534 | int neg; | |||
535 | ||||
536 | v = isl_val_cow(v); | |||
537 | if (!v) | |||
538 | return NULL((void*)0); | |||
539 | if (!isl_val_is_int(v)) | |||
540 | isl_die(isl_val_get_ctx(v), isl_error_invalid,do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "can only compute integer powers" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/polly/lib/External/isl/isl_val.c" , 542); return isl_val_free(v); } while (0) | |||
541 | "can only compute integer powers",do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "can only compute integer powers" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/polly/lib/External/isl/isl_val.c" , 542); return isl_val_free(v); } while (0) | |||
542 | return isl_val_free(v))do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "can only compute integer powers" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/polly/lib/External/isl/isl_val.c" , 542); return isl_val_free(v); } while (0); | |||
543 | neg = isl_val_is_neg(v); | |||
544 | if (neg) | |||
545 | isl_int_neg(v->n, v->n)isl_sioimath_neg((v->n), *(v->n)); | |||
546 | if (!isl_int_fits_ulong(v->n)isl_sioimath_fits_ulong(*(v->n))) | |||
547 | isl_die(isl_val_get_ctx(v), isl_error_invalid,do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "exponent too large" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/polly/lib/External/isl/isl_val.c" , 548); return isl_val_free(v); } while (0) | |||
548 | "exponent too large", return isl_val_free(v))do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "exponent too large" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/polly/lib/External/isl/isl_val.c" , 548); return isl_val_free(v); } while (0); | |||
549 | exp = isl_int_get_ui(v->n)isl_sioimath_get_ui(*(v->n)); | |||
550 | if (neg) { | |||
551 | isl_int_mul_2exp(v->d, v->d, exp)isl_sioimath_mul_2exp((v->d), *(v->d), exp); | |||
552 | isl_int_set_si(v->n, 1)isl_sioimath_set_si((v->n), 1); | |||
553 | } else { | |||
554 | isl_int_mul_2exp(v->n, v->d, exp)isl_sioimath_mul_2exp((v->n), *(v->d), exp); | |||
555 | } | |||
556 | ||||
557 | return v; | |||
558 | } | |||
559 | ||||
560 | /* This is an alternative name for the function above. | |||
561 | */ | |||
562 | __isl_give isl_val *isl_val_2exp(__isl_take isl_val *v) | |||
563 | { | |||
564 | return isl_val_pow2(v); | |||
565 | } | |||
566 | ||||
567 | /* Return the minimum of "v1" and "v2". | |||
568 | */ | |||
569 | __isl_give isl_val *isl_val_min(__isl_take isl_val *v1, __isl_take isl_val *v2) | |||
570 | { | |||
571 | if (!v1 || !v2) | |||
572 | goto error; | |||
573 | ||||
574 | if (isl_val_is_nan(v1)) { | |||
575 | isl_val_free(v2); | |||
576 | return v1; | |||
577 | } | |||
578 | if (isl_val_is_nan(v2)) { | |||
579 | isl_val_free(v1); | |||
580 | return v2; | |||
581 | } | |||
582 | if (isl_val_le(v1, v2)) { | |||
583 | isl_val_free(v2); | |||
584 | return v1; | |||
585 | } else { | |||
586 | isl_val_free(v1); | |||
587 | return v2; | |||
588 | } | |||
589 | error: | |||
590 | isl_val_free(v1); | |||
591 | isl_val_free(v2); | |||
592 | return NULL((void*)0); | |||
593 | } | |||
594 | ||||
595 | /* Return the maximum of "v1" and "v2". | |||
596 | */ | |||
597 | __isl_give isl_val *isl_val_max(__isl_take isl_val *v1, __isl_take isl_val *v2) | |||
598 | { | |||
599 | if (!v1 || !v2) | |||
600 | goto error; | |||
601 | ||||
602 | if (isl_val_is_nan(v1)) { | |||
603 | isl_val_free(v2); | |||
604 | return v1; | |||
605 | } | |||
606 | if (isl_val_is_nan(v2)) { | |||
607 | isl_val_free(v1); | |||
608 | return v2; | |||
609 | } | |||
610 | if (isl_val_ge(v1, v2)) { | |||
611 | isl_val_free(v2); | |||
612 | return v1; | |||
613 | } else { | |||
614 | isl_val_free(v1); | |||
615 | return v2; | |||
616 | } | |||
617 | error: | |||
618 | isl_val_free(v1); | |||
619 | isl_val_free(v2); | |||
620 | return NULL((void*)0); | |||
621 | } | |||
622 | ||||
623 | /* Return the sum of "v1" and "v2". | |||
624 | */ | |||
625 | __isl_give isl_val *isl_val_add(__isl_take isl_val *v1, __isl_take isl_val *v2) | |||
626 | { | |||
627 | if (!v1 || !v2) | |||
628 | goto error; | |||
629 | if (isl_val_is_nan(v1)) { | |||
630 | isl_val_free(v2); | |||
631 | return v1; | |||
632 | } | |||
633 | if (isl_val_is_nan(v2)) { | |||
634 | isl_val_free(v1); | |||
635 | return v2; | |||
636 | } | |||
637 | if ((isl_val_is_infty(v1) && isl_val_is_neginfty(v2)) || | |||
638 | (isl_val_is_neginfty(v1) && isl_val_is_infty(v2))) { | |||
639 | isl_val_free(v2); | |||
640 | return isl_val_set_nan(v1); | |||
641 | } | |||
642 | if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1)) { | |||
643 | isl_val_free(v2); | |||
644 | return v1; | |||
645 | } | |||
646 | if (isl_val_is_infty(v2) || isl_val_is_neginfty(v2)) { | |||
647 | isl_val_free(v1); | |||
648 | return v2; | |||
649 | } | |||
650 | if (isl_val_is_zero(v1)) { | |||
651 | isl_val_free(v1); | |||
652 | return v2; | |||
653 | } | |||
654 | if (isl_val_is_zero(v2)) { | |||
655 | isl_val_free(v2); | |||
656 | return v1; | |||
657 | } | |||
658 | ||||
659 | v1 = isl_val_cow(v1); | |||
660 | if (!v1) | |||
661 | goto error; | |||
662 | if (isl_val_is_int(v1) && isl_val_is_int(v2)) | |||
663 | isl_int_add(v1->n, v1->n, v2->n)isl_sioimath_add((v1->n), *(v1->n), *(v2->n)); | |||
664 | else { | |||
665 | if (isl_int_eq(v1->d, v2->d)(isl_sioimath_cmp(*(v1->d), *(v2->d)) == 0)) | |||
666 | isl_int_add(v1->n, v1->n, v2->n)isl_sioimath_add((v1->n), *(v1->n), *(v2->n)); | |||
667 | else { | |||
668 | isl_int_mul(v1->n, v1->n, v2->d)isl_sioimath_mul((v1->n), *(v1->n), *(v2->d)); | |||
669 | isl_int_addmul(v1->n, v2->n, v1->d)isl_sioimath_addmul((v1->n), *(v2->n), *(v1->d)); | |||
670 | isl_int_mul(v1->d, v1->d, v2->d)isl_sioimath_mul((v1->d), *(v1->d), *(v2->d)); | |||
671 | } | |||
672 | v1 = isl_val_normalize(v1); | |||
673 | } | |||
674 | isl_val_free(v2); | |||
675 | return v1; | |||
676 | error: | |||
677 | isl_val_free(v1); | |||
678 | isl_val_free(v2); | |||
679 | return NULL((void*)0); | |||
680 | } | |||
681 | ||||
682 | /* Return the sum of "v1" and "v2". | |||
683 | */ | |||
684 | __isl_give isl_val *isl_val_add_ui(__isl_take isl_val *v1, unsigned long v2) | |||
685 | { | |||
686 | if (!v1) | |||
687 | return NULL((void*)0); | |||
688 | if (!isl_val_is_rat(v1)) | |||
689 | return v1; | |||
690 | if (v2 == 0) | |||
691 | return v1; | |||
692 | v1 = isl_val_cow(v1); | |||
693 | if (!v1) | |||
694 | return NULL((void*)0); | |||
695 | ||||
696 | isl_int_addmul_ui(v1->n, v1->d, v2)isl_sioimath_addmul_ui((v1->n), *(v1->d), v2); | |||
697 | ||||
698 | return v1; | |||
699 | } | |||
700 | ||||
701 | /* Subtract "v2" from "v1". | |||
702 | */ | |||
703 | __isl_give isl_val *isl_val_sub(__isl_take isl_val *v1, __isl_take isl_val *v2) | |||
704 | { | |||
705 | if (!v1 || !v2) | |||
706 | goto error; | |||
707 | if (isl_val_is_nan(v1)) { | |||
708 | isl_val_free(v2); | |||
709 | return v1; | |||
710 | } | |||
711 | if (isl_val_is_nan(v2)) { | |||
712 | isl_val_free(v1); | |||
713 | return v2; | |||
714 | } | |||
715 | if ((isl_val_is_infty(v1) && isl_val_is_infty(v2)) || | |||
716 | (isl_val_is_neginfty(v1) && isl_val_is_neginfty(v2))) { | |||
717 | isl_val_free(v2); | |||
718 | return isl_val_set_nan(v1); | |||
719 | } | |||
720 | if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1)) { | |||
721 | isl_val_free(v2); | |||
722 | return v1; | |||
723 | } | |||
724 | if (isl_val_is_infty(v2) || isl_val_is_neginfty(v2)) { | |||
725 | isl_val_free(v1); | |||
726 | return isl_val_neg(v2); | |||
727 | } | |||
728 | if (isl_val_is_zero(v2)) { | |||
729 | isl_val_free(v2); | |||
730 | return v1; | |||
731 | } | |||
732 | if (isl_val_is_zero(v1)) { | |||
733 | isl_val_free(v1); | |||
734 | return isl_val_neg(v2); | |||
735 | } | |||
736 | ||||
737 | v1 = isl_val_cow(v1); | |||
738 | if (!v1) | |||
739 | goto error; | |||
740 | if (isl_val_is_int(v1) && isl_val_is_int(v2)) | |||
741 | isl_int_sub(v1->n, v1->n, v2->n)isl_sioimath_sub((v1->n), *(v1->n), *(v2->n)); | |||
742 | else { | |||
743 | if (isl_int_eq(v1->d, v2->d)(isl_sioimath_cmp(*(v1->d), *(v2->d)) == 0)) | |||
744 | isl_int_sub(v1->n, v1->n, v2->n)isl_sioimath_sub((v1->n), *(v1->n), *(v2->n)); | |||
745 | else { | |||
746 | isl_int_mul(v1->n, v1->n, v2->d)isl_sioimath_mul((v1->n), *(v1->n), *(v2->d)); | |||
747 | isl_int_submul(v1->n, v2->n, v1->d)isl_sioimath_submul((v1->n), *(v2->n), *(v1->d)); | |||
748 | isl_int_mul(v1->d, v1->d, v2->d)isl_sioimath_mul((v1->d), *(v1->d), *(v2->d)); | |||
749 | } | |||
750 | v1 = isl_val_normalize(v1); | |||
751 | } | |||
752 | isl_val_free(v2); | |||
753 | return v1; | |||
754 | error: | |||
755 | isl_val_free(v1); | |||
756 | isl_val_free(v2); | |||
757 | return NULL((void*)0); | |||
758 | } | |||
759 | ||||
760 | /* Subtract "v2" from "v1". | |||
761 | */ | |||
762 | __isl_give isl_val *isl_val_sub_ui(__isl_take isl_val *v1, unsigned long v2) | |||
763 | { | |||
764 | if (!v1) | |||
765 | return NULL((void*)0); | |||
766 | if (!isl_val_is_rat(v1)) | |||
767 | return v1; | |||
768 | if (v2 == 0) | |||
769 | return v1; | |||
770 | v1 = isl_val_cow(v1); | |||
771 | if (!v1) | |||
772 | return NULL((void*)0); | |||
773 | ||||
774 | isl_int_submul_ui(v1->n, v1->d, v2)isl_sioimath_submul_ui((v1->n), *(v1->d), v2); | |||
775 | ||||
776 | return v1; | |||
777 | } | |||
778 | ||||
779 | /* Return the product of "v1" and "v2". | |||
780 | */ | |||
781 | __isl_give isl_val *isl_val_mul(__isl_take isl_val *v1, __isl_take isl_val *v2) | |||
782 | { | |||
783 | if (!v1 || !v2) | |||
784 | goto error; | |||
785 | if (isl_val_is_nan(v1)) { | |||
786 | isl_val_free(v2); | |||
787 | return v1; | |||
788 | } | |||
789 | if (isl_val_is_nan(v2)) { | |||
790 | isl_val_free(v1); | |||
791 | return v2; | |||
792 | } | |||
793 | if ((!isl_val_is_rat(v1) && isl_val_is_zero(v2)) || | |||
794 | (isl_val_is_zero(v1) && !isl_val_is_rat(v2))) { | |||
795 | isl_val_free(v2); | |||
796 | return isl_val_set_nan(v1); | |||
797 | } | |||
798 | if (isl_val_is_zero(v1)) { | |||
799 | isl_val_free(v2); | |||
800 | return v1; | |||
801 | } | |||
802 | if (isl_val_is_zero(v2)) { | |||
803 | isl_val_free(v1); | |||
804 | return v2; | |||
805 | } | |||
806 | if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1)) { | |||
807 | if (isl_val_is_neg(v2)) | |||
808 | v1 = isl_val_neg(v1); | |||
809 | isl_val_free(v2); | |||
810 | return v1; | |||
811 | } | |||
812 | if (isl_val_is_infty(v2) || isl_val_is_neginfty(v2)) { | |||
813 | if (isl_val_is_neg(v1)) | |||
814 | v2 = isl_val_neg(v2); | |||
815 | isl_val_free(v1); | |||
816 | return v2; | |||
817 | } | |||
818 | ||||
819 | v1 = isl_val_cow(v1); | |||
820 | if (!v1) | |||
821 | goto error; | |||
822 | if (isl_val_is_int(v1) && isl_val_is_int(v2)) | |||
823 | isl_int_mul(v1->n, v1->n, v2->n)isl_sioimath_mul((v1->n), *(v1->n), *(v2->n)); | |||
824 | else { | |||
825 | isl_int_mul(v1->n, v1->n, v2->n)isl_sioimath_mul((v1->n), *(v1->n), *(v2->n)); | |||
826 | isl_int_mul(v1->d, v1->d, v2->d)isl_sioimath_mul((v1->d), *(v1->d), *(v2->d)); | |||
827 | v1 = isl_val_normalize(v1); | |||
828 | } | |||
829 | isl_val_free(v2); | |||
830 | return v1; | |||
831 | error: | |||
832 | isl_val_free(v1); | |||
833 | isl_val_free(v2); | |||
834 | return NULL((void*)0); | |||
835 | } | |||
836 | ||||
837 | /* Return the product of "v1" and "v2". | |||
838 | * | |||
839 | * This is a private copy of isl_val_mul for use in the generic | |||
840 | * isl_multi_*_scale_val instantiated for isl_val. | |||
841 | */ | |||
842 | __isl_give isl_val *isl_val_scale_val(__isl_take isl_val *v1, | |||
843 | __isl_take isl_val *v2) | |||
844 | { | |||
845 | return isl_val_mul(v1, v2); | |||
846 | } | |||
847 | ||||
848 | /* Return the product of "v1" and "v2". | |||
849 | */ | |||
850 | __isl_give isl_val *isl_val_mul_ui(__isl_take isl_val *v1, unsigned long v2) | |||
851 | { | |||
852 | if (!v1) | |||
853 | return NULL((void*)0); | |||
854 | if (isl_val_is_nan(v1)) | |||
855 | return v1; | |||
856 | if (!isl_val_is_rat(v1)) { | |||
857 | if (v2 == 0) | |||
858 | v1 = isl_val_set_nan(v1); | |||
859 | return v1; | |||
860 | } | |||
861 | if (v2 == 1) | |||
862 | return v1; | |||
863 | v1 = isl_val_cow(v1); | |||
864 | if (!v1) | |||
865 | return NULL((void*)0); | |||
866 | ||||
867 | isl_int_mul_ui(v1->n, v1->n, v2)isl_sioimath_mul_ui((v1->n), *(v1->n), v2); | |||
868 | ||||
869 | return isl_val_normalize(v1); | |||
870 | } | |||
871 | ||||
872 | /* Divide "v1" by "v2". | |||
873 | */ | |||
874 | __isl_give isl_val *isl_val_div(__isl_take isl_val *v1, __isl_take isl_val *v2) | |||
875 | { | |||
876 | if (!v1 || !v2) | |||
877 | goto error; | |||
878 | if (isl_val_is_nan(v1)) { | |||
879 | isl_val_free(v2); | |||
880 | return v1; | |||
881 | } | |||
882 | if (isl_val_is_nan(v2)) { | |||
883 | isl_val_free(v1); | |||
884 | return v2; | |||
885 | } | |||
886 | if (isl_val_is_zero(v2) || | |||
887 | (!isl_val_is_rat(v1) && !isl_val_is_rat(v2))) { | |||
888 | isl_val_free(v2); | |||
889 | return isl_val_set_nan(v1); | |||
890 | } | |||
891 | if (isl_val_is_zero(v1)) { | |||
892 | isl_val_free(v2); | |||
893 | return v1; | |||
894 | } | |||
895 | if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1)) { | |||
896 | if (isl_val_is_neg(v2)) | |||
897 | v1 = isl_val_neg(v1); | |||
898 | isl_val_free(v2); | |||
899 | return v1; | |||
900 | } | |||
901 | if (isl_val_is_infty(v2) || isl_val_is_neginfty(v2)) { | |||
902 | isl_val_free(v2); | |||
903 | return isl_val_set_zero(v1); | |||
904 | } | |||
905 | ||||
906 | v1 = isl_val_cow(v1); | |||
907 | if (!v1) | |||
908 | goto error; | |||
909 | if (isl_val_is_int(v2)) { | |||
910 | isl_int_mul(v1->d, v1->d, v2->n)isl_sioimath_mul((v1->d), *(v1->d), *(v2->n)); | |||
911 | v1 = isl_val_normalize(v1); | |||
912 | } else { | |||
913 | isl_int_mul(v1->d, v1->d, v2->n)isl_sioimath_mul((v1->d), *(v1->d), *(v2->n)); | |||
914 | isl_int_mul(v1->n, v1->n, v2->d)isl_sioimath_mul((v1->n), *(v1->n), *(v2->d)); | |||
915 | v1 = isl_val_normalize(v1); | |||
916 | } | |||
917 | isl_val_free(v2); | |||
918 | return v1; | |||
919 | error: | |||
920 | isl_val_free(v1); | |||
921 | isl_val_free(v2); | |||
922 | return NULL((void*)0); | |||
923 | } | |||
924 | ||||
925 | /* Divide "v1" by "v2". | |||
926 | */ | |||
927 | __isl_give isl_val *isl_val_div_ui(__isl_take isl_val *v1, unsigned long v2) | |||
928 | { | |||
929 | if (!v1) | |||
930 | return NULL((void*)0); | |||
931 | if (isl_val_is_nan(v1)) | |||
932 | return v1; | |||
933 | if (v2 == 0) | |||
934 | return isl_val_set_nan(v1); | |||
935 | if (v2 == 1) | |||
936 | return v1; | |||
937 | if (isl_val_is_zero(v1)) | |||
938 | return v1; | |||
939 | if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1)) | |||
940 | return v1; | |||
941 | v1 = isl_val_cow(v1); | |||
942 | if (!v1) | |||
943 | return NULL((void*)0); | |||
944 | ||||
945 | isl_int_mul_ui(v1->d, v1->d, v2)isl_sioimath_mul_ui((v1->d), *(v1->d), v2); | |||
946 | ||||
947 | return isl_val_normalize(v1); | |||
948 | } | |||
949 | ||||
950 | /* Divide "v1" by "v2". | |||
951 | * | |||
952 | * This is a private copy of isl_val_div for use in the generic | |||
953 | * isl_multi_*_scale_down_val instantiated for isl_val. | |||
954 | */ | |||
955 | __isl_give isl_val *isl_val_scale_down_val(__isl_take isl_val *v1, | |||
956 | __isl_take isl_val *v2) | |||
957 | { | |||
958 | return isl_val_div(v1, v2); | |||
959 | } | |||
960 | ||||
961 | /* Given two integer values "v1" and "v2", check if "v1" is divisible by "v2". | |||
962 | */ | |||
963 | isl_bool isl_val_is_divisible_by(__isl_keep isl_val *v1, __isl_keep isl_val *v2) | |||
964 | { | |||
965 | if (!v1 || !v2) | |||
966 | return isl_bool_error; | |||
967 | ||||
968 | if (!isl_val_is_int(v1) || !isl_val_is_int(v2)) | |||
969 | isl_die(isl_val_get_ctx(v1), isl_error_invalid,do { isl_handle_error(isl_val_get_ctx(v1), isl_error_invalid, "expecting two integers", "/build/llvm-toolchain-snapshot-9~svn362543/tools/polly/lib/External/isl/isl_val.c" , 970); return isl_bool_error; } while (0) | |||
970 | "expecting two integers", return isl_bool_error)do { isl_handle_error(isl_val_get_ctx(v1), isl_error_invalid, "expecting two integers", "/build/llvm-toolchain-snapshot-9~svn362543/tools/polly/lib/External/isl/isl_val.c" , 970); return isl_bool_error; } while (0); | |||
971 | ||||
972 | return isl_int_is_divisible_by(v1->n, v2->n)isl_sioimath_is_divisible_by(*(v1->n), *(v2->n)); | |||
973 | } | |||
974 | ||||
975 | /* Given two integer values "v1" and "v2", return the residue of "v1" | |||
976 | * modulo "v2". | |||
977 | */ | |||
978 | __isl_give isl_val *isl_val_mod(__isl_take isl_val *v1, __isl_take isl_val *v2) | |||
979 | { | |||
980 | if (!v1 || !v2) | |||
981 | goto error; | |||
982 | if (!isl_val_is_int(v1) || !isl_val_is_int(v2)) | |||
983 | isl_die(isl_val_get_ctx(v1), isl_error_invalid,do { isl_handle_error(isl_val_get_ctx(v1), isl_error_invalid, "expecting two integers", "/build/llvm-toolchain-snapshot-9~svn362543/tools/polly/lib/External/isl/isl_val.c" , 984); goto error; } while (0) | |||
984 | "expecting two integers", goto error)do { isl_handle_error(isl_val_get_ctx(v1), isl_error_invalid, "expecting two integers", "/build/llvm-toolchain-snapshot-9~svn362543/tools/polly/lib/External/isl/isl_val.c" , 984); goto error; } while (0); | |||
985 | if (isl_val_is_nonneg(v1) && isl_val_lt(v1, v2)) { | |||
986 | isl_val_free(v2); | |||
987 | return v1; | |||
988 | } | |||
989 | v1 = isl_val_cow(v1); | |||
990 | if (!v1) | |||
991 | goto error; | |||
992 | isl_int_fdiv_r(v1->n, v1->n, v2->n)isl_sioimath_fdiv_r((v1->n), *(v1->n), *(v2->n)); | |||
993 | isl_val_free(v2); | |||
994 | return v1; | |||
995 | error: | |||
996 | isl_val_free(v1); | |||
997 | isl_val_free(v2); | |||
998 | return NULL((void*)0); | |||
999 | } | |||
1000 | ||||
1001 | /* Given two integer values "v1" and "v2", return the residue of "v1" | |||
1002 | * modulo "v2". | |||
1003 | * | |||
1004 | * This is a private copy of isl_val_mod for use in the generic | |||
1005 | * isl_multi_*_mod_multi_val instantiated for isl_val. | |||
1006 | */ | |||
1007 | __isl_give isl_val *isl_val_mod_val(__isl_take isl_val *v1, | |||
1008 | __isl_take isl_val *v2) | |||
1009 | { | |||
1010 | return isl_val_mod(v1, v2); | |||
1011 | } | |||
1012 | ||||
1013 | /* Given two integer values, return their greatest common divisor. | |||
1014 | */ | |||
1015 | __isl_give isl_val *isl_val_gcd(__isl_take isl_val *v1, __isl_take isl_val *v2) | |||
1016 | { | |||
1017 | if (!v1 || !v2) | |||
1018 | goto error; | |||
1019 | if (!isl_val_is_int(v1) || !isl_val_is_int(v2)) | |||
1020 | isl_die(isl_val_get_ctx(v1), isl_error_invalid,do { isl_handle_error(isl_val_get_ctx(v1), isl_error_invalid, "expecting two integers", "/build/llvm-toolchain-snapshot-9~svn362543/tools/polly/lib/External/isl/isl_val.c" , 1021); goto error; } while (0) | |||
1021 | "expecting two integers", goto error)do { isl_handle_error(isl_val_get_ctx(v1), isl_error_invalid, "expecting two integers", "/build/llvm-toolchain-snapshot-9~svn362543/tools/polly/lib/External/isl/isl_val.c" , 1021); goto error; } while (0); | |||
1022 | if (isl_val_eq(v1, v2)) { | |||
1023 | isl_val_free(v2); | |||
1024 | return v1; | |||
1025 | } | |||
1026 | if (isl_val_is_one(v1)) { | |||
1027 | isl_val_free(v2); | |||
1028 | return v1; | |||
1029 | } | |||
1030 | if (isl_val_is_one(v2)) { | |||
1031 | isl_val_free(v1); | |||
1032 | return v2; | |||
1033 | } | |||
1034 | v1 = isl_val_cow(v1); | |||
1035 | if (!v1) | |||
1036 | goto error; | |||
1037 | isl_int_gcd(v1->n, v1->n, v2->n)isl_sioimath_gcd((v1->n), *(v1->n), *(v2->n)); | |||
1038 | isl_val_free(v2); | |||
1039 | return v1; | |||
1040 | error: | |||
1041 | isl_val_free(v1); | |||
1042 | isl_val_free(v2); | |||
1043 | return NULL((void*)0); | |||
1044 | } | |||
1045 | ||||
1046 | /* Compute x, y and g such that g = gcd(a,b) and a*x+b*y = g. | |||
1047 | */ | |||
1048 | static void isl_int_gcdext(isl_int *g, isl_int *x, isl_int *y, | |||
1049 | isl_int a, isl_int b) | |||
1050 | { | |||
1051 | isl_int d, tmp; | |||
1052 | isl_int a_copy, b_copy; | |||
1053 | ||||
1054 | isl_int_init(a_copy)isl_sioimath_init((a_copy)); | |||
1055 | isl_int_init(b_copy)isl_sioimath_init((b_copy)); | |||
1056 | isl_int_init(d)isl_sioimath_init((d)); | |||
1057 | isl_int_init(tmp)isl_sioimath_init((tmp)); | |||
1058 | isl_int_set(a_copy, a)isl_sioimath_set((a_copy), *(a)); | |||
1059 | isl_int_set(b_copy, b)isl_sioimath_set((b_copy), *(b)); | |||
1060 | isl_int_abs(*g, a_copy)isl_sioimath_abs((*g), *(a_copy)); | |||
1061 | isl_int_abs(d, b_copy)isl_sioimath_abs((d), *(b_copy)); | |||
1062 | isl_int_set_si(*x, 1)isl_sioimath_set_si((*x), 1); | |||
1063 | isl_int_set_si(*y, 0)isl_sioimath_set_si((*y), 0); | |||
1064 | while (isl_int_is_pos(d)(isl_sioimath_sgn(*(d)) > 0)) { | |||
1065 | isl_int_fdiv_q(tmp, *g, d)isl_sioimath_fdiv_q((tmp), *(*g), *(d)); | |||
1066 | isl_int_submul(*x, tmp, *y)isl_sioimath_submul((*x), *(tmp), *(*y)); | |||
1067 | isl_int_submul(*g, tmp, d)isl_sioimath_submul((*g), *(tmp), *(d)); | |||
1068 | isl_int_swap(*g, d)isl_sioimath_swap((*g), (d)); | |||
1069 | isl_int_swap(*x, *y)isl_sioimath_swap((*x), (*y)); | |||
1070 | } | |||
1071 | if (isl_int_is_zero(a_copy)(isl_sioimath_sgn(*(a_copy)) == 0)) | |||
1072 | isl_int_set_si(*x, 0)isl_sioimath_set_si((*x), 0); | |||
1073 | else if (isl_int_is_neg(a_copy)(isl_sioimath_sgn(*(a_copy)) < 0)) | |||
1074 | isl_int_neg(*x, *x)isl_sioimath_neg((*x), *(*x)); | |||
1075 | if (isl_int_is_zero(b_copy)(isl_sioimath_sgn(*(b_copy)) == 0)) | |||
1076 | isl_int_set_si(*y, 0)isl_sioimath_set_si((*y), 0); | |||
1077 | else { | |||
1078 | isl_int_mul(tmp, a_copy, *x)isl_sioimath_mul((tmp), *(a_copy), *(*x)); | |||
1079 | isl_int_sub(tmp, *g, tmp)isl_sioimath_sub((tmp), *(*g), *(tmp)); | |||
1080 | isl_int_divexact(*y, tmp, b_copy)isl_sioimath_tdiv_q((*y), *(tmp), *(b_copy)); | |||
1081 | } | |||
1082 | isl_int_clear(d)isl_sioimath_clear((d)); | |||
1083 | isl_int_clear(tmp)isl_sioimath_clear((tmp)); | |||
1084 | isl_int_clear(a_copy)isl_sioimath_clear((a_copy)); | |||
1085 | isl_int_clear(b_copy)isl_sioimath_clear((b_copy)); | |||
1086 | } | |||
1087 | ||||
1088 | /* Given two integer values v1 and v2, return their greatest common divisor g, | |||
1089 | * as well as two integers x and y such that x * v1 + y * v2 = g. | |||
1090 | */ | |||
1091 | __isl_give isl_val *isl_val_gcdext(__isl_take isl_val *v1, | |||
1092 | __isl_take isl_val *v2, __isl_give isl_val **x, __isl_give isl_val **y) | |||
1093 | { | |||
1094 | isl_ctx *ctx; | |||
1095 | isl_val *a = NULL((void*)0), *b = NULL((void*)0); | |||
1096 | ||||
1097 | if (!x && !y) | |||
1098 | return isl_val_gcd(v1, v2); | |||
1099 | ||||
1100 | if (!v1 || !v2) | |||
1101 | goto error; | |||
1102 | ||||
1103 | ctx = isl_val_get_ctx(v1); | |||
1104 | if (!isl_val_is_int(v1) || !isl_val_is_int(v2)) | |||
1105 | isl_die(ctx, isl_error_invalid,do { isl_handle_error(ctx, isl_error_invalid, "expecting two integers" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/polly/lib/External/isl/isl_val.c" , 1106); goto error; } while (0) | |||
1106 | "expecting two integers", goto error)do { isl_handle_error(ctx, isl_error_invalid, "expecting two integers" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/polly/lib/External/isl/isl_val.c" , 1106); goto error; } while (0); | |||
1107 | ||||
1108 | v1 = isl_val_cow(v1); | |||
1109 | a = isl_val_alloc(ctx); | |||
1110 | b = isl_val_alloc(ctx); | |||
1111 | if (!v1 || !a || !b) | |||
1112 | goto error; | |||
1113 | isl_int_gcdext(&v1->n, &a->n, &b->n, v1->n, v2->n); | |||
1114 | if (x) { | |||
1115 | isl_int_set_si(a->d, 1)isl_sioimath_set_si((a->d), 1); | |||
1116 | *x = a; | |||
1117 | } else | |||
1118 | isl_val_free(a); | |||
1119 | if (y) { | |||
1120 | isl_int_set_si(b->d, 1)isl_sioimath_set_si((b->d), 1); | |||
1121 | *y = b; | |||
1122 | } else | |||
1123 | isl_val_free(b); | |||
1124 | isl_val_free(v2); | |||
1125 | return v1; | |||
1126 | error: | |||
1127 | isl_val_free(v1); | |||
1128 | isl_val_free(v2); | |||
1129 | isl_val_free(a); | |||
1130 | isl_val_free(b); | |||
1131 | if (x) | |||
1132 | *x = NULL((void*)0); | |||
1133 | if (y) | |||
1134 | *y = NULL((void*)0); | |||
1135 | return NULL((void*)0); | |||
1136 | } | |||
1137 | ||||
1138 | /* Does "v" represent an integer value? | |||
1139 | */ | |||
1140 | isl_bool isl_val_is_int(__isl_keep isl_val *v) | |||
1141 | { | |||
1142 | if (!v) | |||
1143 | return isl_bool_error; | |||
1144 | ||||
1145 | return isl_int_is_one(v->d)(isl_sioimath_cmp_si(*(v->d), 1) == 0); | |||
1146 | } | |||
1147 | ||||
1148 | /* Does "v" represent a rational value? | |||
1149 | */ | |||
1150 | isl_bool isl_val_is_rat(__isl_keep isl_val *v) | |||
1151 | { | |||
1152 | if (!v) | |||
1153 | return isl_bool_error; | |||
1154 | ||||
1155 | return !isl_int_is_zero(v->d)(isl_sioimath_sgn(*(v->d)) == 0); | |||
1156 | } | |||
1157 | ||||
1158 | /* Does "v" represent NaN? | |||
1159 | */ | |||
1160 | isl_bool isl_val_is_nan(__isl_keep isl_val *v) | |||
1161 | { | |||
1162 | if (!v) | |||
1163 | return isl_bool_error; | |||
1164 | ||||
1165 | return isl_int_is_zero(v->n)(isl_sioimath_sgn(*(v->n)) == 0) && isl_int_is_zero(v->d)(isl_sioimath_sgn(*(v->d)) == 0); | |||
1166 | } | |||
1167 | ||||
1168 | /* Does "v" represent +infinity? | |||
1169 | */ | |||
1170 | isl_bool isl_val_is_infty(__isl_keep isl_val *v) | |||
1171 | { | |||
1172 | if (!v) | |||
1173 | return isl_bool_error; | |||
1174 | ||||
1175 | return isl_int_is_pos(v->n)(isl_sioimath_sgn(*(v->n)) > 0) && isl_int_is_zero(v->d)(isl_sioimath_sgn(*(v->d)) == 0); | |||
1176 | } | |||
1177 | ||||
1178 | /* Does "v" represent -infinity? | |||
1179 | */ | |||
1180 | isl_bool isl_val_is_neginfty(__isl_keep isl_val *v) | |||
1181 | { | |||
1182 | if (!v) | |||
1183 | return isl_bool_error; | |||
1184 | ||||
1185 | return isl_int_is_neg(v->n)(isl_sioimath_sgn(*(v->n)) < 0) && isl_int_is_zero(v->d)(isl_sioimath_sgn(*(v->d)) == 0); | |||
1186 | } | |||
1187 | ||||
1188 | /* Does "v" represent the integer zero? | |||
1189 | */ | |||
1190 | isl_bool isl_val_is_zero(__isl_keep isl_val *v) | |||
1191 | { | |||
1192 | if (!v) | |||
1193 | return isl_bool_error; | |||
1194 | ||||
1195 | return isl_int_is_zero(v->n)(isl_sioimath_sgn(*(v->n)) == 0) && !isl_int_is_zero(v->d)(isl_sioimath_sgn(*(v->d)) == 0); | |||
1196 | } | |||
1197 | ||||
1198 | /* Does "v" represent the integer one? | |||
1199 | */ | |||
1200 | isl_bool isl_val_is_one(__isl_keep isl_val *v) | |||
1201 | { | |||
1202 | if (!v) | |||
1203 | return isl_bool_error; | |||
1204 | ||||
1205 | if (isl_val_is_nan(v)) | |||
1206 | return isl_bool_false; | |||
1207 | ||||
1208 | return isl_int_eq(v->n, v->d)(isl_sioimath_cmp(*(v->n), *(v->d)) == 0); | |||
1209 | } | |||
1210 | ||||
1211 | /* Does "v" represent the integer negative one? | |||
1212 | */ | |||
1213 | isl_bool isl_val_is_negone(__isl_keep isl_val *v) | |||
1214 | { | |||
1215 | if (!v) | |||
1216 | return isl_bool_error; | |||
1217 | ||||
1218 | return isl_int_is_neg(v->n)(isl_sioimath_sgn(*(v->n)) < 0) && isl_int_abs_eq(v->n, v->d)(isl_sioimath_abs_cmp(*(v->n), *(v->d)) == 0); | |||
1219 | } | |||
1220 | ||||
1221 | /* Is "v" (strictly) positive? | |||
1222 | */ | |||
1223 | isl_bool isl_val_is_pos(__isl_keep isl_val *v) | |||
1224 | { | |||
1225 | if (!v) | |||
1226 | return isl_bool_error; | |||
1227 | ||||
1228 | return isl_int_is_pos(v->n)(isl_sioimath_sgn(*(v->n)) > 0); | |||
1229 | } | |||
1230 | ||||
1231 | /* Is "v" (strictly) negative? | |||
1232 | */ | |||
1233 | isl_bool isl_val_is_neg(__isl_keep isl_val *v) | |||
1234 | { | |||
1235 | if (!v) | |||
1236 | return isl_bool_error; | |||
1237 | ||||
1238 | return isl_int_is_neg(v->n)(isl_sioimath_sgn(*(v->n)) < 0); | |||
1239 | } | |||
1240 | ||||
1241 | /* Is "v" non-negative? | |||
1242 | */ | |||
1243 | isl_bool isl_val_is_nonneg(__isl_keep isl_val *v) | |||
1244 | { | |||
1245 | if (!v) | |||
1246 | return isl_bool_error; | |||
1247 | ||||
1248 | if (isl_val_is_nan(v)) | |||
1249 | return isl_bool_false; | |||
1250 | ||||
1251 | return isl_int_is_nonneg(v->n)(isl_sioimath_sgn(*(v->n)) >= 0); | |||
1252 | } | |||
1253 | ||||
1254 | /* Is "v" non-positive? | |||
1255 | */ | |||
1256 | isl_bool isl_val_is_nonpos(__isl_keep isl_val *v) | |||
1257 | { | |||
1258 | if (!v) | |||
1259 | return isl_bool_error; | |||
1260 | ||||
1261 | if (isl_val_is_nan(v)) | |||
1262 | return isl_bool_false; | |||
1263 | ||||
1264 | return isl_int_is_nonpos(v->n)(isl_sioimath_sgn(*(v->n)) <= 0); | |||
1265 | } | |||
1266 | ||||
1267 | /* Return the sign of "v". | |||
1268 | * | |||
1269 | * The sign of NaN is undefined. | |||
1270 | */ | |||
1271 | int isl_val_sgn(__isl_keep isl_val *v) | |||
1272 | { | |||
1273 | if (!v) | |||
1274 | return 0; | |||
1275 | if (isl_val_is_zero(v)) | |||
1276 | return 0; | |||
1277 | if (isl_val_is_pos(v)) | |||
1278 | return 1; | |||
1279 | return -1; | |||
1280 | } | |||
1281 | ||||
1282 | /* Is "v1" (strictly) less than "v2"? | |||
1283 | */ | |||
1284 | isl_bool isl_val_lt(__isl_keep isl_val *v1, __isl_keep isl_val *v2) | |||
1285 | { | |||
1286 | isl_int t; | |||
1287 | isl_bool lt; | |||
1288 | ||||
1289 | if (!v1 || !v2) | |||
1290 | return isl_bool_error; | |||
1291 | if (isl_val_is_int(v1) && isl_val_is_int(v2)) | |||
1292 | return isl_int_lt(v1->n, v2->n)(isl_sioimath_cmp(*(v1->n), *(v2->n)) < 0); | |||
1293 | if (isl_val_is_nan(v1) || isl_val_is_nan(v2)) | |||
1294 | return isl_bool_false; | |||
1295 | if (isl_val_eq(v1, v2)) | |||
1296 | return isl_bool_false; | |||
1297 | if (isl_val_is_infty(v2)) | |||
1298 | return isl_bool_true; | |||
1299 | if (isl_val_is_infty(v1)) | |||
1300 | return isl_bool_false; | |||
1301 | if (isl_val_is_neginfty(v1)) | |||
1302 | return isl_bool_true; | |||
1303 | if (isl_val_is_neginfty(v2)) | |||
1304 | return isl_bool_false; | |||
1305 | ||||
1306 | isl_int_init(t)isl_sioimath_init((t)); | |||
1307 | isl_int_mul(t, v1->n, v2->d)isl_sioimath_mul((t), *(v1->n), *(v2->d)); | |||
1308 | isl_int_submul(t, v2->n, v1->d)isl_sioimath_submul((t), *(v2->n), *(v1->d)); | |||
1309 | lt = isl_int_is_neg(t)(isl_sioimath_sgn(*(t)) < 0); | |||
1310 | isl_int_clear(t)isl_sioimath_clear((t)); | |||
1311 | ||||
1312 | return lt; | |||
1313 | } | |||
1314 | ||||
1315 | /* Is "v1" (strictly) greater than "v2"? | |||
1316 | */ | |||
1317 | isl_bool isl_val_gt(__isl_keep isl_val *v1, __isl_keep isl_val *v2) | |||
1318 | { | |||
1319 | return isl_val_lt(v2, v1); | |||
1320 | } | |||
1321 | ||||
1322 | /* Is "v" (strictly) greater than "i"? | |||
1323 | */ | |||
1324 | isl_bool isl_val_gt_si(__isl_keep isl_val *v, long i) | |||
1325 | { | |||
1326 | isl_val *vi; | |||
1327 | isl_bool res; | |||
1328 | ||||
1329 | if (!v) | |||
1330 | return isl_bool_error; | |||
1331 | if (isl_val_is_int(v)) | |||
1332 | return isl_int_cmp_si(v->n, i)isl_sioimath_cmp_si(*(v->n), i) > 0; | |||
1333 | if (isl_val_is_nan(v)) | |||
1334 | return isl_bool_false; | |||
1335 | if (isl_val_is_infty(v)) | |||
1336 | return isl_bool_true; | |||
1337 | if (isl_val_is_neginfty(v)) | |||
1338 | return isl_bool_false; | |||
1339 | ||||
1340 | vi = isl_val_int_from_si(isl_val_get_ctx(v), i); | |||
1341 | res = isl_val_gt(v, vi); | |||
1342 | isl_val_free(vi); | |||
1343 | ||||
1344 | return res; | |||
1345 | } | |||
1346 | ||||
1347 | /* Is "v1" less than or equal to "v2"? | |||
1348 | */ | |||
1349 | isl_bool isl_val_le(__isl_keep isl_val *v1, __isl_keep isl_val *v2) | |||
1350 | { | |||
1351 | isl_int t; | |||
1352 | isl_bool le; | |||
1353 | ||||
1354 | if (!v1 || !v2) | |||
1355 | return isl_bool_error; | |||
1356 | if (isl_val_is_int(v1) && isl_val_is_int(v2)) | |||
1357 | return isl_int_le(v1->n, v2->n)(isl_sioimath_cmp(*(v1->n), *(v2->n)) <= 0); | |||
1358 | if (isl_val_is_nan(v1) || isl_val_is_nan(v2)) | |||
1359 | return isl_bool_false; | |||
1360 | if (isl_val_eq(v1, v2)) | |||
1361 | return isl_bool_true; | |||
1362 | if (isl_val_is_infty(v2)) | |||
1363 | return isl_bool_true; | |||
1364 | if (isl_val_is_infty(v1)) | |||
1365 | return isl_bool_false; | |||
1366 | if (isl_val_is_neginfty(v1)) | |||
1367 | return isl_bool_true; | |||
1368 | if (isl_val_is_neginfty(v2)) | |||
1369 | return isl_bool_false; | |||
1370 | ||||
1371 | isl_int_init(t)isl_sioimath_init((t)); | |||
1372 | isl_int_mul(t, v1->n, v2->d)isl_sioimath_mul((t), *(v1->n), *(v2->d)); | |||
1373 | isl_int_submul(t, v2->n, v1->d)isl_sioimath_submul((t), *(v2->n), *(v1->d)); | |||
1374 | le = isl_int_is_nonpos(t)(isl_sioimath_sgn(*(t)) <= 0); | |||
1375 | isl_int_clear(t)isl_sioimath_clear((t)); | |||
1376 | ||||
1377 | return le; | |||
1378 | } | |||
1379 | ||||
1380 | /* Is "v1" greater than or equal to "v2"? | |||
1381 | */ | |||
1382 | isl_bool isl_val_ge(__isl_keep isl_val *v1, __isl_keep isl_val *v2) | |||
1383 | { | |||
1384 | return isl_val_le(v2, v1); | |||
1385 | } | |||
1386 | ||||
1387 | /* How does "v" compare to "i"? | |||
1388 | * | |||
1389 | * Return 1 if v is greater, -1 if v is smaller and 0 if v is equal to i. | |||
1390 | * | |||
1391 | * If v is NaN (or NULL), then the result is undefined. | |||
1392 | */ | |||
1393 | int isl_val_cmp_si(__isl_keep isl_val *v, long i) | |||
1394 | { | |||
1395 | isl_int t; | |||
1396 | int cmp; | |||
1397 | ||||
1398 | if (!v) | |||
1399 | return 0; | |||
1400 | if (isl_val_is_int(v)) | |||
1401 | return isl_int_cmp_si(v->n, i)isl_sioimath_cmp_si(*(v->n), i); | |||
1402 | if (isl_val_is_nan(v)) | |||
1403 | return 0; | |||
1404 | if (isl_val_is_infty(v)) | |||
1405 | return 1; | |||
1406 | if (isl_val_is_neginfty(v)) | |||
1407 | return -1; | |||
1408 | ||||
1409 | isl_int_init(t)isl_sioimath_init((t)); | |||
1410 | isl_int_mul_si(t, v->d, i)isl_sioimath_mul_si((t), *(v->d), i); | |||
1411 | isl_int_sub(t, v->n, t)isl_sioimath_sub((t), *(v->n), *(t)); | |||
1412 | cmp = isl_int_sgn(t)isl_sioimath_sgn(*(t)); | |||
1413 | isl_int_clear(t)isl_sioimath_clear((t)); | |||
1414 | ||||
1415 | return cmp; | |||
1416 | } | |||
1417 | ||||
1418 | /* Is "v1" equal to "v2"? | |||
1419 | */ | |||
1420 | isl_bool isl_val_eq(__isl_keep isl_val *v1, __isl_keep isl_val *v2) | |||
1421 | { | |||
1422 | if (!v1 || !v2) | |||
1423 | return isl_bool_error; | |||
1424 | if (isl_val_is_nan(v1) || isl_val_is_nan(v2)) | |||
1425 | return isl_bool_false; | |||
1426 | ||||
1427 | return isl_int_eq(v1->n, v2->n)(isl_sioimath_cmp(*(v1->n), *(v2->n)) == 0) && isl_int_eq(v1->d, v2->d)(isl_sioimath_cmp(*(v1->d), *(v2->d)) == 0); | |||
1428 | } | |||
1429 | ||||
1430 | /* Is "v1" equal to "v2" in absolute value? | |||
1431 | */ | |||
1432 | isl_bool isl_val_abs_eq(__isl_keep isl_val *v1, __isl_keep isl_val *v2) | |||
1433 | { | |||
1434 | if (!v1 || !v2) | |||
1435 | return isl_bool_error; | |||
1436 | if (isl_val_is_nan(v1) || isl_val_is_nan(v2)) | |||
1437 | return isl_bool_false; | |||
1438 | ||||
1439 | return isl_int_abs_eq(v1->n, v2->n)(isl_sioimath_abs_cmp(*(v1->n), *(v2->n)) == 0) && isl_int_eq(v1->d, v2->d)(isl_sioimath_cmp(*(v1->d), *(v2->d)) == 0); | |||
1440 | } | |||
1441 | ||||
1442 | /* Is "v1" different from "v2"? | |||
1443 | */ | |||
1444 | isl_bool isl_val_ne(__isl_keep isl_val *v1, __isl_keep isl_val *v2) | |||
1445 | { | |||
1446 | if (!v1 || !v2) | |||
1447 | return isl_bool_error; | |||
1448 | if (isl_val_is_nan(v1) || isl_val_is_nan(v2)) | |||
1449 | return isl_bool_false; | |||
1450 | ||||
1451 | return isl_int_ne(v1->n, v2->n)(isl_sioimath_cmp(*(v1->n), *(v2->n)) != 0) || isl_int_ne(v1->d, v2->d)(isl_sioimath_cmp(*(v1->d), *(v2->d)) != 0); | |||
1452 | } | |||
1453 | ||||
1454 | /* Print a textual representation of "v" onto "p". | |||
1455 | */ | |||
1456 | __isl_give isl_printer *isl_printer_print_val(__isl_take isl_printer *p, | |||
1457 | __isl_keep isl_val *v) | |||
1458 | { | |||
1459 | int neg; | |||
1460 | ||||
1461 | if (!p || !v) | |||
1462 | return isl_printer_free(p); | |||
1463 | ||||
1464 | neg = isl_int_is_neg(v->n)(isl_sioimath_sgn(*(v->n)) < 0); | |||
1465 | if (neg) { | |||
1466 | p = isl_printer_print_str(p, "-"); | |||
1467 | isl_int_neg(v->n, v->n)isl_sioimath_neg((v->n), *(v->n)); | |||
1468 | } | |||
1469 | if (isl_int_is_zero(v->d)(isl_sioimath_sgn(*(v->d)) == 0)) { | |||
1470 | int sgn = isl_int_sgn(v->n)isl_sioimath_sgn(*(v->n)); | |||
1471 | p = isl_printer_print_str(p, sgn < 0 ? "-infty" : | |||
1472 | sgn == 0 ? "NaN" : "infty"); | |||
1473 | } else | |||
1474 | p = isl_printer_print_isl_int(p, v->n); | |||
1475 | if (neg) | |||
1476 | isl_int_neg(v->n, v->n)isl_sioimath_neg((v->n), *(v->n)); | |||
1477 | if (!isl_int_is_zero(v->d)(isl_sioimath_sgn(*(v->d)) == 0) && !isl_int_is_one(v->d)(isl_sioimath_cmp_si(*(v->d), 1) == 0)) { | |||
1478 | p = isl_printer_print_str(p, "/"); | |||
1479 | p = isl_printer_print_isl_int(p, v->d); | |||
1480 | } | |||
1481 | ||||
1482 | return p; | |||
1483 | } | |||
1484 | ||||
1485 | /* Is "val1" (obviously) equal to "val2"? | |||
1486 | * | |||
1487 | * This is a private copy of isl_val_eq for use in the generic | |||
1488 | * isl_multi_*_plain_is_equal instantiated for isl_val. | |||
1489 | */ | |||
1490 | int isl_val_plain_is_equal(__isl_keep isl_val *val1, __isl_keep isl_val *val2) | |||
1491 | { | |||
1492 | return isl_val_eq(val1, val2); | |||
1493 | } | |||
1494 | ||||
1495 | /* Does "v" have any non-zero coefficients | |||
1496 | * for any dimension in the given range? | |||
1497 | * | |||
1498 | * This function is only meant to be used in the generic isl_multi_* | |||
1499 | * functions which have to deal with base objects that have an associated | |||
1500 | * space. Since an isl_val does not have any coefficients, this function | |||
1501 | * always returns isl_bool_false. | |||
1502 | */ | |||
1503 | isl_bool isl_val_involves_dims(__isl_keep isl_val *v, enum isl_dim_type type, | |||
1504 | unsigned first, unsigned n) | |||
1505 | { | |||
1506 | if (!v) | |||
1507 | return isl_bool_error; | |||
1508 | ||||
1509 | return isl_bool_false; | |||
1510 | } | |||
1511 | ||||
1512 | /* Insert "n" dimensions of type "type" at position "first". | |||
1513 | * | |||
1514 | * This function is only meant to be used in the generic isl_multi_* | |||
1515 | * functions which have to deal with base objects that have an associated | |||
1516 | * space. Since an isl_val does not have an associated space, this function | |||
1517 | * does not do anything. | |||
1518 | */ | |||
1519 | __isl_give isl_val *isl_val_insert_dims(__isl_take isl_val *v, | |||
1520 | enum isl_dim_type type, unsigned first, unsigned n) | |||
1521 | { | |||
1522 | return v; | |||
1523 | } | |||
1524 | ||||
1525 | /* Drop the "n" first dimensions of type "type" at position "first". | |||
1526 | * | |||
1527 | * This function is only meant to be used in the generic isl_multi_* | |||
1528 | * functions which have to deal with base objects that have an associated | |||
1529 | * space. Since an isl_val does not have an associated space, this function | |||
1530 | * does not do anything. | |||
1531 | */ | |||
1532 | __isl_give isl_val *isl_val_drop_dims(__isl_take isl_val *v, | |||
1533 | enum isl_dim_type type, unsigned first, unsigned n) | |||
1534 | { | |||
1535 | return v; | |||
1536 | } | |||
1537 | ||||
1538 | /* Change the name of the dimension of type "type" at position "pos" to "s". | |||
1539 | * | |||
1540 | * This function is only meant to be used in the generic isl_multi_* | |||
1541 | * functions which have to deal with base objects that have an associated | |||
1542 | * space. Since an isl_val does not have an associated space, this function | |||
1543 | * does not do anything. | |||
1544 | */ | |||
1545 | __isl_give isl_val *isl_val_set_dim_name(__isl_take isl_val *v, | |||
1546 | enum isl_dim_type type, unsigned pos, const char *s) | |||
1547 | { | |||
1548 | return v; | |||
1549 | } | |||
1550 | ||||
1551 | /* Return the space of "v". | |||
1552 | * | |||
1553 | * This function is only meant to be used in the generic isl_multi_* | |||
1554 | * functions which have to deal with base objects that have an associated | |||
1555 | * space. The conditions surrounding the call to this function make sure | |||
1556 | * that this function will never actually get called. We return a valid | |||
1557 | * space anyway, just in case. | |||
1558 | */ | |||
1559 | __isl_give isl_space *isl_val_get_space(__isl_keep isl_val *v) | |||
1560 | { | |||
1561 | if (!v) | |||
1562 | return NULL((void*)0); | |||
1563 | ||||
1564 | return isl_space_params_alloc(isl_val_get_ctx(v), 0); | |||
1565 | } | |||
1566 | ||||
1567 | /* Reset the domain space of "v" to "space". | |||
1568 | * | |||
1569 | * This function is only meant to be used in the generic isl_multi_* | |||
1570 | * functions which have to deal with base objects that have an associated | |||
1571 | * space. Since an isl_val does not have an associated space, this function | |||
1572 | * does not do anything, apart from error handling and cleaning up memory. | |||
1573 | */ | |||
1574 | __isl_give isl_val *isl_val_reset_domain_space(__isl_take isl_val *v, | |||
1575 | __isl_take isl_space *space) | |||
1576 | { | |||
1577 | if (!space) | |||
1578 | return isl_val_free(v); | |||
1579 | isl_space_free(space); | |||
1580 | return v; | |||
1581 | } | |||
1582 | ||||
1583 | /* Align the parameters of "v" to those of "space". | |||
1584 | * | |||
1585 | * This function is only meant to be used in the generic isl_multi_* | |||
1586 | * functions which have to deal with base objects that have an associated | |||
1587 | * space. Since an isl_val does not have an associated space, this function | |||
1588 | * does not do anything, apart from error handling and cleaning up memory. | |||
1589 | * Note that the conditions surrounding the call to this function make sure | |||
1590 | * that this function will never actually get called. | |||
1591 | */ | |||
1592 | __isl_give isl_val *isl_val_align_params(__isl_take isl_val *v, | |||
1593 | __isl_take isl_space *space) | |||
1594 | { | |||
1595 | if (!space) | |||
1596 | return isl_val_free(v); | |||
1597 | isl_space_free(space); | |||
1598 | return v; | |||
1599 | } | |||
1600 | ||||
1601 | /* Reorder the dimensions of the domain of "v" according | |||
1602 | * to the given reordering. | |||
1603 | * | |||
1604 | * This function is only meant to be used in the generic isl_multi_* | |||
1605 | * functions which have to deal with base objects that have an associated | |||
1606 | * space. Since an isl_val does not have an associated space, this function | |||
1607 | * does not do anything, apart from error handling and cleaning up memory. | |||
1608 | */ | |||
1609 | __isl_give isl_val *isl_val_realign_domain(__isl_take isl_val *v, | |||
1610 | __isl_take isl_reordering *r) | |||
1611 | { | |||
1612 | if (!r) | |||
1613 | return isl_val_free(v); | |||
1614 | isl_reordering_free(r); | |||
1615 | return v; | |||
1616 | } | |||
1617 | ||||
1618 | /* Return an isl_val that is zero on "ls". | |||
1619 | * | |||
1620 | * This function is only meant to be used in the generic isl_multi_* | |||
1621 | * functions which have to deal with base objects that have an associated | |||
1622 | * space. Since an isl_val does not have an associated space, this function | |||
1623 | * simply returns a zero isl_val in the same context as "ls". | |||
1624 | */ | |||
1625 | __isl_give isl_val *isl_val_zero_on_domain(__isl_take isl_local_space *ls) | |||
1626 | { | |||
1627 | isl_ctx *ctx; | |||
1628 | ||||
1629 | if (!ls) | |||
1630 | return NULL((void*)0); | |||
1631 | ctx = isl_local_space_get_ctx(ls); | |||
1632 | isl_local_space_free(ls); | |||
1633 | return isl_val_zero(ctx); | |||
1634 | } | |||
1635 | ||||
1636 | /* Do the parameters of "v" match those of "space"? | |||
1637 | * | |||
1638 | * This function is only meant to be used in the generic isl_multi_* | |||
1639 | * functions which have to deal with base objects that have an associated | |||
1640 | * space. Since an isl_val does not have an associated space, this function | |||
1641 | * simply returns true, except if "v" or "space" are NULL. | |||
1642 | */ | |||
1643 | isl_bool isl_val_matching_params(__isl_keep isl_val *v, | |||
1644 | __isl_keep isl_space *space) | |||
1645 | { | |||
1646 | if (!v || !space) | |||
1647 | return isl_bool_error; | |||
1648 | return isl_bool_true; | |||
1649 | } | |||
1650 | ||||
1651 | /* Check that the domain space of "v" matches "space". | |||
1652 | * | |||
1653 | * This function is only meant to be used in the generic isl_multi_* | |||
1654 | * functions which have to deal with base objects that have an associated | |||
1655 | * space. Since an isl_val does not have an associated space, this function | |||
1656 | * simply returns 0, except if "v" or "space" are NULL. | |||
1657 | */ | |||
1658 | isl_stat isl_val_check_match_domain_space(__isl_keep isl_val *v, | |||
1659 | __isl_keep isl_space *space) | |||
1660 | { | |||
1661 | if (!v || !space) | |||
1662 | return isl_stat_error; | |||
1663 | return isl_stat_ok; | |||
1664 | } | |||
1665 | ||||
1666 | #define isl_val_involves_nanisl_val_is_nan isl_val_is_nan | |||
1667 | ||||
1668 | #undef BASEval | |||
1669 | #define BASEval val | |||
1670 | ||||
1671 | #define NO_DOMAIN | |||
1672 | #define NO_IDENTITY | |||
1673 | #define NO_FROM_BASE | |||
1674 | #define NO_MOVE_DIMS | |||
1675 | #include <isl_multi_no_explicit_domain.c> | |||
1676 | #include <isl_multi_templ.c> | |||
1677 | #include <isl_multi_dims.c> | |||
1678 | ||||
1679 | /* Apply "fn" to each of the elements of "mv" with as second argument "v". | |||
1680 | */ | |||
1681 | static __isl_give isl_multi_val *isl_multi_val_fn_val( | |||
1682 | __isl_take isl_multi_val *mv, | |||
1683 | __isl_give isl_val *(*fn)(__isl_take isl_val *v1, | |||
1684 | __isl_take isl_val *v2), | |||
1685 | __isl_take isl_val *v) | |||
1686 | { | |||
1687 | int i; | |||
1688 | ||||
1689 | mv = isl_multi_val_cow(mv); | |||
1690 | if (!mv || !v) | |||
1691 | goto error; | |||
1692 | ||||
1693 | for (i = 0; i < mv->n; ++i) { | |||
1694 | mv->u.p[i] = fn(mv->u.p[i], isl_val_copy(v)); | |||
1695 | if (!mv->u.p[i]) | |||
1696 | goto error; | |||
1697 | } | |||
1698 | ||||
1699 | isl_val_free(v); | |||
| ||||
1700 | return mv; | |||
1701 | error: | |||
1702 | isl_val_free(v); | |||
1703 | isl_multi_val_free(mv); | |||
1704 | return NULL((void*)0); | |||
1705 | } | |||
1706 | ||||
1707 | /* Add "v" to each of the elements of "mv". | |||
1708 | */ | |||
1709 | __isl_give isl_multi_val *isl_multi_val_add_val(__isl_take isl_multi_val *mv, | |||
1710 | __isl_take isl_val *v) | |||
1711 | { | |||
1712 | if (!v) | |||
1713 | return isl_multi_val_free(mv); | |||
1714 | if (isl_val_is_zero(v)) { | |||
1715 | isl_val_free(v); | |||
1716 | return mv; | |||
1717 | } | |||
1718 | return isl_multi_val_fn_val(mv, &isl_val_add, v); | |||
1719 | } | |||
1720 | ||||
1721 | /* Reduce the elements of "mv" modulo "v". | |||
1722 | */ | |||
1723 | __isl_give isl_multi_val *isl_multi_val_mod_val(__isl_take isl_multi_val *mv, | |||
1724 | __isl_take isl_val *v) | |||
1725 | { | |||
1726 | return isl_multi_val_fn_val(mv, &isl_val_mod, v); | |||
| ||||
1727 | } |