Question

Are there any equivalents of java floatToRawIntBits/intBitsToFloat (or doubleToRawLongBits/longBitsToDouble) in ruby?

Answer 1

While there is not a simple alternative such as a floatToRawIntBits function, you could use Array#packand String#unpack to obtain the underlying bits:

bytes = [3.14].pack('D').each_byte.map { |byte| byte.ord.to_s(2) }
=> ["11111", "10000101", "11101011", "1010001", "10111000", "11110", "1001",
    "1000000"]

bytes.map { |byte| byte.to_i(2).chr }.join.unpack('D')
=> [3.14]

What’s going on here it’s you’re packing an array (we’re using an array with a single element, so we’re really packing just the element, i.e. 3.14) to a string that represents each byte with an ASCII character.
We then take each byte of the string (it’s the same as each character, because we’re using ASCII characters) and take the String#ord of the character; in Ruby 1.9 characters are strings of a single element, and String#ord returns the ordinal of a single character string.
Using Integer#to_s, with 2 as an argument, we get a binary representation of the ordinal, which is what we were searching for, the single bits of every byte of our float.

Note that passing 'D' to Array#pack means we want the bytes (what we get is characters in a string, but the method is really low-level enough to think in terms of bytes) that represent the element of the array as a double in native machine format. It’s important to pass the same parameter to String#unpack when getting back the number, because bytes are just bytes: the method doesn’t know anything about endianess, or about the data type.

Check the docs for Array#pack and String#unpack for more info (especially regarding the correct byte order).

Edit: You can also get the underlying bits in a string form:

bytes = [3.14].pack('D').each_byte.
    map { |byte| ('0' * 7 + byte.ord.to_s(2))[-8,8] }
 => ["00011111", "10000101", "11101011", "01010001", "10111000", "00011110",
     "00001001", "01000000"] 

bits = bytes.join(' ')
=> "00011111 10000101 11101011 01010001 10111000 00011110 00001001 01000000"

bits.gsub(' ', '')
=> "0001111110000101111010110101000110111000000111100000100101000000"

bits.split(' ').map { |byte| byte.to_i(2).chr }.join.unpack('D')
=> [3.14]

Edit 2: If you have some string read from a file, you can try with:

# You'll probably read each_line from a file, and get a bunch of strings like:
from_file =  0001111110000101111010110101000110111000000111100000100101000000

# If you've no byte separator in your file, the trick is to scan the string
# for 8 digits groups, that is bytes:
bytes = from_file.scan(/\d{8}/)
=>["00011111", "10000101", "11101011", "01010001", "10111000", "00011110",
   "00001001", "01000000"]

# Then, we can go on unpacking:
bytes.map { |byte| byte.to_i(2).chr }.join.unpack('D')
=> [3.14]