geometry 6.4 → 6.6

data/lib/geometry/point_one.rb

@@ -1,5 +1,3 @@
-require_relative 'point'
-
 module Geometry
 =begin rdoc
 An object repesenting a {Point} that is one unit away from the origin, along each
@@ -67,43 +65,55 @@ everything else, regardless of size. It's similar to the
 	end
 # @endgroup
 
-    # @override max()
-    # @return [Number]  The maximum value of the {Point}'s elements
-    # @override max(point)
-    # @return [Point]    The element-wise maximum values of the receiver and the given {Point}
-    def max(*args)
-	if args.empty?
-	    1
-	else
-	    args = args.first if 1 == args.size
-	    Point[Array.new(args.size, 1).zip(args).map(&:max)]
+	# @override max()
+	# @return [Number]  The maximum value of the {Point}'s elements
+	# @override max(point)
+	# @return [Point]    The element-wise maximum values of the receiver and the given {Point}
+	def max(*args)
+	    if args.empty?
+		1
+	    else
+		args = args.first if 1 == args.size
+		Point[Array.new(args.size, 1).zip(args).map(&:max)]
+	    end
 	end
-    end
 
-    # @override min()
-    # @return [Number]  The minimum value of the {Point}'s elements
-    # @override min(point)
-    # @return [Point]    The element-wise minimum values of the receiver and the given {Point}
-    def min(*args)
-	if args.empty?
-	    1
-	else
-	    args = args.first if 1 == args.size
-	    Point[Array.new(args.size, 1).zip(args).map(&:min)]
+	# @override min()
+	# @return [Number]  The minimum value of the {Point}'s elements
+	# @override min(point)
+	# @return [Point]    The element-wise minimum values of the receiver and the given {Point}
+	def min(*args)
+	    if args.empty?
+		1
+	    else
+		args = args.first if 1 == args.size
+		Point[Array.new(args.size, 1).zip(args).map(&:min)]
+	    end
 	end
-    end
 
-    # @override minmax()
-    # @return [Array<Number>]   The minimum value of the {Point}'s elements
-    # @override min(point)
-    # @return [Array<Point>]    The element-wise minimum values of the receiver and the given {Point}
-    def minmax(*args)
-	if args.empty?
-	    [1, 1]
-	else
-	    [min(*args), max(*args)]
+	# @override minmax()
+	# @return [Array<Number>]   The minimum value of the {Point}'s elements
+	# @override min(point)
+	# @return [Array<Point>]    The element-wise minimum values of the receiver and the given {Point}
+	def minmax(*args)
+	    if args.empty?
+		[1, 1]
+	    else
+		[min(*args), max(*args)]
+	    end
+	end
+
+	# Returns a new {Point} with the given number of elements removed from the end
+	# @return [Point]   the popped elements
+	def pop(count=1)
+	    Point[Array.new(count, 1)]
+	end
+
+	# Removes the first element and returns it
+	# @return [Point]   the shifted elements
+	def shift(count=1)
+	    Point[Array.new(count, 1)]
 	end
-    end
 
 # @group Arithmetic
 

data/lib/geometry/point_zero.rb

@@ -1,4 +1,3 @@
-require_relative 'point'
 require_relative 'point_iso'
 
 module Geometry
@@ -105,6 +104,18 @@ everything else, regardless of size. You can think of it as an application of th
 	    end
 	end
 
+	# Returns a new {Point} with the given number of elements removed from the end
+	# @return [Point]   the popped elements
+	def pop(count=1)
+	    Point[Array.new(count, 0)]
+	end
+
+	# Removes the first element and returns it
+	# @return [Point]   the shifted elements
+	def shift(count=1)
+	    Point[Array.new(count, 0)]
+	end
+
 # @group Arithmetic
 
 # @group Unary operators

data/lib/geometry/polygon.rb

@@ -46,7 +46,7 @@ but there's currently nothing that enforces simplicity.
 
 	# @return [Polygon] A new {Polygon} with orientation that's the opposite of the receiver
 	def reverse
-	    self.class.new *(self.vertices.reverse)
+	    self.class.new(*(self.vertices.reverse))
 	end
 
 	# Reverse the receiver and return it
@@ -68,7 +68,7 @@ but there's currently nothing that enforces simplicity.
 	# @param [Point] point	The {Point} to test
 	# @return [Number]	1 if the {Point} is inside the {Polygon}, -1 if it's outside, and 0 if it's on an {Edge}
 	def <=>(point)
