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

Add From<[...; .]> impls for all SIMD geometric sructures up to the isometry (excluded).

This commit is contained in:
sebcrozet 2020-03-23 09:16:01 +01:00
parent b1857e6a36
commit b3f347e45e
11 changed files with 720 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

107
src/base/conversion.rs
View File

@ -9,6 +9,8 @@ use generic_array::ArrayLength;
use std::ops::Mul;
use typenum::Prod;
use simba::simd::{PrimitiveSimdValue, SimdValue};
use crate::base::allocator::{Allocator, SameShapeAllocator};
use crate::base::constraint::{SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
#[cfg(any(feature = "std", feature = "alloc"))]
@ -576,3 +578,108 @@ impl<'a, N: Scalar + Copy> From<&'a mut [N]> for DVectorSliceMut<'a, N> {
Self::from_slice(slice, slice.len())
}
}
impl<N: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[MatrixMN<N::Element, R, C>; 2]>
for MatrixMN<N, R, C>
where
N: From<[<N as SimdValue>::Element; 2]>,
N::Element: Scalar + SimdValue,
DefaultAllocator: Allocator<N, R, C> + Allocator<N::Element, R, C>,
{
#[inline]
fn from(arr: [MatrixMN<N::Element, R, C>; 2]) -> Self {
let (nrows, ncols) = arr[0].data.shape();
Self::from_fn_generic(nrows, ncols, |i, j| {
[
arr[0][(i, j)].inlined_clone(),
arr[1][(i, j)].inlined_clone(),
]
.into()
})
}
}
impl<N: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[MatrixMN<N::Element, R, C>; 4]>
for MatrixMN<N, R, C>
where
N: From<[<N as SimdValue>::Element; 4]>,
N::Element: Scalar + SimdValue,
DefaultAllocator: Allocator<N, R, C> + Allocator<N::Element, R, C>,
{
#[inline]
fn from(arr: [MatrixMN<N::Element, R, C>; 4]) -> Self {
let (nrows, ncols) = arr[0].data.shape();
Self::from_fn_generic(nrows, ncols, |i, j| {
[
arr[0][(i, j)].inlined_clone(),
arr[1][(i, j)].inlined_clone(),
arr[2][(i, j)].inlined_clone(),
arr[3][(i, j)].inlined_clone(),
]
.into()
})
}
}
impl<N: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[MatrixMN<N::Element, R, C>; 8]>
for MatrixMN<N, R, C>
where
N: From<[<N as SimdValue>::Element; 8]>,
N::Element: Scalar + SimdValue,
DefaultAllocator: Allocator<N, R, C> + Allocator<N::Element, R, C>,
{
#[inline]
fn from(arr: [MatrixMN<N::Element, R, C>; 8]) -> Self {
let (nrows, ncols) = arr[0].data.shape();
Self::from_fn_generic(nrows, ncols, |i, j| {
[
arr[0][(i, j)].inlined_clone(),
arr[1][(i, j)].inlined_clone(),
arr[2][(i, j)].inlined_clone(),
arr[3][(i, j)].inlined_clone(),
arr[4][(i, j)].inlined_clone(),
arr[5][(i, j)].inlined_clone(),
arr[6][(i, j)].inlined_clone(),
arr[7][(i, j)].inlined_clone(),
]
.into()
})
}
}
impl<N: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[MatrixMN<N::Element, R, C>; 16]>
for MatrixMN<N, R, C>
where
N: From<[<N as SimdValue>::Element; 16]>,
N::Element: Scalar + SimdValue,
DefaultAllocator: Allocator<N, R, C> + Allocator<N::Element, R, C>,
{
fn from(arr: [MatrixMN<N::Element, R, C>; 16]) -> Self {
let (nrows, ncols) = arr[0].data.shape();
Self::from_fn_generic(nrows, ncols, |i, j| {
[
arr[0][(i, j)].inlined_clone(),
arr[1][(i, j)].inlined_clone(),
arr[2][(i, j)].inlined_clone(),
arr[3][(i, j)].inlined_clone(),
arr[4][(i, j)].inlined_clone(),
arr[5][(i, j)].inlined_clone(),
arr[6][(i, j)].inlined_clone(),
arr[7][(i, j)].inlined_clone(),
arr[8][(i, j)].inlined_clone(),
arr[9][(i, j)].inlined_clone(),
arr[10][(i, j)].inlined_clone(),
arr[11][(i, j)].inlined_clone(),
arr[12][(i, j)].inlined_clone(),
arr[13][(i, j)].inlined_clone(),
arr[14][(i, j)].inlined_clone(),
arr[15][(i, j)].inlined_clone(),
]
.into()
})
}
}

