playbook/skills/tsl-api-reference/references/codegen/builtin/math/numeric.md

# Builtin - 数学 / 数值计算

## `odd(x)`

判断X是否是奇数，如果是，返回真，否则返回假

| 参数 | 类型    | 说明                           |
| ---- | ------- | ------------------------------ |
| `x`  | integer | 整数，如果是实数，先取整数部分 |

返回：bool

### 示例

```tsl
// 判断1是否是奇数
return odd (1);
// 结果：1
```

## `ldexp(x, p)`

返回X\*（2p）

| 参数 | 类型    | 说明           |
| ---- | ------- | -------------- |
| `x`  | real    | 实数，作底     |
| `p`  | integer | 整数，作为指数 |

返回：real

### 示例

```tsl
return ldexp(3, 2);
// 结果：12  //返回3*2^2
```

## `_not(x)`

非，返回位运算Not X，把二进制x全部取反,即非0为1,非1为0。

| 参数 | 类型    | 说明 |
| ---- | ------- | ---- |
| `x`  | integer | 整数 |

返回：integer

### 示例

```tsl
return _not (4);
// 结果：-5
// 返回十进制_not (4=00000100) 取非运算最后得到二进制11111011，十进制//是-5,注意：在计算机中,负数以其正值的补码形式表示。补码是烦吗+1，
// 5=00000101，得到反码11111010，得到补码11111011=-5
```

## `sin(x)`

正弦函数

| 参数 | 类型 | 说明        |
| ---- | ---- | ----------- |
| `x`  | real | 弧度值,实数 |

返回：real

### 示例

```tsl
// 求sin(π/6)
return sin(pi()/6);
// 结果：0.5
```

## `cos(x)`

余弦函数

| 参数 | 类型 | 说明         |
| ---- | ---- | ------------ |
| `x`  | real | 弧度值, 实数 |

返回：real

### 示例

```tsl
// 求cos(π/3)
return cos(pi()/3);
// 结果：0.5
```

## `sinCos(x, sin, cos)`

计算X的正弦和余弦值，分别返回到参数Sin和Cos中

| 参数  | 类型 | 说明                     |
| ----- | ---- | ------------------------ |
| `x`   | real | 弧度值, 实数             |
| `sin` |      | 正弦计算结果存放于该参数 |
| `cos` | real | 余弦计算结果存放于该参数 |

返回：integer

### 示例

```tsl
sinCos(pi()/2, sin, cos);
return array(sin, cos);
// 输出：
// array(1.0,6.12323399573677E-17)
```

## `tan(x)`

正切函数

| 参数 | 类型 | 说明                                  |
| ---- | ---- | ------------------------------------- |
| `x`  | real | 弧度值，实数，X≠n\*π+π/2，（n是整数） |

返回：real

### 示例

```tsl
// 求tan(π/4)
return tan (pi()/4);
// 结果：1
```

## `cot(x)`

余切函数，也就是返回1/Tan(X)的值

| 参数 | 类型 | 说明                              |
| ---- | ---- | --------------------------------- |
| `x`  | real | 弧度值，实数，X≠n\*π，（n是整数） |

返回：real

### 示例

```tsl
// 求Cot (π/4)
return cot(pi()/4);
// 结果：1
```

## `coTan(x)`

余切函数，也就是返回1/Tan(X)的值

| 参数 | 类型 | 说明                              |
| ---- | ---- | --------------------------------- |
| `x`  | real | 弧度值，实数，X≠n\*π，（n是整数） |

返回：real

### 示例

```tsl
// 求Cotan(π/4)
return coTan(pi()/4);
// 结果：1
```

## `sec(x)`

正割函数，返回参数X的正割值，也就是返回1/Cos(X)的值

| 参数 | 类型 | 说明         |
| ---- | ---- | ------------ |
| `x`  | real | 弧度值，实数 |

返回：real

### 示例

```tsl
// 求Sec(π/3)
return sec(pi()/3);
// 结果：2
```

## `csc(x)`

余割函数，返回参数X的余割值，也就是返回1/Sin(X)的值

| 参数 | 类型 | 说明         |
| ---- | ---- | ------------ |
| `x`  | real | 弧度值，实数 |

返回：real

### 示例

```tsl
// 求Csc(π/6)
return csc(pi()/6);
// 结果：2
```

## `secant(x)`

正割函数，返回参数X的正割值，也就是返回1/Cos(X)的值

| 参数 | 类型 | 说明         |
| ---- | ---- | ------------ |
| `x`  | real | 弧度值，实数 |

返回：real

### 示例

```tsl
// 求Secant (π/6)
return secant(pi()/3);
// 结果：2
```

## `cosecant(x)`

余割函数，返回参数X的余割值，也就是返回1/Sin(X)的值

| 参数 | 类型 | 说明         |
| ---- | ---- | ------------ |
| `x`  | real | 弧度值，实数 |

返回：real

### 示例

```tsl
// 求Cosecant (π/6)
return cosecant (pi()/6);
// 结果：2
```

## `arcSin(x)`

反正弦函数，返回弧度值（介于-π/2和π/2之间）

| 参数 | 类型 | 说明                                 |
| ---- | ---- | ------------------------------------ |
| `x`  | real | Sin函数值，实数，定义域范围是[-1，1] |

返回：real

### 示例

```tsl
return arcSin(1);
// 结果：1.57   //约等于π/2
```

## `arcCos(x)`

反余弦函数，返回弧度值（介于0和π之间）

| 参数 | 类型 | 说明                                 |
| ---- | ---- | ------------------------------------ |
| `x`  | real | Cos函数值，实数，定义域范围是[-1，1] |

返回：real

### 示例

```tsl
return arcCos(0);
// 结果：1.57   //约等于π/2
```

## `arcTan(x)`

反正切函数，返回值域是[-π，π]

| 参数 | 类型 | 说明            |
| ---- | ---- | --------------- |
| `x`  | real | Tan函数值，实数 |

返回：real

### 示例

```tsl
// 求ArcTan(1)
return arcTan (1);
// 结果：0.785398163397448 //该值=pi()/4
```

## `arcTan2(x, y)`

反正切函数，求正切值等于Y/X的弧度值，[-π，π]

| 参数 | 类型 | 说明         |
| ---- | ---- | ------------ |
| `x`  | real | 对边长，实数 |
| `y`  | real | 侧边长，实数 |

返回：real

### 示例

```tsl
return arcTan2(1, 2);
// 结果：0.46
```

## `arcCot(x)`

反余切函数，计算参数X的反余切值

| 参数 | 类型 | 说明             |
| ---- | ---- | ---------------- |
| `x`  | real | 余切函数值，实数 |

返回：real

### 示例

```tsl
return arcCot(1);
// 结果：0.7854
```

## `arcSec(x)`

反正割函数

| 参数 | 类型 | 说明             |
| ---- | ---- | ---------------- |
| `x`  | real | 正割函数值，实数 |

返回：real

### 示例

```tsl
// 求ArcSec(2)
return arcSec(2);
// 结果：1.05
```

## `arcCsc(x)`

反余割函数

| 参数 | 类型 | 说明             |
| ---- | ---- | ---------------- |
| `x`  | real | 余割函数值，实数 |

返回：real

### 示例

```tsl
// 求ArcCsc(2)
return arcCsc(2);
// 结果：0.52
```

## `hypot(x, y)`

根据直角三角形的两条直角边返回斜边长度

| 参数 | 类型 | 说明                   |
| ---- | ---- | ---------------------- |
| `x`  | real | 一条直角边长度，实数   |
| `y`  | real | 另一条直角边长度，实数 |

返回：real

### 示例

```tsl
// 求Hypot (3,4)
return hypot (3, 4); // 返回sqrt(3^2+4^2)
// 结果：5
```

## `radToDeg(radians)`

将弧度值Radians转化为以角度为度量单位的相应值，也就是计算Radians\*180/π

| 参数      | 类型 | 说明         |
| --------- | ---- | ------------ |
| `radians` | real | 弧度值，实数 |

返回：real

### 示例

```tsl
// 求RadToDeg (π/3)
return radToDeg(pi()/3);
// 结果：60
```

## `radToGrad(radians)`

将弧度值Radians转化为以梯度为度量单位的相应值，也就是计算Radians\*200/π

| 参数      | 类型 | 说明         |
| --------- | ---- | ------------ |
| `radians` | real | 弧度值，实数 |

返回：real

### 示例

```tsl
// 求RadToGrad (π/4)
return radToGrad(pi()/4);
// 结果：50
```

## `radToCycle(radians)`

