float-formats 0.1.0 → 0.1.1

data/History.txt

@@ -1,3 +1,35 @@
+== 0.1.1 2007-12-15
+
+*  HP-71B formats defined
+
+*  Add half precision IEEE format (binary16)
+
+*  New names for IEEE formats
+
+*  Add some IEEE 754r interchange formats
+
+*  new methods hex_to_float, hex_from_float in float-formats/native
+
+*  Allow non-bcd values in fields of BCD formats by passing
+   hex values as Strings; allow such values to be used for 
+   nan/infinity exponents.
+
+*  Nio 0.2.1 is now required
+
+*  Handle special values (Infinities and NaN) in #from_fmt, #from_number
+
+*  Add ulp methods to Value and FP classes and to Float
+   
+*  Bug fixes
+    - Fix the encoding-decoding of nan and infinity in Decimal format.
+    - Fix the decoding of NaN in Binary & Hexadecimal
+    - The definition of IEEE_binary128 was not correct
+    - In formats such as XS256 where the minimum exponent is not used only for zero
+      and there is a hidden bit, then minimum nonzero significand is radix*(prec-1)+1
+      rather than radix*(prec-1); the latter value could be computed in ratio_float
+      and then packed in the representation, being replaced by zero. This would
+      result in an incorrect encoding of the minimum nonzero value.
+
 == 0.1.0 2007-11-04
 
 * Initial release

data/Manifest.txt

@@ -11,7 +11,6 @@ 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

data/README.txt

@@ -33,14 +33,22 @@ The latest version of Float-Formats and its source code can be downloaded from
 
 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).
+==IEEE 754r
+<b>binary</b> floating point representations in little endian order:
+IEEE_binary16 (half precision), 
+IEEE_binary32 (single precision),
+IEEE_binary64 (double precision),
+IEEE_binary80 (extended), IEEE_binary128 (quadruple precision) and
+as little endian: IEEE_binary16_BE, etc.
+
+<b>decimal</b> formats (using DPD): 
+IEEE_decimal32, IEEE_decimal64 and IEEE_decimal128.
+
+<b>interchange binary & decimal</b> formats: 
+IEEE_binary256, IEEE_binary512, IEEE_binary1024, IEEE_decimal192, IEEE_decimal256.
+Others can be defined with IEEE.interchange_binary and IEEE.interchange_decimal
+(see the IEEE module).
 
-<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
@@ -68,13 +76,14 @@ Formats used in the Intel 8051 by the C51 compiler:
 
 
 ==Calculators
-Formats used in HP SATURN based calculators (RPL): (SATURN, SATURN_X),
-Classic HP 10 digit calculators: (HP_CLASSIC).
-
+Formats used in HP RPL calculators: (RPL, RPL_X),
+HP-71B formats (HP71B, HP71B_X)
+and classic HP 10 digit calculators: (HP_CLASSIC).
 
 
 =Using the pre-defined formats
 
+  require 'rubygems'
   require 'float-formats'
   include FltPnt
 
@@ -209,3 +218,110 @@ Nio has been developed by Javier Goizueta (mailto:javier@goizueta.info).
 
 You can contact me through Rubyforge:http://rubyforge.org/sendmessage.php?touser=25432
 
+=References
+
+
+[<i>Floating Point Representations.</i> C.B. Silio.]
+  http://www.ece.umd.edu/class/enpm607.S2000/fltngpt.pdf  
+  Description of formats used in UNIVAC 1100, CDC 6600/7600, PDP-11, IEEE754, IBM360/370
+  
+[<i>Floating-Point Formats.</i> John Savard.]  
+  http://www.quadibloc.com/comp/cp0201.htm
+  Description of formats used in VAX and PDF-11
+
+
+===IEEE754 binary formats
+[<i>IEEE-754 References.</i> Christopher Vickery.]
+  http://babbage.cs.qc.edu/courses/cs341/IEEE-754references.html
+
+[<i>What Every Computer Scientist Should Know About Floating-Point Arithmetic.</i> David Goldberg.]
+  http://docs.sun.com/source/806-3568/ncg_goldberg.html
+
+
+===DPD/IEEE754r decimal formats
+[<i>Decimal Arithmetic Encoding. Strawman 4d.</i> Mike Cowlishaw.]
+  http://www2.hursley.ibm.com/decimal/decbits.pdf
+
+[<i>A Summary of Densely Packed Decimal encoding.</i> Mike Cowlishaw.]
+  http://www2.hursley.ibm.com/decimal/DPDecimal.html
+  
+[<i>Packed Decimal Encoding IEEE-754-r.</i> J.H.M. Bonten.]
+  http://home.hetnet.nl/mr_1/81/jhm.bonten/computers/bitsandbytes/wordsizes/ibmpde.htm
+
+[<i>DRAFT Standard for Floating-Point Arithmetic P754.</i> IEEE.]
+  http://www.validlab.com/754R/drafts/archive/2007-10-05.pdf
+  
+
+
+===HP 10 digits calculators
+
+[<i>HP CPU and Programming</i>. David G.Hicks.]
+  http://www.hpmuseum.org/techcpu.htm  Description of calculator CPUs from the Museum of HP Calculators.
+[<i>HP 35 ROM step by step.</i> Jacques Laporte]
+  http://www.jacques-laporte.org/HP35%20ROM.htm
+  Description of HP35 registers.
+[<i>Scientific Pocket Calculator Extends Range of Built-In Functions.</i> Eric A. Evett, Paul J. McClellan, Joseph P. Tanzini.]
+  Hewlett Packard Journal 1983-05 pgs 27-28. Describes format used in HP-15C.
+
+
+===HP 12 digits calculators
+[<i>Software Internal Design Specification Volume I For the HP-71</i>. Hewlett Packard.]
+  Available from http://www.hpmuseum.org/cd/cddesc.htm
+[<i>RPL PROGRAMMING GUIDE</i>]
+  Excerpted from <i>RPL: A Mathematical Control Language</i>. by W. C. Wickes.
+  Available at http://www.hpcalc.org/details.php?id=1743
+
+===HP-3000
+[<i>A Pocket Calculator for Computer Science Professionals.</i> Eric A. Evett.]
+  Hewlett Packard Journal 1983-05 pg 37. Describes format used in HP-3000
+
+===IBM
+[<i>IBM Floating Point Architecture.</i> Wikipedia.]
+  http://en.wikipedia.org/wiki/IBM_Floating_Point_Architecture
+[<i>The IBM eServer z990 floating-point unit</i>. G. Gerwig, H. Wetter, E. M. Schwarz, J. Haess, C. A. Krygowski, B. M. Fleischer and M. Kroener.]
+  http://www.research.ibm.com/journal/rd/483/gerwig.html
+  
+===MBF  
+[<i>Microsoft Knowledbase Article 35826</i>]
+  http://support.microsoft.com/?scid=kb%3Ben-us%3B35826&x=17&y=12
+[<i>Microsoft MBF2IEEE library</i>]
+  http://download.microsoft.com/download/vb30/install/1/win98/en-us/mbf2ieee.exe
+
+===Borland
+[<i>An Overview of Floating Point Numbers.</i> Borland Developer Support Staff]
+
+[<i>Pascal Floating-Point Page.<i> J R Stockton.]
+  http://www.merlyn.demon.co.uk/pas-real.htm
+
+===8-bit micros
+This is the MS Basic format (BASIC09 for TRS-80 Color Computer, Dragon),
+also used in the Sinclair Spectrum.
+
+[<i>Numbers are followed by information not in listings</i>]
+  Sinclair User October 1983 http://www.sincuser.f9.co.uk/019/helplne.htm
+
+[<i>Sinclair ZX Spectrum / Basic Programming.</i>. Steven Vickers.]
+  Chapter 24. http://www.worldofspectrum.org/ZXBasicManual/zxmanchap24.html
+
+
+
+===Apple II
+[<i>Floating Point Routines for the 6502</i> Roy Rankin and Steve Wozniak.]
+  Dr. Dobb's Journal, August 1976, pages 17-19.
+
+===C51
+[<i>Advanced Development System</i> Franklin Software, Inc.]
+  http://www.fsinc.com/reference/html/com9anm.htm
+
+===CDC6600
+[<i>CONTROL DATA 6400/6500/6600 COMPUTER SYSTEMS Reference Manual</i>]
+  Manuals available at http://bitsavers.org/
+ 
+
+===Cray
+[<i>CRAY-1 COMPUTER SYSTEM Hardware Reference Manual</i>]
+  See pg 3-20 from 2240004 or pg 4-30 from HR-0808 or pg 4-21 from HP-0032.
+  Manuals available at http://bitsavers.org/
+
+===Wang 2200
+[<i>Internal Floating Point Representation</i>] http://www.wang2200.org/fp_format.html

