isl-rs 0.3.1

// Automatically generated by isl_bindings_generator.
// LICENSE: MIT

use super::{
    Aff, Constraint, Context, DimType, Error, LibISLError, Point, QPolynomialList, Set, Space,
    Term, Val,
};
use libc::uintptr_t;
use std::ffi::CString;
use std::os::raw::c_char;

/// Wraps `isl_qpolynomial`.
pub struct QPolynomial {
    pub ptr: uintptr_t,
    pub should_free_on_drop: bool,
}

extern "C" {

    fn isl_qpolynomial_add(qp1: uintptr_t, qp2: uintptr_t) -> uintptr_t;

    fn isl_qpolynomial_add_dims(qp: uintptr_t, type_: i32, n: u32) -> uintptr_t;

    fn isl_qpolynomial_align_params(qp: uintptr_t, model: uintptr_t) -> uintptr_t;

    fn isl_qpolynomial_as_aff(qp: uintptr_t) -> uintptr_t;

    fn isl_qpolynomial_copy(qp: uintptr_t) -> uintptr_t;

    fn isl_qpolynomial_dim(qp: uintptr_t, type_: i32) -> i32;

    fn isl_qpolynomial_domain_reverse(qp: uintptr_t) -> uintptr_t;

    fn isl_qpolynomial_drop_dims(qp: uintptr_t, type_: i32, first: u32, n: u32) -> uintptr_t;

    fn isl_qpolynomial_dump(qp: uintptr_t) -> ();

    fn isl_qpolynomial_eval(qp: uintptr_t, pnt: uintptr_t) -> uintptr_t;

    fn isl_qpolynomial_free(qp: uintptr_t) -> uintptr_t;

    fn isl_qpolynomial_from_aff(aff: uintptr_t) -> uintptr_t;

    fn isl_qpolynomial_from_constraint(c: uintptr_t, type_: i32, pos: u32) -> uintptr_t;

    fn isl_qpolynomial_from_term(term: uintptr_t) -> uintptr_t;

    fn isl_qpolynomial_get_constant_val(qp: uintptr_t) -> uintptr_t;

    fn isl_qpolynomial_get_ctx(qp: uintptr_t) -> uintptr_t;

    fn isl_qpolynomial_get_domain_space(qp: uintptr_t) -> uintptr_t;

    fn isl_qpolynomial_get_space(qp: uintptr_t) -> uintptr_t;

    fn isl_qpolynomial_gist(qp: uintptr_t, context: uintptr_t) -> uintptr_t;

    fn isl_qpolynomial_gist_params(qp: uintptr_t, context: uintptr_t) -> uintptr_t;

    fn isl_qpolynomial_homogenize(poly: uintptr_t) -> uintptr_t;

    fn isl_qpolynomial_infty_on_domain(domain: uintptr_t) -> uintptr_t;

    fn isl_qpolynomial_insert_dims(qp: uintptr_t, type_: i32, first: u32, n: u32) -> uintptr_t;

    fn isl_qpolynomial_involves_dims(qp: uintptr_t, type_: i32, first: u32, n: u32) -> i32;

    fn isl_qpolynomial_is_infty(qp: uintptr_t) -> i32;

    fn isl_qpolynomial_is_nan(qp: uintptr_t) -> i32;

    fn isl_qpolynomial_is_neginfty(qp: uintptr_t) -> i32;

    fn isl_qpolynomial_is_zero(qp: uintptr_t) -> i32;

    fn isl_qpolynomial_isa_aff(qp: uintptr_t) -> i32;

    fn isl_qpolynomial_move_dims(qp: uintptr_t, dst_type: i32, dst_pos: u32, src_type: i32,
                                 src_pos: u32, n: u32)
                                 -> uintptr_t;

    fn isl_qpolynomial_mul(qp1: uintptr_t, qp2: uintptr_t) -> uintptr_t;

    fn isl_qpolynomial_nan_on_domain(domain: uintptr_t) -> uintptr_t;

    fn isl_qpolynomial_neg(qp: uintptr_t) -> uintptr_t;

    fn isl_qpolynomial_neginfty_on_domain(domain: uintptr_t) -> uintptr_t;

    fn isl_qpolynomial_one_on_domain(domain: uintptr_t) -> uintptr_t;

    fn isl_qpolynomial_plain_is_equal(qp1: uintptr_t, qp2: uintptr_t) -> i32;

    fn isl_qpolynomial_pow(qp: uintptr_t, power: u32) -> uintptr_t;

    fn isl_qpolynomial_project_domain_on_params(qp: uintptr_t) -> uintptr_t;

    fn isl_qpolynomial_scale_down_val(qp: uintptr_t, v: uintptr_t) -> uintptr_t;

    fn isl_qpolynomial_scale_val(qp: uintptr_t, v: uintptr_t) -> uintptr_t;

    fn isl_qpolynomial_set_dim_name(qp: uintptr_t, type_: i32, pos: u32, s: *const c_char)
                                    -> uintptr_t;

    fn isl_qpolynomial_sgn(qp: uintptr_t) -> i32;

    fn isl_qpolynomial_sub(qp1: uintptr_t, qp2: uintptr_t) -> uintptr_t;

    fn isl_qpolynomial_to_list(el: uintptr_t) -> uintptr_t;

    fn isl_qpolynomial_val_on_domain(space: uintptr_t, val: uintptr_t) -> uintptr_t;

    fn isl_qpolynomial_var_on_domain(domain: uintptr_t, type_: i32, pos: u32) -> uintptr_t;

    fn isl_qpolynomial_zero_on_domain(domain: uintptr_t) -> uintptr_t;

}

