M-Labs
/
nalgebra
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

chore: update to simba 0.9 (#1415)

This commit is contained in:
Sébastien Crozet 2024-06-22 19:06:20 +02:00 committed by GitHub
parent f812694959
commit 292abfbaa0
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
54 changed files with 331 additions and 362 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Cargo.toml
View File

@ -82,7 +82,7 @@ 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 }

2
nalgebra-glm/Cargo.toml
View File

@ -34,5 +34,5 @@ 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 }

14
nalgebra-glm/src/traits.rs
View File

@ -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,

2
nalgebra-lapack/Cargo.toml
View File

@ -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 }

14
nalgebra-sparse/src/convert/impl_std_ops.rs
View File

@ -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
nalgebra-sparse/src/convert/serial.rs
View File

@ -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());

24
nalgebra-sparse/src/ops/impl_std_ops.rs
View File

@ -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>,

10
nalgebra-sparse/src/ops/serial/cs.rs
View File

@ -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) => {

14
nalgebra-sparse/src/ops/serial/csc.rs
View File

@ -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>,

14
nalgebra-sparse/src/ops/serial/csr.rs
View File

@ -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>,

12
src/base/blas.rs
View File

@ -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`.
/// ///

12
src/base/blas_uninit.rs
View File

@ -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>,

9
src/base/cg.rs
View File

@ -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]

12
src/base/componentwise.rs
View File

@ -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() {

6
src/base/construction.rs
View File

@ -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]

9
src/base/interpolation.rs
View File

@ -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.
/// ///

12
src/base/matrix.rs
View File

@ -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]

6
src/base/matrix_simba.rs
View File

@ -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)

40
src/base/ops.rs
View File

@ -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> {

4
src/base/properties.rs
View File

@ -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>,

18
src/base/statistics.rs
View File

@ -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;

4
src/geometry/abstract_rotation.rs
View File

@ -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.

2
src/geometry/isometry_ops.rs
View File

@ -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};

6
src/geometry/isometry_simba.rs
View File

@ -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))

4
src/geometry/op_macros.rs
View File

@ -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 )*),*>)* ),*
{ {

4
src/geometry/point.rs
View File

@ -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),

4
src/geometry/point_construction.rs
View File

@ -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>>,
{ {

4
src/geometry/point_conversion.rs
View File

@ -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>,

36
src/geometry/point_ops.rs
View File

@ -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),* $(,)*) => {$(

6
src/geometry/point_simba.rs
View File

@ -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()

12
src/geometry/quaternion_simba.rs
View File

@ -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()))

4
src/geometry/rotation_construction.rs
View File

@ -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 {

2
src/geometry/rotation_ops.rs
View File

@ -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};

6
src/geometry/rotation_simba.rs
View File

@ -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()))

16
src/geometry/scale.rs
View File

@ -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

4
src/geometry/scale_construction.rs
View File

@ -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()

36
src/geometry/scale_ops.rs
View File

@ -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; );

6
src/geometry/scale_simba.rs
View File

@ -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()

2
src/geometry/similarity_ops.rs
View File

@ -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};

6
src/geometry/similarity_simba.rs
View File

@ -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());

2
src/geometry/transform_ops.rs
View File

@ -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};

6
src/geometry/transform_simba.rs
View File

@ -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
src/geometry/translation.rs
View File

@ -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

4
src/geometry/translation_construction.rs
View File

@ -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()

34
src/geometry/translation_ops.rs
View File

@ -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 }; );

6
src/geometry/translation_simba.rs
View File

@ -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()

6
src/geometry/unit_complex_simba.rs
View File

@ -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()))

5
src/lib.rs
View File

@ -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;

4
src/linalg/exp.rs
View File

@ -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

4
src/linalg/mod.rs
View File

@ -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
src/linalg/pow.rs
View File

@ -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>,

8
src/sparse/cs_matrix.rs
View File

@ -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;

6
src/sparse/cs_matrix_conversion.rs
View File

@ -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>,
{ {

14
src/sparse/cs_matrix_ops.rs
View File

@ -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>,