251 KiB

Raw Blame History

数学函数

内容

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

数值计算

内容

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

数值微积分

####### 内容

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

其中fun1函数：

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

参考ig_Trapezoid_1 ig_Trapezoid_2 ig_Simpson_1 ig_Romberg ig_Gauss ig_Chebyshev ig_Simpson_2

####### ig_Trapezoid_1

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

范例

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

参考sf_CosX sf_eX

####### sf_CosX

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

返回：处理后的结果值。

范例

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

参考sf_SinX sf_eX

####### sf_eX

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

返回：处理后的结果值。

范例

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

参考sf_SinX sf_CosX

####### sf_EllipseX_1

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

返回：处理后的结果值。

范例

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

参考sf_EllipseX_2

####### sf_EllipseX_2

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

返回：处理后的结果值。

范例

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

参考sf_EllipseX_1

####### Conv

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

线性方程组的求解

####### 内容

se_Gauss
se_Gauss_Jordan
se_Ldl
se_Cholesky
se_Gauss_Seidel

####### se_Gauss

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

范例

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

X := array(0, 0.01) -  > 1;
Y := X ^ 2 - X;
Xi := array(0.005, 0.01) -  > 1;
Yi := interp(X, Y, Xi, 'spline');
return Yi;
// 结果：6

1、"nearest"

x_ := array(5, 1, 19, 8);
y_ := array(2, 3, 1, 7);
xi := array(4, 12);
return interp(x_, y_, xi, "nearest");
// 返回： array(2,7)

2、" linear" 分段线性插值

x_ := array(5, 1, 19, 8);
y_ := array(2, 3, 1, 7);
xi := array(4, 12);
return interp(x_, y_, xi, "linear");
// 返回： array(2.25,4.8182)

3、"spline" 三次样条插值

x_ := array(5, 1, 19, 8);
y_ := array(2, 3, 1, 7);
xi := array(4, 12);
return interp(x_, y_, xi, "spline");
// 返回： array(1.1407,13.9444)

4、"pchip" 分段三次hermite插值

x_ := array(5, 1, 19, 8);
y_ := array(2, 3, 1, 7);
xi := array(4, 12);
return interp(x_, y_, xi, "pchip");
// 返回： array(2.0156,6.7115)

####### 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开始。范例

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

范例

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

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

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

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

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：整数。

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：整数。

范例

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：

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

范例02：

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

范例03：

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

####### mtva Cholesky

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

参考mtva 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。范例

// 计算矩阵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

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

返回：整数。

范例

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

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

返回：处理后的结果值。

范例

// 每列之和为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'));

其显示如下：

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

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

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

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

####### Det

范例

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

####### isSymmetry

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

返回：布尔值。

范例

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

####### Orth

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

返回：处理后的结果值。

范例

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

####### roots

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

返回：处理后的结果值。

范例

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

####### Eigen

范例

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

####### pinv

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

返回：处理后的结果值。

范例

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

####### norm2

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

返回：处理后的结果值。

范例

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

####### Cond

范例

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

####### diag

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

返回：处理后的结果值。

范例

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

####### isDefinite

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

返回：布尔值。

范例

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

数组扩展

####### 内容

####### Any

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

返回：处理后的结果值。

范例

范例一：

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

范例二：

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

结果

范例三：

// 判断二维数组的行
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’列中。

范例四：

// 判断多维数组的行
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

范例五：

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

结果

####### ALL

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

返回：处理后的结果值。

范例

范例一：

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

范例二：

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

结果

范例三：

// 判断二维数组的行
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判断为假。

范例四：

// 判断多维数组的行
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

范例五：

// 判断多维数组的列
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的阶乘

return perms(10);

返回结果：3628800

范例02：排列组合

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'))中任意两个数据的排列组合

v := array(('A', 'B'), ('C', 'D'));
return perms(v, 2);

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

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

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

返回：处理后的结果值。

范例

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：

// 计算一组序列的最大涨幅
data := array(3, 1, 7, 5, 6, 3);
return MaxDrawDown(data, 1);

1 2 6 6

结果说明：入点为data[1]，出点为data[2]，两者差为6，最大涨幅比例差为6

范例02：

// ------计算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：

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

####### MinRecoveryTime

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

返回：日期或时间值。

范例

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

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

返回结果：6

####### Betainc

范例

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

####### PercentileOfScore

范例

去除随机数组的极值

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

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

返回：处理后的结果值。

范例

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

####### Percentage

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

返回：处理后的结果值。

范例

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

常用数学函数

内容

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

Pi

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

范例

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

Odd

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

返回：处理后的结果值。

范例

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

参考简单函数对数组支持

Abs

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

返回：处理后的结果值。

范例

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

参考简单函数对数组支持

Sqr

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

返回：处理后的结果值。

范例

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

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

Sqrt

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

返回：处理后的结果值。

范例

求实数的平方根

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

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

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

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

DivMod

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

返回：处理后的结果值。

范例

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

参考简单函数对数组支持

Frexp

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

返回：处理后的结果值。

范例

// 将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

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

返回：处理后的结果值。

范例

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

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

Poly

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

返回：处理后的结果值。

范例

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

正常的二维数组的处理

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

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

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

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

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

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

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

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

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是一个一维数组:

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

范例

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

参考_Or _Not _Xor _Shl _Shr _Rol _Ror

_Or

范例

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

参考_And _Not _Xor _Shl _Shr _Rol _Ror

_Not

范例

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

参考_And _Or _Xor _Shl _Shr _Rol _Ror

_Xor

范例

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

参考_And _Or _Not _Shl _Shr _Rol _Ror

_Shl

范例

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

参考_And _Or _Not _Xor _Shr _Rol _Ror

_Shr

范例

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

参考_And _Or _Not _Xor _Shl _Rol _Ror

_Rol

范例

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

参考_And _Or _Not _Xor _Shl _Shr _Ror

_Ror

范例

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

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

返回：处理后的结果值。

范例

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

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

Cos

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

返回：处理后的结果值。

范例

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

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

SinCos

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

返回：处理后的结果值。

范例

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

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

Tan

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

返回：处理后的结果值。

范例

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

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

Cot

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

返回：处理后的结果值。

范例

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

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

CoTan

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

返回：处理后的结果值。

范例

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

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

Sec

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

返回：处理后的结果值。

范例

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

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

Csc

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

返回：处理后的结果值。

范例

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

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

Secant

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

返回：处理后的结果值。

范例

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

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

Cosecant

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

返回：处理后的结果值。

范例

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

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

ArcSin

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

返回：处理后的结果值。

范例

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

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

ArcCos

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

返回：处理后的结果值。

范例

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

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

ArcTan

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

返回：处理后的结果值。

范例

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

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

ArcTan2

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

返回：处理后的结果值。

范例

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

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

ArcCot

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

返回：处理后的结果值。

范例

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

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

ArcSec

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

返回：处理后的结果值。

范例

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

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

ArcCsc

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

返回：处理后的结果值。

范例

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

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

Hypot

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

返回：处理后的结果值。

范例

// 求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

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

返回：处理后的结果值。

范例

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

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

RadToGrad

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

返回：处理后的结果值。

范例

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

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

RadToCycle

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

返回：处理后的结果值。

范例

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

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

DegToRad

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

返回：处理后的结果值。

范例

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

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

DegToGrad

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

返回：处理后的结果值。

范例

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

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

DegToCycle

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

返回：处理后的结果值。

范例

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

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

GradToRad

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

返回：处理后的结果值。

范例

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

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

GradToDeg

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

返回：处理后的结果值。

范例

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

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

GradToCycle

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

返回：处理后的结果值。

范例

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

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

CycleToRad

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

返回：处理后的结果值。

范例

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

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

CycleToDeg

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

返回：处理后的结果值。

范例

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

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

CycleToGrad

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

返回：处理后的结果值。

范例

// 求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

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

返回：处理后的结果值。

范例

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

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

Cosh

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

返回：处理后的结果值。

范例

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

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

Tanh

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

返回：处理后的结果值。

范例

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

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

CotH

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

返回：处理后的结果值。

范例

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

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

SecH

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

返回：处理后的结果值。

范例

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

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

CscH

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

返回：处理后的结果值。

