cartesius 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 95fd724a37b3fd9e2e072f649cd34ffcd6ade1bd
+  data.tar.gz: 304ab894b81c52b1d02c63076be66879a20319f7
+SHA512:
+  metadata.gz: 5f3b5b319332a590bcd796952e58328cbafa0b6857fea724bc796cbdc72520c715a167d063bf3510a5db5617cb52c49e55b75938c42c69c484a47a82a817471e
+  data.tar.gz: 3abcc3dc0cdc72e7878dbb1c55cf7c4d887f1fe464e228083e993e0d11f4952ee9769c9afaf34cfc69212e51f848f56c32bc08b808cf1f2c259b941006bdc50d

data/lib/cartesius/circumference.rb

@@ -0,0 +1,95 @@
+require('cartesius/line')
+require('cartesius/determinator')
+require('cartesius/numerificator')
+require('cartesius/cramer')
+
+module Cartesius
+
+  class Circumference
+    include Determinator, Numerificator
+
+    # Conic
+    # Conic equation type: x^2 + y^2 + dx + ey + f = 0
+    def initialize(x:, y:, k:)
+      @x2_coeff, @y2_coeff, @x_coeff, @y_coeff, @k_coeff = 1, 1, x.to_r, y.to_r, k.to_r
+      validation
+    end
+
+    def self.by_definition(focus:, radius:)
+      alfa = -2 * focus.x
+      beta = -2 * focus.y
+      gamma = focus.x ** 2 + focus.y ** 2 - radius.to_r ** 2
+
+      self.new(x: alfa, y: beta, k: gamma)
+    end
+
+    def self.by_canonical(focus:, radius:)
+      by_definition(focus: focus, radius: radius)
+    end
+
+    def self.by_points(point1:, point2:, point3:)
+      if point1 == point2 or point1 == point3 or point2 == point3
+        raise ArgumentError.new('Points must be distinct!')
+      end
+
+      line = Line.by_points(point1: point1, point2: point2)
+      if line.include?(point3)
+        raise ArgumentError.new('Points must not be aligned!')
+      end
+
+      alfa, beta, gamma = Cramer.solution3(
+          [point1.x, point1.y, 1],
+          [point2.x, point2.y, 1],
+          [point3.x, point3.y, 1],
+          [-(point1.x ** 2 + point1.y ** 2), -(point2.x ** 2 + point2.y ** 2), -(point3.x ** 2 + point3.y ** 2)]
+      )
+
+      self.new(x: alfa, y: beta, k: gamma)
+    end
+
+
+    def self.unitary
+      new(x: 0, y: 0, k: -1)
+    end
+
+    def center
+      Point.new(x: centrum[:xc], y: centrum[:yc])
+    end
+
+    def radius
+      Math.sqrt(a2)
+    end
+
+    def unitary?
+      self == Circumference.unitary
+    end
+
+    def == (circumference)
+      circumference.instance_of?(Circumference) and
+          circumference.center == self.center and circumference.radius == self.radius
+    end
+
+    def congruent?(circumference)
+      unless circumference.instance_of?(self.class)
+        return false
+      end
+
+      circumference.radius == self.radius
+    end
+
+    def to_equation
+      equationfy(
+          'x^2' => @x2_coeff, 'y^2' => @y2_coeff, 'x' => @x_coeff, 'y' => @y_coeff, '1' => @k_coeff
+      )
+    end
+
+    private
+
+    def validation
+      if determinator <= @k_coeff
+        raise ArgumentError.new('Invalid coefficients!')
+      end
+    end
+
+  end
+end

data/lib/cartesius/ellipse.rb

