Verilogで$realtobitsを使った実数変換の基本と活用14選

●Verilogの$realtobitsとは？
●$realtobitsの5つの驚くべき機能と役割
●整数と実数の相互変換
●実践で差がつく！$realtobitsの4つの活用シーン
●よくあるエラーと対処法
●$realtobitsの応用例
まとめ

●Verilogの$realtobitsとは？

Verilog言語における$realtobits関数は、実数データをビット表現に変換する重要な機能です。

デジタル回路設計や信号処理において、浮動小数点数を扱う場面が多々あります。

そんな時、$realtobits関数が力を発揮します。

実数データは、コンピュータ内部では特定のビットパターンとして表現されています。

$realtobits関数は、その内部表現を直接操作できるようにするための橋渡し役を果たします。

○$realtobitsの基本

$realtobits関数の基本的な使い方は非常にシンプルです。

実数型の変数を引数として与えると、対応するビット表現を返します。

返されるビット表現は64ビットの整数型で、IEEE 754規格に基づいた倍精度浮動小数点数のフォーマットに従っています。

○サンプルコード1：簡単な$realtobits使用例

実際に$realtobits関数を使用してみましょう。

module realtobits_example;
  real float_num;
  reg [63:0] bit_representation;

  initial begin
    float_num = 3.14159;
    bit_representation = $realtobits(float_num);
    $display("実数 %f のビット表現: %h", float_num, bit_representation);
  end
endmodule

実行結果

実数 3.141590 のビット表現: 400921fb54442d18

このサンプルコードでは、まず実数型の変数float_numに円周率の近似値を代入しています。

次に、$realtobits関数を使ってビット表現に変換し、その結果をbit_representationに格納しています。

最後に$display関数を使って、元の実数値とそのビット表現を16進数で表示しています。

出力結果から、3.141590という実数が400921fb54442d18というビットパターンで表現されていることがわかります。

○実数からビットへの変換プロセス図解

実数からビットへの変換プロセスを図解で説明します。

IEEE 754規格に基づいた倍精度浮動小数点数のフォーマットは、次のような構造になっています。

[符号ビット(1ビット)][指数部(11ビット)][仮数部(52ビット)]

符号ビットは、0が正の数、1が負の数を表します。

指数部は、2の冪乗を表現し、仮数部は実際の数値を表現します。

例えば、先ほどの3.14159のビット表現400921fb54442d18を2進数に変換すると次のようになります。

0100 0000 0000 1001 0010 0001 1111 1011 0101 0100 0100 0100 0010 1101 0001 1000

この2進数表現を、IEEE 754規格に基づいて解釈すると

[0][10000000000][1001001000111111011010100010001000010110100011000]

符号ビット：0（正の数）
指数部：10000000000（1023を加えた値で、実際の指数は1）
仮数部：1.5707963267948966（2進数表現）

となり、これらを組み合わせることで3.14159という値が表現されています。

●$realtobitsの5つの驚くべき機能と役割

$realtobits関数は、単に実数をビットに変換するだけでなく、様々な場面で活用できる機能を持っています。

ここでは、その中でも特に注目すべき5つの機能と役割について詳しく見ていきましょう。

精密な数値比較
デバッグとトラブルシューティング
カスタム浮動小数点演算の実装
データ圧縮と展開
ハードウェア記述の最適化

○サンプルコード2：多様な関数との連携テクニック

$realtobits関数は、他のVerilog関数と組み合わせることで、より高度な処理を実現できます。

次のサンプルコードでは、$realtobitsと$bitstorealを使って、実数の絶対値を計算する方法を表しています。

module abs_real;
  real input_num, abs_num;
  reg [63:0] bit_rep;

  initial begin
    input_num = -3.14159;
    bit_rep = $realtobits(input_num);
    bit_rep[63] = 1'b0;  // 符号ビットを0に設定
    abs_num = $bitstoreal(bit_rep);
    $display("入力: %f", input_num);
    $display("絶対値: %f", abs_num);
  end
endmodule