范例

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

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

ArcCosh

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

返回：处理后的结果值。

范例

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

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

ArcSinh

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

返回：处理后的结果值。

范例

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

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

ArcTanh

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

返回：处理后的结果值。

范例

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

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

ArcCotH

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

返回：处理后的结果值。

范例

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

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

ArcSecH

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

返回：处理后的结果值。

范例

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

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

ArcCscH

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

返回：处理后的结果值。

范例

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

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

指数对数函数

内容

Ln
LnXP1
Log10
Log2
LogN
Exp
IntPower
Power

Ln

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

返回：处理后的结果值。

范例

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

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

LnXP1

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

返回：处理后的结果值。

范例

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

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

Log10

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

返回：处理后的结果值。

范例

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

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

Log2

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

返回：处理后的结果值。

范例

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

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

LogN

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

返回：处理后的结果值。

范例

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

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

Exp

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

返回：处理后的结果值。

范例

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

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

IntPower

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

返回：处理后的结果值。

范例

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

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

Power

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

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

Ceil

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

返回：处理后的结果值。

范例

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

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

Ceil32

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

返回：处理后的结果值。

范例

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

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

Ceil64

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

返回：处理后的结果值。

范例

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

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

Floor

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

返回：处理后的结果值。

范例

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

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

Floor32

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

返回：处理后的结果值。

范例

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

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

Floor64

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

返回：处理后的结果值。

范例

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

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

Trunc

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

返回：处理后的结果值。

范例

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

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

Trunc32

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

返回：处理后的结果值。

范例

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

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

Trunc64

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

返回：处理后的结果值。

范例

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

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

Frac

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

返回：处理后的结果值。

范例

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

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

Round

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

返回：处理后的结果值。

范例

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

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

Round32

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

返回：处理后的结果值。

范例

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

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

Round64

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

返回：处理后的结果值。

范例

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

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

SimpleRound

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

返回：处理后的结果值。

范例

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

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

SimpleRound32

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

返回：处理后的结果值。

范例

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

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

SimpleRound64

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

返回：处理后的结果值。

范例

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

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

RoundTo

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

返回：处理后的结果值。

范例

范例01：整数四舍五入

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

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

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

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

SimpleRoundTo

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

返回：处理后的结果值。

范例

范例01：

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

范例02：

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

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

比较判断函数

内容

IsNan
IsInfinite
Sign
IsZero
Min
Max
CompareValue
SameValue
RandomRange
InRange
EnsureRange

IsNan

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

返回：布尔值。

范例

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

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

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

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

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

IsInfinite

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

返回：布尔值。

范例

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

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

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

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

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

Sign

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

返回：处理后的结果值。

范例

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

参考简单函数对数组支持

IsZero

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

返回：布尔值。

范例

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

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

Min

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

返回：处理后的结果值。

范例

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

比较两个数组

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

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

Max

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

返回：处理后的结果值。

范例

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

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

CompareValue

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

返回：处理后的结果值。

范例

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

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

SameValue

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

返回：处理后的结果值。

范例

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

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

RandomRange

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

返回：处理后的结果值。

范例

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

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

InRange

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

返回：处理后的结果值。

范例

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

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

EnsureRange

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

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

SumOfSquares

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

返回：处理后的结果值。

范例

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

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

StdDev

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

返回：处理后的结果值。

范例

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

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

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

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：一维数组求平均值

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

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

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：一维数组求和

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

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

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：一维数组求最大值

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

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

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：一维数组求最小值

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

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

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：一维数组求平方和的平方根

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

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

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

参考统计函数功能拓展 SumOfSquares

SumsAndSquares

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

返回：处理后的结果值。

范例

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

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

MaxIntValue

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

返回：处理后的结果值。

范例

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

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

SumInt

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

返回：处理后的结果值。

范例

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

参考统计函数功能拓展 Sum

Harmean

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

返回：处理后的结果值。

范例

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

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

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

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：一维数组求样本方差

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

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

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

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

MeanAndStdDev

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

参考统计函数功能拓展 StdDev

Skewness

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

返回：处理后的结果值。

范例

范例01：一维数组求偏度

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

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

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

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

TotalVariance

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

返回：处理后的结果值。

范例

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

参考统计函数功能拓展 Variance

Product

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

返回：处理后的结果值。

范例

一维数组计算累乘值

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

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

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

参考统计函数功能拓展 Sum

PopnStdDev

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

返回：处理后的结果值。

范例

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

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

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

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

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

kurtosis2

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

返回：处理后的结果值。

范例

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

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

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

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

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

Median

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

返回：处理后的结果值。

范例

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

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

skewness2

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

返回：处理后的结果值。

范例

范例01：一维数组求偏度

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

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

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函数为例：

正常数据的处理:

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

含字符串异常数据

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和字符串元素

空数组时候的默认输出：

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

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

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

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

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

N是一个整数的时候

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

N是一个一维数组的时候

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

Kurtosis

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

返回：处理后的结果值。

范例

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

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

结果：-1.64

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

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

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

Mode

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

返回：处理后的结果值。

范例

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

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

RandG

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

返回：处理后的结果值。

范例

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

参考简单函数对数组支持

Geomean

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

返回：处理后的结果值。

范例

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

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

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

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：一维数组求总体方差

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

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

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

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

MomentSkewKurtosis

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

参考统计函数功能拓展 StdDev

randomfrom

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

返回：处理后的结果值。

范例

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

参考统计函数功能拓展

次序统计量

内容

Large
Small
Percentile
Percentrank
Quartile
Rank
Trimmean
Frequency

Large

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

返回：处理后的结果值。

范例

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

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

Small

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

返回：处理后的结果值。

范例

// 返回数组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：序列百分点的值

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

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

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：二维数组指定列指定步长的百分点的值

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

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

返回：处理后的结果值。

范例

// 返回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

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

返回：处理后的结果值。

范例

// 返回数组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

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

返回：处理后的结果值。

范例

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

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

Trimmean

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

返回：处理后的结果值。

范例

// 去除个数=总个数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

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

返回：处理后的结果值。

范例

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日线收盘与大盘的协方差

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日线收盘与大盘价格的相关系数

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日线收盘与大盘收盘价格的回归斜率

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日线收盘与大盘收盘价的相回归截距

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日线收盘与大盘的乘积矩相关系数平方

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日线收盘与大盘的相对标准偏差

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日线收盘与大盘收盘价格的回归斜率和截距

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.=σ/μ，其中σ为标准差，μ为均值。范例

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

Skew

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

返回：处理后的结果值。

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

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

SelfStddev

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

返回：处理后的结果值。

算法

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

对t2求标准差范例

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

RegressionChannel

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

返回：处理后的结果值。

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

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为标准差。范例

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

MeanAndPopnStdDevWithRate

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

返回：处理后的结果值。

算法

μ=1nRi*Di1nRi

σ=1nRiinRiDi2-(1nRi*Di)21nRi

其中μ为均值，σ为标准差范例

MeanAndPopnStdDevWithRate(array(1, 2, 3), array(1, 1, 1), m, s);
return m;
// 返回：2

BetaAndAlpha

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

返回：处理后的结果值。

范例

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

范例

r := array(-1, 2, -3, 9);
return ExpdMax(r); // array(-1,2,2,9)

######## ExpdMin

范例

r := array(-1, 2, -3, 9);
return ExpdMin (r); // array(-1,-1,-3,-3)

######## ExpdSum

范例

r := array(-1, 2, -3, 9);
return ExpdSum (r); // array(-1,1,-2,7)

######## ExpdProduct

范例

r := array(-1, 2, -3, 9);
return ExpdProduct (r); // array(-1,-2,6,54)

######## ExpdVar

范例

r := array(-1, 2, -3, 9);
return ExpdVar (r, 0); // array(0,2.25,4.22,20.69)

######## ExpdStd

范例

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

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

返回：处理后的结果值。

范例

A := array(5, 6, 8, Nan);
return NanMean(A);
// 结果：6.33

####### NanSum

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

返回：处理后的结果值。

范例

A := array(5, 6, 8, Nan);
return NanSum(A);
// 结果：19

####### NanStd

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

返回：处理后的结果值。

范例

