easy_geometry 0.1.0

data/lib/easy_geometry/d2/vector.rb

@@ -0,0 +1,71 @@
+module EasyGeometry
+  module D2
+    # A vector in a 2-dimensional Euclidean space.
+    class Vector
+      attr_reader :x, :y
+
+      EQUITY_TOLERANCE = 0.0000000000001
+      
+      def initialize(x, y)
+        @x = x; @y = y
+
+        validate!
+        converting_to_rational!
+      end
+
+      # Compare self and other Vector.
+      def ==(other)
+        return false unless other.is_a?(Vector)
+        (x - other.x).abs < EQUITY_TOLERANCE && (y - other.y).abs < EQUITY_TOLERANCE
+      end
+
+      # Subtract two vectors.
+      def -(other)
+        raise TypeError, "Subtract between Vector and #{ other.class } is not defined" unless other.is_a?(Vector)
+        Vector.new(self.x - other.x, self.y - other.y)
+      end
+
+      # Returns a non-zero vector that is orthogonal to the
+      # line containing `self` and the origin.
+      def orthogonal_direction
+        # if a coordinate is zero, we can put a 1 there and zeros elsewhere
+        return Vector.new(1, 0) if x.zero?
+        return Vector.new(0, 1) if y.zero?
+
+        # if the first two coordinates aren't zero, we can create a non-zero
+        # orthogonal vector by swapping them, negating one, and padding with zeros
+        Vector.new(-y, x)
+      end
+
+      # It is positive if other vector should be turned counter-clockwise in order to superpose them.
+      # It is negetive if other vector should be turned clockwise in order to superpose them.
+      # It is zero when vectors are collinear.
+      def cross_product(other)
+        raise TypeError, "Cross product between Vector and #{ other.class } is not defined" unless other.is_a?(Vector)
+        x * other.y - y * other.x
+      end
+
+      # Dot product, also known as inner product or scalar product.
+      def dot(other)
+        raise TypeError, "Scalar (dot) product between Vector and #{ other.class } is not defined" unless other.is_a?(Vector)
+        x * other.x + y * other.y
+      end
+
+      # Converts the vector to a point
+      def to_point
+        Point.new(x, y)
+      end
+
+      private
+
+      def validate!
+        raise TypeError, 'Coords should be numbers' if !x.is_a?(Numeric) || !y.is_a?(Numeric)
+      end
+
+      def converting_to_rational!
+        @x = Rational(x.to_s) unless x.is_a?(Rational)
+        @y = Rational(y.to_s) unless y.is_a?(Rational)
+      end
+    end
+  end
+end

data/spec/d2/line_spec.rb

