Added scala test

Author: HexagonNico

build.sbt

@@ -7,3 +7,6 @@ libraryDependencies += "io.github.hexagonnico" % "vecmatlib" % "2.2"
 lazy val root = (project in file(".")).settings(
   name := "CmplxLib"
 )
+
+// Scala test dependency
+libraryDependencies += "org.scalatest" %% "scalatest" % "3.2.15" % Test

src/main/scala/io/github/hexagonnico/cmplxlib/Complex.scala

@@ -146,20 +146,20 @@ case class Complex(a: Double, b: Double) extends Double2 {
   /**
    * Returns the product between this complex number and the given real number.
    *
-   * @param k The real number to multiply
+   * @param r The real number to multiply
    * @return The product between this complex number and the given real number
    */
-  def *(k: Double): Complex = Complex(this.a * k, this.b * k)
+  def *(r: Double): Complex = Complex(this.a * r, this.b * r)
 
   /**
    * Returns the product between this complex number and the given real number.
    *
    * This method can be used in place of the '*' operator for better interoperability with Java.
    *
-   * @param k The real number to multiply
+   * @param r The real number to multiply
    * @return The product between this complex number and the given real number
    */
-  def multiply(k: Double): Complex = this * k
+  def multiply(r: Double): Complex = this * r
 
   /**
    * Returns the product between this complex number and the number `a + ib`.
@@ -202,20 +202,20 @@ case class Complex(a: Double, b: Double) extends Double2 {
   /**
    * Returns the result of the division between this complex number and the given real number.
    *
-   * @param k The real number by which this complex number is divided
+   * @param r The real number by which this complex number is divided
    * @return The result of the division between this complex number and the given real number
    */
-  def /(k: Double): Complex = Complex(this.a / k, this.b / k)
+  def /(r: Double): Complex = Complex(this.a / r, this.b / r)
 
   /**
    * Returns the result of the division between this complex number and the given real number.
    *
    * This method can be used in place of the '/' operator for better interoperability with Java.
    *
-   * @param k The real number by which this complex number is divided
+   * @param r The real number by which this complex number is divided
    * @return The result of the division between this complex number and the given real number
    */
-  def divide(k: Double): Complex = this / k
+  def divide(r: Double): Complex = this / r
 
   /**
    * Returns the complex conjugate of this complex number.
@@ -328,12 +328,16 @@ case class Complex(a: Double, b: Double) extends Double2 {
    * @return A string representation of this complex number
    */
   override def toString: String = {
-    if(this.a == 0.0 && this.b == 0.0) {
+    if (this.a == 0.0 && this.b == 0.0) {
       "0.0"
-    } else if(this.b == 0.0) {
+    } else if (this.b == 0.0) {
       this.a.toString
-    } else if(this.a == 0.0) {
-      f"${b}i"
+    } else if (this.a == 0.0) {
+      if (this.b == 1.0) {
+        "i"
+      } else {
+        f"${b}i"
+      }
     } else {
       f"$a ${if(b > 0.0) "+" else "-"} ${b.abs}i"
     }

src/test/scala/io/github/hexagonnico/cmplxlib/ComplexSuite.scala

@@ -0,0 +1,149 @@
+package io.github.hexagonnico.cmplxlib
+
+import org.scalatest.funsuite.AnyFunSuite
+
+class ComplexSuite extends AnyFunSuite {
+
+  test("Sum of a complex number and two real numbers") {
+    val z = Complex(2.0, 1.0)
+    val res = z + (1.5, 2.0)
+    assert(res == Complex(3.5, 3.0))
+  }
+
+  test("Sum of a complex number and a real number") {
+    val z = Complex(2.0, 1.0)
+    val res = z + 1.5
+    assert(res == Complex(3.5, 1.0))
+  }
+
+  test("Sum of a real number and a complex number") {
+    val z = Complex(2.0, 1.0)
+    val res = 1.5 + z
+    assert(res == Complex(3.5, 1.0))
+  }
+
+  test("Sum of two complex numbers") {
+    val z = Complex(2.0, 1.0)
+    val w = Complex(1.5, 2.0)
+    assert(z + w == Complex(3.5, 3.0))
+  }
+
+  test("Additive inverse") {
+    val z = Complex(2.0, 1.0)
+    assert(-z == Complex(-2.0, -1.0))
+  }
+
+  test("Subtraction of two real numbers from a complex number") {
+    val z = Complex(2.0, 1.0)
+    val res = z - (1.5, 2.0)
+    assert(res == Complex(0.5, -1.0))
+  }
+
+  test("Subtraction of a real number from a complex number") {
+    val z = Complex(2.0, 1.0)
+    val res = z - 1.5
+    assert(res == Complex(0.5, 1.0))
+  }
+
+  test("Subtraction of a complex number from a real number") {
+    val z = Complex(2.0, 1.0)
+    val res = 1.5 - z
+    assert(res == Complex(-0.5, -1.0))
+  }
+
+  test("Subtraction of two complex numbers") {
+    val z = Complex(2.0, 1.0)
+    val w = Complex(1.5, 2.0)
+    assert(z - w == Complex(0.5, -1.0))
+  }
+
+  test("Product between a complex number and a real number") {
+    val z = Complex(2.0, 1.0)
+    val res = z * 1.5
+    assert(res == Complex(3.0, 1.5))
+  }
+
+  test("Product between a real number and a complex number") {
+    val z = Complex(2.0, 1.0)
+    val res = 1.5 * z
+    assert(res == Complex(3.0, 1.5))
+  }
+
+  test("Product between a complex number and two real numbers") {
+    val z = Complex(2.0, 1.0)
+    val res = z * (1.5, 2.0)
+    assert(res == Complex(1.0, 5.5))
+  }
+
+  test("Product between two complex numbers") {
+    val z = Complex(2.0, 1.0)
+    val w = Complex(1.5, 2.0)
+    assert(z * w == Complex(1.0, 5.5))
+  }
+
+  test("Complex number divided by a real number") {
+    val z = Complex(2.0, 1.0)
+    val res = z / 2.0
+    assert(res == Complex(1.0, 0.5))
+  }
+
+  test("Conjugate of a complex number") {
+    val z = Complex(2.0, 1.0)
+    assert(z.conjugate == Complex(2.0, -1.0))
+  }
+
+  test("Modulus of a complex number") {
+    val z = Complex(1.0, 1.0)
+    assert(z.abs == math.sqrt(2.0))
+  }
+
+  test("Reciprocal of a complex number") {
+    val z = Complex(2.0, 1.0)
+    assert(z.reciprocal == Complex(0.4, -0.2))
+  }
+
+  test("Complex number divided by a complex number") {
+    val z = Complex(2.0, 2.0)
+    val w = Complex(3.0, 2.0)
+    assert(w / z == Complex(1.25, -0.25))
+  }
+
+  test("Complex number divided by two real numbers") {
+    val z = Complex(3.0, 2.0)
+    val res = z / (2.0, 2.0)
+    assert(res == Complex(1.25, -0.25))
+  }
+
+  test("Argument of a complex number") {
+    val z = Complex(4.0, 2.0)
+    assert(z.arg == math.atan(0.5))
+  }
+
+  test("Real and imaginary part of a complex number") {
+    val z = Complex(3.0, 2.0)
+    assert(z.real == 3.0)
+    assert(z.imaginary == 2.0)
+  }
+
+  test("Complex number to string") {
+    val z = Complex(3.0, 2.0)
+    assert(z.toString == "3.0 + 2.0i")
+  }
+
+  test("Real number to string") {
+    assert(Complex.One.toString == "1.0")
+  }
+
+  test("Imaginary unit to string") {
+    assert(Complex.I.toString == "i")
+  }
+
+  test("Imaginary number to string") {
+    val z = Complex(0.0, 2.0)
+    assert(z.toString == "2.0i")
+  }
+
+  test("Zero to string") {
+    assert(Complex.Zero.toString == "0.0")
+  }
+}

src/test/scala/io/github/hexagonnico/cmplxlib/vector/Vec2cSuite.scala

@@ -0,0 +1,125 @@
+package io.github.hexagonnico.cmplxlib.vector
+
+import io.github.hexagonnico.cmplxlib.Complex
+import org.scalactic.Tolerance.convertNumericToPlusOrMinusWrapper
+import org.scalatest.funsuite.AnyFunSuite
+
+class Vec2cSuite extends AnyFunSuite {
+
+  test("Sum of a vector and two values") {
+    val vec = Vec2c(Complex(1.0, 2.0), Complex(1.5, 1.0))
+    val res = vec + (Complex(2.0, 2.5), Complex(3.0, 0.5))
+    assert(res == Vec2c(Complex(3.0, 4.5), Complex(4.5, 1.5)))
+  }
+
+  test("Sum of two vectors") {
+    val a = Vec2c(Complex(1.0, 2.0), Complex(1.5, 1.0))
+    val b = Vec2c(Complex(2.0, 2.5), Complex(3.0, 0.5))
+    assert(a + b == Vec2c(Complex(3.0, 4.5), Complex(4.5, 1.5)))
+  }
+
+  test("Additive inverse") {
+    val a = Vec2c(Complex(1.0, 2.0), Complex(1.5, 1.0))
+    assert(-a == Vec2c(Complex(-1.0, -2.0), Complex(-1.5, -1.0)))
+  }
+
+  test("Subtraction of two values from a vector") {
+    val vec = Vec2c(Complex(1.0, 2.0), Complex(1.5, 1.0))
+    val res = vec - (Complex(2.0, 2.5), Complex(3.0, 0.5))
+    assert(res == Vec2c(Complex(-1.0, -0.5), Complex(-1.5, 0.5)))
+  }
+
+  test("Subtraction of two vectors") {
+    val a = Vec2c(Complex(1.0, 2.0), Complex(1.5, 1.0))
+    val b = Vec2c(Complex(2.0, 2.5), Complex(3.0, 0.5))
+    assert(a - b == Vec2c(Complex(-1.0, -0.5), Complex(-1.5, 0.5)))
+  }
+
+  test("Vector multiplied by a scalar") {
+    val vec = Vec2c(Complex(1.0, 2.0), Complex(1.5, 1.0))
+    val res = vec * 1.5
+    assert(res == Vec2c(Complex(1.5, 3.0), Complex(2.25, 1.5)))
+  }
+
+  test("Vector multiplied by a scalar commutativity") {
+    val vec = Vec2c(Complex(1.0, 2.0), Complex(1.5, 1.0))
+    val res = 1.5 * vec
+    assert(res == Vec2c(Complex(1.5, 3.0), Complex(2.25, 1.5)))
+  }
+
+  test("Vector divided by a scalar") {
+    val vec = Vec2c(Complex(1.0, 2.0), Complex(1.5, 1.0))
+    val res = vec / 2.0
+    assert(res == Vec2c(Complex(0.5, 1.0), Complex(0.75, 0.5)))
+  }
+
+  test("Component-wise multiplication of a vector and two values") {
+    val vec = Vec2c(Complex(1.0, 2.0), Complex(1.5, 1.0))
+    val res = vec * (Complex(2.0, 2.5), Complex(3.0, 0.5))
+    assert(res == Vec2c(Complex(-3.0, 6.5), Complex(4.0, 3.75)))
+  }
+
+  test("Component-wise multiplication of two vectors") {
+    val a = Vec2c(Complex(1.0, 2.0), Complex(1.5, 1.0))
+    val b = Vec2c(Complex(2.0, 2.5), Complex(3.0, 0.5))
+    assert(a * b == Vec2c(Complex(-3.0, 6.5), Complex(4.0, 3.75)))
+  }
+
+  test("Dot product with two values") {
+    val vec = Vec2c(Complex(1.0, 2.0), Complex(1.5, 1.0))
+    val res = vec.dot(Complex(2.0, 2.5), Complex(3.0, 0.5))
+    assert(res == Complex(12.0, 3.75))
+  }
+
+  test("Dot product of two vectors") {
+    val a = Vec2c(Complex(1.0, 2.0), Complex(1.5, 1.0))
+    val b = Vec2c(Complex(2.0, 2.5), Complex(3.0, 0.5))
+    assert((a dot b) == Complex(12.0, 3.75))
+  }
+
+  test("Length squared") {
+    assert(Vec2c(Complex(1.0, 1.0), Complex(1.0, 1.0)).lengthSquared == 4.0)
+  }
+
+  test("Length") {
+    assert(Vec2c(Complex(1.0, 1.0), Complex(1.0, 1.0)).length == 2.0)
+  }
+
+  test("Normalized vector") {
+    val vec = Vec2c(Complex(1.0, 1.0), Complex(1.0, 1.0))
+    assert(vec.normalized == Vec2c(Complex(0.5, 0.5), Complex(0.5, 0.5)))
+  }
+
+  test("Angle between two vectors") {
+    val a = Vec2c(Complex(1.0, 1.0), Complex(2.0, 1.0))
+    val b = Vec2c(Complex(2.0, 1.0), Complex(1.0, 1.0))
+    assert(a.angle(b) === math.acos(6.0 / 7.0) +- 1e-9)
+  }
+
+  test("Conjugate of a vector") {
+    val vec = Vec2c(Complex(2.0, 4.0), Complex(8.0, 6.0))
+    assert(vec.conjugate == Vec2c(Complex(2.0, -4.0), Complex(8.0, -6.0)))
+  }
+
+  test("Reciprocal of a vector") {
+    val vec = Vec2c(Complex(2.0, 4.0), Complex(8.0, 6.0))
+    assert(vec.reciprocal == Vec2c(Complex(0.1, -0.2), Complex(0.08, -0.06)))
+  }
+
+  test("Component-wise division of two vectors") {
+    val a = Vec2c(Complex(8.0, 6.0), Complex(6.0, 8.0))
+    val b = Vec2c(Complex(2.0, 2.0), Complex(4.0, 2.0))
+    assert(a / b == Vec2c(Complex(3.5, -0.5), Complex(2.0, 1.0)))
+  }
+
+  test("Component-wise division of a vector and two values") {
+    val vec = Vec2c(Complex(8.0, 6.0), Complex(6.0, 8.0))
+    val res = vec / (Complex(2.0, 2.0), Complex(4.0, 2.0))
+    assert(res == Vec2c(Complex(3.5, -0.5), Complex(2.0, 1.0)))
+  }
+
+  test("Vector absolute value") {
+    val vec = Vec2c(Complex(1.0, 1.0), Complex(1.0, 1.0))
+    assert(vec.abs == Vec2c(Complex(math.sqrt(2.0), 0.0), Complex(math.sqrt(2.0), 0.0)))
+  }
+}