浅谈 System.Decimal 结构

引言

我们知道，Microsoft .NET Framework 中的 System.Decimal 结构（在 C# 语言中等价于 decimal 关键字）用来表示十进制数，范围从 -(2⁹⁶ - 1) 到 2⁹⁶ - 1，并且可以有 28 位小数。这就是说：

• decimal.MinValue = -79,228,162,514,264,337,593,543,950,335 = -(2⁹⁶ - 1)
• decimal.MaxValue = 79,228,162,514,264,337,593,543,950,335 = 2⁹⁶ - 1
• decimal.Epsilon = 0.0000000000000000000000000001 = 10^-28

上面前两个是 decimal 的静态只读字段。遗憾的是，第三个不属于 decimal 结构。

decimal 内部使用 4 个 32-bit 的 System.Int32 来存储，占用 128 bits = 16 bytes。这 128 bits 分配如下：

• 96 bits 表示从 0 至 2⁹⁶ - 1 的整数，分布在 3 个 32-bit 的 System.Int32 中。
• 剩下的 1 个 32-bit 的 System.Int32 包括符号位和比例因子。
• 第 31 bit 是符号位，0 表示正数，1 表示负数。
• 第 16 至 23 bit 表示比例因子，必须包含一个 0 至 28 之间的指数，指示 10 的幂，即小数点的位置，也就是小数点右边有几位数字。
• 其实表示 0 至 28 之间的指数只需 5 bits 就够了，而上面的第 16 至 23 bit 共 8 bits = 1 byte。也就是说剩下的 3 bits (第 21 至 23 bit) 一定是零。
• 其余 bits （0 - 15 bit 和 24 - 30 bit）不被使用，必须为零。

decimal.GetBits 方法就返回上述 decimal 的内部表示。而 decimal (int[] bits) 构造函数就使用这个内部表示构造来构造 decimal 实例。一个 decimal 可能会有几种不同的内部表示，所有这些内部表示均同样有效，并且在数值上相等。

TinyDecimal 数据类型

为了更好地理解 decimal 结构，我们来构造一个只有 8 bits = 1 byte 的 TinyDecimal 结构：

• number: 第 0 至 5 bit （共 6 bits）表示从 0 至 2⁶ - 1 的整数，共有 64 个。
• exp: 第 6 bit 表示比例因子，包含一个 0 至 1 之间的指数，指示 10 的幂，即小数点的位置。0 表示小数点在最右边。
• sign: 第 7 bit 是符号位，0 表示正数，1 表示负数。

因此：

• TinyDecimal.MinValue = -63 = -(2⁶ - 1)
• TinyDecimal.MaxValue = 63 = 2⁶ - 1
• TinyDecimal.Epsilon = 0.1 = 10^-1

也就是说，TinyDecimal 的表示范围从 -63 至 63，并且可以有 1 位小数。

TinyDecimal 的正数有以下两种情形：

• 当 exp = 1 时: 0.1, 0.2, ... , 0.9, 1.0, 1.1, ... , 6.2, 6.3 。共 63 个。
• 当 exp = 0 时：1, 2, ... , 63 。共 63 个，但前 6 个（1 = 1.0, 2 = 2.0, ... , 6 = 6.0）和上面的重复了。

所以 TinyDecimal 的正数共有 63 + (63 - 6) = 120 个。负数的情况是一样的，也有 120 个。所以 TinyDecimal 有 241 个不同的值，即正数和负数各 120 个，加上一个零。注意，零有四种不同的表示：+0, -0, +0.0, -0.0。TinyDecimal 的正数顺序排列如下：

• 0.1, 0.2, ... , 6.2, 6.3, 7, 8, 9, 10, 11, ... , 62, 63

注意，在 TinyDecimal 中，6.3 的下一个数就是 7，7 的下一个数就是 8，根据就不存在 6.4 和 7.1 之类的数。并且有以下运算例子：

• 6.3 + 0.1 = 6.3
• 6.3 + 0.3 = 7
• 7 + 0.4 = 7
• 7 + 0.6 = 8
• 63 + 1 = overflow

我们知道，1 byte 可以表示 2⁸ = 256 个不同的值。而 TinyDecimal 有 241 个不同的值，计算如下：241 = 256 - 6 * 2 - 3 ，即需要扣除 6 * 2 个重复的正负数和 3 个重复的零。

测试程序

System.Decimal 结构就是以上 TinyDecimal 结构的放大版本。为了更好地理解以上内容，我写了一个如下所测试程序：

 1 using System;
 2  
 3 static class DecimalTester
 4 {
 5   static void Main()
 6   {
 7     var epsilon = 0.0000000000000000000000000001m;
 8     var a = decimal.MaxValue / 100;
 9     var b = 7.1234567890123456789012345685m;
10     Console.WriteLine("{0}: 1e-28", epsilon);
11     Console.WriteLine("{0}: 1e-28 + 0.1", 0.1m + epsilon);
12     Console.WriteLine("{0}: a", a);
13     Console.WriteLine("{0,-30}: a + 0.004", a + 0.004m);
14     Console.WriteLine("{0,-30}: a + 0.005", a + 0.005m);
15     Console.WriteLine("{0,-30}: a + 0.01", a + 0.01m);
16     Console.WriteLine("{0,-30}: a + 0.099", a + 0.099m);
17     Console.WriteLine("{0,-30}: a + 0.1", a + 0.1m);
18     Console.WriteLine("{0,-30}: (a + 0.1) + 1e-28", a + 0.1m + epsilon);
19     Console.WriteLine("{0,-30}: a + (0.1 + 1e-28)", a + (0.1m + epsilon));
20     Console.WriteLine("{0}: b", b);
21     Console.WriteLine("{0,-30}: b + 1", b + 1);
22   }
23 }

