euclidean 0.1.0

data/lib/euclidean/size.rb

@@ -0,0 +1,78 @@
+require 'matrix'
+
+module Euclidean
+=begin
+An object representing the size of something.
+
+Supports all of the familiar {Vector} methods as well as a few convenience
+methods (width, height and depth).
+
+== Usage
+
+=== Constructor
+   size = Geometry::Size[x,y,z]
+=end
+
+  class Size < Vector
+    attr_reader :x, :y, :z
+
+    # Allow vector-style initialization, but override to support copy-init
+    # from Vector, Point or another Size
+    #
+    # @overload [](x,y,z,...)
+    # @overload [](Point)
+    # @overload [](Size)
+    # @overload [](Vector)
+    # @return [Size]    A new {Size} object
+    def self.[](*array)
+      array = array[0].to_a unless array[0].is_a?(Numeric)
+      super *array
+    end
+
+    # Allow comparison with an Array, otherwise do the normal thing
+    def ==(other)
+      return @elements == other if other.is_a?(Array)
+      super other
+    end
+
+    # @return [Number]  The size along the Z axis
+    def depth
+      z
+    end
+
+    # @return [Number]  The size along the Y axis
+    def height
+      y
+    end
+
+    def inspect
+      'Size' + @elements.inspect
+    end
+
+    def to_s
+      'Size' + @elements.to_s
+    end
+
+    # @return [Number]  The size along the X axis
+    def width
+      x
+    end
+
+    # @return [Number] X-component (width)
+    def x
+      @elements[0]
+    end
+
+    # @return [Number] Y-component (height)
+    def y
+      @elements[1]
+    end
+
+    # @return [Number] Z-component (depth)
+    def z
+      @elements[2]
+    end
+
+  end
+  
+end

data/lib/euclidean/vector.rb

@@ -0,0 +1,34 @@
+require 'matrix'
+
+# Monkeypatch Vector to overcome some deficiencies
+class Vector
+  X = Vector[1,0,0]
+  Y = Vector[0,1,0]
+  Z = Vector[0,0,1]
+
+  # @group Unary operators
+  def +@
+    self
+  end
+
+  def -@
+    Vector[*(@elements.map {|e| -e })]
+  end
+  # @endgroup
+
+  # Cross-product of two {Vector}s
+  # @return [Vector]
+  def cross(other)
+    Vector.Raise ErrDimensionMismatch unless @elements.size == other.size
+
+    case @elements.size
+    when 0 then raise ArgumentError, "Can't multply zero-length Vectors"
+    when 1 then @elements.first * other.first
+    when 2 then @elements.first * other[1] - @elements.last * other.first
+    when 3 then Vector[ @elements[1]*other[2] - @elements[2]*other[1],
+  		@elements[2]*other[0] - @elements[0]*other[2],
+  		@elements[0]*other[1] - @elements[1]*other[0]]
+    end
+  end
+  alias ** cross
+end

data/lib/euclidean/version.rb

@@ -0,0 +1,3 @@
+module Euclidean
+  VERSION = "0.1.0"
+end

