cartesius 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8ca7c08a027f0547ece43bf75d1d622aa7a59279
-  data.tar.gz: 9b95391ad0010c8dd2cb1eb11a37933e2fa74b2f
+  metadata.gz: 69e7a9e2b6c6f4edb2bcc0cd73e5f909ee2eed07
+  data.tar.gz: 4eda3671a45184320a8485a0bd389df017bc8b8f
 SHA512:
-  metadata.gz: 6b141b69ced00426c9c461e07bec394bacf3a625058c68ee101caa3f8886c21711342a920d2adfd29fc3fadc2094a108354ca004ad47a891a5830f306d4370d6
-  data.tar.gz: b37537b3e28b9973c9d2981742cc52e6a2b181a1bc7342407af1e37d96fff7d343ed5199f4fce435c5d344909906a83d252541380e720a8cbb1d9c29bb5cb3f9
+  metadata.gz: 005e1721917eb39048995f4567a084c53ec9bdc66f2d95ca78ae2a827ae9bb19561747072ac257f697c46d2fc572e2a4175c897feedd929408a7d1fe438cbc8b
+  data.tar.gz: 01db7a237a5fa5edc13314dee6503120f9e232f65665e1cba2a3c9d830c1d9bbf68da95f367bc634e3af493d51b3e004eff202b9f4250665504e212643a8c8b0

data/lib/cartesius/angle.rb

@@ -0,0 +1,95 @@
+module Cartesius
+  class Angle
+    NULL, RIGHT, FLAT, FULL = 0, 90, 180, 360
+    private_constant(:NULL)
+    private_constant(:RIGHT)
+    private_constant(:FLAT)
+    private_constant(:FULL)
+
+    def initialize(angle)
+      @angle = angle
+    end
+
+    private_class_method(:new)
+
+    def self.by_degrees(degrees)
+      new(degrees)
+    end
+
+    def self.by_radiants(radiants)
+      by_degrees(radiants * FLAT / Math::PI)
+    end
+
+    def self.by_lines(line1:, line2:)
+      raise ArgumentError.new('Lines must not be parallel!') if line1.parallel?(line2)
+      if line1.perpendicular?(line2)
+        [right, right]
+      else
+        acute = by_radiants(Math.atan(line1.slope - line2.slope / 1 + line1.slope * line2.slope).abs)
+        [acute, new(FLAT - acute.degrees)]
+      end
+    end
+
+    def self.null
+      by_degrees(NULL)
+    end
+
+    def self.right
+      by_degrees(RIGHT)
+    end
+
+    def self.flat
+      by_degrees(FLAT)
+    end
+
+    def self.full
+      by_degrees(FULL)
+    end
+
+    def degrees(precision = 3)
+      @angle.round(precision)
+    end
+
+    def radiants(precision = 3)
+      (@angle * Math::PI / FLAT).round(precision)
+    end
+
+    def null?
+      degrees == NULL
+    end
+
+    def acute?
+      degrees > NULL and degrees < RIGHT
+    end
+
+    def right?
+      degrees == RIGHT
+    end
+
+    def obtuse?
+      degrees > RIGHT and degrees < FLAT
+    end
+
+    def flat?
+      degrees == FLAT
+    end
+
+    def full?
+      degrees == FULL
+    end
+
+    def congruent?(angle)
+      angle.instance_of?(self.class) and
+          angle.degrees == degrees
+    end
+
+    alias_method(:eql?, :congruent?)
+
+    private
+
+    def hash
+      @angle.hash
+    end
+
+  end
+end

data/lib/cartesius/circumference.rb

@@ -37,7 +37,7 @@ module Cartesius
           [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)
+      new(x: alfa, y: beta, k: gamma)
     rescue
       raise ArgumentError.new('Invalid points!')
     end
@@ -59,17 +59,17 @@ module Cartesius
     end
 
     def congruent?(circumference)
-      circumference.instance_of?(Circumference) and
-          circumference.radius == self.radius
+      circumference.instance_of?(self.class) and
+          circumference.radius == radius
     end
 
     def == (circumference)
-      circumference.instance_of?(Circumference) and
-          circumference.center == self.center and circumference.radius == self.radius
+      circumference.instance_of?(self.class) and
+          circumference.center == center and circumference.radius == radius
     end
 
     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)
+      new(x: -2 * center.x, y: -2 * center.y, k: center.x ** 2 + center.y ** 2 - radius.to_r ** 2)
     end
 
     private_class_method(:build_by)

