chore: update to simba 0.9 (#1415)
This commit is contained in:
parent
f812694959
commit
292abfbaa0
84
Cargo.toml
84
Cargo.toml
|
@ -1,15 +1,15 @@
|
||||||
[package]
|
[package]
|
||||||
name = "nalgebra"
|
name = "nalgebra"
|
||||||
version = "0.32.3"
|
version = "0.32.3"
|
||||||
authors = [ "Sébastien Crozet <developer@crozet.re>" ]
|
authors = ["Sébastien Crozet <developer@crozet.re>"]
|
||||||
|
|
||||||
description = "General-purpose linear algebra library with transformations and statically-sized or dynamically-sized matrices."
|
description = "General-purpose linear algebra library with transformations and statically-sized or dynamically-sized matrices."
|
||||||
documentation = "https://www.nalgebra.org/docs"
|
documentation = "https://www.nalgebra.org/docs"
|
||||||
homepage = "https://nalgebra.org"
|
homepage = "https://nalgebra.org"
|
||||||
repository = "https://github.com/dimforge/nalgebra"
|
repository = "https://github.com/dimforge/nalgebra"
|
||||||
readme = "README.md"
|
readme = "README.md"
|
||||||
categories = [ "science", "mathematics", "wasm", "no-std" ]
|
categories = ["science", "mathematics", "wasm", "no-std"]
|
||||||
keywords = [ "linear", "algebra", "matrix", "vector", "math" ]
|
keywords = ["linear", "algebra", "matrix", "vector", "math"]
|
||||||
license = "Apache-2.0"
|
license = "Apache-2.0"
|
||||||
edition = "2018"
|
edition = "2018"
|
||||||
exclude = ["/ci/*", "/.travis.yml", "/Makefile"]
|
exclude = ["/ci/*", "/.travis.yml", "/Makefile"]
|
||||||
|
@ -22,57 +22,57 @@ name = "nalgebra"
|
||||||
path = "src/lib.rs"
|
path = "src/lib.rs"
|
||||||
|
|
||||||
[features]
|
[features]
|
||||||
default = [ "std", "macros" ]
|
default = ["std", "macros"]
|
||||||
std = [ "matrixmultiply", "num-traits/std", "num-complex/std", "num-rational/std", "approx/std", "simba/std" ]
|
std = ["matrixmultiply", "num-traits/std", "num-complex/std", "num-rational/std", "approx/std", "simba/std"]
|
||||||
sparse = [ ]
|
sparse = []
|
||||||
debug = [ "approx/num-complex", "rand" ]
|
debug = ["approx/num-complex", "rand"]
|
||||||
alloc = [ ]
|
alloc = []
|
||||||
io = [ "pest", "pest_derive" ]
|
io = ["pest", "pest_derive"]
|
||||||
compare = [ "matrixcompare-core" ]
|
compare = ["matrixcompare-core"]
|
||||||
libm = [ "simba/libm" ]
|
libm = ["simba/libm"]
|
||||||
libm-force = [ "simba/libm_force" ]
|
libm-force = ["simba/libm_force"]
|
||||||
macros = [ "nalgebra-macros" ]
|
macros = ["nalgebra-macros"]
|
||||||
|
|
||||||
|
|
||||||
# Conversion
|
# Conversion
|
||||||
convert-mint = [ "mint" ]
|
convert-mint = ["mint"]
|
||||||
convert-bytemuck = [ "bytemuck" ]
|
convert-bytemuck = ["bytemuck"]
|
||||||
convert-glam014 = [ "glam014" ]
|
convert-glam014 = ["glam014"]
|
||||||
convert-glam015 = [ "glam015" ]
|
convert-glam015 = ["glam015"]
|
||||||
convert-glam016 = [ "glam016" ]
|
convert-glam016 = ["glam016"]
|
||||||
convert-glam017 = [ "glam017" ]
|
convert-glam017 = ["glam017"]
|
||||||
convert-glam018 = [ "glam018" ]
|
convert-glam018 = ["glam018"]
|
||||||
convert-glam019 = [ "glam019" ]
|
convert-glam019 = ["glam019"]
|
||||||
convert-glam020 = [ "glam020" ]
|
convert-glam020 = ["glam020"]
|
||||||
convert-glam021 = [ "glam021" ]
|
convert-glam021 = ["glam021"]
|
||||||
convert-glam022 = [ "glam022" ]
|
convert-glam022 = ["glam022"]
|
||||||
convert-glam023 = [ "glam023" ]
|
convert-glam023 = ["glam023"]
|
||||||
convert-glam024 = [ "glam024" ]
|
convert-glam024 = ["glam024"]
|
||||||
convert-glam025 = [ "glam025" ]
|
convert-glam025 = ["glam025"]
|
||||||
convert-glam027 = [ "glam027" ]
|
convert-glam027 = ["glam027"]
|
||||||
convert-glam028 = [ "glam028" ]
|
convert-glam028 = ["glam028"]
|
||||||
|
|
||||||
# Serialization
|
# Serialization
|
||||||
## To use serde in a #[no-std] environment, enable the
|
## To use serde in a #[no-std] environment, enable the
|
||||||
## `serde-serialize-no-std` feature instead of `serde-serialize`.
|
## `serde-serialize-no-std` feature instead of `serde-serialize`.
|
||||||
## Serialization of dynamically-sized matrices/vectors require
|
## Serialization of dynamically-sized matrices/vectors require
|
||||||
## `serde-serialize`.
|
## `serde-serialize`.
|
||||||
serde-serialize-no-std = [ "serde", "num-complex/serde" ]
|
serde-serialize-no-std = ["serde", "num-complex/serde"]
|
||||||
serde-serialize = [ "serde-serialize-no-std", "serde/std" ]
|
serde-serialize = ["serde-serialize-no-std", "serde/std"]
|
||||||
rkyv-serialize-no-std = [ "rkyv/size_32" ]
|
rkyv-serialize-no-std = ["rkyv/size_32"]
|
||||||
rkyv-serialize = [ "rkyv-serialize-no-std", "rkyv/std", "rkyv/validation" ]
|
rkyv-serialize = ["rkyv-serialize-no-std", "rkyv/std", "rkyv/validation"]
|
||||||
|
|
||||||
# Randomness
|
# Randomness
|
||||||
## To use rand in a #[no-std] environment, enable the
|
## To use rand in a #[no-std] environment, enable the
|
||||||
## `rand-no-std` feature instead of `rand`.
|
## `rand-no-std` feature instead of `rand`.
|
||||||
rand-no-std = [ "rand-package" ]
|
rand-no-std = ["rand-package"]
|
||||||
rand = [ "rand-no-std", "rand-package/std", "rand-package/std_rng", "rand_distr" ]
|
rand = ["rand-no-std", "rand-package/std", "rand-package/std_rng", "rand_distr"]
|
||||||
|
|
||||||
# Tests
|
# Tests
|
||||||
arbitrary = [ "quickcheck" ]
|
arbitrary = ["quickcheck"]
|
||||||
proptest-support = [ "proptest" ]
|
proptest-support = ["proptest"]
|
||||||
slow-tests = []
|
slow-tests = []
|
||||||
rkyv-safe-deser = [ "rkyv-serialize", "rkyv/validation" ]
|
rkyv-safe-deser = ["rkyv-serialize", "rkyv/validation"]
|
||||||
|
|
||||||
[dependencies]
|
[dependencies]
|
||||||
nalgebra-macros = { version = "0.2.1", path = "nalgebra-macros", optional = true }
|
nalgebra-macros = { version = "0.2.1", path = "nalgebra-macros", optional = true }
|
||||||
|
@ -82,11 +82,11 @@ num-traits = { version = "0.2", default-features = false }
|
||||||
num-complex = { version = "0.4", default-features = false }
|
num-complex = { version = "0.4", default-features = false }
|
||||||
num-rational = { version = "0.4", default-features = false }
|
num-rational = { version = "0.4", default-features = false }
|
||||||
approx = { version = "0.5", default-features = false }
|
approx = { version = "0.5", default-features = false }
|
||||||
simba = { version = "0.8", default-features = false }
|
simba = { version = "0.9", default-features = false }
|
||||||
alga = { version = "0.9", default-features = false, optional = true }
|
alga = { version = "0.9", default-features = false, optional = true }
|
||||||
rand_distr = { version = "0.4", default-features = false, optional = true }
|
rand_distr = { version = "0.4", default-features = false, optional = true }
|
||||||
matrixmultiply = { version = "0.3", optional = true }
|
matrixmultiply = { version = "0.3", optional = true }
|
||||||
serde = { version = "1.0", default-features = false, features = [ "derive" ], optional = true }
|
serde = { version = "1.0", default-features = false, features = ["derive"], optional = true }
|
||||||
rkyv = { version = "0.7.41", default-features = false, optional = true }
|
rkyv = { version = "0.7.41", default-features = false, optional = true }
|
||||||
mint = { version = "0.5", optional = true }
|
mint = { version = "0.5", optional = true }
|
||||||
quickcheck = { version = "1", optional = true }
|
quickcheck = { version = "1", optional = true }
|
||||||
|
@ -116,14 +116,14 @@ serde_json = "1.0"
|
||||||
rand_xorshift = "0.3"
|
rand_xorshift = "0.3"
|
||||||
rand_isaac = "0.3"
|
rand_isaac = "0.3"
|
||||||
criterion = { version = "0.4", features = ["html_reports"] }
|
criterion = { version = "0.4", features = ["html_reports"] }
|
||||||
nalgebra = { path = ".", features = ["debug", "compare", "rand", "macros"]}
|
nalgebra = { path = ".", features = ["debug", "compare", "rand", "macros"] }
|
||||||
|
|
||||||
# For matrix comparison macro
|
# For matrix comparison macro
|
||||||
matrixcompare = "0.3.0"
|
matrixcompare = "0.3.0"
|
||||||
itertools = "0.13"
|
itertools = "0.13"
|
||||||
|
|
||||||
[workspace]
|
[workspace]
|
||||||
members = [ "nalgebra-lapack", "nalgebra-glm", "nalgebra-sparse", "nalgebra-macros" ]
|
members = ["nalgebra-lapack", "nalgebra-glm", "nalgebra-sparse", "nalgebra-macros"]
|
||||||
resolver = "2"
|
resolver = "2"
|
||||||
|
|
||||||
[[example]]
|
[[example]]
|
||||||
|
|
|
@ -8,8 +8,8 @@ documentation = "https://www.nalgebra.org/docs"
|
||||||
homepage = "https://nalgebra.org"
|
homepage = "https://nalgebra.org"
|
||||||
repository = "https://github.com/dimforge/nalgebra"
|
repository = "https://github.com/dimforge/nalgebra"
|
||||||
readme = "../README.md"
|
readme = "../README.md"
|
||||||
categories = [ "science", "mathematics", "wasm", "no standard library" ]
|
categories = ["science", "mathematics", "wasm", "no standard library"]
|
||||||
keywords = [ "linear", "algebra", "matrix", "vector", "math" ]
|
keywords = ["linear", "algebra", "matrix", "vector", "math"]
|
||||||
license = "Apache-2.0"
|
license = "Apache-2.0"
|
||||||
edition = "2018"
|
edition = "2018"
|
||||||
|
|
||||||
|
@ -17,22 +17,22 @@ edition = "2018"
|
||||||
maintenance = { status = "actively-developed" }
|
maintenance = { status = "actively-developed" }
|
||||||
|
|
||||||
[features]
|
[features]
|
||||||
default = [ "std" ]
|
default = ["std"]
|
||||||
std = [ "nalgebra/std", "simba/std" ]
|
std = ["nalgebra/std", "simba/std"]
|
||||||
arbitrary = [ "nalgebra/arbitrary" ]
|
arbitrary = ["nalgebra/arbitrary"]
|
||||||
serde-serialize = [ "nalgebra/serde-serialize-no-std" ]
|
serde-serialize = ["nalgebra/serde-serialize-no-std"]
|
||||||
|
|
||||||
# Conversion
|
# Conversion
|
||||||
convert-mint = [ "nalgebra/mint" ]
|
convert-mint = ["nalgebra/mint"]
|
||||||
convert-bytemuck = [ "nalgebra/bytemuck" ]
|
convert-bytemuck = ["nalgebra/bytemuck"]
|
||||||
convert-glam014 = [ "nalgebra/glam014" ]
|
convert-glam014 = ["nalgebra/glam014"]
|
||||||
convert-glam015 = [ "nalgebra/glam015" ]
|
convert-glam015 = ["nalgebra/glam015"]
|
||||||
convert-glam016 = [ "nalgebra/glam016" ]
|
convert-glam016 = ["nalgebra/glam016"]
|
||||||
convert-glam017 = [ "nalgebra/glam017" ]
|
convert-glam017 = ["nalgebra/glam017"]
|
||||||
convert-glam018 = [ "nalgebra/glam018" ]
|
convert-glam018 = ["nalgebra/glam018"]
|
||||||
|
|
||||||
[dependencies]
|
[dependencies]
|
||||||
num-traits = { version = "0.2", default-features = false }
|
num-traits = { version = "0.2", default-features = false }
|
||||||
approx = { version = "0.5", default-features = false }
|
approx = { version = "0.5", default-features = false }
|
||||||
simba = { version = "0.8", default-features = false }
|
simba = { version = "0.9", default-features = false }
|
||||||
nalgebra = { path = "..", version = "0.32", default-features = false }
|
nalgebra = { path = "..", version = "0.32", default-features = false }
|
||||||
|
|
|
@ -2,16 +2,16 @@ use approx::AbsDiffEq;
|
||||||
use num::{Bounded, Signed};
|
use num::{Bounded, Signed};
|
||||||
|
|
||||||
use na::Scalar;
|
use na::Scalar;
|
||||||
use simba::scalar::{ClosedAdd, ClosedMul, ClosedSub, RealField};
|
use simba::scalar::{ClosedAddAssign, ClosedMulAssign, ClosedSubAssign, RealField};
|
||||||
|
|
||||||
/// A number that can either be an integer or a float.
|
/// A number that can either be an integer or a float.
|
||||||
pub trait Number:
|
pub trait Number:
|
||||||
Scalar
|
Scalar
|
||||||
+ Copy
|
+ Copy
|
||||||
+ PartialOrd
|
+ PartialOrd
|
||||||
+ ClosedAdd
|
+ ClosedAddAssign
|
||||||
+ ClosedSub
|
+ ClosedSubAssign
|
||||||
+ ClosedMul
|
+ ClosedMulAssign
|
||||||
+ AbsDiffEq<Epsilon = Self>
|
+ AbsDiffEq<Epsilon = Self>
|
||||||
+ Signed
|
+ Signed
|
||||||
+ Bounded
|
+ Bounded
|
||||||
|
@ -22,9 +22,9 @@ impl<
|
||||||
T: Scalar
|
T: Scalar
|
||||||
+ Copy
|
+ Copy
|
||||||
+ PartialOrd
|
+ PartialOrd
|
||||||
+ ClosedAdd
|
+ ClosedAddAssign
|
||||||
+ ClosedSub
|
+ ClosedSubAssign
|
||||||
+ ClosedMul
|
+ ClosedMulAssign
|
||||||
+ AbsDiffEq<Epsilon = Self>
|
+ AbsDiffEq<Epsilon = Self>
|
||||||
+ Signed
|
+ Signed
|
||||||
+ Bounded,
|
+ Bounded,
|
||||||
|
|
|
@ -32,7 +32,7 @@ intel-mkl = ["lapack-src/intel-mkl"]
|
||||||
nalgebra = { version = "0.32", path = ".." }
|
nalgebra = { version = "0.32", path = ".." }
|
||||||
num-traits = "0.2"
|
num-traits = "0.2"
|
||||||
num-complex = { version = "0.4", default-features = false }
|
num-complex = { version = "0.4", default-features = false }
|
||||||
simba = "0.8"
|
simba = "0.9"
|
||||||
serde = { version = "1.0", features = ["derive"], optional = true }
|
serde = { version = "1.0", features = ["derive"], optional = true }
|
||||||
lapack = { version = "0.19", default-features = false }
|
lapack = { version = "0.19", default-features = false }
|
||||||
lapack-src = { version = "0.8", default-features = false }
|
lapack-src = { version = "0.8", default-features = false }
|
||||||
|
|
|
@ -3,7 +3,7 @@ use crate::coo::CooMatrix;
|
||||||
use crate::csc::CscMatrix;
|
use crate::csc::CscMatrix;
|
||||||
use crate::csr::CsrMatrix;
|
use crate::csr::CsrMatrix;
|
||||||
use nalgebra::storage::RawStorage;
|
use nalgebra::storage::RawStorage;
|
||||||
use nalgebra::{ClosedAdd, DMatrix, Dim, Matrix, Scalar};
|
use nalgebra::{ClosedAddAssign, DMatrix, Dim, Matrix, Scalar};
|
||||||
use num_traits::Zero;
|
use num_traits::Zero;
|
||||||
|
|
||||||
impl<'a, T, R, C, S> From<&'a Matrix<T, R, C, S>> for CooMatrix<T>
|
impl<'a, T, R, C, S> From<&'a Matrix<T, R, C, S>> for CooMatrix<T>
|
||||||
|
@ -20,7 +20,7 @@ where
|
||||||
|
|
||||||
impl<'a, T> From<&'a CooMatrix<T>> for DMatrix<T>
|
impl<'a, T> From<&'a CooMatrix<T>> for DMatrix<T>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + ClosedAdd,
|
T: Scalar + Zero + ClosedAddAssign,
|
||||||
{
|
{
|
||||||
fn from(coo: &'a CooMatrix<T>) -> Self {
|
fn from(coo: &'a CooMatrix<T>) -> Self {
|
||||||
convert_coo_dense(coo)
|
convert_coo_dense(coo)
|
||||||
|
@ -29,7 +29,7 @@ where
|
||||||
|
|
||||||
impl<'a, T> From<&'a CooMatrix<T>> for CsrMatrix<T>
|
impl<'a, T> From<&'a CooMatrix<T>> for CsrMatrix<T>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + ClosedAdd,
|
T: Scalar + Zero + ClosedAddAssign,
|
||||||
{
|
{
|
||||||
fn from(matrix: &'a CooMatrix<T>) -> Self {
|
fn from(matrix: &'a CooMatrix<T>) -> Self {
|
||||||
convert_coo_csr(matrix)
|
convert_coo_csr(matrix)
|
||||||
|
@ -38,7 +38,7 @@ where
|
||||||
|
|
||||||
impl<'a, T> From<&'a CsrMatrix<T>> for CooMatrix<T>
|
impl<'a, T> From<&'a CsrMatrix<T>> for CooMatrix<T>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + ClosedAdd,
|
T: Scalar + Zero + ClosedAddAssign,
|
||||||
{
|
{
|
||||||
fn from(matrix: &'a CsrMatrix<T>) -> Self {
|
fn from(matrix: &'a CsrMatrix<T>) -> Self {
|
||||||
convert_csr_coo(matrix)
|
convert_csr_coo(matrix)
|
||||||
|
@ -59,7 +59,7 @@ where
|
||||||
|
|
||||||
impl<'a, T> From<&'a CsrMatrix<T>> for DMatrix<T>
|
impl<'a, T> From<&'a CsrMatrix<T>> for DMatrix<T>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + ClosedAdd,
|
T: Scalar + Zero + ClosedAddAssign,
|
||||||
{
|
{
|
||||||
fn from(matrix: &'a CsrMatrix<T>) -> Self {
|
fn from(matrix: &'a CsrMatrix<T>) -> Self {
|
||||||
convert_csr_dense(matrix)
|
convert_csr_dense(matrix)
|
||||||
|
@ -68,7 +68,7 @@ where
|
||||||
|
|
||||||
impl<'a, T> From<&'a CooMatrix<T>> for CscMatrix<T>
|
impl<'a, T> From<&'a CooMatrix<T>> for CscMatrix<T>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + ClosedAdd,
|
T: Scalar + Zero + ClosedAddAssign,
|
||||||
{
|
{
|
||||||
fn from(matrix: &'a CooMatrix<T>) -> Self {
|
fn from(matrix: &'a CooMatrix<T>) -> Self {
|
||||||
convert_coo_csc(matrix)
|
convert_coo_csc(matrix)
|
||||||
|
@ -98,7 +98,7 @@ where
|
||||||
|
|
||||||
impl<'a, T> From<&'a CscMatrix<T>> for DMatrix<T>
|
impl<'a, T> From<&'a CscMatrix<T>> for DMatrix<T>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + ClosedAdd,
|
T: Scalar + Zero + ClosedAddAssign,
|
||||||
{
|
{
|
||||||
fn from(matrix: &'a CscMatrix<T>) -> Self {
|
fn from(matrix: &'a CscMatrix<T>) -> Self {
|
||||||
convert_csc_dense(matrix)
|
convert_csc_dense(matrix)
|
||||||
|
|
|
@ -8,7 +8,7 @@ use std::ops::Add;
|
||||||
use num_traits::Zero;
|
use num_traits::Zero;
|
||||||
|
|
||||||
use nalgebra::storage::RawStorage;
|
use nalgebra::storage::RawStorage;
|
||||||
use nalgebra::{ClosedAdd, DMatrix, Dim, Matrix, Scalar};
|
use nalgebra::{ClosedAddAssign, DMatrix, Dim, Matrix, Scalar};
|
||||||
|
|
||||||
use crate::coo::CooMatrix;
|
use crate::coo::CooMatrix;
|
||||||
use crate::cs;
|
use crate::cs;
|
||||||
|
@ -41,7 +41,7 @@ where
|
||||||
/// Converts a [`CooMatrix`] to a dense matrix.
|
/// Converts a [`CooMatrix`] to a dense matrix.
|
||||||
pub fn convert_coo_dense<T>(coo: &CooMatrix<T>) -> DMatrix<T>
|
pub fn convert_coo_dense<T>(coo: &CooMatrix<T>) -> DMatrix<T>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + ClosedAdd,
|
T: Scalar + Zero + ClosedAddAssign,
|
||||||
{
|
{
|
||||||
let mut output = DMatrix::repeat(coo.nrows(), coo.ncols(), T::zero());
|
let mut output = DMatrix::repeat(coo.nrows(), coo.ncols(), T::zero());
|
||||||
for (i, j, v) in coo.triplet_iter() {
|
for (i, j, v) in coo.triplet_iter() {
|
||||||
|
@ -80,7 +80,7 @@ pub fn convert_csr_coo<T: Scalar>(csr: &CsrMatrix<T>) -> CooMatrix<T> {
|
||||||
/// Converts a [`CsrMatrix`] to a dense matrix.
|
/// Converts a [`CsrMatrix`] to a dense matrix.
|
||||||
pub fn convert_csr_dense<T>(csr: &CsrMatrix<T>) -> DMatrix<T>
|
pub fn convert_csr_dense<T>(csr: &CsrMatrix<T>) -> DMatrix<T>
|
||||||
where
|
where
|
||||||
T: Scalar + ClosedAdd + Zero,
|
T: Scalar + ClosedAddAssign + Zero,
|
||||||
{
|
{
|
||||||
let mut output = DMatrix::zeros(csr.nrows(), csr.ncols());
|
let mut output = DMatrix::zeros(csr.nrows(), csr.ncols());
|
||||||
|
|
||||||
|
@ -157,7 +157,7 @@ where
|
||||||
/// Converts a [`CscMatrix`] to a dense matrix.
|
/// Converts a [`CscMatrix`] to a dense matrix.
|
||||||
pub fn convert_csc_dense<T>(csc: &CscMatrix<T>) -> DMatrix<T>
|
pub fn convert_csc_dense<T>(csc: &CscMatrix<T>) -> DMatrix<T>
|
||||||
where
|
where
|
||||||
T: Scalar + ClosedAdd + Zero,
|
T: Scalar + ClosedAddAssign + Zero,
|
||||||
{
|
{
|
||||||
let mut output = DMatrix::zeros(csc.nrows(), csc.ncols());
|
let mut output = DMatrix::zeros(csc.nrows(), csc.ncols());
|
||||||
|
|
||||||
|
|
|
@ -10,8 +10,8 @@ use nalgebra::allocator::Allocator;
|
||||||
use nalgebra::base::storage::RawStorage;
|
use nalgebra::base::storage::RawStorage;
|
||||||
use nalgebra::constraint::{DimEq, ShapeConstraint};
|
use nalgebra::constraint::{DimEq, ShapeConstraint};
|
||||||
use nalgebra::{
|
use nalgebra::{
|
||||||
ClosedAdd, ClosedDiv, ClosedMul, ClosedSub, DefaultAllocator, Dim, Dyn, Matrix, OMatrix,
|
ClosedAddAssign, ClosedDivAssign, ClosedMulAssign, ClosedSubAssign, DefaultAllocator, Dim, Dyn,
|
||||||
Scalar, U1,
|
Matrix, OMatrix, Scalar, U1,
|
||||||
};
|
};
|
||||||
use num_traits::{One, Zero};
|
use num_traits::{One, Zero};
|
||||||
use std::ops::{Add, Div, DivAssign, Mul, MulAssign, Neg, Sub};
|
use std::ops::{Add, Div, DivAssign, Mul, MulAssign, Neg, Sub};
|
||||||
|
@ -28,7 +28,7 @@ macro_rules! impl_bin_op {
|
||||||
// Note: The Neg bound is currently required because we delegate e.g.
|
// Note: The Neg bound is currently required because we delegate e.g.
|
||||||
// Sub to SpAdd with negative coefficients. This is not well-defined for
|
// Sub to SpAdd with negative coefficients. This is not well-defined for
|
||||||
// unsigned data types.
|
// unsigned data types.
|
||||||
$($scalar_type: $($bounds + )? Scalar + ClosedAdd + ClosedSub + ClosedMul + Zero + One + Neg<Output=T>)?
|
$($scalar_type: $($bounds + )? Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output=T>)?
|
||||||
{
|
{
|
||||||
type Output = $ret;
|
type Output = $ret;
|
||||||
fn $method(self, $b: $b_type) -> Self::Output {
|
fn $method(self, $b: $b_type) -> Self::Output {
|
||||||
|
@ -164,7 +164,7 @@ macro_rules! impl_scalar_mul {
|
||||||
|
|
||||||
impl<T> MulAssign<T> for $matrix_type<T>
|
impl<T> MulAssign<T> for $matrix_type<T>
|
||||||
where
|
where
|
||||||
T: Scalar + ClosedAdd + ClosedMul + Zero + One
|
T: Scalar + ClosedAddAssign + ClosedMulAssign + Zero + One
|
||||||
{
|
{
|
||||||
fn mul_assign(&mut self, scalar: T) {
|
fn mul_assign(&mut self, scalar: T) {
|
||||||
for val in self.values_mut() {
|
for val in self.values_mut() {
|
||||||
|
@ -175,7 +175,7 @@ macro_rules! impl_scalar_mul {
|
||||||
|
|
||||||
impl<'a, T> MulAssign<&'a T> for $matrix_type<T>
|
impl<'a, T> MulAssign<&'a T> for $matrix_type<T>
|
||||||
where
|
where
|
||||||
T: Scalar + ClosedAdd + ClosedMul + Zero + One
|
T: Scalar + ClosedAddAssign + ClosedMulAssign + Zero + One
|
||||||
{
|
{
|
||||||
fn mul_assign(&mut self, scalar: &'a T) {
|
fn mul_assign(&mut self, scalar: &'a T) {
|
||||||
for val in self.values_mut() {
|
for val in self.values_mut() {
|
||||||
|
@ -227,15 +227,15 @@ impl_neg!(CscMatrix);
|
||||||
|
|
||||||
macro_rules! impl_div {
|
macro_rules! impl_div {
|
||||||
($matrix_type:ident) => {
|
($matrix_type:ident) => {
|
||||||
impl_bin_op!(Div, div, <T: ClosedDiv>(matrix: $matrix_type<T>, scalar: T) -> $matrix_type<T> {
|
impl_bin_op!(Div, div, <T: ClosedDivAssign>(matrix: $matrix_type<T>, scalar: T) -> $matrix_type<T> {
|
||||||
let mut matrix = matrix;
|
let mut matrix = matrix;
|
||||||
matrix /= scalar;
|
matrix /= scalar;
|
||||||
matrix
|
matrix
|
||||||
});
|
});
|
||||||
impl_bin_op!(Div, div, <'a, T: ClosedDiv>(matrix: $matrix_type<T>, scalar: &T) -> $matrix_type<T> {
|
impl_bin_op!(Div, div, <'a, T: ClosedDivAssign>(matrix: $matrix_type<T>, scalar: &T) -> $matrix_type<T> {
|
||||||
matrix / scalar.clone()
|
matrix / scalar.clone()
|
||||||
});
|
});
|
||||||
impl_bin_op!(Div, div, <'a, T: ClosedDiv>(matrix: &'a $matrix_type<T>, scalar: T) -> $matrix_type<T> {
|
impl_bin_op!(Div, div, <'a, T: ClosedDivAssign>(matrix: &'a $matrix_type<T>, scalar: T) -> $matrix_type<T> {
|
||||||
let new_values = matrix.values()
|
let new_values = matrix.values()
|
||||||
.iter()
|
.iter()
|
||||||
.map(|v_i| v_i.clone() / scalar.clone())
|
.map(|v_i| v_i.clone() / scalar.clone())
|
||||||
|
@ -243,12 +243,12 @@ macro_rules! impl_div {
|
||||||
$matrix_type::try_from_pattern_and_values(matrix.pattern().clone(), new_values)
|
$matrix_type::try_from_pattern_and_values(matrix.pattern().clone(), new_values)
|
||||||
.unwrap()
|
.unwrap()
|
||||||
});
|
});
|
||||||
impl_bin_op!(Div, div, <'a, T: ClosedDiv>(matrix: &'a $matrix_type<T>, scalar: &'a T) -> $matrix_type<T> {
|
impl_bin_op!(Div, div, <'a, T: ClosedDivAssign>(matrix: &'a $matrix_type<T>, scalar: &'a T) -> $matrix_type<T> {
|
||||||
matrix / scalar.clone()
|
matrix / scalar.clone()
|
||||||
});
|
});
|
||||||
|
|
||||||
impl<T> DivAssign<T> for $matrix_type<T>
|
impl<T> DivAssign<T> for $matrix_type<T>
|
||||||
where T : Scalar + ClosedAdd + ClosedMul + ClosedDiv + Zero + One
|
where T : Scalar + ClosedAddAssign + ClosedMulAssign + ClosedDivAssign + Zero + One
|
||||||
{
|
{
|
||||||
fn div_assign(&mut self, scalar: T) {
|
fn div_assign(&mut self, scalar: T) {
|
||||||
self.values_mut().iter_mut().for_each(|v_i| *v_i /= scalar.clone());
|
self.values_mut().iter_mut().for_each(|v_i| *v_i /= scalar.clone());
|
||||||
|
@ -256,7 +256,7 @@ macro_rules! impl_div {
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, T> DivAssign<&'a T> for $matrix_type<T>
|
impl<'a, T> DivAssign<&'a T> for $matrix_type<T>
|
||||||
where T : Scalar + ClosedAdd + ClosedMul + ClosedDiv + Zero + One
|
where T : Scalar + ClosedAddAssign + ClosedMulAssign + ClosedDivAssign + Zero + One
|
||||||
{
|
{
|
||||||
fn div_assign(&mut self, scalar: &'a T) {
|
fn div_assign(&mut self, scalar: &'a T) {
|
||||||
*self /= scalar.clone();
|
*self /= scalar.clone();
|
||||||
|
@ -298,7 +298,7 @@ macro_rules! impl_spmm_cs_dense {
|
||||||
{
|
{
|
||||||
impl<'a, T, R, C, S> Mul<$dense_matrix_type> for $sparse_matrix_type
|
impl<'a, T, R, C, S> Mul<$dense_matrix_type> for $sparse_matrix_type
|
||||||
where
|
where
|
||||||
T: Scalar + ClosedMul + ClosedAdd + ClosedSub + ClosedDiv + Neg + Zero + One,
|
T: Scalar + ClosedMulAssign + ClosedAddAssign + ClosedSubAssign + ClosedDivAssign + Neg + Zero + One,
|
||||||
R: Dim,
|
R: Dim,
|
||||||
C: Dim,
|
C: Dim,
|
||||||
S: RawStorage<T, R, C>,
|
S: RawStorage<T, R, C>,
|
||||||
|
|
|
@ -2,7 +2,7 @@ use crate::cs::CsMatrix;
|
||||||
use crate::ops::serial::{OperationError, OperationErrorKind};
|
use crate::ops::serial::{OperationError, OperationErrorKind};
|
||||||
use crate::ops::Op;
|
use crate::ops::Op;
|
||||||
use crate::SparseEntryMut;
|
use crate::SparseEntryMut;
|
||||||
use nalgebra::{ClosedAdd, ClosedMul, DMatrixView, DMatrixViewMut, Scalar};
|
use nalgebra::{ClosedAddAssign, ClosedMulAssign, DMatrixView, DMatrixViewMut, Scalar};
|
||||||
use num_traits::{One, Zero};
|
use num_traits::{One, Zero};
|
||||||
|
|
||||||
fn spmm_cs_unexpected_entry() -> OperationError {
|
fn spmm_cs_unexpected_entry() -> OperationError {
|
||||||
|
@ -28,7 +28,7 @@ pub fn spmm_cs_prealloc_unchecked<T>(
|
||||||
b: &CsMatrix<T>,
|
b: &CsMatrix<T>,
|
||||||
) -> Result<(), OperationError>
|
) -> Result<(), OperationError>
|
||||||
where
|
where
|
||||||
T: Scalar + ClosedAdd + ClosedMul + Zero + One,
|
T: Scalar + ClosedAddAssign + ClosedMulAssign + Zero + One,
|
||||||
{
|
{
|
||||||
assert_eq!(c.pattern().major_dim(), a.pattern().major_dim());
|
assert_eq!(c.pattern().major_dim(), a.pattern().major_dim());
|
||||||
assert_eq!(c.pattern().minor_dim(), b.pattern().minor_dim());
|
assert_eq!(c.pattern().minor_dim(), b.pattern().minor_dim());
|
||||||
|
@ -73,7 +73,7 @@ pub fn spmm_cs_prealloc<T>(
|
||||||
b: &CsMatrix<T>,
|
b: &CsMatrix<T>,
|
||||||
) -> Result<(), OperationError>
|
) -> Result<(), OperationError>
|
||||||
where
|
where
|
||||||
T: Scalar + ClosedAdd + ClosedMul + Zero + One,
|
T: Scalar + ClosedAddAssign + ClosedMulAssign + Zero + One,
|
||||||
{
|
{
|
||||||
for i in 0..c.pattern().major_dim() {
|
for i in 0..c.pattern().major_dim() {
|
||||||
let a_lane_i = a.get_lane(i).unwrap();
|
let a_lane_i = a.get_lane(i).unwrap();
|
||||||
|
@ -119,7 +119,7 @@ pub fn spadd_cs_prealloc<T>(
|
||||||
a: Op<&CsMatrix<T>>,
|
a: Op<&CsMatrix<T>>,
|
||||||
) -> Result<(), OperationError>
|
) -> Result<(), OperationError>
|
||||||
where
|
where
|
||||||
T: Scalar + ClosedAdd + ClosedMul + Zero + One,
|
T: Scalar + ClosedAddAssign + ClosedMulAssign + Zero + One,
|
||||||
{
|
{
|
||||||
match a {
|
match a {
|
||||||
Op::NoOp(a) => {
|
Op::NoOp(a) => {
|
||||||
|
@ -181,7 +181,7 @@ pub fn spmm_cs_dense<T>(
|
||||||
a: Op<&CsMatrix<T>>,
|
a: Op<&CsMatrix<T>>,
|
||||||
b: Op<DMatrixView<'_, T>>,
|
b: Op<DMatrixView<'_, T>>,
|
||||||
) where
|
) where
|
||||||
T: Scalar + ClosedAdd + ClosedMul + Zero + One,
|
T: Scalar + ClosedAddAssign + ClosedMulAssign + Zero + One,
|
||||||
{
|
{
|
||||||
match a {
|
match a {
|
||||||
Op::NoOp(a) => {
|
Op::NoOp(a) => {
|
||||||
|
|
|
@ -4,7 +4,7 @@ use crate::ops::serial::cs::{
|
||||||
};
|
};
|
||||||
use crate::ops::serial::{OperationError, OperationErrorKind};
|
use crate::ops::serial::{OperationError, OperationErrorKind};
|
||||||
use crate::ops::Op;
|
use crate::ops::Op;
|
||||||
use nalgebra::{ClosedAdd, ClosedMul, DMatrixView, DMatrixViewMut, RealField, Scalar};
|
use nalgebra::{ClosedAddAssign, ClosedMulAssign, DMatrixView, DMatrixViewMut, RealField, Scalar};
|
||||||
use num_traits::{One, Zero};
|
use num_traits::{One, Zero};
|
||||||
|
|
||||||
use std::borrow::Cow;
|
use std::borrow::Cow;
|
||||||
|
@ -21,7 +21,7 @@ pub fn spmm_csc_dense<'a, T>(
|
||||||
a: Op<&CscMatrix<T>>,
|
a: Op<&CscMatrix<T>>,
|
||||||
b: Op<impl Into<DMatrixView<'a, T>>>,
|
b: Op<impl Into<DMatrixView<'a, T>>>,
|
||||||
) where
|
) where
|
||||||
T: Scalar + ClosedAdd + ClosedMul + Zero + One,
|
T: Scalar + ClosedAddAssign + ClosedMulAssign + Zero + One,
|
||||||
{
|
{
|
||||||
let b = b.convert();
|
let b = b.convert();
|
||||||
spmm_csc_dense_(beta, c.into(), alpha, a, b)
|
spmm_csc_dense_(beta, c.into(), alpha, a, b)
|
||||||
|
@ -34,7 +34,7 @@ fn spmm_csc_dense_<T>(
|
||||||
a: Op<&CscMatrix<T>>,
|
a: Op<&CscMatrix<T>>,
|
||||||
b: Op<DMatrixView<'_, T>>,
|
b: Op<DMatrixView<'_, T>>,
|
||||||
) where
|
) where
|
||||||
T: Scalar + ClosedAdd + ClosedMul + Zero + One,
|
T: Scalar + ClosedAddAssign + ClosedMulAssign + Zero + One,
|
||||||
{
|
{
|
||||||
assert_compatible_spmm_dims!(c, a, b);
|
assert_compatible_spmm_dims!(c, a, b);
|
||||||
// Need to interpret matrix as transposed since the spmm_cs_dense function assumes CSR layout
|
// Need to interpret matrix as transposed since the spmm_cs_dense function assumes CSR layout
|
||||||
|
@ -57,7 +57,7 @@ pub fn spadd_csc_prealloc<T>(
|
||||||
a: Op<&CscMatrix<T>>,
|
a: Op<&CscMatrix<T>>,
|
||||||
) -> Result<(), OperationError>
|
) -> Result<(), OperationError>
|
||||||
where
|
where
|
||||||
T: Scalar + ClosedAdd + ClosedMul + Zero + One,
|
T: Scalar + ClosedAddAssign + ClosedMulAssign + Zero + One,
|
||||||
{
|
{
|
||||||
assert_compatible_spadd_dims!(c, a);
|
assert_compatible_spadd_dims!(c, a);
|
||||||
spadd_cs_prealloc(beta, &mut c.cs, alpha, a.map_same_op(|a| &a.cs))
|
spadd_cs_prealloc(beta, &mut c.cs, alpha, a.map_same_op(|a| &a.cs))
|
||||||
|
@ -81,7 +81,7 @@ pub fn spmm_csc_prealloc<T>(
|
||||||
b: Op<&CscMatrix<T>>,
|
b: Op<&CscMatrix<T>>,
|
||||||
) -> Result<(), OperationError>
|
) -> Result<(), OperationError>
|
||||||
where
|
where
|
||||||
T: Scalar + ClosedAdd + ClosedMul + Zero + One,
|
T: Scalar + ClosedAddAssign + ClosedMulAssign + Zero + One,
|
||||||
{
|
{
|
||||||
assert_compatible_spmm_dims!(c, a, b);
|
assert_compatible_spmm_dims!(c, a, b);
|
||||||
|
|
||||||
|
@ -109,7 +109,7 @@ pub fn spmm_csc_prealloc_unchecked<T>(
|
||||||
b: Op<&CscMatrix<T>>,
|
b: Op<&CscMatrix<T>>,
|
||||||
) -> Result<(), OperationError>
|
) -> Result<(), OperationError>
|
||||||
where
|
where
|
||||||
T: Scalar + ClosedAdd + ClosedMul + Zero + One,
|
T: Scalar + ClosedAddAssign + ClosedMulAssign + Zero + One,
|
||||||
{
|
{
|
||||||
assert_compatible_spmm_dims!(c, a, b);
|
assert_compatible_spmm_dims!(c, a, b);
|
||||||
|
|
||||||
|
@ -133,7 +133,7 @@ fn spmm_csc_transposed<T, F>(
|
||||||
spmm_kernel: F,
|
spmm_kernel: F,
|
||||||
) -> Result<(), OperationError>
|
) -> Result<(), OperationError>
|
||||||
where
|
where
|
||||||
T: Scalar + ClosedAdd + ClosedMul + Zero + One,
|
T: Scalar + ClosedAddAssign + ClosedMulAssign + Zero + One,
|
||||||
F: Fn(
|
F: Fn(
|
||||||
T,
|
T,
|
||||||
&mut CscMatrix<T>,
|
&mut CscMatrix<T>,
|
||||||
|
|
|
@ -4,7 +4,7 @@ use crate::ops::serial::cs::{
|
||||||
};
|
};
|
||||||
use crate::ops::serial::OperationError;
|
use crate::ops::serial::OperationError;
|
||||||
use crate::ops::Op;
|
use crate::ops::Op;
|
||||||
use nalgebra::{ClosedAdd, ClosedMul, DMatrixView, DMatrixViewMut, Scalar};
|
use nalgebra::{ClosedAddAssign, ClosedMulAssign, DMatrixView, DMatrixViewMut, Scalar};
|
||||||
use num_traits::{One, Zero};
|
use num_traits::{One, Zero};
|
||||||
use std::borrow::Cow;
|
use std::borrow::Cow;
|
||||||
|
|
||||||
|
@ -16,7 +16,7 @@ pub fn spmm_csr_dense<'a, T>(
|
||||||
a: Op<&CsrMatrix<T>>,
|
a: Op<&CsrMatrix<T>>,
|
||||||
b: Op<impl Into<DMatrixView<'a, T>>>,
|
b: Op<impl Into<DMatrixView<'a, T>>>,
|
||||||
) where
|
) where
|
||||||
T: Scalar + ClosedAdd + ClosedMul + Zero + One,
|
T: Scalar + ClosedAddAssign + ClosedMulAssign + Zero + One,
|
||||||
{
|
{
|
||||||
let b = b.convert();
|
let b = b.convert();
|
||||||
spmm_csr_dense_(beta, c.into(), alpha, a, b)
|
spmm_csr_dense_(beta, c.into(), alpha, a, b)
|
||||||
|
@ -29,7 +29,7 @@ fn spmm_csr_dense_<T>(
|
||||||
a: Op<&CsrMatrix<T>>,
|
a: Op<&CsrMatrix<T>>,
|
||||||
b: Op<DMatrixView<'_, T>>,
|
b: Op<DMatrixView<'_, T>>,
|
||||||
) where
|
) where
|
||||||
T: Scalar + ClosedAdd + ClosedMul + Zero + One,
|
T: Scalar + ClosedAddAssign + ClosedMulAssign + Zero + One,
|
||||||
{
|
{
|
||||||
assert_compatible_spmm_dims!(c, a, b);
|
assert_compatible_spmm_dims!(c, a, b);
|
||||||
spmm_cs_dense(beta, c, alpha, a.map_same_op(|a| &a.cs), b)
|
spmm_cs_dense(beta, c, alpha, a.map_same_op(|a| &a.cs), b)
|
||||||
|
@ -52,7 +52,7 @@ pub fn spadd_csr_prealloc<T>(
|
||||||
a: Op<&CsrMatrix<T>>,
|
a: Op<&CsrMatrix<T>>,
|
||||||
) -> Result<(), OperationError>
|
) -> Result<(), OperationError>
|
||||||
where
|
where
|
||||||
T: Scalar + ClosedAdd + ClosedMul + Zero + One,
|
T: Scalar + ClosedAddAssign + ClosedMulAssign + Zero + One,
|
||||||
{
|
{
|
||||||
assert_compatible_spadd_dims!(c, a);
|
assert_compatible_spadd_dims!(c, a);
|
||||||
spadd_cs_prealloc(beta, &mut c.cs, alpha, a.map_same_op(|a| &a.cs))
|
spadd_cs_prealloc(beta, &mut c.cs, alpha, a.map_same_op(|a| &a.cs))
|
||||||
|
@ -75,7 +75,7 @@ pub fn spmm_csr_prealloc<T>(
|
||||||
b: Op<&CsrMatrix<T>>,
|
b: Op<&CsrMatrix<T>>,
|
||||||
) -> Result<(), OperationError>
|
) -> Result<(), OperationError>
|
||||||
where
|
where
|
||||||
T: Scalar + ClosedAdd + ClosedMul + Zero + One,
|
T: Scalar + ClosedAddAssign + ClosedMulAssign + Zero + One,
|
||||||
{
|
{
|
||||||
assert_compatible_spmm_dims!(c, a, b);
|
assert_compatible_spmm_dims!(c, a, b);
|
||||||
|
|
||||||
|
@ -100,7 +100,7 @@ pub fn spmm_csr_prealloc_unchecked<T>(
|
||||||
b: Op<&CsrMatrix<T>>,
|
b: Op<&CsrMatrix<T>>,
|
||||||
) -> Result<(), OperationError>
|
) -> Result<(), OperationError>
|
||||||
where
|
where
|
||||||
T: Scalar + ClosedAdd + ClosedMul + Zero + One,
|
T: Scalar + ClosedAddAssign + ClosedMulAssign + Zero + One,
|
||||||
{
|
{
|
||||||
assert_compatible_spmm_dims!(c, a, b);
|
assert_compatible_spmm_dims!(c, a, b);
|
||||||
|
|
||||||
|
@ -121,7 +121,7 @@ fn spmm_csr_transposed<T, F>(
|
||||||
spmm_kernel: F,
|
spmm_kernel: F,
|
||||||
) -> Result<(), OperationError>
|
) -> Result<(), OperationError>
|
||||||
where
|
where
|
||||||
T: Scalar + ClosedAdd + ClosedMul + Zero + One,
|
T: Scalar + ClosedAddAssign + ClosedMulAssign + Zero + One,
|
||||||
F: Fn(
|
F: Fn(
|
||||||
T,
|
T,
|
||||||
&mut CsrMatrix<T>,
|
&mut CsrMatrix<T>,
|
||||||
|
|
|
@ -1,6 +1,6 @@
|
||||||
use crate::{RawStorage, SimdComplexField};
|
use crate::{RawStorage, SimdComplexField};
|
||||||
use num::{One, Zero};
|
use num::{One, Zero};
|
||||||
use simba::scalar::{ClosedAdd, ClosedMul};
|
use simba::scalar::{ClosedAddAssign, ClosedMulAssign};
|
||||||
|
|
||||||
use crate::base::allocator::Allocator;
|
use crate::base::allocator::Allocator;
|
||||||
use crate::base::blas_uninit::{axcpy_uninit, gemm_uninit, gemv_uninit};
|
use crate::base::blas_uninit::{axcpy_uninit, gemm_uninit, gemv_uninit};
|
||||||
|
@ -17,7 +17,7 @@ use crate::base::{
|
||||||
/// # Dot/scalar product
|
/// # Dot/scalar product
|
||||||
impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
|
impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + ClosedAdd + ClosedMul,
|
T: Scalar + Zero + ClosedAddAssign + ClosedMulAssign,
|
||||||
{
|
{
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
fn dotx<R2: Dim, C2: Dim, SB>(
|
fn dotx<R2: Dim, C2: Dim, SB>(
|
||||||
|
@ -275,7 +275,7 @@ where
|
||||||
/// # BLAS functions
|
/// # BLAS functions
|
||||||
impl<T, D: Dim, S> Vector<T, D, S>
|
impl<T, D: Dim, S> Vector<T, D, S>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + ClosedAdd + ClosedMul,
|
T: Scalar + Zero + ClosedAddAssign + ClosedMulAssign,
|
||||||
S: StorageMut<T, D>,
|
S: StorageMut<T, D>,
|
||||||
{
|
{
|
||||||
/// Computes `self = a * x * c + b * self`.
|
/// Computes `self = a * x * c + b * self`.
|
||||||
|
@ -609,7 +609,7 @@ where
|
||||||
|
|
||||||
impl<T, R1: Dim, C1: Dim, S: StorageMut<T, R1, C1>> Matrix<T, R1, C1, S>
|
impl<T, R1: Dim, C1: Dim, S: StorageMut<T, R1, C1>> Matrix<T, R1, C1, S>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + ClosedAdd + ClosedMul,
|
T: Scalar + Zero + ClosedAddAssign + ClosedMulAssign,
|
||||||
{
|
{
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
fn gerx<D2: Dim, D3: Dim, SB, SC>(
|
fn gerx<D2: Dim, D3: Dim, SB, SC>(
|
||||||
|
@ -862,7 +862,7 @@ where
|
||||||
|
|
||||||
impl<T, R1: Dim, C1: Dim, S: StorageMut<T, R1, C1>> Matrix<T, R1, C1, S>
|
impl<T, R1: Dim, C1: Dim, S: StorageMut<T, R1, C1>> Matrix<T, R1, C1, S>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + ClosedAdd + ClosedMul,
|
T: Scalar + Zero + ClosedAddAssign + ClosedMulAssign,
|
||||||
{
|
{
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
fn xxgerx<D2: Dim, D3: Dim, SB, SC>(
|
fn xxgerx<D2: Dim, D3: Dim, SB, SC>(
|
||||||
|
@ -1010,7 +1010,7 @@ where
|
||||||
|
|
||||||
impl<T, D1: Dim, S: StorageMut<T, D1, D1>> SquareMatrix<T, D1, S>
|
impl<T, D1: Dim, S: StorageMut<T, D1, D1>> SquareMatrix<T, D1, S>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + One + ClosedAdd + ClosedMul,
|
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
|
||||||
{
|
{
|
||||||
/// Computes the quadratic form `self = alpha * lhs * mid * lhs.transpose() + beta * self`.
|
/// Computes the quadratic form `self = alpha * lhs * mid * lhs.transpose() + beta * self`.
|
||||||
///
|
///
|
||||||
|
|
|
@ -11,7 +11,7 @@
|
||||||
#[cfg(feature = "std")]
|
#[cfg(feature = "std")]
|
||||||
use matrixmultiply;
|
use matrixmultiply;
|
||||||
use num::{One, Zero};
|
use num::{One, Zero};
|
||||||
use simba::scalar::{ClosedAdd, ClosedMul};
|
use simba::scalar::{ClosedAddAssign, ClosedMulAssign};
|
||||||
#[cfg(feature = "std")]
|
#[cfg(feature = "std")]
|
||||||
use std::{any::TypeId, mem};
|
use std::{any::TypeId, mem};
|
||||||
|
|
||||||
|
@ -41,7 +41,7 @@ unsafe fn array_axcpy<Status, T>(
|
||||||
len: usize,
|
len: usize,
|
||||||
) where
|
) where
|
||||||
Status: InitStatus<T>,
|
Status: InitStatus<T>,
|
||||||
T: Scalar + Zero + ClosedAdd + ClosedMul,
|
T: Scalar + Zero + ClosedAddAssign + ClosedMulAssign,
|
||||||
{
|
{
|
||||||
for i in 0..len {
|
for i in 0..len {
|
||||||
let y = Status::assume_init_mut(y.get_unchecked_mut(i * stride1));
|
let y = Status::assume_init_mut(y.get_unchecked_mut(i * stride1));
|
||||||
|
@ -61,7 +61,7 @@ fn array_axc<Status, T>(
|
||||||
len: usize,
|
len: usize,
|
||||||
) where
|
) where
|
||||||
Status: InitStatus<T>,
|
Status: InitStatus<T>,
|
||||||
T: Scalar + Zero + ClosedAdd + ClosedMul,
|
T: Scalar + Zero + ClosedAddAssign + ClosedMulAssign,
|
||||||
{
|
{
|
||||||
for i in 0..len {
|
for i in 0..len {
|
||||||
unsafe {
|
unsafe {
|
||||||
|
@ -89,7 +89,7 @@ pub unsafe fn axcpy_uninit<Status, T, D1: Dim, D2: Dim, SA, SB>(
|
||||||
c: T,
|
c: T,
|
||||||
b: T,
|
b: T,
|
||||||
) where
|
) where
|
||||||
T: Scalar + Zero + ClosedAdd + ClosedMul,
|
T: Scalar + Zero + ClosedAddAssign + ClosedMulAssign,
|
||||||
SA: RawStorageMut<Status::Value, D1>,
|
SA: RawStorageMut<Status::Value, D1>,
|
||||||
SB: RawStorage<T, D2>,
|
SB: RawStorage<T, D2>,
|
||||||
ShapeConstraint: DimEq<D1, D2>,
|
ShapeConstraint: DimEq<D1, D2>,
|
||||||
|
@ -129,7 +129,7 @@ pub unsafe fn gemv_uninit<Status, T, D1: Dim, R2: Dim, C2: Dim, D3: Dim, SA, SB,
|
||||||
beta: T,
|
beta: T,
|
||||||
) where
|
) where
|
||||||
Status: InitStatus<T>,
|
Status: InitStatus<T>,
|
||||||
T: Scalar + Zero + One + ClosedAdd + ClosedMul,
|
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
|
||||||
SA: RawStorageMut<Status::Value, D1>,
|
SA: RawStorageMut<Status::Value, D1>,
|
||||||
SB: RawStorage<T, R2, C2>,
|
SB: RawStorage<T, R2, C2>,
|
||||||
SC: RawStorage<T, D3>,
|
SC: RawStorage<T, D3>,
|
||||||
|
@ -199,7 +199,7 @@ pub unsafe fn gemm_uninit<
|
||||||
beta: T,
|
beta: T,
|
||||||
) where
|
) where
|
||||||
Status: InitStatus<T>,
|
Status: InitStatus<T>,
|
||||||
T: Scalar + Zero + One + ClosedAdd + ClosedMul,
|
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
|
||||||
SA: RawStorageMut<Status::Value, R1, C1>,
|
SA: RawStorageMut<Status::Value, R1, C1>,
|
||||||
SB: RawStorage<T, R2, C2>,
|
SB: RawStorage<T, R2, C2>,
|
||||||
SC: RawStorage<T, R3, C3>,
|
SC: RawStorage<T, R3, C3>,
|
||||||
|
|
|
@ -19,7 +19,7 @@ use crate::geometry::{
|
||||||
Rotation3,
|
Rotation3,
|
||||||
};
|
};
|
||||||
|
|
||||||
use simba::scalar::{ClosedAdd, ClosedMul, RealField};
|
use simba::scalar::{ClosedAddAssign, ClosedMulAssign, RealField};
|
||||||
|
|
||||||
/// # Translation and scaling in any dimension
|
/// # Translation and scaling in any dimension
|
||||||
impl<T, D: DimName> OMatrix<T, D, D>
|
impl<T, D: DimName> OMatrix<T, D, D>
|
||||||
|
@ -207,8 +207,11 @@ impl<T: RealField> Matrix4<T> {
|
||||||
}
|
}
|
||||||
|
|
||||||
/// # Append/prepend translation and scaling
|
/// # Append/prepend translation and scaling
|
||||||
impl<T: Scalar + Zero + One + ClosedMul + ClosedAdd, D: DimName, S: Storage<T, D, D>>
|
impl<
|
||||||
SquareMatrix<T, D, S>
|
T: Scalar + Zero + One + ClosedMulAssign + ClosedAddAssign,
|
||||||
|
D: DimName,
|
||||||
|
S: Storage<T, D, D>,
|
||||||
|
> SquareMatrix<T, D, S>
|
||||||
{
|
{
|
||||||
/// Computes the transformation equal to `self` followed by an uniform scaling factor.
|
/// Computes the transformation equal to `self` followed by an uniform scaling factor.
|
||||||
#[inline]
|
#[inline]
|
||||||
|
|
|
@ -3,7 +3,7 @@
|
||||||
use num::{Signed, Zero};
|
use num::{Signed, Zero};
|
||||||
use std::ops::{Add, Mul};
|
use std::ops::{Add, Mul};
|
||||||
|
|
||||||
use simba::scalar::{ClosedDiv, ClosedMul};
|
use simba::scalar::{ClosedDivAssign, ClosedMulAssign};
|
||||||
use simba::simd::SimdPartialOrd;
|
use simba::simd::SimdPartialOrd;
|
||||||
|
|
||||||
use crate::base::allocator::{Allocator, SameShapeAllocator};
|
use crate::base::allocator::{Allocator, SameShapeAllocator};
|
||||||
|
@ -11,7 +11,7 @@ use crate::base::constraint::{SameNumberOfColumns, SameNumberOfRows, ShapeConstr
|
||||||
use crate::base::dimension::Dim;
|
use crate::base::dimension::Dim;
|
||||||
use crate::base::storage::{Storage, StorageMut};
|
use crate::base::storage::{Storage, StorageMut};
|
||||||
use crate::base::{DefaultAllocator, Matrix, MatrixSum, OMatrix, Scalar};
|
use crate::base::{DefaultAllocator, Matrix, MatrixSum, OMatrix, Scalar};
|
||||||
use crate::ClosedAdd;
|
use crate::ClosedAddAssign;
|
||||||
|
|
||||||
/// The type of the result of a matrix component-wise operation.
|
/// The type of the result of a matrix component-wise operation.
|
||||||
pub type MatrixComponentOp<T, R1, C1, R2, C2> = MatrixSum<T, R1, C1, R2, C2>;
|
pub type MatrixComponentOp<T, R1, C1, R2, C2> = MatrixSum<T, R1, C1, R2, C2>;
|
||||||
|
@ -148,7 +148,7 @@ macro_rules! component_binop_impl(
|
||||||
/// # Componentwise operations
|
/// # Componentwise operations
|
||||||
impl<T: Scalar, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>> Matrix<T, R1, C1, SA> {
|
impl<T: Scalar, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>> Matrix<T, R1, C1, SA> {
|
||||||
component_binop_impl!(
|
component_binop_impl!(
|
||||||
component_mul, component_mul_mut, component_mul_assign, cmpy, ClosedMul.mul.mul_assign,
|
component_mul, component_mul_mut, component_mul_assign, cmpy, ClosedMulAssign.mul.mul_assign,
|
||||||
r"
|
r"
|
||||||
Componentwise matrix or vector multiplication.
|
Componentwise matrix or vector multiplication.
|
||||||
|
|
||||||
|
@ -193,7 +193,7 @@ impl<T: Scalar, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>> Matrix<T, R1, C1, SA>
|
||||||
assert_eq!(a, expected);
|
assert_eq!(a, expected);
|
||||||
```
|
```
|
||||||
";
|
";
|
||||||
component_div, component_div_mut, component_div_assign, cdpy, ClosedDiv.div.div_assign,
|
component_div, component_div_mut, component_div_assign, cdpy, ClosedDivAssign.div.div_assign,
|
||||||
r"
|
r"
|
||||||
Componentwise matrix or vector division.
|
Componentwise matrix or vector division.
|
||||||
|
|
||||||
|
@ -320,7 +320,7 @@ impl<T: Scalar, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>> Matrix<T, R1, C1, SA>
|
||||||
#[must_use = "Did you mean to use add_scalar_mut()?"]
|
#[must_use = "Did you mean to use add_scalar_mut()?"]
|
||||||
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: ClosedAddAssign,
|
||||||
DefaultAllocator: Allocator<R1, C1>,
|
DefaultAllocator: Allocator<R1, C1>,
|
||||||
{
|
{
|
||||||
let mut res = self.clone_owned();
|
let mut res = self.clone_owned();
|
||||||
|
@ -343,7 +343,7 @@ impl<T: Scalar, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>> Matrix<T, R1, C1, SA>
|
||||||
#[inline]
|
#[inline]
|
||||||
pub fn add_scalar_mut(&mut self, rhs: T)
|
pub fn add_scalar_mut(&mut self, rhs: T)
|
||||||
where
|
where
|
||||||
T: ClosedAdd,
|
T: ClosedAddAssign,
|
||||||
SA: StorageMut<T, R1, C1>,
|
SA: StorageMut<T, R1, C1>,
|
||||||
{
|
{
|
||||||
for e in self.iter_mut() {
|
for e in self.iter_mut() {
|
||||||
|
|
|
@ -16,7 +16,7 @@ use rand::{
|
||||||
use std::iter;
|
use std::iter;
|
||||||
use typenum::{self, Cmp, Greater};
|
use typenum::{self, Cmp, Greater};
|
||||||
|
|
||||||
use simba::scalar::{ClosedAdd, ClosedMul};
|
use simba::scalar::{ClosedAddAssign, ClosedMulAssign};
|
||||||
|
|
||||||
use crate::base::allocator::Allocator;
|
use crate::base::allocator::Allocator;
|
||||||
use crate::base::dimension::{Dim, DimName, Dyn, ToTypenum};
|
use crate::base::dimension::{Dim, DimName, Dyn, ToTypenum};
|
||||||
|
@ -814,7 +814,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 + ClosedAddAssign,
|
||||||
DefaultAllocator: Allocator<R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -830,7 +830,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 + ClosedMulAssign + ClosedAddAssign,
|
||||||
DefaultAllocator: Allocator<D, D>,
|
DefaultAllocator: Allocator<D, D>,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
|
|
|
@ -2,11 +2,14 @@ use crate::storage::Storage;
|
||||||
use crate::{
|
use crate::{
|
||||||
Allocator, DefaultAllocator, Dim, OVector, One, RealField, Scalar, Unit, Vector, Zero,
|
Allocator, DefaultAllocator, Dim, OVector, One, RealField, Scalar, Unit, Vector, Zero,
|
||||||
};
|
};
|
||||||
use simba::scalar::{ClosedAdd, ClosedMul, ClosedSub};
|
use simba::scalar::{ClosedAddAssign, ClosedMulAssign, ClosedSubAssign};
|
||||||
|
|
||||||
/// # Interpolation
|
/// # Interpolation
|
||||||
impl<T: Scalar + Zero + One + ClosedAdd + ClosedSub + ClosedMul, D: Dim, S: Storage<T, D>>
|
impl<
|
||||||
Vector<T, D, S>
|
T: Scalar + Zero + One + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign,
|
||||||
|
D: Dim,
|
||||||
|
S: Storage<T, D>,
|
||||||
|
> Vector<T, D, S>
|
||||||
{
|
{
|
||||||
/// Returns `self * (1.0 - t) + rhs * t`, i.e., the linear blend of the vectors x and y using the scalar value a.
|
/// Returns `self * (1.0 - t) + rhs * t`, i.e., the linear blend of the vectors x and y using the scalar value a.
|
||||||
///
|
///
|
||||||
|
|
|
@ -18,7 +18,7 @@ use rkyv::bytecheck;
|
||||||
#[cfg(feature = "rkyv-serialize-no-std")]
|
#[cfg(feature = "rkyv-serialize-no-std")]
|
||||||
use rkyv::{with::With, Archive, Archived};
|
use rkyv::{with::With, Archive, Archived};
|
||||||
|
|
||||||
use simba::scalar::{ClosedAdd, ClosedMul, ClosedSub, Field, SupersetOf};
|
use simba::scalar::{ClosedAddAssign, ClosedMulAssign, ClosedSubAssign, Field, SupersetOf};
|
||||||
use simba::simd::SimdPartialOrd;
|
use simba::simd::SimdPartialOrd;
|
||||||
|
|
||||||
use crate::base::allocator::{Allocator, SameShapeAllocator, SameShapeC, SameShapeR};
|
use crate::base::allocator::{Allocator, SameShapeAllocator, SameShapeC, SameShapeR};
|
||||||
|
@ -1586,7 +1586,7 @@ impl<T: Scalar, D: Dim, S: RawStorage<T, D, D>> SquareMatrix<T, D, S> {
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn trace(&self) -> T
|
pub fn trace(&self) -> T
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + ClosedAdd,
|
T: Scalar + Zero + ClosedAddAssign,
|
||||||
{
|
{
|
||||||
assert!(
|
assert!(
|
||||||
self.is_square(),
|
self.is_square(),
|
||||||
|
@ -2002,8 +2002,12 @@ mod tests {
|
||||||
}
|
}
|
||||||
|
|
||||||
/// # Cross product
|
/// # Cross product
|
||||||
impl<T: Scalar + ClosedAdd + ClosedSub + ClosedMul, R: Dim, C: Dim, S: RawStorage<T, R, C>>
|
impl<
|
||||||
Matrix<T, R, C, S>
|
T: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign,
|
||||||
|
R: Dim,
|
||||||
|
C: Dim,
|
||||||
|
S: RawStorage<T, R, C>,
|
||||||
|
> Matrix<T, R, C, S>
|
||||||
{
|
{
|
||||||
/// The perpendicular product between two 2D column vectors, i.e. `a.x * b.y - a.y * b.x`.
|
/// The perpendicular product between two 2D column vectors, i.e. `a.x * b.y - a.y * b.x`.
|
||||||
#[inline]
|
#[inline]
|
||||||
|
|
|
@ -17,14 +17,10 @@ where
|
||||||
T::Element: Scalar,
|
T::Element: Scalar,
|
||||||
DefaultAllocator: Allocator<R, C>,
|
DefaultAllocator: Allocator<R, C>,
|
||||||
{
|
{
|
||||||
|
const LANES: usize = T::LANES;
|
||||||
type Element = OMatrix<T::Element, R, C>;
|
type Element = OMatrix<T::Element, R, C>;
|
||||||
type SimdBool = T::SimdBool;
|
type SimdBool = T::SimdBool;
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn lanes() -> usize {
|
|
||||||
T::lanes()
|
|
||||||
}
|
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn splat(val: Self::Element) -> Self {
|
fn splat(val: Self::Element) -> Self {
|
||||||
val.map(T::splat)
|
val.map(T::splat)
|
||||||
|
|
|
@ -4,7 +4,9 @@ use std::ops::{
|
||||||
Add, AddAssign, Div, DivAssign, Index, IndexMut, Mul, MulAssign, Neg, Sub, SubAssign,
|
Add, AddAssign, Div, DivAssign, Index, IndexMut, Mul, MulAssign, Neg, Sub, SubAssign,
|
||||||
};
|
};
|
||||||
|
|
||||||
use simba::scalar::{ClosedAdd, ClosedDiv, ClosedMul, ClosedNeg, ClosedSub};
|
use simba::scalar::{
|
||||||
|
ClosedAddAssign, ClosedDivAssign, ClosedMulAssign, ClosedNeg, ClosedSubAssign,
|
||||||
|
};
|
||||||
|
|
||||||
use crate::base::allocator::{Allocator, SameShapeAllocator, SameShapeC, SameShapeR};
|
use crate::base::allocator::{Allocator, SameShapeAllocator, SameShapeC, SameShapeR};
|
||||||
use crate::base::blas_uninit::gemm_uninit;
|
use crate::base::blas_uninit::gemm_uninit;
|
||||||
|
@ -357,16 +359,16 @@ macro_rules! componentwise_binop_impl(
|
||||||
}
|
}
|
||||||
);
|
);
|
||||||
|
|
||||||
componentwise_binop_impl!(Add, add, ClosedAdd;
|
componentwise_binop_impl!(Add, add, ClosedAddAssign;
|
||||||
AddAssign, add_assign, add_assign_statically_unchecked, add_assign_statically_unchecked_mut;
|
AddAssign, add_assign, add_assign_statically_unchecked, add_assign_statically_unchecked_mut;
|
||||||
add_to, add_to_statically_unchecked_uninit);
|
add_to, add_to_statically_unchecked_uninit);
|
||||||
componentwise_binop_impl!(Sub, sub, ClosedSub;
|
componentwise_binop_impl!(Sub, sub, ClosedSubAssign;
|
||||||
SubAssign, sub_assign, sub_assign_statically_unchecked, sub_assign_statically_unchecked_mut;
|
SubAssign, sub_assign, sub_assign_statically_unchecked, sub_assign_statically_unchecked_mut;
|
||||||
sub_to, sub_to_statically_unchecked_uninit);
|
sub_to, sub_to_statically_unchecked_uninit);
|
||||||
|
|
||||||
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 + ClosedAddAssign + Zero,
|
||||||
DefaultAllocator: Allocator<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> {
|
||||||
|
@ -376,7 +378,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 + ClosedAddAssign + Zero,
|
||||||
DefaultAllocator: Allocator<Dyn, C>,
|
DefaultAllocator: Allocator<Dyn, C>,
|
||||||
{
|
{
|
||||||
/// # Example
|
/// # Example
|
||||||
|
@ -406,7 +408,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 + ClosedAddAssign + Zero,
|
||||||
DefaultAllocator: Allocator<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> {
|
||||||
|
@ -416,7 +418,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 + ClosedAddAssign + Zero,
|
||||||
DefaultAllocator: Allocator<Dyn, C>,
|
DefaultAllocator: Allocator<Dyn, C>,
|
||||||
{
|
{
|
||||||
/// # Example
|
/// # Example
|
||||||
|
@ -506,8 +508,8 @@ macro_rules! componentwise_scalarop_impl(
|
||||||
}
|
}
|
||||||
);
|
);
|
||||||
|
|
||||||
componentwise_scalarop_impl!(Mul, mul, ClosedMul; MulAssign, mul_assign);
|
componentwise_scalarop_impl!(Mul, mul, ClosedMulAssign; MulAssign, mul_assign);
|
||||||
componentwise_scalarop_impl!(Div, div, ClosedDiv; DivAssign, div_assign);
|
componentwise_scalarop_impl!(Div, div, ClosedDivAssign; DivAssign, div_assign);
|
||||||
|
|
||||||
macro_rules! left_scalar_mul_impl(
|
macro_rules! left_scalar_mul_impl(
|
||||||
($($T: ty),* $(,)*) => {$(
|
($($T: ty),* $(,)*) => {$(
|
||||||
|
@ -551,7 +553,7 @@ left_scalar_mul_impl!(u8, u16, u32, u64, usize, i8, i16, i32, i64, isize, f32, f
|
||||||
impl<'a, 'b, T, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<&'b Matrix<T, R2, C2, SB>>
|
impl<'a, 'b, T, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<&'b Matrix<T, R2, C2, SB>>
|
||||||
for &'a Matrix<T, R1, C1, SA>
|
for &'a Matrix<T, R1, C1, SA>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + One + ClosedAdd + ClosedMul,
|
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
|
||||||
SA: Storage<T, R1, C1>,
|
SA: Storage<T, R1, C1>,
|
||||||
SB: Storage<T, R2, C2>,
|
SB: Storage<T, R2, C2>,
|
||||||
DefaultAllocator: Allocator<R1, C2>,
|
DefaultAllocator: Allocator<R1, C2>,
|
||||||
|
@ -573,7 +575,7 @@ where
|
||||||
impl<'a, T, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<Matrix<T, R2, C2, SB>>
|
impl<'a, T, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<Matrix<T, R2, C2, SB>>
|
||||||
for &'a Matrix<T, R1, C1, SA>
|
for &'a Matrix<T, R1, C1, SA>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + One + ClosedAdd + ClosedMul,
|
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
|
||||||
SB: Storage<T, R2, C2>,
|
SB: Storage<T, R2, C2>,
|
||||||
SA: Storage<T, R1, C1>,
|
SA: Storage<T, R1, C1>,
|
||||||
DefaultAllocator: Allocator<R1, C2>,
|
DefaultAllocator: Allocator<R1, C2>,
|
||||||
|
@ -590,7 +592,7 @@ where
|
||||||
impl<'b, T, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<&'b Matrix<T, R2, C2, SB>>
|
impl<'b, T, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<&'b Matrix<T, R2, C2, SB>>
|
||||||
for Matrix<T, R1, C1, SA>
|
for Matrix<T, R1, C1, SA>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + One + ClosedAdd + ClosedMul,
|
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
|
||||||
SB: Storage<T, R2, C2>,
|
SB: Storage<T, R2, C2>,
|
||||||
SA: Storage<T, R1, C1>,
|
SA: Storage<T, R1, C1>,
|
||||||
DefaultAllocator: Allocator<R1, C2>,
|
DefaultAllocator: Allocator<R1, C2>,
|
||||||
|
@ -607,7 +609,7 @@ where
|
||||||
impl<T, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<Matrix<T, R2, C2, SB>>
|
impl<T, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<Matrix<T, R2, C2, SB>>
|
||||||
for Matrix<T, R1, C1, SA>
|
for Matrix<T, R1, C1, SA>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + One + ClosedAdd + ClosedMul,
|
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
|
||||||
SB: Storage<T, R2, C2>,
|
SB: Storage<T, R2, C2>,
|
||||||
SA: Storage<T, R1, C1>,
|
SA: Storage<T, R1, C1>,
|
||||||
DefaultAllocator: Allocator<R1, C2>,
|
DefaultAllocator: Allocator<R1, C2>,
|
||||||
|
@ -629,7 +631,7 @@ where
|
||||||
R1: Dim,
|
R1: Dim,
|
||||||
C1: Dim,
|
C1: Dim,
|
||||||
R2: Dim,
|
R2: Dim,
|
||||||
T: Scalar + Zero + One + ClosedAdd + ClosedMul,
|
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
|
||||||
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>,
|
||||||
|
@ -646,7 +648,7 @@ where
|
||||||
R1: Dim,
|
R1: Dim,
|
||||||
C1: Dim,
|
C1: Dim,
|
||||||
R2: Dim,
|
R2: Dim,
|
||||||
T: Scalar + Zero + One + ClosedAdd + ClosedMul,
|
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
|
||||||
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>,
|
||||||
|
@ -662,7 +664,7 @@ where
|
||||||
/// # Special multiplications.
|
/// # Special multiplications.
|
||||||
impl<T, R1: Dim, C1: Dim, SA> Matrix<T, R1, C1, SA>
|
impl<T, R1: Dim, C1: Dim, SA> Matrix<T, R1, C1, SA>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + One + ClosedAdd + ClosedMul,
|
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
|
||||||
SA: Storage<T, R1, C1>,
|
SA: Storage<T, R1, C1>,
|
||||||
{
|
{
|
||||||
/// Equivalent to `self.transpose() * rhs`.
|
/// Equivalent to `self.transpose() * rhs`.
|
||||||
|
@ -799,7 +801,7 @@ where
|
||||||
rhs: &Matrix<T, R2, C2, SB>,
|
rhs: &Matrix<T, R2, C2, SB>,
|
||||||
) -> OMatrix<T, DimProd<R1, R2>, DimProd<C1, C2>>
|
) -> OMatrix<T, DimProd<R1, R2>, DimProd<C1, C2>>
|
||||||
where
|
where
|
||||||
T: ClosedMul,
|
T: ClosedMulAssign,
|
||||||
R1: DimMul<R2>,
|
R1: DimMul<R2>,
|
||||||
C1: DimMul<C2>,
|
C1: DimMul<C2>,
|
||||||
SB: Storage<T, R2, C2>,
|
SB: Storage<T, R2, C2>,
|
||||||
|
@ -835,7 +837,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 + ClosedMulAssign + ClosedAddAssign,
|
||||||
DefaultAllocator: Allocator<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> {
|
||||||
|
@ -845,7 +847,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 + ClosedMulAssign + ClosedAddAssign,
|
||||||
DefaultAllocator: Allocator<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> {
|
||||||
|
|
|
@ -2,7 +2,7 @@
|
||||||
use approx::RelativeEq;
|
use approx::RelativeEq;
|
||||||
use num::{One, Zero};
|
use num::{One, Zero};
|
||||||
|
|
||||||
use simba::scalar::{ClosedAdd, ClosedMul, ComplexField, RealField};
|
use simba::scalar::{ClosedAddAssign, ClosedMulAssign, ComplexField, RealField};
|
||||||
|
|
||||||
use crate::base::allocator::Allocator;
|
use crate::base::allocator::Allocator;
|
||||||
use crate::base::dimension::{Dim, DimMin};
|
use crate::base::dimension::{Dim, DimMin};
|
||||||
|
@ -88,7 +88,7 @@ impl<T: ComplexField, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn is_orthogonal(&self, eps: T::Epsilon) -> bool
|
pub fn is_orthogonal(&self, eps: T::Epsilon) -> bool
|
||||||
where
|
where
|
||||||
T: Zero + One + ClosedAdd + ClosedMul + RelativeEq,
|
T: Zero + One + ClosedAddAssign + ClosedMulAssign + RelativeEq,
|
||||||
S: Storage<T, R, C>,
|
S: Storage<T, R, C>,
|
||||||
T::Epsilon: Clone,
|
T::Epsilon: Clone,
|
||||||
DefaultAllocator: Allocator<R, C> + Allocator<C, C>,
|
DefaultAllocator: Allocator<R, C> + Allocator<C, C>,
|
||||||
|
|
|
@ -2,7 +2,7 @@ use crate::allocator::Allocator;
|
||||||
use crate::storage::RawStorage;
|
use crate::storage::RawStorage;
|
||||||
use crate::{Const, DefaultAllocator, Dim, Matrix, OVector, RowOVector, Scalar, VectorView, U1};
|
use crate::{Const, DefaultAllocator, Dim, Matrix, OVector, RowOVector, Scalar, VectorView, U1};
|
||||||
use num::{One, Zero};
|
use num::{One, Zero};
|
||||||
use simba::scalar::{ClosedAdd, ClosedMul, Field, SupersetOf};
|
use simba::scalar::{ClosedAddAssign, ClosedMulAssign, Field, SupersetOf};
|
||||||
use std::mem::MaybeUninit;
|
use std::mem::MaybeUninit;
|
||||||
|
|
||||||
/// # Folding on columns and rows
|
/// # Folding on columns and rows
|
||||||
|
@ -104,7 +104,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn sum(&self) -> T
|
pub fn sum(&self) -> T
|
||||||
where
|
where
|
||||||
T: ClosedAdd + Zero,
|
T: ClosedAddAssign + Zero,
|
||||||
{
|
{
|
||||||
self.iter().cloned().fold(T::zero(), |a, b| a + b)
|
self.iter().cloned().fold(T::zero(), |a, b| a + b)
|
||||||
}
|
}
|
||||||
|
@ -132,7 +132,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn row_sum(&self) -> RowOVector<T, C>
|
pub fn row_sum(&self) -> RowOVector<T, C>
|
||||||
where
|
where
|
||||||
T: ClosedAdd + Zero,
|
T: ClosedAddAssign + Zero,
|
||||||
DefaultAllocator: Allocator<U1, C>,
|
DefaultAllocator: Allocator<U1, C>,
|
||||||
{
|
{
|
||||||
self.compress_rows(|col| col.sum())
|
self.compress_rows(|col| col.sum())
|
||||||
|
@ -159,7 +159,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn row_sum_tr(&self) -> OVector<T, C>
|
pub fn row_sum_tr(&self) -> OVector<T, C>
|
||||||
where
|
where
|
||||||
T: ClosedAdd + Zero,
|
T: ClosedAddAssign + Zero,
|
||||||
DefaultAllocator: Allocator<C>,
|
DefaultAllocator: Allocator<C>,
|
||||||
{
|
{
|
||||||
self.compress_rows_tr(|col| col.sum())
|
self.compress_rows_tr(|col| col.sum())
|
||||||
|
@ -186,7 +186,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn column_sum(&self) -> OVector<T, R>
|
pub fn column_sum(&self) -> OVector<T, R>
|
||||||
where
|
where
|
||||||
T: ClosedAdd + Zero,
|
T: ClosedAddAssign + Zero,
|
||||||
DefaultAllocator: Allocator<R>,
|
DefaultAllocator: Allocator<R>,
|
||||||
{
|
{
|
||||||
let nrows = self.shape_generic().0;
|
let nrows = self.shape_generic().0;
|
||||||
|
@ -215,7 +215,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn product(&self) -> T
|
pub fn product(&self) -> T
|
||||||
where
|
where
|
||||||
T: ClosedMul + One,
|
T: ClosedMulAssign + One,
|
||||||
{
|
{
|
||||||
self.iter().cloned().fold(T::one(), |a, b| a * b)
|
self.iter().cloned().fold(T::one(), |a, b| a * b)
|
||||||
}
|
}
|
||||||
|
@ -243,7 +243,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn row_product(&self) -> RowOVector<T, C>
|
pub fn row_product(&self) -> RowOVector<T, C>
|
||||||
where
|
where
|
||||||
T: ClosedMul + One,
|
T: ClosedMulAssign + One,
|
||||||
DefaultAllocator: Allocator<U1, C>,
|
DefaultAllocator: Allocator<U1, C>,
|
||||||
{
|
{
|
||||||
self.compress_rows(|col| col.product())
|
self.compress_rows(|col| col.product())
|
||||||
|
@ -270,7 +270,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn row_product_tr(&self) -> OVector<T, C>
|
pub fn row_product_tr(&self) -> OVector<T, C>
|
||||||
where
|
where
|
||||||
T: ClosedMul + One,
|
T: ClosedMulAssign + One,
|
||||||
DefaultAllocator: Allocator<C>,
|
DefaultAllocator: Allocator<C>,
|
||||||
{
|
{
|
||||||
self.compress_rows_tr(|col| col.product())
|
self.compress_rows_tr(|col| col.product())
|
||||||
|
@ -297,7 +297,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn column_product(&self) -> OVector<T, R>
|
pub fn column_product(&self) -> OVector<T, R>
|
||||||
where
|
where
|
||||||
T: ClosedMul + One,
|
T: ClosedMulAssign + One,
|
||||||
DefaultAllocator: Allocator<R>,
|
DefaultAllocator: Allocator<R>,
|
||||||
{
|
{
|
||||||
let nrows = self.shape_generic().0;
|
let nrows = self.shape_generic().0;
|
||||||
|
|
|
@ -1,10 +1,10 @@
|
||||||
use crate::geometry::{Rotation, UnitComplex, UnitQuaternion};
|
use crate::geometry::{Rotation, UnitComplex, UnitQuaternion};
|
||||||
use crate::{Const, OVector, Point, SVector, Scalar, SimdRealField, Unit};
|
use crate::{Const, OVector, Point, SVector, Scalar, SimdRealField, Unit};
|
||||||
|
|
||||||
use simba::scalar::ClosedMul;
|
use simba::scalar::ClosedMulAssign;
|
||||||
|
|
||||||
/// Trait implemented by rotations that can be used inside of an `Isometry` or `Similarity`.
|
/// Trait implemented by rotations that can be used inside of an `Isometry` or `Similarity`.
|
||||||
pub trait AbstractRotation<T: Scalar, const D: usize>: PartialEq + ClosedMul + Clone {
|
pub trait AbstractRotation<T: Scalar, const D: usize>: PartialEq + ClosedMulAssign + Clone {
|
||||||
/// The rotation identity.
|
/// The rotation identity.
|
||||||
fn identity() -> Self;
|
fn identity() -> Self;
|
||||||
/// The rotation inverse.
|
/// The rotation inverse.
|
||||||
|
|
|
@ -4,7 +4,7 @@
|
||||||
use num::{One, Zero};
|
use num::{One, Zero};
|
||||||
use std::ops::{Div, DivAssign, Mul, MulAssign};
|
use std::ops::{Div, DivAssign, Mul, MulAssign};
|
||||||
|
|
||||||
use simba::scalar::{ClosedAdd, ClosedMul};
|
use simba::scalar::{ClosedAddAssign, ClosedMulAssign};
|
||||||
use simba::simd::SimdRealField;
|
use simba::simd::SimdRealField;
|
||||||
|
|
||||||
use crate::base::{SVector, Unit};
|
use crate::base::{SVector, Unit};
|
||||||
|
|
|
@ -10,14 +10,10 @@ where
|
||||||
R: SimdValue<SimdBool = T::SimdBool> + AbstractRotation<T, D>,
|
R: SimdValue<SimdBool = T::SimdBool> + AbstractRotation<T, D>,
|
||||||
R::Element: AbstractRotation<T::Element, D>,
|
R::Element: AbstractRotation<T::Element, D>,
|
||||||
{
|
{
|
||||||
|
const LANES: usize = T::LANES;
|
||||||
type Element = Isometry<T::Element, R::Element, D>;
|
type Element = Isometry<T::Element, R::Element, D>;
|
||||||
type SimdBool = T::SimdBool;
|
type SimdBool = T::SimdBool;
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn lanes() -> usize {
|
|
||||||
T::lanes()
|
|
||||||
}
|
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn splat(val: Self::Element) -> Self {
|
fn splat(val: Self::Element) -> Self {
|
||||||
Isometry::from_parts(Translation::splat(val.translation), R::splat(val.rotation))
|
Isometry::from_parts(Translation::splat(val.translation), R::splat(val.rotation))
|
||||||
|
|
|
@ -21,7 +21,7 @@ macro_rules! md_impl(
|
||||||
// Lifetime.
|
// Lifetime.
|
||||||
$($lives: tt),*) => {
|
$($lives: tt),*) => {
|
||||||
impl<$($lives ,)* T $(, $DimsDecl)* $(, const $D: usize)*> $Op<$Rhs> for $Lhs
|
impl<$($lives ,)* T $(, $DimsDecl)* $(, const $D: usize)*> $Op<$Rhs> for $Lhs
|
||||||
where T: Scalar + Zero + One + ClosedAdd + ClosedMul $($(+ $ScalarBounds)*)*,
|
where T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign $($(+ $ScalarBounds)*)*,
|
||||||
$( $ConstraintType: $ConstraintBound$(<$( $ConstraintBoundParams $( = $EqBound )*),*>)* ),*
|
$( $ConstraintType: $ConstraintBound$(<$( $ConstraintBoundParams $( = $EqBound )*),*>)* ),*
|
||||||
{
|
{
|
||||||
type Output = $Result;
|
type Output = $Result;
|
||||||
|
@ -112,7 +112,7 @@ macro_rules! md_assign_impl(
|
||||||
// Actual implementation and lifetimes.
|
// Actual implementation and lifetimes.
|
||||||
$action: expr; $($lives: tt),*) => {
|
$action: expr; $($lives: tt),*) => {
|
||||||
impl<$($lives ,)* T $(, $DimsDecl)* $(, const $D: usize)*> $Op<$Rhs> for $Lhs
|
impl<$($lives ,)* T $(, $DimsDecl)* $(, const $D: usize)*> $Op<$Rhs> for $Lhs
|
||||||
where T: Scalar + Zero + One + ClosedAdd + ClosedMul $($(+ $ScalarBounds)*)*,
|
where T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign $($(+ $ScalarBounds)*)*,
|
||||||
$($(T::Element: $ElementBounds,)*)*
|
$($(T::Element: $ElementBounds,)*)*
|
||||||
$( $ConstraintType: $ConstraintBound $(<$( $ConstraintBoundParams $( = $EqBound )*),*>)* ),*
|
$( $ConstraintType: $ConstraintBound $(<$( $ConstraintBoundParams $( = $EqBound )*),*>)* ),*
|
||||||
{
|
{
|
||||||
|
|
|
@ -15,7 +15,7 @@ use crate::base::allocator::Allocator;
|
||||||
use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
|
use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
|
||||||
use crate::base::iter::{MatrixIter, MatrixIterMut};
|
use crate::base::iter::{MatrixIter, MatrixIterMut};
|
||||||
use crate::base::{Const, DefaultAllocator, OVector, Scalar};
|
use crate::base::{Const, DefaultAllocator, OVector, Scalar};
|
||||||
use simba::scalar::{ClosedAdd, ClosedMul, ClosedSub};
|
use simba::scalar::{ClosedAddAssign, ClosedMulAssign, ClosedSubAssign};
|
||||||
use std::mem::MaybeUninit;
|
use std::mem::MaybeUninit;
|
||||||
|
|
||||||
/// A point in an euclidean space.
|
/// A point in an euclidean space.
|
||||||
|
@ -234,7 +234,7 @@ where
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn lerp(&self, rhs: &OPoint<T, D>, t: T) -> OPoint<T, D>
|
pub fn lerp(&self, rhs: &OPoint<T, D>, t: T) -> OPoint<T, D>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + One + ClosedAdd + ClosedSub + ClosedMul,
|
T: Scalar + Zero + One + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign,
|
||||||
{
|
{
|
||||||
OPoint {
|
OPoint {
|
||||||
coords: self.coords.lerp(&rhs.coords, t),
|
coords: self.coords.lerp(&rhs.coords, t),
|
||||||
|
|
|
@ -15,7 +15,7 @@ use crate::{
|
||||||
Const, DimName, OPoint, OVector, Point1, Point2, Point3, Point4, Point5, Point6, Vector1,
|
Const, DimName, OPoint, OVector, Point1, Point2, Point3, Point4, Point5, Point6, Vector1,
|
||||||
Vector2, Vector3, Vector4, Vector5, Vector6,
|
Vector2, Vector3, Vector4, Vector5, Vector6,
|
||||||
};
|
};
|
||||||
use simba::scalar::{ClosedDiv, SupersetOf};
|
use simba::scalar::{ClosedDivAssign, SupersetOf};
|
||||||
|
|
||||||
use crate::geometry::Point;
|
use crate::geometry::Point;
|
||||||
|
|
||||||
|
@ -108,7 +108,7 @@ where
|
||||||
#[inline]
|
#[inline]
|
||||||
pub fn from_homogeneous(v: OVector<T, DimNameSum<D, U1>>) -> Option<Self>
|
pub fn from_homogeneous(v: OVector<T, DimNameSum<D, U1>>) -> Option<Self>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + One + ClosedDiv,
|
T: Scalar + Zero + One + ClosedDivAssign,
|
||||||
D: DimNameAdd<U1>,
|
D: DimNameAdd<U1>,
|
||||||
DefaultAllocator: Allocator<DimNameSum<D, U1>>,
|
DefaultAllocator: Allocator<DimNameSum<D, U1>>,
|
||||||
{
|
{
|
||||||
|
|
|
@ -1,5 +1,5 @@
|
||||||
use num::{One, Zero};
|
use num::{One, Zero};
|
||||||
use simba::scalar::{ClosedDiv, SubsetOf, SupersetOf};
|
use simba::scalar::{ClosedDivAssign, SubsetOf, SupersetOf};
|
||||||
use simba::simd::PrimitiveSimdValue;
|
use simba::simd::PrimitiveSimdValue;
|
||||||
|
|
||||||
use crate::base::allocator::Allocator;
|
use crate::base::allocator::Allocator;
|
||||||
|
@ -45,7 +45,7 @@ impl<T1, T2, D> SubsetOf<OVector<T2, DimNameSum<D, U1>>> for OPoint<T1, D>
|
||||||
where
|
where
|
||||||
D: DimNameAdd<U1>,
|
D: DimNameAdd<U1>,
|
||||||
T1: Scalar,
|
T1: Scalar,
|
||||||
T2: Scalar + Zero + One + ClosedDiv + SupersetOf<T1>,
|
T2: Scalar + Zero + One + ClosedDivAssign + SupersetOf<T1>,
|
||||||
DefaultAllocator: Allocator<D> + Allocator<DimNameSum<D, U1>>,
|
DefaultAllocator: Allocator<D> + Allocator<DimNameSum<D, U1>>,
|
||||||
// + Allocator<T1, D>
|
// + Allocator<T1, D>
|
||||||
// + Allocator<D>,
|
// + Allocator<D>,
|
||||||
|
|
|
@ -3,7 +3,9 @@ use std::ops::{
|
||||||
Add, AddAssign, Div, DivAssign, Index, IndexMut, Mul, MulAssign, Neg, Sub, SubAssign,
|
Add, AddAssign, Div, DivAssign, Index, IndexMut, Mul, MulAssign, Neg, Sub, SubAssign,
|
||||||
};
|
};
|
||||||
|
|
||||||
use simba::scalar::{ClosedAdd, ClosedDiv, ClosedMul, ClosedNeg, ClosedSub};
|
use simba::scalar::{
|
||||||
|
ClosedAddAssign, ClosedDivAssign, ClosedMulAssign, ClosedNeg, ClosedSubAssign,
|
||||||
|
};
|
||||||
|
|
||||||
use crate::base::constraint::{
|
use crate::base::constraint::{
|
||||||
AreMultipliable, SameNumberOfColumns, SameNumberOfRows, ShapeConstraint,
|
AreMultipliable, SameNumberOfColumns, SameNumberOfRows, ShapeConstraint,
|
||||||
|
@ -79,32 +81,32 @@ where
|
||||||
*/
|
*/
|
||||||
|
|
||||||
// Point - Point
|
// Point - Point
|
||||||
add_sub_impl!(Sub, sub, ClosedSub;
|
add_sub_impl!(Sub, sub, ClosedSubAssign;
|
||||||
(D, U1), (D, U1) -> (D, U1)
|
(D, U1), (D, U1) -> (D, U1)
|
||||||
const; for D; where D: DimName, DefaultAllocator: Allocator<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, ClosedSubAssign;
|
||||||
(D, U1), (D, U1) -> (D, U1)
|
(D, U1), (D, U1) -> (D, U1)
|
||||||
const; for D; where D: DimName, DefaultAllocator: Allocator<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, ClosedSubAssign;
|
||||||
(D, U1), (D, U1) -> (D, U1)
|
(D, U1), (D, U1) -> (D, U1)
|
||||||
const; for D; where D: DimName, DefaultAllocator: Allocator<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, ClosedSubAssign;
|
||||||
(D, U1), (D, U1) -> (D, U1)
|
(D, U1), (D, U1) -> (D, U1)
|
||||||
const; for D; where D: DimName, DefaultAllocator: Allocator<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; );
|
||||||
|
|
||||||
// Point - Vector
|
// Point - Vector
|
||||||
add_sub_impl!(Sub, sub, ClosedSub;
|
add_sub_impl!(Sub, sub, ClosedSubAssign;
|
||||||
(D1, U1), (D2, U1) -> (D1, U1)
|
(D1, U1), (D2, U1) -> (D1, U1)
|
||||||
const;
|
const;
|
||||||
for D1, D2, SB;
|
for D1, D2, SB;
|
||||||
|
@ -112,7 +114,7 @@ add_sub_impl!(Sub, sub, ClosedSub;
|
||||||
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);
|
||||||
|
|
||||||
add_sub_impl!(Sub, sub, ClosedSub;
|
add_sub_impl!(Sub, sub, ClosedSubAssign;
|
||||||
(D1, U1), (D2, U1) -> (D1, U1)
|
(D1, U1), (D2, U1) -> (D1, U1)
|
||||||
const;
|
const;
|
||||||
for D1, D2, SB;
|
for D1, D2, SB;
|
||||||
|
@ -120,7 +122,7 @@ add_sub_impl!(Sub, sub, ClosedSub;
|
||||||
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`.
|
||||||
|
|
||||||
add_sub_impl!(Sub, sub, ClosedSub;
|
add_sub_impl!(Sub, sub, ClosedSubAssign;
|
||||||
(D1, U1), (D2, U1) -> (D1, U1)
|
(D1, U1), (D2, U1) -> (D1, U1)
|
||||||
const;
|
const;
|
||||||
for D1, D2, SB;
|
for D1, D2, SB;
|
||||||
|
@ -128,7 +130,7 @@ add_sub_impl!(Sub, sub, ClosedSub;
|
||||||
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);
|
||||||
|
|
||||||
add_sub_impl!(Sub, sub, ClosedSub;
|
add_sub_impl!(Sub, sub, ClosedSubAssign;
|
||||||
(D1, U1), (D2, U1) -> (D1, U1)
|
(D1, U1), (D2, U1) -> (D1, U1)
|
||||||
const;
|
const;
|
||||||
for D1, D2, SB;
|
for D1, D2, SB;
|
||||||
|
@ -137,7 +139,7 @@ add_sub_impl!(Sub, sub, ClosedSub;
|
||||||
Self::Output::from(self.coords - right); );
|
Self::Output::from(self.coords - right); );
|
||||||
|
|
||||||
// Point + Vector
|
// Point + Vector
|
||||||
add_sub_impl!(Add, add, ClosedAdd;
|
add_sub_impl!(Add, add, ClosedAddAssign;
|
||||||
(D1, U1), (D2, U1) -> (D1, U1)
|
(D1, U1), (D2, U1) -> (D1, U1)
|
||||||
const;
|
const;
|
||||||
for D1, D2, SB;
|
for D1, D2, SB;
|
||||||
|
@ -145,7 +147,7 @@ add_sub_impl!(Add, add, ClosedAdd;
|
||||||
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);
|
||||||
|
|
||||||
add_sub_impl!(Add, add, ClosedAdd;
|
add_sub_impl!(Add, add, ClosedAddAssign;
|
||||||
(D1, U1), (D2, U1) -> (D1, U1)
|
(D1, U1), (D2, U1) -> (D1, U1)
|
||||||
const;
|
const;
|
||||||
for D1, D2, SB;
|
for D1, D2, SB;
|
||||||
|
@ -153,7 +155,7 @@ add_sub_impl!(Add, add, ClosedAdd;
|
||||||
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`.
|
||||||
|
|
||||||
add_sub_impl!(Add, add, ClosedAdd;
|
add_sub_impl!(Add, add, ClosedAddAssign;
|
||||||
(D1, U1), (D2, U1) -> (D1, U1)
|
(D1, U1), (D2, U1) -> (D1, U1)
|
||||||
const;
|
const;
|
||||||
for D1, D2, SB;
|
for D1, D2, SB;
|
||||||
|
@ -161,7 +163,7 @@ add_sub_impl!(Add, add, ClosedAdd;
|
||||||
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);
|
||||||
|
|
||||||
add_sub_impl!(Add, add, ClosedAdd;
|
add_sub_impl!(Add, add, ClosedAddAssign;
|
||||||
(D1, U1), (D2, U1) -> (D1, U1)
|
(D1, U1), (D2, U1) -> (D1, U1)
|
||||||
const;
|
const;
|
||||||
for D1, D2, SB;
|
for D1, D2, SB;
|
||||||
|
@ -199,8 +201,8 @@ macro_rules! op_assign_impl(
|
||||||
);
|
);
|
||||||
|
|
||||||
op_assign_impl!(
|
op_assign_impl!(
|
||||||
AddAssign, add_assign, ClosedAdd;
|
AddAssign, add_assign, ClosedAddAssign;
|
||||||
SubAssign, sub_assign, ClosedSub;
|
SubAssign, sub_assign, ClosedSubAssign;
|
||||||
);
|
);
|
||||||
|
|
||||||
/*
|
/*
|
||||||
|
@ -263,8 +265,8 @@ macro_rules! componentwise_scalarop_impl(
|
||||||
}
|
}
|
||||||
);
|
);
|
||||||
|
|
||||||
componentwise_scalarop_impl!(Mul, mul, ClosedMul; MulAssign, mul_assign);
|
componentwise_scalarop_impl!(Mul, mul, ClosedMulAssign; MulAssign, mul_assign);
|
||||||
componentwise_scalarop_impl!(Div, div, ClosedDiv; DivAssign, div_assign);
|
componentwise_scalarop_impl!(Div, div, ClosedDivAssign; DivAssign, div_assign);
|
||||||
|
|
||||||
macro_rules! left_scalar_mul_impl(
|
macro_rules! left_scalar_mul_impl(
|
||||||
($($T: ty),* $(,)*) => {$(
|
($($T: ty),* $(,)*) => {$(
|
||||||
|
|
|
@ -8,14 +8,10 @@ impl<T: Scalar + SimdValue, const D: usize> SimdValue for Point<T, D>
|
||||||
where
|
where
|
||||||
T::Element: Scalar,
|
T::Element: Scalar,
|
||||||
{
|
{
|
||||||
|
const LANES: usize = T::LANES;
|
||||||
type Element = Point<T::Element, D>;
|
type Element = Point<T::Element, D>;
|
||||||
type SimdBool = T::SimdBool;
|
type SimdBool = T::SimdBool;
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn lanes() -> usize {
|
|
||||||
T::lanes()
|
|
||||||
}
|
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn splat(val: Self::Element) -> Self {
|
fn splat(val: Self::Element) -> Self {
|
||||||
OVector::splat(val.coords).into()
|
OVector::splat(val.coords).into()
|
||||||
|
|
|
@ -8,14 +8,10 @@ impl<T: Scalar + SimdValue> SimdValue for Quaternion<T>
|
||||||
where
|
where
|
||||||
T::Element: Scalar,
|
T::Element: Scalar,
|
||||||
{
|
{
|
||||||
|
const LANES: usize = T::LANES;
|
||||||
type Element = Quaternion<T::Element>;
|
type Element = Quaternion<T::Element>;
|
||||||
type SimdBool = T::SimdBool;
|
type SimdBool = T::SimdBool;
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn lanes() -> usize {
|
|
||||||
T::lanes()
|
|
||||||
}
|
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn splat(val: Self::Element) -> Self {
|
fn splat(val: Self::Element) -> Self {
|
||||||
Vector4::splat(val.coords).into()
|
Vector4::splat(val.coords).into()
|
||||||
|
@ -51,14 +47,10 @@ impl<T: Scalar + SimdValue> SimdValue for UnitQuaternion<T>
|
||||||
where
|
where
|
||||||
T::Element: Scalar,
|
T::Element: Scalar,
|
||||||
{
|
{
|
||||||
|
const LANES: usize = T::LANES;
|
||||||
type Element = UnitQuaternion<T::Element>;
|
type Element = UnitQuaternion<T::Element>;
|
||||||
type SimdBool = T::SimdBool;
|
type SimdBool = T::SimdBool;
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn lanes() -> usize {
|
|
||||||
T::lanes()
|
|
||||||
}
|
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn splat(val: Self::Element) -> Self {
|
fn splat(val: Self::Element) -> Self {
|
||||||
UnitQuaternion::new_unchecked(Quaternion::splat(val.into_inner()))
|
UnitQuaternion::new_unchecked(Quaternion::splat(val.into_inner()))
|
||||||
|
|
|
@ -1,6 +1,6 @@
|
||||||
use num::{One, Zero};
|
use num::{One, Zero};
|
||||||
|
|
||||||
use simba::scalar::{ClosedAdd, ClosedMul, SupersetOf};
|
use simba::scalar::{ClosedAddAssign, ClosedMulAssign, SupersetOf};
|
||||||
|
|
||||||
use crate::base::{SMatrix, Scalar};
|
use crate::base::{SMatrix, Scalar};
|
||||||
|
|
||||||
|
@ -64,7 +64,7 @@ impl<T: Scalar, const D: usize> Rotation<T, D> {
|
||||||
|
|
||||||
impl<T, const D: usize> One for Rotation<T, D>
|
impl<T, const D: usize> One for Rotation<T, D>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + One + ClosedAdd + ClosedMul,
|
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
fn one() -> Self {
|
fn one() -> Self {
|
||||||
|
|
|
@ -20,7 +20,7 @@
|
||||||
use num::{One, Zero};
|
use num::{One, Zero};
|
||||||
use std::ops::{Div, DivAssign, Index, Mul, MulAssign};
|
use std::ops::{Div, DivAssign, Index, Mul, MulAssign};
|
||||||
|
|
||||||
use simba::scalar::{ClosedAdd, ClosedMul};
|
use simba::scalar::{ClosedAddAssign, ClosedMulAssign};
|
||||||
|
|
||||||
use crate::base::allocator::Allocator;
|
use crate::base::allocator::Allocator;
|
||||||
use crate::base::constraint::{AreMultipliable, ShapeConstraint};
|
use crate::base::constraint::{AreMultipliable, ShapeConstraint};
|
||||||
|
|
|
@ -9,14 +9,10 @@ where
|
||||||
T: Scalar + SimdValue,
|
T: Scalar + SimdValue,
|
||||||
T::Element: Scalar,
|
T::Element: Scalar,
|
||||||
{
|
{
|
||||||
|
const LANES: usize = T::LANES;
|
||||||
type Element = Rotation<T::Element, D>;
|
type Element = Rotation<T::Element, D>;
|
||||||
type SimdBool = T::SimdBool;
|
type SimdBool = T::SimdBool;
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn lanes() -> usize {
|
|
||||||
T::lanes()
|
|
||||||
}
|
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn splat(val: Self::Element) -> Self {
|
fn splat(val: Self::Element) -> Self {
|
||||||
Rotation::from_matrix_unchecked(OMatrix::splat(val.into_inner()))
|
Rotation::from_matrix_unchecked(OMatrix::splat(val.into_inner()))
|
||||||
|
|
|
@ -10,8 +10,8 @@ use crate::base::allocator::Allocator;
|
||||||
use crate::base::dimension::{DimNameAdd, DimNameSum, U1};
|
use crate::base::dimension::{DimNameAdd, DimNameSum, U1};
|
||||||
use crate::base::storage::Owned;
|
use crate::base::storage::Owned;
|
||||||
use crate::base::{Const, DefaultAllocator, OMatrix, OVector, SVector, Scalar};
|
use crate::base::{Const, DefaultAllocator, OMatrix, OVector, SVector, Scalar};
|
||||||
use crate::ClosedDiv;
|
use crate::ClosedDivAssign;
|
||||||
use crate::ClosedMul;
|
use crate::ClosedMulAssign;
|
||||||
|
|
||||||
use crate::geometry::Point;
|
use crate::geometry::Point;
|
||||||
|
|
||||||
|
@ -121,7 +121,7 @@ impl<T: Scalar, const D: usize> Scale<T, D> {
|
||||||
#[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<Scale<T, D>>
|
pub fn try_inverse(&self) -> Option<Scale<T, D>>
|
||||||
where
|
where
|
||||||
T: ClosedDiv + One + Zero,
|
T: ClosedDivAssign + One + Zero,
|
||||||
{
|
{
|
||||||
for i in 0..D {
|
for i in 0..D {
|
||||||
if self.vector[i] == T::zero() {
|
if self.vector[i] == T::zero() {
|
||||||
|
@ -156,7 +156,7 @@ impl<T: Scalar, const D: usize> Scale<T, D> {
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub unsafe fn inverse_unchecked(&self) -> Scale<T, D>
|
pub unsafe fn inverse_unchecked(&self) -> Scale<T, D>
|
||||||
where
|
where
|
||||||
T: ClosedDiv + One,
|
T: ClosedDivAssign + One,
|
||||||
{
|
{
|
||||||
self.vector.map(|e| T::one() / e).into()
|
self.vector.map(|e| T::one() / e).into()
|
||||||
}
|
}
|
||||||
|
@ -184,7 +184,7 @@ impl<T: Scalar, const D: usize> Scale<T, D> {
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn pseudo_inverse(&self) -> Scale<T, D>
|
pub fn pseudo_inverse(&self) -> Scale<T, D>
|
||||||
where
|
where
|
||||||
T: ClosedDiv + One + Zero,
|
T: ClosedDivAssign + One + Zero,
|
||||||
{
|
{
|
||||||
self.vector
|
self.vector
|
||||||
.map(|e| {
|
.map(|e| {
|
||||||
|
@ -260,7 +260,7 @@ impl<T: Scalar, const D: usize> Scale<T, D> {
|
||||||
#[inline]
|
#[inline]
|
||||||
pub fn try_inverse_mut(&mut self) -> bool
|
pub fn try_inverse_mut(&mut self) -> bool
|
||||||
where
|
where
|
||||||
T: ClosedDiv + One + Zero,
|
T: ClosedDivAssign + One + Zero,
|
||||||
{
|
{
|
||||||
if let Some(v) = self.try_inverse() {
|
if let Some(v) = self.try_inverse() {
|
||||||
self.vector = v.vector;
|
self.vector = v.vector;
|
||||||
|
@ -271,7 +271,7 @@ impl<T: Scalar, const D: usize> Scale<T, D> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T: Scalar + ClosedMul, const D: usize> Scale<T, D> {
|
impl<T: Scalar + ClosedMulAssign, const D: usize> Scale<T, D> {
|
||||||
/// Translate the given point.
|
/// Translate the given point.
|
||||||
///
|
///
|
||||||
/// This is the same as the multiplication `self * pt`.
|
/// This is the same as the multiplication `self * pt`.
|
||||||
|
@ -290,7 +290,7 @@ impl<T: Scalar + ClosedMul, const D: usize> Scale<T, D> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T: Scalar + ClosedDiv + ClosedMul + One + Zero, const D: usize> Scale<T, D> {
|
impl<T: Scalar + ClosedDivAssign + ClosedMulAssign + One + Zero, const D: usize> Scale<T, D> {
|
||||||
/// Translate the given point by the inverse of this Scale.
|
/// Translate the given point by the inverse of this Scale.
|
||||||
///
|
///
|
||||||
/// # Example
|
/// # Example
|
||||||
|
|
|
@ -10,7 +10,7 @@ use rand::{
|
||||||
Rng,
|
Rng,
|
||||||
};
|
};
|
||||||
|
|
||||||
use simba::scalar::{ClosedMul, SupersetOf};
|
use simba::scalar::{ClosedMulAssign, SupersetOf};
|
||||||
|
|
||||||
use crate::base::{SVector, Scalar};
|
use crate::base::{SVector, Scalar};
|
||||||
use crate::geometry::Scale;
|
use crate::geometry::Scale;
|
||||||
|
@ -55,7 +55,7 @@ impl<T: Scalar, const D: usize> Scale<T, D> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T: Scalar + One + ClosedMul, const D: usize> One for Scale<T, D> {
|
impl<T: Scalar + One + ClosedMulAssign, const D: usize> One for Scale<T, D> {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn one() -> Self {
|
fn one() -> Self {
|
||||||
Self::identity()
|
Self::identity()
|
||||||
|
|
|
@ -1,6 +1,6 @@
|
||||||
use std::ops::{Mul, MulAssign};
|
use std::ops::{Mul, MulAssign};
|
||||||
|
|
||||||
use simba::scalar::ClosedMul;
|
use simba::scalar::ClosedMulAssign;
|
||||||
|
|
||||||
use crate::base::constraint::{SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
|
use crate::base::constraint::{SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
|
||||||
use crate::base::dimension::U1;
|
use crate::base::dimension::U1;
|
||||||
|
@ -9,117 +9,117 @@ use crate::base::{Const, SVector, Scalar};
|
||||||
use crate::geometry::{Point, Scale};
|
use crate::geometry::{Point, Scale};
|
||||||
|
|
||||||
// Scale × Scale
|
// Scale × Scale
|
||||||
add_sub_impl!(Mul, mul, ClosedMul;
|
add_sub_impl!(Mul, mul, ClosedMulAssign;
|
||||||
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
||||||
const D; for; where;
|
const D; for; where;
|
||||||
self: &'a Scale<T, D>, right: &'b Scale<T, D>, Output = Scale<T, D>;
|
self: &'a Scale<T, D>, right: &'b Scale<T, D>, Output = Scale<T, D>;
|
||||||
Scale::from(self.vector.component_mul(&right.vector));
|
Scale::from(self.vector.component_mul(&right.vector));
|
||||||
'a, 'b);
|
'a, 'b);
|
||||||
|
|
||||||
add_sub_impl!(Mul, mul, ClosedMul;
|
add_sub_impl!(Mul, mul, ClosedMulAssign;
|
||||||
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
||||||
const D; for; where;
|
const D; for; where;
|
||||||
self: &'a Scale<T, D>, right: Scale<T, D>, Output = Scale<T, D>;
|
self: &'a Scale<T, D>, right: Scale<T, D>, Output = Scale<T, D>;
|
||||||
Scale::from(self.vector.component_mul(&right.vector));
|
Scale::from(self.vector.component_mul(&right.vector));
|
||||||
'a);
|
'a);
|
||||||
|
|
||||||
add_sub_impl!(Mul, mul, ClosedMul;
|
add_sub_impl!(Mul, mul, ClosedMulAssign;
|
||||||
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
||||||
const D; for; where;
|
const D; for; where;
|
||||||
self: Scale<T, D>, right: &'b Scale<T, D>, Output = Scale<T, D>;
|
self: Scale<T, D>, right: &'b Scale<T, D>, Output = Scale<T, D>;
|
||||||
Scale::from(self.vector.component_mul(&right.vector));
|
Scale::from(self.vector.component_mul(&right.vector));
|
||||||
'b);
|
'b);
|
||||||
|
|
||||||
add_sub_impl!(Mul, mul, ClosedMul;
|
add_sub_impl!(Mul, mul, ClosedMulAssign;
|
||||||
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
||||||
const D; for; where;
|
const D; for; where;
|
||||||
self: Scale<T, D>, right: Scale<T, D>, Output = Scale<T, D>;
|
self: Scale<T, D>, right: Scale<T, D>, Output = Scale<T, D>;
|
||||||
Scale::from(self.vector.component_mul(&right.vector)); );
|
Scale::from(self.vector.component_mul(&right.vector)); );
|
||||||
|
|
||||||
// Scale × scalar
|
// Scale × scalar
|
||||||
add_sub_impl!(Mul, mul, ClosedMul;
|
add_sub_impl!(Mul, mul, ClosedMulAssign;
|
||||||
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
||||||
const D; for; where;
|
const D; for; where;
|
||||||
self: &'a Scale<T, D>, right: T, Output = Scale<T, D>;
|
self: &'a Scale<T, D>, right: T, Output = Scale<T, D>;
|
||||||
Scale::from(&self.vector * right);
|
Scale::from(&self.vector * right);
|
||||||
'a);
|
'a);
|
||||||
|
|
||||||
add_sub_impl!(Mul, mul, ClosedMul;
|
add_sub_impl!(Mul, mul, ClosedMulAssign;
|
||||||
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
||||||
const D; for; where;
|
const D; for; where;
|
||||||
self: Scale<T, D>, right: T, Output = Scale<T, D>;
|
self: Scale<T, D>, right: T, Output = Scale<T, D>;
|
||||||
Scale::from(self.vector * right); );
|
Scale::from(self.vector * right); );
|
||||||
|
|
||||||
// Scale × Point
|
// Scale × Point
|
||||||
add_sub_impl!(Mul, mul, ClosedMul;
|
add_sub_impl!(Mul, mul, ClosedMulAssign;
|
||||||
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
||||||
const D; for; where;
|
const D; for; where;
|
||||||
self: &'a Scale<T, D>, right: &'b Point<T, D>, Output = Point<T, D>;
|
self: &'a Scale<T, D>, right: &'b Point<T, D>, Output = Point<T, D>;
|
||||||
Point::from(self.vector.component_mul(&right.coords));
|
Point::from(self.vector.component_mul(&right.coords));
|
||||||
'a, 'b);
|
'a, 'b);
|
||||||
|
|
||||||
add_sub_impl!(Mul, mul, ClosedMul;
|
add_sub_impl!(Mul, mul, ClosedMulAssign;
|
||||||
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
||||||
const D; for; where;
|
const D; for; where;
|
||||||
self: &'a Scale<T, D>, right: Point<T, D>, Output = Point<T, D>;
|
self: &'a Scale<T, D>, right: Point<T, D>, Output = Point<T, D>;
|
||||||
Point::from(self.vector.component_mul(&right.coords));
|
Point::from(self.vector.component_mul(&right.coords));
|
||||||
'a);
|
'a);
|
||||||
|
|
||||||
add_sub_impl!(Mul, mul, ClosedMul;
|
add_sub_impl!(Mul, mul, ClosedMulAssign;
|
||||||
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
||||||
const D; for; where;
|
const D; for; where;
|
||||||
self: Scale<T, D>, right: &'b Point<T, D>, Output = Point<T, D>;
|
self: Scale<T, D>, right: &'b Point<T, D>, Output = Point<T, D>;
|
||||||
Point::from(self.vector.component_mul(&right.coords));
|
Point::from(self.vector.component_mul(&right.coords));
|
||||||
'b);
|
'b);
|
||||||
|
|
||||||
add_sub_impl!(Mul, mul, ClosedMul;
|
add_sub_impl!(Mul, mul, ClosedMulAssign;
|
||||||
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
||||||
const D; for; where;
|
const D; for; where;
|
||||||
self: Scale<T, D>, right: Point<T, D>, Output = Point<T, D>;
|
self: Scale<T, D>, right: Point<T, D>, Output = Point<T, D>;
|
||||||
Point::from(self.vector.component_mul(&right.coords)); );
|
Point::from(self.vector.component_mul(&right.coords)); );
|
||||||
|
|
||||||
// Scale * Vector
|
// Scale * Vector
|
||||||
add_sub_impl!(Mul, mul, ClosedMul;
|
add_sub_impl!(Mul, mul, ClosedMulAssign;
|
||||||
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
||||||
const D; for; where;
|
const D; for; where;
|
||||||
self: &'a Scale<T, D>, right: &'b SVector<T, D>, Output = SVector<T, D>;
|
self: &'a Scale<T, D>, right: &'b SVector<T, D>, Output = SVector<T, D>;
|
||||||
self.vector.component_mul(right);
|
self.vector.component_mul(right);
|
||||||
'a, 'b);
|
'a, 'b);
|
||||||
|
|
||||||
add_sub_impl!(Mul, mul, ClosedMul;
|
add_sub_impl!(Mul, mul, ClosedMulAssign;
|
||||||
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
||||||
const D; for; where;
|
const D; for; where;
|
||||||
self: &'a Scale<T, D>, right: SVector<T, D>, Output = SVector<T, D>;
|
self: &'a Scale<T, D>, right: SVector<T, D>, Output = SVector<T, D>;
|
||||||
self.vector.component_mul(&right);
|
self.vector.component_mul(&right);
|
||||||
'a);
|
'a);
|
||||||
|
|
||||||
add_sub_impl!(Mul, mul, ClosedMul;
|
add_sub_impl!(Mul, mul, ClosedMulAssign;
|
||||||
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
||||||
const D; for; where;
|
const D; for; where;
|
||||||
self: Scale<T, D>, right: &'b SVector<T, D>, Output = SVector<T, D>;
|
self: Scale<T, D>, right: &'b SVector<T, D>, Output = SVector<T, D>;
|
||||||
self.vector.component_mul(right);
|
self.vector.component_mul(right);
|
||||||
'b);
|
'b);
|
||||||
|
|
||||||
add_sub_impl!(Mul, mul, ClosedMul;
|
add_sub_impl!(Mul, mul, ClosedMulAssign;
|
||||||
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
||||||
const D; for; where;
|
const D; for; where;
|
||||||
self: Scale<T, D>, right: SVector<T, D>, Output = SVector<T, D>;
|
self: Scale<T, D>, right: SVector<T, D>, Output = SVector<T, D>;
|
||||||
self.vector.component_mul(&right); );
|
self.vector.component_mul(&right); );
|
||||||
|
|
||||||
// Scale *= Scale
|
// Scale *= Scale
|
||||||
add_sub_assign_impl!(MulAssign, mul_assign, ClosedMul;
|
add_sub_assign_impl!(MulAssign, mul_assign, ClosedMulAssign;
|
||||||
const D;
|
const D;
|
||||||
self: Scale<T, D>, right: &'b Scale<T, D>;
|
self: Scale<T, D>, right: &'b Scale<T, D>;
|
||||||
self.vector.component_mul_assign(&right.vector);
|
self.vector.component_mul_assign(&right.vector);
|
||||||
'b);
|
'b);
|
||||||
|
|
||||||
add_sub_assign_impl!(MulAssign, mul_assign, ClosedMul;
|
add_sub_assign_impl!(MulAssign, mul_assign, ClosedMulAssign;
|
||||||
const D;
|
const D;
|
||||||
self: Scale<T, D>, right: Scale<T, D>;
|
self: Scale<T, D>, right: Scale<T, D>;
|
||||||
self.vector.component_mul_assign(&right.vector); );
|
self.vector.component_mul_assign(&right.vector); );
|
||||||
|
|
||||||
// Scale ×= scalar
|
// Scale ×= scalar
|
||||||
add_sub_assign_impl!(MulAssign, mul_assign, ClosedMul;
|
add_sub_assign_impl!(MulAssign, mul_assign, ClosedMulAssign;
|
||||||
const D;
|
const D;
|
||||||
self: Scale<T, D>, right: T;
|
self: Scale<T, D>, right: T;
|
||||||
self.vector *= right; );
|
self.vector *= right; );
|
||||||
|
|
|
@ -9,14 +9,10 @@ impl<T: Scalar + SimdValue, const D: usize> SimdValue for Scale<T, D>
|
||||||
where
|
where
|
||||||
T::Element: Scalar,
|
T::Element: Scalar,
|
||||||
{
|
{
|
||||||
|
const LANES: usize = T::LANES;
|
||||||
type Element = Scale<T::Element, D>;
|
type Element = Scale<T::Element, D>;
|
||||||
type SimdBool = T::SimdBool;
|
type SimdBool = T::SimdBool;
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn lanes() -> usize {
|
|
||||||
T::lanes()
|
|
||||||
}
|
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn splat(val: Self::Element) -> Self {
|
fn splat(val: Self::Element) -> Self {
|
||||||
OVector::splat(val.vector).into()
|
OVector::splat(val.vector).into()
|
||||||
|
|
|
@ -4,7 +4,7 @@
|
||||||
use num::{One, Zero};
|
use num::{One, Zero};
|
||||||
use std::ops::{Div, DivAssign, Mul, MulAssign};
|
use std::ops::{Div, DivAssign, Mul, MulAssign};
|
||||||
|
|
||||||
use simba::scalar::{ClosedAdd, ClosedMul};
|
use simba::scalar::{ClosedAddAssign, ClosedMulAssign};
|
||||||
use simba::simd::SimdRealField;
|
use simba::simd::SimdRealField;
|
||||||
|
|
||||||
use crate::base::{SVector, Scalar};
|
use crate::base::{SVector, Scalar};
|
||||||
|
|
|
@ -8,14 +8,10 @@ where
|
||||||
R: SimdValue<SimdBool = T::SimdBool> + AbstractRotation<T, D>,
|
R: SimdValue<SimdBool = T::SimdBool> + AbstractRotation<T, D>,
|
||||||
R::Element: AbstractRotation<T::Element, D>,
|
R::Element: AbstractRotation<T::Element, D>,
|
||||||
{
|
{
|
||||||
|
const LANES: usize = T::LANES;
|
||||||
type Element = Similarity<T::Element, R::Element, D>;
|
type Element = Similarity<T::Element, R::Element, D>;
|
||||||
type SimdBool = T::SimdBool;
|
type SimdBool = T::SimdBool;
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn lanes() -> usize {
|
|
||||||
T::lanes()
|
|
||||||
}
|
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn splat(val: Self::Element) -> Self {
|
fn splat(val: Self::Element) -> Self {
|
||||||
let scaling = T::splat(val.scaling());
|
let scaling = T::splat(val.scaling());
|
||||||
|
|
|
@ -4,7 +4,7 @@
|
||||||
use num::{One, Zero};
|
use num::{One, Zero};
|
||||||
use std::ops::{Div, DivAssign, Index, IndexMut, Mul, MulAssign};
|
use std::ops::{Div, DivAssign, Index, IndexMut, Mul, MulAssign};
|
||||||
|
|
||||||
use simba::scalar::{ClosedAdd, ClosedMul, RealField, SubsetOf};
|
use simba::scalar::{ClosedAddAssign, ClosedMulAssign, RealField, SubsetOf};
|
||||||
|
|
||||||
use crate::base::allocator::Allocator;
|
use crate::base::allocator::Allocator;
|
||||||
use crate::base::dimension::{DimNameAdd, DimNameSum, U1};
|
use crate::base::dimension::{DimNameAdd, DimNameSum, U1};
|
||||||
|
|
|
@ -14,14 +14,10 @@ where
|
||||||
Const<D>: DimNameAdd<U1>,
|
Const<D>: DimNameAdd<U1>,
|
||||||
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
|
||||||
{
|
{
|
||||||
|
const LANES: usize = T::LANES;
|
||||||
type Element = Transform<T::Element, C, D>;
|
type Element = Transform<T::Element, C, D>;
|
||||||
type SimdBool = T::SimdBool;
|
type SimdBool = T::SimdBool;
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn lanes() -> usize {
|
|
||||||
T::lanes()
|
|
||||||
}
|
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn splat(val: Self::Element) -> Self {
|
fn splat(val: Self::Element) -> Self {
|
||||||
Transform::from_matrix_unchecked(OMatrix::splat(val.into_inner()))
|
Transform::from_matrix_unchecked(OMatrix::splat(val.into_inner()))
|
||||||
|
|
|
@ -6,7 +6,7 @@ use std::hash;
|
||||||
#[cfg(feature = "serde-serialize-no-std")]
|
#[cfg(feature = "serde-serialize-no-std")]
|
||||||
use serde::{Deserialize, Deserializer, Serialize, Serializer};
|
use serde::{Deserialize, Deserializer, Serialize, Serializer};
|
||||||
|
|
||||||
use simba::scalar::{ClosedAdd, ClosedNeg, ClosedSub};
|
use simba::scalar::{ClosedAddAssign, ClosedNeg, ClosedSubAssign};
|
||||||
|
|
||||||
use crate::base::allocator::Allocator;
|
use crate::base::allocator::Allocator;
|
||||||
use crate::base::dimension::{DimNameAdd, DimNameSum, U1};
|
use crate::base::dimension::{DimNameAdd, DimNameSum, U1};
|
||||||
|
@ -188,7 +188,7 @@ impl<T: Scalar, const D: usize> Translation<T, D> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T: Scalar + ClosedAdd, const D: usize> Translation<T, D> {
|
impl<T: Scalar + ClosedAddAssign, const D: usize> Translation<T, D> {
|
||||||
/// Translate the given point.
|
/// Translate the given point.
|
||||||
///
|
///
|
||||||
/// This is the same as the multiplication `self * pt`.
|
/// This is the same as the multiplication `self * pt`.
|
||||||
|
@ -207,7 +207,7 @@ impl<T: Scalar + ClosedAdd, const D: usize> Translation<T, D> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T: Scalar + ClosedSub, const D: usize> Translation<T, D> {
|
impl<T: Scalar + ClosedSubAssign, const D: usize> Translation<T, D> {
|
||||||
/// Translate the given point by the inverse of this translation.
|
/// Translate the given point by the inverse of this translation.
|
||||||
///
|
///
|
||||||
/// # Example
|
/// # Example
|
||||||
|
|
|
@ -10,7 +10,7 @@ use rand::{
|
||||||
Rng,
|
Rng,
|
||||||
};
|
};
|
||||||
|
|
||||||
use simba::scalar::{ClosedAdd, SupersetOf};
|
use simba::scalar::{ClosedAddAssign, SupersetOf};
|
||||||
|
|
||||||
use crate::base::{SVector, Scalar};
|
use crate::base::{SVector, Scalar};
|
||||||
use crate::geometry::Translation;
|
use crate::geometry::Translation;
|
||||||
|
@ -61,7 +61,7 @@ impl<T: Scalar, const D: usize> Translation<T, D> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T: Scalar + Zero + ClosedAdd, const D: usize> One for Translation<T, D> {
|
impl<T: Scalar + Zero + ClosedAddAssign, const D: usize> One for Translation<T, D> {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn one() -> Self {
|
fn one() -> Self {
|
||||||
Self::identity()
|
Self::identity()
|
||||||
|
|
|
@ -1,6 +1,6 @@
|
||||||
use std::ops::{Div, DivAssign, Mul, MulAssign};
|
use std::ops::{Div, DivAssign, Mul, MulAssign};
|
||||||
|
|
||||||
use simba::scalar::{ClosedAdd, ClosedSub};
|
use simba::scalar::{ClosedAddAssign, ClosedSubAssign};
|
||||||
|
|
||||||
use crate::base::constraint::{SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
|
use crate::base::constraint::{SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
|
||||||
use crate::base::dimension::U1;
|
use crate::base::dimension::U1;
|
||||||
|
@ -9,28 +9,28 @@ use crate::base::{Const, Scalar};
|
||||||
use crate::geometry::{Point, Translation};
|
use crate::geometry::{Point, Translation};
|
||||||
|
|
||||||
// Translation × Translation
|
// Translation × Translation
|
||||||
add_sub_impl!(Mul, mul, ClosedAdd;
|
add_sub_impl!(Mul, mul, ClosedAddAssign;
|
||||||
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
||||||
const D; for; where;
|
const D; for; where;
|
||||||
self: &'a Translation<T, D>, right: &'b Translation<T, D>, Output = Translation<T, D>;
|
self: &'a Translation<T, D>, right: &'b Translation<T, D>, Output = Translation<T, D>;
|
||||||
#[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(&self.vector + &right.vector) };
|
#[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(&self.vector + &right.vector) };
|
||||||
'a, 'b);
|
'a, 'b);
|
||||||
|
|
||||||
add_sub_impl!(Mul, mul, ClosedAdd;
|
add_sub_impl!(Mul, mul, ClosedAddAssign;
|
||||||
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
||||||
const D; for; where;
|
const D; for; where;
|
||||||
self: &'a Translation<T, D>, right: Translation<T, D>, Output = Translation<T, D>;
|
self: &'a Translation<T, D>, right: Translation<T, D>, Output = Translation<T, D>;
|
||||||
#[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(&self.vector + right.vector) };
|
#[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(&self.vector + right.vector) };
|
||||||
'a);
|
'a);
|
||||||
|
|
||||||
add_sub_impl!(Mul, mul, ClosedAdd;
|
add_sub_impl!(Mul, mul, ClosedAddAssign;
|
||||||
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
||||||
const D; for; where;
|
const D; for; where;
|
||||||
self: Translation<T, D>, right: &'b Translation<T, D>, Output = Translation<T, D>;
|
self: Translation<T, D>, right: &'b Translation<T, D>, Output = Translation<T, D>;
|
||||||
#[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(self.vector + &right.vector) };
|
#[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(self.vector + &right.vector) };
|
||||||
'b);
|
'b);
|
||||||
|
|
||||||
add_sub_impl!(Mul, mul, ClosedAdd;
|
add_sub_impl!(Mul, mul, ClosedAddAssign;
|
||||||
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
||||||
const D; for; where;
|
const D; for; where;
|
||||||
self: Translation<T, D>, right: Translation<T, D>, Output = Translation<T, D>;
|
self: Translation<T, D>, right: Translation<T, D>, Output = Translation<T, D>;
|
||||||
|
@ -38,28 +38,28 @@ add_sub_impl!(Mul, mul, ClosedAdd;
|
||||||
|
|
||||||
// Translation ÷ Translation
|
// Translation ÷ Translation
|
||||||
// TODO: instead of calling inverse explicitly, could we just add a `mul_tr` or `mul_inv` method?
|
// TODO: instead of calling inverse explicitly, could we just add a `mul_tr` or `mul_inv` method?
|
||||||
add_sub_impl!(Div, div, ClosedSub;
|
add_sub_impl!(Div, div, ClosedSubAssign;
|
||||||
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
||||||
const D; for; where;
|
const D; for; where;
|
||||||
self: &'a Translation<T, D>, right: &'b Translation<T, D>, Output = Translation<T, D>;
|
self: &'a Translation<T, D>, right: &'b Translation<T, D>, Output = Translation<T, D>;
|
||||||
#[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(&self.vector - &right.vector) };
|
#[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(&self.vector - &right.vector) };
|
||||||
'a, 'b);
|
'a, 'b);
|
||||||
|
|
||||||
add_sub_impl!(Div, div, ClosedSub;
|
add_sub_impl!(Div, div, ClosedSubAssign;
|
||||||
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
||||||
const D; for; where;
|
const D; for; where;
|
||||||
self: &'a Translation<T, D>, right: Translation<T, D>, Output = Translation<T, D>;
|
self: &'a Translation<T, D>, right: Translation<T, D>, Output = Translation<T, D>;
|
||||||
#[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(&self.vector - right.vector) };
|
#[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(&self.vector - right.vector) };
|
||||||
'a);
|
'a);
|
||||||
|
|
||||||
add_sub_impl!(Div, div, ClosedSub;
|
add_sub_impl!(Div, div, ClosedSubAssign;
|
||||||
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
||||||
const D; for; where;
|
const D; for; where;
|
||||||
self: Translation<T, D>, right: &'b Translation<T, D>, Output = Translation<T, D>;
|
self: Translation<T, D>, right: &'b Translation<T, D>, Output = Translation<T, D>;
|
||||||
#[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(self.vector - &right.vector) };
|
#[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(self.vector - &right.vector) };
|
||||||
'b);
|
'b);
|
||||||
|
|
||||||
add_sub_impl!(Div, div, ClosedSub;
|
add_sub_impl!(Div, div, ClosedSubAssign;
|
||||||
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
||||||
const D; for; where;
|
const D; for; where;
|
||||||
self: Translation<T, D>, right: Translation<T, D>, Output = Translation<T, D>;
|
self: Translation<T, D>, right: Translation<T, D>, Output = Translation<T, D>;
|
||||||
|
@ -68,52 +68,52 @@ add_sub_impl!(Div, div, ClosedSub;
|
||||||
// Translation × Point
|
// Translation × Point
|
||||||
// TODO: we don't handle properly non-zero origins here. Do we want this to be the intended
|
// TODO: we don't handle properly non-zero origins here. Do we want this to be the intended
|
||||||
// behavior?
|
// behavior?
|
||||||
add_sub_impl!(Mul, mul, ClosedAdd;
|
add_sub_impl!(Mul, mul, ClosedAddAssign;
|
||||||
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
||||||
const D; for; where;
|
const D; for; where;
|
||||||
self: &'a Translation<T, D>, right: &'b Point<T, D>, Output = Point<T, D>;
|
self: &'a Translation<T, D>, right: &'b Point<T, D>, Output = Point<T, D>;
|
||||||
#[allow(clippy::suspicious_arithmetic_impl)] { right + &self.vector };
|
#[allow(clippy::suspicious_arithmetic_impl)] { right + &self.vector };
|
||||||
'a, 'b);
|
'a, 'b);
|
||||||
|
|
||||||
add_sub_impl!(Mul, mul, ClosedAdd;
|
add_sub_impl!(Mul, mul, ClosedAddAssign;
|
||||||
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
||||||
const D; for; where;
|
const D; for; where;
|
||||||
self: &'a Translation<T, D>, right: Point<T, D>, Output = Point<T, D>;
|
self: &'a Translation<T, D>, right: Point<T, D>, Output = Point<T, D>;
|
||||||
#[allow(clippy::suspicious_arithmetic_impl)] { right + &self.vector };
|
#[allow(clippy::suspicious_arithmetic_impl)] { right + &self.vector };
|
||||||
'a);
|
'a);
|
||||||
|
|
||||||
add_sub_impl!(Mul, mul, ClosedAdd;
|
add_sub_impl!(Mul, mul, ClosedAddAssign;
|
||||||
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
||||||
const D; for; where;
|
const D; for; where;
|
||||||
self: Translation<T, D>, right: &'b Point<T, D>, Output = Point<T, D>;
|
self: Translation<T, D>, right: &'b Point<T, D>, Output = Point<T, D>;
|
||||||
#[allow(clippy::suspicious_arithmetic_impl)] { right + self.vector };
|
#[allow(clippy::suspicious_arithmetic_impl)] { right + self.vector };
|
||||||
'b);
|
'b);
|
||||||
|
|
||||||
add_sub_impl!(Mul, mul, ClosedAdd;
|
add_sub_impl!(Mul, mul, ClosedAddAssign;
|
||||||
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
|
||||||
const D; for; where;
|
const D; for; where;
|
||||||
self: Translation<T, D>, right: Point<T, D>, Output = Point<T, D>;
|
self: Translation<T, D>, right: Point<T, D>, Output = Point<T, D>;
|
||||||
#[allow(clippy::suspicious_arithmetic_impl)] { right + self.vector }; );
|
#[allow(clippy::suspicious_arithmetic_impl)] { right + self.vector }; );
|
||||||
|
|
||||||
// Translation *= Translation
|
// Translation *= Translation
|
||||||
add_sub_assign_impl!(MulAssign, mul_assign, ClosedAdd;
|
add_sub_assign_impl!(MulAssign, mul_assign, ClosedAddAssign;
|
||||||
const D;
|
const D;
|
||||||
self: Translation<T, D>, right: &'b Translation<T, D>;
|
self: Translation<T, D>, right: &'b Translation<T, D>;
|
||||||
#[allow(clippy::suspicious_op_assign_impl)] { self.vector += &right.vector };
|
#[allow(clippy::suspicious_op_assign_impl)] { self.vector += &right.vector };
|
||||||
'b);
|
'b);
|
||||||
|
|
||||||
add_sub_assign_impl!(MulAssign, mul_assign, ClosedAdd;
|
add_sub_assign_impl!(MulAssign, mul_assign, ClosedAddAssign;
|
||||||
const D;
|
const D;
|
||||||
self: Translation<T, D>, right: Translation<T, D>;
|
self: Translation<T, D>, right: Translation<T, D>;
|
||||||
#[allow(clippy::suspicious_op_assign_impl)] { self.vector += right.vector }; );
|
#[allow(clippy::suspicious_op_assign_impl)] { self.vector += right.vector }; );
|
||||||
|
|
||||||
add_sub_assign_impl!(DivAssign, div_assign, ClosedSub;
|
add_sub_assign_impl!(DivAssign, div_assign, ClosedSubAssign;
|
||||||
const D;
|
const D;
|
||||||
self: Translation<T, D>, right: &'b Translation<T, D>;
|
self: Translation<T, D>, right: &'b Translation<T, D>;
|
||||||
#[allow(clippy::suspicious_op_assign_impl)] { self.vector -= &right.vector };
|
#[allow(clippy::suspicious_op_assign_impl)] { self.vector -= &right.vector };
|
||||||
'b);
|
'b);
|
||||||
|
|
||||||
add_sub_assign_impl!(DivAssign, div_assign, ClosedSub;
|
add_sub_assign_impl!(DivAssign, div_assign, ClosedSubAssign;
|
||||||
const D;
|
const D;
|
||||||
self: Translation<T, D>, right: Translation<T, D>;
|
self: Translation<T, D>, right: Translation<T, D>;
|
||||||
#[allow(clippy::suspicious_op_assign_impl)] { self.vector -= right.vector }; );
|
#[allow(clippy::suspicious_op_assign_impl)] { self.vector -= right.vector }; );
|
||||||
|
|
|
@ -9,14 +9,10 @@ impl<T: Scalar + SimdValue, const D: usize> SimdValue for Translation<T, D>
|
||||||
where
|
where
|
||||||
T::Element: Scalar,
|
T::Element: Scalar,
|
||||||
{
|
{
|
||||||
|
const LANES: usize = T::LANES;
|
||||||
type Element = Translation<T::Element, D>;
|
type Element = Translation<T::Element, D>;
|
||||||
type SimdBool = T::SimdBool;
|
type SimdBool = T::SimdBool;
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn lanes() -> usize {
|
|
||||||
T::lanes()
|
|
||||||
}
|
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn splat(val: Self::Element) -> Self {
|
fn splat(val: Self::Element) -> Self {
|
||||||
OVector::splat(val.vector).into()
|
OVector::splat(val.vector).into()
|
||||||
|
|
|
@ -10,14 +10,10 @@ impl<T: SimdRealField> SimdValue for UnitComplex<T>
|
||||||
where
|
where
|
||||||
T::Element: SimdRealField,
|
T::Element: SimdRealField,
|
||||||
{
|
{
|
||||||
|
const LANES: usize = T::LANES;
|
||||||
type Element = UnitComplex<T::Element>;
|
type Element = UnitComplex<T::Element>;
|
||||||
type SimdBool = T::SimdBool;
|
type SimdBool = T::SimdBool;
|
||||||
|
|
||||||
#[inline]
|
|
||||||
fn lanes() -> usize {
|
|
||||||
T::lanes()
|
|
||||||
}
|
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn splat(val: Self::Element) -> Self {
|
fn splat(val: Self::Element) -> Self {
|
||||||
Unit::new_unchecked(Complex::splat(val.into_inner()))
|
Unit::new_unchecked(Complex::splat(val.into_inner()))
|
||||||
|
|
|
@ -165,7 +165,8 @@ use num::{One, Signed, Zero};
|
||||||
use base::allocator::Allocator;
|
use base::allocator::Allocator;
|
||||||
pub use num_complex::Complex;
|
pub use num_complex::Complex;
|
||||||
pub use simba::scalar::{
|
pub use simba::scalar::{
|
||||||
ClosedAdd, ClosedDiv, ClosedMul, ClosedSub, ComplexField, Field, RealField,
|
ClosedAddAssign, ClosedDivAssign, ClosedMulAssign, ClosedSubAssign, ComplexField, Field,
|
||||||
|
RealField,
|
||||||
};
|
};
|
||||||
pub use simba::simd::{SimdBool, SimdComplexField, SimdPartialOrd, SimdRealField, SimdValue};
|
pub use simba::simd::{SimdBool, SimdComplexField, SimdPartialOrd, SimdRealField, SimdValue};
|
||||||
|
|
||||||
|
@ -206,7 +207,7 @@ pub fn zero<T: Zero>() -> T {
|
||||||
#[inline]
|
#[inline]
|
||||||
pub fn wrap<T>(mut val: T, min: T, max: T) -> T
|
pub fn wrap<T>(mut val: T, min: T, max: T) -> T
|
||||||
where
|
where
|
||||||
T: Copy + PartialOrd + ClosedAdd + ClosedSub,
|
T: Copy + PartialOrd + ClosedAddAssign + ClosedSubAssign,
|
||||||
{
|
{
|
||||||
assert!(min < max, "Invalid wrapping bounds.");
|
assert!(min < max, "Invalid wrapping bounds.");
|
||||||
let width = max - min;
|
let width = max - min;
|
||||||
|
|
|
@ -430,7 +430,7 @@ where
|
||||||
|
|
||||||
let abs_c_recip = choose_2m_m * factorial(2 * m + 1);
|
let abs_c_recip = choose_2m_m * factorial(2 * m + 1);
|
||||||
let alpha = a_abs_onenorm / one_norm(a);
|
let alpha = a_abs_onenorm / one_norm(a);
|
||||||
let alpha: f64 = try_convert(alpha).unwrap() / abs_c_recip as f64;
|
let alpha: f64 = try_convert::<_, f64>(alpha).unwrap() / abs_c_recip as f64;
|
||||||
|
|
||||||
let u = 2_f64.powf(-53.0);
|
let u = 2_f64.powf(-53.0);
|
||||||
let log2_alpha_div_u = (alpha / u).log2();
|
let log2_alpha_div_u = (alpha / u).log2();
|
||||||
|
@ -523,7 +523,7 @@ where
|
||||||
let mut s = if eta_5 == T::RealField::zero() {
|
let mut s = if eta_5 == T::RealField::zero() {
|
||||||
0
|
0
|
||||||
} else {
|
} else {
|
||||||
let l2 = try_convert((eta_5 / theta_13).log2().ceil()).unwrap();
|
let l2 = try_convert::<_, f64>((eta_5 / theta_13).log2().ceil()).unwrap();
|
||||||
|
|
||||||
if l2 < 0.0 {
|
if l2 < 0.0 {
|
||||||
0
|
0
|
||||||
|
|
|
@ -37,14 +37,10 @@ mod udu;
|
||||||
pub use self::bidiagonal::*;
|
pub use self::bidiagonal::*;
|
||||||
pub use self::cholesky::*;
|
pub use self::cholesky::*;
|
||||||
pub use self::col_piv_qr::*;
|
pub use self::col_piv_qr::*;
|
||||||
pub use self::convolution::*;
|
|
||||||
#[cfg(feature = "std")]
|
|
||||||
pub use self::exp::*;
|
|
||||||
pub use self::full_piv_lu::*;
|
pub use self::full_piv_lu::*;
|
||||||
pub use self::hessenberg::*;
|
pub use self::hessenberg::*;
|
||||||
pub use self::lu::*;
|
pub use self::lu::*;
|
||||||
pub use self::permutation_sequence::*;
|
pub use self::permutation_sequence::*;
|
||||||
pub use self::pow::*;
|
|
||||||
pub use self::qr::*;
|
pub use self::qr::*;
|
||||||
pub use self::schur::*;
|
pub use self::schur::*;
|
||||||
pub use self::svd::*;
|
pub use self::svd::*;
|
||||||
|
|
|
@ -6,11 +6,11 @@ use crate::{
|
||||||
DefaultAllocator, DimMin, Matrix, OMatrix, Scalar,
|
DefaultAllocator, DimMin, Matrix, OMatrix, Scalar,
|
||||||
};
|
};
|
||||||
use num::{One, Zero};
|
use num::{One, Zero};
|
||||||
use simba::scalar::{ClosedAdd, ClosedMul};
|
use simba::scalar::{ClosedAddAssign, ClosedMulAssign};
|
||||||
|
|
||||||
impl<T, D, S> Matrix<T, D, D, S>
|
impl<T, D, S> Matrix<T, D, D, S>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + One + ClosedAdd + ClosedMul,
|
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
|
||||||
D: DimMin<D, Output = D>,
|
D: DimMin<D, Output = D>,
|
||||||
S: StorageMut<T, D, D>,
|
S: StorageMut<T, D, D>,
|
||||||
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
|
@ -56,7 +56,7 @@ where
|
||||||
|
|
||||||
impl<T, D, S: Storage<T, D, D>> Matrix<T, D, D, S>
|
impl<T, D, S: Storage<T, D, D>> Matrix<T, D, D, S>
|
||||||
where
|
where
|
||||||
T: Scalar + Zero + One + ClosedAdd + ClosedMul,
|
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
|
||||||
D: DimMin<D, Output = D>,
|
D: DimMin<D, Output = D>,
|
||||||
S: StorageMut<T, D, D>,
|
S: StorageMut<T, D, D>,
|
||||||
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
DefaultAllocator: Allocator<D, D> + Allocator<D>,
|
||||||
|
|
|
@ -1,5 +1,5 @@
|
||||||
use num::Zero;
|
use num::Zero;
|
||||||
use simba::scalar::ClosedAdd;
|
use simba::scalar::ClosedAddAssign;
|
||||||
use std::iter;
|
use std::iter;
|
||||||
use std::marker::PhantomData;
|
use std::marker::PhantomData;
|
||||||
use std::ops::Range;
|
use std::ops::Range;
|
||||||
|
@ -294,7 +294,7 @@ where
|
||||||
vals: Vec<T>,
|
vals: Vec<T>,
|
||||||
) -> Self
|
) -> Self
|
||||||
where
|
where
|
||||||
T: Zero + ClosedAdd,
|
T: Zero + ClosedAddAssign,
|
||||||
DefaultAllocator: Allocator<R>,
|
DefaultAllocator: Allocator<R>,
|
||||||
{
|
{
|
||||||
assert_eq!(ncols.value(), p.len(), "Invalid inptr size.");
|
assert_eq!(ncols.value(), p.len(), "Invalid inptr size.");
|
||||||
|
@ -333,7 +333,7 @@ where
|
||||||
}
|
}
|
||||||
|
|
||||||
/*
|
/*
|
||||||
impl<T: Scalar + Zero + ClosedAdd> CsMatrix<T> {
|
impl<T: Scalar + Zero + ClosedAddAssign> CsMatrix<T> {
|
||||||
pub(crate) fn from_parts(
|
pub(crate) fn from_parts(
|
||||||
nrows: usize,
|
nrows: usize,
|
||||||
ncols: usize,
|
ncols: usize,
|
||||||
|
@ -501,7 +501,7 @@ where
|
||||||
// Remove duplicate entries on a sorted CsMatrix.
|
// Remove duplicate entries on a sorted CsMatrix.
|
||||||
pub(crate) fn dedup(&mut self)
|
pub(crate) fn dedup(&mut self)
|
||||||
where
|
where
|
||||||
T: Zero + ClosedAdd,
|
T: Zero + ClosedAddAssign,
|
||||||
{
|
{
|
||||||
let mut curr_i = 0;
|
let mut curr_i = 0;
|
||||||
|
|
||||||
|
|
|
@ -1,5 +1,5 @@
|
||||||
use num::Zero;
|
use num::Zero;
|
||||||
use simba::scalar::ClosedAdd;
|
use simba::scalar::ClosedAddAssign;
|
||||||
|
|
||||||
use crate::allocator::Allocator;
|
use crate::allocator::Allocator;
|
||||||
use crate::sparse::cs_utils;
|
use crate::sparse::cs_utils;
|
||||||
|
@ -7,7 +7,7 @@ use crate::sparse::{CsMatrix, CsStorage};
|
||||||
use crate::storage::Storage;
|
use crate::storage::Storage;
|
||||||
use crate::{DefaultAllocator, Dim, Dyn, Matrix, OMatrix, Scalar};
|
use crate::{DefaultAllocator, Dim, Dyn, Matrix, OMatrix, Scalar};
|
||||||
|
|
||||||
impl<'a, T: Scalar + Zero + ClosedAdd> CsMatrix<T> {
|
impl<'a, T: Scalar + Zero + ClosedAddAssign> CsMatrix<T> {
|
||||||
/// 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(
|
pub fn from_triplet(
|
||||||
nrows: usize,
|
nrows: usize,
|
||||||
|
@ -20,7 +20,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 + ClosedAddAssign, R: Dim, C: Dim> CsMatrix<T, R, C>
|
||||||
where
|
where
|
||||||
DefaultAllocator: Allocator<C> + Allocator<R>,
|
DefaultAllocator: Allocator<C> + Allocator<R>,
|
||||||
{
|
{
|
||||||
|
|
|
@ -1,5 +1,5 @@
|
||||||
use num::{One, Zero};
|
use num::{One, Zero};
|
||||||
use simba::scalar::{ClosedAdd, ClosedMul};
|
use simba::scalar::{ClosedAddAssign, ClosedMulAssign};
|
||||||
use std::ops::{Add, Mul};
|
use std::ops::{Add, Mul};
|
||||||
|
|
||||||
use crate::allocator::Allocator;
|
use crate::allocator::Allocator;
|
||||||
|
@ -20,7 +20,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: CsStorage<T, R, C>> CsMatrix<T, R, C, S> {
|
||||||
res: &mut CsMatrix<T, R2, C2>,
|
res: &mut CsMatrix<T, R2, C2>,
|
||||||
) -> usize
|
) -> usize
|
||||||
where
|
where
|
||||||
T: ClosedAdd + ClosedMul,
|
T: ClosedAddAssign + ClosedMulAssign,
|
||||||
DefaultAllocator: Allocator<C2>,
|
DefaultAllocator: Allocator<C2>,
|
||||||
{
|
{
|
||||||
for (i, val) in self.data.column_entries(j) {
|
for (i, val) in self.data.column_entries(j) {
|
||||||
|
@ -76,7 +76,9 @@ impl<T: Scalar, R, S> CsVector<T, R, S> {
|
||||||
}
|
}
|
||||||
*/
|
*/
|
||||||
|
|
||||||
impl<T: Scalar + Zero + ClosedAdd + ClosedMul, D: Dim, S: StorageMut<T, D>> Vector<T, D, S> {
|
impl<T: Scalar + Zero + ClosedAddAssign + ClosedMulAssign, D: Dim, S: StorageMut<T, D>>
|
||||||
|
Vector<T, D, S>
|
||||||
|
{
|
||||||
/// Perform a sparse axpy operation: `self = alpha * x + beta * self` operation.
|
/// Perform a sparse axpy operation: `self = alpha * x + beta * self` operation.
|
||||||
pub fn axpy_cs<D2: Dim, S2>(&mut self, alpha: T, x: &CsVector<T, D2, S2>, beta: T)
|
pub fn axpy_cs<D2: Dim, S2>(&mut self, alpha: T, x: &CsVector<T, D2, S2>, beta: T)
|
||||||
where
|
where
|
||||||
|
@ -126,7 +128,7 @@ impl<T: Scalar + Zero + ClosedAdd + ClosedMul, D: Dim, S: StorageMut<T, D>> Vect
|
||||||
impl<'a, 'b, T, R1, R2, C1, C2, S1, S2> Mul<&'b CsMatrix<T, R2, C2, S2>>
|
impl<'a, 'b, T, R1, R2, C1, C2, S1, S2> Mul<&'b CsMatrix<T, R2, C2, S2>>
|
||||||
for &'a CsMatrix<T, R1, C1, S1>
|
for &'a CsMatrix<T, R1, C1, S1>
|
||||||
where
|
where
|
||||||
T: Scalar + ClosedAdd + ClosedMul + Zero,
|
T: Scalar + ClosedAddAssign + ClosedMulAssign + Zero,
|
||||||
R1: Dim,
|
R1: Dim,
|
||||||
C1: Dim,
|
C1: Dim,
|
||||||
R2: Dim,
|
R2: Dim,
|
||||||
|
@ -219,7 +221,7 @@ where
|
||||||
impl<'a, 'b, T, R1, R2, C1, C2, S1, S2> Add<&'b CsMatrix<T, R2, C2, S2>>
|
impl<'a, 'b, T, R1, R2, C1, C2, S1, S2> Add<&'b CsMatrix<T, R2, C2, S2>>
|
||||||
for &'a CsMatrix<T, R1, C1, S1>
|
for &'a CsMatrix<T, R1, C1, S1>
|
||||||
where
|
where
|
||||||
T: Scalar + ClosedAdd + ClosedMul + Zero + One,
|
T: Scalar + ClosedAddAssign + ClosedMulAssign + Zero + One,
|
||||||
R1: Dim,
|
R1: Dim,
|
||||||
C1: Dim,
|
C1: Dim,
|
||||||
R2: Dim,
|
R2: Dim,
|
||||||
|
@ -287,7 +289,7 @@ where
|
||||||
|
|
||||||
impl<'a, 'b, T, R, C, S> Mul<T> for CsMatrix<T, R, C, S>
|
impl<'a, 'b, T, R, C, S> Mul<T> for CsMatrix<T, R, C, S>
|
||||||
where
|
where
|
||||||
T: Scalar + ClosedAdd + ClosedMul + Zero,
|
T: Scalar + ClosedAddAssign + ClosedMulAssign + Zero,
|
||||||
R: Dim,
|
R: Dim,
|
||||||
C: Dim,
|
C: Dim,
|
||||||
S: CsStorageMut<T, R, C>,
|
S: CsStorageMut<T, R, C>,
|
||||||
|
|
Loading…
Reference in New Issue