geometry 3 → 4

data/README.markdown

@@ -19,9 +19,13 @@ Primitives
 ----------
 
 - Point
+- Size
 - Line
+- Edge
 - Circle
 - Rectangle
+- Polygon
+- Transformation
 
 Examples
 --------
@@ -29,7 +33,6 @@ Examples
 ### Point
 ```ruby
     point = Geometry::Point[3,4]    # 2D Point at coordinate 3, 4
-    point = Geometry.point(1,2)	    # Functional constructor
 
     # Copy constructors
     point2 = Geometry::Point[point]
@@ -66,3 +69,9 @@ Examples
     # A circle at Point[1,2] with a radius of 3
     circle = Geometry::Circle.new [1,2], 3
 ```
+
+### Polygon
+```ruby
+    # A polygon that looks a lot like a square
+    polygon = Geometry::Polygon.new [0,0], [1,0], [1,1], [0,1]
+```

data/Rakefile

@@ -1,4 +1,11 @@
 require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+    t.libs.push "lib"
+    t.test_files = FileList['test/**/*.rb']
+    t.verbose = true
+end
 
 task :fixdates do
     branch = `git branch --no-color -r --merged`.strip
@@ -14,6 +21,10 @@ task :trim_whitespace do
   system(%Q[git status --short | awk '{if ($1 != "D" && $1 != "R") print $2}' | grep -e '.*\.rb$' | xargs sed -i '' -e 's/[ \t]*$//g;'])
 end
 
+task :docs do
+    `yard`
+end
+
 task :uninstall do
     `gem uninstall geometry`
 end

data/geometry.gemspec

@@ -3,7 +3,7 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "geometry"
-  s.version     = '3'
+  s.version     = '4'
   s.authors     = ["Brandon Fosdick"]
   s.email       = ["bfoz@bfoz.net"]
   s.homepage    = "http://github.com/bfoz/geometry"

data/lib/geometry.rb

@@ -1,9 +1,16 @@
+require_relative 'geometry/arc'
 require_relative 'geometry/circle'
-require_relative 'geometry/point'
 require_relative 'geometry/line'
+require_relative 'geometry/point'
+require_relative 'geometry/point_zero'
 require_relative 'geometry/polygon'
 require_relative 'geometry/rectangle'
+require_relative 'geometry/rotation'
 require_relative 'geometry/size'
+require_relative 'geometry/size_zero'
+require_relative 'geometry/square'
+require_relative 'geometry/transformation'
+require_relative 'geometry/vector'
 
 module Geometry
     # @overload Line(array0, array1)

data/lib/geometry/arc.rb

@@ -0,0 +1,31 @@
+require_relative 'point'
+
+module Geometry
+
+=begin rdoc
+Arcs are Circles that don't quite go all the way around
+
+== Usage
+An {Arc} with its center at [1,1] and a radius of 2 that starts at the X-axis and goes to the Y-axis (counter-clockwise)
+    arc = Geometry::Arc.new [1,1], 2, 0, 90
+=end
+
+    class Arc
+	attr_reader :center
+	attr_reader :radius
+	attr_reader :start_angle, :end_angle
+
+	# Construct a new {Arc}
+	# @overload initialize(center, radius, start_angle, end_angle)
+	# @param [Point]    center	The {Point} at the center of it all
+	# @param [Numeric]  radius	Radius
+	# @param [Numeric]  start_angle	Starting angle
+	# @param [Numeric]  end_angle	Ending angle
+	def initialize(center, radius, start_angle, end_angle)
+	    @center = Point[center]
+	    @radius = radius
+	    @start_angle = start_angle
+	    @end_angle = end_angle
+	end
+    end
+end

data/lib/geometry/circle.rb

@@ -21,7 +21,7 @@ Circles come in all shapes and sizes, but they're usually round.
 	# @param    [Number]	radius  The radius of the Circle
 	# @return   [Circle]	A new Circle object
 	def initialize(center, radius)
-	    @center = center.is_a?(Point) ? center : Point[center]
+	    @center = Point[center]
 	    @radius = radius
 	end
     end

data/lib/geometry/edge.rb

@@ -16,7 +16,7 @@ An edge. It's a line segment between 2 points. Generally part of a {Polygon}.
 	# Construct a new {Edge} object from any two things that can be converted
 	# to a {Point}.
 	def initialize(point0, point1)
-	    @first, @last = [point0, point1].map {|p| p.is_a?(Point) ? p : Point[p] }
+	    @first, @last = [Point[point0], Point[point1]]
 	end
 
 	# Two Edges are equal if both have equal {Point}s in the same order

data/lib/geometry/line.rb

@@ -67,7 +67,7 @@ Supports two-point, slope-intercept, and point-slope initializer forms
     # @private
     class PointSlopeLine < Line
 	def initialize(point, slope)
-	    @point = point.is_a?(Geometry::Point) ? point : Geometry.Point(point)
+	    @point = Point[point]
 	    @slope = slope
 	end
 	def to_s
@@ -111,7 +111,7 @@ Supports two-point, slope-intercept, and point-slope initializer forms
 	attr_reader :first, :last
 
 	def initialize(point0, point1)
