一道前端面试题：如何判断 0.1 + 0.2 与 0.3 相等？

console.log(0.1 + 0.2 === 0.3); // false
console.log(0.1 + 0.2); // 0.30000000000000004

// JavaScript
console.log(0.1 + 0.2); // 0.30000000000000004

// Python
# 0.1 + 0.2 = 0.30000000000000004

// Java
// 0.1 + 0.2 = 0.30000000000000004

// 一些常见小数的二进制表示
console.log(parseFloat(0.1).toString(2)); // 0.0001100110011001100110011001100110011001100110011001101
console.log(parseFloat(0.2).toString(2)); // 0.001100110011001100110011001100110011001100110011001101
console.log(parseFloat(0.3).toString(2)); // 0.010011001100110011001100110011001100110011001100110011
console.log(parseFloat(0.4).toString(2)); // 0.01100110011001100110011001100110011001100110011001101
console.log(parseFloat(0.5).toString(2)); // 0.1
console.log(parseFloat(0.75).toString(2)); // 0.11

// 0.1的64位表示
console.log(parseFloat(0.1).toString(2));
// 0.0001100110011001100110011001100110011001100110011001101

// 0.2的64位表示
console.log(parseFloat(0.2).toString(2));
// 0.001100110011001100110011001100110011001100110011001101

console.log(0.1 + 0.2);
// 0.30000000000000004

console.log(0.1 + 0.2 - 0.3);
// 5.551115123125783e-17

// 使用 toPrecision 查看完整精度
console.log((0.1 + 0.2).toPrecision(21));
// 0.300000000000000044409

console.log((0.3).toPrecision(21));
// 0.299999999999999988898

// Number.EPSILON的数学定义
Number.EPSILON === Math.pow(2, -52); // true
Number.EPSILON === 2.220446049250313e-16; // true

// 它是1与大于1的最小浮点数之间的差值
console.log(1 + Number.EPSILON > 1); // true
console.log(1 + Number.EPSILON / 2 > 1); // false

function simpleFloatEqual(a, b) {
  return Math.abs(a - b) < Number.EPSILON;
}

// 测试
console.log(simpleFloatEqual(0.1 + 0.2, 0.3)); // true
console.log(simpleFloatEqual(1.0, 1.0 + Number.EPSILON / 2)); // true
console.log(simpleFloatEqual(1.0, 1.0 + Number.EPSILON)); // false

// 大数值测试 - 错误结果
const bigNum = 1e16;
console.log(simpleFloatEqual(bigNum, bigNum + 1)); // true，错误！

// 小数值测试 - 过于严格
const smallNum = 1e-20;
console.log(simpleFloatEqual(smallNum, smallNum * 1.1)); // false，过于严格

// 不同量级对比
console.log(simpleFloatEqual(2.0, 2.0 + Number.EPSILON)); // false
console.log(simpleFloatEqual(0.5, 0.5 + Number.EPSILON)); // false

function floatEqual(a, b, toleranceFactor = 1) {
  // 处理特殊值
  if (!Number.isFinite(a) || !Number.isFinite(b)) return a === b;

  // 完全相等（包括+0/-0）
  if (a === b) return true;

  // 计算差值
  const diff = Math.abs(a - b);

  // 处理接近零的情况
  if (Math.abs(a) < Number.MIN_VALUE || Math.abs(b) < Number.MIN_VALUE) {
    return diff < Number.EPSILON * toleranceFactor;
  }

  // 获取两数中较大的指数
  const exp = Math.max(getExponent(a), getExponent(b));

  // 计算该指数区间的理论最小精度单位
  const ulp = Math.pow(2, exp) * Number.EPSILON;

  // 比较
  return diff <= ulp * toleranceFactor;
}

// 获取浮点数指数部分
function getExponent(x) {
  if (x === 0) return 0;
  const float64 = new Float64Array(1);
  float64[0] = x;
  const view = new DataView(float64.buffer);
  const bits = view.getBigUint64(0, true);
  return Number((bits >> 52n) & 0x7ffn) - 1023;
}

// 获取数值的ULP
function getULP(x) {
  if (x === 0) return Number.MIN_VALUE;
  const exp = getExponent(x);
  return Math.pow(2, exp) * Number.EPSILON;
}

function fastFloatEqual(a, b, factor = 2) {
  if (!Number.isFinite(a) || !Number.isFinite(b)) return a === b;

  const diff = Math.abs(a - b);

  // 接近零时的特殊处理
  if (diff < Number.EPSILON) return true;

  // 基于较大值计算容差
  const max = Math.max(Math.abs(a), Math.abs(b));
  return diff <= max * Number.EPSILON * factor;
}