data/lib/cartesius/ellipse.rb

@@ -151,17 +151,17 @@ module Cartesius
     end
 
     def congruent?(ellipse)
-      ellipse.instance_of?(Ellipse) and
-          ellipse.eccentricity == self.eccentricity
+      ellipse.instance_of?(self.class) and
+          ellipse.eccentricity == eccentricity
     end
 
     def == (ellipse)
-      ellipse.instance_of?(Ellipse) and
-          ellipse.focus1 == self.focus1 and ellipse.focus2 == self.focus2 and ellipse.distance == self.distance
+      ellipse.instance_of?(self.class) and
+          ellipse.focus1 == focus1 and ellipse.focus2 == focus2 and ellipse.distance == distance
     end
 
     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)
+      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)

data/lib/cartesius/hyperbola.rb

@@ -181,17 +181,17 @@ module Cartesius
     end
 
     def congruent?(hyperbola)
-      hyperbola.instance_of?(Hyperbola) and
-          hyperbola.eccentricity == self.eccentricity
+      hyperbola.instance_of?(self.class) and
+          hyperbola.eccentricity == eccentricity
     end
 
     def == (hyperbola)
-      hyperbola.instance_of?(Hyperbola) and
-          hyperbola.focus1 == self.focus1 and hyperbola.focus2 == self.focus2 and hyperbola.distance == self.distance
+      hyperbola.instance_of?(self.class) and
+          hyperbola.focus1 == focus1 and hyperbola.focus2 == focus2 and hyperbola.distance == 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)
+      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)

data/lib/cartesius/line.rb

@@ -7,6 +7,10 @@ module Cartesius
     VERTICAL_SLOPE = Float::INFINITY
     HORIZONTAL_SLOPE = 0
 
+    private_constant(:VERTICAL_SLOPE)
+    private_constant(:HORIZONTAL_SLOPE)
+
+    # equation type: dx + ey + f = 0
     def initialize(x:, y:, k:)
       @x_coeff, @y_coeff, @k_coeff = x.to_r, y.to_r, k.to_r
       validation
@@ -17,7 +21,7 @@ module Cartesius
     end
 
     def self.horizontal(known_term:)
-      new(x: 0, y: 1, k: -known_term.to_r)
+      create(slope: HORIZONTAL_SLOPE, known_term: known_term)
     end
 
     def self.vertical(known_term:)
@@ -29,18 +33,16 @@ module Cartesius
         raise ArgumentError.new('Points must be different!')
       end
 
-      if point1.y == point2.y
-        return horizontal(known_term: point1.y)
-      end
-
       if point1.x == point2.x
         return vertical(known_term: point1.x)
+      else
+        m, q = Cramer.solution2(
+            [point1.x, 1],
+            [point2.x, 1],
+            [point1.y, point2.y]
+        )
+        create(slope: m, known_term: q)
       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
@@ -52,19 +54,27 @@ module Cartesius
     end
 
     def self.ascending_bisector
-      new(x: -1, y: 1, k: 0)
+      create(slope: 1, known_term: 0)
     end
 
     def self.descending_bisector
-      new(x: 1, y: 1, k: 0)
+      create(slope: -1, known_term: 0)
     end
 
     def slope
-      @y_coeff == 0 ? VERTICAL_SLOPE : Rational(-@x_coeff, @y_coeff)
+      if @y_coeff.zero?
+        VERTICAL_SLOPE
+      else
+        numberfy(-@x_coeff, @y_coeff)
+      end
     end
 
     def known_term
-      @y_coeff == 0 ? Rational(-@k_coeff, @x_coeff) : Rational(-@k_coeff, @y_coeff)
+      if @y_coeff.zero?
+        numberfy(-@k_coeff, @x_coeff)
+      else
+        numberfy(-@k_coeff, @y_coeff)
+      end
     end
 
     def x_axis?
@@ -92,65 +102,68 @@ module Cartesius
     end
 
     def inclined?
-      (not horizontal?) and (not vertical?)
+      ascending? or descending?
     end
 
     def ascending?
-      slope != VERTICAL_SLOPE and slope > 0
+      slope != VERTICAL_SLOPE and slope > HORIZONTAL_SLOPE
     end
 
     def descending?
-      slope < 0
+      slope < HORIZONTAL_SLOPE
     end
 
     def parallel?(line)
