#[cfg(feature = "abomonation-serialize")]
use std::io::{Result as IOResult, Write};
use std::mem;
use std::ops::Deref;
#[cfg(feature = "serde-serialize")]
use serde::{Deserialize, Deserializer, Serialize, Serializer};
#[cfg(feature = "abomonation-serialize")]
use abomonation::Abomonation;
use crate::allocator::Allocator;
use crate::base::DefaultAllocator;
use crate::storage::Storage;
use crate::{Dim, Matrix, MatrixMN, RealField, Scalar, SimdComplexField, SimdRealField};
#[repr(transparent)]
#[derive(Clone, Hash, Debug, Copy)]
pub struct Unit<T> {
pub(crate) value: T,
}
#[cfg(feature = "serde-serialize")]
impl<T: Serialize> Serialize for Unit<T> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
self.value.serialize(serializer)
}
}
#[cfg(feature = "serde-serialize")]
impl<'de, T: Deserialize<'de>> Deserialize<'de> for Unit<T> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
T::deserialize(deserializer).map(|x| Unit { value: x })
}
}
#[cfg(feature = "abomonation-serialize")]
impl<T: Abomonation> Abomonation for Unit<T> {
unsafe fn entomb<W: Write>(&self, writer: &mut W) -> IOResult<()> {
self.value.entomb(writer)
}
fn extent(&self) -> usize {
self.value.extent()
}
unsafe fn exhume<'a, 'b>(&'a mut self, bytes: &'b mut [u8]) -> Option<&'b mut [u8]> {
self.value.exhume(bytes)
}
}
impl<N, R, C, S> PartialEq for Unit<Matrix<N, R, C, S>>
where
N: Scalar + PartialEq,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
{
#[inline]
fn eq(&self, rhs: &Self) -> bool {
self.value.eq(&rhs.value)
}
}
impl<N, R, C, S> Eq for Unit<Matrix<N, R, C, S>>
where
N: Scalar + Eq,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
{
}
pub trait Normed {
type Norm: SimdRealField;
fn norm(&self) -> Self::Norm;
fn norm_squared(&self) -> Self::Norm;
fn scale_mut(&mut self, n: Self::Norm);
fn unscale_mut(&mut self, n: Self::Norm);
}
impl<T: Normed> Unit<T> {
#[inline]
pub fn new_normalize(value: T) -> Self {
Self::new_and_get(value).0
}
#[inline]
pub fn try_new(value: T, min_norm: T::Norm) -> Option<Self>
where
T::Norm: RealField,
{
Self::try_new_and_get(value, min_norm).map(|res| res.0)
}
#[inline]
pub fn new_and_get(mut value: T) -> (Self, T::Norm) {
let n = value.norm();
value.unscale_mut(n);
(Unit { value }, n)
}
#[inline]
pub fn try_new_and_get(mut value: T, min_norm: T::Norm) -> Option<(Self, T::Norm)>
where
T::Norm: RealField,
{
let sq_norm = value.norm_squared();
if sq_norm > min_norm * min_norm {
let n = sq_norm.simd_sqrt();
value.unscale_mut(n);
Some((Unit { value }, n))
} else {
None
}
}
#[inline]
pub fn renormalize(&mut self) -> T::Norm {
let n = self.norm();
self.value.unscale_mut(n);
n
}
#[inline]
pub fn renormalize_fast(&mut self) {
let sq_norm = self.value.norm_squared();
let three: T::Norm = crate::convert(3.0);
let half: T::Norm = crate::convert(0.5);
self.value.scale_mut(half * (three - sq_norm));
}
}
impl<T> Unit<T> {
#[inline]
pub fn new_unchecked(value: T) -> Self {
Unit { value }
}
#[inline]
pub fn from_ref_unchecked<'a>(value: &'a T) -> &'a Self {
unsafe { mem::transmute(value) }
}
#[inline]
pub fn into_inner(self) -> T {
self.value
}
#[deprecated(note = "use `.into_inner()` instead")]
#[inline]
pub fn unwrap(self) -> T {
self.value
}
#[inline]
pub fn as_mut_unchecked(&mut self) -> &mut T {
&mut self.value
}
}
impl<T> AsRef<T> for Unit<T> {
#[inline]
fn as_ref(&self) -> &T {
&self.value
}
}
impl<T> Deref for Unit<T> {
type Target = T;
#[inline]
fn deref(&self) -> &T {
unsafe { mem::transmute(self) }
}
}
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(),
]))
}
}