👳 🍇 🗻 それだけです、ポイント、出航しました！浮動小数点数を操作し、小数の固定精度で代替を開発する方法を学びます。 ⁉️ 👩‍👩‍👧‍👧 ↕️

今日は実数についてお話します。より正確には、分数数量の計算におけるプロセッサによる表示について。私たちはそれぞれ、3.5の代わりに3,4999990123という形式の数値の文字列を出力することに直面しました。さらに悪いことに、理論的な結果とプログラムコードの実行の結果として行われた結果との計算後の大きな違いです。これにはひどい秘密はありません。浮動小数点表現アプローチの長所と短所について説明し、代替の固定小数点パスを検討し、固定精度で小数のクラスを記述します。

ポイントはどこに行きますか

プロセッサが必ずしも実数を理解していなかったのは秘密ではありません。プログラミング時代のd明期、最初のコプロセッサーが登場する前は、実数はハードウェアレベルでサポートされておらず、プロセッサーがうまく機能する整数を使用してアルゴリズム的にエミュレートされていました。したがって、古き良きパスカルの実数型は現在の実数の先祖でしたが、ビットが実数の仮数と指数として論理的に解釈される整数の上位構造でした。

仮数は、本質的にドットなしで書かれた数字です。指数は、特定の数N（通常、N = 2）を上げる必要がある度合いです。そのため、仮数を掛けると、目的の数が得られます（仮数の桁容量に正確）。次のようになります。

x = m * N ^ e,  m  e —  ,         .

あいまいさを避けるため、1 <= | m | <N、つまり、番号はカンマの前に1つの記号が付いているように書き込まれますが、コンマは悪意を持って削除され、番号は整数になりました。

仮数は、本質的にドットなしで書かれた数字です。指数は、特定の数N（通常N = 2）を上げる必要がある度合いです。仮数を掛けると、目的の数が得られます。

最近では、実数を持つすべてのアルゴリズムと同様に、開発者は浮動小数点演算を避けようとしました。実数を使用したコプロセッサー処理操作は、すべてのプロセッサーで実行されたわけではありませんが、実際には、常に効率的に機能するとは限りませんでした。しかし、時間が経ち、現在では浮動小数点演算がプロセッサコアに組み込まれています。さらに、ビデオチップは実数も積極的に処理し、同じタイプの演算を並列化します。

プロセッサレベルでハードウェアによってサポートされる最新の実数も、仮数と指数に分けられます。もちろん、整数演算になじみのあるすべての演算は、実数のプロセッサ命令でもサポートされており、可能な限り迅速に実行されます。

そのような記録形式は、まず、そのような数での乗算および除算演算が非常に効果的であることに加えて、そのような形式で表される元の実数を得ることも難しくないため、すべてが非常に複雑です。この数値表現は、浮動小数点数と呼ばれます。

ダイビング標準

プロセッサレベルでサポートされる浮動小数点実数は、特別な国際標準IEEE 754で記述されています。計算の主な2つのタイプは、 単精度 （単精度）および倍精度 （倍精度） 浮動小数点 （ 浮動小数点数）です。これらの名前は、単精度と倍精度の数値のバイナリ表現のビット深度を直接反映します。単精度の表現には32ビットが割り当てられ、奇妙なことに、倍精度表現には64ビットが2回割り当てられます。

IEEE 754-2008規格の新版は、単精度と倍精度に加えて、4倍精度、さらには半精度の拡張精度も提供します。ただし、C / C ++では、floatとdoubleの他に、おそらくlong double型があり、Microsoftでは頑固にサポートされておらず、Visual C ++では代わりに通常のdoubleを置き換えます。現時点のプロセッサコアも、原則として、半精度および4倍精度のタイプをまだサポートしていません。したがって、浮動小数点ビューを選択する場合は、floatとdoubleからのみ選択する必要があります。

標準による数値の指数の基礎として、それぞれ2が使用され、上記の式は次のようになります。

 x = m * (2 ^ e),  1 <= |m| < 2; m, e —

仮数はバイナリ形式で記述され、整数部分（明らかに1に等しい）は破棄されるため、仮数がバイナリ形式で格納されるよりも1ビット長いことを決して忘れません

