playbook/docs/tsl/codegen/builtin/math/statistics.md

Builtin - 数学 / 统计与分布

randG(mean, std_dev)

随机产生均值为Mean，标准差为StdDev的服从高斯分布的数据。往往用于模拟取样误差。

参数	类型	说明
mean	real	作为产生正态分布的均值
std_dev	real	作为产生正态分布的标准差，大于0

返回：real

示例

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

gamma(x)

计算伽马(Gamma)函数的数值

参数	类型	说明
x	array	大于0,支持数值数组。

返回：array

示例

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

gammaln(x)

计算对数gamma

参数	类型	说明
x	array	大于0,支持数值数组。

返回：array

示例

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

erf(x)

误差函数也称为概率函数，其定义为

参数	类型	说明
x	array	实型变量。支持数组

返回：array

示例

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

erfinv(x)

误差函数逆函数

参数	类型	说明
x	array	实型变量,支持数组

返回：array

示例

return erfinv(0.15);
// 结果：0.13372692166482

erfc(x)

误差累计分布函数

参数	类型	说明
x	array	实型变量。支持数组

返回：array

示例

return erfc(0.15);
// 0.832004028572637

erfcinv(x)

误差累计逆函数

参数	类型	说明
x	array	实型变量.支持数组

返回：array

示例

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

minIntValue(data)

返回一组实数数据中的最小值的整数部分

参数	类型	说明
data	array of real	存放整数的数组，如果输入是实数，计算先取整数部分

返回：integer

示例

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

sumOfSquares(data)

计算一组实数的平方和

参数	类型	说明
data	array of real	存放实数的数组

返回：real

示例

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

sumsAndSquares(data, sum, sum_of_squares)

计算一组实数的总和以及平方和，执行完毕后，总和存在参数Sum，平方和存在参数SumOfSquares中

参数	类型	说明
data	array of real	存放实数的数组
sum	real	实数，用来存放总和
sum_of_squares	real	实数，用来存放平方和

返回：any

示例

a := array(2, 3, 1, 5, 6, 7);
// b是总和,c是平方和
sumsAndSquares (a, b, c);
return array(b, c);
// 输出：
// array(24.0,124.0)

maxIntValue(data)

返回一组实数中的最大值的整数部分

参数	类型	说明
data	array of real	存放整数的数组名，如果输入是实数，计算先取整数部分

返回：integer

示例

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

sumInt(data)

计算一组数整数部分的总和

参数	类型	说明
data	array of real	存放整数的数组

返回：integer

示例

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

meanAndStdDev(data, mean, std_dev)

估计一组数据的平均值和标准差。执行完毕后，平均值放在参数Mean中，标准差放在参数StdDev中

参数	类型	说明
data	array of real	实数数组
mean	real	实数，存放平均值
std_dev	real	实数，存放标准差

返回：any

示例

a := array(5.3, 3.9, 5.6, 5, 7.5, 7.6);
// b是返回的平均值,c是返回的标准差
meanAndStdDev (a, b, c);
return array(b, c);
// 输出：
// array(5.81666666666667,1.46070759108956)

aveDev(data)

计算一组数据与均值绝对偏差的平均值

参数	类型	说明
data	array of real	存放实数的数组

返回：real

示例

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

totalVariance(data)

计算一组数据对其算术平均数的离差平方和（总体偏差）

参数	类型	说明
data	array of real	存放实数的数组

返回：real

示例

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

median(data)

计算一组数据的中位数

参数	类型	说明
data	array of real	存放实数的数组

返回：real

示例

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

mode(data)

计算一组数据的众数

参数	类型	说明
data	array of real	存放实数的数组

返回：real

示例

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

momentSkewKurtosis(data, m1, m2, m3, m4, skew, kurtosis)

计算一组数据的各项统计指标

参数	类型	说明
data	array of real	存放实数的数组
m1	real	数据平均值
m2	real	数据的方差
m3	real	数据的三阶中心距
m4	real	数据的四阶中心距
skew	real	偏度，反映数据不对称的程度
kurtosis	real	峰度，反映数据集中的程度

返回：any

示例

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);
// 输出：
// array(6.42857142857143,5.95918367346938,1.25947521865896,55.6684714702205,0.0865783828574166,1.56760180146369)

devSq(data)

计算一组数据样本平均值偏差的平方和

参数	类型	说明
data	array of real	存放实数的数组

返回：real

示例

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

cov(data1, data2)

两个数据间的协方差

参数	类型	说明
data1	array	数据，一维数组
data2	array	数据，一维数组

返回：real

示例

// 万科A在2018/10/1~2018/10/30日线收盘与大盘的协方差
begt := 20181001T;
endt := 20181030T;
setSysParam(Pn_Stock(), "SZ000002");
date_arr := 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(data1, data2)

两个数据间的相关系数

参数	类型	说明
data1	array	数据，一维数组
data2	array	数据，一维数组

返回：real

示例

// 万科A在2018/10/1~2018/10/30日线收盘与大盘价格的相关系数
begt := 20181001T;
endt := 20181030T;
setSysParam(Pn_Stock(), "SZ000002");
date_arr := 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(data1, data2)

两个数据间的回归斜率

参数	类型	说明
data1	array	数据，一维数组
data2	array	数据，一维数组

返回：real

示例

// 万科A在2018/10/1~2018/10/30日线收盘与大盘收盘价格的回归斜率
begt := 20181001T;
endt := 20181030T;
setSysParam(Pn_Stock(), "SZ000002");
date_arr := 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(data1, data2)

两个数据间的回归截距

参数	类型	说明
data1	array	数据，一维数组
data2	array	数据，一维数组

返回：real

示例

// 万科A在2018/10/1~2018/10/30日线收盘与大盘收盘价的相回归截距
begt := 20181001T;
endt := 20181030T;
setSysParam(Pn_Stock(), "SZ000002");
date_arr := 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(data1, data2)

两个数据间的乘积矩相关系数平方

参数	类型	说明
data1	array	数据，一维数组
data2	array	数据，一维数组

返回：real

示例

// 万科A在2018/10/1~2018/10/30日线收盘与大盘的乘积矩相关系数平方
begt := 20181001T;
endt := 20181030T;
setSysParam(Pn_Stock(), "SZ000002");
date_arr := 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(data1, data2)

两个数据间的相对标准偏差

参数	类型	说明
data1	array	数据，一维数组
data2	array	数据，一维数组

返回：real

示例

// 万科A在2018/10/1~2018/10/30日线收盘与大盘的相对标准偏差
begt := 20181001T;
endt := 20181030T;
setSysParam(Pn_Stock(), "SZ000002");
date_arr := 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(data1, data2)

两个数据间的回归斜率和截距

参数	类型	说明
data1	array	数据，一维数组
data2	array	数据，一维数组

返回：real

示例

// 万科A在2018/10/1~2018/10/30日线收盘与大盘收盘价格的回归斜率和截距
begt := 20181001T;
endt := 20181030T;
setSysParam(Pn_Stock(), "SZ000002");
date_arr := 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[: , "大盘"]);

quartile(data, x)

数据集中四分位的值

参数	类型	说明
data	array of real	存放实数的数组
x	integer	整数，0-4表示第几个四分点，为0的结果是数据集中最小的数，为4的结果是数据集中最大的数

返回：real

示例

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

minValue(data, rc, ml, assign, abnormal, fill)

返回一组实数中的最小值

参数	类型	说明
data	array of real	存放实数的数组
rc	integer	可选参数，行列选择:0求列最小值；1求行最小值；默认为0
ml	integer	可选参数，移动步长，默认不移动
assign	integer	可选参数，对字段筛选,指定某些行列，求其最小值；默认全部
abnormal	integer	可选参数，异常处理参数，按照存储位来进行管理:
fill	any	可选参数，data 为空时的返回

返回：real or array

示例

范例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;
// 输出：
// array(
// ("A":0.150146444095299,"B":0.0720029249787331,"A-最小":0.150146444095299),
// ("A":0.752386756474152,"B":0.794236877467483,"A-最小":0.150146444095299),
// ("A":0.875261440640315,"B":0.24984975066036,"A-最小":0.150146444095299),
// ("A":0.273097287165001,"B":0.905757479835302,"A-最小":0.150146444095299),
// ("A":0.725633884547278,"B":0.73020756803453,"A-最小":0.150146444095299),
// ("A":0.640606550732628,"B":0.688115618657321,"A-最小":0.150146444095299),
// ("A":0.942538371076807,"B":0.245572400279343,"A-最小":0.150146444095299),
// ("A":0.898009897442535,"B":0.00986421713605523,"A-最小":0.150146444095299),
// ("A":0.884120375616476,"B":0.413575921207666,"A-最小":0.150146444095299),
// ("A":0.0179871807340533,"B":0.90700996434316,"A-最小":0.0179871807340533))

maxvalue(data, rc, ml, assign, abnormal, fill)

返回一组实数中的最大值

参数	类型	说明
data	array of real	存放实数的数组
rc	integer	可选参数，行列选择:0求列最大值；1求行最大值；默认为0
ml	integer	可选参数，移动步长，默认不移动
assign	integer	可选参数，对字段筛选,指定某些行列，求其最大值；默认全部
abnormal	integer	可选参数，异常处理参数，按照存储位来进行管理:
fill	any	可选参数，data 为空时的返回

返回：real or array

示例

范例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;
// 输出：
// array(
// ("A":0.958783811656758,"B":0.707278462126851,"A-最大":0.958783811656758),
// ("A":0.750536063918844,"B":0.200482148211449,"A-最大":0.958783811656758),
// ("A":0.517184586962685,"B":0.178965070284903,"A-最大":0.958783811656758),
// ("A":0.846249950351194,"B":0.059791746083647,"A-最大":0.958783811656758),
// ("A":0.189113092375919,"B":0.773908615112305,"A-最大":0.958783811656758),
// ("A":0.789464950794354,"B":0.578314067330211,"A-最大":0.958783811656758),
// ("A":0.59376598126255,"B":0.8564029103145,"A-最大":0.958783811656758),
// ("A":0.493202868150547,"B":0.528921798337251,"A-最大":0.958783811656758),
// ("A":0.384325044928119,"B":0.3864487092942,"A-最大":0.958783811656758),
// ("A":0.977926453808323,"B":0.866223617922515,"A-最大":0.977926453808323))

mean(data, rc, ml, assign, abnormal, fill)

计算一组数的算术平均值

参数	类型	说明
data	array of real	存放实数的数组
rc	integer	可选参数，行列选择:0求列平均；1求行平均；默认为0
ml	integer	可选参数，移动步长，求移动平均步长，默认不移动
assign	integer	可选参数，对字段筛选,指定某些行列，求其均值；默认全部
abnormal	integer	可选参数，异常处理参数，按照存储位来进行管理:
fill	any	可选参数，data 为空时的返回

返回：real or array

示例

范例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;
// 输出：
// array(
// ("A":0.87071518227458,"B":0.582499709213153,"A-平均":0.87071518227458),
// ("A":0.881466222461313,"B":0.764262322103605,"A-平均":0.876090702367947),
// ("A":0.806781190447509,"B":0.855670898454264,"A-平均":0.852987531727801),
// ("A":0.999613848049194,"B":0.0568885344546288,"A-平均":0.889644110808149),
// ("A":0.481501111760736,"B":0.797956990310922,"A-平均":0.808015510998666),
// ("A":0.108187671285123,"B":0.354029157897458,"A-平均":0.691377537713076),
// ("A":0.581335202790797,"B":0.581649502040818,"A-平均":0.67565720415275),
// ("A":0.518596450332552,"B":0.212483842624351,"A-平均":0.656024609925225),
// ("A":0.639061011373997,"B":0.364532657200471,"A-平均":0.654139765641756),
// ("A":0.239243724849075,"B":0.521682396298274,"A-平均":0.612650161562488))

sum(data, rc, ml, assign, abnormal, fill)

计算一组数的总和

参数	类型	说明
data	array of real	存放实数的数组
rc	integer	可选参数，行列选择:0求列的和；1求行的和；默认为0
ml	integer	可选参数，移动步长，默认不移动
assign	integer	可选参数，对字段筛选,指定某些行列，求其合计值；默认全部
abnormal	integer	可选参数，异常处理参数，按照存储位来进行管理:
fill	any	可选参数，data 为空时的返回

返回：real or array

示例

范例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;
// 输出：
// 示例包含说明文字，未作为可执行片段运行。

norm(data, rc, ml, assign, abnormal, fill)

计算一组数据的平方和的平方根，也就是Sqrt(SumOfSquares)

参数	类型	说明
data	array of real	存放实数的数组
rc	integer	可选参数，行列选择:0求列平方和的平方根；1求行平方和的平方根；默认为0
ml	integer	可选参数，移动步长，默认不移动
assign	integer	可选参数，对字段筛选,指定某些行列，求其平方和的平方根；默认全部
abnormal	integer	可选参数，异常处理参数，按照存储位来进行管理:
fill	any	可选参数，data 为空时的返回

返回：real

示例

范例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;
// 输出：
// array(
// ("A":0.183076372835785,"B":0.990034059388563,"A-平方和的平方根":0.183076372835785),
// ("A":0.251783866435289,"B":0.299099538708106,"A-平方和的平方根":0.311307040858075),
// ("A":0.49730991339311,"B":0.890515994047746,"A-平方和的平方根":0.586710510939487),
// ("A":0.0872881365939975,"B":0.574711061315611,"A-平方和的平方根":0.593168140106097),
// ("A":0.528904323000461,"B":0.131601712433621,"A-平方和的平方根":0.79472525147091),
// ("A":0.785433517768979,"B":0.914764100918546,"A-平方和的平方根":1.11736029827467),
// ("A":0.404511127155274,"B":0.0298984514083713,"A-平方和的平方根":1.18832793796699),
// ("A":0.0960042411461473,"B":0.651920047821477,"A-平方和的平方根":1.19219969068564),
// ("A":0.456138449255377,"B":0.338952687336132,"A-平方和的平方根":1.27648046885177),
// ("A":0.00426198542118073,"B":0.550133779877797,"A-平方和的平方根":1.27648758391132))

stdDev(data, rc, ml, assign, abnormal, fill)

计算一组数据的标准差的估计（样本标准差），数学公式如下：

参数	类型	说明
data	array of real	存放实数的数组
rc	integer	可选参数，行列选择:0求列样本标准差；1求行样本标准差；默认为0
ml	integer	可选参数，移动步长，默认不移动
assign	integer	可选参数，对字段筛选,指定某些行列，求其样本标准差；默认全部
abnormal	integer	可选参数，异常处理参数，按照存储位来进行管理:
fill	any	可选参数，data 为空时的返回

返回：real or array

示例

范例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;
// 输出：
// array(
// ("A":0.15182253299281,"B":0.315825292607769,"A-样本标准差":0.0),
// ("A":0.577175007201731,"B":0.838894178392366,"A-样本标准差":0.300769618907604),
// ("A":0.913798103574663,"B":0.327133466256782,"A-样本标准差":0.381847833237904),
// ("A":0.874265916645527,"B":0.694091119104996,"A-样本标准差":0.351970269974613),
// ("A":0.873455712106079,"B":0.718590721255168,"A-样本标准差":0.323787099621693),
// ("A":0.671421690843999,"B":0.249334673630074,"A-样本标准差":0.28961683255538),
// ("A":0.34758283989504,"B":0.831702823517844,"A-样本标准差":0.292231994406431),
// ("A":0.214012956246734,"B":0.170686958590522,"A-样本标准差":0.307933683143253),
// ("A":0.61253499193117,"B":0.52847190736793,"A-样本标准差":0.288276298285835),
// ("A":0.96317343134433,"B":0.269431800814346,"A-样本标准差":0.297346945279902))

popnStdDev(data, rc, ml, assign, abnormal, fill)

计算一组数据的总体标准差，数学公式：

参数	类型	说明
data	array of real	存放实数的数组
rc	integer	可选参数，行列选择:0求列总体标准差；1求行总体标准差；默认为0
ml	integer	可选参数，移动步长，默认不移动
assign	integer	可选参数，对字段筛选,指定某些行列，求其总体标准差；默认全部
abnormal	integer	可选参数，异常处理参数，按照存储位来进行管理:
fill	any	可选参数，data 为空时的返回

返回：real or array

示例

