浅谈 System.Decimal 结构
引言
我们知道,Microsoft .NET Framework 中的 System.Decimal 结构(在 C# 语言中等价于 decimal keyword)用来表示十进制数,范围从 -(296 - 1) 到 296 - 1,而且能够有 28 位小数。
这就是说:
- decimal.MinValue = -79,228,162,514,264,337,593,543,950,335 = -(296 - 1)
- decimal.MaxValue = 79,228,162,514,264,337,593,543,950,335 = 296 - 1
- decimal.Epsilon = 0.0000000000000000000000000001 = 10-28
上面前两个是 decimal 的静态仅仅读字段。
遗憾的是。第三个不属于 decimal 结构。
decimal 内部使用 4 个 32-bit 的 System.Int32 来存储。占用 128 bits = 16 bytes。
这 128 bits 分配例如以下:
- 96 bits 表示从 0 至 296 - 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 至 26 - 1 的整数,共同拥有 64 个。
- exp: 第 6 bit 表示比例因子,包括一个 0 至 1 之间的指数,指示 10 的幂,即小数点的位置。0 表示小数点在最右边。
- sign: 第 7 bit 是符号位,0 表示正数,1 表示负数。
因此:
- TinyDecimal.MinValue = -63 = -(26 - 1)
- TinyDecimal.MaxValue = 63 = 26 - 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 能够表示 28 = 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
上述执行结果各行相应例如以下:
- epsilon = 10-28 = 0.0000000000000000000000000001,这是 decimal 可以表示的最小正数。
- epsilon + 0.1 = 10-28 + 0.1 = 0.1000000000000000000000000001 。
- a = decimal.Value / 100 = 79...3.35 。这个数有 29 位有效数字。
- a + 0.004 = 79...3.354。舍入至 79...3.350。就等于 a 。
- a + 0.005 = 79...3.355。舍入至 79...3.360,但这个数无法在 decimal 中表示,仅仅好舍入至 79...3.400,这个数仅仅有 28 位有效数字。
- a + 0.01 = 79...3.36。如上所述。这个数无法在 decimal 中表示,仅仅好舍入至 79...3.40 。
- a + 0.099 = 79...3.449。舍入至 79...3.400 。
- a + 0.1 = 79...3.45,舍入至 79...3.50 。
- (a + 0.1) + 10-28,结果和上一行同样。
- a + (0.1 + 10-28)。结果和上一行同样。
- b = 7.1234567890123456789012345685 。这个数有 29 位有效数字。
- 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
上述执行结果各行相应例如以下:
- epsilon = 10-28 = 0.0000000000000000000000000001。这是 decimal 可以表示的最小正数。
- epsilon + 0.1 = 10-28 + 0.1 = 0.1000000000000000000000000001 。
- a = decimal.Value / 100 = 79...3.35 。
这个数有 29 位有效数字。
- a + 0.004 = 79...3.354。舍入至 79...3.350,就等于 a 。
- a + 0.005 = 79...3.355,舍入至 79...3.360。但这个数无法在 decimal 中表示。仅仅好舍入至 79...3.400,这个数仅仅有 28 位有效数字。
- a + 0.01 = 79...3.36,如上所述。这个数无法在 decimal 中表示。仅仅好舍入至 79...3.40 。
- a + 0.099 = 79...3.449,舍入至 79...3.400 。
- a + 0.1 = 79...3.45。舍入至 79...3.40 。
- (a + 0.1) + 10-28,结果和上一行同样。等于 79...3.40 。由于 10-28 太小了。加上去也改变不了什么。
- a + (0.1 + 10-28) = 79...3.4500000000000000000000000001,舍入至 79...3.50...0 。和上一行对照,发现加法不满足结合律。
- b = 7.1234567890123456789012345685 。这个数有 29 位有效数字。
- b + 1 = 8.1...85 。但这个数无法在 decimal 中表示,仅仅好舍入至 8.1...80 。
从上面的分析能够看出,在 Windows 的 .NET Framework 环境中 decimal 的算术运算的舍入规则是四舍六入五取偶。
所以造成第 8 、9 和 12 行和 Linux 中的输出不同。
因为 decimal 的精度是有限的,仅仅能表示有限个分散的值。在进行一些特殊的算术运算步骤时,会产生很出乎意料的结果。
且听下回分解。
posted on 2017-07-31 16:01 yjbjingcha 阅读(1426) 评论(0) 编辑 收藏 举报