tellAboutX - Functions that expose the bits
Here are the different functions that tell us about the bits:
def tellAboutByte(x: Byte) = {
print("I am an 8-bit word that Scala views as having format 'Byte' ...\n"
++ "... my bits are, in binary, ("
++ new String((0 to 7)
.toArray
.map(j => (x >> 7-j)&1)
.flatMap(b => "%d".format(b)))
++ ")_2\n"
++ "... or equivalently, in hexadecimal, 0x%02X\n"
.format(x)
++ "... Scala prints me out as " ++ x.toString ++ "\n"
++ "... I represent the signed decimal integer %d\n"
.format(x)
++ "... I represent the unsigned decimal integer %d\n"
.format(if((x & 0x80) != 0) 0x100+x else x)
)
}
def tellAboutShort(x: Short) = {
print("I am a 16-bit word that Scala views as having format 'Short' ...\n"
++ "... my bits are, in binary, ("
++ new String((0 to 15)
.toArray
.map(j => (x >> 15-j)&1)
.flatMap(b => "%d".format(b)))
++ ")_2\n"
++ "... or equivalently, in hexadecimal, 0x%04X\n"
.format(x)
++ "... Scala prints me out as " ++ x.toString ++ "\n"
++ "... I represent the signed decimal integer %d\n"
.format(x)
++ "... I represent the unsigned decimal integer %d\n"
.format(if((x & 0x8000) != 0) 0x10000+x else x)
)
}
def tellAboutInt(x: Int) = {
print("I am a 32-bit word that Scala views as having format 'Int' ...\n"
++ "... my bits are, in binary, ("
++ new String((0 to 31)
.toArray
.map(j => (x >> 31-j)&1)
.flatMap(b => "%d".format(b)))
++ ")_2\n"
++ "... or equivalently, in hexadecimal, 0x%08X\n"
.format(x)
++ "... Scala prints me out as " ++ x.toString ++ "\n"
++ "... I represent the signed decimal integer %d\n"
.format(x)
++ "... I represent the unsigned decimal integer %d\n"
.format(if((x & 0x80000000) != 0) 0x100000000L+x else x)
)
}
def tellAboutLong(x: Long) = {
print("I am a 64-bit word that Scala views as having format 'Long' ...\n"
++ "... my bits are, in binary, ("
++ new String((0 to 63)
.toArray
.map(j => (x >> 63-j)&1)
.flatMap(b => "%d".format(b)))
++ ")_2\n"
++ "... or equivalently, in hexadecimal, 0x%016X\n"
.format(x)
++ "... Scala prints me out as " ++ x.toString ++ "\n"
++ "... I represent the signed decimal integer %d\n"
.format(x)
++ "... I represent the unsigned decimal integer %s\n"
.format(if((x & 0x8000000000000000L) != 0) BigInt("10000000000000000",16)+x else x)
)
}
def tellAboutChar(x: Char) = {
val xx = x.toShort
print("I am a 16-bit word that Scala views as having format 'Char' ...\n"
++ "... my bits are, in binary, ("
++ new String((0 to 15)
.toArray
.map(j => (xx >> 15-j)&1)
.flatMap(b => "%d".format(b)))
++ ")_2\n"
++ "... or equivalently, in hexadecimal, 0x%04X\n"
.format(xx)
++ "... Scala prints me out as " ++ x.toString ++ "\n"
++ "... indeed, my bits acquire meaning via the Unicode standard\n"
++ " http://www.unicode.org/\n"
++ "... I represent a single 16-bit Unicode character '\\u%04X'\n"
.format(xx)
++ "... as a signed decimal integer, I am %d\n"
.format(xx)
++ "... as an unsigned decimal integer, I am %d\n"
.format(if((x & 0x8000) != 0) 0x10000+xx else xx)
)
}
def tellAboutString(x: String) = {
val xx = x.toArray
print("I am compound data that Scala views as having format 'String' ...\n"
++ "... in essence, I am a sequence of %d consecutive 16-bit words,\n"
.format(xx.length)
++ " each of which Scala views as having format 'Char'\n"
++ "... the bits of this sequence are, in binary, ("
++ new String(xx.flatMap(w => (0 to 15)
.toArray
.map(j => (w.toShort >> 15-j)&1)
.flatMap(b => "%d".format(b))))
++ ")_2\n"
++ "... or equivalently, in hexadecimal, 0x%s\n"
.format(new String(xx.flatMap(w => "%04X".format(w.toShort))))
++ "... Scala prints me out as " ++ x ++ "\n"
)
}
def tellAboutFloat(x: Float) = {
val xx = java.lang.Float.floatToIntBits(x)
val sign = (xx >> 31) & 0x1 // unpack sign
val bexp = (xx >> 23) & 0xFF // unpack biased exponent
val tsig = xx & 0x007FFFFF // unpack trailing significand
val normalized = bexp > 0 && bexp < 254
require(bexp < 254)
// (no support for telling about NaNs or infinities
// -- consult the standard yourself for these!)
// We are either normalized or subnormal at this point
val exp = if(normalized) { bexp - 127 } else { -126 }
val sig = if(normalized) { tsig | (1L << 23) } else { tsig }
import java.math.{MathContext => jMC}
def p2(j: Int): BigDecimal = { if(j < 0) { BigDecimal(1,jMC.UNLIMITED)/p2(-j) } else { BigDecimal(2,jMC.UNLIMITED).pow(j) } }
val dd = ((0 to 23).filter(j => ((sig >> (23-j))&1) != 0).map(j => p2(exp-j)).foldLeft(BigDecimal(0,jMC.UNLIMITED))(_ + _)).toString
val sigstr = new String((0 to 23).map(j => (sig >> (23-j))&1).flatMap(b => "%1d".format(b)).toArray)
val bb = "(" ++ sigstr.take(1) ++ "." ++ sigstr.drop(1) ++ ")_2 * 2^{%d}".format(exp)
val sdd = "%s%s".format(if(sign == 1) "-" else "",dd)
val sbb = "%s%s".format(if(sign == 1) "-" else "",bb)
print("I am a 32-bit word that Scala views as having format 'Float' ...\n"
++ "... my bits are, in binary, ("
++ new String((0 to 31)
.toArray
.map(j => (xx >> 31-j)&1)
.flatMap(b => "%d".format(b)))
++ ")_2\n"
++ "... or equivalently, in hexadecimal, 0x%08X\n"
.format(xx)
++ "... Scala prints me out as " ++ x.toString ++ "\n"
++ "... indeed, my bits acquire meaning as specified\n"
++ " in the binary interchange format 'binary32' in the\n"
++ " IEEE Std 754-2008 IEEE Standard for Floating-Point Arithmetic\n"
++ " http://dx.doi.org/10.1109%2FIEEESTD.2008.4610935\n"
++ "... this format is a bit-packed format with three components:\n"
++ " ("
++ new String((0 to 31)
.toArray
.map(j => (xx >> 31-j)&1)
.flatMap(b => "%d".format(b)))
++ ")_2\n"
++ " a) the sign\n"
++ " (bit 31): %d\n"
.format(sign)
++ " b) the biased exponent\n"
++ " (bits 30 to 23): "
++ new String((0 to 7)
.toArray
.map(j => (bexp >> 7-j)&1)
.flatMap(b => "%d".format(b)))
++ "\n"
++ " c) the trailing significand\n"
++ " (bits 22 to 0): "
++ new String((0 to 22)
.toArray
.map(j => (tsig >> 22-j)&1)
.flatMap(b => "%d".format(b)))
++ "\n"
++ (if(normalized)
"... my biased exponent %d indicates that I am a _normalized_ number\n"
.format(bexp)
++ " with a leading 1-digit in my significand and\n"
++ " an unbiased exponent %d = %d - 127\n"
.format(exp,bexp)
else
"... my biased exponent %d indicates that I am a _subnormal_ number\n"
.format(bexp)
++ " with a leading 0-digit in my significand and\n"
++ " an unbiased exponent %d\n"
.format(exp)
)
++ "... that is, in _binary radix point notation_, I am exactly\n"
++ " %s%s\n"
.format(if(sign == 1) "" else " ",sbb)
++ "... or what is the same in _decimal radix point notation_, I am exactly\n"
++ " %s\n"
.format(sdd)
)
}
def tellAboutDouble(x: Double) = {
val xx = java.lang.Double.doubleToLongBits(x)
val sign = ((xx >> 63) & 0x1L).toInt // unpack sign
val bexp = ((xx >> 52) & 0x7FFL).toInt // unpack biased exponent
val tsig = xx & 0x000FFFFFFFFFFFFFL // unpack trailing significand
val normalized = bexp > 0 && bexp < 2047
require(bexp < 2047)
// (no support for telling about NaNs or infinities
// -- consult the standard yourself for these!)
// We are either normalized or subnormal at this point
val exp = if(normalized) { bexp - 1023 } else { -1022 }
val sig = if(normalized) { tsig | (1L << 52) } else { tsig }
import java.math.{MathContext => jMC}
def p2(j: Int): BigDecimal = { if(j < 0) { BigDecimal(1,jMC.UNLIMITED)/p2(-j) } else { BigDecimal(2,jMC.UNLIMITED).pow(j) } }
val dd = ((0 to 52).filter(j => ((sig >> (52-j))&1) != 0).map(j => p2(exp-j)).foldLeft(BigDecimal(0,jMC.UNLIMITED) )(_ + _)).toString
val sigstr = new String((0 to 52).map(j => (sig >> (52-j))&1).flatMap(b => "%1d".format(b)).toArray)
val bb = "(" ++ sigstr.take(1) ++ "." ++ sigstr.drop(1) ++ ")_2 * 2^{%d}".format(exp)
val sdd = "%s%s".format(if(sign == 1) "-" else "",dd)
val sbb = "%s%s".format(if(sign == 1) "-" else "",bb)
print("I am a 64-bit word that Scala views as having format 'Double' ...\n"
++ "... my bits are, in binary, ("
++ new String((0 to 63)
.toArray
.map(j => (xx >> 63-j)&1)
.flatMap(b => "%d".format(b)))
++ ")_2\n"
++ "... or equivalently, in hexadecimal, 0x%016X\n"
.format(xx)
++ "... Scala prints me out as " ++ x.toString ++ "\n"
++ "... indeed, my bits acquire meaning as specified\n"
++ " in the binary interchange format 'binary64' in the\n"
++ " IEEE Std 754-2008 IEEE Standard for Floating-Point Arithmetic\n"
++ " http://dx.doi.org/10.1109%2FIEEESTD.2008.4610935\n"
++ "... this format is a bit-packed format with three components:\n"
++ " ("
++ new String((0 to 63)
.toArray
.map(j => (xx >> 63-j)&1)
.flatMap(b => "%d".format(b)))
++ ")_2\n"
++ " a) the sign\n"
++ " (bit 63): %d\n"
.format(sign)
++ " b) the biased exponent\n"
++ " (bits 62 to 52): "
++ new String((0 to 10)
.toArray
.map(j => (bexp >> 10-j)&1)
.flatMap(b => "%d".format(b)))
++ "\n"
++ " c) the trailing significand\n"
++ " (bits 51 to 0): "
++ new String((0 to 51)
.toArray
.map(j => (tsig >> 51-j)&1)
.flatMap(b => "%d".format(b)))
++ "\n"
++ (if(normalized)
"... my biased exponent %d indicates that I am a _normalized_ number\n"
.format(bexp)
++ " with a leading 1-digit in my significand and\n"
++ " an unbiased exponent %d = %d - 1023\n"
.format(exp,bexp)
else
"... my biased exponent %d indicates that I am a _subnormal_ number\n"
.format(bexp)
++ " with a leading 0-digit in my significand and\n"
++ " an unbiased exponent %d\n"
.format(exp)
)
++ "... that is, in _binary radix point notation_, I am exactly\n"
++ " %s%s\n"
.format(if(sign == 1) "" else " ",sbb)
++ "... or what is the same in _decimal radix point notation_, I am exactly\n"
++ " %s\n"
.format(sdd)
)
}