JavaScriptで浮動小数点数の精度を処理する方法は？

次のダミーテストスクリプトがあります。

function test() {
  var x = 0.1 * 0.2;
  document.write(x);
}
test();

これは結果0.020000000000000004を印刷しますが、0.02（計算機を使用する場合）印刷する必要があります。私が理解している限り、これは浮動小数点乗算精度のエラーによるものです。

そのような場合に私が正しい結果を得るように誰かが良い解決策を持っています0.02か？などの関数があることはわかっていますがtoFixed、丸めが別の可能性になることもありますが、丸めたり丸めたりせずに実際に整数を印刷したいです。誰かが素敵でエレガントな解決策を持っているかどうか知りたいだけです。

もちろん、それ以外の場合は、10桁程度に丸めます。

浮動小数点ガイド：

この問題を回避するにはどうすればよいですか？

それは、どのような計算を行っているかによって異なります。

• 結果を正確に合計する必要がある場合、特にお金を扱う場合は、特別な10進データ型を使用してください。
• これらの余分な小数点以下の桁をすべて表示したくない場合は、結果を表示するときに、結果を固定小数点以下の桁数に丸めるだけです。
• 利用可能な10進数のデータ型がない場合、代わりに整数を使用することもできます。たとえば、お金の計算はすべてセントで行います。しかし、これはより多くの作業であり、いくつかの欠点があります。

最初の点は、特定の正確な10進数の動作が本当に必要な場合にのみ適用されることに注意してください。ほとんどの人はそれを必要とせず、1/3で発生した場合に同じエラーで点滅することさえないことに気付かずに、プログラムが1/10のような数値で正しく機能しないことに単にイライラします。

最初の点が本当に当てはまる場合は、BigDecimal for JavaScriptを使用してください。これはエレガントではありませんが、不完全な回避策を提供するのではなく、実際に問題を解決します。

私はPedro Ladariaのソリューションが好きで、似たようなものを使用しています。

function strip(number) {
    return (parseFloat(number).toPrecision(12));
}

Pedrosソリューションとは異なり、これは0.999を切り上げます...繰り返し、最下位桁のプラス/マイナス1まで正確です。

注：32ビットまたは64ビットの浮動小数点数を処理する場合、最良の結果を得るにはtoPrecision（7）およびtoPrecision（15）を使用する必要があります。理由については、この質問を参照してください。

数学的に傾いている場合：http : //docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html

推奨されるアプローチは、補正係数を使用することです（整数間で計算が行われるように、適切な10の累乗を掛けます）。たとえば、の場合0.1 * 0.2、補正係数は10であり、計算を実行しています。

> var x = 0.1
> var y = 0.2
> var cf = 10
> x * y
0.020000000000000004
> (x * cf) * (y * cf) / (cf * cf)
0.02

（非常に迅速な）ソリューションは次のようになります。

var _cf = (function() {
  function _shift(x) {
    var parts = x.toString().split('.');
    return (parts.length < 2) ? 1 : Math.pow(10, parts[1].length);
  }
  return function() { 
    return Array.prototype.reduce.call(arguments, function (prev, next) { return prev === undefined || next === undefined ? undefined : Math.max(prev, _shift (next)); }, -Infinity);
  };
})();

Math.a = function () {
  var f = _cf.apply(null, arguments); if(f === undefined) return undefined;
  function cb(x, y, i, o) { return x + f * y; }
  return Array.prototype.reduce.call(arguments, cb, 0) / f;
};

Math.s = function (l,r) { var f = _cf(l,r); return (l * f - r * f) / f; };

Math.m = function () {
  var f = _cf.apply(null, arguments);
  function cb(x, y, i, o) { return (x*f) * (y*f) / (f * f); }
  return Array.prototype.reduce.call(arguments, cb, 1);
};

Math.d = function (l,r) { var f = _cf(l,r); return (l * f) / (r * f); };

この場合：

> Math.m(0.1, 0.2)
0.02

SinfulJSのようなテスト済みライブラリを使用することをお勧めします

乗算のみを実行していますか？もしそうなら、あなたはあなたの利点に小数算術についてのきちんとした秘密を使うことができます。それですNumberOfDecimals(X) + NumberOfDecimals(Y) = ExpectedNumberOfDecimals。つまり、0.123 * 0.12小数点以下0.1233桁と小数点以下0.122 桁なので、小数点以下5桁になることがわかっている場合です。したがって、JavaScriptによって、0.014760000002精度を失うことを恐れずに小数点以下5桁まで安全に丸めることができるような数値が得られた場合。