A := array(5, 6, 8, Nan);
return NanStd(A);
// 结果：1.53

####### NanVariance

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

返回：处理后的结果值。

范例

A := array(5, 6, 8, Nan);
return NanVariance(A);
// 结果：2.33

####### NanPopnStd

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

返回：处理后的结果值。

范例

A := array(5, 6, 8, Nan);
return NanPopnStd(A);
// 结果：1.25

####### NanPopnVariance

范例

A := array(5, 6, 8, Nan);
return PopnVariance(A);
// 结果：1.56

####### NanRankArr

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

a := rand(10);
b := rand(10);
return correlpaired(a, b); // array((0.17))

范例02

a := rand(10);
b := rand(10, 2);
return correlpaired(a, b); // array((-0.35,-0.19))

范例03

a := rand(10, 2);
b := rand(10, 4);
return correlpaired(a, b);

范例04

a := `array("A":rand(10));
b := `array("A":rand(10), "B":rand(10));
return correlpaired(a, b); // array((0.2,-0.08))

correlpaired_side

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

return Gammaln(array(1.5, 2.3, 3.4));
// 结果：array(-0.120782237635245,0.15418945495963,1.09232805980274)

Hist

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

返回：处理后的结果值。

范例

A := randnorm(0, 1, 10000);
return Hist(A, 30, center);

结果，一维数字数组

sf_Error

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

返回：处理后的结果值。

范例

sf_Error(0.15, v);
return v;
// 结果：0.168

erfc

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

返回：处理后的结果值。

范例

return erfc(0.15);
// 0.832004028572637

sf_Gamma

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

返回：处理后的结果值。

范例

sf_Gamma(5, v);
return v;
// 结果：24

参考sf_IncompleteGamma

erf

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

返回：处理后的结果值。

范例

return erf(0.15);
// 结果：0.168

erfcinv

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

返回：处理后的结果值。

范例

return erfcinv(0.15);
// 结果：1.01790246483203

sf_Beta

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

返回：处理后的结果值。

范例

sf_Beta(2, 5, v);
return v;
// 结果：0.03333

参考sf_Gamma

sf_IntegerBessel_1

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

a := 5;
x := 7;
sf_IncompleteGamma(a, x, v);
return v;
// 结果：0.82701

参考sf_Gamma

Gamma

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

返回：处理后的结果值。

范例

return Gamma(array(1.5, 2.3, 3.4));
// 结果：array(0.886226925452758,1.16671190519816,2.98120642681033)

erfinv

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

return Randnorm(0, 1, 10, array("a", "b"));

参考分布函数 sf_normpdf sf_normcdf sf_norminv Normfit

sf_F

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

返回：处理后的结果值。

范例

f := 2;
n1 := 3;
n2 := 5;
sf_F(f, n1, n2, v);
return v;
// 结果：0.76738

参考sf_Normal sf_t sf_X2

sf_geopdf

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

返回：处理后的结果值。

范例

x := 1 -  > 10;
return sf_geopdf(x, 0.5);

参考sf_geocdf sf_geoinv Randgeo 分布函数

sf_RealBessel_1

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

x := array(-4, 0.1) -  > 4;
return sf_unidcdf(x, 0, 1);

参考sf_unidpdf sf_unidcdf sf_unidinv Randunid 分布函数

sf_normpdf

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

返回：处理后的结果值。

范例

x := array(-2, 0.1) -  > 2;
return sf_normpdf(x, 0, 1);

参考分布函数 sf_normcdf sf_norminv Randnorm Normfit

sf_geoinv

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

返回：处理后的结果值。

范例

y := array(0.01, 0.01) -  > 0.99;
return sf_geoinv(y, 0.5);

参考sf_geopdf sf_geocdf Randgeo 分布函数

sf_unidpdf

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

返回：处理后的结果值。

范例

x := 1 -  > 10;
return sf_unidpdf(x, 10);

参考sf_unidpdf sf_unidcdf sf_unidinv Randunid 分布函数

sf_IncompleteBeta

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

返回：处理后的结果值。

范例

a := 3;
b := 4;
x := 0.25;
sf_IncompleteBeta(a, b, x, v);
return v;
// 结果：0.16943

参考sf_Beta

sf_normalinv2

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

返回：处理后的结果值。

范例

sf_normalinv2(0.5 , v);
return v; // 返回结果0.

sf_norminv

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

返回：处理后的结果值。

范例

y := array(0.01, 0.01) -  > 0.99;
return sf_norminv(y, 0, 1);

参考分布函数 sf_normpdf sf_normcdf Randnorm Normfit

Randunid

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

返回：处理后的结果值。

范例

return Randunid(10, 10, array("a", "b"));

参考sf_unidpdf sf_unidcdf sf_unidinv 分布函数

sf_Normal

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

返回：处理后的结果值。

范例

x := 0;
a := 0;
d := 1;
sf_Normal(x, a, d, v);
return v;
// 结果：0.5

参考sf_t sf_X2 sf_F

sf_unidinv

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

返回：处理后的结果值。

范例

y := array(0.01, 0.01) -  > 0.99;
return sf_unidinv(y, 10);

参考sf_unidpdf sf_unidcdf sf_unidinv Randunid 分布函数

sf_X2

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

返回：处理后的结果值。

范例

x := 2.5;
n := 10;
sf_X2(x, n, v);
return v;
// 结果：0.00912

参考sf_Normal sf_t sf_F

sf_IntegerBessel_2

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

返回：处理后的结果值。

范例

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

x := array(-4, 0.1) -  > 4;
return sf_normcdf(x, 0, 1);

参考分布函数 sf_normpdf sf_norminv Randnorm Normfit

sf_t

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

返回：处理后的结果值。

范例

t := 2.5;
n := 10;
sf_t(t, n, v);
return v;
// 结果：0.98428

参考sf_Normal sf_X2 sf_F

sf_geocdf

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

返回：处理后的结果值。

范例

x := 1 -  > 10;
return sf_geocdf(x, 0.5);

参考sf_geopdf sf_geoinv Randgeo 分布函数

Randgeo

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

返回：处理后的结果值。

范例

return Randgeo(10, 10, array("a", "b"));

参考sf_geopdf sf_geocdf sf_geoinv 分布函数

sf_normalinv

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

返回：处理后的结果值。

范例

sf_normalinv(0.5, 0, 1, v);
return v; // 返回结果0.

Normfit

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

返回：处理后的结果值。

范例

x := randnorm(0, 1, 10, array("a", "b"));
return Normfit(x, 0.05);

结果：返回mu,sigma的估计以及他们的在alpha的显著性水平下的区间估计

sf_RealBessel_2

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

y := array(0.01, 0.01) -  > 0.99;
return sf_hygeinv(y, 100, 10, 20);

参考sf_hygepdf sf_hygecdf Randhyge 分布函数

poissfit

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

返回：处理后的结果值。

范例

x := randpoiss(1, 100);
return poissfit(x, 0.05);

结果：返回lambda的估计以及他们的在alpha的显著性水平下的区间估计

参考sf_poisspdf sf_poisscdf sf_poissinv Randpoiss 分布函数

sf_binocdf

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

返回：处理后的结果值。

范例

x := 1 -  > 10;
return sf_binocdf(x, 10, 0.5);

参考sf_binopdf sf_binoinv Randbino binofit 分布函数

Randhyge

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

返回：处理后的结果值。

范例

return Randhyge(100, 10, 20, 10, array("a", "b"));

参考sf_hygepdf sf_hygecdf sf_hygeinv 分布函数

sf_poissinv

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

返回：处理后的结果值。

范例

y := array(0.01, 0.01) -  > 0.99;
return sf_poissinv(y, 10);

参考sf_poisspdf sf_poisscdf Randpoiss poissfit 分布函数

sf_poisscdf

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

返回：处理后的结果值。

范例

x := 1 -  > 20;
return sf_poisscdf(x, 10);

参考sf_poisspdf sf_poissinv Randpoiss poissfit 分布函数

sf_nbininv

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

返回：处理后的结果值。

范例

y := array(0.01, 0.01) -  > 0.99;
return sf_nbininv(y, 10, 0.5);

参考sf_nbinpdf sf_nbincdf Randnbin 分布函数