data/config/hoe.rb

@@ -60,7 +60,7 @@ hoe = Hoe.new(GEM_NAME, VERS) do |p|
   # == Optional
   p.changes = p.paragraphs_of("History.txt", 0..1).join("\\n\\n")
   p.extra_deps = [
-    ['nio', '>=0.2.0']
+    ['nio', '>=0.2.1']
   ]
   
   #p.spec_extras = {}    # A hash of extra values to set in the gemspec.

data/lib/float-formats.rb

@@ -7,5 +7,4 @@ require 'float-formats/formats'
 
 # FltPnt contains constants for common floating point formats.
 module FltPnt
-  
-end
+end

data/lib/float-formats/classes.rb

@@ -97,12 +97,12 @@ class FormatBase
     @max_encoded_exp = params[:max_encoded_exp] || @exponent_radix**@fields[:exponent]-1 # maximum regular exponent, encoded
     if @infinity      
       @infinite_encoded_exp = @nan_encoded_exp || @max_encoded_exp if !@infinite_encoded_exp
-      @max_encoded_exp = @infinite_encoded_exp - 1 if @infinite_encoded_exp<=@max_encoded_exp
+      @max_encoded_exp = @infinite_encoded_exp - 1 if @infinite_encoded_exp.kind_of?(Integer) && @infinite_encoded_exp<=@max_encoded_exp
     end
     @nan = params[:nan] || (@nan_encoded_exp ? true : false)
     if @nan
       @nan_encoded_exp = @infinite_encoded_exp || @max_encoded_exp if !@nan_encoded_exp
-      @max_encoded_exp = @nan_encoded_exp - 1 if @nan_encoded_exp<=@max_encoded_exp
+      @max_encoded_exp = @nan_encoded_exp - 1 if @nan_encoded_exp.kind_of?(Integer) && @nan_encoded_exp<=@max_encoded_exp
     end
         
     @exponent_mode = params[:exponent_mode]
@@ -411,7 +411,15 @@ class FormatBase
   # Produce an encoded floating point value using a number defined by a
   # formatted text string (using Nio formats). Returns a Value.
   def from_fmt(txt,fmt=Nio::Fmt.default)    
-       neutral = fmt.nio_read_formatted(txt)       
+       neutral = fmt.nio_read_formatted(txt)
+       if neutral.special?
+          case neutral.special
+            when :nan
+              return nan
+            when :inf
+              return infinity(neutral.sign=='-' ? minus_sign_value : 0)
+          end
+       end
        if neutral.rep_pos<neutral.digits.length
          nd = fmt.get_base==10 ? decimal_digits_necessary : (significand_digits*Math.log(radix)/Math.log(fmt.get_base)).ceil+1
          fmt = fmt.mode(:sig,nd)
@@ -531,7 +539,7 @@ class FormatBase
   # Computes the next adjacent floating point value.
   # Accepts either a Value or a byte String.
   # Returns a Value.  
-  def next_float(v)    
+  def next_float(v)   
     s,f,e = to_integral_sign_significand_exponent(v)
     return neg(prev_float(neg(v))) if s!=0 && e!=:zero
     s = switch_sign_value(s) if e==:zero && s!=0
@@ -584,6 +592,27 @@ class FormatBase
       from_integral_sign_significand_exponent(s,f,e)
     end
   end      
+  
+  # ulp (unit in the last place) according to the definition proposed by J.M. Muller in
+  # "On the definition of ulp(x)" INRIA No. 5504
+  def ulp(v)
+    sign,sig,exp = to_integral_sign_significand_exponent(v)
+        
+    mnexp = radix_min_exp(:integral_significand)
+    mxexp = radix_max_exp(:integral_significand)
+    prec = significand_digits
+      
+    if exp==:nan
+      return_bytes v
+    elsif exp==:infinity
+      from_integral_sign_significand_exponent(1,1,mxexp) # from_integral_sign_significand_exponent(1,fmt.radix_power(prec-1),mxexp-prec+1)    
+    elsif exp==:zero || exp <= mnexp
+      min_value
+    else
+      exp -= 1 if sig==radix_power(prec-1) # minimum normalized significand      
+      from_integral_sign_significand_exponent(1,1,exp)
+    end 
+  end
       
   # Produce an encoded floating point value from the integral value
   # of the sign, significand and exponent.
@@ -607,6 +636,7 @@ class FormatBase
       when :normalized_significand
         m = Rational(m,radix_power(@significand_digits-1))
     end
+    [s,m,e]
   end  
   
   # Returns the encoded value of a floating-point number as an integer
@@ -802,14 +832,17 @@ class FormatBase
     v_r = v-r
     z = from_integral_sign_significand_exponent(0,q,k)
     if r<v_r
-      z
     elsif r>v_r