data/spec/euclidean/circle_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+require 'euclidean/circle'
+
+describe Euclidean::Circle do
+  Circle     = Euclidean::Circle
+  Point      = Euclidean::Point
+  Rectangle  = Euclidean::Rectangle
+
+  context "When contstructed with center and radius arguments" do
+    let(:circle) { Circle.new [1,2], 3 }
+
+    it "must create a Circle" do
+      expect(circle).to be_an_instance_of Circle
+    end
+
+    it "must have a center point accessor" do
+      expect(circle.center).to eq Point[1,2]
+    end
+
+    it "must have a radius accessor" do
+      expect(circle.radius).to eq 3
+    end
+
+    it "must compare equal" do
+      expect(circle).to eq Circle.new([1,2], 3)
+    end
+  end
+
+  context "When constructed with named center and radius arguments" do
+    let(:circle) { Circle.new :center => [1,2], :radius => 3 }
+
+    it "must create a Circle" do
+      expect(circle).to be_an_instance_of Euclidean::Circle
+    end
+
+    it "must have a center point accessor" do
+      expect(circle.center).to eq Point[1,2]
+    end
+
+    it "must have a radius accessor" do
+      expect(circle.radius).to eq 3
+    end
+
+    it "must compare equal" do
+      expect((circle == Circle.new(:center => [1,2], :radius => 3))).to eq true
+    end
+  end
+
+  context "When constructed with named center and diameter arguments" do
+    let(:circle) { Circle.new center:[1,2], diameter:4 }
+
+    it "must be a CenterDiameterCircle" do
+      expect(circle).to be_an_instance_of Euclidean::CenterDiameterCircle
+      expect(circle).to be_a_kind_of Euclidean::Circle
+    end
+
+    it "must have a center" do
+      expect(circle.center).to eq Point[1,2]
+    end
+
+    it "must have a diameter" do
+      expect(circle.diameter).to eq 4
+    end
+
+    it "must calculate the correct radius" do
+      expect(circle.radius).to eq 2
+    end
+
+    it "must compare equal" do
+      expect(circle).to eq Circle.new([1,2], :diameter => 4)
+    end
+  end
+
+  context "When constructed with a diameter and no center" do
+    let(:circle) { Circle.new :diameter => 4 }
+
+    it "must be a CenterDiameterCircle" do
+      expect(circle).to be_an_instance_of Euclidean::CenterDiameterCircle
+      expect(circle).to be_a_kind_of Euclidean::Circle
+    end
+
+    it "must have a nil center" do
+      expect(circle.center).to be_a_kind_of Euclidean::PointZero
+    end
+
+    it "must have a diameter" do
+      expect(circle.diameter).to eq 4
+    end
+
+    it "must calculate the correct radius" do
+      expect(circle.radius).to eq 2
+    end
+  end
+
+  describe "Properties" do
+    subject { Circle.new center:[1,2], :diameter => 4 }
+
+    it "must have a bounds property that returns a Rectangle" do
+      expect(subject.bounds).to eq Rectangle.new([-1,0], [3,4])
+    end
+
+    it "must have a minmax property that returns the corners of the bounding rectangle" do
+      expect(subject.minmax).to eq [Point[-1,0], Point[3,4]]
+    end
+
+    it "must have a max property that returns the upper right corner of the bounding rectangle" do
+      expect(subject.max).to eq Point[3,4]
+    end
+
+    it "must have a min property that returns the lower left corner of the bounding rectangle" do
+      expect(subject.min).to eq Point[-1,0]
+    end
+  end
+
+end

