create-dwy 0.12.2 → 0.13.1

package/templates/claude-global/skills//346/225/260/346/215/256/345/272/223/dwy-dolphindb/references/official/tutorials/DECIMAL.md

@@ -0,0 +1,306 @@
+---
+source_url: https://docs.dolphindb.cn/zh/tutorials/DECIMAL.html
+fetched_at: 2026-05-19T09:48:28Z
+category: tutorials
+title: DECIMAL 类型之于 DolphinDB
+sha1: 3d99ada0dfbd2dbf78d0f748383f9ad3b4ff71f3
+---
+
+# DECIMAL 类型之于 DolphinDB
+
+数字运算在数据库中是很常见的需求，例如计算数量、重量、价格等，为了满足各种需求，数据库系统通常支持精准的数据类型和近似的数据类型。在金融领域中，对数据的计算精度要求极高，为保证数据的一致性以及计算结果的精准性，DolphinDB 数据库在 v2.00.8 版本中专门引入两个新的数据类型 DECIMAL32、DECIMAL64。
+
+本文将简要介绍 DECIMAL 类型在 DolphinDB 数据库中的使用方法、计算规则，以及对比现有浮点数类型 (DOUBLE/FLOAT) 所具备的差异性。
+
+## 1. DECIMAL 在 DolphinDB 中的用法
+
+### 1.1. 语法特征
+
+与目前 DolphinDB 中现有的浮点数数据类型 FLOAT 和 DOUBLE 不同，DECIMAL 在创建时需要指定一个输入数据和一个描述精度范围的数据，分别是 X 和 scale：即 `decimal32(X, scale)` 或者`decimal64(X, scale)`。其中：
+
+- X 是整型/浮点型/字符串类型的标量或者向量；
+- scale 是一个整型标量，指 DECIMAL 所保留的小数位数，
+
+​ 例如，decimal32(3, 2) 就是将整数3转换成含有两位小数的 DECIMAL32 类型的数据。
+
+### 1.2. 数据结构及定义
+
+DolphinDB 目前支持 DECIMAL 类型的数据结构有：标量、向量、表等，本节主要介绍如何创建 DECIMAL 类型的各种数据结构。
+
+#### 1.2.1. 标量
+
+DolphinDB 中的 DECIMAL 类型的数据创建方式不同于 mysql 。在 mysql 中 DECIMAL 在创建时需要指定两个描述精度的数字，分别是 precision 和 scale，即 decimal (p, s)，p 代表整个 DECIMAL 包括整数和小数部分一共有多少位数字，s 代表 DECIMAL 的小数部分包含多少位数字。而在 DolphinDB 中定义一个 DECIMAL 类型的标量，我们只需要输入一个整型/浮点型/字符串类型的标量，并通过指定 scale，便可将其转换成DECIMAL 类型的数据，比如：
+
+```dolphindb
+a=decimal32(142, 2)
+//output：142.00
+
+b=decimal32(1.23456, 3)
+//output: 1.234
+
+c=decimal32(`1.23456, 3)
+//output: 1.234
+```
+
+#### 1.2.2. 向量
+
+在 DolphinDB 中定义一个 DECIMAL32/DECIMAL64 类型的向量，主要有以下几种方式（注意：一个DECIMAL 类型向量里的所有数据，类型和 scale 都需相同。）：
+
+用户可以使用函数 bigarray 声明一个 DECIMAL32/DECIMAL64 类型的大数组，语法如下：
+
+```dolphindb
+bigarray(DECIMAL32(scale), initialSize, [capacity], [defaultValue])
+bigarray(DECIMAL64(scale), initialSize, [capacity], [defaultValue])
+
+x=bigarray(DECIMAL32(3),0,10000000);
+x.append!(1..1000)
+//output:[1.000,2.000,3.000,4.000,5.000,6.000,7.000,8.000,9.000,10.000]
+```
+
+用户可以使用函数 array 声明一个 DECIMAL32/DECIMAL64 类型的数组，语法如下：
+
+```dolphindb
+array(DECIMAL32(scale), [initialSize], [capacity], [defaultValue])
+array(DECIMAL64(scale), [initialSize], [capacity], [defaultValue])
+
+x=array(DECIMAL32(3), 10, 10, 2.3)
+//output: [2.300,2.300,2.300,2.300,2.300,2.300,2.300,2.300,2.300,2.300]
+```
+
+或者使用以下方式进行数据类型转换：
+
+```dolphindb
+m=[decimal32(1.2356, 3), decimal32(2.59874, 3), decimal32(-5.23564, 3)]
+n=decimal32([1.2356, 2.59874, -5.23564], 3)
+```
+
+用户可以使用数组向量 arrayVector 声明一个 DECIMAL32/DECIMAL64 类型的大数组，语法如下：
+
+```dolphindb
+array(DECIMAL32(scale)[], [initialSize], [capacity], [defaultValue])
+array(DECIMAL64(scale)[], [initialSize], [capacity], [defaultValue])
+
+x = array(DECIMAL32(5)[], 0, 10)
+val1 = [1.77, 2.8, -3.77, -3.77, 77.32, 1.77]
+val2 = [1.77, 2.8, NULL, -3.77, -3.77, 77.32, 1.77, NULL]
+x.append!([val1, val2])
+//output:[[1.77000,2.80000,-3.77000,-3.77000,77.31999,1.77000],[1.77000,2.80000,,-3.77000,-3.77000,77.31999,1.77000,]]
+```
+
+#### 1.2.3. 表
+
+在 DolphinDB 中定义一个含有 DECIMAL 类型的 column，可以在建表时参考如下定义方式：
+
+```dolphindb
+t=table(100:0, `id`val1`val2, [INT, DECIMAL32(4), DECIMAL64(8)])
+```
+
+可以向该表中插入 DECIMAL 类型的数据或整型/浮点型/字符串类型的数据。例如：
+
+```dolphindb
+insert into t values(1, decimal32(2.345, 4), decimal64(2.3654, 8));
+or
+insert into t values(1, 2.345, 2.3654);
+```
+
+除了内存表支持存储 DECIMAL 类型的数据， 同样在 OLAP 和 TSDB 引擎中也支持存储 DECIMAL 类型的数据。示例如下：
+
+```dolphindb
+// 在olap引擎中：
+dbName="dfs://testDecimal_olap"
+if(existsDatabase(dbName)){
+	dropDatabase(dbName)
+}
+t=table(100:0, `id`sym`timev`val1`val2, [INT, SYMBOL, TIMESTAMP, DECIMAL32(4), DECIMAL64(8)])
+db=database(dbName, VALUE, 1..10)
+pt=db.createPartitionedTable(t, `pt, `id)
+n=1000
+data=table(rand(1..10, n) as id, rand("A"+string(1..10), n) as sym, rand(2022.11.24T12:23:45.456+1..100, n) as timev, rand(100.0, n) as val1, rand(100.0, n) as val2)
+t.append!(data)
+pt.append!(t)
+select * from loadTable(dbName, `pt)
+
+// 在tsdb引擎中：
+dbName="dfs://testDecimal_tsdb"
+if(existsDatabase(dbName)){
+	dropDatabase(dbName)
+}
+t=table(100:0, `id`sym`timev`val1`val2, [INT, SYMBOL, TIMESTAMP, DECIMAL32(4), DECIMAL64(8)])
+db=database(dbName, VALUE, 1..10, , "TSDB")
+pt=db.createPartitionedTable(t, `pt, `id, , `sym`timev)
+n=1000
+data=table(rand(1..10, n) as id, rand("A"+string(1..10), n) as sym, rand(2022.11.24T12:23:45.456+1..100, n) as timev, rand(100.0, n) as val1, rand(100.0, n) as val2)
+t.append!(data)
+pt.append!(t)
+select * from loadTable(dbName, `pt)
+```
+
+## 2. 数值范围
+
+DECIMAL32/DECIMAL64 类型的数值范围如下表所示，其中，DECIMAL32(S) 和 DECIMAL64(S) 中的 S 表示保留的小数位数。
+
+|  | **底层存储数据类型** | **字节占用** | **Scale有效范围** | **有效数值范围** | **最大表示位数** |
+| --- | --- | --- | --- | --- | --- |
+| **DECIMAL32(S)** | int32\_t | 占用4个字节 | [0, 9] | (-1 \* 10  (9 - S), 1 \* 10  (9 - S)) | 9位 |
+| **DECIMAL64(S)** | int64\_t | 占用8个字节 | [0, 18] | (-1 \* 10  (18 - S), 1 \* 10  (18 - S)) | 18位 |
+
+在将其他数值类型转换为 DECIMAL 时，DolphinDB 不会检查其数值范围是否有效，仅在将字符串解析为DECIMAL 时进行检查。由此可知，将数值型数据强制转换为 DECIMAL32，若该数值的整数部分超过 DECIMAL32 的有效数值范围，但仍属于 [-2147483648, 2147483647]（4 字节整数（INT32）的有效数值范围），仍可转换成功；而将字符串类型数据强制转换成 DECIMAL32，其长度超过有效位数时系统抛异常。例如：强制类型转换整型数据 1000000000 为 DECIMAL32 时不会报错，因为 1000000000∈[-2147483647, 2147483648]，没有 overflow。但强制类型转换字符串"1000000000"为 DECIMAL32 时，系统会抛异常，这是因为该字符串包含10位数字，而 DECIMAL32 最多表示9位数。
+
+因此，对 DECIMAL32/DECIMAL64 类型执行特定操作时，数值会溢出。为了保证数据结果的一致性和精准性，DolphinDB 会对计算结果做溢出校验。本章节将介绍 DolphinDB 系统中常见的三种溢出检查。
+
+### 2.1. 创建数据时的溢出检查
+
+在创建 DECIMAL32/DECIMAL64 类型的数据时，会首先考虑有效数值范围和 scale 的有效范围，超出限定范围，则做溢出处理。若小数位超出 DECIMAL32/DECIMAL64 的 scale 有效范围，系统将报错：“Scale is out of bounds”。例如：
+
+```dolphindb
+decimal32(1.2, 10)
+decimal64(1.2, 19)
+```
+
+同样，若整数位数超出数据类型所能表示的最大位数也会做溢出处理，系统将报错：“Decimal math overflow”。例如：
+
+```dolphindb
+decimal32(1000000000, 1)
+decimal32(`1000000000, 1)
+```
+
+### 2.2. 算术计算的溢出检查
+
+即使创建数值时其没有超出有效数值范围，但随着数据在计算过程中小数位数的增多或者数值的增大，也有可能超出有效数值范围，导致溢出。例如：
+
+```dolphindb
+6*decimal32(4.2, 8)
+6*decimal32(100000000, 1)
+```
+
+### 2.3. 比较运算中的溢出检查
+
+溢出检查不仅存在于算术运算中，也存在于比较运算中。在比较 DECIMAL 类型的数据和其他数值类型的数据时，系统会自动将其他数值类型转换成 DECIMAL 类型，再进行比较运算。
+
+注意：
+
+1. 2.00.8 版本 server 会将其它数据类型转换为对应的 DECIMAL 类型。如下例，将100与 DECIMAL32 比较，会将100转换为 decimal32(100,8)，此时会报数据溢出的错误：
+
+```dolphindb
+decimal32(1, 8) < 100
+//output: Decimal math overflow
+```
+
+1. 2.00.9 及以上版本，在进行 DECIMAL 类型与其它数据类型的比较时，系统会将所有数据类型都转换为 DECIMAL64。此时运行上例，不会出现数据溢出的报错。
+
+```dolphindb
+decimal32(1, 8) < 100
+//output: true
+```
+
+## 3. 算术运算规则
+
+### 3.1. DECIMAL 类型之间的算数规则及 scale 的规则
+
+DolphinDB 数据库规定了 DECIMAL 类型的数据之间进行算术运算的规则，规则如下:
+
+​ 规则一：`DECIMAL32(S1) <op> DECIMAL32(S2) => DECIMAL32(S)`
+
+```dolphindb
+m=decimal32(1.23, 3)+decimal32(2.45, 2)
+//output:3.680
+//typestr:DECIMAL32
+```
+
+​ 规则二：`DECIMAL64(S1) <op> DECIMAL64(S2) => DECIMAL64(S)`
+
+```dolphindb
+m=decimal64(1.23, 3)+decimal64(2.45, 2)
+//output:3.680
+//typestr:DECIMAL64
+```
+
+​ 规则三：`DECIMAL64(S1) <op> DECIMAL32(S2) => DECIMAL64(S)`
+
+```dolphindb
+m=decimal64(1.23, 3)+decimal32(2.45, 2)
+//output:3.680
+//typestr:DECIMAL64
+```
+
+​ 规则四：`DECIMAL32(S1) <op> DECIMAL64(S2) => DECIMAL64(S)`
+
+```dolphindb
+m=decimal32(1.23, 3)+decimal64(2.45, 2)
+//output:3.680
+//typestr:DECIMAL64
+```
+
+DolphinDB 数据库中 DECIMAL 类型的数据算术运算结果的 `scale` 由以下规则来确定:
+
+- 对于加法和减法: `S = max(S1, S2)`
+- 对于乘法: `S = S1 + S2`
+
+```dolphindb
+m=decimal64(1.23, 3)*decimal32(2.45, 2)
+//output:3.01350
+//typestr:DECIMAL64
+```
+
+- 对于除法: `S = S1`
+
+```dolphindb
+m=decimal64(1.23, 3)/decimal32(2.45, 2)
+//output:0.502
+//typestr:DECIMAL64
+```
+
+### 3.2. DECIMAL 类型与整型进行计算
+
+在 DolphinDB 数据库中，DECIMAL 类型与整型 (INT/LONG) 进行运算时，会将整型转换成相同类型的 DECIMAL 再进行运算。计算 `decimal32(10, 2)*6`，相当于 `decimal32(10, 2)*decimal32(6, 0)`。因此，整数型数值乘以 scale 为 `S` 的DECIMAL类型的数据，结果的 scale 仍然为 `S`。
+
+### 3.3. DECIMAL 类型与浮点数进行计算
+
+在 DolphinDB 数据库中，DECIMAL 类型与浮点数之间的算术运算是未定义的，但是系统不会抛出异常， 如果确实需要这么做，建议先将浮点数强制转换成 DECIMAL 类型的数据。
+
+## 4. 导入数据成 DECIMAL 类型
+
+通过以下步骤，可以将导入数据转换成 DECIMAL 类型：
+
+​ 1. 使用 saveText 函数获得一个 *test\_decimal.csv* 文件。
+
+```dolphindb
+WORK_DIR="/hdd/hdd1/test_decimal/"
+n=1000
+t=table(rand(1..100, n) as id, rand(2022.11.23T12:39:56+1..100, n) as datetimev, rand(`AAPL`ARS`BSA, n) as sym, rand(rand(100.0, 10) join take(00f, 10), n) as val1, rand(rand(100.0, 10) join take(00f, 10), n) as val2)
+saveText(t, WORK_DIR+"test_decimal.csv")
+```
+
+​ 2. 使用 loadText 函数将 *test\_decimal.csv* 中的部分列转换为 DECIMAL 类型。
+
+```dolphindb
+shemaTable=table(`id`timev`sym`val1`val2 as name, [`INT, `DATETIME, `SYMBOL, "DECIMAL32(4)", "DECIMAL64(5)"] as type)
+re=loadText(filePath, , shemaTable)
+```
+
+## 5. 对比 DECIMAL32/DECIMAL64 和 DOUBLE/FLOAT
+
+### 5.1. 指定小数位数
+
+将无限多的实数压缩成有限的位数需要近似表示。尽管整数有无穷多个，但在大多数程序中，整数计算的结果可以用 32 位存储。相反，给定任何固定位数，大多数实数计算将产生无法使用那么多位数精确表示的量。因此，浮点计算的结果通常必须四舍五入以适应其有限表示。
+
+DOUBLE 和 FLOAT 类型精度遵循 IEEE 754 标准，在表示有限的小数位数时，对数据进行四舍五入，如： 将 1.2356789 的小数位数缩减为三位，输出结果为：1.236。而 DECIMAL32/DECIMAL64 类型精度遵循 IEEE 754-2008 标准，在表示有限的小数位数时，将1.2356789 的小数位数缩减为三位，输出结果为：1.235。
+
+### 5.2. 精度差异
+
+目前有很多种实数的表示方法， 其中最为广泛使用的是浮点数表示法（IEEE floating-point representation）。浮点数表示法有一个基数 β（通常假定为偶数）和一个精度 p，如果 β=10 且 p=3，则数字 0.1 被表示为 1.00 × 10 -1；如果 β=2 且 p=24，无法精确表示十进制数 0.1，近似为 1.10011001100110011001101 × 2 -4。
+
+实数无法精确地表示为浮点数的原因主要有两个。第一个原因是类似于 0.1 这样的数字，具有有限的十进制表示，但是在二进制中能表示为无穷重复的数据，等于 0.1 的近似值，无法得精确数据。第二个原因是超出数据的数值范围，系统将对数据做一定处理。
+
+数据类型 FLOAT/DOUBLE 属于 binary floating-point types，DOUBLE 型数据在运算时会先将数值转换成二进制的数值表示再做运算，但转换成二进制时，只能表示为无限循环小数，存在一定误差。而当数据超出 FLOAT 和 DOUBLE 的数值范围，在 DolphinDB 系统将结果置为 NULL，保证数据在溢出时可以继续计算。如 0/0 的结果为 NULL。而 DECIMAL 类型属于 decimal floating-point types，0.1 被表示为 1.00 × 10 -1，无精度缺失，且在数据溢出时，直接报 overflow 的错误，避免了数据超出数值范围时，结果精度的缺失。
+
+### 5.3. 局限性
+
+在 DolphinDB 中，DECIMAL 类型与 FLOAT/DOUBLE 类型相比，目前所支持的功能和结构较少。
+
+- 在功能方面，目前暂未支持流数据。
+- 在函数支持方面，尚有少部分计算函数不支持 DECIMAL 类型。
+- 数据结构方面，DolphinDB 系统目前暂未支持 DECIMAL 类型在 matrix 和 set 中使用。
+- 数据类型转换方面，DolphinDB 系统暂不支持 BOOL/CHAR/SYMBOL/UUID/IPADDR/INT128 等类型和 temporal 集合下的时间相关类型与 DECIMAL 类型相互转换，其中 STRING/BLOB 类型的数据如需转换成 DECIMAL 类型，必须满足 STRING/BLOB 类型的数据可以转换成数值类型的前提。
+
+综上所述，在选择一个合适的数据类型处理浮点数时，需要综合考虑类型的数值范围以及数据对精确度的要求等。

package/templates/claude-global/skills//346/225/260/346/215/256/345/272/223/dwy-dolphindb/references/official/tutorials/DECIMAL_Calculation_Characteristics.md

@@ -0,0 +1,327 @@
+---
+source_url: https://docs.dolphindb.cn/zh/tutorials/DECIMAL_Calculation_Characteristics.html
+fetched_at: 2026-05-19T09:48:29Z
+category: tutorials
+title: 计算精度问题与 DECIMAL 类型
+sha1: 2205e203a3fc9cf2dd731b33f577793c2671c9aa
+---
+
+# 计算精度问题与 DECIMAL 类型
+
+## 1. DECIMAL 的计算特性
+
+### 1.1. DECIMAL 的计算方式
+
+DECIMAL 的存储分为两部分，即存储整型数据的 raw data 和存储小数位数的 scale。例如，对于DECIMAL32(2) 类型的 1.23, 它存储了两个数据：(1) raw data：即整型 123，(2) scale：即 2。这样存储的好处是，在计算时可以直接使用整型的 raw data 进行计算，从而避免精度损失。
+
+对于大多数计算函数，如果最后返回的结果是浮点数类型，DECIMAL 在进行计算时， 会使用 raw data 参与计算，尽量延迟转换成浮点数的时机，从而确保得到精确结果。比如计算 avg 时，假设数据为 DECIMAL32(2) 类型：[1.11, 2.22, 3.33]，其 raw data 为：[111, 222, 333]。在计算时，先算出 raw data 的 sum：111 + 222 + 333 = 666，然后转换成浮点数：double(666) / 10^2 / 3 = 2.22。
+
+对于DECIMAL算术运算的规则，可参照：[DECIMAL.md](DECIMAL.html#%E7%AE%97%E6%9C%AF%E8%AE%A1%E7%AE%97%E7%9A%84%E6%BA%A2%E5%87%BA%E6%A3%80%E6%9F%A5)。
+
+### 1.2. DECIMAL 的计算输出
+
+本节主要讲述DECIMAL作为计算函数输入的输出结果。
+
+在 DolphinDB 计算函数中，以 DECIMAL 类型作为输入，输出结果仍为 DECIMAL 类型的函数较少，仅有：`sum`、`max`、`min`、`first`、`last`、`firstNot`、`lastNot` 及其 cum、m、tm、TopN 系列函数，如 `cummax`、`mmin`、`tmsum`、`msumTopN`，`cumsumTopN`，`tmsumTopN` 等；以及 `cumPositiveStreak`。
+
+```dolphindb
+a = decimal64(rand(10,100),4)
+
+typestr(sum(a))
+>> DECIMAL128
+
+typestr(cummax(a))
+>> FAST DECIMAL64 VECTOR
+
+typestr(mmin(a,5))
+>> FAST DECIMAL64 VECTOR
+
+T = 2023.03.23..2023.06.30
+typestr(tmsum(T, a, 3))
+>> FAST DECIMAL128 VECTOR
+
+typestr(cumPositiveStreak(a))
+>> FAST DECIMAL128 VECTOR
+```
+
+需要注意的是，在引入 DECIMAL128 类型后，自 2.00.10 版本起，sum 系列函数和 `cumPositiveStreak` 的输入输出类型对应规则如下：
+
+| **计算函数** | **输入类型** | **输出类型** |
+| --- | --- | --- |
+| sum/cumsum/msum/tmsum/msumTopN/cumsumTopN/tmsumTopN/cumPositiveStreak | DECIMAL32 | DECIMAL64 |
+|  | DECIMAL64 | DECIMAL128 |
+|  | DECIMAL128 | DECIMAL128 |
+
+除了上述函数外，cum、m、tm、TopN 系列的函数，包括它们对应的原始的函数，比如 `avg`、`std`、`var`、`skew` 等，以 DECIMAL 类型作为输入，都将返回 DOUBLE 类型的输出结果。
+
+```dolphindb
+a = decimal64(rand(10,100),4)
+
+typestr(avg(a))
+>> DOUBLE
+
+typestr(cumstd(a))
+>> FAST DOUBLE VECTOR
+
+typestr(mvar(a,5))
+>> FAST DOUBLE VECTOR
+
+T = 2023.03.23..2023.06.30
+typestr(tmskew(T, a, 3))
+>> FAST DOUBLE VECTOR
+```
+
+下面将以 DECIMAL64 作为输入为例，列出常见计算函数的输出结果类型。
+
+| **计算函数** | **输入类型** | **输出类型** |
+| --- | --- | --- |
+| sum/cumsum/msum/tmsum | DECIMAL64 | DECIMAL128 |
+| msumTopN/cumsumTopN/tmsumTopN | DECIMAL64 | DECIMAL128 |
+| max/cummax/mmax/tmmax | DECIMAL64 | DECIMAL64 |
+| min/cummin/mmin/tmmin | DECIMAL64 | DECIMAL64 |
+| first/mfirst/tmfirst | DECIMAL64 | DECIMAL64 |
+| last/mlast/tmlast | DECIMAL64 | DECIMAL64 |
+| firstNot/cumfirstNot | DECIMAL64 | DECIMAL64 |
+| lastNot/cumlastNot | DECIMAL64 | DECIMAL64 |
+| cumPositiveStreak | DECIMAL64 | DECIMAL128 |
+| avg/cumavg/mavg/tmavg/mavgTopN/cumavgTopN/tmavgTopN | DECIMAL64 | DOUBLE |
+| sum2/cumsum2/msum2/tmsum2 | DECIMAL64 | DOUBLE |
+| prod/cumprod/mprod/tmprod | DECIMAL64 | DOUBLE |
+| med/cummed/mmed/tmmed | DECIMAL64 | DOUBLE |
+| std/cumstd/mstd/tmstd/mstdTopN/cumstdTopN/tmstdTopN | DECIMAL64 | DOUBLE |
+| skew/mskew/tmskew/mskewTopN/cumskewTopN/tmskewTopN | DECIMAL64 | DOUBLE |
+| kurtosis/mkurtosis/tmkurtosis/mkurtosisTopN/cumkurtosisTopN/tmkurtosisTopN | DECIMAL64 | DOUBLE |
+| corr/cumcorr/mcorr/tmcorr/mcorrTopN/cumcorrTopN/tmcorrTopN | DECIMAL64 | DOUBLE |
+| covar/cumcovar/mcovar/tmcovar/mcovarTopN/cumcovarTopN/tmcovarTopN | DECIMAL64 | DOUBLE |
+| beta/cumbeta/mbeta/tmbeta/mbetaTopN/cumbetaTopN/tmbetaTopN | DECIMAL64 | DOUBLE |
+
+## 2. DECIMAL 的优缺点
+
+### 2.1. DECIMAL 的优点
+
+实数在计算机内部无法被精确地表示为浮点数的原因主要有两个：第一个原因是类似于 0.1 这样的数字，具有有限的十进制表示，但是在二进制中能表示为无穷重复的数据，等于 0.1 的近似值，无法被精确表示；第二个原因是数值超出了数据类型能表示的数值范围，系统将对数据做一定处理。与浮点数相比，DECIMAL 类型最大的优点，就在于它能够精确地表示和计算数据。
+
+例如，在表示123.0001时：
+
+```dolphindb
+a =123.0001
+print(a)
+>> 123.000100000000003
+
+b = decimal64(`123.0001,15)
+print(b)
+>> 123.000100000000000
+```
+
+可见，浮点数无法精确表示123.0001，而 DECIMAL 可以。
+
+在计算 avg 时：
+
+```dolphindb
+a = array(DOUBLE,0)
+for (i in 1..100){
+	a.append!(123.0000+0.0003*i)
+}
+avg(a)
+>> 123.015149999999
+avg(a) == 123.01515
+>> false
+eqFloat(avg(a),123.01515)
+>> true
+
+b= array(DECIMAL64(4),0)
+for (i in 1..100){
+	b.append!(123.0000+0.0003*i)
+}
+avg(b)
+>> 123.015150000000
+typestr(avg(b))
+>> DOUBLE
+avg(b) == 123.01515
+>> true
+```
+
+可见，在进行 avg 计算时，浮点数没有返回精确结果，而 DECIMAL 虽然返回结果也是 DOUBLE 类型，但返回了精确结果。
+
+### 2.2. DECIMAL 的缺点
+
+#### 2.2.1. 容易溢出
+
+DECIMAL32/DECIMAL64/DECIMAL128 类型的数值范围如下表所示，其中，DECIMAL32(S)、DECIMAL64(S) 和 DECIMAL128(S) 中的 S 表示保留的小数位数。
+
+|  | **底层存储数据类型** | **字节占用** | **Scale有效范围** | **有效数值范围** | **最大表示位数** |
+| --- | --- | --- | --- | --- | --- |
+| DECIMAL32 | int32\_t | 占用4个字节 | [0,9] | (-1 \* 10(9 - S), 1 \* 10(9 - S))) | 9位 |
+| DECIMAL64 | int64\_t | 占用8个字节 | [0,18] | (-1 \* 10  (18 - S), 1 \* 10  (18 - S)) | 18位 |
+| DECIMAL128 | int128\_t | 占用16个字节 | [0,38] | (-1 \* 10  (38 - S), 1 \* 10  (38 - S)) | 38位 |
+
+在有效数值范围和最大表示位数的限制下，DECIMAL 类型很容易溢出。自 2.00.10 版本起，我们支持算术运算溢出后，若存在更高精度的类型，则将自动拓展结果的数据类型，从而降低溢出风险：
+
+```dolphindb
+version 2.00.9.6：
+
+a = decimal32(4.0000,4)
+b = decimal32(8.0000,4)
+c = a*b
+>> Server response: 'c = a * b => Decimal math overflow'
+
+version 2.00.10：
+a = decimal32(4.0000,4)
+b = decimal32(8.0000,4)
+c = a*b
+print(c)
+>> 32.00000000
+typestr(c)
+>> DECIMAL64
+```
+
+但即使如此，DECIMAL128 仍存在溢出风险：
+
+```dolphindb
+a = decimal128(36.00000000,8)
+b = a*a*a*a
+>> Server response: 'b = a * a * a * a => Decimal math overflow'
+```
+
+如上所示，由于 DolphinDB 中 DECIMAL 类型的数据乘法运算结果的 scale 是逐个累加的，b 的预期结果将会是 1679616.00000000000000000000000000000000，将会有39位数字，超出了 DECIMAL128 的最大表示位数38位，导致了溢出。
+
+2.00.10版本新增支持了 DECIMAL 类型的乘法函数 `decimalMultiply`，与 `multiply` 函数 (`*` 运算符) 相比，该函数可以指定计算结果的精度。当 DEICMAL 类型的乘法运算导致 scale 累加存在溢出风险时，可以按需使用 `decimalMultiply` 函数，指定计算结果精度。
+
+```dolphindb
+a = decimal64(36.00000000,8)
+decimalMultiply(a, a, 8)
+>> 1296.00000000
+```
+
+#### 2.2.2. 转换误差
+
+当我们直接使用常量生成 DECIMAL 类型时，可能会因为浮点数的转换产生误差：
+
+```dolphindb
+a = 0.5599
+decimal64(a,4)
+>> 0.5598
+```
+
+为了避免这种误差，可以使用字符串来生成 DECIMAL：
+
+```dolphindb
+a = "0.5599"
+decimal64(a,4)
+>> 0.5599
+```
+
+#### 2.2.3. 内存占用
+
+DECIMAL32、DECIMAL64 和 DECIMAL128 类型在内存中分别占用4个字节、8个字节和16个字节，而 FLOAT 和 DOUBLE 类型在内存中占用4个字节和8个字节。因此，在数据量相同的情况下，DECIMAL128 占用的内存是 DOUBLE 的两倍。
+
+且由于算术运算溢出后，将自动拓展结果的数据类型，每次拓展后等量数据占用的内存将翻倍，存在一定的内存风险。
+
+#### 2.2.4. 性能差异
+
+与 FLOAT 和 DOUBLE 类型相比，DECIMAL 类型的计算速度更慢，我们将在第三节中进行详细比较。
+
+#### 2.2.5. 局限性
+
+在 DolphinDB 中，DECIMAL 类型与 FLOAT/DOUBLE 类型相比，目前所支持的功能和结构较少。
+
+- 在函数支持方面，尚有少部分计算函数不支持 DECIMAL 类型。
+- 计算结果方面，cum, tm, m, TopN 系列的函数，包括它们对应的原始的函数（`sum`、`max`、`min`、`firstNot`、`lastNot`、`cumPositiveStreak` 除外），即使原始数据是 DECIMAL 类型，返回结果还是浮点数类型。
+- 数据结构方面，DolphinDB 系统目前暂未支持 DECIMAL 类型在 matrix 和 set 中使用。
+- 数据类型转换方面，DolphinDB 系统暂不支持 BOOL/CHAR/SYMBOL/UUID/IPADDR/INT128 等类型和 temporal 集合下的时间相关类型与 DECIMAL 类型相互转换，其中 STRING/BLOB 类型的数据如需转换成 DECIMAL 类型，必须满足 STRING/BLOB 类型的数据可以转换成数值类型的前提。
+
+## 3. 浮点数与 DECIMAL 计算性能差异比较
+
+为了比较浮点数类型与 DECIMAL 类型的计算性能差异，我们选取了一些常用的计算函数，比较相同数据情况下，各个数据类型的计算耗时。
+
+首先，模拟数据脚本如下：
+
+```dolphindb
+n = 1000000
+data1 = rand(float(100.0),n)
+data2 = double(data1)
+data3 = decimal32(data1,4)
+data4 = decimal64(data1,4)
+data5 = decimal128(data1,4)
+```
+
+随后，使用 `timer` 语句统计常用计算函数对于各个类型数据的计算耗时：
+
+```dolphindb
+timer(100){sum(data1)}  //执行100次，避免单次计算误差，并放大不同类型间的耗时差异
+timer(100){sum(data2)}
+timer(100){sum(data3)}
+timer(100){sum(data4)}
+timer(100){sum(data5)}
+... ...
+```
+
+得到的计算耗时统计结果如下（单位：ms）：
+
+|  | **FLOAT** | **DOUBLE** | **DECIMAL32** | **DECIMAL64** | **DECIMAL128** |
+| --- | --- | --- | --- | --- | --- |
+| **sum** | 52.985 | 64.331 | 28.721 | 57.234 | 107.126 |
+| **sum2** | 173.278 | 211.772 | 176.261 | 180.051 | 603.422 |
+| **prod** | 63.650 | 55.641 | 171.718 | 174.389 | 18850.009 |
+| **avg** | 178.086 | 210.495 | 26.094 | 106.869 | 258.508 |
+| **std** | 362.388 | 345.758 | 278.933 | 319.177 | 968.276 |
+| **kurtosis** | 547.751 | 407.561 | 585.859 | 769.879 | 1013.591 |
+| **skew** | 546.705 | 439.348 | 622.758 | 842.994 | 1074.128 |
+
+根据上述统计结果，可以得知：
+
+（1）对于大部分计算函数，DECIMAL 的性能都比 FLOAT/DOUBLE 差；
+
+（2）DECIMAL128 在计算时，会转换成 LONG DOUBLE（DECIMAL32/DECIMAL64 会转换成 DOUBLE），而 LONG DOUBLE 的实现取决于编译器和 CPU，可能是 12 字节或者 16 字节，LONG DOUBLE 的乘法在数据很大时非常耗时。在本节的测试样例中，vector 里的元素的取值范围较大，所以其乘积非常大，计算非常耗时。而如果把取值范围取小一些，比如 [0.5, 1.0]，则 DECIMAL128 的计算和 DECIMAL32/DECIMAL64 相差不大；
+
+（3）对于 `sum`、`avg`、`std` 这样的函数，DECIMAL 类型在计算时都没有做循环展开，而浮点数类型对 `sum` 做了循环展开，`avg` 则没有。此外，由于 DECIMAL 计算时会使用 raw data 先参与计算，再直接返回 DECIMAL 类型或转化为浮点数，本质是整型计算，实际过程比浮点数运算更高效。因此，它们的性能相差不大，甚至 DECIMAL32/DECIMAL64 的性能比 FLOAT/DOUBLE 更好。
+
+## 4. DECIMAL 最佳实践：避免 mavg 计算精度损失
+
+本节将以具体场景，比较 DECIMAL 类型和浮点数类型在实际计算中的精度差异。
+
+`mavg` 和 `moving(avg,…)` 虽然在含义上完全相同，但两者的实现方式并不一致。`mavg` 的算法是：随着窗口的移动，总和加上进入窗口的数，减去离开窗口的数，再计算 avg，所以在这个加减的过程中，会产生浮点数精度问题。
+
+首先，我们导入样例数据 [tick.csv](https://cdn.dolphindb.cn/zh/tutorials/data/DECIMAL_Calculation_Characteristics/tick.csv)，原始数据类型均为 DOUBLE 类型，并计算 `mavg`、`moving(avg,…)`：
+
+```dolphindb
+data = loadText("<yourDirectory>/tick.csv")
+
+t = select
+	MDTime,
+	((LastPx - prev(LastPx)) / (prev(LastPx) + 1E-10) * 1000) as val,
+	mavg(((LastPx - prev(LastPx)) / (prev(LastPx) + 1E-10) * 1000), 20, 1),
+	moving(avg, ((LastPx - prev(LastPx)) / (prev(LastPx) + 1E-10) * 1000), 20, 1)
+from data
+```
+
+得到的结果如下图所示：
+
+![](images/DECIMAL_Calculation_Characteristics/4_1.png)  
+
+可以看到，计算结果从09:31:53.000开始产生误差。
+
+为了避免这种计算误差，我们先将中间计算结果转换为 DECIMAL128 类型，再计算 `mavg` 和 `moving(avg,…)`：
+
+```dolphindb
+t = select
+	MDTime,
+	((LastPx - prev(LastPx)) / (prev(LastPx) + 1E-10) * 1000) as val,
+	mavg(decimal128(((LastPx - prev(LastPx)) / (prev(LastPx) + 1E-10) * 1000),12), 20, 1),
+	moving(avg, decimal128(((LastPx - prev(LastPx)) / (prev(LastPx) + 1E-10) * 1000),12), 20, 1)
+from data
+```
+
+得到的结果如下图所示：
+
+![](images/DECIMAL_Calculation_Characteristics/4_2.png)  
+
+可以看到，`mavg` 和 `moving(avg,…)` 的计算结果完全一致。
+
+由于浮点数的精度问题，cum, tm, m, TopN 系列的函数，包括它们对应的原始的函数，比如 `avg`、`std` 等，都有可能导致计算的精度误差。在对精度极为关注的场景下，我们推荐使用 DECIMAL 进行计算。需要注意的是，除了 `sum`、`max`、`min`、`firstNot`、`lastNot`、`cumPositiveStreak` 及其对应的系列函数，在入参是 DECIMAL 类型时能够返回 DECIMAL 类型的计算结果，其他函数都将返回浮点数类型。虽然存在一定的 DECIMAL 类型转换为浮点数类型的精度误差风险，但避免了计算过程中的精度损失，也可以对计算结果使用 `round` 函数或再次转换为 DECIMAL 类型，得到相对精确的结果。
+
+## 5. 总结
+
+浮点数由于其实现方式，在计算机内部无法精确地表示某些数值，因而容易出现精度误差，导致存储或计算结果与预期不符。DECIMAL 可以精确表示数值，但存在容易溢出、内存占用大、性能较劣、有一定局限性等缺点。尽管如此，在某些场景中，选用 DECIMAL 类型依旧能够很好地避免存储或计算结果与预期不符的情况出现。
+
+综上所述，在实际应用时，需要考虑具体需要，选用合适的数据类型，对数据进行相应的精度管理。