isl_rs/bindings/
mat.rs

1// Automatically generated by isl_bindings_generator.
2// LICENSE: MIT
3
4use super::{Context, Error, LibISLError, Val, Vec};
5use libc::uintptr_t;
6
7/// Wraps `isl_mat`.
8pub struct Mat {
9    pub ptr: uintptr_t,
10    pub should_free_on_drop: bool,
11}
12
13extern "C" {
14
15    fn isl_mat_add_rows(mat: uintptr_t, n: u32) -> uintptr_t;
16
17    fn isl_mat_add_zero_cols(mat: uintptr_t, n: u32) -> uintptr_t;
18
19    fn isl_mat_add_zero_rows(mat: uintptr_t, n: u32) -> uintptr_t;
20
21    fn isl_mat_aff_direct_sum(left: uintptr_t, right: uintptr_t) -> uintptr_t;
22
23    fn isl_mat_alloc(ctx: uintptr_t, n_row: u32, n_col: u32) -> uintptr_t;
24
25    fn isl_mat_col_add(mat: uintptr_t, dst_col: i32, src_col: i32) -> ();
26
27    fn isl_mat_cols(mat: uintptr_t) -> i32;
28
29    fn isl_mat_concat(top: uintptr_t, bot: uintptr_t) -> uintptr_t;
30
31    fn isl_mat_copy(mat: uintptr_t) -> uintptr_t;
32
33    fn isl_mat_diagonal(mat1: uintptr_t, mat2: uintptr_t) -> uintptr_t;
34
35    fn isl_mat_drop_cols(mat: uintptr_t, col: u32, n: u32) -> uintptr_t;
36
37    fn isl_mat_drop_rows(mat: uintptr_t, row: u32, n: u32) -> uintptr_t;
38
39    fn isl_mat_dump(mat: uintptr_t) -> ();
40
41    fn isl_mat_extend(mat: uintptr_t, n_row: u32, n_col: u32) -> uintptr_t;
42
43    fn isl_mat_free(mat: uintptr_t) -> uintptr_t;
44
45    fn isl_mat_from_row_vec(vec: uintptr_t) -> uintptr_t;
46
47    fn isl_mat_get_ctx(mat: uintptr_t) -> uintptr_t;
48
49    fn isl_mat_get_element_val(mat: uintptr_t, row: i32, col: i32) -> uintptr_t;
50
51    fn isl_mat_has_linearly_independent_rows(mat1: uintptr_t, mat2: uintptr_t) -> i32;
52
53    fn isl_mat_identity(ctx: uintptr_t, n_row: u32) -> uintptr_t;
54
55    fn isl_mat_initial_non_zero_cols(mat: uintptr_t) -> i32;
56
57    fn isl_mat_insert_cols(mat: uintptr_t, col: u32, n: u32) -> uintptr_t;
58
59    fn isl_mat_insert_rows(mat: uintptr_t, row: u32, n: u32) -> uintptr_t;
60
61    fn isl_mat_insert_zero_cols(mat: uintptr_t, first: u32, n: u32) -> uintptr_t;
62
63    fn isl_mat_insert_zero_rows(mat: uintptr_t, row: u32, n: u32) -> uintptr_t;
64
65    fn isl_mat_inverse_product(left: uintptr_t, right: uintptr_t) -> uintptr_t;
66
67    fn isl_mat_is_equal(mat1: uintptr_t, mat2: uintptr_t) -> i32;
68
69    fn isl_mat_lin_to_aff(mat: uintptr_t) -> uintptr_t;
70
71    fn isl_mat_move_cols(mat: uintptr_t, dst_col: u32, src_col: u32, n: u32) -> uintptr_t;
72
73    fn isl_mat_normalize(mat: uintptr_t) -> uintptr_t;
74
75    fn isl_mat_normalize_row(mat: uintptr_t, row: i32) -> uintptr_t;
76
77    fn isl_mat_product(left: uintptr_t, right: uintptr_t) -> uintptr_t;
78
79    fn isl_mat_rank(mat: uintptr_t) -> i32;
80
81    fn isl_mat_right_inverse(mat: uintptr_t) -> uintptr_t;
82
83    fn isl_mat_right_kernel(mat: uintptr_t) -> uintptr_t;
84
85    fn isl_mat_row_basis(mat: uintptr_t) -> uintptr_t;
86
87    fn isl_mat_row_basis_extension(mat1: uintptr_t, mat2: uintptr_t) -> uintptr_t;
88
89    fn isl_mat_rows(mat: uintptr_t) -> i32;
90
91    fn isl_mat_set_element_si(mat: uintptr_t, row: i32, col: i32, v: i32) -> uintptr_t;
92
93    fn isl_mat_set_element_val(mat: uintptr_t, row: i32, col: i32, v: uintptr_t) -> uintptr_t;
94
95    fn isl_mat_swap_cols(mat: uintptr_t, i: u32, j: u32) -> uintptr_t;
96
97    fn isl_mat_swap_rows(mat: uintptr_t, i: u32, j: u32) -> uintptr_t;
98
99    fn isl_mat_transpose(mat: uintptr_t) -> uintptr_t;
100
101    fn isl_mat_unimodular_complete(M: uintptr_t, row: i32) -> uintptr_t;
102
103    fn isl_mat_vec_concat(top: uintptr_t, bot: uintptr_t) -> uintptr_t;
104
105    fn isl_mat_vec_inverse_product(mat: uintptr_t, vec: uintptr_t) -> uintptr_t;
106
107    fn isl_mat_vec_product(mat: uintptr_t, vec: uintptr_t) -> uintptr_t;
108
109}
110
111impl Mat {
112    /// Wraps `isl_mat_add_rows`.
113    pub fn add_rows(self, n: u32) -> Result<Mat, LibISLError> {
114        let mat = self;
115        let isl_rs_ctx = mat.get_ctx();
116        let mut mat = mat;
117        mat.do_not_free_on_drop();
118        let mat = mat.ptr;
119        let isl_rs_result = unsafe { isl_mat_add_rows(mat, n) };
120        let isl_rs_result = Mat { ptr: isl_rs_result,
121                                  should_free_on_drop: true };
122        let err = isl_rs_ctx.last_error();
123        if err != Error::None_ {
124            let err_msg = isl_rs_ctx.last_error_msg();
125            isl_rs_ctx.reset_error();
126            return Err(LibISLError::new(err, err_msg));
127        }
128        Ok(isl_rs_result)
129    }
130
131    /// Wraps `isl_mat_add_zero_cols`.
132    pub fn add_zero_cols(self, n: u32) -> Result<Mat, LibISLError> {
133        let mat = self;
134        let isl_rs_ctx = mat.get_ctx();
135        let mut mat = mat;
136        mat.do_not_free_on_drop();
137        let mat = mat.ptr;
138        let isl_rs_result = unsafe { isl_mat_add_zero_cols(mat, n) };
139        let isl_rs_result = Mat { ptr: isl_rs_result,
140                                  should_free_on_drop: true };
141        let err = isl_rs_ctx.last_error();
142        if err != Error::None_ {
143            let err_msg = isl_rs_ctx.last_error_msg();
144            isl_rs_ctx.reset_error();
145            return Err(LibISLError::new(err, err_msg));
146        }
147        Ok(isl_rs_result)
148    }
149
150    /// Wraps `isl_mat_add_zero_rows`.
151    pub fn add_zero_rows(self, n: u32) -> Result<Mat, LibISLError> {
152        let mat = self;
153        let isl_rs_ctx = mat.get_ctx();
154        let mut mat = mat;
155        mat.do_not_free_on_drop();
156        let mat = mat.ptr;
157        let isl_rs_result = unsafe { isl_mat_add_zero_rows(mat, n) };
158        let isl_rs_result = Mat { ptr: isl_rs_result,
159                                  should_free_on_drop: true };
160        let err = isl_rs_ctx.last_error();
161        if err != Error::None_ {
162            let err_msg = isl_rs_ctx.last_error_msg();
163            isl_rs_ctx.reset_error();
164            return Err(LibISLError::new(err, err_msg));
165        }
166        Ok(isl_rs_result)
167    }
168
169    /// Wraps `isl_mat_aff_direct_sum`.
170    pub fn aff_direct_sum(self, right: Mat) -> Result<Mat, LibISLError> {
171        let left = self;
172        let isl_rs_ctx = left.get_ctx();
173        let mut left = left;
174        left.do_not_free_on_drop();
175        let left = left.ptr;
176        let mut right = right;
177        right.do_not_free_on_drop();
178        let right = right.ptr;
179        let isl_rs_result = unsafe { isl_mat_aff_direct_sum(left, right) };
180        let isl_rs_result = Mat { ptr: isl_rs_result,
181                                  should_free_on_drop: true };
182        let err = isl_rs_ctx.last_error();
183        if err != Error::None_ {
184            let err_msg = isl_rs_ctx.last_error_msg();
185            isl_rs_ctx.reset_error();
186            return Err(LibISLError::new(err, err_msg));
187        }
188        Ok(isl_rs_result)
189    }
190
191    /// Wraps `isl_mat_alloc`.
192    pub fn alloc(ctx: &Context, n_row: u32, n_col: u32) -> Result<Mat, LibISLError> {
193        let isl_rs_ctx = Context { ptr: ctx.ptr,
194                                   should_free_on_drop: false };
195        let ctx = ctx.ptr;
196        let isl_rs_result = unsafe { isl_mat_alloc(ctx, n_row, n_col) };
197        let isl_rs_result = Mat { ptr: isl_rs_result,
198                                  should_free_on_drop: true };
199        let err = isl_rs_ctx.last_error();
200        if err != Error::None_ {
201            let err_msg = isl_rs_ctx.last_error_msg();
202            isl_rs_ctx.reset_error();
203            return Err(LibISLError::new(err, err_msg));
204        }
205        Ok(isl_rs_result)
206    }
207
208    /// Wraps `isl_mat_col_add`.
209    pub fn col_add(&self, dst_col: i32, src_col: i32) -> Result<(), LibISLError> {
210        let mat = self;
211        let isl_rs_ctx = mat.get_ctx();
212        let mat = mat.ptr;
213        let isl_rs_result = unsafe { isl_mat_col_add(mat, dst_col, src_col) };
214        let err = isl_rs_ctx.last_error();
215        if err != Error::None_ {
216            let err_msg = isl_rs_ctx.last_error_msg();
217            isl_rs_ctx.reset_error();
218            return Err(LibISLError::new(err, err_msg));
219        }
220        Ok(isl_rs_result)
221    }
222
223    /// Wraps `isl_mat_cols`.
224    pub fn cols(&self) -> Result<i32, LibISLError> {
225        let mat = self;
226        let isl_rs_ctx = mat.get_ctx();
227        let mat = mat.ptr;
228        let isl_rs_result = unsafe { isl_mat_cols(mat) };
229        let err = isl_rs_ctx.last_error();
230        if err != Error::None_ {
231            let err_msg = isl_rs_ctx.last_error_msg();
232            isl_rs_ctx.reset_error();
233            return Err(LibISLError::new(err, err_msg));
234        }
235        Ok(isl_rs_result)
236    }
237
238    /// Wraps `isl_mat_concat`.
239    pub fn concat(self, bot: Mat) -> Result<Mat, LibISLError> {
240        let top = self;
241        let isl_rs_ctx = top.get_ctx();
242        let mut top = top;
243        top.do_not_free_on_drop();
244        let top = top.ptr;
245        let mut bot = bot;
246        bot.do_not_free_on_drop();
247        let bot = bot.ptr;
248        let isl_rs_result = unsafe { isl_mat_concat(top, bot) };
249        let isl_rs_result = Mat { ptr: isl_rs_result,
250                                  should_free_on_drop: true };
251        let err = isl_rs_ctx.last_error();
252        if err != Error::None_ {
253            let err_msg = isl_rs_ctx.last_error_msg();
254            isl_rs_ctx.reset_error();
255            return Err(LibISLError::new(err, err_msg));
256        }
257        Ok(isl_rs_result)
258    }
259
260    /// Wraps `isl_mat_copy`.
261    pub fn copy(&self) -> Result<Mat, LibISLError> {
262        let mat = self;
263        let isl_rs_ctx = mat.get_ctx();
264        let mat = mat.ptr;
265        let isl_rs_result = unsafe { isl_mat_copy(mat) };
266        let isl_rs_result = Mat { ptr: isl_rs_result,
267                                  should_free_on_drop: true };
268        let err = isl_rs_ctx.last_error();
269        if err != Error::None_ {
270            let err_msg = isl_rs_ctx.last_error_msg();
271            isl_rs_ctx.reset_error();
272            return Err(LibISLError::new(err, err_msg));
273        }
274        Ok(isl_rs_result)
275    }
276
277    /// Wraps `isl_mat_diagonal`.
278    pub fn diagonal(self, mat2: Mat) -> Result<Mat, LibISLError> {
279        let mat1 = self;
280        let isl_rs_ctx = mat1.get_ctx();
281        let mut mat1 = mat1;
282        mat1.do_not_free_on_drop();
283        let mat1 = mat1.ptr;
284        let mut mat2 = mat2;
285        mat2.do_not_free_on_drop();
286        let mat2 = mat2.ptr;
287        let isl_rs_result = unsafe { isl_mat_diagonal(mat1, mat2) };
288        let isl_rs_result = Mat { ptr: isl_rs_result,
289                                  should_free_on_drop: true };
290        let err = isl_rs_ctx.last_error();
291        if err != Error::None_ {
292            let err_msg = isl_rs_ctx.last_error_msg();
293            isl_rs_ctx.reset_error();
294            return Err(LibISLError::new(err, err_msg));
295        }
296        Ok(isl_rs_result)
297    }
298
299    /// Wraps `isl_mat_drop_cols`.
300    pub fn drop_cols(self, col: u32, n: u32) -> Result<Mat, LibISLError> {
301        let mat = self;
302        let isl_rs_ctx = mat.get_ctx();
303        let mut mat = mat;
304        mat.do_not_free_on_drop();
305        let mat = mat.ptr;
306        let isl_rs_result = unsafe { isl_mat_drop_cols(mat, col, n) };
307        let isl_rs_result = Mat { ptr: isl_rs_result,
308                                  should_free_on_drop: true };
309        let err = isl_rs_ctx.last_error();
310        if err != Error::None_ {
311            let err_msg = isl_rs_ctx.last_error_msg();
312            isl_rs_ctx.reset_error();
313            return Err(LibISLError::new(err, err_msg));
314        }
315        Ok(isl_rs_result)
316    }
317
318    /// Wraps `isl_mat_drop_rows`.
319    pub fn drop_rows(self, row: u32, n: u32) -> Result<Mat, LibISLError> {
320        let mat = self;
321        let isl_rs_ctx = mat.get_ctx();
322        let mut mat = mat;
323        mat.do_not_free_on_drop();
324        let mat = mat.ptr;
325        let isl_rs_result = unsafe { isl_mat_drop_rows(mat, row, n) };
326        let isl_rs_result = Mat { ptr: isl_rs_result,
327                                  should_free_on_drop: true };
328        let err = isl_rs_ctx.last_error();
329        if err != Error::None_ {
330            let err_msg = isl_rs_ctx.last_error_msg();
331            isl_rs_ctx.reset_error();
332            return Err(LibISLError::new(err, err_msg));
333        }
334        Ok(isl_rs_result)
335    }
336
337    /// Wraps `isl_mat_dump`.
338    pub fn dump(&self) -> Result<(), LibISLError> {
339        let mat = self;
340        let isl_rs_ctx = mat.get_ctx();
341        let mat = mat.ptr;
342        let isl_rs_result = unsafe { isl_mat_dump(mat) };
343        let err = isl_rs_ctx.last_error();
344        if err != Error::None_ {
345            let err_msg = isl_rs_ctx.last_error_msg();
346            isl_rs_ctx.reset_error();
347            return Err(LibISLError::new(err, err_msg));
348        }
349        Ok(isl_rs_result)
350    }
351
352    /// Wraps `isl_mat_extend`.
353    pub fn extend(self, n_row: u32, n_col: u32) -> Result<Mat, LibISLError> {
354        let mat = self;
355        let isl_rs_ctx = mat.get_ctx();
356        let mut mat = mat;
357        mat.do_not_free_on_drop();
358        let mat = mat.ptr;
359        let isl_rs_result = unsafe { isl_mat_extend(mat, n_row, n_col) };
360        let isl_rs_result = Mat { ptr: isl_rs_result,
361                                  should_free_on_drop: true };
362        let err = isl_rs_ctx.last_error();
363        if err != Error::None_ {
364            let err_msg = isl_rs_ctx.last_error_msg();
365            isl_rs_ctx.reset_error();
366            return Err(LibISLError::new(err, err_msg));
367        }
368        Ok(isl_rs_result)
369    }
370
371    /// Wraps `isl_mat_free`.
372    pub fn free(self) -> Result<Mat, LibISLError> {
373        let mat = self;
374        let isl_rs_ctx = mat.get_ctx();
375        let mut mat = mat;
376        mat.do_not_free_on_drop();
377        let mat = mat.ptr;
378        let isl_rs_result = unsafe { isl_mat_free(mat) };
379        let isl_rs_result = Mat { ptr: isl_rs_result,
380                                  should_free_on_drop: true };
381        let err = isl_rs_ctx.last_error();
382        if err != Error::None_ {
383            let err_msg = isl_rs_ctx.last_error_msg();
384            isl_rs_ctx.reset_error();
385            return Err(LibISLError::new(err, err_msg));
386        }
387        Ok(isl_rs_result)
388    }
389
390    /// Wraps `isl_mat_from_row_vec`.
391    pub fn from_row_vec(vec: Vec) -> Result<Mat, LibISLError> {
392        let isl_rs_ctx = vec.get_ctx();
393        let mut vec = vec;
394        vec.do_not_free_on_drop();
395        let vec = vec.ptr;
396        let isl_rs_result = unsafe { isl_mat_from_row_vec(vec) };
397        let isl_rs_result = Mat { ptr: isl_rs_result,
398                                  should_free_on_drop: true };
399        let err = isl_rs_ctx.last_error();
400        if err != Error::None_ {
401            let err_msg = isl_rs_ctx.last_error_msg();
402            isl_rs_ctx.reset_error();
403            return Err(LibISLError::new(err, err_msg));
404        }
405        Ok(isl_rs_result)
406    }
407
408    /// Wraps `isl_mat_get_ctx`.
409    pub fn get_ctx(&self) -> Context {
410        let mat = self;
411        let mat = mat.ptr;
412        let isl_rs_result = unsafe { isl_mat_get_ctx(mat) };
413        let isl_rs_result = Context { ptr: isl_rs_result,
414                                      should_free_on_drop: false };
415        isl_rs_result
416    }
417
418    /// Wraps `isl_mat_get_element_val`.
419    pub fn get_element_val(&self, row: i32, col: i32) -> Result<Val, LibISLError> {
420        let mat = self;
421        let isl_rs_ctx = mat.get_ctx();
422        let mat = mat.ptr;
423        let isl_rs_result = unsafe { isl_mat_get_element_val(mat, row, col) };
424        let isl_rs_result = Val { ptr: isl_rs_result,
425                                  should_free_on_drop: true };
426        let err = isl_rs_ctx.last_error();
427        if err != Error::None_ {
428            let err_msg = isl_rs_ctx.last_error_msg();
429            isl_rs_ctx.reset_error();
430            return Err(LibISLError::new(err, err_msg));
431        }
432        Ok(isl_rs_result)
433    }
434
435    /// Wraps `isl_mat_has_linearly_independent_rows`.
436    pub fn has_linearly_independent_rows(&self, mat2: &Mat) -> Result<bool, LibISLError> {
437        let mat1 = self;
438        let isl_rs_ctx = mat1.get_ctx();
439        let mat1 = mat1.ptr;
440        let mat2 = mat2.ptr;
441        let isl_rs_result = unsafe { isl_mat_has_linearly_independent_rows(mat1, mat2) };
442        let isl_rs_result = match isl_rs_result {
443            0 => false,
444            1 => true,
445            _ => {
446                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
447            }
448        };
449        let err = isl_rs_ctx.last_error();
450        if err != Error::None_ {
451            let err_msg = isl_rs_ctx.last_error_msg();
452            isl_rs_ctx.reset_error();
453            return Err(LibISLError::new(err, err_msg));
454        }
455        Ok(isl_rs_result)
456    }
457
458    /// Wraps `isl_mat_identity`.
459    pub fn identity(ctx: &Context, n_row: u32) -> Result<Mat, LibISLError> {
460        let isl_rs_ctx = Context { ptr: ctx.ptr,
461                                   should_free_on_drop: false };
462        let ctx = ctx.ptr;
463        let isl_rs_result = unsafe { isl_mat_identity(ctx, n_row) };
464        let isl_rs_result = Mat { ptr: isl_rs_result,
465                                  should_free_on_drop: true };
466        let err = isl_rs_ctx.last_error();
467        if err != Error::None_ {
468            let err_msg = isl_rs_ctx.last_error_msg();
469            isl_rs_ctx.reset_error();
470            return Err(LibISLError::new(err, err_msg));
471        }
472        Ok(isl_rs_result)
473    }
474
475    /// Wraps `isl_mat_initial_non_zero_cols`.
476    pub fn initial_non_zero_cols(&self) -> Result<i32, LibISLError> {
477        let mat = self;
478        let isl_rs_ctx = mat.get_ctx();
479        let mat = mat.ptr;
480        let isl_rs_result = unsafe { isl_mat_initial_non_zero_cols(mat) };
481        let err = isl_rs_ctx.last_error();
482        if err != Error::None_ {
483            let err_msg = isl_rs_ctx.last_error_msg();
484            isl_rs_ctx.reset_error();
485            return Err(LibISLError::new(err, err_msg));
486        }
487        Ok(isl_rs_result)
488    }
489
490    /// Wraps `isl_mat_insert_cols`.
491    pub fn insert_cols(self, col: u32, n: u32) -> Result<Mat, LibISLError> {
492        let mat = self;
493        let isl_rs_ctx = mat.get_ctx();
494        let mut mat = mat;
495        mat.do_not_free_on_drop();
496        let mat = mat.ptr;
497        let isl_rs_result = unsafe { isl_mat_insert_cols(mat, col, n) };
498        let isl_rs_result = Mat { ptr: isl_rs_result,
499                                  should_free_on_drop: true };
500        let err = isl_rs_ctx.last_error();
501        if err != Error::None_ {
502            let err_msg = isl_rs_ctx.last_error_msg();
503            isl_rs_ctx.reset_error();
504            return Err(LibISLError::new(err, err_msg));
505        }
506        Ok(isl_rs_result)
507    }
508
509    /// Wraps `isl_mat_insert_rows`.
510    pub fn insert_rows(self, row: u32, n: u32) -> Result<Mat, LibISLError> {
511        let mat = self;
512        let isl_rs_ctx = mat.get_ctx();
513        let mut mat = mat;
514        mat.do_not_free_on_drop();
515        let mat = mat.ptr;
516        let isl_rs_result = unsafe { isl_mat_insert_rows(mat, row, n) };
517        let isl_rs_result = Mat { ptr: isl_rs_result,
518                                  should_free_on_drop: true };
519        let err = isl_rs_ctx.last_error();
520        if err != Error::None_ {
521            let err_msg = isl_rs_ctx.last_error_msg();
522            isl_rs_ctx.reset_error();
523            return Err(LibISLError::new(err, err_msg));
524        }
525        Ok(isl_rs_result)
526    }
527
528    /// Wraps `isl_mat_insert_zero_cols`.
529    pub fn insert_zero_cols(self, first: u32, n: u32) -> Result<Mat, LibISLError> {
530        let mat = self;
531        let isl_rs_ctx = mat.get_ctx();
532        let mut mat = mat;
533        mat.do_not_free_on_drop();
534        let mat = mat.ptr;
535        let isl_rs_result = unsafe { isl_mat_insert_zero_cols(mat, first, n) };
536        let isl_rs_result = Mat { ptr: isl_rs_result,
537                                  should_free_on_drop: true };
538        let err = isl_rs_ctx.last_error();
539        if err != Error::None_ {
540            let err_msg = isl_rs_ctx.last_error_msg();
541            isl_rs_ctx.reset_error();
542            return Err(LibISLError::new(err, err_msg));
543        }
544        Ok(isl_rs_result)
545    }
546
547    /// Wraps `isl_mat_insert_zero_rows`.
548    pub fn insert_zero_rows(self, row: u32, n: u32) -> Result<Mat, LibISLError> {
549        let mat = self;
550        let isl_rs_ctx = mat.get_ctx();
551        let mut mat = mat;
552        mat.do_not_free_on_drop();
553        let mat = mat.ptr;
554        let isl_rs_result = unsafe { isl_mat_insert_zero_rows(mat, row, n) };
555        let isl_rs_result = Mat { ptr: isl_rs_result,
556                                  should_free_on_drop: true };
557        let err = isl_rs_ctx.last_error();
558        if err != Error::None_ {
559            let err_msg = isl_rs_ctx.last_error_msg();
560            isl_rs_ctx.reset_error();
561            return Err(LibISLError::new(err, err_msg));
562        }
563        Ok(isl_rs_result)
564    }
565
566    /// Wraps `isl_mat_inverse_product`.
567    pub fn inverse_product(self, right: Mat) -> Result<Mat, LibISLError> {
568        let left = self;
569        let isl_rs_ctx = left.get_ctx();
570        let mut left = left;
571        left.do_not_free_on_drop();
572        let left = left.ptr;
573        let mut right = right;
574        right.do_not_free_on_drop();
575        let right = right.ptr;
576        let isl_rs_result = unsafe { isl_mat_inverse_product(left, right) };
577        let isl_rs_result = Mat { ptr: isl_rs_result,
578                                  should_free_on_drop: true };
579        let err = isl_rs_ctx.last_error();
580        if err != Error::None_ {
581            let err_msg = isl_rs_ctx.last_error_msg();
582            isl_rs_ctx.reset_error();
583            return Err(LibISLError::new(err, err_msg));
584        }
585        Ok(isl_rs_result)
586    }
587
588    /// Wraps `isl_mat_is_equal`.
589    pub fn is_equal(&self, mat2: &Mat) -> Result<bool, LibISLError> {
590        let mat1 = self;
591        let isl_rs_ctx = mat1.get_ctx();
592        let mat1 = mat1.ptr;
593        let mat2 = mat2.ptr;
594        let isl_rs_result = unsafe { isl_mat_is_equal(mat1, mat2) };
595        let isl_rs_result = match isl_rs_result {
596            0 => false,
597            1 => true,
598            _ => {
599                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
600            }
601        };
602        let err = isl_rs_ctx.last_error();
603        if err != Error::None_ {
604            let err_msg = isl_rs_ctx.last_error_msg();
605            isl_rs_ctx.reset_error();
606            return Err(LibISLError::new(err, err_msg));
607        }
608        Ok(isl_rs_result)
609    }
610
611    /// Wraps `isl_mat_lin_to_aff`.
612    pub fn lin_to_aff(self) -> Result<Mat, LibISLError> {
613        let mat = self;
614        let isl_rs_ctx = mat.get_ctx();
615        let mut mat = mat;
616        mat.do_not_free_on_drop();
617        let mat = mat.ptr;
618        let isl_rs_result = unsafe { isl_mat_lin_to_aff(mat) };
619        let isl_rs_result = Mat { ptr: isl_rs_result,
620                                  should_free_on_drop: true };
621        let err = isl_rs_ctx.last_error();
622        if err != Error::None_ {
623            let err_msg = isl_rs_ctx.last_error_msg();
624            isl_rs_ctx.reset_error();
625            return Err(LibISLError::new(err, err_msg));
626        }
627        Ok(isl_rs_result)
628    }
629
630    /// Wraps `isl_mat_move_cols`.
631    pub fn move_cols(self, dst_col: u32, src_col: u32, n: u32) -> Result<Mat, LibISLError> {
632        let mat = self;
633        let isl_rs_ctx = mat.get_ctx();
634        let mut mat = mat;
635        mat.do_not_free_on_drop();
636        let mat = mat.ptr;
637        let isl_rs_result = unsafe { isl_mat_move_cols(mat, dst_col, src_col, n) };
638        let isl_rs_result = Mat { ptr: isl_rs_result,
639                                  should_free_on_drop: true };
640        let err = isl_rs_ctx.last_error();
641        if err != Error::None_ {
642            let err_msg = isl_rs_ctx.last_error_msg();
643            isl_rs_ctx.reset_error();
644            return Err(LibISLError::new(err, err_msg));
645        }
646        Ok(isl_rs_result)
647    }
648
649    /// Wraps `isl_mat_normalize`.
650    pub fn normalize(self) -> Result<Mat, LibISLError> {
651        let mat = self;
652        let isl_rs_ctx = mat.get_ctx();
653        let mut mat = mat;
654        mat.do_not_free_on_drop();
655        let mat = mat.ptr;
656        let isl_rs_result = unsafe { isl_mat_normalize(mat) };
657        let isl_rs_result = Mat { ptr: isl_rs_result,
658                                  should_free_on_drop: true };
659        let err = isl_rs_ctx.last_error();
660        if err != Error::None_ {
661            let err_msg = isl_rs_ctx.last_error_msg();
662            isl_rs_ctx.reset_error();
663            return Err(LibISLError::new(err, err_msg));
664        }
665        Ok(isl_rs_result)
666    }
667
668    /// Wraps `isl_mat_normalize_row`.
669    pub fn normalize_row(self, row: i32) -> Result<Mat, LibISLError> {
670        let mat = self;
671        let isl_rs_ctx = mat.get_ctx();
672        let mut mat = mat;
673        mat.do_not_free_on_drop();
674        let mat = mat.ptr;
675        let isl_rs_result = unsafe { isl_mat_normalize_row(mat, row) };
676        let isl_rs_result = Mat { ptr: isl_rs_result,
677                                  should_free_on_drop: true };
678        let err = isl_rs_ctx.last_error();
679        if err != Error::None_ {
680            let err_msg = isl_rs_ctx.last_error_msg();
681            isl_rs_ctx.reset_error();
682            return Err(LibISLError::new(err, err_msg));
683        }
684        Ok(isl_rs_result)
685    }
686
687    /// Wraps `isl_mat_product`.
688    pub fn product(self, right: Mat) -> Result<Mat, LibISLError> {
689        let left = self;
690        let isl_rs_ctx = left.get_ctx();
691        let mut left = left;
692        left.do_not_free_on_drop();
693        let left = left.ptr;
694        let mut right = right;
695        right.do_not_free_on_drop();
696        let right = right.ptr;
697        let isl_rs_result = unsafe { isl_mat_product(left, right) };
698        let isl_rs_result = Mat { ptr: isl_rs_result,
699                                  should_free_on_drop: true };
700        let err = isl_rs_ctx.last_error();
701        if err != Error::None_ {
702            let err_msg = isl_rs_ctx.last_error_msg();
703            isl_rs_ctx.reset_error();
704            return Err(LibISLError::new(err, err_msg));
705        }
706        Ok(isl_rs_result)
707    }
708
709    /// Wraps `isl_mat_rank`.
710    pub fn rank(&self) -> Result<i32, LibISLError> {
711        let mat = self;
712        let isl_rs_ctx = mat.get_ctx();
713        let mat = mat.ptr;
714        let isl_rs_result = unsafe { isl_mat_rank(mat) };
715        let err = isl_rs_ctx.last_error();
716        if err != Error::None_ {
717            let err_msg = isl_rs_ctx.last_error_msg();
718            isl_rs_ctx.reset_error();
719            return Err(LibISLError::new(err, err_msg));
720        }
721        Ok(isl_rs_result)
722    }
723
724    /// Wraps `isl_mat_right_inverse`.
725    pub fn right_inverse(self) -> Result<Mat, LibISLError> {
726        let mat = self;
727        let isl_rs_ctx = mat.get_ctx();
728        let mut mat = mat;
729        mat.do_not_free_on_drop();
730        let mat = mat.ptr;
731        let isl_rs_result = unsafe { isl_mat_right_inverse(mat) };
732        let isl_rs_result = Mat { ptr: isl_rs_result,
733                                  should_free_on_drop: true };
734        let err = isl_rs_ctx.last_error();
735        if err != Error::None_ {
736            let err_msg = isl_rs_ctx.last_error_msg();
737            isl_rs_ctx.reset_error();
738            return Err(LibISLError::new(err, err_msg));
739        }
740        Ok(isl_rs_result)
741    }
742
743    /// Wraps `isl_mat_right_kernel`.
744    pub fn right_kernel(self) -> Result<Mat, LibISLError> {
745        let mat = self;
746        let isl_rs_ctx = mat.get_ctx();
747        let mut mat = mat;
748        mat.do_not_free_on_drop();
749        let mat = mat.ptr;
750        let isl_rs_result = unsafe { isl_mat_right_kernel(mat) };
751        let isl_rs_result = Mat { ptr: isl_rs_result,
752                                  should_free_on_drop: true };
753        let err = isl_rs_ctx.last_error();
754        if err != Error::None_ {
755            let err_msg = isl_rs_ctx.last_error_msg();
756            isl_rs_ctx.reset_error();
757            return Err(LibISLError::new(err, err_msg));
758        }
759        Ok(isl_rs_result)
760    }
761
762    /// Wraps `isl_mat_row_basis`.
763    pub fn row_basis(self) -> Result<Mat, LibISLError> {
764        let mat = self;
765        let isl_rs_ctx = mat.get_ctx();
766        let mut mat = mat;
767        mat.do_not_free_on_drop();
768        let mat = mat.ptr;
769        let isl_rs_result = unsafe { isl_mat_row_basis(mat) };
770        let isl_rs_result = Mat { ptr: isl_rs_result,
771                                  should_free_on_drop: true };
772        let err = isl_rs_ctx.last_error();
773        if err != Error::None_ {
774            let err_msg = isl_rs_ctx.last_error_msg();
775            isl_rs_ctx.reset_error();
776            return Err(LibISLError::new(err, err_msg));
777        }
778        Ok(isl_rs_result)
779    }
780
781    /// Wraps `isl_mat_row_basis_extension`.
782    pub fn row_basis_extension(self, mat2: Mat) -> Result<Mat, LibISLError> {
783        let mat1 = self;
784        let isl_rs_ctx = mat1.get_ctx();
785        let mut mat1 = mat1;
786        mat1.do_not_free_on_drop();
787        let mat1 = mat1.ptr;
788        let mut mat2 = mat2;
789        mat2.do_not_free_on_drop();
790        let mat2 = mat2.ptr;
791        let isl_rs_result = unsafe { isl_mat_row_basis_extension(mat1, mat2) };
792        let isl_rs_result = Mat { ptr: isl_rs_result,
793                                  should_free_on_drop: true };
794        let err = isl_rs_ctx.last_error();
795        if err != Error::None_ {
796            let err_msg = isl_rs_ctx.last_error_msg();
797            isl_rs_ctx.reset_error();
798            return Err(LibISLError::new(err, err_msg));
799        }
800        Ok(isl_rs_result)
801    }
802
803    /// Wraps `isl_mat_rows`.
804    pub fn rows(&self) -> Result<i32, LibISLError> {
805        let mat = self;
806        let isl_rs_ctx = mat.get_ctx();
807        let mat = mat.ptr;
808        let isl_rs_result = unsafe { isl_mat_rows(mat) };
809        let err = isl_rs_ctx.last_error();
810        if err != Error::None_ {
811            let err_msg = isl_rs_ctx.last_error_msg();
812            isl_rs_ctx.reset_error();
813            return Err(LibISLError::new(err, err_msg));
814        }
815        Ok(isl_rs_result)
816    }
817
818    /// Wraps `isl_mat_set_element_si`.
819    pub fn set_element_si(self, row: i32, col: i32, v: i32) -> Result<Mat, LibISLError> {
820        let mat = self;
821        let isl_rs_ctx = mat.get_ctx();
822        let mut mat = mat;
823        mat.do_not_free_on_drop();
824        let mat = mat.ptr;
825        let isl_rs_result = unsafe { isl_mat_set_element_si(mat, row, col, v) };
826        let isl_rs_result = Mat { ptr: isl_rs_result,
827                                  should_free_on_drop: true };
828        let err = isl_rs_ctx.last_error();
829        if err != Error::None_ {
830            let err_msg = isl_rs_ctx.last_error_msg();
831            isl_rs_ctx.reset_error();
832            return Err(LibISLError::new(err, err_msg));
833        }
834        Ok(isl_rs_result)
835    }
836
837    /// Wraps `isl_mat_set_element_val`.
838    pub fn set_element_val(self, row: i32, col: i32, v: Val) -> Result<Mat, LibISLError> {
839        let mat = self;
840        let isl_rs_ctx = mat.get_ctx();
841        let mut mat = mat;
842        mat.do_not_free_on_drop();
843        let mat = mat.ptr;
844        let mut v = v;
845        v.do_not_free_on_drop();
846        let v = v.ptr;
847        let isl_rs_result = unsafe { isl_mat_set_element_val(mat, row, col, v) };
848        let isl_rs_result = Mat { ptr: isl_rs_result,
849                                  should_free_on_drop: true };
850        let err = isl_rs_ctx.last_error();
851        if err != Error::None_ {
852            let err_msg = isl_rs_ctx.last_error_msg();
853            isl_rs_ctx.reset_error();
854            return Err(LibISLError::new(err, err_msg));
855        }
856        Ok(isl_rs_result)
857    }
858
859    /// Wraps `isl_mat_swap_cols`.
860    pub fn swap_cols(self, i: u32, j: u32) -> Result<Mat, LibISLError> {
861        let mat = self;
862        let isl_rs_ctx = mat.get_ctx();
863        let mut mat = mat;
864        mat.do_not_free_on_drop();
865        let mat = mat.ptr;
866        let isl_rs_result = unsafe { isl_mat_swap_cols(mat, i, j) };
867        let isl_rs_result = Mat { ptr: isl_rs_result,
868                                  should_free_on_drop: true };
869        let err = isl_rs_ctx.last_error();
870        if err != Error::None_ {
871            let err_msg = isl_rs_ctx.last_error_msg();
872            isl_rs_ctx.reset_error();
873            return Err(LibISLError::new(err, err_msg));
874        }
875        Ok(isl_rs_result)
876    }
877
878    /// Wraps `isl_mat_swap_rows`.
879    pub fn swap_rows(self, i: u32, j: u32) -> Result<Mat, LibISLError> {
880        let mat = self;
881        let isl_rs_ctx = mat.get_ctx();
882        let mut mat = mat;
883        mat.do_not_free_on_drop();
884        let mat = mat.ptr;
885        let isl_rs_result = unsafe { isl_mat_swap_rows(mat, i, j) };
886        let isl_rs_result = Mat { ptr: isl_rs_result,
887                                  should_free_on_drop: true };
888        let err = isl_rs_ctx.last_error();
889        if err != Error::None_ {
890            let err_msg = isl_rs_ctx.last_error_msg();
891            isl_rs_ctx.reset_error();
892            return Err(LibISLError::new(err, err_msg));
893        }
894        Ok(isl_rs_result)
895    }
896
897    /// Wraps `isl_mat_transpose`.
898    pub fn transpose(self) -> Result<Mat, LibISLError> {
899        let mat = self;
900        let isl_rs_ctx = mat.get_ctx();
901        let mut mat = mat;
902        mat.do_not_free_on_drop();
903        let mat = mat.ptr;
904        let isl_rs_result = unsafe { isl_mat_transpose(mat) };
905        let isl_rs_result = Mat { ptr: isl_rs_result,
906                                  should_free_on_drop: true };
907        let err = isl_rs_ctx.last_error();
908        if err != Error::None_ {
909            let err_msg = isl_rs_ctx.last_error_msg();
910            isl_rs_ctx.reset_error();
911            return Err(LibISLError::new(err, err_msg));
912        }
913        Ok(isl_rs_result)
914    }
915
916    /// Wraps `isl_mat_unimodular_complete`.
917    pub fn unimodular_complete(self, row: i32) -> Result<Mat, LibISLError> {
918        let M = self;
919        let isl_rs_ctx = M.get_ctx();
920        let mut M = M;
921        M.do_not_free_on_drop();
922        let M = M.ptr;
923        let isl_rs_result = unsafe { isl_mat_unimodular_complete(M, row) };
924        let isl_rs_result = Mat { ptr: isl_rs_result,
925                                  should_free_on_drop: true };
926        let err = isl_rs_ctx.last_error();
927        if err != Error::None_ {
928            let err_msg = isl_rs_ctx.last_error_msg();
929            isl_rs_ctx.reset_error();
930            return Err(LibISLError::new(err, err_msg));
931        }
932        Ok(isl_rs_result)
933    }
934
935    /// Wraps `isl_mat_vec_concat`.
936    pub fn vec_concat(self, bot: Vec) -> Result<Mat, LibISLError> {
937        let top = self;
938        let isl_rs_ctx = top.get_ctx();
939        let mut top = top;
940        top.do_not_free_on_drop();
941        let top = top.ptr;
942        let mut bot = bot;
943        bot.do_not_free_on_drop();
944        let bot = bot.ptr;
945        let isl_rs_result = unsafe { isl_mat_vec_concat(top, bot) };
946        let isl_rs_result = Mat { ptr: isl_rs_result,
947                                  should_free_on_drop: true };
948        let err = isl_rs_ctx.last_error();
949        if err != Error::None_ {
950            let err_msg = isl_rs_ctx.last_error_msg();
951            isl_rs_ctx.reset_error();
952            return Err(LibISLError::new(err, err_msg));
953        }
954        Ok(isl_rs_result)
955    }
956
957    /// Wraps `isl_mat_vec_inverse_product`.
958    pub fn vec_inverse_product(self, vec: Vec) -> Result<Vec, LibISLError> {
959        let mat = self;
960        let isl_rs_ctx = mat.get_ctx();
961        let mut mat = mat;
962        mat.do_not_free_on_drop();
963        let mat = mat.ptr;
964        let mut vec = vec;
965        vec.do_not_free_on_drop();
966        let vec = vec.ptr;
967        let isl_rs_result = unsafe { isl_mat_vec_inverse_product(mat, vec) };
968        let isl_rs_result = Vec { ptr: isl_rs_result,
969                                  should_free_on_drop: true };
970        let err = isl_rs_ctx.last_error();
971        if err != Error::None_ {
972            let err_msg = isl_rs_ctx.last_error_msg();
973            isl_rs_ctx.reset_error();
974            return Err(LibISLError::new(err, err_msg));
975        }
976        Ok(isl_rs_result)
977    }
978
979    /// Wraps `isl_mat_vec_product`.
980    pub fn vec_product(self, vec: Vec) -> Result<Vec, LibISLError> {
981        let mat = self;
982        let isl_rs_ctx = mat.get_ctx();
983        let mut mat = mat;
984        mat.do_not_free_on_drop();
985        let mat = mat.ptr;
986        let mut vec = vec;
987        vec.do_not_free_on_drop();
988        let vec = vec.ptr;
989        let isl_rs_result = unsafe { isl_mat_vec_product(mat, vec) };
990        let isl_rs_result = Vec { ptr: isl_rs_result,
991                                  should_free_on_drop: true };
992        let err = isl_rs_ctx.last_error();
993        if err != Error::None_ {
994            let err_msg = isl_rs_ctx.last_error_msg();
995            isl_rs_ctx.reset_error();
996            return Err(LibISLError::new(err, err_msg));
997        }
998        Ok(isl_rs_result)
999    }
1000
1001    /// Does not call isl_mat_free() on being dropped. (For internal use only.)
1002    pub fn do_not_free_on_drop(&mut self) {
1003        self.should_free_on_drop = false;
1004    }
1005}
1006
1007impl Drop for Mat {
1008    fn drop(&mut self) {
1009        if self.should_free_on_drop {
1010            unsafe {
1011                isl_mat_free(self.ptr);
1012            }
1013        }
1014    }
1015}
isl_rs/bindings/mat.rs

isl_rs/bindings/
mat.rs