-	    sum = edges.reduce(0) do |sum, e|
+	    winding = edges.reduce(0) do |sum, e|
 		direction = e.last.y <=> e.first.y
 		# Ignore edges that don't cross the point's x coordinate
 		next sum unless ((point.y <=> e.last.y) + (point.y <=> e.first.y)).abs <= 1
@@ -83,7 +83,7 @@ but there's currently nothing that enforces simplicity.
 		    sum += 0 <=> (direction + is_left)
 		end
 	    end
-	    (0 == sum) ? -1 : 1
+	    (0 == winding) ? -1 : 1
 	end
 
 	# Create a new {Polygon} that's the union of the receiver and a passed {Polygon}
@@ -152,11 +152,11 @@ but there's currently nothing that enforces simplicity.
 	    edgeFragments = edgeFragments.reject {|f| edgeFragments.find {|f2| (f[:first] == f2[:last]) and (f[:last] == f2[:first])} }
 
 	    # Construct the output polygons
-	    output = edgeFragments.reduce([Array.new]) do |output, fragment|
+	    output_polygons = edgeFragments.reduce([Array.new]) do |output, fragment|
 		next output if fragment.empty?
 		polygon = output.last
 		polygon.push fragment[:first], fragment[:last] if polygon.empty?
-		while 1 do
+		loop do
 		    adjacent_fragment = edgeFragments.find {|f| fragment[:last] == f[:first]}
 		    break unless adjacent_fragment
 
@@ -170,13 +170,13 @@ but there's currently nothing that enforces simplicity.
 	    end
 
 	    # If everything worked properly there should be only one output Polygon
-	    output.reject! {|a| a.empty?}
-	    output = Polygon.new *(output[0])
+	    output_polygons.reject! {|a| a.empty?}
+	    output_polygons = Polygon.new(*(output_polygons[0]))
 
 	    # Table 4: Both input polygons are "island" type and the operation
 	    #  is union, so the output polygon's orientation should be the same
 	    #  as the input polygon's orientation
-	    (self.clockwise? != output.clockwise?) ? output.reverse : output
+	    (self.clockwise? != output_polygons.clockwise?) ? output_polygons.reverse : output_polygons
 	end
 	alias :+ :union
 
@@ -213,7 +213,7 @@ but there's currently nothing that enforces simplicity.
 		break if current_point == hull_points.first
 		hull_points << min_point
 	    end
-	    Polygon.new *hull_points
+	    Polygon.new(*hull_points)
 	end
 
 	# @endgroup
@@ -278,7 +278,7 @@ but there's currently nothing that enforces simplicity.
 		    redo    # Recheck the modified edges
 		end
 	    end
-	    Polygon.new *(active_edges.map {|e| e[:edge]}.compact.map {|e| [e.first, e.last]}.flatten)
+	    Polygon.new(*(active_edges.map {|e| e[:edge]}.compact.map {|e| [e.first, e.last]}.flatten))
 	end
 
 	# Vertex bisectors suitable for outsetting
@@ -332,9 +332,10 @@ but there's currently nothing that enforces simplicity.
 	# @param [Integer] index	The index to insert the new {Point} before
 	# @param [Point] point		The {Point} to insert
 	# @param [Integer] type		The vertex type: 1 is inside, 0 is boundary, -1 is outside
+	# @return [Bool]    true if the {Point} was inserted, false otherwise
 	def insert(index, point, type)
-	    if v = @vertices.find {|v| v[:vertex] == point }
-		v[:type] = type
+	    if vertex = @vertices.find {|v| v[:vertex] == point }
+		vertex[:type] = type
 		false
 	    else
 		@vertices.insert(index, {:vertex => point, :type => type})

data/lib/geometry/polyline.rb

@@ -41,7 +41,7 @@ also like a {Path} in that it isn't necessarily closed.
 		@vertices.push first
 	    elsif first.is_a?(Edge)
 		@edges.push first
-		@vertices.push *(first.to_a)
+		@vertices.push(*(first.to_a))
 	    end
 
 	    args.reduce(@vertices.last) do |previous,n|
@@ -82,7 +82,7 @@ also like a {Path} in that it isn't necessarily closed.
 		    else
 			e = Edge.new(previous, n.first)
 			push_edge e, n
-			push_vertex *(e.to_a), *(n.to_a)
+			push_vertex(*(e.to_a), *(n.to_a))
 		    end
 		    n.last
 		end
