vector2d 2.2.4 → 3.0.0

data/lib/vector2d/calculations.rb

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-
-class Vector2d
-  module Calculations
-    module ClassMethods
-      # Calculates cross product of two vectors.
-      #
-      #   v1 = Vector2d(2, 1)
-      #   v2 = Vector2d(2, 3)
-      #   Vector2d.cross_product(v1, v2) # => 4
-      #
-      def cross_product(vector1, vector2)
-        (vector1.x * vector2.y) - (vector1.y * vector2.x)
-      end
-
-      # Calculates dot product of two vectors.
-      #
-      #   v1 = Vector2d(2, 1)
-      #   v2 = Vector2d(2, 3)
-      #   Vector2d.dot_product(v1, v2) # => 10
-      #
-      def dot_product(vector1, vector2)
-        (vector1.x * vector2.x) + (vector1.y * vector2.y)
-      end
-
-      # Calculates angle between two vectors in radians.
-      #
-      #   v1 = Vector2d(2, 3)
-      #   v2 = Vector2d(4, 5)
-      #   Vector2d.angle_between(v1, v2) # => 0.0867..
-      #
-      def angle_between(vector1, vector2)
-        one = vector1.normalized? ? vector1 : vector1.normalize
-        two = vector2.normalized? ? vector2 : vector2.normalize
-        Math.acos(dot_product(one, two))
-      end
-    end
-
-    # Multiplies vectors.
-    #
-    #   Vector2d(1, 2) * Vector2d(2, 3) # => Vector2d(2, 6)
-    #   Vector2d(1, 2) * 2              # => Vector2d(2, 4)
-    #
-    def *(other)
-      calculate_each(:*, other)
-    end
-
-    # Divides vectors.
-    #
-    #   Vector2d(4, 2) / Vector2d(2, 1) # => Vector2d(2, 2)
-    #   Vector2d(4, 2) / 2              # => Vector2d(2, 1)
-    #
-    def /(other)
-      calculate_each(:/, other)
-    end
-
-    # Adds vectors.
-    #
-    #   Vector2d(1, 2) + Vector2d(2, 3) # => Vector2d(3, 5)
-    #   Vector2d(1, 2) + 2              # => Vector2d(3, 4)
-    #
-    def +(other)
-      calculate_each(:+, other)
-    end
-
-    # Subtracts vectors.
-    #
-    #   Vector2d(2, 3) - Vector2d(2, 1) # => Vector2d(0, 2)
-    #   Vector2d(4, 3) - 1              # => Vector2d(3, 2)
-    #
-    def -(other)
-      calculate_each(:-, other)
-    end
-
-    # Calculates the distance between two vectors.
-    #
-    #   v1 = Vector2d(2, 3)
-    #   v2 = Vector2d(5, 6)
-    #   v1.distance(v2) # => 1.4142..
-    #
-    def distance(other)
-      Math.sqrt(squared_distance(other))
-    end
-
-    # Calculate squared distance between vectors.
-    #
-    #   v1 = Vector2d(2, 3)
-    #   v2 = Vector2d(5, 6)
-    #   v1.distance_squared(v2) # => 18
-    #
-    def squared_distance(other)
-      v, = coerce(other)
-      dx = v.x - x
-      dy = v.y - y
-      (dx * dx) + (dy * dy)
-    end
-
-    # Dot product of this vector and another vector.
-    #
-    #   v1 = Vector2d(2, 1)
-    #   v2 = Vector2d(2, 3)
-    #   v1.dot_product(v2) # => 10
-    #
-    def dot_product(other)
-      v, = coerce(other)
-      self.class.dot_product(self, v)
-    end
-
-    # Cross product of this vector and another vector.
-    #
-    #   v1 = Vector2d(2, 1)
-    #   v2 = Vector2d(2, 3)
-    #   v1.cross_product(v2) # => 4
-    #
-    def cross_product(other)
-      v, = coerce(other)
-      self.class.cross_product(self, v)
-    end
-
-    # Angle in radians between this vector and another vector.
-    #
-    #   v1 = Vector2d(2, 3)
-    #   v2 = Vector2d(4, 5)
-    #   v1.angle_between(v2) # => 0.0867..
-    #
-    def angle_between(other)
-      v, = coerce(other)
-      self.class.angle_between(self, v)
-    end
-
-    private
-
-    def calculate_each(method, other)
-      v, = coerce(other)
-      self.class.new(
-        x.send(method, v.x),
-        y.send(method, v.y)
-      )
-    end
-  end
-end

