From 31e687bd76b22430ed3f18e6af761e4a551fa78e Mon Sep 17 00:00:00 2001
From: Andreas Longva <andreas.b.longva@gmail.com>
Date: Mon, 14 Nov 2022 16:41:01 +0100
Subject: [PATCH] Implement Matrix::{as_view, as_view_mut} methods

---
 src/base/conversion.rs  |  3 --
 src/base/matrix_view.rs | 85 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 85 insertions(+), 3 deletions(-)

diff --git a/src/base/conversion.rs b/src/base/conversion.rs
index 79a61461..20553257 100644
--- a/src/base/conversion.rs
+++ b/src/base/conversion.rs
@@ -373,7 +373,6 @@ where
 impl<'a, T, R, C, RView, CView, RStride, CStride, S> From<&'a Matrix<T, R, C, S>>
     for MatrixView<'a, T, RView, CView, RStride, CStride>
 where
-    T: Scalar,
     R: Dim,
     C: Dim,
     RView: Dim,
@@ -410,7 +409,6 @@ where
 impl<'a, T, R, C, RView, CView, RStride, CStride, S> From<&'a mut Matrix<T, R, C, S>>
     for MatrixView<'a, T, RView, CView, RStride, CStride>
 where
-    T: Scalar,
     R: Dim,
     C: Dim,
     RView: Dim,
@@ -447,7 +445,6 @@ where
 impl<'a, T, R, C, RView, CView, RStride, CStride, S> From<&'a mut Matrix<T, R, C, S>>
     for MatrixViewMut<'a, T, RView, CView, RStride, CStride>
 where
-    T: Scalar,
     R: Dim,
     C: Dim,
     RView: Dim,
diff --git a/src/base/matrix_view.rs b/src/base/matrix_view.rs
index ef024f19..210e7a57 100644
--- a/src/base/matrix_view.rs
+++ b/src/base/matrix_view.rs
@@ -8,6 +8,7 @@ use crate::base::dimension::{Const, Dim, DimName, Dynamic, IsNotStaticOne, U1};
 use crate::base::iter::MatrixIter;
 use crate::base::storage::{IsContiguous, Owned, RawStorage, RawStorageMut, Storage};
 use crate::base::{Matrix, Scalar};
+use crate::constraint::{DimEq, ShapeConstraint};
 
 macro_rules! view_storage_impl (
     ($doc: expr; $Storage: ident as $SRef: ty; $legacy_name:ident => $T: ident.$get_addr: ident ($Ptr: ty as $Ref: ty)) => {
@@ -1091,3 +1092,87 @@ where
         unsafe { Matrix::from_data_statically_unchecked(data) }
     }
 }
+
+impl<T, R, C, S> Matrix<T, R, C, S>
+where
+    R: Dim,
+    C: Dim,
+    S: RawStorage<T, R, C>,
+{
+    /// Returns this matrix as a view.
+    ///
+    /// The returned view type is generally ambiguous unless specified.
+    /// This is particularly useful when working with functions or methods that take
+    /// matrix views as input.
+    ///
+    /// # Panics
+    /// Panics if the dimensions of the view and the matrix are not compatible and this cannot
+    /// be proven at compile-time. This might happen, for example, when constructing a static
+    /// view of size 3x3 from a dynamically sized matrix of dimension 5x5.
+    ///
+    /// # Examples
+    /// ```
+    /// use nalgebra::{DMatrixSlice, SMatrixView};
+    ///
+    /// fn consume_view(_: DMatrixSlice<f64>) {}
+    ///
+    /// let matrix = nalgebra::Matrix3::zeros();
+    /// consume_view(matrix.as_view());
+    ///
+    /// let dynamic_view: DMatrixSlice<f64> = matrix.as_view();
+    /// let static_view_from_dyn: SMatrixView<f64, 3, 3> = dynamic_view.as_view();
+    /// ```
+    pub fn as_view<RView, CView, RViewStride, CViewStride>(&self) -> MatrixView<'_, T, RView, CView, RViewStride, CViewStride>
+    where
+        RView: Dim,
+        CView: Dim,
+        RViewStride: Dim,
+        CViewStride: Dim,
+        ShapeConstraint: DimEq<R, RView> + DimEq<C, CView> + DimEq<RViewStride, S::RStride> + DimEq<CViewStride, S::CStride>
+    {
+        // Defer to (&matrix).into()
+        self.into()
+    }
+}
+
+impl<T, R, C, S> Matrix<T, R, C, S>
+where
+    R: Dim,
+    C: Dim,
+    S: RawStorageMut<T, R, C>,
+{
+    /// Returns this matrix as a mutable view.
+    ///
+    /// The returned view type is generally ambiguous unless specified.
+    /// This is particularly useful when working with functions or methods that take
+    /// matrix views as input.
+    ///
+    /// # Panics
+    /// Panics if the dimensions of the view and the matrix are not compatible and this cannot
+    /// be proven at compile-time. This might happen, for example, when constructing a static
+    /// view of size 3x3 from a dynamically sized matrix of dimension 5x5.
+    ///
+    /// # Examples
+    /// ```
+    /// use nalgebra::{DMatrixViewMut, SMatrixViewMut};
+    ///
+    /// fn consume_view(_: DMatrixViewMut<f64>) {}
+    ///
+    /// let mut matrix = nalgebra::Matrix3::zeros();
+    /// consume_view(matrix.as_view_mut());
+    ///
+    /// let mut dynamic_view: DMatrixViewMut<f64> = matrix.as_view_mut();
+    /// let static_view_from_dyn: SMatrixViewMut<f64, 3, 3> = dynamic_view.as_view_mut();
+    /// ```
+    pub fn as_view_mut<RView, CView, RViewStride, CViewStride>(&mut self) -> MatrixViewMut<'_, T, RView, CView, RViewStride, CViewStride>
+        where
+            RView: Dim,
+            CView: Dim,
+            RViewStride: Dim,
+            CViewStride: Dim,
+            ShapeConstraint: DimEq<R, RView> + DimEq<C, CView> + DimEq<RViewStride, S::RStride> + DimEq<CViewStride, S::CStride>
+    {
+        // Defer to (&mut matrix).into()
+        self.into()
+    }
+}