Фон

Формат IEEE 754 з подвійною точністю з плаваючою комою - це спосіб представити реальні числа з 64 бітами. Виглядає так:

Реальне число nперетворюється в a doubleтаким чином:

1. Біт знака sдорівнює 0, якщо число додатне, 1 в іншому випадку.
2. Абсолютне значення nпредставлено у формі 2**y * 1.xxx, тобто потужність у 2 рази від бази .
3. Показник eє y(сила 2) мінус тисяча двадцять три.
4. Фракція f- це xxxчастина (дробова частина основи), що займає найбільш значущі 52 біти.

І навпаки, бітовий візерунок (визначений знаком s, експонентом eі дробом f, кожне ціле число) представляє число:

(s ? -1 : 1) * 2 ** (e - 1023) * (1 + f / (2 ** 52))

Виклик

З огляду на дійсне число n, виведіть його 52-бітну частку doubleподання nяк ціле число.

Випробування

0.0        =>                0
1.2        =>  900719925474099 (hex 3333333333333)
3.1        => 2476979795053773 (hex 8cccccccccccd)
3.5        => 3377699720527872 (hex c000000000000)
10.0       => 1125899906842624 (hex 4000000000000)
1234567.0  =>  798825262350336 (hex 2d68700000000)
1e-256     => 2258570371166019 (hex 8062864ac6f43)
1e+256     => 1495187628212028 (hex 54fdd7f73bf3c)

-0.0       =>                0
-1.2       =>  900719925474099 (hex 3333333333333)
-3.1       => 2476979795053773 (hex 8cccccccccccd)
-3.5       => 3377699720527872 (hex c000000000000)
-10.0      => 1125899906842624 (hex 4000000000000)
-1234567.0 =>  798825262350336 (hex 2d68700000000)
-1e-256    => 2258570371166019 (hex 8062864ac6f43)
-1e+256    => 1495187628212028 (hex 54fdd7f73bf3c)

Ви можете перевірити інші номери за допомогою цього довідника C, який використовує бітові поля та об'єднання.

Зауважте, що очікувана відповідь однакова +nі -nдля будь-якого числа n.

Вхід і вихід

Діють стандартні правила.

Прийнятий формат введення:

• Число з плаваючою комою, принаймні має doubleвнутрішню точність
• Рядкове представлення числа в десятковій частині (вам не потрібно підтримувати наукові позначення, оскільки ви можете використовувати 1000...00або 0.0000...01як введення)

Для виводу допускається помилка округлення принаймні значущому біті.

Умова виграшу

Це код-гольф , тому найнижчі байти в кожній мові виграють.

C (gcc) , 42 30 байт

long f(long*p){p=*p&~0UL>>12;}

Бере вказівник на подвійний аргумент і повертає довгий .

Потрібні 64-бітні тривалості та gcc (невизначена поведінка).

Дякуємо @nwellnhof за -2 байти!

Спробуйте в Інтернеті!

Haskell, 27 31 байт

(`mod`2^52).abs.fst.decodeFloat

decodeFloatповертає значення та показник, але чомусь колишній 53-х бітний у Haskell, тому ми повинні відрізати один біт.

Спробуйте в Інтернеті!

Python 3 , 54 50 байт

f=lambda x:int(x.hex().split('.')[1].split('p')[0],16)

Спробуйте в Інтернеті!

З пропозицією Кирила:

f=lambda x:int(x.hex()[4+(x<0):].split('p')[0],16)

Спробуйте в Інтернеті!

x86_64 машинна мова для Linux, 14 байт

0:       66 48 0f 7e c0          movq   %xmm0,%rax
5:       48 c1 e0 0c             shl    $0xc,%rax
9:       48 c1 e8 0c             shr    $0xc,%rax
d:       c3                      retq

Спробуйте в Інтернеті!

MATL , 10 байт

IZ%52W\0YA

Спробуйте в Інтернеті!

Пояснення

        % Implicit input
IZ%     % Cast to uint64 without changing underlying byte representation
52W     % Push 2^52
\       % Modulus
0YA     % Convert to decimal. Gives a string. This is needed to avoid
        % the number being displayed in scientific notation
        % Implicit display

JavaScript (ES7), 52 50 байт

f=n=>n?n<0?f(-n):n<1?f(n*2):n<2?--n*2**52:f(n/2):0

<input oninput=o.textContent=f(this.value)><pre id=o>0

Не використовується, Math.floor(Math.log2(n))тому що це не гарантовано, щоб бути точним. Редагувати: збережено 2 байти завдяки @DanielIndie.

Perl 5 -pl , 28 байт

$_=-1>>12&unpack Q,pack d,$_

Спробуйте в Інтернеті!

Тестові випадки 1e-256 та 1e256 вимкнено, але це тому, що Perl 5 точно перетворює величезні чи крихітні струни з плаваючою точкою.

C (gcc) макрос, 49 байт

