Use lapack_sys in Eig_ impl for complex

Author: termoshtt

lax/src/eig.rs

@@ -20,7 +20,7 @@ macro_rules! impl_eig_complex {
             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
@@ -42,52 +42,55 @@ macro_rules! impl_eig_complex {
                     (EigenVectorFlag::Not, EigenVectorFlag::Not)
                 };
                 let mut eigs = unsafe { vec_uninit(n as usize) };
-                let mut rwork = unsafe { vec_uninit(2 * n as usize) };
+                let mut rwork: Vec<Self::Real> = unsafe { vec_uninit(2 * n as usize) };
 
-                let mut vl = jobvl.then(|| unsafe { vec_uninit((n * n) as usize) });
-                let mut vr = jobvr.then(|| unsafe { vec_uninit((n * n) as usize) });
+                let mut vl: Option<Vec<Self>> =
+                    jobvl.then(|| unsafe { vec_uninit((n * n) as usize) });
+                let mut vr: Option<Vec<Self>> =
+                    jobvr.then(|| unsafe { vec_uninit((n * n) as usize) });
 
                 // calc work size
                 let mut info = 0;
                 let mut work_size = [Self::zero()];
                 unsafe {
                     $ev(
-                        jobvl as u8,
-                        jobvr as u8,
-                        n,
-                        &mut a,
-                        n,
-                        &mut eigs,
-                        &mut vl.as_mut().map(|v| v.as_mut_slice()).unwrap_or(&mut []),
-                        n,
-                        &mut vr.as_mut().map(|v| v.as_mut_slice()).unwrap_or(&mut []),
-                        n,
-                        &mut work_size,
-                        -1,
-                        &mut rwork,
+                        jobvl.as_ptr(),
+                        jobvr.as_ptr(),
+                        &n,
+                        AsPtr::as_mut_ptr(a),
+                        &n,
+                        AsPtr::as_mut_ptr(&mut eigs),
+                        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),
+                        AsPtr::as_mut_ptr(&mut rwork),
                         &mut info,
                     )
                 };
                 info.as_lapack_result()?;
 
                 // actal 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 eigs,
-                        &mut vl.as_mut().map(|v| v.as_mut_slice()).unwrap_or(&mut []),
-                        n,
-                        &mut vr.as_mut().map(|v| v.as_mut_slice()).unwrap_or(&mut []),
-                        n,
-                        &mut work,
-                        lwork as i32,
-                        &mut rwork,
+                        jobvl.as_ptr(),
+                        jobvr.as_ptr(),
+                        &n,
+                        AsPtr::as_mut_ptr(a),
+                        &n,
+                        AsPtr::as_mut_ptr(&mut eigs),
+                        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,
+                        AsPtr::as_mut_ptr(&mut rwork),
                         &mut info,
                     )
                 };
@@ -106,8 +109,8 @@ macro_rules! impl_eig_complex {
     };
 }
 
-impl_eig_complex!(c64, lapack::zgeev);
-impl_eig_complex!(c32, lapack::cgeev);
+impl_eig_complex!(c64, lapack_sys::zgeev_);
+impl_eig_complex!(c32, lapack_sys::cgeev_);
 
 macro_rules! impl_eig_real {
     ($scalar:ty, $ev:path) => {