numerals 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e87d9faabf0392f12d84d026d85d480aa67d32c
-  data.tar.gz: 67b89570a8c97ae4abe727c730bdc77099ca70d0
+  metadata.gz: c2db2456e26dc108b6ffc0e72616b58c94c00eee
+  data.tar.gz: 4150c883baaa50b85c7f9f7619b5bde35ec5ff9e
 SHA512:
-  metadata.gz: 3c3b97ef87dcda6dec5dce9a8d8449da8b8da3c5faab0664ab4563dfb32f4770b9295271454c6e9c2efbec2be3b72843cf12c6f2d48395e36c7474b8d6be886c
-  data.tar.gz: 6ff01ddb162578b80b30596adfd38be3fb992509b8ff7aa32018b98815dae4e2449770313728647e9b8af0110e6a0cd4078edc1f4d01754a91a3205ceb7cd93a
+  metadata.gz: 755fe267a26a4091942e522f32e335cc5d17adfcd3d24a671a09d251927d40bdf7a2fc8f508f27272de8b1dd310ac160d7bf256079d7c9b44df34bb542724661
+  data.tar.gz: e1d04a258486962b14b0c5c1065d017a20ea09bcb15d551579a55f0db3f0a206ebe7b800ce065ca7e9ca0aff832ecb2a0d357b4390228ed7caa5931b684e4d5c

data/README.md

@@ -1,6 +1,9 @@
 Numerals
 ========
 
