web-dev-qa-db-ja.com

floatまたはdoubleのバイナリ表現を表示するにはどうすればよいですか？

浮動小数点数のバイナリ（または16進）表現を表示したいと思います。私は手で変換する方法を知っています（メソッド here を使用）が、同じことを行うコードサンプルを見ることに興味があります。

私は特にC++とJavaソリューションに興味がありますが、どの言語でも特に簡単になるのではないかと思うので、この言語不可知論。他の言語でいくつかの解決策を見たいです。

EDIT：C、C++、C＃、およびJavaを十分に取り上げました。リストに追加したい代替言語の達人はいますか？

language-agnosticfloating-point
38
Bill the Lizard

C/C++は簡単です。

union ufloat {
  float f;
  unsigned u;
};

ufloat u1;
u1.f = 0.3f;

次に、u1.uを出力します。 この実装 に適応できます。

同様に簡単に倍増します。

union udouble {
  double d;
  unsigned long u;
}

doubleは64ビットだからです。

Javaは少し簡単です： Float.floatToRawIntBits（） と組み合わせて Integer.toBinaryString（） と Double.doubleToRawLongBits を組み合わせて Long.toBinaryString（） 。

31
cletus

Cで：

int fl = *(int*)&floatVar;

&floatVarはアドレスメモリを取得し、(int*)はこのアドレスメモリへのポインタになり、最後に*はintの4バイト浮動小数点の値を取得します。その後、バイナリ形式または16進形式を印刷できます。

25
bslima

Java：Google検索で Sunのフォーラム でこのリンクが見つかります

具体的には（私はこれを自分で試したことはありません）

long binary = Double.doubleToLongBits(3.14159);
String strBinary = Long.toBinaryString(binary);
7
Jason S

.NET（C＃を含む）には、多くの型を受け入れるBitConverterがあり、生のバイナリにアクセスできます。 16進数を取得するには、ToString("x2")が最も一般的なオプションです（おそらくユーティリティメソッドにラップされています）。

    byte[] raw = BitConverter.GetBytes(123.45);
    StringBuilder sb = new StringBuilder(raw.Length * 2);
    foreach (byte b in raw)
    {
        sb.Append(b.ToString("x2"));
    }
    Console.WriteLine(sb);

奇妙なことに、base-64には1行の変換（Convert.ToBase64String）、しかしbase-16はもっと手間がかかります。 Microsoft.VisualBasicを参照しない限り、その場合：

long tmp = BitConverter.DoubleToInt64Bits(123.45);
string hex = Microsoft.VisualBasic.Conversion.Hex(tmp);
6
Marc Gravell

私はこのようにしました：

/*
@(#)File:           $RCSfile: dumpdblflt.c,v $
@(#)Version:        $Revision: 1.1 $
@(#)Last changed:   $Date: 2007/09/05 22:23:33 $
@(#)Purpose:        Print C double and float data in bytes etc.
@(#)Author:         J Leffler
@(#)Copyright:      (C) JLSS 2007
@(#)Product:        :PRODUCT:
*/

/*TABSTOP=4*/

#include <stdio.h>
#include "imageprt.h"

#ifndef lint
/* Prevent over-aggressive optimizers from eliminating ID string */
extern const char jlss_id_dumpdblflt_c[];
const char jlss_id_dumpdblflt_c[] = "@(#)$Id: dumpdblflt.c,v 1.1 2007/09/05 22:23:33 jleffler Exp $";
#endif /* lint */

union u_double
{
    double  dbl;
    char    data[sizeof(double)];
};

union u_float
{
    float   flt;
    char    data[sizeof(float)];
};

static void dump_float(union u_float f)
{
    int exp;
    long mant;

    printf("32-bit float: sign: %d, ", (f.data[0] & 0x80) >> 7);
    exp = ((f.data[0] & 0x7F) << 1) | ((f.data[1] & 0x80) >> 7);
    printf("expt: %4d (unbiassed %5d), ", exp, exp - 127);
    mant = ((((f.data[1] & 0x7F) << 8) | (f.data[2] & 0xFF)) << 8) | (f.data[3] & 0xFF);
    printf("mant: %16ld (0x%06lX)\n", mant, mant);
}

