geometry 0

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+
+.DS_Store
+*.xcodeproj

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in geometry.gemspec
+gemspec

data/README

@@ -0,0 +1,60 @@
+Geometry for Ruby
+=================
+
+Classes and methods for the handling of all of the basic geometry that you 
+learned in high school (and then forgot).
+
+The classes in this libary are based on the Vector class provided by the Ruby 
+standard library. Geometric primitives are generally assumed to lie in 2D space,
+but aren't necessarily restricted to it. Please let me know if you find cases 
+that don't work in higher dimensions and I'll do my best to fix them.
+
+License
+-------
+
+Copyright 2012 Brandon Fosdick <bfoz@bfoz.net> and released under the BSD 
+license.
+
+Primitives
+----------
+
+- Point
+- Line
+
+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]
+    point2 = Geometry::Point[Vector[5,6]]
+
+    # Accessors
+    point.x
+    point.y
+    point[2]	# Same as point.z
+```
+
+### 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)
+```

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/geometry.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "geometry"
+  s.version     = '0'
+  s.authors     = ["Brandon Fosdick"]
+  s.email       = ["bfoz@bfoz.net"]
+  s.homepage    = "http://github.com/bfoz/geometry"
+  s.summary     = %q{Geometric primitives and algoritms}
+  s.description = %q{Geometric primitives and algorithms for Ruby}
+
+  s.rubyforge_project = "geometry"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/lib/geometry.rb

@@ -0,0 +1,6 @@
+require_relative 'point'
+require_relative 'line'
+
+module Geometry
+  # Your code goes here...
+end

data/lib/line.rb

@@ -0,0 +1,85 @@
+require_relative 'point'
+
+module Geometry
+    class Line
+	def self.[](*args)
+	    Geometry.Line(*args)
+	end
+	def self.horizontal(y_intercept=0)
+	    SlopeInterceptLine.new(0, y_intercept)
+	end
+	def self.vertical(x_intercept=0)
+	    SlopeInterceptLine.new(1/0.0, x_intercept)
+	end
+    end
+
+    class PointSlopeLine < Line
+	def initialize(point, slope)
+	    @point = point.is_a?(Geometry::Point) ? point : Geometry.Point(point)
+	    @slope = slope
+	end
+	def to_s
+	    'Line(' + @slope.to_s + ',' + @point.to_s + ')'
+	end
+    end
+
+    class SlopeInterceptLine < Line
+	def initialize(slope, intercept)
+	    @slope = slope
+	    @intercept = intercept
+	end
+	
+	def horizontal?
+	    0 == @slope
+	end
+	def vertical?
+	    (1/0.0) == @slope
+	end
+
+	def intercept(axis=:y)
+	    case axis
+		when :x
+		    vertical? ? @intercept : (horizontal? ? nil : (-@intercept/@slope))
+		when :y
+		    vertical? ? nil : @intercept
+	    end
+	end
+	def slope
+	    @slope
+	end
+
+	def to_s
+	    'Line(' + @slope.to_s + ',' + @intercept.to_s + ')'
+	end
+    end
+
+    class TwoPointLine < Line
+	attr_reader :first, :last
+
+	def initialize(point0, point1)
+	    @first, @last = [point0, point1].map {|p| p.is_a?(Point) ? p : Geometry.Point(p) }
+	end
+	def inspect
+	    'Line(' + @first.to_s + ', ' + @last.to_s + ')'
+	end
+	alias :to_s :inspect
+    end
+
+    def self.Line(*args)
+	if( 2 == args.size )
+	    args.map! {|x| x.is_a?(Array) ? Point[*x] : x}
+
+	    # If both args are Points, create a TwoPointLine
+	    return TwoPointLine.new(*args) if args.all? {|x| x.is_a?(Vector)}
+
+	    # If only the first arg is a Point, create a PointSlopeLine
+	    return PointSlopeLine.new(*args) if args.first.is_a?(Vector)
+
+	    # Otherise, create a SlopeInterceptLine
+	    return SlopeInterceptLine.new(*args)
+	else
+	    nil
+	end
+    end
+end
+

data/lib/point.rb