@@ -0,0 +1,173 @@
+require('cartesius/segment')
+require('cartesius/determinator')
+require('cartesius/numerificator')
+require('cartesius/cramer')
+
+module Cartesius
+
+  class Ellipse
+    include Determinator, Numerificator
+
+    # Conic
+    # Conic equation type: ax^2 + by^2 + dx + ey + f = 0
+    def initialize(x2:, y2:, x:, y:, k:)
+      x2, y2, x, y, k = normalize(x2, y2, x, y, k)
+      @x2_coeff, @y2_coeff, @x_coeff, @y_coeff, @k_coeff = x2.to_r, y2.to_r, x.to_r, y.to_r, k.to_r
+      validation
+    end
+
+    def self.by_definition(focus1:, focus2:, distance:)
+      if focus1 == focus2
+        raise ArgumentError.new('Focus points must be different!')
+      end
+
+      unless focus1.aligned_horizontally_with?(focus2) or focus1.aligned_vertically_with?(focus2)
+        raise ArgumentError.new('Focus must be aligned to axis!')
+      end
+
+      focal_distance = Point.distance(focus1, focus2)
+      if distance <= focal_distance
+        raise ArgumentError.new('Sum of distances must be greater than focal distance!')
+      end
+
+      center = Segment.new(extreme1: focus1, extreme2: focus2).mid
+      c2 = Rational(focal_distance, 2) ** 2
+      if focus1.aligned_horizontally_with?(focus2)
+        a2 = Rational(distance, 2) ** 2
+        b2 = a2 - c2
+      end
+      if focus1.aligned_vertically_with?(focus2)
+        b2 = Rational(distance, 2) ** 2
+        a2 = b2 - c2
+      end
+
+      self.new(x2: b2, y2: a2, x: -2 * b2 * center.x, y: -2 * a2 * center.y, k: b2 * center.x ** 2 + a2 * center.y ** 2 - a2 * b2)
+    end
+
+    def self.by_canonical(center:, x_semi_axis:, y_semi_axis:)
+      if x_semi_axis <= 0 or y_semi_axis <= 0
+        raise ArgumentError.new('Semi axis length must be positive!')
+      end
+
+      if x_semi_axis == y_semi_axis
+        raise ArgumentError.new('Semi axis length must be different!')
+      end
+
+      b2 = y_semi_axis ** 2
+      a2 = x_semi_axis ** 2
+
+      self.new(x2: b2, y2: a2, x: -2 * b2 * center.x, y: -2 * a2 * center.y, k: b2 * center.x ** 2 + a2 * center.y ** 2 - a2 * b2)
+    end
+
+    def self.by_points(center:, point1:, point2:)
+      if center == point1 or center == point2 or point1 == point2
+        raise ArgumentError.new('Points must be different!')
+      end
+
+      shifted1 = Point.new(x: point1.x - center.x, y: point1.y - center.y)
+      shifted2 = Point.new(x: point2.x - center.x, y: point2.y - center.y)
+
+      begin
+        alfa, beta = Cramer.solution2(
+            [shifted1.x ** 2, shifted1.y ** 2],
+            [shifted2.x ** 2, shifted2.y ** 2],
+            [1, 1]
+        )
+      rescue
+        raise ArgumentError.new('No Ellipse for these points!')
+      end
+
+      a2 = Rational(1, alfa)
+      b2 = Rational(1, beta)
+
+      self.new(x2: b2, y2: a2, x: -2 * b2 * center.x, y: -2 * a2 * center.y, k: b2 * center.x ** 2 + a2 * center.y ** 2 - a2 * b2)
+    end
+
+    def focus1
+      if a2 > b2
+        Point.new(x: center.x + Math.sqrt(a2 - b2), y: center.y)
+      else
+        Point.new(x: center.x, y: center.y + Math.sqrt(b2 - a2))
+      end
+    end
+
+    def focus2
+      if a2 > b2
+        Point.new(x: center.x - Math.sqrt(a2 - b2), y: center.y)
+      else
+        Point.new(x: center.x, y: center.y - Math.sqrt(b2 - a2))
+      end
+    end
+
+    def focal_distance
+      Point.distance(focus1, focus2)
+    end
+
+    def center
+      Point.new(x: centrum[:xc], y: centrum[:yc])
+    end
+
+    def sum_of_distances
+      if a2 > b2
+        2 * Math.sqrt(a2)
+      else
+        2 * Math.sqrt(b2)
+      end
+    end
+
+    def x_semi_axis_length
+      Math.sqrt(a2)
+    end
+
+    def y_semi_axis_length
+      Math.sqrt(b2)
+    end
+
+    def major_semi_axis
+      [x_semi_axis_length, y_semi_axis_length].max
+    end
+
+    def minor_semi_axis
+      [x_semi_axis_length, y_semi_axis_length].min
+    end
+
+    def vertices
+      [
+          Point.new(x: center.x + x_semi_axis_length, y: center.y),
+          Point.new(x: center.x, y: center.y - y_semi_axis_length),
+          Point.new(x: center.x - x_semi_axis_length, y: center.y),
+          Point.new(x: center.x, y: center.y + y_semi_axis_length)
+      ]
+    end
+
+    def eccentricity
+      Rational(focal_distance, 2 * major_semi_axis)
+    end
+
+    def congruent?(ellipse)
+      ellipse.instance_of?(Ellipse) and
+          ellipse.eccentricity == self.eccentricity
+    end
+
+    def == (ellipse)
+      ellipse.instance_of?(Ellipse) and
+          ellipse.focus1 == self.focus1 and ellipse.focus2 == self.focus2 and ellipse.sum_of_distances == self.sum_of_distances
+    end
+
+    def to_equation
+      equationfy(
+          'x^2' => @x2_coeff, 'y^2' => @y2_coeff, 'x' => @x_coeff, 'y' => @y_coeff, '1' => @k_coeff
+      )
+    end
+
+    private
+
+    def validation
+      if @x2_coeff <= 0 or @y2_coeff <= 0 or @x2_coeff == @y2_coeff or determinator <= @k_coeff
+        raise ArgumentError.new('Invalid coefficients!')
+      end
+    end
+
+  end
+
+end

