numerals 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c2db2456e26dc108b6ffc0e72616b58c94c00eee
-  data.tar.gz: 4150c883baaa50b85c7f9f7619b5bde35ec5ff9e
+  metadata.gz: 4a2eebfacb8568be5a073d74a2f7a08eeafafc68
+  data.tar.gz: d950941cd533ec4a5dd681446893f0d5f59b5f54
 SHA512:
-  metadata.gz: 755fe267a26a4091942e522f32e335cc5d17adfcd3d24a671a09d251927d40bdf7a2fc8f508f27272de8b1dd310ac160d7bf256079d7c9b44df34bb542724661
-  data.tar.gz: e1d04a258486962b14b0c5c1065d017a20ea09bcb15d551579a55f0db3f0a206ebe7b800ce065ca7e9ca0aff832ecb2a0d357b4390228ed7caa5931b684e4d5c
+  metadata.gz: d0b51714327a49c8554ee335010707578909cf129f6a089f50422e34e0a0939c4b7426dd10b305b411326dfc7ac9246a1c342de8236e7ee6d691a3c0f8c0d1dc
+  data.tar.gz: a3bd8a43be96700742968d64374fb3a299fdbb111d9fe6b3a2aefe2c14a2f419394e6bc9982fd339113c739bac39ecabd694910ea72b8cbc0bcb0710c19241a0

data/README.md

@@ -72,15 +72,17 @@ Specific precision can be obtained like this:
 But this won't show digits that are insignificant (when the input number
 is regarded as an approximation):
 
-    puts Format[precision: 20].write(0.1)          # -> 0.10000000000000001
-    puts Format[precision: 20].write(Rational(1,10))# -> 0.10000000000000000000
+    puts Format[precision: 20].write(0.1)            # -> 0.10000000000000001
+    puts Format[precision: 20].write(Rational(1,10)) # -> 0.10000000000000000000
 
 Although a Float is considered an approximation by default (since
 it cannot represent arbitrary precision exactly), we can
 reinterpret it as an exact quantity with the :exact_input Format option:
 
-    puts Format[:exact_input, precision: 20].write(0.1)# -> 0.10000000000000000555
-    puts Format[:exact_input].write(0.1)           # -> 0.1000000000000000055511151231257827021181583404541015625
+    puts Format[:exact_input, precision: 20].write(0.1)
+    # -> 0.10000000000000000555
+    puts Format[:exact_input].write(0.1)
+    # -> 0.1000000000000000055511151231257827021181583404541015625
 
 Rationals are always 'exact' quantities, and they may require infinite
 digits to be represented exactly in some output bases. This is handled
@@ -104,28 +106,28 @@ will be a variable-precision result based on the input. The default
 Format, which has :short (simplifying) precision will produce a simple
 result with as few significant digits as possible:
 
-    puts Format[:short].read('1.000', type: Flt::DecNum)# -> 1
-    puts Format[:short].read('0.100', type: Flt::BinNum)# -> 0.1
+    puts Format[:short].read('1.000', type: Flt::DecNum) # -> 1
+    puts Format[:short].read('0.100', type: Flt::BinNum) # -> 0.1
 
 To retain the precision of the input text, the :free precision should be
 used:
 
-    puts Format[:free].read('1.000', type: Flt::DecNum)# -> 1.000
-    puts Format[:free].read('0.100', type: Flt::BinNum)# -> 0.1
+    puts Format[:free].read('1.000', type: Flt::DecNum) # -> 1.000
+    puts Format[:free].read('0.100', type: Flt::BinNum) # -> 0.1
 
 As an alternative, the precision implied by the text input can be ignored
 and the result adjusted to the precision of the destination context. This
 is done by regarding the input as 'exact'.
 
-    puts Format[:exact_input].read('1.000', type: Flt::DecNum)# -> 1.000000000000000000000000000
-    puts Format[:exact_input].read('0.100', type: Flt::BinNum)# -> 0.1
+    puts Format[:exact_input].read('1.000', type: Flt::DecNum) # -> 1.000000000000000000000000000
+    puts Format[:exact_input].read('0.100', type: Flt::BinNum) # -> 0.1
     Flt::DecNum.context.precision = 8
