cartesius 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 95fd724a37b3fd9e2e072f649cd34ffcd6ade1bd
-  data.tar.gz: 304ab894b81c52b1d02c63076be66879a20319f7
+  metadata.gz: 8ca7c08a027f0547ece43bf75d1d622aa7a59279
+  data.tar.gz: 9b95391ad0010c8dd2cb1eb11a37933e2fa74b2f
 SHA512:
-  metadata.gz: 5f3b5b319332a590bcd796952e58328cbafa0b6857fea724bc796cbdc72520c715a167d063bf3510a5db5617cb52c49e55b75938c42c69c484a47a82a817471e
-  data.tar.gz: 3abcc3dc0cdc72e7878dbb1c55cf7c4d887f1fe464e228083e993e0d11f4952ee9769c9afaf34cfc69212e51f848f56c32bc08b808cf1f2c259b941006bdc50d
+  metadata.gz: 6b141b69ced00426c9c461e07bec394bacf3a625058c68ee101caa3f8886c21711342a920d2adfd29fc3fadc2094a108354ca004ad47a891a5830f306d4370d6
+  data.tar.gz: b37537b3e28b9973c9d2981742cc52e6a2b181a1bc7342407af1e37d96fff7d343ed5199f4fce435c5d344909906a83d252541380e720a8cbb1d9c29bb5cb3f9

data/lib/cartesius/circumference.rb

@@ -11,57 +11,56 @@ module Cartesius
     # 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
+      @x2_coeff, @y2_coeff, @x_coeff, @y_coeff, @k_coeff = normalize(1, 1, x, y, k)
       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
+    def self.by_definition(center:, radius:)
+      if radius <= 0
+        raise ArgumentError.new('Radius must be positive!')
+      end
 
-      self.new(x: alfa, y: beta, k: gamma)
+      build_by(center, radius)
     end
 
-    def self.by_canonical(focus:, radius:)
-      by_definition(focus: focus, radius: radius)
+    def self.by_diameter(diameter:)
+      center = diameter.mid
+      radius = Rational(diameter.length, 2)
+
+      build_by(center, 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)
+    rescue
+      raise ArgumentError.new('Invalid points!')
     end
 
-
-    def self.unitary
-      new(x: 0, y: 0, k: -1)
+    def self.goniometric
+      build_by(Point.origin, 1)
     end
 
-    def center
-      Point.new(x: centrum[:xc], y: centrum[:yc])
+    def goniometric?
+      self == Circumference.goniometric
     end
 
     def radius
       Math.sqrt(a2)
     end
 
-    def unitary?
-      self == Circumference.unitary
+    def eccentricity
+      0
+    end
+
+    def congruent?(circumference)
+      circumference.instance_of?(Circumference) and
+          circumference.radius == self.radius
     end
 
     def == (circumference)
@@ -69,19 +68,11 @@ module Cartesius
           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
+    def self.build_by(center, radius)
+      self.new(x: -2 * center.x, y: -2 * center.y, k: center.x ** 2 + center.y ** 2 - radius.to_r ** 2)
     end
 
-    def to_equation
-      equationfy(
-          'x^2' => @x2_coeff, 'y^2' => @y2_coeff, 'x' => @x_coeff, 'y' => @y_coeff, '1' => @k_coeff
-      )
-    end
+    private_class_method(:build_by)
 
     private
 

data/lib/cartesius/ellipse.rb

@@ -11,8 +11,7 @@ module Cartesius
     # 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
+      @x2_coeff, @y2_coeff, @x_coeff, @y_coeff, @k_coeff = normalize(x2, y2, x, y, k)
       validation
     end
 
@@ -21,42 +20,61 @@ module Cartesius
         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!')
+      focal_axis = Segment.new(extreme1: focus1, extreme2: focus2)
+      if focal_axis.inclined?
+        raise ArgumentError.new('Focal axis must not be inclined!')
       end
 
-      focal_distance = Point.distance(focus1, focus2)
-      if distance <= focal_distance
+      if distance <= focal_axis.length
         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)
