rubysketch 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83aecf951db1320693714768446ccc95aa0a87f23012e02fff31b032c88be3c6
-  data.tar.gz: 6d1f67cbe65c15468cb606666acceacf19f56bf8c83dd1abae2a1b21d7daf94b
+  metadata.gz: 90fb6bf8a945c62f9ac122dc4df7515aa2ebf271cb100836c76cb8cc1d4f7c50
+  data.tar.gz: 53e61d592dbc5090d98e3c6bb015d406f018683767997c3f2f4d53462a9f27b4
 SHA512:
-  metadata.gz: 9946ba3029ce56a90042daa9be9e6c2f74f5d7ef7d318b5263b10c03ca35c26f5f7e67c61e6f78bd90f4224c267f732dcb937d86030adbe2b0ac51350a225f6e
-  data.tar.gz: 627eb17aa1e83da474f9ab9457b449b278ecf95d84956f98b82d3185c6bc87fa9b5788ad65c1144f80364171b14a4f7322d86a42066925ccbca8f2e19ff46cc3
+  metadata.gz: deb1f851efbcfd3feff20a7495ad55c9ef3a2d1e9ee416d6b87de89069197cc397a64303c69929f212cb0dda658f739a6ca1f1e83bea3050afa219b889509a9d
+  data.tar.gz: ba13f0ce8a03a0b86f1ad20078e0b473d2e6058a446a3059c21f8c9e5ccabcaa72f065bcbfee13bb7b105960f0e658b1ee3e609c44c1429f1d4a9851ce122eab

data/ChangeLog.md

@@ -1,6 +1,11 @@
 # RubySketch ChangeLog
 
 
+## [0.3.3] - 2020-08-01
+
+- add Vector class
+
+
 ## [0.3.2] - 2020-07-22
 
 - text() draws to the baseline by default

data/Rakefile

@@ -18,6 +18,7 @@ MODULES = [Xot, Rucy, Rays, Reflex, RubySketch]
 
 ENV['RDOC'] = 'yardoc --no-private'
 
+test_ruby_extension
 generate_documents
 build_ruby_gem
 

data/VERSION

@@ -1 +1 @@
-0.3.2
+0.3.3

data/lib/rubysketch/processing.rb

@@ -6,13 +6,567 @@ module RubySketch
   module Processing
 
 
