Add Quaternion/Matrix.isFinite() (#211)

JOML-CI · Feb 26, 2020 · 537c93d · 537c93d
1 parent f4ceb64
commit 537c93d
Show file tree

Hide file tree

Showing 28 changed files with 198 additions and 9 deletions.
diff --git a/pom.xml b/pom.xml
@@ -4,7 +4,7 @@
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>org.joml</groupId>
 	<artifactId>joml</artifactId>
-	<version>1.9.22</version>
+	<version>1.9.23-SNAPSHOT</version>
 	<name>JOML</name>
 	<description>Java OpenGL Math Library</description>
 	<inceptionYear>2015</inceptionYear>

diff --git a/src/org/joml/Matrix2d.java b/src/org/joml/Matrix2d.java
@@ -1669,4 +1669,9 @@ public Matrix2d lerp(Matrix2dc other, double t, Matrix2d dest) {
         return dest;
     }
 
+    public boolean isFinite() {
+        return Math.isFinite(m00) && Math.isFinite(m01) &&
+               Math.isFinite(m10) && Math.isFinite(m11);
+    }
+
 }
diff --git a/src/org/joml/Matrix2dc.java b/src/org/joml/Matrix2dc.java
@@ -743,4 +743,14 @@ public interface Matrix2dc {
      */
     boolean equals(Matrix2dc m, double delta);
 
+    /**
+     * Determine whether all matrix elements are finite floating-point values, that
+     * is, they are not {@link Double#isNaN() NaN} and not
+     * {@link Double#isInfinite() infinity}.
+     *
+     * @return {@code true} if all components are finite floating-point values;
+     *         {@code false} otherwise
+     */
+    boolean isFinite();
+
 }
diff --git a/src/org/joml/Matrix2f.java b/src/org/joml/Matrix2f.java
@@ -1558,4 +1558,9 @@ public Matrix2f lerp(Matrix2fc other, float t, Matrix2f dest) {
         return dest;
     }
 
+    public boolean isFinite() {
+        return Math.isFinite(m00) && Math.isFinite(m01) &&
+               Math.isFinite(m10) && Math.isFinite(m11);
+    }
+
 }
diff --git a/src/org/joml/Matrix2fc.java b/src/org/joml/Matrix2fc.java
@@ -727,4 +727,14 @@ public interface Matrix2fc {
      */
     boolean equals(Matrix2fc m, float delta);
 
+    /**
+     * Determine whether all matrix elements are finite floating-point values, that
+     * is, they are not {@link Float#isNaN() NaN} and not
+     * {@link Float#isInfinite() infinity}.
+     *
+     * @return {@code true} if all components are finite floating-point values;
+     *         {@code false} otherwise
+     */
+    boolean isFinite();
+
 }
diff --git a/src/org/joml/Matrix3d.java b/src/org/joml/Matrix3d.java
@@ -5090,4 +5090,10 @@ public Matrix3d reflection(Quaterniondc orientation) {
         return reflection(normalX, normalY, normalZ);
     }
 
+    public boolean isFinite() {
+        return Math.isFinite(m00) && Math.isFinite(m01) && Math.isFinite(m02) &&
+               Math.isFinite(m10) && Math.isFinite(m11) && Math.isFinite(m12) &&
+               Math.isFinite(m20) && Math.isFinite(m21) && Math.isFinite(m22);
+    }
+
 }
diff --git a/src/org/joml/Matrix3dc.java b/src/org/joml/Matrix3dc.java
@@ -1581,4 +1581,14 @@ public interface Matrix3dc {
      */
     Matrix3d reflect(Vector3dc normal, Matrix3d dest);
 
+    /**
+     * Determine whether all matrix elements are finite floating-point values, that
+     * is, they are not {@link Double#isNaN() NaN} and not
+     * {@link Double#isInfinite() infinity}.
+     *
+     * @return {@code true} if all components are finite floating-point values;
+     *         {@code false} otherwise
+     */
+    boolean isFinite();
+
 }
diff --git a/src/org/joml/Matrix3f.java b/src/org/joml/Matrix3f.java
@@ -4506,4 +4506,10 @@ public Matrix3f reflection(Quaternionfc orientation) {
         return reflection(normalX, normalY, normalZ);
     }
 
