feat: use GAT to remove the scalar type T from the Allocator trait (#1397)
This commit is contained in:
parent
28e993a4f5
commit
c23807ac5d
|
@ -12,7 +12,7 @@ fn reflect_wrt_hyperplane_with_dimensional_genericity<T: RealField, D: Dim>(
|
||||||
where
|
where
|
||||||
T: RealField,
|
T: RealField,
|
||||||
D: Dim,
|
D: Dim,
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
let n = plane_normal.as_ref(); // Get the underlying V.
|
let n = plane_normal.as_ref(); // Get the underlying V.
|
||||||
vector - n * (n.dot(vector) * na::convert(2.0))
|
vector - n * (n.dot(vector) * na::convert(2.0))
|
||||||
|
|
|
@ -15,32 +15,32 @@ use lapack;
|
||||||
#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
|
#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize",
|
feature = "serde-serialize",
|
||||||
serde(bound(serialize = "DefaultAllocator: Allocator<T, D>,
|
serde(bound(serialize = "DefaultAllocator: Allocator<D>,
|
||||||
OMatrix<T, D, D>: Serialize"))
|
OMatrix<T, D, D>: Serialize"))
|
||||||
)]
|
)]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize",
|
feature = "serde-serialize",
|
||||||
serde(bound(deserialize = "DefaultAllocator: Allocator<T, D>,
|
serde(bound(deserialize = "DefaultAllocator: Allocator<D>,
|
||||||
OMatrix<T, D, D>: Deserialize<'de>"))
|
OMatrix<T, D, D>: Deserialize<'de>"))
|
||||||
)]
|
)]
|
||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
pub struct Cholesky<T: Scalar, D: Dim>
|
pub struct Cholesky<T: Scalar, D: Dim>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
l: OMatrix<T, D, D>,
|
l: OMatrix<T, D, D>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T: Scalar + Copy, D: Dim> Copy for Cholesky<T, D>
|
impl<T: Scalar + Copy, D: Dim> Copy for Cholesky<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
OMatrix<T, D, D>: Copy,
|
OMatrix<T, D, D>: Copy,
|
||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T: CholeskyScalar + Zero, D: Dim> Cholesky<T, D>
|
impl<T: CholeskyScalar + Zero, D: Dim> Cholesky<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
/// Computes the cholesky decomposition of the given symmetric-definite-positive square
|
/// Computes the cholesky decomposition of the given symmetric-definite-positive square
|
||||||
/// matrix.
|
/// matrix.
|
||||||
|
@ -105,7 +105,7 @@ where
|
||||||
) -> Option<OMatrix<T, R2, C2>>
|
) -> Option<OMatrix<T, R2, C2>>
|
||||||
where
|
where
|
||||||
S2: Storage<T, R2, C2>,
|
S2: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: Allocator<T, R2, C2>,
|
DefaultAllocator: Allocator<R2, C2>,
|
||||||
{
|
{
|
||||||
let mut res = b.clone_owned();
|
let mut res = b.clone_owned();
|
||||||
if self.solve_mut(&mut res) {
|
if self.solve_mut(&mut res) {
|
||||||
|
@ -119,7 +119,7 @@ where
|
||||||
/// the unknown to be determined.
|
/// the unknown to be determined.
|
||||||
pub fn solve_mut<R2: Dim, C2: Dim>(&self, b: &mut OMatrix<T, R2, C2>) -> bool
|
pub fn solve_mut<R2: Dim, C2: Dim>(&self, b: &mut OMatrix<T, R2, C2>) -> bool
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R2, C2>,
|
DefaultAllocator: Allocator<R2, C2>,
|
||||||
{
|
{
|
||||||
let dim = self.l.nrows();
|
let dim = self.l.nrows();
|
||||||
|
|
||||||
|
|
|
@ -16,24 +16,20 @@ use lapack;
|
||||||
#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
|
#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize",
|
feature = "serde-serialize",
|
||||||
serde(
|
serde(bound(serialize = "DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
bound(serialize = "DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
|
|
||||||
OVector<T, D>: Serialize,
|
OVector<T, D>: Serialize,
|
||||||
OMatrix<T, D, D>: Serialize")
|
OMatrix<T, D, D>: Serialize"))
|
||||||
)
|
|
||||||
)]
|
)]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize",
|
feature = "serde-serialize",
|
||||||
serde(
|
serde(bound(deserialize = "DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
bound(deserialize = "DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
|
|
||||||
OVector<T, D>: Serialize,
|
OVector<T, D>: Serialize,
|
||||||
OMatrix<T, D, D>: Deserialize<'de>")
|
OMatrix<T, D, D>: Deserialize<'de>"))
|
||||||
)
|
|
||||||
)]
|
)]
|
||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
pub struct Eigen<T: Scalar, D: Dim>
|
pub struct Eigen<T: Scalar, D: Dim>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D> + Allocator<D, D>,
|
||||||
{
|
{
|
||||||
/// The real parts of eigenvalues of the decomposed matrix.
|
/// The real parts of eigenvalues of the decomposed matrix.
|
||||||
pub eigenvalues_re: OVector<T, D>,
|
pub eigenvalues_re: OVector<T, D>,
|
||||||
|
@ -47,7 +43,7 @@ where
|
||||||
|
|
||||||
impl<T: Scalar + Copy, D: Dim> Copy for Eigen<T, D>
|
impl<T: Scalar + Copy, D: Dim> Copy for Eigen<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D> + Allocator<D, D>,
|
||||||
OVector<T, D>: Copy,
|
OVector<T, D>: Copy,
|
||||||
OMatrix<T, D, D>: Copy,
|
OMatrix<T, D, D>: Copy,
|
||||||
{
|
{
|
||||||
|
@ -55,7 +51,7 @@ where
|
||||||
|
|
||||||
impl<T: EigenScalar + RealField, D: Dim> Eigen<T, D>
|
impl<T: EigenScalar + RealField, D: Dim> Eigen<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
|
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
{
|
{
|
||||||
/// Computes the eigenvalues and eigenvectors of the square matrix `m`.
|
/// Computes the eigenvalues and eigenvectors of the square matrix `m`.
|
||||||
///
|
///
|
||||||
|
@ -177,7 +173,7 @@ where
|
||||||
Option<Vec<OVector<T, D>>>,
|
Option<Vec<OVector<T, D>>>,
|
||||||
)
|
)
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
let (number_of_elements, _) = self.eigenvalues_re.shape_generic();
|
let (number_of_elements, _) = self.eigenvalues_re.shape_generic();
|
||||||
let number_of_elements_value = number_of_elements.value();
|
let number_of_elements_value = number_of_elements.value();
|
||||||
|
@ -234,7 +230,7 @@ where
|
||||||
Option<Vec<OVector<Complex<T>, D>>>,
|
Option<Vec<OVector<Complex<T>, D>>>,
|
||||||
)
|
)
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<Complex<T>, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
match self.eigenvalues_are_real() {
|
match self.eigenvalues_are_real() {
|
||||||
true => (None, None, None),
|
true => (None, None, None),
|
||||||
|
|
|
@ -30,24 +30,20 @@ use lapack;
|
||||||
#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
|
#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize",
|
feature = "serde-serialize",
|
||||||
serde(
|
serde(bound(serialize = "DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
bound(serialize = "DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
|
|
||||||
OVector<T, D>: Serialize,
|
OVector<T, D>: Serialize,
|
||||||
OMatrix<T, D, D>: Serialize")
|
OMatrix<T, D, D>: Serialize"))
|
||||||
)
|
|
||||||
)]
|
)]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize",
|
feature = "serde-serialize",
|
||||||
serde(
|
serde(bound(deserialize = "DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
bound(deserialize = "DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
|
|
||||||
OVector<T, D>: Deserialize<'de>,
|
OVector<T, D>: Deserialize<'de>,
|
||||||
OMatrix<T, D, D>: Deserialize<'de>")
|
OMatrix<T, D, D>: Deserialize<'de>"))
|
||||||
)
|
|
||||||
)]
|
)]
|
||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
pub struct GeneralizedEigen<T: Scalar, D: Dim>
|
pub struct GeneralizedEigen<T: Scalar, D: Dim>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D> + Allocator<D, D>,
|
||||||
{
|
{
|
||||||
alphar: OVector<T, D>,
|
alphar: OVector<T, D>,
|
||||||
alphai: OVector<T, D>,
|
alphai: OVector<T, D>,
|
||||||
|
@ -58,7 +54,7 @@ where
|
||||||
|
|
||||||
impl<T: Scalar + Copy, D: Dim> Copy for GeneralizedEigen<T, D>
|
impl<T: Scalar + Copy, D: Dim> Copy for GeneralizedEigen<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
|
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
OMatrix<T, D, D>: Copy,
|
OMatrix<T, D, D>: Copy,
|
||||||
OVector<T, D>: Copy,
|
OVector<T, D>: Copy,
|
||||||
{
|
{
|
||||||
|
@ -66,7 +62,7 @@ where
|
||||||
|
|
||||||
impl<T: GeneralizedEigenScalar + RealField + Copy, D: Dim> GeneralizedEigen<T, D>
|
impl<T: GeneralizedEigenScalar + RealField + Copy, D: Dim> GeneralizedEigen<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
|
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
{
|
{
|
||||||
/// Attempts to compute the generalized eigenvalues, and left and right associated eigenvectors
|
/// Attempts to compute the generalized eigenvalues, and left and right associated eigenvectors
|
||||||
/// via the raw returns from LAPACK's dggev and sggev routines
|
/// via the raw returns from LAPACK's dggev and sggev routines
|
||||||
|
@ -162,8 +158,7 @@ where
|
||||||
/// as columns.
|
/// as columns.
|
||||||
pub fn eigenvectors(&self) -> (OMatrix<Complex<T>, D, D>, OMatrix<Complex<T>, D, D>)
|
pub fn eigenvectors(&self) -> (OMatrix<Complex<T>, D, D>, OMatrix<Complex<T>, D, D>)
|
||||||
where
|
where
|
||||||
DefaultAllocator:
|
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
Allocator<Complex<T>, D, D> + Allocator<Complex<T>, D> + Allocator<(Complex<T>, T), D>,
|
|
||||||
{
|
{
|
||||||
/*
|
/*
|
||||||
How the eigenvectors are built up:
|
How the eigenvectors are built up:
|
||||||
|
@ -230,7 +225,7 @@ where
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn raw_eigenvalues(&self) -> OVector<(Complex<T>, T), D>
|
pub fn raw_eigenvalues(&self) -> OVector<(Complex<T>, T), D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<(Complex<T>, T), D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
let mut out = Matrix::from_element_generic(
|
let mut out = Matrix::from_element_generic(
|
||||||
self.vsl.shape_generic().0,
|
self.vsl.shape_generic().0,
|
||||||
|
|
|
@ -12,22 +12,22 @@ use lapack;
|
||||||
#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
|
#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize",
|
feature = "serde-serialize",
|
||||||
serde(bound(serialize = "DefaultAllocator: Allocator<T, D, D> +
|
serde(bound(serialize = "DefaultAllocator: Allocator<D, D> +
|
||||||
Allocator<T, DimDiff<D, U1>>,
|
Allocator<DimDiff<D, U1>>,
|
||||||
OMatrix<T, D, D>: Serialize,
|
OMatrix<T, D, D>: Serialize,
|
||||||
OVector<T, DimDiff<D, U1>>: Serialize"))
|
OVector<T, DimDiff<D, U1>>: Serialize"))
|
||||||
)]
|
)]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize",
|
feature = "serde-serialize",
|
||||||
serde(bound(deserialize = "DefaultAllocator: Allocator<T, D, D> +
|
serde(bound(deserialize = "DefaultAllocator: Allocator<D, D> +
|
||||||
Allocator<T, DimDiff<D, U1>>,
|
Allocator<DimDiff<D, U1>>,
|
||||||
OMatrix<T, D, D>: Deserialize<'de>,
|
OMatrix<T, D, D>: Deserialize<'de>,
|
||||||
OVector<T, DimDiff<D, U1>>: Deserialize<'de>"))
|
OVector<T, DimDiff<D, U1>>: Deserialize<'de>"))
|
||||||
)]
|
)]
|
||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
pub struct Hessenberg<T: Scalar, D: DimSub<U1>>
|
pub struct Hessenberg<T: Scalar, D: DimSub<U1>>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>,
|
DefaultAllocator: Allocator<D, D> + Allocator<DimDiff<D, U1>>,
|
||||||
{
|
{
|
||||||
h: OMatrix<T, D, D>,
|
h: OMatrix<T, D, D>,
|
||||||
tau: OVector<T, DimDiff<D, U1>>,
|
tau: OVector<T, DimDiff<D, U1>>,
|
||||||
|
@ -35,7 +35,7 @@ where
|
||||||
|
|
||||||
impl<T: Scalar + Copy, D: DimSub<U1>> Copy for Hessenberg<T, D>
|
impl<T: Scalar + Copy, D: DimSub<U1>> Copy for Hessenberg<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>,
|
DefaultAllocator: Allocator<D, D> + Allocator<DimDiff<D, U1>>,
|
||||||
OMatrix<T, D, D>: Copy,
|
OMatrix<T, D, D>: Copy,
|
||||||
OVector<T, DimDiff<D, U1>>: Copy,
|
OVector<T, DimDiff<D, U1>>: Copy,
|
||||||
{
|
{
|
||||||
|
@ -43,7 +43,7 @@ where
|
||||||
|
|
||||||
impl<T: HessenbergScalar + Zero, D: DimSub<U1>> Hessenberg<T, D>
|
impl<T: HessenbergScalar + Zero, D: DimSub<U1>> Hessenberg<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>,
|
DefaultAllocator: Allocator<D, D> + Allocator<DimDiff<D, U1>>,
|
||||||
{
|
{
|
||||||
/// Computes the hessenberg decomposition of the matrix `m`.
|
/// Computes the hessenberg decomposition of the matrix `m`.
|
||||||
pub fn new(mut m: OMatrix<T, D, D>) -> Self {
|
pub fn new(mut m: OMatrix<T, D, D>) -> Self {
|
||||||
|
@ -97,7 +97,7 @@ where
|
||||||
|
|
||||||
impl<T: HessenbergReal + Zero, D: DimSub<U1>> Hessenberg<T, D>
|
impl<T: HessenbergReal + Zero, D: DimSub<U1>> Hessenberg<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>,
|
DefaultAllocator: Allocator<D, D> + Allocator<DimDiff<D, U1>>,
|
||||||
{
|
{
|
||||||
/// Computes the matrices `(Q, H)` of this decomposition.
|
/// Computes the matrices `(Q, H)` of this decomposition.
|
||||||
#[inline]
|
#[inline]
|
||||||
|
|
|
@ -20,22 +20,22 @@ use lapack;
|
||||||
#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
|
#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize",
|
feature = "serde-serialize",
|
||||||
serde(bound(serialize = "DefaultAllocator: Allocator<T, R, C> +
|
serde(bound(serialize = "DefaultAllocator: Allocator<R, C> +
|
||||||
Allocator<i32, DimMinimum<R, C>>,
|
Allocator<DimMinimum<R, C>>,
|
||||||
OMatrix<T, R, C>: Serialize,
|
OMatrix<T, R, C>: Serialize,
|
||||||
PermutationSequence<DimMinimum<R, C>>: Serialize"))
|
PermutationSequence<DimMinimum<R, C>>: Serialize"))
|
||||||
)]
|
)]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize",
|
feature = "serde-serialize",
|
||||||
serde(bound(deserialize = "DefaultAllocator: Allocator<T, R, C> +
|
serde(bound(deserialize = "DefaultAllocator: Allocator<R, C> +
|
||||||
Allocator<i32, DimMinimum<R, C>>,
|
Allocator<DimMinimum<R, C>>,
|
||||||
OMatrix<T, R, C>: Deserialize<'de>,
|
OMatrix<T, R, C>: Deserialize<'de>,
|
||||||
PermutationSequence<DimMinimum<R, C>>: Deserialize<'de>"))
|
PermutationSequence<DimMinimum<R, C>>: Deserialize<'de>"))
|
||||||
)]
|
)]
|
||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
pub struct LU<T: Scalar, R: DimMin<C>, C: Dim>
|
pub struct LU<T: Scalar, R: DimMin<C>, C: Dim>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<i32, DimMinimum<R, C>> + Allocator<T, R, C>,
|
DefaultAllocator: Allocator<DimMinimum<R, C>> + Allocator<R, C>,
|
||||||
{
|
{
|
||||||
lu: OMatrix<T, R, C>,
|
lu: OMatrix<T, R, C>,
|
||||||
p: OVector<i32, DimMinimum<R, C>>,
|
p: OVector<i32, DimMinimum<R, C>>,
|
||||||
|
@ -43,7 +43,7 @@ where
|
||||||
|
|
||||||
impl<T: Scalar + Copy, R: DimMin<C>, C: Dim> Copy for LU<T, R, C>
|
impl<T: Scalar + Copy, R: DimMin<C>, C: Dim> Copy for LU<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C> + Allocator<i32, DimMinimum<R, C>>,
|
DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>>,
|
||||||
OMatrix<T, R, C>: Copy,
|
OMatrix<T, R, C>: Copy,
|
||||||
OVector<i32, DimMinimum<R, C>>: Copy,
|
OVector<i32, DimMinimum<R, C>>: Copy,
|
||||||
{
|
{
|
||||||
|
@ -53,11 +53,11 @@ impl<T: LUScalar, R: Dim, C: Dim> LU<T, R, C>
|
||||||
where
|
where
|
||||||
T: Zero + One,
|
T: Zero + One,
|
||||||
R: DimMin<C>,
|
R: DimMin<C>,
|
||||||
DefaultAllocator: Allocator<T, R, C>
|
DefaultAllocator: Allocator<R, C>
|
||||||
+ Allocator<T, R, R>
|
+ Allocator<R, R>
|
||||||
+ Allocator<T, R, DimMinimum<R, C>>
|
+ Allocator<R, DimMinimum<R, C>>
|
||||||
+ Allocator<T, DimMinimum<R, C>, C>
|
+ Allocator<DimMinimum<R, C>, C>
|
||||||
+ Allocator<i32, DimMinimum<R, C>>,
|
+ Allocator<DimMinimum<R, C>>,
|
||||||
{
|
{
|
||||||
/// Computes the LU decomposition with partial (row) pivoting of `matrix`.
|
/// Computes the LU decomposition with partial (row) pivoting of `matrix`.
|
||||||
pub fn new(mut m: OMatrix<T, R, C>) -> Self {
|
pub fn new(mut m: OMatrix<T, R, C>) -> Self {
|
||||||
|
@ -136,7 +136,7 @@ where
|
||||||
#[inline]
|
#[inline]
|
||||||
pub fn permute<C2: Dim>(&self, rhs: &mut OMatrix<T, R, C2>)
|
pub fn permute<C2: Dim>(&self, rhs: &mut OMatrix<T, R, C2>)
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C2>,
|
DefaultAllocator: Allocator<R, C2>,
|
||||||
{
|
{
|
||||||
let (nrows, ncols) = rhs.shape();
|
let (nrows, ncols) = rhs.shape();
|
||||||
|
|
||||||
|
@ -153,7 +153,7 @@ where
|
||||||
|
|
||||||
fn generic_solve_mut<R2: Dim, C2: Dim>(&self, trans: u8, b: &mut OMatrix<T, R2, C2>) -> bool
|
fn generic_solve_mut<R2: Dim, C2: Dim>(&self, trans: u8, b: &mut OMatrix<T, R2, C2>) -> bool
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R2, C2> + Allocator<i32, R2>,
|
DefaultAllocator: Allocator<R2, C2> + Allocator<R2>,
|
||||||
{
|
{
|
||||||
let dim = self.lu.nrows();
|
let dim = self.lu.nrows();
|
||||||
|
|
||||||
|
@ -192,7 +192,7 @@ where
|
||||||
) -> Option<OMatrix<T, R2, C2>>
|
) -> Option<OMatrix<T, R2, C2>>
|
||||||
where
|
where
|
||||||
S2: Storage<T, R2, C2>,
|
S2: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: Allocator<T, R2, C2> + Allocator<i32, R2>,
|
DefaultAllocator: Allocator<R2, C2> + Allocator<R2>,
|
||||||
{
|
{
|
||||||
let mut res = b.clone_owned();
|
let mut res = b.clone_owned();
|
||||||
if self.generic_solve_mut(b'T', &mut res) {
|
if self.generic_solve_mut(b'T', &mut res) {
|
||||||
|
@ -210,7 +210,7 @@ where
|
||||||
) -> Option<OMatrix<T, R2, C2>>
|
) -> Option<OMatrix<T, R2, C2>>
|
||||||
where
|
where
|
||||||
S2: Storage<T, R2, C2>,
|
S2: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: Allocator<T, R2, C2> + Allocator<i32, R2>,
|
DefaultAllocator: Allocator<R2, C2> + Allocator<R2>,
|
||||||
{
|
{
|
||||||
let mut res = b.clone_owned();
|
let mut res = b.clone_owned();
|
||||||
if self.generic_solve_mut(b'T', &mut res) {
|
if self.generic_solve_mut(b'T', &mut res) {
|
||||||
|
@ -228,7 +228,7 @@ where
|
||||||
) -> Option<OMatrix<T, R2, C2>>
|
) -> Option<OMatrix<T, R2, C2>>
|
||||||
where
|
where
|
||||||
S2: Storage<T, R2, C2>,
|
S2: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: Allocator<T, R2, C2> + Allocator<i32, R2>,
|
DefaultAllocator: Allocator<R2, C2> + Allocator<R2>,
|
||||||
{
|
{
|
||||||
let mut res = b.clone_owned();
|
let mut res = b.clone_owned();
|
||||||
if self.generic_solve_mut(b'T', &mut res) {
|
if self.generic_solve_mut(b'T', &mut res) {
|
||||||
|
@ -243,7 +243,7 @@ where
|
||||||
/// Returns `false` if no solution was found (the decomposed matrix is singular).
|
/// Returns `false` if no solution was found (the decomposed matrix is singular).
|
||||||
pub fn solve_mut<R2: Dim, C2: Dim>(&self, b: &mut OMatrix<T, R2, C2>) -> bool
|
pub fn solve_mut<R2: Dim, C2: Dim>(&self, b: &mut OMatrix<T, R2, C2>) -> bool
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R2, C2> + Allocator<i32, R2>,
|
DefaultAllocator: Allocator<R2, C2> + Allocator<R2>,
|
||||||
{
|
{
|
||||||
self.generic_solve_mut(b'T', b)
|
self.generic_solve_mut(b'T', b)
|
||||||
}
|
}
|
||||||
|
@ -254,7 +254,7 @@ where
|
||||||
/// Returns `false` if no solution was found (the decomposed matrix is singular).
|
/// Returns `false` if no solution was found (the decomposed matrix is singular).
|
||||||
pub fn solve_transpose_mut<R2: Dim, C2: Dim>(&self, b: &mut OMatrix<T, R2, C2>) -> bool
|
pub fn solve_transpose_mut<R2: Dim, C2: Dim>(&self, b: &mut OMatrix<T, R2, C2>) -> bool
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R2, C2> + Allocator<i32, R2>,
|
DefaultAllocator: Allocator<R2, C2> + Allocator<R2>,
|
||||||
{
|
{
|
||||||
self.generic_solve_mut(b'T', b)
|
self.generic_solve_mut(b'T', b)
|
||||||
}
|
}
|
||||||
|
@ -265,7 +265,7 @@ where
|
||||||
/// Returns `false` if no solution was found (the decomposed matrix is singular).
|
/// Returns `false` if no solution was found (the decomposed matrix is singular).
|
||||||
pub fn solve_adjoint_mut<R2: Dim, C2: Dim>(&self, b: &mut OMatrix<T, R2, C2>) -> bool
|
pub fn solve_adjoint_mut<R2: Dim, C2: Dim>(&self, b: &mut OMatrix<T, R2, C2>) -> bool
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R2, C2> + Allocator<i32, R2>,
|
DefaultAllocator: Allocator<R2, C2> + Allocator<R2>,
|
||||||
{
|
{
|
||||||
self.generic_solve_mut(b'T', b)
|
self.generic_solve_mut(b'T', b)
|
||||||
}
|
}
|
||||||
|
@ -275,7 +275,7 @@ impl<T: LUScalar, D: Dim> LU<T, D, D>
|
||||||
where
|
where
|
||||||
T: Zero + One,
|
T: Zero + One,
|
||||||
D: DimMin<D, Output = D>,
|
D: DimMin<D, Output = D>,
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<i32, D>,
|
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
{
|
{
|
||||||
/// Computes the inverse of the decomposed matrix.
|
/// Computes the inverse of the decomposed matrix.
|
||||||
pub fn inverse(mut self) -> Option<OMatrix<T, D, D>> {
|
pub fn inverse(mut self) -> Option<OMatrix<T, D, D>> {
|
||||||
|
|
|
@ -15,22 +15,22 @@ use lapack;
|
||||||
#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
|
#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize",
|
feature = "serde-serialize",
|
||||||
serde(bound(serialize = "DefaultAllocator: Allocator<T, R, C> +
|
serde(bound(serialize = "DefaultAllocator: Allocator<R, C> +
|
||||||
Allocator<T, DimMinimum<R, C>>,
|
Allocator<DimMinimum<R, C>>,
|
||||||
OMatrix<T, R, C>: Serialize,
|
OMatrix<T, R, C>: Serialize,
|
||||||
OVector<T, DimMinimum<R, C>>: Serialize"))
|
OVector<T, DimMinimum<R, C>>: Serialize"))
|
||||||
)]
|
)]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize",
|
feature = "serde-serialize",
|
||||||
serde(bound(deserialize = "DefaultAllocator: Allocator<T, R, C> +
|
serde(bound(deserialize = "DefaultAllocator: Allocator<R, C> +
|
||||||
Allocator<T, DimMinimum<R, C>>,
|
Allocator<DimMinimum<R, C>>,
|
||||||
OMatrix<T, R, C>: Deserialize<'de>,
|
OMatrix<T, R, C>: Deserialize<'de>,
|
||||||
OVector<T, DimMinimum<R, C>>: Deserialize<'de>"))
|
OVector<T, DimMinimum<R, C>>: Deserialize<'de>"))
|
||||||
)]
|
)]
|
||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
pub struct QR<T: Scalar, R: DimMin<C>, C: Dim>
|
pub struct QR<T: Scalar, R: DimMin<C>, C: Dim>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C> + Allocator<T, DimMinimum<R, C>>,
|
DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>>,
|
||||||
{
|
{
|
||||||
qr: OMatrix<T, R, C>,
|
qr: OMatrix<T, R, C>,
|
||||||
tau: OVector<T, DimMinimum<R, C>>,
|
tau: OVector<T, DimMinimum<R, C>>,
|
||||||
|
@ -38,7 +38,7 @@ where
|
||||||
|
|
||||||
impl<T: Scalar + Copy, R: DimMin<C>, C: Dim> Copy for QR<T, R, C>
|
impl<T: Scalar + 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<R, C> + Allocator<DimMinimum<R, C>>,
|
||||||
OMatrix<T, R, C>: Copy,
|
OMatrix<T, R, C>: Copy,
|
||||||
OVector<T, DimMinimum<R, C>>: Copy,
|
OVector<T, DimMinimum<R, C>>: Copy,
|
||||||
{
|
{
|
||||||
|
@ -46,10 +46,10 @@ where
|
||||||
|
|
||||||
impl<T: QRScalar + Zero, R: DimMin<C>, C: Dim> QR<T, R, C>
|
impl<T: QRScalar + Zero, R: DimMin<C>, C: Dim> QR<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C>
|
DefaultAllocator: Allocator<R, C>
|
||||||
+ Allocator<T, R, DimMinimum<R, C>>
|
+ Allocator<R, DimMinimum<R, C>>
|
||||||
+ Allocator<T, DimMinimum<R, C>, C>
|
+ Allocator<DimMinimum<R, C>, C>
|
||||||
+ Allocator<T, DimMinimum<R, C>>,
|
+ Allocator<DimMinimum<R, C>>,
|
||||||
{
|
{
|
||||||
/// Computes the QR decomposition of the matrix `m`.
|
/// Computes the QR decomposition of the matrix `m`.
|
||||||
pub fn new(mut m: OMatrix<T, R, C>) -> Self {
|
pub fn new(mut m: OMatrix<T, R, C>) -> Self {
|
||||||
|
@ -98,10 +98,10 @@ where
|
||||||
|
|
||||||
impl<T: QRReal + Zero, R: DimMin<C>, C: Dim> QR<T, R, C>
|
impl<T: QRReal + Zero, R: DimMin<C>, C: Dim> QR<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C>
|
DefaultAllocator: Allocator<R, C>
|
||||||
+ Allocator<T, R, DimMinimum<R, C>>
|
+ Allocator<R, DimMinimum<R, C>>
|
||||||
+ Allocator<T, DimMinimum<R, C>, C>
|
+ Allocator<DimMinimum<R, C>, C>
|
||||||
+ Allocator<T, DimMinimum<R, C>>,
|
+ Allocator<DimMinimum<R, C>>,
|
||||||
{
|
{
|
||||||
/// Retrieves the matrices `(Q, R)` of this decompositions.
|
/// Retrieves the matrices `(Q, R)` of this decompositions.
|
||||||
pub fn unpack(
|
pub fn unpack(
|
||||||
|
|
|
@ -22,24 +22,20 @@ use lapack;
|
||||||
#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
|
#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize",
|
feature = "serde-serialize",
|
||||||
serde(
|
serde(bound(serialize = "DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
bound(serialize = "DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
|
|
||||||
OVector<T, D>: Serialize,
|
OVector<T, D>: Serialize,
|
||||||
OMatrix<T, D, D>: Serialize")
|
OMatrix<T, D, D>: Serialize"))
|
||||||
)
|
|
||||||
)]
|
)]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize",
|
feature = "serde-serialize",
|
||||||
serde(
|
serde(bound(deserialize = "DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
bound(deserialize = "DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
|
|
||||||
OVector<T, D>: Deserialize<'de>,
|
OVector<T, D>: Deserialize<'de>,
|
||||||
OMatrix<T, D, D>: Deserialize<'de>")
|
OMatrix<T, D, D>: Deserialize<'de>"))
|
||||||
)
|
|
||||||
)]
|
)]
|
||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
pub struct QZ<T: Scalar, D: Dim>
|
pub struct QZ<T: Scalar, D: Dim>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D> + Allocator<D, D>,
|
||||||
{
|
{
|
||||||
alphar: OVector<T, D>,
|
alphar: OVector<T, D>,
|
||||||
alphai: OVector<T, D>,
|
alphai: OVector<T, D>,
|
||||||
|
@ -52,7 +48,7 @@ where
|
||||||
|
|
||||||
impl<T: Scalar + Copy, D: Dim> Copy for QZ<T, D>
|
impl<T: Scalar + Copy, D: Dim> Copy for QZ<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
|
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
OMatrix<T, D, D>: Copy,
|
OMatrix<T, D, D>: Copy,
|
||||||
OVector<T, D>: Copy,
|
OVector<T, D>: Copy,
|
||||||
{
|
{
|
||||||
|
@ -60,7 +56,7 @@ where
|
||||||
|
|
||||||
impl<T: QZScalar + RealField, D: Dim> QZ<T, D>
|
impl<T: QZScalar + RealField, D: Dim> QZ<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
|
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
{
|
{
|
||||||
/// Attempts to compute the QZ decomposition of input real square matrices `a` and `b`.
|
/// Attempts to compute the QZ decomposition of input real square matrices `a` and `b`.
|
||||||
///
|
///
|
||||||
|
@ -182,7 +178,7 @@ where
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn raw_eigenvalues(&self) -> OVector<(Complex<T>, T), D>
|
pub fn raw_eigenvalues(&self) -> OVector<(Complex<T>, T), D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<(Complex<T>, T), D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
let mut out = Matrix::from_element_generic(
|
let mut out = Matrix::from_element_generic(
|
||||||
self.vsl.shape_generic().0,
|
self.vsl.shape_generic().0,
|
||||||
|
|
|
@ -17,24 +17,20 @@ use lapack;
|
||||||
#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
|
#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize",
|
feature = "serde-serialize",
|
||||||
serde(
|
serde(bound(serialize = "DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
bound(serialize = "DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
|
|
||||||
OVector<T, D>: Serialize,
|
OVector<T, D>: Serialize,
|
||||||
OMatrix<T, D, D>: Serialize")
|
OMatrix<T, D, D>: Serialize"))
|
||||||
)
|
|
||||||
)]
|
)]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize",
|
feature = "serde-serialize",
|
||||||
serde(
|
serde(bound(deserialize = "DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
bound(deserialize = "DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
|
|
||||||
OVector<T, D>: Serialize,
|
OVector<T, D>: Serialize,
|
||||||
OMatrix<T, D, D>: Deserialize<'de>")
|
OMatrix<T, D, D>: Deserialize<'de>"))
|
||||||
)
|
|
||||||
)]
|
)]
|
||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
pub struct Schur<T: Scalar, D: Dim>
|
pub struct Schur<T: Scalar, D: Dim>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D> + Allocator<D, D>,
|
||||||
{
|
{
|
||||||
re: OVector<T, D>,
|
re: OVector<T, D>,
|
||||||
im: OVector<T, D>,
|
im: OVector<T, D>,
|
||||||
|
@ -44,7 +40,7 @@ where
|
||||||
|
|
||||||
impl<T: Scalar + Copy, D: Dim> Copy for Schur<T, D>
|
impl<T: Scalar + Copy, D: Dim> Copy for Schur<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
|
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
OMatrix<T, D, D>: Copy,
|
OMatrix<T, D, D>: Copy,
|
||||||
OVector<T, D>: Copy,
|
OVector<T, D>: Copy,
|
||||||
{
|
{
|
||||||
|
@ -52,7 +48,7 @@ where
|
||||||
|
|
||||||
impl<T: SchurScalar + RealField, D: Dim> Schur<T, D>
|
impl<T: SchurScalar + RealField, D: Dim> Schur<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
|
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
{
|
{
|
||||||
/// Computes the eigenvalues and real Schur form of the matrix `m`.
|
/// Computes the eigenvalues and real Schur form of the matrix `m`.
|
||||||
///
|
///
|
||||||
|
@ -150,7 +146,7 @@ where
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn complex_eigenvalues(&self) -> OVector<Complex<T>, D>
|
pub fn complex_eigenvalues(&self) -> OVector<Complex<T>, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<Complex<T>, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
let mut out = Matrix::zeros_generic(self.t.shape_generic().0, Const::<1>);
|
let mut out = Matrix::zeros_generic(self.t.shape_generic().0, Const::<1>);
|
||||||
|
|
||||||
|
|
|
@ -14,18 +14,18 @@ use lapack;
|
||||||
#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
|
#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize",
|
feature = "serde-serialize",
|
||||||
serde(bound(serialize = "DefaultAllocator: Allocator<T, DimMinimum<R, C>> +
|
serde(bound(serialize = "DefaultAllocator: Allocator<DimMinimum<R, C>> +
|
||||||
Allocator<T, R, R> +
|
Allocator<R, R> +
|
||||||
Allocator<T, C, C>,
|
Allocator<C, C>,
|
||||||
OMatrix<T, R>: Serialize,
|
OMatrix<T, R>: Serialize,
|
||||||
OMatrix<T, C>: Serialize,
|
OMatrix<T, C>: Serialize,
|
||||||
OVector<T, DimMinimum<R, C>>: Serialize"))
|
OVector<T, DimMinimum<R, C>>: Serialize"))
|
||||||
)]
|
)]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize",
|
feature = "serde-serialize",
|
||||||
serde(bound(serialize = "DefaultAllocator: Allocator<T, DimMinimum<R, C>> +
|
serde(bound(serialize = "DefaultAllocator: Allocator<DimMinimum<R, C>> +
|
||||||
Allocator<T, R, R> +
|
Allocator<R, R> +
|
||||||
Allocator<T, C, C>,
|
Allocator<C, C>,
|
||||||
OMatrix<T, R>: Deserialize<'de>,
|
OMatrix<T, R>: Deserialize<'de>,
|
||||||
OMatrix<T, C>: Deserialize<'de>,
|
OMatrix<T, C>: Deserialize<'de>,
|
||||||
OVector<T, DimMinimum<R, C>>: Deserialize<'de>"))
|
OVector<T, DimMinimum<R, C>>: Deserialize<'de>"))
|
||||||
|
@ -33,7 +33,7 @@ use lapack;
|
||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
pub struct SVD<T: Scalar, R: DimMin<C>, C: Dim>
|
pub struct SVD<T: Scalar, R: DimMin<C>, C: Dim>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, R> + Allocator<T, DimMinimum<R, C>> + Allocator<T, C, C>,
|
DefaultAllocator: Allocator<R, R> + Allocator<DimMinimum<R, C>> + Allocator<C, C>,
|
||||||
{
|
{
|
||||||
/// The left-singular vectors `U` of this SVD.
|
/// The left-singular vectors `U` of this SVD.
|
||||||
pub u: OMatrix<T, R, R>, // TODO: should be OMatrix<T, R, DimMinimum<R, C>>
|
pub u: OMatrix<T, R, R>, // TODO: should be OMatrix<T, R, DimMinimum<R, C>>
|
||||||
|
@ -45,7 +45,7 @@ where
|
||||||
|
|
||||||
impl<T: Scalar + Copy, R: DimMin<C>, C: Dim> Copy for SVD<T, R, C>
|
impl<T: Scalar + Copy, R: DimMin<C>, C: Dim> Copy for SVD<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, C, C> + Allocator<T, R, R> + Allocator<T, DimMinimum<R, C>>,
|
DefaultAllocator: Allocator<C, C> + Allocator<R, R> + Allocator<DimMinimum<R, C>>,
|
||||||
OMatrix<T, R, R>: Copy,
|
OMatrix<T, R, R>: Copy,
|
||||||
OMatrix<T, C, C>: Copy,
|
OMatrix<T, C, C>: Copy,
|
||||||
OVector<T, DimMinimum<R, C>>: Copy,
|
OVector<T, DimMinimum<R, C>>: Copy,
|
||||||
|
@ -56,10 +56,8 @@ where
|
||||||
/// supported by the Singular Value Decompotition.
|
/// supported by the Singular Value Decompotition.
|
||||||
pub trait SVDScalar<R: DimMin<C>, C: Dim>: Scalar
|
pub trait SVDScalar<R: DimMin<C>, C: Dim>: Scalar
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<Self, R, R>
|
DefaultAllocator:
|
||||||
+ Allocator<Self, R, C>
|
Allocator<R, R> + Allocator<R, C> + Allocator<DimMinimum<R, C>> + Allocator<C, C>,
|
||||||
+ Allocator<Self, DimMinimum<R, C>>
|
|
||||||
+ Allocator<Self, C, C>,
|
|
||||||
{
|
{
|
||||||
/// Computes the SVD decomposition of `m`.
|
/// Computes the SVD decomposition of `m`.
|
||||||
fn compute(m: OMatrix<Self, R, C>) -> Option<SVD<Self, R, C>>;
|
fn compute(m: OMatrix<Self, R, C>) -> Option<SVD<Self, R, C>>;
|
||||||
|
@ -67,10 +65,8 @@ where
|
||||||
|
|
||||||
impl<T: SVDScalar<R, C>, R: DimMin<C>, C: Dim> SVD<T, R, C>
|
impl<T: SVDScalar<R, C>, R: DimMin<C>, C: Dim> SVD<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, R>
|
DefaultAllocator:
|
||||||
+ Allocator<T, R, C>
|
Allocator<R, R> + Allocator<R, C> + Allocator<DimMinimum<R, C>> + Allocator<C, C>,
|
||||||
+ Allocator<T, DimMinimum<R, C>>
|
|
||||||
+ Allocator<T, C, C>,
|
|
||||||
{
|
{
|
||||||
/// Computes the Singular Value Decomposition of `matrix`.
|
/// Computes the Singular Value Decomposition of `matrix`.
|
||||||
pub fn new(m: OMatrix<T, R, C>) -> Option<Self> {
|
pub fn new(m: OMatrix<T, R, C>) -> Option<Self> {
|
||||||
|
@ -82,10 +78,10 @@ macro_rules! svd_impl(
|
||||||
($t: ty, $lapack_func: path) => (
|
($t: ty, $lapack_func: path) => (
|
||||||
impl<R: Dim, C: Dim> SVDScalar<R, C> for $t
|
impl<R: Dim, C: Dim> SVDScalar<R, C> for $t
|
||||||
where R: DimMin<C>,
|
where R: DimMin<C>,
|
||||||
DefaultAllocator: Allocator<$t, R, C> +
|
DefaultAllocator: Allocator<R, C> +
|
||||||
Allocator<$t, R, R> +
|
Allocator<R, R> +
|
||||||
Allocator<$t, C, C> +
|
Allocator<C, C> +
|
||||||
Allocator<$t, DimMinimum<R, C>> {
|
Allocator<DimMinimum<R, C>> {
|
||||||
|
|
||||||
fn compute(mut m: OMatrix<$t, R, C>) -> Option<SVD<$t, R, C>> {
|
fn compute(mut m: OMatrix<$t, R, C>) -> Option<SVD<$t, R, C>> {
|
||||||
let (nrows, ncols) = m.shape_generic();
|
let (nrows, ncols) = m.shape_generic();
|
||||||
|
@ -134,16 +130,16 @@ macro_rules! svd_impl(
|
||||||
|
|
||||||
impl<R: DimMin<C>, C: Dim> SVD<$t, R, C>
|
impl<R: DimMin<C>, C: Dim> SVD<$t, R, C>
|
||||||
// TODO: All those bounds…
|
// TODO: All those bounds…
|
||||||
where DefaultAllocator: Allocator<$t, R, C> +
|
where DefaultAllocator: Allocator<R, C> +
|
||||||
Allocator<$t, C, R> +
|
Allocator<C, R> +
|
||||||
Allocator<$t, U1, R> +
|
Allocator<U1, R> +
|
||||||
Allocator<$t, U1, C> +
|
Allocator<U1, C> +
|
||||||
Allocator<$t, R, R> +
|
Allocator<R, R> +
|
||||||
Allocator<$t, DimMinimum<R, C>> +
|
Allocator<DimMinimum<R, C>> +
|
||||||
Allocator<$t, DimMinimum<R, C>, R> +
|
Allocator<DimMinimum<R, C>, R> +
|
||||||
Allocator<$t, DimMinimum<R, C>, C> +
|
Allocator<DimMinimum<R, C>, C> +
|
||||||
Allocator<$t, R, DimMinimum<R, C>> +
|
Allocator<R, DimMinimum<R, C>> +
|
||||||
Allocator<$t, C, C> {
|
Allocator<C, C> {
|
||||||
/// Reconstructs the matrix from its decomposition.
|
/// Reconstructs the matrix from its decomposition.
|
||||||
///
|
///
|
||||||
/// Useful if some components (e.g. some singular values) of this decomposition have
|
/// Useful if some components (e.g. some singular values) of this decomposition have
|
||||||
|
@ -237,9 +233,9 @@ macro_rules! svd_complex_impl(
|
||||||
where R: DimMin<C>,
|
where R: DimMin<C>,
|
||||||
S: ContiguousStorage<Complex<$t>, R, C>,
|
S: ContiguousStorage<Complex<$t>, R, C>,
|
||||||
S::Alloc: OwnedAllocator<Complex<$t>, R, C, S> +
|
S::Alloc: OwnedAllocator<Complex<$t>, R, C, S> +
|
||||||
Allocator<Complex<$t>, R, R> +
|
Allocator<R, R> +
|
||||||
Allocator<Complex<$t>, C, C> +
|
Allocator<C, C> +
|
||||||
Allocator<$t, DimMinimum<R, C>> {
|
Allocator<DimMinimum<R, C>> {
|
||||||
let (nrows, ncols) = m.shape_generic();
|
let (nrows, ncols) = m.shape_generic();
|
||||||
|
|
||||||
if nrows.value() == 0 || ncols.value() == 0 {
|
if nrows.value() == 0 || ncols.value() == 0 {
|
||||||
|
|
|
@ -17,22 +17,22 @@ use lapack;
|
||||||
#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
|
#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize",
|
feature = "serde-serialize",
|
||||||
serde(bound(serialize = "DefaultAllocator: Allocator<T, D, D> +
|
serde(bound(serialize = "DefaultAllocator: Allocator<D, D> +
|
||||||
Allocator<T, D>,
|
Allocator<D>,
|
||||||
OVector<T, D>: Serialize,
|
OVector<T, D>: Serialize,
|
||||||
OMatrix<T, D, D>: Serialize"))
|
OMatrix<T, D, D>: Serialize"))
|
||||||
)]
|
)]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize",
|
feature = "serde-serialize",
|
||||||
serde(bound(deserialize = "DefaultAllocator: Allocator<T, D, D> +
|
serde(bound(deserialize = "DefaultAllocator: Allocator<D, D> +
|
||||||
Allocator<T, D>,
|
Allocator<D>,
|
||||||
OVector<T, D>: Deserialize<'de>,
|
OVector<T, D>: Deserialize<'de>,
|
||||||
OMatrix<T, D, D>: Deserialize<'de>"))
|
OMatrix<T, D, D>: Deserialize<'de>"))
|
||||||
)]
|
)]
|
||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
pub struct SymmetricEigen<T: Scalar, D: Dim>
|
pub struct SymmetricEigen<T: Scalar, D: Dim>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D> + Allocator<D, D>,
|
||||||
{
|
{
|
||||||
/// The eigenvectors of the decomposed matrix.
|
/// The eigenvectors of the decomposed matrix.
|
||||||
pub eigenvectors: OMatrix<T, D, D>,
|
pub eigenvectors: OMatrix<T, D, D>,
|
||||||
|
@ -43,7 +43,7 @@ where
|
||||||
|
|
||||||
impl<T: Scalar + Copy, D: Dim> Copy for SymmetricEigen<T, D>
|
impl<T: Scalar + Copy, D: Dim> Copy for SymmetricEigen<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
|
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
OMatrix<T, D, D>: Copy,
|
OMatrix<T, D, D>: Copy,
|
||||||
OVector<T, D>: Copy,
|
OVector<T, D>: Copy,
|
||||||
{
|
{
|
||||||
|
@ -51,7 +51,7 @@ where
|
||||||
|
|
||||||
impl<T: SymmetricEigenScalar + RealField, D: Dim> SymmetricEigen<T, D>
|
impl<T: SymmetricEigenScalar + RealField, D: Dim> SymmetricEigen<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
|
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
{
|
{
|
||||||
/// Computes the eigenvalues and eigenvectors of the symmetric matrix `m`.
|
/// Computes the eigenvalues and eigenvectors of the symmetric matrix `m`.
|
||||||
///
|
///
|
||||||
|
|
|
@ -302,13 +302,13 @@ macro_rules! impl_spmm_cs_dense {
|
||||||
R: Dim,
|
R: Dim,
|
||||||
C: Dim,
|
C: Dim,
|
||||||
S: RawStorage<T, R, C>,
|
S: RawStorage<T, R, C>,
|
||||||
DefaultAllocator: Allocator<T, Dyn, C>,
|
DefaultAllocator: Allocator<Dyn, C>,
|
||||||
// TODO: Is it possible to simplify these bounds?
|
// TODO: Is it possible to simplify these bounds?
|
||||||
ShapeConstraint:
|
ShapeConstraint:
|
||||||
// Bounds so that we can turn OMatrix<T, Dyn, C> into a DMatrixSliceMut
|
// Bounds so that we can turn OMatrix<T, Dyn, C> into a DMatrixSliceMut
|
||||||
DimEq<U1, <<DefaultAllocator as Allocator<T, Dyn, C>>::Buffer as RawStorage<T, Dyn, C>>::RStride>
|
DimEq<U1, <<DefaultAllocator as Allocator<Dyn, C>>::Buffer<T> as RawStorage<T, Dyn, C>>::RStride>
|
||||||
+ DimEq<C, Dyn>
|
+ DimEq<C, Dyn>
|
||||||
+ DimEq<Dyn, <<DefaultAllocator as Allocator<T, Dyn, C>>::Buffer as RawStorage<T, Dyn, C>>::CStride>
|
+ DimEq<Dyn, <<DefaultAllocator as Allocator<Dyn, C>>::Buffer<T> as RawStorage<T, Dyn, C>>::CStride>
|
||||||
// Bounds so that we can turn &Matrix<T, R, C, S> into a DMatrixSlice
|
// Bounds so that we can turn &Matrix<T, R, C, S> into a DMatrixSlice
|
||||||
+ DimEq<U1, S::RStride>
|
+ DimEq<U1, S::RStride>
|
||||||
+ DimEq<R, Dyn>
|
+ DimEq<R, Dyn>
|
||||||
|
|
|
@ -19,36 +19,36 @@ use std::mem::MaybeUninit;
|
||||||
///
|
///
|
||||||
/// Every allocator must be both static and dynamic. Though not all implementations may share the
|
/// Every allocator must be both static and dynamic. Though not all implementations may share the
|
||||||
/// same `Buffer` type.
|
/// same `Buffer` type.
|
||||||
pub trait Allocator<T, R: Dim, C: Dim = U1>: Any + Sized {
|
pub trait Allocator<R: Dim, C: Dim = U1>: Any + Sized {
|
||||||
/// The type of buffer this allocator can instantiate.
|
/// The type of buffer this allocator can instantiate.
|
||||||
type Buffer: StorageMut<T, R, C> + IsContiguous + Clone + Debug;
|
type Buffer<T: Scalar>: StorageMut<T, R, C> + IsContiguous + Clone + Debug;
|
||||||
/// The type of buffer with uninitialized components this allocator can instantiate.
|
/// The type of buffer with uninitialized components this allocator can instantiate.
|
||||||
type BufferUninit: RawStorageMut<MaybeUninit<T>, R, C> + IsContiguous;
|
type BufferUninit<T: Scalar>: RawStorageMut<MaybeUninit<T>, R, C> + IsContiguous;
|
||||||
|
|
||||||
/// Allocates a buffer with the given number of rows and columns without initializing its content.
|
/// Allocates a buffer with the given number of rows and columns without initializing its content.
|
||||||
fn allocate_uninit(nrows: R, ncols: C) -> Self::BufferUninit;
|
fn allocate_uninit<T: Scalar>(nrows: R, ncols: C) -> Self::BufferUninit<T>;
|
||||||
|
|
||||||
/// Assumes a data buffer to be initialized.
|
/// Assumes a data buffer to be initialized.
|
||||||
///
|
///
|
||||||
/// # Safety
|
/// # Safety
|
||||||
/// The user must make sure that every single entry of the buffer has been initialized,
|
/// The user must make sure that every single entry of the buffer has been initialized,
|
||||||
/// or Undefined Behavior will immediately occur.
|
/// or Undefined Behavior will immediately occur.
|
||||||
unsafe fn assume_init(uninit: Self::BufferUninit) -> Self::Buffer;
|
unsafe fn assume_init<T: Scalar>(uninit: Self::BufferUninit<T>) -> Self::Buffer<T>;
|
||||||
|
|
||||||
/// Allocates a buffer initialized with the content of the given iterator.
|
/// Allocates a buffer initialized with the content of the given iterator.
|
||||||
fn allocate_from_iterator<I: IntoIterator<Item = T>>(
|
fn allocate_from_iterator<T: Scalar, I: IntoIterator<Item = T>>(
|
||||||
nrows: R,
|
nrows: R,
|
||||||
ncols: C,
|
ncols: C,
|
||||||
iter: I,
|
iter: I,
|
||||||
) -> Self::Buffer;
|
) -> Self::Buffer<T>;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
/// Allocates a buffer initialized with the content of the given row-major order iterator.
|
/// Allocates a buffer initialized with the content of the given row-major order iterator.
|
||||||
fn allocate_from_row_iterator<I: IntoIterator<Item = T>>(
|
fn allocate_from_row_iterator<T: Scalar, I: IntoIterator<Item = T>>(
|
||||||
nrows: R,
|
nrows: R,
|
||||||
ncols: C,
|
ncols: C,
|
||||||
iter: I,
|
iter: I,
|
||||||
) -> Self::Buffer {
|
) -> Self::Buffer<T> {
|
||||||
let mut res = Self::allocate_uninit(nrows, ncols);
|
let mut res = Self::allocate_uninit(nrows, ncols);
|
||||||
let mut count = 0;
|
let mut count = 0;
|
||||||
|
|
||||||
|
@ -73,7 +73,7 @@ pub trait Allocator<T, R: Dim, C: Dim = U1>: Any + Sized {
|
||||||
"Matrix init. from row iterator: iterator not long enough."
|
"Matrix init. from row iterator: iterator not long enough."
|
||||||
);
|
);
|
||||||
|
|
||||||
<Self as Allocator<T, R, C>>::assume_init(res)
|
<Self as Allocator<R, C>>::assume_init(res)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -81,7 +81,7 @@ pub trait Allocator<T, R: Dim, C: Dim = U1>: Any + Sized {
|
||||||
/// 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: Scalar, RFrom: Dim, CFrom: Dim, RTo: Dim, CTo: Dim>:
|
pub trait Reallocator<T: Scalar, RFrom: Dim, CFrom: Dim, RTo: Dim, CTo: Dim>:
|
||||||
Allocator<T, RFrom, CFrom> + Allocator<T, RTo, CTo>
|
Allocator<RFrom, CFrom> + Allocator<RTo, CTo>
|
||||||
{
|
{
|
||||||
/// Reallocates a buffer of shape `(RTo, CTo)`, possibly reusing a previously allocated buffer
|
/// Reallocates a buffer of shape `(RTo, CTo)`, possibly reusing a previously allocated buffer
|
||||||
/// `buf`. Data stored by `buf` are linearly copied to the output:
|
/// `buf`. Data stored by `buf` are linearly copied to the output:
|
||||||
|
@ -94,8 +94,8 @@ pub trait Reallocator<T: Scalar, RFrom: Dim, CFrom: Dim, RTo: Dim, CTo: Dim>:
|
||||||
unsafe fn reallocate_copy(
|
unsafe fn reallocate_copy(
|
||||||
nrows: RTo,
|
nrows: RTo,
|
||||||
ncols: CTo,
|
ncols: CTo,
|
||||||
buf: <Self as Allocator<T, RFrom, CFrom>>::Buffer,
|
buf: <Self as Allocator<RFrom, CFrom>>::Buffer<T>,
|
||||||
) -> <Self as Allocator<T, RTo, CTo>>::BufferUninit;
|
) -> <Self as Allocator<RTo, CTo>>::BufferUninit<T>;
|
||||||
}
|
}
|
||||||
|
|
||||||
/// The number of rows of the result of a componentwise operation on two matrices.
|
/// The number of rows of the result of a componentwise operation on two matrices.
|
||||||
|
@ -106,8 +106,8 @@ pub type SameShapeC<C1, C2> = <ShapeConstraint as SameNumberOfColumns<C1, C2>>::
|
||||||
|
|
||||||
// TODO: Bad name.
|
// TODO: Bad name.
|
||||||
/// Restricts the given number of rows and columns to be respectively the same.
|
/// Restricts the given number of rows and columns to be respectively the same.
|
||||||
pub trait SameShapeAllocator<T, R1, C1, R2, C2>:
|
pub trait SameShapeAllocator<R1, C1, R2, C2>:
|
||||||
Allocator<T, R1, C1> + Allocator<T, SameShapeR<R1, R2>, SameShapeC<C1, C2>>
|
Allocator<R1, C1> + Allocator<SameShapeR<R1, R2>, SameShapeC<C1, C2>>
|
||||||
where
|
where
|
||||||
R1: Dim,
|
R1: Dim,
|
||||||
R2: Dim,
|
R2: Dim,
|
||||||
|
@ -117,21 +117,21 @@ where
|
||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T, R1, R2, C1, C2> SameShapeAllocator<T, R1, C1, R2, C2> for DefaultAllocator
|
impl<R1, R2, C1, C2> SameShapeAllocator<R1, C1, R2, C2> for DefaultAllocator
|
||||||
where
|
where
|
||||||
R1: Dim,
|
R1: Dim,
|
||||||
R2: Dim,
|
R2: Dim,
|
||||||
C1: Dim,
|
C1: Dim,
|
||||||
C2: Dim,
|
C2: Dim,
|
||||||
DefaultAllocator: Allocator<T, R1, C1> + Allocator<T, SameShapeR<R1, R2>, SameShapeC<C1, C2>>,
|
DefaultAllocator: Allocator<R1, C1> + Allocator<SameShapeR<R1, R2>, SameShapeC<C1, C2>>,
|
||||||
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
|
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
|
||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
|
||||||
// XXX: Bad name.
|
// XXX: Bad name.
|
||||||
/// Restricts the given number of rows to be equal.
|
/// Restricts the given number of rows to be equal.
|
||||||
pub trait SameShapeVectorAllocator<T, R1, R2>:
|
pub trait SameShapeVectorAllocator<R1, R2>:
|
||||||
Allocator<T, R1> + Allocator<T, SameShapeR<R1, R2>> + SameShapeAllocator<T, R1, U1, R2, U1>
|
Allocator<R1> + Allocator<SameShapeR<R1, R2>> + SameShapeAllocator<R1, U1, R2, U1>
|
||||||
where
|
where
|
||||||
R1: Dim,
|
R1: Dim,
|
||||||
R2: Dim,
|
R2: Dim,
|
||||||
|
@ -139,11 +139,11 @@ where
|
||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T, R1, R2> SameShapeVectorAllocator<T, R1, R2> for DefaultAllocator
|
impl<R1, R2> SameShapeVectorAllocator<R1, R2> for DefaultAllocator
|
||||||
where
|
where
|
||||||
R1: Dim,
|
R1: Dim,
|
||||||
R2: Dim,
|
R2: Dim,
|
||||||
DefaultAllocator: Allocator<T, R1, U1> + Allocator<T, SameShapeR<R1, R2>>,
|
DefaultAllocator: Allocator<R1, U1> + Allocator<SameShapeR<R1, R2>>,
|
||||||
ShapeConstraint: SameNumberOfRows<R1, R2>,
|
ShapeConstraint: SameNumberOfRows<R1, R2>,
|
||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
|
|
@ -113,12 +113,12 @@ unsafe impl<T, const R: usize, const C: usize> RawStorage<T, Const<R>, Const<C>>
|
||||||
unsafe impl<T: Scalar, const R: usize, const C: usize> Storage<T, Const<R>, Const<C>>
|
unsafe impl<T: Scalar, const R: usize, const C: usize> Storage<T, Const<R>, Const<C>>
|
||||||
for ArrayStorage<T, R, C>
|
for ArrayStorage<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, Const<R>, Const<C>, Buffer = Self>,
|
DefaultAllocator: Allocator<Const<R>, Const<C>, Buffer<T> = Self>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn into_owned(self) -> Owned<T, Const<R>, Const<C>>
|
fn into_owned(self) -> Owned<T, Const<R>, Const<C>>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, Const<R>, Const<C>>,
|
DefaultAllocator: Allocator<Const<R>, Const<C>>,
|
||||||
{
|
{
|
||||||
self
|
self
|
||||||
}
|
}
|
||||||
|
@ -126,7 +126,7 @@ where
|
||||||
#[inline]
|
#[inline]
|
||||||
fn clone_owned(&self) -> Owned<T, Const<R>, Const<C>>
|
fn clone_owned(&self) -> Owned<T, Const<R>, Const<C>>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, Const<R>, Const<C>>,
|
DefaultAllocator: Allocator<Const<R>, Const<C>>,
|
||||||
{
|
{
|
||||||
self.clone()
|
self.clone()
|
||||||
}
|
}
|
||||||
|
@ -250,7 +250,7 @@ where
|
||||||
V: SeqAccess<'a>,
|
V: SeqAccess<'a>,
|
||||||
{
|
{
|
||||||
let mut out: ArrayStorage<core::mem::MaybeUninit<T>, R, C> =
|
let mut out: ArrayStorage<core::mem::MaybeUninit<T>, R, C> =
|
||||||
DefaultAllocator::allocate_uninit(Const::<R>, Const::<C>);
|
<DefaultAllocator as Allocator<_, _>>::allocate_uninit(Const::<R>, Const::<C>);
|
||||||
let mut curr = 0;
|
let mut curr = 0;
|
||||||
|
|
||||||
while let Some(value) = visitor.next_element()? {
|
while let Some(value) = visitor.next_element()? {
|
||||||
|
@ -263,7 +263,7 @@ where
|
||||||
|
|
||||||
if curr == R * C {
|
if curr == R * C {
|
||||||
// Safety: all the elements have been initialized.
|
// Safety: all the elements have been initialized.
|
||||||
unsafe { Ok(<DefaultAllocator as Allocator<T, Const<R>, Const<C>>>::assume_init(out)) }
|
unsafe { Ok(<DefaultAllocator as Allocator<Const<R>, Const<C>>>::assume_init(out)) }
|
||||||
} else {
|
} else {
|
||||||
for i in 0..curr {
|
for i in 0..curr {
|
||||||
// Safety:
|
// Safety:
|
||||||
|
|
|
@ -1098,7 +1098,7 @@ where
|
||||||
S3: Storage<T, R3, C3>,
|
S3: Storage<T, R3, C3>,
|
||||||
S4: Storage<T, D4, D4>,
|
S4: Storage<T, D4, D4>,
|
||||||
ShapeConstraint: DimEq<D1, D1> + DimEq<D1, R3> + DimEq<C3, D4>,
|
ShapeConstraint: DimEq<D1, D1> + DimEq<D1, R3> + DimEq<C3, D4>,
|
||||||
DefaultAllocator: Allocator<T, D1>,
|
DefaultAllocator: Allocator<D1>,
|
||||||
{
|
{
|
||||||
// TODO: would it be useful to avoid the zero-initialization of the workspace data?
|
// TODO: would it be useful to avoid the zero-initialization of the workspace data?
|
||||||
let mut work = Matrix::zeros_generic(self.shape_generic().0, Const::<1>);
|
let mut work = Matrix::zeros_generic(self.shape_generic().0, Const::<1>);
|
||||||
|
@ -1196,7 +1196,7 @@ where
|
||||||
S2: Storage<T, D2, D2>,
|
S2: Storage<T, D2, D2>,
|
||||||
S3: Storage<T, R3, C3>,
|
S3: Storage<T, R3, C3>,
|
||||||
ShapeConstraint: DimEq<D2, R3> + DimEq<D1, C3> + AreMultipliable<C3, R3, D2, U1>,
|
ShapeConstraint: DimEq<D2, R3> + DimEq<D1, C3> + AreMultipliable<C3, R3, D2, U1>,
|
||||||
DefaultAllocator: Allocator<T, D2>,
|
DefaultAllocator: Allocator<D2>,
|
||||||
{
|
{
|
||||||
// TODO: would it be useful to avoid the zero-initialization of the workspace data?
|
// TODO: would it be useful to avoid the zero-initialization of the workspace data?
|
||||||
let mut work = Vector::zeros_generic(mid.shape_generic().0, Const::<1>);
|
let mut work = Vector::zeros_generic(mid.shape_generic().0, Const::<1>);
|
||||||
|
|
|
@ -25,7 +25,7 @@ use simba::scalar::{ClosedAdd, ClosedMul, RealField};
|
||||||
impl<T, D: DimName> OMatrix<T, D, D>
|
impl<T, D: DimName> OMatrix<T, D, D>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + One,
|
T: Scalar + Zero + One,
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
/// Creates a new homogeneous matrix that applies the same scaling factor on each dimension.
|
/// Creates a new homogeneous matrix that applies the same scaling factor on each dimension.
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -216,7 +216,7 @@ impl<T: Scalar + Zero + One + ClosedMul + ClosedAdd, D: DimName, S: Storage<T, D
|
||||||
pub fn append_scaling(&self, scaling: T) -> OMatrix<T, D, D>
|
pub fn append_scaling(&self, scaling: T) -> OMatrix<T, D, D>
|
||||||
where
|
where
|
||||||
D: DimNameSub<U1>,
|
D: DimNameSub<U1>,
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
let mut res = self.clone_owned();
|
let mut res = self.clone_owned();
|
||||||
res.append_scaling_mut(scaling);
|
res.append_scaling_mut(scaling);
|
||||||
|
@ -229,7 +229,7 @@ impl<T: Scalar + Zero + One + ClosedMul + ClosedAdd, D: DimName, S: Storage<T, D
|
||||||
pub fn prepend_scaling(&self, scaling: T) -> OMatrix<T, D, D>
|
pub fn prepend_scaling(&self, scaling: T) -> OMatrix<T, D, D>
|
||||||
where
|
where
|
||||||
D: DimNameSub<U1>,
|
D: DimNameSub<U1>,
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
let mut res = self.clone_owned();
|
let mut res = self.clone_owned();
|
||||||
res.prepend_scaling_mut(scaling);
|
res.prepend_scaling_mut(scaling);
|
||||||
|
@ -246,7 +246,7 @@ impl<T: Scalar + Zero + One + ClosedMul + ClosedAdd, D: DimName, S: Storage<T, D
|
||||||
where
|
where
|
||||||
D: DimNameSub<U1>,
|
D: DimNameSub<U1>,
|
||||||
SB: Storage<T, DimNameDiff<D, U1>>,
|
SB: Storage<T, DimNameDiff<D, U1>>,
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
let mut res = self.clone_owned();
|
let mut res = self.clone_owned();
|
||||||
res.append_nonuniform_scaling_mut(scaling);
|
res.append_nonuniform_scaling_mut(scaling);
|
||||||
|
@ -263,7 +263,7 @@ impl<T: Scalar + Zero + One + ClosedMul + ClosedAdd, D: DimName, S: Storage<T, D
|
||||||
where
|
where
|
||||||
D: DimNameSub<U1>,
|
D: DimNameSub<U1>,
|
||||||
SB: Storage<T, DimNameDiff<D, U1>>,
|
SB: Storage<T, DimNameDiff<D, U1>>,
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
let mut res = self.clone_owned();
|
let mut res = self.clone_owned();
|
||||||
res.prepend_nonuniform_scaling_mut(scaling);
|
res.prepend_nonuniform_scaling_mut(scaling);
|
||||||
|
@ -280,7 +280,7 @@ impl<T: Scalar + Zero + One + ClosedMul + ClosedAdd, D: DimName, S: Storage<T, D
|
||||||
where
|
where
|
||||||
D: DimNameSub<U1>,
|
D: DimNameSub<U1>,
|
||||||
SB: Storage<T, DimNameDiff<D, U1>>,
|
SB: Storage<T, DimNameDiff<D, U1>>,
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
let mut res = self.clone_owned();
|
let mut res = self.clone_owned();
|
||||||
res.append_translation_mut(shift);
|
res.append_translation_mut(shift);
|
||||||
|
@ -297,7 +297,7 @@ impl<T: Scalar + Zero + One + ClosedMul + ClosedAdd, D: DimName, S: Storage<T, D
|
||||||
where
|
where
|
||||||
D: DimNameSub<U1>,
|
D: DimNameSub<U1>,
|
||||||
SB: Storage<T, DimNameDiff<D, U1>>,
|
SB: Storage<T, DimNameDiff<D, U1>>,
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimNameDiff<D, U1>>,
|
DefaultAllocator: Allocator<D, D> + Allocator<DimNameDiff<D, U1>>,
|
||||||
{
|
{
|
||||||
let mut res = self.clone_owned();
|
let mut res = self.clone_owned();
|
||||||
res.prepend_translation_mut(shift);
|
res.prepend_translation_mut(shift);
|
||||||
|
@ -379,7 +379,7 @@ impl<T: Scalar + Zero + One + ClosedMul + ClosedAdd, D: DimName, S: Storage<T, D
|
||||||
D: DimNameSub<U1>,
|
D: DimNameSub<U1>,
|
||||||
S: StorageMut<T, D, D>,
|
S: StorageMut<T, D, D>,
|
||||||
SB: Storage<T, DimNameDiff<D, U1>>,
|
SB: Storage<T, DimNameDiff<D, U1>>,
|
||||||
DefaultAllocator: Allocator<T, DimNameDiff<D, U1>>,
|
DefaultAllocator: Allocator<DimNameDiff<D, U1>>,
|
||||||
{
|
{
|
||||||
let scale = self
|
let scale = self
|
||||||
.generic_view(
|
.generic_view(
|
||||||
|
@ -405,9 +405,9 @@ impl<T: Scalar + Zero + One + ClosedMul + ClosedAdd, D: DimName, S: Storage<T, D
|
||||||
/// # Transformation of vectors and points
|
/// # Transformation of vectors and points
|
||||||
impl<T: RealField, D: DimNameSub<U1>, S: Storage<T, D, D>> SquareMatrix<T, D, S>
|
impl<T: RealField, D: DimNameSub<U1>, S: Storage<T, D, D>> SquareMatrix<T, D, S>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D>
|
DefaultAllocator: Allocator<D, D>
|
||||||
+ Allocator<T, DimNameDiff<D, U1>>
|
+ Allocator<DimNameDiff<D, U1>>
|
||||||
+ Allocator<T, DimNameDiff<D, U1>, DimNameDiff<D, U1>>,
|
+ Allocator<DimNameDiff<D, U1>, DimNameDiff<D, U1>>,
|
||||||
{
|
{
|
||||||
/// Transforms the given vector, assuming the matrix `self` uses homogeneous coordinates.
|
/// Transforms the given vector, assuming the matrix `self` uses homogeneous coordinates.
|
||||||
#[inline]
|
#[inline]
|
||||||
|
|
|
@ -32,7 +32,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
pub fn abs(&self) -> OMatrix<T, R, C>
|
pub fn abs(&self) -> OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
T: Signed,
|
T: Signed,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
let mut res = self.clone_owned();
|
let mut res = self.clone_owned();
|
||||||
|
|
||||||
|
@ -55,7 +55,7 @@ macro_rules! component_binop_impl(
|
||||||
where T: $Trait,
|
where T: $Trait,
|
||||||
R2: Dim, C2: Dim,
|
R2: Dim, C2: Dim,
|
||||||
SB: Storage<T, R2, C2>,
|
SB: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: SameShapeAllocator<T, R1, C1, R2, C2>,
|
DefaultAllocator: SameShapeAllocator<R1, C1, R2, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> {
|
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> {
|
||||||
|
|
||||||
assert_eq!(self.shape(), rhs.shape(), "Componentwise mul/div: mismatched matrix dimensions.");
|
assert_eq!(self.shape(), rhs.shape(), "Componentwise mul/div: mismatched matrix dimensions.");
|
||||||
|
@ -257,7 +257,7 @@ impl<T: Scalar, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>> Matrix<T, R1, C1, SA>
|
||||||
pub fn inf(&self, other: &Self) -> OMatrix<T, R1, C1>
|
pub fn inf(&self, other: &Self) -> OMatrix<T, R1, C1>
|
||||||
where
|
where
|
||||||
T: SimdPartialOrd,
|
T: SimdPartialOrd,
|
||||||
DefaultAllocator: Allocator<T, R1, C1>,
|
DefaultAllocator: Allocator<R1, C1>,
|
||||||
{
|
{
|
||||||
self.zip_map(other, |a, b| a.simd_min(b))
|
self.zip_map(other, |a, b| a.simd_min(b))
|
||||||
}
|
}
|
||||||
|
@ -278,7 +278,7 @@ impl<T: Scalar, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>> Matrix<T, R1, C1, SA>
|
||||||
pub fn sup(&self, other: &Self) -> OMatrix<T, R1, C1>
|
pub fn sup(&self, other: &Self) -> OMatrix<T, R1, C1>
|
||||||
where
|
where
|
||||||
T: SimdPartialOrd,
|
T: SimdPartialOrd,
|
||||||
DefaultAllocator: Allocator<T, R1, C1>,
|
DefaultAllocator: Allocator<R1, C1>,
|
||||||
{
|
{
|
||||||
self.zip_map(other, |a, b| a.simd_max(b))
|
self.zip_map(other, |a, b| a.simd_max(b))
|
||||||
}
|
}
|
||||||
|
@ -299,7 +299,7 @@ impl<T: Scalar, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>> Matrix<T, R1, C1, SA>
|
||||||
pub fn inf_sup(&self, other: &Self) -> (OMatrix<T, R1, C1>, OMatrix<T, R1, C1>)
|
pub fn inf_sup(&self, other: &Self) -> (OMatrix<T, R1, C1>, OMatrix<T, R1, C1>)
|
||||||
where
|
where
|
||||||
T: SimdPartialOrd,
|
T: SimdPartialOrd,
|
||||||
DefaultAllocator: Allocator<T, R1, C1>,
|
DefaultAllocator: Allocator<R1, C1>,
|
||||||
{
|
{
|
||||||
// TODO: can this be optimized?
|
// TODO: can this be optimized?
|
||||||
(self.inf(other), self.sup(other))
|
(self.inf(other), self.sup(other))
|
||||||
|
@ -321,7 +321,7 @@ impl<T: Scalar, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>> Matrix<T, R1, C1, SA>
|
||||||
pub fn add_scalar(&self, rhs: T) -> OMatrix<T, R1, C1>
|
pub fn add_scalar(&self, rhs: T) -> OMatrix<T, R1, C1>
|
||||||
where
|
where
|
||||||
T: ClosedAdd,
|
T: ClosedAdd,
|
||||||
DefaultAllocator: Allocator<T, R1, C1>,
|
DefaultAllocator: Allocator<R1, C1>,
|
||||||
{
|
{
|
||||||
let mut res = self.clone_owned();
|
let mut res = self.clone_owned();
|
||||||
res.add_scalar_mut(rhs);
|
res.add_scalar_mut(rhs);
|
||||||
|
|
|
@ -29,7 +29,7 @@ use std::mem::MaybeUninit;
|
||||||
|
|
||||||
impl<T: Scalar, R: Dim, C: Dim> UninitMatrix<T, R, C>
|
impl<T: Scalar, R: Dim, C: Dim> UninitMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
/// Builds a matrix with uninitialized elements of type `MaybeUninit<T>`.
|
/// Builds a matrix with uninitialized elements of type `MaybeUninit<T>`.
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
|
@ -50,7 +50,7 @@ where
|
||||||
/// These functions should only be used when working on dimension-generic code.
|
/// These functions should only be used when working on dimension-generic code.
|
||||||
impl<T: Scalar, R: Dim, C: Dim> OMatrix<T, R, C>
|
impl<T: Scalar, R: Dim, C: Dim> OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
/// Creates a matrix with all its elements set to `elem`.
|
/// Creates a matrix with all its elements set to `elem`.
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -338,7 +338,7 @@ where
|
||||||
impl<T, D: Dim> OMatrix<T, D, D>
|
impl<T, D: Dim> OMatrix<T, D, D>
|
||||||
where
|
where
|
||||||
T: Scalar,
|
T: Scalar,
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
/// Creates a square matrix with its diagonal set to `diag` and all other entries set to 0.
|
/// Creates a square matrix with its diagonal set to `diag` and all other entries set to 0.
|
||||||
///
|
///
|
||||||
|
@ -646,7 +646,7 @@ macro_rules! impl_constructors(
|
||||||
/// # Constructors of statically-sized vectors or statically-sized matrices
|
/// # Constructors of statically-sized vectors or statically-sized matrices
|
||||||
impl<T: Scalar, R: DimName, C: DimName> OMatrix<T, R, C>
|
impl<T: Scalar, R: DimName, C: DimName> OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
// TODO: this is not very pretty. We could find a better call syntax.
|
// TODO: this is not very pretty. We could find a better call syntax.
|
||||||
impl_constructors!(R, C; // Arguments for Matrix<T, ..., S>
|
impl_constructors!(R, C; // Arguments for Matrix<T, ..., S>
|
||||||
|
@ -658,7 +658,7 @@ where
|
||||||
/// # Constructors of matrices with a dynamic number of columns
|
/// # Constructors of matrices with a dynamic number of columns
|
||||||
impl<T: Scalar, R: DimName> OMatrix<T, R, Dyn>
|
impl<T: Scalar, R: DimName> OMatrix<T, R, Dyn>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, Dyn>,
|
DefaultAllocator: Allocator<R, Dyn>,
|
||||||
{
|
{
|
||||||
impl_constructors!(R, Dyn;
|
impl_constructors!(R, Dyn;
|
||||||
=> R: DimName;
|
=> R: DimName;
|
||||||
|
@ -669,7 +669,7 @@ where
|
||||||
/// # Constructors of dynamic vectors and matrices with a dynamic number of rows
|
/// # Constructors of dynamic vectors and matrices with a dynamic number of rows
|
||||||
impl<T: Scalar, C: DimName> OMatrix<T, Dyn, C>
|
impl<T: Scalar, C: DimName> OMatrix<T, Dyn, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, Dyn, C>,
|
DefaultAllocator: Allocator<Dyn, C>,
|
||||||
{
|
{
|
||||||
impl_constructors!(Dyn, C;
|
impl_constructors!(Dyn, C;
|
||||||
=> C: DimName;
|
=> C: DimName;
|
||||||
|
@ -678,9 +678,10 @@ where
|
||||||
}
|
}
|
||||||
|
|
||||||
/// # Constructors of fully dynamic matrices
|
/// # Constructors of fully dynamic matrices
|
||||||
|
#[cfg(any(feature = "std", feature = "alloc"))]
|
||||||
impl<T: Scalar> OMatrix<T, Dyn, Dyn>
|
impl<T: Scalar> OMatrix<T, Dyn, Dyn>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, Dyn, Dyn>,
|
DefaultAllocator: Allocator<Dyn, Dyn>,
|
||||||
{
|
{
|
||||||
impl_constructors!(Dyn, Dyn;
|
impl_constructors!(Dyn, Dyn;
|
||||||
;
|
;
|
||||||
|
@ -697,7 +698,7 @@ where
|
||||||
macro_rules! impl_constructors_from_data(
|
macro_rules! impl_constructors_from_data(
|
||||||
($data: ident; $($Dims: ty),*; $(=> $DimIdent: ident: $DimBound: ident),*; $($gargs: expr),*; $($args: ident),*) => {
|
($data: ident; $($Dims: ty),*; $(=> $DimIdent: ident: $DimBound: ident),*; $($gargs: expr),*; $($args: ident),*) => {
|
||||||
impl<T: Scalar, $($DimIdent: $DimBound, )*> OMatrix<T $(, $Dims)*>
|
impl<T: Scalar, $($DimIdent: $DimBound, )*> OMatrix<T $(, $Dims)*>
|
||||||
where DefaultAllocator: Allocator<T $(, $Dims)*> {
|
where DefaultAllocator: Allocator<$($Dims),*> {
|
||||||
/// Creates a matrix with its elements filled with the components provided by a slice
|
/// Creates a matrix with its elements filled with the components provided by a slice
|
||||||
/// in row-major order.
|
/// in row-major order.
|
||||||
///
|
///
|
||||||
|
@ -800,6 +801,7 @@ impl_constructors_from_data!(data; Dyn, C;
|
||||||
Dyn(data.len() / C::dim()), C::name();
|
Dyn(data.len() / C::dim()), C::name();
|
||||||
);
|
);
|
||||||
|
|
||||||
|
#[cfg(any(feature = "std", feature = "alloc"))]
|
||||||
impl_constructors_from_data!(data; Dyn, Dyn;
|
impl_constructors_from_data!(data; Dyn, Dyn;
|
||||||
;
|
;
|
||||||
Dyn(nrows), Dyn(ncols);
|
Dyn(nrows), Dyn(ncols);
|
||||||
|
@ -813,7 +815,7 @@ impl_constructors_from_data!(data; Dyn, Dyn;
|
||||||
impl<T, R: DimName, C: DimName> Zero for OMatrix<T, R, C>
|
impl<T, R: DimName, C: DimName> Zero for OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + ClosedAdd,
|
T: Scalar + Zero + ClosedAdd,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn zero() -> Self {
|
fn zero() -> Self {
|
||||||
|
@ -829,7 +831,7 @@ where
|
||||||
impl<T, D: DimName> One for OMatrix<T, D, D>
|
impl<T, D: DimName> One for OMatrix<T, D, D>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + One + ClosedMul + ClosedAdd,
|
T: Scalar + Zero + One + ClosedMul + ClosedAdd,
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn one() -> Self {
|
fn one() -> Self {
|
||||||
|
@ -840,7 +842,7 @@ where
|
||||||
impl<T, R: DimName, C: DimName> Bounded for OMatrix<T, R, C>
|
impl<T, R: DimName, C: DimName> Bounded for OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
T: Scalar + Bounded,
|
T: Scalar + Bounded,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn max_value() -> Self {
|
fn max_value() -> Self {
|
||||||
|
@ -856,7 +858,7 @@ where
|
||||||
#[cfg(feature = "rand-no-std")]
|
#[cfg(feature = "rand-no-std")]
|
||||||
impl<T: Scalar, R: Dim, C: Dim> Distribution<OMatrix<T, R, C>> for Standard
|
impl<T: Scalar, R: Dim, C: Dim> Distribution<OMatrix<T, R, C>> for Standard
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
Standard: Distribution<T>,
|
Standard: Distribution<T>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -874,7 +876,7 @@ where
|
||||||
R: Dim,
|
R: Dim,
|
||||||
C: Dim,
|
C: Dim,
|
||||||
T: Scalar + Arbitrary + Send,
|
T: Scalar + Arbitrary + Send,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
Owned<T, R, C>: Clone + Send,
|
Owned<T, R, C>: Clone + Send,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -892,7 +894,7 @@ where
|
||||||
#[cfg(feature = "rand")]
|
#[cfg(feature = "rand")]
|
||||||
impl<T: crate::RealField, D: DimName> Distribution<Unit<OVector<T, D>>> for Standard
|
impl<T: crate::RealField, D: DimName> Distribution<Unit<OVector<T, D>>> for Standard
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
rand_distr::StandardNormal: Distribution<T>,
|
rand_distr::StandardNormal: Distribution<T>,
|
||||||
{
|
{
|
||||||
/// Generate a uniformly distributed random unit vector.
|
/// Generate a uniformly distributed random unit vector.
|
||||||
|
@ -1111,7 +1113,7 @@ impl<T, R: DimName> OVector<T, R>
|
||||||
where
|
where
|
||||||
R: ToTypenum,
|
R: ToTypenum,
|
||||||
T: Scalar + Zero + One,
|
T: Scalar + Zero + One,
|
||||||
DefaultAllocator: Allocator<T, R>,
|
DefaultAllocator: Allocator<R>,
|
||||||
{
|
{
|
||||||
/// The column vector with `val` as its i-th component.
|
/// The column vector with `val` as its i-th component.
|
||||||
#[inline]
|
#[inline]
|
||||||
|
|
|
@ -35,8 +35,7 @@ where
|
||||||
C2: Dim,
|
C2: Dim,
|
||||||
T1: Scalar,
|
T1: Scalar,
|
||||||
T2: Scalar + SupersetOf<T1>,
|
T2: Scalar + SupersetOf<T1>,
|
||||||
DefaultAllocator:
|
DefaultAllocator: Allocator<R2, C2> + Allocator<R1, C1> + SameShapeAllocator<R1, C1, R2, C2>,
|
||||||
Allocator<T2, R2, C2> + Allocator<T1, R1, C1> + SameShapeAllocator<T1, R1, C1, R2, C2>,
|
|
||||||
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
|
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -561,7 +560,7 @@ impl<T: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[OMatrix<T::Element, R
|
||||||
where
|
where
|
||||||
T: From<[<T as SimdValue>::Element; 2]>,
|
T: From<[<T as SimdValue>::Element; 2]>,
|
||||||
T::Element: Scalar + SimdValue,
|
T::Element: Scalar + SimdValue,
|
||||||
DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn from(arr: [OMatrix<T::Element, R, C>; 2]) -> Self {
|
fn from(arr: [OMatrix<T::Element, R, C>; 2]) -> Self {
|
||||||
|
@ -578,7 +577,7 @@ impl<T: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[OMatrix<T::Element, R
|
||||||
where
|
where
|
||||||
T: From<[<T as SimdValue>::Element; 4]>,
|
T: From<[<T as SimdValue>::Element; 4]>,
|
||||||
T::Element: Scalar + SimdValue,
|
T::Element: Scalar + SimdValue,
|
||||||
DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn from(arr: [OMatrix<T::Element, R, C>; 4]) -> Self {
|
fn from(arr: [OMatrix<T::Element, R, C>; 4]) -> Self {
|
||||||
|
@ -601,7 +600,7 @@ impl<T: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[OMatrix<T::Element, R
|
||||||
where
|
where
|
||||||
T: From<[<T as SimdValue>::Element; 8]>,
|
T: From<[<T as SimdValue>::Element; 8]>,
|
||||||
T::Element: Scalar + SimdValue,
|
T::Element: Scalar + SimdValue,
|
||||||
DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn from(arr: [OMatrix<T::Element, R, C>; 8]) -> Self {
|
fn from(arr: [OMatrix<T::Element, R, C>; 8]) -> Self {
|
||||||
|
@ -628,7 +627,7 @@ impl<T: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[OMatrix<T::Element, R
|
||||||
where
|
where
|
||||||
T: From<[<T as SimdValue>::Element; 16]>,
|
T: From<[<T as SimdValue>::Element; 16]>,
|
||||||
T::Element: Scalar + SimdValue,
|
T::Element: Scalar + SimdValue,
|
||||||
DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
fn from(arr: [OMatrix<T::Element, R, C>; 16]) -> Self {
|
fn from(arr: [OMatrix<T::Element, R, C>; 16]) -> Self {
|
||||||
let (nrows, ncols) = arr[0].shape_generic();
|
let (nrows, ncols) = arr[0].shape_generic();
|
||||||
|
|
|
@ -34,21 +34,21 @@ use std::mem::MaybeUninit;
|
||||||
pub struct DefaultAllocator;
|
pub struct DefaultAllocator;
|
||||||
|
|
||||||
// Static - Static
|
// Static - Static
|
||||||
impl<T: Scalar, const R: usize, const C: usize> Allocator<T, Const<R>, Const<C>>
|
impl<const R: usize, const C: usize> Allocator<Const<R>, Const<C>> for DefaultAllocator {
|
||||||
for DefaultAllocator
|
type Buffer<T: Scalar> = ArrayStorage<T, R, C>;
|
||||||
{
|
type BufferUninit<T: Scalar> = ArrayStorage<MaybeUninit<T>, R, C>;
|
||||||
type Buffer = ArrayStorage<T, R, C>;
|
|
||||||
type BufferUninit = ArrayStorage<MaybeUninit<T>, R, C>;
|
|
||||||
|
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
fn allocate_uninit(_: Const<R>, _: Const<C>) -> ArrayStorage<MaybeUninit<T>, R, C> {
|
fn allocate_uninit<T: Scalar>(_: Const<R>, _: Const<C>) -> ArrayStorage<MaybeUninit<T>, R, C> {
|
||||||
// SAFETY: An uninitialized `[MaybeUninit<_>; _]` is valid.
|
// SAFETY: An uninitialized `[MaybeUninit<_>; _]` is valid.
|
||||||
let array: [[MaybeUninit<T>; R]; C] = unsafe { MaybeUninit::uninit().assume_init() };
|
let array: [[MaybeUninit<T>; R]; C] = unsafe { MaybeUninit::uninit().assume_init() };
|
||||||
ArrayStorage(array)
|
ArrayStorage(array)
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
unsafe fn assume_init(uninit: ArrayStorage<MaybeUninit<T>, R, C>) -> ArrayStorage<T, R, C> {
|
unsafe fn assume_init<T: Scalar>(
|
||||||
|
uninit: ArrayStorage<MaybeUninit<T>, R, C>,
|
||||||
|
) -> ArrayStorage<T, R, 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
|
||||||
|
@ -58,11 +58,11 @@ impl<T: Scalar, const R: usize, const C: usize> Allocator<T, Const<R>, Const<C>>
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn allocate_from_iterator<I: IntoIterator<Item = T>>(
|
fn allocate_from_iterator<T: Scalar, I: IntoIterator<Item = T>>(
|
||||||
nrows: Const<R>,
|
nrows: Const<R>,
|
||||||
ncols: Const<C>,
|
ncols: Const<C>,
|
||||||
iter: I,
|
iter: I,
|
||||||
) -> Self::Buffer {
|
) -> Self::Buffer<T> {
|
||||||
let mut res = Self::allocate_uninit(nrows, ncols);
|
let mut res = Self::allocate_uninit(nrows, ncols);
|
||||||
let mut count = 0;
|
let mut count = 0;
|
||||||
|
|
||||||
|
@ -80,19 +80,19 @@ impl<T: Scalar, const R: usize, const C: usize> Allocator<T, Const<R>, Const<C>>
|
||||||
|
|
||||||
// Safety: the assertion above made sure that the iterator
|
// Safety: the assertion above made sure that the iterator
|
||||||
// yielded enough elements to initialize our matrix.
|
// yielded enough elements to initialize our matrix.
|
||||||
unsafe { <Self as Allocator<T, Const<R>, Const<C>>>::assume_init(res) }
|
unsafe { <Self as Allocator<Const<R>, Const<C>>>::assume_init(res) }
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// Dyn - Static
|
// Dyn - Static
|
||||||
// Dyn - Dyn
|
// Dyn - Dyn
|
||||||
#[cfg(any(feature = "std", feature = "alloc"))]
|
#[cfg(any(feature = "std", feature = "alloc"))]
|
||||||
impl<T: Scalar, C: Dim> Allocator<T, Dyn, C> for DefaultAllocator {
|
impl<C: Dim> Allocator<Dyn, C> for DefaultAllocator {
|
||||||
type Buffer = VecStorage<T, Dyn, C>;
|
type Buffer<T: Scalar> = VecStorage<T, Dyn, C>;
|
||||||
type BufferUninit = VecStorage<MaybeUninit<T>, Dyn, C>;
|
type BufferUninit<T: Scalar> = VecStorage<MaybeUninit<T>, Dyn, C>;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn allocate_uninit(nrows: Dyn, ncols: C) -> VecStorage<MaybeUninit<T>, Dyn, C> {
|
fn allocate_uninit<T: Scalar>(nrows: Dyn, ncols: C) -> VecStorage<MaybeUninit<T>, Dyn, 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);
|
||||||
|
@ -101,7 +101,9 @@ impl<T: Scalar, C: Dim> Allocator<T, Dyn, C> for DefaultAllocator {
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn assume_init(uninit: VecStorage<MaybeUninit<T>, Dyn, C>) -> VecStorage<T, Dyn, C> {
|
unsafe fn assume_init<T: Scalar>(
|
||||||
|
uninit: VecStorage<MaybeUninit<T>, Dyn, C>,
|
||||||
|
) -> VecStorage<T, Dyn, 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();
|
||||||
|
@ -116,11 +118,11 @@ impl<T: Scalar, C: Dim> Allocator<T, Dyn, C> for DefaultAllocator {
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn allocate_from_iterator<I: IntoIterator<Item = T>>(
|
fn allocate_from_iterator<T: Scalar, I: IntoIterator<Item = T>>(
|
||||||
nrows: Dyn,
|
nrows: Dyn,
|
||||||
ncols: C,
|
ncols: C,
|
||||||
iter: I,
|
iter: I,
|
||||||
) -> Self::Buffer {
|
) -> Self::Buffer<T> {
|
||||||
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(),
|
||||||
|
@ -132,12 +134,12 @@ impl<T: Scalar, C: Dim> Allocator<T, Dyn, C> for DefaultAllocator {
|
||||||
|
|
||||||
// Static - Dyn
|
// Static - Dyn
|
||||||
#[cfg(any(feature = "std", feature = "alloc"))]
|
#[cfg(any(feature = "std", feature = "alloc"))]
|
||||||
impl<T: Scalar, R: DimName> Allocator<T, R, Dyn> for DefaultAllocator {
|
impl<R: DimName> Allocator<R, Dyn> for DefaultAllocator {
|
||||||
type Buffer = VecStorage<T, R, Dyn>;
|
type Buffer<T: Scalar> = VecStorage<T, R, Dyn>;
|
||||||
type BufferUninit = VecStorage<MaybeUninit<T>, R, Dyn>;
|
type BufferUninit<T: Scalar> = VecStorage<MaybeUninit<T>, R, Dyn>;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn allocate_uninit(nrows: R, ncols: Dyn) -> VecStorage<MaybeUninit<T>, R, Dyn> {
|
fn allocate_uninit<T: Scalar>(nrows: R, ncols: Dyn) -> VecStorage<MaybeUninit<T>, R, Dyn> {
|
||||||
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);
|
||||||
|
@ -147,7 +149,9 @@ impl<T: Scalar, R: DimName> Allocator<T, R, Dyn> for DefaultAllocator {
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn assume_init(uninit: VecStorage<MaybeUninit<T>, R, Dyn>) -> VecStorage<T, R, Dyn> {
|
unsafe fn assume_init<T: Scalar>(
|
||||||
|
uninit: VecStorage<MaybeUninit<T>, R, Dyn>,
|
||||||
|
) -> VecStorage<T, R, Dyn> {
|
||||||
// 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();
|
||||||
|
@ -162,11 +166,11 @@ impl<T: Scalar, R: DimName> Allocator<T, R, Dyn> for DefaultAllocator {
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn allocate_from_iterator<I: IntoIterator<Item = T>>(
|
fn allocate_from_iterator<T: Scalar, I: IntoIterator<Item = T>>(
|
||||||
nrows: R,
|
nrows: R,
|
||||||
ncols: Dyn,
|
ncols: Dyn,
|
||||||
iter: I,
|
iter: I,
|
||||||
) -> Self::Buffer {
|
) -> Self::Buffer<T> {
|
||||||
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(),
|
||||||
|
@ -187,15 +191,15 @@ impl<T: Scalar, RFrom, CFrom, const RTO: usize, const CTO: usize>
|
||||||
where
|
where
|
||||||
RFrom: Dim,
|
RFrom: Dim,
|
||||||
CFrom: Dim,
|
CFrom: Dim,
|
||||||
Self: Allocator<T, RFrom, CFrom>,
|
Self: Allocator<RFrom, CFrom>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn reallocate_copy(
|
unsafe fn reallocate_copy(
|
||||||
rto: Const<RTO>,
|
rto: Const<RTO>,
|
||||||
cto: Const<CTO>,
|
cto: Const<CTO>,
|
||||||
buf: <Self as Allocator<T, RFrom, CFrom>>::Buffer,
|
buf: <Self as Allocator<RFrom, CFrom>>::Buffer<T>,
|
||||||
) -> ArrayStorage<MaybeUninit<T>, RTO, CTO> {
|
) -> ArrayStorage<MaybeUninit<T>, RTO, CTO> {
|
||||||
let mut res = <Self as Allocator<T, Const<RTO>, Const<CTO>>>::allocate_uninit(rto, cto);
|
let mut res = <Self as Allocator<Const<RTO>, Const<CTO>>>::allocate_uninit(rto, cto);
|
||||||
|
|
||||||
let (rfrom, cfrom) = buf.shape();
|
let (rfrom, cfrom) = buf.shape();
|
||||||
|
|
||||||
|
@ -226,7 +230,7 @@ where
|
||||||
cto: CTo,
|
cto: CTo,
|
||||||
buf: ArrayStorage<T, RFROM, CFROM>,
|
buf: ArrayStorage<T, RFROM, CFROM>,
|
||||||
) -> VecStorage<MaybeUninit<T>, Dyn, CTo> {
|
) -> VecStorage<MaybeUninit<T>, Dyn, CTo> {
|
||||||
let mut res = <Self as Allocator<T, Dyn, CTo>>::allocate_uninit(rto, cto);
|
let mut res = <Self as Allocator<Dyn, CTo>>::allocate_uninit(rto, cto);
|
||||||
|
|
||||||
let (rfrom, cfrom) = buf.shape();
|
let (rfrom, cfrom) = buf.shape();
|
||||||
|
|
||||||
|
@ -257,7 +261,7 @@ where
|
||||||
cto: Dyn,
|
cto: Dyn,
|
||||||
buf: ArrayStorage<T, RFROM, CFROM>,
|
buf: ArrayStorage<T, RFROM, CFROM>,
|
||||||
) -> VecStorage<MaybeUninit<T>, RTo, Dyn> {
|
) -> VecStorage<MaybeUninit<T>, RTo, Dyn> {
|
||||||
let mut res = <Self as Allocator<T, RTo, Dyn>>::allocate_uninit(rto, cto);
|
let mut res = <Self as Allocator<RTo, Dyn>>::allocate_uninit(rto, cto);
|
||||||
|
|
||||||
let (rfrom, cfrom) = buf.shape();
|
let (rfrom, cfrom) = buf.shape();
|
||||||
|
|
||||||
|
|
|
@ -21,7 +21,7 @@ impl<T: Scalar + Zero, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn upper_triangle(&self) -> OMatrix<T, R, C>
|
pub fn upper_triangle(&self) -> OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
let mut res = self.clone_owned();
|
let mut res = self.clone_owned();
|
||||||
res.fill_lower_triangle(T::zero(), 1);
|
res.fill_lower_triangle(T::zero(), 1);
|
||||||
|
@ -34,7 +34,7 @@ impl<T: Scalar + Zero, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn lower_triangle(&self) -> OMatrix<T, R, C>
|
pub fn lower_triangle(&self) -> OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
let mut res = self.clone_owned();
|
let mut res = self.clone_owned();
|
||||||
res.fill_upper_triangle(T::zero(), 1);
|
res.fill_upper_triangle(T::zero(), 1);
|
||||||
|
@ -52,7 +52,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
where
|
where
|
||||||
I: IntoIterator<Item = &'a usize>,
|
I: IntoIterator<Item = &'a usize>,
|
||||||
I::IntoIter: ExactSizeIterator + Clone,
|
I::IntoIter: ExactSizeIterator + Clone,
|
||||||
DefaultAllocator: Allocator<T, Dyn, C>,
|
DefaultAllocator: Allocator<Dyn, C>,
|
||||||
{
|
{
|
||||||
let irows = irows.into_iter();
|
let irows = irows.into_iter();
|
||||||
let ncols = self.shape_generic().1;
|
let ncols = self.shape_generic().1;
|
||||||
|
@ -89,7 +89,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
where
|
where
|
||||||
I: IntoIterator<Item = &'a usize>,
|
I: IntoIterator<Item = &'a usize>,
|
||||||
I::IntoIter: ExactSizeIterator,
|
I::IntoIter: ExactSizeIterator,
|
||||||
DefaultAllocator: Allocator<T, R, Dyn>,
|
DefaultAllocator: Allocator<R, Dyn>,
|
||||||
{
|
{
|
||||||
let icols = icols.into_iter();
|
let icols = icols.into_iter();
|
||||||
let nrows = self.shape_generic().0;
|
let nrows = self.shape_generic().0;
|
||||||
|
@ -1037,7 +1037,7 @@ impl<T: Scalar> OMatrix<T, Dyn, Dyn> {
|
||||||
#[cfg(any(feature = "std", feature = "alloc"))]
|
#[cfg(any(feature = "std", feature = "alloc"))]
|
||||||
impl<T: Scalar, C: Dim> OMatrix<T, Dyn, C>
|
impl<T: Scalar, C: Dim> OMatrix<T, Dyn, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, Dyn, C>,
|
DefaultAllocator: Allocator<Dyn, C>,
|
||||||
{
|
{
|
||||||
/// Changes the number of rows of this matrix in-place.
|
/// Changes the number of rows of this matrix in-place.
|
||||||
///
|
///
|
||||||
|
@ -1058,7 +1058,7 @@ where
|
||||||
#[cfg(any(feature = "std", feature = "alloc"))]
|
#[cfg(any(feature = "std", feature = "alloc"))]
|
||||||
impl<T: Scalar, R: Dim> OMatrix<T, R, Dyn>
|
impl<T: Scalar, R: Dim> OMatrix<T, R, Dyn>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, Dyn>,
|
DefaultAllocator: Allocator<R, Dyn>,
|
||||||
{
|
{
|
||||||
/// Changes the number of column of this matrix in-place.
|
/// Changes the number of column of this matrix in-place.
|
||||||
///
|
///
|
||||||
|
|
|
@ -23,7 +23,7 @@ impl<T: Scalar + Zero + One + ClosedAdd + ClosedSub + ClosedMul, D: Dim, S: Stor
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn lerp<S2: Storage<T, D>>(&self, rhs: &Vector<T, D, S2>, t: T) -> OVector<T, D>
|
pub fn lerp<S2: Storage<T, D>>(&self, rhs: &Vector<T, D, S2>, t: T) -> OVector<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
let mut res = self.clone_owned();
|
let mut res = self.clone_owned();
|
||||||
res.axpy(t.clone(), rhs, T::one() - t);
|
res.axpy(t.clone(), rhs, T::one() - t);
|
||||||
|
@ -50,7 +50,7 @@ impl<T: Scalar + Zero + One + ClosedAdd + ClosedSub + ClosedMul, D: Dim, S: Stor
|
||||||
pub fn slerp<S2: Storage<T, D>>(&self, rhs: &Vector<T, D, S2>, t: T) -> OVector<T, D>
|
pub fn slerp<S2: Storage<T, D>>(&self, rhs: &Vector<T, D, S2>, t: T) -> OVector<T, D>
|
||||||
where
|
where
|
||||||
T: RealField,
|
T: RealField,
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
let me = Unit::new_normalize(self.clone_owned());
|
let me = Unit::new_normalize(self.clone_owned());
|
||||||
let rhs = Unit::new_normalize(rhs.clone_owned());
|
let rhs = Unit::new_normalize(rhs.clone_owned());
|
||||||
|
@ -81,7 +81,7 @@ impl<T: RealField, D: Dim, S: Storage<T, D>> Unit<Vector<T, D, S>> {
|
||||||
t: T,
|
t: T,
|
||||||
) -> Unit<OVector<T, D>>
|
) -> Unit<OVector<T, D>>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
// TODO: the result is wrong when self and rhs are collinear with opposite direction.
|
// TODO: the result is wrong when self and rhs are collinear with opposite direction.
|
||||||
self.try_slerp(rhs, t, T::default_epsilon())
|
self.try_slerp(rhs, t, T::default_epsilon())
|
||||||
|
@ -100,7 +100,7 @@ impl<T: RealField, D: Dim, S: Storage<T, D>> Unit<Vector<T, D, S>> {
|
||||||
epsilon: T,
|
epsilon: T,
|
||||||
) -> Option<Unit<OVector<T, D>>>
|
) -> Option<Unit<OVector<T, D>>>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
let c_hang = self.dot(rhs);
|
let c_hang = self.dot(rhs);
|
||||||
|
|
||||||
|
|
|
@ -383,9 +383,9 @@ impl<T> RowDVector<T> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T, R: Dim, C: Dim> UninitMatrix<T, R, C>
|
impl<T: Scalar, R: Dim, C: Dim> UninitMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
/// Assumes a matrix's entries to be initialized. This operation should be near zero-cost.
|
/// Assumes a matrix's entries to be initialized. This operation should be near zero-cost.
|
||||||
///
|
///
|
||||||
|
@ -394,7 +394,7 @@ where
|
||||||
/// or Undefined Behavior will immediately occur.
|
/// or Undefined Behavior will immediately occur.
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
pub unsafe fn assume_init(self) -> OMatrix<T, R, C> {
|
pub unsafe fn assume_init(self) -> OMatrix<T, R, C> {
|
||||||
OMatrix::from_data(<DefaultAllocator as Allocator<T, R, C>>::assume_init(
|
OMatrix::from_data(<DefaultAllocator as Allocator<R, C>>::assume_init(
|
||||||
self.data,
|
self.data,
|
||||||
))
|
))
|
||||||
}
|
}
|
||||||
|
@ -533,7 +533,7 @@ impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
max_relative: T::Epsilon,
|
max_relative: T::Epsilon,
|
||||||
) -> bool
|
) -> bool
|
||||||
where
|
where
|
||||||
T: RelativeEq,
|
T: RelativeEq + Scalar,
|
||||||
R2: Dim,
|
R2: Dim,
|
||||||
C2: Dim,
|
C2: Dim,
|
||||||
SB: Storage<T, R2, C2>,
|
SB: Storage<T, R2, C2>,
|
||||||
|
@ -568,7 +568,7 @@ impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
where
|
where
|
||||||
T: Scalar,
|
T: Scalar,
|
||||||
S: Storage<T, R, C>,
|
S: Storage<T, R, C>,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
Matrix::from_data(self.data.into_owned())
|
Matrix::from_data(self.data.into_owned())
|
||||||
}
|
}
|
||||||
|
@ -584,7 +584,7 @@ impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
S: Storage<T, R, C>,
|
S: Storage<T, R, C>,
|
||||||
R2: Dim,
|
R2: Dim,
|
||||||
C2: Dim,
|
C2: Dim,
|
||||||
DefaultAllocator: SameShapeAllocator<T, R, C, R2, C2>,
|
DefaultAllocator: SameShapeAllocator<R, C, R2, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
|
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
|
||||||
{
|
{
|
||||||
if TypeId::of::<SameShapeStorage<T, R, C, R2, C2>>() == TypeId::of::<Owned<T, R, C>>() {
|
if TypeId::of::<SameShapeStorage<T, R, C, R2, C2>>() == TypeId::of::<Owned<T, R, C>>() {
|
||||||
|
@ -609,7 +609,7 @@ impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
where
|
where
|
||||||
T: Scalar,
|
T: Scalar,
|
||||||
S: Storage<T, R, C>,
|
S: Storage<T, R, C>,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
Matrix::from_data(self.data.clone_owned())
|
Matrix::from_data(self.data.clone_owned())
|
||||||
}
|
}
|
||||||
|
@ -624,7 +624,7 @@ impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
S: Storage<T, R, C>,
|
S: Storage<T, R, C>,
|
||||||
R2: Dim,
|
R2: Dim,
|
||||||
C2: Dim,
|
C2: Dim,
|
||||||
DefaultAllocator: SameShapeAllocator<T, R, C, R2, C2>,
|
DefaultAllocator: SameShapeAllocator<R, C, R2, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
|
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
|
||||||
{
|
{
|
||||||
let (nrows, ncols) = self.shape();
|
let (nrows, ncols) = self.shape();
|
||||||
|
@ -700,7 +700,7 @@ impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
pub fn transpose(&self) -> OMatrix<T, C, R>
|
pub fn transpose(&self) -> OMatrix<T, C, R>
|
||||||
where
|
where
|
||||||
T: Scalar,
|
T: Scalar,
|
||||||
DefaultAllocator: Allocator<T, C, R>,
|
DefaultAllocator: Allocator<C, R>,
|
||||||
{
|
{
|
||||||
let (nrows, ncols) = self.shape_generic();
|
let (nrows, ncols) = self.shape_generic();
|
||||||
|
|
||||||
|
@ -719,7 +719,7 @@ impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
pub fn map<T2: Scalar, F: FnMut(T) -> T2>(&self, mut f: F) -> OMatrix<T2, R, C>
|
pub fn map<T2: Scalar, F: FnMut(T) -> T2>(&self, mut f: F) -> OMatrix<T2, R, C>
|
||||||
where
|
where
|
||||||
T: Scalar,
|
T: Scalar,
|
||||||
DefaultAllocator: Allocator<T2, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
let (nrows, ncols) = self.shape_generic();
|
let (nrows, ncols) = self.shape_generic();
|
||||||
let mut res = Matrix::uninit(nrows, ncols);
|
let mut res = Matrix::uninit(nrows, ncols);
|
||||||
|
@ -751,7 +751,7 @@ impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
where
|
where
|
||||||
T: Scalar,
|
T: Scalar,
|
||||||
OMatrix<T2, R, C>: SupersetOf<Self>,
|
OMatrix<T2, R, C>: SupersetOf<Self>,
|
||||||
DefaultAllocator: Allocator<T2, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
crate::convert(self)
|
crate::convert(self)
|
||||||
}
|
}
|
||||||
|
@ -769,7 +769,7 @@ impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
where
|
where
|
||||||
T: Scalar,
|
T: Scalar,
|
||||||
Self: SupersetOf<OMatrix<T2, R, C>>,
|
Self: SupersetOf<OMatrix<T2, R, C>>,
|
||||||
DefaultAllocator: Allocator<T2, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
crate::try_convert(self)
|
crate::try_convert(self)
|
||||||
}
|
}
|
||||||
|
@ -806,7 +806,7 @@ impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
) -> OMatrix<T2, R, C>
|
) -> OMatrix<T2, R, C>
|
||||||
where
|
where
|
||||||
T: Scalar,
|
T: Scalar,
|
||||||
DefaultAllocator: Allocator<T2, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
let (nrows, ncols) = self.shape_generic();
|
let (nrows, ncols) = self.shape_generic();
|
||||||
let mut res = Matrix::uninit(nrows, ncols);
|
let mut res = Matrix::uninit(nrows, ncols);
|
||||||
|
@ -836,7 +836,7 @@ impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
N3: Scalar,
|
N3: Scalar,
|
||||||
S2: RawStorage<T2, R, C>,
|
S2: RawStorage<T2, R, C>,
|
||||||
F: FnMut(T, T2) -> N3,
|
F: FnMut(T, T2) -> N3,
|
||||||
DefaultAllocator: Allocator<N3, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
let (nrows, ncols) = self.shape_generic();
|
let (nrows, ncols) = self.shape_generic();
|
||||||
let mut res = Matrix::uninit(nrows, ncols);
|
let mut res = Matrix::uninit(nrows, ncols);
|
||||||
|
@ -880,7 +880,7 @@ impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
S2: RawStorage<T2, R, C>,
|
S2: RawStorage<T2, R, C>,
|
||||||
S3: RawStorage<N3, R, C>,
|
S3: RawStorage<N3, R, C>,
|
||||||
F: FnMut(T, T2, N3) -> N4,
|
F: FnMut(T, T2, N3) -> N4,
|
||||||
DefaultAllocator: Allocator<N4, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
let (nrows, ncols) = self.shape_generic();
|
let (nrows, ncols) = self.shape_generic();
|
||||||
let mut res = Matrix::uninit(nrows, ncols);
|
let mut res = Matrix::uninit(nrows, ncols);
|
||||||
|
@ -1420,7 +1420,7 @@ impl<T: SimdComplexField, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C
|
||||||
#[must_use = "Did you mean to use adjoint_mut()?"]
|
#[must_use = "Did you mean to use adjoint_mut()?"]
|
||||||
pub fn adjoint(&self) -> OMatrix<T, C, R>
|
pub fn adjoint(&self) -> OMatrix<T, C, R>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, C, R>,
|
DefaultAllocator: Allocator<C, R>,
|
||||||
{
|
{
|
||||||
let (nrows, ncols) = self.shape_generic();
|
let (nrows, ncols) = self.shape_generic();
|
||||||
|
|
||||||
|
@ -1449,7 +1449,7 @@ impl<T: SimdComplexField, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C
|
||||||
#[inline]
|
#[inline]
|
||||||
pub fn conjugate_transpose(&self) -> OMatrix<T, C, R>
|
pub fn conjugate_transpose(&self) -> OMatrix<T, C, R>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, C, R>,
|
DefaultAllocator: Allocator<C, R>,
|
||||||
{
|
{
|
||||||
self.adjoint()
|
self.adjoint()
|
||||||
}
|
}
|
||||||
|
@ -1459,7 +1459,7 @@ impl<T: SimdComplexField, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C
|
||||||
#[must_use = "Did you mean to use conjugate_mut()?"]
|
#[must_use = "Did you mean to use conjugate_mut()?"]
|
||||||
pub fn conjugate(&self) -> OMatrix<T, R, C>
|
pub fn conjugate(&self) -> OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
self.map(|e| e.simd_conjugate())
|
self.map(|e| e.simd_conjugate())
|
||||||
}
|
}
|
||||||
|
@ -1469,7 +1469,7 @@ impl<T: SimdComplexField, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C
|
||||||
#[must_use = "Did you mean to use unscale_mut()?"]
|
#[must_use = "Did you mean to use unscale_mut()?"]
|
||||||
pub fn unscale(&self, real: T::SimdRealField) -> OMatrix<T, R, C>
|
pub fn unscale(&self, real: T::SimdRealField) -> OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
self.map(|e| e.simd_unscale(real.clone()))
|
self.map(|e| e.simd_unscale(real.clone()))
|
||||||
}
|
}
|
||||||
|
@ -1479,7 +1479,7 @@ impl<T: SimdComplexField, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C
|
||||||
#[must_use = "Did you mean to use scale_mut()?"]
|
#[must_use = "Did you mean to use scale_mut()?"]
|
||||||
pub fn scale(&self, real: T::SimdRealField) -> OMatrix<T, R, C>
|
pub fn scale(&self, real: T::SimdRealField) -> OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
self.map(|e| e.simd_scale(real.clone()))
|
self.map(|e| e.simd_scale(real.clone()))
|
||||||
}
|
}
|
||||||
|
@ -1547,7 +1547,7 @@ impl<T: Scalar, D: Dim, S: RawStorage<T, D, D>> SquareMatrix<T, D, S> {
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn diagonal(&self) -> OVector<T, D>
|
pub fn diagonal(&self) -> OVector<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
self.map_diagonal(|e| e)
|
self.map_diagonal(|e| e)
|
||||||
}
|
}
|
||||||
|
@ -1559,7 +1559,7 @@ impl<T: Scalar, D: Dim, S: RawStorage<T, D, D>> SquareMatrix<T, D, S> {
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn map_diagonal<T2: Scalar>(&self, mut f: impl FnMut(T) -> T2) -> OVector<T2, D>
|
pub fn map_diagonal<T2: Scalar>(&self, mut f: impl FnMut(T) -> T2) -> OVector<T2, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T2, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
assert!(
|
assert!(
|
||||||
self.is_square(),
|
self.is_square(),
|
||||||
|
@ -1610,7 +1610,7 @@ impl<T: SimdComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn symmetric_part(&self) -> OMatrix<T, D, D>
|
pub fn symmetric_part(&self) -> OMatrix<T, D, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
assert!(
|
assert!(
|
||||||
self.is_square(),
|
self.is_square(),
|
||||||
|
@ -1627,7 +1627,7 @@ impl<T: SimdComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn hermitian_part(&self) -> OMatrix<T, D, D>
|
pub fn hermitian_part(&self) -> OMatrix<T, D, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
assert!(
|
assert!(
|
||||||
self.is_square(),
|
self.is_square(),
|
||||||
|
@ -1650,7 +1650,7 @@ impl<T: Scalar + Zero + One, D: DimAdd<U1> + IsNotStaticOne, S: RawStorage<T, D,
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn to_homogeneous(&self) -> OMatrix<T, DimSum<D, U1>, DimSum<D, U1>>
|
pub fn to_homogeneous(&self) -> OMatrix<T, DimSum<D, U1>, DimSum<D, U1>>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, DimSum<D, U1>, DimSum<D, U1>>,
|
DefaultAllocator: Allocator<DimSum<D, U1>, DimSum<D, U1>>,
|
||||||
{
|
{
|
||||||
assert!(
|
assert!(
|
||||||
self.is_square(),
|
self.is_square(),
|
||||||
|
@ -1671,7 +1671,7 @@ impl<T: Scalar + Zero, D: DimAdd<U1>, S: RawStorage<T, D>> Vector<T, D, S> {
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn to_homogeneous(&self) -> OVector<T, DimSum<D, U1>>
|
pub fn to_homogeneous(&self) -> OVector<T, DimSum<D, U1>>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, DimSum<D, U1>>,
|
DefaultAllocator: Allocator<DimSum<D, U1>>,
|
||||||
{
|
{
|
||||||
self.push(T::zero())
|
self.push(T::zero())
|
||||||
}
|
}
|
||||||
|
@ -1682,7 +1682,7 @@ impl<T: Scalar + Zero, D: DimAdd<U1>, S: RawStorage<T, D>> Vector<T, D, S> {
|
||||||
pub fn from_homogeneous<SB>(v: Vector<T, DimSum<D, U1>, SB>) -> Option<OVector<T, D>>
|
pub fn from_homogeneous<SB>(v: Vector<T, DimSum<D, U1>, SB>) -> Option<OVector<T, D>>
|
||||||
where
|
where
|
||||||
SB: RawStorage<T, DimSum<D, U1>>,
|
SB: RawStorage<T, DimSum<D, U1>>,
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
if v[v.len() - 1].is_zero() {
|
if v[v.len() - 1].is_zero() {
|
||||||
let nrows = D::from_usize(v.len() - 1);
|
let nrows = D::from_usize(v.len() - 1);
|
||||||
|
@ -1699,7 +1699,7 @@ impl<T: Scalar, D: DimAdd<U1>, S: RawStorage<T, D>> Vector<T, D, S> {
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn push(&self, element: T) -> OVector<T, DimSum<D, U1>>
|
pub fn push(&self, element: T) -> OVector<T, DimSum<D, U1>>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, DimSum<D, U1>>,
|
DefaultAllocator: Allocator<DimSum<D, U1>>,
|
||||||
{
|
{
|
||||||
let len = self.len();
|
let len = self.len();
|
||||||
let hnrows = DimSum::<D, U1>::from_usize(len + 1);
|
let hnrows = DimSum::<D, U1>::from_usize(len + 1);
|
||||||
|
@ -2052,7 +2052,7 @@ impl<T: Scalar + ClosedAdd + ClosedSub + ClosedMul, R: Dim, C: Dim, S: RawStorag
|
||||||
R2: Dim,
|
R2: Dim,
|
||||||
C2: Dim,
|
C2: Dim,
|
||||||
SB: RawStorage<T, R2, C2>,
|
SB: RawStorage<T, R2, C2>,
|
||||||
DefaultAllocator: SameShapeAllocator<T, R, C, R2, C2>,
|
DefaultAllocator: SameShapeAllocator<R, C, R2, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
|
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
|
||||||
{
|
{
|
||||||
let shape = self.shape();
|
let shape = self.shape();
|
||||||
|
@ -2252,7 +2252,7 @@ where
|
||||||
where
|
where
|
||||||
T: Scalar,
|
T: Scalar,
|
||||||
OVector<T2, D>: SupersetOf<Vector<T, D, S>>,
|
OVector<T2, D>: SupersetOf<Vector<T, D, S>>,
|
||||||
DefaultAllocator: Allocator<T2, D, U1>,
|
DefaultAllocator: Allocator<D, U1>,
|
||||||
{
|
{
|
||||||
Unit::new_unchecked(crate::convert_ref(self.as_ref()))
|
Unit::new_unchecked(crate::convert_ref(self.as_ref()))
|
||||||
}
|
}
|
||||||
|
|
|
@ -15,7 +15,7 @@ where
|
||||||
R: Dim,
|
R: Dim,
|
||||||
C: Dim,
|
C: Dim,
|
||||||
T::Element: Scalar,
|
T::Element: Scalar,
|
||||||
DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
type Element = OMatrix<T::Element, R, C>;
|
type Element = OMatrix<T::Element, R, C>;
|
||||||
type SimdBool = T::SimdBool;
|
type SimdBool = T::SimdBool;
|
||||||
|
|
|
@ -218,13 +218,13 @@ macro_rules! storage_impl(
|
||||||
for $T<'a, T, R, C, RStride, CStride> {
|
for $T<'a, T, R, C, RStride, CStride> {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn into_owned(self) -> Owned<T, R, C>
|
fn into_owned(self) -> Owned<T, R, C>
|
||||||
where DefaultAllocator: Allocator<T, R, C> {
|
where DefaultAllocator: Allocator<R, C> {
|
||||||
self.clone_owned()
|
self.clone_owned()
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn clone_owned(&self) -> Owned<T, R, C>
|
fn clone_owned(&self) -> Owned<T, R, C>
|
||||||
where DefaultAllocator: Allocator<T, R, C> {
|
where DefaultAllocator: Allocator<R, C> {
|
||||||
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)
|
DefaultAllocator::allocate_from_iterator(nrows, ncols, it)
|
||||||
|
|
|
@ -301,7 +301,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
pub fn normalize(&self) -> OMatrix<T, R, C>
|
pub fn normalize(&self) -> OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
T: SimdComplexField,
|
T: SimdComplexField,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
self.unscale(self.norm())
|
self.unscale(self.norm())
|
||||||
}
|
}
|
||||||
|
@ -325,7 +325,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
where
|
where
|
||||||
T: SimdComplexField,
|
T: SimdComplexField,
|
||||||
T::Element: Scalar,
|
T::Element: Scalar,
|
||||||
DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
let n = self.norm();
|
let n = self.norm();
|
||||||
let le = n.clone().simd_le(min_norm);
|
let le = n.clone().simd_le(min_norm);
|
||||||
|
@ -356,7 +356,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
pub fn cap_magnitude(&self, max: T::RealField) -> OMatrix<T, R, C>
|
pub fn cap_magnitude(&self, max: T::RealField) -> OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
T: ComplexField,
|
T: ComplexField,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
let n = self.norm();
|
let n = self.norm();
|
||||||
|
|
||||||
|
@ -374,7 +374,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
where
|
where
|
||||||
T: SimdComplexField,
|
T: SimdComplexField,
|
||||||
T::Element: Scalar,
|
T::Element: Scalar,
|
||||||
DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
let n = self.norm();
|
let n = self.norm();
|
||||||
let scaled = self.scale(max.clone() / n.clone());
|
let scaled = self.scale(max.clone() / n.clone());
|
||||||
|
@ -390,7 +390,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
pub fn try_normalize(&self, min_norm: T::RealField) -> Option<OMatrix<T, R, C>>
|
pub fn try_normalize(&self, min_norm: T::RealField) -> Option<OMatrix<T, R, C>>
|
||||||
where
|
where
|
||||||
T: ComplexField,
|
T: ComplexField,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
let n = self.norm();
|
let n = self.norm();
|
||||||
|
|
||||||
|
@ -430,7 +430,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: StorageMut<T, R, C>> Matrix<T, R, C, S> {
|
||||||
where
|
where
|
||||||
T: SimdComplexField,
|
T: SimdComplexField,
|
||||||
T::Element: Scalar,
|
T::Element: Scalar,
|
||||||
DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
let n = self.norm();
|
let n = self.norm();
|
||||||
let le = n.clone().simd_le(min_norm);
|
let le = n.clone().simd_le(min_norm);
|
||||||
|
@ -459,7 +459,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: StorageMut<T, R, C>> Matrix<T, R, C, S> {
|
||||||
|
|
||||||
impl<T: SimdComplexField, R: Dim, C: Dim> Normed for OMatrix<T, R, C>
|
impl<T: SimdComplexField, R: Dim, C: Dim> Normed for OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
type Norm = T::SimdRealField;
|
type Norm = T::SimdRealField;
|
||||||
|
|
||||||
|
@ -486,7 +486,7 @@ where
|
||||||
|
|
||||||
impl<T: Scalar + ClosedNeg, R: Dim, C: Dim> Neg for Unit<OMatrix<T, R, C>>
|
impl<T: Scalar + ClosedNeg, R: Dim, C: Dim> Neg for Unit<OMatrix<T, R, C>>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
type Output = Unit<OMatrix<T, R, C>>;
|
type Output = Unit<OMatrix<T, R, C>>;
|
||||||
|
|
||||||
|
@ -503,7 +503,7 @@ where
|
||||||
/// # Basis and orthogonalization
|
/// # Basis and orthogonalization
|
||||||
impl<T: ComplexField, D: DimName> OVector<T, D>
|
impl<T: ComplexField, D: DimName> OVector<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
/// The i-the canonical basis element.
|
/// The i-the canonical basis element.
|
||||||
#[inline]
|
#[inline]
|
||||||
|
|
|
@ -81,7 +81,7 @@ impl<T, R: Dim, C: Dim, S> Neg for Matrix<T, R, C, S>
|
||||||
where
|
where
|
||||||
T: Scalar + ClosedNeg,
|
T: Scalar + ClosedNeg,
|
||||||
S: Storage<T, R, C>,
|
S: Storage<T, R, C>,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
type Output = OMatrix<T, R, C>;
|
type Output = OMatrix<T, R, C>;
|
||||||
|
|
||||||
|
@ -97,7 +97,7 @@ impl<'a, T, R: Dim, C: Dim, S> Neg for &'a Matrix<T, R, C, S>
|
||||||
where
|
where
|
||||||
T: Scalar + ClosedNeg,
|
T: Scalar + ClosedNeg,
|
||||||
S: Storage<T, R, C>,
|
S: Storage<T, R, C>,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
type Output = OMatrix<T, R, C>;
|
type Output = OMatrix<T, R, C>;
|
||||||
|
|
||||||
|
@ -262,7 +262,7 @@ macro_rules! componentwise_binop_impl(
|
||||||
T: Scalar + $bound,
|
T: Scalar + $bound,
|
||||||
SA: Storage<T, R1, C1>,
|
SA: Storage<T, R1, C1>,
|
||||||
SB: Storage<T, R2, C2>,
|
SB: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: SameShapeAllocator<T, R1, C1, R2, C2>,
|
DefaultAllocator: SameShapeAllocator<R1, C1, R2, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> {
|
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> {
|
||||||
type Output = MatrixSum<T, R1, C1, R2, C2>;
|
type Output = MatrixSum<T, R1, C1, R2, C2>;
|
||||||
|
|
||||||
|
@ -280,7 +280,7 @@ macro_rules! componentwise_binop_impl(
|
||||||
T: Scalar + $bound,
|
T: Scalar + $bound,
|
||||||
SA: Storage<T, R1, C1>,
|
SA: Storage<T, R1, C1>,
|
||||||
SB: Storage<T, R2, C2>,
|
SB: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: SameShapeAllocator<T, R2, C2, R1, C1>,
|
DefaultAllocator: SameShapeAllocator<R2, C2, R1, C1>,
|
||||||
ShapeConstraint: SameNumberOfRows<R2, R1> + SameNumberOfColumns<C2, C1> {
|
ShapeConstraint: SameNumberOfRows<R2, R1> + SameNumberOfColumns<C2, C1> {
|
||||||
type Output = MatrixSum<T, R2, C2, R1, C1>;
|
type Output = MatrixSum<T, R2, C2, R1, C1>;
|
||||||
|
|
||||||
|
@ -298,7 +298,7 @@ macro_rules! componentwise_binop_impl(
|
||||||
T: Scalar + $bound,
|
T: Scalar + $bound,
|
||||||
SA: Storage<T, R1, C1>,
|
SA: Storage<T, R1, C1>,
|
||||||
SB: Storage<T, R2, C2>,
|
SB: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: SameShapeAllocator<T, R1, C1, R2, C2>,
|
DefaultAllocator: SameShapeAllocator<R1, C1, R2, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> {
|
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> {
|
||||||
type Output = MatrixSum<T, R1, C1, R2, C2>;
|
type Output = MatrixSum<T, R1, C1, R2, C2>;
|
||||||
|
|
||||||
|
@ -313,7 +313,7 @@ macro_rules! componentwise_binop_impl(
|
||||||
T: Scalar + $bound,
|
T: Scalar + $bound,
|
||||||
SA: Storage<T, R1, C1>,
|
SA: Storage<T, R1, C1>,
|
||||||
SB: Storage<T, R2, C2>,
|
SB: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: SameShapeAllocator<T, R1, C1, R2, C2>,
|
DefaultAllocator: SameShapeAllocator<R1, C1, R2, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> {
|
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> {
|
||||||
type Output = MatrixSum<T, R1, C1, R2, C2>;
|
type Output = MatrixSum<T, R1, C1, R2, C2>;
|
||||||
|
|
||||||
|
@ -367,7 +367,7 @@ componentwise_binop_impl!(Sub, sub, ClosedSub;
|
||||||
impl<T, R: DimName, C: DimName> iter::Sum for OMatrix<T, R, C>
|
impl<T, R: DimName, C: DimName> iter::Sum for OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
T: Scalar + ClosedAdd + Zero,
|
T: Scalar + ClosedAdd + Zero,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
fn sum<I: Iterator<Item = OMatrix<T, R, C>>>(iter: I) -> OMatrix<T, R, C> {
|
fn sum<I: Iterator<Item = OMatrix<T, R, C>>>(iter: I) -> OMatrix<T, R, C> {
|
||||||
iter.fold(Matrix::zero(), |acc, x| acc + x)
|
iter.fold(Matrix::zero(), |acc, x| acc + x)
|
||||||
|
@ -377,7 +377,7 @@ where
|
||||||
impl<T, C: Dim> iter::Sum for OMatrix<T, Dyn, C>
|
impl<T, C: Dim> iter::Sum for OMatrix<T, Dyn, C>
|
||||||
where
|
where
|
||||||
T: Scalar + ClosedAdd + Zero,
|
T: Scalar + ClosedAdd + Zero,
|
||||||
DefaultAllocator: Allocator<T, Dyn, C>,
|
DefaultAllocator: Allocator<Dyn, C>,
|
||||||
{
|
{
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
|
@ -407,7 +407,7 @@ where
|
||||||
impl<'a, T, R: DimName, C: DimName> iter::Sum<&'a OMatrix<T, R, C>> for OMatrix<T, R, C>
|
impl<'a, T, R: DimName, C: DimName> iter::Sum<&'a OMatrix<T, R, C>> for OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
T: Scalar + ClosedAdd + Zero,
|
T: Scalar + ClosedAdd + Zero,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
fn sum<I: Iterator<Item = &'a OMatrix<T, R, C>>>(iter: I) -> OMatrix<T, R, C> {
|
fn sum<I: Iterator<Item = &'a OMatrix<T, R, C>>>(iter: I) -> OMatrix<T, R, C> {
|
||||||
iter.fold(Matrix::zero(), |acc, x| acc + x)
|
iter.fold(Matrix::zero(), |acc, x| acc + x)
|
||||||
|
@ -417,7 +417,7 @@ where
|
||||||
impl<'a, T, C: Dim> iter::Sum<&'a OMatrix<T, Dyn, C>> for OMatrix<T, Dyn, C>
|
impl<'a, T, C: Dim> iter::Sum<&'a OMatrix<T, Dyn, C>> for OMatrix<T, Dyn, C>
|
||||||
where
|
where
|
||||||
T: Scalar + ClosedAdd + Zero,
|
T: Scalar + ClosedAdd + Zero,
|
||||||
DefaultAllocator: Allocator<T, Dyn, C>,
|
DefaultAllocator: Allocator<Dyn, C>,
|
||||||
{
|
{
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
|
@ -458,7 +458,7 @@ macro_rules! componentwise_scalarop_impl(
|
||||||
impl<T, R: Dim, C: Dim, S> $Trait<T> for Matrix<T, R, C, S>
|
impl<T, R: Dim, C: Dim, S> $Trait<T> for Matrix<T, R, C, S>
|
||||||
where T: Scalar + $bound,
|
where T: Scalar + $bound,
|
||||||
S: Storage<T, R, C>,
|
S: Storage<T, R, C>,
|
||||||
DefaultAllocator: Allocator<T, R, C> {
|
DefaultAllocator: Allocator<R, C> {
|
||||||
type Output = OMatrix<T, R, C>;
|
type Output = OMatrix<T, R, C>;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -482,7 +482,7 @@ macro_rules! componentwise_scalarop_impl(
|
||||||
impl<'a, T, R: Dim, C: Dim, S> $Trait<T> for &'a Matrix<T, R, C, S>
|
impl<'a, T, R: Dim, C: Dim, S> $Trait<T> for &'a Matrix<T, R, C, S>
|
||||||
where T: Scalar + $bound,
|
where T: Scalar + $bound,
|
||||||
S: Storage<T, R, C>,
|
S: Storage<T, R, C>,
|
||||||
DefaultAllocator: Allocator<T, R, C> {
|
DefaultAllocator: Allocator<R, C> {
|
||||||
type Output = OMatrix<T, R, C>;
|
type Output = OMatrix<T, R, C>;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -512,7 +512,7 @@ componentwise_scalarop_impl!(Div, div, ClosedDiv; DivAssign, div_assign);
|
||||||
macro_rules! left_scalar_mul_impl(
|
macro_rules! left_scalar_mul_impl(
|
||||||
($($T: ty),* $(,)*) => {$(
|
($($T: ty),* $(,)*) => {$(
|
||||||
impl<R: Dim, C: Dim, S: Storage<$T, R, C>> Mul<Matrix<$T, R, C, S>> for $T
|
impl<R: Dim, C: Dim, S: Storage<$T, R, C>> Mul<Matrix<$T, R, C, S>> for $T
|
||||||
where DefaultAllocator: Allocator<$T, R, C> {
|
where DefaultAllocator: Allocator<R, C> {
|
||||||
type Output = OMatrix<$T, R, C>;
|
type Output = OMatrix<$T, R, C>;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -534,7 +534,7 @@ macro_rules! left_scalar_mul_impl(
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'b, R: Dim, C: Dim, S: Storage<$T, R, C>> Mul<&'b Matrix<$T, R, C, S>> for $T
|
impl<'b, R: Dim, C: Dim, S: Storage<$T, R, C>> Mul<&'b Matrix<$T, R, C, S>> for $T
|
||||||
where DefaultAllocator: Allocator<$T, R, C> {
|
where DefaultAllocator: Allocator<R, C> {
|
||||||
type Output = OMatrix<$T, R, C>;
|
type Output = OMatrix<$T, R, C>;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -554,7 +554,7 @@ where
|
||||||
T: Scalar + Zero + One + ClosedAdd + ClosedMul,
|
T: Scalar + Zero + One + ClosedAdd + ClosedMul,
|
||||||
SA: Storage<T, R1, C1>,
|
SA: Storage<T, R1, C1>,
|
||||||
SB: Storage<T, R2, C2>,
|
SB: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: Allocator<T, R1, C2>,
|
DefaultAllocator: Allocator<R1, C2>,
|
||||||
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
|
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
|
||||||
{
|
{
|
||||||
type Output = OMatrix<T, R1, C2>;
|
type Output = OMatrix<T, R1, C2>;
|
||||||
|
@ -576,7 +576,7 @@ where
|
||||||
T: Scalar + Zero + One + ClosedAdd + ClosedMul,
|
T: Scalar + Zero + One + ClosedAdd + ClosedMul,
|
||||||
SB: Storage<T, R2, C2>,
|
SB: Storage<T, R2, C2>,
|
||||||
SA: Storage<T, R1, C1>,
|
SA: Storage<T, R1, C1>,
|
||||||
DefaultAllocator: Allocator<T, R1, C2>,
|
DefaultAllocator: Allocator<R1, C2>,
|
||||||
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
|
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
|
||||||
{
|
{
|
||||||
type Output = OMatrix<T, R1, C2>;
|
type Output = OMatrix<T, R1, C2>;
|
||||||
|
@ -593,7 +593,7 @@ where
|
||||||
T: Scalar + Zero + One + ClosedAdd + ClosedMul,
|
T: Scalar + Zero + One + ClosedAdd + ClosedMul,
|
||||||
SB: Storage<T, R2, C2>,
|
SB: Storage<T, R2, C2>,
|
||||||
SA: Storage<T, R1, C1>,
|
SA: Storage<T, R1, C1>,
|
||||||
DefaultAllocator: Allocator<T, R1, C2>,
|
DefaultAllocator: Allocator<R1, C2>,
|
||||||
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
|
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
|
||||||
{
|
{
|
||||||
type Output = OMatrix<T, R1, C2>;
|
type Output = OMatrix<T, R1, C2>;
|
||||||
|
@ -610,7 +610,7 @@ where
|
||||||
T: Scalar + Zero + One + ClosedAdd + ClosedMul,
|
T: Scalar + Zero + One + ClosedAdd + ClosedMul,
|
||||||
SB: Storage<T, R2, C2>,
|
SB: Storage<T, R2, C2>,
|
||||||
SA: Storage<T, R1, C1>,
|
SA: Storage<T, R1, C1>,
|
||||||
DefaultAllocator: Allocator<T, R1, C2>,
|
DefaultAllocator: Allocator<R1, C2>,
|
||||||
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
|
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
|
||||||
{
|
{
|
||||||
type Output = OMatrix<T, R1, C2>;
|
type Output = OMatrix<T, R1, C2>;
|
||||||
|
@ -633,7 +633,7 @@ where
|
||||||
SB: Storage<T, R2, C1>,
|
SB: Storage<T, R2, C1>,
|
||||||
SA: StorageMut<T, R1, C1> + IsContiguous + Clone, // TODO: get rid of the IsContiguous
|
SA: StorageMut<T, R1, C1> + IsContiguous + Clone, // TODO: get rid of the IsContiguous
|
||||||
ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,
|
ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,
|
||||||
DefaultAllocator: Allocator<T, R1, C1, Buffer = SA>,
|
DefaultAllocator: Allocator<R1, C1, Buffer<T> = SA>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn mul_assign(&mut self, rhs: Matrix<T, R2, C1, SB>) {
|
fn mul_assign(&mut self, rhs: Matrix<T, R2, C1, SB>) {
|
||||||
|
@ -651,7 +651,7 @@ where
|
||||||
SA: StorageMut<T, R1, C1> + IsContiguous + Clone, // TODO: get rid of the IsContiguous
|
SA: StorageMut<T, R1, C1> + IsContiguous + Clone, // TODO: get rid of the IsContiguous
|
||||||
ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,
|
ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,
|
||||||
// TODO: this is too restrictive. See comments for the non-ref version.
|
// TODO: this is too restrictive. See comments for the non-ref version.
|
||||||
DefaultAllocator: Allocator<T, R1, C1, Buffer = SA>,
|
DefaultAllocator: Allocator<R1, C1, Buffer<T> = SA>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn mul_assign(&mut self, rhs: &'b Matrix<T, R2, C1, SB>) {
|
fn mul_assign(&mut self, rhs: &'b Matrix<T, R2, C1, SB>) {
|
||||||
|
@ -671,7 +671,7 @@ where
|
||||||
pub fn tr_mul<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> OMatrix<T, C1, C2>
|
pub fn tr_mul<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> OMatrix<T, C1, C2>
|
||||||
where
|
where
|
||||||
SB: Storage<T, R2, C2>,
|
SB: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: Allocator<T, C1, C2>,
|
DefaultAllocator: Allocator<C1, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<R1, R2>,
|
ShapeConstraint: SameNumberOfRows<R1, R2>,
|
||||||
{
|
{
|
||||||
let mut res = Matrix::uninit(self.shape_generic().1, rhs.shape_generic().1);
|
let mut res = Matrix::uninit(self.shape_generic().1, rhs.shape_generic().1);
|
||||||
|
@ -687,7 +687,7 @@ where
|
||||||
where
|
where
|
||||||
T: SimdComplexField,
|
T: SimdComplexField,
|
||||||
SB: Storage<T, R2, C2>,
|
SB: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: Allocator<T, C1, C2>,
|
DefaultAllocator: Allocator<C1, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<R1, R2>,
|
ShapeConstraint: SameNumberOfRows<R1, R2>,
|
||||||
{
|
{
|
||||||
let mut res = Matrix::uninit(self.shape_generic().1, rhs.shape_generic().1);
|
let mut res = Matrix::uninit(self.shape_generic().1, rhs.shape_generic().1);
|
||||||
|
@ -803,7 +803,7 @@ where
|
||||||
R1: DimMul<R2>,
|
R1: DimMul<R2>,
|
||||||
C1: DimMul<C2>,
|
C1: DimMul<C2>,
|
||||||
SB: Storage<T, R2, C2>,
|
SB: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: Allocator<T, DimProd<R1, R2>, DimProd<C1, C2>>,
|
DefaultAllocator: Allocator<DimProd<R1, R2>, DimProd<C1, C2>>,
|
||||||
{
|
{
|
||||||
let (nrows1, ncols1) = self.shape_generic();
|
let (nrows1, ncols1) = self.shape_generic();
|
||||||
let (nrows2, ncols2) = rhs.shape_generic();
|
let (nrows2, ncols2) = rhs.shape_generic();
|
||||||
|
@ -836,7 +836,7 @@ where
|
||||||
impl<T, D: DimName> iter::Product for OMatrix<T, D, D>
|
impl<T, D: DimName> iter::Product for OMatrix<T, D, D>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + One + ClosedMul + ClosedAdd,
|
T: Scalar + Zero + One + ClosedMul + ClosedAdd,
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
fn product<I: Iterator<Item = OMatrix<T, D, D>>>(iter: I) -> OMatrix<T, D, D> {
|
fn product<I: Iterator<Item = OMatrix<T, D, D>>>(iter: I) -> OMatrix<T, D, D> {
|
||||||
iter.fold(Matrix::one(), |acc, x| acc * x)
|
iter.fold(Matrix::one(), |acc, x| acc * x)
|
||||||
|
@ -846,7 +846,7 @@ where
|
||||||
impl<'a, T, D: DimName> iter::Product<&'a OMatrix<T, D, D>> for OMatrix<T, D, D>
|
impl<'a, T, D: DimName> iter::Product<&'a OMatrix<T, D, D>> for OMatrix<T, D, D>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + One + ClosedMul + ClosedAdd,
|
T: Scalar + Zero + One + ClosedMul + ClosedAdd,
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
fn product<I: Iterator<Item = &'a OMatrix<T, D, D>>>(iter: I) -> OMatrix<T, D, D> {
|
fn product<I: Iterator<Item = &'a OMatrix<T, D, D>>>(iter: I) -> OMatrix<T, D, D> {
|
||||||
iter.fold(Matrix::one(), |acc, x| acc * x)
|
iter.fold(Matrix::one(), |acc, x| acc * x)
|
||||||
|
|
|
@ -91,7 +91,7 @@ impl<T: ComplexField, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
T: Zero + One + ClosedAdd + ClosedMul + RelativeEq,
|
T: Zero + One + ClosedAdd + ClosedMul + RelativeEq,
|
||||||
S: Storage<T, R, C>,
|
S: Storage<T, R, C>,
|
||||||
T::Epsilon: Clone,
|
T::Epsilon: Clone,
|
||||||
DefaultAllocator: Allocator<T, R, C> + Allocator<T, C, C>,
|
DefaultAllocator: Allocator<R, C> + Allocator<C, C>,
|
||||||
{
|
{
|
||||||
(self.ad_mul(self)).is_identity(eps)
|
(self.ad_mul(self)).is_identity(eps)
|
||||||
}
|
}
|
||||||
|
@ -99,7 +99,7 @@ impl<T: ComplexField, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
|
|
||||||
impl<T: RealField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S>
|
impl<T: RealField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
/// Checks that this matrix is orthogonal and has a determinant equal to 1.
|
/// Checks that this matrix is orthogonal and has a determinant equal to 1.
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -107,7 +107,7 @@ where
|
||||||
pub fn is_special_orthogonal(&self, eps: T) -> bool
|
pub fn is_special_orthogonal(&self, eps: T) -> bool
|
||||||
where
|
where
|
||||||
D: DimMin<D, Output = D>,
|
D: DimMin<D, Output = D>,
|
||||||
DefaultAllocator: Allocator<(usize, usize), D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
self.is_square() && self.is_orthogonal(eps) && self.determinant() > T::zero()
|
self.is_square() && self.is_orthogonal(eps) && self.determinant() > T::zero()
|
||||||
}
|
}
|
||||||
|
|
|
@ -16,7 +16,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
f: impl Fn(VectorView<'_, T, R, S::RStride, S::CStride>) -> T,
|
f: impl Fn(VectorView<'_, T, R, S::RStride, S::CStride>) -> T,
|
||||||
) -> RowOVector<T, C>
|
) -> RowOVector<T, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, U1, C>,
|
DefaultAllocator: Allocator<U1, C>,
|
||||||
{
|
{
|
||||||
let ncols = self.shape_generic().1;
|
let ncols = self.shape_generic().1;
|
||||||
let mut res = Matrix::uninit(Const::<1>, ncols);
|
let mut res = Matrix::uninit(Const::<1>, ncols);
|
||||||
|
@ -44,7 +44,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
f: impl Fn(VectorView<'_, T, R, S::RStride, S::CStride>) -> T,
|
f: impl Fn(VectorView<'_, T, R, S::RStride, S::CStride>) -> T,
|
||||||
) -> OVector<T, C>
|
) -> OVector<T, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, C>,
|
DefaultAllocator: Allocator<C>,
|
||||||
{
|
{
|
||||||
let ncols = self.shape_generic().1;
|
let ncols = self.shape_generic().1;
|
||||||
let mut res = Matrix::uninit(ncols, Const::<1>);
|
let mut res = Matrix::uninit(ncols, Const::<1>);
|
||||||
|
@ -70,7 +70,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
f: impl Fn(&mut OVector<T, R>, VectorView<'_, T, R, S::RStride, S::CStride>),
|
f: impl Fn(&mut OVector<T, R>, VectorView<'_, T, R, S::RStride, S::CStride>),
|
||||||
) -> OVector<T, R>
|
) -> OVector<T, R>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R>,
|
DefaultAllocator: Allocator<R>,
|
||||||
{
|
{
|
||||||
let mut res = init;
|
let mut res = init;
|
||||||
|
|
||||||
|
@ -133,7 +133,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
pub fn row_sum(&self) -> RowOVector<T, C>
|
pub fn row_sum(&self) -> RowOVector<T, C>
|
||||||
where
|
where
|
||||||
T: ClosedAdd + Zero,
|
T: ClosedAdd + Zero,
|
||||||
DefaultAllocator: Allocator<T, U1, C>,
|
DefaultAllocator: Allocator<U1, C>,
|
||||||
{
|
{
|
||||||
self.compress_rows(|col| col.sum())
|
self.compress_rows(|col| col.sum())
|
||||||
}
|
}
|
||||||
|
@ -160,7 +160,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
pub fn row_sum_tr(&self) -> OVector<T, C>
|
pub fn row_sum_tr(&self) -> OVector<T, C>
|
||||||
where
|
where
|
||||||
T: ClosedAdd + Zero,
|
T: ClosedAdd + Zero,
|
||||||
DefaultAllocator: Allocator<T, C>,
|
DefaultAllocator: Allocator<C>,
|
||||||
{
|
{
|
||||||
self.compress_rows_tr(|col| col.sum())
|
self.compress_rows_tr(|col| col.sum())
|
||||||
}
|
}
|
||||||
|
@ -187,7 +187,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
pub fn column_sum(&self) -> OVector<T, R>
|
pub fn column_sum(&self) -> OVector<T, R>
|
||||||
where
|
where
|
||||||
T: ClosedAdd + Zero,
|
T: ClosedAdd + Zero,
|
||||||
DefaultAllocator: Allocator<T, R>,
|
DefaultAllocator: Allocator<R>,
|
||||||
{
|
{
|
||||||
let nrows = self.shape_generic().0;
|
let nrows = self.shape_generic().0;
|
||||||
self.compress_columns(OVector::zeros_generic(nrows, Const::<1>), |out, col| {
|
self.compress_columns(OVector::zeros_generic(nrows, Const::<1>), |out, col| {
|
||||||
|
@ -244,7 +244,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
pub fn row_product(&self) -> RowOVector<T, C>
|
pub fn row_product(&self) -> RowOVector<T, C>
|
||||||
where
|
where
|
||||||
T: ClosedMul + One,
|
T: ClosedMul + One,
|
||||||
DefaultAllocator: Allocator<T, U1, C>,
|
DefaultAllocator: Allocator<U1, C>,
|
||||||
{
|
{
|
||||||
self.compress_rows(|col| col.product())
|
self.compress_rows(|col| col.product())
|
||||||
}
|
}
|
||||||
|
@ -271,7 +271,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
pub fn row_product_tr(&self) -> OVector<T, C>
|
pub fn row_product_tr(&self) -> OVector<T, C>
|
||||||
where
|
where
|
||||||
T: ClosedMul + One,
|
T: ClosedMul + One,
|
||||||
DefaultAllocator: Allocator<T, C>,
|
DefaultAllocator: Allocator<C>,
|
||||||
{
|
{
|
||||||
self.compress_rows_tr(|col| col.product())
|
self.compress_rows_tr(|col| col.product())
|
||||||
}
|
}
|
||||||
|
@ -298,7 +298,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
pub fn column_product(&self) -> OVector<T, R>
|
pub fn column_product(&self) -> OVector<T, R>
|
||||||
where
|
where
|
||||||
T: ClosedMul + One,
|
T: ClosedMul + One,
|
||||||
DefaultAllocator: Allocator<T, R>,
|
DefaultAllocator: Allocator<R>,
|
||||||
{
|
{
|
||||||
let nrows = self.shape_generic().0;
|
let nrows = self.shape_generic().0;
|
||||||
self.compress_columns(
|
self.compress_columns(
|
||||||
|
@ -361,7 +361,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
pub fn row_variance(&self) -> RowOVector<T, C>
|
pub fn row_variance(&self) -> RowOVector<T, C>
|
||||||
where
|
where
|
||||||
T: Field + SupersetOf<f64>,
|
T: Field + SupersetOf<f64>,
|
||||||
DefaultAllocator: Allocator<T, U1, C>,
|
DefaultAllocator: Allocator<U1, C>,
|
||||||
{
|
{
|
||||||
self.compress_rows(|col| col.variance())
|
self.compress_rows(|col| col.variance())
|
||||||
}
|
}
|
||||||
|
@ -382,7 +382,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
pub fn row_variance_tr(&self) -> OVector<T, C>
|
pub fn row_variance_tr(&self) -> OVector<T, C>
|
||||||
where
|
where
|
||||||
T: Field + SupersetOf<f64>,
|
T: Field + SupersetOf<f64>,
|
||||||
DefaultAllocator: Allocator<T, C>,
|
DefaultAllocator: Allocator<C>,
|
||||||
{
|
{
|
||||||
self.compress_rows_tr(|col| col.variance())
|
self.compress_rows_tr(|col| col.variance())
|
||||||
}
|
}
|
||||||
|
@ -404,7 +404,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
pub fn column_variance(&self) -> OVector<T, R>
|
pub fn column_variance(&self) -> OVector<T, R>
|
||||||
where
|
where
|
||||||
T: Field + SupersetOf<f64>,
|
T: Field + SupersetOf<f64>,
|
||||||
DefaultAllocator: Allocator<T, R>,
|
DefaultAllocator: Allocator<R>,
|
||||||
{
|
{
|
||||||
let (nrows, ncols) = self.shape_generic();
|
let (nrows, ncols) = self.shape_generic();
|
||||||
|
|
||||||
|
@ -469,7 +469,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
pub fn row_mean(&self) -> RowOVector<T, C>
|
pub fn row_mean(&self) -> RowOVector<T, C>
|
||||||
where
|
where
|
||||||
T: Field + SupersetOf<f64>,
|
T: Field + SupersetOf<f64>,
|
||||||
DefaultAllocator: Allocator<T, U1, C>,
|
DefaultAllocator: Allocator<U1, C>,
|
||||||
{
|
{
|
||||||
self.compress_rows(|col| col.mean())
|
self.compress_rows(|col| col.mean())
|
||||||
}
|
}
|
||||||
|
@ -490,7 +490,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
pub fn row_mean_tr(&self) -> OVector<T, C>
|
pub fn row_mean_tr(&self) -> OVector<T, C>
|
||||||
where
|
where
|
||||||
T: Field + SupersetOf<f64>,
|
T: Field + SupersetOf<f64>,
|
||||||
DefaultAllocator: Allocator<T, C>,
|
DefaultAllocator: Allocator<C>,
|
||||||
{
|
{
|
||||||
self.compress_rows_tr(|col| col.mean())
|
self.compress_rows_tr(|col| col.mean())
|
||||||
}
|
}
|
||||||
|
@ -511,7 +511,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
pub fn column_mean(&self) -> OVector<T, R>
|
pub fn column_mean(&self) -> OVector<T, R>
|
||||||
where
|
where
|
||||||
T: Field + SupersetOf<f64>,
|
T: Field + SupersetOf<f64>,
|
||||||
DefaultAllocator: Allocator<T, R>,
|
DefaultAllocator: Allocator<R>,
|
||||||
{
|
{
|
||||||
let (nrows, ncols) = self.shape_generic();
|
let (nrows, ncols) = self.shape_generic();
|
||||||
let denom = T::one() / crate::convert::<_, T>(ncols.value() as f64);
|
let denom = T::one() / crate::convert::<_, T>(ncols.value() as f64);
|
||||||
|
|
|
@ -12,22 +12,22 @@ use crate::base::Scalar;
|
||||||
*/
|
*/
|
||||||
/// The data storage for the sum of two matrices with dimensions `(R1, C1)` and `(R2, C2)`.
|
/// The data storage for the sum of two matrices with dimensions `(R1, C1)` and `(R2, C2)`.
|
||||||
pub type SameShapeStorage<T, R1, C1, R2, C2> =
|
pub type SameShapeStorage<T, R1, C1, R2, C2> =
|
||||||
<DefaultAllocator as Allocator<T, SameShapeR<R1, R2>, SameShapeC<C1, C2>>>::Buffer;
|
<DefaultAllocator as Allocator<SameShapeR<R1, R2>, SameShapeC<C1, C2>>>::Buffer<T>;
|
||||||
|
|
||||||
// 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 Allocator<T, R, C>>::Buffer;
|
pub type Owned<T, R, C = U1> = <DefaultAllocator as Allocator<R, C>>::Buffer<T>;
|
||||||
|
|
||||||
/// The owned data storage that can be allocated from `S`.
|
/// The owned data storage that can be allocated from `S`.
|
||||||
pub type OwnedUninit<T, R, C = U1> = <DefaultAllocator as Allocator<T, R, C>>::BufferUninit;
|
pub type OwnedUninit<T, R, C = U1> = <DefaultAllocator as Allocator<R, C>>::BufferUninit<T>;
|
||||||
|
|
||||||
/// 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> =
|
||||||
<<DefaultAllocator as Allocator<T, R, C>>::Buffer as RawStorage<T, R, C>>::RStride;
|
<<DefaultAllocator as Allocator<R, C>>::Buffer<T> as RawStorage<T, R, C>>::RStride;
|
||||||
|
|
||||||
/// The column-stride of the owned data storage for a buffer of dimension `(R, C)`.
|
/// The column-stride of the owned data storage for a buffer of dimension `(R, C)`.
|
||||||
pub type CStride<T, R, C = U1> =
|
pub type CStride<T, R, C = U1> =
|
||||||
<<DefaultAllocator as Allocator<T, R, C>>::Buffer as RawStorage<T, R, C>>::CStride;
|
<<DefaultAllocator as Allocator<R, C>>::Buffer<T> as RawStorage<T, R, C>>::CStride;
|
||||||
|
|
||||||
/// The trait shared by all matrix data storage.
|
/// The trait shared by all matrix data storage.
|
||||||
///
|
///
|
||||||
|
@ -139,16 +139,16 @@ pub unsafe trait RawStorage<T, R: Dim, C: Dim = U1>: Sized {
|
||||||
/// should **not** allow the user to modify the size of the underlying buffer with safe methods
|
/// should **not** allow the user to modify the size of the underlying buffer with safe methods
|
||||||
/// (for example the `VecStorage::data_mut` method is unsafe because the user could change the
|
/// (for example the `VecStorage::data_mut` method is unsafe because the user could change the
|
||||||
/// vector's size so that it no longer contains enough elements: this will lead to UB.
|
/// vector's size so that it no longer contains enough elements: this will lead to UB.
|
||||||
pub unsafe trait Storage<T, R: Dim, C: Dim = U1>: RawStorage<T, R, C> {
|
pub unsafe trait Storage<T: Scalar, R: Dim, C: Dim = U1>: RawStorage<T, R, C> {
|
||||||
/// Builds a matrix data storage that does not contain any reference.
|
/// Builds a matrix data storage that does not contain any reference.
|
||||||
fn into_owned(self) -> Owned<T, R, C>
|
fn into_owned(self) -> Owned<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C>;
|
DefaultAllocator: Allocator<R, C>;
|
||||||
|
|
||||||
/// Clones this data storage to one that does not contain any reference.
|
/// Clones this data storage to one that does not contain any reference.
|
||||||
fn clone_owned(&self) -> Owned<T, R, C>
|
fn clone_owned(&self) -> Owned<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C>;
|
DefaultAllocator: Allocator<R, C>;
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Trait implemented by matrix data storage that can provide a mutable access to its elements.
|
/// Trait implemented by matrix data storage that can provide a mutable access to its elements.
|
||||||
|
@ -260,12 +260,12 @@ pub unsafe trait RawStorageMut<T, R: Dim, C: Dim = U1>: RawStorage<T, R, C> {
|
||||||
/// # Safety
|
/// # Safety
|
||||||
///
|
///
|
||||||
/// See safety note for `Storage`, `RawStorageMut`.
|
/// See safety note for `Storage`, `RawStorageMut`.
|
||||||
pub unsafe trait StorageMut<T, R: Dim, C: Dim = U1>:
|
pub unsafe trait StorageMut<T: Scalar, R: Dim, C: Dim = U1>:
|
||||||
Storage<T, R, C> + RawStorageMut<T, R, C>
|
Storage<T, R, C> + RawStorageMut<T, R, C>
|
||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
|
||||||
unsafe impl<S, T, R, C> StorageMut<T, R, C> for S
|
unsafe impl<S, T: Scalar, R, C> StorageMut<T, R, C> for S
|
||||||
where
|
where
|
||||||
R: Dim,
|
R: Dim,
|
||||||
C: Dim,
|
C: Dim,
|
||||||
|
|
|
@ -303,7 +303,7 @@ impl<T: Scalar + simba::simd::PrimitiveSimdValue, R: Dim, C: Dim>
|
||||||
where
|
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<R, C>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn from(arr: [Unit<OMatrix<T::Element, R, C>>; 2]) -> Self {
|
fn from(arr: [Unit<OMatrix<T::Element, R, C>>; 2]) -> Self {
|
||||||
|
@ -319,7 +319,7 @@ impl<T: Scalar + simba::simd::PrimitiveSimdValue, R: Dim, C: Dim>
|
||||||
where
|
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<R, C>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn from(arr: [Unit<OMatrix<T::Element, R, C>>; 4]) -> Self {
|
fn from(arr: [Unit<OMatrix<T::Element, R, C>>; 4]) -> Self {
|
||||||
|
@ -337,7 +337,7 @@ impl<T: Scalar + simba::simd::PrimitiveSimdValue, R: Dim, C: Dim>
|
||||||
where
|
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<R, C>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn from(arr: [Unit<OMatrix<T::Element, R, C>>; 8]) -> Self {
|
fn from(arr: [Unit<OMatrix<T::Element, R, C>>; 8]) -> Self {
|
||||||
|
@ -359,7 +359,7 @@ impl<T: Scalar + simba::simd::PrimitiveSimdValue, R: Dim, C: Dim>
|
||||||
where
|
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<R, C>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn from(arr: [Unit<OMatrix<T::Element, R, C>>; 16]) -> Self {
|
fn from(arr: [Unit<OMatrix<T::Element, R, C>>; 16]) -> Self {
|
||||||
|
|
|
@ -264,12 +264,12 @@ unsafe impl<T, C: Dim> RawStorage<T, Dyn, C> for VecStorage<T, Dyn, C> {
|
||||||
|
|
||||||
unsafe impl<T: Scalar, C: Dim> Storage<T, Dyn, C> for VecStorage<T, Dyn, C>
|
unsafe impl<T: Scalar, C: Dim> Storage<T, Dyn, C> for VecStorage<T, Dyn, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, Dyn, C, Buffer = Self>,
|
DefaultAllocator: Allocator<Dyn, C, Buffer<T> = Self>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn into_owned(self) -> Owned<T, Dyn, C>
|
fn into_owned(self) -> Owned<T, Dyn, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, Dyn, C>,
|
DefaultAllocator: Allocator<Dyn, C>,
|
||||||
{
|
{
|
||||||
self
|
self
|
||||||
}
|
}
|
||||||
|
@ -277,7 +277,7 @@ where
|
||||||
#[inline]
|
#[inline]
|
||||||
fn clone_owned(&self) -> Owned<T, Dyn, C>
|
fn clone_owned(&self) -> Owned<T, Dyn, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, Dyn, C>,
|
DefaultAllocator: Allocator<Dyn, C>,
|
||||||
{
|
{
|
||||||
self.clone()
|
self.clone()
|
||||||
}
|
}
|
||||||
|
@ -315,12 +315,12 @@ unsafe impl<T, R: DimName> RawStorage<T, R, Dyn> for VecStorage<T, R, Dyn> {
|
||||||
|
|
||||||
unsafe impl<T: Scalar, R: DimName> Storage<T, R, Dyn> for VecStorage<T, R, Dyn>
|
unsafe impl<T: Scalar, R: DimName> Storage<T, R, Dyn> for VecStorage<T, R, Dyn>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, Dyn, Buffer = Self>,
|
DefaultAllocator: Allocator<R, Dyn, Buffer<T> = Self>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn into_owned(self) -> Owned<T, R, Dyn>
|
fn into_owned(self) -> Owned<T, R, Dyn>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, Dyn>,
|
DefaultAllocator: Allocator<R, Dyn>,
|
||||||
{
|
{
|
||||||
self
|
self
|
||||||
}
|
}
|
||||||
|
@ -328,7 +328,7 @@ where
|
||||||
#[inline]
|
#[inline]
|
||||||
fn clone_owned(&self) -> Owned<T, R, Dyn>
|
fn clone_owned(&self) -> Owned<T, R, Dyn>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, Dyn>,
|
DefaultAllocator: Allocator<R, Dyn>,
|
||||||
{
|
{
|
||||||
self.clone()
|
self.clone()
|
||||||
}
|
}
|
||||||
|
|
|
@ -14,14 +14,14 @@ use simba::scalar::ComplexField;
|
||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
pub struct RandomOrthogonal<T: Scalar, D: Dim = Dyn>
|
pub struct RandomOrthogonal<T: Scalar, D: Dim = Dyn>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
m: OMatrix<T, D, D>,
|
m: OMatrix<T, D, D>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T: ComplexField, D: Dim> RandomOrthogonal<T, D>
|
impl<T: ComplexField, D: Dim> RandomOrthogonal<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
/// Retrieve the generated matrix.
|
/// Retrieve the generated matrix.
|
||||||
pub fn unwrap(self) -> OMatrix<T, D, D> {
|
pub fn unwrap(self) -> OMatrix<T, D, D> {
|
||||||
|
@ -45,7 +45,7 @@ where
|
||||||
#[cfg(feature = "arbitrary")]
|
#[cfg(feature = "arbitrary")]
|
||||||
impl<T: ComplexField + Arbitrary + Send, D: Dim> Arbitrary for RandomOrthogonal<T, D>
|
impl<T: ComplexField + Arbitrary + Send, D: Dim> Arbitrary for RandomOrthogonal<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
Owned<T, D, D>: Clone + Send,
|
Owned<T, D, D>: Clone + Send,
|
||||||
{
|
{
|
||||||
fn arbitrary(g: &mut Gen) -> Self {
|
fn arbitrary(g: &mut Gen) -> Self {
|
||||||
|
|
|
@ -15,14 +15,14 @@ use crate::debug::RandomOrthogonal;
|
||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
pub struct RandomSDP<T: Scalar, D: Dim = Dyn>
|
pub struct RandomSDP<T: Scalar, D: Dim = Dyn>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
m: OMatrix<T, D, D>,
|
m: OMatrix<T, D, D>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T: ComplexField, D: Dim> RandomSDP<T, D>
|
impl<T: ComplexField, D: Dim> RandomSDP<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
/// Retrieve the generated matrix.
|
/// Retrieve the generated matrix.
|
||||||
pub fn unwrap(self) -> OMatrix<T, D, D> {
|
pub fn unwrap(self) -> OMatrix<T, D, D> {
|
||||||
|
@ -48,7 +48,7 @@ where
|
||||||
#[cfg(feature = "arbitrary")]
|
#[cfg(feature = "arbitrary")]
|
||||||
impl<T: ComplexField + Arbitrary + Send, D: Dim> Arbitrary for RandomSDP<T, D>
|
impl<T: ComplexField + Arbitrary + Send, D: Dim> Arbitrary for RandomSDP<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
Owned<T, D, D>: Clone + Send,
|
Owned<T, D, D>: Clone + Send,
|
||||||
{
|
{
|
||||||
fn arbitrary(g: &mut Gen) -> Self {
|
fn arbitrary(g: &mut Gen) -> Self {
|
||||||
|
|
|
@ -58,14 +58,14 @@ use rkyv::bytecheck;
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(serialize = "R: Serialize,
|
serde(bound(serialize = "R: Serialize,
|
||||||
DefaultAllocator: Allocator<T, Const<D>>,
|
DefaultAllocator: Allocator<Const<D>>,
|
||||||
Owned<T, Const<D>>: Serialize,
|
Owned<T, Const<D>>: Serialize,
|
||||||
T: Scalar"))
|
T: Scalar"))
|
||||||
)]
|
)]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(deserialize = "R: Deserialize<'de>,
|
serde(bound(deserialize = "R: Deserialize<'de>,
|
||||||
DefaultAllocator: Allocator<T, Const<D>>,
|
DefaultAllocator: Allocator<Const<D>>,
|
||||||
Owned<T, Const<D>>: Deserialize<'de>,
|
Owned<T, Const<D>>: Deserialize<'de>,
|
||||||
T: Scalar"))
|
T: Scalar"))
|
||||||
)]
|
)]
|
||||||
|
@ -433,7 +433,7 @@ impl<T: SimdRealField, R, const D: usize> Isometry<T, R, D> {
|
||||||
where
|
where
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
|
R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
{
|
{
|
||||||
let mut res: OMatrix<T, _, _> = crate::convert_ref(&self.rotation);
|
let mut res: OMatrix<T, _, _> = crate::convert_ref(&self.rotation);
|
||||||
res.fixed_view_mut::<D, 1>(0, D)
|
res.fixed_view_mut::<D, 1>(0, D)
|
||||||
|
@ -465,7 +465,7 @@ impl<T: SimdRealField, R, const D: usize> Isometry<T, R, D> {
|
||||||
where
|
where
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
|
R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
{
|
{
|
||||||
self.to_homogeneous()
|
self.to_homogeneous()
|
||||||
}
|
}
|
||||||
|
|
|
@ -9,7 +9,7 @@ use crate::geometry::{
|
||||||
AbstractRotation, Isometry, Isometry3, Similarity, SuperTCategoryOf, TAffine, Transform,
|
AbstractRotation, Isometry, Isometry3, Similarity, SuperTCategoryOf, TAffine, Transform,
|
||||||
Translation, UnitDualQuaternion, UnitQuaternion,
|
Translation, UnitDualQuaternion, UnitQuaternion,
|
||||||
};
|
};
|
||||||
use crate::{Point, SVector};
|
use crate::{ArrayStorage, Point, SVector};
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* This file provides the following conversions:
|
* This file provides the following conversions:
|
||||||
|
@ -105,13 +105,11 @@ where
|
||||||
+ SubsetOf<OMatrix<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>
|
+ SubsetOf<OMatrix<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>
|
||||||
+ SubsetOf<OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
|
+ SubsetOf<OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
|
||||||
Const<D>: DimNameAdd<U1> + DimMin<Const<D>, Output = Const<D>>, // needed by .is_special_orthogonal()
|
Const<D>: DimNameAdd<U1> + DimMin<Const<D>, Output = Const<D>>, // needed by .is_special_orthogonal()
|
||||||
DefaultAllocator: Allocator<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
+ Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
|
||||||
+ Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
|
||||||
// + Allocator<T1, D>
|
// + Allocator<T1, D>
|
||||||
// + Allocator<(usize, usize), D>
|
// + Allocator<D>
|
||||||
// + Allocator<T2, D, D>
|
// + Allocator<D, D>
|
||||||
// + Allocator<T2, D>
|
// + Allocator<D>
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn to_superset(&self) -> Transform<T2, C, D> {
|
fn to_superset(&self) -> Transform<T2, C, D> {
|
||||||
|
@ -138,13 +136,8 @@ where
|
||||||
+ SubsetOf<OMatrix<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>
|
+ SubsetOf<OMatrix<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>
|
||||||
+ SubsetOf<OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
|
+ SubsetOf<OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
|
||||||
Const<D>: DimNameAdd<U1> + DimMin<Const<D>, Output = Const<D>>, // needed by .is_special_orthogonal()
|
Const<D>: DimNameAdd<U1> + DimMin<Const<D>, Output = Const<D>>, // needed by .is_special_orthogonal()
|
||||||
DefaultAllocator: Allocator<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
DefaultAllocator: Allocator<Const<D>, Const<1>, Buffer<T1> = ArrayStorage<T1, D, 1>>
|
||||||
+ Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
+ Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
+ Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>, // + Allocator<(usize, usize), D>
|
|
||||||
// + Allocator<T2, D, D>
|
|
||||||
// + Allocator<T2, D>
|
|
||||||
// + Allocator<T1, D>
|
|
||||||
// + Allocator<T1, D, D>
|
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn to_superset(&self) -> OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> {
|
fn to_superset(&self) -> OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> {
|
||||||
|
@ -191,7 +184,7 @@ impl<T: SimdRealField, R, const D: usize> From<Isometry<T, R, D>>
|
||||||
where
|
where
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
|
R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>, // + Allocator<T, D>,
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>, // + Allocator<D>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn from(iso: Isometry<T, R, D>) -> Self {
|
fn from(iso: Isometry<T, R, D>) -> Self {
|
||||||
|
|
|
@ -49,13 +49,13 @@ use std::mem::MaybeUninit;
|
||||||
T: rkyv::Archive,
|
T: rkyv::Archive,
|
||||||
T::Archived: Scalar,
|
T::Archived: Scalar,
|
||||||
OVector<T, D>: rkyv::Archive<Archived = OVector<T::Archived, D>>,
|
OVector<T, D>: rkyv::Archive<Archived = OVector<T::Archived, D>>,
|
||||||
DefaultAllocator: Allocator<T::Archived, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
")
|
")
|
||||||
)
|
)
|
||||||
)]
|
)]
|
||||||
pub struct OPoint<T: Scalar, D: DimName>
|
pub struct OPoint<T: Scalar, D: DimName>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
/// The coordinates of this point, i.e., the shift from the origin.
|
/// The coordinates of this point, i.e., the shift from the origin.
|
||||||
pub coords: OVector<T, D>,
|
pub coords: OVector<T, D>,
|
||||||
|
@ -63,7 +63,7 @@ where
|
||||||
|
|
||||||
impl<T: Scalar + fmt::Debug, D: DimName> fmt::Debug for OPoint<T, D>
|
impl<T: Scalar + fmt::Debug, D: DimName> fmt::Debug for OPoint<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
|
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
|
||||||
self.coords.as_slice().fmt(formatter)
|
self.coords.as_slice().fmt(formatter)
|
||||||
|
@ -72,7 +72,7 @@ where
|
||||||
|
|
||||||
impl<T: Scalar + hash::Hash, D: DimName> hash::Hash for OPoint<T, D>
|
impl<T: Scalar + hash::Hash, D: DimName> hash::Hash for OPoint<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
fn hash<H: hash::Hasher>(&self, state: &mut H) {
|
fn hash<H: hash::Hasher>(&self, state: &mut H) {
|
||||||
self.coords.hash(state)
|
self.coords.hash(state)
|
||||||
|
@ -81,7 +81,7 @@ where
|
||||||
|
|
||||||
impl<T: Scalar + Copy, D: DimName> Copy for OPoint<T, D>
|
impl<T: Scalar + Copy, D: DimName> Copy for OPoint<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
OVector<T, D>: Copy,
|
OVector<T, D>: Copy,
|
||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
@ -90,7 +90,7 @@ where
|
||||||
unsafe impl<T: Scalar, D: DimName> bytemuck::Zeroable for OPoint<T, D>
|
unsafe impl<T: Scalar, D: DimName> bytemuck::Zeroable for OPoint<T, D>
|
||||||
where
|
where
|
||||||
OVector<T, D>: bytemuck::Zeroable,
|
OVector<T, D>: bytemuck::Zeroable,
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -99,15 +99,15 @@ unsafe impl<T: Scalar, D: DimName> bytemuck::Pod for OPoint<T, D>
|
||||||
where
|
where
|
||||||
T: Copy,
|
T: Copy,
|
||||||
OVector<T, D>: bytemuck::Pod,
|
OVector<T, D>: bytemuck::Pod,
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
|
||||||
#[cfg(feature = "serde-serialize-no-std")]
|
#[cfg(feature = "serde-serialize-no-std")]
|
||||||
impl<T: Scalar, D: DimName> Serialize for OPoint<T, D>
|
impl<T: Scalar, D: DimName> Serialize for OPoint<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
<DefaultAllocator as Allocator<T, D>>::Buffer: Serialize,
|
<DefaultAllocator as Allocator<D>>::Buffer<T>: 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
|
||||||
|
@ -120,8 +120,8 @@ where
|
||||||
#[cfg(feature = "serde-serialize-no-std")]
|
#[cfg(feature = "serde-serialize-no-std")]
|
||||||
impl<'a, T: Scalar, D: DimName> Deserialize<'a> for OPoint<T, D>
|
impl<'a, T: Scalar, D: DimName> Deserialize<'a> for OPoint<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
<DefaultAllocator as Allocator<T, D>>::Buffer: Deserialize<'a>,
|
<DefaultAllocator as Allocator<D>>::Buffer<T>: Deserialize<'a>,
|
||||||
{
|
{
|
||||||
fn deserialize<Des>(deserializer: Des) -> Result<Self, Des::Error>
|
fn deserialize<Des>(deserializer: Des) -> Result<Self, Des::Error>
|
||||||
where
|
where
|
||||||
|
@ -135,7 +135,7 @@ where
|
||||||
|
|
||||||
impl<T: Scalar, D: DimName> OPoint<T, D>
|
impl<T: Scalar, D: DimName> OPoint<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
/// Returns a point containing the result of `f` applied to each of its entries.
|
/// Returns a point containing the result of `f` applied to each of its entries.
|
||||||
///
|
///
|
||||||
|
@ -153,7 +153,7 @@ where
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn map<T2: Scalar, F: FnMut(T) -> T2>(&self, f: F) -> OPoint<T2, D>
|
pub fn map<T2: Scalar, F: FnMut(T) -> T2>(&self, f: F) -> OPoint<T2, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T2, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
self.coords.map(f).into()
|
self.coords.map(f).into()
|
||||||
}
|
}
|
||||||
|
@ -198,7 +198,7 @@ where
|
||||||
where
|
where
|
||||||
T: One,
|
T: One,
|
||||||
D: DimNameAdd<U1>,
|
D: DimNameAdd<U1>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<D, U1>>,
|
DefaultAllocator: Allocator<DimNameSum<D, U1>>,
|
||||||
{
|
{
|
||||||
// TODO: this is mostly a copy-past from Vector::push.
|
// TODO: this is mostly a copy-past from Vector::push.
|
||||||
// But we can’t use Vector::push because of the DimAdd bound
|
// But we can’t use Vector::push because of the DimAdd bound
|
||||||
|
@ -304,7 +304,7 @@ where
|
||||||
#[inline]
|
#[inline]
|
||||||
pub fn iter(
|
pub fn iter(
|
||||||
&self,
|
&self,
|
||||||
) -> MatrixIter<'_, T, D, Const<1>, <DefaultAllocator as Allocator<T, D>>::Buffer> {
|
) -> MatrixIter<'_, T, D, Const<1>, <DefaultAllocator as Allocator<D>>::Buffer<T>> {
|
||||||
self.coords.iter()
|
self.coords.iter()
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -335,7 +335,7 @@ where
|
||||||
#[inline]
|
#[inline]
|
||||||
pub fn iter_mut(
|
pub fn iter_mut(
|
||||||
&mut self,
|
&mut self,
|
||||||
) -> MatrixIterMut<'_, T, D, Const<1>, <DefaultAllocator as Allocator<T, D>>::Buffer> {
|
) -> MatrixIterMut<'_, T, D, Const<1>, <DefaultAllocator as Allocator<D>>::Buffer<T>> {
|
||||||
self.coords.iter_mut()
|
self.coords.iter_mut()
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -364,7 +364,7 @@ where
|
||||||
impl<T: Scalar + AbsDiffEq, D: DimName> AbsDiffEq for OPoint<T, D>
|
impl<T: Scalar + AbsDiffEq, D: DimName> AbsDiffEq for OPoint<T, D>
|
||||||
where
|
where
|
||||||
T::Epsilon: Clone,
|
T::Epsilon: Clone,
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
type Epsilon = T::Epsilon;
|
type Epsilon = T::Epsilon;
|
||||||
|
|
||||||
|
@ -382,7 +382,7 @@ where
|
||||||
impl<T: Scalar + RelativeEq, D: DimName> RelativeEq for OPoint<T, D>
|
impl<T: Scalar + RelativeEq, D: DimName> RelativeEq for OPoint<T, D>
|
||||||
where
|
where
|
||||||
T::Epsilon: Clone,
|
T::Epsilon: Clone,
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn default_max_relative() -> Self::Epsilon {
|
fn default_max_relative() -> Self::Epsilon {
|
||||||
|
@ -404,7 +404,7 @@ where
|
||||||
impl<T: Scalar + UlpsEq, D: DimName> UlpsEq for OPoint<T, D>
|
impl<T: Scalar + UlpsEq, D: DimName> UlpsEq for OPoint<T, D>
|
||||||
where
|
where
|
||||||
T::Epsilon: Clone,
|
T::Epsilon: Clone,
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn default_max_ulps() -> u32 {
|
fn default_max_ulps() -> u32 {
|
||||||
|
@ -417,11 +417,11 @@ where
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T: Scalar + Eq, D: DimName> Eq for OPoint<T, D> where DefaultAllocator: Allocator<T, D> {}
|
impl<T: Scalar + Eq, D: DimName> Eq for OPoint<T, D> where DefaultAllocator: Allocator<D> {}
|
||||||
|
|
||||||
impl<T: Scalar, D: DimName> PartialEq for OPoint<T, D>
|
impl<T: Scalar, D: DimName> PartialEq for OPoint<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn eq(&self, right: &Self) -> bool {
|
fn eq(&self, right: &Self) -> bool {
|
||||||
|
@ -431,7 +431,7 @@ where
|
||||||
|
|
||||||
impl<T: Scalar + PartialOrd, D: DimName> PartialOrd for OPoint<T, D>
|
impl<T: Scalar + PartialOrd, D: DimName> PartialOrd for OPoint<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
|
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
|
||||||
|
@ -464,7 +464,7 @@ where
|
||||||
*/
|
*/
|
||||||
impl<T: Scalar + SimdPartialOrd, D: DimName> OPoint<T, D>
|
impl<T: Scalar + SimdPartialOrd, D: DimName> OPoint<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
/// Computes the infimum (aka. componentwise min) of two points.
|
/// Computes the infimum (aka. componentwise min) of two points.
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -496,7 +496,7 @@ where
|
||||||
*/
|
*/
|
||||||
impl<T: Scalar + fmt::Display, D: DimName> fmt::Display for OPoint<T, D>
|
impl<T: Scalar + fmt::Display, D: DimName> fmt::Display for OPoint<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||||
write!(f, "{{")?;
|
write!(f, "{{")?;
|
||||||
|
|
|
@ -21,7 +21,7 @@ use crate::geometry::Point;
|
||||||
|
|
||||||
impl<T: Scalar + Zero, D: DimName> Default for OPoint<T, D>
|
impl<T: Scalar + Zero, D: DimName> Default for OPoint<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
fn default() -> Self {
|
fn default() -> Self {
|
||||||
Self::origin()
|
Self::origin()
|
||||||
|
@ -31,7 +31,7 @@ where
|
||||||
/// # Other construction methods
|
/// # Other construction methods
|
||||||
impl<T: Scalar, D: DimName> OPoint<T, D>
|
impl<T: Scalar, D: DimName> OPoint<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
/// Creates a new point with all coordinates equal to zero.
|
/// Creates a new point with all coordinates equal to zero.
|
||||||
///
|
///
|
||||||
|
@ -110,7 +110,7 @@ where
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + One + ClosedDiv,
|
T: Scalar + Zero + One + ClosedDiv,
|
||||||
D: DimNameAdd<U1>,
|
D: DimNameAdd<U1>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<D, U1>>,
|
DefaultAllocator: Allocator<DimNameSum<D, U1>>,
|
||||||
{
|
{
|
||||||
if !v[D::dim()].is_zero() {
|
if !v[D::dim()].is_zero() {
|
||||||
let coords = v.generic_view((0, 0), (D::name(), Const::<1>)) / v[D::dim()].clone();
|
let coords = v.generic_view((0, 0), (D::name(), Const::<1>)) / v[D::dim()].clone();
|
||||||
|
@ -132,7 +132,7 @@ where
|
||||||
pub fn cast<To: Scalar>(self) -> OPoint<To, D>
|
pub fn cast<To: Scalar>(self) -> OPoint<To, D>
|
||||||
where
|
where
|
||||||
OPoint<To, D>: SupersetOf<Self>,
|
OPoint<To, D>: SupersetOf<Self>,
|
||||||
DefaultAllocator: Allocator<To, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
crate::convert(self)
|
crate::convert(self)
|
||||||
}
|
}
|
||||||
|
@ -145,7 +145,7 @@ where
|
||||||
*/
|
*/
|
||||||
impl<T: Scalar + Bounded, D: DimName> Bounded for OPoint<T, D>
|
impl<T: Scalar + Bounded, D: DimName> Bounded for OPoint<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn max_value() -> Self {
|
fn max_value() -> Self {
|
||||||
|
@ -162,7 +162,7 @@ where
|
||||||
impl<T: Scalar, D: DimName> Distribution<OPoint<T, D>> for Standard
|
impl<T: Scalar, D: DimName> Distribution<OPoint<T, D>> for Standard
|
||||||
where
|
where
|
||||||
Standard: Distribution<T>,
|
Standard: Distribution<T>,
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
/// Generate a `Point` where each coordinate is an independent variate from `[0, 1)`.
|
/// Generate a `Point` where each coordinate is an independent variate from `[0, 1)`.
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -174,8 +174,8 @@ where
|
||||||
#[cfg(feature = "arbitrary")]
|
#[cfg(feature = "arbitrary")]
|
||||||
impl<T: Scalar + Arbitrary + Send, D: DimName> Arbitrary for OPoint<T, D>
|
impl<T: Scalar + Arbitrary + Send, D: DimName> Arbitrary for OPoint<T, D>
|
||||||
where
|
where
|
||||||
<DefaultAllocator as Allocator<T, D>>::Buffer: Send,
|
<DefaultAllocator as Allocator<D>>::Buffer<T>: Send,
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn arbitrary(g: &mut Gen) -> Self {
|
fn arbitrary(g: &mut Gen) -> Self {
|
||||||
|
|
|
@ -21,7 +21,7 @@ impl<T1, T2, D: DimName> SubsetOf<OPoint<T2, D>> for OPoint<T1, D>
|
||||||
where
|
where
|
||||||
T1: Scalar,
|
T1: Scalar,
|
||||||
T2: Scalar + SupersetOf<T1>,
|
T2: Scalar + SupersetOf<T1>,
|
||||||
DefaultAllocator: Allocator<T1, D> + Allocator<T2, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn to_superset(&self) -> OPoint<T2, D> {
|
fn to_superset(&self) -> OPoint<T2, D> {
|
||||||
|
@ -46,12 +46,9 @@ where
|
||||||
D: DimNameAdd<U1>,
|
D: DimNameAdd<U1>,
|
||||||
T1: Scalar,
|
T1: Scalar,
|
||||||
T2: Scalar + Zero + One + ClosedDiv + SupersetOf<T1>,
|
T2: Scalar + Zero + One + ClosedDiv + SupersetOf<T1>,
|
||||||
DefaultAllocator: Allocator<T1, D>
|
DefaultAllocator: Allocator<D> + Allocator<DimNameSum<D, U1>>,
|
||||||
+ Allocator<T2, D>
|
|
||||||
+ Allocator<T1, DimNameSum<D, U1>>
|
|
||||||
+ Allocator<T2, DimNameSum<D, U1>>,
|
|
||||||
// + Allocator<T1, D>
|
// + Allocator<T1, D>
|
||||||
// + Allocator<T2, D>,
|
// + Allocator<D>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn to_superset(&self) -> OVector<T2, DimNameSum<D, U1>> {
|
fn to_superset(&self) -> OVector<T2, DimNameSum<D, U1>> {
|
||||||
|
@ -76,7 +73,7 @@ where
|
||||||
impl<T: Scalar + Zero + One, D: DimName> From<OPoint<T, D>> for OVector<T, DimNameSum<D, U1>>
|
impl<T: Scalar + Zero + One, D: DimName> From<OPoint<T, D>> for OVector<T, DimNameSum<D, U1>>
|
||||||
where
|
where
|
||||||
D: DimNameAdd<U1>,
|
D: DimNameAdd<U1>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<D, U1>> + Allocator<T, D>,
|
DefaultAllocator: Allocator<DimNameSum<D, U1>> + Allocator<D>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn from(t: OPoint<T, D>) -> Self {
|
fn from(t: OPoint<T, D>) -> Self {
|
||||||
|
@ -102,7 +99,7 @@ impl<T: Scalar, const D: usize> From<Point<T, D>> for [T; D] {
|
||||||
|
|
||||||
impl<T: Scalar, D: DimName> From<OVector<T, D>> for OPoint<T, D>
|
impl<T: Scalar, D: DimName> From<OVector<T, D>> for OPoint<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn from(coords: OVector<T, D>) -> Self {
|
fn from(coords: OVector<T, D>) -> Self {
|
||||||
|
@ -115,7 +112,7 @@ impl<T: Scalar + Copy + PrimitiveSimdValue, const D: usize> From<[Point<T::Eleme
|
||||||
where
|
where
|
||||||
T: From<[<T as simba::simd::SimdValue>::Element; 2]>,
|
T: From<[<T as simba::simd::SimdValue>::Element; 2]>,
|
||||||
T::Element: Scalar + Copy,
|
T::Element: Scalar + Copy,
|
||||||
<DefaultAllocator as Allocator<T::Element, Const<D>>>::Buffer: Copy,
|
<DefaultAllocator as Allocator<Const<D>>>::Buffer<T::Element>: Copy,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn from(arr: [Point<T::Element, D>; 2]) -> Self {
|
fn from(arr: [Point<T::Element, D>; 2]) -> Self {
|
||||||
|
@ -128,7 +125,7 @@ impl<T: Scalar + Copy + PrimitiveSimdValue, const D: usize> From<[Point<T::Eleme
|
||||||
where
|
where
|
||||||
T: From<[<T as simba::simd::SimdValue>::Element; 4]>,
|
T: From<[<T as simba::simd::SimdValue>::Element; 4]>,
|
||||||
T::Element: Scalar + Copy,
|
T::Element: Scalar + Copy,
|
||||||
<DefaultAllocator as Allocator<T::Element, Const<D>>>::Buffer: Copy,
|
<DefaultAllocator as Allocator<Const<D>>>::Buffer<T::Element>: Copy,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn from(arr: [Point<T::Element, D>; 4]) -> Self {
|
fn from(arr: [Point<T::Element, D>; 4]) -> Self {
|
||||||
|
@ -146,7 +143,7 @@ impl<T: Scalar + Copy + PrimitiveSimdValue, const D: usize> From<[Point<T::Eleme
|
||||||
where
|
where
|
||||||
T: From<[<T as simba::simd::SimdValue>::Element; 8]>,
|
T: From<[<T as simba::simd::SimdValue>::Element; 8]>,
|
||||||
T::Element: Scalar + Copy,
|
T::Element: Scalar + Copy,
|
||||||
<DefaultAllocator as Allocator<T::Element, Const<D>>>::Buffer: Copy,
|
<DefaultAllocator as Allocator<Const<D>>>::Buffer<T::Element>: Copy,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn from(arr: [Point<T::Element, D>; 8]) -> Self {
|
fn from(arr: [Point<T::Element, D>; 8]) -> Self {
|
||||||
|
@ -168,7 +165,7 @@ impl<T: Scalar + Copy + PrimitiveSimdValue, const D: usize> From<[Point<T::Eleme
|
||||||
where
|
where
|
||||||
T: From<[<T as simba::simd::SimdValue>::Element; 16]>,
|
T: From<[<T as simba::simd::SimdValue>::Element; 16]>,
|
||||||
T::Element: Scalar + Copy,
|
T::Element: Scalar + Copy,
|
||||||
<DefaultAllocator as Allocator<T::Element, Const<D>>>::Buffer: Copy,
|
<DefaultAllocator as Allocator<Const<D>>>::Buffer<T::Element>: Copy,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn from(arr: [Point<T::Element, D>; 16]) -> Self {
|
fn from(arr: [Point<T::Element, D>; 16]) -> Self {
|
||||||
|
|
|
@ -23,7 +23,7 @@ use crate::DefaultAllocator;
|
||||||
*/
|
*/
|
||||||
impl<T: Scalar, D: DimName> Index<usize> for OPoint<T, D>
|
impl<T: Scalar, D: DimName> Index<usize> for OPoint<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
type Output = T;
|
type Output = T;
|
||||||
|
|
||||||
|
@ -35,7 +35,7 @@ where
|
||||||
|
|
||||||
impl<T: Scalar, D: DimName> IndexMut<usize> for OPoint<T, D>
|
impl<T: Scalar, D: DimName> IndexMut<usize> for OPoint<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn index_mut(&mut self, i: usize) -> &mut Self::Output {
|
fn index_mut(&mut self, i: usize) -> &mut Self::Output {
|
||||||
|
@ -50,7 +50,7 @@ where
|
||||||
*/
|
*/
|
||||||
impl<T: Scalar + ClosedNeg, D: DimName> Neg for OPoint<T, D>
|
impl<T: Scalar + ClosedNeg, D: DimName> Neg for OPoint<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
type Output = Self;
|
type Output = Self;
|
||||||
|
|
||||||
|
@ -62,7 +62,7 @@ where
|
||||||
|
|
||||||
impl<'a, T: Scalar + ClosedNeg, D: DimName> Neg for &'a OPoint<T, D>
|
impl<'a, T: Scalar + ClosedNeg, D: DimName> Neg for &'a OPoint<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
type Output = OPoint<T, D>;
|
type Output = OPoint<T, D>;
|
||||||
|
|
||||||
|
@ -81,25 +81,25 @@ where
|
||||||
// Point - Point
|
// Point - Point
|
||||||
add_sub_impl!(Sub, sub, ClosedSub;
|
add_sub_impl!(Sub, sub, ClosedSub;
|
||||||
(D, U1), (D, U1) -> (D, U1)
|
(D, U1), (D, U1) -> (D, U1)
|
||||||
const; for D; where D: DimName, DefaultAllocator: Allocator<T, D>;
|
const; for D; where D: DimName, DefaultAllocator: Allocator<D>;
|
||||||
self: &'a OPoint<T, D>, right: &'b OPoint<T, D>, Output = OVector<T, D>;
|
self: &'a OPoint<T, D>, right: &'b OPoint<T, D>, Output = OVector<T, D>;
|
||||||
&self.coords - &right.coords; 'a, 'b);
|
&self.coords - &right.coords; 'a, 'b);
|
||||||
|
|
||||||
add_sub_impl!(Sub, sub, ClosedSub;
|
add_sub_impl!(Sub, sub, ClosedSub;
|
||||||
(D, U1), (D, U1) -> (D, U1)
|
(D, U1), (D, U1) -> (D, U1)
|
||||||
const; for D; where D: DimName, DefaultAllocator: Allocator<T, D>;
|
const; for D; where D: DimName, DefaultAllocator: Allocator<D>;
|
||||||
self: &'a OPoint<T, D>, right: OPoint<T, D>, Output = OVector<T, D>;
|
self: &'a OPoint<T, D>, right: OPoint<T, D>, Output = OVector<T, D>;
|
||||||
&self.coords - right.coords; 'a);
|
&self.coords - right.coords; 'a);
|
||||||
|
|
||||||
add_sub_impl!(Sub, sub, ClosedSub;
|
add_sub_impl!(Sub, sub, ClosedSub;
|
||||||
(D, U1), (D, U1) -> (D, U1)
|
(D, U1), (D, U1) -> (D, U1)
|
||||||
const; for D; where D: DimName, DefaultAllocator: Allocator<T, D>;
|
const; for D; where D: DimName, DefaultAllocator: Allocator<D>;
|
||||||
self: OPoint<T, D>, right: &'b OPoint<T, D>, Output = OVector<T, D>;
|
self: OPoint<T, D>, right: &'b OPoint<T, D>, Output = OVector<T, D>;
|
||||||
self.coords - &right.coords; 'b);
|
self.coords - &right.coords; 'b);
|
||||||
|
|
||||||
add_sub_impl!(Sub, sub, ClosedSub;
|
add_sub_impl!(Sub, sub, ClosedSub;
|
||||||
(D, U1), (D, U1) -> (D, U1)
|
(D, U1), (D, U1) -> (D, U1)
|
||||||
const; for D; where D: DimName, DefaultAllocator: Allocator<T, D>;
|
const; for D; where D: DimName, DefaultAllocator: Allocator<D>;
|
||||||
self: OPoint<T, D>, right: OPoint<T, D>, Output = OVector<T, D>;
|
self: OPoint<T, D>, right: OPoint<T, D>, Output = OVector<T, D>;
|
||||||
self.coords - right.coords; );
|
self.coords - right.coords; );
|
||||||
|
|
||||||
|
@ -108,7 +108,7 @@ add_sub_impl!(Sub, sub, ClosedSub;
|
||||||
(D1, U1), (D2, U1) -> (D1, U1)
|
(D1, U1), (D2, U1) -> (D1, U1)
|
||||||
const;
|
const;
|
||||||
for D1, D2, SB;
|
for D1, D2, SB;
|
||||||
where D1: DimName, D2: Dim, SB: Storage<T, D2>, DefaultAllocator: Allocator<T, D1>;
|
where D1: DimName, D2: Dim, SB: Storage<T, D2>, DefaultAllocator: Allocator<D1>;
|
||||||
self: &'a OPoint<T, D1>, right: &'b Vector<T, D2, SB>, Output = OPoint<T, D1>;
|
self: &'a OPoint<T, D1>, right: &'b Vector<T, D2, SB>, Output = OPoint<T, D1>;
|
||||||
Self::Output::from(&self.coords - right); 'a, 'b);
|
Self::Output::from(&self.coords - right); 'a, 'b);
|
||||||
|
|
||||||
|
@ -116,7 +116,7 @@ add_sub_impl!(Sub, sub, ClosedSub;
|
||||||
(D1, U1), (D2, U1) -> (D1, U1)
|
(D1, U1), (D2, U1) -> (D1, U1)
|
||||||
const;
|
const;
|
||||||
for D1, D2, SB;
|
for D1, D2, SB;
|
||||||
where D1: DimName, D2: Dim, SB: Storage<T, D2>, DefaultAllocator: Allocator<T, D1>;
|
where D1: DimName, D2: Dim, SB: Storage<T, D2>, DefaultAllocator: Allocator<D1>;
|
||||||
self: &'a OPoint<T, D1>, right: Vector<T, D2, SB>, Output = OPoint<T, D1>;
|
self: &'a OPoint<T, D1>, right: Vector<T, D2, SB>, Output = OPoint<T, D1>;
|
||||||
Self::Output::from(&self.coords - &right); 'a); // TODO: should not be a ref to `right`.
|
Self::Output::from(&self.coords - &right); 'a); // TODO: should not be a ref to `right`.
|
||||||
|
|
||||||
|
@ -124,7 +124,7 @@ add_sub_impl!(Sub, sub, ClosedSub;
|
||||||
(D1, U1), (D2, U1) -> (D1, U1)
|
(D1, U1), (D2, U1) -> (D1, U1)
|
||||||
const;
|
const;
|
||||||
for D1, D2, SB;
|
for D1, D2, SB;
|
||||||
where D1: DimName, D2: Dim, SB: Storage<T, D2>, DefaultAllocator: Allocator<T, D1>;
|
where D1: DimName, D2: Dim, SB: Storage<T, D2>, DefaultAllocator: Allocator<D1>;
|
||||||
self: OPoint<T, D1>, right: &'b Vector<T, D2, SB>, Output = OPoint<T, D1>;
|
self: OPoint<T, D1>, right: &'b Vector<T, D2, SB>, Output = OPoint<T, D1>;
|
||||||
Self::Output::from(self.coords - right); 'b);
|
Self::Output::from(self.coords - right); 'b);
|
||||||
|
|
||||||
|
@ -132,7 +132,7 @@ add_sub_impl!(Sub, sub, ClosedSub;
|
||||||
(D1, U1), (D2, U1) -> (D1, U1)
|
(D1, U1), (D2, U1) -> (D1, U1)
|
||||||
const;
|
const;
|
||||||
for D1, D2, SB;
|
for D1, D2, SB;
|
||||||
where D1: DimName, D2: Dim, SB: Storage<T, D2>, DefaultAllocator: Allocator<T, D1>;
|
where D1: DimName, D2: Dim, SB: Storage<T, D2>, DefaultAllocator: Allocator<D1>;
|
||||||
self: OPoint<T, D1>, right: Vector<T, D2, SB>, Output = OPoint<T, D1>;
|
self: OPoint<T, D1>, right: Vector<T, D2, SB>, Output = OPoint<T, D1>;
|
||||||
Self::Output::from(self.coords - right); );
|
Self::Output::from(self.coords - right); );
|
||||||
|
|
||||||
|
@ -141,7 +141,7 @@ add_sub_impl!(Add, add, ClosedAdd;
|
||||||
(D1, U1), (D2, U1) -> (D1, U1)
|
(D1, U1), (D2, U1) -> (D1, U1)
|
||||||
const;
|
const;
|
||||||
for D1, D2, SB;
|
for D1, D2, SB;
|
||||||
where D1: DimName, D2: Dim, SB: Storage<T, D2>, DefaultAllocator: Allocator<T, D1>;
|
where D1: DimName, D2: Dim, SB: Storage<T, D2>, DefaultAllocator: Allocator<D1>;
|
||||||
self: &'a OPoint<T, D1>, right: &'b Vector<T, D2, SB>, Output = OPoint<T, D1>;
|
self: &'a OPoint<T, D1>, right: &'b Vector<T, D2, SB>, Output = OPoint<T, D1>;
|
||||||
Self::Output::from(&self.coords + right); 'a, 'b);
|
Self::Output::from(&self.coords + right); 'a, 'b);
|
||||||
|
|
||||||
|
@ -149,7 +149,7 @@ add_sub_impl!(Add, add, ClosedAdd;
|
||||||
(D1, U1), (D2, U1) -> (D1, U1)
|
(D1, U1), (D2, U1) -> (D1, U1)
|
||||||
const;
|
const;
|
||||||
for D1, D2, SB;
|
for D1, D2, SB;
|
||||||
where D1: DimName, D2: Dim, SB: Storage<T, D2>, DefaultAllocator: Allocator<T, D1>;
|
where D1: DimName, D2: Dim, SB: Storage<T, D2>, DefaultAllocator: Allocator<D1>;
|
||||||
self: &'a OPoint<T, D1>, right: Vector<T, D2, SB>, Output = OPoint<T, D1>;
|
self: &'a OPoint<T, D1>, right: Vector<T, D2, SB>, Output = OPoint<T, D1>;
|
||||||
Self::Output::from(&self.coords + &right); 'a); // TODO: should not be a ref to `right`.
|
Self::Output::from(&self.coords + &right); 'a); // TODO: should not be a ref to `right`.
|
||||||
|
|
||||||
|
@ -157,7 +157,7 @@ add_sub_impl!(Add, add, ClosedAdd;
|
||||||
(D1, U1), (D2, U1) -> (D1, U1)
|
(D1, U1), (D2, U1) -> (D1, U1)
|
||||||
const;
|
const;
|
||||||
for D1, D2, SB;
|
for D1, D2, SB;
|
||||||
where D1: DimName, D2: Dim, SB: Storage<T, D2>, DefaultAllocator: Allocator<T, D1>;
|
where D1: DimName, D2: Dim, SB: Storage<T, D2>, DefaultAllocator: Allocator<D1>;
|
||||||
self: OPoint<T, D1>, right: &'b Vector<T, D2, SB>, Output = OPoint<T, D1>;
|
self: OPoint<T, D1>, right: &'b Vector<T, D2, SB>, Output = OPoint<T, D1>;
|
||||||
Self::Output::from(self.coords + right); 'b);
|
Self::Output::from(self.coords + right); 'b);
|
||||||
|
|
||||||
|
@ -165,7 +165,7 @@ add_sub_impl!(Add, add, ClosedAdd;
|
||||||
(D1, U1), (D2, U1) -> (D1, U1)
|
(D1, U1), (D2, U1) -> (D1, U1)
|
||||||
const;
|
const;
|
||||||
for D1, D2, SB;
|
for D1, D2, SB;
|
||||||
where D1: DimName, D2: Dim, SB: Storage<T, D2>, DefaultAllocator: Allocator<T, D1>;
|
where D1: DimName, D2: Dim, SB: Storage<T, D2>, DefaultAllocator: Allocator<D1>;
|
||||||
self: OPoint<T, D1>, right: Vector<T, D2, SB>, Output = OPoint<T, D1>;
|
self: OPoint<T, D1>, right: Vector<T, D2, SB>, Output = OPoint<T, D1>;
|
||||||
Self::Output::from(self.coords + right); );
|
Self::Output::from(self.coords + right); );
|
||||||
|
|
||||||
|
@ -176,7 +176,7 @@ macro_rules! op_assign_impl(
|
||||||
where T: Scalar + $bound,
|
where T: Scalar + $bound,
|
||||||
SB: Storage<T, D2>,
|
SB: Storage<T, D2>,
|
||||||
ShapeConstraint: SameNumberOfRows<D1, D2>,
|
ShapeConstraint: SameNumberOfRows<D1, D2>,
|
||||||
DefaultAllocator: Allocator<T, D1> {
|
DefaultAllocator: Allocator<D1> {
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn $method_assign(&mut self, right: &'b Vector<T, D2, SB>) {
|
fn $method_assign(&mut self, right: &'b Vector<T, D2, SB>) {
|
||||||
|
@ -188,7 +188,7 @@ macro_rules! op_assign_impl(
|
||||||
where T: Scalar + $bound,
|
where T: Scalar + $bound,
|
||||||
SB: Storage<T, D2>,
|
SB: Storage<T, D2>,
|
||||||
ShapeConstraint: SameNumberOfRows<D1, D2>,
|
ShapeConstraint: SameNumberOfRows<D1, D2>,
|
||||||
DefaultAllocator: Allocator<T, D1> {
|
DefaultAllocator: Allocator<D1> {
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn $method_assign(&mut self, right: Vector<T, D2, SB>) {
|
fn $method_assign(&mut self, right: Vector<T, D2, SB>) {
|
||||||
|
@ -231,7 +231,7 @@ macro_rules! componentwise_scalarop_impl(
|
||||||
($Trait: ident, $method: ident, $bound: ident;
|
($Trait: ident, $method: ident, $bound: ident;
|
||||||
$TraitAssign: ident, $method_assign: ident) => {
|
$TraitAssign: ident, $method_assign: ident) => {
|
||||||
impl<T: Scalar + $bound, D: DimName> $Trait<T> for OPoint<T, D>
|
impl<T: Scalar + $bound, D: DimName> $Trait<T> for OPoint<T, D>
|
||||||
where DefaultAllocator: Allocator<T, D>
|
where DefaultAllocator: Allocator<D>
|
||||||
{
|
{
|
||||||
type Output = OPoint<T, D>;
|
type Output = OPoint<T, D>;
|
||||||
|
|
||||||
|
@ -242,7 +242,7 @@ macro_rules! componentwise_scalarop_impl(
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, T: Scalar + $bound, D: DimName> $Trait<T> for &'a OPoint<T, D>
|
impl<'a, T: Scalar + $bound, D: DimName> $Trait<T> for &'a OPoint<T, D>
|
||||||
where DefaultAllocator: Allocator<T, D>
|
where DefaultAllocator: Allocator<D>
|
||||||
{
|
{
|
||||||
type Output = OPoint<T, D>;
|
type Output = OPoint<T, D>;
|
||||||
|
|
||||||
|
@ -253,7 +253,7 @@ macro_rules! componentwise_scalarop_impl(
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T: Scalar + $bound, D: DimName> $TraitAssign<T> for OPoint<T, D>
|
impl<T: Scalar + $bound, D: DimName> $TraitAssign<T> for OPoint<T, D>
|
||||||
where DefaultAllocator: Allocator<T, D>
|
where DefaultAllocator: Allocator<D>
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn $method_assign(&mut self, right: T) {
|
fn $method_assign(&mut self, right: T) {
|
||||||
|
@ -269,7 +269,7 @@ componentwise_scalarop_impl!(Div, div, ClosedDiv; DivAssign, div_assign);
|
||||||
macro_rules! left_scalar_mul_impl(
|
macro_rules! left_scalar_mul_impl(
|
||||||
($($T: ty),* $(,)*) => {$(
|
($($T: ty),* $(,)*) => {$(
|
||||||
impl<D: DimName> Mul<OPoint<$T, D>> for $T
|
impl<D: DimName> Mul<OPoint<$T, D>> for $T
|
||||||
where DefaultAllocator: Allocator<$T, D>
|
where DefaultAllocator: Allocator<D>
|
||||||
{
|
{
|
||||||
type Output = OPoint<$T, D>;
|
type Output = OPoint<$T, D>;
|
||||||
|
|
||||||
|
@ -280,7 +280,7 @@ macro_rules! left_scalar_mul_impl(
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'b, D: DimName> Mul<&'b OPoint<$T, D>> for $T
|
impl<'b, D: DimName> Mul<&'b OPoint<$T, D>> for $T
|
||||||
where DefaultAllocator: Allocator<$T, D>
|
where DefaultAllocator: Allocator<D>
|
||||||
{
|
{
|
||||||
type Output = OPoint<$T, D>;
|
type Output = OPoint<$T, D>;
|
||||||
|
|
||||||
|
|
|
@ -77,7 +77,7 @@ impl<T: fmt::Debug, const D: usize> fmt::Debug for Rotation<T, D> {
|
||||||
|
|
||||||
impl<T: Scalar + hash::Hash, const D: usize> hash::Hash for Rotation<T, D>
|
impl<T: Scalar + hash::Hash, const D: usize> hash::Hash for Rotation<T, D>
|
||||||
where
|
where
|
||||||
<DefaultAllocator as Allocator<T, Const<D>, Const<D>>>::Buffer: hash::Hash,
|
<DefaultAllocator as Allocator<Const<D>, Const<D>>>::Buffer<T>: 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)
|
||||||
|
@ -265,7 +265,7 @@ impl<T: Scalar, const D: usize> Rotation<T, D> {
|
||||||
where
|
where
|
||||||
T: Zero + One,
|
T: Zero + One,
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
{
|
{
|
||||||
// We could use `SMatrix::to_homogeneous()` here, but that would imply
|
// We could use `SMatrix::to_homogeneous()` here, but that would imply
|
||||||
// adding the additional traits `DimAdd` and `IsNotStaticOne`. Maybe
|
// adding the additional traits `DimAdd` and `IsNotStaticOne`. Maybe
|
||||||
|
|
|
@ -1,5 +1,6 @@
|
||||||
use num::Zero;
|
use num::Zero;
|
||||||
|
|
||||||
|
use crate::ArrayStorage;
|
||||||
use simba::scalar::{RealField, SubsetOf, SupersetOf};
|
use simba::scalar::{RealField, SubsetOf, SupersetOf};
|
||||||
use simba::simd::{PrimitiveSimdValue, SimdValue};
|
use simba::simd::{PrimitiveSimdValue, SimdValue};
|
||||||
|
|
||||||
|
@ -169,11 +170,9 @@ where
|
||||||
T2: RealField + SupersetOf<T1>,
|
T2: RealField + SupersetOf<T1>,
|
||||||
C: SuperTCategoryOf<TAffine>,
|
C: SuperTCategoryOf<TAffine>,
|
||||||
Const<D>: DimNameAdd<U1> + DimMin<Const<D>, Output = Const<D>>, // needed by .is_special_orthogonal()
|
Const<D>: DimNameAdd<U1> + DimMin<Const<D>, Output = Const<D>>, // needed by .is_special_orthogonal()
|
||||||
DefaultAllocator: Allocator<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
+ Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
// + Allocator<D>,
|
||||||
// + Allocator<(usize, usize), D>,
|
// + Allocator<D, D>
|
||||||
// Allocator<T1, D, D>
|
|
||||||
// + Allocator<T2, D, D>
|
|
||||||
{
|
{
|
||||||
// needed by .is_special_orthogonal()
|
// needed by .is_special_orthogonal()
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -198,10 +197,9 @@ where
|
||||||
T1: RealField,
|
T1: RealField,
|
||||||
T2: RealField + SupersetOf<T1>,
|
T2: RealField + SupersetOf<T1>,
|
||||||
Const<D>: DimNameAdd<U1> + DimMin<Const<D>, Output = Const<D>>, // needed by .is_special_orthogonal()
|
Const<D>: DimNameAdd<U1> + DimMin<Const<D>, Output = Const<D>>, // needed by .is_special_orthogonal()
|
||||||
DefaultAllocator: Allocator<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
DefaultAllocator: Allocator<Const<D>, Const<D>, Buffer<T1> = ArrayStorage<T1, D, D>>
|
||||||
+ Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>, // + Allocator<(usize, usize), D>,
|
+ Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>, // + Allocator<D>,
|
||||||
// + Allocator<T1, D, D>
|
// + Allocator<D, D>
|
||||||
// + Allocator<T2, D, D>
|
|
||||||
{
|
{
|
||||||
// needed by .is_special_orthogonal()
|
// needed by .is_special_orthogonal()
|
||||||
#[inline]
|
#[inline]
|
||||||
|
|
|
@ -77,7 +77,7 @@ md_impl_all!(
|
||||||
const D1;
|
const D1;
|
||||||
for R2, C2, SB;
|
for R2, C2, SB;
|
||||||
where R2: Dim, C2: Dim, SB: Storage<T, R2, C2>,
|
where R2: Dim, C2: Dim, SB: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: Allocator<T, Const<D1>, C2>,
|
DefaultAllocator: Allocator<Const<D1>, C2>,
|
||||||
ShapeConstraint: AreMultipliable<Const<D1>, Const<D1>, R2, C2>;
|
ShapeConstraint: AreMultipliable<Const<D1>, Const<D1>, R2, C2>;
|
||||||
self: Rotation<T, D1>, right: Matrix<T, R2, C2, SB>, Output = OMatrix<T, Const<D1>, C2>;
|
self: Rotation<T, D1>, right: Matrix<T, R2, C2, SB>, Output = OMatrix<T, Const<D1>, C2>;
|
||||||
[val val] => self.into_inner() * right;
|
[val val] => self.into_inner() * right;
|
||||||
|
@ -93,7 +93,7 @@ md_impl_all!(
|
||||||
const D2;
|
const D2;
|
||||||
for R1, C1, SA;
|
for R1, C1, SA;
|
||||||
where R1: Dim, C1: Dim, SA: Storage<T, R1, C1>,
|
where R1: Dim, C1: Dim, SA: Storage<T, R1, C1>,
|
||||||
DefaultAllocator: Allocator<T, R1, Const<D2>>,
|
DefaultAllocator: Allocator<R1, Const<D2>>,
|
||||||
ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>;
|
ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>;
|
||||||
self: Matrix<T, R1, C1, SA>, right: Rotation<T, D2>, Output = OMatrix<T, R1, Const<D2>>;
|
self: Matrix<T, R1, C1, SA>, right: Rotation<T, D2>, Output = OMatrix<T, R1, Const<D2>>;
|
||||||
[val val] => self * right.into_inner();
|
[val val] => self * right.into_inner();
|
||||||
|
@ -109,7 +109,7 @@ md_impl_all!(
|
||||||
const D2;
|
const D2;
|
||||||
for R1, C1, SA;
|
for R1, C1, SA;
|
||||||
where R1: Dim, C1: Dim, SA: Storage<T, R1, C1>,
|
where R1: Dim, C1: Dim, SA: Storage<T, R1, C1>,
|
||||||
DefaultAllocator: Allocator<T, R1, Const<D2>>,
|
DefaultAllocator: Allocator<R1, Const<D2>>,
|
||||||
ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>;
|
ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>;
|
||||||
self: Matrix<T, R1, C1, SA>, right: Rotation<T, D2>, Output = OMatrix<T, R1, Const<D2>>;
|
self: Matrix<T, R1, C1, SA>, right: Rotation<T, D2>, Output = OMatrix<T, R1, Const<D2>>;
|
||||||
[val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * right.inverse() };
|
[val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * right.inverse() };
|
||||||
|
|
|
@ -221,8 +221,8 @@ impl<T: Scalar, const D: usize> Scale<T, D> {
|
||||||
where
|
where
|
||||||
T: Zero + One + Clone,
|
T: Zero + One + Clone,
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
||||||
+ Allocator<T, DimNameSum<Const<D>, U1>, U1>,
|
+ Allocator<DimNameSum<Const<D>, U1>, U1>,
|
||||||
{
|
{
|
||||||
// TODO: use self.vector.push() instead. We can’t right now because
|
// TODO: use self.vector.push() instead. We can’t right now because
|
||||||
// that would require the DimAdd bound (but here we use DimNameAdd).
|
// that would require the DimAdd bound (but here we use DimNameAdd).
|
||||||
|
|
|
@ -48,9 +48,8 @@ where
|
||||||
T2: RealField + SupersetOf<T1>,
|
T2: RealField + SupersetOf<T1>,
|
||||||
C: SuperTCategoryOf<TAffine>,
|
C: SuperTCategoryOf<TAffine>,
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
DefaultAllocator: Allocator<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
||||||
+ Allocator<T1, DimNameSum<Const<D>, U1>, U1>
|
+ Allocator<DimNameSum<Const<D>, U1>, U1>,
|
||||||
+ Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn to_superset(&self) -> Transform<T2, C, D> {
|
fn to_superset(&self) -> Transform<T2, C, D> {
|
||||||
|
@ -74,9 +73,8 @@ where
|
||||||
T1: RealField,
|
T1: RealField,
|
||||||
T2: RealField + SupersetOf<T1>,
|
T2: RealField + SupersetOf<T1>,
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
DefaultAllocator: Allocator<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
||||||
+ Allocator<T1, DimNameSum<Const<D>, U1>, U1>
|
+ Allocator<DimNameSum<Const<D>, U1>, U1>,
|
||||||
+ Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn to_superset(&self) -> OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> {
|
fn to_superset(&self) -> OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> {
|
||||||
|
@ -113,9 +111,9 @@ impl<T: Scalar + Zero + One, const D: usize> From<Scale<T, D>>
|
||||||
for OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
for OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
||||||
where
|
where
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
||||||
+ Allocator<T, DimNameSum<Const<D>, U1>, U1>
|
+ Allocator<DimNameSum<Const<D>, U1>, U1>
|
||||||
+ Allocator<T, Const<D>>,
|
+ Allocator<Const<D>>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn from(t: Scale<T, D>) -> Self {
|
fn from(t: Scale<T, D>) -> Self {
|
||||||
|
|
|
@ -26,14 +26,14 @@ use rkyv::bytecheck;
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(serialize = "T: Scalar + Serialize,
|
serde(bound(serialize = "T: Scalar + Serialize,
|
||||||
R: Serialize,
|
R: Serialize,
|
||||||
DefaultAllocator: Allocator<T, Const<D>>,
|
DefaultAllocator: Allocator<Const<D>>,
|
||||||
Owned<T, Const<D>>: Serialize"))
|
Owned<T, Const<D>>: Serialize"))
|
||||||
)]
|
)]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(deserialize = "T: Scalar + Deserialize<'de>,
|
serde(bound(deserialize = "T: Scalar + Deserialize<'de>,
|
||||||
R: Deserialize<'de>,
|
R: Deserialize<'de>,
|
||||||
DefaultAllocator: Allocator<T, Const<D>>,
|
DefaultAllocator: Allocator<Const<D>>,
|
||||||
Owned<T, Const<D>>: Deserialize<'de>"))
|
Owned<T, Const<D>>: Deserialize<'de>"))
|
||||||
)]
|
)]
|
||||||
#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
|
#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
|
||||||
|
@ -307,7 +307,7 @@ impl<T: SimdRealField, R, const D: usize> Similarity<T, R, D> {
|
||||||
where
|
where
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
|
R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
{
|
{
|
||||||
let mut res = self.isometry.to_homogeneous();
|
let mut res = self.isometry.to_homogeneous();
|
||||||
|
|
||||||
|
|
|
@ -1,5 +1,6 @@
|
||||||
use num::Zero;
|
use num::Zero;
|
||||||
|
|
||||||
|
use crate::ArrayStorage;
|
||||||
use simba::scalar::{RealField, SubsetOf, SupersetOf};
|
use simba::scalar::{RealField, SubsetOf, SupersetOf};
|
||||||
use simba::simd::{PrimitiveSimdValue, SimdRealField, SimdValue};
|
use simba::simd::{PrimitiveSimdValue, SimdRealField, SimdValue};
|
||||||
|
|
||||||
|
@ -56,14 +57,12 @@ where
|
||||||
+ SubsetOf<OMatrix<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>
|
+ SubsetOf<OMatrix<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>
|
||||||
+ SubsetOf<OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
|
+ SubsetOf<OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
|
||||||
Const<D>: DimNameAdd<U1> + DimMin<Const<D>, Output = Const<D>>, // needed by .determinant()
|
Const<D>: DimNameAdd<U1> + DimMin<Const<D>, Output = Const<D>>, // needed by .determinant()
|
||||||
DefaultAllocator: Allocator<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
+ Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
// + Allocator<D>
|
||||||
+ Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
|
||||||
// + Allocator<(usize, usize), D>
|
|
||||||
// + Allocator<T1, D>
|
// + Allocator<T1, D>
|
||||||
// + Allocator<T1, D, D>
|
// + Allocator<T1, D, D>
|
||||||
// + Allocator<T2, D, D>
|
// + Allocator<D, D>
|
||||||
// + Allocator<T2, D>,
|
// + Allocator<D>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn to_superset(&self) -> Transform<T2, C, D> {
|
fn to_superset(&self) -> Transform<T2, C, D> {
|
||||||
|
@ -91,13 +90,8 @@ where
|
||||||
+ SubsetOf<OMatrix<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>
|
+ SubsetOf<OMatrix<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>
|
||||||
+ SubsetOf<OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
|
+ SubsetOf<OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
|
||||||
Const<D>: DimNameAdd<U1> + DimMin<Const<D>, Output = Const<D>>, // needed by .determinant()
|
Const<D>: DimNameAdd<U1> + DimMin<Const<D>, Output = Const<D>>, // needed by .determinant()
|
||||||
DefaultAllocator: Allocator<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
DefaultAllocator: Allocator<Const<D>, Const<1>, Buffer<T1> = ArrayStorage<T1, D, 1>>
|
||||||
+ Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
+ Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
+ Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>, // + Allocator<(usize, usize), D>
|
|
||||||
// + Allocator<T1, D>
|
|
||||||
// + Allocator<T1, D, D>
|
|
||||||
// + Allocator<T2, D, D>
|
|
||||||
// + Allocator<T2, D>
|
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn to_superset(&self) -> OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> {
|
fn to_superset(&self) -> OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> {
|
||||||
|
@ -178,7 +172,7 @@ impl<T: SimdRealField, R, const D: usize> From<Similarity<T, R, D>>
|
||||||
where
|
where
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
|
R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>, // + Allocator<T, D>
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>, // + Allocator<D>
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn from(sim: Similarity<T, R, D>) -> Self {
|
fn from(sim: Similarity<T, R, D>) -> Self {
|
||||||
|
|
|
@ -32,7 +32,7 @@ pub trait TCategory: Any + Debug + Copy + PartialEq + Send {
|
||||||
fn check_homogeneous_invariants<T: RealField, D: DimName>(mat: &OMatrix<T, D, D>) -> bool
|
fn check_homogeneous_invariants<T: RealField, D: DimName>(mat: &OMatrix<T, D, D>) -> bool
|
||||||
where
|
where
|
||||||
T::Epsilon: Clone,
|
T::Epsilon: Clone,
|
||||||
DefaultAllocator: Allocator<T, D, D>;
|
DefaultAllocator: Allocator<D, D>;
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Traits that gives the `Transform` category that is compatible with the result of the
|
/// Traits that gives the `Transform` category that is compatible with the result of the
|
||||||
|
@ -75,7 +75,7 @@ impl TCategory for TGeneral {
|
||||||
fn check_homogeneous_invariants<T: RealField, D: DimName>(_: &OMatrix<T, D, D>) -> bool
|
fn check_homogeneous_invariants<T: RealField, D: DimName>(_: &OMatrix<T, D, D>) -> bool
|
||||||
where
|
where
|
||||||
T::Epsilon: Clone,
|
T::Epsilon: Clone,
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
true
|
true
|
||||||
}
|
}
|
||||||
|
@ -86,7 +86,7 @@ impl TCategory for TProjective {
|
||||||
fn check_homogeneous_invariants<T: RealField, D: DimName>(mat: &OMatrix<T, D, D>) -> bool
|
fn check_homogeneous_invariants<T: RealField, D: DimName>(mat: &OMatrix<T, D, D>) -> bool
|
||||||
where
|
where
|
||||||
T::Epsilon: Clone,
|
T::Epsilon: Clone,
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
mat.is_invertible()
|
mat.is_invertible()
|
||||||
}
|
}
|
||||||
|
@ -102,7 +102,7 @@ impl TCategory for TAffine {
|
||||||
fn check_homogeneous_invariants<T: RealField, D: DimName>(mat: &OMatrix<T, D, D>) -> bool
|
fn check_homogeneous_invariants<T: RealField, D: DimName>(mat: &OMatrix<T, D, D>) -> bool
|
||||||
where
|
where
|
||||||
T::Epsilon: Clone,
|
T::Epsilon: Clone,
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
let last = D::dim() - 1;
|
let last = D::dim() - 1;
|
||||||
mat.is_invertible()
|
mat.is_invertible()
|
||||||
|
@ -160,7 +160,7 @@ super_tcategory_impl!(
|
||||||
pub struct Transform<T: RealField, C: TCategory, const D: usize>
|
pub struct Transform<T: RealField, C: TCategory, const D: usize>
|
||||||
where
|
where
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
{
|
{
|
||||||
matrix: OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
matrix: OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
_phantom: PhantomData<C>,
|
_phantom: PhantomData<C>,
|
||||||
|
@ -169,7 +169,7 @@ where
|
||||||
impl<T: RealField + Debug, C: TCategory, const D: usize> Debug for Transform<T, C, D>
|
impl<T: RealField + 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<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
{
|
{
|
||||||
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
|
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
|
||||||
self.matrix.fmt(formatter)
|
self.matrix.fmt(formatter)
|
||||||
|
@ -179,7 +179,7 @@ where
|
||||||
impl<T: RealField + hash::Hash, C: TCategory, const D: usize> hash::Hash for Transform<T, C, D>
|
impl<T: RealField + hash::Hash, C: TCategory, const D: usize> hash::Hash 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<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
Owned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: hash::Hash,
|
Owned<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) {
|
||||||
|
@ -190,7 +190,7 @@ where
|
||||||
impl<T: RealField + Copy, C: TCategory, const D: usize> Copy for Transform<T, C, D>
|
impl<T: RealField + 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<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
Owned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: Copy,
|
Owned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: Copy,
|
||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
@ -198,7 +198,7 @@ where
|
||||||
impl<T: RealField, C: TCategory, const D: usize> Clone for Transform<T, C, D>
|
impl<T: RealField, 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<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn clone(&self) -> Self {
|
fn clone(&self) -> Self {
|
||||||
|
@ -211,7 +211,7 @@ unsafe impl<T, C: TCategory, const D: usize> bytemuck::Zeroable for Transform<T,
|
||||||
where
|
where
|
||||||
T: RealField + bytemuck::Zeroable,
|
T: RealField + bytemuck::Zeroable,
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: bytemuck::Zeroable,
|
OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: bytemuck::Zeroable,
|
||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
@ -221,7 +221,7 @@ unsafe impl<T, C: TCategory, const D: usize> bytemuck::Pod for Transform<T, C, D
|
||||||
where
|
where
|
||||||
T: RealField + bytemuck::Pod,
|
T: RealField + bytemuck::Pod,
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: bytemuck::Pod,
|
OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: bytemuck::Pod,
|
||||||
Owned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: Copy,
|
Owned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: Copy,
|
||||||
{
|
{
|
||||||
|
@ -231,7 +231,7 @@ where
|
||||||
impl<T: RealField, C: TCategory, const D: usize> Serialize for Transform<T, C, D>
|
impl<T: RealField, 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<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
Owned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: Serialize,
|
Owned<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>
|
||||||
|
@ -246,7 +246,7 @@ where
|
||||||
impl<'a, T: RealField, C: TCategory, const D: usize> Deserialize<'a> for Transform<T, C, D>
|
impl<'a, T: RealField, 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<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
Owned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: Deserialize<'a>,
|
Owned<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>
|
||||||
|
@ -264,14 +264,14 @@ where
|
||||||
impl<T: RealField + Eq, C: TCategory, const D: usize> Eq for Transform<T, C, D>
|
impl<T: RealField + Eq, C: TCategory, const D: usize> Eq 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<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T: RealField, C: TCategory, const D: usize> PartialEq for Transform<T, C, D>
|
impl<T: RealField, C: TCategory, const D: usize> PartialEq 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<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn eq(&self, right: &Self) -> bool {
|
fn eq(&self, right: &Self) -> bool {
|
||||||
|
@ -282,7 +282,7 @@ where
|
||||||
impl<T: RealField, C: TCategory, const D: usize> Transform<T, C, D>
|
impl<T: RealField, C: TCategory, const D: usize> 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<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
{
|
{
|
||||||
/// Creates a new transformation from the given homogeneous matrix. The transformation category
|
/// Creates a new transformation from the given homogeneous matrix. The transformation category
|
||||||
/// of `Self` is not checked to be verified by the given matrix.
|
/// of `Self` is not checked to be verified by the given matrix.
|
||||||
|
@ -523,9 +523,9 @@ where
|
||||||
T: RealField,
|
T: RealField,
|
||||||
C: TCategory,
|
C: TCategory,
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
||||||
+ Allocator<T, DimNameSum<Const<D>, U1>>, // + Allocator<T, D, D>
|
+ Allocator<DimNameSum<Const<D>, U1>>, // + Allocator<D, D>
|
||||||
// + Allocator<T, D>
|
// + Allocator<D>
|
||||||
{
|
{
|
||||||
/// Transform the given point by this transformation.
|
/// Transform the given point by this transformation.
|
||||||
///
|
///
|
||||||
|
@ -551,9 +551,9 @@ impl<T: RealField, C: TCategory, const D: usize> Transform<T, C, D>
|
||||||
where
|
where
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
C: SubTCategoryOf<TProjective>,
|
C: SubTCategoryOf<TProjective>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
||||||
+ Allocator<T, DimNameSum<Const<D>, U1>>, // + Allocator<T, D, D>
|
+ Allocator<DimNameSum<Const<D>, U1>>, // + Allocator<D, D>
|
||||||
// + Allocator<T, D>
|
// + Allocator<D>
|
||||||
{
|
{
|
||||||
/// 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
|
||||||
|
@ -577,7 +577,7 @@ where
|
||||||
impl<T: RealField, const D: usize> Transform<T, TGeneral, D>
|
impl<T: RealField, const D: usize> Transform<T, TGeneral, D>
|
||||||
where
|
where
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
{
|
{
|
||||||
/// A mutable reference to underlying matrix. Use `.matrix_mut_unchecked` instead if this
|
/// A mutable reference to underlying matrix. Use `.matrix_mut_unchecked` instead if this
|
||||||
/// transformation category is not `TGeneral`.
|
/// transformation category is not `TGeneral`.
|
||||||
|
@ -593,7 +593,7 @@ impl<T: RealField, C: TCategory, const D: usize> AbsDiffEq for Transform<T, C, D
|
||||||
where
|
where
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
T::Epsilon: Clone,
|
T::Epsilon: Clone,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
{
|
{
|
||||||
type Epsilon = T::Epsilon;
|
type Epsilon = T::Epsilon;
|
||||||
|
|
||||||
|
@ -612,7 +612,7 @@ impl<T: RealField, C: TCategory, const D: usize> RelativeEq for Transform<T, C,
|
||||||
where
|
where
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
T::Epsilon: Clone,
|
T::Epsilon: Clone,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn default_max_relative() -> Self::Epsilon {
|
fn default_max_relative() -> Self::Epsilon {
|
||||||
|
@ -635,7 +635,7 @@ impl<T: RealField, C: TCategory, const D: usize> UlpsEq for Transform<T, C, D>
|
||||||
where
|
where
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
T::Epsilon: Clone,
|
T::Epsilon: Clone,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn default_max_ulps() -> u32 {
|
fn default_max_ulps() -> u32 {
|
||||||
|
|
|
@ -11,7 +11,7 @@ use crate::geometry::{TCategory, Transform};
|
||||||
impl<T: RealField, C: TCategory, const D: usize> Default for Transform<T, C, D>
|
impl<T: RealField, C: TCategory, const D: usize> Default 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<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
{
|
{
|
||||||
fn default() -> Self {
|
fn default() -> Self {
|
||||||
Self::identity()
|
Self::identity()
|
||||||
|
@ -21,7 +21,7 @@ where
|
||||||
impl<T: RealField, C: TCategory, const D: usize> Transform<T, C, D>
|
impl<T: RealField, C: TCategory, const D: usize> 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<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
{
|
{
|
||||||
/// Creates a new identity transform.
|
/// Creates a new identity transform.
|
||||||
///
|
///
|
||||||
|
@ -64,7 +64,7 @@ where
|
||||||
impl<T: RealField, C: TCategory, const D: usize> One for Transform<T, C, D>
|
impl<T: RealField, C: TCategory, const D: usize> One 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<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
{
|
{
|
||||||
/// Creates a new identity transform.
|
/// Creates a new identity transform.
|
||||||
#[inline]
|
#[inline]
|
||||||
|
|
|
@ -13,8 +13,7 @@ where
|
||||||
C1: TCategory,
|
C1: TCategory,
|
||||||
C2: SuperTCategoryOf<C1>,
|
C2: SuperTCategoryOf<C1>,
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
DefaultAllocator: Allocator<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
+ Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
|
||||||
T1::Epsilon: Copy,
|
T1::Epsilon: Copy,
|
||||||
T2::Epsilon: Copy,
|
T2::Epsilon: Copy,
|
||||||
{
|
{
|
||||||
|
@ -42,8 +41,7 @@ where
|
||||||
T2: RealField,
|
T2: RealField,
|
||||||
C: TCategory,
|
C: TCategory,
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
DefaultAllocator: Allocator<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
+ Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
|
||||||
T1::Epsilon: Copy,
|
T1::Epsilon: Copy,
|
||||||
T2::Epsilon: Copy,
|
T2::Epsilon: Copy,
|
||||||
{
|
{
|
||||||
|
@ -70,7 +68,7 @@ impl<T: RealField, C, const D: usize> From<Transform<T, C, D>>
|
||||||
where
|
where
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
C: TCategory,
|
C: TCategory,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn from(t: Transform<T, C, D>) -> Self {
|
fn from(t: Transform<T, C, D>) -> Self {
|
||||||
|
|
|
@ -85,7 +85,7 @@ use crate::geometry::{
|
||||||
impl<T: RealField, C: TCategory, const D: usize> Index<(usize, usize)> for Transform<T, C, D>
|
impl<T: RealField, C: TCategory, const D: usize> Index<(usize, usize)> 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<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
{
|
{
|
||||||
type Output = T;
|
type Output = T;
|
||||||
|
|
||||||
|
@ -99,7 +99,7 @@ where
|
||||||
impl<T: RealField, const D: usize> IndexMut<(usize, usize)> for Transform<T, TGeneral, D>
|
impl<T: RealField, const D: usize> IndexMut<(usize, usize)> for Transform<T, TGeneral, D>
|
||||||
where
|
where
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn index_mut(&mut self, ij: (usize, usize)) -> &mut T {
|
fn index_mut(&mut self, ij: (usize, usize)) -> &mut T {
|
||||||
|
@ -114,7 +114,7 @@ md_impl_all!(
|
||||||
const D;
|
const D;
|
||||||
for C;
|
for C;
|
||||||
where Const<D>: DimNameAdd<U1>, C: TCategory,
|
where Const<D>: DimNameAdd<U1>, C: TCategory,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
||||||
self: Transform<T, C, D>, rhs: SVector<T, D>, Output = SVector<T, D>;
|
self: Transform<T, C, D>, rhs: SVector<T, D>, Output = SVector<T, D>;
|
||||||
[val val] => &self * &rhs;
|
[val val] => &self * &rhs;
|
||||||
[ref val] => self * &rhs;
|
[ref val] => self * &rhs;
|
||||||
|
@ -142,7 +142,7 @@ md_impl_all!(
|
||||||
const D;
|
const D;
|
||||||
for C;
|
for C;
|
||||||
where Const<D>: DimNameAdd<U1>, C: TCategory,
|
where Const<D>: DimNameAdd<U1>, C: TCategory,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
||||||
self: Transform<T, C, D>, rhs: Point<T, D>, Output = Point<T, D>;
|
self: Transform<T, C, D>, rhs: Point<T, D>, Output = Point<T, D>;
|
||||||
[val val] => &self * &rhs;
|
[val val] => &self * &rhs;
|
||||||
[ref val] => self * &rhs;
|
[ref val] => self * &rhs;
|
||||||
|
@ -172,7 +172,7 @@ md_impl_all!(
|
||||||
const D;
|
const D;
|
||||||
for CA, CB;
|
for CA, CB;
|
||||||
where Const<D>: DimNameAdd<U1>, CA: TCategoryMul<CB>, CB: TCategory,
|
where Const<D>: DimNameAdd<U1>, CA: TCategoryMul<CB>, CB: TCategory,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
||||||
self: Transform<T, CA, D>, rhs: Transform<T, CB, D>, Output = Transform<T, CA::Representative, D>;
|
self: Transform<T, CA, D>, rhs: Transform<T, CB, D>, Output = Transform<T, CA::Representative, D>;
|
||||||
[val val] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.into_inner());
|
[val val] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.into_inner());
|
||||||
[ref val] => Self::Output::from_matrix_unchecked(self.matrix() * rhs.into_inner());
|
[ref val] => Self::Output::from_matrix_unchecked(self.matrix() * rhs.into_inner());
|
||||||
|
@ -188,7 +188,7 @@ md_impl_all!(
|
||||||
const D;
|
const D;
|
||||||
for C;
|
for C;
|
||||||
where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>,
|
where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
||||||
self: Transform<T, C, D>, rhs: Rotation<T, D>, Output = Transform<T, C::Representative, D>;
|
self: Transform<T, C, D>, rhs: Rotation<T, D>, Output = Transform<T, C::Representative, D>;
|
||||||
[val val] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.to_homogeneous());
|
[val val] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.to_homogeneous());
|
||||||
[ref val] => Self::Output::from_matrix_unchecked(self.matrix() * rhs.to_homogeneous());
|
[ref val] => Self::Output::from_matrix_unchecked(self.matrix() * rhs.to_homogeneous());
|
||||||
|
@ -203,7 +203,7 @@ md_impl_all!(
|
||||||
const D;
|
const D;
|
||||||
for C;
|
for C;
|
||||||
where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>,
|
where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
||||||
self: Rotation<T, D>, rhs: Transform<T, C, D>, Output = Transform<T, C::Representative, D>;
|
self: Rotation<T, D>, rhs: Transform<T, C, D>, Output = Transform<T, C::Representative, D>;
|
||||||
[val val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
|
[val val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
|
||||||
[ref val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
|
[ref val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
|
||||||
|
@ -274,7 +274,7 @@ md_impl_all!(
|
||||||
const D;
|
const D;
|
||||||
for C, R;
|
for C, R;
|
||||||
where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >,
|
where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
||||||
self: Transform<T, C, D>, rhs: Isometry<T, R, D>, Output = Transform<T, C::Representative, D>;
|
self: Transform<T, C, D>, rhs: Isometry<T, R, D>, Output = Transform<T, C::Representative, D>;
|
||||||
[val val] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.to_homogeneous());
|
[val val] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.to_homogeneous());
|
||||||
[ref val] => Self::Output::from_matrix_unchecked(self.matrix() * rhs.to_homogeneous());
|
[ref val] => Self::Output::from_matrix_unchecked(self.matrix() * rhs.to_homogeneous());
|
||||||
|
@ -289,7 +289,7 @@ md_impl_all!(
|
||||||
const D;
|
const D;
|
||||||
for C, R;
|
for C, R;
|
||||||
where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >,
|
where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
||||||
self: Isometry<T, R, D>, rhs: Transform<T, C, D>, Output = Transform<T, C::Representative, D>;
|
self: Isometry<T, R, D>, rhs: Transform<T, C, D>, Output = Transform<T, C::Representative, D>;
|
||||||
[val val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
|
[val val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
|
||||||
[ref val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
|
[ref val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
|
||||||
|
@ -304,7 +304,7 @@ md_impl_all!(
|
||||||
const D;
|
const D;
|
||||||
for C, R;
|
for C, R;
|
||||||
where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >,
|
where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
||||||
self: Transform<T, C, D>, rhs: Similarity<T, R, D>, Output = Transform<T, C::Representative, D>;
|
self: Transform<T, C, D>, rhs: Similarity<T, R, D>, Output = Transform<T, C::Representative, D>;
|
||||||
[val val] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.to_homogeneous());
|
[val val] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.to_homogeneous());
|
||||||
[ref val] => Self::Output::from_matrix_unchecked(self.matrix() * rhs.to_homogeneous());
|
[ref val] => Self::Output::from_matrix_unchecked(self.matrix() * rhs.to_homogeneous());
|
||||||
|
@ -319,7 +319,7 @@ md_impl_all!(
|
||||||
const D;
|
const D;
|
||||||
for C, R;
|
for C, R;
|
||||||
where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >,
|
where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
||||||
self: Similarity<T, R, D>, rhs: Transform<T, C, D>, Output = Transform<T, C::Representative, D>;
|
self: Similarity<T, R, D>, rhs: Transform<T, C, D>, Output = Transform<T, C::Representative, D>;
|
||||||
[val val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
|
[val val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
|
||||||
[ref val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
|
[ref val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
|
||||||
|
@ -342,7 +342,7 @@ md_impl_all!(
|
||||||
const D;
|
const D;
|
||||||
for C;
|
for C;
|
||||||
where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>,
|
where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
||||||
self: Transform<T, C, D>, rhs: Translation<T, D>, Output = Transform<T, C::Representative, D>;
|
self: Transform<T, C, D>, rhs: Translation<T, D>, Output = Transform<T, C::Representative, D>;
|
||||||
[val val] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.to_homogeneous());
|
[val val] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.to_homogeneous());
|
||||||
[ref val] => Self::Output::from_matrix_unchecked(self.matrix() * rhs.to_homogeneous());
|
[ref val] => Self::Output::from_matrix_unchecked(self.matrix() * rhs.to_homogeneous());
|
||||||
|
@ -357,7 +357,7 @@ md_impl_all!(
|
||||||
const D;
|
const D;
|
||||||
for C;
|
for C;
|
||||||
where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>,
|
where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
||||||
self: Translation<T, D>, rhs: Transform<T, C, D>, Output = Transform<T, C::Representative, D>;
|
self: Translation<T, D>, rhs: Transform<T, C, D>, Output = Transform<T, C::Representative, D>;
|
||||||
[val val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
|
[val val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
|
||||||
[ref val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
|
[ref val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
|
||||||
|
@ -372,7 +372,7 @@ md_impl_all!(
|
||||||
const D;
|
const D;
|
||||||
for CA, CB;
|
for CA, CB;
|
||||||
where Const<D>: DimNameAdd<U1>, CA: TCategoryMul<CB>, CB: SubTCategoryOf<TProjective>,
|
where Const<D>: DimNameAdd<U1>, CA: TCategoryMul<CB>, CB: SubTCategoryOf<TProjective>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
||||||
self: Transform<T, CA, D>, rhs: Transform<T, CB, D>, Output = Transform<T, CA::Representative, D>;
|
self: Transform<T, CA, D>, rhs: Transform<T, CB, D>, Output = Transform<T, CA::Representative, D>;
|
||||||
[val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
|
[val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
|
||||||
[ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
|
[ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
|
||||||
|
@ -387,7 +387,7 @@ md_impl_all!(
|
||||||
const D;
|
const D;
|
||||||
for C;
|
for C;
|
||||||
where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>,
|
where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
||||||
self: Transform<T, C, D>, rhs: Rotation<T, D>, Output = Transform<T, C::Representative, D>;
|
self: Transform<T, C, D>, rhs: Rotation<T, D>, Output = Transform<T, C::Representative, D>;
|
||||||
[val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
|
[val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
|
||||||
[ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
|
[ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
|
||||||
|
@ -402,7 +402,7 @@ md_impl_all!(
|
||||||
const D;
|
const D;
|
||||||
for C;
|
for C;
|
||||||
where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>,
|
where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
||||||
self: Rotation<T, D>, rhs: Transform<T, C, D>, Output = Transform<T, C::Representative, D>;
|
self: Rotation<T, D>, rhs: Transform<T, C, D>, Output = Transform<T, C::Representative, D>;
|
||||||
[val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self.inverse() * rhs };
|
[val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self.inverse() * rhs };
|
||||||
[ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self.inverse() * rhs };
|
[ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self.inverse() * rhs };
|
||||||
|
@ -443,7 +443,7 @@ md_impl_all!(
|
||||||
// Div, div where T: RealField;
|
// Div, div where T: RealField;
|
||||||
// (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>), (Const<D>, U1)
|
// (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>), (Const<D>, U1)
|
||||||
// for Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >
|
// for Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >
|
||||||
// where SB::Alloc: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1> >;
|
// where SB::Alloc: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1> >;
|
||||||
// self: Transform<T, C, D>, rhs: Isometry<T, R, D>, Output = Transform<T, C::Representative, D>;
|
// self: Transform<T, C, D>, rhs: Isometry<T, R, D>, Output = Transform<T, C::Representative, D>;
|
||||||
// [val val] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.inverse().to_homogeneous());
|
// [val val] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.inverse().to_homogeneous());
|
||||||
// [ref val] => Self::Output::from_matrix_unchecked(self.matrix() * rhs.inverse().to_homogeneous());
|
// [ref val] => Self::Output::from_matrix_unchecked(self.matrix() * rhs.inverse().to_homogeneous());
|
||||||
|
@ -456,7 +456,7 @@ md_impl_all!(
|
||||||
// Div, div where T: RealField;
|
// Div, div where T: RealField;
|
||||||
// (Const<D>, U1), (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>)
|
// (Const<D>, U1), (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>)
|
||||||
// for Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >
|
// for Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >
|
||||||
// where SA::Alloc: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1> >;
|
// where SA::Alloc: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1> >;
|
||||||
// self: Isometry<T, R, D>, rhs: Transform<T, C, D>, Output = Transform<T, C::Representative, D>;
|
// self: Isometry<T, R, D>, rhs: Transform<T, C, D>, Output = Transform<T, C::Representative, D>;
|
||||||
// [val val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
|
// [val val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
|
||||||
// [ref val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
|
// [ref val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
|
||||||
|
@ -469,8 +469,8 @@ md_impl_all!(
|
||||||
// Div, div where T: RealField;
|
// Div, div where T: RealField;
|
||||||
// (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>), (Const<D>, U1)
|
// (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>), (Const<D>, U1)
|
||||||
// for Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >
|
// for Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >
|
||||||
// where SB::Alloc: Allocator<T, D, D >
|
// where SB::Alloc: Allocator<D, D >
|
||||||
// where SB::Alloc: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1> >;
|
// where SB::Alloc: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1> >;
|
||||||
// self: Transform<T, C, D>, rhs: Similarity<T, R, D>, Output = Transform<T, C::Representative, D>;
|
// self: Transform<T, C, D>, rhs: Similarity<T, R, D>, Output = Transform<T, C::Representative, D>;
|
||||||
// [val val] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.to_homogeneous());
|
// [val val] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.to_homogeneous());
|
||||||
// [ref val] => Self::Output::from_matrix_unchecked(self.matrix() * rhs.to_homogeneous());
|
// [ref val] => Self::Output::from_matrix_unchecked(self.matrix() * rhs.to_homogeneous());
|
||||||
|
@ -483,8 +483,8 @@ md_impl_all!(
|
||||||
// Div, div where T: RealField;
|
// Div, div where T: RealField;
|
||||||
// (Const<D>, U1), (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>)
|
// (Const<D>, U1), (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>)
|
||||||
// for Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >
|
// for Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >
|
||||||
// where SA::Alloc: Allocator<T, D, D >
|
// where SA::Alloc: Allocator<D, D >
|
||||||
// where SA::Alloc: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1> >;
|
// where SA::Alloc: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1> >;
|
||||||
// self: Similarity<T, R, D>, rhs: Transform<T, C, D>, Output = Transform<T, C::Representative, D>;
|
// self: Similarity<T, R, D>, rhs: Transform<T, C, D>, Output = Transform<T, C::Representative, D>;
|
||||||
// [val val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
|
// [val val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
|
||||||
// [ref val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
|
// [ref val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
|
||||||
|
@ -499,7 +499,7 @@ md_impl_all!(
|
||||||
const D;
|
const D;
|
||||||
for C;
|
for C;
|
||||||
where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>,
|
where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
||||||
self: Transform<T, C, D>, rhs: Translation<T, D>, Output = Transform<T, C::Representative, D>;
|
self: Transform<T, C, D>, rhs: Translation<T, D>, Output = Transform<T, C::Representative, D>;
|
||||||
[val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
|
[val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
|
||||||
[ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
|
[ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
|
||||||
|
@ -514,7 +514,7 @@ md_impl_all!(
|
||||||
const D;
|
const D;
|
||||||
for C;
|
for C;
|
||||||
where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>,
|
where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
||||||
self: Translation<T, D>, rhs: Transform<T, C, D>, Output = Transform<T, C::Representative, D>;
|
self: Translation<T, D>, rhs: Transform<T, C, D>, Output = Transform<T, C::Representative, D>;
|
||||||
[val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self.inverse() * rhs };
|
[val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self.inverse() * rhs };
|
||||||
[ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self.inverse() * rhs };
|
[ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self.inverse() * rhs };
|
||||||
|
@ -529,7 +529,7 @@ md_assign_impl_all!(
|
||||||
const D;
|
const D;
|
||||||
for CA, CB;
|
for CA, CB;
|
||||||
where Const<D>: DimNameAdd<U1>, CA: TCategory, CB: SubTCategoryOf<CA>,
|
where Const<D>: DimNameAdd<U1>, CA: TCategory, CB: SubTCategoryOf<CA>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
||||||
self: Transform<T, CA, D>, rhs: Transform<T, CB, D>;
|
self: Transform<T, CA, D>, rhs: Transform<T, CB, D>;
|
||||||
[val] => *self.matrix_mut_unchecked() *= rhs.into_inner();
|
[val] => *self.matrix_mut_unchecked() *= rhs.into_inner();
|
||||||
[ref] => *self.matrix_mut_unchecked() *= rhs.matrix();
|
[ref] => *self.matrix_mut_unchecked() *= rhs.matrix();
|
||||||
|
@ -542,7 +542,7 @@ md_assign_impl_all!(
|
||||||
const D;
|
const D;
|
||||||
for C, R;
|
for C, R;
|
||||||
where Const<D>: DimNameAdd<U1>, C: TCategory, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >,
|
where Const<D>: DimNameAdd<U1>, C: TCategory, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
||||||
self: Transform<T, C, D>, rhs: Similarity<T, R, D>;
|
self: Transform<T, C, D>, rhs: Similarity<T, R, D>;
|
||||||
[val] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
|
[val] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
|
||||||
[ref] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
|
[ref] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
|
||||||
|
@ -555,7 +555,7 @@ md_assign_impl_all!(
|
||||||
const D;
|
const D;
|
||||||
for C, R;
|
for C, R;
|
||||||
where Const<D>: DimNameAdd<U1>, C: TCategory, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >,
|
where Const<D>: DimNameAdd<U1>, C: TCategory, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
||||||
self: Transform<T, C, D>, rhs: Isometry<T, R, D>;
|
self: Transform<T, C, D>, rhs: Isometry<T, R, D>;
|
||||||
[val] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
|
[val] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
|
||||||
[ref] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
|
[ref] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
|
||||||
|
@ -576,7 +576,7 @@ md_assign_impl_all!(
|
||||||
const D;
|
const D;
|
||||||
for C;
|
for C;
|
||||||
where Const<D>: DimNameAdd<U1>, C: TCategory,
|
where Const<D>: DimNameAdd<U1>, C: TCategory,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
||||||
self: Transform<T, C, D>, rhs: Translation<T, D>;
|
self: Transform<T, C, D>, rhs: Translation<T, D>;
|
||||||
[val] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
|
[val] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
|
||||||
[ref] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
|
[ref] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
|
||||||
|
@ -589,7 +589,7 @@ md_assign_impl_all!(
|
||||||
const D;
|
const D;
|
||||||
for C;
|
for C;
|
||||||
where Const<D>: DimNameAdd<U1>, C: TCategory,
|
where Const<D>: DimNameAdd<U1>, C: TCategory,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
||||||
self: Transform<T, C, D>, rhs: Rotation<T, D>;
|
self: Transform<T, C, D>, rhs: Rotation<T, D>;
|
||||||
[val] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
|
[val] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
|
||||||
[ref] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
|
[ref] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
|
||||||
|
@ -626,7 +626,7 @@ md_assign_impl_all!(
|
||||||
const D;
|
const D;
|
||||||
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<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
||||||
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() };
|
||||||
|
@ -660,7 +660,7 @@ md_assign_impl_all!(
|
||||||
const D;
|
const D;
|
||||||
for C;
|
for C;
|
||||||
where Const<D>: DimNameAdd<U1>, C: TCategory,
|
where Const<D>: DimNameAdd<U1>, C: TCategory,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
||||||
self: Transform<T, C, D>, rhs: Translation<T, D>;
|
self: Transform<T, C, D>, rhs: Translation<T, 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.inverse() };
|
[ref] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
|
||||||
|
@ -673,7 +673,7 @@ md_assign_impl_all!(
|
||||||
const D;
|
const D;
|
||||||
for C;
|
for C;
|
||||||
where Const<D>: DimNameAdd<U1>, C: TCategory,
|
where Const<D>: DimNameAdd<U1>, C: TCategory,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
|
||||||
self: Transform<T, C, D>, rhs: Rotation<T, D>;
|
self: Transform<T, C, D>, rhs: Rotation<T, 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.inverse() };
|
[ref] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
|
||||||
|
|
|
@ -12,8 +12,7 @@ where
|
||||||
T::Element: Scalar,
|
T::Element: Scalar,
|
||||||
C: TCategory,
|
C: TCategory,
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
+ Allocator<T::Element, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
|
||||||
{
|
{
|
||||||
type Element = Transform<T::Element, C, D>;
|
type Element = Transform<T::Element, C, D>;
|
||||||
type SimdBool = T::SimdBool;
|
type SimdBool = T::SimdBool;
|
||||||
|
|
|
@ -153,7 +153,7 @@ impl<T: Scalar, const D: usize> Translation<T, D> {
|
||||||
where
|
where
|
||||||
T: Zero + One,
|
T: Zero + One,
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
{
|
{
|
||||||
let mut res = OMatrix::<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>::identity();
|
let mut res = OMatrix::<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>::identity();
|
||||||
res.fixed_view_mut::<D, 1>(0, D).copy_from(&self.vector);
|
res.fixed_view_mut::<D, 1>(0, D).copy_from(&self.vector);
|
||||||
|
|
|
@ -11,7 +11,7 @@ use crate::geometry::{
|
||||||
AbstractRotation, Isometry, Similarity, SuperTCategoryOf, TAffine, Transform, Translation,
|
AbstractRotation, Isometry, Similarity, SuperTCategoryOf, TAffine, Transform, Translation,
|
||||||
Translation3, UnitDualQuaternion, UnitQuaternion,
|
Translation3, UnitDualQuaternion, UnitQuaternion,
|
||||||
};
|
};
|
||||||
use crate::Point;
|
use crate::{ArrayStorage, Point};
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* This file provides the following conversions:
|
* This file provides the following conversions:
|
||||||
|
@ -122,8 +122,7 @@ where
|
||||||
T2: RealField + SupersetOf<T1>,
|
T2: RealField + SupersetOf<T1>,
|
||||||
C: SuperTCategoryOf<TAffine>,
|
C: SuperTCategoryOf<TAffine>,
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
DefaultAllocator: Allocator<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
+ Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn to_superset(&self) -> Transform<T2, C, D> {
|
fn to_superset(&self) -> Transform<T2, C, D> {
|
||||||
|
@ -147,10 +146,8 @@ where
|
||||||
T1: RealField,
|
T1: RealField,
|
||||||
T2: RealField + SupersetOf<T1>,
|
T2: RealField + SupersetOf<T1>,
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
DefaultAllocator: Allocator<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
DefaultAllocator: Allocator<Const<D>, Buffer<T1> = ArrayStorage<T1, D, 1>>
|
||||||
+ Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
+ Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
// + Allocator<T1, D>
|
|
||||||
// + Allocator<T2, D>
|
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn to_superset(&self) -> OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> {
|
fn to_superset(&self) -> OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> {
|
||||||
|
@ -173,9 +170,9 @@ where
|
||||||
fn from_superset_unchecked(
|
fn from_superset_unchecked(
|
||||||
m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
) -> Self {
|
) -> Self {
|
||||||
let t = m.fixed_view::<D, 1>(0, D);
|
let t: OVector<T2, Const<D>> = m.fixed_view::<D, 1>(0, D).into_owned();
|
||||||
Self {
|
Self {
|
||||||
vector: crate::convert_unchecked(t.into_owned()),
|
vector: crate::convert_unchecked(t),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -185,7 +182,7 @@ impl<T: Scalar + Zero + One, const D: usize> From<Translation<T, D>>
|
||||||
where
|
where
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
DefaultAllocator:
|
DefaultAllocator:
|
||||||
Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> + Allocator<T, Const<D>>,
|
Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> + Allocator<Const<D>>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn from(t: Translation<T, D>) -> Self {
|
fn from(t: Translation<T, D>) -> Self {
|
||||||
|
|
|
@ -275,7 +275,7 @@ pub fn abs<T: Signed>(a: &T) -> T {
|
||||||
pub fn inf<T, R: Dim, C: Dim>(a: &OMatrix<T, R, C>, b: &OMatrix<T, R, C>) -> OMatrix<T, R, C>
|
pub fn inf<T, R: Dim, C: Dim>(a: &OMatrix<T, R, C>, b: &OMatrix<T, R, C>) -> OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
T: Scalar + SimdPartialOrd,
|
T: Scalar + SimdPartialOrd,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
a.inf(b)
|
a.inf(b)
|
||||||
}
|
}
|
||||||
|
@ -286,7 +286,7 @@ where
|
||||||
pub fn sup<T, R: Dim, C: Dim>(a: &OMatrix<T, R, C>, b: &OMatrix<T, R, C>) -> OMatrix<T, R, C>
|
pub fn sup<T, R: Dim, C: Dim>(a: &OMatrix<T, R, C>, b: &OMatrix<T, R, C>) -> OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
T: Scalar + SimdPartialOrd,
|
T: Scalar + SimdPartialOrd,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
a.sup(b)
|
a.sup(b)
|
||||||
}
|
}
|
||||||
|
@ -300,7 +300,7 @@ pub fn inf_sup<T, R: Dim, C: Dim>(
|
||||||
) -> (OMatrix<T, R, C>, OMatrix<T, R, C>)
|
) -> (OMatrix<T, R, C>, OMatrix<T, R, C>)
|
||||||
where
|
where
|
||||||
T: Scalar + SimdPartialOrd,
|
T: Scalar + SimdPartialOrd,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
a.inf_sup(b)
|
a.inf_sup(b)
|
||||||
}
|
}
|
||||||
|
|
|
@ -13,7 +13,7 @@ use crate::base::{Const, DefaultAllocator, OMatrix, OVector};
|
||||||
/// See <https://arxiv.org/pdf/1401.5766.pdf>
|
/// See <https://arxiv.org/pdf/1401.5766.pdf>
|
||||||
pub fn balance_parlett_reinsch<T: RealField, D: Dim>(matrix: &mut OMatrix<T, D, D>) -> OVector<T, D>
|
pub fn balance_parlett_reinsch<T: RealField, D: Dim>(matrix: &mut OMatrix<T, D, D>) -> OVector<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
|
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
{
|
{
|
||||||
assert!(matrix.is_square(), "Unable to balance a non-square matrix.");
|
assert!(matrix.is_square(), "Unable to balance a non-square matrix.");
|
||||||
|
|
||||||
|
@ -68,7 +68,7 @@ where
|
||||||
/// Computes in-place `D * m * D.inverse()`, where `D` is the matrix with diagonal `d`.
|
/// Computes in-place `D * m * D.inverse()`, where `D` is the matrix with diagonal `d`.
|
||||||
pub fn unbalance<T: RealField, D: Dim>(m: &mut OMatrix<T, D, D>, d: &OVector<T, D>)
|
pub fn unbalance<T: RealField, D: Dim>(m: &mut OMatrix<T, D, D>, d: &OVector<T, D>)
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
|
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
{
|
{
|
||||||
assert!(m.is_square(), "Unable to unbalance a non-square matrix.");
|
assert!(m.is_square(), "Unable to unbalance a non-square matrix.");
|
||||||
assert_eq!(m.nrows(), d.len(), "Unbalancing: mismatched dimensions.");
|
assert_eq!(m.nrows(), d.len(), "Unbalancing: mismatched dimensions.");
|
||||||
|
|
|
@ -16,9 +16,9 @@ use std::mem::MaybeUninit;
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(serialize = "DimMinimum<R, C>: DimSub<U1>,
|
serde(bound(serialize = "DimMinimum<R, C>: DimSub<U1>,
|
||||||
DefaultAllocator: Allocator<T, R, C> +
|
DefaultAllocator: Allocator<R, C> +
|
||||||
Allocator<T, DimMinimum<R, C>> +
|
Allocator<DimMinimum<R, C>> +
|
||||||
Allocator<T, DimDiff<DimMinimum<R, C>, U1>>,
|
Allocator<DimDiff<DimMinimum<R, C>, U1>>,
|
||||||
OMatrix<T, R, C>: Serialize,
|
OMatrix<T, R, C>: Serialize,
|
||||||
OVector<T, DimMinimum<R, C>>: Serialize,
|
OVector<T, DimMinimum<R, C>>: Serialize,
|
||||||
OVector<T, DimDiff<DimMinimum<R, C>, U1>>: Serialize"))
|
OVector<T, DimDiff<DimMinimum<R, C>, U1>>: Serialize"))
|
||||||
|
@ -26,9 +26,9 @@ use std::mem::MaybeUninit;
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(deserialize = "DimMinimum<R, C>: DimSub<U1>,
|
serde(bound(deserialize = "DimMinimum<R, C>: DimSub<U1>,
|
||||||
DefaultAllocator: Allocator<T, R, C> +
|
DefaultAllocator: Allocator<R, C> +
|
||||||
Allocator<T, DimMinimum<R, C>> +
|
Allocator<DimMinimum<R, C>> +
|
||||||
Allocator<T, DimDiff<DimMinimum<R, C>, U1>>,
|
Allocator<DimDiff<DimMinimum<R, C>, U1>>,
|
||||||
OMatrix<T, R, C>: Deserialize<'de>,
|
OMatrix<T, R, C>: Deserialize<'de>,
|
||||||
OVector<T, DimMinimum<R, C>>: Deserialize<'de>,
|
OVector<T, DimMinimum<R, C>>: Deserialize<'de>,
|
||||||
OVector<T, DimDiff<DimMinimum<R, C>, U1>>: Deserialize<'de>"))
|
OVector<T, DimDiff<DimMinimum<R, C>, U1>>: Deserialize<'de>"))
|
||||||
|
@ -37,9 +37,8 @@ use std::mem::MaybeUninit;
|
||||||
pub struct Bidiagonal<T: ComplexField, R: DimMin<C>, C: Dim>
|
pub struct Bidiagonal<T: ComplexField, R: DimMin<C>, C: Dim>
|
||||||
where
|
where
|
||||||
DimMinimum<R, C>: DimSub<U1>,
|
DimMinimum<R, C>: DimSub<U1>,
|
||||||
DefaultAllocator: Allocator<T, R, C>
|
DefaultAllocator:
|
||||||
+ Allocator<T, DimMinimum<R, C>>
|
Allocator<R, C> + Allocator<DimMinimum<R, C>> + Allocator<DimDiff<DimMinimum<R, C>, U1>>,
|
||||||
+ Allocator<T, DimDiff<DimMinimum<R, C>, U1>>,
|
|
||||||
{
|
{
|
||||||
// TODO: perhaps we should pack the axes into different vectors so that axes for `v_t` are
|
// TODO: perhaps we should pack the axes into different vectors so that axes for `v_t` are
|
||||||
// contiguous. This prevents some useless copies.
|
// contiguous. This prevents some useless copies.
|
||||||
|
@ -54,9 +53,8 @@ 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, DimMinimum<R, C>>
|
Allocator<R, C> + Allocator<DimMinimum<R, C>> + Allocator<DimDiff<DimMinimum<R, C>, U1>>,
|
||||||
+ Allocator<T, DimDiff<DimMinimum<R, C>, U1>>,
|
|
||||||
OMatrix<T, R, C>: Copy,
|
OMatrix<T, R, C>: Copy,
|
||||||
OVector<T, DimMinimum<R, C>>: Copy,
|
OVector<T, DimMinimum<R, C>>: Copy,
|
||||||
OVector<T, DimDiff<DimMinimum<R, C>, U1>>: Copy,
|
OVector<T, DimDiff<DimMinimum<R, C>, U1>>: Copy,
|
||||||
|
@ -66,11 +64,11 @@ where
|
||||||
impl<T: ComplexField, R: DimMin<C>, C: Dim> Bidiagonal<T, R, C>
|
impl<T: ComplexField, R: DimMin<C>, C: Dim> Bidiagonal<T, R, C>
|
||||||
where
|
where
|
||||||
DimMinimum<R, C>: DimSub<U1>,
|
DimMinimum<R, C>: DimSub<U1>,
|
||||||
DefaultAllocator: Allocator<T, R, C>
|
DefaultAllocator: Allocator<R, C>
|
||||||
+ Allocator<T, C>
|
+ Allocator<C>
|
||||||
+ Allocator<T, R>
|
+ Allocator<R>
|
||||||
+ Allocator<T, DimMinimum<R, C>>
|
+ Allocator<DimMinimum<R, C>>
|
||||||
+ Allocator<T, DimDiff<DimMinimum<R, C>, U1>>,
|
+ Allocator<DimDiff<DimMinimum<R, C>, U1>>,
|
||||||
{
|
{
|
||||||
/// Computes the Bidiagonal decomposition using householder reflections.
|
/// Computes the Bidiagonal decomposition using householder reflections.
|
||||||
pub fn new(mut matrix: OMatrix<T, R, C>) -> Self {
|
pub fn new(mut matrix: OMatrix<T, R, C>) -> Self {
|
||||||
|
@ -177,9 +175,9 @@ where
|
||||||
OMatrix<T, DimMinimum<R, C>, C>,
|
OMatrix<T, DimMinimum<R, C>, C>,
|
||||||
)
|
)
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, DimMinimum<R, C>, DimMinimum<R, C>>
|
DefaultAllocator: Allocator<DimMinimum<R, C>, DimMinimum<R, C>>
|
||||||
+ Allocator<T, R, DimMinimum<R, C>>
|
+ Allocator<R, DimMinimum<R, C>>
|
||||||
+ Allocator<T, DimMinimum<R, C>, C>,
|
+ Allocator<DimMinimum<R, C>, C>,
|
||||||
{
|
{
|
||||||
// TODO: optimize by calling a reallocator.
|
// TODO: optimize by calling a reallocator.
|
||||||
(self.u(), self.d(), self.v_t())
|
(self.u(), self.d(), self.v_t())
|
||||||
|
@ -190,7 +188,7 @@ where
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn d(&self) -> OMatrix<T, DimMinimum<R, C>, DimMinimum<R, C>>
|
pub fn d(&self) -> OMatrix<T, DimMinimum<R, C>, DimMinimum<R, C>>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, DimMinimum<R, C>, DimMinimum<R, C>>,
|
DefaultAllocator: Allocator<DimMinimum<R, C>, DimMinimum<R, C>>,
|
||||||
{
|
{
|
||||||
let (nrows, ncols) = self.uv.shape_generic();
|
let (nrows, ncols) = self.uv.shape_generic();
|
||||||
|
|
||||||
|
@ -218,7 +216,7 @@ where
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn u(&self) -> OMatrix<T, R, DimMinimum<R, C>>
|
pub fn u(&self) -> OMatrix<T, R, DimMinimum<R, C>>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, DimMinimum<R, C>>,
|
DefaultAllocator: Allocator<R, DimMinimum<R, C>>,
|
||||||
{
|
{
|
||||||
let (nrows, ncols) = self.uv.shape_generic();
|
let (nrows, ncols) = self.uv.shape_generic();
|
||||||
|
|
||||||
|
@ -253,7 +251,7 @@ where
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn v_t(&self) -> OMatrix<T, DimMinimum<R, C>, C>
|
pub fn v_t(&self) -> OMatrix<T, DimMinimum<R, C>, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, DimMinimum<R, C>, C>,
|
DefaultAllocator: Allocator<DimMinimum<R, C>, C>,
|
||||||
{
|
{
|
||||||
let (nrows, ncols) = self.uv.shape_generic();
|
let (nrows, ncols) = self.uv.shape_generic();
|
||||||
let min_nrows_ncols = nrows.min(ncols);
|
let min_nrows_ncols = nrows.min(ncols);
|
||||||
|
@ -293,7 +291,7 @@ where
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn diagonal(&self) -> OVector<T::RealField, DimMinimum<R, C>>
|
pub fn diagonal(&self) -> OVector<T::RealField, DimMinimum<R, C>>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T::RealField, DimMinimum<R, C>>,
|
DefaultAllocator: Allocator<DimMinimum<R, C>>,
|
||||||
{
|
{
|
||||||
self.diagonal.map(|e| e.modulus())
|
self.diagonal.map(|e| e.modulus())
|
||||||
}
|
}
|
||||||
|
@ -302,7 +300,7 @@ where
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn off_diagonal(&self) -> OVector<T::RealField, DimDiff<DimMinimum<R, C>, U1>>
|
pub fn off_diagonal(&self) -> OVector<T::RealField, DimDiff<DimMinimum<R, C>, U1>>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T::RealField, DimDiff<DimMinimum<R, C>, U1>>,
|
DefaultAllocator: Allocator<DimDiff<DimMinimum<R, C>, U1>>,
|
||||||
{
|
{
|
||||||
self.off_diagonal.map(|e| e.modulus())
|
self.off_diagonal.map(|e| e.modulus())
|
||||||
}
|
}
|
||||||
|
@ -314,8 +312,8 @@ where
|
||||||
}
|
}
|
||||||
|
|
||||||
// impl<T: ComplexField, D: DimMin<D, Output = D> + DimSub<Dyn>> Bidiagonal<T, D, D>
|
// impl<T: ComplexField, D: DimMin<D, Output = D> + DimSub<Dyn>> Bidiagonal<T, D, D>
|
||||||
// where DefaultAllocator: Allocator<T, D, D> +
|
// where DefaultAllocator: Allocator<D, D> +
|
||||||
// Allocator<T, D> {
|
// Allocator<D> {
|
||||||
// /// Solves the linear system `self * x = b`, where `x` is the unknown to be determined.
|
// /// Solves the linear system `self * x = b`, where `x` is the unknown to be determined.
|
||||||
// pub fn solve<R2: Dim, C2: Dim, S2>(&self, b: &Matrix<T, R2, C2, S2>) -> OMatrix<T, R2, C2>
|
// pub fn solve<R2: Dim, C2: Dim, S2>(&self, b: &Matrix<T, R2, C2, S2>) -> OMatrix<T, R2, C2>
|
||||||
// where S2: StorageMut<T, R2, C2>,
|
// where S2: StorageMut<T, R2, C2>,
|
||||||
|
|
|
@ -15,32 +15,32 @@ use crate::storage::{Storage, StorageMut};
|
||||||
#[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))]
|
#[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(serialize = "DefaultAllocator: Allocator<T, D>,
|
serde(bound(serialize = "DefaultAllocator: Allocator<D>,
|
||||||
OMatrix<T, D, D>: Serialize"))
|
OMatrix<T, D, D>: Serialize"))
|
||||||
)]
|
)]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(deserialize = "DefaultAllocator: Allocator<T, D>,
|
serde(bound(deserialize = "DefaultAllocator: Allocator<D>,
|
||||||
OMatrix<T, D, D>: Deserialize<'de>"))
|
OMatrix<T, D, D>: Deserialize<'de>"))
|
||||||
)]
|
)]
|
||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
pub struct Cholesky<T: SimdComplexField, D: Dim>
|
pub struct Cholesky<T: SimdComplexField, D: Dim>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
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<D, D>,
|
||||||
OMatrix<T, D, D>: Copy,
|
OMatrix<T, D, D>: Copy,
|
||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T: SimdComplexField, D: Dim> Cholesky<T, D>
|
impl<T: SimdComplexField, D: Dim> Cholesky<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
/// Computes the Cholesky decomposition of `matrix` without checking that the matrix is definite-positive.
|
/// Computes the Cholesky decomposition of `matrix` without checking that the matrix is definite-positive.
|
||||||
///
|
///
|
||||||
|
@ -133,7 +133,7 @@ where
|
||||||
pub fn solve<R2: Dim, C2: Dim, S2>(&self, b: &Matrix<T, R2, C2, S2>) -> OMatrix<T, R2, C2>
|
pub fn solve<R2: Dim, C2: Dim, S2>(&self, b: &Matrix<T, R2, C2, S2>) -> OMatrix<T, R2, C2>
|
||||||
where
|
where
|
||||||
S2: Storage<T, R2, C2>,
|
S2: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: Allocator<T, R2, C2>,
|
DefaultAllocator: Allocator<R2, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<R2, D>,
|
ShapeConstraint: SameNumberOfRows<R2, D>,
|
||||||
{
|
{
|
||||||
let mut res = b.clone_owned();
|
let mut res = b.clone_owned();
|
||||||
|
@ -186,7 +186,7 @@ where
|
||||||
|
|
||||||
impl<T: ComplexField, D: Dim> Cholesky<T, D>
|
impl<T: ComplexField, D: Dim> Cholesky<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
/// Attempts to compute the Cholesky decomposition of `matrix`.
|
/// Attempts to compute the Cholesky decomposition of `matrix`.
|
||||||
///
|
///
|
||||||
|
@ -268,7 +268,7 @@ where
|
||||||
pub fn rank_one_update<R2: Dim, S2>(&mut self, x: &Vector<T, R2, S2>, sigma: T::RealField)
|
pub fn rank_one_update<R2: Dim, S2>(&mut self, x: &Vector<T, R2, S2>, sigma: T::RealField)
|
||||||
where
|
where
|
||||||
S2: Storage<T, R2, U1>,
|
S2: Storage<T, R2, U1>,
|
||||||
DefaultAllocator: Allocator<T, R2, U1>,
|
DefaultAllocator: Allocator<R2, U1>,
|
||||||
ShapeConstraint: SameNumberOfRows<R2, D>,
|
ShapeConstraint: SameNumberOfRows<R2, D>,
|
||||||
{
|
{
|
||||||
Self::xx_rank_one_update(&mut self.chol, &mut x.clone_owned(), sigma)
|
Self::xx_rank_one_update(&mut self.chol, &mut x.clone_owned(), sigma)
|
||||||
|
@ -285,7 +285,7 @@ where
|
||||||
D: DimAdd<U1>,
|
D: DimAdd<U1>,
|
||||||
R2: Dim,
|
R2: Dim,
|
||||||
S2: Storage<T, R2, U1>,
|
S2: Storage<T, R2, U1>,
|
||||||
DefaultAllocator: Allocator<T, DimSum<D, U1>, DimSum<D, U1>> + Allocator<T, R2>,
|
DefaultAllocator: Allocator<DimSum<D, U1>, DimSum<D, U1>> + Allocator<R2>,
|
||||||
ShapeConstraint: SameNumberOfRows<R2, DimSum<D, U1>>,
|
ShapeConstraint: SameNumberOfRows<R2, DimSum<D, U1>>,
|
||||||
{
|
{
|
||||||
let mut col = col.into_owned();
|
let mut col = col.into_owned();
|
||||||
|
@ -357,7 +357,7 @@ where
|
||||||
pub fn remove_column(&self, j: usize) -> Cholesky<T, DimDiff<D, U1>>
|
pub fn remove_column(&self, j: usize) -> Cholesky<T, DimDiff<D, U1>>
|
||||||
where
|
where
|
||||||
D: DimSub<U1>,
|
D: DimSub<U1>,
|
||||||
DefaultAllocator: Allocator<T, DimDiff<D, U1>, DimDiff<D, U1>> + Allocator<T, D>,
|
DefaultAllocator: Allocator<DimDiff<D, U1>, DimDiff<D, U1>> + Allocator<D>,
|
||||||
{
|
{
|
||||||
let n = self.chol.nrows();
|
let n = self.chol.nrows();
|
||||||
assert!(n > 0, "The matrix needs at least one column.");
|
assert!(n > 0, "The matrix needs at least one column.");
|
||||||
|
|
|
@ -17,16 +17,16 @@ use std::mem::MaybeUninit;
|
||||||
#[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))]
|
#[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(serialize = "DefaultAllocator: Allocator<T, R, C> +
|
serde(bound(serialize = "DefaultAllocator: Allocator<R, C> +
|
||||||
Allocator<T, DimMinimum<R, C>>,
|
Allocator<DimMinimum<R, C>>,
|
||||||
OMatrix<T, R, C>: Serialize,
|
OMatrix<T, R, C>: Serialize,
|
||||||
PermutationSequence<DimMinimum<R, C>>: Serialize,
|
PermutationSequence<DimMinimum<R, C>>: Serialize,
|
||||||
OVector<T, DimMinimum<R, C>>: Serialize"))
|
OVector<T, DimMinimum<R, C>>: Serialize"))
|
||||||
)]
|
)]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(deserialize = "DefaultAllocator: Allocator<T, R, C> +
|
serde(bound(deserialize = "DefaultAllocator: Allocator<R, C> +
|
||||||
Allocator<T, DimMinimum<R, C>>,
|
Allocator<DimMinimum<R, C>>,
|
||||||
OMatrix<T, R, C>: Deserialize<'de>,
|
OMatrix<T, R, C>: Deserialize<'de>,
|
||||||
PermutationSequence<DimMinimum<R, C>>: Deserialize<'de>,
|
PermutationSequence<DimMinimum<R, C>>: Deserialize<'de>,
|
||||||
OVector<T, DimMinimum<R, C>>: Deserialize<'de>"))
|
OVector<T, DimMinimum<R, C>>: Deserialize<'de>"))
|
||||||
|
@ -34,9 +34,7 @@ use std::mem::MaybeUninit;
|
||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
pub struct ColPivQR<T: ComplexField, R: DimMin<C>, C: Dim>
|
pub struct ColPivQR<T: ComplexField, R: DimMin<C>, C: Dim>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C>
|
DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>>,
|
||||||
+ Allocator<T, DimMinimum<R, C>>
|
|
||||||
+ Allocator<(usize, usize), DimMinimum<R, C>>,
|
|
||||||
{
|
{
|
||||||
col_piv_qr: OMatrix<T, R, C>,
|
col_piv_qr: OMatrix<T, R, C>,
|
||||||
p: PermutationSequence<DimMinimum<R, C>>,
|
p: PermutationSequence<DimMinimum<R, C>>,
|
||||||
|
@ -45,9 +43,7 @@ where
|
||||||
|
|
||||||
impl<T: ComplexField, R: DimMin<C>, C: Dim> Copy for ColPivQR<T, R, C>
|
impl<T: ComplexField, R: DimMin<C>, C: Dim> Copy for ColPivQR<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C>
|
DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>>,
|
||||||
+ Allocator<T, DimMinimum<R, C>>
|
|
||||||
+ Allocator<(usize, usize), DimMinimum<R, C>>,
|
|
||||||
OMatrix<T, R, C>: Copy,
|
OMatrix<T, R, C>: Copy,
|
||||||
PermutationSequence<DimMinimum<R, C>>: Copy,
|
PermutationSequence<DimMinimum<R, C>>: Copy,
|
||||||
OVector<T, DimMinimum<R, C>>: Copy,
|
OVector<T, DimMinimum<R, C>>: Copy,
|
||||||
|
@ -56,10 +52,7 @@ where
|
||||||
|
|
||||||
impl<T: ComplexField, R: DimMin<C>, C: Dim> ColPivQR<T, R, C>
|
impl<T: ComplexField, R: DimMin<C>, C: Dim> ColPivQR<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C>
|
DefaultAllocator: Allocator<R, C> + Allocator<R> + Allocator<DimMinimum<R, C>>,
|
||||||
+ Allocator<T, R>
|
|
||||||
+ Allocator<T, DimMinimum<R, C>>
|
|
||||||
+ Allocator<(usize, usize), DimMinimum<R, C>>,
|
|
||||||
{
|
{
|
||||||
/// Computes the `ColPivQR` decomposition using householder reflections.
|
/// Computes the `ColPivQR` decomposition using householder reflections.
|
||||||
pub fn new(mut matrix: OMatrix<T, R, C>) -> Self {
|
pub fn new(mut matrix: OMatrix<T, R, C>) -> Self {
|
||||||
|
@ -102,7 +95,7 @@ where
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn r(&self) -> OMatrix<T, DimMinimum<R, C>, C>
|
pub fn r(&self) -> OMatrix<T, DimMinimum<R, C>, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, DimMinimum<R, C>, C>,
|
DefaultAllocator: Allocator<DimMinimum<R, C>, C>,
|
||||||
{
|
{
|
||||||
let (nrows, ncols) = self.col_piv_qr.shape_generic();
|
let (nrows, ncols) = self.col_piv_qr.shape_generic();
|
||||||
let mut res = self
|
let mut res = self
|
||||||
|
@ -134,7 +127,7 @@ where
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn q(&self) -> OMatrix<T, R, DimMinimum<R, C>>
|
pub fn q(&self) -> OMatrix<T, R, DimMinimum<R, C>>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, DimMinimum<R, C>>,
|
DefaultAllocator: Allocator<R, DimMinimum<R, C>>,
|
||||||
{
|
{
|
||||||
let (nrows, ncols) = self.col_piv_qr.shape_generic();
|
let (nrows, ncols) = self.col_piv_qr.shape_generic();
|
||||||
|
|
||||||
|
@ -171,9 +164,9 @@ where
|
||||||
)
|
)
|
||||||
where
|
where
|
||||||
DimMinimum<R, C>: DimMin<C, Output = DimMinimum<R, C>>,
|
DimMinimum<R, C>: DimMin<C, Output = DimMinimum<R, C>>,
|
||||||
DefaultAllocator: Allocator<T, R, DimMinimum<R, C>>
|
DefaultAllocator: Allocator<R, DimMinimum<R, C>>
|
||||||
+ Reallocator<T, R, C, DimMinimum<R, C>, C>
|
+ Reallocator<T, R, C, DimMinimum<R, C>, C>
|
||||||
+ Allocator<(usize, usize), DimMinimum<R, C>>,
|
+ Allocator<DimMinimum<R, C>>,
|
||||||
{
|
{
|
||||||
(self.q(), self.r(), self.p)
|
(self.q(), self.r(), self.p)
|
||||||
}
|
}
|
||||||
|
@ -202,8 +195,7 @@ where
|
||||||
|
|
||||||
impl<T: ComplexField, D: DimMin<D, Output = D>> ColPivQR<T, D, D>
|
impl<T: ComplexField, D: DimMin<D, Output = D>> ColPivQR<T, D, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator:
|
DefaultAllocator: Allocator<D, D> + Allocator<D> + Allocator<DimMinimum<D, D>>,
|
||||||
Allocator<T, D, D> + Allocator<T, D> + Allocator<(usize, usize), DimMinimum<D, D>>,
|
|
||||||
{
|
{
|
||||||
/// Solves the linear system `self * x = b`, where `x` is the unknown to be determined.
|
/// Solves the linear system `self * x = b`, where `x` is the unknown to be determined.
|
||||||
///
|
///
|
||||||
|
@ -216,7 +208,7 @@ where
|
||||||
where
|
where
|
||||||
S2: StorageMut<T, R2, C2>,
|
S2: StorageMut<T, R2, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<R2, D>,
|
ShapeConstraint: SameNumberOfRows<R2, D>,
|
||||||
DefaultAllocator: Allocator<T, R2, C2>,
|
DefaultAllocator: Allocator<R2, C2>,
|
||||||
{
|
{
|
||||||
let mut res = b.clone_owned();
|
let mut res = b.clone_owned();
|
||||||
|
|
||||||
|
|
|
@ -25,7 +25,7 @@ impl<T: RealField, D1: Dim, S1: Storage<T, D1>> Vector<T, D1, S1> {
|
||||||
D2: DimAdd<D1, Output = DimSum<D1, D2>>,
|
D2: DimAdd<D1, Output = DimSum<D1, D2>>,
|
||||||
DimSum<D1, D2>: DimSub<U1>,
|
DimSum<D1, D2>: DimSub<U1>,
|
||||||
S2: Storage<T, D2>,
|
S2: Storage<T, D2>,
|
||||||
DefaultAllocator: Allocator<T, DimDiff<DimSum<D1, D2>, U1>>,
|
DefaultAllocator: Allocator<DimDiff<DimSum<D1, D2>, U1>>,
|
||||||
{
|
{
|
||||||
let vec = self.len();
|
let vec = self.len();
|
||||||
let ker = kernel.len();
|
let ker = kernel.len();
|
||||||
|
@ -78,7 +78,7 @@ impl<T: RealField, D1: Dim, S1: Storage<T, D1>> Vector<T, D1, S1> {
|
||||||
D2: Dim,
|
D2: Dim,
|
||||||
DimSum<D1, U1>: DimSub<D2>,
|
DimSum<D1, U1>: DimSub<D2>,
|
||||||
S2: Storage<T, D2>,
|
S2: Storage<T, D2>,
|
||||||
DefaultAllocator: Allocator<T, DimDiff<DimSum<D1, U1>, D2>>,
|
DefaultAllocator: Allocator<DimDiff<DimSum<D1, U1>, D2>>,
|
||||||
{
|
{
|
||||||
let vec = self.len();
|
let vec = self.len();
|
||||||
let ker = kernel.len();
|
let ker = kernel.len();
|
||||||
|
@ -117,7 +117,7 @@ impl<T: RealField, D1: Dim, S1: Storage<T, D1>> Vector<T, D1, S1> {
|
||||||
where
|
where
|
||||||
D2: Dim,
|
D2: Dim,
|
||||||
S2: Storage<T, D2>,
|
S2: Storage<T, D2>,
|
||||||
DefaultAllocator: Allocator<T, D1>,
|
DefaultAllocator: Allocator<D1>,
|
||||||
{
|
{
|
||||||
let vec = self.len();
|
let vec = self.len();
|
||||||
let ker = kernel.len();
|
let ker = kernel.len();
|
||||||
|
|
|
@ -24,11 +24,11 @@ impl<T: ComplexField, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
where
|
where
|
||||||
R: DimMin<C>,
|
R: DimMin<C>,
|
||||||
DimMinimum<R, C>: DimSub<U1>,
|
DimMinimum<R, C>: DimSub<U1>,
|
||||||
DefaultAllocator: Allocator<T, R, C>
|
DefaultAllocator: Allocator<R, C>
|
||||||
+ Allocator<T, C>
|
+ Allocator<C>
|
||||||
+ Allocator<T, R>
|
+ Allocator<R>
|
||||||
+ Allocator<T, DimMinimum<R, C>>
|
+ Allocator<DimMinimum<R, C>>
|
||||||
+ Allocator<T, DimDiff<DimMinimum<R, C>, U1>>,
|
+ Allocator<DimDiff<DimMinimum<R, C>, U1>>,
|
||||||
{
|
{
|
||||||
Bidiagonal::new(self.into_owned())
|
Bidiagonal::new(self.into_owned())
|
||||||
}
|
}
|
||||||
|
@ -39,7 +39,7 @@ impl<T: ComplexField, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
pub fn full_piv_lu(self) -> FullPivLU<T, R, C>
|
pub fn full_piv_lu(self) -> FullPivLU<T, R, C>
|
||||||
where
|
where
|
||||||
R: DimMin<C>,
|
R: DimMin<C>,
|
||||||
DefaultAllocator: Allocator<T, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
|
DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>>,
|
||||||
{
|
{
|
||||||
FullPivLU::new(self.into_owned())
|
FullPivLU::new(self.into_owned())
|
||||||
}
|
}
|
||||||
|
@ -48,7 +48,7 @@ impl<T: ComplexField, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
pub fn lu(self) -> LU<T, R, C>
|
pub fn lu(self) -> LU<T, R, C>
|
||||||
where
|
where
|
||||||
R: DimMin<C>,
|
R: DimMin<C>,
|
||||||
DefaultAllocator: Allocator<T, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
|
DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>>,
|
||||||
{
|
{
|
||||||
LU::new(self.into_owned())
|
LU::new(self.into_owned())
|
||||||
}
|
}
|
||||||
|
@ -57,7 +57,7 @@ impl<T: ComplexField, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
pub fn qr(self) -> QR<T, R, C>
|
pub fn qr(self) -> QR<T, R, C>
|
||||||
where
|
where
|
||||||
R: DimMin<C>,
|
R: DimMin<C>,
|
||||||
DefaultAllocator: Allocator<T, R, C> + Allocator<T, R> + Allocator<T, DimMinimum<R, C>>,
|
DefaultAllocator: Allocator<R, C> + Allocator<R> + Allocator<DimMinimum<R, C>>,
|
||||||
{
|
{
|
||||||
QR::new(self.into_owned())
|
QR::new(self.into_owned())
|
||||||
}
|
}
|
||||||
|
@ -66,10 +66,10 @@ impl<T: ComplexField, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
pub fn col_piv_qr(self) -> ColPivQR<T, R, C>
|
pub fn col_piv_qr(self) -> ColPivQR<T, R, C>
|
||||||
where
|
where
|
||||||
R: DimMin<C>,
|
R: DimMin<C>,
|
||||||
DefaultAllocator: Allocator<T, R, C>
|
DefaultAllocator: Allocator<R, C>
|
||||||
+ Allocator<T, R>
|
+ Allocator<R>
|
||||||
+ Allocator<T, DimMinimum<R, C>>
|
+ Allocator<DimMinimum<R, C>>
|
||||||
+ Allocator<(usize, usize), DimMinimum<R, C>>,
|
+ Allocator<DimMinimum<R, C>>,
|
||||||
{
|
{
|
||||||
ColPivQR::new(self.into_owned())
|
ColPivQR::new(self.into_owned())
|
||||||
}
|
}
|
||||||
|
@ -81,17 +81,13 @@ impl<T: ComplexField, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
where
|
where
|
||||||
R: DimMin<C>,
|
R: DimMin<C>,
|
||||||
DimMinimum<R, C>: DimSub<U1>, // for Bidiagonal.
|
DimMinimum<R, C>: DimSub<U1>, // for Bidiagonal.
|
||||||
DefaultAllocator: Allocator<T, R, C>
|
DefaultAllocator: Allocator<R, C>
|
||||||
+ Allocator<T, C>
|
+ Allocator<C>
|
||||||
+ Allocator<T, R>
|
+ Allocator<R>
|
||||||
+ Allocator<T, DimDiff<DimMinimum<R, C>, U1>>
|
+ Allocator<DimDiff<DimMinimum<R, C>, U1>>
|
||||||
+ Allocator<T, DimMinimum<R, C>, C>
|
+ Allocator<DimMinimum<R, C>, C>
|
||||||
+ Allocator<T, R, DimMinimum<R, C>>
|
+ Allocator<R, DimMinimum<R, C>>
|
||||||
+ Allocator<T, DimMinimum<R, C>>
|
+ Allocator<DimMinimum<R, C>>,
|
||||||
+ Allocator<T::RealField, DimMinimum<R, C>>
|
|
||||||
+ Allocator<T::RealField, DimDiff<DimMinimum<R, C>, U1>>
|
|
||||||
+ Allocator<(usize, usize), DimMinimum<R, C>>
|
|
||||||
+ Allocator<(T::RealField, usize), DimMinimum<R, C>>,
|
|
||||||
{
|
{
|
||||||
SVD::new(self.into_owned(), compute_u, compute_v)
|
SVD::new(self.into_owned(), compute_u, compute_v)
|
||||||
}
|
}
|
||||||
|
@ -103,15 +99,13 @@ impl<T: ComplexField, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
where
|
where
|
||||||
R: DimMin<C>,
|
R: DimMin<C>,
|
||||||
DimMinimum<R, C>: DimSub<U1>, // for Bidiagonal.
|
DimMinimum<R, C>: DimSub<U1>, // for Bidiagonal.
|
||||||
DefaultAllocator: Allocator<T, R, C>
|
DefaultAllocator: Allocator<R, C>
|
||||||
+ Allocator<T, C>
|
+ Allocator<C>
|
||||||
+ Allocator<T, R>
|
+ Allocator<R>
|
||||||
+ Allocator<T, DimDiff<DimMinimum<R, C>, U1>>
|
+ Allocator<DimDiff<DimMinimum<R, C>, U1>>
|
||||||
+ Allocator<T, DimMinimum<R, C>, C>
|
+ Allocator<DimMinimum<R, C>, C>
|
||||||
+ Allocator<T, R, DimMinimum<R, C>>
|
+ Allocator<R, DimMinimum<R, C>>
|
||||||
+ Allocator<T, DimMinimum<R, C>>
|
+ Allocator<DimMinimum<R, C>>,
|
||||||
+ Allocator<T::RealField, DimMinimum<R, C>>
|
|
||||||
+ Allocator<T::RealField, DimDiff<DimMinimum<R, C>, U1>>,
|
|
||||||
{
|
{
|
||||||
SVD::new_unordered(self.into_owned(), compute_u, compute_v)
|
SVD::new_unordered(self.into_owned(), compute_u, compute_v)
|
||||||
}
|
}
|
||||||
|
@ -138,17 +132,13 @@ impl<T: ComplexField, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
where
|
where
|
||||||
R: DimMin<C>,
|
R: DimMin<C>,
|
||||||
DimMinimum<R, C>: DimSub<U1>, // for Bidiagonal.
|
DimMinimum<R, C>: DimSub<U1>, // for Bidiagonal.
|
||||||
DefaultAllocator: Allocator<T, R, C>
|
DefaultAllocator: Allocator<R, C>
|
||||||
+ Allocator<T, C>
|
+ Allocator<C>
|
||||||
+ Allocator<T, R>
|
+ Allocator<R>
|
||||||
+ Allocator<T, DimDiff<DimMinimum<R, C>, U1>>
|
+ Allocator<DimDiff<DimMinimum<R, C>, U1>>
|
||||||
+ Allocator<T, DimMinimum<R, C>, C>
|
+ Allocator<DimMinimum<R, C>, C>
|
||||||
+ Allocator<T, R, DimMinimum<R, C>>
|
+ Allocator<R, DimMinimum<R, C>>
|
||||||
+ Allocator<T, DimMinimum<R, C>>
|
+ Allocator<DimMinimum<R, C>>,
|
||||||
+ Allocator<T::RealField, DimMinimum<R, C>>
|
|
||||||
+ Allocator<T::RealField, DimDiff<DimMinimum<R, C>, U1>>
|
|
||||||
+ Allocator<(usize, usize), DimMinimum<R, C>>
|
|
||||||
+ Allocator<(T::RealField, usize), DimMinimum<R, C>>,
|
|
||||||
{
|
{
|
||||||
SVD::try_new(self.into_owned(), compute_u, compute_v, eps, max_niter)
|
SVD::try_new(self.into_owned(), compute_u, compute_v, eps, max_niter)
|
||||||
}
|
}
|
||||||
|
@ -175,15 +165,15 @@ impl<T: ComplexField, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
where
|
where
|
||||||
R: DimMin<C>,
|
R: DimMin<C>,
|
||||||
DimMinimum<R, C>: DimSub<U1>, // for Bidiagonal.
|
DimMinimum<R, C>: DimSub<U1>, // for Bidiagonal.
|
||||||
DefaultAllocator: Allocator<T, R, C>
|
DefaultAllocator: Allocator<R, C>
|
||||||
+ Allocator<T, C>
|
+ Allocator<C>
|
||||||
+ Allocator<T, R>
|
+ Allocator<R>
|
||||||
+ Allocator<T, DimDiff<DimMinimum<R, C>, U1>>
|
+ Allocator<DimDiff<DimMinimum<R, C>, U1>>
|
||||||
+ Allocator<T, DimMinimum<R, C>, C>
|
+ Allocator<DimMinimum<R, C>, C>
|
||||||
+ Allocator<T, R, DimMinimum<R, C>>
|
+ Allocator<R, DimMinimum<R, C>>
|
||||||
+ Allocator<T, DimMinimum<R, C>>
|
+ Allocator<DimMinimum<R, C>>
|
||||||
+ Allocator<T::RealField, DimMinimum<R, C>>
|
+ Allocator<DimMinimum<R, C>>
|
||||||
+ Allocator<T::RealField, DimDiff<DimMinimum<R, C>, U1>>,
|
+ Allocator<DimDiff<DimMinimum<R, C>, U1>>,
|
||||||
{
|
{
|
||||||
SVD::try_new_unordered(self.into_owned(), compute_u, compute_v, eps, max_niter)
|
SVD::try_new_unordered(self.into_owned(), compute_u, compute_v, eps, max_niter)
|
||||||
}
|
}
|
||||||
|
@ -193,19 +183,19 @@ impl<T: ComplexField, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
where
|
where
|
||||||
R: DimMin<C>,
|
R: DimMin<C>,
|
||||||
DimMinimum<R, C>: DimSub<U1>, // for Bidiagonal.
|
DimMinimum<R, C>: DimSub<U1>, // for Bidiagonal.
|
||||||
DefaultAllocator: Allocator<T, R, C>
|
DefaultAllocator: Allocator<R, C>
|
||||||
+ Allocator<T, DimMinimum<R, C>, R>
|
+ Allocator<DimMinimum<R, C>, R>
|
||||||
+ Allocator<T, DimMinimum<R, C>>
|
+ Allocator<DimMinimum<R, C>>
|
||||||
+ Allocator<T, R, R>
|
+ Allocator<R, R>
|
||||||
+ Allocator<T, DimMinimum<R, C>, DimMinimum<R, C>>
|
+ Allocator<DimMinimum<R, C>, DimMinimum<R, C>>
|
||||||
+ Allocator<T, C>
|
+ Allocator<C>
|
||||||
+ Allocator<T, R>
|
+ Allocator<R>
|
||||||
+ Allocator<T, DimDiff<DimMinimum<R, C>, U1>>
|
+ Allocator<DimDiff<DimMinimum<R, C>, U1>>
|
||||||
+ Allocator<T, DimMinimum<R, C>, C>
|
+ Allocator<DimMinimum<R, C>, C>
|
||||||
+ Allocator<T, R, DimMinimum<R, C>>
|
+ Allocator<R, DimMinimum<R, C>>
|
||||||
+ Allocator<T, DimMinimum<R, C>>
|
+ Allocator<DimMinimum<R, C>>
|
||||||
+ Allocator<T::RealField, DimMinimum<R, C>>
|
+ Allocator<DimMinimum<R, C>>
|
||||||
+ Allocator<T::RealField, DimDiff<DimMinimum<R, C>, U1>>,
|
+ Allocator<DimDiff<DimMinimum<R, C>, U1>>,
|
||||||
{
|
{
|
||||||
SVD::new_unordered(self.into_owned(), true, true)
|
SVD::new_unordered(self.into_owned(), true, true)
|
||||||
.to_polar()
|
.to_polar()
|
||||||
|
@ -226,19 +216,19 @@ impl<T: ComplexField, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
where
|
where
|
||||||
R: DimMin<C>,
|
R: DimMin<C>,
|
||||||
DimMinimum<R, C>: DimSub<U1>, // for Bidiagonal.
|
DimMinimum<R, C>: DimSub<U1>, // for Bidiagonal.
|
||||||
DefaultAllocator: Allocator<T, R, C>
|
DefaultAllocator: Allocator<R, C>
|
||||||
+ Allocator<T, DimMinimum<R, C>, R>
|
+ Allocator<DimMinimum<R, C>, R>
|
||||||
+ Allocator<T, DimMinimum<R, C>>
|
+ Allocator<DimMinimum<R, C>>
|
||||||
+ Allocator<T, R, R>
|
+ Allocator<R, R>
|
||||||
+ Allocator<T, DimMinimum<R, C>, DimMinimum<R, C>>
|
+ Allocator<DimMinimum<R, C>, DimMinimum<R, C>>
|
||||||
+ Allocator<T, C>
|
+ Allocator<C>
|
||||||
+ Allocator<T, R>
|
+ Allocator<R>
|
||||||
+ Allocator<T, DimDiff<DimMinimum<R, C>, U1>>
|
+ Allocator<DimDiff<DimMinimum<R, C>, U1>>
|
||||||
+ Allocator<T, DimMinimum<R, C>, C>
|
+ Allocator<DimMinimum<R, C>, C>
|
||||||
+ Allocator<T, R, DimMinimum<R, C>>
|
+ Allocator<R, DimMinimum<R, C>>
|
||||||
+ Allocator<T, DimMinimum<R, C>>
|
+ Allocator<DimMinimum<R, C>>
|
||||||
+ Allocator<T::RealField, DimMinimum<R, C>>
|
+ Allocator<DimMinimum<R, C>>
|
||||||
+ Allocator<T::RealField, DimDiff<DimMinimum<R, C>, U1>>,
|
+ Allocator<DimDiff<DimMinimum<R, C>, U1>>,
|
||||||
{
|
{
|
||||||
SVD::try_new_unordered(self.into_owned(), true, true, eps, max_niter)
|
SVD::try_new_unordered(self.into_owned(), true, true, eps, max_niter)
|
||||||
.and_then(|svd| svd.to_polar())
|
.and_then(|svd| svd.to_polar())
|
||||||
|
@ -265,7 +255,7 @@ impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> Matrix<T, D, D, S> {
|
||||||
/// to be symmetric and only the lower-triangular part is read.
|
/// to be symmetric and only the lower-triangular part is read.
|
||||||
pub fn cholesky(self) -> Option<Cholesky<T, D>>
|
pub fn cholesky(self) -> Option<Cholesky<T, D>>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
Cholesky::new(self.into_owned())
|
Cholesky::new(self.into_owned())
|
||||||
}
|
}
|
||||||
|
@ -277,7 +267,7 @@ impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> Matrix<T, D, D, S> {
|
||||||
pub fn udu(self) -> Option<UDU<T, D>>
|
pub fn udu(self) -> Option<UDU<T, D>>
|
||||||
where
|
where
|
||||||
T: RealField,
|
T: RealField,
|
||||||
DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D> + Allocator<D, D>,
|
||||||
{
|
{
|
||||||
UDU::new(self.into_owned())
|
UDU::new(self.into_owned())
|
||||||
}
|
}
|
||||||
|
@ -286,7 +276,7 @@ impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> Matrix<T, D, D, S> {
|
||||||
pub fn hessenberg(self) -> Hessenberg<T, D>
|
pub fn hessenberg(self) -> Hessenberg<T, D>
|
||||||
where
|
where
|
||||||
D: DimSub<U1>,
|
D: DimSub<U1>,
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, D> + Allocator<T, DimDiff<D, U1>>,
|
DefaultAllocator: Allocator<D, D> + Allocator<D> + Allocator<DimDiff<D, U1>>,
|
||||||
{
|
{
|
||||||
Hessenberg::new(self.into_owned())
|
Hessenberg::new(self.into_owned())
|
||||||
}
|
}
|
||||||
|
@ -295,10 +285,10 @@ impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> Matrix<T, D, D, S> {
|
||||||
pub fn schur(self) -> Schur<T, D>
|
pub fn schur(self) -> Schur<T, D>
|
||||||
where
|
where
|
||||||
D: DimSub<U1>, // For Hessenberg.
|
D: DimSub<U1>, // For Hessenberg.
|
||||||
DefaultAllocator: Allocator<T, D, DimDiff<D, U1>>
|
DefaultAllocator: Allocator<D, DimDiff<D, U1>>
|
||||||
+ Allocator<T, DimDiff<D, U1>>
|
+ Allocator<DimDiff<D, U1>>
|
||||||
+ Allocator<T, D, D>
|
+ Allocator<D, D>
|
||||||
+ Allocator<T, D>,
|
+ Allocator<D>,
|
||||||
{
|
{
|
||||||
Schur::new(self.into_owned())
|
Schur::new(self.into_owned())
|
||||||
}
|
}
|
||||||
|
@ -317,10 +307,10 @@ impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> Matrix<T, D, D, S> {
|
||||||
pub fn try_schur(self, eps: T::RealField, max_niter: usize) -> Option<Schur<T, D>>
|
pub fn try_schur(self, eps: T::RealField, max_niter: usize) -> Option<Schur<T, D>>
|
||||||
where
|
where
|
||||||
D: DimSub<U1>, // For Hessenberg.
|
D: DimSub<U1>, // For Hessenberg.
|
||||||
DefaultAllocator: Allocator<T, D, DimDiff<D, U1>>
|
DefaultAllocator: Allocator<D, DimDiff<D, U1>>
|
||||||
+ Allocator<T, DimDiff<D, U1>>
|
+ Allocator<DimDiff<D, U1>>
|
||||||
+ Allocator<T, D, D>
|
+ Allocator<D, D>
|
||||||
+ Allocator<T, D>,
|
+ Allocator<D>,
|
||||||
{
|
{
|
||||||
Schur::try_new(self.into_owned(), eps, max_niter)
|
Schur::try_new(self.into_owned(), eps, max_niter)
|
||||||
}
|
}
|
||||||
|
@ -331,10 +321,8 @@ impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> Matrix<T, D, D, S> {
|
||||||
pub fn symmetric_eigen(self) -> SymmetricEigen<T, D>
|
pub fn symmetric_eigen(self) -> SymmetricEigen<T, D>
|
||||||
where
|
where
|
||||||
D: DimSub<U1>,
|
D: DimSub<U1>,
|
||||||
DefaultAllocator: Allocator<T, D, D>
|
DefaultAllocator:
|
||||||
+ Allocator<T, DimDiff<D, U1>>
|
Allocator<D, D> + Allocator<DimDiff<D, U1>> + Allocator<D> + Allocator<DimDiff<D, U1>>,
|
||||||
+ Allocator<T::RealField, D>
|
|
||||||
+ Allocator<T::RealField, DimDiff<D, U1>>,
|
|
||||||
{
|
{
|
||||||
SymmetricEigen::new(self.into_owned())
|
SymmetricEigen::new(self.into_owned())
|
||||||
}
|
}
|
||||||
|
@ -357,10 +345,8 @@ impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> Matrix<T, D, D, S> {
|
||||||
) -> Option<SymmetricEigen<T, D>>
|
) -> Option<SymmetricEigen<T, D>>
|
||||||
where
|
where
|
||||||
D: DimSub<U1>,
|
D: DimSub<U1>,
|
||||||
DefaultAllocator: Allocator<T, D, D>
|
DefaultAllocator:
|
||||||
+ Allocator<T, DimDiff<D, U1>>
|
Allocator<D, D> + Allocator<DimDiff<D, U1>> + Allocator<D> + Allocator<DimDiff<D, U1>>,
|
||||||
+ Allocator<T::RealField, D>
|
|
||||||
+ Allocator<T::RealField, DimDiff<D, U1>>,
|
|
||||||
{
|
{
|
||||||
SymmetricEigen::try_new(self.into_owned(), eps, max_niter)
|
SymmetricEigen::try_new(self.into_owned(), eps, max_niter)
|
||||||
}
|
}
|
||||||
|
@ -371,7 +357,7 @@ impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> Matrix<T, D, D, S> {
|
||||||
pub fn symmetric_tridiagonalize(self) -> SymmetricTridiagonal<T, D>
|
pub fn symmetric_tridiagonalize(self) -> SymmetricTridiagonal<T, D>
|
||||||
where
|
where
|
||||||
D: DimSub<U1>,
|
D: DimSub<U1>,
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>,
|
DefaultAllocator: Allocator<D, D> + Allocator<DimDiff<D, U1>>,
|
||||||
{
|
{
|
||||||
SymmetricTridiagonal::new(self.into_owned())
|
SymmetricTridiagonal::new(self.into_owned())
|
||||||
}
|
}
|
||||||
|
|
|
@ -15,7 +15,7 @@ impl<T: ComplexField, D: DimMin<D, Output = D>, S: Storage<T, D, D>> SquareMatri
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn determinant(&self) -> T
|
pub fn determinant(&self) -> T
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<(usize, usize), D>,
|
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
{
|
{
|
||||||
assert!(
|
assert!(
|
||||||
self.is_square(),
|
self.is_square(),
|
||||||
|
|
|
@ -23,20 +23,20 @@ use crate::linalg::Schur;
|
||||||
#[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))]
|
#[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(serialize = "DefaultAllocator: Allocator<T, D>,
|
serde(bound(serialize = "DefaultAllocator: Allocator<D>,
|
||||||
OVector<T, D>: Serialize,
|
OVector<T, D>: Serialize,
|
||||||
OMatrix<T, D, D>: Serialize"))
|
OMatrix<T, D, D>: Serialize"))
|
||||||
)]
|
)]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(deserialize = "DefaultAllocator: Allocator<T, D>,
|
serde(bound(deserialize = "DefaultAllocator: Allocator<D>,
|
||||||
OVector<T, D>: Serialize,
|
OVector<T, D>: Serialize,
|
||||||
OMatrix<T, D, D>: Deserialize<'de>"))
|
OMatrix<T, D, D>: Deserialize<'de>"))
|
||||||
)]
|
)]
|
||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
pub struct Eigen<T: ComplexField, D: Dim>
|
pub struct Eigen<T: ComplexField, D: Dim>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
|
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
{
|
{
|
||||||
pub eigenvectors: OMatrix<T, D, D>,
|
pub eigenvectors: OMatrix<T, D, D>,
|
||||||
pub eigenvalues: OVector<T, D>,
|
pub eigenvalues: OVector<T, D>,
|
||||||
|
@ -44,7 +44,7 @@ where
|
||||||
|
|
||||||
impl<T: ComplexField, D: Dim> Copy for Eigen<T, D>
|
impl<T: ComplexField, D: Dim> Copy for Eigen<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
|
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
OMatrix<T, D, D>: Copy,
|
OMatrix<T, D, D>: Copy,
|
||||||
OVector<T, D>: Copy,
|
OVector<T, D>: Copy,
|
||||||
{
|
{
|
||||||
|
@ -54,12 +54,10 @@ impl<T: ComplexField, D: Dim> Eigen<T, D>
|
||||||
where
|
where
|
||||||
D: DimSub<U1>, // For Hessenberg.
|
D: DimSub<U1>, // For Hessenberg.
|
||||||
ShapeConstraint: DimEq<Dyn, DimDiff<D, U1>>, // For Hessenberg.
|
ShapeConstraint: DimEq<Dyn, DimDiff<D, U1>>, // For Hessenberg.
|
||||||
DefaultAllocator: Allocator<T, D, DimDiff<D, U1>>
|
DefaultAllocator:
|
||||||
+ Allocator<T, DimDiff<D, U1>>
|
Allocator<D, DimDiff<D, U1>> + Allocator<DimDiff<D, U1>> + Allocator<D, D> + Allocator<D>,
|
||||||
+ Allocator<T, D, D>
|
|
||||||
+ Allocator<T, D>,
|
|
||||||
// XXX: for debug
|
// XXX: for debug
|
||||||
DefaultAllocator: Allocator<usize, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
OMatrix<T, D, D>: Display,
|
OMatrix<T, D, D>: Display,
|
||||||
{
|
{
|
||||||
/// Computes the eigendecomposition of a diagonalizable matrix with Complex eigenvalues.
|
/// Computes the eigendecomposition of a diagonalizable matrix with Complex eigenvalues.
|
||||||
|
|
|
@ -57,7 +57,7 @@ struct ExpmPadeHelper<T, D>
|
||||||
where
|
where
|
||||||
T: ComplexField,
|
T: ComplexField,
|
||||||
D: DimMin<D>,
|
D: DimMin<D>,
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<(usize, usize), DimMinimum<D, D>>,
|
DefaultAllocator: Allocator<D, D> + Allocator<DimMinimum<D, D>>,
|
||||||
{
|
{
|
||||||
use_exact_norm: bool,
|
use_exact_norm: bool,
|
||||||
ident: OMatrix<T, D, D>,
|
ident: OMatrix<T, D, D>,
|
||||||
|
@ -84,7 +84,7 @@ impl<T, D> ExpmPadeHelper<T, D>
|
||||||
where
|
where
|
||||||
T: ComplexField,
|
T: ComplexField,
|
||||||
D: DimMin<D>,
|
D: DimMin<D>,
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<(usize, usize), DimMinimum<D, D>>,
|
DefaultAllocator: Allocator<D, D> + Allocator<DimMinimum<D, D>>,
|
||||||
{
|
{
|
||||||
fn new(a: OMatrix<T, D, D>, use_exact_norm: bool) -> Self {
|
fn new(a: OMatrix<T, D, D>, use_exact_norm: bool) -> Self {
|
||||||
let (nrows, ncols) = a.shape_generic();
|
let (nrows, ncols) = a.shape_generic();
|
||||||
|
@ -397,7 +397,7 @@ fn onenorm_matrix_power_nonm<T, D>(a: &OMatrix<T, D, D>, p: usize) -> T
|
||||||
where
|
where
|
||||||
T: RealField,
|
T: RealField,
|
||||||
D: Dim,
|
D: Dim,
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
|
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
{
|
{
|
||||||
let nrows = a.shape_generic().0;
|
let nrows = a.shape_generic().0;
|
||||||
let mut v = crate::OVector::<T, D>::repeat_generic(nrows, Const::<1>, convert(1.0));
|
let mut v = crate::OVector::<T, D>::repeat_generic(nrows, Const::<1>, convert(1.0));
|
||||||
|
@ -414,10 +414,7 @@ fn ell<T, D>(a: &OMatrix<T, D, D>, m: usize) -> u64
|
||||||
where
|
where
|
||||||
T: ComplexField,
|
T: ComplexField,
|
||||||
D: Dim,
|
D: Dim,
|
||||||
DefaultAllocator: Allocator<T, D, D>
|
DefaultAllocator: Allocator<D, D> + Allocator<D> + Allocator<D> + Allocator<D, D>,
|
||||||
+ Allocator<T, D>
|
|
||||||
+ Allocator<T::RealField, D>
|
|
||||||
+ Allocator<T::RealField, D, D>,
|
|
||||||
{
|
{
|
||||||
let a_abs = a.map(|x| x.abs());
|
let a_abs = a.map(|x| x.abs());
|
||||||
|
|
||||||
|
@ -449,7 +446,7 @@ fn solve_p_q<T, D>(u: OMatrix<T, D, D>, v: OMatrix<T, D, D>) -> OMatrix<T, D, D>
|
||||||
where
|
where
|
||||||
T: ComplexField,
|
T: ComplexField,
|
||||||
D: DimMin<D, Output = D>,
|
D: DimMin<D, Output = D>,
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<(usize, usize), DimMinimum<D, D>>,
|
DefaultAllocator: Allocator<D, D> + Allocator<DimMinimum<D, D>>,
|
||||||
{
|
{
|
||||||
let p = &u + &v;
|
let p = &u + &v;
|
||||||
let q = &v - &u;
|
let q = &v - &u;
|
||||||
|
@ -461,7 +458,7 @@ fn one_norm<T, D>(m: &OMatrix<T, D, D>) -> T::RealField
|
||||||
where
|
where
|
||||||
T: ComplexField,
|
T: ComplexField,
|
||||||
D: Dim,
|
D: Dim,
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
let mut max = <T as ComplexField>::RealField::zero();
|
let mut max = <T as ComplexField>::RealField::zero();
|
||||||
|
|
||||||
|
@ -481,11 +478,11 @@ where
|
||||||
impl<T: ComplexField, D> OMatrix<T, D, D>
|
impl<T: ComplexField, D> OMatrix<T, D, D>
|
||||||
where
|
where
|
||||||
D: DimMin<D, Output = D>,
|
D: DimMin<D, Output = D>,
|
||||||
DefaultAllocator: Allocator<T, D, D>
|
DefaultAllocator: Allocator<D, D>
|
||||||
+ Allocator<(usize, usize), DimMinimum<D, D>>
|
+ Allocator<DimMinimum<D, D>>
|
||||||
+ Allocator<T, D>
|
+ Allocator<D>
|
||||||
+ Allocator<T::RealField, D>
|
+ Allocator<D>
|
||||||
+ Allocator<T::RealField, D, D>,
|
+ Allocator<D, D>,
|
||||||
{
|
{
|
||||||
/// Computes exponential of this matrix
|
/// Computes exponential of this matrix
|
||||||
#[must_use]
|
#[must_use]
|
||||||
|
|
|
@ -15,22 +15,22 @@ use crate::linalg::PermutationSequence;
|
||||||
#[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))]
|
#[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(serialize = "DefaultAllocator: Allocator<T, R, C> +
|
serde(bound(serialize = "DefaultAllocator: Allocator<R, C> +
|
||||||
Allocator<(usize, usize), DimMinimum<R, C>>,
|
Allocator<DimMinimum<R, C>>,
|
||||||
OMatrix<T, R, C>: Serialize,
|
OMatrix<T, R, C>: Serialize,
|
||||||
PermutationSequence<DimMinimum<R, C>>: Serialize"))
|
PermutationSequence<DimMinimum<R, C>>: Serialize"))
|
||||||
)]
|
)]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(deserialize = "DefaultAllocator: Allocator<T, R, C> +
|
serde(bound(deserialize = "DefaultAllocator: Allocator<R, C> +
|
||||||
Allocator<(usize, usize), DimMinimum<R, C>>,
|
Allocator<DimMinimum<R, C>>,
|
||||||
OMatrix<T, R, C>: Deserialize<'de>,
|
OMatrix<T, R, C>: Deserialize<'de>,
|
||||||
PermutationSequence<DimMinimum<R, C>>: Deserialize<'de>"))
|
PermutationSequence<DimMinimum<R, C>>: Deserialize<'de>"))
|
||||||
)]
|
)]
|
||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
pub struct FullPivLU<T: ComplexField, R: DimMin<C>, C: Dim>
|
pub struct FullPivLU<T: ComplexField, R: DimMin<C>, C: Dim>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
|
DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>>,
|
||||||
{
|
{
|
||||||
lu: OMatrix<T, R, C>,
|
lu: OMatrix<T, R, C>,
|
||||||
p: PermutationSequence<DimMinimum<R, C>>,
|
p: PermutationSequence<DimMinimum<R, C>>,
|
||||||
|
@ -39,7 +39,7 @@ where
|
||||||
|
|
||||||
impl<T: ComplexField, R: DimMin<C>, C: Dim> Copy for FullPivLU<T, R, C>
|
impl<T: ComplexField, R: DimMin<C>, C: Dim> Copy for FullPivLU<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
|
DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>>,
|
||||||
OMatrix<T, R, C>: Copy,
|
OMatrix<T, R, C>: Copy,
|
||||||
PermutationSequence<DimMinimum<R, C>>: Copy,
|
PermutationSequence<DimMinimum<R, C>>: Copy,
|
||||||
{
|
{
|
||||||
|
@ -47,7 +47,7 @@ where
|
||||||
|
|
||||||
impl<T: ComplexField, R: DimMin<C>, C: Dim> FullPivLU<T, R, C>
|
impl<T: ComplexField, R: DimMin<C>, C: Dim> FullPivLU<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
|
DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>>,
|
||||||
{
|
{
|
||||||
/// Computes the LU decomposition with full pivoting of `matrix`.
|
/// Computes the LU decomposition with full pivoting of `matrix`.
|
||||||
///
|
///
|
||||||
|
@ -99,7 +99,7 @@ where
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn l(&self) -> OMatrix<T, R, DimMinimum<R, C>>
|
pub fn l(&self) -> OMatrix<T, R, DimMinimum<R, C>>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, DimMinimum<R, C>>,
|
DefaultAllocator: Allocator<R, DimMinimum<R, C>>,
|
||||||
{
|
{
|
||||||
let (nrows, ncols) = self.lu.shape_generic();
|
let (nrows, ncols) = self.lu.shape_generic();
|
||||||
let mut m = self.lu.columns_generic(0, nrows.min(ncols)).into_owned();
|
let mut m = self.lu.columns_generic(0, nrows.min(ncols)).into_owned();
|
||||||
|
@ -113,7 +113,7 @@ where
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn u(&self) -> OMatrix<T, DimMinimum<R, C>, C>
|
pub fn u(&self) -> OMatrix<T, DimMinimum<R, C>, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, DimMinimum<R, C>, C>,
|
DefaultAllocator: Allocator<DimMinimum<R, C>, C>,
|
||||||
{
|
{
|
||||||
let (nrows, ncols) = self.lu.shape_generic();
|
let (nrows, ncols) = self.lu.shape_generic();
|
||||||
self.lu.rows_generic(0, nrows.min(ncols)).upper_triangle()
|
self.lu.rows_generic(0, nrows.min(ncols)).upper_triangle()
|
||||||
|
@ -144,7 +144,7 @@ where
|
||||||
PermutationSequence<DimMinimum<R, C>>,
|
PermutationSequence<DimMinimum<R, C>>,
|
||||||
)
|
)
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, DimMinimum<R, C>> + Allocator<T, DimMinimum<R, C>, C>,
|
DefaultAllocator: Allocator<R, DimMinimum<R, C>> + Allocator<DimMinimum<R, C>, C>,
|
||||||
{
|
{
|
||||||
// Use reallocation for either l or u.
|
// Use reallocation for either l or u.
|
||||||
let l = self.l();
|
let l = self.l();
|
||||||
|
@ -158,7 +158,7 @@ where
|
||||||
|
|
||||||
impl<T: ComplexField, D: DimMin<D, Output = D>> FullPivLU<T, D, D>
|
impl<T: ComplexField, D: DimMin<D, Output = D>> FullPivLU<T, D, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<(usize, usize), D>,
|
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
{
|
{
|
||||||
/// Solves the linear system `self * x = b`, where `x` is the unknown to be determined.
|
/// Solves the linear system `self * x = b`, where `x` is the unknown to be determined.
|
||||||
///
|
///
|
||||||
|
@ -171,7 +171,7 @@ where
|
||||||
where
|
where
|
||||||
S2: Storage<T, R2, C2>,
|
S2: Storage<T, R2, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<R2, D>,
|
ShapeConstraint: SameNumberOfRows<R2, D>,
|
||||||
DefaultAllocator: Allocator<T, R2, C2>,
|
DefaultAllocator: Allocator<R2, C2>,
|
||||||
{
|
{
|
||||||
let mut res = b.clone_owned();
|
let mut res = b.clone_owned();
|
||||||
if self.solve_mut(&mut res) {
|
if self.solve_mut(&mut res) {
|
||||||
|
|
|
@ -14,22 +14,22 @@ use std::mem::MaybeUninit;
|
||||||
#[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))]
|
#[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(serialize = "DefaultAllocator: Allocator<T, D, D> +
|
serde(bound(serialize = "DefaultAllocator: Allocator<D, D> +
|
||||||
Allocator<T, DimDiff<D, U1>>,
|
Allocator<DimDiff<D, U1>>,
|
||||||
OMatrix<T, D, D>: Serialize,
|
OMatrix<T, D, D>: Serialize,
|
||||||
OVector<T, DimDiff<D, U1>>: Serialize"))
|
OVector<T, DimDiff<D, U1>>: Serialize"))
|
||||||
)]
|
)]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(deserialize = "DefaultAllocator: Allocator<T, D, D> +
|
serde(bound(deserialize = "DefaultAllocator: Allocator<D, D> +
|
||||||
Allocator<T, DimDiff<D, U1>>,
|
Allocator<DimDiff<D, U1>>,
|
||||||
OMatrix<T, D, D>: Deserialize<'de>,
|
OMatrix<T, D, D>: Deserialize<'de>,
|
||||||
OVector<T, DimDiff<D, U1>>: Deserialize<'de>"))
|
OVector<T, DimDiff<D, U1>>: Deserialize<'de>"))
|
||||||
)]
|
)]
|
||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
pub struct Hessenberg<T: ComplexField, D: DimSub<U1>>
|
pub struct Hessenberg<T: ComplexField, D: DimSub<U1>>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>,
|
DefaultAllocator: Allocator<D, D> + Allocator<DimDiff<D, U1>>,
|
||||||
{
|
{
|
||||||
hess: OMatrix<T, D, D>,
|
hess: OMatrix<T, D, D>,
|
||||||
subdiag: OVector<T, DimDiff<D, U1>>,
|
subdiag: OVector<T, DimDiff<D, U1>>,
|
||||||
|
@ -37,7 +37,7 @@ where
|
||||||
|
|
||||||
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<D, D> + Allocator<DimDiff<D, U1>>,
|
||||||
OMatrix<T, D, D>: Copy,
|
OMatrix<T, D, D>: Copy,
|
||||||
OVector<T, DimDiff<D, U1>>: Copy,
|
OVector<T, DimDiff<D, U1>>: Copy,
|
||||||
{
|
{
|
||||||
|
@ -45,7 +45,7 @@ where
|
||||||
|
|
||||||
impl<T: ComplexField, D: DimSub<U1>> Hessenberg<T, D>
|
impl<T: ComplexField, D: DimSub<U1>> Hessenberg<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, D> + Allocator<T, DimDiff<D, U1>>,
|
DefaultAllocator: Allocator<D, D> + Allocator<D> + Allocator<DimDiff<D, U1>>,
|
||||||
{
|
{
|
||||||
/// Computes the Hessenberg decomposition using householder reflections.
|
/// Computes the Hessenberg decomposition using householder reflections.
|
||||||
pub fn new(hess: OMatrix<T, D, D>) -> Self {
|
pub fn new(hess: OMatrix<T, D, D>) -> Self {
|
||||||
|
|
|
@ -65,7 +65,7 @@ pub fn clear_column_unchecked<T: ComplexField, R: Dim, C: Dim>(
|
||||||
bilateral: Option<&mut OVector<T, R>>,
|
bilateral: Option<&mut OVector<T, R>>,
|
||||||
) -> T
|
) -> T
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C> + Allocator<T, R>,
|
DefaultAllocator: Allocator<R, C> + Allocator<R>,
|
||||||
{
|
{
|
||||||
let (mut left, mut right) = matrix.columns_range_pair_mut(icol, icol + 1..);
|
let (mut left, mut right) = matrix.columns_range_pair_mut(icol, icol + 1..);
|
||||||
let mut axis = left.rows_range_mut(icol + shift..);
|
let mut axis = left.rows_range_mut(icol + shift..);
|
||||||
|
@ -98,7 +98,7 @@ pub fn clear_row_unchecked<T: ComplexField, R: Dim, C: Dim>(
|
||||||
shift: usize,
|
shift: usize,
|
||||||
) -> T
|
) -> T
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C> + Allocator<T, R> + Allocator<T, C>,
|
DefaultAllocator: Allocator<R, C> + Allocator<R> + Allocator<C>,
|
||||||
{
|
{
|
||||||
let (mut top, mut bottom) = matrix.rows_range_pair_mut(irow, irow + 1..);
|
let (mut top, mut bottom) = matrix.rows_range_pair_mut(irow, irow + 1..);
|
||||||
let mut axis = axis_packed.rows_range_mut(irow + shift..);
|
let mut axis = axis_packed.rows_range_mut(irow + shift..);
|
||||||
|
@ -129,7 +129,7 @@ where
|
||||||
#[doc(hidden)]
|
#[doc(hidden)]
|
||||||
pub fn assemble_q<T: ComplexField, D: Dim>(m: &OMatrix<T, D, D>, signs: &[T]) -> OMatrix<T, D, D>
|
pub fn assemble_q<T: ComplexField, D: Dim>(m: &OMatrix<T, D, D>, signs: &[T]) -> OMatrix<T, D, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
assert!(m.is_square());
|
assert!(m.is_square());
|
||||||
let dim = m.shape_generic().0;
|
let dim = m.shape_generic().0;
|
||||||
|
|
|
@ -17,7 +17,7 @@ impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
|
||||||
#[must_use = "Did you mean to use try_inverse_mut()?"]
|
#[must_use = "Did you mean to use try_inverse_mut()?"]
|
||||||
pub fn try_inverse(self) -> Option<OMatrix<T, D, D>>
|
pub fn try_inverse(self) -> Option<OMatrix<T, D, D>>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
let mut me = self.into_owned();
|
let mut me = self.into_owned();
|
||||||
if me.try_inverse_mut() {
|
if me.try_inverse_mut() {
|
||||||
|
@ -38,7 +38,7 @@ impl<T: ComplexField, D: Dim, S: StorageMut<T, D, D>> SquareMatrix<T, D, S> {
|
||||||
#[inline]
|
#[inline]
|
||||||
pub fn try_inverse_mut(&mut self) -> bool
|
pub fn try_inverse_mut(&mut self) -> bool
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
assert!(self.is_square(), "Unable to invert a non-square matrix.");
|
assert!(self.is_square(), "Unable to invert a non-square matrix.");
|
||||||
|
|
||||||
|
@ -141,7 +141,7 @@ fn do_inverse4<T: ComplexField, D: Dim, S: StorageMut<T, D, D>>(
|
||||||
out: &mut SquareMatrix<T, D, S>,
|
out: &mut SquareMatrix<T, D, S>,
|
||||||
) -> bool
|
) -> bool
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
let m = m.as_slice();
|
let m = m.as_slice();
|
||||||
|
|
||||||
|
|
|
@ -15,22 +15,22 @@ use crate::linalg::PermutationSequence;
|
||||||
#[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))]
|
#[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(serialize = "DefaultAllocator: Allocator<T, R, C> +
|
serde(bound(serialize = "DefaultAllocator: Allocator<R, C> +
|
||||||
Allocator<(usize, usize), DimMinimum<R, C>>,
|
Allocator<DimMinimum<R, C>>,
|
||||||
OMatrix<T, R, C>: Serialize,
|
OMatrix<T, R, C>: Serialize,
|
||||||
PermutationSequence<DimMinimum<R, C>>: Serialize"))
|
PermutationSequence<DimMinimum<R, C>>: Serialize"))
|
||||||
)]
|
)]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(deserialize = "DefaultAllocator: Allocator<T, R, C> +
|
serde(bound(deserialize = "DefaultAllocator: Allocator<R, C> +
|
||||||
Allocator<(usize, usize), DimMinimum<R, C>>,
|
Allocator<DimMinimum<R, C>>,
|
||||||
OMatrix<T, R, C>: Deserialize<'de>,
|
OMatrix<T, R, C>: Deserialize<'de>,
|
||||||
PermutationSequence<DimMinimum<R, C>>: Deserialize<'de>"))
|
PermutationSequence<DimMinimum<R, C>>: Deserialize<'de>"))
|
||||||
)]
|
)]
|
||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
pub struct LU<T: ComplexField, R: DimMin<C>, C: Dim>
|
pub struct LU<T: ComplexField, R: DimMin<C>, C: Dim>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
|
DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>>,
|
||||||
{
|
{
|
||||||
lu: OMatrix<T, R, C>,
|
lu: OMatrix<T, R, C>,
|
||||||
p: PermutationSequence<DimMinimum<R, C>>,
|
p: PermutationSequence<DimMinimum<R, C>>,
|
||||||
|
@ -38,7 +38,7 @@ where
|
||||||
|
|
||||||
impl<T: ComplexField, R: DimMin<C>, C: Dim> Copy for LU<T, R, C>
|
impl<T: ComplexField, 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<R, C> + Allocator<DimMinimum<R, C>>,
|
||||||
OMatrix<T, R, C>: Copy,
|
OMatrix<T, R, C>: Copy,
|
||||||
PermutationSequence<DimMinimum<R, C>>: Copy,
|
PermutationSequence<DimMinimum<R, C>>: Copy,
|
||||||
{
|
{
|
||||||
|
@ -53,7 +53,7 @@ pub fn try_invert_to<T: ComplexField, D: Dim, S>(
|
||||||
) -> bool
|
) -> bool
|
||||||
where
|
where
|
||||||
S: StorageMut<T, D, D>,
|
S: StorageMut<T, D, D>,
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
assert!(
|
assert!(
|
||||||
matrix.is_square(),
|
matrix.is_square(),
|
||||||
|
@ -86,7 +86,7 @@ where
|
||||||
|
|
||||||
impl<T: ComplexField, R: DimMin<C>, C: Dim> LU<T, R, C>
|
impl<T: ComplexField, R: DimMin<C>, C: Dim> LU<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
|
DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>>,
|
||||||
{
|
{
|
||||||
/// Computes the LU decomposition with partial (row) pivoting of `matrix`.
|
/// Computes the LU decomposition with partial (row) pivoting of `matrix`.
|
||||||
pub fn new(mut matrix: OMatrix<T, R, C>) -> Self {
|
pub fn new(mut matrix: OMatrix<T, R, C>) -> Self {
|
||||||
|
@ -130,7 +130,7 @@ where
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn l(&self) -> OMatrix<T, R, DimMinimum<R, C>>
|
pub fn l(&self) -> OMatrix<T, R, DimMinimum<R, C>>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, DimMinimum<R, C>>,
|
DefaultAllocator: Allocator<R, DimMinimum<R, C>>,
|
||||||
{
|
{
|
||||||
let (nrows, ncols) = self.lu.shape_generic();
|
let (nrows, ncols) = self.lu.shape_generic();
|
||||||
let mut m = self.lu.columns_generic(0, nrows.min(ncols)).into_owned();
|
let mut m = self.lu.columns_generic(0, nrows.min(ncols)).into_owned();
|
||||||
|
@ -174,7 +174,7 @@ where
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn u(&self) -> OMatrix<T, DimMinimum<R, C>, C>
|
pub fn u(&self) -> OMatrix<T, DimMinimum<R, C>, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, DimMinimum<R, C>, C>,
|
DefaultAllocator: Allocator<DimMinimum<R, C>, C>,
|
||||||
{
|
{
|
||||||
let (nrows, ncols) = self.lu.shape_generic();
|
let (nrows, ncols) = self.lu.shape_generic();
|
||||||
self.lu.rows_generic(0, nrows.min(ncols)).upper_triangle()
|
self.lu.rows_generic(0, nrows.min(ncols)).upper_triangle()
|
||||||
|
@ -197,8 +197,8 @@ where
|
||||||
OMatrix<T, DimMinimum<R, C>, C>,
|
OMatrix<T, DimMinimum<R, C>, C>,
|
||||||
)
|
)
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, DimMinimum<R, C>>
|
DefaultAllocator: Allocator<R, DimMinimum<R, C>>
|
||||||
+ Allocator<T, DimMinimum<R, C>, C>
|
+ Allocator<DimMinimum<R, C>, C>
|
||||||
+ Reallocator<T, R, C, R, DimMinimum<R, C>>,
|
+ Reallocator<T, R, C, R, DimMinimum<R, C>>,
|
||||||
{
|
{
|
||||||
// Use reallocation for either l or u.
|
// Use reallocation for either l or u.
|
||||||
|
@ -211,7 +211,7 @@ where
|
||||||
|
|
||||||
impl<T: ComplexField, D: DimMin<D, Output = D>> LU<T, D, D>
|
impl<T: ComplexField, D: DimMin<D, Output = D>> LU<T, D, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<(usize, usize), D>,
|
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
{
|
{
|
||||||
/// Solves the linear system `self * x = b`, where `x` is the unknown to be determined.
|
/// Solves the linear system `self * x = b`, where `x` is the unknown to be determined.
|
||||||
///
|
///
|
||||||
|
@ -224,7 +224,7 @@ where
|
||||||
where
|
where
|
||||||
S2: Storage<T, R2, C2>,
|
S2: Storage<T, R2, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<R2, D>,
|
ShapeConstraint: SameNumberOfRows<R2, D>,
|
||||||
DefaultAllocator: Allocator<T, R2, C2>,
|
DefaultAllocator: Allocator<R2, C2>,
|
||||||
{
|
{
|
||||||
let mut res = b.clone_owned();
|
let mut res = b.clone_owned();
|
||||||
if self.solve_mut(&mut res) {
|
if self.solve_mut(&mut res) {
|
||||||
|
|
|
@ -15,18 +15,18 @@ use crate::storage::StorageMut;
|
||||||
#[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))]
|
#[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(serialize = "DefaultAllocator: Allocator<(usize, usize), D>,
|
serde(bound(serialize = "DefaultAllocator: Allocator<D>,
|
||||||
OVector<(usize, usize), D>: Serialize"))
|
OVector<(usize, usize), D>: Serialize"))
|
||||||
)]
|
)]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(deserialize = "DefaultAllocator: Allocator<(usize, usize), D>,
|
serde(bound(deserialize = "DefaultAllocator: Allocator<D>,
|
||||||
OVector<(usize, usize), D>: Deserialize<'de>"))
|
OVector<(usize, usize), D>: Deserialize<'de>"))
|
||||||
)]
|
)]
|
||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
pub struct PermutationSequence<D: Dim>
|
pub struct PermutationSequence<D: Dim>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<(usize, usize), D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
len: usize,
|
len: usize,
|
||||||
ipiv: OVector<(usize, usize), D>,
|
ipiv: OVector<(usize, usize), D>,
|
||||||
|
@ -34,14 +34,14 @@ where
|
||||||
|
|
||||||
impl<D: Dim> Copy for PermutationSequence<D>
|
impl<D: Dim> Copy for PermutationSequence<D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<(usize, usize), D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
OVector<(usize, usize), D>: Copy,
|
OVector<(usize, usize), D>: Copy,
|
||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<D: DimName> PermutationSequence<D>
|
impl<D: DimName> PermutationSequence<D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<(usize, usize), D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
/// Creates a new statically-allocated sequence of `D` identity permutations.
|
/// Creates a new statically-allocated sequence of `D` identity permutations.
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -53,7 +53,7 @@ where
|
||||||
#[cfg(any(feature = "std", feature = "alloc"))]
|
#[cfg(any(feature = "std", feature = "alloc"))]
|
||||||
impl PermutationSequence<Dyn>
|
impl PermutationSequence<Dyn>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<(usize, usize), Dyn>,
|
DefaultAllocator: Allocator<Dyn>,
|
||||||
{
|
{
|
||||||
/// Creates a new dynamically-allocated sequence of `n` identity permutations.
|
/// Creates a new dynamically-allocated sequence of `n` identity permutations.
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -64,7 +64,7 @@ where
|
||||||
|
|
||||||
impl<D: Dim> PermutationSequence<D>
|
impl<D: Dim> PermutationSequence<D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<(usize, usize), D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
/// Creates a new sequence of D identity permutations.
|
/// Creates a new sequence of D identity permutations.
|
||||||
#[inline]
|
#[inline]
|
||||||
|
|
|
@ -13,7 +13,7 @@ where
|
||||||
T: Scalar + Zero + One + ClosedAdd + ClosedMul,
|
T: Scalar + Zero + One + ClosedAdd + ClosedMul,
|
||||||
D: DimMin<D, Output = D>,
|
D: DimMin<D, Output = D>,
|
||||||
S: StorageMut<T, D, D>,
|
S: StorageMut<T, D, D>,
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
|
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
{
|
{
|
||||||
/// Raises this matrix to an integral power `exp` in-place.
|
/// Raises this matrix to an integral power `exp` in-place.
|
||||||
pub fn pow_mut(&mut self, mut exp: u32) {
|
pub fn pow_mut(&mut self, mut exp: u32) {
|
||||||
|
@ -59,7 +59,7 @@ where
|
||||||
T: Scalar + Zero + One + ClosedAdd + ClosedMul,
|
T: Scalar + Zero + One + ClosedAdd + ClosedMul,
|
||||||
D: DimMin<D, Output = D>,
|
D: DimMin<D, Output = D>,
|
||||||
S: StorageMut<T, D, D>,
|
S: StorageMut<T, D, D>,
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
|
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
{
|
{
|
||||||
/// Raise this matrix to an integral power `exp`.
|
/// Raise this matrix to an integral power `exp`.
|
||||||
#[must_use]
|
#[must_use]
|
||||||
|
|
|
@ -17,22 +17,22 @@ use std::mem::MaybeUninit;
|
||||||
#[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))]
|
#[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(serialize = "DefaultAllocator: Allocator<T, R, C> +
|
serde(bound(serialize = "DefaultAllocator: Allocator<R, C> +
|
||||||
Allocator<T, DimMinimum<R, C>>,
|
Allocator<DimMinimum<R, C>>,
|
||||||
OMatrix<T, R, C>: Serialize,
|
OMatrix<T, R, C>: Serialize,
|
||||||
OVector<T, DimMinimum<R, C>>: Serialize"))
|
OVector<T, DimMinimum<R, C>>: Serialize"))
|
||||||
)]
|
)]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(deserialize = "DefaultAllocator: Allocator<T, R, C> +
|
serde(bound(deserialize = "DefaultAllocator: Allocator<R, C> +
|
||||||
Allocator<T, DimMinimum<R, C>>,
|
Allocator<DimMinimum<R, C>>,
|
||||||
OMatrix<T, R, C>: Deserialize<'de>,
|
OMatrix<T, R, C>: Deserialize<'de>,
|
||||||
OVector<T, DimMinimum<R, C>>: Deserialize<'de>"))
|
OVector<T, DimMinimum<R, C>>: Deserialize<'de>"))
|
||||||
)]
|
)]
|
||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
pub struct QR<T: ComplexField, R: DimMin<C>, C: Dim>
|
pub struct QR<T: ComplexField, R: DimMin<C>, C: Dim>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C> + Allocator<T, DimMinimum<R, C>>,
|
DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>>,
|
||||||
{
|
{
|
||||||
qr: OMatrix<T, R, C>,
|
qr: OMatrix<T, R, C>,
|
||||||
diag: OVector<T, DimMinimum<R, C>>,
|
diag: OVector<T, DimMinimum<R, C>>,
|
||||||
|
@ -40,7 +40,7 @@ where
|
||||||
|
|
||||||
impl<T: ComplexField, R: DimMin<C>, C: Dim> Copy for QR<T, R, C>
|
impl<T: ComplexField, 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<R, C> + Allocator<DimMinimum<R, C>>,
|
||||||
OMatrix<T, R, C>: Copy,
|
OMatrix<T, R, C>: Copy,
|
||||||
OVector<T, DimMinimum<R, C>>: Copy,
|
OVector<T, DimMinimum<R, C>>: Copy,
|
||||||
{
|
{
|
||||||
|
@ -48,7 +48,7 @@ where
|
||||||
|
|
||||||
impl<T: ComplexField, R: DimMin<C>, C: Dim> QR<T, R, C>
|
impl<T: ComplexField, R: DimMin<C>, C: Dim> QR<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C> + Allocator<T, R> + Allocator<T, DimMinimum<R, C>>,
|
DefaultAllocator: Allocator<R, C> + Allocator<R> + Allocator<DimMinimum<R, C>>,
|
||||||
{
|
{
|
||||||
/// Computes the QR decomposition using householder reflections.
|
/// Computes the QR decomposition using householder reflections.
|
||||||
pub fn new(mut matrix: OMatrix<T, R, C>) -> Self {
|
pub fn new(mut matrix: OMatrix<T, R, C>) -> Self {
|
||||||
|
@ -79,7 +79,7 @@ where
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn r(&self) -> OMatrix<T, DimMinimum<R, C>, C>
|
pub fn r(&self) -> OMatrix<T, DimMinimum<R, C>, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, DimMinimum<R, C>, C>,
|
DefaultAllocator: Allocator<DimMinimum<R, C>, C>,
|
||||||
{
|
{
|
||||||
let (nrows, ncols) = self.qr.shape_generic();
|
let (nrows, ncols) = self.qr.shape_generic();
|
||||||
let mut res = self.qr.rows_generic(0, nrows.min(ncols)).upper_triangle();
|
let mut res = self.qr.rows_generic(0, nrows.min(ncols)).upper_triangle();
|
||||||
|
@ -106,7 +106,7 @@ where
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn q(&self) -> OMatrix<T, R, DimMinimum<R, C>>
|
pub fn q(&self) -> OMatrix<T, R, DimMinimum<R, C>>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, DimMinimum<R, C>>,
|
DefaultAllocator: Allocator<R, DimMinimum<R, C>>,
|
||||||
{
|
{
|
||||||
let (nrows, ncols) = self.qr.shape_generic();
|
let (nrows, ncols) = self.qr.shape_generic();
|
||||||
|
|
||||||
|
@ -137,7 +137,7 @@ where
|
||||||
where
|
where
|
||||||
DimMinimum<R, C>: DimMin<C, Output = DimMinimum<R, C>>,
|
DimMinimum<R, C>: DimMin<C, Output = DimMinimum<R, C>>,
|
||||||
DefaultAllocator:
|
DefaultAllocator:
|
||||||
Allocator<T, R, DimMinimum<R, C>> + Reallocator<T, R, C, DimMinimum<R, C>, C>,
|
Allocator<R, DimMinimum<R, C>> + Reallocator<T, R, C, DimMinimum<R, C>, C>,
|
||||||
{
|
{
|
||||||
(self.q(), self.unpack_r())
|
(self.q(), self.unpack_r())
|
||||||
}
|
}
|
||||||
|
@ -172,7 +172,7 @@ where
|
||||||
|
|
||||||
impl<T: ComplexField, D: DimMin<D, Output = D>> QR<T, D, D>
|
impl<T: ComplexField, D: DimMin<D, Output = D>> QR<T, D, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
|
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
{
|
{
|
||||||
/// Solves the linear system `self * x = b`, where `x` is the unknown to be determined.
|
/// Solves the linear system `self * x = b`, where `x` is the unknown to be determined.
|
||||||
///
|
///
|
||||||
|
@ -185,7 +185,7 @@ where
|
||||||
where
|
where
|
||||||
S2: Storage<T, R2, C2>,
|
S2: Storage<T, R2, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<R2, D>,
|
ShapeConstraint: SameNumberOfRows<R2, D>,
|
||||||
DefaultAllocator: Allocator<T, R2, C2>,
|
DefaultAllocator: Allocator<R2, C2>,
|
||||||
{
|
{
|
||||||
let mut res = b.clone_owned();
|
let mut res = b.clone_owned();
|
||||||
|
|
||||||
|
|
|
@ -25,18 +25,18 @@ use std::mem::MaybeUninit;
|
||||||
#[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))]
|
#[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(serialize = "DefaultAllocator: Allocator<T, D, D>,
|
serde(bound(serialize = "DefaultAllocator: Allocator<D, D>,
|
||||||
OMatrix<T, D, D>: Serialize"))
|
OMatrix<T, D, D>: Serialize"))
|
||||||
)]
|
)]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(deserialize = "DefaultAllocator: Allocator<T, D, D>,
|
serde(bound(deserialize = "DefaultAllocator: Allocator<D, D>,
|
||||||
OMatrix<T, D, D>: Deserialize<'de>"))
|
OMatrix<T, D, D>: Deserialize<'de>"))
|
||||||
)]
|
)]
|
||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
pub struct Schur<T: ComplexField, D: Dim>
|
pub struct Schur<T: ComplexField, D: Dim>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
q: OMatrix<T, D, D>,
|
q: OMatrix<T, D, D>,
|
||||||
t: OMatrix<T, D, D>,
|
t: OMatrix<T, D, D>,
|
||||||
|
@ -44,7 +44,7 @@ where
|
||||||
|
|
||||||
impl<T: ComplexField, D: Dim> Copy for Schur<T, D>
|
impl<T: ComplexField, D: Dim> Copy for Schur<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
OMatrix<T, D, D>: Copy,
|
OMatrix<T, D, D>: Copy,
|
||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
@ -52,10 +52,8 @@ where
|
||||||
impl<T: ComplexField, D: Dim> Schur<T, D>
|
impl<T: ComplexField, D: Dim> Schur<T, D>
|
||||||
where
|
where
|
||||||
D: DimSub<U1>, // For Hessenberg.
|
D: DimSub<U1>, // For Hessenberg.
|
||||||
DefaultAllocator: Allocator<T, D, DimDiff<D, U1>>
|
DefaultAllocator:
|
||||||
+ Allocator<T, DimDiff<D, U1>>
|
Allocator<D, DimDiff<D, U1>> + Allocator<DimDiff<D, U1>> + Allocator<D, D> + Allocator<D>,
|
||||||
+ Allocator<T, D, D>
|
|
||||||
+ Allocator<T, D>,
|
|
||||||
{
|
{
|
||||||
/// Computes the Schur decomposition of a square matrix.
|
/// Computes the Schur decomposition of a square matrix.
|
||||||
pub fn new(m: OMatrix<T, D, D>) -> Self {
|
pub fn new(m: OMatrix<T, D, D>) -> Self {
|
||||||
|
@ -295,7 +293,7 @@ where
|
||||||
fn do_complex_eigenvalues(t: &OMatrix<T, D, D>, out: &mut UninitVector<NumComplex<T>, D>)
|
fn do_complex_eigenvalues(t: &OMatrix<T, D, D>, out: &mut UninitVector<NumComplex<T>, D>)
|
||||||
where
|
where
|
||||||
T: RealField,
|
T: RealField,
|
||||||
DefaultAllocator: Allocator<NumComplex<T>, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
let dim = t.nrows();
|
let dim = t.nrows();
|
||||||
let mut m = 0;
|
let mut m = 0;
|
||||||
|
@ -340,7 +338,7 @@ where
|
||||||
fn delimit_subproblem(t: &mut OMatrix<T, D, D>, eps: T::RealField, end: usize) -> (usize, usize)
|
fn delimit_subproblem(t: &mut OMatrix<T, D, D>, eps: T::RealField, end: usize) -> (usize, usize)
|
||||||
where
|
where
|
||||||
D: DimSub<U1>,
|
D: DimSub<U1>,
|
||||||
DefaultAllocator: Allocator<T, DimDiff<D, U1>>,
|
DefaultAllocator: Allocator<DimDiff<D, U1>>,
|
||||||
{
|
{
|
||||||
let mut n = end;
|
let mut n = end;
|
||||||
|
|
||||||
|
@ -406,7 +404,7 @@ where
|
||||||
pub fn complex_eigenvalues(&self) -> OVector<NumComplex<T>, D>
|
pub fn complex_eigenvalues(&self) -> OVector<NumComplex<T>, D>
|
||||||
where
|
where
|
||||||
T: RealField,
|
T: RealField,
|
||||||
DefaultAllocator: Allocator<NumComplex<T>, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
let mut out = Matrix::uninit(self.t.shape_generic().0, Const::<1>);
|
let mut out = Matrix::uninit(self.t.shape_generic().0, Const::<1>);
|
||||||
Self::do_complex_eigenvalues(&self.t, &mut out);
|
Self::do_complex_eigenvalues(&self.t, &mut out);
|
||||||
|
@ -420,7 +418,7 @@ fn decompose_2x2<T: ComplexField, D: Dim>(
|
||||||
compute_q: bool,
|
compute_q: bool,
|
||||||
) -> Option<(Option<OMatrix<T, D, D>>, OMatrix<T, D, D>)>
|
) -> Option<(Option<OMatrix<T, D, D>>, OMatrix<T, D, D>)>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
let dim = m.shape_generic().0;
|
let dim = m.shape_generic().0;
|
||||||
let mut q = None;
|
let mut q = None;
|
||||||
|
@ -508,10 +506,8 @@ fn compute_2x2_basis<T: ComplexField, S: Storage<T, U2, U2>>(
|
||||||
impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S>
|
impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S>
|
||||||
where
|
where
|
||||||
D: DimSub<U1>, // For Hessenberg.
|
D: DimSub<U1>, // For Hessenberg.
|
||||||
DefaultAllocator: Allocator<T, D, DimDiff<D, U1>>
|
DefaultAllocator:
|
||||||
+ Allocator<T, DimDiff<D, U1>>
|
Allocator<D, DimDiff<D, U1>> + Allocator<DimDiff<D, U1>> + Allocator<D, D> + Allocator<D>,
|
||||||
+ Allocator<T, D, D>
|
|
||||||
+ Allocator<T, D>,
|
|
||||||
{
|
{
|
||||||
/// Computes the eigenvalues of this matrix.
|
/// Computes the eigenvalues of this matrix.
|
||||||
#[must_use]
|
#[must_use]
|
||||||
|
@ -561,7 +557,7 @@ where
|
||||||
// TODO: add balancing?
|
// TODO: add balancing?
|
||||||
where
|
where
|
||||||
T: RealField,
|
T: RealField,
|
||||||
DefaultAllocator: Allocator<NumComplex<T>, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
let dim = self.shape_generic().0;
|
let dim = self.shape_generic().0;
|
||||||
let mut work = Matrix::zeros_generic(dim, Const::<1>);
|
let mut work = Matrix::zeros_generic(dim, Const::<1>);
|
||||||
|
|
|
@ -18,7 +18,7 @@ impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
|
||||||
) -> Option<OMatrix<T, R2, C2>>
|
) -> Option<OMatrix<T, R2, C2>>
|
||||||
where
|
where
|
||||||
S2: Storage<T, R2, C2>,
|
S2: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: Allocator<T, R2, C2>,
|
DefaultAllocator: Allocator<R2, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<R2, D>,
|
ShapeConstraint: SameNumberOfRows<R2, D>,
|
||||||
{
|
{
|
||||||
let mut res = b.clone_owned();
|
let mut res = b.clone_owned();
|
||||||
|
@ -39,7 +39,7 @@ impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
|
||||||
) -> Option<OMatrix<T, R2, C2>>
|
) -> Option<OMatrix<T, R2, C2>>
|
||||||
where
|
where
|
||||||
S2: Storage<T, R2, C2>,
|
S2: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: Allocator<T, R2, C2>,
|
DefaultAllocator: Allocator<R2, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<R2, D>,
|
ShapeConstraint: SameNumberOfRows<R2, D>,
|
||||||
{
|
{
|
||||||
let mut res = b.clone_owned();
|
let mut res = b.clone_owned();
|
||||||
|
@ -196,7 +196,7 @@ impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
|
||||||
) -> Option<OMatrix<T, R2, C2>>
|
) -> Option<OMatrix<T, R2, C2>>
|
||||||
where
|
where
|
||||||
S2: Storage<T, R2, C2>,
|
S2: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: Allocator<T, R2, C2>,
|
DefaultAllocator: Allocator<R2, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<R2, D>,
|
ShapeConstraint: SameNumberOfRows<R2, D>,
|
||||||
{
|
{
|
||||||
let mut res = b.clone_owned();
|
let mut res = b.clone_owned();
|
||||||
|
@ -217,7 +217,7 @@ impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
|
||||||
) -> Option<OMatrix<T, R2, C2>>
|
) -> Option<OMatrix<T, R2, C2>>
|
||||||
where
|
where
|
||||||
S2: Storage<T, R2, C2>,
|
S2: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: Allocator<T, R2, C2>,
|
DefaultAllocator: Allocator<R2, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<R2, D>,
|
ShapeConstraint: SameNumberOfRows<R2, D>,
|
||||||
{
|
{
|
||||||
let mut res = b.clone_owned();
|
let mut res = b.clone_owned();
|
||||||
|
@ -288,7 +288,7 @@ impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
|
||||||
) -> Option<OMatrix<T, R2, C2>>
|
) -> Option<OMatrix<T, R2, C2>>
|
||||||
where
|
where
|
||||||
S2: Storage<T, R2, C2>,
|
S2: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: Allocator<T, R2, C2>,
|
DefaultAllocator: Allocator<R2, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<R2, D>,
|
ShapeConstraint: SameNumberOfRows<R2, D>,
|
||||||
{
|
{
|
||||||
let mut res = b.clone_owned();
|
let mut res = b.clone_owned();
|
||||||
|
@ -309,7 +309,7 @@ impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
|
||||||
) -> Option<OMatrix<T, R2, C2>>
|
) -> Option<OMatrix<T, R2, C2>>
|
||||||
where
|
where
|
||||||
S2: Storage<T, R2, C2>,
|
S2: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: Allocator<T, R2, C2>,
|
DefaultAllocator: Allocator<R2, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<R2, D>,
|
ShapeConstraint: SameNumberOfRows<R2, D>,
|
||||||
{
|
{
|
||||||
let mut res = b.clone_owned();
|
let mut res = b.clone_owned();
|
||||||
|
@ -457,7 +457,7 @@ impl<T: SimdComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
|
||||||
) -> OMatrix<T, R2, C2>
|
) -> OMatrix<T, R2, C2>
|
||||||
where
|
where
|
||||||
S2: Storage<T, R2, C2>,
|
S2: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: Allocator<T, R2, C2>,
|
DefaultAllocator: Allocator<R2, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<R2, D>,
|
ShapeConstraint: SameNumberOfRows<R2, D>,
|
||||||
{
|
{
|
||||||
let mut res = b.clone_owned();
|
let mut res = b.clone_owned();
|
||||||
|
@ -475,7 +475,7 @@ impl<T: SimdComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
|
||||||
) -> OMatrix<T, R2, C2>
|
) -> OMatrix<T, R2, C2>
|
||||||
where
|
where
|
||||||
S2: Storage<T, R2, C2>,
|
S2: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: Allocator<T, R2, C2>,
|
DefaultAllocator: Allocator<R2, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<R2, D>,
|
ShapeConstraint: SameNumberOfRows<R2, D>,
|
||||||
{
|
{
|
||||||
let mut res = b.clone_owned();
|
let mut res = b.clone_owned();
|
||||||
|
@ -594,7 +594,7 @@ impl<T: SimdComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
|
||||||
) -> OMatrix<T, R2, C2>
|
) -> OMatrix<T, R2, C2>
|
||||||
where
|
where
|
||||||
S2: Storage<T, R2, C2>,
|
S2: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: Allocator<T, R2, C2>,
|
DefaultAllocator: Allocator<R2, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<R2, D>,
|
ShapeConstraint: SameNumberOfRows<R2, D>,
|
||||||
{
|
{
|
||||||
let mut res = b.clone_owned();
|
let mut res = b.clone_owned();
|
||||||
|
@ -612,7 +612,7 @@ impl<T: SimdComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
|
||||||
) -> OMatrix<T, R2, C2>
|
) -> OMatrix<T, R2, C2>
|
||||||
where
|
where
|
||||||
S2: Storage<T, R2, C2>,
|
S2: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: Allocator<T, R2, C2>,
|
DefaultAllocator: Allocator<R2, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<R2, D>,
|
ShapeConstraint: SameNumberOfRows<R2, D>,
|
||||||
{
|
{
|
||||||
let mut res = b.clone_owned();
|
let mut res = b.clone_owned();
|
||||||
|
@ -666,7 +666,7 @@ impl<T: SimdComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
|
||||||
) -> OMatrix<T, R2, C2>
|
) -> OMatrix<T, R2, C2>
|
||||||
where
|
where
|
||||||
S2: Storage<T, R2, C2>,
|
S2: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: Allocator<T, R2, C2>,
|
DefaultAllocator: Allocator<R2, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<R2, D>,
|
ShapeConstraint: SameNumberOfRows<R2, D>,
|
||||||
{
|
{
|
||||||
let mut res = b.clone_owned();
|
let mut res = b.clone_owned();
|
||||||
|
@ -684,7 +684,7 @@ impl<T: SimdComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
|
||||||
) -> OMatrix<T, R2, C2>
|
) -> OMatrix<T, R2, C2>
|
||||||
where
|
where
|
||||||
S2: Storage<T, R2, C2>,
|
S2: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: Allocator<T, R2, C2>,
|
DefaultAllocator: Allocator<R2, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<R2, D>,
|
ShapeConstraint: SameNumberOfRows<R2, D>,
|
||||||
{
|
{
|
||||||
let mut res = b.clone_owned();
|
let mut res = b.clone_owned();
|
||||||
|
|
|
@ -21,32 +21,28 @@ use crate::linalg::Bidiagonal;
|
||||||
#[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))]
|
#[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(
|
serde(bound(serialize = "DefaultAllocator: Allocator<DimMinimum<R, C>> +
|
||||||
serialize = "DefaultAllocator: Allocator<T::RealField, DimMinimum<R, C>> +
|
Allocator<DimMinimum<R, C>, C> +
|
||||||
Allocator<T, DimMinimum<R, C>, C> +
|
Allocator<R, DimMinimum<R, C>>,
|
||||||
Allocator<T, R, DimMinimum<R, C>>,
|
|
||||||
OMatrix<T, R, DimMinimum<R, C>>: Serialize,
|
OMatrix<T, R, DimMinimum<R, C>>: Serialize,
|
||||||
OMatrix<T, DimMinimum<R, C>, C>: Serialize,
|
OMatrix<T, DimMinimum<R, C>, C>: Serialize,
|
||||||
OVector<T::RealField, DimMinimum<R, C>>: Serialize"
|
OVector<T::RealField, DimMinimum<R, C>>: Serialize"))
|
||||||
))
|
|
||||||
)]
|
)]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(
|
serde(bound(deserialize = "DefaultAllocator: Allocator<DimMinimum<R, C>> +
|
||||||
deserialize = "DefaultAllocator: Allocator<T::RealField, DimMinimum<R, C>> +
|
Allocator<DimMinimum<R, C>, C> +
|
||||||
Allocator<T, DimMinimum<R, C>, C> +
|
Allocator<R, DimMinimum<R, C>>,
|
||||||
Allocator<T, R, DimMinimum<R, C>>,
|
|
||||||
OMatrix<T, R, DimMinimum<R, C>>: Deserialize<'de>,
|
OMatrix<T, R, DimMinimum<R, C>>: Deserialize<'de>,
|
||||||
OMatrix<T, DimMinimum<R, C>, C>: Deserialize<'de>,
|
OMatrix<T, DimMinimum<R, C>, C>: Deserialize<'de>,
|
||||||
OVector<T::RealField, DimMinimum<R, C>>: Deserialize<'de>"
|
OVector<T::RealField, DimMinimum<R, C>>: Deserialize<'de>"))
|
||||||
))
|
|
||||||
)]
|
)]
|
||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
pub struct SVD<T: ComplexField, R: DimMin<C>, C: Dim>
|
pub struct SVD<T: ComplexField, R: DimMin<C>, C: Dim>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, DimMinimum<R, C>, C>
|
DefaultAllocator: Allocator<DimMinimum<R, C>, C>
|
||||||
+ Allocator<T, R, DimMinimum<R, C>>
|
+ Allocator<R, DimMinimum<R, C>>
|
||||||
+ Allocator<T::RealField, DimMinimum<R, C>>,
|
+ Allocator<DimMinimum<R, C>>,
|
||||||
{
|
{
|
||||||
/// The left-singular vectors `U` of this SVD.
|
/// The left-singular vectors `U` of this SVD.
|
||||||
pub u: Option<OMatrix<T, R, DimMinimum<R, C>>>,
|
pub u: Option<OMatrix<T, R, DimMinimum<R, C>>>,
|
||||||
|
@ -58,9 +54,9 @@ where
|
||||||
|
|
||||||
impl<T: ComplexField, R: DimMin<C>, C: Dim> Copy for SVD<T, R, C>
|
impl<T: ComplexField, R: DimMin<C>, C: Dim> Copy for SVD<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, DimMinimum<R, C>, C>
|
DefaultAllocator: Allocator<DimMinimum<R, C>, C>
|
||||||
+ Allocator<T, R, DimMinimum<R, C>>
|
+ Allocator<R, DimMinimum<R, C>>
|
||||||
+ Allocator<T::RealField, DimMinimum<R, C>>,
|
+ Allocator<DimMinimum<R, C>>,
|
||||||
OMatrix<T, R, DimMinimum<R, C>>: Copy,
|
OMatrix<T, R, DimMinimum<R, C>>: Copy,
|
||||||
OMatrix<T, DimMinimum<R, C>, C>: Copy,
|
OMatrix<T, DimMinimum<R, C>, C>: Copy,
|
||||||
OVector<T::RealField, DimMinimum<R, C>>: Copy,
|
OVector<T::RealField, DimMinimum<R, C>>: Copy,
|
||||||
|
@ -70,15 +66,15 @@ where
|
||||||
impl<T: ComplexField, R: DimMin<C>, C: Dim> SVD<T, R, C>
|
impl<T: ComplexField, R: DimMin<C>, C: Dim> SVD<T, R, C>
|
||||||
where
|
where
|
||||||
DimMinimum<R, C>: DimSub<U1>, // for Bidiagonal.
|
DimMinimum<R, C>: DimSub<U1>, // for Bidiagonal.
|
||||||
DefaultAllocator: Allocator<T, R, C>
|
DefaultAllocator: Allocator<R, C>
|
||||||
+ Allocator<T, C>
|
+ Allocator<C>
|
||||||
+ Allocator<T, R>
|
+ Allocator<R>
|
||||||
+ Allocator<T, DimDiff<DimMinimum<R, C>, U1>>
|
+ Allocator<DimDiff<DimMinimum<R, C>, U1>>
|
||||||
+ Allocator<T, DimMinimum<R, C>, C>
|
+ Allocator<DimMinimum<R, C>, C>
|
||||||
+ Allocator<T, R, DimMinimum<R, C>>
|
+ Allocator<R, DimMinimum<R, C>>
|
||||||
+ Allocator<T, DimMinimum<R, C>>
|
+ Allocator<DimMinimum<R, C>>
|
||||||
+ Allocator<T::RealField, DimMinimum<R, C>>
|
+ Allocator<DimMinimum<R, C>>
|
||||||
+ Allocator<T::RealField, DimDiff<DimMinimum<R, C>, U1>>,
|
+ Allocator<DimDiff<DimMinimum<R, C>, U1>>,
|
||||||
{
|
{
|
||||||
fn use_special_always_ordered_svd2() -> bool {
|
fn use_special_always_ordered_svd2() -> bool {
|
||||||
TypeId::of::<OMatrix<T, R, C>>() == TypeId::of::<Matrix2<T::RealField>>()
|
TypeId::of::<OMatrix<T, R, C>>() == TypeId::of::<Matrix2<T::RealField>>()
|
||||||
|
@ -579,7 +575,7 @@ where
|
||||||
/// been computed at construction-time.
|
/// been computed at construction-time.
|
||||||
pub fn pseudo_inverse(mut self, eps: T::RealField) -> Result<OMatrix<T, C, R>, &'static str>
|
pub fn pseudo_inverse(mut self, eps: T::RealField) -> Result<OMatrix<T, C, R>, &'static str>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, C, R>,
|
DefaultAllocator: Allocator<C, R>,
|
||||||
{
|
{
|
||||||
if eps < T::RealField::zero() {
|
if eps < T::RealField::zero() {
|
||||||
Err("SVD pseudo inverse: the epsilon must be non-negative.")
|
Err("SVD pseudo inverse: the epsilon must be non-negative.")
|
||||||
|
@ -610,7 +606,7 @@ where
|
||||||
) -> Result<OMatrix<T, C, C2>, &'static str>
|
) -> Result<OMatrix<T, C, C2>, &'static str>
|
||||||
where
|
where
|
||||||
S2: Storage<T, R2, C2>,
|
S2: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: Allocator<T, C, C2> + Allocator<T, DimMinimum<R, C>, C2>,
|
DefaultAllocator: Allocator<C, C2> + Allocator<DimMinimum<R, C>, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<R, R2>,
|
ShapeConstraint: SameNumberOfRows<R, R2>,
|
||||||
{
|
{
|
||||||
if eps < T::RealField::zero() {
|
if eps < T::RealField::zero() {
|
||||||
|
@ -648,11 +644,11 @@ where
|
||||||
/// Returns None if the singular vectors of the SVD haven't been calculated
|
/// Returns None if the singular vectors of the SVD haven't been calculated
|
||||||
pub fn to_polar(&self) -> Option<(OMatrix<T, R, R>, OMatrix<T, R, C>)>
|
pub fn to_polar(&self) -> Option<(OMatrix<T, R, R>, OMatrix<T, R, C>)>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, R, C> //result
|
DefaultAllocator: Allocator<R, C> //result
|
||||||
+ Allocator<T, DimMinimum<R, C>, R> // adjoint
|
+ Allocator<DimMinimum<R, C>, R> // adjoint
|
||||||
+ Allocator<T, DimMinimum<R, C>> // mapped vals
|
+ Allocator<DimMinimum<R, C>> // mapped vals
|
||||||
+ Allocator<T, R, R> // result
|
+ Allocator<R, R> // result
|
||||||
+ Allocator<T, DimMinimum<R, C>, DimMinimum<R, C>>, // square matrix
|
+ Allocator<DimMinimum<R, C>, DimMinimum<R, C>>, // square matrix
|
||||||
{
|
{
|
||||||
match (&self.u, &self.v_t) {
|
match (&self.u, &self.v_t) {
|
||||||
(Some(u), Some(v_t)) => Some((
|
(Some(u), Some(v_t)) => Some((
|
||||||
|
@ -668,17 +664,13 @@ where
|
||||||
impl<T: ComplexField, R: DimMin<C>, C: Dim> SVD<T, R, C>
|
impl<T: ComplexField, R: DimMin<C>, C: Dim> SVD<T, R, C>
|
||||||
where
|
where
|
||||||
DimMinimum<R, C>: DimSub<U1>, // for Bidiagonal.
|
DimMinimum<R, C>: DimSub<U1>, // for Bidiagonal.
|
||||||
DefaultAllocator: Allocator<T, R, C>
|
DefaultAllocator: Allocator<R, C>
|
||||||
+ Allocator<T, C>
|
+ Allocator<C>
|
||||||
+ Allocator<T, R>
|
+ Allocator<R>
|
||||||
+ Allocator<T, DimDiff<DimMinimum<R, C>, U1>>
|
+ Allocator<DimDiff<DimMinimum<R, C>, U1>>
|
||||||
+ Allocator<T, DimMinimum<R, C>, C>
|
+ Allocator<DimMinimum<R, C>, C>
|
||||||
+ Allocator<T, R, DimMinimum<R, C>>
|
+ Allocator<R, DimMinimum<R, C>>
|
||||||
+ Allocator<T, DimMinimum<R, C>>
|
+ Allocator<DimMinimum<R, C>>, // for sorted singular values
|
||||||
+ Allocator<T::RealField, DimMinimum<R, C>>
|
|
||||||
+ Allocator<T::RealField, DimDiff<DimMinimum<R, C>, U1>>
|
|
||||||
+ Allocator<(usize, usize), DimMinimum<R, C>> // for sorted singular values
|
|
||||||
+ Allocator<(T::RealField, usize), DimMinimum<R, C>>, // for sorted singular values
|
|
||||||
{
|
{
|
||||||
/// Computes the Singular Value Decomposition of `matrix` using implicit shift.
|
/// Computes the Singular Value Decomposition of `matrix` using implicit shift.
|
||||||
/// The singular values are guaranteed to be sorted in descending order.
|
/// The singular values are guaranteed to be sorted in descending order.
|
||||||
|
@ -784,15 +776,15 @@ where
|
||||||
impl<T: ComplexField, R: DimMin<C>, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S>
|
impl<T: ComplexField, R: DimMin<C>, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S>
|
||||||
where
|
where
|
||||||
DimMinimum<R, C>: DimSub<U1>, // for Bidiagonal.
|
DimMinimum<R, C>: DimSub<U1>, // for Bidiagonal.
|
||||||
DefaultAllocator: Allocator<T, R, C>
|
DefaultAllocator: Allocator<R, C>
|
||||||
+ Allocator<T, C>
|
+ Allocator<C>
|
||||||
+ Allocator<T, R>
|
+ Allocator<R>
|
||||||
+ Allocator<T, DimDiff<DimMinimum<R, C>, U1>>
|
+ Allocator<DimDiff<DimMinimum<R, C>, U1>>
|
||||||
+ Allocator<T, DimMinimum<R, C>, C>
|
+ Allocator<DimMinimum<R, C>, C>
|
||||||
+ Allocator<T, R, DimMinimum<R, C>>
|
+ Allocator<R, DimMinimum<R, C>>
|
||||||
+ Allocator<T, DimMinimum<R, C>>
|
+ Allocator<DimMinimum<R, C>>
|
||||||
+ Allocator<T::RealField, DimMinimum<R, C>>
|
+ Allocator<DimMinimum<R, C>>
|
||||||
+ Allocator<T::RealField, DimDiff<DimMinimum<R, C>, U1>>,
|
+ Allocator<DimDiff<DimMinimum<R, C>, U1>>,
|
||||||
{
|
{
|
||||||
/// Computes the singular values of this matrix.
|
/// Computes the singular values of this matrix.
|
||||||
/// The singular values are not guaranteed to be sorted in any particular order.
|
/// The singular values are not guaranteed to be sorted in any particular order.
|
||||||
|
@ -816,7 +808,7 @@ where
|
||||||
/// All singular values below `eps` are considered equal to 0.
|
/// All singular values below `eps` are considered equal to 0.
|
||||||
pub fn pseudo_inverse(self, eps: T::RealField) -> Result<OMatrix<T, C, R>, &'static str>
|
pub fn pseudo_inverse(self, eps: T::RealField) -> Result<OMatrix<T, C, R>, &'static str>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, C, R>,
|
DefaultAllocator: Allocator<C, R>,
|
||||||
{
|
{
|
||||||
SVD::new_unordered(self.clone_owned(), true, true).pseudo_inverse(eps)
|
SVD::new_unordered(self.clone_owned(), true, true).pseudo_inverse(eps)
|
||||||
}
|
}
|
||||||
|
@ -825,17 +817,13 @@ where
|
||||||
impl<T: ComplexField, R: DimMin<C>, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S>
|
impl<T: ComplexField, R: DimMin<C>, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S>
|
||||||
where
|
where
|
||||||
DimMinimum<R, C>: DimSub<U1>,
|
DimMinimum<R, C>: DimSub<U1>,
|
||||||
DefaultAllocator: Allocator<T, R, C>
|
DefaultAllocator: Allocator<R, C>
|
||||||
+ Allocator<T, C>
|
+ Allocator<C>
|
||||||
+ Allocator<T, R>
|
+ Allocator<R>
|
||||||
+ Allocator<T, DimDiff<DimMinimum<R, C>, U1>>
|
+ Allocator<DimDiff<DimMinimum<R, C>, U1>>
|
||||||
+ Allocator<T, DimMinimum<R, C>, C>
|
+ Allocator<DimMinimum<R, C>, C>
|
||||||
+ Allocator<T, R, DimMinimum<R, C>>
|
+ Allocator<R, DimMinimum<R, C>>
|
||||||
+ Allocator<T, DimMinimum<R, C>>
|
+ Allocator<DimMinimum<R, C>>,
|
||||||
+ Allocator<T::RealField, DimMinimum<R, C>>
|
|
||||||
+ Allocator<T::RealField, DimDiff<DimMinimum<R, C>, U1>>
|
|
||||||
+ Allocator<(usize, usize), DimMinimum<R, C>>
|
|
||||||
+ Allocator<(T::RealField, usize), DimMinimum<R, C>>,
|
|
||||||
{
|
{
|
||||||
/// Computes the singular values of this matrix.
|
/// Computes the singular values of this matrix.
|
||||||
/// The singular values are guaranteed to be sorted in descending order.
|
/// The singular values are guaranteed to be sorted in descending order.
|
||||||
|
|
|
@ -17,22 +17,22 @@ use crate::linalg::SymmetricTridiagonal;
|
||||||
#[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))]
|
#[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(serialize = "DefaultAllocator: Allocator<T, D, D> +
|
serde(bound(serialize = "DefaultAllocator: Allocator<D, D> +
|
||||||
Allocator<T::RealField, D>,
|
Allocator<D>,
|
||||||
OVector<T::RealField, D>: Serialize,
|
OVector<T::RealField, D>: Serialize,
|
||||||
OMatrix<T, D, D>: Serialize"))
|
OMatrix<T, D, D>: Serialize"))
|
||||||
)]
|
)]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(deserialize = "DefaultAllocator: Allocator<T, D, D> +
|
serde(bound(deserialize = "DefaultAllocator: Allocator<D, D> +
|
||||||
Allocator<T::RealField, D>,
|
Allocator<D>,
|
||||||
OVector<T::RealField, D>: Deserialize<'de>,
|
OVector<T::RealField, D>: Deserialize<'de>,
|
||||||
OMatrix<T, D, D>: Deserialize<'de>"))
|
OMatrix<T, D, D>: Deserialize<'de>"))
|
||||||
)]
|
)]
|
||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
pub struct SymmetricEigen<T: ComplexField, D: Dim>
|
pub struct SymmetricEigen<T: ComplexField, D: Dim>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T::RealField, D>,
|
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
{
|
{
|
||||||
/// The eigenvectors of the decomposed matrix.
|
/// The eigenvectors of the decomposed matrix.
|
||||||
pub eigenvectors: OMatrix<T, D, D>,
|
pub eigenvectors: OMatrix<T, D, D>,
|
||||||
|
@ -43,7 +43,7 @@ where
|
||||||
|
|
||||||
impl<T: ComplexField, D: Dim> Copy for SymmetricEigen<T, D>
|
impl<T: ComplexField, D: Dim> Copy for SymmetricEigen<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T::RealField, D>,
|
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
OMatrix<T, D, D>: Copy,
|
OMatrix<T, D, D>: Copy,
|
||||||
OVector<T::RealField, D>: Copy,
|
OVector<T::RealField, D>: Copy,
|
||||||
{
|
{
|
||||||
|
@ -51,7 +51,7 @@ where
|
||||||
|
|
||||||
impl<T: ComplexField, D: Dim> SymmetricEigen<T, D>
|
impl<T: ComplexField, D: Dim> SymmetricEigen<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T::RealField, D>,
|
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
{
|
{
|
||||||
/// Computes the eigendecomposition of the given symmetric matrix.
|
/// Computes the eigendecomposition of the given symmetric matrix.
|
||||||
///
|
///
|
||||||
|
@ -59,7 +59,7 @@ where
|
||||||
pub fn new(m: OMatrix<T, D, D>) -> Self
|
pub fn new(m: OMatrix<T, D, D>) -> Self
|
||||||
where
|
where
|
||||||
D: DimSub<U1>,
|
D: DimSub<U1>,
|
||||||
DefaultAllocator: Allocator<T, DimDiff<D, U1>> + Allocator<T::RealField, DimDiff<D, U1>>,
|
DefaultAllocator: Allocator<DimDiff<D, U1>> + Allocator<DimDiff<D, U1>>,
|
||||||
{
|
{
|
||||||
Self::try_new(m, T::RealField::default_epsilon(), 0).unwrap()
|
Self::try_new(m, T::RealField::default_epsilon(), 0).unwrap()
|
||||||
}
|
}
|
||||||
|
@ -78,7 +78,7 @@ where
|
||||||
pub fn try_new(m: OMatrix<T, D, D>, eps: T::RealField, max_niter: usize) -> Option<Self>
|
pub fn try_new(m: OMatrix<T, D, D>, eps: T::RealField, max_niter: usize) -> Option<Self>
|
||||||
where
|
where
|
||||||
D: DimSub<U1>,
|
D: DimSub<U1>,
|
||||||
DefaultAllocator: Allocator<T, DimDiff<D, U1>> + Allocator<T::RealField, DimDiff<D, U1>>,
|
DefaultAllocator: Allocator<DimDiff<D, U1>> + Allocator<DimDiff<D, U1>>,
|
||||||
{
|
{
|
||||||
Self::do_decompose(m, true, eps, max_niter).map(|(vals, vecs)| SymmetricEigen {
|
Self::do_decompose(m, true, eps, max_niter).map(|(vals, vecs)| SymmetricEigen {
|
||||||
eigenvectors: vecs.unwrap(),
|
eigenvectors: vecs.unwrap(),
|
||||||
|
@ -94,7 +94,7 @@ where
|
||||||
) -> Option<(OVector<T::RealField, D>, Option<OMatrix<T, D, D>>)>
|
) -> Option<(OVector<T::RealField, D>, Option<OMatrix<T, D, D>>)>
|
||||||
where
|
where
|
||||||
D: DimSub<U1>,
|
D: DimSub<U1>,
|
||||||
DefaultAllocator: Allocator<T, DimDiff<D, U1>> + Allocator<T::RealField, DimDiff<D, U1>>,
|
DefaultAllocator: Allocator<DimDiff<D, U1>> + Allocator<DimDiff<D, U1>>,
|
||||||
{
|
{
|
||||||
assert!(
|
assert!(
|
||||||
matrix.is_square(),
|
matrix.is_square(),
|
||||||
|
@ -244,7 +244,7 @@ where
|
||||||
) -> (usize, usize)
|
) -> (usize, usize)
|
||||||
where
|
where
|
||||||
D: DimSub<U1>,
|
D: DimSub<U1>,
|
||||||
DefaultAllocator: Allocator<T::RealField, DimDiff<D, U1>>,
|
DefaultAllocator: Allocator<DimDiff<D, U1>>,
|
||||||
{
|
{
|
||||||
let mut n = end;
|
let mut n = end;
|
||||||
|
|
||||||
|
@ -321,10 +321,8 @@ pub fn wilkinson_shift<T: ComplexField>(tmm: T, tnn: T, tmn: T) -> T {
|
||||||
*/
|
*/
|
||||||
impl<T: ComplexField, D: DimSub<U1>, S: Storage<T, D, D>> SquareMatrix<T, D, S>
|
impl<T: ComplexField, D: DimSub<U1>, S: Storage<T, D, D>> SquareMatrix<T, D, S>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D>
|
DefaultAllocator:
|
||||||
+ Allocator<T, DimDiff<D, U1>>
|
Allocator<D, D> + Allocator<DimDiff<D, U1>> + Allocator<D> + Allocator<DimDiff<D, U1>>,
|
||||||
+ Allocator<T::RealField, D>
|
|
||||||
+ Allocator<T::RealField, DimDiff<D, U1>>,
|
|
||||||
{
|
{
|
||||||
/// Computes the eigenvalues of this symmetric matrix.
|
/// Computes the eigenvalues of this symmetric matrix.
|
||||||
///
|
///
|
||||||
|
|
|
@ -14,22 +14,22 @@ use std::mem::MaybeUninit;
|
||||||
#[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))]
|
#[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(serialize = "DefaultAllocator: Allocator<T, D, D> +
|
serde(bound(serialize = "DefaultAllocator: Allocator<D, D> +
|
||||||
Allocator<T, DimDiff<D, U1>>,
|
Allocator<DimDiff<D, U1>>,
|
||||||
OMatrix<T, D, D>: Serialize,
|
OMatrix<T, D, D>: Serialize,
|
||||||
OVector<T, DimDiff<D, U1>>: Serialize"))
|
OVector<T, DimDiff<D, U1>>: Serialize"))
|
||||||
)]
|
)]
|
||||||
#[cfg_attr(
|
#[cfg_attr(
|
||||||
feature = "serde-serialize-no-std",
|
feature = "serde-serialize-no-std",
|
||||||
serde(bound(deserialize = "DefaultAllocator: Allocator<T, D, D> +
|
serde(bound(deserialize = "DefaultAllocator: Allocator<D, D> +
|
||||||
Allocator<T, DimDiff<D, U1>>,
|
Allocator<DimDiff<D, U1>>,
|
||||||
OMatrix<T, D, D>: Deserialize<'de>,
|
OMatrix<T, D, D>: Deserialize<'de>,
|
||||||
OVector<T, DimDiff<D, U1>>: Deserialize<'de>"))
|
OVector<T, DimDiff<D, U1>>: Deserialize<'de>"))
|
||||||
)]
|
)]
|
||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
pub struct SymmetricTridiagonal<T: ComplexField, D: DimSub<U1>>
|
pub struct SymmetricTridiagonal<T: ComplexField, D: DimSub<U1>>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>,
|
DefaultAllocator: Allocator<D, D> + Allocator<DimDiff<D, U1>>,
|
||||||
{
|
{
|
||||||
tri: OMatrix<T, D, D>,
|
tri: OMatrix<T, D, D>,
|
||||||
off_diagonal: OVector<T, DimDiff<D, U1>>,
|
off_diagonal: OVector<T, DimDiff<D, U1>>,
|
||||||
|
@ -37,7 +37,7 @@ where
|
||||||
|
|
||||||
impl<T: ComplexField, D: DimSub<U1>> Copy for SymmetricTridiagonal<T, D>
|
impl<T: ComplexField, D: DimSub<U1>> Copy for SymmetricTridiagonal<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>,
|
DefaultAllocator: Allocator<D, D> + Allocator<DimDiff<D, U1>>,
|
||||||
OMatrix<T, D, D>: Copy,
|
OMatrix<T, D, D>: Copy,
|
||||||
OVector<T, DimDiff<D, U1>>: Copy,
|
OVector<T, DimDiff<D, U1>>: Copy,
|
||||||
{
|
{
|
||||||
|
@ -45,7 +45,7 @@ where
|
||||||
|
|
||||||
impl<T: ComplexField, D: DimSub<U1>> SymmetricTridiagonal<T, D>
|
impl<T: ComplexField, D: DimSub<U1>> SymmetricTridiagonal<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>,
|
DefaultAllocator: Allocator<D, D> + Allocator<DimDiff<D, U1>>,
|
||||||
{
|
{
|
||||||
/// Computes the tridiagonalization of the symmetric matrix `m`.
|
/// Computes the tridiagonalization of the symmetric matrix `m`.
|
||||||
///
|
///
|
||||||
|
@ -108,7 +108,7 @@ where
|
||||||
OVector<T::RealField, DimDiff<D, U1>>,
|
OVector<T::RealField, DimDiff<D, U1>>,
|
||||||
)
|
)
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T::RealField, D> + Allocator<T::RealField, DimDiff<D, U1>>,
|
DefaultAllocator: Allocator<D> + Allocator<DimDiff<D, U1>>,
|
||||||
{
|
{
|
||||||
let diag = self.diagonal();
|
let diag = self.diagonal();
|
||||||
let q = self.q();
|
let q = self.q();
|
||||||
|
@ -124,7 +124,7 @@ where
|
||||||
OVector<T::RealField, DimDiff<D, U1>>,
|
OVector<T::RealField, DimDiff<D, U1>>,
|
||||||
)
|
)
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T::RealField, D> + Allocator<T::RealField, DimDiff<D, U1>>,
|
DefaultAllocator: Allocator<D> + Allocator<DimDiff<D, U1>>,
|
||||||
{
|
{
|
||||||
(self.diagonal(), self.off_diagonal.map(T::modulus))
|
(self.diagonal(), self.off_diagonal.map(T::modulus))
|
||||||
}
|
}
|
||||||
|
@ -133,7 +133,7 @@ where
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn diagonal(&self) -> OVector<T::RealField, D>
|
pub fn diagonal(&self) -> OVector<T::RealField, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T::RealField, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
self.tri.map_diagonal(|e| e.real())
|
self.tri.map_diagonal(|e| e.real())
|
||||||
}
|
}
|
||||||
|
@ -142,7 +142,7 @@ where
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn off_diagonal(&self) -> OVector<T::RealField, DimDiff<D, U1>>
|
pub fn off_diagonal(&self) -> OVector<T::RealField, DimDiff<D, U1>>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T::RealField, DimDiff<D, U1>>,
|
DefaultAllocator: Allocator<DimDiff<D, U1>>,
|
||||||
{
|
{
|
||||||
self.off_diagonal.map(T::modulus)
|
self.off_diagonal.map(T::modulus)
|
||||||
}
|
}
|
||||||
|
|
|
@ -21,7 +21,7 @@ use simba::scalar::RealField;
|
||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
pub struct UDU<T: RealField, D: Dim>
|
pub struct UDU<T: RealField, D: Dim>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D> + Allocator<D, D>,
|
||||||
{
|
{
|
||||||
/// The upper triangular matrix resulting from the factorization
|
/// The upper triangular matrix resulting from the factorization
|
||||||
pub u: OMatrix<T, D, D>,
|
pub u: OMatrix<T, D, D>,
|
||||||
|
@ -31,7 +31,7 @@ where
|
||||||
|
|
||||||
impl<T: RealField, D: Dim> Copy for UDU<T, D>
|
impl<T: RealField, D: Dim> Copy for UDU<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D> + Allocator<D, D>,
|
||||||
OVector<T, D>: Copy,
|
OVector<T, D>: Copy,
|
||||||
OMatrix<T, D, D>: Copy,
|
OMatrix<T, D, D>: Copy,
|
||||||
{
|
{
|
||||||
|
@ -39,7 +39,7 @@ where
|
||||||
|
|
||||||
impl<T: RealField, D: Dim> UDU<T, D>
|
impl<T: RealField, D: Dim> UDU<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D> + Allocator<D, D>,
|
||||||
{
|
{
|
||||||
/// Computes the UDU^T factorization.
|
/// Computes the UDU^T factorization.
|
||||||
///
|
///
|
||||||
|
|
|
@ -257,7 +257,7 @@ where
|
||||||
ScalarStrategy::Value: Scalar,
|
ScalarStrategy::Value: Scalar,
|
||||||
R: Dim,
|
R: Dim,
|
||||||
C: Dim,
|
C: Dim,
|
||||||
DefaultAllocator: Allocator<ScalarStrategy::Value, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
matrix_(value_strategy, rows.into(), cols.into())
|
matrix_(value_strategy, rows.into(), cols.into())
|
||||||
}
|
}
|
||||||
|
@ -273,7 +273,7 @@ where
|
||||||
ScalarStrategy::Value: Scalar,
|
ScalarStrategy::Value: Scalar,
|
||||||
R: Dim,
|
R: Dim,
|
||||||
C: Dim,
|
C: Dim,
|
||||||
DefaultAllocator: Allocator<ScalarStrategy::Value, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
let nrows = rows.lower_bound().value()..=rows.upper_bound().value();
|
let nrows = rows.lower_bound().value()..=rows.upper_bound().value();
|
||||||
let ncols = cols.lower_bound().value()..=cols.upper_bound().value();
|
let ncols = cols.lower_bound().value()..=cols.upper_bound().value();
|
||||||
|
@ -327,7 +327,7 @@ where
|
||||||
ScalarStrategy: Strategy + Clone + 'static,
|
ScalarStrategy: Strategy + Clone + 'static,
|
||||||
ScalarStrategy::Value: Scalar,
|
ScalarStrategy::Value: Scalar,
|
||||||
D: Dim,
|
D: Dim,
|
||||||
DefaultAllocator: Allocator<ScalarStrategy::Value, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
matrix_(value_strategy, length.into(), Const::<1>.into())
|
matrix_(value_strategy, length.into(), Const::<1>.into())
|
||||||
}
|
}
|
||||||
|
@ -395,7 +395,7 @@ where
|
||||||
R: Dim,
|
R: Dim,
|
||||||
C: Dim,
|
C: Dim,
|
||||||
MatrixParameters<T::Parameters, R, C>: Default,
|
MatrixParameters<T::Parameters, R, C>: Default,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
type Parameters = MatrixParameters<T::Parameters, R, C>;
|
type Parameters = MatrixParameters<T::Parameters, R, C>;
|
||||||
|
|
||||||
|
@ -413,7 +413,7 @@ pub struct MatrixStrategy<NStrategy, R: Dim, C: Dim>
|
||||||
where
|
where
|
||||||
NStrategy: Strategy,
|
NStrategy: Strategy,
|
||||||
NStrategy::Value: Scalar,
|
NStrategy::Value: Scalar,
|
||||||
DefaultAllocator: Allocator<NStrategy::Value, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
// For now we only internally hold a boxed strategy. The reason for introducing this
|
// For now we only internally hold a boxed strategy. The reason for introducing this
|
||||||
// separate wrapper struct is so that we can replace the strategy logic with custom logic
|
// separate wrapper struct is so that we can replace the strategy logic with custom logic
|
||||||
|
@ -427,7 +427,7 @@ where
|
||||||
NStrategy::Value: Scalar,
|
NStrategy::Value: Scalar,
|
||||||
R: Dim,
|
R: Dim,
|
||||||
C: Dim,
|
C: Dim,
|
||||||
DefaultAllocator: Allocator<NStrategy::Value, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
type Tree = MatrixValueTree<NStrategy::Value, R, C>;
|
type Tree = MatrixValueTree<NStrategy::Value, R, C>;
|
||||||
type Value = OMatrix<NStrategy::Value, R, C>;
|
type Value = OMatrix<NStrategy::Value, R, C>;
|
||||||
|
@ -446,7 +446,7 @@ where
|
||||||
T: Scalar,
|
T: Scalar,
|
||||||
R: Dim,
|
R: Dim,
|
||||||
C: Dim,
|
C: Dim,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
// For now we only wrap a boxed value tree. The reason for wrapping is that this allows us
|
// For now we only wrap a boxed value tree. The reason for wrapping is that this allows us
|
||||||
// to swap out the value tree logic down the road without significant breaking changes.
|
// to swap out the value tree logic down the road without significant breaking changes.
|
||||||
|
@ -458,7 +458,7 @@ where
|
||||||
T: Scalar,
|
T: Scalar,
|
||||||
R: Dim,
|
R: Dim,
|
||||||
C: Dim,
|
C: Dim,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
type Value = OMatrix<T, R, C>;
|
type Value = OMatrix<T, R, C>;
|
||||||
|
|
||||||
|
|
|
@ -106,7 +106,7 @@ pub trait CsStorageMut<T, R, C = U1>:
|
||||||
#[derive(Clone, Debug, PartialEq)]
|
#[derive(Clone, Debug, PartialEq)]
|
||||||
pub struct CsVecStorage<T: Scalar, R: Dim, C: Dim>
|
pub struct CsVecStorage<T: Scalar, R: Dim, C: Dim>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<usize, C>,
|
DefaultAllocator: Allocator<C>,
|
||||||
{
|
{
|
||||||
pub(crate) shape: (R, C),
|
pub(crate) shape: (R, C),
|
||||||
pub(crate) p: OVector<usize, C>,
|
pub(crate) p: OVector<usize, C>,
|
||||||
|
@ -116,7 +116,7 @@ where
|
||||||
|
|
||||||
impl<T: Scalar, R: Dim, C: Dim> CsVecStorage<T, R, C>
|
impl<T: Scalar, R: Dim, C: Dim> CsVecStorage<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<usize, C>,
|
DefaultAllocator: Allocator<C>,
|
||||||
{
|
{
|
||||||
/// The value buffer of this storage.
|
/// The value buffer of this storage.
|
||||||
#[must_use]
|
#[must_use]
|
||||||
|
@ -137,11 +137,11 @@ where
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T: Scalar, R: Dim, C: Dim> CsVecStorage<T, R, C> where DefaultAllocator: Allocator<usize, C> {}
|
impl<T: Scalar, R: Dim, C: Dim> CsVecStorage<T, R, C> where DefaultAllocator: Allocator<C> {}
|
||||||
|
|
||||||
impl<'a, T: Scalar, R: Dim, C: Dim> CsStorageIter<'a, T, R, C> for CsVecStorage<T, R, C>
|
impl<'a, T: Scalar, R: Dim, C: Dim> CsStorageIter<'a, T, R, C> for CsVecStorage<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<usize, C>,
|
DefaultAllocator: Allocator<C>,
|
||||||
{
|
{
|
||||||
type ColumnEntries = ColumnEntries<'a, T>;
|
type ColumnEntries = ColumnEntries<'a, T>;
|
||||||
type ColumnRowIndices = iter::Cloned<slice::Iter<'a, usize>>;
|
type ColumnRowIndices = iter::Cloned<slice::Iter<'a, usize>>;
|
||||||
|
@ -161,7 +161,7 @@ where
|
||||||
|
|
||||||
impl<T: Scalar, R: Dim, C: Dim> CsStorage<T, R, C> for CsVecStorage<T, R, C>
|
impl<T: Scalar, R: Dim, C: Dim> CsStorage<T, R, C> for CsVecStorage<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<usize, C>,
|
DefaultAllocator: Allocator<C>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn shape(&self) -> (R, C) {
|
fn shape(&self) -> (R, C) {
|
||||||
|
@ -207,7 +207,7 @@ where
|
||||||
|
|
||||||
impl<'a, T: Scalar, R: Dim, C: Dim> CsStorageIterMut<'a, T, R, C> for CsVecStorage<T, R, C>
|
impl<'a, T: Scalar, R: Dim, C: Dim> CsStorageIterMut<'a, T, R, C> for CsVecStorage<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<usize, C>,
|
DefaultAllocator: Allocator<C>,
|
||||||
{
|
{
|
||||||
type ValuesMut = slice::IterMut<'a, T>;
|
type ValuesMut = slice::IterMut<'a, T>;
|
||||||
type ColumnEntriesMut = iter::Zip<iter::Cloned<slice::Iter<'a, usize>>, slice::IterMut<'a, T>>;
|
type ColumnEntriesMut = iter::Zip<iter::Cloned<slice::Iter<'a, usize>>, slice::IterMut<'a, T>>;
|
||||||
|
@ -228,7 +228,7 @@ where
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T: Scalar, R: Dim, C: Dim> CsStorageMut<T, R, C> for CsVecStorage<T, R, C> where
|
impl<T: Scalar, R: Dim, C: Dim> CsStorageMut<T, R, C> for CsVecStorage<T, R, C> where
|
||||||
DefaultAllocator: Allocator<usize, C>
|
DefaultAllocator: Allocator<C>
|
||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -257,7 +257,7 @@ pub type CsVector<T, R = Dyn, S = CsVecStorage<T, R, U1>> = CsMatrix<T, R, U1, S
|
||||||
|
|
||||||
impl<T: Scalar, R: Dim, C: Dim> CsMatrix<T, R, C>
|
impl<T: Scalar, R: Dim, C: Dim> CsMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<usize, C>,
|
DefaultAllocator: Allocator<C>,
|
||||||
{
|
{
|
||||||
/// Creates a new compressed sparse column matrix with the specified dimension and
|
/// Creates a new compressed sparse column matrix with the specified dimension and
|
||||||
/// `nvals` possible non-zero values.
|
/// `nvals` possible non-zero values.
|
||||||
|
@ -295,7 +295,7 @@ where
|
||||||
) -> Self
|
) -> Self
|
||||||
where
|
where
|
||||||
T: Zero + ClosedAdd,
|
T: Zero + ClosedAdd,
|
||||||
DefaultAllocator: Allocator<T, R>,
|
DefaultAllocator: Allocator<R>,
|
||||||
{
|
{
|
||||||
assert_eq!(ncols.value(), p.len(), "Invalid inptr size.");
|
assert_eq!(ncols.value(), p.len(), "Invalid inptr size.");
|
||||||
assert_eq!(i.len(), vals.len(), "Invalid value size.");
|
assert_eq!(i.len(), vals.len(), "Invalid value size.");
|
||||||
|
@ -421,7 +421,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: CsStorage<T, R, C>> CsMatrix<T, R, C, S> {
|
||||||
#[must_use = "This function does not mutate the matrix. Consider using the return value or removing the function call. There's also transpose_mut() for square matrices."]
|
#[must_use = "This function does not mutate the matrix. Consider using the return value or removing the function call. There's also transpose_mut() for square matrices."]
|
||||||
pub fn transpose(&self) -> CsMatrix<T, C, R>
|
pub fn transpose(&self) -> CsMatrix<T, C, R>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<usize, R>,
|
DefaultAllocator: Allocator<R>,
|
||||||
{
|
{
|
||||||
let (nrows, ncols) = self.data.shape();
|
let (nrows, ncols) = self.data.shape();
|
||||||
|
|
||||||
|
@ -462,12 +462,12 @@ impl<T: Scalar, R: Dim, C: Dim, S: CsStorageMut<T, R, C>> CsMatrix<T, R, C, S> {
|
||||||
|
|
||||||
impl<T: Scalar, R: Dim, C: Dim> CsMatrix<T, R, C>
|
impl<T: Scalar, R: Dim, C: Dim> CsMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<usize, C>,
|
DefaultAllocator: Allocator<C>,
|
||||||
{
|
{
|
||||||
pub(crate) fn sort(&mut self)
|
pub(crate) fn sort(&mut self)
|
||||||
where
|
where
|
||||||
T: Zero,
|
T: Zero,
|
||||||
DefaultAllocator: Allocator<T, R>,
|
DefaultAllocator: Allocator<R>,
|
||||||
{
|
{
|
||||||
// Size = R
|
// Size = R
|
||||||
let nrows = self.data.shape().0;
|
let nrows = self.data.shape().0;
|
||||||
|
|
|
@ -8,7 +8,7 @@ use crate::{Const, DefaultAllocator, Dim, Matrix, OVector, RealField};
|
||||||
/// The cholesky decomposition of a column compressed sparse matrix.
|
/// The cholesky decomposition of a column compressed sparse matrix.
|
||||||
pub struct CsCholesky<T: RealField, D: Dim>
|
pub struct CsCholesky<T: RealField, D: Dim>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<usize, D> + Allocator<T, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
// Non-zero pattern of the original matrix upper-triangular part.
|
// Non-zero pattern of the original matrix upper-triangular part.
|
||||||
// Unlike the original matrix, the `original_p` array does contain the last sentinel value
|
// Unlike the original matrix, the `original_p` array does contain the last sentinel value
|
||||||
|
@ -28,7 +28,7 @@ where
|
||||||
|
|
||||||
impl<T: RealField, D: Dim> CsCholesky<T, D>
|
impl<T: RealField, D: Dim> CsCholesky<T, D>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<usize, D> + Allocator<T, D>,
|
DefaultAllocator: Allocator<D> + Allocator<D>,
|
||||||
{
|
{
|
||||||
/// Computes the cholesky decomposition of the sparse matrix `m`.
|
/// Computes the cholesky decomposition of the sparse matrix `m`.
|
||||||
pub fn new(m: &CsMatrix<T, D, D>) -> Self {
|
pub fn new(m: &CsMatrix<T, D, D>) -> Self {
|
||||||
|
|
|
@ -22,7 +22,7 @@ impl<'a, T: Scalar + Zero + ClosedAdd> CsMatrix<T> {
|
||||||
|
|
||||||
impl<'a, T: Scalar + Zero + ClosedAdd, R: Dim, C: Dim> CsMatrix<T, R, C>
|
impl<'a, T: Scalar + Zero + ClosedAdd, R: Dim, C: Dim> CsMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<usize, C> + Allocator<T, R>,
|
DefaultAllocator: Allocator<C> + Allocator<R>,
|
||||||
{
|
{
|
||||||
/// Creates a column-compressed sparse matrix from a sparse matrix in triplet form.
|
/// Creates a column-compressed sparse matrix from a sparse matrix in triplet form.
|
||||||
pub fn from_triplet_generic(
|
pub fn from_triplet_generic(
|
||||||
|
@ -68,7 +68,7 @@ where
|
||||||
impl<'a, T: Scalar + Zero, R: Dim, C: Dim, S> From<CsMatrix<T, R, C, S>> for OMatrix<T, R, C>
|
impl<'a, T: Scalar + Zero, R: Dim, C: Dim, S> From<CsMatrix<T, R, C, S>> for OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
S: CsStorage<T, R, C>,
|
S: CsStorage<T, R, C>,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
fn from(m: CsMatrix<T, R, C, S>) -> Self {
|
fn from(m: CsMatrix<T, R, C, S>) -> Self {
|
||||||
let (nrows, ncols) = m.data.shape();
|
let (nrows, ncols) = m.data.shape();
|
||||||
|
@ -87,7 +87,7 @@ where
|
||||||
impl<'a, T: Scalar + Zero, R: Dim, C: Dim, S> From<Matrix<T, R, C, S>> for CsMatrix<T, R, C>
|
impl<'a, T: Scalar + Zero, R: Dim, C: Dim, S> From<Matrix<T, R, C, S>> for CsMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
S: Storage<T, R, C>,
|
S: Storage<T, R, C>,
|
||||||
DefaultAllocator: Allocator<T, R, C> + Allocator<usize, C>,
|
DefaultAllocator: Allocator<R, C> + Allocator<C>,
|
||||||
{
|
{
|
||||||
fn from(m: Matrix<T, R, C, S>) -> Self {
|
fn from(m: Matrix<T, R, C, S>) -> Self {
|
||||||
let (nrows, ncols) = m.data.shape();
|
let (nrows, ncols) = m.data.shape();
|
||||||
|
|
|
@ -21,7 +21,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: CsStorage<T, R, C>> CsMatrix<T, R, C, S> {
|
||||||
) -> usize
|
) -> usize
|
||||||
where
|
where
|
||||||
T: ClosedAdd + ClosedMul,
|
T: ClosedAdd + ClosedMul,
|
||||||
DefaultAllocator: Allocator<usize, C2>,
|
DefaultAllocator: Allocator<C2>,
|
||||||
{
|
{
|
||||||
for (i, val) in self.data.column_entries(j) {
|
for (i, val) in self.data.column_entries(j) {
|
||||||
if timestamps[i] < timestamp {
|
if timestamps[i] < timestamp {
|
||||||
|
@ -134,7 +134,7 @@ where
|
||||||
S1: CsStorage<T, R1, C1>,
|
S1: CsStorage<T, R1, C1>,
|
||||||
S2: CsStorage<T, R2, C2>,
|
S2: CsStorage<T, R2, C2>,
|
||||||
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
|
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
|
||||||
DefaultAllocator: Allocator<usize, C2> + Allocator<usize, R1> + Allocator<T, R1>,
|
DefaultAllocator: Allocator<C2> + Allocator<R1> + Allocator<R1>,
|
||||||
{
|
{
|
||||||
type Output = CsMatrix<T, R1, C2>;
|
type Output = CsMatrix<T, R1, C2>;
|
||||||
|
|
||||||
|
@ -227,7 +227,7 @@ where
|
||||||
S1: CsStorage<T, R1, C1>,
|
S1: CsStorage<T, R1, C1>,
|
||||||
S2: CsStorage<T, R2, C2>,
|
S2: CsStorage<T, R2, C2>,
|
||||||
ShapeConstraint: DimEq<R1, R2> + DimEq<C1, C2>,
|
ShapeConstraint: DimEq<R1, R2> + DimEq<C1, C2>,
|
||||||
DefaultAllocator: Allocator<usize, C2> + Allocator<usize, R1> + Allocator<T, R1>,
|
DefaultAllocator: Allocator<C2> + Allocator<R1> + Allocator<R1>,
|
||||||
{
|
{
|
||||||
type Output = CsMatrix<T, R1, C2>;
|
type Output = CsMatrix<T, R1, C2>;
|
||||||
|
|
||||||
|
|
|
@ -13,7 +13,7 @@ impl<T: RealField, D: Dim, S: CsStorage<T, D, D>> CsMatrix<T, D, D, S> {
|
||||||
) -> Option<OMatrix<T, R2, C2>>
|
) -> Option<OMatrix<T, R2, C2>>
|
||||||
where
|
where
|
||||||
S2: Storage<T, R2, C2>,
|
S2: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: Allocator<T, R2, C2>,
|
DefaultAllocator: Allocator<R2, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<D, R2>,
|
ShapeConstraint: SameNumberOfRows<D, R2>,
|
||||||
{
|
{
|
||||||
let mut b = b.clone_owned();
|
let mut b = b.clone_owned();
|
||||||
|
@ -32,7 +32,7 @@ impl<T: RealField, D: Dim, S: CsStorage<T, D, D>> CsMatrix<T, D, D, S> {
|
||||||
) -> Option<OMatrix<T, R2, C2>>
|
) -> Option<OMatrix<T, R2, C2>>
|
||||||
where
|
where
|
||||||
S2: Storage<T, R2, C2>,
|
S2: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: Allocator<T, R2, C2>,
|
DefaultAllocator: Allocator<R2, C2>,
|
||||||
ShapeConstraint: SameNumberOfRows<D, R2>,
|
ShapeConstraint: SameNumberOfRows<D, R2>,
|
||||||
{
|
{
|
||||||
let mut b = b.clone_owned();
|
let mut b = b.clone_owned();
|
||||||
|
@ -144,7 +144,7 @@ impl<T: RealField, D: Dim, S: CsStorage<T, D, D>> CsMatrix<T, D, D, S> {
|
||||||
) -> Option<CsVector<T, D2>>
|
) -> Option<CsVector<T, D2>>
|
||||||
where
|
where
|
||||||
S2: CsStorage<T, D2>,
|
S2: CsStorage<T, D2>,
|
||||||
DefaultAllocator: Allocator<bool, D> + Allocator<T, D2> + Allocator<usize, D2>,
|
DefaultAllocator: Allocator<D> + Allocator<D2>,
|
||||||
ShapeConstraint: SameNumberOfRows<D, D2>,
|
ShapeConstraint: SameNumberOfRows<D, D2>,
|
||||||
{
|
{
|
||||||
let mut reach = Vec::new();
|
let mut reach = Vec::new();
|
||||||
|
@ -208,7 +208,7 @@ impl<T: RealField, D: Dim, S: CsStorage<T, D, D>> CsMatrix<T, D, D, S> {
|
||||||
xi: &mut Vec<usize>,
|
xi: &mut Vec<usize>,
|
||||||
) where
|
) where
|
||||||
S2: CsStorage<T, D2>,
|
S2: CsStorage<T, D2>,
|
||||||
DefaultAllocator: Allocator<bool, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
let mut visited = OVector::repeat_generic(self.data.shape().1, U1, false);
|
let mut visited = OVector::repeat_generic(self.data.shape().1, U1, false);
|
||||||
let mut stack = Vec::new();
|
let mut stack = Vec::new();
|
||||||
|
@ -252,7 +252,7 @@ impl<T: RealField, D: Dim, S: CsStorage<T, D, D>> CsMatrix<T, D, D, S> {
|
||||||
fn lower_triangular_reach<D2: Dim, S2>(&self, b: &CsVector<T, D2, S2>, xi: &mut Vec<usize>)
|
fn lower_triangular_reach<D2: Dim, S2>(&self, b: &CsVector<T, D2, S2>, xi: &mut Vec<usize>)
|
||||||
where
|
where
|
||||||
S2: CsStorage<T, D2>,
|
S2: CsStorage<T, D2>,
|
||||||
DefaultAllocator: Allocator<bool, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
let mut visited = OVector::repeat_generic(self.data.shape().1, Const::<1>, false);
|
let mut visited = OVector::repeat_generic(self.data.shape().1, Const::<1>, false);
|
||||||
let mut stack = Vec::new();
|
let mut stack = Vec::new();
|
||||||
|
|
|
@ -3,7 +3,7 @@ use crate::{DefaultAllocator, Dim, OVector};
|
||||||
|
|
||||||
pub fn cumsum<D: Dim>(a: &mut OVector<usize, D>, b: &mut OVector<usize, D>) -> usize
|
pub fn cumsum<D: Dim>(a: &mut OVector<usize, D>, b: &mut OVector<usize, D>) -> usize
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<usize, D>,
|
DefaultAllocator: Allocator<D>,
|
||||||
{
|
{
|
||||||
assert!(a.len() == b.len());
|
assert!(a.len() == b.len());
|
||||||
let mut sum = 0;
|
let mut sum = 0;
|
||||||
|
|
|
@ -27,7 +27,7 @@ use std::mem::MaybeUninit;
|
||||||
impl<T, R: DimName, C: DimName> Identity<Additive> for OMatrix<T, R, C>
|
impl<T, R: DimName, C: DimName> Identity<Additive> for OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero,
|
T: Scalar + Zero,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn identity() -> Self {
|
fn identity() -> Self {
|
||||||
|
@ -38,7 +38,7 @@ where
|
||||||
impl<T, R: DimName, C: DimName> AbstractMagma<Additive> for OMatrix<T, R, C>
|
impl<T, R: DimName, C: DimName> AbstractMagma<Additive> for OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
T: Scalar + ClosedAdd,
|
T: Scalar + ClosedAdd,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn operate(&self, other: &Self) -> Self {
|
fn operate(&self, other: &Self) -> Self {
|
||||||
|
@ -49,7 +49,7 @@ where
|
||||||
impl<T, R: DimName, C: DimName> TwoSidedInverse<Additive> for OMatrix<T, R, C>
|
impl<T, R: DimName, C: DimName> TwoSidedInverse<Additive> for OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
T: Scalar + ClosedNeg,
|
T: Scalar + ClosedNeg,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
#[must_use = "Did you mean to use two_sided_inverse_mut()?"]
|
#[must_use = "Did you mean to use two_sided_inverse_mut()?"]
|
||||||
|
@ -67,7 +67,7 @@ macro_rules! inherit_additive_structure(
|
||||||
($($marker: ident<$operator: ident> $(+ $bounds: ident)*),* $(,)*) => {$(
|
($($marker: ident<$operator: ident> $(+ $bounds: ident)*),* $(,)*) => {$(
|
||||||
impl<T, R: DimName, C: DimName> $marker<$operator> for OMatrix<T, R, C>
|
impl<T, R: DimName, C: DimName> $marker<$operator> for OMatrix<T, R, C>
|
||||||
where T: Scalar + $marker<$operator> $(+ $bounds)*,
|
where T: Scalar + $marker<$operator> $(+ $bounds)*,
|
||||||
DefaultAllocator: Allocator<T, R, C> { }
|
DefaultAllocator: Allocator<R, C> { }
|
||||||
)*}
|
)*}
|
||||||
);
|
);
|
||||||
|
|
||||||
|
@ -83,7 +83,7 @@ inherit_additive_structure!(
|
||||||
impl<T, R: DimName, C: DimName> AbstractModule for OMatrix<T, R, C>
|
impl<T, R: DimName, C: DimName> AbstractModule for OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
T: Scalar + RingCommutative,
|
T: Scalar + RingCommutative,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
type AbstractRing = T;
|
type AbstractRing = T;
|
||||||
|
|
||||||
|
@ -96,7 +96,7 @@ where
|
||||||
impl<T, R: DimName, C: DimName> Module for OMatrix<T, R, C>
|
impl<T, R: DimName, C: DimName> Module for OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
T: Scalar + RingCommutative,
|
T: Scalar + RingCommutative,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
type Ring = T;
|
type Ring = T;
|
||||||
}
|
}
|
||||||
|
@ -104,7 +104,7 @@ where
|
||||||
impl<T, R: DimName, C: DimName> VectorSpace for OMatrix<T, R, C>
|
impl<T, R: DimName, C: DimName> VectorSpace for OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
T: Scalar + Field,
|
T: Scalar + Field,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
type Field = T;
|
type Field = T;
|
||||||
}
|
}
|
||||||
|
@ -112,7 +112,7 @@ where
|
||||||
impl<T, R: DimName, C: DimName> FiniteDimVectorSpace for OMatrix<T, R, C>
|
impl<T, R: DimName, C: DimName> FiniteDimVectorSpace for OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
T: Scalar + Field,
|
T: Scalar + Field,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn dimension() -> usize {
|
fn dimension() -> usize {
|
||||||
|
@ -154,7 +154,7 @@ impl<
|
||||||
> NormedSpace for OMatrix<T, R, C>
|
> NormedSpace for OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
<T as ComplexField>::RealField: simba::scalar::RealField,
|
<T as ComplexField>::RealField: simba::scalar::RealField,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
type RealField = <T as ComplexField>::RealField;
|
type RealField = <T as ComplexField>::RealField;
|
||||||
type ComplexField = T;
|
type ComplexField = T;
|
||||||
|
@ -202,7 +202,7 @@ impl<
|
||||||
> InnerSpace for OMatrix<T, R, C>
|
> InnerSpace for OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
<T as ComplexField>::RealField: simba::scalar::RealField,
|
<T as ComplexField>::RealField: simba::scalar::RealField,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn angle(&self, other: &Self) -> <T as ComplexField>::RealField {
|
fn angle(&self, other: &Self) -> <T as ComplexField>::RealField {
|
||||||
|
@ -226,7 +226,7 @@ impl<
|
||||||
> FiniteDimInnerSpace for OMatrix<T, R, C>
|
> FiniteDimInnerSpace for OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
<T as ComplexField>::RealField: simba::scalar::RealField,
|
<T as ComplexField>::RealField: simba::scalar::RealField,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn orthonormalize(vs: &mut [Self]) -> usize {
|
fn orthonormalize(vs: &mut [Self]) -> usize {
|
||||||
|
@ -362,7 +362,7 @@ where
|
||||||
impl<T, D: DimName> Identity<Multiplicative> for OMatrix<T, D, D>
|
impl<T, D: DimName> Identity<Multiplicative> for OMatrix<T, D, D>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + One,
|
T: Scalar + Zero + One,
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn identity() -> Self {
|
fn identity() -> Self {
|
||||||
|
@ -373,7 +373,7 @@ where
|
||||||
impl<T, D: DimName> AbstractMagma<Multiplicative> for OMatrix<T, D, D>
|
impl<T, D: DimName> AbstractMagma<Multiplicative> for OMatrix<T, D, D>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + One + ClosedAdd + ClosedMul,
|
T: Scalar + Zero + One + ClosedAdd + ClosedMul,
|
||||||
DefaultAllocator: Allocator<T, D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn operate(&self, other: &Self) -> Self {
|
fn operate(&self, other: &Self) -> Self {
|
||||||
|
@ -385,7 +385,7 @@ macro_rules! impl_multiplicative_structure(
|
||||||
($($marker: ident<$operator: ident> $(+ $bounds: ident)*),* $(,)*) => {$(
|
($($marker: ident<$operator: ident> $(+ $bounds: ident)*),* $(,)*) => {$(
|
||||||
impl<T, D: DimName> $marker<$operator> for OMatrix<T, D, D>
|
impl<T, D: DimName> $marker<$operator> for OMatrix<T, D, D>
|
||||||
where T: Scalar + Zero + One + ClosedAdd + ClosedMul + $marker<$operator> $(+ $bounds)*,
|
where T: Scalar + Zero + One + ClosedAdd + ClosedMul + $marker<$operator> $(+ $bounds)*,
|
||||||
DefaultAllocator: Allocator<T, D, D> { }
|
DefaultAllocator: Allocator<D, D> { }
|
||||||
)*}
|
)*}
|
||||||
);
|
);
|
||||||
|
|
||||||
|
@ -402,7 +402,7 @@ impl_multiplicative_structure!(
|
||||||
impl<T, R: Dim, C: Dim> MeetSemilattice for OMatrix<T, R, C>
|
impl<T, R: Dim, C: Dim> MeetSemilattice for OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
T: Scalar + MeetSemilattice,
|
T: Scalar + MeetSemilattice,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn meet(&self, other: &Self) -> Self {
|
fn meet(&self, other: &Self) -> Self {
|
||||||
|
@ -413,7 +413,7 @@ where
|
||||||
impl<T, R: Dim, C: Dim> JoinSemilattice for OMatrix<T, R, C>
|
impl<T, R: Dim, C: Dim> JoinSemilattice for OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
T: Scalar + JoinSemilattice,
|
T: Scalar + JoinSemilattice,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn join(&self, other: &Self) -> Self {
|
fn join(&self, other: &Self) -> Self {
|
||||||
|
@ -424,7 +424,7 @@ where
|
||||||
impl<T, R: Dim, C: Dim> Lattice for OMatrix<T, R, C>
|
impl<T, R: Dim, C: Dim> Lattice for OMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
T: Scalar + Lattice,
|
T: Scalar + Lattice,
|
||||||
DefaultAllocator: Allocator<T, R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn meet_join(&self, other: &Self) -> (Self, Self) {
|
fn meet_join(&self, other: &Self) -> (Self, Self) {
|
||||||
|
|
|
@ -20,7 +20,7 @@ impl<T: RealField + simba::scalar::RealField, C, const D: usize> Identity<Multip
|
||||||
where
|
where
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
C: TCategory,
|
C: TCategory,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn identity() -> Self {
|
fn identity() -> Self {
|
||||||
|
@ -33,7 +33,7 @@ impl<T: RealField + simba::scalar::RealField, C, const D: usize> TwoSidedInverse
|
||||||
where
|
where
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
C: SubTCategoryOf<TProjective>,
|
C: SubTCategoryOf<TProjective>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
#[must_use = "Did you mean to use two_sided_inverse_mut()?"]
|
#[must_use = "Did you mean to use two_sided_inverse_mut()?"]
|
||||||
|
@ -52,7 +52,7 @@ impl<T: RealField + simba::scalar::RealField, C, const D: usize> AbstractMagma<M
|
||||||
where
|
where
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
C: TCategory,
|
C: TCategory,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn operate(&self, rhs: &Self) -> Self {
|
fn operate(&self, rhs: &Self) -> Self {
|
||||||
|
@ -66,7 +66,7 @@ macro_rules! impl_multiplicative_structures(
|
||||||
where
|
where
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
C: TCategory,
|
C: TCategory,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> { }
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> { }
|
||||||
)*}
|
)*}
|
||||||
);
|
);
|
||||||
|
|
||||||
|
@ -76,7 +76,7 @@ macro_rules! impl_inversible_multiplicative_structures(
|
||||||
where
|
where
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
C: SubTCategoryOf<TProjective>,
|
C: SubTCategoryOf<TProjective>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> { }
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> { }
|
||||||
)*}
|
)*}
|
||||||
);
|
);
|
||||||
|
|
||||||
|
@ -101,8 +101,8 @@ where
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
T: RealField + simba::scalar::RealField,
|
T: RealField + simba::scalar::RealField,
|
||||||
C: TCategory,
|
C: TCategory,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
||||||
+ Allocator<T, DimNameSum<Const<D>, U1>>,
|
+ Allocator<DimNameSum<Const<D>, U1>>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
|
fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
|
||||||
|
@ -120,8 +120,8 @@ where
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
T: RealField + simba::scalar::RealField,
|
T: RealField + simba::scalar::RealField,
|
||||||
C: SubTCategoryOf<TProjective>,
|
C: SubTCategoryOf<TProjective>,
|
||||||
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
|
||||||
+ Allocator<T, DimNameSum<Const<D>, U1>>,
|
+ Allocator<DimNameSum<Const<D>, U1>>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
|
fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
|
||||||
|
@ -139,7 +139,7 @@ where
|
||||||
// impl<T, C, const D: usize> AffineTransformation<Point<T, D>> for Transform<T, C, D>
|
// impl<T, C, const D: usize> AffineTransformation<Point<T, D>> for Transform<T, C, D>
|
||||||
// where T: RealField,
|
// where T: RealField,
|
||||||
// C: SubTCategoryOf<TAffine>,
|
// C: SubTCategoryOf<TAffine>,
|
||||||
// DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> {
|
// DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> {
|
||||||
// type PreRotation = Rotation<T, D>;
|
// type PreRotation = Rotation<T, D>;
|
||||||
// type NonUniformScaling = OVector<T, D>;
|
// type NonUniformScaling = OVector<T, D>;
|
||||||
// type PostRotation = Rotation<T, D>;
|
// type PostRotation = Rotation<T, D>;
|
||||||
|
|
|
@ -11,7 +11,7 @@ macro_rules! impl_from_into_mint_1D(
|
||||||
($($NRows: ident => $VT:ident [$SZ: expr]);* $(;)*) => {$(
|
($($NRows: ident => $VT:ident [$SZ: expr]);* $(;)*) => {$(
|
||||||
impl<T> From<mint::$VT<T>> for OMatrix<T, $NRows, U1>
|
impl<T> From<mint::$VT<T>> for OMatrix<T, $NRows, U1>
|
||||||
where T: Scalar,
|
where T: Scalar,
|
||||||
DefaultAllocator: Allocator<T, $NRows, U1> {
|
DefaultAllocator: Allocator<$NRows, U1> {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn from(v: mint::$VT<T>) -> Self {
|
fn from(v: mint::$VT<T>) -> Self {
|
||||||
unsafe {
|
unsafe {
|
||||||
|
@ -81,7 +81,7 @@ macro_rules! impl_from_into_mint_2D(
|
||||||
($(($NRows: ty, $NCols: ty) => $MV:ident{ $($component:ident),* }[$SZRows: expr]);* $(;)*) => {$(
|
($(($NRows: ty, $NCols: ty) => $MV:ident{ $($component:ident),* }[$SZRows: expr]);* $(;)*) => {$(
|
||||||
impl<T> From<mint::$MV<T>> for OMatrix<T, $NRows, $NCols>
|
impl<T> From<mint::$MV<T>> for OMatrix<T, $NRows, $NCols>
|
||||||
where T: Scalar,
|
where T: Scalar,
|
||||||
DefaultAllocator: Allocator<T, $NRows, $NCols> {
|
DefaultAllocator: Allocator<$NRows, $NCols> {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn from(m: mint::$MV<T>) -> Self {
|
fn from(m: mint::$MV<T>) -> Self {
|
||||||
unsafe {
|
unsafe {
|
||||||
|
@ -101,7 +101,7 @@ macro_rules! impl_from_into_mint_2D(
|
||||||
|
|
||||||
impl<T> Into<mint::$MV<T>> for OMatrix<T, $NRows, $NCols>
|
impl<T> Into<mint::$MV<T>> for OMatrix<T, $NRows, $NCols>
|
||||||
where T: Scalar,
|
where T: Scalar,
|
||||||
DefaultAllocator: Allocator<T, $NRows, $NCols> {
|
DefaultAllocator: Allocator<$NRows, $NCols> {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn into(self) -> mint::$MV<T> {
|
fn into(self) -> mint::$MV<T> {
|
||||||
unsafe {
|
unsafe {
|
||||||
|
|
|
@ -1161,8 +1161,8 @@ fn generic_omatrix_to_string<D>(
|
||||||
) -> (String, String)
|
) -> (String, String)
|
||||||
where
|
where
|
||||||
D: nalgebra::Dim,
|
D: nalgebra::Dim,
|
||||||
nalgebra::DefaultAllocator: nalgebra::base::allocator::Allocator<f64, D>,
|
nalgebra::DefaultAllocator: nalgebra::base::allocator::Allocator<D>,
|
||||||
nalgebra::DefaultAllocator: nalgebra::base::allocator::Allocator<f64, D, D>,
|
nalgebra::DefaultAllocator: nalgebra::base::allocator::Allocator<D, D>,
|
||||||
{
|
{
|
||||||
(vector.to_string(), matrix.to_string())
|
(vector.to_string(), matrix.to_string())
|
||||||
}
|
}
|
||||||
|
|
|
@ -208,8 +208,8 @@ fn very_small_deviation_from_identity_issue_1368() {
|
||||||
// fn verify_eigenvectors<D: Dim>(m: OMatrix<f64, D>, mut eig: RealEigen<f64, D>) -> bool
|
// fn verify_eigenvectors<D: Dim>(m: OMatrix<f64, D>, mut eig: RealEigen<f64, D>) -> bool
|
||||||
// where DefaultAllocator: Allocator<f64, D, D> +
|
// where DefaultAllocator: Allocator<f64, D, D> +
|
||||||
// Allocator<f64, D> +
|
// Allocator<f64, D> +
|
||||||
// Allocator<usize, D, D> +
|
// Allocator<D, D> +
|
||||||
// Allocator<usize, D>,
|
// Allocator<D>,
|
||||||
// OMatrix<f64, D>: Display,
|
// OMatrix<f64, D>: Display,
|
||||||
// OVector<f64, D>: Display {
|
// OVector<f64, D>: Display {
|
||||||
// let mv = &m * &eig.eigenvectors;
|
// let mv = &m * &eig.eigenvectors;
|
||||||
|
|
|
@ -105,7 +105,7 @@ pub fn dmatrix_<ScalarStrategy>(
|
||||||
where
|
where
|
||||||
ScalarStrategy: Strategy + Clone + 'static,
|
ScalarStrategy: Strategy + Clone + 'static,
|
||||||
ScalarStrategy::Value: Scalar,
|
ScalarStrategy::Value: Scalar,
|
||||||
DefaultAllocator: Allocator<ScalarStrategy::Value, Dyn, Dyn>,
|
DefaultAllocator: Allocator<Dyn, Dyn>,
|
||||||
{
|
{
|
||||||
matrix(scalar_strategy, PROPTEST_MATRIX_DIM, PROPTEST_MATRIX_DIM)
|
matrix(scalar_strategy, PROPTEST_MATRIX_DIM, PROPTEST_MATRIX_DIM)
|
||||||
}
|
}
|
||||||
|
@ -114,7 +114,7 @@ where
|
||||||
// where
|
// where
|
||||||
// RangeInclusive<T>: Strategy<Value = T>,
|
// RangeInclusive<T>: Strategy<Value = T>,
|
||||||
// T: Scalar + PartialEq + Copy,
|
// T: Scalar + PartialEq + Copy,
|
||||||
// DefaultAllocator: Allocator<T, Dyn>,
|
// DefaultAllocator: Allocator<Dyn>,
|
||||||
// {
|
// {
|
||||||
// vector(range, PROPTEST_MATRIX_DIM)
|
// vector(range, PROPTEST_MATRIX_DIM)
|
||||||
// }
|
// }
|
||||||
|
|
Loading…
Reference in New Issue