Class: Flt::BCDFormat

Inherits:

DecimalFormatBase

• Object
• FormatBase
• DecimalFormatBase
• Flt::BCDFormat

Defined in:

lib/float-formats/classes.rb

Overview

BCD (Binary-Coded-Decimal) floating point formats

Direct Known Subclasses

C51BCDFormat

Constant Summary

Constants included from Flt

APPLE, IEEE_128, IEEE_128_BE, IEEE_DEC128, IEEE_DEC32, IEEE_DEC64, IEEE_DOUBLE, IEEE_D_BE, IEEE_EXTENDED, IEEE_HALF, IEEE_H_BE, IEEE_QUAD, IEEE_Q_BE, IEEE_SINGLE, IEEE_S_BE, IEEE_X_BE, IEEE_binaryx, RPL, RPL_X

Instance Attribute Summary

Attributes inherited from FormatBase

#exponent, #sign, #significand

Class Method Summary

• .bcd_field?(i) ⇒ Boolean

  this has beed added to allow some fields to contain binary integers rather than bcd.

• .define(params) ⇒ Object

  The fields lengths are defined in decimal digits.

• .pack(s, m, e) ⇒ Object
• .pack_fields(*fields) ⇒ Object
• .total_bits ⇒ Object
• .total_bytes ⇒ Object
• .total_nibbles ⇒ Object

  :stopdoc:.

• .unpack(v) ⇒ Object

  assume @exponent_mode==:radix_complement.

• .unpack_fields(v) ⇒ Object

Methods inherited from DecimalFormatBase

decimal_digits_necessary, decimal_digits_stored, decimal_max_exp, decimal_min_exp, radix, radix_log, radix_log10, radix_power

Methods inherited from FormatBase

#<=>, arithmetic, arithmetic_type, bias, canonicalized, context, #convert_to, decimal_digits_necessary, decimal_digits_stored, decimal_max_exp, decimal_min_exp, endianness, epsilon, #form_class, #fp_format, from, from_bits, from_bits_text, from_bytes, from_hex, from_number, from_text, gradual_underflow?, half_epsilon, #infinite?, infinity, #initialize, join, max_value, maximum_integral_significand, min_normalized_value, min_value, minimum_normalized_integral_significand, #minus, minus_sign_value, nan, #nan?, #next_minus, #next_plus, #normal?, num, num_class, numerals_conversion, pack_fields_hash, radix_log, radix_log10, radix_max_exp, radix_min_exp, radix_power, rounding_mode, sign_from_unit, sign_to_unit, #split, strict_epsilon, #subnormal?, switch_sign_value, #to, #to_a, #to_bits, #to_bits_text, #to_bytes, #to_hex, #to_num, #to_text, #ulp, unpack_fields_hash, zero, #zero?

Methods included from Flt

#*, #+, #-, #-@, #/, bcd2dpd, bitnot, convert_bytes, dbl_from_float, dbl_from_text, dbl_to_float, dpd2bcd, dpd_to_hexbcd, float_bin, float_dec, float_from_integral_sign_significand_exponent, float_from_integral_significand_exponent, float_shortest_dec, float_significant_dec, float_to_integral_sign_significand_exponent, float_to_integral_significand_exponent, hex_from_float, hex_to_float, hexbcd_to_dpd, sgl_from_float, sgl_from_text, sgl_to_float

Constructor Details

This class inherits a constructor from Flt::FormatBase

Class Method Details

.bcd_field?(i) ⇒ Boolean

this has beed added to allow some fields to contain binary integers rather than bcd

Returns:

• (Boolean)

# File 'lib/float-formats/classes.rb', line 1214

def self.bcd_field?(i)
  true
end

.define(params) ⇒ Object

The fields lengths are defined in decimal digits

# File 'lib/float-formats/classes.rb', line 1151

def self.define(params)

  @splitted_fields_supported = false
  define_fields params[:fields]

  @significand_digits = @fields[:significand]
  super  params

end

.pack(s, m, e) ⇒ Object

