flash_math 0.0.1

data/spec/lib/geometry/geometric_distance_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe GeometricDistance do
+
+  describe '#initialize_by_numbers' do
+    distance = GeometricDistance.new(1, 2)
+
+    it 'to be equal' do
+      expect(distance.point1).to eq(1)
+      expect(distance.point2).to eq(2)
+    end
+
+    it 'to be not equal' do
+      expect(distance.point1).not_to eq(3)
+      expect(distance.point2).not_to eq(3)
+    end
+  end
+
+  describe '#initialize_by_array' do
+    point1 = GeometricPoint.new(1, 2)
+    point2 = GeometricPoint.new(1, 1)
+    distance = GeometricDistance.new_by_arrays([1, 2], [1, 1])
+
+    it 'to be equal' do
+      expect(distance.point1).to eq(point1)
+      expect(distance.point2).to eq(point2)
+    end
+
+    it 'to be not equal' do
+      expect(distance.point1).not_to eq(point2)
+      expect(distance.point2).not_to eq(point1)
+    end
+  end
+
+  describe '#distance' do
+    it 'to be distance between two points' do
+      expect(GeometricDistance.new_by_arrays([1, 1], [1, 2]).distance).to eq(1)
+      expect(GeometricDistance.new_by_arrays([1, 1], [2, 1]).distance).to eq(1)
+      expect(GeometricDistance.new_by_arrays([1, 1], [2, 2]).distance).to eq(1.4142135623730951)
+    end
+  end
+
+  describe '#midpoint' do
+    it 'to be midpoint' do
+      expect(GeometricDistance.new_by_arrays([1, 2], [3, 4]).midpoint).to eq([2, 3])
+    end
+  end
+
+  describe '#midpoint_distance' do
+    it 'to be half the distance between two points' do
+      expect(GeometricDistance.new_by_arrays([1, 1], [1, 2]).midpoint_distance).to eq(0.5)
+    end
+  end
+
+end

data/spec/lib/geometry/geometric_line_spec.rb