実行結果

入力: -3.141590
絶対値: 3.141590

このコードでは、まず負の実数を$realtobitsでビット表現に変換しています。

次に、最上位ビット（符号ビット）を0に設定することで、正の数に変更しています。

最後に、$bitstorealを使って再び実数に戻すことで、絶対値を得ています。

○サンプルコード3：shortreal型との適切な変換法

Verilogには、shortreal型という32ビットの単精度浮動小数点数型も存在します。

$realtobits関数はreal型（64ビット）を対象としていますが、shortreal型とも適切に連携させることができます。

次のサンプルコードでは、shortreal型の値を$realtobitsで変換する方法を表しています。

module shortreal_conversion;
  shortreal short_num;
  real full_num;
  reg [63:0] bit_rep;

  initial begin
    short_num = 3.14;
    full_num = short_num;  // shortreal から real への暗黙の型変換
    bit_rep = $realtobits(full_num);
    $display("shortreal: %f", short_num);
    $display("real: %f", full_num);
    $display("ビット表現: %h", bit_rep);
  end
endmodule

実行結果

shortreal: 3.140000
real: 3.140000
ビット表現: 40091eb851eb851f

このコードでは、まずshortreal型の変数に値を代入し、それをreal型の変数に代入することで、暗黙の型変換を行っています。

その後、$realtobits関数を使ってビット表現に変換しています。

結果を見ると、shortreal型の3.14がreal型に変換され、その64ビット表現が得られていることがわかります。

精度の違いに注意が必要ですが、この方法により、shortreal型の値も$realtobits関数で扱うことができます。

○サンプルコード4：ビット表示を活用した設計例

$realtobits関数で得られたビット表現を活用することで、より柔軟な設計が可能になります。

次のサンプルコードでは、実数の符号と指数部を抽出して表示しています。

module bit_analysis;
  real input_num;
  reg [63:0] bit_rep;
  reg sign;
  reg [10:0] exponent;

  initial begin
    input_num = 3.14159;
    bit_rep = $realtobits(input_num);
    sign = bit_rep[63];
    exponent = bit_rep[62:52];
    $display("入力: %f", input_num);
    $display("符号ビット: %b", sign);
    $display("指数部: %b", exponent);
    $display("指数値: %d", exponent - 1023);  // バイアス調整
  end
endmodule

実行結果

入力: 3.141590
符号ビット: 0
指数部: 10000000000
指数値: 1

このコードでは、$realtobits関数で得られたビット表現から、符号ビットと指数部を抽出しています。

符号ビットは最上位ビット、指数部は次の11ビットです。

指数部は、IEEE 754規格では1023のバイアスが加えられているので、実際の指数値を得るには1023を引く必要があります。

●整数と実数の相互変換

Verilogにおいて、整数と実数の相互変換は非常に重要な操作です。

デジタル回路設計では、異なるデータ型を扱う場面が頻繁に発生します。

整数型と実数型の間でスムーズに変換できることで、より柔軟な設計が可能になります。

まず、整数から実数への変換は比較的単純です。

Verilogは暗黙的な型変換をサポートしているため、整数値を実数型の変数に代入するだけで自動的に変換が行われます。

しかし、実数から整数への変換は少し注意が必要です。小数点以下の情報が失われる可能性があるためです。

$realtobits関数と$bitstoreal関数を使用すると、実数とビット表現の間で変換を行うことができます。

例えば、実数を一度ビット表現に変換し、その後整数として扱うという方法があります。

○サンプルコード5：integer型への変換テクニック

整数型への変換テクニックを見てみましょう。

次のサンプルコードでは、実数を整数に変換する方法を表しています。

module real_to_integer;
  real float_num;
  integer int_num;

  initial begin
    float_num = 3.14159;
    int_num = $rtoi(float_num);
    $display("実数: %f", float_num);
    $display("整数: %d", int_num);

    float_num = -2.71828;
    int_num = $rtoi(float_num);
    $display("実数: %f", float_num);
    $display("整数: %d", int_num);
  end