sprintfJavaScriptの実装を探しているので、（バイナリ形式で保存されているため）小さなエラーのある浮動小数点数を期待どおりの形式で書き出すことができます。

javascript-sprintfを試してください。次のように呼び出します。

var yourString = sprintf("%.2f", yourNumber);

小数点以下2桁の浮動小数点数として数値を出力します。

浮動小数点を特定の精度に丸めるためだけにファイルを追加しない場合は、表示目的でNumber.toFixed（）を使用することも できます。

BigNumber.jsが私のニーズを満たしていることがわかりました。

任意精度の10進数および非10進数の算術演算用のJavaScriptライブラリ。

良いドキュメントがありますあり、著者はフィードバックに非常に注意深く対応しています。

同じ作者が他に2つの類似したライブラリを持っています：

Big.js

任意精度の小数演算用の小さくて高速なJavaScriptライブラリ。bignumber.jsの妹。

およびDecimal.js

JavaScriptの任意精度のDecimalタイプ。

BigNumberを使用したコードは次のとおりです。

$(function(){

  
  var product = BigNumber(.1).times(.2);  
  $('#product').text(product);

  var sum = BigNumber(.1).plus(.2);  
  $('#sum').text(sum);


});

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>

<!-- 1.4.1 is not the current version, but works for this example. -->
<script src="http://cdn.bootcss.com/bignumber.js/1.4.1/bignumber.min.js"></script>

.1 &times; .2 = <span id="product"></span><br>
.1 &plus; .2 = <span id="sum"></span><br>

var times = function (a, b) {
    return Math.round((a * b) * 100)/100;
};

---または---

var fpFix = function (n) {
    return Math.round(n * 100)/100;
};

fpFix(0.1*0.2); // -> 0.02

---また---

var fpArithmetic = function (op, x, y) {
    var n = {
            '*': x * y,
            '-': x - y,
            '+': x + y,
            '/': x / y
        }[op];        

    return Math.round(n * 100)/100;
};

---のように---

fpArithmetic('*', 0.1, 0.2);
// 0.02

fpArithmetic('+', 0.1, 0.2);
// 0.3

fpArithmetic('-', 0.1, 0.2);
// -0.1

fpArithmetic('/', 0.2, 0.1);
// 2

この関数は、2つの浮動小数点数の乗算から必要な精度を決定し、適切な精度で結果を返します。エレガントではありませんが。

function multFloats(a,b){
  var atens = Math.pow(10,String(a).length - String(a).indexOf('.') - 1), 
      btens = Math.pow(10,String(b).length - String(b).indexOf('.') - 1); 
  return (a * atens) * (b * btens) / (atens * btens); 
}

驚いたことに、この関数はまだ投稿されていませんが、他の関数には同様のバリエーションがあります。これは、Math.round（）のMDN Webドキュメントからのものです。簡潔であり、さまざまな精度が可能です。

function precisionRound(number, precision) {
  var factor = Math.pow(10, precision);
  return Math.round(number * factor) / factor;
}

console.log（precisionRound（1234.5678、1））; //予想される出力：1234.6

console.log（precisionRound（1234.5678、-1））; //予想される出力：1230

var inp = document.querySelectorAll('input');
var btn = document.querySelector('button');

btn.onclick = function(){
  inp[2].value = precisionRound( parseFloat(inp[0].value) * parseFloat(inp[1].value) , 5 );
};

//MDN function
function precisionRound(number, precision) {
  var factor = Math.pow(10, precision);
  return Math.round(number * factor) / factor;
}

button{
display: block;
}

<input type='text' value='0.1'>
<input type='text' value='0.2'>
<button>Get Product</button>
<input type='text'>

更新：Aug / 20/2019このエラーに気づきました。Math.round（）の浮動小数点精度エラーが原因だと思います。

precisionRound(1.005, 2) // produces 1, incorrect, should be 1.01

これらの条件は正しく機能します。

precisionRound(0.005, 2) // produces 0.01
precisionRound(1.0005, 3) // produces 1.001
precisionRound(1234.5, 0) // produces 1235
precisionRound(1234.5, -1) // produces 1230

修正：

function precisionRoundMod(number, precision) {
  var factor = Math.pow(10, precision);
  var n = precision < 0 ? number : 0.01 / factor + number;
  return Math.round( n * factor) / factor;
}

これは、小数を丸めるときに右側に数字を追加するだけです。MDNはMath.roundページを更新したので、誰かがより良い解決策を提供できるかもしれません。

あなたは本当にあなたが実際に欲しい10進数をいくつ決めるかを決めなければなりません-ケーキを持ってそれを食べることもできません:-)