范例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;
// 输出：
// array(
// ("A":0.0316496836021543,"B":0.838673108490184,"A-总体标准差":0.0),
// ("A":0.0380017445422709,"B":0.016102873487398,"A-总体标准差":0.00317603047005831),
// ("A":0.865900214761496,"B":0.421355169499293,"A-总体标准差":0.391780859156006),
// ("A":0.531020013149828,"B":0.991538721835241,"A-总体标准差":0.352314903801803),
// ("A":0.356325420551002,"B":0.24732820619829,"A-总体标准差":0.315147053389551),
// ("A":0.068206172902137,"B":0.404504089383409,"A-总体标准差":0.308162811041045),
// ("A":0.508473539724946,"B":0.705417396733537,"A-总体标准差":0.293211170252909),
// ("A":0.14910603640601,"B":0.279827648540959,"A-总体标准差":0.281654950955512),
// ("A":0.831985981203616,"B":0.0213200200814754,"A-总体标准差":0.310721312537621),
// ("A":0.0396571704186499,"B":0.384453092468903,"A-总体标准差":0.311531618685409))

variance(data, rc, ml, assign, abnormal, fill)

计算一组数据的方差的估计（样本方差），数学公式：

参数	类型	说明
data	array of real	存放实数的数组
rc	integer	可选参数，行列选择:0求列样本方差；1求行样本方差；默认为0
ml	integer	可选参数，移动步长，默认不移动
assign	integer	可选参数，对字段筛选,指定某些行列，求其样本方差；默认全部
abnormal	integer	可选参数，异常处理参数，按照存储位来进行管理:
fill	any	可选参数，data 为空时的返回

返回：real or array

示例

范例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;
// 输出：
// array(
// ("A":0.0976159237325191,"B":0.482796263182536,"A-样本方差":0.0),
// ("A":0.883788225706667,"B":0.639443505322561,"A-样本方差":0.309033444195665),
// ("A":0.297417941503227,"B":0.866883828537539,"A-样本方差":0.166969640815567),
// ("A":0.767699372489005,"B":0.0667955267708749,"A-样本方差":0.140455909946851),
// ("A":0.425307923927903,"B":0.222725304076448,"A-样本方差":0.106832245256288),
// ("A":0.932575504761189,"B":0.838074648519978,"A-样本方差":0.117470409113205),
// ("A":0.108969272114337,"B":0.241227929713205,"A-样本方差":0.127914790428133),
// ("A":0.345403993967921,"B":0.100473587168381,"A-样本方差":0.11270303845495),
// ("A":0.39564486593008,"B":0.465002589160577,"A-样本方差":0.0994504149628084),
// ("A":0.00122168054804206,"B":0.989088654285297,"A-样本方差":0.110630838406093))

skewness(data, rc, ml, assign, abnormal, fill)

计算一组数据的偏度，算法和excel兼容

参数	类型	说明
data	array of real	存放实数的数组
rc	integer	可选参数，行列选择:0求列偏度；1求行偏度；默认为0
ml	integer	可选参数，移动步长，默认不移动
assign	integer	可选参数，对字段筛选,指定某些行列，求其偏度；默认全部
abnormal	integer	可选参数，异常处理参数，按照存储位来进行管理:
fill	any	可选参数，data 为空时的返回

返回：real or array

示例

范例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;
// 输出：
// array(
// ("A":0.345008506439626,"B":0.947316359030083,"A-偏度":NAN),
// ("A":0.456479304004461,"B":0.314875329611823,"A-偏度":NAN),
// ("A":0.542076414451003,"B":0.465758888283745,"A-偏度":-0.389761200780375),
// ("A":0.830417833756656,"B":0.674252083292231,"A-偏度":1.12823697245901),
// ("A":0.692654144950211,"B":0.513484538765624,"A-偏度":0.305098325022161),
// ("A":0.175067013595253,"B":0.0867823071312159,"A-偏度":-0.0145265618339346),
// ("A":0.997625324875116,"B":0.229432929540053,"A-偏度":0.131336671537343),
// ("A":0.607732360716909,"B":0.00203069648705423,"A-偏度":0.0768566639543401),
// ("A":0.769998977892101,"B":0.25457691331394,"A-偏度":-0.181274403805795),
// ("A":0.462916810531169,"B":0.490705287782475,"A-偏度":0.0103060619790022))

skewness2(data, rc, ml, assign, abnormal, fill)

计算一组数据的偏度，算法和matlab兼容

参数	类型	说明
data	array of real	存放实数的数组
rc	integer	可选参数，行列选择:0求列偏度；1求行偏度；默认为0
ml	integer	可选参数，移动步长，默认不移动
assign	integer	可选参数，对字段筛选,指定某些行列，求其偏度；默认全部
abnormal	integer	可选参数，异常处理参数，按照存储位来进行管理:
fill	any	可选参数，data 为空时的返回

返回：real or array

示例

范例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;
// 输出：
// array(
// ("A":0.6100484195631,"B":0.715981872752309,"A-偏度":NAN),
// ("A":0.993454972514883,"B":0.599585968535394,"A-偏度":0.0),
// ("A":0.372750075301156,"B":0.444524445571005,"A-偏度":0.278760317564702),
// ("A":0.550206494750455,"B":0.647872807923704,"A-偏度":0.635048178529647),
// ("A":0.408510100794956,"B":0.953352153301239,"A-偏度":0.952205303351184),
// ("A":0.536475122207776,"B":0.74982732674107,"A-偏度":1.15164267581698),
// ("A":0.571144290035591,"B":0.0298545127734542,"A-偏度":1.26050077048314),
// ("A":0.230761173414067,"B":0.755714789498597,"A-偏度":0.85583534867919),
// ("A":0.150797324953601,"B":0.0688467305153608,"A-偏度":0.619687690263225),
// ("A":0.077599665382877,"B":0.990505203139037,"A-偏度":0.486284607637024))

kurtosis(data, rc, ml, assign, abnormal, fill)

计算一组数据的峰度，算法和excel兼容

参数	类型	说明
data	array of real	存放实数的数组
rc	integer	可选参数，行列选择:0求列峰度；1求行峰度；默认为0
ml	integer	可选参数，移动步长，默认不移动
assign	integer	可选参数，对字段筛选,指定某些行列，求其峰度；默认全部
abnormal	integer	可选参数，异常处理参数，按照存储位来进行管理:
fill	any	可选参数，data 为空时的返回

返回：real or array

示例

范例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;
// 输出：
// array(
// ("A":0.980047498596832,"B":0.402004413306713,"A-峰度":NAN),
// ("A":0.633000277215615,"B":0.990959876682609,"A-峰度":NAN),
// ("A":0.0302784142550081,"B":0.897569506429136,"A-峰度":NAN),
// ("A":0.952995504485443,"B":0.902370758820325,"A-峰度":1.14914121941789),
// ("A":0.647436241386458,"B":0.798524161800742,"A-峰度":1.75277777253052),
// ("A":0.106838567415252,"B":0.783145941328257,"A-峰度":-1.79403146968547),
// ("A":0.940166180720553,"B":0.361717429943383,"A-峰度":-1.27336988351427),
// ("A":0.696889952989295,"B":0.985664031002671,"A-峰度":-0.658650953176948),
// ("A":0.123242125613615,"B":0.675423074513674,"A-峰度":-1.65506451391199),
// ("A":0.986539963865653,"B":0.68698396300897,"A-峰度":-1.41423021480228))

kurtosis2(data, rc, ml, assign, abnormal, fill)

计算一组数据的峰度，算法和matlab兼容

参数	类型	说明
data	array of real	存放实数的数组
rc	integer	可选参数，行列选择:0求列峰度；1求行峰度；默认为0
ml	integer	可选参数，移动步长，默认不移动
assign	integer	可选参数，对字段筛选,指定某些行列，求其峰度；默认全部
abnormal	integer	可选参数，异常处理参数，按照存储位来进行管理:
fill	any	可选参数，data 为空时的返回

返回：real

示例

范例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;
// 输出：
// array(
// ("A":0.655130569823086,"B":0.169059717329219,"A-峰度":NAN),
// ("A":0.848595677409321,"B":0.331126981182024,"A-峰度":1.00000000000272),
// ("A":0.0950429700314999,"B":0.555930029833689,"A-峰度":1.5),
// ("A":0.741949734743685,"B":0.7052144294139,"A-峰度":2.19701539579311),
// ("A":0.0635894564911723,"B":0.696825876133516,"A-峰度":1.23130776662201),
// ("A":0.975331973750144,"B":0.707070349482819,"A-峰度":1.52458726295925),
// ("A":0.199741119518876,"B":0.772686692187563,"A-峰度":1.30375485345706),
// ("A":0.133859496098012,"B":0.414379859110341,"A-峰度":1.27199062552285),
// ("A":0.402421594597399,"B":0.580620889784768,"A-峰度":1.43616776036497),
// ("A":0.465525532606989,"B":0.129364971769974,"A-峰度":1.59328967992336))

harmean(data, rc, ml, assign, abnormal, fill)

计算一组数据的调和平均数

参数	类型	说明
data	array of real	存放实数的数组
rc	integer	可选参数，行列选择:0求列调和平均数；1求行调和平均数；默认为0
ml	integer	可选参数，移动步长，默认不移动
assign	integer	可选参数，对字段筛选,指定某些行列，求其调和平均数；默认全部
abnormal	integer	可选参数，异常处理参数，按照存储位来进行管理:
fill	any	可选参数，data 为空时的返回

返回：real or array

示例

范例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;
// 输出：
// array(
// ("A":0.124961190624163,"B":0.0598194859921932,"A-调和平均数":0.124961190624163),
// ("A":0.857839953387156,"B":0.141636071261019,"A-调和平均数":0.218145252665682),
// ("A":0.65432970575057,"B":0.0625838069245219,"A-调和平均数":0.280465973816327),
// ("A":0.458887472050265,"B":0.121089172083885,"A-调和平均数":0.310663488719166),
// ("A":0.613102434901521,"B":0.116132015362382,"A-调和平均数":0.344667921602947),
// ("A":0.785793515155092,"B":0.855155329685658,"A-调和平均数":0.380244620081035),
// ("A":0.799667620798573,"B":0.722903371788561,"A-调和平均数":0.411043312484736),
// ("A":0.653244619490579,"B":0.679718399886042,"A-调和平均数":0.431019257240658),
// ("A":0.955700401915237,"B":0.652552865445614,"A-调和平均数":0.459019535579044),
// ("A":0.965912215644494,"B":0.150117957498878,"A-调和平均数":0.484442154536813))

product(data, rc, ml, assign, abnormal, fill)

返回累乘值

参数	类型	说明
data	array of real	存放实数的数组
rc	integer	可选参数，行列选择:0求列累乘值；1求行累乘值；默认为0
ml	integer	可选参数，移动步长，默认不移动
assign	integer	可选参数，对字段筛选,指定某些行列，求其累乘值；默认全部
abnormal	integer	可选参数，异常处理参数，按照存储位来进行管理:
fill	any	可选参数，data 为空时的返回

返回：real or array

示例

// 一维数组计算累乘值
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;
// 输出：
// array(
// ("A":3.50745165487751,"B":8.34431231953204,"A-累乘":3.50745165487751),
// ("A":6.7908460390754,"B":5.874217399396,"A-累乘":23.8185641777734),
// ("A":5.74234192026779,"B":0.828072652220726,"A-累乘":136.774339558617),
// ("A":4.92611460620537,"B":0.982504128478467,"A-累乘":673.766071853797),
// ("A":2.6915419078432,"B":8.85313867591322,"A-累乘":1813.46961847739),
// ("A":2.64794702874497,"B":3.58003713656217,"A-累乘":4801.97148796647),
// ("A":5.65035830019042,"B":3.64946177229285,"A-累乘":27132.8594543091),
// ("A":7.37319005886093,"B":4.58649940323085,"A-累乘":200055.729596983),
// ("A":5.89445208897814,"B":2.48157736845315,"A-累乘":1179218.91323498),
// ("A":7.35567317577079,"B":2.42680004332215,"A-累乘":8673948.92844412))

large(data, n, rc, ml, assign, abnormal, fill)

找出第N最大的数

参数	类型	说明
data	array of real	存放实数的数组
n	integer	表示序号，1表示最大的数据
rc	integer	行列选择:0求列第N最大的数；1求行第N最大的数；默认为0
ml	integer	移动步长，默认不移动
assign	integer	对字段筛选,指定某些行列，求其第N最大的数；默认全部
abnormal	integer	异常处理参数，按照存储位来进行管理:
fill	any	data 为空时的返回

返回：real

示例

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

small(data, n, rc, ml, assign, abnormal, fill)

找出第N最小的数

参数	类型	说明
data	array of real	存放实数的数组
n	integer	表示序号，1表示最小的数据
rc	integer	行列选择:0求列第N最小的数；1求行第N最小的数；默认为0
ml	integer	移动步长，默认不移动
assign	integer	对字段筛选,指定某些行列，求其第N最小的数；默认全部
abnormal	integer	异常处理参数，按照存储位来进行管理:
fill	any	data 为空时的返回

返回：real

示例

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

percentrank(data, x, rc, ml, assign, abnormal, fill)

数据集中X在该组数据中的百分点

参数	类型	说明
data	array of real	存放实数的数组
x	real	实数，在数据集外的数的百分位使用线性插值得到
rc	integer	行列选择:0求列百分点；1求行百分点；默认为0
ml	integer	移动步长，默认不移动
assign	integer	对字段筛选,指定某些行列，求其百分点；默认全部
abnormal	integer	异常处理参数，按照存储位来进行管理:
fill	any	data 为空时的返回

返回：real

示例

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

rank(data, x, rc, ml, assign, abnormal, fill)

返回X在DATA中的排名(Data从大到小排列)，该数据必需存在在Data中。

参数	类型	说明
data	array of real	存放实数的数组
x	real	实数
rc	integer	行列选择:0求列排名；1求行排名；默认为0
ml	integer	移动步长，默认不移动
assign	integer	对字段筛选,指定某些行列，求其排名；默认全部
abnormal	integer	异常处理参数，按照存储位来进行管理:
fill	any	data 为空时的返回

返回：real

示例

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

trimmean(data, x, rc, ml, assign, abnormal, fill)

返回去掉头尾百分数以后的平均值。算法如下：

参数	类型	说明
data	array of real	存放实数的数组
x	real	百分比，实数，一般在0-1之间
rc	integer	行列选择:0求列排名；1求行排名；默认为0
ml	integer	移动步长，默认不移动
assign	integer	对字段筛选,指定某些行列，求其排名；默认全部
abnormal	integer	异常处理参数，按照存储位来进行管理:
fill	any	data 为空时的返回

返回：real

示例

// 去除个数=总个数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, freq_data, rc, ml, assign, abnormal, fill)

返回DATA在FreqData分割区间中的出现个数。

参数	类型	说明
data	array of real	存放实数的数组
freq_data	array of real	分割区间，如果为array(1,2,3)则表示需要计算Data 分别落在(-inf,1),(1,2),(2,3),(3,inf)四个区间的个数(频数)
rc	integer	行列选择:0求列排名；1求行排名；默认为0
ml	integer	移动步长，默认不移动
assign	integer	对字段筛选,指定某些行列，求其排名；默认全部
abnormal	integer	异常处理参数，按照存储位来进行管理:
fill	any	data 为空时的返回

返回：array of integer

示例

data := array(5, 3, 6, 8, 9, 10, 4);
freq_data := array(1, 2, 3);
return frequency(data, freq_data);
// 输出：
// array(0,0,1,6)

geomean(data)

计算一组数据的几何平均数

参数	类型	说明
data	array of real	存放实数的数组

返回：real

示例

范例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;
// 输出：
// array(
// ("A":0.519830256002024,"B":0.374670889694244,"A-几何平均数":0.519830256002024),
// ("A":0.765975012211129,"B":0.00843984819948673,"A-几何平均数":0.631012667613626),
// ("A":0.402682410785928,"B":0.294473465066403,"A-几何平均数":0.543266516297067),
// ("A":0.66125158383511,"B":0.80891461763531,"A-几何平均数":0.570625775662063),
// ("A":0.239383002044633,"B":0.718946079257876,"A-几何平均数":0.479622744628361),
// ("A":0.335142631782219,"B":0.669408179819584,"A-几何平均数":0.451808871517444),
// ("A":0.664034612709656,"B":0.788084068801254,"A-几何平均数":0.477359539816948),
// ("A":0.0850369480904192,"B":0.813925041817129,"A-几何平均数":0.384760839429897),
// ("A":0.231962512480095,"B":0.205027454067022,"A-几何平均数":0.363723728819524),
// ("A":0.809202993987128,"B":0.396649306640029,"A-几何平均数":0.394003626650774))