data/lib/cartesius/hyperbola.rb

@@ -0,0 +1,168 @@
+require('cartesius/segment')
+require('cartesius/determinator')
+require('cartesius/numerificator')
+require('cartesius/cramer')
+
+module Cartesius
+
+  class Hyperbola
+    include Determinator, Numerificator
+
+    # Conic
+    # Conic equation type: ax^2 + by^2 + dx + ey + f = 0
+    def initialize(x2:, y2:, x:, y:, k:)
+      x2, y2, x, y, k = normalize(x2, y2, x, y, k)
+      @x2_coeff, @y2_coeff, @x_coeff, @y_coeff, @k_coeff = x2.to_r, y2.to_r, x.to_r, y.to_r, k.to_r
+      validation
+    end
+
+    def self.by_definition(focus1:, focus2:, distance:)
+      if focus1 == focus2
+        raise ArgumentError.new('Focus points must be different!')
+      end
+
+      unless focus1.aligned_horizontally_with?(focus2) or focus1.aligned_vertically_with?(focus2)
+        raise ArgumentError.new('Focus must be aligned to axis!')
+      end
+
+      focal_distance = Point.distance(focus1, focus2)
+      if distance >= focal_distance
+        raise ArgumentError.new('Difference of distances must be less than focal distance!')
+      end
+
+      center = Segment.new(extreme1: focus1, extreme2: focus2).mid
+      c2 = Rational(focal_distance, 2) ** 2
+      if focus1.aligned_horizontally_with?(focus2)
+        a2 = Rational(distance, 2) ** 2
+        b2 = c2 - a2
+        position = 1
+      end
+      if focus1.aligned_vertically_with?(focus2)
+        b2 = Rational(distance, 2) ** 2
+        a2 = c2 - b2
+        position = -1
+      end
+
+      self.new(x2: b2, y2: -a2, x: -2 * b2 * center.x, y: 2 * a2 * center.y, k: b2 * center.x ** 2 - a2 * center.y ** 2 + -position * a2 * b2)
+    end
+
+    def self.by_canonical(center:, transverse_axis:, not_transverse_axis:, position:)
+      if transverse_axis <= 0 or not_transverse_axis <= 0
+        raise ArgumentError.new('Axis length must be positive!')
+      end
+
+      unless [-1, 1].include?(position)
+        raise ArgumentError.new('Position must be up or right!')
+      end
+
+      if position == -1
+        a2 = not_transverse_axis ** 2
+        b2 = transverse_axis ** 2
+      end
+
+      if position == 1
+        a2 = transverse_axis ** 2
+        b2 = not_transverse_axis ** 2
+      end
+
+      self.new(x2: b2, y2: -a2, x: -2 * b2 * center.x, y: 2 * a2 * center.y, k: b2 * center.x ** 2 - a2 * center.y ** 2 + -position * a2 * b2)
+    end
+
+    def self.by_points(center:, vertex:, point:)
+      if center == vertex or center == point or vertex == point
+        raise ArgumentError.new('Points must be different!')
+      end
+
+      unless vertex.aligned_horizontally_with?(center) or vertex.aligned_vertically_with?(center)
+        raise ArgumentError.new('Vertex must be aligned with center!')
+      end
+
+      if vertex.aligned_horizontally_with?(center)
+        position = 1
+      end
+
+      if vertex.aligned_vertically_with?(center)
+        position = -1
+      end
+
+      shifted1 = Point.new(x: vertex.x - center.x, y: vertex.y - center.y)
+      shifted2 = Point.new(x: point.x - center.x, y: point.y - center.y)
+
+      begin
+        alfa, beta = Cramer.solution2(
+            [shifted1.x ** 2, shifted1.y ** 2],
+            [shifted2.x ** 2, shifted2.y ** 2],
+            [1, 1]
+        )
+      rescue
+        raise ArgumentError.new('No Hyperbola for these points!')
+      end
+
+      a2 = Rational(1, alfa)
+      b2 = Rational(1, beta)
+
+      self.new(x2: b2, y2: -a2, x: -2 * b2 * center.x, y: 2 * a2 * center.y, k: b2 * center.x ** 2 - a2 * center.y ** 2 + -position * a2 * b2)
+    end
+
+    def focus1
+      if position == 1
+        return Point.new(x: center.x + Math.sqrt(a2 + b2), y: center.y)
+      end
+      if position == -1
+        return Point.new(x: center.x, y: center.y + Math.sqrt(a2 + b2))
+      end
+    end
+
+    def focus2
+      if position == 1
+        return Point.new(x: center.x - Math.sqrt(a2 + b2), y: center.y)
+      end
+      if position == -1
+        return Point.new(x: center.x, y: center.y - Math.sqrt(a2 + b2))
+      end
+    end
+
+    def focal_distance
+      Point.distance(focus1, focus2)
+    end
+
+    def center
+      Point.new(x: centrum[:xc], y: centrum[:yc])
+    end
+
+    def difference_of_distances
+      if position == 1
+        return 2 * Math.sqrt(a2)
+      end
+      if position == -1
+        return 2 * Math.sqrt(b2)
+      end
+    end
+
+    def congruent?(hyperbola)
+      hyperbola.instance_of?(Hyperbola) and
+          hyperbola.eccentricity == self.eccentricity
+    end
+
+    def == (hyperbola)
+      hyperbola.instance_of?(Hyperbola) and
+          hyperbola.focus1 == self.focus1 and hyperbola.focus2 == self.focus2 and hyperbola.difference_of_distances == self.difference_of_distances
+    end
+
+    private
+
+    def validation
+
+      if signum(@x2_coeff * @y2_coeff) >= 0 or determinator == @k_coeff
+        raise ArgumentError.new('Invalid coefficients!')
+      end
+
+    end
+
+    def position
+      signum(determinator - @k_coeff)
+    end
+
+  end
+
+end