将弧度值Radians转化为以圆周为度量单位的相应值，也就是计算Radians\*/2π（2π是一个圆周）

| 参数      | 类型 | 说明         |
| --------- | ---- | ------------ |
| `radians` | real | 弧度值，实数 |

返回：real

### 示例

```tsl
// 求RadToCycle (π/4)
return radToCycle(pi()/4);
// 结果：0.125
```

## `degToRad(degrees)`

将角度值Degrees转化为以弧度为度量单位的相应值，也就是计算Degrees\*π/180

| 参数      | 类型 | 说明         |
| --------- | ---- | ------------ |
| `degrees` | real | 角度值，实数 |

返回：real

### 示例

```tsl
// 求DegToRad (60)
return degToRad(60);
// 结果：1.0472    //返回π/3
```

## `degToGrad(degrees)`

将角度值Degrees转化为以梯度为度量单位的相应值，也就是计算Degrees\*100/90（90度角相当于100梯度）

| 参数      | 类型 | 说明         |
| --------- | ---- | ------------ |
| `degrees` | real | 角度值，实数 |

返回：real

### 示例

```tsl
// 求DegToGrad (90)
return degToGrad (90);
// 结果：100
s
```

## `degToCycle(degrees)`

将角度值Degrees转化为以圆周为度量单位的相应值，也就是计算Degrees\*/360

| 参数      | 类型 | 说明         |
| --------- | ---- | ------------ |
| `degrees` | real | 角度值，实数 |

返回：real

### 示例

```tsl
// 求DegToCycle(45)
return degToCycle(45);
// 结果：0.125
```

## `gradToRad(grads)`

将梯度值Grads转化为以弧度为度量单位的相应值，也就是计算Grads\*π/200

| 参数    | 类型 | 说明         |
| ------- | ---- | ------------ |
| `grads` | real | 梯度值，实数 |

返回：real

### 示例

```tsl
// 求GradToRad(50)
return gradToRad(50);
// 结果：0.79//结果相当于π/4
```

## `gradToDeg(grads)`

将梯度值Grads转化为以角度为度量单位的相应值，也就是计算Grads\*90/100

| 参数    | 类型 | 说明         |
| ------- | ---- | ------------ |
| `grads` | real | 梯度值，实数 |

返回：real

### 示例

```tsl
// 求GradToDeg(50)
return gradToDeg(50);
// 结果：45
```

## `gradToCycle(grads)`

将梯度值Grads转化为以圆周为度量单位的相应值，也就是计算Grads/400

| 参数    | 类型 | 说明         |
| ------- | ---- | ------------ |
| `grads` | real | 梯度值，实数 |

返回：real

### 示例

```tsl
// 求GradToCycle(100)
return gradToCycle(100);
// 结果：0.25
```

## `cycleToRad(cycles)`

将圆周值Cycles转化为以弧度为度量单位的相应值，也就是计算Cycles*2*π

| 参数     | 类型 | 说明         |
| -------- | ---- | ------------ |
| `cycles` | real | 圆周值，实数 |

返回：real

### 示例

```tsl
// 求CycleToRad(1/4)
return cycleToRad(1/4);
// 结果：1.57 //相当于π/2
```

## `cycleToDeg(cycles)`

将圆周值Cycles转化为以角度为度量单位的相应值，也就是计算Cycles\*360

| 参数     | 类型 | 说明         |
| -------- | ---- | ------------ |
| `cycles` | real | 圆周值，实数 |

返回：real

### 示例

```tsl
// 求CycleToDeg(1/4)
return cycleToDeg(1/4);
// 结果：90
```

## `cycleToGrad(cycles)`

将圆周值Cycles转化为以梯度为度量单位的相应值，也就是计算Cycles\*400

| 参数     | 类型 | 说明         |
| -------- | ---- | ------------ |
| `cycles` | real | 圆周值，实数 |

返回：real

### 示例

```tsl
// 求CycleToGrad(1/4)
return cycleToGrad(1/4);
// 结果：100
```

## `sinh(x)`

双曲线正弦函数，返回参数X的双曲线正弦值，也就是(ex-e-x)/2

| 参数 | 类型 | 说明         |
| ---- | ---- | ------------ |
| `x`  | real | 弧度值，实数 |

返回：real

### 示例

```tsl
// 求Sinh (2)
return sinh(2);
// 结果：3.63
```

## `cosh(x)`

双曲余弦函数，返回参数X的双曲线余弦值，也就是(ex+e-x)/2

| 参数 | 类型 | 说明         |
| ---- | ---- | ------------ |
| `x`  | real | 弧度值，实数 |

返回：real

### 示例

```tsl
// 求Cosh(2)
return cosh(2);
// 结果：3.76
```

## `tanh(x)`

双曲线正切函数，返回参数X的双曲线正切值，也就是(ex-e-x)/(ex+e-x)

| 参数 | 类型 | 说明         |
| ---- | ---- | ------------ |
| `x`  | real | 弧度值，实数 |

返回：real

### 示例

```tsl
// 求Tanh(2)
return tanh(2);
// 结果：0.96
```

## `coth(x)`

双曲线余切函数，返回参数X的双曲线余切值，也就是(ex+e-x)/(ex-e-x)

| 参数 | 类型 | 说明         |
| ---- | ---- | ------------ |
| `x`  | real | 弧度值，实数 |

返回：real

### 示例

```tsl
// 求CotH(2)
return coth(2);
// 结果：1.04
```

## `sech(x)`

双曲线正割函数，计算参数X的双曲线正割值，也就是计算2/(ex+e-x)

| 参数 | 类型 | 说明         |
| ---- | ---- | ------------ |
| `x`  | real | 弧度值，实数 |

返回：real

### 示例

```tsl
// 求SecH(2)
return sech(2);
// 结果：0.27
```

## `csch(x)`

双曲线余割函数，计算参数X的双曲线余割值，也就是计算2/(ex-e-x)

| 参数 | 类型 | 说明         |
| ---- | ---- | ------------ |
| `x`  | real | 弧度值，实数 |

返回：real

### 示例

```tsl
// 求CscH (2)
return csch(2);
// 结果：0.28
```

## `arcCosh(x)`

反双曲余弦函数，计算参数X的反双曲余弦值，是双曲余弦函数Cosh（X）的反函数

| 参数 | 类型 | 说明                  |
| ---- | ---- | --------------------- |
| `x`  | real | 定义域是[1，+∞), 实数 |

返回：real

### 示例

```tsl
// 求ArcCosh(2)
return arcCosh(2);
// 结果：1.32
```

## `arcSinh(x)`

反双曲正弦函数，计算参数X的反双曲正弦值，是双曲正弦函数Sinh(X)的反函数

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `x`  | real | 实数 |

返回：real

### 示例

```tsl
// 求ArcSinh (2)
return arcSinh(2);
// 结果：1.44
```

## `arcTanh(x)`

反双曲正切函数，计算参数X的反双曲正切值，是双曲正切函数TanH(X)的反函数

| 参数 | 类型 | 说明                   |
| ---- | ---- | ---------------------- |
| `x`  | real | 实数，定义域是[-1，+1] |

返回：real

### 示例

```tsl
// 求ArcTanh(0.8)
return arcTanh(0.8);
// 结果：1.1
```

## `arcCoth(x)`

反双曲余切函数，计算参数X的反双曲余切值，是双曲余切函数CotH(X)的反函数

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `x`  | real | 实数 |

返回：real

### 示例

```tsl
// 求ArcCotH(4)
return arcCoth(4);
// 结果：0.26
```

## `arcSech(x)`

反双曲正割函数，计算参数X的反双曲正割值，是双曲正割函数CecH(X)的反函数

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `x`  | real | 实数 |

返回：real

### 示例

```tsl
// 求ArcSecH(4)
return arcSech(0.5);
// 结果：1.32
```

## `arcCsch(x)`

反双曲余割函数，计算参数X的反双曲余割值，是双曲余割函数Csch (X)的反函数

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `x`  | real | 实数 |

返回：real

### 示例

```tsl
// 求ArcCscH(4)
return arcCsch(4);
// 结果：0.25
```

## `ln(x)`

返回X的自然对数，是Exp函数的反函数

| 参数 | 类型 | 说明        |
| ---- | ---- | ----------- |
| `x`  | real | 实数，大于0 |

返回：real

### 示例

```tsl
// 求ln(e^2)
return ln(7.38905609893065);
// 结果：2
```

## `lnXp1(x)`

返回（X+1）的自然对数，也就是Ln（X+1）

