Heim  >  Artikel  >  Web-Frontend  >  Lassen Sie uns über die Rechengenauigkeit von js sprechen

Lassen Sie uns über die Rechengenauigkeit von js sprechen

angryTom
angryTomnach vorne
2019-11-25 17:27:552240Durchsuche

Lassen Sie uns über die Rechengenauigkeit von js sprechen

Wir alle wissen, dass die Verwendung von js zum Durchführen von Berechnungen definitiv auf Probleme mit der Berechnungsgenauigkeit (oder Rundungsfehler) stoßen wird, aber wie man diese Fallstricke vermeidet, hier ist der Plan, den ich aus dem Internet zusammengestellt habe. Gerne zur Diskussion.

Lassen Sie uns über die Rechengenauigkeit von js sprechen

Gründe für Präzisionsverlust

Die binäre Implementierung von Computern und die Anzahl der Bits sind begrenzt, einige Zahlen können nicht endlich dargestellt werden. Genauso wie einige irrationale Zahlen nicht endlich dargestellt werden können, wie zum Beispiel pi 3,1415926…, 1,3333… usw. JavaScript verwendet 64 Bit zum Speichern numerischer Typen, sodass überschüssige Daten verworfen werden. Der ausgelassene Teil ist der Teil, bei dem die Genauigkeit verloren geht.

Das Folgende ist die binäre Darstellung von Dezimalzahlen

0.1 >> 0.0001 1001 1001 1001…(1001无限循环)
0.2 >> 0.0011 0011 0011 0011…(0011无限循环)

Lösung

Wenn Sie eine komplexere Berechnungsbibliothek benötigen, können Sie math.js in Betracht ziehen usw. Bekannte Klassenbibliotheken

Gleitkommazahlen (Dezimalzahlen)

Bei Dezimalzahlen besteht immer noch eine große Wahrscheinlichkeit von Problemen im Frontend, insbesondere bei einigen E-Commerce-Websites, die beteiligt sind Beträge und andere Daten. Lösung: Setzen Sie die Dezimalzahl in eine Ganzzahl um (multiplizieren Sie das Vielfache) und reduzieren Sie sie dann wieder auf das ursprüngliche Vielfache (dividieren Sie das Vielfache). Das Operationsergebnis nach der Konvertierung in eine Ganzzahl darf Math.pow(2,53)

nicht überschreiten
// 0.1 + 0.2
(0.1*10 + 0.2*10) / 10 == 0.3 // true

Gleitkomma-Präzisionsoperation

/**
 * floatObj 包含加减乘除四个方法,能确保浮点数运算不丢失精度
 *
 * ** method **
 *  add / subtract / multiply /divide
 *
 * ** explame **
 *  0.1 + 0.2 == 0.30000000000000004 (多了 0.00000000000004)
 *  0.2 + 0.4 == 0.6000000000000001  (多了 0.0000000000001)
 *  19.9 * 100 == 1989.9999999999998 (少了 0.0000000000002)
 *
 * floatObj.add(0.1, 0.2) >> 0.3
 * floatObj.multiply(19.9, 100) >> 1990
 *
 */
