numerals 0.0.0 → 0.1.0

data/lib/numerals/conversions/float.rb

@@ -1,20 +1,16 @@
-require 'numerals/conversions'
-require 'flt/float'
+require 'numerals/conversions/context_conversion'
 
-class Numerals::FloatConversion
+class Numerals::FloatConversion < Numerals::ContextConversion
 
+  # Options:
+  #
+  # * :input_rounding (optional, a non-exact Rounding or rounding mode)
+  #   which is used when input is approximate as the assumed rounding
+  #   mode which would be used so that the result numeral rounds back
+  #   to the input number
+  #
   def initialize(options={})
-    @type = Float
-    @context = @type.context
-    options = { use_native_float: true }.merge(options)
-    @use_native_float = options[:use_native_float]
-    # @rounding_mode if used for :free numeral to number conversion
-    # and should be the implied rounding mode of the invers conversion
-    # (number to numeral);
-    # TODO: it should be possible to assign it for higher level
-    # formatting handling.
-    @rounding_mode = @context.rounding
-    @honor_rounding = true
+    super Float, options
   end
 
   def order_of_magnitude(value, options={})
@@ -26,6 +22,19 @@ class Numerals::FloatConversion
     end
   end
 
+  def number_of_digits(value, options={})
+    base = options[:base] || 10
+    if base == @context.radix
+      @context.precision
+    else
+      @context.necessary_digits(base)
+    end
+  end
+
+  def exact?(value, options={})
+    options[:exact]
+  end
+
   # mode is either :exact or :approximate
   def number_to_numeral(number, mode, rounding)
     if @context.special?(number)
@@ -49,70 +58,87 @@ class Numerals::FloatConversion
     end
   end
 
+  def write(number, exact_input, output_rounding)
+    output_base = output_rounding.base
+    input_base = @context.radix
+
+    if @context.special?(number)
+      special_float_to_numeral number
+    elsif exact_input
+      if output_base == input_base && output_rounding.free?
+        # akin to number.format(base: output_base, simplified: true)
+        general_float_to_numeral number, output_rounding, false
+      else
+        # akin to number.format(base: output_base, exact: true)
+        exact_float_to_numeral number, output_rounding
+      end
+    else
+      if output_base == input_base && output_rounding.preserving?
+        # akin to number.format(base: output_base)
+        sign, coefficient, exp = @context.split(number)
+        Numerals::Numeral.from_coefficient_scale(
+          sign*coefficient, exp,
+          approximate: true, base: output_base
+        )
+      elsif output_rounding.simplifying?
+        # akin to number.forma(base: output_base, simplify: true)
+        general_float_to_numeral number, output_rounding, false
+      else
+        # akin to number.forma(base: output_base, all_digits: true)
+        general_float_to_numeral number, output_rounding, true
+      end
+    end
+  end
+
+  def read(numeral, exact_input, approximate_simplified)
+    if numeral.special?
+      special_numeral_to_float numeral
+    # elsif numeral.approximate? && !exact_input
+    #   if approximate_simplified
+    #     # akin to @context.Num(numeral_text, :short)
+    #     short_numeral_to_float numeral
+    #   else
+    #     # akin to @context.Num(numeral_text, :free)
+    #     free_numeral_to_float numeral
+    #   end
+    else
+      # akin to @context.Num(numeral_text, :fixed)
+      fixed_numeral_to_float numeral
+    end
+  end
+
   private
 
   def special_float_to_numeral(x)
     if x.nan?
-      Numeral.nan
+      Numerals::Numeral.nan
     elsif x.infinite?
-      Numeral.infinity @context.sign(x)
+      Numerals::Numeral.infinity @context.sign(x)
     end
   end
 
   def exact_float_to_numeral(number, rounding)
     quotient = number.to_r
-    numeral = Numeral.from_quotient(quotient, base: rounding.base)
-    unless rounding.exact?
+    numeral = Numerals::Numeral.from_quotient(quotient, base: rounding.base)
+    unless rounding.free?
       numeral = rounding.round(numeral)
     end
     numeral
   end
 
   def approximate_float_to_numeral(number, rounding)
-    all_digits = !rounding.exact?
+    all_digits = !rounding.free?
     general_float_to_numeral(number, rounding, all_digits)
   end
 