-    puts Format[:exact_input].read('1.000', type: Flt::DecNum)# -> 1.0000000
+    puts Format[:exact_input].read('1.000', type: Flt::DecNum) # -> 1.0000000
 
 If the input specifies repeating digits, then it is automatically regarded
 exact and rounded according to the destination context:
 
-    puts Format[:exact_input].read('0.333...', type: Flt::DecNum)# -> 0.33333333
+    puts Format[:exact_input].read('0.333...', type: Flt::DecNum) # -> 0.33333333
 
 Note that the repeating digits have been automatically detected. This
 happens because the repeating suffix '...' has ben found (it is defined
@@ -138,13 +140,31 @@ in Symbols, which are <> by default:
 
 A Format can also be used to read a formatted number into a Numeral:
 
-    puts Format[].read('1.25', type: Numeral)      # -> Numeral[1, 2, 5, :sign=>1, :point=>1, :normalize=>:approximate, :base=>10]
-    puts Format[].read('1.<3>', type: Numeral)     # -> Numeral[1, 3, :sign=>1, :point=>1, :repeat=>1, :base=>10]
+    puts Format[].read('1.25', type: Numeral)
+    # -> Numeral[1, 2, 5, :sign=>1, :point=>1, :normalize=>:approximate, :base=>10]
+    puts Format[].read('1.<3>', type: Numeral)
+    # -> Numeral[1, 3, :sign=>1, :point=>1, :repeat=>1, :base=>10]
 
 Other examples:
 
     puts Format[:free, base: 2].read('0.1', type: Flt::DecNum)# -> 0.5
 
+## Shortcut notation
+
+The `<<` and `>>` operators can be applied to Format objects
+as a shortcut for formatted writing and reading:
+
+    fmt = Format[]
+    puts fmt << 0.1                                            # -> 0.1
+    puts fmt << 0.1 << ' ' << 0.2 << ' ' << [places: 3] << 0.3 # -> 0.1 0.2 0.300
+    puts fmt >> '0.1' >> Rational                              # -> 1/10
+
+These operators can also be applied to Format, which is equivalent
+to apply them to de default Format, `Format[]`:
+
+    puts Format << [:sci, places: 4] <<  0.1                   # -> 1.000e-1
+    puts Format >> '0.1' >> Rational                           # -> 1/10
+
 Roadmap
 =======
 

data/lib/numerals.rb

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

data/lib/numerals/conversions.rb

@@ -77,6 +77,28 @@ module Numerals
       # Rounding. (in this case the :free and :short precision roundings are
       # equivalent)
       #
+      # Summary
+      #
+      # In result there are 5 basically diferent conversion modes.
+      # Three of them apply only to approximate values, so they are
+      # not available for all input types:
+      #
+      # * 'Short' mode, which produces an exact Numeral. Used when
+      #   input is not exact and rounding precision is :short.
+      # * 'Free' mode, which produces an approximate Numeral. Used
+      #   when input is not exact and rounding precision is :short.
+      # * 'Fixed' mode, which produces an approximate Numeral. Used when
+      #   input isnot exact and rounding precision is limited.
+      #
+      # The other two modes are applied to exact input, so they're
+      # available for all input types (since all can be taken as exact with
+      # the :exact option):
+      #
+      # * 'All' mode, which produces an exact Numeral. Used when
+      #   input is exact and rounding precision is :free (or :short).
+      # * 'Rounded' mode, which produces an approximate Numeral. Used
+      #   when input is exact and rounding precision is limited.
+      #
       def write(number, options = {})
         output_rounding = Rounding[options[:rounding] || Rounding[]]
         conversion = self[number.class, options[:type_options]]
@@ -88,6 +110,76 @@ module Numerals
         self[number.class, options[:type_options]].exact?(number, options)
       end
 
+      # Convert an number to a different numeric type.
+      # Conversion is done by first converting the number to a Numeral,
+      # then converting the Numeral to de destination type.
+      #
+      # Options:
+      #
+      # * :exact_input Consider the number an exact quantity.
+      #   Otherwise, for approximate types, insignificant digits
+      #   will not be converted.
+      # * :rounding Rounding to be applied during the conversion.
+      # * :type or :context can be used to define the destination
+      #   type.
+      # * :output_mode can have the values :free, :short or :fixed
+      #   and is used to define how the result is generated.
+      #
+      def convert(number, options = {})
+        if options[:exact]
+          options = options.merge(exact_input: true, ouput_mode: :free)
+        end
+
+        exact_input = options[:exact_input] || false
+        rounding = Rounding[options[:rounding] || Rounding[]]
+        output_mode = options[:output_mode] || :free # :short :free :fixed
+        type_options =  options[:type_options]
+        selector = options[:context] || options[:type]
+        output_conversions = self[selector, type_options]
+        if output_conversions && output_conversions.respond_to?(:context)
+          output_base = output_conversions.context.radix
+          if rounding.base != output_base && rounding.free?
+            rounding = rounding[base: output_base]
+          end
+        end
+
+        if number.is_a?(Numeral)
+          numeral = number
+        else
+          input_options = {
+            exact: exact_input,
+            rounding: rounding,
+            type_options: type_options
+          }
+          numeral = write(number, input_options)
+        end
+
+        output_options = {
+          type: options[:type], context: options[:context]
+        }
+        case output_mode
+        when :short
+          output_options.merge!(
+            exact: false,
+            simplify: true
+          )
+        when :free
+          output_options.merge!(
+            exact: false,
+            simplify: false
+          )
+        when :fixed
+          output_options.merge!(
+            exact: true,
+            simplify: false
+          )
+        end
+        if !output_options[:exact] && numeral.exact?
+          numeral.approximate!
+        end
+        read(numeral, output_options)
+      end
+
       private
 
       def extract_mode_from_args!(args)

data/lib/numerals/conversions/flt.rb

@@ -106,6 +106,7 @@ module Numerals
         end
       else
         # akin to @context.Num(numeral_text, :fixed)
+        numeral = numeral.exact if exact_input
         fixed_numeral_to_num numeral
       end
     end
@@ -215,7 +216,7 @@ module Numerals
       if @input_rounding
         rounding_mode = @input_rounding.mode
       else
-         rounding_Mode = @context.rounding
+        rounding_Mode = @context.rounding
       end
       reader.read(@context, rounding_mode, sign, coefficient, scale, numeral.base).tap do
         # @exact = reader.exact?

data/lib/numerals/format/input.rb

@@ -3,7 +3,22 @@ module Numerals
   # Formatted input implementation
   module Format::Input
 
-    def read(text, options={})
+    def read(*args)
+      options = {}
+      args.each do |arg|
+        case arg
+        when String
+          options.merge! text: arg
+        when Hash
+          options.merge! arg
+        else
+          options.merge! type: arg
+        end
+      end
+
+      text = options[:text]
+      options[:type] ||= options[:as]
+
       # 1. Obtain destination type
       selector = options[:context] || options[:type]
       conversion = Conversions[selector, options[:type_options]]

data/lib/numerals/format/sugar.rb

@@ -0,0 +1,110 @@
+module Numerals
+
+  class Format
+    def self.<<(*args)
+      Format[].<<(*args)
+    end
+
+    def self.>>(*args)
+      Format[].>>(*args)
+    end
+
+    def <<(*args)
+      FormattingStream[self].<<(*args)
+    end
+
+    def >>(*args)
+      FormattingStream[self].>>(*args)
+    end
+  end
+
+  # Auxiliar class to implement << & >> operators
+  # on Format class and Format instances as a
+  # shortcut for the Format#write and #read
+  # formatting operators.
+  class FormattingStream
+    def initialize(format)
+      @format = format
+      @text = nil
+      @type = nil
+      @output = []
+    end
+
+    def self.[](*args)
+      new *args
+    end
+
+    def to_a
+      @output
+    end
+
+    def to_s
+      to_a.join
+    end
+
+    def to_str
+      to_s
+    end
+
+    def value
+      if @output.size > 1
+        @output
+      else
+        @output.first
+      end
+    end
+
+    def <<(*objects)
+      objects.each do |object|
+        case object
+        when Format, Hash, Array
+          @format.set! object
+        when String
+          if @type
+            @output << @format.read(object, type: @type)
+          else
+            @output << object
+          end
+        else
+          if @text
+            @output << @format.read(@text, type: object)
+          elsif object.is_a?(Class)
+            @type = object
+          else
+            @output << @format.write(object)
+          end
+        end
+      end
+      self
+    end
+
+    def >>(*objects)
+      objects.each do |object|
+        case object
+        when Format, Hash, Array
+          @format.set! object
+        when String
+          @text = object
+          if @type
+            @output << @format.read(object, type: @type)
+          end
+        else
+          if @text
+            @output << @format.read(@text, type: object)
+          elsif object.is_a?(Class)
+            @type = object
+          else
+            @output << @format.write(object)
+          end
+        end
+      end
+      self
+    end
+
+    def clear
+      @output.clear
+    end
+
+  end
+
+end

data/lib/numerals/numeral.rb

@@ -626,14 +626,23 @@ module Numerals
 
     # Expand to the specified number of digits,
     # then truncate and remove repetitions.
-    def approximate!(number_of_digits)
-      expand! number_of_digits
-      @digits.truncate! number_of_digits
-      @repeat = nil
+    # If no number of digits is given, then it will be
+    # converted to approximate numeral only if it is not
+    # repeating.
+    def approximate!(number_of_digits = nil)
+      if number_of_digits.nil?
+        if exact? && !repeating?
+          @repeat = nil
+        end
+      else
+        expand! number_of_digits
+        @digits.truncate! number_of_digits
+        @repeat = nil
+      end
       self
     end
 
-    def approximate(number_of_digits)
+    def approximate(number_of_digits = nil)
       dup.approximate! number_of_digits
     end
 

data/lib/numerals/version.rb

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

data/numerals.gemspec

@@ -18,8 +18,8 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency 'flt', "~> 1.4.6"
-  spec.add_dependency 'modalsupport', "~> 0.9.2"
+  spec.add_dependency 'flt', "~> 1.4"
+  spec.add_dependency 'modalsupport', "~> 0.9"
 
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"

data/test/helper.rb

@@ -38,3 +38,18 @@ PrepareData.init
 def BigDec(x)
   BigDecimal.new(x.to_s)
 end
+
+
+def assert_same_number(x, y)
+  assert_equal x.class, y.class, x.to_s
+  case x
+  when Flt::Num
+    assert_equal x.split, y.split, x.to_s
+  when Float
+    assert_equal Float.context.split(x), Float.context.split(y), x.to_s
+  when Rational
+    assert_equal [x.numerator, x.denominator], [y.numerator, y.denominator]
+  else
+    assert_equal x, y
+  end
+end

data/test/test_conversions.rb

@@ -0,0 +1,1921 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
+
+require 'numerals'
+
+class TestConversions <  Test::Unit::TestCase # < Minitest::Test
+
+  include Numerals
+  include Flt
+
+  def setup
+    @dec_context = Flt::DecNum.context
+    @bin_context = Flt::BinNum.context
+    Flt::DecNum.context = Flt::DecNum::ExtendedContext
+    Flt::BinNum.context = Flt::BinNum::ExtendedContext
+  end
+
+  def tear_down
+    Flt::DecNum.context = @dec_context
+    Flt::BinNum.context = @bin_context
+  end
+
+  def test_special
+    assert Conversions.convert(Float::NAN, type: DecNum).nan?
+    assert Conversions.convert(Float::NAN, type: DecNum, exact: true).nan?
+    assert Conversions.convert(DecNum.context.nan, type: Float).nan?
+    assert_equal DecNum.context.infinity, Conversions.convert(Float::INFINITY, type: DecNum)
+    assert_equal Float::INFINITY, Conversions.convert(DecNum.context.infinity, type: Float)
+    assert_equal -DecNum.context.infinity, Conversions.convert(-Float::INFINITY, type: DecNum)
+    assert_equal -Float::INFINITY, Conversions.convert(-DecNum.context.infinity, type: Float)
+  end
+
+  def test_regular
+
+    x = 0.1
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, rounding:[:short], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, rounding:[:short], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, rounding:[:short], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, rounding:[:free], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, rounding:[:free], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, rounding:[:free], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 3602879701896397, -55], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 3602879701896397, -55], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 13421773, -27], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 53687091, -29], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 3602879701896397, -55], # 0.1
+      Conversions.convert(x, rounding:[:short], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 3602879701896397, -55], # 0.1
+      Conversions.convert(x, rounding:[:short], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, rounding:[:short], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 3602879701896397, -55], # 0.1
+      Conversions.convert(x, rounding:[:free], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, rounding:[:free], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, rounding:[:free], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 13421773, -27], # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 53687091, -29], # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      DecNum('0.1000000000000000055511151231257827021181583404541015625'),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1000000000000000055511151231257827021181583404541015625'),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.10000000'),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, rounding:[:short], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, rounding:[:short], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, rounding:[:short], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.10000000000000001'),
+      Conversions.convert(x, rounding:[:free], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.10000000000000001'),
+      Conversions.convert(x, rounding:[:free], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, rounding:[:free], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.10000000'),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      Rational(3602879701896397, 36028797018963968),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(3602879701896397, 36028797018963968),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(3602879701896397, 36028797018963968),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[:short], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[:short], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[:short], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(10000000000000001, 100000000000000000),
+      Conversions.convert(x, rounding:[:free], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(10000000000000001, 100000000000000000),
+      Conversions.convert(x, rounding:[:free], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(10000000000000001, 100000000000000000),
+      Conversions.convert(x, rounding:[:free], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :fixed, type: Rational)
+    )
+    x = 0.5
+    assert_same_number(
+      Float('0X1P-1'), # 0.5
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1P-1'), # 0.5
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1P-1'), # 0.5
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1P-1'), # 0.5
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1P-1'), # 0.5
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1P-1'), # 0.5
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1P-1'), # 0.5
+      Conversions.convert(x, rounding:[:short], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1P-1'), # 0.5
+      Conversions.convert(x, rounding:[:short], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1P-1'), # 0.5
+      Conversions.convert(x, rounding:[:short], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1P-1'), # 0.5
+      Conversions.convert(x, rounding:[:free], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1P-1'), # 0.5
+      Conversions.convert(x, rounding:[:free], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1P-1'), # 0.5
+      Conversions.convert(x, rounding:[:free], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1P-1'), # 0.5
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1P-1'), # 0.5
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1P-1'), # 0.5
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 1, -1], # 0.5
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 1, -1], # 0.5
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 4503599627370496, -53], # 0.5
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 1, -1], # 0.5
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 134217728, -28], # 0.5
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 4503599627370496, -53], # 0.5
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 1, -1], # 0.5
+      Conversions.convert(x, rounding:[:short], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 1, -1], # 0.5
+      Conversions.convert(x, rounding:[:short], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 4503599627370496, -53], # 0.5
+      Conversions.convert(x, rounding:[:short], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 1, -1], # 0.5
+      Conversions.convert(x, rounding:[:free], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 4503599627370496, -53], # 0.5
+      Conversions.convert(x, rounding:[:free], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 4503599627370496, -53], # 0.5
+      Conversions.convert(x, rounding:[:free], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 1, -1], # 0.5
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 134217728, -28], # 0.5
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 4503599627370496, -53], # 0.5
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      DecNum('0.5'),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.5'),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.500000000'),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.5'),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.50000000'),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.500000000'),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.5'),
+      Conversions.convert(x, rounding:[:short], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.5'),
+      Conversions.convert(x, rounding:[:short], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.500000000'),
+      Conversions.convert(x, rounding:[:short], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.5'),
+      Conversions.convert(x, rounding:[:free], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.50000000000000000'),
+      Conversions.convert(x, rounding:[:free], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.500000000'),
+      Conversions.convert(x, rounding:[:free], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.5'),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.50000000'),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.500000000'),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      Rational(1, 2),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 2),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 2),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 2),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 2),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 2),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 2),
+      Conversions.convert(x, rounding:[:short], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 2),
+      Conversions.convert(x, rounding:[:short], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 2),
+      Conversions.convert(x, rounding:[:short], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 2),
+      Conversions.convert(x, rounding:[:free], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 2),
+      Conversions.convert(x, rounding:[:free], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 2),
+      Conversions.convert(x, rounding:[:free], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 2),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 2),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 2),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :fixed, type: Rational)
+    )
+    x = Flt::BinNum('0.1', :fixed)
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, rounding:[:short], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, rounding:[:short], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, rounding:[:short], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, rounding:[:free], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, rounding:[:free], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, rounding:[:free], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 3602879701896397, -55], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 3602879701896397, -55], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 13421773, -27], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 53687091, -29], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 3602879701896397, -55], # 0.1
+      Conversions.convert(x, rounding:[:short], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 3602879701896397, -55], # 0.1
+      Conversions.convert(x, rounding:[:short], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, rounding:[:short], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 3602879701896397, -55], # 0.1
+      Conversions.convert(x, rounding:[:free], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, rounding:[:free], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, rounding:[:free], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 13421773, -27], # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 53687091, -29], # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      DecNum('0.1000000000000000055511151231257827021181583404541015625'),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1000000000000000055511151231257827021181583404541015625'),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.10000000'),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, rounding:[:short], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, rounding:[:short], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, rounding:[:short], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.10000000000000001'),
+      Conversions.convert(x, rounding:[:free], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.10000000000000001'),
+      Conversions.convert(x, rounding:[:free], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, rounding:[:free], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.10000000'),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      Rational(3602879701896397, 36028797018963968),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(3602879701896397, 36028797018963968),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(3602879701896397, 36028797018963968),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[:short], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[:short], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[:short], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(10000000000000001, 100000000000000000),
+      Conversions.convert(x, rounding:[:free], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(10000000000000001, 100000000000000000),
+      Conversions.convert(x, rounding:[:free], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(10000000000000001, 100000000000000000),
+      Conversions.convert(x, rounding:[:free], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :fixed, type: Rational)
+    )
+    x = Flt::BinNum('0.1', :free)
+    assert_same_number(
+      Float('0X1.AP-4'), # 0.1015625
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.AP-4'), # 0.1015625
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.AP-4'), # 0.1015625
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.AP-4'), # 0.1015625
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.AP-4'), # 0.1015625
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.AP-4'), # 0.1015625
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.AP-4'), # 0.1015625
+      Conversions.convert(x, rounding:[:short], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.AP-4'), # 0.1015625
+      Conversions.convert(x, rounding:[:short], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.AP-4'), # 0.1015625
+      Conversions.convert(x, rounding:[:short], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.AP-4'), # 0.1015625
+      Conversions.convert(x, rounding:[:free], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.AP-4'), # 0.1015625
+      Conversions.convert(x, rounding:[:free], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.AP-4'), # 0.1015625
+      Conversions.convert(x, rounding:[:free], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.A1CAC083126E9P-4'), # 0.102
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.A1CAC083126E9P-4'), # 0.102
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.A1CAC083126E9P-4'), # 0.102
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 13, -7], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 13, -7], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7318349394477056, -56], # 0.1015625
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 13, -7], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 27262976, -28], # 0.1015625
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7318349394477056, -56], # 0.1015625
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 13, -7], # 0.1
+      Conversions.convert(x, rounding:[:short], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 13, -7], # 0.1
+      Conversions.convert(x, rounding:[:short], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7318349394477056, -56], # 0.1015625
+      Conversions.convert(x, rounding:[:short], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 13, -7], # 0.1
+      Conversions.convert(x, rounding:[:free], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 26, -8], # 0.1
+      Conversions.convert(x, rounding:[:free], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7318349394477056, -56], # 0.1015625
+      Conversions.convert(x, rounding:[:free], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 13, -7], # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 209, -11], # 0.102
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7349874591868649, -56], # 0.102
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      DecNum('0.1015625'),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1015625'),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.101562500'),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1015625'),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.10156250'),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.101562500'),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, rounding:[:short], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, rounding:[:short], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, rounding:[:short], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.102'),
+      Conversions.convert(x, rounding:[:free], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.102'),
+      Conversions.convert(x, rounding:[:free], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.102000000'),
+      Conversions.convert(x, rounding:[:free], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.102'),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.102'),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.102000000'),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      Rational(13, 128),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(13, 128),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(13, 128),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(13, 128),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(13, 128),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(13, 128),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[:short], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[:short], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[:short], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(51, 500),
+      Conversions.convert(x, rounding:[:free], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(51, 500),
+      Conversions.convert(x, rounding:[:free], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(51, 500),
+      Conversions.convert(x, rounding:[:free], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(51, 500),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(51, 500),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(51, 500),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :fixed, type: Rational)
+    )
+    x = Flt::DecNum('0.1')
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1P-3'), # 0.125
+      Conversions.convert(x, rounding:[:short], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1P-3'), # 0.125
+      Conversions.convert(x, rounding:[:short], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1P-3'), # 0.125
+      Conversions.convert(x, rounding:[:short], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.AP-4'), # 0.1015625
+      Conversions.convert(x, rounding:[:free], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.AP-4'), # 0.1015625
+      Conversions.convert(x, rounding:[:free], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.AP-4'), # 0.1015625
+      Conversions.convert(x, rounding:[:free], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 13421773, -27], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 53687091, -29], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 1, -3], # 0.1
+      Conversions.convert(x, rounding:[:short], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 1, -3], # 0.1
+      Conversions.convert(x, rounding:[:short], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 4503599627370496, -55], # 0.125
+      Conversions.convert(x, rounding:[:short], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 13, -7], # 0.1
+      Conversions.convert(x, rounding:[:free], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 26, -8], # 0.1
+      Conversions.convert(x, rounding:[:free], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7318349394477056, -56], # 0.1015625
+      Conversions.convert(x, rounding:[:free], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 13, -7], # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 51, -9], # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.10000000'),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, rounding:[:short], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, rounding:[:short], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, rounding:[:short], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, rounding:[:free], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, rounding:[:free], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, rounding:[:free], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.10'),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[:short], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[:short], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[:short], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[:free], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[:free], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[:free], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :fixed, type: Rational)
+    )
+    x = Flt::DecNum('0.1000')
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.99CP-4'), # 0.10003662109375
+      Conversions.convert(x, rounding:[:short], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.99CP-4'), # 0.10003662109375
+      Conversions.convert(x, rounding:[:short], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.99CP-4'), # 0.10003662109375
+      Conversions.convert(x, rounding:[:short], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.9998P-4'), # 0.09999847412109375
+      Conversions.convert(x, rounding:[:free], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.9998P-4'), # 0.09999847412109375
+      Conversions.convert(x, rounding:[:free], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.9998P-4'), # 0.09999847412109375
+      Conversions.convert(x, rounding:[:free], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 13421773, -27], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 53687091, -29], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 1639, -14], # 0.10004
+      Conversions.convert(x, rounding:[:short], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 1639, -14], # 0.10004
+      Conversions.convert(x, rounding:[:short], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7208398231699456, -56], # 0.10003662109375
+      Conversions.convert(x, rounding:[:short], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 13107, -17], # 0.1
+      Conversions.convert(x, rounding:[:free], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 13107, -17], # 0.1
+      Conversions.convert(x, rounding:[:free], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205649452630016, -56], # 0.09999847412109375
+      Conversions.convert(x, rounding:[:free], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 26215, -18], # 0.100002
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 209715, -21], # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.10000000'),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, rounding:[:short], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, rounding:[:short], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, rounding:[:short], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, rounding:[:free], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1000'),
+      Conversions.convert(x, rounding:[:free], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, rounding:[:free], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.10000'),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[:short], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[:short], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[:short], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[:free], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[:free], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[:free], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :fixed, type: Rational)
+    )
+    x = Flt::DecNum('0.1000', :fixed)
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999AP-4'), # 0.10000000009313226
+      Conversions.convert(x, rounding:[:short], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999AP-4'), # 0.10000000009313226
+      Conversions.convert(x, rounding:[:short], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999AP-4'), # 0.10000000009313226
+      Conversions.convert(x, rounding:[:short], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.99999998P-4'), # 0.09999999997671694
+      Conversions.convert(x, rounding:[:free], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.99999998P-4'), # 0.09999999997671694
+      Conversions.convert(x, rounding:[:free], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.99999998P-4'), # 0.09999999997671694
+      Conversions.convert(x, rounding:[:free], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 13421773, -27], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 53687091, -29], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 214748365, -31], # 0.1
+      Conversions.convert(x, rounding:[:short], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 214748365, -31], # 0.1
+      Conversions.convert(x, rounding:[:short], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759410503680, -56], # 0.10000000009313226
+      Conversions.convert(x, rounding:[:short], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 858993459, -33], # 0.1
+      Conversions.convert(x, rounding:[:free], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 858993459, -33], # 0.1
+      Conversions.convert(x, rounding:[:free], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759402115072, -56], # 0.09999999997671694
+      Conversions.convert(x, rounding:[:free], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 13421773, -27], # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 53687091, -29], # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.10000000'),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, rounding:[:short], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, rounding:[:short], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, rounding:[:short], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, rounding:[:free], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, rounding:[:free], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, rounding:[:free], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.10000000'),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[:short], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[:short], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[:short], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[:free], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[:free], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[:free], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, rounding:[precision: 8], output_mode: :fixed, type: Rational)
+    )
+    x = Rational(1,10)
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.999999999999AP-4'), # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 13421773, -27], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 53687091, -29], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 7205759403792794, -56], # 0.1
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.1'),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.10000000'),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.100000000'),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 10),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Rational)
+    )
+    x = Rational(1,3)
+    assert_same_number(
+      Float('0X1.5555555555555P-2'), # 0.3333333333333333
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.5555555555555P-2'), # 0.3333333333333333
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.5555555555555P-2'), # 0.3333333333333333
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.5555551C112DAP-2'), # 0.33333333
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.5555551C112DAP-2'), # 0.33333333
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Float)
+    )
+    assert_same_number(
+      Float('0X1.5555551C112DAP-2'), # 0.33333333
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Float)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 6004799503160661, -54], # 0.3333333333333333
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 6004799503160661, -54], # 0.3333333333333333
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 6004799503160661, -54], # 0.3333333333333333
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 22369621, -26], # 0.33333333
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 89478484, -28], # 0.33333333
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Flt::BinNum)
+    )
+    assert_same_number(
+      Flt::BinNum[1, 6004799443112666, -54], # 0.33333333
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Flt::BinNum)
+    )
+    assert_same_number(
+      DecNum('0.333333333'),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.333333333'),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.333333333'),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.33333333'),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.33333333'),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Flt::DecNum)
+    )
+    assert_same_number(
+      DecNum('0.333333330'),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Flt::DecNum)
+    )
+    assert_same_number(
+      Rational(1, 3),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 3),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(1, 3),
+      Conversions.convert(x, exact_input: true, rounding:[:free], output_mode: :fixed, type: Rational)
+    )
+    assert_same_number(
+      Rational(33333333, 100000000),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :short, type: Rational)
+    )
+    assert_same_number(
+      Rational(33333333, 100000000),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :free, type: Rational)
+    )
+    assert_same_number(
+      Rational(33333333, 100000000),
+      Conversions.convert(x, exact_input: true, rounding:[precision: 8], output_mode: :fixed, type: Rational)
+    )
+
+
+  end
+
+
+
+end