使用电脑去进行浮点数运算的时候,在某些条件下会出现显而易见的误差,而这样的误差,就会导致与浮点数有关的计算或是逻辑判断出现问题。
在这篇文章开始前,您可以先看看以下的程序:
Rust
Java
TypeScript
fn main() {
println!("0.1 + 1.1 = {}", 0.1 + 1.1);
println!("0.1 * 1.1 = {}", 0.1 * 1.1);
}
public static void main(final String[] args) {
System.out.println("0.1 + 1.1 = " + (0.1 + 1.1));
System.out.println("0.1 * 1.1 = " + (0.1 * 1.1));
}
console.log(`0.1 + 1.1 = ${0.1 + 1.1}`);
console.log(`0.1 * 1.1 = ${0.1 * 1.1}`);
以上程序的输出结果如下:
0.1 + 1.1 = 1.2000000000000002
0.1 * 1.1 = 0.11000000000000001
如何?很奇怪吧!
尝试写个程序判断两个浮点数是否能整除
当我们要判断两个数是否能整除的时候,只要将这两个数相除,再看看除出来的商是否为整数,如果是整数,表示被除数是除数的整数倍。让我们直接根据这个作法来写个程序判断两个浮点数是否能整除,代码如下:
Rust
Java
TypeScript
pub fn is_divisible(dividend: f64, divisor: f64) -> bool {
let quotient = dividend / divisor;
quotient == quotient.round()
}
public static boolean isDivisible(final double dividend, final double divisor) {
final double quotient = dividend / divisor;
return quotient == Math.round(quotient);
}
function isDivisible(dividend: number, divisor: number) {
const quotient = dividend / divisor;
return quotient == Math.round(quotient);
}
以上的 is_divisible 或 isDivisible 函数,当传入的参数是 0.1 和 0.000001 时,就会回传 false(不能整除)。但 0.1 很显然是可以被 0.000001 整除的。问题出现的原因是在于电脑计算 0.1/0.000001 之后得到了 100000.00000000001 这样的非整数结果。
这里要特别注意的是,在判断一个浮点数是否为整数的时候,不要使用 ceil 或是 floor 函数来消除小数,因为有误差的值可能会比原值大或是小。好比 1/0.00001 会算出 99999.99999999999,如果我们是用 floor 直接消除小数,那么 99999.99999999999 和 99999 将会差距巨大,使我们无法正确判断 1/0.00001 的结果是否为整数。
判断两个浮点数是否相等
在大部分的情况下,要写程序去判断两个浮点数类型的值(#{{a}}#、#{{b}}#)是否相等的时候,要先将两数相减所得出的差(difference)取绝对值,再判断差的绝对值是否小于某个误差值(epsilon),而不是直接去进行相等的逻辑运算。即:
#{{{
\text{若} \mid a - b \mid \text{ } \lt \text{ } \epsilon \rightarrow \text{则 a = b}
}}}#
至于这个 #{{\epsilon}}# 的值该怎么定,就看我们要算得多精准。首先要先决定好是要用单倍精准浮点数,还是双倍精准浮点数。
浮点数是以二进制的科学记号(scientific notation,或称科学计数法)来表示数值,即 #{{\pm a \times 2^n}}#。浮点数的第一个比特用来表示正负号(sign);中间段的几个比特用来表示科学记号的指数 #{{n}}#,尾段的几个比特用来表示科学记号的实数 #{{a}}# 的小数部份(尾数)。
单倍精准浮点数 有 32 个比特,尾段的 23 个比特用来表示实数 #{{a}}# 的尾数,共可表示 #{{2^{23} = 8388608}}# 个尾数,所以 32 比特的浮点数的精确度为 #{{\lfloor log_{10}{2^{23}} \rfloor = 6}}# 个位数 。它可以保证在不计算开头那些连续的 0 的位数下(像是 0.00106 只能算后面的 3 个位数),至少能精确地从前面开始表示 6 个位数。
您可能会有看过 32 比特的浮点数的有效位数有 7 个或是 6 至 7 个的说法,这跟指数 #{{n}}# 是有关系的。
当指数 #{{n}}# 是 0 时,32 比特的浮点数可表示的数值范围为 [1.0, 2.0)(先不管正负号,不重要)。32 比特的浮点数可以将这个范围的数值平均切成 8_388_608 段,此时的精准度就是 7 个位数,因为 0.000000、0.000001、……、0.999999 也不过 1_000_000 个数字,离「32 比特的浮点数可以表示出 8_388_608 个尾数」还差得很远呢!把精确的小数点后 6 个位数再加上小数点前的 1 个位数(也就是 1),不就是 7 位了吗?
当指数 #{{n}}# 是 23 时,浮点数可能的数值范围为 [223 , 224 ),也就是 [8_388_608, 16_777_216),32 比特的浮点数可以将这个范围的数值平均切成 8_388_608 段,若以精准 7 位数来看的话,[9_000_000, 10_000_000) 共有 1_000_000 个数字要表示,且因为这个范围的每个 32 比特的浮点数相差 1,刚好可以对应这 1_000_000 个数字,所以此时是有 7 位数的精确度的。
当指数 #{{n}}# 是 33 时,浮点数可能的数值范围为 [233 , 234 ),也就是 [8_589_934_592, 17_179_869_184),32 比特的浮点数可以将这个范围的数值平均切成 8_388_608 段,若以精准 7 位数来看的话,[9_000_000_000, 10_000_000_000) 共有 1_000_000 个数字要表示(9_000_000_000, 9_000_001_000, 9_000_002_000, ...),但这个范围的每个 32 比特的浮点数相差 1024,只能够表示其中的 976_562 个数字,所以精准度就不足 7 位数了!
至于小于 1 的数字,也可以找到有效位数非 7 位数的例子,像是 0.0009962818,32 比特的浮点数就只能够使用最接近的 0.0009962817 来表示它。
双倍精准浮点数 有 64 个比特,尾段的 52 个比特用来表示实数 #{{a}}# 的尾数,所以 64 比特的浮点数的精确度为 #{{\lfloor log_{10}{2^{52}} \rfloor = 15}}# 个位数 。
与 32 比特的浮点数同理,也有 64 比特的浮点数的有效位数有 15 个或是 15 至 16 个的说法,它们表示的数值范围会影响到它们的有效位数。
判断两个浮点数是否相等的时候,若要设置误差能容忍到小数点后第 n 位,可以将 #{{\epsilon}}# 设置为 10-n (1e-n)。但这样的设置方式会有个问题是我们的浮点数有效位可能不一定都会靠近小数点,好比我们设置了 n = 6,但使用的浮点数的绝对值都小于 10-6 ,此时会将所有的浮点数都视为相等。
还有一种判断两个浮点数是否相等方式,要利用大于 1 的最小浮点数与 1 的差,即「machine epsilon」,编程语言通常会以常数的方式提供这个值。不过也要把判断两个浮点数是否相等的方式改为以下的样子以符合 machine epsilon 的定义,不然像是 0.1234567 和 0.1234568 这两个 32 比特的浮点数,就会被判定为是一样的浮点数。
#{{{
\text{设} \mid a \mid \text{ } \geq \text{ } \mid b \mid \text{,若 } \mid {a \over b} - 1 \mid \text{ } \lt \text{ } \epsilon \text{ } \rightarrow \text{ } \text{则 a = b}
}}}#
为了避免 #{{b = 0}}# 导致除以 0 的情况发生,我们或许可以对不等式做一些改变,如下:
#{{{
\begin{alignedat}{2}
&&&\mid {a \over b} - 1 \mid \text{ } \lt \text{ } \epsilon \text{ } \\
&{}\rightarrow{}&& \text{ } \mid {{a - b} \over b} \mid \text{ } \lt \text{ } \epsilon \text{ } \\
&{}\rightarrow{}&& \text{ } \mid {a - b} \mid \text{ } \lt \text{ } \mid b \mid \times \epsilon
\end{alignedat}
}}}#
以上的不等式看起来可行,但实际使用会发现当我们等比例增大或减少 #{{a}}#、#{{b}}# 时,#{{\mid {a - b} \mid}}# 的误差值并不会等比例做变化,所以要把 #{{\mid b \mid \times \epsilon}}# 再乘上某值来扩大容许的误差范围才行,笔者觉得变成 #{{8}}# 倍还不错。
此外,浮点数也有可能会是无限大的,因此在程序实作时,也要纳入考量。
程序实作如下:
Rust
Java
TypeScript
pub fn is_equal(a: f64, b: f64) -> bool {
if a == b {
true
} else {
let a_abs = a.abs();
let b_abs = b.abs();
let d_abs = (a - b).abs();
if a_abs >= b_abs {
d_abs < b_abs * f64::EPSILON * 8.0
} else {
d_abs < a_abs * f64::EPSILON * 8.0
}
}
}
a == b 可以判断无限大是否相等。
public static boolean isEqual(final double a, final double b) {
if (a == b) {
return true;
} else {
final double aAbs = Math.abs(a);
final double bAbs = Math.abs(b);
final double dAbs = Math.abs(a - b);
if (aAbs >= bAbs) {
return dAbs < bAbs * Math.ulp(1.0) * 8.0;
} else {
return dAbs < aAbs * Math.ulp(1.0) * 8.0;
}
}
}
a == b 可以判断无限大是否相等。Java 并没有提供 machine epsilon 常数,所以用 Math.ulp(1.0) 函数来算出。
function isEqual(a: number, b: number) {
if (a === b) {
return true;
} else {
const aAbs = Math.abs(a);
const bAbs = Math.abs(b);
const dAbs = Math.abs(a - b);
if (aAbs >= bAbs) {
return dAbs < bAbs * Number.EPSILON * 8.0;
} else {
return dAbs < aAbs * Number.EPSILON * 8.0;
}
}
}
a === b 可以判断无限大是否相等。
以上程序还可以再化简如下:
Rust
Java
TypeScript
pub fn is_equal(a: f64, b: f64) -> bool {
if a == b {
true
} else {
let a_abs = a.abs();
let b_abs = b.abs();
let d_abs = (a - b).abs();
d_abs < a_abs.min(b_abs) * f64::EPSILON * 8.0
}
}
public static boolean isEqual(final double a, final double b) {
if (a == b) {
return true;
} else {
final double aAbs = Math.abs(a);
final double bAbs = Math.abs(b);
final double dAbs = Math.abs(a - b);
return dAbs < Math.min(aAbs, bAbs) * Math.ulp(1.0) * 8.0;
}
}
function isEqual(a: number, b: number) {
if (a === b) {
return true;
} else {
const aAbs = Math.abs(a);
const bAbs = Math.abs(b);
const dAbs = Math.abs(a - b);
return dAbs < Math.min(aAbs, bAbs) * Number.EPSILON * 8.0;
}
}
判断两个浮点数是否能整除
稍微修改以上的 is_divisible 或 isDivisible 函数,结合我们后来想出的判断浮点数是否相等的作法,再利用大于 0 的最小浮点数来判断被除数和除数是否(近似)等于 0,可以实作出如下的程序:
Rust
Java
TypeScript
pub fn is_divisible(dividend: f64, divisor: f64) -> bool {
if divisor.abs() < f64::MIN_POSITIVE {
dividend.abs() < f64::MIN_POSITIVE
} else {
let quotient = dividend / divisor;
is_equal(quotient, quotient.round())
}
}
Rust 的 f64::MIN_POSITIVE 或 f32::MIN_POSITIVE 是大于 0 的最小正规数(normal number),0 到最小正规数之间还有许多次正规数(subnormal number)。这样做可以避免在某些机器上面,0 到最小正规数之间的次正规数被当作 0。如果要使用大于 0 的最小次正规数,可以直接使用浮点数定数 4.9406564584124654e-324(64 比特)、1.401298e-45(32 比特)。
public static boolean isDivisible(final double dividend, final double divisor) {
final double DBL_MIN_POSITIVE = Math.ulp(0.0);
if (Math.abs(divisor) < DBL_MIN_POSITIVE) {
return Math.abs(dividend) < DBL_MIN_POSITIVE;
} else {
final double quotient = dividend / divisor;
return isEqual(quotient, Math.round(quotient));
}
}
Java 的 Math.ulp 函数会找出次正规数(subnormal number)间的差。
function isDivisible(dividend: number, divisor: number) {
const DBL_MIN_POSITIVE = Number.MIN_VALUE;
if (Math.abs(divisor) < DBL_MIN_POSITIVE) {
return Math.abs(dividend) < DBL_MIN_POSITIVE;
} else {
const quotient = dividend / divisor;
return isEqual(quotient, Math.round(quotient));
}
}
如果用相除后余数(remainder)是否为 0 来判断两个浮点数能不能整除呢?大部份编程语言不是都会有提供余数操作符 %,如果没有也会有相关的 mod 函数吧?
您可以先看看以下的程序:
Rust
Java
TypeScript
fn main() {
println!("1.0 % 0.5 = {}", 1.0 % 0.5);
println!("1.0 % 0.2 = {}", 1.0 % 0.2);
println!("1.0 % 0.1 = {}", 1.0 % 0.1);
}
public static void main(final String[] args) {
System.out.println("1.0 % 0.5 = " + (1.0 % 0.5));
System.out.println("1.0 % 0.2 = " + (1.0 % 0.2));
System.out.println("1.0 % 0.1 = " + (1.0 % 0.1));
}
console.log(`1.0 % 0.5 = ${1.0 % 0.5}`);
console.log(`1.0 % 0.2 = ${1.0 % 0.2}`);
console.log(`1.0 % 0.1 = ${1.0 % 0.1}`);
以上程序的输出结果如下(Java 会把第一行的 0 印成 0.0):
1.0 % 0.5 = 0
1.0 % 0.2 = 0.19999999999999996
1.0 % 0.1 = 0.09999999999999995
如何?很奇怪吧!这已经不是余数是不是近似于 0 的问题了,0.19999999999999996 和 0 明显差很多。所以我们不能 用这样的方式来找浮点数相除的余数。
计算两个浮点数相除后的余数
注意,这边我们定义用商向下取整(取不大于商的最大整数)后乘上除数,再用被除数去减掉所得到的乘积即为余数,所以余数正负号会跟除数一样。(Python 的 % 操作符所得到的余数也是如此,但其它编程语言就不一定了。)
要计算 #{{a}}#、#{{b}}# 两个数相除(#{{a \div b}}#)后的余数,可以使用以下公式:
#{{{
\text{余数} = a - \lfloor {a \over b} \rfloor \times b
}}}#
然而我们知道电脑在运算 #{{a \over b}}# 的时候有可能会因为出现误差而导致整数部份有所变化,所以我们不能直接使用 floor 函数来计算余数。
我们可以先将 #{{a \over b}}# 的商代入 ceil 函数,再判断计算结果与商是否(近似)相等。如果是的话就使用 ceil 函数算出来的结果作为 #{{\lfloor {a \over b} \rfloor}}# 的结果;如果不是的话才使用 floor 函数来计算。
程序实作如下:
Rust
Java
TypeScript
pub fn calculate_remainder(dividend: f64, divisor: f64) -> f64 {
let quotient = dividend / divisor;
let quotient_ceil = quotient.ceil();
let floor = if is_equal(quotient, quotient_ceil) {
quotient_ceil
} else {
quotient.floor()
};
dividend - (floor * divisor)
}
public static double calculateRemainder(final double dividend, final double divisor) {
final double quotient = dividend / divisor;
final double quotientCeil = Math.ceil(quotient);
final double floor;
if (isEqual(quotient, quotientCeil)) {
floor = quotientCeil;
} else {
floor = Math.floor(quotient);
}
return dividend - (floor * divisor);
}
function calculateRemainder(dividend: number, divisor: number) {
const quotient = dividend / divisor;
const quotientCeil = Math.ceil(quotient);
let floor;
if (isEqual(quotient, quotientCeil)) {
floor = quotientCeil;
} else {
floor = Math.floor(quotient);
}
return dividend - floor * divisor;
}