# Builtin - 数值方法

## `all(data, n)`

声明：function

所有为真，判断任意值或数组或数组其行列数据的真假，集合中只要有一个元素为假则为假。

| 参数   | 类型    | 说明                                                                      |
| ------ | ------- | ------------------------------------------------------------------------- |
| `data` | any     | 当N缺省或取默认值0时，可以为任意数据，否则只能是数组。                    |
| `n`    | integer | 若值为0，则对Data整体判断，如果Data是数组，则对所有元素进行判断，缺省值。 |

返回：real/table

### 示例

范例一：

```tsl
// 判断数组中所有元素是否都为真
echo all(array(1, 2, -1, 1, 9));
// 输出：1
```

范例二：

```tsl
// 判断特殊数据类型的真假
echo trim(toStn(all(array(1, '', ' ', nan, nil, inf, -inf, array()), 1)));
// 输出：array(1,0,1,1,0,1,1,1)
```

范例三：

```tsl
// 判断二维数组的行
f := array('e': ('A': 1, 'B': 0), 'f': ('A': 2, 'B': 3), 'd': ('A': 3, 'B': nil));
echo trim(toStn(all(f, 1)));
// 输出：array("e":0,"f":1,"d":0)
```

范例四：

```tsl
// 判断多维数组的行
t := array('e': ('A': 1, 'B': 1), 'f': ('A': 2, 'B': array(1, 0)));
echo trim(toStn(all(t, 1)));
// 输出：array("e":1,"f":0)
```

范例五：

```tsl
// 判断多维数组的列
t := array('e': ('A': 1, 'B': 1), 'f': ('A': 2, 'B': array(1, 0)));
echo trim(toStn(all(t, 2)));
// 输出：array("A":1,"B":0)
```

## `any(data, n)`

声明：function

判断任意值或数组或数组其行列数据的真假，集合中只要有一个元素是真则为真。

| 参数   | 类型    | 说明                                                                    |
| ------ | ------- | ----------------------------------------------------------------------- |
| `data` | any     | 当N缺省或取默认值0时，可以为任意数据，否则只能是数组。                  |
| `n`    | integer | 若取值0，对Data整体判断，如果Data是数组，则对所有元素进行判断，缺省值。 |

返回：real/table

### 示例

范例一：

```tsl
// 判断非数组的真假
echo any('a', 0);
// 输出：1
```

范例二：

```tsl
// 判断特殊数据类型的真假
echo trim(toStn(any(array(1, '', ' ', nan, nil, inf, -inf, array()), 1)));
// 输出：array(1,0,1,1,0,1,1,0)
```

范例三：

```tsl
// 判断二维数组的行
f := array('e': ('A': 1, 'B': 0), 'f': ('A': 2, 'B': ''), 'd': ('A': 3, 'B': nil));
echo trim(toStn(any(f, 1)));
// 输出：array("e":1,"f":1,"d":1)
```

范例四：

```tsl
// 判断多维数组的行
t := array('e': ('A': 0, 'B': 0), 'f': ('A': 2, 'B': array(1, 0)));
echo trim(toStn(any(t, 1)));
// 输出：array("e":0,"f":1)
```

范例五：

```tsl
// 判断多维数组的列
t := array('e': ('A': 1, 'B': 1), 'f': ('A': 2, 'B': array(1, 0)));
echo trim(toStn(any(t, 2)));
// 输出：array("A":1,"B":1)
```

## `conv(a, b)`

声明：function

计算输入序列A、B的卷积

| 参数 | 类型  | 说明         |
| ---- | ----- | ------------ |
| `a`  | array | 一维数字数组 |
| `b`  | array | 一维数字数组 |

返回：array

### 示例

```tsl
a := array(0.4044, 0.32362, 0.38548, 0.17435, 0.08502, 0.41899, 0.02551, 0.46226);
b := array(0.82284, 0.7466, 0.17411, 0.85894, 0.7105, 0.51353, 0.30399, 0.01498, 0.0914, 0.36445, 0.14731, 0.1659, 0.98853, 0.44569, 0.11908);
echo trim(toStn(conv(a, b)));
// 输出：array(0.332756496,0.5682125208,0.6292131392,0.8349623362,0.8325398524,1.2073014753,1.0613732782,0.9716555873,1.018384851,0.6794859585,0.8715477319,0.7413644482,0.8329634672,0.7999655273,0.7768548297,0.5100653747,0.4493928066,0.5451659761,0.298770169,0.5182207589,0.2090623902,0.0550459208)
```