var floatObj = function() {
    /*
     * 判断obj是否为一个整数
     */
    function isInteger(obj) {
        return Math.floor(obj) === obj
    }
    /*
     * 将一个浮点数转成整数,返回整数和倍数。如 3.14 >> 314,倍数是 100
     * @param floatNum {number} 小数
     * @return {object}
     *   {times:100, num: 314}
     */
    function toInteger(floatNum) {
        var ret = {times: 1, num: 0}
        if (isInteger(floatNum)) {
            ret.num = floatNum
            return ret
        }
        var strfi  = floatNum + ''
        var dotPos = strfi.indexOf('.')
        var len    = strfi.substr(dotPos+1).length
        var times  = Math.pow(10, len)
        var intNum = parseInt(floatNum * times + 0.5, 10)
        ret.times  = times
        ret.num    = intNum
        return ret
    }
    /*
     * 核心方法,实现加减乘除运算,确保不丢失精度
     * 思路:把小数放大为整数(乘),进行算术运算,再缩小为小数(除)
     *
     * @param a {number} 运算数1
     * @param b {number} 运算数2
     * @param digits {number} 精度,保留的小数点数,比如 2, 即保留为两位小数
     * @param op {string} 运算类型,有加减乘除(add/subtract/multiply/divide)
     *
     */
    function operation(a, b, digits, op) {
        var o1 = toInteger(a)
        var o2 = toInteger(b)
        var n1 = o1.num
        var n2 = o2.num
        var t1 = o1.times
        var t2 = o2.times
        var max = t1 > t2 ? t1 : t2
        var result = null
        switch (op) {
            case 'add':
                if (t1 === t2) { // 两个小数位数相同
                    result = n1 + n2
                } else if (t1 > t2) { // o1 小数位 大于 o2
                    result = n1 + n2 * (t1 / t2)
                } else { // o1 小数位 小于 o2
                    result = n1 * (t2 / t1) + n2
                }
                return result / max
            case 'subtract':
                if (t1 === t2) {
                    result = n1 - n2
                } else if (t1 > t2) {
                    result = n1 - n2 * (t1 / t2)
                } else {
                    result = n1 * (t2 / t1) - n2
                }
                return result / max
            case 'multiply':
                result = (n1 * n2) / (t1 * t2)
                return result
            case 'divide':
                result = (n1 / n2) * (t2 / t1)
                return result
        }
    }
    // 加减乘除的四个接口
    function add(a, b, digits) {
        return operation(a, b, digits, 'add')
    }
    function subtract(a, b, digits) {
        return operation(a, b, digits, 'subtract')
    }
    function multiply(a, b, digits) {
        return operation(a, b, digits, 'multiply')
    }
    function divide(a, b, digits) {
        return operation(a, b, digits, 'divide')
    }
    // exports
    return {
        add: add,
        subtract: subtract,
        multiply: multiply,
        divide: divide
    }
}();

Verwendung:

floatTool.add(a,b);//相加
floatTool.subtract(a,b);//相减
floatTool.multiply(a,b);//相乘
floatTool.divide(a,b);//相除

Extra große Ganzzahl

Obwohl das Operationsergebnis dies tut nicht überschreiten Math.pow(2,53) Die obige Methode kann auch für Ganzzahlen (9007199254740992) verwendet werden, aber wenn es mehr als eine gibt, kann es im tatsächlichen Szenario einige Chargennummern, Zahlensegmente und andere Anforderungen geben Ich habe auch eine Lösung gefunden. Geben Sie den Code direkt ein.

Online-Berechnung: https://www.shen.ee/math.html