binofit

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

返回：处理后的结果值。

范例

x := randbino(10, 0.5, 1);
return binofit(x, 10, 0.05);

结果：返回p的估计以及在alpha的显著性水平下的区间估计

参考sf_binopdf sf_binocdf sf_binoinv Randbino 分布函数

sf_hygepdf

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

返回：处理后的结果值。

范例

x := 1 -  > 20;
return sf_hygepdf(x, 100, 10, 20);

参考sf_hygecdf sf_hygeinv Randhyge 分布函数

sf_unifcdf

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

返回：处理后的结果值。

范例

x := 1 -  > 10;
return sf_unifcdf(x, 1, 10);

参考sf_unifpdf Randunif uniffit 分布函数

sf_exppdf

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

返回：处理后的结果值。

范例

x := array(0, 0.1) -  > 4.5;
return sf_exppdf(x, 1);

参考sf_expcdf sf_expinv Randexp expfit 分布函数

sf_binoinv

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

返回：处理后的结果值。

范例

y := array(0.01, 0.01) -  > 0.99;
return sf_binoinv(y, 10, 0.5);

参考sf_binopdf sf_binocdf Randbino binofit 分布函数

uniffit

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

返回：处理后的结果值。

范例

x := randunif(1, 10, 100);
return uniffit(x, 0.05);

结果：返回a,b的估计以及他们的在alpha的显著性水平下的区间估计

参考sf_unifpdf sf_unifcdf sf_unifinv Randunif 分布函数

sf_nbinpdf

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

返回：处理后的结果值。

范例

x := 1 -  > 20;
return sf_nbinpdf(x, 10, 0.5);

参考sf_nbincdf sf_nbininv Randnbin 分布函数

Randnbin

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

返回：处理后的结果值。

范例

return Randnbin(10, 0.5, 10, array("a", "b"));

参考sf_nbinpdf sf_nbincdf sf_nbininv 分布函数

Randpoiss

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

返回：处理后的结果值。

范例

return Randpoiss(10, 10, array("a", "b"));

参考sf_poisspdf sf_poisscdf sf_poissinv poissfit 分布函数

sf_hygecdf

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

返回：处理后的结果值。

范例

x := 1 -  > 10;
return sf_hygecdf(x, 100, 10, 20);

参考sf_hygepdf sf_hygeinv Randhyge 分布函数

sf_poisspdf

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

返回：处理后的结果值。

范例

x := 1 -  > 20;
return sf_poisspdf(x, 10);

参考sf_poisscdf sf_poissinv Randpoiss poissfit 分布函数

Randbino

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

返回：处理后的结果值。

范例

return Randbino(10, 0.5, 10, array("a", "b"));

参考sf_binopdf sf_binocdf sf_binoinv binofit 分布函数

Randunif

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

返回：处理后的结果值。

范例

return Randunif(1, 10, 10, array("a", "b"));

参考sf_unifpdf sf_unifcdf sf_unifinv uniffit 分布函数

sf_unifinv

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

返回：处理后的结果值。

范例

y := array(0.01, 0.01) -  > 0.99;
return sf_unifinv(y, 1, 10);

参考sf_unifpdf sf_unifcdf Randunif uniffit 分布函数

sf_binopdf

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

返回：处理后的结果值。

范例

x := 1 -  > 20;
return sf_binopdf(x, 10, 0.5);

参考sf_binocdf sf_binoinv Randbino binofit 分布函数

sf_nbincdf

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

返回：处理后的结果值。

范例

x := 1 -  > 10;
return sf_nbincdf(x, 10, 0.5);

参考sf_nbinpdf sf_nbininv Randnbin 分布函数

sf_unifpdf

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

返回：处理后的结果值。

范例

x := 1 -  > 10;
return sf_unifpdf(x, 1, 10);

参考sf_unifcdf Randunif uniffit 分布函数

sf_tcdf

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

返回：处理后的结果值。

范例

x := array(-2.5, 0.1) -  > 2.5;
return sf_tcdf(x, 30);

参考sf_tpdf sf_tinv1 Randt 分布函数

sf_fpdf

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

返回：处理后的结果值。

范例

x := array(0, 0.1) -  > 3;
return sf_fpdf(x, 20, 30);

参考sf_fcdf sf_finv1 Randf 分布函数

sf_tinv

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

返回：处理后的结果值。

范例

sf_tinv(0.6, 30, v);
return v; // 返回结果0.255605364951908

expfit

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

返回：处理后的结果值。

范例

x := randexp(1, 100);
return expfit(x, 0.05);

结果：返回parm的估计已经他们的在alpha的显著性水平下的区间估计

参考sf_exppdf sf_expcdf sf_expinv Randexp 分布函数

Randgam

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

返回：处理后的结果值。

范例

return Randgam(2, 2, 100, array("a", "b"));

参考sf_gampdf sf_gamcdf sf_gaminv 分布函数

sf_ch2inv

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

返回：处理后的结果值。

范例

y := array(0.01, 0.01) -  > 0.99;
return sf_ch2inv(y, 30);

参考sf_ch2pdf sf_ch2cdf Randch2 分布函数

sf_ch2cdf

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

返回：处理后的结果值。

范例

x := 0 -  > 50;
return sf_ch2cdf(x, 30);

参考sf_ch2pdf sf_ch2inv Randch2 分布函数

sf_finv1

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

返回：处理后的结果值。

范例

y := array(0.01, 0.01) -  > 0.99;
return sf_finv1(y, 20, 30);

参考sf_fpdf sf_fcdf Randf 分布函数

Randt

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

返回：处理后的结果值。

范例

return Randt(30, 10, array("a", "b"));

参考sf_tpdf sf_tcdf sf_tinv1 分布函数

sf_expcdf

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

返回：处理后的结果值。

范例

x := array(0, 0.1) -  > 4.5;
return sf_expcdf(x, 1);

参考sf_exppdf sf_expinv Randexp expfit 分布函数

sf_finv

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

返回：处理后的结果值。

范例

sf_finv(0.6, 20, 30, v);
return v; // 返回结果1.09737928787751

sf_gamcdf

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

返回：处理后的结果值。

范例

x := array(0, 0.1) -  > 13;
return sf_gamcdf(x, 2, 2);

参考sf_gampdf sf_gaminv Randgam 分布函数

sf_tpdf

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

返回：处理后的结果值。

范例

x := array(-2.5, 0.1) -  > 2.5;
return sf_tpdf(x, 30);

参考sf_tcdf sf_tinv1 Randt 分布函数

sf_x2inv

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

返回：处理后的结果值。

范例

sf_x2inv(0.6, 30, v);
return v; // 返回结果31.3158632360391

sf_gampdf

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

返回：处理后的结果值。

范例

x := array(0, 0.1) -  > 13;
return sf_gampdf(x, 2, 2);

参考sf_gamcdf sf_gaminv Randgam 分布函数

sf_gammainv

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

返回：处理后的结果值。

范例

sf_gammainv(0.068094, 9, v);
return v; // 返回结果 5.000005596

sf_fcdf

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

返回：处理后的结果值。

范例

x := array(0, 0.1) -  > 3;
return sf_fcdf(x, 20, 30);

参考sf_fpdf sf_finv1 Randf 分布函数

sf_ch2pdf

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

返回：处理后的结果值。

范例

x := 0 -  > 50;
return sf_ch2pdf(x, 30);

参考sf_ch2cdf sf_ch2inv Randch2 分布函数

Randf

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

返回：处理后的结果值。

范例

return Randf(20, 30, 10, array("a", "b"));

参考sf_fpdf sf_fcdf sf_finv1 分布函数

Randexp

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

返回：处理后的结果值。

范例

return Randexp(1, 10, array("a", "b"));

参考sf_exppdf sf_expcdf sf_expinv expfit 分布函数

Randch2

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

返回：处理后的结果值。

范例

return Randch2(30, 10, array("a", "b"));

参考sf_ch2pdf sf_ch2cdf sf_ch2inv 分布函数

sf_gaminv

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

返回：处理后的结果值。

范例

y := array(0.01, 0.01) -  > 0.99;
return sf_gaminv(y, 2, 2);