## `ig_Chebyshev(a, b, call_back, v)`

声明：function

用切比雪夫求积法计算定积分。

| 参数        | 类型   | 说明                       |
| ----------- | ------ | -------------------------- |
| `a`         | float  | 积分下限                   |
| `b`         | float  | 积分上限                   |
| `call_back` | string | 计算被积函数值的回调函数名 |
| `v`         | float  | 写回积分结果               |

返回：integer

### 示例

```tsl
a := 1;
b := 3;
callback := "linearValue";
ig_Chebyshev(a, b, callback, value);
echo value;
// 输出：10

function linearValue(x);
begin
    return 2 * x + 1;
end;
```

## `ig_Gauss(a, b, call_back, v)`

声明：function

用高斯求积法计算定积分。

| 参数        | 类型   | 说明                       |
| ----------- | ------ | -------------------------- |
| `a`         | float  | 积分下限                   |
| `b`         | float  | 积分上限                   |
| `call_back` | string | 计算被积函数值的回调函数名 |
| `v`         | float  | 写回积分结果               |

返回：integer

### 示例

```tsl
a := 1;
b := 3;
callback := "linearValue";
ig_Gauss(a, b, callback, value);
echo value;
// 输出：10.0000000005

function linearValue(x);
begin
    return 2 * x + 1;
end;
```

## `ig_Romberg(a, b, call_back, v)`

声明：function

用龙贝格(Romberg)求积法计算定积分，

| 参数        | 类型   | 说明                     |
| ----------- | ------ | ------------------------ |
| `a`         | float  | 实型变量。积分下限       |
| `b`         | float  | 实型变量。积分上限       |
| `call_back` | string | 计算被积函数值的回调     |
| `v`         | float  | 实型变量，返回的积分结果 |

返回：integer

### 示例

```tsl
a := 1;
b := 3;
callback := "linearValue";
ig_Romberg(a, b, callback, value);
echo value;
// 输出：10

function linearValue(x);
begin
    return 2 * x + 1;
end;
```

## `ig_Simpson_1(a, b, call_back, v)`

声明：function

用变步长辛普森(Simpson)计算定积分

| 参数        | 类型   | 说明                     |
| ----------- | ------ | ------------------------ |
| `a`         | float  | 实型变量。积分下限       |
| `b`         | float  | 实型变量。积分上限       |
| `call_back` | string | 计算被积函数值的回调     |
| `v`         | float  | 实型变量，返回的积分结果 |

返回：integer

### 示例

```tsl
a := 1;
b := 3;
callback := "linearValue";
ig_Simpson_1(a, b, callback, value);
echo value;
// 输出：10

function linearValue(x);
begin
    return 2 * x + 1;
end;
```

## `ig_Simpson_2(a, b, call_back1, call_back2, call_back3, v)`

声明：function

用变步长辛普森(Simpson)计算二重积分

| 参数         | 类型   | 说明                           |
| ------------ | ------ | ------------------------------ |
| `a`          | float  | 实型变量。积分下限             |
| `b`          | float  | 实型变量。积分上限             |
| `call_back1` | string | 计算积分下限的回调             |
| `call_back2` | string | 计算积分上限的回调             |
| `call_back3` | string | 计算被积函数f(x,y)函数值的回调 |
| `v`          | float  | 实型变量，返回的积分结果       |

返回：integer

### 示例

```tsl
a := 1;
b := 2;
lower_callback := "lowerBound";
upper_callback := "upperBound";
value_callback := "integrand";
ig_Simpson_2(a, b, lower_callback, upper_callback, value_callback, value);
echo value;
// 输出：4.66666666666667

function lowerBound(x);
begin
    return -x;
end;

function upperBound(x);
begin
    return x;
end;

function integrand(x, y);
begin
    return x + 2 * y;
end;
```

## `ig_Trapezoid_1(a, b, call_back, v)`

声明：function

用变步长梯形求积法计算定积分