@@ -0,0 +1,39 @@
+require 'matrix'
+
+module Geometry
+    class Point < Vector
+	
+	# Custom accessors to enable a more natural notation
+	def x
+	    @elements[0]
+	end
+	def y
+	    @elements[1]
+	end
+	def z
+	    @elements[2]
+	end
+
+	# Allow vector-style initialization, but override to
+	#  support copy-init from another Vector or Point
+	def self.[](*array)
+	    array = array[0] if array[0].is_a?(Array)
+	    return Point[*(array[0].to_a)] if array[0].is_a?(Vector)
+	    super *array
+	end
+
+	def inspect
+	    'Point' + @elements.inspect
+	end
+	def to_s
+	    'Point' + @elements.to_s
+	end
+    end
+    
+end
+
+def Geometry.Point(*args)
+    args[0] = args[0].to_a if args[0].is_a?(Vector)
+    args = args[0] if args[0].is_a?(Array)
+    Geometry::Point[*args]
+end

data/test/test_line.rb

@@ -0,0 +1,84 @@
+require 'test/unit'
+require_relative 'test_unit_extensions'
+require_relative '../lib/line'
+
+class PointTest < Test::Unit::TestCase
+    must "create a Line object from 2 Points" do
+	line = Geometry::Line[Geometry::Point[0,0], Geometry::Point[10,10]]
+	assert_kind_of(Geometry::Line, line)
+	assert_kind_of(Geometry::TwoPointLine, line)
+    end
+    must "create a Line object from two arrays" do
+	line = Geometry::Line[[0,0], [10,10]]
+	assert(line.is_a?(Geometry::Line))
+	assert_kind_of(Geometry::TwoPointLine, line)
+	assert_kind_of(Geometry::Point, line.first)
+	assert_kind_of(Geometry::Point, line.last)
+    end
+    must "create a Line object from two Vectors" do
+	line = Geometry::Line[Vector[0,0], Vector[10,10]]
+	assert(line.is_a?(Geometry::Line))
+	assert_kind_of(Geometry::TwoPointLine, line)
+    end
+
+    must "create a Line from a slope and y-intercept" do
+	line = Geometry::Line[0.75, 5]
+	assert(line.is_a?(Geometry::Line))
+	assert_kind_of(Geometry::SlopeInterceptLine, line)
+	assert_equal(5, line.intercept)
+	assert_equal(0.75, line.slope)
+    end
+
+    must "create a Line from a Rational slope and y-intercept" do
+	line = Geometry::Line[Rational(3,4), 5]
+	assert_kind_of(Geometry::SlopeInterceptLine, line)
+	assert(line.is_a?(Geometry::Line))
+	assert_equal(Rational(3,4), line.slope)
+    end
+
+    must "have a special constructor for horizontal lines" do
+	line = Geometry::Line.horizontal
+	assert(line.horizontal?)
+    end
+    must "have a special constructor for vertical lines" do
+	line = Geometry::Line.vertical
+	assert(line.vertical?)
+    end
+
+    must "have accessor for y-intercept" do
+	line = Geometry::Line[0.75, 5]
+	assert_equal(5, line.intercept)
+	assert_equal(5, line.intercept(:y))
+    end
+    must "have accessor for x-intercept" do
+	line = Geometry::Line.vertical(7)
+	assert_equal(7, line.intercept(:x))
+    end
+
+    must "return the correct x-intercept for vertical lines" do
+	line = Geometry::Line.vertical(7)
+	assert_equal(7, line.intercept(:x))
+    end
+    must "return the correct y-intercept for horizontal lines" do
+	line = Geometry::Line.horizontal(4)
+	assert_equal(4, line.intercept(:y))
+    end
+
+    must "return nil x-intercept for horizontal lines" do
+	line = Geometry::Line.horizontal
+	assert_nil(line.intercept(:x))
+    end
+    must "return nil y-intercept for vertical lines" do
+	line = Geometry::Line.vertical
+	assert_nil(line.intercept(:y))
+    end
+
+    must "implement inspect" do
+	line = Geometry::Line[[0,0], [10,10]]
+	assert_equal('Line(Point[0, 0], Point[10, 10])', line.inspect)
+    end
+    must "implement to_s" do
+	line = Geometry::Line[[0,0], [10,10]]
+	assert_equal('Line(Point[0, 0], Point[10, 10])', line.to_s)
+    end
+end