static void dump_double(union u_double d)
{
    int exp;
    long long mant;

    printf("64-bit float: sign: %d, ", (d.data[0] & 0x80) >> 7);
    exp = ((d.data[0] & 0x7F) << 4) | ((d.data[1] & 0xF0) >> 4);
    printf("expt: %4d (unbiassed %5d), ", exp, exp - 1023);
    mant = ((((d.data[1] & 0x0F) << 8) | (d.data[2] & 0xFF)) << 8) |
              (d.data[3] & 0xFF);
    mant = (mant << 32) | ((((((d.data[4] & 0xFF) << 8) |
              (d.data[5] & 0xFF)) << 8) | (d.data[6] & 0xFF)) << 8) |
              (d.data[7] & 0xFF);
    printf("mant: %16lld (0x%013llX)\n", mant, mant);
}

static void print_value(double v)
{
    union u_double d;
    union u_float  f;

    f.flt = v;
    d.dbl = v;

    printf("SPARC: float/double of %g\n", v);
    image_print(stdout, 0, f.data, sizeof(f.data));
    image_print(stdout, 0, d.data, sizeof(d.data));
    dump_float(f);
    dump_double(d);
}


int main(void)
{
    print_value(+1.0);
    print_value(+2.0);
    print_value(+3.0);
    print_value( 0.0);
    print_value(-3.0);
    print_value(+3.1415926535897932);
    print_value(+1e126);
    return(0);
}

Sun UltraSPARCで実行すると、次の結果が得られました。

SPARC: float/double of 1
0x0000: 3F 80 00 00                                       ?...
0x0000: 3F F0 00 00 00 00 00 00                           ?.......
32-bit float: sign: 0, expt:  127 (unbiassed     0), mant:                0 (0x000000)
64-bit float: sign: 0, expt: 1023 (unbiassed     0), mant:                0 (0x0000000000000)
SPARC: float/double of 2
0x0000: 40 00 00 00                                       @...
0x0000: 40 00 00 00 00 00 00 00                           @.......
32-bit float: sign: 0, expt:  128 (unbiassed     1), mant:                0 (0x000000)
64-bit float: sign: 0, expt: 1024 (unbiassed     1), mant:                0 (0x0000000000000)
SPARC: float/double of 3
0x0000: 40 40 00 00                                       @@..
0x0000: 40 08 00 00 00 00 00 00                           @.......
32-bit float: sign: 0, expt:  128 (unbiassed     1), mant:          4194304 (0x400000)
64-bit float: sign: 0, expt: 1024 (unbiassed     1), mant: 2251799813685248 (0x8000000000000)
SPARC: float/double of 0
0x0000: 00 00 00 00                                       ....
0x0000: 00 00 00 00 00 00 00 00                           ........
32-bit float: sign: 0, expt:    0 (unbiassed  -127), mant:                0 (0x000000)
64-bit float: sign: 0, expt:    0 (unbiassed -1023), mant:                0 (0x0000000000000)
SPARC: float/double of -3
0x0000: C0 40 00 00                                       .@..
0x0000: C0 08 00 00 00 00 00 00                           ........
32-bit float: sign: 1, expt:  128 (unbiassed     1), mant:          4194304 (0x400000)
64-bit float: sign: 1, expt: 1024 (unbiassed     1), mant: 2251799813685248 (0x8000000000000)
SPARC: float/double of 3.14159
0x0000: 40 49 0F DB                                       @I..
0x0000: 40 09 21 FB 54 44 2D 18                           @.!.TD-.
32-bit float: sign: 0, expt:  128 (unbiassed     1), mant:          4788187 (0x490FDB)
64-bit float: sign: 0, expt: 1024 (unbiassed     1), mant: 2570638124657944 (0x921FB54442D18)
SPARC: float/double of 1e+126
0x0000: 7F 80 00 00                                       ....
0x0000: 5A 17 A2 EC C4 14 A0 3F                           Z......?
32-bit float: sign: 0, expt:  255 (unbiassed   128), mant:                0 (0x000000)
64-bit float: sign: 0, expt: 1441 (unbiassed   418), mant:      -1005281217 (0xFFFFFFFFC414A03F)
4
Jonathan Leffler

Python：

コード：

import struct

def float2bin(number, hexdecimal=False, single=False):
    bytes = struct.pack('>f' if single else '>d', number)
    func, length = (hex, 2) if hexdecimal else (bin, 8)
    byte2bin = lambda byte: func(ord(byte))[2:].ljust(length, '0')
    return ''.join(map(byte2bin, bytes))

サンプル：

>>> float2bin(1.0)
'1111110011110000000000000000000000000000000000000000000000000000'
>>> float2bin(-1.0)
'1011111111110000000000000000000000000000000000000000000000000000'
>>> float2bin(1.0, True)
'3ff0000000000000'
>>> float2bin(1.0, True, True)
'3f800000'
>>> float2bin(-1.0, True)
'bff0000000000000'
3
quantum