| 参数        | 类型   | 说明                     |
| ----------- | ------ | ------------------------ |
| `a`         | float  | 实型变量。积分下限       |
| `b`         | float  | 实型变量。积分上限       |
| `call_back` | string | 计算被积函数值的回调     |
| `v`         | float  | 实型变量，返回的积分结果 |

返回：integer

### 示例

```tsl
a := 1;
b := 3;
callback := "linearValue";
ig_Trapezoid_1(a, b, callback, value);
echo value;
// 输出：10

function linearValue(x);
begin
    return 2 * x + 1;
end;
```

## `ig_Trapezoid_2(a, b, call_back, v)`

声明：function

用自适应梯形求积法计算定积分

| 参数        | 类型   | 说明                     |
| ----------- | ------ | ------------------------ |
| `a`         | float  | 实型变量。积分下限       |
| `b`         | float  | 实型变量。积分上限       |
| `call_back` | string | 计算被积函数值的回调     |
| `v`         | float  | 实型变量，返回的积分结果 |

返回：integer

### 示例

```tsl
a := 1;
b := 3;
callback := "linearValue";
ig_Trapezoid_2(a, b, callback, value);
echo value;
// 输出：10

function linearValue(x);
begin
    return 2 * x + 1;
end;
```

## `ip_Aitken_A(x, y, xv, yv)`

声明：function

用埃特金逐步插值法，根据不等距节点计算指定插值点的函数值。

| 参数 | 类型          | 说明                 |
| ---- | ------------- | -------------------- |
| `x`  | array of real | 严格递增的不等距节点 |
| `y`  | array of real | 各节点的函数值       |
| `xv` | float         | 插值点               |
| `yv` | float         | 写回插值结果         |

返回：integer

### 示例

```tsl
x := array(1, 1.2, 1.5, 2.3, 2.9, 4, 4.5, 8);
y := array(1, 3, 4, 7, 9, 13, 15, 20);
ip_Aitken_A(x, y, 3, value);
echo value;
// 输出：9.3291726257716
```

## `ip_Aitken_B(x0, h, y, xv, yv)`

声明：function

用埃特金逐步插值法，根据等距节点计算指定插值点的函数值。

| 参数 | 类型          | 说明           |
| ---- | ------------- | -------------- |
| `x0` | float         | 第一个节点     |
| `h`  | float         | 节点步长       |
| `y`  | array of real | 各节点的函数值 |
| `xv` | float         | 插值点         |
| `yv` | float         | 写回插值结果   |

返回：integer

### 示例

```tsl
y := array(1, 3, 4, 6, 9, 11, 13);
ip_Aitken_B(1.3, 0.5, y, 3, value);
echo value;
// 输出：7.08
```

## `ip_Hermite_A(x, y, dy, xv, yv)`

声明：function

用埃尔米特插值法，根据不等距节点及其一阶导数计算指定插值点的函数值。

| 参数 | 类型          | 说明                 |
| ---- | ------------- | -------------------- |
| `x`  | array of real | 严格递增的不等距节点 |
| `y`  | array of real | 各节点的函数值       |
| `dy` | array of real | 各节点的一阶导数     |
| `xv` | float         | 插值点               |
| `yv` | float         | 写回插值结果         |

返回：integer

### 示例

```tsl
x := array(1, 1.2, 1.5, 2.3, 2.9, 4, 4.5, 8);
y := x ^ 2 - x;
dy := 2 * x - 1;
ip_Hermite_A(x, y, dy, 3, value);
echo value;
// 输出：6
```

## `ip_Hermite_B(x0, h, y, dy, xv, yv)`

声明：function

用埃尔米特插值法，根据等距节点及其一阶导数计算指定插值点的函数值。

| 参数 | 类型          | 说明             |
| ---- | ------------- | ---------------- |
| `x0` | float         | 第一个节点       |
| `h`  | float         | 节点步长         |
| `y`  | array of real | 各节点的函数值   |
| `dy` | array of real | 各节点的一阶导数 |
| `xv` | float         | 插值点           |
| `yv` | float         | 写回插值结果     |

返回：integer

### 示例

```tsl
y := array(0, 2, 6, 12, 20, 30);
dy := array(1, 3, 5, 7, 9, 11);
ip_Hermite_B(1, 1, y, dy, 4.5, value);
echo value;
// 输出：15.75
```

