First draft of `Owned` overhaul

This commit is contained in:
Violeta Hernández 2021-07-19 18:00:40 -05:00
parent a753d84aae
commit 22b657f566
41 changed files with 392 additions and 205 deletions

View File

@ -1,11 +1,10 @@
#[cfg(any(feature = "alloc", feature = "std"))] #[cfg(any(feature = "alloc", feature = "std"))]
use crate::base::dimension::Dynamic; use crate::base::dimension::Dynamic;
use crate::base::dimension::{U1, U2, U3, U4, U5, U6}; use crate::base::dimension::{U1, U2, U3, U4, U5, U6};
use crate::base::storage::Owned; use crate::base::storage::InnerOwned;
#[cfg(any(feature = "std", feature = "alloc"))] #[cfg(any(feature = "std", feature = "alloc"))]
use crate::base::vec_storage::VecStorage; use crate::base::vec_storage::VecStorage;
use crate::base::{ArrayStorage, Const, Matrix, Unit}; use crate::base::{ArrayStorage, Const, Matrix, Owned, Unit};
/* /*
* *
@ -26,13 +25,13 @@ pub type OMatrix<T, R, C> = Matrix<T, R, C, Owned<T, R, C>>;
#[deprecated( #[deprecated(
note = "use SMatrix for a statically-sized matrix using integer dimensions, or OMatrix for an owned matrix using types as dimensions." note = "use SMatrix for a statically-sized matrix using integer dimensions, or OMatrix for an owned matrix using types as dimensions."
)] )]
pub type MatrixMN<T, R, C> = Matrix<T, R, C, Owned<T, R, C>>; pub type MatrixMN<T, R, C> = OMatrix<T, R, C>;
/// An owned matrix column-major matrix with `D` columns. /// An owned matrix column-major matrix with `D` columns.
/// ///
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
#[deprecated(note = "use OMatrix<T, D, D> or SMatrix<T, D, D> instead.")] #[deprecated(note = "use OMatrix<T, D, D> or SMatrix<T, D, D> instead.")]
pub type MatrixN<T, D> = Matrix<T, D, D, Owned<T, D, D>>; pub type MatrixN<T, D> = Matrix<T, D, D, InnerOwned<T, D, D>>;
/// A statically sized column-major matrix with `R` rows and `C` columns. /// A statically sized column-major matrix with `R` rows and `C` columns.
/// ///
@ -275,7 +274,7 @@ pub type Matrix6x5<T> = Matrix<T, U6, U5, ArrayStorage<T, 6, 5>>;
pub type DVector<T> = Matrix<T, Dynamic, U1, VecStorage<T, Dynamic, U1>>; pub type DVector<T> = Matrix<T, Dynamic, U1, VecStorage<T, Dynamic, U1>>;
/// An owned D-dimensional column vector. /// An owned D-dimensional column vector.
pub type OVector<T, D> = Matrix<T, D, U1, Owned<T, D, U1>>; pub type OVector<T, D> = Matrix<T, D, U1, InnerOwned<T, D, U1>>;
/// A statically sized D-dimensional column vector. /// A statically sized D-dimensional column vector.
pub type SVector<T, const D: usize> = Matrix<T, Const<D>, U1, ArrayStorage<T, D, 1>>; // Owned<T, Const<D>, U1>>; pub type SVector<T, const D: usize> = Matrix<T, Const<D>, U1, ArrayStorage<T, D, 1>>; // Owned<T, Const<D>, U1>>;
@ -285,7 +284,7 @@ pub type SVector<T, const D: usize> = Matrix<T, Const<D>, U1, ArrayStorage<T, D,
#[deprecated( #[deprecated(
note = "use SVector for a statically-sized matrix using integer dimensions, or OVector for an owned matrix using types as dimensions." note = "use SVector for a statically-sized matrix using integer dimensions, or OVector for an owned matrix using types as dimensions."
)] )]
pub type VectorN<T, D> = Matrix<T, D, U1, Owned<T, D, U1>>; pub type VectorN<T, D> = Matrix<T, D, U1, InnerOwned<T, D, U1>>;
/// A stack-allocated, 1-dimensional column vector. /// A stack-allocated, 1-dimensional column vector.
pub type Vector1<T> = Matrix<T, U1, U1, ArrayStorage<T, 1, 1>>; pub type Vector1<T> = Matrix<T, U1, U1, ArrayStorage<T, 1, 1>>;
@ -312,7 +311,7 @@ pub type Vector6<T> = Matrix<T, U6, U1, ArrayStorage<T, 6, 1>>;
pub type RowDVector<T> = Matrix<T, U1, Dynamic, VecStorage<T, U1, Dynamic>>; pub type RowDVector<T> = Matrix<T, U1, Dynamic, VecStorage<T, U1, Dynamic>>;
/// An owned D-dimensional row vector. /// An owned D-dimensional row vector.
pub type RowOVector<T, D> = Matrix<T, U1, D, Owned<T, U1, D>>; pub type RowOVector<T, D> = Matrix<T, U1, D, InnerOwned<T, U1, D>>;
/// A statically sized D-dimensional row vector. /// A statically sized D-dimensional row vector.
pub type RowSVector<T, const D: usize> = Matrix<T, U1, Const<D>, ArrayStorage<T, 1, D>>; pub type RowSVector<T, const D: usize> = Matrix<T, U1, Const<D>, ArrayStorage<T, 1, D>>;

View File

@ -59,6 +59,7 @@ pub trait Allocator<T, R: Dim, C: Dim = U1>:
) -> <Self as InnerAllocator<ManuallyDrop<T>, R, C>>::Buffer; ) -> <Self as InnerAllocator<ManuallyDrop<T>, R, C>>::Buffer;
} }
/// A matrix reallocator. Changes the size of the memory buffer that initially contains (RFrom × /// A matrix reallocator. Changes the size of the memory buffer that initially contains (RFrom ×
/// CFrom) elements to a smaller or larger size (RTo, CTo). /// CFrom) elements to a smaller or larger size (RTo, CTo).
pub trait Reallocator<T, RFrom: Dim, CFrom: Dim, RTo: Dim, CTo: Dim>: pub trait Reallocator<T, RFrom: Dim, CFrom: Dim, RTo: Dim, CTo: Dim>:
@ -68,6 +69,7 @@ pub trait Reallocator<T, RFrom: Dim, CFrom: Dim, RTo: Dim, CTo: Dim>:
/// `buf`. Data stored by `buf` are linearly copied to the output: /// `buf`. Data stored by `buf` are linearly copied to the output:
/// ///
/// # Safety /// # Safety
/// **NO! THIS IS STILL UB!**
/// * The copy is performed as if both were just arrays (without a matrix structure). /// * The copy is performed as if both were just arrays (without a matrix structure).
/// * If `buf` is larger than the output size, then extra elements of `buf` are truncated. /// * If `buf` is larger than the output size, then extra elements of `buf` are truncated.
/// * If `buf` is smaller than the output size, then extra elements of the output are left /// * If `buf` is smaller than the output size, then extra elements of the output are left

View File

@ -21,8 +21,9 @@ use crate::allocator::InnerAllocator;
use crate::base::default_allocator::DefaultAllocator; use crate::base::default_allocator::DefaultAllocator;
use crate::base::dimension::{Const, ToTypenum}; use crate::base::dimension::{Const, ToTypenum};
use crate::base::storage::{ use crate::base::storage::{
ContiguousStorage, ContiguousStorageMut, Owned, ReshapableStorage, Storage, StorageMut, ContiguousStorage, ContiguousStorageMut, ReshapableStorage, Storage, StorageMut,
}; };
use crate::base::Owned;
/* /*
* *
@ -85,7 +86,7 @@ where
where where
DefaultAllocator: InnerAllocator<T, Const<R>, Const<C>>, DefaultAllocator: InnerAllocator<T, Const<R>, Const<C>>,
{ {
self Owned(self)
} }
#[inline] #[inline]
@ -95,7 +96,11 @@ where
DefaultAllocator: InnerAllocator<T, Const<R>, Const<C>>, DefaultAllocator: InnerAllocator<T, Const<R>, Const<C>>,
{ {
let it = self.as_slice().iter().cloned(); let it = self.as_slice().iter().cloned();
DefaultAllocator::allocate_from_iterator(self.shape().0, self.shape().1, it) Owned(DefaultAllocator::allocate_from_iterator(
self.shape().0,
self.shape().1,
it,
))
} }
#[inline] #[inline]

View File

@ -2,7 +2,7 @@
use alloc::vec::Vec; use alloc::vec::Vec;
#[cfg(feature = "arbitrary")] #[cfg(feature = "arbitrary")]
use crate::base::storage::Owned; use crate::base::storage::InnerOwned;
#[cfg(feature = "arbitrary")] #[cfg(feature = "arbitrary")]
use quickcheck::{Arbitrary, Gen}; use quickcheck::{Arbitrary, Gen};
@ -898,7 +898,7 @@ impl<T, R: Dim, C: Dim> Arbitrary for OMatrix<T, R, C>
where where
T: Arbitrary + Send, T: Arbitrary + Send,
DefaultAllocator: Allocator<T, R, C>, DefaultAllocator: Allocator<T, R, C>,
Owned<T, R, C>: Clone + Send, InnerOwned<T, R, C>: Clone + Send,
{ {
#[inline] #[inline]
fn arbitrary(g: &mut Gen) -> Self { fn arbitrary(g: &mut Gen) -> Self {

View File

@ -4,22 +4,25 @@
//! heap-allocated buffers for matrices with at least one dimension unknown at compile-time. //! heap-allocated buffers for matrices with at least one dimension unknown at compile-time.
use std::cmp; use std::cmp;
use std::mem::{ManuallyDrop, MaybeUninit}; use std::fmt;
use std::mem::{self, ManuallyDrop, MaybeUninit};
use std::ptr; use std::ptr;
#[cfg(all(feature = "alloc", not(feature = "std")))] #[cfg(all(feature = "alloc", not(feature = "std")))]
use alloc::vec::Vec; use alloc::vec::Vec;
#[cfg(any(feature = "alloc", feature = "std"))]
use crate::base::dimension::Dynamic;
use super::Const; use super::Const;
use crate::base::allocator::{Allocator, InnerAllocator, Reallocator}; use crate::base::allocator::{Allocator, InnerAllocator, Reallocator};
use crate::base::array_storage::ArrayStorage; use crate::base::array_storage::ArrayStorage;
#[cfg(any(feature = "alloc", feature = "std"))]
use crate::base::dimension::Dynamic;
use crate::base::dimension::{Dim, DimName}; use crate::base::dimension::{Dim, DimName};
use crate::base::storage::{ContiguousStorageMut, Storage, StorageMut}; use crate::base::storage::{
#[cfg(any(feature = "std", feature = "alloc"))] ContiguousStorage, ContiguousStorageMut, InnerOwned, Storage, StorageMut,
};
use crate::base::vec_storage::VecStorage; use crate::base::vec_storage::VecStorage;
use crate::storage::Owned; use crate::U1;
/* /*
* *
@ -66,7 +69,7 @@ impl<T, const R: usize, const C: usize> Allocator<T, Const<R>, Const<C>> for Def
fn allocate_uninitialized( fn allocate_uninitialized(
_: Const<R>, _: Const<R>,
_: Const<C>, _: Const<C>,
) -> Owned<MaybeUninit<T>, Const<R>, Const<C>> { ) -> InnerOwned<MaybeUninit<T>, Const<R>, Const<C>> {
// SAFETY: An uninitialized `[MaybeUninit<_>; _]` is valid. // SAFETY: An uninitialized `[MaybeUninit<_>; _]` is valid.
let array = unsafe { MaybeUninit::uninit().assume_init() }; let array = unsafe { MaybeUninit::uninit().assume_init() };
ArrayStorage(array) ArrayStorage(array)
@ -75,7 +78,7 @@ impl<T, const R: usize, const C: usize> Allocator<T, Const<R>, Const<C>> for Def
#[inline] #[inline]
unsafe fn assume_init( unsafe fn assume_init(
uninit: <Self as InnerAllocator<MaybeUninit<T>, Const<R>, Const<C>>>::Buffer, uninit: <Self as InnerAllocator<MaybeUninit<T>, Const<R>, Const<C>>>::Buffer,
) -> Owned<T, Const<R>, Const<C>> { ) -> InnerOwned<T, Const<R>, Const<C>> {
// Safety: // Safety:
// * The caller guarantees that all elements of the array are initialized // * The caller guarantees that all elements of the array are initialized
// * `MaybeUninit<T>` and T are guaranteed to have the same layout // * `MaybeUninit<T>` and T are guaranteed to have the same layout
@ -120,7 +123,7 @@ impl<T, C: Dim> InnerAllocator<T, Dynamic, C> for DefaultAllocator {
impl<T, C: Dim> Allocator<T, Dynamic, C> for DefaultAllocator { impl<T, C: Dim> Allocator<T, Dynamic, C> for DefaultAllocator {
#[inline] #[inline]
fn allocate_uninitialized(nrows: Dynamic, ncols: C) -> Owned<MaybeUninit<T>, Dynamic, C> { fn allocate_uninitialized(nrows: Dynamic, ncols: C) -> InnerOwned<MaybeUninit<T>, Dynamic, C> {
let mut data = Vec::new(); let mut data = Vec::new();
let length = nrows.value() * ncols.value(); let length = nrows.value() * ncols.value();
data.reserve_exact(length); data.reserve_exact(length);
@ -130,7 +133,9 @@ impl<T, C: Dim> Allocator<T, Dynamic, C> for DefaultAllocator {
} }
#[inline] #[inline]
unsafe fn assume_init(uninit: Owned<MaybeUninit<T>, Dynamic, C>) -> Owned<T, Dynamic, C> { unsafe fn assume_init(
uninit: InnerOwned<MaybeUninit<T>, Dynamic, C>,
) -> InnerOwned<T, Dynamic, C> {
// Avoids a double-drop. // Avoids a double-drop.
let (nrows, ncols) = uninit.shape(); let (nrows, ncols) = uninit.shape();
let vec: Vec<_> = uninit.into(); let vec: Vec<_> = uninit.into();
@ -173,7 +178,7 @@ impl<T, R: DimName> InnerAllocator<T, R, Dynamic> for DefaultAllocator {
nrows: R, nrows: R,
ncols: Dynamic, ncols: Dynamic,
iter: I, iter: I,
) -> Owned<T, R, Dynamic> { ) -> InnerOwned<T, R, Dynamic> {
let it = iter.into_iter(); let it = iter.into_iter();
let res: Vec<T> = it.collect(); let res: Vec<T> = it.collect();
assert!(res.len() == nrows.value() * ncols.value(), assert!(res.len() == nrows.value() * ncols.value(),
@ -185,7 +190,7 @@ impl<T, R: DimName> InnerAllocator<T, R, Dynamic> for DefaultAllocator {
impl<T, R: DimName> Allocator<T, R, Dynamic> for DefaultAllocator { impl<T, R: DimName> Allocator<T, R, Dynamic> for DefaultAllocator {
#[inline] #[inline]
fn allocate_uninitialized(nrows: R, ncols: Dynamic) -> Owned<MaybeUninit<T>, R, Dynamic> { fn allocate_uninitialized(nrows: R, ncols: Dynamic) -> InnerOwned<MaybeUninit<T>, R, Dynamic> {
let mut data = Vec::new(); let mut data = Vec::new();
let length = nrows.value() * ncols.value(); let length = nrows.value() * ncols.value();
data.reserve_exact(length); data.reserve_exact(length);
@ -195,7 +200,9 @@ impl<T, R: DimName> Allocator<T, R, Dynamic> for DefaultAllocator {
} }
#[inline] #[inline]
unsafe fn assume_init(uninit: Owned<MaybeUninit<T>, R, Dynamic>) -> Owned<T, R, Dynamic> { unsafe fn assume_init(
uninit: InnerOwned<MaybeUninit<T>, R, Dynamic>,
) -> InnerOwned<T, R, Dynamic> {
// Avoids a double-drop. // Avoids a double-drop.
let (nrows, ncols) = uninit.shape(); let (nrows, ncols) = uninit.shape();
let vec: Vec<_> = uninit.into(); let vec: Vec<_> = uninit.into();
@ -228,6 +235,170 @@ impl<T, R: DimName> Allocator<T, R, Dynamic> for DefaultAllocator {
} }
} }
/// The owned storage type for a matrix.
#[repr(transparent)]
pub struct Owned<T, R: Dim, C: Dim>(pub InnerOwned<T, R, C>)
where
DefaultAllocator: Allocator<T, R, C>;
impl<T: Copy, R: DimName, C: DimName> Copy for Owned<T, R, C>
where
DefaultAllocator: Allocator<T, R, C>,
InnerOwned<T, R, C>: Copy,
{
}
impl<T: Clone, R: Dim, C: Dim> Clone for Owned<T, R, C>
where
DefaultAllocator: Allocator<T, R, C>,
{
fn clone(&self) -> Self {
if Self::is_array() {
// We first clone the data.
let slice = unsafe { self.as_slice_unchecked() };
let vec = ManuallyDrop::new(slice.to_owned());
// We then transmute it back into an array and then an Owned.
unsafe { mem::transmute_copy(&*vec.as_ptr()) }
// TODO: check that the auxiliary copy is elided.
} else {
// We first clone the data.
let clone = ManuallyDrop::new(self.as_vec_storage().clone());
// We then transmute it back into an Owned.
unsafe { mem::transmute_copy(&clone) }
// TODO: check that the auxiliary copy is elided.
}
}
}
impl<T: fmt::Debug, R: Dim, C: Dim> fmt::Debug for Owned<T, R, C>
where
DefaultAllocator: Allocator<T, R, C>,
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
if Self::is_array() {
let slice = unsafe { self.as_slice_unchecked() };
slice.fmt(f)
} else {
self.as_vec_storage().fmt(f)
}
}
}
impl<T, R: Dim, C: Dim> Owned<T, R, C>
where
DefaultAllocator: Allocator<T, R, C>,
{
/// Returns whether `Self` stores an [`ArrayStorage`].
fn is_array() -> bool {
R::is_static() && C::is_static()
}
/// Returns whether `Self` stores a [`VecStorage`].
fn is_vec() -> bool {
!Self::is_array()
}
/// Returns the underlying [`VecStorage`]. Does not do any sort of static
/// type checking.
///
/// # Panics
/// This method will panic if `Self` does not contain a [`VecStorage`].
fn as_vec_storage(&self) -> &VecStorage<T, R, C> {
assert!(Self::is_vec());
// Safety: `self` is transparent and must contain a `VecStorage`.
unsafe { &*(&self as *const _ as *const _) }
}
}
unsafe impl<T, R: Dim, C: Dim> Storage<T, R, C> for Owned<T, R, C>
where
DefaultAllocator: Allocator<T, R, C>,
{
type RStride = U1;
type CStride = R;
fn ptr(&self) -> *const T {
if Self::is_array() {
&self as *const _ as *const T
} else {
self.as_vec_storage().as_vec().as_ptr()
}
}
fn shape(&self) -> (R, C) {
if Self::is_array() {
(R::default(), C::default())
} else {
let vec = self.as_vec_storage();
(vec.nrows, vec.ncols)
}
}
fn strides(&self) -> (Self::RStride, Self::CStride) {
if Self::is_array() {
(U1::name(), R::default())
} else {
let vec = self.as_vec_storage();
(U1::name(), vec.nrows)
}
}
fn is_contiguous(&self) -> bool {
true
}
unsafe fn as_slice_unchecked(&self) -> &[T] {
if Self::is_array() {
std::slice::from_raw_parts(
self.ptr(),
R::try_to_usize().unwrap() * C::try_to_usize().unwrap(),
)
} else {
self.as_vec_storage().as_vec().as_ref()
}
}
fn into_owned(self) -> Owned<T, R, C> {
self
}
fn clone_owned(&self) -> Owned<T, R, C>
where
T: Clone,
{
self.clone()
}
}
unsafe impl<T, R: Dim, C: Dim> StorageMut<T, R, C> for Owned<T, R, C>
where
DefaultAllocator: Allocator<T, R, C>,
{
fn ptr_mut(&mut self) -> *mut T {
todo!()
}
unsafe fn as_mut_slice_unchecked(&mut self) -> &mut [T] {
todo!()
}
}
unsafe impl<T, R: Dim, C: Dim> ContiguousStorage<T, R, C> for Owned<T, R, C> where
DefaultAllocator: Allocator<T, R, C>
{
}
unsafe impl<T, R: Dim, C: Dim> ContiguousStorageMut<T, R, C> for Owned<T, R, C> where
DefaultAllocator: Allocator<T, R, C>
{
}
/* /*
* *
* Reallocator. * Reallocator.
@ -243,7 +414,7 @@ where
unsafe fn reallocate_copy( unsafe fn reallocate_copy(
rto: Const<RTO>, rto: Const<RTO>,
cto: Const<CTO>, cto: Const<CTO>,
buf: Owned<T, RFrom, CFrom>, buf: InnerOwned<T, RFrom, CFrom>,
) -> ArrayStorage<T, RTO, CTO> { ) -> ArrayStorage<T, RTO, CTO> {
let mut res = let mut res =
<Self as Allocator<_, Const<RTO>, Const<CTO>>>::allocate_uninitialized(rto, cto); <Self as Allocator<_, Const<RTO>, Const<CTO>>>::allocate_uninitialized(rto, cto);

View File

@ -12,7 +12,7 @@ use typenum::{self, Diff, Max, Maximum, Min, Minimum, Prod, Quot, Sum, Unsigned}
use serde::{Deserialize, Deserializer, Serialize, Serializer}; use serde::{Deserialize, Deserializer, Serialize, Serializer};
/// Stores the dimension of dynamically-sized algebraic entities. /// Stores the dimension of dynamically-sized algebraic entities.
#[derive(Clone, Copy, Eq, PartialEq, Debug)] #[derive(Clone, Copy, Default, Eq, PartialEq, Debug)]
pub struct Dynamic { pub struct Dynamic {
value: usize, value: usize,
} }
@ -55,7 +55,7 @@ impl IsNotStaticOne for Dynamic {}
/// Trait implemented by any type that can be used as a dimension. This includes type-level /// Trait implemented by any type that can be used as a dimension. This includes type-level
/// integers and `Dynamic` (for dimensions not known at compile-time). /// integers and `Dynamic` (for dimensions not known at compile-time).
pub trait Dim: 'static + Debug + Copy + PartialEq + Send + Sync { pub trait Dim: 'static + Debug + Copy + Default + PartialEq + Send + Sync {
#[inline(always)] #[inline(always)]
fn is<D: Dim>() -> bool { fn is<D: Dim>() -> bool {
TypeId::of::<Self>() == TypeId::of::<D>() TypeId::of::<Self>() == TypeId::of::<D>()
@ -65,6 +65,16 @@ pub trait Dim: 'static + Debug + Copy + PartialEq + Send + Sync {
/// Dynamic`. /// Dynamic`.
fn try_to_usize() -> Option<usize>; fn try_to_usize() -> Option<usize>;
/// Returns whether `Self` has a known compile-time value.
fn is_static() -> bool {
Self::try_to_usize().is_some()
}
/// Returns whether `Self` does not have a known compile-time value.
fn is_dynamic() -> bool {
Self::try_to_usize().is_none()
}
/// Gets the run-time value of `self`. For type-level integers, this is the same as /// Gets the run-time value of `self`. For type-level integers, this is the same as
/// `Self::try_to_usize().unwrap()`. /// `Self::try_to_usize().unwrap()`.
fn value(&self) -> usize; fn value(&self) -> usize;
@ -199,7 +209,7 @@ dim_ops!(
/// A wrapper around const types, which provides the capability of performing /// A wrapper around const types, which provides the capability of performing
/// type-level arithmetic. This might get removed if const-generics become /// type-level arithmetic. This might get removed if const-generics become
/// more powerful in the future. /// more powerful in the future.
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] #[derive(Debug, Copy, Clone, Default, PartialEq, Eq, Hash)]
pub struct Const<const R: usize>; pub struct Const<const R: usize>;
/// Trait implemented exclusively by type-level integers. /// Trait implemented exclusively by type-level integers.

View File

@ -812,7 +812,7 @@ impl<T: Clone, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
let mut data = self.data.into_owned(); let mut data = self.data.into_owned();
if new_nrows.value() == nrows { if new_nrows.value() == nrows {
let res = unsafe { DefaultAllocator::reallocate_copy(new_nrows, new_ncols, data) }; let res = unsafe { DefaultAllocator::reallocate_copy(new_nrows, new_ncols, data.0) };
let mut res = Matrix::from_data(res); let mut res = Matrix::from_data(res);
if new_ncols.value() > ncols { if new_ncols.value() > ncols {
res.columns_range_mut(ncols..).fill(val); res.columns_range_mut(ncols..).fill(val);
@ -832,11 +832,11 @@ impl<T: Clone, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
nrows - new_nrows.value(), nrows - new_nrows.value(),
); );
res = Matrix::from_data(DefaultAllocator::reallocate_copy( res = Matrix::from_data(DefaultAllocator::reallocate_copy(
new_nrows, new_ncols, data, new_nrows, new_ncols, data.0,
)); ));
} else { } else {
res = Matrix::from_data(DefaultAllocator::reallocate_copy( res = Matrix::from_data(DefaultAllocator::reallocate_copy(
new_nrows, new_ncols, data, new_nrows, new_ncols, data.0,
)); ));
extend_rows( extend_rows(
&mut res.data.as_mut_slice(), &mut res.data.as_mut_slice(),

View File

@ -153,7 +153,7 @@ pub type MatrixCross<T, R1, C1, R2, C2> =
/// dynamically-sized column vector should be represented as a `Matrix<T, Dynamic, U1, S>` (given /// dynamically-sized column vector should be represented as a `Matrix<T, Dynamic, U1, S>` (given
/// some concrete types for `T` and a compatible data storage type `S`). /// some concrete types for `T` and a compatible data storage type `S`).
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy)] #[derive(Clone,Copy,Debug)]
pub struct Matrix<T, R, C, S> { pub struct Matrix<T, R, C, S> {
/// The data storage that contains all the matrix components. Disappointed? /// The data storage that contains all the matrix components. Disappointed?
/// ///
@ -193,12 +193,6 @@ pub struct Matrix<T, R, C, S> {
_phantoms: PhantomData<(T, R, C)>, _phantoms: PhantomData<(T, R, C)>,
} }
impl<T, R: Dim, C: Dim, S: fmt::Debug> fmt::Debug for Matrix<T, R, C, S> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Matrix").field("data", &self.data).finish()
}
}
impl<T, R: Dim, C: Dim, S> Default for Matrix<T, R, C, S> impl<T, R: Dim, C: Dim, S> Default for Matrix<T, R, C, S>
where where
S: Storage<T, R, C> + Default, S: Storage<T, R, C> + Default,
@ -640,7 +634,7 @@ impl<T, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
T: Clone, T: Clone,
DefaultAllocator: Allocator<T, R, C>, DefaultAllocator: Allocator<T, R, C>,
{ {
Matrix::from_data(self.data.into_owned()) Matrix::from_data(self.data.into_owned().0)
} }
// TODO: this could probably benefit from specialization. // TODO: this could probably benefit from specialization.
@ -680,7 +674,7 @@ impl<T, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
T: Clone, T: Clone,
DefaultAllocator: Allocator<T, R, C>, DefaultAllocator: Allocator<T, R, C>,
{ {
Matrix::from_data(self.data.clone_owned()) Matrix::from_data(self.data.clone_owned().0)
} }
/// Clones this matrix into one that owns its data. The actual type of the result depends on /// Clones this matrix into one that owns its data. The actual type of the result depends on

View File

@ -7,8 +7,8 @@ use crate::base::allocator::{Allocator, InnerAllocator};
use crate::base::default_allocator::DefaultAllocator; use crate::base::default_allocator::DefaultAllocator;
use crate::base::dimension::{Const, Dim, DimName, Dynamic, IsNotStaticOne, U1}; use crate::base::dimension::{Const, Dim, DimName, Dynamic, IsNotStaticOne, U1};
use crate::base::iter::MatrixIter; use crate::base::iter::MatrixIter;
use crate::base::storage::{ContiguousStorage, ContiguousStorageMut, Owned, Storage, StorageMut}; use crate::base::storage::{ContiguousStorage, ContiguousStorageMut, Storage, StorageMut};
use crate::base::Matrix; use crate::base::{Matrix, Owned};
macro_rules! slice_storage_impl( macro_rules! slice_storage_impl(
($doc: expr; $Storage: ident as $SRef: ty; $T: ident.$get_addr: ident ($Ptr: ty as $Ref: ty)) => { ($doc: expr; $Storage: ident as $SRef: ty; $T: ident.$get_addr: ident ($Ptr: ty as $Ref: ty)) => {
@ -199,7 +199,7 @@ macro_rules! storage_impl(
{ {
let (nrows, ncols) = self.shape(); let (nrows, ncols) = self.shape();
let it = MatrixIter::new(self).cloned(); let it = MatrixIter::new(self).cloned();
DefaultAllocator::allocate_from_iterator(nrows, ncols, it) Owned( DefaultAllocator::allocate_from_iterator(nrows, ncols, it))
} }
#[inline] #[inline]

View File

@ -16,7 +16,7 @@ use crate::base::constraint::{
use crate::base::dimension::{Dim, DimMul, DimName, DimProd, Dynamic}; use crate::base::dimension::{Dim, DimMul, DimName, DimProd, Dynamic};
use crate::base::storage::{ContiguousStorageMut, Storage, StorageMut}; use crate::base::storage::{ContiguousStorageMut, Storage, StorageMut};
use crate::base::{DefaultAllocator, Matrix, MatrixSum, OMatrix, Scalar, VectorSlice}; use crate::base::{DefaultAllocator, Matrix, MatrixSum, OMatrix, Scalar, VectorSlice};
use crate::storage::Owned; use crate::storage::InnerOwned;
use crate::{MatrixSliceMut, SimdComplexField}; use crate::{MatrixSliceMut, SimdComplexField};
/* /*
@ -436,7 +436,7 @@ where
// TODO: we should take out this trait bound, as T: Clone should suffice. // TODO: we should take out this trait bound, as T: Clone should suffice.
// The brute way to do it would be how it was already done: by adding this // The brute way to do it would be how it was already done: by adding this
// trait bound on the associated type itself. // trait bound on the associated type itself.
Owned<T, Dynamic, C>: Clone, InnerOwned<T, Dynamic, C>: Clone,
{ {
/// # Example /// # Example
/// ``` /// ```

View File

@ -5,6 +5,7 @@ use std::ptr;
use crate::base::allocator::{Allocator, InnerAllocator, SameShapeC, SameShapeR}; use crate::base::allocator::{Allocator, InnerAllocator, SameShapeC, SameShapeR};
use crate::base::default_allocator::DefaultAllocator; use crate::base::default_allocator::DefaultAllocator;
use crate::base::dimension::{Dim, U1}; use crate::base::dimension::{Dim, U1};
use crate::base::Owned;
/* /*
* Aliases for allocation results. * Aliases for allocation results.
@ -15,7 +16,7 @@ pub type SameShapeStorage<T, R1, C1, R2, C2> =
// TODO: better name than Owned ? // TODO: better name than Owned ?
/// The owned data storage that can be allocated from `S`. /// The owned data storage that can be allocated from `S`.
pub type Owned<T, R, C = U1> = <DefaultAllocator as InnerAllocator<T, R, C>>::Buffer; pub type InnerOwned<T, R, C = U1> = <DefaultAllocator as InnerAllocator<T, R, C>>::Buffer;
/// The row-stride of the owned data storage for a buffer of dimension `(R, C)`. /// The row-stride of the owned data storage for a buffer of dimension `(R, C)`.
pub type RStride<T, R, C = U1> = pub type RStride<T, R, C = U1> =

View File

@ -10,7 +10,7 @@ use abomonation::Abomonation;
use crate::allocator::Allocator; use crate::allocator::Allocator;
use crate::base::DefaultAllocator; use crate::base::DefaultAllocator;
use crate::storage::{Owned, Storage}; use crate::storage::{InnerOwned, Storage};
use crate::{Dim, Matrix, OMatrix, RealField, Scalar, SimdComplexField, SimdRealField}; use crate::{Dim, Matrix, OMatrix, RealField, Scalar, SimdComplexField, SimdRealField};
/// A wrapper that ensures the underlying algebraic entity has a unit norm. /// A wrapper that ensures the underlying algebraic entity has a unit norm.
@ -344,7 +344,7 @@ where
T: From<[<T as simba::simd::SimdValue>::Element; 2]>, T: From<[<T as simba::simd::SimdValue>::Element; 2]>,
T::Element: Scalar, T::Element: Scalar,
DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>, DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,
Owned<T::Element, R, C>: Clone, InnerOwned<T::Element, R, C>: Clone,
{ {
#[inline] #[inline]
fn from(arr: [Unit<OMatrix<T::Element, R, C>>; 2]) -> Self { fn from(arr: [Unit<OMatrix<T::Element, R, C>>; 2]) -> Self {
@ -361,7 +361,7 @@ where
T: From<[<T as simba::simd::SimdValue>::Element; 4]>, T: From<[<T as simba::simd::SimdValue>::Element; 4]>,
T::Element: Scalar, T::Element: Scalar,
DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>, DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,
Owned<T::Element, R, C>: Clone, InnerOwned<T::Element, R, C>: Clone,
{ {
#[inline] #[inline]
fn from(arr: [Unit<OMatrix<T::Element, R, C>>; 4]) -> Self { fn from(arr: [Unit<OMatrix<T::Element, R, C>>; 4]) -> Self {
@ -380,7 +380,7 @@ where
T: From<[<T as simba::simd::SimdValue>::Element; 8]>, T: From<[<T as simba::simd::SimdValue>::Element; 8]>,
T::Element: Scalar, T::Element: Scalar,
DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>, DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,
Owned<T::Element, R, C>: Clone, InnerOwned<T::Element, R, C>: Clone,
{ {
#[inline] #[inline]
fn from(arr: [Unit<OMatrix<T::Element, R, C>>; 8]) -> Self { fn from(arr: [Unit<OMatrix<T::Element, R, C>>; 8]) -> Self {
@ -403,7 +403,7 @@ where
T: From<[<T as simba::simd::SimdValue>::Element; 16]>, T: From<[<T as simba::simd::SimdValue>::Element; 16]>,
T::Element: Scalar, T::Element: Scalar,
DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>, DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,
Owned<T::Element, R, C>: Clone, InnerOwned<T::Element, R, C>: Clone,
{ {
#[inline] #[inline]
fn from(arr: [Unit<OMatrix<T::Element, R, C>>; 16]) -> Self { fn from(arr: [Unit<OMatrix<T::Element, R, C>>; 16]) -> Self {

View File

@ -9,9 +9,9 @@ use crate::base::constraint::{SameNumberOfRows, ShapeConstraint};
use crate::base::default_allocator::DefaultAllocator; use crate::base::default_allocator::DefaultAllocator;
use crate::base::dimension::{Dim, DimName, Dynamic, U1}; use crate::base::dimension::{Dim, DimName, Dynamic, U1};
use crate::base::storage::{ use crate::base::storage::{
ContiguousStorage, ContiguousStorageMut, Owned, ReshapableStorage, Storage, StorageMut, ContiguousStorage, ContiguousStorageMut, ReshapableStorage, Storage, StorageMut,
}; };
use crate::base::Vector; use crate::base::{Owned, Vector};
#[cfg(feature = "serde-serialize-no-std")] #[cfg(feature = "serde-serialize-no-std")]
use serde::{ use serde::{
@ -31,8 +31,8 @@ use abomonation::Abomonation;
#[derive(Eq, Debug, Clone, PartialEq)] #[derive(Eq, Debug, Clone, PartialEq)]
pub struct VecStorage<T, R: Dim, C: Dim> { pub struct VecStorage<T, R: Dim, C: Dim> {
data: Vec<T>, data: Vec<T>,
nrows: R, pub(crate) nrows: R,
ncols: C, pub(crate) ncols: C,
} }
#[cfg(feature = "serde-serialize")] #[cfg(feature = "serde-serialize")]
@ -184,20 +184,16 @@ where
} }
#[inline] #[inline]
fn into_owned(self) -> Owned<T, Dynamic, C> fn into_owned(self) -> Owned<T, Dynamic, C> {
where Owned(self)
DefaultAllocator: InnerAllocator<T, Dynamic, C>,
{
self
} }
#[inline] #[inline]
fn clone_owned(&self) -> Owned<T, Dynamic, C> fn clone_owned(&self) -> Owned<T, Dynamic, C>
where where
T: Clone, T: Clone,
DefaultAllocator: InnerAllocator<T, Dynamic, C>,
{ {
self.clone() Owned(self.clone())
} }
#[inline] #[inline]
@ -234,20 +230,16 @@ where
} }
#[inline] #[inline]
fn into_owned(self) -> Owned<T, R, Dynamic> fn into_owned(self) -> Owned<T, R, Dynamic> {
where Owned(self)
DefaultAllocator: InnerAllocator<T, R, Dynamic>,
{
self
} }
#[inline] #[inline]
fn clone_owned(&self) -> Owned<T, R, Dynamic> fn clone_owned(&self) -> Owned<T, R, Dynamic>
where where
T: Clone, T: Clone,
DefaultAllocator: InnerAllocator<T, R, Dynamic>,
{ {
self.clone() Owned(self.clone())
} }
#[inline] #[inline]

View File

@ -4,7 +4,7 @@ use std::fmt;
use quickcheck::{Arbitrary, Gen}; use quickcheck::{Arbitrary, Gen};
use crate::base::allocator::Allocator; use crate::base::allocator::Allocator;
use crate::base::dimension::{Dim, Dynamic}; use crate::base::dimension::{Dim, DimName, Dynamic};
use crate::base::{DefaultAllocator, OMatrix}; use crate::base::{DefaultAllocator, OMatrix};
use crate::linalg::givens::GivensRotation; use crate::linalg::givens::GivensRotation;
use crate::storage::Owned; use crate::storage::Owned;
@ -18,7 +18,7 @@ where
m: OMatrix<T, D, D>, m: OMatrix<T, D, D>,
} }
impl<T: Copy, D: Dim> Copy for RandomOrthogonal<T, D> impl<T: Copy, D: DimName> Copy for RandomOrthogonal<T, D>
where where
DefaultAllocator: Allocator<T, D, D>, DefaultAllocator: Allocator<T, D, D>,
Owned<T, D, D>: Copy, Owned<T, D, D>: Copy,

View File

@ -5,8 +5,7 @@ use quickcheck::{Arbitrary, Gen};
use crate::base::allocator::Allocator; use crate::base::allocator::Allocator;
use crate::base::dimension::{Dim, Dynamic}; use crate::base::dimension::{Dim, Dynamic};
use crate::base::{DefaultAllocator, OMatrix}; use crate::base::{DefaultAllocator, OMatrix, Owned};
use crate::storage::Owned;
use simba::scalar::ComplexField; use simba::scalar::ComplexField;
use crate::debug::RandomOrthogonal; use crate::debug::RandomOrthogonal;

View File

@ -15,7 +15,7 @@ use simba::simd::SimdRealField;
use crate::base::allocator::Allocator; use crate::base::allocator::Allocator;
use crate::base::dimension::{DimNameAdd, DimNameSum, U1}; use crate::base::dimension::{DimNameAdd, DimNameSum, U1};
use crate::base::storage::Owned; use crate::base::storage::InnerOwned;
use crate::base::{Const, DefaultAllocator, OMatrix, SVector, Scalar, Unit}; use crate::base::{Const, DefaultAllocator, OMatrix, SVector, Scalar, Unit};
use crate::geometry::{AbstractRotation, Point, Translation}; use crate::geometry::{AbstractRotation, Point, Translation};
@ -157,7 +157,7 @@ mod rkyv_impl {
impl<T: hash::Hash, R: hash::Hash, const D: usize> hash::Hash for Isometry<T, R, D> impl<T: hash::Hash, R: hash::Hash, const D: usize> hash::Hash for Isometry<T, R, D>
where where
Owned<T, Const<D>>: hash::Hash, InnerOwned<T, Const<D>>: hash::Hash,
{ {
fn hash<H: hash::Hasher>(&self, state: &mut H) { fn hash<H: hash::Hasher>(&self, state: &mut H) {
self.translation.hash(state); self.translation.hash(state);
@ -165,7 +165,7 @@ where
} }
} }
impl<T: Copy, R: Copy, const D: usize> Copy for Isometry<T, R, D> where Owned<T, Const<D>>: Copy {} impl<T: Copy, R: Copy, const D: usize> Copy for Isometry<T, R, D> where InnerOwned<T, Const<D>>: Copy {}
impl<T: Clone, R: Clone, const D: usize> Clone for Isometry<T, R, D> { impl<T: Clone, R: Clone, const D: usize> Clone for Isometry<T, R, D> {
#[inline] #[inline]

View File

@ -1,5 +1,5 @@
#[cfg(feature = "arbitrary")] #[cfg(feature = "arbitrary")]
use crate::base::storage::Owned; use crate::base::storage::InnerOwned;
#[cfg(feature = "arbitrary")] #[cfg(feature = "arbitrary")]
use quickcheck::{Arbitrary, Gen}; use quickcheck::{Arbitrary, Gen};
@ -97,7 +97,7 @@ where
T: SimdRealField + Arbitrary + Send, T: SimdRealField + Arbitrary + Send,
T::Element: SimdRealField, T::Element: SimdRealField,
R: AbstractRotation<T, D> + Arbitrary + Send, R: AbstractRotation<T, D> + Arbitrary + Send,
Owned<T, crate::Const<D>>: Send, InnerOwned<T, crate::Const<D>>: Send,
{ {
#[inline] #[inline]
fn arbitrary(rng: &mut Gen) -> Self { fn arbitrary(rng: &mut Gen) -> Self {

View File

@ -20,7 +20,7 @@ use crate::base::allocator::Allocator;
use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1}; use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
use crate::base::iter::{MatrixIter, MatrixIterMut}; use crate::base::iter::{MatrixIter, MatrixIterMut};
use crate::base::{Const, DefaultAllocator, OVector}; use crate::base::{Const, DefaultAllocator, OVector};
use crate::storage::Owned; use crate::storage::InnerOwned;
use crate::Scalar; use crate::Scalar;
/// A point in an euclidean space. /// A point in an euclidean space.
@ -322,7 +322,7 @@ where
/// assert_eq!(it.next(), Some(3.0)); /// assert_eq!(it.next(), Some(3.0));
/// assert_eq!(it.next(), None); /// assert_eq!(it.next(), None);
#[inline] #[inline]
pub fn iter(&self) -> MatrixIter<T, D, Const<1>, Owned<T, D>> { pub fn iter(&self) -> MatrixIter<T, D, Const<1>, InnerOwned<T, D>> {
self.coords.iter() self.coords.iter()
} }
@ -346,7 +346,7 @@ where
/// ///
/// assert_eq!(p, Point3::new(10.0, 20.0, 30.0)); /// assert_eq!(p, Point3::new(10.0, 20.0, 30.0));
#[inline] #[inline]
pub fn iter_mut(&mut self) -> MatrixIterMut<T, D, Const<1>, Owned<T, D>> { pub fn iter_mut(&mut self) -> MatrixIterMut<T, D, Const<1>, InnerOwned<T, D>> {
self.coords.iter_mut() self.coords.iter_mut()
} }

View File

@ -185,7 +185,7 @@ where
impl<T: Arbitrary + Send, D: DimName> Arbitrary for OPoint<T, D> impl<T: Arbitrary + Send, D: DimName> Arbitrary for OPoint<T, D>
where where
DefaultAllocator: Allocator<T, D>, DefaultAllocator: Allocator<T, D>,
crate::base::storage::Owned<T, D>: Clone + Send, crate::base::storage::InnerOwned<T, D>: Clone + Send,
{ {
#[inline] #[inline]
fn arbitrary(g: &mut Gen) -> Self { fn arbitrary(g: &mut Gen) -> Self {

View File

@ -6,7 +6,7 @@ use std::hash::{Hash, Hasher};
use std::io::{Result as IOResult, Write}; use std::io::{Result as IOResult, Write};
#[cfg(feature = "serde-serialize-no-std")] #[cfg(feature = "serde-serialize-no-std")]
use crate::base::storage::Owned; use crate::base::storage::InnerOwned;
#[cfg(feature = "serde-serialize-no-std")] #[cfg(feature = "serde-serialize-no-std")]
use serde::{Deserialize, Deserializer, Serialize, Serializer}; use serde::{Deserialize, Deserializer, Serialize, Serializer};

View File

@ -1,7 +1,7 @@
#[cfg(feature = "arbitrary")] #[cfg(feature = "arbitrary")]
use crate::base::dimension::U4; use crate::base::dimension::U4;
#[cfg(feature = "arbitrary")] #[cfg(feature = "arbitrary")]
use crate::base::storage::Owned; use crate::base::storage::InnerOwned;
#[cfg(feature = "arbitrary")] #[cfg(feature = "arbitrary")]
use quickcheck::{Arbitrary, Gen}; use quickcheck::{Arbitrary, Gen};
@ -179,7 +179,7 @@ where
#[cfg(feature = "arbitrary")] #[cfg(feature = "arbitrary")]
impl<T: SimdRealField + Arbitrary> Arbitrary for Quaternion<T> impl<T: SimdRealField + Arbitrary> Arbitrary for Quaternion<T>
where where
Owned<T, U4>: Send, InnerOwned<T, U4>: Send,
{ {
#[inline] #[inline]
fn arbitrary(g: &mut Gen) -> Self { fn arbitrary(g: &mut Gen) -> Self {
@ -881,8 +881,8 @@ where
#[cfg(feature = "arbitrary")] #[cfg(feature = "arbitrary")]
impl<T: RealField + Arbitrary> Arbitrary for UnitQuaternion<T> impl<T: RealField + Arbitrary> Arbitrary for UnitQuaternion<T>
where where
Owned<T, U4>: Send, InnerOwned<T, U4>: Send,
Owned<T, U3>: Send, InnerOwned<T, U3>: Send,
{ {
#[inline] #[inline]
fn arbitrary(g: &mut Gen) -> Self { fn arbitrary(g: &mut Gen) -> Self {

View File

@ -9,8 +9,8 @@ use std::io::{Result as IOResult, Write};
use serde::{Deserialize, Deserializer, Serialize, Serializer}; use serde::{Deserialize, Deserializer, Serialize, Serializer};
#[cfg(feature = "serde-serialize-no-std")] #[cfg(feature = "serde-serialize-no-std")]
use crate::base::storage::Owned; use crate::base::storage::InnerOwned;
use crate::storage::Owned; use crate::storage::InnerOwned;
#[cfg(feature = "abomonation-serialize")] #[cfg(feature = "abomonation-serialize")]
use abomonation::Abomonation; use abomonation::Abomonation;
@ -62,18 +62,18 @@ pub struct Rotation<T, const D: usize> {
impl<T: hash::Hash, const D: usize> hash::Hash for Rotation<T, D> impl<T: hash::Hash, const D: usize> hash::Hash for Rotation<T, D>
where where
Owned<T, Const<D>, Const<D>>: hash::Hash, InnerOwned<T, Const<D>, Const<D>>: hash::Hash,
{ {
fn hash<H: hash::Hasher>(&self, state: &mut H) { fn hash<H: hash::Hasher>(&self, state: &mut H) {
self.matrix.hash(state) self.matrix.hash(state)
} }
} }
impl<T: Copy, const D: usize> Copy for Rotation<T, D> where Owned<T, Const<D>, Const<D>>: Copy {} impl<T: Copy, const D: usize> Copy for Rotation<T, D> where InnerOwned<T, Const<D>, Const<D>>: Copy {}
impl<T: Clone, const D: usize> Clone for Rotation<T, D> impl<T: Clone, const D: usize> Clone for Rotation<T, D>
where where
Owned<T, Const<D>, Const<D>>: Clone, InnerOwned<T, Const<D>, Const<D>>: Clone,
{ {
#[inline] #[inline]
fn clone(&self) -> Self { fn clone(&self) -> Self {
@ -102,7 +102,7 @@ where
#[cfg(feature = "serde-serialize-no-std")] #[cfg(feature = "serde-serialize-no-std")]
impl<T: Scalar, const D: usize> Serialize for Rotation<T, D> impl<T: Scalar, const D: usize> Serialize for Rotation<T, D>
where where
Owned<T, Const<D>, Const<D>>: Serialize, InnerOwned<T, Const<D>, Const<D>>: Serialize,
{ {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where where
@ -115,7 +115,7 @@ where
#[cfg(feature = "serde-serialize-no-std")] #[cfg(feature = "serde-serialize-no-std")]
impl<'a, T, const D: usize> Deserialize<'a> for Rotation<T, D> impl<'a, T, const D: usize> Deserialize<'a> for Rotation<T, D>
where where
Owned<T, Const<D>, Const<D>>: Deserialize<'a>, InnerOwned<T, Const<D>, Const<D>>: Deserialize<'a>,
{ {
fn deserialize<Des>(deserializer: Des) -> Result<Self, Des::Error> fn deserialize<Des>(deserializer: Des) -> Result<Self, Des::Error>
where where

View File

@ -1,5 +1,5 @@
#[cfg(feature = "arbitrary")] #[cfg(feature = "arbitrary")]
use crate::base::storage::Owned; use crate::base::storage::InnerOwned;
#[cfg(feature = "arbitrary")] #[cfg(feature = "arbitrary")]
use quickcheck::{Arbitrary, Gen}; use quickcheck::{Arbitrary, Gen};
@ -284,7 +284,7 @@ where
impl<T: SimdRealField + Arbitrary> Arbitrary for Rotation2<T> impl<T: SimdRealField + Arbitrary> Arbitrary for Rotation2<T>
where where
T::Element: SimdRealField, T::Element: SimdRealField,
Owned<T, U2, U2>: Send, InnerOwned<T, U2, U2>: Send,
{ {
#[inline] #[inline]
fn arbitrary(g: &mut Gen) -> Self { fn arbitrary(g: &mut Gen) -> Self {
@ -976,8 +976,8 @@ where
impl<T: SimdRealField + Arbitrary> Arbitrary for Rotation3<T> impl<T: SimdRealField + Arbitrary> Arbitrary for Rotation3<T>
where where
T::Element: SimdRealField, T::Element: SimdRealField,
Owned<T, U3, U3>: Send, InnerOwned<T, U3, U3>: Send,
Owned<T, U3>: Send, InnerOwned<T, U3>: Send,
{ {
#[inline] #[inline]
fn arbitrary(g: &mut Gen) -> Self { fn arbitrary(g: &mut Gen) -> Self {

View File

@ -17,7 +17,7 @@ use simba::simd::SimdRealField;
use crate::base::allocator::Allocator; use crate::base::allocator::Allocator;
use crate::base::dimension::{DimNameAdd, DimNameSum, U1}; use crate::base::dimension::{DimNameAdd, DimNameSum, U1};
use crate::base::storage::Owned; use crate::base::storage::InnerOwned;
use crate::base::{Const, DefaultAllocator, OMatrix, SVector, Scalar}; use crate::base::{Const, DefaultAllocator, OMatrix, SVector, Scalar};
use crate::geometry::{AbstractRotation, Isometry, Point, Translation}; use crate::geometry::{AbstractRotation, Isometry, Point, Translation};
@ -64,7 +64,7 @@ where
impl<T: Scalar + hash::Hash, R: hash::Hash, const D: usize> hash::Hash for Similarity<T, R, D> impl<T: Scalar + hash::Hash, R: hash::Hash, const D: usize> hash::Hash for Similarity<T, R, D>
where where
Owned<T, Const<D>>: hash::Hash, InnerOwned<T, Const<D>>: hash::Hash,
{ {
fn hash<H: hash::Hasher>(&self, state: &mut H) { fn hash<H: hash::Hasher>(&self, state: &mut H) {
self.isometry.hash(state); self.isometry.hash(state);
@ -75,7 +75,7 @@ where
impl<T: Scalar + Copy + Zero, R: AbstractRotation<T, D> + Copy, const D: usize> Copy impl<T: Scalar + Copy + Zero, R: AbstractRotation<T, D> + Copy, const D: usize> Copy
for Similarity<T, R, D> for Similarity<T, R, D>
where where
Owned<T, Const<D>>: Copy, InnerOwned<T, Const<D>>: Copy,
{ {
} }

View File

@ -1,5 +1,5 @@
#[cfg(feature = "arbitrary")] #[cfg(feature = "arbitrary")]
use crate::base::storage::Owned; use crate::base::storage::InnerOwned;
#[cfg(feature = "arbitrary")] #[cfg(feature = "arbitrary")]
use quickcheck::{Arbitrary, Gen}; use quickcheck::{Arbitrary, Gen};
@ -109,7 +109,7 @@ where
T: crate::RealField + Arbitrary + Send, T: crate::RealField + Arbitrary + Send,
T::Element: crate::RealField, T::Element: crate::RealField,
R: AbstractRotation<T, D> + Arbitrary + Send, R: AbstractRotation<T, D> + Arbitrary + Send,
Owned<T, crate::Const<D>>: Send, InnerOwned<T, crate::Const<D>>: Send,
{ {
#[inline] #[inline]
fn arbitrary(rng: &mut Gen) -> Self { fn arbitrary(rng: &mut Gen) -> Self {

View File

@ -12,7 +12,7 @@ use simba::scalar::{ComplexField, RealField};
use crate::base::allocator::Allocator; use crate::base::allocator::Allocator;
use crate::base::dimension::{DimNameAdd, DimNameSum, U1}; use crate::base::dimension::{DimNameAdd, DimNameSum, U1};
use crate::base::storage::Owned; use crate::base::storage::InnerOwned;
use crate::base::{Const, DefaultAllocator, DimName, OMatrix, SVector}; use crate::base::{Const, DefaultAllocator, DimName, OMatrix, SVector};
use crate::geometry::Point; use crate::geometry::Point;
@ -171,26 +171,28 @@ impl<T: hash::Hash, C: TCategory, const D: usize> hash::Hash for Transform<T, C,
where where
Const<D>: DimNameAdd<U1>, Const<D>: DimNameAdd<U1>,
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>, DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
Owned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: hash::Hash, InnerOwned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: hash::Hash,
{ {
fn hash<H: hash::Hasher>(&self, state: &mut H) { fn hash<H: hash::Hasher>(&self, state: &mut H) {
self.matrix.hash(state); self.matrix.hash(state);
} }
} }
/*
impl<T: Copy, C: TCategory, const D: usize> Copy for Transform<T, C, D> impl<T: Copy, C: TCategory, const D: usize> Copy for Transform<T, C, D>
where where
Const<D>: DimNameAdd<U1>, Const<D>: DimNameAdd<U1>,
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>, DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
Owned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: Copy, InnerOwned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: Copy,
{ {
} }
*/
impl<T: Clone, C: TCategory, const D: usize> Clone for Transform<T, C, D> impl<T: Clone, C: TCategory, const D: usize> Clone for Transform<T, C, D>
where where
Const<D>: DimNameAdd<U1>, Const<D>: DimNameAdd<U1>,
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>, DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
Owned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: Clone, InnerOwned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: Clone,
{ {
#[inline] #[inline]
fn clone(&self) -> Self { fn clone(&self) -> Self {
@ -202,7 +204,7 @@ impl<T: Debug, C: TCategory, const D: usize> Debug for Transform<T, C, D>
where where
Const<D>: DimNameAdd<U1>, Const<D>: DimNameAdd<U1>,
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>, DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
Owned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: Debug, InnerOwned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: Debug,
{ {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("Transform") f.debug_struct("Transform")
@ -216,7 +218,7 @@ impl<T, C: TCategory, const D: usize> Serialize for Transform<T, C, D>
where where
Const<D>: DimNameAdd<U1>, Const<D>: DimNameAdd<U1>,
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>, DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
Owned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: Serialize, InnerOwned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: Serialize,
{ {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where where
@ -231,7 +233,7 @@ impl<'a, T, C: TCategory, const D: usize> Deserialize<'a> for Transform<T, C, D>
where where
Const<D>: DimNameAdd<U1>, Const<D>: DimNameAdd<U1>,
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>, DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
Owned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: Deserialize<'a>, InnerOwned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: Deserialize<'a>,
{ {
fn deserialize<Des>(deserializer: Des) -> Result<Self, Des::Error> fn deserialize<Des>(deserializer: Des) -> Result<Self, Des::Error>
where where
@ -551,7 +553,7 @@ where
C: SubTCategoryOf<TProjective>, C: SubTCategoryOf<TProjective>,
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
+ Allocator<T, DimNameSum<Const<D>, U1>>, + Allocator<T, DimNameSum<Const<D>, U1>>,
Owned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: Clone, InnerOwned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: Clone,
{ {
/// Transform the given point by the inverse of this transformation. /// Transform the given point by the inverse of this transformation.
/// This may be cheaper than inverting the transformation and transforming /// This may be cheaper than inverting the transformation and transforming

View File

@ -9,7 +9,7 @@ use simba::scalar::{ClosedAdd, ClosedMul, RealField, SubsetOf};
use crate::base::allocator::Allocator; use crate::base::allocator::Allocator;
use crate::base::dimension::{DimNameAdd, DimNameSum, U1}; use crate::base::dimension::{DimNameAdd, DimNameSum, U1};
use crate::base::{Const, DefaultAllocator, OMatrix, SVector, Scalar}; use crate::base::{Const, DefaultAllocator, OMatrix, SVector, Scalar};
use crate::storage::Owned; use crate::storage::InnerOwned;
use crate::geometry::{ use crate::geometry::{
Isometry, Point, Rotation, Similarity, SubTCategoryOf, SuperTCategoryOf, TAffine, TCategory, Isometry, Point, Rotation, Similarity, SubTCategoryOf, SuperTCategoryOf, TAffine, TCategory,
@ -589,7 +589,7 @@ md_assign_impl_all!(
for CA, CB; for CA, CB;
where Const<D>: DimNameAdd<U1>, CA: SuperTCategoryOf<CB>, CB: SubTCategoryOf<TProjective>, where Const<D>: DimNameAdd<U1>, CA: SuperTCategoryOf<CB>, CB: SubTCategoryOf<TProjective>,
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>, DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
Owned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: Clone; InnerOwned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: Clone;
self: Transform<T, CA, D>, rhs: Transform<T, CB, D>; self: Transform<T, CA, D>, rhs: Transform<T, CB, D>;
[val] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() }; [val] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
[ref] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.clone().inverse() }; [ref] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.clone().inverse() };

View File

@ -15,7 +15,7 @@ use simba::scalar::{ClosedAdd, ClosedNeg, ClosedSub};
use crate::base::allocator::Allocator; use crate::base::allocator::Allocator;
use crate::base::dimension::{DimNameAdd, DimNameSum, U1}; use crate::base::dimension::{DimNameAdd, DimNameSum, U1};
use crate::base::storage::Owned; use crate::base::storage::InnerOwned;
use crate::base::{Const, DefaultAllocator, OMatrix, SVector, Scalar}; use crate::base::{Const, DefaultAllocator, OMatrix, SVector, Scalar};
use crate::geometry::Point; use crate::geometry::Point;
@ -31,7 +31,7 @@ pub struct Translation<T, const D: usize> {
impl<T: hash::Hash, const D: usize> hash::Hash for Translation<T, D> impl<T: hash::Hash, const D: usize> hash::Hash for Translation<T, D>
where where
Owned<T, Const<D>>: hash::Hash, InnerOwned<T, Const<D>>: hash::Hash,
{ {
fn hash<H: hash::Hasher>(&self, state: &mut H) { fn hash<H: hash::Hasher>(&self, state: &mut H) {
self.vector.hash(state) self.vector.hash(state)
@ -42,7 +42,7 @@ impl<T: Copy, const D: usize> Copy for Translation<T, D> {}
impl<T: Clone, const D: usize> Clone for Translation<T, D> impl<T: Clone, const D: usize> Clone for Translation<T, D>
where where
Owned<T, Const<D>>: Clone, InnerOwned<T, Const<D>>: Clone,
{ {
#[inline] #[inline]
fn clone(&self) -> Self { fn clone(&self) -> Self {
@ -71,7 +71,7 @@ where
#[cfg(feature = "serde-serialize-no-std")] #[cfg(feature = "serde-serialize-no-std")]
impl<T, const D: usize> Serialize for Translation<T, D> impl<T, const D: usize> Serialize for Translation<T, D>
where where
Owned<T, Const<D>>: Serialize, InnerOwned<T, Const<D>>: Serialize,
{ {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where where
@ -84,7 +84,7 @@ where
#[cfg(feature = "serde-serialize-no-std")] #[cfg(feature = "serde-serialize-no-std")]
impl<'a, T, const D: usize> Deserialize<'a> for Translation<T, D> impl<'a, T, const D: usize> Deserialize<'a> for Translation<T, D>
where where
Owned<T, Const<D>>: Deserialize<'a>, InnerOwned<T, Const<D>>: Deserialize<'a>,
{ {
fn deserialize<Des>(deserializer: Des) -> Result<Self, Des::Error> fn deserialize<Des>(deserializer: Des) -> Result<Self, Des::Error>
where where

View File

@ -1,5 +1,5 @@
#[cfg(feature = "arbitrary")] #[cfg(feature = "arbitrary")]
use crate::base::storage::Owned; use crate::base::storage::InnerOwned;
#[cfg(feature = "arbitrary")] #[cfg(feature = "arbitrary")]
use quickcheck::{Arbitrary, Gen}; use quickcheck::{Arbitrary, Gen};
@ -77,7 +77,7 @@ where
#[cfg(feature = "arbitrary")] #[cfg(feature = "arbitrary")]
impl<T: Scalar + Arbitrary + Send, const D: usize> Arbitrary for Translation<T, D> impl<T: Scalar + Arbitrary + Send, const D: usize> Arbitrary for Translation<T, D>
where where
Owned<T, crate::Const<D>>: Send, InnerOwned<T, crate::Const<D>>: Send,
{ {
#[inline] #[inline]
fn arbitrary(rng: &mut Gen) -> Self { fn arbitrary(rng: &mut Gen) -> Self {

View File

@ -6,7 +6,7 @@ use serde::{Deserialize, Serialize};
use crate::allocator::Allocator; use crate::allocator::Allocator;
use crate::base::{DefaultAllocator, Matrix, OMatrix, OVector, Unit}; use crate::base::{DefaultAllocator, Matrix, OMatrix, OVector, Unit};
use crate::dimension::{Const, Dim, DimDiff, DimMin, DimMinimum, DimSub, U1}; use crate::dimension::{Const, Dim, DimDiff, DimMin, DimMinimum, DimSub, U1};
use crate::storage::{Owned, Storage}; use crate::storage::{InnerOwned, Storage};
use crate::Dynamic; use crate::Dynamic;
use simba::scalar::ComplexField; use simba::scalar::ComplexField;
@ -58,9 +58,9 @@ where
DefaultAllocator: Allocator<T, R, C> DefaultAllocator: Allocator<T, R, C>
+ Allocator<T, DimMinimum<R, C>> + Allocator<T, DimMinimum<R, C>>
+ Allocator<T, DimDiff<DimMinimum<R, C>, U1>>, + Allocator<T, DimDiff<DimMinimum<R, C>, U1>>,
Owned<T, R, C>: Clone, InnerOwned<T, R, C>: Clone,
Owned<T, DimMinimum<R, C>>: Clone, InnerOwned<T, DimMinimum<R, C>>: Clone,
Owned<T, DimDiff<DimMinimum<R, C>, U1>>: Clone, InnerOwned<T, DimDiff<DimMinimum<R, C>, U1>>: Clone,
{ {
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self { Self {
@ -72,17 +72,19 @@ where
} }
} }
/*
impl<T: ComplexField, R: DimMin<C>, C: Dim> Copy for Bidiagonal<T, R, C> impl<T: ComplexField, R: DimMin<C>, C: Dim> Copy for Bidiagonal<T, R, C>
where where
DimMinimum<R, C>: DimSub<U1>, DimMinimum<R, C>: DimSub<U1>,
DefaultAllocator: Allocator<T, R, C> DefaultAllocator: Allocator<T, R, C>
+ Allocator<T, DimMinimum<R, C>> + Allocator<T, DimMinimum<R, C>>
+ Allocator<T, DimDiff<DimMinimum<R, C>, U1>>, + Allocator<T, DimDiff<DimMinimum<R, C>, U1>>,
Owned<T, R, C>: Copy, InnerOwned<T, R, C>: Copy,
Owned<T, DimMinimum<R, C>>: Copy, InnerOwned<T, DimMinimum<R, C>>: Copy,
Owned<T, DimDiff<DimMinimum<R, C>, U1>>: Copy, InnerOwned<T, DimDiff<DimMinimum<R, C>, U1>>: Copy,
{ {
} }
*/
impl<T: ComplexField, R: DimMin<C>, C: Dim> fmt::Debug for Bidiagonal<T, R, C> impl<T: ComplexField, R: DimMin<C>, C: Dim> fmt::Debug for Bidiagonal<T, R, C>
where where
@ -90,9 +92,9 @@ where
DefaultAllocator: Allocator<T, R, C> DefaultAllocator: Allocator<T, R, C>
+ Allocator<T, DimMinimum<R, C>> + Allocator<T, DimMinimum<R, C>>
+ Allocator<T, DimDiff<DimMinimum<R, C>, U1>>, + Allocator<T, DimDiff<DimMinimum<R, C>, U1>>,
Owned<T, R, C>: fmt::Debug, InnerOwned<T, R, C>: fmt::Debug,
Owned<T, DimMinimum<R, C>>: fmt::Debug, InnerOwned<T, DimMinimum<R, C>>: fmt::Debug,
Owned<T, DimDiff<DimMinimum<R, C>, U1>>: fmt::Debug, InnerOwned<T, DimDiff<DimMinimum<R, C>, U1>>: fmt::Debug,
{ {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("Bidiagonal") f.debug_struct("Bidiagonal")

View File

@ -12,7 +12,7 @@ use crate::allocator::Allocator;
use crate::base::{Const, DefaultAllocator, Matrix, OMatrix, Vector}; use crate::base::{Const, DefaultAllocator, Matrix, OMatrix, Vector};
use crate::constraint::{SameNumberOfRows, ShapeConstraint}; use crate::constraint::{SameNumberOfRows, ShapeConstraint};
use crate::dimension::{Dim, DimAdd, DimDiff, DimSub, DimSum, U1}; use crate::dimension::{Dim, DimAdd, DimDiff, DimSub, DimSum, U1};
use crate::storage::{Owned, Storage, StorageMut}; use crate::storage::{InnerOwned, Storage, StorageMut};
/// The Cholesky decomposition of a symmetric-definite-positive matrix. /// The Cholesky decomposition of a symmetric-definite-positive matrix.
#[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))] #[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))]
@ -33,17 +33,19 @@ where
chol: OMatrix<T, D, D>, chol: OMatrix<T, D, D>,
} }
/*
impl<T: SimdComplexField, D: Dim> Copy for Cholesky<T, D> impl<T: SimdComplexField, D: Dim> Copy for Cholesky<T, D>
where where
DefaultAllocator: Allocator<T, D, D>, DefaultAllocator: Allocator<T, D, D>,
Owned<T, D, D>: Copy, InnerOwned<T, D, D>: Copy,
{ {
} }
*/
impl<T: SimdComplexField, D: Dim> Clone for Cholesky<T, D> impl<T: SimdComplexField, D: Dim> Clone for Cholesky<T, D>
where where
DefaultAllocator: Allocator<T, D, D>, DefaultAllocator: Allocator<T, D, D>,
Owned<T, D, D>: Clone, InnerOwned<T, D, D>: Clone,
{ {
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self { Self {
@ -55,7 +57,7 @@ where
impl<T: SimdComplexField, D: Dim> fmt::Debug for Cholesky<T, D> impl<T: SimdComplexField, D: Dim> fmt::Debug for Cholesky<T, D>
where where
DefaultAllocator: Allocator<T, D, D>, DefaultAllocator: Allocator<T, D, D>,
Owned<T, D, D>: fmt::Debug, InnerOwned<T, D, D>: fmt::Debug,
{ {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("Cholesky") f.debug_struct("Cholesky")

View File

@ -8,7 +8,7 @@ use crate::{
DefaultAllocator, DefaultAllocator,
}, },
convert, convert,
storage::Owned, storage::InnerOwned,
try_convert, ComplexField, OMatrix, RealField, try_convert, ComplexField, OMatrix, RealField,
}; };
@ -435,7 +435,7 @@ where
+ Allocator<T, D> + Allocator<T, D>
+ Allocator<T::RealField, D> + Allocator<T::RealField, D>
+ Allocator<T::RealField, D, D>, + Allocator<T::RealField, D, D>,
Owned<T, D, D>: Clone, InnerOwned<T, D, D>: Clone,
{ {
/// Computes exponential of this matrix /// Computes exponential of this matrix
#[must_use] #[must_use]

View File

@ -7,7 +7,7 @@ use serde::{Deserialize, Serialize};
use crate::allocator::Allocator; use crate::allocator::Allocator;
use crate::base::{DefaultAllocator, OMatrix, OVector}; use crate::base::{DefaultAllocator, OMatrix, OVector};
use crate::dimension::{Const, DimDiff, DimSub, U1}; use crate::dimension::{Const, DimDiff, DimSub, U1};
use crate::storage::{Owned, Storage}; use crate::storage::{InnerOwned, Storage};
use crate::Matrix; use crate::Matrix;
use simba::scalar::ComplexField; use simba::scalar::ComplexField;
@ -37,19 +37,21 @@ where
subdiag: OVector<T, DimDiff<D, U1>>, subdiag: OVector<T, DimDiff<D, U1>>,
} }
/*
impl<T: ComplexField, D: DimSub<U1>> Copy for Hessenberg<T, D> impl<T: ComplexField, D: DimSub<U1>> Copy for Hessenberg<T, D>
where where
DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>, DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>,
Owned<T, D, D>: Copy, InnerOwned<T, D, D>: Copy,
Owned<T, DimDiff<D, U1>>: Copy, InnerOwned<T, DimDiff<D, U1>>: Copy,
{ {
} }
*/
impl<T: ComplexField, D: DimSub<U1>> Clone for Hessenberg<T, D> impl<T: ComplexField, D: DimSub<U1>> Clone for Hessenberg<T, D>
where where
DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>, DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>,
Owned<T, D, D>: Clone, InnerOwned<T, D, D>: Clone,
Owned<T, DimDiff<D, U1>>: Clone, InnerOwned<T, DimDiff<D, U1>>: Clone,
{ {
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self { Self {
@ -62,8 +64,8 @@ where
impl<T: ComplexField, D: DimSub<U1>> fmt::Debug for Hessenberg<T, D> impl<T: ComplexField, D: DimSub<U1>> fmt::Debug for Hessenberg<T, D>
where where
DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>, DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>,
Owned<T, D, D>: fmt::Debug, InnerOwned<T, D, D>: fmt::Debug,
Owned<T, DimDiff<D, U1>>: fmt::Debug, InnerOwned<T, DimDiff<D, U1>>: fmt::Debug,
{ {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("Hessenberg") f.debug_struct("Hessenberg")
@ -170,7 +172,7 @@ where
#[must_use] #[must_use]
pub fn h(&self) -> OMatrix<T, D, D> pub fn h(&self) -> OMatrix<T, D, D>
where where
Owned<T, D, D>: Clone, InnerOwned<T, D, D>: Clone,
{ {
let dim = self.hess.nrows(); let dim = self.hess.nrows();
let mut res = self.hess.clone(); let mut res = self.hess.clone();

View File

@ -8,7 +8,7 @@ use crate::allocator::{Allocator, Reallocator};
use crate::base::{DefaultAllocator, Matrix, OMatrix, Scalar}; use crate::base::{DefaultAllocator, Matrix, OMatrix, Scalar};
use crate::constraint::{SameNumberOfRows, ShapeConstraint}; use crate::constraint::{SameNumberOfRows, ShapeConstraint};
use crate::dimension::{Dim, DimMin, DimMinimum}; use crate::dimension::{Dim, DimMin, DimMinimum};
use crate::storage::{Owned, Storage, StorageMut}; use crate::storage::{InnerOwned, Storage, StorageMut};
use simba::scalar::{ComplexField, Field}; use simba::scalar::{ComplexField, Field};
use crate::linalg::PermutationSequence; use crate::linalg::PermutationSequence;
@ -37,19 +37,21 @@ where
p: PermutationSequence<DimMinimum<R, C>>, p: PermutationSequence<DimMinimum<R, C>>,
} }
/*
impl<T: Copy, R: DimMin<C>, C: Dim> Copy for LU<T, R, C> impl<T: Copy, R: DimMin<C>, C: Dim> Copy for LU<T, R, C>
where where
DefaultAllocator: Allocator<T, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>, DefaultAllocator: Allocator<T, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
PermutationSequence<DimMinimum<R, C>>: Copy, PermutationSequence<DimMinimum<R, C>>: Copy,
Owned<T, R, C>: Copy, InnerOwned<T, R, C>: Copy,
{ {
} }
*/
impl<T: Clone, R: DimMin<C>, C: Dim> Clone for LU<T, R, C> impl<T: Clone, R: DimMin<C>, C: Dim> Clone for LU<T, R, C>
where where
DefaultAllocator: Allocator<T, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>, DefaultAllocator: Allocator<T, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
PermutationSequence<DimMinimum<R, C>>: Clone, PermutationSequence<DimMinimum<R, C>>: Clone,
Owned<T, R, C>: Clone, InnerOwned<T, R, C>: Clone,
{ {
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self { Self {
@ -63,7 +65,7 @@ impl<T: ComplexField, R: DimMin<C>, C: Dim> fmt::Debug for LU<T, R, C>
where where
DefaultAllocator: Allocator<T, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>, DefaultAllocator: Allocator<T, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
PermutationSequence<DimMinimum<R, C>>: fmt::Debug, PermutationSequence<DimMinimum<R, C>>: fmt::Debug,
Owned<T, R, C>: fmt::Debug, InnerOwned<T, R, C>: fmt::Debug,
{ {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("LU") f.debug_struct("LU")

View File

@ -13,7 +13,7 @@ use crate::base::{DefaultAllocator, Matrix, OVector, Scalar};
use crate::dimension::Dynamic; use crate::dimension::Dynamic;
use crate::dimension::{Dim, DimName}; use crate::dimension::{Dim, DimName};
use crate::iter::MatrixIter; use crate::iter::MatrixIter;
use crate::storage::{Owned, StorageMut}; use crate::storage::{InnerOwned, StorageMut};
use crate::{Const, U1}; use crate::{Const, U1};
/// A sequence of row or column permutations. /// A sequence of row or column permutations.
@ -200,7 +200,7 @@ where
MaybeUninit<(usize, usize)>, MaybeUninit<(usize, usize)>,
D, D,
U1, U1,
Owned<MaybeUninit<(usize, usize)>, D, U1>, InnerOwned<MaybeUninit<(usize, usize)>, D, U1>,
>, >,
>, >,
>, >,

View File

@ -8,7 +8,7 @@ use crate::allocator::{Allocator, Reallocator};
use crate::base::{DefaultAllocator, Matrix, OMatrix, OVector, Unit}; use crate::base::{DefaultAllocator, Matrix, OMatrix, OVector, Unit};
use crate::constraint::{SameNumberOfRows, ShapeConstraint}; use crate::constraint::{SameNumberOfRows, ShapeConstraint};
use crate::dimension::{Const, Dim, DimMin, DimMinimum}; use crate::dimension::{Const, Dim, DimMin, DimMinimum};
use crate::storage::{Owned, Storage, StorageMut}; use crate::storage::{InnerOwned, Storage, StorageMut};
use simba::scalar::ComplexField; use simba::scalar::ComplexField;
use crate::geometry::Reflection; use crate::geometry::Reflection;
@ -39,19 +39,21 @@ where
diag: OVector<T, DimMinimum<R, C>>, diag: OVector<T, DimMinimum<R, C>>,
} }
/*
impl<T: Copy, R: DimMin<C>, C: Dim> Copy for QR<T, R, C> impl<T: Copy, R: DimMin<C>, C: Dim> Copy for QR<T, R, C>
where where
DefaultAllocator: Allocator<T, R, C> + Allocator<T, DimMinimum<R, C>>, DefaultAllocator: Allocator<T, R, C> + Allocator<T, DimMinimum<R, C>>,
Owned<T, R, C>: Copy, InnerOwned<T, R, C>: Copy,
Owned<T, DimMinimum<R, C>>: Copy, InnerOwned<T, DimMinimum<R, C>>: Copy,
{ {
} }
*/
impl<T: Clone, R: DimMin<C>, C: Dim> Clone for QR<T, R, C> impl<T: Clone, R: DimMin<C>, C: Dim> Clone for QR<T, R, C>
where where
DefaultAllocator: Allocator<T, R, C> + Allocator<T, DimMinimum<R, C>>, DefaultAllocator: Allocator<T, R, C> + Allocator<T, DimMinimum<R, C>>,
Owned<T, R, C>: Clone, InnerOwned<T, R, C>: Clone,
Owned<T, DimMinimum<R, C>>: Clone, InnerOwned<T, DimMinimum<R, C>>: Clone,
{ {
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self { Self {
@ -64,8 +66,8 @@ where
impl<T: fmt::Debug, R: DimMin<C>, C: Dim> fmt::Debug for QR<T, R, C> impl<T: fmt::Debug, R: DimMin<C>, C: Dim> fmt::Debug for QR<T, R, C>
where where
DefaultAllocator: Allocator<T, R, C> + Allocator<T, DimMinimum<R, C>>, DefaultAllocator: Allocator<T, R, C> + Allocator<T, DimMinimum<R, C>>,
Owned<T, R, C>: fmt::Debug, InnerOwned<T, R, C>: fmt::Debug,
Owned<T, DimMinimum<R, C>>: fmt::Debug, InnerOwned<T, DimMinimum<R, C>>: fmt::Debug,
{ {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("QR") f.debug_struct("QR")

View File

@ -11,9 +11,11 @@ use num_complex::Complex as NumComplex;
use simba::scalar::{ComplexField, RealField}; use simba::scalar::{ComplexField, RealField};
use crate::allocator::Allocator; use crate::allocator::Allocator;
use crate::base::dimension::{Const, Dim, DimDiff, DimSub, Dynamic, U1, U2}; use crate::base::dimension::{Const, Dim, DimDiff, DimName, DimSub, Dynamic, U1, U2};
use crate::base::storage::{Owned, Storage}; use crate::base::storage::{InnerOwned, Storage};
use crate::base::{DefaultAllocator, OMatrix, OVector, SquareMatrix, Unit, Vector2, Vector3}; use crate::base::{
DefaultAllocator, OMatrix, OVector, Owned, SquareMatrix, Unit, Vector2, Vector3,
};
use crate::geometry::Reflection; use crate::geometry::Reflection;
use crate::linalg::givens::GivensRotation; use crate::linalg::givens::GivensRotation;
@ -42,7 +44,7 @@ where
t: OMatrix<T, D, D>, t: OMatrix<T, D, D>,
} }
impl<T: Copy, D: Dim> Copy for Schur<T, D> impl<T: Copy, D: DimName> Copy for Schur<T, D>
where where
DefaultAllocator: Allocator<T, D, D>, DefaultAllocator: Allocator<T, D, D>,
Owned<T, D, D>: Copy, Owned<T, D, D>: Copy,
@ -52,7 +54,7 @@ where
impl<T: Clone, D: Dim> Clone for Schur<T, D> impl<T: Clone, D: Dim> Clone for Schur<T, D>
where where
DefaultAllocator: Allocator<T, D, D>, DefaultAllocator: Allocator<T, D, D>,
Owned<T, D, D>: Clone, InnerOwned<T, D, D>: Clone,
{ {
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self { Self {
@ -65,7 +67,7 @@ where
impl<T: fmt::Debug, D: Dim> fmt::Debug for Schur<T, D> impl<T: fmt::Debug, D: Dim> fmt::Debug for Schur<T, D>
where where
DefaultAllocator: Allocator<T, D, D>, DefaultAllocator: Allocator<T, D, D>,
Owned<T, D, D>: fmt::Debug, InnerOwned<T, D, D>: fmt::Debug,
{ {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("Schur") f.debug_struct("Schur")

View File

@ -9,8 +9,8 @@ use num::{One, Zero};
use crate::allocator::Allocator; use crate::allocator::Allocator;
use crate::base::{DefaultAllocator, Matrix, Matrix2x3, OMatrix, OVector, Vector2}; use crate::base::{DefaultAllocator, Matrix, Matrix2x3, OMatrix, OVector, Vector2};
use crate::constraint::{SameNumberOfRows, ShapeConstraint}; use crate::constraint::{SameNumberOfRows, ShapeConstraint};
use crate::dimension::{Dim, DimDiff, DimMin, DimMinimum, DimSub, U1}; use crate::dimension::{Dim, DimDiff, DimMin, DimMinimum, DimName, DimSub, U1};
use crate::storage::{Owned, Storage}; use crate::storage::{InnerOwned, Storage};
use simba::scalar::{ComplexField, RealField}; use simba::scalar::{ComplexField, RealField};
use crate::linalg::givens::GivensRotation; use crate::linalg::givens::GivensRotation;
@ -55,14 +55,14 @@ where
pub singular_values: OVector<T::RealField, DimMinimum<R, C>>, pub singular_values: OVector<T::RealField, DimMinimum<R, C>>,
} }
impl<T: ComplexField, R: DimMin<C>, C: Dim> Copy for SVD<T, R, C> impl<T: ComplexField + Copy, R: DimName + DimMin<C>, C: DimName> Copy for SVD<T, R, C>
where where
DefaultAllocator: Allocator<T, DimMinimum<R, C>, C> DefaultAllocator: Allocator<T, DimMinimum<R, C>, C>
+ Allocator<T, R, DimMinimum<R, C>> + Allocator<T, R, DimMinimum<R, C>>
+ Allocator<T::RealField, DimMinimum<R, C>>, + Allocator<T::RealField, DimMinimum<R, C>>,
Owned<T, R, DimMinimum<R, C>>: Copy, InnerOwned<T, R, DimMinimum<R, C>>: Copy,
Owned<T, DimMinimum<R, C>, C>: Copy, InnerOwned<T, DimMinimum<R, C>, C>: Copy,
Owned<T::RealField, DimMinimum<R, C>>: Copy, InnerOwned<T::RealField, DimMinimum<R, C>>: Copy,
{ {
} }
@ -71,9 +71,9 @@ where
DefaultAllocator: Allocator<T, DimMinimum<R, C>, C> DefaultAllocator: Allocator<T, DimMinimum<R, C>, C>
+ Allocator<T, R, DimMinimum<R, C>> + Allocator<T, R, DimMinimum<R, C>>
+ Allocator<T::RealField, DimMinimum<R, C>>, + Allocator<T::RealField, DimMinimum<R, C>>,
Owned<T, R, DimMinimum<R, C>>: Clone, InnerOwned<T, R, DimMinimum<R, C>>: Clone,
Owned<T, DimMinimum<R, C>, C>: Clone, InnerOwned<T, DimMinimum<R, C>, C>: Clone,
Owned<T::RealField, DimMinimum<R, C>>: Clone, InnerOwned<T::RealField, DimMinimum<R, C>>: Clone,
{ {
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self { Self {
@ -89,9 +89,9 @@ where
DefaultAllocator: Allocator<T, DimMinimum<R, C>, C> DefaultAllocator: Allocator<T, DimMinimum<R, C>, C>
+ Allocator<T, R, DimMinimum<R, C>> + Allocator<T, R, DimMinimum<R, C>>
+ Allocator<T::RealField, DimMinimum<R, C>>, + Allocator<T::RealField, DimMinimum<R, C>>,
Owned<T, R, DimMinimum<R, C>>: fmt::Debug, InnerOwned<T, R, DimMinimum<R, C>>: fmt::Debug,
Owned<T, DimMinimum<R, C>, C>: fmt::Debug, InnerOwned<T, DimMinimum<R, C>, C>: fmt::Debug,
Owned<T::RealField, DimMinimum<R, C>>: fmt::Debug, InnerOwned<T::RealField, DimMinimum<R, C>>: fmt::Debug,
{ {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SVD") f.debug_struct("SVD")

View File

@ -8,8 +8,8 @@ use num::Zero;
use crate::allocator::Allocator; use crate::allocator::Allocator;
use crate::base::{DefaultAllocator, Matrix2, OMatrix, OVector, SquareMatrix, Vector2}; use crate::base::{DefaultAllocator, Matrix2, OMatrix, OVector, SquareMatrix, Vector2};
use crate::dimension::{Dim, DimDiff, DimSub, U1}; use crate::dimension::{Dim, DimDiff, DimName, DimSub, U1};
use crate::storage::{Owned, Storage}; use crate::storage::{InnerOwned, Storage};
use simba::scalar::ComplexField; use simba::scalar::ComplexField;
use crate::linalg::givens::GivensRotation; use crate::linalg::givens::GivensRotation;
@ -42,19 +42,19 @@ where
pub eigenvalues: OVector<T::RealField, D>, pub eigenvalues: OVector<T::RealField, D>,
} }
impl<T: ComplexField, D: Dim> Copy for SymmetricEigen<T, D> impl<T: ComplexField, D: DimName> Copy for SymmetricEigen<T, D>
where where
DefaultAllocator: Allocator<T, D, D> + Allocator<T::RealField, D>, DefaultAllocator: Allocator<T, D, D> + Allocator<T::RealField, D>,
Owned<T, D, D>: Copy, InnerOwned<T, D, D>: Copy,
Owned<T::RealField, D>: Copy, InnerOwned<T::RealField, D>: Copy,
{ {
} }
impl<T: ComplexField, D: Dim> Clone for SymmetricEigen<T, D> impl<T: ComplexField, D: Dim> Clone for SymmetricEigen<T, D>
where where
DefaultAllocator: Allocator<T, D, D> + Allocator<T::RealField, D>, DefaultAllocator: Allocator<T, D, D> + Allocator<T::RealField, D>,
Owned<T, D, D>: Clone, InnerOwned<T, D, D>: Clone,
Owned<T::RealField, D>: Clone, InnerOwned<T::RealField, D>: Clone,
{ {
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self { Self {
@ -67,8 +67,8 @@ where
impl<T: ComplexField, D: Dim> fmt::Debug for SymmetricEigen<T, D> impl<T: ComplexField, D: Dim> fmt::Debug for SymmetricEigen<T, D>
where where
DefaultAllocator: Allocator<T, D, D> + Allocator<T::RealField, D>, DefaultAllocator: Allocator<T, D, D> + Allocator<T::RealField, D>,
Owned<T, D, D>: fmt::Debug, InnerOwned<T, D, D>: fmt::Debug,
Owned<T::RealField, D>: fmt::Debug, InnerOwned<T::RealField, D>: fmt::Debug,
{ {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("SymmetricEigen") f.debug_struct("SymmetricEigen")
@ -301,7 +301,7 @@ where
#[must_use] #[must_use]
pub fn recompose(&self) -> OMatrix<T, D, D> pub fn recompose(&self) -> OMatrix<T, D, D>
where where
Owned<T, D, D>: Clone, InnerOwned<T, D, D>: Clone,
{ {
let mut u_t = self.eigenvectors.clone(); let mut u_t = self.eigenvectors.clone();
for i in 0..self.eigenvalues.len() { for i in 0..self.eigenvalues.len() {

View File

@ -6,8 +6,8 @@ use serde::{Deserialize, Serialize};
use crate::allocator::Allocator; use crate::allocator::Allocator;
use crate::base::{DefaultAllocator, OMatrix, OVector}; use crate::base::{DefaultAllocator, OMatrix, OVector};
use crate::dimension::{Const, DimDiff, DimSub, U1}; use crate::dimension::{Const, DimDiff, DimName, DimSub, U1};
use crate::storage::{Owned, Storage}; use crate::storage::{InnerOwned, Storage};
use simba::scalar::ComplexField; use simba::scalar::ComplexField;
use crate::linalg::householder; use crate::linalg::householder;
@ -36,19 +36,19 @@ where
off_diagonal: OVector<T, DimDiff<D, U1>>, off_diagonal: OVector<T, DimDiff<D, U1>>,
} }
impl<T: Copy, D: DimSub<U1>> Copy for SymmetricTridiagonal<T, D> impl<T: Copy, D: DimSub<U1> + DimName> Copy for SymmetricTridiagonal<T, D>
where where
DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>, DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>,
Owned<T, D, D>: Copy, InnerOwned<T, D, D>: Copy,
Owned<T, DimDiff<D, U1>>: Copy, InnerOwned<T, DimDiff<D, U1>>: Copy,
{ {
} }
impl<T: Clone, D: DimSub<U1>> Clone for SymmetricTridiagonal<T, D> impl<T: Clone, D: DimSub<U1>> Clone for SymmetricTridiagonal<T, D>
where where
DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>, DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>,
Owned<T, D, D>: Clone, InnerOwned<T, D, D>: Clone,
Owned<T, DimDiff<D, U1>>: Clone, InnerOwned<T, DimDiff<D, U1>>: Clone,
{ {
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self { Self {
@ -61,8 +61,8 @@ where
impl<T: fmt::Debug, D: DimSub<U1>> fmt::Debug for SymmetricTridiagonal<T, D> impl<T: fmt::Debug, D: DimSub<U1>> fmt::Debug for SymmetricTridiagonal<T, D>
where where
DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>, DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>,
Owned<T, D, D>: fmt::Debug, InnerOwned<T, D, D>: fmt::Debug,
Owned<T, DimDiff<D, U1>>: fmt::Debug, InnerOwned<T, DimDiff<D, U1>>: fmt::Debug,
{ {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("SymmetricTridiagonal") f.debug_struct("SymmetricTridiagonal")

View File

@ -5,8 +5,8 @@ use serde::{Deserialize, Serialize};
use crate::allocator::Allocator; use crate::allocator::Allocator;
use crate::base::{Const, DefaultAllocator, OMatrix, OVector}; use crate::base::{Const, DefaultAllocator, OMatrix, OVector};
use crate::dimension::Dim; use crate::dimension::{Dim, DimName};
use crate::storage::{Owned, Storage}; use crate::storage::{InnerOwned, Storage};
use simba::scalar::RealField; use simba::scalar::RealField;
/// UDU factorization. /// UDU factorization.
@ -31,19 +31,19 @@ where
pub d: OVector<T, D>, pub d: OVector<T, D>,
} }
impl<T: Copy, D: Dim> Copy for UDU<T, D> impl<T: Copy, D: DimName> Copy for UDU<T, D>
where where
DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>, DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
Owned<T, D>: Copy, InnerOwned<T, D>: Copy,
Owned<T, D, D>: Copy, InnerOwned<T, D, D>: Copy,
{ {
} }
impl<T: Clone, D: Dim> Clone for UDU<T, D> impl<T: Clone, D: Dim> Clone for UDU<T, D>
where where
DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>, DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
Owned<T, D>: Clone, InnerOwned<T, D>: Clone,
Owned<T, D, D>: Clone, InnerOwned<T, D, D>: Clone,
{ {
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self { Self {
@ -56,8 +56,8 @@ where
impl<T: fmt::Debug, D: Dim> fmt::Debug for UDU<T, D> impl<T: fmt::Debug, D: Dim> fmt::Debug for UDU<T, D>
where where
DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>, DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
Owned<T, D>: fmt::Debug, InnerOwned<T, D>: fmt::Debug,
Owned<T, D, D>: fmt::Debug, InnerOwned<T, D, D>: fmt::Debug,
{ {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("UDU") f.debug_struct("UDU")