numerals 0.0.0 → 0.1.0

data/lib/numerals/numeral.rb

@@ -22,15 +22,15 @@ module Numerals
   #
   # A Numeral is equivalent to a Rational number; a quotient of integers
   # can be converted to a Numeral in any base and back to a quotient without
-  # altering its value (though the fraction might be simplified).
+  # altering its value (although the fraction might be simplified).
   #
   # By default a Numeral represents an exact quantity (rational number).
-  # A numeral can alo represent an approximate value given with a certain
-  # precision, the number of significant digits (numeral.digits.size)
+  # A numeral can also represent an approximate value with a specific
+  # precision: the number of significant digits (numeral.digits.size),
   # which can include significant trailing zeros. Approximate numerals
   # are never repeating.
   #
-  # Exact numerals are always repeating, but when the repeating digits are
+  # Exact numerals are always repeating, but, when the repeating digits are
   # just zeros, the repeating? method returns false.
   #
   class Numeral
@@ -44,24 +44,25 @@ module Numerals
     def self.maximum_number_of_digits=(n)
       @maximum_number_of_digits = [n, 2048].max
     end
+
     # Return the maximum number of digits that Numeral objects
     # can handle.
     def self.maximum_number_of_digits
       @maximum_number_of_digits
     end
 
-    # Special nomerals may be contructed with the symbols :nan, :infinity,
-    # :negative_infinity, :positive_infinity. Or also with :infinity and the
-    # :sign option which should be either +1 or -1:
+    # Special numerals may be constructed with the symbols :nan, :infinity,
+    # :negative_infinity, :positive_infinity (or with :infinity and the
+    # :sign option which should be either +1 or -1)
     #
     # Examples:
     #
     #   Numeral[:nan]
     #   Numeral[:infinity, sign: -1]
     #
-    # For nonspecial numerals, the first argument may be a Digits object or
-    # an Array of digits, and the rest parameters (:base, :sign, :point and
-    # :repeat) are passed as options.
+    # For non-special numerals, the first argument may be a Digits object or
+    # an Array of digits, and the remaining parameters (:base, :sign, :point
+    # and :repeat) are passed as options.
     #
     # Examples:
     #
@@ -69,10 +70,10 @@ module Numerals
     #   Numeral[1,2,3,4, point: 1, repeat: 2] # 1.234343434...
     #
     # The :normalize option can be used to specify the kind of normalization
-    # applied to the numeral:
+    # to be applied to the numeral:
     #
-    # * :exact, the default produces a normalized :exact number,
-    #   where no trailing zeros are kept and there are always a repeat point
+    # * :exact, the default, produces a normalized :exact number
+    #   where no trailing zeros are kept and there is always a repeat point
     #   (which may just repeat trailing zeros)
     # * :approximate produces a non-repeating numeral with a fixed number of
     #   digits (where trailing zeros are significant)
@@ -213,7 +214,8 @@ module Numerals
       else
         repeated_length = @digits.size - @repeat
         i = (i - @repeat) % repeated_length
-        @digits[i + @repeat]
+        i += @repeat
+        i < 0 ? 0 : @digits[i]
       end
     end
 
@@ -249,6 +251,16 @@ module Numerals
               @digits.replace @digits[0...-rep_length]
             end
           end
+          # remove unneeded partial repetitions
+          if rep_length > 0 && @digits.size > rep_length
+            removed = 0
+            while @repeat > 0 && @digits[@repeat-1] == @digits[@repeat-1+rep_length]
+              @repeat -= 1
+              removed += 1
+            end
+            @digits.replace @digits[0...-removed] if removed > 0
+          end
+
         end
 
         # Replace 'nines' repetition 0.999... -> 1
@@ -313,7 +325,6 @@ module Numerals
           end
         end
       end
-
       self
     end
 
@@ -383,9 +394,10 @@ module Numerals
       Numeral[digits, sign: sign]
     end
 
-    # Create a Numeral from a quotient (Rational number)
-    # The quotient can be passed as an Array, so that fractions with a zero denominator
-    # can be handled (represented indefinite or infinite numbers).
+    # Create a Numeral from a quotient (Rational number).
+    # The quotient can be passed as an Array [numerator, denomnator];
+    # to allow fractions with a zero denominator
+    # (representing indefinite or infinite numbers).
     def self.from_quotient(*args)
       r = args.shift
       if Integer === args.first