@@ -0,0 +1,287 @@
+require 'spec_helper'
+
+describe GeometricLine do
+  infinity = 1.0 / 0.0
+
+  describe '#initialize_by_numbers' do
+    line = GeometricLine.new(1, 2)
+
+    it 'to be equal' do
+      expect(line.point1).to eq(1)
+      expect(line.point2).to eq(2)
+    end
+
+    it 'to be not equal' do
+      expect(line.point1).not_to eq(3)
+      expect(line.point2).not_to eq(3)
+    end
+  end
+
+  describe '#initialize_by_array' do
+    point1 = GeometricPoint.new(1, 2)
+    point2 = GeometricPoint.new(1, 1)
+    line = GeometricLine.new_by_arrays([1, 2], [1, 1])
+
+    it 'to be equal' do
+      expect(line.point1).to eq(point1)
+      expect(line.point2).to eq(point2)
+    end
+
+    it 'to be not equal' do
+      expect(line.point1).not_to eq(point2)
+      expect(line.point2).not_to eq(point1)
+    end
+  end
+
+  describe '#angle_to' do
+    line = GeometricLine.new_by_arrays([0, 0], [1, 1])
+
+    it 'to be angle to self' do
+      expect(line.angle_to(line)).to eq(0)
+    end
+
+    it 'to be angle to perpendicular' do
+      perp = GeometricLine.new_by_arrays([0, 0], [1, -1])
+      expect(line.angle_to(perp)).to eq(Math::PI / 2)
+      expect(perp.angle_to(line)).to eq(Math::PI / 2)
+    end
+
+    it 'to be angle to acute' do
+      acute = GeometricLine.new_by_arrays([0, 0], [0, 1])
+      expect(line.angle_to(acute)).to eq(Math::PI / 4)
+      expect(acute.angle_to(line)).to eq(Math::PI / 4)
+    end
+  end
+
+  describe '#distance_to' do
+    it 'to be point on line' do
+      line = GeometricLine.new_by_arrays([0, 2], [2, 0])
+      point = GeometricPoint.new(1, 1)
+      expect(line.distance_to(point)).to eq(0)
+    end
+
+    it 'to be flat line' do
+      line = GeometricLine.new_by_arrays([0, 1], [2, 1])
+      point = GeometricPoint.new(1, 2)
+      expect(line.distance_to(point)).to eq(1)
+    end
+  end
+
+  describe '#horizontal?' do
+    it 'to be horizontal' do
+      line = GeometricLine.new_by_arrays([0, 0], [1, 0])
+      expect(line.horizontal?).to eq(true)
+    end
+
+    it 'to be not horizontal' do
+      line = GeometricLine.new_by_arrays([0, 0], [1, 1])
+      expect(line.horizontal?).to eq(false)
+    end
+  end
+
+  describe '#intersect_x' do
+    it 'to be vertical non overlapping' do
+      line1 = GeometricLine.new_by_arrays([0, 0], [0, 1])
+      line2 = GeometricLine.new_by_arrays([1, 0], [1, 1])
+      expect(line1.intersect_x(line2).nil?).to eq(true)
+    end
+
+    it 'to be vertical overlapping' do
+      line1 = GeometricLine.new_by_arrays([0, 0], [0, 1])
+      line2 = GeometricLine.new_by_arrays([0, 0], [0, 1])
+      expect(line1.intersect_x(line2)).to eq(0)
+      expect(line2.intersect_x(line1)).to eq(0)
+    end
+
+    it 'to be horizontal non overlapping' do
+      line1 = GeometricLine.new_by_arrays([0, 0], [1, 0])
+      line2 = GeometricLine.new_by_arrays([0, 1], [1, 1])
+      expect(line1.intersect_x(line2).nil?).to eq(true)
+    end
+
+    it 'to be horizontal overlapping' do
+      line1 = GeometricLine.new_by_arrays([0, 0], [1, 0])
+      line2 = GeometricLine.new_by_arrays([0, 0], [1, 0])
+      expect(line1.intersect_x(line2).nil?).to eq(true)
+    end
+
+    it 'to be perpendicular' do
+      [-1, 0, 1].each do |xo|
+        [-1, 0, 1].each do |yo|
+          line1 = GeometricLine.new_by_arrays([xo, yo], [xo + 0, yo + 1])
+          line2 = GeometricLine.new_by_arrays([xo, yo], [xo + 1, yo + 0])
+          expect(line1.intersect_x(line2)).to eq(xo)
+          expect(line2.intersect_x(line1)).to eq(xo)
+        end
+      end
+    end
+  end
+
+  describe '#parallel_to?' do
+    it 'to be identical' do
+      (1..100).each do
+        point1 = [rand-0.5, rand-0.5]
+        point2 = [rand-0.5, rand-0.5]
+        line = GeometricLine.new_by_arrays(point1, point2)
+        expect(line.parallel_to?(line)).to eq(true)
+      end
+    end
+
+    it 'to be vertical' do
+      line1 = GeometricLine.new_by_arrays([0, 0], [0, 1])
+      line2 = GeometricLine.new_by_arrays([0, 0], [0, -1])
+      expect(line1.parallel_to?(line2)).to eq(true)
+      expect(line2.parallel_to?(line1)).to eq(true)
+    end
+
+    it 'to be horizontal' do
+      line1 = GeometricLine.new_by_arrays([0, 0], [-1, 0])
+      line2 = GeometricLine.new_by_arrays([0, 0], [1, 0])
+      expect(line1.parallel_to?(line2)).to eq(true)
+      expect(line2.parallel_to?(line1)).to eq(true)
+    end
+
+    it 'to be shifted' do
+      line1 = GeometricLine.new_by_arrays([0, 0], [1, 1])
+      line2 = GeometricLine.new_by_arrays([1, 0], [2, 1])
+      expect(line1.parallel_to?(line2)).to eq(true)
+      expect(line2.parallel_to?(line1)).to eq(true)
+    end
+
+    it 'to be not parallel' do
+      line1 = GeometricLine.new_by_arrays([0, 0], [-1, 1])
+      line2 = GeometricLine.new_by_arrays([0, 0], [1, -2])
+      expect(line1.parallel_to?(line2)).to eq(false)
+      expect(line2.parallel_to?(line1)).to eq(false)
+    end
+  end
+
+  describe '#slope' do
+    it 'to be vertical' do
+      [-1, 0, 1].each do |x|
+        line = GeometricLine.new(GeometricPoint.new(x, 0), GeometricPoint.new(x, 1))
+        expect(line.slope).to eq(infinity)
+      end
+    end
+
+    it 'to be vertical negative' do
+      [-1, 0, 1].each do |x|
+        line = GeometricLine.new(GeometricPoint.new(x, 0), GeometricPoint.new(x, -1))
+        expect(line.slope).to eq(-infinity)
+      end
+    end
+
+    it 'to be horizontal' do
+      [-1, 0, 1].each do |y|
+        line = GeometricLine.new(GeometricPoint.new(0, y), GeometricPoint.new(1, y))
+        expect(line.slope).to eq(0)
+      end
+    end
+
+    it 'to be horizontal negative' do
+      [-1, 0, 1].each do |y|
+        line = GeometricLine.new(GeometricPoint.new(0, y), GeometricPoint.new(-1, y))
+        expect(line.slope).to eq(0)
+      end
+    end
+
+    it 'to be full circle' do
+      delta = 0.000001
+      increment = Math::PI / 10
+      divisions = 2 * Math::PI / increment
+      radius = 1
+      (0..divisions).each do |d|
+        angle = d * increment
+        y = radius * Math::sin(angle)
+        x = radius * Math::cos(angle)
+        line = GeometricLine.new(GeometricPoint.new(0, 0), GeometricPoint.new(x, y))
+        expect(line.slope).to be_within(delta).of(Math::tan(angle))
+      end
+    end
+  end
+
+  describe '#vertical?' do
+    it 'to be vertical' do
+      line = GeometricLine.new_by_arrays([0, 0], [0, 1])
+      expect(line.vertical?).to eq(true)
+    end
+
+    it 'to be not vertical' do
+      line = GeometricLine.new_by_arrays([0, 0], [1, 1])
+      expect(line.vertical?).to eq(false)
+    end
+  end
+
+  describe '#x_intercept' do
+    it 'to be anchored at x axis' do
+      [-1, 0, 1].each do |xi|
+        line = GeometricLine.new(GeometricPoint.new(xi, 0), GeometricPoint.new(1, 1))
+        expect(line.x_intercept).to eq(xi)
+      end
+    end
+
+    it 'to be not floating' do
+      [-1, 1].each do |slope|
+        [-2, 0, 2].each do |yo|
+          [-1, 0, 1].each do |xi|
+            point1 = GeometricPoint.new(xi + yo / slope, yo)
+            point2 = GeometricPoint.new(xi + (yo + 1) / slope, yo + 1)
+            line = GeometricLine.new(point1, point2)
+            expect(line.x_intercept).to eq(xi)
+          end
+        end
+      end
+    end
+
+    it 'to be vertical' do
+      [-1, 0, 1].each do |xi|
+        line = GeometricLine.new(GeometricPoint.new(xi, 1), GeometricPoint.new(xi, 2))
+        expect(line.x_intercept).to eq(xi)
+      end
+    end
+
+    it 'to be horizontal' do
+      [-1, 0, 1].each do |yo|
+        line = GeometricLine.new(GeometricPoint.new(0, yo), GeometricPoint.new(1, yo))
+        expect(line.x_intercept.nil?).to eq(true)
+      end
+    end
+  end
+
+  describe '#y_intercept' do
+    it 'to be anchored at y axis' do
+      [-1, 0, 1].each do |yi|
+        line = GeometricLine.new(GeometricPoint.new(0, yi), GeometricPoint.new(1, 1))
+        expect(line.y_intercept).to eq(yi)
+      end
+    end
+
+    it 'to be not floating' do
+      [-1, 1].each do |slope|
+        [-2, 0, 2].each do |xo|
+          [-1, 0, 1].each do |yi|
+            point1 = GeometricPoint.new(xo, yi + slope * xo)
+            point2 = GeometricPoint.new(xo + 1, yi + slope * (xo + 1))
+            line = GeometricLine.new(point1, point2)
+            expect(line.y_intercept).to eq(yi)
+          end
+        end
+      end
+    end
+
+    it 'to be horizontal' do
+      [-1, 0, 1].each do |yi|
+        line = GeometricLine.new(GeometricPoint.new(1, yi), GeometricPoint.new(2, yi))
+        expect(line.y_intercept).to eq(yi)
+      end
+    end
+
+    it 'to be vertical' do
+      [-1, 0, 1].each do |xo|
+        line = GeometricLine.new(GeometricPoint.new(xo, 0), GeometricPoint.new(xo, 1))
+        expect(line.y_intercept.nil?).to eq(true)
+      end
+    end
+  end
+
+end