参考sf_gampdf sf_gamcdf Randgam 分布函数

sf_expinv

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

返回：处理后的结果值。

范例

y := array(0.01, 0.01) -  > 0.99;
return sf_expinv(y, 1);

参考sf_exppdf sf_expcdf Randexp expfit 分布函数

sf_betapdf

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

返回：处理后的结果值。

范例

x := array(0, 0.01) -  > 1;
return sf_betapdf(x, 2, 4);

参考sf_betacdf sf_betainv Randbeta 分布函数

sf_tinv1

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

返回：处理后的结果值。

范例

y := array(0.01, 0.01) -  > 0.99;
return sf_tinv1(y, 30);

参考sf_tpdf sf_tcdf Randt 分布函数

RandCauchy

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

返回：处理后的结果值。

范例

return RandCauchy(0, 2, 10, array("a", "b"));

参考sf_Cauchypdf sf_Cauchycdf sf_Cauchyinv 分布函数

sf_Laplacecdf

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

返回：处理后的结果值。

范例

x := array(-8, 0.1) -  > 8;
return sf_Laplacecdf(x, 0, 2);

参考sf_Laplacepdf sf_Laplaceinv RandLaplace 分布函数

Randbeta

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

返回：处理后的结果值。

范例

return Randbeta(2, 4, 100, array("a", "b"));

参考sf_betapdf sf_betacdf sf_betainv 分布函数

sf_Cauchypdf

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

返回：处理后的结果值。

范例

x := array(-60, 1) -  > 60;
return sf_Cauchypdf(x, 0, 2);

参考sf_Cauchycdf sf_Cauchyinv RandCauchy 分布函数

sf_logninv

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

返回：处理后的结果值。

范例

y := array(0.01, 0.01) -  > 0.99;
return sf_logninv(y, 0, 1);

参考sf_lognpdf sf_logncdf Randlogn 分布函数

sf_Laplaceinv

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

返回：处理后的结果值。

范例

y := array(0.01, 0.01) -  > 0.99;
return sf_Laplaceinv(y, 0, 2);

参考sf_Laplacepdf sf_Laplacecdf RandLaplace 分布函数

sf_betacdf

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

返回：处理后的结果值。

范例

x := array(0, 0.01) -  > 1;
return sf_betacdf(x, 2, 4);

参考sf_betapdf sf_betainv Randbeta 分布函数

sf_raylinv

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

返回：处理后的结果值。

范例

y := array(0.01, 0.01) -  > 0.99;
return sf_raylinv(y, 1);

参考sf_raylpdf sf_raylcdf Randrayl 分布函数

sf_wblcdf

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

返回：处理后的结果值。

范例

x := array(0, 0.05) -  > 3;
return sf_wblcdf(x, 1, 1.5);

参考sf_wblpdf sf_wblinv Randwbl 分布函数

sf_lognpdf

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

返回：处理后的结果值。

范例

x := array(0, 0.1) -  > 5;
return sf_lognpdf(x, 0, 1);

参考sf_logncdf sf_logninv Randlogn 分布函数

sf_Cauchycdf

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

返回：处理后的结果值。

范例

x := array(-60, 1) -  > 60;
return sf_Cauchycdf(x, 0, 2);

参考sf_Cauchypdf sf_Cauchyinv RandCauchy 分布函数

Randlogn

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

返回：处理后的结果值。

范例

return Randlogn(0, 1, 10, array("a", "b"));

参考sf_lognpdf sf_logncdf sf_logninv 分布函数

Randrayl

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

返回：处理后的结果值。

范例

return Randrayl(1, 100, array("a", "b"));

参考sf_raylpdf sf_raylcdf sf_raylinv 分布函数

sf_Laplacepdf

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

返回：处理后的结果值。

范例

x := array(-8, 0.1) -  > 8;
return sf_Laplacepdf(x, 0, 2);

参考sf_Laplacecdf sf_Laplaceinv RandLaplace 分布函数

sf_raylpdf

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

返回：处理后的结果值。

范例

x := array(0, 0.05) -  > 9;
return sf_raylpdf(x, 1);

参考sf_raylcdf sf_raylinv Randrayl 分布函数

sf_wblinv

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

返回：处理后的结果值。

范例

y := array(0.01, 0.01) -  > 0.99;
return sf_wblinv(y, 1, 1.5);

参考sf_wblpdf sf_wblcdf Randwbl 分布函数

sf_logncdf

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

返回：处理后的结果值。

范例

x := array(0, 0.1) -  > 5;
return sf_logncdf(x, 0, 1);

参考sf_lognpdf sf_logninv Randlogn 分布函数

sf_Cauchyinv

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

返回：处理后的结果值。

范例

y := array(0.01, 0.01) -  > 0.99;
return sf_Cauchyinv(y, 0, 2);

参考sf_Cauchypdf sf_Cauchycdf RandCauchy 分布函数

sf_raylcdf

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

返回：处理后的结果值。

范例

x := array(0, 0.05) -  > 3;
return sf_raylcdf(x, 1);

参考sf_raylpdf sf_raylinv Randrayl 分布函数

Randwbl

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

返回：处理后的结果值。

范例

return Randwbl(1, 1.5, 100, array("a", "b"));

参考sf_wblpdf sf_wblcdf sf_wblinv 分布函数

sf_betainv

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

返回：处理后的结果值。

范例

y := array(0.01, 0.01) -  > 0.99;
r := sf_betainv(y, 2, 4, x);
return x;

参考sf_betapdf sf_betacdf Randbeta 分布函数

RandLaplace

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

返回：处理后的结果值。

范例

return RandLaplace(0, 2, 10, array("a", "b"));

参考sf_Laplacepdf sf_Laplacecdf sf_Laplaceinv 分布函数

sf_wblpdf

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

返回：处理后的结果值。

范例

x := array(0, 0.05) -  > 3;
return sf_wblpdf(x, 1, 1.5);

参考sf_wblcdf sf_wblinv Randwbl 分布函数

sf_betainv1

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

返回：处理后的结果值。

范例

y := array(0.01, 0.01) -  > 0.99;
return sf_betainv1(y, 2, 4);

参考sf_betapdf sf_betacdf Randbeta 分布函数

sf_mvtcdf

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

返回：处理后的结果值。

范例

范例01：

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：

return sf_mvtcdf(zeros(length(u), 3), u, rho, 2);

Mvtcdfqmc

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

返回：处理后的结果值。

范例

范例01：

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：

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：

return sf_mvncdf(zeros(length(u), 3), u, zeros(1, 3), rho);

sf_copulacdf

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

返回：处理后的结果值。

范例

范例01：gaussian分布

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分布

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调用相同)

u := Randunif(0, 1, 300, 2);
return sf_copulacdf(u, "clayton", nil, 1);

sf_copulafit

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

返回：处理后的结果值。

范例

范例01：gaussian分布

// 返回数组，相关系数矩阵
u := Randunif(0, 1, 300, 3);
return sf_copulafit(u, "gaussian", "AML");

范例02：t分布

// 返回数组，相关系数矩阵以及自由度
u := Randunif(0, 1, 300, 2);
return sf_copulafit(u, "t", "AML");

范例03：阿基米德族，clayton(frank、gumbel调用相同)

// 返回实数，参数估计值
u := Randunif(0, 1, 300, 2);
return sf_copulafit(u[:, 0:1], "clayton");

RandCopula

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

返回：处理后的结果值。

范例

范例01：gaussian分布

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分布

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调用相同)

alpha := 1;
n := 10;
return RandCopula("clayton", nil, alpha, n);

sf_exp

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

返回：处理后的结果值。

范例

y := array(0.01, 0.01) -  > 0.99;
sf_exp(y, 3, v);
return v;

Norminv

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

参考EstimateTNU Estimate SND Estimate_TND Estimate_SP Estimate_TP

Estimate_TNU

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

返回：处理后的结果值。

范例

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

参考EstimateSNU Estimate SND Estimate_TND Estimate_SP Estimate_TP

Estimate_ SND

范例

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

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

返回：处理后的结果值。

范例

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

参考EstimateSNU Estimate_TNU Estimate SND Estimate_SP Estimate_TP

Estimate_SP

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

返回：处理后的结果值。

范例

