geometry 6.5 → 6.6

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    YTE5MmE5YjU5ZDBkOTZiNGY0OGI5NzU5NDU4Yzk1OTk3Y2VjNDBhYw==
-  data.tar.gz: !binary |-
-    N2QyODkzMTkwYzhkZjhmYjg2MjliOTViYTM4ZjkxN2JkMDA4NDAyOQ==
+SHA256:
+  metadata.gz: 18aa25c45e739b77377ac376b9575f9828e2eb0566b4349a073be5b4deeea20e
+  data.tar.gz: 1ddbf89f0ad3854c222ffd344c0eaedd129d315ec9b1488f503f519dc8b5ca5b
 SHA512:
-  metadata.gz: !binary |-
-    ODc3NmE4ZDEzMDg0YjVhNGI0YmU0YjY4NTNkMTM3Mjk4NDFkYjRlMDZiZjkw
-    Y2M2ZWNmYTc1NzU2ODFkN2Y2NGI3NTYzYzE2NTcwY2IwMWVlODYzM2U1NmIx
-    NzNmYjM3OTEyMDY3NGVhZjU3NTZiNzY1YmQ1ZDVmODEzODE3N2I=
-  data.tar.gz: !binary |-
-    ZDU2NTJmODQ1ZTAyMzc2NGJiNjFhM2E4NTBhNWIxNjY5M2JjNThhNWJjN2Rm
-    MjAwNTYwMjlkMWE1N2UyNTMwZTMxNWZkNDc5NTU3NzhiNDlhOTdjMmY0NzBk
-    ZWRiNmVlMDgwZjVjNzY5YjM0ZTMyM2U4M2UzOGU0MzIzYmVkMjM=
+  metadata.gz: 69645a43932bb7b4c36a6401daabf49d2bbcbf3450f750f85d1c2f60f8d1e7944cb0f1c5110569912bc10d656f3ef8a1f5ffaa80ee9eb228a8a8f7855aaed0c8
+  data.tar.gz: 8e68aa085655950d9f499a887cf9ec0aeaac2c183e53a242675105f093652fdcb141aae4cc91226bedadf97e0dd94651b25956026c78c4a98e60b57d7b232dfa

data/.github/workflows/ruby.yml

@@ -0,0 +1,21 @@
+name: Ruby
+
+on: [push]
+
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby-version: ['3.0', '3.1', '3.2', '3.3']
+        os: [ubuntu-latest]
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+    - uses: actions/checkout@v4
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true
+    - run: bundle exec rake

data/Gemfile

@@ -3,5 +3,8 @@ source "http://rubygems.org"
 gemspec
 
 group :test do
+    gem 'minitest'
     gem 'rake'
 end
+
+gem "matrix", "~> 0.4.2"

data/README.markdown

@@ -1,7 +1,6 @@
 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 
@@ -15,7 +14,7 @@ that don't work in higher dimensions and I'll do my best to fix them.
 License
 -------
 
-Copyright 2012-2014 Brandon Fosdick <bfoz@bfoz.net> and released under the BSD license.
+Copyright 2012-2024 Brandon Fosdick <bfoz@bfoz.net> and released under the BSD license.
 
 Primitives
 ----------

data/geometry.gemspec

@@ -2,8 +2,9 @@
 $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
+    spec = s
   s.name        = "geometry"
-  s.version     = '6.5'
+    spec.version	= '6.6'
   s.authors     = ["Brandon Fosdick"]
   s.email       = ["bfoz@bfoz.net"]
   s.homepage    = "http://github.com/bfoz/geometry"
@@ -18,4 +19,7 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   s.required_ruby_version = '>= 2.0'
+
+    spec.add_development_dependency "bundler", "~> 2"
+    spec.add_development_dependency "rake", "~> 13"
 end

data/lib/geometry/annulus.rb

@@ -22,7 +22,7 @@ known as a Ring, is a circle that ate another circle.
 	# @!attribute inner_radius
 	#   @return [Number]  the radius of the inside of the {Annulus}
 	def inner_radius
-	    @inner_radius || (@inner_diameter && @inner_diameter/2)
+	    @inner_radius || (@inner_diameter && @inner_diameter.to_r/2)
 	end
 
 	# @!attribute outer_diameter
@@ -34,7 +34,7 @@ known as a Ring, is a circle that ate another circle.
 	# @!attribute outer_radius
 	#   @return [Number]  the outer radius
 	def outer_radius
-	    @outer_radius || (@outer_diameter && @outer_diameter/2)
+	    @outer_radius || ((@outer_diameter && @outer_diameter).to_r/2)
 	end
 
 	# @!attribute diameter

data/lib/geometry/arc.rb

@@ -17,8 +17,15 @@ An {Arc} with its center at [1,1] and a radius of 2 that starts at the X-axis an
 	include ClusterFactory
 
 	attr_reader :center