+    # Vector class.
+    #
+    class Vector
+
+      include Comparable
+
+      # Initialize vector object.
+      #
+      # @overload new()
+      # @overload new(x)
+      # @overload new(x, y)
+      # @overload new(x, y, z)
+      # @overload new(v)
+      # @overload new(a)
+      #
+      # @param x [Numeric] x of vector
+      # @param y [Numeric] y of vector
+      # @param z [Numeric] z of vector
+      # @param v [Vector]  vector object to copy
+      # @param a [Array]   array like [x, y, z]
+      #
+      def initialize (x = 0, y = 0, z = 0, context: context)
+        @point = case x
+          when Rays::Point then x.dup
+          when Vector      then x.getInternal__.dup
+          when Array       then Rays::Point.new x[0] || 0, x[1] || 0, x[2] || 0
+          else                  Rays::Point.new x    || 0, y    || 0, z    || 0
+          end
+        @context = context
+      end
+
+      # Initializer for dup or clone
+      #
+      def initialize_copy (o)
+        @point = o.getInternal__.dup
+      end
+
+      # Copy vector object
+      #
+      # @return [Vector] duplicated vector object
+      #
+      alias copy dup
+
+      # Sets x, y and z.
+      #
+      # @overload set(x)
+      # @overload set(x, y)
+      # @overload set(x, y, z)
+      # @overload set(v)
+      # @overload set(a)
+      #
+      # @param x [Numeric] x of vector
+      # @param y [Numeric] y of vector
+      # @param z [Numeric] z of vector
+      # @param v [Vector]  vector object to copy
+      # @param a [Array]   array with x, y, z
+      #
+      # @return [nil] nil
+      #
+      def set (*args)
+        initialize *args
+        self
+      end
+
+      # Gets x value.
+      #
+      # @return [Numeric] x value of vector
+      #
+      def x ()
+        @point.x
+      end
+
+      # Gets y value.
+      #
+      # @return [Numeric] y value of vector
+      #
+      def y ()
+        @point.y
+      end
+
+      # Gets z value.
+      #
+      # @return [Numeric] z value of vector
+      #
+      def z ()
+        @point.z
+      end
+
+      # Sets x value.
+      #
+      # @return [Numeric] x value of vector
+      #
+      def x= (x)
+        @point.x = x
+      end
+
+      # Sets y value.
+      #
+      # @return [Numeric] y value of vector
+      #
+      def y= (y)
+        @point.y = y
+      end
+
+      # Sets z value.
+      #
+      # @return [Numeric] z value of vector
+      #
+      def z= (z)
+        @point.z = z
+      end
+
+      # Returns the interpolated vector between 2 vectors.
+      #
+      # @overload lerp(v, amount)
+      # @overload lerp(x, y, amount)
+      # @overload lerp(x, y, z, amount)
+      #
+      # @param v      [Vector]  vector to interpolate
+      # @param x      [Numeric] x of vector to interpolate
+      # @param y      [Numeric] y of vector to interpolate
+      # @param z      [Numeric] z of vector to interpolate
+      # @param amount [Numeric] amount to interpolate
+      #
+      # @return [Vector] interporated vector
+      #
+      def lerp (*args, amount)
+        v      = toVector__ *args
+        self.x = x + (v.x - x) * amount
+        self.y = y + (v.y - y) * amount
+        self.z = z + (v.z - z) * amount
+        self
+      end
+
+      # Returns the interpolated vector between 2 vectors.
+      #
+      # @param v1     [Vector] vector to interpolate
+      # @param v2     [Vector] vector to interpolate
+      # @param amount [Numeric] amount to interpolate
+      #
+      # @return [Vector] interporated vector
+      #
+      def self.lerp (v1, v2, amount)
+        v1.dup.lerp v2, amount
+      end
+
+      # Returns x, y, z as an array
+      #
+      # @return [Array] array of x, y, z
+      #
+      def array ()
+        @point.to_a 3
+      end
+
+      # Adds a vector.
+      #
+      # @overload add(v)
+      # @overload add(x, y)
+      # @overload add(x, y, z)
+      #
+      # @param v [Vector] vector to add
+      # @param x [Vector] x of vector to add
+      # @param y [Vector] y of vector to add
+      # @param z [Vector] z of vector to add
+      #
+      # @return [Vector] added vector
+      #
+      def add (*args)
+        @point += toVector__(*args).getInternal__
+        self
+      end
+
+      # Subtracts a vector.
+      #
+      # @overload sub(v)
+      # @overload sub(x, y)
+      # @overload sub(x, y, z)
+      #
+      # @param v [Vector] vector to subtract
+      # @param x [Vector] x of vector to subtract
+      # @param y [Vector] y of vector to subtract
+      # @param z [Vector] z of vector to subtract
+      #
+      # @return [Vector] subtracted vector
+      #
+      def sub (*args)
+        @point -= toVector__(*args).getInternal__
+        self
+      end
+
+      # Multiplies a vector by scalar.
+      #
+      # @param num [Numeric] number to multiply the vector
+      #
+      # @return [Vector] multiplied vector
+      #
+      def mult (num)
+        @point *= num
+        self
+      end
+
+      # Divides a vector by scalar.
+      #
+      # @param num [Numeric] number to divide the vector
+      #
+      # @return [Vector] divided vector
+      #
+      def div (num)
+        @point /= num
+        self
+      end
+
+      # Adds a vector.
+      #
+      # @param v [Vector] vector to add
+      #
+      # @return [Vector] added vector
+      #
+      def + (v)
+        dup.add v
+      end
+
+      # Subtracts a vector.
+      #
+      # @param v [Vector] vector to subtract
+      #
+      # @return [Vector] subtracted vector
+      #
+      def - (v)
+        dup.sub v
+      end
+
+      # Multiplies a vector by scalar.
+      #
+      # @param num [Numeric] number to multiply the vector
+      #
+      # @return [Vector] multiplied vector
+      #
+      def * (num)
+        dup.mult num
+      end
+
+      # Divides a vector by scalar.
+      #
+      # @param num [Numeric] number to divide the vector
+      #
+      # @return [Vector] divided vector
+      #
+      def / (num)
+        dup.div num
+      end
+
+      # Adds 2 vectors.
+      #
+      # @overload add(v1, v2)
+      # @overload add(v1, v2, target)
+      #
+      # @param v1     [Vector] a vector
+      # @param v2     [Vector] another vector
+      # @param target [Vector] vector to store added vector
+      #
+      # @return [Vector] added vector
+      #
+      def self.add (v1, v2, target = nil)
+        v = v1 + v2
+        target.set v if self === target
+        v
+      end
+
+      # Subtracts 2 vectors.
+      #
+      # @overload sub(v1, v2)
+      # @overload sub(v1, v2, target)
+      #
+      # @param v1     [Vector] a vector
+      # @param v2     [Vector] another vector
+      # @param target [Vector] vector to store subtracted vector
+      #
+      # @return [Vector] subtracted vector
+      #
+      def self.sub (v1, v2, target = nil)
+        v = v1 - v2
+        target.set v if self === target
+        v
+      end
+
+      # Multiplies a vector by scalar.
+      #
+      # @overload mult(v, num)
+      # @overload mult(v, num, target)
+      #
+      # @param v      [Vector]  a vector
+      # @param num    [Numeric] number to multiply the vector
+      # @param target [Vector]  vector to store multiplied vector
+      #
+      # @return [Vector] multiplied vector
+      #
+      def self.mult (v1, num, target = nil)
+        v = v1 * num
+        target.set v if self === target
+        v
+      end
+
+      # Divides a vector by scalar.
+      #
+      # @overload div(v, num)
+      # @overload div(v, num, target)
+      #
+      # @param v      [Vector]  a vector
+      # @param num    [Numeric] number to divide the vector
+      # @param target [Vector]  vector to store divided vector
+      #
+      # @return [Vector] divided vector
+      #
+      def self.div (v1, num, target = nil)
+        v = v1 / num
+        target.set v if self === target
+        v
+      end
+
+      # Returns the length of the vector.
+      #
+      # @return [Numeric] length
+      #
+      def mag ()
+        @point.length
+      end
+
+      # Returns squared length of the vector.
+      #
+      # @return [Numeric] squared length
+      #
+      def magSq ()
+        Rays::Point::dot(@point, @point)
+      end
+
+      # Changes the length of the vector.
+      #
+      # @overload setMag(len)
+      # @overload setMag(target, len)
+      #
+      # @param len    [Numeric] length of new vector
+      # @param target [Vector]  vector to store new vector
+      #
+      # @return [Vector] vector with new length
+      #
+      def setMag (target = nil, len)
+        (target || self).set @point.normal * len
+      end
+
+      # Changes the length of the vector to 1.0.
+      #
+      # @param target [Vector] vector to store the normalized vector
+      #
+      # @return [Vector] normalized vector
+      #
+      def normalize (target = nil)
+        (target || self).set @point.normal
+      end
+
+      # Changes the length of the vector if it's length is greater than the max value.
+      #
+      # @param max [Numeric] max length
+      #
+      # @return [Vector] new vector
+      #
+      def limit (max)
+        setMag max if magSq > max ** 2
+        self
+      end
+
+      # Returns the distance of 2 vectors.
+      #
+      # @param v [Vector] a vector
+      #
+      # @return [Numeric] the distance
+      #
+      def dist (v)
+        (self - v).mag
+      end
+
+      # Returns the distance of 2 vectors.
+      #
+      # @param v1 [Vector] a vector
+      # @param v2 [Vector] another vector
+      #
+      # @return [Numeric] the distance
+      #
+      def self.dist (v1, v2)
+        v1.dist v2
+      end
+
+      # Calculates the dot product of 2 vectors.
+      #
+      # @overload dot(v)
+      # @overload dot(x, y)
+      # @overload dot(x, y, z)
+      #
+      # @param v [Vector] a vector
+      # @param x [Numeric] x of vector
+      # @param y [Numeric] y of vector
+      # @param z [Numeric] z of vector
+      #
+      # @return [Numeric] result of dot product
+      #
+      def dot (*args)
+        Rays::Point::dot getInternal__, toVector__(*args).getInternal__
+      end
+
+      # Calculates the dot product of 2 vectors.
+      #
+      # @param v1 [Vector] a vector
+      # @param v2 [Vector] another vector
+      #
+      # @return [Numeric] result of dot product
+      #
+      def self.dot (v1, v2)
+        v1.dot v2
+      end
+
+      # Calculates the cross product of 2 vectors.
+      #
+      # @overload cross(v)
+      # @overload cross(x, y)
+      # @overload cross(x, y, z)
+      #
+      # @param v [Vector] a vector
+      # @param x [Numeric] x of vector
+      # @param y [Numeric] y of vector
+      # @param z [Numeric] z of vector
+      #
+      # @return [Numeric] result of cross product
+      #
+      def cross (a, *rest)
+        target = self.class === rest.last ? rest.pop : nil
+        v = self.class.new Rays::Point::cross getInternal__, toVector__(a, *rest).getInternal__
+        target.set v if self.class === target
+        v
+      end
+
+      # Calculates the cross product of 2 vectors.
+      #
+      # @param v1 [Vector] a vector
+      # @param v2 [Vector] another vector
+      #
+      # @return [Numeric] result of cross product
+      #
+      def self.cross (v1, v2, target = nil)
+        v1.cross v2, target
+      end
+
+      # Rotate the vector.
+      #
+      # @param angle [Numeric] the angle of rotation
+      #
+      # @return [Vector] rotated this object
+      #
+      def rotate (angle)
+        angle = @context ? @context.toAngle__(angle) : angle * Utility::RAD2DEG__
+        @point.rotate! angle
+        self
+      end
+
+      # Returns the angle of rotation for this vector.
+      #
+      # @return [Numeric] the angle in radians
+      #
+      def heading ()
+        Math.atan2 y, x
+      end
+
+      # Returns rotated new vector.
+      #
+      # @param angle  [Numeric] the angle of rotation
+      # @param target [Vector]  vector to store new vector
+      #
+      # @return [Vector] rotated vector
+      #
+      def self.fromAngle (angle, target = nil)
+        v = self.new(1, 0, 0).rotate(angle)
+        target.set v if target
+        v
+      end
+
+      # Returns angle between 2 vectors.
+      #
+      # @param v1 [Vector] a vector
+      # @param v2 [Vector] another vector
+      #
+      # @return [Numeric] angle in radians
+      #
+      def self.angleBetween (v1, v2)
+        x1, y1, z1 = v1.array
+        x2, y2, z2 = v2.array
+        return 0 if (x1 == 0 && y1 == 0 && z1 == 0) || (x2 == 0 && y2 == 0 && z2 == 0)
+
+        x = dot(v1, v2) / (v1.mag * v2.mag)
+        return Math::PI if x <= -1
+        return 0        if x >= 1
+        return Math.acos x
+      end
+
+      # Returns a new 2D unit vector with a random direction.
+      #
+      # @param target [Vector] a vector to store the new vector
+      #
+      # @return [Vector] a random vector
+      #
+      def self.random2D (target = nil)
+        v = self.fromAngle rand 0.0...(Math::PI * 2)
+        target.set v if target
+        v
+      end
+
+      # Returns a new 3D unit vector with a random direction.
+      #
+      # @param target [Vector] a vector to store the new vector
+      #
+      # @return [Vector] a random vector
+      #
+      def self.random3D (target = nil)
+        angle = rand 0.0...(Math::PI * 2)
+        z     = rand -1.0..1.0
+        z2    = z ** 2
+        x     = Math.sqrt(1.0 - z2) * Math.cos(angle)
+        y     = Math.sqrt(1.0 - z2) * Math.sin(angle)
+        v     = self.new x, y, z
+        target.set v if target
+        v
+      end
+
+      # @private
+      def inspect ()
+        "<##{self.class.name} #{x}, #{y}, #{z}>"
+      end
+
+      # @private
+      def <=> (o)
+        @point <=> o.getInternal__
+      end
+
+      # @private
+      protected def getInternal__ ()
+        @point
+      end
+
+      # @private
+      private def toVector__ (*args)
+        self.class === args.first ? args.first : self.class.new(*args)
+      end
+
+    end# Vector
+
+
     # Image object.
     #
     class Image
 
       # @private
       def initialize (image)