| 参数 | 类型 | 说明               |
| ---- | ---- | ------------------ |
| `x`  | real | 可以是实数，大于-1 |

返回：real

### 示例

```tsl
return lnXp1(3);
// 结果：1.39 //返回ln4
```

## `log10(x)`

返回X以10为底的自然对数，也就是log10X

| 参数 | 类型 | 说明        |
| ---- | ---- | ----------- |
| `x`  | real | 实数，大于0 |

返回：real

### 示例

```tsl
return log10(100);
// 结果：2 //返回log10100
```

## `log2(x)`

返回X以2为底的自然对数，也就是log2X

| 参数 | 类型 | 说明        |
| ---- | ---- | ----------- |
| `x`  | real | 实数，大于0 |

返回：real

### 示例

```tsl
return log2(8);
// 结果：3 //返回log28
```

## `logN(base, x)`

返回X以Base为底的自然对数，也就是logbaseX

| 参数   | 类型 | 说明        |
| ------ | ---- | ----------- |
| `base` | real | 底数，实数  |
| `x`    | real | 实数，大于0 |

返回：real

### 示例

```tsl
return logN(2, 8);
// 结果：3 //返回log28
```

## `intpower(base, exponent)`

计算Base的Exponent次幂，也就是计算BaseExponent

| 参数       | 类型 | 说明                                 |
| ---------- | ---- | ------------------------------------ |
| `base`     | real | 底数，实数                           |
| `exponent` | real | 指数，整数，如果不是整数则会进行取整 |

返回：real

### 示例

```tsl
return intPower (2, 3.2);
// 结果：8 //返回2^3
```

## `power(base, exponent)`

计算Base的Exponent次幂，也就是计算BaseExponent，由于指数也是实数，计算速度要低于IntPower()函数

| 参数       | 类型 | 说明                                    |
| ---------- | ---- | --------------------------------------- |
| `base`     | real | 底数，实数                              |
| `exponent` | real | 指数，实数，非整数时，参数Base必须大于0 |

返回：real

### 示例

```tsl
return power (2, 3.2);
// 结果：9.19 //返回2^3.2
```

## `round32(x)`

对X做取整运算，近似到最接近的整数。

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `x`  | real | 实数 |

返回：integer

### 示例

```tsl
x := round32(6.8);
return x;
// 结果：7
```

## `round64(x)`

对X做取整运算，近似到最接近的整数。采用银行家舍入原则，“四舍六入五考虑，五后非零就进一，五后皆零看奇偶，五前为偶应舍去，五前为奇要进一”。

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `x`  | real | 实数 |

返回：int64

### 示例

```tsl
x := round64(3.5);
return x;
// 结果：4
```

## `simpleRound32(x)`

对X做取整运算，近似到最接近的整数。采用四舍五入原则，即尾数是五就进一。

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `x`  | real | 实数 |

返回：integer

### 示例

```tsl
x := simpleRound32(6.8);
return x;
// 结果：7
```

## `simpleRound64(x)`

对X做取整运算，近似到最接近的整数。采用四舍五入原则，即尾数是五就进一。

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `x`  | real | 实数 |

返回：int64

### 示例

```tsl
x := simpleRound64(3.5);
return x;
// 结果：4
```

## `roundTo(a_value, a_digit)`

使用银行家算法对AValue进行四舍五入,精确到10Adigit位。“四舍六入五考虑，五后非零就进一，五后皆零看奇偶，五前为偶应舍去，五前为奇要进一”。

| 参数      | 类型    | 说明                 |
| --------- | ------- | -------------------- |
| `a_value` | real    | 实数                 |
| `a_digit` | integer | 整数,范围为[-37，37] |

返回：real

### 示例

范例01：整数四舍五入

```tsl
return roundTo(1234567.3, 4);
// 结果：1230000
```

范例02：小数部分四舍五入

```tsl
return roundTo(1.234567, -3);
// 结果：1.235
```

## `simpleRoundTo(a_value, a_digit)`

返回参数AValue四舍五入后的值。四舍五入的位置由参数Adigit决定，尾数是五就进一。

| 参数      | 类型    | 说明                 |
| --------- | ------- | -------------------- |
| `a_value` | real    | 实数                 |
| `a_digit` | integer | 整数,范围为[-37，37] |

返回：real

### 示例

范例01：

```tsl
return simpleRoundTo(1234567.3，4);
// 结果：1230000
```

范例02：

```tsl
return simpleRoundTo(-1.235, -2);
// -1.24
```

## `isNan(a_value)`

返回布尔型真假值，确定指定的参数AValue是否是一个NAN数。

| 参数      | 类型 | 说明     |
| --------- | ---- | -------- |
| `a_value` | any  | 任意数据 |

返回：bool

### 示例

范例01：判断单个值是否nan

```tsl
v := nan;
return isNan(v); // 1
```

范例02：判断数组中各元素是否nan

```tsl
data := array(2, nan, 3, '', 's', nil);
return isNan(data);
// 输出：
// array(0,1,0,0,0,0)
```

## `isInfinite(a_value)`

返回布尔型真假值，确定指定的参数AValue是否是一个正或负的无穷大的数。

| 参数      | 类型 | 说明     |
| --------- | ---- | -------- |
| `a_value` | any  | 任意数据 |

返回：bool

### 示例

范例01：判断单个值是否inf

```tsl
return isInfinite (inf);
// 结果：1
```

范例02：判断数组中各元素是否nan

```tsl
data := array(2, nan, 3, '', 's', nil, inf);
return isInfinite(data);
// 输出：
// array(0,0,0,0,0,0,1)
```

## `sign(a_value)`

Sign函数，判断参数AValue的符号。如果为正，返回+1，如果为负数，返回-1，如果为0，则返回0

| 参数      | 类型 | 说明 |
| --------- | ---- | ---- |
| `a_value` | real | 实数 |

返回：integer

### 示例

```tsl
return sign (-2);
// 结果：-1
```

## `isZero(a, epsilon)`

返回布尔真假值。返回A是否在(0-Epsilon,0+ Epsilon)范围内。

| 参数      | 类型 | 说明                     |
| --------- | ---- | ------------------------ |
| `a`       | real | 实数，需要进行判断的数据 |
| `epsilon` | real | 与0的差距范围，实数      |

返回：bool

### 示例

```tsl
a := 1.400000000001;
b := 1.399999999999;
return isZero(a-b, 0.000000001); // 在9位小数的精度下
// 结果：1
```

## `min(a, b)`

返回A、B中的较小值，如果A、B是数组，需保证两个参数的数据维度相同，一一比较对应位置的两个数字，返回较小的值

| 参数 | 类型        | 说明 |
| ---- | ----------- | ---- |
| `a`  | real\|array | 实数 |
| `b`  | real\|array | 实数 |

返回：real|array

### 示例

```tsl
// 比较两个值
return min(3, 3.6);
// 结果：3
// 比较两个数组
a := array(1, 3, 5);
b := array(2, 3, 4);
return min(a, b);
```

## `max(a, b)`

返回A、B中的较大值，如果A、B是数组，需保证两个参数的数据维度相同，一一比较对应位置的两个数字，返回较大的值

| 参数 | 类型        | 说明      |
| ---- | ----------- | --------- |
| `a`  | real\|array | 实数/数组 |
| `b`  | real\|array | 实数/数组 |

返回：real|array

### 示例

```tsl
return max(5, 5.6);
// 结果：5.6
return max(array(1, 2, 8), array(4, 5, 6));
```

## `compareValue(a, b, epsilon)`

返回-1,0或1。比较A与B的大小，如果A大于B，返回+1，如果A小于B，返回-1，如果相等，则返回0。参数Epsilon表示一个范围，如果A和B的差距大于这个范围，则进行正常的比较，如果A和B的差距小于这个范围，则认为A等于B。

| 参数      | 类型 | 说明     |
| --------- | ---- | -------- |
| `a`       | real | 实数     |
| `b`       | real | 实数     |
| `epsilon` | real | 误差范围 |

返回：integer

### 示例

```tsl
return compareValue (3, 4, 0.5);
// 结果：-1
// 表示3与4之间的差距超过0.5则正常比较，否则认为相等
```

## `sameValue(a, b, epsilon)`

返回A与B是否近似相等。两者的差距是否小于Epsilon参数定义的范围

| 参数      | 类型 | 说明                       |
| --------- | ---- | -------------------------- |
| `a`       | real | 实数                       |
| `b`       | real | 实数                       |
| `epsilon` | real | 表示一个两者差距的最大范围 |

返回：bool

### 示例

```tsl
return sameValue (3, 4, 0.5);
// 结果：0
// 表示3与4之间的差距在0.5之内认为相等,否则认为不相等
```

