提取 Javascript 数字的指数和尾数

Question

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

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

我正在实现一个用于生成 Javascript 的 GHC 插件，需要实现 decodeFloat_Int# 和 decodeDouble_2Int# primitive operations;我想我可以重写基础库的部分，使用该操作来做他们以其他方式做的事情（这不应该太难，因为所有数字类型都以数字作为它们的表示，）但是它'如果我不必这样做，那就太好了。

有没有什么方法可以通过一些黑暗的 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 规范的第 8.5 节，以了解您必须处理哪些情况。

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

虽然我喜欢接受的解决方案，但使用它在任意基础上工作重新引入了由 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 5

对于以 10 为底的数，您可以使用数组获取尾数和指数

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

如果您不关心结果部分是否是文本而不是数字，并且指数部分前面是否有加号，那么您可以跳过 parseFloat 和 parseInt 步骤，只需执行直接从数组 [0] 和 [1] 中提取的部分。

Answer 6

接下来如何获得指数？：

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

1000 将导致 exp = 3

Answer 7

我的 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 8

如果只需要尾数长度，

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();