data/spec/euclidean/edge_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+require 'euclidean/edge'
+
+describe Euclidean::Edge do
+  Edge = Euclidean::Edge
+  subject { Edge.new [0,0], [1,1] }
+
+  it "must create an Edge object" do
+    edge = Edge.new([0,0], [1,0])
+    expect(edge).to be_a_kind_of Euclidean::Edge
+    expect(edge.first).to eq Euclidean::Point[0,0]
+    expect(edge.last).to eq Euclidean::Point[1,0]
+  end
+
+  it "must handle equality" do
+    edge1 = Edge.new([1,0], [0,1])
+    edge2 = Edge.new([1,0], [0,1])
+    edge3 = Edge.new([1,1], [5,5])
+    expect(edge1==edge2).to be true
+    expect(edge1==edge3).to be false
+  end
+
+  it "must return the height of the edge" do
+    edge = Edge([0,0], [1,1])
+    expect(edge.height).to eq 1
+  end
+
+  it "must return the width of the edge" do
+    edge = Edge([0,0], [1,1])
+    expect(edge.width).to eq 1
+  end
+
+  it "must convert an Edge to a Vector" do
+    expect(Edge.new([0,0], [1,0]).vector).to eq Vector[1,0]
+  end
+
+  it "must return the normalized direction of a vector" do
+    expect(Edge.new([0,0], [1,0]).direction).to eq Vector[1,0]
+  end
+
+  it "must return true for parallel edges" do
+    expect( Edge.new([0,0], [1,0]).parallel?(Edge.new([0,0], [1,0])) ).to be true
+    expect( Edge.new([0,0], [1,0]).parallel?(Edge.new([1,0], [2,0])) ).to be true
+    expect( Edge.new([0,0], [1,0]).parallel?(Edge.new([3,0], [4,0])) ).to be true
+    expect( Edge.new([0,0], [1,0]).parallel?(Edge.new([3,1], [4,1])) ).to be true
+  end
+
+  it "must return false for non-parallel edges" do
+    expect( Edge.new([0,0], [2,0]).parallel?(Edge.new([1,-1], [1,1])) ).to be false
+  end
+
+  it "must clone and reverse" do
+    reversed = subject.reverse
+    expect(reversed.to_a).to eq subject.to_a.reverse
+    expect(reversed==subject).to be false
+  end
+
+  it "must reverse itself" do
+    original = subject.to_a
+    subject.reverse!
+    expect(subject.to_a).to eq original.reverse
+  end
+
+  describe "Spaceship" do
+    it "ascending with a Point" do
+      edge = Edge.new [0,0], [1,1]
+      expect(edge <=> Point[0,0]).to eq 0
+      expect(edge <=> Point[1,0]).to eq -1
+      expect(edge <=> Point[0,1]).to eq 1
+      expect(edge <=> Point[2,2]).to be_nil
+    end
+
+    it "descending with a Point" do
+      edge = Edge.new [1,1], [0,0]
+      expect(edge <=> Point[0,0]).to eq 0
+      expect(edge <=> Point[1,0]).to eq 1
+      expect(edge <=> Point[0,1]).to eq -1
+      expect(edge <=> Point[2,2]).to be_nil
+    end
+  end
+
+  describe "Intersection" do
+    it "must find the intersection of two end-intersecting Edges" do
+      intersection = Edge.new([0,0],[1,1]).intersection(Edge.new([0,1],[1,1]))
+      expect(intersection).to be_a_kind_of Euclidean::Point
+      expect(intersection).to eq Euclidean::Point[1,1]
+    end
+
+    it "must find the intersection of two collinear end-intersecting Edges" do
+      intersection = Edge.new([2,2], [0,2]).intersection(Edge.new([3,2], [2,2]))
+      expect(intersection).to be_a_kind_of Euclidean::Point
+      expect(intersection).to eq Euclidean::Point[2,2]
+
+      intersection = Edge.new([0,2], [2,2]).intersection(Edge.new([2,2], [3,2]))
+      expect(intersection).to be_a_kind_of Euclidean::Point
+      expect(intersection).to eq Euclidean::Point[2,2]
+    end
+
+    it "must find the itersection of two crossed Edges" do
+      edge1 = Edge.new [0.0, 0], [2.0, 2.0]
+      edge2 = Edge.new [2.0, 0], [0.0, 2.0]
+      intersection = edge1.intersection edge2
+      expect(intersection).to be_a_kind_of Euclidean::Point
+      expect(intersection).to eq Euclidean::Point[1,1]
+    end
+
+    it "must return nil for two edges that do not intersect" do
+      expect( Edge.new([0,0],[1,0]).intersection(Edge.new([0,1],[1,1])) ).to be_nil
+    end
+
+    it "must return true for two collinear and overlapping edges" do
+      expect( Edge.new([0,0],[2,0]).intersection(Edge.new([1,0],[3,0])) ).to be true
+    end
+
+    it "must return false for collinear but non-overlapping edges" do
+      expect( Edge.new([0,0],[2,0]).intersection(Edge.new([3,0],[4,0])) ).to be false
+      expect( Edge.new([0,0],[0,2]).intersection(Edge.new([0,3],[0,4])) ).to be false
+    end
+
+    it "must return nil for two parallel but not collinear edges" do
+      expect( Edge.new([0,0],[2,0]).intersection(Edge.new([1,1],[3,1])) ).to be_nil
+    end
+
+    it "must return nil for two perpendicular but not interseting edges" do
+      expect( Edge.new([0, 0], [2, 0]).intersection(Edge.new([3, 3], [3, 1])) ).to be_nil
+    end
+  end
+
+end

data/spec/euclidean/point_spec.rb

