vector2d 1.1.2 → 2.0.0

data/lib/vector2d/coercions.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+class Vector2d
+  module Coercions
+    def coerce(other)
+      case other
+      when Vector2d
+        [other, self]
+      when Array, Numeric, String, Hash
+        [Vector2d.parse(other), self]
+      else
+        raise TypeError, "#{self.class} can't be coerced into #{other.class}"
+      end
+    end
+
+    # Renders vector as a pretty string.
+    #
+    #   Vector2d(2, 3).inspect # => "Vector2d(2,3)"
+    #
+    def inspect
+      "Vector2d(#{x},#{y})"
+    end
+
+    # Converts vector to array.
+    #
+    #   Vector2d(2, 3).to_a # => [2,3]
+    #
+    def to_a
+      [x, y]
+    end
+
+    # Converts vector to hash.
+    #
+    #   Vector2d(2, 3).to_hash # => {x: 2, y: 3}
+    #
+    def to_hash
+      { x: x, y: y }
+    end
+
+    # Converts vector to fixnums.
+    #
+    #   Vector2d(2.0, 3.0).to_i_vector # => Vector2d(2,3)
+    #
+    def to_i_vector
+      self.class.new(x.to_i, y.to_i)
+    end
+
+    # Converts vector to floats.
+    #
+    #   Vector2d(2, 3).to_f_vector # => Vector2d(2.0,3.0)
+    #
+    def to_f_vector
+      self.class.new(x.to_f, y.to_f)
+    end
+
+    # Converts vector to string.
+    #
+    #   Vector2d.new(150, 100).to_s # => "150x100"
+    #
+    def to_s
+      "#{x}x#{y}"
+    end
+  end
+end

data/lib/vector2d/fitting.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+class Vector2d
+  module Fitting
+    # Returns a new vector fitting inside another vector, retaining the aspect ratio.
+    #
+    #   vector = Vector2d(20, 10)
+    #   vector.fit(Vector2d(10, 10)) # => Vector2d(10,5)
+    #   vector.fit(Vector2d(20, 20)) # => Vector2d(20,10)
+    #   vector.fit(Vector2d(40, 40)) # => Vector2d(40,20)
+    #
+    # Note: Either axis will be disregarded if zero or nil. This is a feature, not a bug.
+    #
+    def fit(other)
+      v, _ = coerce(other)
+      scale = v.to_f_vector / self
+      self * ((scale.y == 0 || (scale.x > 0 && scale.x < scale.y)) ? scale.x : scale.y)
+    end
+    alias_method :constrain_both, :fit
+
+    # Constrain/expand so that one of the coordinates fit within (the square implied by) another vector.
+    #
+    #   constraint = Vector2d(5, 5)
+    #   Vector2d(20, 10).fit_either(constraint) # => Vector2d(10,5)
+    #   Vector2d(10, 20).fit_either(constraint) # => Vector2d(5,10)
+    #
+    def fit_either(other)
+      v, _ = coerce(other)
+      scale = v.to_f_vector / self
+      if (scale.x > 0 && scale.y > 0)
+        scale = (scale.x < scale.y) ? scale.y : scale.x
+        self * scale
+      else
+        fit(v)
+      end
+    end
+    alias_method :constrain_one, :fit_either
+  end
+end

data/lib/vector2d/properties.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+class Vector2d
+  module Properties
+    # Angle of vector.
+    #
+    #   Vector(2, 3).angle # => 0.9827..
+    #
+    def angle
+      Math.atan2(y, x)
+    end
+
+    # Aspect ratio of vector.
+    #
+    #   Vector(2, 3).aspect_ratio # => 0.6667..
+    #
+    def aspect_ratio
+      (x.to_f / y.to_f).abs
+    end
+
+    # Length of vector.
+    #
+    #   Vector(2, 3).length # => 3.6055..
+    #
+    def length
+      Math.sqrt(squared_length)
+    end
+
+    # Squared length of vector.
+    #
+    #   Vector(2, 3).squared_length # => 13
+    #
+    def squared_length
+      x * x + y * y
+    end
+
+    # Is this a normalized vector?
+    #
+    #   Vector(0, 1).normalized? # => true
+    #   Vector(2, 3).normalized? # => false
+    #
+    def normalized?
+      self.length.to_f == 1.0
+    end
+  end
+end