この標準で表すことができる数値の小数点以下の精度を計算するために博士号を取得する必要はありません。2^（23 + 1）= 16 777 216; これは、単精度で実数を表現する精度が小数点以下7桁をわずかに超えるという事実を明らかに示しています。これは、この形式では保存できないことを意味します。たとえば、123,456.78という数字は一般に小さい数字ですが、100分の1から始まる数字は間違っています。 32ビット整数にも完全に適合する1 234 567 890という形式の多数の場合、数百単位でエラーが発生するため、状況は複雑です。したがって、たとえば、C ++では、実数の場合、デフォルトでdouble型が使用されます。倍精度の数値の仮数は、すでに15桁を超えています：2 ^ 52> = 4 503 599 627 370 496すべての32ビット整数に静かに対応し、本当に大きな64ビット整数（10進数19桁）でのみエラーが発生します。原則として、数百単位ではすでに重要ではありません。より正確な情報が必要な場合は、この記事で必ず役立ちます。

出展者の方へ。これは通常の整数のバイナリ表現で、10を累乗して正規化形式の仮数を乗算して元の数を取得する必要があります。さらに、標準ではオフセットが導入されているだけであり、10のべき乗 （いわゆるバイアス指数 -オフセット指数）を得るために、バイナリ表現から減算する必要があります。比較演算を簡素化するために指数がシフトされます。つまり、単精度の場合は値127が、倍精度の場合1023が取得されます。これらはすべて非常に複雑に聞こえるので、浮動小数点型の章をスキップします。しかし、無駄に！

おおよその水泳

少し明確にするために、例を考えてみましょう。数値640 （= 512 + 128）を単精度の実数としてバイナリ形式でエンコードします。

正の数-符号ビットは0になります。
正規化された仮数を取得するには、数値を512で除算する必要があります。最大次数である数値よりも小さく、640/512 = 512/512 + 128/512または1 + 1/4になり、それぞれバイナリで1.01になりますカマキリのビットは01000000000000000000000になります。
再び1 + 1/4から640を取得するには、9に等しい指数を指定する必要があります。ちょうど2 ^ 9 = 512、仮数を正規化するときに数値を除算した数ですが、バイナリ形式ではオフセット表現が必要です。単精度の実数の場合、127を追加する必要があり、127 + 9 = 128 + 8になります。これは、バイナリ形式で10001000のように記述されます。

倍精度の場合、ほとんどすべてが同じになりますが、仮数部の小数部の右側にはさらに多くのゼロが含まれ、指数は1023 + 9 = 1024 + 8になります。つまり、最上位ビットと指数の数の間のゼロより少し大きいです：、慎重に理解すれば、すべてがそれほど怖いわけではありません。

宿題：次の定数のバイナリ表記を理解する：プラスとマイナスの無限大（ INF-無限大）、ゼロ、マイナスゼロ、および数ではない数（ NaN-数ではない）。

ブイのために泳ぐな！

1つの重要なルールがあります。数値を表現するための各形式には、泳ぐことができない独自の制限があります。さらに、C / C ++プログラムの動作は、2つの大きな正の整数の追加として小さな負が与えられたときに穏やかな顔をすることであるため、これらの制限を超えないようにすることはプログラマ次第です。ただし、整数の場合、最大値と最小値のみを考慮する必要がある場合、浮動小数点表現の実数については、数値のビット深度よりも最大値に注意を払う必要があります。指数のため、倍精度の浮動小数点表現の最大数は10 ³⁰⁸を超えます。単精度の指数でも10 ^38を超える数値をエンコードできます。 64ビット整数の最大値である「悲惨な」10 ¹⁹と比較すると、最大値と最小値を考慮する必要はほとんどないと結論付けることができますが、それらを忘れてはなりません。

整数について、最大値と最小値のみを考慮する必要がある場合、浮動小数点表現の実数については、数値のビット深度に関しては最大値よりも注意を払う必要があります。

