numerals 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 20e32ed4a377f88140d75db5dce2070dceca3b30
+  data.tar.gz: 835f3416de372cf7fa26f2607b74176b666d88b5
+SHA512:
+  metadata.gz: a97323fa538d4e1fe2cc9c57b5fc9bc2e09dcf67260b8a74828be88415d7672efb6f314eefa6e23f41542d739bc291cf0c3f36c8b446eaf82c359b8beb0a7e7a
+  data.tar.gz: e894386209dbfbc2e3471a00cf866a39e320a99a00e8f6c467dfa4c3947a87eac6797409036efe4c6446041dbb9d8ad4a1dfeb83a7d8a3ae5522932d5a81d40d

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Javier Goizueta
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,24 @@
+numerals
+========
+
+Number representation as text.
+
+This will be a successor gem to Nio.
+
+Roadmap
+=======
+
+Done:
+
+* Numeral handles (repeating) numerals in any base with bidirectional
+  quotient conversion.
+
+* Numerical conversions (numbers to/from Numerals)
+
+* Rounding can be applied to Numerals (with rounding options)
+
+Pending:
+
+* Numerals can be written into text form using Formatting options
+
+* Numerals con be read from text form using Formatting options

data/Rakefile

@@ -0,0 +1,19 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = Numerals::VERSION
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "Numerals #{version}"
+  rdoc.main = "README.md"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/numerals/conversions/bigdecimal.rb

@@ -0,0 +1,30 @@
+require 'numerals/conversions'
+
+class Numerals::BigDecimalConversion
+
+  def order_of_magnitude(value, options={})
+    base = options[:base] || 10
+    if base == 10
+      value.exponent
+    else
+      Conversions.order_of_magnitude(Flt::DecNum(value.to_s), options)
+    end
+  end
+
+  def number_to_numeral(number, options={})
+    mode = options[:mode] || :fixed
+    base = options[:base] || 10
+    rounding = options[:rounding] || Rounding[:exact]
+
+  end
+
+  def numeral_to_number(numeral, options={})
+    mode = options[:mode] || :fixed
+
+  end
+
+end
+
+def BigDecimal.numerals_conversion
+  Numerals::BigDecimalConversion.new
+end

data/lib/numerals/conversions/float.rb

@@ -0,0 +1,226 @@
+require 'numerals/conversions'
+require 'flt/float'
+
+class Numerals::FloatConversion
+
+  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
+  end
+
+  def order_of_magnitude(value, options={})
+    base = options[:base] || 10 # @contex.radix
+    if base == 10
+      Math.log10(value.abs).floor + 1
+    else
+      (Math.log(value.abs)/Math.log(base)).floor + 1
+    end
+  end
+
+  # mode is either :exact or :approximate
+  def number_to_numeral(number, mode, rounding)
+    if @context.special?(number)
+      special_float_to_numeral(number)
+    else
+      if mode == :exact
+        exact_float_to_numeral number, rounding
+      else # mode == :approximate
+        approximate_float_to_numeral(number, rounding)
+      end
+    end
+  end
+
+  def numeral_to_number(numeral, mode)
+    if numeral.special?
+      special_numeral_to_float numeral
+    elsif mode == :fixed
+      fixed_numeral_to_float numeral
+    else # mode == :free
+      free_numeral_to_float numeral
+    end
+  end
+
+  private
+
+  def special_float_to_numeral(x)
+    if x.nan?
+      Numeral.nan
+    elsif x.infinite?
+      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 = rounding.round(numeral)
+    end
+    numeral
+  end
+
+  def approximate_float_to_numeral(number, rounding)
+    all_digits = !rounding.exact?
+    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
+    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
+    formatter = Flt::Support::Formatter.new(
+      @context.radix, @context.etiny, output_base, raise_on_repeat: false
+    )
+    formatter.format(
+      x, coefficient, exponent, rounding_mode, precision, all_digits
+    )
+
+    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
+    numeral
+  end
+
+  def special_numeral_to_float(numeral)
+    case numeral.special
+    when :nan
+      @context.nan
+    when :inf
+      @context.infinity numeral.sign
+    end
+  end
+
+  def fixed_numeral_to_float(numeral)
+    # consider:
+    # return exact_numeral_to_float(numeral) if numeral.exact?
+    if numeral.base == @context.radix
+      same_base_numeral_to_float numeral
+    else
+      # representable_digits: number of numeral.base digits that can always be converted to Float and back
+      # 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
+        representable_numeral_to_float numeral
+      elsif !@honor_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
+      else
+        general_numeral_to_float numeral, :fixed
+      end
+    end
+  end
+
+  def exact_numeral_to_float(numeral)
+    Rational(*numeral.to_quotient).to_f
+  end
+
+  def free_numeral_to_float(numeral)
+    # raise "Invalid Conversion" # Float does not support free (arbitrary precision)
+    # fixed_numeral_to_float numeral
+    # consider:
+    # return general_numeral_to_float(numeral, :short) if numeral.exact?
+    general_numeral_to_float numeral, :free
+  end
+
+  def same_base_numeral_to_float(numeral)
+    sign, coefficient, scale = numeral.split
+    @context.Num(sign, coefficient, scale)
+  end
+
+  def representable_numeral_to_float(numeral)
+    value, scale = numeral.to_value_scale
+    x = value.to_f
+    if scale < 0
+      x /= Float(numeral.base**-scale)
+    else
+      x *= Float(numeral.base**scale)
+    end
+    x
+  end
+
+  def near_representable_numeral_to_float(numeral)
+    value, scale = numeral.to_value_scale
+    j = scale - numeral.digits.size
+    x = value.to_f * Float(numeral.base**(j))
+    x *= Float(numeral.base**(scale - j))
+    x
+  end
+
+  def conmensurable_base_numeral_to_float(numeral)
+    general_numeral_to_float numeral, :fixed
+  end
+
+  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
+    else
+      rounding_mode = @rounding_mode
+    end
+    reader.read(@context, rounding_mode, sign, coefficient, scale, numeral.base).tap do
+      # @exact = reader.exact?
+    end
+  end
+
+end
+
+def Float.numerals_conversion
+  Numerals::FloatConversion.new
+end
+
+class <<Float.context
+  def numerals_conversion
+    Numerals::FloatConversion.new
+  end
+end