@@ -451,7 +463,7 @@ module Numerals
 
     # Return a quotient (Rational) that represents the exact value of the numeral.
     # The quotient is returned as an Array, so that fractions with a zero denominator
-    # can be handled (represented indefinite or infinite numbers).
+    # can be handled (representing indefinite or infinite numbers).
     def to_quotient
       if @special
         y = 0
@@ -503,7 +515,7 @@ module Numerals
       else
         sign = +1
       end
-      digits = Digits[radix]
+      digits = Digits[base: radix]
       digits.value = coefficient
       point = scale + digits.size
       normalization = options[:normalize] || :exact
@@ -564,6 +576,7 @@ module Numerals
           'Numeral[:inf]'
         end
       else
+        args = ''
         if @digits.size > 0
           args = @digits.digits_array.to_s.unwrap('[]')
           args << ', '
@@ -581,7 +594,7 @@ module Numerals
     end
 
     # An exact Numeral represents exactly a rational number.
-    # It always has a repeat position, althugh the repeated digits
+    # It always has a repeat position, although the repeated digits
     # may all be zero.
     def exact?
       !!@repeat

data/lib/numerals/repeat_detector.rb

@@ -0,0 +1,99 @@
+module RepeatDetector
+
+  # detec digitss repetitions
+  def self.detect(digits, min_repetitions=1)
+    n = min_repetitions + 1
+    for l in 1..(digits.size/n)
+      l = digits.size/n + 1 - l
+      # l loops from digits.size/n to 1
+      # l is the length of the trailing repetition to be check
+      # the longest possible repetition to occur at least n times
+      # is 1/n of the digits,
+      # and the shortest is 1 digit long.
+      # Longest repetitions are found first.
+
+      # check the last l digits for n repetitions
+      repeating = true
+      (2..n).each do |i|
+        if digits[-l..-1] != digits[-i*l...-(i-1)*l]
+          repeating = false
+          break
+        end
+      end
+
+      if repeating
+        # found n-1 repetitions of length l;
+        # remove them:
+        digits = digits[0...-(n-1)*l]
+        # keap index of repetition beginning
+        repeat = digits.size - l
+
+        # now iterate over the divisors of l
+        # to find sub-repetitions
+        for m in 1..l
+          if l.modulo(m) == 0
+            # m is a divisor of l
+            # check if the l-digit repeating sequence
+            # is composed of m-digit sub-repetitions
+            reduce_l = true
+            for i in 2..l/m
+              if digits[-m..-1] != digits[-i*m...-i*m+m]
+                reduce_l = false
+                break
+              end
+            end
+            if reduce_l
+              # found an m-digit sub-repetition
+              l = m
+              repeat = digits.size - l
+              break
+            end
+          end
+        end
+
+        # now remove innecesary repetitions
+        while digits.size >= 2*l && digits[-l..-1] == digits[-2*l...-l]
+          repeat -= l
+          digits = digits[0...-l]
+        end
+
+        break
+      end
+    end
+
+    if repeat
+      # remove zero repetition
+      if digits.size == repeat+1 && digits[repeat]==0
+        repeat = nil
+        digits.pop
+      end
+    end
+    # and remove trailing zeros that may be exposed
+    # TODO: review: this may not be needed
+    digits.pop while digits[-1]==0 && !digits.empty?
+
+    [digits, repeat]
+  end
+
+  # Compute the miniumum number of times the repeated part must
+  # apper in a digit sequence so that it is correctly detected
+  # with detect_min_rep repeatitions
+  def self.min_repeat_count(digits, repeat, detect_min_rep=1)
+    if repeat
+      n = detect_min_rep
+      loop do
+        n += 1
+        detected_digits, detected_repeat = detect(
+          digits + digits[repeat..-1]*(n-1), detect_min_rep
+        )
+        if repeat == detected_repeat # && detected_digits == digits
+          break
+        end
+      end
+      n
+    else
+      0
+    end
+  end
+
+end