I think quaternions are finished now

Author: HexagonNico

src/main/scala/io/github/hexagonnico/vecmatlib/quaternion/Quaternion.scala

@@ -1,13 +1,13 @@
 package io.github.hexagonnico.vecmatlib.quaternion
 
-import io.github.hexagonnico.vecmatlib.vector.Vec3d
+import io.github.hexagonnico.vecmatlib.vector.VecAbstract
 
 /**
  * Abstract class with quaternion operations.
  *
  * @tparam Q The quaternion class extending this one
  */
-abstract class Quaternion[Q <: Quaternion[Q]] {
+abstract class Quaternion[Q <: Quaternion[Q, V], V <: VecAbstract[V]] {
 
   /**
    * Returns the sum between this quaternion and the given one.
@@ -103,29 +103,29 @@ abstract class Quaternion[Q <: Quaternion[Q]] {
   def normalized: Q
 
   /**
-   * Returns the multiplicative inverse (or the reciprocal) of this quaternion.
+   * Returns the multiplicative inverse of this quaternion.
    *
    * The same quaternion can be obtained with `1.0 / q`.
    *
-   * @return The reciprocal of this quaternion
+   * @return The inverse of this quaternion
    */
-  def reciprocal: Q
+  def inverse: Q
 
   /**
-   * Returns the product of this quaternion by the [[reciprocal]] of the given one.
+   * Returns the product of this quaternion by the [[inverse]] of the given one.
    *
    * @param q The second operand of the division
-   * @return The product of this quaternion by the reciprocal of the given one
+   * @return The product of this quaternion by the inverse of the given one
    */
-  def /(q: Q): Q = this * q.reciprocal
+  def /(q: Q): Q = this * q.inverse
 
   /**
-   * Returns the product of this quaternion by the [[reciprocal]] of the given one.
+   * Returns the product of this quaternion by the [[inverse]] of the given one.
    *
    * This method can be used in place of the '/' operator for better interoperability with Java.
    *
    * @param q The second operand of the division
-   * @return The product of this quaternion by the reciprocal of the given one
+   * @return The product of this quaternion by the inverse of the given one
    */
   def divide(q: Q): Q = this / q
 
@@ -150,7 +150,7 @@ abstract class Quaternion[Q <: Quaternion[Q]] {
    *
    * @return This quaternion's rotation in the form of euler angles
    */
-  def euler: Vec3d
+  def euler: V
 
   /**
    * Returns the angle of the rotation represented by this unit quaternion.
@@ -162,11 +162,14 @@ abstract class Quaternion[Q <: Quaternion[Q]] {
   def angle: Double
 
   /**
-   * Returns the axis this quaternion is rotating around.
+   * Returns the vector part of this quaternion.
+   * The vector part of a quaternion `w + xi + yj + zk` is the vector `(x, y, z)`.
    *
-   * @return The axis this quaternion is rotating around
+   * Normalize this vector to get the rotation axis of the quaternion.
+   *
+   * @return
    */
-  def axis: Vec3d
+  def vector: V
 
   /**
    * Returns that is, this quaternion divided by its norm or [[length]].

src/main/scala/io/github/hexagonnico/vecmatlib/quaternion/QuaternionD.scala

@@ -12,7 +12,7 @@ import io.github.hexagonnico.vecmatlib.vector.Vec3d
  * @param y The second component of the vector part (imaginary 'j' axis)
  * @param z The third component of the vector part (imaginary 'k' axis)
  */
-case class QuaternionD(w: Double, x: Double, y: Double, z: Double) extends Quaternion[QuaternionD] with Double4 {
+case class QuaternionD(w: Double, x: Double, y: Double, z: Double) extends Quaternion[QuaternionD, Vec3d] with Double4 {
 
   /**
    * Constructs a quaternion from the given scalar part and the given vector part
@@ -208,35 +208,35 @@ case class QuaternionD(w: Double, x: Double, y: Double, z: Double) extends Quate
   override def normalized: QuaternionD = this / this.length
 
   /**
-   * Returns the multiplicative inverse (or the reciprocal) of this quaternion.
+   * Returns the multiplicative inverse of this quaternion.
    *
    * The same quaternion can be obtained with `1.0 / q`.
    *
-   * @return The reciprocal of this quaternion
+   * @return The inverse of this quaternion
    */
-  override def reciprocal: QuaternionD = this.conjugate / this.lengthSquared
+  override def inverse: QuaternionD = this.conjugate / this.lengthSquared
 
   /**
-   * Returns the product of this quaternion by the [[reciprocal]] of the quaternion `w + xi + yj + zk`.
+   * Returns the product of this quaternion by the [[inverse]] of the quaternion `w + xi + yj + zk`.
    *
    * @param w The real/scalar part of the second operand of the division
    * @param x The first component of the vector part of the second operand of the division
    * @param y The second component of the vector part of the second operand of the division
    * @param z The third component of the vector part of the second operand of the division
-   * @return The product of this quaternion by the reciprocal of the quaternion `w + xi + yj + zk`
+   * @return The product of this quaternion by the inverse of the quaternion `w + xi + yj + zk`
    */
   def /(w: Double, x: Double, y: Double, z: Double): QuaternionD = this / QuaternionD(w, x, y, z)
 
   /**
-   * Returns the product of this quaternion by the [[reciprocal]] of the quaternion `w + xi + yj + zk`.
+   * Returns the product of this quaternion by the [[inverse]] of the quaternion `w + xi + yj + zk`.
    *
    * This method can be used in place of the '/' operator for better interoperability with Java.
    *
    * @param w The real/scalar part of the second operand of the division
    * @param x The first component of the vector part of the second operand of the division
    * @param y The second component of the vector part of the second operand of the division
    * @param z The third component of the vector part of the second operand of the division
-   * @return The product of this quaternion by the reciprocal of the quaternion `w + xi + yj + zk`
+   * @return The product of this quaternion by the inverse of the quaternion `w + xi + yj + zk`
    */
   def divide(w: Double, x: Double, y: Double, z: Double): QuaternionD = this / (w, x, y, z)
 
@@ -285,14 +285,14 @@ case class QuaternionD(w: Double, x: Double, y: Double, z: Double) extends Quate
   override def angle: Double = 2.0 * math.acos(this.w)
 
   /**
-   * Returns the axis this quaternion is rotating around.
+   * Returns the vector part of this quaternion.
+   * The vector part of a quaternion `w + xi + yj + zk` is the vector `(x, y, z)`.
    *
-   * @return The axis this quaternion is rotating around
+   * Normalize this vector to get the rotation axis of the quaternion.
+   *
+   * @return
    */
-  override def axis: Vec3d = {
-    val r = 1.0 / math.sqrt(1.0 - w * w)
-    Vec3d(x * r, y * r, z * r)
-  }
+  override def vector: Vec3d = Vec3d(this.x, this.y, this.z)
 
   /**
    * Returns that is, this quaternion divided by its norm or [[length]].
@@ -447,11 +447,11 @@ object QuaternionD {
     def *(q: QuaternionD): QuaternionD = q * l
 
     /**
-     * Returns the product between this scalar and the [[Quaternion.reciprocal]] of the given quaternion.
+     * Returns the product between this scalar and the [[Quaternion.inverse]] of the given quaternion.
      *
      * @param q The second operand of the division
-     * @return The product of this scalar by the reciprocal of the given quaternion
+     * @return The product of this scalar by the inverse of the given quaternion
      */
-    def /(q: QuaternionD): QuaternionD = l * q.reciprocal
+    def /(q: QuaternionD): QuaternionD = l * q.inverse
   }
 }

src/main/scala/io/github/hexagonnico/vecmatlib/quaternion/QuaternionF.scala

@@ -12,7 +12,7 @@ import io.github.hexagonnico.vecmatlib.vector.{Vec3d, Vec3f}
  * @param y The second component of the vector part (imaginary 'j' axis)
  * @param z The third component of the vector part (imaginary 'k' axis)
  */
-case class QuaternionF(w: Float, x: Float, y: Float, z: Float) extends Quaternion[QuaternionF] with Float4 {
+case class QuaternionF(w: Float, x: Float, y: Float, z: Float) extends Quaternion[QuaternionF, Vec3f] with Float4 {
 
   /**
    * Constructs a quaternion from the given scalar part and the given vector part
@@ -208,35 +208,35 @@ case class QuaternionF(w: Float, x: Float, y: Float, z: Float) extends Quaternio
   override def normalized: QuaternionF = this / this.length.toFloat
 
   /**
-   * Returns the multiplicative inverse (or the reciprocal) of this quaternion.
+   * Returns the multiplicative inverse of this quaternion.
    *
    * The same quaternion can be obtained with `1.0 / q`.
    *
-   * @return The reciprocal of this quaternion
+   * @return The inverse of this quaternion
    */
-  override def reciprocal: QuaternionF = this.conjugate / this.lengthSquared
+  override def inverse: QuaternionF = this.conjugate / this.lengthSquared
 
   /**
-   * Returns the product of this quaternion by the [[reciprocal]] of the quaternion `w + xi + yj + zk`.
+   * Returns the product of this quaternion by the [[inverse]] of the quaternion `w + xi + yj + zk`.
    *
    * @param w The real/scalar part of the second operand of the division
    * @param x The first component of the vector part of the second operand of the division
    * @param y The second component of the vector part of the second operand of the division
    * @param z The third component of the vector part of the second operand of the division
-   * @return The product of this quaternion by the reciprocal of the quaternion `w + xi + yj + zk`
+   * @return The product of this quaternion by the inverse of the quaternion `w + xi + yj + zk`
    */
   def /(w: Float, x: Float, y: Float, z: Float): QuaternionF = this / QuaternionF(w, x, y, z)
 
   /**
-   * Returns the product of this quaternion by the [[reciprocal]] of the quaternion `w + xi + yj + zk`.
+   * Returns the product of this quaternion by the [[inverse]] of the quaternion `w + xi + yj + zk`.
    *
    * This method can be used in place of the '/' operator for better interoperability with Java.
    *
    * @param w The real/scalar part of the second operand of the division
    * @param x The first component of the vector part of the second operand of the division
    * @param y The second component of the vector part of the second operand of the division
    * @param z The third component of the vector part of the second operand of the division
-   * @return The product of this quaternion by the reciprocal of the quaternion `w + xi + yj + zk`
+   * @return The product of this quaternion by the inverse of the quaternion `w + xi + yj + zk`
    */
   def divide(w: Float, x: Float, y: Float, z: Float): QuaternionF = this / (w, x, y, z)
 
@@ -245,22 +245,14 @@ case class QuaternionF(w: Float, x: Float, y: Float, z: Float) extends Quaternio
    *
    * @return The exponential of this quaternion
    */
-  override def exp: QuaternionF = {
-    val v = Vec3d(this.x, this.y, this.z)
-    val length = v.length
-    (QuaternionD(math.cos(length), v / v.length * math.sin(length)) * math.exp(this.w)).toFloat
-  }
+  override def exp: QuaternionF = this.toDouble.exp.toFloat
 
   /**
    * Returns the logarithm of this quaternion.
    *
    * @return The logarithm of this quaternion
    */
-  override def log: QuaternionF = {
-    val v = Vec3d(this.x, this.y, this.z)
-    val length = this.length
-    QuaternionD(math.log(length), v.normalized * math.acos(this.w / length)).toFloat
-  }
+  override def log: QuaternionF = this.toDouble.log.toFloat
 
   /**
    * Returns this quaternion's rotation in the form of euler angles.
@@ -269,11 +261,7 @@ case class QuaternionF(w: Float, x: Float, y: Float, z: Float) extends Quaternio
    *
    * @return This quaternion's rotation in the form of euler angles
    */
-  override def euler: Vec3d = Vec3d(
-    math.atan2(2.0 * (w * x + y * z), 1.0 - 2.0 * (x * x + y * y)),
-    2.0 * math.atan2(1.0 + 2.0 * (w * y - x * z), 1.0 - 2.0 * (w * y - x * z)) - math.Pi / 2.0,
-    math.atan2(2.0 * (w * z + x * y), 1.0 - 2.0 * (y * y + z * z))
-  )
+  override def euler: Vec3f = this.toDouble.euler.toFloat
 
   /**
    * Returns the angle of the rotation represented by this unit quaternion.
@@ -285,25 +273,21 @@ case class QuaternionF(w: Float, x: Float, y: Float, z: Float) extends Quaternio
   override def angle: Double = 2.0 * math.acos(this.w)
 
   /**
-   * Returns the axis this quaternion is rotating around.
+   * Returns the vector part of this quaternion.
+   * The vector part of a quaternion `w + xi + yj + zk` is the vector `(x, y, z)`.
    *
-   * @return The axis this quaternion is rotating around
+   * Normalize this vector to get the rotation axis of the quaternion.
+   *
+   * @return
    */
-  override def axis: Vec3d = {
-    val r = 1.0f / math.sqrt(1.0 - w * w)
-    Vec3d(x * r, y * r, z * r)
-  }
+  override def vector: Vec3f = Vec3f(this.x, this.y, this.z)
 
   /**
    * Returns that is, this quaternion divided by its norm or [[length]].
    *
    * @return A unit quaternion
    */
-  override def slerp(to: QuaternionF, weight: Double): QuaternionF = {
-    val omega = math.acos(this dot to)
-    val sinOmega = math.sin(omega)
-    (this.toDouble * (math.sin((1.0 - weight) * omega) / sinOmega) + to.toDouble * (math.sin(weight * omega) / sinOmega)).toFloat
-  }
+  override def slerp(to: QuaternionF, weight: Double): QuaternionF = this.toDouble.slerp(to.toDouble, weight).toFloat
 
   /**
    * Converts this quaternion to a double quaternion.
@@ -475,11 +459,11 @@ object QuaternionF {
     def *(q: QuaternionF): QuaternionF = q * l
 
     /**
-     * Returns the product between this scalar and the [[Quaternion.reciprocal]] of the given quaternion.
+     * Returns the product between this scalar and the [[Quaternion.inverse]] of the given quaternion.
      *
      * @param q The second operand of the division
-     * @return The product of this scalar by the reciprocal of the given quaternion
+     * @return The product of this scalar by the inverse of the given quaternion
      */
-    def /(q: QuaternionF): QuaternionF = l * q.reciprocal
+    def /(q: QuaternionF): QuaternionF = l * q.inverse
   }
 }

src/test/java/io/github/hexagonnico/vecmatlib/quaternion/TestQuaternionD.java

@@ -60,22 +60,22 @@ public void testMultiplyQuaternion() {
 
     @Test
     public void testDivideByScalar() {
-        QuaternionD q = new QuaternionD(1.2, 1.4, -2.1, 3.0);
-        assertEqualApprox(q.dividedBy(1.2), 1.0, 1.16666666667, -1.75, 2.5);
+        QuaternionD q = new QuaternionD(1.5, 2.0, -2.5, 3.0);
+        assertEqualApprox(q.dividedBy(2.0), 0.75, 1.0, -1.25, 1.5);
     }
 
     @Test
     public void testDivideQuaternion() {
-        QuaternionD q = new QuaternionD(1.2, 1.4, -2.1, 3.0);
-        QuaternionD p = new QuaternionD(0.3, -1.5, 1.1, 0.0);
-        assertEqualApprox(q.divide(p), -1.1408450704225355, 1.5549295774647889, 0.7183098591549296, 0.7070422535211269);
+        QuaternionD q = new QuaternionD(1.0, 1.0, 1.0, 1.0);
+        QuaternionD p = new QuaternionD(1.0, 0.0, 1.0, 0.0);
+        assertEqualApprox(q.divide(p), 1.0, 1.0, 0.0, 0.0);
     }
 
     @Test
     public void testDivideFourValues() {
-        QuaternionD q = new QuaternionD(1.2, 1.4, -2.1, 3.0);
-        QuaternionD p = q.divide(0.3, -1.5, 1.1, 0.0);
-        assertEqualApprox(p, -1.1408450704225355, 1.5549295774647889, 0.7183098591549296, 0.7070422535211269);
+        QuaternionD q = new QuaternionD(1.0, 1.0, 1.0, 1.0);
+        QuaternionD p = q.divide(1.0, 0.0, 1.0, 0.0);
+        assertEqualApprox(p, 1.0, 1.0, 0.0, 0.0);
     }
 
     @Test
@@ -85,9 +85,9 @@ public void testEqualsFourValues() {
     }
 
     private static void assertEqualApprox(QuaternionD a, double w, double x, double y, double z) {
-        Assert.assertTrue(Math.abs(a.w() - w) < 1e-9);
-        Assert.assertTrue(Math.abs(a.x() - x) < 1e-9);
-        Assert.assertTrue(Math.abs(a.y() - y) < 1e-9);
-        Assert.assertTrue(Math.abs(a.z() - z) < 1e-9);
+        Assert.assertTrue(Math.abs(a.w() - w) < 1e-6);
+        Assert.assertTrue(Math.abs(a.x() - x) < 1e-6);
+        Assert.assertTrue(Math.abs(a.y() - y) < 1e-6);
+        Assert.assertTrue(Math.abs(a.z() - z) < 1e-6);
     }
 }

src/test/java/io/github/hexagonnico/vecmatlib/quaternion/TestQuaternionF.java

@@ -60,22 +60,22 @@ public void testMultiplyQuaternion() {
 
     @Test
     public void testDivideByScalar() {
-        QuaternionF q = new QuaternionF(1.2f, 1.4f, -2.1f, 3.0f);
-        assertEqualApprox(q.dividedBy(1.2f), 1.0f, 1.16666666667f, -1.75f, 2.5f);
+        QuaternionF q = new QuaternionF(1.5f, 2.0f, -2.5f, 3.0f);
+        assertEqualApprox(q.dividedBy(2.0f), 0.75f, 1.0f, -1.25f, 1.5f);
     }
 
     @Test
     public void testDivideQuaternion() {
-        QuaternionF q = new QuaternionF(1.2f, 1.4f, -2.1f, 3.0f);
-        QuaternionF p = new QuaternionF(0.3f, -1.5f, 1.1f, 0.0f);
-        assertEqualApprox(q.divide(p), -1.1408450704225355f, 1.5549295774647889f, 0.7183098591549296f, 0.7070422535211269f);
+        QuaternionF q = new QuaternionF(1.0f, 1.0f, 1.0f, 1.0f);
+        QuaternionF p = new QuaternionF(1.0f, 0.0f, 1.0f, 0.0f);
+        assertEqualApprox(q.divide(p), 1.0f, 1.0f, 0.0f, 0.0f);
     }
 
     @Test
     public void testDivideFourValues() {
-        QuaternionF q = new QuaternionF(1.2f, 1.4f, -2.1f, 3.0f);
-        QuaternionF p = q.divide(0.3f, -1.5f, 1.1f, 0.0f);
-        assertEqualApprox(p, -1.1408450704225355f, 1.5549295774647889f, 0.7183098591549296f, 0.7070422535211269f);
+        QuaternionF q = new QuaternionF(1.0f, 1.0f, 1.0f, 1.0f);
+        QuaternionF p = q.divide(1.0f, 0.0f, 1.0f, 0.0f);
+        assertEqualApprox(p, 1.0f, 1.0f, 0.0f, 0.0f);
     }
 
     @Test