-DF(x)=x?ldexp(frexp(fabs(x),(int[1]){})-.5,53):0

Спробуйте в Інтернеті!

Повертає, doubleале припускаючи точність IEEE, вона не матиме дробової частини. Також зараз обробляє негативні числа.

T-SQL , 80 байт

SELECT CAST(CAST(n AS BINARY(8))AS BIGINT)&CAST(4503599627370495AS BIGINT)FROM t

Вхід береться із стовпця nтаблиці з назвою t:

CREATE TABLE t (n FLOAT)
INSERT INTO t VALUES (0.0),(1.2),(3.1),(3.5),(10.0),(1234567.0),(1e-256),(1e+256)

SQLFiddle

Хун , 25 байт

|*(* (mod +< (pow 2 52)))

Створіть загальну функцію, яка повертає вхідний мод 2^52.

Виклик:

> %.  .~1e256
  |*(* (mod +< (pow 2 52)))
1.495.187.628.212.028

JavaScript (ES7), 98 76 байт

Збережено 22 (!) Байти завдяки @Neil

Більш багатослівний, ніж відповідь Ніла , але я хотів спробувати спробувати набрані масиви .

(n,[l,h]=new Uint32Array(new Float64Array([n]).buffer))=>(h&-1>>>12)*2**32+l

Спробуйте в Інтернеті!

APL (Dyalog) , 38 байт

{0=⍵:0⋄(2*52)ׯ1+×∘2⍣(1≤⊣)÷∘2⍣(1>⊣)|⍵}

Спробуйте в Інтернеті!

Стакс , 19 14 байт

üâïc-Hò~÷]ó┬ó♪

Запустіть і налагоджуйте його

Розпакований, нерозроблений та коментований код виглядає приблизно так.

|a      absolute value
{HcDw   double until there's no fractional part
@       convert to integer type
:B      convert to binary digits
D52(    drop the first digit, then pad to 52
:b      convert back number

Виконати цей

Рубін , 39 байт

->n{[n].pack(?D).unpack(?Q)[0]&~-2**52}

Спробуйте в Інтернеті!

Іржа , 21 байт

|p|p.to_bits()&!0>>12

Досить сильно скопійований розчин C. Бере f64аргумент.

Спробуйте в Інтернеті!

Java 8 або новіших версій , 38 байт

x->Double.doubleToLongBits(x)&-1L>>>12

Спробуйте в Інтернеті!

Мова машини машини Aarch64 для Linux, 12 байт

0:   9e660000        fmov x0, d0
4:   9240cc00        and  x0, x0, #0xfffffffffffff
8:   d65f03c0        ret

Щоб спробувати це, скомпілюйте та запустіть наступну програму C на будь-якій машині Aarch64 Linux або (Aarch64) Android на пристрої під керуванням Termux

#include<stdio.h>
const char f[]="\0\0f\x9e\0\xcc@\x92\xc0\3_\xd6";
int main(){
  double io[] = { 0.0,
                  1.2,
                  3.1,
                  3.5,
                 10.0,
            1234567.0,
               1e-256,
               1e+256,
                 -0.0,
                 -1.2,
                 -3.1,
                 -3.5,
                -10.0,
           -1234567.0,
              -1e-256,
              -1e+256 };

  for (int i = 0; i < sizeof io / sizeof*io; i++) {
    double input = io[i];
    long output = ((long(*)(double))f)(io[i]);

    printf("%-8.7g => %16lu (hex %1$013lx)\n", input, output);
  }
}

Джулія 0,4 , 30 байт

x->reinterpret(UInt,x)<<12>>12

Спробуйте в Інтернеті!

Четвертий (gforth) , 42 байти

Передбачає, що поплавці подвійні за замовчуванням, а комірки довжиною 8 байт (як це відбувається на моєму комп’ютері та TIO)

: f f, here float - @ $fffffffffffff and ;

Спробуйте в Інтернеті!

Пояснення

f,             \ take the top of the floating point stack and store it in memory
here float -   \ subtract the size of a float from the top of the dictionary
@              \ grab the value at the address calculated above and stick it on the stack
$fffffffffffff \ place the bitmask (equivalent to 52 1's in binary) on the stack
and            \ apply the bitmask to discard the first 12 bits

Четверта (gforth) 4- байтова відповідь комірки, 40 байт

Натомість деякі старіші установки встановлюються за замовчуванням для 4-байтних комірок

: f f, here float - 2@ swap $FFFFF and ;

Пояснення

f,             \ take the top of the floating point stack and store it in memory
here float -   \ subtract the size of a float from the top of the dictionary
2@             \ grab the value at the address above and put it in the top two stack cells
swap           \ swap the top two cells put the number in double-cell order
$fffff         \ place the bitmask (equivalent to 20 1's in binary) on the stack
and            \ apply the bitmask to discard the first 12 bits of the higher-order cell