diff --git a/src/lmath.rs b/src/lmath.rs index c2fb1df..c528f0c 100644 --- a/src/lmath.rs +++ b/src/lmath.rs @@ -23,17 +23,8 @@ #[license = "ASL2"]; #[crate_type = "lib"]; -extern mod std; - pub mod mat; pub mod quat; pub mod vec; pub mod projection; - -#[cfg(test)] -mod test { - #[path = "test_mat.rs" ] mod mat; - #[path = "test_quat.rs"] mod quat; - #[path = "test_vec.rs" ] mod vec; -} diff --git a/src/mat2.rs b/src/mat2.rs index e513e19..3cab5ff 100644 --- a/src/mat2.rs +++ b/src/mat2.rs @@ -377,3 +377,172 @@ impl> ApproxEq for Mat2 { self.col(1).approx_eq_eps(other.col(1), epsilon) } } + +#[cfg(test)] +mod tests{ + use mat::*; + use vec::*; + + #[test] + fn test_mat2() { + let a = Mat2 { x: Vec2 { x: 1.0, y: 3.0 }, + y: Vec2 { x: 2.0, y: 4.0 } }; + let b = Mat2 { x: Vec2 { x: 2.0, y: 4.0 }, + y: Vec2 { x: 3.0, y: 5.0 } }; + + let v1 = Vec2::new::(1.0, 2.0); + let f1 = 0.5; + + assert_eq!(a, Mat2::new::(1.0, 3.0, + 2.0, 4.0)); + + assert_eq!(a, Mat2::from_cols::(Vec2::new::(1.0, 3.0), + Vec2::new::(2.0, 4.0))); + + assert_eq!(Mat2::from_value::(4.0), + Mat2::new::(4.0, 0.0, + 0.0, 4.0)); + + assert_eq!(*a.col(0), Vec2::new::(1.0, 3.0)); + assert_eq!(*a.col(1), Vec2::new::(2.0, 4.0)); + + assert_eq!(a.row(0), Vec2::new::(1.0, 2.0)); + assert_eq!(a.row(1), Vec2::new::(3.0, 4.0)); + + assert_eq!(*a.col(0), Vec2::new::(1.0, 3.0)); + assert_eq!(*a.col(1), Vec2::new::(2.0, 4.0)); + + assert_eq!(Mat2::identity::(), + Mat2::new::(1.0, 0.0, + 0.0, 1.0)); + + assert_eq!(Mat2::zero::(), + Mat2::new::(0.0, 0.0, + 0.0, 0.0)); + + assert_eq!(a.determinant(), -2.0); + assert_eq!(a.trace(), 5.0); + + assert_eq!(a.neg(), + Mat2::new::(-1.0, -3.0, + -2.0, -4.0)); + assert_eq!(-a, a.neg()); + assert_eq!(a.mul_t(f1), + Mat2::new::(0.5, 1.5, + 1.0, 2.0)); + assert_eq!(a.mul_v(&v1), Vec2::new::(5.0, 11.0)); + assert_eq!(a.add_m(&b), + Mat2::new::(3.0, 7.0, + 5.0, 9.0)); + assert_eq!(a.sub_m(&b), + Mat2::new::(-1.0, -1.0, + -1.0, -1.0)); + assert_eq!(a.mul_m(&b), + Mat2::new::(10.0, 22.0, + 13.0, 29.0)); + assert_eq!(a.dot(&b), 40.0); + + assert_eq!(a.transpose(), + Mat2::new::(1.0, 2.0, + 3.0, 4.0)); + + assert_eq!(a.inverse().unwrap(), + Mat2::new::(-2.0, 1.5, + 1.0, -0.5)); + + assert!(Mat2::new::(0.0, 2.0, + 0.0, 5.0).inverse().is_none()); + + let ident = Mat2::identity::(); + + assert!(ident.is_identity()); + assert!(ident.is_symmetric()); + assert!(ident.is_diagonal()); + assert!(!ident.is_rotated()); + assert!(ident.is_invertible()); + + assert!(!a.is_identity()); + assert!(!a.is_symmetric()); + assert!(!a.is_diagonal()); + assert!(a.is_rotated()); + assert!(a.is_invertible()); + + let c = Mat2::new::(2.0, 1.0, + 1.0, 2.0); + assert!(!c.is_identity()); + assert!(c.is_symmetric()); + assert!(!c.is_diagonal()); + assert!(c.is_rotated()); + assert!(c.is_invertible()); + + assert!(Mat2::from_value::(6.0).is_diagonal()); + + assert_eq!(a.to_mat3(), + Mat3::new::(1.0, 3.0, 0.0, + 2.0, 4.0, 0.0, + 0.0, 0.0, 1.0)); + + assert_eq!(a.to_mat4(), + Mat4::new::(1.0, 3.0, 0.0, 0.0, + 2.0, 4.0, 0.0, 0.0, + 0.0, 0.0, 1.0, 0.0, + 0.0, 0.0, 0.0, 1.0)); + } + + fn test_mat2_mut() { + let a = Mat2 { x: Vec2 { x: 1.0, y: 3.0 }, + y: Vec2 { x: 2.0, y: 4.0 } }; + let b = Mat2 { x: Vec2 { x: 2.0, y: 4.0 }, + y: Vec2 { x: 3.0, y: 5.0 } }; + + let f1 = 0.5; + + let mut mut_a = a; + + mut_a.swap_cols(0, 1); + assert_eq!(mut_a.col(0), a.col(1)); + assert_eq!(mut_a.col(1), a.col(0)); + mut_a = a; + + mut_a.swap_rows(0, 1); + assert_eq!(mut_a.row(0), a.row(1)); + assert_eq!(mut_a.row(1), a.row(0)); + mut_a = a; + + mut_a.to_identity(); + assert!(mut_a.is_identity()); + mut_a = a; + + mut_a.to_zero(); + assert_eq!(mut_a, Mat2::zero::()); + mut_a = a; + + mut_a.mul_self_t(f1); + assert_eq!(mut_a, a.mul_t(f1)); + mut_a = a; + + mut_a.add_self_m(&b); + assert_eq!(mut_a, a.add_m(&b)); + mut_a = a; + + mut_a.sub_self_m(&b); + assert_eq!(mut_a, a.sub_m(&b)); + mut_a = a; + + mut_a.invert_self(); + assert_eq!(mut_a, a.inverse().unwrap()); + mut_a = a; + + mut_a.transpose_self(); + assert_eq!(mut_a, a.transpose()); + // mut_a = a; + } + + #[test] + fn test_mat2_approx_eq() { + assert!(!Mat2::new::(0.000001, 0.000001, + 0.000001, 0.000001).approx_eq(&Mat2::zero::())); + assert!(Mat2::new::(0.0000001, 0.0000001, + 0.0000001, 0.0000001).approx_eq(&Mat2::zero::())); + } +} diff --git a/src/mat3.rs b/src/mat3.rs index 030921f..14bcfaf 100644 --- a/src/mat3.rs +++ b/src/mat3.rs @@ -548,3 +548,207 @@ impl> ApproxEq for Mat3 { self.col(2).approx_eq_eps(other.col(2), epsilon) } } + +#[cfg(test)] +mod tests{ + use mat::*; + use vec::*; + + #[test] + fn test_mat3() { + let a = Mat3 { x: Vec3 { x: 1.0, y: 4.0, z: 7.0 }, + y: Vec3 { x: 2.0, y: 5.0, z: 8.0 }, + z: Vec3 { x: 3.0, y: 6.0, z: 9.0 } }; + let b = Mat3 { x: Vec3 { x: 2.0, y: 5.0, z: 8.0 }, + y: Vec3 { x: 3.0, y: 6.0, z: 9.0 }, + z: Vec3 { x: 4.0, y: 7.0, z: 10.0 } }; + + let v1 = Vec3::new::(1.0, 2.0, 3.0); + let f1 = 0.5; + + assert_eq!(a, Mat3::new::(1.0, 4.0, 7.0, + 2.0, 5.0, 8.0, + 3.0, 6.0, 9.0)); + + assert_eq!(a, Mat3::from_cols::(Vec3::new::(1.0, 4.0, 7.0), + Vec3::new::(2.0, 5.0, 8.0), + Vec3::new::(3.0, 6.0, 9.0))); + + assert_eq!(*a.col(0), Vec3::new::(1.0, 4.0, 7.0)); + assert_eq!(*a.col(1), Vec3::new::(2.0, 5.0, 8.0)); + assert_eq!(*a.col(2), Vec3::new::(3.0, 6.0, 9.0)); + + assert_eq!(a.row(0), Vec3::new::(1.0, 2.0, 3.0)); + assert_eq!(a.row(1), Vec3::new::(4.0, 5.0, 6.0)); + assert_eq!(a.row(2), Vec3::new::(7.0, 8.0, 9.0)); + + assert_eq!(*a.col(0), Vec3::new::(1.0, 4.0, 7.0)); + assert_eq!(*a.col(1), Vec3::new::(2.0, 5.0, 8.0)); + assert_eq!(*a.col(2), Vec3::new::(3.0, 6.0, 9.0)); + + assert_eq!(Mat3::identity::(), + Mat3::new::(1.0, 0.0, 0.0, + 0.0, 1.0, 0.0, + 0.0, 0.0, 1.0)); + + assert_eq!(Mat3::zero::(), + Mat3::new::(0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0)); + + assert_eq!(a.determinant(), 0.0); + assert_eq!(a.trace(), 15.0); + + assert_eq!(a.neg(), + Mat3::new::(-1.0, -4.0, -7.0, + -2.0, -5.0, -8.0, + -3.0, -6.0, -9.0)); + assert_eq!(-a, a.neg()); + + assert_eq!(a.mul_t(f1), + Mat3::new::(0.5, 2.0, 3.5, + 1.0, 2.5, 4.0, + 1.5, 3.0, 4.5)); + assert_eq!(a.mul_v(&v1), Vec3::new::(14.0, 32.0, 50.0)); + + assert_eq!(a.add_m(&b), + Mat3::new::(3.0, 9.0, 15.0, + 5.0, 11.0, 17.0, + 7.0, 13.0, 19.0)); + assert_eq!(a.sub_m(&b), + Mat3::new::(-1.0, -1.0, -1.0, + -1.0, -1.0, -1.0, + -1.0, -1.0, -1.0)); + assert_eq!(a.mul_m(&b), + Mat3::new::(36.0, 81.0, 126.0, + 42.0, 96.0, 150.0, + 48.0, 111.0, 174.0)); + assert_eq!(a.dot(&b), 330.0); + + assert_eq!(a.transpose(), + Mat3::new::(1.0, 2.0, 3.0, + 4.0, 5.0, 6.0, + 7.0, 8.0, 9.0)); + + assert!(a.inverse().is_none()); + + assert_eq!(Mat3::new::(2.0, 4.0, 6.0, + 0.0, 2.0, 4.0, + 0.0, 0.0, 1.0).inverse().unwrap(), + Mat3::new::(0.5, -1.0, 1.0, + 0.0, 0.5, -2.0, + 0.0, 0.0, 1.0)); + + let ident = Mat3::identity::(); + + assert_eq!(ident.inverse().unwrap(), ident); + + assert!(ident.is_identity()); + assert!(ident.is_symmetric()); + assert!(ident.is_diagonal()); + assert!(!ident.is_rotated()); + assert!(ident.is_invertible()); + + assert!(!a.is_identity()); + assert!(!a.is_symmetric()); + assert!(!a.is_diagonal()); + assert!(a.is_rotated()); + assert!(!a.is_invertible()); + + let c = Mat3::new::(3.0, 2.0, 1.0, + 2.0, 3.0, 2.0, + 1.0, 2.0, 3.0); + assert!(!c.is_identity()); + assert!(c.is_symmetric()); + assert!(!c.is_diagonal()); + assert!(c.is_rotated()); + assert!(c.is_invertible()); + + assert!(Mat3::from_value::(6.0).is_diagonal()); + + assert_eq!(a.to_mat4(), + Mat4::new::(1.0, 4.0, 7.0, 0.0, + 2.0, 5.0, 8.0, 0.0, + 3.0, 6.0, 9.0, 0.0, + 0.0, 0.0, 0.0, 1.0)); + + // to_Quaternion + } + + fn test_mat3_mut() { + let a = Mat3 { x: Vec3 { x: 1.0, y: 4.0, z: 7.0 }, + y: Vec3 { x: 2.0, y: 5.0, z: 8.0 }, + z: Vec3 { x: 3.0, y: 6.0, z: 9.0 } }; + let b = Mat3 { x: Vec3 { x: 2.0, y: 5.0, z: 8.0 }, + y: Vec3 { x: 3.0, y: 6.0, z: 9.0 }, + z: Vec3 { x: 4.0, y: 7.0, z: 10.0 } }; + let c = Mat3 { x: Vec3 { x: 2.0, y: 4.0, z: 6.0 }, + y: Vec3 { x: 0.0, y: 2.0, z: 4.0 }, + z: Vec3 { x: 0.0, y: 0.0, z: 1.0 } }; + + let f1 = 0.5; + + let mut mut_a = a; + let mut mut_c = c; + + mut_a.swap_cols(0, 2); + assert_eq!(mut_a.col(0), a.col(2)); + assert_eq!(mut_a.col(2), a.col(0)); + mut_a = a; + + mut_a.swap_cols(1, 2); + assert_eq!(mut_a.col(1), a.col(2)); + assert_eq!(mut_a.col(2), a.col(1)); + mut_a = a; + + mut_a.swap_rows(0, 2); + assert_eq!(mut_a.row(0), a.row(2)); + assert_eq!(mut_a.row(2), a.row(0)); + mut_a = a; + + mut_a.swap_rows(1, 2); + assert_eq!(mut_a.row(1), a.row(2)); + assert_eq!(mut_a.row(2), a.row(1)); + mut_a = a; + + mut_a.to_identity(); + assert!(mut_a.is_identity()); + mut_a = a; + + mut_a.to_zero(); + assert_eq!(mut_a, Mat3::zero::()); + mut_a = a; + + mut_a.mul_self_t(f1); + assert_eq!(mut_a, a.mul_t(f1)); + mut_a = a; + + mut_a.add_self_m(&b); + assert_eq!(mut_a, a.add_m(&b)); + mut_a = a; + + mut_a.sub_self_m(&b); + assert_eq!(mut_a, a.sub_m(&b)); + mut_a = a; + + mut_c.invert_self(); + assert_eq!(mut_c, c.inverse().unwrap()); + // mut_c = c; + + mut_a.transpose_self(); + assert_eq!(mut_a, a.transpose()); + // mut_a = a; + } + + #[test] + fn test_mat3_approx_eq() { + assert!(!Mat3::new::(0.000001, 0.000001, 0.000001, + 0.000001, 0.000001, 0.000001, + 0.000001, 0.000001, 0.000001) + .approx_eq(&Mat3::zero::())); + assert!(Mat3::new::(0.0000001, 0.0000001, 0.0000001, + 0.0000001, 0.0000001, 0.0000001, + 0.0000001, 0.0000001, 0.0000001) + .approx_eq(&Mat3::zero::())); + } +} diff --git a/src/mat4.rs b/src/mat4.rs index f345e20..96f4dd2 100644 --- a/src/mat4.rs +++ b/src/mat4.rs @@ -526,3 +526,225 @@ impl> ApproxEq for Mat4 { self.col(3).approx_eq_eps(other.col(3), epsilon) } } + +#[cfg(test)] +mod tests{ + use mat::*; + use vec::*; + + #[test] + fn test_mat4() { + let a = Mat4 { x: Vec4 { x: 1.0, y: 5.0, z: 9.0, w: 13.0 }, + y: Vec4 { x: 2.0, y: 6.0, z: 10.0, w: 14.0 }, + z: Vec4 { x: 3.0, y: 7.0, z: 11.0, w: 15.0 }, + w: Vec4 { x: 4.0, y: 8.0, z: 12.0, w: 16.0 } }; + let b = Mat4 { x: Vec4 { x: 2.0, y: 6.0, z: 10.0, w: 14.0 }, + y: Vec4 { x: 3.0, y: 7.0, z: 11.0, w: 15.0 }, + z: Vec4 { x: 4.0, y: 8.0, z: 12.0, w: 16.0 }, + w: Vec4 { x: 5.0, y: 9.0, z: 13.0, w: 17.0 } }; + let c = Mat4 { x: Vec4 { x: 3.0, y: 2.0, z: 1.0, w: 1.0 }, + y: Vec4 { x: 2.0, y: 3.0, z: 2.0, w: 2.0 }, + z: Vec4 { x: 1.0, y: 2.0, z: 3.0, w: 3.0 }, + w: Vec4 { x: 0.0, y: 1.0, z: 1.0, w: 0.0 } }; + + let v1 = Vec4::new::(1.0, 2.0, 3.0, 4.0); + let f1 = 0.5; + + assert_eq!(a, Mat4::new::(1.0, 5.0, 9.0, 13.0, + 2.0, 6.0, 10.0, 14.0, + 3.0, 7.0, 11.0, 15.0, + 4.0, 8.0, 12.0, 16.0)); + + assert_eq!(a, Mat4::from_cols::(Vec4::new::(1.0, 5.0, 9.0, 13.0), + Vec4::new::(2.0, 6.0, 10.0, 14.0), + Vec4::new::(3.0, 7.0, 11.0, 15.0), + Vec4::new::(4.0, 8.0, 12.0, 16.0))); + + assert_eq!(Mat4::from_value::(4.0), + Mat4::new::(4.0, 0.0, 0.0, 0.0, + 0.0, 4.0, 0.0, 0.0, + 0.0, 0.0, 4.0, 0.0, + 0.0, 0.0, 0.0, 4.0)); + + assert_eq!(*a.col(0), Vec4::new::(1.0, 5.0, 9.0, 13.0)); + assert_eq!(*a.col(1), Vec4::new::(2.0, 6.0, 10.0, 14.0)); + assert_eq!(*a.col(2), Vec4::new::(3.0, 7.0, 11.0, 15.0)); + assert_eq!(*a.col(3), Vec4::new::(4.0, 8.0, 12.0, 16.0)); + + assert_eq!(a.row(0), Vec4::new::( 1.0, 2.0, 3.0, 4.0)); + assert_eq!(a.row(1), Vec4::new::( 5.0, 6.0, 7.0, 8.0)); + assert_eq!(a.row(2), Vec4::new::( 9.0, 10.0, 11.0, 12.0)); + assert_eq!(a.row(3), Vec4::new::(13.0, 14.0, 15.0, 16.0)); + + assert_eq!(*a.col(0), Vec4::new::(1.0, 5.0, 9.0, 13.0)); + assert_eq!(*a.col(1), Vec4::new::(2.0, 6.0, 10.0, 14.0)); + assert_eq!(*a.col(2), Vec4::new::(3.0, 7.0, 11.0, 15.0)); + assert_eq!(*a.col(3), Vec4::new::(4.0, 8.0, 12.0, 16.0)); + + assert_eq!(Mat4::identity::(), + Mat4::new::(1.0, 0.0, 0.0, 0.0, + 0.0, 1.0, 0.0, 0.0, + 0.0, 0.0, 1.0, 0.0, + 0.0, 0.0, 0.0, 1.0)); + + assert_eq!(Mat4::zero::(), + Mat4::new::(0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0)); + + assert_eq!(a.determinant(), 0.0); + assert_eq!(a.trace(), 34.0); + + assert_eq!(a.neg(), + Mat4::new::(-1.0, -5.0, -9.0, -13.0, + -2.0, -6.0, -10.0, -14.0, + -3.0, -7.0, -11.0, -15.0, + -4.0, -8.0, -12.0, -16.0)); + assert_eq!(-a, a.neg()); + assert_eq!(a.mul_t(f1), + Mat4::new::(0.5, 2.5, 4.5, 6.5, + 1.0, 3.0, 5.0, 7.0, + 1.5, 3.5, 5.5, 7.5, + 2.0, 4.0, 6.0, 8.0)); + assert_eq!(a.mul_v(&v1), + Vec4::new::(30.0, 70.0, 110.0, 150.0)); + assert_eq!(a.add_m(&b), + Mat4::new::(3.0, 11.0, 19.0, 27.0, + 5.0, 13.0, 21.0, 29.0, + 7.0, 15.0, 23.0, 31.0, + 9.0, 17.0, 25.0, 33.0)); + assert_eq!(a.sub_m(&b), + Mat4::new::(-1.0, -1.0, -1.0, -1.0, + -1.0, -1.0, -1.0, -1.0, + -1.0, -1.0, -1.0, -1.0, + -1.0, -1.0, -1.0, -1.0)); + assert_eq!(a.mul_m(&b), + Mat4::new::(100.0, 228.0, 356.0, 484.0, + 110.0, 254.0, 398.0, 542.0, + 120.0, 280.0, 440.0, 600.0, + 130.0, 306.0, 482.0, 658.0)); + assert_eq!(a.dot(&b), 1632.0); + assert_eq!(a.transpose(), + Mat4::new::( 1.0, 2.0, 3.0, 4.0, + 5.0, 6.0, 7.0, 8.0, + 9.0, 10.0, 11.0, 12.0, + 13.0, 14.0, 15.0, 16.0)); + + assert_approx_eq!(c.inverse().unwrap(), + Mat4::new::( 5.0, -4.0, 1.0, 0.0, + -4.0, 8.0, -4.0, 0.0, + 4.0, -8.0, 4.0, 8.0, + -3.0, 4.0, 1.0, -8.0).mul_t(0.125)); + + let ident = Mat4::identity::(); + + assert_eq!(ident.inverse().unwrap(), ident); + + assert!(ident.is_identity()); + assert!(ident.is_symmetric()); + assert!(ident.is_diagonal()); + assert!(!ident.is_rotated()); + assert!(ident.is_invertible()); + + assert!(!a.is_identity()); + assert!(!a.is_symmetric()); + assert!(!a.is_diagonal()); + assert!(a.is_rotated()); + assert!(!a.is_invertible()); + + let c = Mat4::new::(4.0, 3.0, 2.0, 1.0, + 3.0, 4.0, 3.0, 2.0, + 2.0, 3.0, 4.0, 3.0, + 1.0, 2.0, 3.0, 4.0); + assert!(!c.is_identity()); + assert!(c.is_symmetric()); + assert!(!c.is_diagonal()); + assert!(c.is_rotated()); + assert!(c.is_invertible()); + + assert!(Mat4::from_value::(6.0).is_diagonal()); + } + + fn test_mat4_mut() { + let a = Mat4 { x: Vec4 { x: 1.0, y: 5.0, z: 9.0, w: 13.0 }, + y: Vec4 { x: 2.0, y: 6.0, z: 10.0, w: 14.0 }, + z: Vec4 { x: 3.0, y: 7.0, z: 11.0, w: 15.0 }, + w: Vec4 { x: 4.0, y: 8.0, z: 12.0, w: 16.0 } }; + let b = Mat4 { x: Vec4 { x: 2.0, y: 6.0, z: 10.0, w: 14.0 }, + y: Vec4 { x: 3.0, y: 7.0, z: 11.0, w: 15.0 }, + z: Vec4 { x: 4.0, y: 8.0, z: 12.0, w: 16.0 }, + w: Vec4 { x: 5.0, y: 9.0, z: 13.0, w: 17.0 } }; + let c = Mat4 { x: Vec4 { x: 3.0, y: 2.0, z: 1.0, w: 1.0 }, + y: Vec4 { x: 2.0, y: 3.0, z: 2.0, w: 2.0 }, + z: Vec4 { x: 1.0, y: 2.0, z: 3.0, w: 3.0 }, + w: Vec4 { x: 0.0, y: 1.0, z: 1.0, w: 0.0 } }; + + let f1 = 0.5; + + let mut mut_a = a; + let mut mut_c = c; + + mut_a.swap_cols(0, 3); + assert_eq!(mut_a.col(0), a.col(3)); + assert_eq!(mut_a.col(3), a.col(0)); + mut_a = a; + + mut_a.swap_cols(1, 2); + assert_eq!(mut_a.col(1), a.col(2)); + assert_eq!(mut_a.col(2), a.col(1)); + mut_a = a; + + mut_a.swap_rows(0, 3); + assert_eq!(mut_a.row(0), a.row(3)); + assert_eq!(mut_a.row(3), a.row(0)); + mut_a = a; + + mut_a.swap_rows(1, 2); + assert_eq!(mut_a.row(1), a.row(2)); + assert_eq!(mut_a.row(2), a.row(1)); + mut_a = a; + + mut_a.to_identity(); + assert!(mut_a.is_identity()); + mut_a = a; + + mut_a.to_zero(); + assert_eq!(mut_a, Mat4::zero::()); + mut_a = a; + + mut_a.mul_self_t(f1); + assert_eq!(mut_a, a.mul_t(f1)); + mut_a = a; + + mut_a.add_self_m(&b); + assert_eq!(mut_a, a.add_m(&b)); + mut_a = a; + + mut_a.sub_self_m(&b); + assert_eq!(mut_a, a.sub_m(&b)); + mut_a = a; + + mut_c.invert_self(); + assert_eq!(mut_c, c.inverse().unwrap()); + // mut_c = c; + + mut_a.transpose_self(); + assert_eq!(mut_a, a.transpose()); + // mut_a = a; + } + + #[test] + fn test_mat4_approx_eq() { + assert!(!Mat4::new::(0.000001, 0.000001, 0.000001, 0.000001, + 0.000001, 0.000001, 0.000001, 0.000001, + 0.000001, 0.000001, 0.000001, 0.000001, + 0.000001, 0.000001, 0.000001, 0.000001) + .approx_eq(&Mat4::zero::())); + assert!(Mat4::new::(0.0000001, 0.0000001, 0.0000001, 0.0000001, + 0.0000001, 0.0000001, 0.0000001, 0.0000001, + 0.0000001, 0.0000001, 0.0000001, 0.0000001, + 0.0000001, 0.0000001, 0.0000001, 0.0000001) + .approx_eq(&Mat4::zero::())); + } +} diff --git a/src/quat.rs b/src/quat.rs index 753c796..025dfec 100644 --- a/src/quat.rs +++ b/src/quat.rs @@ -389,3 +389,53 @@ impl> ApproxEq for Quat { priv fn two() -> T { One::one::() + One::one::() } + +#[cfg(test)] +mod tests { + use mat::*; + use quat::*; + use vec::*; + + #[test] + fn test_quat() { + let a = Quat { s: 1.0, v: Vec3 { x: 2.0, y: 3.0, z: 4.0 } }; + + assert_eq!(a, Quat::from_sv::(1.0, Vec3::new::(2.0, 3.0, 4.0))); + assert_eq!(a, Quat::new::(1.0, 2.0, 3.0, 4.0)); + + assert_eq!(Quat::zero::(), Quat::new::(0.0, 0.0, 0.0, 0.0)); + assert_eq!(Quat::identity::(), Quat::new::(1.0, 0.0, 0.0, 0.0)); + + assert_eq!(a.s, 1.0); + assert_eq!(a.v.x, 2.0); + assert_eq!(a.v.y, 3.0); + assert_eq!(a.v.z, 4.0); + assert_eq!(*a.index(0), 1.0); + assert_eq!(*a.index(1), 2.0); + assert_eq!(*a.index(2), 3.0); + assert_eq!(*a.index(3), 4.0); + // TODO + } + + #[test] + fn test_quat_2() { + let v = Vec3::new(1f32, 0f32, 0f32); + + let q = Quat::from_angle_axis((-45f32).to_radians(), &Vec3::new(0f32, 0f32, -1f32)); + + // http://www.wolframalpha.com/input/?i={1,0}+rotate+-45+degrees + assert_approx_eq!(q.mul_v(&v), Vec3::new(1f32/2f32.sqrt(), 1f32/2f32.sqrt(), 0f32)); + assert_eq!(q.mul_v(&v).length(), v.length()); + assert_approx_eq!(q.to_mat3(), Mat3::new( 1f32/2f32.sqrt(), 1f32/2f32.sqrt(), 0f32, + -1f32/2f32.sqrt(), 1f32/2f32.sqrt(), 0f32, + 0f32, 0f32, 1f32)); + } + + #[test] + fn test_quat_approx_eq() { + assert!(!Quat::new::(0.000001, 0.000001, 0.000001, 0.000001) + .approx_eq(&Quat::new::(0.0, 0.0, 0.0, 0.0))); + assert!(Quat::new::(0.0000001, 0.0000001, 0.0000001, 0.0000001) + .approx_eq(&Quat::new::(0.0, 0.0, 0.0, 0.0))); + } +} diff --git a/src/test/test_mat.rs b/src/test/test_mat.rs deleted file mode 100644 index 943576a..0000000 --- a/src/test/test_mat.rs +++ /dev/null @@ -1,594 +0,0 @@ -// Copyright 2013 The Lmath Developers. For a full listing of the authors, -// refer to the AUTHORS file at the top-level directory of this distribution. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -use mat::*; -use vec::*; - -#[test] -fn test_mat2() { - let a = Mat2 { x: Vec2 { x: 1.0, y: 3.0 }, - y: Vec2 { x: 2.0, y: 4.0 } }; - let b = Mat2 { x: Vec2 { x: 2.0, y: 4.0 }, - y: Vec2 { x: 3.0, y: 5.0 } }; - - let v1 = Vec2::new::(1.0, 2.0); - let f1 = 0.5; - - assert_eq!(a, Mat2::new::(1.0, 3.0, - 2.0, 4.0)); - - assert_eq!(a, Mat2::from_cols::(Vec2::new::(1.0, 3.0), - Vec2::new::(2.0, 4.0))); - - assert_eq!(Mat2::from_value::(4.0), - Mat2::new::(4.0, 0.0, - 0.0, 4.0)); - - assert_eq!(*a.col(0), Vec2::new::(1.0, 3.0)); - assert_eq!(*a.col(1), Vec2::new::(2.0, 4.0)); - - assert_eq!(a.row(0), Vec2::new::(1.0, 2.0)); - assert_eq!(a.row(1), Vec2::new::(3.0, 4.0)); - - assert_eq!(*a.col(0), Vec2::new::(1.0, 3.0)); - assert_eq!(*a.col(1), Vec2::new::(2.0, 4.0)); - - assert_eq!(Mat2::identity::(), - Mat2::new::(1.0, 0.0, - 0.0, 1.0)); - - assert_eq!(Mat2::zero::(), - Mat2::new::(0.0, 0.0, - 0.0, 0.0)); - - assert_eq!(a.determinant(), -2.0); - assert_eq!(a.trace(), 5.0); - - assert_eq!(a.neg(), - Mat2::new::(-1.0, -3.0, - -2.0, -4.0)); - assert_eq!(-a, a.neg()); - assert_eq!(a.mul_t(f1), - Mat2::new::(0.5, 1.5, - 1.0, 2.0)); - assert_eq!(a.mul_v(&v1), Vec2::new::(5.0, 11.0)); - assert_eq!(a.add_m(&b), - Mat2::new::(3.0, 7.0, - 5.0, 9.0)); - assert_eq!(a.sub_m(&b), - Mat2::new::(-1.0, -1.0, - -1.0, -1.0)); - assert_eq!(a.mul_m(&b), - Mat2::new::(10.0, 22.0, - 13.0, 29.0)); - assert_eq!(a.dot(&b), 40.0); - - assert_eq!(a.transpose(), - Mat2::new::(1.0, 2.0, - 3.0, 4.0)); - - assert_eq!(a.inverse().unwrap(), - Mat2::new::(-2.0, 1.5, - 1.0, -0.5)); - - assert!(Mat2::new::(0.0, 2.0, - 0.0, 5.0).inverse().is_none()); - - let ident = Mat2::identity::(); - - assert!(ident.is_identity()); - assert!(ident.is_symmetric()); - assert!(ident.is_diagonal()); - assert!(!ident.is_rotated()); - assert!(ident.is_invertible()); - - assert!(!a.is_identity()); - assert!(!a.is_symmetric()); - assert!(!a.is_diagonal()); - assert!(a.is_rotated()); - assert!(a.is_invertible()); - - let c = Mat2::new::(2.0, 1.0, - 1.0, 2.0); - assert!(!c.is_identity()); - assert!(c.is_symmetric()); - assert!(!c.is_diagonal()); - assert!(c.is_rotated()); - assert!(c.is_invertible()); - - assert!(Mat2::from_value::(6.0).is_diagonal()); - - assert_eq!(a.to_mat3(), - Mat3::new::(1.0, 3.0, 0.0, - 2.0, 4.0, 0.0, - 0.0, 0.0, 1.0)); - - assert_eq!(a.to_mat4(), - Mat4::new::(1.0, 3.0, 0.0, 0.0, - 2.0, 4.0, 0.0, 0.0, - 0.0, 0.0, 1.0, 0.0, - 0.0, 0.0, 0.0, 1.0)); -} - -fn test_mat2_mut() { - let a = Mat2 { x: Vec2 { x: 1.0, y: 3.0 }, - y: Vec2 { x: 2.0, y: 4.0 } }; - let b = Mat2 { x: Vec2 { x: 2.0, y: 4.0 }, - y: Vec2 { x: 3.0, y: 5.0 } }; - - let f1 = 0.5; - - let mut mut_a = a; - - mut_a.swap_cols(0, 1); - assert_eq!(mut_a.col(0), a.col(1)); - assert_eq!(mut_a.col(1), a.col(0)); - mut_a = a; - - mut_a.swap_rows(0, 1); - assert_eq!(mut_a.row(0), a.row(1)); - assert_eq!(mut_a.row(1), a.row(0)); - mut_a = a; - - mut_a.to_identity(); - assert!(mut_a.is_identity()); - mut_a = a; - - mut_a.to_zero(); - assert_eq!(mut_a, Mat2::zero::()); - mut_a = a; - - mut_a.mul_self_t(f1); - assert_eq!(mut_a, a.mul_t(f1)); - mut_a = a; - - mut_a.add_self_m(&b); - assert_eq!(mut_a, a.add_m(&b)); - mut_a = a; - - mut_a.sub_self_m(&b); - assert_eq!(mut_a, a.sub_m(&b)); - mut_a = a; - - mut_a.invert_self(); - assert_eq!(mut_a, a.inverse().unwrap()); - mut_a = a; - - mut_a.transpose_self(); - assert_eq!(mut_a, a.transpose()); - // mut_a = a; -} - -#[test] -fn test_mat2_approx_eq() { - assert!(!Mat2::new::(0.000001, 0.000001, - 0.000001, 0.000001).approx_eq(&Mat2::zero::())); - assert!(Mat2::new::(0.0000001, 0.0000001, - 0.0000001, 0.0000001).approx_eq(&Mat2::zero::())); -} - -#[test] -fn test_mat3() { - let a = Mat3 { x: Vec3 { x: 1.0, y: 4.0, z: 7.0 }, - y: Vec3 { x: 2.0, y: 5.0, z: 8.0 }, - z: Vec3 { x: 3.0, y: 6.0, z: 9.0 } }; - let b = Mat3 { x: Vec3 { x: 2.0, y: 5.0, z: 8.0 }, - y: Vec3 { x: 3.0, y: 6.0, z: 9.0 }, - z: Vec3 { x: 4.0, y: 7.0, z: 10.0 } }; - - let v1 = Vec3::new::(1.0, 2.0, 3.0); - let f1 = 0.5; - - assert_eq!(a, Mat3::new::(1.0, 4.0, 7.0, - 2.0, 5.0, 8.0, - 3.0, 6.0, 9.0)); - - assert_eq!(a, Mat3::from_cols::(Vec3::new::(1.0, 4.0, 7.0), - Vec3::new::(2.0, 5.0, 8.0), - Vec3::new::(3.0, 6.0, 9.0))); - - assert_eq!(*a.col(0), Vec3::new::(1.0, 4.0, 7.0)); - assert_eq!(*a.col(1), Vec3::new::(2.0, 5.0, 8.0)); - assert_eq!(*a.col(2), Vec3::new::(3.0, 6.0, 9.0)); - - assert_eq!(a.row(0), Vec3::new::(1.0, 2.0, 3.0)); - assert_eq!(a.row(1), Vec3::new::(4.0, 5.0, 6.0)); - assert_eq!(a.row(2), Vec3::new::(7.0, 8.0, 9.0)); - - assert_eq!(*a.col(0), Vec3::new::(1.0, 4.0, 7.0)); - assert_eq!(*a.col(1), Vec3::new::(2.0, 5.0, 8.0)); - assert_eq!(*a.col(2), Vec3::new::(3.0, 6.0, 9.0)); - - assert_eq!(Mat3::identity::(), - Mat3::new::(1.0, 0.0, 0.0, - 0.0, 1.0, 0.0, - 0.0, 0.0, 1.0)); - - assert_eq!(Mat3::zero::(), - Mat3::new::(0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0)); - - assert_eq!(a.determinant(), 0.0); - assert_eq!(a.trace(), 15.0); - - assert_eq!(a.neg(), - Mat3::new::(-1.0, -4.0, -7.0, - -2.0, -5.0, -8.0, - -3.0, -6.0, -9.0)); - assert_eq!(-a, a.neg()); - - assert_eq!(a.mul_t(f1), - Mat3::new::(0.5, 2.0, 3.5, - 1.0, 2.5, 4.0, - 1.5, 3.0, 4.5)); - assert_eq!(a.mul_v(&v1), Vec3::new::(14.0, 32.0, 50.0)); - - assert_eq!(a.add_m(&b), - Mat3::new::(3.0, 9.0, 15.0, - 5.0, 11.0, 17.0, - 7.0, 13.0, 19.0)); - assert_eq!(a.sub_m(&b), - Mat3::new::(-1.0, -1.0, -1.0, - -1.0, -1.0, -1.0, - -1.0, -1.0, -1.0)); - assert_eq!(a.mul_m(&b), - Mat3::new::(36.0, 81.0, 126.0, - 42.0, 96.0, 150.0, - 48.0, 111.0, 174.0)); - assert_eq!(a.dot(&b), 330.0); - - assert_eq!(a.transpose(), - Mat3::new::(1.0, 2.0, 3.0, - 4.0, 5.0, 6.0, - 7.0, 8.0, 9.0)); - - assert!(a.inverse().is_none()); - - assert_eq!(Mat3::new::(2.0, 4.0, 6.0, - 0.0, 2.0, 4.0, - 0.0, 0.0, 1.0).inverse().unwrap(), - Mat3::new::(0.5, -1.0, 1.0, - 0.0, 0.5, -2.0, - 0.0, 0.0, 1.0)); - - let ident = Mat3::identity::(); - - assert_eq!(ident.inverse().unwrap(), ident); - - assert!(ident.is_identity()); - assert!(ident.is_symmetric()); - assert!(ident.is_diagonal()); - assert!(!ident.is_rotated()); - assert!(ident.is_invertible()); - - assert!(!a.is_identity()); - assert!(!a.is_symmetric()); - assert!(!a.is_diagonal()); - assert!(a.is_rotated()); - assert!(!a.is_invertible()); - - let c = Mat3::new::(3.0, 2.0, 1.0, - 2.0, 3.0, 2.0, - 1.0, 2.0, 3.0); - assert!(!c.is_identity()); - assert!(c.is_symmetric()); - assert!(!c.is_diagonal()); - assert!(c.is_rotated()); - assert!(c.is_invertible()); - - assert!(Mat3::from_value::(6.0).is_diagonal()); - - assert_eq!(a.to_mat4(), - Mat4::new::(1.0, 4.0, 7.0, 0.0, - 2.0, 5.0, 8.0, 0.0, - 3.0, 6.0, 9.0, 0.0, - 0.0, 0.0, 0.0, 1.0)); - - // to_Quaternion -} - -fn test_mat3_mut() { - let a = Mat3 { x: Vec3 { x: 1.0, y: 4.0, z: 7.0 }, - y: Vec3 { x: 2.0, y: 5.0, z: 8.0 }, - z: Vec3 { x: 3.0, y: 6.0, z: 9.0 } }; - let b = Mat3 { x: Vec3 { x: 2.0, y: 5.0, z: 8.0 }, - y: Vec3 { x: 3.0, y: 6.0, z: 9.0 }, - z: Vec3 { x: 4.0, y: 7.0, z: 10.0 } }; - let c = Mat3 { x: Vec3 { x: 2.0, y: 4.0, z: 6.0 }, - y: Vec3 { x: 0.0, y: 2.0, z: 4.0 }, - z: Vec3 { x: 0.0, y: 0.0, z: 1.0 } }; - - let f1 = 0.5; - - let mut mut_a = a; - let mut mut_c = c; - - mut_a.swap_cols(0, 2); - assert_eq!(mut_a.col(0), a.col(2)); - assert_eq!(mut_a.col(2), a.col(0)); - mut_a = a; - - mut_a.swap_cols(1, 2); - assert_eq!(mut_a.col(1), a.col(2)); - assert_eq!(mut_a.col(2), a.col(1)); - mut_a = a; - - mut_a.swap_rows(0, 2); - assert_eq!(mut_a.row(0), a.row(2)); - assert_eq!(mut_a.row(2), a.row(0)); - mut_a = a; - - mut_a.swap_rows(1, 2); - assert_eq!(mut_a.row(1), a.row(2)); - assert_eq!(mut_a.row(2), a.row(1)); - mut_a = a; - - mut_a.to_identity(); - assert!(mut_a.is_identity()); - mut_a = a; - - mut_a.to_zero(); - assert_eq!(mut_a, Mat3::zero::()); - mut_a = a; - - mut_a.mul_self_t(f1); - assert_eq!(mut_a, a.mul_t(f1)); - mut_a = a; - - mut_a.add_self_m(&b); - assert_eq!(mut_a, a.add_m(&b)); - mut_a = a; - - mut_a.sub_self_m(&b); - assert_eq!(mut_a, a.sub_m(&b)); - mut_a = a; - - mut_c.invert_self(); - assert_eq!(mut_c, c.inverse().unwrap()); - // mut_c = c; - - mut_a.transpose_self(); - assert_eq!(mut_a, a.transpose()); - // mut_a = a; -} - -#[test] -fn test_mat3_approx_eq() { - assert!(!Mat3::new::(0.000001, 0.000001, 0.000001, - 0.000001, 0.000001, 0.000001, - 0.000001, 0.000001, 0.000001) - .approx_eq(&Mat3::zero::())); - assert!(Mat3::new::(0.0000001, 0.0000001, 0.0000001, - 0.0000001, 0.0000001, 0.0000001, - 0.0000001, 0.0000001, 0.0000001) - .approx_eq(&Mat3::zero::())); -} - -#[test] -fn test_mat4() { - let a = Mat4 { x: Vec4 { x: 1.0, y: 5.0, z: 9.0, w: 13.0 }, - y: Vec4 { x: 2.0, y: 6.0, z: 10.0, w: 14.0 }, - z: Vec4 { x: 3.0, y: 7.0, z: 11.0, w: 15.0 }, - w: Vec4 { x: 4.0, y: 8.0, z: 12.0, w: 16.0 } }; - let b = Mat4 { x: Vec4 { x: 2.0, y: 6.0, z: 10.0, w: 14.0 }, - y: Vec4 { x: 3.0, y: 7.0, z: 11.0, w: 15.0 }, - z: Vec4 { x: 4.0, y: 8.0, z: 12.0, w: 16.0 }, - w: Vec4 { x: 5.0, y: 9.0, z: 13.0, w: 17.0 } }; - let c = Mat4 { x: Vec4 { x: 3.0, y: 2.0, z: 1.0, w: 1.0 }, - y: Vec4 { x: 2.0, y: 3.0, z: 2.0, w: 2.0 }, - z: Vec4 { x: 1.0, y: 2.0, z: 3.0, w: 3.0 }, - w: Vec4 { x: 0.0, y: 1.0, z: 1.0, w: 0.0 } }; - - let v1 = Vec4::new::(1.0, 2.0, 3.0, 4.0); - let f1 = 0.5; - - assert_eq!(a, Mat4::new::(1.0, 5.0, 9.0, 13.0, - 2.0, 6.0, 10.0, 14.0, - 3.0, 7.0, 11.0, 15.0, - 4.0, 8.0, 12.0, 16.0)); - - assert_eq!(a, Mat4::from_cols::(Vec4::new::(1.0, 5.0, 9.0, 13.0), - Vec4::new::(2.0, 6.0, 10.0, 14.0), - Vec4::new::(3.0, 7.0, 11.0, 15.0), - Vec4::new::(4.0, 8.0, 12.0, 16.0))); - - assert_eq!(Mat4::from_value::(4.0), - Mat4::new::(4.0, 0.0, 0.0, 0.0, - 0.0, 4.0, 0.0, 0.0, - 0.0, 0.0, 4.0, 0.0, - 0.0, 0.0, 0.0, 4.0)); - - assert_eq!(*a.col(0), Vec4::new::(1.0, 5.0, 9.0, 13.0)); - assert_eq!(*a.col(1), Vec4::new::(2.0, 6.0, 10.0, 14.0)); - assert_eq!(*a.col(2), Vec4::new::(3.0, 7.0, 11.0, 15.0)); - assert_eq!(*a.col(3), Vec4::new::(4.0, 8.0, 12.0, 16.0)); - - assert_eq!(a.row(0), Vec4::new::( 1.0, 2.0, 3.0, 4.0)); - assert_eq!(a.row(1), Vec4::new::( 5.0, 6.0, 7.0, 8.0)); - assert_eq!(a.row(2), Vec4::new::( 9.0, 10.0, 11.0, 12.0)); - assert_eq!(a.row(3), Vec4::new::(13.0, 14.0, 15.0, 16.0)); - - assert_eq!(*a.col(0), Vec4::new::(1.0, 5.0, 9.0, 13.0)); - assert_eq!(*a.col(1), Vec4::new::(2.0, 6.0, 10.0, 14.0)); - assert_eq!(*a.col(2), Vec4::new::(3.0, 7.0, 11.0, 15.0)); - assert_eq!(*a.col(3), Vec4::new::(4.0, 8.0, 12.0, 16.0)); - - assert_eq!(Mat4::identity::(), - Mat4::new::(1.0, 0.0, 0.0, 0.0, - 0.0, 1.0, 0.0, 0.0, - 0.0, 0.0, 1.0, 0.0, - 0.0, 0.0, 0.0, 1.0)); - - assert_eq!(Mat4::zero::(), - Mat4::new::(0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0)); - - assert_eq!(a.determinant(), 0.0); - assert_eq!(a.trace(), 34.0); - - assert_eq!(a.neg(), - Mat4::new::(-1.0, -5.0, -9.0, -13.0, - -2.0, -6.0, -10.0, -14.0, - -3.0, -7.0, -11.0, -15.0, - -4.0, -8.0, -12.0, -16.0)); - assert_eq!(-a, a.neg()); - assert_eq!(a.mul_t(f1), - Mat4::new::(0.5, 2.5, 4.5, 6.5, - 1.0, 3.0, 5.0, 7.0, - 1.5, 3.5, 5.5, 7.5, - 2.0, 4.0, 6.0, 8.0)); - assert_eq!(a.mul_v(&v1), - Vec4::new::(30.0, 70.0, 110.0, 150.0)); - assert_eq!(a.add_m(&b), - Mat4::new::(3.0, 11.0, 19.0, 27.0, - 5.0, 13.0, 21.0, 29.0, - 7.0, 15.0, 23.0, 31.0, - 9.0, 17.0, 25.0, 33.0)); - assert_eq!(a.sub_m(&b), - Mat4::new::(-1.0, -1.0, -1.0, -1.0, - -1.0, -1.0, -1.0, -1.0, - -1.0, -1.0, -1.0, -1.0, - -1.0, -1.0, -1.0, -1.0)); - assert_eq!(a.mul_m(&b), - Mat4::new::(100.0, 228.0, 356.0, 484.0, - 110.0, 254.0, 398.0, 542.0, - 120.0, 280.0, 440.0, 600.0, - 130.0, 306.0, 482.0, 658.0)); - assert_eq!(a.dot(&b), 1632.0); - assert_eq!(a.transpose(), - Mat4::new::( 1.0, 2.0, 3.0, 4.0, - 5.0, 6.0, 7.0, 8.0, - 9.0, 10.0, 11.0, 12.0, - 13.0, 14.0, 15.0, 16.0)); - - assert_approx_eq!(c.inverse().unwrap(), - Mat4::new::( 5.0, -4.0, 1.0, 0.0, - -4.0, 8.0, -4.0, 0.0, - 4.0, -8.0, 4.0, 8.0, - -3.0, 4.0, 1.0, -8.0).mul_t(0.125)); - - let ident = Mat4::identity::(); - - assert_eq!(ident.inverse().unwrap(), ident); - - assert!(ident.is_identity()); - assert!(ident.is_symmetric()); - assert!(ident.is_diagonal()); - assert!(!ident.is_rotated()); - assert!(ident.is_invertible()); - - assert!(!a.is_identity()); - assert!(!a.is_symmetric()); - assert!(!a.is_diagonal()); - assert!(a.is_rotated()); - assert!(!a.is_invertible()); - - let c = Mat4::new::(4.0, 3.0, 2.0, 1.0, - 3.0, 4.0, 3.0, 2.0, - 2.0, 3.0, 4.0, 3.0, - 1.0, 2.0, 3.0, 4.0); - assert!(!c.is_identity()); - assert!(c.is_symmetric()); - assert!(!c.is_diagonal()); - assert!(c.is_rotated()); - assert!(c.is_invertible()); - - assert!(Mat4::from_value::(6.0).is_diagonal()); -} - -fn test_mat4_mut() { - let a = Mat4 { x: Vec4 { x: 1.0, y: 5.0, z: 9.0, w: 13.0 }, - y: Vec4 { x: 2.0, y: 6.0, z: 10.0, w: 14.0 }, - z: Vec4 { x: 3.0, y: 7.0, z: 11.0, w: 15.0 }, - w: Vec4 { x: 4.0, y: 8.0, z: 12.0, w: 16.0 } }; - let b = Mat4 { x: Vec4 { x: 2.0, y: 6.0, z: 10.0, w: 14.0 }, - y: Vec4 { x: 3.0, y: 7.0, z: 11.0, w: 15.0 }, - z: Vec4 { x: 4.0, y: 8.0, z: 12.0, w: 16.0 }, - w: Vec4 { x: 5.0, y: 9.0, z: 13.0, w: 17.0 } }; - let c = Mat4 { x: Vec4 { x: 3.0, y: 2.0, z: 1.0, w: 1.0 }, - y: Vec4 { x: 2.0, y: 3.0, z: 2.0, w: 2.0 }, - z: Vec4 { x: 1.0, y: 2.0, z: 3.0, w: 3.0 }, - w: Vec4 { x: 0.0, y: 1.0, z: 1.0, w: 0.0 } }; - - let f1 = 0.5; - - let mut mut_a = a; - let mut mut_c = c; - - mut_a.swap_cols(0, 3); - assert_eq!(mut_a.col(0), a.col(3)); - assert_eq!(mut_a.col(3), a.col(0)); - mut_a = a; - - mut_a.swap_cols(1, 2); - assert_eq!(mut_a.col(1), a.col(2)); - assert_eq!(mut_a.col(2), a.col(1)); - mut_a = a; - - mut_a.swap_rows(0, 3); - assert_eq!(mut_a.row(0), a.row(3)); - assert_eq!(mut_a.row(3), a.row(0)); - mut_a = a; - - mut_a.swap_rows(1, 2); - assert_eq!(mut_a.row(1), a.row(2)); - assert_eq!(mut_a.row(2), a.row(1)); - mut_a = a; - - mut_a.to_identity(); - assert!(mut_a.is_identity()); - mut_a = a; - - mut_a.to_zero(); - assert_eq!(mut_a, Mat4::zero::()); - mut_a = a; - - mut_a.mul_self_t(f1); - assert_eq!(mut_a, a.mul_t(f1)); - mut_a = a; - - mut_a.add_self_m(&b); - assert_eq!(mut_a, a.add_m(&b)); - mut_a = a; - - mut_a.sub_self_m(&b); - assert_eq!(mut_a, a.sub_m(&b)); - mut_a = a; - - mut_c.invert_self(); - assert_eq!(mut_c, c.inverse().unwrap()); - // mut_c = c; - - mut_a.transpose_self(); - assert_eq!(mut_a, a.transpose()); - // mut_a = a; -} - -#[test] -fn test_mat4_approx_eq() { - assert!(!Mat4::new::(0.000001, 0.000001, 0.000001, 0.000001, - 0.000001, 0.000001, 0.000001, 0.000001, - 0.000001, 0.000001, 0.000001, 0.000001, - 0.000001, 0.000001, 0.000001, 0.000001) - .approx_eq(&Mat4::zero::())); - assert!(Mat4::new::(0.0000001, 0.0000001, 0.0000001, 0.0000001, - 0.0000001, 0.0000001, 0.0000001, 0.0000001, - 0.0000001, 0.0000001, 0.0000001, 0.0000001, - 0.0000001, 0.0000001, 0.0000001, 0.0000001) - .approx_eq(&Mat4::zero::())); -} \ No newline at end of file diff --git a/src/test/test_quat.rs b/src/test/test_quat.rs deleted file mode 100644 index 83ab7f8..0000000 --- a/src/test/test_quat.rs +++ /dev/null @@ -1,63 +0,0 @@ -// Copyright 2013 The Lmath Developers. For a full listing of the authors, -// refer to the AUTHORS file at the top-level directory of this distribution. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -use mat::*; -use quat::*; -use vec::*; - -// TODO - -#[test] -fn test_quat() { - let a = Quat { s: 1.0, v: Vec3 { x: 2.0, y: 3.0, z: 4.0 } }; - - assert_eq!(a, Quat::from_sv::(1.0, Vec3::new::(2.0, 3.0, 4.0))); - assert_eq!(a, Quat::new::(1.0, 2.0, 3.0, 4.0)); - - assert_eq!(Quat::zero::(), Quat::new::(0.0, 0.0, 0.0, 0.0)); - assert_eq!(Quat::identity::(), Quat::new::(1.0, 0.0, 0.0, 0.0)); - - assert_eq!(a.s, 1.0); - assert_eq!(a.v.x, 2.0); - assert_eq!(a.v.y, 3.0); - assert_eq!(a.v.z, 4.0); - assert_eq!(*a.index(0), 1.0); - assert_eq!(*a.index(1), 2.0); - assert_eq!(*a.index(2), 3.0); - assert_eq!(*a.index(3), 4.0); - // TODO -} - -#[test] -fn test_quat_2() { - let v = Vec3::new(1f32, 0f32, 0f32); - - let q = Quat::from_angle_axis((-45f32).to_radians(), &Vec3::new(0f32, 0f32, -1f32)); - - // http://www.wolframalpha.com/input/?i={1,0}+rotate+-45+degrees - assert_approx_eq!(q.mul_v(&v), Vec3::new(1f32/2f32.sqrt(), 1f32/2f32.sqrt(), 0f32)); - assert_eq!(q.mul_v(&v).length(), v.length()); - assert_approx_eq!(q.to_mat3(), Mat3::new( 1f32/2f32.sqrt(), 1f32/2f32.sqrt(), 0f32, - -1f32/2f32.sqrt(), 1f32/2f32.sqrt(), 0f32, - 0f32, 0f32, 1f32)); -} - -#[test] -fn test_quat_approx_eq() { - assert!(!Quat::new::(0.000001, 0.000001, 0.000001, 0.000001) - .approx_eq(&Quat::new::(0.0, 0.0, 0.0, 0.0))); - assert!(Quat::new::(0.0000001, 0.0000001, 0.0000001, 0.0000001) - .approx_eq(&Quat::new::(0.0, 0.0, 0.0, 0.0))); -} \ No newline at end of file diff --git a/src/test/test_vec.rs b/src/test/test_vec.rs deleted file mode 100644 index f2d0a87..0000000 --- a/src/test/test_vec.rs +++ /dev/null @@ -1,441 +0,0 @@ -// Copyright 2013 The Lmath Developers. For a full listing of the authors, -// refer to the AUTHORS file at the top-level directory of this distribution. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -use vec::*; - -// TODO - -#[test] -fn test_vec2() { - let a = Vec2 { x: 1.0, y: 2.0 }; - let b = Vec2 { x: 3.0, y: 4.0 }; - let f1 = 1.5; - let f2 = 0.5; - - let mut mut_a = a; - - assert_eq!(Vec2::new::(1.0, 2.0), a); - assert_eq!(Vec2::from_value(1.0), Vec2::new::(1.0, 1.0)); - - assert_eq!(Vec2::zero(), Vec2::new::(0.0, 0.0)); - assert_eq!(Vec2::unit_x(), Vec2::new::(1.0, 0.0)); - assert_eq!(Vec2::unit_y(), Vec2::new::(0.0, 1.0)); - assert_eq!(Vec2::identity(), Vec2::new::(1.0, 1.0)); - - *mut_a.index_mut(0) = 42.0; - *mut_a.index_mut(1) = 43.0; - assert_eq!(mut_a, Vec2::new::(42.0, 43.0)); - mut_a = a; - - mut_a.swap(0, 1); - assert_eq!(*mut_a.index(0), *a.index(1)); - assert_eq!(*mut_a.index(1), *a.index(0)); - mut_a = a; - - assert_eq!(a.x, 1.0); - assert_eq!(a.y, 2.0); - assert_eq!(*a.index(0), 1.0); - assert_eq!(*a.index(1), 2.0); - - assert_eq!(-a, Vec2::new::(-1.0, -2.0)); - assert_eq!(a.neg(), Vec2::new::(-1.0, -2.0)); - - assert!(Vec2::new::(0.0, 0.0).is_zero()); - assert!(!Vec2::new::(1.0, 1.0).is_zero()); - - assert_eq!(a.mul_t(f1), Vec2::new::( 1.5, 3.0)); - assert_eq!(a.div_t(f2), Vec2::new::( 2.0, 4.0)); - - assert_eq!(a.add_v(&b), Vec2::new::( 4.0, 6.0)); - assert_eq!(a.sub_v(&b), Vec2::new::( -2.0, -2.0)); - assert_eq!(a.mul_v(&b), Vec2::new::( 3.0, 8.0)); - assert_eq!(a.div_v(&b), Vec2::new::(1.0/3.0, 2.0/4.0)); - - mut_a.neg_self(); - assert_eq!(mut_a, -a); - mut_a = a; - - mut_a.mul_self_t(f1); - assert_eq!(mut_a, a.mul_t(f1)); - mut_a = a; - - mut_a.div_self_t(f2); - assert_eq!(mut_a, a.div_t(f2)); - mut_a = a; - - mut_a.add_self_v(&b); - assert_eq!(mut_a, a.add_v(&b)); - mut_a = a; - - mut_a.sub_self_v(&b); - assert_eq!(mut_a, a.sub_v(&b)); - mut_a = a; - - mut_a.mul_self_v(&b); - assert_eq!(mut_a, a.mul_v(&b)); - mut_a = a; - - mut_a.div_self_v(&b); - assert_eq!(mut_a, a.div_v(&b)); -} - -#[test] -fn test_vec2_approx_eq() { - assert!(!Vec2::new::(0.000001, 0.000001).approx_eq(&Vec2::new::(0.0, 0.0))); - assert!(Vec2::new::(0.0000001, 0.0000001).approx_eq(&Vec2::new::(0.0, 0.0))); -} - -#[test] -fn test_vec2_euclidean() { - let a = Vec2::new::(5.0, 12.0); // (5, 12, 13) Pythagorean triple - let b0 = Vec2::new::(3.0, 4.0); // (3, 4, 5) Pythagorean triple - let b = a.add_v(&b0); - - assert_eq!(a.length(), 13.0); - assert_eq!(a.length2(), 13.0 * 13.0); - - assert_eq!(b0.length(), 5.0); - assert_eq!(b0.length2(), 5.0 * 5.0); - - assert_eq!(a.distance(&b), 5.0); - assert_eq!(a.distance2(&b), 5.0 * 5.0); - - assert!(Vec2::new::(1.0, 0.0).angle(&Vec2::new::(0.0, 1.0)).approx_eq(&Real::frac_pi_2())); - assert!(Vec2::new::(10.0, 0.0).angle(&Vec2::new::(0.0, 5.0)).approx_eq(&Real::frac_pi_2())); - assert!(Vec2::new::(-1.0, 0.0).angle(&Vec2::new::(0.0, 1.0)).approx_eq(&-Real::frac_pi_2::())); - - assert!(Vec2::new::(3.0, 4.0).normalize().approx_eq(&Vec2::new::(3.0/5.0, 4.0/5.0))); - // TODO: test normalize_to, normalize_self, and normalize_self_to - - let c = Vec2::new::(-2.0, -1.0); - let d = Vec2::new::( 1.0, 0.0); - - assert_eq!(c.lerp(&d, 0.75), Vec2::new::(0.250, -0.250)); - - let mut mut_c = c; - mut_c.lerp_self(&d, 0.75); - assert_eq!(mut_c, c.lerp(&d, 0.75)); -} - -#[test] -fn test_vec2_boolean() { - let tf = Vec2::new(true, false); - let ff = Vec2::new(false, false); - let tt = Vec2::new(true, true); - - assert_eq!(tf.any(), true); - assert_eq!(tf.all(), false); - assert_eq!(tf.not(), Vec2::new(false, true)); - - assert_eq!(ff.any(), false); - assert_eq!(ff.all(), false); - assert_eq!(ff.not(), Vec2::new(true, true)); - - assert_eq!(tt.any(), true); - assert_eq!(tt.all(), true); - assert_eq!(tt.not(), Vec2::new(false, false)); -} - -#[test] -fn test_vec3() { - let a = Vec3 { x: 1.0, y: 2.0, z: 3.0 }; - let b = Vec3 { x: 4.0, y: 5.0, z: 6.0 }; - let f1 = 1.5; - let f2 = 0.5; - - let mut mut_a = a; - - assert_eq!(Vec3::new::(1.0, 2.0, 3.0), a); - assert_eq!(Vec3::from_value(1.0), Vec3::new::(1.0, 1.0, 1.0)); - - assert_eq!(Vec3::zero(), Vec3::new::(0.0, 0.0, 0.0)); - assert_eq!(Vec3::unit_x(), Vec3::new::(1.0, 0.0, 0.0)); - assert_eq!(Vec3::unit_y(), Vec3::new::(0.0, 1.0, 0.0)); - assert_eq!(Vec3::unit_z(), Vec3::new::(0.0, 0.0, 1.0)); - assert_eq!(Vec3::identity(), Vec3::new::(1.0, 1.0, 1.0)); - - *mut_a.index_mut(0) = 42.0; - *mut_a.index_mut(1) = 43.0; - *mut_a.index_mut(2) = 44.0; - assert_eq!(mut_a, Vec3::new::(42.0, 43.0, 44.0)); - mut_a = a; - - mut_a.swap(0, 2); - assert_eq!(*mut_a.index(0), *a.index(2)); - assert_eq!(*mut_a.index(2), *a.index(0)); - mut_a = a; - - mut_a.swap(1, 2); - assert_eq!(*mut_a.index(1), *a.index(2)); - assert_eq!(*mut_a.index(2), *a.index(1)); - mut_a = a; - - assert_eq!(a.x, 1.0); - assert_eq!(a.y, 2.0); - assert_eq!(a.z, 3.0); - assert_eq!(*a.index(0), 1.0); - assert_eq!(*a.index(1), 2.0); - assert_eq!(*a.index(2), 3.0); - - assert_eq!(a.cross(&b), Vec3::new::(-3.0, 6.0, -3.0)); - - mut_a.cross_self(&b); - assert_eq!(mut_a, a.cross(&b)); - mut_a = a; - - assert_eq!(-a, Vec3::new::(-1.0, -2.0, -3.0)); - assert_eq!(a.neg(), Vec3::new::(-1.0, -2.0, -3.0)); - - assert!(Vec3::new::(0.0, 0.0, 0.0).is_zero()); - assert!(!Vec3::new::(1.0, 1.0, 1.0).is_zero()); - - assert_eq!(a.mul_t(f1), Vec3::new::( 1.5, 3.0, 4.5)); - assert_eq!(a.div_t(f2), Vec3::new::( 2.0, 4.0, 6.0)); - - assert_eq!(a.add_v(&b), Vec3::new::( 5.0, 7.0, 9.0)); - assert_eq!(a.sub_v(&b), Vec3::new::( -3.0, -3.0, -3.0)); - assert_eq!(a.mul_v(&b), Vec3::new::( 4.0, 10.0, 18.0)); - assert_eq!(a.div_v(&b), Vec3::new::(1.0/4.0, 2.0/5.0, 3.0/6.0)); - - mut_a.neg_self(); - assert_eq!(mut_a, -a); - mut_a = a; - - mut_a.mul_self_t(f1); - assert_eq!(mut_a, a.mul_t(f1)); - mut_a = a; - - mut_a.div_self_t(f2); - assert_eq!(mut_a, a.div_t(f2)); - mut_a = a; - - mut_a.add_self_v(&b); - assert_eq!(mut_a, a.add_v(&b)); - mut_a = a; - - mut_a.sub_self_v(&b); - assert_eq!(mut_a, a.sub_v(&b)); - mut_a = a; - - mut_a.mul_self_v(&b); - assert_eq!(mut_a, a.mul_v(&b)); - mut_a = a; - - mut_a.div_self_v(&b); - assert_eq!(mut_a, a.div_v(&b)); -} - -#[test] -fn test_vec3_approx_eq() { - assert!(!Vec3::new::(0.000001, 0.000001, 0.000001).approx_eq(&Vec3::new::(0.0, 0.0, 0.0))); - assert!(Vec3::new::(0.0000001, 0.0000001, 0.0000001).approx_eq(&Vec3::new::(0.0, 0.0, 0.0))); -} - -#[test] -fn test_vec3_euclidean() { - let a = Vec3::new::(2.0, 3.0, 6.0); // (2, 3, 6, 7) Pythagorean quadruple - let b0 = Vec3::new::(1.0, 4.0, 8.0); // (1, 4, 8, 9) Pythagorean quadruple - let b = a.add_v(&b0); - - assert_eq!(a.length(), 7.0); - assert_eq!(a.length2(), 7.0 * 7.0); - - assert_eq!(b0.length(), 9.0); - assert_eq!(b0.length2(), 9.0 * 9.0); - - assert_eq!(a.distance(&b), 9.0); - assert_eq!(a.distance2(&b), 9.0 * 9.0); - - assert!(Vec3::new::(1.0, 0.0, 1.0).angle(&Vec3::new::(1.0, 1.0, 0.0)).approx_eq(&Real::frac_pi_3())); - assert!(Vec3::new::(10.0, 0.0, 10.0).angle(&Vec3::new::(5.0, 5.0, 0.0)).approx_eq(&Real::frac_pi_3())); - assert!(Vec3::new::(-1.0, 0.0, -1.0).angle(&Vec3::new::(1.0, -1.0, 0.0)).approx_eq(&(2.0 * Real::frac_pi_3()))); - - assert!(Vec3::new::(2.0, 3.0, 6.0).normalize().approx_eq(&Vec3::new::(2.0/7.0, 3.0/7.0, 6.0/7.0))); - // TODO: test normalize_to, normalize_self, and normalize_self_to - - let c = Vec3::new::(-2.0, -1.0, 1.0); - let d = Vec3::new::( 1.0, 0.0, 0.5); - - assert_eq!(c.lerp(&d, 0.75), Vec3::new::(0.250, -0.250, 0.625)); - - let mut mut_c = c; - mut_c.lerp_self(&d, 0.75); - assert_eq!(mut_c, c.lerp(&d, 0.75)); -} - -#[test] -fn test_vec3_boolean() { - let tft = Vec3::new(true, false, true); - let fff = Vec3::new(false, false, false); - let ttt = Vec3::new(true, true, true); - - assert_eq!(tft.any(), true); - assert_eq!(tft.all(), false); - assert_eq!(tft.not(), Vec3::new(false, true, false)); - - assert_eq!(fff.any(), false); - assert_eq!(fff.all(), false); - assert_eq!(fff.not(), Vec3::new(true, true, true)); - - assert_eq!(ttt.any(), true); - assert_eq!(ttt.all(), true); - assert_eq!(ttt.not(), Vec3::new(false, false, false)); -} - -#[test] -fn test_vec4() { - let a = Vec4 { x: 1.0, y: 2.0, z: 3.0, w: 4.0 }; - let b = Vec4 { x: 5.0, y: 6.0, z: 7.0, w: 8.0 }; - let f1 = 1.5; - let f2 = 0.5; - - let mut mut_a = a; - - assert_eq!(Vec4::new::(1.0, 2.0, 3.0, 4.0), a); - assert_eq!(Vec4::from_value(1.0), Vec4::new::(1.0, 1.0, 1.0, 1.0)); - - *mut_a.index_mut(0) = 42.0; - *mut_a.index_mut(1) = 43.0; - *mut_a.index_mut(2) = 44.0; - *mut_a.index_mut(3) = 45.0; - assert_eq!(mut_a, Vec4::new::(42.0, 43.0, 44.0, 45.0)); - mut_a = a; - - mut_a.swap(0, 3); - assert_eq!(*mut_a.index(0), *a.index(3)); - assert_eq!(*mut_a.index(3), *a.index(0)); - mut_a = a; - - mut_a.swap(1, 2); - assert_eq!(*mut_a.index(1), *a.index(2)); - assert_eq!(*mut_a.index(2), *a.index(1)); - mut_a = a; - - assert_eq!(Vec4::zero(), Vec4::new::(0.0, 0.0, 0.0, 0.0)); - assert_eq!(Vec4::unit_x(), Vec4::new::(1.0, 0.0, 0.0, 0.0)); - assert_eq!(Vec4::unit_y(), Vec4::new::(0.0, 1.0, 0.0, 0.0)); - assert_eq!(Vec4::unit_z(), Vec4::new::(0.0, 0.0, 1.0, 0.0)); - assert_eq!(Vec4::unit_w(), Vec4::new::(0.0, 0.0, 0.0, 1.0)); - assert_eq!(Vec4::identity(), Vec4::new::(1.0, 1.0, 1.0, 1.0)); - - assert_eq!(a.x, 1.0); - assert_eq!(a.y, 2.0); - assert_eq!(a.z, 3.0); - assert_eq!(a.w, 4.0); - assert_eq!(*a.index(0), 1.0); - assert_eq!(*a.index(1), 2.0); - assert_eq!(*a.index(2), 3.0); - assert_eq!(*a.index(3), 4.0); - - assert_eq!(-a, Vec4::new::(-1.0, -2.0, -3.0, -4.0)); - assert_eq!(a.neg(), Vec4::new::(-1.0, -2.0, -3.0, -4.0)); - - assert!(Vec4::new::(0.0, 0.0, 0.0, 0.0).is_zero()); - assert!(!Vec4::new::(1.0, 1.0, 1.0, 1.0).is_zero()); - - assert_eq!(a.mul_t(f1), Vec4::new::( 1.5, 3.0, 4.5, 6.0)); - assert_eq!(a.div_t(f2), Vec4::new::( 2.0, 4.0, 6.0, 8.0)); - - assert_eq!(a.add_v(&b), Vec4::new::( 6.0, 8.0, 10.0, 12.0)); - assert_eq!(a.sub_v(&b), Vec4::new::( -4.0, -4.0, -4.0, -4.0)); - assert_eq!(a.mul_v(&b), Vec4::new::( 5.0, 12.0, 21.0, 32.0)); - assert_eq!(a.div_v(&b), Vec4::new::(1.0/5.0, 2.0/6.0, 3.0/7.0, 4.0/8.0)); - - assert_eq!(a.dot(&b), 70.0); - - mut_a.neg_self(); - assert_eq!(mut_a, -a); - mut_a = a; - - mut_a.mul_self_t(f1); - assert_eq!(mut_a, a.mul_t(f1)); - mut_a = a; - - mut_a.div_self_t(f2); - assert_eq!(mut_a, a.div_t(f2)); - mut_a = a; - - mut_a.add_self_v(&b); - assert_eq!(mut_a, a.add_v(&b)); - mut_a = a; - - mut_a.sub_self_v(&b); - assert_eq!(mut_a, a.sub_v(&b)); - mut_a = a; - - mut_a.mul_self_v(&b); - assert_eq!(mut_a, a.mul_v(&b)); - mut_a = a; - - mut_a.div_self_v(&b); - assert_eq!(mut_a, a.div_v(&b)); -} - -#[test] -fn test_vec4_approx_eq() { - assert!(!Vec4::new::(0.000001, 0.000001, 0.000001, 0.000001).approx_eq(&Vec4::new::(0.0, 0.0, 0.0, 0.0))); - assert!(Vec4::new::(0.0000001, 0.0000001, 0.0000001, 0.0000001).approx_eq(&Vec4::new::(0.0, 0.0, 0.0, 0.0))); -} - -#[test] -fn test_vec4_euclidean() { - let a = Vec4::new::(1.0, 2.0, 4.0, 10.0); // (1, 2, 4, 10, 11) Pythagorean quintuple - let b0 = Vec4::new::(1.0, 2.0, 8.0, 10.0); // (1, 2, 8, 10, 13) Pythagorean quintuple - let b = a.add_v(&b0); - - assert_eq!(a.length(), 11.0); - assert_eq!(a.length2(), 11.0 * 11.0); - - assert_eq!(b0.length(), 13.0); - assert_eq!(b0.length2(), 13.0 * 13.0); - - assert_eq!(a.distance(&b), 13.0); - assert_eq!(a.distance2(&b), 13.0 * 13.0); - - assert!(Vec4::new::(1.0, 0.0, 1.0, 0.0).angle(&Vec4::new::(0.0, 1.0, 0.0, 1.0)).approx_eq(&Real::frac_pi_2())); - assert!(Vec4::new::(10.0, 0.0, 10.0, 0.0).angle(&Vec4::new::(0.0, 5.0, 0.0, 5.0)).approx_eq(&Real::frac_pi_2())); - assert!(Vec4::new::(-1.0, 0.0, -1.0, 0.0).angle(&Vec4::new::(0.0, 1.0, 0.0, 1.0)).approx_eq(&Real::frac_pi_2())); - - assert!(Vec4::new::(1.0, 2.0, 4.0, 10.0).normalize().approx_eq(&Vec4::new::(1.0/11.0, 2.0/11.0, 4.0/11.0, 10.0/11.0))); - // TODO: test normalize_to, normalize_self, and normalize_self_to - - let c = Vec4::new::(-2.0, -1.0, 1.0, 2.0); - let d = Vec4::new::( 1.0, 0.0, 0.5, 1.0); - - assert_eq!(c.lerp(&d, 0.75), Vec4::new::(0.250, -0.250, 0.625, 1.250)); - - let mut mut_c = c; - mut_c.lerp_self(&d, 0.75); - assert_eq!(mut_c, c.lerp(&d, 0.75)); -} - -#[test] -fn test_vec4_boolean() { - let tftf = Vec4::new(true, false, true, false); - let ffff = Vec4::new(false, false, false, false); - let tttt = Vec4::new(true, true, true, true); - - assert_eq!(tftf.any(), true); - assert_eq!(tftf.all(), false); - assert_eq!(tftf.not(), Vec4::new(false, true, false, true)); - - assert_eq!(ffff.any(), false); - assert_eq!(ffff.all(), false); - assert_eq!(ffff.not(), Vec4::new(true, true, true, true)); - - assert_eq!(tttt.any(), true); - assert_eq!(tttt.all(), true); - assert_eq!(tttt.not(), Vec4::new(false, false, false, false)); -} \ No newline at end of file diff --git a/src/vec2.rs b/src/vec2.rs index 1f59095..1985d43 100644 --- a/src/vec2.rs +++ b/src/vec2.rs @@ -416,3 +416,139 @@ impl Vec2 { Vec2::new(!*self.index(0), !*self.index(1)) } } + +#[cfg(test)] +mod tests { + use vec::*; + + #[test] + fn test_vec2() { + let a = Vec2 { x: 1.0, y: 2.0 }; + let b = Vec2 { x: 3.0, y: 4.0 }; + let f1 = 1.5; + let f2 = 0.5; + + let mut mut_a = a; + + assert_eq!(Vec2::new::(1.0, 2.0), a); + assert_eq!(Vec2::from_value(1.0), Vec2::new::(1.0, 1.0)); + + assert_eq!(Vec2::zero(), Vec2::new::(0.0, 0.0)); + assert_eq!(Vec2::unit_x(), Vec2::new::(1.0, 0.0)); + assert_eq!(Vec2::unit_y(), Vec2::new::(0.0, 1.0)); + assert_eq!(Vec2::identity(), Vec2::new::(1.0, 1.0)); + + *mut_a.index_mut(0) = 42.0; + *mut_a.index_mut(1) = 43.0; + assert_eq!(mut_a, Vec2::new::(42.0, 43.0)); + mut_a = a; + + mut_a.swap(0, 1); + assert_eq!(*mut_a.index(0), *a.index(1)); + assert_eq!(*mut_a.index(1), *a.index(0)); + mut_a = a; + + assert_eq!(a.x, 1.0); + assert_eq!(a.y, 2.0); + assert_eq!(*a.index(0), 1.0); + assert_eq!(*a.index(1), 2.0); + + assert_eq!(-a, Vec2::new::(-1.0, -2.0)); + assert_eq!(a.neg(), Vec2::new::(-1.0, -2.0)); + + assert!(Vec2::new::(0.0, 0.0).is_zero()); + assert!(!Vec2::new::(1.0, 1.0).is_zero()); + + assert_eq!(a.mul_t(f1), Vec2::new::( 1.5, 3.0)); + assert_eq!(a.div_t(f2), Vec2::new::( 2.0, 4.0)); + + assert_eq!(a.add_v(&b), Vec2::new::( 4.0, 6.0)); + assert_eq!(a.sub_v(&b), Vec2::new::( -2.0, -2.0)); + assert_eq!(a.mul_v(&b), Vec2::new::( 3.0, 8.0)); + assert_eq!(a.div_v(&b), Vec2::new::(1.0/3.0, 2.0/4.0)); + + mut_a.neg_self(); + assert_eq!(mut_a, -a); + mut_a = a; + + mut_a.mul_self_t(f1); + assert_eq!(mut_a, a.mul_t(f1)); + mut_a = a; + + mut_a.div_self_t(f2); + assert_eq!(mut_a, a.div_t(f2)); + mut_a = a; + + mut_a.add_self_v(&b); + assert_eq!(mut_a, a.add_v(&b)); + mut_a = a; + + mut_a.sub_self_v(&b); + assert_eq!(mut_a, a.sub_v(&b)); + mut_a = a; + + mut_a.mul_self_v(&b); + assert_eq!(mut_a, a.mul_v(&b)); + mut_a = a; + + mut_a.div_self_v(&b); + assert_eq!(mut_a, a.div_v(&b)); + } + + #[test] + fn test_vec2_approx_eq() { + assert!(!Vec2::new::(0.000001, 0.000001).approx_eq(&Vec2::new::(0.0, 0.0))); + assert!(Vec2::new::(0.0000001, 0.0000001).approx_eq(&Vec2::new::(0.0, 0.0))); + } + + #[test] + fn test_vec2_euclidean() { + let a = Vec2::new::(5.0, 12.0); // (5, 12, 13) Pythagorean triple + let b0 = Vec2::new::(3.0, 4.0); // (3, 4, 5) Pythagorean triple + let b = a.add_v(&b0); + + assert_eq!(a.length(), 13.0); + assert_eq!(a.length2(), 13.0 * 13.0); + + assert_eq!(b0.length(), 5.0); + assert_eq!(b0.length2(), 5.0 * 5.0); + + assert_eq!(a.distance(&b), 5.0); + assert_eq!(a.distance2(&b), 5.0 * 5.0); + + assert!(Vec2::new::(1.0, 0.0).angle(&Vec2::new::(0.0, 1.0)).approx_eq(&Real::frac_pi_2())); + assert!(Vec2::new::(10.0, 0.0).angle(&Vec2::new::(0.0, 5.0)).approx_eq(&Real::frac_pi_2())); + assert!(Vec2::new::(-1.0, 0.0).angle(&Vec2::new::(0.0, 1.0)).approx_eq(&-Real::frac_pi_2::())); + + assert!(Vec2::new::(3.0, 4.0).normalize().approx_eq(&Vec2::new::(3.0/5.0, 4.0/5.0))); + // TODO: test normalize_to, normalize_self, and normalize_self_to + + let c = Vec2::new::(-2.0, -1.0); + let d = Vec2::new::( 1.0, 0.0); + + assert_eq!(c.lerp(&d, 0.75), Vec2::new::(0.250, -0.250)); + + let mut mut_c = c; + mut_c.lerp_self(&d, 0.75); + assert_eq!(mut_c, c.lerp(&d, 0.75)); + } + + #[test] + fn test_vec2_boolean() { + let tf = Vec2::new(true, false); + let ff = Vec2::new(false, false); + let tt = Vec2::new(true, true); + + assert_eq!(tf.any(), true); + assert_eq!(tf.all(), false); + assert_eq!(tf.not(), Vec2::new(false, true)); + + assert_eq!(ff.any(), false); + assert_eq!(ff.all(), false); + assert_eq!(ff.not(), Vec2::new(true, true)); + + assert_eq!(tt.any(), true); + assert_eq!(tt.all(), true); + assert_eq!(tt.not(), Vec2::new(false, false)); + } +} diff --git a/src/vec3.rs b/src/vec3.rs index 89caebb..0267e51 100644 --- a/src/vec3.rs +++ b/src/vec3.rs @@ -464,3 +464,154 @@ impl Vec3 { Vec3::new(!*self.index(0), !*self.index(1), !*self.index(2)) } } + +#[cfg(test)] +mod tests{ + use vec::*; + + #[test] + fn test_vec3() { + let a = Vec3 { x: 1.0, y: 2.0, z: 3.0 }; + let b = Vec3 { x: 4.0, y: 5.0, z: 6.0 }; + let f1 = 1.5; + let f2 = 0.5; + + let mut mut_a = a; + + assert_eq!(Vec3::new::(1.0, 2.0, 3.0), a); + assert_eq!(Vec3::from_value(1.0), Vec3::new::(1.0, 1.0, 1.0)); + + assert_eq!(Vec3::zero(), Vec3::new::(0.0, 0.0, 0.0)); + assert_eq!(Vec3::unit_x(), Vec3::new::(1.0, 0.0, 0.0)); + assert_eq!(Vec3::unit_y(), Vec3::new::(0.0, 1.0, 0.0)); + assert_eq!(Vec3::unit_z(), Vec3::new::(0.0, 0.0, 1.0)); + assert_eq!(Vec3::identity(), Vec3::new::(1.0, 1.0, 1.0)); + + *mut_a.index_mut(0) = 42.0; + *mut_a.index_mut(1) = 43.0; + *mut_a.index_mut(2) = 44.0; + assert_eq!(mut_a, Vec3::new::(42.0, 43.0, 44.0)); + mut_a = a; + + mut_a.swap(0, 2); + assert_eq!(*mut_a.index(0), *a.index(2)); + assert_eq!(*mut_a.index(2), *a.index(0)); + mut_a = a; + + mut_a.swap(1, 2); + assert_eq!(*mut_a.index(1), *a.index(2)); + assert_eq!(*mut_a.index(2), *a.index(1)); + mut_a = a; + + assert_eq!(a.x, 1.0); + assert_eq!(a.y, 2.0); + assert_eq!(a.z, 3.0); + assert_eq!(*a.index(0), 1.0); + assert_eq!(*a.index(1), 2.0); + assert_eq!(*a.index(2), 3.0); + + assert_eq!(a.cross(&b), Vec3::new::(-3.0, 6.0, -3.0)); + + mut_a.cross_self(&b); + assert_eq!(mut_a, a.cross(&b)); + mut_a = a; + + assert_eq!(-a, Vec3::new::(-1.0, -2.0, -3.0)); + assert_eq!(a.neg(), Vec3::new::(-1.0, -2.0, -3.0)); + + assert!(Vec3::new::(0.0, 0.0, 0.0).is_zero()); + assert!(!Vec3::new::(1.0, 1.0, 1.0).is_zero()); + + assert_eq!(a.mul_t(f1), Vec3::new::( 1.5, 3.0, 4.5)); + assert_eq!(a.div_t(f2), Vec3::new::( 2.0, 4.0, 6.0)); + + assert_eq!(a.add_v(&b), Vec3::new::( 5.0, 7.0, 9.0)); + assert_eq!(a.sub_v(&b), Vec3::new::( -3.0, -3.0, -3.0)); + assert_eq!(a.mul_v(&b), Vec3::new::( 4.0, 10.0, 18.0)); + assert_eq!(a.div_v(&b), Vec3::new::(1.0/4.0, 2.0/5.0, 3.0/6.0)); + + mut_a.neg_self(); + assert_eq!(mut_a, -a); + mut_a = a; + + mut_a.mul_self_t(f1); + assert_eq!(mut_a, a.mul_t(f1)); + mut_a = a; + + mut_a.div_self_t(f2); + assert_eq!(mut_a, a.div_t(f2)); + mut_a = a; + + mut_a.add_self_v(&b); + assert_eq!(mut_a, a.add_v(&b)); + mut_a = a; + + mut_a.sub_self_v(&b); + assert_eq!(mut_a, a.sub_v(&b)); + mut_a = a; + + mut_a.mul_self_v(&b); + assert_eq!(mut_a, a.mul_v(&b)); + mut_a = a; + + mut_a.div_self_v(&b); + assert_eq!(mut_a, a.div_v(&b)); + } + + #[test] + fn test_vec3_approx_eq() { + assert!(!Vec3::new::(0.000001, 0.000001, 0.000001).approx_eq(&Vec3::new::(0.0, 0.0, 0.0))); + assert!(Vec3::new::(0.0000001, 0.0000001, 0.0000001).approx_eq(&Vec3::new::(0.0, 0.0, 0.0))); + } + + #[test] + fn test_vec3_euclidean() { + let a = Vec3::new::(2.0, 3.0, 6.0); // (2, 3, 6, 7) Pythagorean quadruple + let b0 = Vec3::new::(1.0, 4.0, 8.0); // (1, 4, 8, 9) Pythagorean quadruple + let b = a.add_v(&b0); + + assert_eq!(a.length(), 7.0); + assert_eq!(a.length2(), 7.0 * 7.0); + + assert_eq!(b0.length(), 9.0); + assert_eq!(b0.length2(), 9.0 * 9.0); + + assert_eq!(a.distance(&b), 9.0); + assert_eq!(a.distance2(&b), 9.0 * 9.0); + + assert!(Vec3::new::(1.0, 0.0, 1.0).angle(&Vec3::new::(1.0, 1.0, 0.0)).approx_eq(&Real::frac_pi_3())); + assert!(Vec3::new::(10.0, 0.0, 10.0).angle(&Vec3::new::(5.0, 5.0, 0.0)).approx_eq(&Real::frac_pi_3())); + assert!(Vec3::new::(-1.0, 0.0, -1.0).angle(&Vec3::new::(1.0, -1.0, 0.0)).approx_eq(&(2.0 * Real::frac_pi_3()))); + + assert!(Vec3::new::(2.0, 3.0, 6.0).normalize().approx_eq(&Vec3::new::(2.0/7.0, 3.0/7.0, 6.0/7.0))); + // TODO: test normalize_to, normalize_self, and normalize_self_to + + let c = Vec3::new::(-2.0, -1.0, 1.0); + let d = Vec3::new::( 1.0, 0.0, 0.5); + + assert_eq!(c.lerp(&d, 0.75), Vec3::new::(0.250, -0.250, 0.625)); + + let mut mut_c = c; + mut_c.lerp_self(&d, 0.75); + assert_eq!(mut_c, c.lerp(&d, 0.75)); + } + + #[test] + fn test_vec3_boolean() { + let tft = Vec3::new(true, false, true); + let fff = Vec3::new(false, false, false); + let ttt = Vec3::new(true, true, true); + + assert_eq!(tft.any(), true); + assert_eq!(tft.all(), false); + assert_eq!(tft.not(), Vec3::new(false, true, false)); + + assert_eq!(fff.any(), false); + assert_eq!(fff.all(), false); + assert_eq!(fff.not(), Vec3::new(true, true, true)); + + assert_eq!(ttt.any(), true); + assert_eq!(ttt.all(), true); + assert_eq!(ttt.not(), Vec3::new(false, false, false)); + } +} diff --git a/src/vec4.rs b/src/vec4.rs index 6a5c923..3ce41a5 100644 --- a/src/vec4.rs +++ b/src/vec4.rs @@ -487,3 +487,154 @@ impl Vec4 { Vec4::new(!*self.index(0), !*self.index(1), !*self.index(2), !*self.index(3)) } } + +#[cfg(test)] +mod tests { + use vec::*; + + #[test] + fn test_vec4() { + let a = Vec4 { x: 1.0, y: 2.0, z: 3.0, w: 4.0 }; + let b = Vec4 { x: 5.0, y: 6.0, z: 7.0, w: 8.0 }; + let f1 = 1.5; + let f2 = 0.5; + + let mut mut_a = a; + + assert_eq!(Vec4::new::(1.0, 2.0, 3.0, 4.0), a); + assert_eq!(Vec4::from_value(1.0), Vec4::new::(1.0, 1.0, 1.0, 1.0)); + + *mut_a.index_mut(0) = 42.0; + *mut_a.index_mut(1) = 43.0; + *mut_a.index_mut(2) = 44.0; + *mut_a.index_mut(3) = 45.0; + assert_eq!(mut_a, Vec4::new::(42.0, 43.0, 44.0, 45.0)); + mut_a = a; + + mut_a.swap(0, 3); + assert_eq!(*mut_a.index(0), *a.index(3)); + assert_eq!(*mut_a.index(3), *a.index(0)); + mut_a = a; + + mut_a.swap(1, 2); + assert_eq!(*mut_a.index(1), *a.index(2)); + assert_eq!(*mut_a.index(2), *a.index(1)); + mut_a = a; + + assert_eq!(Vec4::zero(), Vec4::new::(0.0, 0.0, 0.0, 0.0)); + assert_eq!(Vec4::unit_x(), Vec4::new::(1.0, 0.0, 0.0, 0.0)); + assert_eq!(Vec4::unit_y(), Vec4::new::(0.0, 1.0, 0.0, 0.0)); + assert_eq!(Vec4::unit_z(), Vec4::new::(0.0, 0.0, 1.0, 0.0)); + assert_eq!(Vec4::unit_w(), Vec4::new::(0.0, 0.0, 0.0, 1.0)); + assert_eq!(Vec4::identity(), Vec4::new::(1.0, 1.0, 1.0, 1.0)); + + assert_eq!(a.x, 1.0); + assert_eq!(a.y, 2.0); + assert_eq!(a.z, 3.0); + assert_eq!(a.w, 4.0); + assert_eq!(*a.index(0), 1.0); + assert_eq!(*a.index(1), 2.0); + assert_eq!(*a.index(2), 3.0); + assert_eq!(*a.index(3), 4.0); + + assert_eq!(-a, Vec4::new::(-1.0, -2.0, -3.0, -4.0)); + assert_eq!(a.neg(), Vec4::new::(-1.0, -2.0, -3.0, -4.0)); + + assert!(Vec4::new::(0.0, 0.0, 0.0, 0.0).is_zero()); + assert!(!Vec4::new::(1.0, 1.0, 1.0, 1.0).is_zero()); + + assert_eq!(a.mul_t(f1), Vec4::new::( 1.5, 3.0, 4.5, 6.0)); + assert_eq!(a.div_t(f2), Vec4::new::( 2.0, 4.0, 6.0, 8.0)); + + assert_eq!(a.add_v(&b), Vec4::new::( 6.0, 8.0, 10.0, 12.0)); + assert_eq!(a.sub_v(&b), Vec4::new::( -4.0, -4.0, -4.0, -4.0)); + assert_eq!(a.mul_v(&b), Vec4::new::( 5.0, 12.0, 21.0, 32.0)); + assert_eq!(a.div_v(&b), Vec4::new::(1.0/5.0, 2.0/6.0, 3.0/7.0, 4.0/8.0)); + + assert_eq!(a.dot(&b), 70.0); + + mut_a.neg_self(); + assert_eq!(mut_a, -a); + mut_a = a; + + mut_a.mul_self_t(f1); + assert_eq!(mut_a, a.mul_t(f1)); + mut_a = a; + + mut_a.div_self_t(f2); + assert_eq!(mut_a, a.div_t(f2)); + mut_a = a; + + mut_a.add_self_v(&b); + assert_eq!(mut_a, a.add_v(&b)); + mut_a = a; + + mut_a.sub_self_v(&b); + assert_eq!(mut_a, a.sub_v(&b)); + mut_a = a; + + mut_a.mul_self_v(&b); + assert_eq!(mut_a, a.mul_v(&b)); + mut_a = a; + + mut_a.div_self_v(&b); + assert_eq!(mut_a, a.div_v(&b)); + } + + #[test] + fn test_vec4_approx_eq() { + assert!(!Vec4::new::(0.000001, 0.000001, 0.000001, 0.000001).approx_eq(&Vec4::new::(0.0, 0.0, 0.0, 0.0))); + assert!(Vec4::new::(0.0000001, 0.0000001, 0.0000001, 0.0000001).approx_eq(&Vec4::new::(0.0, 0.0, 0.0, 0.0))); + } + + #[test] + fn test_vec4_euclidean() { + let a = Vec4::new::(1.0, 2.0, 4.0, 10.0); // (1, 2, 4, 10, 11) Pythagorean quintuple + let b0 = Vec4::new::(1.0, 2.0, 8.0, 10.0); // (1, 2, 8, 10, 13) Pythagorean quintuple + let b = a.add_v(&b0); + + assert_eq!(a.length(), 11.0); + assert_eq!(a.length2(), 11.0 * 11.0); + + assert_eq!(b0.length(), 13.0); + assert_eq!(b0.length2(), 13.0 * 13.0); + + assert_eq!(a.distance(&b), 13.0); + assert_eq!(a.distance2(&b), 13.0 * 13.0); + + assert!(Vec4::new::(1.0, 0.0, 1.0, 0.0).angle(&Vec4::new::(0.0, 1.0, 0.0, 1.0)).approx_eq(&Real::frac_pi_2())); + assert!(Vec4::new::(10.0, 0.0, 10.0, 0.0).angle(&Vec4::new::(0.0, 5.0, 0.0, 5.0)).approx_eq(&Real::frac_pi_2())); + assert!(Vec4::new::(-1.0, 0.0, -1.0, 0.0).angle(&Vec4::new::(0.0, 1.0, 0.0, 1.0)).approx_eq(&Real::frac_pi_2())); + + assert!(Vec4::new::(1.0, 2.0, 4.0, 10.0).normalize().approx_eq(&Vec4::new::(1.0/11.0, 2.0/11.0, 4.0/11.0, 10.0/11.0))); + // TODO: test normalize_to, normalize_self, and normalize_self_to + + let c = Vec4::new::(-2.0, -1.0, 1.0, 2.0); + let d = Vec4::new::( 1.0, 0.0, 0.5, 1.0); + + assert_eq!(c.lerp(&d, 0.75), Vec4::new::(0.250, -0.250, 0.625, 1.250)); + + let mut mut_c = c; + mut_c.lerp_self(&d, 0.75); + assert_eq!(mut_c, c.lerp(&d, 0.75)); + } + + #[test] + fn test_vec4_boolean() { + let tftf = Vec4::new(true, false, true, false); + let ffff = Vec4::new(false, false, false, false); + let tttt = Vec4::new(true, true, true, true); + + assert_eq!(tftf.any(), true); + assert_eq!(tftf.all(), false); + assert_eq!(tftf.not(), Vec4::new(false, true, false, true)); + + assert_eq!(ffff.any(), false); + assert_eq!(ffff.all(), false); + assert_eq!(ffff.not(), Vec4::new(true, true, true, true)); + + assert_eq!(tttt.any(), true); + assert_eq!(tttt.all(), true); + assert_eq!(tttt.not(), Vec4::new(false, false, false, false)); + } +}