+[![Gem Version](https://badge.fury.io/rb/numerals.svg)](http://badge.fury.io/rb/numerals)
+[![Build Status](https://travis-ci.org/jgoizueta/numerals.svg)](https://travis-ci.org/jgoizueta/numerals)
+
 The Numerals module provides formatted input/output for numeric types.
 
 ## Use

data/Rakefile

@@ -17,3 +17,5 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
+
+task :default => :test

data/lib/numerals.rb

@@ -11,4 +11,3 @@ require 'numerals/conversions/rational'
 require 'numerals/conversions/bigdecimal'
 require 'numerals/conversions/flt'
 require 'numerals/format'
-# require 'numerals/formatting/options'

data/lib/numerals/conversions.rb

@@ -1,98 +1,102 @@
-module Numerals::Conversions
+module Numerals
 
-  class <<self
-    def [](type, options = nil)
-      if type.respond_to?(:numerals_conversion)
-        type.numerals_conversion(options || {})
+  module Conversions
+
+    class <<self
+      def [](type, options = nil)
+        if type.respond_to?(:numerals_conversion)
+          type.numerals_conversion(options || {})
+        end
       end
-    end
 
-    def order_of_magnitude(number, options={})
-      self[number.class, options[:type_options]].order_of_magnitude(number, options)
-    end
+      def order_of_magnitude(number, options={})
+        self[number.class, options[:type_options]].order_of_magnitude(number, options)
+      end
 
-    def number_of_digits(number, options={})
-      self[number.class, options[:type_options]].number_of_digits(number, options)
-    end
+      def number_of_digits(number, options={})
+        self[number.class, options[:type_options]].number_of_digits(number, options)
+      end
 
-    # Convert Numeral to Number
-    #
-    #   read numeral, options={}
-    #
-    # If the input numeral is approximate and the destination type
-    # allows for arbitrary precision, then the destination context
-    # precision will be ignored and the precision of the input will be
-    # preserved. The :simplify option affects this case by generating
-    # only the mininimun number of digits needed.
-    #
-    # The :exact option will prevent this behaviour and always treat
-    # input as exact.
-    #
-    # Valid output options:
-    #
-    # * :type class of the output number
-    # * :context context (in the case of Flt::Num, Float) for the output
-    # * :simplify (for approximate input numeral/arbitrary precision type only)
-    # * :exact treat input numeral as if exact
-    #
-    def read(numeral, options={})
-      selector = options[:context] || options[:type]
-      exact_input = options[:exact]
-      approximate_simplified = options[:simplify]
-      conversions = self[selector, options[:type_options]]
-      conversions.read(numeral, exact_input, approximate_simplified)
-    end
+      # Convert Numeral to Number
+      #
+      #   read numeral, options={}
+      #
+      # If the input numeral is approximate and the destination type
+      # allows for arbitrary precision, then the destination context
+      # precision will be ignored and the precision of the input will be
+      # preserved. The :simplify option affects this case by generating
+      # only the mininimun number of digits needed.
+      #
+      # The :exact option will prevent this behaviour and always treat
+      # input as exact.
+      #
+      # Valid output options:
+      #
+      # * :type class of the output number
+      # * :context context (in the case of Flt::Num, Float) for the output
+      # * :simplify (for approximate input numeral/arbitrary precision type only)
+      # * :exact treat input numeral as if exact
+      #
+      def read(numeral, options={})
+        selector = options[:context] || options[:type]
+        exact_input = options[:exact]
+        approximate_simplified = options[:simplify]
+        conversions = self[selector, options[:type_options]]
+        conversions.read(numeral, exact_input, approximate_simplified)
+      end
 
-    # Convert Number to Numeral
-    #
-    #   write number, options={}
-    #
-    # Valid options:
-    #
-    # * :rounding (a Rounding) (which defines output base as well)
-    # * :exact (exact input indicator)
-    #
-    # Approximate mode:
-    #
-    # If the input is treated as an approximation
-    # (which is the case for types such as Flt::Num, Float,...
-    # unless the :exact option is true) then no 'spurious' digits
-    # will be shown (digits that can take any value and the numeral
-    # still would convert to the original number if rounded to the same precision)
-    #
-    # In approximate mode, if rounding is simplifying? (:short), the shortest representation
-    # which rounds back to the origina number with the same precision is used.
-    # If rounding is :free and the output base is the same as the number
-    # internal radix, the exact precision (trailing zeros) of the number
-    # is represented.
-    #
-    # Exact mode:
-    #
-    # Is used for 'exact' types (such as Integer, Rational) or when the :exact
-    # option is defined to be true.
-    #
-    # The number is treated as an exact value, and converted according to
-    # Rounding. (in this case the :free and :short precision roundings are
-    # equivalent)
-    #
-    def write(number, options = {})
-      output_rounding = Rounding[options[:rounding] || Rounding[]]
-      conversion = self[number.class, options[:type_options]]
-      exact_input = conversion.exact?(number, options)
-      conversion.write(number, exact_input, output_rounding)
-    end
+      # Convert Number to Numeral
+      #
+      #   write number, options={}
+      #
+      # Valid options:
+      #
+      # * :rounding (a Rounding) (which defines output base as well)
+      # * :exact (exact input indicator)
+      #
+      # Approximate mode:
+      #
+      # If the input is treated as an approximation
+      # (which is the case for types such as Flt::Num, Float,...
+      # unless the :exact option is true) then no 'spurious' digits
+      # will be shown (digits that can take any value and the numeral
+      # still would convert to the original number if rounded to the same precision)
+      #
+      # In approximate mode, if rounding is simplifying? (:short), the shortest representation
+      # which rounds back to the origina number with the same precision is used.
+      # If rounding is :free and the output base is the same as the number
+      # internal radix, the exact precision (trailing zeros) of the number
+      # is represented.
+      #
+      # Exact mode:
+      #
+      # Is used for 'exact' types (such as Integer, Rational) or when the :exact
+      # option is defined to be true.
+      #
+      # The number is treated as an exact value, and converted according to
+      # Rounding. (in this case the :free and :short precision roundings are
+      # equivalent)
+      #
+      def write(number, options = {})
+        output_rounding = Rounding[options[:rounding] || Rounding[]]
+        conversion = self[number.class, options[:type_options]]
+        exact_input = conversion.exact?(number, options)
+        conversion.write(number, exact_input, output_rounding)
+      end
 
-    def exact?(number, options = {})
-      self[number.class, options[:type_options]].exact?(number, options)
-    end
+      def exact?(number, options = {})
+        self[number.class, options[:type_options]].exact?(number, options)
+      end
 
-    private
+      private
 
-    def extract_mode_from_args!(args)
-      if [:fixed, :free, :exact, :approximate].include?(args.first)
-        args.shift
+      def extract_mode_from_args!(args)
+        if [:fixed, :free, :exact, :approximate].include?(args.first)
+          args.shift
+        end
       end
     end
+
   end
 
 end

data/lib/numerals/conversions/context_conversion.rb

@@ -1,40 +1,44 @@
 require 'numerals/conversions'
 require 'flt'
 
-# Base class for Conversions of type with context
-class Numerals::ContextConversion
+module Numerals
 
-  def initialize(context_or_type, options={})
-    if Class === context_or_type && context_or_type.respond_to?(:context)
-      @type = context_or_type
-      @context = @type.context
-    elsif context_or_type.respond_to?(:num_class)
-      @context = context_or_type
-      @type = @context.num_class
-    else
-      raise "Invalid Conversion definition"
+  # Base class for Conversions of type with context
+  class ContextConversion
+
+    def initialize(context_or_type, options={})
+      if Class === context_or_type && context_or_type.respond_to?(:context)
+        @type = context_or_type
+        @context = @type.context
+      elsif context_or_type.respond_to?(:num_class)
+        @context = context_or_type
+        @type = @context.num_class
+      else
+        raise "Invalid Conversion definition"
+      end
+      self.input_rounding = options[:input_rounding]
     end
-    self.input_rounding = options[:input_rounding]
-  end
 
-  attr_reader :context, :type, :input_rounding
+    attr_reader :context, :type, :input_rounding
 
-  def input_rounding=(rounding)
-    if rounding
-      if rounding == :context
-        @input_rounding = Rounding[@context.rounding, precision: @context.precision, base: @context.radix]
-      else
-        rounding = Rounding[base: @context.radix].set!(rounding)
-        if rounding.base == @context.radix
-          @input_rounding = rounding
+    def input_rounding=(rounding)
+      if rounding
+        if rounding == :context
+          @input_rounding = Rounding[@context.rounding, precision: @context.precision, base: @context.radix]
         else
-          # The rounding precision is not meaningful for the destination type on input
-          @input_rounding = Rounding[rounding.mode, base: @context.radix]
+          rounding = Rounding[base: @context.radix].set!(rounding)
+          if rounding.base == @context.radix
+            @input_rounding = rounding
+          else
+            # The rounding precision is not meaningful for the destination type on input
+            @input_rounding = Rounding[rounding.mode, base: @context.radix]
+          end
         end
+      else
+        @input_rounding = nil
       end
-    else
-      @input_rounding = nil
     end
+
   end
 
 end

data/lib/numerals/conversions/flt.rb

@@ -1,233 +1,237 @@
 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
-
-  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
+module Numerals
+
+  class FltConversion < 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
-  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)
+    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
-  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)
-      special_num_to_numeral(number)
-    else
-      if mode == :exact
-        exact_num_to_numeral number, rounding
-      else # mode == :approximate
-        approximate_num_to_numeral(number, rounding)
+    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
-  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
+    def exact?(value, options={})
+      options[:exact]
     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
+    # 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
-        # akin to number.format(base: output_base, exact: true)
-        exact_num_to_numeral number, output_rounding
+        if mode == :exact
+          exact_num_to_numeral number, rounding
+        else # mode == :approximate
+          approximate_num_to_numeral(number, rounding)
+        end
       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
+    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
+
+    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
-        # akin to number.forma(base: output_base, all_digits: true)
-        general_num_to_numeral number, output_rounding, true
+        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
-  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
+    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, :free)
-        free_numeral_to_num numeral
+        # akin to @context.Num(numeral_text, :fixed)
+        fixed_numeral_to_num numeral
       end
-    else
-      # akin to @context.Num(numeral_text, :fixed)
-      fixed_numeral_to_num numeral
     end
-  end
 
-  private
+    private
 
-  def special_num_to_numeral(x)
-    if x.nan?
-      Numeral.nan
-    elsif x.infinite?
-      Numeral.infinity @context.sign(x)
+    def special_num_to_numeral(x)
+      if x.nan?
+        Numeral.nan
+      elsif x.infinite?
+        Numeral.infinity @context.sign(x)
+      end
     end
-  end
 
-  def exact_num_to_numeral(number, rounding)
-    quotient = number.to_r
-    numeral = Numerals::Numeral.from_quotient(quotient, base: rounding.base)
-    unless rounding.free?
-      numeral = rounding.round(numeral)
+    def exact_num_to_numeral(number, rounding)
+      quotient = number.to_r
+      numeral = Numerals::Numeral.from_quotient(quotient, base: rounding.base)
+      unless rounding.free?
+        numeral = rounding.round(numeral)
+      end
+      numeral
     end
-    numeral
-  end
 
-  def approximate_num_to_numeral(number, rounding)
-    all_digits = !rounding.free?
-    general_num_to_numeral(number, rounding, all_digits)
-  end
+    def approximate_num_to_numeral(number, rounding)
+      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 # @context.split(x)
-    precision = x.number_of_digits
-    output_base = rounding.base
+    def general_num_to_numeral(x, rounding, all_digits)
+      sign, coefficient, exponent = x.split # @context.split(x)
+      precision = x.number_of_digits
+      output_base = rounding.base
 
-    # here rounding_mode is not the output rounding mode, but the rounding mode used for input
-    rounding_mode = (@input_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
-    )
-    formatter.format(
-      x, coefficient, exponent, rounding_mode, precision, all_digits
-    )
+      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
+      dec_pos, digits = formatter.digits
+      rep_pos = formatter.repeat
 
-    normalization = :approximate
+      normalization = :approximate
 
-    numeral = Numerals::Numeral[digits, sign: sign, point: dec_pos, rep_pos: formatter.repeat, base: output_base, normalize: normalization]
+      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 = rounding.round(numeral, round_up: formatter.round_up)
 
-    numeral
-  end
-
-  def special_numeral_to_num(numeral)
-    case numeral.special
-    when :nan
-      @context.nan
-    when :inf
-      @context.infinity numeral.sign
+      numeral
     end
-  end
 
-  def fixed_numeral_to_num(numeral)
-    # consider:
-    # return exact_numeral_to_num(numeral) if numeral.exact?
-    if numeral.base == @context.radix
-      unless @context.exact?
-        rounding = Rounding[@context.rounding, precision: @context.precision, base: @context.radix]
-        numeral = rounding.round(numeral)
+    def special_numeral_to_num(numeral)
+      case numeral.special
+      when :nan
+        @context.nan
+      when :inf
+        @context.infinity numeral.sign
       end
-      same_base_numeral_to_num numeral
-    else
-      if numeral.repeating? # numeral.exact?
-        exact_numeral_to_num(numeral)
+    end
+
+    def fixed_numeral_to_num(numeral)
+      # consider:
+      # return exact_numeral_to_num(numeral) if numeral.exact?
+      if numeral.base == @context.radix
+        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
-  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)
-    if numeral.base == @context.radix
-      same_base_numeral_to_num numeral
-    else
-      general_numeral_to_num numeral, :free
+    def same_base_numeral_to_num(numeral)
+      sign, coefficient, scale = numeral.split
+      @context.Num sign, coefficient, scale
     end