这个程序第 7 行的 epsilon 就是引言中提到的 decimal.Epsilon，其值为 10^-28，等于 decimal 能够表示最小正数。

在 Linux 中编译和运行

在 Arch Linux 64-bit 操作系统的 Mono 3.0.4 环境下编译和运行：

work$ dmcs --version
Mono C# compiler version 3.0.4.0
work$ dmcs DecimalTester.cs
work$ mono DecimalTester.exe
0.0000000000000000000000000001: 1e-28
0.1000000000000000000000000001: 1e-28 + 0.1
792281625142643375935439503.35: a
792281625142643375935439503.35: a + 0.004
792281625142643375935439503.4 : a + 0.005
792281625142643375935439503.4 : a + 0.01
792281625142643375935439503.4 : a + 0.099
792281625142643375935439503.5 : a + 0.1
792281625142643375935439503.5 : (a + 0.1) + 1e-28
792281625142643375935439503.5 : a + (0.1 + 1e-28)
7.1234567890123456789012345685: b
8.123456789012345678901234569 : b + 1

上述运行结果各行对应如下：

1. epsilon = 10^-28 = 0.0000000000000000000000000001，这是 decimal 能够表示的最小正数。
2. epsilon + 0.1 = 10^-28 + 0.1 = 0.1000000000000000000000000001 。
3. a = decimal.Value / 100 = 79...3.35 。这个数有 29 位有效数字。
4. a + 0.004 = 79...3.354，舍入至 79...3.350，就等于 a 。
5. a + 0.005 = 79...3.355，舍入至 79...3.360，但这个数无法在 decimal 中表示，只好舍入至 79...3.400，这个数只有 28 位有效数字。
6. a + 0.01 = 79...3.36，如上所述，这个数无法在 decimal 中表示，只好舍入至 79...3.40 。
7. a + 0.099 = 79...3.449，舍入至 79...3.400 。
8. a + 0.1 = 79...3.45，舍入至 79...3.50 。
9. (a + 0.1) + 10^-28，结果和上一行相同。
10. a + (0.1 + 10^-28)，结果和上一行相同。
11. b = 7.1234567890123456789012345685 。这个数有 29 位有效数字。
12. b + 1 = 8.1...85 。但这个数无法在 decimal 中表示，只好舍入至 8.1...90 。

从上面的分析可以看出，在 Linux 的 Mono 环境中 decimal 的算术运算的舍入规则是四舍五入。

在 Windows 中编译和运行

在 Windows 7 SP1 32-bit 操作系统的 Microsoft .NET Framework 4.5 环境下编译和运行：

D:\work> csc DecimalSumTester.cs
Microsoft(R) Visual C# 编译器版本 4.0.30319.17929
用于 Microsoft(R) .NET Framework 4.5
版权所有 (C) Microsoft Corporation。保留所有权利。
D:\work> DecimalTester
0.0000000000000000000000000001: 1e-28
0.1000000000000000000000000001: 1e-28 + 0.1
792281625142643375935439503.35: a
792281625142643375935439503.35: a + 0.004
792281625142643375935439503.4 : a + 0.005
792281625142643375935439503.4 : a + 0.01
792281625142643375935439503.4 : a + 0.099
792281625142643375935439503.4 : a + 0.1
792281625142643375935439503.4 : (a + 0.1) + 1e-28
792281625142643375935439503.5 : a + (0.1 + 1e-28)
7.1234567890123456789012345685: b
8.123456789012345678901234568 : b + 1

上述运行结果各行对应如下：

1. epsilon = 10^-28 = 0.0000000000000000000000000001，这是 decimal 能够表示的最小正数。
2. epsilon + 0.1 = 10^-28 + 0.1 = 0.1000000000000000000000000001 。
3. a = decimal.Value / 100 = 79...3.35 。这个数有 29 位有效数字。
4. a + 0.004 = 79...3.354，舍入至 79...3.350，就等于 a 。
5. a + 0.005 = 79...3.355，舍入至 79...3.360，但这个数无法在 decimal 中表示，只好舍入至 79...3.400，这个数只有 28 位有效数字。
6. a + 0.01 = 79...3.36，如上所述，这个数无法在 decimal 中表示，只好舍入至 79...3.40 。
7. a + 0.099 = 79...3.449，舍入至 79...3.400 。
8. a + 0.1 = 79...3.45，舍入至 79...3.40 。
9. (a + 0.1) + 10^-28，结果和上一行相同，等于 79...3.40 。因为 10^-28 太小了，加上去也改变不了什么。
10. a + (0.1 + 10^-28) = 79...3.4500000000000000000000000001，舍入至 79...3.50...0 。和上一行对比，发现加法不满足结合律。
11. b = 7.1234567890123456789012345685 。这个数有 29 位有效数字。
12. b + 1 = 8.1...85 。但这个数无法在 decimal 中表示，只好舍入至 8.1...80 。

从上面的分析可以看出，在 Windows 的 .NET Framework 环境中 decimal 的算术运算的舍入规则是四舍六入五取偶。所以造成第 8 、9 和 12 行和 Linux 中的输出不同。

由于 decimal 的精度是有限的，只能表示有限个分散的值，在进行一些特殊的算术运算步骤时，会产生非常出乎意料的结果。且听下回分解。

参考资料

1. MSDN: Decimal 结构 (System)
2. MSDN: Decimal.GetBits 方法 (System)
3. MSDN: Decimal 构造函数 (Int32[]) (System)