-      z = next_float(z)
+      q += 1
     elsif (round_mode==:even && q.even?) || (round_mode==:zero)
-      z
     else
-      z = next_float(z)
+      q += 1
+    end
+    if q==radix_power(significand_digits)
+      q = radix_power(significand_digits-1)
+      k += 1
     end
+    from_integral_sign_significand_exponent(0,q,k)
   end
   
   def algM(f,e,round_mode,eb=10)
@@ -935,7 +968,18 @@ class BCDFormat < DecimalFormatBase
     end
     # now we conver the nibble strings to numbers
     i = -1
-    nibble_fields.collect{|ns| i+=1;bcd_field?(i) ? ns.reverse.to_i : ns.reverse.to_i(16)}
+    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
   def from_fields(*fields)    
     fields = fields[0] if fields.size==1 and fields[0].kind_of?(Array)
@@ -943,8 +987,12 @@ class BCDFormat < DecimalFormatBase
     i = 0
     nibbles = ""
     for l in @field_lengths
-      fmt = bcd_field?(i) ? 'd' : 'X'
-      nibbles << ("%0#{l}#{fmt}" % fields[i]).reverse
+      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
     v = hex_to_bytes(nibbles)
@@ -964,15 +1012,15 @@ class BCDFormat < DecimalFormatBase
     e = f[:exponent]
     s = f[:sign]
     m,e = neg_significand_exponent(s,m,e) if s%2==1
-    if m==0
-      # +-zero
-      e = :zero
-    elsif @infinite_encoded_exp && e==@infinite_encoded_exp && m==0
-      # +-inifinity
+    if @infinite_encoded_exp && e==@infinite_encoded_exp
+      # +-infinity
       e = :infinity
-    elsif @nan_encoded_exp && e==@nan_encoded_exp && m!=0 
+    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)
@@ -989,11 +1037,11 @@ class BCDFormat < DecimalFormatBase
       e = @infinite_encoded_exp || radix_power(@fields[:exponent])-1
       m = 0
     elsif e==:nan
-      e = @infinite_encoded_exp || radix_power(@fields[:exponent])-1
-      s = minus_sign_value # ?
-      m = radix_power(@significand_digits-2) if m==0
+      e = @nan_encoded_exp || radix_power(@fields[:exponent])-1
+      #s = minus_sign_value # ?
+      #m = radix_power(@significand_digits-2) if m==0
     elsif e==:denormal
-      e = @denormal_encoded_exp      
+      e = @denormal_encoded_exp    
     else
       # to do: try to adjust m to keep e in range if out of valid range
       # to do: reduce m and adjust e if m too big
@@ -1173,7 +1221,6 @@ class DPDFormat < DecimalFormatBase
 
   def from_integral_sign_significand_exponent(s,m,e)
     msb = radix_power(@significand_digits-1)
-    #puts "DEC FROM #{s} #{m} #{e}"
     t = nil
     if e==:zero
       e = @zero_encoded_exp
@@ -1307,7 +1354,7 @@ class BinaryFormat < FieldsInBitsFormatBase
       e = @infinite_encoded_exp || radix_power(@fields[:exponent])-1
       m = 0
     elsif e==:nan
-      e = @infinite_encoded_exp || radix_power(@fields[:exponent])-1
+      e = @nan_encoded_exp || radix_power(@fields[:exponent])-1
       s = minus_sign_value # ?
       m = radix_power(@significand_digits-2) if m==0
     elsif e==:denormal
@@ -1399,7 +1446,7 @@ class HexadecimalFormat < FieldsInBitsFormatBase
       e = @infinite_encoded_exp || radix_power(@fields[:exponent])-1
       m = 0
     elsif e==:nan
-      e = @infinite_encoded_exp || radix_power(@fields[:exponent])-1
+      e = @nan_encoded_exp || radix_power(@fields[:exponent])-1
       s = minus_sign_value # ?
       m = radix_power(@significand_digits-2) if m==0
     elsif e==:denormal
@@ -1524,6 +1571,14 @@ class Value
     self.class.new(@fptype, @fptype.prev_float(@value))
   end  
   
+  def neg
+    @fptype.neg(@value)
+  end
+  
+  def ulp
+    @fptype.ulp(@value)    
+  end
+  
   def fp_format
     @fptype
   end

data/lib/float-formats/formats.rb

@@ -14,84 +14,114 @@ module FltPnt
 
 # Floating Point Format Definitions ==========================================
 
+# Helper methods to define IEEE 754r formats
+module IEEE
+  # Define an IEEE binary format by passing parameters in a hash;
+  # :significand and :exponent are used to defined the fields,
+  # optional parameters may follow.
+  def self.binary(parameters)
+    significand_bits = parameters[:significand]
+    exponent_bits = parameters[:exponent]
+    BinaryFormat.new({
+      :fields=>[:significand,significand_bits,:exponent,exponent_bits,:sign,1], 
+      :bias=>2**(exponent_bits-1)-1, :bias_mode=>:normalized_significand,
+      :hidden_bit=>true,
+      :endianness=>:little_endian, :round=>:even,
+      :gradual_underflow=>true, :infinity=>true, :nan=>true
+    }.merge(parameters))
+  end
+  
+  # Define an IEEE binary interchange format given its width in bits
+  def self.interchange_binary(width_in_bits, options={})
+    raise "Invalid IEEE binary interchange format definition: size (#{width_in_bits}) is not valid" unless (width_in_bits%32)==0 && (width_in_bits/32)>=4
+    p = width_in_bits - (4*Math.log(width_in_bits)/Math.log(2)).round.to_i + 13
+    binary({:significand=>p-1, :exponent=>width_in_bits-p}.merge(options))
+  end    
+  
+  # Define an IEEE decimal format by passing parameters in a hash;
+  # :significand and :exponent are used to defined the fields,
+  # optional parameters may follow.
+  def self.decimal(parameters)
+    significand_continuation_bits = parameters[:significand]
+    exponent_continuation_bits = parameters[:exponent]
+    DPDFormat.new({
+      :fields=>[:significand_continuation,significand_continuation_bits,:exponent_continuation,exponent_continuation_bits,:combination,5,:sign,1],
+      :endianness=>:big_endian,
+      :gradual_underflow=>true, :infinity=>true, :nan=>true
+    }.merge(parameters))
+  end
+
+  # Define an IEEE decimal interchange format given its width in bits
+  def self.interchange_decimal(width_in_bits, options={})
+    raise "Invalid IEEE decimal interchange format definition: size (#{width_in_bits}) is not valid" unless (width_in_bits%32)==0
+    p = width_in_bits*9/32 - 2
+    t = (p-1)*10/3
+    w = width_in_bits - t - 6
+    decimal({:significand=>t, :exponent=>w}.merge(options))
+  end    
+
+end
+
 # IEEE 754 binary types, as stored in little endian architectures such as Intel, Alpha
 