-        @image__ = image
+        @image = image
       end
 
       # Gets width of image.
@@ -20,7 +574,7 @@ module RubySketch
       # @return [Numeric] width of image
       #
       def width ()
-        @image__.width
+        @image.width
       end
 
       # Gets height of image.
@@ -28,7 +582,7 @@ module RubySketch
       # @return [Numeric] height of image
       #
       def height ()
-        @image__.height
+        @image.height
       end
 
       # Resizes image.
@@ -39,8 +593,8 @@ module RubySketch
       # @return [nil] nil
       #
       def resize (width, height)
-        @image__ = Rays::Image.new(width, height).paint do |painter|
-          painter.image @image__, 0, 0, width, height
+        @image = Rays::Image.new(width, height).paint do |painter|
+          painter.image @image, 0, 0, width, height
         end
         nil
       end
@@ -64,7 +618,7 @@ module RubySketch
       #
       def copy (img = nil, sx, sy, sw, sh, dx, dy, dw, dh)
         img ||= self
-        @image__.paint do |painter|
+        @image.paint do |painter|
           painter.image img.getInternal__, sx, sy, sw, sh, dx, dy, dw, dh
         end
       end
@@ -74,12 +628,12 @@ module RubySketch
       # @param filename [String] file name to save image
       #
       def save (filename)
