vector2d 1.1.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 682557f0f29ae91579f654ea0d158b294f34842a
-  data.tar.gz: 3c06461f5a55f84d40c2d9a6ccaeb2c588180b5e
+  metadata.gz: 1406edfe102d42ed1f904b284c2d60a3fb7ab377
+  data.tar.gz: ad834281b90b577cb6b9d5e392cd27d8aed630cf
 SHA512:
-  metadata.gz: be219090e10f35d43eee02aafb26008dac0763cc206d748e51169eff6f5d208a8afbb058e489f150584828ee2b58abb665595514bec5562d12fbe2f5ae69ed6a
-  data.tar.gz: 46aba4ea456801fe4cf7403a431ef3a754424623004faec67b7c9290042af806dbd8195c6c67bcd70d9f01560228793a8938a5e9474e1c292eb35dd99946551f
+  metadata.gz: f5894c2e97725decc4e019eef6fa43b597ab4e5349e09fd036d516763d687eac3d9d9c882cfc785ff6cfcf1f9f5cf1d50a73eb4f7afb3e84f24619cdd23f79bd
+  data.tar.gz: 82bb98f6236e474dffc947c5ea8a95c52bb94d92c0e885cf95886129242b7e13fa4947042571ee3bc362b0414570c7ba95c8268971e3fdf21c8caa7d1e9172d0

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.2
+script:
+  - bundle exec rspec spec

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    vector2d (1.1.2)
+    vector2d (2.0.0)
 
 GEM
   remote: http://rubygems.org/

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2006 Inge Jørgensen
+Copyright (c) 2006-2014 Inge Jørgensen
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -0,0 +1,29 @@
+# Vector2d [![Build Status](https://travis-ci.org/elektronaut/vector2d.png)](https://travis-ci.org/elektronaut/vector2d) [![Code Climate](https://codeclimate.com/github/elektronaut/vector2d.png)](https://codeclimate.com/github/elektronaut/vector2d)
+
+Vector2d handles two-dimensional coordinates and vectors.
+Vectors are immutable, meaning this is a purely functional library.
+
+## Quick example
+
+    require 'vector2d'
+
+    vector = Vector2d(50, 70)
+
+    vector.aspect_ratio        # => 0.714285714285714
+    vector.length              # => 86.0232526704263
+
+    vector * 2                 # => Vector2d(140,100)
+    vector + Vector2d(20, 30)  # => Vector2d(100,70)
+
+    vector.fit(Vector(64, 64)) # => Vector2d(64,45)
+
+    Vector2d.parse([50, 70])   # => Vector2d(50,70)
+    Vector2d.parse("50x70")    # => Vector2d(50,70)
+
+## Documentation
+
+[API documentation](http://rdoc.info/github/elektronaut/vector2d)
+
+## License
+
+Vector2d is released under the [MIT License](http://www.opensource.org/licenses/MIT).

data/lib/vector2d.rb

@@ -1,238 +1,92 @@
 # encoding: utf-8
 
-# Vector2d allows for easy handling of two-dimensionals coordinates and vectors.
-# It's very flexible, most methods accepts arguments as strings, arrays, hashes
-# or Vector2d objects.
-class Vector2d
-
-  # X axis
-  attr_accessor :x
-  # Y axis
-  attr_accessor :y
+require 'vector2d/calculations'
+require 'vector2d/coercions'
+require 'vector2d/fitting'
+require 'vector2d/properties'
+require 'vector2d/transformations'
+require 'vector2d/version'
 
-  # Creates a new vector.
-  # The following examples are all valid:
-  #
-  #   Vector2d.new(150, 100)
-  #   Vector2d.new(150.0, 100.0)
-  #   Vector2d.new("150x100")
-  #   Vector2d.new("150.0x100.0")
-  #   Vector2d.new([150,100})
-  #   Vector2d.new({:x => 150, :y => 100})
-  #   Vector2d.new({"x" => 150.0, "y" => 100.0})
-  #   Vector2d.new(Vector2d.new(150, 100))
-  def initialize(*args)
-    args.flatten!
-    if (args.length == 1)
-      if (args[0].kind_of?(String) && args[0].match(/^[\s]*[\d\.]*[\s]*x[\s]*[\d\.]*[\s]*$/))
-        args = args[0].split("x")
-      elsif args[0].kind_of?(Vector2d)
-        args = [args[0].x, args[0].y]
-      elsif args[0].kind_of?(Hash)
-        if args[0].has_key?(:y)
-          args[1] = args[0][:y]
-        elsif args[0].has_key?("y")
-          args[1] = args[0]["y"]
-        end
-        if args[0].has_key?(:x)
-          args[0] = args[0][:x]
-        elsif args[0].has_key?("x")
-          args[0] = args[0]["x"]
-        end
+class Vector2d
+  extend Vector2d::Calculations::ClassMethods
+  include Vector2d::Calculations
+  include Vector2d::Coercions
+  include Vector2d::Fitting
+  include Vector2d::Properties
+  include Vector2d::Transformations
+
+  class << self
+    # Creates a new vector.
+    # The following examples are all valid:
+    #
+    #   Vector2d.parse(150, 100)
+    #   Vector2d.parse(150.0, 100.0)
+    #   Vector2d.parse("150x100")
+    #   Vector2d.parse("150.0x100.0")
+    #   Vector2d.parse([150,100})
+    #   Vector2d.parse({x: 150, y: 100})
+    #   Vector2d.parse({"x" => 150.0, "y" => 100.0})
+    #   Vector2d.parse(Vector2d(150, 100))
+    def parse(arg, second_arg=nil)
+      if second_arg.nil?
+        parse_single_arg(arg)
       else
-        args = [args[0], args[0]]
+        self.new(arg, second_arg)
       end
     end
-    @x, @y = args[0].to_f, args[1].to_f
-  end
-
-  # Compares two vectors.
-  def ==(comp)
-    comp.x == @x && comp.y == y
-  end
-
-  # Returns a string representation of the vector.
-  #
-  # Example:
-  #   Vector2d.new( 150, 100 ).to_s  # "150x100"
-  def to_s
-    "#{@x}x#{@y}"
-  end
-
-  # Length of vector
-  def length
-    Math.sqrt(length_squared)
-  end
-
-  # Returns the length of this vector before square root. Allows for a faster check.
-  def length_squared
-    @x * @x + @y * @y
-  end
-
-  # Set new length.
-  def length=(new_length)
-    v = self * (new_length/length)
-    @x, @y = v.x, v.y
-  end
-
-  # Returns a normalized (length = 1.0) version of the vector.
-  def normalize
-    self.dup.normalize!
-  end
-
-  # In-place form of Vector2d.normalize.
-  def normalize!
-    self.length = 1.0
-    self
-  end
-
-  def normalized?
-    self.length == 1.0
-  end
-
-  # Rounds coordinates to nearest integer.
-  def round
-    self.dup.round!
-  end
-
-  # In-place form of Vector2d.round.
-  def round!
-    @x, @y = @x.round, @y.round
-    self
-  end
 
-  # Returns the aspect ratio of the vector.
-  def aspect_ratio
-    (@x/@y).abs
-  end
-
-  # Multiply vectors. If args is a single Numeric, both axis will be multiplied.
-  def *(*vector_or_number)
-    v = Vector2d::new(vector_or_number)
-    Vector2d.new(@x*v.x, @y*v.y)
-  end
-
-  # Divide vectors. If args is a single Numeric, both axis will be divided.
-  def /(*vector_or_number)
-    v = Vector2d::new(vector_or_number)
-    Vector2d.new(@x/v.x, @y/v.y)
-  end
-
-  # Add vectors. If args is a single Numeric, it will be added to both axis.
-  def +(*vector_or_number)
-    v = Vector2d::new(vector_or_number)
-    Vector2d.new(@x+v.x, @y+v.y)
-  end
-
-  # Subtract vectors. If args is a single Numeric, it will be subtracted from both axis.
-  def -(*vector_or_number)
-    v = Vector2d::new(vector_or_number)
-    Vector2d.new(@x-v.x, @y-v.y)
-  end
-
-  # return a new vector perpendicular to this one
-  def perpendicular
-    Vector2d.new(-@y, @x)
-  end
-
-  # distance between two vectors
-  def distance(vector2)
-    Math.sqrt(distance_sq(vector2))
-  end
-
-  # Calculate squared distance between vectors. Faster than standard distance.
-  # param vector2 The other vector.
-  # returns the squared distance between the vectors.
-  def distance_sq(vector2)
-    dx = vector2.x - @x
-    dy = vector2.y - @y
-    dx * dx + dy * dy
-  end
-
-  # angle of this vector
-  def angle
-    Math.atan2(@y, @x)
-  end
-
-  # sets the length under the given value. Nothing is done if
-  # the vector is already shorter.
-  def truncate(max)
-    self.length = [max, self.length].min
-    self
-  end
-
-  # Makes the vector face the opposite way.
-  def reverse
-    @x = -@x
-    @y = -@y
-    self
-  end
-
-  # dot product of this vector and another vector
-  def dot_product(vector2)
-    self.class.dot_product(self, vector2)
-  end
-
-  # cross product of this vector and another vector
-  def cross_product(vector2)
-    self.class.cross_product(self, vector2)
-  end
-
-  # angle in radians between this vector and another
-  def angle_between(vector2)
-    self.class.angle_between(self, vector2)
-  end
+    private
+
+    def parse_single_arg(arg)
+      case arg
+      when Vector2d
+        arg
+      when Array
+        self.parse(*arg)
+      when String
+        parse_str(arg)
+      when Hash
+        parse_hash(arg.dup)
+      else
+        self.new(arg, arg)
+      end
+    end
 
-  # cross product of two vectors
-  def self.cross_product(vector1, vector2)
-    vector1.x * vector2.y - vector1.y * vector2.x
-  end
+    def parse_hash(hash)
+      hash[:x] ||= hash['x'] if hash.has_key?('x')
+      hash[:y] ||= hash['y'] if hash.has_key?('y')
+      self.new(hash[:x], hash[:y])
+    end
 
-  # dot product of two vectors
-  def self.dot_product(vector1, vector2)
-    vector1.x * vector2.x + vector1.y * vector2.y
+    def parse_str(str)
+      if str =~ /^[\s]*[\d\.]*[\s]*x[\s]*[\d\.]*[\s]*$/
+        self.new(*str.split("x").map(&:to_f))
+      else
+        raise ArgumentError, "not a valid string input"
+      end
+    end
   end
 
-  # angle between two vectors in radians
-  def self.angle_between(vector1, vector2)
-    one = vector1.normalized? ? vector1 : vector1.normalize
-    two = vector2.normalized? ? vector2 : vector2.normalize
-    Math.acos(self.dot_product(one, two))
-  end
+  attr_reader :x, :y
 
-  # Constrain/expand so that both coordinates fit within (the square implied by) another vector.
-  # This is useful for resizing images to fit a certain size while keeping aspect ratio.
-  #
-  # == Examples
-  #
-  #   my_image = Vector2d.new("320x200")  # Creates a new vector object
-  #   my_image.constrain_both(100)        # Returns a new vector: x=100, y=63
-  #   my_image.constrain_both(150, 50)    # Returns a new vector: x=80, y=50
-  #   my_image.constrain_both("150x50")   # Equal to constrain_both( 150, 50 )
-  #   my_image.constrain_both("x100")     # Returns a new vector: x=160, y=100
-  #
-  # == Note
-  #
-  # Either axis will be disregarded if zero or nil (see the last example). This is a feature, not a bug. ;)
-  def constrain_both(*vector_or_number)
-    scale = Vector2d::new(vector_or_number) / self
-    (self * ((scale.y==0||(scale.x>0&&scale.x<scale.y)) ? scale.x : scale.y))
+  def initialize(x, y)
+    @x, @y = x, y
   end
 
-  # Constrain/expand so that one of the coordinates fit within (the square implied by) another vector.
+  # Compares two vectors
   #
-  # == Example
+  #   Vector2d(2, 3) == Vector2d(2, 3) # => true
+  #   Vector2d(2, 3) == Vector2d(1, 0) # => false
   #
-  #   my_image = Vector2d.new("320x200")  # Creates a new vector object
-  #   my_image.constrain_one(100, 100)    # Returns a new vector: x=160, y=100
-  def constrain_one( *vector_or_number )
-    scale = Vector2d::new(vector_or_number) / self
-    if (scale.x > 0 && scale.y > 0)
-      scale = (scale.x<scale.y) ? scale.y : scale.x
-      self * scale
-    else
-      constrain_both(vector_or_number)
-    end
+  def ==(comp)
+    comp.x === x && comp.y === y
   end
-
 end
+
+# Instantiates a Vector2d
+#
+#   Vector2d(2, 3) # => Vector2d(2,3)
+#
+def Vector2d(*args)
+  Vector2d.parse(*args)
+end

data/lib/vector2d/calculations.rb

@@ -0,0 +1,141 @@
+# encoding: utf-8
+
+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(self.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