-  # def fixed_float_to_numeral(number, rounding)
-  #   # adjust to rounding.precision
-  #   if rounding.exact?
-  #     # if simplify
-  #     #   number = @context.rationalize(simplify)
-  #     # end
-  #     exact_float_to_numeral number, rounding.base
-  #   else
-  #     if rounding.base == 10 && @use_native_float
-  #       native_float_to_numeral number, rounding
-  #     else
-  #       general_float_to_numeral number, rounding, true
-  #     end
-  #   end
-  # end
-
-  # def free_float_to_numeral(number, rounding)
-  #   # free mode ignores output precision (rounding) and
-  #   # produces the result based only on the number precision
-  #   rounding = Rounding[:exact, base: rounding.base]
-  #   general_float_to_numeral number, rounding, false
-  # end
-
-  def native_float_to_numeral(number, rounding)
-    need_to_round = (rounding.mode != @context.rounding)
-    n = need_to_round ? Float::DECIMAL_DIG : rounding.precision
-    txt = format("%.*e", n - 1, number)
-    numeral = text_to_numeral(txt, normalize: :approximate) # C-Locale text to numeral...
-    numeral = rounding.round(numeral) if need_to_round
-    numeral
-  end
-
   def general_float_to_numeral(x, rounding, all_digits)
-    sign, coefficient, exponent = x.split
-    precision = x.number_of_digits
+    sign, coefficient, exponent = @context.split(x)
+    precision = @context.precision
     output_base = rounding.base
 
-    # here rounding_mode should be not the output rounding mode, but the rounding mode used for input
-    # we'll assume rounding.mode will be used for input unless it is exact
-    rounding_mode = rounding.exact? ? @context.rounding : rounding.mode
+    # here rounding_mode is not the output rounding mode, but the rounding mode used for input
+    rounding_mode = (@input_rounding || rounding).mode
+
     formatter = Flt::Support::Formatter.new(
       @context.radix, @context.etiny, output_base, raise_on_repeat: false
     )
@@ -122,10 +148,14 @@ class Numerals::FloatConversion
 
     dec_pos, digits = formatter.digits
     rep_pos = formatter.repeat
-    numeral = Numeral[digits, sign: sign, point: dec_pos, rep_pos: rep_pos, base: output_base]
-    if all_digits
-      numeral = rounding.round(numeral, formatter.round_up)
-    end
+
+    normalization = :approximate
+
+    numeral = Numerals::Numeral[digits, sign: sign, point: dec_pos, rep_pos: rep_pos, base: output_base,
+                                normalize: normalization]
+
+    numeral = rounding.round(numeral, round_up: formatter.round_up)
+
     numeral
   end
 
@@ -139,8 +169,7 @@ class Numerals::FloatConversion
   end
 
   def fixed_numeral_to_float(numeral)
-    # consider:
-    # return exact_numeral_to_float(numeral) if numeral.exact?
+    return exact_numeral_to_float(numeral) if numeral.exact?
     if numeral.base == @context.radix
       same_base_numeral_to_float numeral
     else
@@ -148,9 +177,9 @@ class Numerals::FloatConversion
       # to a numeral preserving its value.
       representable_digits = @context.representable_digits(numeral.base)
       k = numeral.scale
-      if !@honor_rounding && numeral.digits.size <= representable_digits && k.abs <= representable_digits
+      if !@input_rounding && numeral.digits.size <= representable_digits && k.abs <= representable_digits
         representable_numeral_to_float numeral
-      elsif !@honor_rounding && (k > 0 && numeral.point < 2*representable_digits)
+      elsif !@input_rounding && (k > 0 && numeral.point < 2*representable_digits)
         near_representable_numeral_to_float numeral
       elsif numeral.base.modulo(@context.radix) == 0
         conmensurable_base_numeral_to_float numeral
@@ -172,6 +201,12 @@ class Numerals::FloatConversion
     general_numeral_to_float numeral, :free
   end
 
+  def short_numeral_to_float(numeral)
+    # raise "Invalid Conversion" # Float does not support short (arbitrary precision)
+    # fixed_numeral_to_float numeral
+    general_numeral_to_float numeral, :short
+  end
+
   def same_base_numeral_to_float(numeral)
     sign, coefficient, scale = numeral.split
     @context.Num(sign, coefficient, scale)