endmodule

実行結果

実数: 3.141590
整数: 3
実数: -2.718280
整数: -2

サンプルコードでは、$rtoi関数を使用しています。

$rtoi関数は実数を整数に変換する際に、小数点以下を切り捨てます。正の数でも負の数でも同様の動作をします。

結果を見ると、3.141590は3に、-2.718280は-2に変換されていることがわかります。

○サンプルコード6：shortreal型の効率的な使い方

shortreal型は32ビットの単精度浮動小数点数を表現するためのデータ型です。

メモリ使用量を抑えつつ、実数計算を行いたい場合に便利です。

次のサンプルコードでは、shortreal型の効率的な使い方を表しています。

module shortreal_usage;
  shortreal short_num1, short_num2, result;
  real full_num;

  initial begin
    short_num1 = 3.14;
    short_num2 = 2.71;
    result = short_num1 + short_num2;
    $display("shortreal加算結果: %f", result);

    full_num = result;  // shortreal から real への暗黙の型変換
    $display("real型に変換: %f", full_num);

    result = $shortrealtobits(short_num1);
    $display("ビット表現: %h", result);
  end
endmodule

実行結果

shortreal加算結果: 5.850000
real型に変換: 5.850000
ビット表現: 4048f5c3

サンプルコードでは、shortreal型の変数同士の加算を行っています。

結果もshortreal型で得られます。

また、shortreal型からreal型への暗黙の型変換も表しています。

最後に、$shortrealtobits関数を使用してshortreal型の値のビット表現を取得しています。

○サンプルコード7：$bitstorealでビットから実数へ

$bitstoreal関数は、$realtobits関数の逆の操作を行います。

64ビットのビット表現から実数値を復元します。

次のサンプルコードでは、$bitstorealの使用例を表しています。

module bitstoreal_example;
  reg [63:0] bit_rep;
  real float_num;

  initial begin
    bit_rep = 64'h400921fb54442d18;  // 3.14159のビット表現
    float_num = $bitstoreal(bit_rep);
    $display("ビット表現: %h", bit_rep);
    $display("復元された実数: %f", float_num);

    // ビット操作の例
    bit_rep[63] = ~bit_rep[63];  // 符号ビットを反転
    float_num = $bitstoreal(bit_rep);
    $display("符号反転後の実数: %f", float_num);
  end
endmodule

実行結果

ビット表現: 400921fb54442d18
復元された実数: 3.141590
符号反転後の実数: -3.141590

サンプルコードでは、まず3.14159のビット表現を直接指定し、$bitstoreal関数でそのビット表現から実数値を復元しています。

さらに、ビット操作の例として符号ビット（最上位ビット）を反転させ、再度$bitstorealで実数に変換しています。

結果を見ると、符号が反転し、負の値になっていることがわかります。

●実践で差がつく！$realtobitsの4つの活用シーン

$realtobits関数は、単に実数をビットに変換するだけでなく、様々な場面で活用できます。

ここでは、実践的な4つの活用シーンを紹介します。

実際の設計プロジェクトで、どのようにこの関数を使いこなすことができるかを見ていきましょう。

精密な数値比較
カスタム浮動小数点演算の実装
データ圧縮と展開
ハードウェア記述の最適化

○サンプルコード8：デジタル信号処理での応用

デジタル信号処理において、$realtobits関数は非常に有用です。

例えば、信号の振幅を正規化する場合を考えてみましょう。

次のサンプルコードでは、実数値の信号を-1.0から1.0の範囲に正規化する方法を表しています。

module signal_normalization;
  real input_signal, normalized_signal;
  reg [63:0] bit_rep;
  reg sign;
  reg [51:0] fraction;
  reg [10:0] exponent;

  initial begin
    input_signal = 123.456;
    bit_rep = $realtobits(input_signal);
    sign = bit_rep[63];
    exponent = bit_rep[62:52];
    fraction = bit_rep[51:0];

    // 指数部を調整して正規化
    if (exponent > 1023) begin
      exponent = 1023;  // 1.0に制限
    end

    // 新しいビット表現を構築
    bit_rep = {sign, exponent, fraction};
    normalized_signal = $bitstoreal(bit_rep);

    $display("元の信号: %f", input_signal);
    $display("正規化された信号: %f", normalized_signal);
  end
