csh
c0bf0358e0
Mirror docs/tsl/codegen into the bundled tsl-api-reference skill and rebuild the function index. Remove invalid duplicate API entries for cb_delistedbydate, createhttpsession, exportJsonString, and Anova_Bartlett so exact lookup returns the canonical entries.
1652 lines
68 KiB
Markdown
1652 lines
68 KiB
Markdown
# 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
|