@@ -203,10 +238,10 @@ class Numerals::FloatConversion
   def general_numeral_to_float(numeral, mode)
     sign, coefficient, scale = numeral.split
     reader = Flt::Support::Reader.new(mode: mode)
-    if mode == :fixed
-      rounding_mode = @context.rounding
+    if @input_rounding
+      rounding_mode = @input_rounding.mode
     else
-      rounding_mode = @rounding_mode
+       rounding_Mode = @context.rounding
     end
     reader.read(@context, rounding_mode, sign, coefficient, scale, numeral.base).tap do
       # @exact = reader.exact?
@@ -215,12 +250,12 @@ class Numerals::FloatConversion
 
 end
 
-def Float.numerals_conversion
-  Numerals::FloatConversion.new
+def Float.numerals_conversion(options = {})
+  Numerals::FloatConversion.new(options)
 end
 
 class <<Float.context
-  def numerals_conversion
-    Numerals::FloatConversion.new
+  def numerals_conversion(options = {})
+    Numerals::FloatConversion.new(options)
   end
 end

data/lib/numerals/conversions/flt.rb

@@ -1,28 +1,20 @@
-require 'numerals/conversions'
-require 'flt'
-
-class Numerals::FltConversion
-
-  def initialize(context_or_type)
-    if Class === context_or_type && context_or_type < Flt::Num
-      @type = context_or_type
-      @context = @type.context
-    elsif Flt::Num::ContextBase === context_or_type
-      @context = context_or_type
-      @type = @context.num_class
-    else
-      raise "Invalid FltConversion definition"
-    end
-    # @rounding_mode if used for :free numeral to number conversion
-    # and should be the implied rounding mode of the invers conversion
-    # (number to numeral);
-    # TODO: it should be possible to assign it for higher level
-    # formatting handling.
-    @rounding_mode = @context.rounding
+require 'numerals/conversions/context_conversion'
+
+class Numerals::FltConversion < Numerals::ContextConversion
+
+  # Options:
+  #
+  # * :input_rounding (optional, a non-exact Rounding or rounding mode)
+  #   which is used when input is approximate as the assumed rounding
+  #   mode which would be used so that the result numeral rounds back
+  #   to the input number. :context can be used to use the
+  #   numeric context as input rounding.
+  #   input_rounding is also used to round input ...
+  #
+  def initialize(context_or_type, options={})
+    super
   end
 
-  attr_reader :context, :type
-
   def order_of_magnitude(value, options={})
     base = options[:base] || 10 # value.num_class.radix
     if value.class.radix == base
@@ -32,6 +24,19 @@ class Numerals::FltConversion
     end
   end
 
+  def number_of_digits(value, options={})
+    base = options[:base] || 10
+    if base == @context.radix
+      value.number_of_digits
+    else
+      x.class.context[precision: value.number_of_digits].necessary_digits(base)
+    end
+  end
+
+  def exact?(value, options={})
+    options[:exact]
+  end
+
   # mode is either :exact or :approximate
   def number_to_numeral(number, mode, rounding)
     if number.special? # @context.special?(number)
@@ -55,6 +60,54 @@ class Numerals::FltConversion
     end
   end
 
+  def write(number, exact_input, output_rounding)
+    output_base = output_rounding.base
+    input_base = @context.radix
+
+    if number.special? # @context.special?(number)
+      special_num_to_numeral number
+    elsif exact_input
+      if output_base == input_base && output_rounding.free?
+        # akin to number.format(base: output_base, simplified: true)
+        general_num_to_numeral number, output_rounding, false
+      else
+        # akin to number.format(base: output_base, exact: true)
+        exact_num_to_numeral number, output_rounding
+      end
+    else
+      if output_base == input_base && output_rounding.preserving?
+        # akin to number.format(base: output_base)
+        Numeral.from_coefficient_scale(
+          number.sign*number.coefficient, number.integral_exponent,
+          approximate: true, base: output_base
+        )
+      elsif output_rounding.simplifying?
+        # akin to number.forma(base: output_base, simplify: true)
+        general_num_to_numeral number, output_rounding, false
+      else
+        # akin to number.forma(base: output_base, all_digits: true)
+        general_num_to_numeral number, output_rounding, true
+      end
+    end
+  end
+
+  def read(numeral, exact_input, approximate_simplified)
+    if numeral.special?
+      special_numeral_to_num numeral
+    elsif numeral.approximate? && !exact_input
+      if approximate_simplified
+        # akin to @context.Num(numeral_text, :short)
+        short_numeral_to_num numeral
+      else
+        # akin to @context.Num(numeral_text, :free)
+        free_numeral_to_num numeral
+      end
+    else
+      # akin to @context.Num(numeral_text, :fixed)
+      fixed_numeral_to_num numeral
+    end
+  end
+
   private
 
   def special_num_to_numeral(x)
