#### 数学函数

##### 内容

- 数值计算
- 常用数学函数
- 位运算函数
- 三角函数
- 角度量转换
- 双曲线函数
- 指数对数函数
- 精度设置及取整运算
- 比较判断函数
- 一般统计量
- 次序统计量
- 统计函数
- 统计分布
- 统计推断
- 多元统计分析
- 回归
- 灰色系统
- 主成分分析
- 时间序列分析
- 优化
- 小波分析
- 财务函数
- 增长率与比率
- 概率分布
- 信号处理

##### 数值计算

###### 内容

- 数值微积分
- 线性方程组的求解
- 插值
- 矩阵运算及分解
- 数组扩展
- 其他

###### 数值微积分

####### 内容

- ig_Romberg
- integral
- ig_Trapezoid_1
- ig_Trapezoid_2
- ig_Simpson_1
- ig_Gauss
- ig_Chebyshev
- ig_Simpson_2
- sf_SinX
- sf_CosX
- sf_eX
- sf_EllipseX_1
- sf_EllipseX_2
- Conv
- Hessian

####### ig_Romberg

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
a := 1;
b := 3;
callback := "fun1";
ig_Romberg(a, b, CallBack, v);
return v;
function fun1(x)
begin
    return 2 * x + 1;
end;
// 结果：10
```

参考integral ig_Trapezoid_1 ig_Simpson_1 ig_Gauss ig_Chebyshev

####### integral

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
a := 1;
b := 3;
callback := "fun1";
return integral(callback, a, b, ’Romberg’);
```

其中fun1函数：

```tsl
function fun1(x)
begin
    return 2 * x + 1;
end;
// 结果：10
```

参考ig_Trapezoid_1 ig_Trapezoid_2 ig_Simpson_1 ig_Romberg ig_Gauss ig_Chebyshev
ig_Simpson_2

####### ig_Trapezoid_1

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
a := 1;
b := 3;
callback := "fun1";
ig_Trapezoid_1(a, b, CallBack, v);
return v;
function fun1(x)
begin
    return 2 * x + 1;
end;
// 结果：10
```

参考integral ig_Simpson_1 ig_Romberg ig_Gauss ig_Chebyshev

####### ig_Trapezoid_2

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
a := 1;
b := 3;
callback := "fun1";
ig_Trapezoid_2(a, b, CallBack, v);
return v;
function fun1(x)
begin
    return 2 * x + 1;
end;
// 结果：10
```

参考integral ig_Trapezoid_1 ig_Simpson_1 ig_Romberg ig_Gauss ig_Chebyshev

####### ig_Simpson_1

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
a := 1;
b := 3;
callback := "fun1";
ig_Simpson_1(a, b, CallBack, v);
return v;
function fun1(x)
begin
    return 2 * x + 1;
end;
// 结果：10
```

参考integral ig_Trapezoid_1 ig_Romberg ig_Gauss ig_Chebyshev

####### ig_Gauss

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
a := 1;
b := 3;
callback := "fun1";
ig_Gauss(a, b, CallBack, v);
return v;
function fun1(x)
begin
    return 2 * x + 1;
end;
// 结果：10
```

参考integral ig_Trapezoid_1 ig_Simpson_1 ig_Romberg ig_Chebyshev

####### ig_Chebyshev

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
a := 1;
b := 3;
callback := "fun1";
ig_Chebyshev(a, b, CallBack, v);
return v;
function fun1(x)
begin
    return 2 * x + 1;
end;
// 结果：10
```

参考integral ig_Trapezoid_1 ig_Simpson_1 ig_Romberg ig_Gauss

####### ig_Simpson_2

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
a := 1;
b := 2;
callback1 := "y1";
callback2 := "y2";
callback3 := "f";
ig_Simpson_2(a, b, CallBack1, CallBack2, CallBack3, v);
return v;
function y1(x)
begin
    return -x;
end;
function y2(x)
begin
    return x;
end;
function f(x, y)
begin
    return x + 2 * y;
end;
// 结果：4.66667
```

参考integral ig_Simpson_1

####### sf_SinX

范例

```tsl
sf_sinx(2, v);
return v;
// 结果：
1.60541
```

参考sf_CosX sf_eX

####### sf_CosX

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
sf_CosX(2, v);
return v;
// 结果：
0.42298
```

参考sf_SinX sf_eX

####### sf_eX

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
sf_eX(2, v);
return v;
// 结果：-0.0489
```

参考sf_SinX sf_CosX

####### sf_EllipseX_1

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
k := 6;
f := 8;
sf_EllipseX_1(k, f, v);
return v;
// 结果：8.05747
```

参考sf_EllipseX_2

####### sf_EllipseX_2

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
k := 6;
f := 8;
sf_EllipseX_2(k, f, v);
return v;
// 结果：7.94314
```

参考sf_EllipseX_1

####### Conv

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```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);
```

####### Hessian

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

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

###### 线性方程组的求解

####### 内容

- se_Gauss
- se_Gauss_Jordan
- se_Ldl
- se_Cholesky
- se_Gauss_Seidel

####### se_Gauss

范例

```tsl
A := array((1, 0, 0),
(0, 2, 0),
(0, 0, 3));
B := array(1, 4, 9);
se_gauss(A, B, X);
return X;
// 结果：array(1,2,3);
```

参考se_Gauss_Jordan se_Ldl se_Cholesky se_Gauss_Seidel

####### se_Gauss_Jordan

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```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);
return X;
```

X=参考se_Gauss se_Ldl se_Cholesky se_Gauss_Seidel

####### se_Ldl

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```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);
return X;
```

X=参考se_Gauss se_Gauss_Jordan se_Cholesky se_Gauss_Seidel

####### se_Cholesky

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```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);
return X;
```

X=参考se_Gauss se_Gauss_Jordan se_Ldl se_Gauss_Seidel

####### se_Gauss_Seidel

范例

```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);
return X;
```

X=参考se_Gauss se_Gauss_Jordan se_Ldl se_Cholesky

###### 插值

####### 内容

- interp
- interp_unit
- ip_Lagrangian_A
- ip_Lagrangian_B
- ip_Parabola_A
- ip_Parabola_B
- ip_Hermite_A
- ip_Hermite_B
- ip_Aitken_A
- ip_Aitken_B
- ip_Spline_A
- ip_Spline_B
- ip_Spline_C
- ip_SLQ
- ip_SLG

####### interp

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

算法

已知数据集有[(x0,y0), (x1,y1)…(xn,yn)]

1、"nearest" 最邻近插值：

在数据集寻找两点(xi,yi), (xi+1,yi+1),满足xi≤x≤xi+1。

插值方程fx=yi+1 (x-xi>x-xi+1)yi (x-xi≤x-xi+1)

2、"linear" 分段线性插值：

插值函数为一次多项式fx=ax+b, (x0,y0),
(x1,y1)是数据集上相异的两点,且x0<x1。有fx0=x0，fx1=x1代入插值函数解得

fx=y0+y1-y0x1-x0x-x0

3、”spline” 三次样条插值：

设S(x)满足样本点要求，则只需在每个子区间[xj，xj+1]上确定1个三次多项式，假设为：

Sj(x) = ajx3 + bjx2 + cjx + d

假设有n个点，需要n-1条线描述，每条线四个未知数，则未知数个数为4(n-1)。显然中间(n-2)个点具有4个约束条件：

S(xj) = f(xj)

S'(xj+0) = f'(xj-0)

S''(xj+0) = f''(xj-0)

S'''(xj+0) = f'''(xj-0)

两端断点存在约束 S(xi) = f(xi)，则约束方程有4(n-2) + 2 =
4(n-1)-2，所以，总的未知数个数比方程个数多两个。所以需要额外的两个约束，于是就有了三种边界条件的插值算法。

第 1 类边界条件：给定端点处的一阶导数值

S'(x1) = y1' ，S'(xn) = yn'

第 2 类边界条件：给定端点处的一阶导数值

S''(x1) = y1'' ，S''(xn) = yn''

第 3 类边界条件是周期性条件，如果y=f(x)是以[xj,
xj+1]为周期的函数，于是S(x)在端点处满足条件

S'(x1+0) = S'(xn- 0) ，S''(x1+0) = S''(xn- 0)

4、” pchip” 分段三次hermite插值：

(x0,y0), (x1,y1)是数据集上相异的两点,且x0<x1。

y=fx在xi上的函数值和一阶导数值分别为yi=fxi和mi=f'xi
(i=0,1),求三次多项式H3x,使其满足H3xi=yiH3'xi=mi （i=0,1）。

构造三次埃尔米特插值多项式

H3x=y0a0x+y1a1x+m0β0x+m1β1x

| 函数 | 函数值 x0 | 函数值 x1 | 导数值 x0 | 导数值 x1 |
| ---- | --------- | --------- | --------- | --------- |
| a0x  | 1         | 0         | 0         | 0         |
| a1x  | 0         | 1         | 0         | 0         |
| β0x  | 0         | 0         | 1         | 0         |
| β1x  | 0         | 0         | 0         | 1         |

由 a0x1=a0'x1=0

可写成 a0x=a+b(x-x0)2

由a0x0=1 得 a=1(x0-x1)2

再由a0'(x0) = 0得b = - 2(x0-x1)3，所以

a0x = 1+2x-x0x1-x02

同理（将x0<->x1）

a1x = 1+2x-x0x1-x02

同样由β0(x0) = β0(x1)= β0'(x1) = 0，可令

β0(x) = c(x-x0)( x-x1)2

再由β0'(x0) = 1，得c = 1(x0-x1)2

β0(x) = (x-x0) ( x-x1x0-x1)2 ，β1(x) = (x-x1) ( x-x0x1-x0)2

a0(x) = [1+2x-x0x1-x0] ( x-x1x0-x1)2 ，β0(x) = (x-x0) ( x-x1x0-x1)2

a1(x) = [1+2x-x1x0-x1] ( x-x0x1-x0)2 ，β1(x) = (x-x1) ( x-x0x1-x0)2

即

a0(x) = [1+2l1(x)]l02(x)

β0(x) = [x-x0]l02(x)

a1(x) = [1+2l0(x)]l12(x)

β1(x) = [x-x1]l12(x)

l02(x) ，l12(x) 为以(x0，y0)，(x1，y1) 插值点得Lagrange一次基函数。

可得满足条件得三次埃尔米特插值多项式为

H3x = y0a0(x) + y1a1(x) + m0β0x+m1β1x

= y0[1+2x-x0x1-x0] ( x-x1x0-x1)2 + y1[1+2x-x1x0-x1] ( x-x0x1-x0)2 + m0(x-x0) (
x-x1x0-x1)2 + m1(x-x1) ( x-x0x1-x0)2范例

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

```tsl
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" 分段线性插值

```tsl
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" 三次样条插值

```tsl
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插值

```tsl
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)
```

####### interp_unit

说明：插值相关函数的单元

其中包括的接口如下：

######## 内容

- HISTC2
- chckxy
- nearest
- linear
- pchip
- pwch
- ppval
- spline

######## HISTC2

算法

对于a中每个元素a[j]在b中查找b[i]<=a[j]<=b[j+1]，取a[j]的位置为i+1，返回a中满足条件的元素在b中的所属位置。i，j从0开始。范例

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

范例

```tsl
uses interp_unit; // 置顶
x := array(5, 1, 19, 8);
y := array(2, 3, 1, 7);
chckxy(x, y);
return x | y;
```

######## nearest

算法

已知数据集有[(x0,y0), (x1,y1)…(xn,yn)]

在数据集寻找两点(xi,yi), (xi+1,yi+1),满足xi≤x≤xi+1。

插值方程fx=yi+1 (x-xi>x-xi+1)yi (x-xi≤x-xi+1)范例

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

算法

插值函数为一次多项式fx=ax+b, (x0,y0),
(x1,y1)是数据集上相异的两点,且x0<x1。有fx0=x0，fx1=x1代入插值函数解得

fx=y0+y1-y0x1-x0x-x0范例

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

算法

(x0,y0),
(x1,y1)是数据集上相异的两点,且x0<x1。y=fx在xi上的函数值和一阶导数值分别为yi=fxi和mi=f'xi
(i=0,1),求三次多项式H3x,使其满足H3xi=yiH3'xi=mi （i=0,1）。

构造三次埃尔米特插值多项式

H3x=y0a0x+y1a1x+m0β0x+m1β1x

| 函数 | 函数值 x0 | 函数值 x1 | 导数值 x0 | 导数值 x1 |
| ---- | --------- | --------- | --------- | --------- |
| a0x  | 1         | 0         | 0         | 0         |
| a1x  | 0         | 1         | 0         | 0         |
| β0x  | 0         | 0         | 1         | 0         |
| β1x  | 0         | 0         | 0         | 1         |

由 a0x1=a0'x1=0

可写成 a0x=a+b(x-x0)2

由a0x0=1 得 a=1(x0-x1)2

再由a0'(x0) = 0得b = - 2(x0-x1)3，所以

a0x = 1+2x-x0x1-x02

同理（将x0<->x1）

a1x = 1+2x-x0x1-x02

同样由β0(x0) = β0(x1)= β0'(x1) = 0，可令

β0(x) = c(x-x0)( x-x1)2

再由β0'(x0) = 1，得c = 1(x0-x1)2

β0(x) = (x-x0) ( x-x1x0-x1)2 ，β1(x) = (x-x1) ( x-x0x1-x0)2

a0(x) = [1+2x-x0x1-x0] ( x-x1x0-x1)2 ，β0(x) = (x-x0) ( x-x1x0-x1)2

a1(x) = [1+2x-x1x0-x1] ( x-x0x1-x0)2 ，β1(x) = (x-x1) ( x-x0x1-x0)2

即

a0(x) = [1+2l1(x)]l02(x)

β0(x) = [x-x0]l02(x)

a1(x) = [1+2l0(x)]l12(x)

β1(x) = [x-x1]l12(x)

l02(x) ，l12(x) 为以(x0，y0)，(x1，y1) 插值点得Lagrange一次基函数。

可得满足条件得三次埃尔米特插值多项式为

H3x = y0a0(x) + y1a1(x) + m0β0x+m1β1x

= y0[1+2x-x0x1-x0] ( x-x1x0-x1)2 + y1[1+2x-x1x0-x1] ( x-x0x1-x0)2 + m0(x-x0) (
x-x1x0-x1)2 + m1(x-x1) ( x-x0x1-x0)2范例

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

######## ppval

######## spline

范例

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

####### ip_Lagrangian_A

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
X := array(1, 1.2, 1.5, 2.3, 2.9, 4, 4.5, 8);
Y := X ^ 2 - X;
xv := 3;
ip_Lagrangian_A(X, Y, xv, yv);
return yv;
// 结果：6
```

参考ip_Lagrangian_B ip_Parabola_A ip_Hermite_A ip_Aitken_A

####### ip_Lagrangian_B

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
X0 := 1.3;
h := 0.5;
Y := array(1, 3, 4, 6, 9, 11, 13);
xv := 3;
ip_Lagrangian_B(X0, h, Y, xv, yv);
return yv;
// 结果：7.17766
```

参考ip_Lagrangian_A ip_Parabola_B ip_Hermite_B ip_Aitken_B

####### ip_Parabola_A

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```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);
xv := 3;
ip_Parabola_A(X, Y, xv, yv);
return yv;
// 结果：9.34581
```

参考ip_Lagrangian_A ip_Parabola_B ip_Hermite_A ip_Aitken_A

####### ip_Parabola_B

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
X0 := 1.3;
h := 0.5;
Y := array(1, 3, 4, 6, 9, 11, 13);
xv := 3;
ip_Parabola_B(X0, h, Y, xv, yv);
return yv;
// 结果：7.08
```

参考ip_Lagrangian_B ip_Parabola_A ip_Hermite_B ip_Aitken_B

####### ip_Hermite_A

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
X := array(1, 1.2, 1.5, 2.3, 2.9, 4, 4.5, 8);
Y := X ^ 2 - X;
Dy := 2 * X - 1;
xv := 3;
ip_Hermite_A(X, Y, Dy, xv, yv);
return yv;
// 结果：6
```

参考ip_Lagrangian_A ip_Parabola_A ip_Hermite_B ip_Aitken_A

####### ip_Hermite_B

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
X0 := 1;
h := 1;
Y := array(0, 2, 6, 12, 20, 30);
Dy := array(1, 3, 5, 7, 9, 11);
xv := 4.5;
ip_Hermite_B(X0, h, Y, Dy, xv, yv);
return yv;
// 结果：15.75
```

参考ip_Lagrangian_B ip_Parabola_B ip_Hermite_A ip_Aitken_B

####### ip_Aitken_A

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```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);
xv := 3;
ip_Aitken_A(X, Y, xv, yv);
return yv;
// 结果：9.32917
```

参考ip_Lagrangian_A ip_Parabola_A ip_Hermite_A ip_Aitken_B

####### ip_Aitken_B

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
X0 := 1.3;
h := 0.5;
Y := array(1, 3, 4, 6, 9, 11, 13);
xv := 3;
ip_Aitken_B(X0, h, Y, xv, yv);
return yv;
// 结果：7.08
```

参考ip_Lagrangian_B ip_Parabola_B ip_Hermite_B ip_Aitken_A

####### ip_Spline_A

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
X := array(1, 2, 3, 4, 5, 6);
Y := array(0, 2, 6, 12, 20, 30);
dy0 := 1;
dyn_1 := 11;
xv := 4.5;
ip_Spline_A(X, Y, dy0, dyn_1, xv, yv);
return yv;
// 结果：15.75
```

参考ip_Spline_B ip_Spline_C

####### ip_Spline_B

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
X := array(1, 2, 3, 4, 5, 6);
Y := array(0, 2, 6, 12, 20, 30);
ddy0 := 2;
ddyn_1 := 2;
xv := 4.5;
ip_Spline_B(X, Y, ddy0, ddyn_1, xv, yv);
return yv;
// 结果：15.2828
```

参考ip_Spline_A ip_Spline_C

####### ip_Spline_C

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
X := array(1, 2, 3, 4, 5, 6);
Y := array(2, 6, 3, 0, 3, 2);
xv := 3.5;
ip_Spline_C(X, Y, xv, yv);
return yv;
// 结果：0.71591
```

参考ip_Spline_A ip_Spline_B

####### ip_SLQ

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```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));
xv := 3.5;
yv := 4.5;
ip_SLQ(X, Y, z, xv, yv, zv);
return zv;
// 结果：29.59375
```

参考ip_SLG

####### ip_SLG

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```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));
xv := 3.5;
yv := 4.5;
ip_SLG(X, Y, z, xv, yv, zv);
return zv;
// 结果：31.54688
```

参考ip_SLQ

###### 矩阵运算及分解

####### 内容

- mt_Transposition
- mt_Multiplication
- mt_Addition
- mt_iv_Gauss_Jordan
- mt_iv_Ldl
- mt_Subtraction
- Mt_decompose_lu
- mt_decompose_qr
- mt*va* Cholesky
- mt_decompose_chol
- chol
- mt_va_Gauss_Jordan
- mt_decompose_svd
- mt_decompose_ldl
- mt_decompose_eig
- Standarize_II
- ReIndex2
- Det
- isSymmetry
- Orth
- roots
- Eigen
- pinv
- norm2
- Cond
- diag
- isDefinite

####### mt_Transposition

用途：数值计算相关函数。
参数：

返回：整数。

范例

```tsl
A := array((1, 3, 6),
(0, 4, 2));
mt_Transposition(A, C);
return C;
// 结果：
array((1, 0),
(3, 4),
(6, 2))
```

参考mt_Multiplication mt_Addition mt_Subtraction

####### mt_Multiplication

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
A := array((1, 3, 6),
(0, 4, 2));
B := array((1, 2),
(4, 0),
(3, 2));
mt_Multiplication(A, B, C);
return C;
// 结果：
array((31, 14),
(22, 4))
```

参考mt_Addition mt_Subtraction mt_Transposition

####### mt_Addition

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
A := array((1, 3, 6),
(0, 4, 2));
B := array((1, 2, 4),
(0, 3, 2));
mt_Addition(A, B, C);
return C;
// 结果：
array((2, 5, 10),
(0, 7, 4))
```

参考mt_Multiplication mt_Subtraction mt_Transposition

####### mt_iv_Gauss_Jordan

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
A := array((3, 2),
(4, 6));
mt_iv_Gauss_Jordan(A, X);
return X;
// 结果：
array((0.6, -0.2),
(-0.4, 0.3))
```

参考mt_iv_Ldl

####### mt_iv_Ldl

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
A := array((1, 4),
(4, 6));
mt_iv_Ldl(A, X);
return X;
// 结果：
array((-0.6, 0.4),
(0.4, -0.1))
```

参考mt_iv_Gauss_Jordan

####### mt_Subtraction

用途：进行字符串提取或替换处理。
参数：

返回：处理后的结果值。

范例

```tsl
A := array((1, 3, 6),
(0, 4, 2));
B := array((1, 2, 4),
(0, 3, 2));
mt_Subtraction(A, B, C);
return C;
// 结果：
array((0, 1, 2),
(0, 1, 0))
```

参考mt_Multiplication mt_Addition mt_Transposition

####### Mt_decompose_lu

用途：数值计算相关函数。
参数：

返回：整数。

范例

```tsl
H := corr(rand(100, 4));
Mt_decompose_lu(H, L, U);
return array(L, U);
```

参考Mt_decompose_lu chol mt_decompose_qr mt_decompose_eig mt_decompose_svd
mt_decompose_ldl mt_decompose_chol

####### mt_decompose_qr

用途：数值计算相关函数。
参数：

返回：整数。

范例

范例01：

```tsl
H := corr(rand(100, 4));
mt_decompose_qr(H, Q, R); // QR分解
return array(Q, R);
```

范例02：

```tsl
H := corr(rand(100, 4));
return mt_decompose_qr(H); // 返回上三角矩阵
```

范例03：

```tsl
H := corr(rand(100, 4));
mt_decompose_qr(H, Q, R, E, 0);
return array(Q, R, E);
```

参考Mt_decompose_lu chol mt_decompose_eig mt_decompose_svd mt_decompose_ldl
mt_decompose_chol

####### mt*va* Cholesky

范例

```tsl
A := array((1, 2),
(2, 6));
mt_va_Cholesky(A, v);
return v;
// 结果：1.414
```

参考mt_va_Gauss_Jordan

####### mt_decompose_chol

参考Mt_decompose_lu chol mt_decompose_qr mt_decompose_eig mt_decompose_ldl

####### chol

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
H := corr(rand(100, 4));
chol(H, L, p); // 乔列斯基分解
if p = -1 then return L; // p=-1表示分解成功
```

参考Mt_decompose_lu mt_decompose_qr mt_decompose_eig mt_decompose_svd
mt_decompose_ldl mt_decompose_chol

####### mt_va_Gauss_Jordan

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
A := array((1, 4),
(4, 6));
mt_va_Gauss_Jordan(A, v);
return v;
// 结果：-10
```

参考mt*va* Cholesky

####### mt_decompose_svd

算法

假设矩阵A为一个m×n的矩阵，定义矩阵A的SVD分解为：

A=USDT

其中U为m×m矩阵，S为m×n矩阵，D为个n×n矩阵，其中U、D都为酉矩阵。

求解U、S、D三个矩阵的步骤如下：

1)根据下式求解方阵ATA的特征值与特征向量:

ATAdi=λidi

n个特征向量di组成右奇异矩阵D。

同理，利用AATui=λiui计算可得左奇异矩阵U。

2)求奇异值矩阵S（除了对角线为奇异值σi，其余位置为0）可根据以下公式求得：

AD=USAdi=uiσi

(也可通过σi=λi计算)，即可计算出奇异值矩阵S。范例

```tsl
// 计算矩阵A的SVD分解
A := array((0, 1), (1, 1), (1, 0));
Mt_Decompose_SVD(A, U, S, D);
// 反推初始矩阵A，使用U:*(eye(3,2)*S):*`D;
return array((U), (S), (D));
```

U，S，D矩阵分别为：

####### mt_decompose_ldl

参考Mt_decompose_lu chol mt_decompose_qr mt_decompose_eig mt_decompose_chol

####### mt_decompose_eig

用途：数值计算相关函数。
参数：

返回：整数。

范例

```tsl
H := corr(rand(100, 4));
mt_decompose_eig(H, wr, wi, vr);
return array(wr, wi, vr);
```

参考Mt_decompose_lu chol mt_decompose_qr mt_decompose_svd mt_decompose_ldl
mt_decompose_chol

####### Standarize_II

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 每列之和为0
A := rand(5, 5);
A := Standarize_II(a, 7);
return A;
```

####### ReIndex2

范例

范例数据表：a:=array('C':('A':1,'B':'too'),'D':('A':2,'B':'two'));

其显示如下：

范例一：将表列标改为数字

```tsl
a := array('C':('A':1, 'B':'too'), 'D':('A':2, 'B':'two'));
return reindex2(a, 0);
```

范例二：将行列标作为首列首行

```tsl
a := array('C':('A':1, 'B':'too'), 'D':('A':2, 'B':'two'));
return reindex2(a, 5);
```

####### Det

范例

```tsl
A := array((1, 2), (3, 4));
return det(A); // -2
```

####### isSymmetry

用途：判断条件是否成立。
参数：

返回：布尔值。

范例

```tsl
A := array((2, 1), (1, 3));
return isSymmetry(A, 0.1); // 1
```

####### Orth

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 计算矩阵A的标准正交基
A := array((0, 1), (1, 1), (1, 0));
return Orth(A);
```

####### roots

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求根：3x^3+x^2+x^1+0^0=0
return roots(array(0, 1, 1, 3));
```

####### Eigen

范例

```tsl
A := array((1, 2), (3, 4));
eigen(A, eigen);
return eigen;
// array(-0.37,5.37)
```

####### pinv

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array((9, 1), (-1, 0), (0, 2), (1, 1));
return pinv(x);
```

####### norm2

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
A := array((2, 1), (1, 3));
return norm2(A, 'inf'); // 4
```

####### Cond

范例

```tsl
x := array((9, 1), (-1, 0), (0, 2), (1, 1));
return cond(x); // 4.22
```

####### diag

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
A := array((2, 1), (1, 3));
return diag(A); // array(2,3);
```

####### isDefinite

用途：判断条件是否成立。
参数：

返回：布尔值。

范例

```tsl
x := array((3, 1), (1, 4));
return isDefinite(x); // 1
```

###### 数组扩展

####### 内容

- Any
- ALL

####### Any

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

范例一：

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

范例二：

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

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

范例一：

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

范例二：

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

###### 其他

####### 内容

- perms
- nchoosek
- MaxDrawDown
- MinRecoveryTime
- Betainc
- PercentileOfScore
- GenerateCombinations
- Percentage

####### perms

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

范例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);
```

范例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;
```

####### nchoosek

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return nchoosek(array('a', 'b', 'c', 'd'), 2);
```

结果:

array(

("d","c"),

("d","b"),

("d","a"),

("c","b"),

("c","a"),

("b","a"))

####### MaxDrawDown

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

算法

数据差序列

Fi,j=xj-xi ,其中(i<j,且d2≤j-i≤d1)

寻找入点与出点

若最大涨幅，则Up(i,j)=Max(Fi,j)

若最大跌幅，则Down(i,j)=Min(Fi,j)

即入点：i 出点：j

值差

Dv=xj-xi

比例

Rv=xjAbs(xi)-1，若xi=0,则xi=1.0e-5

注：

i、j：分别为序列Data的下标值，从0开始。

xi、xj：分别为序列Data中下标为i、j的元素值 。

d1：最大间隔，默认为最大长度，即length(Data)-1。

d2：最小间隔（本函数不支持该约束条件的设置），默认为1。

1.0e-5：即0.00001范例

范例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：

```text
12
43
6.96759
0.25765
```

注：若需计算最大跌幅率，则只需t[3]\*100即可。

####### MinRecoveryTime

用途：日期时间处理函数。
参数：

返回：日期或时间值。

范例

科大讯飞(SZ002230)在20201220最近十个交易日序列中第一天购买第二天卖出后的最小恢复时间

```tsl
setsysparam(pn_stock(), "SZ002230");
setsysparam(PN_Date(), 20201220t);
R := nday(10, "close", close())[:, "close"];
return MinRecoveryTime(R, 0, 1);
```

返回结果：6

####### Betainc

范例

```tsl
a := 3;
b := 4;
tail := 'upper';
x := rand(10);
return array(betainc(x, a, b), betainc(x, a, b, tail));
```

####### PercentileOfScore

范例

去除随机数组的极值

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

####### GenerateCombinations

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
list := array('a', 'b', 'c');
GenerateCombinations(list, ret);
return ret;
```

####### Percentage

用途：数值计算相关函数。
参数：

返回：处理后的结果值。

范例

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

##### 常用数学函数

###### 内容

- Pi
- Odd
- Abs
- Sqr
- Sqrt
- DivMod
- Frexp
- Ldexp
- Poly
- 简单函数对数组支持

###### Pi

用途：常用数学函数相关函数。
参数：无。
返回：处理后的结果值。

范例

```tsl
// 求面积(π*R^2)
R := 2;
return Pi() * R ^ 2;
// 结果：12.5663706143592
```

###### Odd

用途：常用数学函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 判断1是否是奇数
return Odd(1);
// 结果：1
```

参考简单函数对数组支持

###### Abs

用途：常用数学函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求-2的绝对值
return Abs(-2);
// 结果：2
```

参考简单函数对数组支持

###### Sqr

用途：常用数学函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求x^2
X := 2;
return Sqr(x);
// 结果：4
```

参考简单函数对数组支持 Sqrt Power

###### Sqrt

用途：常用数学函数相关函数。
参数：

返回：处理后的结果值。

范例

求实数的平方根

```tsl
X := 4;
return Sqrt(x);
// 结果：2
```

计算一维数组中所有元素的平方根

```tsl
X := array(4, 9, 16, 25);
return Sqrt(x);
// 结果：array(2,3,4,5)
```

参考简单函数对数组支持 Sqrt Power

###### DivMod

用途：常用数学函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
DivMod(5, 3, a, b);
return array(a, b);
```

参考简单函数对数组支持

###### Frexp

用途：常用数学函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 将X分离出位数和指数,即X= Base *2^ Exponent
X := pi();
Frexp(X, Base, Exponent);
return array(Base, Exponent);
```

参考简单函数对数组支持 Ldexp

差异说明对于奇异值的处理（如INF,NAN等），在不同系统中表现会存在差异。

所以，在使用前尽量先排除掉奇异值。

如：

Frexp(INF,a,b);

return array(a,b);

windows系统下运行，返回：array(INF,-1)

而Linux系统下运行，返回：array(INF,0)

###### Ldexp

用途：常用数学函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Ldexp(3, 2);
// 结果：12  //返回3*2^2
```

参考简单函数对数组支持 Ldexp

###### Poly

用途：常用数学函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
X := 2;
a := array(2, 3, 1, 5);
return Poly(x, a);
// 结果：52
// 返回2*(2^0)+3*(2^1)+1*(2^2)+ 5*(2^3)
```

参考简单函数对数组支持

###### 简单函数对数组支持

以前平台多数基本函数（比如sin）都不支持数组的输入,升级之后的函数不仅支持了数组,还加入了对于异常值的处理。`func(In1,In2...InN[,Out1,...OutN])`，In参数除支持数组外，还增加了两个可选参数 `func(In1,In2...InN[,Out1,...OutN][,Opt1,Opt2])`

Opt1：异常值处理，为0表示不做处理（默认情况）;为1表示计算跳过nil值;为2表示跳过所有的异常值；

Opt2: 报错填充值，当某单元报错的时候，使用该参数填充。

单参数输入，以SIN函数为例，多个参数输入，以LogN为例：

正常的二维数组的处理

```tsl
a := rand(10, array("a", "b", "c"));
return sin(a);
```

当出现nil值的时候，计算跳过:

```tsl
a := rand(10, 10);
a[0, 1] := nil;
return sin(a, 1); // 得到的结果nil位置的值还是nil
```

当出现nil值,字符串的时候，计算跳过：

```tsl
a := rand(10, 10);
a[0, 1] := nil;
a[0, 2] := "a";
return sin(a, 2); // 得到的结果nil位置的值还是nil，”a”位置还是”a”
```

当出现nil值,字符串的时候，结果填入替换值：

```tsl
a := rand(10, 10);
a[0, 1] := nil;
a[0, 2] := "a";
return sin(a, 0, "替换值");
```

只当出现nil值的时候跳过,出现字符串的时候替换为设置值：

```tsl
a := rand(10, 10);
a[0, 1] := nil;
a[0, 2] := "a";
return sin(a, 1, "替换值");
```

多个参数（不包括输出变参）输入，以LogN为例：