@@ -167,7 +167,7 @@ also like a {Path} in that it isn't necessarily closed.
 	# Clone the receiver, reverse it, then return it
 	# @return [Polyline]	the reversed clone
 	def reverse
-	    self.class.new *(edges.reverse.map! {|edge| edge.reverse! })
+	    self.class.new(*(edges.reverse.map! {|edge| edge.reverse! }))
 	end
 
 	# Reverse the receiver and return it
@@ -261,7 +261,7 @@ also like a {Path} in that it isn't necessarily closed.
 		    redo    # Recheck the modified edges
 		end
 	    end
-	    Polyline.new *(active_edges.map {|e| e[:edge]}.compact.map {|e| [e.first, e.last]}.flatten)
+	    Polyline.new(*(active_edges.map {|e| e[:edge]}.compact.map {|e| [e.first, e.last]}.flatten))
 	end
 	alias :leftset :offset
 
@@ -369,12 +369,12 @@ also like a {Path} in that it isn't necessarily closed.
 	end
 
 	def push_edge(*e)
-	    @edges.push *e
+	    @edges.push(*e)
 	    @edges.uniq!
 	end
 
 	def push_vertex(*v)
-	    @vertices.push *v
+	    @vertices.push(*v)
 	    @vertices.uniq!
 	end
 

data/lib/geometry/rectangle.rb

@@ -25,16 +25,8 @@ The {Rectangle} class cluster represents your typical arrangement of 4 corners a
     class Rectangle
 	include ClusterFactory
 
-	# @return [Point]   The {Rectangle}'s center
-	attr_reader :center
-	# @return [Number]  Height of the {Rectangle}
-	attr_reader :height
-	# @return [Point]   The {Rectangle}'s origin
-	attr_reader :origin
 	# @return [Size]    The {Size} of the {Rectangle}
 	attr_reader :size
-	# @return [Number]  Width of the {Rectangle}
-	attr_reader :width
 
 	# @overload new(width, height)
 	#   Creates a {Rectangle} of the given width and height, centered on the origin
@@ -120,7 +112,7 @@ The {Rectangle} class cluster represents your typical arrangement of 4 corners a
 	# @return [Point]   The {Rectangle}'s center
 	def center
 	    min, max = @points.minmax {|a,b| a.y <=> b.y}
-	    Point[(max.x+min.x)/2, (max.y+min.y)/2]
+	    Point[(max.x+min.x).to_r/2, (max.y+min.y).to_r/2]
 	end
 
 	# @!attribute closed?
@@ -155,25 +147,28 @@ The {Rectangle} class cluster represents your typical arrangement of 4 corners a
 	    [self.min, self.max]
 	end
 
-	# @return [Array<Point>]    The {Rectangle}'s four points (counterclockwise)
+	# @return [Array<Point>]    The {Rectangle}'s four points (clockwise)
 	def points
 	    point0, point2 = *@points
-	    point1 = Point[point2.x, point0.y]
-	    point3 = Point[point0.x, point2.y]
+	    point1 = Point[point0.x, point2.y]
+	    point3 = Point[point2.x, point0.y]
 	    [point0, point1, point2, point3]
 	end
 
+	# @return [Point]   The {Rectangle}'s origin
 	def origin
 	    minx = @points.min {|a,b| a.x <=> b.x}
 	    miny = @points.min {|a,b| a.y <=> b.y}
 	    Point[minx.x, miny.y]
 	end
 
+	# @return [Number]  Height of the {Rectangle}
 	def height
 	    min, max = @points.minmax {|a,b| a.y <=> b.y}
 	    max.y - min.y
 	end
 
+	# @return [Number]  Width of the {Rectangle}
 	def width
 	    min, max = @points.minmax {|a,b| a.x <=> b.x}
 	    max.x - min.x
@@ -212,6 +207,11 @@ The {Rectangle} class cluster represents your typical arrangement of 4 corners a
 		Rectangle.new from:(min + Point[options[:left], options[:bottom]]), to:(max - Point[options[:right], options[:top]])
 	    end
 	end
+
+	# @return [Path]    A closed {Path} that traces the boundary of the {Rectangle} clockwise, starting from the lower-left
+	def path
+	    Path.new(*self.points, self.points.first)
+	end
     end
 
     class CenteredRectangle < Rectangle

data/lib/geometry/rotation.rb

@@ -72,16 +72,18 @@ A generalized representation of a rotation transformation.
 	alias :== :eql?
 
 	def identity?