@@ -0,0 +1,264 @@
+require 'spec_helper'
+require 'euclidean/point'
+
+describe Euclidean::Point do
+  PointZero = Euclidean::PointZero
+  Point     = Euclidean::Point
+
+  it "must generate a PointZero" do
+    expect(Point.zero).to be_an_instance_of(PointZero)
+  end
+
+  it "must generate a Point full of zeros" do
+    expect( Point.zero(3) ).to eq Point[0,0,0]
+  end
+
+  describe "constructor" do
+    it "must return the Point when constructed from a Point" do
+      original_point = Point[3,4]
+      point = Point[original_point]
+      expect( point ).to eq original_point
+      expect( point.size ).to eq 2
+      expect( point.x ).to eq 3
+      expect( point.y ).to eq 4
+    end
+
+    it "must return the PointZero when constructed from a PointZero" do
+      original_point = PointZero.new
+      point = Point[original_point]
+      expect( point ).to eq original_point
+    end
+  end
+
+  it "create a Point object from an array" do
+    point = Point[[3,4]]
+    expect(point.size).to eq 2
+    expect(point.x).to eq 3
+    expect(point.y).to eq 4
+  end
+
+  it "create a Point object from individual parameters" do
+    point = Point[3,4]
+    expect(point.size).to eq 2
+    expect(point.x).to eq 3
+    expect(point.y).to eq 4
+  end
+
+  it "create a Point object from a Vector" do
+    point = Point[Vector[3,4]]
+    expect(point.size).to eq 2
+    expect(point.x).to eq 3
+    expect(point.y).to eq 4
+  end
+
+  it "create a Point object from a Point using list syntax" do
+    point = Point[Point[13,14]]
+    expect(point.size).to eq 2
+    expect(point.x).to eq 13
+    expect(point.y).to eq 14
+  end
+
+  it "allow indexed element access" do
+    point = Point[5,6]
+    expect(point.size).to eq 2
+    expect(point[0]).to eq 5
+    expect(point[1]).to eq 6
+  end
+
+  it "allow named element access" do
+    point = Point[5,6,7]
+    expect(point.size).to eq 3
+    expect(point.x).to eq 5
+    expect(point.y).to eq 6
+    expect(point.z).to eq 7
+  end
+
+  it "implement inspect" do
+    point = Point[8,9]
+    expect(point.inspect).to eq 'Point[8, 9]'
+  end
+
+  it "implement to_s" do
+    point = Point[10,11]
+    expect(point.to_s).to eq 'Point[10, 11]'
+  end
+
+  it "must support array access" do
+    expect( Point[1,2][0] ).to eq 1
+    expect( Point[1,2][1] ).to eq 2
+    expect( Point[1,2][2] ).to eq nil
+  end
+
+  it "must clone" do
+    expect(Point[1,2].clone).to be_an_instance_of(Point)
+    expect( Point[1,2].clone ).to eq Point[1,2]
+  end
+
+  it "must duplicate" do
+    expect(Point[1,2].dup).to be_an_instance_of(Point)
+    expect( Point[1,2].dup ).to eq Point[1,2]
+  end
+
+  describe "Artrithmetic" do
+    let(:left) { Point[1,2] }
+    let(:right) { Point[3,4] }
+
+    it "must have +@" do
+      expect(+left).to eq Point[1,2]
+      expect(+left).to be_an_instance_of(Point)
+    end
+
+    it "must have unary negation" do
+      expect(-left).to eq Point[-1,-2]
+      expect(-left).to be_an_instance_of(Point)
+    end
+
+    context "When adding" do
+      it "return a Point when adding two Points" do
+        expect(left+right).to be_a_kind_of Point
+      end
+
+      it "must return a Point when adding an array to a Point" do
+        expect(left + [5,6]).to eq Point[6,8]
+      end
+
+      it "must add a Numeric to all elements" do
+        expect(left + 2).to eq Point[3,4]
+        expect(2 + left).to eq Point[3,4]
+      end
+
+      it "must raise an exception when adding mismatched sizes" do
+        expect { left + [1,2,3,4] }.to raise_error Euclidean::DimensionMismatch
+      end
+
+      it "must return a Point when adding a Vector" do
+        expect(left + Vector[5,6]).to eq Point[6,8]
+        expect(Vector[5,6] + right).to eq Vector[8,10]
+      end
+
+      it "must return self when adding a PointZero" do
+        expect(left + Point.zero).to eq left
+      end
+
+      it "must return self when adding a NilClass" do
+        expect(left + nil).to eq left
+      end
+    end
+
+    context "When subtracting" do
+      it "return a Point when subtracting two Points" do
+        expect(left-right).to be_a_kind_of Point
+      end
+
+      it "must return a Point when subtracting an array from a Point" do
+        expect(left - [5,6]).to eq Point[-4, -4]
+      end
+
+      it "must subtract a Numeric from all elements" do
+        expect(left - 2).to eq Point[-1, 0]
+        expect(2 - left).to eq Point[1,0]
+      end
+
+      it "must raise an exception when subtracting mismatched sizes" do
+        expect{ left - [1,2,3,4] }.to raise_error Euclidean::DimensionMismatch
+      end
+
+      it "must return self when subtracting a PointZero" do
+        expect(left - Point.zero).to eq left
+      end
+
+      it "must return self when subtracting a NilClass" do
+        expect(left - nil).to eq left
+      end
+    end
+
+    context "When multiplying" do
+      it "must return a Point when multiplied by a Matrix" do
+        expect(Matrix[[1,2],[3,4]]*Point[5,6]).to eq Point[17, 39]
+      end
+    end
+
+  end
+
+  describe "Coercion" do
+    subject { Point[1,2] }
+
+    it "must coerce Arrays into Points" do
+      expect( subject.coerce([3,4]) ).to eq [Point[3,4], subject]
+    end
+
+    it "must coerce Vectors into Points" do
+      expect( subject.coerce(Vector[3,4]) ).to eq [Point[3,4], subject]
+    end
+
+    it "must coerce a Numeric into a Point" do
+      expect( subject.coerce(42) ).to eq [Point[42,42], subject]
+    end
+
+    it "must reject anything that can't be coerced" do
+      expect{ subject.coerce(NilClass) }.to raise_error TypeError
+    end
+  end
+
+  describe "Comparison" do
+    let(:point) { Point[1,2] }
+
+    it "must compare equal to an equal Array" do
+      expect(point).to eq [1,2]
+      expect(point).to eql [1,2]
+      expect([1,2]).to eq point.to_a
+    end
+
+    it "must not compare equal to an unequal Array" do
+      expect(point==[3,2]).to be false
+      expect([3,2]==point).to be false
+    end
+
+    it "must compare equal to an equal Point" do
+      expect(point).to eq Point[1,2]
+      expect(point).to eql Point[1,2]
+      expect(Point[1,2]).to eq point
+    end
+
+    it "must not compare equal to an unequal Point" do
+      expect(point==Point[3,2]).to be false
+      expect(Point[3,2]==point).to be false
+    end
+
+    it "must compare equal to an equal Vector" do
+      expect(point).to eq Vector[1,2]
+      expect(Vector[1,2]).to eq point
+    end
+
+    it "must not compare equal to an unequal Vector" do
+      expect(point == Vector[3,2]).to be false
+      expect(Vector[3,2] == point).to be false
+    end
+
+    it "must think that floats == ints" do
+      expect(Point[1,2]).to eq Point[1.0,2.0]
+      expect(Point[1.0,2.0]).to eq Point[1,2]
+    end
+
+    it "must not think that floats eql? ints" do
+      expect(Point[1,2].eql? Point[1.0,2.0]).to be false
+      expect(Point[1.0,2.0].eql? Point[1,2]).to be false
+    end
+  end
+
+  describe "spaceship" do
+    it "must spaceship with another Point of the same length" do
+      expect(Point[1,2] <=> Point[0,3]).to eq Point[1,-1]
+    end
+
+    it "must spaceship with another Point of different length" do
+      expect(Point[1,2] <=> Point[0,3,4]).to eq Point[1,-1]
+      expect(Point[1,2,4] <=> Point[0,3]).to eq Point[1,-1]
+    end
+
+    it "must spaceship with an Array" do
+      expect(Point[1,2] <=> [0,3]).to eq Point[1,-1]
+    end
+  end
+
+end