もう1つは、精度の問題です。仮数の下の悲惨な23ビットは、小数点第8位で既にエラーを発生させます。倍精度の数値の場合、状況はそれほど嘆かわしいものではありませんが、たとえば、データ処理でポイントの後に6つの固定文字が必要で、ポイントまでの数値が非常に大きく、その下に残っているのが9文字だけである場合、小数点以下15桁が非常にすぐに問題になります。したがって、数十億ドルの金額があると、小数部分に大きな誤差が生じます。このような数の処理を集中的に行うと、数十億ユーロが「収まらなかった」という理由だけで消滅する可能性があり、小数部分の誤差が合計され、膨大な残高の未計上データが蓄積されました。

それだけが理論だったら！実際には、1000分の1セントも消えてはならず、すべての操作のエラーは厳密にゼロに等しくなければなりません。したがって、ビジネスロジックでは、原則として、C / C ++を使用しませんが、C＃またはPythonを使用します。ここで、Decimal型は既に標準ライブラリで構築されており、指定された小数点以下桁数の精度でエラーなしの小数部を処理します。高度なプログラミング言語を使用せずに非常に大きな数を処理するタスクに直面した場合、C ++プログラマは何をすべきでしょうか？はい、いつもと同じです。10進型の高レベルライブラリと同様に、高精度の小数部を操作するための1つの小さなデータ型を作成してギャップを埋めます。

浮動小数点セメントを追加する

浮動小数点を修正します。計算の精度に問題があるため、浮動小数点型を削除することに決めたため、整数型が残っています。最大ビット深度が必要なため、最大ビット幅が64ビットの整数型が必要です。

今日、教育目的のために、期間後の18文字までの精度を保証した実数の表現を作成する方法を検討します。これは、整数部分と小数部分にそれぞれ2つの64ビット整数を単純に組み合わせることによって実現されます。原則として、各コンポーネントの単一の番号の代わりに、値の配列を取得して完全な「長い」算術を取得することを誰も気にしません。しかし、精度の問題を解決するには十分であるため、小数点の前後に18桁の精度で作業し、これら2つの値の間のポイントを固定し、セメントで埋めることができます。

私にも小数を注ぎます！

まず、少しの理論。整数と整数の小数部分の2つのコンポーネントをnとfとして示します。数値自体は次の形式で表現できます。

x = n + f * 10 ^-18 （n、fは整数、0 <= f <10 ^18）

整数部分については、64ビット整数の符号付きタイプが最適であり、小数部分（符号なし）の場合、これにより将来の多くの操作が簡素化されます。

 class decimal { … private: int64_t m_integral; uint64_t m_fractional; };

この場合の整数部は、表現された数値よりも小さい最大整数です。小数部は、この数値から整数部を10 ¹⁸倍して整数に減じた結果です：f =（x-n）* 10 ¹⁸ 。

負の数値の整数部分は、数値自体を法として大きくなり、小数部分は数値自体の10進表記と一致しません。たとえば、数値–1.67の場合、コンポーネントはn = –2およびf = 0.33 * 10 ^18になります。しかし、このようなレコードを使用すると、負の数に分岐が必要ないため、加算および乗算アルゴリズムを単純化および高速化できます。

10進型の操作

もちろん、精度が向上した数値のタイプは、算術演算なしでは役に立ちません。追加は比較的簡単です：

 x = a + b * 1e-18, y = c + d * 1e-18, z = x + y = e + f * 1e-18, a, c, e: int64_t; b, d ,f: uint64_t; 0 <= b, d, f < 1e+18, z = (a + b * 1e-18) + (c + d * 1e-18) e = a + c + [b * 1e-18 + d * 1e-18] f = {b * 1e-18 + d * 1e-18} * 1e+18

NB：以降、1eの形式のすべてのエントリは整数です。

ここで、[n]は数値の整数部分を取得し、{n}は小数部分を取得しています。すべて問題ありませんが、整数の制限を覚えておいてください。値1e + 18は、符号なし64ビット整数型uint64_tの値の限界に既に近づいています（そのため、選択しました）。

 e = a + c + (b + d) div 1e+18, f = (b + d) mod 1e+18.