-  end
 
-  def short_numeral_to_num(numeral)
-    general_numeral_to_num numeral, :short
-  end
+    def exact_numeral_to_num(numeral)
+      @context.Num Rational(*numeral.to_quotient), :fixed
+    end
 
-  def general_numeral_to_num(numeral, mode)
-    sign, coefficient, scale = numeral.split
-    reader = Flt::Support::Reader.new(mode: mode)
-    if @input_rounding
-      rounding_mode = @input_rounding.mode
-    else
-       rounding_Mode = @context.rounding
+    def free_numeral_to_num(numeral)
+      if numeral.base == @context.radix
+        same_base_numeral_to_num numeral
+      else
+        general_numeral_to_num numeral, :free
+      end
     end
-    reader.read(@context, rounding_mode, sign, coefficient, scale, numeral.base).tap do
-      # @exact = reader.exact?
+
+    def short_numeral_to_num(numeral)
+      general_numeral_to_num numeral, :short
     end
-  end
 
-end
+    def general_numeral_to_num(numeral, mode)
+      sign, coefficient, scale = numeral.split
+      reader = Flt::Support::Reader.new(mode: mode)
+      if @input_rounding
+        rounding_mode = @input_rounding.mode
+      else
+         rounding_Mode = @context.rounding
+      end
+      reader.read(@context, rounding_mode, sign, coefficient, scale, numeral.base).tap do
+        # @exact = reader.exact?
+      end
+    end
 
