geometry 6.2 → 6.3

data/lib/geometry/size_one.rb

@@ -0,0 +1,85 @@
+require_relative 'point'
+
+module Geometry
+=begin rdoc
+An object repesenting a {Size} of 1, in N-dimensional space
+
+A {SizeOne} object is a {Size} that will always compare equal to one and unequal to
+everything else, regardless of dimensionality. It's similar to the
+{http://en.wikipedia.org/wiki/Null_Object_pattern Null Object Pattern}, but for ones.
+=end
+    class SizeOne
+	def eql?(other)
+	    if other.respond_to? :all?
+		other.all? {|e| e.eql? 1}
+	    else
+		other == 1
+	    end
+	end
+	alias == eql?
+
+	def coerce(other)
+	    if other.is_a? Numeric
+		[other, 1]
+	    elsif other.is_a? Array
+		[other, Array.new(other.size,1)]
+	    elsif other.is_a? Vector
+		[other, Vector[*Array.new(other.size,1)]]
+	    else
+		[Size[other], Size[Array.new(other.size,1)]]
+	    end
+	end
+
+# @group Arithmetic
+
+# @group Unary operators
+	def +@
+	    self
+	end
+
+	def -@
+	    -1
+	end
+# @endgroup
+
+	def +(other)
+	    if other.respond_to?(:map)
+		other.map {|a| a + 1 }
+	    else
+		other + 1
+	    end
+	end
+
+	def -(other)
+	    if other.is_a? Numeric
+		1 - other
+	    elsif other.respond_to? :map
+		other.map {|a| 1 - a }
+	    else
+		1 - other
+	    end
+	end
+
+	def *(other)
+	    raise OperationNotDefined unless other.is_a? Numeric
+	    other
+	end
+
+	def /(other)
+	    raise OperationNotDefined unless other.is_a? Numeric
+	    raise ZeroDivisionError if 0 == other
+	    1 / other
+	end
+# @endgroup
+
+	# @group Enumerable
+
+	# Return the first, or first n, elements (always 0)
+	# @param n [Number]	the number of elements to return
+	def first(n=nil)
+	    Array.new(n, 1) rescue 1
+	end
+	# @endgroup
+    end
+end
+

data/lib/geometry/size_zero.rb

@@ -65,6 +65,14 @@ everything else, regardless of dimensionality. You can think of it as an applica
 	end
 # @endgroup
 
+	# @group Enumerable
+
+	# Return the first, or first n, elements (always 0)
+	# @param n [Number]	the number of elements to return
+	def first(n=nil)
+	    Array.new(n, 0) rescue 0
+	end
+	# @endgroup
     end
 end
 

data/lib/geometry/square.rb

@@ -69,6 +69,12 @@ The {Square} class cluster is like the {Rectangle} class cluster, but not longer
 	end
 
 # !@group Accessors
+	# @!attribute closed?
+	#   @return [Bool]  always true
+	def closed?
+	    true
+	end
+
 	# @return [Point]   The upper right corner of the bounding {Rectangle}
 	def max
 	    @points.last

data/lib/geometry/triangle.rb

@@ -35,6 +35,27 @@ An isoscoles right {Triangle} created with an origin and leg length
 		RightTriangle.new args[0], args[1], args[1]
 	     end
 	end
+
+	# @!attribute closed?
+	#   @return [Bool]  always true
+	def closed?
+	    true
+	end
+
+	# @return [Point]   The upper-right corner of the bounding rectangle that encloses the {Polyline}
+	def max
+	    points.reduce {|memo, vertex| Point[[memo.x, vertex.x].max, [memo.y, vertex.y].max] }
+	end
+
+	# @return [Point]   The lower-left corner of the bounding rectangle that encloses the {Polyline}
+	def min
+	    points.reduce {|memo, vertex| Point[[memo.x, vertex.x].min, [memo.y, vertex.y].min] }
+	end
+
+	# @return [Array<Point>]    The lower-left and upper-right corners of the enclosing bounding rectangle
+	def minmax
+	    points.reduce([points.first, points.first]) {|memo, vertex| [Point[[memo.first.x, vertex.x].min, [memo.first.y, vertex.y].min], Point[[memo.last.x, vertex.x].max, [memo.last.y, vertex.y].max]] }
+	end
     end
 
     # {http://en.wikipedia.org/wiki/Equilateral_triangle Equilateral Triangle}

data/test/geometry/annulus.rb

@@ -0,0 +1,69 @@
+require 'minitest/autorun'
+require 'geometry/annulus'
+
+describe Geometry::Annulus do
+    it 'must complain when constructed with only a center' do
+	-> { Geometry::Annulus.new center:Point[1,2] }.must_raise ArgumentError
+    end
+
+    it 'must also be known as a Ring' do
+	Geometry::Ring.new(Point[1,2], inner_radius:5, radius:10).must_be_instance_of Geometry::Annulus
+    end
+    
+    describe 'when constructed with a named center' do
+	subject { Geometry::Annulus.new center:Point[1,2], inner_radius:5, radius:10 }
+
+	it 'must have a center' do
+	    subject.center.must_equal Point[1,2]
+	end
+    end
+    
+    describe 'when constructed with a center, inner_radius and radius' do
+	subject { Geometry::Annulus.new Point[1,2], inner_radius:5, radius:10 }
+
+	it 'must have a center' do
+	    subject.center.must_equal Point[1,2]
+	end
+
+	it 'must have an inner diameter' do
+	    subject.inner_diameter.must_equal 10
+	end
+
+	it 'must have an inner radius' do
+	    subject.inner_radius.must_equal 5
+	end
+
+	it 'must have an outer diameter' do
+	    subject.outer_diameter.must_equal 20
+	end
+
+	it 'must have a radius' do
+	    subject.radius.must_equal 10
+	    subject.outer_radius.must_equal 10
+	end
+    end
+
+    describe 'when constructed with a center, inner_diameter and diameter' do
+	subject { Geometry::Annulus.new Point[1,2], inner_diameter:5, diameter:10 }
+
+	it 'must have a center' do
+	    subject.center.must_equal Point[1,2]
+	end
+
+	it 'must have an inner diameter' do
+	    subject.inner_diameter.must_equal 5
+	end
+
+	it 'must have an inner radius' do
+	    subject.inner_radius.must_equal 2.5
+	end
+
+	it 'must have an outer diameter' do
+	    subject.outer_diameter.must_equal 10
+	end
+
+	it 'must have a radius' do
+	    subject.radius.must_equal 5
+	end
+    end
+end

data/test/geometry/circle.rb

@@ -88,6 +88,38 @@ describe Geometry::Circle do
 	it "must calculate the correct radius" do
 	    circle.radius.must_equal 2
 	end
+
+	it 'must have the correct min values' do
+	    circle.min.must_equal Point[-2, -2]
+	    circle.min.must_be_instance_of Geometry::PointIso
+	end
+
+	it 'must have the correct max values' do
+	    circle.max.must_equal Point[2, 2]
+	    circle.max.must_be_instance_of Geometry::PointIso
+	end
+
+	it 'must have the correct minmax values' do
+	    circle.minmax.must_equal [Point[-2, -2], Point[2,2]]
+	end
+    end
+
+    describe 'when constructed with a Rational diameter and no center' do
+	let(:circle) { Circle.new :diameter => Rational(5,3) }
+
+	it 'must have the correct min values' do
+	    circle.min.must_equal Point[-5/6, -5/6]
+	    circle.min.must_be_instance_of Geometry::PointIso
+	end
+
+	it 'must have the correct max values' do
+	    circle.max.must_equal Point[5/6, 5/6]
+	    circle.max.must_be_instance_of Geometry::PointIso
+	end
+
+	it 'must have the correct minmax values' do
+	    circle.minmax.must_equal [Point[-5/6, -5/6], Point[5/6,5/6]]
+	end
     end
 
     describe "properties" do
@@ -97,6 +129,10 @@ describe Geometry::Circle do
 	    subject.bounds.must_equal Rectangle.new([-1,0], [3,4])
 	end
 
+	it 'must always be closed' do
+	    subject.closed?.must_equal true
+	end
+
 	it "must have a minmax property that returns the corners of the bounding rectangle" do
 	    subject.minmax.must_equal [Point[-1,0], Point[3,4]]
 	end

data/test/geometry/obround.rb

@@ -22,4 +22,9 @@ describe Geometry::Obround do
 	    obround.must_equal Obround.new([1,2], [3,4])
 	end
     end
+
+    it 'must always be closed' do
+	obround = Geometry::Obround.new 2, 3
+	obround.closed?.must_equal true
+    end
 end

data/test/geometry/point.rb

@@ -2,9 +2,18 @@ require 'minitest/autorun'
 require 'geometry/point'
 
 describe Geometry::Point do
+    PointOne = Geometry::PointOne
     PointZero = Geometry::PointZero
 
     describe "class methods" do
+	it 'must generate a PointOne' do
+	    Point.one.must_be_instance_of PointOne
+	end
+
+	it 'must generate a Point full of ones' do
+	    Point.one(3).must_equal Point[1,1,1]
+	end
+
 	it "must generate a PointZero" do
 	    Point.zero.must_be_instance_of(PointZero)
 	end
@@ -56,12 +65,22 @@ describe Geometry::Point do
 	assert_equal(13, point.x)
 	assert_equal(14, point.y)
     end
-    it "allow indexed element access" do
-	point = Geometry::Point[5,6]
-	assert_equal(2, point.size)
-	assert_equal(5, point[0])
-	assert_equal(6, point[1])
+
+    describe 'when array access' do
+	it 'must allow indexed access' do
+	    point = Geometry::Point[5,6]
+	    point.size.must_equal 2
+	    point[0].must_equal 5
+	    point[1].must_equal 6
+	end
+
+	it 'must slize with a start index and a length' do
+	    point = Geometry::Point[5, 6, 7]
+	    slice = point[1,2]
+	    slice.length.must_equal 2
+	end
     end
+
     it "allow named element access" do
 	point = Geometry::Point[5,6,7]
 	assert_equal(3, point.size)
@@ -132,6 +151,10 @@ describe Geometry::Point do
 		(Vector[5,6] + right).must_equal Vector[8,10]
 	    end
 
+	    it 'must add a PointOne' do
+		(left + Point.one).must_equal Point[2,3]
+	    end
+
 	    it "must return self when adding a PointZero" do
 		(left + Point.zero).must_equal left
 	    end
@@ -159,6 +182,10 @@ describe Geometry::Point do
 		lambda { left - [1,2,3,4] }.must_raise Geometry::DimensionMismatch
 	    end
 
+	    it 'must subtract a PointOne' do
+		(left - Point.one).must_equal Point[0,1]
+	    end
+
 	    it "must return self when subtracting a PointZero" do
 		(left - Point.zero).must_equal left
 	    end
@@ -220,6 +247,14 @@ describe Geometry::Point do
 	    Point[3,2].wont_equal point
 	end
 
+	it 'must compare to a PointOne' do
+	    point.wont_equal Point.one
+	    Point.one.wont_equal point
+
+	    Point[1,1].must_equal Point.one
+	    Point.one.must_equal Point[1,1]
+	end
+
 	it "must compare equal to an equal Vector" do
 	    point.must_equal Vector[1,2]
 	    Vector[1,2].must_equal point

data/test/geometry/point_iso.rb

@@ -0,0 +1,189 @@
+require 'minitest/autorun'
+require 'geometry/point_iso'
+
+describe Geometry::PointIso do
+    let(:value) { 5 }
+    subject { Geometry::PointIso.new(5) }
+
+    describe 'arithmetic' do
+	let(:left) { Point[1,2] }
+	let(:right) { Point[3,4] }
+
+	it 'must pretend to be a Point' do
+	    subject.is_a?(Point).must_equal true
+	    subject.kind_of?(Point).must_equal true
+
+	    subject.is_a?(Geometry::PointIso).must_equal true
+	    subject.kind_of?(Geometry::PointIso).must_equal true
+
+	    subject.instance_of?(Point).must_equal false
+	    subject.instance_of?(Geometry::PointIso).must_equal true
+	end
+
+	it 'must have +@' do
+	    (+subject).must_be :eql?, value
+	    (+subject).must_be_instance_of(Geometry::PointIso)
+	end
+
+	it 'must have unary negation' do
+	    (-subject).must_be :eql?, -value
+	    (-subject).must_be_instance_of(Geometry::PointIso)
+	end
+
+	describe 'Accessors' do
+	    it 'must return 1 for array access' do
+		subject[3].must_equal value
+	    end
+
+	    it 'must return 1 for named element access' do
+		subject.x.must_equal value
+		subject.y.must_equal value
+		subject.z.must_equal value
+	    end
+	end
+
+	it 'must add a number' do
+	    (subject + 3).must_equal (value + 3)
+	    (3 + subject).must_equal (3 + value)
+	end
+
+	it 'return a Point when adding two Points' do
+	    (subject + right).must_be_kind_of Point
+	    (left + subject).must_be_kind_of Point
+	end
+
+	it 'must return an Array when adding an array' do
+	    (subject + [5,6]).must_equal [value+5, value+6]
+#	    ([5,6] + subject).must_equal [10, 11]
+	end
+
+	it 'must return a Point when adding a Size' do
+	    (subject + Size[5,6]).must_be_instance_of(Point)
+	    (subject + Size[5,6]).must_equal Point[value+5, value+6]
+	end
+
+	describe 'when subtracting' do
+	    it 'must subtract a number' do
+		(subject - 3).must_equal (value - 3)
+		(3 - subject).must_equal -2
+	    end
+
+	    it 'return a Point when subtracting two Points' do
+		(subject - right).must_equal Point[value - right.x, value - right.y]
+		(left - subject).must_equal Point[left.x - value, left.y - value]
+	    end
+
+	    it 'must return a Point when subtracting an array' do
+		(subject - [5,6]).must_equal [0, -1]
+#		([5,6] - subject).must_equal [4,5]
+	    end
+
+	    it 'must return a Point when subtracting a Size' do
+		(subject - Size[5,6]).must_be_instance_of(Point)
+		(subject - Size[5,6]).must_equal Point[0,-1]
+	    end
+	end
+
+	it 'must multiply by a scalar' do
+	    (subject * 3).must_equal 15
+	    (subject * 3.0).must_equal 15.0
+	end
+
+	it 'must refuse to multiply by a Point' do
+	    -> { subject * Point[1, 2] }.must_raise Geometry::OperationNotDefined
+	end
+
+	it 'must refuse to multiply by a Vector' do
+	    -> { subject * Vector[2, 3] }.must_raise Geometry::OperationNotDefined
+	end
+
+	it 'must divide by a scalar' do
+	    (subject / 3).must_equal 5/3
+	    (subject / 4.0).must_equal 5/4.0
+	end
+
+	it 'must raise an exception when divided by 0' do
+	    -> { subject / 0 }.must_raise ZeroDivisionError
+	end
+
+	describe 'division' do
+	    it 'must raise an exception for Points' do
+		lambda { subject / Point[1,2] }.must_raise Geometry::OperationNotDefined
+	    end
+
+	    it 'must raise an exception for Vectors' do
+		lambda { subject / Vector[1,2] }.must_raise Geometry::OperationNotDefined
+	    end
+	end
+    end
+
+    describe 'coercion' do
+	it 'must coerce Arrays into Points' do
+	    subject.coerce([3,4]).must_equal [Point[3,4], Point[5, 5]]
+	end
+
+	it 'must coerce Vectors into Vectors' do
+	    subject.coerce(Vector[3,4]).must_equal [Vector[3,4], Vector[5, 5]]
+	end
+
+	it 'must coerce Points into Points' do
+	    subject.coerce(Point[5,6]).must_equal [Point[5,6], Point[5, 5]]
+	end
+    end
+
+    describe 'comparison' do
+	it 'must be equal to the same value' do
+	    subject.must_be :eql?, 5
+	    subject.must_be :eql?, 5.0
+	end
+
+	it 'must not be equal to a number of a different value' do
+	    0.wont_equal subject
+	    3.14.wont_equal subject
+	end
+
+	it 'must be equal to an Array of the same value' do
+	    subject.must_be :==, [5,5]
+	    subject.must_be :eql?, [5,5]
+	    subject.must_be :===, [5,5]
+	    [5,5].must_equal subject
+	    subject.must_equal [5,5]
+	end
+
+	it 'must not be equal to an Array of other values' do
+	    subject.wont_equal [3, 2, 1]
+	    [3, 2, 1].wont_equal subject
+	end
+
+	it 'must not be equal to a Point at the origin' do
+	    subject.wont_be :==, Point[0,0]
+	    subject.wont_be :eql?, Point[0,0]
+	    subject.wont_be :===, Point[0,0]
+	    Point[0,0].wont_equal subject
+	    subject.wont_equal Point[0,0]
+	end
+
+	it 'must not be equal to a Point not at the origin' do
+	    subject.wont_equal Point[3,2]
+	    Point[3,2].wont_equal subject
+	end
+
+	it 'must be equal to a Point of subjects' do
+	    subject.must_be :==, Point[value, value]
+	    subject.must_be :eql?, Point[value, value]
+	    subject.must_be :===, Point[value, value]
+	    Point[value, value].must_equal subject
+	    subject.must_equal Point[value, value]
+	end
+
+	it 'must be equal to an Vector of the same value' do
+	    subject.must_be :eql?, Vector[value, value]
+	    Vector[5, 5].must_equal subject
+	end
+
+	it 'must not be equal to a Vector of other values' do
+	    subject.wont_equal Vector[3,2]
+	    Vector[3,2].wont_equal subject
+	end
+    end
+end