+
+	# @return [Number]  the radius of the {Arc}
 	attr_reader :radius
-	attr_reader :start_angle, :end_angle
+
+	# @return [Number]  the starting angle of the {Arc} as radians from the x-axis
+	attr_reader :start_angle
+
+	# @return [Number]  the ending angle of the {Arc} as radians from the x-axis
+	attr_reader :end_angle
 
 	# @overload new(center, start, end)
 	#  Create a new {Arc} given center, start and end {Point}s
@@ -90,5 +97,69 @@ An {Arc} with its center at [1,1] and a radius of 2 that starts at the X-axis an
 	# The end point of the {Arc}
 	# @return [Point]
 	alias :last :end
+
+	def ==(other)
+	    if other.is_a?(ThreePointArc)
+		(self.center == other.center) && (self.end == other.end) && (self.start == other.start)
+	    else
+		super other
+	    end
+	end
+
+    # @group Attributes
+
+	# @return [Point]   The upper-right corner of the bounding rectangle that encloses the {Path}
+	def max
+	    minmax.last
+	end
+
+	# @return [Point]   The lower-left corner of the bounding rectangle that encloses the {Path}
+	def min
+	    minmax.first
+	end
+
+	# @return [Array<Point>]    The lower-left and upper-right corners of the enclosing bounding rectangle
+	def minmax
+	    a = [self.start, self.end]
+	    quadrants = a.map(&:quadrant)
+
+	    # If the Arc spans more than one quadrant, then it must cross at
+	    #  least one axis. Each axis-crossing is a potential extrema.
+	    if quadrants.first != quadrants.last
+		range = (quadrants.first...quadrants.last)
+		# If the Arc crosses the X axis...
+		if quadrants.first > quadrants.last
+		    range = (quadrants.first..4).to_a + (1...quadrants.last).to_a
+		end
+
+		a = range.map do |q|
+		    case q
+			when 1 then self.center + Point[0,radius]
+			when 2 then self.center + Point[-radius, 0]
+			when 3 then self.center + Point[0,-radius]
+			when 4 then self.center + Point[radius,0]
+		    end
+		end.push(*a)
+		a.reduce([a.first, a.first]) {|memo, e| [memo.first.min(e), memo.last.max(e)] }
+	    else
+		[a.first.min(a.last), a.first.max(a.last)]
+	    end
+	end
+
+	def end_angle
+	    a = (self.end - self.center)
+	    Math.atan2(a.y, a.x)
+	end
+
+	def radius
+	    (self.start - self.center).magnitude
+	end
+
+	def start_angle
+	    a = (self.start - self.center)
+	    Math.atan2(a.y, a.x)
+	end
+
+    # @endgroup
     end
 end

data/lib/geometry/edge.rb

@@ -1,5 +1,3 @@
-require 'mathn'
-
 require_relative 'point'
 
 module Geometry
@@ -42,6 +40,25 @@ An edge. It's a line segment between 2 points. Generally part of a {Polygon}.
 	    end
 	end
 
+    # @group Attributes
+
+	# @return [Point]   The upper-right corner of the bounding rectangle that encloses the {Edge}
+	def max
+	    first.max(last)
+	end
+
+	# @return [Point]   The lower-left corner of the bounding rectangle that encloses the {Edge}
+	def min
+	    first.min(last)
+	end
+
+	# @return [Array<Point>]    The lower-left and upper-right corners of the enclosing bounding rectangle
+	def minmax
+	    first.minmax(last)
+	end
+
+    # @endgroup
+
 	# Return a new {Edge} with swapped endpoints
 	def reverse
 	    self.class.new(@last, @first)
@@ -128,8 +145,8 @@ An edge. It's a line segment between 2 points. Generally part of a {Polygon}.
 		    nil
 		end
 	    else
-		s = (-v1[1] * p.x + v1[0] * p.y) / denominator	# v1 x (p0 - p2) / denominator
-		t = ( v2[0] * p.y - v2[1] * p.x) / denominator	# v2 x (p0 - p2) / denominator
+		s = (-v1[1] * p.x + v1[0] * p.y).to_r / denominator	# v1 x (p0 - p2) / denominator
+		t = ( v2[0] * p.y - v2[1] * p.x).to_r / denominator	# v2 x (p0 - p2) / denominator
 
 		p0 + v1 * t if ((0..1) === s) && ((0..1) === t)
 	    end

data/lib/geometry/line.rb

@@ -190,7 +190,7 @@ Supports two-point, slope-intercept, and point-slope initializer forms
 		    ((other.first.y == slope * other.first.x + intercept)) && (other.last.y == (slope * other.last.x + intercept))
 		else
 		    self.eql? other
-		end
+	    end
 	end
 
 	# Two {SlopeInterceptLine}s are equal if both have equal slopes and intercepts