data/test/test_point.rb

@@ -0,0 +1,75 @@
+require 'test/unit'
+require_relative 'test_unit_extensions'
+require_relative '../lib/point'
+
+class PointTest < Test::Unit::TestCase
+    must "create a Point object using list syntax" do
+	point = Geometry::Point[2,1]
+	assert_equal(2, point.size)
+	assert_equal(2, point.x)
+	assert_equal(1, point.y)
+    end
+    must "create a Point object from an array" do
+	point = Geometry::Point([3,4])
+	assert_equal(2, point.size)
+	assert_equal(3, point.x)
+	assert_equal(4, point.y)
+    end
+    must "create a Point object from an array using list syntax" do
+	point = Geometry::Point[[3,4]]
+	assert_equal(2, point.size)
+	assert_equal(3, point.x)
+	assert_equal(4, point.y)
+    end
+    must "create a Point object from individual parameters" do
+	point = Geometry.Point(3,4)
+	assert_equal(2, point.size)
+	assert_equal(3, point.x)
+	assert_equal(4, point.y)
+    end
+    must "create a Point object from a Vector" do
+	point = Geometry.Point(Vector[3,4])
+	assert_equal(2, point.size)
+	assert_equal(3, point.x)
+	assert_equal(4, point.y)
+    end
+    must "create a Point object from a Point" do
+	point = Geometry.Point(Geometry::Point[3,4])
+	assert_equal(2, point.size)
+	assert_equal(3, point.x)
+	assert_equal(4, point.y)
+    end
+    must "create a Point object from a Vector using list syntax" do
+	point = Geometry::Point[Vector[3,4]]
+	assert_equal(2, point.size)
+	assert_equal(3, point.x)
+	assert_equal(4, point.y)
+    end
+    must "create a Point object from a Point using list syntax" do
+	point = Geometry::Point[Geometry::Point[13,14]]
+	assert_equal(2, point.size)
+	assert_equal(13, point.x)
+	assert_equal(14, point.y)
+    end
+    must "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])
+    end
+    must "allow named element access" do
+	point = Geometry::Point[5,6,7]
+	assert_equal(3, point.size)
+	assert_equal(5, point.x)
+	assert_equal(6, point.y)
+	assert_equal(7, point.z)
+    end
+    must "implement inspect" do
+	point = Geometry::Point[8,9]
+	assert_equal('Point[8, 9]', point.inspect)
+    end
+    must "implement to_s" do
+	point = Geometry::Point[10,11]
+	assert_equal('Point[10, 11]', point.to_s)
+    end
+end

data/test/test_unit_extensions.rb

@@ -0,0 +1,23 @@
+# https://github.com/sandal/rbp/blob/master/testing/test_unit_extensions.rb
+
+module Test::Unit
+  # Used to fix a minor minitest/unit incompatibility in flexmock
+  AssertionFailedError = Class.new(StandardError)
+
+  class TestCase
+
+    def self.must(name, &block)
+      test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
+      defined = instance_method(test_name) rescue false
+      raise "#{test_name} is already defined in #{self}" if defined
+      if block_given?
+        define_method(test_name, &block)
+      else
+        define_method(test_name) do
+          flunk "No implementation provided for #{name}"
+        end
+      end
+    end
+
+  end
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: geometry
+version: !ruby/object:Gem::Version
+  version: '0'
+  prerelease: 
+platform: ruby
+authors:
+- Brandon Fosdick
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-08 00:00:00.000000000 Z
+dependencies: []
+description: Geometric primitives and algorithms for Ruby
+email:
+- bfoz@bfoz.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README
+- Rakefile
+- geometry.gemspec
+- lib/geometry.rb
+- lib/line.rb
+- lib/point.rb
+- test/test_line.rb
+- test/test_point.rb
+- test/test_unit_extensions.rb
+homepage: http://github.com/bfoz/geometry
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: geometry
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Geometric primitives and algoritms
+test_files:
+- test/test_line.rb
+- test/test_point.rb
+- test/test_unit_extensions.rb