mx := 0.3;
n := 120;
alpha := 0.05;
return Estimate_SP(mx, n, alpha);

参考EstimateSNU Estimate_TNU Estimate SND Estimate_TND Estimate_TP

Estimate_TP

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

返回：处理后的结果值。

范例

P := array(0.478, 0.328);
N := array(1000.00, 750.00);
alpha := 0.05;
return Estimate_TP(P, N, alpha);

参考EstimateSNU Estimate_TNU Estimate SND Estimate_TND Estimate_SP

Hypoth_TailRes

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

返回：处理后的结果值。

范例

return Hypoth_TailRes(50.110101, 0.06, "left", 0.05);

NormPlot

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

return Hypoth_Kstest(randn(0, 1, 100), ’both’, a, cdf);

参考NormPlot Hypoth_lillietest

Hypoth_lillietest

用途：统计推断相关函数。参数：无。返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

x := array((120, 30), (479, 371));return Hypoth_KruskalWallis(x, 0.05);

结果表示接受原假设，即x与y无关参考Hypoth_IndepTest

Hypoth_SNUTest

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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下，判断以上各水平是否有显著差异

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对某指标是否有显著影响

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下，判断以上四组数据方差是否有显著差异:

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下，判断以上四组数据方差是否有显著差异:

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

x := array((6, 4), (20, 10));
Alpha := 0.05;
return Hypoth_McNemarTest(x, Alpha);

结果

配对检验

####### 内容

Hypoth_PNUTest
Hypoth_PSignTest
Hypoth_PWilcoxonTest

####### Hypoth_PNUTest

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

返回：处理后的结果值。

范例

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

用途：多元统计分析相关函数。参数：

返回：处理后的结果值。

范例

A := rand(3, 4);
return Corr(A, 1); // 返回的是一般相关系数矩阵

输出结果：

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

用途：多元统计分析相关函数。参数：

返回：处理后的结果值。

范例

a := rand(4, 3);
return CorrelationMatrix(a, 1);

结果

参考Corr Covariance Corr_partial Corrcoef Corr_partial Distance

Covariance

用途：多元统计分析相关函数。参数：

返回：处理后的结果值。

范例

a := rand(4, 3);
return Covariance(A);

结果

参考Corr CorrelationMatrix Corr_partial Corrcoef Corr_partial Distance

Corrcoef

用途：多元统计分析相关函数。参数：

返回：处理后的结果值。

范例

A := rand(7, 4);
return Corrcoef(A); // 返回简单相关系数分析

输出结果：

参考Corr Covariance Corr_partial CorrelationMatrix Corr_partial Distance

Corr_partial

用途：多元统计分析相关函数。参数：

返回：处理后的结果值。

范例

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

用途：多元统计分析相关函数。参数：

返回：处理后的结果值。

范例

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;

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

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

返回：处理后的结果值。

范例

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

用途：多元统计分析相关函数。参数：

返回：处理后的结果值。

范例

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

用途：多元统计分析相关函数。参数：

返回：处理后的结果值。

范例

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

用途：多元统计分析相关函数。参数：

返回：处理后的结果值。

范例

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

用途：多元统计分析相关函数。参数：

返回：处理后的结果值。

范例

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代码：

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

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

// 首先选取数据并且对数据做标准化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分别表示平均位次。范例

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

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

返回：处理后的结果值。

范例

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个时使用范例

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

用途：多元统计分析相关函数。参数：

返回：处理后的结果值。

范例

A := Covariance(rand(4, 3));
return Cov2CorrMatrix(A);

CorrMatrixAdjust

用途：多元统计分析相关函数。参数：

返回：处理后的结果值。

范例

A := Corr(rand(6, 6));
return CorrMatrixAdjust(A, 1, 5);

corr_Kendall

用途：多元统计分析相关函数。参数：

返回：处理后的结果值。

范例

x := array(3, 8, 4, 7, 2);
y := array(5, 10, 8, 10, 6);
return corr_Kendall(x, y);

结果：0.7379

HISTC

用途：多元统计分析相关函数。参数：

返回：处理后的结果值。

范例

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

用途：回归相关函数。参数：

返回：处理后的结果值。

范例

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

用途：回归相关函数。参数：

返回：处理后的结果值。

范例

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代码:

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

用途：回归相关函数。参数：

返回：处理后的结果值。

范例

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

用途：回归相关函数。参数：

返回：处理后的结果值。

范例

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

用途：回归相关函数。参数：

返回：处理后的结果值。

范例

判断股票涨幅与各财务指标的相关系

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

用途：回归相关函数。参数：

返回：处理后的结果值。

范例

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

用途：回归相关函数。参数：

返回：处理后的结果值。

范例

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

用途：回归相关函数。参数：

返回：处理后的结果值。

范例

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

用途：回归相关函数。参数：

返回：处理后的结果值。

范例

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

范例

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

范例

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

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

使用极大似然法估计模型中的各个参数：

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

下面我们继续看看样本内的误判率：

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

范例

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 X1（以1978年为100）	人均可支配收入 X2（元）	上年人均消费支出 X3（元）	人均消费支出 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

用途：回归相关函数。参数：

返回：处理后的结果值。

范例

// 对序列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

用途：回归相关函数。参数：

返回：处理后的结果值。

范例

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

用途：回归相关函数。参数：

返回：处理后的结果值。

范例

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

用途：回归相关函数。参数：

返回：处理后的结果值。

范例

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

用途：回归相关函数。参数：

返回：处理后的结果值。

范例

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|之间存在系统关系，异方差问题存在。范例

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

用途：回归相关函数。参数：

返回：处理后的结果值。

范例

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

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

用途：回归相关函数。参数：

返回：处理后的结果值。

范例

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

用途：回归相关函数。参数：

返回：处理后的结果值。

范例

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

用途：回归相关函数。参数：

返回：处理后的结果值。

范例

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

范例

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

用途：回归相关函数。参数：

返回：处理后的结果值。

范例

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/tunessqrt1-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)<ε范例

x := 1 -  > 100;
y := 3 * x + 100;
y[:5] := 1000;
return robustfit_M(y, x, 0.05, 1, 'andrews', 1.339);

####### Regress_GRStest

用途：回归相关函数。参数：

返回：处理后的结果值。

范例

// 截距项矩阵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相应位置上的值，然后两者进行矩阵的左除范例

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，利用最小二乘法进行回归得到系数矩阵范例

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的数组范例

x := array(0.00, 1.00, 2.00);
return SingleLinearRegression_CallBack(x);
// 结果：

####### 多项式回归

######## 内容

PolynomialRegression

######## PolynomialRegression

算法

(1)计算每个X对应的由0到M为指数的指数函数值F；

(2)运用最小二乘方法进行回归得到系数矩阵；范例

x := array(0.00, 1.00, 2.00);
y := array(1.00, 2.00, 3);
return PolynomialRegression(x, y, 1);
// 结果：

####### 多元回归

######## 内容

MultipleRegression
中间函数

######## MultipleRegression

算法

采用字符串的方式调用CallBack函数得到F，运用最小二乘法进行回归得到系数矩阵范例

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中取自然对数后的值的数组范例

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的取值的数组范例

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)运用最小二乘方法进行回归得到系数矩阵；范例

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)运用最小二乘方法进行回归得到系数矩阵；范例

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的数值范例

X := array(1.00, -5.00, 6.00);
return SingleUnLineralRegression_CallBack(X);
// 结果：

######## 多项式回归

######### 内容

PolynomialRegression_Pgm

######### PolynomialRegression_Pgm

算法

(1)计算每个X对应的由0到M为指数的指数函数值F；

(2)运用最小二乘方法进行回归得到系数矩阵；范例

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)运用最小二乘方法进行回归得到系数矩阵；范例

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)运用最小二乘方法进行回归得到系数矩阵；范例

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的数组范例

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

用途：灰色系统相关函数。参数：

返回：处理后的结果值。

范例

初值化：代码如下

x := array((1, 2, 3), (2, 3, 4));
un := array();
return GM_Initial(x, "ini", un);

均值化：

TSL代码如下

x := array((1, 2, 3), (2, 3, 4));
un := array();
return GM_Initial(x, "mean", un);