@@ -251,7 +251,7 @@ Supports two-point, slope-intercept, and point-slope initializer forms
 		    ((first.y == other.slope * first.x + other.intercept)) && (last.y == (other.slope * last.x + other.intercept))
 		else
 		    self.eql?(other) || ((first == other.last) && (last == other.first))
-		end
+	    end
 	end
 
 	# Two {TwoPointLine}s are equal if both have equal endpoints

data/lib/geometry/obround.rb

@@ -180,8 +180,6 @@ The {Obround} class cluster represents a rectangle with semicircular end caps
     end
 
     class SizedObround < Obround
-	# @return [Point]   The {Obround}'s center
-	attr_reader :center
 	# @return [Point]	The {Obround}'s origin
 	attr_accessor :origin
 	# @return [Size]	The {Size} of the {Obround}
@@ -219,6 +217,7 @@ The {Obround} class cluster represents a rectangle with semicircular end caps
 	alias :== :eql?
 
 # @group Accessors
+	# @return [Point]   The {Obround}'s center
 	def center
 	    @origin + @size/2
 	end

data/lib/geometry/path.rb

@@ -52,11 +52,38 @@ An object representing a set of connected elements, each of which could be an
 	    end
 	end
 
+	def ==(other)
+	    if other.is_a?(Path)
+		@elements == other.elements
+	    else
+		super other
+	    end
+	end
+
+    # @group Attributes
+
+	# @return [Point]   The upper-right corner of the bounding rectangle that encloses the {Path}
+	def max
+	    elements.reduce(elements.first.max) {|memo, e| memo.max(e.max) }
+	end
+
+	# @return [Point]   The lower-left corner of the bounding rectangle that encloses the {Path}
+	def min
+	    elements.reduce(elements.first.min) {|memo, e| memo.min(e.max) }
+	end
+
+	# @return [Array<Point>]    The lower-left and upper-right corners of the enclosing bounding rectangle
+	def minmax
+	    elements.reduce(elements.first.minmax) {|memo, e| [memo.first.min(e.min), memo.last.max(e.max)] }
+	end
+
 	# @return [Geometry]	The last element in the {Path}
 	def last
 	    @elements.last
 	end
 
+    # @endgroup
+
 	# Append a new geometry element to the {Path}
 	# @return [Path]
 	def push(arg)

data/lib/geometry/point.rb

@@ -21,8 +21,6 @@ geometry class (x, y, z).
     point = Geometry::Point[x,y]
 =end
     class Point < Vector
-	attr_reader :x, :y, :z
-
 	# Allow vector-style initialization, but override to support copy-init
 	# from Vector or another Point
 	#
@@ -34,15 +32,15 @@ geometry class (x, y, z).
 	    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
+	    super(*array)
 	end
 
-	# Creates and returns a new {PointIso} instance. Or, a {Point} full of ones if the size argument is given.
+	# Creates and returns a new {PointIso} instance. Or, a {Point} full of the given value 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)
+	    size ? Point[Array.new(size, value)] : PointIso.new(value)
 	end
 
 	# Creates and returns a new {PointOne} instance. Or, a {Point} full of ones if the size argument is given.
@@ -119,6 +117,8 @@ geometry class (x, y, z).
 	    'Point' + @elements.to_s
 	end
 
+    # @group Attributes
+
 	# @override max()
 	# @return [Number]  The maximum value of the {Point}'s elements
 	# @override max(point)
@@ -169,6 +169,22 @@ geometry class (x, y, z).
 	    end
 	end
 
+	# Return the {Point}'s quadrant in the 2D Cartesian Euclidean Plane
+	# https://en.wikipedia.org/wiki/Quadrant_(plane_geometry)
+	# @note Undefined for all points on the axes, and for dimensionalities other than 2
+	# @todo Define the results for points on the axes
+	# @return [Bool]    The {Point}'s quadrant in the 2D Cartesian Euclidean Plane
+	def quadrant
+	    return nil unless elements[1]
+	    if elements.first > 0
+		(elements[1] > 0) ? 1 : 4
+	    else
+		(elements[1] > 0) ? 2 : 3
+	    end
+	end
+
+    # @endgroup
+
 	# Returns a new {Point} with the given number of elements removed from the end
 	# @return [Point]   the popped elements
 	def pop(count=1)
@@ -298,4 +314,3 @@ geometry class (x, y, z).
 
     end
 end
-

data/lib/geometry/point_iso.rb

@@ -1,5 +1,3 @@
-require_relative 'point'
-
 module Geometry
 =begin rdoc
 An object repesenting a N-dimensional {Point} with identical elements.

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

data/lib/geometry/point_zero.rb

@@ -1,4 +1,3 @@
-require_relative 'point'
 require_relative 'point_iso'
 
 module Geometry

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.