data/lib/numerals/conversions/flt.rb

@@ -0,0 +1,162 @@
+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
+  end
+
+  attr_reader :context, :type
+
+  def order_of_magnitude(value, options={})
+    base = options[:base] || 10 # value.num_class.radix
+    if value.class.radix == base
+      value.adjusted_exponent + 1
+    else
+      value.abs.log(base).floor + 1
+    end
+  end
+
+  # mode is either :exact or :approximate
+  def number_to_numeral(number, mode, rounding)
+    if number.special? # @context.special?(number)
+      special_num_to_numeral(number)
+    else
+      if mode == :exact
+        exact_num_to_numeral number, rounding
+      else # mode == :approximate
+        approximate_num_to_numeral(number, rounding)
+      end
+    end
+  end
+
+  def numeral_to_number(numeral, mode)
+    if numeral.special?
+      special_numeral_to_num numeral
+    elsif mode == :fixed
+      fixed_numeral_to_num numeral
+    else # mode == :free
+      free_numeral_to_num numeral
+    end
+  end
+
+  private
+
+  def special_num_to_numeral(x)
+    if x.nan?
+      Numeral.nan
+    elsif x.infinite?
+      Numeral.infinity @context.sign(x)
+    end
+  end
+
+  def exact_num_to_numeral(number, rounding)
+    quotient = number.to_r
+    numeral = Numeral.from_quotient(quotient, base: rounding.base)
+    unless rounding.exact?
+      numeral = rounding.round(numeral)
+    end
+    numeral
+  end
+
+  def approximate_num_to_numeral(number, rounding)
+    all_digits = !rounding.exact?
+    general_num_to_numeral(number, rounding, all_digits)
+  end
+
+  def general_num_to_numeral(x, rounding, all_digits)
+    sign, coefficient, exponent = x.split
+    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
+    formatter = Flt::Support::Formatter.new(
+      @context.radix, @context.etiny, output_base, raise_on_repeat: false
+    )
+    formatter.format(
+      x, coefficient, exponent, rounding_mode, precision, all_digits
+    )
+
+    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
+    numeral
+  end
+
+  def special_numeral_to_num(numeral)
+    case numeral.special
+    when :nan
+      @context.nan
+    when :inf
+      @context.infinity numeral.sign
+    end
+  end
+
+  def fixed_numeral_to_num(numeral)
+    # consider:
+    # return exact_numeral_to_num(numeral) if numeral.exact?
+    if numeral.base == @context.radix
+      numeral = numeral.approximate(@context.precision) unless @context.exact?
+      same_base_numeral_to_num numeral
+    else
+      general_numeral_to_num numeral, :fixed
+    end
+  end
+
+  def same_base_numeral_to_num(numeral)
+    sign, coefficient, scale = numeral.split
+    @context.Num sign, coefficient, scale
+  end
+
+  def exact_numeral_to_num(numeral)
+    @context.Num Rational(*numeral.to_quotient), :fixed
+  end
+
+  def free_numeral_to_num(numeral)
+    general_numeral_to_num numeral, :free
+  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
+    else
+      rounding_mode = @rounding_mode
+    end
+    reader.read(@context, rounding_mode, sign, coefficient, scale, numeral.base).tap do
+      # @exact = reader.exact?
+    end
+  end
+
+end
+
+def (Flt::Num).numerals_conversion
+  Numerals::FltConversion.new(self)
+end
+
+class Flt::Num::ContextBase
+  def numerals_conversion
+    Numerals::FltConversion.new(self)
+  end
+end

