Add from helper methods

Author: kashike

src/main/template/float/com/flowpowered/math/imaginary/Complex_E_.template

@@ -518,6 +518,43 @@ public class Complex#E# implements Imaginary#E#, Comparable<Complex#E#>, Seriali
         return "(" + x + ", " + y + ")";
     }
 
+    /**
+     * Creates a new complex from the #e# real component.
+     *
+     * <p>The {@link #ZERO} constant is re-used when {@code x} is 0.</p>
+     *
+     * @param x The x (real) component
+     * @return The complex created from the #e# real component
+     */
+    public static Complex#E# fromReal(#e# x) {
+         return x == 0 ? ZERO : new Complex#E#(x, 0);
+    }
+
+    /**
+     * Creates a new quaternion from the #e# imaginary components.
+     *
+     * <p>The {@link #ZERO} constant is re-used when {@code y} is 0.</p>
+     *
+     * @param y The y (imaginary) component
+     * @return The complex created from the #e# imaginary component
+     */
+    public static Complex#E# fromImaginary(#e# y) {
+         return y == 0 ? ZERO : new Complex#E#(0, y);
+    }
+
+    /**
+     * Creates a new complex from the #e# components.
+     *
+     * <p>The {@link #ZERO} constant is re-used when both {@code x} and {@code z} are 0.</p>
+     *
+     * @param x The x (real) component
+     * @param y The y (imaginary) component
+     * @return The complex created from the #e# components
+     */
+    public static Complex#E# from(#e# x, #e# y) {
+         return x == 0 && y == 0 ? ZERO : new Complex#E#(x, y);
+    }
+
     /**
      * Creates a new complex from the angle defined from the first to the second vector.
      *

src/main/template/float/com/flowpowered/math/imaginary/Quaternion_E_.template

@@ -572,6 +572,47 @@ public class Quaternion#E# implements Imaginary#E#, Comparable<Quaternion#E#>, S
         return "(" + x + ", " + y + ", " + z + ", " + w + ")";
     }
 
+    /**
+     * Creates a new quaternion from the #e# real component.
+     *
+     * <p>The {@link #ZERO} constant is re-used when {@code w} is 0.</p>
+     *
+     * @param w The w (real) component
+     * @return The quaternion created from the #e# real component
+     */
+    public static Quaternion#E# fromReal(#e# w) {
+         return w == 0 ? ZERO : new Quaternion#E#(0, 0, 0, w);
+    }
+
+    /**
+     * Creates a new quaternion from the #e# imaginary components.
+     *
+     * <p>The {@link #ZERO} constant is re-used when {@code x}, {@code y}, and {@code z} are 0.</p>
+     *
+     * @param x The x (imaginary) component
+     * @param y The y (imaginary) component
+     * @param z The z (imaginary) component
+     * @return The quaternion created from the #e# imaginary components
+     */
+    public static Quaternion#E# fromImaginary(#e# x, #e# y, #e# z) {
+         return x == 0 && y == 0 && z == 0 ? ZERO : new Quaternion#E#(x, y, z, 0);
+    }
+
+    /**
+     * Creates a new quaternion from the #e# components.
+     *
+     * <p>The {@link #ZERO} constant is re-used when {@code x}, {@code y}, {@code z}, and {@code w} are 0.</p>
+     *
+     * @param x The x (imaginary) component
+     * @param y The y (imaginary) component
+     * @param z The z (imaginary) component
+     * @param w The w (real) component
+     * @return The quaternion created from the #e# components
+     */
+    public static Quaternion#E# from(#e# x, #e# y, #e# z, #e# w) {
+         return x == 0 && y == 0 && z == 0 && w == 0 ? ZERO : new Quaternion#E#(x, y, z, w);
+    }
+
     /**
      * Creates a new quaternion from the #EOverload# angles in degrees around the x, y and z axes.
      *

src/main/template/float/com/flowpowered/math/matrix/Matrix2_E_.template

@@ -350,6 +350,18 @@ public class Matrix2#E# implements Matrix#E#, Serializable, Cloneable {
         return new Matrix2#E#(this);
     }
 
+    public static Matrix2#E# from(#e# n) {
+         return n == 0 ? ZERO : new Matrix2#E#(n, n, n, n);
+    }
+
+    public static Matrix2#E# from(#e# m00, #e# m01, #e# m10, #e# m11) {
+         return m00 == 0 && m01 == 0 && m10 == 0 && m11 == 0 ? ZERO : new Matrix2#E#(m00, m01, m10, m11);
+    }
+
+    public static Matrix2#E# fromDiagonal(#e# m00, #e# m11) {
+         return m00 == 0 && m11 == 0 ? ZERO : new Matrix2#E#(m00, 0, 0, m11);
+    }
+
     public static Matrix2#E# createScaling(#EOverload# scale) {
         return createScaling((#e#) scale);
     }

src/main/template/float/com/flowpowered/math/matrix/Matrix3_E_.template

@@ -448,6 +448,23 @@ public class Matrix3#E# implements Matrix#E#, Serializable, Cloneable {
         return new Matrix3#E#(this);
     }
 
+    public static Matrix3#E# from(#e# n) {
+         return n == 0 ? ZERO : new Matrix3#E#(n, n, n, n, n, n, n, n, n);
+    }
+
+    public static Matrix3#E# from(#e# m00, #e# m01, #e# m02,
+                                #e# m10, #e# m11, #e# m12,
+                                #e# m20, #e# m21, #e# m22) {
+         return m00 == 0 && m01 == 0 && m02 == 0
+             && m10 == 0 && m11 == 0 && m12 == 0
+             && m20 == 0 && m21 == 0 && m22 == 0
+         ? ZERO : new Matrix3#E#(m00, m01, m02, m10, m11, m12, m20, m21, m22);
+    }
+
+    public static Matrix3#E# fromDiagonal(#e# m00, #e# m11, #e# m22) {
+         return m00 == 0 && m11 == 0 && m22 == 0 ? ZERO : new Matrix3#E#(m00, 0, 0, 0, m11, 0, 0, 0, m22);
+    }
+
     public static Matrix3#E# createScaling(#EOverload# scale) {
         return createScaling((#e#) scale);
     }

src/main/template/float/com/flowpowered/math/matrix/Matrix4_E_.template

@@ -570,6 +570,31 @@ public class Matrix4#E# implements Matrix#E#, Serializable, Cloneable {
         return new Matrix4#E#(this);
     }
 
+    public static Matrix4#E# from(#e# n) {
+         return n == 0 ? ZERO : new Matrix4#E#(n, n, n, n, n, n, n, n, n, n, n, n, n, n, n, n);
+    }
+
+    public static Matrix4#E# from(#e# m00, #e# m01, #e# m02, #e# m03,
+                                #e# m10, #e# m11, #e# m12, #e# m13,
+                                #e# m20, #e# m21, #e# m22, #e# m23,
+                                #e# m30, #e# m31, #e# m32, #e# m33) {
+         return m00 == 0 && m01 == 0 && m02 == 0 && m03 == 0
+             && m10 == 0 && m11 == 0 && m12 == 0 && m13 == 0
+             && m20 == 0 && m21 == 0 && m22 == 0 && m23 == 0
+             && m30 == 0 && m31 == 0 && m32 == 0 && m33 == 0
+         ? ZERO : new Matrix4#E#(m00, m01, m02, m03,
+                                 m10, m11, m12, m13,
+                                 m20, m21, m22, m23,
+                                 m30, m31, m32, m33);
+    }
+
+    public static Matrix4#E# fromDiagonal(#e# m00, #e# m11, #e# m22, #e# m33) {
+         return m00 == 0 && m11 == 0 && m22 == 0 && m33 == 0 ? ZERO : new Matrix4#E#(m00, 0, 0, 0,
+                                                                                     0, m11, 0, 0,
+                                                                                     0, 0, m22, 0,
+                                                                                     0, 0, 0, m33);
+    }
+
     public static Matrix4#E# createScaling(#EOverload# scale) {
         return createScaling((#e#) scale);
     }

src/main/template/float/com/flowpowered/math/vector/Vector2_E_.template

@@ -378,6 +378,14 @@ public class Vector2#E# implements Vector#E#, Comparable<Vector2#E#>, Serializab
         return "(" + x + ", " + y + ")";
     }
 
+    public static Vector2#E# from(#e# n) {
+         return n == 0 ? ZERO : new Vector2#E#(n, n);
+    }
+
+    public static Vector2#E# from(#e# x, #e# y) {
+         return x == 0 && y == 0 ? ZERO : new Vector2#E#(x, y);
+    }
+
     /**
      * Gets the direction vector of a random angle using the random specified.
      *

src/main/template/float/com/flowpowered/math/vector/Vector3_E_.template

@@ -412,6 +412,14 @@ public class Vector3#E# implements Vector#E#, Comparable<Vector3#E#>, Serializab
         return "(" + x + ", " + y + ", " + z + ")";
     }
 
+    public static Vector3#E# from(#e# n) {
+         return n == 0 ? ZERO : new Vector3#E#(n, n, n);
+    }
+
+    public static Vector3#E# from(#e# x, #e# y, #e# z) {
+         return x == 0 && y == 0 && z == 0 ? ZERO : new Vector3#E#(x, y, z);
+    }
+
     /**
      * Gets the direction vector of a random pitch and yaw using the random specified.
      *

src/main/template/float/com/flowpowered/math/vector/Vector4_E_.template

@@ -432,4 +432,12 @@ public class Vector4#E# implements Vector#E#, Comparable<Vector4#E#>, Serializab
     public String toString() {
         return "(" + x + ", " + y + ", " + z + ", " + w + ")";
     }
+
+    public static Vector4#E# from(#e# n) {
+         return n == 0 ? ZERO : new Vector4#E#(n, n, n, n);
+    }
+
+    public static Vector4#E# from(#e# x, #e# y, #e# z, #e# w) {
+         return x == 0 && y == 0 && z == 0 && w == 0 ? ZERO : new Vector4#E#(x, y, z, w);
+    }
 }

src/main/template/integer/com/flowpowered/math/vector/Vector2_E_.template

@@ -342,4 +342,12 @@ public class Vector2#E# implements Vector#E#, Comparable<Vector2#E#>, Serializab
     public String toString() {
         return "(" + x + ", " + y + ")";
     }
+
+    public static Vector2#E# from(#e# n) {
+         return n == 0 ? ZERO : new Vector2#E#(n, n);
+    }
+
+    public static Vector2#E# from(#e# x, #e# y) {
+         return x == 0 && y == 0 ? ZERO : new Vector2#E#(x, y);
+    }
 }

src/main/template/integer/com/flowpowered/math/vector/Vector3_E_.template

@@ -373,4 +373,12 @@ public class Vector3#E# implements Vector#E#, Comparable<Vector3#E#>, Serializab
     public String toString() {
         return "(" + x + ", " + y + ", " + z + ")";
     }
+
+    public static Vector3#E# from(#e# n) {
+         return n == 0 ? ZERO : new Vector3#E#(n, n, n);
+    }
+
+    public static Vector3#E# from(#e# x, #e# y, #e# z) {
+         return x == 0 && y == 0 && z == 0 ? ZERO : new Vector3#E#(x, y, z);
+    }
 }