popnVariance(data)

计算一组数据的总体方差，数学公式：

参数	类型	说明
data	array of real	存放实数的数组

返回：real

示例

范例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;
// 输出：
// array(
// ("A":0.564295332413167,"B":0.198089802404866,"A-总体方差":0.0),
// ("A":0.166125119663775,"B":0.0624075580853969,"A-总体方差":0.039634879580224),
// ("A":0.378304088953883,"B":0.14998382772319,"A-总体方差":0.0264613528859377),
// ("A":0.318244896829128,"B":0.703246884280816,"A-总体方差":0.0203400328742531),
// ("A":0.568663859274238,"B":0.957403063541278,"A-总体方差":0.0234577418324268),
// ("A":0.257466434501112,"B":0.0300985530484468,"A-总体方差":0.0223352875445233),
// ("A":0.957228042650968,"B":0.674682865617797,"A-总体方差":0.0605798191589568),
// ("A":0.73080830834806,"B":0.904764427104965,"A-总体方差":0.0611106539800822),
// ("A":0.236550874542445,"B":0.432319020619616,"A-总体方差":0.0607978820394406),
// ("A":0.479372498579323,"B":0.225869641872123,"A-总体方差":0.0547388465767192))

percentile(data, pct, rc, ml, assign, abnormal, fi_ll)

计算序列百分点PCT的值。

参数	类型	说明
data	array of real	数组，存放实数的数组
pct	real	实数，表示百分点,从0开始,以1结束
rc	integer	行列选择:0求列第PCT个百分点的值；1求行第PCT个百分点的值；默认为0
ml	integer	整型，移动步长，取当前行向前ML个长度序列的百分点的值，为0时取整个序列（默认）。
assign	integer|string|array	下标或下标序列，对字段筛选，指定某些行列求百分点的值，为nil时为全部（默认）。
abnormal	integer	整型，
fi_ll	any	数据data为空时的返回值。

返回：real

示例

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

pdPreTaxPriceField()

分红送-派息(税前)。根据不同的数据库提供商返回对应的值

返回：string

pdNoticeDateField()

分红送-权息公告日字段。根据不同的数据库提供商返回对应的值

返回：string

pdPriceAmountField()

红利金额

返回：string

pdExDateField()

分红送-除权除息日字段。根据不同的数据库提供商返回对应的值

返回：string

pdIssureYearField()

分红送-分配年度字段。根据不同的数据库提供商返回对应的值

返回：string

pdDominatorValue()

分红送-送股比例分母。根据不同的数据库提供商返回对应的值

返回：any

pdGivenSharesField()

分红送-送股数量字段。根据不同的数据库提供商返回对应的值

返回：string

pdRecordDateField()

分红送-股权登记日字段。根据不同的数据库提供商返回对应的值

返回：string

pdAdvanceDateField()

分红送-预案公告日字段。根据不同的数据库提供商返回对应的值

返回：string

pdAllRatioField()

分红送-送股比。根据不同的数据库提供商返回对应的值

返回：string

pdFirstTradingDateField()

分红送-送股上市日。根据不同的数据库提供商返回对应的值

返回：string

pdGivenRatioField()

分红送-红股比字段。根据不同的数据库提供商返回对应的值

返回：string

pdDistributeYearField()

分红送-分配年度字段。根据不同的数据库提供商返回对应的值

返回：string

pdAddRatioField()

分红送-转增比字段。根据不同的数据库提供商返回对应的值

返回：string

pdBonusListDateField()

分红送-分红发放日。根据不同的数据库提供商返回对应的值

返回：string

pdDecisionDeclareDateField()

分红送-决案公告日字段。根据不同的数据库提供商返回对应的值

返回：string

pdAfterTaxPriceField()

分红送-派息(税后)。根据不同的数据库提供商返回对应的值

返回：string

pdRatioField()

分红送-比例字段。根据不同的数据库提供商返回对应的值

返回：string

sdEndDateField()

配股-缴款截止日。根据不同的数据库提供商返回对应的值

返回：string

sdRatioField()

配股-配股比。根据不同的数据库提供商返回对应的值

返回：string

sdPriceField()

配股-配股价。根据不同的数据库提供商返回对应的值

返回：string

sdRecordDateField()

配股-股权登记日。根据不同的数据库提供商返回对应的值

返回：string

sdValueOfRightsField()

配股-募集资金总额。根据不同的数据库提供商返回对应的值

返回：string

sdTrueVolField()

配股-实际配股数。根据不同的数据库提供商返回对应的值

返回：string

sdActualValueOfRightsField()

配股-募集资金净额。根据不同的数据库提供商返回对应的值

返回：string

sdFirstTradingDateField()

配股-配股上市日。根据不同的数据库提供商返回对应的值

返回：string

sdDistributeYearField()

配股-分配年度。根据不同的数据库提供商返回对应的值

返回：string

sdAdvanceDateField()

配股-预案公布日。根据不同的数据库提供商返回对应的值

返回：string

sdActualRatioField()

配股-实配比。根据不同的数据库提供商返回对应的值

返回：string

sdBeginDateField()

配股-缴款起始日。根据不同的数据库提供商返回对应的值

返回：string

sdDecisionDeclareDateField()

配股-决议公布日。根据不同的数据库提供商返回对应的值

返回：string

sdDeclareDateField()

配股-说明书刊登日字段。根据不同的数据库提供商返回对应的值

返回：string

sdPriceCeilingField()

配股-配股价上限。根据不同的数据库提供商返回对应的值

返回：string

sdDominatorValue2()

配股-配股金额单位。根据不同的数据库提供商返回对应的值

返回：any

sdPriceFloorField()

配股-配股价下限。根据不同的数据库提供商返回对应的值

返回：string

sdDominatorValue()

配股-配股比例分母。根据不同的数据库提供商返回对应的值

返回：any

sdExDateField()

配股-除权日。根据不同的数据库提供商返回对应的值

返回：string

sfNormal2(x)

累积标准正态分布，等同于sf_normcdf(x,0,1)

参数	类型	说明
x	float	实数，随机变量

返回：float

weightedVarianceFreq(x, w, v1)

频率权重加权样本方差 频率权重下，权重表示样本出现的次数 其中表示样本总数，当为样本个数时，，为加权均值。

参数	类型	说明
x	array	一维数字数组
w	array	一维权重向量
v1	any	样本个数

返回：float

weightedCovFreq(a, b, w, v1)

频率权重加权样本协方差 其中：分别表示加权均值，表示样本总数，当为样本个数时，

参数	类型	说明
a	array	样本a计算移动平均的一维数字数组
b	array	因子b计算移动平均的一维数字数组
w	array	一维权重向量
v1	any	样本个数

返回：any

weightedCovarianceFreq(a, w, v1)

频率权重加权样本协方差矩阵

参数	类型	说明
a	array	待计算的矩阵，每一列为一个因子
w	array	一维权重向量
v1	any	样本个数

返回：array

weightedSkewnessFreq(x, w, v1)

频率权重加权样本偏度 根据 V1^2/[(V1-1)*(V1-2)]进行修正

参数	类型	说明
x	array	一维数字数组，样本序列
w	array	一维数字数组，权重向量
v1	any	整数，样本总数

返回：float

weightedKurtosisFreq(x, w, v1)

频率权重加权样本峰度 根据V1^2*(V1+1)/[(V1-1)*(V1-2)*(V1-3)]进行修正

参数	类型	说明
x	array	一维数字数组，样本序列
w	array	一维数字数组，权重向量
v1	any	整数，样本总数

返回：float

correlMEwm(a, b, alphatype, adjust)

指数加权下最后一期的相关系数矩阵

参数	类型	说明
a	array	待计算的矩阵，每一列表示一个因子
b	float	衰减因子，与alphatype共同决定实际的衰减因子alpha，见平滑系数的确定
alphatype	any	用户自定义，默认为0
adjust	bool	是否调整，True、实际权重计算，False、根据无穷序列假设下的递推式计算，默认为False，见指数加权的两种递推式。

返回：array

covarianceEwm(a, b, alphatype, adjust)

指数加权下最后一期的协方差矩阵

参数	类型	说明
a	array	待计算的矩阵，每一列表示一个因子
b	float	衰减因子，与alphatype共同决定实际的衰减因子alpha，见平滑系数的确定
alphatype	any	用户自定义，默认为0
adjust	bool	是否调整，True、实际权重计算，False、根据无穷序列假设下的递推式计算，默认为False，见指数加权的两种递推式。；biased:是否有偏，True、返回加权总体方差，False、返回以修正后的无偏的加权样本方差，默认为Fasle

返回：array

accuracyScore(y_true, y_pred, normalize, sample_weight)

计算准确率

参数	类型	说明
y_true	array	数组，真实值序列
y_pred	array	数组，预测值序列
normalize	bool	布尔型，是否转为准确率，默认为真；为假时返回 两个序列相等的个数
sample_weight	array	数组，样本权重

返回：float

confusionMatrix(y_true, y_pred, labels, sample_weight)

计算混淆矩阵

参数	类型	说明
y_true	array	真实值序列
y_pred	array	预测值序列
labels	array	混淆矩阵下标排序，不给定labels时，可以通过labels读取出。内部排序
sample_weight	array	样本权重，1表示等权重，与全一数组等效，默认等权重

返回：array

confusionMatrix2(y_true, y_pred, labels, sample_weight)

计算混淆矩阵，返回以分类标签为下标的混淆矩阵

参数	类型	说明
y_true	array	真实值序列
y_pred	array	预测值序列
labels	array	混淆矩阵下标排序，；不给定labels时，可以通过labels读取出；内部排序
sample_weight	array	样本权重，1表示等权重，与全一数组等效，默认等权重

返回：array

multilabelConfusionMatrix(y_true, y_pred, labels, sample_weight, samplewise)

多标签混淆矩阵，适用于单标签和多标签。本函数支持多标签分类，单标签分类， 但在计算单标签分类的混淆矩阵的时候，跟confusion_matrix是不一样的

参数	类型	说明
y_true	array	真实值标签，一维或者二维数组
y_pred	array	预测值标签 ，与y_true统一大小
labels	array	要计算的标签集合，默认全部计算
sample_weight	array	样本权重
samplewise	bool	布尔值，表示是否按样本统计混淆矩阵，只适用于多标签

返回：array

hammingLoss(y_true, y_pred, sample_weight)

计算分类模型的汉明损失，适用于单标签和多标签模型，其中多标签模型数据是多维二元标签

参数	类型	说明
y_true	array	一维或者二维数组，真实类别，长度与样本数相等
y_pred	array	一维或者二维数组（与y_true一样），预测类别，长度与样本数相等
sample_weight	array	一维数组，样本权重，默认是等权重

返回：float

matthewsCorrcoef(y_true, y_pred, sample_weight)

用以测量分类模型的分类性能的指标，该指标考虑了真阳性、真阴性和假阳性和假阴性，通常认为该指标是一个比较均衡的指标，适用于单标签二分类和多分类

参数	类型	说明
y_true	array	一维数组，真实标签
y_pred	array	一维数组，预测标签
sample_weight	array	一维数组，样本权重，默认是等权重

返回：float

cohenKappaScore(y1, y2, labels, weights, sample_weight)

衡量单标签分类模型的分类精度的kappa系数，适用于单标签二分类和多分类

参数	类型	说明
y1	array	一维数组，真实标签
y2	array	一维数组，预测标签，y1和y2交换顺序不影响计算结果
labels	array	一维数组，选择的标签集，默认是y1和y2出现过的标签
weights	string	字符串，kappa系数的惩罚权重，可选array(nil,'linear','quadratic');默认是nil
sample_weight	array	一维数组，样本权重，默认是等权重，全一数组

返回：float

balancedAccuracyScore(y_true, y_pred, sample_weight, adjusted)

计算单标签分类模型的平衡准确率，适用于单标签模型

参数	类型	说明
y_true	array	一维数组，真实标签
y_pred	array	一维数组，预测标签
sample_weight	array	一维数组，样本权重，默认是等权重
adjusted	bool	布尔值，是否调整准确率，去掉随机部分，默认false，不作调整

返回：float

precisionScore(y_true, y_pred, average, labels, pos_label, sample_weight)

计算precision，适用于单标签和多标签分类

参数	类型	说明
y_true	array	真实标签
y_pred	array	预测标签
average	string	平均方法，可选array(nil,'micro', 'macro', 'weighted', 'samples','binary')，；'samples'只适用于多标签，默认是nil，即不做平均处理，计算每一个标签的precision
labels	array	需要计算的标签，默认是y_true和y_pred出现的所有
pos_label	any	正例标签，在单标签二分类时起作用，当数据是单标签二分类时，；并且average等于"binary"时有用，其他情况会被忽略
sample_weight	array	样本权重，默认等权重

返回：float

logLoss(y_true, y_pred_pro, sample_weight)

计算分类模型的对数损失，适用于概率估计模型，即通过输出概率来确定类别的模型，只适用于 单标签分类

参数	类型	说明
y_true	array	一维数组，真实类别，长度与样本数相等
y_pred_pro	array	二维数组，样本属于各个类别的输出概率；lablels :一维数组，样本可以取到的类别标签，；不提供则默认是y_true出现过的标签求唯一值
sample_weight	array	一维数组，样本权重，默认是等权重

返回：float

recallScore(y_true, y_pred, average, labels, pos_label, sample_weight)

计算recall，适用于单标签和多标签分类

参数	类型	说明
y_true	array	真实标签
y_pred	array	预测标签
average	string	平均方法，可选array(nil,'micro', 'macro', 'weighted', 'samples','binary')，；'samples'只适用于多标签，默认是nil，即不做平均处理，计算每一个标签的precision
labels	array	需要计算的标签，默认是y_true和y_pred出现的所有
pos_label	any	正例标签，在单标签二分类时起作用，当数据是单标签二分类时，；并且average等于"binary"时有用，其他情况会被忽略
sample_weight	array	样本权重，默认等权重

返回：float

fbetaScore(y_true, y_pred, beta, average, labels, pos_label, sample_weight)

计算f_score，适用于单标签和多标签分类

参数	类型	说明
y_true	array	真实标签
y_pred	array	预测标签
beta	float	beta参数，默认是1
average	string	平均方法，可选array(nil,'micro', 'macro', 'weighted', 'samples','binary')，；'samples'只适用于多标签，默认是nil，即不做平均处理，；计算每一个标签的precision
labels	array	需要计算的标签，默认是y_true和y_pred出现的所有
pos_label	any	正例标签，在单标签二分类时起作用，；当数据是单标签二分类时，并且average等于"binary"时有用，其他情况会被忽略
sample_weight	array	样本权重，默认等权重

返回：float

f1Score(y_true, y_pred, average, labels, pos_label, sample_weight)

调用fbeta_score时beta固定为1，适用于单标签和多标签分类

参数	类型	说明
y_true	array	真实标签
y_pred	array	预测标签
average	string	平均方法，可选array(nil,'micro', 'macro', 'weighted', 'samples','binary')，；'samples'只适用于多标签，默认是nil，即不做平均处理，；计算每一个标签的precision
labels	array	需要计算的标签，默认是y_true和y_pred出现的所有
pos_label	any	正例标签，在单标签二分类是起作用，当数据是单标签二分类时，；并且average等于"binary"时有用，其他情况会被忽略
sample_weight	array	样本权重，默认等权重

返回：float

precisionRecallCurve(y_true, y_score, pos_label, sample_weight)

计算PRC曲线序列值，适用于单标签二分类和多分类

参数	类型	说明
y_true	array	真实标签
y_score	array	预测输出概率
pos_label	any	正例标签，默认是1，多分类必须提供
sample_weight	array	样本权重，默认等权重

返回：array

ksCurve(y_true, y_score, pos_label, sample_weight, drop_intermediate)

计算K-S曲线序列值，使用单标签二分类和多分类

参数	类型	说明
y_true	array	真实标签
y_score	array	预测输出概率
pos_label	any	正例标签，默认是1，多分类必须提供
sample_weight	array	样本权重，默认等权重
drop_intermediate	bool	是否去掉无用点，默认为真