function compare(p, q) {
  while (p[0] === '0') {
    p = p.substr(1);
  }
  while (q[0] === '0') {
    q = q.substr(1);
  }
  if (p.length > q.length) {
    return 1;
  } else if (p.length < q.length) {
    return -1;
  } else {
    let i = 0;
    let a, b;
    while (1) {
      a = parseInt(p.charAt(i));
      b = parseInt(q.charAt(i));
      if (a > b) {
        return 1;
      } else if (a < b) {
        return -1;
      } else if (i === p.length - 1) {
        return 0;
      }
      i++;
    }
  }
}
function divide(A, B) {
  let result = [];
  let max = 9;
  let point = 5;
  let fill = 0;
  if (B.length - A.length > 0) {
    point += fill = B.length - A.length;
  }
  for (let i = 0; i < point; i++) {
    A += &#39;0&#39;;
  }
  let la = A.length;
  let lb = B.length;
  let b0 = parseInt(B.charAt(0));
  let Adb = A.substr(0, lb);
  A = A.substr(lb);
  let temp, r;
  for (let j = 0; j < la - lb + 1; j++) {
    while (Adb[0] === &#39;0&#39;) {
      Adb = Adb.substr(1);
    }
    if (Adb.length === lb) {
      max = Math.ceil((parseInt(Adb.charAt(0)) + 1) / b0); // 不可能取到这个最大值,1<= max <= 10
    } else if (Adb.length > lb) {
      max = Math.ceil((parseInt(Adb.substr(0, 2)) + 1) / b0);
    } else {
      result.push(0);
      Adb += A[0];
      A = A.substr(1);
      continue;
    }
    for (let i = max - 1; i >= 0; i--) {
      if (i === 0) {
        result.push(0);
        Adb += A[0];
        A = A.substr(1);
        break;
      } else {
        temp = temp || multiply(B, i + &#39;&#39;);
        r = compare(temp, Adb);
        if (r === 0 || r === -1) {
          result.push(i);
          if (r) {
            Adb = reduce(Adb, temp);
            Adb += A[0];
          } else {
            Adb = A[0];
          }
          A = A.substr(1);
          break;
        } else {
          temp = reduce(temp, B);
        }
      }
    }
    temp = 0;
  }
  for (let i = 0; i < fill; i++) {
    result.unshift(&#39;0&#39;);
  }
  result.splice(result.length - point, 0, &#39;.&#39;);
  if (!result[0] && result[1] !== &#39;.&#39;) {
    result.shift();
  }
  point = false;
  let position = result.indexOf(&#39;.&#39;);
  for (let i = position + 1; i < result.length; i++) {
    if (result[i]) {
      point = true;
      break;
    }
  }
  if (!point) {
    result.splice(position);
  }
  result = result.join(&#39;&#39;);
  return result;
}
function multiply(A, B) {
  let result = [];
  (A += &#39;&#39;), (B += &#39;&#39;);
  const l = -4; // 以支持百万位精确运算,但速度减半
  let r1 = [],
    r2 = [];
  while (A !== &#39;&#39;) {
    r1.unshift(parseInt(A.substr(l)));
    A = A.slice(0, l);
  }
  while (B !== &#39;&#39;) {
    r2.unshift(parseInt(B.substr(l)));
    B = B.slice(0, l);
  }
  let index, value;
  for (let i = 0; i < r1.length; i++) {
    for (let j = 0; j < r2.length; j++) {
      value = 0;
      if (r1[i] && r2[j]) {
        value = r1[i] * r2[j];
      }
      index = i + j;
      if (result[index]) {
        result[index] += value;
      } else {
        result[index] = value;
      }
    }
  }
  for (let i = result.length - 1; i > 0; i--) {
    result[i] += &#39;&#39;;
    if (result[i].length > -l) {
      result[i - 1] += parseInt(result[i].slice(0, l));
      result[i] = result[i].substr(l);
    }
    while (result[i].length < -l) {
      result[i] = &#39;0&#39; + result[i];
    }
  }
  if (result[0]) {
    result = result.join(&#39;&#39;);
  } else {
    result = &#39;0&#39;;
  }
  return result;
}
function add(A, B) {
  let result = [];
  (A += &#39;&#39;), (B += &#39;&#39;);
  const l = -15;
  while (A !== &#39;&#39; && B !== &#39;&#39;) {
    result.unshift(parseInt(A.substr(l)) + parseInt(B.substr(l)));
    A = A.slice(0, l);
    B = B.slice(0, l);
  }
  A += B;
  for (let i = result.length - 1; i > 0; i--) {
    result[i] += &#39;&#39;;
    if (result[i].length > -l) {
      result[i - 1] += 1;
      result[i] = result[i].substr(1);
    } else {
      while (result[i].length < -l) {
        result[i] = &#39;0&#39; + result[i];
      }
    }
  }
  while (A && (result[0] + &#39;&#39;).length > -l) {
    result[0] = (result[0] + &#39;&#39;).substr(1);
    result.unshift(parseInt(A.substr(l)) + 1);
    A = A.slice(0, l);
  }
  if (A) {
    while ((result[0] + &#39;&#39;).length < -l) {
      result[0] = &#39;0&#39; + result[0];
    }
    result.unshift(A);
  }
  if (result[0]) {
    result = result.join(&#39;&#39;);
  } else {
    result = &#39;0&#39;;
  }
  return result;
}
function reduce(A, B) {
  let result = [];
  (A += &#39;&#39;), (B += &#39;&#39;);
  while (A[0] === &#39;0&#39;) {
    A = A.substr(1);
  }
  while (B[0] === &#39;0&#39;) {
    B = B.substr(1);
  }
  const l = -15;
  let N = &#39;1&#39;;
  for (let i = 0; i < -l; i++) {
    N += &#39;0&#39;;
  }
  N = parseInt(N);
  while (A !== &#39;&#39; && B !== &#39;&#39;) {
    result.unshift(parseInt(A.substr(l)) - parseInt(B.substr(l)));
    A = A.slice(0, l);
    B = B.slice(0, l);
  }
  if (A !== &#39;&#39; || B !== &#39;&#39;) {
    let s = B === &#39;&#39; ? 1 : -1;
    A += B;
    while (A !== &#39;&#39;) {
      result.unshift(s * parseInt(A.substr(l)));
      A = A.slice(0, l);
    }
  }
  while (result.length !== 0 && result[0] === 0) {
    result.shift();
  }
  let s = &#39;&#39;;
  if (result.length === 0) {
    result = 0;
  } else if (result[0] < 0) {
    s = &#39;-&#39;;
    for (let i = result.length - 1; i > 0; i--) {
      if (result[i] > 0) {
        result[i] -= N;
        result[i - 1]++;
      }
      result[i] *= -1;
      result[i] += &#39;&#39;;
      while (result[i].length < -l) {
        result[i] = &#39;0&#39; + result[i];
      }
    }
    result[0] *= -1;
  } else {
    for (let i = result.length - 1; i > 0; i--) {
      if (result[i] < 0) {
        result[i] += N;
        result[i - 1]--;
      }
      result[i] += &#39;&#39;;
      while (result[i].length < -l) {
        result[i] = &#39;0&#39; + result[i];
      }
    }
  }
  if (result) {
    while ((result[0] = parseInt(result[0])) === 0) {
      result.shift();
    }
    result = s + result.join(&#39;&#39;);
  }
  return result;
}

Verwendung: Negative Zahlen sind nicht zulässig, und es ist am besten, Zeichenfolgen für Parameter zu verwenden

divide(A,B)    // 除法
multiply(A,B)    //乘法
add(A,B)    //加法
reduce(A,B)    //减法

Fixed Fixes für toFixed

In Firefox/Chrome rundet toFixed die letzte Ziffer nicht, wenn sie 5 ist.

1.35.toFixed(1) // 1.4 正确
1.335.toFixed(2) // 1.33  错误
1.3335.toFixed(3) // 1.333 错误
1.33335.toFixed(4) // 1.3334 正确
1.333335.toFixed(5)  // 1.33333 错误
1.3333335.toFixed(6) // 1.333333 错误

Es gibt kein Problem mit der Implementierung von Firefox und Chrome. Die Hauptursache ist der Verlust der Genauigkeit von Gleitkommazahlen im Computer.

Reparaturmethode:

function toFixed(num, s) {
    var times = Math.pow(10, s)
    var des = num * times + 0.5
    des = parseInt(des, 10) / times
    return des + &#39;&#39;
}

Dieser Artikel ist hier zu Ende. Weitere spannende Inhalte finden Sie im JavaScript-Video-Tutorial auf der chinesischen PHP-Website Spalte!

Das obige ist der detaillierte Inhalt vonLassen Sie uns über die Rechengenauigkeit von js sprechen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Stellungnahme:
Dieser Artikel ist reproduziert unter:www.iyouhun.com. Bei Verstößen wenden Sie sich bitte an admin@php.cn löschen