+    public boolean isFinite() {
+        return Math.isFinite(m00) && Math.isFinite(m01) && Math.isFinite(m02) &&
+               Math.isFinite(m10) && Math.isFinite(m11) && Math.isFinite(m12) &&
+               Math.isFinite(m20) && Math.isFinite(m21) && Math.isFinite(m22);
+    }
+
 }
diff --git a/src/org/joml/Matrix3fc.java b/src/org/joml/Matrix3fc.java
@@ -1503,4 +1503,14 @@ public interface Matrix3fc {
      */
     Matrix3f reflect(Vector3fc normal, Matrix3f dest);
 
-}
+    /**
+     * Determine whether all matrix elements are finite floating-point values, that
+     * is, they are not {@link Float#isNaN() NaN} and not
+     * {@link Float#isInfinite() infinity}.
+     *
+     * @return {@code true} if all components are finite floating-point values;
+     *         {@code false} otherwise
+     */
+    boolean isFinite();
+
+}
diff --git a/src/org/joml/Matrix3x2d.java b/src/org/joml/Matrix3x2d.java
@@ -2547,4 +2547,10 @@ public boolean equals(Matrix3x2dc m, double delta) {
         return true;
     }
 
+    public boolean isFinite() {
+        return Math.isFinite(m00) && Math.isFinite(m01) &&
+               Math.isFinite(m10) && Math.isFinite(m11) &&
+               Math.isFinite(m20) && Math.isFinite(m21);
+    }
+
 }
diff --git a/src/org/joml/Matrix3x2dc.java b/src/org/joml/Matrix3x2dc.java
@@ -1213,4 +1213,14 @@ public interface Matrix3x2dc {
      */
     boolean equals(Matrix3x2dc m, double delta);
 
+    /**
+     * Determine whether all matrix elements are finite floating-point values, that
+     * is, they are not {@link Double#isNaN() NaN} and not
+     * {@link Double#isInfinite() infinity}.
+     *
+     * @return {@code true} if all components are finite floating-point values;
+     *         {@code false} otherwise
+     */
+    boolean isFinite();
+
 }
diff --git a/src/org/joml/Matrix3x2f.java b/src/org/joml/Matrix3x2f.java
@@ -2544,4 +2544,10 @@ public boolean equals(Matrix3x2fc m, float delta) {
         return true;
     }
 
+    public boolean isFinite() {
+        return Math.isFinite(m00) && Math.isFinite(m01) &&
+               Math.isFinite(m10) && Math.isFinite(m11) &&
+               Math.isFinite(m20) && Math.isFinite(m21);
+    }
+
 }
diff --git a/src/org/joml/Matrix3x2fc.java b/src/org/joml/Matrix3x2fc.java
@@ -1197,4 +1197,14 @@ public interface Matrix3x2fc {
      */
     boolean equals(Matrix3x2fc m, float delta);
 
+    /**
+     * Determine whether all matrix elements are finite floating-point values, that
+     * is, they are not {@link Float#isNaN() NaN} and not
+     * {@link Float#isInfinite() infinity}.
+     *
+     * @return {@code true} if all components are finite floating-point values;
+     *         {@code false} otherwise
+     */
+    boolean isFinite();
+
 }
diff --git a/src/org/joml/Matrix4d.java b/src/org/joml/Matrix4d.java
@@ -16392,4 +16392,11 @@ public Matrix4d withLookAtUp(double upX, double upY, double upZ, Matrix4d dest)
         return dest;
     }
 
+    public boolean isFinite() {
+        return Math.isFinite(m00) && Math.isFinite(m01) && Math.isFinite(m02) && Math.isFinite(m03) &&
+               Math.isFinite(m10) && Math.isFinite(m11) && Math.isFinite(m12) && Math.isFinite(m13) &&
+               Math.isFinite(m20) && Math.isFinite(m21) && Math.isFinite(m22) && Math.isFinite(m23) &&
+               Math.isFinite(m30) && Math.isFinite(m31) && Math.isFinite(m32) && Math.isFinite(m33);
+    }
+
 }
diff --git a/src/org/joml/Matrix4dc.java b/src/org/joml/Matrix4dc.java
@@ -5458,4 +5458,14 @@ Matrix4d mul3x3(
      */
     boolean equals(Matrix4dc m, double delta);
 
+    /**
+     * Determine whether all matrix elements are finite floating-point values, that
+     * is, they are not {@link Double#isNaN() NaN} and not
+     * {@link Double#isInfinite() infinity}.
+     *
+     * @return {@code true} if all components are finite floating-point values;
+     *         {@code false} otherwise
+     */
+    boolean isFinite();
+
 }