返回：array

maxError(y_true, y_pred, sample_weight)

在完全拟合的单输出回归模型中，训练集上的max_error将为0。

参数	类型	说明
y_true	any	数据的实际值
y_pred	any	模型的预测值
sample_weight	any	样本权重

返回：float

meanAbsoluteError(y_true, y_pred, sample_weight, multioutput)

暂时参数multioutput定义：为空数组，供后续开发使用。

参数	类型	说明
y_true	any	数据的实际值
y_pred	any	模型的预测值
sample_weight	any	样本权重
multioutput	any	多输出方法选项

返回：array

meanSquaredError(y_true, y_pred, sample_weight, multioutput)

暂时参数multioutput定义：为空数组，供后续开发使用。

参数	类型	说明
y_true	any	数据的实际值
y_pred	any	模型的预测值
sample_weight	any	样本权重
multioutput	any	多输出方法选项

返回：array

meanSquaredLogError(y_true, y_pred, sample_weight, multioutput)

暂时参数multioutput定义：为空数组，供后续开发使用。

参数	类型	说明
y_true	any	数据的实际值
y_pred	any	模型的预测值
sample_weight	any	样本权重
multioutput	any	多输出方法选项

返回：array

medianAbsoluteError(y_true, y_pred, sample_weight, multioutput)

暂时参数multioutput定义：为空数组，供后续开发使用。

参数	类型	说明
y_true	any	数据的实际值
y_pred	any	模型的预测值
sample_weight	any	样本权重
multioutput	any	多输出方法选项

返回：array

r2Score(y_true, y_pred, sample_weight, multioutput)

暂时参数multioutput定义：为空数组，供后续开发使用。 最佳可能的分数是1.0，它也可以是负的。

参数	类型	说明
y_true	any	数据的实际值
y_pred	any	模型的预测值
sample_weight	any	样本权重
multioutput	any	多输出方法选项

返回：array

explainedVarianceScore(y_true, y_pred, sample_weight, multioutput)

暂时参数multioutput定义：为空数组，供后续开发使用。 最好的得分是1.0, 值越小预测效果越差。

参数	类型	说明
y_true	any	数据的实际值
y_pred	any	模型的预测值
sample_weight	any	样本权重
multioutput	any	多输出方法选项

返回：array

kurt(t, real)

峰度。

参数	类型	说明
t	array	一维数字数组，一维数据
real		实数，返回的峰度

返回：any

示例

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

std(rsp_cycle, n)

已实现波动率(%)

参数	类型	说明
rsp_cycle	any	采样小周期
n	any	整型，当前时间向历史推移N个周期长度作为采样的时间区间(大区间)，与当前时间，周期相关。默认为 1，与市场周期对齐；N为0时，返回最后一个高频时刻

返回：float

stdUp(rsp_cycle, n)

高频上行波动率(%)

参数	类型	说明
rsp_cycle	any	采样小周期
n	any	整型，当前时间向历史推移N个周期长度作为采样的时间区间(大区间)，与当前时间，周期相关。默认为 1，与市场周期对齐；N为0时，返回最后一个高频时刻

返回：float

beta(rsp_cycle, n, cut_value)

S=|R|/(V^beta)

参数	类型	说明
rsp_cycle	any	采样小周期
n	any	整型，当前时间向历史推移N个周期长度作为采样的时间区间(大区间)，与当前时间，周期相关。默认为 1，与市场周期对齐；N为0时，返回最后一个高频时刻
cut_value	float	划分截至比例

返回：float

lnv(rsp_cycle, n, cut_value)

S=|R|/ln(V)

参数	类型	说明
rsp_cycle	any	采样小周期
n	any	整型，当前时间向历史推移N个周期长度作为采样的时间区间(大区间)，与当前时间，周期相关。默认为 1，与市场周期对齐；N为0时，返回最后一个高频时刻
cut_value	float	划分截至比例

返回：float

skewWBuy(rsp_cycle, k, n)

净委买变化率偏度

参数	类型	说明
rsp_cycle	any	采样小周期
k	any	前k档行情，默认为1
n	any	整型，当前时间向历史推移N个周期长度作为采样的时间区间(大区间)，与当前时间，周期相关。默认为 1，与市场周期对齐；N为0时，返回最后一个高频时刻

返回：float

demoSfIntegerBessel2()

sf_IntegerBessel_2()教学函数。整数阶第二类贝塞尔函数，利用和的值可以递推出任意正整数阶第二类Bessel函数的值，这里阶数n=3,变量x=50。

返回：float

demoSfIncompleteGamma()

sf_IncompleteGamma()教学函数。不完全伽马函数，带入a=0.05,x=0.3求函数值。

返回：float

demoSfRealBessel1()

sf_RealBessel_1()教学函数，实数阶第一类贝塞尔函数，带入阶数n=2,x=0.5求函数值。

返回：float

demoSfF()

sf_F()函数教学函数。F分布函数，带入随机变量f=9,自由度n1=2,自由度n2=3求积分值。

返回：float

demoSfT()

sf_T()函数教学函数。T分布函数，带入随机变量t=0.5,自由度n=4求积分值。

返回：float

demoSfSinX()

sf_SinX ()函数教学函数。正弦分布函数，带入随机变量x=14.5求积分值。

返回：float

demoSfIncompleteBeta()

sf_IncompleteBeta()函数教学函数。不完全贝塔函数，带入参a=1,b=2,自变量x=0.2求积分值。

返回：float

demoSfNormal()

sf_Normal()函数教学函数。正态分布函数，带入期望a=3,标准差d=15,随机变量x=-10求积分值。

返回：float

demoSfEllipseX2()

sf_EllipseX_2()函数教学函数。第二类椭圆积分函数，带入变量k=1,椭圆参数=π6求积分值。

返回：float

demoSfEx()

sf_eX()函数教学函数。指数积分函数，带入变量x=1.65求积分值。

返回：float

demoSfIntegerBessel1()

sf_IntegerBessel_1()函数教学函数。整数阶第一类贝塞尔函数，带入阶数n=3,变量x=50求函数值。

返回：float

demoSfBeta()

sf_Beta()函数教学函数。贝塔函数，带入变量x=1.5,y=2.5求积分值。

返回：float

demoSfError()

sf_Error()函数教学函数。误差(概率)函数，带入变量x=0.05求积分值。

返回：float

demoSfEllipseX1()

sf_EllipseX_1()函数教学函数。第一类椭圆积分函数，带入变量k=0.5,椭圆参数=π/2求积分值。

返回：float

demoSfCosX()

sf_CosX()函数教学函数。余弦积分函数，带入随机变量x=14.5求积分值。

返回：float

demoSfRealBessel2()

sf_RealBessel_2 ()函数教学函数。实数阶第二类贝塞尔函数，带入阶数n=2,变量x=0.5求函数值。

返回：float

demoSfGamma()

sf_Gamma()函数教学函数。伽马函数，带入x=1.5求积分值。

返回：float

demoSfX2()

sf_X2()函数教学函数。卡方分布函数，带入自由度n=3,随机变量x=5求积分值。

返回：float

randunid(n, row, col)

产生离散均匀分布的随机数

参数	类型	说明
n	integer	分布参数,整数；
row	integer or array of string	行数或者行名字符串数组
col	integer or array of string	列数或者列名字符串数组

返回：any

示例