## `randomRange(a_from, a_to)`

返回一个介于参数AFrom（包括）和参数ATo（不包括）之间的随机整数

| 参数     | 类型    | 说明 |
| -------- | ------- | ---- |
| `a_from` | integer | 整数 |
| `a_to`   | integer | 整数 |

返回：integer

### 示例

```tsl
return randomRange (4.7, 8.5);
// 结果：5//返回4到8之间的随机整数
```

## `slnDepreciation(cost, salvage, life)`

返回根据直线折旧法计算的每期折旧额。类似地，计算现值加速折旧法折旧的函数是SYDDepreciation。计算方法是用资产原值Cost减去资产残值Salvage的差除以折旧周期数Life

| 参数      | 类型    | 说明                 |
| --------- | ------- | -------------------- |
| `cost`    | real    | 实数，资产原值       |
| `salvage` | real    | 实数，资产残值       |
| `life`    | integer | 整数，设备的使用期数 |

返回：real

### 示例

```tsl
return slnDepreciation(20000, 2000, 5);
// 结果：3600
// 第一年应提折旧额=(20000-2000)/5=3600
// 第二年应提折旧额=(20000-2000)/5=3600
// 第三年应提折旧额=(20000-2000)/5=3600
// 第四年应提折旧额=(20000-2000)/5=3600
// 第五年应提折旧额=(20000-2000)/5=3600
// 输出：1800
```

## `sydDepreciation(cost, salvage, life, period)`

根据"sum-of-years-digits depreciation"方法计算某期的折旧额。这是一种加速折旧方法，在早一些的年份折旧速度快于晚一些的年份。计算方法是：`(Cost-Salvage)*Period/[（1+Life）* Life/2]`

| 参数      | 类型    | 说明                         |
| --------- | ------- | ---------------------------- |
| `cost`    | real    | 实数，资产原值               |
| `salvage` | real    | 实数，资产残值               |
| `life`    | integer | 整数，设备的使用期数         |
| `period`  | integer | 整数，指出计算第几期的折旧额 |

返回：real

### 示例

```tsl
return sydDepreciation(20000, 2000, 5, 2);
// 结果：4800
// 第一年应提折旧额=(20000-2000)*5/((1+5)*5/2)=6000
// 第二年应提折旧额=(20000-2000) *4/((1+5)*5/2)=4800
// 第三年应提折旧额=(20000-2000) *3/((1+5)*5/2)=3600
// 第四年应提折旧额=(20000-2000) *2/((1+5)*5/2)=2400
// 第五年应提折旧额=(20000-2000) *1/((1+5)*5/2)=1200
// 输出：2400
```

## `pi()`

圆周率，返回3.1415926535897932385

返回：real

### 示例

```tsl
// 求面积(π*R^2)
r := 2;
return pi() * r^2;
// 结果：12.5663706143592
```

## `abs(x)`

返回X的绝对值

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `x`  | real | 实数 |

返回：real

### 示例

```tsl
// 求-2的绝对值
return abs(-2);
// 结果：2
```

## `sqr(x)`

返回X的平方

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `x`  | real | 实数 |

返回：real

### 示例

```tsl
// 求x^2
x := 2;
return sqr(x);
// 结果：4
```

## `sqrt(x)`

返回X的平方根（该函数支持对数组操作）。可以对一维数组和二维数组里面的数据开平方，如果数组中含有字符，函数将报错。

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `x`  | real | 实数 |

返回：real

### 示例

```tsl
// 求实数的平方根
x := 4;
return sqrt(x);
// 结果：2
// 计算一维数组中所有元素的平方根
x := array(4, 9, 16, 25);
return sqrt(x);
// 结果：array(2,3,4,5)
```

## `divMod(dividend, divisor, result, remainder)`

计算整数除法的整数商和余数。也就是用参数Dividend除以参数Divisor，得到的整数商存到参数Result中，把余数存到参数Remainder中

| 参数        | 类型    | 说明         |
| ----------- | ------- | ------------ |
| `dividend`  | integer | 整数，被除数 |
| `divisor`   | integer | 整数，除数   |
| `result`    | int64   | 整数，商     |
| `remainder` | int64   | 整数，余数   |

返回：real

### 示例

```tsl
divMod (5, 3, a, b);
return array(a, b);
// 输出：
// array(1L,2L)
```

## `frexp(x, base, exponent)`

分离出浮点数存储的尾数和指数

| 参数       | 类型    | 说明             |
| ---------- | ------- | ---------------- |
| `x`        | real    | 实数，浮点数。   |
| `base`     | real    | 实数，返回的尾数 |
| `exponent` | integer | 整数，返回的指数 |

返回：real

### 示例

```tsl
// 将X分离出位数和指数,即X= Base *2^ Exponent
x := pi();
frexp(x, base, exponent);
return array(base, exponent);
// 输出：
// array(0.785398163397448,2)
```

## `poly(x, coefficients)`

计算以下多项式的值，其中参数Coefficients必须是数组类型，存放参数X的各次幂的系数。公式是

| 参数           | 类型          | 说明                 |
| -------------- | ------------- | -------------------- |
| `x`            | real          | 实数                 |
| `coefficients` | array of real | 多项式数组，一维数组 |

返回：real

### 示例

```tsl
x := 2;
a := array(2, 3, 1, 5);
return poly(x, a);
// 结果：52
// 返回2*(2^0)+3*(2^1)+1*(2^2)+ 5*(2^3)
```

## `exp(x)`

返回自然对数e的X次方

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `x`  | real | 实数 |

返回：real

### 示例

```tsl
// 求e^2
return exp(2);
// 结果：7.38905609893065
```

## `int(x)`

对X取整数部分，去掉小数部分，得到的还是实数

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `x`  | real | 实数 |

返回：real

### 示例

```tsl
// 求x
x := 2.45;
return int(x);
// 结果：2.0
```

## `ceil(x)`

得到不比参数X小的最小整数

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `x`  | real | 实数 |

返回：integer

### 示例

```tsl
return ceil(-2.8);
// 结果：-2
```

## `ceil32(x)`

得到比参数X大的最小整数。

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `x`  | real | 实数 |

返回：integer

### 示例

```tsl
return ceil32(-2.8);
// 结果：-2
```

## `ceil64(x)`

得到比参数X大的最小整数。

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `x`  | real | 实数 |

返回：int64

### 示例

```tsl
return ceil64(-2.8);
// 结果：-2
```

## `floor(x)`

得到不比参数X大的最大整数

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `x`  | real | 实数 |

返回：integer

### 示例

```tsl
return floor(-2.8);
// 结果：-3
```

## `floor32(x)`

得到比参数X小的最大整数。参数：

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `x`  | real |      |

返回：integer

### 示例

```tsl
return floor32(-2.8);
// 结果：-3
```

## `floor64(x)`

得到比参数X小的最大整数。参数：

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `x`  | real |      |

返回：int64

### 示例

```tsl
return floor64(-2.8);
// 结果：-3
```

## `trunc(x)`

对X做取整运算，近似到最接近0的整数

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `x`  | real | 实数 |

返回：integer

### 示例

```tsl
x := trunc(-6.8);
return x;
// 结果：-6
```

## `trunc32(x)`

对X做取整运算，近似到最接近0的整数。

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `x`  | real | 实数 |

返回：integer

### 示例

```tsl
x := trunc32(-6.8);
return x;
// 结果：-6
```

## `trunc64(x)`

对X做取整运算，近似到最接近0的整数。

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `x`  | real | 实数 |

返回：int64

### 示例

```tsl
x := trunc64(6.8);
return x;
// 结果：6
```

## `frac(x)`

对X取小数部分返回

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `x`  | real | 实数 |

返回：real

### 示例

```tsl
// 求x
x := 2.45;
return frac(x);
// 结果：0.45
```

## `round(x)`

使用银行家算法四舍五入，“四舍六入五考虑，五后非零就进一，五后皆零看奇偶，五前为偶应舍去，五前为奇要进一”。输出整数

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `x`  | real | 实数 |

返回：integer

### 示例

```tsl
// 求x
x := 3.5;
return round(x);
// 结果：4
```

## `simpleRound(x)`

与Round函数相比，SimpleRound采用了正负数不对称的算法，当一个负数正好是进位的一半时，它向较大的数进位。输出为整数类型。

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `x`  | real | 实数 |

返回：integer

### 示例

```tsl
// 求x
x := 3.5;
return simpleRound(x);
// 结果：4
```

## `inRange(amin, amax)`

