Decimal floating point number to binary: Difference between revisions

 

;Task:

 

 

<br><br>

 

 

 

 

 

=={{header|D}}==

{{trans|Python}}

 

immutable string[string] hex2bin, bin2hex;

y2.bin2dec.writeln;

writefln("%.6f", "1011.11101p+0".bin2dec);

{{out}}

<pre>1.011101011p+100

-23.3438

11.906250</pre>

 

=={{header|Elixir}}==

def dec2bin(dec, precision\\16) do

[int, df] = case String.trim(dec) |> String.split(".") do

dec2 = RC.bin2dec(bin)

:io.format "~10s => ~18s =>~12s~n", [dec, bin, dec2]

 

{{out}}

 

=={{header|Factor}}==

 

: bin>dec ( x -- y )

 

23.34375 dup >bin

{{out}}

<pre>

An alternative method is to present the text to the I/O system as with <code>READ (ACARD,*) X</code>, except that there is no facility for specifying any base other than ten. In a more general situation the text would first have to be scanned to span the number part, thus incurring double handling. The codes for hexadecimal, octal and binary formats do ''not'' read or write numbers in those bases, they show the bit pattern of the numerical storage format instead, and for floating-point numbers this is very different. Thus, Pi comes out as 100000000001001001000011111101101010100010001000010110100011000 in B64 format, not 11·0010010000111111011010101... Note the omitted high-order bit in the normalised binary floating-point format - a further complication.

 

CHARACTER*36 DIGIT !A set of acceptable digit characters.

