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            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
125        }
126        Ok(isl_rs_result)
127    }
128
129    /// Wraps `isl_mat_add_zero_cols`.
130    pub fn add_zero_cols(self, n: u32) -> Result<Mat, LibISLError> {
131        let mat = self;
132        let isl_rs_ctx = mat.get_ctx();
133        let mut mat = mat;
134        mat.do_not_free_on_drop();
135        let mat = mat.ptr;
136        let isl_rs_result = unsafe { isl_mat_add_zero_cols(mat, n) };
137        let isl_rs_result = Mat { ptr: isl_rs_result,
138                                  should_free_on_drop: true };
139        let err = isl_rs_ctx.last_error();
140        if err != Error::None_ {
141            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
142        }
143        Ok(isl_rs_result)
144    }
145
146    /// Wraps `isl_mat_add_zero_rows`.
147    pub fn add_zero_rows(self, n: u32) -> Result<Mat, LibISLError> {
148        let mat = self;
149        let isl_rs_ctx = mat.get_ctx();
150        let mut mat = mat;
151        mat.do_not_free_on_drop();
152        let mat = mat.ptr;
153        let isl_rs_result = unsafe { isl_mat_add_zero_rows(mat, n) };
154        let isl_rs_result = Mat { ptr: isl_rs_result,
155                                  should_free_on_drop: true };
156        let err = isl_rs_ctx.last_error();
157        if err != Error::None_ {
158            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
159        }
160        Ok(isl_rs_result)
161    }
162
163    /// Wraps `isl_mat_aff_direct_sum`.
164    pub fn aff_direct_sum(self, right: Mat) -> Result<Mat, LibISLError> {
165        let left = self;
166        let isl_rs_ctx = left.get_ctx();
167        let mut left = left;
168        left.do_not_free_on_drop();
169        let left = left.ptr;
170        let mut right = right;
171        right.do_not_free_on_drop();
172        let right = right.ptr;
173        let isl_rs_result = unsafe { isl_mat_aff_direct_sum(left, right) };
174        let isl_rs_result = Mat { ptr: isl_rs_result,
175                                  should_free_on_drop: true };
176        let err = isl_rs_ctx.last_error();
177        if err != Error::None_ {
178            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
179        }
180        Ok(isl_rs_result)
181    }
182
183    /// Wraps `isl_mat_alloc`.
184    pub fn alloc(ctx: &Context, n_row: u32, n_col: u32) -> Result<Mat, LibISLError> {
185        let isl_rs_ctx = Context { ptr: ctx.ptr,
186                                   should_free_on_drop: false };
187        let ctx = ctx.ptr;
188        let isl_rs_result = unsafe { isl_mat_alloc(ctx, n_row, n_col) };
189        let isl_rs_result = Mat { ptr: isl_rs_result,
190                                  should_free_on_drop: true };
191        let err = isl_rs_ctx.last_error();
192        if err != Error::None_ {
193            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
194        }
195        Ok(isl_rs_result)
196    }
197
198    /// Wraps `isl_mat_col_add`.
199    pub fn col_add(&self, dst_col: i32, src_col: i32) -> Result<(), LibISLError> {
200        let mat = self;
201        let isl_rs_ctx = mat.get_ctx();
202        let mat = mat.ptr;
203        let isl_rs_result = unsafe { isl_mat_col_add(mat, dst_col, src_col) };
204        let err = isl_rs_ctx.last_error();
205        if err != Error::None_ {
206            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
207        }
208        Ok(isl_rs_result)
209    }
210
211    /// Wraps `isl_mat_cols`.
212    pub fn cols(&self) -> Result<i32, LibISLError> {
213        let mat = self;
214        let isl_rs_ctx = mat.get_ctx();
215        let mat = mat.ptr;
216        let isl_rs_result = unsafe { isl_mat_cols(mat) };
217        let err = isl_rs_ctx.last_error();
218        if err != Error::None_ {
219            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
220        }
221        Ok(isl_rs_result)
222    }
223
224    /// Wraps `isl_mat_concat`.
225    pub fn concat(self, bot: Mat) -> Result<Mat, LibISLError> {
226        let top = self;
227        let isl_rs_ctx = top.get_ctx();
228        let mut top = top;
229        top.do_not_free_on_drop();
230        let top = top.ptr;
231        let mut bot = bot;
232        bot.do_not_free_on_drop();
233        let bot = bot.ptr;
234        let isl_rs_result = unsafe { isl_mat_concat(top, bot) };
235        let isl_rs_result = Mat { ptr: isl_rs_result,
236                                  should_free_on_drop: true };
237        let err = isl_rs_ctx.last_error();
238        if err != Error::None_ {
239            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
240        }
241        Ok(isl_rs_result)
242    }
243
244    /// Wraps `isl_mat_copy`.
245    pub fn copy(&self) -> Result<Mat, LibISLError> {
246        let mat = self;
247        let isl_rs_ctx = mat.get_ctx();
248        let mat = mat.ptr;
249        let isl_rs_result = unsafe { isl_mat_copy(mat) };
250        let isl_rs_result = Mat { ptr: isl_rs_result,
251                                  should_free_on_drop: true };
252        let err = isl_rs_ctx.last_error();
253        if err != Error::None_ {
254            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
255        }
256        Ok(isl_rs_result)
257    }
258
259    /// Wraps `isl_mat_diagonal`.
260    pub fn diagonal(self, mat2: Mat) -> Result<Mat, LibISLError> {
261        let mat1 = self;
262        let isl_rs_ctx = mat1.get_ctx();
263        let mut mat1 = mat1;
264        mat1.do_not_free_on_drop();
265        let mat1 = mat1.ptr;
266        let mut mat2 = mat2;
267        mat2.do_not_free_on_drop();
268        let mat2 = mat2.ptr;
269        let isl_rs_result = unsafe { isl_mat_diagonal(mat1, mat2) };
270        let isl_rs_result = Mat { ptr: isl_rs_result,
271                                  should_free_on_drop: true };
272        let err = isl_rs_ctx.last_error();
273        if err != Error::None_ {
274            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
275        }
276        Ok(isl_rs_result)
277    }
278
279    /// Wraps `isl_mat_drop_cols`.
280    pub fn drop_cols(self, col: u32, n: u32) -> Result<Mat, LibISLError> {
281        let mat = self;
282        let isl_rs_ctx = mat.get_ctx();
283        let mut mat = mat;
284        mat.do_not_free_on_drop();
285        let mat = mat.ptr;
286        let isl_rs_result = unsafe { isl_mat_drop_cols(mat, col, n) };
287        let isl_rs_result = Mat { ptr: isl_rs_result,
288                                  should_free_on_drop: true };
289        let err = isl_rs_ctx.last_error();
290        if err != Error::None_ {
291            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
292        }
293        Ok(isl_rs_result)
294    }
295
296    /// Wraps `isl_mat_drop_rows`.
297    pub fn drop_rows(self, row: u32, n: u32) -> Result<Mat, LibISLError> {
298        let mat = self;
299        let isl_rs_ctx = mat.get_ctx();
300        let mut mat = mat;
301        mat.do_not_free_on_drop();
302        let mat = mat.ptr;
303        let isl_rs_result = unsafe { isl_mat_drop_rows(mat, row, n) };
304        let isl_rs_result = Mat { ptr: isl_rs_result,
305                                  should_free_on_drop: true };
306        let err = isl_rs_ctx.last_error();
307        if err != Error::None_ {
308            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
309        }
310        Ok(isl_rs_result)
311    }
312
313    /// Wraps `isl_mat_dump`.
314    pub fn dump(&self) -> Result<(), LibISLError> {
315        let mat = self;
316        let isl_rs_ctx = mat.get_ctx();
317        let mat = mat.ptr;
318        let isl_rs_result = unsafe { isl_mat_dump(mat) };
319        let err = isl_rs_ctx.last_error();
320        if err != Error::None_ {
321            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
322        }
323        Ok(isl_rs_result)
324    }
325
326    /// Wraps `isl_mat_extend`.
327    pub fn extend(self, n_row: u32, n_col: u32) -> Result<Mat, LibISLError> {
328        let mat = self;
329        let isl_rs_ctx = mat.get_ctx();
330        let mut mat = mat;
331        mat.do_not_free_on_drop();
332        let mat = mat.ptr;
333        let isl_rs_result = unsafe { isl_mat_extend(mat, n_row, n_col) };
334        let isl_rs_result = Mat { ptr: isl_rs_result,
335                                  should_free_on_drop: true };
336        let err = isl_rs_ctx.last_error();
337        if err != Error::None_ {
338            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
339        }
340        Ok(isl_rs_result)
341    }
342
343    /// Wraps `isl_mat_free`.
344    pub fn free(self) -> Result<Mat, LibISLError> {
345        let mat = self;
346        let isl_rs_ctx = mat.get_ctx();
347        let mut mat = mat;
348        mat.do_not_free_on_drop();
349        let mat = mat.ptr;
350        let isl_rs_result = unsafe { isl_mat_free(mat) };
351        let isl_rs_result = Mat { ptr: isl_rs_result,
352                                  should_free_on_drop: true };
353        let err = isl_rs_ctx.last_error();
354        if err != Error::None_ {
355            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
356        }
357        Ok(isl_rs_result)
358    }
359
360    /// Wraps `isl_mat_from_row_vec`.
361    pub fn from_row_vec(vec: Vec) -> Result<Mat, LibISLError> {
362        let isl_rs_ctx = vec.get_ctx();
363        let mut vec = vec;
364        vec.do_not_free_on_drop();
365        let vec = vec.ptr;
366        let isl_rs_result = unsafe { isl_mat_from_row_vec(vec) };
367        let isl_rs_result = Mat { ptr: isl_rs_result,
368                                  should_free_on_drop: true };
369        let err = isl_rs_ctx.last_error();
370        if err != Error::None_ {
371            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
372        }
373        Ok(isl_rs_result)
374    }
375
376    /// Wraps `isl_mat_get_ctx`.
377    pub fn get_ctx(&self) -> Context {
378        let mat = self;
379        let mat = mat.ptr;
380        let isl_rs_result = unsafe { isl_mat_get_ctx(mat) };
381        let isl_rs_result = Context { ptr: isl_rs_result,
382                                      should_free_on_drop: false };
383        isl_rs_result
384    }
385
386    /// Wraps `isl_mat_get_element_val`.
387    pub fn get_element_val(&self, row: i32, col: i32) -> Result<Val, LibISLError> {
388        let mat = self;
389        let isl_rs_ctx = mat.get_ctx();
390        let mat = mat.ptr;
391        let isl_rs_result = unsafe { isl_mat_get_element_val(mat, row, col) };
392        let isl_rs_result = Val { ptr: isl_rs_result,
393                                  should_free_on_drop: true };
394        let err = isl_rs_ctx.last_error();
395        if err != Error::None_ {
396            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
397        }
398        Ok(isl_rs_result)
399    }
400
401    /// Wraps `isl_mat_has_linearly_independent_rows`.
402    pub fn has_linearly_independent_rows(&self, mat2: &Mat) -> Result<bool, LibISLError> {
403        let mat1 = self;
404        let isl_rs_ctx = mat1.get_ctx();
405        let mat1 = mat1.ptr;
406        let mat2 = mat2.ptr;
407        let isl_rs_result = unsafe { isl_mat_has_linearly_independent_rows(mat1, mat2) };
408        let isl_rs_result = match isl_rs_result {
409            0 => false,
410            1 => true,
411            _ => panic!("Got isl_bool = -1"),
412        };
413        let err = isl_rs_ctx.last_error();
414        if err != Error::None_ {
415            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
416        }
417        Ok(isl_rs_result)
418    }
419
420    /// Wraps `isl_mat_identity`.
421    pub fn identity(ctx: &Context, n_row: u32) -> Result<Mat, LibISLError> {
422        let isl_rs_ctx = Context { ptr: ctx.ptr,
423                                   should_free_on_drop: false };
424        let ctx = ctx.ptr;
425        let isl_rs_result = unsafe { isl_mat_identity(ctx, n_row) };
426        let isl_rs_result = Mat { ptr: isl_rs_result,
427                                  should_free_on_drop: true };
428        let err = isl_rs_ctx.last_error();
429        if err != Error::None_ {
430            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
431        }
432        Ok(isl_rs_result)
433    }
434
435    /// Wraps `isl_mat_initial_non_zero_cols`.
436    pub fn initial_non_zero_cols(&self) -> Result<i32, LibISLError> {
437        let mat = self;
438        let isl_rs_ctx = mat.get_ctx();
439        let mat = mat.ptr;
440        let isl_rs_result = unsafe { isl_mat_initial_non_zero_cols(mat) };
441        let err = isl_rs_ctx.last_error();
442        if err != Error::None_ {
443            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
444        }
445        Ok(isl_rs_result)
446    }
447
448    /// Wraps `isl_mat_insert_cols`.
449    pub fn insert_cols(self, col: u32, n: u32) -> Result<Mat, LibISLError> {
450        let mat = self;
451        let isl_rs_ctx = mat.get_ctx();
452        let mut mat = mat;
453        mat.do_not_free_on_drop();
454        let mat = mat.ptr;
455        let isl_rs_result = unsafe { isl_mat_insert_cols(mat, col, n) };
456        let isl_rs_result = Mat { ptr: isl_rs_result,
457                                  should_free_on_drop: true };
458        let err = isl_rs_ctx.last_error();
459        if err != Error::None_ {
460            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
461        }
462        Ok(isl_rs_result)
463    }
464
465    /// Wraps `isl_mat_insert_rows`.
466    pub fn insert_rows(self, row: u32, n: u32) -> Result<Mat, LibISLError> {
467        let mat = self;
468        let isl_rs_ctx = mat.get_ctx();
469        let mut mat = mat;
470        mat.do_not_free_on_drop();
471        let mat = mat.ptr;
472        let isl_rs_result = unsafe { isl_mat_insert_rows(mat, row, n) };
473        let isl_rs_result = Mat { ptr: isl_rs_result,
474                                  should_free_on_drop: true };
475        let err = isl_rs_ctx.last_error();
476        if err != Error::None_ {
477            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
478        }
479        Ok(isl_rs_result)
480    }
481
482    /// Wraps `isl_mat_insert_zero_cols`.
483    pub fn insert_zero_cols(self, first: u32, n: u32) -> Result<Mat, LibISLError> {
484        let mat = self;
485        let isl_rs_ctx = mat.get_ctx();
486        let mut mat = mat;
487        mat.do_not_free_on_drop();
488        let mat = mat.ptr;
489        let isl_rs_result = unsafe { isl_mat_insert_zero_cols(mat, first, n) };
490        let isl_rs_result = Mat { ptr: isl_rs_result,
491                                  should_free_on_drop: true };
492        let err = isl_rs_ctx.last_error();
493        if err != Error::None_ {
494            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
495        }
496        Ok(isl_rs_result)
497    }
498
499    /// Wraps `isl_mat_insert_zero_rows`.
500    pub fn insert_zero_rows(self, row: u32, n: u32) -> Result<Mat, LibISLError> {
501        let mat = self;
502        let isl_rs_ctx = mat.get_ctx();
503        let mut mat = mat;
504        mat.do_not_free_on_drop();
505        let mat = mat.ptr;
506        let isl_rs_result = unsafe { isl_mat_insert_zero_rows(mat, row, n) };
507        let isl_rs_result = Mat { ptr: isl_rs_result,
508                                  should_free_on_drop: true };
509        let err = isl_rs_ctx.last_error();
510        if err != Error::None_ {
511            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
512        }
513        Ok(isl_rs_result)
514    }
515
516    /// Wraps `isl_mat_inverse_product`.
517    pub fn inverse_product(self, right: Mat) -> Result<Mat, LibISLError> {
518        let left = self;
519        let isl_rs_ctx = left.get_ctx();
520        let mut left = left;
521        left.do_not_free_on_drop();
522        let left = left.ptr;
523        let mut right = right;
524        right.do_not_free_on_drop();
525        let right = right.ptr;
526        let isl_rs_result = unsafe { isl_mat_inverse_product(left, right) };
527        let isl_rs_result = Mat { ptr: isl_rs_result,
528                                  should_free_on_drop: true };
529        let err = isl_rs_ctx.last_error();
530        if err != Error::None_ {
531            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
532        }
533        Ok(isl_rs_result)
534    }
535
536    /// Wraps `isl_mat_is_equal`.
537    pub fn is_equal(&self, mat2: &Mat) -> Result<bool, LibISLError> {
538        let mat1 = self;
539        let isl_rs_ctx = mat1.get_ctx();
540        let mat1 = mat1.ptr;
541        let mat2 = mat2.ptr;
542        let isl_rs_result = unsafe { isl_mat_is_equal(mat1, mat2) };
543        let isl_rs_result = match isl_rs_result {
544            0 => false,
545            1 => true,
546            _ => panic!("Got isl_bool = -1"),
547        };
548        let err = isl_rs_ctx.last_error();
549        if err != Error::None_ {
550            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
551        }
552        Ok(isl_rs_result)
553    }
554
555    /// Wraps `isl_mat_lin_to_aff`.
556    pub fn lin_to_aff(self) -> Result<Mat, LibISLError> {
557        let mat = self;
558        let isl_rs_ctx = mat.get_ctx();
559        let mut mat = mat;
560        mat.do_not_free_on_drop();
561        let mat = mat.ptr;
562        let isl_rs_result = unsafe { isl_mat_lin_to_aff(mat) };
563        let isl_rs_result = Mat { ptr: isl_rs_result,
564                                  should_free_on_drop: true };
565        let err = isl_rs_ctx.last_error();
566        if err != Error::None_ {
567            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
568        }
569        Ok(isl_rs_result)
570    }
571
572    /// Wraps `isl_mat_move_cols`.
573    pub fn move_cols(self, dst_col: u32, src_col: u32, n: u32) -> Result<Mat, LibISLError> {
574        let mat = self;
575        let isl_rs_ctx = mat.get_ctx();
576        let mut mat = mat;
577        mat.do_not_free_on_drop();
578        let mat = mat.ptr;
579        let isl_rs_result = unsafe { isl_mat_move_cols(mat, dst_col, src_col, n) };
580        let isl_rs_result = Mat { ptr: isl_rs_result,
581                                  should_free_on_drop: true };
582        let err = isl_rs_ctx.last_error();
583        if err != Error::None_ {
584            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
585        }
586        Ok(isl_rs_result)
587    }
588
589    /// Wraps `isl_mat_normalize`.
590    pub fn normalize(self) -> Result<Mat, LibISLError> {
591        let mat = self;
592        let isl_rs_ctx = mat.get_ctx();
593        let mut mat = mat;
594        mat.do_not_free_on_drop();
595        let mat = mat.ptr;
596        let isl_rs_result = unsafe { isl_mat_normalize(mat) };
597        let isl_rs_result = Mat { ptr: isl_rs_result,
598                                  should_free_on_drop: true };
599        let err = isl_rs_ctx.last_error();
600        if err != Error::None_ {
601            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
602        }
603        Ok(isl_rs_result)
604    }
605
606    /// Wraps `isl_mat_normalize_row`.
607    pub fn normalize_row(self, row: i32) -> Result<Mat, LibISLError> {
608        let mat = self;
609        let isl_rs_ctx = mat.get_ctx();
610        let mut mat = mat;
611        mat.do_not_free_on_drop();
612        let mat = mat.ptr;
613        let isl_rs_result = unsafe { isl_mat_normalize_row(mat, row) };
614        let isl_rs_result = Mat { ptr: isl_rs_result,
615                                  should_free_on_drop: true };
616        let err = isl_rs_ctx.last_error();
617        if err != Error::None_ {
618            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
619        }
620        Ok(isl_rs_result)
621    }
622
623    /// Wraps `isl_mat_product`.
624    pub fn product(self, right: Mat) -> Result<Mat, LibISLError> {
625        let left = self;
626        let isl_rs_ctx = left.get_ctx();
627        let mut left = left;
628        left.do_not_free_on_drop();
629        let left = left.ptr;
630        let mut right = right;
631        right.do_not_free_on_drop();
632        let right = right.ptr;
633        let isl_rs_result = unsafe { isl_mat_product(left, right) };
634        let isl_rs_result = Mat { ptr: isl_rs_result,
635                                  should_free_on_drop: true };
636        let err = isl_rs_ctx.last_error();
637        if err != Error::None_ {
638            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
639        }
640        Ok(isl_rs_result)
641    }
642
643    /// Wraps `isl_mat_rank`.
644    pub fn rank(&self) -> Result<i32, LibISLError> {
645        let mat = self;
646        let isl_rs_ctx = mat.get_ctx();
647        let mat = mat.ptr;
648        let isl_rs_result = unsafe { isl_mat_rank(mat) };
649        let err = isl_rs_ctx.last_error();
650        if err != Error::None_ {
651            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
652        }
653        Ok(isl_rs_result)
654    }
655
656    /// Wraps `isl_mat_right_inverse`.
657    pub fn right_inverse(self) -> Result<Mat, LibISLError> {
658        let mat = self;
659        let isl_rs_ctx = mat.get_ctx();
660        let mut mat = mat;
661        mat.do_not_free_on_drop();
662        let mat = mat.ptr;
663        let isl_rs_result = unsafe { isl_mat_right_inverse(mat) };
664        let isl_rs_result = Mat { ptr: isl_rs_result,
665                                  should_free_on_drop: true };
666        let err = isl_rs_ctx.last_error();
667        if err != Error::None_ {
668            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
669        }
670        Ok(isl_rs_result)
671    }
672
673    /// Wraps `isl_mat_right_kernel`.
674    pub fn right_kernel(self) -> Result<Mat, LibISLError> {
675        let mat = self;
676        let isl_rs_ctx = mat.get_ctx();
677        let mut mat = mat;
678        mat.do_not_free_on_drop();
679        let mat = mat.ptr;
680        let isl_rs_result = unsafe { isl_mat_right_kernel(mat) };
681        let isl_rs_result = Mat { ptr: isl_rs_result,
682                                  should_free_on_drop: true };
683        let err = isl_rs_ctx.last_error();
684        if err != Error::None_ {
685            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
686        }
687        Ok(isl_rs_result)
688    }
689
690    /// Wraps `isl_mat_row_basis`.
691    pub fn row_basis(self) -> Result<Mat, LibISLError> {
692        let mat = self;
693        let isl_rs_ctx = mat.get_ctx();
694        let mut mat = mat;
695        mat.do_not_free_on_drop();
696        let mat = mat.ptr;
697        let isl_rs_result = unsafe { isl_mat_row_basis(mat) };
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            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
703        }
704        Ok(isl_rs_result)
705    }
706
707    /// Wraps `isl_mat_row_basis_extension`.
708    pub fn row_basis_extension(self, mat2: Mat) -> Result<Mat, LibISLError> {
709        let mat1 = self;
710        let isl_rs_ctx = mat1.get_ctx();
711        let mut mat1 = mat1;
712        mat1.do_not_free_on_drop();
713        let mat1 = mat1.ptr;
714        let mut mat2 = mat2;
715        mat2.do_not_free_on_drop();
716        let mat2 = mat2.ptr;
717        let isl_rs_result = unsafe { isl_mat_row_basis_extension(mat1, mat2) };
718        let isl_rs_result = Mat { ptr: isl_rs_result,
719                                  should_free_on_drop: true };
720        let err = isl_rs_ctx.last_error();
721        if err != Error::None_ {
722            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
723        }
724        Ok(isl_rs_result)
725    }
726
727    /// Wraps `isl_mat_rows`.
728    pub fn rows(&self) -> Result<i32, LibISLError> {
729        let mat = self;
730        let isl_rs_ctx = mat.get_ctx();
731        let mat = mat.ptr;
732        let isl_rs_result = unsafe { isl_mat_rows(mat) };
733        let err = isl_rs_ctx.last_error();
734        if err != Error::None_ {
735            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
736        }
737        Ok(isl_rs_result)
738    }
739
740    /// Wraps `isl_mat_set_element_si`.
741    pub fn set_element_si(self, row: i32, col: i32, v: i32) -> Result<Mat, LibISLError> {
742        let mat = self;
743        let isl_rs_ctx = mat.get_ctx();
744        let mut mat = mat;
745        mat.do_not_free_on_drop();
746        let mat = mat.ptr;
747        let isl_rs_result = unsafe { isl_mat_set_element_si(mat, row, col, v) };
748        let isl_rs_result = Mat { 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    /// Wraps `isl_mat_set_element_val`.
758    pub fn set_element_val(self, row: i32, col: i32, v: Val) -> Result<Mat, LibISLError> {
759        let mat = self;
760        let isl_rs_ctx = mat.get_ctx();
761        let mut mat = mat;
762        mat.do_not_free_on_drop();
763        let mat = mat.ptr;
764        let mut v = v;
765        v.do_not_free_on_drop();
766        let v = v.ptr;
767        let isl_rs_result = unsafe { isl_mat_set_element_val(mat, row, col, v) };
768        let isl_rs_result = Mat { 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    /// Wraps `isl_mat_swap_cols`.
778    pub fn swap_cols(self, i: u32, j: u32) -> Result<Mat, LibISLError> {
779        let mat = self;
780        let isl_rs_ctx = mat.get_ctx();
781        let mut mat = mat;
782        mat.do_not_free_on_drop();
783        let mat = mat.ptr;
784        let isl_rs_result = unsafe { isl_mat_swap_cols(mat, i, j) };
785        let isl_rs_result = Mat { ptr: isl_rs_result,
786                                  should_free_on_drop: true };
787        let err = isl_rs_ctx.last_error();
788        if err != Error::None_ {
789            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
790        }
791        Ok(isl_rs_result)
792    }
793
794    /// Wraps `isl_mat_swap_rows`.
795    pub fn swap_rows(self, i: u32, j: u32) -> Result<Mat, LibISLError> {
796        let mat = self;
797        let isl_rs_ctx = mat.get_ctx();
798        let mut mat = mat;
799        mat.do_not_free_on_drop();
800        let mat = mat.ptr;
801        let isl_rs_result = unsafe { isl_mat_swap_rows(mat, i, j) };
802        let isl_rs_result = Mat { ptr: isl_rs_result,
803                                  should_free_on_drop: true };
804        let err = isl_rs_ctx.last_error();
805        if err != Error::None_ {
806            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
807        }
808        Ok(isl_rs_result)
809    }
810
811    /// Wraps `isl_mat_transpose`.
812    pub fn transpose(self) -> Result<Mat, LibISLError> {
813        let mat = self;
814        let isl_rs_ctx = mat.get_ctx();
815        let mut mat = mat;
816        mat.do_not_free_on_drop();
817        let mat = mat.ptr;
818        let isl_rs_result = unsafe { isl_mat_transpose(mat) };
819        let isl_rs_result = Mat { ptr: isl_rs_result,
820                                  should_free_on_drop: true };
821        let err = isl_rs_ctx.last_error();
822        if err != Error::None_ {
823            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
824        }
825        Ok(isl_rs_result)
826    }
827
828    /// Wraps `isl_mat_unimodular_complete`.
829    pub fn unimodular_complete(self, row: i32) -> Result<Mat, LibISLError> {
830        let M = self;
831        let isl_rs_ctx = M.get_ctx();
832        let mut M = M;
833        M.do_not_free_on_drop();
834        let M = M.ptr;
835        let isl_rs_result = unsafe { isl_mat_unimodular_complete(M, row) };
836        let isl_rs_result = Mat { ptr: isl_rs_result,
837                                  should_free_on_drop: true };
838        let err = isl_rs_ctx.last_error();
839        if err != Error::None_ {
840            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
841        }
842        Ok(isl_rs_result)
843    }
844
845    /// Wraps `isl_mat_vec_concat`.
846    pub fn vec_concat(self, bot: Vec) -> Result<Mat, LibISLError> {
847        let top = self;
848        let isl_rs_ctx = top.get_ctx();
849        let mut top = top;
850        top.do_not_free_on_drop();
851        let top = top.ptr;
852        let mut bot = bot;
853        bot.do_not_free_on_drop();
854        let bot = bot.ptr;
855        let isl_rs_result = unsafe { isl_mat_vec_concat(top, bot) };
856        let isl_rs_result = Mat { ptr: isl_rs_result,
857                                  should_free_on_drop: true };
858        let err = isl_rs_ctx.last_error();
859        if err != Error::None_ {
860            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
861        }
862        Ok(isl_rs_result)
863    }
864
865    /// Wraps `isl_mat_vec_inverse_product`.
866    pub fn vec_inverse_product(self, vec: Vec) -> Result<Vec, LibISLError> {
867        let mat = self;
868        let isl_rs_ctx = mat.get_ctx();
869        let mut mat = mat;
870        mat.do_not_free_on_drop();
871        let mat = mat.ptr;
872        let mut vec = vec;
873        vec.do_not_free_on_drop();
874        let vec = vec.ptr;
875        let isl_rs_result = unsafe { isl_mat_vec_inverse_product(mat, vec) };
876        let isl_rs_result = Vec { ptr: isl_rs_result,
877                                  should_free_on_drop: true };
878        let err = isl_rs_ctx.last_error();
879        if err != Error::None_ {
880            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
881        }
882        Ok(isl_rs_result)
883    }
884
885    /// Wraps `isl_mat_vec_product`.
886    pub fn vec_product(self, vec: Vec) -> Result<Vec, LibISLError> {
887        let mat = self;
888        let isl_rs_ctx = mat.get_ctx();
889        let mut mat = mat;
890        mat.do_not_free_on_drop();
891        let mat = mat.ptr;
892        let mut vec = vec;
893        vec.do_not_free_on_drop();
894        let vec = vec.ptr;
895        let isl_rs_result = unsafe { isl_mat_vec_product(mat, vec) };
896        let isl_rs_result = Vec { ptr: isl_rs_result,
897                                  should_free_on_drop: true };
898        let err = isl_rs_ctx.last_error();
899        if err != Error::None_ {
900            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
901        }
902        Ok(isl_rs_result)
903    }
904
905    /// Does not call isl_mat_free() on being dropped. (For internal use only.)
906    pub fn do_not_free_on_drop(&mut self) {
907        self.should_free_on_drop = false;
908    }
909}
910
911impl Drop for Mat {
912    fn drop(&mut self) {
913        if self.should_free_on_drop {
914            unsafe {
915                isl_mat_free(self.ptr);
916            }
917        }
918    }
919}
isl_rs/bindings/mat.rs

isl_rs/bindings/
mat.rs