-      slope == line.slope
+      line.slope == slope
     end
 
     def perpendicular?(line)
-      if slope == 0
-        return line.slope == VERTICAL_SLOPE
-      end
-      if slope == VERTICAL_SLOPE
-        return line.slope == 0
+      if line.slope == HORIZONTAL_SLOPE
+        slope == VERTICAL_SLOPE
+      elsif line.slope == VERTICAL_SLOPE
+        slope == HORIZONTAL_SLOPE
+      else
+        line.slope * slope == -1
       end
-      slope * line.slope == -1
     end
 
     def include?(point)
       if vertical?
-        return known_term == point.x
+        point.x == known_term
+      else
+        point.y == slope * point.x + known_term
       end
-      point.y == slope * point.x + known_term
     end
 
     def x_intercept
-      @x_coeff.zero? ? nil : -Rational(@k_coeff, @x_coeff)
+      unless @x_coeff.zero?
+        numberfy(-@k_coeff, @x_coeff)
+      end
     end
 
     def y_intercept
-      @y_coeff.zero? ? nil : -Rational(@k_coeff, @y_coeff)
+      unless @y_coeff.zero?
+        numberfy(-@k_coeff, @y_coeff)
+      end
     end
 
     def to_equation
-      equationfy(
-          'x' => @x_coeff, 'y' => @y_coeff, '1' => @k_coeff
-      )
+      equationfy('x' => @x_coeff, 'y' => @y_coeff, '1' => @k_coeff)
     end
 
     def congruent?(line)
-      line.instance_of?(Line)
+      line.instance_of?(self.class)
     end
 
     def == (line)
-      line.instance_of?(Line) and
-          line.slope == self.slope and line.known_term == self.known_term
+      line.instance_of?(self.class) and
+          line.slope == slope and line.known_term == known_term
     end
 
     private
 
     def validation
-      if (@x_coeff == 0 and @y_coeff == 0)
+      if @x_coeff.zero? and @y_coeff.zero?
         raise ArgumentError.new('Invalid coefficients!')
       end
     end

data/lib/cartesius/parabola.rb

@@ -28,7 +28,7 @@ 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)
+      new(x2: a, x: b, k: c)
     end
 
     def self.by_points(point1:, point2:, point3:)
@@ -39,7 +39,7 @@ module Cartesius
           [point1.y, point2.y, point3.y]
       )
 
-      self.new(x2: a, x: b, k: c)
+      new(x2: a, x: b, k: c)
     rescue
       raise ArgumentError.new('Invalid points!')
     end
@@ -71,13 +71,13 @@ module Cartesius
     end
 
     def congruent?(parabola)
-      parabola.instance_of?(Parabola) and
-          parabola.eccentricity == self.eccentricity
+      parabola.instance_of?(self.class) and
+          parabola.eccentricity == eccentricity
     end
 
     def == (parabola)
-      parabola.instance_of?(Parabola) and
-          parabola.focus == self.focus and parabola.directrix == self.directrix
+      parabola.instance_of?(self.class) and
+          parabola.focus == focus and parabola.directrix == directrix
     end
 
     private

data/lib/cartesius/point.rb

@@ -1,7 +1,6 @@
 require('cartesius/numerificator')
 
 module Cartesius
-
   class Point
     include Numerificator
     attr_reader :x, :y
@@ -15,36 +14,36 @@ 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 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
-      )
+      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)
+      point.instance_of?(self.class)
     end
 
     def == (point)
-      point.instance_of?(Point) and
+      point.instance_of?(self.class) and
           point.x == @x and point.y == @y
     end
 
-  end
+    alias_method(:eql?, :==)
 
+    private
+
+    def hash
+      @x.hash ^ @y.hash
+    end
+  end
 end

data/lib/cartesius/segment.rb

@@ -4,6 +4,7 @@ require('cartesius/line')
 module Cartesius
 
   class Segment
+    include Numerificator
     extend Forwardable
     attr_reader :extreme1, :extreme2
     def_delegators(:@line, :horizontal?, :vertical?, :inclined?, :ascending?, :descending?)
@@ -24,8 +25,8 @@ module Cartesius
 
     def mid
       Point.new(
-          x: Rational(@extreme1.x + @extreme2.x, 2),
-          y: Rational(@extreme1.y + @extreme2.y, 2)
+          x: numberfy(@extreme1.x + @extreme2.x, 2),
+          y: numberfy(@extreme1.y + @extreme2.y, 2)
       )
     end
 
