Go math.Ldexp 怎样按二的整数次幂缩放数值

如果已有一个 float64 数值，需要按二的整数次幂放大或缩小，直接调用 math.Ldexp(frac, exp)：它返回 frac × 2^exp。exp 为正就是放大，为负就是缩小，等于 0 则保持原值。

这个函数适合二进制刻度、浮点算法和需要显式表达“调整指数”的代码。它不是任意底数的幂函数；如果底数不是 2，或者指数本身是小数，应考虑其他数学 API。下面从参数、边界到业务封装逐步展开。

Ldexp 的两个参数分别表示什么

函数签名是 func Ldexp(frac float64, exp int) float64。第一个参数是已经存在的浮点数，第二个参数是整数指数，结果相当于把第一个参数乘以 2^exp。例如 math.Ldexp(1.5, 3) 等于 1.5 × 8，结果是 12。

package main

import (
	"fmt"
	"math"
)

func main() {
	values := []struct {
		frac float64
		exp  int
	}{
		{frac: 1.5, exp: 3},   // 放大 2^3 倍。
		{frac: 12, exp: -2},   // 缩小为原来的 1/4。
		{frac: 7.25, exp: 0},  // 指数为 0，结果保持不变。
	}

	for _, item := range values {
		result := math.Ldexp(item.frac, item.exp)
		// %g 适合观察数值，避免固定小数位掩盖数量级变化。
		fmt.Printf("Ldexp(%g, %d) = %g\n", item.frac, item.exp, result)
	}
}

示例中的关键不是把乘法写短，而是把“只调整二进制指数”的意图写进 API。阅读代码的人可以直接看出缩放因子是 2 的整数次幂，也不需要先猜一个常量是否应该换成 math.Pow(2, ...)。

负指数不是整数除法：先看最小例子

exp 是负数时，数学含义是除以对应的二的正整数次幂。例如 math.Ldexp(12, -2) 等于 12 × 2^-2，结果为 3。因为输入和结果都是 float64，这里不会发生 Go 整数除法那种截断。

package main

import (
	"fmt"
	"math"
)

func main() {
	for _, exp := range []int{2, 1, 0, -1, -2, -3} {
		result := math.Ldexp(12, exp)
		// 统一打印正负指数，便于观察每减少一个指数位就除以 2。
		fmt.Printf("exp=%2d result=%g\n", exp, result)
	}

	negativeZero := math.Copysign(0, -1)
	// 特殊值由 math.Ldexp 保持，不要用等于 0 的判断丢掉符号信息。
	fmt.Println("-0 sign:", math.Signbit(math.Ldexp(negativeZero, 10)))
	fmt.Println("+Inf:", math.IsInf(math.Ldexp(math.Inf(1), -20), 1))
	fmt.Println("NaN:", math.IsNaN(math.Ldexp(math.NaN(), 20)))
}

标准库文档明确列出了三个特殊情况：正负零仍是对应的正负零，正负无穷仍是对应的无穷，NaN 仍是 NaN。因此，调用方不需要为了这些值另写一套缩放公式，但如果业务不接受它们，仍然应该在进入计算前用 math.IsInf、math.IsNaN 或 math.Signbit 做策略判断。

结果为什么会变成 0 或 Inf

float64 的可表示范围有限。math.MaxFloat64 是最大的有限值，math.SmallestNonzeroFloat64 是最小的正非零值。负指数过大时，结果会先进入次正规数区域，继续缩小则发生下溢；正指数过大时则发生上溢。工程上不能只看调用是否成功，还要看结果是否已经离开业务允许的范围。

package main

import (
	"fmt"
	"math"
)