-	    (!@x && !@y && !@z) || ([@x, @y, @z].select {|a| a}.all? {|a| a.respond_to?(:magnitude) ? (1 == a.magnitude) : (1 == a.size)})
+	    x, y, z = self.x, self.y, self.z
+	    (!x && !y && !z) || ([x, y, z].select {|a| a}.all? {|a| a.respond_to?(:magnitude) ? (1 == a.magnitude) : (1 == a.size)})
 	end
 
 	# @attribute [r] matrix
 	# @return [Matrix] the transformation {Matrix} representing the {Rotation}
 	def matrix
-	    return nil unless [@x, @y, @z].compact.size >= 2
+	    x, y, z = self.x, self.y, self.z
+	    return nil unless [x, y, z].compact.size >= 2
 
 	    # Force all axes to be Vectors
-	    x,y,z = [@x, @y, @z].map {|a| a.is_a?(Array) ? Vector[*a] : a}
+	    x,y,z = [x, y, z].map {|a| a.is_a?(Array) ? Vector[*a] : a}
 
 	    # Force all axes to exist
 	    if x and y

data/lib/geometry/size.rb

@@ -17,8 +17,6 @@ methods (width, height and depth).
 =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
 	#
@@ -30,7 +28,7 @@ methods (width, height and depth).
 	def self.[](*array)
 	    array.map! {|a| a.respond_to?(:to_a) ? a.to_a : a }
 	    array.flatten!
-	    super *array
+	    super(*array)
 	end
 
 	# Creates and returns a new {SizeOne} instance. Or, a {Size} full of ones if the size argument is given.

data/lib/geometry/square.rb

@@ -16,10 +16,6 @@ The {Square} class cluster is like the {Rectangle} class cluster, but not longer
     class Square
 	include ClusterFactory
 
-	# @!attribute origin
-	#   @return [Point]  The {Square}'s origin
-	attr_reader :origin
-
 	# @!attribute points
 	#   @return [Array<Point>]  the corner {Point}s of the {Square} in counter-clockwise order
 	attr_reader :points
@@ -101,15 +97,16 @@ The {Square} class cluster is like the {Rectangle} class cluster, but not longer
 	    [self.min, self.max]
 	end
 
-	# @attribute [r] origin
-	# @return [Point] The lower left corner
+	# @!attribute origin
+	#   @return [Point]  The {Square}'s origin (lower-left corner)
 	def origin
 	    @points.first
 	end
 
+	# @return [Array<Point>]    The {Square}'s four points (clockwise)
 	def points
 	    p0, p1 = *@points
-	    [p0, Point[p1.x, p0.y], p1, Point[p0.x, p1.y]]
+	    [p0, Point[p0.x, p1.y], p1, Point[p1.x, p0.y]]
 	end
 
 	def height
@@ -122,6 +119,11 @@ The {Square} class cluster is like the {Rectangle} class cluster, but not longer
 	    max.x - min.x
 	end
 # @endgroup
+
+	# @return [Path]    A closed {Path} that traces the boundary of the {Square} clockwise, starting from the lower-left
+	def path
+	    Path.new(*self.points, self.points.first)
+	end
     end
 
     # A {Square} created with a center point and a size
@@ -166,7 +168,7 @@ The {Square} class cluster is like the {Rectangle} class cluster, but not longer
 	end
 
 	# @attribute [r] points
-	# @return [Array<Point>]    The {Square}'s four points (counterclockwise)
+	# @return [Array<Point>]    The {Square}'s four points (clockwise)
 	def points
 	    half_size = @size/2
 	    minx = @center.x - half_size
@@ -174,7 +176,7 @@ The {Square} class cluster is like the {Rectangle} class cluster, but not longer
 	    miny = @center.y - half_size
 	    maxy = @center.y + half_size
 
-	    [Point[minx,miny], Point[maxx, miny], Point[maxx, maxy], Point[minx,maxy]]
+	    [Point[minx,miny], Point[minx, maxy], Point[maxx, maxy], Point[maxx,miny]]
 	end
 
 	def height
@@ -224,14 +226,14 @@ The {Square} class cluster is like the {Rectangle} class cluster, but not longer
 	end
 
 	# @attribute [r] points
-	# @return [Array<Point>]    The {Square}'s four points (counterclockwise)
+	# @return [Array<Point>]    The {Square}'s four points (clockwise)
 	def points
 	    minx = origin.x
 	    maxx = origin.x + size
 	    miny = origin.y
 	    maxy = origin.y + size
 
