Added component-wise division

Author: HexagonNico

src/main/scala/vecmatlib/vector/Vec2d.scala

@@ -135,6 +135,33 @@ case class Vec2d(x: Double, y: Double) extends VecDouble[Vec2d] with Double2 {
    */
   def angle(x: Double, y: Double): Double = this.angle(Vec2d(x, y))
 
+  /**
+   * Returns a vector whose components are the multiplicative inverse of this vectors components.
+   *
+   * @return A vector whose components are the multiplicative inverse of this vectors components
+   */
+  override def inverse: Vec2d = Vec2d(1.0 / this.x, 1.0 / this.y)
+
+  /**
+   * Returns the component-wise division between this vector and the given scalars.
+   *
+   * @param x Value by which the X component is divided
+   * @param y Value by which the Y component is divided
+   * @return The component-wise division between this vector and the given scalars.
+   */
+  def /(x: Double, y: Double): Vec2d = Vec2d(this.x / x, this.y / y)
+
+  /**
+   * Returns the component-wise division between this vector and the given scalars.
+   *
+   * This method can be used in place of the '/' operator for better interoperability with Java.
+   *
+   * @param x Value by which the X component is divided
+   * @param y Value by which the Y component is divided
+   * @return The component-wise division between this vector and the given scalars.
+   */
+  def divide(x: Double, y: Double): Vec2d = this / (x, y)
+
   /**
    * Returns a vector with all components in absolute value.
    *

src/main/scala/vecmatlib/vector/Vec2f.scala

@@ -135,6 +135,33 @@ case class Vec2f(x: Float, y: Float) extends VecFloat[Vec2f] with Float2 {
    */
   def angle(x: Double, y: Double): Double = this.toDouble.angle(Vec2d(x, y))
 
+  /**
+   * Returns a vector whose components are the multiplicative inverse of this vectors components.
+   *
+   * @return A vector whose components are the multiplicative inverse of this vectors components
+   */
+  override def inverse: Vec2f = Vec2f(1.0f / this.x, 1.0f / this.y)
+
+  /**
+   * Returns the component-wise division between this vector and the given scalars.
+   *
+   * @param x Value by which the X component is divided
+   * @param y Value by which the Y component is divided
+   * @return The component-wise division between this vector and the given scalars.
+   */
+  def /(x: Float, y: Float): Vec2f = Vec2f(this.x / x, this.y / y)
+
+  /**
+   * Returns the component-wise division between this vector and the given scalars.
+   *
+   * This method can be used in place of the '/' operator for better interoperability with Java.
+   *
+   * @param x Value by which the X component is divided
+   * @param y Value by which the Y component is divided
+   * @return The component-wise division between this vector and the given scalars.
+   */
+  def divide(x: Float, y: Float): Vec2f = this / (x, y)
+
   /**
    * Returns a vector with all components in absolute value.
    *

src/main/scala/vecmatlib/vector/Vec3d.scala

@@ -192,6 +192,35 @@ case class Vec3d(x: Double, y: Double, z: Double) extends VecDouble[Vec3d] with
    */
   def angle(x: Double, y: Double, z: Double): Double = this.angle(Vec3d(x, y, z))
 
+  /**
+   * Returns a vector whose components are the multiplicative inverse of this vectors components.
+   *
+   * @return A vector whose components are the multiplicative inverse of this vectors components
+   */
+  override def inverse: Vec3d = Vec3d(1.0 / this.x, 1.0 / this.y, 1.0 / this.z)
+
+  /**
+   * Returns the component-wise division between this vector and the given scalars.
+   *
+   * @param x Value by which the X component is divided
+   * @param y Value by which the Y component is divided
+   * @param z Value by which the Z component is divided
+   * @return The component-wise division between this vector and the given scalars.
+   */
+  def /(x: Double, y: Double, z: Double): Vec3d = Vec3d(this.x / x, this.y / y, this.z / z)
+
+  /**
+   * Returns the component-wise division between this vector and the given scalars.
+   *
+   * This method can be used in place of the '/' operator for better interoperability with Java.
+   *
+   * @param x Value by which the X component is divided
+   * @param y Value by which the Y component is divided
+   * @param z Value by which the Z component is divided
+   * @return The component-wise division between this vector and the given scalars.
+   */
+  def divide(x: Double, y: Double, z: Double): Vec3d = this / (x, y, z)
+
   /**
    * Returns a vector with all components in absolute value.
    *

src/main/scala/vecmatlib/vector/Vec3f.scala

@@ -192,6 +192,35 @@ case class Vec3f(x: Float, y: Float, z: Float) extends VecFloat[Vec3f] with Floa
    */
   def angle(x: Double, y: Double, z: Double): Double = this.toDouble.angle(Vec3d(x, y, z))
 
+  /**
+   * Returns a vector whose components are the multiplicative inverse of this vectors components.
+   *
+   * @return A vector whose components are the multiplicative inverse of this vectors components
+   */
+  override def inverse: Vec3f = Vec3f(1.0f / this.x, 1.0f / this.y, 1.0f / this.z)
+
+  /**
+   * Returns the component-wise division between this vector and the given scalars.
+   *
+   * @param x Value by which the X component is divided
+   * @param y Value by which the Y component is divided
+   * @param z Value by which the Z component is divided
+   * @return The component-wise division between this vector and the given scalars.
+   */
+  def /(x: Float, y: Float, z: Float): Vec3f = Vec3f(this.x / x, this.y / y, this.z / z)
+
+  /**
+   * Returns the component-wise division between this vector and the given scalars.
+   *
+   * This method can be used in place of the '/' operator for better interoperability with Java.
+   *
+   * @param x Value by which the X component is divided
+   * @param y Value by which the Y component is divided
+   * @param z Value by which the Z component is divided
+   * @return The component-wise division between this vector and the given scalars.
+   */
+  def divide(x: Float, y: Float, z: Float): Vec3f = this / (x, y, z)
+
   /**
    * Returns a vector with all components in absolute value.
    *

src/main/scala/vecmatlib/vector/Vec4d.scala

@@ -231,6 +231,37 @@ case class Vec4d(x: Double, y: Double, z: Double, w: Double) extends VecDouble[V
    */
   def angle(x: Double, y: Double, z: Double, w: Double): Double = this.angle(Vec4d(x, y, z, w))
 
+  /**
+   * Returns a vector whose components are the multiplicative inverse of this vectors components.
+   *
+   * @return A vector whose components are the multiplicative inverse of this vectors components
+   */
+  override def inverse: Vec4d = Vec4d(1.0 / this.x, 1.0 / this.y, 1.0 / this.z, 1.0 / this.w)
+
+  /**
+   * Returns the component-wise division between this vector and the given scalars.
+   *
+   * @param x Value by which the X component is divided
+   * @param y Value by which the Y component is divided
+   * @param z Value by which the Z component is divided
+   * @param w Value by which the W component is divided
+   * @return The component-wise division between this vector and the given scalars.
+   */
+  def /(x: Double, y: Double, z: Double, w: Double): Vec4d = Vec4d(this.x / x, this.y / y, this.z / z, this.w / w)
+
+  /**
+   * Returns the component-wise division between this vector and the given scalars.
+   *
+   * This method can be used in place of the '/' operator for better interoperability with Java.
+   *
+   * @param x Value by which the X component is divided
+   * @param y Value by which the Y component is divided
+   * @param z Value by which the Z component is divided
+   * @param w Value by which the W component is divided
+   * @return The component-wise division between this vector and the given scalars.
+   */
+  def divide(x: Double, y: Double, z: Double, w: Double): Vec4d = this / (x, y, z, w)
+
   /**
    * Returns a vector with all components in absolute value.
    *

src/main/scala/vecmatlib/vector/Vec4f.scala

@@ -231,6 +231,37 @@ case class Vec4f(x: Float, y: Float, z: Float, w: Float) extends VecFloat[Vec4f]
    */
   def angle(x: Double, y: Double, z: Double, w: Double): Double = this.toDouble.angle(Vec4d(x, y, z, w))
 
+  /**
+   * Returns a vector whose components are the multiplicative inverse of this vectors components.
+   *
+   * @return A vector whose components are the multiplicative inverse of this vectors components
+   */
+  override def inverse: Vec4f = Vec4f(1.0f / this.x, 1.0f / this.y, 1.0f / this.z, 1.0f / this.w)
+
+  /**
+   * Returns the component-wise division between this vector and the given scalars.
+   *
+   * @param x Value by which the X component is divided
+   * @param y Value by which the Y component is divided
+   * @param z Value by which the Z component is divided
+   * @param w Value by which the W component is divided
+   * @return The component-wise division between this vector and the given scalars.
+   */
+  def /(x: Float, y: Float, z: Float, w: Float): Vec4f = Vec4f(this.x / x, this.y / y, this.z / z, this.w / w)
+
+  /**
+   * Returns the component-wise division between this vector and the given scalars.
+   *
+   * This method can be used in place of the '/' operator for better interoperability with Java.
+   *
+   * @param x Value by which the X component is divided
+   * @param y Value by which the Y component is divided
+   * @param z Value by which the Z component is divided
+   * @param w Value by which the W component is divided
+   * @return The component-wise division between this vector and the given scalars.
+   */
+  def divide(x: Float, y: Float, z: Float, w: Float): Vec4f = this / (x, y, z, w)
+
   /**
    * Returns a vector with all components in absolute value.
    *

src/main/scala/vecmatlib/vector/VecDouble.scala

@@ -80,6 +80,31 @@ abstract class VecDouble[V <: VecDouble[V]] extends VecAbstract[V] {
    */
   override def angle(v: V): Double = math.acos((this dot v) / (this.length * v.length))
 
+  /**
+   * Returns a vector whose components are the multiplicative inverse of this vectors components.
+   *
+   * @return A vector whose components are the multiplicative inverse of this vectors components
+   */
+  def inverse: V
+
+  /**
+   * Returns the component-wise division between this vector and the given one.
+   *
+   * @param v The second operand of the division
+   * @return The component-wise multiplication between this vector and the given one
+   */
+  def /(v: V): V = this * v.inverse
+
+  /**
+   * Returns the component-wise division between this vector and the given one.
+   *
+   * This method can be used in place of the '/' operator for better interoperability with Java.
+   *
+   * @param v The second operand of the division
+   * @return The component-wise multiplication between this vector and the given one
+   */
+  def divide(v: V): V = this / v
+
   /**
    * Returns the normalized vector pointing from this vector to the given one.
    *

src/main/scala/vecmatlib/vector/VecFloat.scala

@@ -80,6 +80,31 @@ abstract class VecFloat[V <: VecFloat[V]] extends VecAbstract[V] {
    */
   override def angle(v: V): Double = math.acos((this dot v) / (this.length * v.length))
 
+  /**
+   * Returns a vector whose components are the multiplicative inverse of this vectors components.
+   *
+   * @return A vector whose components are the multiplicative inverse of this vectors components
+   */
+  def inverse: V
+
+  /**
+   * Returns the component-wise division between this vector and the given one.
+   *
+   * @param v The second operand of the division
+   * @return The component-wise multiplication between this vector and the given one
+   */
+  def /(v: V): V = this * v.inverse
+
+  /**
+   * Returns the component-wise division between this vector and the given one.
+   *
+   * This method can be used in place of the '/' operator for better interoperability with Java.
+   *
+   * @param v The second operand of the division
+   * @return The component-wise multiplication between this vector and the given one
+   */
+  def divide(v: V): V = this / v
+
   /**
    * Returns the normalized vector pointing from this vector to the given one.
    *