data/lib/numerals/conversions/integer.rb

@@ -0,0 +1,39 @@
+require 'numerals/conversions'
+require 'singleton'
+
+class Numerals::IntegerConversion
+
+  include Singleton
+
+  class InvalidConversion < RuntimeError
+  end
+
+  def order_of_magnitude(value, options={})
+    base = options[:base] || 10
+    if base == 2 && value.respond_to?(:bit_length)
+      value.bit_length
+    else
+      value.to_s(base).size
+    end
+  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
+  end
+
+  def numeral_to_number(numeral, mode)
+    rational = Rational.numerals_conversion.numeral_to_number numeral, mode
+    if rational.denominator != 1
+      raise InvalidConversion, "Invalid numeral to rational conversion"
+    end
+    rational.numerator
+  end
+
+end
+
+def Integer.numerals_conversion
+  Numerals::IntegerConversion.instance
+end

data/lib/numerals/conversions/rational.rb

@@ -0,0 +1,32 @@
+require 'numerals/conversions'
+require 'singleton'
+
+class Numerals::RationalConversion
+
+  include Singleton
+
+  def order_of_magnitude(value, options={})
+    base = options[:base] || 10
+    if base == 10
+      Math.log10(value.abs).floor + 1
+    else
+      (Math.log(value.abs)/Math.log(base)).floor + 1
+    end
+  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
+  end
+
+  def numeral_to_number(numeral, mode)
+    Rational(*numeral.to_quotient)
+  end
+
+end
+
+def Rational.numerals_conversion
+  Numerals::RationalConversion.instance
+end

data/lib/numerals/conversions.rb

@@ -0,0 +1,57 @@
+module Numerals::Conversions
+
+  class <<self
+    def [](type)
+      if type.respond_to?(:numerals_conversion)
+        type.numerals_conversion
+      end
+    end
+
+    def order_of_magnitude(number, options={})
+      self[number.class].order_of_magnitude(number, options)
+    end
+
+    # explicit: number_to_numeral x, mode, rounding
+    # but for :free mode rounding is ignored except for the base
+    # so if no rounding/rounding options are passed except for the base, the default mode should be :free
+    # otherwise, the default mode should be :fixed...
+
+    # number_to_numeral(x, precision: 3) = number_to_numeral(x, :fixed, Rounding[precision: 3])
+    # number_to_numeral(x, precision: 3, base: 2) = number_to_numeral(x, :fixed, Rounding[precision: 3, base: 2])
+    # number_to_numeral(x, :exact, base: 2) = number_to_numeral(x, :free, Rounding[:exact, base: 2])
+
+    # Two ways of defining the conversion mode:
+    # 1. fixed or free:
+    # * :fixed means: adjust the number precision to the output rounding
+    # * :free means: forget about the rounding, preserve the input number precision
+    # But :free cheats: if rounding is not exact it really honors it by
+    # converting the number to an exact numeral an then rounding it.
+    # 2. exact or approximate
+    # * :exact means: consider the number an exact quantity
+    # * :approximate means: consider the number approximate; show only non-spurious digits.
+    def number_to_numeral(number, *args)
+      mode = extract_mode_from_args!(args)
+      rounding = Rounding[*args]
+      # mode ||= rounding.exact? ? :free : :fixed
+      mode ||= :approximate
+      if [:fixed, :free].include?(mode)
+        mode = (mode == :fixed) == (rounding.exact?) ? :exact : :approximate
+      end
+      self[number.class].number_to_numeral(number, mode, rounding)
+    end
+
+    def numeral_to_number(numeral, type, *args)
+      mode = extract_mode_from_args!(args) || :fixed
+      self[type].numeral_to_number(numeral, mode, *args)
+    end
+
+    private
+
+    def extract_mode_from_args!(args)
+      if [:fixed, :free, :exact, :approximate].include?(args.first)
+        args.shift
+      end
+    end
+  end
+
+end