data/lib/cartesius/line.rb

@@ -0,0 +1,159 @@
+require('cartesius/numerificator')
+
+module Cartesius
+
+  class Line
+    include Numerificator
+    VERTICAL_SLOPE = Float::INFINITY
+    HORIZONTAL_SLOPE = 0
+
+    def initialize(x:, y:, k:)
+      @x_coeff, @y_coeff, @k_coeff = x.to_r, y.to_r, k.to_r
+      validation
+    end
+
+    def self.create(slope:, known_term:)
+      new(x: -slope.to_r, y: 1, k: -known_term.to_r)
+    end
+
+    def self.horizontal(known_term:)
+      new(x: 0, y: 1, k: -known_term.to_r)
+    end
+
+    def self.vertical(known_term:)
+      new(x: 1, y: 0, k: -known_term.to_r)
+    end
+
+    def self.by_points(point1:, point2:)
+      if point1 == point2
+        raise ArgumentError.new('Points must be different!')
+      end
+
+      if point1.aligned_horizontally_with?(point2)
+        return horizontal(known_term: point1.y)
+      end
+
+      if point1.aligned_vertically_with?(point2)
+        return vertical(known_term: point1.x)
+      end
+
+      slope = Rational(point2.y - point1.y, point2.x - point1.x)
+      known_term = point1.y - slope * point1.x
+
+      create(slope: slope, known_term: known_term)
+    end
+
+    def self.x_axis
+      horizontal(known_term: 0)
+    end
+
+    def self.y_axis
+      vertical(known_term: 0)
+    end
+
+    def self.ascending_bisector
+      new(x: -1, y: 1, k: 0)
+    end
+
+    def self.descending_bisector
+      new(x: 1, y: 1, k: 0)
+    end
+
+    def slope
+      @y_coeff == 0 ? VERTICAL_SLOPE : Rational(-@x_coeff, @y_coeff)
+    end
+
+    def known_term
+      @y_coeff == 0 ? Rational(-@k_coeff, @x_coeff) : Rational(-@k_coeff, @y_coeff)
+    end
+
+    def x_axis?
+      self == Line.x_axis
+    end
+
+    def y_axis?
+      self == Line.y_axis
+    end
+
+    def ascending_bisector?
+      self == Line.ascending_bisector
+    end
+
+    def descending_bisector?
+      self == Line.descending_bisector
+    end
+
+    def horizontal?
+      slope == HORIZONTAL_SLOPE
+    end
+
+    def vertical?
+      slope == VERTICAL_SLOPE
+    end
+
+    def inclined?
+      (not horizontal?) and (not vertical?)
+    end
+
+    def ascending?
+      slope != VERTICAL_SLOPE and slope > 0
+    end
+
+    def descending?
+      slope < 0
+    end
+
+    def parallel?(line)
+      slope == line.slope
+    end
+
+    def perpendicular?(line)
+      if slope == 0
+        return line.slope == VERTICAL_SLOPE
+      end
+      if slope == VERTICAL_SLOPE
+        return line.slope == 0
+      end
+      slope * line.slope == -1
+    end
+
+    def include?(point)
+      if vertical?
+        return known_term == point.x
+      end
+      point.y == slope * point.x + known_term
+    end
+
+    def x_intercept
+      @x_coeff.zero? ? nil : -Rational(@k_coeff, @x_coeff)
+    end
+
+    def y_intercept
+      @y_coeff.zero? ? nil : -Rational(@k_coeff, @y_coeff)
+    end
+
+    def to_equation
+      equationfy(
+          'x' => @x_coeff, 'y' => @y_coeff, '1' => @k_coeff
+      )
+    end
+
+    def congruent?(line)
+      line.instance_of?(Line)
+    end
+
+    def == (line)
+      congruent?(line) and
+          line.slope == self.slope and line.known_term == self.known_term
+    end
+
+    private
+
+    def validation
+      if (@x_coeff == 0 and @y_coeff == 0)
+        raise ArgumentError.new('Invalid coefficients!')
+      end
+    end
+
+  end
+end