## `ip_Lagrangian_A(x, y, xv, yv)`

声明：function

用拉格朗日插值法，根据不等距节点计算指定插值点的函数值。

| 参数 | 类型          | 说明                 |
| ---- | ------------- | -------------------- |
| `x`  | array of real | 严格递增的不等距节点 |
| `y`  | array of real | 各节点的函数值       |
| `xv` | float         | 插值点               |
| `yv` | float         | 写回插值结果         |

返回：integer

### 示例

```tsl
x := array(1, 1.2, 1.5, 2.3, 2.9, 4, 4.5, 8);
y := x ^ 2 - x;
ip_Lagrangian_A(x, y, 3, value);
echo value;
// 输出：6
```

## `ip_Lagrangian_B(x0, h, y, xv, yv)`

声明：function

用拉格朗日插值法，根据等距节点计算指定插值点的函数值。

| 参数 | 类型          | 说明           |
| ---- | ------------- | -------------- |
| `x0` | float         | 第一个节点     |
| `h`  | float         | 节点步长       |
| `y`  | array of real | 各节点的函数值 |
| `xv` | float         | 插值点         |
| `yv` | float         | 写回插值结果   |

返回：integer

### 示例

```tsl
y := array(1, 3, 4, 6, 9, 11, 13);
ip_Lagrangian_B(1.3, 0.5, y, 3, value);
echo value;
// 输出：7.177664
```

## `ip_Parabola_A(x, y, xv, yv)`

声明：function

用抛物线插值法，根据不等距节点计算指定插值点的函数值。

| 参数 | 类型          | 说明                 |
| ---- | ------------- | -------------------- |
| `x`  | array of real | 严格递增的不等距节点 |
| `y`  | array of real | 各节点的函数值       |
| `xv` | float         | 插值点               |
| `yv` | float         | 写回插值结果         |

返回：integer

### 示例

```tsl
x := array(1, 1.2, 1.5, 2.3, 2.9, 4, 4.5, 8);
y := array(1, 3, 4, 7, 9, 13, 15, 20);
ip_Parabola_A(x, y, 3, value);
echo value;
// 输出：9.3458110516934
```

## `ip_Parabola_B(x0, h, y, xv, yv)`

声明：function

用抛物线插值法，根据等距节点计算指定插值点的函数值。

| 参数 | 类型          | 说明           |
| ---- | ------------- | -------------- |
| `x0` | float         | 第一个节点     |
| `h`  | float         | 节点步长       |
| `y`  | array of real | 各节点的函数值 |
| `xv` | float         | 插值点         |
| `yv` | float         | 写回插值结果   |

返回：integer

### 示例

```tsl
y := array(1, 3, 4, 6, 9, 11, 13);
ip_Parabola_B(1.3, 0.5, y, 3, value);
echo value;
// 输出：7.08
```

## `ip_SLG(x, y, z, xv, yv, zv)`

声明：function

根据给定矩形域上的nXm个结点（i=0,1…..n-1；j = 0 , 1, ….., m-1）上的函数值Zij = Z(Xi,Yj)，利用二元插值公式计算指定插值点（u,v）处的函数值w=Z(u,v)

| 参数 | 类型  | 说明                                                                        |
| ---- | ----- | --------------------------------------------------------------------------- |
| `x`  | array | 实型一维数组，长度为N。存放给定nXm个点的X方向上的n个坐标，要求X0<X1...<Xn-1 |
| `y`  | array | 实型一维数组，长度为N。存放给定nXm个点的X方向上的m个坐标，要求Y0<Y1...<Ym-1 |
| `z`  | array | 实型二维数组，体积为为nXm。存放给定nXm个点上的函数值                        |
| `xv` | float | 实型变量，插值点的X坐标                                                     |
| `yv` | float | 实型变量，插值点的Y坐标                                                     |
| `zv` | float | 实型变量，返回的插值结果                                                    |

返回：integer

### 示例

```tsl
x := array(1, 2, 3, 4);
y := array(1, 2, 3);
z := array(
    (4, 6, 8),
    (6, 9, 10),
    (11, 20, 25),
    (14, 24, 30)
);
x_value := 3.5;
y_value := 4.5;
ip_SLG(x, y, z, x_value, y_value, z_value);
echo z_value;
// 输出：31.546875
```