@@ -0,0 +1,339 @@
+require 'spec_helper'
+
+RSpec.describe EasyGeometry::D2::Line do
+  let(:p1) { EasyGeometry::D2::Point.new(0, 0) }
+  let(:p2) { EasyGeometry::D2::Point.new(1, 1) }
+  let(:l1) { described_class.new([0, 0], [1, 1]) }
+  let(:l2) { described_class.new([0, 0], [-1, 1]) }
+  let(:l3) { described_class.new([0, 0], [1, 0]) }
+  let(:s1) { EasyGeometry::D2::Segment.new([0, 0], [1, 1]) }
+  let(:s2) { EasyGeometry::D2::Segment.new([0, 0], [-1, 1]) }
+  let(:s3) { EasyGeometry::D2::Segment.new([0, 0], [1, 0]) }
+  let(:r1) { EasyGeometry::D2::Ray.new([0, 0], [1, 1]) }
+  let(:r2) { EasyGeometry::D2::Ray.new([0, 0], [-1, 1]) }
+  let(:r3) { EasyGeometry::D2::Ray.new([0, 0], [1, 0]) }
+
+  describe '.new' do
+    it 'should raise type error if incorrect parameters' do
+      expect { described_class.new("1", 0) }.to raise_error(TypeError)
+      expect { described_class.new(nil, 0) }.to raise_error(TypeError)
+      expect { described_class.new({}, 0) }.to raise_error(TypeError)
+    end
+
+    it 'should raise argument error if two points are equal' do
+      expect { described_class.new([0, 0], [0, 0]) }.to raise_error(ArgumentError)
+      expect { described_class.new([1, 1], [1, 1]) }.to raise_error(ArgumentError)
+      expect { described_class.new(EasyGeometry::D2::Point.new(2, 2), EasyGeometry::D2::Point.new(2, 2)) }.to raise_error(ArgumentError)
+    end
+
+    it 'should create line' do
+      expect(described_class.new(p1, [1, 1])).to eq(l1)
+      expect(described_class.new([0, 0], p2)).to eq(l1)
+      expect(described_class.new(p1, p2)).to eq(l1)
+      expect(described_class.new([0, 0], [1, 1])).to eq(l1)
+    end
+  end
+
+  describe '#direction' do
+    it 'should return a correct vector' do
+      expect(l1.direction).to eq(EasyGeometry::D2::Vector.new(1, 1))
+      expect(l2.direction).to eq(EasyGeometry::D2::Vector.new(-1, 1))
+    end
+  end
+
+  describe '#angle_between' do
+    it 'should raise error if incorrect parameters' do
+      expect { l1.angle_between(1) }.to raise_error(TypeError)
+      expect { l1.angle_between("") }.to raise_error(TypeError)
+      expect { l1.angle_between({}) }.to raise_error(TypeError)
+    end
+
+    it 'should return a correct angle' do
+      expect(l1.angle_between(l2)).to eq(90 * Math::PI / 180)
+      expect(l1.angle_between(s2)).to eq(90 * Math::PI / 180)
+      expect(l1.angle_between(r2)).to eq(90 * Math::PI / 180)
+ 
+      expect(l1.angle_between(l1)).to eq(0)
+      expect(l1.angle_between(s1)).to eq(0)
+      expect(l1.angle_between(r1)).to eq(0)
+
+      expect(l1.angle_between(l3)).to eq((45 * Math::PI / 180))
+      expect(l1.angle_between(s3)).to eq((45 * Math::PI / 180))
+      expect(l1.angle_between(r3)).to eq((45 * Math::PI / 180))
+    end
+  end
+
+  describe '#parallel_to?' do
+    it 'should raise error if incorrect parameters' do
+      expect { l1.parallel_to?(1) }.to raise_error(TypeError)
+      expect { l1.parallel_to?("") }.to raise_error(TypeError)
+      expect { l1.parallel_to?({}) }.to raise_error(TypeError)
+    end
+
+    it 'should return true' do
+      expect(l1.parallel_to?(l1)).to be true
+      expect(l1.parallel_to?(s1)).to be true
+      expect(l1.parallel_to?(r1)).to be true
+      expect(l3.parallel_to?(described_class.new([6, 6], [12, 6]))).to be true
+    end
+
+    it 'should return false' do
+      expect(l1.parallel_to?(l2)).to be false
+      expect(l1.parallel_to?(s2)).to be false
+      expect(l1.parallel_to?(r2)).to be false
+      expect(l2.parallel_to?(l3)).to be false
+      expect(l3.parallel_to?(described_class.new([6, 6], [12, 6.00001]))).to be false
+    end
+  end
+
+  describe '#perpendicular_to?' do
+    it 'should raise error if incorrect parameters' do
+      expect { l1.perpendicular_to?(1) }.to raise_error(TypeError)
+      expect { l1.perpendicular_to?("") }.to raise_error(TypeError)
+      expect { l1.perpendicular_to?({}) }.to raise_error(TypeError)
+    end
+
+    it 'should return true' do
+      expect(l1.perpendicular_to?(l2)).to be true
+      expect(l1.perpendicular_to?(s2)).to be true
+      expect(l1.perpendicular_to?(r2)).to be true
+      expect(l3.perpendicular_to?(described_class.new(p1, [0, 1]))).to be true
+    end
+
+    it 'should return false' do
+      expect(l1.perpendicular_to?(l1)).to be false  
+      expect(l1.perpendicular_to?(s1)).to be false  
+      expect(l1.perpendicular_to?(r1)).to be false  
+      expect(l1.perpendicular_to?(l3)).to be false   
+      expect(l2.perpendicular_to?(l3)).to be false   
+    end
+  end
+
+  describe '#similar_to?' do
+    it 'should raise error if incorrect parameters' do
+      expect { l1.similar_to?(1) }.to raise_error(TypeError)
+      expect { l1.similar_to?("") }.to raise_error(TypeError)
+      expect { l1.similar_to?({}) }.to raise_error(TypeError)
+    end
+
+    it 'should return true' do
+      expect(l1.similar_to?(described_class.new([2, 2], [4, 4]))).to be true
+      expect(l1.similar_to?(EasyGeometry::D2::Segment.new([2, 2], [4, 4]))).to be true
+      expect(l1.similar_to?(EasyGeometry::D2::Ray.new([2, 2], [4, 4]))).to be true
+      expect(l3.similar_to?(described_class.new([10, 0], [40, 0]))).to be true
+    end
+
+    it 'should return false' do
+      expect(l1.similar_to?(l2)).to be false   
+      expect(l1.similar_to?(s2)).to be false   
+      expect(l1.similar_to?(r2)).to be false   
+      expect(l1.similar_to?(l3)).to be false   
+      expect(l2.similar_to?(l3)).to be false   
+    end
+  end
+
+  describe '#intersection' do
+    it 'should raise error if incorrect parameters' do
+      expect { l1.intersection(1) }.to raise_error(TypeError)
+      expect { l1.intersection("") }.to raise_error(TypeError)
+      expect { l1.intersection({}) }.to raise_error(TypeError)
+    end
+
+    context 'intersection with a point' do
+      it 'should return array with our point' do
+        expect(l1.intersection(p1)).to eq([p1])
+        expect(l1.intersection(p2)).to eq([p2])
+        expect(l1.intersection(EasyGeometry::D2::Point.new(2, 2))).to eq([EasyGeometry::D2::Point.new(2, 2)])
+      end
+
+      it 'should return empty array' do
+        expect(l2.intersection(p2)).to eq([])
+        expect(l3.intersection(p2)).to eq([])
+      end
+    end
+
+    context 'intersection with a linear entity which lies on our line' do
+      let(:s1) { EasyGeometry::D2::Segment.new([10, 10], [20, 20]) }
+      let(:r1) { EasyGeometry::D2::Ray.new([10, 10], [20, 20]) }
+
+      it 'should return array with self when intersection with line' do
+        expect(l1.intersection(l1)).to eq([l1])
+        expect(l2.intersection(l2)).to eq([l2])
+        expect(l3.intersection(l3)).to eq([l3])
+        expect(l1.intersection(described_class.new([10, 10], [20, 20]))).to eq([l1])
+      end
+
+
+      it 'should return array with linear entity when intersection with no line' do
+        expect(l1.intersection(s1)).to eq([s1])
+        expect(l1.intersection(r1)).to eq([r1])
+      end
+    end
+
+    context 'intersection with a linear entity which does not lie on our line' do
+      context 'intersection with parallel linear entity' do
+        it 'should return empty array' do
+          expect(l1.intersection(described_class.new([1, 0], [2, 1]))).to eq([])
+          expect(l1.intersection(EasyGeometry::D2::Segment.new([1, 0], [2, 1]))).to eq([])
+          expect(l3.intersection(described_class.new([0, 1], [1, 1]))).to eq([])
+          expect(l3.intersection(EasyGeometry::D2::Ray.new([0, 1], [1, 1]))).to eq([])
+        end
+      end
+
+      context 'intersection with not parallel linear entity' do
+        it 'should return array with point' do
+          expect(l1.intersection(l2)).to eq([p1])
+          expect(l1.intersection(l3)).to eq([p1])
+          expect(l3.intersection(described_class.new([7, 1], [9, 2]))).to eq([
+            EasyGeometry::D2::Point.new(5, 0)
+          ])
+          expect(l3.intersection(described_class.new([1, 7], [2, 9]))).to eq([
+            EasyGeometry::D2::Point.new(-2.5, 0)
+          ])
+          expect(l3.intersection(EasyGeometry::D2::Segment.new([0, 0], [1, 1]))).to eq([p1])
+          expect(l3.intersection(EasyGeometry::D2::Segment.new([-1, -1], [1, 1]))).to eq([p1])
+          expect(l3.intersection(EasyGeometry::D2::Ray.new([0, 0], [1, 1]))).to eq([p1])
+          expect(l3.intersection(EasyGeometry::D2::Ray.new([-1, -1], [1, 1]))).to eq([p1])
+        end
+
+        it 'should return empty array' do
+          expect(l3.intersection(EasyGeometry::D2::Segment.new([2, 2], [1, 1]))).to eq([])
+          expect(l3.intersection(EasyGeometry::D2::Segment.new([-2, -2], [-1, -1]))).to eq([])
+
+          expect(l3.intersection(EasyGeometry::D2::Ray.new([0, 0.001], [1, 1]))).to eq([])
+        end
+      end
+    end
+  end
+
+  describe '#parallel_line' do
+    it 'should raise error if incorrect parameters' do
+      expect { l1.parallel_line(1) }.to raise_error(TypeError)
+      expect { l1.parallel_line("") }.to raise_error(TypeError)
+      expect { l1.parallel_line({}) }.to raise_error(TypeError)
+    end
+
+    it 'should return a parallel line' do
+      expect(l3.parallel_line(p2).parallel_to?(l3)).to be true
+    end
+  end
+
+  describe '#perpendicular_line' do
+    it 'should raise error if incorrect parameters' do
+      expect { l1.perpendicular_line(1) }.to raise_error(TypeError)
+      expect { l1.perpendicular_line("") }.to raise_error(TypeError)
+      expect { l1.perpendicular_line({}) }.to raise_error(TypeError)
+    end
+
+    it 'should return a perpendicular line' do
+      expect(l3.perpendicular_line(p2).perpendicular_to?(l3)).to be true
+    end
+  end
+
+  describe '#perpendicular_segment' do
+    it 'should raise error if incorrect parameters' do
+      expect { l1.perpendicular_segment(1) }.to raise_error(TypeError)
+      expect { l1.perpendicular_segment("") }.to raise_error(TypeError)
+      expect { l1.perpendicular_segment({}) }.to raise_error(TypeError)
+    end
+
+    it 'should return the point if line contains this point' do
+      expect(l1.perpendicular_segment(p1)).to eq(p1) 
+      expect(l2.perpendicular_segment(p1)).to eq(p1) 
+      expect(l3.perpendicular_segment(p1)).to eq(p1) 
+    end
+
+    it 'should return a perpendicular segment' do
+      expect(l2.perpendicular_segment(p2)).to eq(EasyGeometry::D2::Segment.new(p2, p1)) 
+    end
+  end
+
+  describe '#slope' do
+    it 'should return a number' do
+      expect(l1.slope).to eq(1)
+      expect(l3.slope).to eq(0)
+      expect(described_class.new(p1, [0, 2]).slope).to eq(BigDecimal('Infinity'))
+    end
+  end
+
+  describe '#span_test' do
+    it 'should raise error if incorrect parameters' do
+      expect { l1.span_test(1) }.to raise_error(TypeError)
+      expect { l1.span_test("") }.to raise_error(TypeError)
+      expect { l1.span_test({}) }.to raise_error(TypeError)
+    end
+
+    it 'should return correct number' do
+      expect(l1.span_test(p1)).to eq(0)
+      expect(l1.span_test(p2)).to eq(1)
+      expect(l1.span_test(EasyGeometry::D2::Point.new(-1, -1))).to eq(-1)
+    end
+  end
+
+  describe '#contains?' do
+    it 'should return true' do
+      expect(l1.contains?(p1)).to be true
+      expect(l1.contains?(p2)).to be true
+      expect(l1.contains?(EasyGeometry::D2::Point.new(100, 100))).to be true
+      expect(l1.contains?(EasyGeometry::D2::Segment.new(
+        [1000, 1000], [2000, 2000]
+      ))).to be true
+      expect(l1.contains?(EasyGeometry::D2::Ray.new(
+        [-1000, -1000], [2000, 2000]
+      ))).to be true
+    end
+
+    it 'should return false' do
+      expect(l1.contains?(EasyGeometry::D2::Point.new(2, 3))).to be false
+      expect(l1.contains?(EasyGeometry::D2::Point.new(0, 0.1))).to be false
+      expect(l1.contains?(EasyGeometry::D2::Segment.new(
+        [1000.1, 1000], [2000, 2000]
+      ))).to be false
+      expect(l1.contains?(EasyGeometry::D2::Ray.new(
+        [-1000, -1001], [2000, 2000]
+      ))).to be false
+      expect(l1.contains?(2)).to be false
+      expect(l1.contains?("")).to be false
+    end
+  end
+
+  describe '#distance' do
+    it 'should raise error if incorrect parameters' do
+      expect { l1.distance(1) }.to raise_error(TypeError)
+      expect { l1.distance("") }.to raise_error(TypeError)
+      expect { l1.distance({}) }.to raise_error(TypeError)
+    end
+
+    it 'should return zero if line contains point' do
+      expect(l1.distance(p1)).to eq(0) 
+      expect(l1.distance(p2)).to eq(0) 
+      expect(l2.distance(p1)).to eq(0) 
+      expect(l3.distance(p1)).to eq(0) 
+    end
+
+    it 'should return correct number' do
+      expect(l1.distance([-1, 1])).to eq(Math.sqrt(2))
+      expect(l1.distance([1, -1])).to eq(Math.sqrt(2))
+      expect(l3.distance([10, 10])).to eq(10)
+    end
+  end
+
+  describe '#==' do
+    it 'should return false if argument is not line' do
+      expect(l1 == p1).to be false
+      expect(l1 == '').to be false
+      expect(l1 == 2).to be false
+      expect(l1 == EasyGeometry::D2::Segment.new([0, 0], [1, 1])).to be false
+    end
+
+    it 'should return false if not equal' do
+      expect(l1 == l2).to be false
+      expect(l1 == l3).to be false
+    end
+
+    it 'should return false if equal' do
+      expect(l1 == l1).to be true
+      expect(l1 == EasyGeometry::D2::Line.new([-1, -1], [100, 100])).to be true
+    end
+  end
+end