PARAMETER (DIGIT = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ") !Not only including hexadecimal.

END DO !On to the next test.

END DO !And another base.

 

Rather than mess about with invocations, the test interprets the texts firstly as base ten sequences, then base two. It makes no complaint over encountering the likes of "666" when commanded to absorb according to base two. The placewise notation is straightforward: 666 = 6x2² + 6x2¹ + 6x2⁰

 

=={{header|FreeBASIC}}==

 

' Expresses (or rounds) the fractional part to the same number of places in binary as the decimal to be converted.

Print

Print "Press any key to quit"

 

{{out}}

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

s := "1011.11101"

fmt.Printf("%s\t => %v\n", s, binToDec(s))

 

{{out}}

=={{header|Haskell}}==

float to binary part only:

import Numeric (floatToDigits, showIntAtBase)

 

 

main :: IO ()

{{out}}

<pre>

Implementation:

 

NB. string to rational number

exp=. (1x+y i.'.')-#y

s=. exp&(}.,'.',{.) (":m#.inv mant)-.' '

((exp-1)>.-+/*/\|.s e.'.0') }. s

 

Example use:

 

10111.01011

10 b2b 2 '1011.11101'

 

 

=={{header|Julia}}==

function dec2bin(x::String)

bx = parse(BigFloat, x)

pre, post, n = "", "", div(nextpow(2, bx), 2)

while bx > 0

if n >= 1

pre *= a > 0 ? '1' : '0'

(pre, post) = split(binfloat, ".")

mult = BigInt(2)^length(post)

else

end

end

testdata = ["23.34375", "11.90625", "-23.34375", "-11.90625"]

testconversions(testdata)

<pre>

String (base 10) Base 2 Base 10

-11.90625 -1011.11101 -11.90625

</pre>

 

=={{header|Kotlin}}==

 

fun decToBin(d: Double): String {

val s = "1011.11101"

println("$s\t => ${binToDec(s)}")

 

{{out}}

1011.11101 => 11.90625

</pre>

 

=={{header|LiveCode}}==

LiveCode's baseConvert only works on integers.

Only the first part of this task is complete.

put 15 into limit

put 0 into i

 

put float2bin(23.34375) // 10111.01011

 

=={{header|M2000 Interpreter}}==

Module Checkit {

Conv2dec=lambda (n$, frombase=10, dp$=".") -> {

}

Checkit

{{out}}

<pre>

 

=={{header|Maple}}==

convert(23.34375,binary,decimal);

 

convert(1011.11101,decimal,binary);

Output:

<pre>

</pre>

 

{digits, pos} = (RealDigits[ToExpression@x, 2] /. {a_, b_} :> {ToString /@ a, b});

StringJoin @@

Join@{Take[digits, pos], {"."}, Quiet@NestWhile[Most, Drop[digits, pos], Last@# === "0" &]}]

bin2dec[x_] := FromDigits[RealDigits@ToExpression@x, 2] // N

Print[NumberForm[#, {9, 5}], " => ", dec2bin@#] &@23.34375;

{{out}}

1011.11101 => 11.90625</pre>

 

 

=={{header|OCaml}}==

program should perform conversions from any base to any other base.

{{works with|OCaml|4.03+}}

#load "str.cma"

(* Using the interpteter or the compiler:

and _ = List.iter (fun tpl -> print_endline (testit tpl)) values

in ()

{{out}}

23.343750 => 10111.01011; expected 10111.01011 [PASS]

23.700000 => 23.700000; expected 23.700000 [PASS]

 

 

{{out}}

=={{header|Phix}}==

Handles bases 2..36. Does not handle any form of scientific notation.

{{out}}

<pre>

The truth of the matter is simply that you ''can'' extract a float to a binary text representation exactly,

in a way that you just cannot do for most other (ie non-power-2) bases.<br>

 

=={{header|Python}}==

Python has float.hex() and float.fromhex() that can be used to form our own binary format.

bin2hex = dict('{:b} {:x}'.format(x,x).split() for x in range(16))

 

hx = (('-' if neg else '') + '0x' + hx + bn2[p:p+2]

+ str(int('0b' + bn2[p+2:], 2)))

 

{{out}}

=={{header|Racket}}==

The binary to number conversion is easy because it's supported by Racket. We can use <code>string-&gt;number</code>, wrap it in a dedicated function or use the read extension.

 

(define (string->number/binary x)

#b0.01

(string->number "0.01" 2)

{{out}}

<pre>2.3125

0.25</pre>

Racket only supports the number to binary conversion for integer numbers, so we multiply the original number by a power of two, to get all the binary digits, and then we manipulate the string to place the point in the correct place.

(define decimals-places 10)

(define digits-all (~r (inexact->exact (round (* x (expt 2 decimals-places))))

(number->string/binary 9)

(number->string/binary 0.01)

{{out}}

<pre>"1001.000000101"

"0.000000101"</pre>

Some additional interesting examples

(string-&gt;number/binary (number->string/binary .1))

(newline)

 

(number->string/binary (string->number/binary "0.11111111111"))

{{out}}

<pre>"10110.001101000"

"1.000000000"

0.99951171875</pre>

 

=={{header|REXX}}==

 

This REXX program is a modified version of the original program which can

<br>program did more extensive error checking.

 

This REXX program can handle any sized number &nbsp; (as per the number of digits/numerals) &nbsp; that can be entered at the

<br>command line.

parse arg number toBase inBase digits . /*obtain optional arguments from the CL*/

if toBase=='' | toBase=="," then toBase= 10 /*Not specified? Then use the default.*/

return oS || word( strip( space(w), 'L', 0)strip( strip(g, , 0), "T", .) 0, 1)

/*──────────────────────────────────────────────────────────────────────────────────────*/

{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> 23.34375 &nbsp; 2 </tt>}}

<pre>

 

===version 2===

* 08.02.2014 Walter Pachl

*--------------------------------------------------------------------*/

If res<>soll Then

Say 'soll='soll

'''Output:'''

<pre>23.34375 -> 10111.01011

-23.34375 -> -10111.01011

-1011.11101 -> -11.90625</pre>

 

=={{header|Ruby}}==

int, df = dec.split(".")

minus = int.delete!("-")

dec2 = bin2dec(bin)

puts "%10s => %12s =>%10s" % [dec, bin, dec2]

 

{{out}}

=={{header|Scala}}==

===Idiomatic (FP with tailrec)===

 

import scala.annotation.tailrec

println( { def s = "1011.11101"; s"$s\t => ${binToDec(s)}" } )

}

{{Out}}Experience running it in your browser by [https://scastie.scala-lang.org/auzWgFqCRBaYoOaJV92tgw Scastie (remote JVM)].

=={{header|Sidef}}==

Num(Num(n, 10).base(2), 10)

}

 

with("23.34375") { |s| say (" #{s} => ", dec2bin(s)) }

{{out}}

<pre>

By far the easiest way to do this is to use Tcl's built-in handling of IEEE arithmetic, converting the IEEE representation into the string representation we want (and ''vice versa'') by simple string manipulations.

{{works with|Tcl|8.6}}

 

proc dec2bin x {

set d [bin2dec $b]

puts "$case => $b => $d"

{{out}}

<pre>

</pre>

Adapting the code to work with IEEE double-precision floats is left as an exercise for the reader, as is dealing with the trickier special cases of the infinities and NaN.

 

=={{header|zkl}}==

Rather limited.

bstr=bstr.strip();

m:=bstr[0,1]=="-"; if(m)bstr=bstr[1,*]; m=m and -1 or 1;

a,b:=bstr.split(".").apply(fcn(s){ s and s or 0 }).append(0,0);

(a.toInt(2).toFloat() + b.toInt(2).toFloat()/(2).pow(b.len()))*m

println(bstr," --> ",bin2float(bstr).toString(20))

{{out}}

<pre>

1 --> 1

</pre>

m,zeros:="","0"*digitsOfPrecision;

if(x<0){ m="-"; x=-x }

if(z:=b.reverse().prefix(zeros)) b=b[0,-z]; // remove trailing zeros

String(m,a.toString(2),".",b);

println(x," --> ",s:=float2bin(x)," --> ",bin2float(s).toString(20));

{{out}}

<pre>