93
src/base/unit.rs
View File

@ -9,7 +9,9 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
#[cfg(feature = "abomonation-serialize")]
use abomonation::Abomonation;
use crate::{RealField, SimdComplexField, SimdRealField};
use crate::allocator::Allocator;
use crate::base::DefaultAllocator;
use crate::{Dim, MatrixMN, RealField, Scalar, SimdComplexField, SimdRealField};
/// A wrapper that ensures the underlying algebraic entity has a unit norm.
///
@ -240,3 +242,92 @@ impl<T> Deref for Unit<T> {
unsafe { mem::transmute(self) }
}
}
// NOTE: we can't use a generic implementation for `Unit<T>` because
// num_complex::Complex does not implement `From[Complex<...>...]` (and can't
// because of the orphan rules).
impl<N: Scalar + simba::simd::PrimitiveSimdValue, R: Dim, C: Dim>
From<[Unit<MatrixMN<N::Element, R, C>>; 2]> for Unit<MatrixMN<N, R, C>>
where
N: From<[<N as simba::simd::SimdValue>::Element; 2]>,
N::Element: Scalar,
DefaultAllocator: Allocator<N, R, C> + Allocator<N::Element, R, C>,
{
#[inline]
fn from(arr: [Unit<MatrixMN<N::Element, R, C>>; 2]) -> Self {
Self::new_unchecked(MatrixMN::from([
arr[0].clone().into_inner(),
arr[1].clone().into_inner(),
]))
}
}
impl<N: Scalar + simba::simd::PrimitiveSimdValue, R: Dim, C: Dim>
From<[Unit<MatrixMN<N::Element, R, C>>; 4]> for Unit<MatrixMN<N, R, C>>
where
N: From<[<N as simba::simd::SimdValue>::Element; 4]>,
N::Element: Scalar,
DefaultAllocator: Allocator<N, R, C> + Allocator<N::Element, R, C>,
{
#[inline]
fn from(arr: [Unit<MatrixMN<N::Element, R, C>>; 4]) -> Self {
Self::new_unchecked(MatrixMN::from([
arr[0].clone().into_inner(),
arr[1].clone().into_inner(),
arr[2].clone().into_inner(),
arr[3].clone().into_inner(),
]))
}
}
impl<N: Scalar + simba::simd::PrimitiveSimdValue, R: Dim, C: Dim>
From<[Unit<MatrixMN<N::Element, R, C>>; 8]> for Unit<MatrixMN<N, R, C>>
where
N: From<[<N as simba::simd::SimdValue>::Element; 8]>,
N::Element: Scalar,
DefaultAllocator: Allocator<N, R, C> + Allocator<N::Element, R, C>,
{
#[inline]
fn from(arr: [Unit<MatrixMN<N::Element, R, C>>; 8]) -> Self {
Self::new_unchecked(MatrixMN::from([
arr[0].clone().into_inner(),
arr[1].clone().into_inner(),
arr[2].clone().into_inner(),
arr[3].clone().into_inner(),
arr[4].clone().into_inner(),
arr[5].clone().into_inner(),
arr[6].clone().into_inner(),
arr[7].clone().into_inner(),
]))
}
}
impl<N: Scalar + simba::simd::PrimitiveSimdValue, R: Dim, C: Dim>
From<[Unit<MatrixMN<N::Element, R, C>>; 16]> for Unit<MatrixMN<N, R, C>>
where
N: From<[<N as simba::simd::SimdValue>::Element; 16]>,
N::Element: Scalar,
DefaultAllocator: Allocator<N, R, C> + Allocator<N::Element, R, C>,
{
#[inline]
fn from(arr: [Unit<MatrixMN<N::Element, R, C>>; 16]) -> Self {
Self::new_unchecked(MatrixMN::from([
arr[0].clone().into_inner(),
arr[1].clone().into_inner(),
arr[2].clone().into_inner(),
arr[3].clone().into_inner(),
arr[4].clone().into_inner(),
arr[5].clone().into_inner(),
arr[6].clone().into_inner(),
arr[7].clone().into_inner(),
arr[8].clone().into_inner(),
arr[9].clone().into_inner(),
arr[10].clone().into_inner(),
arr[11].clone().into_inner(),
arr[12].clone().into_inner(),
arr[13].clone().into_inner(),
arr[14].clone().into_inner(),
arr[15].clone().into_inner(),
]))
}
}