判断Avalue是否在[Amin, Amax]范围内

| 参数   | 类型 | 说明 |
| ------ | ---- | ---- |
| `amin` | real | 实数 |
| `amax` | real | 实数 |

返回：bool

### 示例

```tsl
return inRange (4.3, 4, 8);
// 结果：1
```

## `ensureRange(amin, amax)`

这个函数可以保证返回某个区间之内的数，参数Amin和参数Amax是这个区间的上限和下限。

| 参数   | 类型 | 说明 |
| ------ | ---- | ---- |
| `amin` | real | 实数 |
| `amax` | real | 实数 |

返回：real

### 示例

```tsl
return ensureRange (4.3, 4, 8);
// 结果：4.3
```

## `_and(x, y)`

与，返回位运算二进制X And 二进制Y

| 参数 | 类型    | 说明 |
| ---- | ------- | ---- |
| `x`  | integer | 整数 |
| `y`  | integer | 整数 |

返回：integer

### 示例

```tsl
return _and(6, 3); // 返回十进制(6=110) and 3=(11) 最后得到二进制10
// 结果：2
```

## `_or(x, y)`

或，返回位运算X Or Y

| 参数 | 类型    | 说明 |
| ---- | ------- | ---- |
| `x`  | integer | 整数 |
| `y`  | integer | 整数 |

返回：integer

### 示例

```tsl
return _or (6, 3);
// 结果：7
// 返回十进制(6=110) or 3=(11) 最后得到二进制111，十进制是7
```

## `_xor(x, y)`

异或，返回位运算X Xor Y，

| 参数 | 类型    | 说明 |
| ---- | ------- | ---- |
| `x`  | integer | 整数 |
| `y`  | integer | 整数 |

返回：integer

### 示例

```tsl
return _xor (6, 3);
// 结果：5
// 返回十进制 (6=110) Xor (3=011) 最后得到二进制101，十进制是5
```

## `_shl(x, y)`

左移位，返回位运算X Shl Y，二进制X左移 Y位

| 参数 | 类型    | 说明 |
| ---- | ------- | ---- |
| `x`  | integer | 整数 |
| `y`  | integer | 整数 |

返回：integer

### 示例

```tsl
return _shl (6, 3);
// 结果：48
// 返回十进制 (6=110) _Shl 3 最后得到二进制110000，十进制是48
```

## `_shr(x, y)`

右移位，返回位运算X Shr Y，二进制X右移 Y位

| 参数 | 类型    | 说明 |
| ---- | ------- | ---- |
| `x`  | integer | 整数 |
| `y`  | integer | 整数 |

返回：integer

### 示例

```tsl
return _shr (36, 3);
// 结果：4
// 返回十进制 (36=100100) _Shr 3最后得到二进制00000100，十进制是4
```

## `_rol(x, y)`

循环左移位，返回位运算X Rol Y，二进制X各位左移Y位，原来的高Y位变成低Y位

| 参数 | 类型    | 说明 |
| ---- | ------- | ---- |
| `x`  | integer | 整数 |
| `y`  | integer | 整数 |

返回：integer

### 示例

```tsl
return _rol (36, 3);
// 结果：288
// 返回十进制 (36=100100) 左移3位,最后得到二进制100100000，十进制是//288
```

## `_ror(x, y)`

循环右移位，返回位运算X Ror Y

| 参数 | 类型    | 说明 |
| ---- | ------- | ---- |
| `x`  | integer | 整数 |
| `y`  | integer | 整数 |

返回：integer

### 示例

```tsl
return _ror (36, 2);
// 结果：9
// 返回十进制 (36=100100) 右移2位,最后得到二进制00001001，十进制是9
```

## `doubleDecliningBalance(cost, salvage, life, period)`

返回对一项资产的第Period期的加速折旧值。COST表示资产原值（折旧初始值），Salvage表示资产残值，Life表示折旧年限，Period表示第几期折旧。

| 参数      | 类型    | 说明                     |
| --------- | ------- | ------------------------ |
| `cost`    | real    | 实数，表示资产原值       |
| `salvage` | real    | 实数，表示资产残值       |
| `life`    | integer | 实数，表示折旧年限       |
| `period`  | integer | 实数，表示计算第几期折旧 |

返回：real

### 示例

```tsl
cost := 100;
salvage := 32;
life := 3;
period := 2;
return doubleDecliningBalance(cost, salvage, life, period);
// 输出：
1.3333
```

## `futureValue(rate, nperiods, payment, present_value, payment_time)`

返回一项投资的未来值。这项投资的现值投入是PresentValue，每期投资额是Payment，投资的内部收益率是Rate，投资期数是Nperiods，而参数PaymentTime决定每期的Payment投资是在期初或期末进行。

| 参数            | 类型    | 说明                                               |
| --------------- | ------- | -------------------------------------------------- |
| `rate`          | real    | 实数，表示内部收益率                               |
| `nperiods`      | integer | 整数，表示投资的总期数                             |
| `payment`       | real    | 实数，表示投资期内，每期投入值                     |
| `present_value` | real    | 实数，初期投入的现值                               |
| `payment_time`  | integer | PaymentTime决定每期的Payment投资是在期初或期末进行 |

返回：real

### 示例

```tsl
rate := 0.05;
nperiods := 5;
payment := 100;
present_value := -10000;
payment_time := 1;
return futureValue(rate, nperiods, payment, present_value, payment_time);
// 输出：5.3253
```

## `interestPayment(rate, period, nperiods, present_value, future_value, payment_time)`

返回一项贷款的第Periods期的还款的利息额部分。这项贷款的现值是PresentValue，投资所产生的终值是FutureValue，而参数PaymentTime决定每期的利息投资是在期初或期末进行

| 参数            | 类型    | 说明                                               |
| --------------- | ------- | -------------------------------------------------- |
| `rate`          | real    | 实数，表示贷款利率                                 |
| `period`        | integer | 整数，第几期还款                                   |
| `nperiods`      | integer | 整数，表示还款的总期数                             |
| `present_value` | real    | 实数，表示贷款总额                                 |
| `future_value`  | real    | 实数，表示投资的未来值                             |
| `payment_time`  | integer | PaymentTime决定每期的Payment投资是在期初或期末进行 |

返回：real

### 示例

```tsl
rate := 0.1;
period := 5;
nperiods := 12;
present_value := 120;
future_value := 500;
payment_time := 0;
return interestPayment(rate, period, nperiods, present_value, future_value, payment_time);
// 输出：1.456
```

## `internalRateOfReturn(guess, cash_flows)`

返回内部回报率，根据一个项目完整的现金流情况得出，函数假设这些现金流的发生是规则、持续的，它们之间的时间间隔必须相等，例如每年年末。同时，现金流入用正值表示，现金流出用负值表示。第一个数据必须为负，以表示初始投资。

| 参数         | 类型          | 说明               |
| ------------ | ------------- | ------------------ |
| `guess`      | real          | 实数，评估的收益率 |
| `cash_flows` | array of real | 实数数组，现金流   |

返回：real

### 示例

```tsl
guess := 100;
data := array(10, 20);
return internalRateOfReturn(guess, data);
// 输出：-1
```

## `netPresentValue(rate, cash_flows, payment_time)`

返回净现值。就是根据CashFlows未来现金流的状况，以Rate利率折线的数值。PaymentTime决定CashFlow的是在期初还是期末发生

| 参数           | 类型          | 说明                               |
| -------------- | ------------- | ---------------------------------- |
| `rate`         | real          | 实数，利率                         |
| `cash_flows`   | array of real | 实数数组名，现金流                 |
| `payment_time` | integer       | 决定CashFlow的是在期初还是期末发生 |

返回：real

### 示例

```tsl
rate := 0.1;
cash_flows := Array(100, 1000);
payment_time := 0;
return netPresentValue(rate, cash_flows, payment_time);
// 输出：917.3554
```

## `payment(rate, nperiods, present_value, future_value, payment_time)`

返回贷款每期还款数。贷款数为PresentValue，贷款利率是Rate，NPeriods表示还款的总期数。这个函数假定利息是在每个期末支付。FutureValue表示投资到还款结束起达到的程度，PaymentTime决定每期的还款是在期初还是期末发生

| 参数            | 类型    | 说明                               |
| --------------- | ------- | ---------------------------------- |
| `rate`          | real    | 实数，贷款利率                     |
| `nperiods`      | integer | 整数，表示还款的总期数             |
| `present_value` | real    | 实数，表示贷款总额                 |
| `future_value`  | real    | 表示投资到还款结束起达到的程度     |
| `payment_time`  | integer | 决定CashFlow的是在期初还是期末发生 |