-        @image__.save filename
+        @image.save filename
       end
 
       # @private
       def getInternal__ ()
-        @image__
+        @image
       end
 
     end# Image
@@ -369,7 +923,7 @@ module RubySketch
       end
 
       # @private
-      private def toAngle__ (angle)
+      protected def toAngle__ (angle)
         angle * @angleScale__
       end
 
@@ -1025,12 +1579,12 @@ module RubySketch
       end
 
       # @private
-      def getInternal__ ()
+      private def getInternal__ ()
         @image__
       end
 
       # @private
-      def assertDrawing__ ()
+      private def assertDrawing__ ()
         raise "call beginDraw() before drawing" unless @drawing
       end
 

data/test/processing/test_vector.rb

@@ -0,0 +1,395 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative '../helper'
+
+
+class TestProcessingVector < Test::Unit::TestCase
+
+  V = RubySketch::Processing::Vector
+
+  M = Math
+
+  PI = M::PI
+
+  def vec (*args)
+    V.new *args
+  end
+
+  def point (*args)
+    Rays::Point.new *args
+  end
+
+  def test_initialize ()
+    assert_equal vec(0, 0, 0), vec()
+    assert_equal vec(1, 0, 0), vec(1)
+    assert_equal vec(1, 2, 0), vec(1, 2)
+    assert_equal vec(1, 2, 3), vec(1, 2, 3)
+
+    assert_equal vec(0, 0, 0), vec([])
+    assert_equal vec(1, 0, 0), vec([1])
+    assert_equal vec(1, 2, 0), vec([1, 2])
+    assert_equal vec(1, 2, 3), vec([1, 2, 3])
+
+    assert_equal vec(1, 2, 3), vec(vec 1, 2, 3)
+    assert_equal vec(1, 2, 3), vec(point 1, 2, 3)
+  end
+
+  def test_set ()
+    v0 = vec 9, 9, 9
+
+    v = v0.dup; v.set;         assert_equal vec(0, 0, 0), v
+    v = v0.dup; v.set 1;       assert_equal vec(1, 0, 0), v
+    v = v0.dup; v.set 1, 2;    assert_equal vec(1, 2, 0), v
+    v = v0.dup; v.set 1, 2, 3; assert_equal vec(1, 2, 3), v
+
+    v = v0.dup; v.set [];        assert_equal vec(0, 0, 0), v
+    v = v0.dup; v.set [1];       assert_equal vec(1, 0, 0), v
+    v = v0.dup; v.set [1, 2];    assert_equal vec(1, 2, 0), v
+    v = v0.dup; v.set [1, 2, 3]; assert_equal vec(1, 2, 3), v
+
+    v = v0.dup; v.set   vec(1, 2, 3); assert_equal vec(1, 2, 3), v
+    v = v0.dup; v.set point(1, 2, 3); assert_equal vec(1, 2, 3), v
+  end
+
+  def test_dup ()
+    v1 = vec 1, 2, 3
+    assert_equal vec(1, 2, 3), v1
+
+    v2 = v1.dup
+    assert_equal vec(1, 2, 3), v1
+    assert_equal vec(1, 2, 3), v2
+
+    v1.set 7, 8, 9
+    assert_equal vec(7, 8, 9), v1
+    assert_equal vec(1, 2, 3), v2
+  end
+
+  def test_copy ()
+    v1 = vec 1, 2, 3
+    assert_equal vec(1, 2, 3), v1
+
+    v2 = v1.copy
+    assert_equal vec(1, 2, 3), v1
+    assert_equal vec(1, 2, 3), v2
+
+    v1.set 7, 8, 9
+    assert_equal vec(7, 8, 9), v1
+    assert_equal vec(1, 2, 3), v2
+  end
+
+  def test_xyz ()
+    v = vec 1, 2, 3
+    assert_equal vec(1, 2, 3), v
+    assert_equal [1, 2, 3], [v.x, v.y, v.z]
+
+    v.x = 7
+    assert_equal vec(7, 2, 3), v
+
+    v.y = 8
+    assert_equal vec(7, 8, 3), v
+
+    v.z = 9
+    assert_equal vec(7, 8, 9), v
+  end
+
+  def test_array ()
+    assert_equal [1, 2, 3], vec(1, 2, 3).array
+  end
+
+  def test_add ()
+    v = vec 1, 2, 3
+    v.add 4, 5, 6
+    assert_equal vec(5, 7, 9), v
+
+    assert_equal vec(1, 2, 3), vec(1, 2, 3).add()
+    assert_equal vec(5, 2, 3), vec(1, 2, 3).add(4)
+    assert_equal vec(5, 7, 3), vec(1, 2, 3).add(4, 5)
+    assert_equal vec(5, 7, 9), vec(1, 2, 3).add(4, 5, 6)
+
+    assert_equal vec(1, 2, 3), vec(1, 2, 3).add([])
+    assert_equal vec(5, 2, 3), vec(1, 2, 3).add([4])
+    assert_equal vec(5, 7, 3), vec(1, 2, 3).add([4, 5])
+    assert_equal vec(5, 7, 9), vec(1, 2, 3).add([4, 5, 6])
+
+    assert_equal vec(5, 7, 9), vec(1, 2, 3).add(  vec(4, 5, 6))
+    assert_equal vec(5, 7, 9), vec(1, 2, 3).add(point(4, 5, 6))
+  end
+
+  def test_sub ()
+    v = vec 9, 8, 7
+    v.sub 1, 2, 3
+    assert_equal vec(8, 6, 4), v
+
+    assert_equal vec(9, 8, 7), vec(9, 8, 7).sub()
+    assert_equal vec(8, 8, 7), vec(9, 8, 7).sub(1)
+    assert_equal vec(8, 6, 7), vec(9, 8, 7).sub(1, 2)
+    assert_equal vec(8, 6, 4), vec(9, 8, 7).sub(1, 2, 3)
+
+    assert_equal vec(9, 8, 7), vec(9, 8, 7).sub([])
+    assert_equal vec(8, 8, 7), vec(9, 8, 7).sub([1])
+    assert_equal vec(8, 6, 7), vec(9, 8, 7).sub([1, 2])
+    assert_equal vec(8, 6, 4), vec(9, 8, 7).sub([1, 2, 3])
+
+    assert_equal vec(8, 6, 4), vec(9, 8, 7).sub(  vec(1, 2, 3))
+    assert_equal vec(8, 6, 4), vec(9, 8, 7).sub(point(1, 2, 3))
+  end
+
+  def test_mult ()
+    v = vec 1, 2, 3
+    v.mult 2
+    assert_equal vec(2, 4, 6), v
+  end
+
+  def test_div ()
+    v = vec 2, 4, 6
+    v.div 2
+    assert_equal vec(1, 2, 3), v
+  end
+
+  def test_op_add ()
+    v1 = vec 1, 2, 3
+    v2 = vec 4, 5, 6
+    assert_equal vec(5, 7, 9), v1 + v2
+    assert_equal vec(1, 2, 3), v1
+    assert_equal vec(4, 5, 6), v2
+
+    assert_equal vec(5, 2, 3), vec(1, 2, 3) + 4
+
+    assert_equal vec(1, 2, 3), vec(1, 2, 3) + []
+    assert_equal vec(5, 2, 3), vec(1, 2, 3) + [4]
+    assert_equal vec(5, 7, 3), vec(1, 2, 3) + [4, 5]
+    assert_equal vec(5, 7, 9), vec(1, 2, 3) + [4, 5, 6]
+
+    assert_equal vec(5, 7, 9), vec(1, 2, 3) +   vec(4, 5, 6)
+    assert_equal vec(5, 7, 9), vec(1, 2, 3) + point(4, 5, 6)
+  end
+
+  def test_op_sub ()
+    v1 = vec 9, 8, 7
+    v2 = vec 1, 2, 3
+    assert_equal vec(8, 6, 4), v1 - v2
+    assert_equal vec(9, 8, 7), v1
+    assert_equal vec(1, 2, 3), v2
+
+    assert_equal vec(8, 8, 7), vec(9, 8, 7) - 1
+
+    assert_equal vec(9, 8, 7), vec(9, 8, 7) - []
+    assert_equal vec(8, 8, 7), vec(9, 8, 7) - [1]
+    assert_equal vec(8, 6, 7), vec(9, 8, 7) - [1, 2]
+    assert_equal vec(8, 6, 4), vec(9, 8, 7) - [1, 2, 3]
+
+    assert_equal vec(8, 6, 4), vec(9, 8, 7) -   vec(1, 2, 3)
+    assert_equal vec(8, 6, 4), vec(9, 8, 7) - point(1, 2, 3)
+  end
+
+  def test_op_mult ()
+    v = vec 1, 2, 3
+    assert_equal vec(2, 4, 6), v * 2
+    assert_equal vec(1, 2, 3), v
+  end
+
+  def test_op_div ()
+    v = vec 2, 4, 6
+    assert_equal vec(1, 2, 3), v / 2
+    assert_equal vec(2, 4, 6), v
+  end
+
+  def test_fun_add ()
+    v1     = vec 1, 2, 3
+    v2     = vec 4, 5, 6
+    result = vec
+    assert_equal vec(5, 7, 9), V.add(v1, v2, result)
+    assert_equal vec(1, 2, 3), v1
+    assert_equal vec(4, 5, 6), v2
+    assert_equal vec(5, 7, 9), result
+  end
+
+  def test_fun_sub ()
+    v1     = vec 9, 8, 7
+    v2     = vec 1, 2, 3
+    result = vec
+    assert_equal vec(8, 6, 4), V.sub(v1, v2, result)
+    assert_equal vec(9, 8, 7), v1
+    assert_equal vec(1, 2, 3), v2
+    assert_equal vec(8, 6, 4), result
+  end
+
+  def test_fun_mult ()
+    v1     = vec 1, 2, 3
+    result = vec
+    assert_equal vec(2, 4, 6), V.mult(v1, 2, result)
+    assert_equal vec(1, 2, 3), v1
+    assert_equal vec(2, 4, 6), result
+  end
+
+  def test_fun_div ()
+    v1     = vec 2, 4, 6
+    result = vec
+    assert_equal vec(1, 2, 3), V.div(v1, 2, result)
+    assert_equal vec(2, 4, 6), v1
+    assert_equal vec(1, 2, 3), result
+  end
+
+  def test_mag ()
+    assert_in_delta M.sqrt(5),  vec(1, 2)   .mag, 0.000001
+    assert_in_delta M.sqrt(14), vec(1, 2, 3).mag, 0.000001
+  end
+
+  def test_magSq ()
+    assert_equal 5,  vec(1, 2)   .magSq
+    assert_equal 14, vec(1, 2, 3).magSq
+  end
+
+  def test_setMag ()
+    v = vec 3, 4, 0
+    assert_equal vec(6, 8, 0), v.setMag(10)
+    assert_equal vec(6, 8, 0), v
+
+    v      = vec 3, 4, 0
+    result = vec
+    assert_equal vec(6, 8, 0), v.setMag(result, 10)
+    assert_equal vec(3, 4, 0), v
+    assert_equal vec(6, 8, 0), result
+  end
+
+  def test_normalize ()
+    v      = vec 1, 2, 3
+    normal = v / v.mag
+    assert_equal normal, v.normalize
+    assert_equal normal, v
+
+    v      = vec 1, 2, 3
+    result = vec
+    assert_equal normal,       v.normalize(result)
+    assert_equal vec(1, 2, 3), v
+    assert_equal normal,       result
+  end
+
+  def test_limit ()
+    v = vec 1, 2, 3
+    assert_in_delta 1, v.limit(1).mag, 0.000001
+    assert_in_delta 1, v         .mag, 0.000001
+
+    assert_in_delta 1,                vec(1, 2, 3).limit(1).mag, 0.000001
+    assert_in_delta 2,                vec(1, 2, 3).limit(2).mag, 0.000001
+    assert_in_delta 3,                vec(1, 2, 3).limit(3).mag, 0.000001
+    assert_in_delta vec(1, 2, 3).mag, vec(1, 2, 3).limit(4).mag, 0.000001
+  end
+
+  def test_dist ()
+    v1 = vec 1, 2, 3
+    v2 = vec 4, 5, 6
+
+    assert_in_delta M.sqrt((4-1)**2 + (5-2)**2 + (6-3)**2), v1.dist(v2), 0.000001
+    assert_equal vec(1, 2, 3), v1
+    assert_equal vec(4, 5, 6), v2
+
+    assert_in_delta M.sqrt((4-1)**2 + (5-2)**2 + (6-3)**2), V.dist(v1, v2), 0.000001
+    assert_equal vec(1, 2, 3), v1
+    assert_equal vec(4, 5, 6), v2
+  end
+
+  def test_dot ()
+    v1 = vec 1, 2, 3
+    v2 = vec 4, 5, 6
+
+    assert_equal 1*4 + 2*5 + 3*6, v1.dot(4, 5, 6)
+    assert_equal vec(1, 2, 3), v1
+
+    assert_equal 1*4 + 2*5 + 3*6, v1.dot(v2)
+    assert_equal vec(1, 2, 3), v1
+    assert_equal vec(4, 5, 6), v2
+
+    assert_equal 1*4 + 2*5 + 3*6, V.dot(v1, v2)
+    assert_equal vec(1, 2, 3), v1
+    assert_equal vec(4, 5, 6), v2
+  end
+
+  def test_cross ()
+    v1 = vec 1, 0, 0
+    v2 = vec 0, 1, 0
+
+    assert_equal vec(0, 0, 1), v1.cross(0, 1, 0)
+    assert_equal vec(1, 0, 0), v1
+
+    result = vec 1, 2, 3
+    assert_equal vec(0, 0, 1), v1.cross(v2, result)
+    assert_equal vec(1, 0, 0), v1
+    assert_equal vec(0, 1, 0), v2
+    assert_equal vec(0, 0, 1), result
+
+    result = vec 1, 2, 3
+    assert_equal vec(0, 0, 1), V.cross(v1, v2, result)
+    assert_equal vec(1, 0, 0), v1
+    assert_equal vec(0, 1, 0), v2
+    assert_equal vec(0, 0, 1), result
+  end
+
+  def test_rotate ()
+    angle   = PI * 2 * 0.1
+    context = Object.new.tap {|o| def o.toAngle__ (angle); angle; end}
+
+    v = vec 1, 0, 0
+    assert_equal vec(M.cos(angle), M.sin(angle), 0), v.rotate(angle)
+    assert_equal vec(M.cos(angle), M.sin(angle), 0), v
+
+    v = vec 1, 0, 0, context: context
+    assert_equal vec(M.cos(angle), M.sin(angle), 0), v.rotate(36)
+  end
+
+  def test_fromAngle ()
+    angle  = PI * 2 * 0.1
+    result = vec
+    assert_equal vec(M.cos(angle), M.sin(angle), 0), V.fromAngle(angle)
+    assert_equal vec(M.cos(angle), M.sin(angle), 0), V.fromAngle(angle, result)
+    assert_equal vec(M.cos(angle), M.sin(angle), 0), result
+  end
+
+  def test_heading ()
+    angle = PI * 1 * 0.1
+    assert_in_delta  angle, V.fromAngle( angle).heading, 0.000001
+    assert_in_delta -angle, V.fromAngle(-angle).heading, 0.000001
+  end
+
+  def test_angleBetween ()
+    v1 = V.fromAngle PI * 0.25
+    v2 = V.fromAngle PI * 0.75
+    assert_in_delta PI / 2, V.angleBetween(v1, v2), 0.000001
+  end
+
+  def test_lerp ()
+    assert_equal vec(0.5, 0.5, 0.5), vec(0, 0, 0).lerp(vec(1, 1, 1),    0.5)
+    assert_equal vec(0.5, 0.5, 0.5), vec(0, 0, 0).lerp(    1, 1, 1,     0.5)
+    assert_equal vec(0.5, 0.5, 0.5), V.lerp(vec(0, 0, 0), vec(1, 1, 1), 0.5)
+  end
+
+  def test_random2D ()
+    v1 = V.random2D
+    v2 = V.random2D
+    assert          v1.x != 0
+    assert          v1.y != 0
+    assert_equal 0, v1.z
+    assert          v2.x != 0
+    assert          v2.y != 0
+    assert_equal 0, v2.z
+    assert_not_equal v1, v2
+    assert_in_delta 1, v1.mag, 0.000001
+    assert_in_delta 1, v2.mag, 0.000001
+  end
+
+  def test_random3D ()
+    v1 = V.random3D
+    v2 = V.random3D
+    assert v1.x != 0
+    assert v1.y != 0
+    assert v1.z != 0
+    assert v2.x != 0
+    assert v2.y != 0
+    assert v2.z != 0
+    assert_not_equal v1, v2
+    assert_in_delta 1, v1.mag, 0.000001
+    assert_in_delta 1, v2.mag, 0.000001
+  end
+
+end# TestProcessingVector

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubysketch
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors:
 - xordog
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-22 00:00:00.000000000 Z
+date: 2020-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yard
@@ -120,6 +120,7 @@ files:
 - lib/rubysketch/processing.rb
 - lib/rubysketch/window.rb
 - rubysketch.gemspec
+- test/processing/test_vector.rb
 homepage: https://github.com/xord/rubysketch
 licenses: []
 metadata: {}
@@ -142,4 +143,5 @@ rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Processing like Creative Coding Framework.
-test_files: []
+test_files:
+- test/processing/test_vector.rb