# 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
```