data/lib/vector2d/coercions.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-class Vector2d
-  module Fitting
-    # Scales down the given vector unless it fits inside.
-    #
-    #   vector = Vector2d(20, 20)
-    #   vector.contain(Vector2d(10, 10)) # => Vector2d(10,10)
-    #   vector.contain(Vector2d(40, 20)) # => Vector2d(20,10)
-    #   vector.contain(Vector2d(20, 40)) # => Vector2d(10,20)
-    #
-    def contain(other)
-      v, = coerce(other)
-      v.x > x || v.y > y ? other.fit(self) : other
-    end
-
-    # Scales the vector to fit 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 * (
-        if scale.y.zero? || (scale.x.positive? && scale.x < scale.y)
-          scale.x
-        else
-          scale.y
-        end
-      )
-    end
-    alias 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.positive? && scale.y.positive?
-        scale = [scale.x, scale.y].max
-        self * scale
-      else
-        fit(v)
-      end
-    end
-    alias constrain_one fit_either
-  end
-end

data/lib/vector2d/properties.rb

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

data/lib/vector2d/transformations.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-class Vector2d
-  module Transformations
-    # Rounds vector to up nearest integer.
-    #
-    #   Vector2d(2.4, 3.6).ceil # => Vector2d(3,4)
-    #
-    def ceil
-      self.class.new(x.ceil, y.ceil)
-    end
-
-    # Rounds vector to up nearest integer.
-    #
-    #   Vector2d(2.4, 3.6).floor # => Vector2d(2,3)
-    #
-    def floor
-      self.class.new(x.floor, y.floor)
-    end
-
-    # 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 / length)
-    end
-
-    # Reverses the vector.
-    #
-    #   Vector2d(2, 3).reverse # => Vector2d(-2,-3)
-    #
-    def reverse
-      self.class.new(-x, -y)
-    end
-
-    # Rotates the vector
-    #
-    #   Vector2d(1, 0).rotate(Math:PI/2) => Vector2d(1,0)
-    #
-    def rotate(angle)
-      Vector2d.new(
-        (x * Math.cos(angle)) - (y * Math.sin(angle)),
-        (x * Math.sin(angle)) + (y * Math.cos(angle))
-      )
-    end
-
-    # Rounds vector to nearest integer.
-    #
-    #   Vector2d(2.4, 3.6).round # => Vector2d(2,4)
-    #   Vector2d(2.4444, 3.666).round(2) # => Vector2d(2.44, 3.67)
-    #
-    def round(digits = 0)
-      self.class.new(x.round(digits), y.round(digits))
-    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, length].min)
-    end
-  end
-end

data/spec/lib/vector2d/coercions_spec.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-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
-    subject { vector.to_f_vector }
-
-    its(:x) { is_expected.to be_a(Float) }
-    its(:y) { is_expected.to be_a(Float) }
-  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.to_i_vector }
-
-    let(:vector) { Vector2d.new(2.0, 3.0) }
-
-    its(:x) { is_expected.to be_a(Integer) }
-    its(:y) { is_expected.to be_a(Integer) }
-  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

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe Vector2d::Fitting do
-  let(:original) { Vector2d.new(300, 300) }
-
-  describe "#contain" do
-    subject(:vector) { original.contain(comp) }
-
-    context "when vector is smaller" do
-      let(:comp) { Vector2d.new(150, 100) }
-
-      its(:x) { is_expected.to eq(150) }
-      its(:y) { is_expected.to eq(100) }
-    end
-
-    context "when vector is wider" do
-      let(:comp) { Vector2d.new(400, 300) }
-
-      its(:x) { is_expected.to eq(300) }
-      its(:y) { is_expected.to eq(225) }
-    end
-
-    context "when vector is higher" do
-      let(:comp) { Vector2d.new(300, 400) }
-
-      its(:x) { is_expected.to eq(225) }
-      its(:y) { is_expected.to eq(300) }
-    end
-  end
-
-  describe "#fit" do
-    subject(:vector) { original.fit(comp) }
-
-    context "when scaling by height" do
-      let(:comp) { Vector2d.new(200, 150) }
-
-      its(:x) { is_expected.to eq(150) }
-      its(:y) { is_expected.to eq(150) }
-    end
-
-    context "when scaling by width" do
-      let(:comp) { Vector2d.new(150, 200) }
-
-      its(:x) { is_expected.to eq(150) }
-      its(:y) { is_expected.to eq(150) }
-    end
-  end
-
-  describe "#fit_either" do
-    subject(:vector) { original.fit_either(comp) }
-
-    let(:original) { Vector2d.new(300, 300) }
-
-    context "when width is largest" do
-      let(:comp) { Vector2d.new(200, 150) }
-
-      its(:x) { is_expected.to eq(200) }
-      its(:y) { is_expected.to eq(200) }
-    end
-
-    context "when height is largest" do
-      let(:comp) { Vector2d.new(150, 200) }
-
-      its(:x) { is_expected.to eq(200) }
-      its(:y) { is_expected.to eq(200) }
-    end
-  end
-end