diff --git a/src/org/joml/Matrix4f.java b/src/org/joml/Matrix4f.java
@@ -15102,4 +15102,11 @@ public Matrix4f withLookAtUp(float upX, float upY, float upZ, Matrix4f dest) {
         return dest;
     }
 
+    public boolean isFinite() {
+        return Math.isFinite(m00) && Math.isFinite(m01) && Math.isFinite(m02) && Math.isFinite(m03) &&
+               Math.isFinite(m10) && Math.isFinite(m11) && Math.isFinite(m12) && Math.isFinite(m13) &&
+               Math.isFinite(m20) && Math.isFinite(m21) && Math.isFinite(m22) && Math.isFinite(m23) &&
+               Math.isFinite(m30) && Math.isFinite(m31) && Math.isFinite(m32) && Math.isFinite(m33);
+    }
+
 }
diff --git a/src/org/joml/Matrix4fc.java b/src/org/joml/Matrix4fc.java
@@ -5293,4 +5293,14 @@ Matrix4f mul3x3(
      */
     boolean equals(Matrix4fc m, float delta);
 
+    /**
+     * Determine whether all matrix elements are finite floating-point values, that
+     * is, they are not {@link Float#isNaN() NaN} and not
+     * {@link Float#isInfinite() infinity}.
+     *
+     * @return {@code true} if all components are finite floating-point values;
+     *         {@code false} otherwise
+     */
+    boolean isFinite();
+
 }
diff --git a/src/org/joml/Matrix4x3d.java b/src/org/joml/Matrix4x3d.java
@@ -10019,4 +10019,11 @@ public Matrix4x3d obliqueZ(double a, double b, Matrix4x3d dest) {
         return dest;
     }
 
+    public boolean isFinite() {
+        return Math.isFinite(m00) && Math.isFinite(m01) && Math.isFinite(m02) &&
+               Math.isFinite(m10) && Math.isFinite(m11) && Math.isFinite(m12) &&
+               Math.isFinite(m20) && Math.isFinite(m21) && Math.isFinite(m22) &&
+               Math.isFinite(m30) && Math.isFinite(m31) && Math.isFinite(m32);
+    }
+
 }
diff --git a/src/org/joml/Matrix4x3dc.java b/src/org/joml/Matrix4x3dc.java
@@ -3034,4 +3034,14 @@ public interface Matrix4x3dc {
      */
     boolean equals(Matrix4x3dc m, double delta);
 
+    /**
+     * Determine whether all matrix elements are finite floating-point values, that
+     * is, they are not {@link Double#isNaN() NaN} and not
+     * {@link Double#isInfinite() infinity}.
+     *
+     * @return {@code true} if all components are finite floating-point values;
+     *         {@code false} otherwise
+     */
+    boolean isFinite();
+
 }
diff --git a/src/org/joml/Matrix4x3f.java b/src/org/joml/Matrix4x3f.java
@@ -9217,4 +9217,11 @@ public Matrix4x3f withLookAtUp(float upX, float upY, float upZ, Matrix4x3f dest)
         return dest;
     }
 
+    public boolean isFinite() {
+        return Math.isFinite(m00) && Math.isFinite(m01) && Math.isFinite(m02) &&
+               Math.isFinite(m10) && Math.isFinite(m11) && Math.isFinite(m12) &&
+               Math.isFinite(m20) && Math.isFinite(m21) && Math.isFinite(m22) &&
+               Math.isFinite(m30) && Math.isFinite(m31) && Math.isFinite(m32);
+    }
+
 }
diff --git a/src/org/joml/Matrix4x3fc.java b/src/org/joml/Matrix4x3fc.java
@@ -2782,4 +2782,14 @@ public interface Matrix4x3fc {
      */
     boolean equals(Matrix4x3fc m, float delta);
 
+    /**
+     * Determine whether all matrix elements are finite floating-point values, that
+     * is, they are not {@link Float#isNaN() NaN} and not
+     * {@link Float#isInfinite() infinity}.
+     *
+     * @return {@code true} if all components are finite floating-point values;
+     *         {@code false} otherwise
+     */
+    boolean isFinite();
+
 }