data/lib/cartesius/parabola.rb

@@ -0,0 +1,118 @@
+require('cartesius/point')
+require('cartesius/line')
+require('cartesius/numerificator')
+require('cartesius/cramer')
+
+module Cartesius
+
+  class Parabola
+    include Numerificator
+
+    # Conic
+    # Conic equation type: ax^2 + dx - y + f = 0
+    def initialize(x2:, x:, k:)
+      @x2_coeff, @x_coeff, @y_coeff, @k_coeff = x2.to_r, x.to_r, -1, k.to_r
+      validation
+    end
+
+    def self.unitary_convex
+      new(x2: 1, x: 0, k: 0)
+    end
+
+    def self.unitary_concave
+      new(x2: -1, x: 0, k: 0)
+    end
+
+    def self.by_definition(directrix:, focus:)
+      if directrix.include?(focus)
+        raise ArgumentError.new('Focus belongs to directrix!')
+      end
+
+      unless directrix.horizontal?
+        raise ArgumentError.new('Directrix is not parallel to x-axis!')
+      end
+
+      a = Rational(1, 2 * (focus.y - directrix.y_intercept))
+      b = -2 * a * focus.x
+      c = a * (focus.x ** 2) + focus.y - Rational(1, 4 * a)
+
+      self.new(x2: -a, x: -b, k: -c)
+    end
+
+    def self.by_canonical(focus:, gap:)
+      if gap.zero?
+        raise ArgumentError.new('Gap must not be zero!')
+      end
+
+      a = gap
+      b = -2 * a * focus.x
+      c = (focus.x ** 2) + focus.y - Rational(1, 4 * a)
+
+      self.new(x2: -a, x: -b, k: -c)
+    end
+
+    def self.by_points(point1:, point2:, point3:)
+
+      if point1 == point2 or point1 == point3 or point2 == point3
+        raise ArgumentError.new('Points must be distinct!')
+      end
+
+      a, b, c = Cramer.solution3(
+          [point1.x ** 2, point1.x, 1],
+          [point2.x ** 2, point2.x, 1],
+          [point3.x ** 2, point3.x, 1],
+          [point1.y, point2.y, point3.y]
+      )
+
+      self.new(x2: -a, x: -b, k: -c)
+    end
+
+    def directrix
+      Line.horizontal(known_term: Rational(-delta - 1, 4 * @x2_coeff))
+    end
+
+    def focus
+      Point.new(x: Rational(-@x_coeff, 2 * @x2_coeff), y: Rational(1 - delta, 4 * @x2_coeff))
+    end
+
+    def vertex
+      Point.new(x: Rational(-@x_coeff, 2 * @x2_coeff), y: Rational(-delta, 4 * @x2_coeff))
+    end
+
+    def symmetry_axis
+      Line.vertical(known_term: Rational(-@x_coeff, 2* @x2_coeff))
+    end
+
+    def unitary_convex?
+      self == Parabola.unitary_convex
+    end
+
+    def unitary_concave?
+      self == Parabola.unitary_concave
+    end
+
+    def == (parabola)
+      parabola.instance_of?(Parabola) and
+          parabola.focus == self.focus and parabola.directrix == self.directrix
+    end
+
+    def to_equation
+      equationfy(
+          'x^2' => @x2_coeff, 'x' => @x_coeff, 'y' => @y_coeff, '1' => @k_coeff
+      )
+    end
+
+    private
+
+    def validation
+      if @x2_coeff == 0
+        raise ArgumentError.new('Invalid coefficients!')
+      end
+    end
+
+    def delta
+      (@x_coeff ** 2) - (4 * @x2_coeff * @k_coeff)
+    end
+
+  end
+end