data/spec/lib/vector2d/properties_spec.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe Vector2d::Properties do
-  subject(:vector) { Vector2d.new(2, 3) }
-
-  describe "#angle" do
-    it "returns the angle" do
-      expect(vector.angle).to be_within(0.0001).of(0.9827)
-    end
-  end
-
-  describe "#aspect_ratio" do
-    it "returns the aspect_ratio" do
-      expect(vector.aspect_ratio).to be_within(0.0001).of(0.6667)
-    end
-  end
-
-  describe "#length" do
-    it "calculates the length" do
-      expect(vector.length).to be_within(0.0001).of(3.6055)
-    end
-  end
-
-  describe "#squared_length" do
-    it "calculates the squared length" do
-      expect(vector.squared_length).to eq(13)
-    end
-  end
-
-  describe "#normalized?" do
-    subject { vector.normalized? }
-
-    context "when vector is normalized" do
-      let(:vector) { Vector2d.new(2, 3).normalize }
-
-      it { is_expected.to be(true) }
-    end
-
-    context "when vector isn't normalized" do
-      let(:vector) { Vector2d.new(2, 3) }
-
-      it { is_expected.to be(false) }
-    end
-  end
-end

data/spec/lib/vector2d/transformations_spec.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe Vector2d::Transformations do
-  subject(:vector) { Vector2d.new(2, 3) }
-
-  describe "#ceil" do
-    subject(:vector) { Vector2d.new(2.3, 3.3) }
-
-    it "rounds the vector up" do
-      expect(vector.ceil).to eq(Vector2d.new(3, 4))
-    end
-  end
-
-  describe "#floor" do
-    subject(:vector) { Vector2d.new(2.7, 3.6) }
-
-    it "rounds the vector down" do
-      expect(vector.floor).to eq(Vector2d.new(2, 3))
-    end
-  end
-
-  describe "#normalize" do
-    subject { vector.normalize }
-
-    its(:x) { is_expected.to be_within(0.0001).of(0.5547) }
-    its(:y) { is_expected.to be_within(0.0001).of(0.8320) }
-  end
-
-  describe "#perpendicular" do
-    it "returns a perpendicular vector" do
-      expect(vector.perpendicular).to eq(Vector2d.new(-3, 2))
-    end
-  end
-
-  describe "#resize" do
-    subject(:resized) { vector.resize(2.0) }
-
-    it "modifies the vector length" do
-      expect(resized.length).to be_within(0.0001).of(2.0)
-    end
-
-    it "modifies the x property" do
-      expect(resized.x).to be_within(0.0001).of(1.1094)
-    end
-
-    it "modifies the y property" do
-      expect(resized.y).to be_within(0.0001).of(1.6641)
-    end
-  end
-
-  describe "#reverse" do
-    it "reverses the vector" do
-      expect(vector.reverse).to eq(Vector2d.new(-2, -3))
-    end
-  end
-
-  describe "#rotate" do
-    subject { vector.rotate(rotation).round(3) }
-
-    let(:vector) { Vector2d.new(1, 0) }
-
-    context "when roating by PI" do
-      let(:rotation) { Math::PI }
-
-      it { is_expected.to eq(Vector2d.new(-1, 0)) }
-    end
-
-    context "when roating by PI/2" do
-      let(:rotation) { Math::PI / 2 }
-
-      it { is_expected.to eq(Vector2d.new(0, 1)) }
-    end
-
-    context "when roating by -PI/2" do
-      let(:rotation) { -Math::PI / 2 }
-
-      it { is_expected.to eq(Vector2d.new(0, -1)) }
-    end
-
-    context "when roating by PI/4" do
-      let(:rotation) { Math::PI / 4 }
-
-      it { is_expected.to eq(Vector2d.new(0.707, 0.707)) }
-    end
-  end
-
-  describe "#round" do
-    let(:vector) { Vector2d.new(2.3333, 3.666) }
-
-    context "without argument" do
-      subject { vector.round }
-
-      it { is_expected.to eq(Vector2d.new(2, 4)) }
-    end
-
-    context "with precision" do
-      subject { vector.round(2) }
-
-      it { is_expected.to eq(Vector2d.new(2.33, 3.67)) }
-    end
-  end
-
-  describe "#truncate" do
-    context "when argument is longer than length" do
-      let(:arg) { 5.0 }
-
-      it "does not change the length" do
-        expect(vector.truncate(arg).length).to be_within(0.0001).of(3.6055)
-      end
-    end
-
-    context "when argument is shorter than length" do
-      let(:arg) { 2.5 }
-
-      it "changes the length" do
-        expect(vector.truncate(arg).length).to be_within(0.0001).of(arg)
-      end
-    end
-  end
-end