csh/playbook
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9010829c6df1067c1960c5d492b0acd28242e4e4
playbook/skills/tsl-api-reference/references/codegen/builtin/optimization.md
T
csh 9010829c6d ✨ feat(tsl-api-reference): expand and reorganize api catalog 
Flatten builtin pages, add third-party and platform scopes, and import financial and data warehouse references.

Keep the existing generated index without rebuilding after signature normalization.
2026-08-10 18:26:24 +08:00

903 lines
23 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# Builtin - 数值方法
## `all(data, n)`
声明：function
所有为真，判断任意值或数组或数组其行列数据的真假，集合中只要有一个元素为假则为假。
| 参数 | 类型 | 说明 |
| ------ | ------- | ------------------------------------------------------------------------- |
| `data` | any | 当N缺省或取默认值0时，可以为任意数据，否则只能是数组。 |
| `n` | integer | 若值为0，则对Data整体判断，如果Data是数组，则对所有元素进行判断，缺省值。 |
返回：real/table
### 示例
范例一：
```tsl
// 判断数组中所有元素是否都为真
echo all(array(1, 2, -1, 1, 9));
// 输出：1
```
范例二：
```tsl
// 判断特殊数据类型的真假
echo trim(toStn(all(array(1, '', ' ', nan, nil, inf, -inf, array()), 1)));
// 输出：array(1,0,1,1,0,1,1,1)
```
范例三：
```tsl
// 判断二维数组的行
f := array('e': ('A': 1, 'B': 0), 'f': ('A': 2, 'B': 3), 'd': ('A': 3, 'B': nil));
echo trim(toStn(all(f, 1)));
// 输出：array("e":0,"f":1,"d":0)
```
范例四：
```tsl
// 判断多维数组的行
t := array('e': ('A': 1, 'B': 1), 'f': ('A': 2, 'B': array(1, 0)));
echo trim(toStn(all(t, 1)));
// 输出：array("e":1,"f":0)
```
范例五：
```tsl
// 判断多维数组的列
t := array('e': ('A': 1, 'B': 1), 'f': ('A': 2, 'B': array(1, 0)));
echo trim(toStn(all(t, 2)));
// 输出：array("A":1,"B":0)
```
## `any(data, n)`
声明：function
判断任意值或数组或数组其行列数据的真假，集合中只要有一个元素是真则为真。
| 参数 | 类型 | 说明 |
| ------ | ------- | ----------------------------------------------------------------------- |
| `data` | any | 当N缺省或取默认值0时，可以为任意数据，否则只能是数组。 |
| `n` | integer | 若取值0，对Data整体判断，如果Data是数组，则对所有元素进行判断，缺省值。 |
返回：real/table
### 示例
范例一：
```tsl
// 判断非数组的真假
echo any('a', 0);
// 输出：1
```
范例二：
```tsl
// 判断特殊数据类型的真假
echo trim(toStn(any(array(1, '', ' ', nan, nil, inf, -inf, array()), 1)));
// 输出：array(1,0,1,1,0,1,1,0)
```
范例三：
```tsl
// 判断二维数组的行
f := array('e': ('A': 1, 'B': 0), 'f': ('A': 2, 'B': ''), 'd': ('A': 3, 'B': nil));
echo trim(toStn(any(f, 1)));
// 输出：array("e":1,"f":1,"d":1)
```
范例四：
```tsl
// 判断多维数组的行
t := array('e': ('A': 0, 'B': 0), 'f': ('A': 2, 'B': array(1, 0)));
echo trim(toStn(any(t, 1)));
// 输出：array("e":0,"f":1)
```
范例五：
```tsl
// 判断多维数组的列
t := array('e': ('A': 1, 'B': 1), 'f': ('A': 2, 'B': array(1, 0)));
echo trim(toStn(any(t, 2)));
// 输出：array("A":1,"B":1)
```
## `conv(a, b)`
声明：function
计算输入序列A、B的卷积
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------ |
| `a` | array | 一维数字数组 |
| `b` | array | 一维数字数组 |
返回：array
### 示例
```tsl
a := array(0.4044, 0.32362, 0.38548, 0.17435, 0.08502, 0.41899, 0.02551, 0.46226);
b := array(0.82284, 0.7466, 0.17411, 0.85894, 0.7105, 0.51353, 0.30399, 0.01498, 0.0914, 0.36445, 0.14731, 0.1659, 0.98853, 0.44569, 0.11908);
echo trim(toStn(conv(a, b)));
// 输出：array(0.332756496,0.5682125208,0.6292131392,0.8349623362,0.8325398524,1.2073014753,1.0613732782,0.9716555873,1.018384851,0.6794859585,0.8715477319,0.7413644482,0.8329634672,0.7999655273,0.7768548297,0.5100653747,0.4493928066,0.5451659761,0.298770169,0.5182207589,0.2090623902,0.0550459208)
```
## `ig_Chebyshev(a, b, call_back, v)`
声明：function
用切比雪夫求积法计算定积分。
| 参数 | 类型 | 说明 |
| ----------- | ------ | -------------------------- |
| `a` | float | 积分下限 |
| `b` | float | 积分上限 |
| `call_back` | string | 计算被积函数值的回调函数名 |
| `v` | float | 写回积分结果 |
返回：integer
### 示例
```tsl
a := 1;
b := 3;
callback := "linearValue";
ig_Chebyshev(a, b, callback, value);
echo value;
// 输出：10
function linearValue(x);
begin
return 2 * x + 1;
end;
```
## `ig_Gauss(a, b, call_back, v)`
声明：function
用高斯求积法计算定积分。
| 参数 | 类型 | 说明 |
| ----------- | ------ | -------------------------- |
| `a` | float | 积分下限 |
| `b` | float | 积分上限 |
| `call_back` | string | 计算被积函数值的回调函数名 |
| `v` | float | 写回积分结果 |
返回：integer
### 示例
```tsl
a := 1;
b := 3;
callback := "linearValue";
ig_Gauss(a, b, callback, value);
echo value;
// 输出：10.0000000005
function linearValue(x);
begin
return 2 * x + 1;
end;
```
## `ig_Romberg(a, b, call_back, v)`
声明：function
用龙贝格(Romberg)求积法计算定积分，
| 参数 | 类型 | 说明 |
| ----------- | ------ | ------------------------ |
| `a` | float | 实型变量。积分下限 |
| `b` | float | 实型变量。积分上限 |
| `call_back` | string | 计算被积函数值的回调 |
| `v` | float | 实型变量，返回的积分结果 |
返回：integer
### 示例
```tsl
a := 1;
b := 3;
callback := "linearValue";
ig_Romberg(a, b, callback, value);
echo value;
// 输出：10
function linearValue(x);
begin
return 2 * x + 1;
end;
```
## `ig_Simpson_1(a, b, call_back, v)`
声明：function
用变步长辛普森(Simpson)计算定积分
| 参数 | 类型 | 说明 |
| ----------- | ------ | ------------------------ |
| `a` | float | 实型变量。积分下限 |
| `b` | float | 实型变量。积分上限 |
| `call_back` | string | 计算被积函数值的回调 |
| `v` | float | 实型变量，返回的积分结果 |
返回：integer
### 示例
```tsl
a := 1;
b := 3;
callback := "linearValue";
ig_Simpson_1(a, b, callback, value);
echo value;
// 输出：10
function linearValue(x);
begin
return 2 * x + 1;
end;
```
## `ig_Simpson_2(a, b, call_back1, call_back2, call_back3, v)`
声明：function
用变步长辛普森(Simpson)计算二重积分
| 参数 | 类型 | 说明 |
| ------------ | ------ | ------------------------------ |
| `a` | float | 实型变量。积分下限 |
| `b` | float | 实型变量。积分上限 |
| `call_back1` | string | 计算积分下限的回调 |
| `call_back2` | string | 计算积分上限的回调 |
| `call_back3` | string | 计算被积函数f(x,y)函数值的回调 |
| `v` | float | 实型变量，返回的积分结果 |
返回：integer
### 示例
```tsl
a := 1;
b := 2;
lower_callback := "lowerBound";
upper_callback := "upperBound";
value_callback := "integrand";
ig_Simpson_2(a, b, lower_callback, upper_callback, value_callback, value);
echo value;
// 输出：4.66666666666667
function lowerBound(x);
begin
return -x;
end;
function upperBound(x);
begin
return x;
end;
function integrand(x, y);
begin
return x + 2 * y;
end;
```
## `ig_Trapezoid_1(a, b, call_back, v)`
声明：function
用变步长梯形求积法计算定积分
| 参数 | 类型 | 说明 |
| ----------- | ------ | ------------------------ |
| `a` | float | 实型变量。积分下限 |
| `b` | float | 实型变量。积分上限 |
| `call_back` | string | 计算被积函数值的回调 |
| `v` | float | 实型变量，返回的积分结果 |
返回：integer
### 示例
```tsl
a := 1;
b := 3;
callback := "linearValue";
ig_Trapezoid_1(a, b, callback, value);
echo value;
// 输出：10
function linearValue(x);
begin
return 2 * x + 1;
end;
```
## `ig_Trapezoid_2(a, b, call_back, v)`
声明：function
用自适应梯形求积法计算定积分
| 参数 | 类型 | 说明 |
| ----------- | ------ | ------------------------ |
| `a` | float | 实型变量。积分下限 |
| `b` | float | 实型变量。积分上限 |
| `call_back` | string | 计算被积函数值的回调 |
| `v` | float | 实型变量，返回的积分结果 |
返回：integer
### 示例
```tsl
a := 1;
b := 3;
callback := "linearValue";
ig_Trapezoid_2(a, b, callback, value);
echo value;
// 输出：10
function linearValue(x);
begin
return 2 * x + 1;
end;
```
## `ip_Aitken_A(x, y, xv, yv)`
声明：function
用埃特金逐步插值法，根据不等距节点计算指定插值点的函数值。
| 参数 | 类型 | 说明 |
| ---- | ------------- | -------------------- |
| `x` | array of real | 严格递增的不等距节点 |
| `y` | array of real | 各节点的函数值 |
| `xv` | float | 插值点 |
| `yv` | float | 写回插值结果 |
返回：integer
### 示例
```tsl
x := array(1, 1.2, 1.5, 2.3, 2.9, 4, 4.5, 8);
y := array(1, 3, 4, 7, 9, 13, 15, 20);
ip_Aitken_A(x, y, 3, value);
echo value;
// 输出：9.3291726257716
```
## `ip_Aitken_B(x0, h, y, xv, yv)`
声明：function
用埃特金逐步插值法，根据等距节点计算指定插值点的函数值。
| 参数 | 类型 | 说明 |
| ---- | ------------- | -------------- |
| `x0` | float | 第一个节点 |
| `h` | float | 节点步长 |
| `y` | array of real | 各节点的函数值 |
| `xv` | float | 插值点 |
| `yv` | float | 写回插值结果 |
返回：integer
### 示例
```tsl
y := array(1, 3, 4, 6, 9, 11, 13);
ip_Aitken_B(1.3, 0.5, y, 3, value);
echo value;
// 输出：7.08
```
## `ip_Hermite_A(x, y, dy, xv, yv)`
声明：function
用埃尔米特插值法，根据不等距节点及其一阶导数计算指定插值点的函数值。
| 参数 | 类型 | 说明 |
| ---- | ------------- | -------------------- |
| `x` | array of real | 严格递增的不等距节点 |
| `y` | array of real | 各节点的函数值 |
| `dy` | array of real | 各节点的一阶导数 |
| `xv` | float | 插值点 |
| `yv` | float | 写回插值结果 |
返回：integer
### 示例
```tsl
x := array(1, 1.2, 1.5, 2.3, 2.9, 4, 4.5, 8);
y := x ^ 2 - x;
dy := 2 * x - 1;
ip_Hermite_A(x, y, dy, 3, value);
echo value;
// 输出：6
```
## `ip_Hermite_B(x0, h, y, dy, xv, yv)`
声明：function
用埃尔米特插值法，根据等距节点及其一阶导数计算指定插值点的函数值。
| 参数 | 类型 | 说明 |
| ---- | ------------- | ---------------- |
| `x0` | float | 第一个节点 |
| `h` | float | 节点步长 |
| `y` | array of real | 各节点的函数值 |
| `dy` | array of real | 各节点的一阶导数 |
| `xv` | float | 插值点 |
| `yv` | float | 写回插值结果 |
返回：integer
### 示例
```tsl
y := array(0, 2, 6, 12, 20, 30);
dy := array(1, 3, 5, 7, 9, 11);
ip_Hermite_B(1, 1, y, dy, 4.5, value);
echo value;
// 输出：15.75
```
## `ip_Lagrangian_A(x, y, xv, yv)`
声明：function
用拉格朗日插值法，根据不等距节点计算指定插值点的函数值。
| 参数 | 类型 | 说明 |
| ---- | ------------- | -------------------- |
| `x` | array of real | 严格递增的不等距节点 |
| `y` | array of real | 各节点的函数值 |
| `xv` | float | 插值点 |
| `yv` | float | 写回插值结果 |
返回：integer
### 示例
```tsl
x := array(1, 1.2, 1.5, 2.3, 2.9, 4, 4.5, 8);
y := x ^ 2 - x;
ip_Lagrangian_A(x, y, 3, value);
echo value;
// 输出：6
```
## `ip_Lagrangian_B(x0, h, y, xv, yv)`
声明：function
用拉格朗日插值法，根据等距节点计算指定插值点的函数值。
| 参数 | 类型 | 说明 |
| ---- | ------------- | -------------- |
| `x0` | float | 第一个节点 |
| `h` | float | 节点步长 |
| `y` | array of real | 各节点的函数值 |
| `xv` | float | 插值点 |
| `yv` | float | 写回插值结果 |
返回：integer
### 示例
```tsl
y := array(1, 3, 4, 6, 9, 11, 13);
ip_Lagrangian_B(1.3, 0.5, y, 3, value);
echo value;
// 输出：7.177664
```
## `ip_Parabola_A(x, y, xv, yv)`
声明：function
用抛物线插值法，根据不等距节点计算指定插值点的函数值。
| 参数 | 类型 | 说明 |
| ---- | ------------- | -------------------- |
| `x` | array of real | 严格递增的不等距节点 |
| `y` | array of real | 各节点的函数值 |
| `xv` | float | 插值点 |
| `yv` | float | 写回插值结果 |
返回：integer
### 示例
```tsl
x := array(1, 1.2, 1.5, 2.3, 2.9, 4, 4.5, 8);
y := array(1, 3, 4, 7, 9, 13, 15, 20);
ip_Parabola_A(x, y, 3, value);
echo value;
// 输出：9.3458110516934
```
## `ip_Parabola_B(x0, h, y, xv, yv)`
声明：function
用抛物线插值法，根据等距节点计算指定插值点的函数值。
| 参数 | 类型 | 说明 |
| ---- | ------------- | -------------- |
| `x0` | float | 第一个节点 |
| `h` | float | 节点步长 |
| `y` | array of real | 各节点的函数值 |
| `xv` | float | 插值点 |
| `yv` | float | 写回插值结果 |
返回：integer
### 示例
```tsl
y := array(1, 3, 4, 6, 9, 11, 13);
ip_Parabola_B(1.3, 0.5, y, 3, value);
echo value;
// 输出：7.08
```
## `ip_SLG(x, y, z, xv, yv, zv)`
声明：function
根据给定矩形域上的nXm个结点（i=0,1…..n-1；j = 0 , 1, ….., m-1）上的函数值Zij = Z(Xi,Yj)，利用二元插值公式计算指定插值点（u,v）处的函数值w=Z(u,v)
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------------------------------------- |
| `x` | array | 实型一维数组，长度为N。存放给定nXm个点的X方向上的n个坐标，要求X0<X1...<Xn-1 |
| `y` | array | 实型一维数组，长度为N。存放给定nXm个点的X方向上的m个坐标，要求Y0<Y1...<Ym-1 |
| `z` | array | 实型二维数组，体积为为nXm。存放给定nXm个点上的函数值 |
| `xv` | float | 实型变量，插值点的X坐标 |
| `yv` | float | 实型变量，插值点的Y坐标 |
| `zv` | float | 实型变量，返回的插值结果 |
返回：integer
### 示例
```tsl
x := array(1, 2, 3, 4);
y := array(1, 2, 3);
z := array(
(4, 6, 8),
(6, 9, 10),
(11, 20, 25),
(14, 24, 30)
);
x_value := 3.5;
y_value := 4.5;
ip_SLG(x, y, z, x_value, y_value, z_value);
echo z_value;
// 输出：31.546875
```
## `ip_SLQ(x, y, z, xv, yv, zv)`
声明：function
根据给定矩形域上的nXm个结点（i=0,1…..n-1；j = 0 , 1, ….., m-1）上的函数值Zij = Z(Xi,Yj)，利用二元三点插值公式计算指定插值点（u,v）处的函数值w=Z(u,v)
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------------------------------------- |
| `x` | array | 实型一维数组，长度为N。存放给定nXm个点的X方向上的n个坐标，要求X0<X1...<Xn-1 |
| `y` | array | 实型一维数组，长度为N。存放给定nXm个点的X方向上的m个坐标，要求Y0<Y1...<Ym-1 |
| `z` | array | 实型二维数组，体积为为nXm。存放给定nXm个点上的函数值 |
| `xv` | float | 实型变量，插值点的X坐标 |
| `yv` | float | 实型变量，插值点的Y坐标 |
| `zv` | float | 实型变量，返回的插值结果 |
返回：integer
### 示例
```tsl
x := array(1, 2, 3, 4);
y := array(1, 2, 3);
z := array(
(4, 6, 8),
(6, 9, 10),
(11, 20, 25),
(14, 24, 30)
);
x_value := 3.5;
y_value := 4.5;
ip_SLQ(x, y, z, x_value, y_value, z_value);
echo z_value;
// 输出：29.59375
```
## `ip_Spline_A(x, y, dy0, dyn_1, xv, yv)`
声明：function
使用第一类边界条件进行三次样条插值。
| 参数 | 类型 | 说明 |
| ------- | ------------- | ---------------------- |
| `x` | array of real | 严格递增的节点 |
| `y` | array of real | 各节点的函数值 |
| `dy0` | float | 第一个节点的一阶导数 |
| `dyn_1` | float | 最后一个节点的一阶导数 |
| `xv` | float | 插值点 |
| `yv` | float | 写回插值结果 |
返回：integer
### 示例
```tsl
x := array(1, 2, 3, 4, 5, 6);
y := array(0, 2, 6, 12, 20, 30);
ip_Spline_A(x, y, 1, 11, 4.5, value);
echo value;
// 输出：15.75
```
## `ip_Spline_B(x, y, ddy0, ddyn_1, xv, yv)`
声明：function
使用第二类边界条件进行三次样条插值。
| 参数 | 类型 | 说明 |
| -------- | ------------- | ---------------------- |
| `x` | array of real | 严格递增的节点 |
| `y` | array of real | 各节点的函数值 |
| `ddy0` | float | 第一个节点的二阶导数 |
| `ddyn_1` | float | 最后一个节点的二阶导数 |
| `xv` | float | 插值点 |
| `yv` | float | 写回插值结果 |
返回：integer
### 示例
```tsl
x := array(1, 2, 3, 4, 5, 6);
y := array(0, 2, 6, 12, 20, 30);
ip_Spline_B(x, y, 2, 2, 4.5, value);
echo value;
// 输出：15.2828038674033
```
## `ip_Spline_C(x, y, xv, yv)`
声明：function
使用第三类边界条件进行三次样条插值。
| 参数 | 类型 | 说明 |
| ---- | ------------- | -------------- |
| `x` | array of real | 严格递增的节点 |
| `y` | array of real | 各节点的函数值 |
| `xv` | float | 插值点 |
| `yv` | float | 写回插值结果 |
返回：integer
### 示例
```tsl
x := array(1, 2, 3, 4, 5, 6);
y := array(2, 6, 3, 0, 3, 2);
ip_Spline_C(x, y, 3.5, value);
echo value;
// 输出：0.715909090909091
```
## `se_Cholesky(a, b, x)`
声明：function
用乔列斯基(Cholesky)分解法（即平方根法）求解系数矩阵为对称正定、且右端具有m组常数向量的线性方程组AX = B
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------------------------------------------------------------------------- |
| `a` | array | 实型二维数组，大小为NN。存放方程组的系数矩阵，此系数矩阵必须为对称矩阵（即） |
| `b` | array | 实型二维数组，大小为NM。存放方程组右端的常数向量 |
| `x` | array | 实型一维数组，大小为NM。返回方程组的解向量 |
返回：integer
### 示例
```tsl
a := array(
(1, 0, 0),
(0, 2, 0),
(0, 0, 3)
);
b := array(
(1, 3),
(4, 6),
(9, 9)
);
se_Cholesky(a, b, x);
echo trim(toStn(x));
// 输出：array((1.0,3.0),(2.0,3.0),(3.0,3.0))
```
## `se_Gauss(a, b, x)`
声明：function
用全选主元高斯消去法求解n阶线性方程组AX = B
| 参数 | 类型 | 说明 |
| ---- | ----- | ---- |
| `a` | array | |
| `b` | array | |
| `x` | array | |
返回：integer
### 示例
```tsl
a := array(
(1, 0, 0),
(0, 2, 0),
(0, 0, 3)
);
b := array(1, 4, 9);
se_Gauss(a, b, x);
echo trim(toStn(x));
// 输出：array(1.0,2.0,3.0)
```
## `se_Gauss_Jordan(a, b, x)`
声明：function
用全主元高斯-约当(Gauss-Jordan)消去法同时求解系数矩阵相同而常数向量不同的m个n阶线性方程组AX = B
| 参数 | 类型 | 说明 |
| ---- | ----- | ---- |
| `a` | array | |
| `b` | array | |
| `x` | array | |
返回：integer
### 示例
```tsl
a := array(
(1, 0, 0),
(0, 2, 0),
(0, 0, 3)
);
b := array(
(1, 3),
(4, 6),
(9, 9)
);
se_Gauss_Jordan(a, b, x);
echo trim(toStn(x));
// 输出：array((1.0,3.0),(2.0,3.0),(3.0,3.0))
```
## `se_Gauss_Seidel(a, b, x)`
声明：function
用高斯-赛德尔迭代法求解系数矩阵具有主元占优的线性方程组AX = B
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------------------------------------ |
| `a` | array | 实型二维数组，NN。存放方程组的系数矩阵 |
| `b` | array | 实型二维数组，NM。存放方程组右端的常数向量 |
| `x` | array | 实型一维数组，NM。返回方程组的解向量 |
返回：integer
### 示例
```tsl
a := array(
(1, 0, 0),
(0, 2, 0),
(0, 0, 3)
);
b := array(1, 4, 9);
x := array(0.0, 0.0, 0.0);
se_Gauss_Seidel(a, b, x);
echo trim(toStn(x));
// 输出：array(1.0,2.0,3.0)
```
## `se_Ldl(a, b, x)`
声明：function
用LU分解法求解系数矩阵为对称、右端具有m组常数向量的线性方程组 AX = B
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------------------------------------------------------------------------- |
| `a` | array | 实型二维数组，大小为NN。存放方程组的系数矩阵，此系数矩阵必须为对称矩阵（即） |
| `b` | array | 实型二维数组，大小为NM。存放方程组右端的常数向量 |
| `x` | array | 实型一维数组，大小为NM。返回方程组的解向量 |
返回：integer
### 示例
```tsl
a := array(
(1, 0, 0),
(0, 2, 0),
(0, 0, 3)
);
b := array(
(1, 3),
(4, 6),
(9, 9)
);
se_Ldl(a, b, x);
echo trim(toStn(x));
// 输出：array((1.0,3.0),(2.0,3.0),(3.0,3.0))
```
## `setSysParams(params)`
声明：function
一次性设置整个系统参数。
| 参数 | 类型 | 说明 |
| -------- | ----- | ---- |
| `params` | array | |
返回：integer
### 示例
```tsl
s0 := getSysParams();
echo toStn(s0), '\r\n';
r := setSysParams(array("StockID": "SZ000001"));
s1 := getSysParams();
echo r, ':', toStn(s1), '\r\n';
// 输出：
// array()
// 0:
// array()
```
Reference in New Issue View Git Blame Copy Permalink