数値エラーは、それ以降の操作ごとに蓄積され、それを早期に切り落とさなければ、それは大きくなるだけです。きれいに見える結果を示す数値ライブラリは、すべてのステップで最後の2桁を単純に切り捨てます。数値コプロセッサにも、同じ理由で「通常」と「完全」の長さがあります。Cuf-offは、プロセッサにとっては安価ですが、スクリプト（pov（...）の乗算と除算および使用）では非常に高価です。良い数学ライブラリは、カットオフを行うためにfloor（x、n）を提供します。

したがって、少なくとも、pov（10、n）を使用してグローバルvar / constantを作成する必要があります。つまり、必要な精度を決定したことになります。

Math.floor(x*PREC_LIM)/PREC_LIM  // floor - you are cutting off, not rounding

結果を表示するだけで、if-sを実行していないと仮定して、計算を続け、最後に切り捨てることもできます。それができる場合は、.toFixed（...）の方が効率的です。

if-s / comparisonsを実行していて、切り捨てたくない場合は、通常はepsと呼ばれる小さな定数も必要です。これは、予想される最大エラーよりも小数点第1位高い値です。カットオフが最後の2つの小数点であるとすると、epsは最後から3番目に1（最下位3番目）であり、それを使用して結果が期待されるepsの範囲内にあるかどうかを比較できます（0.02 -eps <0.1 * 0.2 <0.02 + eps）。

あなたは使用することができますparseFloat()し、toFixed()あなたが小さな操作のために、この問題のバイパスにしたい場合：

a = 0.1;
b = 0.2;

a + b = 0.30000000000000004;

c = parseFloat((a+b).toFixed(2));

c = 0.3;

a = 0.3;
b = 0.2;

a - b = 0.09999999999999998;

c = parseFloat((a-b).toFixed(2));

c = 0.1;

phpjs.orgのround（）関数はうまく動作します：http ://phpjs.org/functions/round

num = .01 + .06;  // yields 0.0699999999999
rnum = round(num,12); // yields 0.07

0.6 * 3それは素晴らしいです！））私にとってこれはうまくいきます：

function dec( num )
{
    var p = 100;
    return Math.round( num * p ) / p;
}

非常に非常にシンプル））

一般的な用途では、この動作は許容できる可能性が高いことに注意してください。
これらの浮動小数点値を比較して適切なアクションを決定すると、問題が発生します。
ES6の出現によりNumber.EPSILON、許容可能なエラーマージンを決定するために新しい定数が定義されています。
したがって、このような比較を実行する代わりに

0.1 + 0.2 === 0.3 // which returns false

次のように、カスタム比較関数を定義できます。

function epsEqu(x, y) {
    return Math.abs(x - y) < Number.EPSILON;
}
console.log(epsEqu(0.1+0.2, 0.3)); // true

出典：http : //2ality.com/2015/04/numbers-math-es6.html#numberepsilon

あなたが得た結果は、異なる言語、プロセッサ、オペレーティングシステムでの浮動小数点の実装全体で正確でかなり一貫しています-変化するのは、フロートが実際にdouble（またはそれ以上）であるときの不正確さのレベルです。

2進浮動小数点の0.1は10進の1/3（つまり、0.3333333333333 ...永遠に）のようなものであり、正確に処理する方法はありません。

フロートを処理している場合は、常に小さな丸め誤差が予想されるため、表示された結果を常に適切な丸めにする必要があります。代わりに、すべての計算がプロセッサのネイティブバイナリで行われるため、非常に高速で強力な演算が得られます。

ほとんどの場合、解決策は固定小数点演算に切り替えることではありません。これは主に、速度が非常に遅く、99％の時間で精度が必要ないためです。そのレベルの精度が必要なもの（金融取引など）を扱っている場合は、JavaScriptはおそらく使用するのに最適なツールではありません（固定小数点型を強制したいので、静的言語の方が良いでしょう） ）。

あなたはエレガントな解決策を探しています、それは恐らくこれです：フロートは高速ですが小さな丸め誤差があります-結果を表示するときは常に賢明なものに丸めます。

これを回避するには、浮動小数点ではなく整数値を使用する必要があります。したがって、2つの位置の精度が必要な場合は、値* 100を使用します。3つの位置の場合は1000を使用します。表示するときは、フォーマッタを使用して区切り記号を挿入します。

多くのシステムは、このように小数での作業を省略します。これが、多くのシステムがドル/ユーロ（浮動小数点）ではなくセント（整数）で機能する理由です。

問題