20
src/geometry/isometry_conversion.rs
View File

@ -1,5 +1,5 @@
use simba::scalar::{RealField, SubsetOf, SupersetOf};
use simba::simd::SimdRealField;
use simba::simd::{PrimitiveSimdValue, SimdRealField, SimdValue};
use crate::base::allocator::Allocator;
use crate::base::dimension::{DimMin, DimName, DimNameAdd, DimNameSum, U1};
@ -162,3 +162,21 @@ where
iso.to_homogeneous()
}
}
//impl<N: Scalar + PrimitiveSimdValue, D: DimName, R> From<[Isometry<N::Element, D, R>; 2]>
// for Rotation<N, D>
//where
// N: From<[<N as SimdValue>::Element; 2]>,
// R: From<[R::Element; 2]>,
// N::Element: Scalar + Copy,
// R::Element: Scalar + Copy,
// DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
//{
// #[inline]
// fn from(arr: [Isometry<N::Element, D, R>; 2]) -> Self {
// Self::from_parts(MatrixN::from([
// arr[0].clone().into_inner(),
// arr[1].clone().into_inner(),
// ]))
// }
//}

88
src/geometry/point_conversion.rs
View File

@ -1,5 +1,6 @@
use num::{One, Zero};
use simba::scalar::{ClosedDiv, SubsetOf, SupersetOf};
use simba::simd::{PrimitiveSimdValue, SimdValue};
use crate::base::allocator::Allocator;
use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
@ -149,3 +150,90 @@ where DefaultAllocator: Allocator<N, D>
Point { coords }
}
}
impl<N: Scalar + Copy + PrimitiveSimdValue, D: DimName> From<[Point<N::Element, D>; 2]>
for Point<N, D>
where
N: From<[<N as simba::simd::SimdValue>::Element; 2]>,
N::Element: Scalar + Copy,
DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
<DefaultAllocator as Allocator<N::Element, D>>::Buffer: Copy,
{
#[inline]
fn from(arr: [Point<N::Element, D>; 2]) -> Self {
Self::from(VectorN::from([arr[0].coords, arr[1].coords]))
}
}
impl<N: Scalar + Copy + PrimitiveSimdValue, D: DimName> From<[Point<N::Element, D>; 4]>
for Point<N, D>
where
N: From<[<N as simba::simd::SimdValue>::Element; 4]>,
N::Element: Scalar + Copy,
DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
<DefaultAllocator as Allocator<N::Element, D>>::Buffer: Copy,
{
#[inline]
fn from(arr: [Point<N::Element, D>; 4]) -> Self {
Self::from(VectorN::from([
arr[0].coords,
arr[1].coords,
arr[2].coords,
arr[3].coords,
]))
}
}
impl<N: Scalar + Copy + PrimitiveSimdValue, D: DimName> From<[Point<N::Element, D>; 8]>
for Point<N, D>
where
N: From<[<N as simba::simd::SimdValue>::Element; 8]>,
N::Element: Scalar + Copy,
DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
<DefaultAllocator as Allocator<N::Element, D>>::Buffer: Copy,
{
#[inline]
fn from(arr: [Point<N::Element, D>; 8]) -> Self {
Self::from(VectorN::from([
arr[0].coords,
arr[1].coords,
arr[2].coords,
arr[3].coords,
arr[4].coords,
arr[5].coords,
arr[6].coords,
arr[7].coords,
]))
}
}
impl<N: Scalar + Copy + PrimitiveSimdValue, D: DimName> From<[Point<N::Element, D>; 16]>
for Point<N, D>
where
N: From<[<N as simba::simd::SimdValue>::Element; 16]>,
N::Element: Scalar + Copy,
DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
<DefaultAllocator as Allocator<N::Element, D>>::Buffer: Copy,
{
#[inline]
fn from(arr: [Point<N::Element, D>; 16]) -> Self {
Self::from(VectorN::from([
arr[0].coords,
arr[1].coords,
arr[2].coords,
arr[3].coords,
arr[4].coords,
arr[5].coords,
arr[6].coords,
arr[7].coords,
arr[8].coords,
arr[9].coords,
arr[10].coords,
arr[11].coords,
arr[12].coords,
arr[13].coords,
arr[14].coords,
arr[15].coords,
]))
}
}

