提取 Javascript 数字的指数和尾数

Question

有没有一种相当快速的方法可以从 JavaScript 中的数字中提取指数和尾数？

AFAIK 没有办法获取 Javascript 中数字后面的位，这让我觉得我正在研究因式分解问题：找到 m 和 n 这样对于给定的k，2^n * m = k。由于整数分解属于 NP 范畴，我只能假设这将是一个相当困难的问题。

我正在实现一个用于生成 Javascript 的 GHC 插件，并且需要实现 decodeFloat_Int# 和 decodeDouble_2Int# 原始操作；我想我可以重写基础库的部分，这些部分使用该操作以其他方式执行任何操作（这应该不会太难，因为所有数字类型都以 Number 作为其表示形式，）但是它'如果我不需要的话就好了。

有没有办法以一种甚至远程性能的方式做到这一点，通过一些黑暗的Javascript巫毒，聪明的数学或其他一些手段，或者我应该埋头苦干并在基础库中使用？

编辑 根据 ruakh 和 Louis Wasserman 的出色回答，我提出了以下实现，它似乎运行得很好：

function getNumberParts(x) {
    if(isNaN(x)) {
        return {mantissa: -6755399441055744, exponent: 972};
    }
    var sig = x > 0 ? 1 : -1;
    if(!isFinite(x)) {
        return {mantissa: sig * 4503599627370496, exponent: 972};
    }
    x = Math.abs(x);
    var exp = Math.floor(Math.log(x)*Math.LOG2E)-52;
    var man = x/Math.pow(2, exp);
    return {mantissa: sig*man, exponent: exp};
}

Answer 1

使用新的 ArrayBuffer 访问数组，实际上可以通过从 Uint8Array。如果您需要更快的速度，请考虑重用 Float64Array。

function getNumberParts(x)
{
    var float = new Float64Array(1),
        bytes = new Uint8Array(float.buffer);

    float[0] = x;

    var sign = bytes[7] >> 7,
        exponent = ((bytes[7] & 0x7f) << 4 | bytes[6] >> 4) - 0x3ff;

    bytes[7] = 0x3f;
    bytes[6] |= 0xf0;

    return {
        sign: sign,
        exponent: exponent,
        mantissa: float[0],
    }
}

我还创建了一些测试用例。 0 失败，因为 2^-1023 有另一种表示形式。

var tests = [1, -1, .123, -.123, 1.5, -1.5, 1e100, -1e100, 
                    1e-100, -1e-100, Infinity, -Infinity];

tests.forEach(function(x)
{
    var parts = getNumberParts(x),
        value = Math.pow(-1, parts.sign) *
                    Math.pow(2, parts.exponent) *
                    parts.mantissa;

    console.log("Testing: " + x + " " + value);
    console.assert(x === value);
});

console.log("Tests passed");

Answer 2

ECMAScript 没有定义任何直接的方法来做到这一点；但就其价值而言，这并不是与质因数分解相同意义上的“因式分解问题”。

理论上，您可以通过首先处理符号，然后使用二叉树方法（或对数）来查找指数，最后除以 2 的相关幂以获得尾数来快速完成您想要的操作；但不幸的是，在实践中实现这一点可能有点棘手（对于特殊情况，例如非规范化数字）。我建议您通读 ECMAScript 规范的第 6.1.6.1 节：数字类型，以了解您必须处理的情况。

Answer 3

为此，整数分解几乎没有必要。

指数基本上就是以 2 为底的对数的底数，这并不难计算。

以下代码通过了 QuickCheck 测试，以及对无穷大和负无穷大的测试：

minNormalizedDouble :: Double
minNormalizedDouble = 2 ^^ (-1022)

powers :: [(Int, Double)]
powers = [(b, 2.0 ^^ fromIntegral b) | i <- [9, 8..0], let b = bit i]

