math模块篇（二）

math.fma(x, y, z)

math.fma(x, y, z) 是 Python 中 math 模块的一个函数，用于执行融合乘加（fused multiply-add）运算。融合乘加是一种数学运算，它将乘法和加法组合成一个单独的运算，以减少浮点数运算中的舍入误差。

具体来说，math.fma(x, y, z) 计算 (x * y) + z，但是作为单个操作执行，而不是分别执行乘法和加法。这有助于防止在连续执行乘法和加法时由于中间结果的舍入而产生的精度损失。

例如：

import math

# 常规方式执行乘法和加法
result1 = (1.0 * 2.0) + 3.0

# 使用 math.fma 执行融合乘加
result2 = math.fma(1.0, 2.0, 3.0)

print(result1)  # 输出: 5.0
print(result2)  # 输出: 5.0

在这个例子中，result1 和 result2 都应该等于 5.0，但是由于浮点数的精度问题，如果直接进行两次独立的运算（乘法和加法），可能会引入小的舍入误差。使用 math.fma() 可以减少这种误差。

融合乘加运算在需要高精度计算的应用中非常有用，特别是在图形学、科学计算和数值分析中。在这些领域中，减少舍入误差是非常重要的，因为它可以保持计算的稳定性和准确性。

math.fmod(x, y)

math.fmod(x, y) 是 Python 中 math 模块的一个函数，用于计算 x 除以 y 的余数，即 x 对 y 的浮点余数。这个函数与内置的 % 运算符类似，但 math.fmod() 总是返回一个浮点数，即使对于整数输入也是如此。

math.fmod() 与 % 运算符的主要区别在于如何处理负数和零。例如，当 y 是零时，math.fmod() 会引发一个 ZeroDivisionError 异常，而 % 运算符则会返回 x 本身（在 Python 3 中）。

下面是一些使用 math.fmod() 的例子：

import math

print(math.fmod(10, 3))  # 输出: 1.0
print(math.fmod(-10, 3)) # 输出: -1.0
print(math.fmod(10, -3)) # 输出: 1.0
print(math.fmod(-10, -3)) # 输出: -1.0
print(math.fmod(10, 0))  # 引发 ZeroDivisionError

在这个例子中，math.fmod(10, 3) 返回 1.0，因为 10 除以 3 的余数是 1。对于负数，余数也是负数，并且其符号与 x 相同。

需要注意的是，由于浮点数的精度问题，math.fmod() 的结果可能不会完全符合预期。例如，math.fmod(1.0, 0.3) 可能不会返回完全准确的 0.1，而是接近 0.1 的一个浮点数。

这个函数在处理需要高精度余数计算的情况时非常有用，例如在物理模拟、金融计算或信号处理等领域。

math.frexp(x)

math.frexp(x) 是 Python 中 math 模块的一个函数，用于将一个浮点数 x 分解为一个尾数（mantissa）和一个指数（exponent），遵循以下公式：

x = mantissa * 2**exponent

其中 mantissa（尾数）是一个介于 [0.5, 1) 或者为 0 的浮点数，而 exponent 是一个整数。math.frexp(x) 返回一个包含这两个值的元组 (mantissa, exponent)。

如果 x 是零，那么返回的尾数是 0.0，指数是任意值（在 Python 中通常是 0）。

这个函数对于理解浮点数的内部表示和进行某些数学运算是有用的。

下面是一些 math.frexp() 的使用例子：

import math

# 正数
mantissa, exponent = math.frexp(8.0)
print(mantissa)  # 输出: 0.5
print(exponent)  # 输出: 4

# 负数
mantissa, exponent = math.frexp(-8.0)
print(mantissa)  # 输出: -0.5
print(exponent)  # 输出: 4

# 0
mantissa, exponent = math.frexp(0.0)
print(mantissa)  # 输出: 0.0
print(exponent)  # 输出: 0

# 非规格化数（denormalized number）
mantissa, exponent = math.frexp(1e-323)
print(mantissa)  # 输出: 0.99999999999999989
print(exponent)  # 输出: -1074

在这些例子中，你可以看到 math.frexp() 如何将浮点数分解为其尾数和指数。对于正数，尾数是 0.5 到 1 之间的数；对于负数，尾数是 -0.5 到 0 之间的数。指数是一个整数，它表示了尾数需要乘以 2 的多少次方才能得到原始的浮点数 x。

math.fsum(iterable)