@@ -67,26 +120,26 @@ class Numerals::FltConversion
 
   def exact_num_to_numeral(number, rounding)
     quotient = number.to_r
-    numeral = Numeral.from_quotient(quotient, base: rounding.base)
-    unless rounding.exact?
+    numeral = Numerals::Numeral.from_quotient(quotient, base: rounding.base)
+    unless rounding.free?
       numeral = rounding.round(numeral)
     end
     numeral
   end
 
   def approximate_num_to_numeral(number, rounding)
-    all_digits = !rounding.exact?
+    all_digits = !rounding.free?
     general_num_to_numeral(number, rounding, all_digits)
   end
 
   def general_num_to_numeral(x, rounding, all_digits)
-    sign, coefficient, exponent = x.split
+    sign, coefficient, exponent = x.split # @context.split(x)
     precision = x.number_of_digits
     output_base = rounding.base
 
-    # here rounding_mode should be not the output rounding mode, but the rounding mode used for input
-    # we'll assume rounding.mode will be used for input unless it is exact
-    rounding_mode = rounding.exact? ? @context.rounding : rounding.mode
+    # here rounding_mode is not the output rounding mode, but the rounding mode used for input
+    rounding_mode = (@input_rounding || rounding).mode
+
     formatter = Flt::Support::Formatter.new(
       @context.radix, @context.etiny, output_base, raise_on_repeat: false
     )
@@ -96,10 +149,13 @@ class Numerals::FltConversion
 
     dec_pos, digits = formatter.digits
     rep_pos = formatter.repeat
-    numeral = Numeral[digits, sign: sign, point: dec_pos, rep_pos: formatter.repeat, base: output_base]
-    if all_digits
-      numeral = rounding.round(numeral, formatter.round_up)
-    end
+
+    normalization = :approximate
+
+    numeral = Numerals::Numeral[digits, sign: sign, point: dec_pos, rep_pos: formatter.repeat, base: output_base, normalize: normalization]
+
+    numeral = rounding.round(numeral, round_up: formatter.round_up)
+
     numeral
   end
 
@@ -116,10 +172,17 @@ class Numerals::FltConversion
     # consider:
     # return exact_numeral_to_num(numeral) if numeral.exact?
     if numeral.base == @context.radix
-      numeral = numeral.approximate(@context.precision) unless @context.exact?
+      unless @context.exact?
+        rounding = Rounding[@context.rounding, precision: @context.precision, base: @context.radix]
+        numeral = rounding.round(numeral)
+      end
       same_base_numeral_to_num numeral
     else
-      general_numeral_to_num numeral, :fixed
+      if numeral.repeating? # numeral.exact?
+        exact_numeral_to_num(numeral)
+      else
+        general_numeral_to_num numeral, :fixed
+      end
     end
   end
 
@@ -133,16 +196,24 @@ class Numerals::FltConversion
   end
 
   def free_numeral_to_num(numeral)
-    general_numeral_to_num numeral, :free
+    if numeral.base == @context.radix
+      same_base_numeral_to_num numeral
+    else
+      general_numeral_to_num numeral, :free
+    end
+  end
+
+  def short_numeral_to_num(numeral)
+    general_numeral_to_num numeral, :short
   end
 
   def general_numeral_to_num(numeral, mode)
     sign, coefficient, scale = numeral.split
     reader = Flt::Support::Reader.new(mode: mode)
-    if mode == :fixed
-      rounding_mode = @context.rounding
+    if @input_rounding
+      rounding_mode = @input_rounding.mode
     else
