[Question]
  [
The task is simple: given a 32 bit integer, convert it to its floating point value as defined by the IEEE 754 (32-bit) standard.  
To put it another way, interpret the integer as the bit-pattern of an IEEE binary32 single-precision float and output the numeric value it represents.
## IEEE 754 single precision
[*Here is a converter for your reference.*](https://www.h-schmidt.net/FloatConverter/IEEE754.html)
Here is how the format looks, from [Wikipedia's excellent article](https://en.wikipedia.org/wiki/Single-precision_floating-point_format):
![](https://upload.wikimedia.org/wikipedia/commons/thumb/d/d2/Float_example.svg/885px-Float_example.svg.png)
The standard is similar to scientific notation.
The sign bit determines whether the output is negative or positive. If the bit is set, the number is negative otherwise it is positive.
The exponent bit determines the exponent (base 2), it's value is offset by 127. Therefore the exponent is \$2^{n-127}\$ where n is the integer representation of the exponent bits.
The mantissa defines a floating point number in the range \$[1,2)\$. The way it represents the number is like binary, the most significant bit is \$\frac 1 2\$, the one to the right is \$\frac 1 4\$, the next one is \$\frac 1 8\$ and so on... A one by default is added to the value, [implied by a non-zero exponent](https://en.wikipedia.org/wiki/Single-precision_floating-point_format#Exponent_encoding).
Now the final number is: $$\text{sign}\cdot 2^{\text{exponent}-127}\cdot \text{mantissa}$$
## Test cases
```
1078523331 ->   3.1400001049041748046875
1076719780 ->   2.71000003814697265625
1036831949 ->   0.100000001490116119384765625
3264511895 -> -74.24919891357421875
1056964608 ->   0.5
3205496832 ->  -0.5625
0          ->   0.0
2147483648 ->  -0.0 (or 0.0)
```
For this challenge assume that cases like `NaN` and `inf` are not going to be the inputs, and subnormals need not be handled (except for `0.0` which works like a subnormal, with the all-zero exponent implying a leading 0 bit for the all-zero mantissa.) You may output `0` for the case where the number represented is `-0`.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest answer in bytes wins.
  
[Answer]
# [Python](https://www.python.org), 55 bytes
Correct as per original challenge description (always add 2^23 to mantissa) but not per IEEE.
```
lambda i:-(i>>31or-1)*2**((i>>23)%256-129)*(i/8**7%4+4)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=LYxNCsIwFIT3niIbIYkN5uXl56Vgz-HCTUWCAW1LqQvP4qYgeidvY8SuZuZjZh7v4T6d-25-pt3hdZuSok-4tNfjqWW5Vjw3DUI_KhDSSMl_2aBYG-cVmCgkz1uSMqztxoplvk_9yDLLHQMdyBlEhKpYHyAG0sWiJ4RoY4XGWwdA0RXqfPTWaypUOxtLx9QrNoy5m3jiWSz_8_zXLw)
Direct bit twiddling, no casting.
# [Python](https://www.python.org), 69 bytes
At last proper IEEE, I think (thanks @Neil).
```
lambda i:-(i>>31or-1)*2**((e:=i>>23&255)-126-(e>0))*(i/2**23%1+(e>0))
```
[Attempt This Online!](https://ato.pxeger.com/run?1=NY1BDoIwEEX3nqIbTUEaOzO0tCSw8xZuMEJsokAILjyLGxKjd_I2jqKbmZ-XP_Nuz_46Hrt2ujfF7nEZG-Ve21N13h8qEXIlQ1kSdIOCKMY4lrLOC0ZIKzQmUoBWybrUURTLsOEC0hLWM_k9G5puEEGEVoDOnEEigoSjzcBnTnMk6wh86hNCmxoA5w1TY71NrXZMtUk9dzDRCSv4_CPC75wz5QvRD6EdZSPD3zxN834D)
# [Python](https://www.python.org) NumPy, 47 bytes
```
lambda i:int32(i).view("f4")
from numpy import*
```
[Attempt This Online!](https://ato.pxeger.com/run?1=LY1LCsIwFEXnruLRUStV829ScB8OnFQ0-MB8CKnStTgpiO7J3Rioo3s53M_zE6d8DX5-2f3xPWa70d_dbXCn8wDYo8-c1dhs73h51JUVVbOyKTjwo4sToIsh5fW_drAhAQJ6oKTTknHOaVus6qjpNCmWK82pEablTAlJqTayUKmMEoroQokUpmRYv4KYynlty3mz7M_zoj8)
Boring use of builtin "view" or "reinterpret" casting. Note that we can save the "u" from `uint32` without issues.
[Answer]
# x86 32-bit machine code, 5 bytes
```
D9 44 24 04 C3
```
[Try it online!](https://tio.run/##ZVFNb9swDD1bv4JzEUCKncDfsZOmpx43dAgGbECagyPJjgBFLmyncxDkr8@lgm7YuotEPZJPj498VnM@jnfKcH0SEu67Xqhmfngg/0Ba7T9irTK1xYhuTA2iOe21hIoq04NhK3htlABpBGUrUnZHoLBxKZnXutmXGipSLZ1KC3j8/rR5hK/fNrCV3Qt4kOyI08qeYOuSMBewnVjOY6nMjbxsa@4DP5QtTKf4eGXkQhzemK4Hm@/5dgdruITBIk@jOI5DHzDOFmGxyAMbx1keh0VS@BBHWZKGYV6kFk@zIkuyILd4kCYFlkXXFXEs64CUM2Q64x0g9vOgcFzqeQPcQ8aI47ygIX1F3UkYKZhEyTzMP1fPxvWtomHnoze3gOFEf4qfzZeSH5SRwBshl67NDe9fiAYuv@tgEkQ/kOq8pvRkOlUbKW4eTFnFtoPn7djqCu@i/qtAkZ/W8BFGh/@WAnSiYH/uZcduqgebxE2cWmPlXMk4/uKVLutunB3jCA9c6xp7pX4D "C (gcc) – Try It Online")
Following the `cdecl` calling convention, this takes the 32-bit integer on the stack and returns the result on the FPU register stack.
In assembly:
```
f:  fld DWORD PTR [esp + 4]
    ret
```
([`fld`](https://www.felixcloutier.com/x86/fld) does everything that is needed. The integer is placed below the return address on the stack, hence the `+ 4` to get to it.)
[Answer]
# Rust, 14 bytes
```
f32::from_bits
```
Not even reached the 30 byte min limit for posts
[Answer]
# [C (GCC)](https://gcc.gnu.org) without reliance on undefined behaviour, ~~41~~ 40 bytes
```
#define f(x)((union{int a;float b;})x).b
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m700OT49OXnBJuXMvOSc0pRUBZvikpTMfL0Mu6WlJWm6Fjc1lFNS0zLzUhXSNCo0NTRK8zLz86oz80oUEq3TcvITSxSSrGs1KzT1kqDqfUFyuYmZeRpgRUXpyToKyRmJRQpaWkBOmaZCNVdBEVAqTUNJVc_YKE1JB2iyoYG5hamRsbGxoaamNVdRaklpUZ6CgTVXLcTQBQsgNAA)
Type-punning through pointers does normally work, but the compiler is free to do strange optimisations which can stop it working. A union makes this explicit in ways the compiler understands. It can also potentially be evaluated at compile time instead of at run time.
Note that it's best practise in C/C++ to use parentheses around the input value to a function-like macro and around the result, so you don't get unwanted interactions with precedence rules if this is used in a more complex statement. This would add 4 extra bytes to the total. For the tests defined in the question, we don't need this.
(Thanks @ceilingcat for spotting an unneeded space.)
[Answer]
# C++ (GCC / Clang / MSVC), 39 bytes
```
#define f(x)__builtin_bit_cast(float,x)
```
[Try it online!](https://godbolt.org/z/xnY5PMazz)
[Answer]
# [Factor](https://factorcode.org/), 10 bytes
```
bits>float
```
[Try it online!](https://tio.run/##RZC9TsRADIT7PMXyAFnZa69/QLoW0dAgKkQRopw4AXchWQqEePawpyPKlPY3M5b3XV9O0/L4cHd/ex0@uvIa5uHzazj2wxzGaSjle5wOxxJumuanCVUIajkREYar0O7qhCIyVCGwA6OyAYtpXnFRdDVY8RQVzziQIYtrkixphUmM0NlXGOKFrek1HFEQnYx181ASzojm@eJplWNiRzdHysoJt1OyuLCAbelrBmT2Wp3@N23dnAt@w1OzvBzKvNu/n7qyPNcXjWEuXf8Wlz8 "Factor – Try It Online")
[Answer]
# [Java](https://en.wikipedia.org/wiki/Java_(programming_language)), 21 bytes
```
Float::intBitsToFloat
```
[Attempt This Online!](https://ato.pxeger.com/run?1=NYw9CsIwGIb3niIIQgsarEEsrTo4FByc6iYOsTblkzQJzRdBxJO4dNAjeJjexp_q9P7xvLf7kZ9400qojK6RfBJ1CJIKp3IErWj6M4mXS24tWV-M20vIiUWObzlpOJCKg_IzrEGV2x0PLt6fmq0UFmVRD1KpOS6IIHPycCiG0fPbxDEoXALajf7mbmtZkp0tFhXVDql536Lwe33KxqI3EJQbI89-OJpGkzFjLAyCxLteO7RpOn0B)
Builtin :P
[Answer]
# JavaScript (ES6), 50 bytes
*-16 bytes (!) thanks to [@Neil](https://codegolf.stackexchange.com/users/17602/neil)*
```
n=>new Float32Array(new Int32Array([n]).buffer)[0]
```
[Try it online!](https://tio.run/##bY6xTsNADIZ3niJjMuRqn30@e2glFiSeoeoQSoKKojuUtiCePlxVCkPqzdb/@fvfu8/uuJ8OH6c25dd@HtZzWm9S/1U9jbk7kX@cpu67vhye09@6TbvGvZyHoZ@aLezmfU7HPPZuzG/1UCNEDZ6IsGmq1aqqKnLIUAaBDRgjK7BoDA8LUCJaVLiB3kW8gECKLBa9BPFLjEQJje2GgbtSxViEiIJopBzv0eSFA6JauNJtZOfZ0NSQQmSP94oGMWEB/Tcu/0JgK8X8b6YtmaKffwA "JavaScript (Node.js) – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 45 bytes
```
Ｎθ≔Ｘ²¦²³η≔﹪÷θη²⁵⁶ζＩ∧ζ××⁺﹪θηηＸ²⁻ζ¹⁵⁰∨‹θＸ²¦³¹±¹
```
[Try it online!](https://tio.run/##RY1NCoMwEIX3PYXLCVjQpEqLK2k3QrUuegGrQQOa1PxY8PJpQls7MI9h3vdm2qGRrWhGawv@NLoy04NKmFG2y5ViPYdavNwChwEmKAyGv1GKzowCCq4vbGEdhdnbjktSp6sDa8m4hnOjNOS8gzUM7myiCj5aj0b9jnyjvrd/JeMOcKE4iRByzk3ClSrl4Q0isXcq2jeagpt9ZdYSHCWHU3ok2O6X8Q0 "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
Ｎθ
```
Input the integer.
```
≔Ｘ²¦²³η
```
Calculate `2²³` as it gets used often enough to make it worthwhile. (It was originally only used twice but it was still worthwhile then. I then golfed a byte off by introducing a third use, which also avoided the use of `Incremented` which is buggy on TIO, otherwise I would have had to have used ATO instead.)
```
≔﹪÷θη²⁵⁶ζ
```
Extract the exponent. This is needed because an exponent of `0` needs to be special-cased. (Normally this results in a subnormal, but fortunately the only subnormals that we need to support are `0` and `-0`.)
```
Ｉ∧ζ××
```
If the exponent is zero, output zero, otherwise output the product of...
```
⁺﹪θηη
```
... the bottom `23` bits of the input integer, with a `1` bit prepended, ...
```
Ｘ²⁻ζ¹⁵⁰
```
... 2 to the power of the exponent, adjusted by `150` instead of `127` to shift the mantissa bits by `23`, and...
```
∨‹θＸ²¦³¹±¹
```
... the sign bit.
[Answer]
# ARM Thumb machine code, 2 bytes
`arm-none-eabi-g++` defaults to `-mfloat-abi=soft`, so `float` is passed/returned in general-purpose integer registers. ([Godbolt](https://godbolt.org/#z:OYLghAFBqd5QCxAYwPYBMCmBRdBLAF1QCcAaPECAMzwBtMA7AQwFtMQByARg9KtQYEAysib0QXACx8BBAKoBnTAAUAHpwAMvAFYTStJg1DIApACYAQuYukl9ZATwDKjdAGFUtAK4sGIAMwAbKSuADJ4DJgAcj4ARpjEINIADqgKhE4MHt6%2BAcGp6Y4C4ZExLPGJ0naYDplCBEzEBNk%2BfkG2mPZFDPWNBCXRcQlJtg1NLbntCmP9EYPlw5IAlLaoXsTI7BxUtKhMBADUVBARh6pLJgDsFsSYBOsMBwD6T7FedI4Mr4RPotPUu32pAO5xM/islwAIiYNABBGGwgD0iJ2e0OACpgCdBOjkhdrrd7sQGBAAG6oPDodFLZJgiGQg7Ig5uA4CWgAT2BDFQhzc1n5cIOR0BGKxp1x%2BJudweALR1Np4KukI4K1onAArLw/BwtKRUJw%2BZZrAcFGsNpgDuZ/DxSARNCqVgBrEDqwIAOgAnGYzIFLpIPV6NJIuL79JxJFr7XrOLwFCANLb7Ss4LAYIgUKgWMk6AlyJQ0Fmc4lGixgFxvQmaLQCAk4xBYlHYhFGuzODaC2xBAB5BgcqNYFiGYDiHW8fC3WqkzBx0chVQ1Lw1tu8U6dKO0PCxYgtjxYKMEYh4FjLlY7JjABQANTwmAA7l3koxlzJBCIxOwpC/5Eo1FHdGZ9CHFB%2BUsfRNzjSAVlQZJuhnABaLszAOOCWFRfY4KYJswUhU0qAIWNOhqboXAYdxPFaPQwjmMoKj0AoMgECY/C4Uh6O6AYaOGFjqlqARenGcjcm4wjeJ6GYOKGRJuJmJi9GmPoJIWKSVlNdZNj0A9MC2HhVQ1SNZ31DhYQAJQAWQOYBkGQA5yzdJCIA3BgvHOA4IENKxQIOXBCBIS0zGtYEPELehiD8/wzCWXg7VHJYVgQTAmCwRIIF0jgI1IY9/H8N0styvL8uCbVdUM2N40TGLSBTdMC2zEK8wgGqixAEsywrPgPlrSgG1nJtmGIVtuF4DtGAIHs%2B1nAchxHXVxyIvApxnXVMHnZBF20ldBDXWcNy3HcMC2XUDyPE8%2BAMC9rzvB8n0Gr833ET9%2BEERQVHUWddBYgwjGAo1QJ2iCUr1GDMngxCCK6TISLInJmJCUjFNoli2MyWTEbSBiGHhriOnBviZMEmGeO6fjZlKSS5Lx6HyYU6iya4FSzXUljNPW1LNVIIreEMkzzMs6zbPsxznKWVz3OsYFvKIUKrRY5lM1qhIwrpqKkydJJso0S5LnC9UNA1j11QADiysM0t4TLsvyy3csKqMStsMroq0ZM0wgJBGrqigGrlpqSy4csWKrGtiDrbrdV6ltn2G7tewGmbMEHIxprHPAJ0cBao2Whclxu1c1W2zdt363cDqiw9j0G08zqvG970fbUbUe4RRHu6RG%2Be383oCQCvtMH6bD%2B%2BAoKBgQQbMMG5ucCBXBRj1YfQTHKlYtHuhnpfCkyBeRkJuoKYorhZ%2B33HqdJpSt93oSD/EmnT%2BWVY1I/W1bhZk22Y56MjLMiyrJsrg7LdLhXLckiMLNyIEbBeXwJLRWgVvYhTCv4SK5UnapXSubHKVtLbs1tjGe2CZHYOlIM6SQ6tNba11pcfWRt/Am38PpYqOD8GxRNmPLBBkGEq1IFOYOENJBAA%3D))
ARM's standard calling convention passes the first arg in `r0`, which is also the return-value register. So all we need to do is return with `bx lr` (2 bytes).
```
// float f(int)
  // machine code hex        // assembly
  70 47                      bx lr
```
**The same trick can work for any ISA if you can justify a custom calling convention**. Normally that's fine, but on machines that use IEEE754 FP the challenge reduces to type-punning, and a calling convention that trivializes it is less interesting. e.g. for x86, you could normally justify taking an integer arg in XMM0, which is where you'd want a scalar `float`. ([Tips for golfing in x86/x64 machine code](https://codegolf.stackexchange.com/questions/132981/tips-for-golfing-in-x86-x64-machine-code/165020#165020))
## x86-64 machine code, with custom calling convention, 1 byte
**1-byte `c3 ret` for x86-64.**
Another justification could be that we take the input by reference and update in-place. Like C `void f(void*p){}` - mutate the pointed-to `int` object from `int` to `float`, which is a no-op in asm.
(As a C function, that wouldn't make it well-defined to point a `float*` at an `int`, still a strict-aliasing violation. It might make it work in practice if it couldn't be inlined, forcing the compiler to keep its hands off. But this is a machine code answer. Obviously in real asm you'd never call this, it doesn't do anything.)
## x86-64 machine code with AMD64 System V calling convention, 5 bytes
It's the same length as a `call` instruction, making it pointless not to inline, but whatever. :/
```
   66 0f 6e c7             movd   xmm0,edi
   c3                      ret
```
AVX `vmovd xmm0,edi` is the same 4-byte length.
### x86 with custom 3DNow! calling convention, 4 bytes
Did anyone ever use the low element of an mm register for scalar float with 3DNow!, like how SSE/SSE2 use the bottom of an `xmm` register for scalar float/double? Possible, although there [aren't scalar 3DNow! instructions](https://en.wikipedia.org/wiki/3DNow!) like SSE `addss`, only packed float like `pfadd`. So you might get slowdown from subnormals in the high half. Still it's plausible.
```
# int arg in EDI,  float return value in MM0
    0f 6e c7                movd   mm0,edi
    c3                      ret
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~36~~ ~~34~~ ~~30~~ 23 bytes
```
#define f(x)*(float*)&x
```
[Try it online!](https://tio.run/##NU/LbsIwELznK1ZUIDsY6ndsAV9COUQhjiwFpyKRiory63VtIuY0s9rZmW12XdPE@HFtnQ8tOPTAJXL9UE8l3jzirfYB4eJZQEI/hA6mdpzOFzjBExitjOJCCEYy1xWzlaGZC20Es9ISEFxLxZixKs@VtlpqavKcKmnTGieQLJzJShqhpYH58Apzwx2QDxP4Ez2AhyOM/rcdHMoFMHy@ZfnSaWO7xbD0zPi@J69Dq/We0f6a6q73nLqvsCLLB/5CYLmVKMZL5lzM8a9xfd2NcffzDw "C (gcc) – Try It Online")
-2 thanks to m90
-4 thanks to Digital Trauma and mousetail
-7 thanks to jdt
Unsafe code go brr
```
#define f(x)*(float*)&x // Macrotaking an int, returning a float
#define f(x)            // Boilerplate
                     &x   // Pointer to the input
             (float*)     // Reinterpret it as a pointer to a float instead of an int
            *             // Get the value at that pointer, now a float
```
[Answer]
# [Python](https://www.python.org), 55 bytes
```
lambda n:unpack('f',pack('I',n))[0]
from struct import*
```
[Attempt This Online!](https://ato.pxeger.com/run?1=LY5LCsIwGIT3nuLftZUIeT8KHsAz1C5qJVi0SYjpwrO4KYjeyduYUlfzMcww8_yER7p4N7_s_viekt3pr7p14-ncgasnF7r-Wha2QCscCuSqqsHtxkY_wj3FqU8wjMHHtP3XvfURHAwOGoKVFpQxRhBklooYpfHCTGpGDDcIGJVcEKKNWHwhjeQS68XHgpscowhyhRKuuGaS67beAIQ4uFTaMr9ZZ-d51R8)
[Answer]
# [Python](https://www.python.org), ~~69~~ ~~67~~ 65 bytes
```
lambda x:((x&8388607)/2**23+1)*2**((x>>23&255)-127)*(1-(x>>30&2))
```
[Attempt This Online!](https://ato.pxeger.com/run?1=NZBLasMwEEDp1qcQXgTJjVyNRt9ADL1Hu3BJTA2OY2K1OGfpJlDaO7WnqWRRLfQZvXnDzMf3dA2v5_H22e2fvt5Cx93P49CeXg4tWXaULhuHzhlh2YOsKon3wKp4iR9NI3EjtWYcpGUVBZ5iKDaSsSz6vXsOxznMZE_KsixAWKclIgLhDSEEa1AiLhDKCwVWOaGMszqBxoK3TmRQ1hYSKNCBMt5Ko41MGBqH4JXPmKgzFY1RCGAAPDplM43SKA3gvE40t6qWyoN3HlBbJSEX1sYbZYT7N6Y8oZWPheQa4zGWdKmhojtfyNCPR9KPZO20nsOlnyir52noQ_qaKdsVUUWWLbnGQZzaiUYog9s1O8O05E3JWGYjeHxvB7rk97pNl34MNGq6GI4yVuQp3275_AM)
[Answer]
# [Ruby](https://www.ruby-lang.org/), 29 bytes
Same technique as [solid.py's Python answer](https://codegolf.stackexchange.com/a/252946/11261).
```
->n{[n].pack(?I).unpack1(?f)}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72kqDSpcsEiN9ulpSVpuhZ7de3yqqPzYvUKEpOzNew9NfVK80BMQw37NM1aiJqb8QUKbtGGBuYWpkbGxsaGsVxQvpm5oaW5hQGMb2xmYWxoaWIJ4RsbmZmYGhpaWJrC5E3NLM1MzAwsYPIGpiaWQC1GsRBrFiyA0AA)
[Answer]
# [Go](https://go.dev), 29 bytes
```
import."math"
Float32frombits
```
[Attempt This Online!](https://ato.pxeger.com/run?1=XZBNTsMwEEbFNqeIwqaWUstjj39mwbYbNlzBVLhEbZIquGxQT8ImQuIS3AROgxsT0dYb61nzvm_k949NP37t_XrrN09l65uuaNp9P8SSV6GN1echhqX7vs2PvGp9fK6KVz-U4W61631UMgx9-9jElzz6c3MfDt16ilqw8q14GJou7roFCOu0VEpBHc6A1YoDinRAIAkEi06gcVazc9VYIOtEVv-A1ZJbOKlCOUBDVhpt5IWojFNASJM4A6sFz15qTaUABoCUQ3vlK2lQAzjSyf8HVi8tcokE5AiUtijhamFtyKARbuqd4dR7kS40UtpJTukzpPQ0Nu1xzH86jvn-BQ)
wow builtins
[Answer]
# [PARI/GP](https://pari.math.u-bordeaux.fr), 53 bytes
```
n->(1-n>>31*2)*if(e=n>>23%256,(1+n/2^23%1.)<<(e-127))
```
[Attempt This Online!](https://ato.pxeger.com/run?1=LY5NCsIwEIWvEgQhqYlmZvILtRcRlS6sFCQE0UXP4qYg4pm8jQm6mu97vAfzeOf-Oh7PeX4ObPu63wYVPjapjoNKXUfQoGjGgZ-2xZCWaJ3ksEobPBSDtWhbflKAXoj_eOpzvkw8MdWxfB3TreCiyoINPAkh2Q60DxaJCCQr7DxEH3RlcoEgmigZoTMWIERbc-uiM06HmmtrYqmhZGWCYLwJ5EzY_x-Y59_9Ag)
[Answer]
# [MATL](https://github.com/lmendo/MATL), 7 bytes
```
7Y%10Z%
```
Try it at [MATL online](https://matl.io/?code=7Y%2510Z%25&inputs=1078523331&version=22.7.4)! Or [verify all test cases](https://tio.run/##DcqpEYBQDABRnz6@z314SsCAAg@O/kPczpt97@/pq@NYhOfqbW/CSGMRIZj0oIrESfEUKi0QdjWiLBs1L1fHHEXTmocBgUlDU1zzBw).
### Code explanation
```
      % Implicit input: number in 'double' data type
7Y%   % Cast to 'uint32'
10Z%  % Convert to 'single' without changing underlying data
      % Implicit display
```
[Answer]
# [C++ (GCC)](https://gcc.gnu.org), 30 bytes
```
[](int x){return*(float*)&x;};
```
This is just Seggan's C answer using C++11's lambda syntax instead of a named function.
[Answer]
# [J-uby](https://github.com/cyoce/J-uby), 27 bytes
Port of [my Ruby answer](https://codegolf.stackexchange.com/a/252963/11261).
```
-[I]|~:pack&?I|~:unpack1&?f
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m700K740qXLBIjfbpaUlaboWu3WjPWNr6qwKEpOz1ew9gazSPBDbUM0-DaLiZnyBglu0oYG5hamRsbGxYSwXlG9mbmhpbmEA4xubWRgbWppYQvjGRmYmpoaGFpamMHlTM0szEzMDC5i8gamJJVCLUSzEmgULIDQA)
## Explanation
```
  -[I] |            # Construct an array with one element (the input), then
  ~:pack & ?I |     # pack it into a binary string
  ~:unpack1 & ?f |  # unpack it into a float
```
[Answer]
# [C# (.NET Core 6)](https://www.microsoft.com/net/core/platform), 30 bytes
```
BitConverter.Int32BitsToSingle
```
[.NET Fiddle!](https://dotnetfiddle.net/jFQmn0)
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 48 bytes
```
f=x=>x<0?-f(x^1<<31):x>>24?f(x-2**23)*2:x/2**149
```
[Try it online!](https://tio.run/##bc7LDoIwEAXQvV8CJNWZzvSFPP7EhCAYCaFGjOnf17qmu8k9uTezDN9hH9/P10ds/j7FOLeh7UIDvZiLcMOmISzr0HWS@xQIWVWSykrW4ZJOZBevp9Fvu1@n8@ofxVwgGKskUeqVGdMGnbGQM9KW0LE7mkgIrBRDdlRpp1mDzRatYwOs@YiZJ4RENmxJ838s/gA "JavaScript (Node.js) – Try It Online")
No cast
]