/rust/registry/src/index.crates.io-1949cf8c6b5b557f/nalgebra-0.35.0/src/base/conversion.rs

Source
#[cfg(all(feature = "alloc", not(feature = "std")))]
use alloc::vec::Vec;
use simba::scalar::{SubsetOf, SupersetOf};
use std::borrow::{Borrow, BorrowMut};
use std::convert::{AsMut, AsRef, From, Into};

use simba::simd::{PrimitiveSimdValue, SimdValue};

use crate::base::allocator::{Allocator, SameShapeAllocator};
use crate::base::constraint::{SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
use crate::base::dimension::{
    Const, Dim, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10, U11, U12, U13, U14, U15, U16,
};
#[cfg(any(feature = "std", feature = "alloc"))]
use crate::base::dimension::{DimName, Dyn};
use crate::base::iter::{MatrixIter, MatrixIterMut};
use crate::base::storage::{IsContiguous, RawStorage, RawStorageMut};
use crate::base::{
    ArrayStorage, DVectorView, DVectorViewMut, DefaultAllocator, Matrix, MatrixView, MatrixViewMut,
    OMatrix, Scalar,
};
#[cfg(any(feature = "std", feature = "alloc"))]
use crate::base::{DVector, RowDVector, VecStorage};
use crate::base::{ViewStorage, ViewStorageMut};
use crate::constraint::DimEq;
use crate::{IsNotStaticOne, RowSVector, SMatrix, SVector, VectorView, VectorViewMut};
use std::mem::MaybeUninit;

// TODO: too bad this won't work for slice conversions.
impl<T1, T2, R1, C1, R2, C2> SubsetOf<OMatrix<T2, R2, C2>> for OMatrix<T1, R1, C1>
where
    R1: Dim,
    C1: Dim,
    R2: Dim,
    C2: Dim,
    T1: Scalar,
    T2: Scalar + SupersetOf<T1>,
    DefaultAllocator: Allocator<R2, C2> + Allocator<R1, C1> + SameShapeAllocator<R1, C1, R2, C2>,
    ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
{
    #[inline]
    fn to_superset(&self) -> OMatrix<T2, R2, C2> {
        let (nrows, ncols) = self.shape();
        let nrows2 = R2::from_usize(nrows);
        let ncols2 = C2::from_usize(ncols);
        let mut res = Matrix::uninit(nrows2, ncols2);

        for i in 0..nrows {
            for j in 0..ncols {
                // Safety: all indices are in range.
                unsafe {
                    *res.get_unchecked_mut((i, j)) =
                        MaybeUninit::new(T2::from_subset(self.get_unchecked((i, j))));
                }
            }
        }

        // Safety: res is now fully initialized.
        unsafe { res.assume_init() }
    }

    #[inline]
    fn is_in_subset(m: &OMatrix<T2, R2, C2>) -> bool {
        m.iter().all(|e| e.is_in_subset())
    }

    #[inline]
    fn from_superset_unchecked(m: &OMatrix<T2, R2, C2>) -> Self {
        let (nrows2, ncols2) = m.shape();
        let nrows = R1::from_usize(nrows2);
        let ncols = C1::from_usize(ncols2);
        let mut res = Matrix::uninit(nrows, ncols);

        for i in 0..nrows2 {
            for j in 0..ncols2 {
                // Safety: all indices are in range.
                unsafe {
                    *res.get_unchecked_mut((i, j)) =
                        MaybeUninit::new(m.get_unchecked((i, j)).to_subset_unchecked())
                }
            }
        }

        unsafe { res.assume_init() }
    }
}

impl<'a, T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> IntoIterator
    for &'a Matrix<T, R, C, S>
{
    type Item = &'a T;
    type IntoIter = MatrixIter<'a, T, R, C, S>;

    #[inline]
    fn into_iter(self) -> Self::IntoIter {
        self.iter()
    }
}

impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> IntoIterator
    for Matrix<T, R, C, ViewStorage<'a, T, R, C, RStride, CStride>>
{
    type Item = &'a T;
    type IntoIter = MatrixIter<'a, T, R, C, ViewStorage<'a, T, R, C, RStride, CStride>>;

    #[inline]
    fn into_iter(self) -> Self::IntoIter {
        MatrixIter::new_owned(self.data)
    }
}

impl<'a, T: Scalar, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> IntoIterator
    for &'a mut Matrix<T, R, C, S>
{
    type Item = &'a mut T;
    type IntoIter = MatrixIterMut<'a, T, R, C, S>;

    #[inline]
    fn into_iter(self) -> Self::IntoIter {
        self.iter_mut()
    }
}

impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> IntoIterator
    for Matrix<T, R, C, ViewStorageMut<'a, T, R, C, RStride, CStride>>
{
    type Item = &'a mut T;
    type IntoIter = MatrixIterMut<'a, T, R, C, ViewStorageMut<'a, T, R, C, RStride, CStride>>;

    #[inline]
    fn into_iter(self) -> Self::IntoIter {
        MatrixIterMut::new_owned_mut(self.data)
    }
}

impl<T: Scalar, const D: usize> From<[T; D]> for SVector<T, D> {
    #[inline]
    fn from(arr: [T; D]) -> Self {
        unsafe { Self::from_data_statically_unchecked(ArrayStorage([arr; 1])) }
    }
}

impl<T: Scalar, const D: usize> From<SVector<T, D>> for [T; D] {
    #[inline]
    fn from(vec: SVector<T, D>) -> Self {
        // TODO: unfortunately, we must clone because we can move out of an array.
        vec.data.0[0].clone()
    }
}

impl<'a, T: Scalar, RStride: Dim, CStride: Dim, const D: usize>
    From<VectorView<'a, T, Const<D>, RStride, CStride>> for [T; D]
{
    #[inline]
    fn from(vec: VectorView<'a, T, Const<D>, RStride, CStride>) -> Self {
        vec.into_owned().into()
    }
}

impl<'a, T: Scalar, RStride: Dim, CStride: Dim, const D: usize>
    From<VectorViewMut<'a, T, Const<D>, RStride, CStride>> for [T; D]
{
    #[inline]
    fn from(vec: VectorViewMut<'a, T, Const<D>, RStride, CStride>) -> Self {
        vec.into_owned().into()
    }
}

impl<T: Scalar, const D: usize> From<[T; D]> for RowSVector<T, D>
where
    Const<D>: IsNotStaticOne,
{
    #[inline]
    fn from(arr: [T; D]) -> Self {
        SVector::<T, D>::from(arr).transpose()
    }
}

impl<T: Scalar, const D: usize> From<RowSVector<T, D>> for [T; D]
where
    Const<D>: IsNotStaticOne,
{
    #[inline]
    fn from(vec: RowSVector<T, D>) -> [T; D] {
        vec.transpose().into()
    }
}

macro_rules! impl_from_into_asref_1D(
    ($(($NRows: ident, $NCols: ident) => $SZ: expr_2021);* $(;)*) => {$(
        impl<T, S> AsRef<[T; $SZ]> for Matrix<T, $NRows, $NCols, S>
        where T: Scalar,
              S: RawStorage<T, $NRows, $NCols> + IsContiguous {
            #[inline]
            fn as_ref(&self) -> &[T; $SZ] {
                // Safety: this is OK thanks to the IsContiguous trait.
                unsafe {
                    &*(self.data.ptr() as *const [T; $SZ])
                }
            }
        }

        impl<T, S> AsMut<[T; $SZ]> for Matrix<T, $NRows, $NCols, S>
        where T: Scalar,
              S: RawStorageMut<T, $NRows, $NCols> + IsContiguous {
            #[inline]
            fn as_mut(&mut self) -> &mut [T; $SZ] {
                // Safety: this is OK thanks to the IsContiguous trait.
                unsafe {
                    &mut *(self.data.ptr_mut() as *mut [T; $SZ])
                }
            }
        }
    )*}
);

// Implement for vectors of dimension 1 .. 16.
impl_from_into_asref_1D!(
    // Row vectors.
    (U1, U1 ) => 1;  (U1, U2 ) => 2;  (U1, U3 ) => 3;  (U1, U4 ) => 4;
    (U1, U5 ) => 5;  (U1, U6 ) => 6;  (U1, U7 ) => 7;  (U1, U8 ) => 8;
    (U1, U9 ) => 9;  (U1, U10) => 10; (U1, U11) => 11; (U1, U12) => 12;
    (U1, U13) => 13; (U1, U14) => 14; (U1, U15) => 15; (U1, U16) => 16;

    // Column vectors.
                     (U2 , U1) => 2;  (U3 , U1) => 3;  (U4 , U1) => 4;
    (U5 , U1) => 5;  (U6 , U1) => 6;  (U7 , U1) => 7;  (U8 , U1) => 8;
    (U9 , U1) => 9;  (U10, U1) => 10; (U11, U1) => 11; (U12, U1) => 12;
    (U13, U1) => 13; (U14, U1) => 14; (U15, U1) => 15; (U16, U1) => 16;
);

impl<T: Scalar, const R: usize, const C: usize> From<[[T; R]; C]> for SMatrix<T, R, C> {
    #[inline]
    fn from(arr: [[T; R]; C]) -> Self {
        unsafe { Self::from_data_statically_unchecked(ArrayStorage(arr)) }
    }
}

impl<T: Scalar, const R: usize, const C: usize> From<SMatrix<T, R, C>> for [[T; R]; C] {
    #[inline]
    fn from(mat: SMatrix<T, R, C>) -> Self {
        mat.data.0
    }
}

impl<'a, T: Scalar, RStride: Dim, CStride: Dim, const R: usize, const C: usize>
    From<MatrixView<'a, T, Const<R>, Const<C>, RStride, CStride>> for [[T; R]; C]
{
    #[inline]
    fn from(mat: MatrixView<'a, T, Const<R>, Const<C>, RStride, CStride>) -> Self {
        mat.into_owned().into()
    }
}

impl<'a, T: Scalar, RStride: Dim, CStride: Dim, const R: usize, const C: usize>
    From<MatrixViewMut<'a, T, Const<R>, Const<C>, RStride, CStride>> for [[T; R]; C]
{
    #[inline]
    fn from(mat: MatrixViewMut<'a, T, Const<R>, Const<C>, RStride, CStride>) -> Self {
        mat.into_owned().into()
    }
}

macro_rules! impl_from_into_asref_borrow_2D(

    //does the impls on one case for either AsRef/AsMut and Borrow/BorrowMut
    (
        ($NRows: ty, $NCols: ty) => ($SZRows: expr_2021, $SZCols: expr_2021);
        $Ref:ident.$ref:ident(), $Mut:ident.$mut:ident()
    ) => {
        impl<T: Scalar, S> $Ref<[[T; $SZRows]; $SZCols]> for Matrix<T, $NRows, $NCols, S>
        where S: RawStorage<T, $NRows, $NCols> + IsContiguous {
            #[inline]
            fn $ref(&self) -> &[[T; $SZRows]; $SZCols] {
                // Safety: OK thanks to the IsContiguous trait.
                unsafe {
                    &*(self.data.ptr() as *const [[T; $SZRows]; $SZCols])
                }
            }
        }

        impl<T: Scalar, S> $Mut<[[T; $SZRows]; $SZCols]> for Matrix<T, $NRows, $NCols, S>
        where S: RawStorageMut<T, $NRows, $NCols> + IsContiguous {
            #[inline]
            fn $mut(&mut self) -> &mut [[T; $SZRows]; $SZCols] {
                // Safety: OK thanks to the IsContiguous trait.
                unsafe {
                    &mut *(self.data.ptr_mut() as *mut [[T; $SZRows]; $SZCols])
                }
            }
        }
    };

    //collects the mappings from typenum pairs to consts
    ($(($NRows: ty, $NCols: ty) => ($SZRows: expr_2021, $SZCols: expr_2021));* $(;)*) => {$(
        impl_from_into_asref_borrow_2D!(
            ($NRows, $NCols) => ($SZRows, $SZCols); AsRef.as_ref(), AsMut.as_mut()
        );
        impl_from_into_asref_borrow_2D!(
            ($NRows, $NCols) => ($SZRows, $SZCols); Borrow.borrow(), BorrowMut.borrow_mut()
        );
    )*}
);

// Implement for matrices with shape 2x2 .. 6x6.
impl_from_into_asref_borrow_2D!(
    (U2, U2) => (2, 2); (U2, U3) => (2, 3); (U2, U4) => (2, 4); (U2, U5) => (2, 5); (U2, U6) => (2, 6);
    (U3, U2) => (3, 2); (U3, U3) => (3, 3); (U3, U4) => (3, 4); (U3, U5) => (3, 5); (U3, U6) => (3, 6);
    (U4, U2) => (4, 2); (U4, U3) => (4, 3); (U4, U4) => (4, 4); (U4, U5) => (4, 5); (U4, U6) => (4, 6);
    (U5, U2) => (5, 2); (U5, U3) => (5, 3); (U5, U4) => (5, 4); (U5, U5) => (5, 5); (U5, U6) => (5, 6);
    (U6, U2) => (6, 2); (U6, U3) => (6, 3); (U6, U4) => (6, 4); (U6, U5) => (6, 5); (U6, U6) => (6, 6);
);

impl<'a, T, RStride, CStride, const R: usize, const C: usize>
    From<MatrixView<'a, T, Const<R>, Const<C>, RStride, CStride>>
    for Matrix<T, Const<R>, Const<C>, ArrayStorage<T, R, C>>
where
    T: Scalar,
    RStride: Dim,
    CStride: Dim,
{
    fn from(matrix_view: MatrixView<'a, T, Const<R>, Const<C>, RStride, CStride>) -> Self {
        matrix_view.into_owned()
    }
}

#[cfg(any(feature = "std", feature = "alloc"))]
impl<'a, T, C, RStride, CStride> From<MatrixView<'a, T, Dyn, C, RStride, CStride>>
    for Matrix<T, Dyn, C, VecStorage<T, Dyn, C>>
where
    T: Scalar,
    C: Dim,
    RStride: Dim,
    CStride: Dim,
{
    fn from(matrix_view: MatrixView<'a, T, Dyn, C, RStride, CStride>) -> Self {
        matrix_view.into_owned()
    }
}

#[cfg(any(feature = "std", feature = "alloc"))]
impl<'a, T, R, RStride, CStride> From<MatrixView<'a, T, R, Dyn, RStride, CStride>>
    for Matrix<T, R, Dyn, VecStorage<T, R, Dyn>>
where
    T: Scalar,
    R: DimName,
    RStride: Dim,
    CStride: Dim,
{
    fn from(matrix_view: MatrixView<'a, T, R, Dyn, RStride, CStride>) -> Self {
        matrix_view.into_owned()
    }
}

impl<'a, T, RStride, CStride, const R: usize, const C: usize>
    From<MatrixViewMut<'a, T, Const<R>, Const<C>, RStride, CStride>>
    for Matrix<T, Const<R>, Const<C>, ArrayStorage<T, R, C>>
where
    T: Scalar,
    RStride: Dim,
    CStride: Dim,
{
    fn from(matrix_view: MatrixViewMut<'a, T, Const<R>, Const<C>, RStride, CStride>) -> Self {
        matrix_view.into_owned()
    }
}

#[cfg(any(feature = "std", feature = "alloc"))]
impl<'a, T, C, RStride, CStride> From<MatrixViewMut<'a, T, Dyn, C, RStride, CStride>>
    for Matrix<T, Dyn, C, VecStorage<T, Dyn, C>>
where
    T: Scalar,
    C: Dim,
    RStride: Dim,
    CStride: Dim,
{
    fn from(matrix_view: MatrixViewMut<'a, T, Dyn, C, RStride, CStride>) -> Self {
        matrix_view.into_owned()
    }
}

#[cfg(any(feature = "std", feature = "alloc"))]
impl<'a, T, R, RStride, CStride> From<MatrixViewMut<'a, T, R, Dyn, RStride, CStride>>
    for Matrix<T, R, Dyn, VecStorage<T, R, Dyn>>
where
    T: Scalar,
    R: DimName,
    RStride: Dim,
    CStride: Dim,
{
    fn from(matrix_view: MatrixViewMut<'a, T, R, Dyn, RStride, CStride>) -> Self {
        matrix_view.into_owned()
    }
}

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
    R: Dim,
    C: Dim,
    RView: Dim,
    CView: Dim,
    RStride: Dim,
    CStride: Dim,
    S: RawStorage<T, R, C>,
    ShapeConstraint:
        DimEq<R, RView> + DimEq<C, CView> + DimEq<RStride, S::RStride> + DimEq<CStride, S::CStride>,
{
    fn from(m: &'a Matrix<T, R, C, S>) -> Self {
        let (row, col) = m.shape_generic();
        let rows_result = RView::from_usize(row.value());
        let cols_result = CView::from_usize(col.value());

        let (rstride, cstride) = m.strides();

        let rstride_result = RStride::from_usize(rstride);
        let cstride_result = CStride::from_usize(cstride);

        unsafe {
            let data = ViewStorage::from_raw_parts(
                m.data.ptr(),
                (rows_result, cols_result),
                (rstride_result, cstride_result),
            );
            Matrix::from_data_statically_unchecked(data)
        }
    }
}

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
    R: Dim,
    C: Dim,
    RView: Dim,
    CView: Dim,
    RStride: Dim,
    CStride: Dim,
    S: RawStorage<T, R, C>,
    ShapeConstraint:
        DimEq<R, RView> + DimEq<C, CView> + DimEq<RStride, S::RStride> + DimEq<CStride, S::CStride>,
{
    fn from(m: &'a mut Matrix<T, R, C, S>) -> Self {
        let (row, col) = m.shape_generic();
        let rows_result = RView::from_usize(row.value());
        let cols_result = CView::from_usize(col.value());

        let (rstride, cstride) = m.strides();

        let rstride_result = RStride::from_usize(rstride);
        let cstride_result = CStride::from_usize(cstride);

        unsafe {
            let data = ViewStorage::from_raw_parts(
                m.data.ptr(),
                (rows_result, cols_result),
                (rstride_result, cstride_result),
            );
            Matrix::from_data_statically_unchecked(data)
        }
    }
}

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
    R: Dim,
    C: Dim,
    RView: Dim,
    CView: Dim,
    RStride: Dim,
    CStride: Dim,
    S: RawStorageMut<T, R, C>,
    ShapeConstraint:
        DimEq<R, RView> + DimEq<C, CView> + DimEq<RStride, S::RStride> + DimEq<CStride, S::CStride>,
{
    fn from(m: &'a mut Matrix<T, R, C, S>) -> Self {
        let (row, col) = m.shape_generic();
        let rows_result = RView::from_usize(row.value());
        let cols_result = CView::from_usize(col.value());

        let (rstride, cstride) = m.strides();

        let rstride_result = RStride::from_usize(rstride);
        let cstride_result = CStride::from_usize(cstride);

        unsafe {
            let data = ViewStorageMut::from_raw_parts(
                m.data.ptr_mut(),
                (rows_result, cols_result),
                (rstride_result, cstride_result),
            );
            Matrix::from_data_statically_unchecked(data)
        }
    }
}

#[cfg(any(feature = "std", feature = "alloc"))]
impl<T: Scalar> From<Vec<T>> for DVector<T> {
    #[inline]
    fn from(vec: Vec<T>) -> Self {
        Self::from_vec(vec)
    }
}

#[cfg(any(feature = "std", feature = "alloc"))]
impl<T: Scalar> From<Vec<T>> for RowDVector<T> {
    #[inline]
    fn from(vec: Vec<T>) -> Self {
        Self::from_vec(vec)
    }
}

impl<'a, T: Scalar + Copy, R: Dim, C: Dim, S: RawStorage<T, R, C> + IsContiguous>
    From<&'a Matrix<T, R, C, S>> for &'a [T]
{
    #[inline]
    fn from(matrix: &'a Matrix<T, R, C, S>) -> Self {
        matrix.as_slice()
    }
}

impl<'a, T: Scalar + Copy, R: Dim, C: Dim, S: RawStorageMut<T, R, C> + IsContiguous>
    From<&'a mut Matrix<T, R, C, S>> for &'a mut [T]
{
    #[inline]
    fn from(matrix: &'a mut Matrix<T, R, C, S>) -> Self {
        matrix.as_mut_slice()
    }
}

impl<'a, T: Scalar + Copy> From<&'a [T]> for DVectorView<'a, T> {
    #[inline]
    fn from(slice: &'a [T]) -> Self {
        Self::from_slice(slice, slice.len())
    }
}

