1use super::{
5 Aff, Context, DimType, Error, LibISLError, MultiAff, MultiUnionPwAff, MultiVal, PwMultiAff,
6 PwMultiAffList, Set, Space, UnionMap, UnionPwAff, UnionPwMultiAffList, UnionSet, Val,
7};
8use libc::uintptr_t;
9use std::ffi::{CStr, CString};
10use std::os::raw::c_char;
11
12pub struct UnionPwMultiAff {
14 pub ptr: uintptr_t,
15 pub should_free_on_drop: bool,
16}
17
18extern "C" {
19
20 fn isl_union_pw_multi_aff_add(upma1: uintptr_t, upma2: uintptr_t) -> uintptr_t;
21
22 fn isl_union_pw_multi_aff_add_pw_multi_aff(upma: uintptr_t, pma: uintptr_t) -> uintptr_t;
23
24 fn isl_union_pw_multi_aff_align_params(upma: uintptr_t, model: uintptr_t) -> uintptr_t;
25
26 fn isl_union_pw_multi_aff_apply_union_pw_multi_aff(upma1: uintptr_t, upma2: uintptr_t)
27 -> uintptr_t;
28
29 fn isl_union_pw_multi_aff_as_multi_union_pw_aff(upma: uintptr_t) -> uintptr_t;
30
31 fn isl_union_pw_multi_aff_as_pw_multi_aff(upma: uintptr_t) -> uintptr_t;
32
33 fn isl_union_pw_multi_aff_as_union_map(upma: uintptr_t) -> uintptr_t;
34
35 fn isl_union_pw_multi_aff_coalesce(upma: uintptr_t) -> uintptr_t;
36
37 fn isl_union_pw_multi_aff_copy(upma: uintptr_t) -> uintptr_t;
38
39 fn isl_union_pw_multi_aff_dim(upma: uintptr_t, type_: i32) -> i32;
40
41 fn isl_union_pw_multi_aff_domain(upma: uintptr_t) -> uintptr_t;
42
43 fn isl_union_pw_multi_aff_drop_dims(upma: uintptr_t, type_: i32, first: u32, n: u32)
44 -> uintptr_t;
45
46 fn isl_union_pw_multi_aff_drop_unused_params(upma: uintptr_t) -> uintptr_t;
47
48 fn isl_union_pw_multi_aff_dump(upma: uintptr_t) -> ();
49
50 fn isl_union_pw_multi_aff_empty(space: uintptr_t) -> uintptr_t;
51
52 fn isl_union_pw_multi_aff_empty_ctx(ctx: uintptr_t) -> uintptr_t;
53
54 fn isl_union_pw_multi_aff_empty_space(space: uintptr_t) -> uintptr_t;
55
56 fn isl_union_pw_multi_aff_extract_pw_multi_aff(upma: uintptr_t, space: uintptr_t) -> uintptr_t;
57
58 fn isl_union_pw_multi_aff_find_dim_by_name(upma: uintptr_t, type_: i32, name: *const c_char)
59 -> i32;
60
61 fn isl_union_pw_multi_aff_flat_range_product(upma1: uintptr_t, upma2: uintptr_t) -> uintptr_t;
62
63 fn isl_union_pw_multi_aff_free(upma: uintptr_t) -> uintptr_t;
64
65 fn isl_union_pw_multi_aff_from_aff(aff: uintptr_t) -> uintptr_t;
66
67 fn isl_union_pw_multi_aff_from_domain(uset: uintptr_t) -> uintptr_t;
68
69 fn isl_union_pw_multi_aff_from_multi_aff(ma: uintptr_t) -> uintptr_t;
70
71 fn isl_union_pw_multi_aff_from_multi_union_pw_aff(mupa: uintptr_t) -> uintptr_t;
72
73 fn isl_union_pw_multi_aff_from_pw_multi_aff(pma: uintptr_t) -> uintptr_t;
74
75 fn isl_union_pw_multi_aff_from_union_map(umap: uintptr_t) -> uintptr_t;
76
77 fn isl_union_pw_multi_aff_from_union_pw_aff(upa: uintptr_t) -> uintptr_t;
78
79 fn isl_union_pw_multi_aff_from_union_set(uset: uintptr_t) -> uintptr_t;
80
81 fn isl_union_pw_multi_aff_get_ctx(upma: uintptr_t) -> uintptr_t;
82
83 fn isl_union_pw_multi_aff_get_pw_multi_aff_list(upma: uintptr_t) -> uintptr_t;
84
85 fn isl_union_pw_multi_aff_get_space(upma: uintptr_t) -> uintptr_t;
86
87 fn isl_union_pw_multi_aff_get_union_pw_aff(upma: uintptr_t, pos: i32) -> uintptr_t;
88
89 fn isl_union_pw_multi_aff_gist(upma: uintptr_t, context: uintptr_t) -> uintptr_t;
90
91 fn isl_union_pw_multi_aff_gist_params(upma: uintptr_t, context: uintptr_t) -> uintptr_t;
92
93 fn isl_union_pw_multi_aff_intersect_domain(upma: uintptr_t, uset: uintptr_t) -> uintptr_t;
94
95 fn isl_union_pw_multi_aff_intersect_domain_space(upma: uintptr_t, space: uintptr_t)
96 -> uintptr_t;
97
98 fn isl_union_pw_multi_aff_intersect_domain_union_set(upma: uintptr_t, uset: uintptr_t)
99 -> uintptr_t;
100
101 fn isl_union_pw_multi_aff_intersect_domain_wrapped_domain(upma: uintptr_t, uset: uintptr_t)
102 -> uintptr_t;
103
104 fn isl_union_pw_multi_aff_intersect_domain_wrapped_range(upma: uintptr_t, uset: uintptr_t)
105 -> uintptr_t;
106
107 fn isl_union_pw_multi_aff_intersect_params(upma: uintptr_t, set: uintptr_t) -> uintptr_t;
108
109 fn isl_union_pw_multi_aff_involves_locals(upma: uintptr_t) -> i32;
110
111 fn isl_union_pw_multi_aff_involves_nan(upma: uintptr_t) -> i32;
112
113 fn isl_union_pw_multi_aff_isa_pw_multi_aff(upma: uintptr_t) -> i32;
114
115 fn isl_union_pw_multi_aff_multi_val_on_domain(domain: uintptr_t, mv: uintptr_t) -> uintptr_t;
116
117 fn isl_union_pw_multi_aff_n_pw_multi_aff(upma: uintptr_t) -> i32;
118
119 fn isl_union_pw_multi_aff_neg(upma: uintptr_t) -> uintptr_t;
120
121 fn isl_union_pw_multi_aff_plain_is_empty(upma: uintptr_t) -> i32;
122
123 fn isl_union_pw_multi_aff_plain_is_equal(upma1: uintptr_t, upma2: uintptr_t) -> i32;
124
125 fn isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff(upma1: uintptr_t,
126 upma2: uintptr_t)
127 -> uintptr_t;
128
129 fn isl_union_pw_multi_aff_pullback_union_pw_multi_aff(upma1: uintptr_t, upma2: uintptr_t)
130 -> uintptr_t;
131
132 fn isl_union_pw_multi_aff_range_factor_domain(upma: uintptr_t) -> uintptr_t;
133
134 fn isl_union_pw_multi_aff_range_factor_range(upma: uintptr_t) -> uintptr_t;
135
136 fn isl_union_pw_multi_aff_range_product(upma1: uintptr_t, upma2: uintptr_t) -> uintptr_t;
137
138 fn isl_union_pw_multi_aff_read_from_str(ctx: uintptr_t, str_: *const c_char) -> uintptr_t;
139
140 fn isl_union_pw_multi_aff_reset_user(upma: uintptr_t) -> uintptr_t;
141
142 fn isl_union_pw_multi_aff_scale_down_val(upma: uintptr_t, val: uintptr_t) -> uintptr_t;
143
144 fn isl_union_pw_multi_aff_scale_multi_val(upma: uintptr_t, mv: uintptr_t) -> uintptr_t;
145
146 fn isl_union_pw_multi_aff_scale_val(upma: uintptr_t, val: uintptr_t) -> uintptr_t;
147
148 fn isl_union_pw_multi_aff_set_dim_name(upma: uintptr_t, type_: i32, pos: u32, s: *const c_char)
149 -> uintptr_t;
150
151 fn isl_union_pw_multi_aff_sub(upma1: uintptr_t, upma2: uintptr_t) -> uintptr_t;
152
153 fn isl_union_pw_multi_aff_subtract_domain(upma: uintptr_t, uset: uintptr_t) -> uintptr_t;
154
155 fn isl_union_pw_multi_aff_subtract_domain_space(upma: uintptr_t, space: uintptr_t)
156 -> uintptr_t;
157
158 fn isl_union_pw_multi_aff_subtract_domain_union_set(upma: uintptr_t, uset: uintptr_t)
159 -> uintptr_t;
160
161 fn isl_union_pw_multi_aff_to_list(el: uintptr_t) -> uintptr_t;
162
163 fn isl_union_pw_multi_aff_to_str(upma: uintptr_t) -> *const c_char;
164
165 fn isl_union_pw_multi_aff_union_add(upma1: uintptr_t, upma2: uintptr_t) -> uintptr_t;
166
167}
168
169impl UnionPwMultiAff {
170 pub fn add(self, upma2: UnionPwMultiAff) -> Result<UnionPwMultiAff, LibISLError> {
172 let upma1 = self;
173 let isl_rs_ctx = upma1.get_ctx();
174 let mut upma1 = upma1;
175 upma1.do_not_free_on_drop();
176 let upma1 = upma1.ptr;
177 let mut upma2 = upma2;
178 upma2.do_not_free_on_drop();
179 let upma2 = upma2.ptr;
180 let isl_rs_result = unsafe { isl_union_pw_multi_aff_add(upma1, upma2) };
181 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
182 should_free_on_drop: true };
183 let err = isl_rs_ctx.last_error();
184 if err != Error::None_ {
185 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
186 }
187 Ok(isl_rs_result)
188 }
189
190 pub fn add_pw_multi_aff(self, pma: PwMultiAff) -> Result<UnionPwMultiAff, LibISLError> {
192 let upma = self;
193 let isl_rs_ctx = upma.get_ctx();
194 let mut upma = upma;
195 upma.do_not_free_on_drop();
196 let upma = upma.ptr;
197 let mut pma = pma;
198 pma.do_not_free_on_drop();
199 let pma = pma.ptr;
200 let isl_rs_result = unsafe { isl_union_pw_multi_aff_add_pw_multi_aff(upma, pma) };
201 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
202 should_free_on_drop: true };
203 let err = isl_rs_ctx.last_error();
204 if err != Error::None_ {
205 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
206 }
207 Ok(isl_rs_result)
208 }
209
210 pub fn align_params(self, model: Space) -> Result<UnionPwMultiAff, LibISLError> {
212 let upma = self;
213 let isl_rs_ctx = upma.get_ctx();
214 let mut upma = upma;
215 upma.do_not_free_on_drop();
216 let upma = upma.ptr;
217 let mut model = model;
218 model.do_not_free_on_drop();
219 let model = model.ptr;
220 let isl_rs_result = unsafe { isl_union_pw_multi_aff_align_params(upma, model) };
221 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
222 should_free_on_drop: true };
223 let err = isl_rs_ctx.last_error();
224 if err != Error::None_ {
225 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
226 }
227 Ok(isl_rs_result)
228 }
229
230 pub fn apply_union_pw_multi_aff(self, upma2: UnionPwMultiAff)
232 -> Result<UnionPwMultiAff, LibISLError> {
233 let upma1 = self;
234 let isl_rs_ctx = upma1.get_ctx();
235 let mut upma1 = upma1;
236 upma1.do_not_free_on_drop();
237 let upma1 = upma1.ptr;
238 let mut upma2 = upma2;
239 upma2.do_not_free_on_drop();
240 let upma2 = upma2.ptr;
241 let isl_rs_result =
242 unsafe { isl_union_pw_multi_aff_apply_union_pw_multi_aff(upma1, upma2) };
243 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
244 should_free_on_drop: true };
245 let err = isl_rs_ctx.last_error();
246 if err != Error::None_ {
247 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
248 }
249 Ok(isl_rs_result)
250 }
251
252 pub fn as_multi_union_pw_aff(self) -> Result<MultiUnionPwAff, LibISLError> {
254 let upma = self;
255 let isl_rs_ctx = upma.get_ctx();
256 let mut upma = upma;
257 upma.do_not_free_on_drop();
258 let upma = upma.ptr;
259 let isl_rs_result = unsafe { isl_union_pw_multi_aff_as_multi_union_pw_aff(upma) };
260 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
261 should_free_on_drop: true };
262 let err = isl_rs_ctx.last_error();
263 if err != Error::None_ {
264 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
265 }
266 Ok(isl_rs_result)
267 }
268
269 pub fn as_pw_multi_aff(self) -> Result<PwMultiAff, LibISLError> {
271 let upma = self;
272 let isl_rs_ctx = upma.get_ctx();
273 let mut upma = upma;
274 upma.do_not_free_on_drop();
275 let upma = upma.ptr;
276 let isl_rs_result = unsafe { isl_union_pw_multi_aff_as_pw_multi_aff(upma) };
277 let isl_rs_result = PwMultiAff { ptr: isl_rs_result,
278 should_free_on_drop: true };
279 let err = isl_rs_ctx.last_error();
280 if err != Error::None_ {
281 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
282 }
283 Ok(isl_rs_result)
284 }
285
286 pub fn as_union_map(self) -> Result<UnionMap, LibISLError> {
288 let upma = self;
289 let isl_rs_ctx = upma.get_ctx();
290 let mut upma = upma;
291 upma.do_not_free_on_drop();
292 let upma = upma.ptr;
293 let isl_rs_result = unsafe { isl_union_pw_multi_aff_as_union_map(upma) };
294 let isl_rs_result = UnionMap { ptr: isl_rs_result,
295 should_free_on_drop: true };
296 let err = isl_rs_ctx.last_error();
297 if err != Error::None_ {
298 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
299 }
300 Ok(isl_rs_result)
301 }
302
303 pub fn coalesce(self) -> Result<UnionPwMultiAff, LibISLError> {
305 let upma = self;
306 let isl_rs_ctx = upma.get_ctx();
307 let mut upma = upma;
308 upma.do_not_free_on_drop();
309 let upma = upma.ptr;
310 let isl_rs_result = unsafe { isl_union_pw_multi_aff_coalesce(upma) };
311 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
312 should_free_on_drop: true };
313 let err = isl_rs_ctx.last_error();
314 if err != Error::None_ {
315 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
316 }
317 Ok(isl_rs_result)
318 }
319
320 pub fn copy(&self) -> Result<UnionPwMultiAff, LibISLError> {
322 let upma = self;
323 let isl_rs_ctx = upma.get_ctx();
324 let upma = upma.ptr;
325 let isl_rs_result = unsafe { isl_union_pw_multi_aff_copy(upma) };
326 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
327 should_free_on_drop: true };
328 let err = isl_rs_ctx.last_error();
329 if err != Error::None_ {
330 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
331 }
332 Ok(isl_rs_result)
333 }
334
335 pub fn dim(&self, type_: DimType) -> Result<i32, LibISLError> {
337 let upma = self;
338 let isl_rs_ctx = upma.get_ctx();
339 let upma = upma.ptr;
340 let type_ = type_.to_i32();
341 let isl_rs_result = unsafe { isl_union_pw_multi_aff_dim(upma, type_) };
342 let err = isl_rs_ctx.last_error();
343 if err != Error::None_ {
344 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
345 }
346 Ok(isl_rs_result)
347 }
348
349 pub fn domain(self) -> Result<UnionSet, LibISLError> {
351 let upma = self;
352 let isl_rs_ctx = upma.get_ctx();
353 let mut upma = upma;
354 upma.do_not_free_on_drop();
355 let upma = upma.ptr;
356 let isl_rs_result = unsafe { isl_union_pw_multi_aff_domain(upma) };
357 let isl_rs_result = UnionSet { ptr: isl_rs_result,
358 should_free_on_drop: true };
359 let err = isl_rs_ctx.last_error();
360 if err != Error::None_ {
361 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
362 }
363 Ok(isl_rs_result)
364 }
365
366 pub fn drop_dims(self, type_: DimType, first: u32, n: u32)
368 -> Result<UnionPwMultiAff, LibISLError> {
369 let upma = self;
370 let isl_rs_ctx = upma.get_ctx();
371 let mut upma = upma;
372 upma.do_not_free_on_drop();
373 let upma = upma.ptr;
374 let type_ = type_.to_i32();
375 let isl_rs_result = unsafe { isl_union_pw_multi_aff_drop_dims(upma, type_, first, n) };
376 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
377 should_free_on_drop: true };
378 let err = isl_rs_ctx.last_error();
379 if err != Error::None_ {
380 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
381 }
382 Ok(isl_rs_result)
383 }
384
385 pub fn drop_unused_params(self) -> Result<UnionPwMultiAff, LibISLError> {
387 let upma = self;
388 let isl_rs_ctx = upma.get_ctx();
389 let mut upma = upma;
390 upma.do_not_free_on_drop();
391 let upma = upma.ptr;
392 let isl_rs_result = unsafe { isl_union_pw_multi_aff_drop_unused_params(upma) };
393 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
394 should_free_on_drop: true };
395 let err = isl_rs_ctx.last_error();
396 if err != Error::None_ {
397 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
398 }
399 Ok(isl_rs_result)
400 }
401
402 pub fn dump(&self) -> Result<(), LibISLError> {
404 let upma = self;
405 let isl_rs_ctx = upma.get_ctx();
406 let upma = upma.ptr;
407 let isl_rs_result = unsafe { isl_union_pw_multi_aff_dump(upma) };
408 let err = isl_rs_ctx.last_error();
409 if err != Error::None_ {
410 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
411 }
412 Ok(isl_rs_result)
413 }
414
415 pub fn empty(space: Space) -> Result<UnionPwMultiAff, LibISLError> {
417 let isl_rs_ctx = space.get_ctx();
418 let mut space = space;
419 space.do_not_free_on_drop();
420 let space = space.ptr;
421 let isl_rs_result = unsafe { isl_union_pw_multi_aff_empty(space) };
422 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
423 should_free_on_drop: true };
424 let err = isl_rs_ctx.last_error();
425 if err != Error::None_ {
426 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
427 }
428 Ok(isl_rs_result)
429 }
430
431 pub fn empty_ctx(ctx: &Context) -> Result<UnionPwMultiAff, LibISLError> {
433 let isl_rs_ctx = Context { ptr: ctx.ptr,
434 should_free_on_drop: false };
435 let ctx = ctx.ptr;
436 let isl_rs_result = unsafe { isl_union_pw_multi_aff_empty_ctx(ctx) };
437 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
438 should_free_on_drop: true };
439 let err = isl_rs_ctx.last_error();
440 if err != Error::None_ {
441 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
442 }
443 Ok(isl_rs_result)
444 }
445
446 pub fn empty_space(space: Space) -> Result<UnionPwMultiAff, LibISLError> {
448 let isl_rs_ctx = space.get_ctx();
449 let mut space = space;
450 space.do_not_free_on_drop();
451 let space = space.ptr;
452 let isl_rs_result = unsafe { isl_union_pw_multi_aff_empty_space(space) };
453 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
454 should_free_on_drop: true };
455 let err = isl_rs_ctx.last_error();
456 if err != Error::None_ {
457 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
458 }
459 Ok(isl_rs_result)
460 }
461
462 pub fn extract_pw_multi_aff(&self, space: Space) -> Result<PwMultiAff, LibISLError> {
464 let upma = self;
465 let isl_rs_ctx = upma.get_ctx();
466 let upma = upma.ptr;
467 let mut space = space;
468 space.do_not_free_on_drop();
469 let space = space.ptr;
470 let isl_rs_result = unsafe { isl_union_pw_multi_aff_extract_pw_multi_aff(upma, space) };
471 let isl_rs_result = PwMultiAff { ptr: isl_rs_result,
472 should_free_on_drop: true };
473 let err = isl_rs_ctx.last_error();
474 if err != Error::None_ {
475 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
476 }
477 Ok(isl_rs_result)
478 }
479
480 pub fn find_dim_by_name(&self, type_: DimType, name: &str) -> Result<i32, LibISLError> {
482 let upma = self;
483 let isl_rs_ctx = upma.get_ctx();
484 let upma = upma.ptr;
485 let type_ = type_.to_i32();
486 let name = CString::new(name).unwrap();
487 let name = name.as_ptr();
488 let isl_rs_result = unsafe { isl_union_pw_multi_aff_find_dim_by_name(upma, type_, name) };
489 let err = isl_rs_ctx.last_error();
490 if err != Error::None_ {
491 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
492 }
493 Ok(isl_rs_result)
494 }
495
496 pub fn flat_range_product(self, upma2: UnionPwMultiAff)
498 -> Result<UnionPwMultiAff, LibISLError> {
499 let upma1 = self;
500 let isl_rs_ctx = upma1.get_ctx();
501 let mut upma1 = upma1;
502 upma1.do_not_free_on_drop();
503 let upma1 = upma1.ptr;
504 let mut upma2 = upma2;
505 upma2.do_not_free_on_drop();
506 let upma2 = upma2.ptr;
507 let isl_rs_result = unsafe { isl_union_pw_multi_aff_flat_range_product(upma1, upma2) };
508 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
509 should_free_on_drop: true };
510 let err = isl_rs_ctx.last_error();
511 if err != Error::None_ {
512 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
513 }
514 Ok(isl_rs_result)
515 }
516
517 pub fn free(self) -> Result<UnionPwMultiAff, LibISLError> {
519 let upma = self;
520 let isl_rs_ctx = upma.get_ctx();
521 let mut upma = upma;
522 upma.do_not_free_on_drop();
523 let upma = upma.ptr;
524 let isl_rs_result = unsafe { isl_union_pw_multi_aff_free(upma) };
525 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
526 should_free_on_drop: true };
527 let err = isl_rs_ctx.last_error();
528 if err != Error::None_ {
529 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
530 }
531 Ok(isl_rs_result)
532 }
533
534 pub fn from_aff(aff: Aff) -> Result<UnionPwMultiAff, LibISLError> {
536 let isl_rs_ctx = aff.get_ctx();
537 let mut aff = aff;
538 aff.do_not_free_on_drop();
539 let aff = aff.ptr;
540 let isl_rs_result = unsafe { isl_union_pw_multi_aff_from_aff(aff) };
541 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
542 should_free_on_drop: true };
543 let err = isl_rs_ctx.last_error();
544 if err != Error::None_ {
545 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
546 }
547 Ok(isl_rs_result)
548 }
549
550 pub fn from_domain(uset: UnionSet) -> Result<UnionPwMultiAff, LibISLError> {
552 let isl_rs_ctx = uset.get_ctx();
553 let mut uset = uset;
554 uset.do_not_free_on_drop();
555 let uset = uset.ptr;
556 let isl_rs_result = unsafe { isl_union_pw_multi_aff_from_domain(uset) };
557 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
558 should_free_on_drop: true };
559 let err = isl_rs_ctx.last_error();
560 if err != Error::None_ {
561 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
562 }
563 Ok(isl_rs_result)
564 }
565
566 pub fn from_multi_aff(ma: MultiAff) -> Result<UnionPwMultiAff, LibISLError> {
568 let isl_rs_ctx = ma.get_ctx();
569 let mut ma = ma;
570 ma.do_not_free_on_drop();
571 let ma = ma.ptr;
572 let isl_rs_result = unsafe { isl_union_pw_multi_aff_from_multi_aff(ma) };
573 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
574 should_free_on_drop: true };
575 let err = isl_rs_ctx.last_error();
576 if err != Error::None_ {
577 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
578 }
579 Ok(isl_rs_result)
580 }
581
582 pub fn from_multi_union_pw_aff(mupa: MultiUnionPwAff) -> Result<UnionPwMultiAff, LibISLError> {
584 let isl_rs_ctx = mupa.get_ctx();
585 let mut mupa = mupa;
586 mupa.do_not_free_on_drop();
587 let mupa = mupa.ptr;
588 let isl_rs_result = unsafe { isl_union_pw_multi_aff_from_multi_union_pw_aff(mupa) };
589 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
590 should_free_on_drop: true };
591 let err = isl_rs_ctx.last_error();
592 if err != Error::None_ {
593 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
594 }
595 Ok(isl_rs_result)
596 }
597
598 pub fn from_pw_multi_aff(pma: PwMultiAff) -> Result<UnionPwMultiAff, LibISLError> {
600 let isl_rs_ctx = pma.get_ctx();
601 let mut pma = pma;
602 pma.do_not_free_on_drop();
603 let pma = pma.ptr;
604 let isl_rs_result = unsafe { isl_union_pw_multi_aff_from_pw_multi_aff(pma) };
605 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
606 should_free_on_drop: true };
607 let err = isl_rs_ctx.last_error();
608 if err != Error::None_ {
609 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
610 }
611 Ok(isl_rs_result)
612 }
613
614 pub fn from_union_map(umap: UnionMap) -> Result<UnionPwMultiAff, LibISLError> {
616 let isl_rs_ctx = umap.get_ctx();
617 let mut umap = umap;
618 umap.do_not_free_on_drop();
619 let umap = umap.ptr;
620 let isl_rs_result = unsafe { isl_union_pw_multi_aff_from_union_map(umap) };
621 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
622 should_free_on_drop: true };
623 let err = isl_rs_ctx.last_error();
624 if err != Error::None_ {
625 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
626 }
627 Ok(isl_rs_result)
628 }
629
630 pub fn from_union_pw_aff(upa: UnionPwAff) -> Result<UnionPwMultiAff, LibISLError> {
632 let isl_rs_ctx = upa.get_ctx();
633 let mut upa = upa;
634 upa.do_not_free_on_drop();
635 let upa = upa.ptr;
636 let isl_rs_result = unsafe { isl_union_pw_multi_aff_from_union_pw_aff(upa) };
637 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
638 should_free_on_drop: true };
639 let err = isl_rs_ctx.last_error();
640 if err != Error::None_ {
641 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
642 }
643 Ok(isl_rs_result)
644 }
645
646 pub fn from_union_set(uset: UnionSet) -> Result<UnionPwMultiAff, LibISLError> {
648 let isl_rs_ctx = uset.get_ctx();
649 let mut uset = uset;
650 uset.do_not_free_on_drop();
651 let uset = uset.ptr;
652 let isl_rs_result = unsafe { isl_union_pw_multi_aff_from_union_set(uset) };
653 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
654 should_free_on_drop: true };
655 let err = isl_rs_ctx.last_error();
656 if err != Error::None_ {
657 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
658 }
659 Ok(isl_rs_result)
660 }
661
662 pub fn get_ctx(&self) -> Context {
664 let upma = self;
665 let upma = upma.ptr;
666 let isl_rs_result = unsafe { isl_union_pw_multi_aff_get_ctx(upma) };
667 let isl_rs_result = Context { ptr: isl_rs_result,
668 should_free_on_drop: false };
669 isl_rs_result
670 }
671
672 pub fn get_pw_multi_aff_list(&self) -> Result<PwMultiAffList, LibISLError> {
674 let upma = self;
675 let isl_rs_ctx = upma.get_ctx();
676 let upma = upma.ptr;
677 let isl_rs_result = unsafe { isl_union_pw_multi_aff_get_pw_multi_aff_list(upma) };
678 let isl_rs_result = PwMultiAffList { ptr: isl_rs_result,
679 should_free_on_drop: true };
680 let err = isl_rs_ctx.last_error();
681 if err != Error::None_ {
682 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
683 }
684 Ok(isl_rs_result)
685 }
686
687 pub fn get_space(&self) -> Result<Space, LibISLError> {
689 let upma = self;
690 let isl_rs_ctx = upma.get_ctx();
691 let upma = upma.ptr;
692 let isl_rs_result = unsafe { isl_union_pw_multi_aff_get_space(upma) };
693 let isl_rs_result = Space { ptr: isl_rs_result,
694 should_free_on_drop: true };
695 let err = isl_rs_ctx.last_error();
696 if err != Error::None_ {
697 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
698 }
699 Ok(isl_rs_result)
700 }
701
702 pub fn get_union_pw_aff(&self, pos: i32) -> Result<UnionPwAff, LibISLError> {
704 let upma = self;
705 let isl_rs_ctx = upma.get_ctx();
706 let upma = upma.ptr;
707 let isl_rs_result = unsafe { isl_union_pw_multi_aff_get_union_pw_aff(upma, pos) };
708 let isl_rs_result = UnionPwAff { ptr: isl_rs_result,
709 should_free_on_drop: true };
710 let err = isl_rs_ctx.last_error();
711 if err != Error::None_ {
712 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
713 }
714 Ok(isl_rs_result)
715 }
716
717 pub fn gist(self, context: UnionSet) -> Result<UnionPwMultiAff, LibISLError> {
719 let upma = self;
720 let isl_rs_ctx = upma.get_ctx();
721 let mut upma = upma;
722 upma.do_not_free_on_drop();
723 let upma = upma.ptr;
724 let mut context = context;
725 context.do_not_free_on_drop();
726 let context = context.ptr;
727 let isl_rs_result = unsafe { isl_union_pw_multi_aff_gist(upma, context) };
728 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
729 should_free_on_drop: true };
730 let err = isl_rs_ctx.last_error();
731 if err != Error::None_ {
732 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
733 }
734 Ok(isl_rs_result)
735 }
736
737 pub fn gist_params(self, context: Set) -> Result<UnionPwMultiAff, LibISLError> {
739 let upma = self;
740 let isl_rs_ctx = upma.get_ctx();
741 let mut upma = upma;
742 upma.do_not_free_on_drop();
743 let upma = upma.ptr;
744 let mut context = context;
745 context.do_not_free_on_drop();
746 let context = context.ptr;
747 let isl_rs_result = unsafe { isl_union_pw_multi_aff_gist_params(upma, context) };
748 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
749 should_free_on_drop: true };
750 let err = isl_rs_ctx.last_error();
751 if err != Error::None_ {
752 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
753 }
754 Ok(isl_rs_result)
755 }
756
757 pub fn intersect_domain(self, uset: UnionSet) -> Result<UnionPwMultiAff, LibISLError> {
759 let upma = self;
760 let isl_rs_ctx = upma.get_ctx();
761 let mut upma = upma;
762 upma.do_not_free_on_drop();
763 let upma = upma.ptr;
764 let mut uset = uset;
765 uset.do_not_free_on_drop();
766 let uset = uset.ptr;
767 let isl_rs_result = unsafe { isl_union_pw_multi_aff_intersect_domain(upma, uset) };
768 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
769 should_free_on_drop: true };
770 let err = isl_rs_ctx.last_error();
771 if err != Error::None_ {
772 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
773 }
774 Ok(isl_rs_result)
775 }
776
777 pub fn intersect_domain_space(self, space: Space) -> Result<UnionPwMultiAff, LibISLError> {
779 let upma = self;
780 let isl_rs_ctx = upma.get_ctx();
781 let mut upma = upma;
782 upma.do_not_free_on_drop();
783 let upma = upma.ptr;
784 let mut space = space;
785 space.do_not_free_on_drop();
786 let space = space.ptr;
787 let isl_rs_result = unsafe { isl_union_pw_multi_aff_intersect_domain_space(upma, space) };
788 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
789 should_free_on_drop: true };
790 let err = isl_rs_ctx.last_error();
791 if err != Error::None_ {
792 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
793 }
794 Ok(isl_rs_result)
795 }
796
797 pub fn intersect_domain_union_set(self, uset: UnionSet)
799 -> Result<UnionPwMultiAff, LibISLError> {
800 let upma = self;
801 let isl_rs_ctx = upma.get_ctx();
802 let mut upma = upma;
803 upma.do_not_free_on_drop();
804 let upma = upma.ptr;
805 let mut uset = uset;
806 uset.do_not_free_on_drop();
807 let uset = uset.ptr;
808 let isl_rs_result =
809 unsafe { isl_union_pw_multi_aff_intersect_domain_union_set(upma, uset) };
810 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
811 should_free_on_drop: true };
812 let err = isl_rs_ctx.last_error();
813 if err != Error::None_ {
814 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
815 }
816 Ok(isl_rs_result)
817 }
818
819 pub fn intersect_domain_wrapped_domain(self, uset: UnionSet)
821 -> Result<UnionPwMultiAff, LibISLError> {
822 let upma = self;
823 let isl_rs_ctx = upma.get_ctx();
824 let mut upma = upma;
825 upma.do_not_free_on_drop();
826 let upma = upma.ptr;
827 let mut uset = uset;
828 uset.do_not_free_on_drop();
829 let uset = uset.ptr;
830 let isl_rs_result =
831 unsafe { isl_union_pw_multi_aff_intersect_domain_wrapped_domain(upma, uset) };
832 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
833 should_free_on_drop: true };
834 let err = isl_rs_ctx.last_error();
835 if err != Error::None_ {
836 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
837 }
838 Ok(isl_rs_result)
839 }
840
841 pub fn intersect_domain_wrapped_range(self, uset: UnionSet)
843 -> Result<UnionPwMultiAff, LibISLError> {
844 let upma = self;
845 let isl_rs_ctx = upma.get_ctx();
846 let mut upma = upma;
847 upma.do_not_free_on_drop();
848 let upma = upma.ptr;
849 let mut uset = uset;
850 uset.do_not_free_on_drop();
851 let uset = uset.ptr;
852 let isl_rs_result =
853 unsafe { isl_union_pw_multi_aff_intersect_domain_wrapped_range(upma, uset) };
854 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
855 should_free_on_drop: true };
856 let err = isl_rs_ctx.last_error();
857 if err != Error::None_ {
858 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
859 }
860 Ok(isl_rs_result)
861 }
862
863 pub fn intersect_params(self, set: Set) -> Result<UnionPwMultiAff, LibISLError> {
865 let upma = self;
866 let isl_rs_ctx = upma.get_ctx();
867 let mut upma = upma;
868 upma.do_not_free_on_drop();
869 let upma = upma.ptr;
870 let mut set = set;
871 set.do_not_free_on_drop();
872 let set = set.ptr;
873 let isl_rs_result = unsafe { isl_union_pw_multi_aff_intersect_params(upma, set) };
874 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
875 should_free_on_drop: true };
876 let err = isl_rs_ctx.last_error();
877 if err != Error::None_ {
878 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
879 }
880 Ok(isl_rs_result)
881 }
882
883 pub fn involves_locals(&self) -> Result<bool, LibISLError> {
885 let upma = self;
886 let isl_rs_ctx = upma.get_ctx();
887 let upma = upma.ptr;
888 let isl_rs_result = unsafe { isl_union_pw_multi_aff_involves_locals(upma) };
889 let isl_rs_result = match isl_rs_result {
890 0 => false,
891 1 => true,
892 _ => panic!("Got isl_bool = -1"),
893 };
894 let err = isl_rs_ctx.last_error();
895 if err != Error::None_ {
896 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
897 }
898 Ok(isl_rs_result)
899 }
900
901 pub fn involves_nan(&self) -> Result<bool, LibISLError> {
903 let upma = self;
904 let isl_rs_ctx = upma.get_ctx();
905 let upma = upma.ptr;
906 let isl_rs_result = unsafe { isl_union_pw_multi_aff_involves_nan(upma) };
907 let isl_rs_result = match isl_rs_result {
908 0 => false,
909 1 => true,
910 _ => panic!("Got isl_bool = -1"),
911 };
912 let err = isl_rs_ctx.last_error();
913 if err != Error::None_ {
914 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
915 }
916 Ok(isl_rs_result)
917 }
918
919 pub fn isa_pw_multi_aff(&self) -> Result<bool, LibISLError> {
921 let upma = self;
922 let isl_rs_ctx = upma.get_ctx();
923 let upma = upma.ptr;
924 let isl_rs_result = unsafe { isl_union_pw_multi_aff_isa_pw_multi_aff(upma) };
925 let isl_rs_result = match isl_rs_result {
926 0 => false,
927 1 => true,
928 _ => panic!("Got isl_bool = -1"),
929 };
930 let err = isl_rs_ctx.last_error();
931 if err != Error::None_ {
932 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
933 }
934 Ok(isl_rs_result)
935 }
936
937 pub fn multi_val_on_domain(domain: UnionSet, mv: MultiVal)
939 -> Result<UnionPwMultiAff, LibISLError> {
940 let isl_rs_ctx = domain.get_ctx();
941 let mut domain = domain;
942 domain.do_not_free_on_drop();
943 let domain = domain.ptr;
944 let mut mv = mv;
945 mv.do_not_free_on_drop();
946 let mv = mv.ptr;
947 let isl_rs_result = unsafe { isl_union_pw_multi_aff_multi_val_on_domain(domain, mv) };
948 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
949 should_free_on_drop: true };
950 let err = isl_rs_ctx.last_error();
951 if err != Error::None_ {
952 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
953 }
954 Ok(isl_rs_result)
955 }
956
957 pub fn n_pw_multi_aff(&self) -> Result<i32, LibISLError> {
959 let upma = self;
960 let isl_rs_ctx = upma.get_ctx();
961 let upma = upma.ptr;
962 let isl_rs_result = unsafe { isl_union_pw_multi_aff_n_pw_multi_aff(upma) };
963 let err = isl_rs_ctx.last_error();
964 if err != Error::None_ {
965 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
966 }
967 Ok(isl_rs_result)
968 }
969
970 pub fn neg(self) -> Result<UnionPwMultiAff, LibISLError> {
972 let upma = self;
973 let isl_rs_ctx = upma.get_ctx();
974 let mut upma = upma;
975 upma.do_not_free_on_drop();
976 let upma = upma.ptr;
977 let isl_rs_result = unsafe { isl_union_pw_multi_aff_neg(upma) };
978 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
979 should_free_on_drop: true };
980 let err = isl_rs_ctx.last_error();
981 if err != Error::None_ {
982 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
983 }
984 Ok(isl_rs_result)
985 }
986
987 pub fn plain_is_empty(&self) -> Result<bool, LibISLError> {
989 let upma = self;
990 let isl_rs_ctx = upma.get_ctx();
991 let upma = upma.ptr;
992 let isl_rs_result = unsafe { isl_union_pw_multi_aff_plain_is_empty(upma) };
993 let isl_rs_result = match isl_rs_result {
994 0 => false,
995 1 => true,
996 _ => panic!("Got isl_bool = -1"),
997 };
998 let err = isl_rs_ctx.last_error();
999 if err != Error::None_ {
1000 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1001 }
1002 Ok(isl_rs_result)
1003 }
1004
1005 pub fn plain_is_equal(&self, upma2: &UnionPwMultiAff) -> Result<bool, LibISLError> {
1007 let upma1 = self;
1008 let isl_rs_ctx = upma1.get_ctx();
1009 let upma1 = upma1.ptr;
1010 let upma2 = upma2.ptr;
1011 let isl_rs_result = unsafe { isl_union_pw_multi_aff_plain_is_equal(upma1, upma2) };
1012 let isl_rs_result = match isl_rs_result {
1013 0 => false,
1014 1 => true,
1015 _ => panic!("Got isl_bool = -1"),
1016 };
1017 let err = isl_rs_ctx.last_error();
1018 if err != Error::None_ {
1019 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1020 }
1021 Ok(isl_rs_result)
1022 }
1023
1024 pub fn preimage_domain_wrapped_domain_union_pw_multi_aff(
1026 self, upma2: UnionPwMultiAff)
1027 -> Result<UnionPwMultiAff, LibISLError> {
1028 let upma1 = self;
1029 let isl_rs_ctx = upma1.get_ctx();
1030 let mut upma1 = upma1;
1031 upma1.do_not_free_on_drop();
1032 let upma1 = upma1.ptr;
1033 let mut upma2 = upma2;
1034 upma2.do_not_free_on_drop();
1035 let upma2 = upma2.ptr;
1036 let isl_rs_result = unsafe {
1037 isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff(upma1, upma2)
1038 };
1039 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
1040 should_free_on_drop: true };
1041 let err = isl_rs_ctx.last_error();
1042 if err != Error::None_ {
1043 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1044 }
1045 Ok(isl_rs_result)
1046 }
1047
1048 pub fn pullback_union_pw_multi_aff(self, upma2: UnionPwMultiAff)
1050 -> Result<UnionPwMultiAff, LibISLError> {
1051 let upma1 = self;
1052 let isl_rs_ctx = upma1.get_ctx();
1053 let mut upma1 = upma1;
1054 upma1.do_not_free_on_drop();
1055 let upma1 = upma1.ptr;
1056 let mut upma2 = upma2;
1057 upma2.do_not_free_on_drop();
1058 let upma2 = upma2.ptr;
1059 let isl_rs_result =
1060 unsafe { isl_union_pw_multi_aff_pullback_union_pw_multi_aff(upma1, upma2) };
1061 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
1062 should_free_on_drop: true };
1063 let err = isl_rs_ctx.last_error();
1064 if err != Error::None_ {
1065 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1066 }
1067 Ok(isl_rs_result)
1068 }
1069
1070 pub fn range_factor_domain(self) -> Result<UnionPwMultiAff, LibISLError> {
1072 let upma = self;
1073 let isl_rs_ctx = upma.get_ctx();
1074 let mut upma = upma;
1075 upma.do_not_free_on_drop();
1076 let upma = upma.ptr;
1077 let isl_rs_result = unsafe { isl_union_pw_multi_aff_range_factor_domain(upma) };
1078 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
1079 should_free_on_drop: true };
1080 let err = isl_rs_ctx.last_error();
1081 if err != Error::None_ {
1082 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1083 }
1084 Ok(isl_rs_result)
1085 }
1086
1087 pub fn range_factor_range(self) -> Result<UnionPwMultiAff, LibISLError> {
1089 let upma = self;
1090 let isl_rs_ctx = upma.get_ctx();
1091 let mut upma = upma;
1092 upma.do_not_free_on_drop();
1093 let upma = upma.ptr;
1094 let isl_rs_result = unsafe { isl_union_pw_multi_aff_range_factor_range(upma) };
1095 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
1096 should_free_on_drop: true };
1097 let err = isl_rs_ctx.last_error();
1098 if err != Error::None_ {
1099 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1100 }
1101 Ok(isl_rs_result)
1102 }
1103
1104 pub fn range_product(self, upma2: UnionPwMultiAff) -> Result<UnionPwMultiAff, LibISLError> {
1106 let upma1 = self;
1107 let isl_rs_ctx = upma1.get_ctx();
1108 let mut upma1 = upma1;
1109 upma1.do_not_free_on_drop();
1110 let upma1 = upma1.ptr;
1111 let mut upma2 = upma2;
1112 upma2.do_not_free_on_drop();
1113 let upma2 = upma2.ptr;
1114 let isl_rs_result = unsafe { isl_union_pw_multi_aff_range_product(upma1, upma2) };
1115 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
1116 should_free_on_drop: true };
1117 let err = isl_rs_ctx.last_error();
1118 if err != Error::None_ {
1119 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1120 }
1121 Ok(isl_rs_result)
1122 }
1123
1124 pub fn read_from_str(ctx: &Context, str_: &str) -> Result<UnionPwMultiAff, LibISLError> {
1126 let isl_rs_ctx = Context { ptr: ctx.ptr,
1127 should_free_on_drop: false };
1128 let ctx = ctx.ptr;
1129 let str_ = CString::new(str_).unwrap();
1130 let str_ = str_.as_ptr();
1131 let isl_rs_result = unsafe { isl_union_pw_multi_aff_read_from_str(ctx, str_) };
1132 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
1133 should_free_on_drop: true };
1134 let err = isl_rs_ctx.last_error();
1135 if err != Error::None_ {
1136 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1137 }
1138 Ok(isl_rs_result)
1139 }
1140
1141 pub fn reset_user(self) -> Result<UnionPwMultiAff, LibISLError> {
1143 let upma = self;
1144 let isl_rs_ctx = upma.get_ctx();
1145 let mut upma = upma;
1146 upma.do_not_free_on_drop();
1147 let upma = upma.ptr;
1148 let isl_rs_result = unsafe { isl_union_pw_multi_aff_reset_user(upma) };
1149 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
1150 should_free_on_drop: true };
1151 let err = isl_rs_ctx.last_error();
1152 if err != Error::None_ {
1153 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1154 }
1155 Ok(isl_rs_result)
1156 }
1157
1158 pub fn scale_down_val(self, val: Val) -> Result<UnionPwMultiAff, LibISLError> {
1160 let upma = self;
1161 let isl_rs_ctx = upma.get_ctx();
1162 let mut upma = upma;
1163 upma.do_not_free_on_drop();
1164 let upma = upma.ptr;
1165 let mut val = val;
1166 val.do_not_free_on_drop();
1167 let val = val.ptr;
1168 let isl_rs_result = unsafe { isl_union_pw_multi_aff_scale_down_val(upma, val) };
1169 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
1170 should_free_on_drop: true };
1171 let err = isl_rs_ctx.last_error();
1172 if err != Error::None_ {
1173 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1174 }
1175 Ok(isl_rs_result)
1176 }
1177
1178 pub fn scale_multi_val(self, mv: MultiVal) -> Result<UnionPwMultiAff, LibISLError> {
1180 let upma = self;
1181 let isl_rs_ctx = upma.get_ctx();
1182 let mut upma = upma;
1183 upma.do_not_free_on_drop();
1184 let upma = upma.ptr;
1185 let mut mv = mv;
1186 mv.do_not_free_on_drop();
1187 let mv = mv.ptr;
1188 let isl_rs_result = unsafe { isl_union_pw_multi_aff_scale_multi_val(upma, mv) };
1189 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
1190 should_free_on_drop: true };
1191 let err = isl_rs_ctx.last_error();
1192 if err != Error::None_ {
1193 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1194 }
1195 Ok(isl_rs_result)
1196 }
1197
1198 pub fn scale_val(self, val: Val) -> Result<UnionPwMultiAff, LibISLError> {
1200 let upma = self;
1201 let isl_rs_ctx = upma.get_ctx();
1202 let mut upma = upma;
1203 upma.do_not_free_on_drop();
1204 let upma = upma.ptr;
1205 let mut val = val;
1206 val.do_not_free_on_drop();
1207 let val = val.ptr;
1208 let isl_rs_result = unsafe { isl_union_pw_multi_aff_scale_val(upma, val) };
1209 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
1210 should_free_on_drop: true };
1211 let err = isl_rs_ctx.last_error();
1212 if err != Error::None_ {
1213 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1214 }
1215 Ok(isl_rs_result)
1216 }
1217
1218 pub fn set_dim_name(self, type_: DimType, pos: u32, s: &str)
1220 -> Result<UnionPwMultiAff, LibISLError> {
1221 let upma = self;
1222 let isl_rs_ctx = upma.get_ctx();
1223 let mut upma = upma;
1224 upma.do_not_free_on_drop();
1225 let upma = upma.ptr;
1226 let type_ = type_.to_i32();
1227 let s = CString::new(s).unwrap();
1228 let s = s.as_ptr();
1229 let isl_rs_result = unsafe { isl_union_pw_multi_aff_set_dim_name(upma, type_, pos, s) };
1230 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
1231 should_free_on_drop: true };
1232 let err = isl_rs_ctx.last_error();
1233 if err != Error::None_ {
1234 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1235 }
1236 Ok(isl_rs_result)
1237 }
1238
1239 pub fn sub(self, upma2: UnionPwMultiAff) -> Result<UnionPwMultiAff, LibISLError> {
1241 let upma1 = self;
1242 let isl_rs_ctx = upma1.get_ctx();
1243 let mut upma1 = upma1;
1244 upma1.do_not_free_on_drop();
1245 let upma1 = upma1.ptr;
1246 let mut upma2 = upma2;
1247 upma2.do_not_free_on_drop();
1248 let upma2 = upma2.ptr;
1249 let isl_rs_result = unsafe { isl_union_pw_multi_aff_sub(upma1, upma2) };
1250 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
1251 should_free_on_drop: true };
1252 let err = isl_rs_ctx.last_error();
1253 if err != Error::None_ {
1254 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1255 }
1256 Ok(isl_rs_result)
1257 }
1258
1259 pub fn subtract_domain(self, uset: UnionSet) -> Result<UnionPwMultiAff, LibISLError> {
1261 let upma = self;
1262 let isl_rs_ctx = upma.get_ctx();
1263 let mut upma = upma;
1264 upma.do_not_free_on_drop();
1265 let upma = upma.ptr;
1266 let mut uset = uset;
1267 uset.do_not_free_on_drop();
1268 let uset = uset.ptr;
1269 let isl_rs_result = unsafe { isl_union_pw_multi_aff_subtract_domain(upma, uset) };
1270 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
1271 should_free_on_drop: true };
1272 let err = isl_rs_ctx.last_error();
1273 if err != Error::None_ {
1274 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1275 }
1276 Ok(isl_rs_result)
1277 }
1278
1279 pub fn subtract_domain_space(self, space: Space) -> Result<UnionPwMultiAff, LibISLError> {
1281 let upma = self;
1282 let isl_rs_ctx = upma.get_ctx();
1283 let mut upma = upma;
1284 upma.do_not_free_on_drop();
1285 let upma = upma.ptr;
1286 let mut space = space;
1287 space.do_not_free_on_drop();
1288 let space = space.ptr;
1289 let isl_rs_result = unsafe { isl_union_pw_multi_aff_subtract_domain_space(upma, space) };
1290 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
1291 should_free_on_drop: true };
1292 let err = isl_rs_ctx.last_error();
1293 if err != Error::None_ {
1294 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1295 }
1296 Ok(isl_rs_result)
1297 }
1298
1299 pub fn subtract_domain_union_set(self, uset: UnionSet) -> Result<UnionPwMultiAff, LibISLError> {
1301 let upma = self;
1302 let isl_rs_ctx = upma.get_ctx();
1303 let mut upma = upma;
1304 upma.do_not_free_on_drop();
1305 let upma = upma.ptr;
1306 let mut uset = uset;
1307 uset.do_not_free_on_drop();
1308 let uset = uset.ptr;
1309 let isl_rs_result = unsafe { isl_union_pw_multi_aff_subtract_domain_union_set(upma, uset) };
1310 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
1311 should_free_on_drop: true };
1312 let err = isl_rs_ctx.last_error();
1313 if err != Error::None_ {
1314 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1315 }
1316 Ok(isl_rs_result)
1317 }
1318
1319 pub fn to_list(self) -> Result<UnionPwMultiAffList, LibISLError> {
1321 let el = self;
1322 let isl_rs_ctx = el.get_ctx();
1323 let mut el = el;
1324 el.do_not_free_on_drop();
1325 let el = el.ptr;
1326 let isl_rs_result = unsafe { isl_union_pw_multi_aff_to_list(el) };
1327 let isl_rs_result = UnionPwMultiAffList { ptr: isl_rs_result,
1328 should_free_on_drop: true };
1329 let err = isl_rs_ctx.last_error();
1330 if err != Error::None_ {
1331 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1332 }
1333 Ok(isl_rs_result)
1334 }
1335
1336 pub fn to_str(&self) -> Result<&str, LibISLError> {
1338 let upma = self;
1339 let isl_rs_ctx = upma.get_ctx();
1340 let upma = upma.ptr;
1341 let isl_rs_result = unsafe { isl_union_pw_multi_aff_to_str(upma) };
1342 let isl_rs_result = unsafe { CStr::from_ptr(isl_rs_result) };
1343 let isl_rs_result = isl_rs_result.to_str().unwrap();
1344 let err = isl_rs_ctx.last_error();
1345 if err != Error::None_ {
1346 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1347 }
1348 Ok(isl_rs_result)
1349 }
1350
1351 pub fn union_add(self, upma2: UnionPwMultiAff) -> Result<UnionPwMultiAff, LibISLError> {
1353 let upma1 = self;
1354 let isl_rs_ctx = upma1.get_ctx();
1355 let mut upma1 = upma1;
1356 upma1.do_not_free_on_drop();
1357 let upma1 = upma1.ptr;
1358 let mut upma2 = upma2;
1359 upma2.do_not_free_on_drop();
1360 let upma2 = upma2.ptr;
1361 let isl_rs_result = unsafe { isl_union_pw_multi_aff_union_add(upma1, upma2) };
1362 let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
1363 should_free_on_drop: true };
1364 let err = isl_rs_ctx.last_error();
1365 if err != Error::None_ {
1366 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1367 }
1368 Ok(isl_rs_result)
1369 }
1370
1371 pub fn do_not_free_on_drop(&mut self) {
1374 self.should_free_on_drop = false;
1375 }
1376}
1377
1378impl Drop for UnionPwMultiAff {
1379 fn drop(&mut self) {
1380 if self.should_free_on_drop {
1381 unsafe {
1382 isl_union_pw_multi_aff_free(self.ptr);
1383 }
1384 }
1385 }
1386}