use std::fmt;
use std::mem;
use std::ops::*;
use rand::{Rand, Rng};
use rust_num::{NumCast, Zero, One};
use angle::{Angle, Rad};
use approx::ApproxEq;
use array::Array;
use num::{BaseNum, BaseFloat, PartialOrd};
pub trait Vector: Copy + Clone where
Self: Array<Element = <Self as Vector>::Scalar>,
Self: Add<Self, Output = Self>,
Self: Sub<Self, Output = Self>,
Self: Mul<Self, Output = Self>,
Self: Div<Self, Output = Self>,
Self: Rem<Self, Output = Self>,
Self: Add<<Self as Vector>::Scalar, Output = Self>,
Self: Sub<<Self as Vector>::Scalar, Output = Self>,
Self: Mul<<Self as Vector>::Scalar, Output = Self>,
Self: Div<<Self as Vector>::Scalar, Output = Self>,
Self: Rem<<Self as Vector>::Scalar, Output = Self>,
{
type Scalar: BaseNum;
fn from_value(scalar: Self::Scalar) -> Self;
#[inline]
fn zero() -> Self { Self::from_value(Self::Scalar::zero()) }
fn dot(self, other: Self) -> Self::Scalar;
}
#[inline] pub fn dot<V: Vector>(a: V, b: V) -> V::Scalar { a.dot(b) }
macro_rules! impl_vector {
($VectorN:ident <$S:ident> { $($field:ident),+ }, $n:expr, $constructor:ident) => {
#[derive(PartialEq, Eq, Copy, Clone, Hash, RustcEncodable, RustcDecodable)]
pub struct $VectorN<S> { $(pub $field: S),+ }
impl<$S> $VectorN<$S> {
#[inline]
pub fn new($($field: $S),+) -> $VectorN<$S> {
$VectorN { $($field: $field),+ }
}
}
impl<$S: Copy + Neg<Output = $S>> $VectorN<$S> {
#[inline]
pub fn neg_self(&mut self) {
$(self.$field = -self.$field);+
}
}
#[inline]
pub fn $constructor<S>($($field: S),+) -> $VectorN<S> {
$VectorN::new($($field),+)
}
impl<$S: NumCast + Copy> $VectorN<$S> {
#[inline]
pub fn cast<T: NumCast>(&self) -> $VectorN<T> {
$VectorN { $($field: NumCast::from(self.$field).unwrap()),+ }
}
}
impl<S: Copy> Array for $VectorN<S> {
type Element = S;
#[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),+ }) }
#[inline] fn min(self) -> S where S: PartialOrd { fold_array!(partial_min, { $(self.$field),+ }) }
#[inline] fn max(self) -> S where S: PartialOrd { fold_array!(partial_max, { $(self.$field),+ }) }
}
impl<S: BaseNum> Vector for $VectorN<S> {
type Scalar = S;
#[inline] fn from_value(scalar: S) -> $VectorN<S> { $VectorN { $($field: scalar),+ } }
#[inline] fn dot(self, other: $VectorN<S>) -> S { (self * other).sum() }
}
impl<S: Neg<Output = S>> Neg for $VectorN<S> {
type Output = $VectorN<S>;
#[inline]
fn neg(self) -> $VectorN<S> { $VectorN::new($(-self.$field),+) }
}
impl<S: BaseFloat> ApproxEq for $VectorN<S> {
type Epsilon = S;
#[inline]
fn approx_eq_eps(&self, other: &$VectorN<S>, epsilon: &S) -> bool {
$(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
}
}
impl<S: BaseFloat + Rand> Rand for $VectorN<S> {
#[inline]
fn rand<R: Rng>(rng: &mut R) -> $VectorN<S> {
$VectorN { $($field: rng.gen()),+ }
}
}
impl_operator!(<S: BaseNum> Add<S> for $VectorN<S> {
fn add(vector, scalar) -> $VectorN<S> { $VectorN::new($(vector.$field + scalar),+) }
});
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<S> for $VectorN<S> {
fn add_assign(&mut self, scalar) { $(self.$field += scalar);+ }
});
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<S> for $VectorN<S> {
fn sub(vector, scalar) -> $VectorN<S> { $VectorN::new($(vector.$field - scalar),+) }
});
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<S> for $VectorN<S> {
fn sub_assign(&mut self, scalar) { $(self.$field -= scalar);+ }
});
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_operator!(<S: BaseNum> Mul<$VectorN<S> > for $VectorN<S> {
fn mul(lhs, rhs) -> $VectorN<S> { $VectorN::new($(lhs.$field * rhs.$field),+) }
});
impl_assignment_operator!(<S: BaseNum> MulAssign<S> for $VectorN<S> {
fn mul_assign(&mut self, scalar) { $(self.$field *= scalar);+ }
});
impl_assignment_operator!(<S: BaseNum> MulAssign<$VectorN<S> > for $VectorN<S> {
fn mul_assign(&mut self, other) { $(self.$field *= other.$field);+ }
});
impl_operator!(<S: BaseNum> Div<S> for $VectorN<S> {
fn div(vector, scalar) -> $VectorN<S> { $VectorN::new($(vector.$field / scalar),+) }
});
impl_operator!(<S: BaseNum> Div<$VectorN<S> > for $VectorN<S> {
fn div(lhs, rhs) -> $VectorN<S> { $VectorN::new($(lhs.$field / rhs.$field),+) }
});
impl_assignment_operator!(<S: BaseNum> DivAssign<S> for $VectorN<S> {
fn div_assign(&mut self, scalar) { $(self.$field /= scalar);+ }
});
impl_assignment_operator!(<S: BaseNum> DivAssign<$VectorN<S> > for $VectorN<S> {
fn div_assign(&mut self, other) { $(self.$field /= other.$field);+ }
});
impl_operator!(<S: BaseNum> Rem<S> for $VectorN<S> {
fn rem(vector, scalar) -> $VectorN<S> { $VectorN::new($(vector.$field % scalar),+) }
});
impl_operator!(<S: BaseNum> Rem<$VectorN<S> > for $VectorN<S> {
fn rem(lhs, rhs) -> $VectorN<S> { $VectorN::new($(lhs.$field % rhs.$field),+) }
});
impl_assignment_operator!(<S: BaseNum> RemAssign<S> for $VectorN<S> {
fn rem_assign(&mut self, scalar) { $(self.$field %= scalar);+ }
});
impl_assignment_operator!(<S: BaseNum> RemAssign<$VectorN<S> > for $VectorN<S> {
fn rem_assign(&mut self, other) { $(self.$field %= other.$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);
}
}
impl_vector!(Vector2<S> { x, y }, 2, vec2);
impl_vector!(Vector3<S> { x, y, z }, 3, vec3);
impl_vector!(Vector4<S> { x, y, z, w }, 4, vec4);
impl_fixed_array_conversions!(Vector2<S> { x: 0, y: 1 }, 2);
impl_fixed_array_conversions!(Vector3<S> { x: 0, y: 1, z: 2 }, 3);
impl_fixed_array_conversions!(Vector4<S> { x: 0, y: 1, z: 2, w: 3 }, 4);
impl_tuple_conversions!(Vector2<S> { x, y }, (S, S));
impl_tuple_conversions!(Vector3<S> { x, y, z }, (S, S, S));
impl_tuple_conversions!(Vector4<S> { x, y, z, w }, (S, S, S, S));
impl<S: BaseNum> Vector2<S> {
#[inline]
pub fn unit_x() -> Vector2<S> {
Vector2::new(S::one(), S::zero())
}
#[inline]
pub fn unit_y() -> Vector2<S> {
Vector2::new(S::zero(), S::one())
}
#[inline]
pub fn perp_dot(self, other: Vector2<S>) -> S {
(self.x * other.y) - (self.y * other.x)
}
#[inline]
pub fn extend(self, z: S)-> Vector3<S> {
Vector3::new(self.x, self.y, z)
}
}
impl<S: BaseNum> Vector3<S> {
#[inline]
pub fn unit_x() -> Vector3<S> {
Vector3::new(S::one(), S::zero(), S::zero())
}
#[inline]
pub fn unit_y() -> Vector3<S> {
Vector3::new(S::zero(), S::one(), S::zero())
}
#[inline]
pub fn unit_z() -> Vector3<S> {
Vector3::new(S::zero(), S::zero(), S::one())
}
#[inline]
#[must_use]
pub fn cross(self, other: Vector3<S>) -> Vector3<S> {
Vector3::new((self.y * other.z) - (self.z * other.y),
(self.z * other.x) - (self.x * other.z),
(self.x * other.y) - (self.y * other.x))
}
#[inline]
pub fn extend(self, w: S)-> Vector4<S> {
Vector4::new(self.x, self.y, self.z, w)
}
#[inline]
pub fn truncate(self)-> Vector2<S> {
Vector2::new(self.x, self.y)
}
}
impl<S: BaseNum> Vector4<S> {
#[inline]
pub fn unit_x() -> Vector4<S> {
Vector4::new(S::one(), S::zero(), S::zero(), S::zero())
}
#[inline]
pub fn unit_y() -> Vector4<S> {
Vector4::new(S::zero(), S::one(), S::zero(), S::zero())
}
#[inline]
pub fn unit_z() -> Vector4<S> {
Vector4::new(S::zero(), S::zero(), S::one(), S::zero())
}
#[inline]
pub fn unit_w() -> Vector4<S> {
Vector4::new(S::zero(), S::zero(), S::zero(), S::one())
}
#[inline]
pub fn truncate(self)-> Vector3<S> {
Vector3::new(self.x, self.y, self.z)
}
#[inline]
pub fn truncate_n(&self, n: isize)-> Vector3<S> {
match n {
0 => Vector3::new(self.y, self.z, self.w),
1 => Vector3::new(self.x, self.z, self.w),
2 => Vector3::new(self.x, self.y, self.w),
3 => Vector3::new(self.x, self.y, self.z),
_ => panic!("{:?} is out of range", n)
}
}
}
pub trait EuclideanVector: Vector + Sized where
<Self as Vector>::Scalar: BaseFloat,
Self: ApproxEq<Epsilon = <Self as Vector>::Scalar>,
{
fn is_perpendicular(self, other: Self) -> bool {
self.dot(other).approx_eq(&Self::Scalar::zero())
}
#[inline]
fn length2(self) -> Self::Scalar {
self.dot(self)
}
#[inline]
fn length(self) -> Self::Scalar {
<<Self as Vector>::Scalar as ::rust_num::Float>::sqrt(self.dot(self))
}
fn angle(self, other: Self) -> Rad<Self::Scalar>;
#[inline]
#[must_use]
fn normalize(self) -> Self {
self.normalize_to(Self::Scalar::one())
}
#[inline]
#[must_use]
fn normalize_to(self, length: Self::Scalar) -> Self {
self * (length / self.length())
}
#[inline]
#[must_use]
fn lerp(self, other: Self, amount: Self::Scalar) -> Self {
self + ((other - self) * amount)
}
}
impl<S: BaseFloat> EuclideanVector for Vector2<S> {
#[inline]
fn angle(self, other: Vector2<S>) -> Rad<S> {
Rad::atan2(self.perp_dot(other), self.dot(other))
}
}
impl<S: BaseFloat> EuclideanVector for Vector3<S> {
#[inline]
fn angle(self, other: Vector3<S>) -> Rad<S> {
Rad::atan2(self.cross(other).length(), self.dot(other))
}
}
impl<S: BaseFloat> EuclideanVector for Vector4<S> {
#[inline]
fn angle(self, other: Vector4<S>) -> Rad<S> {
Rad::acos(self.dot(other) / (self.length() * other.length()))
}
}
impl<S: BaseNum> fmt::Debug for Vector2<S> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "[{:?}, {:?}]", self.x, self.y)
}
}
impl<S: BaseNum> fmt::Debug for Vector3<S> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "[{:?}, {:?}, {:?}]", self.x, self.y, self.z)
}
}
impl<S: BaseNum> fmt::Debug for Vector4<S> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "[{:?}, {:?}, {:?}, {:?}]", self.x, self.y, self.z, self.w)
}
}
#[cfg(test)]
mod tests {
mod vector2 {
use vector::*;
const VECTOR2: Vector2<i32> = Vector2 { x: 1, y: 2 };
#[test]
fn test_index() {
assert_eq!(VECTOR2[0], VECTOR2.x);
assert_eq!(VECTOR2[1], VECTOR2.y);
}
#[test]
fn test_index_mut() {
let mut v = VECTOR2;
*&mut v[0] = 0;
assert_eq!(v, [0, 2].into());
}
#[test]
#[should_panic]
fn test_index_out_of_bounds() {
VECTOR2[2];
}
#[test]
fn test_index_range() {
assert_eq!(&VECTOR2[..0], &[]);
assert_eq!(&VECTOR2[..1], &[1]);
assert_eq!(VECTOR2[..0].len(), 0);
assert_eq!(VECTOR2[..1].len(), 1);
assert_eq!(&VECTOR2[2..], &[]);
assert_eq!(&VECTOR2[1..], &[2]);
assert_eq!(VECTOR2[2..].len(), 0);
assert_eq!(VECTOR2[1..].len(), 1);
assert_eq!(&VECTOR2[..], &[1, 2]);
assert_eq!(VECTOR2[..].len(), 2);
}
#[test]
fn test_into() {
let v = VECTOR2;
{
let v: [i32; 2] = v.into();
assert_eq!(v, [1, 2]);
}
{
let v: (i32, i32) = v.into();
assert_eq!(v, (1, 2));
}
}
#[test]
fn test_as_ref() {
let v = VECTOR2;
{
let v: &[i32; 2] = v.as_ref();
assert_eq!(v, &[1, 2]);
}
{
let v: &(i32, i32) = v.as_ref();
assert_eq!(v, &(1, 2));
}
}
#[test]
fn test_as_mut() {
let mut v = VECTOR2;
{
let v: &mut [i32; 2] = v.as_mut();
assert_eq!(v, &mut [1, 2]);
}
{
let v: &mut (i32, i32) = v.as_mut();
assert_eq!(v, &mut (1, 2));
}
}
#[test]
fn test_from() {
assert_eq!(Vector2::from([1, 2]), VECTOR2);
{
let v = &[1, 2];
let v: &Vector2<_> = From::from(v);
assert_eq!(v, &VECTOR2);
}
{
let v = &mut [1, 2];
let v: &mut Vector2<_> = From::from(v);
assert_eq!(v, &VECTOR2);
}
assert_eq!(Vector2::from((1, 2)), VECTOR2);
{
let v = &(1, 2);
let v: &Vector2<_> = From::from(v);
assert_eq!(v, &VECTOR2);
}
{
let v = &mut (1, 2);
let v: &mut Vector2<_> = From::from(v);
assert_eq!(v, &VECTOR2);
}
}
}
mod vector3 {
use vector::*;
const VECTOR3: Vector3<i32> = Vector3 { x: 1, y: 2, z: 3 };
#[test]
fn test_index() {
assert_eq!(VECTOR3[0], VECTOR3.x);
assert_eq!(VECTOR3[1], VECTOR3.y);
assert_eq!(VECTOR3[2], VECTOR3.z);
}
#[test]
fn test_index_mut() {
let mut v = VECTOR3;
*&mut v[1] = 0;
assert_eq!(v, [1, 0, 3].into());
}
#[test]
#[should_panic]
fn test_index_out_of_bounds() {
VECTOR3[3];
}
#[test]
fn test_index_range() {
assert_eq!(&VECTOR3[..1], &[1]);
assert_eq!(&VECTOR3[..2], &[1, 2]);
assert_eq!(VECTOR3[..1].len(), 1);
assert_eq!(VECTOR3[..2].len(), 2);
assert_eq!(&VECTOR3[2..], &[3]);
assert_eq!(&VECTOR3[1..], &[2, 3]);
assert_eq!(VECTOR3[2..].len(), 1);
assert_eq!(VECTOR3[1..].len(), 2);
assert_eq!(&VECTOR3[..], &[1, 2, 3]);
assert_eq!(VECTOR3[..].len(), 3);
}
#[test]
fn test_into() {
let v = VECTOR3;
{
let v: [i32; 3] = v.into();
assert_eq!(v, [1, 2, 3]);
}
{
let v: (i32, i32, i32) = v.into();
assert_eq!(v, (1, 2, 3));
}
}
#[test]
fn test_as_ref() {
let v = VECTOR3;
{
let v: &[i32; 3] = v.as_ref();
assert_eq!(v, &[1, 2, 3]);
}
{
let v: &(i32, i32, i32) = v.as_ref();
assert_eq!(v, &(1, 2, 3));
}
}
#[test]
fn test_as_mut() {
let mut v = VECTOR3;
{
let v: &mut [i32; 3] = v.as_mut();
assert_eq!(v, &mut [1, 2, 3]);
}
{
let v: &mut (i32, i32, i32) = v.as_mut();
assert_eq!(v, &mut (1, 2, 3));
}
}
#[test]
fn test_from() {
assert_eq!(Vector3::from([1, 2, 3]), VECTOR3);
{
let v = &[1, 2, 3];
let v: &Vector3<_> = From::from(v);
assert_eq!(v, &VECTOR3);
}
{
let v = &mut [1, 2, 3];
let v: &mut Vector3<_> = From::from(v);
assert_eq!(v, &VECTOR3);
}
assert_eq!(Vector3::from((1, 2, 3)), VECTOR3);
{
let v = &(1, 2, 3);
let v: &Vector3<_> = From::from(v);
assert_eq!(v, &VECTOR3);
}
{
let v = &mut (1, 2, 3);
let v: &mut Vector3<_> = From::from(v);
assert_eq!(v, &VECTOR3);
}
}
}
mod vector4 {
use vector::*;
const VECTOR4: Vector4<i32> = Vector4 { x: 1, y: 2, z: 3, w: 4 };
#[test]
fn test_index() {
assert_eq!(VECTOR4[0], VECTOR4.x);
assert_eq!(VECTOR4[1], VECTOR4.y);
assert_eq!(VECTOR4[2], VECTOR4.z);
assert_eq!(VECTOR4[3], VECTOR4.w);
}
#[test]
fn test_index_mut() {
let mut v = VECTOR4;
*&mut v[2] = 0;
assert_eq!(v, [1, 2, 0, 4].into());
}
#[test]
#[should_panic]
fn test_index_out_of_bounds() {
VECTOR4[4];
}
#[test]
fn test_index_range() {
assert_eq!(&VECTOR4[..2], &[1, 2]);
assert_eq!(&VECTOR4[..3], &[1, 2, 3]);
assert_eq!(VECTOR4[..2].len(), 2);
assert_eq!(VECTOR4[..3].len(), 3);
assert_eq!(&VECTOR4[2..], &[3, 4]);
assert_eq!(&VECTOR4[1..], &[2, 3, 4]);
assert_eq!(VECTOR4[2..].len(), 2);
assert_eq!(VECTOR4[1..].len(), 3);
assert_eq!(&VECTOR4[..], &[1, 2, 3, 4]);
assert_eq!(VECTOR4[..].len(), 4);
}
#[test]
fn test_into() {
let v = VECTOR4;
{
let v: [i32; 4] = v.into();
assert_eq!(v, [1, 2, 3, 4]);
}
{
let v: (i32, i32, i32, i32) = v.into();
assert_eq!(v, (1, 2, 3, 4));
}
}
#[test]
fn test_as_ref() {
let v = VECTOR4;
{
let v: &[i32; 4] = v.as_ref();
assert_eq!(v, &[1, 2, 3, 4]);
}
{
let v: &(i32, i32, i32, i32) = v.as_ref();
assert_eq!(v, &(1, 2, 3, 4));
}
}
#[test]
fn test_as_mut() {
let mut v = VECTOR4;
{
let v: &mut[i32; 4] = v.as_mut();
assert_eq!(v, &mut [1, 2, 3, 4]);
}
{
let v: &mut(i32, i32, i32, i32) = v.as_mut();
assert_eq!(v, &mut (1, 2, 3, 4));
}
}
#[test]
fn test_from() {
assert_eq!(Vector4::from([1, 2, 3, 4]), VECTOR4);
{
let v = &[1, 2, 3, 4];
let v: &Vector4<_> = From::from(v);
assert_eq!(v, &VECTOR4);
}
{
let v = &mut [1, 2, 3, 4];
let v: &mut Vector4<_> = From::from(v);
assert_eq!(v, &VECTOR4);
}
assert_eq!(Vector4::from((1, 2, 3, 4)), VECTOR4);
{
let v = &(1, 2, 3, 4);
let v: &Vector4<_> = From::from(v);
assert_eq!(v, &VECTOR4);
}
{
let v = &mut (1, 2, 3, 4);
let v: &mut Vector4<_> = From::from(v);
assert_eq!(v, &VECTOR4);
}
}
}
}