-def (Flt::Num).numerals_conversion(options = {})
-  Numerals::FltConversion.new(self, options)
-end
+  end
 
-class Flt::Num::ContextBase
-  def numerals_conversion(options = {})
+  def (Flt::Num).numerals_conversion(options = {})
     Numerals::FltConversion.new(self, options)
   end
+
+  class Flt::Num::ContextBase
+    def numerals_conversion(options = {})
+      Numerals::FltConversion.new(self, options)
+    end
+  end
+
 end

data/lib/numerals/format/base_scaler.rb

@@ -144,9 +144,9 @@ module Numerals
     end
 
     # Convert base digits to scaled base digits
-    def self.ugrouped_digits(digits, base, base_scale)
+    def self.ungrouped_digits(digits, base, base_scale)
       digits.flat_map { |d|
-        group = Numeral::Digits[base: base]
+        group = Digits[base: base]
         group.value = d
         ungrouped = group.digits_array
         if ungrouped.size < base_scale

data/lib/numerals/format/input.rb

@@ -104,7 +104,7 @@ module Numerals
 
         if @mode.base_scale > 1
           # De-scale the significand base
-          digits = Format::BaseScaler.ugrouped_digits(digits, base, @mode.base_scale)
+          digits = Format::BaseScaler.ungrouped_digits(digits, base, @mode.base_scale)
           point  *= @mode.base_scale
           repeat *= @mode.base_scale if repeat
         end

data/lib/numerals/format/notations/html.rb

@@ -34,7 +34,7 @@ module Numerals
             else
               # show base suffix as a subscript
               subscript = format.symbols.base_suffix || base.to_s
-º             output << "<sub>#{subscript}</sub>"
+              output << "<sub>#{subscript}</sub>"
             end
           end
           if text_parts.exponent_value != 0 || format.mode.mode == :scientific

data/lib/numerals/version.rb

@@ -1,3 +1,3 @@
 module Numerals
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

data/test/test_base_scaler.rb

@@ -1,10 +1,11 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
 
 require 'numerals'
-include Numerals
 
 class TestBaseScaler <  Test::Unit::TestCase # < Minitest::Test
 
+  include Numerals
+
   def digits_string(part, base)
     part.map{|d| d.to_s(base)}.join
   end

data/test/test_big_conversions.rb

@@ -2,10 +2,10 @@ require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
 
 require 'numerals'
 require 'flt/bigdecimal'
-include Numerals
 
 class TestBigConversions <  Test::Unit::TestCase # < Minitest::Test
 
+  include Numerals
 
   def test_write_special
     context = BigDecimal.context

data/test/test_digits_definition.rb

@@ -2,11 +2,12 @@
 
 require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
 require 'test/unit'
-include Numerals
 require 'yaml'
 
 class TestDigitsDefinition < Test::Unit::TestCase
 
+  include Numerals
+
   DEFAULT_DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
   MAX_TEST_BASE  = DEFAULT_DIGITS.size
 

data/test/test_exp_setter.rb

@@ -1,10 +1,11 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
 
 require 'numerals'
-include Numerals
 
 class TestExpSetter <  Test::Unit::TestCase # < Minitest::Test
 
+  include Numerals
+
   def check_setter(numeral, n=nil)
     adjust = Format::ExpSetter[numeral]
     adjust.integer_part_size = n if n

data/test/test_float_conversions.rb

@@ -1,10 +1,10 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
 
 require 'numerals'
-include Numerals
 
 class TestFloatConversions <  Test::Unit::TestCase # < Minitest::Test
 
+  include Numerals
 
   def test_write_special
     assert_equal Numeral.nan, Conversions.write(Float.context.nan)

data/test/test_flt_conversions.rb

@@ -1,10 +1,11 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
 
 require 'numerals'
-include Numerals
 
 class TestFltConversions <  Test::Unit::TestCase # < Minitest::Test
 
+  include Numerals
+
   def test_write_special_binary
     context = Flt::BinNum.context = Flt::BinNum::FloatContext
     type = Flt::BinNum

data/test/test_format.rb

@@ -1,9 +1,10 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
-include Numerals
 require 'yaml'
 
 class TestFormat <  Test::Unit::TestCase # < Minitest::Test
 
+  include Numerals
+
   def test_mutated_copy
     f1 = Format[Rounding[precision: 3, base: 2]]
 

data/test/test_format_input.rb

@@ -1,9 +1,10 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
-include Numerals
 require 'yaml'
 
 class TestFormatInput <  Test::Unit::TestCase # < Minitest::Test
 
+  include Numerals
+
   def assert_same_flt(x, y)
     assert_equal x.class, y.class, x.to_s
     assert_equal x.split, y.split, x.to_s

data/test/test_format_mode.rb

@@ -1,10 +1,11 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
 
 require 'numerals/rounding'
-include Numerals
 
 class TestFormatMode <  Test::Unit::TestCase # < Minitest::Test
 
+  include Numerals
+
   def test_format_mode_constructor
     mode = Format::Mode[:scientific]
     assert mode.scientific?

data/test/test_format_output.rb

@@ -1,10 +1,11 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
-include Numerals
 require 'yaml'
 require 'tempfile'
 
 class TestFormatOutput <  Test::Unit::TestCase # < Minitest::Test
 
+  include Numerals
+
   def test_write_float_dec
     assert_equal '1', Format[rounding: :short].write(1.0)
     assert_equal '1', Format[].write(1.0)

data/test/test_integer_conversions.rb

@@ -1,10 +1,11 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
 
 require 'numerals'
-include Numerals
 
 class TestIntegerConversions <  Test::Unit::TestCase # < Minitest::Test
 
+  include Numerals
+
   def test_read_special
     assert_raise(ZeroDivisionError){ Conversions.read(Numeral.nan, type: Integer) }
     assert_raise(ZeroDivisionError){ Conversions.read(Numeral.infinity, type: Integer) }

data/test/test_numeral.rb

@@ -1,9 +1,10 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
-include Numerals
 require 'yaml'
 
 class TestNumeral <  Test::Unit::TestCase # < Minitest::Test
 
+  include Numerals
+
   def test_numeral_reference_constructors
     # We'll use this forms as reference for comparisons:
     #   Numeral[digits, base: ..., point: ... , repeat: ...]

data/test/test_qualified.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
+
+class TestQualified <  Test::Unit::TestCase # < Minitest::Test
+
+  def test_qualified_use
+    assert_equal '1', Numerals::Format[].write(1.0)
+    assert_equal '1.00', Numerals::Format[Numerals::Rounding[precision: 3]].write(1.0)
+    assert_equal '1.000', Numerals::Format[Numerals::Rounding[places: 3]].write(1.0)
+    assert_equal '1234567.1234', Numerals::Format[rounding: :short].write(1234567.1234)
+    assert_equal '1234567.123', Numerals::Format[Numerals::Rounding[places: 3]].write(1234567.1234)
+  end
+
+end

data/test/test_rational_conversions.rb

@@ -1,10 +1,11 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
 
 require 'numerals'
-include Numerals
 
 class TestRationalConversions <  Test::Unit::TestCase # < Minitest::Test
 
+  include Numerals
+
   def test_read_special
     assert_raise(ZeroDivisionError){ Conversions.read(Numeral.nan, type: Rational) }
     assert_raise(ZeroDivisionError){ Conversions.read(Numeral.infinity, type: Rational) }

data/test/test_repeat_detector.rb

@@ -1,10 +1,11 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
 
 require 'numerals'
-include Numerals
 
 class TestRepeatDetector <  Test::Unit::TestCase # < Minitest::Test
 
+  include Numerals
+
   def test_repeat_detector
 
     assert_equal(

data/test/test_rounding.rb

@@ -1,10 +1,11 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
 
 require 'numerals/rounding'
-include Numerals
 
 class TestRounding <  Test::Unit::TestCase # < Minitest::Test
 
+  include Numerals
+
   def test_rounding
     r = Rounding[:half_even, places: 0]
     assert_equal Numeral[1,0,0, point: 3, normalize: :approximate], r.round(Numeral[1,0,0,5, point: 3])

data/test/test_symbols.rb

@@ -1,10 +1,11 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
 
 require 'numerals/rounding'
-include Numerals
 
 class TestSymbols <  Test::Unit::TestCase # < Minitest::Test
 
+  include Numerals
+
   def test_symbols
     s = Format::Symbols[show_plus: false]
     s2 = s[uppercase: true]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: numerals
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Javier Goizueta
@@ -123,6 +123,7 @@ files:
 - test/test_format_output.rb
 - test/test_integer_conversions.rb
 - test/test_numeral.rb
+- test/test_qualified.rb
 - test/test_rational_conversions.rb
 - test/test_repeat_detector.rb
 - test/test_rounding.rb
@@ -166,6 +167,7 @@ test_files:
 - test/test_format_output.rb
 - test/test_integer_conversions.rb
 - test/test_numeral.rb
+- test/test_qualified.rb
 - test/test_rational_conversions.rb
 - test/test_repeat_detector.rb
 - test/test_rounding.rb