+      c2 = Rational(focal_axis.length, 2) ** 2
+      if focal_axis.horizontal?
         a2 = Rational(distance, 2) ** 2
         b2 = a2 - c2
-      end
-      if focus1.aligned_vertically_with?(focus2)
+      else
         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)
+      center = focal_axis.mid
+
+      build_by(a2, b2, center)
     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!')
+    def self.by_axes(major_axis:, minor_axis:)
+      if major_axis == minor_axis
+        raise ArgumentError.new('Axes must be different!')
       end
 
-      if x_semi_axis == y_semi_axis
-        raise ArgumentError.new('Semi axis length must be different!')
+      if major_axis.inclined? or minor_axis.inclined?
+        raise ArgumentError.new('Axes must not be inclined!')
       end
 
-      b2 = y_semi_axis ** 2
-      a2 = x_semi_axis ** 2
+      if major_axis.horizontal? and minor_axis.horizontal?
+        raise ArgumentError.new('Axes can not be both horizontal!')
+      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)
+      if major_axis.vertical? and minor_axis.vertical?
+        raise ArgumentError.new('Axes can not be both vertical!')
+      end
+
+      if major_axis.mid != minor_axis.mid
+        raise ArgumentError.new('Axes must be the same mid point!')
+      end
+
+      if major_axis.horizontal?
+        a2 = Rational(major_axis.length, 2) ** 2
+        b2 = Rational(minor_axis.length, 2) ** 2
+      else
+        a2 = Rational(minor_axis.length, 2) ** 2
+        b2 = Rational(major_axis.length, 2) ** 2
+      end
+
+      center = major_axis.mid
+
+      build_by(a2, b2, center)
     end
 
     def self.by_points(center:, point1:, point2:)
@@ -74,74 +92,62 @@ module Cartesius
             [1, 1]
         )
       rescue
-        raise ArgumentError.new('No Ellipse for these points!')
+        raise ArgumentError.new('Center and points are not valid!')
       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)
+      build_by(a2, b2, center)
     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
+      discriminating(
+          lambda {Point.new(x: center.x + cx, y: center.y)},
+          lambda {Point.new(x: center.x, y: center.y + cy)}
+      )
     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
+      discriminating(
+          lambda {Point.new(x: center.x - cx, y: center.y)},
+          lambda {Point.new(x: center.x, y: center.y - cy)}
+      )
     end
 
-    def x_semi_axis_length
-      Math.sqrt(a2)
+    def distance
+      discriminating(lambda {2 * a}, lambda {2 * b})
     end
 
-    def y_semi_axis_length
-      Math.sqrt(b2)
+    def focal_axis
+      Segment.new(extreme1: focus1, extreme2: focus2)
     end
 
-    def major_semi_axis
-      [x_semi_axis_length, y_semi_axis_length].max
+    def major_axis
+      discriminating(
+          lambda {Segment.new(extreme1: Point.new(x: center.x - a, y: center.y), extreme2: Point.new(x: center.x + a, y: center.y))},
+          lambda {Segment.new(extreme1: Point.new(x: center.x, y: center.y - b), extreme2: Point.new(x: center.x, y: center.y + b))},
+          )
     end
 
-    def minor_semi_axis
-      [x_semi_axis_length, y_semi_axis_length].min
+    def minor_axis
+      discriminating(
+          lambda {Segment.new(extreme1: Point.new(x: center.x, y: center.y - b), extreme2: Point.new(x: center.x, y: center.y + b))},
+          lambda {Segment.new(extreme1: Point.new(x: center.x - a, y: center.y), extreme2: Point.new(x: center.x + a, y: center.y))}
+      )
     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)
+          Point.new(x: center.x + a, y: center.y),
+          Point.new(x: center.x, y: center.y - b),
+          Point.new(x: center.x - a, y: center.y),
+          Point.new(x: center.x, y: center.y + b)
       ]
     end
 
     def eccentricity
-      Rational(focal_distance, 2 * major_semi_axis)
+      Rational(focal_axis.length, major_axis.length)
     end
 
     def congruent?(ellipse)
@@ -151,15 +157,15 @@ module Cartesius
 
     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
