playbook/skills/tsl-api-reference/references/codegen/builtin/math/statistics.md

Builtin - 数学 / 统计与分布

randG(mean, std_dev)

声明：function

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

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

返回：real

示例

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

gamma(x)

声明：function

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

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

返回：array

示例

return gamma(array(1.5, 2.3, 3.4));
// 输出：array(0.886226925452758,1.16671190519816,2.98120642681033)

gammaln(x)

声明：function

计算对数gamma

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

返回：array

示例

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

erf(x)

声明：function

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

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

返回：array

示例

return erf(0.15);
// 输出：0.168

erfinv(x)

声明：function

误差函数逆函数

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

返回：array

示例

return erfinv(0.15);
// 输出：0.13372692166482

erfc(x)

声明：function

误差累计分布函数

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

返回：array

示例

return erfc(0.15);
// 0.832004028572637

erfcinv(x)

声明：function

误差累计逆函数

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

返回：array

示例

return erfcinv(0.15);
// 输出：1.01790246483203

minIntValue(data)

声明：function

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

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

返回：integer

示例

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

sumOfSquares(data)

声明：function

计算一组实数的平方和

参数	类型	说明
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)

声明：function

计算一组实数的总和以及平方和，执行完毕后，总和存在参数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)

声明：function

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

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

返回：integer

示例

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

sumInt(data)

声明：function

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

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

返回：integer

示例

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

meanAndStdDev(data, mean, std_dev)

声明：function

估计一组数据的平均值和标准差。执行完毕后，平均值放在参数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)

声明：function

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

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

返回：real

示例

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

totalVariance(data)

声明：function

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

参数	类型	说明
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)

声明：function

计算一组数据的中位数

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

返回：real

示例

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

mode(data)

声明：function

计算一组数据的众数

参数	类型	说明
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)

声明：function

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

参数	类型	说明
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)

声明：function

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

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

返回：real

示例

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

cov(data1, data2)

声明：function

两个数据间的协方差

参数	类型	说明
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)

声明：function

两个数据间的相关系数

参数	类型	说明
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)

声明：function

两个数据间的回归斜率

参数	类型	说明
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)

声明：function

两个数据间的回归截距

参数	类型	说明
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)

声明：function

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

参数	类型	说明
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)

声明：function

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

参数	类型	说明
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)

声明：function

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

参数	类型	说明
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)

声明：function

数据集中四分位的值

参数	类型	说明
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)

声明：function

返回一组实数中的最小值

参数	类型	说明
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)

声明：function

返回一组实数中的最大值

参数	类型	说明
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)

声明：function

计算一组数的算术平均值

参数	类型	说明
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)

声明：function

计算一组数的总和

参数	类型	说明
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)

声明：function

计算一组数据的平方和的平方根，也就是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)

声明：function

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

参数	类型	说明
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)

声明：function

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

参数	类型	说明
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)

声明：function

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

参数	类型	说明
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)

声明：function

计算一组数据的偏度，算法和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)

声明：function

计算一组数据的偏度，算法和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)

声明：function

计算一组数据的峰度，算法和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)

声明：function

计算一组数据的峰度，算法和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)

声明：function

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

参数	类型	说明
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)

声明：function

返回累乘值

参数	类型	说明
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)

声明：function

找出第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)

声明：function

找出第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)

声明：function

数据集中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)

声明：function

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

声明：function

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

参数	类型	说明
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)

声明：function

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

声明：function

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

参数	类型	说明
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)

声明：function

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

参数	类型	说明
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)

声明：function

计算序列百分点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'));

std(rsp_cycle, n)

声明：function

已实现波动率(%)

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

返回：float

stdUp(rsp_cycle, n)

声明：function

高频上行波动率(%)

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

返回：float

beta(rsp_cycle, n, cut_value)

声明：function

S=|R|/(V^beta)

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

返回：float

lnv(rsp_cycle, n, cut_value)

声明：function

S=|R|/ln(V)

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

返回：float

skewWBuy(rsp_cycle, k, n)

声明：function

净委买变化率偏度

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

返回：float

sf_exppdf(values, lambda_value)

声明：function

计算指数分布概率密度。

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

返回：array

sf_expcdf(values, lambda_value)

声明：function

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

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

返回：array

sf_mvtcdf(lower_bounds, upper_bounds, correlation_matrix, degrees_freedom)

声明：function

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

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

返回：array

sf_mvncdf(lower_bounds, upper_bounds, mean_values, correlation_matrix)

声明：function

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

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

返回：array

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

声明：function

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

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

返回：array

Hypoth_SNDTest(values, variance_value, tail, alpha)

声明：function

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

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

返回：array

Anova_Twice(values, alpha, repeat_count)

声明：function

执行双因素方差分析。

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

返回：array

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

声明：function

执行符号检验。

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

返回：array

correlpaired(a, b)

声明：function

功能：计算 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))

correlpaired_side(a, dir_type)

声明：function

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

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

返回：array

sf_SinX(x, v)

声明：function

正弦积分的定义为

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

返回：any

sf_CosX(x, v)

声明：function

余弦积分的定义为

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

返回：any

sf_eX(x, v)

声明：function

指数积分的定义为

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

返回：any

sf_Gamma(x, v)

声明：function

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

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

返回：any

sf_Beta(x, y, v)

声明：function

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

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

返回：any

sf_Error(x, v)

声明：function

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

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

返回：any

sf_Normal(x, a, d)

声明：function

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

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

返回：any

sf_normalinv(data, m, s, v)

声明：function

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

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

返回：any

sf_normalinv2(data, v)

声明：function

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

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

返回：any

sf_nbininv(y, r, p, x)

声明：function

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

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

返回：any

sf_tinv(data, n, v)

声明：function

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

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

返回：any

sf_finv(data, n, n1, v)

声明：function

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

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

返回：any

sf_x2inv(data, n, v)

声明：function

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

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

返回：any

sf_gammainv(probability, alpha, v)

声明：function

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

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

返回：any

sf_betainv(y, a, b, x)

声明：function

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

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

返回：any

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

声明：function

中间函数，采用蒙特卡洛计算多元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());

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

声明：function

估计多元函数分布值

参数	类型	说明
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

sf_copulafit(x, copula_type, method, options)

声明：function

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

参数	类型	说明
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)

声明：function

生成服从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);

Regress_VIFR2(x, w, constant)

声明：function

vif分析增强

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

返回：array