-	    [origin, Point[maxx, miny], Point[maxx, maxy], Point[minx,maxy]]
+	    [origin, Point[minx, maxy], Point[maxx, maxy], Point[maxx,miny]]
 	end
 
 	# @return [Number]  The size of the {Square} along the y-axis

data/lib/geometry/transformation/composition.rb

@@ -32,7 +32,7 @@ module Geometry
 # @endgroup
 
 	    def transform(point)
-		transformations.reverse.reduce(point) {|point, transformation| transformation.transform(point) }
+		transformations.reverse.reduce(point) {|_point, transformation| transformation.transform(_point) }
 	    end
 	end
     end

data/lib/geometry/transformation.rb

@@ -180,4 +180,19 @@ system's X-axis:
 	    @translation ? (@translation + point) : point
 	end
     end
+
+    # @override translation(x, y, z)
+    #   Construct a new translation from the given values
+    #   @param x    [Number]	The distance to translate along the X-axis
+    #   @param y    [Number]	The distance to translate along the Y-axis
+    #   @param z    [Number]	The distance to translate along the Z-axis
+    # @override translation([x, y, z])
+    #   Construct a new translation from an array of values
+    # @override translation(point)
+    #   Construct a new translation from a {Point}
+    #   @param point	[Point]	A {Point}
+    def self.translation(*args)
+	args = *args if args[0].is_a? Array
+	Transformation.new translate:args
+    end
 end

data/lib/geometry/triangle.rb

@@ -30,7 +30,7 @@ An isoscoles right {Triangle} created with an origin and leg length
 	#   @param [Number] height  The length of the {Triangle}'s vertical leg
 	def self.new(*args)
 	     if args.size == 3
-		ScaleneTriangle.new *args
+		ScaleneTriangle.new(*args)
 	     elsif args.size == 2
 		RightTriangle.new args[0], args[1], args[1]
 	     end

data/test/geometry/annulus.rb

@@ -16,6 +16,18 @@ describe Geometry::Annulus do
 	it 'must have a center' do
 	    subject.center.must_equal Point[1,2]
 	end
+
+	it 'must have a max' do
+	    subject.max.must_equal Point[11, 12]
+	end
+
+	it 'must have a min' do
+	    subject.min.must_equal Point[-9, -8]
+	end
+
+	it 'must have a min and a max' do
+	    subject.minmax.must_equal [subject.min, subject.max]
+	end
     end
     
     describe 'when constructed with a center, inner_radius and radius' do

data/test/geometry/arc.rb

@@ -23,3 +23,101 @@ describe Geometry::Arc do
 	end
     end
 end