exponentOf :: Double -> Int
exponentOf d
  | d < 0   = exponentOf (-d)
  | d < minNormalizedDouble = -1024
  | d < 1   = 
      let go (dd, accum) (p, twoP)
            | dd * twoP < 1 = (dd * twoP, accum - p)
            | otherwise = (dd, accum)
      in snd $ foldl' go (d, 0) powers
  | otherwise   =
      let go (x, accum) (p, twoP)
            | x * twoP <= d = (x * twoP, accum + p)
            | otherwise = (x, accum)
    in 1 + (snd $ foldl' go (1.0, 0) powers)


decode :: Double -> (Integer, Int)
decode 0.0 = (0, 0)
decode d
  | isInfinite d, d > 0 = (4503599627370496, 972)
  | isInfinite d, d < 0 = (-4503599627370496, 972)
  | isNaN d             = (-6755399441055744, 972)
  | otherwise       =
      let
        e = exponentOf d - 53
        twoE = 2.0 ^^ e
         in (round (d / twoE), e)

我使用 quickCheck (\ d ->decodeFloat d ==decode d) 对其进行了测试，并在正无穷大上单独对其进行了显式测试和负无穷大。

这里使用的唯一原始操作是左移、双乘、双除以及无穷大和 NaN 测试，据我所知，Javascript 支持这些操作。

Answer 4

对于以 10 为基数的情况，您可以使用以下方法在数组中获取尾数和指数：

   var myarray = (number.toExponential() + '').split("e");
   // then ...
   var mantissa = parseFloat(myarray[0]);
   var exponent = parseInt(myarray[1]);

如果您不关心结果部分是否是文本而不是数字，并且如果指数部分前面可能有一个加号，那么您可以跳过 < code>parseFloat 和 parseInt 步骤，直接从数组 [0] 和 [1] 处获取部分。

Answer 5

虽然我喜欢接受的解决方案，但使用它在任意基础上工作会重新引入由 Math.log 和 Math.pow 引起的所有错误。下面是任何基数的一个小实现： x = mantisse * b^exponent

function numberParts(x, b) {
  var exp = 0
  var sgn = 0
  if (x === 0) return { sign: 0, mantissa: 0, exponent: 0 }
  if (x<0) sgn=1, x=-x
  while (x>b) x/=b, exp++
  while (x<1) x*=b, exp--
  return { sign: sgn, mantissa: x, exponent: exp }
}

NaN 和 Infinite 情况可以轻松添加。如果 +0 和 -0 之间的区别很重要：

if (1/x === Infinity) return { sign: 0, mantissa: 0, exponent: 0 }
if (1/x === -Infinity) return { sign: 1, mantissa: 0, exponent: 0 }

Answer 6

下面来获取指数怎么样？：

let exp = String(number.toExponential());
exp = Number(exp.substr(exp.lastIndexOf('e')+1));

1000 将导致 exp = 3

Answer 7

我迟到了十年，但我对文案对此问题的回答并不满意。虽然它非常好，但事实是尾数被 JavaScript 解释为浮点数（准确地说是双精度），其所有数字都在小数部分，这有点违背了获取原始尾数值。我们希望获得原始尾数值，就像它是一个整数一样。

所以，我决定解决这个问题。尾数有 52 位，前面有一个隐含的 1（表示非正规数）。因此，诀窍是将 52 加到指数上，这会将小数部分中的所有尾数位移出，并减去 2⁵² 以消除隐式前导 1。此外，由于我们已经覆盖了在读取尾数之前先计算指数，我们永远不会得到非正规数，所以我们不必为此烦恼。

如下：

function getNumberParts(x) {
    const asDouble = new Float64Array(1);
    const asBytes = new Uint8Array(asDouble.buffer);

    asDouble[0] = x;

    const sign = asBytes[7] >> 7;
    const exponent = ((asBytes[7] & 0x7f) << 4 | asBytes[6] >> 4);

    asBytes[7] = 0x43;
    asBytes[6] &= 0x0f;
    asBytes[6] |= 0x30;

    return {
        sign: sign,
        rawExponent: exponent,
        biasedExponent: exponent - 1023,
        mantissa: Number(BigInt(asDouble[0]) - 2n ** 52n)
    };
}

在 原始副本的答案中，前两个字节被设置为 0x3ff_ 因为这会清除符号位并设置0x3ff 作为指数（_ 是尾数的一部分，无论它是什么，都会被保留）。 0x3ff 是十进制的 1023。添加 52，则得到 0x433_。

由于 double 的未缩放值将是一个 53 位的整数（由于隐式前导 1），因此直接处理会太长 1 位，因此我简单地使用 BigInt 来避免溢出在去掉多余的部分之前。如果由于某种原因您不能或不想使用 BigInt，还有其他方法可以处理它。

此外，虽然有些人可能更喜欢获取原始指数，但其他人可能希望获取带有偏差解释的指数值。为了让双方都满意，我添加了指数的两种解释。

另外，我将变量重命名为 asDouble 和 asBytes 而不是 float 和 bytes 因为我认为这更好地反映了预期的行为。否则，这只是表面上的改变。

由于我们可以通过这种方式分解 double ，因此最好使用相反的操作来组装它。如下：

function constructNumberFromParts(obj) {
    const sign = obj.sign, exponent = obj.rawExponent, mantissa = obj.mantissa;

    const asDouble = new Float64Array(1);
    const asBytes = new Uint8Array(asDouble.buffer);

    asBytes[0] = mantissa & 0xFF;
    asBytes[1] =  Math.floor(mantissa / 2 **  8) & 0xFF;
    asBytes[2] =  Math.floor(mantissa / 2 ** 16) & 0xFF;
    asBytes[3] =  Math.floor(mantissa / 2 ** 24) & 0xFF;
    asBytes[4] =  Math.floor(mantissa / 2 ** 32) & 0xFF;
    asBytes[5] =  Math.floor(mantissa / 2 ** 40) & 0xFF;
    asBytes[6] = (Math.floor(mantissa / 2 ** 48) & 0x0F) | ((exponent & 0x0F) << 4);
    asBytes[7] = (exponent >>> 4) | (sign << 7);
    return asDouble[0];
}

理想情况下，我会在尾数上使用位移位，但由于 JavaScript 在位移之前会减少到 32 位，因此会丢弃 20 位来破坏它。因此，我使用除法和 Math.floor 来模拟位移。

最后，测试所有这些：

(() => {
    function check1(a) {
        const b = getNumberParts(a);
        const c = constructNumberFromParts(b);
        const d = getNumberParts(c);
        const ok = a === a ? a === c : c !== c;
        const whatIs = `${a}, ${c}, ${JSON.stringify(b)}, ${JSON.stringify(d)}`;
        if (!ok) throw new Error(`Fails for ${whatIs}.`);
        console.log(`Pass for ${whatIs}.`);
    }

    function check2(a) {
        const p = {
            sign: a[0],
            rawExponent: a[1] + 1023,
            biasedExponent: a[1],
            mantissa: a[2]
        };
        const b = constructNumberFromParts(p);
        const c = getNumberParts(b);
        const d = c.sign, e = c.rawExponent, f = c.mantissa, g = c.biasedExponent;
        const ok = a[1] === g && e === g + 1023 && (b !== b || (a[0] === d && a[2] === f));
        const whatIs = `${JSON.stringify(a)}, ${JSON.stringify(p)}, ${b}, ${JSON.stringify(c)}`;
        if (!ok) throw new Error(`Fails for ${whatIs}.`);
        console.log(`Pass for ${whatIs}.`);
    }
  
    [
        0, 1, 2, 3, 4, 1.5, 1.25, 1.75, 10, 999, -4,
        Math.PI, Infinity, NaN, -Infinity, 2**-1075, 2**1023
    ].forEach(x => check1(x));
  
    [
        [0, 0, 0], [0, 1, 0], [1, 0, 0], [0, 1023, 0],
        [0, -1023, Number(2n**52n-1n)], [0, 0, Number(2n**52n-1n)],
        [0, 1024, 0], [0, 1024, Number(2n**52n-1n)],
        [0, 444, 4444444444], [1, 444, Number(2n**52n-1n)]
    ].forEach(x => check2(x));
})();

请看这里，所有这些都在一起并正在运行：

function getNumberParts(x) {
    const asDouble = new Float64Array(1);
    const asBytes = new Uint8Array(asDouble.buffer);

    asDouble[0] = x;

    const sign = asBytes[7] >> 7;
    const exponent = ((asBytes[7] & 0x7f) << 4 | asBytes[6] >> 4);

    asBytes[7] = 0x43;
    asBytes[6] &= 0x0f;
    asBytes[6] |= 0x30;

    return {
        sign: sign,
        rawExponent: exponent,
        biasedExponent: exponent - 1023,
        mantissa: Number(BigInt(asDouble[0]) - 2n ** 52n)
    };
}

function constructNumberFromParts(obj) {
    const sign = obj.sign, exponent = obj.rawExponent, mantissa = obj.mantissa;

    const asDouble = new Float64Array(1);
    const asBytes = new Uint8Array(asDouble.buffer);

    asBytes[0] = mantissa & 0xFF;
    asBytes[1] =  Math.floor(mantissa / 2 **  8) & 0xFF;
    asBytes[2] =  Math.floor(mantissa / 2 ** 16) & 0xFF;
    asBytes[3] =  Math.floor(mantissa / 2 ** 24) & 0xFF;
    asBytes[4] =  Math.floor(mantissa / 2 ** 32) & 0xFF;
    asBytes[5] =  Math.floor(mantissa / 2 ** 40) & 0xFF;
    asBytes[6] = (Math.floor(mantissa / 2 ** 48) & 0x0F) | ((exponent & 0x0F) << 4);
    asBytes[7] = (exponent >>> 4) | (sign << 7);
    return asDouble[0];
}

(() => {
    function check1(a) {
        const b = getNumberParts(a);
        const c = constructNumberFromParts(b);
        const d = getNumberParts(c);
        const ok = a === a ? a === c : c !== c;
        const whatIs = `${a}, ${c}, ${JSON.stringify(b)}, ${JSON.stringify(d)}`;
        if (!ok) throw new Error(`Fails for ${whatIs}.`);
        console.log(`Pass for ${whatIs}.`);
    }

    function check2(a) {
        const p = {
            sign: a[0],
            rawExponent: a[1] + 1023,
            biasedExponent: a[1],
            mantissa: a[2]
        };
        const b = constructNumberFromParts(p);
        const c = getNumberParts(b);
        const d = c.sign, e = c.rawExponent, f = c.mantissa, g = c.biasedExponent;
        const ok = a[1] === g && e === g + 1023 && (b !== b || (a[0] === d && a[2] === f));
        const whatIs = `${JSON.stringify(a)}, ${JSON.stringify(p)}, ${b}, ${JSON.stringify(c)}`;
        if (!ok) throw new Error(`Fails for ${whatIs}.`);
        console.log(`Pass for ${whatIs}.`);
    }
  
    [
        0, 1, 2, 3, 4, 1.5, 1.25, 1.75, 10, 999, -4,
        Math.PI, Infinity, NaN, -Infinity, 2**-1075, 2**1023
    ].forEach(x => check1(x));
  
    [
        [0, 0, 0], [0, 1, 0], [1, 0, 0], [0, 1023, 0],
        [0, -1023, Number(2n**52n-1n)], [0, 0, Number(2n**52n-1n)],
        [0, 1024, 0], [0, 1024, Number(2n**52n-1n)],
        [0, 444, 4444444444], [1, 444, Number(2n**52n-1n)]
    ].forEach(x => check2(x));
})();

Answer 8

我的 Haskell 不存在。这是 JavaScript 中的解决方案。正如其他人所指出的，关键是计算二进制对数以获得指数。

来自 http:// /blog.coolmuse.com/2012/06/21/getting-the-exponent-and-mantissa-from-a-javascript-number/

function decodeIEEE64 ( value ) {

    if ( typeof value !== "number" )
        throw new TypeError( "value must be a Number" );

    var result = {
        isNegative : false,
        exponent : 0,
        mantissa : 0
    };

    if ( value === 0 ) {

        return result;
    }

    // not finite?
    if ( !isFinite( value ) ) {

        result.exponent = 2047;

        if ( isNaN( value ) ) {

            result.isNegative = false;
            result.mantissa = 2251799813685248; // QNan

        } else {

            result.isNegative = value === -Infinity;
            result.mantissa = 0;

        }

        return result;
    }

    // negative?
    if ( value < 0 ) {
        result.isNegative = true;
        value = -value;
    }

    // calculate biased exponent
    var e = 0;
    if ( value >= Math.pow( 2, -1022 ) ) {   // not denormalized

        // calculate integer part of binary logarithm
        var r = value;

        while ( r < 1 )  { e -= 1; r *= 2; }
        while ( r >= 2 ) { e += 1; r /= 2; }

        e += 1023;  // add bias
    }
    result.exponent = e;

    // calculate mantissa
    if ( e != 0 ) {

        var f = value / Math.pow( 2, e - 1023 );
        result.mantissa = Math.floor( (f - 1) * Math.pow( 2, 52 ) );

    } else { // denormalized

        result.mantissa = Math.floor( value / Math.pow( 2, -1074 ) );

    }

    return result;
}

Answer 9

如果您只需要尾数长度，

Number.prototype.mantissaLength = function(){
    var m = this.toString(), d = m.indexOf('.') + 1;
    return d? m.length - d:0;
}

var x = 1234.5678;
var mantL = x.mantissaLength();