impl<'a, T: Scalar> From<DVectorView<'a, T>> for &'a [T] {
    fn from(vec: DVectorView<'a, T>) -> &'a [T] {
        vec.data.into_slice()
    }
}

impl<'a, T: Scalar + Copy> From<&'a mut [T]> for DVectorViewMut<'a, T> {
    #[inline]
    fn from(slice: &'a mut [T]) -> Self {
        Self::from_slice(slice, slice.len())
    }
}

impl<'a, T: Scalar> From<DVectorViewMut<'a, T>> for &'a mut [T] {
    fn from(vec: DVectorViewMut<'a, T>) -> &'a mut [T] {
        vec.data.into_slice_mut()
    }
}

impl<T: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[OMatrix<T::Element, R, C>; 2]>
    for OMatrix<T, R, C>
where
    T: From<[<T as SimdValue>::Element; 2]>,
    T::Element: Scalar + SimdValue,
    DefaultAllocator: Allocator<R, C>,
{
    #[inline]
    fn from(arr: [OMatrix<T::Element, R, C>; 2]) -> Self {
        let (nrows, ncols) = arr[0].shape_generic();

        Self::from_fn_generic(nrows, ncols, |i, j| {
            [arr[0][(i, j)].clone(), arr[1][(i, j)].clone()].into()
        })
    }
}

