apple-accelerate 0.3.1

// @generated by tools/raw-ffi-gen; do not edit by hand.

/* automatically generated by rust-bindgen 0.71.1 */

#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage> {
    storage: Storage,
}
impl<Storage> __BindgenBitfieldUnit<Storage> {
    #[inline]
    pub const fn new(storage: Storage) -> Self {
        Self { storage }
    }
}
impl<Storage> __BindgenBitfieldUnit<Storage>
where
    Storage: AsRef<[u8]> + AsMut<[u8]>,
{
    #[inline]
    fn extract_bit(byte: u8, index: usize) -> bool {
        let bit_index = if cfg!(target_endian = "big") {
            7 - (index % 8)
        } else {
            index % 8
        };
        let mask = 1 << bit_index;
        byte & mask == mask
    }
    #[inline]
    pub fn get_bit(&self, index: usize) -> bool {
        debug_assert!(index / 8 < self.storage.as_ref().len());
        let byte_index = index / 8;
        let byte = self.storage.as_ref()[byte_index];
        Self::extract_bit(byte, index)
    }
    #[inline]
    pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool {
        debug_assert!(index / 8 < core::mem::size_of::<Storage>());
        let byte_index = index / 8;
        let byte = *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize);
        Self::extract_bit(byte, index)
    }
    #[inline]
    fn change_bit(byte: u8, index: usize, val: bool) -> u8 {
        let bit_index = if cfg!(target_endian = "big") {
            7 - (index % 8)
        } else {
            index % 8
        };
        let mask = 1 << bit_index;
        if val {
            byte | mask
        } else {
            byte & !mask
        }
    }
    #[inline]
    pub fn set_bit(&mut self, index: usize, val: bool) {
        debug_assert!(index / 8 < self.storage.as_ref().len());
        let byte_index = index / 8;
        let byte = &mut self.storage.as_mut()[byte_index];
        *byte = Self::change_bit(*byte, index, val);
    }
    #[inline]
    pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
        debug_assert!(index / 8 < core::mem::size_of::<Storage>());
        let byte_index = index / 8;
        let byte =
            (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize);
        *byte = Self::change_bit(*byte, index, val);
    }
    #[inline]
    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
        let mut val = 0;
        for i in 0..(bit_width as usize) {
            if self.get_bit(i + bit_offset) {
                let index = if cfg!(target_endian = "big") {
                    bit_width as usize - 1 - i
                } else {
                    i
                };
                val |= 1 << index;
            }
        }
        val
    }
    #[inline]
    pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
        let mut val = 0;
        for i in 0..(bit_width as usize) {
            if Self::raw_get_bit(this, i + bit_offset) {
                let index = if cfg!(target_endian = "big") {
                    bit_width as usize - 1 - i
                } else {
                    i
                };
                val |= 1 << index;
            }
        }
        val
    }
    #[inline]
    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
        for i in 0..(bit_width as usize) {
            let mask = 1 << i;
            let val_bit_is_set = val & mask == mask;
            let index = if cfg!(target_endian = "big") {
                bit_width as usize - 1 - i
            } else {
                i
            };
            self.set_bit(index + bit_offset, val_bit_is_set);
        }
    }
    #[inline]
    pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
        for i in 0..(bit_width as usize) {
            let mask = 1 << i;
            let val_bit_is_set = val & mask == mask;
            let index = if cfg!(target_endian = "big") {
                bit_width as usize - 1 - i
            } else {
                i
            };
            Self::raw_set_bit(this, index + bit_offset, val_bit_is_set);
        }
    }
}
#[derive(PartialEq, Copy, Clone, Hash, Debug, Default)]
#[repr(C)]
pub struct __BindgenComplex<T> {
    pub re: T,
    pub im: T,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sparse_m_double {
    _unused: [u8; 0],
}
pub type sparse_matrix_double = *mut sparse_m_double;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sparse_m_float_complex {
    _unused: [u8; 0],
}
pub type sparse_matrix_float_complex = *mut sparse_m_float_complex;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sparse_m_double_complex {
    _unused: [u8; 0],
}
pub type sparse_matrix_double_complex = *mut sparse_m_double_complex;
pub const sparse_norm_SPARSE_NORM_ONE: sparse_norm = 171;
pub const sparse_norm_SPARSE_NORM_TWO: sparse_norm = 173;
pub const sparse_norm_SPARSE_NORM_INF: sparse_norm = 175;
pub const sparse_norm_SPARSE_NORM_R1: sparse_norm = 179;
pub type sparse_norm = ::core::ffi::c_uint;
pub const CBLAS_ORDER_CblasRowMajor: CBLAS_ORDER = 101;
pub const CBLAS_ORDER_CblasColMajor: CBLAS_ORDER = 102;
pub type CBLAS_ORDER = ::core::ffi::c_uint;
pub const CBLAS_TRANSPOSE_CblasNoTrans: CBLAS_TRANSPOSE = 111;
pub const CBLAS_TRANSPOSE_CblasTrans: CBLAS_TRANSPOSE = 112;
pub const CBLAS_TRANSPOSE_CblasConjTrans: CBLAS_TRANSPOSE = 113;
pub const CBLAS_TRANSPOSE_AtlasConj: CBLAS_TRANSPOSE = 114;
pub type CBLAS_TRANSPOSE = ::core::ffi::c_uint;
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_inner_product_dense_double(
        nz: sparse_dimension,
        x: *const f64,
        indx: *const sparse_index,
        y: *const f64,
        incy: sparse_stride,
    ) -> f64;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_inner_product_dense_float_complex(
        nz: sparse_dimension,
        x: *const __BindgenComplex<f32>,
        indx: *const sparse_index,
        y: *const __BindgenComplex<f32>,
        incy: sparse_stride,
    ) -> __BindgenComplex<f32>;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_inner_product_dense_double_complex(
        nz: sparse_dimension,
        x: *const __BindgenComplex<f64>,
        indx: *const sparse_index,
        y: *const __BindgenComplex<f64>,
        incy: sparse_stride,
    ) -> __BindgenComplex<f64>;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_inner_product_sparse_double(
        nzx: sparse_dimension,
        nzy: sparse_dimension,
        x: *const f64,
        indx: *const sparse_index,
        y: *const f64,
        indy: *const sparse_index,
    ) -> f64;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_inner_product_sparse_float_complex(
        nzx: sparse_dimension,
        nzy: sparse_dimension,
        x: *const __BindgenComplex<f32>,
        indx: *const sparse_index,
        y: *const __BindgenComplex<f32>,
        indy: *const sparse_index,
    ) -> __BindgenComplex<f32>;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_inner_product_sparse_double_complex(
        nzx: sparse_dimension,
        nzy: sparse_dimension,
        x: *const __BindgenComplex<f64>,
        indx: *const sparse_index,
        y: *const __BindgenComplex<f64>,
        indy: *const sparse_index,
    ) -> __BindgenComplex<f64>;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_vector_add_with_scale_dense_double(
        nz: sparse_dimension,
        alpha: f64,
        x: *const f64,
        indx: *const sparse_index,
        y: *mut f64,
        incy: sparse_stride,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_vector_add_with_scale_dense_float_complex(
        nz: sparse_dimension,
        alpha: __BindgenComplex<f32>,
        x: *const __BindgenComplex<f32>,
        indx: *const sparse_index,
        y: *mut __BindgenComplex<f32>,
        incy: sparse_stride,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_vector_add_with_scale_dense_double_complex(
        nz: sparse_dimension,
        alpha: __BindgenComplex<f64>,
        x: *const __BindgenComplex<f64>,
        indx: *const sparse_index,
        y: *mut __BindgenComplex<f64>,
        incy: sparse_stride,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_vector_norm_float(
        nz: sparse_dimension,
        x: *const f32,
        indx: *const sparse_index,
        norm: sparse_norm,
    ) -> f32;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_vector_norm_double(
        nz: sparse_dimension,
        x: *const f64,
        indx: *const sparse_index,
        norm: sparse_norm,
    ) -> f64;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_vector_norm_float_complex(
        nz: sparse_dimension,
        x: *const __BindgenComplex<f32>,
        indx: *const sparse_index,
        norm: sparse_norm,
    ) -> f32;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_vector_norm_double_complex(
        nz: sparse_dimension,
        x: *const __BindgenComplex<f64>,
        indx: *const sparse_index,
        norm: sparse_norm,
    ) -> f64;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_vector_product_dense_float(
        transa: CBLAS_TRANSPOSE,
        alpha: f32,
        A: sparse_matrix_float,
        x: *const f32,
        incx: sparse_stride,
        y: *mut f32,
        incy: sparse_stride,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_vector_product_dense_double(
        transa: CBLAS_TRANSPOSE,
        alpha: f64,
        A: sparse_matrix_double,
        x: *const f64,
        incx: sparse_stride,
        y: *mut f64,
        incy: sparse_stride,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_vector_product_dense_float_complex(
        transa: CBLAS_TRANSPOSE,
        alpha: __BindgenComplex<f32>,
        A: sparse_matrix_float_complex,
        x: *const __BindgenComplex<f32>,
        incx: sparse_stride,
        y: *mut __BindgenComplex<f32>,
        incy: sparse_stride,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_vector_product_dense_double_complex(
        transa: CBLAS_TRANSPOSE,
        alpha: __BindgenComplex<f64>,
        A: sparse_matrix_double_complex,
        x: *const __BindgenComplex<f64>,
        incx: sparse_stride,
        y: *mut __BindgenComplex<f64>,
        incy: sparse_stride,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_vector_triangular_solve_dense_double(
        transt: CBLAS_TRANSPOSE,
        alpha: f64,
        T: sparse_matrix_double,
        x: *mut f64,
        incx: sparse_stride,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_vector_triangular_solve_dense_float_complex(
        transt: CBLAS_TRANSPOSE,
        alpha: __BindgenComplex<f32>,
        T: sparse_matrix_float_complex,
        x: *mut __BindgenComplex<f32>,
        incx: sparse_stride,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_vector_triangular_solve_dense_double_complex(
        transt: CBLAS_TRANSPOSE,
        alpha: __BindgenComplex<f64>,
        T: sparse_matrix_double_complex,
        x: *mut __BindgenComplex<f64>,
        incx: sparse_stride,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_outer_product_dense_float(
        M: sparse_dimension,
        N: sparse_dimension,
        nz: sparse_dimension,
        alpha: f32,
        x: *const f32,
        incx: sparse_stride,
        y: *const f32,
        indy: *const sparse_index,
        C: *mut sparse_matrix_float,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_outer_product_dense_double(
        M: sparse_dimension,
        N: sparse_dimension,
        nz: sparse_dimension,
        alpha: f64,
        x: *const f64,
        incx: sparse_stride,
        y: *const f64,
        indy: *const sparse_index,
        C: *mut sparse_matrix_double,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_outer_product_dense_float_complex(
        M: sparse_dimension,
        N: sparse_dimension,
        nz: sparse_dimension,
        alpha: __BindgenComplex<f32>,
        x: *const __BindgenComplex<f32>,
        incx: sparse_stride,
        y: *const __BindgenComplex<f32>,
        indy: *const sparse_index,
        C: *mut sparse_matrix_float_complex,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_outer_product_dense_double_complex(
        M: sparse_dimension,
        N: sparse_dimension,
        nz: sparse_dimension,
        alpha: __BindgenComplex<f64>,
        x: *const __BindgenComplex<f64>,
        incx: sparse_stride,
        y: *const __BindgenComplex<f64>,
        indy: *const sparse_index,
        C: *mut sparse_matrix_double_complex,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_permute_rows_float(
        A: sparse_matrix_float,
        perm: *const sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_permute_rows_double(
        A: sparse_matrix_double,
        perm: *const sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_permute_rows_float_complex(
        A: sparse_matrix_float_complex,
        perm: *const sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_permute_rows_double_complex(
        A: sparse_matrix_double_complex,
        perm: *const sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_permute_cols_float(
        A: sparse_matrix_float,
        perm: *const sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_permute_cols_double(
        A: sparse_matrix_double,
        perm: *const sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_permute_cols_float_complex(
        A: sparse_matrix_float_complex,
        perm: *const sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_permute_cols_double_complex(
        A: sparse_matrix_double_complex,
        perm: *const sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_elementwise_norm_float(A: sparse_matrix_float, norm: sparse_norm) -> f32;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_elementwise_norm_double(A: sparse_matrix_double, norm: sparse_norm) -> f64;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_elementwise_norm_float_complex(
        A: sparse_matrix_float_complex,
        norm: sparse_norm,
    ) -> f32;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_elementwise_norm_double_complex(
        A: sparse_matrix_double_complex,
        norm: sparse_norm,
    ) -> f64;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_operator_norm_float(A: sparse_matrix_float, norm: sparse_norm) -> f32;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_operator_norm_double(A: sparse_matrix_double, norm: sparse_norm) -> f64;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_operator_norm_float_complex(
        A: sparse_matrix_float_complex,
        norm: sparse_norm,
    ) -> f32;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_operator_norm_double_complex(
        A: sparse_matrix_double_complex,
        norm: sparse_norm,
    ) -> f64;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_trace_float(A: sparse_matrix_float, offset: sparse_index) -> f32;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_trace_double(A: sparse_matrix_double, offset: sparse_index) -> f64;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_trace_float_complex(
        A: sparse_matrix_float_complex,
        offset: sparse_index,
    ) -> __BindgenComplex<f32>;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_trace_double_complex(
        A: sparse_matrix_double_complex,
        offset: sparse_index,
    ) -> __BindgenComplex<f64>;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_product_dense_float(
        order: CBLAS_ORDER,
        transa: CBLAS_TRANSPOSE,
        n: sparse_dimension,
        alpha: f32,
        A: sparse_matrix_float,
        B: *const f32,
        ldb: sparse_dimension,
        C: *mut f32,
        ldc: sparse_dimension,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_product_dense_double(
        order: CBLAS_ORDER,
        transa: CBLAS_TRANSPOSE,
        n: sparse_dimension,
        alpha: f64,
        A: sparse_matrix_double,
        B: *const f64,
        ldb: sparse_dimension,
        C: *mut f64,
        ldc: sparse_dimension,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_product_dense_float_complex(
        order: CBLAS_ORDER,
        transa: CBLAS_TRANSPOSE,
        n: sparse_dimension,
        alpha: __BindgenComplex<f32>,
        A: sparse_matrix_float_complex,
        B: *const __BindgenComplex<f32>,
        ldb: sparse_dimension,
        C: *mut __BindgenComplex<f32>,
        ldc: sparse_dimension,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_product_dense_double_complex(
        order: CBLAS_ORDER,
        transa: CBLAS_TRANSPOSE,
        n: sparse_dimension,
        alpha: __BindgenComplex<f64>,
        A: sparse_matrix_double_complex,
        B: *const __BindgenComplex<f64>,
        ldb: sparse_dimension,
        C: *mut __BindgenComplex<f64>,
        ldc: sparse_dimension,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_product_sparse_float(
        order: CBLAS_ORDER,
        transa: CBLAS_TRANSPOSE,
        alpha: f32,
        A: sparse_matrix_float,
        B: sparse_matrix_float,
        C: *mut f32,
        ldc: sparse_dimension,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_product_sparse_double(
        order: CBLAS_ORDER,
        transa: CBLAS_TRANSPOSE,
        alpha: f64,
        A: sparse_matrix_double,
        B: sparse_matrix_double,
        C: *mut f64,
        ldc: sparse_dimension,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_product_sparse_float_complex(
        order: CBLAS_ORDER,
        transa: CBLAS_TRANSPOSE,
        alpha: __BindgenComplex<f32>,
        A: sparse_matrix_float_complex,
        B: sparse_matrix_float_complex,
        C: *mut __BindgenComplex<f32>,
        ldc: sparse_dimension,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_product_sparse_double_complex(
        order: CBLAS_ORDER,
        transa: CBLAS_TRANSPOSE,
        alpha: __BindgenComplex<f64>,
        A: sparse_matrix_double_complex,
        B: sparse_matrix_double_complex,
        C: *mut __BindgenComplex<f64>,
        ldc: sparse_dimension,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_triangular_solve_dense_double(
        order: CBLAS_ORDER,
        transt: CBLAS_TRANSPOSE,
        nrhs: sparse_dimension,
        alpha: f64,
        T: sparse_matrix_double,
        B: *mut f64,
        ldb: sparse_dimension,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_triangular_solve_dense_float_complex(
        order: CBLAS_ORDER,
        transt: CBLAS_TRANSPOSE,
        nrhs: sparse_dimension,
        alpha: __BindgenComplex<f32>,
        T: sparse_matrix_float_complex,
        B: *mut __BindgenComplex<f32>,
        ldb: sparse_dimension,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_triangular_solve_dense_double_complex(
        order: CBLAS_ORDER,
        transt: CBLAS_TRANSPOSE,
        nrhs: sparse_dimension,
        alpha: __BindgenComplex<f64>,
        T: sparse_matrix_double_complex,
        B: *mut __BindgenComplex<f64>,
        ldb: sparse_dimension,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_create_double(
        M: sparse_dimension,
        N: sparse_dimension,
    ) -> sparse_matrix_double;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_create_float_complex(
        M: sparse_dimension,
        N: sparse_dimension,
    ) -> sparse_matrix_float_complex;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_create_double_complex(
        M: sparse_dimension,
        N: sparse_dimension,
    ) -> sparse_matrix_double_complex;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_insert_entry_double(
        A: sparse_matrix_double,
        val: f64,
        i: sparse_index,
        j: sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_insert_entry_float_complex(
        A: sparse_matrix_float_complex,
        val: __BindgenComplex<f32>,
        i: sparse_index,
        j: sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_insert_entry_double_complex(
        A: sparse_matrix_double_complex,
        val: __BindgenComplex<f64>,
        i: sparse_index,
        j: sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_insert_entries_float(
        A: sparse_matrix_float,
        N: sparse_dimension,
        val: *const f32,
        indx: *const sparse_index,
        jndx: *const sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_insert_entries_double(
        A: sparse_matrix_double,
        N: sparse_dimension,
        val: *const f64,
        indx: *const sparse_index,
        jndx: *const sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_insert_entries_float_complex(
        A: sparse_matrix_float_complex,
        N: sparse_dimension,
        val: *const __BindgenComplex<f32>,
        indx: *const sparse_index,
        jndx: *const sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_insert_entries_double_complex(
        A: sparse_matrix_double_complex,
        N: sparse_dimension,
        val: *const __BindgenComplex<f64>,
        indx: *const sparse_index,
        jndx: *const sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_insert_col_float(
        A: sparse_matrix_float,
        j: sparse_index,
        nz: sparse_dimension,
        val: *const f32,
        indx: *const sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_insert_col_double(
        A: sparse_matrix_double,
        j: sparse_index,
        nz: sparse_dimension,
        val: *const f64,
        indx: *const sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_insert_col_float_complex(
        A: sparse_matrix_float_complex,
        j: sparse_index,
        nz: sparse_dimension,
        val: *const __BindgenComplex<f32>,
        indx: *const sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_insert_col_double_complex(
        A: sparse_matrix_double_complex,
        j: sparse_index,
        nz: sparse_dimension,
        val: *const __BindgenComplex<f64>,
        indx: *const sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_insert_row_float(
        A: sparse_matrix_float,
        i: sparse_index,
        nz: sparse_dimension,
        val: *const f32,
        jndx: *const sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_insert_row_double(
        A: sparse_matrix_double,
        i: sparse_index,
        nz: sparse_dimension,
        val: *const f64,
        jndx: *const sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_insert_row_float_complex(
        A: sparse_matrix_float_complex,
        i: sparse_index,
        nz: sparse_dimension,
        val: *const __BindgenComplex<f32>,
        jndx: *const sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_insert_row_double_complex(
        A: sparse_matrix_double_complex,
        i: sparse_index,
        nz: sparse_dimension,
        val: *const __BindgenComplex<f64>,
        jndx: *const sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_extract_sparse_row_float(
        A: sparse_matrix_float,
        row: sparse_index,
        column_start: sparse_index,
        column_end: *mut sparse_index,
        nz: sparse_dimension,
        val: *mut f32,
        jndx: *mut sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_extract_sparse_row_double(
        A: sparse_matrix_double,
        row: sparse_index,
        column_start: sparse_index,
        column_end: *mut sparse_index,
        nz: sparse_dimension,
        val: *mut f64,
        jndx: *mut sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_extract_sparse_row_float_complex(
        A: sparse_matrix_float_complex,
        row: sparse_index,
        column_start: sparse_index,
        column_end: *mut sparse_index,
        nz: sparse_dimension,
        val: *mut __BindgenComplex<f32>,
        jndx: *mut sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_extract_sparse_row_double_complex(
        A: sparse_matrix_double_complex,
        row: sparse_index,
        column_start: sparse_index,
        column_end: *mut sparse_index,
        nz: sparse_dimension,
        val: *mut __BindgenComplex<f64>,
        jndx: *mut sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_extract_sparse_column_float(
        A: sparse_matrix_float,
        column: sparse_index,
        row_start: sparse_index,
        row_end: *mut sparse_index,
        nz: sparse_dimension,
        val: *mut f32,
        indx: *mut sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_extract_sparse_column_double(
        A: sparse_matrix_double,
        column: sparse_index,
        row_start: sparse_index,
        row_end: *mut sparse_index,
        nz: sparse_dimension,
        val: *mut f64,
        indx: *mut sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_extract_sparse_column_float_complex(
        A: sparse_matrix_float_complex,
        column: sparse_index,
        row_start: sparse_index,
        row_end: *mut sparse_index,
        nz: sparse_dimension,
        val: *mut __BindgenComplex<f32>,
        indx: *mut sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_extract_sparse_column_double_complex(
        A: sparse_matrix_double_complex,
        column: sparse_index,
        row_start: sparse_index,
        row_end: *mut sparse_index,
        nz: sparse_dimension,
        val: *mut __BindgenComplex<f64>,
        indx: *mut sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_block_create_float(
        Mb: sparse_dimension,
        Nb: sparse_dimension,
        k: sparse_dimension,
        l: sparse_dimension,
    ) -> sparse_matrix_float;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_block_create_double(
        Mb: sparse_dimension,
        Nb: sparse_dimension,
        k: sparse_dimension,
        l: sparse_dimension,
    ) -> sparse_matrix_double;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_block_create_float_complex(
        Mb: sparse_dimension,
        Nb: sparse_dimension,
        k: sparse_dimension,
        l: sparse_dimension,
    ) -> sparse_matrix_float_complex;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_block_create_double_complex(
        Mb: sparse_dimension,
        Nb: sparse_dimension,
        k: sparse_dimension,
        l: sparse_dimension,
    ) -> sparse_matrix_double_complex;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_variable_block_create_float(
        Mb: sparse_dimension,
        Nb: sparse_dimension,
        K: *const sparse_dimension,
        L: *const sparse_dimension,
    ) -> sparse_matrix_float;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_variable_block_create_double(
        Mb: sparse_dimension,
        Nb: sparse_dimension,
        K: *const sparse_dimension,
        L: *const sparse_dimension,
    ) -> sparse_matrix_double;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_variable_block_create_float_complex(
        Mb: sparse_dimension,
        Nb: sparse_dimension,
        K: *const sparse_dimension,
        L: *const sparse_dimension,
    ) -> sparse_matrix_float_complex;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_matrix_variable_block_create_double_complex(
        Mb: sparse_dimension,
        Nb: sparse_dimension,
        K: *const sparse_dimension,
        L: *const sparse_dimension,
    ) -> sparse_matrix_double_complex;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_insert_block_float(
        A: sparse_matrix_float,
        val: *const f32,
        row_stride: sparse_dimension,
        col_stride: sparse_dimension,
        bi: sparse_index,
        bj: sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_insert_block_double(
        A: sparse_matrix_double,
        val: *const f64,
        row_stride: sparse_dimension,
        col_stride: sparse_dimension,
        bi: sparse_index,
        bj: sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_insert_block_float_complex(
        A: sparse_matrix_float_complex,
        val: *const __BindgenComplex<f32>,
        row_stride: sparse_dimension,
        col_stride: sparse_dimension,
        bi: sparse_index,
        bj: sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_insert_block_double_complex(
        A: sparse_matrix_double_complex,
        val: *const __BindgenComplex<f64>,
        row_stride: sparse_dimension,
        col_stride: sparse_dimension,
        bi: sparse_index,
        bj: sparse_index,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_extract_block_float(
        A: sparse_matrix_float,
        bi: sparse_index,
        bj: sparse_index,
        row_stride: sparse_dimension,
        col_stride: sparse_dimension,
        val: *mut f32,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_extract_block_double(
        A: sparse_matrix_double,
        bi: sparse_index,
        bj: sparse_index,
        row_stride: sparse_dimension,
        col_stride: sparse_dimension,
        val: *mut f64,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_extract_block_float_complex(
        A: sparse_matrix_float_complex,
        bi: sparse_index,
        bj: sparse_index,
        row_stride: sparse_dimension,
        col_stride: sparse_dimension,
        val: *mut __BindgenComplex<f32>,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_extract_block_double_complex(
        A: sparse_matrix_double_complex,
        bi: sparse_index,
        bj: sparse_index,
        row_stride: sparse_dimension,
        col_stride: sparse_dimension,
        val: *mut __BindgenComplex<f64>,
    ) -> sparse_status;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_get_block_dimension_for_row(
        A: *mut ::core::ffi::c_void,
        i: sparse_index,
    ) -> ::core::ffi::c_long;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_get_block_dimension_for_col(
        A: *mut ::core::ffi::c_void,
        j: sparse_index,
    ) -> ::core::ffi::c_long;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_get_matrix_property(
        A: *mut ::core::ffi::c_void,
        pname: sparse_matrix_property,
    ) -> ::core::ffi::c_long;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_get_matrix_nonzero_count_for_row(
        A: *mut ::core::ffi::c_void,
        i: sparse_index,
    ) -> ::core::ffi::c_long;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_get_matrix_nonzero_count_for_column(
        A: *mut ::core::ffi::c_void,
        j: sparse_index,
    ) -> ::core::ffi::c_long;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_get_vector_nonzero_count_float(
        N: sparse_dimension,
        x: *const f32,
        incx: sparse_stride,
    ) -> ::core::ffi::c_long;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_get_vector_nonzero_count_double(
        N: sparse_dimension,
        x: *const f64,
        incx: sparse_stride,
    ) -> ::core::ffi::c_long;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_get_vector_nonzero_count_float_complex(
        N: sparse_dimension,
        x: *const __BindgenComplex<f32>,
        incx: sparse_stride,
    ) -> ::core::ffi::c_long;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_get_vector_nonzero_count_double_complex(
        N: sparse_dimension,
        x: *const __BindgenComplex<f64>,
        incx: sparse_stride,
    ) -> ::core::ffi::c_long;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_pack_vector_float(
        N: sparse_dimension,
        nz: sparse_dimension,
        x: *const f32,
        incx: sparse_stride,
        y: *mut f32,
        indy: *mut sparse_index,
    ) -> ::core::ffi::c_long;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_pack_vector_double(
        N: sparse_dimension,
        nz: sparse_dimension,
        x: *const f64,
        incx: sparse_stride,
        y: *mut f64,
        indy: *mut sparse_index,
    ) -> ::core::ffi::c_long;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_pack_vector_float_complex(
        N: sparse_dimension,
        nz: sparse_dimension,
        x: *const __BindgenComplex<f32>,
        incx: sparse_stride,
        y: *mut __BindgenComplex<f32>,
        indy: *mut sparse_index,
    ) -> ::core::ffi::c_long;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_pack_vector_double_complex(
        N: sparse_dimension,
        nz: sparse_dimension,
        x: *const __BindgenComplex<f64>,
        incx: sparse_stride,
        y: *mut __BindgenComplex<f64>,
        indy: *mut sparse_index,
    ) -> ::core::ffi::c_long;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_unpack_vector_float(
        N: sparse_dimension,
        nz: sparse_dimension,
        zero: bool,
        x: *const f32,
        indx: *const sparse_index,
        y: *mut f32,
        incy: sparse_stride,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_unpack_vector_double(
        N: sparse_dimension,
        nz: sparse_dimension,
        zero: bool,
        x: *const f64,
        indx: *const sparse_index,
        y: *mut f64,
        incy: sparse_stride,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_unpack_vector_float_complex(
        N: sparse_dimension,
        nz: sparse_dimension,
        zero: bool,
        x: *const __BindgenComplex<f32>,
        indx: *const sparse_index,
        y: *mut __BindgenComplex<f32>,
        incy: sparse_stride,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn sparse_unpack_vector_double_complex(
        N: sparse_dimension,
        nz: sparse_dimension,
        zero: bool,
        x: *const __BindgenComplex<f64>,
        indx: *const sparse_index,
        y: *mut __BindgenComplex<f64>,
        incy: sparse_stride,
    );
}
pub type __SPARSE_float_complex = __BindgenComplex<f32>;
pub type __SPARSE_double_complex = __BindgenComplex<f64>;
pub type SparseKind_t = ::core::ffi::c_uint;
pub type SparseTriangle_t = ::core::ffi::c_uchar;
#[repr(C)]
#[repr(align(4))]
#[derive(Debug, Default, Copy, Clone)]
pub struct SparseAttributes_t {
    pub _bitfield_align_1: [u16; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
    pub __bindgen_padding_0: u16,
}
impl SparseAttributes_t {
    #[inline]
    pub fn transpose(&self) -> bool {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_transpose(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::core::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn transpose_raw(this: *const Self) -> bool {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                0usize,
                1u8,
            ) as u8)
        }
    }
    #[inline]
    pub unsafe fn set_transpose_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn triangle(&self) -> SparseTriangle_t {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_triangle(&mut self, val: SparseTriangle_t) {
        unsafe {
            let val: u8 = ::core::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn triangle_raw(this: *const Self) -> SparseTriangle_t {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                1usize,
                1u8,
            ) as u8)
        }
    }
    #[inline]
    pub unsafe fn set_triangle_raw(this: *mut Self, val: SparseTriangle_t) {
        unsafe {
            let val: u8 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                1usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn kind(&self) -> SparseKind_t {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u32) }
    }
    #[inline]
    pub fn set_kind(&mut self, val: SparseKind_t) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(2usize, 2u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn kind_raw(this: *const Self) -> SparseKind_t {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                2usize,
                2u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_kind_raw(this: *mut Self, val: SparseKind_t) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                2usize,
                2u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn _reserved(&self) -> ::core::ffi::c_uint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 11u8) as u32) }
    }
    #[inline]
    pub fn set__reserved(&mut self, val: ::core::ffi::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(4usize, 11u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn _reserved_raw(this: *const Self) -> ::core::ffi::c_uint {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                4usize,
                11u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set__reserved_raw(this: *mut Self, val: ::core::ffi::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                4usize,
                11u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn _allocatedBySparse(&self) -> bool {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set__allocatedBySparse(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::core::mem::transmute(val);
            self._bitfield_1.set(15usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn _allocatedBySparse_raw(this: *const Self) -> bool {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                15usize,
                1u8,
            ) as u8)
        }
    }
    #[inline]
    pub unsafe fn set__allocatedBySparse_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                15usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        transpose: bool,
        triangle: SparseTriangle_t,
        kind: SparseKind_t,
        _reserved: ::core::ffi::c_uint,
        _allocatedBySparse: bool,
    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
        __bindgen_bitfield_unit.set(0usize, 1u8, {
            let transpose: u8 = unsafe { ::core::mem::transmute(transpose) };
            transpose as u64
        });
        __bindgen_bitfield_unit.set(1usize, 1u8, {
            let triangle: u8 = unsafe { ::core::mem::transmute(triangle) };
            triangle as u64
        });
        __bindgen_bitfield_unit.set(2usize, 2u8, {
            let kind: u32 = unsafe { ::core::mem::transmute(kind) };
            kind as u64
        });
        __bindgen_bitfield_unit.set(4usize, 11u8, {
            let _reserved: u32 = unsafe { ::core::mem::transmute(_reserved) };
            _reserved as u64
        });
        __bindgen_bitfield_unit.set(15usize, 1u8, {
            let _allocatedBySparse: u8 = unsafe { ::core::mem::transmute(_allocatedBySparse) };
            _allocatedBySparse as u64
        });
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[repr(align(4))]
#[derive(Debug, Default, Copy, Clone)]
pub struct SparseAttributesComplex_t {
    pub _bitfield_align_1: [u16; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
    pub __bindgen_padding_0: u16,
}
impl SparseAttributesComplex_t {
    #[inline]
    pub fn transpose(&self) -> bool {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_transpose(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::core::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn transpose_raw(this: *const Self) -> bool {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                0usize,
                1u8,
            ) as u8)
        }
    }
    #[inline]
    pub unsafe fn set_transpose_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn triangle(&self) -> SparseTriangle_t {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_triangle(&mut self, val: SparseTriangle_t) {
        unsafe {
            let val: u8 = ::core::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn triangle_raw(this: *const Self) -> SparseTriangle_t {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                1usize,
                1u8,
            ) as u8)
        }
    }
    #[inline]
    pub unsafe fn set_triangle_raw(this: *mut Self, val: SparseTriangle_t) {
        unsafe {
            let val: u8 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                1usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn kind(&self) -> SparseKind_t {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 3u8) as u32) }
    }
    #[inline]
    pub fn set_kind(&mut self, val: SparseKind_t) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(2usize, 3u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn kind_raw(this: *const Self) -> SparseKind_t {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                2usize,
                3u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_kind_raw(this: *mut Self, val: SparseKind_t) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                2usize,
                3u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn conjugate_transpose(&self) -> bool {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_conjugate_transpose(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::core::mem::transmute(val);
            self._bitfield_1.set(5usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn conjugate_transpose_raw(this: *const Self) -> bool {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                5usize,
                1u8,
            ) as u8)
        }
    }
    #[inline]
    pub unsafe fn set_conjugate_transpose_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                5usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn _reserved(&self) -> ::core::ffi::c_uint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(6usize, 9u8) as u32) }
    }
    #[inline]
    pub fn set__reserved(&mut self, val: ::core::ffi::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(6usize, 9u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn _reserved_raw(this: *const Self) -> ::core::ffi::c_uint {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                6usize,
                9u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set__reserved_raw(this: *mut Self, val: ::core::ffi::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                6usize,
                9u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn _allocatedBySparse(&self) -> bool {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set__allocatedBySparse(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::core::mem::transmute(val);
            self._bitfield_1.set(15usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn _allocatedBySparse_raw(this: *const Self) -> bool {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                15usize,
                1u8,
            ) as u8)
        }
    }
    #[inline]
    pub unsafe fn set__allocatedBySparse_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                15usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        transpose: bool,
        triangle: SparseTriangle_t,
        kind: SparseKind_t,
        conjugate_transpose: bool,
        _reserved: ::core::ffi::c_uint,
        _allocatedBySparse: bool,
    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
        __bindgen_bitfield_unit.set(0usize, 1u8, {
            let transpose: u8 = unsafe { ::core::mem::transmute(transpose) };
            transpose as u64
        });
        __bindgen_bitfield_unit.set(1usize, 1u8, {
            let triangle: u8 = unsafe { ::core::mem::transmute(triangle) };
            triangle as u64
        });
        __bindgen_bitfield_unit.set(2usize, 3u8, {
            let kind: u32 = unsafe { ::core::mem::transmute(kind) };
            kind as u64
        });
        __bindgen_bitfield_unit.set(5usize, 1u8, {
            let conjugate_transpose: u8 = unsafe { ::core::mem::transmute(conjugate_transpose) };
            conjugate_transpose as u64
        });
        __bindgen_bitfield_unit.set(6usize, 9u8, {
            let _reserved: u32 = unsafe { ::core::mem::transmute(_reserved) };
            _reserved as u64
        });
        __bindgen_bitfield_unit.set(15usize, 1u8, {
            let _allocatedBySparse: u8 = unsafe { ::core::mem::transmute(_allocatedBySparse) };
            _allocatedBySparse as u64
        });
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SparseMatrixStructure {
    pub rowCount: ::core::ffi::c_int,
    pub columnCount: ::core::ffi::c_int,
    pub columnStarts: *mut ::core::ffi::c_long,
    pub rowIndices: *mut ::core::ffi::c_int,
    pub attributes: SparseAttributes_t,
    pub blockSize: u8,
}
impl Default for SparseMatrixStructure {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SparseMatrixStructureComplex {
    pub rowCount: ::core::ffi::c_int,
    pub columnCount: ::core::ffi::c_int,
    pub columnStarts: *mut ::core::ffi::c_long,
    pub rowIndices: *mut ::core::ffi::c_int,
    pub attributes: SparseAttributesComplex_t,
    pub blockSize: u8,
}
impl Default for SparseMatrixStructureComplex {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SparseMatrix_Double {
    pub structure: SparseMatrixStructure,
    pub data: *mut f64,
}
impl Default for SparseMatrix_Double {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SparseMatrix_Float {
    pub structure: SparseMatrixStructure,
    pub data: *mut f32,
}
impl Default for SparseMatrix_Float {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SparseMatrix_Complex_Double {
    pub structure: SparseMatrixStructureComplex,
    pub data: *mut __SPARSE_double_complex,
}
impl Default for SparseMatrix_Complex_Double {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SparseMatrix_Complex_Float {
    pub structure: SparseMatrixStructureComplex,
    pub data: *mut __SPARSE_float_complex,
}
impl Default for SparseMatrix_Complex_Float {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct DenseVector_Double {
    pub count: ::core::ffi::c_int,
    pub data: *mut f64,
}
impl Default for DenseVector_Double {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct DenseVector_Float {
    pub count: ::core::ffi::c_int,
    pub data: *mut f32,
}
impl Default for DenseVector_Float {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct DenseVector_Complex_Double {
    pub count: ::core::ffi::c_int,
    pub data: *mut __SPARSE_double_complex,
}
impl Default for DenseVector_Complex_Double {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct DenseVector_Complex_Float {
    pub count: ::core::ffi::c_int,
    pub data: *mut __SPARSE_float_complex,
}
impl Default for DenseVector_Complex_Float {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct DenseMatrix_Double {
    pub rowCount: ::core::ffi::c_int,
    pub columnCount: ::core::ffi::c_int,
    pub columnStride: ::core::ffi::c_int,
    pub attributes: SparseAttributes_t,
    pub data: *mut f64,
}
impl Default for DenseMatrix_Double {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct DenseMatrix_Float {
    pub rowCount: ::core::ffi::c_int,
    pub columnCount: ::core::ffi::c_int,
    pub columnStride: ::core::ffi::c_int,
    pub attributes: SparseAttributes_t,
    pub data: *mut f32,
}
impl Default for DenseMatrix_Float {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct DenseMatrix_Complex_Double {
    pub rowCount: ::core::ffi::c_int,
    pub columnCount: ::core::ffi::c_int,
    pub columnStride: ::core::ffi::c_int,
    pub attributes: SparseAttributesComplex_t,
    pub data: *mut __SPARSE_double_complex,
}
impl Default for DenseMatrix_Complex_Double {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct DenseMatrix_Complex_Float {
    pub rowCount: ::core::ffi::c_int,
    pub columnCount: ::core::ffi::c_int,
    pub columnStride: ::core::ffi::c_int,
    pub attributes: SparseAttributesComplex_t,
    pub data: *mut __SPARSE_float_complex,
}
impl Default for DenseMatrix_Complex_Float {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type SparseStatus_t = ::core::ffi::c_int;
pub type SparseFactorization_t = u8;
pub type SparseControl_t = u32;
pub type SparseOrder_t = u8;
pub type SparseScaling_t = u8;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SparseSymbolicFactorOptions {
    pub control: SparseControl_t,
    pub orderMethod: SparseOrder_t,
    pub order: *mut ::core::ffi::c_int,
    pub ignoreRowsAndColumns: *mut ::core::ffi::c_int,
    pub malloc:
        ::core::option::Option<unsafe extern "C" fn(size: usize) -> *mut ::core::ffi::c_void>,
    pub free: ::core::option::Option<unsafe extern "C" fn(pointer: *mut ::core::ffi::c_void)>,
    pub reportError:
        ::core::option::Option<unsafe extern "C" fn(message: *const ::core::ffi::c_char)>,
}
impl Default for SparseSymbolicFactorOptions {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SparseNumericFactorOptions {
    pub control: SparseControl_t,
    pub scalingMethod: SparseScaling_t,
    pub scaling: *mut ::core::ffi::c_void,
    pub pivotTolerance: f64,
    pub zeroTolerance: f64,
}
impl Default for SparseNumericFactorOptions {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SparseOpaqueSymbolicFactorization {
    pub status: SparseStatus_t,
    pub rowCount: ::core::ffi::c_int,
    pub columnCount: ::core::ffi::c_int,
    pub attributes: SparseAttributes_t,
    pub blockSize: u8,
    pub type_: SparseFactorization_t,
    pub factorization: *mut ::core::ffi::c_void,
    pub workspaceSize_Float: usize,
    pub workspaceSize_Double: usize,
    pub factorSize_Float: usize,
    pub factorSize_Double: usize,
}
impl Default for SparseOpaqueSymbolicFactorization {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SparseOpaqueFactorization_Double {
    pub status: SparseStatus_t,
    pub attributes: SparseAttributes_t,
    pub symbolicFactorization: SparseOpaqueSymbolicFactorization,
    pub userFactorStorage: bool,
    pub numericFactorization: *mut ::core::ffi::c_void,
    pub solveWorkspaceRequiredStatic: usize,
    pub solveWorkspaceRequiredPerRHS: usize,
}
impl Default for SparseOpaqueFactorization_Double {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SparseOpaqueFactorization_Float {
    pub status: SparseStatus_t,
    pub attributes: SparseAttributes_t,
    pub symbolicFactorization: SparseOpaqueSymbolicFactorization,
    pub userFactorStorage: bool,
    pub numericFactorization: *mut ::core::ffi::c_void,
    pub solveWorkspaceRequiredStatic: usize,
    pub solveWorkspaceRequiredPerRHS: usize,
}
impl Default for SparseOpaqueFactorization_Float {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SparseOpaqueFactorization_Complex_Double {
    pub status: SparseStatus_t,
    pub attributes: SparseAttributesComplex_t,
    pub symbolicFactorization: SparseOpaqueSymbolicFactorization,
    pub userFactorStorage: bool,
    pub numericFactorization: *mut ::core::ffi::c_void,
    pub solveWorkspaceRequiredStatic: usize,
    pub solveWorkspaceRequiredPerRHS: usize,
}
impl Default for SparseOpaqueFactorization_Complex_Double {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SparseOpaqueFactorization_Complex_Float {
    pub status: SparseStatus_t,
    pub attributes: SparseAttributesComplex_t,
    pub symbolicFactorization: SparseOpaqueSymbolicFactorization,
    pub userFactorStorage: bool,
    pub numericFactorization: *mut ::core::ffi::c_void,
    pub solveWorkspaceRequiredStatic: usize,
    pub solveWorkspaceRequiredPerRHS: usize,
}
impl Default for SparseOpaqueFactorization_Complex_Float {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type SparseSubfactor_t = u8;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SparseOpaqueSubfactor_Double {
    pub attributes: SparseAttributes_t,
    pub contents: SparseSubfactor_t,
    pub factor: SparseOpaqueFactorization_Double,
    pub workspaceRequiredStatic: usize,
    pub workspaceRequiredPerRHS: usize,
}
impl Default for SparseOpaqueSubfactor_Double {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SparseOpaqueSubfactor_Float {
    pub attributes: SparseAttributes_t,
    pub contents: SparseSubfactor_t,
    pub factor: SparseOpaqueFactorization_Float,
    pub workspaceRequiredStatic: usize,
    pub workspaceRequiredPerRHS: usize,
}
impl Default for SparseOpaqueSubfactor_Float {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SparseOpaqueSubfactor_Complex_Double {
    pub attributes: SparseAttributesComplex_t,
    pub contents: SparseSubfactor_t,
    pub factor: SparseOpaqueFactorization_Complex_Double,
    pub workspaceRequiredStatic: usize,
    pub workspaceRequiredPerRHS: usize,
}
impl Default for SparseOpaqueSubfactor_Complex_Double {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SparseOpaqueSubfactor_Complex_Float {
    pub attributes: SparseAttributesComplex_t,
    pub contents: SparseSubfactor_t,
    pub factor: SparseOpaqueFactorization_Complex_Float,
    pub workspaceRequiredStatic: usize,
    pub workspaceRequiredPerRHS: usize,
}
impl Default for SparseOpaqueSubfactor_Complex_Float {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    #[link_name = "\u{1}__Z16SparseGetInertia31SparseOpaqueFactorization_FloatPiS0_S0_"]
    pub fn SparseGetInertia(
        Factored: SparseOpaqueFactorization_Float,
        num_positive: *mut ::core::ffi::c_int,
        num_zero: *mut ::core::ffi::c_int,
        num_negative: *mut ::core::ffi::c_int,
    ) -> ::core::ffi::c_int;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    #[link_name = "\u{1}__Z16SparseGetInertia32SparseOpaqueFactorization_DoublePiS0_S0_"]
    pub fn SparseGetInertia1(
        Factored: SparseOpaqueFactorization_Double,
        num_positive: *mut ::core::ffi::c_int,
        num_zero: *mut ::core::ffi::c_int,
        num_negative: *mut ::core::ffi::c_int,
    ) -> ::core::ffi::c_int;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    #[link_name = "\u{1}__Z16SparseGetInertia39SparseOpaqueFactorization_Complex_FloatPiS0_S0_"]
    pub fn SparseGetInertia2(
        Factored: SparseOpaqueFactorization_Complex_Float,
        num_positive: *mut ::core::ffi::c_int,
        num_zero: *mut ::core::ffi::c_int,
        num_negative: *mut ::core::ffi::c_int,
    ) -> ::core::ffi::c_int;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    #[link_name = "\u{1}__Z16SparseGetInertia40SparseOpaqueFactorization_Complex_DoublePiS0_S0_"]
    pub fn SparseGetInertia3(
        Factored: SparseOpaqueFactorization_Complex_Double,
        num_positive: *mut ::core::ffi::c_int,
        num_zero: *mut ::core::ffi::c_int,
        num_negative: *mut ::core::ffi::c_int,
    ) -> ::core::ffi::c_int;
}
pub type SparsePreconditioner_t = ::core::ffi::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SparseOpaquePreconditioner_Double {
    pub type_: SparsePreconditioner_t,
    pub mem: *mut ::core::ffi::c_void,
    pub apply: ::core::option::Option<
        unsafe extern "C" fn(
            arg1: *mut ::core::ffi::c_void,
            trans: CBLAS_TRANSPOSE,
            X: DenseMatrix_Double,
            Y: DenseMatrix_Double,
        ),
    >,
}
impl Default for SparseOpaquePreconditioner_Double {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SparseOpaquePreconditioner_Float {
    pub type_: SparsePreconditioner_t,
    pub mem: *mut ::core::ffi::c_void,
    pub apply: ::core::option::Option<
        unsafe extern "C" fn(
            arg1: *mut ::core::ffi::c_void,
            trans: CBLAS_TRANSPOSE,
            X: DenseMatrix_Float,
            arg2: DenseMatrix_Float,
        ),
    >,
}
impl Default for SparseOpaquePreconditioner_Float {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SparseOpaquePreconditioner_Complex_Double {
    pub type_: SparsePreconditioner_t,
    pub mem: *mut ::core::ffi::c_void,
    pub apply: ::core::option::Option<
        unsafe extern "C" fn(
            arg1: *mut ::core::ffi::c_void,
            trans: CBLAS_TRANSPOSE,
            X: DenseMatrix_Complex_Double,
            Y: DenseMatrix_Complex_Double,
        ),
    >,
}
impl Default for SparseOpaquePreconditioner_Complex_Double {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SparseOpaquePreconditioner_Complex_Float {
    pub type_: SparsePreconditioner_t,
    pub mem: *mut ::core::ffi::c_void,
    pub apply: ::core::option::Option<
        unsafe extern "C" fn(
            arg1: *mut ::core::ffi::c_void,
            trans: CBLAS_TRANSPOSE,
            X: DenseMatrix_Complex_Float,
            Y: DenseMatrix_Complex_Float,
        ),
    >,
}
impl Default for SparseOpaquePreconditioner_Complex_Float {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type SparseIterativeStatus_t = ::core::ffi::c_int;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _SparseIterativeMethodBaseOptions {
    pub reportError:
        ::core::option::Option<unsafe extern "C" fn(message: *const ::core::ffi::c_char)>,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct SparseCGOptions {
    pub reportError:
        ::core::option::Option<unsafe extern "C" fn(message: *const ::core::ffi::c_char)>,
    pub maxIterations: ::core::ffi::c_int,
    pub atol: f64,
    pub rtol: f64,
    pub reportStatus:
        ::core::option::Option<unsafe extern "C" fn(message: *const ::core::ffi::c_char)>,
}
pub type SparseGMRESVariant_t = u8;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct SparseGMRESOptions {
    pub reportError:
        ::core::option::Option<unsafe extern "C" fn(message: *const ::core::ffi::c_char)>,
    pub variant: SparseGMRESVariant_t,
    pub nvec: ::core::ffi::c_int,
    pub maxIterations: ::core::ffi::c_int,
    pub atol: f64,
    pub rtol: f64,
    pub reportStatus:
        ::core::option::Option<unsafe extern "C" fn(message: *const ::core::ffi::c_char)>,
}
pub type SparseLSMRConvergenceTest_t = ::core::ffi::c_int;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct SparseLSMROptions {
    pub reportError:
        ::core::option::Option<unsafe extern "C" fn(message: *const ::core::ffi::c_char)>,
    pub lambda: f64,
    pub nvec: ::core::ffi::c_int,
    pub convergenceTest: SparseLSMRConvergenceTest_t,
    pub atol: f64,
    pub rtol: f64,
    pub btol: f64,
    pub conditionLimit: f64,
    pub maxIterations: ::core::ffi::c_int,
    pub reportStatus:
        ::core::option::Option<unsafe extern "C" fn(message: *const ::core::ffi::c_char)>,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SparseIterativeMethod {
    pub method: ::core::ffi::c_int,
    pub options: SparseIterativeMethod__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union SparseIterativeMethod__bindgen_ty_1 {
    pub base: _SparseIterativeMethodBaseOptions,
    pub cg: SparseCGOptions,
    pub gmres: SparseGMRESOptions,
    pub lsmr: SparseLSMROptions,
    pub padding: [::core::ffi::c_char; 256usize],
}
impl Default for SparseIterativeMethod__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for SparseIterativeMethod {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseSymbolicFactorSymmetric(
        factorType: SparseFactorization_t,
        Matrix: *const SparseMatrixStructure,
        options: *const SparseSymbolicFactorOptions,
    ) -> SparseOpaqueSymbolicFactorization;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseSymbolicFactorQR(
        factorType: SparseFactorization_t,
        Matrix: *const SparseMatrixStructure,
        options: *const SparseSymbolicFactorOptions,
    ) -> SparseOpaqueSymbolicFactorization;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseSymbolicFactorLU(
        factorType: SparseFactorization_t,
        Matrix: *const SparseMatrixStructure,
        options: *const SparseSymbolicFactorOptions,
    ) -> SparseOpaqueSymbolicFactorization;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseRetainSymbolic(symbolicFactor: *mut SparseOpaqueSymbolicFactorization);
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseDestroyOpaqueSymbolic(toFree: *mut SparseOpaqueSymbolicFactorization);
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseGetOptionsFromSymbolicFactor(
        factor: *mut SparseOpaqueSymbolicFactorization,
    ) -> SparseSymbolicFactorOptions;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseTrap();
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseFromKindComplex(K: SparseKind_t) -> SparseKind_t;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseToKindComplex(K: SparseKind_t) -> SparseKind_t;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseFromAttributeComplex(K: SparseAttributesComplex_t) -> SparseAttributes_t;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseToAttributeComplex(K: SparseAttributes_t) -> SparseAttributesComplex_t;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseFromStructureComplex(K: SparseMatrixStructureComplex) -> SparseMatrixStructure;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseToStructureComplex(K: SparseMatrixStructure) -> SparseMatrixStructureComplex;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseConvertFromCoordinate_Double(
        m: ::core::ffi::c_int,
        n: ::core::ffi::c_int,
        nBlock: ::core::ffi::c_long,
        blockSize: u8,
        attributes: SparseAttributes_t,
        row: *const ::core::ffi::c_int,
        col: *const ::core::ffi::c_int,
        val: *const f64,
        storage: *mut ::core::ffi::c_char,
        workspace: *mut ::core::ffi::c_int,
    ) -> SparseMatrix_Double;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseConvertFromOpaque_Double(matrix: sparse_matrix_double) -> SparseMatrix_Double;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseNumericFactorSymmetric_Double(
        symbolicFactor: *mut SparseOpaqueSymbolicFactorization,
        Matrix: *const SparseMatrix_Double,
        options: *const SparseNumericFactorOptions,
        factorStorage: *mut ::core::ffi::c_void,
        workspace: *mut ::core::ffi::c_void,
    ) -> SparseOpaqueFactorization_Double;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseNumericFactorQR_Double(
        symbolicFactor: *mut SparseOpaqueSymbolicFactorization,
        Matrix: *const SparseMatrix_Double,
        options: *const SparseNumericFactorOptions,
        factorStorage: *mut ::core::ffi::c_void,
        workspace: *mut ::core::ffi::c_void,
    ) -> SparseOpaqueFactorization_Double;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseNumericFactorLU_Double(
        symbolicFactor: *mut SparseOpaqueSymbolicFactorization,
        Matrix: *const SparseMatrix_Double,
        options: *const SparseNumericFactorOptions,
        factorStorage: *mut ::core::ffi::c_void,
        workspace: *mut ::core::ffi::c_void,
    ) -> SparseOpaqueFactorization_Double;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseFactorSymmetric_Double(
        factorType: SparseFactorization_t,
        Matrix: *const SparseMatrix_Double,
        sfoptions: *const SparseSymbolicFactorOptions,
        nfoptions: *const SparseNumericFactorOptions,
    ) -> SparseOpaqueFactorization_Double;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseFactorQR_Double(
        factorType: SparseFactorization_t,
        Matrix: *const SparseMatrix_Double,
        sfoptions: *const SparseSymbolicFactorOptions,
        nfoptions: *const SparseNumericFactorOptions,
    ) -> SparseOpaqueFactorization_Double;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseFactorLU_Double(
        factorType: SparseFactorization_t,
        Matrix: *const SparseMatrix_Double,
        sfoptions: *const SparseSymbolicFactorOptions,
        nfoptions: *const SparseNumericFactorOptions,
    ) -> SparseOpaqueFactorization_Double;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseRefactorSymmetric_Double(
        Matrix: *const SparseMatrix_Double,
        Factorization: *mut SparseOpaqueFactorization_Double,
        nfoptions: *const SparseNumericFactorOptions,
        workspace: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseRefactorQR_Double(
        Matrix: *const SparseMatrix_Double,
        Factorization: *mut SparseOpaqueFactorization_Double,
        nfoptions: *const SparseNumericFactorOptions,
        workspace: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseRefactorLU_Double(
        Matrix: *const SparseMatrix_Double,
        Factorization: *mut SparseOpaqueFactorization_Double,
        nfoptions: *const SparseNumericFactorOptions,
        workspace: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseUpdatePartialRefactorLU_Double(
        Opaque: *mut SparseOpaqueFactorization_Double,
        updateCount: ::core::ffi::c_int,
        updatedIndices: *const ::core::ffi::c_int,
        newMatrix: SparseMatrix_Double,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseMultiplySubfactor_Double(
        Subfactor: *const SparseOpaqueSubfactor_Double,
        x: *const DenseMatrix_Double,
        y: *const DenseMatrix_Double,
        workspace: *mut ::core::ffi::c_char,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseSolveSubfactor_Double(
        Subfactor: *const SparseOpaqueSubfactor_Double,
        b: *const DenseMatrix_Double,
        x: *const DenseMatrix_Double,
        workspace: *mut ::core::ffi::c_char,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseSolveOpaque_Double(
        Factored: *const SparseOpaqueFactorization_Double,
        RHS: *const DenseMatrix_Double,
        Soln: *const DenseMatrix_Double,
        workspace: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseDestroyOpaqueNumeric_Double(toFree: *mut SparseOpaqueFactorization_Double);
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseRetainNumeric_Double(numericFactor: *mut SparseOpaqueFactorization_Double);
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseGetOptionsFromNumericFactor_Double(
        factor: *mut SparseOpaqueFactorization_Double,
    ) -> SparseNumericFactorOptions;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseGetWorkspaceRequired_Double(
        Subfactor: SparseSubfactor_t,
        Factor: SparseOpaqueFactorization_Double,
        workStatic: *mut usize,
        workPerRHS: *mut usize,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseGetIterativeStateSize_Double(
        method: *const SparseIterativeMethod,
        preconditioner: bool,
        m: ::core::ffi::c_int,
        n: ::core::ffi::c_int,
        nrhs: ::core::ffi::c_int,
    ) -> usize;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseCGIterate_Double(
        options: *const SparseCGOptions,
        iteration: ::core::ffi::c_int,
        state: *mut ::core::ffi::c_char,
        converged: *const bool,
        X: *mut DenseMatrix_Double,
        B: *mut DenseMatrix_Double,
        R: *mut DenseMatrix_Double,
        Preconditioner: *const SparseOpaquePreconditioner_Double,
        ApplyOperator: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseCGSolve_Double(
        options: *const SparseCGOptions,
        X: *mut DenseMatrix_Double,
        B: *mut DenseMatrix_Double,
        ApplyOperator: *mut ::core::ffi::c_void,
        Preconditioner: *const SparseOpaquePreconditioner_Double,
    ) -> SparseIterativeStatus_t;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseGMRESIterate_Double(
        options: *const SparseGMRESOptions,
        iteration: ::core::ffi::c_int,
        state: *mut ::core::ffi::c_char,
        converged: *const bool,
        X: *mut DenseMatrix_Double,
        B: *mut DenseMatrix_Double,
        R: *mut DenseMatrix_Double,
        Preconditioner: *const SparseOpaquePreconditioner_Double,
        ApplyOperator: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseGMRESSolve_Double(
        options: *mut SparseGMRESOptions,
        X: *mut DenseMatrix_Double,
        B: *mut DenseMatrix_Double,
        ApplyOperator: *mut ::core::ffi::c_void,
        Preconditioner: *const SparseOpaquePreconditioner_Double,
    ) -> SparseIterativeStatus_t;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseLSMRIterate_Double(
        options: *const SparseLSMROptions,
        iteration: ::core::ffi::c_int,
        state: *mut ::core::ffi::c_char,
        converged: *const bool,
        X: *mut DenseMatrix_Double,
        B: *mut DenseMatrix_Double,
        R: *mut DenseMatrix_Double,
        Preconditioner: *const SparseOpaquePreconditioner_Double,
        ApplyOperator: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseLSMRSolve_Double(
        options: *mut SparseLSMROptions,
        X: *mut DenseMatrix_Double,
        B: *mut DenseMatrix_Double,
        ApplyOperator: *mut ::core::ffi::c_void,
        Preconditioner: *const SparseOpaquePreconditioner_Double,
    ) -> SparseIterativeStatus_t;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseCreatePreconditioner_Double(
        type_: SparsePreconditioner_t,
        A: *mut SparseMatrix_Double,
    ) -> SparseOpaquePreconditioner_Double;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseReleaseOpaquePreconditioner_Double(
        toFree: *mut SparseOpaquePreconditioner_Double,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseSpMV_Double(
        alpha: f64,
        A: SparseMatrix_Double,
        x: DenseMatrix_Double,
        accumulate: bool,
        y: DenseMatrix_Double,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseConvertFromCoordinate_Float(
        m: ::core::ffi::c_int,
        n: ::core::ffi::c_int,
        nBlock: ::core::ffi::c_long,
        blockSize: u8,
        attributes: SparseAttributes_t,
        row: *const ::core::ffi::c_int,
        col: *const ::core::ffi::c_int,
        val: *const f32,
        storage: *mut ::core::ffi::c_char,
        workspace: *mut ::core::ffi::c_int,
    ) -> SparseMatrix_Float;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseConvertFromOpaque_Float(matrix: sparse_matrix_float) -> SparseMatrix_Float;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseNumericFactorSymmetric_Float(
        symbolicFactor: *mut SparseOpaqueSymbolicFactorization,
        Matrix: *const SparseMatrix_Float,
        options: *const SparseNumericFactorOptions,
        factorStorage: *mut ::core::ffi::c_void,
        workspace: *mut ::core::ffi::c_void,
    ) -> SparseOpaqueFactorization_Float;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseNumericFactorQR_Float(
        symbolicFactor: *mut SparseOpaqueSymbolicFactorization,
        Matrix: *const SparseMatrix_Float,
        options: *const SparseNumericFactorOptions,
        factorStorage: *mut ::core::ffi::c_void,
        workspace: *mut ::core::ffi::c_void,
    ) -> SparseOpaqueFactorization_Float;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseNumericFactorLU_Float(
        symbolicFactor: *mut SparseOpaqueSymbolicFactorization,
        Matrix: *const SparseMatrix_Float,
        options: *const SparseNumericFactorOptions,
        factorStorage: *mut ::core::ffi::c_void,
        workspace: *mut ::core::ffi::c_void,
    ) -> SparseOpaqueFactorization_Float;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseFactorSymmetric_Float(
        factorType: SparseFactorization_t,
        Matrix: *const SparseMatrix_Float,
        sfoptions: *const SparseSymbolicFactorOptions,
        nfoptions: *const SparseNumericFactorOptions,
    ) -> SparseOpaqueFactorization_Float;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseFactorQR_Float(
        factorType: SparseFactorization_t,
        Matrix: *const SparseMatrix_Float,
        sfoptions: *const SparseSymbolicFactorOptions,
        nfoptions: *const SparseNumericFactorOptions,
    ) -> SparseOpaqueFactorization_Float;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseFactorLU_Float(
        factorType: SparseFactorization_t,
        Matrix: *const SparseMatrix_Float,
        sfoptions: *const SparseSymbolicFactorOptions,
        nfoptions: *const SparseNumericFactorOptions,
    ) -> SparseOpaqueFactorization_Float;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseRefactorSymmetric_Float(
        Matrix: *const SparseMatrix_Float,
        Factorization: *mut SparseOpaqueFactorization_Float,
        nfoptions: *const SparseNumericFactorOptions,
        workspace: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseRefactorQR_Float(
        Matrix: *const SparseMatrix_Float,
        Factorization: *mut SparseOpaqueFactorization_Float,
        nfoptions: *const SparseNumericFactorOptions,
        workspace: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseRefactorLU_Float(
        Matrix: *const SparseMatrix_Float,
        Factorization: *mut SparseOpaqueFactorization_Float,
        nfoptions: *const SparseNumericFactorOptions,
        workspace: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseUpdatePartialRefactorLU_Float(
        Opaque: *mut SparseOpaqueFactorization_Float,
        updateCount: ::core::ffi::c_int,
        updatedIndices: *const ::core::ffi::c_int,
        newMatrix: SparseMatrix_Float,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseMultiplySubfactor_Float(
        Subfactor: *const SparseOpaqueSubfactor_Float,
        x: *const DenseMatrix_Float,
        y: *const DenseMatrix_Float,
        workspace: *mut ::core::ffi::c_char,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseSolveSubfactor_Float(
        Subfactor: *const SparseOpaqueSubfactor_Float,
        b: *const DenseMatrix_Float,
        x: *const DenseMatrix_Float,
        workspace: *mut ::core::ffi::c_char,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseSolveOpaque_Float(
        Factored: *const SparseOpaqueFactorization_Float,
        RHS: *const DenseMatrix_Float,
        Soln: *const DenseMatrix_Float,
        workspace: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseDestroyOpaqueNumeric_Float(toFree: *mut SparseOpaqueFactorization_Float);
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseRetainNumeric_Float(numericFactor: *mut SparseOpaqueFactorization_Float);
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseGetOptionsFromNumericFactor_Float(
        factor: *mut SparseOpaqueFactorization_Float,
    ) -> SparseNumericFactorOptions;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseGetWorkspaceRequired_Float(
        Subfactor: SparseSubfactor_t,
        Factor: SparseOpaqueFactorization_Float,
        workStatic: *mut usize,
        workPerRHS: *mut usize,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseGetIterativeStateSize_Float(
        method: *const SparseIterativeMethod,
        preconditioner: bool,
        m: ::core::ffi::c_int,
        n: ::core::ffi::c_int,
        nrhs: ::core::ffi::c_int,
    ) -> usize;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseCGIterate_Float(
        options: *const SparseCGOptions,
        iteration: ::core::ffi::c_int,
        state: *mut ::core::ffi::c_char,
        converged: *const bool,
        X: *mut DenseMatrix_Float,
        B: *mut DenseMatrix_Float,
        R: *mut DenseMatrix_Float,
        Preconditioner: *const SparseOpaquePreconditioner_Float,
        ApplyOperator: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseCGSolve_Float(
        options: *const SparseCGOptions,
        X: *mut DenseMatrix_Float,
        B: *mut DenseMatrix_Float,
        ApplyOperator: *mut ::core::ffi::c_void,
        Preconditioner: *const SparseOpaquePreconditioner_Float,
    ) -> SparseIterativeStatus_t;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseGMRESIterate_Float(
        options: *const SparseGMRESOptions,
        iteration: ::core::ffi::c_int,
        state: *mut ::core::ffi::c_char,
        converged: *const bool,
        X: *mut DenseMatrix_Float,
        B: *mut DenseMatrix_Float,
        R: *mut DenseMatrix_Float,
        Preconditioner: *const SparseOpaquePreconditioner_Float,
        ApplyOperator: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseGMRESSolve_Float(
        options: *mut SparseGMRESOptions,
        X: *mut DenseMatrix_Float,
        B: *mut DenseMatrix_Float,
        ApplyOperator: *mut ::core::ffi::c_void,
        Preconditioner: *const SparseOpaquePreconditioner_Float,
    ) -> SparseIterativeStatus_t;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseLSMRIterate_Float(
        options: *const SparseLSMROptions,
        iteration: ::core::ffi::c_int,
        state: *mut ::core::ffi::c_char,
        converged: *const bool,
        X: *mut DenseMatrix_Float,
        B: *mut DenseMatrix_Float,
        R: *mut DenseMatrix_Float,
        Preconditioner: *const SparseOpaquePreconditioner_Float,
        ApplyOperator: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseLSMRSolve_Float(
        options: *mut SparseLSMROptions,
        X: *mut DenseMatrix_Float,
        B: *mut DenseMatrix_Float,
        ApplyOperator: *mut ::core::ffi::c_void,
        Preconditioner: *const SparseOpaquePreconditioner_Float,
    ) -> SparseIterativeStatus_t;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseCreatePreconditioner_Float(
        type_: SparsePreconditioner_t,
        A: *mut SparseMatrix_Float,
    ) -> SparseOpaquePreconditioner_Float;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseReleaseOpaquePreconditioner_Float(toFree: *mut SparseOpaquePreconditioner_Float);
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseSpMV_Float(
        alpha: f32,
        A: SparseMatrix_Float,
        x: DenseMatrix_Float,
        accumulate: bool,
        y: DenseMatrix_Float,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseConvertFromCoordinate_Complex_Double(
        m: ::core::ffi::c_int,
        n: ::core::ffi::c_int,
        nBlock: ::core::ffi::c_long,
        blockSize: u8,
        attributes: SparseAttributesComplex_t,
        row: *const ::core::ffi::c_int,
        col: *const ::core::ffi::c_int,
        val: *const __SPARSE_double_complex,
        storage: *mut ::core::ffi::c_char,
        workspace: *mut ::core::ffi::c_int,
    ) -> SparseMatrix_Complex_Double;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseConvertFromOpaque_Complex_Double(
        matrix: sparse_matrix_double_complex,
    ) -> SparseMatrix_Complex_Double;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseNumericFactorSymmetric_Complex_Double(
        symbolicFactor: *mut SparseOpaqueSymbolicFactorization,
        Matrix: *const SparseMatrix_Complex_Double,
        options: *const SparseNumericFactorOptions,
        factorStorage: *mut ::core::ffi::c_void,
        workspace: *mut ::core::ffi::c_void,
    ) -> SparseOpaqueFactorization_Complex_Double;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseNumericFactorHermitian_Complex_Double(
        symbolicFactor: *mut SparseOpaqueSymbolicFactorization,
        Matrix: *const SparseMatrix_Complex_Double,
        options: *const SparseNumericFactorOptions,
        factorStorage: *mut ::core::ffi::c_void,
        workspace: *mut ::core::ffi::c_void,
    ) -> SparseOpaqueFactorization_Complex_Double;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseNumericFactorQR_Complex_Double(
        symbolicFactor: *mut SparseOpaqueSymbolicFactorization,
        Matrix: *const SparseMatrix_Complex_Double,
        options: *const SparseNumericFactorOptions,
        factorStorage: *mut ::core::ffi::c_void,
        workspace: *mut ::core::ffi::c_void,
    ) -> SparseOpaqueFactorization_Complex_Double;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseNumericFactorLU_Complex_Double(
        symbolicFactor: *mut SparseOpaqueSymbolicFactorization,
        Matrix: *const SparseMatrix_Complex_Double,
        options: *const SparseNumericFactorOptions,
        factorStorage: *mut ::core::ffi::c_void,
        workspace: *mut ::core::ffi::c_void,
    ) -> SparseOpaqueFactorization_Complex_Double;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseFactorSymmetric_Complex_Double(
        factorType: SparseFactorization_t,
        Matrix: *const SparseMatrix_Complex_Double,
        sfoptions: *const SparseSymbolicFactorOptions,
        nfoptions: *const SparseNumericFactorOptions,
    ) -> SparseOpaqueFactorization_Complex_Double;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseFactorHermitian_Complex_Double(
        factorType: SparseFactorization_t,
        Matrix: *const SparseMatrix_Complex_Double,
        sfoptions: *const SparseSymbolicFactorOptions,
        nfoptions: *const SparseNumericFactorOptions,
    ) -> SparseOpaqueFactorization_Complex_Double;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseFactorQR_Complex_Double(
        factorType: SparseFactorization_t,
        Matrix: *const SparseMatrix_Complex_Double,
        sfoptions: *const SparseSymbolicFactorOptions,
        nfoptions: *const SparseNumericFactorOptions,
    ) -> SparseOpaqueFactorization_Complex_Double;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseFactorLU_Complex_Double(
        factorType: SparseFactorization_t,
        Matrix: *const SparseMatrix_Complex_Double,
        sfoptions: *const SparseSymbolicFactorOptions,
        nfoptions: *const SparseNumericFactorOptions,
    ) -> SparseOpaqueFactorization_Complex_Double;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseRefactorSymmetric_Complex_Double(
        Matrix: *const SparseMatrix_Complex_Double,
        Factorization: *mut SparseOpaqueFactorization_Complex_Double,
        nfoptions: *const SparseNumericFactorOptions,
        workspace: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseRefactorHermitian_Complex_Double(
        Matrix: *const SparseMatrix_Complex_Double,
        Factorization: *mut SparseOpaqueFactorization_Complex_Double,
        nfoptions: *const SparseNumericFactorOptions,
        workspace: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseRefactorQR_Complex_Double(
        Matrix: *const SparseMatrix_Complex_Double,
        Factorization: *mut SparseOpaqueFactorization_Complex_Double,
        nfoptions: *const SparseNumericFactorOptions,
        workspace: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseRefactorLU_Complex_Double(
        Matrix: *const SparseMatrix_Complex_Double,
        Factorization: *mut SparseOpaqueFactorization_Complex_Double,
        nfoptions: *const SparseNumericFactorOptions,
        workspace: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseUpdatePartialRefactorLU_Complex_Double(
        Opaque: *mut SparseOpaqueFactorization_Complex_Double,
        updateCount: ::core::ffi::c_int,
        updatedIndices: *const ::core::ffi::c_int,
        newMatrix: SparseMatrix_Complex_Double,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseMultiplySubfactor_Complex_Double(
        Subfactor: *const SparseOpaqueSubfactor_Complex_Double,
        x: *const DenseMatrix_Complex_Double,
        y: *const DenseMatrix_Complex_Double,
        workspace: *mut ::core::ffi::c_char,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseSolveSubfactor_Complex_Double(
        Subfactor: *const SparseOpaqueSubfactor_Complex_Double,
        b: *const DenseMatrix_Complex_Double,
        x: *const DenseMatrix_Complex_Double,
        workspace: *mut ::core::ffi::c_char,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseSolveOpaque_Complex_Double(
        Factored: *const SparseOpaqueFactorization_Complex_Double,
        RHS: *const DenseMatrix_Complex_Double,
        Soln: *const DenseMatrix_Complex_Double,
        workspace: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseDestroyOpaqueNumeric_Complex_Double(
        toFree: *mut SparseOpaqueFactorization_Complex_Double,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseRetainNumeric_Complex_Double(
        numericFactor: *mut SparseOpaqueFactorization_Complex_Double,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseGetOptionsFromNumericFactor_Complex_Double(
        factor: *mut SparseOpaqueFactorization_Complex_Double,
    ) -> SparseNumericFactorOptions;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseGetWorkspaceRequired_Complex_Double(
        Subfactor: SparseSubfactor_t,
        Factor: SparseOpaqueFactorization_Complex_Double,
        workStatic: *mut usize,
        workPerRHS: *mut usize,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseGetIterativeStateSize_Complex_Double(
        method: *const SparseIterativeMethod,
        preconditioner: bool,
        m: ::core::ffi::c_int,
        n: ::core::ffi::c_int,
        nrhs: ::core::ffi::c_int,
    ) -> usize;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseCGIterate_Complex_Double(
        options: *const SparseCGOptions,
        iteration: ::core::ffi::c_int,
        state: *mut ::core::ffi::c_char,
        converged: *const bool,
        X: *mut DenseMatrix_Complex_Double,
        B: *mut DenseMatrix_Complex_Double,
        R: *mut DenseMatrix_Complex_Double,
        Preconditioner: *const SparseOpaquePreconditioner_Complex_Double,
        ApplyOperator: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseCGSolve_Complex_Double(
        options: *const SparseCGOptions,
        X: *mut DenseMatrix_Complex_Double,
        B: *mut DenseMatrix_Complex_Double,
        ApplyOperator: *mut ::core::ffi::c_void,
        Preconditioner: *const SparseOpaquePreconditioner_Complex_Double,
    ) -> SparseIterativeStatus_t;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseGMRESIterate_Complex_Double(
        options: *const SparseGMRESOptions,
        iteration: ::core::ffi::c_int,
        state: *mut ::core::ffi::c_char,
        converged: *const bool,
        X: *mut DenseMatrix_Complex_Double,
        B: *mut DenseMatrix_Complex_Double,
        R: *mut DenseMatrix_Complex_Double,
        Preconditioner: *const SparseOpaquePreconditioner_Complex_Double,
        ApplyOperator: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseGMRESSolve_Complex_Double(
        options: *mut SparseGMRESOptions,
        X: *mut DenseMatrix_Complex_Double,
        B: *mut DenseMatrix_Complex_Double,
        ApplyOperator: *mut ::core::ffi::c_void,
        Preconditioner: *const SparseOpaquePreconditioner_Complex_Double,
    ) -> SparseIterativeStatus_t;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseLSMRIterate_Complex_Double(
        options: *const SparseLSMROptions,
        iteration: ::core::ffi::c_int,
        state: *mut ::core::ffi::c_char,
        converged: *const bool,
        X: *mut DenseMatrix_Complex_Double,
        B: *mut DenseMatrix_Complex_Double,
        R: *mut DenseMatrix_Complex_Double,
        Preconditioner: *const SparseOpaquePreconditioner_Complex_Double,
        ApplyOperator: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseLSMRSolve_Complex_Double(
        options: *mut SparseLSMROptions,
        X: *mut DenseMatrix_Complex_Double,
        B: *mut DenseMatrix_Complex_Double,
        ApplyOperator: *mut ::core::ffi::c_void,
        Preconditioner: *const SparseOpaquePreconditioner_Complex_Double,
    ) -> SparseIterativeStatus_t;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseCreatePreconditioner_Complex_Double(
        type_: SparsePreconditioner_t,
        A: *mut SparseMatrix_Complex_Double,
    ) -> SparseOpaquePreconditioner_Complex_Double;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseReleaseOpaquePreconditioner_Complex_Double(
        toFree: *mut SparseOpaquePreconditioner_Complex_Double,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseSpMV_Complex_Double(
        alpha: __SPARSE_double_complex,
        A: SparseMatrix_Complex_Double,
        x: DenseMatrix_Complex_Double,
        accumulate: bool,
        y: DenseMatrix_Complex_Double,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseConvertFromCoordinate_Complex_Float(
        m: ::core::ffi::c_int,
        n: ::core::ffi::c_int,
        nBlock: ::core::ffi::c_long,
        blockSize: u8,
        attributes: SparseAttributesComplex_t,
        row: *const ::core::ffi::c_int,
        col: *const ::core::ffi::c_int,
        val: *const __SPARSE_float_complex,
        storage: *mut ::core::ffi::c_char,
        workspace: *mut ::core::ffi::c_int,
    ) -> SparseMatrix_Complex_Float;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseConvertFromOpaque_Complex_Float(
        matrix: sparse_matrix_float_complex,
    ) -> SparseMatrix_Complex_Float;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseNumericFactorSymmetric_Complex_Float(
        symbolicFactor: *mut SparseOpaqueSymbolicFactorization,
        Matrix: *const SparseMatrix_Complex_Float,
        options: *const SparseNumericFactorOptions,
        factorStorage: *mut ::core::ffi::c_void,
        workspace: *mut ::core::ffi::c_void,
    ) -> SparseOpaqueFactorization_Complex_Float;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseNumericFactorHermitian_Complex_Float(
        symbolicFactor: *mut SparseOpaqueSymbolicFactorization,
        Matrix: *const SparseMatrix_Complex_Float,
        options: *const SparseNumericFactorOptions,
        factorStorage: *mut ::core::ffi::c_void,
        workspace: *mut ::core::ffi::c_void,
    ) -> SparseOpaqueFactorization_Complex_Float;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseNumericFactorQR_Complex_Float(
        symbolicFactor: *mut SparseOpaqueSymbolicFactorization,
        Matrix: *const SparseMatrix_Complex_Float,
        options: *const SparseNumericFactorOptions,
        factorStorage: *mut ::core::ffi::c_void,
        workspace: *mut ::core::ffi::c_void,
    ) -> SparseOpaqueFactorization_Complex_Float;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseNumericFactorLU_Complex_Float(
        symbolicFactor: *mut SparseOpaqueSymbolicFactorization,
        Matrix: *const SparseMatrix_Complex_Float,
        options: *const SparseNumericFactorOptions,
        factorStorage: *mut ::core::ffi::c_void,
        workspace: *mut ::core::ffi::c_void,
    ) -> SparseOpaqueFactorization_Complex_Float;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseFactorSymmetric_Complex_Float(
        factorType: SparseFactorization_t,
        Matrix: *const SparseMatrix_Complex_Float,
        sfoptions: *const SparseSymbolicFactorOptions,
        nfoptions: *const SparseNumericFactorOptions,
    ) -> SparseOpaqueFactorization_Complex_Float;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseFactorHermitian_Complex_Float(
        factorType: SparseFactorization_t,
        Matrix: *const SparseMatrix_Complex_Float,
        sfoptions: *const SparseSymbolicFactorOptions,
        nfoptions: *const SparseNumericFactorOptions,
    ) -> SparseOpaqueFactorization_Complex_Float;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseFactorQR_Complex_Float(
        factorType: SparseFactorization_t,
        Matrix: *const SparseMatrix_Complex_Float,
        sfoptions: *const SparseSymbolicFactorOptions,
        nfoptions: *const SparseNumericFactorOptions,
    ) -> SparseOpaqueFactorization_Complex_Float;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseFactorLU_Complex_Float(
        factorType: SparseFactorization_t,
        Matrix: *const SparseMatrix_Complex_Float,
        sfoptions: *const SparseSymbolicFactorOptions,
        nfoptions: *const SparseNumericFactorOptions,
    ) -> SparseOpaqueFactorization_Complex_Float;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseRefactorSymmetric_Complex_Float(
        Matrix: *const SparseMatrix_Complex_Float,
        Factorization: *mut SparseOpaqueFactorization_Complex_Float,
        nfoptions: *const SparseNumericFactorOptions,
        workspace: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseRefactorHermitian_Complex_Float(
        Matrix: *const SparseMatrix_Complex_Float,
        Factorization: *mut SparseOpaqueFactorization_Complex_Float,
        nfoptions: *const SparseNumericFactorOptions,
        workspace: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseRefactorQR_Complex_Float(
        Matrix: *const SparseMatrix_Complex_Float,
        Factorization: *mut SparseOpaqueFactorization_Complex_Float,
        nfoptions: *const SparseNumericFactorOptions,
        workspace: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseRefactorLU_Complex_Float(
        Matrix: *const SparseMatrix_Complex_Float,
        Factorization: *mut SparseOpaqueFactorization_Complex_Float,
        nfoptions: *const SparseNumericFactorOptions,
        workspace: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseUpdatePartialRefactorLU_Complex_Float(
        Opaque: *mut SparseOpaqueFactorization_Complex_Float,
        updateCount: ::core::ffi::c_int,
        updatedIndices: *const ::core::ffi::c_int,
        newMatrix: SparseMatrix_Complex_Float,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseMultiplySubfactor_Complex_Float(
        Subfactor: *const SparseOpaqueSubfactor_Complex_Float,
        x: *const DenseMatrix_Complex_Float,
        y: *const DenseMatrix_Complex_Float,
        workspace: *mut ::core::ffi::c_char,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseSolveSubfactor_Complex_Float(
        Subfactor: *const SparseOpaqueSubfactor_Complex_Float,
        b: *const DenseMatrix_Complex_Float,
        x: *const DenseMatrix_Complex_Float,
        workspace: *mut ::core::ffi::c_char,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseSolveOpaque_Complex_Float(
        Factored: *const SparseOpaqueFactorization_Complex_Float,
        RHS: *const DenseMatrix_Complex_Float,
        Soln: *const DenseMatrix_Complex_Float,
        workspace: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseDestroyOpaqueNumeric_Complex_Float(
        toFree: *mut SparseOpaqueFactorization_Complex_Float,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseRetainNumeric_Complex_Float(
        numericFactor: *mut SparseOpaqueFactorization_Complex_Float,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseGetOptionsFromNumericFactor_Complex_Float(
        factor: *mut SparseOpaqueFactorization_Complex_Float,
    ) -> SparseNumericFactorOptions;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseGetWorkspaceRequired_Complex_Float(
        Subfactor: SparseSubfactor_t,
        Factor: SparseOpaqueFactorization_Complex_Float,
        workStatic: *mut usize,
        workPerRHS: *mut usize,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseGetIterativeStateSize_Complex_Float(
        method: *const SparseIterativeMethod,
        preconditioner: bool,
        m: ::core::ffi::c_int,
        n: ::core::ffi::c_int,
        nrhs: ::core::ffi::c_int,
    ) -> usize;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseCGIterate_Complex_Float(
        options: *const SparseCGOptions,
        iteration: ::core::ffi::c_int,
        state: *mut ::core::ffi::c_char,
        converged: *const bool,
        X: *mut DenseMatrix_Complex_Float,
        B: *mut DenseMatrix_Complex_Float,
        R: *mut DenseMatrix_Complex_Float,
        Preconditioner: *const SparseOpaquePreconditioner_Complex_Float,
        ApplyOperator: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseCGSolve_Complex_Float(
        options: *const SparseCGOptions,
        X: *mut DenseMatrix_Complex_Float,
        B: *mut DenseMatrix_Complex_Float,
        ApplyOperator: *mut ::core::ffi::c_void,
        Preconditioner: *const SparseOpaquePreconditioner_Complex_Float,
    ) -> SparseIterativeStatus_t;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseGMRESIterate_Complex_Float(
        options: *const SparseGMRESOptions,
        iteration: ::core::ffi::c_int,
        state: *mut ::core::ffi::c_char,
        converged: *const bool,
        X: *mut DenseMatrix_Complex_Float,
        B: *mut DenseMatrix_Complex_Float,
        R: *mut DenseMatrix_Complex_Float,
        Preconditioner: *const SparseOpaquePreconditioner_Complex_Float,
        ApplyOperator: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseGMRESSolve_Complex_Float(
        options: *mut SparseGMRESOptions,
        X: *mut DenseMatrix_Complex_Float,
        B: *mut DenseMatrix_Complex_Float,
        ApplyOperator: *mut ::core::ffi::c_void,
        Preconditioner: *const SparseOpaquePreconditioner_Complex_Float,
    ) -> SparseIterativeStatus_t;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseLSMRIterate_Complex_Float(
        options: *const SparseLSMROptions,
        iteration: ::core::ffi::c_int,
        state: *mut ::core::ffi::c_char,
        converged: *const bool,
        X: *mut DenseMatrix_Complex_Float,
        B: *mut DenseMatrix_Complex_Float,
        R: *mut DenseMatrix_Complex_Float,
        Preconditioner: *const SparseOpaquePreconditioner_Complex_Float,
        ApplyOperator: *mut ::core::ffi::c_void,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseLSMRSolve_Complex_Float(
        options: *mut SparseLSMROptions,
        X: *mut DenseMatrix_Complex_Float,
        B: *mut DenseMatrix_Complex_Float,
        ApplyOperator: *mut ::core::ffi::c_void,
        Preconditioner: *const SparseOpaquePreconditioner_Complex_Float,
    ) -> SparseIterativeStatus_t;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseCreatePreconditioner_Complex_Float(
        type_: SparsePreconditioner_t,
        A: *mut SparseMatrix_Complex_Float,
    ) -> SparseOpaquePreconditioner_Complex_Float;
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseReleaseOpaquePreconditioner_Complex_Float(
        toFree: *mut SparseOpaquePreconditioner_Complex_Float,
    );
}
#[link(name = "Accelerate", kind = "framework")]
unsafe extern "C" {
    pub fn _SparseSpMV_Complex_Float(
        alpha: __SPARSE_float_complex,
        A: SparseMatrix_Complex_Float,
        x: DenseMatrix_Complex_Float,
        accumulate: bool,
        y: DenseMatrix_Complex_Float,
    );
}