// 更简单的版本，适用于大多数场景
function simpleFloatEqual(a, b, factor = 2) {
  return (
    Math.abs(a - b) <=
    Math.max(Math.abs(a), Math.abs(b)) * Number.EPSILON * factor
  );
}

// 基础测试
console.log(floatEqual(0.1 + 0.2, 0.3)); // true

// 不同量级测试
console.log(floatEqual(1e16, 1e16 + 1)); // false (正确)
console.log(floatEqual(3.0, 3.0 + 4e-16)); // true (ULP=4.44e-16)
console.log(floatEqual(0.75, 0.75 + 1e-16)); // true (ULP=1.11e-16)

// 边界测试
console.log(floatEqual(Number.MIN_VALUE, Number.MIN_VALUE)); // true
console.log(floatEqual(Infinity, Infinity)); // true
console.log(floatEqual(NaN, NaN)); // false (符合标准)
console.log(floatEqual(+0, -0)); // true

// 实际应用测试
console.log(floatEqual(Math.PI, 3.141592653589793)); // true
console.log(floatEqual(Math.sqrt(2), 1.4142135623730951)); // true

/**
 * 最小可用精确计算库
 * 基于字符串处理和整数运算原理
 */
class PreciseMath {
  constructor(precision = 20) {
    this.precision = precision;
    this.roundingMode = "round"; // round, floor, ceil
  }

  /**
   * 将数字转换为字符串，处理科学计数法
   */
  _normalize(num) {
    if (typeof num === "string") return num;

    // 处理科学计数法
    const str = num.toString();
    if (str.includes("e") || str.includes("E")) {
      const [mantissa, exponent] = str.split(/[eE]/);
      const exp = parseInt(exponent);

      if (exp > 0) {
        return (
          mantissa.replace(".", "") +
          "0".repeat(exp - (mantissa.length - mantissa.indexOf(".") - 1))
        );
      } else {
        return "0." + "0".repeat(-exp - 1) + mantissa.replace(".", "");
      }
    }

    return str;
  }

  /**
   * 将小数转换为整数进行运算
   * 例如：0.1 + 0.2 => (1 * 10^1 + 2 * 10^1) / 10^1
   */
  _toInteger(num) {
    const str = this._normalize(num);
    const parts = str.split(".");

    if (parts.length === 1) {
      return {
        value: parts[0],
        scale: 0,
      };
    }

    return {
      value: parts[0] + parts[1],
      scale: parts[1].length,
    };
  }

  /**
   * 对齐两个数的精度
   */
  _align(a, b) {
    const maxScale = Math.max(a.scale, b.scale);

    return {
      a: {
        value: a.value + "0".repeat(maxScale - a.scale),
        scale: maxScale,
      },
      b: {
        value: b.value + "0".repeat(maxScale - b.scale),
        scale: maxScale,
      },
    };
  }

  /**
   * 字符串加法
   */
  _addStrings(a, b) {
    const maxLen = Math.max(a.length, b.length);
    a = a.padStart(maxLen, "0");
    b = b.padStart(maxLen, "0");

    let carry = 0;
    let result = "";

    for (let i = maxLen - 1; i >= 0; i--) {
      const sum = parseInt(a[i]) + parseInt(b[i]) + carry;
      result = (sum % 10) + result;
      carry = Math.floor(sum / 10);
    }

    if (carry > 0) {
      result = carry + result;
    }

    return result;
  }

  /**
   * 字符串减法
   */
  _subtractStrings(a, b) {
    const maxLen = Math.max(a.length, b.length);
    a = a.padStart(maxLen, "0");
    b = b.padStart(maxLen, "0");

    let borrow = 0;
    let result = "";

    for (let i = maxLen - 1; i >= 0; i--) {
      let diff = parseInt(a[i]) - parseInt(b[i]) - borrow;

      if (diff < 0) {
        diff += 10;
        borrow = 1;
      } else {
        borrow = 0;
      }

      result = diff + result;
    }

    // 移除前导零
    result = result.replace(/^0+/, "") || "0";
    return result;
  }

  /**
   * 格式化结果
   */
  _formatResult(value, scale) {
    if (scale === 0) return value;

    // 确保有足够的小数位
    while (value.length <= scale) {
      value = "0" + value;
    }

    const integerPart = value.slice(0, -scale);
    const decimalPart = value.slice(-scale);

    return (integerPart || "0") + "." + decimalPart;
  }