math.fsum(iterable) 是 Python 中 math 模块的一个函数，用于对可迭代对象（如列表、元组等）中的浮点数进行精确求和。这个函数接受一个可迭代对象作为参数，并返回其中所有浮点数的总和。

常规的加法运算在涉及大量浮点数相加时可能会因为浮点数的精度问题而积累误差，而 math.fsum() 函数使用一种特殊的算法，能够更精确地计算浮点数的总和，从而避免这种误差的积累。

下面是一个使用 math.fsum() 的例子：

import math

# 一个包含浮点数的列表
numbers = [0.1, 0.2, 0.3, 0.4]

# 使用 math.fsum() 对浮点数进行精确求和
total = math.fsum(numbers)

print(total)  # 输出: 1.0，而不是 0.9999999999999999（由于浮点数的精度问题，常规加法可能会得到这个结果）

在这个例子中，math.fsum() 能够正确地计算出列表中所有浮点数的和，即 0.1 + 0.2 + 0.3 + 0.4 等于 1.0。

需要注意的是，math.fsum() 只能用于浮点数。如果可迭代对象中包含非浮点数（如整数或复数），则这些值将被忽略。此外，如果可迭代对象为空，math.fsum() 将返回 0.0。

这个函数在处理需要高精度求和的场合时非常有用，例如金融计算、统计分析或科学计算等。

math.gcd(*integers)

math.gcd(*integers) 是 Python 中 math 模块的一个函数，用于计算两个或多个整数的最大公约数（Greatest Common Divisor, GCD）。这个函数接受任意数量的整数作为参数，并返回这些整数的最大公约数。

最大公约数是两个或多个整数共有约数中最大的一个。例如，12 和 15 的公约数有 1, 3，其中最大的是 3，所以 12 和 15 的最大公约数是 3。

math.gcd() 函数的使用非常直接，以下是一些例子：

import math

# 计算两个整数的最大公约数
gcd_two = math.gcd(48, 18)
print(gcd_two)  # 输出: 6

# 计算三个整数的最大公约数
gcd_three = math.gcd(48, 18, 12)
print(gcd_three)  # 输出: 6

# 计算多个整数的最大公约数
gcd_many = math.gcd(48, 18, 12, 24, 36)
print(gcd_many)  # 输出: 6

在这个例子中，math.gcd(48, 18) 返回 6，因为 6 是 48 和 18 的最大公约数。同样地，math.gcd(48, 18, 12) 和 math.gcd(48, 18, 12, 24, 36) 也返回 6，因为 6 是这些数字的最大公约数。

这个函数对于需要找出两个或多个数共同因素的问题很有用，例如在分数简化、密码学、编程算法等领域。

math.isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)

math.isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0) 是 Python 中 math 模块的一个函数，用于判断两个浮点数 a 和 b 是否足够接近，从而可以被认为是相等的。由于浮点数的精度限制，有时候即使两个浮点数在理论上应该是相等的，由于舍入误差，它们可能在实际计算中并不相等。math.isclose() 函数提供了解决这个问题的方法。

函数参数解释：

• a 和 b：需要比较的两个浮点数。
• rel_tol：相对容差（relative tolerance），默认为 1e-09。这是 a 和 b 之间可接受的最大相对误差。相对容差是相对于 a 和 b 中较大值的比例。
• abs_tol：绝对容差（absolute tolerance），默认为 0.0。这是 a 和 b 之间可接受的最大绝对误差。

math.isclose(a, b) 返回 True 如果 a 和 b 在相对容差和绝对容差的范围内被认为是接近的，否则返回 False。

这里有一个使用 math.isclose() 的例子：

import math

# 由于浮点数的精度问题，直接比较可能会产生意外的结果
a = 0.1 + 0.2
b = 0.3

# 使用 math.isclose() 来判断 a和b是否足够接近
print(a == b)          # 输出: False，因为直接比较浮点数通常不可靠
print(math.isclose(a, b))  # 输出: True，因为a和b在容差范围内被认为是相等的

# 改变相对容差和绝对容差
print(math.isclose(a, b, rel_tol=1e-5, abs_tol=0.001))  # 输出可能会变，取决于容差的选择

在这个例子中，即使 a 和 b 在理论上应该是相等的（0.3），但由于浮点数的精度问题，直接比较它们会得到 False。然而，使用 math.isclose() 并指定适当的容差，我们可以得出它们是否足够接近的结论。