# File 'lib/float-formats/classes.rb', line 1243

def self.pack(s,m,e)
  msb = radix_power(@significand_digits-1)
  if e==:zero
    e = @zero_encoded_exp
    m = 0
  elsif e==:infinity
    e = @infinite_encoded_exp || radix_power(@fields[:exponent])-1
    m = 0
  elsif e==:nan
    e = @nan_encoded_exp || radix_power(@fields[:exponent])-1
    #s = -1 # ?
    #m = radix_power(@significand_digits-2) if m==0
  elsif e==:denormal
    e = @denormal_encoded_exp
  else
    # TODO: try to adjust m to keep e in range if out of valid range
    # TODO: reduce m and adjust e if m too big

    min_exp = radix_min_exp(:integral_significand)
    if m>0
      while m<msb && e>min_exp
        e -= 1
        m *= radix
      end
    end
    if m<msb && @denormal_encoded_exp
      e = @denormal_encoded_exp
    elsif m==0 # => && @denormal_encoded_exp.nil?
      e = 0
    else
      e = encode_exponent(e, :integral_significand)
    end
  end
  s = sign_from_unit(s)
  m,e = neg_significand_exponent(0,m,e) if s%2==1
  pack_fields_hash sign: s, significand: m, exponent: e
end

.pack_fields(*fields) ⇒ Object

# File 'lib/float-formats/classes.rb', line 1197

def self.pack_fields(*fields)
  fields = fields[0] if fields.size==1 and fields[0].kind_of?(Array)
  handle_fields fields
  i = 0
  nibbles = ""
  for l in @field_lengths
    f = fields[i]
    unless f.kind_of?(String)
      fmt = bcd_field?(i) ? 'd' : 'X'
      f = "%0#{l}#{fmt}" % fields[i]
    end
    nibbles << f.reverse
    i += 1
  end
  Bytes.from_hex(nibbles).reverse_byte_nibbles.convert_endianness(:little_endian,@endianness)
end

.total_bits ⇒ Object

# File 'lib/float-formats/classes.rb', line 1167

def self.total_bits
  4*total_nibbles
end

.total_bytes ⇒ Object

# File 'lib/float-formats/classes.rb', line 1164

def self.total_bytes
  (total_nibbles+1)/2
end

.total_nibbles ⇒ Object

:stopdoc:

# File 'lib/float-formats/classes.rb', line 1161

def self.total_nibbles
  @field_lengths.inject{|x,y| x+y}
end

.unpack(v) ⇒ Object

assume @exponent_mode==:radix_complement

# File 'lib/float-formats/classes.rb', line 1220

def self.unpack(v)
  f = unpack_fields_hash(v)
  m = f[:significand]
  e = f[:exponent]
  s = f[:sign]
  m,e = neg_significand_exponent(s,m,e) if s%2==1
  s = sign_to_unit(s)
  if @infinite_encoded_exp && e==@infinite_encoded_exp
    # +-infinity
    e = :infinity
  elsif @nan_encoded_exp && e==@nan_encoded_exp
    # NaN
    e = :nan
  elsif m==0
    # +-zero
    e = :zero
  else
    # normalized number
      e = decode_exponent(e, :integral_significand)
  end
  [s,m,e]
end

.unpack_fields(v) ⇒ Object

# File 'lib/float-formats/classes.rb', line 1171

def self.unpack_fields(v)
  # bytes have always nibbles in big-endian order
  v = input_bytes(v).convert_endianness(@endianness,:little_endian).reverse_byte_nibbles
  nibbles = v.to_hex
  # now we have a little endian nibble string
  nibble_fields = []
  i = 0
  for l in @field_lengths
    nibble_fields << nibbles[i,l]
    i += l
  end
  # now we conver the nibble strings to numbers
  i = -1
  nibble_fields.collect do |ns|
    i+=1
    if bcd_field?(i)
      if /\A\d+\Z/.match(ns)
        ns.reverse.to_i
      else
        ns.reverse
      end
    else
      ns.reverse.to_i(16)
    end
  end
end