func main() {
	tooLarge := math.Ldexp(math.MaxFloat64, 1)
	stillSmallest := math.Ldexp(1, -1074)
	underflow := math.Ldexp(1, -1075)

	// 用 IsInf 区分上溢结果，用等于 0 识别已经下溢到零的结果。
	fmt.Println("overflow to +Inf:", math.IsInf(tooLarge, 1))
	fmt.Println("smallest non-zero:", stillSmallest == math.SmallestNonzeroFloat64)
	fmt.Println("underflow to zero:", underflow == 0)
}

注意，负指数并不意味着结果立刻变成 0。只要数值仍在可表示范围内，结果可能是正常数，也可能是次正规数。只有继续缩小到最小非零值以下，才会下溢到带符号的零；正方向越过最大有限值时，才会得到带符号的无穷。

什么时候用 Ldexp，什么时候用乘法或 Pow

Ldexp 的优势主要是语义清楚，而不是让所有计算都更快。若比例已经存在，直接相乘更自然；若要处理任意底数，强行把问题改写成 Ldexp 反而会让代码难读。只有“底数固定为 2，指数是整数”这个边界成立时，才优先考虑它。

把范围检查放进业务函数

在日志采样、传感器归一化或二进制格式转换中，缩放结果可能继续参与金额、计数或阈值判断。此时可以在封装层明确拒绝 NaN、无穷和越界结果，让调用方处理错误，而不是等到后续比较时才发现异常。

package main

import (
	"errors"
	"fmt"
	"math"
)

var errOutOfRange = errors.New("scaled value is outside the finite float64 range")

func scaleByPowerOfTwo(value float64, exp int) (float64, error) {
	// 业务不接受 NaN 和无穷时，先拒绝特殊输入，避免错误被静默传播。
	if math.IsNaN(value) || math.IsInf(value, 0) {
		return 0, errOutOfRange
	}

	result := math.Ldexp(value, exp)
	// Ldexp 可能因为指数过大或过小产生 Inf 或 0；这里把它转换为显式错误。
	if math.IsInf(result, 0) || (result == 0 && value != 0) {
		return 0, errOutOfRange
	}
	return result, nil
}

func main() {
	result, err := scaleByPowerOfTwo(1.25, 4)
	// 调用方只消费通过范围检查的结果。
	fmt.Println(result, err)
}

上面的策略把“结果下溢为 0”也当作错误，但这不是 Ldexp 的统一要求，而是示例业务的选择。如果你的算法允许下溢，应该把这条规则改成记录状态或单独返回一个标志；如果输入本身就是 0，则保留 0 通常是合理的。

使用前的四个检查点

1. 确认指数类型：第二个参数必须是整数；若指数来自浮点计算，先明确取整规则，不要隐式截断。
2. 确认缩放语义：只有底数固定为 2 时使用 Ldexp，任意比例不要为了形式统一而改写。
3. 确认特殊值策略：决定业务是否接受 NaN、Inf、正负零和次正规数，并把判断放在结果进入下一阶段之前。
4. 确认范围处理：对可能很大的正指数或很小的负指数，检查 IsInf、零结果和业务上限，不要把它们当作普通数继续计算。

可以把结论压缩成一句话：math.Ldexp(x, n) 是“把 x 的二进制指数调整 n 位”的清晰写法。正负指数、特殊值和浮点范围决定了它的实际结果；当这些边界会影响业务时，在调用外包一层明确的范围策略。

相关问题

math.Ldexp(x, 0) 会改变 x 吗？

按数学意义结果仍是 x。对于零、无穷和 NaN，标准库也保留对应的特殊值语义。

负指数是不是先把 x 转成整数再除法？

不是。x 和返回值都是 float64，负指数表达的是乘以 2 的负整数次幂，不是 Go 整数除法。

为什么不统一使用 math.Pow(2, float64(exp))？

当问题明确是二的整数次幂缩放时，Ldexp 的参数和意图更直接；Pow 更适合任意底数、任意实数指数的幂运算。

下溢到 0 一定是错误吗？

不一定。它是浮点范围的结果，是否错误取决于业务；需要保留极小量时，应提前定义次正规数和零的处理策略。