geometry 6.2 → 6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c1d1683621a91df0a25df4e3f2cc4fe6ecdf3dfb
-  data.tar.gz: 597979326e97270c5fd7f037615f391e7f50fc18
+  metadata.gz: 8d541e7a304b060e2bc7bd392a4530fbfca3040b
+  data.tar.gz: 9f4bfc263c8c735ed3d28a6f32f676e0fe3606c4
 SHA512:
-  metadata.gz: 2fbe85bbe712dff07a728326e3aafc40325849f03cb995221b8a6f65e6f4b3a6ba6b10de21f13e0ed4b18b92664f92ecb1b99a67b013430173494a35449354b2
-  data.tar.gz: 5f1e1ddc4670af310745a74951eb6280bd4d515122ade09df4bc9cbbc40c6247fc5131c3ee7ef46f9d9ea4e707850e8462c03e458e6443e1793f374f950344d4
+  metadata.gz: e9e952e9d9c66085aa7fc2852605467b8456ab30ac05d6106f5593b183d6ff865ec812d47d63f32f01b280838b51d93ec58811542b1adfc5b6632b9c57cfc7fc
+  data.tar.gz: 53f91b55768b360e9f07026228b150d7f250dc866098eba904b01ad0ee4d2cf9eb693399ec95a44b1a5ab6640ec8898ce68690e9971e5500456ad06db6a84b7d

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 2.1.1

data/README.markdown