## `ip_SLQ(x, y, z, xv, yv, zv)`

声明：function

根据给定矩形域上的nXm个结点（i=0,1…..n-1；j = 0 , 1, ….., m-1）上的函数值Zij = Z(Xi,Yj)，利用二元三点插值公式计算指定插值点（u,v）处的函数值w=Z(u,v)

| 参数 | 类型  | 说明                                                                        |
| ---- | ----- | --------------------------------------------------------------------------- |
| `x`  | array | 实型一维数组，长度为N。存放给定nXm个点的X方向上的n个坐标，要求X0<X1...<Xn-1 |
| `y`  | array | 实型一维数组，长度为N。存放给定nXm个点的X方向上的m个坐标，要求Y0<Y1...<Ym-1 |
| `z`  | array | 实型二维数组，体积为为nXm。存放给定nXm个点上的函数值                        |
| `xv` | float | 实型变量，插值点的X坐标                                                     |
| `yv` | float | 实型变量，插值点的Y坐标                                                     |
| `zv` | float | 实型变量，返回的插值结果                                                    |

返回：integer

### 示例

```tsl
x := array(1, 2, 3, 4);
y := array(1, 2, 3);
z := array(
    (4, 6, 8),
    (6, 9, 10),
    (11, 20, 25),
    (14, 24, 30)
);
x_value := 3.5;
y_value := 4.5;
ip_SLQ(x, y, z, x_value, y_value, z_value);
echo z_value;
// 输出：29.59375
```

## `ip_Spline_A(x, y, dy0, dyn_1, xv, yv)`

声明：function

使用第一类边界条件进行三次样条插值。

| 参数    | 类型          | 说明                   |
| ------- | ------------- | ---------------------- |
| `x`     | array of real | 严格递增的节点         |
| `y`     | array of real | 各节点的函数值         |
| `dy0`   | float         | 第一个节点的一阶导数   |
| `dyn_1` | float         | 最后一个节点的一阶导数 |
| `xv`    | float         | 插值点                 |
| `yv`    | float         | 写回插值结果           |

返回：integer

### 示例

```tsl
x := array(1, 2, 3, 4, 5, 6);
y := array(0, 2, 6, 12, 20, 30);
ip_Spline_A(x, y, 1, 11, 4.5, value);
echo value;
// 输出：15.75
```

## `ip_Spline_B(x, y, ddy0, ddyn_1, xv, yv)`

声明：function

使用第二类边界条件进行三次样条插值。

| 参数     | 类型          | 说明                   |
| -------- | ------------- | ---------------------- |
| `x`      | array of real | 严格递增的节点         |
| `y`      | array of real | 各节点的函数值         |
| `ddy0`   | float         | 第一个节点的二阶导数   |
| `ddyn_1` | float         | 最后一个节点的二阶导数 |
| `xv`     | float         | 插值点                 |
| `yv`     | float         | 写回插值结果           |

返回：integer

### 示例

```tsl
x := array(1, 2, 3, 4, 5, 6);
y := array(0, 2, 6, 12, 20, 30);
ip_Spline_B(x, y, 2, 2, 4.5, value);
echo value;
// 输出：15.2828038674033
```

## `ip_Spline_C(x, y, xv, yv)`

声明：function

使用第三类边界条件进行三次样条插值。

| 参数 | 类型          | 说明           |
| ---- | ------------- | -------------- |
| `x`  | array of real | 严格递增的节点 |
| `y`  | array of real | 各节点的函数值 |
| `xv` | float         | 插值点         |
| `yv` | float         | 写回插值结果   |

返回：integer

### 示例

```tsl
x := array(1, 2, 3, 4, 5, 6);
y := array(2, 6, 3, 0, 3, 2);
ip_Spline_C(x, y, 3.5, value);
echo value;
// 输出：0.715909090909091
```

## `se_Cholesky(a, b, x)`

声明：function

用乔列斯基(Cholesky)分解法（即平方根法）求解系数矩阵为对称正定、且右端具有m组常数向量的线性方程组AX = B