数値を使用した操作を実装するときは、集中的な使用を伴うため、常に2つのことを考慮する必要があります。最初に、乗算と除算の操作を最小限に抑えるために常にアルゴリズムを最適化する必要があります。そのため、最初のポイントが簡単に実行されるように、数式を事前に単純化する価値がありますこの場合、すべてを整数の除算に最小化し、残りを必要とします。第二に、計算された型の境界を越えて数値がオーバーフローする可能性のある状況をすべて確認する必要があります。そうしないと、型を使用するときに非常に明白なエラーが発生します。

もちろん、aとcを追加するときに境界値をチェックする価値があります。また、bとdが1e + 18未満であるという事実に基づいて、（b + d）<2 * 1e + 18であることがわかります。これは、最大値が最後の加算として追加されることを意味します。したがって、アルゴリズム上、除算をまったく考慮して実行速度を最適化することはできません操作：

 e = a + c; f = b + d; if (f >= 1e+18) f -= 1e+18, ++e;

ここでは、eの値の最大整数のチェックは、表示を簡単にするために省略されています。

減算については、すべてがもう少し複雑です。ここでは、符号なし整数のゼロ未満の遷移を考慮する必要があります。つまり、減算する前に2つの数値を比較する必要があります。

 e = a - c; if (b >= d) f = b - d; else f = (1e+18 - d) + b, --e;

一般的に、これまでのところすべてが簡単です。乗算と除算の前は、すべてが常に単純です。

固定精度の乗算

最初に乗算を検討してください。小数部分の数値は非常に大きく、原則として1e + 18のすぐ近くにあるため、アセンブラー言語とQレジスタでの操作を使用するか、整数値をバイパスして、各コンポーネントを1e + 9の2つの部分に分割する必要があります。この場合、乗算は1e + 18以下であり、アセンブラはまだ必要ありません。それほど高速ではありませんが、十分な64ビット整数があり、C ++内に残ります。学校と列の乗算を覚えていますか？そうでない場合は、次のことに注意してください。

a = s _a * a ₁ -a ₂ * 10 ^-9 ; b = b ₁ -b ₂ * 10 ^-9 ;

c = s _c * c ₁ -c ₂ * 10 ^-9 ; d = d ₁ -d ₂ * 10 ^-9 ;

0 <= a ₂ 、b ₂ 、c _1,2 、c _1,2 <10 ⁹ ;

s _a、c =記号（a）、記号（c）

0 <= a ₁ 、s ₁ <MAX_INT64 / 10 ^{9 9}

乗算の計算を簡素化するためのマトリックスを導入します。

U =（a ₁ 、a ₂ 、b ₁ 、b ₂ ）、

V =（c ₁ 、c ₂ 、d ₁ 、d ₂ ） ^T 、

A = V * U、

A =

| a ₁ * c ₁ a ₁ * c ₁ b ₁ * c ₁ b ₂ * c ₁ |

| a ₁ * c ₂ a ₁ * c ₂ b ₁ * c ₂ b ₂ * c ₂ |

| a ₁ * d ₁ a ₁ * d ₁ b ₁ * d ₁ b ₂ * d ₁ |

| a ₁ * d ₂ a ₁ * d ₂ b ₁ * d ₂ b ₂ * d ₂ |

マトリックスは、計算を容易にするためではなく、検証を容易にするために導入されています。実際、A ₁₁ = a ₁ * c ₁は厳密にMAX_INT64 / 10 ¹⁸未満でなければならず、対角線の値は次のとおりです。A12 = a ₁ * c ₂およびA ₂₁ = a ₂ * c ₁は厳密にMAX_INT64 / 109未満でなければなりません。コンポーネントを追加するときにこれらの係数を乗算します。

e = A ₁₁ * 10 ¹⁸ +（A ₁₂ + A ₂₁ ）* 10 ⁹ +（A ₁₃ + A ₂₂ + A ₃₁ ）+（A ₁₄ + A ₂₃ + A ₃₂ + A ₄₁ ）div 10 ¹⁸ 、

f =（A ₁₄ + A ₂₃ + A ₃₂ + A ₄₁ ）mod 10 ¹⁸ +（A ₂₄ + A ₃₃ + A ₄₂ ）+（A ₃₄ + A ₄₃ ）div 10 ⁹

