opnorm() for ArrayBase

Author: termoshtt

src/impl2/opnorm.rs

@@ -12,36 +12,21 @@ pub enum NormType {
     Frobenius = b'f',
 }
 
-pub trait OperatorNorm_: Sized {
-    type Output;
-
-    fn opnorm(NormType, Layout, &[Self]) -> Self::Output;
-
-    fn opnorm_one(l: Layout, a: &[Self]) -> Self::Output {
-        Self::opnorm(NormType::One, l, a)
-    }
-
-    fn opnorm_inf(l: Layout, a: &[Self]) -> Self::Output {
-        Self::opnorm(NormType::Infinity, l, a)
-    }
-
-    fn opnorm_fro(l: Layout, a: &[Self]) -> Self::Output {
-        Self::opnorm(NormType::Frobenius, l, a)
-    }
+pub trait OperatorNorm_: AssociatedReal {
+    fn opnorm(NormType, Layout, &[Self]) -> Self::Real;
 }
 
 macro_rules! impl_opnorm {
-    ($scalar:ty, $output:ty, $lange:path) => {
+    ($scalar:ty, $lange:path) => {
 impl OperatorNorm_ for $scalar {
-    type Output = $output;
-    fn opnorm(t: NormType, l: Layout, a: &[Self]) -> Self::Output {
+    fn opnorm(t: NormType, l: Layout, a: &[Self]) -> Self::Real {
         let (m, n) = l.ffi_size();
         $lange(l.ffi_layout(), t as u8, m, n, a, m)
     }
 }
 }} // impl_opnorm!
 
-impl_opnorm!(f64, f64, c::dlange);
-impl_opnorm!(f32, f32, c::slange);
-impl_opnorm!(c64, f64, c::zlange);
-impl_opnorm!(c32, f32, c::clange);
+impl_opnorm!(f64, c::dlange);
+impl_opnorm!(f32, c::slange);
+impl_opnorm!(c64, c::zlange);
+impl_opnorm!(c32, c::clange);

src/lib.rs

@@ -48,6 +48,8 @@ pub mod layout;
 pub mod impls;
 pub mod impl2;
 
+pub mod traits;
+
 pub mod vector;
 pub mod matrix;
 pub mod square;

src/traits.rs

@@ -0,0 +1,36 @@
+
+pub use impl2::LapackScalar;
+pub use impl2::NormType;
+
+use ndarray::*;
+
+use super::types::*;
+use super::error::*;
+use super::layout::*;
+
+pub trait OperationNorm {
+    type Output;
+    fn opnorm(&self, t: NormType) -> Self::Output;
+    fn opnorm_one(&self) -> Self::Output {
+        self.opnorm(NormType::One)
+    }
+    fn opnorm_inf(&self) -> Self::Output {
+        self.opnorm(NormType::Infinity)
+    }
+    fn opnorm_fro(&self) -> Self::Output {
+        self.opnorm(NormType::Frobenius)
+    }
+}
+
+impl<A, S> OperationNorm for ArrayBase<S, Ix2>
+    where A: LapackScalar + AssociatedReal,
+          S: Data<Elem = A>
+{
+    type Output = Result<A::Real>;
+
+    fn opnorm(&self, t: NormType) -> Self::Output {
+        let l = self.layout()?;
+        let a = self.as_allocated()?;
+        Ok(A::opnorm(t, l, a))
+    }
+}