返回：real

### 示例

```tsl
rate := 0.1;
nperiods := 100;
present_value := 0;
future_value := 10000;
payment_time := 0;
return payment(rate, nperiods, present_value, future_value, payment_time);
// 输出：-0.0726
```

## `periodPayment(rate, period, nperiods, present_value, future_value, payment_time)`

返回贷款每期还款本金的部分。类似地，InterestPayment函数是返回贷款每期还款利息的部分

| 参数            | 类型    | 说明                           |
| --------------- | ------- | ------------------------------ |
| `rate`          | real    | 实数，贷款利率                 |
| `period`        | integer | 整数，第几期还款               |
| `nperiods`      | integer | 整数，表示还款的总期数         |
| `present_value` | real    | 实数，表示贷款总额             |
| `future_value`  | real    | 表示投资到还款结束起达到的程度 |
| `payment_time`  | integer | 决定现金流是在期初还是期末发生 |

返回：real

### 示例

```tsl
rate := 0.1;
period := 10;
nperiods := 30;
present_value := 0;
future_value := 10000;
payment_time := 0;
return periodPayment(rate, period, nperiods, present_value, future_value, payment_time);
// 输出：-143.3455
```

## `presentValue(rate, nperiods, payment, future_value, payment_time)`

返回现值，这部分现值由两部分组成，一部分是每期的固定的现金流入，一部分是最终的一笔现金流入。例如购买每年付息的债券就可以用这个函数来计算现值。

| 参数           | 类型    | 说明                           |
| -------------- | ------- | ------------------------------ |
| `rate`         | real    | 实数，要求利率                 |
| `nperiods`     | integer | 整数，表示现金流入的总期数     |
| `payment`      | real    | 实数，表示每期的现金流入额     |
| `future_value` | real    | 实数，表示结束时现金流入       |
| `payment_time` | integer | 决定现金流是在期初还是期末发生 |

返回：real

### 示例

```tsl
rate := 0.1;
nperiods := 30;
future_value := 10000;
payment_time := 0;
return presentValue(rate, nperiods, payment, future_value, payment_time);
// 输出：-573.0855
```

## `mbbub(p, z)`

排序，对数组P按照从小到大的顺序排序，把数组排序的顺序对应的下标值返回到数组Z中

| 参数 | 类型  | 说明             |
| ---- | ----- | ---------------- |
| `p`  | array | 一维数字数组类型 |
| `z`  | array | 一维数字数组类型 |

返回：array

### 示例

```tsl
p := array(2.72, 1.24, 1.31, 0.02, 0.88, 2.18);
return mbbub(p, z);
// 输出：
// Execute script error at Line:2
// function:__main__:line 2:instruction:usercall: function:mbbub compile error or not found
// function:__main__:line 2:instruction:usercall: function execute error
```

## `componentScoreMatrix(cm, r)`

因子得分系数矩阵

| 参数 | 类型  | 说明                           |
| ---- | ----- | ------------------------------ |
| `cm` | array | 二维数字数组类型，载荷矩阵     |
| `r`  | array | 二维数字数组类型，相关系数矩阵 |

返回：array

### 示例

```tsl
// 设置样本矩阵
zt := array((0.7592, 1.7593, 21.9279, 48.5626, 55.1679),
(0.0490, 0.4457, 2.2255, 82.2658, 192.4348),
(-2.2313, -1.3096, -59.8883, 3.9922, -80.2419),
(0.1364, 0.539, 4.3910, 55.1438, 46.0612),
(0.7233, 1.9467, 15.6127, 111.3018, 58.3969));
z_t_s := Standarize_II(z_t); // 标准化
mt_Transposition(z_t_s, z); // 转置
r := correlationMatrix(z); // 相关系数矩阵
Eigen_Jacobi(r, eigen_value, eigen_vector); // 特征值&特征向量
cm := componentMatrix(eigen_value, eigen_vector, max_eigen_value); // 载荷矩阵
return componentScoreMatrix(cm, r);
// 输出：
// 示例包含说明文字，未作为可执行片段运行。
```

## `factorScoreMatrix(cs, z)`

主因子得分

| 参数 | 类型  | 说明                           |
| ---- | ----- | ------------------------------ |
| `cs` | array | 二维数字数组类型，因子得分矩阵 |
| `z`  | array | 二维数字数组类型，原始数据矩阵 |

返回：array

### 示例

```tsl
// 设置样本矩阵
zt := array((0.7592, 1.7593, 21.9279, 48.5626, 55.1679),
(0.0490, 0.4457, 2.2255, 82.2658, 192.4348),
(-2.2313, -1.3096, -59.8883, 3.9922, -80.2419),
(0.1364, 0.539, 4.3910, 55.1438, 46.0612),
(0.7233, 1.9467, 15.6127, 111.3018, 58.3969));
z_t_s := Standarize_II(z_t); // 标准化
mt_Transposition(z_t_s, z); // 转置
r := correlationMatrix(z); // 相关系数矩阵
Eigen_Jacobi(r, eigen_value, eigen_vector); // 特征值&特征向量
cm := componentMatrix(eigen_value, eigen_vector, max_eigen_value); // 载荷矩阵
cs := componentScoreMatrix(cm, r); // 因子得分矩阵
return factorScoreMatrix(cs, zt);
// 输出：
// 示例包含说明文字，未作为可执行片段运行。
```

## `rotatedComponentMatrix(cm)`

返回方差最大正交旋转矩阵

| 参数 | 类型  | 说明                       |
| ---- | ----- | -------------------------- |
| `cm` | array | 二维数字数组类型，载荷矩阵 |

返回：array

### 示例

```tsl
// 设置样本矩阵
zt := array((0.7592, 1.7593, 21.9279, 48.5626, 55.1679),
(0.0490, 0.4457, 2.2255, 82.2658, 192.4348),
(-2.2313, -1.3096, -59.8883, 3.9922, -80.2419),
(0.1364, 0.539, 4.3910, 55.1438, 46.0612),
(0.7233, 1.9467, 15.6127, 111.3018, 58.3969));
z_t_s := Standarize_II(z_t); // 标准化
mt_Transposition(z_t_s, z); // 转置
r := correlationMatrix(z); // 相关系数矩阵
Eigen_Jacobi(r, eigen_value, eigen_vector); // 特征值&特征向量
cm := componentMatrix(eigen_value, eigen_vector, max_eigen_value); // 载荷矩阵
return rotatedComponentMatrix(cm);
// 输出：
// 示例包含说明文字，未作为可执行片段运行。
```

## `arma(series, p, q)`

自回归移动平均模型，ARMA(p,q)模型，采用逆函数去估计自回归系数和移动平均系数，返回结果有自回归系数、移动平均系数、残差方差等信息

| 参数     | 类型          | 说明                                     |
| -------- | ------------- | ---------------------------------------- |
| `series` | array of real | 样本序列，为一维数组类型，注意要零均值化 |
| `p`      | integer       | 自回归阶数，整数类型                     |
| `q`      | integer       | 移动平均阶数，整数类型                   |

返回：array

### 示例

```tsl
elps := randnorm(0, 1, 200);
y := array();
y[0] := 0;
for i := 1 to 199 do
y[i] := 0.8 * y[i-1]+elps[i]-0.4 * elps[i-1];
return arma(y, 1, 1);
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:usercall: function:randnorm compile error or not found
// function:__main__:line 1:instruction:usercall: function execute error
```

## `princaipalComponentAnalysis(zt)`

主成分分析

| 参数 | 类型  | 说明                       |
| ---- | ----- | -------------------------- |
| `zt` | array | 二维数字数组类型，样本矩阵 |

返回：array

### 示例

```tsl
// 设置样本矩阵
zt := array((0.7592, 1.7593, 21.9279, 48.5626, 55.1679),
(0.0490, 0.4457, 2.2255, 82.2658, 192.4348),
(-2.2313, -1.3096, -59.8883, 3.9922, -80.2419),
(0.1364, 0.539, 4.3910, 55.1438, 46.0612),
(0.7233, 1.9467, 15.6127, 111.3018, 58.3969));
return princaipalComponentAnalysis(zt);
// 输出：
// Execute script error at Line:7
// function:__main__:line 7:instruction:usercall: function:princaipalComponentAnalysis compile error or not found
// function:__main__:line 7:instruction:usercall: function execute error
```

## `componentMatrix(eigen_value, eigen_vector, max_eigen_value)`

载荷矩阵