-IEEE_SINGLE = BinaryFormat.new(
-  :fields=>[:significand,23,:exponent,8,:sign,1], 
-  :bias=>127, :bias_mode=>:normalized_significand,
-  :hidden_bit=>true,
-  :endianness=>:little_endian, :round=>:even,
-  :gradual_underflow=>true, :infinity=>true, :nan=>true
-)
-IEEE_DOUBLE = BinaryFormat.new(
-  :fields=>[:significand,52,:exponent,11,:sign,1], 
-  :bias=>1023, :bias_mode=>:normalized_significand,
-  :hidden_bit=>true,
-  :endianness=>:little_endian, :round=>:even,
-  :gradual_underflow=>true, :infinity=>true, :nan=>true
-)
-IEEE_EXTENDED = BinaryFormat.new(
-  :fields=>[:significand,64,:exponent,15,:sign,1], 
-  :bias=>16383, :bias_mode=>:normalized_significand,
-  :hidden_bit=>false, :min_encoded_exp=>1, :round=>:even,
-  :endianness=>:little_endian,
-  :gradual_underflow=>true, :infinity=>true, :nan=>true
-)
-IEEE_128 = BinaryFormat.new(
-  :fields=>[:significand,112,:exponent,15,:sign,1], 
-  :bias=>16383, :bias_mode=>:normalized_significand,
-  :hidden_bit=>false, :min_encoded_exp=>1, :round=>:even,
-  :endianness=>:little_endian,
-  :gradual_underflow=>true, :infinity=>true, :nan=>true
-)
+IEEE_binary16 = IEEE.binary(:significand=>10, :exponent=>5)
+IEEE_binary32 = IEEE.binary(:significand=>23,:exponent=>8)
+IEEE_binary64 = IEEE.binary(:significand=>52,:exponent=>11)
+IEEE_binary80 = IEEE.binary(:significand=>64,:exponent=>15, :hidden_bit=>false, :min_encoded_exp=>1)
+IEEE_binary128 = IEEE.binary(:significand=>112,:exponent=>15)
+
 
 # IEEE 754 in big endian order (SPARC, Motorola 68k, PowerPC)
 
-IEEE_S_BE = BinaryFormat.new(
-  :fields=>[:significand,23,:exponent,8,:sign,1], 
-  :bias=>127, :bias_mode=>:normalized_significand,
-  :hidden_bit=>true,
-  :endianness=>:big_endian,
-  :gradual_underflow=>true, :infinity=>true, :nan=>true)
-IEEE_D_BE = BinaryFormat.new(
-  :fields=>[:significand,52,:exponent,11,:sign,1], 
-  :bias=>1023, :bias_mode=>:normalized_significand,
-  :hidden_bit=>true, :round=>:even,
-  :endianness=>:big_endian,
-  :gradual_underflow=>true, :infinity=>true, :nan=>true
-)
-IEEE_X_BE = BinaryFormat.new(
-  :fields=>[:significand,64,:exponent,15,:sign,1], 
-  :bias=>16383, :bias_mode=>:normalized_significand,
-  :hidden_bit=>false, :round=>:even,
-  :endianness=>:big_endian,
-  :gradual_underflow=>true, :infinity=>true, :nan=>true
-)
-IEEE_128_BE = BinaryFormat.new(
-  :fields=>[:significand,112,:exponent,15,:sign,1], 
-  :bias=>16383, :bias_mode=>:normalized_significand,
-  :hidden_bit=>false, :min_encoded_exp=>1, :round=>:even,
-  :endianness=>:big_endian,
-  :gradual_underflow=>true, :infinity=>true, :nan=>true
-)
+IEEE_binary16_BE = IEEE.binary(:significand=>10, :exponent=>5, :endianness=>:big_endian)
+IEEE_binary32_BE = IEEE.binary(:significand=>23,:exponent=>8, :endianness=>:big_endian)
+IEEE_binary64_BE = IEEE.binary(:significand=>52,:exponent=>11, :endianness=>:big_endian)
+IEEE_binary80_BE = IEEE.binary(:significand=>64,:exponent=>15, :endianness=>:big_endian, :hidden_bit=>false, :min_encoded_exp=>1)
+IEEE_binary128_BE = IEEE.binary(:significand=>112,:exponent=>15, :endianness=>:big_endian)
+
+
+# some IEEE745r interchange binary formats
+
+IEEE_binary256 = IEEE.interchange_binary(256)
+IEEE_binary512 = IEEE.interchange_binary(512)
+IEEE_binary1024 = IEEE.interchange_binary(1024)
+IEEE_binary256_BE = IEEE.interchange_binary(256, :endianness=>:big_endian)
+IEEE_binary512_BE = IEEE.interchange_binary(512, :endianness=>:big_endian)
+IEEE_binary1024_BE = IEEE.interchange_binary(1024, :endianness=>:big_endian)
+
+
+# old names
+IEEE_binaryx = IEEE_binary80
+IEEE_HALF = IEEE_binary16
+IEEE_SINGLE = IEEE_binary32
+IEEE_DOUBLE = IEEE_binary64
+IEEE_EXTENDED = IEEE_binary80
+IEEE_QUAD = IEEE_binary128
+IEEE_128 = IEEE_binary128IEEE_H_BE = IEEE_binary16_BE
+IEEE_S_BE = IEEE_binary32_BE
+IEEE_D_BE = IEEE_binary64_BE
+IEEE_X_BE = IEEE_binary80_BE
+IEEE_128_BE = IEEE_binary128_BE
+IEEE_Q_BE = IEEE_binary128_BE
+
+
 # Decimal IEEE 754r formats
 
-IEEE_DEC32 = DPDFormat.new(
-  :fields=>[:significand_continuation,20,:exponent_continuation,6,:combination,5,:sign,1],
-  :endianness=>:big_endian,
-  :gradual_underflow=>true, :infinity=>true, :nan=>true
-)
-IEEE_DEC64 = DPDFormat.new(
-  :fields=>[:significand_continuation,50,:exponent_continuation,8,:combination,5,:sign,1],
-  :endianness=>:big_endian,
-  :gradual_underflow=>true, :infinity=>true, :nan=>true
-)
-IEEE_DEC128 = DPDFormat.new(
-  :fields=>[:significand_continuation,110,:exponent_continuation,12,:combination,5,:sign,1],
-  :endianness=>:big_endian,
-  :gradual_underflow=>true, :infinity=>true, :nan=>true
-)
+IEEE_decimal32 = IEEE.decimal(:significand=>20, :exponent=>6)
+IEEE_decimal64 = IEEE.decimal(:significand=>50, :exponent=>8)
+IEEE_decimal128 = IEEE.decimal(:significand=>110, :exponent=>12)
+
+# some IEEE745r interchange binary formats
+
+IEEE_decimal96 = IEEE.interchange_decimal(96)
+IEEE_decimal192 = IEEE.interchange_decimal(192)
+IEEE_decimal256 = IEEE.interchange_decimal(256)
    
