From dfb8766e381157ec79dfd3c7d143addd065d0b38 Mon Sep 17 00:00:00 2001
From: Norbert Nemec <Norbert@Nemec-online.de>
Date: Sun, 1 Sep 2019 20:35:27 +0200
Subject: [PATCH] drop redundant impl_vector_default

---
 src/vector.rs | 273 --------------------------------------------------
 1 file changed, 273 deletions(-)

diff --git a/src/vector.rs b/src/vector.rs
index 8ddfe4d..8a7e091 100644
--- a/src/vector.rs
+++ b/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);