@@ -2,6 +2,7 @@ Geometry for Ruby
 =================
 
 [![Build Status](https://travis-ci.org/bfoz/geometry.png)](https://travis-ci.org/bfoz/geometry)
+[![Gem Version](https://badge.fury.io/rb/geometry.svg)](http://badge.fury.io/rb/geometry)
 
 Classes and methods for the handling of all of the basic geometry that you 
 learned in high school (and then forgot).
@@ -23,6 +24,7 @@ Primitives
 - Size
 - Line
 - Edge
+- [Annulus](http://en.wikipedia.org/wiki/Annulus_(mathematics))
 - [Arc](http://en.wikipedia.org/wiki/Arc_(geometry)), Circle
 - Rectangle, Square
 - Path, [Polyline](http://en.wikipedia.org/wiki/Polyline), [Polygon](http://en.wikipedia.org/wiki/Polygon), [RegularPolygon](http://en.wikipedia.org/wiki/Regular_polygon)
@@ -35,71 +37,83 @@ Examples
 
 ### Point
 ```ruby
-    point = Geometry::Point[3,4]    # 2D Point at coordinate 3, 4
+point = Geometry::Point[3,4]    # 2D Point at coordinate 3, 4
 
-    # Copy constructors
-    point2 = Geometry::Point[point]
-    point2 = Geometry::Point[Vector[5,6]]
+# Copy constructors
+point2 = Geometry::Point[point]
+point2 = Geometry::Point[Vector[5,6]]
 
-    # Accessors
-    point.x
-    point.y
-    point[2]	# Same as point.z
+# Accessors
+point.x
+point.y
+point[2]	# Same as point.z
 
-    # Zero
-    PointZero.new   # A Point full of zeros of unspecified length
-    Point.zero      # Another way to do the same thing
-    Point.zero(3)   # => Point[0,0,0]
+# Zero
+PointZero.new   # A Point full of zeros of unspecified length
+Point.zero      # Another way to do the same thing
+Point.zero(3)   # => Point[0,0,0]
 ```
 
 ### Line
 ```ruby
-    # Two-point constructors
-    line = Geometry::Line[[0,0], [10,10]]
-    line = Geometry::Line[Geometry::Point[0,0], Geometry::Point[10,10]]
-    line = Geometry::Line[Vector[0,0], Vector[10,10]]
-
-    # Slope-intercept constructors
-    Geometry::Line[Rational(3,4), 5]	# Slope = 3/4, Intercept = 5
-    Geometry::Line[0.75, 5]
-
-    # Point-slope constructors
-    Geometry::Line(Geometry::Point[0,0], 0.75)
-    Geometry::Line(Vector[0,0], Rational(3,4))
-
-    # Special constructors (2D only)
-    Geometry::Line.horizontal(y=0)
-    Geometry::Line.vertical(x=0)
+# Two-point constructors
+line = Geometry::Line[[0,0], [10,10]]
+line = Geometry::Line[Geometry::Point[0,0], Geometry::Point[10,10]]
+line = Geometry::Line[Vector[0,0], Vector[10,10]]
+
+# Slope-intercept constructors
+Geometry::Line[Rational(3,4), 5]	# Slope = 3/4, Intercept = 5
+Geometry::Line[0.75, 5]
+
+# Point-slope constructors
+Geometry::Line(Geometry::Point[0,0], 0.75)
+Geometry::Line(Vector[0,0], Rational(3,4))
+
+# Special constructors (2D only)
+Geometry::Line.horizontal(y=0)
+Geometry::Line.vertical(x=0)
 ```
 
 ### Rectangle
 ```ruby
-    # A Rectangle made from two corner points
-    Geometry::Rectangle.new [1,2], [2,3]
-    Geometry::Rectangle.new from:[1,2], to:[2,3]
+# A Rectangle made from two corner points
+Geometry::Rectangle.new [1,2], [2,3]
+Geometry::Rectangle.new from:[1,2], to:[2,3]
 
-    Geometry::Rectangle.new center:[1,2], size:[1,1]	# Using a center point and a size
-    Geometry::Rectangle.new origin:[1,2], size:[1,1]	# Using an origin point and a size
+Geometry::Rectangle.new center:[1,2], size:[1,1]	# Using a center point and a size
+Geometry::Rectangle.new origin:[1,2], size:[1,1]	# Using an origin point and a size
 
-    # A Rectangle with its origin at [0, 0] and a size of [10, 20]
-    Geometry::Rectangle.new size: [10, 20]
-    Geometry::Rectangle.new size: Size[10, 20]
-    Geometry::Rectangle.new width: 10, height: 20
+# A Rectangle with its origin at [0, 0] and a size of [10, 20]
+Geometry::Rectangle.new size: [10, 20]
+Geometry::Rectangle.new size: Size[10, 20]
+Geometry::Rectangle.new width: 10, height: 20
 ```
 
 ### Circle
 ```ruby
-    # A circle at Point[1,2] with a radius of 3
-    circle = Geometry::Circle.new center:[1,2], radius:3
+# A circle at Point[1,2] with a radius of 3
+circle = Geometry::Circle.new center:[1,2], radius:3
 ```
 
 ### Polygon
 ```ruby
-    # A polygon that looks a lot like a square
-    polygon = Geometry::Polygon.new [0,0], [1,0], [1,1], [0,1]
+# A polygon that looks a lot like a square
+polygon = Geometry::Polygon.new [0,0], [1,0], [1,1], [0,1]
 ```
 ### Regular Polygon
 ```ruby
-    # Everyone loves a good hexagon
-    hexagon = Geometry::RegularPolygon.new 6, :diameter => 3
-```
+# Everyone loves a good hexagon
+hexagon = Geometry::RegularPolygon.new 6, :diameter => 3
+```
+
+### Zeros and Ones
+```ruby
+# For when you know you need a zero, but you don't know how big it should be
+zero = Point.zero       # Returns a Point of indeterminate length that always compares equal to zero
+
+# Oh, you wanted ones instead? No problem.
+ones = Point.one        # => Point[1,1,1...1]
+
+# Looking for something more exotic that a mere 1?
+iso = Point.iso(5)      # => Point[5,5,5...5]
+```

data/geometry.gemspec

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

data/lib/geometry.rb

@@ -1,3 +1,4 @@
+require_relative 'geometry/annulus'
 require_relative 'geometry/arc'
 require_relative 'geometry/circle'
 require_relative 'geometry/line'

data/lib/geometry/annulus.rb

@@ -0,0 +1,74 @@
+module Geometry
+
+=begin rdoc
+An {http://en.wikipedia.org/wiki/Annulus_(mathematics) Annulus}, more commonly 
+known as a Ring, is a circle that ate another circle.
+
+== Usage
+    ring = Geometry::Annulus.new center:[1,2], inner_radius:5, radius:10
+    ring = Geometry::Ring.new center:[1,2], inner_radius:5, radius:10
+=end
+    class Annulus
+	# @!attribute center
+	#   @return [Point]  The center point of the {Annulus}
+	attr_accessor :center
+
+	# @!attribute inner_diameter
+	#   @return [Number]  the diameter of the inside of the {Annulus}
+	def inner_diameter
+	    @inner_diameter || (@inner_radius && 2*@inner_radius)
+	end
+
+	# @!attribute inner_radius
+	#   @return [Number]  the radius of the inside of the {Annulus}
+	def inner_radius
+	    @inner_radius || (@inner_diameter && @inner_diameter/2)
+	end
+
+	# @!attribute outer_diameter
+	#   @return [Number]  the out diameter
+	def outer_diameter
+	    @outer_diameter || (@outer_radius && 2*@outer_radius)
+	end
+
+	# @!attribute outer_radius
+	#   @return [Number]  the outer radius
+	def outer_radius
+	    @outer_radius || (@outer_diameter && @outer_diameter/2)
+	end
+
+	# @!attribute diameter
+	#   @return [Number]  the outer diameter
+	alias :diameter :outer_diameter
+
+	# @!attribute radius
+	#   @return [Number]  the outer radius
+	alias :radius :outer_radius
+
+	# @note
+	#  The 'center' argument can also be passed as a named argument of the same name
+	# @overload initialize(center, :inner_radius, :outer_radius)
+	#   @param center	 [Point]    The center {Point}, defaults to the origin
+	#   @param :inner_radius [Number]   The radius of the hole that's in the center
+	#   @param :outer_radius [Number]   The overall radius of the whole thing
+	# @overload initialize(center, :inner_diameter, :outer_diameter)
+	#   @param center	    [Point]	The center {Point}, defaults to the origin
+	#   @param :inner_diameter  [Number]	The radius of the hole that's in the center
+	#   @param :outer_diameter  [Number]	The overall radius of the whole thing
+	def initialize(center = Point.zero, **options)
+	    @center = Point[options.fetch(:center, center)]
+
+	    options.delete :center
+	    raise ArgumentError, 'Annulus requires more than a center' if options.empty?
+
+	    @inner_diameter = options[:inner_diameter]
+	    @inner_radius = options[:inner_radius]
+	    @outer_diameter = options[:outer_diameter] || options[:diameter]
+	    @outer_radius = options[:outer_radius] || options[:radius]
+	end
+    end
+
+    # Ring is an alias of Annulus because that's the word that most people use,
+    #  despite the proclivities of mathmeticians.
+    Ring = Annulus
+end

data/lib/geometry/circle.rb

@@ -71,6 +71,12 @@ Circles come in all shapes and sizes, but they're usually round.
 	    return Rectangle.new(self.min, self.max)
 	end
 
+	# @!attribute closed?
+	#   @return [Bool]  always true
+	def closed?
+	    true
+	end
+
 	# @!attribute [r] diameter
 	#   @return [Numeric] The diameter of the {Circle}
 	def diameter

data/lib/geometry/edge.rb

@@ -70,7 +70,8 @@ An edge. It's a line segment between 2 points. Generally part of a {Polygon}.
 
 	# @return [Bool] Returns true if the passed {Edge} is parallel to the receiver
 	def parallel?(edge)
-	    v1, v2 = self.direction, edge.direction
+	    v1 = self.direction
+	    v2 = edge.direction
 	    winding = v1[0]*v2[1] - v1[1]*v2[0]
 	    if 0 == winding	# collinear?
 		if v1 == v2
@@ -89,9 +90,10 @@ An edge. It's a line segment between 2 points. Generally part of a {Polygon}.
 	    (@first == other.last) || (@last == other.first) || (@first == other.first) || (@last == other.last)
 	end
 
+	# @!attribute [r] direction
 	# @return [Vector]  A unit {Vector} pointing from first to last
 	def direction
-	    self.vector.normalize
+	    @direction ||= self.vector.normalize
 	end
 
 	# Find the intersection of two {Edge}s (http://bloggingmath.wordpress.com/2009/05/29/line-segment-intersection/)
@@ -128,9 +130,10 @@ An edge. It's a line segment between 2 points. Generally part of a {Polygon}.
 	    end
 	end
 
+	# @!attribute [r] vector
 	# @return [Vector]  A {Vector} pointing from first to last
 	def vector
-	    last - first
+	    @vector ||= last - first
 	end
 
 	def to_a

data/lib/geometry/obround.rb

@@ -90,6 +90,12 @@ The {Obround} class cluster represents a rectangle with semicircular end caps
 	    Point[(max.x+min.x)/2, (max.y+min.y)/2]
 	end
 
+	# @!attribute closed?
+	#   @return [Bool]  always true
+	def closed?
+	    true
+	end
+
 	# @return [Array<Point>]    The {Obround}'s four points (counterclockwise)
 	def points
 	    point0, point2 = *@points

data/lib/geometry/point.rb

@@ -1,5 +1,7 @@
 require 'matrix'
 
+require_relative 'point_iso'
+require_relative 'point_one'
 require_relative 'point_zero'
 
 module Geometry
@@ -29,12 +31,27 @@ geometry class (x, y, z).
 	# @overload [](Point)
 	# @overload [](Vector)
 	def self.[](*array)
-	    return array[0] if array[0].is_a?(Point) or array[0].is_a?(PointZero)
+	    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 {PointIso} instance. Or, a {Point} full of ones if the size argument is given.
+	# @param value [Number]	the value of the elements
+	# @param size [Number] the size of the new {Point} full of ones
+	# @return [PointIso] A new {PointIso} instance
+	def self.iso(value, size=nil)
+	    size ? Point[Array.new(size, 1)] : PointIso.new(value)
+	end
+
+	# Creates and returns a new {PointOne} instance. Or, a {Point} full of ones if the size argument is given.
+	# @param size [Number] the size of the new {Point} full of ones
+	# @return [PointOne] A new {PointOne} instance
+	def self.one(size=nil)
+	    size ? Point[Array.new(size, 1)] : PointOne.new
+	end
+
 	# Creates and returns a new {PointZero} instance. Or, a {Point} full of zeros if the size argument is given.
 	# @param size [Number] the size of the new {Point} full of zeros
 	# @return [PointZero] A new {PointZero} instance
@@ -51,6 +68,11 @@ geometry class (x, y, z).
 	def eql?(other)
 	    if other.is_a?(Array)
 		@elements.eql? other
+	    elsif other.is_a?(PointIso)
+		value = other.value
+		@elements.all? {|e| e.eql? value }
+	    elsif other.is_a?(PointOne)
+		@elements.all? {|e| e.eql? 1 }
 	    elsif other.is_a?(PointZero)
 		@elements.all? {|e| e.eql? 0 }
 	    else
@@ -62,6 +84,11 @@ geometry class (x, y, z).
 	def ==(other)
 	    if other.is_a?(Array)
 		@elements.eql? other
+	    elsif other.is_a?(PointIso)
+		value = other.value
+		@elements.all? {|e| e.eql? value }
+	    elsif other.is_a?(PointOne)
+		@elements.all? {|e| e.eql? 1 }
 	    elsif other.is_a?(PointZero)
 		@elements.all? {|e| e.eql? 0 }
 	    else
@@ -95,8 +122,8 @@ geometry class (x, y, z).
 # @group Accessors
 	# @param [Integer]  i	Index into the {Point}'s elements
 	# @return [Numeric] Element i (starting at 0)
-	def [](i)
-	    @elements[i]
+	def [](*args)
+	    @elements[*args]
 	end
 
 	# @attribute [r] x
@@ -134,6 +161,11 @@ geometry class (x, y, z).
 	    case other
 		when Numeric
 		    Point[@elements.map {|e| e + other}]
+		when PointIso
+		    value = other.value
+		    Point[@elements.map {|e| e + value}]
+		when PointOne
+		    Point[@elements.map {|e| e + 1}]
 		when PointZero, NilClass
 		    self.dup
 		else
@@ -147,6 +179,11 @@ geometry class (x, y, z).
 	    case other
 		when Numeric
 		    Point[@elements.map {|e| e - other}]
+		when PointIso
+		    value = other.value
+		    Point[@elements.map {|e| e - value}]
+		when PointOne
+		    Point[@elements.map {|e| e - 1}]
 		when PointZero, NilClass
 		    self.dup
 		else

data/lib/geometry/point_iso.rb

@@ -0,0 +1,133 @@
+require_relative 'point'
+
+module Geometry
+=begin rdoc
+An object repesenting a N-dimensional {Point} with identical elements.
+=end
+    class PointIso
+	# @!attribute value
+	#   @return [Number]  the value for every element
+	attr_accessor :value
+
+	# Initialize to the given value
+	# @param value [Number]	the value for every element of the new {PointIso}
+ 	def initialize(value)
+	    @value = value
+	end
+
+	def eql?(other)
+	    if other.respond_to? :all?
+		other.all? {|e| e.eql? @value}
+	    else
+		other == @value
+	    end
+	end
+	alias == eql?
+
+	def coerce(other)
+	    if other.is_a? Numeric
+		[other, @value]
+	    elsif other.is_a? Array
+		[other, Array.new(other.size, @value)]
+	    elsif other.is_a? Vector
+		[other, Vector[*Array.new(other.size, @value)]]
+	    else
+		[Point[other], Point[Array.new(other.size, @value)]]
+	    end
+	end
+
+	def inspect
+	    'PointIso<' + @value.inspect + '>'
+	end
+	def to_s
+	    'PointIso<' + @value.to_s + '>'
+	end
+
+	def is_a?(klass)
+	    (klass == Point) || super
+	end
+	alias :kind_of? :is_a?
+
+	# This is a hack to get Array#== to work properly. It works on ruby 2.0 and 1.9.3.
+	def to_ary
+	    []
+	end
+
+# @group Accessors
+	# @param i [Integer]	Index into the {Point}'s elements
+	# @return [Numeric] Element i (starting at 0)
+	def [](i)
+	    @value
+	end
+
+	# @attribute [r] x
+	#   @return [Numeric] X-component
+	def x
+	    @value
+	end
+
+	# @attribute [r] y
+	#   @return [Numeric] Y-component
+	def y
+	    @value
+	end
+
+	# @attribute [r] z
+	#   @return [Numeric] Z-component
+	def z
+	    @value
+	end
+# @endgroup
+
+# @group Arithmetic
+
+# @group Unary operators
+	def +@
+	    self
+	end
+
+	def -@
+	    self.class.new(-@value)
+	end
+# @endgroup
+
+	def +(other)
+	    case other
+		when Numeric
+		    other + @value
+		when Size
+		    Point[other.map {|a| a + @value }]
+		else
+		    if other.respond_to?(:map)
+			other.map {|a| a + @value }
+		    else
+			Point[other + @value]
+		    end
+	    end
+	end
+
+	def -(other)
+	    if other.is_a? Size
+		Point[other.map {|a| @value - a }]
+	    elsif other.respond_to? :map
+		other.map {|a| @value - a }
+	    else
+		@value - other
+	    end
+	end
+
+	def *(other)
+	    raise OperationNotDefined unless other.is_a? Numeric
+	    self.class.new(other * @value)
+	end
+
+	def /(other)
+	    raise OperationNotDefined unless other.is_a? Numeric
+	    raise ZeroDivisionError if 0 == other
+	    self.class.new(@value / other)
+	end
+# @endgroup
+
+    end
+end
+