@@ -34,17 +35,15 @@ module Cartesius
     end
 
     def congruent?(segment)
-      segment.instance_of?(Segment) and
+      segment.instance_of?(self.class) 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)
+      segment.instance_of?(self.class) and (
+      (segment.extreme1 == extreme1 and segment.extreme2 == extreme2) or
+          (segment.extreme1 == extreme2 and segment.extreme2 == extreme1)
+      )
     end
 
     private

data/lib/cartesius/triangle.rb

@@ -0,0 +1,106 @@
+require('cartesius/validator')
+require('cartesius/segment')
+require('cartesius/angle')
+
+module Cartesius
+
+  class Triangle
+
+    def initialize(a:, b:, c:)
+      validation(a, b, c)
+      @v_a = a
+      @v_b = b
+      @v_c = c
+      @s_a = Segment.new(extreme1: @v_b, extreme2: @v_c)
+      @s_b = Segment.new(extreme1: @v_a, extreme2: @v_c)
+      @s_c = Segment.new(extreme1: @v_a, extreme2: @v_b)
+      @a_a = Angle.by_radiants(carnot(@s_a, @s_b, @s_c))
+      @a_b = Angle.by_radiants(carnot(@s_b, @s_a, @s_c))
+      @a_c = Angle.by_radiants(carnot(@s_c, @s_a, @s_b))
+    end
+
+    def angles
+      {a: @a_a, b: @a_b, c: @a_c}
+    end
+
+    def sides
+      {a: @s_a, b: @s_b, c: @s_c}
+    end
+
+    def vertices
+      {a: @v_a, b: @v_b, c: @v_c}
+    end
+
+    def rectangle?
+      angles.values.any?(&:right?)
+    end
+
+    def obtuse?
+      angles.values.any?(&:obtuse?)
+    end
+
+    def acute?
+      not rectangle? and not obtuse?
+    end
+
+    def equilateral?(precision = 2)
+      sides_congruent(precision) == 1
+    end
+
+    def isosceles?(precision = 2)
+      equilateral? or sides_congruent(precision) == 2
+    end
+
+    def scalene?(precision = 2)
+      sides_congruent(precision) == 3
+    end
+
+    def perimeter
+      sides.values.inject(0) {|sum, side| sum + side.length}
+    end
+
+    def area(precision = 2)
+      Rational(sides[:a].length * sides[:b].length * Math.sin(angles[:c].radiants), 2).round(precision)
+    end
+
+    def == (triangle)
+      triangle.instance_of?(self.class) and
+          triangle.vertices.values.to_set == vertices.values.to_set
+    end
+
+    def congruent? (triangle)
+      triangle.instance_of?(self.class) and
+          sides_length(triangle) == sides_length(self)
+    end
+
+    def similar?(triangle)
+      triangle.instance_of?(self.class) and
+          triangle.angles.values.to_set == angles.values.to_set
+    end
+
+    private
+
+    def carnot(side1, side2, side3)
+      cosine = Rational(
+          side2.length ** 2 + side3.length ** 2 - side1.length ** 2,
+          2 * side2.length * side3.length
+      )
+      Math.acos(cosine)
+    end
+
+    def validation(a, b, c)
+      Validator.same_points([a, b, c])
+      Validator.aligned_points([a, b, c])
+    end
+
+    def sides_length(triangle)
+      triangle.sides.values.collect(&:length).sort
+    end
+
+    def sides_congruent(precision)
+      sides_length(self).map {|side| side.round(precision)}.uniq.count
+    end
+
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cartesius
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Mauro Quaglia
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-01 00:00:00.000000000 Z
+date: 2018-01-05 00:00:00.000000000 Z
 dependencies: []
 description: The cartesian plan and its elements.
 email: mauroquaglia@libero.it
@@ -16,6 +16,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/cartesius/angle.rb
 - lib/cartesius/circumference.rb
 - lib/cartesius/ellipse.rb
 - lib/cartesius/hyperbola.rb
@@ -23,6 +24,7 @@ files:
 - lib/cartesius/parabola.rb
 - lib/cartesius/point.rb
 - lib/cartesius/segment.rb
+- lib/cartesius/triangle.rb
 homepage: https://github.com/MauroQuaglia/cartesius
 licenses:
 - MIT
@@ -35,7 +37,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.4.0
+      version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -43,7 +45,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.10
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: The cartesian coordinate system.