高效精确的浮点二进制搜索

Question

考虑以下二进制搜索大于lo但小于或等于hi的值：

find(lo: number, hi: number, isTooLow: (testVal: number) => boolean) {
    for(;;) {
        const testVal = between(lo, hi);
        if (testVal <= lo || testVal >= hi) {
            break;
        }
        if (isTooLow(testVal)) {
            lo = testVal;
        } else {
            hi = testVal;
        }
    }
    return hi;
}

请注意，此处的number是 64 位浮点数。

搜索将始终终止，如果非常仔细地编写 function between的值以选择lo和hi之间可用的 64 位浮点数的中位数，如果它存在，则还：

• 搜索将在 64 次迭代内终止； 和
• 它将精确地找到最小值hi使得isTooLow(hi) == false

但是 function between的这种比较棘手和复杂，它取决于浮点表示的精细细节。

任何人都可以建议between的实现更简单并且不依赖于浮点表示的任何细节，除了有一个固定宽度的尾数，一个固定宽度的指数和一个符号吗？

它需要在 Javascript 中实现，并且它只需要几乎一样好，这样：

• 搜索将始终在 200 次左右的迭代内终止； 和
• 它将非常接近（在 3 或 4 个可能值内）找到最小值hi使得isTooLow(hi) == false

避免超越函数和 sqrt 的加分项。

解析度

最后，我真的很喜欢 David 的有状态猜测器，但我将 state 提升到调用堆栈中，结果基本上是先搜索指数，而不知道表示形式。

我还没有测试/调试这个：

function find(lo: number, hi: number, isTooLow: (testVal: number) => boolean) {
    [lo, hi] = getLinearRange(lo, hi, isTooLow);
    for (; ;) {
        const testVal = lo + (hi - lo) * 0.5;
        if (testVal <= lo || testVal >= hi) {
            break;
        }
        if (isTooLow(testVal)) {
            lo = testVal;
        } else {
            hi = testVal;
        }
    }
    return hi;
}

/**
 * Reduce a floating-point range to a size where a conventional binary
 * search is appropriate.
 * @returns [newlow, newhigh]
 */
function getLinearRange(
    low: number, high: number,
    isTooLow: (n: number) => boolean): [number, number] {

    let negRange: [number, number] | undefined;
    if (low < 0) {
        if (high > 0) {
            if (isTooLow(0)) {
                return scaleRange(0, high, 0.25, isTooLow);
            } else {
                const isTooHigh = (n: number) => !isTooLow(n);
                negRange = scaleRange(0, -low, 0.25, isTooHigh);
            }
        } else {
            const isTooHigh = (n: number) => !isTooLow(n);
            negRange = scaleRange(-high, -low, 0.25, isTooHigh);
        }
    } else {
        return scaleRange(low, high, 0.25, isTooLow);
    }
    // we have to negate the range
    low = -negRange[1];
    negRange[1] = -negRange[0];
    negRange[0] = low;
    return negRange;
}

/**
 * Reduce a positive range until low/high >= minScale
 * @returns [newlow, newhigh]
 */
function scaleRange(
    low: number, high: number, minScale: number,
    isTooLow: (n: number) => boolean): [number, number] {

    if (!(minScale > 0 && low < high * minScale)) {
        return [low, high];
    }
    const range = scaleRange(low, high, minScale * minScale, isTooLow);
    [low, high] = range;
    const test = high * minScale;
    if (test > low && test < high) {
        if (isTooLow(test)) {
            range[0] = test;
        } else {
            range[1] = test;
        }
    }
    return range;
}

Answer 1

这是一个我认为仅使用原始操作就符合 IEEE 双精度规范的想法（但假设它是硬件加速的，似乎可能比使用平方根更糟糕）。 找到符号（如果需要），使用线性搜索找到 11 位指数的前 7 位（≈ 128 个查询，加上 4 个次正规，呃），然后切换到算术平均值（≈ 53 + 2 ¹¹⁻⁷ = 69 个查询），如果我没记错的话，总共大约有 200 个查询。 下面未经测试 JavaScript。