+          ellipse.focus1 == self.focus1 and ellipse.focus2 == self.focus2 and ellipse.distance == self.distance
     end
 
-    def to_equation
-      equationfy(
-          'x^2' => @x2_coeff, 'y^2' => @y2_coeff, 'x' => @x_coeff, 'y' => @y_coeff, '1' => @k_coeff
-      )
+    def self.build_by(a2, b2, center)
+      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
 
+    private_class_method(:build_by)
+
     private
 
     def validation
@@ -168,6 +174,30 @@ module Cartesius
       end
     end
 
+    def discriminating(horizontal_focus_type, vertical_focus_type)
+      if a2 > b2
+        horizontal_focus_type.call
+      else
+        vertical_focus_type.call
+      end
+    end
+
+    def a
+      Math.sqrt(a2)
+    end
+
+    def b
+      Math.sqrt(b2)
+    end
+
+    def cx
+      Math.sqrt(a2 - b2)
+    end
+
+    def cy
+      Math.sqrt(b2 - a2)
+    end
+
   end
 
 end

data/lib/cartesius/hyperbola.rb

@@ -8,11 +8,15 @@ module Cartesius
   class Hyperbola
     include Determinator, Numerificator
 
-    # Conic
+    RIGHT_POSITION = 1
+    UP_POSITION = -1
+
+    private_constant(:UP_POSITION)
+    private_constant(:RIGHT_POSITION)
+
     # 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
+      @x2_coeff, @y2_coeff, @x_coeff, @y_coeff, @k_coeff = normalize(x2, y2, x, y, k)
       validation
     end
 
@@ -21,51 +25,65 @@ module Cartesius
         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!')
+      focal_axis = Segment.new(extreme1: focus1, extreme2: focus2)
+      if focal_axis.inclined?
+        raise ArgumentError.new('Focal axis must not be inclined!')
       end
 
-      focal_distance = Point.distance(focus1, focus2)
-      if distance >= focal_distance
-        raise ArgumentError.new('Difference of distances must be less than focal distance!')
+      if distance >= focal_axis.length
+        raise ArgumentError.new('Difference between 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
+      c2 = Rational(focal_axis.length, 2)**2
+      if focal_axis.horizontal?
+        a2 = Rational(distance, 2)**2
         b2 = c2 - a2
-        position = 1
-      end
-      if focus1.aligned_vertically_with?(focus2)
-        b2 = Rational(distance, 2) ** 2
+        position = RIGHT_POSITION
+      else
+        b2 = Rational(distance, 2)**2
         a2 = c2 - b2
-        position = -1
+        position = UP_POSITION
       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)
+      center = focal_axis.mid
+
+      build_by(a2, b2, center, position)
     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!')
+    def self.by_axes(transverse_axis:, not_transverse_axis:)
+      if transverse_axis == not_transverse_axis
+        raise ArgumentError.new('Axes must be different!')
       end
 
-      unless [-1, 1].include?(position)
-        raise ArgumentError.new('Position must be up or right!')
+      if transverse_axis.inclined? or not_transverse_axis.inclined?
+        raise ArgumentError.new('Axes must not be inclined!')
       end
 
-      if position == -1
-        a2 = not_transverse_axis ** 2
-        b2 = transverse_axis ** 2
+      if transverse_axis.horizontal? and not_transverse_axis.horizontal?
+        raise ArgumentError.new('Axes can not be both horizontal!')
       end
 
-      if position == 1
-        a2 = transverse_axis ** 2
-        b2 = not_transverse_axis ** 2
+      if transverse_axis.vertical? and not_transverse_axis.vertical?
+        raise ArgumentError.new('Axes can not be both vertical!')
       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)
+      if transverse_axis.mid != not_transverse_axis.mid
+        raise ArgumentError.new('Axes must be the same mid point!')
+      end
+
+      if transverse_axis.horizontal?
+        a2 = Rational(transverse_axis.length, 2)**2
+        b2 = Rational(not_transverse_axis.length, 2)**2
+        position = RIGHT_POSITION
+      else
+        a2 = Rational(not_transverse_axis.length, 2)**2
+        b2 = Rational(transverse_axis.length, 2)**2
+        position = UP_POSITION
+      end
+
+      center = transverse_axis.mid
+
+      build_by(a2, b2, center, position)
     end
 
     def self.by_points(center:, vertex:, point:)