data/lib/vector2d/transformations.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+class Vector2d
+  module Transformations
+    # Normalizes the vector.
+    #
+    #   vector = Vector2d(2, 3)
+    #   vector.normalize        # => Vector2d(0.5547.., 0.8320..)
+    #   vector.normalize.length # => 1.0
+    #
+    def normalize
+      resize(1.0)
+    end
+
+    # Returns a perpendicular vector.
+    #
+    #   Vector2d(2, 3).perpendicular # => Vector2d(-3,2)
+    #
+    def perpendicular
+      Vector2d.new(-y, x)
+    end
+
+    # Changes magnitude of vector.
+    #
+    #   Vector2d(2, 3).resize(1.0) # => Vector2d(0.5547.., 0.8320..)
+    #
+    def resize(new_length)
+      self * (new_length / self.length)
+    end
+
+    # Reverses the vector.
+    #
+    #   Vector2d(2, 3).reverse # => Vector2d(-2,-3)
+    #
+    def reverse
+      self.class.new(-x, -y)
+    end
+
+    # Rounds vector to nearest integer.
+    #
+    #   Vector2d(2.4, 3.6).round # => Vector2d(2,4)
+    #
+    def round
+      self.class.new(x.round, y.round)
+    end
+
+    # Truncates to max length if vector is longer than max.
+    #
+    #   vector = Vector2d(2.0, 3.0)
+    #   vector.truncate(5.0) # => Vector2d(2.0, 3.0)
+    #   vector.truncate(1.0) # => Vector2d(0.5547.., 0.8320..)
+    #
+    def truncate(max)
+      resize([max, self.length].min)
+    end
+  end
+end

data/lib/vector2d/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 class Vector2d
-  VERSION = "1.1.2"
+  VERSION = "2.0.0"
 end

data/spec/lib/vector2d/calculations_spec.rb

@@ -0,0 +1,126 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Vector2d::Calculations do
+  subject(:vector) { Vector2d.new(2, 3) }
+
+  describe ".cross_product" do
+    let(:v1) { Vector2d.new(2, 3) }
+    let(:v2) { Vector2d.new(4, 5) }
+    it "calculates the cross product between two vectors" do
+      expect(Vector2d.cross_product(v1, v2)).to eq(-2.0)
+    end
+  end
+
+  describe ".dot_product" do
+    let(:v1) { Vector2d.new(2, 3) }
+    let(:v2) { Vector2d.new(4, 5) }
+    it "calculates the dot product between two vectors" do
+      expect(Vector2d.dot_product(v1, v2)).to eq(23)
+    end
+  end
+
+  describe ".angle_between" do
+    let(:v1) { Vector2d.new(2, 3) }
+    let(:v2) { Vector2d.new(4, 5) }
+    it "calculates the angle between two vectors" do
+      expect(Vector2d.angle_between(v1, v2)).to be_within(0.0001).of(0.0867)
+    end
+  end
+
+  describe "*" do
+    context "with vector" do
+      subject(:vector) { Vector2d.new(2, 3) * Vector2d.new(3, 4) }
+      it "multiplies the vectors" do
+        expect(vector).to eq(Vector2d.new(6, 12))
+      end
+    end
+    context "with number" do
+      subject(:vector) { Vector2d.new(2, 3) * 3 }
+      it "multiplies both members" do
+        expect(vector).to eq(Vector2d.new(6, 9))
+      end
+    end
+  end
+
+  describe "/" do
+    context "with vector" do
+      subject(:vector) { Vector2d.new(6, 12) / Vector2d.new(2, 3) }
+      it "divides the vectors" do
+        expect(vector).to eq(Vector2d.new(3, 4))
+      end
+    end
+    context "with number" do
+      subject(:vector) { Vector2d.new(6, 12) / 3 }
+      it "divides both members" do
+        expect(vector).to eq(Vector2d.new(2, 4))
+      end
+    end
+  end
+
+  describe "+" do
+    context "with vector" do
+      subject(:vector) { Vector2d.new(2, 3) + Vector2d.new(3, 4) }
+      it "adds the vectors" do
+        expect(vector).to eq(Vector2d.new(5, 7))
+      end
+    end
+    context "with number" do
+      subject(:vector) { Vector2d.new(2, 3) + 2 }
+      it "adds to both members" do
+        expect(vector).to eq(Vector2d.new(4, 5))
+      end
+    end
+  end
+
+  describe "-" do
+    context "with vector" do
+      subject(:vector) { Vector2d.new(3, 5) - Vector2d.new(1, 2) }
+      it "subtracts the vectors" do
+        expect(vector).to eq(Vector2d.new(2, 3))
+      end
+    end
+    context "with number" do
+      subject(:vector) { Vector2d.new(2, 3) - 2 }
+      it "subtracts from both members" do
+        expect(vector).to eq(Vector2d.new(0, 1))
+      end
+    end
+  end
+
+  describe "#cross_product" do
+    let(:comp) { Vector2d.new(3, 4) }
+    it "calulates the cross product" do
+      expect(vector.cross_product(comp)).to eq(Vector2d.cross_product(vector, comp))
+    end
+  end
+
+  describe "#distance" do
+    let(:comp) { Vector2d.new(3, 4) }
+    it "returns the distance between two vectors" do
+      expect(vector.distance(comp)).to be_within(0.0001).of(1.4142)
+    end
+  end
+
+  describe "#squared_distance" do
+    let(:comp) { Vector2d.new(5, 6) }
+    it "returns the squared distance between two vectors" do
+      expect(vector.squared_distance(comp)).to eq(18)
+    end
+  end
+
+  describe "#dot_product" do
+    let(:comp) { Vector2d.new(3, 4) }
+    it "calulates the dot product" do
+      expect(vector.dot_product(comp)).to eq(Vector2d.dot_product(vector, comp))
+    end
+  end
+
+  describe "#angle_between" do
+    let(:comp) { Vector2d.new(3, 4) }
+    it "calculates the angle between vectors" do
+      expect(vector.angle_between(comp)).to eq(Vector2d.angle_between(vector, comp))
+    end
+  end
+end