data/spec/lib/geometry/geometric_point_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe GeometricPoint do
+  describe '#initialize_by_numbers' do
+    point = GeometricPoint.new(1, 2)
+
+    it 'to be equal' do
+      expect(point.x).to eq(1)
+      expect(point.y).to eq(2)
+    end
+
+    it 'to be not equal' do
+      expect(point.x).not_to eq(3)
+      expect(point.y).not_to eq(3)
+    end
+  end
+
+  describe '#initialize_by_array' do
+    point = GeometricPoint.new_by_array([1, 2])
+
+    it 'to be equal' do
+      expect(point.x).to eq(1)
+      expect(point.y).to eq(2)
+    end
+
+    it 'to be not equal' do
+      expect(point.x).not_to eq(3)
+      expect(point.y).not_to eq(3)
+    end
+  end
+
+  describe '#advance_by' do
+    it 'to be the addition of a point to a vector' do
+      point = GeometricPoint.new(1, 2)
+      vector = GeometricVector.new(2, -1)
+      expect(point.advance_by(vector)).to eq(GeometricPoint.new(3, 1))
+    end
+  end
+
+  describe '#to_vector' do
+    it 'to be converted to a vector' do
+      expect(GeometricPoint.new(1, 2).to_vector).to eq(GeometricVector.new(1, 2))
+    end
+  end
+
+  describe '#==' do
+    it 'to be converted to a vector' do
+      point = GeometricPoint.new(1, 2)
+      expect(point == point).to eq(true)
+      expect(point == GeometricPoint.new(1, 3)).to eq(false)
+    end
+  end
+end