@@ -73,16 +91,15 @@ module Cartesius
         raise ArgumentError.new('Points must be different!')
       end
 
-      unless vertex.aligned_horizontally_with?(center) or vertex.aligned_vertically_with?(center)
+      semi_axis = Segment.new(extreme1: center, extreme2: vertex)
+      if semi_axis.inclined?
         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
+      if semi_axis.horizontal?
+        position = RIGHT_POSITION
+      else
+        position = UP_POSITION
       end
 
       shifted1 = Point.new(x: vertex.x - center.x, y: vertex.y - center.y)
@@ -90,53 +107,77 @@ module Cartesius
 
       begin
         alfa, beta = Cramer.solution2(
-            [shifted1.x ** 2, shifted1.y ** 2],
-            [shifted2.x ** 2, shifted2.y ** 2],
-            [1, 1]
+            [shifted1.x**2, -shifted1.y**2],
+            [shifted2.x**2, -shifted2.y**2],
+            [position, position]
         )
       rescue
-        raise ArgumentError.new('No Hyperbola for these points!')
+        raise ArgumentError.new('Center, vertex and point are not valid!')
       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)
+      build_by(a2, b2, center, position)
     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
+      discriminating(
+          lambda {Point.new(x: center.x + c, y: center.y)},
+          lambda {Point.new(x: center.x, y: center.y + c)}
+      )
     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
+      discriminating(
+          lambda {Point.new(x: center.x - c, y: center.y)},
+          lambda {Point.new(x: center.x, y: center.y - c)}
+      )
     end
 
-    def focal_distance
-      Point.distance(focus1, focus2)
+    def distance
+      discriminating(lambda {2 * a}, lambda {2 * b})
     end
 
-    def center
-      Point.new(x: centrum[:xc], y: centrum[:yc])
+    def focal_axis
+      Segment.new(extreme1: focus1, extreme2: focus2)
     end
 
-    def difference_of_distances
-      if position == 1
-        return 2 * Math.sqrt(a2)
-      end
-      if position == -1
-        return 2 * Math.sqrt(b2)
-      end
+    def transverse_axis
+      discriminating(
+          lambda {Segment.new(extreme1: Point.new(x: center.x - a, y: center.y), extreme2: Point.new(x: center.x + a, y: center.y))},
+          lambda {Segment.new(extreme1: Point.new(x: center.x, y: center.y - b), extreme2: Point.new(x: center.x, y: center.y + b))},
+      )
+    end
+
+    def not_transverse_axis
+      discriminating(
+          lambda {Segment.new(extreme1: Point.new(x: center.x, y: center.y - b), extreme2: Point.new(x: center.x, y: center.y + b))},
+          lambda {Segment.new(extreme1: Point.new(x: center.x - a, y: center.y), extreme2: Point.new(x: center.x + a, y: center.y))}
+      )
+    end
+
+    def vertices
+      discriminating(
+          lambda {[Point.new(x: center.x - a, y: center.y), Point.new(x: center.x + a, y: center.y)]},
+          lambda {[Point.new(x: center.x, y: center.y - b), Point.new(x: center.x, y: center.y + b)]}
+      )
+    end
+
+    def eccentricity
+      Rational(focal_axis.length, transverse_axis.length)
+    end
+
+    def ascending_asymptote
+      Line.create(slope: Rational(b, a), known_term: center.y - center.x * Rational(b, a))
+    end
+
+    def descending_asymptote
+      Line.create(slope: -Rational(b, a), known_term: center.y + center.x * Rational(b, a))
+    end
+
+    def equilateral?
+      a2 == b2
     end
 
     def congruent?(hyperbola)
@@ -146,21 +187,41 @@ module Cartesius
 
     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
+          hyperbola.focus1 == self.focus1 and hyperbola.focus2 == self.focus2 and hyperbola.distance == self.distance
     end
 