| 参数              | 类型  | 说明                                 |
| ----------------- | ----- | ------------------------------------ |
| `eigen_value`     | array | 一维数字数组类型，特征根             |
| `eigen_vector`    | array | 二维数字数组类型，特征向量           |
| `max_eigen_value` | array | 一维数字数组类型，主因子对应的特征根 |

返回：array

### 示例

```tsl
// 设置样本矩阵
zt := array((0.7592, 1.7593, 21.9279, 48.5626, 55.1679),
(0.0490, 0.4457, 2.2255, 82.2658, 192.4348),
(-2.2313, -1.3096, -59.8883, 3.9922, -80.2419),
(0.1364, 0.539, 4.3910, 55.1438, 46.0612),
(0.7233, 1.9467, 15.6127, 111.3018, 58.3969));
z_t_s := Standarize_II(z_t); // 标准化
mt_Transposition(z_t_s, z); // 转置
r := correlationMatrix(z); // 相关系数矩阵
Eigen_Jacobi(r, eigen_value, eigen_vector); // 特征值&特征向量
return componentMatrix(eigen_value, eigen_vector, max_eigen_value);
// 输出：
// 示例包含说明文字，未作为可执行片段运行。
```

## `fScoreResult(factor_arr, max_eigen_value)`

获取主因子得分

| 参数              | 类型  | 说明                                 |
| ----------------- | ----- | ------------------------------------ |
| `factor_arr`      | array | 二维数字数组类型，因子得分矩阵       |
| `max_eigen_value` | array | 二维数字数组类型，主因子对应的特征根 |

返回：array

### 示例

```tsl
// 设置样本矩阵
zt := array((0.7592, 1.7593, 21.9279, 48.5626, 55.1679),
(0.0490, 0.4457, 2.2255, 82.2658, 192.4348),
(-2.2313, -1.3096, -59.8883, 3.9922, -80.2419),
(0.1364, 0.539, 4.3910, 55.1438, 46.0612),
(0.7233, 1.9467, 15.6127, 111.3018, 58.3969));
z_t_s := Standarize_II(z_t); // 标准化
mt_Transposition(z_t_s, z); // 转置
r := correlationMatrix(z); // 相关系数矩阵
Eigen_Jacobi(r, eigen_value, eigen_vector); // 特征值&特征向量
cm := componentMatrix(eigen_value, eigen_vector, max_eigen_value); // 载荷矩阵
cs := componentScoreMatrix(cm, r); // 因子得分系数矩阵
f_arr := factorScoreMatrix(cs, z_t_s); // 样本公共因子得分
return fScoreResult(f_arr, max_eigen_value);
// 输出：
// 示例包含说明文字，未作为可执行片段运行。
```

## `ar(y, p, approach)`

自回归模型，AR(p)模型，选择使用最小二乘，Yule-Walker方法，Foiward-backward,Geometric lattice,Burg’s lattice-bas去估计p阶自回归模型的系数，返回结果有自回归系数、残差方差、预测值及预测波动等信息

| 参数       | 类型          | 说明                                     |
| ---------- | ------------- | ---------------------------------------- |
| `y`        | array of real | 样本序列，为一维数组类型，注意要零均值化 |
| `p`        | integer       | 自回归阶数                               |
| `approach` | string        | 估计方法                                 |

返回：array

### 示例

```tsl
elps := randnorm(0, 1, 200);
y := array();
y[0] := 0;
y[1] := 0;
for i := 2 to 199 do
y[i] := -0.5 * y[i-1]+0.3 * y[i-2]+elps[i];
return ar(y, 2, 'ls');
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:usercall: function:randnorm compile error or not found
// function:__main__:line 1:instruction:usercall: function execute error
```

## `garchFit(model_spec, y, x, e0, s0, y0)`

广义自回归条件异方差模型，采用极大似然估计方法估计模型的参数

| 参数         | 类型  | 说明                                                   |
| ------------ | ----- | ------------------------------------------------------ |
| `model_spec` | array | 模型设置项，为数据表类型，参考:表8-5                   |
| `y`          | array | 原始数据，一维数字数组                                 |
| `x`          | array | 均值方程回归外生变量，二维数字数组，可缺省             |
| `e0`         | array | 自回归方程残差序列起始的几项取值，一维数字数组，可缺省 |
| `s0`         | array | 条件方程方差序列起始的几项取值，一维数字数组，可缺省   |
| `y0`         | array | 原始序列起始的几项取值，一维数字数组，可缺省           |

返回：array

### 示例

```tsl
// 以1995年1月至2000年8月日元兑换美元汇率值序列（JPY，如图8-9）为例介绍怎样用天软来进行ARCH建模（序列共1427个值）。
// 图8-9日元兑换美元汇率值(JPY)序列图8-10DJPY时间序列
JPY序列显然是一个非平稳时间序列，对JPY进行差分，DJPY表示收益，见图8-10，因为DJPY是一个平稳时间序列，应该使用DJPY建立时间序列模型。按照ARMA模型中讲的那样对DJPY拟合ARMA模型，根据自相关系数以及偏自相关系数，AIC准则等，我们最终将模型定为AR(3)模型。
d_jpy := diff(jpy);
m := mean(d_jpy);
d_jpy := d_jpy-m;
ret := arma(d_jpy, 3, 0);
// 得到的结果是：
// 图8-11 AR(3)残差
// 该模型的残差如图8-11所示，我们怀疑残差含有异方差，使用Time_ARCHTest函数检验。
Time_ARCHTest(ret["e"], 1, 0.05);
// 图8-12 AR(3)残差
// 拒绝原假设，认为模型含有异方差，建立ARCH模型，首先建立ARCH(7)模型(尝试多次，最大滞后选为7为宜)。
// 图8-13ARCH模型结果图8-14异方差估计情况
modelspec := array(
("R": 3,
"M": 0,
"AR": nil,
"MA": nil,
"Regress": nil,
"VarianceModel": "GARCH",
"C": nan,
"P": 0,
"Q": 7,
"GARCH": array(),
"ARCH": array(),
"Leverage": nil));
t := garchFit(model_spec, d_jpy);
// 得到的异方差如图8-14。ARCH模型中的的滞后项太多，应该尝试建立GARCH(1, 1)模型：
modelspec := array(
("R": 3,
"M": 0,
"AR": nil,
"MA": nil,
"Regress": nil,
"VarianceModel": "GARCH",
"C": nan,
"P": 1,
"Q": 1,
"GARCH": array(),
"ARCH": array(),
"Leverage": nil));
t := garchFit(model_spec, d_jpy);
// 图8-15GARCH模型结果图8-16方差估计情况
```

## `wavedec(x, n, wname)`

使用给定的小波wname进行一维多尺度离散小波分析，返回信号xin在n层上的小波分解。输出分解结构包含小波分解向量C和相应的记录向量L.

| 参数    | 类型    | 说明                     |
| ------- | ------- | ------------------------ |
| `x`     | array   | 一维序列，一维数字数组   |
| `n`     | integer | 小波分解层数，正整数     |
| `wname` | string  | 基础小波函数，字符串类型 |

返回：array

### 示例

```tsl
setSysParam(PN_Stock(), "SH000300");
setSysParam(pn_date(), intToDate(20120731));
close300 := nDay(800, "时间", dateTimeToStr(sp_time(1)), "收盘价", close());
close3 := close300[: , "收盘价"];
return wave := wavedec(close3, 3, "db3");
// 输出：结果格式：
// 第一行是小波分解向量C，第二行是相应的记录向量L
// 下面我们从图像来直接看看小波分解：
// 原始序列:
// 原始序列可分解成：
```

## `wrcoef(o, c, l, wname, n)`

一维离散小波单支重构，小波分析，小波重构中间函数或者细节系数（高频）提取

| 参数    | 类型    | 说明                                                          |
| ------- | ------- | ------------------------------------------------------------- |
| `o`     | string  | 为字符串类型，'a' 一维离散小波单支重构，'d' 细节系数提取      |
| `c`     | array   | 小波分解向量C，数组类型，参考[Wavedec]函数的输出              |
| `l`     | array   | 相应的记录向量L，数组类型，参考[Wavedec]函数的输出            |
| `wname` | string  | 基础小波函数，字符串类型,取值参考[Wavedec]函数的wname输入参数 |
| `n`     | integer | 小波分解层数，正整数                                          |

返回：array

### 示例

