Use lapack_sys in Eig_ impl for real

Author: termoshtt

lax/src/eig.rs

@@ -123,7 +123,7 @@ macro_rules! impl_eig_real {
             fn eig(
                 calc_v: bool,
                 l: MatrixLayout,
-                mut a: &mut [Self],
+                a: &mut [Self],
             ) -> Result<(Vec<Self::Complex>, Vec<Self::Complex>)> {
                 let (n, _) = l.size();
                 // LAPACK assumes a column-major input. A row-major input can
@@ -150,61 +150,62 @@ macro_rules! impl_eig_real {
                 } else {
                     (EigenVectorFlag::Not, EigenVectorFlag::Not)
                 };
-                let mut eig_re = unsafe { vec_uninit(n as usize) };
-                let mut eig_im = unsafe { vec_uninit(n as usize) };
+                let mut eig_re: Vec<Self> = unsafe { vec_uninit(n as usize) };
+                let mut eig_im: Vec<Self> = unsafe { vec_uninit(n as usize) };
 
-                let mut vl = if jobvl == EigenVectorFlag::Calc {
+                let mut vl: Option<Vec<Self>> = if jobvl == EigenVectorFlag::Calc {
                     Some(unsafe { vec_uninit((n * n) as usize) })
                 } else {
                     None
                 };
-                let mut vr = if jobvr == EigenVectorFlag::Calc {
+                let mut vr: Option<Vec<Self>> = if jobvr == EigenVectorFlag::Calc {
                     Some(unsafe { vec_uninit((n * n) as usize) })
                 } else {
                     None
                 };
 
                 // calc work size
                 let mut info = 0;
-                let mut work_size = [0.0];
+                let mut work_size: [Self; 1] = [0.0];
                 unsafe {
                     $ev(
-                        jobvl as u8,
-                        jobvr as u8,
-                        n,
-                        &mut a,
-                        n,
-                        &mut eig_re,
-                        &mut eig_im,
-                        vl.as_mut().map(|v| v.as_mut_slice()).unwrap_or(&mut []),
-                        n,
-                        vr.as_mut().map(|v| v.as_mut_slice()).unwrap_or(&mut []),
-                        n,
-                        &mut work_size,
-                        -1,
+                        jobvl.as_ptr(),
+                        jobvr.as_ptr(),
+                        &n,
+                        AsPtr::as_mut_ptr(a),
+                        &n,
+                        AsPtr::as_mut_ptr(&mut eig_re),
+                        AsPtr::as_mut_ptr(&mut eig_im),
+                        AsPtr::as_mut_ptr(vl.as_mut().map(|v| v.as_mut_slice()).unwrap_or(&mut [])),
+                        &n,
+                        AsPtr::as_mut_ptr(vr.as_mut().map(|v| v.as_mut_slice()).unwrap_or(&mut [])),
+                        &n,
+                        AsPtr::as_mut_ptr(&mut work_size),
+                        &(-1),
                         &mut info,
                     )
                 };
                 info.as_lapack_result()?;
 
                 // actual ev
                 let lwork = work_size[0].to_usize().unwrap();
-                let mut work = unsafe { vec_uninit(lwork) };
+                let mut work: Vec<Self> = unsafe { vec_uninit(lwork) };
+                let lwork = lwork as i32;
                 unsafe {
                     $ev(
-                        jobvl as u8,
-                        jobvr as u8,
-                        n,
-                        &mut a,
-                        n,
-                        &mut eig_re,
-                        &mut eig_im,
-                        vl.as_mut().map(|v| v.as_mut_slice()).unwrap_or(&mut []),
-                        n,
-                        vr.as_mut().map(|v| v.as_mut_slice()).unwrap_or(&mut []),
-                        n,
-                        &mut work,
-                        lwork as i32,
+                        jobvl.as_ptr(),
+                        jobvr.as_ptr(),
+                        &n,
+                        AsPtr::as_mut_ptr(a),
+                        &n,
+                        AsPtr::as_mut_ptr(&mut eig_re),
+                        AsPtr::as_mut_ptr(&mut eig_im),
+                        AsPtr::as_mut_ptr(vl.as_mut().map(|v| v.as_mut_slice()).unwrap_or(&mut [])),
+                        &n,
+                        AsPtr::as_mut_ptr(vr.as_mut().map(|v| v.as_mut_slice()).unwrap_or(&mut [])),
+                        &n,
+                        AsPtr::as_mut_ptr(&mut work),
+                        &lwork,
                         &mut info,
                     )
                 };
@@ -270,5 +271,5 @@ macro_rules! impl_eig_real {
     };
 }
 
-impl_eig_real!(f64, lapack::dgeev);
-impl_eig_real!(f32, lapack::sgeev);
+impl_eig_real!(f64, lapack_sys::dgeev_);
+impl_eig_real!(f32, lapack_sys::sgeev_);