+# old names
+
+IEEE_DEC32 = IEEE_decimal32
+IEEE_DEC64 = IEEE_decimal64
+IEEE_DEC128 = IEEE_decimal128
 
 # Excess 128 used by Microsoft Basic in 8-bit micros, Spectrum, ...
 
@@ -202,6 +232,7 @@ PDP11_D = BinaryFormat.new(
 
 
 # Format used in HP Saturn-based RPL calculators (HP48,HP49,HP50, also HP32s, HP42s --which use RPL internally)
+# (these formats are not used in the HP-71B which is a Saturn, non-RPL machine)
           
 SATURN = BCDFormat.new(
   :fields=>[:prolog,5,:exponent,3,:significand,12,:sign,1],
@@ -217,9 +248,40 @@ SATURN_X = BCDFormat.new(
   :endianness=>:little_endian, :round=>:even,
   :gradual_underflow=>false, :infinity=>false, :nan=>false
 )
-          
-# Format used in classic HP calculators (HP-35, ... HP-15C) (endianess is unknown)
-
+         
+         
+RPL = SATURN
+RPL_X = SATURN_X
+         
+# SATURN HP-71B (IEEE, NON-RPL) formats
+
+# HP-71B REAL format (12-form) which is stored in a single register
+HP71B = BCDFormat.new(
+  :fields=>[:exponent,3,:significand,12,:sign,1],
+  :exponent_mode=>:radix_complement,
+  :endianness=>:little_endian, :round=>:even,
+  :gradual_underflow=>true, :infinity=>true, :nan=>true,
+  :denormal_encoded_exp=>501,
+  :nan_encoded_exp=>"F01", # signaling NaN is F02
+  :infinite_encoded_exp=>"F00"
+)   
+
+# HP-71B internal 15-digit format (15-form), stored in a pair of registers
+# we use here a little-endian order for the registers, otherwise the
+# definition would be [:significand,15,:unused1,1,:exponent,5,:unused2,10,:sign,1]
+HP71B_X = BCDFormat.new(
+  :fields=>[:exponent,5,:unused2,10,:sign,1, :significand,15,:unused1,1],
+  :exponent_mode=>:radix_complement,
+  :endianness=>:little_endian, :round=>:even,
+  :gradual_underflow=>false, :infinity=>true, :nan=>true,
+  :nan_encoded_exp=>"00F01",
+  :infinite_encoded_exp=>"00F00"
+)   
+
+# Format used in classic HP calculators (HP-35, ... HP-15C)
+# Endianness is indeterminate, since these machines have named registers that
+# hold a floating-point value in a single 56-bit word.
+# (But intra-word field/nibble addressing is little-endian)
 HP_CLASSIC = BCDFormat.new(
   :fields=>[:exponent,3,:significand,10,:sign,1],
   :exponent_mode=>:radix_complement,
@@ -306,15 +368,16 @@ CDC_SINGLE = CDCFLoatingPoint.new(
   :gradual_underflow=>false, :infinity=>false, :nan=>false
 )
 
-# the CDC_DOUBLE can be splitted in two CDC_SINGLE values:
+# The CDC_DOUBLE can be splitted in two CDC_SINGLE values:
 #   get_bitfields(v,[CDC_SINGLE.total_bits]*2,CDC_DOUBLE.endianness).collect{|x| int_to_bytes(x,0,CDC_SINGLE.endianness)}
 # and the value of the double is the sum of the values of the singles.
-# unlike the single, we must use :fractional_significand mode because with :integral_significand
+# Unlike the single, we must use :fractional_significand mode because with :integral_significand
 # the exponent would refer to the whole significand, but it must refer only to the most significant half.
 # we substract the number of bits in the single to the bias and exponent because of this change,
 # and add 48 to the min_exponent to avoid the exponent of the low order single to be out of range
 # because the exponent of the low order single is adjusted to 
 # the position of its digits by substracting 48 from the high order exponent
+# when its exponent would be out of range
 # Note that when computing the low order exponent with the fields handler we must take into account the sign 
 # because for negative numbers all the fields are one-complemented.
 CDC_DOUBLE= CDCFLoatingPoint.new(
@@ -353,17 +416,15 @@ UNIVAC_DOUBLE = BinaryFormat.new(
   :gradual_underflow=>false, :infinity=>false, :nan=>false
 )
                                                                                                                         
-# Sofware floating point implementatin for the Apple II (6502)
-# the significand & sign are a single field in two's commplement
 
-APPLE = BinaryFormat.new(
+# :stopdoc: # the next definition is not handled correctly by RDoc
+APPLE_INSANE = BinaryFormat.new(
   :fields=>[:significand,23,:sign,1,:exponent,8],
   :bias=>128, :bias_mode=>:normalized_significand,
   :hidden_bit=>false, :min_encoded_exp=>0,
   :neg_mode=>:radix_complement_significand,
   :endianness=>:big_endian,
   :gradual_underflow=>true, :infinity=>false, :nan=>false) { |fp|
-                        
   # This needs a peculiar treatment for the negative values, which not simply use two's complement
   # but also avoid having the sign and msb of the significand equal.
   # Note that here we have a separate sign bit, but it can also be considered as the msb of the significand
@@ -387,10 +448,14 @@ APPLE = BinaryFormat.new(
     #puts ""
     [f,e]
   end
-
 }
+# :startdoc:
 
 
+# Sofware floating point implementatin for the Apple II (6502)
+# the significand & sign are a single field in two's commplement
+APPLE = APPLE_INSANE
+
 # Wang 2200 Basic Decimal floating point
 WANG2200 = BCDFormat.new(
   :fields=>[:significand,13,:exponent,2,:signs,1],
@@ -572,7 +637,31 @@ C51_BCD_LONG_DOUBLE = C51BCDFloatingPoint.new(
   :zero_encoded_exp=>0, :min_encoded_exp=>0,:max_encoded_exp=>127
 ) 
 
-
+=begin
+# Note:
+# One could be tempted to define a double-double type as:
+    IEEE_DOUBLE_DOUBLE = BinaryFormat.new(
+      :fields=>[:significand,52,:lo_exponent,11,:lo_sign,1,:significand,52,:exponent,11,:sign,1], 
+      :fields_handler=>lambda{|fields|     
+        fields[2] = fields[5];
+        bits,max_exp = 53,2047    
+        if fields[4]>bits && fields[4]<max_exp
+          fields[1] = fields[4] - bits
+        else # 0, denormals, small numbers, NaN, Infinities
+          fields[0] = fields[1] = 0
+        end
+      },
+      :bias=>1023, :bias_mode=>:normalized_significand,
+      :hidden_bit=>true,
+      :endianness=>:little_endian, :round=>:even,
+      :gradual_underflow=>true, :infinity=>true, :nan=>true
+    )
+#  But this is incorrect since there's a hidden bit in the low double too and it must be normalized.
+#  In general the halfs of the significand need not be adjacent, they
+#  can have exponets with a separation higher than 53; (in fact the minimum separation seems to be 54)
+#  and they can have different sings, too;
+#  double-double is too tricky to be supported by this package.
+=end
 
  
 

data/lib/float-formats/native.rb

@@ -99,6 +99,27 @@ class Float
   
   # Maximum significand  == Math.ldexp(Math.ldexp(1,Float::MANT_DIG)-1,-Float::MANT_DIG)
   MAX_F = Math.frexp(Float::MAX)[0]   == Math.ldexp(Math.ldexp(1,Float::MANT_DIG)-1,-Float::MANT_DIG)
+
+  # ulp (unit in the last place) according to the definition proposed by J.M. Muller in
+  # "On the definition of ulp(x)" INRIA No. 5504
+  def ulp
+    return self if nan?     
+    x = abs
+    if x < Math.ldexp(1,MIN_EXP) # x < RADIX*MIN_N
+      res = Math.ldexp(1,MIN_EXP-MANT_DIG) # res = MIN_D
+    elsif x > Math.ldexp(1-Math.ldexp(1,-MANT_DIG),MAX_EXP)  # x > MAX
+      res = Math.ldexp(1,MAX_EXP-MANT_DIG) # res = MAX - MAX.prev
+    else
+      f,e = Math.frexp(x)
+      if f==Math.ldexp(1,-1)
+        res = Math.ldexp(1,e-MANT_DIG-1)
+      else
+        res = Math.ldexp(1,e-MANT_DIG)
+      end        
+    end  
+    res  
+  end
+  
      
 end
 
@@ -127,6 +148,89 @@ def float_bin(x)
   x.nio_write(Nio::Fmt.mode(:sci,:exact).base(2))
 end
 
+# decompose a float into a signed integer significand and exponent (base Float::RADIX)
+def float_to_integral_significand_exponent(x)
+  s,e = Math.frexp(x)
+  [Math.ldexp(s,Float::MANT_DIG).to_i,e-Float::MANT_DIG]
+end
+
+# compose float from significand and exponent
+def float_from_integral_significand_exponent(s,e)
+  Math.ldexp(s,e)
+end
+
+def float_to_integral_sign_significand_exponent(x)
+  if x==0.0
+    sign = (1/x<0) ? -1 : +1
+  else
+    sign = x<0 ? -1 : +1
+  end
+  x = -x if sign<0  
+  s,e = Math.frexp(x)
+  [sign,Math.ldexp(s,Float::MANT_DIG).to_i,e-Float::MANT_DIG]
+end
+
+def float_from_integral_sign_significand_exponent(sgn,s,e)
+  f = Math.ldexp(s,e)
+  f = -f if sgn<0
+  f
+end
+
+# convert a float to C99's hexadecimal notation
+def hex_from_float(v)
+  if Float::RADIX==2
+    sgn,s,e = float_to_integral_sign_significand_exponent(v)
+  else
+    txt = v.nio_write(Fmt.base(2).sep('.')).upcase
+    p = txt.index('E')
+    exp = 0
+    if p
+      exp = rep[p+1..-1].to_i
+      txt = rep[0...p]
+    end
+    p = txt.index('.')
+    if p
+      exp -= (txt.size-p-1)
+      txt.tr!('.','')    
+    end
+    s = txt.to_i(2)
+    e = exp  
+  end
+  "0x#{sgn<0 ? '-' : ''}#{s.to_s(16)}p#{e}"  
+end
+
+# convert a string formatted in C99's hexadecimal notation to a float
+def hex_to_float(txt)
+  txt = txt.strip.upcase
+  txt = txt[2..-1] if txt[0,2]=='0X'
+  p = txt.index('P')
+  if p
+    exp = txt[p+1..-1].to_i
+    txt = txt[0...p]
+  else
+    exp = 0
+  end
+  p = txt.index('.')
+  if p
+    exp -= (txt.size-p-1)*4
+    txt.tr!('.','')    
+  end
+  if Float::RADIX==2
+    v = txt.to_i(16)
+    if v==0 && txt.include?('-')
+      sign = -1
+    elsif v<0
+      sign = -1
+      v = -v
+    else
+      sign = +1
+    end      
+    float_from_integral_sign_significand_exponent(sign,v,exp)
+  else
+    (txt.to_i(16)*(2**exp)).to_f
+  end
+end
+
 # ===== IEEE types =====================================================================================
  
 # generate a SGL value stored in a byte string given a decimal value formatted as text

data/lib/float-formats/version.rb

@@ -2,7 +2,7 @@ module FltPnt
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 1
-    TINY  = 0
+    TINY  = 1
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/test/test_data.yaml

@@ -484,60 +484,11 @@ XS256_DOUBLE:
   - "65536.0": 44 00 00 00 00 00 00 00
   - "-65536.0": C4 00 00 00 00 00 00 00
   - "-7.50": C0 B8 00 00 00 00 00 00
-  - "8.6361685550944451E-78": 00 00 00 00 00 00 00 00
+  - "8.6361685550944451E-78": 00 00 00 00 00 00 00 01
   - 1.15792089237316192E77: 7F FF FF FF FF FF FF FF
   - "5.5511151231257827E-17": 32 80 00 00 00 00 00 00
   - "2.77555756156289135E-17": 32 40 00 00 00 00 00 00
   base: :bytes
-IEEE_128: 
-  parameters: 
-  - total_bits: 128
-  - radix: 2
-  - significand_digits: 112
-  - radix_min_exp: -16382
-  - radix_max_exp: 16383
-  - decimal_digits_stored: 33
-  - decimal_digits_necessary: 35
-  - decimal_min_exp: -4931
-  - decimal_max_exp: 4932
-  values: 
-  - Rational(1, 3): AB AA AA AA AA AA AA AA AA AA AA AA AA AA FD 3F
-  - Rational(1, 10): CD CC CC CC CC CC CC CC CC CC CC CC CC CC FB 3F
-  - Rational(2, 3): AB AA AA AA AA AA AA AA AA AA AA AA AA AA FE 3F
-  - Rational(1, 1024): 00 00 00 00 00 00 00 00 00 00 00 00 00 80 F5 3F
-  - Rational(1, 1000): 31 08 AC 1C 5A 64 3B DF 4F 8D 97 6E 12 83 F5 3F
-  - Rational(1024, 1): 00 00 00 00 00 00 00 00 00 00 00 00 00 80 09 40
-  - Rational(1024, 1): 00 00 00 00 00 00 00 00 00 00 00 00 00 80 09 40
-  special: 
-  - min_value: 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
-  - min_normalized_value: 00 00 00 00 00 00 00 00 00 00 00 00 00 80 01 00
-  - max_value: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FE 7F
-  - epsilon: 00 00 00 00 00 00 00 00 00 00 00 00 00 80 90 3F
-  - strict_epsilon: 01 00 00 00 00 00 00 00 00 00 00 00 00 80 8F 3F
-  numerals: 
-  - "+0": 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
-  - "-0": 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 80
-  - "+1": 00 00 00 00 00 00 00 00 00 00 00 00 00 80 FF 3F
-  - "-1": 00 00 00 00 00 00 00 00 00 00 00 00 00 80 FF BF
-  - "+0.1": CD CC CC CC CC CC CC CC CC CC CC CC CC CC FB 3F
-  - "-0.1": CD CC CC CC CC CC CC CC CC CC CC CC CC CC FB BF
-  - "0.5": 00 00 00 00 00 00 00 00 00 00 00 00 00 80 FE 3F
-  - "-0.5": 00 00 00 00 00 00 00 00 00 00 00 00 00 80 FE BF
-  - "29.2": 9A 99 99 99 99 99 99 99 99 99 99 99 99 E9 03 40
-  - "-29.2": 9A 99 99 99 99 99 99 99 99 99 99 99 99 E9 03 C0
-  - "0.03125": 00 00 00 00 00 00 00 00 00 00 00 00 00 80 FA 3F
-  - "-0.03125": 00 00 00 00 00 00 00 00 00 00 00 00 00 80 FA BF
-  - "-0.3125": 00 00 00 00 00 00 00 00 00 00 00 00 00 A0 FD BF
-  - 1.234E2: CD CC CC CC CC CC CC CC CC CC CC CC CC F6 05 40
-  - "-1.234E-6": 90 0F B2 E0 09 B3 8C B1 6C 16 CA EA 9F A5 EB BF
-  - "65536.0": 00 00 00 00 00 00 00 00 00 00 00 00 00 80 0F 40
-  - "-65536.0": 00 00 00 00 00 00 00 00 00 00 00 00 00 80 0F C0
-  - "-7.50": 00 00 00 00 00 00 00 00 00 00 00 00 00 F0 01 C0
-  - "3.3621031431120935062626778173217526E-4932": 00 00 00 00 00 00 00 00 00 00 00 00 00 80 01 00
-  - 1.1897314953572317650857593266280069E4932: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FE 7F
-  - "3.8518598887744717061119558851698546E-34": 00 00 00 00 00 00 00 00 00 00 00 00 00 80 90 3F
-  - "1.9259299443872358530559779425849281E-34": 01 00 00 00 00 00 00 00 00 00 00 00 00 80 8F 3F
-  base: :bytes
 IEEE_DOUBLE: 
   parameters: 
   - total_bits: 64
@@ -680,7 +631,7 @@ PDP11_F:
   - "65536.0": 80 48 00 00
   - "-65536.0": 80 C8 00 00
   - "-7.50": F0 C1 00 00
-  - "1.46936811E-39": 00 00 00 00
+  - "1.46936811E-39": 00 00 01 00
   - 1.70141173E38: FF 7F FF FF
   - "1.1920929E-7": 00 35 00 00
   - "1.1920929E-7": 00 35 00 00
@@ -1121,7 +1072,7 @@ XS256:
   - "65536.0": 44 00 00 00
   - "-65536.0": C4 00 00 00
   - "-7.50": C0 B8 00 00
-  - "8.6361706E-78": 00 00 00 00
+  - "8.6361706E-78": 00 00 00 01
   - 1.1579208E77: 7F FF FF FF
   - "2.3841858E-7": 3A 80 00 00
   - "1.1920929E-7": 3A 40 00 00
@@ -1660,7 +1611,7 @@ BORLAND48:
   - "65536.0": 91 00 00 00 00 00
   - "-65536.0": 91 00 00 00 00 80
   - "-7.50": 83 00 00 00 00 F0
-  - "2.9387358770557E-39": 02 00 00 00 00 00
+  - "2.9387358770557E-39": 01 00 00 00 00 00
   - 1.7014118346031E38: FF FF FF FF FF 7F
   - "1.8189894035459E-12": 5A 00 00 00 00 00
   - "1.8189894035459E-12": 5A 00 00 00 00 00

data/test/test_float-formats.rb

@@ -109,4 +109,61 @@ class TestFloatFormats < Test::Unit::TestCase
     end  
       
   end 
+
+  def test_hp71b
+    assert_equal(-499, HP71B.radix_min_exp)
+    assert_equal(499, HP71B.radix_max_exp)
+
+    fmt = Nio::Fmt.prec(12)
+    assert_equal  '9.99999999999E499', HP71B.max_value.to_fmt(fmt)
+    assert_equal '0000000000001501', HP71B.min_value.to_bits_text(16)
+    assert_equal '1E-510', HP71B.min_value.to_fmt(fmt)
+    assert_equal '1E-499', HP71B.min_normalized_value.to_fmt(fmt)
+
+    assert_equal '9210000000000999',HP71B.from_fmt('-0.21').to_bits_text(16)
+    assert_equal '0100000000000001',HP71B.from_fmt('10').to_bits_text(16)
+    assert_equal '9000000000000000',HP71B.from_fmt('-0').to_bits_text(16)
+    assert_equal '0000510000000501', HP71B.from_fmt('0.0051E-499').to_bits_text(16)
+
+    assert_equal '0000000000000F01',HP71B.nan.to_bits_text(16).upcase
+    assert_equal 'NAN', HP71B.nan.to_fmt.upcase
+    assert_equal '0000000000000F00', HP71B.infinity.to_bits_text(16).upcase
+    assert_equal '+INFINITY', HP71B.infinity.to_fmt.upcase
+    assert_equal '9000000000000F00', HP71B.infinity.neg.to_bits_text(16).upcase
+  end
+  def test_quad
+    assert_equal "3fff 0000 0000 0000 0000 0000 0000 0000".tr(' ',''), IEEE_binary128_BE.from_fmt('1').to_hex.downcase
+    assert_equal "7ffe ffff ffff ffff ffff ffff ffff ffff".tr(' ',''), IEEE_binary128_BE.max_value.to_hex.downcase
+    assert_equal '1.19E4932', IEEE_binary128.max_value.to_fmt(Nio::Fmt.prec(4))
+    assert_equal "c000 0000 0000 0000 0000 0000 0000 0000".tr(' ',''), IEEE_binary128_BE.from_fmt('-2').to_hex.downcase
+    assert_equal "0000 0000 0000 0000 0000 0000 0000 0000".tr(' ',''), IEEE_binary128_BE.from_fmt('0').to_hex.downcase
+    assert_equal "8000 0000 0000 0000 0000 0000 0000 0000".tr(' ',''), IEEE_binary128_BE.from_fmt('-0').to_hex.downcase
+    assert_equal "7fff 0000 0000 0000 0000 0000 0000 0000".tr(' ',''), IEEE_binary128_BE.infinity.to_hex.downcase
+    assert_equal "ffff 0000 0000 0000 0000 0000 0000 0000".tr(' ',''), IEEE_binary128_BE.infinity(1).to_hex.downcase
+    assert_equal "3ffd 5555 5555 5555 5555 5555 5555 5555".tr(' ',''), IEEE_binary128_BE.from_number(Rational(1,3)).to_hex.downcase
+    assert_equal "3fff 0000 0000 0000 0000 0000 0000 0001".tr(' ',''), IEEE_binary128_BE.from_fmt('1').next.to_hex.downcase    
+  end
+  def test_half
+    assert_equal "3c00", IEEE_binary16_BE.from_fmt('1').to_hex.downcase
+    assert_equal "7bff", IEEE_binary16_BE.max_value.to_hex.downcase
+    assert_equal '65504', IEEE_binary16_BE.max_value.to_fmt
+    assert_equal "0400", IEEE_binary16_BE.min_normalized_value.to_hex.downcase
+    assert_equal "6.103515625E-5", IEEE_binary16_BE.min_normalized_value.to_fmt
+    assert_equal "0001", IEEE_binary16_BE.min_value.to_hex.downcase
+    assert_equal "5.9604644775390625E-8", IEEE_binary16_BE.min_value.to_fmt
+    assert_equal "0000", IEEE_binary16_BE.from_fmt('0').to_hex.downcase
+    assert_equal "8000", IEEE_binary16_BE.from_fmt('-0').to_hex.downcase
+    assert_equal "7c00".tr(' ',''), IEEE_binary16_BE.infinity.to_hex.downcase
+    assert_equal "fc00".tr(' ',''), IEEE_binary16_BE.infinity(1).to_hex.downcase
+  end
+  def test_special
+    assert_equal '+Infinity', IEEE_binary32.from_number(1.0/0.0).to_fmt 
+    assert_equal '-Infinity', IEEE_binary32.from_number(-1.0/0.0).to_fmt 
+    assert_equal '+Infinity', IEEE_binary32.from_fmt('+Infinity').to_fmt 
+    assert_equal '-Infinity', IEEE_binary32.from_fmt('-Infinity').to_fmt 
+    assert_equal 'NAN', IEEE_binary32.from_number(0.0/0.0).to_fmt.upcase
+    assert_equal 'NAN', IEEE_binary32.from_fmt('NaN').to_fmt.upcase
+  end
+  
+
 end

data/test/test_helper.rb

@@ -1,2 +1,3 @@
+require 'rubygems'
 require 'test/unit'
 require File.dirname(__FILE__) + '/../lib/float-formats'

data/test/test_native-float.rb

@@ -22,4 +22,56 @@ class TestNativeFloat < Test::Unit::TestCase
       assert(-(1.0.next) == (-1.0).prev)
       assert((-1.0).next == -(1.0.prev))
     end
+    
+    def test_hex
+      if Float::RADIX==2 && Float::MANT_DIG==53
+        assert_equal((1.0+Float::EPSILON),hex_to_float('0x1.0000000000001p0'))
+        assert_equal '0x10000000000001p-52', hex_from_float(1.0+Float::EPSILON)
+      end
+      assert_equal 1.0, hex_to_float(hex_from_float(1.0))
+      assert_equal(-1.0, hex_to_float(hex_from_float(-1.0)))
+      assert_equal 1.0e-5, hex_to_float(hex_from_float(1.0e-5))
+      assert_equal(-1.0e-5, hex_to_float(hex_from_float(-1.0e-5)))
+      
+      assert_equal(+1,float_to_integral_sign_significand_exponent(+0.0).first)
+      assert_equal(-1,float_to_integral_sign_significand_exponent(-0.0).first)
+      assert_not_equal hex_from_float(-0.0), hex_from_float(+0.0)
+      assert_equal hex_to_float(hex_from_float(-0.0)), hex_to_float(hex_from_float(+0.0))
+      
+    end
+    
+    
+    def check_ulp_around(x)
+      assert_equal x-x.prev, x.prev.ulp
+      assert_equal x-x.prev, x.ulp
+      assert_equal x.next-x, x.next.ulp
+      assert_equal x.next.next-x.next, x.next.next.ulp
+    end
+    
+    def test_ulp
+      r = Float::RADIX
+      assert_equal Float::MIN_D, 0.0.ulp
+      assert_equal Float::MIN_D, Float::MIN_D.ulp
+      assert_equal Float::MIN_D, Float::MIN_D.next.ulp
+      assert_equal Float::MIN_D, (0.5*(Float::MIN_D+Float::MAX_D)).ulp
+      assert_equal Float::MIN_D, Float::MAX_D.prev.ulp
+      assert_equal Float::MIN_D, Float::MAX_D.ulp
+      assert_equal Float::MIN_D, Float::MIN_N.ulp
+      assert_equal Float::MIN_D, Float::MIN_N.next.ulp
+      assert_equal Float::MIN_D, (r*Float::MIN_N).prev.ulp
+      assert_equal Float::MIN_D, (r*Float::MIN_N).ulp
+      assert_equal r*Float::MIN_D, (r*Float::MIN_N).next.ulp
+      check_ulp_around 1.0
+      assert_equal 1.0.next-1.0, 1.5.ulp
+      check_ulp_around r.to_f
+      check_ulp_around Math.ldexp(1,10)
+      check_ulp_around Math.ldexp(1,-10)
+      check_ulp_around Float::MAX/r
+      assert_equal Float::MAX-Float::MAX.prev, Float::MAX.prev.ulp
+      assert_equal Float::MAX-Float::MAX.prev, Float::MAX.ulp
+      assert_equal Float::MAX-Float::MAX.prev, (1.0/0.0).ulp
+      assert((0.0/0.0).ulp.nan?)
+      assert_equal Math.ldexp(1,10)-Math.ldexp(1,10).prev, Math.ldexp(1,10).prev.ulp
+    end
+    
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: float-formats
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
-date: 2007-11-04 00:00:00 +01:00
+  version: 0.1.1
+date: 2007-12-15 00:00:00 +01:00
 summary: Floating-Point Formats
 require_paths: 
 - lib
@@ -42,7 +42,6 @@ files:
 - 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
@@ -84,5 +83,5 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.2.0
+        version: 0.2.1
     version: