# Builtin - 数学 / 数值方法

## `any(data, n)`

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

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

返回：real/table

### 示例

范例一：

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

范例二：

```tsl
// 判断特殊数据类型的真假
return any(array(1, '', ' ', nan, nil, inf, -inf, array()), 1);
// 结果
```

范例三：

```tsl
// 判断二维数组的行
f := array('e': ('A': 1, 'B': 0), 'f': ('A': 2, 'B': ''), 'd': ('A': 3, 'B': nil));
return any(f, 1);
// 结果：’e’,’f’,’d’为行标，表示该行结果。其中，’d’行中，对集合(3,nil)判断为真，则该行值判断结果为1，’B’列中。
```

范例四：

```tsl
// 判断多维数组的行
t := array('e': ('A': 0, 'B': 0), 'f': ('A': 2, 'B': array(1, 0)));
return any(t, 1);
// 结果：’f’行中对集合(0,array(1,0))->(0,1)->1，则该列结果为1
```

范例五：

```tsl
// 判断多维数组的列
t := array('e': ('A': 1, 'B': 1), 'f': ('A': 2, 'B': array(1, 0)));
return any(t, 2);
// 结果
```

## `all(data, n)`

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

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

返回：real/table

### 示例

范例一：

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

范例二：

```tsl
// 判断特殊数据类型的真假
return all(array(1, '', ' ', nan, nil, inf, -inf, array()), 1);
// 结果
```

范例三：

```tsl
// 判断二维数组的行
f := array('e': ('A': 1, 'B': 0), 'f': ('A': 2, 'B': 3), 'd': ('A': 3, 'B': nil));
return all(f, 1);
// 结果：’e’,’f’,’d’为行标，表示该行判断结果。其中，’d’行中，对集合(3,nil)判断为假，因为其中nil判断为假。
```

范例四：

```tsl
// 判断多维数组的行
t := array('e': ('A': 1, 'B': 1), 'f': ('A': 2, 'B': array(1, 0)));
return all(t, 1);
// 结果：’f’行中对集合(2,array(1,0))->(1,0)->0，则该行结果为0
```

范例五：

```tsl
// 判断多维数组的列
t := array('e': ('A': 1, 'B': 1), 'f': ('A': 2, 'B': array(1, 0)));
return all(t, 2);
// 结果：’B’列中对集合(1,array(1,0))->(1,0)->0，则该行结果为0
```

## `conv(a, b)`

计算输入序列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);
return conv(a, b);
```

## `setSysParams(params)`

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

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

返回：integer

### 示例

```tsl
s0 := getSysParams();
echo toStn(s0), '\r\n';
r := setSysParams(array("StockID": "SZ000001"));
s1 := getSysParams();
echo r, ':', toStn(s1), '\r\n';
// 打印结果：
```

## `SelectStockIndex_Call(stock_arr, beg_t, end_t, select_cond, not_is_sell, sell_cond, not_need_stoped)`

返回选股结果

| 参数              | 类型     | 说明                     |
| ----------------- | -------- | ------------------------ |
| `stock_arr`       | array    | 一维字符串数组，证券代码 |
| `beg_t`           | datetime | 日期型时间，开始选股时间 |
| `end_t`           | datetime | 日期型时间，结束选股时间 |
| `select_cond`     | any      | 布尔表达式，选股条件     |
| `not_is_sell`     | bool     | object                   |
| `sell_cond`       | any      | 布尔表达式，卖出股票条件 |
| `not_need_stoped` | bool     | object                   |

返回：array

## `Demo_ip_Hermite_B()`

ip_Hermite_B()函数教学函数。埃尔米特等距插值，计算给定插值点处的函数值。

返回：float

## `Demo_ip_SLG()`

ip_SLG()函数教学函数。二元全曲间插值，计算给定插值点处的函数值。

返回：float

## `Demo_ip_SLQ()`

ip_SLQ()函数教学函数。二元三点插值，计算给定插值点处的函数值。

返回：float

## `Demo_ip_Aitken_A()`

ip_Aitken_A()函数教学函数。埃特金不等距插值，计算给定插值点处的函数值。

返回：float

## `Demo_ip_Hermite_A()`

ip_Hermite_A()函数教学函数。埃儿米特不等距插值，计算给定插值点处的函数值。

返回：float

## `Demo_ip_Parabola_A()`

ip_Parabola_A()函数教学函数。抛物线不等距插值，计算给定插值点处的函数值。

返回：float

## `Demo_ip_Lagrangian_A()`

ip_Lagrangian_A()函数教学函数。拉格朗日不等距插值，计算给定插值点处的函数值。

返回：float

## `Demo_ip_Spline_A()`

ip_Spline_A ()函数教学函数。第一类边界条件的三次样条插值，计算给定插值点处的函数值。

返回：float

## `Demo_ip_Aitken_B()`

ip_Aitken_B()函数教学函数。埃特金等距插值，计算给定插值点处的函数值。

返回：float

## `Demo_ip_Lagrangian_B()`

ip_Lagrangian_B()函数教学函数。拉格朗日等距插值，计算给定插值点处的函数值。

返回：float

## `Demo_ip_Spline_B()`

ip_Spline_B ()函数教学函数。第二类边界条件的三次样条插值，计算给定插值点处的函数值。

返回：float

## `Demo_ip_Parabola_B()`

ip_Parabola_B ()函数教学函数。抛物线等距插值，计算给定插值点处的函数值。

返回：float

## `Demo_ip_Spline_C()`

ip_Spline_C ()函数教学函数。第三类边界条件的三次样条插值，计算给定插值点处的函数值。

返回：float

## `Demo_ig_Simpson_1()`

ig_Simpson_1()函数教学函数。辛普森求积法回调函数，计算定积分。

返回：float

## `Demo_ig_Romberg()`

ig_Romberg()函数教学函数。龙贝格求积法回调函数，计算定积分。

返回：float

## `Demo_ig_Simpson_2()`

ig_Simpson_2()函数教学函数。辛普森二重积分法回调函数，计算定积分。

返回：float

## `Demo_ig_Trapezoid_2()`

Demo_ig_Trapezoid_2()函数教学函数。自适应梯形求积法回调函数，计算定积分。

返回：float

## `Demo_ig_Chebyshev()`

Demo_ig_Chebyshev()函数教学函数。切比雪夫求积法回调函数，计算定积分。

返回：float

## `Demo_ig_Gauss()`

Demo_ig_Gauss()函数教学函数。高斯求积法回调函数，计算定积分。

返回：float

## `Demo_ig_Trapezoid_1()`

Demo_ig_Trapezoid_1()函数教学函数。变步长梯形求积法回调函数，计算定积分。

返回：float

## `ig_Trapezoid_2CallBack(x)`

自适应梯形求积法回调函数。关于自变量x的函数式，一般作用于定积分计算的被积函数。

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

返回：float

## `ig_Trapezoid_1CallBack(x)`

变步长梯形求积法回调函数。关于自变量x的函数式，一般作用于定积分计算的被积函数。

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

返回：float

## `ig_Simpson_2CallBack2(x)`

辛普森二重积分法积分上限回调函数。关于自变量x的函数式，一般作用于定积分计算的被积函数。

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

返回：float

## `ig_Simpson_1CallBack(x)`

辛普森求积法回调函数。关于自变量x的函数式，一般作用于定积分计算的被积函数。

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

返回：float

## `ig_Simpson_2CallBack1(x)`

辛普森二重积分法积分下限回调函数。关于自变量x的函数式，一般作用于定积分计算的被积函数。

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

返回：float

## `ig_ChebyshevCallBack(x)`

切比雪夫求积法回调函数。关于自变量x的函数式，一般作用于定积分计算的被积函数。

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

返回：float

## `ig_RombergCallBack(x)`

龙贝格求积法回调函数。关于自变量x的函数式，一般作用于定积分计算的被积函数。

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

返回：float

## `ig_GaussCallBack(x)`

高斯求积法回调函数。关于自变量x的函数式，一般作用于定积分计算的被积函数。

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

返回：float

## `ig_Simpson_2CallBack(x, y)`

辛普森二重积分法函数值回调函数。关于自变量x的函数式，一般作用于定积分计算的被积函数。

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `x`  | float | 实数 |
| `y`  | float | 实数 |

返回：float

## `Demo_se_Gauss_Jordan()`

se_Gauss_Jordan()函数教学函数。高斯-约当消去法，用全主元高斯-约当法消去法同时求解系数矩阵相同而常数向量不同的m个n阶线性方程组AX = B，其中A=array((0.2368,0.2471,0.2568,1.2671),(0.1968,0.2071,1.2168,0.2271),(0.1581,1.1675,0.1768,0.1871), (1.1161,0.1254,0.1397,0.1490))，B=array((1.8471),(1.7471),(1.6471),(1.5471))。

返回：any

## `Demo_se_Ldl()`

se_Ldl()函数教学函数。LU分解法，用LU分解法求解系数矩阵为对称、右端具有m组常数向量的线性方程组 AX =B,其A=array((5,7,6,5,1),(7,10,8,7,2),(5,7,9,10,4),(1,2,3,4,5)),B=array((24,96),(34,136),(36,144),(35,140),(15,60));

返回：any

## `Demo_se_Gauss()`

se_Gauss()函数教学函数。高斯消去法，用全选主元高斯消去法求解n阶线性方程组AX = B。其中A=array((0.2368,0.2471,0.2568,1.2671),(0.1968,0.2071,1.2168,0.2271),(0.1581,1.1675,0.1768,0.1871),(1.1161,0.1254,0.1397,0.1490))，B= array(1.8471,1.7471,1.6471,1.5471)

返回：any

## `Demo_se_Gauss_Seidel()`

se_Gauss_Seidel()函数教学函数。高斯-赛德尔迭代法，用高斯-赛德尔迭代法求解系数矩阵具有主元占优的线性方程组AX = B。其中A=array((7,2,1,-2), (9,15,3,-2),(-2,-2,11,5),(1,3,2,13))，B=array(4,7,-1,0)。

返回：any

## `Demo_se_Cholesky()`

se_Cholesky()函数教学函数。乔列斯基分解法，用乔列斯基(Cholesky)分解法(即平方根法)求解系数矩阵为对称正定、且右端具有m组常数向量的线性方程组AX = B。其中A=array((5,7,6,5),(7,10,8,7),(6,8,10,9),(5,7,9,10))，B= array((23,92),(32,128), (33,132), (31,124))。

返回：any

## `GM_Icorr(values, target_index)`

计算灰色关联分析结果。

| 参数           | 类型  | 说明           |
| -------------- | ----- | -------------- |
| `values`       | array | 待分析序列矩阵 |
| `target_index` | any   | 参考序列下标   |

返回：array

## `nchoosek(n, k)`

样本组合

| 参数 | 类型    | 说明               |
| ---- | ------- | ------------------ |
| `n`  | array   | 样本(一维数组)     |
| `k`  | integer | 每组样本数量(整数) |

返回：array

### 示例

```tsl
Returnnchoosek(array('a', 'b', 'c', 'd'), 2);
// 输出：
array(
("d", "c"),
("d", "b"),
("d", "a"),
("c", "b"),
("c", "a"),
("b", "a"))
```

## `betainc(x, a, b, tail)`

不完全贝塔函数

| 参数   | 类型   | 说明                                  |
| ------ | ------ | ------------------------------------- |
| `x`    | array  | (一维数字数组,实数) 变量 要求0<=x<=1; |
| `a`    | float  | float 不完全贝塔函数的参数 要求a>=0;  |
| `b`    | float  | float 不完全贝塔函数的参数 要求b>=0;  |
| `tail` | string | 返回类型                              |

返回：array

### 示例

```tsl
a := 3;
b := 4;
tail := 'upper';
x := rand(10);
return array(betainc(x, a, b), betainc(x, a, b, tail));
// 输出：
// Execute script error at Line:5
// function:__main__:line 5:instruction:usercall: function:betainc compile error or not found
// function:__main__:line 5:instruction:usercall: function execute error
```

## `percentileOfScore(data, score, _type)`

百分位占比(%)

| 参数    | 类型    | 说明             |
| ------- | ------- | ---------------- |
| `data`  | array   | 数组 待处理数据, |
| `score` | float   | float 待排序值,  |
| `_type` | integer | 算法             |

返回：array

### 示例

```tsl
// 去除随机数组的极值
data := array(1, 2, 2, 4);
ret := array();
n := 0;
for i := 0 to 5 do
begin
ret[n, 'score'] := i;
for j, kind in array('rank', 'strict', 'weak', 'mean')do
begin
ret[n, kind] := percentileOfScore(data, i, j);
end
ret[n, 'percenrank'] := percentrank(data, i);
n++;
end;
return ret;
// 输出：
// 示例包含说明文字，未作为可执行片段运行。
```

## `Prog_Q(h, f, a, b, aeq, beq, lower_bounds, upper_bounds)`

求解带线性约束和边界约束的二次规划问题。

| 参数           | 类型  | 说明                   |
| -------------- | ----- | ---------------------- |
| `h`            | array | 二次项系数矩阵         |
| `f`            | array | 一次项系数             |
| `a`            | array | 线性不等式约束左侧矩阵 |
| `b`            | array | 线性不等式约束右侧向量 |
| `aeq`          | array | 线性等式约束左侧矩阵   |
| `beq`          | array | 线性等式约束右侧向量   |
| `lower_bounds` | array | 变量下界               |
| `upper_bounds` | array | 变量上界               |

返回：array

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

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

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

返回：any

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

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

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

返回：any

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

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

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

返回：any

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

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

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

返回：any

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

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

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

返回：any

## `interp(x, y, xi, method)`

分段插值函数，根据给定的数据 x,y 对数据xv进行分段插值,可选择方法

| 参数     | 类型          | 说明                                                          |
| -------- | ------------- | ------------------------------------------------------------- |
| `x`      | array of real | 实型一维数组，长度为N。存放给定N个点的值Xi，要求X0<X1...<Xn-1 |
| `y`      | array of real | 实型一维数组，长度为N。存放N个给定点上的函数值Yi              |
| `xi`     | array of real | 实数或者一维实数数组，存放指定插值点的值                      |
| `method` | string        | 方法选择，具体取值如下:                                       |

返回：array

### 示例

```tsl
x := array(0, 0.01)->1;
y := x^2-x;
xi := array(0.005, 0.01)->1;
yi := interp(x, y, xi, 'spline');
return yi;
// 结果：6
1、"nearest"
x_ := array(5, 1, 19, 8);
y_ := array(2, 3, 1, 7);
xi := array(4, 12);
return interp(x_, y_, xi, "nearest");
// 返回： array(2,7)
2、" linear" 分段线性插值
x_ := array(5, 1, 19, 8);
y_ := array(2, 3, 1, 7);
xi := array(4, 12);
return interp(x_, y_, xi, "linear");
// 返回： array(2.25,4.8182)
3、"spline" 三次样条插值
x_ := array(5, 1, 19, 8);
y_ := array(2, 3, 1, 7);
xi := array(4, 12);
return interp(x_, y_, xi, "spline");
// 返回： array(1.1407,13.9444)
4、"pchip" 分段三次hermite插值
x_ := array(5, 1, 19, 8);
y_ := array(2, 3, 1, 7);
xi := array(4, 12);
return interp(x_, y_, xi, "pchip");
// 返回： array(2.0156,6.7115)
```

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

根据给定矩形域上的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 | 实型变量，返回的插值结果                                                    |

返回：any

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

根据给定矩形域上的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 | 实型变量，返回的插值结果                                                    |

返回：any

## `histc2(a, b)`

记录a中的元素在b中第几个区间的位置

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

返回：array

### 示例

```tsl
uses interp_unit; // 置顶
a := 1->10;
b := 3->7;
return histc2(a, b);
// 返回：array(0,0,1,1,2,3,4,0,0,0)
```

## `chckxy(x, y)`

合并x，y后对x列正序排列。

| 参数 | 类型  | 说明     |
| ---- | ----- | -------- |
| `x`  | array | 一维数组 |
| `y`  | array | 一维数组 |

返回：array

### 示例

```tsl
uses interp_unit; // 置顶
x := array(5, 1, 19, 8);
y := array(2, 3, 1, 7);
chckxy(x, y);
return x | y;
// 输出：
// Execute script error at Line:4
// function:__main__:line 4:instruction:usercall: function:chckxy compile error or not found
// function:__main__:line 4:instruction:usercall: function execute error
```

## `nearest(x, y, xi)`

最邻近插值

| 参数 | 类型  | 说明                |
| ---- | ----- | ------------------- |
| `x`  | array | 一维数组 横坐标序列 |
| `y`  | array | 一维数组 纵坐标序列 |
| `xi` | array | 一维数组 插值点序列 |

返回：array

### 示例

```tsl
uses interp_unit; // 置顶
x := array(5, 1, 19, 8);
y := array(2, 3, 1, 7);
xi := array(4, 12);
return nearest(x, y, xi);
// 返回：array(3,1)
```

## `linear(x, y, xi)`

线性插值

| 参数 | 类型  | 说明                |
| ---- | ----- | ------------------- |
| `x`  | array | 一维数组 横坐标序列 |
| `y`  | array | 一维数组 纵坐标序列 |
| `xi` | array | 一维数组 插值点序列 |

返回：array

### 示例

```tsl
uses interp_unit; // 置顶
x := array(5, 1, 19, 8);
y := array(2, 3, 1, 7);
xi := array(4, 12);
return linear(x, y, xi);
// 返回：array(2.6667,1.7778)
```

## `pchip(x, y, xx)`

分段三次hermite插值

| 参数 | 类型  | 说明                |
| ---- | ----- | ------------------- |
| `x`  | array | 一维数组 横坐标序列 |
| `y`  | array | 一维数组 纵坐标序列 |
| `xx` | array | 一维数组 插值点序列 |

返回：array

### 示例

```tsl
uses interp_unit; // 置顶
x := array(5, 1, 19, 8);
y := array(2, 3, 1, 7);
xx := array(4, 12);
return pchip(x, y, xx);
// 返回：array(3.3403,6.9345)
```

## `pwch(x, y, s, dx, divdif)`

计算下x，y所对应的不同间隔区间。

| 参数     | 类型  | 说明     |
| -------- | ----- | -------- |
| `x`      | array | 一维数组 |
| `y`      | array | 一维数组 |
| `s`      | array | 一维数组 |
| `dx`     | array | 一维数组 |
| `divdif` | array | 一维数组 |

返回：array

## `ppval(pp, xx)`

对插值点列的值数据区间中计算出插值。

| 参数 | 类型  | 说明                            |
| ---- | ----- | ------------------------------- |
| `pp` | array | 二维数组 包含列＂x＂，＂coefs＂ |
| `xx` | array | 一维数组 插值点序列             |

返回：array

## `spline(x1, y1, xx1)`

三次样条插值

| 参数  | 类型  | 说明                    |
| ----- | ----- | ----------------------- |
| `x1`  | array | 一维数字数组 横坐标序列 |
| `y1`  | array | 一维数字数组 纵坐标序列 |
| `xx1` | array | 实数或一维数字数组 插值 |

返回：array

### 示例

```tsl
x := array(5, 1, 19, 8);
y := array(2, 3, 1, 7);
xx := array(4, 12);
return spline(x, y, xx);
// 返回：array(1.1407,13.9444)
```

## `integral(call_back, a, b, method)`

求函数的数值积分

| 参数        | 类型   | 说明                 |
| ----------- | ------ | -------------------- |
| `call_back` | string | 计算被积函数值的回调 |
| `a`         | double | 实型变量。积分下限   |
| `b`         | double | 实型变量。积分上限   |
| `method`    | string | 积分方法             |

返回：double

### 示例

```tsl
a := 1;
b := 3;
callback := "fun1";
return integral(callback, a, b, ’romberg’);
// 其中fun1函数：
function fun1(x)
begin
return 2 * x+1;
end;
// 结果：10
```

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

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

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

返回：any

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

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

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

返回：any

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

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

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

返回：any

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

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

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

返回：any

## `hessian(fun, x)`

海塞矩阵 求解函数 fun 在x点的 海塞矩阵；

| 参数  | 类型   | 说明             |
| ----- | ------ | ---------------- |
| `fun` | string | 字符串，函数名   |
| `x`   | array  | 一维数组，指定点 |

返回：array

### 示例

```tsl
return hessian("Hessian.demo", array(3, 4));
```

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

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

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

返回：any

## `perms(x)`

样本排列

| 参数 | 类型  | 说明             |
| ---- | ----- | ---------------- |
| `x`  | array | 样本，数组或数字 |

返回：array

### 示例

范例01：求10的阶乘

```tsl
return perms(10);
// 输出：3628800
```

范例02：排列组合

```tsl
return perms(array("a", "b", "c"));
// 输出：
array(
("c", "b", "a"),
("c", "a", "b"),
("b", "c", "a"),
("b", "a", "c"),
("a", "b", "c"),
("a", "c", "b"))
```

范例03：返回数组Array(('A','B'),('C', 'D'))中任意两个数据的排列组合

```tsl
v := Array(('A', 'B'), ('C', 'D'));
return perms(v, 2);
// 输出：
// Execute script error at Line:2
// function:__main__:line 2:instruction:usercall: function:perms compile error or not found
// function:__main__:line 2:instruction:usercall: function execute error
```

范例04：对排列组合的每列求和

```tsl
function test_1cth();
begin
func := createobject("funcexe");
a := array("A", "B", "C");
return perms(a, 3, func);
end;
type funcexe = class()
data;
function create();
begin
data := "";
end
function exe(dat);
begin
data+=dat;
end
end
// 输出：
// Execute script error at Line:0
```

## `maxDrawDown(data, updn, interval, ifabs)`

最大回撤

| 参数       | 类型    | 说明                                            |
| ---------- | ------- | ----------------------------------------------- |
| `data`     | array   | 一维数字序列                                    |
| `updn`     | bool    | 涨跌标示符。1为求最大涨，0为求最大跌（默认值）  |
| `interval` | integer | 最大区间，为空或者小于1时，求整个区间（默认值） |
| `ifabs`    | float   | 预留字段，暂时没有实际意义，可不给值 。         |

返回：real/table

### 示例

范例01：

```tsl
// 计算一组序列的最大涨幅
data := array(3, 1, 7, 5, 6, 3);
return maxDrawDown(data, 1);
// 结果：
1
2
6
6
// 输出：说明：入点为data[1]，出点为data[2]，两者差为6，最大涨幅比例差为6
```

范例02：

```tsl
// ------计算100日股票的最大跌幅
setSysParam(pn_stock(), 'SZ000002');
setSysParam(pn_date(), 20181031T);
setSysParam(pn_rate(), 1);
setSysParam(pn_rateday(), 20181031T);
setSysParam(pn_cycle(), cy_day());
data := nDay3(100, close());
t := maxDrawDown(data);
return t;
// 结果t：
12
43
6.96759
0.25765
// 注：若需计算最大跌幅率，则只需t[3] * 100即可。
```

## `minRecoveryTime(r, n1, n2)`

最小恢复时间

| 参数 | 类型    | 说明                 |
| ---- | ------- | -------------------- |
| `r`  | array   | (一维数字数组) 序列, |
| `n1` | integer | Int 买入点位置,      |
| `n2` | integer | Int 卖出点位置       |

返回：integer

### 示例

```tsl
// 科大讯飞(SZ002230)在20201220最近十个交易日序列中第一天购买第二天卖出后的最小恢复时间
setSysParam(pn_stock(), "SZ002230");
setSysParam(PN_Date(), 20201220t);
r := nDay(10, "close", close())[: , "close"];
return minRecoveryTime(r, 0, 1);
// 输出：6
```

## `generateCombinations(list, ret, start, n)`

非空全组合生成器

| 参数    | 类型    | 说明                        |
| ------- | ------- | --------------------------- |
| `list`  | array   | 一维数组 样本,              |
| `ret`   | array   | 返回生成的组合数组,         |
| `start` | integer | Int 选取起始数据的位置,     |
| `n`     | integer | Int 记录每组数据的起始位置, |

返回：integer

### 示例

```tsl
list := array('a', 'b', 'c');
generateCombinations(list, ret);
return ret;
// 输出：
// Execute script error at Line:2
// function:__main__:line 2:instruction:usercall: function:generateCombinations compile error or not found
// function:__main__:line 2:instruction:usercall: function execute error
```

## `percentage(y, per, style)`

百分位去极值

| 参数    | 类型        | 说明                                                                                        |
| ------- | ----------- | ------------------------------------------------------------------------------------------- |
| `y`     | array       | 数字数组，待处理数据                                                                        |
| `per`   | real\|array | 实数或者一维数字数组，去极值百分位；5表示 5%；                                              |
| `style` | integer     | 整数，0 或者不输入时 去 百分位大于 per 和小于per的；1, 去除小于per的；2 去除 大于per的 数据 |

返回：array

### 示例

```tsl
y := rand(100, 2);
per := 20;
style := 0;
return percentage(y, per, style);
```

## `GM_Initial(x, method, un)`

数据初始化，提供了几种数据变换的方法，有初值化、均值化、最小值化、最大值化、按行区间值化、按列区间值化、归一化、逆化、倒数化和始点零化处理原始的序列 1）初值化： 2）均值化：， 3）最小值化：， 4）最大值化：， 5）按行区间值化： 6）按列区间值化： 7）归一化：， 8）逆化： 9）倒数化： 10）始点零化：

| 参数     | 类型   | 说明                                                                       |
| -------- | ------ | -------------------------------------------------------------------------- |
| `x`      | array  | 数据矩阵，为二维数组类型；                                                 |
| `method` | string | 处理方法(ini,mean,min,max,rrange,crange,norm,inv,rec,zero)，为字符串类型； |
| `un`     | array  | 归一化单位，为一维数组类型                                                 |

返回：array

## `GM_Corr(x, l)`

灰色关联度，以l行为参考数列的灰色关联度，返回的是关联度矩阵 ，， 以为参考数列，则关联度计算步骤如下： 1）初值化：； 2）求差数列：， 3）求两级最大和最小：， 4）求关联系数：，为分辨系数，是0到1之间的数 5）求关联度：

| 参数 | 类型  | 说明                       |
| ---- | ----- | -------------------------- |
| `x`  | array | 数据矩阵，为二维数组类型； |
| `l`  | any   | 参考序列标号，为整数类型   |

返回：array

## `GM_AGO(x, method, r)`

数列生成，r(r>0)次的累加或累减生成新数列 1）累加：， 2）累减：，

| 参数     | 类型   | 说明                              |
| -------- | ------ | --------------------------------- |
| `x`      | array  | 数据矩阵，为一维数组类型；        |
| `method` | string | 生成方法(add,sub)，为字符串类型； |
| `r`      | any    | 次数，为整数类型                  |

返回：array

## `GM_Scorr(x, method)`

灰色绝对关联度、灰色相对关联度和灰色综合关联度，返回的是关联度矩阵 ，， 1）灰色绝对关联度： 2）灰色相对关联度：先对数列进行初值化，然后求新数列的灰色绝对关联度，即为原数列的灰色相对关联度 3）灰色综合关联度：

| 参数     | 类型   | 说明                              |
| -------- | ------ | --------------------------------- |
| `x`      | array  | 数据矩阵，为二维数组类型；        |
| `method` | string | 方法(abs,ret,com)，为字符串类型； |

返回：array

## `GM_Estimate(x, l)`

GM(1,1)模型，用于灰色系统模型的l步预测 结果说明： 平均相对误差：越小越接近零越好； 关联度：当ρ=0.5时，关联度大于0.6便满意 方差比：C 小误差概率：P

| 参数 | 类型  | 说明                       |
| ---- | ----- | -------------------------- |
| `x`  | array | 数据矩阵，为一维数组类型； |
| `l`  | any   | 预测步长，为整数类型       |

返回：array

## `Prog_L(f, a, b, aeq, beq, lb, ub, x0, options, ozarr, intarr)`

使用单纯形法，和起作用集法，系统默认作用集形法求解线性规划问题，即求解目标都为线性和约束条件都为线性的规划问题 Prog_L(f,A,b) 求解不等式约束 Prog_L(f,A,b,Aeq,beq) 求解不等式约束、等式约束 Prog_L(f,A,b,Aeq,beq,LB,UB) 求解不等式约束、等式约束、上下界限约束 Prog_L(f,A,b,Aeq,beq,LB,UB,x0,options) 求解不等式约束、等式约束，上下限约束，加入用户算法设置 Prog_L(f,A,b,Aeq,beq,LB,UB,x0,options,ozarr) 求解不等式约束、等式约束、上下限约束、0-1 约束 Prog_L(f,A,b,Aeq,beq,LB,UB,x0,options,ozarr,intarr) 求解不等式约束、等式约束、上下限约束、0-1 约束、整数约束 模型表达： min= sum(f\*x) st. A:\*x<=b Aeq :\* x = Beq lb<x<ub x = (0 or 1) x = integer

| 参数      | 类型  | 说明                                                                                                                                                                                                                                                                              |
| --------- | ----- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `f`       | array | 线性目标，一维数字数组，不可缺省                                                                                                                                                                                                                                                  |
| `a`       | array | 线性约束，二维数字数组，不可缺省                                                                                                                                                                                                                                                  |
| `b`       | array | 线性约束，一维数字数组，不可缺省                                                                                                                                                                                                                                                  |
| `aeq`     | array | 线性约束，二维数字数组，缺省为空                                                                                                                                                                                                                                                  |
| `beq`     | array | 线性约束，一维数字数组，缺省为空                                                                                                                                                                                                                                                  |
| `lb`      | array | 下界约束，一维数字数组，缺省为空                                                                                                                                                                                                                                                  |
| `ub`      | array | 上界约束，一维数字数组，缺省为空                                                                                                                                                                                                                                                  |
| `x0`      | array | 初始值，一维数组                                                                                                                                                                                                                                                                  |
| `options` | array | 选项设置，数据表类型，缺省为:；array( 'algorithm' :'activeset'，//'simplex' 单纯形，'activeset' 作用集法；//(当整数、0-1 约束时推荐使用)；'maxiter': 400 , //最大迭代次数；'tolcon': 1.0e-10, //约束容忍误差；'tolfun' : 1.0e-8 , //目标最小误差；'tolx' : 1.0e-8 //变量最小变化) |
| `ozarr`   | array | 01约束条件，第1个变量为01变量则ozarr := array(0)                                                                                                                                                                                                                                  |
| `intarr`  | array | 整数约束条件，第2,3两个变量为整数变量则 intarr:=array(1,2)；返回结果:；数据表类型；ret\["X"\] : 变量取值，一维数字数组；ret\["Fval"\] :规划目标值，实数；ret\["Error_M"\] : 结果信息，整数；ret\["Iter"\] : 迭代次数,整数                                                         |

返回：array

## `Prog_N(fun, x0, a, b, aeq, beq, lb, ub, nlc, options)`

采用拟牛顿下山方法求解非线性规划求解。 Prog_n(fun,x0) 无约束最小值约束 Prog_n(fun,x0,A,B) 非线性不等式约束求解 Prog_n(fun,A,b,Aeq,beq) 求解不等式约束、等式约束 Prog_n(fun,x0,A,b,Aeq,beq,LB,UB) 求解不等式约束、等式约束、上下界限约束 Prog_n(fun,x0,A,b,Aeq,beq,LB,UB,x0,options) 模型表达 1非线性无约束最小值 min fun(x) 2非线性规划求解 min fun(x) st. c(x)<=0; //非线性不等式约束 ceq(x)=0; //非线性等式约束 A\*x<=b; //线性不等式约束 aeq\*x=beq; //线性等式约束 lb<=x<=ub ; //边界约束

| 参数      | 类型  | 说明                                                                                                                                                                                                                                                                                         |
| --------- | ----- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `fun`     | array | 目标函数，目标函数名字符串类型，不可缺省。其中，目标函数的返回值必须是一个实数（1x1的矩阵，或长度为1的数组都不允许）                                                                                                                                                                         |
| `x0`      | array | 初始值，一维数字数组，不可缺省                                                                                                                                                                                                                                                               |
| `a`       | array | 不等式约束，二维数组，缺省为空                                                                                                                                                                                                                                                               |
| `b`       | array | 不等式约束，一维数组，缺省为空                                                                                                                                                                                                                                                               |
| `aeq`     | array | 等式约束，二维数组，缺省为空                                                                                                                                                                                                                                                                 |
| `beq`     | array | 等式约束，一维数组，缺省为空                                                                                                                                                                                                                                                                 |
| `lb`      | array | 下界，一维数组，缺省为空                                                                                                                                                                                                                                                                     |
| `ub`      | array | 上界，一维数组，缺省为空                                                                                                                                                                                                                                                                     |
| `nlc`     | array | 非线性约束，函数名，字符串                                                                                                                                                                                                                                                                   |
| `options` | array | 算法参数设置，默认为array('maxiter':400 , //最大迭代次数'maxfunevals':'100\*numberofvariables', //目标回调最大次数'tolcon':1.0e-6 ,//约束容忍误差'tolfun' :1.0e-6 ,//目标最小误差'tolx' :1.0e-6 , //变量最小变化'diffmaxchange':1e-1,//差分时最大步长'diffminchange':1e-8 )// 差分时最小步长 |

返回：array

## `Prog_M(fun, x0, goal, weight, a, b, aeq, beq, lb, ub, nlc, options)`

求解多目标规划问题 模型表达： min AttainFactor st. f(x)-AttainFactor\*wight <=goal //目标约束 c(x)<=0; //非线性不等式约束 ceq(x)=0; //非线性等式约束 A\*x<=b; //线性不等式约束 aeq\*x=beq; //线性等式约束 lb<=x<=ub ; //边界约束

| 参数      | 类型   | 说明                                                                                                                                                                                                                                                                                     |
| --------- | ------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `fun`     | array  | 目标函数，函数名字符串                                                                                                                                                                                                                                                                   |
| `x0`      | array  | 初始值                                                                                                                                                                                                                                                                                   |
| `goal`    | array  | 目标中各个分目标的差，一维数组和目标个数相同                                                                                                                                                                                                                                             |
| `weight`  | array  | 目标中各个分量的在总体中的比重，一维数组和目标个数相同                                                                                                                                                                                                                                   |
| `a`       | array  | 不等式约束，二维数组                                                                                                                                                                                                                                                                     |
| `b`       | array  | 不等式约束，一维数组                                                                                                                                                                                                                                                                     |
| `aeq`     | array  | 等式约束，二维数组                                                                                                                                                                                                                                                                       |
| `beq`     | array  | 等式约束，一维数组                                                                                                                                                                                                                                                                       |
| `lb`      | array  | 下界，一维数组                                                                                                                                                                                                                                                                           |
| `ub`      | array  | 上界，一维数组                                                                                                                                                                                                                                                                           |
| `nlc`     | string | 非线性约束，约束函数名字符串                                                                                                                                                                                                                                                             |
| `options` | array  | 算法参数设置，默认为:array('maxiter':400, //最大迭代次数'maxfunevals':'100\*numberofvariables', //目标回调最大次数'tolcon':1.0e-6,//约束容忍误差'tolfun' :1.0e-6,//目标最小误差'tolx' :1.0e-6, //变量最小变化'diffmaxchange':1e-1,//差分时最大步长'diffminchange':1e-8)// 差分时最小步长 |

返回：array

## `NonLP_Fminsearch(fun, x0, methods)`

无约束最小值求解,求解模型如下： min fun(x)

| 参数      | 类型   | 说明                                                                       |
| --------- | ------ | -------------------------------------------------------------------------- |
| `fun`     | string | 目标函数，函数名字符串                                                     |
| `x0`      | array  | 初始值，一维数字数组                                                       |
| `methods` | any    | 方法选择0 单纯形法1 转轴法2 模式搜索法3 拟牛顿下山法（默认方法，推荐使用） |

返回：array

## `NonLP_minSUMT(fun, x0, a, b, aeq, beq, nonlcon, methods)`

（非线性规划建议统一使用prog_n函数）混合惩罚函数+转轴法/模式搜索法：可解所有优化问题，返回最优点、最优值和迭代次数。可求解如下问题：

| 参数      | 类型   | 说明                                   |
| --------- | ------ | -------------------------------------- |
| `fun`     | string | 目标函数表达式，为字符串类型；         |
| `x0`      | array  | 初值向量，为一维数组类型；             |
| `a`       | array  | 线性矩阵不等式约束，为二维数组类型；   |
| `b`       | array  | 线性向量不等式约束值，为一维数组类型； |
| `aeq`     | array  | 线性矩阵等式约束，为二维数组类型；     |
| `beq`     | array  | 线性向量等式约束值，为一维数组类型；   |
| `nonlcon` | string | 非线性约束回调，为字符串类型；         |
| `methods` | string | 方法选择,’NM’,’Rb’,’HJ’                |

返回：array

## `NonLP_minPS(fun, x0, a, b, nonlcon)`

（非线性规划建议统一使用prog_n函数）,坐标轮换法求不等式约束问题，初值必须在可行域内！可求解如下问题：

| 参数      | 类型   | 说明                                   |
| --------- | ------ | -------------------------------------- |
| `fun`     | string | 目标函数表达式，为字符串类型；         |
| `x0`      | array  | 初值向量，为一维数组类型；             |
| `a`       | array  | 线性矩阵不等式约束，为二维数组类型；   |
| `b`       | array  | 线性向量不等式约束值，为一维数组类型； |
| `nonlcon` | string | 非线性约束回调，为字符串类型；         |

返回：array

## `NonLP_minFactor(fun, x0, aeq, beq, nonlcon)`

（非线性规划建议统一使用prog_n函数）,乘子法求等式约束问题，可求解如下问题：

| 参数      | 类型   | 说明                                 |
| --------- | ------ | ------------------------------------ |
| `fun`     | string | 目标函数表达式，为字符串类型；       |
| `x0`      | array  | 初值向量，为一维数组类型；           |
| `aeq`     | array  | 线性矩阵等式约束，为二维数组类型；   |
| `beq`     | array  | 线性向量等式约束值，为一维数组类型； |
| `nonlcon` | string | 非线性约束回调，为字符串类型；       |

返回：array

## `NonLP_Fmincon(fun, x0, a, b, aeq, beq, nonlcon, c, methods)`

（非线性规划建议统一使用prog_n函数）默认选项只适合于单纯的等式约束问题或者单纯的不等式约束问题，罚函数+转轴法/模式搜索法适合于任何问题，结果返回最优点、最优值和迭代次数。 可求解如下问题：

| 参数      | 类型   | 说明                                                                                                                                                   |
| --------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `fun`     | string | 目标函数表达式，为字符串类型；                                                                                                                         |
| `x0`      | array  | 初值向量，为一维数组类型；                                                                                                                             |
| `a`       | array  | 线性矩阵不等式约束，为二维数组类型；                                                                                                                   |
| `b`       | array  | 线性向量不等式约束值，为一维数组类型；                                                                                                                 |
| `aeq`     | array  | 线性矩阵等式约束，为二维数组类型；                                                                                                                     |
| `beq`     | array  | 线性向量等式约束值，为一维数组类型；                                                                                                                   |
| `nonlcon` | string | 非线性约束回调，为字符串类型；nonlcon回调需用户自己新建一个函数，然后把函数名传进nonlcon，函数格式如下:；Function “函数名”(x);；Begin                  |
| `c`       | any    | =array();//\*；C\[0\]:=……；C\[1\]:=……；……；Ceq:=array();//\*；Ceq\[0\]:=……；Ceq\[1\]:=……；……；Return array(0:c,1:ceq);//\*；End;；//\*号的式子一定要写 |
| `methods` | any    | 优化方法（0:默认，1:罚函数+转轴法，2:罚函数+模式搜索法），为用户自定义类型（整型）；                                                                   |

返回：array

## `NonLP_Range(fun, x0, h)`

进退法，可一维优化问题的确定搜索区间，但目标函数必须是单峰函数，返回结果为上下界的取值。（中间函数）

| 参数  | 类型   | 说明                         |
| ----- | ------ | ---------------------------- |
| `fun` | string | 目标函数表达式，为字符串类型 |
| `x0`  | float  | 初值，为实数类型；           |
| `h`   | float  | 步长，为实数类型；           |

返回：array

## `NonLP_BSearch(fun, x0, h)`

一维盲人搜索方法，目标函数既可以是单峰，也可以是多峰。返回最优点和最优值。（中间函数）

| 参数  | 类型   | 说明                         |
| ----- | ------ | ---------------------------- |
| `fun` | string | 目标函数表达式，为字符串类型 |
| `x0`  | float  | 初值，为实数类型；           |
| `h`   | float  | 步长，为实数类型；           |

返回：array

## `NonLP_Golden(fun, a, b)`

（一维最小值搜索建议统一使用NonLP_Fminbnd函数），黄金分割法搜索\[a,b\]区间内目标函数的最小值，返回最优点和最优值

| 参数  | 类型   | 说明                           |
| ----- | ------ | ------------------------------ |
| `fun` | string | 目标函数表达式，为字符串类型； |
| `a`   | float  | 区间左侧，为实数类型；         |
| `b`   | float  | 区间右侧，为实数类型           |

返回：array

## `NonLP_Fibonacci(fun, a, b)`

（一维最小值搜索建议统一使用NonLP_Fminbnd函数），斐波那契法，用斐波那契数列去搜索\[a,b\]区间内目标函数的最小值，返回最优点和最优值

| 参数  | 类型   | 说明                           |
| ----- | ------ | ------------------------------ |
| `fun` | string | 目标函数表达式，为字符串类型； |
| `a`   | float  | 区间左侧，为实数类型；         |
| `b`   | float  | 区间右侧，为实数类型           |

返回：array

## `NonLP_GP(fun, a, b)`

（一维最小值搜索建议统一使用NonLP_Fminbnd函数），黄金分割+抛物线插值法：一维优化方法，返回最优点和最优值

| 参数  | 类型   | 说明                           |
| ----- | ------ | ------------------------------ |
| `fun` | string | 目标函数表达式，为字符串类型； |
| `a`   | float  | 区间左侧，为实数类型；         |
| `b`   | float  | 区间右侧，为实数类型；         |

返回：array

## `NonLP_Nelder(fun, x0)`

（无约束最小值求解建议统一使用NonLP_Fminsearch函数）内德-米德法，无约束多维的非线性规划方法，即单纯形法。返回最优点和最优值。

| 参数  | 类型   | 说明                           |
| ----- | ------ | ------------------------------ |
| `fun` | string | 目标函数表达式，为字符串类型； |
| `x0`  | array  | 初值向量，为一维数组类型       |

返回：array

## `NonLP_Hooke_Jeeves(fun, x0)`

（无约束最小值求解建议统一使用NonLP_Fminsearch函数）模式搜索法，又叫Hooke-Jeeves法，求解无约束多维极值问题，返回最优点和最优值。

| 参数  | 类型   | 说明                           |
| ----- | ------ | ------------------------------ |
| `fun` | string | 目标函数表达式，为字符串类型； |
| `x0`  | array  | 初值向量，为一维数组类型       |

返回：array

## `linearProgramming(f, a, b, aeq, beq)`

（线性规划，包括整数规划，01规划建议统一使用prog_L函数）,解决如下线性规划模型问题

| 参数  | 类型          | 说明                                                                                         |
| ----- | ------------- | -------------------------------------------------------------------------------------------- |
| `f`   | array of real | 一维实数数组，表示线性规划模型的目标函数系数；                                               |
| `a`   | array of real | 二维实数数组，表示线性规划模型的带“”约束方程系数矩阵，如果是带“”，则将该方程两边同乘以“-1”； |
| `b`   | array of real | 一维实数数组，表示线性规划模型带“”约束方程的约束值；                                         |
| `aeq` | array of real | 二维实数数组，表示线性规划模型带“=”约束方程系数矩阵；                                        |
| `beq` | array of real | 一维实数数组，表示线性规划模型带“=”约束方程的约束值；                                        |

返回：any

### 示例

```tsl
Find x that minimizes
f(x) = –5x1 – 4x2 –6x3,
subject to
x1 – x2 + x3 ≤ 20
3x1 + 2x2 + 4x3 ≤ 42
3x1 + 2x2 ≤ 30
0 ≤ x1, 0 ≤ x2, 0 ≤ x3.
// TSL代码：
f := array(-5, -4, -6);
a := array((1, -1, 1), (3, 2, 4), (3, 2, 0));
b := array(20, 42, 30);
aeq := array();
beq := array();
return linearProgramming(f, a, b, aeq, beq);
// 结果：x1=0,x2=15,x3=3,f(x)=-78
```

## `intLinProg(f, a, b, aeq, beq, int_par)`

（线性规划，包括整数规划，01规划建议统一使用prog_L函数）解决如下整数规划模型问题

| 参数      | 类型          | 说明                                                                                         |
| --------- | ------------- | -------------------------------------------------------------------------------------------- |
| `f`       | array of real | 一维实数数组，表示整数规划模型的目标函数系数；                                               |
| `a`       | array of real | 二维实数数组，表示整数规划模型的带“”约束方程系数矩阵，如果是带“”，则将该方程两边同乘以“-1”； |
| `b`       | array of real | 一维实数数组，表示整数规划模型带“”约束方程的约束值；                                         |
| `aeq`     | array of real | 二维实数数组，表示整数规划模型带“=”约束方程系数矩阵；                                        |
| `beq`     | array of real | 一维实数数组，表示整数规划模型带“=”约束方程的约束值；                                        |
| `int_par` | array of real | 一维整数数组，表示要取整数的变量，缺省时表示全部变量取整；                                   |

返回：array

### 示例

```tsl
Find x that Maximum
f(x) =40x1+90x2
subject to
9x1+7x2≤ 56
7x1 + 20x2≤ 70
0 ≤ x1, 0 ≤ x2
x1, x2整数
// TSL代码：
f := array(-40, -90);
a := array((9, 7), (7, 20));
b := array(56, 70);
aeq := array();
beq := array();
int_par := array();
return intLinProg(f, a, b, aeq, beq, intpar);
// 结果：x1=4,x2=2,f(x)=-340
```

## `quadprog(h, f, a, b, aeq, beq)`

（二次规划建议统一使用prog_Q函数）,解决如下二次规划模型问题：

| 参数  | 类型          | 说明                                                                                         |
| ----- | ------------- | -------------------------------------------------------------------------------------------- |
| `h`   | array of real | 二维实数数组，表示二次项目标函数系数，为对称矩阵                                             |
| `f`   | array of real | 一维实数数组，表示二次规划模型的目标函数系数；                                               |
| `a`   | array of real | 二维实数数组，表示二次规划模型的带“”约束方程系数矩阵，如果是带“”，则将该方程两边同乘以“-1”； |
| `b`   | array of real | 一维实数数组，表示二次规划模型带“”约束方程的约束值；                                         |
| `aeq` | array of real | 二维实数数组，表示二次规划模型带“=”约束方程系数矩阵；                                        |
| `beq` | array of real | 一维实数数组，表示二次规划模型带“=”约束方程的约束值；                                        |

返回：array

### 示例

```tsl
Find x that minimize
f(x) = 1/2 * x1^2+x2^2-x1 * x2-2x1-6x2
subject to
x1 + x2 ≤ 2
–x1 + 2x2 ≤ 2
2x1 + x2 ≤ 3
0 ≤ x1, 0 ≤ x2.
// TSL代码：
h := Array((1, -1), (-1, 2));
f := Array(-2, -6);
a := Array((1, 1), (-1, 2), (2, 1));
b := array(2, 2, 3);
aeq := array();
beq := array();
return quadprog(h, f, a, b, aeq, beq);
// 结果： x1=0.6667,x2=1.3333,f(x)=-8.2222
```

## `quadTrackRoute(h, f, a, b, aeq, beq, x0)`

（二次规划建议统一使用prog_Q函数）解决如下二次规划模型问题:

| 参数  | 类型          | 说明                                                                                         |
| ----- | ------------- | -------------------------------------------------------------------------------------------- |
| `h`   | array of real | 二维实数数组，表示二次项目标函数系数，为对称矩阵                                             |
| `f`   |               | 一维实数数组，表示二次规划模型的目标函数系数；                                               |
| `a`   | array of real | 二维实数数组，表示二次规划模型的带“”约束方程系数矩阵，如果是带“”，则将该方程两边同乘以“-1”； |
| `b`   | array of real | 一维实数数组，表示二次规划模型带“”约束方程的约束值；                                         |
| `aeq` | array of real | 二维实数数组，表示二次规划模型带“=”约束方程系数矩阵；                                        |
| `beq` | array of real | 一维实数数组，表示二次规划模型带“=”约束方程的约束值；                                        |
| `x0`  | array of real | 变量的初始点。                                                                               |

返回：array

### 示例

```tsl
Find x that minimize
f(x) = 2 * x1^2+2 * x2^2-x1 * x2+8 * x1-6x2
subject to
x1 + x2 ≤ 2
2 * x1 - x2 ≤ 1
// TSL代码：
h := Array((4, -1), (-1, 4));
f := Array(8, -6);
a := Array((1, 1), (2, -1));
b := array(2, 1);
aeq := array();
beq := array();
x0 := array(0, 0);
return quadTrackRoute(h, f, a, b, aeq, beq, x0);
// 输出：
// 示例包含说明文字，未作为可执行片段运行。
// 输出：分析：x1=-1.733333, x2=1.066667, 最小值f(x)=-10.13333
```

## `quadLagR(h, f, aeq, beq)`

(二次规划建议统一使用prog_Q函数)解决如下二次规划模型问题:

| 参数  | 类型             | 说明                                                  |
| ----- | ---------------- | ----------------------------------------------------- |
| `h`   | array,tablearray | 二维实数数组，表示二次项目标函数系数，为对称矩阵      |
| `f`   | array,tablearray | 一维实数数组，表示二次规划模型的目标函数系数；        |
| `aeq` | array,tablearray | 二维实数数组，表示二次规划模型带“=”约束方程系数矩阵； |
| `beq` | array,tablearray | 一维实数数组，表示二次规划模型带“=”约束方程的约束值。 |

返回：any

### 示例

```tsl
Find x that minimize
f(x) = 2 * x1^2+x2^2+x1 * x2-x1-x2
subject to
x1 + x2 = 1
// TSL代码：
h := Array((4, 1), (1, 2));
f := Array(-1, -1);
aeq := array((1, 1));
beq := array(1);
return quadLagR(h, f, aeq, beq);
// 输出：
// 示例包含说明文字，未作为可执行片段运行。
// 输出：解析：x1=0.25, x2=0.75, 最小值f(x)=-0.125
```

## `Hooke_Jeeves_Method(x0, d0, d_min, r, call_back)`

H-J法求解无约束最优化问题

| 参数        | 类型   | 说明                         |
| ----------- | ------ | ---------------------------- |
| `x0`        | array  | 一维数字数组类型             |
| `d0`        | array  | 一维数字数组类型             |
| `d_min`     | array  | 一维数字数组类型             |
| `r`         | float  | 实数类型                     |
| `call_back` | string | 字符串类型，计算目标值的回调 |

返回：array

## `SUMT_Method(x0, call_back)`

SUMT法求解有约束最优化问题

| 参数        | 类型   | 说明                               |
| ----------- | ------ | ---------------------------------- |
| `x0`        | array  | 一维数字数组类型，各个变量的初始值 |
| `call_back` | string | 字符串类型，计算目标值的回调       |

返回：array

## `Sumt_Method__Pgm()`

Sumt算法测试

返回：array

## `Sumt_Method_CallBack(x, r)`

Sumt算法回调

| 参数 | 类型  | 说明             |
| ---- | ----- | ---------------- |
| `x`  | array | 一维数字数组类型 |
| `r`  | float | 实数类型         |

返回：float

## `sendToClient(cmd_type, cmd_text, cmd_param, cmd_data, time_out)`

发送命令到客户端执行。

| 参数        | 类型        | 说明                       |
| ----------- | ----------- | -------------------------- |
| `cmd_type`  | string      | 命令类型。                 |
| `cmd_text`  | string      | 命令串。                   |
| `cmd_param` | any         | 命令参数。                 |
| `cmd_data`  | any         | 命令数据。                 |
| `time_out`  | integer=300 | 超时的秒数。默认是300s超时 |

返回：any

### 示例

```tsl
// 1)执行命令：return 100+1
return sendToClient("getdo", "return 100 + 1;", nil, nil);
// 结果：101
// 2)采用系统参数取得数据，将取得的数据相加，并设置超时时间为30s
return sendToClient("getdo", "return getsysparam('a') + getsysparam('b');", nil, array("a": 10, "b": 30), 30);
// 结果：40
```

## `setGlobalCache(name, value)`

写入全局缓存。

| 参数    | 类型   | 说明         |
| ------- | ------ | ------------ |
| `name`  | string | 缓存键       |
| `value` | any    | 写入缓存的值 |

返回：any