const multiplicative_stride = 1 / 2 ** (2 ** (11 - 7));
function between(low, high) {
  if (high <= 0) return -between(-high, -low);
  if (low < 0) return 0;
  const mid = multiplicative_stride * high;
  return mid <= low ? low + 0.5 * (high - low) : mid;
}

Answer 2

我们也可以做一些预计算（下面的代码适用于非负有限范围，添加分支 ad lib 来处理其他情况）。 我们近似最小的有用分数，将其增加平方根以对指数进行二进制搜索，然后以良好的旧算术平均值结束以确定尾数。 我认为最坏的情况是 65 个查询，当然不会更多，尽管许多输入将花费比 bit-munging 算法更长的时间。

const fractions = [];
const Guesser = {
  fractions: null,
  between(low, high) {
    if (this.fractions === null) {
      this.fractions = [];
      let f = 0.25;
      while (low + f * (high - low) > low) {
        this.fractions.push(f);
        f *= f;
      }
    }
    return low + (this.fractions.pop() || 0.5) * (high - low);
  },
};
for (let i = 0; i <= 101; ++i) {
  let n = 0;
  let g = Object.create(Guesser);
  let low = 0;
  let high = 1.7976931348623157e308;
  for (;;) {
    ++n;
    let mid = g.between(low, high);
    if (mid <= low || high <= mid) break;
    if (100 * Math.random() < i) low = mid;
    else high = mid;
  }
  console.log(n);
}

Answer 3

使用 64 位浮点数迭代不是一个好主意，因为您忘记了64 位浮点数 ( double )表示为 3 个独立的东西：

1 bit sign
11 bit exponent
53 bit mantissa

如果你不知道解决方案的实际范围（你可以从哪里开始）那么你可能会因为这个数字的范围远远超过 2 ^ 64 ...

但是，如果您直接对二进制位执行此操作，则可以（但您必须处理特殊情况，例如NaN,Inf以及非规范化数字）。

因此，不是使用*0.5 ，而是对单个位使用二进制运算，例如x<<=1, x|=1, x^=1 ...

这里简单的例子 C++：

double f64_sqrt(double x)
    {
    // IEEE 754 double MSW masks
    const DWORD _f64_sig    =0x80000000;    // sign
    const DWORD _f64_exp    =0x7FF00000;    // exponent
    const DWORD _f64_exp_sig=0x40000000;    // exponent sign
    const DWORD _f64_exp_bia=0x3FF00000;    // exponent bias
    const DWORD _f64_exp_lsb=0x00100000;    // exponent LSB
    const DWORD _f64_man    =0x000FFFFF;    // mantisa
    const DWORD _f64_man_msb=0x00080000;    // mantisa MSB

    const int h=1;      // may be platform dependent MSB/LSB order
    const int l=0;
    DWORD b;            // bit mask
    union               // semi result
        {
        double f;       // 64bit floating point
        DWORD u[2];     // 2x32 bit uint
        } y;
    // fabs
    y.f=x; y.u[h]&=_f64_exp|_f64_man; x=y.f;
    // set safe exponent (~ abs half) destroys mantisa,sign
    b=(y.u[h]&_f64_exp)-_f64_exp_bia;
    y.u[h]=((b>>1)|(b&_f64_exp_sig))+_f64_exp_bia;
    // sign=`+` mantisa=0
    y.u[h]&=_f64_exp;
    // correct exponent if needed
    if (y.f*y.f>x) y.u[h]=(y.u[h]-_f64_exp_lsb)&_f64_exp;
    // binary search
    for (b=_f64_man_msb;b;b>>=1) { y.u[h]|=b; if (y.f*y.f>x) y.u[h]^=b; }
    for (b=0x80000000  ;b;b>>=1) { y.u[l]|=b; if (y.f*y.f>x) y.u[l]^=b; }
    return y.f;
    }

使用解决方案指数的“估计”（利用结果具有 ~ integer 位的一半用于 sqrt 的事实）和仅尾数的二进制访问二进制搜索（53 次迭代）

如果您不知道指数范围，您也必须对其进行 bin 搜索（从最高位开始或如果符号已知则从一位开始）...