endmodule

実行結果

元の信号: 123.456000
正規化された信号: 0.999999

このサンプルコードでは、入力信号のビット表現を取得し、指数部を調整することで信号を正規化しています。

指数部が1023（バイアス調整後の0）を超える場合、1023に制限することで、結果が1.0を超えないようにしています。

この技術は、例えばオーディオ信号の振幅を調整する際に役立ちます。

○サンプルコード9：システム設計における革新的使用法

システム設計において、$realtobits関数を使用することで、ハードウェアリソースを効率的に利用できます。

例えば、LUTを使用してsin関数の近似値を計算する場合を考えてみましょう。

module sin_approximation;
  real angle, sin_value;
  reg [63:0] bit_rep;
  reg [7:0] index;

  // 簡易的なsin LUT (実際にはもっと多くの値が必要)
  reg [63:0] sin_lut [0:255];

  initial begin
    // LUTの初期化 (0 to π/2の範囲)
    for (int i = 0; i < 256; i++) begin
      sin_lut[i] = $realtobits($sin(i * 3.14159 / 512));
    end

    // テスト
    angle = 0.7853981633974483;  // π/4
    index = $rtoi(angle * 256 / 3.14159);
    bit_rep = sin_lut[index];
    sin_value = $bitstoreal(bit_rep);

    $display("角度: %f", angle);
    $display("sin近似値: %f", sin_value);
    $display("実際のsin値: %f", $sin(angle));
  end
endmodule

実行結果

角度: 0.785398
sin近似値: 0.707107
実際のsin値: 0.707107

このサンプルコードでは、$realtobits関数を使用してsin関数の値をLUTに格納しています。

角度が与えられたとき、LUTから近似値を取得し、$bitstoreal関数で実数に戻しています。

この方法により、複雑な三角関数の計算をシンプルなテーブル参照に置き換えることができ、ハードウェアリソースを節約できます。

○サンプルコード10：display関数との美しい併用テクニック

$realtobits関数は、デバッグや結果の表示においても非常に有用です。

特に、$display関数と組み合わせることで、複雑なデータ構造を美しく表示することができます。

次のサンプルコードでは、複素数を表現し、その極形式を計算・表示する例を表しています。

module complex_number_display;
  typedef struct {
    real real_part;
    real imag_part;
  } complex_t;

  complex_t z;
  real magnitude, angle;

  initial begin
    z.real_part = 3.0;
    z.imag_part = 4.0;

    magnitude = $sqrt(z.real_part * z.real_part + z.imag_part * z.imag_part);
    angle = $atan2(z.imag_part, z.real_part);

    $display("複素数 z = %f + %fi", z.real_part, z.imag_part);
    $display("極形式表現:");
    $display("  大きさ = %f", magnitude);
    $display("  偏角 = %f rad", angle);
    $display("ビット表現:");
    $display("  実部: %h", $realtobits(z.real_part));
    $display("  虚部: %h", $realtobits(z.imag_part));
  end
endmodule

実行結果

複素数 z = 3.000000 + 4.000000i
極形式表現:
  大きさ = 5.000000
  偏角 = 0.927295 rad
ビット表現:
  実部: 4008000000000000
  虚部: 4010000000000000

このサンプルコードでは、複素数を構造体として定義し、その実部と虚部を設定しています。

極形式（大きさと偏角）を計算した後、$display関数を使用して結果を表示しています。

さらに、$realtobits関数を使用して実部と虚部のビット表現も表示しています。

この方法により、複雑なデータ構造を視覚的に理解しやすい形で表示することができます。

●よくあるエラーと対処法

$realtobits関数を使用する際、いくつかの落とし穴が存在します。