LogN(Base,X:Real Or Array of Real;[varOpt1: Integer;[Opt2:Any]]:Real Or Array of
Real;

这类函数需要注意X，Y在维度不一致的时候，比如X是一个二维数组,Y是一个一维数组:

```tsl
X := 2 * ones(10, 10);
Base := 2 -  > 11;
return LogN(Base, X);
```

这里最直观的的理解是把二维数组看成一维数据（其每一个元素是一维数组），所以，这个问题也就简化为两个等大小的一维数组在做计算了。超过两个以上主要参数的操作是类似的

支持这项操作的函数包括：

单参数输入：

常用数学函数：Odd，Abs，Sqr，Sqrt

三角函数：Sin，Cos，Tan，Cot，CoTan，Sec，Csc，Secant，Cosecant，ArcSin，ArcCos，ArcTan，ArcCot，ArcSec，ArcCsc，SinCos

角度转换函数，双曲线函数

指数对数函数：Ln，LnXP1，Log10，Log2，Exp

精度设置及取整函数：Int，Ceil，Ceil32，Ceil64，Floor，Floor32，Floor64，Trunc，Trunc32，Trunc64，Frac，Round，Round32，Round64，SimpleRound，SimpleRound32，SimpleRound64

比较判断函数：IsNan，IsInfinite，Sign

多个参数输入：

DivMod，Frexp，Ldexp，Poly，ArcTan2，Hypot，LogN，IntPower，Power，RoundTo，SimpleRoundTo，IsZero，Min，Max，CompareValue，SameValue，RandomRange，InRange，EnsureRange，RandG，财务函数等

##### 位运算函数

###### 内容

- \_And
- \_Or
- \_Not
- \_Xor
- \_Shl
- \_Shr
- \_Rol
- \_Ror

###### \_And

范例

```tsl
return _And(6, 3); // 返回十进制(6=110) and 3=(11) 最后得到二进制10
// 结果：2
```

参考\_Or \_Not \_Xor \_Shl \_Shr \_Rol \_Ror

###### \_Or

范例

```tsl
return _Or (6, 3);
// 结果：7
// 返回十进制(6=110) or 3=(11) 最后得到二进制111，十进制是7
```

参考\_And \_Not \_Xor \_Shl \_Shr \_Rol \_Ror

###### \_Not

范例

```tsl
return _Not (4);
// 结果：-5
// 返回十进制_not (4=00000100) 取非运算最后得到二进制11111011，十进制//是-5,注意：在计算机中,负数以其正值的补码形式表示。补码是烦吗+1，
// 5=00000101，得到反码11111010，得到补码11111011=-5
```

参考\_And \_Or \_Xor \_Shl \_Shr \_Rol \_Ror

###### \_Xor

范例

```tsl
return _Xor (6, 3);
// 结果：5
// 返回十进制 (6=110) Xor (3=011) 最后得到二进制101，十进制是5
```

参考\_And \_Or \_Not \_Shl \_Shr \_Rol \_Ror

###### \_Shl

范例

```tsl
return _Shl (6, 3);
// 结果：48
// 返回十进制 (6=110) _Shl 3 最后得到二进制110000，十进制是48
```

参考\_And \_Or \_Not \_Xor \_Shr \_Rol \_Ror

###### \_Shr

范例

```tsl
return _Shr (36, 3);
// 结果：4
// 返回十进制 (36=100100) _Shr 3最后得到二进制00000100，十进制是4
```

参考\_And \_Or \_Not \_Xor \_Shl \_Rol \_Ror

###### \_Rol

范例

```tsl
return _Rol (36, 3);
// 结果：288
// 返回十进制 (36=100100) 左移3位,最后得到二进制100100000，十进制是//288
```

参考\_And \_Or \_Not \_Xor \_Shl \_Shr \_Ror

###### \_Ror

范例

```tsl
return _Ror (36, 2);
// 结果：9
// 返回十进制 (36=100100) 右移2位,最后得到二进制00001001，十进制是9
```

参考\_And \_Or \_Not \_Xor \_Shl \_Shr \_Rol

##### 三角函数

###### 内容

- Sin
- Cos
- SinCos
- Tan
- Cot
- CoTan
- Sec
- Csc
- Secant
- Cosecant
- ArcSin
- ArcCos
- ArcTan
- ArcTan2
- ArcCot
- ArcSec
- ArcCsc
- Hypot

###### Sin

用途：三角函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求sin(π/6)
return Sin(pi() / 6);
// 结果：0.5
```

参考简单函数对数组支持 Cos SinCos ArcSin Sinh

###### Cos

用途：三角函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求cos(π/3)
return Cos(pi() / 3);
// 结果：0.5
```

参考简单函数对数组支持 Sin SinCos Cosecant ArcCos Cosh

###### SinCos

用途：三角函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
SinCos(pi() / 2, sin, cos);
return array(sin, cos);
```

参考简单函数对数组支持 Cos SinCos ArcSin Sinh

###### Tan

用途：三角函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求tan(π/4)
return Tan(pi() / 4);
// 结果：1
```

参考简单函数对数组支持 Cot CoTan ArcTan ArcTan2 Tanh

###### Cot

用途：三角函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求Cot (π/4)
return Cot(pi() / 4);
// 结果：1
```

参考简单函数对数组支持 CoTan ArcCot ArcCotH Tan

###### CoTan

用途：三角函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求Cotan(π/4)
return CoTan(pi() / 4);
// 结果：1
```

参考简单函数对数组支持 CoTan ArcCot ArcCotH Tan

###### Sec

用途：三角函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求Sec(π/3)
return Sec(pi() / 3);
// 结果：2
```

参考简单函数对数组支持 Csc Secant ArcSec SecH

###### Csc

用途：三角函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求Csc(π/6)
return Csc(pi() / 6);
// 结果：2
```

参考简单函数对数组支持 Sec Secant ArcCsc CscH

###### Secant

用途：三角函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求Secant (π/6)
return Secant(pi() / 3);
// 结果：2
```

参考简单函数对数组支持 Sec Csc ArcSec SecH

###### Cosecant

用途：三角函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求Cosecant (π/6)
return Cosecant(pi() / 6);
// 结果：2
```

参考简单函数对数组支持 Sin SinCos Cosecant ArcCos Cosh

###### ArcSin

用途：三角函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return ArcSin(1);
// 结果：1.57   //约等于π/2
```

参考简单函数对数组支持 Sin ArcSinh

###### ArcCos

用途：三角函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return ArcCos(0);
// 结果：1.57   //约等于π/2
```

参考简单函数对数组支持 Cos Cosecant ArcCosh

###### ArcTan

用途：三角函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求ArcTan(1)
return ArcTan(1);
// 结果：0.785398163397448 //该值=pi()/4
```

参考简单函数对数组支持 ArcTan2 ArcTan ArcTanh

###### ArcTan2

用途：三角函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return ArcTan2(1, 2);
// 结果：0.46
```

参考简单函数对数组支持 Tan ArcTan ArcTanh

###### ArcCot

用途：三角函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return ArcCot(1);
// 结果：0.7854
```

参考简单函数对数组支持 Cot CoTan ArcCotH

###### ArcSec

用途：三角函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求ArcSec(2)
return ArcSec(2);
// 结果：1.05
```

参考简单函数对数组支持 Secant Sec ArcSecH

###### ArcCsc

用途：三角函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求ArcCsc(2)
return ArcCsc(2);
// 结果：0.52
```

参考简单函数对数组支持 Csc ArcCscH

###### Hypot

用途：三角函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求Hypot (3,4)
return Hypot(3, 4); // 返回sqrt(3^2+4^2)
// 结果：5
```

参考简单函数对数组支持 ArcTan2

##### 角度量转换

###### 内容

- RadToDeg
- RadToGrad
- RadToCycle
- DegToRad
- DegToGrad
- DegToCycle
- GradToRad
- GradToDeg
- GradToCycle
- CycleToRad
- CycleToDeg
- CycleToGrad

###### RadToDeg

用途：角度量转换相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求RadToDeg (π/3)
return RadToDeg(pi() / 3);
// 结果：60
```

参考简单函数对数组支持 RadToGrad RadToCycle DegToRad DegToGrad DegToCycle
GradToRad GradToDeg CycleToRad CycleToDeg

###### RadToGrad

用途：角度量转换相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求RadToGrad (π/4)
return RadToGrad(pi() / 4);
// 结果：50
```

参考简单函数对数组支持 RadToDeg RadToCycle DegToRad DegToGrad GradToRad
GradToDeg GradToCycle CycleToRad CycleToGrad

###### RadToCycle

用途：角度量转换相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求RadToCycle (π/4)
return RadToCycle(pi() / 4);
// 结果：0.125
```

参考简单函数对数组支持 RadToDeg RadToGrad DegToRad DegToCycle GradToRad
GradToCycle CycleToRad CycleToDeg CycleToGrad

###### DegToRad

用途：角度量转换相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求DegToRad (60)
return DegToRad(60);
// 结果：1.0472    //返回π/3
```

参考简单函数对数组支持 RadToDeg RadToGrad RadToCycle DegToGrad DegToCycle
GradToRad GradToDeg CycleToRad CycleToDeg

###### DegToGrad

用途：角度量转换相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求DegToGrad (90)
return DegToGrad(90);
// 结果：100
```

s参考简单函数对数组支持 RadToDeg RadToGrad DegToRad DegToCycle GradToRad
GradToDeg GradToCycle CycleToDeg CycleToGrad

###### DegToCycle

用途：角度量转换相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求DegToCycle(45)
return DegToCycle(45);
// 结果：0.125
```

参考简单函数对数组支持 RadToDeg RadToCycle DegToRad DegToGrad GradToDeg
GradToCycle CycleToRad CycleToDeg CycleToGrad

###### GradToRad

用途：角度量转换相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求GradToRad(50)
return GradToRad(50);
// 结果：0.79//结果相当于π/4
```

参考简单函数对数组支持 RadToDeg RadToGrad RadToCycle DegToRad DegToGrad
GradToDeg GradToCycle CycleToRad CycleToGrad

###### GradToDeg

用途：角度量转换相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求GradToDeg(50)
return GradToDeg(50);
// 结果：45
```

参考简单函数对数组支持 RadToDeg RadToGrad DegToRad DegToGrad DegToCycle
GradToRad GradToCycle CycleToDeg CycleToGrad

###### GradToCycle

用途：角度量转换相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求GradToCycle(100)
return GradToCycle(100);
// 结果：0.25
```

参考简单函数对数组支持 RadToGrad RadToCycle DegToGrad DegToCycle GradToRad
GradToDeg CycleToRad CycleToDeg CycleToGrad

###### CycleToRad

用途：角度量转换相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求CycleToRad(1/4)
return CycleToRad(1 / 4);
// 结果：1.57 //相当于π/2
```

参考简单函数对数组支持 RadToDeg RadToGrad RadToCycle DegToRad DegToCycle
GradToRad GradToCycle CycleToDeg CycleToGrad

###### CycleToDeg

用途：角度量转换相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求CycleToDeg(1/4)
return CycleToDeg(1 / 4);
// 结果：90
```

参考简单函数对数组支持 RadToDeg RadToCycle DegToRad DegToGrad DegToCycle
GradToDeg GradToCycle CycleToRad CycleToGrad

###### CycleToGrad

用途：角度量转换相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求CycleToGrad(1/4)
return CycleToGrad(1 / 4);
// 结果：100
```

参考简单函数对数组支持 RadToGrad RadToCycle DegToGrad DegToCycle GradToRad
GradToDeg GradToCycle CycleToRad CycleToDeg

##### 双曲线函数

###### 内容

- Sinh
- Cosh
- Tanh
- CotH
- SecH
- CscH
- ArcCosh
- ArcSinh
- ArcTanh
- ArcCotH
- ArcSecH
- ArcCscH

###### Sinh

用途：双曲线函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求Sinh (2)
return Sinh(2);
// 结果：3.63
```

参考简单函数对数组支持 Cosh ArcSinh Sin

###### Cosh

用途：双曲线函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求Cosh(2)
return Cosh(2);
// 结果：3.76
```

参考简单函数对数组支持 Cos Cosecant Sinh ArcCosh

###### Tanh

用途：双曲线函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求Tanh(2)
return Tanh(2);
// 结果：0.96
```

参考简单函数对数组支持 Tan CotH ArcTanh

###### CotH

用途：双曲线函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求CotH(2)
return CotH(2);
// 结果：1.04
```

参考简单函数对数组支持 Cot CoTan Tanh ArcCotH

###### SecH

用途：双曲线函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求SecH(2)
return SecH(2);
// 结果：0.27
```

参考简单函数对数组支持 Secant Sec CscH ArcSecH

###### CscH

用途：双曲线函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求CscH (2)
return CscH(2);
// 结果：0.28
```

参考简单函数对数组支持 Csc SecH ArcCscH

###### ArcCosh

用途：双曲线函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求ArcCosh(2)
return ArcCosh(2);
// 结果：1.32
```

参考简单函数对数组支持 Cosh ArcCos

###### ArcSinh

用途：双曲线函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求ArcSinh (2)
return ArcSinh(2);
// 结果：1.44
```

参考简单函数对数组支持 ArcSin Sinh

###### ArcTanh

用途：双曲线函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求ArcTanh(0.8)
return ArcTanh(0.8);
// 结果：1.1
```

参考简单函数对数组支持 Tanh ArcTan

###### ArcCotH

用途：双曲线函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求ArcCotH(4)
return ArcCotH(4);
// 结果：0.26
```

参考简单函数对数组支持 ArcCot Tanh

###### ArcSecH

用途：双曲线函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求ArcSecH(4)
return ArcSecH(0.5);
// 结果：1.32
```

参考简单函数对数组支持 SecH ArcSec

###### ArcCscH

用途：双曲线函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求ArcCscH(4)
return ArcCscH(4);
// 结果：0.25
```

参考简单函数对数组支持 ArcCsc CscH

##### 指数对数函数

###### 内容

- Ln
- LnXP1
- Log10
- Log2
- LogN
- Exp
- IntPower
- Power

###### Ln

用途：指数对数函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求ln(e^2)
return Ln(7.38905609893065);
// 结果：2
```

参考简单函数对数组支持 LnXP1 Log10 Log2 LogN Exp IntPower Power

###### LnXP1

用途：指数对数函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return LnXP1(3);
// 结果：1.39 //返回ln4
```

参考简单函数对数组支持 Ln Log10 Log2 LogN Exp IntPower Power

###### Log10

用途：指数对数函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Log10(100);
// 结果：2 //返回log10100
```

参考简单函数对数组支持 Ln LnXP1 Log2 LogN Exp IntPower Power

###### Log2

用途：指数对数函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Log2(8);
// 结果：3 //返回log28
```

参考简单函数对数组支持 Ln LnXP1 Log10 LogN Exp IntPower Power

###### LogN

用途：指数对数函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return LogN(2, 8);
// 结果：3 //返回log28
```

参考简单函数对数组支持 Ln LnXP1 Log10 Log2 Exp IntPower Power

###### Exp

用途：指数对数函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求e^2
return Exp(2);
// 结果：7.38905609893065
```

参考简单函数对数组支持 Ln LnXP1 Log10 Log2 LogN IntPower Power

###### IntPower

用途：指数对数函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return IntPower(2, 3.2);
// 结果：8 //返回2^3
```

参考简单函数对数组支持 Ln LnXP1 Log10 Log2 LogN Exp Power

###### Power

用途：指数对数函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Power(2, 3.2);
// 结果：9.19 //返回2^3.2
```

参考简单函数对数组支持 Ln LnXP1 Log10 Log2 LogN Exp IntPower

##### 精度设置及取整运算

###### 内容

- Int
- Ceil
- Ceil32
- Ceil64
- Floor
- Floor32
- Floor64
- Trunc
- Trunc32
- Trunc64
- Frac
- Round
- Round32
- Round64
- SimpleRound
- SimpleRound32
- SimpleRound64
- RoundTo
- SimpleRoundTo

###### Int

用途：精度设置及取整运算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求x
X := 2.45;
return Int(x);
// 结果：2.0
```

参考简单函数对数组支持 Ceil Floor Trunc Frac

###### Ceil

用途：精度设置及取整运算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Ceil(-2.8);
// 结果：-2
```

参考简单函数对数组支持 Ceil32 Ceil64 Int Floor Trunc Frac

###### Ceil32

用途：精度设置及取整运算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Ceil32(-2.8);
// 结果：-2
```

参考简单函数对数组支持 Int Ceil Floor Trunc Frac

###### Ceil64

用途：精度设置及取整运算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Ceil64(-2.8);
// 结果：-2
```

参考简单函数对数组支持 Int Ceil Floor Trunc Frac

###### Floor

用途：精度设置及取整运算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Floor(-2.8);
// 结果：-3
```

参考简单函数对数组支持 Floor32 Floor64 Int Ceil Trunc Frac

###### Floor32

用途：精度设置及取整运算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Floor32(-2.8);
// 结果：-3
```

参考简单函数对数组支持 Int Ceil Floor Trunc Frac

###### Floor64

用途：精度设置及取整运算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Floor64(-2.8);
// 结果：-3
```

参考简单函数对数组支持 Int Ceil Floor Trunc Frac

###### Trunc

用途：精度设置及取整运算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := Trunc(-6.8);
return x;
// 结果：-6
```

参考简单函数对数组支持 Trunc32 Trunc64 Int Ceil Floor Frac

###### Trunc32

用途：精度设置及取整运算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := Trunc32(-6.8);
return x;
// 结果：-6
```

参考简单函数对数组支持 Int Ceil Floor Trunc Frac

###### Trunc64

用途：精度设置及取整运算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := Trunc64(6.8);
return x;
// 结果：6
```

参考简单函数对数组支持 Int Ceil Floor Trunc Frac

###### Frac

用途：精度设置及取整运算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求x
X := 2.45;
return Frac(x);
// 结果：0.45
```

参考简单函数对数组支持 Int Ceil Floor Trunc

###### Round

用途：精度设置及取整运算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求x
X := 3.5;
return Round(x);
// 结果：4
```

参考简单函数对数组支持 Round32 Round64 SimpleRound RoundTo SimpleRoundTo

###### Round32

用途：精度设置及取整运算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := Round32(6.8);
return x;
// 结果：7
```

参考简单函数对数组支持 Round SimpleRound RoundTo SimpleRoundTo

###### Round64

用途：精度设置及取整运算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := Round64(3.5);
return x;
// 结果：4
```

参考简单函数对数组支持 Round SimpleRound RoundTo SimpleRoundTo

###### SimpleRound

用途：精度设置及取整运算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 求x
X := 3.5;
return SimpleRound(x);
// 结果：4
```

参考简单函数对数组支持 SimpleRound32 SimpleRound64 Round RoundTo SimpleRoundTo

###### SimpleRound32

用途：精度设置及取整运算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := SimpleRound32(6.8);
return x;
// 结果：7
```

参考简单函数对数组支持 Round SimpleRound RoundTo SimpleRoundTo

###### SimpleRound64

用途：精度设置及取整运算相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := SimpleRound64(3.5);
return x;
// 结果：4
```

参考简单函数对数组支持 Round SimpleRound RoundTo SimpleRoundTo

###### RoundTo

用途：精度设置及取整运算相关函数。
参数：

返回：处理后的结果值。

范例

范例01：整数四舍五入

```tsl
return RoundTo(1234567.3, 4);
// 结果：1230000
```

范例02：小数部分四舍五入

```tsl
return RoundTo(1.234567, -3);
// 结果：1.235
```

参考简单函数对数组支持 Round SimpleRound SimpleRoundTo

###### SimpleRoundTo

用途：精度设置及取整运算相关函数。
参数：

返回：处理后的结果值。

范例

范例01：

```tsl
return SimpleRoundTo(1234567.3，4);
// 结果：1230000
```

范例02：

```tsl
return SimpleRoundTo(-1.235, -2);
// -1.24
```

参考简单函数对数组支持 Round SimpleRound RoundTo

##### 比较判断函数

###### 内容

- IsNan
- IsInfinite
- Sign
- IsZero
- Min
- Max
- CompareValue
- SameValue
- RandomRange
- InRange
- EnsureRange

###### IsNan

用途：判断条件是否成立。
参数：

返回：布尔值。

范例

范例01：判断单个值是否nan

```tsl
v := nan;
return IsNan(v); // 1
```

范例02：判断数组中各元素是否nan

```tsl
Data := array(2, nan, 3, '', 's', nil);
return IsNan(data);
```

参考简单函数对数组支持 IsInfinite

###### IsInfinite

用途：判断条件是否成立。
参数：

返回：布尔值。

范例

范例01：判断单个值是否inf

```tsl
return IsInfinite(inf);
// 结果：1
```

范例02：判断数组中各元素是否nan

```tsl
Data := array(2, nan, 3, '', 's', nil, inf);
return IsInfinite(data);
```

参考简单函数对数组支持 IsNan

###### Sign

用途：比较判断函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Sign(-2);
// 结果：-1
```

参考简单函数对数组支持

###### IsZero

用途：判断条件是否成立。
参数：

返回：布尔值。

范例

```tsl
a := 1.400000000001;
b := 1.399999999999;
return IsZero(a - b, 0.000000001); // 在9位小数的精度下
// 结果：1
```

参考简单函数对数组支持 CompareValue SameValue RandomRange InRange EnsureRange

###### Min

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

```tsl
// 比较两个值
return Min(3, 3.6);
// 结果：3
```

比较两个数组

```tsl
a := array(1, 3, 5);
b := array(2, 3, 4);
return Min(a, b);
```

参考简单函数对数组支持 MinValue MinIntValue MaxValue MaxIntValue Max

###### Max

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

```tsl
return Max(5, 5.6);
// 结果：5.6
return Max(array(1, 2, 8), array(4, 5, 6));
```

参考简单函数对数组支持 MinValue MinIntValue MaxValue MaxIntValue Min

###### CompareValue

用途：比较判断函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return CompareValue(3, 4, 0.5);
// 结果：-1
// 表示3与4之间的差距超过0.5则正常比较，否则认为相等
```

参考简单函数对数组支持 IsZero SameValue RandomRange InRange EnsureRange

###### SameValue

用途：比较判断函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return SameValue(3, 4, 0.5);
// 结果：0
// 表示3与4之间的差距在0.5之内认为相等,否则认为不相等
```

参考简单函数对数组支持 IsZero CompareValue RandomRange InRange EnsureRange

###### RandomRange

用途：比较判断函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return RandomRange(4.7, 8.5);
// 结果：5//返回4到8之间的随机整数
```

参考简单函数对数组支持 IsZero CompareValue SameValue InRange EnsureRange

###### InRange

用途：比较判断函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return InRange(4.3, 4, 8);
// 结果：1
```

参考简单函数对数组支持 IsZero CompareValue SameValue RandomRange EnsureRange

###### EnsureRange

用途：比较判断函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return EnsureRange(4.3, 4, 8);
// 结果：4.3
```

参考简单函数对数组支持 IsZero CompareValue SameValue RandomRange InRange

##### 一般统计量

###### 内容

- MinIntValue
- SumOfSquares
- StdDev
- Mean
- Sum
- MaxValue
- MinValue
- Norm
- SumsAndSquares
- MaxIntValue
- SumInt
- Harmean
- Variance
- MeanAndStdDev
- AveDev
- Skewness
- TotalVariance
- Product
- PopnStdDev
- kurtosis2
- Median
- skewness2
- 统计函数功能拓展
- Kurtosis
- Mode
- RandG
- Geomean
- PopnVariance
- MomentSkewKurtosis
- DevSq
- randomfrom

###### MinIntValue

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

```tsl
a := array(5.3, 3.9, 5.6, 5, 6.5, 7.6);
return MinIntValue(a);
// 结果：3
```

参考统计函数功能拓展 MinValue MaxValue MaxIntValue Min Max

###### SumOfSquares

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

```tsl
a := array(2, 3, 1, 5, 6.5, 7.5);
return SumOfSquares(a);
// 结果：124
```

参考统计函数功能拓展 Norm SumsAndSquares

###### StdDev

用途：一般统计量相关函数。
参数：

返回：处理后的结果值。

范例

范例01：一维数组求样本标准差

```tsl
a := array(5.3, 3.9, 5.6, 5, 7.5, 7.6);
return StdDev(a);
// 结果：1.46070759108956 //样本a的标准差
```

范例02：二维数组指定列+指定步长计算样本标准差

```tsl
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[:, "A-样本标准差"] := StdDev(arr, 0, ml, "A");
return arr;
```

参考统计函数功能拓展 SumOfSquares Norm PopnStdDev Variance PopnVariance

###### Mean

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

范例01：一维数组求平均值

```tsl
a := array(2, 3, 1, 5, 6, 7);
return Mean(a);
// 结果：4
```

范例02：二维数组指定列+指定步长计算平均

```tsl
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[:, "A-平均"] := Mean(arr, 0, ml, "A");
return arr;
```

参考统计函数功能拓展 Sum StdDev Geomean Harmean Mode Median

###### Sum

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

范例01：一维数组求和

```tsl
a := array(2, 3, 1, 5, 6, 7);
return Sum(a);
// 结果：24
```

范例02：二维数组指定列+指定步长求和

```tsl
arr := ones(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[:, "A-累加"] := Sum(arr, 0, ml, "A");
return arr;
```

参考统计函数功能拓展 Mean SumInt SumOfSquares Norm SumsAndSquares

###### MaxValue

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

范例01：一维数组求最大值

```tsl
a := array(5.3, 3.9, 5.6, 5, 6.5, 7.6);
return MaxValue(a);
// 结果：7.6
```

范例02：二维数组指定列+指定步长计算最大值

```tsl
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[:, "A-最大"] := MaxValue(arr, 0, ml, "A");
return arr;
```

参考统计函数功能拓展 MinValue MinIntValue MaxIntValue Min Max

###### MinValue

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

范例01：一维数组求最小值

```tsl
a := array(2, 3, 1, 5, 6, 7);
return MinValue(a);
// 结果：1
```

范例02：二维数组指定列+指定步长计算最小值

```tsl
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[:, "A-最小"] := MinValue(arr, 0, ml, "A");
return arr;
```

参考统计函数功能拓展 MinIntValue MaxValue MaxIntValue Min Max

###### Norm

用途：一般统计量相关函数。
参数：

返回：处理后的结果值。

范例

范例01：一维数组求平方和的平方根

```tsl
a := array(5, 3, 5, 5, 7, 7);
return Norm(a);
// 结果：13.490737563232
```

范例02：二维数组指定列+指定步长计算平方和的平方根

```tsl
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[:, "A-平方和的平方根"] := Norm(arr, 0, ml, "A");
return arr;
```

参考统计函数功能拓展 SumOfSquares

###### SumsAndSquares

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

```tsl
a := array(2, 3, 1, 5, 6, 7);
// b是总和,c是平方和
SumsAndSquares(a, b, c);
return array(b, c);
```

参考统计函数功能拓展 Sum SumOfSquares

###### MaxIntValue

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

```tsl
a := array(5.3, 3.9, 5.6, 5, 7.5, 7.6);
return MaxIntValue(a);
// 结果：7
```

参考统计函数功能拓展 MinValue MinIntValue MaxValue Min Max

###### SumInt

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

```tsl
a := array(2, 3, 1, 5, 6.5, 7.5);
return SumInt(a);
// 结果：24
```

参考统计函数功能拓展 Sum

###### Harmean

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

范例01：一维数组计算调和平均数

```tsl
Data := array(5, 3, 6, 8, 9, 10, 4);
return Harmean(Data);
// 结果：5.44
```

范例02：二维数组指定列+指定步长计算调和平均数

```tsl
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[:, "A-调和平均数"] := Harmean(arr, 0, ml, "A");
return arr;
```

参考统计函数功能拓展 Mean StdDev Geomean Mode Median

###### Variance

用途：一般统计量相关函数。
参数：

返回：处理后的结果值。

范例

范例01：一维数组求样本方差

```tsl
a := array(5.3, 3.9, 5.6, 5, 7.5, 7.6);
return Variance(a);
// 结果：2.13366666666666
```

范例02：二维数组指定列+指定步长计算样本方差

```tsl
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[:, "A-样本方差"] := Variance(arr, 0, ml, "A");
return arr;
```

参考统计函数功能拓展 StdDev PopnStdDev PopnVariance

###### MeanAndStdDev

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

```tsl
a := array(5.3, 3.9, 5.6, 5, 7.5, 7.6);
// b是返回的平均值,c是返回的标准差
MeanAndStdDev(a, b, c);
return array(b, c);
```

参考统计函数功能拓展 Mean StdDev

###### AveDev

用途：一般统计量相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
Data := array(5, 3, 6, 8, 9, 10, 4);
// 返回数组Data的平均绝对偏
return AveDev(Data);
// 结果：2.2
```

参考统计函数功能拓展 StdDev

###### Skewness

用途：一般统计量相关函数。
参数：

返回：处理后的结果值。

范例

范例01：一维数组求偏度

```tsl
Data := array(5, 3, 6, 8, 9, 10, 4);
return Skewness(Data);
// 结果：0.11
```

范例02：二维数组指定列+指定步长计算偏度

```tsl
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[:, "A-偏度"] := Skewness(arr, 0, ml, "A");
return arr;
```

参考统计函数功能拓展 skewness2 Kurtosis kurtosis2

###### TotalVariance

用途：一般统计量相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
a := array(5.3, 3.9, 5.6, 5, 7.5, 7.6);
return TotalVariance(a);
// 结果：10.6683333333333
```

参考统计函数功能拓展 Variance

###### Product

用途：一般统计量相关函数。
参数：

返回：处理后的结果值。

范例

一维数组计算累乘值

```tsl
Data := array(5, 3, 6, 8, 9, 10, 4);
return Product(Data);
// 结果：259200 //返回5*3*6*8*9*10*4
```

范例02：二维数组指定列+指定步长计算累乘值

```tsl
arr := rand(10, array("A", "B")) * 10;
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[:, "A-累乘"] := Product(arr, 0, ml, "A");
return arr;
```

参考统计函数功能拓展 Sum

###### PopnStdDev

用途：一般统计量相关函数。
参数：

返回：处理后的结果值。

范例

范例01：一维数组求总体标准差

```tsl
a := array(5.3, 3.9, 5.6, 5, 7.5, 7.6);
return PopnStdDev(a);
// 结果：1.33343749593131
```

范例02：二维数组指定列+指定步长计算总体标准差

```tsl
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[:, "A-总体标准差"] := PopnStdDev(arr, 0, ml, "A");
return arr;
```

参考统计函数功能拓展 StdDev Variance PopnVariance

###### kurtosis2

用途：一般统计量相关函数。
参数：

返回：处理后的结果值。

范例

范例01：：一维数组计算峰度

```tsl
Data := array(5, 3, 6, 8, 9, 10, 4);
return kurtosis2(Data);
// 结果：1.57
```

范例02：二维数组指定列+指定步长计算峰度

```tsl
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[:, "A-峰度"] := kurtosis2(arr, 0, ml, "A");
return arr;
```

参考统计函数功能拓展 Skew skewness2 Kurtosis

###### Median

用途：一般统计量相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
Data := array(5, 3, 6, 8, 9, 10, 4);
return Median(Data);
// 结果：6
```

参考统计函数功能拓展 Mean StdDev Geomean Harmean Mode

###### skewness2

用途：一般统计量相关函数。
参数：

返回：处理后的结果值。

范例

范例01：一维数组求偏度

```tsl
Data := array(5, 3, 6, 8, 9, 10, 4);
return skewness2(Data);
// 结果：0.09
```

范例02：二维数组指定列+指定步长计算偏度

```tsl
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[:, "A-偏度"] := skewness2(arr, 0, ml, "A");
return arr;
```

参考统计函数功能拓展 Skewness Kurtosis kurtosis2

###### 统计函数功能拓展

我们以前的统计函数，只支持对于一维数组的处理，现在一并支持了对二维数组的处理，对行列操作的选择，移动统计，选择部分字段做统计等功能。

比如func(In1,In2...InN[,Out1,...OutN])，这类函数，In参数除支持二维数组外，还增加了五个可选参数func(In1,In2...InN[,Out1,...OutN],Opt1[,Opt2[,
Opt3[, Opt4[, Opt5]]]]])

Opt1：对列操作为0（默认），对行操作为1，可缺省（以下参数都是默认缺省的参数）；

Opt2：是否移动进行计算，为0表示不移动（默认），其余正整数表示移动计算的长度；

Opt3：对字段筛选，nil表示全选（默认），可以使用数组进行多选，也可以使用简单类型进行单选

Opt4：异常处理参数，按照存储位来进行管理（默认为0）：

第一位管理的是是否忽略异常值(不包括nil)，即1不报错，0报错。

第二位管理的是nil值是否报错，即1报错，0不报错。

第三位管的是计算移动长度的时候，nil值及字符串等异常值是否包括在内。即0不忽略，1忽略。

这样的话，衍生出8种组合场景，分别对应如下：

注：下列说明中移动时异常值包括nil值在内，而其它处异常值中不包括nil值在内。

| 二进制 | 十进制值 | 功能说明                                          |
| ------ | -------- | ------------------------------------------------- |
| 0b000  | 0        | 默认值，异常值报错，nil不报错，移动时异常值不忽略 |
| 0b001  | 1        | 异常值不报错，nil值不报错，移动时异常值不忽略     |
| 0b010  | 2        | 异常值与nil值报错，移动时异常值不忽略             |
| 0b011  | 3        | 异常值不报错，nil值报错，移动时异常值不忽略       |
| 0b100  | 4        | 异常值报错，nil值不报错，计算移动单位时忽略异常值 |
| 0b101  | 5        | 异常值与nil值不报错，计算移动单位时忽略异常值     |
| 0b110  | 6        | 异常值报错，nil值报错，计算移动单位时忽略异常值   |
| 0b111  | 7        | 异常值不报错，nil值报错，计算移动单位时忽略异常值 |

Opt5：当In为空数组时的返回值，该参数默认缺省为0。

常用统计量：以mean函数为例：

正常数据的处理:

```tsl
a := array((1, 2, 3), (2, nil, 4), (4, 5, 6)); // 在一般的统计函数中，遇到nil是不会报错的
return mean(a); // 对每一列求均值
return mean(a, 1); // 对每一行求均值
return mean(a, 0, 2); // 求取长度为2的移动平均
return mean(a, 0, 2, array(0, 1)); // 只对0,1列做计算
return mean(a, 0, 2, array(0, 1), 4);
// 比较和上一个返回，这里求移动均值时跳过了nil
```

含字符串异常数据

```tsl
a := array((1, 2, 3), (2, nil, "a"), (4, 5, 6));
return mean(a, 0, 2, array(0, 1), 1);
// 忽略含字符串元素时候的报错
return mean(a, 0, 2, array(0, 1), 1 + 4);
// 比较和上一个返回，这里求移动均值时跳过了nil和字符串元素
```

空数组时候的默认输出：

```tsl
return mean(array(), 0, 0, nil, 1, "默认输出值"); // 输出第6个参数
```

一维数组的处理和n\*1二维数组类似，注意第二个参数一般为0，移动平均还是一维数组，一般平均结果是实数。

```tsl
a := rand(100);
return mean(a); // 结果为实数
return mean(a, 0, 10); // 长度为10的移动平均
```

次序统计量，以Large函数为例：

相比较统计函数的用法，次序统计函数主要要注意的是第二个不可缺省的参数的设置问题，比如：Large(Data:Array;N:[Int,Array]):[real,Array];

N是一个整数的时候

```tsl
a := 1 -  > 10;
a |= a;
return _large(a, 1); // 这样可以得到每列最大的元素
```

N是一个一维数组的时候

```tsl
a := rand(100, 10);
return _large(a, 1 -  > 10); // 对列做的时候，N的长度必须和列数目一致
return _large(a, ones(100), 1); // 对行做的时候，N的长度必须和行数目一致
```

###### Kurtosis

用途：一般统计量相关函数。
参数：

返回：处理后的结果值。

范例

范例01：一维数组计算峰度

```tsl
Data := array(5, 3, 6, 8, 9, 10, 4);
return Kurtosis(Data);
// 结果：-1.64
```

结果：-1.64

范例02：二维数组指定列+指定步长计算峰度

```tsl
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[:, "A-峰度"] := Kurtosis(arr, 0, ml, "A");
return arr;
```

参考统计函数功能拓展 Skewness skewness2 kurtosis2

###### Mode

用途：一般统计量相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
Data := array(5, 3, 6, 8, 9, 10, 4);
return Mode(Data);
// 结果：3
```

参考统计函数功能拓展 Mean StdDev Geomean Harmean Median

###### RandG

用途：一般统计量相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return RandG(2, 3);
// 结果：3.05   //3.05是均值为2,标准差为3的高斯分布的一个样本数据
```

参考简单函数对数组支持

###### Geomean

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

范例01：一维数组计算几何平均数

```tsl
Data := array(5, 3, 6, 8, 9, 10, 4);
return Geomean(Data);
// 结果：5.93
```

范例02：二维数组指定列+指定步长计算几何平均数

```tsl
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[:, "A-几何平均数"] := Geomean(arr, 0, ml, "A");
return arr;
```

参考统计函数功能拓展 Mean StdDev Harmean Mode Median

###### PopnVariance

用途：一般统计量相关函数。
参数：

返回：处理后的结果值。

范例

范例01：一维数组求总体方差

```tsl
a := array(5.3, 3.9, 5.6, 5, 7.5, 7.6);
return PopnVariance(a);
// 结果：1.77805555555555
```

范例02：二维数组指定列+指定步长计算总体方差

```tsl
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[:, "A-总体方差"] := PopnVariance(arr, 0, ml, "A");
return arr;
```

参考统计函数功能拓展 StdDev PopnStdDev Variance

###### MomentSkewKurtosis

用途：一般统计量相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
Data := array(5, 3, 6, 8, 9, 10, 4);
MomentSkewKurtosis(Data, M1, M2, M3, M4, Skew, Kurtosis);
return array(M1, M2, M3, M4, Skew, Kurtosis);
```

结果;

参考统计函数功能拓展

###### DevSq

用途：一般统计量相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
Data := array(5, 3, 6, 8, 9, 10, 4);
return DevSq(Data);
// 结果：41.71
```

参考统计函数功能拓展 StdDev

###### randomfrom

用途：一般统计量相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
Data := array(5, 3, 6, 8, 9, 10, 4);
return randomfrom(Data);
// 结果：9
```

参考统计函数功能拓展

##### 次序统计量

###### 内容

- Large
- Small
- Percentile
- Percentrank
- Quartile
- Rank
- Trimmean
- Frequency

###### Large

用途：次序统计量相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
Data := array(5, 3, 6, 8, 9, 10, 4);
// 返回数组Data中第3大的数据
return Large(Data, 3);
// 结果：8
```

参考统计函数功能拓展 Small Percentile

###### Small

用途：次序统计量相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 返回数组Data中第3小的数据
Data := array(5, 3, 6, 8, 9, 10, 4);
return Small(Data, 3);
// 结果：5
```

参考统计函数功能拓展 Large Percentile

###### Percentile

用途：次序统计量相关函数。
参数：

返回：处理后的结果值。

算法

对序列从小到大排序，数据长度为n，则

（1）

求(n-1)\* PCT，记整数部分为i，小数部分为j

（2）

所求结果＝（1－j）*序列第(i＋1)个数＋j*序列第(i+2)个数

范例

范例1：序列百分点的值

```tsl
// 返回数组Data的第3个百分点
Data := array(5, 3, 6, 8, 9, 10, 4);
return Percentile(Data, 0.3);
// 结果：4.8
```

范例2：二维数组各列百分点的值

```tsl
a := array('A':('g':1, 'f':2, 'k':3),
'B':('g':10, 'f':20, 'k':30),
'C':('g':100, 'f':200, 'k':300),
'D':('g':1000, 'f':2000, 'k':3000),
);
return Percentile(a, 0.5, 0);
```

范例3：二维数组指定列指定步长的百分点的值

```tsl
a := array('A':('g':1, 'f':2, 'k':3),
'B':('g':10, 'f':20, 'k':30),
'C':('g':100, 'f':200, 'k':300),
'D':('g':1000, 'f':2000, 'k':3000),
);
return Percentile(a, 0.5, 0, 2, array('f', 'k'));
```

参考统计函数功能拓展 Large Small

###### Percentrank

用途：次序统计量相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 返回8在数组Data的百分点，即小于8的个数/（小于8个数+大于8个
// 数）结果是4/6
Data := array(5, 3, 6, 8, 9, 10, 4);
return Percentrank(Data, 8);
// 结果：0.666666666666667
```

参考统计函数功能拓展 Large Small Percentile

###### Quartile

用途：次序统计量相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 返回数组Data中第3个四分位数,即75%。然后按照Percentile的算法求值
// (7-1)*75%=4.5，i=4，j=5，最终结果是(1-0.5)*8+0.5*9=8.5
Data := array(5, 3, 6, 8, 9, 10, 4);
return Quartile(Data, 3);
// 结果：8.5
```

参考统计函数功能拓展 Large Small Percentile Percentrank

###### Rank

用途：次序统计量相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
Data := array(5, 3, 6, 8, 9, 10, 4);
return Rank(Data, 8);
// 结果：3
```

参考统计函数功能拓展 Percentile Percentrank

###### Trimmean

用途：对字符串进行裁剪处理。
参数：

返回：处理后的结果值。

范例

```tsl
// 去除个数=总个数7*0.7=4.9，头和尾各去除2个数据，剩下数据5，6，8求//均值
Data := array(5, 3, 6, 8, 9, 10, 4);
return Trimmean(Data, 0.7);
// 结果：6.33333333333333
```

参考统计函数功能拓展

###### Frequency

用途：次序统计量相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
Data := array(5, 3, 6, 8, 9, 10, 4);
FreqData := array(1, 2, 3);
return Frequency(Data, FreqData);
```

参考统计函数功能拓展

##### 统计函数

###### 内容

- Cov
- Correl
- Slope
- Intercept
- Rsq
- Steyx
- Slopeandintercept
- VariationCoefficient
- Skew
- SelfStddev
- RegressionChannel
- Kurt
- MeanAndPopnStdDevWithRate
- BetaAndAlpha
- 扩充统计
- 含NAN统计
- correlpaired
- correlpaired_side

###### Cov

用途：统计函数相关函数。
参数：

返回：处理后的结果值。

算法

备注：数据长度必须保持一致且大于等于2范例

万科A在2018/10/1~2018/10/30日线收盘与大盘的协方差

```tsl
begt := 20181001T;
Endt := 20181030T;
Setsysparam(Pn_Stock(), "SZ000002");
dateArr := markettradedayQK(begt, Endt);
data := select thisrow as"日期",
Spec(Specdate(close(), thisrow), "SZ000002") as"价格",
SPec(Specdate(Close(), thisrow), "SH000001") as"大盘"
from dateArr
end;
return Cov(data[:, "价格"], data[:, "大盘"]);
```

###### Correl

用途：统计函数相关函数。
参数：

返回：处理后的结果值。

算法ra,b=cov(a,b)σaσb，其中cov(a,b)为a,b序列协方差，σ为总体标准差。

备注：数据长度必须保持一致且大于等于2范例

万科A在2018/10/1~2018/10/30日线收盘与大盘价格的相关系数

```tsl
begt := 20181001T;
Endt := 20181030T;
Setsysparam(Pn_Stock(), "SZ000002");
dateArr := markettradedayQK(begt, Endt);
data := select thisrow as"日期",
Spec(Specdate(close(), thisrow), "SZ000002") as"价格",
SPec(Specdate(Close(), thisrow), "SH000001") as"大盘"
from dateArr
end;
return Correl(data[:, "价格"], data[:, "大盘"]);
```

###### Slope

用途：统计函数相关函数。
参数：

返回：处理后的结果值。

算法 or

备注：数据长度必须保持一致且大于等于2范例

万科A在2018/10/1~2018/10/30日线收盘与大盘收盘价格的回归斜率

```tsl
begt := 20181001T;
Endt := 20181030T;
Setsysparam(Pn_Stock(), "SZ000002");
dateArr := markettradedayQK(begt, Endt);
data := select thisrow as"日期",
Spec(Specdate(close(), thisrow), "SZ000002") as"价格",
SPec(Specdate(Close(), thisrow), "SH000001") as"大盘"
from dateArr
end;
return Slope(data[:, "价格"], data[:, "大盘"]);
```

###### Intercept

用途：统计函数相关函数。
参数：

返回：处理后的结果值。

算法

备注：数据长度必须保持一致且大于等于2范例

万科A在2018/10/1~2018/10/30日线收盘与大盘收盘价的相回归截距

```tsl
begt := 20181001T;
Endt := 20181030T;
Setsysparam(Pn_Stock(), "SZ000002");
dateArr := markettradedayQK(begt, Endt);
data := select thisrow as"日期",
Spec(Specdate(close(), thisrow), "SZ000002") as"价格",
SPec(Specdate(Close(), thisrow), "SH000001") as"大盘"
from dateArr
end;
return Intercept(data[:, "价格"], data[:, "大盘"]);
```

###### Rsq

用途：统计函数相关函数。
参数：

返回：处理后的结果值。

算法

备注：参数数据长度必须保持一致且大于等于2范例

万科A在2018/10/1~2018/10/30日线收盘与大盘的乘积矩相关系数平方

```tsl
begt := 20181001T;
Endt := 20181030T;
Setsysparam(Pn_Stock(), "SZ000002");
dateArr := markettradedayQK(begt, Endt);
data := select thisrow as"日期",
Spec(Specdate(close(), thisrow), "SZ000002") as"价格",
SPec(Specdate(Close(), thisrow), "SH000001") as"大盘"
from dateArr
end;
return Rsq(data[:, "价格"], data[:, "大盘"]);
```

###### Steyx

用途：统计函数相关函数。
参数：

返回：处理后的结果值。

算法

备注：数据长度必须保持长度一致且大于2。范例

万科A在2018/10/1~2018/10/30日线收盘与大盘的相对标准偏差

```tsl
begt := 20181001T;
Endt := 20181030T;
Setsysparam(Pn_Stock(), "SZ000002");
dateArr := markettradedayQK(begt, Endt);
data := select thisrow as"日期",
Spec(Specdate(close(), thisrow), "SZ000002") as"价格",
SPec(Specdate(Close(), thisrow), "SH000001") as"大盘"
from dateArr
end;
return Steyx(data[:, "价格"], data[:, "大盘"]);
```

###### Slopeandintercept

用途：统计函数相关函数。
参数：

返回：处理后的结果值。

算法

备注：参数数据长度必须保持一致且大于等于2范例

万科A在2018/10/1~2018/10/30日线收盘与大盘收盘价格的回归斜率和截距

```tsl
begt := 20181001T;
Endt := 20181030T;
Setsysparam(Pn_Stock(), "SZ000002");
dateArr := markettradedayQK(begt, Endt);
data := select thisrow as"日期",
Spec(Specdate(close(), thisrow), "SZ000002") as"价格",
SPec(Specdate(Close(), thisrow), "SH000001") as"大盘"
from dateArr
end;
return Slopeandintercept(data[:, "价格"], data[:, "大盘"]);
```

###### VariationCoefficient

用途：统计函数相关函数。
参数：

返回：处理后的结果值。

算法C.V.=σ/μ，其中σ为标准差，μ为均值。范例

```tsl
return VariationCoefficient(array(1, 2, 1, 2, 1, 2));
// 返回：0.33
```

###### Skew

用途：统计函数相关函数。
参数：

返回：处理后的结果值。

算法sc=1n(ti-μσ)3\*nn-1(n-2)，其中n为序列长度，其中σ为标准差，μ为均值。范例

```tsl
Skew(array(1, 2, 3, 4, 5, 7), s);
return s;
// 返回：0.46
```

###### SelfStddev

用途：统计函数相关函数。
参数：

返回：处理后的结果值。

算法

t2=t-Rmar,并将t2中大于0的元素化为0。

对t2求标准差范例

```tsl
return SelfStddev(array(1, 2, 3, 4, 5), 3);
// 返回：0.89
```

###### RegressionChannel

用途：统计函数相关函数。
参数：

返回：处理后的结果值。

算法返回BETA系数以及ALPHA值，并得到上行轨道以及下行轨道的ALPHA。依此得到指定X的上轨以及下轨，并根据当前的Y得到其所在轨道中的百分比，如果<0则低于下轨，>100则超越上轨。依照Alpha和Beta值，得到nowx的预期回归运行值。范例

```tsl
RegressionChannel(array(1, 2, 3, 4, 5), array(6, 7, 8, 9, 10), 1, 2, 3, 4, 5, 6, 7, 8, s, a);
return a;
// 返回：-3
```

###### Kurt

用途：统计函数相关函数。
参数：

返回：处理后的结果值。

算法

其中n为序列长度，其中Stdev为标准差。范例

```tsl
Kurt(array(1, 2, 3, 4, 5), s);
return s;
// 返回：-1.2
```

###### MeanAndPopnStdDevWithRate

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

算法

μ=1nRi\*Di1nRi

σ=1nRi*inRi*Di2-(1nRi\*Di)21nRi

其中μ为均值，σ为标准差范例

```tsl
MeanAndPopnStdDevWithRate(array(1, 2, 3), array(1, 1, 1), m, s);
return m;
// 返回：2
```

###### BetaAndAlpha

用途：统计函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
BetaAndAlpha(array(3, 6), array(4, 12), k, b);
return k;
// 返回：0.375
```

###### 扩充统计

####### 内容

- Expanding_Unit

####### Expanding_Unit

功能描述：

扩充统计单元库，扩充统计方法，提高运算效率，譬如cumsum

输 入：

r 必须为数字数组，当为空数组时，返回空数组

支持一维数组或二维数组（此时按列统计）,也可以为二维数据表

######## 内容

- ExpdMax
- ExpdMin
- ExpdSum
- ExpdProduct
- ExpdVar
- ExpdStd

######## ExpdMax

范例

```tsl
r := array(-1, 2, -3, 9);
return ExpdMax(r); // array(-1,2,2,9)
```

######## ExpdMin

范例

```tsl
r := array(-1, 2, -3, 9);
return ExpdMin (r); // array(-1,-1,-3,-3)
```

######## ExpdSum

范例

```tsl
r := array(-1, 2, -3, 9);
return ExpdSum (r); // array(-1,1,-2,7)
```

######## ExpdProduct

范例

```tsl
r := array(-1, 2, -3, 9);
return ExpdProduct (r); // array(-1,-2,6,54)
```

######## ExpdVar

范例

```tsl
r := array(-1, 2, -3, 9);
return ExpdVar (r, 0); // array(0,2.25,4.22,20.69)
```

######## ExpdStd

范例

```tsl
r := array(-1, 2, -3, 9);
return ExpdStd (r, 0); // array(0,1.5,2.05,4.55)
```

###### 含NAN统计

####### 内容

- NanMean
- NanSum
- NanStd
- NanVariance
- NanPopnStd
- NanPopnVariance
- NanRankArr
- NanPercentRankArr

####### NanMean

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

```tsl
A := array(5, 6, 8, Nan);
return NanMean(A);
// 结果：6.33
```

####### NanSum

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

```tsl
A := array(5, 6, 8, Nan);
return NanSum(A);
// 结果：19
```

####### NanStd

用途：统计函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
A := array(5, 6, 8, Nan);
return NanStd(A);
// 结果：1.53
```

####### NanVariance

用途：统计函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
A := array(5, 6, 8, Nan);
return NanVariance(A);
// 结果：2.33
```

####### NanPopnStd

用途：统计函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
A := array(5, 6, 8, Nan);
return NanPopnStd(A);
// 结果：1.25
```

####### NanPopnVariance

范例

```tsl
A := array(5, 6, 8, Nan);
return PopnVariance(A);
// 结果：1.56
```

####### NanRankArr

用途：统计函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
a := array(1, 1, 2, 2, 2, 9, Nan, 9, 9);
return NanRankArr(a);
// 结果：array(1,1,3,3,3,6,NAN,6,6)
```

####### NanPercentRankArr

用途：统计函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
a := array(1, 1, 2, 2, 2, 9, Nan, 9, 9);
return NanPercentRankArr(a);
// 结果：array(0.0,0.0,0.29,0.29,0.29,0.71,NAN,0.71,0.71)
```

###### correlpaired

用途：统计函数相关函数。
参数：

返回：处理后的结果值。

范例

范例01

```tsl
a := rand(10);
b := rand(10);
return correlpaired(a, b); // array((0.17))
```

范例02

```tsl
a := rand(10);
b := rand(10, 2);
return correlpaired(a, b); // array((-0.35,-0.19))
```

范例03

```tsl
a := rand(10, 2);
b := rand(10, 4);
return correlpaired(a, b);
```

返回:

范例04

```tsl
a := `array("A":rand(10));
b := `array("A":rand(10), "B":rand(10));
return correlpaired(a, b); // array((0.2,-0.08))
```

###### correlpaired_side

用途：统计函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
a := randnorm(0, 1, 20, array(0, 1, 2, 3, 4));
dirType := 3;
return correlpaired_side(a, filtType);
```

##### 统计分布

###### 内容

- Gammaln
- Hist
- sf_Error
- erfc
- sf_Gamma
- erf
- erfcinv
- sf_Beta
- sf_IntegerBessel_1
- sf_IncompleteGamma
- Gamma
- erfinv
- 分布函数
- Randnorm
- sf_F
- sf_geopdf
- sf_RealBessel_1
- sf_unidcdf
- sf_normpdf
- sf_geoinv
- sf_unidpdf
- sf_IncompleteBeta
- sf_normalinv2
- sf_norminv
- Randunid
- sf_Normal
- sf_unidinv
- sf_X2
- sf_IntegerBessel_2
- sf_normcdf
- sf_t
- sf_geocdf
- Randgeo
- sf_normalinv
- Normfit
- sf_RealBessel_2
- sf_hygeinv
- poissfit
- sf_binocdf
- Randhyge
- sf_poissinv
- sf_poisscdf
- sf_nbininv
- binofit
- sf_hygepdf
- sf_unifcdf
- sf_exppdf
- sf_binoinv
- uniffit
- sf_nbinpdf
- Randnbin
- Randpoiss
- sf_hygecdf
- sf_poisspdf
- Randbino
- Randunif
- sf_unifinv
- sf_binopdf
- sf_nbincdf
- sf_unifpdf
- sf_tcdf
- sf_fpdf
- sf_tinv
- expfit
- Randgam
- sf_ch2inv
- sf_ch2cdf
- sf_finv1
- Randt
- sf_expcdf
- sf_finv
- sf_gamcdf
- sf_tpdf
- sf_x2inv
- sf_gampdf
- sf_gammainv
- sf_fcdf
- sf_ch2pdf
- Randf
- Randexp
- Randch2
- sf_gaminv
- sf_expinv
- sf_betapdf
- sf_tinv1
- RandCauchy
- sf_Laplacecdf
- Randbeta
- sf_Cauchypdf
- sf_logninv
- sf_Laplaceinv
- sf_betacdf
- sf_raylinv
- sf_wblcdf
- sf_lognpdf
- sf_Cauchycdf
- Randlogn
- Randrayl
- sf_Laplacepdf
- sf_raylpdf
- sf_wblinv
- sf_logncdf
- sf_Cauchyinv
- sf_raylcdf
- Randwbl
- sf_betainv
- RandLaplace
- sf_wblpdf
- sf_betainv1
- sf_mvtcdf
- Mvtcdfqmc
- sf_mvncdf
- sf_copulacdf
- sf_copulafit
- RandCopula
- sf_exp
- Norminv

###### Gammaln

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Gammaln(array(1.5, 2.3, 3.4));
// 结果：array(-0.120782237635245,0.15418945495963,1.09232805980274)
```

###### Hist

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
A := randnorm(0, 1, 10000);
return Hist(A, 30, center);
```

结果，一维数字数组

###### sf_Error

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
sf_Error(0.15, v);
return v;
// 结果：0.168
```

###### erfc

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return erfc(0.15);
// 0.832004028572637
```

###### sf_Gamma

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
sf_Gamma(5, v);
return v;
// 结果：24
```

参考sf_IncompleteGamma

###### erf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return erf(0.15);
// 结果：0.168
```

###### erfcinv

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return erfcinv(0.15);
// 结果：1.01790246483203
```

###### sf_Beta

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
sf_Beta(2, 5, v);
return v;
// 结果：0.03333
```

参考sf_Gamma

###### sf_IntegerBessel_1

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
n := 7;
x := 4.5;
sf_IntegerBessel_1(n, x, v);
return v;
// 结果：0.03002
```

参考sf_IntegerBessel_2 sf_RealBessel_1 sf_RealBessel_2

###### sf_IncompleteGamma

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
a := 5;
x := 7;
sf_IncompleteGamma(a, x, v);
return v;
// 结果：0.82701
```

参考sf_Gamma

###### Gamma

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Gamma(array(1.5, 2.3, 3.4));
// 结果：array(0.886226925452758,1.16671190519816,2.98120642681033)
```

###### erfinv

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return erfinv(0.15);
// 结果：0.13372692166482
```

###### 分布函数

TinySoft金融分析平台上提供了有关统计分布的函数：概率密度,(累计)分布函数,分位数函数(分布逆函数),随机数函数,估计函数

概率密度,(累计)分布函数,分位数的函数命名使用规则：

概率分布函数（包括概率密度函数，分布函数，分布逆函数）输入的第一个变量参数是随机变量或分布函数值，都支持数组形式，中间的参数，一般为分布参数，参数个数不定，只支持符合要求的实数和整数类型.最后一个参数存在的主要原因是为了支持tinysoft金融分析平台以前的使用方法，该参数可缺省，而使用return输出结果，输出结果和第一个参数的维度是一样的.

随机数函数命名使用规则：

生成随机数的函数名称一般使用rand+分布类型（分布参数+行数目+列数目）,如：

return randrayl(5,array('a','b','c'));

return randrayl(5,array('a','b','c','d','e','f'),4);

return randrayl(5,4,array('a'));

或使用rand函数：

A:=rand(100,100,array("normal")); //标准正态分布

a := rand(100,100,array("normal",0,1));//标准正态分布

支持如下类型(大小写无关)：正态分布"normal",泊松分布"posisson",伽马分布"Gamma",均匀分布"Uniform"，二项分布"Binomial",几何分布"Geometric",指数分布"Exp",beta分布"Beta",对数正态分布"Lognormal",威布尔分布"Weibull",柯西"Cauchy",拉普拉斯"Laplace",超几何"Hypergeometric",离散均匀"IntUniform",瑞利分布"Rayleigh"

估计函数命名使用规则：

估计函数的函数名称一般使用分布类型+fit(数据+显著性水平)如

return normfit(rand(1000,5),0.05);

结果以列为样本进行估计，muhat，muci为正态分布位置参数的点估计，区间估计，sigmahat，sigmaci为正态分布形态参数的点估计，区间估计.其中每一个样本区间的区间估计中含有两个值，upper是上限，lower是下限.

函数列表：

|              | 概率密度       | 分布函数       | 分布逆函数     | 随机数      | 估计函数 |
| ------------ | -------------- | -------------- | -------------- | ----------- | -------- |
| 离散均匀分布 | sf_unidpdf     | sf_unidcdf     | sf_unidinv     | randunid    |          |
| 几何分布     | sf_geopdf      | sf_geocdf      | sf_geoinv      | Randgeo     |          |
| 超几何分布   | sf_hygepdf     | sf_hygecdf     | sf_hygeinv     | Randhyge    |          |
| 二项分布     | sf_binopdf     | sf_binocdf     | sf_binoinv     | Randbino    | binofit  |
| 负二项分布   | sf_nbinpdf     | sf_nbincdf     | sf_nbininv     | Randnbin    |          |
| 均匀分布     | sf_unifpdf     | sf_unifcdf     | sf_unifinv     | Randunif    | uniffit  |
| 泊松分布     | sf_poissonpdf  | sf_poissoncdf  | sf_poissoninv  | Randpoisson | poissfit |
| 指数分布     | sf_exppdf      | sf_expcdf      | sf_expinv      | Randexp     | expfit   |
| 正态分布     | sf_normpdf     | sf_normcdf     | sf_norminv     | Randnorm    |          |
| 卡方分布     | sf_ch2pdf      | sf_ch2cdf      | sf_ch2inv      | Randch2     |          |
| 学生T分布    | sf_tpdf        | sf_tcdf        | sf_tinv1       | Randt       |          |
| F分布        | sf_fpdf        | sf_fcdf        | sf_finv1       | Randf       |          |
| gam分布      | sf_gampdf      | sf_gamcdf      | sf_gaminv      | Randgam     |          |
| beta分布     | sf_betapdf     | sf_betacdf     | sf_betainv1    | Randbeta    |          |
| 瑞利分布     | sf_raylpdf     | sf_raylcdf     | sf_raylinv1    | Randrayl    |          |
| 威布尔分布   | sf_wblpdf      | sf_wblcdf      | sf_wblinv      | Randwbl     |          |
| 对数正态分布 | sf_lognpdf     | sf_logncdf     | sf_logninv     | Randlohn    |          |
| 拉普拉斯分布 | sf_Laplacepdf  | sf_Laplacecdf  | sf_Laplaceinv  | RandLaplace |          |
| 柯西分布     | sf\_ Cauchypdf | sf\_ Cauchycdf | sf\_ Cauchyinv | RandCauchy  |          |

###### Randnorm

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Randnorm(0, 1, 10, array("a", "b"));
```

参考分布函数 sf_normpdf sf_normcdf sf_norminv Normfit

###### sf_F

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
f := 2;
n1 := 3;
n2 := 5;
sf_F(f, n1, n2, v);
return v;
// 结果：0.76738
```

参考sf_Normal sf_t sf_X2

###### sf_geopdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := 1 -  > 10;
return sf_geopdf(x, 0.5);
```

参考sf_geocdf sf_geoinv Randgeo 分布函数

###### sf_RealBessel_1

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
n := 7;
x := 4.5;
sf_RealBessel_1(n, x, v);
return v;
// 结果：0.10684
```

参考sf_IntegerBessel_1 sf_IntegerBessel_2 sf_RealBessel_2

###### sf_unidcdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(-4, 0.1) -  > 4;
return sf_unidcdf(x, 0, 1);
```

参考sf_unidpdf sf_unidcdf sf_unidinv Randunid 分布函数

###### sf_normpdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(-2, 0.1) -  > 2;
return sf_normpdf(x, 0, 1);
```

参考分布函数 sf_normcdf sf_norminv Randnorm Normfit

###### sf_geoinv

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
y := array(0.01, 0.01) -  > 0.99;
return sf_geoinv(y, 0.5);
```

参考sf_geopdf sf_geocdf Randgeo 分布函数

###### sf_unidpdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := 1 -  > 10;
return sf_unidpdf(x, 10);
```

参考sf_unidpdf sf_unidcdf sf_unidinv Randunid 分布函数

###### sf_IncompleteBeta

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
a := 3;
b := 4;
x := 0.25;
sf_IncompleteBeta(a, b, x, v);
return v;
// 结果：0.16943
```

参考sf_Beta

###### sf_normalinv2

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
sf_normalinv2(0.5 , v);
return v; // 返回结果0.
```

###### sf_norminv

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

```tsl
y := array(0.01, 0.01) -  > 0.99;
return sf_norminv(y, 0, 1);
```

参考分布函数 sf_normpdf sf_normcdf Randnorm Normfit

###### Randunid

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Randunid(10, 10, array("a", "b"));
```

参考sf_unidpdf sf_unidcdf sf_unidinv 分布函数

###### sf_Normal

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := 0;
a := 0;
d := 1;
sf_Normal(x, a, d, v);
return v;
// 结果：0.5
```

参考sf_t sf_X2 sf_F

###### sf_unidinv

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
y := array(0.01, 0.01) -  > 0.99;
return sf_unidinv(y, 10);
```

参考sf_unidpdf sf_unidcdf sf_unidinv Randunid 分布函数

###### sf_X2

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := 2.5;
n := 10;
sf_X2(x, n, v);
return v;
// 结果：0.00912
```

参考sf_Normal sf_t sf_F

###### sf_IntegerBessel_2

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
n := 7;
x := 4.5;
sf_IntegerBessel_2(n, x, v);
return v;
// 结果：
-2.02943
```

参考sf_IntegerBessel_1 sf_RealBessel_1 sf_RealBessel_2

###### sf_normcdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

算法

标准正态分布的概率密度函数为：

pt=12πe-t22 t∈(-∞,+∞)

则随机变量x对应分布函数(x)：

(x)=12π-∞xe-t22dt

定义函数erfx=2π0xe-t2dt(x>0)为误差函数；

函数erfcx=1-erfx=2πx+∞e-t2dt为余误差函数。

则分布函数x与余误差函数有以下关系：

x=0.5\*erfc(-x2)

设随机变量服从均值为mu，标准差为sigma的正态分布Nmu,sigma，经过标准化

z=x-musigma

后服从标准正态分布N0,1。

变量z对应的分布函数值为：

z=0.5\*erfc(-z2)范例

```tsl
x := array(-4, 0.1) -  > 4;
return sf_normcdf(x, 0, 1);
```

参考分布函数 sf_normpdf sf_norminv Randnorm Normfit

###### sf_t

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
t := 2.5;
n := 10;
sf_t(t, n, v);
return v;
// 结果：0.98428
```

参考sf_Normal sf_X2 sf_F

###### sf_geocdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := 1 -  > 10;
return sf_geocdf(x, 0.5);
```

参考sf_geopdf sf_geoinv Randgeo 分布函数

###### Randgeo

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Randgeo(10, 10, array("a", "b"));
```

参考sf_geopdf sf_geocdf sf_geoinv 分布函数

###### sf_normalinv

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
sf_normalinv(0.5, 0, 1, v);
return v; // 返回结果0.
```

###### Normfit

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := randnorm(0, 1, 10, array("a", "b"));
return Normfit(x, 0.05);
```

结果：返回mu,sigma的估计以及他们的在alpha的显著性水平下的区间估计

###### sf_RealBessel_2

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
n := 7;
x := 4.5;
sf_RealBessel_2(n, x, v);
return v;
// 结果：0.56161
```

参考sf_IntegerBessel_1 sf_IntegerBessel_2 sf_RealBessel_1

###### sf_hygeinv

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
y := array(0.01, 0.01) -  > 0.99;
return sf_hygeinv(y, 100, 10, 20);
```

参考sf_hygepdf sf_hygecdf Randhyge 分布函数

###### poissfit

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := randpoiss(1, 100);
return poissfit(x, 0.05);
```

结果：返回lambda的估计以及他们的在alpha的显著性水平下的区间估计

参考sf_poisspdf sf_poisscdf sf_poissinv Randpoiss 分布函数

###### sf_binocdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := 1 -  > 10;
return sf_binocdf(x, 10, 0.5);
```

参考sf_binopdf sf_binoinv Randbino binofit 分布函数

###### Randhyge

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Randhyge(100, 10, 20, 10, array("a", "b"));
```

参考sf_hygepdf sf_hygecdf sf_hygeinv 分布函数

###### sf_poissinv

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
y := array(0.01, 0.01) -  > 0.99;
return sf_poissinv(y, 10);
```

参考sf_poisspdf sf_poisscdf Randpoiss poissfit 分布函数

###### sf_poisscdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := 1 -  > 20;
return sf_poisscdf(x, 10);
```

参考sf_poisspdf sf_poissinv Randpoiss poissfit 分布函数

###### sf_nbininv

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
y := array(0.01, 0.01) -  > 0.99;
return sf_nbininv(y, 10, 0.5);
```

参考sf_nbinpdf sf_nbincdf Randnbin 分布函数

###### binofit

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := randbino(10, 0.5, 1);
return binofit(x, 10, 0.05);
```

结果：返回p的估计以及在alpha的显著性水平下的区间估计

参考sf_binopdf sf_binocdf sf_binoinv Randbino 分布函数

###### sf_hygepdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := 1 -  > 20;
return sf_hygepdf(x, 100, 10, 20);
```

参考sf_hygecdf sf_hygeinv Randhyge 分布函数

###### sf_unifcdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := 1 -  > 10;
return sf_unifcdf(x, 1, 10);
```

参考sf_unifpdf Randunif uniffit 分布函数

###### sf_exppdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(0, 0.1) -  > 4.5;
return sf_exppdf(x, 1);
```

参考sf_expcdf sf_expinv Randexp expfit 分布函数

###### sf_binoinv

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
y := array(0.01, 0.01) -  > 0.99;
return sf_binoinv(y, 10, 0.5);
```

参考sf_binopdf sf_binocdf Randbino binofit 分布函数

###### uniffit

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := randunif(1, 10, 100);
return uniffit(x, 0.05);
```

结果：返回a,b的估计以及他们的在alpha的显著性水平下的区间估计

参考sf_unifpdf sf_unifcdf sf_unifinv Randunif 分布函数

###### sf_nbinpdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := 1 -  > 20;
return sf_nbinpdf(x, 10, 0.5);
```

参考sf_nbincdf sf_nbininv Randnbin 分布函数

###### Randnbin

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Randnbin(10, 0.5, 10, array("a", "b"));
```

参考sf_nbinpdf sf_nbincdf sf_nbininv 分布函数

###### Randpoiss

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Randpoiss(10, 10, array("a", "b"));
```

参考sf_poisspdf sf_poisscdf sf_poissinv poissfit 分布函数

###### sf_hygecdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := 1 -  > 10;
return sf_hygecdf(x, 100, 10, 20);
```

参考sf_hygepdf sf_hygeinv Randhyge 分布函数

###### sf_poisspdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := 1 -  > 20;
return sf_poisspdf(x, 10);
```

参考sf_poisscdf sf_poissinv Randpoiss poissfit 分布函数

###### Randbino

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Randbino(10, 0.5, 10, array("a", "b"));
```

参考sf_binopdf sf_binocdf sf_binoinv binofit 分布函数

###### Randunif

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Randunif(1, 10, 10, array("a", "b"));
```

参考sf_unifpdf sf_unifcdf sf_unifinv uniffit 分布函数

###### sf_unifinv

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
y := array(0.01, 0.01) -  > 0.99;
return sf_unifinv(y, 1, 10);
```

参考sf_unifpdf sf_unifcdf Randunif uniffit 分布函数

###### sf_binopdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := 1 -  > 20;
return sf_binopdf(x, 10, 0.5);
```

参考sf_binocdf sf_binoinv Randbino binofit 分布函数

###### sf_nbincdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := 1 -  > 10;
return sf_nbincdf(x, 10, 0.5);
```

参考sf_nbinpdf sf_nbininv Randnbin 分布函数

###### sf_unifpdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := 1 -  > 10;
return sf_unifpdf(x, 1, 10);
```

参考sf_unifcdf Randunif uniffit 分布函数

###### sf_tcdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(-2.5, 0.1) -  > 2.5;
return sf_tcdf(x, 30);
```

参考sf_tpdf sf_tinv1 Randt 分布函数

###### sf_fpdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(0, 0.1) -  > 3;
return sf_fpdf(x, 20, 30);
```

参考sf_fcdf sf_finv1 Randf 分布函数

###### sf_tinv

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
sf_tinv(0.6, 30, v);
return v; // 返回结果0.255605364951908
```

###### expfit

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := randexp(1, 100);
return expfit(x, 0.05);
```

结果：返回parm的估计已经他们的在alpha的显著性水平下的区间估计

参考sf_exppdf sf_expcdf sf_expinv Randexp 分布函数

###### Randgam

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Randgam(2, 2, 100, array("a", "b"));
```

参考sf_gampdf sf_gamcdf sf_gaminv 分布函数

###### sf_ch2inv

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
y := array(0.01, 0.01) -  > 0.99;
return sf_ch2inv(y, 30);
```

参考sf_ch2pdf sf_ch2cdf Randch2 分布函数

###### sf_ch2cdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := 0 -  > 50;
return sf_ch2cdf(x, 30);
```

参考sf_ch2pdf sf_ch2inv Randch2 分布函数

###### sf_finv1

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
y := array(0.01, 0.01) -  > 0.99;
return sf_finv1(y, 20, 30);
```

参考sf_fpdf sf_fcdf Randf 分布函数

###### Randt

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Randt(30, 10, array("a", "b"));
```

参考sf_tpdf sf_tcdf sf_tinv1 分布函数

###### sf_expcdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(0, 0.1) -  > 4.5;
return sf_expcdf(x, 1);
```

参考sf_exppdf sf_expinv Randexp expfit 分布函数

###### sf_finv

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
sf_finv(0.6, 20, 30, v);
return v; // 返回结果1.09737928787751
```

###### sf_gamcdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(0, 0.1) -  > 13;
return sf_gamcdf(x, 2, 2);
```

参考sf_gampdf sf_gaminv Randgam 分布函数

###### sf_tpdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(-2.5, 0.1) -  > 2.5;
return sf_tpdf(x, 30);
```

参考sf_tcdf sf_tinv1 Randt 分布函数

###### sf_x2inv

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
sf_x2inv(0.6, 30, v);
return v; // 返回结果31.3158632360391
```

###### sf_gampdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(0, 0.1) -  > 13;
return sf_gampdf(x, 2, 2);
```

参考sf_gamcdf sf_gaminv Randgam 分布函数

###### sf_gammainv

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
sf_gammainv(0.068094, 9, v);
return v; // 返回结果 5.000005596
```

###### sf_fcdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(0, 0.1) -  > 3;
return sf_fcdf(x, 20, 30);
```

参考sf_fpdf sf_finv1 Randf 分布函数

###### sf_ch2pdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := 0 -  > 50;
return sf_ch2pdf(x, 30);
```

参考sf_ch2cdf sf_ch2inv Randch2 分布函数

###### Randf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Randf(20, 30, 10, array("a", "b"));
```

参考sf_fpdf sf_fcdf sf_finv1 分布函数

###### Randexp

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Randexp(1, 10, array("a", "b"));
```

参考sf_exppdf sf_expcdf sf_expinv expfit 分布函数

###### Randch2

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Randch2(30, 10, array("a", "b"));
```

参考sf_ch2pdf sf_ch2cdf sf_ch2inv 分布函数

###### sf_gaminv

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

```tsl
y := array(0.01, 0.01) -  > 0.99;
return sf_gaminv(y, 2, 2);
```

参考sf_gampdf sf_gamcdf Randgam 分布函数

###### sf_expinv

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
y := array(0.01, 0.01) -  > 0.99;
return sf_expinv(y, 1);
```

参考sf_exppdf sf_expcdf Randexp expfit 分布函数

###### sf_betapdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(0, 0.01) -  > 1;
return sf_betapdf(x, 2, 4);
```

参考sf_betacdf sf_betainv Randbeta 分布函数

###### sf_tinv1

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
y := array(0.01, 0.01) -  > 0.99;
return sf_tinv1(y, 30);
```

参考sf_tpdf sf_tcdf Randt 分布函数

###### RandCauchy

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return RandCauchy(0, 2, 10, array("a", "b"));
```

参考sf_Cauchypdf sf_Cauchycdf sf_Cauchyinv 分布函数

###### sf_Laplacecdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(-8, 0.1) -  > 8;
return sf_Laplacecdf(x, 0, 2);
```

参考sf_Laplacepdf sf_Laplaceinv RandLaplace 分布函数

###### Randbeta

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Randbeta(2, 4, 100, array("a", "b"));
```

参考sf_betapdf sf_betacdf sf_betainv 分布函数

###### sf_Cauchypdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(-60, 1) -  > 60;
return sf_Cauchypdf(x, 0, 2);
```

参考sf_Cauchycdf sf_Cauchyinv RandCauchy 分布函数

###### sf_logninv

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
y := array(0.01, 0.01) -  > 0.99;
return sf_logninv(y, 0, 1);
```

参考sf_lognpdf sf_logncdf Randlogn 分布函数

###### sf_Laplaceinv

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
y := array(0.01, 0.01) -  > 0.99;
return sf_Laplaceinv(y, 0, 2);
```

参考sf_Laplacepdf sf_Laplacecdf RandLaplace 分布函数

###### sf_betacdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(0, 0.01) -  > 1;
return sf_betacdf(x, 2, 4);
```

参考sf_betapdf sf_betainv Randbeta 分布函数

###### sf_raylinv

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
y := array(0.01, 0.01) -  > 0.99;
return sf_raylinv(y, 1);
```

参考sf_raylpdf sf_raylcdf Randrayl 分布函数

###### sf_wblcdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(0, 0.05) -  > 3;
return sf_wblcdf(x, 1, 1.5);
```

参考sf_wblpdf sf_wblinv Randwbl 分布函数

###### sf_lognpdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(0, 0.1) -  > 5;
return sf_lognpdf(x, 0, 1);
```

参考sf_logncdf sf_logninv Randlogn 分布函数

###### sf_Cauchycdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(-60, 1) -  > 60;
return sf_Cauchycdf(x, 0, 2);
```

参考sf_Cauchypdf sf_Cauchyinv RandCauchy 分布函数

###### Randlogn

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Randlogn(0, 1, 10, array("a", "b"));
```

参考sf_lognpdf sf_logncdf sf_logninv 分布函数

###### Randrayl

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Randrayl(1, 100, array("a", "b"));
```

参考sf_raylpdf sf_raylcdf sf_raylinv 分布函数

###### sf_Laplacepdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(-8, 0.1) -  > 8;
return sf_Laplacepdf(x, 0, 2);
```

参考sf_Laplacecdf sf_Laplaceinv RandLaplace 分布函数

###### sf_raylpdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(0, 0.05) -  > 9;
return sf_raylpdf(x, 1);
```

参考sf_raylcdf sf_raylinv Randrayl 分布函数

###### sf_wblinv

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
y := array(0.01, 0.01) -  > 0.99;
return sf_wblinv(y, 1, 1.5);
```

参考sf_wblpdf sf_wblcdf Randwbl 分布函数

###### sf_logncdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(0, 0.1) -  > 5;
return sf_logncdf(x, 0, 1);
```

参考sf_lognpdf sf_logninv Randlogn 分布函数

###### sf_Cauchyinv

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
y := array(0.01, 0.01) -  > 0.99;
return sf_Cauchyinv(y, 0, 2);
```

参考sf_Cauchypdf sf_Cauchycdf RandCauchy 分布函数

###### sf_raylcdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(0, 0.05) -  > 3;
return sf_raylcdf(x, 1);
```

参考sf_raylpdf sf_raylinv Randrayl 分布函数

###### Randwbl

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Randwbl(1, 1.5, 100, array("a", "b"));
```

参考sf_wblpdf sf_wblcdf sf_wblinv 分布函数

###### sf_betainv

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
y := array(0.01, 0.01) -  > 0.99;
r := sf_betainv(y, 2, 4, x);
return x;
```

参考sf_betapdf sf_betacdf Randbeta 分布函数

###### RandLaplace

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return RandLaplace(0, 2, 10, array("a", "b"));
```

参考sf_Laplacepdf sf_Laplacecdf sf_Laplaceinv 分布函数

###### sf_wblpdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(0, 0.05) -  > 3;
return sf_wblpdf(x, 1, 1.5);
```

参考sf_wblcdf sf_wblinv Randwbl 分布函数

###### sf_betainv1

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
y := array(0.01, 0.01) -  > 0.99;
return sf_betainv1(y, 2, 4);
```

参考sf_betapdf sf_betacdf Randbeta 分布函数

###### sf_mvtcdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

范例01：

```tsl
Rho := array(
(1.0000, 0.9264, 0.0406),
(0.9264, 1.0000, 0.0613),
(0.0406, 0.0613, 1.0000)
);
u := Randunif(0, 1, 300, 3);
return sf_mvtcdf(nil, u, rho, 2);
```

范例02：

```tsl
return sf_mvtcdf(zeros(length(u), 3), u, rho, 2);
```

###### Mvtcdfqmc

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

范例01：

```tsl
Rho := array(
(1, 0.923912552224476, 0.035770327030089),
(0.923912552224476, 1, 0.084276570941762),
(0.035770327030089, 0.084276570941762, 1)
);
return Mvtcdfqmc(array(0, 0, 0), rand(3), rho, 2, array());
```

###### sf_mvncdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

范例01：

```tsl
Rho := array(
(1.0000, 0.9264, 0.0406),
(0.9264, 1.0000, 0.0613),
(0.0406, 0.0613, 1.0000)
);
u := Randunif(0, 1, 300, 3);
return sf_mvncdf(nil, u, nil, rho);
```

范例02：

```tsl
return sf_mvncdf(zeros(length(u), 3), u, zeros(1, 3), rho);
```

###### sf_copulacdf

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

范例01：gaussian分布

```tsl
u := Randunif(0, 1, 300, 3);
Rho := array(
(1.0000, 0.9239, 0.0358),
(0.9239, 1.0000, 0.0843),
(0.0358, 0.0843, 1.0000)
);
return sf_copulacdf(u, "gaussian", rho);
```

范例02：t分布

```tsl
u := Randunif(0, 1, 300, 3);
Rho := array(
(1, 0.923912552224476, 0.035770327030089),
(0.923912552224476, 1, 0.084276570941762),
(0.035770327030089, 0.084276570941762, 1)
);
return sf_copulacdf(u, "t", rho, 2);
```

范例03：阿基米德族，clayton(frank、gumbel调用相同)

```tsl
u := Randunif(0, 1, 300, 2);
return sf_copulacdf(u, "clayton", nil, 1);
```

###### sf_copulafit

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

范例01：gaussian分布

```tsl
// 返回数组，相关系数矩阵
u := Randunif(0, 1, 300, 3);
return sf_copulafit(u, "gaussian", "AML");
```

范例02：t分布

```tsl
// 返回数组，相关系数矩阵以及自由度
u := Randunif(0, 1, 300, 2);
return sf_copulafit(u, "t", "AML");
```

范例03：阿基米德族，clayton(frank、gumbel调用相同)

```tsl
// 返回实数，参数估计值
u := Randunif(0, 1, 300, 2);
return sf_copulafit(u[:, 0:1], "clayton");
```

###### RandCopula

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

范例01：gaussian分布

```tsl
Rho := array(
(1.0000, 0.9239, 0.0358),
(0.9239, 1.0000, 0.0843),
(0.0358, 0.0843, 1.0000)
);
n := 10;
v := array((0, 0, 0), (0, 0, 0), (0, 0, 0));
return RandCopula("gaussian", rho, v, n);
```

范例02：t分布

```tsl
Rho := array(
(1.0000, 0.9239, 0.0358),
(0.9239, 1.0000, 0.0843),
(0.0358, 0.0843, 1.0000)
);
n := 10;
return RandCopula("t", rho, 3, n);
```

范例03：阿基米德族，clayton(frank、gumbel调用相同)

```tsl
alpha := 1;
n := 10;
return RandCopula("clayton", nil, alpha, n);
```

###### sf_exp

用途：统计分布相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
y := array(0.01, 0.01) -  > 0.99;
sf_exp(y, 3, v);
return v;
```

###### Norminv

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

```tsl
return Norminv(0.15, 0.5, 1); // -0.5364
```

##### 统计推断

###### 内容

- Estimate_SNU
- Estimate_TNU
- Estimate\_ SND
- Estimate_TND
- Estimate_SP
- Estimate_TP
- Hypoth_TailRes
- NormPlot
- Hypoth_Kstest
- Hypoth_lillietest
- Hypoth_IndepTest
- Hypoth_KruskalWallis
- Hypoth_SNUTest
- Hypoth_TNUTest
- Hypoth_SNDTest
- Hypoth_TNDTest
- Hypoth_LSUTest
- Anova_Single
- Anova_Twice
- Anova_Bartlett
- Anova_Levene
- 假设检验
- 配对检验

###### Estimate_SNU

用途：统计推断相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(4.68, 4.85, 4.32, 4.85, 4.61, 5.02, 5.2, 4.6, 4.58, 4.72, 4.38, 4.7);
return Estimate_SNU(x, nil, 0.05, 'both');
```

参考Estimate*TNU Estimate* SND Estimate_TND Estimate_SP Estimate_TP

###### Estimate_TNU

用途：统计推断相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
X := array((628, 583, 510, 554, 612, 523, 530, 615), (535, 433, 398, 470, 567, 480, 498, 560, 503, 426));
d := array(nil, nil);
return Estimate_TNU(X, d, 0.05, 'both', 1);
```

参考Estimate*SNU Estimate* SND Estimate_TND Estimate_SP Estimate_TP

###### Estimate\_ SND

范例

```tsl
x := array(45.3, 45.4, 45.1, 45.3, 45.5, 45.7, 45.4, 45.3, 45.6);
alpha := 0.05;
return Estimate_SND(x, alpha, 'right');
```

参考Estimate_SNU Estimate_TNU Estimate_TND Estimate_SP Estimate_TP

###### Estimate_TND

用途：统计推断相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
X := array((2.066, 2.063, 2.068, 2.06, 2.067), (2.058, 2.057, 2.063, 2.059, 2.06));
alpha := 0.1;
return Estimate_TND(X, alpha);
```

参考Estimate*SNU Estimate_TNU Estimate* SND Estimate_SP Estimate_TP

###### Estimate_SP

用途：统计推断相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
mx := 0.3;
n := 120;
alpha := 0.05;
return Estimate_SP(mx, n, alpha);
```

参考Estimate*SNU Estimate_TNU Estimate* SND Estimate_TND Estimate_TP

###### Estimate_TP

用途：统计推断相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
P := array(0.478, 0.328);
N := array(1000.00, 750.00);
alpha := 0.05;
return Estimate_TP(P, N, alpha);
```

参考Estimate*SNU Estimate_TNU Estimate* SND Estimate_TND Estimate_SP

###### Hypoth_TailRes

用途：统计推断相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Hypoth_TailRes(50.110101, 0.06, "left", 0.05);
```

###### NormPlot

用途：统计推断相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := rand(10);
return NormPlot(x);
```

array(

("采样位数":0.171976955840364,"理想位数":-1.64484977722168),

("采样位数":0.301570532377809,"理想位数":-1.03643536567688),

("采样位数":0.470976530341431,"理想位数":-0.674489885568619),

("采样位数":0.479131903499365,"理想位数":-0.38532167673111),

("采样位数":0.678062069928274,"理想位数":-0.125661492347717),

("采样位数":0.735156666953117,"理想位数":0.125661492347717),

("采样位数":0.739045920781791,"理想位数":0.38532167673111),

("采样位数":0.780685598030686,"理想位数":0.674489885568619),

("采样位数":0.817699506180361,"理想位数":1.03643536567688),

("采样位数":0.828364443266764,"理想位数":1.64484977722168))

QQ图形：

Return NormPlot(x,1);

结果：0.911334081735257参考Hypoth_Kstest Hypoth_lillietest

###### Hypoth_Kstest

用途：统计推断相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Hypoth_Kstest(randn(0, 1, 100), ’both’, a, cdf);
```

参考NormPlot Hypoth_lillietest

###### Hypoth_lillietest

用途：统计推断相关函数。
参数：无。
返回：处理后的结果值。

范例

```tsl
return Hypoth_lillietest(array(9.4000, 8.8000, 9.6000, 10.2000,
10.1000, 7.2000 , 11.1000, 8.2000,
8.6000, 9.6000),
0.05, "norm");
```

参考NormPlot Hypoth_Kstest

###### Hypoth_IndepTest

用途：统计推断相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
X := array((25, 70, 60, 85, 95, 90, 80), (70, 60, 20, 30, 15, 40, 35), (50, 70, 60, 80, 90, 70, 75));
return Hypoth_IndepTest(X, 0.05);
```

结果表示拒绝原假设，即x与y有关参考Hypoth_KruskalWallis

###### Hypoth_KruskalWallis

用途：统计推断相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array((120, 30), (479, 371));return Hypoth_KruskalWallis(x, 0.05);
```

结果表示接受原假设，即x与y无关参考Hypoth_IndepTest

###### Hypoth_SNUTest

用途：统计推断相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(8.05, 8.15, 8.2, 8.1, 8.25);
u := 8;
d := 0.2;
tail := "both";
alpha := 0.05;
return Hypoth_SNUTest(x, u, d, tail, alpha);
```

表示接受原假设，均值等于8,该假设检验使用U检验，其中U统计量为1.677，对应的P值为0.094，在显著性水平为0.05时，不能拒绝原假设，所以我们接受原假设。结果中还给出了均值的在0.05的显著性水平下的置信区间参考Hypoth_TNUTest
Hypoth_SNDTest Hypoth_TNDTest Hypoth_LSUTest

###### Hypoth_TNUTest

用途：统计推断相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
X := array((76.43, 76.21, 73.58, 69.69, 65.29, 70.83, 82.75, 72.34),
(73.66, 64.27, 69.34, 71.37, 69.77, 68.12, 67.27, 68.07, 62.61));
uu := 0;
d := array(1, 1);
tail := "both";
alpha := 0.05;
return Hypoth_TNUTest(X, uu, d, tail, alpha, 0);
```

表示拒绝均值差等于0的原假设。该假设检验使用U检验，其中U统计量为10.525，对应的P值为0.00，在显著性水平为0.05时，拒绝原假设，所以我们认为两个样本均值之差显著不为0。结果中还给出了均值差在0.05的显著性水平下的置信区间。参考Hypoth_SNUTest
Hypoth_SNDTest Hypoth_TNDTest Hypoth_LSUTest

###### Hypoth_SNDTest

用途：统计推断相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(1.38, 1.43, 1.39, 1.40, 1.41);
d2 := sqr(0.048);
tail := "left";
alpha := 0.1;
return Hypoth_SNDTest(x, d2, tail, alpha);
```

表示拒绝方差大于sqr(0.048)的原假设。该假设检验使用卡方检验，其中卡方统计量为0.642，对应的P值为0.042，在显著性水平为0.05时，拒绝原假设。参考Hypoth_SNUTest
Hypoth_TNUTest Hypoth_TNDTest Hypoth_LSUTest

###### Hypoth_TNDTest

用途：统计推断相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
X := array((0.140, 0.138, 0.143, 0.141, 0.144, 0.137), (0.135, 0.140, 0.142, 0.136, 0.139));
tail := "both";
alpha := 0.1;
return Hypoth_TNDTest(X, tail, alpha);
```

表示接受原假设，则方差相同参考Hypoth_SNUTest Hypoth_TNUTest Hypoth_SNDTest
Hypoth_LSUTest

###### Hypoth_LSUTest

用途：统计推断相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
mx := 1.85;
s2 := 0.0064;
n := 100;
u := 1.84;
tail := "both";
alpha := 0.01;
return Hypoth_LSUTest(mx, s2, n, u, tail, alpha);
```

表示均值为1.84参考Hypoth_SNUTest Hypoth_TNUTest Hypoth_SNDTest Hypoth_TNDTest

###### Anova_Single

用途：统计推断相关函数。
参数：

返回：处理后的结果值。

范例

例子来自《概率论与数理统计教程》-高等教育出版社 P379 例8.1.4

因素A有4个水平，对A进行重复试验，获得观察值如下：

A1=12 18

A2=14 12 13

A3=19 17 21

A4=24 30

现在显著性水平0.05下，判断以上各水平是否有显著差异

```tsl
x := array((12, 18), (14, 12, 13), (19, 17, 21), (24, 30));
alpha := 0.05;
return Anova_Single(x, alpha);
```

结果表示拒绝原假设，即各个水平下的方差间有显著差异参考Anova_Twice Anova_Bartlett
Anova_Levene

###### Anova_Twice

用途：统计推断相关函数。
参数：

返回：处理后的结果值。

范例

在某指标，因素A和因素B有3个水平，对A、B分别进行2次重复试验，获得观察值如下：

x:=
array((75.00,81.00,74.00),(75.00,81.00,73.00),(62.00,85.00,79.00),(71.00,68.00,60.00),
(58.00,92.00, 75.00),(73.00,90.00,81.00));

现在显著性水平0.05下，判断以上因素A和B对某指标是否有显著影响

```tsl
x := array((75.00, 81.00, 74.00), (75.00, 81.00, 73.00), (62.00, 85.00, 79.00), (71.00, 68.00, 60.00), (58.00, 92.00, 75.00), (73.00, 90.00, 81.00));
return Anova_Twice(x, 0.05, 2);
```

因素A：结果表示接受原假设，即因素A对某指标无显著影响

因素B：结果表示拒绝原假设，即因素B对某指标影响显著

交叉效应：结果表示拒绝原假设，即交叉效应对某指标影响显著参考Anova_Single
Anova_Bartlett Anova_Levene

###### Anova_Bartlett

用途：统计推断相关函数。
参数：

返回：处理后的结果值。

范例

因素A有4个水平，对A进行重复试验，获得观察值如下：

A1=7.96.26.68.68.910.19.6

A2=5.7 7.5 9.8 6.1 8.4

A3=6.4 7.1 7.9 4.5 5 4

A4=6.8 7.5 5 5.3 6.1 7.4

现在显著性水平0.05下，判断以上四组数据方差是否有显著差异:

```tsl
x := array((7.9, 6.2, 6.6, 8.6, 8.9, 10.1, 9.6), (5.7, 7.5, 9.8, 6.1, 8.4), (6.4, 7.1, 7.9, 4.5, 5.0, 4.0), (6.8, 7.5, 5.0, 5.3, 6.1, 7.4));
return Anova_Bartlett(x, 0.05);
```

array("B-Stat":0.965,"P-Value":0.81,"df":3,"Hypothesis":1)

结果表示接受原假设，即各个水平下的方差间无显著差异参考Anova_Single Anova_Twice
Anova_Levene

###### Anova_Levene

用途：统计推断相关函数。
参数：

返回：处理后的结果值。

范例

因素A有4个水平，对A进行重复试验，获得观察值如下：

A1=7.96.26.68.68.910.19.6

A2=5.7 7.5 9.8 6.1 8.4

A3=6.4 7.1 7.9 4.5 5 4

A4=6.8 7.5 5 5.3 6.1 7.4

现在显著性水平0.05下，判断以上四组数据方差是否有显著差异:

```tsl
x := array((7.9, 6.2, 6.6, 8.6, 8.9, 10.1, 9.6), (5.7, 7.5, 9.8, 6.1, 8.4), (6.4, 7.1, 7.9, 4.5, 5.0, 4.0), (6.8, 7.5, 5.0, 5.3, 6.1, 7.4));
return Anova_Levene(x, 0.05);
```

array("F-Stat":0.514,"P-Value":0.678,"df1":3,"df2":20,"Hypothesis":1)

结果表示接受原假设，即各个水平下的方差间无显著差异参考Anova_Single Anova_Twice
Anova_Bartlett

###### 假设检验

####### 内容

- Hypoth_SignTest
- Hypoth_WilcoxonTest
- Hypoth_McNemarTest

####### Hypoth_SignTest

用途：统计推断相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(27.8, 27.8, 29.1, 32.2, 32.7, 32.7, 36.4, 36.5, 37.5, 37.7, 38.8, 41.9);
pi_ := 0.5;
q0 := 32;
tail := "both";
Alpha := 0.05;
return Hypoth_SignTest(x, pi_, q0, tail, alpha);
```

####### Hypoth_WilcoxonTest

用途：统计推断相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(27.8, 27.8, 29.1, 32.2, 32.7, 32.7, 36.4, 36.5, 37.5, 37.7, 38.8, 41.9);
m0 := 34;
tail := "both";
Alpha := 0.05;
return Hypoth_WilcoxonTest(x, m0, tail, Alpha);
```

结果

####### Hypoth_McNemarTest

用途：统计推断相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array((6, 4), (20, 10));
Alpha := 0.05;
return Hypoth_McNemarTest(x, Alpha);
```

结果

###### 配对检验

####### 内容

- Hypoth_PNUTest
- Hypoth_PSignTest
- Hypoth_PWilcoxonTest

####### Hypoth_PNUTest

用途：统计推断相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
X := array((5, 4, 7, 3, 5, 8, 5, 6), (6, 6, 7, 4, 3, 9, 7, 6));
uu := 0;
d := nil;
tail := "both";
alpha := 0.05;
return Hypoth_PNUTest(x, uu, d, tail, alpha)
```

####### Hypoth_PSignTest

####### Hypoth_PWilcoxonTest

##### 多元统计分析

###### 内容

- Corr
- CorrelationMatrix
- Covariance
- Corrcoef
- Corr_partial
- Distance
- Cluster_Kmeans
- Cluster_System
- Cluster_ward
- Discrim
- princomp
- Factor
- corr_canonical
- corr_Spearman
- 相对重要性
- Cov2CorrMatrix
- CorrMatrixAdjust
- corr_Kendall
- HISTC

###### Corr

用途：多元统计分析相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
A := rand(3, 4);
return Corr(A, 1); // 返回的是一般相关系数矩阵
```

输出结果：

```tsl
A := rand(3, 4);
return ret := Corr(A, 1, 'both');
```

输出结果：

array(

(

(1,-0.997183665009044,-0.25079062964811,0.52903553507686),

(-0.997183665009044,1,0.177482907109564,-0.463902099303707),

(-0.25079062964811,0.177482907109564,1,-0.954156728736678),

(0.52903553507686,-0.463902099303707,-0.954156728736678,0.999999999999999)),

(

(0.00,0.0477902336084508,0.83861889909013,0.645107717271616),

(0.0477902336084508,0.00,0.886409132694126,0.692897950958597),

(0.83861889909013,0.886409132694126,0.00,0.1935111818216),

(0.645107717271616,0.692897950958597,0.1935111818216,2.683151079097E-8)))

Ret[0]：相关系数矩阵

Ret[1]：相关系数假设检验P值参考Covariance Corr_partial CorrelationMatrix
Corrcoef Corr_partial Distance

###### CorrelationMatrix

用途：多元统计分析相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
a := rand(4, 3);
return CorrelationMatrix(a, 1);
```

结果

参考Corr Covariance Corr_partial Corrcoef Corr_partial Distance

###### Covariance

用途：多元统计分析相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
a := rand(4, 3);
return Covariance(A);
```

结果

参考Corr CorrelationMatrix Corr_partial Corrcoef Corr_partial Distance

###### Corrcoef

用途：多元统计分析相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
A := rand(7, 4);
return Corrcoef(A); // 返回简单相关系数分析
```

输出结果：

参考Corr Covariance Corr_partial CorrelationMatrix Corr_partial Distance

###### Corr_partial

用途：多元统计分析相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := rand(100, 3);
y := rand(100, 2);
z := rand(100, 2);
return Corr_partial(x, y, z, 2);
// 返回结果：array((-0.0862,0.2046),(-0.1844,0.00),(0.0736,0.0411))
ret := Corr_partial(x, y, z, 2, 'both'); // 返回检验ret 为一个数据表类型
return ret['coef']; // 偏相关系数
return ret['pval']; // 检验偏相关系数是否显著的P值
return ret['df']; // 自由度
```

参考Corr Covariance CorrelationMatrix Corrcoef Corr_partial Distance

###### Distance

用途：多元统计分析相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(22, 35, 24, 32, 43, 53);
y := array(1, 2, 3, 4, 5, 6);
name := 'euclidean'; // 采用欧式距;
return Distance(x, y, name);
```

结果 80.04998438475;

```tsl
x := array(
(700.9, 39.77, 8.49, 12.94, 19.27, 11.05, 2.04, 13.29),
(7.68, 50.37, 11.35, 13.3, 19.25, 14.59, 2.75, 14.87),
(9.42, 27.93, 8.2, 8.14, 16.17, 9.42, 1.55, 9.76),
(9.16, 27000.98, 9.01, 9.32, 15.99, 9.1, 1.82, 11.35),
(10.06, 28.64, 10.52, 10.05, 16.18, 8.39, 1.96, 10.81));
name := "euclidean";
return Distance(x, name);
```

结果

array(

(0,693.32,691.62,26970.08,690.96),

(693.32,0,24.64,26950.61,23.54),

(691.62,24.64,0,26973.05,3.5),

(26970.08,26950.61,26973.05,0,26972.34),

(690.96,23.54,3.5,26972.34,0));参考Corr Covariance Cluster_Kmeans Cluster_System
Cluster_ward

###### Cluster_Kmeans

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

```tsl
sample := array(
(700.9, 39.77, 8.49, 12.94, 19.27, 11.05, 2.04, 13.29), (7.68, 50.37, 11.35, 13.3, 19.25, 14.59, 2.75, 14.87),
(9.42, 27.93, 8.2, 8.14, 16.17, 9.42, 1.55, 9.76),
(9.16, 27000.98, 9.01, 9.32, 15.99, 9.1, 1.82, 11.35),
(10.06, 28.64, 10.52, 10.05, 16.18, 8.39, 1.96, 10.81));
n := 3;
options := array("maxiter":20, "tol":1.0e - 16, "distance":1, "out":1); // 可不输入采用默认
return Cluster_Kmeans(sample, n, options);
```

结果

array(

(1,2,4), //第一类为 1,2,4 个样本

(3), // 第二类为第3个样本

(0))； // 第三类为第0 个样本参考Distance Cluster_System Cluster_ward

###### Cluster_System

用途：多元统计分析相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
A := array(
(7.9, 39.77, 8.49, 12.94, 19.27, 11.05, 2.04, 13.29),
(7.68, 50.37, 11.35, 13.3, 19.25, 14.59, 2.75, 14.87),
(9.42, 27.93, 8.2, 8.14, 16.17, 9.42, 1.55, 9.76),
(9.16, 27.98, 9.01, 9.32, 15.99, 9.1, 1.82, 11.35),
(10.06, 28.64, 10.52, 10.05, 16.18, 8.39, 1.96, 10.81));
dmethods := 1;
methods := 1;
output := array('best':1);
ret1 := Cluster_System(a, Dmethods, Methods);
ret2 := Cluster_System(a, Dmethods, Methods, output);
```

ret1,为谱系图

array(

(2,3,2.2032702966273),

(2,3,3.50368377568526),

(0,1,11.6726218134573),

(0,1,18.0243203755371))；

谱系图解析：

每行表示一次归类，(2,3,2.2032702966273)表示将第2个样本与第3个样本合并，为样本2，样本3,4为合并前的样本4,5，样本数减少一个。(2,3,3.50368377568526)表示将第3个样本与第2个样本合并为样本2，样本3为该次合并前的样本4, 样本数减少一个。

ret2为最佳分类

array(0,0,1,1,1) ；

样本0,1 被分在第一个类；

样本 2,3,4 被分在第二个类中；参考Distance Cluster_Kmeans Cluster_ward

###### Cluster_ward

用途：多元统计分析相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
A := array(
(7.9, 39.77, 8.49, 12.94, 19.27, 11.05, 2.04, 13.29),
(7.68, 50.37, 11.35, 13.3, 19.25, 14.59, 2.75, 14.87),
(9.42, 27.93, 8.2, 8.14, 16.17, 9.42, 1.55, 9.76),
(9.16, 27.98, 9.01, 9.32, 15.99, 9.1, 1.82, 11.35),
(10.06, 28.64, 10.52, 10.05, 16.18, 8.39, 1.96, 10.81));
return Cluster_ward(a);
```

结果

结果解析：第0列与第1列表示合并组合的相对位置，第2列表示合并组合间的距离平方，第3 列表示分类情况，中各个元素用 "," 分割类类之间用"#"分割

###### Discrim

用途：多元统计分析相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
A := array(
(3.00, 8.35, 23.53, 7.51, 8.62, 17.42, 10.00, 1.04, 11.21),
(3.00, 9.25, 23.75, 6.61, 9.19, 17.77, 10.48, 1.72, 10.51),
(3.00, 8.19, 30.5, 4.72, 9.78, 16.28, 7.6, 2.52, 10.32),
(3.00, 7.73, 29.2, 5.42, 9.43, 19.29, 8.49, 2.52, 10.00),
(3.00, 9.42, 27.93, 8.2, 8.14, 16.17, 9.42, 1.55, 9.76),
(3.00, 9.16, 27.98, 9.01, 9.32, 15.99, 9.1, 1.82, 11.35),
(3.00, 10.06, 28.64, 10.52, 10.05, 16.18, 8.39, 1.96, 10.81),
(1.00, 8.67, 36.05, 7.31, 7.75, 16.67, 11.68, 2.38, 12.88),
(1.00, 9.98, 37.69, 7.01, 8.94, 16.15, 11.08, 0.83, 11.67),
(1.00, 6.77, 38.69, 6.01, 8.82, 14.79, 11.44, 1.74, 13.23),
(1.00, 8.14, 37.75, 9.61, 8.49, 13.15, 9.76, 1.28, 11.28),
(1.00, 7.67, 35.71, 8.04, 8.31, 15.13, 7.67, 1.41, 13.25),
(1.00, 7.9, 39.77, 8.49, 12.94, 19.29, 11.05, 2.04, 13.29),
(1.00, 7.18, 40.91, 7.32, 8.94, 17.6, 12.75, 1.14, 14.8),
(1.00, 8.82, 33.7, 7.59, 10.98, 18.82, 14.73, 1.78, 10.1),
(1.00, 6.25, 35.02, 4.72, 6.28, 10.03, 7.15, 1.93, 10.39),
(2.00, 10.6, 52.41, 7.7, 9.98, 12.53, 11.7, 2.31, 14.69),
(3.00, 7.27, 52.65, 3.84, 9.16, 13.03, 15.26, 1.98, 14.57),
(3.00, 13.45, 55.85, 5.5, 7.45, 9.55, 9.52, 2.21, 16.3),
(3.00, 10.85, 44.68, 7.32, 14.51, 17.13, 12.08, 1.26, 11.57),
(3.00, 7.21, 45.79, 7.66, 10.36, 16.56, 12.86, 2.25, 11.69),
(3.00, 7.68, 50.37, 11.35, 13.3, 19.25, 14.59, 2.75, 14.87),
(2.00, 7.78, 48.44, 8.00, 20.51, 22.12, 15.73, 1.15, 16.61));
X := array(
(9.09, 28.12, 7.4, 9.62, 17.26, 11.12, 2.49, 12.65),
(9.41, 28.2, 5.77, 10.8, 16.36, 11.56, 1.53, 12.17),
(8.7, 28.12, 7.21, 10.53, 19.45, 13.3, 1.66, 11.96),
(6.93, 29.85, 4.54, 9.49, 16.62, 10.65, 1.88, 13.61));
options := array('cov':1, 'backtest':1, 'crosstest':1);
return Discrim(A, X, 0, options);
```

计算结果：

参考Cluster_Kmeans Cluster_System Distance Cluster_ward

###### princomp

用途：多元统计分析相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
data := array(
(947.00, 23.4, 14.8, 45.3, 0.46, 85.2, 373.00, 9.54, 0.37, 3.88),
(935.00, 23.2, 16.2, 41.7, 0.4, 83.3, 305.00, 7.9, 0.38, 4.81),
(918.2, 20.9, 14.8, 43.8, 0.38, 82.6, 320.00, 9.51, 0.43, 4.52),
(910.7, 23.4, 16.1, 44.00, 0.46, 85.2, 338.00, 8.6, 0.33, 3.84),
(905.00, 22.9, 17.00, 39.8, 0.45, 80.4, 348.00, 9.53, 0.42, 4.4),
(890.6, 22.3, 15.7, 44.00, 0.41, 85.4, 286.00, 8.67, 0.39, 4.5),
(853.4, 20.9, 15.9, 41.6, 0.35, 85.4, 273.00, 9.79, 0.42, 4.29),
(837.3, 20.2, 14.4, 37.3, 0.33, 82.5, 326.00, 7.62, 0.36, 4.73),
(833.3, 22.2, 15.2, 38.3, 0.37, 82.2, 310.00, 7.84, 0.4, 5.1),
(760.9, 20.4, 15.5, 40.7, 0.32, 84.2, 268.00, 7.75, 0.35, 4.52),
(760.3, 20.8, 15.1, 44.8, 0.35, 79.5, 273.00, 8.91, 0.45, 5.05),
(742.5, 23.4, 14.7, 43.1, 0.35, 79.5, 310.00, 9.13, 0.4, 4.36));
return princomp(data, 0.85, 1, resid);
```

参考Factor

###### Factor

用途：多元统计分析相关函数。
参数：

返回：处理后的结果值。

范例

我们对2010年上证A股的9个财务指标进行因子分析：

TSL代码：

```tsl
stockn := getbk("上证A股");
vo := BackUpSystemParameters();
SetSysParam(pn_date(), today());
sto := array();
for nI := 0 to length(stockn) - 1 do
begin
    SetSysParam(pn_stock(), stockn[nI]);
    if IsStockGoMarket(inttodate(20011231)) then sto[length(sto)] := stockn[nI];
end;
st := array2str(sto, ";");
A1 := Query("", st, true, "", "代码", DefaultStockID(),
"主营业务利润", report(46008, 20101231),
"利润总额", report(46024, 20101231),
"净利润", report(46033, 20101231),
"加权每股收益", report(42003, 20101231),
"每股净资产", report(42006, 20101231),
"加权净资产收益率", report(42013, 20101231),
"资产总计", report(44059, 20101231),
"股本", report(44099, 20101231));
RestoreSystemParameters(vo);
a := zeros(mrows(a1), mcols(a1));
a[:, :] := a1[:, :];
stock := a[:, 0];
data := a[:, 1:8];
// 取得纯数据矩阵
br := Factor(data, 0.85); //
return br;
```

结果分析：

Ret["kmo",0]=0.733，即表明数据可以做因子分析

ret["Total Variance
Explained",0]：第一列为样本矩阵的相关系数矩阵的特征值，第二列为方差贡献率，第三列为累计方差贡献率

ret["Component Matrix",0]：因子载荷矩阵

ret["Communalities",0]：共同度表示三个因子解释掉变量的多少，显然，共同度越大，表示能解释原来变量的信息就越全；

ret["thogonal matrix",0]：从thogonal
matrix中看出第一个公因子可以解释为“规模因子”，因为它的 0:主营业务收入净额、1:主营业务利润;、2:利润总额、3:净利润、7:资产总计、8:股本的绝对值都比较大；第二个公因子可以解释为“收益率因子”，因为其4:每股收益、5:每股净资产的绝对值大；第三个公因子则可以解释为“每股价值因子”因为其4:每股收益和6:净资产收益率;的绝对值较大。因子分析模型中的因子是抽象的，得根据研究对象的具体分析所解释，“解释”是抽象的概念。

ret["Rotation matrix",0]：旋转矩阵

array(

(0.9888,0.1296,0.0734),

(-0.149,0.8703,0.4695),

(-0.0031,-0.4752,0.8799))

ret["Factor
score",0]:因子得分，表示各个股票在这三个因子的得分情况，让研究人员更好的做其他分析参考princomp

###### corr_canonical

用途：多元统计分析相关函数。
参数：

返回：处理后的结果值。

算法

典型性分析算法说明：

典型相关分析是用来分析两组随机变量之间的相关性程度的一种统计方法，它能够有效地解释两组随机变量之间相互线性依赖的关系。

比如在实际问题中，经常遇到一部分变量和另一部分变量之间的相互关系。例如，在经济学中研究商品价格的相关指标和销售的相关指标之间的关系；在地质学中，研究岩石形成的成因关系，考察岩石的化学成分与其周围化学成分的相关性；教育学中，考察学生入学考试成绩和本科阶段一些主要课程成绩的相关性；在统计学中，也可以用来做随机变量之间的多重共线性判断和重构随机变量组，改进随机变量之间多重共线性问题，使得回归分析等结果更加合理，等等。

一般地，假设有两组随机变量和研究它们的相关关系，当p=q=1时，就是通常两个随机变量之间的相关关系；当p>1,q>1时，采用类似主成分分析的方法，找出的线性组合U和的线性组合V，即：U=，，于是将研究两组变量的相关性问题转化成研究两个变量的相关性问题，并且可以适当的调整系数a 和b，使得U和V的相关性达到最大，称这种相关为典型相关，基于这种原则的分析方法称为典型相关分析。

第一步，先定义典型相关，设X=和Y=为随机向量，用X和Y的线性组合和之间相关性来研究X与Y之间的相关性，并希望找到a与b，使得最大。由相关系数定义，

|     |     | (4. 1) |
| --- | --- | ------ |

对任意的α，β和c，d有

|     |     | (4. 2) |
| --- | --- | ------ |

式(4.2)说明，使得相关系数最大的和并不唯一。因此，在综合变量，可限定，。

总结一下第一步，设X=和Y=，p+q维随机向量的均值为0，协方差阵正定。若存在a1=和b1=，使得是约束问题

|     | max  | (4. 3) |
| --- | ---- | ------ |
|     | s.t. | (4. 4) |
|     |      | (4. 5) |

目标函数的最大值，则成，为的第一对典型变量，称它们之间的相关系数为第一典型相关系数。

如果存在和使得

和前面的k-1对典型变量都不相关；

;

和相关系数最大

则称，为的第k对典型变量，称它们之间的相关系数为第k典型相关系数典型相关系数。

第二步，下面直接给出计算过程所需的重要推导步骤以及计算过程：

设Z=，则有，，令，，因此，求解第一对典型变量和典型相关系数的约束问题式(4.3)~(4.5)就等价为

|     | max  | (4. 6) |
| --- | ---- | ------ |
|     | s.t. | (4. 7) |
|     |      | (4. 8) |

这是一个典型的约束优化问题，这里采用拉格朗日乘数法求解该约束问题，其中为Lagrange乘子，得到如下方程：

|     |     | (4. 9)  |
| --- | --- | ------- |
|     |     | (4. 10) |
|     |     | (4. 11) |
|     |     | (4. 12) |

求解上述方程组，在式(4.6)左乘，在式(4.7)左乘，然后将式(4.8)代入式(4.6)，将式(4.9)代入式(4.7)，得到结果。由于正定(在第一步中有定义，即使没有定义的情况下协方差矩阵也是半正定的)，所以和存在，先将式(4.6)和(4.7)中和移到等号右边，然后再分别左乘和，得到

|     | ，  | (4. 13) |
| --- | --- | ------- |

然后将代入式中,所以有

|     |     | (4. 14) |
| --- | --- | ------- |

同理，可得

|     |     | (4. 15) |
| --- | --- | ------- |

其中,。

因此，是矩阵特征根(注意，和具有相同的特征根)，是的特征根对应的特征向量，是的特征根对应的特征向量。

由于，式(4.9)和式(4.11)可得。所以典型相关系数就是和共有根号下的特征根。

因此，优化问题式(4.3)~式(4.5)的解和就是求或最大特征跟相应的特征向量和。

计算步骤如下：

令;

计算最大的特征根和对应的特征向量，令，，,则为第一对典型相关系数，，为第一对典型变量。

对于第k对典型变量的求解方法类似于第一对典型相关变量，只需要将（2）改为

计算最大的特征根和对应的特征向量，令，，，则是第k对典型相关系数，，为第k对典型变量。

第三步，由于在实际中，设，和，所以无法求出典型变量和典型相关系数，需要用样本数据估计样本协方差矩阵。

已知，总体Z的n次观测数据

于是可给出Z的样本资料矩阵为

假设Z~Np+q(μ,∑)，则样本协方差的极大似然估计为

其中，称为样本协方差矩阵。具体计算过程和第二步中的计算步骤基本相同，只需要将替换为即可求解。范例

实例1：

某康复俱乐部对两组指标的典型相关性分析

某康复俱乐部对20名中年人测量了3个生理指标：体重（X1）、腰围（X2）、脉搏（X3）和三个训练指标：引体向上（Y1）、仰卧起坐次数（Y2）、跳跃次数（Y3）

表1 ：某康复俱乐部两组生理指标的典型相关分析

| 编号 | X1  | X2  | X3  | Y1  | Y2  | Y3  |
| ---- | --- | --- | --- | --- | --- | --- |
| 1    | 191 | 36  | 50  | 5   | 162 | 60  |
| 2    | 193 | 38  | 58  | 12  | 101 | 101 |
| 3    | 189 | 35  | 46  | 13  | 155 | 58  |
| 4    | 211 | 38  | 56  | 8   | 101 | 38  |
| 5    | 176 | 31  | 74  | 15  | 200 | 40  |
| 6    | 169 | 34  | 50  | 17  | 120 | 38  |
| 7    | 154 | 34  | 64  | 14  | 215 | 105 |
| 8    | 193 | 36  | 46  | 6   | 70  | 31  |
| 9    | 176 | 37  | 54  | 4   | 60  | 25  |
| 10   | 156 | 33  | 54  | 15  | 225 | 73  |
| 11   | 189 | 37  | 52  | 2   | 110 | 60  |
| 12   | 162 | 35  | 62  | 12  | 105 | 37  |
| 13   | 182 | 36  | 56  | 4   | 101 | 42  |
| 14   | 167 | 34  | 60  | 6   | 125 | 40  |
| 15   | 154 | 33  | 56  | 17  | 251 | 250 |
| 16   | 166 | 33  | 52  | 13  | 210 | 115 |
| 17   | 247 | 46  | 50  | 1   | 50  | 50  |
| 18   | 202 | 37  | 62  | 12  | 210 | 120 |
| 19   | 157 | 32  | 52  | 11  | 230 | 80  |
| 20   | 138 | 33  | 68  | 2   | 110 | 43  |

```tsl
return corr_canonical(x, y, 0.1, 1);
```

实例2：企业经济效益典型相关分析

某市为了全面分析机械类各企业的经济效益，选择了8个不同的利润指标，14家企业关于这8个指标的统计数据如表4-1所示.

表2：机械类各企业的经济效益主成分分析

| 企业 | X1净产值利润率% | X2固定资产利润率% | X3总产值利润% | X4销售收入利润率% | Y1产品成本利润率% | Y2物耗利润率% | Y3人均利润率千元/人 | Y4流动资金利润率% |
| ---- | --------------- | ----------------- | ------------- | ----------------- | ----------------- | ------------- | ------------------- | ----------------- |
| 1    | 40.4            | 24.7              | 7.2           | 6.1               | 8.3               | 8.7           | 2.44                | 20.0              |
| 2    | 25.0            | 12.7              | 11.2          | 11.0              | 12.9              | 20.2          | 3.542               | 9.1               |
| 3    | 13.2            | 3.3               | 3.9           | 4.3               | 4.4               | 5.5           | 0.578               | 3.6               |
| 4    | 22.3            | 6.7               | 5.6           | 3.7               | 6.0               | 7.4           | 0.176               | 7.3               |
| 5    | 34.3            | 11.8              | 7.1           | 7.1               | 8.0               | 8.9           | 1.726               | 27.5              |
| 6    | 35.6            | 12.5              | 16.4          | 16.7              | 22.8              | 29.3          | 3.017               | 26.6              |
| 7    | 22.0            | 7.8               | 9.9           | 10.2              | 12.6              | 17.6          | 0.847               | 10.6              |
| 8    | 48.4            | 13.4              | 10.9          | 9.9               | 10.9              | 13.9          | 1.772               | 17.8              |
| 9    | 40.6            | 19.1              | 19.8          | 19.0              | 29.7              | 39.6          | 2.449               | 35.8              |
| 10   | 24.8            | 8.0               | 9.8           | 8.9               | 11.9              | 16.2          | 0.789               | 13.7              |
| 11   | 12.5            | 9.7               | 4.2           | 4.2               | 4.6               | 6.5           | 0.874               | 3.9               |
| 12   | 1.8             | 0.6               | 0.7           | 0.7               | 0.8               | 1.1           | 0.056               | 1.0               |
| 13   | 32.3            | 13.9              | 9.4           | 8.3               | 9.8               | 13.3          | 2.126               | 17.1              |
| 14   | 38.5            | 9.1               | 11.3          | 9.5               | 12.2              | 16.4          | 1.327               | 11.6              |

```tsl
// 首先选取数据并且对数据做标准化z-score，消除量纲对结果的影响
X := data[:][0:3];
Y := data[:][4:7];
return corr_canonical(X, Y, 0.1, 1);
```

数据返回结论分析：

首先说明XCenter和YCenter返回结果都为零是因为做了数据标准化的结果。从Cor我们可以看出X和Y这两组随机变量之间具有很高的相似度，第一对典型相关系数达到100%的相似度。在这里想说明的是，如果在对类似数据进行回归分析的时候，回归诊断发现了比较严重的多重共线性的时候，此时可以运用典型相关分析的方法，提取出典型相关成都最高的第一对典型相关组合U或者V来代替之前出现多重共线性的随机变量，从而消除和改进回归模型的病态和精度。

###### corr_Spearman

用途：多元统计分析相关函数。
参数：

返回：处理后的结果值。

算法ρ=∑(Rxi-Rx)(Ryi-Ry)∑(Rxi-Rx)2(Ryi-Ry)2

其中：Rx、Ry分别是x和y的位次，位次按照从大到小排序后，这个数所在的位置。

Rx、Ry分别表示平均位次。范例

```tsl
x := array(3, 8, 4, 7, 2);
y := array(5, 10, 8, 10, 6);
return corr_Spearman(x, y);
```

结果：0.87208

###### 相对重要性

####### 内容

- Regress_domin_formula
- Regress_domin_marginal

####### Regress_domin_formula

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

```tsl
y := rand(10);
x := rand(10, 3);
mr := Regress_Domin_Formula(y, x);
return array(
'详情':mr,
'---':'---',
'贡献和':sum(mr[:, '贡献度']),
'R2':Regression(y, x, 0.05, 1)['R-Squared']
);
```

####### Regress_domin_marginal

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

算法

1、快速R2边际效用法：为完整回归的R2减去不包含变量 k 的回归的R2的差

2、平均R2边际效用法：考虑剔除回归的顺序

      自变量较多时较消耗效率，一般在自变量不多于30个时使用范例

```tsl
Y := array(11.73913, 6.400963, 5.016723, 9.033813, 8.083731, 4.62963,
10.49114, 17.20612, 13.08374, 7.745568);
X := array(
(37.0, 48.0, 5.333333, 0.0, 69.33332900000001),
(37.0, 40.0, 5.25, 0.0, 60.0),
(42.0, 40.0, 1.25, 0.0, 16.25),
(43.0, 42.0, 1.75, 1.0, 22.75),
(42.0, 48.0, 17.75, 1.0, 200.0),
(39.0, 30.0, 2.25, 1.0, 29.25),
(37.0, 40.0, 19.0, 0.0, 247.0),
(40.0, 45.0, 14.16667, 1.0, 150.0),
(40.0, 8.0, 5.5, 1.0, 71.5),
(40.0, 50.0, 2.25, 1.0, 29.25));
return Regress_Domin_Marginal(Y, X, nil, 1);
// 结果
array(
("变量名":0, "贡献度":0.03, "贡献率(%)":7.87, "排名":4),
("变量名":1, "贡献度":0.02, "贡献率(%)":6.93, "排名":5),
("变量名":2, "贡献度":0.13, "贡献率(%)":37.94, "排名":1),
("变量名":3, "贡献度":0.06, "贡献率(%)":15.86, "排名":3),
("变量名":4, "贡献度":0.11, "贡献率(%)":31.4, "排名":2));
```

###### Cov2CorrMatrix

用途：多元统计分析相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
A := Covariance(rand(4, 3));
return Cov2CorrMatrix(A);
```

###### CorrMatrixAdjust

用途：多元统计分析相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
A := Corr(rand(6, 6));
return CorrMatrixAdjust(A, 1, 5);
```

###### corr_Kendall

用途：多元统计分析相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(3, 8, 4, 7, 2);
y := array(5, 10, 8, 10, 6);
return corr_Kendall(x, y);
```

结果：0.7379

###### HISTC

用途：多元统计分析相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
a := rand(1000) * 5;
b := array(0, 1, 2, 3, 4, 5);
return HISTC(a, b);
```

##### 回归

###### 内容

- 回归检验
- 回归公用函数
- 最小二乘法回归
- 测试

###### 回归检验

####### 内容

- Regress_Ridge
- Regress_AdjustedR2
- Regress_Logistic
- Regression
- Regress_DWTest
- Regress_Stepwise
- Regress_Constraint
- Regress_White
- Regress_MLS
- Regress_CMLS
- Regress_JBTest
- Regress_pri
- Regress_FTest
- Regression_WLS
- Regress_Binary
- Regress_TTest
- Regress_NLM
- Regress_WLS
- Regress_AicAndSbic
- Regress_RSquare
- Regress_QRlsq
- boxcox
- Regress_HettestSpearman
- Regress_VIF
- Regress_TTest_RWLS
- Regress_TTest_White
- Regress_TTest_NW
- Regression_OLS_White
- Regression_OLS_NW
- NW_Adjustment_Simplification
- Robustfit_M
- Regress_GRStest

####### Regress_Ridge

用途：回归相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
y := array(49.00, 50.2, 50.5, 48.5, 47.5, 44.5, 28.00, 31.5, 34.5, 35.00, 38.00, 38.5, 15.00, 17.00, 20.5, 29.5);
x := array(
(1300.00, 7.5, 0.012, 9750.00, 15.6, 0.09),
(1300.00, 9.00, 0.012, 11700.00, 15.6, 0.108),
(1300.00, 11.00, 0.0115, 14300.00, 14.95, 0.1265),
(1300.00, 13.5, 0.013, 17550.00, 16.9, 0.1755),
(1300.00, 17.00, 0.0135, 22100.00, 17.55, 0.2295),
(1300.00, 23.00, 0.012, 29900.00, 15.6, 0.276),
(1200.00, 5.3, 0.04, 6360.00, 48.00, 0.212),
(1200.00, 7.5, 0.038, 9000.00, 45.6, 0.285),
(1200.00, 11.00, 0.032, 13200.00, 38.4, 0.352),
(1200.00, 13.5, 0.026, 16200.00, 31.2, 0.351),
(1200.00, 17.00, 0.034, 20400.00, 40.8, 0.578),
(1200.00, 23.00, 0.041, 27600.00, 49.2, 0.943),
(1100.00, 5.3, 0.084, 5830.00, 92.4, 0.4452),
(1100.00, 7.5, 0.098, 8250.00, 107.8, 0.735),
(1100.00, 11.00, 0.092, 12100.00, 101.2, 1.012),
(1100.00, 17.00, 0.086, 18700.00, 94.6, 1.462));
k := array();
i := 0;
for nI := 0 to 6e - 3 step 1e - 5 do k[i++] := nI;
return ret := Regress_Ridge(y, x, k, false); // 输出岭迹
// return ret:= Regress_Ridge(y,x); // 输出x对y的岭回归，方差扩大因子法选取k
```

参考Regression Regress_pri Regress_Stepwise Regress_VIF boxcox

####### Regress_AdjustedR2

用途：回归相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Regress_AdjustedR2(0.942066, 9, 1);
// 结果：0.93379
```

参考Regress_CMLS Regression Regress_RSquare

####### Regress_Logistic

用途：回归相关函数。
参数：

返回：处理后的结果值。

范例

在一次关于某城镇居民上下班使用交通工具的社会调查中，

因变量y =1表示居民主要乘坐公共汽车上下班；y=0表示主要骑自行车上下班；

自变量x1表示被调查者的年龄；

x2表示被调查者的月收入；

x3表示被调查者的性别（x3=1为男性，x3=0为女性）

试建立y与自变量间的Logistic回归

TSL代码:

```tsl
y := array(0.00, 0.00, 1.00, 1.00, 1.00, 0.00, 1.00, 1.00, 1.00, 0.00, 1.00, 1.00, 1.00, 0.00, 0.00, 0.00, 0.00, 0.00, 1.00, 0.00, 0.00, 0.00, 0.00, 0.00, 1.00, 0.00, 1.00, 1.00);
x := `array((18, 21, 23, 23, 28, 31, 36, 42, 46, 48, 55, 56, 58, 18, 20, 25, 27, 28, 30, 32, 33, 33, 38, 41, 45, 48, 52, 56), (850, 1200, 850, 950, 1200, 850, 1500, 1000, 950, 1200, 1800, 2100, 1800, 850, 1000, 1200, 1300, 1500, 950, 1000, 1800, 1000, 1200, 1500, 1800, 1000, 1500, 1800), (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1));
constant := true;
alpha := 0.05;
return Regress_Logistic (y, x, constant, alpha);
```

["Coefficient"]：

则logistics回归函数为11+e-(-3.65536889+0.08218454x0+0.00151704x1+2.50195582x2)

["-2LogLikeHood"]：

-2对数似然值是25.97065221，用来描述模型对因变量的预测能力。数值越大，预测越差。

["Wald Test"]：

对每个变量的显著性检验

Wald-Stat：Wald统计量

Z-Stat：Wald统计量的平方根

P-Value：卡方检验p值，即接受零假设的临界值

Hypothesis：是否通过检验，0或1参考Regress_Binary Regress_CMLS Regression

####### Regression

用途：回归相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
Y := array(0.001, 0.564, 0.193, 0.809, 0.585, 0.48, 0.35, 0.896, 0.823, 0.747);
X := array(
(0.174, 0.859),
(0.711, 0.514),
(0.304, 0.015),
(0.091, 0.364),
(0.147, 0.166),
(0.989, 0.446),
(0.119, 0.005),
(0.009, 0.378),
(0.532, 0.571),
(0.602, 0.607));
// u作为变参返回
return Regression(y, x, 0.05, 1);
```

参考Regress_CMLS Regress_RSquare Regress_AdjustedR2 Regress_FTest Regress_TTest
Regress_DWTest Regress_JBTest Regress_AicAndSbic

####### Regress_DWTest

用途：回归相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
U := array(0.245863, 0.056726, -0.145411, -0.287547, -0.410684, 0.012821, 0.073042, 0.201905, 0.136768);
return Regress_DWTest(u); // 结果：0.7874
```

参考Regress_CMLS Regression

####### Regress_Stepwise

用途：回归相关函数。
参数：

返回：处理后的结果值。

范例

判断股票涨幅与各财务指标的相关系

```tsl
endt := inttodate(20100910);
stklist := GetBKByDate('sh000300', endt);
y := array();
x := array();
for i := 0 to length(stklist) - 1 do
begin
    setsysparam(pn_stock(), Stklist[i]);
    setsysparam(pn_date(), endt);
    setsysparam(pn_rate(), 1);
    RDate := NewReportDateOfEndT2(EndT);
    y[i] := stockzf3();
    x[i][0] := Last12MData(RDate, 9900000); // 每股收益
    x[i][1] := Last12MData(RDate, 9900003); // 每股净资产
    x[i][2] := Last12MData(RDate, 9900100); // 净资产收益
    x[i][3] := Last12MData(RDate, 9900108); // 净利润率
    x[i][4] := Last12MData(RDate, 9900203); // 资产负债率
    x[i][5] := Last12MData(RDate, 9900004); // 净资产增长率
    x[i][6] := ln(StockMarketValue(EndT)); // 流通市值
end;
return Regress_Stepwise(y, x, 0.05, 0.1);
```

ret["x"]：array(4,2)

ret["regress"]：和[Regression]的输出结果是一样的格局参考Regression Regress_pri
Regress_Ridge Regress_VIF boxcox

####### Regress_Constraint

用途：回归相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
y := array(0.425306623295765, 1.36119535984939, 0.330434097687351, 0.693363166256445, 1.12135794381143, 0.992864415538359, 0.599585222220468, 1.03157839185033, 0.817720425216125, 0.613581071515125);
x := array( (0.0437987553887069, 0.865901106735691, 0.637902588583529),
(0.991149639012292, 0.402538175228983, 0.830022667301819), (0.794031135737896, 0.866388283902779, 0.336671882774681),
(0.715198307996616, 0.416468291543424, 0.581486012088135),
(0.0273062069900334, 0.24702803301625, 0.983555873855948),
(0.529860897222534, 0.200076438020915, 0.59641290246509),
(0.813422230072319, 0.370269910665229, 0.23934360453859),
(0.888038919074461, 0.293901670724154, 0.613906089449301),
(0.311180313583463, 0.752806227421388, 0.332180465571582),
(0.31012851675041, 0.979520652908832, 0.346078625647351));
constant := 1; // 包含常数项
a := array();
b := array();
aeq := array((1, 1, 1)); // 加入等式约束，之和为 1.2
beq := array(1.2);
alpha := 0.05;
option := 0; // 残差平方和最小
lb := array();
ub := array();
return Regress_Constraint(y, x, constant, A, b, aeq, beq, alpha, option, lb, ub);
```

参考Regress_CMLS Regression Regress_NLM Regress_Binary

####### Regress_White

用途：回归相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(554.61, 562.47, 584.42, 587.43, 600.71, 622.9, 610.19, 624.33, 608.8, 584.74, 590.36, 601.76, 607.39, 617.27, 622.9, 621.8, 587.21, 575.07, 572.99, 569.38, 565.17, 560.42, 553.3);
y := array(1894.61, 1889.64, 1965.41, 2001.5, 2018.66, 2090.77, 2037.74, 2079.12, 2031.68, 1954.21, 1964.37, 1975.01, 1976.82, 2015.69, 2018.46, 1987.76, 1897.22, 1863.8, 1852.42, 1851.52, 1850.48, 1832.91, 1820.81);
z := array(64, 60, 60.1, 59.95, 61.5, 71.5, 70.5, 75.05, 77.5, 73.2, 75.3, 76.5, 78.2, 79.2, 78.8, 75.9, 73, 72.7, 72.7, 72.7, 73.85, 73.8, 73.6);
w := array(4.255, 4.235, 4.438, 4.534, 4.568, 4.768, 4.669, 4.792, 4.648, 4.47, 4.482, 4.548, 4.52, 4.622, 4.639, 4.552, 4.343, 4.276, 4.255, 4.25, 4.238, 4.191, 4.151);
xzw := `array(x, z, w);
alpha := 0.05;
return Regress_White(y, xzw, 0, alpha);
```

参考Regress_CMLS Regression

####### Regress_MLS

用途：回归相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
Y := array(0.001, 0.564, 0.193, 0.809, 0.585, 0.48, 0.35, 0.896, 0.823, 0.747);
X := array(
(0.174, 0.859),
(0.711, 0.514),
(0.304, 0.015),
(0.091, 0.364),
(0.147, 0.166),
(0.989, 0.446),
(0.119, 0.005),
(0.009, 0.378),
(0.532, 0.571),
(0.602, 0.607));
// u作为变参返回
return Regress_MLS(y, x, u);
```

参考Regress_CMLS Regression Regress_QRlsq

####### Regress_CMLS

用途：回归相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
Y := array(0.001, 0.564, 0.193, 0.809, 0.585, 0.48, 0.35, 0.896, 0.823, 0.747);
X := array(
(0.174, 0.859),
(0.711, 0.514),
(0.304, 0.015),
(0.091, 0.364),
(0.147, 0.166),
(0.989, 0.446),
(0.119, 0.005),
(0.009, 0.378),
(0.532, 0.571),
(0.602, 0.607));
// u作为变参返回
return Regress_CMLS(y, x, u, 1);
```

参考Regress_MLS Regression Regress_QRlsq

####### Regress_JBTest

范例

```tsl
Y := array(0.564, 0.693, 0.809, 0.985, 1.18, 1.896, 2.3, 2.747, 3);
return regress_jbtest(y, 0.05);
```

参考Regress_CMLS Regression Regress_FTest Regress_TTest

####### Regress_pri

范例

| 解释变量1 | 解释变量2 | 解释变量3 | 解释变量4 | 解释变量5 | 解释变量6 |
| --------- | --------- | --------- | --------- | --------- | --------- |
| 1.431     | 0.424     | 28.439    | 182.3     | 110.831   | -293.756  |
| 1.651     | 0.318     | 33.287    | 250.835   | 152.497   | -162.076  |
| 1.027     | 0.003     | 22.314    | 209.87    | 127.592   | -153.508  |
| 1.081     | 0.001     | 24.029    | 176.446   | 107.272   | -142.257  |
| 1.117     | 0.164     | 25.75     | 145.37    | 88.379    | -294.591  |
| 1.484     | 0.188     | 32.626    | 166.437   | 101.187   | -360.097  |
| 1.325     | 0.442     | 25.108    | 173.032   | 105.196   | -327.462  |
| 1.519     | 0.804     | 27.114    | 183.501   | 111.561   | -289.782  |
| 1.329     | 0.621     | 20.759    | 113.244   | 68.848    | -658.805  |
| 1.02      | 0.549     | 16.086    | 114.542   | 69.637    | -619.165  |
| 1.209     | 0.633     | 19.215    | 150.918   | 91.752    | -194.209  |
| 1.573     | 0.741     | 24.169    | 210.993   | 128.275   | -133.067  |
| 0.943     | 0.6       | 14.548    | 204.009   | 124.029   | -155.778  |
| 0.829     | 0.667     | 12.946    | 204.971   | 124.614   | -134.152  |
| 0.927     | 0.812     | 14.594    | 398.204   | 242.091   | -122.255  |
| 0.167     | 0.61      | 2.422     | 286.634   | 174.261   | -133.654  |
| -0.293    | 0.49      | -4.122    | 89.503    | 54.414    | -236.781  |
| -0.446    | 0.576     | -6.198    | -66.142   | -40.212   | -56.116   |
| -0.053    | 0.571     | -0.716    | 44.514    | 27.063    | 611.885   |
| -0.133    | 0.213     | -1.783    | -51.718   | -31.442   | -41.645   |
| -0.039    | 0.367     | -0.536    | -102.793  | -62.494   | -58.664   |
| 0.181     | 0.409     | 2.751     | -16.555   | -10.065   | -18.585   |
| 0.025     | 0.16      | 0.442     | -66.158   | -40.221   | -47.71    |
| -0.134    | 0.22      | -1.817    | -159.184  | -96.777   | -68.74    |
| 0.045     | 0.155     | 0.85      | -20.311   | -12.348   | -21.893   |
| 0.059     | 0.076     | 1.038     | -52.438   | -31.88    | -41.981   |
| -0.188    | 0.006     | -2.626    | -50.366   | -30.62    | -34.58    |
| 0.354     | 0.114     | 5.15      | 140.769   | 85.582    | -206.032  |
| 0.324     | -0.242    | 6.233     | 291.18    | 177.026   | -148.341  |

| 解释变量7  | 解释变量8 | 解释变量9 | 解释变量10 | 解释变量11 | 被解释变量 |
| ---------- | --------- | --------- | ---------- | ---------- | ---------- |
| -576.35    | 3038.437  | 1847.244  | -8949.161  | -17558.29  | 0.6        |
| -282.297   | 3992.413  | 2427.222  | -6484.493  | -11294.439 | 0.667      |
| -418.446   | 2704.007  | 1643.925  | -4163.383  | -11348.898 | 0.812      |
| -1260.496  | 2281.625  | 1387.134  | -3257.498  | -28863.787 | 0.61       |
| 605.611    | 2095.182  | 1273.784  | -6196.863  | 12739.329  | 0.49       |
| 1117.915   | 2610.283  | 1586.944  | -9428.13   | 29269.472  | 0.576      |
| 2568.14    | 2626.929  | 1597.064  | -8628.615  | 67670.492  | 0.571      |
| -11379.056 | 2724.996  | 1656.685  | -7920.047  | -311001.92 | 0.213      |
| 185.692    | 1834.922  | 1115.557  | -12147.208 | 3423.841   | 0.367      |
| 233.605    | 1857.328  | 1129.179  | -11556.339 | 4360.099   | 0.409      |
| 9312.993   | 2205.132  | 1340.629  | -4298.943  | 206149.543 | 0.16       |
| -338.246   | 2781.867  | 1691.26   | -3712.606  | -9437.154  | 0.22       |
| -298.984   | 2363.908  | 1437.159  | -3695.792  | -7093.291  | 0.155      |
| -224.157   | 2133.811  | 1297.269  | -2874.695  | -4803.394  | 0.076      |
| -144.225   | 2633.445  | 1601.026  | -3230.017  | -3810.463  | 0.006      |
| -202.274   | 1925.562  | 1170.662  | -2588.069  | -3916.818  | 0.114      |
| 228.624    | 1661.155  | 1009.914  | -3992.523  | 3854.983   | -0.242     |
| -31.182    | 612.07    | 372.113   | -336.585   | -187.029   | -0.255     |
| 42.943     | 1629.952  | 990.943   | 10256.156  | 719.794    | -0.248     |
| -25.383    | 919.83    | 559.218   | -373.312   | -227.538   | -0.042     |
| -40.435    | 903.872   | 549.517   | -523.253   | -360.658   | -0.181     |
| -9.953     | 991.052   | 602.519   | -170.109   | -91.103    | -0.274     |
| -30.643    | 1038.49   | 631.359   | -485.897   | -312.083   | -0.169     |
| -52.728    | 856.257   | 520.569   | -583.427   | -447.526   | -0.11      |
| -12.573    | 1144.935  | 696.073   | -234.303   | -134.559   | -0.079     |
| -27.054    | 1138.099  | 691.917   | -465.796   | -300.176   | -0.025     |
| -25.356    | 1008.787  | 613.301   | -339.702   | -249.089   | 0.095      |
| -2097.228  | 1472.114  | 894.984   | -3061.924  | -31167.74  | 0.185      |
| -197.858   | 1757.787  | 1068.662  | -2622.88   | -3498.408  | 0.358      |

return s:= regression(y,x,0.05,1);

tr:=s["Coefficient"];

return x:\*(`(tr[1:length(tr)-1]))+tr[0] | y;