impl<T: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[OMatrix<T::Element, R, C>; 4]>
    for OMatrix<T, R, C>
where
    T: From<[<T as SimdValue>::Element; 4]>,
    T::Element: Scalar + SimdValue,
    DefaultAllocator: Allocator<R, C>,
{
    #[inline]
    fn from(arr: [OMatrix<T::Element, R, C>; 4]) -> Self {
        let (nrows, ncols) = arr[0].shape_generic();

        Self::from_fn_generic(nrows, ncols, |i, j| {
            [
                arr[0][(i, j)].clone(),
                arr[1][(i, j)].clone(),
                arr[2][(i, j)].clone(),
                arr[3][(i, j)].clone(),
            ]
            .into()
        })
    }
}

impl<T: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[OMatrix<T::Element, R, C>; 8]>
    for OMatrix<T, R, C>
where
    T: From<[<T as SimdValue>::Element; 8]>,
    T::Element: Scalar + SimdValue,
    DefaultAllocator: Allocator<R, C>,
{
    #[inline]
    fn from(arr: [OMatrix<T::Element, R, C>; 8]) -> Self {
        let (nrows, ncols) = arr[0].shape_generic();

        Self::from_fn_generic(nrows, ncols, |i, j| {
            [
                arr[0][(i, j)].clone(),
                arr[1][(i, j)].clone(),
                arr[2][(i, j)].clone(),
                arr[3][(i, j)].clone(),
                arr[4][(i, j)].clone(),
                arr[5][(i, j)].clone(),
                arr[6][(i, j)].clone(),
                arr[7][(i, j)].clone(),
            ]
            .into()
        })
    }
}