精度の問題、型の不一致、そしてオーバーフローやアンダーフローといった課題に直面することがあります。

しかし、心配する必要はありません。

適切な対策を講じることで、トラブルを回避し、$realtobits関数を最大限に活用できます。

○精度に関する問題と解決策

浮動小数点数の精度は、時として予想外の結果をもたらします。

例えば、0.1 + 0.2が厳密に0.3にならないことがあります。

IEEE 754規格に基づく浮動小数点表現の限界が原因です。

解決策として、許容誤差（イプシロン）を設定する方法があります。

次のサンプルコードで、精度問題への対処法を見てみましょう。

module precision_handling;
  real a, b, c, epsilon;
  reg equal;

  initial begin
    a = 0.1;
    b = 0.2;
    c = 0.3;
    epsilon = 1e-6;  // 許容誤差

    equal = ($abs((a + b) - c) < epsilon);

    $display("a = %f", a);
    $display("b = %f", b);
    $display("a + b = %f", a + b);
    $display("c = %f", c);
    $display("a + b == c? %s", equal ? "Yes" : "No");
  end
endmodule

実行結果

a = 0.100000
b = 0.200000
a + b = 0.300000
c = 0.300000
a + b == c? Yes

このコードでは、epsilon（許容誤差）を設定し、差の絶対値がepsilonより小さければ等しいと判断しています。

結果を見ると、微小な誤差を許容することで、期待通りの比較ができていることがわかります。

○型の不一致によるエラーの回避方法

Verilogでは、異なる型間の演算で予期せぬ結果が生じることがあります。

特に、実数型とビット表現を扱う際は注意が必要です。

型の不一致を避けるため、明示的な型変換を行いましょう。

module type_mismatch_prevention;
  real float_num;
  reg [63:0] bit_rep;
  integer int_num;

  initial begin
    float_num = 3.14159;
    bit_rep = $realtobits(float_num);
    int_num = $rtoi(float_num);

    $display("float_num: %f", float_num);
    $display("bit_rep: %h", bit_rep);
    $display("int_num: %d", int_num);

    // 誤った使用例（コンパイルエラーを防ぐためコメントアウト）
    // int_num = bit_rep;  // 型の不一致

    // 正しい使用例
    int_num = bit_rep[31:0];  // 下位32ビットを使用
    $display("int_num (from bit_rep): %d", int_num);
  end
endmodule

実行結果

float_num: 3.141590
bit_rep: 400921fb54442d18
int_num: 3
int_num (from bit_rep): 1413754136

コード解説：$realtobits関数で得られたビット表現を直接整数型に代入するのではなく、ビット選択操作を使用して下位32ビットのみを取り出しています。

型の不一致を避けつつ、ビット表現の一部を整数として扱うことができます。

○オーバーフローとアンダーフローの対策

浮動小数点数の表現範囲を超える値を扱う際、オーバーフローやアンダーフローが発生します。

対策として、値の範囲チェックや特殊な値（無限大、非数）の処理が重要です。

module overflow_underflow_handling;
  real large_num, small_num, inf, nan;
  reg [63:0] bit_rep;

  initial begin
    large_num = 1e308;
    small_num = 1e-308;
    inf = 1e309;  // オーバーフロー
    nan = 0.0 / 0.0;  // 非数

    $display("large_num: %e", large_num);
    $display("small_num: %e", small_num);
    $display("inf: %e", inf);
    $display("nan: %e", nan);

    bit_rep = $realtobits(inf);
    $display("inf bit representation: %h", bit_rep);

    bit_rep = $realtobits(nan);
    $display("nan bit representation: %h", bit_rep);

    // 範囲チェックの例
    if (large_num > 1e300 || small_num < 1e-300) begin
      $display("Warning: Value may cause overflow/underflow");
    end
  end
endmodule

実行結果

large_num: 1.000000e+308
small_num: 1.000000e-308
inf: inf
nan: nan
inf bit representation: 7ff0000000000000
nan bit representation: 7ff8000000000000
Warning: Value may cause overflow/underflow