预测效果图：

R:=corr(x,1);//检验多重共线性

return regress_vif(X);

array("VIF":(0.508,0.452,0.166,0.00,0.00,0.324,2.405,

2.428,0.401,0.292,7.472),"Cond":INF)

s:=regress_pri(y,x,0.85,0.05);//主成分回归

return s;

tr:= s["Coefficient"];

return x:\*(`(tr[1:length(tr)-1]))+tr[0] | y; //主成分回归预测值与实际值的比较

主成分回归结果：

参考Regression Regress_Ridge Regress_Stepwise Regress_VIF boxcox

####### Regress_FTest

范例

```tsl
U := array(0.245863, 0.056726, -0.145411, -0.287547, -0.410684, 0.012821, 0.073042, 0.201905, 0.136768);
Y := array(0.564, 0.693, 0.809, 0.985, 1.18, 1.896, 2.3, 2.747, 3);
return regress_FTest(y, u, 1, 0.05);
```

参考Regress_CMLS Regression Regress_RSquare Regress_AdjustedR2 Regress_TTest
Regress_JBTest

####### Regression_WLS

用途：回归相关函数。
参数：

返回：处理后的结果值。

算法

加权最小二乘法算法说明：

因变量y和自变量x长度都是n，假设满足最小二乘回归的经典假设时，y对x进行回归，形如：

yi=β0+β1x1+β2x2+…+βkxk+μi，i=1,2,3,...,n

用矩阵形式表示为：

Y=Xβ+μ

其中，ββ为系数矩阵，Y为因变量的n个观测值组成的n×1的列向量，X为一个n×(k+1)的矩阵。

一般的多元线性回归中，假设满足最小二乘回归的经典假设时，β系数的计算公式为：

β=(X＇X)-1 X＇Y

但是，当误差项μi存在异方差时，违反了经典假定中的同方差性的假定条件，加权离差平方和为：

Qw=i=1nwi(yi-β0-β1x1-β2x2-…-βkxk)^2

其中，wi为给定的第i个观测值的权数，加权最小二乘法就是寻找β0，β1，β2，…，βkβ0，β1，β2，…βk的估计值使Qw达到最小，记：

Wdiag=w1wn

加权最小二乘估计WLS的矩阵可表达为

βw=(X'WdiagX)-1X'WdiagY范例

```tsl
Y := array(55.0, 65.0, 70.0, 80.0, 79.0, 84.0, 98.0, 95.0, 90.0, 75.0, 74.0, 110.0, 113.0, 125.0, 108.0, 115.0, 140.0, 120.0, 145.0, 130.0, 152.0, 144.0, 175.0, 180.0, 135.0, 140.0, 178.0, 191.0, 137.0, 189.0, 55.0, 70.0, 75.0, 65.0, 74.0, 80.0, 84.0, 79.0, 90.0, 98.0, 95.0, 108.0, 113.0, 110.0, 125.0, 115.0, 130.0, 135.0, 120.0, 140.0, 140.0, 152.0, 140.0, 137.0, 145.0, 175.0, 189.0, 180.0, 178.0, 191.0);
x := array((80.0), (100.0), (85.0), (110.0), (120.0), (115.0), (130.0), (140.0), (125.0),
(90.0), (105.0), (160.0), (150.0), (165.0), (145.0), (180.0), (225.0), (200.0), (240.0),
(185.0), (220.0), (210.0), (245.0), (260.0), (190.0), (205.0), (265.0), (270.0), (230.0),
(250.0), (80.0), (85.0), (90.0), (100.0), (105.0), (110.0), (115.0), (120.0), (125.0),
(130.0), (140.0), (145.0), (150.0), (160.0), (165.0), (180.0), (185.0), (190.0), (200.0),
(205.0), (210.0), (220.0), (225.0), (230.0), (240.0), (245.0), (250.0), (260.0), (265.0),
(270.0));
wweight := 1 / (x[:, 0] ^ 1.5);
return Regression_WLS(Y, X, 0.05, 1, 1, nil, nil, nil, wweight);
```

####### Regress_Binary

用途：回归相关函数。
参数：

返回：处理后的结果值。

范例

在一次关于某城镇居民上下班使用交通工具的社会调查中，因变量y
=1表示居民主要乘坐公共汽车上下班；y=0表示主要骑自行车上下班；自变量x1表示被调查者的年龄；x2表示被调查者的月收入；x3表示被调查者的性别（x3=1为男性，x3=0为女性）

| 交通工具 | 年龄 | 月收入 | 性别 | 交通工具 | 年龄 | 月收入 | 性别 |
| -------- | ---- | ------ | ---- | -------- | ---- | ------ | ---- |
| 0        | 18   | 850    | 0    | 0        | 20   | 1000   | 1    |
| 0        | 21   | 1200   | 0    | 0        | 25   | 1200   | 1    |
| 1        | 23   | 850    | 0    | 0        | 27   | 1300   | 1    |
| 1        | 23   | 950    | 0    | 0        | 28   | 1500   | 1    |
| 1        | 28   | 1200   | 0    | 1        | 30   | 950    | 1    |
| 0        | 31   | 850    | 0    | 0        | 32   | 1000   | 1    |
| 1        | 36   | 1500   | 0    | 0        | 33   | 1800   | 1    |
| 1        | 42   | 1000   | 0    | 0        | 33   | 1000   | 1    |
| 1        | 46   | 950    | 0    | 0        | 38   | 1200   | 1    |
| 0        | 48   | 1200   | 0    | 0        | 41   | 1500   | 1    |
| 1        | 55   | 1800   | 0    | 1        | 45   | 1800   | 1    |
| 1        | 56   | 2100   | 0    | 0        | 48   | 1000   | 1    |
| 1        | 58   | 1800   | 0    | 1        | 52   | 1500   | 1    |
| 0        | 18   | 850    | 1    | 1        | 56   | 1800   | 1    |

使用极大似然法估计模型中的各个参数：

```tsl
y := array(0.00, 0.00, 1.00, 1.00, 1.00, 0.00, 1.00, 1.00, 1.00, 0.00, 1.00, 1.00, 1.00, 0.00, 0.00, 0.00, 0.00, 0.00, 1.00, 0.00, 0.00, 0.00, 0.00, 0.00, 1.00, 0.00, 1.00, 1.00);
x := `array((18, 21, 23, 23, 28, 31, 36, 42, 46, 48, 55, 56, 58, 18, 20, 25, 27, 28, 30, 32, 33, 33, 38, 41, 45, 48, 52, 56), (850, 1200, 850, 950, 1200, 850, 1500, 1000, 950, 1200, 1800, 2100, 1800, 850, 1000, 1200, 1300, 1500, 950, 1000, 1800, 1000, 1200, 1500, 1800, 1000, 1500, 1800), (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1));
constant := true;
alpha := 0.05;
ret := Regress_Binary(y, x, "logit", 3, constant, alpha);
```

下面我们继续看看样本内的误判率：

```tsl
a := (ones(length(x))|x): * `ret["Coefficient"];
a: := 1 / (1 + exp(-mcell));
a := a[:, 0];
a: := mcell >= 0.5;
// 预测值
// return y|a;
b := y - a;
// 误判的为0或1
b: := abs(mcell);
return sum(b) / length(b);
```

得到的结果：

阈值设为0.5，误判率是0.17857参考Regress_CMLS Regression Regress_NLM

####### Regress_TTest

范例

```tsl
U := array(0.245863, 0.056726, -0.145411, -0.287547, -0.410684, -0.012821, 0.073042, 0.201905, 0.136768);
X := `array(1, 2, 3, 4, 5, 6, 7, 8, 9);
a := array(0.318137);
return regress_TTest(x, a, u, 0, 0.05, 0);
```

参考Regress_CMLS Regression Regress_JBTest Regress_FTest

####### Regress_NLM

用途：回归相关函数。
参数：

返回：处理后的结果值。

范例

| 年份 | 消费价格指数CPI<br>X1（以1978年为100） | 人均可支配收入<br>X2（元） | 上年人均消费支出<br>X3（元） | 人均消费支出<br>Y（元） |
| ---- | -------------------------------------- | -------------------------- | ---------------------------- | ----------------------- |
| 1993 | 273.100                                | 2577.400                   | 1671.730                     | 2110.810                |
| 1994 | 339.000                                | 3496.200                   | 2110.810                     | 2851.340                |
| 1995 | 396.900                                | 4283.000                   | 2851.340                     | 3537.570                |
| 1996 | 429.900                                | 4838.900                   | 3537.570                     | 3919.470                |
| 1997 | 441.900                                | 5160.300                   | 3919.470                     | 4185.640                |
| 1998 | 438.400                                | 5425.100                   | 4185.640                     | 4331.600                |
| 1999 | 432.200                                | 5854.020                   | 4331.600                     | 4615.900                |
| 2000 | 434.000                                | 6280.000                   | 4615.900                     | 4998.000                |
| 2001 | 437.000                                | 6859.600                   | 4998.000                     | 5309.000                |
| 2002 | 433.500                                | 7702.800                   | 5309.000                     | 6029.880                |
| 2003 | 438.700                                | 8472.200                   | 6029.880                     | 6510.940                |
| 2004 | 455.800                                | 9421.600                   | 6510.940                     | 7182.100                |
| 2005 | 464.000                                | 10493.000                  | 7182.100                     | 7942.880                |
| 2006 | 471.000                                | 11759.500                  | 7942.880                     | 8696.550                |
| 2007 | 493.600                                | 13785.800                  | 8696.550                     | 9997.470                |

回归方程：

Y1:=log(Y);

X1:=log(X);

return Regression(Y1,X1);

注：根据Hypothesis,0表示显著,1表示不显著,则T检验最后一个变量通不过！

return Regress_VIF(x1); // array("VIF":(7.83,66.409,95.241),"Cond":269.959)

注：当VIF>10或Cond>30时，认为存在严重的多重共线性,第1,2个变量存在严重多重共线性,?第1,2个变量影响是相似的,则可以降维减少特征数量。

return Regress_Stepwise(Y1,X1,0.05,0.1)//逐步回归选取第0,1个解释变量

逐步回归结果：

x:=x[:,0:1];

return Regress_NLM('Demo_Regress_NLM_CallBack',x,y,array(-0.2,0.2,0.8));或

return Regress_NLM('Demo_Regress_NLM_CallBack',x,y, array(-0.1,0.2,0.9));

其中Demo_Regress_NLM_CallBack函数

Function Demo_Regress_NLM_CallBack(beta,x);

Begin

return beta[0]_(x[0]^beta[1])_(x[1]^beta[2]);

End;

结果都是：

估计参数残差序列雅克比矩阵（解释变量）可决系数拟合值拟合值和实际值的比较参考Regress_CMLS
Regression Regress_Binary

####### Regress_WLS

用途：回归相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 对序列s跟gdp进行加权最小二乘法估计，权重数列为1/gdp//
s := array(2010.02, 1055.17, 2660.93, 919.23, 847.89, 1835.54, 898.45, 1322.37, 2409.39, 4808.67, 3467.46, 1310.3, 2119.58, 999.28, 4940.67, 2546.46, 1994.77, 1572.89, 4156.67, 877.93, 275.99, 990.05, 1976.68, 649.33, 887.49, 72.19, 1107.7, 538.62, 245.84, 245.22, 864.27);
gdp := array(3212.71, 2051.16, 6122.53, 2017.54, 1734.31, 5458.22, 2246.12, 3882.16, 5408.76, 10631.75, 7796, 3569.1, 4682.01, 2450.48, 10552.06, 6168.73, 4975.63, 4340.94, 11769.73, 2455.36, 604.13, 1971.3, 4875.12, 1185.04, 2232.32, 161.42, 2035.96, 1161.43, 341.11, 329.28, 1598.28);
w := 1 / (gdp);
// u作为变参返回
return Regress_WLS(s, gdp, w, u);
```

参考Regress_CMLS Regression

####### Regress_AicAndSbic

用途：回归相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
U := array(0.245863, 0.056726, -0.145411, -0.287547, -0.410684, 0.012821, 0.073042, 0.201905, 0.136768);
return Regress_AicAndSbic(u, 1, 9);
```

参考Regress_CMLS Regression

####### Regress_RSquare

用途：回归相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
U := array(0.245863, 0.056726, -0.145411, -0.287547, -0.410684, -0.012821, 0.073042, 0.201905, 0.136768);
Y := array(0.564, 0.693, 0.809, 0.985, 1.18, 1.896, 2.3, 2.747, 3);
return Regress_RSquare(y, u);
// 结果：0.9421
```

参考Regress_CMLS Regression Regress_AdjustedR2

####### Regress_QRlsq

用途：回归相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
Y := array(0.564, 0.693, 0.809, 0.985, 1.18, 1.896, 2.3, 2.747, 3);
X := `array(1, 2, 3, 4, 5, 6, 7, 8, 9);
// u作为变参返回
return Regress_QRlsq(y, x, u, 1);
```

参考Regress_CMLS Regression

####### boxcox

用途：回归相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
data := rand(100);
return boxcox(data);
```

参考Regress_Stepwise Regress_pri Regress_Ridge Regress_VIF

####### Regress_HettestSpearman

用途：回归相关函数。
参数：

返回：处理后的结果值。

算法

做y关于x的普通最小二乘回归，求出εi的估计值，即ei的值

取ei的绝对值，即|ei|，将xi与|ei|按递增或递减的次序排列并分等级

根据公式 rs=1-6n(n2-1)i=1ndi2 算出等级相关系数，其中n为样本量；di对应于xi与|ei|的等级差数

做等级相关系数的显著性检验。在n>8的情况下，用t=n-2rs1-rs对相关系数进行t检验，若|t|≤tα/2(n-2)，则认为异方差问题不存在；否则说明xi与|ei|之间存在系统关系，异方差问题存在。范例

```tsl
y := array(49.00, 50.2, 50.5, 48.5, 47.5, 44.5, 28.00, 31.5, 34.5, 35.00, 38.00, 38.5, 15.00, 17.00, 20.5, 29.5);
x := array(
(1300.00, 7.5, 0.012, 9750.00, 15.6, 0.09),
(1300.00, 9.00, 0.012, 11700.00, 15.6, 0.108),
(1300.00, 11.00, 0.0115, 14300.00, 14.95, 0.1265),
(1300.00, 13.5, 0.013, 17550.00, 16.9, 0.1755),
(1300.00, 17.00, 0.0135, 22100.00, 17.55, 0.2295),
(1300.00, 23.00, 0.012, 29900.00, 15.6, 0.276),
(1200.00, 5.3, 0.04, 6360.00, 48.00, 0.212),
(1200.00, 7.5, 0.038, 9000.00, 45.6, 0.285),
(1200.00, 11.00, 0.032, 13200.00, 38.4, 0.352),
(1200.00, 13.5, 0.026, 16200.00, 31.2, 0.351),
(1200.00, 17.00, 0.034, 20400.00, 40.8, 0.578),
(1200.00, 23.00, 0.041, 27600.00, 49.2, 0.943),
(1100.00, 5.3, 0.084, 5830.00, 92.4, 0.4452),
(1100.00, 7.5, 0.098, 8250.00, 107.8, 0.735),
(1100.00, 11.00, 0.092, 12100.00, 101.2, 1.012),
(1100.00, 17.00, 0.086, 18700.00, 94.6, 1.462));
alpha := 0.05;
constant := 0;
return Regress_HettestSpearman(y, X, alpha, constant);
```

| Statistic  | 1.227706414781371  |
| ---------- | ------------------ |
| P-Value    | 0.2398000476741131 |
| Hypothesis | 1                  |

####### Regress_VIF

用途：回归相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return Regress_VIF(rand(100, 10));
```

参考Regress_Stepwise Regress_pri Regress_Ridge boxcox

####### Regress_TTest_RWLS

用途：回归相关函数。
参数：

返回：处理后的结果值。

算法OLS：普通最小二乘法回归，不需要给权重参数weight，不需要给约束参数restrictiveness

WLS：加权最小二乘法回归，需要给权重参数weight，不需要给约束参数restrictiveness

ROLS：线性约束的普通最小二乘法，不需要给权重参数weight，需要给约束参数restrictiveness

RWLS：线性约束的加权最小二乘法，需要给权重参数weight，需要给约束参数restrictiveness范例

```tsl
x := rand(10, 3);
a := rand(3);
u := rand(10);
k := 3 - 1;
return Regress_TTest_RWLS(x, a, u, k, 0.05, 0);
```

####### Regress_TTest_White

用途：回归相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
Y := array(0.001, 0.564, 0.193, 0.809, 0.585, 0.48, 0.35, 0.896, 0.823, 0.747);
X := array(
(0.174, 0.859),
(0.711, 0.514),
(0.304, 0.015),
(0.091, 0.364),
(0.147, 0.166),
(0.989, 0.446),
(0.119, 0.005),
(0.009, 0.378),
(0.532, 0.571),
(0.602, 0.607));
coe := Regress_CMLS(y, x, u, true, x0, Y0); // 最小二乘回归
return Regress_TTest_White(x, coe, u, 0.05, true, V_OLS);
```

####### Regress_TTest_NW

用途：回归相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
Y := array(0.001, 0.564, 0.193, 0.809, 0.585, 0.48, 0.35, 0.896, 0.823, 0.747);
X := array(
(0.174, 0.859),
(0.711, 0.514),
(0.304, 0.015),
(0.091, 0.364),
(0.147, 0.166),
(0.989, 0.446),
(0.119, 0.005),
(0.009, 0.378),
(0.532, 0.571),
(0.602, 0.607));
coe := Regress_CMLS(y, x, u, true, x0, Y0); // 最小二乘回归
return Regress_TTest_NW(x, coe, u, 0.05, true, 2, V_OLS);
```

####### Regression_OLS_White

用途：回归相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
y := array(0.001, 0.56, 0.193, 0.80, 0.58, 0.48, 0.35, 0.89, 0.82, 0.74);
X := array(
(0.174, 0.859),
(0.711, 0.514),
(0.304, 0.015),
(0.091, 0.364),
(0.147, 0.166),
(0.989, 0.446),
(0.119, 0.005),
(0.009, 0.378),
(0.532, 0.571),
(0.602, 0.607));
return Regression_OLS_White(y, x);
```

####### Regression_OLS_NW

范例

```tsl
y := array(0.001, 0.56, 0.193, 0.80, 0.58, 0.48, 0.35, 0.89, 0.82, 0.74);
X := array(
(0.174, 0.859),
(0.711, 0.514),
(0.304, 0.015),
(0.091, 0.364),
(0.147, 0.166),
(0.989, 0.446),
(0.119, 0.005),
(0.009, 0.378),
(0.532, 0.571),
(0.602, 0.607));
return Regression_OLS_White(y, x);
```

####### NW_Adjustment_Simplification

用途：回归相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
y := array(0.001, 0.56, 0.193, 0.80, 0.58, 0.48, 0.35, 0.89, 0.82, 0.74);
return NW_Adjustment_Simplification(y);
```

####### Robustfit_M

算法采用迭代加权最小二乘估计得到最优权重，使得偏差大的样本点权重小、偏差小的样本点权重大，从而降低异常点对于回归的影响。迭代过程如下：

选取LS估计的β0=XTX-1XTY为迭代初始值，求出初始残差e=Y-Xβ0

残差标准化得到u，u=e/tune*s*sqrt1-h

tune为默认调节常数

s为尺度因子，s=medianabse0-mediane00.6745

h为杠杆向量，H=X(XTX)-1XT，h为H的对角线元素

使用加权函数wfunx求出权重向量W，其第i个元素为wi=w(ui0)

利用β=(XTWX)-1XTWY求得β(1)代替β(0)，求得新残差e

返回步骤（2），依次迭代计算β(i)，当相邻两步的回归系数的差的绝对值的最大值小于预先设定的标准误差时，迭代结束，即max?β(i)-β(i-1)<ε范例

```tsl
x := 1 -  > 100;
y := 3 * x + 100;
y[:5] := 1000;
return robustfit_M(y, x, 0.05, 1, 'andrews', 1.339);
```

####### Regress_GRStest

用途：回归相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 截距项矩阵alpha
Alpha := array((0.1288), (-0.0731), (0.0606), (-0.1398), (-0.2368));
// 回归残差矩阵
eps := array(( 0.2391, 2.8350, 0.1298, -0.1303, -0.4705),
( 0.3388, 0.8279, 0.8726, 1.0098, -0.1260),
( 1.2022, 0.7552, 0.1406, 0.9817, -0.5472),
(-1.2390, -0.8745, -0.8203, -0.7948, -0.9886),
(-0.1682, 0.3842, -0.1333, -0.0479, -0.5298),
( 0.4537, 0.2827, 0.4283, 0.5073, -0.0321),
(-0.6363, 0.3396, -0.4626, -0.2871, -0.5787),
( 0.3037, -0.9632, 0.0126, -0.0788, 0.9519),
( 1.6618, -1.7807, 0.2230, 0.6233, 1.4380),
(-0.2783, 0.4255, -0.3253, -0.2529, -1.0784));
// 因子暴露矩阵
mu := array(( 1.9006, 1.4588, -0.8829),
( 2.4169, 1.2151, -1.1462),
( 0.4599, 0.9646, -0.5166),
( 0.8420, 0.9289, 0.2966),
( 0.1703, -1.6531, 0.0567),
( 1.3330, 1.3360, -1.1067),
(-0.7639, -0.5524, 0.1642),
( 0.4294, -0.2513, 0.2316),
( 2.7809, 1.2122, -0.5281),
( 0.5903, 1.6501, -0.5097));
return Regress_GRStest(alpha, eps, mu);
// array("FGRS":1.97496665,"pGRS":0.36939759)
```

###### 回归公用函数

####### 内容

- LeastSquares_CurveFitting

####### LeastSquares_CurveFitting

用途：回归相关函数。
参数：

返回：处理后的结果值。

算法

若Y中存在空值或者nan，去除F和Y相应位置上的值，然后两者进行矩阵的左除范例

```tsl
f := array((0.01, 0.49, 0.71),
(0.38, 0.54, 0.08),
(0.07, 0.74, 0.2),
(0.5, 0.97, 0.12),
(0.53, 0.45, 0.73));
y := array(0.71, 0.3, 0.01, 0.05, 0.44);
return LeastSquares_CurveFitting(f, y);
// 结果：
```

###### 最小二乘法回归

####### 内容

- 单元回归
- 多项式回归
- 多元回归

####### 单元回归

######## 内容

- SingleRegression
- 中间函数

######## SingleRegression

算法

采用字符串的方式调用CallBack函数得到F，利用最小二乘法进行回归得到系数矩阵范例

```tsl
x := array(0.00, 1.00, 2.00);
y := array(1.00, 2.00, 3);
CallBack := 'SingleLinearRegression_CallBack';
return SingleRegression(x, y, CallBack);
// 结果：
```

######## 中间函数

######### 内容

- SingleLinearRegression_CallBack

######### SingleLinearRegression_CallBack

算法

返回第一项为1，第二项为对应位置X的数组范例

```tsl
x := array(0.00, 1.00, 2.00);
return SingleLinearRegression_CallBack(x);
// 结果：
```

####### 多项式回归

######## 内容

- PolynomialRegression

######## PolynomialRegression

算法

(1)计算每个X对应的由0到M为指数的指数函数值F；

(2)运用最小二乘方法进行回归得到系数矩阵；范例

```tsl
x := array(0.00, 1.00, 2.00);
y := array(1.00, 2.00, 3);
return PolynomialRegression(x, y, 1);
// 结果：
```

####### 多元回归

######## 内容

- MultipleRegression
- 中间函数

######## MultipleRegression

算法

采用字符串的方式调用CallBack函数得到F，运用最小二乘法进行回归得到系数矩阵范例

```tsl
x := array((0.00, 0.00), (0.00, 1.00), (1.00, 0.00), (1.00, 1.00));
y := array(1.00, 2.00, 2.00, 3.00);
CallBack := 'MultipleRegression_CallBack';
return MultipleRegression(x, y, CallBack);
// 结果：
```

######## 中间函数

######### 内容

- LnRegression_CallBack
- MultipleRegression_CallBack

######### LnRegression_CallBack

算法

返回第一项为1，若X中元素小于等于0，其余项对应位置为0，否则其余项对应位置为X中取自然对数后的值的数组范例

```tsl
x := array((0.00, 0.00), (0.00, 1.00), (1.00, 2.00), (2.00, 1.00));
return LnRegression_CallBack(x);
// 结果：
```

######### MultipleRegression_CallBack

算法

返回第一项为1，其余项为对应位置X的取值的数组范例

```tsl
x := array((0.00, 0.00), (0.00, 1.00), (1.00, 2.00), (2.00, 1.00));
return MultipleRegression_CallBack(x);
// 结果：
```

###### 测试

####### 内容

- 最小二乘法回归

####### 最小二乘法回归

######## 内容

- 单元回归
- 多项式回归
- 多元回归

######## 单元回归

######### 内容

- SingleUnLineralRegression_Pgm
- SingleLineralRegression_Pgm
- 中间函数

######### SingleUnLineralRegression_Pgm

算法

(1)采用字符串的方式调用函数得到F；

(2)运用最小二乘方法进行回归得到系数矩阵；范例

```tsl
X := array(0.00, 0.5, 2.00, -2.00);
Y := array(1.00, 1.625, 40, -39);
return SingleUnLineralRegression_Pgm(X, Y);
// 结果：
```

######### SingleLineralRegression_Pgm

算法

(1)采用字符串的方式调用函数得到F；

(2)运用最小二乘方法进行回归得到系数矩阵；范例

```tsl
X := array(1.00, -5.00, 6.00);
Y := array(7.00, -5.00, 17.00);
return SingleLineralRegression_Pgm(X, Y);
// 结果：
```

######### 中间函数

########## 内容

- SingleUnLineralRegression_CallBack

########## SingleUnLineralRegression_CallBack

算法

计算X^3的数值范例

```tsl
X := array(1.00, -5.00, 6.00);
return SingleUnLineralRegression_CallBack(X);
// 结果：
```

######## 多项式回归

######### 内容

- PolynomialRegression_Pgm

######### PolynomialRegression_Pgm

算法

(1)计算每个X对应的由0到M为指数的指数函数值F；

(2)运用最小二乘方法进行回归得到系数矩阵；范例

```tsl
X := array(0.5, 1, 1.5, 2, 2.5, 3);
Y := array(1.71, 2.45, 3.81, 4.8, 7, 8.6);
return PolynomialRegression_Pgm(X, y, 2);
// 结果：
```

######## 多元回归

######### 内容

- MultipleRegression_Pgm
- MultipleUnLinearRegression_Pgm
- 中间函数

######### MultipleRegression_Pgm

算法

(1)采用字符串的方式调用函数得到F；

(2)运用最小二乘方法进行回归得到系数矩阵；范例

```tsl
X := array((5960, 44967, 1873),
(9000, 27860, 928),
(9500, 31439, 1126),
(10000, 39592, 1265),
(18000, 72827, 2214),
(8500, 27317, 912),
(8000, 29856, 899),
(23000, 47752, 1803),
(8100, 39117, 1204),
(9000, 29349, 1725),
(7300, 40116, 1080),
(8000, 31679, 1529),
(20000, 58510, 2455),
(8000, 23454, 1151),
(8000, 20897, 1173),
(10500, 56248, 1960),
(4000, 20859, 1344),
(4500, 22610, 988),
(3400, 35948, 1076),
(1500, 5779, 962));
Y := array(68900, 48500, 55500, 62000, 116500, 45000, 38000, 83000, 59000, 47500, 40500, 40000,
97000, 45500, 40900, 80000, 56000, 37000, 50000, 22400);
return MultipleRegression_Pgm(X, Y);
// 结果：
```

######### MultipleUnLinearRegression_Pgm

算法

(1)采用字符串的方式调用函数得到F；

(2)运用最小二乘方法进行回归得到系数矩阵；范例

```tsl
X := array((15.2, 2.6),
(13.9, 2.14),
(15.8, 1.52),
(12.8, 3.12),
(6.9, 2.48),
(14.6, 3.08),
(15.4, 2.92),
(17.3, 2.76),
(13.7, 2.36),
(12.7, 2.36),
(15.3, 2.56),
(15.2, 2.8),
(12.00, 2.72),
(15.3, 1.92),
(13.7, 1.92),
(13.3, 1.6));
Y := array(25, 20, 15, 34, 20, 33, 28, 30, 23, 24, 25, 26, 26, 20, 20, 13);
CallBack := 'MultiUnLineralRegression_CallBack';
return MultipleUnLinearRegression_Pgm(X, Y, CallBack);
// 结果：
```

######### 中间函数

########## 内容

- MultiUnLineralRegression_CallBack

########## MultiUnLineralRegression_CallBack

算法

返回第一项为常数，第二项为X1，第二项为X2，第三项为X1\*X2的数组范例

```tsl
X := array((15.2, 2.6),
(13.9, 2.14),
(15.8, 1.52),
(12.8, 3.12),
(6.9, 2.48),
(14.6, 3.08),
(15.4, 2.92),
(17.3, 2.76),
(13.7, 2.36),
(12.7, 2.36),
(15.3, 2.56),
(15.2, 2.8),
(12.00, 2.72),
(15.3, 1.92),
(13.7, 1.92),
(13.3, 1.6));
return MultiUnLineralRegression_CallBack(X);
// 结果：
```

##### 灰色系统

###### 内容

- GM_Initial
- GM_Corr
- GM_AGO
- GM_Icorr
- GM_Scorr

###### GM_Initial

用途：灰色系统相关函数。
参数：

返回：处理后的结果值。

范例

初值化：代码如下

```tsl
x := array((1, 2, 3), (2, 3, 4));
un := array();
return GM_Initial(x, "ini", un);
```

均值化：

TSL代码如下

```tsl
x := array((1, 2, 3), (2, 3, 4));
un := array();
return GM_Initial(x, "mean", un);
```

按行区间值化

TSL代码如下

```tsl
x := array((1, 2, 3), (2, 3, 4));
un := array();
return GM_Initial(x, "rrange", un);
```

归一化

TSL代码如下

```tsl
x := array((1, 2, 3), (2, 3, 4));
un := array(1, 2);
return GM_Initial(x, "norm", un);
```

参考GM_Corr GM_AGO GM_Icorr GM_Scorr GM_Estimate

###### GM_Corr

用途：灰色系统相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array((1, 2, 3), (2, 3, 4));
return GM_Corr(x, 0);
```

参考GM_Initial GM_AGO GM_Icorr GM_Scorr GM_Estimate

###### GM_AGO

用途：灰色系统相关函数。
参数：

返回：处理后的结果值。

范例

TSL代码如下

```tsl
x := array(1, 2, 3, 4);
return GM_AGO(x, "add", 2);
```

2. TSL代码如下

```tsl
x := array(1, 2, 3, 4);
return GM_AGO(x, "sub", 2);
```

参考GM_Initial GM_Corr GM_Icorr GM_Scorr GM_Estimate

###### GM_Icorr

用途：灰色系统相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array((1, 2, 3), (2, 3, 4));
return GM_Icorr(x, 1);
```

参考GM_Initial GM_Corr GM_AGO GM_Scorr GM_Estimate

###### GM_Scorr

用途：灰色系统相关函数。
参数：

返回：处理后的结果值。

范例

灰色绝对关联度： TSL代码如下

```tsl
x := array((1, 2, 3), (2, 3, 4));
return GM_Scorr(x, "abs");
```

灰色相对关联度： TSL代码如下

```tsl
x := array((1, 2, 3), (2, 3, 4));
return GM_Scorr(x, "ret");
```

灰色综合关联度： TSL代码如下

```tsl
x := array((1, 2, 3), (2, 3, 4));
return GM_Scorr(x, "com");
```

参考GM_Initial GM_Corr GM_AGO GM_Icorr GM_Estimate

##### 主成分分析

###### 内容

- PrincaipalComponentAnalysis
- 中间函数

###### PrincaipalComponentAnalysis

用途：主成分分析相关函数。
参数：

返回：处理后的结果值。

算法

将Zt标准化得到zT_s，然后进行转置获得新的数组Z，根据数组Z获得相关系数矩阵R，根据数组R获得特征值和特征向量，获得载荷矩阵Cm，对其进行旋转得到RM，根据R和RM获得因子得分系数矩阵Cs，根据Cs和zT_s获得样本公共因子得分矩阵Farr，根据Farr和主因子对应的特征根获得主因子及其得分范例

```tsl
// 设置样本矩阵
zt := array((0.7592, 1.7593, 21.9279, 48.5626, 55.1679),
(0.0490, 0.4457, 2.2255, 82.2658, 192.4348),
(-2.2313, -1.3096, -59.8883, 3.9922, -80.2419),
(0.1364, 0.539, 4.3910, 55.1438, 46.0612),
(0.7233, 1.9467, 15.6127, 111.3018, 58.3969));
return PrincaipalComponentAnalysis(zt);
// 结果：
```

###### 中间函数

####### 内容

- Mbbub
- ComponentScoreMatrix
- FactorScoreMatrix
- Eastrq
- ComponentMatrix
- RotatedComponentMatrix
- Eigen_Jacobi
- GetEigenValue
- FScoreResult

####### Mbbub

算法

获取n=数组p的长度，k=0，m=n-1;

从nI=0到m-1进行循环，将nI的值赋值给数组z对应下标为nI的值，当k<m时，进行以下步骤；

j=m-1，m=0，从i=k到j进行循环，若以i为下标对应p的值大于以i+1为下标对应p的值，把两者的值调换位置，令m=i，并把对应的下标取值在数组z中进行同样的调换；

j=k+1，k=0，从i=m到j进行递减循环，若以i-1为下标对应p的值大于以i为下标对应p的值，把两者的值调换位置，令k=i，并把对应的下标取值在数组z中进行同样的调换范例

```tsl
p := array(2.72, 1.24, 1.31, 0.02, 0.88, 2.18);
return mbbub(p, z);
```

####### ComponentScoreMatrix

用途：主成分分析相关函数。
参数：

返回：处理后的结果值。

算法

将Cm进行转置得到CmT，获得R的逆矩阵rinv，将两个矩阵经过矩阵的乘法得到矩阵t，将t进行转置获得tT范例

```tsl
// 设置样本矩阵
zt := array((0.7592, 1.7593, 21.9279, 48.5626, 55.1679),
(0.0490, 0.4457, 2.2255, 82.2658, 192.4348),
(-2.2313, -1.3096, -59.8883, 3.9922, -80.2419),
(0.1364, 0.539, 4.3910, 55.1438, 46.0612),
(0.7233, 1.9467, 15.6127, 111.3018, 58.3969));
zT_s := Standarize_II(zT); // 标准化
mt_Transposition(zT_s, Z); // 转置
R := CorrelationMatrix(Z); // 相关系数矩阵
Eigen_Jacobi(R, EigenValue, EigenVector); // 特征值&特征向量
Cm := ComponentMatrix(EigenValue, EigenVector, MaxEigenValue); // 载荷矩阵
return ComponentScoreMatrix(Cm, R);
// 结果：
```

####### FactorScoreMatrix

用途：主成分分析相关函数。
参数：

返回：处理后的结果值。

算法

将Cs和Z进行转置得到CmT和zT，将两个矩阵经过矩阵的乘法得到矩阵r，将r进行转置获得rT范例

```tsl
// 设置样本矩阵
zt := array((0.7592, 1.7593, 21.9279, 48.5626, 55.1679),
(0.0490, 0.4457, 2.2255, 82.2658, 192.4348),
(-2.2313, -1.3096, -59.8883, 3.9922, -80.2419),
(0.1364, 0.539, 4.3910, 55.1438, 46.0612),
(0.7233, 1.9467, 15.6127, 111.3018, 58.3969));
zT_s := Standarize_II(zT); // 标准化
mt_Transposition(zT_s, Z); // 转置
R := CorrelationMatrix(Z); // 相关系数矩阵
Eigen_Jacobi(R, EigenValue, EigenVector); // 特征值&特征向量
Cm := ComponentMatrix(EigenValue, EigenVector, MaxEigenValue); // 载荷矩阵
Cs := ComponentScoreMatrix(Cm, R); // 因子得分矩阵
return FactorScoreMatrix(Cs, zt);
// 结果：
```

####### Eastrq

####### ComponentMatrix

用途：主成分分析相关函数。
参数：

返回：处理后的结果值。

算法

计算特征根开平方根乘以对应位置的特征向量得到数组Z;

将数组Z进行转置得到矩阵ZT，对特征根进行排序，按照从小到大的顺序找到特征根的累计方差贡献率大于或等于85%为止对应在数组ZT的值得到矩阵R，转置得到RT范例

```tsl
// 设置样本矩阵
zt := array((0.7592, 1.7593, 21.9279, 48.5626, 55.1679),
(0.0490, 0.4457, 2.2255, 82.2658, 192.4348),
(-2.2313, -1.3096, -59.8883, 3.9922, -80.2419),
(0.1364, 0.539, 4.3910, 55.1438, 46.0612),
(0.7233, 1.9467, 15.6127, 111.3018, 58.3969));
zT_s := Standarize_II(zT); // 标准化
mt_Transposition(zT_s, Z); // 转置
R := CorrelationMatrix(Z); // 相关系数矩阵
Eigen_Jacobi(R, EigenValue, EigenVector); // 特征值&特征向量
return ComponentMatrix(EigenValue, EigenVector, MaxEigenValue);
// 结果：
```

####### RotatedComponentMatrix

用途：主成分分析相关函数。
参数：

返回：处理后的结果值。

算法

计算相对方差，然后把矩阵进行规范化，最后进行方差的最大旋转范例

```tsl
// 设置样本矩阵
zt := array((0.7592, 1.7593, 21.9279, 48.5626, 55.1679),
(0.0490, 0.4457, 2.2255, 82.2658, 192.4348),
(-2.2313, -1.3096, -59.8883, 3.9922, -80.2419),
(0.1364, 0.539, 4.3910, 55.1438, 46.0612),
(0.7233, 1.9467, 15.6127, 111.3018, 58.3969));
zT_s := Standarize_II(zT); // 标准化
mt_Transposition(zT_s, Z); // 转置
R := CorrelationMatrix(Z); // 相关系数矩阵
Eigen_Jacobi(R, EigenValue, EigenVector); // 特征值&特征向量
Cm := ComponentMatrix(EigenValue, EigenVector, MaxEigenValue); // 载荷矩阵
return RotatedComponentMatrix(Cm);
// 结果：
```

####### Eigen_Jacobi

用途：主成分分析相关函数。
参数：

返回：处理后的结果值。

####### GetEigenValue

算法

将数组a行下标与列下标相同对应的值赋值给EigenValue

####### FScoreResult

用途：主成分分析相关函数。
参数：

返回：处理后的结果值。

算法

通过矩阵的乘法获得矩阵F，矩阵F的第一列为数组R的第一项，数组R的其他项为矩阵FactorArr的值范例

```tsl
// 设置样本矩阵
zt := array((0.7592, 1.7593, 21.9279, 48.5626, 55.1679),
(0.0490, 0.4457, 2.2255, 82.2658, 192.4348),
(-2.2313, -1.3096, -59.8883, 3.9922, -80.2419),
(0.1364, 0.539, 4.3910, 55.1438, 46.0612),
(0.7233, 1.9467, 15.6127, 111.3018, 58.3969));
zT_s := Standarize_II(zT); // 标准化
mt_Transposition(zT_s, Z); // 转置
R := CorrelationMatrix(Z); // 相关系数矩阵
Eigen_Jacobi(R, EigenValue, EigenVector); // 特征值&特征向量
Cm := ComponentMatrix(EigenValue, EigenVector, MaxEigenValue); // 载荷矩阵
Cs := ComponentScoreMatrix(Cm, R); // 因子得分系数矩阵
FArr := FactorScoreMatrix(Cs, zT_s); // 样本公共因子得分
return FScoreResult(FArr, MaxEigenValue);
// 结果：
```

##### 时间序列分析

###### 内容

- Time_Diff
- Time_AutoCov
- Time_ACF
- Time_PACF
- Time_RandomTest
- Time_DanielTest
- AR
- ARMA
- Time_ARCH
- Time_GARCH
- Times_ADFTest
- Times_Cointergration_test
- Times_ECM
- Times_Granger
- Time_ARp
- Time_MAq
- Time_ARMA
- Time_GreenFun
- Time_InvFun
- Time_Analyse
- Time_ChoseP
- Times_Cointergration
- GM_Estimate
- Time_ARCHTest
- GarchFit
- Times_johansen
- Times_GrangerCausality
- 因果推断

###### Time_Diff

用途：日期时间处理函数。
参数：

返回：日期或时间值。

范例

```tsl
A := rand(100, 10);
return Time_Diff(A, 1); // 得到A的一阶差分
```

参考diff

###### Time_AutoCov

用途：日期时间处理函数。
参数：

返回：日期或时间值。

范例

```tsl
y := array(64.00, 60.00, 60.1, 59.95, 61.5, 71.5, 75.05, 77.5, 73.2, 75.3);
L := 5;
return Time_AutoCov(y, L);
// 结果:-2.1
```

###### Time_ACF

用途：日期时间处理函数。
参数：

返回：日期或时间值。

算法

其中N为序列x的长度，为序列x的均值，k为滞后阶数。范例

```tsl
y := array(64.00, 60.00, 60.1, 59.95, 61.5, 71.5, 75.05, 77.5, 73.2, 75.3);
return Time_ACF(y);
```

array(1.00,0.7607,0.4403,0.0142,-0.2972,-0.4878,-0.4229,-0.284,-0.1641,-0.0593)参考Time_PACF
Time_RandomTest AR ARMA

###### Time_PACF

用途：日期时间处理函数。
参数：

返回：日期或时间值。

范例

```tsl
y := array(64.00, 60.00, 60.1, 59.95, 61.5, 71.5, 75.05, 77.5, 73.2, 75.3);
return Time_PACF(y);
```

array(1.00,0.7607,-0.3281,-0.4815,-0.0442,-0.0491,0.2401,-0.1081,-0.4253,0.027)参考Time_ACF
Time_RandomTest AR ARMA

###### Time_RandomTest

用途：日期时间处理函数。
参数：

返回：日期或时间值。

范例

```tsl
y := randNorm(0, 1, 200);
m := 6;
alpha := 0.05;
return Time_RandomTest(y, m, alpha);
```

结果表明序列为纯随机序列参考Time_ACF Time_PACF AR ARMA

###### Time_DanielTest

用途：日期时间处理函数。
参数：

返回：日期或时间值。

范例

检验上证指数的平稳性

```tsl
SetSysParam(pn_date(), inttodate(20101222));
N := 40;
SetSysParam(pn_stock(), "SH000001");
y := Nday3(N, StockZf3());
alpha := 0.05;
return Time_DanielTest(y, alpha);
```

表示日期20101222推前总共40个数据的上证指数为平稳序列参考Times_ADFTest
Times_Cointergration_test Times_ECM

###### AR

用途：时间序列分析相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
elps := Randnorm(0, 1, 200);
y := array();
y[0] := 0;
y[1] := 0;
for i := 2 to 199 do y[i] := -0.5 * y[i - 1] + 0.3 * y[i - 2] + elps[i];
return AR(y, 2, 'ls');
```

参考Time_ACF Time_PACF Time_RandomTest ARMA

###### ARMA

用途：时间序列分析相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
elps := randnorm(0, 1, 200);
y := array();
y[0] := 0;
for i := 1 to 199 do y[i] := 0.8 * y[i - 1] + elps[i] - 0.4 * elps[i - 1];
return ARMA(y, 1, 1);
```

参考Time_ACF Time_PACF Time_RandomTest AR

###### Time_ARCH

用途：日期时间处理函数。
参数：

返回：日期或时间值。

范例

```tsl
// 以招商银行(收益率)为例，用ARCH(q)预测2008-6-20的波动率//
SetSysParam(pn_stock(), "SH600036");
SetSysParam(pn_date(), inttodate(20080619));
N := TradeDays(IntToDate(20070101), IntToDate(20080619));
r := Nday3(N, StockLnZf3());
q := 1;
l := 1;
return Time_ARCH(r, q, l);
```

参考AR ARMA Time_GARCH Time_ARCHTest

###### Time_GARCH

用途：日期时间处理函数。
参数：

返回：日期或时间值。

范例

```tsl
// 以招商银行(收益率)为例，用GARCH(1,1)预测2008-6-20的波动率
setsysparam(PN_Precision(), -1);
SetSysParam(pn_stock(), "SH600036");
SetSysParam(pn_date(), inttodate(20080619));
N := TradeDays(IntToDate(20070101), IntToDate(20080619));
rseries := Nday3(N, StockLnZf3());
Model := "GARCH";
return Time_GARCH(rseries, Model);
```

参考AR ARMA Time_ARCH Time_ARCHTest

###### Times_ADFTest

用途：日期时间处理函数。
参数：

返回：日期或时间值。

范例

```tsl
// 检验上证指数的平稳性（是否存在单位根）(结果可参照eviews)
SetSysParam(pn_date(), inttodate(20101222));
N := 40;
SetSysParam(pn_stock(), "SH000001");
y := Nday3(N, StockZf3());
diff := 0; // 不进行差分运算//
style := 0; // 类型为无常数项和趋势项//
F := "SBIC";
p := 1; // 滞后阶数为1阶//
return Times_ADFTest(y, diff, style, F, p, 0.05);
```

统计量的绝对值都大于临界值的绝对值，所以2010-12-22推前总共40个数据的上证指数在5%的显著性水平下为平稳序列，即不存在单位根参考Times_Cointergration_test
Times_ECM Times_Granger

###### Times_Cointergration_test

用途：日期时间处理函数。
参数：

返回：日期或时间值。

范例

```tsl
SetSysParam(PN_Rate(), 1);
SetSysParam(pn_date(), inttodate(20120918));
SetSysParam(PN_Cycle(), cy_day());
SetSysParam(pn_Rateday(), -1);
SetSysParam(pn_stock(), "SH600036");
close1 := nday3(500, close());
SetSysParam(pn_stock(), "SH600000");
close2 := nday3(500, close());
return Times_Cointergration_test(close1, close2, 1, 0.05, 1, "AIC");
```

协整通过参考Times_ADFTest Times_ECM Times_Granger

###### Times_ECM

用途：日期时间处理函数。
参数：

返回：日期或时间值。

范例

```tsl
SetSysParam(PN_Rate(), 1);
SetSysParam(pn_date(), inttodate(20120918));
SetSysParam(PN_Cycle(), cy_day());
SetSysParam(pn_Rateday(), -1);
SetSysParam(pn_stock(), "SH600036");
close1 := nday3(500, close());
SetSysParam(pn_stock(), "SH600000");
close2 := nday3(500, close());
ret := Times_Cointergration_test(close1, close2, 1, 0.05, 1, "AIC");
resid := ret["resid"];
return Times_ECM(close1, close2, resid, 0.05, 2, 2);
```

ECM项为负，结果表明上证指数与深证综指存在长期稳定的协整关系，可在短期内保持均衡参考Times_ADFTest
Times_Cointergration_test Times_Granger

###### Times_Granger

用途：日期时间处理函数。
参数：

返回：日期或时间值。

范例

```tsl
// 判断序列y与x的Granger因果关系，可选择滞后的阶数q(结果可参照eviews)
y := array(7.54676829158648, 7.54414161372032, 7.58345615393818, 7.60165217843263, 7.61018920393381, 7.64528769816112, 7.6195966295892, 7.63970000624999, 7.61661831598208, 7.57774129868065, 7.58292686220974, 7.58832874061354, 7.58924477198461, 7.6087168475262, 7.61009012340108, 7.59476365558267, 7.54814493579901, 7.53037269335155, 7.52424817135246, 7.52376220234772, 7.52320034387805, 7.51366014679793, 7.50703673600832);
x := array(4.15888308335967, 4.0943445622221, 4.09600984154116, 4.09351088147352, 4.11903717481247, 4.26969744969996, 4.25561270981822, 4.31815455807947, 4.3502779363593, 4.29319542096727, 4.32148013480585, 4.33729074083249, 4.35926964755127, 4.37197629882038, 4.36691299686383, 4.32941668440158, 4.29045944114839, 4.28634138453947, 4.28634138453947, 4.28634138453947, 4.30203600897739, 4.30135873160643, 4.29864502573483);
q := 2;
alpha := 0.05;
return Times_Granger(y, x, q, alpha);
```

表示X是Y的Granger原因参考Times_ADFTest Times_Cointergration_test Times_ECM

###### Time_ARp

用途：日期时间处理函数。
参数：

返回：日期或时间值。

范例

```tsl
elps := Randnorm(0, 1, 200);
y := array();
y[0] := 0;
y[1] := 0;
for i := 2 to 199 do y[i] := -0.5 * y[i - 1] + 0.3 * y[i - 2] + elps[i];
return Time_ARp(y, 2, 0);;
```

参考AR ARMA

###### Time_MAq

用途：日期时间处理函数。
参数：

返回：日期或时间值。

范例

```tsl
{已知一个MA模型，通过产生样本去模拟MA模型，求出拟合系数再跟原模型系数比较}
elps := Randnorm(0, 1, 200);
y := array();
y[0] := 0;
y[1] := 0;
for i := 2 to 199 do y[i] := elps[i] - 0.9 * elps[i - 1] + 0.3 * elps[i - 2];
return Time_MAq(y, 2, 0);
```

参考AR ARMA

###### Time_ARMA

用途：日期时间处理函数。
参数：

返回：日期或时间值。

范例

```tsl
{已知一个ARMA模型，通过产生样本去模拟ARMA模型，求出拟合系数再跟原模型系数比较}
elps := Randnorm(0, 1, 200);
y := array();
y[0] := 0;
for i := 1 to 199 do y[i] := 0.8 * y[i - 1] + elps[i] - 0.4 * elps[i - 1];
return Time_ARMA(y, 1, 1, 0);
```

参考AR ARMA

###### Time_GreenFun

用途：日期时间处理函数。
参数：

返回：日期或时间值。

范例

```tsl
Ap := array(1, -0.5);
Mq := array(0);
return Time_GreenFun(Ap, Mq);
```

参考AR ARMA

###### Time_InvFun

用途：日期时间处理函数。
参数：

返回：日期或时间值。

范例

```tsl
x := array(64, 60, 59, 50, 67, 45);
y := array(34, 23);
return Time_InvFun(x, y);
```

参考AR ARMA

###### Time_Analyse

用途：日期时间处理函数。
参数：

返回：日期或时间值。

范例

```tsl
{以招商银行(日收盘价)为例，用AR、MA或ARMA建模，并预测2008 - 6 - 20的收盘价及波动值 / }
SetSysParam(pn_stock(), "SH600036");
SetSysParam(Pn_Cycle(), cy_day());
SetSysParam(pn_date(), inttodate(20080619));
N := TradeDays(IntToDate(20070601), IntToDate(20080619));
r := Nday3(N, close());
Model := "ARMA";
// 调用Time_Analyse模型，根据已知条件建立确定的模型//
case Model of
    "AR":begin
        p := 1;q := 0;l := 1;
    end;
    "MA":begin
        p := 0;q := 1;l := 1;
    end;
    "ARMA":begin
        p := 1;q := 1;l := 1;
    end;
end;
return Time_Analyse(r, Model, p, q, l);
```

参考AR ARMA

###### Time_ChoseP

用途：日期时间处理函数。
参数：

返回：日期或时间值。

范例

```tsl
x := array(64, 60, 59, 50, 67, 45);
return Time_ChoseP(x, "AR", "SBIC");
// 结果：1

x := array(64, 60, 59, 50, 67, 45);
return Time_ChoseP(x, "MA", "SBIC");
// 结果：2

x := array(64, 60, 59, 50, 67, 45);
return Time_ChoseP(x, "ARMA", "AIC");
// 结果：2
```

参考AR ARMA

###### Times_Cointergration

用途：日期时间处理函数。
参数：

返回：日期或时间值。

范例

```tsl
// 判断上证指数与深证综指（对数收益率）的协整关系(结果可参照eviews)
SetSysParam(pn_date(), inttodate(20100730));
N := 20;
SetSysParam(pn_stock(), "SH000001");
y := Nday3(N, StockZf3());
SetSysParam(pn_stock(), "SZ399106");
x := Nday3(N, StockZf3());
alpha := 0.05;
return Times_Cointergration(y, x, alpha);
```

参考Times_Cointergration_test

###### GM_Estimate

用途：时间序列分析相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
x := array(1, 2, 3, 4);
return GM_Estimate(x, 2);
```

参考GM_Initial GM_Corr GM_AGO GM_Icorr GM_Scorr

###### Time_ARCHTest

- Time_Diff
- Time_AutoCov
- Time_ACF
- Time_PACF
- Time_RandomTest
- Time_DanielTest
- AR
- ARMA
- Time_ARCH
- Time_GARCH
- Times_ADFTest
- Times_Cointergration_test
- Times_ECM
- Times_Granger
- Time_ARp
- Time_MAq
- Time_ARMA
- Time_GreenFun
- Time_InvFun
- Time_Analyse
- Time_ChoseP
- Times_Cointergration
- GM_Estimate
- Time_ARCHTest
- GarchFit
- Times_johansen
- Times_GrangerCausality
- 因果推断

###### GarchFit

用途：时间序列分析相关函数。
参数：

返回：处理后的结果值。

范例

以1995年1月至2000年8月日元兑换美元汇率值序列（JPY，如图8-9）为例介绍怎样用天软来进行ARCH建模（序列共1427个值）。

图8-9日元兑换美元汇率值(JPY)序列图8-10DJPY时间序列

JPY序列显然是一个非平稳时间序列，对JPY进行差分，DJPY表示收益，见图8-10，因为DJPY是一个平稳时间序列，应该使用DJPY建立时间序列模型。按照ARMA模型中讲的那样对DJPY拟合ARMA模型，根据自相关系数以及偏自相关系数，AIC准则等，我们最终将模型定为AR(3)模型。

dJPY := diff(JPY);

m := mean(dJPY);

dJPY := dJPY-m;

ret := ARMA(dJPY,3,0);

得到的结果是：

图8-11 AR(3)残差

该模型的残差如图8-11所示，我们怀疑残差含有异方差，使用Time_ARCHTest函数检验。

Time_ARCHTest(ret["e"],1,0.05);

图8-12 AR(3)残差

拒绝原假设，认为模型含有异方差，建立ARCH模型，首先建立ARCH(7)模型(尝试多次，最大滞后选为7为宜)。

图8-13ARCH模型结果图8-14异方差估计情况

modelspec:= array(

    ("R":3,

    "M":0,

    "AR":NIL,

    "MA":NIL,

    "Regress":NIL,

    "VarianceModel":"GARCH",

    "C":nan,

    "P":0,

    "Q":7,

    "GARCH":array(),

    "ARCH":array(),

    "Leverage":NIL));

t := garchfit(ModelSpec,dJPY);

得到的异方差如图8-14。ARCH模型中的的滞后项太多，应该尝试建立GARCH(1,1)模型：

modelspec := array(

    ("R":3,

    "M":0,

    "AR":NIL,

    "MA":NIL,

    "Regress":NIL,

    "VarianceModel":"GARCH",

    "C":nan,

    "P":1,

    "Q":1,

    "GARCH":array(),

    "ARCH":array(),

    "Leverage":NIL));

t := garchfit(ModelSpec,dJPY);

图8-15GARCH模型结果图8-16方差估计情况

###### Times_johansen

- Time_Diff
- Time_AutoCov
- Time_ACF
- Time_PACF
- Time_RandomTest
- Time_DanielTest
- AR
- ARMA
- Time_ARCH
- Time_GARCH
- Times_ADFTest
- Times_Cointergration_test
- Times_ECM
- Times_Granger
- Time_ARp
- Time_MAq
- Time_ARMA
- Time_GreenFun
- Time_InvFun
- Time_Analyse
- Time_ChoseP
- Times_Cointergration
- GM_Estimate
- Time_ARCHTest
- GarchFit
- Times_johansen
- Times_GrangerCausality
- 因果推断

###### Times_GrangerCausality

用途：日期时间处理函数。
参数：

返回：日期或时间值。

范例

只说明该函数的用法，不考虑实际背景应用，我们继续使用招商银行，浦发银行的收盘价数据来做Granger因果检验。

```tsl
return Times_GrangerCausality(close1|close2, 2);
```

array(("result":0,"cause":1,"F-Stat":123.8121,"P-Value":0.00),

("result":1,"cause":0,"F-Stat":1.5181,"P-Value":0.2201))

1是0的Granger原因，0不是1的Granger原因。即浦发银行是招商银行股价波动的原因。

###### 因果推断

####### 内容

- Time_VolatilitySpillover

####### Time_VolatilitySpillover

范例见Demo_Time_VolatilitySpillover_01

##### 优化

###### 内容

- NonLP_Hooke_Jeeves
- Prog_L
- NonLP_minPS
- NonLP_Fibonacci
- NonLP_Range
- Fmin
- NonLP_BSearch
- Prog_M
- NonLP_minFactor
- NonLP_GP
- NonLP_Fminsearch
- NonLP_Fmincon
- NonLP_minSUMT
- Prog_Q
- Prog_N
- NonLP_Nelder
- NonLP_Fminbnd
- NonLP_Golden
- TSOptimizer
- Quadprog
- LinearProgramming
- NonLP_Rosenbrock
- QuadLagR
- OZProg
- 有约束优化算法
- 无约束优化算法
- 测试
- QuadTrackRoute
- IntLinProg

###### NonLP_Hooke_Jeeves

用途：优化相关函数。
参数：

返回：处理后的结果值。

范例

目标：

```tsl
function obj(x);
begin
    return 3 * x[0] ^ 2 + x[1] ^ 2 - 2 * x[0] * x[1] + 4 * x[0] + 3 * x[1];
end;
```

函数求解：

```tsl
x0 := array(1, 1); // 初始值;
return ret := NonLP_Hooke_Jeeves("obj", x0, 0.2);
```

参考NonLP_Fminsearch NonLP_Nelder NonLP_Rosenbrock

###### Prog_L

用途：优化相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
f := array(-2, -3);
a := array((1, 2), (4, 0), (0, 4)); // 二维数组
b := array(-2, 6, 2); // 一维数组
aeq := array(); // 二维数组
beq := array(); // 一维数组
lb := array(); // 一维数组
ub := array(); // 一维数组
// options := array(); // 算法设置采用默认精度
ozarr := array(0); // 设置第0 个变量为0 or1；
intarr := array(); // 整数约束为空；
x0 := array(1, 2);
ret := Prog_L(f, a, b, aeq, beq, lb, ub, x0, options, ozarr, intarr);
return ret;
```

参考Prog_Q Prog_N Prog_M NonLP_Fminsearch NonLP_Fminbnd

###### NonLP_minPS

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

```tsl
{线性不等式约束
x[0] + x[1] <= 3;
4 * x[0] + x[1] <= 9; }
A := array((1, 1), (4, 1));
B := array(3, 9);
// 初始值S
X0 := array(1, 1);
// 分别设置的变量,约束条件,目标函数的迭代精度；不设置采用默认值
return NonLP_minPS('obj', x0, A, B, 'constr');
```

目标函数

```tsl
function obj(x);
begin
    return 2 * x[0] ^ 2 - 4 * x[0] * x[1] + 4 * x[1] ^ 2 - 6 * x[0] - 3 * x[1];
end;
```

非线性约束:

```tsl
function constr(x);
begin
    ne := array();
    e := array();
    ne[0] := x[0] + x[1] ^ 2 - 5; // x[0]+x[1]^2<5非线性不等式约束
    return array(ne, e);
end;
```

参考Prog_N Fmin NonLP_minSUMT NonLP_minFactor NonLP_Fmincon

###### NonLP_Fibonacci

用途：优化相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 目标函数
function obj(x);
begin
    return a ^ 2 - 5 * a + 8;
end;
```

求解最小值：

```tsl
A := 1; // 下界;
B := 7; // 上界；
return ret := NonLP_Fibonacci("obj", 1, 7);
```

参考NonLP_Fminbnd NonLP_Golden NonLP_GP NonLP_Range NonLP_BSearch

###### NonLP_Range

用途：优化相关函数。
参数：

返回：处理后的结果值。

范例

目标：

```tsl
function obj(x);
begin
    return 3 * x[0] ^ 2 + x[1] ^ 2 - 2 * x[0] * x[1] + 4 * x[0] + 3 * x[1];
end;
```

函数求解：

```tsl
x0 := array(1, 1); // 初始值;
return ret := NonLP_Range("obj", x0, 0.2);
```

参考NonLP_Fminbnd NonLP_BSearch NonLP_Golden NonLP_Fibonacci NonLP_GP

###### Fmin

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

Find values of x that minimize

f(x) = –x1x2x3, starting at the point x = [10;10;10],

subject to the constraints:

0 ≤ x1 + 2x2 + 2x3 ≤ 72.

TSL代码：

```tsl
fun := "Fmin_FunCall"; // 回调目标函数
x0 := array(10, 10, 10); // 初值
A := array((-1, -2, -2), (1, 2, 2)); // 线性不等式左边
B := array(0, 72); // 线性不等式右边
Aeq := array(); //
Beq := array(); //
lb := array();
ub := array();
nonlcon := ""; // 回调非线性约束为空
return Fmin(fun, x0, A, B, Aeq, Beq, lb, ub, nonlcon);
```

x1=24,x2=12,x3=12,最优值f(x)=-3456

回调函数：

Function Fmin_FunCall(x);

Begin

return -x[0]*x[2]*x[1];

End;参考Prog_N NonLP_minSUMT NonLP_minPS NonLP_minFactor NonLP_Fmincon

###### NonLP_BSearch

用途：优化相关函数。
参数：

返回：处理后的结果值。

范例

目标：

```tsl
function obj(x);
begin
    return 3 * x[0] ^ 2 + x[1] ^ 2 - 2 * x[0] * x[1] + 4 * x[0] + 3 * x[1];
end;
```

函数求解：

```tsl
x0 := array(1, 1); // 初始值;
return ret := NonLP_BSearch("obj", x0, 0.2);
```

参考NonLP_Fminbnd NonLP_Range NonLP_Golden NonLP_Fibonacci NonLP_GP

###### Prog_M

用途：优化相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
function UndefineFunc147(); // 主函数
begin
    goal := array(1, 1); // 目标约束
    wight := array(1, 0.5); // 目标权重
    // 线性等式约束
    aeq := array((1, 1, 1));
    beq := array(1);
    // 上下界约束
    lb := array(0, 0, 0);
    ub := array();
    // 初始值
    x0 := array(1, 1, 1);
    // 算法设定
    options := array('tolx':1.0e - 6, 'tolcon':1.0e - 6, 'tolfun':1.0e - 6);
    // 线性不等式约束
    A := array((1, 1), (4, 1));
    B := array(3, 9);
    return Prog_M('UndefineFunc147.obj', x0, goal, wight, a, b, aeq, beq, lb, ub, 'UndefineFunc147.cons', options);
end;
function obj(x); // 目标函数
begin
    f1 := -3 * x[0] - x[1] - 5 * x[2] + 6; // 目标1
    f2 := 3 * x[0] + 4 * x[1] + 5 * x[2] - 6; // 目标2
    f := array(f1, f2);
    return f;
end;
function cons(x); // 约束条件
begin
    c := array();
    c[0] := x[0] ^ 2 - x[1]; // x[0]^2<=x[1]; 不等式
    ceq := array();
    ceq[0] := x[0] ^ 2 - 0.1; // x[0]^2=0.1; 等式约束
    ceq[1] := x[1] ^ 2 - 0.3; // x[1]^2=0.3; 等式约束
    return array(c, ceq);
end;
```

参考Prog_L Prog_Q Prog_N NonLP_Fminsearch NonLP_Fminbnd

###### NonLP_minFactor

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

参考有约束非线性优化总函数NonLP_Fmincon的范例和参考

```tsl
// 线性等式约束
AEQ := array();
BEQ := array();
// 初始值
x0 := array(1, 1);
// 分别设置的变量,约束条件,目标函数的迭代精度；不设置采用默认值
return NonLP_minFactor('obj', X0, AEQ, BEQ, 'constr');
```

目标函数

```tsl
function obj(x);
begin
    return 2 * x[0] ^ 2 - 4 * x[0] * x[1] + 4 * x[1] ^ 2 - 6 * x[0] - 3 * x[1];
end;
```

非线性约束:

```tsl
function constr(x);
begin
    ne := array();
    e := array();
    // ne[0]:= x[0]+x[1]^2-5; // x[0]+x[1]^2<5非线性不等式约束
    e[0] := x[1] ^ 2 + x[0] ^ 2 - 4; // x[1]^2=4非线性等式约束
    return array(ne, e);
end;
```

参考Prog_N Fmin NonLP_minSUMT NonLP_minPS NonLP_Fmincon

###### NonLP_GP

用途：优化相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 目标函数
function obj(x);
begin
    return a ^ 2 - 5 * a + 8;
end;
```

求解最小值：

```tsl
A := 1; // 下界;
B := 7; // 上界；
return ret := NonLP_GP("obj", 1, 7);
```

参考NonLP_Fminbnd NonLP_Golden NonLP_Fibonacci NonLP_Range NonLP_BSearch

###### NonLP_Fminsearch

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

```tsl
function UndefineFunc150();
begin
    x0 := array(1, 1); // 初始值;
    methods := 3; //
    return ret := NonLP_Fminsearch("UndefineFunc150.obj", x0, methods);
end;
function obj(x);
begin
    return 3 * x[0] ^ 2 + x[1] ^ 2 - 2 * x[0] * x[1] + 4 * x[0] + 3 * x[1];
end;
```

参考Prog_L Prog_Q Prog_N Prog_M NonLP_Fminbnd

###### NonLP_Fmincon

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

```tsl
{线性不等式约束
x[0] + x[1] <= 3;
4 * x[0] + x[1] <= 9; }
A := array((1, 1), (4, 1));
B := array(3, 9);
// 线性等式约束
AEQ := array();
BEQ := array();
// 初始值
x0 := array(1, 1);
// 分别设置的变量,约束条件,目标函数的迭代精度；不设置采用默认值
return NonLP_Fmincon('obj', x0, a, b, aeq, beq, 'constr', 1);
```

目标函数

```tsl
function obj(x);
begin
    return 2 * x[0] ^ 2 - 4 * x[0] * x[1] + 4 * x[1] ^ 2 - 6 * x[0] - 3 * x[1];
end;
```

非线性约束:

```tsl
function constr(x);
begin
    ne := array();
    e := array();
    ne[0] := x[0] + x[1] ^ 2 - 5; // x[0]+x[1]^2<5非线性不等式约束
    e[0] := x[1] ^ 2 + x[0] ^ 2 - 4; // x[1]^2=4非线性等式约束
    return array(ne, e);
end;
```

参考Prog_N Fmin NonLP_minSUMT NonLP_minPS NonLP_minFactor

###### NonLP_minSUMT

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

```tsl
{线性不等式约束
x[0] + x[1] <= 3;
4 * x[0] + x[1] <= 9; }
A := array((1, 1), (4, 1));
B := array(3, 9);
// 线性等式约束
AEQ := array();
BEQ := array();
// 初始值
x0 := array(1, 1);
// 分别设置的变量,约束条件,目标函数的迭代精度；不设置采用默认值
return NonLP_minSUMT('obj', X0, A, B, Aeq, Beq, 'constr', "NM");
```

目标函数

```tsl
function obj(x);
begin
    return 2 * x[0] ^ 2 - 4 * x[0] * x[1] + 4 * x[1] ^ 2 - 6 * x[0] - 3 * x[1];
end;
```

非线性约束:

```tsl
function constr(x);
begin
    ne := array();
    e := array();
    ne[0] := x[0] + x[1] ^ 2 - 5; // x[0]+x[1]^2<5非线性不等式约束
    e[0] := x[1] ^ 2 + x[0] ^ 2 - 4; // x[1]^2=4非线性等式约束
    return array(ne, e);
end;
```

参考Prog_N Fmin NonLP_minPS NonLP_minFactor NonLP_Fmincon

###### Prog_Q

用途：优化相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
H := array((2, 0), (0, 2)); // 二次项
f := array(-8, -10); // 一次项
A := array((3, 2));b := array(6); // 不等式约束
Aeq := array((1, 1));beq := array(2.54); // 等式约束
Lb := array(0, 0);
Ub := array(); // 上下界约束
ret := Prog_Q(h, f, a, b, aeq, beq, lb, ub);
```

参考Prog_L Prog_N Prog_M NonLP_Fminsearch NonLP_Fminbnd

###### Prog_N

用途：优化相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
function UndefineFunc149();
begin
    {线性不等式约束
    x[0] + x[1] <= 3;
    4 * x[0] + x[1] <= 9; }
    A := array((1, 1), (4, 1));
    B := array(3, 9);
    // 线性等式约束
    AEQ := array();
    BEQ := array();
    {上下界约束:
    0 < x[0];0 < x[1]
    x[0] < 5;x[1] < 5 }
    ub := array(5, 5);
    lb := array(0, 0);
    // 初始值
    x0 := array(1, 1);
    // 算法设定：
    options := array('tolx':1.0e - 6, 'tolcon':1.0e - 6, 'tolfun':1.0e - 6);
    // 分别设置的变量,约束条件,目标函数的迭代精度；不设置采用默认值
    return Prog_N('UndefineFunc149.obj', x0, a, b, aeq, beq, lb, ub, 'UndefineFunc149.constr', options);
end;
// 目标函数
function obj(x);
begin
    return 2 * x[0] ^ 2 - 4 * x[0] * x[1] + 4 * x[1] ^ 2 - 6 * x[0] - 3 * x[1];
end;
// 非线性约束:
function constr(x);
begin
    ne := array();
    e := array();
    ne[0] := x[0] + x[1] ^ 2 - 5; // x[0]+x[1]^2<5非线性不等式约束
    e[0] := x[1] ^ 2 + x[0] ^ 2 - 4; // x[1]^2=4非线性等式约束
    return array(ne, e);
end;
```

参考Prog_L Prog_Q Prog_M NonLP_Fminsearch NonLP_Fminbnd

###### NonLP_Nelder

用途：优化相关函数。
参数：

返回：处理后的结果值。

范例

目标：

```tsl
function obj(x);
begin
    return 3 * x[0] ^ 2 + x[1] ^ 2 - 2 * x[0] * x[1] + 4 * x[0] + 3 * x[1];
end;
```

函数求解：

```tsl
x0 := array(1, 1); // 初始值;
methods := 3; //
return ret := NonLP_Nelder("obj", x0, 0.2);
```

参考NonLP_Fminsearch NonLP_Hooke_Jeeves NonLP_Rosenbrock

###### NonLP_Fminbnd

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

目标：

function obj(x);

begin

return a^2-5\*a+8;

End;

A := 1 ;//下界;

B := 7;//上界；

methods :=0;//

Return ret := NonLP_Fminbnd("obj",a,b,methods);

参考Prog_L Prog_Q Prog_N Prog_M NonLP_Fminsearch

###### NonLP_Golden

用途：优化相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
// 目标函数
function obj(x);
begin
    return a ^ 2 - 5 * a + 8;
end;
```

求解最小值：

```tsl
A := 1; // 下界;
B := 7; // 上界；
return ret := NonLP_Golden("obj", 1, 7);
```

参考NonLP_Fminbnd NonLP_Fibonacci NonLP_GP NonLP_Range NonLP_BSearch

###### TSOptimizer

范例

```tsl
obj := createobject("testopt");
obj.fx0 := array(1, 1); // 初始值
obj.flb := array(0, 0); // 设置下界
obj.fub := array(5, 5); // 设置上界
obj.foptions := array('tolx':1.0e - 6, 'tolcon':1.0e - 6, 'tolfun':1.0e - 6); // 设置计算参数
obj.prog();
return obj.fresult;
type testopt = class(tsoptimizer)
function obj(x); virtual; // 重写目标
begin
    return 2 * x[0] ^ 2 - 4 * x[0] * x[1] + 4 * x[1] ^ 2 - 6 * x[0] - 3 * x[1];
end;
function con(x);virtual; // 重写约束
begin
    ne := array();
    e := array();
    ne[0] := x[0] + x[1] ^ 2 - 5;
    e[0] := x[1] ^ 2 + x[0] ^ 2 - 4;
    return array(ne, e);
end;
end;
```

###### Quadprog

用途：优化相关函数。
参数：

返回：处理后的结果值。

范例

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代码：

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

参考Prog_Q QuadTrackRoute QuadLagR

###### LinearProgramming

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

范例

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代码：

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

参考Prog_L IntLinProg OZProg

###### NonLP_Rosenbrock

用途：优化相关函数。
参数：

返回：处理后的结果值。

范例

目标：

```tsl
function obj(x);
begin
    return 3 * x[0] ^ 2 + x[1] ^ 2 - 2 * x[0] * x[1] + 4 * x[0] + 3 * x[1];
end;
```

函数求解：

```tsl
x0 := array(1, 1); // 初始值;
return ret := NonLP_Rosenbrock("obj", x0, 0.2);
```

参考NonLP_Fminsearch NonLP_Nelder NonLP_Hooke_Jeeves

###### QuadLagR

用途：优化相关函数。
参数：

返回：处理后的结果值。

范例

Find x that minimize

f(x) = 2*x1^2+x2^2+x1*x2-x1-x2

subject to

x1 + x2 = 1

TSL代码：

```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参考Prog_Q Quadprog QuadTrackRoute

###### OZProg

用途：优化相关函数。
参数：

返回：处理后的结果值。

范例

Find x that Maximum

f(x) =3x1-2x2+5x3

subject to

x1+2x2-x3≤ 2

x1 + 4x2+x3≤ 4

x1 + x2≤ 3

4x1 +x3≤ 6

x1,x2,x3=0或1

TSL代码：

```tsl
f := array(-3, 2, -5);
A := array((1, 2, -1), (1, 4, 1), (1, 1, 0), (4, 0, 1));
B := array(2, 4, 3, 6);
return OZProg(f, A, B);
// 结果：x1=1,x2=0,x3=1,f(x)=-8
```

参考Prog_L LinearProgramming IntLinProg

###### 有约束优化算法

####### 内容

- SUMT_Method

####### SUMT_Method

算法

(1)获得N=数组X0的长度,r=1,c=10,epsi=0.0001，STARTINGStep = 1.28，LEASTStep =
0.005；

(2)从nI=0到N-1进行循环，将数组D0对应位置数值取值为STARTINGStep，Dmi对应位置数值取值为LEASTStep；

(3)iSum = 0，xN = X0；

(4)将xN赋值给X，调用Hooke_Jeeves_Method函数获得最优解xN，iSum=iSum +
CallBackNum;

(5)err = 0，从nI=0到N-1进行循环，err = err + (X[nI] - xN[nI]) \* (X[nI] -
xN[nI])，若err>epsi，r = r / c，否则结束；返回xN；

###### 无约束优化算法

####### 内容

- Hooke_Jeeves_Method

####### Hooke_Jeeves_Method

算法

(1)N=数组X0的长度，X0的值赋值给X，X的值赋值给Y，将D0赋值给Dt，采用字符串的方式调用TZZHCallBack函数得到函数初始值F0,并赋值给Fy；

(2)把Y的值赋值给X，Fy赋值给Fs；

# (3)从nI=0到N-1进行循环，将X和Dt对应位置数据相加得到新的数组X，调用TZZHCallBack函数得到函数值Fx；若Fx<Fs或|Fx-Fs|<0.00001\*|Fs|，Xs=X，Fs

Fx；若不满足条件，将X对应位置的数据和Dt对应位置的数据的2倍相减得到新的数组X，调用TZZHCallBack函数得到函数值Fx，若Fx<Fs或|Fx-Fs|<0.00001\*|Fs|，Xs=X，Fs
= Fx，否则，将X和Dt对应位置数据相加得到新的数组X；

(4)若第(3)步最终得到的Fs
<Fy，从nI=0到N-1进行循环，将Xs对应位置的数据的2倍减X0对应位置的数据得到新的数组Y，调用TZZHCallBack函数得到函数值Fy，将Xs赋值给X0，如果Fy<Fs，将Xs赋值给Y，Fs赋值给Fy；

(5)当第(4)中的开始条件Fs
<Fy不满足时，从nI=0到N-1进行循环，将Dt对应位置的数据乘0.5得到新的数组Dt，DtSum的初始值为0，若Dt对应位置的数据小于DMin对应位置的数据，DtSum加1；

(6)以上(2)-(5)直到DtSum=N为止，返回Y；

###### 测试

####### 内容

- H_J_Method_Pgm
- Sumt_Method\_\_Pgm
- Sumt_Method_CallBack
- 中间函数

####### H_J_Method_Pgm

用途：优化相关函数。
参数：

返回：处理后的结果值。

算法

运用H-J法求解无约束最优化问题范例

```tsl
CallBack := 'H_J_CallBack';
return H_J_Method_Pgm(CallBack);
// 结果：
```

####### Sumt_Method\_\_Pgm

算法

运用SUMT法求解最优化问题范例

```tsl
return Sumt_Method__Pgm();
// 结果：
```

####### Sumt_Method_CallBack

用途：进行数值统计计算。
参数：

返回：处理后的结果值。

算法

设置X对应下标为0的值为X1, X对应下标为1的值为X2，fS1 =0，fS2 =0；

设置函数Fx=(X1 - 3)^2 + (X2 - 2)^2，g=6-X1-X2；

若g<0，fS1 =Ln(-g)，否则fS2 = g^2；Gx = - r \* fS1 + fS2 / r；

返回Fx + Gx范例

```tsl
x := array(1.00, 2.00); // 设置一维数字数组
return Sumt_Method_CallBack(x, 1);
// 结果：13
```

####### 中间函数

######## 内容

- H_J_CallBack

######## H_J_CallBack

算法

(1)设置X对应下标为0的值为X1, X对应下标为1的值为X2；

(2)设置函数Fx=X1 _ X1 + 2 _ X2 _ X2 - 4 _ X1 - 2 _ X1 _ X2；

(3)返回函数Fx的值范例

```tsl
x := array(1.00, 2.00); // 设置一维数字数组
return H_J_CallBack(x, 0);
// 结果：1
```

###### QuadTrackRoute

用途：优化相关函数。
参数：

返回：处理后的结果值。

范例

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代码：

```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参考Prog_Q Quadprog
QuadLagR

###### IntLinProg

用途：优化相关函数。
参数：

返回：处理后的结果值。

范例

Find x that Maximum

f(x) =40x1+90x2

subject to

9x1+7x2≤ 56

7x1 + 20x2≤ 70

0 ≤ x1, 0 ≤ x2

x1,x2整数

TSL代码：

```tsl
f := array(-40, -90);
A := array((9, 7), (7, 20));
B := array(56, 70);
Aeq := array();
Beq := array();
IntPar := array();
return IntLinProg(f, A, B, Aeq, Beq, Intpar);
// 结果：x1=4,x2=2,f(x)=-340
```

参考Prog_L LinearProgramming OZProg

##### 小波分析

###### 内容

- Wavedec
- wrcoef
- wavelet

###### Wavedec

用途：对序列进行小波分解，返回系数向量与长度向量。
参数：data 为输入序列；level 为分解层数；wname 为小波名称。

返回：`wave[0]` 为分解向量 C，`wave[1]` 为记录向量 L。

范例

```tsl
SetSysParam(PN_Stock(), "SH000300");
SetSysParam(pn_date(), inttodate(20120731));
close_300 := nday(800, "时间", DateTimeToStr(sp_time(1)), "收盘价", close());
close_3 := close_300[:, "收盘价"];
return wave := Wavedec(close_3, 3, "db3");
```

参考 wrcoef, wavelet

###### wrcoef

用途：基于 Wavedec 的结果重构近似或细节信号。
参数：mode 指定近似或细节；c 为分解系数；l 为长度向量；wname 为小波名称；level 为层数。
返回：重构后的序列。

参数：

范例

```tsl
SetSysParam(PN_Stock(), "SH000300");
SetSysParam(pn_date(), inttodate(20120731));
close_300 := nday(800, "时间", DateTimeToStr(sp_time(1)), "收盘价", close());
close_3 := close_300[:, "收盘价"];
wave := Wavedec(close_3, 3, "db3");
c := wave[0];
l := wave[1];
return wrcoef('a', c, l, "db3", 3); // 去除前 3 层高频谐波
// return wrcoef('d', c, l, "db3", 3); // 第 3 次分解得到的高频
```

参考 Wavedec, wavelet

###### wavelet

用途：对序列进行小波变换/去噪，常与 Wavedec、wrcoef 配合使用。
参数：data 为输入序列；wname 为小波名称；n 为层数；options 为去噪选项。
返回：处理后的序列。

范例

```tsl
s := array(2484.83, 2479.05, 2482.34, 2437.79, 2447.75, 2512.96, 2443.06, 2433.16);
n := 2;
wname := "db14";
options := array('brief': 1, 'sigma': 0, 'which': 1, 'alpha': 2, "thr": 0, 'sorh': 's');
return s | wavelet(s, wname, n, options);
```

参考 Wavedec, wrcoef

##### 财务函数

注意：PaymentTime为0表示期初，1表示期末

###### 内容

- DoubleDecliningBalance
- FutureValue
- InterestPayment
- InterestRate
- InternalRateOfReturn
- NumberOfPeriods
- NetPresentValue
- Payment
- PeriodPayment
- PresentValue
- SLNDepreciation
- SYDDepreciation

###### DoubleDecliningBalance

用途：财务函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
Cost := 100;
Salvage := 32;
life := 3;
Period := 2;
return DoubleDecliningBalance(COST, Salvage, life, Period);
```

1.3333参考简单函数对数组支持 FutureValue InterestPayment InterestRate
InternalRateOfReturn NumberOfPeriods NetPresentValue Payment PeriodPayment
PresentValue SLNDepreciation SYDDepreciation

###### FutureValue

用途：财务函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
Rate := 0.05;
Nperiods := 5;
Payment := 100;
PresentValue := -10000;
PaymentTime := 1;
return FutureValue(Rate, Nperiods, Payment, PresentValue, PaymentTime);
```

结果：5.3253参考简单函数对数组支持 DoubleDecliningBalance InterestPayment
InterestRate InternalRateOfReturn NumberOfPeriods NetPresentValue Payment
PeriodPayment PresentValue SLNDepreciation SYDDepreciation

###### InterestPayment

用途：财务函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
Rate := 0.1;
Period := 5;
Nperiods := 12;
PresentValue := 120;
FutureValue := 500;
PaymentTime := 0;
return InterestPayment(Rate, Period, Nperiods, PresentValue, FutureValue, PaymentTime);
```

结果：1.456参考简单函数对数组支持 DoubleDecliningBalance FutureValue
InterestRate InternalRateOfReturn NumberOfPeriods NetPresentValue Payment
PeriodPayment PresentValue SLNDepreciation SYDDepreciation

###### InterestRate

用途：财务函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
NPeriod := 5;
Payment := -100;
PresentValue := 1000000;
FutureValue := 100;
PaymentTime := 0;
return InterestRate(NPeriod, Payment, PresentValue, FutureValue, PaymentTime);
```

结果：-0.8972参考简单函数对数组支持 DoubleDecliningBalance FutureValue
InterestPayment InternalRateOfReturn NumberOfPeriods NetPresentValue Payment
PeriodPayment PresentValue SLNDepreciation SYDDepreciation

###### InternalRateOfReturn

用途：财务函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
Guess := 100;
data := array(10, 20);
return InternalRateOfReturn(Guess, Data);
```

结果：-1参考简单函数对数组支持 DoubleDecliningBalance FutureValue
InterestPayment InterestRate NumberOfPeriods NetPresentValue Payment
PeriodPayment PresentValue SLNDepreciation SYDDepreciation

###### NumberOfPeriods

用途：财务函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
Rate := 0.1;
Payment := 100;
PresentValue := 101;
FutureValue := -105;
PaymentTime := 0;
return NumberOfPeriods(Rate, Payment, PresentValue, FutureValue, PaymentTime);
```

结果：0.038参考简单函数对数组支持 DoubleDecliningBalance FutureValue
InterestPayment InterestRate InternalRateOfReturn NetPresentValue Payment
PeriodPayment PresentValue SLNDepreciation SYDDepreciation

###### NetPresentValue

用途：财务函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
Rate := 0.1;
CashFlows := array(100, 1000);
PaymentTime := 0;
return NetPresentValue(Rate, CashFlows, PaymentTime);
```

结果：917.3554参考简单函数对数组支持 DoubleDecliningBalance FutureValue
InterestPayment InterestRate InternalRateOfReturn NumberOfPeriods Payment
PeriodPayment PresentValue SLNDepreciation SYDDepreciation

###### Payment

用途：财务函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
Rate := 0.1;
Nperiods := 100;
PresentValue := 0;
FutureValue := 10000;
PaymentTime := 0;
return Payment(Rate, Nperiods, PresentValue, FutureValue, PaymentTime);
```

结果：-0.0726参考简单函数对数组支持 DoubleDecliningBalance FutureValue
InterestPayment InterestRate InternalRateOfReturn NumberOfPeriods
NetPresentValue PeriodPayment PresentValue SLNDepreciation SYDDepreciation

###### PeriodPayment

用途：财务函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
Rate := 0.1;
Period := 10;
Nperiods := 30;
PresentValue := 0;
FutureValue := 10000;
PaymentTime := 0;
return PeriodPayment(Rate, Period, Nperiods, PresentValue, FutureValue, PaymentTime);
```

结果：-143.3455参考简单函数对数组支持 DoubleDecliningBalance FutureValue
InterestPayment InterestRate InternalRateOfReturn NumberOfPeriods
NetPresentValue Payment PresentValue SLNDepreciation SYDDepreciation

###### PresentValue

用途：财务函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
Rate := 0.1;
Nperiods := 30;
FutureValue := 10000;
PaymentTime := 0;
return PresentValue(Rate, Nperiods, Payment, FutureValue, PaymentTime);
```

结果：-573.0855参考简单函数对数组支持 DoubleDecliningBalance FutureValue
InterestPayment InterestRate InternalRateOfReturn NumberOfPeriods
NetPresentValue Payment PeriodPayment SLNDepreciation SYDDepreciation

###### SLNDepreciation

用途：财务函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return SLNDepreciation(20000, 2000, 5);
// 结果：3600
// 第一年应提折旧额=(20000-2000)/5=3600
// 第二年应提折旧额=(20000-2000)/5=3600
// 第三年应提折旧额=(20000-2000)/5=3600
// 第四年应提折旧额=(20000-2000)/5=3600
// 第五年应提折旧额=(20000-2000)/5=3600
```

结果：1800参考简单函数对数组支持 DoubleDecliningBalance FutureValue
InterestPayment InterestRate InternalRateOfReturn NumberOfPeriods
NetPresentValue Payment PeriodPayment PresentValue SYDDepreciation

###### SYDDepreciation

用途：财务函数相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return SYDDepreciation(20000, 2000, 5, 2);
// 结果：4800
// 第一年应提折旧额=(20000-2000)*5/((1+5)*5/2)=6000
// 第二年应提折旧额=(20000-2000) *4/((1+5)*5/2)=4800
// 第三年应提折旧额=(20000-2000) *3/((1+5)*5/2)=3600
// 第四年应提折旧额=(20000-2000) *2/((1+5)*5/2)=2400
// 第五年应提折旧额=(20000-2000) *1/((1+5)*5/2)=1200
```

结果：2400参考简单函数对数组支持 DoubleDecliningBalance FutureValue
InterestPayment InterestRate InternalRateOfReturn NumberOfPeriods
NetPresentValue Payment PeriodPayment PresentValue SLNDepreciation

##### 增长率与比率

###### 内容

- AccumulativeYTMtoYTM
- YTMToAccumulativeYTM
- RatioValue
- OutPutValueByUnit
- OutPutLnGrowRatio
- OutPutGrowValue
- OutPutGrowValue2
- OutPutGrowRatio
- OutPutGrowRatio2
- MultyValue
- OutPutGrowValue3
- OutPutGrowRatio3
- RatioValue_Math

###### AccumulativeYTMtoYTM

用途：增长率与比率相关函数。
参数：

返回：处理后的结果值。

算法

日收益率=(当天复合收益率+1)/(1+前天复合收益率)-1;范例

```tsl
// 源数据单位为1,设dw=2,同时返回复合收益率和转换后的日收益率
t1 := array(('日期':20180801T, '复合收益率':0.1),
('日期':20180802T, '复合收益率':0.4),
('日期':20180803T, '复合收益率':0.7));
r1 := AccumulativeYTMtoYTM(t1, '复合收益率', 2);
// 源数据单位为%,设dw=3,同时返回复合收益率和转换后的日收益率
t2 := array(('日期':20180801T, '复合收益率(%)':10),
('日期':20180802T, '复合收益率(%)':40),
('日期':20180803T, '复合收益率(%)':70));
r2 := AccumulativeYTMtoYTM(t2, '复合收益率(%)', 3);
return r1|r2;
```

结果返回：

###### YTMToAccumulativeYTM

用途：增长率与比率相关函数。
参数：

返回：处理后的结果值。

算法复合收益率=(当天日收益率+1)\*(1+昨日复合收益率)-1;范例

范例01：

```tsl
// 源数据单位为1,dw=2,同时返回日收益率和转换后的复合收益率
t1 := array(('日期':20180801T, '日收益率':0.3),
('日期':20180802T, '日收益率':0.6),
('日期':20180803T, '日收益率':0.9));
r1 := YTMToAccumulativeYTM(t1, '日收益率', 2, 0);
// 源数据单位为%,dw=3,同时返回日收益率和转换后的复合收益率
t2 := array(('日期':20180801T, '日收益率(%)':30),
('日期':20180802T, '日收益率(%)':60),
('日期':20180803T, '日收益率(%)':90));
r2 := YTMToAccumulativeYTM(t2, '日收益率(%)', 3, 0);
return r1|r2;
```

范例2：

```tsl
// 计算基金OF000009易方达天天理财A的累计收益率(%)
SetSysParam(PN_Stock(), "OF000009");
t := array(('日期':20150104T, '每万份基金单位收益':4.3769),
('日期':20150105T, '每万份基金单位收益':1.2507),
('日期':20150106T, '每万份基金单位收益':1.4671));
r := YTMToAccumulativeYTM(t, '每万份基金单位收益', 5, 0);
return r;
```

###### RatioValue

用途：增长率与比率相关函数。
参数：

返回：处理后的结果值。

算法

若v1与v2都是实数，且v2<>0，则v=v1/v2；否则，v=0；

若v1<0，且v2<0，则v=-v；

返回v。范例

```tsl
// 返回-1与-2的比率。
return RatioValue(-1, -2);
// 结果：-0.5
```

###### OutPutValueByUnit

用途：增长率与比率相关函数。
参数：

返回：处理后的结果值。

算法

若DataType\_="Real"，则v=Data/DataUnit；

若DataType\_<>"Real"，则v=Data；

返回v。范例

```tsl
// 返回1234.5以10为单位转换后的结果
return OutPutValueByUnit(1234.5, 'Real', 10);
// 结果：123.45
```

###### OutPutLnGrowRatio

用途：增长率与比率相关函数。
参数：

返回：处理后的结果值。

算法若v1>0且v2>0，返回（v1的自然对数 - v2的自然对数）\*100；

否则，返回0。范例

```tsl
// 取3与4的对数增长率
return OutPutLnGrowRatio(3, 4);
// 结果：-28.77
```

###### OutPutGrowValue

用途：增长率与比率相关函数。
参数：

返回：处理后的结果值。

算法若v1与v2都为实数，返回v1-v2；

否则，返回0。范例

```tsl
// 返回13与14的差值
return OutPutGrowValue(13, 14);
// 结果：-1
```

###### OutPutGrowValue2

用途：增长率与比率相关函数。
参数：

返回：处理后的结果值。

算法若v1与v2都为不等于0的实数，返回v1-v2；

否则，返回0。范例

```tsl
// 返回13与14差值
return OutPutGrowValue2(13, 14);
// 结果：-1
```

###### OutPutGrowRatio

用途：增长率与比率相关函数。
参数：

返回：处理后的结果值。

算法若v1与v2都为不等于0的实数，返回（v1-v2）/v2的绝对值\*100；

否则，返回0。范例

```tsl
// 返回13到14的增长率(%)
return OutPutGrowRatio(14, 13);
// 结果：7.69
```

###### OutPutGrowRatio2

用途：增长率与比率相关函数。
参数：

返回：处理后的结果值。

算法

若v1与v2都为不等于0的实数，返回（v1-v2）/v2的绝对值\*100；

若v1与v2其中有一个为0，返回"-"；

否则，返回0。范例

```tsl
// 返回13到14的增长率(%)
return OutPutGrowRatio2(14, 13);
// 结果：7.69
```

###### MultyValue

用途：增长率与比率相关函数。
参数：

返回：处理后的结果值。

算法

若v1与v2都是实数，则v=v1\*v2；否则，v=0；

若v1<0，且v2<0，则v=-v；

返回v。范例

```tsl
// 返回取-3与-5的乘积。
return MultyValue(-3, -5);
// 结果：-15
```

###### OutPutGrowValue3

用途：增长率与比率相关函数。
参数：

返回：处理后的结果值。

算法若v1与v2都为大于等于0的实数，返回v1-v2；

否则，返回空字符串。范例

```tsl
// 返回13与14的差值
return OutPutGrowValue3(13, 14);
// 结果：-1
```

###### OutPutGrowRatio3

用途：增长率与比率相关函数。
参数：

返回：处理后的结果值。

算法若v1与v2都为实数，且v2>0，返回(v1-v2)/v2的绝对值\*100；

否则，返回空字符串。范例

```tsl
// 返回14到13的增长率(%)
return OutPutGrowRatio3(14, 13);
// 结果：7.69
```

###### RatioValue_Math

用途：增长率与比率相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
return RatioValue_Math(0, 0);
// 结果：0
```

##### 概率分布

###### 内容

- 线性变换

###### 线性变换

####### 内容

- Norm_LinearTransform

####### Norm_LinearTransform

用途：概率分布相关函数。
参数：

返回：处理后的结果值。

算法假设随机变量X服从正态分布，其线性组合Y依然服从正态分布

（1）X、Y为单个变量，X~N(μ,σ2)，μ与σ2为实数，Y=a+bX，则

EY=a+bμ

DY=b2σ2

（2）X、Y为多元变量，假设

X=X1,X2,?,XnT~Nμ,Σ , μ=μ1,μ2,?,μnT, Σ=var(X1)cov(X1,Xn)cov(X1,Xn)var(Xn)

Y=Y1Ym=a1+b11*X1+b12*X2+?+b1n*Xnam+bm1*X1+bm2*X2+?+bmn*Xn=A+B\*X

其中，A=a1am， B=b11b1nbm1bmn，则

EY=A+Bμ

DY=BΣBT范例

范例01：

```tsl
A := 1.5;
B := 2;
Mu := 1;
Sigma := 10;
return Norm_LinearTransform(Mu, Sigma, A, B);
```

范例2：

```tsl
A := array(1.5, 1.5, 1.5);
B := array((1, 1, 1), (2, 2, 2), (3, 3, 3));
Mu := array(1, 2, 3);
Mu := `Mu;
sigma := array((0.5, 3, 1), (0.2, 1, 0.4), (3, 0.1, 2));
return Norm_LinearTransform(Mu, Sigma, A, B);
```

array(

"变换后均值":((7.5),(13.5),(19.5)),

"变换后方差":

((11.2,22.4,33.6),(22.4,44.8,67.2),(33.6,67.2,100.8)));

##### 信号处理

###### 内容

- filter_hp

###### filter_hp

用途：信号处理相关函数。
参数：

返回：处理后的结果值。

范例

```tsl
y := MarketTradeDayQk(20220101T, 20220131T);
return filter_hp(y, 10);
```