Make lapack_traits functions unsafe

termoshtt · termoshtt · commit 00b7e8146289 · 2017-07-10T17:26:47.000+09:00
diff --git a/src/cholesky.rs b/src/cholesky.rs
@@ -34,7 +34,7 @@ where
     S: DataMut<Elem = A>,
 {
     fn cholesky_into(mut self, uplo: UPLO) -> Result<Self> {
-        A::cholesky(self.square_layout()?, uplo, self.as_allocated_mut()?)?;
+        unsafe { A::cholesky(self.square_layout()?, uplo, self.as_allocated_mut()?)? };
         Ok(self.into_triangular(uplo))
     }
 }
@@ -45,7 +45,7 @@ where
     S: DataMut<Elem = A>,
 {
     fn cholesky_mut(&mut self, uplo: UPLO) -> Result<&mut Self> {
-        A::cholesky(self.square_layout()?, uplo, self.as_allocated_mut()?)?;
+        unsafe { A::cholesky(self.square_layout()?, uplo, self.as_allocated_mut()?)? };
         Ok(self.into_triangular(uplo))
     }
 }
@@ -59,7 +59,7 @@ where
 
     fn cholesky(&self, uplo: UPLO) -> Result<Self::Output> {
         let mut a = replicate(self);
-        A::cholesky(a.square_layout()?, uplo, a.as_allocated_mut()?)?;
+        unsafe { A::cholesky(a.square_layout()?, uplo, a.as_allocated_mut()?)? };
         Ok(a.into_triangular(uplo))
     }
 }
diff --git a/src/eigh.rs b/src/eigh.rs
@@ -63,7 +63,7 @@ where
     type EigVal = Array1<A::Real>;
 
     fn eigh_mut(&mut self, uplo: UPLO) -> Result<(Self::EigVal, &mut Self)> {
-        let s = A::eigh(true, self.square_layout()?, uplo, self.as_allocated_mut()?)?;
+        let s = unsafe { A::eigh(true, self.square_layout()?, uplo, self.as_allocated_mut()?)? };
         Ok((ArrayBase::from_vec(s), self))
     }
 }
@@ -119,7 +119,7 @@ where
     type EigVal = Array1<A::Real>;
 
     fn eigvalsh_mut(&mut self, uplo: UPLO) -> Result<Self::EigVal> {
-        let s = A::eigh(true, self.square_layout()?, uplo, self.as_allocated_mut()?)?;
+        let s = unsafe { A::eigh(true, self.square_layout()?, uplo, self.as_allocated_mut()?)? };
         Ok(ArrayBase::from_vec(s))
     }
 }
