isl_rs/bindings/
qpolynomial.rs

1// Automatically generated by isl_bindings_generator.
2// LICENSE: MIT
3
4use super::{
5    Aff, Constraint, Context, DimType, Error, LibISLError, Point, QPolynomialList, Set, Space,
6    Term, Val,
7};
8use libc::uintptr_t;
9use std::ffi::CString;
10use std::os::raw::c_char;
11
12/// Wraps `isl_qpolynomial`.
13pub struct QPolynomial {
14    pub ptr: uintptr_t,
15    pub should_free_on_drop: bool,
16}
17
18extern "C" {
19
20    fn isl_qpolynomial_add(qp1: uintptr_t, qp2: uintptr_t) -> uintptr_t;
21
22    fn isl_qpolynomial_add_dims(qp: uintptr_t, type_: i32, n: u32) -> uintptr_t;
23
24    fn isl_qpolynomial_align_params(qp: uintptr_t, model: uintptr_t) -> uintptr_t;
25
26    fn isl_qpolynomial_as_aff(qp: uintptr_t) -> uintptr_t;
27
28    fn isl_qpolynomial_copy(qp: uintptr_t) -> uintptr_t;
29
30    fn isl_qpolynomial_dim(qp: uintptr_t, type_: i32) -> i32;
31
32    fn isl_qpolynomial_domain_reverse(qp: uintptr_t) -> uintptr_t;
33
34    fn isl_qpolynomial_drop_dims(qp: uintptr_t, type_: i32, first: u32, n: u32) -> uintptr_t;
35
36    fn isl_qpolynomial_dump(qp: uintptr_t) -> ();
37
38    fn isl_qpolynomial_eval(qp: uintptr_t, pnt: uintptr_t) -> uintptr_t;
39
40    fn isl_qpolynomial_free(qp: uintptr_t) -> uintptr_t;
41
42    fn isl_qpolynomial_from_aff(aff: uintptr_t) -> uintptr_t;
43
44    fn isl_qpolynomial_from_constraint(c: uintptr_t, type_: i32, pos: u32) -> uintptr_t;
45
46    fn isl_qpolynomial_from_term(term: uintptr_t) -> uintptr_t;
47
48    fn isl_qpolynomial_get_constant_val(qp: uintptr_t) -> uintptr_t;
49
50    fn isl_qpolynomial_get_ctx(qp: uintptr_t) -> uintptr_t;
51
52    fn isl_qpolynomial_get_domain_space(qp: uintptr_t) -> uintptr_t;
53
54    fn isl_qpolynomial_get_space(qp: uintptr_t) -> uintptr_t;
55
56    fn isl_qpolynomial_gist(qp: uintptr_t, context: uintptr_t) -> uintptr_t;
57
58    fn isl_qpolynomial_gist_params(qp: uintptr_t, context: uintptr_t) -> uintptr_t;
59
60    fn isl_qpolynomial_homogenize(poly: uintptr_t) -> uintptr_t;
61
62    fn isl_qpolynomial_infty_on_domain(domain: uintptr_t) -> uintptr_t;
63
64    fn isl_qpolynomial_insert_dims(qp: uintptr_t, type_: i32, first: u32, n: u32) -> uintptr_t;
65
66    fn isl_qpolynomial_involves_dims(qp: uintptr_t, type_: i32, first: u32, n: u32) -> i32;
67
68    fn isl_qpolynomial_is_infty(qp: uintptr_t) -> i32;
69
70    fn isl_qpolynomial_is_nan(qp: uintptr_t) -> i32;
71
72    fn isl_qpolynomial_is_neginfty(qp: uintptr_t) -> i32;
73
74    fn isl_qpolynomial_is_zero(qp: uintptr_t) -> i32;
75
76    fn isl_qpolynomial_isa_aff(qp: uintptr_t) -> i32;
77
78    fn isl_qpolynomial_move_dims(qp: uintptr_t, dst_type: i32, dst_pos: u32, src_type: i32,
79                                 src_pos: u32, n: u32)
80                                 -> uintptr_t;
81
82    fn isl_qpolynomial_mul(qp1: uintptr_t, qp2: uintptr_t) -> uintptr_t;
83
84    fn isl_qpolynomial_nan_on_domain(domain: uintptr_t) -> uintptr_t;
85
86    fn isl_qpolynomial_neg(qp: uintptr_t) -> uintptr_t;
87
88    fn isl_qpolynomial_neginfty_on_domain(domain: uintptr_t) -> uintptr_t;
89
90    fn isl_qpolynomial_one_on_domain(domain: uintptr_t) -> uintptr_t;
91
92    fn isl_qpolynomial_plain_is_equal(qp1: uintptr_t, qp2: uintptr_t) -> i32;
93
94    fn isl_qpolynomial_pow(qp: uintptr_t, power: u32) -> uintptr_t;
95
96    fn isl_qpolynomial_project_domain_on_params(qp: uintptr_t) -> uintptr_t;
97
98    fn isl_qpolynomial_scale_down_val(qp: uintptr_t, v: uintptr_t) -> uintptr_t;
99
100    fn isl_qpolynomial_scale_val(qp: uintptr_t, v: uintptr_t) -> uintptr_t;
101
102    fn isl_qpolynomial_set_dim_name(qp: uintptr_t, type_: i32, pos: u32, s: *const c_char)
103                                    -> uintptr_t;
104
105    fn isl_qpolynomial_sgn(qp: uintptr_t) -> i32;
106
107    fn isl_qpolynomial_sub(qp1: uintptr_t, qp2: uintptr_t) -> uintptr_t;
108
109    fn isl_qpolynomial_to_list(el: uintptr_t) -> uintptr_t;
110
111    fn isl_qpolynomial_val_on_domain(space: uintptr_t, val: uintptr_t) -> uintptr_t;
112
113    fn isl_qpolynomial_var_on_domain(domain: uintptr_t, type_: i32, pos: u32) -> uintptr_t;
114
115    fn isl_qpolynomial_zero_on_domain(domain: uintptr_t) -> uintptr_t;
116
117}
118
119impl QPolynomial {
120    /// Wraps `isl_qpolynomial_add`.
121    pub fn add(self, qp2: QPolynomial) -> Result<QPolynomial, LibISLError> {
122        let qp1 = self;
123        let isl_rs_ctx = qp1.get_ctx();
124        let mut qp1 = qp1;
125        qp1.do_not_free_on_drop();
126        let qp1 = qp1.ptr;
127        let mut qp2 = qp2;
128        qp2.do_not_free_on_drop();
129        let qp2 = qp2.ptr;
130        let isl_rs_result = unsafe { isl_qpolynomial_add(qp1, qp2) };
131        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
132                                          should_free_on_drop: true };
133        let err = isl_rs_ctx.last_error();
134        if err != Error::None_ {
135            let err_msg = isl_rs_ctx.last_error_msg();
136            isl_rs_ctx.reset_error();
137            return Err(LibISLError::new(err, err_msg));
138        }
139        Ok(isl_rs_result)
140    }
141
142    /// Wraps `isl_qpolynomial_add_dims`.
143    pub fn add_dims(self, type_: DimType, n: u32) -> Result<QPolynomial, LibISLError> {
144        let qp = self;
145        let isl_rs_ctx = qp.get_ctx();
146        let mut qp = qp;
147        qp.do_not_free_on_drop();
148        let qp = qp.ptr;
149        let type_ = type_.to_i32();
150        let isl_rs_result = unsafe { isl_qpolynomial_add_dims(qp, type_, n) };
151        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
152                                          should_free_on_drop: true };
153        let err = isl_rs_ctx.last_error();
154        if err != Error::None_ {
155            let err_msg = isl_rs_ctx.last_error_msg();
156            isl_rs_ctx.reset_error();
157            return Err(LibISLError::new(err, err_msg));
158        }
159        Ok(isl_rs_result)
160    }
161
162    /// Wraps `isl_qpolynomial_align_params`.
163    pub fn align_params(self, model: Space) -> Result<QPolynomial, LibISLError> {
164        let qp = self;
165        let isl_rs_ctx = qp.get_ctx();
166        let mut qp = qp;
167        qp.do_not_free_on_drop();
168        let qp = qp.ptr;
169        let mut model = model;
170        model.do_not_free_on_drop();
171        let model = model.ptr;
172        let isl_rs_result = unsafe { isl_qpolynomial_align_params(qp, model) };
173        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
174                                          should_free_on_drop: true };
175        let err = isl_rs_ctx.last_error();
176        if err != Error::None_ {
177            let err_msg = isl_rs_ctx.last_error_msg();
178            isl_rs_ctx.reset_error();
179            return Err(LibISLError::new(err, err_msg));
180        }
181        Ok(isl_rs_result)
182    }
183
184    /// Wraps `isl_qpolynomial_as_aff`.
185    pub fn as_aff(self) -> Result<Aff, LibISLError> {
186        let qp = self;
187        let isl_rs_ctx = qp.get_ctx();
188        let mut qp = qp;
189        qp.do_not_free_on_drop();
190        let qp = qp.ptr;
191        let isl_rs_result = unsafe { isl_qpolynomial_as_aff(qp) };
192        let isl_rs_result = Aff { ptr: isl_rs_result,
193                                  should_free_on_drop: true };
194        let err = isl_rs_ctx.last_error();
195        if err != Error::None_ {
196            let err_msg = isl_rs_ctx.last_error_msg();
197            isl_rs_ctx.reset_error();
198            return Err(LibISLError::new(err, err_msg));
199        }
200        Ok(isl_rs_result)
201    }
202
203    /// Wraps `isl_qpolynomial_copy`.
204    pub fn copy(&self) -> Result<QPolynomial, LibISLError> {
205        let qp = self;
206        let isl_rs_ctx = qp.get_ctx();
207        let qp = qp.ptr;
208        let isl_rs_result = unsafe { isl_qpolynomial_copy(qp) };
209        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
210                                          should_free_on_drop: true };
211        let err = isl_rs_ctx.last_error();
212        if err != Error::None_ {
213            let err_msg = isl_rs_ctx.last_error_msg();
214            isl_rs_ctx.reset_error();
215            return Err(LibISLError::new(err, err_msg));
216        }
217        Ok(isl_rs_result)
218    }
219
220    /// Wraps `isl_qpolynomial_dim`.
221    pub fn dim(&self, type_: DimType) -> Result<i32, LibISLError> {
222        let qp = self;
223        let isl_rs_ctx = qp.get_ctx();
224        let qp = qp.ptr;
225        let type_ = type_.to_i32();
226        let isl_rs_result = unsafe { isl_qpolynomial_dim(qp, type_) };
227        let err = isl_rs_ctx.last_error();
228        if err != Error::None_ {
229            let err_msg = isl_rs_ctx.last_error_msg();
230            isl_rs_ctx.reset_error();
231            return Err(LibISLError::new(err, err_msg));
232        }
233        Ok(isl_rs_result)
234    }
235
236    /// Wraps `isl_qpolynomial_domain_reverse`.
237    pub fn domain_reverse(self) -> Result<QPolynomial, LibISLError> {
238        let qp = self;
239        let isl_rs_ctx = qp.get_ctx();
240        let mut qp = qp;
241        qp.do_not_free_on_drop();
242        let qp = qp.ptr;
243        let isl_rs_result = unsafe { isl_qpolynomial_domain_reverse(qp) };
244        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
245                                          should_free_on_drop: true };
246        let err = isl_rs_ctx.last_error();
247        if err != Error::None_ {
248            let err_msg = isl_rs_ctx.last_error_msg();
249            isl_rs_ctx.reset_error();
250            return Err(LibISLError::new(err, err_msg));
251        }
252        Ok(isl_rs_result)
253    }
254
255    /// Wraps `isl_qpolynomial_drop_dims`.
256    pub fn drop_dims(self, type_: DimType, first: u32, n: u32) -> Result<QPolynomial, LibISLError> {
257        let qp = self;
258        let isl_rs_ctx = qp.get_ctx();
259        let mut qp = qp;
260        qp.do_not_free_on_drop();
261        let qp = qp.ptr;
262        let type_ = type_.to_i32();
263        let isl_rs_result = unsafe { isl_qpolynomial_drop_dims(qp, type_, first, n) };
264        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
265                                          should_free_on_drop: true };
266        let err = isl_rs_ctx.last_error();
267        if err != Error::None_ {
268            let err_msg = isl_rs_ctx.last_error_msg();
269            isl_rs_ctx.reset_error();
270            return Err(LibISLError::new(err, err_msg));
271        }
272        Ok(isl_rs_result)
273    }
274
275    /// Wraps `isl_qpolynomial_dump`.
276    pub fn dump(&self) -> Result<(), LibISLError> {
277        let qp = self;
278        let isl_rs_ctx = qp.get_ctx();
279        let qp = qp.ptr;
280        let isl_rs_result = unsafe { isl_qpolynomial_dump(qp) };
281        let err = isl_rs_ctx.last_error();
282        if err != Error::None_ {
283            let err_msg = isl_rs_ctx.last_error_msg();
284            isl_rs_ctx.reset_error();
285            return Err(LibISLError::new(err, err_msg));
286        }
287        Ok(isl_rs_result)
288    }
289
290    /// Wraps `isl_qpolynomial_eval`.
291    pub fn eval(self, pnt: Point) -> Result<Val, LibISLError> {
292        let qp = self;
293        let isl_rs_ctx = qp.get_ctx();
294        let mut qp = qp;
295        qp.do_not_free_on_drop();
296        let qp = qp.ptr;
297        let mut pnt = pnt;
298        pnt.do_not_free_on_drop();
299        let pnt = pnt.ptr;
300        let isl_rs_result = unsafe { isl_qpolynomial_eval(qp, pnt) };
301        let isl_rs_result = Val { ptr: isl_rs_result,
302                                  should_free_on_drop: true };
303        let err = isl_rs_ctx.last_error();
304        if err != Error::None_ {
305            let err_msg = isl_rs_ctx.last_error_msg();
306            isl_rs_ctx.reset_error();
307            return Err(LibISLError::new(err, err_msg));
308        }
309        Ok(isl_rs_result)
310    }
311
312    /// Wraps `isl_qpolynomial_free`.
313    pub fn free(self) -> Result<QPolynomial, LibISLError> {
314        let qp = self;
315        let isl_rs_ctx = qp.get_ctx();
316        let mut qp = qp;
317        qp.do_not_free_on_drop();
318        let qp = qp.ptr;
319        let isl_rs_result = unsafe { isl_qpolynomial_free(qp) };
320        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
321                                          should_free_on_drop: true };
322        let err = isl_rs_ctx.last_error();
323        if err != Error::None_ {
324            let err_msg = isl_rs_ctx.last_error_msg();
325            isl_rs_ctx.reset_error();
326            return Err(LibISLError::new(err, err_msg));
327        }
328        Ok(isl_rs_result)
329    }
330
331    /// Wraps `isl_qpolynomial_from_aff`.
332    pub fn from_aff(aff: Aff) -> Result<QPolynomial, LibISLError> {
333        let isl_rs_ctx = aff.get_ctx();
334        let mut aff = aff;
335        aff.do_not_free_on_drop();
336        let aff = aff.ptr;
337        let isl_rs_result = unsafe { isl_qpolynomial_from_aff(aff) };
338        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
339                                          should_free_on_drop: true };
340        let err = isl_rs_ctx.last_error();
341        if err != Error::None_ {
342            let err_msg = isl_rs_ctx.last_error_msg();
343            isl_rs_ctx.reset_error();
344            return Err(LibISLError::new(err, err_msg));
345        }
346        Ok(isl_rs_result)
347    }
348
349    /// Wraps `isl_qpolynomial_from_constraint`.
350    pub fn from_constraint(c: Constraint, type_: DimType, pos: u32)
351                           -> Result<QPolynomial, LibISLError> {
352        let isl_rs_ctx = c.get_ctx();
353        let mut c = c;
354        c.do_not_free_on_drop();
355        let c = c.ptr;
356        let type_ = type_.to_i32();
357        let isl_rs_result = unsafe { isl_qpolynomial_from_constraint(c, type_, pos) };
358        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
359                                          should_free_on_drop: true };
360        let err = isl_rs_ctx.last_error();
361        if err != Error::None_ {
362            let err_msg = isl_rs_ctx.last_error_msg();
363            isl_rs_ctx.reset_error();
364            return Err(LibISLError::new(err, err_msg));
365        }
366        Ok(isl_rs_result)
367    }
368
369    /// Wraps `isl_qpolynomial_from_term`.
370    pub fn from_term(term: Term) -> Result<QPolynomial, LibISLError> {
371        let isl_rs_ctx = term.get_ctx();
372        let mut term = term;
373        term.do_not_free_on_drop();
374        let term = term.ptr;
375        let isl_rs_result = unsafe { isl_qpolynomial_from_term(term) };
376        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
377                                          should_free_on_drop: true };
378        let err = isl_rs_ctx.last_error();
379        if err != Error::None_ {
380            let err_msg = isl_rs_ctx.last_error_msg();
381            isl_rs_ctx.reset_error();
382            return Err(LibISLError::new(err, err_msg));
383        }
384        Ok(isl_rs_result)
385    }
386
387    /// Wraps `isl_qpolynomial_get_constant_val`.
388    pub fn get_constant_val(&self) -> Result<Val, LibISLError> {
389        let qp = self;
390        let isl_rs_ctx = qp.get_ctx();
391        let qp = qp.ptr;
392        let isl_rs_result = unsafe { isl_qpolynomial_get_constant_val(qp) };
393        let isl_rs_result = Val { ptr: isl_rs_result,
394                                  should_free_on_drop: true };
395        let err = isl_rs_ctx.last_error();
396        if err != Error::None_ {
397            let err_msg = isl_rs_ctx.last_error_msg();
398            isl_rs_ctx.reset_error();
399            return Err(LibISLError::new(err, err_msg));
400        }
401        Ok(isl_rs_result)
402    }
403
404    /// Wraps `isl_qpolynomial_get_ctx`.
405    pub fn get_ctx(&self) -> Context {
406        let qp = self;
407        let qp = qp.ptr;
408        let isl_rs_result = unsafe { isl_qpolynomial_get_ctx(qp) };
409        let isl_rs_result = Context { ptr: isl_rs_result,
410                                      should_free_on_drop: false };
411        isl_rs_result
412    }
413
414    /// Wraps `isl_qpolynomial_get_domain_space`.
415    pub fn get_domain_space(&self) -> Result<Space, LibISLError> {
416        let qp = self;
417        let isl_rs_ctx = qp.get_ctx();
418        let qp = qp.ptr;
419        let isl_rs_result = unsafe { isl_qpolynomial_get_domain_space(qp) };
420        let isl_rs_result = Space { ptr: isl_rs_result,
421                                    should_free_on_drop: true };
422        let err = isl_rs_ctx.last_error();
423        if err != Error::None_ {
424            let err_msg = isl_rs_ctx.last_error_msg();
425            isl_rs_ctx.reset_error();
426            return Err(LibISLError::new(err, err_msg));
427        }
428        Ok(isl_rs_result)
429    }
430
431    /// Wraps `isl_qpolynomial_get_space`.
432    pub fn get_space(&self) -> Result<Space, LibISLError> {
433        let qp = self;
434        let isl_rs_ctx = qp.get_ctx();
435        let qp = qp.ptr;
436        let isl_rs_result = unsafe { isl_qpolynomial_get_space(qp) };
437        let isl_rs_result = Space { ptr: isl_rs_result,
438                                    should_free_on_drop: true };
439        let err = isl_rs_ctx.last_error();
440        if err != Error::None_ {
441            let err_msg = isl_rs_ctx.last_error_msg();
442            isl_rs_ctx.reset_error();
443            return Err(LibISLError::new(err, err_msg));
444        }
445        Ok(isl_rs_result)
446    }
447
448    /// Wraps `isl_qpolynomial_gist`.
449    pub fn gist(self, context: Set) -> Result<QPolynomial, LibISLError> {
450        let qp = self;
451        let isl_rs_ctx = qp.get_ctx();
452        let mut qp = qp;
453        qp.do_not_free_on_drop();
454        let qp = qp.ptr;
455        let mut context = context;
456        context.do_not_free_on_drop();
457        let context = context.ptr;
458        let isl_rs_result = unsafe { isl_qpolynomial_gist(qp, context) };
459        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
460                                          should_free_on_drop: true };
461        let err = isl_rs_ctx.last_error();
462        if err != Error::None_ {
463            let err_msg = isl_rs_ctx.last_error_msg();
464            isl_rs_ctx.reset_error();
465            return Err(LibISLError::new(err, err_msg));
466        }
467        Ok(isl_rs_result)
468    }
469
470    /// Wraps `isl_qpolynomial_gist_params`.
471    pub fn gist_params(self, context: Set) -> Result<QPolynomial, LibISLError> {
472        let qp = self;
473        let isl_rs_ctx = qp.get_ctx();
474        let mut qp = qp;
475        qp.do_not_free_on_drop();
476        let qp = qp.ptr;
477        let mut context = context;
478        context.do_not_free_on_drop();
479        let context = context.ptr;
480        let isl_rs_result = unsafe { isl_qpolynomial_gist_params(qp, context) };
481        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
482                                          should_free_on_drop: true };
483        let err = isl_rs_ctx.last_error();
484        if err != Error::None_ {
485            let err_msg = isl_rs_ctx.last_error_msg();
486            isl_rs_ctx.reset_error();
487            return Err(LibISLError::new(err, err_msg));
488        }
489        Ok(isl_rs_result)
490    }
491
492    /// Wraps `isl_qpolynomial_homogenize`.
493    pub fn homogenize(self) -> Result<QPolynomial, LibISLError> {
494        let poly = self;
495        let isl_rs_ctx = poly.get_ctx();
496        let mut poly = poly;
497        poly.do_not_free_on_drop();
498        let poly = poly.ptr;
499        let isl_rs_result = unsafe { isl_qpolynomial_homogenize(poly) };
500        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
501                                          should_free_on_drop: true };
502        let err = isl_rs_ctx.last_error();
503        if err != Error::None_ {
504            let err_msg = isl_rs_ctx.last_error_msg();
505            isl_rs_ctx.reset_error();
506            return Err(LibISLError::new(err, err_msg));
507        }
508        Ok(isl_rs_result)
509    }
510
511    /// Wraps `isl_qpolynomial_infty_on_domain`.
512    pub fn infty_on_domain(domain: Space) -> Result<QPolynomial, LibISLError> {
513        let isl_rs_ctx = domain.get_ctx();
514        let mut domain = domain;
515        domain.do_not_free_on_drop();
516        let domain = domain.ptr;
517        let isl_rs_result = unsafe { isl_qpolynomial_infty_on_domain(domain) };
518        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
519                                          should_free_on_drop: true };
520        let err = isl_rs_ctx.last_error();
521        if err != Error::None_ {
522            let err_msg = isl_rs_ctx.last_error_msg();
523            isl_rs_ctx.reset_error();
524            return Err(LibISLError::new(err, err_msg));
525        }
526        Ok(isl_rs_result)
527    }
528
529    /// Wraps `isl_qpolynomial_insert_dims`.
530    pub fn insert_dims(self, type_: DimType, first: u32, n: u32)
531                       -> Result<QPolynomial, LibISLError> {
532        let qp = self;
533        let isl_rs_ctx = qp.get_ctx();
534        let mut qp = qp;
535        qp.do_not_free_on_drop();
536        let qp = qp.ptr;
537        let type_ = type_.to_i32();
538        let isl_rs_result = unsafe { isl_qpolynomial_insert_dims(qp, type_, first, n) };
539        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
540                                          should_free_on_drop: true };
541        let err = isl_rs_ctx.last_error();
542        if err != Error::None_ {
543            let err_msg = isl_rs_ctx.last_error_msg();
544            isl_rs_ctx.reset_error();
545            return Err(LibISLError::new(err, err_msg));
546        }
547        Ok(isl_rs_result)
548    }
549
550    /// Wraps `isl_qpolynomial_involves_dims`.
551    pub fn involves_dims(&self, type_: DimType, first: u32, n: u32) -> Result<bool, LibISLError> {
552        let qp = self;
553        let isl_rs_ctx = qp.get_ctx();
554        let qp = qp.ptr;
555        let type_ = type_.to_i32();
556        let isl_rs_result = unsafe { isl_qpolynomial_involves_dims(qp, type_, first, n) };
557        let isl_rs_result = match isl_rs_result {
558            0 => false,
559            1 => true,
560            _ => {
561                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
562            }
563        };
564        let err = isl_rs_ctx.last_error();
565        if err != Error::None_ {
566            let err_msg = isl_rs_ctx.last_error_msg();
567            isl_rs_ctx.reset_error();
568            return Err(LibISLError::new(err, err_msg));
569        }
570        Ok(isl_rs_result)
571    }
572
573    /// Wraps `isl_qpolynomial_is_infty`.
574    pub fn is_infty(&self) -> Result<bool, LibISLError> {
575        let qp = self;
576        let isl_rs_ctx = qp.get_ctx();
577        let qp = qp.ptr;
578        let isl_rs_result = unsafe { isl_qpolynomial_is_infty(qp) };
579        let isl_rs_result = match isl_rs_result {
580            0 => false,
581            1 => true,
582            _ => {
583                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
584            }
585        };
586        let err = isl_rs_ctx.last_error();
587        if err != Error::None_ {
588            let err_msg = isl_rs_ctx.last_error_msg();
589            isl_rs_ctx.reset_error();
590            return Err(LibISLError::new(err, err_msg));
591        }
592        Ok(isl_rs_result)
593    }
594
595    /// Wraps `isl_qpolynomial_is_nan`.
596    pub fn is_nan(&self) -> Result<bool, LibISLError> {
597        let qp = self;
598        let isl_rs_ctx = qp.get_ctx();
599        let qp = qp.ptr;
600        let isl_rs_result = unsafe { isl_qpolynomial_is_nan(qp) };
601        let isl_rs_result = match isl_rs_result {
602            0 => false,
603            1 => true,
604            _ => {
605                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
606            }
607        };
608        let err = isl_rs_ctx.last_error();
609        if err != Error::None_ {
610            let err_msg = isl_rs_ctx.last_error_msg();
611            isl_rs_ctx.reset_error();
612            return Err(LibISLError::new(err, err_msg));
613        }
614        Ok(isl_rs_result)
615    }
616
617    /// Wraps `isl_qpolynomial_is_neginfty`.
618    pub fn is_neginfty(&self) -> Result<bool, LibISLError> {
619        let qp = self;
620        let isl_rs_ctx = qp.get_ctx();
621        let qp = qp.ptr;
622        let isl_rs_result = unsafe { isl_qpolynomial_is_neginfty(qp) };
623        let isl_rs_result = match isl_rs_result {
624            0 => false,
625            1 => true,
626            _ => {
627                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
628            }
629        };
630        let err = isl_rs_ctx.last_error();
631        if err != Error::None_ {
632            let err_msg = isl_rs_ctx.last_error_msg();
633            isl_rs_ctx.reset_error();
634            return Err(LibISLError::new(err, err_msg));
635        }
636        Ok(isl_rs_result)
637    }
638
639    /// Wraps `isl_qpolynomial_is_zero`.
640    pub fn is_zero(&self) -> Result<bool, LibISLError> {
641        let qp = self;
642        let isl_rs_ctx = qp.get_ctx();
643        let qp = qp.ptr;
644        let isl_rs_result = unsafe { isl_qpolynomial_is_zero(qp) };
645        let isl_rs_result = match isl_rs_result {
646            0 => false,
647            1 => true,
648            _ => {
649                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
650            }
651        };
652        let err = isl_rs_ctx.last_error();
653        if err != Error::None_ {
654            let err_msg = isl_rs_ctx.last_error_msg();
655            isl_rs_ctx.reset_error();
656            return Err(LibISLError::new(err, err_msg));
657        }
658        Ok(isl_rs_result)
659    }
660
661    /// Wraps `isl_qpolynomial_isa_aff`.
662    pub fn isa_aff(&self) -> Result<bool, LibISLError> {
663        let qp = self;
664        let isl_rs_ctx = qp.get_ctx();
665        let qp = qp.ptr;
666        let isl_rs_result = unsafe { isl_qpolynomial_isa_aff(qp) };
667        let isl_rs_result = match isl_rs_result {
668            0 => false,
669            1 => true,
670            _ => {
671                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
672            }
673        };
674        let err = isl_rs_ctx.last_error();
675        if err != Error::None_ {
676            let err_msg = isl_rs_ctx.last_error_msg();
677            isl_rs_ctx.reset_error();
678            return Err(LibISLError::new(err, err_msg));
679        }
680        Ok(isl_rs_result)
681    }
682
683    /// Wraps `isl_qpolynomial_move_dims`.
684    pub fn move_dims(self, dst_type: DimType, dst_pos: u32, src_type: DimType, src_pos: u32,
685                     n: u32)
686                     -> Result<QPolynomial, LibISLError> {
687        let qp = self;
688        let isl_rs_ctx = qp.get_ctx();
689        let mut qp = qp;
690        qp.do_not_free_on_drop();
691        let qp = qp.ptr;
692        let dst_type = dst_type.to_i32();
693        let src_type = src_type.to_i32();
694        let isl_rs_result =
695            unsafe { isl_qpolynomial_move_dims(qp, dst_type, dst_pos, src_type, src_pos, n) };
696        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
697                                          should_free_on_drop: true };
698        let err = isl_rs_ctx.last_error();
699        if err != Error::None_ {
700            let err_msg = isl_rs_ctx.last_error_msg();
701            isl_rs_ctx.reset_error();
702            return Err(LibISLError::new(err, err_msg));
703        }
704        Ok(isl_rs_result)
705    }
706
707    /// Wraps `isl_qpolynomial_mul`.
708    pub fn mul(self, qp2: QPolynomial) -> Result<QPolynomial, LibISLError> {
709        let qp1 = self;
710        let isl_rs_ctx = qp1.get_ctx();
711        let mut qp1 = qp1;
712        qp1.do_not_free_on_drop();
713        let qp1 = qp1.ptr;
714        let mut qp2 = qp2;
715        qp2.do_not_free_on_drop();
716        let qp2 = qp2.ptr;
717        let isl_rs_result = unsafe { isl_qpolynomial_mul(qp1, qp2) };
718        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
719                                          should_free_on_drop: true };
720        let err = isl_rs_ctx.last_error();
721        if err != Error::None_ {
722            let err_msg = isl_rs_ctx.last_error_msg();
723            isl_rs_ctx.reset_error();
724            return Err(LibISLError::new(err, err_msg));
725        }
726        Ok(isl_rs_result)
727    }
728
729    /// Wraps `isl_qpolynomial_nan_on_domain`.
730    pub fn nan_on_domain(domain: Space) -> Result<QPolynomial, LibISLError> {
731        let isl_rs_ctx = domain.get_ctx();
732        let mut domain = domain;
733        domain.do_not_free_on_drop();
734        let domain = domain.ptr;
735        let isl_rs_result = unsafe { isl_qpolynomial_nan_on_domain(domain) };
736        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
737                                          should_free_on_drop: true };
738        let err = isl_rs_ctx.last_error();
739        if err != Error::None_ {
740            let err_msg = isl_rs_ctx.last_error_msg();
741            isl_rs_ctx.reset_error();
742            return Err(LibISLError::new(err, err_msg));
743        }
744        Ok(isl_rs_result)
745    }
746
747    /// Wraps `isl_qpolynomial_neg`.
748    pub fn neg(self) -> Result<QPolynomial, LibISLError> {
749        let qp = self;
750        let isl_rs_ctx = qp.get_ctx();
751        let mut qp = qp;
752        qp.do_not_free_on_drop();
753        let qp = qp.ptr;
754        let isl_rs_result = unsafe { isl_qpolynomial_neg(qp) };
755        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
756                                          should_free_on_drop: true };
757        let err = isl_rs_ctx.last_error();
758        if err != Error::None_ {
759            let err_msg = isl_rs_ctx.last_error_msg();
760            isl_rs_ctx.reset_error();
761            return Err(LibISLError::new(err, err_msg));
762        }
763        Ok(isl_rs_result)
764    }
765
766    /// Wraps `isl_qpolynomial_neginfty_on_domain`.
767    pub fn neginfty_on_domain(domain: Space) -> Result<QPolynomial, LibISLError> {
768        let isl_rs_ctx = domain.get_ctx();
769        let mut domain = domain;
770        domain.do_not_free_on_drop();
771        let domain = domain.ptr;
772        let isl_rs_result = unsafe { isl_qpolynomial_neginfty_on_domain(domain) };
773        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
774                                          should_free_on_drop: true };
775        let err = isl_rs_ctx.last_error();
776        if err != Error::None_ {
777            let err_msg = isl_rs_ctx.last_error_msg();
778            isl_rs_ctx.reset_error();
779            return Err(LibISLError::new(err, err_msg));
780        }
781        Ok(isl_rs_result)
782    }
783
784    /// Wraps `isl_qpolynomial_one_on_domain`.
785    pub fn one_on_domain(domain: Space) -> Result<QPolynomial, LibISLError> {
786        let isl_rs_ctx = domain.get_ctx();
787        let mut domain = domain;
788        domain.do_not_free_on_drop();
789        let domain = domain.ptr;
790        let isl_rs_result = unsafe { isl_qpolynomial_one_on_domain(domain) };
791        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
792                                          should_free_on_drop: true };
793        let err = isl_rs_ctx.last_error();
794        if err != Error::None_ {
795            let err_msg = isl_rs_ctx.last_error_msg();
796            isl_rs_ctx.reset_error();
797            return Err(LibISLError::new(err, err_msg));
798        }
799        Ok(isl_rs_result)
800    }
801
802    /// Wraps `isl_qpolynomial_plain_is_equal`.
803    pub fn plain_is_equal(&self, qp2: &QPolynomial) -> Result<bool, LibISLError> {
804        let qp1 = self;
805        let isl_rs_ctx = qp1.get_ctx();
806        let qp1 = qp1.ptr;
807        let qp2 = qp2.ptr;
808        let isl_rs_result = unsafe { isl_qpolynomial_plain_is_equal(qp1, qp2) };
809        let isl_rs_result = match isl_rs_result {
810            0 => false,
811            1 => true,
812            _ => {
813                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
814            }
815        };
816        let err = isl_rs_ctx.last_error();
817        if err != Error::None_ {
818            let err_msg = isl_rs_ctx.last_error_msg();
819            isl_rs_ctx.reset_error();
820            return Err(LibISLError::new(err, err_msg));
821        }
822        Ok(isl_rs_result)
823    }
824
825    /// Wraps `isl_qpolynomial_pow`.
826    pub fn pow(self, power: u32) -> Result<QPolynomial, LibISLError> {
827        let qp = self;
828        let isl_rs_ctx = qp.get_ctx();
829        let mut qp = qp;
830        qp.do_not_free_on_drop();
831        let qp = qp.ptr;
832        let isl_rs_result = unsafe { isl_qpolynomial_pow(qp, power) };
833        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
834                                          should_free_on_drop: true };
835        let err = isl_rs_ctx.last_error();
836        if err != Error::None_ {
837            let err_msg = isl_rs_ctx.last_error_msg();
838            isl_rs_ctx.reset_error();
839            return Err(LibISLError::new(err, err_msg));
840        }
841        Ok(isl_rs_result)
842    }
843
844    /// Wraps `isl_qpolynomial_project_domain_on_params`.
845    pub fn project_domain_on_params(self) -> Result<QPolynomial, LibISLError> {
846        let qp = self;
847        let isl_rs_ctx = qp.get_ctx();
848        let mut qp = qp;
849        qp.do_not_free_on_drop();
850        let qp = qp.ptr;
851        let isl_rs_result = unsafe { isl_qpolynomial_project_domain_on_params(qp) };
852        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
853                                          should_free_on_drop: true };
854        let err = isl_rs_ctx.last_error();
855        if err != Error::None_ {
856            let err_msg = isl_rs_ctx.last_error_msg();
857            isl_rs_ctx.reset_error();
858            return Err(LibISLError::new(err, err_msg));
859        }
860        Ok(isl_rs_result)
861    }
862
863    /// Wraps `isl_qpolynomial_scale_down_val`.
864    pub fn scale_down_val(self, v: Val) -> Result<QPolynomial, LibISLError> {
865        let qp = self;
866        let isl_rs_ctx = qp.get_ctx();
867        let mut qp = qp;
868        qp.do_not_free_on_drop();
869        let qp = qp.ptr;
870        let mut v = v;
871        v.do_not_free_on_drop();
872        let v = v.ptr;
873        let isl_rs_result = unsafe { isl_qpolynomial_scale_down_val(qp, v) };
874        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
875                                          should_free_on_drop: true };
876        let err = isl_rs_ctx.last_error();
877        if err != Error::None_ {
878            let err_msg = isl_rs_ctx.last_error_msg();
879            isl_rs_ctx.reset_error();
880            return Err(LibISLError::new(err, err_msg));
881        }
882        Ok(isl_rs_result)
883    }
884
885    /// Wraps `isl_qpolynomial_scale_val`.
886    pub fn scale_val(self, v: Val) -> Result<QPolynomial, LibISLError> {
887        let qp = self;
888        let isl_rs_ctx = qp.get_ctx();
889        let mut qp = qp;
890        qp.do_not_free_on_drop();
891        let qp = qp.ptr;
892        let mut v = v;
893        v.do_not_free_on_drop();
894        let v = v.ptr;
895        let isl_rs_result = unsafe { isl_qpolynomial_scale_val(qp, v) };
896        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
897                                          should_free_on_drop: true };
898        let err = isl_rs_ctx.last_error();
899        if err != Error::None_ {
900            let err_msg = isl_rs_ctx.last_error_msg();
901            isl_rs_ctx.reset_error();
902            return Err(LibISLError::new(err, err_msg));
903        }
904        Ok(isl_rs_result)
905    }
906
907    /// Wraps `isl_qpolynomial_set_dim_name`.
908    pub fn set_dim_name(self, type_: DimType, pos: u32, s: &str)
909                        -> Result<QPolynomial, LibISLError> {
910        let qp = self;
911        let isl_rs_ctx = qp.get_ctx();
912        let mut qp = qp;
913        qp.do_not_free_on_drop();
914        let qp = qp.ptr;
915        let type_ = type_.to_i32();
916        let s = CString::new(s).unwrap();
917        let s = s.as_ptr();
918        let isl_rs_result = unsafe { isl_qpolynomial_set_dim_name(qp, type_, pos, s) };
919        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
920                                          should_free_on_drop: true };
921        let err = isl_rs_ctx.last_error();
922        if err != Error::None_ {
923            let err_msg = isl_rs_ctx.last_error_msg();
924            isl_rs_ctx.reset_error();
925            return Err(LibISLError::new(err, err_msg));
926        }
927        Ok(isl_rs_result)
928    }
929
930    /// Wraps `isl_qpolynomial_sgn`.
931    pub fn sgn(&self) -> Result<i32, LibISLError> {
932        let qp = self;
933        let isl_rs_ctx = qp.get_ctx();
934        let qp = qp.ptr;
935        let isl_rs_result = unsafe { isl_qpolynomial_sgn(qp) };
936        let err = isl_rs_ctx.last_error();
937        if err != Error::None_ {
938            let err_msg = isl_rs_ctx.last_error_msg();
939            isl_rs_ctx.reset_error();
940            return Err(LibISLError::new(err, err_msg));
941        }
942        Ok(isl_rs_result)
943    }
944
945    /// Wraps `isl_qpolynomial_sub`.
946    pub fn sub(self, qp2: QPolynomial) -> Result<QPolynomial, LibISLError> {
947        let qp1 = self;
948        let isl_rs_ctx = qp1.get_ctx();
949        let mut qp1 = qp1;
950        qp1.do_not_free_on_drop();
951        let qp1 = qp1.ptr;
952        let mut qp2 = qp2;
953        qp2.do_not_free_on_drop();
954        let qp2 = qp2.ptr;
955        let isl_rs_result = unsafe { isl_qpolynomial_sub(qp1, qp2) };
956        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
957                                          should_free_on_drop: true };
958        let err = isl_rs_ctx.last_error();
959        if err != Error::None_ {
960            let err_msg = isl_rs_ctx.last_error_msg();
961            isl_rs_ctx.reset_error();
962            return Err(LibISLError::new(err, err_msg));
963        }
964        Ok(isl_rs_result)
965    }
966
967    /// Wraps `isl_qpolynomial_to_list`.
968    pub fn to_list(self) -> Result<QPolynomialList, LibISLError> {
969        let el = self;
970        let isl_rs_ctx = el.get_ctx();
971        let mut el = el;
972        el.do_not_free_on_drop();
973        let el = el.ptr;
974        let isl_rs_result = unsafe { isl_qpolynomial_to_list(el) };
975        let isl_rs_result = QPolynomialList { ptr: isl_rs_result,
976                                              should_free_on_drop: true };
977        let err = isl_rs_ctx.last_error();
978        if err != Error::None_ {
979            let err_msg = isl_rs_ctx.last_error_msg();
980            isl_rs_ctx.reset_error();
981            return Err(LibISLError::new(err, err_msg));
982        }
983        Ok(isl_rs_result)
984    }
985
986    /// Wraps `isl_qpolynomial_val_on_domain`.
987    pub fn val_on_domain(space: Space, val: Val) -> Result<QPolynomial, LibISLError> {
988        let isl_rs_ctx = space.get_ctx();
989        let mut space = space;
990        space.do_not_free_on_drop();
991        let space = space.ptr;
992        let mut val = val;
993        val.do_not_free_on_drop();
994        let val = val.ptr;
995        let isl_rs_result = unsafe { isl_qpolynomial_val_on_domain(space, val) };
996        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
997                                          should_free_on_drop: true };
998        let err = isl_rs_ctx.last_error();
999        if err != Error::None_ {
1000            let err_msg = isl_rs_ctx.last_error_msg();
1001            isl_rs_ctx.reset_error();
1002            return Err(LibISLError::new(err, err_msg));
1003        }
1004        Ok(isl_rs_result)
1005    }
1006
1007    /// Wraps `isl_qpolynomial_var_on_domain`.
1008    pub fn var_on_domain(domain: Space, type_: DimType, pos: u32)
1009                         -> Result<QPolynomial, LibISLError> {
1010        let isl_rs_ctx = domain.get_ctx();
1011        let mut domain = domain;
1012        domain.do_not_free_on_drop();
1013        let domain = domain.ptr;
1014        let type_ = type_.to_i32();
1015        let isl_rs_result = unsafe { isl_qpolynomial_var_on_domain(domain, type_, pos) };
1016        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
1017                                          should_free_on_drop: true };
1018        let err = isl_rs_ctx.last_error();
1019        if err != Error::None_ {
1020            let err_msg = isl_rs_ctx.last_error_msg();
1021            isl_rs_ctx.reset_error();
1022            return Err(LibISLError::new(err, err_msg));
1023        }
1024        Ok(isl_rs_result)
1025    }
1026
1027    /// Wraps `isl_qpolynomial_zero_on_domain`.
1028    pub fn zero_on_domain(domain: Space) -> Result<QPolynomial, LibISLError> {
1029        let isl_rs_ctx = domain.get_ctx();
1030        let mut domain = domain;
1031        domain.do_not_free_on_drop();
1032        let domain = domain.ptr;
1033        let isl_rs_result = unsafe { isl_qpolynomial_zero_on_domain(domain) };
1034        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
1035                                          should_free_on_drop: true };
1036        let err = isl_rs_ctx.last_error();
1037        if err != Error::None_ {
1038            let err_msg = isl_rs_ctx.last_error_msg();
1039            isl_rs_ctx.reset_error();
1040            return Err(LibISLError::new(err, err_msg));
1041        }
1042        Ok(isl_rs_result)
1043    }
1044
1045    /// Does not call isl_qpolynomial_free() on being dropped. (For internal use
1046    /// only.)
1047    pub fn do_not_free_on_drop(&mut self) {
1048        self.should_free_on_drop = false;
1049    }
1050}
1051
1052impl Drop for QPolynomial {
1053    fn drop(&mut self) {
1054        if self.should_free_on_drop {
1055            unsafe {
1056                isl_qpolynomial_free(self.ptr);
1057            }
1058        }
1059    }
1060}
isl_rs/bindings/qpolynomial.rs

isl_rs/bindings/
qpolynomial.rs
