drop redundant impl_vector_default
This commit is contained in:
Norbert Nemec
parent
c4acb79d04
commit
dfb8766e38
273
src/vector.rs
273
src/vector.rs
|
|
@ -364,276 +364,6 @@ macro_rules! impl_vector {
|
|||
}
|
||||
}
|
||||
|
||||
// Utility macro for generating associated functions for the vectors
|
||||
// mainly duplication
|
||||
#[cfg(feature = "simd")]
|
||||
macro_rules! impl_vector_default {
|
||||
($VectorN:ident { $($field:ident),+ }, $n:expr, $constructor:ident) => {
|
||||
impl<S> $VectorN<S> {
|
||||
/// Construct a new vector, using the provided values.
|
||||
#[inline]
|
||||
pub const fn new($($field: S),+) -> $VectorN<S> {
|
||||
$VectorN { $($field: $field),+ }
|
||||
}
|
||||
|
||||
/// Perform the given operation on each field in the vector, returning a new point
|
||||
/// constructed from the operations.
|
||||
#[inline]
|
||||
pub fn map<U, F>(self, mut f: F) -> $VectorN<U>
|
||||
where F: FnMut(S) -> U
|
||||
{
|
||||
$VectorN { $($field: f(self.$field)),+ }
|
||||
}
|
||||
|
||||
/// Construct a new vector where each component is the result of
|
||||
/// applying the given operation to each pair of components of the
|
||||
/// given vectors.
|
||||
#[inline]
|
||||
pub fn zip<S2, S3, F>(self, v2: $VectorN<S2>, mut f: F) -> $VectorN<S3>
|
||||
where F: FnMut(S, S2) -> S3
|
||||
{
|
||||
$VectorN { $($field: f(self.$field, v2.$field)),+ }
|
||||
}
|
||||
}
|
||||
|
||||
/// The short constructor.
|
||||
#[inline]
|
||||
pub const fn $constructor<S>($($field: S),+) -> $VectorN<S> {
|
||||
$VectorN::new($($field),+)
|
||||
}
|
||||
|
||||
impl<S: NumCast + Copy> $VectorN<S> {
|
||||
/// Component-wise casting to another type.
|
||||
#[inline]
|
||||
pub fn cast<T: NumCast>(&self) -> Option<$VectorN<T>> {
|
||||
$(
|
||||
let $field = match NumCast::from(self.$field) {
|
||||
Some(field) => field,
|
||||
None => return None
|
||||
};
|
||||
)+
|
||||
Some($VectorN { $($field),+ })
|
||||
}
|
||||
}
|
||||
|
||||
impl<S: BaseFloat> MetricSpace for $VectorN<S> {
|
||||
type Metric = S;
|
||||
|
||||
#[inline]
|
||||
fn distance2(self, other: Self) -> S {
|
||||
(other - self).magnitude2()
|
||||
}
|
||||
}
|
||||
|
||||
impl<S: Copy> Array for $VectorN<S> {
|
||||
type Element = S;
|
||||
|
||||
#[inline]
|
||||
fn len() -> usize {
|
||||
$n
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn from_value(scalar: S) -> $VectorN<S> {
|
||||
$VectorN { $($field: scalar),+ }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn sum(self) -> S where S: Add<Output = S> {
|
||||
fold_array!(add, { $(self.$field),+ })
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn product(self) -> S where S: Mul<Output = S> {
|
||||
fold_array!(mul, { $(self.$field),+ })
|
||||
}
|
||||
|
||||
fn is_finite(&self) -> bool where S: BaseFloat {
|
||||
$(self.$field.is_finite())&&+
|
||||
}
|
||||
}
|
||||
|
||||
impl<S: BaseNum> Zero for $VectorN<S> {
|
||||
#[inline]
|
||||
fn zero() -> $VectorN<S> {
|
||||
$VectorN::from_value(S::zero())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn is_zero(&self) -> bool {
|
||||
*self == $VectorN::zero()
|
||||
}
|
||||
}
|
||||
|
||||
impl<S: BaseNum> iter::Sum<$VectorN<S>> for $VectorN<S> {
|
||||
#[inline]
|
||||
fn sum<I: Iterator<Item=$VectorN<S>>>(iter: I) -> $VectorN<S> {
|
||||
iter.fold($VectorN::zero(), Add::add)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, S: 'a + BaseNum> iter::Sum<&'a $VectorN<S>> for $VectorN<S> {
|
||||
#[inline]
|
||||
fn sum<I: Iterator<Item=&'a $VectorN<S>>>(iter: I) -> $VectorN<S> {
|
||||
iter.fold($VectorN::zero(), Add::add)
|
||||
}
|
||||
}
|
||||
|
||||
impl<S: BaseNum> VectorSpace for $VectorN<S> {
|
||||
type Scalar = S;
|
||||
}
|
||||
|
||||
impl<S: Neg<Output = S>> Neg for $VectorN<S> {
|
||||
type Output = $VectorN<S>;
|
||||
|
||||
#[inline]
|
||||
default_fn!( neg(self) -> $VectorN<S> { $VectorN::new($(-self.$field),+) } );
|
||||
}
|
||||
|
||||
impl<S: BaseFloat> approx::AbsDiffEq for $VectorN<S> {
|
||||
type Epsilon = S::Epsilon;
|
||||
|
||||
#[inline]
|
||||
fn default_epsilon() -> S::Epsilon {
|
||||
S::default_epsilon()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn abs_diff_eq(&self, other: &Self, epsilon: S::Epsilon) -> bool {
|
||||
$(S::abs_diff_eq(&self.$field, &other.$field, epsilon))&&+
|
||||
}
|
||||
}
|
||||
|
||||
impl<S: BaseFloat> approx::RelativeEq for $VectorN<S> {
|
||||
#[inline]
|
||||
fn default_max_relative() -> S::Epsilon {
|
||||
S::default_max_relative()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn relative_eq(&self, other: &Self, epsilon: S::Epsilon, max_relative: S::Epsilon) -> bool {
|
||||
$(S::relative_eq(&self.$field, &other.$field, epsilon, max_relative))&&+
|
||||
}
|
||||
}
|
||||
|
||||
impl<S: BaseFloat> approx::UlpsEq for $VectorN<S> {
|
||||
#[inline]
|
||||
fn default_max_ulps() -> u32 {
|
||||
S::default_max_ulps()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn ulps_eq(&self, other: &Self, epsilon: S::Epsilon, max_ulps: u32) -> bool {
|
||||
$(S::ulps_eq(&self.$field, &other.$field, epsilon, max_ulps))&&+
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "rand")]
|
||||
impl<S> Distribution<$VectorN<S>> for Standard
|
||||
where Standard: Distribution<S>,
|
||||
S: BaseFloat {
|
||||
#[inline]
|
||||
fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $VectorN<S> {
|
||||
$VectorN { $($field: rng.gen()),+ }
|
||||
}
|
||||
}
|
||||
|
||||
impl<S: Bounded> Bounded for $VectorN<S> {
|
||||
#[inline]
|
||||
fn min_value() -> $VectorN<S> {
|
||||
$VectorN { $($field: S::min_value()),+ }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn max_value() -> $VectorN<S> {
|
||||
$VectorN { $($field: S::max_value()),+ }
|
||||
}
|
||||
}
|
||||
|
||||
impl_operator!(<S: BaseNum> Add<$VectorN<S> > for $VectorN<S> {
|
||||
fn add(lhs, rhs) -> $VectorN<S> { $VectorN::new($(lhs.$field + rhs.$field),+) }
|
||||
});
|
||||
impl_assignment_operator!(<S: BaseNum> AddAssign<$VectorN<S> > for $VectorN<S> {
|
||||
fn add_assign(&mut self, other) { $(self.$field += other.$field);+ }
|
||||
});
|
||||
|
||||
impl_operator!(<S: BaseNum> Sub<$VectorN<S> > for $VectorN<S> {
|
||||
fn sub(lhs, rhs) -> $VectorN<S> { $VectorN::new($(lhs.$field - rhs.$field),+) }
|
||||
});
|
||||
impl_assignment_operator!(<S: BaseNum> SubAssign<$VectorN<S> > for $VectorN<S> {
|
||||
fn sub_assign(&mut self, other) { $(self.$field -= other.$field);+ }
|
||||
});
|
||||
|
||||
impl_operator!(<S: BaseNum> Mul<S> for $VectorN<S> {
|
||||
fn mul(vector, scalar) -> $VectorN<S> { $VectorN::new($(vector.$field * scalar),+) }
|
||||
});
|
||||
impl_assignment_operator!(<S: BaseNum> MulAssign<S> for $VectorN<S> {
|
||||
fn mul_assign(&mut self, scalar) { $(self.$field *= scalar);+ }
|
||||
});
|
||||
|
||||
impl_operator!(<S: BaseNum> Div<S> for $VectorN<S> {
|
||||
fn div(vector, scalar) -> $VectorN<S> { $VectorN::new($(vector.$field / scalar),+) }
|
||||
});
|
||||
impl_assignment_operator!(<S: BaseNum> DivAssign<S> for $VectorN<S> {
|
||||
fn div_assign(&mut self, scalar) { $(self.$field /= scalar);+ }
|
||||
});
|
||||
|
||||
impl_operator!(<S: BaseNum> Rem<S> for $VectorN<S> {
|
||||
fn rem(vector, scalar) -> $VectorN<S> { $VectorN::new($(vector.$field % scalar),+) }
|
||||
});
|
||||
impl_assignment_operator!(<S: BaseNum> RemAssign<S> for $VectorN<S> {
|
||||
fn rem_assign(&mut self, scalar) { $(self.$field %= scalar);+ }
|
||||
});
|
||||
|
||||
impl<S: BaseNum> ElementWise for $VectorN<S> {
|
||||
#[inline] default_fn!( add_element_wise(self, rhs: $VectorN<S>) -> $VectorN<S> { $VectorN::new($(self.$field + rhs.$field),+) } );
|
||||
#[inline] default_fn!( sub_element_wise(self, rhs: $VectorN<S>) -> $VectorN<S> { $VectorN::new($(self.$field - rhs.$field),+) } );
|
||||
#[inline] default_fn!( mul_element_wise(self, rhs: $VectorN<S>) -> $VectorN<S> { $VectorN::new($(self.$field * rhs.$field),+) } );
|
||||
#[inline] default_fn!( div_element_wise(self, rhs: $VectorN<S>) -> $VectorN<S> { $VectorN::new($(self.$field / rhs.$field),+) } );
|
||||
#[inline] fn rem_element_wise(self, rhs: $VectorN<S>) -> $VectorN<S> { $VectorN::new($(self.$field % rhs.$field),+) }
|
||||
|
||||
#[inline] default_fn!( add_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field += rhs.$field);+ } );
|
||||
#[inline] default_fn!( sub_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field -= rhs.$field);+ } );
|
||||
#[inline] default_fn!( mul_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field *= rhs.$field);+ } );
|
||||
#[inline] default_fn!( div_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field /= rhs.$field);+ } );
|
||||
#[inline] fn rem_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field %= rhs.$field);+ }
|
||||
}
|
||||
|
||||
impl<S: BaseNum> ElementWise<S> for $VectorN<S> {
|
||||
#[inline] default_fn!( add_element_wise(self, rhs: S) -> $VectorN<S> { $VectorN::new($(self.$field + rhs),+) } );
|
||||
#[inline] default_fn!( sub_element_wise(self, rhs: S) -> $VectorN<S> { $VectorN::new($(self.$field - rhs),+) } );
|
||||
#[inline] default_fn!( mul_element_wise(self, rhs: S) -> $VectorN<S> { $VectorN::new($(self.$field * rhs),+) } );
|
||||
#[inline] default_fn!( div_element_wise(self, rhs: S) -> $VectorN<S> { $VectorN::new($(self.$field / rhs),+) } );
|
||||
#[inline] fn rem_element_wise(self, rhs: S) -> $VectorN<S> { $VectorN::new($(self.$field % rhs),+) }
|
||||
|
||||
#[inline] default_fn!( add_assign_element_wise(&mut self, rhs: S) { $(self.$field += rhs);+ } );
|
||||
#[inline] default_fn!( sub_assign_element_wise(&mut self, rhs: S) { $(self.$field -= rhs);+ } );
|
||||
#[inline] default_fn!( mul_assign_element_wise(&mut self, rhs: S) { $(self.$field *= rhs);+ } );
|
||||
#[inline] default_fn!( div_assign_element_wise(&mut self, rhs: S) { $(self.$field /= rhs);+ } );
|
||||
#[inline] fn rem_assign_element_wise(&mut self, rhs: S) { $(self.$field %= rhs);+ }
|
||||
}
|
||||
|
||||
impl_scalar_ops!($VectorN<usize> { $($field),+ });
|
||||
impl_scalar_ops!($VectorN<u8> { $($field),+ });
|
||||
impl_scalar_ops!($VectorN<u16> { $($field),+ });
|
||||
impl_scalar_ops!($VectorN<u32> { $($field),+ });
|
||||
impl_scalar_ops!($VectorN<u64> { $($field),+ });
|
||||
impl_scalar_ops!($VectorN<isize> { $($field),+ });
|
||||
impl_scalar_ops!($VectorN<i8> { $($field),+ });
|
||||
impl_scalar_ops!($VectorN<i16> { $($field),+ });
|
||||
impl_scalar_ops!($VectorN<i32> { $($field),+ });
|
||||
impl_scalar_ops!($VectorN<i64> { $($field),+ });
|
||||
impl_scalar_ops!($VectorN<f32> { $($field),+ });
|
||||
impl_scalar_ops!($VectorN<f64> { $($field),+ });
|
||||
|
||||
impl_index_operators!($VectorN<S>, $n, S, usize);
|
||||
impl_index_operators!($VectorN<S>, $n, [S], Range<usize>);
|
||||
impl_index_operators!($VectorN<S>, $n, [S], RangeTo<usize>);
|
||||
impl_index_operators!($VectorN<S>, $n, [S], RangeFrom<usize>);
|
||||
impl_index_operators!($VectorN<S>, $n, [S], RangeFull);
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! impl_scalar_ops {
|
||||
($VectorN:ident<$S:ident> { $($field:ident),+ }) => {
|
||||
impl_operator!(Mul<$VectorN<$S>> for $S {
|
||||
|
|
@ -651,10 +381,7 @@ macro_rules! impl_scalar_ops {
|
|||
impl_vector!(Vector1 { x }, 1, vec1);
|
||||
impl_vector!(Vector2 { x, y }, 2, vec2);
|
||||
impl_vector!(Vector3 { x, y, z }, 3, vec3);
|
||||
#[cfg(not(feature = "simd"))]
|
||||
impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
|
||||
#[cfg(feature = "simd")]
|
||||
impl_vector_default!(Vector4 { x, y, z, w }, 4, vec4);
|
||||
|
||||
impl_fixed_array_conversions!(Vector1<S> { x: 0 }, 1);
|
||||
impl_fixed_array_conversions!(Vector2<S> { x: 0, y: 1 }, 2);
|
||||
|
|
|
|||
Loading…
Reference in a new issue