data/lib/cartesius/point.rb

@@ -0,0 +1,62 @@
+require('cartesius/numerificator')
+
+module Cartesius
+
+  class Point
+    include Numerificator
+    attr_reader :x, :y
+
+    def initialize(x:, y:)
+      @x, @y = x.to_r, y.to_r
+    end
+
+    def self.origin
+      new(x: 0, y: 0)
+    end
+
+    def self.distance(point1, point2)
+      Math.sqrt(
+          (point1.x - point2.x) ** 2 + (point1.y - point2.y) ** 2
+      )
+    end
+
+    def origin?
+      self == Point.origin
+    end
+
+    def aligned_horizontally_with?(point)
+      @y == point.y
+    end
+
+    def aligned_vertically_with?(point)
+      @x == point.x
+    end
+
+    def distance_from(point)
+      Math.sqrt(
+          (@x - point.x) ** 2 + (@y - point.y) ** 2
+      )
+    end
+
+    def to_coordinates
+      "(#{stringfy(x)}; #{stringfy(y)})"
+    end
+
+    def to_equation
+      equationfy(
+          'x^2' => 1, 'y^2' => 1, 'x' => -2 * @x, 'y' => -2 * @y, '1' => @x ** 2 + @y ** 2
+      )
+    end
+
+    def congruent?(point)
+      point.instance_of?(Point)
+    end
+
+    def == (point)
+      congruent?(point) and
+          point.x == @x and point.y == @y
+    end
+
+  end
+
+end

data/lib/cartesius/segment.rb

@@ -0,0 +1,60 @@
+require('cartesius/point')
+require('cartesius/line')
+
+module Cartesius
+
+  class Segment
+    extend Forwardable
+    attr_reader :extreme1, :extreme2
+    def_delegators(:@line, :horizontal?, :vertical?, :inclined?, :ascending?, :descending?)
+
+    def initialize(extreme1:, extreme2:)
+      @extreme1, @extreme2 = extreme1, extreme2
+      validation
+      @line = Line.by_points(point1: @extreme1, point2: @extreme2)
+    end
+
+    def to_line
+      @line
+    end
+
+    def length
+      Point.distance(@extreme1, @extreme2)
+    end
+
+    def mid
+      Point.new(
+          x: Rational(@extreme1.x + @extreme2.x, 2),
+          y: Rational(@extreme1.y + @extreme2.y, 2)
+      )
+    end
+
+    def extremes
+      [@extreme1, @extreme2]
+    end
+
+    def congruent?(segment)
+      segment.instance_of?(Segment) and
+          segment.length == self.length
+    end
+
+    def == (segment)
+      unless segment.instance_of?(Segment)
+        return false
+      end
+
+      (segment.extreme1 == self.extreme1 and segment.extreme2 == self.extreme2) or
+          (segment.extreme1 == self.extreme2 and segment.extreme2 == self.extreme1)
+    end
+
+    private
+
+    def validation
+      if @extreme1 == @extreme2
+        raise ArgumentError.new('Extremes cannot be the same!')
+      end
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: cartesius
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Mauro Quaglia
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-11-07 00:00:00.000000000 Z
+dependencies: []
+description: The cartesian plan and its elements.
+email: mauroquaglia@libero.it
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cartesius/circumference.rb
+- lib/cartesius/ellipse.rb
+- lib/cartesius/hyperbola.rb
+- lib/cartesius/line.rb
+- lib/cartesius/parabola.rb
+- lib/cartesius/point.rb
+- lib/cartesius/segment.rb
+homepage: https://github.com/MauroQuaglia/cartesius
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: The cartesian coordinate system.
+test_files: []