diff --git a/src/org/joml/Quaterniond.java b/src/org/joml/Quaterniond.java
@@ -3082,4 +3082,7 @@ public Quaterniond conjugateBy(Quaterniondc q, Quaterniond dest) {
                         Math.fma(qpw, qiw, Math.fma(-qpx, qix, Math.fma(-qpy, qiy, -qpz * qiz))));
     }
 
+    public boolean isFinite() {
+        return Math.isFinite(x) && Math.isFinite(y) && Math.isFinite(z) && Math.isFinite(w);
+    }
 }
diff --git a/src/org/joml/Quaterniondc.java b/src/org/joml/Quaterniondc.java
@@ -1906,4 +1906,14 @@ public interface Quaterniondc {
      */
     Quaterniond conjugateBy(Quaterniondc q, Quaterniond dest);
 
+    /**
+     * Determine whether all components are finite floating-point values, that
+     * is, they are not {@link Double#isNaN() NaN} and not
+     * {@link Double#isInfinite() infinity}.
+     *
+     * @return {@code true} if all components are finite floating-point values;
+     *         {@code false} otherwise
+     */
+    boolean isFinite();
+
 }
diff --git a/src/org/joml/Quaternionf.java b/src/org/joml/Quaternionf.java
@@ -3197,4 +3197,8 @@ public Quaternionf conjugateBy(Quaternionfc q, Quaternionf dest) {
                         Math.fma(qpw, qiz, Math.fma(qpx, qiy, Math.fma(-qpy, qix, qpz * qiw))),
                         Math.fma(qpw, qiw, Math.fma(-qpx, qix, Math.fma(-qpy, qiy, -qpz * qiz))));
     }
+
+    public boolean isFinite() {
+        return Math.isFinite(x) && Math.isFinite(y) && Math.isFinite(z) && Math.isFinite(w);
+    }
 }
diff --git a/src/org/joml/Quaternionfc.java b/src/org/joml/Quaternionfc.java
@@ -1920,4 +1920,14 @@ public interface Quaternionfc {
      */
     Quaternionf conjugateBy(Quaternionfc q, Quaternionf dest);
 
-}
+    /**
+     * Determine whether all components are finite floating-point values, that
+     * is, they are not {@link Float#isNaN() NaN} and not
+     * {@link Float#isInfinite() infinity}.
+     *
+     * @return {@code true} if all components are finite floating-point values;
+     *         {@code false} otherwise
+     */
+    boolean isFinite();
+
+}
diff --git a/src/org/joml/Vector2fc.java b/src/org/joml/Vector2fc.java
@@ -529,8 +529,8 @@ public interface Vector2fc {
 
     /**
      * Determine whether all components are finite floating-point values, that
-     * is, they are not {@link Double#isNaN() NaN} and not
-     * {@link Double#isInfinite() infinity}.
+     * is, they are not {@link Float#isNaN() NaN} and not
+     * {@link Float#isInfinite() infinity}.
      *
      * @return {@code true} if all components are finite floating-point values;
      *         {@code false} otherwise

diff --git a/src/org/joml/Vector3fc.java b/src/org/joml/Vector3fc.java
@@ -1054,8 +1054,8 @@ public interface Vector3fc {
 
     /**
      * Determine whether all components are finite floating-point values, that
-     * is, they are not {@link Double#isNaN() NaN} and not
-     * {@link Double#isInfinite() infinity}.
+     * is, they are not {@link Float#isNaN() NaN} and not
+     * {@link Float#isInfinite() infinity}.
      *
      * @return {@code true} if all components are finite floating-point values;
      *         {@code false} otherwise

diff --git a/src/org/joml/Vector4fc.java b/src/org/joml/Vector4fc.java
@@ -767,8 +767,8 @@ public interface Vector4fc {
 
     /**
      * Determine whether all components are finite floating-point values, that
-     * is, they are not {@link Double#isNaN() NaN} and not
-     * {@link Double#isInfinite() infinity}.
+     * is, they are not {@link Float#isNaN() NaN} and not
+     * {@link Float#isInfinite() infinity}.
      *
      * @return {@code true} if all components are finite floating-point values;
      *         {@code false} otherwise