float-formats 0.1.0

data/History.txt

@@ -0,0 +1,3 @@
+== 0.1.0 2007-11-04
+
+* Initial release

data/License.txt

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

data/Manifest.txt

@@ -0,0 +1,29 @@
+History.txt
+License.txt
+Manifest.txt
+README.txt
+Rakefile
+config/hoe.rb
+config/requirements.rb
+lib/float-formats.rb
+lib/float-formats/version.rb
+lib/float-formats/bytes.rb
+lib/float-formats/classes.rb
+lib/float-formats/formats.rb
+lib/float-formats/native.rb
+log/debug.log
+script/destroy
+script/destroy.cmd
+script/generate
+script/generate.cmd
+script/txt2html
+script/txt2html.cmd
+setup.rb
+tasks/deployment.rake
+tasks/environment.rake
+tasks/website.rake
+test/test_float-formats.rb
+test/test_helper.rb
+test/test_data.yaml
+test/gen_test_data.rb
+test/test_native-float.rb

data/README.txt

@@ -0,0 +1,211 @@
+=Introduction
+
+Float-Formats is a Ruby package with methods to handle diverse floating-point formats.
+These are some of the things that can be done with it:
+
+* Enconding and decoding numerical values in specific floating point representations.
+* Conversion of floating-point data between different formats.
+* Obtaining properties of floating-point formats (ranges, precision, etc.)
+* Exploring and learning about floating point representations.
+* Definition and testing of new floating-point formats.
+
+=Installation
+
+The easiest way to install Nio is using gems:
+
+<tt>  gem install --remote float-formats -y</tt>
+
+==Requirements
+
+Nio[http://nio.rubyforge.org/] 0.2.0 or later is needed. This 
+can be installed as a gem and should be automatically
+installed by the command shown above to install float-formats.
+
+
+==Downloads
+
+The latest version of Float-Formats and its source code can be downloaded from
+* http://rubyforge.org/project/showfiles.php?group_id=4684
+
+
+
+=Predefined formats
+
+A number of common formats are defined as constants in the FltPnt module:
+
+==IEEE
+<b>IEEE 754 binary</b> floating point representations in little endian order:
+IEEE_SINGLE, IEEE_DOUBLE, IEEE_EXTENDED, IEEE_128 and
+as little endian: IEEE_S_BE, IEEE_D_BE, IEEE_X_BE, IEEE_128_BE.
+Note that the standard defines extended formats with either 64 bits or precision
+(IEEE_EXTENDED, IEEE_X_BE) or 112 (IEEE_128, IEEE_128_BE).
+
+<b>IEEE 754r decimal</b> formats (using DPD): IEEE_DEC32, IEEE_DEC64 and IEEE_DEC128.
+
+==Legacy
+Formats of historical interest, some of which are found
+in file formats still in use.
+
+<b>Mainframe/supercomputer</b> formats:
+Univac 1100 (UNIVAC_SINGLE, UNIVAC_DOUBLE),
+IBM 360 etc. (IBM32, IBM64 and IBM128),
+CDC 6600/7600: (CDC_SINGLE, CDC_DOUBLE),
+Cray-1: (CRAY).
+
+<b>Minis</b>: PDP11 and Vaxes: (PDP11_F, PDP11_D, VAX_F, VAX_D, VAX_G and VAX_H),
+HP3000: (XS256, XS256_DOUBLE),
+Wang 2200: (WANG2200).
+
+<b>Microcomputers</b> (software implementations):
+Apple II: (APPLE),
+Microsoft Basic, Spectrum, etc.: (XS128),
+Microsoft Quickbasic: (MBF_SINGLE, MBF_DOUBLE),
+Borland Pascal: (BORLAND48).
+
+<b>Embedded systems</b>: 
+Formats used in the Intel 8051 by the C51 compiler:
+(C51_BCD_FLOAT, C51_BCD_DOUBLE and C51_BCD_LONG_DOUBLE).
+
+
+==Calculators
+Formats used in HP SATURN based calculators (RPL): (SATURN, SATURN_X),
+Classic HP 10 digit calculators: (HP_CLASSIC).
+
+
+
+=Using the pre-defined formats
+
+  require 'float-formats'
+  include FltPnt
+
+The properties of the floating point formats can be queried (which can be
+used for tables or reports comparing different formats):
+
+Size in bits of the representations:
+  puts IEEE_SINGLE.total_bits                        -> 32
+
+Numeric radix:
+  puts IEEE_SINGLE.radix                             -> 2
+
+Digits of precision (radix-based)
+  puts IEEE_SINGLE.significand_digits                -> 24
+
+Minimum and maximum values of the radix-based exponent:
+  puts IEEE_SINGLE.radix_min_exp                     -> -126
+  puts IEEE_SINGLE.radix_max_exp                     -> 127
+
+Decimal precision
+  puts IEEE_SINGLE.decimal_digits_stored             -> 6
+  puts IEEE_SINGLE.decimal_digits_necessary          -> 9
+
+Minimum and maximum decimal exponents:
+  puts IEEE_SINGLE.decimal_min_exp                   -> -37
+  puts IEEE_SINGLE.decimal_max_exp                   -> 38
+
+==Encode and decode numbers
+
+The <tt>from_</tt> methods of the floating-format classes generate a floating point value
+stored in a byte string from a variety of definitions:
+* <tt>from_integral_sign_significand_exponent</tt> defines the value by three integers:
+  the sign (0 for +, 1 for -), the significand (coefficient or mantissa)
+  and the exponent.
+* <tt>from_fmt</tt> : converts a text numeral (with an optional Nio format specifier)
+  to a floating point value
+* <tt>from_number</tt> : converts a numerical value
+  to a floating point representation.
+
+All these methods return an object of type Value that contains the encoded value (#bytes)
+and the Floating point format class (#fp_format).
+  
+  File.open('binary_file.dat','wb'){|f| f.write IEEE_EXTENDED.from_fmt('0.1').bytes}
+  
+  puts IEEE_EXTENDED.from_fmt('0.1').to_hex(true)    -> CD CC CC CC CC CC CC CC FB 3F
+  puts IEEE_EXTENDED.from_number(0.1).to_hex(true)   -> CD CC CC CC CC CC CC CC FB 3F
+  puts IEEE_EXTENDED.from_integral_sign_significand_exponent(0,123,-2).to_hex(true) -> 00 00 00 00 00 00 00 F6 03 40
+  puts IEEE_DEC32.from_fmt('1.234').to_hex(true)     -> 22 20 05 34
+
+A floating-point encoded value can be converted to useful formats wit the to_ methods:
+* <tt>to_integral_sign_significand_exponent</tt>
+* <tt>to_fmt</tt>
+* <tt>to_number</tt>
+
+  puts IEEE_EXTENDED.to_number(File.read('binary_file.dat'))
+  v = IEEE_EXTENDED.from_fmt('0.1')
+  puts v.to_integral_sign_significand_exponent.inspect
+  puts v.to_fmt
+  puts v.to_number(Float)
+    
+==Special values:  
+
+Let's show the decimal expression of some interesting values using
+3 significative digits:
+
+  fmt = Nio::Fmt.mode(:gen,3)  
+
+  puts IEEE_SINGLE.min_value.to_fmt(fmt)             -> 1.4E-45
+  puts IEEE_SINGLE.min_normalized_value.to_fmt(fmt)  -> 1.18E-38
+  puts IEEE_SINGLE.max_value.to_fmt(fmt)             -> 3.4E38
+  puts IEEE_SINGLE.epsilon.to_fmt(fmt)               -> 1.19E-7
+
+==Convert between formats
+
+  v = IEEE_EXTENDED.from_fmt('1.1')
+  v = v.convert_to(IEEE_SINGLE)
+  v = v.convert_to(IEEE_DEC64)
+  
+  
+=Tools for the native floating point format
+This is an optional module (must be loaded explicitely because
+is somewhat intrusive; it adds methods to Float)
+that useful to explore or manipulate the native Float format.
+  
+  require 'float-formats/native'
+  include FltPnt
+
+  puts float_shortest_dec(1.0.next)                  -> 1.0000000000000002
+  puts float_dec(1.0.prev)                           -> 0.99999999999999988897769753748434595763683319091796875
+  puts float_dec(1.0.next)                           -> 1.0000000000000002220446049250313080847263336181640625
+  puts float_dec(1.0.prev)                           -> 0.99999999999999988897769753748434595763683319091796875
+  puts float_bin(1.0.next)                           -> 1.0000000000000000000000000000000000000000000000000001E0
+  puts 1.0.next-1 == Float::EPSILON                  -> true
+  puts float_significant_dec(Float::MIN_D)           -> 5E-324
+  puts float_significant_dec(Float::MIN_D.next)      -> 1.0E-323
+  puts float_significant_dec(Float::MAX_D.prev)      -> 2.2250738585072004E-308
+  puts float_significant_dec(Float::MAX_D)           -> 2.2250738585072009E-308
+  puts float_significant_dec(Float::MIN_N)           -> 2.2250738585072014E-308
+  
+
+=Defining new formats
+
+New formats are defined using one of the classes defined in float-formats/classes.rb
+and passing the necessary parameters in a hash to the constructor.
+
+For example, here we define a binary floating point 32-bits format with 
+22 bits for the significand, 9 for the exponent and 1 for the sign
+(these fields are allocated from least to most significant bits).
+We'll use excess notation with bias 127 for the exponent, interpreting
+the significand bits as a fractional number with the radix point after
+the first bit, which will be hidden:
+  MY_FP = BinaryFormat.new(
+    :fields=>[:significand,22,:exponent,9,:sign,1],
+    :bias=>127, :bias_mode=>:normalized_significand,
+    :hidden_bit=>true)
+Now we can encode values in this format, decode values, convet to other
+formats, query it's range, etc:
+
+     puts MY_FP.from_fmt('0.1').to_bits_text(16)     -> 1ee66666
+     puts MY_FP.max_value.to_fmt(Nio::Fmt.prec(3))   -> 7.88E115
+  
+You can look at float-formats/formats.rb to see how the built-in formats
+are defined.
+
+=License
+
+This code is free to use under the terms of the GNU GENERAL PUBLIC LICENSE.
+
+=Contact
+
+Nio has been developed by Javier Goizueta (mailto:javier@goizueta.info).
+
+You can contact me through Rubyforge:http://rubyforge.org/sendmessage.php?touser=25432
+

data/Rakefile

@@ -0,0 +1,4 @@
+require 'config/requirements'
+require 'config/hoe' # setup Hoe + all gem configuration
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }

data/config/hoe.rb

@@ -0,0 +1,73 @@
+require 'float-formats/version'
+
+AUTHOR = 'Javier Goizueta'  # can also be an array of Authors
+EMAIL = "javier@goizueta.info"
+DESCRIPTION = "Floating-Point Formats"
+GEM_NAME = 'float-formats' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'float-formats' # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+
+@config_file = "C:/Documents and Settings/jgoizueta/.rubyforge/user-config.yml"
+@config = nil
+RUBYFORGE_USERNAME = "jgoizueta"
+def rubyforge_username
+  unless @config
+    begin
+      @config = YAML.load(File.read(File.expand_path(@config_file)))
+    rescue
+      puts <<-EOS
+ERROR: No rubyforge config file found: #{@config_file}
+Run 'rubyforge setup' to prepare your env for access to Rubyforge
+ - See http://newgem.rubyforge.org/rubyforge.html for more details
+      EOS
+      exit
+    end
+  end
+  RUBYFORGE_USERNAME.replace @config["username"]
+end
+
+
+REV = nil 
+# UNCOMMENT IF REQUIRED: 
+# REV = `svn info`.each {|line| if line =~ /^Revision:/ then k,v = line.split(': '); break v.chomp; else next; end} rescue nil
+VERS = FltPnt::VERSION::STRING + (REV ? ".#{REV}" : "")
+RDOC_OPTS = ['--quiet', '--title', 'float-formats documentation',
+    "--opname", "index.html",
+    "--line-numbers", 
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps 
+    @extra_deps.reject! { |x| Array(x).first == 'hoe' } 
+    @extra_deps
+  end 
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.author = AUTHOR 
+  p.description = DESCRIPTION
+  p.email = EMAIL
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/test_*.rb"]
+  p.clean_globs |= ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']  #An array of file patterns to delete on clean.
+  
+  # == Optional
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\\n\\n")
+  p.extra_deps = [
+    ['nio', '>=0.2.0']
+  ]
+  
+  #p.spec_extras = {}    # A hash of extra values to set in the gemspec.
+  
+end
+
+CHANGES = hoe.paragraphs_of('History.txt', 0..1).join("\\n\\n")
+PATH    = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
+hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')
+hoe.rsync_args = '-av --delete --ignore-errors'

data/config/requirements.rb

@@ -0,0 +1,17 @@
+require 'fileutils'
+include FileUtils
+
+require 'rubygems'
+%w[rake hoe newgem rubigen].each do |req_gem|
+  begin
+    require req_gem
+  rescue LoadError
+    puts "This Rakefile requires the '#{req_gem}' RubyGem."
+    puts "Installation: gem install #{req_gem} -y"
+    exit
+  end
+end
+
+$:.unshift(File.join(File.dirname(__FILE__), %w[.. lib]))
+
+require 'float-formats'

data/lib/float-formats.rb

@@ -0,0 +1,11 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'float-formats/version'
+require 'float-formats/bytes'
+require 'float-formats/classes'
+require 'float-formats/formats'
+
+# FltPnt contains constants for common floating point formats.
+module FltPnt
+  
+end

data/lib/float-formats/bytes.rb

@@ -0,0 +1,304 @@
+# Float-Formats
+# Support for binary data representations
+
+require 'nio'
+require 'nio/sugar'
+
+require 'enumerator'
+
+module FltPnt
+
+
+module_function
+
+# return an hex representation of a byte string
+def bytes_to_hex(sgl,sep_bytes=false)
+  hx = sgl.unpack('H*')[0].upcase
+  if sep_bytes
+    sep = ""
+    (0...hx.size).step(2) do |i|
+      sep << " " unless i==0
+      sep << hx[i,2]
+    end        
+    hx = sep
+  end
+  hx
+end
+   
+# generate a byte string from an hex representation
+def hex_to_bytes(hex)  
+  [hex.tr(' ','')].pack('H*')
+end
+  
+# ===== Byte string manipulation ==========================================================
+
+# Reverse the order of the bits in each byte.
+def reverse_byte_bits(b)
+  b.chr.unpack('b*').pack("B*")[0]
+end
+
+# Reverse the order of the nibbles in each byte.
+def reverse_byte_nibbles(v)
+  if v.kind_of?(String)
+    # ... reverse each byte
+    w = ""
+    v.each_byte do |b|
+      w << ((b >> 4)|((b&0xF)<<4))
+    end
+    v = w
+  else
+    # assume one byte
+    # from_hex(to_hex(v).reverse)
+    v = (v >> 4)|((v&0xF)<<4)
+  end
+  v
+end
+# reverse the order of bytes in 16-bit words
+def reverse_byte_pairs(b)
+    w = ""
+    (0...b.size).step(2) do |i|
+      w << b[i+1]
+      w << b[i]
+    end
+    w  
+end
+   
+# Supported endianness modes for byte strings are:
+# [<tt>:little_endian</tt>] (Intel order): least significant bytes come first.
+# [<tt>:big_endian</tt>] (Network order): most significant bytes come first.
+# [<tt>:little_big_endian</tt> or <tt>:middle_endian</tt>] (PDP-11 order): each pair of bytes
+#                                                          (16-bit word) has the bytes in little endian order, but the words
+#                                                          are stored in big endian order (we assume the number of bytes is even).
+# Note that the <tt>:big_little_endian</tt> order which would logically complete the set is
+# not currently supported as it has no known uses.
+def convert_endianness(byte_str, from_endianness, to_endianness)
+  if from_endianness!=to_endianness
+    if ([:little_endian,:big_endian]+[from_endianness, to_endianness]).uniq.size==2
+      # no middle_endian order
+      byte_str = byte_str.reverse
+    else
+      # from or to is middle_endian
+      if [:middle_endian, :little_big_endian].include?(to_endianness)
+        # from little_big_endian
+        byte_str = convert_endianness(byte_str, from_endianness, :big_endian)
+        byte_str = reverse_byte_pairs(byte_str)
+        # now swap the byte pairs            
+      else
+        # from little_big_endian
+        byte_str = reverse_byte_pairs(byte_str)
+        byte_str = convert_endianness(byte_str, :big_endian, to_endianness)      
+      end        
+    end
+  end
+  byte_str
+end
+
+# Binary data is handled here in three representations:
+#  as an Integer
+#  as a byte sequence (String) (with specific endianness)
+#  an an hex-string (nibble values) (with specific endianness)
+
+# Convert a byte string to an integer
+def bytes_to_int(bytes, byte_endianness=:little_endian, bits_little_endian=false)
+  i = 0
+  bytes = convert_endianness(bytes, byte_endianness, :big_endian)
+  bytes.each_byte do |b|
+    # reverse b is bits_little_endian
+    if bits_little_endian
+      b = reverse_byte_bits(b)
+    end    
+    i <<= 8
+    i |= b
+  end
+  i
+end
+
+# Convert an integer to a byte string
+def int_to_bytes(i, len=0, byte_endianness=:little_endian, bits_little_endian=false)
+  return nil if i<0
+  bytes = ""
+  while i>0
+    b = (i&0xFF)
+    if bits_little_endian
+      b = reverse_byte_bits(b)
+    end    
+    #puts "i=#{i} b<<#{b}"
+    bytes << b
+    i >>= 8
+  end
+  bytes << 0 while bytes.size<len
+  bytes = convert_endianness(bytes, :little_endian, byte_endianness)  
+  bytes
+end
+
+
+# convert a byte string to separate fixed-width bit-fields as integers
+def get_bitfields(bytes,lens,byte_endianness=:little_endian, bits_little_endian=false)
+  fields = []
+  i = bytes_to_int(bytes,byte_endianness,bits_little_endian)
+  for len in lens
+    mask = (1<<len)-1    
+    fields << (i&mask)
+    i >>= len
+  end
+  fields
+end
+
+# pack fixed-width bit-fields as integers into a byte string
+def set_bitfields(lens,fields,byte_endianness=:little_endian, bits_little_endian=false)
+  i = 0
+  lens = lens.reverse
+  fields = fields.reverse
+  
+  bits = 0
+        
+  (0...lens.size).each do |j|
+    i <<= lens[j]
+    i |= fields[j]    
+    bits += lens[j]
+  end  
+  int_to_bytes i,(bits+7)/8,byte_endianness, bits_little_endian
+end
+
+# DPD (Densely Packed Decimal) encoding
+
+# The bcd2dpd and dpd2bcd methods are adapted from Mike Cowlishaw's Rexx program:
+# (mfc 2000.10.03; Rexx version with new equations 2007.02.01)
+# available at http://www2.hursley.ibm.com/decimal/DPDecimal.html
+
+# Negate a bit. Auxiliar method for DPD conversions
+def bitnot(b)
+  (~b)&1
+end
+
+# Compress BCD to Densely Packed Decimal
+# 
+# adapted from Mike Cowlishaw's Rexx program:
+#   http://www2.hursley.ibm.com/decimal/DPDecimal.html
+def bcd2dpd(arg)
+  # assign each bit to a variable, named as in the description
+  a,b,c,d,e,f,g,h,i,j,k,m = ("%012B"%arg).split('').collect{|bit| bit.to_i}
+    
+  # derive the result bits, using boolean expressions only
+  #-- [the operators are: '&'=AND, '|'=OR, '\'=NOT.]
+  p=b | (a & j) | (a & f & i)
+  q=c | (a & k) | (a & g & i)
+  r=d
+  s=(f & (bitnot(a) | bitnot(i))) | (bitnot(a) & e & j) | (e & i)
+  t=g  | (bitnot(a) & e &k) | (a & i)
+  u=h
+  v=a | e | i
+  w=a | (e & i) | (bitnot(e) & j)
+  x=e | (a & i) | (bitnot(a) & k)
+  y=m
+  
+  # concatenate the bits and return
+    # result = [p,q,r,s,t,u,v,w,x,y].collect{|bit| bit.to_s}.inject{|aa,bb|aa+bb}.to_i(2)
+    result = 0
+    [p,q,r,s,t,u,v,w,x,y].each do |bit|
+      result <<= 1
+      result |= bit
+    end
+  result
+end
+
+# Expand Densely Packed Decimal to BCD
+# 
+# adapted from Mike Cowlishaw's Rexx program:
+#   http://www2.hursley.ibm.com/decimal/DPDecimal.html
+def dpd2bcd(arg)
+
+  # assign each bit to a variable, named as in the description
+  p,q,r,s,t,u,v,w,x,y = ("%010B"%arg).split('').collect{|bit| bit.to_i}
+
+  # derive the result bits, using boolean expressions only
+  a= (v & w) & (bitnot(s) | t | bitnot(x))
+  b=p & (bitnot(v) | bitnot(w) | (s & bitnot(t) & x))
+  c=q & (bitnot(v) | bitnot(w) | (s & bitnot(t) & x))
+  d=r
+  e=v & ((bitnot(w) & x) | (bitnot(t) & x) | (s & x))
+  f=(s & (bitnot(v) | bitnot(x))) | (p & bitnot(s) & t & v & w & x)
+  g=(t & (bitnot(v) | bitnot(x))) | (q & bitnot(s) & t & w)
+  h=u
+  i=v & ((bitnot(w) & bitnot(x)) | (w & x & (s | t)))
+  j=(bitnot(v) & w) | (s & v & bitnot(w) & x) | (p & w & (bitnot(x) | (bitnot(s) & bitnot(t))))
+  k=(bitnot(v) & x) | (t & bitnot(w) & x) | (q & v & w & (bitnot(x) | (bitnot(s) & bitnot(t))))
+  m=y
+  # concatenate the bits and return
+  # result = [a,b,c,d,e,f,g,h,i,j,k,m].collect{|bit| bit.to_s}.inject{|aa,bb|aa+bb}.to_i(2)
+    result = 0
+    [a,b,c,d,e,f,g,h,i,j,k,m].each do |bit|
+      result <<= 1
+      result |= bit
+    end
+  result
+end
+
+# Pack a bcd digits string into DPD
+def hexbcd_to_dpd(bcd, endianness=:big_endian)
+    
+  n = bcd.size
+  dpd = 0
+  dpd_bits = 0
+  
+  i = 0
+  m = n%3
+  if m>0
+    v = bcd2dpd(bcd[0,m].to_i(16))
+    i += m
+    n -= m
+    bits = m==1 ? 4 : 7
+    dpd_bits += bits
+    dpd <<= bits
+    dpd |= v
+  end
+
+  while n>0
+    v = bcd2dpd(bcd[i,3].to_i(16))
+    i += 3
+    n -= 3
+    bits = 10
+    dpd_bits += bits
+    dpd <<= bits
+    dpd |= v
+  end
+
+  [dpd, dpd_bits]
+end
+
+# Unpack DPD digits
+def dpd_to_hexbcd(dpd, dpd_bits, endianness=:big_endian)
+  
+  bcd = ""
+
+  while dpd_bits>=10
+    v = dpd2bcd(dpd & 0x3FF)
+    dpd >>= 10
+    dpd_bits -= 10
+    bcd = ("%03X"%v)+bcd
+  end
+
+  if dpd_bits>0
+    case dpd_bits
+      when 4
+        v = dpd & 0xF
+        n = 1
+      when 7
+        v = dpd & 0x7F
+        n = 2
+      else
+        raise "Invalid DPD data"       
+    end
+    v = dpd2bcd(v,true)
+    bcd = ("%0#{n}X"%v)+bcd  
+  end
+
+  bcd = bcd.reverse if endianness==:little_endian
+
+  bcd
+
+end  
+
+
+
+end