-	    @first, @last = [point0, point1].map {|p| p.is_a?(Point) ? p : Point[p] }
+	    @first, @last = [Point[point0], Point[point1]]
 	end
 	def inspect
 	    'Line(' + @first.inspect + ', ' + @last.inspect + ')'

data/lib/geometry/point.rb

@@ -1,6 +1,9 @@
 require 'matrix'
 
 module Geometry
+    DimensionMismatch = Class.new(StandardError)
+    OperationNotDefined = Class.new(StandardError)
+
 =begin rdoc
 An object repesenting a Point in N-dimensional space
 
@@ -23,16 +26,33 @@ geometry class (x, y, z).
 	# @overload [](Point)
 	# @overload [](Vector)
 	def self.[](*array)
+	    return array[0] if array[0].is_a? Point
 	    array = array[0] if array[0].is_a?(Array)
 	    array = array[0].to_a if array[0].is_a?(Vector)
 	    super *array
 	end
 
+	# Creates and returns a new {PointZero} instance
+	# @return [PointZero] A new {PointZero} instance
+	def self.zero
+	    PointZero.new
+	end
+
 	# Allow comparison with an Array, otherwise do the normal thing
-	def ==(other)
+	def eql?(other)
 	    return @elements == other if other.is_a?(Array)
 	    super other
 	end
+	alias == eql?
+
+	def coerce(other)
+	    case other
+		when Array then [Point[*other], self]
+		when Vector then [Point[*other], self]
+		else
+		    raise TypeError, "#{self.class} can't be coerced into #{other.class}"
+	    end
+	end
 
 	def inspect
 	    'Point' + @elements.inspect
@@ -41,34 +61,74 @@ geometry class (x, y, z).
 	    'Point' + @elements.to_s
 	end
 
+# !@group Accessors
+	# @param [Integer]  i	Index into the {Point}'s elements
+	# @return [Numeric] Element i (starting at 0)
+	def [](i)
+	    @elements[i]
+	end
+
+	# !@attribute [r] x
 	# @return [Numeric] X-component
 	def x
 	    @elements[0]
 	end
 
+	# !@attribute [r] y
 	# @return [Numeric] Y-component
 	def y
 	    @elements[1]
 	end
 
+	# !@attribute [r] z
 	# @return [Numeric] Z-component
 	def z
 	    @elements[2]
 	end
+# !@endgroup
+
+# !@group Arithmetic
+
+# !@group Unary operators
+	def +@
+	    self
+	end
 
-# @group Arithmetic
-#  Override the arithmetic operators to force them to return {Point}s instead
-#  of {Vector}s
+	def -@
+	    Point[@elements.map {|e| -e }]
+	end
+# !@endgroup
 
 	def +(other)
-	    Point[super]
+	    case other
+		when Numeric
+		    raise DimensionMismatch, "A scalar can't be added to a Point of dimension greater than 1" if size != 1
+		    Point[@elements.first + other]
+		when PointZero
+		    self
+		else
+		    raise OperationNotDefined, "#{other.class} must respond to :size and :[]" unless other.respond_to?(:size) && other.respond_to?(:[])
+		    raise DimensionMismatch,  "Can't add #{other} to #{self}" if size != other.size
+		    Point[Array.new(size) {|i| @elements[i] + other[i] }]
+	    end
 	end
 
 	def -(other)
-	    Point[super]
+	    case other
+		when Numeric
+		    raise DimensionMismatch, "A scalar can't be subtracted from a Point of dimension greater than 1" if size != 1
+		    Point[@elements.first - other]
+		when PointZero
+		    self
+		else
+		    raise OperationNotDefined, "#{other.class} must respond to :size and :[]" unless other.respond_to?(:size) && other.respond_to?(:[])
+		    raise DimensionMismatch, "Can't subtract #{other} from #{self}" if size != other.size
+		    Point[Array.new(size) {|i| @elements[i] - other[i] }]
+	    end
 	end
 
-# @endgroup
+# !@endgroup
 
     end
 end
+

data/lib/geometry/point_zero.rb

@@ -0,0 +1,69 @@
+require_relative 'point'
+
+module Geometry
+=begin rdoc
+An object repesenting a {Point} at the origin in N-dimensional space
+
+A {PointZero} object is a {Point} that will always compare equal to zero and unequal to
+everything else, regardless of size.
+=end
+    class PointZero
+	def eql?(other)
+	    if other.respond_to? :all?
+		other.all? {|e| e.eql? 0}
+	    else
+		other == 0
+	    end
+	end
+	alias == eql?
+
+	def coerce(other)
+	    if other.is_a? Numeric
+		[other, 0]
+	    elsif other.is_a? Array
+		[other, Array.new(other.size,0)]
+	    elsif other.is_a? Vector
+		[other, Vector[*Array.new(other.size,0)]]
+	    else
+		[Point[other], Point[Array.new(other.size,0)]]
+	    end
+	end
+
+# !@group Arithmetic
+
+# !@group Unary operators
+	def +@
+	    self
+	end
+
+	def -@
+	    self
+	end
+# !@endgroup
+
+	def +(other)
+	    other
+	end
+
+	def -(other)
+	    if other.respond_to? :-@
+		-other
+	    elsif other.respond_to? :map
+		other.map {|a| -a }
+	    end
+	end
+
+	def *(other)
+	    self
+	end
+
+	def /(other)
+	    raise OperationNotDefined unless other.is_a? Numeric
+	    raise ZeroDivisionError if 0 == other
+	    self
+	end
+# !@endgroup
+
+    end
+end
+