+
+describe Geometry::ThreePointArc do
+    it 'must have an ending angle' do
+	arc = Geometry::ThreePointArc.new([0,0], [1,0], [0,1])
+	arc.end_angle.must_equal Math::PI/2
+    end
+
+    it 'must have a radius' do
+	arc = Geometry::ThreePointArc.new([0,0], [1,0], [0,1])
+	arc.radius.must_equal 1
+    end
+
+    it 'must have an starting angle' do
+	arc = Geometry::ThreePointArc.new([0,0], [1,0], [0,1])
+	arc.start_angle.must_equal 0
+    end
+
+    describe 'max' do
+	# Cosine and sine of a 22.5 degree angle
+	let(:cos) { 0.9239556995 }
+	let(:sin) { 0.3824994973 }
+	let(:radius) { 1.0000000000366434 }
+
+	it 'must handle an Arc entirely in quadrant 1' do
+	    arc = Geometry::ThreePointArc.new([0,0], [cos,sin], [sin,cos])
+	    arc.max.must_equal Point[cos,cos]
+	end
+
+	it 'must handle a counterclockwise Arc from quadrant 1 to quadrant 2' do
+	    arc = Geometry::ThreePointArc.new([0,0], [cos,sin], [-cos,sin])
+	    arc.max.must_equal Point[cos,radius]
+	end
+
+	it 'must handle a counterclockwise Arc from quadrant 4 to quadrant 1' do
+	    arc = Geometry::ThreePointArc.new([0,0], [sin,-cos], [sin,cos])
+	    arc.max.must_equal Point[radius,cos]
+	end
+
+	it 'must handle a counterclockwise Arc from quadrant 3 to quadrant 2' do
+	    arc = Geometry::ThreePointArc.new([0,0], [-cos,-sin], [-cos,sin])
+	    arc.max.must_equal Point[radius,radius]
+	end
+    end
+
+    describe 'min' do
+	# Cosine and sine of a 22.5 degree angle
+	let(:cos) { 0.9239556995 }
+	let(:sin) { 0.3824994973 }
+	let(:radius) { 1.0000000000366434 }
+
+	it 'must handle an Arc entirely in quadrant 1' do
+	    arc = Geometry::ThreePointArc.new([0,0], [cos,sin], [sin,cos])
+	    arc.min.must_equal Point[sin,sin]
+	end
+
+	it 'must handle a counterclockwise Arc from quadrant 1 to quadrant 2' do
+	    arc = Geometry::ThreePointArc.new([0,0], [cos,sin], [-cos,sin])
+	    arc.min.must_equal Point[-cos,sin]
+	end
+
+	it 'must handle a counterclockwise Arc from quadrant 4 to quadrant 1' do
+	    arc = Geometry::ThreePointArc.new([0,0], [sin,-cos], [sin,cos])
+	    arc.min.must_equal Point[sin,-cos]
+	end
+
+	it 'must handle a counterclockwise Arc from quadrant 3 to quadrant 2' do
+	    arc = Geometry::ThreePointArc.new([0,0], [-cos,-sin], [-cos,sin])
+	    arc.min.must_equal Point[-cos,-radius]
+	end
+    end
+
+    describe 'minmax' do
+	# Cosine and sine of a 22.5 degree angle
+	let(:cos) { 0.9239556995 }
+	let(:sin) { 0.3824994973 }
+	let(:radius) { 1.0000000000366434 }
+
+	it 'must handle an Arc entirely in quadrant 1' do
+	    arc = Geometry::ThreePointArc.new([0,0], [cos,sin], [sin,cos])
+	    arc.minmax.must_equal [Point[sin,sin], Point[cos,cos]]
+	end
+
+	it 'must handle a counterclockwise Arc from quadrant 1 to quadrant 2' do
+	    arc = Geometry::ThreePointArc.new([0,0], [cos,sin], [-cos,sin])
+	    arc.minmax.must_equal [Point[-cos,sin], Point[cos,radius]]
+	end
+
+	it 'must handle a counterclockwise Arc from quadrant 4 to quadrant 1' do
+	    arc = Geometry::ThreePointArc.new([0,0], [sin,-cos], [sin,cos])
+	    arc.minmax.must_equal [Point[sin,-cos], Point[radius,cos]]
+	end
+
+	it 'must handle a counterclockwise Arc from quadrant 3 to quadrant 2' do
+	    arc = Geometry::ThreePointArc.new([0,0], [-cos,-sin], [-cos,sin])
+	    arc.minmax.must_equal [Point[-cos,-radius], Point[radius,radius]]
+	end
+    end
+end

data/test/geometry/circle.rb

@@ -108,17 +108,17 @@ describe Geometry::Circle 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_equal Point[-5.to_r/6, -5.to_r/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_equal Point[5.to_r/6, 5.to_r/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]]
+	    circle.minmax.must_equal [Point[-5.to_r/6, -5.to_r/6], Point[5.to_r/6,5.to_r/6]]
 	end
     end
 

data/test/geometry/edge.rb

@@ -75,11 +75,25 @@ describe Geometry::Edge do
 	subject.to_a.must_equal original.reverse
     end
 
+    describe 'attributes' do
+	it 'must have a maximum' do
+	    Edge([0,0], [1,1]).max.must_equal Point[1,1]
+	end
+
+	it 'must have a minimum' do
+	    Edge([0,0], [1,1]).min.must_equal Point[0,0]
+	end
+
+	it 'must have a minmax' do
+	    Edge([0,0], [1,1]).minmax.must_equal [Point[0,0], Point[1,1]]
+	end
+    end
+
     describe "spaceship" do
 	it "ascending with a Point" do
 	    edge = Edge.new [0,0], [1,1]
 	    (edge <=> Point[0,0]).must_equal 0
-	    (edge <=> Point[1,0]).must_equal -1
+	    (edge <=> Point[1,0]).must_equal(-1)
 	    (edge <=> Point[0,1]).must_equal 1
 	    (edge <=> Point[2,2]).must_equal nil
 	end
@@ -88,7 +102,7 @@ describe Geometry::Edge do
 	    edge = Edge.new [1,1], [0,0]
 	    (edge <=> Point[0,0]).must_equal 0
 	    (edge <=> Point[1,0]).must_equal 1
-	    (edge <=> Point[0,1]).must_equal -1
+	    (edge <=> Point[0,1]).must_equal(-1)
 	    (edge <=> Point[2,2]).must_equal nil
 	end
     end