impl<T: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[OMatrix<T::Element, R, C>; 16]>
    for OMatrix<T, R, C>
where
    T: From<[<T as SimdValue>::Element; 16]>,
    T::Element: Scalar + SimdValue,
    DefaultAllocator: Allocator<R, C>,
{
    fn from(arr: [OMatrix<T::Element, R, C>; 16]) -> Self {
        let (nrows, ncols) = arr[0].shape_generic();

        Self::from_fn_generic(nrows, ncols, |i, j| {
            [
                arr[0][(i, j)].clone(),
                arr[1][(i, j)].clone(),
                arr[2][(i, j)].clone(),
                arr[3][(i, j)].clone(),
                arr[4][(i, j)].clone(),
                arr[5][(i, j)].clone(),
                arr[6][(i, j)].clone(),
                arr[7][(i, j)].clone(),
                arr[8][(i, j)].clone(),
                arr[9][(i, j)].clone(),
                arr[10][(i, j)].clone(),
                arr[11][(i, j)].clone(),
                arr[12][(i, j)].clone(),
                arr[13][(i, j)].clone(),
                arr[14][(i, j)].clone(),
                arr[15][(i, j)].clone(),
            ]
            .into()
        })
    }
}

Coverage Report

Created: 2026-07-30 06:46

Line	Count	Source
1		#[cfg(all(feature = "alloc", not(feature = "std")))]
2		use alloc::vec::Vec;
3		use simba::scalar::{SubsetOf, SupersetOf};
4		use std::borrow::{Borrow, BorrowMut};
5		use std::convert::{AsMut, AsRef, From, Into};
6
7		use simba::simd::{PrimitiveSimdValue, SimdValue};
8
9		use crate::base::allocator::{Allocator, SameShapeAllocator};
10		use crate::base::constraint::{SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
11		use crate::base::dimension::{
12		Const, Dim, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10, U11, U12, U13, U14, U15, U16,
13		};
14		#[cfg(any(feature = "std", feature = "alloc"))]
15		use crate::base::dimension::{DimName, Dyn};
16		use crate::base::iter::{MatrixIter, MatrixIterMut};
17		use crate::base::storage::{IsContiguous, RawStorage, RawStorageMut};
18		use crate::base::{
19		ArrayStorage, DVectorView, DVectorViewMut, DefaultAllocator, Matrix, MatrixView, MatrixViewMut,
20		OMatrix, Scalar,
21		};
22		#[cfg(any(feature = "std", feature = "alloc"))]
23		use crate::base::{DVector, RowDVector, VecStorage};
24		use crate::base::{ViewStorage, ViewStorageMut};
25		use crate::constraint::DimEq;
26		use crate::{IsNotStaticOne, RowSVector, SMatrix, SVector, VectorView, VectorViewMut};
27		use std::mem::MaybeUninit;
28
29		// TODO: too bad this won't work for slice conversions.
30		impl<T1, T2, R1, C1, R2, C2> SubsetOf<OMatrix<T2, R2, C2>> for OMatrix<T1, R1, C1>
31		where
32		R1: Dim,
33		C1: Dim,
34		R2: Dim,
35		C2: Dim,
36		T1: Scalar,
37		T2: Scalar + SupersetOf<T1>,
38		DefaultAllocator: Allocator<R2, C2> + Allocator<R1, C1> + SameShapeAllocator<R1, C1, R2, C2>,
39		ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
40		{
41		#[inline]
42		fn to_superset(&self) -> OMatrix<T2, R2, C2> {
43		let (nrows, ncols) = self.shape();
44		let nrows2 = R2::from_usize(nrows);
45		let ncols2 = C2::from_usize(ncols);
46		let mut res = Matrix::uninit(nrows2, ncols2);
47
48		for i in 0..nrows {
49		for j in 0..ncols {
50		// Safety: all indices are in range.
51		unsafe {
52		*res.get_unchecked_mut((i, j)) =
53		MaybeUninit::new(T2::from_subset(self.get_unchecked((i, j))));
54		}
55		}
56		}
57
58		// Safety: res is now fully initialized.
59		unsafe { res.assume_init() }
60		}
61
62		#[inline]
63		fn is_in_subset(m: &OMatrix<T2, R2, C2>) -> bool {
64		m.iter().all(\|e\| e.is_in_subset())
65		}
66
67		#[inline]
68		fn from_superset_unchecked(m: &OMatrix<T2, R2, C2>) -> Self {
69		let (nrows2, ncols2) = m.shape();
70		let nrows = R1::from_usize(nrows2);
71		let ncols = C1::from_usize(ncols2);
72		let mut res = Matrix::uninit(nrows, ncols);
73
74		for i in 0..nrows2 {
75		for j in 0..ncols2 {
76		// Safety: all indices are in range.
77		unsafe {
78		*res.get_unchecked_mut((i, j)) =
79		MaybeUninit::new(m.get_unchecked((i, j)).to_subset_unchecked())
80		}
81		}
82		}
83
84		unsafe { res.assume_init() }
85		}
86		}
87
88		impl<'a, T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> IntoIterator
89		for &'a Matrix<T, R, C, S>
90		{
91		type Item = &'a T;
92		type IntoIter = MatrixIter<'a, T, R, C, S>;
93
94		#[inline]
95		fn into_iter(self) -> Self::IntoIter {
96		self.iter()
97		}
98		}
99
100		impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> IntoIterator
101		for Matrix<T, R, C, ViewStorage<'a, T, R, C, RStride, CStride>>
102		{
103		type Item = &'a T;
104		type IntoIter = MatrixIter<'a, T, R, C, ViewStorage<'a, T, R, C, RStride, CStride>>;
105
106		#[inline]
107		fn into_iter(self) -> Self::IntoIter {
108		MatrixIter::new_owned(self.data)
109		}
110		}
111
112		impl<'a, T: Scalar, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> IntoIterator
113		for &'a mut Matrix<T, R, C, S>
114		{
115		type Item = &'a mut T;
116		type IntoIter = MatrixIterMut<'a, T, R, C, S>;
117
118		#[inline]
119		fn into_iter(self) -> Self::IntoIter {
120		self.iter_mut()
121		}
122		}
123
124		impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> IntoIterator
125		for Matrix<T, R, C, ViewStorageMut<'a, T, R, C, RStride, CStride>>
126		{
127		type Item = &'a mut T;
128		type IntoIter = MatrixIterMut<'a, T, R, C, ViewStorageMut<'a, T, R, C, RStride, CStride>>;
129
130		#[inline]
131		fn into_iter(self) -> Self::IntoIter {
132		MatrixIterMut::new_owned_mut(self.data)
133		}
134		}
135
136		impl<T: Scalar, const D: usize> From<[T; D]> for SVector<T, D> {
137		#[inline]
138		fn from(arr: [T; D]) -> Self {
139		unsafe { Self::from_data_statically_unchecked(ArrayStorage([arr; 1])) }
140		}
141		}
142
143		impl<T: Scalar, const D: usize> From<SVector<T, D>> for [T; D] {
144		#[inline]
145		fn from(vec: SVector<T, D>) -> Self {
146		// TODO: unfortunately, we must clone because we can move out of an array.
147		vec.data.0[0].clone()
148		}
149		}
150
151		impl<'a, T: Scalar, RStride: Dim, CStride: Dim, const D: usize>
152		From<VectorView<'a, T, Const<D>, RStride, CStride>> for [T; D]
153		{
154		#[inline]
155		fn from(vec: VectorView<'a, T, Const<D>, RStride, CStride>) -> Self {
156		vec.into_owned().into()
157		}
158		}
159
160		impl<'a, T: Scalar, RStride: Dim, CStride: Dim, const D: usize>
161		From<VectorViewMut<'a, T, Const<D>, RStride, CStride>> for [T; D]
162		{
163		#[inline]
164		fn from(vec: VectorViewMut<'a, T, Const<D>, RStride, CStride>) -> Self {
165		vec.into_owned().into()
166		}
167		}
168
169		impl<T: Scalar, const D: usize> From<[T; D]> for RowSVector<T, D>
170		where
171		Const<D>: IsNotStaticOne,
172		{
173		#[inline]
174		fn from(arr: [T; D]) -> Self {
175		SVector::<T, D>::from(arr).transpose()
176		}
177		}
178
179		impl<T: Scalar, const D: usize> From<RowSVector<T, D>> for [T; D]
180		where
181		Const<D>: IsNotStaticOne,
182		{
183		#[inline]
184		fn from(vec: RowSVector<T, D>) -> [T; D] {
185		vec.transpose().into()
186		}
187		}
188
189		macro_rules! impl_from_into_asref_1D(
190		($(($NRows: ident, $NCols: ident) => $SZ: expr_2021);* $(;)*) => {$(
191		impl<T, S> AsRef<[T; $SZ]> for Matrix<T, $NRows, $NCols, S>
192		where T: Scalar,
193		S: RawStorage<T, $NRows, $NCols> + IsContiguous {
194		#[inline]
195		fn as_ref(&self) -> &[T; $SZ] {
196		// Safety: this is OK thanks to the IsContiguous trait.
197		unsafe {
198		&(self.data.ptr() as const [T; $SZ])
199		}
200		}
201		}
202
203		impl<T, S> AsMut<[T; $SZ]> for Matrix<T, $NRows, $NCols, S>
204		where T: Scalar,
205		S: RawStorageMut<T, $NRows, $NCols> + IsContiguous {
206		#[inline]
207		fn as_mut(&mut self) -> &mut [T; $SZ] {
208		// Safety: this is OK thanks to the IsContiguous trait.
209		unsafe {
210		&mut (self.data.ptr_mut() as mut [T; $SZ])
211		}
212		}
213		}
214		)*}
215		);
216
217		// Implement for vectors of dimension 1 .. 16.
218		impl_from_into_asref_1D!(
219		// Row vectors.
220		(U1, U1 ) => 1; (U1, U2 ) => 2; (U1, U3 ) => 3; (U1, U4 ) => 4;
221		(U1, U5 ) => 5; (U1, U6 ) => 6; (U1, U7 ) => 7; (U1, U8 ) => 8;
222		(U1, U9 ) => 9; (U1, U10) => 10; (U1, U11) => 11; (U1, U12) => 12;
223		(U1, U13) => 13; (U1, U14) => 14; (U1, U15) => 15; (U1, U16) => 16;
224
225		// Column vectors.
226		(U2 , U1) => 2; (U3 , U1) => 3; (U4 , U1) => 4;
227		(U5 , U1) => 5; (U6 , U1) => 6; (U7 , U1) => 7; (U8 , U1) => 8;
228		(U9 , U1) => 9; (U10, U1) => 10; (U11, U1) => 11; (U12, U1) => 12;
229		(U13, U1) => 13; (U14, U1) => 14; (U15, U1) => 15; (U16, U1) => 16;
230		);
231
232		impl<T: Scalar, const R: usize, const C: usize> From<[[T; R]; C]> for SMatrix<T, R, C> {
233		#[inline]
234	621	fn from(arr: [[T; R]; C]) -> Self {
235	621	unsafe { Self::from_data_statically_unchecked(ArrayStorage(arr)) }
236	621	}
237		}
238
239		impl<T: Scalar, const R: usize, const C: usize> From<SMatrix<T, R, C>> for [[T; R]; C] {
240		#[inline]
241		fn from(mat: SMatrix<T, R, C>) -> Self {
242		mat.data.0
243		}
244		}
245
246		impl<'a, T: Scalar, RStride: Dim, CStride: Dim, const R: usize, const C: usize>
247		From<MatrixView<'a, T, Const<R>, Const<C>, RStride, CStride>> for [[T; R]; C]
248		{
249		#[inline]
250		fn from(mat: MatrixView<'a, T, Const<R>, Const<C>, RStride, CStride>) -> Self {
251		mat.into_owned().into()
252		}
253		}
254
255		impl<'a, T: Scalar, RStride: Dim, CStride: Dim, const R: usize, const C: usize>
256		From<MatrixViewMut<'a, T, Const<R>, Const<C>, RStride, CStride>> for [[T; R]; C]
257		{
258		#[inline]
259		fn from(mat: MatrixViewMut<'a, T, Const<R>, Const<C>, RStride, CStride>) -> Self {
260		mat.into_owned().into()
261		}
262		}
263
264		macro_rules! impl_from_into_asref_borrow_2D(
265
266		//does the impls on one case for either AsRef/AsMut and Borrow/BorrowMut
267		(
268		($NRows: ty, $NCols: ty) => ($SZRows: expr_2021, $SZCols: expr_2021);
269		$Ref:ident.$ref:ident(), $Mut:ident.$mut:ident()
270		) => {
271		impl<T: Scalar, S> $Ref<[[T; $SZRows]; $SZCols]> for Matrix<T, $NRows, $NCols, S>
272		where S: RawStorage<T, $NRows, $NCols> + IsContiguous {
273		#[inline]
274		fn $ref(&self) -> &[[T; $SZRows]; $SZCols] {
275		// Safety: OK thanks to the IsContiguous trait.
276		unsafe {
277		&(self.data.ptr() as const [[T; $SZRows]; $SZCols])
278		}
279		}
280		}
281
282		impl<T: Scalar, S> $Mut<[[T; $SZRows]; $SZCols]> for Matrix<T, $NRows, $NCols, S>
283		where S: RawStorageMut<T, $NRows, $NCols> + IsContiguous {
284		#[inline]
285		fn $mut(&mut self) -> &mut [[T; $SZRows]; $SZCols] {
286		// Safety: OK thanks to the IsContiguous trait.
287		unsafe {
288		&mut (self.data.ptr_mut() as mut [[T; $SZRows]; $SZCols])
289		}
290		}
291		}
292		};
293
294		//collects the mappings from typenum pairs to consts
295		($(($NRows: ty, $NCols: ty) => ($SZRows: expr_2021, $SZCols: expr_2021));* $(;)*) => {$(
296		impl_from_into_asref_borrow_2D!(
297		($NRows, $NCols) => ($SZRows, $SZCols); AsRef.as_ref(), AsMut.as_mut()
298		);
299		impl_from_into_asref_borrow_2D!(
300		($NRows, $NCols) => ($SZRows, $SZCols); Borrow.borrow(), BorrowMut.borrow_mut()
301		);
302		)*}
303		);
304
305		// Implement for matrices with shape 2x2 .. 6x6.
306		impl_from_into_asref_borrow_2D!(
307		(U2, U2) => (2, 2); (U2, U3) => (2, 3); (U2, U4) => (2, 4); (U2, U5) => (2, 5); (U2, U6) => (2, 6);
308		(U3, U2) => (3, 2); (U3, U3) => (3, 3); (U3, U4) => (3, 4); (U3, U5) => (3, 5); (U3, U6) => (3, 6);
309		(U4, U2) => (4, 2); (U4, U3) => (4, 3); (U4, U4) => (4, 4); (U4, U5) => (4, 5); (U4, U6) => (4, 6);
310		(U5, U2) => (5, 2); (U5, U3) => (5, 3); (U5, U4) => (5, 4); (U5, U5) => (5, 5); (U5, U6) => (5, 6);
311		(U6, U2) => (6, 2); (U6, U3) => (6, 3); (U6, U4) => (6, 4); (U6, U5) => (6, 5); (U6, U6) => (6, 6);
312		);
313
314		impl<'a, T, RStride, CStride, const R: usize, const C: usize>
315		From<MatrixView<'a, T, Const<R>, Const<C>, RStride, CStride>>
316		for Matrix<T, Const<R>, Const<C>, ArrayStorage<T, R, C>>
317		where
318		T: Scalar,
319		RStride: Dim,
320		CStride: Dim,
321		{
322	0	fn from(matrix_view: MatrixView<'a, T, Const<R>, Const<C>, RStride, CStride>) -> Self {
323	0	matrix_view.into_owned()
324	0	}
325		}
326
327		#[cfg(any(feature = "std", feature = "alloc"))]
328		impl<'a, T, C, RStride, CStride> From<MatrixView<'a, T, Dyn, C, RStride, CStride>>
329		for Matrix<T, Dyn, C, VecStorage<T, Dyn, C>>
330		where
331		T: Scalar,
332		C: Dim,
333		RStride: Dim,
334		CStride: Dim,
335		{
336		fn from(matrix_view: MatrixView<'a, T, Dyn, C, RStride, CStride>) -> Self {
337		matrix_view.into_owned()
338		}
339		}
340
341		#[cfg(any(feature = "std", feature = "alloc"))]
342		impl<'a, T, R, RStride, CStride> From<MatrixView<'a, T, R, Dyn, RStride, CStride>>
343		for Matrix<T, R, Dyn, VecStorage<T, R, Dyn>>
344		where
345		T: Scalar,
346		R: DimName,
347		RStride: Dim,
348		CStride: Dim,
349		{
350		fn from(matrix_view: MatrixView<'a, T, R, Dyn, RStride, CStride>) -> Self {
351		matrix_view.into_owned()
352		}
353		}
354
355		impl<'a, T, RStride, CStride, const R: usize, const C: usize>
356		From<MatrixViewMut<'a, T, Const<R>, Const<C>, RStride, CStride>>
357		for Matrix<T, Const<R>, Const<C>, ArrayStorage<T, R, C>>
358		where
359		T: Scalar,
360		RStride: Dim,
361		CStride: Dim,
362		{
363		fn from(matrix_view: MatrixViewMut<'a, T, Const<R>, Const<C>, RStride, CStride>) -> Self {
364		matrix_view.into_owned()
365		}
366		}
367
368		#[cfg(any(feature = "std", feature = "alloc"))]
369		impl<'a, T, C, RStride, CStride> From<MatrixViewMut<'a, T, Dyn, C, RStride, CStride>>
370		for Matrix<T, Dyn, C, VecStorage<T, Dyn, C>>
371		where
372		T: Scalar,
373		C: Dim,
374		RStride: Dim,
375		CStride: Dim,
376		{
377		fn from(matrix_view: MatrixViewMut<'a, T, Dyn, C, RStride, CStride>) -> Self {
378		matrix_view.into_owned()
379		}
380		}
381
382		#[cfg(any(feature = "std", feature = "alloc"))]
383		impl<'a, T, R, RStride, CStride> From<MatrixViewMut<'a, T, R, Dyn, RStride, CStride>>
384		for Matrix<T, R, Dyn, VecStorage<T, R, Dyn>>
385		where
386		T: Scalar,
387		R: DimName,
388		RStride: Dim,
389		CStride: Dim,
390		{
391		fn from(matrix_view: MatrixViewMut<'a, T, R, Dyn, RStride, CStride>) -> Self {
392		matrix_view.into_owned()
393		}
394		}
395
396		impl<'a, T, R, C, RView, CView, RStride, CStride, S> From<&'a Matrix<T, R, C, S>>
397		for MatrixView<'a, T, RView, CView, RStride, CStride>
398		where
399		R: Dim,
400		C: Dim,
401		RView: Dim,
402		CView: Dim,
403		RStride: Dim,
404		CStride: Dim,
405		S: RawStorage<T, R, C>,
406		ShapeConstraint:
407		DimEq<R, RView> + DimEq<C, CView> + DimEq<RStride, S::RStride> + DimEq<CStride, S::CStride>,
408		{
409		fn from(m: &'a Matrix<T, R, C, S>) -> Self {
410		let (row, col) = m.shape_generic();
411		let rows_result = RView::from_usize(row.value());
412		let cols_result = CView::from_usize(col.value());
413
414		let (rstride, cstride) = m.strides();
415
416		let rstride_result = RStride::from_usize(rstride);
417		let cstride_result = CStride::from_usize(cstride);
418
419		unsafe {
420		let data = ViewStorage::from_raw_parts(
421		m.data.ptr(),
422		(rows_result, cols_result),
423		(rstride_result, cstride_result),
424		);
425		Matrix::from_data_statically_unchecked(data)
426		}
427		}
428		}
429
430		impl<'a, T, R, C, RView, CView, RStride, CStride, S> From<&'a mut Matrix<T, R, C, S>>
431		for MatrixView<'a, T, RView, CView, RStride, CStride>
432		where
433		R: Dim,
434		C: Dim,
435		RView: Dim,
436		CView: Dim,
437		RStride: Dim,
438		CStride: Dim,
439		S: RawStorage<T, R, C>,
440		ShapeConstraint:
441		DimEq<R, RView> + DimEq<C, CView> + DimEq<RStride, S::RStride> + DimEq<CStride, S::CStride>,
442		{
443		fn from(m: &'a mut Matrix<T, R, C, S>) -> Self {
444		let (row, col) = m.shape_generic();
445		let rows_result = RView::from_usize(row.value());
446		let cols_result = CView::from_usize(col.value());
447
448		let (rstride, cstride) = m.strides();
449
450		let rstride_result = RStride::from_usize(rstride);
451		let cstride_result = CStride::from_usize(cstride);
452
453		unsafe {
454		let data = ViewStorage::from_raw_parts(
455		m.data.ptr(),
456		(rows_result, cols_result),
457		(rstride_result, cstride_result),
458		);
459		Matrix::from_data_statically_unchecked(data)
460		}
461		}
462		}
463
464		impl<'a, T, R, C, RView, CView, RStride, CStride, S> From<&'a mut Matrix<T, R, C, S>>
465		for MatrixViewMut<'a, T, RView, CView, RStride, CStride>
466		where
467		R: Dim,
468		C: Dim,
469		RView: Dim,
470		CView: Dim,
471		RStride: Dim,
472		CStride: Dim,
473		S: RawStorageMut<T, R, C>,
474		ShapeConstraint:
475		DimEq<R, RView> + DimEq<C, CView> + DimEq<RStride, S::RStride> + DimEq<CStride, S::CStride>,
476		{
477		fn from(m: &'a mut Matrix<T, R, C, S>) -> Self {
478		let (row, col) = m.shape_generic();
479		let rows_result = RView::from_usize(row.value());
480		let cols_result = CView::from_usize(col.value());
481
482		let (rstride, cstride) = m.strides();
483
484		let rstride_result = RStride::from_usize(rstride);
485		let cstride_result = CStride::from_usize(cstride);
486
487		unsafe {
488		let data = ViewStorageMut::from_raw_parts(
489		m.data.ptr_mut(),
490		(rows_result, cols_result),
491		(rstride_result, cstride_result),
492		);
493		Matrix::from_data_statically_unchecked(data)
494		}
495		}
496		}
497
498		#[cfg(any(feature = "std", feature = "alloc"))]
499		impl<T: Scalar> From<Vec<T>> for DVector<T> {
500		#[inline]
501		fn from(vec: Vec<T>) -> Self {
502		Self::from_vec(vec)
503		}
504		}
505
506		#[cfg(any(feature = "std", feature = "alloc"))]
507		impl<T: Scalar> From<Vec<T>> for RowDVector<T> {
508		#[inline]
509		fn from(vec: Vec<T>) -> Self {
510		Self::from_vec(vec)
511		}
512		}
513
514		impl<'a, T: Scalar + Copy, R: Dim, C: Dim, S: RawStorage<T, R, C> + IsContiguous>
515		From<&'a Matrix<T, R, C, S>> for &'a [T]
516		{
517		#[inline]
518		fn from(matrix: &'a Matrix<T, R, C, S>) -> Self {
519		matrix.as_slice()
520		}
521		}
522
523		impl<'a, T: Scalar + Copy, R: Dim, C: Dim, S: RawStorageMut<T, R, C> + IsContiguous>
524		From<&'a mut Matrix<T, R, C, S>> for &'a mut [T]
525		{
526		#[inline]
527		fn from(matrix: &'a mut Matrix<T, R, C, S>) -> Self {
528		matrix.as_mut_slice()
529		}
530		}
531
532		impl<'a, T: Scalar + Copy> From<&'a [T]> for DVectorView<'a, T> {
533		#[inline]
534		fn from(slice: &'a [T]) -> Self {
535		Self::from_slice(slice, slice.len())
536		}
537		}
538
539		impl<'a, T: Scalar> From<DVectorView<'a, T>> for &'a [T] {
540		fn from(vec: DVectorView<'a, T>) -> &'a [T] {
541		vec.data.into_slice()
542		}
543		}
544
545		impl<'a, T: Scalar + Copy> From<&'a mut [T]> for DVectorViewMut<'a, T> {
546		#[inline]
547		fn from(slice: &'a mut [T]) -> Self {
548		Self::from_slice(slice, slice.len())
549		}
550		}
551
552		impl<'a, T: Scalar> From<DVectorViewMut<'a, T>> for &'a mut [T] {
553		fn from(vec: DVectorViewMut<'a, T>) -> &'a mut [T] {
554		vec.data.into_slice_mut()
555		}
556		}
557
558		impl<T: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[OMatrix<T::Element, R, C>; 2]>
559		for OMatrix<T, R, C>
560		where
561		T: From<[<T as SimdValue>::Element; 2]>,
562		T::Element: Scalar + SimdValue,
563		DefaultAllocator: Allocator<R, C>,
564		{
565		#[inline]
566		fn from(arr: [OMatrix<T::Element, R, C>; 2]) -> Self {
567		let (nrows, ncols) = arr[0].shape_generic();
568
569		Self::from_fn_generic(nrows, ncols, \|i, j\| {
570		[arr[0][(i, j)].clone(), arr[1][(i, j)].clone()].into()
571		})
572		}
573		}
574
575		impl<T: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[OMatrix<T::Element, R, C>; 4]>
576		for OMatrix<T, R, C>
577		where
578		T: From<[<T as SimdValue>::Element; 4]>,
579		T::Element: Scalar + SimdValue,
580		DefaultAllocator: Allocator<R, C>,
581		{
582		#[inline]
583		fn from(arr: [OMatrix<T::Element, R, C>; 4]) -> Self {
584		let (nrows, ncols) = arr[0].shape_generic();
585
586		Self::from_fn_generic(nrows, ncols, \|i, j\| {
587		[
588		arr[0][(i, j)].clone(),
589		arr[1][(i, j)].clone(),
590		arr[2][(i, j)].clone(),
591		arr[3][(i, j)].clone(),
592		]
593		.into()
594		})
595		}
596		}
597
598		impl<T: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[OMatrix<T::Element, R, C>; 8]>
599		for OMatrix<T, R, C>
600		where
601		T: From<[<T as SimdValue>::Element; 8]>,
602		T::Element: Scalar + SimdValue,
603		DefaultAllocator: Allocator<R, C>,
604		{
605		#[inline]
606		fn from(arr: [OMatrix<T::Element, R, C>; 8]) -> Self {
607		let (nrows, ncols) = arr[0].shape_generic();
608
609		Self::from_fn_generic(nrows, ncols, \|i, j\| {
610		[
611		arr[0][(i, j)].clone(),
612		arr[1][(i, j)].clone(),
613		arr[2][(i, j)].clone(),
614		arr[3][(i, j)].clone(),
615		arr[4][(i, j)].clone(),
616		arr[5][(i, j)].clone(),
617		arr[6][(i, j)].clone(),
618		arr[7][(i, j)].clone(),
619		]
620		.into()
621		})
622		}
623		}
624
625		impl<T: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[OMatrix<T::Element, R, C>; 16]>
626		for OMatrix<T, R, C>
627		where
628		T: From<[<T as SimdValue>::Element; 16]>,
629		T::Element: Scalar + SimdValue,
630		DefaultAllocator: Allocator<R, C>,
631		{
632		fn from(arr: [OMatrix<T::Element, R, C>; 16]) -> Self {
633		let (nrows, ncols) = arr[0].shape_generic();
634
635		Self::from_fn_generic(nrows, ncols, \|i, j\| {
636		[
637		arr[0][(i, j)].clone(),
638		arr[1][(i, j)].clone(),
639		arr[2][(i, j)].clone(),
640		arr[3][(i, j)].clone(),
641		arr[4][(i, j)].clone(),
642		arr[5][(i, j)].clone(),
643		arr[6][(i, j)].clone(),
644		arr[7][(i, j)].clone(),
645		arr[8][(i, j)].clone(),
646		arr[9][(i, j)].clone(),
647		arr[10][(i, j)].clone(),
648		arr[11][(i, j)].clone(),
649		arr[12][(i, j)].clone(),
650		arr[13][(i, j)].clone(),
651		arr[14][(i, j)].clone(),
652		arr[15][(i, j)].clone(),
653		]
654		.into()
655		})
656		}
657		}