按行区间值化

TSL代码如下

x := array((1, 2, 3), (2, 3, 4));
un := array();
return GM_Initial(x, "rrange", un);

归一化

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

用途：灰色系统相关函数。参数：

返回：处理后的结果值。

范例

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代码如下

x := array(1, 2, 3, 4);
return GM_AGO(x, "add", 2);

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

用途：灰色系统相关函数。参数：

返回：处理后的结果值。

范例

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代码如下

x := array((1, 2, 3), (2, 3, 4));
return GM_Scorr(x, "abs");

灰色相对关联度： TSL代码如下

x := array((1, 2, 3), (2, 3, 4));
return GM_Scorr(x, "ret");

灰色综合关联度： 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和主因子对应的特征根获得主因子及其得分范例

// 设置样本矩阵
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中进行同样的调换范例

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

// 设置样本矩阵
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范例

// 设置样本矩阵
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范例

// 设置样本矩阵
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

用途：主成分分析相关函数。参数：

返回：处理后的结果值。

算法

计算相对方差，然后把矩阵进行规范化，最后进行方差的最大旋转范例

// 设置样本矩阵
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的值范例

// 设置样本矩阵
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

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

返回：日期或时间值。

范例

A := rand(100, 10);
return Time_Diff(A, 1); // 得到A的一阶差分

参考diff

Time_AutoCov

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

返回：日期或时间值。

范例

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为滞后阶数。范例

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

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

返回：日期或时间值。

范例

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

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

返回：日期或时间值。

范例

y := randNorm(0, 1, 200);
m := 6;
alpha := 0.05;
return Time_RandomTest(y, m, alpha);

结果表明序列为纯随机序列参考Time_ACF Time_PACF AR ARMA

Time_DanielTest

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

返回：日期或时间值。

范例

检验上证指数的平稳性

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

用途：时间序列分析相关函数。参数：

返回：处理后的结果值。

范例

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

用途：时间序列分析相关函数。参数：

返回：处理后的结果值。

范例

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

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

返回：日期或时间值。

范例

// 以招商银行(收益率)为例，用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

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

返回：日期或时间值。

范例

// 以招商银行(收益率)为例，用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

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

返回：日期或时间值。

范例

// 检验上证指数的平稳性（是否存在单位根）(结果可参照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

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

返回：日期或时间值。

范例

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

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

返回：日期或时间值。

范例

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

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

返回：日期或时间值。

范例

// 判断序列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

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

返回：日期或时间值。

范例

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

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

返回：日期或时间值。

范例