return randunid(10, 10, array("a", "b"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randunid compile error or not found
// function:__main__:line 1:instruction:array: function execute error

randhyge(m, k, n, row, col)

产生超几何分布的随机数

参数	类型	说明
m	integer	总体数目,非负整数
k	integer	总体标数目,非负整数
n	integer	抽样数目,非负整数
row	integer or array of string	行数或者行名字符串数组
col	integer or array of string	列数或者列名字符串数组

返回：any

示例

return randhyge(100, 10, 20, 10, array("a", "b"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randhyge compile error or not found
// function:__main__:line 1:instruction:array: function execute error

randpoiss(lambda, row, col)

产生泊松分布的随机数

参数	类型	说明
lambda	real	分布参数,实数
row	integer or array of string	行数或者行名字符串数组
col	integer or array of string	列数或者列名字符串数组

返回：any

示例

return randpoiss(10, 10, array("a", "b"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randpoiss compile error or not found
// function:__main__:line 1:instruction:array: function execute error

binofit(x, n, alpha)

根据样本x，x服从二项分布，估计该分布的参数p

参数	类型	说明
x	array of real	二项分布样本，数字数组
n		试验总量,为大于0的整数；
alpha	real	显著性水平，在0-1之间

返回：any

示例

x := randbino(10, 0.5, 1);
return binofit(x, 10, 0.05);
// 输出：返回p的估计以及在alpha的显著性水平下的区间估计

randunif(a, b, row, col)

产生均匀分布的随机数

参数	类型	说明
a	real	均匀分布的下限,实数
b	real	均匀分布的上限,实数
row	integer or array of string	行数或者行名字符串数组
col	integer or array of string	列数或者列名字符串数组

返回：any

示例

return randunif(1, 10, 10, array("a", "b"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randunif compile error or not found
// function:__main__:line 1:instruction:array: function execute error

sfExppdf(values, lambda_value)

计算指数分布概率密度。

参数	类型	说明
values	array	随机变量序列；标量输入会返回 nil，生成代码时使用数组输入
lambda_value	float	lambda 参数

返回：array

expfit(x, alpha)

根据样本x，x服从指数分布，估计该分布的参数parm

参数	类型	说明
x	array of real	指数分布样本，数字数组
alpha	real	显著性水平，在0-1之间

返回：any

示例

x := randexp(1, 100);
return expfit(x, 0.05);
// 输出：返回parm的估计已经他们的在alpha的显著性水平下的区间估计

randgam(a, b, row, col)

产生伽马分布的随机数

参数	类型	说明
a	real	形状参数,大于0的实数
b	real	尺度参数,大于0的实数
row	integer or array of string	行数或者行名字符串数组
col	integer or array of string	列数或者列名字符串数组

返回：any

示例

return randgam(2, 2, 100, array("a", "b"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randgam compile error or not found
// function:__main__:line 1:instruction:array: function execute error

randt(cv, row, col)

产生学生T分布的随机数

参数	类型	说明
cv	real	学生T分布自由度,实数
row	integer or array of string	行数或者行名字符串数组
col	integer or array of string	列数或者列名字符串数组

返回：any

示例

return randt(30, 10, array("a", "b"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randt compile error or not found
// function:__main__:line 1:instruction:array: function execute error

sfExpcdf(values, lambda_value)

计算指数分布累计分布值。

参数	类型	说明
values	array	随机变量序列；标量输入会返回 nil，生成代码时使用数组输入
lambda_value	float	lambda 参数

返回：array

randf(v1, v2, row, col)

产生F分布的随机数

参数	类型	说明
v1	real	分子自由度,大于0的实数
v2	real	分母自由度,大于0的实数
row	integer or array of string	行数或者行名字符串数组
col	integer or array of string	列数或者列名字符串数组

返回：any

示例

return randf(20, 30, 10, array("a", "b"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randf compile error or not found
// function:__main__:line 1:instruction:array: function execute error

randexp(mu, row, col)

产生指数分布的随机数

参数	类型	说明
mu	real	分布参数,实数,缺省为1
row	integer or array of string	行数或者行名字符串数组
col	integer or array of string	列数或者列名字符串数组

返回：any

示例

return randexp(1, 10, array("a", "b"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randexp compile error or not found
// function:__main__:line 1:instruction:array: function execute error

randch2(cv, row, col)

产生卡方分布的随机数

参数	类型	说明
cv	real	卡方分布自由度,实数
row	integer or array of string	行数或者行名字符串数组
col	integer or array of string	列数或者列名字符串数组

返回：any

示例

return randch2(30, 10, array("a", "b"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randch2 compile error or not found
// function:__main__:line 1:instruction:array: function execute error

sfBetapdf(x, shape_alpha, shape_beta)

计算 Beta 分布概率密度。

参数	类型	说明
x	array	随机变量值
shape_alpha	float	alpha 形状参数
shape_beta	float	beta 形状参数

返回：array

randCauchy(a, b, row, col)

产生柯西的随机数

参数	类型	说明
a	real	位置参数,实数
b	real	尺度参数,大于0的实数
row	integer or array of string	行数或者行名字符串数组
col	integer or array of string	列数或者列名字符串数组

返回：any

示例

return randCauchy(0, 2, 10, array("a", "b"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randCauchy compile error or not found
// function:__main__:line 1:instruction:array: function execute error

randbeta(a, b, row, col)

产生贝塔分布的随机数

参数	类型	说明
a	real	beta分布参数1,实数,大于0
b	real	beta分布参数2,实数,大于0
row	integer or array of string	行数或者行名字符串数组
col	integer or array of string	列数或者列名字符串数组

返回：any

示例

return randbeta(2, 4, 100, array("a", "b"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randbeta compile error or not found
// function:__main__:line 1:instruction:array: function execute error

randrayl(b, row, col)

产生瑞利分布的随机数

参数	类型	说明
b	real	分布参数,实数,缺省为1
row	integer or array of string	行数或者行名字符串数组
col	integer or array of string	列数或者列名字符串数组

返回：any

示例

return randrayl(1, 100, array("a", "b"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randrayl compile error or not found
// function:__main__:line 1:instruction:array: function execute error

randwbl(a, b, row, col)

产生威布尔分布的随机数

参数	类型	说明
a	real	比例参数,实数,大于0
b	real	形状参数,实数,大于0
row	integer or array of string	行数或者行名字符串数组
col	integer or array of string	列数或者列名字符串数组

返回：any

示例

return randwbl(1, 1.5, 100, array("a", "b"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randwbl compile error or not found
// function:__main__:line 1:instruction:array: function execute error

randLaplace(mu, b, row, col)

产生拉普拉斯的随机数

参数	类型	说明
mu	real	位置参数,实数
b	real	尺度参数,大于0的实数
row	integer or array of string	行数或者行名字符串数组
col	integer or array of string	列数或者列名字符串数组

返回：any

示例

return randLaplace(0, 2, 10, array("a", "b"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randLaplace compile error or not found
// function:__main__:line 1:instruction:array: function execute error

sfMvtcdf(lower_bounds, upper_bounds, correlation_matrix, degrees_freedom)

计算多变量 t 分布累计分布值。

参数	类型	说明
lower_bounds	array	下界；传 nil 表示使用默认下界
upper_bounds	array	上界矩阵
correlation_matrix	array	相关系数矩阵
degrees_freedom	float	自由度

返回：array

sfMvncdf(lower_bounds, upper_bounds, mean_values, correlation_matrix)

计算多变量正态分布累计分布值。

参数	类型	说明
lower_bounds	array	下界；传 nil 表示使用默认下界
upper_bounds	array	上界矩阵
mean_values	array	均值；传 nil 表示使用默认均值
correlation_matrix	array	相关系数矩阵

返回：array

norminv(p, mu, sigma)

正态逆函数

参数	类型	说明
p	float | array	正态分布的概率
mu	float	分布的算术平均值
sigma	float	方差

返回：float | array

示例

return norminv(0.15, 0.5, 1); // -0.5364

correlationMatrix(a1, t)

相关系数矩阵求解

参数	类型	说明
a1	array of real
t	real

返回：array

示例

a := rand(4, 3);
return correlationMatrix(a, 1);
// 输出：
// Execute script error at Line:2
// function:__main__:line 2:instruction:usercall:  函数 CorrelationMatrix : 参数不匹配！
// function:__main__:line 2:instruction:usercall: function execute error
// function:__main__:line 2:instruction:usercall: function execute error

covariance()

计算协方差矩阵

返回：any

示例

a := rand(4, 3);
return covariance(a);
// 输出：
// Execute script error at Line:2
// function:__main__:line 2:instruction:usercall: function:covariance compile error or not found
// function:__main__:line 2:instruction:usercall: function execute error

corrPartial(x_values, y_values, z_values, method, tail)

计算偏相关系数；带 tail 时同时返回检验结果。

参数	类型	说明
x_values	array	第一组变量
y_values	array	第二组变量
z_values	array	控制变量
method	any	相关系数计算方式
tail	string	检验方向；常用 "both"、"left"、"right"

返回：array

factor(x, var_value)

对样本数据进行因子分析，分别采用主成分分析法估计因子载荷矩阵（因子载荷矩阵不唯一），方差最大法做载荷矩阵的正交旋转矩阵，回归方法计算因子得分

参数	类型	说明
x	array of real	二维维实数数组，表示样本矩阵；
var_value	real	实数，表示方差贡献率,控制因子个数；

返回：array

示例

// 我们对2010年上证A股的9个财务指标进行因子分析：
// TSL代码：
stockn := getBk("上证A股");
vo := BackUpSystemParameters();
setSysParam(pn_date(), today());
sto := array();
for n_i := 0 to length(stockn)-1 do
begin
setSysParam(pn_stock(), stockn[n_i]);
if isStockGoMarket(intToDate(20011231)) then
sto[length(sto)] := stockn[n_i];
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]: 因子得分，表示各个股票在这三个因子的得分情况，让研究人员更好的做其他分析

corrKendall(x_values, y_values)

计算 Kendall 秩相关系数。

参数	类型	说明
x_values	array	第一组数据
y_values	array	第二组数据

返回：float

histc(a, b)

端点定位频数，判断序列a 中各个元素在b中各个段位中的频数

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

返回：array

示例

a := rand(1000) * 5;
b := array(0, 1, 2, 3, 4, 5);
return histc(a, b);
// 输出：
// Execute script error at Line:3
// function:__main__:line 3:instruction:usercall: function:histc compile error or not found
// function:__main__:line 3:instruction:usercall: function execute error

regressDominFormula(y_values, x_values)

计算回归解释变量的相对重要性。

参数	类型	说明
y_values	array	因变量样本
x_values	array	自变量样本矩阵

返回：array

regressDwTest(residuals)

计算 Durbin-Watson 统计量。

参数	类型	说明
residuals	array	回归残差序列

返回：float

regressMls(y_values, x_values, residuals)

执行最小二乘回归并输出残差。

参数	类型	说明
y_values	array	因变量样本
x_values	array	自变量样本矩阵
residuals	any	接收残差序列

返回：array

regressCmls(y_values, x_values, residuals, constant)

执行带常数项控制的最小二乘回归并输出残差。

参数	类型	说明
y_values	array	因变量样本
x_values	array	自变量样本矩阵
residuals	any	接收残差序列
constant	any	bool

返回：array

regressionOlsNw(y_values, x_values)

执行普通最小二乘回归，并输出 Newey-West 稳健标准误相关结果。

参数	类型	说明
y_values	array	因变量样本
x_values	array	自变量样本矩阵

返回：array

regressTTestRwls(x_values, coefficients, residuals, variable_count, alpha, constant)

执行线性约束加权最小二乘回归的系数 T 检验。

参数	类型	说明
x_values	array	自变量样本
coefficients	array	回归系数
residuals	array	回归残差序列
variable_count	any	自变量数量或自由度相关参数
alpha	float	显著性水平
constant	any	bool

返回：array

regressGrStest(alpha_values, residual_matrix, factor_matrix)

执行 GRS 检验。

参数	类型	说明
alpha_values	array	截距项或 alpha 向量
residual_matrix	array	回归残差矩阵
factor_matrix	array	因子收益或因子暴露矩阵

返回：array

hypothSnuTest(values, mean_value, std_dev, tail, alpha)

执行单个正态总体均值 U 检验。

参数	类型	说明
values	array	样本数据
mean_value	float	原假设均值
std_dev	float	总体标准差
tail	string	检验方向；常用 "both"、"left"、"right"
alpha	float	显著性水平

返回：array

hypothTnuTest(samples, mean_diff, std_devs, tail, alpha, mode)

执行两个正态总体均值差 U 检验。

参数	类型	说明
samples	array	两组样本数据
mean_diff	float	原假设均值差
std_devs	array	两组标准差参数
tail	string	检验方向；常用 "both"、"left"、"right"
alpha	float	显著性水平
mode	any	检验模式参数

返回：array

hypothSndTest(values, variance_value, tail, alpha)

执行单个正态总体方差检验。

参数	类型	说明
values	array	样本数据
variance_value	float	原假设方差
tail	string	检验方向；常用 "both"、"left"、"right"
alpha	float	显著性水平

返回：array

hypothTndTest(samples, tail, alpha)

执行两个正态总体方差检验。

参数	类型	说明
samples	array	两组样本数据
tail	string	检验方向；常用 "both"、"left"、"right"
alpha	float	显著性水平

返回：array

hypothLsuTest(sample_mean, sample_variance, sample_count, mean_value, tail, alpha)

用样本均值、样本方差和样本数量执行单总体均值检验。

参数	类型	说明
sample_mean	float	样本均值
sample_variance	float	样本方差
sample_count	any	样本数量
mean_value	float	原假设均值
tail	string	检验方向；常用 "both"、"left"、"right"
alpha	float	显著性水平

返回：array

anovaSingle(groups, alpha)

执行单因素方差分析。

参数	类型	说明
groups	array	各组观测值
alpha	float	显著性水平

返回：array

anovaTwice(values, alpha, repeat_count)

执行双因素方差分析。

参数	类型	说明
values	array	观测值矩阵
alpha	float	显著性水平
repeat_count	any	每个因素水平组合的重复试验次数

返回：array

anovaBartlett(groups, alpha)

执行 Bartlett 方差齐性检验。

参数	类型	说明
groups	array	各组观测值
alpha	float	显著性水平

返回：array

anovaLevene(groups, alpha)

执行 Levene 方差齐性检验。

参数	类型	说明
groups	array	各组观测值
alpha	float	显著性水平

返回：array

hypothSignTest(values, probability, median_value, tail, alpha)

执行符号检验。

参数	类型	说明
values	array	样本数据
probability	float	原假设成功概率
median_value	float	原假设中位数
tail	string	检验方向；常用 "both"、"left"、"right"
alpha	float	显著性水平

返回：array

hypothPnuTest(samples, mean_diff, std_dev, tail, alpha)

执行配对样本均值差 U 检验。

参数	类型	说明
samples	array	两组配对样本数据
mean_diff	float	原假设均值差
std_dev	float	差值标准差；未知时传 nil
tail	string	检验方向；常用 "both"、"left"、"right"
alpha	float	显著性水平

返回：array

variationCoefficient(x)

变异系数。

参数	类型	说明
x	array	一维数字数组

返回：real

示例

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

selfStdDev(t, rmar)

下方标准差。

参数	类型	说明
t	array	数据表类型，一维数据
rmar	real	实数，最低可接受的收益率(已折算过)

返回：real

示例

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

skew(t, skew)

偏斜度。

参数	类型	说明
t	array	一维数字数组，一维数据
skew	real	实数，返回的偏斜度

返回：any

示例

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

meanAndPopnStdDevWithRate(data, rate, mean, stddev)

带权重总体标准差以及平均值。

参数	类型	说明
data	array	一维数字数组
rate	array	一维数字数组
mean	real	实数，均值，返回值
stddev	real	实数，标准差，返回值

返回：real

示例

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

betaAndAlpha(y, x, beta, alpha)

得到斜率和截距。

参数	类型	说明
y	array	一维数字数组
x	array	一维数字数组
beta	real	实数，斜率，返回值
alpha	real	实数，截距，返回值

返回：void

示例

betaAndAlpha(array(3, 6), array(4, 12), k, b);
return k;
// 返回：0.375

regressionChannel(y, x, nowy, nowx, beta, alpha, top_alpha, bottom_alpha, top, bottom, pos, expectvalue)

回归通道模型。

参数	类型	说明
y	array	一维数字数组，Y坐标数组
x	array	一维数字数组，X坐标数组
nowy	real	实数
nowx	real	实数
beta	real	实数
alpha	real	实数
top_alpha	real	实数
bottom_alpha	real	实数
top	real	实数
bottom	real	实数
pos	real	实数
expectvalue	real	实数，预期值(回归值)

返回：real

示例

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

nanMean(a)

计算含Nan一维数组的算术平均值

参数	类型	说明
a	array	一维数字数组

返回：real

示例

a := array(5, 6, 8, nan);
return nanMean(a);
// 结果：6.33

nanSum(a)

计算含Nan一维数组的总和

参数	类型	说明
a	array	一维数字数组

返回：real

示例

a := array(5, 6, 8, nan);
return nanSum(a);
// 结果：19

nanStd(a)

计算含Nan一维数组的标准差的估计（样本标准差）

参数	类型	说明
a	array	一维数字数组

返回：real

示例

a := array(5, 6, 8, nan);
return nanStd(a);
// 结果：1.53

nanVariance(a)

计算含Nan一维数组的方差的估计（样本方差）

参数	类型	说明
a	array	一维数字数组

返回：real

示例

a := array(5, 6, 8, nan);
return nanVariance(a);
// 结果：2.33

nanPopnStd(a)

计算含Nan一维数组的总体标准差

参数	类型	说明
a	array	一维数字数组

返回：real

示例

a := array(5, 6, 8, nan);
return nanPopnStd(a);
// 结果：1.25

correlpaired(a, b)

功能：计算 a 的每一列与 b 的每一列之间的相关系数矩阵，

参数	类型	说明
a	array	一维数字数组,
b	array	一维数字数组,

返回：array

示例

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

correlpairedSide(a, dir_type)

功能：计算 a 的每两列之间符合对应过滤条件的相关系数矩阵， 1) +-相关系数 ：将 a <0 的元素替换为0 ，b>0的元素替换为0,计算相关系数 2) 同向相关系数 ：将 a 与 b 非同向（乘积<0）的元素替换为0，计算相关系数 场景支持同 correlpaired 内部强制 a 转化为fmarray进行计算

参数	类型	说明
a	array	一维数字数组,
dir_type	any	用户自定义,方向类型

返回：array

expdMax(r)

统计数组累计到当前行的最大值序列

参数	类型	说明
r	array of real	数组，一维或二维（此时按列统计）数字数组，也可以为二维数据表

返回：array

示例

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

expdMin(r)

统计数组累积到当前行的最小值序列

参数	类型	说明
r	array of real	数组，一维或二维（此时按列统计）数字数组，也可以为二维数据表

返回：array

示例

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

expdSum(r)

返回数组累积到当前行的求和序列

参数	类型	说明
r	array of real	数组，一维或二维（此时按列统计）数字数组，也可以为二维数据表

返回：array

示例

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

expdProduct(r)

返回数组累积到当前行的累乘序列

参数	类型	说明
r	array of real	数组，一维或二维（此时按列统计）数字数组，也可以为二维数据表

返回：array

示例

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

expdVar(r, ddof)

返回数组累积到当前行的方差序列

参数	类型	说明
r	array of real	数组，一维或二维（此时按列统计）数字数组，也可以为二维数据表
ddof	integer	整型，方差选项，取值如下

返回：array

示例

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

expdStd(r, ddof)

返回数组累积到当前行的标准差序列

参数	类型	说明
r	array of real	数组，一维或二维（此时按列统计）数字数组，也可以为二维数据表
ddof	integer	整型，标准差选项，取值如下

返回：array

示例

r := array(-1, 2, -3, 9);
return expdStd (r, 0); // array(0,1.5,2.05,4.55)

nanPopnVariance(a)

计算含Nan一维数组的总体方差

参数	类型	说明
a	array	一维数字数组

返回：real

示例

a := array(5, 6, 8, nan);
return popnVariance(a);
// 结果：1.56

nanRankArr(a, f_name, sortorder)

1、返回一维数组中的每个值在一维数组中的排位

参数	类型	说明
a	array	数字数组，待计算的数组
f_name	string	字符串，字段名，默认为空
sortorder	bool	排序方向，默认为1

返回：array

示例

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, f_name)

1、返回一维数组中的每个值在一维数组中的百分比排名

参数	类型	说明
a	array	数字数组，待计算的数组
f_name	string	字符串，字段名，默认为空

返回：array

示例

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)

sfSinX(x, v)

正弦积分的定义为

参数	类型	说明
x	float	实型变量。自变量
v	float	实型变量，返回的结果

返回：any

sfCosX(x, v)

余弦积分的定义为

参数	类型	说明
x	float	实型变量。自变量
v	float	实型变量，返回的结果

返回：any

sfEx(x, v)

指数积分的定义为

参数	类型	说明
x	float	实型变量。自变量
v	float	实型变量，返回的结果

返回：any

hist(a, b, center)

统计A的频数分布

参数	类型	说明
a	array of real	参与进行频数分布统计的数据
b	integer or array of real	频数分布分组的依据,可以是整数表示分成多少组，也可以是每组的中心（升序）
center	array of real	变参返回每组的中心

返回：any

示例

a := randnorm(0, 1, 10000);
return hist(a, 30, center);
// 输出：，一维数字数组

sfGamma(x, v)

计算伽马(Gamma)函数的数值 伽马(Gamma)函数的定义为

参数	类型	说明
x	float	实型变量。要求X>=0
v	float	实型变量，返回的结果

返回：any

sfBeta(x, y, v)

计算贝塔函数(Beta)的数值，贝塔函数(Beta)的定义为 或者：

参数	类型	说明
x	float	实型变量。要求X>=0
y	float	实型变量。要求Y>=0
v	float	实型变量，返回的结果

返回：any

sfError(x, v)

误差函数也称为概率函数，其定义为

参数	类型	说明
x	float	实型变量。要求X>=0
v	float	实型变量，返回的结果

返回：any

sfNormal(x, a, d)

正态分布函数的定义为 其中： (1)a为随机变量的数学期望（平均值） (2)σ为随机变量的标准差

参数	类型	说明
x	float	实型变量。随机变量值
a	float	实型变量。数学期望值
d	float	实型变量。标准值

返回：any

sfNormalinv(data, m, s, v)

正态分布的分布逆函数，输入分布函数或者累计概率值，得到随机变量值

参数	类型	说明
data	array	分布函数或者累计概率值，可以使用实数，也可以是一个实数数组
m	float	正态分布参数，均值，实数类型
s	float	正态分布参数，标准差，实数类型
v	array	随机变量值，变参返回。

返回：any

sfNormalinv2(data, v)

标准正态分布的分布逆函数，输入分布函数或者累计概率值，得到随机变量值

参数	类型	说明
data	array	分布函数或者累计概率值，可以使用实数，也可以是一个实数数组
v	array	随机变量值，变参返回。

返回：any

sfNormpdf(x, mu, sigma, v)

正态分布的概率密度函数，输入随机变量，返回随机变量对应的概率密度

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
mu	float	正态分布参数，均值，实数类型
sigma	float	正态分布参数，标准差，实数类型
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfNormcdf(x, mu, sigma, v)

计算随机变量在正态分布, 均值为mu，方差为sigma条件下的分布函数,返回分布函数值。

参数	类型	说明
x	array	:随机变量，可以是实数，也可以是一个实数二维数组
mu	float	正态分布的均值，实数类型
sigma	float	正态分布的标准差，大于0的实数
v	array	变参返回x对应的正态分布函数的值，实数或二维数组

返回：any

sfNorminv(y, mu, sigma, x)

正态分布的分布逆函数，输入分布函数或者累计概率值，返回随机变量值

参数	类型	说明
y	array	:分布函数或者累计概率值，可以使用实数，也可以是一个实数数组
mu	float	正态分布参数，均值，实数类型
sigma	float	正态分布参数，标准差，实数类型
x	array	变参返回，该函数也支持直接返回，类型和y一样

返回：any

randnorm(mu, sigma, row, col)

产生正态分布的随机数

参数	类型	说明
mu	real	正态分布参数，均值，实数类型
sigma	real	正态分布参数，标准差，实数类型
row	integer or array of string	行数或者行名字符串数组
col	integer or array of string	列数或者列名字符串数组

返回：any

示例

return randnorm(0, 1, 10, array("a", "b"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randnorm compile error or not found
// function:__main__:line 1:instruction:array: function execute error

normfit(x, alpha)

根据样本x，x服从正态分布，估计该正态分布的两个参数ma,sigma

参数	类型	说明
x	array of real	正态分布样本，一维数字数组
alpha	real	显著性水平，在0-1之间

返回：any

示例

x := randnorm(0, 1, 10, array("a", "b"));
return normfit(x, 0.05);
// 输出：返回mu, sigma的估计以及他们的在alpha的显著性水平下的区间估计

sfUnidpdf(x, n, v)

离散均匀分布的概率函数，输入随机变量，返回随机变量对应的概率

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
n	any	分布参数,整数；
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfUnidcdf(x, n, v)

离散均匀分布的累计概率函数，输入随机变量，返回随机变量对应的累计概率

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
n	any	分布参数,整数；
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfUnidinv(y, n, x)

离散均匀分布的分布逆函数，输入累计概率值，返回随机变量值

参数	类型	说明
y	array	:分布函数或者累计概率值，可以使用实数，也可以是一个实数数组
n	any	分布参数,整数
x	array	变参返回，该函数也支持直接返回，类型和y一样

返回：any

sfGeopdf(x, p, v)

几何分布的概率函数，输入随机变量，返回随机变量对应的概率

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
p	float	一次试验成功的概率,为0,1之间的实数
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfGeocdf(x, p, v)

几何分布的累计概率函数，输入随机变量，返回随机变量对应的累计概率

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
p	float	p:一次试验成功的概率,为0,1之间的实数
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfGeoinv(y, p, x)

几何分布的分布逆函数，输入累计概率值，返回随机变量值

参数	类型	说明
y	array	:分布函数或者累计概率值，可以使用实数，也可以是一个实数数组
p	float	一次试验成功的概率,为0,1之间的实数
x	array	变参返回，该函数也支持直接返回，类型和y一样

返回：any

randgeo(n, p, row, col)

产生几何分布的随机数

参数	类型	说明
n		分布参数,整数；
p	real	p:一次试验成功的概率,为0,1之间的实数；
row	integer or array of string	行数或者行名字符串数组
col	integer or array of string	列数或者列名字符串数组

返回：any

示例

return randgeo(10, 10, array("a", "b"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randgeo compile error or not found
// function:__main__:line 1:instruction:array: function execute error

sfHygepdf(x, m, k, n, v)

超几何分布的概率函数，输入随机变量，返回随机变量对应的概率

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
m	any	总体数目,非负整数
k	any	总体标数目,非负整数
n	any	抽样数目,非负整数
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfHygecdf(x, m, k, n, v)

超几何分布的累计概率函数，输入随机变量，返回随机变量对应的累计概率

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
m	any	总体数目,非负整数
k	any	总体标数目,非负整数
n	any	抽样数目,非负整数
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfHygeinv(y, m, k, n, x)

超几何分布的分布逆函数，输入累计概率值，返回随机变量值

参数	类型	说明
y	array	:分布函数或者累计概率值，可以使用实数，也可以是一个实数数组
m	any	总体数目,非负整数
k	any	总体标数目,非负整数
n	any	抽样数目,非负整数
x	array	变参返回，该函数也支持直接返回，类型和y一样

返回：any

sfBinopdf(x, n, p, v)

二项分布的概率函数，输入随机变量，返回随机变量对应的概率

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
n	any	试验总量,为大于0的整数；
p	float	一次试验成功的概率,为0,1之间的实数
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfBinocdf(x, n, p, v)

二项分布的累计概率函数，输入随机变量，返回随机变量对应的累计概率

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
n	any	试验总量,为大于0的整数；
p	float	一次试验成功的概率,为0,1之间的实数
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfBinoinv(y, n, p, x)

二项分布的分布逆函数，输入累计概率值，返回随机变量值

参数	类型	说明
y	array	:分布函数或者累计概率值，可以使用实数，也可以是一个实数数组
n	any	试验总量,为大于0的整数；
p	float	一次试验成功的概率,为0,1之间的实数
x	array	变参返回，该函数也支持直接返回，类型和y一样

返回：any

randbino(n, p, row, col)

产生二项分布的随机数

参数	类型	说明
n	integer	试验总量,为大于0的整数；
p	real	一次试验成功的概率,为0,1之间的实数
row	integer or array of string	行数或者行名字符串数组
col	integer or array of string	列数或者列名字符串数组

返回：any

示例

return randbino(10, 0.5, 10, array("a", "b"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randbino compile error or not found
// function:__main__:line 1:instruction:array: function execute error

sfNbinpdf(x, r, p, v)

负二项分布的概率函数，输入随机变量，返回随机变量对应的概率

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
r	any	试验成功的次数,为大于0的整数
p	float	一次试验成功的概率,为0,1之间的实数
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfNbincdf(x, r, p, v)

负二项分布的累计概率函数，输入随机变量，返回随机变量对应的累计概率

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
r	any	试验成功的次数,为大于0的整数
p	float	一次试验成功的概率,为0,1之间的实数
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfNbininv(y, r, p, x)

负二项分布的分布逆函数，输入累计概率值，返回随机变量值

参数	类型	说明
y	array	:分布函数或者累计概率值，可以使用实数，也可以是一个实数数组
r	any	试验成功的次数,为大于0的整数
p	float	一次试验成功的概率,为0,1之间的实数
x	array	变参返回，该函数也支持直接返回，类型和y一样

返回：any

randnbin(r, p, row, col)

产生负二项分布的随机数

参数	类型	说明
r	integer	试验成功的次数,为大于0的整数
p	real	一次试验成功的概率,为0,1之间的实数
row	integer or array of string	行数或者行名字符串数组
col	integer or array of string	列数或者列名字符串数组

返回：any

示例

return randnbin(10, 0.5, 10, array("a", "b"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randnbin compile error or not found
// function:__main__:line 1:instruction:array: function execute error

sfUnifpdf(x, a, b, v)

均匀分布的密度函数，输入随机变量，返回随机变量对应的密度函数值

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
a	float	均匀分布的下限,实数
b	float	均匀分布的上限,实数
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfUnifcdf(x, a, b, v)

均匀分布的分布函数，输入随机变量，返回随机变量对应的分布函数值

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
a	float	均匀分布的下限,实数
b	float	均匀分布的上限,实数
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfUnifinv(y, a, b, x)

均匀分布的分布逆函数，输入分布函数值，返回随机变量值

参数	类型	说明
y	array	:分布函数或者累计概率值，可以使用实数，也可以是一个实数数组
a	float	均匀分布的下限,实数
b	float	均匀分布的上限,实数
x	array	变参返回，该函数也支持直接返回，类型和y一样

返回：any

uniffit(x, alpha)

根据样本x，x服从均匀分布，估计该分布的两个参数a,b

参数	类型	说明
x	array of real	均匀分布样本，数字数组
alpha	real	显著性水平，在0-1之间

返回：any

示例

x := randunif(1, 10, 100);
return uniffit(x, 0.05);
// 输出：返回a, b的估计以及他们的在alpha的显著性水平下的区间估计

sfPoisspdf(x, lambda, v)

泊松分布的密度函数，输入随机变量，返回随机变量对应的密度函数值

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
lambda	float	分布参数,实数
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfPoisscdf(x, lambda, v)

泊松分布的分布函数，输入随机变量，返回随机变量对应的分布函数值

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
lambda	float	分布参数,实数
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfPoissinv(y, lambda, x)

泊松分布的分布逆函数，输入分布函数值，返回随机变量值

参数	类型	说明
y	array	:分布函数或者累计概率值，可以使用实数，也可以是一个实数数组
lambda	float	分布参数,实数
x	array	变参返回，该函数也支持直接返回，类型和y一样

返回：any

poissfit(x, alpha)

根据样本x，x服从泊松分布，估计该分布的参数lambda

参数	类型	说明
x	array of real	泊松分布样本，数字数组
alpha	real	显著性水平，在0-1之间

返回：any

示例

x := randpoiss(1, 100);
return poissfit(x, 0.05);
// 输出：返回lambda的估计以及他们的在alpha的显著性水平下的区间估计

sfExpinv(y, mu, x)

指数分布的分布逆函数，输入分布函数值，返回随机变量值

参数	类型	说明
y	array	:分布函数或者累计概率值，可以使用实数，也可以是一个实数数组
mu	float	分布参数,实数,缺省为1
x	array	变参返回，该函数也支持直接返回，类型和y一样

返回：any

sfCh2Pdf(x, cv, v)

卡方分布的密度函数，输入随机变量，返回随机变量对应的密度函数值

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
cv	float	卡方分布自由度,实数
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfCh2Cdf(x, cv, v)

卡方分布的分布函数，输入随机变量，返回随机变量对应的分布函数值

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
cv	float	卡方分布自由度,实数
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfCh2Inv(y, cv, x, return_value)

卡方分布的分布逆函数，输入分布函数值，返回随机变量值

参数	类型	说明
y	any	:分布函数或者累计概率值，可以使用实数，也可以是一个实数数组
cv	float	卡方分布自由度,实数
x	any	可选，输出参数，随机变量值，类型和y一样
return_value	any	返回随机变量值，类型和y一样

返回：array

sfTpdf(x, cv, v)

学生T分布的密度函数，输入随机变量，返回随机变量对应的密度函数值

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
cv	float	学生T分布自由度,实数
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfTcdf(x, cv, v)

学生T分布的分布函数，输入随机变量，返回随机变量对应的分布函数值

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
cv	float	学生T分布自由度,实数
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfTinv1(y, cv, x)

学生T分布的分布逆函数，输入分布函数值，返回随机变量值

参数	类型	说明
y	array	:分布函数或者累计概率值，可以使用实数，也可以是一个实数数组
cv	float	学生T分布自由度,实数
x	array	变参返回，该函数也支持直接返回，类型和y一样

返回：any

sfTinv(data, n, v)

T分布的分布逆函数，输入分布函数或者累计概率值，返回随机变量值

参数	类型	说明
data	array	分布函数或者累计概率值，可以使用实数，也可以是一个实数数组。
n	any	整数，自由度。
v	array	实数，随机变量值，变参返回。

返回：any

sfFinv(data, n, n1, v)

F分布的分布逆函数，输入分布函数或者累计概率值，返回随机变量值

参数	类型	说明
data	array	分布函数或者累计概率值，可以使用实数，也可以是一个实数数组。
n	any	整数，分子自由度。
n1	any	整数，分母自由度。
v	array	实数，随机变量值，变参返回。

返回：any

sfX2Inv(data, n, v)

卡方分布的分布逆函数，输入分布函数或者累计概率值，返回随机变量值

参数	类型	说明
data	array	分布函数或者累计概率值，可以使用实数，也可以是一个实数数组。
n	any	自由度。
v	array	随机变量值，变参返回。

返回：any

sfFpdf(x, v1, v2, v)

F分布的密度函数，输入随机变量，返回随机变量对应的密度函数值

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
v1	float	分子自由度,大于0的实数
v2	float	分母自由度,大于0的实数
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfFcdf(x, v1, v2, v)

F分布的分布函数，输入随机变量，返回随机变量对应的分布函数值

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
v1	float	分子自由度,大于0的实数
v2	float	分母自由度,大于0的实数
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfFinv1(y, v1, v2, x)

F分布的分布逆函数，输入分布函数值，返回随机变量值

参数	类型	说明
y	array	分布函数或者累计概率值，可以使用实数，也可以是一个实数数组
v1	float	分子自由度,大于0的实数
v2	float	分母自由度,大于0的实数
x	array	变参返回，该函数也支持直接返回，类型和y一样

返回：array

sfGampdf(x, a, b, v)

伽马分布的密度函数，输入随机变量，返回随机变量对应的密度函数值

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
a	float	形状参数,大于0的实数
b	float	尺度参数,大于0的实数
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfGamcdf(x, a, b, v)

伽马分布的分布函数，输入随机变量，返回随机变量对应的分布函数值

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
a	float	形状参数,大于0的实数
b	float	尺度参数,大于0的实数
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfGaminv(y, a, b, x)

伽马分布的分布逆函数，输入分布函数值，返回随机变量值

参数	类型	说明
y	array	:分布函数或者累计概率值，可以使用实数，也可以是一个实数数组
a	float	形状参数,大于0的实数
b	float	尺度参数,大于0的实数
x	array	变参返回，该函数也支持直接返回，类型和y一样

返回：any

sfGammainv(probability, alpha, v)

标准gamma分布的逆函数，输入分布函数或者累计概率值，返回随机变量值。功能等同于sf_gaminv(Probability, Alpha,1,v)。

参数	类型	说明
probability	any	分布函数或者累计概率值，可以使用实数，也可以是一个实数数组。
alpha	any	Alpha分布参数。
v	any	随机变量值，变参返回

返回：any

sfBetacdf(x, a, b, v)

贝塔分布的分布函数，输入随机变量，返回随机变量对应的分布函数值

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
a	float	beta分布参数1,实数,大于0
b	float	beta分布参数2,实数,大于0
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfBetainv(y, a, b, x)

贝塔分布的分布逆函数，输入分布函数值，输出随机变量值

参数	类型	说明
y	array	:分布函数或者累计概率值，可以使用实数，也可以是一个实数数组
a	float	beta分布参数1,实数,大于0
b	float	beta分布参数2,实数,大于0
x	array	变参返回，类型和y一样

返回：any

sfRaylpdf(x, b, v)

瑞利分布的密度函数，输入随机变量，返回随机变量对应的密度函数值

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
b	float	分布参数,实数,缺省为1
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfRaylcdf(x, b, v)

瑞利分布的分布函数，输入随机变量，返回随机变量对应的分布函数值

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
b	float	分布参数,实数,缺省为1
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfRaylinv(y, b, x)

瑞利分布的分布逆函数，输入分布函数值，返回随机变量值

参数	类型	说明
y	array	:分布函数或者累计概率值，可以使用实数，也可以是一个实数数组
b	float	分布参数,实数,缺省为1
x	array	变参返回，该函数也支持直接返回，类型和y一样

返回：any

sfWblpdf(x, a, b, v)

威布尔分布的密度函数，输入随机变量，返回随机变量对应的密度函数值

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
a	float	比例参数,实数,大于0
b	float	形状参数,实数,大于0
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfWblcdf(x, a, b, v)

威布尔分布的分布函数，输入随机变量，返回随机变量对应的分布函数值

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
a	float	比例参数,实数,大于0
b	float	形状参数,实数,大于0
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfWblinv(y, a, b, x)

威布尔分布的分布逆函数，输入分布函数值，返回随机变量值

参数	类型	说明
y	array	:分布函数或者累计概率值，可以使用实数，也可以是一个实数数组
a	float	比例参数,实数,大于0
b	float	形状参数,实数,大于0
x	array	变参返回，该函数也支持直接返回，类型和y一样

返回：any

sfLognpdf(x, mu, sigma, v)

对数正态分布的概率密度函数，输入随机变量，返回随机变量对应的概率密度

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
mu	float	对数正态分布参数，均值，实数类型
sigma	float	对数正态分布参数，标准差，实数类型
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfLogncdf(x, mu, sigma, v)

对数正态分布的累计概率或者分布函数，输入随机变量，返回随机变量对应的累计概率，或者分布函数值

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
mu	float	对数正态分布参数，均值，实数类型
sigma	float	对数正态分布参数，标准差，实数类型
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfLogninv(y, mu, sigma, x)

对数正态分布的分布逆函数，输入分布函数或者累计概率值，返回随机变量值

参数	类型	说明
y	array	:分布函数或者累计概率值，可以使用实数，也可以是一个实数数组
mu	float	对数正态分布参数，均值，实数类型
sigma	float	对数正态分布参数，标准差，实数类型
x	array	变参返回，该函数也支持直接返回，类型和y一样

返回：any

randlogn(mu, sigma, row, col)

产生对数正态分布的随机数

参数	类型	说明
mu	real	对数正态分布参数，均值，实数类型
sigma	real	对数正态分布参数，标准差，实数类型
row	integer or array of string	行数或者行名字符串数组
col	integer or array of string	列数或者列名字符串数组

返回：any

示例

return randlogn(0, 1, 10, array("a", "b"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randlogn compile error or not found
// function:__main__:line 1:instruction:array: function execute error

sfLaplacepdf(x, mu, b, v)

拉普拉斯的概率密度函数，输入随机变量，返回随机变量对应的概率密度

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
mu	float	位置参数,实数
b	float	尺度参数,大于0的实数
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfLaplacecdf(x, mu, b, v)

拉普拉斯的累计概率或者分布函数，输入随机变量，返回随机变量对应的累计概率，或者分布函数值

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
mu	float	位置参数,实数
b	float	尺度参数,大于0的实数
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfLaplaceinv(y, mu, b, x)

拉普拉斯的分布逆函数，输入分布函数或者累计概率值，返回随机变量值

参数	类型	说明
y	array	:分布函数或者累计概率值，可以使用实数，也可以是一个实数数组
mu	float	位置参数,实数
b	float	尺度参数,大于0的实数
x	array	变参返回，该函数也支持直接返回，类型和y一样

返回：any

sfCauchypdf(x, a, b, v)

柯西的概率密度函数，输入随机变量，返回随机变量对应的概率密度

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
a	float	位置参数,实数
b	float	尺度参数,大于0的实数
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfCauchycdf(x, a, b, v)

柯西的累计概率或者分布函数，输入随机变量，返回随机变量对应的累计概率，或者分布函数值

参数	类型	说明
x	array	:随机变量，可以使用实数，也可以是一个实数数组
a	float	位置参数,实数
b	float	尺度参数,大于0的实数
v	array	变参返回，该函数也支持直接返回，类型和x一样

返回：any

sfCauchyinv(y, a, b, x)

柯西的分布逆函数，输入分布函数或者累计概率值，返回随机变量值

参数	类型	说明
y	array	:分布函数或者累计概率值，可以使用实数，也可以是一个实数数组
a	float	位置参数,实数
b	float	尺度参数,大于0的实数
x	array	变参返回，该函数也支持直接返回，类型和y一样

返回：any

sfBetainv1(y, a, b)

贝塔分布的分布逆函数，输入分布函数值，返回随机变量值。功能与sf_betainv一致，输出接口不一样。

参数	类型	说明
y	array	分布函数或者累计概率值，可以使用实数，也可以是一个实数数组
a	float	beta分布参数1,实数,大于0
b	float	beta分布参数2,实数,大于0

返回：array

mvtcdfqmc(a, b, rho, nu, options, funevals)

中间函数，采用蒙特卡洛计算多元t分布，估计概率P值以及误差

参数	类型	说明
a	array	数组，下限，可省略，默认为负无穷
b	array	数组，下限或实际需计算分布的样本值，不可省略
rho	array	数组，相关系数矩阵
nu	float	实数，自由度
options	array	数组，规划条件设置
funevals	array	线性回归的结果条件

返回：array

示例

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

sfCopulacdf(x, copula_type, rho, alpha, options)

估计多元函数分布值

参数	类型	说明
x	array	数组，样本值为均匀分布需要在[0,1]区间内，至少2维
copula_type	string	字符串，分布函数类型:；椭圆族:gaussian、t，支持多维；阿基米德族:clayton、frank、gumbel，目前仅支持二维
rho	array	数组，相关系数矩阵，d*d
alpha	float	实数，参数估计值，t分布时为自由度，二元阿基米德分布时为估值参数,默认1;；clayton:[0,∞)； frank:(-∞,∞)；gumbel:[1,∞)
options	array	数组，估计规划条件，可为空

返回：array

sfCopulafit(x, copula_type, method, options)

估计多元分布相关系数矩阵

参数	类型	说明
x	array	数组，样本值为均匀分布需要在[0,1]区间内，至少2维
copula_type	string	字符串，分布函数类型:；椭圆族:gaussian、t，支持多维；阿基米德族:clayton、frank、gumbel，目前仅支持二维
method	string	字符串，极大似然估计方法(多元分布时有效)；ML —最大似然估计 （默认）；AML —调整的似然估计，性能上比MLE快，但不适用于中小样本量
options	array	数组，估计规划条件，可为空

返回：array

randCopula(copula_type, rho, v, n)

生成服从copula分布的随机数

参数	类型	说明
copula_type	string	字符串，分布函数类型:gaussian、t、clayton、frank、gumbel
rho	array	数组，协方差矩阵，对阿基米德族(clayton、frank、gumbel分布)为空
v	float	实数，对t分布为自由度；对阿基米德族(clayton、frank、gumbel分布)为参数估计值，且其
n	integer	整数，产生随机数长度

返回：array

示例

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

sfExp(x, mu, v)

指数分布累计概率

参数	类型	说明
x	array	随机变量，可以使用实数，也可以是一个实数数组
mu	float	分布参数
v	array	返回值

返回：array

estimateSnu(x, d, alpha, tail)

在1-alpha置信水平下，分为标准差未知和已知两种情况求单个正态总体均值的置信区间（或下置信区间，上置信区间）。

参数	类型	说明
x	array	样本序列，一维数组
d	float	正态总体的标准差，若未知，则输入nil，实数
alpha	float	显著性水平，实数，在0,1之间
tail	string	求取置信区间类型，字符串，取both,left,right，缺省取both

返回：array

estimateTnu(x, d, alpha, tail, equal)

在1-alpha置信水平下，分为标准差未知和已知两种情况求两个正态总体均值差的置信区间（或下置信区间，上置信区间）;

参数	类型	说明
x	array	样本序列,含两行的二维数字数组，每行为一个样本
d	array	正态总体的标准差数组，若未知，则输入array(nil,nil)，为一维数组类型
alpha	float	显著性水平,实数，在0,1之间
tail	string	求取置信区间类型，字符串，取both,left,right，缺省取both
equal	bool	当标准差未知时，方差是否相等，布尔型

返回：array

estimateSnd(x, alpha, tail)

在1-alpha置信水平下，求单个正态总体方差的置信区间（或下置信区间，上置信区间）

参数	类型	说明
x	array	样本序列，一维数组
alpha	float	显著性水平，实数，在0,1之间
tail	string	求取置信区间类型，字符串，取both,left,right，缺省取both

返回：array

estimateTnd(x, alpha, tail)

在1-alpha置信水平下，求两个正态总体方差之比的置信区间（或下置信区间，上置信区间）

参数	类型	说明
x	array	样本序列,含两行的二维数字数组，每行为一个样本
alpha	float	显著性水平,实数，在0,1之间
tail	string	求取置信区间类型，字符串，取both,left,right，缺省取both

返回：array

estimateSp(mx, alpha, tail)

在1-alpha置信水平下，求比率或说概率的置信区间（或下置信区间，上置信区间）；

参数	类型	说明
mx	float	频率，实数；n;样本容量，整数
alpha	float	显著性水平,实数，在0,1之间
tail	string	求取置信区间类型，字符串，取both,left,right，缺省取both

返回：array

estimateTp(p, alpha, tail)

在1-alpha置信水平下，求两个总体的比率或说概率差的置信区间（或下置信区间，上置信区间）

参数	类型	说明
p	array	频率数组；n;样本容量数组，一维数组
alpha	float	显著性水平,实数，在0,1之间
tail	string	求取置信区间类型，字符串，取both,left,right，缺省取both

返回：array

hypothTailRes(sta, v, tail, alpha)

根据tail的取值，进行单侧和双侧检验，原理是根据检验统计量计算P值，若alpha>p，则拒绝原假设，若alpha<p，则接受原假设；最后返回假设检验的结果。原假设分别是：

参数	类型	说明
sta	float	统计量的值，为实数类型
v	float	整体分布的p分位数，1-v为检验的p值，为实数类型
tail	string	取值为both、left和right
alpha	float	显著性水平，实数或整数，在0-1之间；返回结果:；ret["Statistic"]:假设检验统计量；ret["P-Value "]:假设检验的P值；ret["Hypothesis "]:是否接受原假设

返回：array

normPlot(x, return_type)

基于正态概率的正态性检验, ReturnType为0时返回我们常说的QQ图的散点数据，为1返回衡量散点与直线拟合程度的可决系数

参数	类型	说明
x	array of real	检验样本序列，为一维数组类型
return_type	integer	返回类型选项，为0返回散点数据，为1返回直线拟合的可决系数。缺省为0

返回：array

示例

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

hypothKstest(data, tail, alpha, cdf)

在alpha的显著性水平下进行ks检验，检验序列是否服从cdf这种分布（缺省为标准正态分布），Hypothesis为测试结果,若Hypothesis=1,则认为服从;Hypothesis=0,可以认为不服从该分布

参数	类型	说明
data	array	样本数据，一维数字数组
tail	string	检验类型，字符串类型，必须包含在array("both","left","right")中
alpha	float	显著性水平，实数或整数，在01之间
cdf	array	分布的累计概率分布，二维数字数组，第一列为随机变量，第二列为其对应的分布函数值，缺省为标准正态分布；返回结果:；ret["statistical"]:KS统计量；ret["criticalValue"]:KS检验的临界值；ret["P-Value"]:KS检验的P值；ret["Hypothesis"]:是否服从设定的分布

返回：array

hypothLillietest(data, alpha, distr)

在alpha的显著性水平下进行lillietest检验，检验序列是否服从正态分布或对数分布（分布参数估计出来），Hypothesis为测试结果,若Hypothesis=1,则认为服从;Hypothesis=0,可以认为不服从该分布

参数	类型	说明
data	array	样本数据，一维数字数组
alpha	float	显著性水平，实数或整数，在01之间
distr	string	分布函数类型，字符串数据，有"norm"、"exp"；返回结果:；ret[""kstat"]:统计量；ret["cv"]:检验统计量的临界值；ret["P-Value"]:检验的P值；ret["Hypothesis"]:是否服从设定的分布

返回：array

hypothIndepTest(x, alpha)

列联表检验法检验两个随机变量的独立性检验，返回的结果是一个数组，第一个数为统计值，二为p值，三为原假设的值（0表示拒绝，1表示接受） 模型表达： 原假设：H0:X 与Y 相互独立 检验统计量： 其中 ，，

参数	类型	说明
x	array	样本矩阵，为二维数组类型
alpha	float	显著性水平，实数或整数，在01之间

返回：array

hypothKruskalWallis(x, alpha)

两个或多个随机变量的独立性检验。本模型原假设为各随机变量相互独立。

参数	类型	说明
x	array	样本矩阵，为二维数组类型，每行为一个样本
alpha	float	显著性水平，实数或整数，在01之间

返回：array

hypothWilcoxonTest(x, m0, tail, alpha)

非参数检验-Wilcoxon符号秩检验。单样本Wilcoxon符号秩检验 原理：把观测值和零假设的中心位置之差的绝对值的秩按照不同的符号相加作为其检验统计量。 此检验假定样本来自于连续对称总体。 计算步骤： 1、计算样本点到检验值的距离； 2、对上述距离的绝对值进行排序并计算秩，对相同的样本点则取平均秩； 3、分别计算大于检验值与小于检验值样本的秩和； 4、对得到的统计量计算p值

参数	类型	说明
x	array	样本序列，为一维数字数组类型
m0	float	检验值，为实数类型
tail	string	假设检验的三种类型，both（双侧检验），left（左侧检验），right（右侧检验），为字符串类型
alpha	float	显著性水平，在0-1之间，为实数类型

返回：array

hypothMcNemarTest(x, alpha)

非参数检验-McNemar检验。 对配对样本进行McNemar检验 McNemar检验以研究对象自身为对照，检验其两组样本变化是否显著 要求待检验的两组样本的观察值是二分类数据 检验统计量服从卡方分布

参数	类型	说明
x	array	样本统计列联表，为二维数字数组类型
alpha	float	显著性水平，在0-1之间，为实数类型

返回：array

hypothPWilcoxonTest(x, m0, tail, alpha)

非参数检验-配对样本Wilcoxon符号秩检验,配对样本的Wilcoxon符号秩检验 要求样本矩阵中两个样本是配对出现的 可以按照实际需求选择双侧或单侧检验

参数	类型	说明
x	array	一维数字数组,样本矩阵
m0	float	实数,检验值
tail	string	字符串,双侧检验 or 左侧检验 or 右侧检验
alpha	float	实数,显著性水平

返回：array

corr(a, _type, tail)

计算相关系数矩阵及其检验P值

参数	类型	说明
a	array of real	样本数据观测矩阵，二维数字数组
_type	integer	1:pearson相关；2:Kendall等级相关；3:Spearman秩相关
tail	string	假设检验的三种类型，字符串，取值为both、left和right，缺省是只输出相关系数

返回：array

示例

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值

corrcoef(a)

计算简单相关系数矩阵及其检验P值，以及简单相关系数置信区间的上下界（显著性水平为0.05）

参数	类型	说明
a	array,tablearray	样本数据观测矩阵，二维数字数组返回结果:Ret["r"]:样本数据观测矩阵的简单相关系数矩阵Ret["p"]:检验相关系数是否显著的P值，二维数组Ret["rlo"]:简单相关系数置信区间的下界，二维数组Ret["rup"]:简单相关系数置信区间的上界，二维数组

返回：any

示例

a := rand(7, 4);
return corrcoef(a); // 返回简单相关系数分析
// 输出：结果：

distance(x, y, name)

计算样本和样本间的距离或样本数据观测矩阵的距离矩阵，其中距离包括欧氏距离，欧氏距离平方，方差加权距离，Chebychev距离，Block距离，夹角余弦，广义距离

参数	类型	说明
x	array	样本数据观测矩阵或样本数据，一维或二维数字数组
y	array	样本数据，一维数字数组
name	integer	距离方式，为一整数或字符串

返回：array

示例

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

discrim(a, x, method, options)

按照给定分类训练样本，根据训练结果对待定样本类别判定，也可作为原样本的回代检验

参数	类型	说明
a	array of real	样本数据观测矩阵，每行为一个样本，第0列为所在分类
x	array of real	样本数据观测矩阵，为待分类样本
method	integer	为判别方法，默认为 0 bayesian 判别，1为距离判别
options	array	为方法选项

返回：array

示例

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);
// 计算结果：

princomp(x, ep, is_stand, resid)

主成分分析，isStand为0时从中心化协方差出发进行主成分分析，为1时从相关系数出发，进行主成分分析；

参数	类型	说明
x	array of real	样本数据，二维数字数组;
ep	real	累计方差贡献度阈值，实数，缺省时默认为0.85;
is_stand	bool	是否标准化，布尔类型，缺省时为真；
resid	array	残差，变参输出，二维数字数组；

返回：array

示例

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);
// 输出：
// Execute script error at Line:14
// function:__main__:line 14:instruction:usercall: function:princomp compile error or not found
// function:__main__:line 14:instruction:usercall: function execute error

corrCanonical(x, y, alpha, standarize_choice)

典型相关分析，默认条件从中心化数据出发衡量两组随机变量之间的相关性

参数	类型	说明
x	array	X属性样本数据，二维数字数组，详见实例分析
y	array	Y属性样本数据，二维数字数组，详见实例分析
alpha	float	置信度，实数型，0~1之间，缺省值0(不执行典型相关系数显著性检验)
standarize_choice	any	原始数据标准化选择，整数型，0~7，缺省值为0(保持原始数据)

返回：array

corrSpearman(x, y)

Spearman相关系数，简称斯皮尔曼相关系数，经常用希腊字母ρ表示。 它是衡量两个变量的依赖性的非参数指标。它利用单调方程评价两个统计变量的相关性。 如果数据中没有重复值，并且当两个变量完全单调相关时，斯皮尔曼相关系数则为+1或1。

参数	类型	说明
x	array	一维数组，随机变量x
y	array	一维数组，随机变量y

返回：float

cov2CorrMatrix(a)

协方差矩阵转为相关系数矩阵

参数	类型	说明
a	array	二维数字数组，协方差矩阵

返回：array

示例

a := covariance(rand(4, 3));
return cov2CorrMatrix(a);
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:rand: function:covariance compile error or not found
// function:__main__:line 1:instruction:rand: function execute error

corrMatrixAdjust(a, adjust_type, n)

相关系数矩阵调整：将相关系数大或小的样本排在一起（重构）,输出结构调整，不改变相关系数本身

参数	类型	说明
a	array	二维数字数组，协方差矩阵
adjust_type	userdefine	用户自定义，调整方式，默认为0
n	integer	整数，分为N类，AdjustType=1专用

返回：array

示例

a := corr(rand(6, 6));
return corrMatrixAdjust(a, 1, 5);
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:rand: function:corr compile error or not found
// function:__main__:line 1:instruction:rand: function execute error

regressDominMarginal(y, x, variable, option)

相对重要性分析-边际R2法 功能描述： 获取指定变量或所有变量的相对重要性分析， 与公式法相比，考虑了变量的相互关系，且贡献为正， 但是贡献度的和近似等于R2

参数	类型	说明
y	array	因变量，被解释变量，是一维数字数组
x	array	自变量，解释变量，是二维数字数组
variable	any	指定变量，通过给X的列名，来指定单个变量，给nil时，表示所有变量【默认】
option	any	相对重要性的算法选择；1:利用包含指定变量回归中贡献度的均值计算【默认】，即平均R2边际效用法；0:利用完整回归中剔除其他变量的贡献度计算，即快速R2边际效用法

返回：array

regressionWls(y, x, alpha, constant, wtype, m1, m2, steps, wweight)

加权最小二乘法回归, WType为0时，必须给出m1 权重系数下限，m2 权重系数上限，steps 步长，用于计算最优权重，WType为1时，必须给出wweight权重向量。

参数	类型	说明
y	array	因变量，一维数字数组
x	array	自变量，二维数字数组
alpha	float	显著性水平,实数
constant	bool	object
wtype	bool	object
m1	float	权重系数下限，实数
m2	float	权重系数上限，实数
steps	float	步长，实数
wweight	array	权重向量，一维数字数组，当WType设置为1时，需要此参数的输入；返回结果:

返回：array

regression(y, x, alpha, constant, options)

线性回归方程的最小二乘法参数估计及检验（可选择是否包含常数项），返回结果有回归系数、R平方、调整R平方、残差序列、残差检验、F检验、T检验、DW统计量和信息准则

参数	类型	说明
y	array,tablearray
x	array,tablearray
alpha	real
constant	bool
options	array,tablearray

返回：array,tablearray

示例

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);
// 输出：
// Execute script error at Line:14
// function:__main__:line 14:instruction:usercall: function:regression compile error or not found
// function:__main__:line 14:instruction:usercall: function execute error

regressStepwise(y, x, a_e, a_d)

逐步回归，默认的回归方程包含常数项，程序返回的结果:ret["x"]为筛选的变量的下标，ret["regress"]为筛选变量与因变量进行回归的结果。

参数	类型	说明
y	array	因变量序列，为一维数组类型
x	array	自变量矩阵，为二维数组类型，每一列为一个解释变量
a_e	float	选取变量的显著性水平，默认为0.05，为实数类型
a_d	float	剔除变量的显著性水平，默认为0.1，为实数类型

返回：array

regressPri(y, x, exps, alpha)

主成分回归，利用解释变量(Z 分数标准化)进行主成分分析降维得到的主成分，来对被解释变量(Z分数标准化)进行回归，进而消除多重共线性

参数	类型	说明
y	array	被解释变量序列，为一维数组类型
x	array	解释变量矩阵，为二维数组类型，每一列为一个解释变量
exps	float	主成分累计贡献率，作为选取主成分数目的依据，当为小数时，代表累计贡献率的阀值，比如0.85，当为整数时，代表取的主成分的个数，比如2表示取前2个主成分。
alpha	float	显著性水平，实数或整数，在01之间

返回：array

regressRidge(y, x, k, constant, alpha)

岭回归，程序中对x进行了标准化，再结合岭回归系数去计算回归方程的系数，程序返回的结果，每一行为一组回归系数。 Regress_Ridge(y,x) 输出x对y的岭回归，k的选取依据方差扩大因子法 Regress_Ridge(y,x,k) k是一个实数，输出x对y的岭回归，k是一个长度大于1的数组，输出x对y的岭迹

参数	类型	说明
y	array	被解释变量序列，为一维数组类型
x	array	解释变量矩阵，为二维数组类型，每一列为一个解释变量
k	array	岭回归系数，0到1之间的实数，可为整数或一维数组类型；缺省使用方差扩大因子选取
constant	bool	是否包含常数项，为布尔类型，缺省为1
alpha	float	显著性水平，实数或整数，在01之间

返回：array

regressNlm(func, x, y, initial)

多元非线性回归，采用Marquardt方法求多元非线性方程的最小二乘回归系数。

参数	类型	说明
func	string	回归方程函数名，为字符串类型
x	array	解释变量矩阵，为二维数组类型，每一列为一个解释变量
y	array	被解释变量序列，为一维数组类型
initial	array	估计参数初始值，一维数字数组

返回：array

regressBinary(y, x, extimation, methods, constant, alpha)

二元离散选择模型。返回结果有方程的系数、负2倍对数似然值和Wald检验（原假设为解释变量对被解释变量影响不显著，检验包含统计量、P值和原假设的值1表示接受原假设，0表示拒绝原假设）

参数	类型	说明
y	array	二元离散被解释变量序列，为一维数组类型
x	array	解释变量矩阵，每一列为一个解释变量，为二维数组类型
extimation	string	模型选择，字符串类型，"logit"或"probi"
methods	any	0:单纯形法，1:转轴法,2:模式搜索法, 3:拟牛顿下山法,一般使用3方法
constant	bool	object
alpha	float	显著性水平，实数类型，取值在0-1之间，缺省时只输出模型的估计

返回：array

regressLogistic(y, x, constant, alpha)

logit二元离散选择模型。返回结果有方程的系数、负2倍对数似然值和Wald检验（原假设为解释变量对被解释变量影响不显著，检验包含统计量、P值和原假设的值1表示接受原假设，0表示拒绝原假设）

参数	类型	说明
y	array	因变量序列，为一维数组类型；
x	array	自变量矩阵，为二维数组类型，每一列为一个自变量；自变量x的长度应小于等于因变量y，否则会报错，最好等于，若小于会对结果有影响
constant	bool	object
alpha	float	显著性水平，一般为5%，也有1%和10%，数值越小，判断越严格；默认为0.05

返回：array

regressConstraint(y, x, constant, a, b, aeq, beq, alpha, options, lb, ub)

线性约束最小二乘回归

参数	类型	说明
y	array	被解释变量序列，为一维数组类型，不可缺省
x	array	解释变量矩阵，为二维数组类型，每一列为一个自变量，不可缺省
constant	bool	object
a	array	不等式约束二维数字数组，不可缺省
b	array	不等式约束一维数字数组，不可缺省
aeq	array	等式约束二维数字数组
beq	array	等式约束一维数字数组
alpha	float	显著性水平，实数或整数，在0与1之间，缺省时只做参数的估计
options	any	方法选择: 0 残差平方和最小；1 方差最小
lb	array	下界约束一维数组
ub	array	上界约束一维数组

返回：array

regressRSquare(y, u, weight, dtype)

计算回归方程的拟合程度R平方，可适用与一元或多元的线性回归；

参数	类型	说明
y	array	因变量序列，为一维数组类型；
u	array	回归方程的残差序列，为一维数组类型；
weight	array	一维数字数组,权重
dtype	any	整型,返回数据类型

返回：array

regressAdjustedR2(r, t, k)

计算回归方程经调整的R平方，考虑由于加入新的解释变量而产生自由度的损失；

参数	类型	说明
r	any	回归方程的拟合优度R平方，实数类型；
t	any	样本的容量，整数类型；
k	any	自变量的个数；

返回：any

regressFTest(y, u, k, alpha)

在1-alpha的置信水平下，方程线性关系的置信检验：F检验；返回的结果是一个数组，第一个数为F统计值，二为p值，三为原假设的值（0表示拒绝，1表示接受） F-检验统计量： 其中：RSS是残差平方和，即； ESS是回归平方和，因变量的拟合值与因变量均值的差的平方，即； TSS是总平方和 TSS=RSS+ESS； 原假设：(为方程的系数)表示回归方程不显著；

参数	类型	说明
y	array	被解释变量序列，为一维数组类型；
u	array	回归方程的残差序列，为一维数组类型；
k	any	自变量的个数；
alpha	float	1-alpha为置信水平，一般为5%，也有1%和10%，数值越小，判断越严格；

返回：array

regressTTest(x, a, u, k, alpha, constant)

在1-alpha的置信水平下，n元线性回归变量系数的置信检验：T检验；返回的结果是一个数组，第一个数为T统计值，二为p值，三为原假设的值（0表示拒绝，1表示接受） n元线性回归 T-检验统计量： 其中：为方程系数的估计，T为样本容量，k为自变量个数，X为常量加自变量的矩阵，其中； 原假设：（为方程的系数）表示回归方程不显著；

参数	类型	说明
x	array	变量矩阵，为二维数组类型，每一列为一个解释变量；
a	array	回归系数，为一维数组类型；
u	array	方程残差，为一维数组类型；
k	any	自变量个数，为整数类型；
alpha	float	1-alpha为置信水平，一般为5%，也有1%和10%，数值越小，判断越严格；
constant	bool	object

返回：array

regressJbTest(y, alpha)

在1-alpha的置信水平下，Jarque-Bera检验：检验y是否符合正态分布；返回一个数组，第一个数为Jarque-Bera统计值，二为p值，三为原假设的值（0表示拒绝，1表示接受）； Jarque-Bera统计量： 其中：S、K分别表是随即变量的偏度和峰度；T：样本容量； Jarque-Bera统计量服从渐进的分布。 原假设：随机序列为正态分布

参数	类型	说明
y	array	随即序列，接受检验的序列，一维数组类型
alpha	float	1-alpha为置信水平，一般为5%，也有1%和10%，数值越小，判断越严格；

返回：array

regressAicAndSbic(u, k, t)

信息准则函数，判断序列的最佳滞后阶数，分别计算AIC和SBIC统计量，并把结果赋值到一个一维数组，第一个是Aic值，第二个Sbic值。当选择最佳滞后阶数时，统计量越小越好。 AIC和SBIC的表达式如下所示： 其中：T为样本容量；k为自变量个数；u为残差；

参数	类型	说明
u	array	回归方程的残差序列，为一维数组类型；
k	any	解释变量的个数；
t	any	样本的容量，整数类型；

返回：array

regressWhite(y, x, crr, alpha)

包含无交叉项和交叉项两种，用于检验回归方程的异方差性，原假设为不存在异方差（Hypothesis的值0表示拒绝，1表示接受）

参数	类型	说明
y	array	被解释变量，为一维数组类型
x	array	解释变量，为二维数组类型
crr	any	交叉项，0为无交叉项，1为有交叉项
alpha	float	1-alpha为置信水平，一般为5%，也有1%和10%，数值越小，判断越严格；

返回：array

regressWls(y, x, w, u)

加权最小二乘法

参数	类型	说明
y	array	因变量序列，为一维数组类型；
x	array	自变量矩阵，为二维数组类型，每一列为一个自变量；
w	array	权重序列，为一维数组类型；
u	array	残差序列，为一维数组类型；

返回：array

regressQRlsq(y, x, u, constant)

线性回归方程基于QR分解的最小二乘法参数估计（可选择是否包含常数项），返回回归方程的系数，如果有常数项则排在第一项

参数	类型	说明
y	array	因变量序列，为一维数组类型；
x	array	自变量矩阵，为二维数组类型，每一列为一个自变量；
u	array	残差序列，为一维数组类型；
constant	bool	object

返回：array

regressVif(x)

x的多重共线性分析，输出方差扩大因子VIF指标和条件数，一般VIF大于10，表明存在严重的多重共线性；5<VIF<10,表明存在多重共线性；如果VIF小于5的话，表明这种回归模型的多重共线性可以接受。用条件数判断多重共线性的准则 0<k<10时,设计矩阵X没有多重共线性; 10≤k<100时,认为X存在较强的多重共线性; 当k≥100时,则认为存在严重的多重共线性。

参数	类型	说明
x	array	数据，每一列是一个指标

返回：array

boxcox(y)

在做线性回归的过程中，不可观测的误差可能是和预测变量相关，于是给线性回归的最小二乘法估计系数的结果带来误差，为了解决这样的方差齐性问题，所以考虑对相应应变量做Box-Cox变换，变换之后，可以一定程度上减小不可观测的误差和预测变量的相关性

参数	类型	说明
y	array of real	因变量序列，为一维数组类型

返回：array

示例

data := rand(100);
return boxcox(data);
// 输出：
// Execute script error at Line:2
// function:__main__:line 2:instruction:usercall: function:boxcox compile error or not found
// function:__main__:line 2:instruction:usercall: function execute error

regressHettestSpearman(y, x, alpha, constant)

基于等级相关系数的异方差检验

参数	类型	说明
y	array	数组，因变量，一维数字数组
x	array	数组，自变量，二维数字数组
alpha	float	实数，显著性水平，值域为[0,1]
constant	bool	object

返回：array

regressTTestWhite(x, a, u, alpha, constant, v_ols)

用White调整对回归系数进行T检验。此调整用于当残差或者因变量（两者等价）存在异方差性但不存在自相关性时，利用OLS回归后对回归系数的协方差矩阵进行White调整计算，得到每个系数White调整后的标准误，再进行T检验。公式如下QWhite=1Ti=1Tei2XiXi' 其中e为残差序列，Xi为X第i行的转置 之后代入下式计算出回归系数的协方差矩阵，它的对角元即为每个系数的方差Covβ*=X'X-1X'σ2ΩXX'X-1=TX'X-1QWhiteX'X-1

参数	类型	说明
x	array	二维数字数组, 自变量，不需要包含全1列
a	array	一维数字数组，回归系数, 有常数项回归时，a 为 常数项系数 union 自变量系数,；无常数项回归时，a 为 自变量系数
u	array	一维数字数组，残差序列，一维数字数组
alpha	float	实数，显著性水平，应为0到1之间的值，默认0.05
constant	bool	object
v_ols	array	二维数字数组，回归系数协方差矩阵，中间计算变量，无返回，但后续可以直接调用

返回：array

regressTTestNw(x, a, u, alpha, constant, al, v_ols)

用NW调整对回归系数进行T检验。此调整用于当残差或者因变量（两者等价）存在异方差性并且存在自相关性时，利用OLS回归后对回归系数的协方差矩阵进行NW调整计算，得到每个系数NW调整后的标准误，再进行T检验。公式如下QNW=1Tt=1Tet2XtXt'+l=1Lt=l+1Twletet-lXtXt-l'+Xt-lXt' 其中，wl=1-l1+L 其中e为残差序列，Xi为X第i行的转置，L为自相关最大滞后阶数，Newey and West (1994)?提出可以用下面这个公式自动计算L=4*(T100)2/9 之后代入下式计算出回归系数的协方差矩阵，它的对角元即为每个系数的方差Covβ*=X'X-1X'σ2ΩXX'X-1=TX'X-1QNWX'X-1

参数	类型	说明
x	array	二维数字数组, 自变量，不需要包含全1列
a	array	一维数字数组，回归系数, 有常数项回归时，a 为 常数项系数 union 自变量系数,；无常数项回归时，a 为 自变量系数
u	array	一维数字数组，残差序列，一维数字数组
alpha	float	实数，显著性水平，应为0到1之间的值，默认0.05
constant	bool	object
al	any	整数，自相关最大滞后阶数，可缺省，默认用Newey and West (1994)?提出的方法计算，至少为1
v_ols	array	二维数字数组，回归系数协方差矩阵，中间计算变量，无返回，但后续可以直接调用

返回：array

regressionOlsWhite(y, x, constant, alpha)

White调整的OLS回归，此调整用于当残差或者因变量（两者等价）存在异方差性但不存在自相关性时，利用OLS回归后对回归系数的协方差矩阵进行White调整计算，得到每个系数White调整后的标准误，再进行T检验。T检验部分相关公式详见Regress_TTest_White，回归系数的OLS解如下β*=(X'X)-1X'y 其余部分定义与普通最小二乘OLS一致

参数	类型	说明
y	array	一维数字数组, 因变量
x	array	二维数字数组, 自变量，不需要包含全1列
constant	bool	object
alpha	float	实数，显著性水平，应为0到1之间的值，默认0.05

返回：array

regressVifr2(x, w, constant)

vif分析增强

参数	类型	说明
x	any	表达式,自变量
w	any	表达式,权重
constant	bool	object

返回：array

singleRegression(x, y, call_back)

单元回归

参数	类型	说明
x	array	一维数字数组类型，观察数据点
y	array	一维数字数组类型，观察数据值
call_back	string	字符串，计算系数矩阵的回调

返回：array

示例

x := array(0.00, 1.00, 2.00);
y := array(1.00, 2.00, 3);
call_back := 'SingleLinearRegression_CallBack';
return singleRegression(x, y, call_back);
// 输出：
// Execute script error at Line:4
// function:__main__:line 4:instruction:usercall: function:singleRegression compile error or not found
// function:__main__:line 4:instruction:usercall: function execute error

polynomialRegression(x, y, m)

多项式回归

参数	类型	说明
x	array	一维数字数组类型,观察数据点
y	array	一维数字数组类型,观察数据值
m	integer	整数类型，拟合最大阶数

返回：array

示例

x := array(0.00, 1.00, 2.00);
y := array(1.00, 2.00, 3);
return polynomialRegression(x, y, 1);
// 输出：
// Execute script error at Line:3
// function:__main__:line 3:instruction:usercall: function:polynomialRegression compile error or not found
// function:__main__:line 3:instruction:usercall: function execute error