  /**
   * 精确加法
   */
  add(a, b) {
    const aInt = this._toInteger(a);
    const bInt = this._toInteger(b);
    const aligned = this._align(aInt, bInt);

    const result = this._addStrings(aligned.a.value, aligned.b.value);
    return this._formatResult(result, aligned.a.scale);
  }

  /**
   * 精确减法
   */
  subtract(a, b) {
    const aInt = this._toInteger(a);
    const bInt = this._toInteger(b);
    const aligned = this._align(aInt, bInt);

    const result = this._subtractStrings(aligned.a.value, aligned.b.value);
    return this._formatResult(result, aligned.a.scale);
  }

  /**
   * 精确比较
   */
  equals(a, b) {
    return this.add(a, "0") === this.add(b, "0");
  }

  /**
   * 精确乘法（简化版）
   */
  multiply(a, b) {
    const aInt = this._toInteger(a);
    const bInt = this._toInteger(b);

    // 简化的乘法实现
    const result = (parseInt(aInt.value) * parseInt(bInt.value)).toString();
    const scale = aInt.scale + bInt.scale;

    return this._formatResult(result, scale);
  }
}

// 使用示例
const math = new PreciseMath();

console.log("=== 精确计算测试 ===");
console.log("0.1 + 0.2 =", math.add("0.1", "0.2")); // 0.3
console.log(
  "0.1 + 0.2 === 0.3:",
  math.equals("0.1", math.subtract("0.3", "0.2"))
); // true

console.log("\n=== 大数测试 ===");
console.log("1e16 + 1 =", math.add("10000000000000000", "1")); // 10000000000000001
console.log(
  "1e16 + 1 === 1e16:",
  math.equals("10000000000000000", "10000000000000001")
); // false

console.log("\n=== 科学计数法测试 ===");
console.log("1e-10 + 1e-10 =", math.add("0.0000000001", "0.0000000001")); // 0.0000000002

console.log("\n=== 与原生比较 ===");
console.log("原生: 0.1 + 0.2 =", 0.1 + 0.2);
console.log("精确: 0.1 + 0.2 =", math.add("0.1", "0.2"));

/**
 * 扩展功能：支持更多运算和配置
 */
class AdvancedPreciseMath extends PreciseMath {
  constructor(precision = 20, roundingMode = "round") {
    super(precision);
    this.roundingMode = roundingMode;
  }

  /**
   * 设置舍入模式
   */
  setRoundingMode(mode) {
    this.roundingMode = mode;
    return this;
  }

  /**
   * 舍入到指定精度
   */
  round(value, precision) {
    const parts = value.split(".");
    if (parts.length === 1 || parts[1].length <= precision) {
      return value;
    }

    const integerPart = parts[0];
    const decimalPart = parts[1];
    const significant = decimalPart.slice(0, precision);
    const nextDigit = parseInt(decimalPart[precision] || "0");

    let rounded;
    switch (this.roundingMode) {
      case "floor":
        rounded = significant;
        break;
      case "ceil":
        rounded =
          nextDigit > 0 ? this._addStrings(significant, "1") : significant;
        break;
      case "round":
      default:
        rounded =
          nextDigit >= 5 ? this._addStrings(significant, "1") : significant;
        break;
    }

    return this._formatResult(integerPart + rounded, precision);
  }

  /**
   * 格式化输出
   */
  format(value, options = {}) {
    const {
      precision = this.precision,
      notation = "standard", // standard, scientific, engineering
      minFractionDigits = 0,
      maxFractionDigits = precision,
    } = options;

    let result = this.round(value, precision);

    // 处理科学计数法
    if (notation === "scientific" && Math.abs(parseFloat(result)) >= 1e6) {
      const num = parseFloat(result);
      const exp = Math.floor(Math.log10(Math.abs(num)));
      const mantissa = num / Math.pow(10, exp);
      return `${mantissa.toFixed(6)}e${exp}`;
    }

    return result;
  }
}

// 高级功能测试
const advancedMath = new AdvancedPreciseMath(10, "round");

console.log("\n=== 高级功能测试 ===");
console.log("舍入测试 (round):", advancedMath.round("3.14159265359", 3)); // 3.142
console.log(
  "舍入测试 (floor):",
  advancedMath.setRoundingMode("floor").round("3.14159265359", 3)
); // 3.141
console.log(
  "舍入测试 (ceil):",
  advancedMath.setRoundingMode("ceil").round("3.14159265359", 3)
); // 3.142

console.log(
  "格式化测试:",
  advancedMath.format("3.14159265359", { precision: 4 })
); // 3.1416