add tests of is_finite

Author: emilk

tests/mat2.rs

@@ -198,3 +198,14 @@ fn test_product() {
     let two = Mat2::identity() + Mat2::identity();
     assert_eq!(vec![two, two].iter().product::<Mat2>(), two * two);
 }
+
+#[test]
+fn test_mat2_is_finite() {
+    use std::f32::INFINITY;
+    use std::f32::NAN;
+    use std::f32::NEG_INFINITY;
+    assert!(Mat2::identity().is_finite());
+    assert!(!(Mat2::identity() * INFINITY).is_finite());
+    assert!(!(Mat2::identity() * NEG_INFINITY).is_finite());
+    assert!(!(Mat2::identity() * NAN).is_finite());
+}

tests/mat3.rs

@@ -262,3 +262,14 @@ fn test_product() {
     let two = Mat3::identity() + Mat3::identity();
     assert_eq!(vec![two, two].iter().product::<Mat3>(), two * two);
 }
+
+#[test]
+fn test_mat3_is_finite() {
+    use std::f32::INFINITY;
+    use std::f32::NAN;
+    use std::f32::NEG_INFINITY;
+    assert!(Mat3::identity().is_finite());
+    assert!(!(Mat3::identity() * INFINITY).is_finite());
+    assert!(!(Mat3::identity() * NEG_INFINITY).is_finite());
+    assert!(!(Mat3::identity() * NAN).is_finite());
+}

tests/mat4.rs

@@ -543,3 +543,14 @@ fn test_product() {
     let two = Mat4::identity() + Mat4::identity();
     assert_eq!(vec![two, two].iter().product::<Mat4>(), two * two);
 }
+
+#[test]
+fn test_mat4_is_finite() {
+    use std::f32::INFINITY;
+    use std::f32::NAN;
+    use std::f32::NEG_INFINITY;
+    assert!(Mat4::identity().is_finite());
+    assert!(!(Mat4::identity() * INFINITY).is_finite());
+    assert!(!(Mat4::identity() * NEG_INFINITY).is_finite());
+    assert!(!(Mat4::identity() * NAN).is_finite());
+}

tests/quat.rs

@@ -402,3 +402,16 @@ fn test_product() {
     let two = quat(2.0, 2.0, 2.0, 2.0).normalize();
     assert_eq!(vec![two, two].iter().product::<Quat>(), two * two);
 }
+
+#[test]
+fn test_quat_is_finite() {
+    use std::f32::INFINITY;
+    use std::f32::NAN;
+    use std::f32::NEG_INFINITY;
+    assert!(Quat::from_xyzw(0.0, 0.0, 0.0, 0.0).is_finite());
+    assert!(Quat::from_xyzw(-1e-10, 1.0, 1e10, 42.0).is_finite());
+    assert!(!Quat::from_xyzw(INFINITY, 0.0, 0.0, 0.0).is_finite());
+    assert!(!Quat::from_xyzw(0.0, NAN, 0.0, 0.0).is_finite());
+    assert!(!Quat::from_xyzw(0.0, 0.0, NEG_INFINITY, 0.0).is_finite());
+    assert!(!Quat::from_xyzw(0.0, 0.0, 0.0, NAN).is_finite());
+}

tests/vec2.rs

@@ -518,3 +518,16 @@ fn test_product() {
     let two = Vec2::new(2.0, 2.0);
     assert_eq!(vec![two, two].iter().product::<Vec2>(), two * two);
 }
+
+#[test]
+fn test_vec2_is_finite() {
+    use std::f32::INFINITY;
+    use std::f32::NAN;
+    use std::f32::NEG_INFINITY;
+    assert!(Vec2::new(0.0, 0.0).is_finite());
+    assert!(Vec2::new(-1e-10, 1e10).is_finite());
+    assert!(!Vec2::new(INFINITY, 0.0).is_finite());
+    assert!(!Vec2::new(0.0, NAN).is_finite());
+    assert!(!Vec2::new(0.0, NEG_INFINITY).is_finite());
+    assert!(!Vec2::new(INFINITY, NEG_INFINITY).is_finite());
+}

tests/vec3.rs

@@ -566,3 +566,16 @@ fn test_product() {
     let two = Vec3::new(2.0, 2.0, 2.0);
     assert_eq!(vec![two, two].iter().product::<Vec3>(), two * two);
 }
+
+#[test]
+fn test_vec3_is_finite() {
+    use std::f32::INFINITY;
+    use std::f32::NAN;
+    use std::f32::NEG_INFINITY;
+    assert!(Vec3::new(0.0, 0.0, 0.0).is_finite());
+    assert!(Vec3::new(-1e-10, 1.0, 1e10).is_finite());
+    assert!(!Vec3::new(INFINITY, 0.0, 0.0).is_finite());
+    assert!(!Vec3::new(0.0, NAN, 0.0).is_finite());
+    assert!(!Vec3::new(0.0, 0.0, NEG_INFINITY).is_finite());
+    assert!(!Vec3::splat(NAN).is_finite());
+}

tests/vec3a.rs

@@ -604,3 +604,26 @@ fn test_product() {
     let two = Vec3A::new(2.0, 2.0, 2.0);
     assert_eq!(vec![two, two].iter().product::<Vec3A>(), two * two);
 }
+
+#[test]
+fn test_vec3a_is_finite() {
+    use std::f32::INFINITY;
+    use std::f32::NAN;
+    use std::f32::NEG_INFINITY;
+    assert!(Vec3A::new(0.0, 0.0, 0.0).is_finite());
+    assert!(Vec3A::new(-1e-10, 1.0, 1e10).is_finite());
+    assert!(!Vec3A::new(INFINITY, 0.0, 0.0).is_finite());
+    assert!(!Vec3A::new(0.0, NAN, 0.0).is_finite());
+    assert!(!Vec3A::new(0.0, 0.0, NEG_INFINITY).is_finite());
+    assert!(!Vec3A::splat(NAN).is_finite());
+
+    {
+        // Check that the implicit fourth element (in simd) does not affect `is_finite()`:
+        let mut v = Vec3A::splat(NAN);
+        assert!(!v.is_finite());
+        v.x = 42.0;
+        v.y = 42.0;
+        v.z = 42.0;
+        assert!(v.is_finite());
+    }
+}

tests/vec4.rs

@@ -638,3 +638,16 @@ fn test_product() {
     let two = Vec4::new(2.0, 2.0, 2.0, 2.0);
     assert_eq!(vec![two, two].iter().product::<Vec4>(), two * two);
 }
+
+#[test]
+fn test_vec4_is_finite() {
+    use std::f32::INFINITY;
+    use std::f32::NAN;
+    use std::f32::NEG_INFINITY;
+    assert!(Vec4::new(0.0, 0.0, 0.0, 0.0).is_finite());
+    assert!(Vec4::new(-1e-10, 1.0, 1e10, 42.0).is_finite());
+    assert!(!Vec4::new(INFINITY, 0.0, 0.0, 0.0).is_finite());
+    assert!(!Vec4::new(0.0, NAN, 0.0, 0.0).is_finite());
+    assert!(!Vec4::new(0.0, 0.0, NEG_INFINITY, 0.0).is_finite());
+    assert!(!Vec4::new(0.0, 0.0, 0.0, NAN).is_finite());
+}