data/spec/lib/geometry/geometric_polygon_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+describe GeometricPolygon do
+  describe '#area' do
+    it 'to be area of an empty polygon' do
+      expect(GeometricPolygon.new([]).area).to eq(0)
+    end
+
+    it 'to be area of a point' do
+      expect(GeometricPolygon.new([GeometricPoint.new(1,1)]).area).to eq(0)
+    end
+
+    it 'to be area of a line' do
+      expect(GeometricPolygon.new([GeometricPoint.new(0,0), GeometricPoint.new(1,1)]).area).to eq(0)
+    end
+
+    it 'to be area of a triangle' do
+      expect(GeometricPolygon.new([GeometricPoint.new(0,0), GeometricPoint.new(1,1), GeometricPoint.new(0,1)]).area).to eq(0.5)
+    end
+
+    it 'to be area of a square' do
+      expect(GeometricPolygon.new([GeometricPoint.new(0,0), GeometricPoint.new(0,2), GeometricPoint.new(2,2), GeometricPoint.new(2,0)]).area).to eq(4)
+    end
+
+    it 'to be area of a quadralateral' do
+      expect(GeometricPolygon.new([GeometricPoint.new(4,10), GeometricPoint.new(9,7), GeometricPoint.new(11,2), GeometricPoint.new(2,2)]).area).to eq(45.5)
+    end
+  end
+
+  describe '#bounding_box' do
+    it 'to be a rectangle' do
+      polygon = GeometricPolygon.new([
+                                      GeometricPoint.new(-1, -1),
+                                      GeometricPoint.new(1, -1),
+                                      GeometricPoint.new(1, 1),
+                                      GeometricPoint.new(-1, 1)
+                                    ])
+      expect(polygon.bounding_box.leftbottom).to eq(GeometricPoint.new(-1, -1))
+      expect(polygon.bounding_box.righttop).to eq(GeometricPoint.new(1, 1))
+    end
+
+    it 'to be a sloped rectangle' do
+      polygon = GeometricPolygon.new([
+                                      GeometricPoint.new(-1, 0),
+                                      GeometricPoint.new(0, -1),
+                                      GeometricPoint.new(1, 0),
+                                      GeometricPoint.new(0, 1)
+                                    ])
+      expect(polygon.bounding_box.leftbottom).to eq(GeometricPoint.new(-1, -1))
+      expect(polygon.bounding_box.righttop).to eq(GeometricPoint.new(1, 1))
+    end
+
+    it 'to be nonconvex' do
+      polygon = GeometricPolygon.new([
+                                      GeometricPoint.new(0, 2),
+                                      GeometricPoint.new(2, 0),
+                                      GeometricPoint.new(5, 1),
+                                      GeometricPoint.new(3, 8),
+                                      GeometricPoint.new(3, 1),
+                                      GeometricPoint.new(1, 4)
+                                    ])
+      expect(polygon.bounding_box.leftbottom).to eq(GeometricPoint.new(0, 0))
+      expect(polygon.bounding_box.righttop).to eq(GeometricPoint.new(5, 8))
+    end
+  end
+
+  describe '#contains?' do
+    it 'to be convex' do
+      polygon = GeometricPolygon.new([
+                                      GeometricPoint.new(0, 0),
+                                      GeometricPoint.new(1, 0),
+                                      GeometricPoint.new(1, 1),
+                                      GeometricPoint.new(0, 1)
+                                    ])
+      inner = GeometricPoint.new(0.5, 0.5)
+      outer = GeometricPoint.new(1.5, 1.5)
+      on_edge = GeometricPoint.new(0.5, 1)
+      at_vertex = GeometricPoint.new(1, 1)
+
+      expect(polygon.contains?(inner)).to eq(true)
+      expect(polygon.contains?(outer)).to eq(false)
+      expect(polygon.contains?(on_edge)).to eq(true)
+      expect(polygon.contains?(at_vertex)).to eq(true)
+    end
+
+    it 'to be nonconvex' do
+      polygon = GeometricPolygon.new([
+                                      GeometricPoint.new(0, 0),
+                                      GeometricPoint.new(0, 6),
+                                      GeometricPoint.new(4, 6),
+                                      GeometricPoint.new(4, 4),
+                                      GeometricPoint.new(2, 4),
+                                      GeometricPoint.new(2, 2),
+                                      GeometricPoint.new(4, 2),
+                                      GeometricPoint.new(4, 0)
+                                    ])
+
+      inner = GeometricPoint.new(1, 5)
+      outer = GeometricPoint.new(7, 5)
+
+      expect(polygon.contains?(inner)).to eq(true)
+      expect(polygon.contains?(outer)).to eq(false)
+    end
+  end
+
+  describe '#edges' do
+    it 'to be regular' do
+      vertices = [
+                  GeometricPoint.new(0, 0),
+                  GeometricPoint.new(1, 0),
+                  GeometricPoint.new(1, 1),
+                  GeometricPoint.new(0, 1)
+                 ]
+
+      polygon = GeometricPolygon.new(vertices)
+
+      expected_edges = [
+                        GeometricSegment.new_by_arrays(vertices[0], vertices[1]),
+                        GeometricSegment.new_by_arrays(vertices[1], vertices[2]),
+                        GeometricSegment.new_by_arrays(vertices[2], vertices[3]),
+                        GeometricSegment.new_by_arrays(vertices[3], vertices[0])
+                       ]
+
+      expect(polygon.edges).to eq(expected_edges)
+    end
+
+    it 'to be self intersecting' do
+      vertices = [
+                  GeometricPoint.new(0, 0),
+                  GeometricPoint.new(4, 0),
+                  GeometricPoint.new(3, 2),
+                  GeometricPoint.new(1, -2)
+                 ]
+
+      polygon = GeometricPolygon.new(vertices)
+
+      expected_edges = [
+                        GeometricSegment.new_by_arrays(vertices[0], vertices[1]),
+                        GeometricSegment.new_by_arrays(vertices[1], vertices[2]),
+                        GeometricSegment.new_by_arrays(vertices[2], vertices[3]),
+                        GeometricSegment.new_by_arrays(vertices[3], vertices[0])
+                       ]
+
+      expect(polygon.edges).to eq(expected_edges)
+    end
+  end
+
+end