```tsl
setSysParam(PN_Stock(), "SH000300");
setSysParam(pn_date(), intToDate(20120731));
close300 := nDay(800, "时间", dateTimeToStr(sp_time(1)), "收盘价", close());
close3 := close300[: , "收盘价"];
wave := wavedec(close3, 3, "db3");
c := wave[0];
l := wave[1];
return wrcoef('a', c, l, 'db3', 3); // 去除前3层高频谐波
// Return wrcoef('d',c,l,'db3',3);//第3次分解得到的高频
// 输出：
// 去除前3层高频谐波
return wrcoef('d', c, l, wname, 3); // 第三次分解得到的高频
```

## `wavelet(s, wname, n, options)`

一维序列小波消噪

| 参数      | 类型    | 说明                                                          |
| --------- | ------- | ------------------------------------------------------------- |
| `s`       | array   | 一维序列，一维数字数组                                        |
| `wname`   | string  | 基础小波函数，字符串类型,取值参考[Wavedec]函数的wname输入参数 |
| `n`       | integer | 小波分解层数，正整数                                          |
| `options` | array   | 方法选项                                                      |

返回：array

### 示例

```tsl
s := array(2484.83, 2479.05, 2482.34, 2437.79, 2447.75, 2512.96, 2443.06, 2433.16, 2393.18, 2415.05, 2392.06, 2365.34, 2359.22, 2344.79, 2348.52, 2420.00, 2438.79, 2431.38, 2440.4, 2383.49, 2377.51, 2331.37, 2317.27, 2370.33, 2409.67, 2427.48, 2435.61, 2473.41, 2468.25, 2470.02, 2504.11, 2508.09, 2528.29, 2509.8, 2503.84, 2524.92, 2479.54, 2481.08, 2528.71, 2529.76, 2466.96, 2463.05, 2416.56, 2415.13, 2412.62, 2395.06, 2397.55, 2380.22, 2383.03, 2412.39, 2333.41, 2386.86, 2360.66, 2333.23, 2325.91, 2332.73, 2329.82, 2315.27, 2291.54, 2248.59, 2228.52, 2180.9, 2224.84, 2218.24, 2215.93, 2191.15, 2186.3, 2204.78, 2190.11, 2166.21, 2170.01, 2173.56, 2199.42, 2169.39, 2148.45, 2163.4, 2225.89, 2285.74, 2276.05, 2275.01, 2244.58, 2206.19, 2298.38, 2266.38, 2296.07, 2319.12, 2285.04, 2292.61, 2268.08, 2312.56, 2330.41, 2331.14, 2291.9, 2347.53, 2349.59, 2351.98, 2351.85, 2344.77, 2366.7, 2356.86, 2357.18, 2363.6, 2381.43, 2403.59, 2409.55, 2439.63, 2447.06, 2451.86, 2428.49, 2426.11, 2460.69);
n := 2;
wname := "db14";
options := array('brief': 1, 'sigma': 0, 'which': 1, 'alpha': 2, "thr": 0, 'sorh': 's');
return s|wavelet(s, wname, n, options);
// 消噪和原始数据对比：
```

## `accumulativeYtMtoYtm(t, fname, dw)`

复合益率转日收益率。

| 参数    | 类型    | 说明                               |
| ------- | ------- | ---------------------------------- |
| `t`     | array   | 数据表类型，复合收益率序列         |
| `fname` | string  | 字符串，收益字段名称               |
| `dw`    | integer | 整数，决定源数据的单位和返回的数据 |

返回：array

### 示例

```tsl
// 源数据单位为1,设dw=2,同时返回复合收益率和转换后的日收益率
t1 := array(('日期': 20180801T, '复合收益率': 0.1),
('日期': 20180802T, '复合收益率': 0.4),
('日期': 20180803T, '复合收益率': 0.7));
r1 := accumulativeYtMtoYtm(t1, '复合收益率', 2);
// 源数据单位为%,设dw=3,同时返回复合收益率和转换后的日收益率
t2 := array(('日期': 20180801T, '复合收益率(%)': 10),
('日期': 20180802T, '复合收益率(%)': 40),
('日期': 20180803T, '复合收益率(%)': 70));
r2 := accumulativeYtMtoYtm(t2, '复合收益率(%)', 3);
return r1|r2;
// 输出：返回：
```

## `ytmToAccumulativeYtm(t, f_name, dw)`

日收益率转换复合收益率。

| 参数     | 类型    | 说明                               |
| -------- | ------- | ---------------------------------- |
| `t`      | array   | 数组。日收益率序列                 |
| `f_name` | string  | 字符串。收益字段名称               |
| `dw`     | integer | 整数。决定源数据的单位和返回的数据 |

返回：array|real

### 示例

范例01：

```tsl
// 源数据单位为1,dw=2,同时返回日收益率和转换后的复合收益率
t1 := array(('日期': 20180801T, '日收益率': 0.3),
('日期': 20180802T, '日收益率': 0.6),
('日期': 20180803T, '日收益率': 0.9));
r1 := ytmToAccumulativeYtm(t1, '日收益率', 2, 0);
// 源数据单位为%,dw=3,同时返回日收益率和转换后的复合收益率
t2 := array(('日期': 20180801T, '日收益率(%)': 30),
('日期': 20180802T, '日收益率(%)': 60),
('日期': 20180803T, '日收益率(%)': 90));
r2 := ytmToAccumulativeYtm(t2, '日收益率(%)', 3, 0);
return r1|r2;
// 输出：
// 示例包含说明文字，未作为可执行片段运行。
```

范例2：

```tsl
// 计算基金OF000009易方达天天理财A的累计收益率(%)
setSysParam(PN_Stock(), "OF000009");
t := array(('日期': 20150104T, '每万份基金单位收益': 4.3769),
('日期': 20150105T, '每万份基金单位收益': 1.2507),
('日期': 20150106T, '每万份基金单位收益': 1.4671));
r := ytmToAccumulativeYtm(t, '每万份基金单位收益', 5, 0);
return r;
// 输出：
// Execute script error at Line:6
// function:__main__:line 6:instruction:usercall: function:ytmToAccumulativeYtm compile error or not found
// function:__main__:line 6:instruction:usercall: function execute error
```

## `ratioValue(v1, v2)`

比率（财务分析）

| 参数 | 类型 | 说明         |
| ---- | ---- | ------------ |
| `v1` | real | 实型，期末值 |
| `v2` | real | 实型，期初值 |

返回：real

### 示例

```tsl
// 返回-1与-2的比率。
return ratioValue(-1, -2);
// 结果：-0.5
```

## `outPutValueByUnit(data_type, data_unit)`

单位转换。

| 参数        | 类型   | 说明             |
| ----------- | ------ | ---------------- |
| `data_type` | string | 字符串，数据类型 |
| `data_unit` | real   | 实型，指定单位   |

返回：real

### 示例

```tsl
// 返回1234.5以10为单位转换后的结果
return outPutValueByUnit(1234.5, 'Real', 10);
// 结果：123.45
```

## `outPutLnGrowRatio(v1, v2)`

对数增长率输出(%)。

| 参数 | 类型 | 说明         |
| ---- | ---- | ------------ |
| `v1` | real | 实型，期末值 |
| `v2` | real | 实型，期初值 |

返回：real

### 示例

```tsl
// 取3与4的对数增长率
return outPutLnGrowRatio(3, 4);
// 结果：-28.77
```

## `outPutGrowValue(v1, v2)`

增长

| 参数 | 类型 | 说明         |
| ---- | ---- | ------------ |
| `v1` | real | 实型，期末值 |
| `v2` | real | 实型，期初值 |

返回：real

### 示例

```tsl
// 返回13与14的差值
return outPutGrowValue(13, 14);
// 结果：-1
```

## `multyValue(v1, v2)`

乘法（财务分析）

| 参数 | 类型 | 说明         |
| ---- | ---- | ------------ |
| `v1` | real | 实型，期末值 |
| `v2` | real | 实型，期初值 |

返回：real

### 示例

```tsl
// 返回取-3与-5的乘积。
return multyValue(-3, -5);
// 结果：-15
```

## `outPutGrowValue3(v1, v2)`

增长

| 参数 | 类型 | 说明         |
| ---- | ---- | ------------ |
| `v1` | real | 实型，期末值 |
| `v2` | real | 实型，期初值 |

返回：real

### 示例

```tsl
// 返回13与14的差值
return outPutGrowValue3(13, 14);
// 结果：-1
```

## `outPutGrowRatio3(v1, v2)`

增长率(%)

| 参数 | 类型 | 说明         |
| ---- | ---- | ------------ |
| `v1` | real | 实型，期末值 |
| `v2` | real | 实型，期初值 |

返回：real

### 示例

```tsl
// 返回14到13的增长率(%)
return outPutGrowRatio3(14, 13);
// 结果：7.69
```