| 参数 | 类型  | 说明                                                                         |
| ---- | ----- | ---------------------------------------------------------------------------- |
| `a`  | array | 实型二维数组，大小为NN。存放方程组的系数矩阵，此系数矩阵必须为对称矩阵（即） |
| `b`  | array | 实型二维数组，大小为NM。存放方程组右端的常数向量                             |
| `x`  | array | 实型一维数组，大小为NM。返回方程组的解向量                                   |

返回：integer

### 示例

```tsl
a := array(
    (1, 0, 0),
    (0, 2, 0),
    (0, 0, 3)
);
b := array(
    (1, 3),
    (4, 6),
    (9, 9)
);
se_Cholesky(a, b, x);
echo trim(toStn(x));
// 输出：array((1.0,3.0),(2.0,3.0),(3.0,3.0))
```

## `se_Gauss(a, b, x)`

声明：function

用全选主元高斯消去法求解n阶线性方程组AX = B

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `a`  | array |      |
| `b`  | array |      |
| `x`  | array |      |

返回：integer

### 示例

```tsl
a := array(
    (1, 0, 0),
    (0, 2, 0),
    (0, 0, 3)
);
b := array(1, 4, 9);
se_Gauss(a, b, x);
echo trim(toStn(x));
// 输出：array(1.0,2.0,3.0)
```

## `se_Gauss_Jordan(a, b, x)`

声明：function

用全主元高斯-约当(Gauss-Jordan)消去法同时求解系数矩阵相同而常数向量不同的m个n阶线性方程组AX = B

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `a`  | array |      |
| `b`  | array |      |
| `x`  | array |      |

返回：integer

### 示例

```tsl
a := array(
    (1, 0, 0),
    (0, 2, 0),
    (0, 0, 3)
);
b := array(
    (1, 3),
    (4, 6),
    (9, 9)
);
se_Gauss_Jordan(a, b, x);
echo trim(toStn(x));
// 输出：array((1.0,3.0),(2.0,3.0),(3.0,3.0))
```

## `se_Gauss_Seidel(a, b, x)`

声明：function

用高斯-赛德尔迭代法求解系数矩阵具有主元占优的线性方程组AX = B

| 参数 | 类型  | 说明                                       |
| ---- | ----- | ------------------------------------------ |
| `a`  | array | 实型二维数组，NN。存放方程组的系数矩阵     |
| `b`  | array | 实型二维数组，NM。存放方程组右端的常数向量 |
| `x`  | array | 实型一维数组，NM。返回方程组的解向量       |

返回：integer

### 示例

```tsl
a := array(
    (1, 0, 0),
    (0, 2, 0),
    (0, 0, 3)
);
b := array(1, 4, 9);
x := array(0.0, 0.0, 0.0);
se_Gauss_Seidel(a, b, x);
echo trim(toStn(x));
// 输出：array(1.0,2.0,3.0)
```

## `se_Ldl(a, b, x)`

声明：function

用LU分解法求解系数矩阵为对称、右端具有m组常数向量的线性方程组 AX = B

| 参数 | 类型  | 说明                                                                         |
| ---- | ----- | ---------------------------------------------------------------------------- |
| `a`  | array | 实型二维数组，大小为NN。存放方程组的系数矩阵，此系数矩阵必须为对称矩阵（即） |
| `b`  | array | 实型二维数组，大小为NM。存放方程组右端的常数向量                             |
| `x`  | array | 实型一维数组，大小为NM。返回方程组的解向量                                   |

返回：integer

### 示例

```tsl
a := array(
    (1, 0, 0),
    (0, 2, 0),
    (0, 0, 3)
);
b := array(
    (1, 3),
    (4, 6),
    (9, 9)
);
se_Ldl(a, b, x);
echo trim(toStn(x));
// 输出：array((1.0,3.0),(2.0,3.0),(3.0,3.0))
```

## `setSysParams(params)`

声明：function

一次性设置整个系统参数。

| 参数     | 类型  | 说明 |
| -------- | ----- | ---- |
| `params` | array |      |

返回：integer

### 示例

```tsl
s0 := getSysParams();
echo toStn(s0), '\r\n';
r := setSysParams(array("StockID": "SZ000001"));
s1 := getSysParams();
echo r, ':', toStn(s1), '\r\n';
// 输出：
// array()
// 0:
// array()
```