4
src/geometry/quaternion.rs
View File

@ -68,9 +68,9 @@ impl<N: SimdRealField + hash::Hash> hash::Hash for Quaternion<N> {
}
}
impl<N: SimdRealField> Copy for Quaternion<N> {}
impl<N: Scalar + Copy + SimdValue> Copy for Quaternion<N> {}
impl<N: SimdRealField> Clone for Quaternion<N> {
impl<N: Scalar + SimdValue> Clone for Quaternion<N> {
#[inline]
fn clone(&self) -> Self {
Self::from(self.coords.clone())

8
src/geometry/quaternion_construction.rs
View File

@ -10,16 +10,16 @@ use rand::distributions::{Distribution, OpenClosed01, Standard};
use rand::Rng;
use simba::scalar::RealField;
use simba::simd::SimdBool;
use simba::simd::{SimdBool, SimdValue};
use crate::base::dimension::U3;
use crate::base::storage::Storage;
use crate::base::{Matrix3, Matrix4, Unit, Vector, Vector3, Vector4};
use crate::SimdRealField;
use crate::{Scalar, SimdRealField};
use crate::geometry::{Quaternion, Rotation3, UnitQuaternion};
impl<N: SimdRealField> Quaternion<N> {
impl<N: Scalar + SimdValue> Quaternion<N> {
/// Creates a quaternion from a 4D vector. The quaternion scalar part corresponds to the `w`
/// vector component.
#[inline]
@ -45,7 +45,9 @@ impl<N: SimdRealField> Quaternion<N> {
pub fn new(w: N, i: N, j: N, k: N) -> Self {
Self::from(Vector4::new(i, j, k, w))
}
}
impl<N: SimdRealField> Quaternion<N> {
/// Constructs a pure quaternion.
#[inline]
pub fn from_imag(vector: Vector3<N>) -> Self {

156
src/geometry/quaternion_conversion.rs
View File

@ -1,7 +1,7 @@
use num::Zero;
use simba::scalar::{RealField, SubsetOf, SupersetOf};
use simba::simd::{SimdRealField, SimdValue};
use simba::simd::{PrimitiveSimdValue, SimdRealField, SimdValue};
#[cfg(feature = "mint")]
use mint;
@ -260,3 +260,157 @@ impl<N: Scalar + SimdValue> From<Vector4<N>> for Quaternion<N> {
Self { coords }
}
}
impl<N: Scalar + PrimitiveSimdValue> From<[Quaternion<N::Element>; 2]> for Quaternion<N>
where
N: From<[<N as SimdValue>::Element; 2]>,
N::Element: Scalar + Copy,
{
#[inline]
fn from(arr: [Quaternion<N::Element>; 2]) -> Self {
Self::from(Vector4::from([arr[0].coords, arr[1].coords]))
}
}
impl<N: Scalar + PrimitiveSimdValue> From<[Quaternion<N::Element>; 4]> for Quaternion<N>
where
N: From<[<N as SimdValue>::Element; 4]>,
N::Element: Scalar + Copy,
{
#[inline]
fn from(arr: [Quaternion<N::Element>; 4]) -> Self {
Self::from(Vector4::from([
arr[0].coords,
arr[1].coords,
arr[2].coords,
arr[3].coords,
]))
}
}
impl<N: Scalar + PrimitiveSimdValue> From<[Quaternion<N::Element>; 8]> for Quaternion<N>
where
N: From<[<N as SimdValue>::Element; 8]>,
N::Element: Scalar + Copy,
{
#[inline]
fn from(arr: [Quaternion<N::Element>; 8]) -> Self {
Self::from(Vector4::from([
arr[0].coords,
arr[1].coords,
arr[2].coords,
arr[3].coords,
arr[4].coords,
arr[5].coords,
arr[6].coords,
arr[7].coords,
]))
}
}
impl<N: Scalar + PrimitiveSimdValue> From<[Quaternion<N::Element>; 16]> for Quaternion<N>
where
N: From<[<N as SimdValue>::Element; 16]>,
N::Element: Scalar + Copy,
{
#[inline]
fn from(arr: [Quaternion<N::Element>; 16]) -> Self {
Self::from(Vector4::from([
arr[0].coords,
arr[1].coords,
arr[2].coords,
arr[3].coords,
arr[4].coords,
arr[5].coords,
arr[6].coords,
arr[7].coords,
arr[8].coords,
arr[9].coords,
arr[10].coords,
arr[11].coords,
arr[12].coords,
arr[13].coords,
arr[14].coords,
arr[15].coords,
]))
}
}
impl<N: Scalar + Copy + PrimitiveSimdValue> From<[UnitQuaternion<N::Element>; 2]>
for UnitQuaternion<N>
where
N: From<[<N as simba::simd::SimdValue>::Element; 2]>,
N::Element: Scalar + Copy,
{
#[inline]
fn from(arr: [UnitQuaternion<N::Element>; 2]) -> Self {
Self::new_unchecked(Quaternion::from([arr[0].into_inner(), arr[1].into_inner()]))
}
}
impl<N: Scalar + Copy + PrimitiveSimdValue> From<[UnitQuaternion<N::Element>; 4]>
for UnitQuaternion<N>
where
N: From<[<N as simba::simd::SimdValue>::Element; 4]>,
N::Element: Scalar + Copy,
{
#[inline]
fn from(arr: [UnitQuaternion<N::Element>; 4]) -> Self {
Self::new_unchecked(Quaternion::from([
arr[0].into_inner(),
arr[1].into_inner(),
arr[2].into_inner(),
arr[3].into_inner(),
]))
}
}
impl<N: Scalar + Copy + PrimitiveSimdValue> From<[UnitQuaternion<N::Element>; 8]>
for UnitQuaternion<N>
where
N: From<[<N as simba::simd::SimdValue>::Element; 8]>,
N::Element: Scalar + Copy,
{
#[inline]
fn from(arr: [UnitQuaternion<N::Element>; 8]) -> Self {
Self::new_unchecked(Quaternion::from([
arr[0].into_inner(),
arr[1].into_inner(),
arr[2].into_inner(),
arr[3].into_inner(),
arr[4].into_inner(),
arr[5].into_inner(),
arr[6].into_inner(),
arr[7].into_inner(),
]))
}
}
impl<N: Scalar + Copy + PrimitiveSimdValue> From<[UnitQuaternion<N::Element>; 16]>
for UnitQuaternion<N>
where
N: From<[<N as simba::simd::SimdValue>::Element; 16]>,
N::Element: Scalar + Copy,
{
#[inline]
fn from(arr: [UnitQuaternion<N::Element>; 16]) -> Self {
Self::new_unchecked(Quaternion::from([
arr[0].into_inner(),
arr[1].into_inner(),
arr[2].into_inner(),
arr[3].into_inner(),
arr[4].into_inner(),
arr[5].into_inner(),
arr[6].into_inner(),
arr[7].into_inner(),
arr[8].into_inner(),
arr[9].into_inner(),
arr[10].into_inner(),
arr[11].into_inner(),
arr[12].into_inner(),
arr[13].into_inner(),
arr[14].into_inner(),
arr[15].into_inner(),
]))
}
}

7
src/geometry/quaternion_coordinates.rs
View File

@ -1,13 +1,14 @@
use std::mem;
use std::ops::{Deref, DerefMut};
use simba::simd::SimdRealField;
use simba::simd::SimdValue;
use crate::base::coordinates::IJKW;
use crate::Scalar;
use crate::geometry::Quaternion;
impl<N: SimdRealField> Deref for Quaternion<N> {
impl<N: Scalar + SimdValue> Deref for Quaternion<N> {
type Target = IJKW<N>;
#[inline]
@ -16,7 +17,7 @@ impl<N: SimdRealField> Deref for Quaternion<N> {
}
}
impl<N: SimdRealField> DerefMut for Quaternion<N> {
impl<N: Scalar + SimdValue> DerefMut for Quaternion<N> {
#[inline]
fn deref_mut(&mut self) -> &mut Self::Target {
unsafe { mem::transmute(self) }

89
src/geometry/rotation_conversion.rs
View File

@ -1,13 +1,14 @@
use num::Zero;
use simba::scalar::{RealField, SubsetOf, SupersetOf};
use simba::simd::{PrimitiveSimdValue, SimdValue};
#[cfg(feature = "mint")]
use mint;
use crate::base::allocator::Allocator;
use crate::base::dimension::{DimMin, DimName, DimNameAdd, DimNameSum, U1};
use crate::base::{DefaultAllocator, Matrix2, Matrix3, Matrix4, MatrixN};
use crate::base::{DefaultAllocator, Matrix2, Matrix3, Matrix4, MatrixN, Scalar};
use crate::geometry::{
AbstractRotation, Isometry, Rotation, Rotation2, Rotation3, Similarity, SuperTCategoryOf,
@ -243,3 +244,89 @@ impl<N: RealField> From<Rotation3<N>> for Matrix3<N> {
q.into_inner()
}
}
impl<N: Scalar + PrimitiveSimdValue, D: DimName> From<[Rotation<N::Element, D>; 2]>
for Rotation<N, D>
where
N: From<[<N as SimdValue>::Element; 2]>,
N::Element: Scalar + Copy,
DefaultAllocator: Allocator<N, D, D> + Allocator<N::Element, D, D>,
{
#[inline]
fn from(arr: [Rotation<N::Element, D>; 2]) -> Self {
Self::from_matrix_unchecked(MatrixN::from([
arr[0].clone().into_inner(),
arr[1].clone().into_inner(),
]))
}
}
impl<N: Scalar + PrimitiveSimdValue, D: DimName> From<[Rotation<N::Element, D>; 4]>
for Rotation<N, D>
where
N: From<[<N as SimdValue>::Element; 4]>,
N::Element: Scalar + Copy,
DefaultAllocator: Allocator<N, D, D> + Allocator<N::Element, D, D>,
{
#[inline]
fn from(arr: [Rotation<N::Element, D>; 4]) -> Self {
Self::from_matrix_unchecked(MatrixN::from([
arr[0].clone().into_inner(),
arr[1].clone().into_inner(),
arr[2].clone().into_inner(),
arr[3].clone().into_inner(),
]))
}
}
impl<N: Scalar + PrimitiveSimdValue, D: DimName> From<[Rotation<N::Element, D>; 8]>
for Rotation<N, D>
where
N: From<[<N as SimdValue>::Element; 8]>,
N::Element: Scalar + Copy,
DefaultAllocator: Allocator<N, D, D> + Allocator<N::Element, D, D>,
{
#[inline]
fn from(arr: [Rotation<N::Element, D>; 8]) -> Self {
Self::from_matrix_unchecked(MatrixN::from([
arr[0].clone().into_inner(),
arr[1].clone().into_inner(),
arr[2].clone().into_inner(),
arr[3].clone().into_inner(),
arr[4].clone().into_inner(),
arr[5].clone().into_inner(),
arr[6].clone().into_inner(),
arr[7].clone().into_inner(),
]))
}
}
impl<N: Scalar + PrimitiveSimdValue, D: DimName> From<[Rotation<N::Element, D>; 16]>
for Rotation<N, D>
where
N: From<[<N as SimdValue>::Element; 16]>,
N::Element: Scalar + Copy,
DefaultAllocator: Allocator<N, D, D> + Allocator<N::Element, D, D>,
{
#[inline]
fn from(arr: [Rotation<N::Element, D>; 16]) -> Self {
Self::from_matrix_unchecked(MatrixN::from([
arr[0].clone().into_inner(),
arr[1].clone().into_inner(),
arr[2].clone().into_inner(),
arr[3].clone().into_inner(),
arr[4].clone().into_inner(),
arr[5].clone().into_inner(),
arr[6].clone().into_inner(),
arr[7].clone().into_inner(),
arr[8].clone().into_inner(),
arr[9].clone().into_inner(),
arr[10].clone().into_inner(),
arr[11].clone().into_inner(),
arr[12].clone().into_inner(),
arr[13].clone().into_inner(),
arr[14].clone().into_inner(),
arr[15].clone().into_inner(),
]))
}
}

88
src/geometry/translation_conversion.rs
View File

@ -1,6 +1,7 @@
use num::{One, Zero};
use simba::scalar::{RealField, SubsetOf, SupersetOf};
use simba::simd::PrimitiveSimdValue;
use crate::base::allocator::Allocator;
use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
@ -173,3 +174,90 @@ where DefaultAllocator: Allocator<N, D>
Translation { vector }
}
}
impl<N: Scalar + Copy + PrimitiveSimdValue, D: DimName> From<[Translation<N::Element, D>; 2]>
for Translation<N, D>
where
N: From<[<N as simba::simd::SimdValue>::Element; 2]>,
N::Element: Scalar + Copy,
DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
<DefaultAllocator as Allocator<N::Element, D>>::Buffer: Copy,
{
#[inline]
fn from(arr: [Translation<N::Element, D>; 2]) -> Self {
Self::from(VectorN::from([arr[0].vector, arr[1].vector]))
}
}
impl<N: Scalar + Copy + PrimitiveSimdValue, D: DimName> From<[Translation<N::Element, D>; 4]>
for Translation<N, D>
where
N: From<[<N as simba::simd::SimdValue>::Element; 4]>,
N::Element: Scalar + Copy,
DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
<DefaultAllocator as Allocator<N::Element, D>>::Buffer: Copy,
{
#[inline]
fn from(arr: [Translation<N::Element, D>; 4]) -> Self {
Self::from(VectorN::from([
arr[0].vector,
arr[1].vector,
arr[2].vector,
arr[3].vector,
]))
}
}
impl<N: Scalar + Copy + PrimitiveSimdValue, D: DimName> From<[Translation<N::Element, D>; 8]>
for Translation<N, D>
where
N: From<[<N as simba::simd::SimdValue>::Element; 8]>,
N::Element: Scalar + Copy,
DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
<DefaultAllocator as Allocator<N::Element, D>>::Buffer: Copy,
{
#[inline]
fn from(arr: [Translation<N::Element, D>; 8]) -> Self {
Self::from(VectorN::from([
arr[0].vector,
arr[1].vector,
arr[2].vector,
arr[3].vector,
arr[4].vector,
arr[5].vector,
arr[6].vector,
arr[7].vector,
]))
}
}
impl<N: Scalar + Copy + PrimitiveSimdValue, D: DimName> From<[Translation<N::Element, D>; 16]>
for Translation<N, D>
where
N: From<[<N as simba::simd::SimdValue>::Element; 16]>,
N::Element: Scalar + Copy,
DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
<DefaultAllocator as Allocator<N::Element, D>>::Buffer: Copy,
{
#[inline]
fn from(arr: [Translation<N::Element, D>; 16]) -> Self {
Self::from(VectorN::from([
arr[0].vector,
arr[1].vector,
arr[2].vector,
arr[3].vector,
arr[4].vector,
arr[5].vector,
arr[6].vector,
arr[7].vector,
arr[8].vector,
arr[9].vector,
arr[10].vector,
arr[11].vector,
arr[12].vector,
arr[13].vector,
arr[14].vector,
arr[15].vector,
]))
}
}

74
src/geometry/unit_complex_conversion.rs
View File

@ -2,10 +2,10 @@ use num::Zero;
use num_complex::Complex;
use simba::scalar::{RealField, SubsetOf, SupersetOf};
use simba::simd::SimdRealField;
use simba::simd::{PrimitiveSimdValue, SimdRealField, SimdValue};
use crate::base::dimension::U2;
use crate::base::{Matrix2, Matrix3};
use crate::base::{Matrix2, Matrix3, Scalar};
use crate::geometry::{
AbstractRotation, Isometry, Rotation2, Similarity, SuperTCategoryOf, TAffine, Transform,
Translation, UnitComplex,
@ -189,3 +189,73 @@ where N::Element: SimdRealField
q.to_rotation_matrix().into_inner()
}
}
impl<N: Scalar + Copy + PrimitiveSimdValue> From<[UnitComplex<N::Element>; 2]> for UnitComplex<N>
where
N: From<[<N as simba::simd::SimdValue>::Element; 2]>,
N::Element: Scalar + Copy,
{
#[inline]
fn from(arr: [UnitComplex<N::Element>; 2]) -> Self {
Self::new_unchecked(Complex {
re: N::from([arr[0].re, arr[1].re]),
im: N::from([arr[0].im, arr[1].im]),
})
}
}
impl<N: Scalar + Copy + PrimitiveSimdValue> From<[UnitComplex<N::Element>; 4]> for UnitComplex<N>
where
N: From<[<N as simba::simd::SimdValue>::Element; 4]>,
N::Element: Scalar + Copy,
{
#[inline]
fn from(arr: [UnitComplex<N::Element>; 4]) -> Self {
Self::new_unchecked(Complex {
re: N::from([arr[0].re, arr[1].re, arr[2].re, arr[3].re]),
im: N::from([arr[0].im, arr[1].im, arr[2].im, arr[3].im]),
})
}
}
impl<N: Scalar + Copy + PrimitiveSimdValue> From<[UnitComplex<N::Element>; 8]> for UnitComplex<N>
where
N: From<[<N as simba::simd::SimdValue>::Element; 8]>,
N::Element: Scalar + Copy,
{
#[inline]
fn from(arr: [UnitComplex<N::Element>; 8]) -> Self {
Self::new_unchecked(Complex {
re: N::from([
arr[0].re, arr[1].re, arr[2].re, arr[3].re, arr[4].re, arr[5].re, arr[6].re,
arr[7].re,
]),
im: N::from([
arr[0].im, arr[1].im, arr[2].im, arr[3].im, arr[4].im, arr[5].im, arr[6].im,
arr[7].im,
]),
})
}
}
impl<N: Scalar + Copy + PrimitiveSimdValue> From<[UnitComplex<N::Element>; 16]> for UnitComplex<N>
where
N: From<[<N as simba::simd::SimdValue>::Element; 16]>,
N::Element: Scalar + Copy,
{
#[inline]
fn from(arr: [UnitComplex<N::Element>; 16]) -> Self {
Self::new_unchecked(Complex {
re: N::from([
arr[0].re, arr[1].re, arr[2].re, arr[3].re, arr[4].re, arr[5].re, arr[6].re,
arr[7].re, arr[8].re, arr[9].re, arr[10].re, arr[11].re, arr[12].re, arr[13].re,
arr[14].re, arr[15].re,
]),
im: N::from([
arr[0].im, arr[1].im, arr[2].im, arr[3].im, arr[4].im, arr[5].im, arr[6].im,
arr[7].im, arr[8].im, arr[9].im, arr[10].im, arr[11].im, arr[12].im, arr[13].im,
arr[14].im, arr[15].im,
]),
})
}
}