data/spec/d2/point_spec.rb

@@ -0,0 +1,211 @@
+require 'spec_helper'
+
+RSpec.describe EasyGeometry::D2::Point do
+  let(:p1) { described_class.new(0, 0) }
+  let(:p2) { described_class.new(1, 1) }
+  let(:p3) { described_class.new(3, 0) }
+  let(:p4) { described_class.new(2, 2) }
+  let(:p5) { described_class.new(-2, 2) }
+  let(:l1) { EasyGeometry::D2::Line.new(p1, p2) }
+
+  describe '.new' do
+    it 'should raise error if incorrect parameters' do
+      expect { described_class.new("1", 0) }.to raise_error(TypeError)
+      expect { described_class.new(nil, 0) }.to raise_error(TypeError)
+      expect { described_class.new({}, 0) }.to raise_error(TypeError)
+    end
+
+    it 'should convert coords to big decimal' do
+      expect(p2.x).to be_kind_of(Rational)
+      expect(p2.y).to be_kind_of(Rational)
+    end
+  end
+
+  describe '.project' do
+    it 'should raise error if incorrect parameters' do
+      expect { described_class.project(1, 0) }.to raise_error(TypeError)
+      expect { described_class.project(nil, "qwe") }.to raise_error(TypeError)
+      expect { described_class.project(p2, p1) }.to raise_error(ArgumentError)
+    end
+
+    it 'should be equal' do
+      expect(described_class.project(p2, p2)).to eq(p2)
+      expect(described_class.project(p2, p3)).to eq(described_class.new(1, 0))
+      expect(described_class.project(p3, p2)).to eq(described_class.new(1.5, 1.5))
+    end
+  end
+
+  describe '.is_collinear?' do
+    it 'should raise error if incorrect parameters' do
+      expect { described_class.is_collinear?(1, 2) }.to raise_error(TypeError)
+    end
+
+    it 'should return true' do
+      expect(described_class.is_collinear?()).to be true
+      expect(described_class.is_collinear?(p1)).to be true
+      expect(described_class.is_collinear?(p1, p2)).to be true
+      expect(described_class.is_collinear?(p1, p2, p2, p2)).to be true
+      expect(described_class.is_collinear?(p1, p2, p4)).to be true
+    end
+
+    it 'should return false' do
+      expect(described_class.is_collinear?(p1, p2, p3, p4)).to be false
+      expect(described_class.is_collinear?(p1, p2, p3)).to be false
+    end
+  end
+
+  describe '.affine_rank' do
+    it 'should raise error if incorrect parameters' do
+      expect { described_class.affine_rank(1, 2) }.to raise_error(TypeError)
+    end
+
+    it 'should return -1' do
+      expect(described_class.affine_rank()).to eq(-1)
+    end
+    # Other tests are meaningless because they test the Matrix class
+  end
+
+  describe '#dot' do
+    it 'should raise error if incorrect parameters' do
+      expect { p1.dot(1) }.to raise_error(TypeError)
+      expect { p1.dot("sd") }.to raise_error(TypeError)
+      expect { p1.dot(l1) }.to raise_error(TypeError)
+    end
+
+    it 'should be equal' do
+      expect(p1.dot(p2)).to eq(0)
+      expect(p2.dot(p4)).to eq(4)
+      expect(p2.dot(p5)).to eq(0)
+    end
+  end
+
+  describe '#zero?' do
+    it 'should return true' do
+      expect(p1.zero?).to be true      
+    end
+
+    it 'should return false' do
+      expect(p2.zero?).to be false
+      expect(p3.zero?).to be false
+      expect(p5.zero?).to be false
+    end
+  end
+
+  describe '#==' do
+    it 'should return true' do
+      expect(p1 == p1).to be true
+      expect(p2 == p2).to be true
+      expect(p3 == p3).to be true
+      expect(p4 == p4).to be true
+      expect(p5 == p5).to be true
+    end
+
+    it 'should return false' do
+      expect(p1 == p2).to be false
+      expect(p3 == p2).to be false
+      expect(p4 == p1).to be false
+      expect(p1 == 2).to be false
+      expect(p1 == '').to be false
+      expect(p1 == {}).to be false
+    end
+  end
+
+  describe '#-' do
+    it 'should raise error if incorrect parameters' do
+      expect { p1 - 1 }.to raise_error(TypeError)
+      expect { p2 - '' }.to raise_error(TypeError)
+      expect { p2 - l1 }.to raise_error(TypeError)
+    end
+
+    it 'should be equal' do
+      expect(p1 - p2).to eq(described_class.new(-1, -1))
+      expect(p5 - p3).to eq(described_class.new(-5, 2))
+      expect(p5 - p5).to eq(described_class.new(0, 0))
+    end
+  end
+
+  describe '#+' do
+    it 'should raise error if incorrect parameters' do
+      expect { p1 + 1 }.to raise_error(TypeError)
+      expect { p2 + '' }.to raise_error(TypeError)
+      expect { p2 + l1 }.to raise_error(TypeError)
+    end
+
+    it 'should be equal' do
+      expect(p1 + p2).to eq(described_class.new(1, 1))
+      expect(p5 + p3).to eq(described_class.new(1, 2))
+      expect(p5 + p5).to eq(described_class.new(-4, 4))
+    end
+  end
+
+  describe '#*' do
+    it 'should raise error if incorrect parameters' do
+      expect { p1 * p1 }.to raise_error(TypeError)
+      expect { p2 * '' }.to raise_error(TypeError)
+      expect { p1 * l1 }.to raise_error(TypeError)
+    end
+
+    it 'should be equal' do
+      expect(p1 * 10).to eq(described_class.new(0, 0))
+      expect(p2 * 10).to eq(described_class.new(10, 10))
+      expect(p5 * -2).to eq(described_class.new(4, -4))
+    end
+  end
+
+  describe '#/' do
+    it 'should raise error if incorrect parameters' do
+      expect { p1 / p1 }.to raise_error(TypeError)
+      expect { p2 / '' }.to raise_error(TypeError)
+      expect { p1 / l1 }.to raise_error(TypeError)
+    end
+
+    it 'should be equal' do
+      expect(p1 / 10).to eq(described_class.new(0, 0))
+      expect(p2 / 10).to eq(described_class.new(0.1, 0.1))
+      expect(p5 / -2).to eq(described_class.new(1, -1))
+    end
+  end
+
+  describe '#distance' do
+    it 'should raise error if incorrect parameters' do
+      expect { p1.distance(1) }.to raise_error(TypeError)
+      expect { p1.distance('') }.to raise_error(TypeError)
+      expect { p1.distance(nil) }.to raise_error(TypeError)
+    end
+
+    it 'should be equal' do
+      expect(p1.distance(p2)).to eq(Math.sqrt(2))
+      expect(p1.distance(p4)).to eq(Math.sqrt(8))
+      expect(p3.distance(p5)).to eq(Math.sqrt(29))
+    end
+  end
+
+  describe '#intersection' do
+    it 'should raise error if incorrect parameters' do
+      expect { p1.intersection(1) }.to raise_error(TypeError)
+      expect { p1.intersection('') }.to raise_error(TypeError)
+      expect { p1.intersection(nil) }.to raise_error(TypeError)
+    end
+
+    it 'should be equal' do
+      expect(p1.intersection(described_class.new(0, 0))).to eq([p1])
+      expect(p1.intersection(p2)).to eq([])
+    end
+  end
+
+  describe '#midpoint' do
+    it 'should raise error if incorrect parameters' do
+      expect { p1.midpoint(1) }.to raise_error(TypeError)
+      expect { p1.midpoint('') }.to raise_error(TypeError)
+      expect { p1.midpoint(nil) }.to raise_error(TypeError)
+      expect { p1.midpoint(l1) }.to raise_error(TypeError)
+    end
+
+    it 'should be equal' do
+      expect(p1.midpoint(p1)).to eq(p1)
+      expect(p1.midpoint(p2)).to eq(described_class.new(0.5, 0.5))
+      expect(p1.midpoint(p3)).to eq(described_class.new(1.5, 0))
+      expect(p2.midpoint(p5)).to eq(described_class.new(-0.5, 1.5))
+    end
+  end
+end