+    def self.build_by(a2, b2, center, position)
+      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
+
+    private_class_method(:build_by)
+
     private
 
     def validation
-
       if signum(@x2_coeff * @y2_coeff) >= 0 or determinator == @k_coeff
         raise ArgumentError.new('Invalid coefficients!')
       end
+    end
+
+    def discriminating(horizontal_focus_type, vertical_focus_type)
+      if signum(determinator - @k_coeff) == 1
+        horizontal_focus_type.call
+      else
+        vertical_focus_type.call
+      end
+    end
+
+    def a
+      Math.sqrt(a2)
+    end
 
+    def b
+      Math.sqrt(b2)
     end
 
-    def position
-      signum(determinator - @k_coeff)
+    def c
+      Math.sqrt(a2 + b2)
     end
 
   end

data/lib/cartesius/line.rb

@@ -29,11 +29,11 @@ module Cartesius
         raise ArgumentError.new('Points must be different!')
       end
 
-      if point1.aligned_horizontally_with?(point2)
+      if point1.y == point2.y
         return horizontal(known_term: point1.y)
       end
 
-      if point1.aligned_vertically_with?(point2)
+      if point1.x == point2.x
         return vertical(known_term: point1.x)
       end
 
@@ -143,7 +143,7 @@ module Cartesius
     end
 
     def == (line)
-      congruent?(line) and
+      line.instance_of?(Line) and
           line.slope == self.slope and line.known_term == self.known_term
     end
 

data/lib/cartesius/parabola.rb

@@ -15,14 +15,6 @@ module Cartesius
       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!')
@@ -36,27 +28,10 @@ module Cartesius
       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)
+      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],
@@ -64,7 +39,9 @@ module Cartesius
           [point1.y, point2.y, point3.y]
       )
 
-      self.new(x2: -a, x: -b, k: -c)
+      self.new(x2: a, x: b, k: c)
+    rescue
+      raise ArgumentError.new('Invalid points!')
     end
 
     def directrix
@@ -83,23 +60,24 @@ module Cartesius
       Line.vertical(known_term: Rational(-@x_coeff, 2* @x2_coeff))
     end
 
-    def unitary_convex?
-      self == Parabola.unitary_convex
+    def eccentricity
+      @x2_coeff.abs
     end
 
-    def unitary_concave?
-      self == Parabola.unitary_concave
+    def to_equation
+      equationfy(
+          'x^2' => @x2_coeff, 'x' => @x_coeff, 'y' => -1, '1' => @k_coeff
+      )
     end
 
-    def == (parabola)
+    def congruent?(parabola)
       parabola.instance_of?(Parabola) and
-          parabola.focus == self.focus and parabola.directrix == self.directrix
+          parabola.eccentricity == self.eccentricity
     end
 
-    def to_equation
-      equationfy(
-          'x^2' => @x2_coeff, 'x' => @x_coeff, 'y' => @y_coeff, '1' => @k_coeff
-      )
+    def == (parabola)
+      parabola.instance_of?(Parabola) and
+          parabola.focus == self.focus and parabola.directrix == self.directrix
     end
 
     private

data/lib/cartesius/point.rb

@@ -15,27 +15,15 @@ module Cartesius
     end
 
     def self.distance(point1, point2)
-      Math.sqrt(
-          (point1.x - point2.x) ** 2 + (point1.y - point2.y) ** 2
-      )
+      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
-      )
+      Math.sqrt((@x - point.x)** 2 + (@y - point.y)** 2)
     end
 
     def to_coordinates
@@ -53,7 +41,7 @@ module Cartesius
     end
 
     def == (point)
-      congruent?(point) and
+      point.instance_of?(Point) and
           point.x == @x and point.y == @y
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cartesius
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Mauro Quaglia
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-07 00:00:00.000000000 Z
+date: 2017-12-01 00:00:00.000000000 Z
 dependencies: []
 description: The cartesian plan and its elements.
 email: mauroquaglia@libero.it
@@ -35,7 +35,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -43,7 +43,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
 summary: The cartesian coordinate system.