diff --git a/src/lapack_traits/cholesky.rs b/src/lapack_traits/cholesky.rs
@@ -9,15 +9,15 @@ use types::*;
 use super::{UPLO, into_result};
 
 pub trait Cholesky_: Sized {
-    fn cholesky(MatrixLayout, UPLO, a: &mut [Self]) -> Result<()>;
+    unsafe fn cholesky(MatrixLayout, UPLO, a: &mut [Self]) -> Result<()>;
 }
 
 macro_rules! impl_cholesky {
     ($scalar:ty, $potrf:path) => {
 impl Cholesky_ for $scalar {
-    fn cholesky(l: MatrixLayout, uplo: UPLO, mut a: &mut [Self]) -> Result<()> {
+    unsafe fn cholesky(l: MatrixLayout, uplo: UPLO, mut a: &mut [Self]) -> Result<()> {
         let (n, _) = l.size();
-        let info = unsafe { $potrf(l.lapacke_layout(), uplo as u8, n, &mut a, n) };
+        let info = $potrf(l.lapacke_layout(), uplo as u8, n, &mut a, n);
         into_result(info, ())
     }
 }
diff --git a/src/lapack_traits/eigh.rs b/src/lapack_traits/eigh.rs
@@ -11,17 +11,17 @@ use super::{UPLO, into_result};
 
 /// Wraps `*syev` for real and `*heev` for complex
 pub trait Eigh_: AssociatedReal {
-    fn eigh(calc_eigenvec: bool, MatrixLayout, UPLO, a: &mut [Self]) -> Result<Vec<Self::Real>>;
+    unsafe fn eigh(calc_eigenvec: bool, MatrixLayout, UPLO, a: &mut [Self]) -> Result<Vec<Self::Real>>;
 }
 
 macro_rules! impl_eigh {
     ($scalar:ty, $ev:path) => {
 impl Eigh_ for $scalar {
-    fn eigh(calc_v: bool, l: MatrixLayout, uplo: UPLO, mut a: &mut [Self]) -> Result<Vec<Self::Real>> {
+    unsafe fn eigh(calc_v: bool, l: MatrixLayout, uplo: UPLO, mut a: &mut [Self]) -> Result<Vec<Self::Real>> {
         let (n, _) = l.size();
         let jobz = if calc_v { b'V' } else { b'N' };
         let mut w = vec![Self::Real::zero(); n as usize];
-        let info = unsafe { $ev(l.lapacke_layout(), jobz, uplo as u8, n, &mut a, n, &mut w) };
+        let info = $ev(l.lapacke_layout(), jobz, uplo as u8, n, &mut a, n, &mut w);
         into_result(info, w)
     }
 }
diff --git a/src/lapack_traits/opnorm.rs b/src/lapack_traits/opnorm.rs
@@ -24,16 +24,16 @@ impl NormType {
 }
 
 pub trait OperatorNorm_: AssociatedReal {
-    fn opnorm(NormType, MatrixLayout, &[Self]) -> Self::Real;
+    unsafe fn opnorm(NormType, MatrixLayout, &[Self]) -> Self::Real;
 }
 
 macro_rules! impl_opnorm {
     ($scalar:ty, $lange:path) => {
 impl OperatorNorm_ for $scalar {
-    fn opnorm(t: NormType, l: MatrixLayout, a: &[Self]) -> Self::Real {
+    unsafe fn opnorm(t: NormType, l: MatrixLayout, a: &[Self]) -> Self::Real {
         match l {
-            MatrixLayout::F((col, lda)) => unsafe { $lange(cm, t as u8, lda, col, a, lda) },
-            MatrixLayout::C((row, lda)) => unsafe { $lange(cm, t.transpose() as u8, lda, row, a, lda) },
+            MatrixLayout::F((col, lda)) => $lange(cm, t as u8, lda, col, a, lda),
+            MatrixLayout::C((row, lda)) => $lange(cm, t.transpose() as u8, lda, row, a, lda),
         }
     }
 }
diff --git a/src/lapack_traits/qr.rs b/src/lapack_traits/qr.rs
@@ -12,30 +12,30 @@ use super::into_result;
 
 /// Wraps `*geqrf` and `*orgqr` (`*ungqr` for complex numbers)
 pub trait QR_: Sized {
-    fn householder(MatrixLayout, a: &mut [Self]) -> Result<Vec<Self>>;
-    fn q(MatrixLayout, a: &mut [Self], tau: &[Self]) -> Result<()>;
-    fn qr(MatrixLayout, a: &mut [Self]) -> Result<Vec<Self>>;
+    unsafe fn householder(MatrixLayout, a: &mut [Self]) -> Result<Vec<Self>>;
+    unsafe fn q(MatrixLayout, a: &mut [Self], tau: &[Self]) -> Result<()>;
+    unsafe fn qr(MatrixLayout, a: &mut [Self]) -> Result<Vec<Self>>;
 }
 
 macro_rules! impl_qr {
     ($scalar:ty, $qrf:path, $gqr:path) => {
 impl QR_ for $scalar {
-    fn householder(l: MatrixLayout, mut a: &mut [Self]) -> Result<Vec<Self>> {
+    unsafe fn householder(l: MatrixLayout, mut a: &mut [Self]) -> Result<Vec<Self>> {
         let (row, col) = l.size();
         let k = min(row, col);
         let mut tau = vec![Self::zero(); k as usize];
-        let info = unsafe { $qrf(l.lapacke_layout(), row, col, &mut a, l.lda(), &mut tau) };
+        let info = $qrf(l.lapacke_layout(), row, col, &mut a, l.lda(), &mut tau);
         into_result(info, tau)
     }
 
-    fn q(l: MatrixLayout, mut a: &mut [Self], tau: &[Self]) -> Result<()> {
+    unsafe fn q(l: MatrixLayout, mut a: &mut [Self], tau: &[Self]) -> Result<()> {
         let (row, col) = l.size();
         let k = min(row, col);
-        let info = unsafe { $gqr(l.lapacke_layout(), row, k, k, &mut a, l.lda(), &tau) };
+        let info = $gqr(l.lapacke_layout(), row, k, k, &mut a, l.lda(), &tau);
         into_result(info, ())
     }
 
-    fn qr(l: MatrixLayout, mut a: &mut [Self]) -> Result<Vec<Self>> {
+    unsafe fn qr(l: MatrixLayout, mut a: &mut [Self]) -> Result<Vec<Self>> {
         let tau = Self::householder(l, a)?;
         let r = Vec::from(&*a);
         Self::q(l, a, &tau)?;
diff --git a/src/lapack_traits/solve.rs b/src/lapack_traits/solve.rs
@@ -12,34 +12,34 @@ pub type Pivot = Vec<i32>;
 
 /// Wraps `*getrf`, `*getri`, and `*getrs`
 pub trait Solve_: Sized {
-    fn lu(MatrixLayout, a: &mut [Self]) -> Result<Pivot>;
-    fn inv(MatrixLayout, a: &mut [Self], &Pivot) -> Result<()>;
-    fn solve(MatrixLayout, Transpose, a: &[Self], &Pivot, b: &mut [Self]) -> Result<()>;
+    unsafe fn lu(MatrixLayout, a: &mut [Self]) -> Result<Pivot>;
+    unsafe fn inv(MatrixLayout, a: &mut [Self], &Pivot) -> Result<()>;
+    unsafe fn solve(MatrixLayout, Transpose, a: &[Self], &Pivot, b: &mut [Self]) -> Result<()>;
 }
 
 macro_rules! impl_solve {
     ($scalar:ty, $getrf:path, $getri:path, $getrs:path) => {
 
 impl Solve_ for $scalar {
-    fn lu(l: MatrixLayout, a: &mut [Self]) -> Result<Pivot> {
+    unsafe fn lu(l: MatrixLayout, a: &mut [Self]) -> Result<Pivot> {
         let (row, col) = l.size();
         let k = ::std::cmp::min(row, col);
         let mut ipiv = vec![0; k as usize];
-        let info = unsafe { $getrf(l.lapacke_layout(), row, col, a, l.lda(), &mut ipiv) };
+        let info = $getrf(l.lapacke_layout(), row, col, a, l.lda(), &mut ipiv);
         into_result(info, ipiv)
     }
 
-    fn inv(l: MatrixLayout, a: &mut [Self], ipiv: &Pivot) -> Result<()> {
+    unsafe fn inv(l: MatrixLayout, a: &mut [Self], ipiv: &Pivot) -> Result<()> {
         let (n, _) = l.size();
-        let info = unsafe { $getri(l.lapacke_layout(), n, a, l.lda(), ipiv) };
+        let info = $getri(l.lapacke_layout(), n, a, l.lda(), ipiv);
         into_result(info, ())
     }
 
-    fn solve(l: MatrixLayout, t: Transpose, a: &[Self], ipiv: &Pivot, b: &mut [Self]) -> Result<()> {
+    unsafe fn solve(l: MatrixLayout, t: Transpose, a: &[Self], ipiv: &Pivot, b: &mut [Self]) -> Result<()> {
         let (n, _) = l.size();
         let nrhs = 1;
         let ldb = 1;
-        let info = unsafe { $getrs(l.lapacke_layout(), t as u8, n, nrhs, a, l.lda(), ipiv, b, ldb) };
+        let info = $getrs(l.lapacke_layout(), t as u8, n, nrhs, a, l.lda(), ipiv, b, ldb);
         into_result(info, ())
     }
 }
diff --git a/src/lapack_traits/svd.rs b/src/lapack_traits/svd.rs
@@ -29,14 +29,14 @@ pub struct SVDOutput<A: AssociatedReal> {
 
 /// Wraps `*gesvd`
 pub trait SVD_: AssociatedReal {
-    fn svd(MatrixLayout, calc_u: bool, calc_vt: bool, a: &mut [Self]) -> Result<SVDOutput<Self>>;
+    unsafe fn svd(MatrixLayout, calc_u: bool, calc_vt: bool, a: &mut [Self]) -> Result<SVDOutput<Self>>;
 }
 
 macro_rules! impl_svd {
     ($scalar:ty, $gesvd:path) => {
 
 impl SVD_ for $scalar {
-    fn svd(l: MatrixLayout, calc_u: bool, calc_vt: bool, mut a: &mut [Self]) -> Result<SVDOutput<Self>> {
+    unsafe fn svd(l: MatrixLayout, calc_u: bool, calc_vt: bool, mut a: &mut [Self]) -> Result<SVDOutput<Self>> {
         let (m, n) = l.size();
         let k = ::std::cmp::min(n, m);
         let lda = l.lda();
@@ -52,7 +52,7 @@ impl SVD_ for $scalar {
         };
         let mut s = vec![Self::Real::zero(); k as usize];
         let mut superb = vec![Self::Real::zero(); (k-2) as usize];
-        let info = unsafe { $gesvd(l.lapacke_layout(), ju as u8, jvt as u8, m, n, &mut a, lda, &mut s, &mut u, ldu, &mut vt, ldvt, &mut superb) };
+        let info = $gesvd(l.lapacke_layout(), ju as u8, jvt as u8, m, n, &mut a, lda, &mut s, &mut u, ldu, &mut vt, ldvt, &mut superb);
         into_result(info, SVDOutput {
             s: s,
             u: if ldu > 0 { Some(u) } else { None },
diff --git a/src/lapack_traits/triangular.rs b/src/lapack_traits/triangular.rs
@@ -16,33 +16,34 @@ pub enum Diag {
 
 /// Wraps `*trtri` and `*trtrs`
 pub trait Triangular_: Sized {
-    fn inv_triangular(l: MatrixLayout, UPLO, Diag, a: &mut [Self]) -> Result<()>;
-    fn solve_triangular(al: MatrixLayout, bl: MatrixLayout, UPLO, Diag, a: &[Self], b: &mut [Self]) -> Result<()>;
+    unsafe fn inv_triangular(l: MatrixLayout, UPLO, Diag, a: &mut [Self]) -> Result<()>;
+    unsafe fn solve_triangular(
+        al: MatrixLayout,
+        bl: MatrixLayout,
+        UPLO,
+        Diag,
+        a: &[Self],
+        b: &mut [Self],
+    ) -> Result<()>;
 }
 
 macro_rules! impl_triangular {
     ($scalar:ty, $trtri:path, $trtrs:path) => {
 
 impl Triangular_ for $scalar {
-    fn inv_triangular(l: MatrixLayout, uplo: UPLO, diag: Diag, a: &mut [Self]) -> Result<()> {
+    unsafe fn inv_triangular(l: MatrixLayout, uplo: UPLO, diag: Diag, a: &mut [Self]) -> Result<()> {
         let (n, _) = l.size();
         let lda = l.lda();
-        let info = unsafe { $trtri(l.lapacke_layout(), uplo as u8, diag as u8, n, a, lda) };
+        let info = $trtri(l.lapacke_layout(), uplo as u8, diag as u8, n, a, lda);
         into_result(info, ())
     }
 
-    fn solve_triangular(al: MatrixLayout, bl: MatrixLayout, uplo: UPLO, diag: Diag, a: &[Self], mut b: &mut [Self]) -> Result<()> {
+    unsafe fn solve_triangular(al: MatrixLayout, bl: MatrixLayout, uplo: UPLO, diag: Diag, a: &[Self], mut b: &mut [Self]) -> Result<()> {
         let (n, _) = al.size();
         let lda = al.lda();
         let (_, nrhs) = bl.size();
         let ldb = bl.lda();
-        println!("al = {:?}", al);
-        println!("bl = {:?}", bl);
-        println!("n = {}", n);
-        println!("lda = {}", lda);
-        println!("nrhs = {}", nrhs);
-        println!("ldb = {}", ldb);
-        let info = unsafe { $trtrs(al.lapacke_layout(), uplo as u8, Transpose::No as u8, diag as u8, n, nrhs, a, lda, &mut b, ldb) };
+        let info = $trtrs(al.lapacke_layout(), uplo as u8, Transpose::No as u8, diag as u8, n, nrhs, a, lda, &mut b, ldb);
         into_result(info, ())
     }
 }
diff --git a/src/opnorm.rs b/src/opnorm.rs
@@ -43,6 +43,6 @@ where
     fn opnorm(&self, t: NormType) -> Result<Self::Output> {
         let l = self.layout()?;
         let a = self.as_allocated()?;
-        Ok(A::opnorm(t, l, a))
+        Ok(unsafe { A::opnorm(t, l, a) })
     }
 }
diff --git a/src/qr.rs b/src/qr.rs
@@ -61,7 +61,7 @@ where
 
     fn qr_square_mut<'a>(&'a mut self) -> Result<(&'a mut Self, Self::R)> {
         let l = self.square_layout()?;
-        let r = A::qr(l, self.as_allocated_mut()?)?;
+        let r = unsafe { A::qr(l, self.as_allocated_mut()?)? };
         let r: Array2<_> = into_matrix(l, r)?;
         Ok((self, r.into_triangular(UPLO::Upper)))
     }
@@ -108,7 +108,7 @@ where
         let m = self.cols();
         let k = ::std::cmp::min(n, m);
         let l = self.layout()?;
-        let r = A::qr(l, self.as_allocated_mut()?)?;
+        let r = unsafe { A::qr(l, self.as_allocated_mut()?)? };
         let r: Array2<_> = into_matrix(l, r)?;
         let q = self;
         Ok((take_slice(&q, n, k), take_slice_upper(&r, k, m)))
diff --git a/src/solve.rs b/src/solve.rs
@@ -23,13 +23,15 @@ where
     where
         Sb: DataMut<Elem = A>,
     {
-        A::solve(
-            self.a.square_layout()?,
-            t,
-            self.a.as_allocated()?,
-            &self.ipiv,
-            rhs.as_slice_mut().unwrap(),
-        )?;
+        unsafe {
+            A::solve(
+                self.a.square_layout()?,
+                t,
+                self.a.as_allocated()?,
+                &self.ipiv,
+                rhs.as_slice_mut().unwrap(),
+            )?
+        };
         Ok(rhs)
     }
 }
@@ -40,11 +42,13 @@ where
     S: DataMut<Elem = A>,
 {
     pub fn into_inverse(mut self) -> Result<ArrayBase<S, Ix2>> {
-        A::inv(
-            self.a.square_layout()?,
-            self.a.as_allocated_mut()?,
-            &self.ipiv,
-        )?;
+        unsafe {
+            A::inv(
+                self.a.square_layout()?,
+                self.a.as_allocated_mut()?,
+                &self.ipiv,
+            )?
+        };
         Ok(self.a)
     }
 }
@@ -63,7 +67,7 @@ where
     S: DataMut<Elem = A>,
 {
     fn factorize_into(mut self) -> Result<Factorized<S>> {
-        let ipiv = A::lu(self.layout()?, self.as_allocated_mut()?)?;
+        let ipiv = unsafe { A::lu(self.layout()?, self.as_allocated_mut()?)? };
         Ok(Factorized {
             a: self,
             ipiv: ipiv,
@@ -79,7 +83,7 @@ where
 {
     fn factorize(&self) -> Result<Factorized<So>> {
         let mut a: ArrayBase<So, Ix2> = replicate(self);
-        let ipiv = A::lu(a.layout()?, a.as_allocated_mut()?)?;
+        let ipiv = unsafe { A::lu(a.layout()?, a.as_allocated_mut()?)? };
         Ok(Factorized { a: a, ipiv: ipiv })
     }
 }
diff --git a/src/svd.rs b/src/svd.rs
@@ -73,7 +73,7 @@ where
 
     fn svd_mut(&mut self, calc_u: bool, calc_vt: bool) -> Result<(Option<Self::U>, Self::Sigma, Option<Self::VT>)> {
         let l = self.layout()?;
-        let svd_res = A::svd(l, calc_u, calc_vt, self.as_allocated_mut()?)?;
+        let svd_res = unsafe { A::svd(l, calc_u, calc_vt, self.as_allocated_mut()?)? };
         let (n, m) = l.size();
         let u = svd_res.u.map(|u| into_matrix(l.resized(n, n), u).unwrap());
         let vt = svd_res.vt.map(
diff --git a/src/triangular.rs b/src/triangular.rs
@@ -71,7 +71,7 @@ where
             transpose_data(b)?;
         }
         let lb = b.layout()?;
-        A::solve_triangular(la, lb, uplo, diag, a_, b.as_allocated_mut()?)?;
+        unsafe { A::solve_triangular(la, lb, uplo, diag, a_, b.as_allocated_mut()?)? };
         Ok(b)
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ where`
`34`	`34`	`S: DataMut<Elem = A>,`
`35`	`35`	`{`
`36`	`36`	`fn cholesky_into(mut self, uplo: UPLO) -> Result<Self> {`
`37`		`- A::cholesky(self.square_layout()?, uplo, self.as_allocated_mut()?)?;`
	`37`	`+ unsafe { A::cholesky(self.square_layout()?, uplo, self.as_allocated_mut()?)? };`
`38`	`38`	`Ok(self.into_triangular(uplo))`
`39`	`39`	`}`
`40`	`40`	`}`
`@@ -45,7 +45,7 @@ where`
`45`	`45`	`S: DataMut<Elem = A>,`
`46`	`46`	`{`
`47`	`47`	`fn cholesky_mut(&mut self, uplo: UPLO) -> Result<&mut Self> {`
`48`		`- A::cholesky(self.square_layout()?, uplo, self.as_allocated_mut()?)?;`
	`48`	`+ unsafe { A::cholesky(self.square_layout()?, uplo, self.as_allocated_mut()?)? };`
`49`	`49`	`Ok(self.into_triangular(uplo))`
`50`	`50`	`}`
`51`	`51`	`}`
`@@ -59,7 +59,7 @@ where`
`59`	`59`
`60`	`60`	`fn cholesky(&self, uplo: UPLO) -> Result<Self::Output> {`
`61`	`61`	`let mut a = replicate(self);`
`62`		`- A::cholesky(a.square_layout()?, uplo, a.as_allocated_mut()?)?;`
	`62`	`+ unsafe { A::cholesky(a.square_layout()?, uplo, a.as_allocated_mut()?)? };`
`63`	`63`	`Ok(a.into_triangular(uplo))`
`64`	`64`	`}`
`65`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ where`
`63`	`63`	`type EigVal = Array1<A::Real>;`
`64`	`64`
`65`	`65`	`fn eigh_mut(&mut self, uplo: UPLO) -> Result<(Self::EigVal, &mut Self)> {`
`66`		`- let s = A::eigh(true, self.square_layout()?, uplo, self.as_allocated_mut()?)?;`
	`66`	`+ let s = unsafe { A::eigh(true, self.square_layout()?, uplo, self.as_allocated_mut()?)? };`
`67`	`67`	`Ok((ArrayBase::from_vec(s), self))`
`68`	`68`	`}`
`69`	`69`	`}`
`@@ -119,7 +119,7 @@ where`
`119`	`119`	`type EigVal = Array1<A::Real>;`
`120`	`120`
`121`	`121`	`fn eigvalsh_mut(&mut self, uplo: UPLO) -> Result<Self::EigVal> {`
`122`		`- let s = A::eigh(true, self.square_layout()?, uplo, self.as_allocated_mut()?)?;`
	`122`	`+ let s = unsafe { A::eigh(true, self.square_layout()?, uplo, self.as_allocated_mut()?)? };`
`123`	`123`	`Ok(ArrayBase::from_vec(s))`
`124`	`124`	`}`
`125`	`125`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,15 +9,15 @@ use types::*;`
`9`	`9`	`use super::{UPLO, into_result};`
`10`	`10`
`11`	`11`	`pub trait Cholesky_: Sized {`
`12`		`- fn cholesky(MatrixLayout, UPLO, a: &mut [Self]) -> Result<()>;`
	`12`	`+ unsafe fn cholesky(MatrixLayout, UPLO, a: &mut [Self]) -> Result<()>;`
`13`	`13`	`}`
`14`	`14`
`15`	`15`	`macro_rules! impl_cholesky {`
`16`	`16`	`($scalar:ty, $potrf:path) => {`
`17`	`17`	`impl Cholesky_ for $scalar {`
`18`		`- fn cholesky(l: MatrixLayout, uplo: UPLO, mut a: &mut [Self]) -> Result<()> {`
	`18`	`+ unsafe fn cholesky(l: MatrixLayout, uplo: UPLO, mut a: &mut [Self]) -> Result<()> {`
`19`	`19`	`let (n, _) = l.size();`
`20`		`- let info = unsafe { $potrf(l.lapacke_layout(), uplo as u8, n, &mut a, n) };`
	`20`	`+ let info = $potrf(l.lapacke_layout(), uplo as u8, n, &mut a, n);`
`21`	`21`	`into_result(info, ())`
`22`	`22`	`}`
`23`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,17 +11,17 @@ use super::{UPLO, into_result};`
`11`	`11`
`12`	`12`	/// Wraps `syev` for real and `heev` for complex
`13`	`13`	`pub trait Eigh_: AssociatedReal {`
`14`		`- fn eigh(calc_eigenvec: bool, MatrixLayout, UPLO, a: &mut [Self]) -> Result<Vec<Self::Real>>;`
	`14`	`+ unsafe fn eigh(calc_eigenvec: bool, MatrixLayout, UPLO, a: &mut [Self]) -> Result<Vec<Self::Real>>;`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`macro_rules! impl_eigh {`
`18`	`18`	`($scalar:ty, $ev:path) => {`
`19`	`19`	`impl Eigh_ for $scalar {`
`20`		`- fn eigh(calc_v: bool, l: MatrixLayout, uplo: UPLO, mut a: &mut [Self]) -> Result<Vec<Self::Real>> {`
	`20`	`+ unsafe fn eigh(calc_v: bool, l: MatrixLayout, uplo: UPLO, mut a: &mut [Self]) -> Result<Vec<Self::Real>> {`
`21`	`21`	`let (n, _) = l.size();`
`22`	`22`	`let jobz = if calc_v { b'V' } else { b'N' };`
`23`	`23`	`let mut w = vec![Self::Real::zero(); n as usize];`
`24`		`- let info = unsafe { $ev(l.lapacke_layout(), jobz, uplo as u8, n, &mut a, n, &mut w) };`
	`24`	`+ let info = $ev(l.lapacke_layout(), jobz, uplo as u8, n, &mut a, n, &mut w);`
`25`	`25`	`into_result(info, w)`
`26`	`26`	`}`
`27`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,16 +24,16 @@ impl NormType {`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`pub trait OperatorNorm_: AssociatedReal {`
`27`		`- fn opnorm(NormType, MatrixLayout, &[Self]) -> Self::Real;`
	`27`	`+ unsafe fn opnorm(NormType, MatrixLayout, &[Self]) -> Self::Real;`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`macro_rules! impl_opnorm {`
`31`	`31`	`($scalar:ty, $lange:path) => {`
`32`	`32`	`impl OperatorNorm_ for $scalar {`
`33`		`- fn opnorm(t: NormType, l: MatrixLayout, a: &[Self]) -> Self::Real {`
	`33`	`+ unsafe fn opnorm(t: NormType, l: MatrixLayout, a: &[Self]) -> Self::Real {`
`34`	`34`	`match l {`
`35`		`- MatrixLayout::F((col, lda)) => unsafe { $lange(cm, t as u8, lda, col, a, lda) },`
`36`		`- MatrixLayout::C((row, lda)) => unsafe { $lange(cm, t.transpose() as u8, lda, row, a, lda) },`
	`35`	`+ MatrixLayout::F((col, lda)) => $lange(cm, t as u8, lda, col, a, lda),`
	`36`	`+ MatrixLayout::C((row, lda)) => $lange(cm, t.transpose() as u8, lda, row, a, lda),`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -43,6 +43,6 @@ where`
`43`	`43`	`fn opnorm(&self, t: NormType) -> Result<Self::Output> {`
`44`	`44`	`let l = self.layout()?;`
`45`	`45`	`let a = self.as_allocated()?;`
`46`		`- Ok(A::opnorm(t, l, a))`
	`46`	`+ Ok(unsafe { A::opnorm(t, l, a) })`
`47`	`47`	`}`
`48`	`48`	`}`