浮動小数点は、すべての小数値を正確に格納することはできません。したがって、浮動小数点形式を使用する場合、入力値には常に丸め誤差があります。もちろん、入力のエラーは出力のエラーになります。離散関数または演算子の場合、関数または演算子が離散しているポイントの周りの出力に大きな違いが生じる可能性があります。

浮動小数点値の入力と出力

したがって、浮動小数点変数を使用する場合は、常にこれに注意する必要があります。また、浮動小数点を使用した計算で必要な出力は、これを念頭に置いて表示する前に、常にフォーマット/条件付けする必要があります。
連続関数と演算子のみを使用する場合は、必要な精度に丸めることがよくあります（切り捨てないでください）。浮動小数点数を文字列に変換するために使用される標準のフォーマット機能は通常これを行います。
丸めによりエラーが追加され、合計エラーが目的の精度の半分を超える可能性があるため、出力は、入力の期待される精度と出力の目的の精度に基づいて修正する必要があります。あなたがすべき

• 入力を予想される精度に丸めるか、より高い精度で値を入力できないようにします。
• 丸め/フォーマットする前に、出力に小さな値を追加します。これは、必要な精度の1/4以下で、入力時および計算時の丸め誤差によって引き起こされる最大予想誤差よりも大きくなります。それが不可能な場合は、使用するデータ型の精度の組み合わせでは、計算に必要な出力精度を実現するには不十分です。

これら2つのことは通常行われず、ほとんどの場合、それらを行わないことによる差異はほとんどのユーザーにとって重要であるには小さすぎますが、これらの修正なしにユーザーが出力を受け入れないプロジェクトがすでにありました。

離散関数または演算子（モジュラなど）

個別の演算子または関数が含まれる場合、出力が期待どおりであることを確認するには、追加の修正が必要になる場合があります。丸め、丸める前に小さな修正を追加しても問題は解決しません。
離散関数または演算子を適用した直後に、中間計算結果の特別なチェック/修正が必要になる場合があります。特定のケース（モジュラ演算子）については、質問の私の回答を参照してください。なぜモジュラス演算子はJavaScriptで小数を返すのですか？

問題を回避する方が良い

多くの場合、このような計算にデータ型（整数または固定小数点形式）を使用することにより、これらの問題を回避した方が効率的です。その一例は、財務計算に浮動小数点値を使用してはならないことです。

見てい固定小数点演算を。操作したい数値の範囲が狭い場合（通貨など）、問題はおそらく解決します。私はそれをいくつかの10進数の値に四捨五入します。これが最も簡単な解決策です。

ここにある私のキリアス算術ライブラリを試してみてください。より新しいバージョンが必要な場合は、入手できます。

ほとんどの小数は、2進浮動小数点型（ECMAScriptが浮動小数点値を表すために使用する型）では正確に表すことができません。したがって、任意の精度の算術型または10進数ベースの浮動小数点型を使用しない限り、洗練されたソリューションはありません。たとえば、Windowsに同梱されている電卓アプリでは、この問題を解決するために任意精度演算が使用されるようになりました。

    You can use library https://github.com/MikeMcl/decimal.js/. 
    it will   help  lot to give proper solution. 
    javascript console output 95 *722228.630 /100 = 686117.1984999999
    decimal library implementation 
    var firstNumber = new Decimal(95);
    var secondNumber = new Decimal(722228.630);
    var thirdNumber = new Decimal(100);
    var partialOutput = firstNumber.times(secondNumber);
    console.log(partialOutput);
    var output = new Decimal(partialOutput).div(thirdNumber);
    alert(output.valueOf());
    console.log(output.valueOf())== 686117.1985

そうです、その理由は浮動小数点数の精度が限られているためです。有理数を2つの整数の除算として格納します。ほとんどの場合、精度を失うことなく数値を格納できます。印刷に関しては、結果を分数として表示することができます。私が提案した表現では、それは簡単になります。

もちろん、それは無理な数ではあまり役に立ちません。しかし、あなたは、彼らが最も問題が（例えばような状況を検出する原因になりますように、あなたの計算を最適化することもできますsqrt(3)^2)。

mod 3で厄介な丸めエラーの問題が発生しました。0を取得する必要がある場合、.000 ... 01が返されることがあります。これは簡単に処理でき、<= .01をテストするだけです。しかし、時々2.99999999999998を取得します。痛い！

BigNumbersは問題を解決しましたが、別のやや皮肉な問題を引き起こしました。BigNumbersに8.5を読み込もうとすると、実際には8.4999であり、有効桁数が15桁以上であることが通知されました。これは、BigNumbersがそれを受け入れることができなかったことを意味しました（この問題は多少皮肉なことだと私は言ったと思います）