Haskellでは、アクセス可能な浮動小数点の内部表現はありません。ただし、FloatやDoubleなど、多くの形式からバイナリシリアル化を行うことができます。次のソリューションは、Data.Binaryサポートのインスタンスを持つすべてのタイプに一般的です。

module BinarySerial where

import Data.Bits
import Data.Binary
import qualified Data.ByteString.Lazy as B

elemToBits :: (Bits a) => a -> [Bool]
elemToBits a = map (testBit a) [0..7]

listToBits :: (Bits a) => [a] -> [Bool]
listToBits a = reverse $ concat $ map elemToBits a

rawBits :: (Binary a) => a -> [Bool]
rawBits a = listToBits $ B.unpack $ encode a

RawBitsを使用して変換を実行できます。

rawBits (3.14::Float)

しかし、この方法でフロート値にアクセスする必要がある場合、おそらく何か間違ったことをしていることになります。実際の質問は、浮動小数点数の指数と仮数にアクセスする方法ですか？答えは exponent およびプレリュードの仮数：

significand 3.14
0.785

exponent 3.14
2
3
Zouppen

（Javaの）FloatクラスとDoubleクラスの両方にtoHexString（ 'float'）メソッドがあるので、これは16進変換にほとんど対応します。

Double.toHexString(42344);
Float.toHexString(42344);

やさしい！

3
Gareth

16進数の指数表記を取得することがいかに些細なことであるかについて言及することを気にする人はいないようです。

#include <iostream>
#include <cstdio>

using namespace std;

int main()
{
    // C++11 manipulator
    cout << 23.0f << " : " << std::hexfloat << 23.0f << endl;
    // C equivalent solution
    printf("23.0 in hexadecimal is: %A\n", 23.0f);
}
3
Massimiliano

私はここで投稿することを考えなければならなかったので、これは仲間のコーダーがCで悪事をするように促すかもしれないからです。三度考えます。

免責事項は別として、ここに行きます。

まず、バイナリ形式の長い符号なし変数を印刷するための関数を作成します。

void printbin(unsigned long x, int n)
{
  if (--n) printbin(x>>1, n);
  putchar("01"[x&1]);
}

残念ながら、この関数を直接使用してfloat変数を出力することはできないため、少しハックする必要があります。このハックは、おそらく Carmackの逆平方根 Quakeのトリックについて読んだすべての人になじみがあるように見えます。アイデアは、float変数に値を設定し、long integer変数に同じビットマスクを取得することです。したがって、fのメモリアドレスを取得し、それをlong *値に変換し、そのポインターを使用して、fのビットマスクをlong unsignedとして取得します。この値を長い符号なしで印刷すると、結果は混乱になりますが、ビットは元の浮動小数点値と同じであるため、実際には問題ではありません。

int main(void)
{
  long unsigned lu;
  float f = -1.1f;

  lu = *(long*)&f;
  printbin(lu, 32);
  printf("\n");
  return 0;
}

この構文がひどいと思うなら、あなたは正しい。

3
Ville Salonen

C＃でこのようなコードを使用すると、float変数をint変数（またはdoubleからlong）に簡単に変換できます。

float f = ...;   
unsafe
{
    int i = *(int*)&f;
}
2
Ivan Kochurkin

C++では、次の方法でバイナリ表現を表示できます。

template <class T>
std::bitset<sizeof(T)*8> binary_representation(const T& f)
{
   typedef unsigned long TempType;
   assert(sizeof(T)<=sizeof(TempType));
   return std::bitset<sizeof(T)*8>(*(reinterpret_cast<const TempType*>(&f)));
}

ここでの制限は、ビットセットの長いパラメーターが符号なしの長いため、フロートまで機能するためです。ビットセットとアサートを拡張する以外のものを使用できます。

ちなみに、クレタスの提案は、ダブル（1または0）表現を表示するものが必要であるにもかかわらず、ダブルをカバーするために「unsingned long long」が必要であるという意味で失敗します。

0
Gaetano Mendola

将来の参照のために、C++ 2aは新しい関数テンプレートbit_cast仕事をします。

template< class To, class From >
constexpr To bit_cast(const From& from) noexcept;

単に電話することができますが、

float f = 3.14;
std::bit_cast<int>(f);

詳細については、 https://en.cppreference.com/w/cpp/numeric/bit_cast を参照してください

0
JohnKoch