data/spec/lib/vector2d/coercions_spec.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Vector2d::Coercions do
+  subject(:vector) { Vector2d.new(2, 3) }
+
+  describe "#inspect" do
+    it "renders a string representation" do
+      expect(vector.inspect).to eq("Vector2d(2,3)")
+    end
+  end
+
+  describe "#to_a" do
+    it "returns an array" do
+      expect(vector.to_a).to eq([2, 3])
+    end
+  end
+
+  describe "#to_f_vector" do
+    it "returns a float vector" do
+      expect(vector.to_f_vector.x).to be_a(Float)
+      expect(vector.to_f_vector.y).to be_a(Float)
+    end
+  end
+
+  describe "#to_hash" do
+    it "returns a hash" do
+      expect(vector.to_hash).to eq({x: 2, y: 3})
+    end
+  end
+
+  describe "#to_i_vector" do
+    subject(:vector) { Vector2d.new(2.0, 3.0) }
+    it "returns a fixnum vector" do
+      expect(vector.to_i_vector.x).to be_a(Fixnum)
+      expect(vector.to_i_vector.y).to be_a(Fixnum)
+    end
+  end
+
+  describe "#to_s" do
+    context "when fixnum" do
+      subject(:vector) { Vector2d.new(2, 3) }
+      it "renders a string" do
+        expect(vector.to_s).to eq('2x3')
+      end
+    end
+    context "when float" do
+      subject(:vector) { Vector2d.new(2.0, 3.0) }
+      it "renders a string" do
+        expect(vector.to_s).to eq('2.0x3.0')
+      end
+    end
+  end
+end

data/spec/lib/vector2d/fitting_spec.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Vector2d::Fitting do
+  let(:original) { Vector2d.new(300, 300) }
+
+  describe "#fit" do
+    subject(:vector) { original.fit(comp) }
+
+    context "when scaling by height" do
+      let(:comp) { Vector2d.new(200, 150) }
+      it "should fit within the other vector" do
+        expect(vector.x).to eq(150)
+        expect(vector.y).to eq(150)
+      end
+    end
+
+    context "when scaling by width" do
+      let(:comp) { Vector2d.new(150, 200) }
+      it "should fit within the other vector" do
+        expect(vector.x).to eq(150)
+        expect(vector.y).to eq(150)
+      end
+    end
+  end
+
+  describe "#contrain_one" do
+    let(:original) { Vector2d.new(300, 300) }
+    subject(:vector) { original.fit_either(comp) }
+
+    context "when width is largest" do
+      let(:comp) { Vector2d.new(200, 150) }
+      it "should be the same width" do
+        expect(vector.x).to eq(200)
+        expect(vector.y).to eq(200)
+      end
+    end
+
+    context "when height is largest" do
+      let(:comp) { Vector2d.new(150, 200) }
+      it "should be the same height" do
+        expect(vector.x).to eq(200)
+        expect(vector.y).to eq(200)
+      end
+    end
+  end
+end