皮肉な問題の簡単な解決策：

x = Math.round(x*100);
// I only need 2 decimal places, if i needed 3 I would use 1,000, etc.
x = x / 100;
xB = new BigNumber(x);

Number（1.234443）.toFixed（2）;を使用します。それは1.23を印刷します

function test(){
    var x = 0.1 * 0.2;
    document.write(Number(x).toFixed(2));
}
test();

decimal.js、big.jsまたはbignumber.jsは、 JavaScriptでの浮動小数点操作の問題を回避するために使用することができます。

0.1 * 0.2                                // 0.020000000000000004
x = new Decimal(0.1)
y = x.times(0.2)                          // '0.2'
x.times(0.2).equals(0.2)                  // true

big.js：ミニマリスト。使いやすい; 小数点以下の桁数で指定された精度。精度は除算にのみ適用されます。

bignumber.js：2から64のベース。構成オプション; NaN; 無限大; 小数点以下の桁数で指定された精度。除算にのみ適用される精度。ベースプレフィックス。

decimal.js：2から64を基数にします。構成オプション; NaN; 無限大; 非整数の累乗、exp、ln、log; 有効桁数で指定された精度。常に適用される精度。乱数。

詳細な比較へのリンク

エレガント、予測可能、再利用可能

エレガントで再利用可能な方法で問題に対処しましょう。次の7行では.decimal、数値、数式、または組み込みMath関数の末尾に追加するだけで、任意の数値に必要な浮動小数点の精度にアクセスできます。

// First extend the native Number object to handle precision. This populates
// the functionality to all math operations.

Object.defineProperty(Number.prototype, "decimal", {
  get: function decimal() {
    Number.precision = "precision" in Number ? Number.precision : 3;
    var f = Math.pow(10, Number.precision);
    return Math.round( this * f ) / f;
  }
});


// Now lets see how it works by adjusting our global precision level and 
// checking our results.

console.log("'1/3 + 1/3 + 1/3 = 1' Right?");
console.log((0.3333 + 0.3333 + 0.3333).decimal == 1); // true

console.log(0.3333.decimal); // 0.333 - A raw 4 digit decimal, trimmed to 3...

Number.precision = 3;
console.log("Precision: 3");
console.log((0.8 + 0.2).decimal); // 1
console.log((0.08 + 0.02).decimal); // 0.1
console.log((0.008 + 0.002).decimal); // 0.01
console.log((0.0008 + 0.0002).decimal); // 0.001

Number.precision = 2;
console.log("Precision: 2");
console.log((0.8 + 0.2).decimal); // 1
console.log((0.08 + 0.02).decimal); // 0.1
console.log((0.008 + 0.002).decimal); // 0.01
console.log((0.0008 + 0.0002).decimal); // 0

Number.precision = 1;
console.log("Precision: 1");
console.log((0.8 + 0.2).decimal); // 1
console.log((0.08 + 0.02).decimal); // 0.1
console.log((0.008 + 0.002).decimal); // 0
console.log((0.0008 + 0.0002).decimal); // 0

Number.precision = 0;
console.log("Precision: 0");
console.log((0.8 + 0.2).decimal); // 1
console.log((0.08 + 0.02).decimal); // 0
console.log((0.008 + 0.002).decimal); // 0
console.log((0.0008 + 0.0002).decimal); // 0

乾杯！

使用する

var x = 0.1*0.2;
 x =Math.round(x*Math.pow(10,2))/Math.pow(10,2);

エレガントではありませんが、仕事をします（末尾のゼロを削除します）

var num = 0.1*0.2;
alert(parseFloat(num.toFixed(10))); // shows 0.02

これは私にとってはうまくいきます：

function round_up( value, precision ) { 
    var pow = Math.pow ( 10, precision ); 
    return ( Math.ceil ( pow * value ) + Math.ceil ( pow * value - Math.ceil ( pow * value ) ) ) / pow; 
}

round_up(341.536, 2); // 341.54

次の関数を使用して出力します。

var toFixedCurrency = function(num){
    var num = (num).toString();
    var one = new RegExp(/\.\d{1}$/).test(num);
    var two = new RegExp(/\.\d{2,}/).test(num);
    var result = null;

    if(one){ result = num.replace(/\.(\d{1})$/, '.$10');
    } else if(two){ result = num.replace(/\.(\d{2})\d*/, '.$1');
    } else { result = num*100; }

    return result;
}

function test(){
    var x = 0.1 * 0.2;
    document.write(toFixedCurrency(x));
}

test();

出力に注意してくださいtoFixedCurrency(x)。