hodasemi/cgmath
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Moved angle types to tuple structs

Browse source
This commit is contained in:
Andrew Dudney 2016-07-31 20:40:31 -07:00
parent 5a1656a461
commit 3d3b9c96ca
10 changed files with 137 additions and 149 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

76
src/angle.rs
View file

@ -35,7 +35,7 @@ use num::BaseFloat;
#[derive(Copy, Clone, PartialEq, PartialOrd)] #[derive(Copy, Clone, PartialEq, PartialOrd)]
#[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))] #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
#[cfg_attr(feature = "eders", derive(Serialize, Deserialize))] #[cfg_attr(feature = "eders", derive(Serialize, Deserialize))]
pub struct Rad<S> { pub s: S } pub struct Rad<S>(pub S);
/// An angle, in degrees. /// An angle, in degrees.
/// ///
@ -44,40 +44,28 @@ pub struct Rad<S> { pub s: S }
#[derive(Copy, Clone, PartialEq, PartialOrd)] #[derive(Copy, Clone, PartialEq, PartialOrd)]
#[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))] #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
#[cfg_attr(feature = "eders", derive(Serialize, Deserialize))] #[cfg_attr(feature = "eders", derive(Serialize, Deserialize))]
pub struct Deg<S> { pub s: S } pub struct Deg<S>(pub S);
/// Create a new angle, in radians
#[inline] pub fn rad<S: BaseFloat>(s: S) -> Rad<S> { Rad { s: s } }
/// Create a new angle, in degrees
#[inline] pub fn deg<S: BaseFloat>(s: S) -> Deg<S> { Deg { s: s } }
impl<S> From<Rad<S>> for Deg<S> where S: BaseFloat { impl<S> From<Rad<S>> for Deg<S> where S: BaseFloat {
#[inline] #[inline]
fn from(r: Rad<S>) -> Deg<S> { fn from(rad: Rad<S>) -> Deg<S> {
Deg::new(r.s * cast(180.0 / f64::consts::PI).unwrap()) Deg(rad.0 * cast(180.0 / f64::consts::PI).unwrap())
} }
} }
impl<S> From<Deg<S>> for Rad<S> where S: BaseFloat { impl<S> From<Deg<S>> for Rad<S> where S: BaseFloat {
#[inline] #[inline]
fn from(d: Deg<S>) -> Rad<S> { fn from(deg: Deg<S>) -> Rad<S> {
Rad::new(d.s * cast(f64::consts::PI / 180.0).unwrap()) Rad(deg.0 * cast(f64::consts::PI / 180.0).unwrap())
} }
} }
macro_rules! impl_angle { macro_rules! impl_angle {
($Angle:ident, $fmt:expr, $full_turn:expr, $hi:expr) => { ($Angle:ident, $fmt:expr, $full_turn:expr, $hi:expr) => {
impl<S: BaseFloat> $Angle<S> {
#[inline]
pub fn new(value: S) -> $Angle<S> {
$Angle { s: value }
}
}
impl<S: BaseFloat> Zero for $Angle<S> { impl<S: BaseFloat> Zero for $Angle<S> {
#[inline] #[inline]
fn zero() -> $Angle<S> { fn zero() -> $Angle<S> {
$Angle::new(S::zero()) $Angle(S::zero())
} }
#[inline] #[inline]
@ -89,66 +77,66 @@ macro_rules! impl_angle {
impl<S: BaseFloat> Angle for $Angle<S> { impl<S: BaseFloat> Angle for $Angle<S> {
type Unitless = S; type Unitless = S;
#[inline] fn full_turn() -> $Angle<S> { $Angle::new(cast($full_turn).unwrap()) } #[inline] fn full_turn() -> $Angle<S> { $Angle(cast($full_turn).unwrap()) }
#[inline] fn sin(self) -> S { Rad::from(self).s.sin() } #[inline] fn sin(self) -> S { Rad::from(self).0.sin() }
#[inline] fn cos(self) -> S { Rad::from(self).s.cos() } #[inline] fn cos(self) -> S { Rad::from(self).0.cos() }
#[inline] fn tan(self) -> S { Rad::from(self).s.tan() } #[inline] fn tan(self) -> S { Rad::from(self).0.tan() }
#[inline] fn sin_cos(self) -> (S, S) { Rad::from(self).s.sin_cos() } #[inline] fn sin_cos(self) -> (S, S) { Rad::from(self).0.sin_cos() }
#[inline] fn asin(a: S) -> $Angle<S> { Rad::new(a.asin()).into() } #[inline] fn asin(a: S) -> $Angle<S> { Rad(a.asin()).into() }
#[inline] fn acos(a: S) -> $Angle<S> { Rad::new(a.acos()).into() } #[inline] fn acos(a: S) -> $Angle<S> { Rad(a.acos()).into() }
#[inline] fn atan(a: S) -> $Angle<S> { Rad::new(a.atan()).into() } #[inline] fn atan(a: S) -> $Angle<S> { Rad(a.atan()).into() }
#[inline] fn atan2(a: S, b: S) -> $Angle<S> { Rad::new(a.atan2(b)).into() } #[inline] fn atan2(a: S, b: S) -> $Angle<S> { Rad(a.atan2(b)).into() }
} }
impl<S: BaseFloat> Neg for $Angle<S> { impl<S: BaseFloat> Neg for $Angle<S> {
type Output = $Angle<S>; type Output = $Angle<S>;
#[inline] #[inline]
fn neg(self) -> $Angle<S> { $Angle::new(-self.s) } fn neg(self) -> $Angle<S> { $Angle(-self.0) }
} }
impl<'a, S: BaseFloat> Neg for &'a $Angle<S> { impl<'a, S: BaseFloat> Neg for &'a $Angle<S> {
type Output = $Angle<S>; type Output = $Angle<S>;
#[inline] #[inline]
fn neg(self) -> $Angle<S> { $Angle::new(-self.s) } fn neg(self) -> $Angle<S> { $Angle(-self.0) }
} }
impl_operator!(<S: BaseFloat> Add<$Angle<S> > for $Angle<S> { impl_operator!(<S: BaseFloat> Add<$Angle<S> > for $Angle<S> {
fn add(lhs, rhs) -> $Angle<S> { $Angle::new(lhs.s + rhs.s) } fn add(lhs, rhs) -> $Angle<S> { $Angle(lhs.0 + rhs.0) }
}); });
impl_operator!(<S: BaseFloat> Sub<$Angle<S> > for $Angle<S> { impl_operator!(<S: BaseFloat> Sub<$Angle<S> > for $Angle<S> {
fn sub(lhs, rhs) -> $Angle<S> { $Angle::new(lhs.s - rhs.s) } fn sub(lhs, rhs) -> $Angle<S> { $Angle(lhs.0 - rhs.0) }
}); });
impl_operator!(<S: BaseFloat> Div<$Angle<S> > for $Angle<S> { impl_operator!(<S: BaseFloat> Div<$Angle<S> > for $Angle<S> {
fn div(lhs, rhs) -> S { lhs.s / rhs.s } fn div(lhs, rhs) -> S { lhs.0 / rhs.0 }
}); });
impl_operator!(<S: BaseFloat> Rem<$Angle<S> > for $Angle<S> { impl_operator!(<S: BaseFloat> Rem<$Angle<S> > for $Angle<S> {
fn rem(lhs, rhs) -> $Angle<S> { $Angle::new(lhs.s % rhs.s) } fn rem(lhs, rhs) -> $Angle<S> { $Angle(lhs.0 % rhs.0) }
}); });
impl_assignment_operator!(<S: BaseFloat> AddAssign<$Angle<S> > for $Angle<S> { impl_assignment_operator!(<S: BaseFloat> AddAssign<$Angle<S> > for $Angle<S> {
fn add_assign(&mut self, other) { self.s += other.s; } fn add_assign(&mut self, other) { self.0 += other.0; }
}); });
impl_assignment_operator!(<S: BaseFloat> SubAssign<$Angle<S> > for $Angle<S> { impl_assignment_operator!(<S: BaseFloat> SubAssign<$Angle<S> > for $Angle<S> {
fn sub_assign(&mut self, other) { self.s -= other.s; } fn sub_assign(&mut self, other) { self.0 -= other.0; }
}); });
impl_assignment_operator!(<S: BaseFloat> RemAssign<$Angle<S> > for $Angle<S> { impl_assignment_operator!(<S: BaseFloat> RemAssign<$Angle<S> > for $Angle<S> {
fn rem_assign(&mut self, other) { self.s %= other.s; } fn rem_assign(&mut self, other) { self.0 %= other.0; }
}); });
impl_operator!(<S: BaseFloat> Mul<S> for $Angle<S> { impl_operator!(<S: BaseFloat> Mul<S> for $Angle<S> {
fn mul(lhs, scalar) -> $Angle<S> { $Angle::new(lhs.s * scalar) } fn mul(lhs, scalar) -> $Angle<S> { $Angle(lhs.0 * scalar) }
}); });
impl_operator!(<S: BaseFloat> Div<S> for $Angle<S> { impl_operator!(<S: BaseFloat> Div<S> for $Angle<S> {
fn div(lhs, scalar) -> $Angle<S> { $Angle::new(lhs.s / scalar) } fn div(lhs, scalar) -> $Angle<S> { $Angle(lhs.0 / scalar) }
}); });
impl_assignment_operator!(<S: BaseFloat> MulAssign<S> for $Angle<S> { impl_assignment_operator!(<S: BaseFloat> MulAssign<S> for $Angle<S> {
fn mul_assign(&mut self, scalar) { self.s *= scalar; } fn mul_assign(&mut self, scalar) { self.0 *= scalar; }
}); });
impl_assignment_operator!(<S: BaseFloat> DivAssign<S> for $Angle<S> { impl_assignment_operator!(<S: BaseFloat> DivAssign<S> for $Angle<S> {
fn div_assign(&mut self, scalar) { self.s /= scalar; } fn div_assign(&mut self, scalar) { self.0 /= scalar; }
}); });
impl<S: BaseFloat> ApproxEq for $Angle<S> { impl<S: BaseFloat> ApproxEq for $Angle<S> {
@ -156,20 +144,20 @@ macro_rules! impl_angle {
#[inline] #[inline]
fn approx_eq_eps(&self, other: &$Angle<S>, epsilon: &S) -> bool { fn approx_eq_eps(&self, other: &$Angle<S>, epsilon: &S) -> bool {
self.s.approx_eq_eps(&other.s, epsilon) self.0.approx_eq_eps(&other.0, epsilon)
} }
} }
impl<S: BaseFloat + SampleRange> Rand for $Angle<S> { impl<S: BaseFloat + SampleRange> Rand for $Angle<S> {
#[inline] #[inline]
fn rand<R: Rng>(rng: &mut R) -> $Angle<S> { fn rand<R: Rng>(rng: &mut R) -> $Angle<S> {
$Angle::new(rng.gen_range(cast(-$hi).unwrap(), cast($hi).unwrap())) $Angle(rng.gen_range(cast(-$hi).unwrap(), cast($hi).unwrap()))
} }
} }
impl<S: fmt::Debug> fmt::Debug for $Angle<S> { impl<S: fmt::Debug> fmt::Debug for $Angle<S> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, $fmt, self.s) write!(f, $fmt, self.0)
} }
} }
} }

6
src/euler.rs
View file

@ -63,9 +63,9 @@ use num::BaseFloat;
/// use cgmath::{Deg, Euler, Quaternion}; /// use cgmath::{Deg, Euler, Quaternion};
/// ///
/// let rotation = Quaternion::from(Euler { /// let rotation = Quaternion::from(Euler {
/// x: Deg::new(90.0), /// x: Deg(90.0),
/// y: Deg::new(45.0), /// y: Deg(45.0),
/// z: Deg::new(15.0), /// z: Deg(15.0),
/// }); /// });
/// ``` /// ```
/// ///

2
src/lib.rs
View file

@ -72,7 +72,7 @@ pub use matrix::{Matrix2, Matrix3, Matrix4};
pub use quaternion::Quaternion; pub use quaternion::Quaternion;
pub use vector::{Vector1, Vector2, Vector3, Vector4, dot, vec1, vec2, vec3, vec4}; pub use vector::{Vector1, Vector2, Vector3, Vector4, dot, vec1, vec2, vec3, vec4};
pub use angle::{Deg, Rad, deg, rad}; pub use angle::{Deg, Rad};
pub use euler::Euler; pub use euler::Euler;
pub use point::{Point1, Point2, Point3}; pub use point::{Point1, Point2, Point3};
pub use rotation::*; pub use rotation::*;

6
src/rotation.rs
View file

@ -110,7 +110,7 @@ pub trait Rotation3<S: BaseFloat>: Rotation<Point3<S>>
/// matrix: /// matrix:
/// ///
/// ```no_run /// ```no_run
/// use cgmath::rad; /// use cgmath::Rad;
/// use cgmath::Vector2; /// use cgmath::Vector2;
/// use cgmath::{Matrix, Matrix2}; /// use cgmath::{Matrix, Matrix2};
/// use cgmath::{Rotation, Rotation2, Basis2}; /// use cgmath::{Rotation, Rotation2, Basis2};
@ -120,7 +120,7 @@ pub trait Rotation3<S: BaseFloat>: Rotation<Point3<S>>
/// // For simplicity, we will rotate the unit x vector to the unit y vector -- /// // For simplicity, we will rotate the unit x vector to the unit y vector --
/// // so the angle is 90 degrees, or π/2. /// // so the angle is 90 degrees, or π/2.
/// let unit_x: Vector2<f64> = Vector2::unit_x(); /// let unit_x: Vector2<f64> = Vector2::unit_x();
/// let rot: Basis2<f64> = Rotation2::from_angle(rad(0.5f64 * f64::consts::PI)); /// let rot: Basis2<f64> = Rotation2::from_angle(Rad(0.5f64 * f64::consts::PI));
/// ///
/// // Rotate the vector using the two-dimensional rotation matrix: /// // Rotate the vector using the two-dimensional rotation matrix:
/// let unit_y = rot.rotate_vector(unit_x); /// let unit_y = rot.rotate_vector(unit_x);
@ -135,7 +135,7 @@ pub trait Rotation3<S: BaseFloat>: Rotation<Point3<S>>
/// assert_eq!(unit_y2, unit_y); /// assert_eq!(unit_y2, unit_y);
/// ///
/// // Note that we can also concatenate rotations: /// // Note that we can also concatenate rotations:
/// let rot_half: Basis2<f64> = Rotation2::from_angle(rad(0.25f64 * f64::consts::PI)); /// let rot_half: Basis2<f64> = Rotation2::from_angle(Rad(0.25f64 * f64::consts::PI));
/// let unit_y3 = (rot_half * rot_half).rotate_vector(unit_x); /// let unit_y3 = (rot_half * rot_half).rotate_vector(unit_x);
/// assert!(unit_y3.approx_eq(&unit_y2)); /// assert!(unit_y3.approx_eq(&unit_y2));
/// ``` /// ```

14
src/structure.rs
View file

@ -608,7 +608,7 @@ pub trait Angle where
/// use cgmath::prelude::*; /// use cgmath::prelude::*;
/// use cgmath::Rad; /// use cgmath::Rad;
/// ///
/// let angle = Rad::new(35.0); /// let angle = Rad(35.0);
/// let ratio: f32 = Rad::sin(angle); /// let ratio: f32 = Rad::sin(angle);
/// ``` /// ```
fn sin(self) -> Self::Unitless; fn sin(self) -> Self::Unitless;
@ -619,7 +619,7 @@ pub trait Angle where
/// use cgmath::prelude::*; /// use cgmath::prelude::*;
/// use cgmath::Rad; /// use cgmath::Rad;
/// ///
/// let angle = Rad::new(35.0); /// let angle = Rad(35.0);
/// let ratio: f32 = Rad::cos(angle); /// let ratio: f32 = Rad::cos(angle);
/// ``` /// ```
fn cos(self) -> Self::Unitless; fn cos(self) -> Self::Unitless;
@ -630,7 +630,7 @@ pub trait Angle where
/// use cgmath::prelude::*; /// use cgmath::prelude::*;
/// use cgmath::Rad; /// use cgmath::Rad;
/// ///
/// let angle = Rad::new(35.0); /// let angle = Rad(35.0);
/// let ratio: f32 = Rad::tan(angle); /// let ratio: f32 = Rad::tan(angle);
/// ``` /// ```
fn tan(self) -> Self::Unitless; fn tan(self) -> Self::Unitless;
@ -645,7 +645,7 @@ pub trait Angle where
/// use cgmath::prelude::*; /// use cgmath::prelude::*;
/// use cgmath::Rad; /// use cgmath::Rad;
/// ///
/// let angle = Rad::new(35.0); /// let angle = Rad(35.0);
/// let (s, c) = Rad::sin_cos(angle); /// let (s, c) = Rad::sin_cos(angle);
/// ``` /// ```
fn sin_cos(self) -> (Self::Unitless, Self::Unitless); fn sin_cos(self) -> (Self::Unitless, Self::Unitless);
@ -658,7 +658,7 @@ pub trait Angle where
/// use cgmath::prelude::*; /// use cgmath::prelude::*;
/// use cgmath::Rad; /// use cgmath::Rad;
/// ///
/// let angle = Rad::new(35.0); /// let angle = Rad(35.0);
/// let ratio: f32 = Rad::csc(angle); /// let ratio: f32 = Rad::csc(angle);
/// ``` /// ```
#[inline] #[inline]
@ -674,7 +674,7 @@ pub trait Angle where
/// use cgmath::prelude::*; /// use cgmath::prelude::*;
/// use cgmath::Rad; /// use cgmath::Rad;
/// ///
/// let angle = Rad::new(35.0); /// let angle = Rad(35.0);
/// let ratio: f32 = Rad::cot(angle); /// let ratio: f32 = Rad::cot(angle);
/// ``` /// ```
#[inline] #[inline]
@ -690,7 +690,7 @@ pub trait Angle where
/// use cgmath::prelude::*; /// use cgmath::prelude::*;
/// use cgmath::Rad; /// use cgmath::Rad;
/// ///
/// let angle = Rad::new(35.0); /// let angle = Rad(35.0);
/// let ratio: f32 = Rad::sec(angle); /// let ratio: f32 = Rad::sec(angle);
/// ``` /// ```
#[inline] #[inline]

18
tests/angle.rs
View file

@ -15,24 +15,24 @@
extern crate cgmath; extern crate cgmath;
use cgmath::{Rad, Deg, rad, deg}; use cgmath::{Rad, Deg};
use cgmath::ApproxEq; use cgmath::ApproxEq;
#[test] #[test]
fn conv() { fn conv() {
let angle: Rad<_> = deg(-5.0f64).into(); let angle: Rad<_> = Deg(-5.0f64).into();
let angle: Deg<_> = angle.into(); let angle: Deg<_> = angle.into();
assert!(angle.approx_eq(&deg(-5.0f64))); assert!(angle.approx_eq(&Deg(-5.0f64)));
let angle: Rad<_> = deg(30.0f64).into(); let angle: Rad<_> = Deg(30.0f64).into();
let angle: Deg<_> = angle.into(); let angle: Deg<_> = angle.into();
assert!(angle.approx_eq(&deg(30.0f64))); assert!(angle.approx_eq(&Deg(30.0f64)));
let angle: Deg<_> = rad(-5.0f64).into(); let angle: Deg<_> = Rad(-5.0f64).into();
let angle: Rad<_> = angle.into(); let angle: Rad<_> = angle.into();
assert!(angle.approx_eq(&rad(-5.0f64))); assert!(angle.approx_eq(&Rad(-5.0f64)));
let angle: Deg<_> = rad(30.0f64).into(); let angle: Deg<_> = Rad(30.0f64).into();
let angle: Rad<_> = angle.into(); let angle: Rad<_> = angle.into();
assert!(angle.approx_eq(&rad(30.0f64))); assert!(angle.approx_eq(&Rad(30.0f64)));
} }

80
tests/matrix.rs
View file

@ -152,7 +152,7 @@ pub mod matrix2 {
#[test] #[test]
fn test_from_angle() { fn test_from_angle() {
// Rotate the vector (1, 0) by π/2 radians to the vector (0, 1) // Rotate the vector (1, 0) by π/2 radians to the vector (0, 1)
let rot1 = Matrix2::from_angle(rad(0.5f64 * f64::consts::PI)); let rot1 = Matrix2::from_angle(Rad(0.5f64 * f64::consts::PI));
assert_approx_eq!(rot1 * Vector2::unit_x(), &Vector2::unit_y()); assert_approx_eq!(rot1 * Vector2::unit_x(), &Vector2::unit_y());
// Rotate the vector (-1, 0) by -π/2 radians to the vector (0, 1) // Rotate the vector (-1, 0) by -π/2 radians to the vector (0, 1)
@ -160,7 +160,7 @@ pub mod matrix2 {
assert_approx_eq!(rot2 * -Vector2::unit_x(), &Vector2::unit_y()); assert_approx_eq!(rot2 * -Vector2::unit_x(), &Vector2::unit_y());
// Rotate the vector (1, 1) by π radians to the vector (-1, -1) // Rotate the vector (1, 1) by π radians to the vector (-1, -1)
let rot3: Matrix2<f64> = Matrix2::from_angle(rad(f64::consts::PI)); let rot3: Matrix2<f64> = Matrix2::from_angle(Rad(f64::consts::PI));
assert_approx_eq!(rot3 * Vector2::new(1.0, 1.0), &Vector2::new(-1.0, -1.0)); assert_approx_eq!(rot3 * Vector2::new(1.0, 1.0), &Vector2::new(-1.0, -1.0));
} }
} }
@ -318,13 +318,13 @@ pub mod matrix3 {
fn check_from_axis_angle_x(pitch: Rad<f32>) { fn check_from_axis_angle_x(pitch: Rad<f32>) {
let found = Matrix3::from_angle_x(pitch); let found = Matrix3::from_angle_x(pitch);
let expected = Matrix3::from(Euler { x: pitch, y: rad(0.0), z: rad(0.0) }); let expected = Matrix3::from(Euler { x: pitch, y: Rad(0.0), z: Rad(0.0) });
assert_approx_eq_eps!(found, expected, 0.001); assert_approx_eq_eps!(found, expected, 0.001);
} }
#[test] fn test_zero() { check_from_axis_angle_x(rad(0.0)); } #[test] fn test_zero() { check_from_axis_angle_x(Rad(0.0)); }
#[test] fn test_pos_1() { check_from_axis_angle_x(rad(1.0)); } #[test] fn test_pos_1() { check_from_axis_angle_x(Rad(1.0)); }
#[test] fn test_neg_1() { check_from_axis_angle_x(rad(-1.0)); } #[test] fn test_neg_1() { check_from_axis_angle_x(Rad(-1.0)); }
} }
mod from_axis_y { mod from_axis_y {
@ -332,13 +332,13 @@ pub mod matrix3 {
fn check_from_axis_angle_y(yaw: Rad<f32>) { fn check_from_axis_angle_y(yaw: Rad<f32>) {
let found = Matrix3::from_angle_y(yaw); let found = Matrix3::from_angle_y(yaw);
let expected = Matrix3::from(Euler { x: rad(0.0), y: yaw, z: rad(0.0) }); let expected = Matrix3::from(Euler { x: Rad(0.0), y: yaw, z: Rad(0.0) });
assert_approx_eq_eps!(found, expected, 0.001); assert_approx_eq_eps!(found, expected, 0.001);
} }
#[test] fn test_zero() { check_from_axis_angle_y(rad(0.0)); } #[test] fn test_zero() { check_from_axis_angle_y(Rad(0.0)); }
#[test] fn test_pos_1() { check_from_axis_angle_y(rad(1.0)); } #[test] fn test_pos_1() { check_from_axis_angle_y(Rad(1.0)); }
#[test] fn test_neg_1() { check_from_axis_angle_y(rad(-1.0)); } #[test] fn test_neg_1() { check_from_axis_angle_y(Rad(-1.0)); }
} }
mod from_axis_z { mod from_axis_z {
@ -346,13 +346,13 @@ pub mod matrix3 {
fn check_from_axis_angle_z(roll: Rad<f32>) { fn check_from_axis_angle_z(roll: Rad<f32>) {
let found = Matrix3::from_angle_z(roll); let found = Matrix3::from_angle_z(roll);
let expected = Matrix3::from(Euler { x: rad(0.0), y: rad(0.0), z: roll }); let expected = Matrix3::from(Euler { x: Rad(0.0), y: Rad(0.0), z: roll });
assert_approx_eq_eps!(found, expected, 0.001); assert_approx_eq_eps!(found, expected, 0.001);
} }
#[test] fn test_zero() { check_from_axis_angle_z(rad(0.0)); } #[test] fn test_zero() { check_from_axis_angle_z(Rad(0.0)); }
#[test] fn test_pos_1() { check_from_axis_angle_z(rad(1.0)); } #[test] fn test_pos_1() { check_from_axis_angle_z(Rad(1.0)); }
#[test] fn test_neg_1() { check_from_axis_angle_z(rad(-1.0)); } #[test] fn test_neg_1() { check_from_axis_angle_z(Rad(-1.0)); }
} }
mod from_axis_angle { mod from_axis_angle {
@ -361,13 +361,13 @@ pub mod matrix3 {
fn check_from_axis_angle_x(pitch: Rad<f32>) { fn check_from_axis_angle_x(pitch: Rad<f32>) {
let found = Matrix3::from_axis_angle(Vector3::unit_x(), pitch); let found = Matrix3::from_axis_angle(Vector3::unit_x(), pitch);
let expected = Matrix3::from(Euler { x: pitch, y: rad(0.0), z: rad(0.0) }); let expected = Matrix3::from(Euler { x: pitch, y: Rad(0.0), z: Rad(0.0) });
assert_approx_eq_eps!(found, expected, 0.001); assert_approx_eq_eps!(found, expected, 0.001);
} }
#[test] fn test_zero() { check_from_axis_angle_x(rad(0.0)); } #[test] fn test_zero() { check_from_axis_angle_x(Rad(0.0)); }
#[test] fn test_pos_1() { check_from_axis_angle_x(rad(1.0)); } #[test] fn test_pos_1() { check_from_axis_angle_x(Rad(1.0)); }
#[test] fn test_neg_1() { check_from_axis_angle_x(rad(-1.0)); } #[test] fn test_neg_1() { check_from_axis_angle_x(Rad(-1.0)); }
} }
mod axis_y { mod axis_y {
@ -375,13 +375,13 @@ pub mod matrix3 {
fn check_from_axis_angle_y(yaw: Rad<f32>) { fn check_from_axis_angle_y(yaw: Rad<f32>) {
let found = Matrix3::from_axis_angle(Vector3::unit_y(), yaw); let found = Matrix3::from_axis_angle(Vector3::unit_y(), yaw);
let expected = Matrix3::from(Euler { x: rad(0.0), y: yaw, z: rad(0.0) }); let expected = Matrix3::from(Euler { x: Rad(0.0), y: yaw, z: Rad(0.0) });
assert_approx_eq_eps!(found, expected, 0.001); assert_approx_eq_eps!(found, expected, 0.001);
} }
#[test] fn test_zero() { check_from_axis_angle_y(rad(0.0)); } #[test] fn test_zero() { check_from_axis_angle_y(Rad(0.0)); }
#[test] fn test_pos_1() { check_from_axis_angle_y(rad(1.0)); } #[test] fn test_pos_1() { check_from_axis_angle_y(Rad(1.0)); }
#[test] fn test_neg_1() { check_from_axis_angle_y(rad(-1.0)); } #[test] fn test_neg_1() { check_from_axis_angle_y(Rad(-1.0)); }
} }
mod axis_z { mod axis_z {
@ -389,13 +389,13 @@ pub mod matrix3 {
fn check_from_axis_angle_z(roll: Rad<f32>) { fn check_from_axis_angle_z(roll: Rad<f32>) {
let found = Matrix3::from_axis_angle(Vector3::unit_z(), roll); let found = Matrix3::from_axis_angle(Vector3::unit_z(), roll);
let expected = Matrix3::from(Euler { x: rad(0.0), y: rad(0.0), z: roll }); let expected = Matrix3::from(Euler { x: Rad(0.0), y: Rad(0.0), z: roll });
assert_approx_eq_eps!(found, expected, 0.001); assert_approx_eq_eps!(found, expected, 0.001);
} }
#[test] fn test_zero() { check_from_axis_angle_z(rad(0.0)); } #[test] fn test_zero() { check_from_axis_angle_z(Rad(0.0)); }
#[test] fn test_pos_1() { check_from_axis_angle_z(rad(1.0)); } #[test] fn test_pos_1() { check_from_axis_angle_z(Rad(1.0)); }
#[test] fn test_neg_1() { check_from_axis_angle_z(rad(-1.0)); } #[test] fn test_neg_1() { check_from_axis_angle_z(Rad(-1.0)); }
} }
} }
@ -406,10 +406,10 @@ pub mod matrix3 {
fn test_x() { fn test_x() {
let vec = vec3(0.0, 0.0, 1.0); let vec = vec3(0.0, 0.0, 1.0);
let rot = Matrix3::from(Euler::new(deg(90.0), deg(0.0), deg(0.0))); let rot = Matrix3::from(Euler::new(Deg(90.0), Deg(0.0), Deg(0.0)));
assert_approx_eq!(vec3(0.0, -1.0, 0.0), rot * vec); assert_approx_eq!(vec3(0.0, -1.0, 0.0), rot * vec);
let rot = Matrix3::from(Euler::new(deg(-90.0), deg(0.0), deg(0.0))); let rot = Matrix3::from(Euler::new(Deg(-90.0), Deg(0.0), Deg(0.0)));
assert_approx_eq!(vec3(0.0, 1.0, 0.0), rot * vec); assert_approx_eq!(vec3(0.0, 1.0, 0.0), rot * vec);
} }
@ -417,10 +417,10 @@ pub mod matrix3 {
fn test_y() { fn test_y() {
let vec = vec3(0.0, 0.0, 1.0); let vec = vec3(0.0, 0.0, 1.0);
let rot = Matrix3::from(Euler::new(deg(0.0), deg(90.0), deg(0.0))); let rot = Matrix3::from(Euler::new(Deg(0.0), Deg(90.0), Deg(0.0)));
assert_approx_eq!(vec3(1.0, 0.0, 0.0), rot * vec); assert_approx_eq!(vec3(1.0, 0.0, 0.0), rot * vec);
let rot = Matrix3::from(Euler::new(deg(0.0), deg(-90.0), deg(0.0))); let rot = Matrix3::from(Euler::new(Deg(0.0), Deg(-90.0), Deg(0.0)));
assert_approx_eq!(vec3(-1.0, 0.0, 0.0), rot * vec); assert_approx_eq!(vec3(-1.0, 0.0, 0.0), rot * vec);
} }
@ -428,10 +428,10 @@ pub mod matrix3 {
fn test_z() { fn test_z() {
let vec = vec3(1.0, 0.0, 0.0); let vec = vec3(1.0, 0.0, 0.0);
let rot = Matrix3::from(Euler::new(deg(0.0), deg(0.0), deg(90.0))); let rot = Matrix3::from(Euler::new(Deg(0.0), Deg(0.0), Deg(90.0)));
assert_approx_eq!(vec3(0.0, 1.0, 0.0), rot * vec); assert_approx_eq!(vec3(0.0, 1.0, 0.0), rot * vec);
let rot = Matrix3::from(Euler::new(deg(0.0), deg(0.0), deg(-90.0))); let rot = Matrix3::from(Euler::new(Deg(0.0), Deg(0.0), Deg(-90.0)));
assert_approx_eq!(vec3(0.0, -1.0, 0.0), rot * vec); assert_approx_eq!(vec3(0.0, -1.0, 0.0), rot * vec);
} }
@ -441,7 +441,7 @@ pub mod matrix3 {
fn test_x_then_y() { fn test_x_then_y() {
let vec = vec3(0.0, 1.0, 0.0); let vec = vec3(0.0, 1.0, 0.0);
let rot = Matrix3::from(Euler::new(deg(90.0), deg(90.0), deg(0.0))); let rot = Matrix3::from(Euler::new(Deg(90.0), Deg(90.0), Deg(0.0)));
assert_approx_eq!(vec3(0.0, 0.0, 1.0), rot * vec); assert_approx_eq!(vec3(0.0, 0.0, 1.0), rot * vec);
} }
@ -450,7 +450,7 @@ pub mod matrix3 {
fn test_y_then_z() { fn test_y_then_z() {
let vec = vec3(0.0, 0.0, 1.0); let vec = vec3(0.0, 0.0, 1.0);
let rot = Matrix3::from(Euler::new(deg(0.0), deg(90.0), deg(90.0))); let rot = Matrix3::from(Euler::new(Deg(0.0), Deg(90.0), Deg(90.0)));
assert_approx_eq!(vec3(1.0, 0.0, 0.0), rot * vec); assert_approx_eq!(vec3(1.0, 0.0, 0.0), rot * vec);
} }
} }
@ -462,7 +462,7 @@ pub mod matrix3 {
fn test_x() { fn test_x() {
let vec = vec3(0.0, 0.0, 1.0); let vec = vec3(0.0, 0.0, 1.0);
let rot = Matrix3::from_angle_x(deg(90.0)); let rot = Matrix3::from_angle_x(Deg(90.0));
println!("x mat: {:?}", rot); println!("x mat: {:?}", rot);
assert_approx_eq!(vec3(0.0, -1.0, 0.0), rot * vec); assert_approx_eq!(vec3(0.0, -1.0, 0.0), rot * vec);
} }
@ -471,7 +471,7 @@ pub mod matrix3 {
fn test_y() { fn test_y() {
let vec = vec3(0.0, 0.0, 1.0); let vec = vec3(0.0, 0.0, 1.0);
let rot = Matrix3::from_angle_y(deg(90.0)); let rot = Matrix3::from_angle_y(Deg(90.0));
assert_approx_eq!(vec3(1.0, 0.0, 0.0), rot * vec); assert_approx_eq!(vec3(1.0, 0.0, 0.0), rot * vec);
} }
@ -479,7 +479,7 @@ pub mod matrix3 {
fn test_z() { fn test_z() {
let vec = vec3(1.0, 0.0, 0.0); let vec = vec3(1.0, 0.0, 0.0);
let rot = Matrix3::from_angle_z(deg(90.0)); let rot = Matrix3::from_angle_z(Deg(90.0));
assert_approx_eq!(vec3(0.0, 1.0, 0.0), rot * vec); assert_approx_eq!(vec3(0.0, 1.0, 0.0), rot * vec);
} }
@ -487,7 +487,7 @@ pub mod matrix3 {
fn test_xy() { fn test_xy() {
let vec = vec3(0.0, 0.0, 1.0); let vec = vec3(0.0, 0.0, 1.0);
let rot = Matrix3::from_axis_angle(vec3(1.0, 1.0, 0.0).normalize(), deg(90.0)); let rot = Matrix3::from_axis_angle(vec3(1.0, 1.0, 0.0).normalize(), Deg(90.0));
assert_approx_eq!(vec3(2.0f32.sqrt() / 2.0, -2.0f32.sqrt() / 2.0, 0.0), rot * vec); assert_approx_eq!(vec3(2.0f32.sqrt() / 2.0, -2.0f32.sqrt() / 2.0, 0.0), rot * vec);
} }
@ -495,7 +495,7 @@ pub mod matrix3 {
fn test_yz() { fn test_yz() {
let vec = vec3(1.0, 0.0, 0.0); let vec = vec3(1.0, 0.0, 0.0);
let rot = Matrix3::from_axis_angle(vec3(0.0, 1.0, 1.0).normalize(), deg(-90.0)); let rot = Matrix3::from_axis_angle(vec3(0.0, 1.0, 1.0).normalize(), Deg(-90.0));
assert_approx_eq!(vec3(0.0, -2.0f32.sqrt() / 2.0, 2.0f32.sqrt() / 2.0), rot * vec); assert_approx_eq!(vec3(0.0, -2.0f32.sqrt() / 2.0, 2.0f32.sqrt() / 2.0), rot * vec);
} }
@ -503,7 +503,7 @@ pub mod matrix3 {
fn test_xz() { fn test_xz() {
let vec = vec3(0.0, 1.0, 0.0); let vec = vec3(0.0, 1.0, 0.0);
let rot = Matrix3::from_axis_angle(vec3(1.0, 0.0, 1.0).normalize(), deg(90.0)); let rot = Matrix3::from_axis_angle(vec3(1.0, 0.0, 1.0).normalize(), Deg(90.0));
assert_approx_eq!(vec3(-2.0f32.sqrt() / 2.0, 0.0, 2.0f32.sqrt() / 2.0), rot * vec); assert_approx_eq!(vec3(-2.0f32.sqrt() / 2.0, 0.0, 2.0f32.sqrt() / 2.0), rot * vec);
} }
} }

62
tests/quaternion.rs
View file

@ -43,12 +43,12 @@ mod operators {
#[test] #[test]
fn test_mul() { fn test_mul() {
impl_test_mul!(2.0f32, Quaternion::from(Euler { x: rad(1f32), y: rad(1f32), z: rad(1f32) })); impl_test_mul!(2.0f32, Quaternion::from(Euler { x: Rad(1f32), y: Rad(1f32), z: Rad(1f32) }));
} }
#[test] #[test]
fn test_div() { fn test_div() {
impl_test_div!(2.0f32, Quaternion::from(Euler { x: rad(1f32), y: rad(1f32), z: rad(1f32) })); impl_test_div!(2.0f32, Quaternion::from(Euler { x: Rad(1f32), y: Rad(1f32), z: Rad(1f32) }));
} }
} }
@ -63,17 +63,17 @@ mod to_from_euler {
const HPI: f32 = f32::consts::FRAC_PI_2; const HPI: f32 = f32::consts::FRAC_PI_2;
#[test] fn test_zero() { check_euler(Euler { x: rad( 0f32), y: rad( 0f32), z: rad( 0f32) }); } #[test] fn test_zero() { check_euler(Euler { x: Rad( 0f32), y: Rad( 0f32), z: Rad( 0f32) }); }
#[test] fn test_yaw_pos_1() { check_euler(Euler { x: rad( 0f32), y: rad( 1f32), z: rad( 0f32) }); } #[test] fn test_yaw_pos_1() { check_euler(Euler { x: Rad( 0f32), y: Rad( 1f32), z: Rad( 0f32) }); }
#[test] fn test_yaw_neg_1() { check_euler(Euler { x: rad( 0f32), y: rad(-1f32), z: rad( 0f32) }); } #[test] fn test_yaw_neg_1() { check_euler(Euler { x: Rad( 0f32), y: Rad(-1f32), z: Rad( 0f32) }); }
#[test] fn test_pitch_pos_1() { check_euler(Euler { x: rad( 1f32), y: rad( 0f32), z: rad( 0f32) }); } #[test] fn test_pitch_pos_1() { check_euler(Euler { x: Rad( 1f32), y: Rad( 0f32), z: Rad( 0f32) }); }
#[test] fn test_pitch_neg_1() { check_euler(Euler { x: rad(-1f32), y: rad( 0f32), z: rad( 0f32) }); } #[test] fn test_pitch_neg_1() { check_euler(Euler { x: Rad(-1f32), y: Rad( 0f32), z: Rad( 0f32) }); }
#[test] fn test_roll_pos_1() { check_euler(Euler { x: rad( 0f32), y: rad( 0f32), z: rad( 1f32) }); } #[test] fn test_roll_pos_1() { check_euler(Euler { x: Rad( 0f32), y: Rad( 0f32), z: Rad( 1f32) }); }
#[test] fn test_roll_neg_1() { check_euler(Euler { x: rad( 0f32), y: rad( 0f32), z: rad(-1f32) }); } #[test] fn test_roll_neg_1() { check_euler(Euler { x: Rad( 0f32), y: Rad( 0f32), z: Rad(-1f32) }); }
#[test] fn test_pitch_yaw_roll_pos_1() { check_euler(Euler { x: rad( 1f32), y: rad( 1f32), z: rad( 1f32) }); } #[test] fn test_pitch_yaw_roll_pos_1() { check_euler(Euler { x: Rad( 1f32), y: Rad( 1f32), z: Rad( 1f32) }); }
#[test] fn test_pitch_yaw_roll_neg_1() { check_euler(Euler { x: rad(-1f32), y: rad(-1f32), z: rad(-1f32) }); } #[test] fn test_pitch_yaw_roll_neg_1() { check_euler(Euler { x: Rad(-1f32), y: Rad(-1f32), z: Rad(-1f32) }); }
#[test] fn test_pitch_yaw_roll_pos_hp() { check_euler(Euler { x: rad( 0f32), y: rad( HPI), z: rad( 1f32) }); } #[test] fn test_pitch_yaw_roll_pos_hp() { check_euler(Euler { x: Rad( 0f32), y: Rad( HPI), z: Rad( 1f32) }); }
#[test] fn test_pitch_yaw_roll_neg_hp() { check_euler(Euler { x: rad( 0f32), y: rad( -HPI), z: rad( 1f32) }); } #[test] fn test_pitch_yaw_roll_neg_hp() { check_euler(Euler { x: Rad( 0f32), y: Rad( -HPI), z: Rad( 1f32) }); }
} }
mod from { mod from {
@ -90,25 +90,25 @@ mod from {
// triggers: trace >= S::zero() // triggers: trace >= S::zero()
#[test] #[test]
fn test_positive_trace() { fn test_positive_trace() {
check_with_euler(rad(0.0f32), rad(0.0), rad(0.0f32)); check_with_euler(Rad(0.0f32), Rad(0.0), Rad(0.0f32));
} }
// triggers: (mat[0][0] > mat[1][1]) && (mat[0][0] > mat[2][2]) // triggers: (mat[0][0] > mat[1][1]) && (mat[0][0] > mat[2][2])
#[test] #[test]
fn test_xx_maximum() { fn test_xx_maximum() {
check_with_euler(rad(2.0f32), rad(1.0), rad(-1.2f32)); check_with_euler(Rad(2.0f32), Rad(1.0), Rad(-1.2f32));
} }
// triggers: mat[1][1] > mat[2][2] // triggers: mat[1][1] > mat[2][2]
#[test] #[test]
fn test_yy_maximum() { fn test_yy_maximum() {
check_with_euler(rad(2.0f32), rad(1.0), rad(3.0f32)); check_with_euler(Rad(2.0f32), Rad(1.0), Rad(3.0f32));
} }
// base case // base case
#[test] #[test]
fn test_zz_maximum() { fn test_zz_maximum() {
check_with_euler(rad(1.0f32), rad(1.0), rad(3.0f32)); check_with_euler(Rad(1.0f32), Rad(1.0), Rad(3.0f32));
} }
} }
} }
@ -156,10 +156,10 @@ mod rotate_from_euler {
fn test_x() { fn test_x() {
let vec = vec3(0.0, 0.0, 1.0); let vec = vec3(0.0, 0.0, 1.0);
let rot = Quaternion::from(Euler::new(deg(90.0), deg(0.0), deg(0.0))); let rot = Quaternion::from(Euler::new(Deg(90.0), Deg(0.0), Deg(0.0)));
assert_approx_eq!(vec3(0.0, -1.0, 0.0), rot * vec); assert_approx_eq!(vec3(0.0, -1.0, 0.0), rot * vec);
let rot = Quaternion::from(Euler::new(deg(-90.0), deg(0.0), deg(0.0))); let rot = Quaternion::from(Euler::new(Deg(-90.0), Deg(0.0), Deg(0.0)));
assert_approx_eq!(vec3(0.0, 1.0, 0.0), rot * vec); assert_approx_eq!(vec3(0.0, 1.0, 0.0), rot * vec);
} }
@ -167,10 +167,10 @@ mod rotate_from_euler {
fn test_y() { fn test_y() {
let vec = vec3(0.0, 0.0, 1.0); let vec = vec3(0.0, 0.0, 1.0);
let rot = Quaternion::from(Euler::new(deg(0.0), deg(90.0), deg(0.0))); let rot = Quaternion::from(Euler::new(Deg(0.0), Deg(90.0), Deg(0.0)));
assert_approx_eq!(vec3(1.0, 0.0, 0.0), rot * vec); assert_approx_eq!(vec3(1.0, 0.0, 0.0), rot * vec);
let rot = Quaternion::from(Euler::new(deg(0.0), deg(-90.0), deg(0.0))); let rot = Quaternion::from(Euler::new(Deg(0.0), Deg(-90.0), Deg(0.0)));
assert_approx_eq!(vec3(-1.0, 0.0, 0.0), rot * vec); assert_approx_eq!(vec3(-1.0, 0.0, 0.0), rot * vec);
} }
@ -178,10 +178,10 @@ mod rotate_from_euler {
fn test_z() { fn test_z() {
let vec = vec3(1.0, 0.0, 0.0); let vec = vec3(1.0, 0.0, 0.0);
let rot = Quaternion::from(Euler::new(deg(0.0), deg(0.0), deg(90.0))); let rot = Quaternion::from(Euler::new(Deg(0.0), Deg(0.0), Deg(90.0)));
assert_approx_eq!(vec3(0.0, 1.0, 0.0), rot * vec); assert_approx_eq!(vec3(0.0, 1.0, 0.0), rot * vec);
let rot = Quaternion::from(Euler::new(deg(0.0), deg(0.0), deg(-90.0))); let rot = Quaternion::from(Euler::new(Deg(0.0), Deg(0.0), Deg(-90.0)));
assert_approx_eq!(vec3(0.0, -1.0, 0.0), rot * vec); assert_approx_eq!(vec3(0.0, -1.0, 0.0), rot * vec);
} }
@ -191,7 +191,7 @@ mod rotate_from_euler {
fn test_x_then_y() { fn test_x_then_y() {
let vec = vec3(0.0, 1.0, 0.0); let vec = vec3(0.0, 1.0, 0.0);
let rot = Quaternion::from(Euler::new(deg(90.0), deg(90.0), deg(0.0))); let rot = Quaternion::from(Euler::new(Deg(90.0), Deg(90.0), Deg(0.0)));
assert_approx_eq!(vec3(0.0, 0.0, 1.0), rot * vec); assert_approx_eq!(vec3(0.0, 0.0, 1.0), rot * vec);
} }
@ -200,7 +200,7 @@ mod rotate_from_euler {
fn test_y_then_z() { fn test_y_then_z() {
let vec = vec3(0.0, 0.0, 1.0); let vec = vec3(0.0, 0.0, 1.0);
let rot = Quaternion::from(Euler::new(deg(0.0), deg(90.0), deg(90.0))); let rot = Quaternion::from(Euler::new(Deg(0.0), Deg(90.0), Deg(90.0)));
assert_approx_eq!(vec3(1.0, 0.0, 0.0), rot * vec); assert_approx_eq!(vec3(1.0, 0.0, 0.0), rot * vec);
} }
} }
@ -212,7 +212,7 @@ mod rotate_from_axis_angle {
fn test_x() { fn test_x() {
let vec = vec3(0.0, 0.0, 1.0); let vec = vec3(0.0, 0.0, 1.0);
let rot = Quaternion::from_angle_x(deg(90.0)); let rot = Quaternion::from_angle_x(Deg(90.0));
assert_approx_eq!(vec3(0.0, -1.0, 0.0), rot * vec); assert_approx_eq!(vec3(0.0, -1.0, 0.0), rot * vec);
} }
@ -220,7 +220,7 @@ mod rotate_from_axis_angle {
fn test_y() { fn test_y() {
let vec = vec3(0.0, 0.0, 1.0); let vec = vec3(0.0, 0.0, 1.0);
let rot = Quaternion::from_angle_y(deg(90.0)); let rot = Quaternion::from_angle_y(Deg(90.0));
assert_approx_eq!(vec3(1.0, 0.0, 0.0), rot * vec); assert_approx_eq!(vec3(1.0, 0.0, 0.0), rot * vec);
} }
@ -228,7 +228,7 @@ mod rotate_from_axis_angle {
fn test_z() { fn test_z() {
let vec = vec3(1.0, 0.0, 0.0); let vec = vec3(1.0, 0.0, 0.0);
let rot = Quaternion::from_angle_z(deg(90.0)); let rot = Quaternion::from_angle_z(Deg(90.0));
assert_approx_eq!(vec3(0.0, 1.0, 0.0), rot * vec); assert_approx_eq!(vec3(0.0, 1.0, 0.0), rot * vec);
} }
@ -236,7 +236,7 @@ mod rotate_from_axis_angle {
fn test_xy() { fn test_xy() {
let vec = vec3(0.0, 0.0, 1.0); let vec = vec3(0.0, 0.0, 1.0);
let rot = Quaternion::from_axis_angle(vec3(1.0, 1.0, 0.0).normalize(), deg(90.0)); let rot = Quaternion::from_axis_angle(vec3(1.0, 1.0, 0.0).normalize(), Deg(90.0));
assert_approx_eq!(vec3(2.0f32.sqrt() / 2.0, -2.0f32.sqrt() / 2.0, 0.0), rot * vec); assert_approx_eq!(vec3(2.0f32.sqrt() / 2.0, -2.0f32.sqrt() / 2.0, 0.0), rot * vec);
} }
@ -244,7 +244,7 @@ mod rotate_from_axis_angle {
fn test_yz() { fn test_yz() {
let vec = vec3(1.0, 0.0, 0.0); let vec = vec3(1.0, 0.0, 0.0);
let rot = Quaternion::from_axis_angle(vec3(0.0, 1.0, 1.0).normalize(), deg(-90.0)); let rot = Quaternion::from_axis_angle(vec3(0.0, 1.0, 1.0).normalize(), Deg(-90.0));
assert_approx_eq!(vec3(0.0, -2.0f32.sqrt() / 2.0, 2.0f32.sqrt() / 2.0), rot * vec); assert_approx_eq!(vec3(0.0, -2.0f32.sqrt() / 2.0, 2.0f32.sqrt() / 2.0), rot * vec);
} }
@ -252,7 +252,7 @@ mod rotate_from_axis_angle {
fn test_xz() { fn test_xz() {
let vec = vec3(0.0, 1.0, 0.0); let vec = vec3(0.0, 1.0, 0.0);
let rot = Quaternion::from_axis_angle(vec3(1.0, 0.0, 1.0).normalize(), deg(90.0)); let rot = Quaternion::from_axis_angle(vec3(1.0, 0.0, 1.0).normalize(), Deg(90.0));
assert_approx_eq!(vec3(-2.0f32.sqrt() / 2.0, 0.0, 2.0f32.sqrt() / 2.0), rot * vec); assert_approx_eq!(vec3(-2.0f32.sqrt() / 2.0, 0.0, 2.0f32.sqrt() / 2.0), rot * vec);
} }
} }

4
tests/rotation.rs
View file

@ -21,12 +21,12 @@ mod rotation {
use super::cgmath::*; use super::cgmath::*;
pub fn a2<R: Rotation2<f64>>() -> R { pub fn a2<R: Rotation2<f64>>() -> R {
Rotation2::from_angle(deg(30.0)) Rotation2::from_angle(Deg(30.0))
} }
pub fn a3<R: Rotation3<f64>>() -> R { pub fn a3<R: Rotation3<f64>>() -> R {
let axis = Vector3::new(1.0, 1.0, 0.0).normalize(); let axis = Vector3::new(1.0, 1.0, 0.0).normalize();
Rotation3::from_axis_angle(axis, deg(30.0)) Rotation3::from_axis_angle(axis, Deg(30.0))
} }
} }

18
tests/vector.rs
View file

@ -229,17 +229,17 @@ mod test_magnitude {
#[test] #[test]
fn test_angle() { fn test_angle() {
assert!(Vector2::new(1.0f64, 0.0f64).angle(Vector2::new(0.0f64, 1.0f64)).approx_eq( &rad(f64::consts::FRAC_PI_2) )); assert!(Vector2::new(1.0f64, 0.0f64).angle(Vector2::new(0.0f64, 1.0f64)).approx_eq( &Rad(f64::consts::FRAC_PI_2) ));
assert!(Vector2::new(10.0f64, 0.0f64).angle(Vector2::new(0.0f64, 5.0f64)).approx_eq( &rad(f64::consts::FRAC_PI_2) )); assert!(Vector2::new(10.0f64, 0.0f64).angle(Vector2::new(0.0f64, 5.0f64)).approx_eq( &Rad(f64::consts::FRAC_PI_2) ));
assert!(Vector2::new(-1.0f64, 0.0f64).angle(Vector2::new(0.0f64, 1.0f64)).approx_eq( &-rad(f64::consts::FRAC_PI_2) )); assert!(Vector2::new(-1.0f64, 0.0f64).angle(Vector2::new(0.0f64, 1.0f64)).approx_eq( &-Rad(f64::consts::FRAC_PI_2) ));
assert!(Vector3::new(1.0f64, 0.0f64, 1.0f64).angle(Vector3::new(1.0f64, 1.0f64, 0.0f64)).approx_eq( &rad(f64::consts::FRAC_PI_3) )); assert!(Vector3::new(1.0f64, 0.0f64, 1.0f64).angle(Vector3::new(1.0f64, 1.0f64, 0.0f64)).approx_eq( &Rad(f64::consts::FRAC_PI_3) ));
assert!(Vector3::new(10.0f64, 0.0f64, 10.0f64).angle(Vector3::new(5.0f64, 5.0f64, 0.0f64)).approx_eq( &rad(f64::consts::FRAC_PI_3) )); assert!(Vector3::new(10.0f64, 0.0f64, 10.0f64).angle(Vector3::new(5.0f64, 5.0f64, 0.0f64)).approx_eq( &Rad(f64::consts::FRAC_PI_3) ));
assert!(Vector3::new(-1.0f64, 0.0f64, -1.0f64).angle(Vector3::new(1.0f64, -1.0f64, 0.0f64)).approx_eq( &rad(2.0f64 * f64::consts::FRAC_PI_3) )); assert!(Vector3::new(-1.0f64, 0.0f64, -1.0f64).angle(Vector3::new(1.0f64, -1.0f64, 0.0f64)).approx_eq( &Rad(2.0f64 * f64::consts::FRAC_PI_3) ));
assert!(Vector4::new(1.0f64, 0.0f64, 1.0f64, 0.0f64).angle(Vector4::new(0.0f64, 1.0f64, 0.0f64, 1.0f64)).approx_eq( &rad(f64::consts::FRAC_PI_2) )); assert!(Vector4::new(1.0f64, 0.0f64, 1.0f64, 0.0f64).angle(Vector4::new(0.0f64, 1.0f64, 0.0f64, 1.0f64)).approx_eq( &Rad(f64::consts::FRAC_PI_2) ));
assert!(Vector4::new(10.0f64, 0.0f64, 10.0f64, 0.0f64).angle(Vector4::new(0.0f64, 5.0f64, 0.0f64, 5.0f64)).approx_eq( &rad(f64::consts::FRAC_PI_2) )); assert!(Vector4::new(10.0f64, 0.0f64, 10.0f64, 0.0f64).angle(Vector4::new(0.0f64, 5.0f64, 0.0f64, 5.0f64)).approx_eq( &Rad(f64::consts::FRAC_PI_2) ));
assert!(Vector4::new(-1.0f64, 0.0f64, -1.0f64, 0.0f64).angle(Vector4::new(0.0f64, 1.0f64, 0.0f64, 1.0f64)).approx_eq( &rad(f64::consts::FRAC_PI_2) )); assert!(Vector4::new(-1.0f64, 0.0f64, -1.0f64, 0.0f64).angle(Vector4::new(0.0f64, 1.0f64, 0.0f64, 1.0f64)).approx_eq( &Rad(f64::consts::FRAC_PI_2) ));
} }
#[test] #[test]