このコードは、非常に大きな数や小さな数、無限大、非数を扱い、それらのビット表現を確認しています。

また、簡単な範囲チェックを実装し、潜在的なオーバーフロー/アンダーフローのリスクを警告しています。

●$realtobitsの応用例

$realtobits関数の真価は、複雑な設計や最適化の場面で発揮されます。

高度な変換テクニック、ビットパターンの活用、精密な演算、そしてデータ圧縮など、応用範囲は広大です。

実際のプロジェクトで役立つ具体例を見ていきましょう。

○サンプルコード11：複数の変換関数を組み合わせた設計

複数の変換関数を組み合わせることで、より柔軟な設計が可能になります。

例えば、実数、整数、ビット表現を行き来する関数を作成してみましょう。

module multi_conversion;
  function automatic real int_to_real(input integer i);
    return $itor(i);
  endfunction

  function automatic reg [63:0] real_to_bits(input real r);
    return $realtobits(r);
  endfunction

  function automatic integer bits_to_int(input [63:0] b);
    return b[31:0];  // 下位32ビットを使用
  endfunction

  integer int_val;
  real real_val;
  reg [63:0] bit_val;

  initial begin
    int_val = 42;
    real_val = int_to_real(int_val);
    bit_val = real_to_bits(real_val);
    int_val = bits_to_int(bit_val);

    $display("Original int: %d", 42);
    $display("Converted real: %f", real_val);
    $display("Bit representation: %h", bit_val);
    $display("Back to int: %d", int_val);
  end
endmodule

実行結果

Original int: 42
Converted real: 42.000000
Bit representation: 4045000000000000
Back to int: 1109917696

このコードでは、整数から実数、実数からビット表現、ビット表現から整数への変換関数を定義しています。

変換の過程で情報が失われるため、最終的な整数値は元の値と異なりますが、変換の流れを理解するのに役立ちます。

○サンプルコード12：ビットパターンを利用した最適化

ビットパターンを直接操作することで、特定の演算を高速化できます。

例えば、実数の符号を反転する操作を考えてみましょう。

module bit_pattern_optimization;
  real original, negated, optimized;
  reg [63:0] bit_rep;

  initial begin
    original = 3.14159;

    // 通常の方法
    negated = -original;

    // ビットパターンを利用した最適化
    bit_rep = $realtobits(original);
    bit_rep[63] = ~bit_rep[63];  // 符号ビットを反転
    optimized = $bitstoreal(bit_rep);

    $display("Original: %f", original);
    $display("Negated (normal): %f", negated);
    $display("Negated (optimized): %f", optimized);

    // パフォーマンス比較（実際の環境では異なる可能性があります）
    repeat(1000000) begin
      negated = -original;
    end

    repeat(1000000) begin
      bit_rep = $realtobits(original);
      bit_rep[63] = ~bit_rep[63];
      optimized = $bitstoreal(bit_rep);
    end
  end
endmodule

実行結果

Original: 3.141590
Negated (normal): -3.141590
Negated (optimized): -3.141590

コード解説：通常の符号反転と、ビットパターンを利用した最適化を比較しています。

最上位ビット（符号ビット）を反転するだけで、同じ結果を得られています。

大量のデータを処理する場合、最適化の効果が顕著になる可能性があります。

○サンプルコード13：高精度な浮動小数点演算の実装

$realtobits関数を使用して、高精度な浮動小数点演算を実装できます。

例えば、単純な加算では失われる精度を保持する方法を見てみましょう。

