fractify 1.0.0

data/lib/fractify/fraction.rb

@@ -0,0 +1,683 @@
+# frozen_string_literal: true
+
+module Fractify
+  class DividingByZeroError < StandardError; end
+  class IncorrectArgumentsError < StandardError; end
+  class IncorrectStringSyntax < StandardError; end
+  class Fraction
+    attr_accessor :whole_part, :numerator, :denominator, :negative
+
+    def initialize(whole_part: 0, numerator: 0, denominator: 1, string: '', number: false)
+      unless string.strip.empty?
+        to_zero!
+        parse_fraction_string!(string)
+        return
+      end
+
+      if number.is_a? Numeric
+        convert_number!(number)
+        return
+      end
+      raise DividingByZeroError if denominator.zero? && numerator != 0
+
+      @whole_part = whole_part
+      self.numerator = numerator
+      self.denominator = denominator
+      self.negative = false
+
+      simplify!
+    end
+
+    def negative?
+      negative
+    end
+
+    def zero?
+      return true if numerator.zero?
+
+      false
+    end
+
+    def one?
+      return true if numerator == 1 && denominator == 1 && whole_part.zero?
+
+      false
+    end
+
+    def simplify!
+      fix_negativity!
+      if !zero?
+        greatest_common_divisor = self.class.greatest_common_divisor(numerator, denominator)
+
+        @denominator /= greatest_common_divisor
+        @numerator /= greatest_common_divisor
+
+        if denominator == 1 && numerator != 1
+          @whole_part += numerator
+          @numerator = 1
+        elsif numerator > denominator
+          new_whole_part = numerator / denominator
+          @whole_part += new_whole_part
+          @numerator %= denominator
+        end
+      else
+        @negative = false
+      end
+    end
+
+    def puts
+      puts to_s
+    end
+
+    def to_zero!
+      @whole_part = 0
+      @numerator = 0
+      @denominator = 1
+      @negative = false
+    end
+
+    def to_improper!
+      return if whole_part.zero?
+
+      simplify!
+      @numerator -= 1 if numerator == 1 && denominator == 1
+      @numerator += whole_part * denominator
+      @whole_part = 0
+    end
+
+    def to_f
+      return 0.0 if zero?
+
+      fraction = dup
+      fraction.to_improper!
+      fraction.minus_to_numerator!
+
+      fraction.numerator.to_f / fraction.denominator
+    end
+
+    def to_i
+      return 0 if zero?
+
+      fraction = dup
+      fraction.simplify!
+
+      result = whole_part
+      result = -result if fraction.negative?
+
+      result
+    end
+
+    def to_s
+      fraction_string = '('
+      fraction_string += '-' if negative?
+
+      if zero?
+        fraction_string += '0'
+      elsif one?
+        fraction_string += '1'
+      else
+        fraction_string += whole_part.to_s if whole_part != 0
+        if numerator != 1 || denominator != 1
+          fraction_string += ' ' if whole_part != 0
+          fraction_string += numerator.to_s + '/' + denominator.to_s
+        end
+      end
+
+      fraction_string + ')'
+    end
+
+    def -(other)
+      fraction = dup
+      object = other.dup
+      if zero?
+        fraction.whole_part = object.whole_part
+        fraction.numerator = object.numerator
+        fraction.denominator = object.denominator
+        fraction.negative = !object.negative
+      else
+        fraction.to_common_denominator!(object) unless object.zero?
+
+        fraction.minus_to_numerator!
+        object.minus_to_numerator!
+
+        fraction.numerator -= object.numerator
+        fraction.minus_to_negative_field!
+        fraction.simplify!
+      end
+
+      fraction
+    end
+
+    def +(other)
+      fraction = dup
+      object = other.dup
+      if zero?
+        fraction.whole_part = object.whole_part
+        fraction.numerator = object.numerator
+        fraction.denominator = object.denominator
+        fraction.negative = object.negative
+      else
+        fraction.to_common_denominator!(object) unless object.zero?
+
+        fraction.minus_to_numerator!
+        object.minus_to_numerator!
+
+        fraction.numerator += object.numerator
+        fraction.minus_to_negative_field!
+        fraction.simplify!
+      end
+
+      fraction
+    end
+
+    def *(other)
+      fraction = dup
+      object = other.dup
+
+      fraction.to_improper!
+      object.to_improper!
+
+      negative_counter = 0
+      negative_counter += 1 if fraction.negative?
+      negative_counter += 1 if object.negative?
+      fraction.negative = negative_counter.even? ? false : true
+
+      fraction.numerator *= object.numerator
+      fraction.denominator *= object.denominator
+
+      fraction.simplify!
+
+      fraction.whole_part = 1 if fraction.zero?
+
+      fraction
+    end
+
+    def /(other)
+      fraction = dup
+      object = other.dup
+
+      object.to_reciprocal!
+      fraction *= object
+
+      fraction
+    end
+
+    def **(other)
+      if other.is_a? Numeric
+        power(other)
+      elsif other.is_a? Fractify::Fraction
+        x = other.to_f
+        power(x)
+      else
+        raise IncorrectArgumentsError
+      end
+    end
+
+    def self.valid?(string)
+      return false unless string.is_a? String
+
+      validate_fraction_string(string)
+    end
+
+    def self.floating_point_part(number)
+      raise IncorrectArgumentsError unless number.is_a? Numeric
+
+      result = '0.'
+      number_string = number.to_s
+      past_decimal_separator = false
+
+      number_string.each_char do |c|
+        if past_decimal_separator
+          result += c
+        elsif c == '.'
+          past_decimal_separator = true
+        end
+      end
+
+      result.to_f
+    end
+
+    def self.least_common_multiple(first, second)
+      raise IncorrectArgumentsError unless first.is_a?(Numeric) && second.is_a?(Numeric)
+
+      (first * second) / greatest_common_divisor(first, second)
+    end
+
+    def self.greatest_common_divisor(first, second)
+      first = first.abs
+      second = second.abs
+
+      while first != second
+        if first > second
+          first -= second
+        else
+          second -= first
+        end
+      end
+
+      first
+    end
+
+    def self.numeric?(char)
+      char =~ /[[:digit:]]/
+    end
+
+    def self.letter?(char)
+      char =~ /[[:alpha:]]/
+    end
+
+    def self.validate_fraction_string(string)
+      is_float = false
+      string.each_char do |c|
+        if c == '.'
+          is_float = true
+          break
+        end
+      end
+
+      if is_float
+        validate_float_string(string)
+      else
+        validate_string(string)
+      end
+    end
+
+    def self.validate_string(string)
+      stage = 0
+      open_bracket, incorrect_syntax, at_end, digit_present = false
+      minus_is_free = true
+
+      string.each_char do |c|
+        if at_end || letter?(c)
+          incorrect_syntax = true
+          break
+        end
+
+        if open_bracket
+          if stage.zero?
+            if c == '-' && minus_is_free
+              minus_is_free = false
+            elsif numeric?(c)
+              digit_present = true
+            elsif c == ' ' && digit_present
+              stage = 1
+              minus_is_free = true
+              digit_present = false
+            elsif c == '/' && digit_present
+              stage = 2
+              minus_is_free = true
+              digit_present = false
+            elsif c == ')' && digit_present
+            else
+              incorrect_syntax = true
+              break
+            end
+          elsif stage == 1
+            if c == '-' && minus_is_free
+              minus_is_free = false
+            elsif numeric?(c)
+              digit_present = true
+            elsif c == '/' && digit_present
+              stage = 2
+              minus_is_free = true
+              digit_present
+            else
+              incorrect_syntax = true
+              break
+            end
+          elsif stage == 2
+            if c == '-' && minus_is_free
+              minus_is_free = false
+            elsif numeric?(c)
+              digit_present = true
+            elsif c == ')' && digit_present
+            else
+              incorrect_syntax = true
+              break
+            end
+          end
+        end
+
+        if c == '('
+          if open_bracket
+            incorrect_syntax = true
+            break
+          end
+          open_bracket = true
+        elsif c == ')'
+          unless open_bracket
+            incorrect_syntax = true
+            break
+          end
+          open_bracket = false
+          at_end = true
+        end
+      end
+
+      incorrect_syntax = true if open_bracket
+
+      !incorrect_syntax
+    end
+
+    def self.validate_float_string(string)
+      open_bracket, incorrect_syntax, at_end, digit_present,
+      floating_point_present = false
+      minus_is_free = true
+
+      string.each_char do |c|
+        if at_end || letter?(c)
+          incorrect_syntax = true
+          break
+        end
+
+        if open_bracket
+          if c == '-'
+            if !minus_is_free || digit_present
+              incorrect_syntax = true
+              break
+            end
+            minus_is_free = false
+          elsif numeric?(c)
+            digit_present = true
+          elsif c == '.'
+            if floating_point_present || !digit_present
+              incorrect_syntax = true
+              break
+            end
+            floating_point_present = true
+          elsif c == ')'
+            open_bracket = false
+            at_end = true
+          else
+            incorrect_syntax = true
+            break
+          end
+        elsif c == '('
+          open_bracket = true
+        else
+          incorrect_syntax = true
+          break
+        end
+      end
+
+      incorrect_syntax = true if open_bracket
+
+      !incorrect_syntax
+    end
+
+    def to_common_denominator!(other)
+      to_improper!
+      other.to_improper!
+
+      least_common_multiple = self.class.least_common_multiple(denominator, other.denominator)
+
+      numerator_multiplication = least_common_multiple / denominator
+      @numerator *= numerator_multiplication
+      @denominator = least_common_multiple
+
+      numerator_multiplication = least_common_multiple / other.denominator
+      other.numerator *= numerator_multiplication
+      other.denominator = least_common_multiple
+    end
+
+    def to_reciprocal!
+      to_improper!
+      aux = denominator
+      @denominator = numerator
+      @numerator = aux
+    end
+
+    protected
+
+    def minus_to_numerator!
+      return unless negative
+
+      @negative = false
+      @numerator = -numerator
+    end
+
+    def minus_to_negative_field!
+      return unless numerator.negative?
+
+      @negative = true
+      @numerator = numerator.abs
+    end
+
+    private
+
+    def power(x)
+      fraction = dup
+      fraction.negative = false if x % 2 == 0
+
+      if x.negative?
+        fraction.to_reciprocal!
+        x = x.abs
+      else
+        fraction.to_improper!
+      end
+
+      if x == x.to_i
+        fraction.numerator **= x.to_i
+        fraction.denominator **= x.to_i
+        fraction.simplify!
+      else
+        float = fraction.to_f.abs
+        float **= x
+        float = -float if fraction.negative?
+        fraction = Fractify::Fraction.new(number: float)
+      end
+
+      fraction
+    end
+
+    def fix_negativity!
+      @negative = !negative if arguments_make_negative?
+
+      @whole_part = whole_part.abs
+      @numerator = numerator.abs
+      @denominator = denominator.abs
+    end
+
+    def arguments_make_negative?
+      negative_attributes = 0
+      %w[whole_part numerator denominator].each do |a|
+        negative_attributes += 1 if send(a).negative?
+      end
+      return true if negative_attributes.odd?
+
+      false
+    end
+
+    def parse_fraction_string!(string)
+      is_float = false
+      string.each_char do |c|
+        if c == '.'
+          is_float = true
+          break
+        end
+      end
+
+      if is_float
+        parse_float_string!(string)
+      else
+        parse_string!(string)
+      end
+    end
+
+    def parse_string!(string)
+      stage = 0
+      number_string = ''
+
+      open_bracket, incorrect_syntax, at_end, digit_present = false
+
+      minus_is_free = true
+
+      string.each_char do |c|
+        if at_end || self.class.letter?(c)
+          incorrect_syntax = true
+          break
+        end
+
+        if open_bracket
+          if stage.zero?
+            if c == '-' && minus_is_free
+              @negative = true
+              minus_is_free = false
+            elsif self.class.numeric?(c)
+              number_string += c
+              digit_present = true
+            elsif c == ' ' && digit_present
+              stage = 1
+              @whole_part = number_string.to_i
+              number_string = ''
+              minus_is_free = true
+              digit_present = false
+            elsif c == '/' && digit_present
+              stage = 2
+              @numerator = number_string.to_i
+              number_string = ''
+              minus_is_free = true
+              digit_present = false
+            elsif c == ')' && digit_present
+              @numerator = number_string.to_i
+              @denominator = 1
+            else
+              incorrect_syntax = true
+              break
+            end
+          elsif stage == 1
+            if c == '-' && minus_is_free
+              @negative = !negative
+              minus_is_free = false
+            elsif self.class.numeric?(c)
+              number_string += c
+              digit_present = true
+            elsif c == '/' && digit_present
+              stage = 2
+              @numerator = number_string.to_i
+              number_string = ''
+              minus_is_free = true
+              digit_present
+            else
+              incorrect_syntax = true
+              break
+            end
+          elsif stage == 2
+            if c == '-' && minus_is_free
+              @negative = !negative
+              minus_is_free = false
+            elsif self.class.numeric?(c)
+              number_string += c
+              digit_present = true
+            elsif c == ')' && digit_present
+              @denominator = number_string.to_i
+            else
+              incorrect_syntax = true
+              break
+            end
+          end
+        end
+
+        if c == '('
+          if open_bracket
+            incorrect_syntax = true
+            break
+          end
+          open_bracket = true
+        elsif c == ')'
+          unless open_bracket
+            incorrect_syntax = true
+            break
+          end
+          open_bracket = false
+          at_end = true
+        end
+      end
+
+      raise IncorrectStringSyntax if incorrect_syntax || open_bracket
+
+      simplify!
+    end
+
+    def parse_float_string!(string)
+      number_string = ''
+      open_bracket, incorrect_syntax, at_end, digit_present,
+      floating_point_present = false
+
+      minus_is_free = true
+
+      string.each_char do |c|
+        if at_end || self.class.letter?(c)
+          incorrect_syntax = true
+          break
+        end
+
+        if open_bracket
+          if c == '-'
+            if !minus_is_free || digit_present
+              incorrect_syntax = true
+              break
+            end
+            minus_is_free = false
+            number_string += c
+          elsif self.class.numeric?(c)
+            digit_present = true
+            number_string += c
+          elsif c == '.'
+            if floating_point_present || !digit_present
+              incorrect_syntax = true
+              break
+            end
+            floating_point_present = true
+            number_string += c
+          elsif c == ')'
+            open_bracket = false
+            at_end = true
+          else
+            incorrect_syntax = true
+            break
+          end
+        elsif c == '('
+          open_bracket = true
+        else
+          incorrect_syntax = true
+          break
+        end
+      end
+
+      raise IncorrectStringSyntax if open_bracket || incorrect_syntax
+
+      convert_number!(number_string.to_f)
+    end
+
+    def convert_number!(number)
+      if number.zero?
+        to_zero!
+        return
+      end
+
+      if number.negative?
+        number = number.abs
+        @negative = true
+      end
+
+      @whole_part = number.to_i
+      new_denominator = 1
+      floating_point_part = self.class.floating_point_part(number)
+
+      while floating_point_part.positive?
+        floating_point_part *= new_denominator
+        floating_point_part = self.class.floating_point_part(floating_point_part)
+        new_denominator *= 10
+      end
+
+      @numerator = self.class.floating_point_part(number) * new_denominator
+      @numerator = numerator.to_i
+      @denominator = new_denominator
+
+      @numerator = 1 if numerator.zero?
+
+      simplify!
+    end
+  end
+end

data/lib/fractify/operator.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Fractify
+  class IncorrectArgumentsError < StandardError; end
+  class Operator
+    attr_accessor :operator_character, :rank, :executed, :to_left, :to_right
+
+    def initialize(operator_character, rank, to_left = nil, to_right = nil)
+      if to_left && !to_left.is_a?(Fractify::Fraction) || to_right && !to_right.is_a?(Fractify::Fraction)
+        raise IncorrectArgumentsError
+      end
+
+      self.operator_character = operator_character
+      self.rank = rank
+      self.to_left = to_left
+      self.to_right = to_right
+      self.executed = false
+    end
+
+    def <=>(other)
+      raise IncorrectArgumentsError unless other.is_a? Fractify::Operator
+      return 0 if rank == other.rank
+      return 1 if rank > other.rank
+
+      -1
+    end
+
+    def to_s
+      "(#{operator_character}, #{rank})"
+    end
+
+    def decrease_rank!(number = 1)
+      @rank -= number
+    end
+
+    def increase_rank!(number = 1)
+      @rank += number
+    end
+
+    def executed!
+      self.executed = true
+    end
+
+    def executed?
+      executed
+    end
+
+    def not_executed?
+      !executed
+    end
+  end
+end