ここでは、ゼロに等しいという理由だけで、用語A ₄₄ div 10 ¹⁸を省略します。もちろん、各追加の前に、MAX_INT64を超えているかどうかを確認する価値があります。幸いなことに、行列のすべてのコンポーネントと中間結果に対して、符号なしの型uint64_tを操作できます。最後に行う必要があるのは、結果の符号s _e = s _a xor s _cを決定し、負の数の整数と小数部を修正することです。整数を1減らし、小数を1から減算します。ここで、一般的に、すべての乗算では、主なことは非常に注意することです。アセンブラを使用すると、すべてがはるかに簡単になりますが、この資料はC ++ Academyの範囲を超えています。

登録およびSMSを使用しない除算アルゴリズム

列分割アルゴリズムを覚えていれば、よくできていますが、ここでは必要ありません。数学と不等式を持つ小さな魔術のおかげで、逆数x ^-1を計算し、x ^-1で乗算を実行するのが簡単になります。そこで、問題を解決します

y = x ^-1 = 1 /（a + b * 10 ^-18 ）= c + d * 10 ^-18 。

簡単にするために、正のxの逆数を見つけることを検討してください。 xのコンポーネントの少なくとも1つがゼロに等しい（ただし、一度に両方ではない）場合、計算は大幅に簡素化されます。 a = 0の場合：

 y = 1 / (b * 1e-18) = 1e+18 / b, e = 1e+18 div b, f = 1e+18 mod b;  b = 0, a = 1,  y = e = 1, f = 0; ec b = 0, a > 1, : y = 1 / a, e = 0, f = 1e+18 div a.

より一般的な場合、xに非ゼロの小数部と整数部が含まれる場合、この場合、方程式は次のようになります。

  a > 1, b != 0 : y = 1 / (a + b * 1e-18) < 1,  e = 0, f = 1e+18 / (a + b * 1e-18).

ここで、最大次数10を見つける必要があります。これはa以下であり、次のアクションを繰り返し実行します。

 k = max(k): 1e+k <= a, u = 1e+18, v = (a * 1e+18-k + b div 1e+k); f = (u / v) * 1e+18-k, for (++k; k <=18; ++k) { u = (u % v) * 10; if (!u) break; //    f += u / v * 1e+(18-k); }

ここでは、同じ係数（10の累乗）による分数の乗算と除算を使用し、次の10の累乗に対する除算の除算と剰余を段階的に計算します。

それらを計算することは完全に不要であり、事前に知っており、しばしば必要になるため、0から18までの数十度の配列を持つことは非常に便利です。

型変換

ぼんやりとした浮動小数点数を2倍にして、真新しい10進数に変換するのに十分なことがわかっています。

 decimal::decimal(double value) : m_integral(static_cast<int64_t>(std::floor(value)) m_fractional(static_cast<int64_t>(std::floor( (value - m_integral) * 1e+18 + 0.5)) { normalize(); } void decimal::normalize() { uint64_t tail = m_fractional % 1e+3; if (tail) { if (tail > 103/2) m_fractional += 1e+3 - tail; else m_fractional -= tail; } }

ここで、103は、実際には、それを超えるとdoubleが正確でなくなるエラーです。必要に応じて、エラーをさらに減らすことができます。ここで^は、表示を明確にするために10 ^18〜15が必要です。とにかく、変換後の正規化が必要になります。正確にdoubleは10進数の小数部よりも明らかに低いからです。さらに、doubleがint64_tを超える場合、そのような条件下で、小数部が数値の整数部を正しく変換できない場合を考慮する必要があります。

フロートの場合、すべてが似ていますが、エラーは桁違いに大きくなります：10 ^18-7 = 10 ¹¹ 。

decimal , m_integral. m_integral, m_fractional.

decimal double float :

 return m_integral + m_fractional * 1e-18;

. , , , decimal separator , . «» m_precision .

, . , , , , — , .

, decimal, .

GITHUB

decimal, .

, !

, C/C++ . , Python C#, 15–18 , .

decimal , int64_t. , double float , . , decimal . , .

, . double float, , . , , , , . , !

#192.

: Qualab , ++ Parallels

ハッカーを購読する

それだけです、ポイント、出航しました！ 浮動小数点数を操作し、小数の固定精度で代替を開発する方法を学びます。