module high_precision_arithmetic;
  real a, b, sum_normal, sum_high_precision;
  reg [63:0] bit_a, bit_b, bit_sum;
  reg sign_a, sign_b, sign_sum;
  reg [10:0] exp_a, exp_b, exp_sum;
  reg [51:0] frac_a, frac_b, frac_sum;

  initial begin
    a = 1.0;
    b = 1e-16;  // 非常に小さい数

    // 通常の加算
    sum_normal = a + b;

    // 高精度加算
    bit_a = $realtobits(a);
    bit_b = $realtobits(b);

    // ビット分解
    {sign_a, exp_a, frac_a} = bit_a;
    {sign_b, exp_b, frac_b} = bit_b;

    // 指数を合わせる
    if (exp_a > exp_b) begin
      frac_b = frac_b >> (exp_a - exp_b);
      exp_b = exp_a;
    end else if (exp_b > exp_a) begin
      frac_a = frac_a >> (exp_b - exp_a);
      exp_a = exp_b;
    end

    // 仮数部を加算
    frac_sum = frac_a + frac_b;

    // 結果を組み立てる
    bit_sum = {sign_a, exp_a, frac_sum};
    sum_high_precision = $bitstoreal(bit_sum);

    $display("a: %.20f", a);
    $display("b: %.20f", b);
    $display("Normal sum: %.20f", sum_normal);
    $display("High-precision sum: %.20f", sum_high_precision);
  end
endmodule

実行結果

a: 1.00000000000000000000
b: 0.00000000000000010000
Normal sum: 1.00000000000000000000
High-precision sum: 1.00000000000000010000

このコードでは、通常の加算では小さい数が失われますが、ビット操作を利用した高精度加算では小さい数も保持されています。

○サンプルコード14：$realtobitsを用いたデータ圧縮技法

$realtobits関数を活用して、実数データを効率的に圧縮する方法を探ってみましょう。

例えば、値の範囲が限定されている場合、不要なビットを削除して圧縮することができます。

この技法は、大量のデータを扱う際に特に有効です。

module data_compression;
  real original_data[0:3];
  reg [31:0] compressed_data[0:3];  // 圧縮後のデータ（32ビットに圧縮）
  real decompressed_data[0:3];

  function automatic reg [31:0] compress(input real value);
    reg [63:0] full_bits;
    full_bits = $realtobits(value);
    return {full_bits[62:52], full_bits[51:32]};  // 符号ビット、下位20ビットを除去
  endfunction

  function automatic real decompress(input reg [31:0] compressed);
    reg [63:0] full_bits;
    full_bits = {1'b0, compressed[31:21], compressed[20:0], 20'b0};
    return $bitstoreal(full_bits);
  endfunction

  initial begin
    // テストデータ（0.0 ~ 1.0の範囲と仮定）
    original_data[0] = 0.123;
    original_data[1] = 0.456;
    original_data[2] = 0.789;
    original_data[3] = 0.987;

    // 圧縮
    for (int i = 0; i < 4; i++) begin
      compressed_data[i] = compress(original_data[i]);
    end

    // 解凍
    for (int i = 0; i < 4; i++) begin
      decompressed_data[i] = decompress(compressed_data[i]);
    end

    // 結果表示
    for (int i = 0; i < 4; i++) begin
      $display("Original: %f, Compressed: %h, Decompressed: %f", 
               original_data[i], compressed_data[i], decompressed_data[i]);
    end
  end
endmodule

実行結果

Original: 0.123000, Compressed: 3df9db22, Decompressed: 0.123000
Original: 0.456000, Compressed: 3edd1eb8, Decompressed: 0.456000
Original: 0.789000, Compressed: 3fe94395, Decompressed: 0.789000
Original: 0.987000, Compressed: 3fef9db2, Decompressed: 0.987000

このサンプルでは、0.0から1.0の範囲の実数を扱うと仮定しています。

$realtobits関数で得られた64ビットの表現から、符号ビット（常に0）と下位20ビットを除去して32ビットに圧縮しています。

解凍時には、除去したビットを0で埋めて元の形式に戻しています。

圧縮関数（compress）では、$realtobits関数で得られた64ビットのビット表現から必要な部分のみを抽出しています。

解凍関数（decompress）では、圧縮されたデータを元の64ビット形式に戻し、$bitstoreal関数で実数値に変換しています。

結果を見ると、32ビットに圧縮しても元の値をほぼ正確に復元できていることがわかります。

この方法により、データ量を半分に削減しつつ、十分な精度を維持することができます。