{已知一个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

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

返回：日期或时间值。

范例

{已知一个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

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

返回：日期或时间值。

范例

Ap := array(1, -0.5);
Mq := array(0);
return Time_GreenFun(Ap, Mq);

参考AR ARMA

Time_InvFun

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

返回：日期或时间值。

范例

x := array(64, 60, 59, 50, 67, 45);
y := array(34, 23);
return Time_InvFun(x, y);

参考AR ARMA

Time_Analyse

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

返回：日期或时间值。

范例

{以招商银行(日收盘价)为例，用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

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

返回：日期或时间值。

范例

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

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

返回：日期或时间值。

范例

// 判断上证指数与深证综指（对数收益率）的协整关系(结果可参照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

用途：时间序列分析相关函数。参数：

返回：处理后的结果值。

范例

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因果检验。

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

用途：优化相关函数。参数：

返回：处理后的结果值。

范例

目标：

function obj(x);
begin
    return 3 * x[0] ^ 2 + x[1] ^ 2 - 2 * x[0] * x[1] + 4 * x[0] + 3 * x[1];
end;

函数求解：

x0 := array(1, 1); // 初始值;
return ret := NonLP_Hooke_Jeeves("obj", x0, 0.2);

参考NonLP_Fminsearch NonLP_Nelder NonLP_Rosenbrock

Prog_L

用途：优化相关函数。参数：

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

{线性不等式约束
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');

目标函数

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非线性不等式约束
    return array(ne, e);
end;

参考Prog_N Fmin NonLP_minSUMT NonLP_minFactor NonLP_Fmincon

NonLP_Fibonacci

用途：优化相关函数。参数：

返回：处理后的结果值。

范例

// 目标函数
function obj(x);
begin
    return a ^ 2 - 5 * a + 8;
end;

求解最小值：

A := 1; // 下界;
B := 7; // 上界；
return ret := NonLP_Fibonacci("obj", 1, 7);

参考NonLP_Fminbnd NonLP_Golden NonLP_GP NonLP_Range NonLP_BSearch

NonLP_Range

用途：优化相关函数。参数：

返回：处理后的结果值。

范例

目标：

function obj(x);
begin
    return 3 * x[0] ^ 2 + x[1] ^ 2 - 2 * x[0] * x[1] + 4 * x[0] + 3 * x[1];
end;

函数求解：

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代码：

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

用途：优化相关函数。参数：

返回：处理后的结果值。

范例

目标：

function obj(x);
begin
    return 3 * x[0] ^ 2 + x[1] ^ 2 - 2 * x[0] * x[1] + 4 * x[0] + 3 * x[1];
end;

函数求解：

x0 := array(1, 1); // 初始值;
return ret := NonLP_BSearch("obj", x0, 0.2);

参考NonLP_Fminbnd NonLP_Range NonLP_Golden NonLP_Fibonacci NonLP_GP

Prog_M

用途：优化相关函数。参数：

返回：处理后的结果值。

范例

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的范例和参考

// 线性等式约束
AEQ := array();
BEQ := array();
// 初始值
x0 := array(1, 1);
// 分别设置的变量,约束条件,目标函数的迭代精度；不设置采用默认值
return NonLP_minFactor('obj', X0, AEQ, BEQ, 'constr');

目标函数

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_N Fmin NonLP_minSUMT NonLP_minPS NonLP_Fmincon

NonLP_GP

用途：优化相关函数。参数：

返回：处理后的结果值。

范例

// 目标函数
function obj(x);
begin
    return a ^ 2 - 5 * a + 8;
end;

求解最小值：

A := 1; // 下界;
B := 7; // 上界；
return ret := NonLP_GP("obj", 1, 7);

参考NonLP_Fminbnd NonLP_Golden NonLP_Fibonacci NonLP_Range NonLP_BSearch

NonLP_Fminsearch

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

返回：处理后的结果值。

范例

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

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

返回：处理后的结果值。

范例

{线性不等式约束
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);

目标函数

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_N Fmin NonLP_minSUMT NonLP_minPS NonLP_minFactor

NonLP_minSUMT

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

返回：处理后的结果值。

范例

{线性不等式约束
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");

目标函数

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_N Fmin NonLP_minPS NonLP_minFactor NonLP_Fmincon

Prog_Q

用途：优化相关函数。参数：

返回：处理后的结果值。

范例

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

用途：优化相关函数。参数：

返回：处理后的结果值。

范例

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

用途：优化相关函数。参数：

返回：处理后的结果值。

范例

目标：

function obj(x);
begin
    return 3 * x[0] ^ 2 + x[1] ^ 2 - 2 * x[0] * x[1] + 4 * x[0] + 3 * x[1];
end;

函数求解：

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

用途：优化相关函数。参数：

返回：处理后的结果值。

范例

// 目标函数
function obj(x);
begin
    return a ^ 2 - 5 * a + 8;
end;

求解最小值：

A := 1; // 下界;
B := 7; // 上界；
return ret := NonLP_Golden("obj", 1, 7);

参考NonLP_Fminbnd NonLP_Fibonacci NonLP_GP NonLP_Range NonLP_BSearch

TSOptimizer

范例

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/2x1^2+x2^2-x1x2-2x1-6x2

subject to

x1 + x2 ≤ 2

–x1 + 2x2 ≤ 2

2x1 + x2 ≤ 3

0 ≤ x1, 0 ≤ x2.

TSL代码：

H := array((1, -1), (-1, 2));
f := array(-2, -6);
A := array((1, 1), (-1, 2), (2, 1));
B := array(2, 2, 3);
Aeq := array();
Beq := array();
return Quadprog(H, f, A, B, Aeq, Beq);
// 结果： x1=0.6667,x2=1.3333,f(x)=-8.2222

参考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代码：

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

用途：优化相关函数。参数：

返回：处理后的结果值。

范例

目标：

function obj(x);
begin
    return 3 * x[0] ^ 2 + x[1] ^ 2 - 2 * x[0] * x[1] + 4 * x[0] + 3 * x[1];
end;

函数求解：

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) = 2x1^2+x2^2+x1x2-x1-x2

subject to

x1 + x2 = 1

TSL代码：

H := array((4, 1), (1, 2));
f := array(-1, -1);
Aeq := array((1, 1));
Beq := array(1);
return QuadLagR(H, f, Aeq, Beq);

结果解析：x1=0.25,x2=0.75,最小值f(x)=-0.125参考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代码：

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法求解无约束最优化问题范例

CallBack := 'H_J_CallBack';
return H_J_Method_Pgm(CallBack);
// 结果：

####### Sumt_Method__Pgm

算法

运用SUMT法求解最优化问题范例

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

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的值范例

x := array(1.00, 2.00); // 设置一维数字数组
return H_J_CallBack(x, 0);
// 结果：1

QuadTrackRoute

用途：优化相关函数。参数：

返回：处理后的结果值。

范例

Find x that minimize

f(x) = 2x1^2+2x2^2-x1x2+8x1-6x2

subject to

x1 + x2 ≤ 2

2*x1 - x2 ≤ 1

TSL代码：

H := array((4, -1), (-1, 4));
f := array(8, -6);
A := array((1, 1), (2, -1));
B := array(2, 1);
Aeq := array();
Beq := array();
x0 := array(0, 0);
return QuadTrackRoute(H, f, A, B, Aeq, Beq, x0);

结果分析：x1=-1.733333,x2=1.066667,最小值f(x)=-10.13333参考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代码：

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。

范例

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 为层数。返回：重构后的序列。

参数：

范例

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 为去噪选项。返回：处理后的序列。

范例

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

用途：财务函数相关函数。参数：

返回：处理后的结果值。

范例

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

用途：财务函数相关函数。参数：

返回：处理后的结果值。

范例

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

用途：财务函数相关函数。参数：

返回：处理后的结果值。

范例

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

用途：财务函数相关函数。参数：

返回：处理后的结果值。

范例

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

用途：财务函数相关函数。参数：

返回：处理后的结果值。

范例

Guess := 100;
data := array(10, 20);
return InternalRateOfReturn(Guess, Data);

结果：-1参考简单函数对数组支持 DoubleDecliningBalance FutureValue InterestPayment InterestRate NumberOfPeriods NetPresentValue Payment PeriodPayment PresentValue SLNDepreciation SYDDepreciation

NumberOfPeriods

用途：财务函数相关函数。参数：

返回：处理后的结果值。

范例

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

用途：财务函数相关函数。参数：

返回：处理后的结果值。

范例

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

用途：财务函数相关函数。参数：

返回：处理后的结果值。

范例

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

用途：财务函数相关函数。参数：

返回：处理后的结果值。

范例

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

用途：财务函数相关函数。参数：

返回：处理后的结果值。

范例

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

用途：财务函数相关函数。参数：

返回：处理后的结果值。

范例

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

用途：财务函数相关函数。参数：

返回：处理后的结果值。

范例

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

// 源数据单位为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：

// 源数据单位为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：

// 计算基金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。范例

// 返回-1与-2的比率。
return RatioValue(-1, -2);
// 结果：-0.5

OutPutValueByUnit

用途：增长率与比率相关函数。参数：

返回：处理后的结果值。

算法

若DataType_="Real"，则v=Data/DataUnit；

若DataType_<>"Real"，则v=Data；

返回v。范例

// 返回1234.5以10为单位转换后的结果
return OutPutValueByUnit(1234.5, 'Real', 10);
// 结果：123.45

OutPutLnGrowRatio

用途：增长率与比率相关函数。参数：

返回：处理后的结果值。

算法若v1>0且v2>0，返回（v1的自然对数 - v2的自然对数）*100；

否则，返回0。范例

// 取3与4的对数增长率
return OutPutLnGrowRatio(3, 4);
// 结果：-28.77

OutPutGrowValue

用途：增长率与比率相关函数。参数：

返回：处理后的结果值。

算法若v1与v2都为实数，返回v1-v2；

否则，返回0。范例

// 返回13与14的差值
return OutPutGrowValue(13, 14);
// 结果：-1

OutPutGrowValue2

用途：增长率与比率相关函数。参数：

返回：处理后的结果值。

算法若v1与v2都为不等于0的实数，返回v1-v2；

否则，返回0。范例

// 返回13与14差值
return OutPutGrowValue2(13, 14);
// 结果：-1

OutPutGrowRatio

用途：增长率与比率相关函数。参数：

返回：处理后的结果值。

算法若v1与v2都为不等于0的实数，返回（v1-v2）/v2的绝对值*100；

否则，返回0。范例

// 返回13到14的增长率(%)
return OutPutGrowRatio(14, 13);
// 结果：7.69

OutPutGrowRatio2

用途：增长率与比率相关函数。参数：

返回：处理后的结果值。

算法

若v1与v2都为不等于0的实数，返回（v1-v2）/v2的绝对值*100；

若v1与v2其中有一个为0，返回"-"；

否则，返回0。范例

// 返回13到14的增长率(%)
return OutPutGrowRatio2(14, 13);
// 结果：7.69

MultyValue

用途：增长率与比率相关函数。参数：

返回：处理后的结果值。

算法

若v1与v2都是实数，则v=v1*v2；否则，v=0；

若v1<0，且v2<0，则v=-v；

返回v。范例

// 返回取-3与-5的乘积。
return MultyValue(-3, -5);
// 结果：-15

OutPutGrowValue3

用途：增长率与比率相关函数。参数：

返回：处理后的结果值。

算法若v1与v2都为大于等于0的实数，返回v1-v2；

否则，返回空字符串。范例

// 返回13与14的差值
return OutPutGrowValue3(13, 14);
// 结果：-1

OutPutGrowRatio3

用途：增长率与比率相关函数。参数：

返回：处理后的结果值。

算法若v1与v2都为实数，且v2>0，返回(v1-v2)/v2的绝对值*100；

否则，返回空字符串。范例

// 返回14到13的增长率(%)
return OutPutGrowRatio3(14, 13);
// 结果：7.69

RatioValue_Math

用途：增长率与比率相关函数。参数：

返回：处理后的结果值。

范例

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+b11X1+b12X2+?+b1nXnam+bm1X1+bm2X2+?+bmnXn=A+B*X

其中，A=a1am， B=b11b1nbm1bmn，则

EY=A+Bμ

DY=BΣBT范例

范例01：

A := 1.5;
B := 2;
Mu := 1;
Sigma := 10;
return Norm_LinearTransform(Mu, Sigma, A, B);

范例2：

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

用途：信号处理相关函数。参数：

返回：处理后的结果值。

范例

y := MarketTradeDayQk(20220101T, 20220131T);
return filter_hp(y, 10);

编号	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

编号	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

251 KiB Raw Blame History Unescape Escape

数学函数

内容

数值计算

内容

数值微积分

线性方程组的求解

插值

矩阵运算及分解

数组扩展

其他

常用数学函数

内容

Pi

Odd

Abs

Sqr

Sqrt

DivMod

Frexp

Ldexp

Poly

简单函数对数组支持

位运算函数

内容

_And

_Or

_Not

_Xor

_Shl

_Shr

_Rol

_Ror

三角函数

内容

Sin

Cos

SinCos

Tan

Cot

CoTan

Sec

Csc

Secant

Cosecant

ArcSin

ArcCos

ArcTan

ArcTan2

ArcCot

ArcSec

ArcCsc

Hypot

角度量转换

内容

RadToDeg

RadToGrad

RadToCycle

DegToRad

DegToGrad

DegToCycle

GradToRad

GradToDeg

GradToCycle

CycleToRad

CycleToDeg

CycleToGrad

双曲线函数

内容

Sinh

Cosh

Tanh

CotH

SecH

CscH

ArcCosh

ArcSinh

ArcTanh

ArcCotH

ArcSecH

251 KiB

Raw Blame History

编号	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