impl QPolynomial {
    /// Wraps `isl_qpolynomial_add`.
    pub fn add(self, qp2: QPolynomial) -> Result<QPolynomial, LibISLError> {
        let qp1 = self;
        let isl_rs_ctx = qp1.get_ctx();
        let mut qp1 = qp1;
        qp1.do_not_free_on_drop();
        let qp1 = qp1.ptr;
        let mut qp2 = qp2;
        qp2.do_not_free_on_drop();
        let qp2 = qp2.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_add(qp1, qp2) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_add_dims`.
    pub fn add_dims(self, type_: DimType, n: u32) -> Result<QPolynomial, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let mut qp = qp;
        qp.do_not_free_on_drop();
        let qp = qp.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_qpolynomial_add_dims(qp, type_, n) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_align_params`.
    pub fn align_params(self, model: Space) -> Result<QPolynomial, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let mut qp = qp;
        qp.do_not_free_on_drop();
        let qp = qp.ptr;
        let mut model = model;
        model.do_not_free_on_drop();
        let model = model.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_align_params(qp, model) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_as_aff`.
    pub fn as_aff(self) -> Result<Aff, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let mut qp = qp;
        qp.do_not_free_on_drop();
        let qp = qp.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_as_aff(qp) };
        let isl_rs_result = Aff { ptr: isl_rs_result,
                                  should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_copy`.
    pub fn copy(&self) -> Result<QPolynomial, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let qp = qp.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_copy(qp) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_dim`.
    pub fn dim(&self, type_: DimType) -> Result<i32, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let qp = qp.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_qpolynomial_dim(qp, type_) };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_domain_reverse`.
    pub fn domain_reverse(self) -> Result<QPolynomial, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let mut qp = qp;
        qp.do_not_free_on_drop();
        let qp = qp.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_domain_reverse(qp) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_drop_dims`.
    pub fn drop_dims(self, type_: DimType, first: u32, n: u32) -> Result<QPolynomial, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let mut qp = qp;
        qp.do_not_free_on_drop();
        let qp = qp.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_qpolynomial_drop_dims(qp, type_, first, n) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_dump`.
    pub fn dump(&self) -> Result<(), LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let qp = qp.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_dump(qp) };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_eval`.
    pub fn eval(self, pnt: Point) -> Result<Val, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let mut qp = qp;
        qp.do_not_free_on_drop();
        let qp = qp.ptr;
        let mut pnt = pnt;
        pnt.do_not_free_on_drop();
        let pnt = pnt.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_eval(qp, pnt) };
        let isl_rs_result = Val { ptr: isl_rs_result,
                                  should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_free`.
    pub fn free(self) -> Result<QPolynomial, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let mut qp = qp;
        qp.do_not_free_on_drop();
        let qp = qp.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_free(qp) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_from_aff`.
    pub fn from_aff(aff: Aff) -> Result<QPolynomial, LibISLError> {
        let isl_rs_ctx = aff.get_ctx();
        let mut aff = aff;
        aff.do_not_free_on_drop();
        let aff = aff.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_from_aff(aff) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_from_constraint`.
    pub fn from_constraint(c: Constraint, type_: DimType, pos: u32)
                           -> Result<QPolynomial, LibISLError> {
        let isl_rs_ctx = c.get_ctx();
        let mut c = c;
        c.do_not_free_on_drop();
        let c = c.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_qpolynomial_from_constraint(c, type_, pos) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_from_term`.
    pub fn from_term(term: Term) -> Result<QPolynomial, LibISLError> {
        let isl_rs_ctx = term.get_ctx();
        let mut term = term;
        term.do_not_free_on_drop();
        let term = term.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_from_term(term) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_get_constant_val`.
    pub fn get_constant_val(&self) -> Result<Val, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let qp = qp.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_get_constant_val(qp) };
        let isl_rs_result = Val { ptr: isl_rs_result,
                                  should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_get_ctx`.
    pub fn get_ctx(&self) -> Context {
        let qp = self;
        let qp = qp.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_get_ctx(qp) };
        let isl_rs_result = Context { ptr: isl_rs_result,
                                      should_free_on_drop: false };
        isl_rs_result
    }

    /// Wraps `isl_qpolynomial_get_domain_space`.
    pub fn get_domain_space(&self) -> Result<Space, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let qp = qp.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_get_domain_space(qp) };
        let isl_rs_result = Space { ptr: isl_rs_result,
                                    should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_get_space`.
    pub fn get_space(&self) -> Result<Space, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let qp = qp.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_get_space(qp) };
        let isl_rs_result = Space { ptr: isl_rs_result,
                                    should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_gist`.
    pub fn gist(self, context: Set) -> Result<QPolynomial, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let mut qp = qp;
        qp.do_not_free_on_drop();
        let qp = qp.ptr;
        let mut context = context;
        context.do_not_free_on_drop();
        let context = context.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_gist(qp, context) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_gist_params`.
    pub fn gist_params(self, context: Set) -> Result<QPolynomial, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let mut qp = qp;
        qp.do_not_free_on_drop();
        let qp = qp.ptr;
        let mut context = context;
        context.do_not_free_on_drop();
        let context = context.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_gist_params(qp, context) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_homogenize`.
    pub fn homogenize(self) -> Result<QPolynomial, LibISLError> {
        let poly = self;
        let isl_rs_ctx = poly.get_ctx();
        let mut poly = poly;
        poly.do_not_free_on_drop();
        let poly = poly.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_homogenize(poly) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_infty_on_domain`.
    pub fn infty_on_domain(domain: Space) -> Result<QPolynomial, LibISLError> {
        let isl_rs_ctx = domain.get_ctx();
        let mut domain = domain;
        domain.do_not_free_on_drop();
        let domain = domain.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_infty_on_domain(domain) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_insert_dims`.
    pub fn insert_dims(self, type_: DimType, first: u32, n: u32)
                       -> Result<QPolynomial, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let mut qp = qp;
        qp.do_not_free_on_drop();
        let qp = qp.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_qpolynomial_insert_dims(qp, type_, first, n) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_involves_dims`.
    pub fn involves_dims(&self, type_: DimType, first: u32, n: u32) -> Result<bool, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let qp = qp.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_qpolynomial_involves_dims(qp, type_, first, n) };
        let isl_rs_result = match isl_rs_result {
            0 => false,
            1 => true,
            _ => {
                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
            }
        };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_is_infty`.
    pub fn is_infty(&self) -> Result<bool, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let qp = qp.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_is_infty(qp) };
        let isl_rs_result = match isl_rs_result {
            0 => false,
            1 => true,
            _ => {
                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
            }
        };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_is_nan`.
    pub fn is_nan(&self) -> Result<bool, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let qp = qp.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_is_nan(qp) };
        let isl_rs_result = match isl_rs_result {
            0 => false,
            1 => true,
            _ => {
                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
            }
        };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_is_neginfty`.
    pub fn is_neginfty(&self) -> Result<bool, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let qp = qp.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_is_neginfty(qp) };
        let isl_rs_result = match isl_rs_result {
            0 => false,
            1 => true,
            _ => {
                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
            }
        };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_is_zero`.
    pub fn is_zero(&self) -> Result<bool, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let qp = qp.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_is_zero(qp) };
        let isl_rs_result = match isl_rs_result {
            0 => false,
            1 => true,
            _ => {
                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
            }
        };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_isa_aff`.
    pub fn isa_aff(&self) -> Result<bool, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let qp = qp.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_isa_aff(qp) };
        let isl_rs_result = match isl_rs_result {
            0 => false,
            1 => true,
            _ => {
                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
            }
        };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_move_dims`.
    pub fn move_dims(self, dst_type: DimType, dst_pos: u32, src_type: DimType, src_pos: u32,
                     n: u32)
                     -> Result<QPolynomial, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let mut qp = qp;
        qp.do_not_free_on_drop();
        let qp = qp.ptr;
        let dst_type = dst_type.to_i32();
        let src_type = src_type.to_i32();
        let isl_rs_result =
            unsafe { isl_qpolynomial_move_dims(qp, dst_type, dst_pos, src_type, src_pos, n) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_mul`.
    pub fn mul(self, qp2: QPolynomial) -> Result<QPolynomial, LibISLError> {
        let qp1 = self;
        let isl_rs_ctx = qp1.get_ctx();
        let mut qp1 = qp1;
        qp1.do_not_free_on_drop();
        let qp1 = qp1.ptr;
        let mut qp2 = qp2;
        qp2.do_not_free_on_drop();
        let qp2 = qp2.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_mul(qp1, qp2) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_nan_on_domain`.
    pub fn nan_on_domain(domain: Space) -> Result<QPolynomial, LibISLError> {
        let isl_rs_ctx = domain.get_ctx();
        let mut domain = domain;
        domain.do_not_free_on_drop();
        let domain = domain.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_nan_on_domain(domain) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_neg`.
    pub fn neg(self) -> Result<QPolynomial, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let mut qp = qp;
        qp.do_not_free_on_drop();
        let qp = qp.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_neg(qp) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_neginfty_on_domain`.
    pub fn neginfty_on_domain(domain: Space) -> Result<QPolynomial, LibISLError> {
        let isl_rs_ctx = domain.get_ctx();
        let mut domain = domain;
        domain.do_not_free_on_drop();
        let domain = domain.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_neginfty_on_domain(domain) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_one_on_domain`.
    pub fn one_on_domain(domain: Space) -> Result<QPolynomial, LibISLError> {
        let isl_rs_ctx = domain.get_ctx();
        let mut domain = domain;
        domain.do_not_free_on_drop();
        let domain = domain.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_one_on_domain(domain) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_plain_is_equal`.
    pub fn plain_is_equal(&self, qp2: &QPolynomial) -> Result<bool, LibISLError> {
        let qp1 = self;
        let isl_rs_ctx = qp1.get_ctx();
        let qp1 = qp1.ptr;
        let qp2 = qp2.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_plain_is_equal(qp1, qp2) };
        let isl_rs_result = match isl_rs_result {
            0 => false,
            1 => true,
            _ => {
                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
            }
        };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_pow`.
    pub fn pow(self, power: u32) -> Result<QPolynomial, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let mut qp = qp;
        qp.do_not_free_on_drop();
        let qp = qp.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_pow(qp, power) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_project_domain_on_params`.
    pub fn project_domain_on_params(self) -> Result<QPolynomial, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let mut qp = qp;
        qp.do_not_free_on_drop();
        let qp = qp.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_project_domain_on_params(qp) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_scale_down_val`.
    pub fn scale_down_val(self, v: Val) -> Result<QPolynomial, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let mut qp = qp;
        qp.do_not_free_on_drop();
        let qp = qp.ptr;
        let mut v = v;
        v.do_not_free_on_drop();
        let v = v.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_scale_down_val(qp, v) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_scale_val`.
    pub fn scale_val(self, v: Val) -> Result<QPolynomial, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let mut qp = qp;
        qp.do_not_free_on_drop();
        let qp = qp.ptr;
        let mut v = v;
        v.do_not_free_on_drop();
        let v = v.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_scale_val(qp, v) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_set_dim_name`.
    pub fn set_dim_name(self, type_: DimType, pos: u32, s: &str)
                        -> Result<QPolynomial, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let mut qp = qp;
        qp.do_not_free_on_drop();
        let qp = qp.ptr;
        let type_ = type_.to_i32();
        let s = CString::new(s).unwrap();
        let s = s.as_ptr();
        let isl_rs_result = unsafe { isl_qpolynomial_set_dim_name(qp, type_, pos, s) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_sgn`.
    pub fn sgn(&self) -> Result<i32, LibISLError> {
        let qp = self;
        let isl_rs_ctx = qp.get_ctx();
        let qp = qp.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_sgn(qp) };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_sub`.
    pub fn sub(self, qp2: QPolynomial) -> Result<QPolynomial, LibISLError> {
        let qp1 = self;
        let isl_rs_ctx = qp1.get_ctx();
        let mut qp1 = qp1;
        qp1.do_not_free_on_drop();
        let qp1 = qp1.ptr;
        let mut qp2 = qp2;
        qp2.do_not_free_on_drop();
        let qp2 = qp2.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_sub(qp1, qp2) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_to_list`.
    pub fn to_list(self) -> Result<QPolynomialList, LibISLError> {
        let el = self;
        let isl_rs_ctx = el.get_ctx();
        let mut el = el;
        el.do_not_free_on_drop();
        let el = el.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_to_list(el) };
        let isl_rs_result = QPolynomialList { ptr: isl_rs_result,
                                              should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_val_on_domain`.
    pub fn val_on_domain(space: Space, val: Val) -> Result<QPolynomial, LibISLError> {
        let isl_rs_ctx = space.get_ctx();
        let mut space = space;
        space.do_not_free_on_drop();
        let space = space.ptr;
        let mut val = val;
        val.do_not_free_on_drop();
        let val = val.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_val_on_domain(space, val) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_var_on_domain`.
    pub fn var_on_domain(domain: Space, type_: DimType, pos: u32)
                         -> Result<QPolynomial, LibISLError> {
        let isl_rs_ctx = domain.get_ctx();
        let mut domain = domain;
        domain.do_not_free_on_drop();
        let domain = domain.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_qpolynomial_var_on_domain(domain, type_, pos) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_qpolynomial_zero_on_domain`.
    pub fn zero_on_domain(domain: Space) -> Result<QPolynomial, LibISLError> {
        let isl_rs_ctx = domain.get_ctx();
        let mut domain = domain;
        domain.do_not_free_on_drop();
        let domain = domain.ptr;
        let isl_rs_result = unsafe { isl_qpolynomial_zero_on_domain(domain) };
        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Does not call isl_qpolynomial_free() on being dropped. (For internal use
    /// only.)
    pub fn do_not_free_on_drop(&mut self) {
        self.should_free_on_drop = false;
    }
}

impl Drop for QPolynomial {
    fn drop(&mut self) {
        if self.should_free_on_drop {
            unsafe {
                isl_qpolynomial_free(self.ptr);
            }
        }
    }
}