-      rounding_mode = @rounding_mode
+       rounding_Mode = @context.rounding
     end
     reader.read(@context, rounding_mode, sign, coefficient, scale, numeral.base).tap do
       # @exact = reader.exact?
@@ -151,12 +222,12 @@ class Numerals::FltConversion
 
 end
 
-def (Flt::Num).numerals_conversion
-  Numerals::FltConversion.new(self)
+def (Flt::Num).numerals_conversion(options = {})
+  Numerals::FltConversion.new(self, options)
 end
 
 class Flt::Num::ContextBase
-  def numerals_conversion
-    Numerals::FltConversion.new(self)
+  def numerals_conversion(options = {})
+    Numerals::FltConversion.new(self, options)
   end
 end

data/lib/numerals/conversions/integer.rb

@@ -8,6 +8,10 @@ class Numerals::IntegerConversion
   class InvalidConversion < RuntimeError
   end
 
+  def type
+    Integer
+  end
+
   def order_of_magnitude(value, options={})
     base = options[:base] || 10
     if base == 2 && value.respond_to?(:bit_length)
@@ -17,10 +21,19 @@ class Numerals::IntegerConversion
     end
   end
 
+  def number_of_digits(value, options={})
+    # order_of_magnitude(value, options)
+    0 # this is needed only for non-exact values
+  end
+
+  def exact?(value, options={})
+    true
+  end
+
   def number_to_numeral(number, mode, rounding)
     # Rational.numerals_conversion Rational(number), mode, rounding
-    numeral = Numeral.from_quotient(number, 1)
-    numeral = rounding.round(numeral) unless rounding.exact?
+    numeral = Numerals::Numeral.from_quotient(number, 1)
+    numeral = rounding.round(numeral) # unless rounding.free?
     numeral
   end
 
@@ -32,8 +45,24 @@ class Numerals::IntegerConversion
     rational.numerator
   end
 
+  def write(number, exact_input, output_rounding)
+    output_base = output_rounding.base
+    numeral = Numerals::Numeral.from_quotient(number, 1, base: output_base)
+    numeral = output_rounding.round(numeral) # unless output_rounding.free?
+    numeral
+  end
+
+  def read(numeral, exact_input, approximate_simplified)
+    rational = Rational.numerals_conversion.read numeral, exact_input, approximate_simplified
+    if rational.denominator != 1
+      raise InvalidConversion, "Invalid numeral to rational conversion"
+    end
+    rational.numerator
+  end
+
+
 end
 
-def Integer.numerals_conversion
+def Integer.numerals_conversion(options = {})
   Numerals::IntegerConversion.instance
 end

data/lib/numerals/conversions/rational.rb

@@ -5,6 +5,10 @@ class Numerals::RationalConversion
 
   include Singleton
 
+  def type
+    Rational
+  end
+
   def order_of_magnitude(value, options={})
     base = options[:base] || 10
     if base == 10
@@ -14,10 +18,18 @@ class Numerals::RationalConversion
     end
   end
 
+  def number_of_digits(value, options={})
+    return 0 # this is needed only for non-exact values
+  end
+
+  def exact?(value, options={})
+    true
+  end
+
   def number_to_numeral(number, mode, rounding)
     q = [number.numerator, number.denominator]
-    numeral = Numeral.from_quotient(q)
-    numeral = rounding.round(numeral) unless rounding.exact?
+    numeral = Numerals::Numeral.from_quotient(q)
+    numeral = rounding.round(numeral) # unless rounding.free?
     numeral
   end
 
@@ -25,8 +37,20 @@ class Numerals::RationalConversion
     Rational(*numeral.to_quotient)
   end
 
+  def write(number, exact_input, output_rounding)
+    output_base = output_rounding.base
+    q = [number.numerator, number.denominator]
+    numeral = Numerals::Numeral.from_quotient(q, base: output_base)
+    numeral = output_rounding.round(numeral) # unless output_rounding.free?
+    numeral
+  end
+
+  def read(numeral, exact_input, approximate_simplified)
+    Rational(*numeral.to_quotient)
+  end
+
 end
 
-def Rational.numerals_conversion
+def Rational.numerals_conversion(options = {})
   Numerals::RationalConversion.instance
 end