data/lib/geometry/polygon.rb

@@ -13,6 +13,7 @@ An object representing a closed set of vertices and edges.
 
     class Polygon
 	attr_reader :edges, :vertices
+	alias :points :vertices
 
 	# Construct a new Polygon from Points and/or Edges
 	#  The constructor will try to convert all of its arguments into Points and

data/lib/geometry/rectangle.rb

@@ -9,12 +9,12 @@ The {Rectangle} class cluster represents your typical arrangement of 4 corners a
 == Usage
 
 === Constructors
-    rect = Rectangle[[1,2], [2,3]]	# Using two corners
-    rect = Rectangle[[1,2], Size[1,1]]	# Using origin and size
-    rect = Rectangle[1,2,2,3]		# Using four sides
+    rect = Rectangle[[1,2], [2,3]]      # Using two corners
+    rect = Rectangle[[1,2], Size[1,1]]  # Using origin and size
+    rect = Rectangle[1,2,2,3]           # Using four sides
 
-    rect = Rectangle[10, 20]		# origin = [0,0], size = [10, 20]
-    rect = Rectangle[Size[10, 20]]	# origin = [0,0], size = [10, 20]
+    rect = Rectangle[10, 20]            # origin = [0,0], size = [10, 20]
+    rect = Rectangle[Size[10, 20]]      # origin = [0,0], size = [10, 20]
 
 =end
 
@@ -81,8 +81,8 @@ The {Rectangle} class cluster represents your typical arrangement of 4 corners a
 	#   @param [Point]	point0	A corner (ie. bottom-left)
 	#   @param [Point]	point1	The other corner (ie. top-right)
 	def initialize(point0, point1)
-	    point0 = point0.is_a?(Point) ? point0 : Point[point0]
-	    point1 = point1.is_a?(Point) ? point1 : Point[point1]
+	    point0 = Point[point0]
+	    point1 = Point[point1]
 	    raise(ArgumentError, "Point sizes must match") unless point0.size == point1.size
 
 	    # Reorder the points to get lower-left and upper-right
@@ -100,9 +100,11 @@ The {Rectangle} class cluster represents your typical arrangement of 4 corners a
 	end
 
 # @group Accessors
+
+	# @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)/2.0, (max.y+min.y)/2.0]
 	end
 
 	# @return [Array<Edge>]   The {Rectangle}'s four edges
@@ -116,6 +118,14 @@ The {Rectangle} class cluster represents your typical arrangement of 4 corners a
 	     Edge.new(point3, point0)]
 	end
 
+	# @return [Array<Point>]    The {Rectangle}'s four points (clockwise)
+	def points
+	    point0, point2 = *@points
+	    point1 = Point[point0.x,point2.y]
+	    point3 = Point[point2.x, point0.y]
+	    [point0, point1, point2, point3]
+	end
+
 	def origin
 	    minx = @points.min {|a,b| a.x <=> b.x}
 	    miny = @points.min {|a,b| a.y <=> b.y}
@@ -173,8 +183,8 @@ The {Rectangle} class cluster represents your typical arrangement of 4 corners a
 # @group Accessors
 	# @return [Array<Edge>]   The {Rectangle}'s four edges
 	def edges
-	    point0 = @center - @size/2
-	    point2 = @center + @size/2
+	    point0 = @center - @size/2.0
+	    point2 = @center + @size/2.0
 	    point1 = Point[point0.x,point2.y]
 	    point3 = Point[point2.x, point0.y]
 	    [Edge.new(point0, point1),
@@ -183,6 +193,15 @@ The {Rectangle} class cluster represents your typical arrangement of 4 corners a
 	    Edge.new(point3, point0)]
 	end
 
+	# @return [Array<Point>]    The {Rectangle}'s four points (clockwise)
+	def points
+	    point0 = @center - @size/2.0
+	    point2 = @center + @size/2.0
+	    point1 = Point[point0.x,point2.y]
+	    point3 = Point[point2.x, point0.y]
+	    [point0, point1, point2, point3]
+	end
+
 	def height
 	    @size.height
 	end
@@ -249,6 +268,15 @@ The {Rectangle} class cluster represents your typical arrangement of 4 corners a
 	    Edge.new(point3, point0)]
 	end
 
+	# @return [Array<Point>]    The {Rectangle}'s four points (clockwise)
+	def points
+	    point0 = @origin
+	    point2 = @origin + @size
+	    point1 = Point[point0.x,point2.y]
+	    point3 = Point[point2.x, point0.y]
+	    [point0, point1, point2, point3]
+	end
+
 	def height
 	    @size.height
 	end