playbook/skills/tsl-api-reference/references/codegen/dotnet.md

Dotnet

以下为 .NET 运行环境提供的函数。

accumulativeYtMtoYtm(t, fname, dw)

声明：function

复合益率转日收益率

参数	类型	说明
t	array	数据表类型，复合收益率序列
fname	string	字符串，收益字段名称
dw	integer	整数，决定源数据的单位和返回的数据

返回：array

示例

// 源数据单位为1,设dw=2,同时返回复合收益率和转换后的日收益率
t1 := array(('日期': 20180801T, '复合收益率': 0.1),
('日期': 20180802T, '复合收益率': 0.4),
('日期': 20180803T, '复合收益率': 0.7));
r1 := accumulativeYtMtoYtm(t1, '复合收益率', 2);
// 源数据单位为%,设dw=3,同时返回复合收益率和转换后的日收益率
t2 := array(('日期': 20180801T, '复合收益率(%)': 10),
('日期': 20180802T, '复合收益率(%)': 40),
('日期': 20180803T, '复合收益率(%)': 70));
r2 := accumulativeYtMtoYtm(t2, '复合收益率(%)', 3);
return r1|r2;
// 输出：返回：

Anova_Bartlett(y, alpha)

声明：function

在1-alpha的置信水平下，Bartlett方法检验方差齐性；B-Stat为统计值，P-Value为p值，df为自由度，Hypothesis为是否接受原假设 模型表达： Bartlett检验思想来源于几何平均数小于或等于算术平均数 原假设：是水平个数 ,其中 修正的Bartlett检验

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

返回：array

Anova_Levene(y, alpha)

声明：function

在1-Alpha的置信水平下，Levene方法检验方差齐性，和Bartlett检验不同的是，Levene检验不要求总体具有正态性。返回一个数组，F-Stat为统计值，P-Value为p值，df1，df2为自由度，Hypothesis为是否接受原假设 模型表达： 原假设：是水平个数 ，其中是观察数目，是水平数目

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

返回：array

Anova_Single(y, alpha)

声明：function

在1-alpha置信水平下，在假设服从正态分布，且方差齐性，样本之间独立的基础上，判断各水平的均值是否显著相等 模型表达： ， 其中：效应平方和：，误差平方和： 总离差

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

返回：array

Anova_Twice(y, alpha)

声明：function

在1-alpha的置信水平下，进行双因子方差分析，假设每一种情况都服从一个正态分布，且方差相等，数据独立，判断各水平的均值是否显著相等 模型表达： 有A，B两个因素，因素A有r个水平，B有s个水平，对于A，B每一个组合(Ai,Bj)都进行t次试验，得到结果： 因素B 因素A B1 B2 … Bs A1 X111, X112,…,X11t X121, X122,…,X12t … X1s1, X1s2,…,X1st A2 X211, X212,…, X21t X221, X222,…, X22t … X2s1, X2s2,…, X2st … … … … Ar Xr11, Xr12,…, Xr1t Xr21, Xr22,…, Xr2t … Xrs1, Xrs2,…, Xrst 设：且相互独立 ，其中，是水平Ai的效应，是水平Bj的效应，称为水平Ai和Bj的交互效应。， 原假设：，， 现构造了3个F统计量来分别检验假设，原理略

参数	类型	说明
y	array	数据矩阵，为二维数组类型，每rep行，每一列表示一个交叉项
alpha	float	显著性水平，实数或整数，在01之间；Rep:每一个交叉项，做rep次试验，rep=1时，没有交叉效应为0的假设

返回：array

ar(y, p, approach)

声明：function

自回归模型，AR(p)模型，选择使用最小二乘，Yule-Walker方法，Foiward-backward,Geometric lattice,Burg's lattice-bas去估计p阶自回归模型的系数，返回结果有自回归系数、残差方差、预测值及预测波动等信息

参数	类型	说明
y	array of real	样本序列，为一维数组类型，注意要零均值化
p	integer	自回归阶数
approach	string	估计方法

返回：array

示例

elps := randnorm(0, 1, 200);
y := array();
y[0] := 0;
y[1] := 0;
for i := 2 to 199 do
y[i] := -0.5 * y[i-1]+0.3 * y[i-2]+elps[i];
return ar(y, 2, 'ls');

arma(series, p, q)

声明：function

自回归移动平均模型，ARMA(p,q)模型，采用逆函数去估计自回归系数和移动平均系数，返回结果有自回归系数、移动平均系数、残差方差等信息 ARMA模型： 其中：为原序列零均值化的新序列，是自回归方程系数，为移动平均系数，是零均值、方差为的平稳白噪声

参数	类型	说明
series	array	样本序列，为一维数组类型，注意要零均值化
p	int	自回归阶数，整数类型
q	int	移动平均阶数，整数类型；返回结果:；Ret["AR"]:参数估计结果，，第一项为1；Ret["MA"]:参数估计结果，，第一项为1；Ret["T-test"]:AR模型参数的T检验；Ret["LossFunction"]；Ret["FPE"]:预测最大误差；Ret["AIC"]:模型的AIC信息准则；Ret["SC"]:模型的SC信息准则；Ret["e"]:残差信息；Ret["Inverted AR Roots"]:AR特征方程的特征根；Ret["Inverted MA Roots"]:MA特征方程的特征根；Ret["R_squared"]:AR模型的可决系数；Ret["Adjusted_R_squared "]:AR模型的修正可决系数；Ret["Sum_squared_resid"]:AR模型的离差平方和；Ret["Durbin Watson stat"]:DW统计量；Ret["Log Likelihood"]:对数极大似然值；Ret["S.E. of regression"]:回归标准差

返回：array

示例

elps:=randnorm(0,1,200);
y:=array();
y[0]:=0;
for i:=1 to 199 do
y[i]:=0.8*y[i-1]+elps[i]-0.4*elps[i-1];
arma(y,1,1);

BarLine_Web(r, graph_title, return_type)

声明：function

返回直方图。主要用于网页设计

参数	类型	说明
r	array	数据表类型，数据；
graph_title	string	字符串，图形标题；
return_type	any	整数，返回类型。

返回：array

betaAndAlpha(y, x, beta, alpha)

声明：function

获取斜率和截距

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

返回：void

示例

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

betainc(x, a, b, tail)

声明：function

不完全贝塔函数

参数	类型	说明
x	array	(一维数字数组,实数) 变量 要求0<=x<=1;
a	float	float 不完全贝塔函数的参数 要求a>=0;
b	float	float 不完全贝塔函数的参数 要求b>=0;
tail	string	返回类型

返回：array

示例

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

binofit(x, n, alpha)

声明：function

根据样本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的显著性水平下的区间估计

boxcox(y)

声明：function

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

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

返回：array

示例

data := rand(100);
return boxcox(data);

chol(h, l, p, options, sneg)

声明：function

进行乔列斯基分解，H对称正定，则可以得到三角阵L

参数	类型	说明
h	array	需要被分解的对称矩阵，正定矩阵的分解才能成功
l	array	变参返回乔列斯基分解得到的三角阵
p	integer	变参返回H的分解信息，-1表示全部分解成功，否则表示分解到第p步
options	array	三角阵选项，默认'upper'为上三角，'lower' 为下三角
sneg	array	当 H 非正定时计算曲率方向，正定时为空

返回：array

示例

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

Cluster_Kmeans(samples, class_count, options)

声明：function

执行 K-means 聚类

参数	类型	说明
samples	array	样本矩阵
class_count	any	聚类数量
options	array	参数表；常见键包括 maxiter、tol、distance、out

返回：array

Cluster_System(a, dmethods, methods, options)

声明：function

sample是一个样本数据观测矩阵，每一行是一个样本数据，本函数依据各种不同的距离对样本进行谱系聚类

参数	类型	说明
a	array	样本数据观测矩阵，每一行是一个样本数据
dmethods	any	整数或字符串类型，距离方式,参数的输入格式参考[Distance]name的输入,缺省欧式距离
methods	any	1:组间以中心距离,默认组间中心距离；2:以组间最短距离；3:以组间最大距离
options	array	默认为输出谱系树；Options['best':1]:输出最优分类；Options['tree':1]:输出谱系树，默认输出谱系关系；Options['out':0]:最佳分类排列方式。1每一行为一个类（默认）0各个样本对应的类

返回：array

Cluster_ward(samples)

声明：function

执行 Ward 聚类

参数	类型	说明
samples	array	样本矩阵

返回：array

componentMatrix(eigen_value, eigen_vector, max_eigen_value)

声明：function

载荷矩阵

参数	类型	说明
eigen_value	array	一维数字数组类型，特征根
eigen_vector	array	二维数字数组类型，特征向量
max_eigen_value	array	一维数字数组类型，主因子对应的特征根

返回：array

示例

// 设置样本矩阵
zt := array((0.7592, 1.7593, 21.9279, 48.5626, 55.1679),
(0.0490, 0.4457, 2.2255, 82.2658, 192.4348),
(-2.2313, -1.3096, -59.8883, 3.9922, -80.2419),
(0.1364, 0.539, 4.3910, 55.1438, 46.0612),
(0.7233, 1.9467, 15.6127, 111.3018, 58.3969));
z_t_s := Standarize_II(z_t); // 标准化
mt_Transposition(z_t_s, z); // 转置
r := correlationMatrix(z); // 相关系数矩阵
Eigen_Jacobi(r, eigen_value, eigen_vector); // 特征值&特征向量
return componentMatrix(eigen_value, eigen_vector, max_eigen_value);

componentScoreMatrix(cm, r)

声明：function

因子得分系数矩阵

参数	类型	说明
cm	array	二维数字数组类型，载荷矩阵
r	array	二维数字数组类型，相关系数矩阵

返回：array

示例

// 设置样本矩阵
zt := array((0.7592, 1.7593, 21.9279, 48.5626, 55.1679),
(0.0490, 0.4457, 2.2255, 82.2658, 192.4348),
(-2.2313, -1.3096, -59.8883, 3.9922, -80.2419),
(0.1364, 0.539, 4.3910, 55.1438, 46.0612),
(0.7233, 1.9467, 15.6127, 111.3018, 58.3969));
z_t_s := Standarize_II(z_t); // 标准化
mt_Transposition(z_t_s, z); // 转置
r := correlationMatrix(z); // 相关系数矩阵
Eigen_Jacobi(r, eigen_value, eigen_vector); // 特征值&特征向量
cm := componentMatrix(eigen_value, eigen_vector, max_eigen_value); // 载荷矩阵
return componentScoreMatrix(cm, r);

cond(x)

声明：function

求矩阵 X 的条件数，最大奇异值除最小奇异值

参数	类型	说明
x	array	array 需要求条件数的矩阵或二维数组

返回：real

示例

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

corr(a, _type, tail)

声明：function

计算相关系数矩阵及其检验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值

corr_canonical(x, y, alpha, standarize_choice)

声明：function

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

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

返回：array

corr_Kendall(x_values, y_values)

声明：function

计算 Kendall 秩相关系数

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

返回：float

Corr_partial(x, y, z, _type)

声明：function

偏相关系数，返回x和y在控制变量z下的偏相关系数，行为样本，列为指标

参数	类型	说明
x	array	变量一，二维实数数组
y	array	变量二，二维实数数组
z	array	控制变量，二维实数数组
_type	any	1:pearson偏相关;2:Spearman偏相关；tail:假设检验的三种类型，字符串，取值为both、left和right，缺省是只输出相关系数

返回：any

corr_Spearman(x, y)

声明：function

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

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

返回：float

corrcoef(a)

声明：function

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

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

返回：any

示例

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

correlationMatrix(a1, t)

声明：function

相关系数矩阵求解

参数	类型	说明
a1	array
t	float

返回：array

示例

a := rand(4,3);
correlationMatrix(a,1);

correlpaired(a, b)

声明：function

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

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

返回：array

示例

范例01：

a := array(1, 2, 3, 4, 5);
b := array(2, 4, 6, 8, 10);
return correlpaired(a, b);
// 输出：array((1.0))

范例02：

a := array(1, 2, 3, 4, 5);
b := `array(
    "B1": array(2, 4, 6, 8, 10),
    "B2": array(10, 8, 6, 4, 2)
);
return correlpaired(a, b);
// 输出：array((1.0,-1.0))

范例03：

a := `array(
    "A1": array(1, 2, 3, 4, 5),
    "A2": array(5, 4, 3, 2, 1)
);
b := `array(
    "B1": array(2, 4, 6, 8, 10),
    "B2": array(10, 8, 6, 4, 2),
    "B3": array(1, 2, 3, 4, 5),
    "B4": array(5, 4, 3, 2, 1)
);
return correlpaired(a, b);
// 输出：array((1.0,-1.0,1.0,-1.0),(-1.0,1.0,-1.0,1.0))

范例04：

a := `array("A": array(1, 2, 3, 4, 5));
b := `array(
    "A": array(2, 4, 6, 8, 10),
    "B": array(10, 8, 6, 4, 2)
);
return correlpaired(a, b);
// 输出：array((1.0,-1.0))

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

corrMatrixAdjust(a, adjust_type, n)

声明：function

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

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

返回：array

示例

a := corr(rand(6, 6));
return corrMatrixAdjust(a, 1, 5);

cov2CorrMatrix(a)

声明：function

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

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

返回：array

示例

a := covariance(rand(4, 3));
return cov2CorrMatrix(a);

covariance(a)

声明：function

计算协方差矩阵

参数	类型	说明
a	array

返回：any

示例

a := rand(4,3);
covariance(a);

det(a)

声明：function

行列式

参数	类型	说明
a	array	二维数字数组 样本

返回：real

示例

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

diag(a)

声明：function

对角阵

参数	类型	说明
a	array	array 数组

返回：array

示例

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

discrim(a, x, method, options)

声明：function

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

参数	类型	说明
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);
// 计算结果：

distance(x, y, name)

声明：function

计算样本和样本间的距离或样本数据观测矩阵的距离矩阵，其中距离包括欧氏距离，欧氏距离平方，方差加权距离，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));

doubleVariableExecute(arr, sys_name, time_arr, exp)

声明：function

计算指定系统参数，指定时间序列下的指标表达式的值

参数	类型	说明
arr	integer	二维数组，设置的系统参数的值
sys_name	integer	字符串，指定的系统参数名
time_arr	integer	二维数组，需要计算的指定时间
exp	texpression	表达式，指标表达式

返回：array

示例

stocks := array(getBk('上证50'));
timer := marketTradeDayQk(20220101T, 20221211T);
return doubleVariableExecute(stocks, pn_Stock(), timer, @close());
// 返回: （部分结果截图）

eastrq(b, c, q)

声明：function

返回 Eastrq 对应的数据

参数	类型	说明
b	array	一维数字数组类型
c	array	一维数字数组类型
q	array	二维数字数组类型

返回：int

eigen(a, eigen, eigenvectors, isreal)

声明：function

特征根与特征向量

参数	类型	说明
a	array	array 特征值分解的数据
eigen	array	array 变参返回特征值
eigenvectors	array	array 变参返回特征向量
isreal	integer	bool 是否只输出实特征值及特征向量

返回：integer

示例

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

Eigen_Jacobi(matrix, eigen_values, eigen_vectors)

声明：function

用 Jacobi 方法计算矩阵特征值和特征向量

参数	类型	说明
matrix	array	待分解矩阵
eigen_values	any	接收特征值数组
eigen_vectors	any	接收特征向量矩阵

返回：void

Estimate_SND(x, alpha, tail)

声明：function

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

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

返回：array

Estimate_SNU(x, d, alpha, tail)

声明：function

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

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

返回：array

Estimate_SP(mx, alpha, tail)

声明：function

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

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

返回：array

Estimate_TND(x, alpha, tail)

声明：function

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

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

返回：array

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

声明：function

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

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

返回：array

Estimate_TP(p, alpha, tail)

声明：function

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

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

返回：array

expdMax(r)

声明：function

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

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

返回：array

示例

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

expdMin(r)

声明：function

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

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

返回：array

示例

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

expdProduct(r)

声明：function

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

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

返回：array

示例

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

expdStd(r, ddof)

声明：function

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

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

expdSum(r)

声明：function

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

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

返回：array

示例

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

expdVar(r, ddof)

声明：function

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

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

expfit(x, alpha)

声明：function

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

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

返回：any

示例

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

exportCsvne(data, csv_str, include_index, include_header)

声明：function

将指定数组Data转换为csv格式字符串并存储在csvStr参数中。仅支持一维及二维数组的转换。和ExportCsv的区别：在处理浮点数据时，ExportCsvne的结果不会输出为1E15等格式

参数	类型	说明
data	array
csv_str	string
include_index
include_header	bool

返回：bool

示例

范例01：一维数组转换成csv格式字符串（含大数量级数据）

data := array(1, 2, "3", "A", 9, 1E15);
ret := exportCsvne(data, s);
if ret then return s;
else return ret;

范例02：二维数组转换成csv格式字符串

data := array((2, 5, 0), (3, 2, 1), (4, 7, 2));
ret := exportCsvne(data, s);
if ret then return s;
else return ret;

范例03：转换成csv格式字符串，结果包含数组下标信息

data := array("A": (2, 5, 0), "B": (3, 2, 1), "C": (4, 7, 2));
ret := exportCsvne(data, s, 1);
if ret then return s;
else return ret;

范例04：转换成csv格式字符串，结果不包含字段头部信息

data := array((2, 5, 0), (3, 2, 1), (4, 7, 2));
ret := exportCsvne(data, s, 0, 0);
if ret then return s;
else return ret;

exportFile2(_type, alias, file_name, data, include_header, include_index, sheet, range)

声明：function

将数据导出到指定Sheet、指定数据位置Range的excel文件，仅支持Type类型为ftxls()的，为了兼容其他类型，如果输入的类型是非ftxls()的，则执行exportfile导出数据且无法指定Sheet和Range。注：导出时对应的excel文件需要关闭

参数	类型	说明
_type		整数类型。参考导入导出类型函数。
alias	string	字符串类型。参考目录别名。
file_name	string	字符串类型。文件名称。
data		数据，需要导出的数据。
include_header	bool	布尔类型。为真时导出的文件包含字段头部信息。缺省时候为真。
include_index	bool	布尔类型。为真时导出的文件包含数组下标信息。缺省时候为假。
sheet	string	字符串类型，指定Sheet。
range	string	字符串类型，指定单元格，如:”A1”表示要把数据导出到A1开始的单元格。

返回：integer|string

示例

// 导出10 * 5全1矩阵，到C: \\test.xlsx 文件的Sheet3，C2单元格。
data := ones(10, 5);
ret := rdo2 exportFile2(ftXls(), "", "C:\\test.xlsx", data, 1, 0, "Sheet3", "C2");
return ret;
// 结果：1 (表示数据导出成功，可以在c盘看到test.xlsx文件)

factor(x, var_value)

声明：function

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

参数	类型	说明
x	array	二维维实数数组，表示样本矩阵；
var_value	float	实数，表示方差贡献率,控制因子个数；；返回结果:ss；Ret["Correlation Matrix",0]:样本数据的相关系数矩阵；Ret["kmo",0]:KMO检验值；0.9<KMO: 非常适合；0.8<KMO<0.9:适合；0.7<KMO<0.8:一般； 0.6<KMO<0.7:适合度较低；KMO<0.6:适合度很低；ret["Total Variance Explained",0]:特征值、方差贡献率、累计方差贡献率等信息；ret["Component Matrix",0]:因子载荷矩阵；ret["Communalities",0]:共同变量度，即载荷矩阵行的平方和；ret["thogonal matrix",0]:正交变换后的载荷矩阵；ret["Rotation matrix",0]:旋转矩阵；ret["Factor score",0]:因子得分

返回：array

示例

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

factorScoreMatrix(cs, z)

声明：function

主因子得分

参数	类型	说明
cs	array	二维数字数组类型，因子得分矩阵
z	array	二维数字数组类型，原始数据矩阵

返回：array

示例

// 设置样本矩阵
zt := array((0.7592, 1.7593, 21.9279, 48.5626, 55.1679),
(0.0490, 0.4457, 2.2255, 82.2658, 192.4348),
(-2.2313, -1.3096, -59.8883, 3.9922, -80.2419),
(0.1364, 0.539, 4.3910, 55.1438, 46.0612),
(0.7233, 1.9467, 15.6127, 111.3018, 58.3969));
z_t_s := Standarize_II(z_t); // 标准化
mt_Transposition(z_t_s, z); // 转置
r := correlationMatrix(z); // 相关系数矩阵
Eigen_Jacobi(r, eigen_value, eigen_vector); // 特征值&特征向量
cm := componentMatrix(eigen_value, eigen_vector, max_eigen_value); // 载荷矩阵
cs := componentScoreMatrix(cm, r); // 因子得分矩阵
return factorScoreMatrix(cs, zt);

FastLine_Web(r, graph_title, data_prop, return_type)

声明：function

返回线图或者数据，主要用于网页设计

参数	类型	说明
r	array	一维数字数组，数据；
graph_title	string	字符串，图形标题；
data_prop	array	数据表类型，图形属性；
return_type	any	整数，返回类型。

返回：array

filter_hp(y, l)

声明：function

HP滤波法

参数	类型	说明
y	array	一维数字数组，时间序列
l	any	整数，平滑参数

返回：array

Fmin(fun, x0, a, b, aeq, beq, nonlcon, c)

声明：function

（非线性规划建议统一使用prog_n函数），用起作用集法求任意形式非线性优化问题，结果返回最优点、最优值。可求解如下问题

旧定义：NonLP_Fmincon(Fun:String;X0:array;A:Array;B:Array;Aeq:Array;Beq:Array;Nonlcon:String):array

来源：天软金融分析.NET函数大全 > TSL函数 > 数学函数 > 优化 > Prog_N

Source ID：21143

参数	类型	说明
fun	String	目标函数表达式，为字符串类型；
x0	array	初值向量，为一维数组类型；
a	Array	线性矩阵不等式约束，为二维数组类型；
b	Array	线性向量不等式约束值，为一维数组类型；
aeq	Array	线性矩阵等式约束，为二维数组类型；
beq	Array	线性向量等式约束值，为一维数组类型；
nonlcon	String	非线性约束回调，为字符串类型；nonlcon回调需用户自己新建一个函数，然后把函数名传进nonlcon，函数格式如下: Function “函数名”(x); Begin
c		=array();// _ C[0]:=…… C[1]:=…… …… Ceq:=array();// _ Ceq[0]:=…… Ceq[1]:=…… …… Return array(0:c,1:ceq);// * End; // *号的式子一定要写

返回：array

fScoreResult(factor_arr, max_eigen_value)

声明：function

获取主因子得分

参数	类型	说明
factor_arr	array	二维数字数组类型，因子得分矩阵
max_eigen_value	array	二维数字数组类型，主因子对应的特征根

返回：array

示例

// 设置样本矩阵
zt := array((0.7592, 1.7593, 21.9279, 48.5626, 55.1679),
(0.0490, 0.4457, 2.2255, 82.2658, 192.4348),
(-2.2313, -1.3096, -59.8883, 3.9922, -80.2419),
(0.1364, 0.539, 4.3910, 55.1438, 46.0612),
(0.7233, 1.9467, 15.6127, 111.3018, 58.3969));
z_t_s := Standarize_II(z_t); // 标准化
mt_Transposition(z_t_s, z); // 转置
r := correlationMatrix(z); // 相关系数矩阵
Eigen_Jacobi(r, eigen_value, eigen_vector); // 特征值&特征向量
cm := componentMatrix(eigen_value, eigen_vector, max_eigen_value); // 载荷矩阵
cs := componentScoreMatrix(cm, r); // 因子得分系数矩阵
f_arr := factorScoreMatrix(cs, z_t_s); // 样本公共因子得分
return fScoreResult(f_arr, max_eigen_value);

ftCsVne()

声明：function

逗号分割文件类型，输出结果禁用1E20等类型

返回：integer

garchFit(model_spec, y, x, e0, s0, y0)

声明：function

广义自回归条件异方差模型，采用极大似然估计方法估计模型的参数

参数	类型	说明
model_spec	array	模型设置项，为数据表类型，参考:表8-5
y	array	原始数据，一维数字数组
x	array	均值方程回归外生变量，二维数字数组，可缺省
e0	array	自回归方程残差序列起始的几项取值，一维数字数组，可缺省
s0	array	条件方程方差序列起始的几项取值，一维数字数组，可缺省
y0	array	原始序列起始的几项取值，一维数字数组，可缺省

返回：array

示例

// 以1995年1月至2000年8月日元兑换美元汇率值序列（JPY，如图8-9）为例介绍怎样用天软来进行ARCH建模（序列共1427个值）。
// 图8-9日元兑换美元汇率值(JPY)序列图8-10DJPY时间序列
JPY序列显然是一个非平稳时间序列，对JPY进行差分，DJPY表示收益，见图8-10，因为DJPY是一个平稳时间序列，应该使用DJPY建立时间序列模型。按照ARMA模型中讲的那样对DJPY拟合ARMA模型，根据自相关系数以及偏自相关系数，AIC准则等，我们最终将模型定为AR(3)模型。
d_jpy := diff(jpy);
m := mean(d_jpy);
d_jpy := d_jpy-m;
ret := arma(d_jpy, 3, 0);
// 得到的结果是：
// 图8-11 AR(3)残差
// 该模型的残差如图8-11所示，我们怀疑残差含有异方差，使用Time_ARCHTest函数检验。
Time_ARCHTest(ret["e"], 1, 0.05);
// 图8-12 AR(3)残差
// 拒绝原假设，认为模型含有异方差，建立ARCH模型，首先建立ARCH(7)模型(尝试多次，最大滞后选为7为宜)。
// 图8-13ARCH模型结果图8-14异方差估计情况
modelspec := array(
("R": 3,
"M": 0,
"AR": nil,
"MA": nil,
"Regress": nil,
"VarianceModel": "GARCH",
"C": nan,
"P": 0,
"Q": 7,
"GARCH": array(),
"ARCH": array(),
"Leverage": nil));
t := garchFit(model_spec, d_jpy);
// 得到的异方差如图8-14。ARCH模型中的的滞后项太多，应该尝试建立GARCH(1, 1)模型：
modelspec := array(
("R": 3,
"M": 0,
"AR": nil,
"MA": nil,
"Regress": nil,
"VarianceModel": "GARCH",
"C": nan,
"P": 1,
"Q": 1,
"GARCH": array(),
"ARCH": array(),
"Leverage": nil));
t := garchFit(model_spec, d_jpy);
// 图8-15GARCH模型结果图8-16方差估计情况

generateCombinations(list, ret, start, n)

声明：function

非空全组合生成器

参数	类型	说明
list	array	一维数组 样本,
ret	array	返回生成的组合数组,
start	integer	Int 选取起始数据的位置,
n	integer	Int 记录每组数据的起始位置,

返回：integer

示例

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

getColorByIndex(index)

声明：function

依据Index值，获得颜色数组内的指定颜色整数代号

参数	类型	说明
index	integer	整数，颜色索引号

返回：integer

示例

return getColorByIndex(1);
// 返回：16711680

getEigenValue(a, eigen_value)

声明：function

通过赋值得到EigenValue

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

返回：any

GM_AGO(x, method, r)

声明：function

数列生成，r(r>0)次的累加或累减生成新数列 1）累加：， 2）累减

参数	类型	说明
x	array	数据矩阵，为一维数组类型；
method	string	生成方法(add,sub)，为字符串类型；
r	any	次数，为整数类型

返回：array

GM_Corr(x, l)

声明：function

灰色关联度，以l行为参考数列的灰色关联度，返回的是关联度矩阵 ，， 以为参考数列，则关联度计算步骤如下： 1）初值化：； 2）求差数列：， 3）求两级最大和最小：， 4）求关联系数：，为分辨系数，是0到1之间的数 5）求关联度

参数	类型	说明
x	array	数据矩阵，为二维数组类型；
l	any	参考序列标号，为整数类型

返回：array

GM_Estimate(x, l)

声明：function

GM(1,1)模型，用于灰色系统模型的l步预测 结果说明： 平均相对误差：越小越接近零越好； 关联度：当ρ=0.5时，关联度大于0.6便满意 方差比：C 小误差概率：P

参数	类型	说明
x	array	数据矩阵，为一维数组类型；
l	any	预测步长，为整数类型

返回：array

GM_Initial(x, method, un)

声明：function

数据初始化，提供了几种数据变换的方法，有初值化、均值化、最小值化、最大值化、按行区间值化、按列区间值化、归一化、逆化、倒数化和始点零化处理原始的序列 1）初值化： 2）均值化：， 3）最小值化：， 4）最大值化：， 5）按行区间值化： 6）按列区间值化： 7）归一化：， 8）逆化： 9）倒数化： 10）始点零化

参数	类型	说明
x	array	数据矩阵，为二维数组类型；
method	string	处理方法(ini,mean,min,max,rrange,crange,norm,inv,rec,zero)，为字符串类型；
un	array	归一化单位，为一维数组类型

返回：array

GM_Scorr(x, method)

声明：function

灰色绝对关联度、灰色相对关联度和灰色综合关联度，返回的是关联度矩阵 ，， 1）灰色绝对关联度： 2）灰色相对关联度：先对数列进行初值化，然后求新数列的灰色绝对关联度，即为原数列的灰色相对关联度 3）灰色综合关联度

参数	类型	说明
x	array	数据矩阵，为二维数组类型；
method	string	方法(abs,ret,com)，为字符串类型；

返回：array

H_J_CallBack(x, r)

声明：function

H_J算法回调

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

返回：float

H_J_Method_Pgm(call_back)

声明：function

H_J算法测试

参数	类型	说明
call_back	string	字符串类型，计算目标值的回调

返回：array

hessian(fun, x)

声明：function

海塞矩阵 求解函数 fun 在x点的 海塞矩阵

参数	类型	说明
fun	string	字符串，函数名
x	array	一维数组，指定点

返回：array

示例

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

hist(a, b, center)

声明：function

统计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);
// 输出：，一维数字数组

histc(a, b)

声明：function

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

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

返回：array

示例

a:=rand(1000)*5;
b:=array(0,1,2,3,4,5);
histc(a,b);

Hooke_Jeeves_Method(x0, d0, d_min, r, call_back)

声明：function

H-J法求解无约束最优化问题

参数	类型	说明
x0	array	一维数字数组类型
d0	array	一维数字数组类型
d_min	array	一维数字数组类型
r	float	实数类型
call_back	string	字符串类型，计算目标值的回调

返回：array

Hypoth_IndepTest(x, alpha)

声明：function

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

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

返回：array

Hypoth_KruskalWallis(x, alpha)

声明：function

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

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

返回：array

Hypoth_Kstest(data, tail, alpha, cdf)

声明：function

在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

Hypoth_lillietest(data, alpha, distr)

声明：function

在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

Hypoth_LSUTest(mx, s, n, u, tail, alpha)

声明：function

单个或两个总体大样本的均值检验，即大样本U检验，返回的结果是一个数组，第一个数为统计值，二为p值，三为原假设的值（0表示拒绝，1表示接受） 模型表达 单个总体大样本的均值原假设：tail取值both：;left：;right： 两个总体大样本的均值假设：tail取值both：;left：;right： 检验统计量： 或 其中：x为样本x的均值，y为样本y的均值，为正态总体x方差，为正态总本y方差，m,n分别为样本x和y的容量s

参数	类型	说明
mx	array	样本均值数组，第一行为样本1，第二行为样本2，为一维数组类型
s	any	样本方差数组，第一行为样本1，第二行为样本2，为一维数组类型
n	array	样本容量，第一行为样本1，第二行为样本2，为一维数组类型
u	float	单个总体时，为假设检验均值，两个总体时，为均值差
tail	string	假设检验类型
alpha	float	显著性水平，实数或整数，在01之间

返回：array

Hypoth_McNemarTest(x, alpha)

声明：function

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

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

返回：array

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

声明：function

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

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

返回：array

Hypoth_PSignTest(x, pi, q0, tail, alpha)

声明：function

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

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

返回：array

Hypoth_PWilcoxonTest(x, m0, tail, alpha)

声明：function

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

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

返回：array

Hypoth_SignTest(x, pi, q0, tail, alpha)

声明：function

非参数检验-符号检验。对单样本进行符号检验 可以按照实际需求选择双侧或单侧检验 其中，检验变量服从二项分布

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

返回：array

Hypoth_SNDTest(x, d2, tail, alpha)

声明：function

单个正态总体方差的卡方检验，返回的结果是一个数组，第一个数为统计值，二为p值，三为原假设的值（0表示拒绝，1表示接受） 模型表达： 原假设：tail取值both：；left：；right： 检验统计量： 其中：为假设检验的方差，n为样本容量，s为样本标准差

参数	类型	说明
x	array	样本序列，为一维数组类型
d2	float	假设检验的方差，为实数类型
tail	string	假设检验类型
alpha	float	显著性水平，实数或整数，在01之间

返回：array

Hypoth_SNUTest(x, u, d, tail, alpha)

声明：function

单个正态总体的均值检验，分为标准差未知和已知两个情况，返回结果是一个数组，第一个数为统计值，二为p值，三为原假设的值（0表示拒绝，1表示接受） 模型表达： 原假设：tail取值both：；left：；right： 检验统计量：分为两种情况 1）标准差已知时，即d有取值，为U检验： 2）标准差未知时，即d取nil，为T检验： 其中：x为样本均值，为检验均值，为正态总体标准差，n为样本容量，s为样本标准差

参数	类型	说明
x	array	样本序列，为一维数组类型
u	float	假设检验均值，为实数类型
d	float	正态总体的标准差，为实数类型，若未知，则输入nil
tail	string	假设检验的三种类型，字符串，取值为both、left和right
alpha	float	显著性水平，实数或整数，在01之间

返回：array

Hypoth_TailRes(sta, v, tail, alpha)

声明：function

根据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

Hypoth_TNDTest(x, tail, alpha)

声明：function

两个正态总体方差比的F检验，返回的结果是一个数组，第一个数为统计值，二为p值，三为原假设的值（0表示拒绝，1表示接受） 模型表达： 原假设：tail取值both：；left：；right： 检验统计量： 其中：Sx为x的样本标准差，Sy为y的样本标准差

参数	类型	说明
x	array	样本序列矩阵，第一行为样本1，第二行为样本2，为二维数组类型
tail	string	假设检验类型
alpha	float	显著性水平，实数或整数，在01之间

返回：array

Hypoth_TNUTest(x, uu, d, tail, alpha, isequal)

声明：function

两个正态总体均值差的检验，分为标准差未知和已知两个情况，返回的结果是一个数组，第一个数为统计值，二为p值，三为是否接受原假设 模型表达： 原假设：tail取值both：；left：；right： 检验统计量： 标准差已知时，即d数组有取值，为u检验： 标准差未知时，即d取(nil,nil)，为t检验：， 其中：为样本x的均值，为样本y的均值，，为正态总体x，y的方差，分别为样本x和y的容量，为联合样本标准差

参数	类型	说明
x	array	样本序列矩阵，为二维数组类型，第一行为样本1，第二行为样本2
uu	float	假设检验均值差，为实数类型
d	float	正态总体的标准差数组，为一维数组类型，若未知，则输入(nil,nil)
tail	string	假设检验的三种类型，字符串，取值为both、left和right
alpha	float	显著性水平，实数或整数，在01之间
isequal	bool	object

返回：array

Hypoth_WilcoxonTest(x, m0, tail, alpha)

声明：function

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

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

返回：array

ifThen3(left, right, r1, r2, r3)

声明：function

比较left与Right大小，若Left大，则返回r1;若相等，返回r2;若Right大，返回r3

参数	类型	说明
left	real	实数
right	real	实数
r1	expr	表达式
r2	expr	表达式
r3	expr	表达式

返回：expr

示例

return ifThen3(1, 2, '左大', '相等', '右大');
// 返回：’右大’

importFile2(_type, alias, file_name, data, include_header, include_index, force_single, sheet, range)

声明：function

导入excel中指定Sheet的内容，可选择指定数据范围Range。仅支持Type类型为ftxls()的，为了兼容其他类型，如果输入的类型是非ftxls()的，则执行importfile导入数据且无法指定数据位置Range

参数	类型	说明
_type	integer	整数类型。参考导入导出类型函数。
alias	string	字符串类型。参考目录别名。
file_name	string	字符串类型。文件名称。
data	bool	变参返回，存贮导入的数据。当导入成功的时候，数据将存放在Data。
include_header	bool	布尔类型。为真时认为导入的文件包含字段头部信息。缺省时候为真。
include_index	bool	布尔类型。为真时认为导入的文件包含数组下标信息。缺省时候为假。
force_single	bool	布尔类型。为真时认为导入的文件是一个一维数组。缺省时候为假。
sheet	string	字符串类型，指定Sheet。
range	string	字符串类型，指定单元格范围，如果为空导入Sheet的所有数据，非空则必须为excel的Range，如:“A1:E13“。

返回：bool

示例

// 导入"C:\\test.xlsx"文件中的Sheet3的"C2:E5"数据，包含字段名称。
ret := rdo2 importFile2(ftXls(), "", "C:\\test.xlsx", data, 1, 0, 0, "Sheet3", "C2:E5");
if ret then
return data;
else
return "导入失败";
// 输出：
// 无输出。
// Excel的数据：

integral(call_back, a, b, method)

声明：function

求函数的数值积分

参数	类型	说明
call_back	string	计算被积函数值的回调
a	double	实型变量。积分下限
b	double	实型变量。积分上限
method	string	积分方法

返回：double

示例

a := 1;
b := 3;
callback := "fun1";
return integral(callback, a, b, ’romberg’);
// 其中fun1函数：
function fun1(x)
begin
return 2 * x+1;
end;
// 结果：10

interp(x, y, xi, method)

声明：function

分段插值函数，根据给定的数据 x,y 对数据xv进行分段插值,可选择方法

参数	类型	说明
x	array of real	实型一维数组，长度为N。存放给定N个点的值Xi，要求X0<X1...<Xn-1
y	array of real	实型一维数组，长度为N。存放N个给定点上的函数值Yi
xi	array of real	实数或者一维实数数组，存放指定插值点的值
method	string	方法选择，具体取值如下:

返回：array

示例

x := array(0, 0.01)->1;
y := x^2-x;
xi := array(0.005, 0.01)->1;
yi := interp(x, y, xi, 'spline');
return yi;
// 结果：6
1、"nearest"
x_ := array(5, 1, 19, 8);
y_ := array(2, 3, 1, 7);
xi := array(4, 12);
return interp(x_, y_, xi, "nearest");
// 返回： array(2,7)
2、" linear" 分段线性插值
x_ := array(5, 1, 19, 8);
y_ := array(2, 3, 1, 7);
xi := array(4, 12);
return interp(x_, y_, xi, "linear");
// 返回： array(2.25,4.8182)
3、"spline" 三次样条插值
x_ := array(5, 1, 19, 8);
y_ := array(2, 3, 1, 7);
xi := array(4, 12);
return interp(x_, y_, xi, "spline");
// 返回： array(1.1407,13.9444)
4、"pchip" 分段三次hermite插值
x_ := array(5, 1, 19, 8);
y_ := array(2, 3, 1, 7);
xi := array(4, 12);
return interp(x_, y_, xi, "pchip");
// 返回： array(2.0156,6.7115)

intLinProg(f, a, b, aeq, beq, int_par)

声明：function

（线性规划，包括整数规划，01规划建议统一使用prog_L函数）解决如下整数规划模型问题

参数	类型	说明
f	array of real	一维实数数组，表示整数规划模型的目标函数系数；
a	array of real	二维实数数组，表示整数规划模型的带“”约束方程系数矩阵，如果是带“”，则将该方程两边同乘以“-1”；
b	array of real	一维实数数组，表示整数规划模型带“”约束方程的约束值；
aeq	array of real	二维实数数组，表示整数规划模型带“=”约束方程系数矩阵；
beq	array of real	一维实数数组，表示整数规划模型带“=”约束方程的约束值；
int_par	array of real	一维整数数组，表示要取整数的变量，缺省时表示全部变量取整；

返回：array

示例

Find x that Maximum
f(x) =40x1+90x2
subject to
9x1+7x2≤ 56
7x1 + 20x2≤ 70
0 ≤ x1, 0 ≤ x2
x1, x2整数
// TSL代码：
f := array(-40, -90);
a := array((9, 7), (7, 20));
b := array(56, 70);
aeq := array();
beq := array();
int_par := array();
return intLinProg(f, a, b, aeq, beq, intpar);
// 结果：x1=4,x2=2,f(x)=-340

isDefinite(h)

声明：function

判断矩阵是否正定、半正定，采用 Cholesky 分解方法

参数	类型	说明
h	array	array 样本

返回：real

示例

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

isSymmetry(a, tol)

声明：function

判断是否为对称矩阵

参数	类型	说明
a	array	array 二维数组
tol	real	real 精度

返回：integer

示例

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

kurt(t, real)

声明：function

峰度

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

返回：any

示例

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

LeastSquares_CurveFitting(f, y)

声明：function

最小二乘法进行回归

参数	类型	说明
f	array	二维数字数组类型，系数矩阵
y	array	一维数字数组类型，观察数据值

返回：array

linear(x, y, xi)

声明：function

线性插值

参数	类型	说明
x	array	一维数组 横坐标序列
y	array	一维数组 纵坐标序列
xi	array	一维数组 插值点序列

返回：array

示例

uses interp_unit; // 置顶
x := array(5, 1, 19, 8);
y := array(2, 3, 1, 7);
xi := array(4, 12);
return interp_unit.linear(x, y, xi);
// 输出：array(2.66666666666667,1.77777777777778)

linearProgramming(f, a, b, aeq, beq)

声明：function

（线性规划，包括整数规划，01规划建议统一使用prog_L函数）,解决如下线性规划模型问题

参数	类型	说明
f	array of real	一维实数数组，表示线性规划模型的目标函数系数；
a	array of real	二维实数数组，表示线性规划模型的带“”约束方程系数矩阵，如果是带“”，则将该方程两边同乘以“-1”；
b	array of real	一维实数数组，表示线性规划模型带“”约束方程的约束值；
aeq	array of real	二维实数数组，表示线性规划模型带“=”约束方程系数矩阵；
beq	array of real	一维实数数组，表示线性规划模型带“=”约束方程的约束值；

返回：any

示例

Find x that minimizes
f(x) = –5x1 – 4x2 –6x3,
subject to
x1 – x2 + x3 ≤ 20
3x1 + 2x2 + 4x3 ≤ 42
3x1 + 2x2 ≤ 30
0 ≤ x1, 0 ≤ x2, 0 ≤ x3.
// TSL代码：
f := array(-5, -4, -6);
a := array((1, -1, 1), (3, 2, 4), (3, 2, 0));
b := array(20, 42, 30);
aeq := array();
beq := array();
return linearProgramming(f, a, b, aeq, beq);
// 结果：x1=0,x2=15,x3=3,f(x)=-78

LnRegression_CallBack(x)

声明：function

Ln(x)回归回调函数

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

返回：array

maxDrawDown(data, updn, interval, ifabs)

声明：function

最大回撤

参数	类型	说明
data	array	一维数字序列
updn	bool	涨跌标示符。1为求最大涨，0为求最大跌（默认值）
interval	integer	最大区间，为空或者小于1时，求整个区间（默认值）
ifabs	float	预留字段，暂时没有实际意义，可不给值 。

返回：real/table

示例

范例01：

// 计算一组序列的最大涨幅
data := array(3, 1, 7, 5, 6, 3);
return maxDrawDown(data, 1);
// 结果：
1
2
6
6
// 输出：说明：入点为data[1]，出点为data[2]，两者差为6，最大涨幅比例差为6

范例02：

// ------计算100日股票的最大跌幅
setSysParam(pn_stock(), 'SZ000002');
setSysParam(pn_date(), 20181031T);
setSysParam(pn_rate(), 1);
setSysParam(pn_rateday(), 20181031T);
setSysParam(pn_cycle(), cy_day());
data := nDay3(100, close());
t := maxDrawDown(data);
return t;
// 结果t：
12
43
6.96759
0.25765
// 注：若需计算最大跌幅率，则只需t[3] * 100即可。

mbbub(p, z)

声明：function

排序，对数组P按照从小到大的顺序排序，把数组排序的顺序对应的下标值返回到数组Z中

参数	类型	说明
p	array	一维数字数组类型
z	array	一维数字数组类型

返回：array

示例

p := array(2.72, 1.24, 1.31, 0.02, 0.88, 2.18);
return mbbub(p, z);

meanAndPopnStdDevWithRate(data, rate, mean, stddev)

声明：function

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

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

返回：real

示例

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

mergeGraph(g1, g2, g3, gn)

声明：function

将运行结果为图像的多个参数图像叠加，返回叠加后的图形组合

参数	类型	说明
g1	graph	图形1，一般是由graph函数返回的图形
g2	graph	图形2，一般是由graph函数返回的图形
g3	graph	图形3，一般是由graph函数返回的图形
gn	graph	图形n，一般是由graph函数返回的图形

返回：graph

示例

setSysParam(pn_stock(), 'SZ000063');
setSysParam(pn_date(), 20190301T);
setSysParam(pn_nday(), 100);
t1 := nDay2(gfOpen(), open() ,
gfClose(), close(),
gfHigh(), high(),
gfLow(), low(),
gfTime(), dateTimeToStr(sp_time()),
// KLine颜色
gfColor(), ifThen3(close(), open(),
clRed() , // 涨颜色
clYellow() , // 平颜色
clLime() // 跌颜色
),
gfFill(), ifThen3(close(), open(), flClear(), flSolid(), flSolid())
);
t2 := nDay2('MA5', ma(close(), 5)); // 5日均线
t3 := nDay2('MA10', ma(close(), 10)); // 10日均线
t4 := nDay2('MA20', ma(close(), 20)); // 20日均线
g1 := graph(gtKLine(), 'KLine', t1);
g2 := graph(gtLine(), 'MA5', t2);
g3 := graph(gtLine(), 'MA10', t3);
g4 := graph(gtLine(), 'MA20', t4);
return mergeGraph(g1, g2, g3, g4);
// 返回:

minRecoveryTime(r, n1, n2)

声明：function

最小恢复时间

参数	类型	说明
r	array	(一维数字数组) 序列,
n1	integer	Int 买入点位置,
n2	integer	Int 卖出点位置

返回：integer

示例

// 科大讯飞(SZ002230)在20201220最近十个交易日序列中第一天购买第二天卖出后的最小恢复时间
setSysParam(pn_stock(), "SZ002230");
setSysParam(PN_Date(), 20201220t);
r := nDay(10, "close", close())[: , "close"];
return minRecoveryTime(r, 0, 1);
// 输出：6

multipleExecute(exp)

声明：function

表达式求值

参数	类型	说明
exp	texpression	表达式

返回：array

multipleRegression(x, y, call_back)

声明：function

多元回归

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

返回：array

示例

x:=array((0.00,0.00),(0.00,1.00),(1.00,0.00),(1.00,1.00));
y:=array(1.00,2.00,2.00,3.00);
call_back:='MultipleRegression_CallBack';
multipleRegression(x,y,call_back);
//结果：

MultipleRegression_CallBack(x)

声明：function

多元线性回归的回调函数

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

返回：array

MultipleRegression_Pgm(x, y)

声明：function

多元线性回归测试

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

返回：array

MultipleUnLinearRegression_Pgm(x, y, call_back)

声明：function

多元非线性回归测试

参数	类型	说明
x	array	二维数字数组类型，观察数据点
y	array	一维数字数组类型，观察数据值
call_back	string	字符串类型

返回：array

MultiUnLineralRegression_CallBack(x)

声明：function

多元非线性回归的回调函数

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

返回：array

multyValue(v1, v2)

声明：function

乘法（财务分析）

参数	类型	说明
v1	real	实型，期末值
v2	real	实型，期初值

返回：real

示例

// 返回取-3与-5的乘积。
return multyValue(-3, -5);
// 结果：-15

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), array(0.2, 0.4, 0.6), rho, 2, array());
// 输出：近似 array(0.0077,0.0001)，每次运行可能略有差异。

nanMean(a)

声明：function

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

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

返回：real

示例

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

nanPercentRankArr(a, f_name)

声明：function

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)

nanPopnStd(a)

声明：function

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

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

返回：real

示例

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

nanPopnVariance(a)

声明：function

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

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

返回：real

示例

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

nanRankArr(a, f_name, sortorder)

声明：function

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)

nanStd(a)

声明：function

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

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

返回：real

示例

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

nanSum(a)

声明：function

计算含Nan一维数组的总和

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

返回：real

示例

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

nanVariance(a)

声明：function

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

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

返回：real

示例

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

nchoosek(n, k)

声明：function

样本组合

参数	类型	说明
n	array	样本(一维数组)
k	integer	每组样本数量(整数)

返回：array

示例

Returnnchoosek(array('a', 'b', 'c', 'd'), 2);
// 输出：
array(
("d", "c"),
("d", "b"),
("d", "a"),
("c", "b"),
("c", "a"),
("b", "a"))

NonLP_BSearch(fun, x0, h)

声明：function

一维盲人搜索方法，目标函数既可以是单峰，也可以是多峰。返回最优点和最优值。（中间函数）

参数	类型	说明
fun	string	目标函数表达式，为字符串类型
x0	float	初值，为实数类型；
h	float	步长，为实数类型；

返回：array

NonLP_Fibonacci(fun, a, b)

声明：function

（一维最小值搜索建议统一使用NonLP_Fminbnd函数），斐波那契法，用斐波那契数列去搜索[a,b]区间内目标函数的最小值，返回最优点和最优值

参数	类型	说明
fun	string	目标函数表达式，为字符串类型；
a	float	区间左侧，为实数类型；
b	float	区间右侧，为实数类型

返回：array

NonLP_Fminbnd(fun, a, b, methods)

声明：function

一维最小值搜索，求解模型如下： min fun(x)

参数	类型	说明
fun	string	目标函数(函数名字符串)
a	float	下界，实数
b	float	上界，实数
methods	any	方法选择0 :黄金分割法+抛物线法（默认）1 : 盲人收索法2 :黄金分割法3 :斐波那契法

返回：array

NonLP_Fmincon(fun, x0, a, b, aeq, beq, nonlcon, c, methods)

声明：function

（非线性规划建议统一使用prog_n函数）默认选项只适合于单纯的等式约束问题或者单纯的不等式约束问题，罚函数+转轴法/模式搜索法适合于任何问题，结果返回最优点、最优值和迭代次数。 可求解如下问题

参数	类型	说明
fun	string	目标函数表达式，为字符串类型；
x0	array	初值向量，为一维数组类型；
a	array	线性矩阵不等式约束，为二维数组类型；
b	array	线性向量不等式约束值，为一维数组类型；
aeq	array	线性矩阵等式约束，为二维数组类型；
beq	array	线性向量等式约束值，为一维数组类型；
nonlcon	string	非线性约束回调，为字符串类型；nonlcon回调需用户自己新建一个函数，然后把函数名传进nonlcon，函数格式如下:；Function “函数名”(x);；Begin
c	any	=array();//*；C[0]:=……；C[1]:=……；……；Ceq:=array();//*；Ceq[0]:=……；Ceq[1]:=……；……；Return array(0:c,1:ceq);//*；End;；//*号的式子一定要写
methods	any	优化方法（0:默认，1:罚函数+转轴法，2:罚函数+模式搜索法），为用户自定义类型（整型）；

返回：array

NonLP_Fminsearch(fun, x0, methods)

声明：function

无约束最小值求解,求解模型如下： min fun(x)

参数	类型	说明
fun	string	目标函数，函数名字符串
x0	array	初始值，一维数字数组
methods	any	方法选择0 单纯形法1 转轴法2 模式搜索法3 拟牛顿下山法（默认方法，推荐使用）

返回：array

NonLP_Golden(fun, a, b)

声明：function

（一维最小值搜索建议统一使用NonLP_Fminbnd函数），黄金分割法搜索[a,b]区间内目标函数的最小值，返回最优点和最优值

参数	类型	说明
fun	string	目标函数表达式，为字符串类型；
a	float	区间左侧，为实数类型；
b	float	区间右侧，为实数类型

返回：array

NonLP_GP(fun, a, b)

声明：function

（一维最小值搜索建议统一使用NonLP_Fminbnd函数），黄金分割+抛物线插值法：一维优化方法，返回最优点和最优值

参数	类型	说明
fun	string	目标函数表达式，为字符串类型；
a	float	区间左侧，为实数类型；
b	float	区间右侧，为实数类型；

返回：array

NonLP_Hooke_Jeeves(fun, x0)

声明：function

（无约束最小值求解建议统一使用NonLP_Fminsearch函数）模式搜索法，又叫Hooke-Jeeves法，求解无约束多维极值问题，返回最优点和最优值

参数	类型	说明
fun	string	目标函数表达式，为字符串类型；
x0	array	初值向量，为一维数组类型

返回：array

NonLP_minFactor(fun, x0, aeq, beq, nonlcon)

声明：function

（非线性规划建议统一使用prog_n函数）,乘子法求等式约束问题，可求解如下问题

参数	类型	说明
fun	string	目标函数表达式，为字符串类型；
x0	array	初值向量，为一维数组类型；
aeq	array	线性矩阵等式约束，为二维数组类型；
beq	array	线性向量等式约束值，为一维数组类型；
nonlcon	string	非线性约束回调，为字符串类型；

返回：array

NonLP_minPS(fun, x0, a, b, nonlcon)

声明：function

（非线性规划建议统一使用prog_n函数）,坐标轮换法求不等式约束问题，初值必须在可行域内！可求解如下问题

参数	类型	说明
fun	string	目标函数表达式，为字符串类型；
x0	array	初值向量，为一维数组类型；
a	array	线性矩阵不等式约束，为二维数组类型；
b	array	线性向量不等式约束值，为一维数组类型；
nonlcon	string	非线性约束回调，为字符串类型；

返回：array

NonLP_minSUMT(fun, x0, a, b, aeq, beq, nonlcon, methods)

声明：function

（非线性规划建议统一使用prog_n函数）混合惩罚函数+转轴法/模式搜索法：可解所有优化问题，返回最优点、最优值和迭代次数。可求解如下问题

参数	类型	说明
fun	string	目标函数表达式，为字符串类型；
x0	array	初值向量，为一维数组类型；
a	array	线性矩阵不等式约束，为二维数组类型；
b	array	线性向量不等式约束值，为一维数组类型；
aeq	array	线性矩阵等式约束，为二维数组类型；
beq	array	线性向量等式约束值，为一维数组类型；
nonlcon	string	非线性约束回调，为字符串类型；
methods	string	方法选择,’NM’,’Rb’,’HJ’

返回：array

NonLP_Nelder(fun, x0)

声明：function

（无约束最小值求解建议统一使用NonLP_Fminsearch函数）内德-米德法，无约束多维的非线性规划方法，即单纯形法。返回最优点和最优值

参数	类型	说明
fun	string	目标函数表达式，为字符串类型；
x0	array	初值向量，为一维数组类型

返回：array

NonLP_Range(fun, x0, h)

声明：function

进退法，可一维优化问题的确定搜索区间，但目标函数必须是单峰函数，返回结果为上下界的取值。（中间函数）

参数	类型	说明
fun	string	目标函数表达式，为字符串类型
x0	float	初值，为实数类型；
h	float	步长，为实数类型；

返回：array

NonLP_Rosenbrock(fun, x0)

声明：function

（无约束最小值求解建议统一使用NonLP_Fminsearch函数）Rosenbrock求无约束多维极值问题，返回最优点和最优值

参数	类型	说明
fun	string	目标函数表达式，为字符串类型；
x0	array	初值向量，为一维数组类型

返回：array

norm2(a, flag)

声明：function

范数

参数	类型	说明
a	array	二维数字数组 样本
flag	string	string 范数类型

返回：real

示例

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

Norm_LinearTransform(mu, sigma, a, b)

声明：function

正态分布线性变换，得到变换后的均值、协方差或方差

参数	类型	说明
mu	array	实数或二维数组（n*1），原正态分布均值
sigma	array	实数或二维数组（n*1），原正态分布方差
a	array	实数或二维数组（n*1），线性变换常数项
b	array	实数或二维数组（n*1），线性变换系数项

返回：array

normfit(x, alpha)

声明：function

根据样本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的显著性水平下的区间估计

norminv(p, mu, sigma)

声明：function

正态逆函数

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

返回：float | array

示例

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

normPlot(x, return_type)

声明：function

基于正态概率的正态性检验, 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

NW_Adjustment_Simplification(y, alpha, al)

声明：function

在单因子有效性的检验中，进行检验的往往是组合收益率序列或者因子收益率序列在 时序上是否显著异于零，这一过程本身并不涉及回归过程，因此无法直接使用上一节中介绍的调整方法。然而，我们知道组合收益或者因子收益在时序上极有可能存在异方差和自相关特性，因此在计算序列标准误时，必须对其进行 Newey-West 调整，从而得到其标准差的一致性估计，进而得到更稳健的 t 值。 关于这个问题Bali et al(2016)指出对于单个因子收益率序列的显著性检验，我们可以将其转换为一个简单的线性回归模型：将 1 作为自变量，将因子收益率作为因变量，进行回归得到残差变量。此时残差项即为因子收益率减去它在时间序列上的均值。把残差项和X=1代入即可得到简化的结果，对Q的估计形式如下：QNW-Simple=1Tt=1Tet2+l=1Lt=l+1Twletet-l 其中，wl=1-l1+L 这里的Q实际上不是矩阵，只是一个数。 将Q代入Cov[β*]中就可以求出收益率方差的估计，之后就可以进行T检验了。σ2=QNW-Simple/T

参数	类型	说明
y	array	一维数字数组, 因变量
alpha	float	实数，显著性水平，应为0到1之间的值，默认0.05
al	any	整数，自相关最大滞后阶数，可缺省，默认用Newey and West (1994)?提出的方法计算，至少为1

返回：array

orth(a)

声明：function

矩阵范围内的标准正交基向量

参数	类型	说明
a	array	数组，

返回：array

示例

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

outPutGrowRatio(v1, v2)

声明：function

增长率(%)

参数	类型	说明
v1	float	实型，期末值
v2	float	实型，期初值

返回：float

示例

//返回13到14的增长率(%)
outPutGrowRatio(14,13);
//结果：7.69

outPutGrowRatio2(v1, v2)

声明：function

增长率(%)

参数	类型	说明
v1	float	实型，期末值
v2	float	实型，期初值

返回：float

示例

//返回13到14的增长率(%)
outPutGrowRatio2(14,13);
//结果：7.69

outPutGrowRatio3(v1, v2)

声明：function

增长率(%)

参数	类型	说明
v1	real	实型，期末值
v2	real	实型，期初值

返回：real

示例

// 返回14到13的增长率(%)
return outPutGrowRatio3(14, 13);
// 结果：7.69

outPutGrowValue(v1, v2)

声明：function

增长

参数	类型	说明
v1	real	实型，期末值
v2	real	实型，期初值

返回：real

示例

// 返回13与14的差值
return outPutGrowValue(13, 14);
// 结果：-1

outPutGrowValue2(v1, v2)

声明：function

增长

参数	类型	说明
v1	float	实型，期末值
v2	float	实型，期初值

返回：float

示例

//返回13与14差值
outPutGrowValue2(13,14);
//结果：-1

outPutGrowValue3(v1, v2)

声明：function

增长

参数	类型	说明
v1	real	实型，期末值
v2	real	实型，期初值

返回：real

示例

// 返回13与14的差值
return outPutGrowValue3(13, 14);
// 结果：-1

outPutLnGrowRatio(v1, v2)

声明：function

对数增长率输出(%)

参数	类型	说明
v1	real	实型，期末值
v2	real	实型，期初值

返回：real

示例

// 取3与4的对数增长率
return outPutLnGrowRatio(3, 4);
// 结果：-28.77

outPutValueByUnit(data_type, data_unit)

声明：function

单位转换

参数	类型	说明
data_type	string	字符串，数据类型
data_unit	real	实型，指定单位

返回：real

示例

// 返回1234.5以10为单位转换后的结果
return outPutValueByUnit(1234.5, 'Real', 10);
// 结果：123.45

ozProg(f, a, b)

声明：function

（线性规划，包括整数规划，01规划建议统一使用prog_L函数）,0-1规划，解决如下0-1整数规划模型问题 返回该0-1规划模型的最小值及其对应变量的取值,其中可以转化为和

参数	类型	说明
f	array	一维实数数组，表示0-1规划模型的目标函数系数；
a	array	二维实数数组，表示0-1规划模型的带“”约束方程系数矩阵，如果是带“”，则将该方程两边同乘以“-1”；
b	array	一维实数数组，表示0-1规划模型带“”约束方程的约束值；

返回：array

示例

f:=array(-3,2,-5);
a:=array((1,2,-1),(1,4,1),(1,1,0),(4,0,1));
b:=array(2,4,3,6);
ozProg(f,a,b);
//结果：x1=1,x2=0,x3=1,f(x)=-8

percentage(y, per, style)

声明：function

百分位去极值

参数	类型	说明
y	array	数字数组，待处理数据
per	real|array	实数或者一维数字数组，去极值百分位；5表示 5%；
style	integer	整数，0 或者不输入时 去 百分位大于 per 和小于per的；1, 去除小于per的；2 去除 大于per的 数据

返回：array

示例

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

percentileOfScore(data, score, _type)

声明：function

百分位占比(%)

参数	类型	说明
data	array	数组 待处理数据,
score	float	float 待排序值,
_type	integer	算法

返回：array

示例

// 去除随机数组的极值
data := array(1, 2, 2, 4);
ret := array();
n := 0;
for i := 0 to 5 do
begin
ret[n, 'score'] := i;
for j, kind in array('rank', 'strict', 'weak', 'mean')do
begin
ret[n, kind] := percentileOfScore(data, i, j);
end
ret[n, 'percenrank'] := percentrank(data, i);
n++;
end;
return ret;

perms(x)

声明：function

样本排列

参数	类型	说明
x	array	样本，数组或数字

返回：array

示例

范例01：求10的阶乘

return perms(10);
// 输出：3628800

范例02：排列组合

return perms(array("a", "b", "c"));
// 输出：
array(
("c", "b", "a"),
("c", "a", "b"),
("b", "c", "a"),
("b", "a", "c"),
("a", "b", "c"),
("a", "c", "b"))

范例03：返回数组Array(('A','B'),('C', 'D'))中任意两个数据的排列组合

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

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

function test_1cth();
begin
func := createobject("funcexe");
a := array("A", "B", "C");
return perms(a, 3, func);
end;
type funcexe = class()
data;
function create();
begin
data := "";
end
function exe(dat);
begin
data+=dat;
end
end

PieLine_Web(r, graph_title, return_type)

声明：function

返回饼图

参数	类型	说明
r	array	数据表类型，数据；
graph_title	string	字符串，图形标题；
return_type	any	整数，返回类型。

返回：array

pinv(a, t)

声明：function

伪逆

参数	类型	说明
a	array	array 矩阵
t	real	real 精度 默认为 2.220446049250313e-016

返回：array

示例

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

poissfit(x, alpha)

声明：function

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

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

返回：any

示例

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

polynomialRegression(x, y, m)

声明：function

多项式回归

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

PolynomialRegression_Pgm(x, y, m)

声明：function

多项式回归测试

参数	类型	说明
x	array	一维数字数组类型
y	array	一维数字数组类型
m	any	整数类型，拟合最大阶数

返回：array

princaipalComponentAnalysis(zt)

声明：function

主成分分析

参数	类型	说明
zt	array	二维数字数组类型，样本矩阵

返回：array

示例

// 设置样本矩阵
zt := array((0.7592, 1.7593, 21.9279, 48.5626, 55.1679),
(0.0490, 0.4457, 2.2255, 82.2658, 192.4348),
(-2.2313, -1.3096, -59.8883, 3.9922, -80.2419),
(0.1364, 0.539, 4.3910, 55.1438, 46.0612),
(0.7233, 1.9467, 15.6127, 111.3018, 58.3969));
return princaipalComponentAnalysis(zt);

princomp(x, ep, is_stand, resid)

声明：function

主成分分析，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);

Prog_L(f, a, b, aeq, beq, lb, ub, x0, options, ozarr, intarr)

声明：function

使用单纯形法，和起作用集法，系统默认作用集形法求解线性规划问题，即求解目标都为线性和约束条件都为线性的规划问题 Prog_L(f,A,b) 求解不等式约束 Prog_L(f,A,b,Aeq,beq) 求解不等式约束、等式约束 Prog_L(f,A,b,Aeq,beq,LB,UB) 求解不等式约束、等式约束、上下界限约束 Prog_L(f,A,b,Aeq,beq,LB,UB,x0,options) 求解不等式约束、等式约束，上下限约束，加入用户算法设置 Prog_L(f,A,b,Aeq,beq,LB,UB,x0,options,ozarr) 求解不等式约束、等式约束、上下限约束、0-1 约束 Prog_L(f,A,b,Aeq,beq,LB,UB,x0,options,ozarr,intarr) 求解不等式约束、等式约束、上下限约束、0-1 约束、整数约束 模型表达： min= sum(f*x) st. A:*x<=b Aeq :* x = Beq lb<x<ub x = (0 or 1) x = integer

参数	类型	说明
f	array	线性目标，一维数字数组，不可缺省
a	array	线性约束，二维数字数组，不可缺省
b	array	线性约束，一维数字数组，不可缺省
aeq	array	线性约束，二维数字数组，缺省为空
beq	array	线性约束，一维数字数组，缺省为空
lb	array	下界约束，一维数字数组，缺省为空
ub	array	上界约束，一维数字数组，缺省为空
x0	array	初始值，一维数组
options	array	选项设置，数据表类型，缺省为:；array( 'algorithm' :'activeset'，//'simplex' 单纯形，'activeset' 作用集法；//(当整数、0-1 约束时推荐使用)；'maxiter': 400 , //最大迭代次数；'tolcon': 1.0e-10, //约束容忍误差；'tolfun' : 1.0e-8 , //目标最小误差；'tolx' : 1.0e-8 //变量最小变化)
ozarr	array	01约束条件，第1个变量为01变量则ozarr := array(0)
intarr	array	整数约束条件，第2,3两个变量为整数变量则 intarr:=array(1,2)；返回结果:；数据表类型；ret["X"] : 变量取值，一维数字数组；ret["Fval"] :规划目标值，实数；ret["Error_M"] : 结果信息，整数；ret["Iter"] : 迭代次数,整数

返回：array

Prog_M(fun, x0, goal, weight, a, b, aeq, beq, lb, ub, nlc, options)

声明：function

求解多目标规划问题 模型表达： min AttainFactor st. f(x)-AttainFactor*wight <=goal //目标约束 c(x)<=0; //非线性不等式约束 ceq(x)=0; //非线性等式约束 A*x<=b; //线性不等式约束 aeq*x=beq; //线性等式约束 lb<=x<=ub ; //边界约束

参数	类型	说明
fun	array	目标函数，函数名字符串
x0	array	初始值
goal	array	目标中各个分目标的差，一维数组和目标个数相同
weight	array	目标中各个分量的在总体中的比重，一维数组和目标个数相同
a	array	不等式约束，二维数组
b	array	不等式约束，一维数组
aeq	array	等式约束，二维数组
beq	array	等式约束，一维数组
lb	array	下界，一维数组
ub	array	上界，一维数组
nlc	string	非线性约束，约束函数名字符串
options	array	算法参数设置，默认为:array('maxiter':400, //最大迭代次数'maxfunevals':'100*numberofvariables', //目标回调最大次数'tolcon':1.0e-6,//约束容忍误差'tolfun' :1.0e-6,//目标最小误差'tolx' :1.0e-6, //变量最小变化'diffmaxchange':1e-1,//差分时最大步长'diffminchange':1e-8)// 差分时最小步长

返回：array

Prog_N(fun, x0, a, b, aeq, beq, lb, ub, nlc, options)

声明：function

采用拟牛顿下山方法求解非线性规划求解。 Prog_n(fun,x0) 无约束最小值约束 Prog_n(fun,x0,A,B) 非线性不等式约束求解 Prog_n(fun,A,b,Aeq,beq) 求解不等式约束、等式约束 Prog_n(fun,x0,A,b,Aeq,beq,LB,UB) 求解不等式约束、等式约束、上下界限约束 Prog_n(fun,x0,A,b,Aeq,beq,LB,UB,x0,options) 模型表达 1非线性无约束最小值 min fun(x) 2非线性规划求解 min fun(x) st. c(x)<=0; //非线性不等式约束 ceq(x)=0; //非线性等式约束 A*x<=b; //线性不等式约束 aeq*x=beq; //线性等式约束 lb<=x<=ub ; //边界约束

参数	类型	说明
fun	array	目标函数，目标函数名字符串类型，不可缺省。其中，目标函数的返回值必须是一个实数（1x1的矩阵，或长度为1的数组都不允许）
x0	array	初始值，一维数字数组，不可缺省
a	array	不等式约束，二维数组，缺省为空
b	array	不等式约束，一维数组，缺省为空
aeq	array	等式约束，二维数组，缺省为空
beq	array	等式约束，一维数组，缺省为空
lb	array	下界，一维数组，缺省为空
ub	array	上界，一维数组，缺省为空
nlc	array	非线性约束，函数名，字符串
options	array	算法参数设置，默认为array('maxiter':400 , //最大迭代次数'maxfunevals':'100*numberofvariables', //目标回调最大次数'tolcon':1.0e-6 ,//约束容忍误差'tolfun' :1.0e-6 ,//目标最小误差'tolx' :1.0e-6 , //变量最小变化'diffmaxchange':1e-1,//差分时最大步长'diffminchange':1e-8 )// 差分时最小步长

返回：array

Prog_Q(h, f, a, b, aeq, beq, lb, ub, x0, options)

声明：function

二次规划问题求解(采用作用集方法) Prog_Q(H,f,A,b) 求解不等式约束 Prog_Q(H,f,A,b,Aeq,beq) 求解不等式约束、等式约束 Prog_Q(H,f,A,b,Aeq,beq,LB,UB) 求解不等式约束、等式约束、上下界限约束 Prog_Q(H,f,A,b,Aeq,beq,LB,UB,x0,options) 模型表达： min= `x* H* x /2 + sum(f*x) st. A:*x<=b Aeq :* x = Beq; lb<x<ub

参数	类型	说明
h	array	二次型，正定二次型二维数字数组，不可缺省
f	array	线性目标，一维数字数组，不可缺省
a	array	线性约束，二维数字数组，不可缺省
b	array	线性约束，一维数字数组，不可缺省
aeq	array	线性约束，二维数字数组，缺省为空
beq	array	线性约束，一维数字数组，缺省为空
lb	array	下界约束，一维数字数组，缺省为空
ub	array	上界约束，一维数字数组，缺省为空
x0	array	初始值，一维数组
options	array	选项设置,数据表类型，缺省为array('maxiter': 400 , //最大迭代次数'tolcon': 1.0e-6, //约束容忍误差'tolfun' : 1.0e-6 , //目标最小误差'tolx' : 1.0e-6 //变量最小变化)

返回：array

quadLagR(h, f, aeq, beq)

声明：function

(二次规划建议统一使用prog_Q函数)解决如下二次规划模型问题

参数	类型	说明
h	array,tablearray	二维实数数组，表示二次项目标函数系数，为对称矩阵
f	array,tablearray	一维实数数组，表示二次规划模型的目标函数系数；
aeq	array,tablearray	二维实数数组，表示二次规划模型带“=”约束方程系数矩阵；
beq	array,tablearray	一维实数数组，表示二次规划模型带“=”约束方程的约束值。

返回：any

示例

Find x that minimize
f(x) = 2 * x1^2+x2^2+x1 * x2-x1-x2
subject to
x1 + x2 = 1
// TSL代码：
h := Array((4, 1), (1, 2));
f := Array(-1, -1);
aeq := array((1, 1));
beq := array(1);
return quadLagR(h, f, aeq, beq);
// 输出：解析：x1=0.25, x2=0.75, 最小值f(x)=-0.125

quadprog(h, f, a, b, aeq, beq)

声明：function

（二次规划建议统一使用prog_Q函数）,解决如下二次规划模型问题

参数	类型	说明
h	array of real	二维实数数组，表示二次项目标函数系数，为对称矩阵
f	array of real	一维实数数组，表示二次规划模型的目标函数系数；
a	array of real	二维实数数组，表示二次规划模型的带“”约束方程系数矩阵，如果是带“”，则将该方程两边同乘以“-1”；
b	array of real	一维实数数组，表示二次规划模型带“”约束方程的约束值；
aeq	array of real	二维实数数组，表示二次规划模型带“=”约束方程系数矩阵；
beq	array of real	一维实数数组，表示二次规划模型带“=”约束方程的约束值；

返回：array

示例

Find x that minimize
f(x) = 1/2 * x1^2+x2^2-x1 * x2-2x1-6x2
subject to
x1 + x2 ≤ 2
–x1 + 2x2 ≤ 2
2x1 + x2 ≤ 3
0 ≤ x1, 0 ≤ x2.
// TSL代码：
h := Array((1, -1), (-1, 2));
f := Array(-2, -6);
a := Array((1, 1), (-1, 2), (2, 1));
b := array(2, 2, 3);
aeq := array();
beq := array();
return quadprog(h, f, a, b, aeq, beq);
// 结果： x1=0.6667,x2=1.3333,f(x)=-8.2222

quadTrackRoute(h, f, a, b, aeq, beq, x0)

声明：function

（二次规划建议统一使用prog_Q函数）解决如下二次规划模型问题

参数	类型	说明
h	array of real	二维实数数组，表示二次项目标函数系数，为对称矩阵
f		一维实数数组，表示二次规划模型的目标函数系数；
a	array of real	二维实数数组，表示二次规划模型的带“”约束方程系数矩阵，如果是带“”，则将该方程两边同乘以“-1”；
b	array of real	一维实数数组，表示二次规划模型带“”约束方程的约束值；
aeq	array of real	二维实数数组，表示二次规划模型带“=”约束方程系数矩阵；
beq	array of real	一维实数数组，表示二次规划模型带“=”约束方程的约束值；
x0	array of real	变量的初始点。

返回：array

示例

Find x that minimize
f(x) = 2 * x1^2+2 * x2^2-x1 * x2+8 * x1-6x2
subject to
x1 + x2 ≤ 2
2 * x1 - x2 ≤ 1
// TSL代码：
h := Array((4, -1), (-1, 4));
f := Array(8, -6);
a := Array((1, 1), (2, -1));
b := array(2, 1);
aeq := array();
beq := array();
x0 := array(0, 0);
return quadTrackRoute(h, f, a, b, aeq, beq, x0);
// 输出：分析：x1=-1.733333, x2=1.066667, 最小值f(x)=-10.13333

randbeta(a, b, row, col)

声明：function

产生贝塔分布的随机数

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

randbino(n, p, row, col)

声明：function

产生二项分布的随机数

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

randCauchy(a, b, row, col)

声明：function

产生柯西的随机数

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

randch2(cv, row, col)

声明：function

产生卡方分布的随机数

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

返回：any

示例

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

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);
// 输出：10×3 数组；随机样本每次运行不同。

范例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);
// 输出：10×3 数组；随机样本每次运行不同。

范例03：阿基米德族，clayton(frank、gumbel调用相同)

alpha := 1;
n := 10;
return randCopula("clayton", nil, alpha, n);
// 输出：10×2 数组；随机样本每次运行不同。

randexp(mu, row, col)

声明：function

产生指数分布的随机数

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

返回：any

示例

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

randf(v1, v2, row, col)

声明：function

产生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"));

randgam(a, b, row, col)

声明：function

产生伽马分布的随机数

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

返回：any

示例

randgam(2,2,100,array("a","b"));

randgeo(n, p, row, col)

声明：function

产生几何分布的随机数

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

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

声明：function

产生超几何分布的随机数

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

randLaplace(mu, b, row, col)

声明：function

产生拉普拉斯的随机数

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

randlogn(mu, sigma, row, col)

声明：function

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

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

randnbin(r, p, row, col)

声明：function

产生负二项分布的随机数

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

randnorm(mu, sigma, row, col)

声明：function

产生正态分布的随机数

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

randpoiss(lambda, row, col)

声明：function

产生泊松分布的随机数

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

返回：any

示例

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

randrayl(b, row, col)

声明：function

产生瑞利分布的随机数

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

返回：any

示例

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

randt(cv, row, col)

声明：function

产生学生T分布的随机数

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

返回：any

示例

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

randunid(n, row, col)

声明：function

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

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

返回：any

示例

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

randunif(a, b, row, col)

声明：function

产生均匀分布的随机数

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

randwbl(a, b, row, col)

声明：function

产生威布尔分布的随机数

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

ratioValue(v1, v2)

声明：function

比率（财务分析）

参数	类型	说明
v1	real	实型，期末值
v2	real	实型，期初值

返回：real

示例

// 返回-1与-2的比率。
return ratioValue(-1, -2);
// 结果：-0.5

RatioValue_Math(v1, v2)

声明：function

比率（数学分析）。针对除法计算处理，主要是对除0情况的考虑

参数	类型	说明
v1	float	实数。期末值
v2	float	实数。期初值

返回：float

readExcelSheets(alias, file_name, sheets_name, use_ole)

声明：function

从Excel文件中读取Sheets列表

参数	类型	说明
alias	string	字符串类型。参考目录别名。
file_name	string	字符串类型。文件名称。
sheets_name	array	返回值。存贮读出的SHEETS名称，存贮为一个一维字符串数组。
use_ole	bool=false	布尔型。是否使用Excel来读取，默认直接采用读文件的方式。设置为真则要求安装Excel。

返回：bool

示例

// 读取本地文件的sheet列表名
rdo2 readExcelSheets('', 'd:\\test\\test.xls', r, 0);
return r;
// 结果：array("Sheet1","Sheet2","Sheet3")

Regress_AdjustedR2(r, t, k)

声明：function

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

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

返回：any

Regress_AicAndSbic(u, k, t)

声明：function

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

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

返回：array

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

声明：function

二元离散选择模型。返回结果有方程的系数、负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

Regress_CMLS(y, x, u, constant)

声明：function

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

参数	类型	说明
y	array	被解释变量序列，为一维数组类型
x	array	解释变量矩阵，为二维数组类型，每一列为一个解释变量
u	array	残差序列，为一维数组类型，变参
constant	bool	是否包含常数项，为布尔类型，缺省为true

返回：array

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

声明：function

线性约束最小二乘回归

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

Regress_domin_formula(y, x)

声明：function

相对重要性分析-R2公式分解法 功能描述： 1、相对重要性分析 2、算法：根据含常数项的多元回归的r2的分解公式，来计算 不同解释变量的相对贡献度 3、公式法： 未考虑到不同解释变量之间的相互关系， 贡献度可能为负数

参数	类型	说明
y	array	Array of number,因变量
x	array	Array of number,自变量

返回：array

Regress_domin_marginal(y, x, variable, option)

声明：function

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

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

返回：array

Regress_DWTest(u)

声明：function

德宾-沃森检验：检验随机误差项是否存在一阶自相关。结果返回DW统计量 DW统计量：（一般认为值在2附近，则随机误差项不存在自相关）

参数	类型	说明
u	array	方程残差，为一维数组类型；

返回：any

Regress_FTest(y, u, k, alpha)

声明：function

在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

Regress_GRStest(alpha_values, residual_matrix, factor_matrix)

声明：function

执行 GRS 检验

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

返回：array

Regress_HettestSpearman(y, x, alpha, constant)

声明：function

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

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

返回：array

Regress_JBTest(y, alpha)

声明：function

在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

Regress_Logistic(y, x, constant, alpha)

声明：function

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

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

返回：array

Regress_MLS(y, x, u)

声明：function

线性回归方程的最小二乘法参数估计（包含常数项），返回回归方程的系数，常数项排在第一项

参数	类型	说明
y	array	被解释变量序列，为一维数组类型
x	array	解释变量矩阵，为二维数组类型，每一列为一个解释变量
u	array	残差序列，为一维数组类型，变参

返回：array

Regress_NLM(func, x, y, initial)

声明：function

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

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

返回：array

Regress_pri(y, x, exps, alpha)

声明：function

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

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

返回：array

Regress_QRlsq(y, x, u, constant)

声明：function

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

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

返回：array

Regress_Ridge(y_values, x_values, k_values, trace_mode)

声明：function

执行岭回归，或按 k_values 输出岭迹

参数	类型	说明
y_values	array	因变量样本
x_values	array	自变量样本矩阵
k_values	array	可选。岭参数序列；省略时自动选择
trace_mode	bool	是否按岭迹模式输出

返回：array

Regress_RSquare(y, u, weight, dtype)

声明：function

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

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

返回：array

Regress_Stepwise(y, x, a_e, a_d)

声明：function

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

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

返回：array

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

声明：function

在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

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

声明：function

用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

Regress_TTest_RWLS(x, a, u, k, alpha, constant, weight, restrictiveness)

声明：function

T检验,在alpha的置信水平下，n元线性回归变量系数的显著性检验 原假设：回归方程系数不显著。带约束的加权最小二乘 RWLS 模型，对回归系数进行显著性检验， 适用于以下

参数	类型	说明
x	array	一维数字数组,自变量矩阵，注意:含常数项的回归不需要给全1列
a	array	一维数字数组,方程系数；有常数项时，a 为 常数项系数 union 自变量系数；无常数项时，a 为 自变量系数
u	array	一维数字数组,残差序列
k	any	整型,自变量的个数；k = length(a)-constant；有常数项回归时，k := mcols(x);；无常数项回归，k := mcols(x)-1;
alpha	float	实数,显著性水平
constant	bool	Bool,是否为含常数项回归
weight	array	数组,加权回归的权重，默认等权重
restrictiveness	array	数组,线性约束，只需要给对应于回归系数个数长度的一维数组，默认无约束；例如:有5个系数，分别为x0,x1,x2,x3,x4；约束为: x1+x2+3x4=3；则所给的参数为:；array(0,1,1,0,3)

返回：array

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

声明：function

用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

Regress_VIF(x)

声明：function

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

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

返回：array

Regress_VIFR2(x, w, constant)

声明：function

vif分析增强

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

返回：array

Regress_White(y, x, crr, alpha)

声明：function

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

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

返回：array

Regress_WLS(y_values, x_values, weights, residuals)

声明：function

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

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

返回：array

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

声明：function

线性回归方程的最小二乘法参数估计及检验（可选择是否包含常数项），返回结果有回归系数、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);

Regression_OLS_NW(y, x, constant, alpha, al)

声明：function

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

参数	类型	说明
y	array	一维数字数组, 因变量
x	array	二维数字数组, 自变量，不需要包含全1列
constant	bool	object
alpha	float	实数，显著性水平，应为0到1之间的值，默认0.05
al	any	整数，自相关最大滞后阶数，可缺省，默认用Newey and West (1994)?提出的方法计算，至少为1

返回：array

Regression_OLS_White(y, x, constant, alpha)

声明：function

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

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

声明：function

加权最小二乘法回归, 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

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

声明：function

回归通道模型

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

reIndex2(data, flag)

声明：function

修改数组的行标或列名，主要用于字符串下标修改为数字下标等

参数	类型	说明
data	array,tablearray
flag	integer

返回：array,tablearray

示例

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

// 其显示如下：

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

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

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

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

Robustfit_M(y, x, alpha, constant, wfun, tune, options)

声明：function

基于M估计的稳健回归及其检验

参数	类型	说明
y	array	一维数字数组，因变量
x	array	二维数字数组，自变量
alpha	float	实数，显著性水平
constant	bool	object
wfun	string	字符串，权重函数
tune	float	实数，调节常数
options	array	可选。为数组类型，格式为array( 'maxiter':最大迭代次数, 'tol':标准误差, 'ifregtest':是否返回回归检验)，默认值为array('maxiter':50, 'tol':1e-6, 'ifregtest':True)。其中'maxiter'、'tol'与迭代优化相关，分别表示最大迭代次数与相邻两次迭代的标准误差；'ifregtest'是布尔类型，控制输出结果是否返回回归检验，若为真，其回归检验指标使用加权最小二乘的回归检验，可参考Regression_WLS。

返回：array

roots(p)

声明：function

一元n次方程求根

参数	类型	说明
p	array	array 多项式

返回：array

示例

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

rotatedComponentMatrix(cm)

声明：function

返回方差最大正交旋转矩阵

参数	类型	说明
cm	array	二维数字数组类型，载荷矩阵

返回：array

示例

// 设置样本矩阵
zt := array((0.7592, 1.7593, 21.9279, 48.5626, 55.1679),
(0.0490, 0.4457, 2.2255, 82.2658, 192.4348),
(-2.2313, -1.3096, -59.8883, 3.9922, -80.2419),
(0.1364, 0.539, 4.3910, 55.1438, 46.0612),
(0.7233, 1.9467, 15.6127, 111.3018, 58.3969));
z_t_s := Standarize_II(z_t); // 标准化
mt_Transposition(z_t_s, z); // 转置
r := correlationMatrix(z); // 相关系数矩阵
Eigen_Jacobi(r, eigen_value, eigen_vector); // 特征值&特征向量
cm := componentMatrix(eigen_value, eigen_vector, max_eigen_value); // 载荷矩阵
return rotatedComponentMatrix(cm);

safeEval(exp)

声明：function

表达式求值

参数	类型	说明
exp	texpression	表达式类型

返回：any

safeSetSysParam(systype, value)

声明：function

设置系统参数。主要是将value的值转化为正确的对应于systype数据类型，再通过setsysparam进行设置setysparam(systype,value)，保证系统参数设置成功

参数	类型	说明
systype	string	字符串，系统参数名称
value	real	实数或字符串，系统参数值

返回：integer

selfStdDev(t, rmar)

声明：function

下方标准差

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

返回：real

示例

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

setHttpAcceptencoding(session, acceptencodingstr)

声明：function

设置设定压缩格式编码类型

参数	类型	说明
session	comobj	session ID
acceptencodingstr	string	Accept-Encoding类型

返回：any

示例

url := "http://www.baidu.com";
sid := createHttpSession();
setHttpAcceptencoding(sid, "gzip"); // 设定压缩格式编码类型
setHttpCallBack(sid, findfunction("DownProg01")); // 进度回调
r := getHttp(url, 60000, v, code);
echo "\r\nDone", '->code:', code, '->返回内容总长度:', length(v), "\r\n";
return 0;
// --------------进度回调函数---------------------
function DownProg01(sid, alldn_b, dn_b, allup_b, up_b); // progresscallback-不提前结束
begin
if dn_b > 0 then // 如果大于0则打印
begin
echo "AlldnB:", alldn_b, ",dnB:", dn_b, ",AllupB:", allup_b, ",upB:", up_b, "\r\n";
end;
return 0; // not done
end;
// 打印结果：
// 注：当http进度回调时，当服务器使用分块传输（启用压缩通常会使用分块传输）时， 无法预先知道总大小所以可能出现为0的情况，属于正常现象。

setHttpAcceptencodingon(session, is_zip)

声明：function

设置设定是否支持压缩

参数	类型	说明
session	comobj	session ID
is_zip	bool	是否支持压缩传输，默认支持

返回：any

示例

url := "http://www.baidu.com";
sid := createHttpSession();
setHttpAcceptencodingon(sid, false); // 设定为不允许压缩传输
setHttpCallBack(sid, findfunction("DownProg01")); // 进度回调
r := getHttp(url, 60000, v, code);
echo "\r\nDone", '->code:', code, '->返回内容总长度:', length(v), "\r\n";
return 0;
// --------------进度回调函数---------------------
function DownProg01(sid, alldn_b, dn_b, allup_b, up_b); // progresscallback-不提前结束
begin
if dn_b > 0 then // 如果大于0则打印
begin
echo "AlldnB:", alldn_b, ",dnB:", dn_b, ",AllupB:", allup_b, ",upB:", up_b, "\r\n";
end;
return 0; // not done
end;
// 打印信息如下：

sf_betacdf(x, a, b, v)

声明：function

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

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

返回：any

sf_betainv1(y, a, b)

声明：function

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

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

返回：array

sf_betapdf(x, a, b, v)

声明：function

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

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

返回：any

sf_binocdf(x, n, p, v)

声明：function

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

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

返回：any

sf_binoinv(y, n, p, x)

声明：function

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

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

返回：any

sf_binopdf(x, n, p, v)

声明：function

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

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

返回：any

sf_Cauchycdf(x, a, b, v)

声明：function

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

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

返回：any

sf_Cauchyinv(y, a, b, x)

声明：function

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

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

返回：any

sf_Cauchypdf(x, a, b, v)

声明：function

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

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

返回：any

sf_ch2cdf(x, cv, v)

声明：function

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

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

返回：any

sf_ch2inv(y, cv, x, return_value)

声明：function

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

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

返回：array

sf_ch2pdf(x, cv, v)

声明：function

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

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

返回：any

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

sf_exp(x, mu, v)

声明：function

指数分布累计概率

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

返回：array

sf_expinv(y, mu, x)

声明：function

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

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

返回：any

sf_fcdf(x, v1, v2, v)

声明：function

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

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

返回：any

sf_finv1(y, v1, v2, x)

声明：function

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

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

返回：array

sf_fpdf(x, v1, v2, v)

声明：function

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

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

返回：any

sf_gamcdf(x, a, b, v)

声明：function

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

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

返回：any

sf_gaminv(y, a, b, x)

声明：function

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

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

返回：any

sf_gampdf(x, a, b, v)

声明：function

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

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

返回：any

sf_geocdf(x, p, v)

声明：function

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

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

返回：any

sf_geoinv(y, p, x)

声明：function

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

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

返回：any

sf_geopdf(x, p, v)

声明：function

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

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

返回：any

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

声明：function

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

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

返回：any

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

声明：function

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

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

返回：any

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

声明：function

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

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

返回：any

sf_Laplacecdf(x, mu, b, v)

声明：function

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

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

返回：any

sf_Laplaceinv(y, mu, b, x)

声明：function

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

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

返回：any

sf_Laplacepdf(x, mu, b, v)

声明：function

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

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

返回：any

sf_logncdf(x, mu, sigma, v)

声明：function

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

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

返回：any

sf_logninv(y, mu, sigma, x)

声明：function

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

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

返回：any

sf_lognpdf(x, mu, sigma, v)

声明：function

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

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

返回：any

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

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_nbincdf(x, r, p, v)

声明：function

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

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

返回：any

sf_nbininv(y, r, p, x)

声明：function

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

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

返回：any

sf_nbinpdf(x, r, p, v)

声明：function

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

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

返回：any

sf_normcdf(x, mu, sigma, v)

声明：function

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

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

返回：any

sf_norminv(y, mu, sigma, x)

声明：function

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

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

返回：any

sf_normpdf(x, mu, sigma, v)

声明：function

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

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

返回：any

sf_poisscdf(x, lambda, v)

声明：function

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

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

返回：any

sf_poissinv(y, lambda, x)

声明：function

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

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

返回：any

sf_poisspdf(x, lambda, v)

声明：function

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

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

返回：any

sf_raylcdf(x, b, v)

声明：function

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

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

返回：any

sf_raylinv(y, b, x)

声明：function

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

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

返回：any

sf_raylpdf(x, b, v)

声明：function

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

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

返回：any

sf_tcdf(x, cv, v)

声明：function

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

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

返回：any

sf_tinv1(y, cv, x)

声明：function

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

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

返回：any

sf_tpdf(x, cv, v)

声明：function

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

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

返回：any

sf_unidcdf(x, n, v)

声明：function

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

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

返回：any

sf_unidinv(y, n, x)

声明：function

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

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

返回：any

sf_unidpdf(x, n, v)

声明：function

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

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

返回：any

sf_unifcdf(x, a, b, v)

声明：function

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

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

返回：any

sf_unifinv(y, a, b, x)

声明：function

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

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

返回：any

sf_unifpdf(x, a, b, v)

声明：function

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

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

返回：any

sf_wblcdf(x, a, b, v)

声明：function

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

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

返回：any

sf_wblinv(y, a, b, x)

声明：function

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

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

返回：any

sf_wblpdf(x, a, b, v)

声明：function

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

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

返回：any

SingleLinearRegression_CallBack(x)

声明：function

单元线性回归的回调函数

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

返回：array

SingleLineralRegression_Pgm(x, y)

声明：function

单元线性回归测试

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

返回：array

singleRegression(x, y, call_back)

声明：function

单元回归

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

SingleUnLineralRegression_CallBack(x)

声明：function

单元非线性回归的回调函数

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

返回：array

SingleUnLineralRegression_Pgm(x, y)

声明：function

单元非线性回归测试

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

返回：array

singleVariableExecute(arr, sys_name, exp)

声明：function

设置系统变量SysName的值为Arr中的元素，执行表达式exp，将表达式的值放到数组Arr中

参数	类型	说明
arr	array	数组，
sys_name	string	字符串，指定系统参数名称
exp	texpression	表达式

返回：array

示例

// Arr中存储的是代码，获取2019年3月1日，Arr中所有代码的收盘价
arr := array('SZ000001', 'SZ000002');
return singleVariableExecute(arr, pn_stock(), @close());

skew(t, skew)

声明：function

偏斜度

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

返回：any

示例

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

spline(x1, y1, xx1)

声明：function

三次样条插值

参数	类型	说明
x1	array	一维数字数组 横坐标序列
y1	array	一维数字数组 纵坐标序列
xx1	array	实数或一维数字数组 插值

返回：array

示例

x := array(5, 1, 19, 8);
y := array(2, 3, 1, 7);
xx := array(4, 12);
return spline(x, y, xx);
// 返回：array(1.1407,13.9444)

Standarize_II(sample, leib)

声明：function

数据预处理，对二维数字数组进行标准化化处理；行：样本个数;列：因子个数

参数	类型	说明
sample	array	二维数字数组 样本
leib	any	Int 标准化类型

返回：array

SUMT_Method(x0, call_back)

声明：function

SUMT法求解有约束最优化问题

参数	类型	说明
x0	array	一维数字数组类型，各个变量的初始值
call_back	string	字符串类型，计算目标值的回调

返回：array

Sumt_Method__Pgm()

声明：function

Sumt算法测试

返回：array

Sumt_Method_CallBack(x, r)

声明：function

Sumt算法回调

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

返回：float

sysGetMemoryUsage()

声明：function

获取系统内存状态

返回：array,tablearray

示例

// 获得系统内存状态
return sysGetMemoryUsage();

sysGetPidOfCom(obj)

声明：function

获取 COM 对象对应的进程 ID

参数	类型	说明
obj	comobj	COM 对象。

返回：integer

示例

范例01：基本用法

getOleObject("Word.Application", 0, obj);
pid := sysGetPidOfCom(obj);
echo pid > 0, "\n";
// 输出：1

sysGetPidTidOfWnd(wnd[, var thread_id])

声明：function

获取窗口句柄对应的进程 ID，并可通过输出参数取得线程 ID

参数	类型	说明
wnd	hwnd	窗口句柄。
thread_id	integer	可选输出参数，写回线程 ID。

返回：integer

示例

范例01：基本用法

windows := sysGetWndOfCaption("Untitled - Notepad", true);
if length(windows) > 0 then
begin
    pid := sysGetPidTidOfWnd(windows[0], thread_id);
    echo pid > 0 and thread_id > 0, "\n";
    // 输出：1
end

sysGetProcessMemoryUsage(pid)

声明：function

获取进程的内存使用状态

参数	类型	说明
pid	integer	整数，可选参数，进程ID。未指定时默认获取自身的内存使用状态

返回：array

示例

// 获得自身的内存使用状态
return sysGetProcessMemoryUsage();

sysGetWndOfCaption(caption[, is_contain_string])

声明：function

按窗口标题查找窗口句柄列表。is_contain_string 可省略，缺省为真

参数	类型	说明
caption	string	窗口标题。
is_contain_string	boolean	可选；是否按标题包含关系匹配，缺省为真。

返回：array of hwnd

示例

范例01：基本用法

windows := sysGetWndOfCaption("Untitled - Notepad", true);
echo ifArray(windows), "\n";
// 输出：1

sysLibCVersion()

声明：function

获取系统中C语言支持库的版本

返回：string

示例

// 获得C语言支持库的版本
return sysLibCVersion();
// 返回："10.0.26100.8521"

Time_ACF(y)

声明：function

自相关系数，计算随机序列与所有滞后阶数的相关系数

参数	类型	说明
y	array	数组，样本序列；；p:整数，返回样本自相关系数序列的长度，默认值为3，允许缺省；

返回：array

Time_Analyse(y, model, p, q, l)

声明：function

ARMA模型分析，时间序列的ARMA模型分析，可以自动的选择q与p

参数	类型	说明
y	array	样本序列，为一维数组类型；
model	string	模型类别为AR、MA、ARMA，为字符串类型；
p	any	自回归阶数，取0则自动选择阶数，为整数类型；
q	any	移动平均阶数，取0则自动选择阶数，为整数类型；
l	any	预测步长，为整型类型；

返回：any

Time_ARCH(r_series, q, l)

声明：function

自回归条件异方差模型，本模型的ARCH模型如下： sss 可把异方差方程进行整合，得到 用最小二乘法去估计方程的系数了，得到系数的相合估计。 或者用最大似然估计去估计参数，得到精度估计，最大似然估计的目标函数值为

参数	类型	说明
r_series	array	资产收益率，为一维数组类型；
q	any	自回归阶数，为整数类型；
l	any	预测步长，为整数类型

返回：array

Time_ARCHTest(u, q, alpha)

声明：function

时间序列异方差的ARCH检验，原假设都为没有异方差，即不存在ARCH效应，Hypothesis为1表示接受原假设，0表示拒绝原假设 检验统计量为： 对方程进行估计，得到F统计量和T×R2统计量并进行检验

参数	类型	说明
u	array	残差序列，为一维数组类型
q	any	滞后阶数，为整数类型
alpha	float	1-alpha为置信水平，一般为5%，也有1%和10%，数值越小，判断越严格

返回：array

Time_ARMA(y, p, q, l)

声明：function

建议使用ARMA模型替换，自回归移动平均模型，ARMA(p,q)模型，采用逆函数去估计自回归系数和移动平均系数，返回结果有自回归系数、移动平均系数、残差方差、预测值及预测波动。 估计过程如下： ，为自协方差 其中：yt为原序列零均值化的新序列，μ为原序列的均值，ρp是自相关系数，φq是自回归方程系数，θq为移动平均系数，εt是零均值、方差为σ2的平稳白噪声

参数	类型	说明
y	array	样本序列，为一维数组类型；
p	any	自回归阶数；
q	any	移动平均阶数
l	any	预测步长，整数

返回：array

Time_ARp(y, p, l)

声明：function

建议使用AR模型替换，自回归模型，AR(p)模型，用Yule-Walker方程去估计p阶自回归模型的系数，返回结果有自回归系数、残差方差、预测值及预测波动。估计过程如下 AR(p)模型： 如有常数项，则 ，为自协方差 其中：为原序列零均值化的新序列，为原序列的均值，是自相关系数，是自回归方程系数，是零均值，方差为的平稳白噪声

参数	类型	说明
y	array	样本序列，为一维数组类型；
p	any	自回归阶数；
l	any	预测步长；

返回：array

Time_AutoCov(y, l)

声明：function

自协方差，求样本序列跟滞后L阶序列的协方差，即自协方差 自协方差计算公式如下： 其中：yt是样本序列，yL是滞后L阶的序列

参数	类型	说明
y	array	样本序列，为一维数组类型；
l	any	滞后阶数，为整数类型；

返回：any

Time_ChoseP(y, model, f)

声明：function

判断AR模型最佳的阶数，采用信息准则函数判断模型的最佳阶数 其中：T为样本容量，K为待估计参数

参数	类型	说明
y	array	样本序列，为一维数组类型；
model	string	模型类别为AR、MA、ARMA，为字符串类型；
f	string	判断准则为SBIC和AIC，为字符串类型

返回：any

Time_DanielTest(y, alpha)

声明：function

在1-alpha置信水平下，进行随机时间序列的Daniel平稳性检验。返回结果为一个数组，第一个为q值(q>0：序列有上升趋势，q<0：序列有下降趋势)，第二个为T统计量，第三个为p值，第四个为是否接受原假设。原假设为x是平稳序列，所以H为1表示接受原假设，0表示拒绝原假设 其中：qs是Spearman相关系数，Rt为秩统计量，n为样本容量

参数	类型	说明
y	array	随机时间序列，为一维数组类型
alpha	float	显著性水平，实数类型，取值在0-1之间

返回：array

Time_Diff(y, n)

声明：function

序列差分

参数	类型	说明
y	array	需要做差分的数组数据
n	any	差分的阶数，0阶不做处理

返回：any

Time_GARCH(rseries, model)

声明：function

广义自回归条件异方差模型，包含四种模型：GARCH(1,1)、GJR(1,1)、IGARCH(1,1)和EGARCH(1,1)，本模型采用了最大似然估计法去估计模型的系数，可做一步预测。 GARCH(1,1)： GJR(1,1)： IGARCH(1,1)： EGARCH(1,1)： 最大似然估计的目标函数值为

参数	类型	说明
rseries	array	资产收益率，为一维数组类型；
model	string	模型类别，为字符串类型；

返回：any

Time_GreenFun(ap, mq)

声明：function

中间函数，ARMA模型的Green函数，Green函数的递推公式如下： 式中： ，，是自回归方程系数，为移动平均系数

参数	类型	说明
ap	array	自相关系数，为一维数组类型；
mq	array	移动平均系数，为一维数组类型；

返回：array

Time_InvFun(ap, mq)

声明：function

中间函数，模型逆函数，ARMA模型的逆函数，Green函数的递推公式如下： 式中： ，，是自回归方程系数，为移动平均系数

参数	类型	说明
ap	array	自相关系数，为一维数组类型；
mq	array	移动平均系数，为一维数组类型；

返回：array

Time_MAq(y, q, l)

声明：function

建议使用ARMA模型替换，移动平均模型，MA(q)模型，用条件最小二乘法去估计q阶移动平均模型的系数，返回结果有移动平均系数、残差方差、预测值及预测波动。 估计过程如下： MA(q)模型： 具有逆转形式： 用算子形式比较，可得： s 条件最小二乘法使得下列残差平方和最小： 可将上述转化为矩阵形式，先求得的取值，在利用上上式计算移动平均系数 如有常数，则常数项为原序列的均值。 ，为自协方差 其中：yt为原序列零均值化的新序列，μ为原序列的均值，θq为移动平均系数，εt是零均值，方差为σ2的平稳白噪声

参数	类型	说明
y	array	样本序列，为一维数组类型；
q	any	移动平均阶数；
l	any	预测步长；

返回：array

Time_PACF(y)

声明：function

偏自相关系数，计算随机序列与所有滞后阶数的偏自相关系数，返回结果是一个数组。偏相关系数的计算公式如下： 是自相关系数，是偏相关系数

参数	类型	说明
y	array	样本序列，为一维数组类型

返回：array

Time_RandomTest(y, m, alpha)

声明：function

Ljung和Box提出的修正Qm统计量，用于检验序列是否为白噪声，原假设为白噪声序列，即纯随机序列。（Hypothesis为1表示接受原假设，0表示拒绝原假设） Qm统计量的计算公式如下： 其中：是自相关系数，T是样本容量，m是最大滞后长度

参数	类型	说明
y	array	样本序列，为一维数组类型
m	any	最大滞后长度，整数类型，一般取样本数的四分之一
alpha	float	显著性水平，实数类型，取值在0-1之间

返回：array

Time_VolatilitySpillover(x, y, w_type, m, c_type)

声明：function

波动溢出，底层模型为AR(3)-GARCH(1,1)，对时间序列X与Y进行Granger因果检验

参数	类型	说明
x	array	一维数字数组，时间序列X
y	array	一维数字数组，时间序列Y
w_type	any	整型 或 一维数字数组，加权方式，一维数字数组表示可同时返回多种加权方式
m	any	整数 或 一维数字数组，滞后阶数，一维数字数组表示同时计算多个M的场景，缺省时M:= array(5,10,20,30,40);
c_type	any	整数，因果检验类型

返回：array

Times_ADFTest(y, diff, style, f, p, alpha)

声明：function

时间序列的平稳性ADF检验；返回结果为ADF统计量和给定显著性水平下的ADF统计量的临界值；如果ADF统计量的绝对值比临界值的绝对值大，则可在该显著性水平下，拒绝原序列存在单位根的原假设，即原序列是平稳的

参数	类型	说明
y	array	时间序列数据，为一维数组类型
diff	any	差分次数，整数类型，0表示不进行差分
style	any	是否存在常数或趋势项的选项，整数类型，无常数无趋势使用0、有常数无趋势1、有常数有趋势2
f	string	滞后阶数判断信息准则，字符串类型，"SBIC"，"AIC"
p	any	滞后阶数，为整型类型，输入0则表示自动选择
alpha	float	显著性水平，实数类型，范围在0-1之间

返回：array

Times_Cointergration(y, x, alpha)

声明：function

建议使用Times_Cointergration_test函数替换本函数，协整检验—E-G两步法检验变量的协整关系，E-G法如下： 1）在因变量与自变量存在同阶单整关系的条件，进行最小二乘法回归； 2）把回归后的残差进行平稳性检验，如果残差序列是平稳的，则两者存在协整关系，否则不存在

参数	类型	说明
y	array	因变量，为一维数组类型；
x	array	自变量矩阵，为二维数组类型；
alpha	float	1-alpha为置信水平，一般为5%，也有1%和10%，数值越小，判断越严格；

返回：string

Times_Cointergration_test(y, x, constant, alpha_type, style, criterion)

声明：function

E-G两步法协整检验变量的协整关系，E-G法基本步骤如下： 1）在因变量与自变量存在同阶单整关系的条件，进行最小二乘法回归； 2）把回归后的残差进行平稳性检验，如果残差序列是平稳的，则两者存在协整关系，否则不存在

参数	类型	说明
y	array	被解释变量，为一维数组类型
x	array	解释变量，为一维数组类型
constant	bool	回归方程是否含有常数项，为布尔类型
alpha_type	float	显著性水平，为实数类型，一般在0-1之间
style	any	ADF法检验单整阶数时是否存在常数或趋势项，整数类型，无常数无趋势使用0、有常数无趋势1、有常数有趋势2
criterion	string	滞后阶数判断信息准则，字符串类型，"SBIC"，"AIC"

返回：array

Times_ECM(y, x, resid, alpha, q, p)

声明：function

两变量间的误差修正模型，准确的刻画了两序列间的短期波动特征 误差修正模型是时间序列间协整关系的主要表现形式，准确的刻画了序列间的长期均衡关系和短期波动特征。设一阶自回归分布滞后模型为： 其中，是均值为零，方差为的白噪声，进行适当的整理有： 其中若记 称为误差修正项

参数	类型	说明
y	array	被解释变量，为一维数组类型
x	array	解释变量，为一维数组类型
resid	array	协整检验时的残差，没有输入，使用最小二乘得到
alpha	float	显著性水平
q	any	整数类型，被解释变量的滞后项
p	any	整数类型，解释变量的滞后项

返回：any

Times_Granger(y, x, q, alpha)

声明：function

Granger因果检验，原假设：X不是Y的Granger原因，Hypothesis为1表示接受原假设，0表示拒绝原假设 原假设： 分别对上述两个回归方程做回归，提取残差平方和XESS跟YESS，则F统计量如下计算

参数	类型	说明
y	array	被解释变量，为一维数组类型
x	array	解释变量，为一维数组类型
q	any	滞后阶数，为整数类型
alpha	float	显著性水平，为实数类型，一般在0-1之间

返回：array

Times_GrangerCausality(series_matrix, lag_order)

声明：function

对矩阵中的多个序列执行两两 Granger 因果检验

参数	类型	说明
series_matrix	array	多个时间序列组成的矩阵；可由两条序列用 `left_series
lag_order	any	滞后阶数

返回：array

Times_johansen(x, p, k)

声明：function

进行Johansen协整检验，第一列的迹、最大特征值统计量的原假设是：没有协整关系；第二列的迹、最大特征值统计量的原假设是最多只有一个协整关系；第三列的迹、最大特征值统计量的原假设是最多只有两个协整关系……

参数	类型	说明
x	array	输入多元时间序列,每一列为一指标，每行为一时间 (nobs*m)
p	any	是否含时间趋势及常数项p = -1,没有时间趋势以及常数项p =0,含常数项p =1,含常数项以及一次时间项p >1,含常数项以及高次时间项
k	any	滞后阶数

返回：array

toHttpPostdata(v, data_mode)

声明：function

根据数据模式转换为字符串格式

参数	类型	说明
v	any	待转换的数据
data_mode	string	数据模式，支持 json 和 tslstream

返回：string

示例

value := array("Type": 1, "IDs": array("SZ000001"), "SUBs": array("date_s", "price"));
echo toHttpPostdata(value, "json");
// 输出：{"Type":1,"IDs":["SZ000001"],"SUBs":["date_s","price"]}

TSOptimizer

声明：class

天软规划求解基类，以面向对象方式封装 Prog_N、Prog_Q 和 Prog_L

来源：depth=3

Source ID：21162

Source URL：http://www.tinysoft.com/tsdn/helpdoc/display.tsl?id=21162

tssubplot_lines(data, fname_subplots, fname_date, fname_infos, dict_Indicator)

声明：function

时序数据多子图折线图批量绘制函数，按分组配置自动生成多组折线子图，并自动处理时间格式化、数据列重命名和信息列合并

参数	类型	说明
data	array	二维数组，原始时序数据集
fname_subplots	array	二维数组，子图分组配置
fname_date	array	时间字段名，用于生成标准化时间轴
fname_infos	array	一维字符串数组，附加信息列
dict_Indicator	array	一维数组，概览指标

返回：gsubplot

Source ID：37881

Source URL：http://www.tinysoft.com/tsdn/helpdoc/display.tsl?id=37881

uniffit(x, alpha)

声明：function

根据样本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的显著性水平下的区间估计

variationCoefficient(x)

声明：function

变异系数

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

返回：real

示例

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

wavedec(x, n, wname)

声明：function

使用给定的小波wname进行一维多尺度离散小波分析，返回信号xin在n层上的小波分解。输出分解结构包含小波分解向量C和相应的记录向量L

参数	类型	说明
x	array	一维序列，一维数字数组
n	integer	小波分解层数，正整数
wname	string	基础小波函数，字符串类型

返回：array

示例

setSysParam(PN_Stock(), "SH000300");
setSysParam(pn_date(), intToDate(20120731));
close300 := nDay(800, "时间", dateTimeToStr(sp_time(1)), "收盘价", close());
close3 := close300[: , "收盘价"];
return wave := wavedec(close3, 3, "db3");
// 输出：结果格式：
// 第一行是小波分解向量C，第二行是相应的记录向量L
// 下面我们从图像来直接看看小波分解：
// 原始序列:
// 原始序列可分解成：

wavelet(s, wname, n, options)

声明：function

一维序列小波消噪

参数	类型	说明
s	array	一维序列，一维数字数组
wname	string	基础小波函数，字符串类型,取值参考[Wavedec]函数的wname输入参数
n	integer	小波分解层数，正整数
options	array	方法选项

返回：array

示例

s := array(2484.83, 2479.05, 2482.34, 2437.79, 2447.75, 2512.96, 2443.06, 2433.16, 2393.18, 2415.05, 2392.06, 2365.34, 2359.22, 2344.79, 2348.52, 2420.00, 2438.79, 2431.38, 2440.4, 2383.49, 2377.51, 2331.37, 2317.27, 2370.33, 2409.67, 2427.48, 2435.61, 2473.41, 2468.25, 2470.02, 2504.11, 2508.09, 2528.29, 2509.8, 2503.84, 2524.92, 2479.54, 2481.08, 2528.71, 2529.76, 2466.96, 2463.05, 2416.56, 2415.13, 2412.62, 2395.06, 2397.55, 2380.22, 2383.03, 2412.39, 2333.41, 2386.86, 2360.66, 2333.23, 2325.91, 2332.73, 2329.82, 2315.27, 2291.54, 2248.59, 2228.52, 2180.9, 2224.84, 2218.24, 2215.93, 2191.15, 2186.3, 2204.78, 2190.11, 2166.21, 2170.01, 2173.56, 2199.42, 2169.39, 2148.45, 2163.4, 2225.89, 2285.74, 2276.05, 2275.01, 2244.58, 2206.19, 2298.38, 2266.38, 2296.07, 2319.12, 2285.04, 2292.61, 2268.08, 2312.56, 2330.41, 2331.14, 2291.9, 2347.53, 2349.59, 2351.98, 2351.85, 2344.77, 2366.7, 2356.86, 2357.18, 2363.6, 2381.43, 2403.59, 2409.55, 2439.63, 2447.06, 2451.86, 2428.49, 2426.11, 2460.69);
n := 2;
wname := "db14";
options := array('brief': 1, 'sigma': 0, 'which': 1, 'alpha': 2, "thr": 0, 'sorh': 's');
return s|wavelet(s, wname, n, options);
// 消噪和原始数据对比：

wrcoef(o, c, l, wname, n)

声明：function

一维离散小波单支重构，小波分析，小波重构中间函数或者细节系数（高频）提取

参数	类型	说明
o	string	为字符串类型，'a' 一维离散小波单支重构，'d' 细节系数提取
c	array	小波分解向量C，数组类型，参考[Wavedec]函数的输出
l	array	相应的记录向量L，数组类型，参考[Wavedec]函数的输出
wname	string	基础小波函数，字符串类型,取值参考[Wavedec]函数的wname输入参数
n	integer	小波分解层数，正整数

返回：array

示例

setSysParam(PN_Stock(), "SH000300");
setSysParam(pn_date(), intToDate(20120731));
close300 := nDay(800, "时间", dateTimeToStr(sp_time(1)), "收盘价", close());
close3 := close300[: , "收盘价"];
wave := wavedec(close3, 3, "db3");
c := wave[0];
l := wave[1];
return wrcoef('a', c, l, 'db3', 3); // 去除前3层高频谐波
// Return wrcoef('d',c,l,'db3',3);//第3次分解得到的高频
// 输出：
// 去除前3层高频谐波
return wrcoef('d', c, l, wname, 3); // 第三次分解得到的高频

writeToLog(dir, sub_dir, value)

声明：function

向虚拟目录写日志。其中Dir为虚拟目录名，SubDir为文件名，成功写入日志后，会生成命名为'SubDir'+写入日期+'.log'的TXT文件，文件内容为写入时间->Value。用户使用其应当申请好服务器权限。 20250512升级：优化多个线程同时写入时存在丢失情况： 1、增加重试次数，重试20次间隔0.5秒。 2、增加返回内容。 注意：在极端情况下（超多多线程下同时写入）可能还会存在写入失败情况，此时可通过返回结果继续处理

参数	类型	说明
dir	string	字符串，虚拟目录别名，一般在安装目录\Tinysoft\Analyse.NET\Plugin\filemgr.ini中进行配置。如果没有配置别名，该参数赋值为空字符""。
sub_dir	string	字符串，文件名
value	string	字符串，需要写入日志的内容

返回：any

ytmToAccumulativeYtm(t, f_name, dw)

声明：function

日收益率转换复合收益率

参数	类型	说明
t	array	数组。日收益率序列
f_name	string	字符串。收益字段名称
dw	integer	整数。决定源数据的单位和返回的数据

返回：array|real

示例

范例01：

// 源数据单位为1,dw=2,同时返回日收益率和转换后的复合收益率
t1 := array(('日期': 20180801T, '日收益率': 0.3),
('日期': 20180802T, '日收益率': 0.6),
('日期': 20180803T, '日收益率': 0.9));
r1 := ytmToAccumulativeYtm(t1, '日收益率', 2, 0);
// 源数据单位为%,dw=3,同时返回日收益率和转换后的复合收益率
t2 := array(('日期': 20180801T, '日收益率(%)': 30),
('日期': 20180802T, '日收益率(%)': 60),
('日期': 20180803T, '日收益率(%)': 90));
r2 := ytmToAccumulativeYtm(t2, '日收益率(%)', 3, 0);
return r1|r2;

范例2：

// 计算基金OF000009易方达天天理财A的累计收益率(%)
setSysParam(PN_Stock(), "OF000009");
t := array(('日期': 20150104T, '每万份基金单位收益': 4.3769),
('日期': 20150105T, '每万份基金单位收益': 1.2507),
('日期': 20150106T, '每万份基金单位收益': 1.4671));
r := ytmToAccumulativeYtm(t, '每万份基金单位收益', 5, 0);
return r;

abnormalData(y, flag, ystore)

声明：function

数组中出现奇异值的处理。其中y为数据表，Flag为处理方法，Ystore为选择中位数和3倍标准差法返回被处理数据的数据

参数	类型	说明
y	array	一维数字数组
flag	string	用户自定义，奇异值处理方法
ystore	array	数据表类型，存放修改的数据，包括修改的行、原数值、处理后的值

返回：any

示例

示例：返回奇异值的位置及处理后的结果。

t := array(1, 100, 101, 102, 103, 1000);
abnormalData(t, "median", r);
return r;
// 返回:
// 其中，0和5为修改的行，1和1000是对应的原值，93.7和109.3是修改后的值

appendArray(arr, con)

声明：function

数组新增元素，给数组arr添加一项con

参数	类型	说明
arr	array	一维数组
con	integer	整数或字符串，需增加的值

返回：array

示例

a := array(1, 2, 3);
appendArray(a, 4);
return a;
// 返回:

argconfirst(a, v, _type)

声明：function

第一次满足条件的位置, 原数组必须为有序表且元素应可比较

参数	类型	说明
a	array	有序数组
v	string|real|array	对比值
_type	integer	对比条件

返回：integer

示例

范例1：实数对比

a := 0->9;
return argconfirst(a, 3.5, 1); // 返回：4

范例2：数组对比

a := array(("a", "A"), ("b", "B"), ("c", "C"), ("d", "D"));
v := array("b", "B");
return argconfirst(a, v, 6); // 返回：1

argmax(x)

声明：function

1、返回一维数组中最大值所在下标

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

返回：integer

示例

x := array(9, 8, 10);
return argmax(x);
// 输出：2

argmin(x)

声明：function

1、返回一维数组中最小值所在下标

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

返回：integer

示例

x := array(3, 1, 9, 2);
return argmin(x); // 1

argsort(value, sortdir)

声明：function

返回可以用于排序的一维数组下标

参数	类型	说明
value	array	一维数字数组，数组
sortdir	integer	整数，排序方向（1:正序【默认】;0:逆序）

返回：array

示例

value := array(4, 8, 2, 3, 9);
return argsort(value); // 返回：array(2,3,0,1,4)

arrayAddGap(t, key, v, m)

声明：function

数组添加分割线,只支持字符串下标

参数	类型	说明
t	array	数组，待添加数组，直接在原数组更改
key	string	字符串，间隔名，默认无
v	string	字符串，间隔串，默认为 DupeString('-',m*2)
m	integer	整型，间隔串的长度设置，默认 5

返回：array

示例

a := array('alpha(%)': 3);
arrayAddGap(a, '风险');
a['beta'] := 3;
return a; // array("alpha(%)":3,"-----风险-----":"----------","beta":3)

arrayextend(a, ind, v)

声明：function

数组-指定位置插入子集

参数	类型	说明
a	array of number	Array of number,一维数字数组
ind	integer	Integer,插入的起始位置
v	array of number	Array of number,插入的子数组

返回：array

示例

a := letters(1->6);
return arrayextend(a, 2, array('d', 'e'));
// 返回：array("A", "B", "d", "e", "C", "D", "E", "F")

arraygetdefault(r, k, v)

声明：function

带默认值的数组取值，取指定下标的值，若存在则返回，否则返回设定的默认值

参数	类型	说明
r	array of string	Array of string,
k	string	String,下标
v	string	String,默认值

返回：any

示例

r := array("a": 1, "b": 2);
return arraygetdefault(r, "x", 99); // 下标 x 不存在，返回默认值 99；若取 "a" 则返回 1
// 输出：99

arrayinsert(a, ind, v)

声明：function

数组-指定位置插入值

参数	类型	说明
a	array of number	Array of number,一维数字数组
ind	integer	Integer,插入位置
v	any	Any,元素值

返回：array

示例

a := letters(1->6);
return arrayinsert(a, 2, 3);
// 返回：array("A", "B", 3, "C", "D", "E", "F")

arraysetdefault(r, k, v)

声明：function

带默认值的数组赋值(字段未使用则赋值)

参数	类型	说明
r	array of string	Array of string,
k	string	String,下标
v	string	String,默认值

返回：bool

示例

r := array("a": 1, "b": 2);
arraysetdefault(r, "x", 99); // 下标 x 未使用，赋值 99 并返回 true；若对已存在的 "a" 调用则不改、返回 false
return r;
// 输出：array("a":1,"b":2,"x":99)

arraysetdefault2(r, k, v)

声明：function

带默认值的数组赋值(值为nil则赋值)

参数	类型	说明
r	array of string	Array of string,
k	string	String,下标
v	string	String,默认值

返回：bool

示例

r := array("a": 1, "b": nil);
arraysetdefault2(r, "b", 99); // b 的值为 nil，赋值 99 并返回 true；下标缺失时同样赋值
return r;
// 输出：array("a":1,"b":99)

aveDevByColumn(t, f_name)

声明：function

指定列与平均值的绝对偏差的平均值

参数	类型	说明
t	array	数据表
f_name	string	指定列名，字符串

返回：real

示例

t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return aveDevByColumn(t2, 'c');
// 结果：12.5

averageByColumn(t, f_name)

声明：function

求指定列的平均值

参数	类型	说明
t	array	数据表
f_name	string	指定列名

返回：real

示例

t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 8, 'c': 5));
return averageByColumn(t1, 'b');
// 结果：6

averageValueByColumn(t, f_name, from_row, to_row)

声明：function

求在指定多行中指定列的平均值

参数	类型	说明
t	array	数据表
f_name	string	指定列名
from_row	integer	计算起始行索引号（从0开始）
to_row	integer	计算结束行索引号（从0开始）

返回：real

示例

t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return averageValueByColumn(t2, 'c', 1, 3);
// 结果：43

boolToStr(b, use_bool_strs)

声明：function

将布尔型转换成字符串类型并返回。参数UseBoolStrs一般为假，如果B为真，函数返回'-1',如果B为假，返回'0'。若想返回'True'与'False'的结果可用BoolToStr2实现

参数	类型	说明
b	bool	要转换的布尔值
use_bool_strs	bool	布尔型，一般传入假值

返回：string

call(func_name, p1, pn)

声明：function

根据名称或者函数指针调用指定的函数，后面带的参数将自动送入该函数

参数	类型	说明
func_name	string	TFunction
p1	any	整数，参数1
pn	any	整数，参数N。

返回：any

callInArray(func, args)

声明：function

以参数数组调用指定函数（含函数名或函数变量）

参数	类型	说明
func	string	函数名字符串或函数指针
args	array	参数数组

返回：any

columnValue(t, fname)

声明：function

获取指定列的所有值(按列名)。该函数的功能与直接用读取子矩阵的方式一样，但是用子矩阵的方式更简单快速。功能相当于t[:,fname]

参数	类型	说明
t	array	数据表类型，数据表
fname	string	字符串，列字段名称

返回：any

示例

s := select ['StockID'] as '代码',
["StockName"] as "名称",
['price'] as '收盘'
from markettable datekey 20190101T to 20190201T of 'SZ000001' end;
return columnValue(s, '收盘');
// 返回:

columnValue2(t, column_name)

声明：function

获取多个指定列的所有记录

参数	类型	说明
t	array	数据表，二维数组
column_name	string	指定多个字段，以分号分割

返回：array

示例

t2 := array(('a': 2, 'b': 2, 'c': 13), ('a': 3, 'c': 33, 'b': 3), ('a': 3, 'b': 6, 'c': 43), ('a': 5, 'c': 53, 'b': 5));
return columnValue2(t2, 'a;c');

compareDataOfDifferentDataProvider(t_src, t_dest, src_provider, dest_provider, key_arr, value_arr, code_field)

声明：function

比较两个数据源的差异

参数	类型	说明
t_src	array	Array 源数据
t_dest	array	Array 目标数据
src_provider	string	String 源数据提供商
dest_provider	string	String 目标数据提供商
key_arr	array	Array 要比较表的Key字段（也就是数据表中的 唯一性字段）
value_arr	array	Array 要比较的Value字段
code_field	string	String 代码字段（任何数据，都必须有编码字段）

返回：array

示例

src := array(("code": "A", "value": 1));
dest := array(("code": "A", "value": 1));
result := compareDataOfDifferentDataProvider(
    src,
    dest,
    "source",
    "target",
    array("code"),
    array("value"),
    "code"
);
echo trim(toStn(result));

dataisequal(v1, v2)

声明：function

判断2个变量是否相等

参数	类型	说明
v1	any	任意类型,变量1
v2	any	任意类型,变量2

返回：bool

示例

echo dataisequal(array("code": "A"), array("code": "A"));

DataProcess_MF(arr, fwm)

声明：function

极值处理(多因子),对数据表以列为单位处理奇异值。其中arr为数据表，fwm为处理方法

参数	类型	说明
arr	array	数据表类型
fwm	string	用户自定义，处理方法

返回：any

示例

data := array(array(1, 100, 101, 102, 103, 1000), array(2, 200, 201, 202, 203, 2000));
echo trim(toStn(DataProcess_MF(data, "median")));

dateStrToArr(end_dates, sep1, sep2)

声明：function

把日期区间字符串转换为列表

参数	类型	说明
end_dates	string	日期区间字符串
sep1	string	日期区间字符串分割符
sep2	string	开始和截止日期分割符

返回：array

示例

return dateStrToArr('2007-9-10;2007-9-10', '$', ';'); // '$'表示结束位置

dateTimeToString(format, date_time)

声明：function

根据参数Format给定的格式串将参数DateTime转换成字符串类型存到参数Result中，其中格式串的使用参照FormaTDateTime函数

参数	类型	说明
format	any	字符串，格式串
date_time	datetime	TDateTime类型，需转换的日期时间

返回：string

dbglocalcancel(id, return_value)

声明：function

注销任务。该功能可以用来终止运行的WEB任务。 其任务ID为dbglocalrunning中返回信息中的id字段以十六进制模式转换为64位整数

参数	类型	说明
id	int	为dbglocalrunning中返回信息中的id字段以十六进制模式转换为64位整数
return_value	bool	object

返回：bool

decToInt(s)

声明：function

将字符串转换为整数

参数	类型	说明
s	string	字符串。需转换的字符串

返回：integer

示例

范例01

return decToInt("12"); // 输出: 12

范例02：十六进制格式字符串的转换

return decToInt("0x12"); // 报错
return strToInt("0x12"); // 输出：18

decToInt32(s)

声明：function

将字符串转换为32位整数

参数	类型	说明
s	string	字符串。需转换的字符串

返回：integer

示例

范例01

return decToInt32("12"); // 输出: 12

范例02：十六进制格式字符串的转换

return decToInt32("0x12"); // 报错
return strToInt32("0x12"); // 输出：18

decToInt32Def(s, default)

声明：function

将字符串转换为32位整数。如果转换失败，则返回Default值

参数	类型	说明
s	string	字符串。需转换的字符串
default	integer	整数。转换失败时返回的默认值

返回：integer

示例

范例01

return decToInt32Def("12", 1); // 输出: 12
return decToInt32Def("test", 1); // 输出: 1

范例02：十六进制格式字符串的转换

return decToInt32Def("0x12", 1); // 输出: 1
return strToInt32Def("0x12", 1); // 输出：18

decToInt64(s)

声明：function

将字符串转换为64位整数

参数	类型	说明
s	string	字符串。需转换的字符串。

返回：integer

示例

范例01：

return decToInt64("12"); // 输出: 12L

范例02：十六进制格式字符串的转换

return decToInt64("0x12"); // 报错
return strToInt64("0x12"); // 输出：18L

decToInt64Def(s, default)

声明：function

将字符串转换为64位整数。如果转换失败，则返回Default值

参数	类型	说明
s	string	字符串。需转换的字符串
default	integer	整数。转换失败时返回的默认值

返回：integer

示例

范例01

return decToInt64Def("12", 1); // 输出: 12L
return decToInt64Def("test", 1); // 输出: 1L

范例02：十六进制格式字符串的转换

return decToInt64Def("0x12", 1); // 输出: 1L
return strToInt64Def("0x12", 1); // 输出：18L

decToIntDef(s, default)

声明：function

将字符串转换为整数。如果转换失败，则返回Default值

参数	类型	说明
s	string	字符串。需转换的字符串
default	integer	整数。转换失败时返回的默认值

返回：integer

示例

范例01

return decToIntDef("12", 1); // 输出: 12
return decToIntDef("test", 1); // 输出: 1

范例02：十六进制格式字符串的转换

return decToIntDef("0x12", 1); // 输出: 1
return strToIntDef("0x12", 1); // 输出：18

deleteColumnByField(t, fields)

声明：function

删除指定列，可以一次性删除多列，删除的列字段之间使用；分割

参数	类型	说明
t	array	指定数组，数据表列名为字符串类型，程序执行完后会变更为删除指定列后的数组
fields	string	指定列，字符串

返回：array

示例

t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 8, 'c': 5));
return deleteColumnByField(t1, 'a;b');

deleteNilValueByField(t, fields)

声明：function

删除指定字段fields数据为NIL的记录

参数	类型	说明
t	array	数据表类型，数据
fields	string	字符串，字段名称，多个字段用分号（;）连接，例:＂Field1;Field2＂

返回：array

示例

tdata := array(array('time': 1, 'price': 7.78), array('time': 2));
deleteNilValueByField(tdata, 'price');
return tdata;
// 返回:
// array(
// ("time":1,"price":7.78))

descartesJoin(v1, v2, v_n)

声明：function

数组笛卡尔积连接

参数	类型	说明
v1		任意类型，支持不定个数参数，数值1
v2		任意类型，数值2
v_n		任意类型，数值3

返回：array,tablearray

示例

return descartesJoin(1->3, 21->22, 3);
// 输出：
// array(
// (1,21,3),
// (1,22,3),
// (2,21,3),
// (2,22,3),
// (3,21,3),
// (3,22,3))

describe(data, percentiles)

声明：function

简单描述统计

参数	类型	说明
data	array of number	一维数字数组,或 二维矩阵。二维矩阵时，对每列进行操作
percentiles	array of number	统计的分位点，默认取array(0.25,0.5, 0.75)

返回：array

示例

范例01:

load_dataset_iris(data);
return describe(data);

范例02:

return describe(randn(0, 1, 1000), array(0.05, 0.1)->0.95);

devsqByColumn(t, f_name)

声明：function

指定列平均值偏差的平方和

参数	类型	说明
t	array	数据表
f_name	string	指定列名

返回：real

示例

t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 5, 'c': 5));
return devsqByColumn(t1, 'b');
// 结果：0.5

distinctStr(t)

声明：function

去掉序列中的重复元素

参数	类型	说明
t	array	一维字符串/数字数组

返回：array

示例

a := array('w', 'd', 'f', 'd', 'e');
return distinctStr(a); // 保留不相同的，相同的只保留一个

divMod(dividend, divisor, remainder)

声明：function

计算整数除法的整数商和余数。也就是用参数Dividend除以参数Divisor，得到的整数商存到参数Result中，把余数存到参数Remainder中

参数	类型	说明
dividend	int	整数，被除数
divisor	int	整数，除数
remainder	int	整数，余数

返回：float

divValue(v1, v2)

声明：function

除法运算

参数	类型	说明
v1	real	实数，被除数
v2	real	实数，除数

返回：real

示例

return divValue(8, 2);
// 返回：4

dumies_decode(dumiesdata)

声明：function

虚拟变量矩阵解构，根据所给的虚拟变量矩阵返回分类变量结果

参数	类型	说明
dumiesdata	array	二维数字数组，虚拟变量矩阵

返回：array

示例

data := array(
    ("real_estate": 1, "metal": 0, "bank": 0),
    ("real_estate": 0, "metal": 1, "bank": 0),
    ("real_estate": 0, "metal": 0, "bank": 1)
);
echo trim(toStn(dumies_decode(data)));

elementWhere(con, x, y)

声明：function

根据布尔数组con,为True时从X中，为False时从Y中，取对应位置元素的值

参数	类型	说明
con	array,tablearray
x	array,tablearray
y	array,tablearray

返回：array,tablearray

示例

con := array(1, 0, 1, 1, 1, 0);
x := array(1, 2, 3, 4, 5, 6);
y := array(11, 12, 13, 14, 15, 16);
return elementWhere(con, x, y); // array(1,12,3,4,5,16)

endOfTheHalfYear(end_t)

声明：function

返回Endt所在半年的截止日期（半年的最后一天）

参数	类型	说明
end_t	tdatetime	日期

返回：tdatetime

示例

end_t := 40540; // 40540表示2010年12月28日
return endOfTheHalfYear (end_t);
// 结果：40543  //40543表示2010年12月31号

endOfTheQuarter(end_t)

声明：function

返回Endt所在季度的截止日期（季度的最后一天）

参数	类型	说明
end_t	tdatetime	日期

返回：tdatetime

示例

end_t := 40540; // 40540表示2010年12月28日
return endOfTheQuarter (end_t);
// 结果：40543  //40543表示2010年12月31号

ensureRange(a_value, amin, amax)

声明：function

这个函数可以保证返回某个区间之内的数，参数Amin和参数Amax是这个区间的上限和下限。 如果参数Avalue大于等于参数Amin并且小于等于参数Amax，则返回Avalue 如果参数Avalue大于参数Amax，则返回Amax的值 如果参数Avalue小于参数Amin，则返回Amin的值

参数	类型	说明
a_value	float	要限制范围的实数
amin	float	实数，范围下限
amax	float	实数，范围上限

返回：float

excelDateToInt(r_date)

声明：function

将日期型报告期转化成整数型报告期

参数	类型	说明
r_date	tdatetime	日期型报告期

返回：integer

示例

r_date := 20101231;
return excelDateToInt(r_date);
// 结果：20101231

excelIntToDate(r_date)

声明：function

将报告期类型日期转化成实数型

参数	类型	说明
r_date	integer	整型类的报告期日期

返回：tdatetime

示例

// 报告期为2010年年报
r_date := 20101231;
return excelIntToDate(r_date);
// 结果：40543

excelRDate(r_date)

声明：function

将整数报告期转换成Excel的字符串日期类型

参数	类型	说明
r_date	integer	报告期，一般用整型日期表示

返回：string

示例

r_date := 20101231;
return excelRDate(r_date);
// 结果：2010-12-31

expandTable(t, key_field)

声明：function

按指定字段展开表格，根据Keyfield展开指定列。展开的列值必须二维数据表，否则保留原值

参数	类型	说明
t	array	数组类型，数据
key_field	string	字符串类型，关键字，需展开的列名

返回：array

示例

// 按照分红送股列展开数据：分红送股列本身是子表，展开为多行
data := array(
    ("代码":"SH600000","名称":"浦发银行","分红送股":array(("年度":2019,"派息":6),("年度":2020,"派息":8))),
    ("代码":"SZ000002","名称":"万科A","分红送股":array(("年度":2020,"派息":12))));
return expandTable(data, "分红送股");
// 输出：
// array(
// ("代码":"SH600000","名称":"浦发银行","分红送股":2019),
// ("分红送股":6),
// ("分红送股":2020),
// ("分红送股":8),
// ("代码":"SZ000002","名称":"万科A","分红送股":2020),
// ("分红送股":12))

exportFile(filename, arg2, arg3, data)

声明：function

将数据导出到文件

参数	类型	说明
filename	int
arg2	string
arg3	string
data	array

返回：string

exportJsonStringMbcs(data, n, return_value)

声明：function

将TSL结构数据转换为json串。和ExportJSONString不同的是，该函数不会对中文进行转码处理，保留中文原码

参数	类型	说明
data	AnyType	天软数据，任意数据类型。
n	int	可选。要保留的小数位数。为0时保留1位小数，大于16或小于0时保留全部小数位数
return_value	string	字符串，json串

返回：string

exportJsonStringUtf8(data, n, return_value)

声明：function

将天软数组转换为UTF8编码的Json串，解决与第三方交互时的转码问题

参数	类型	说明
data	anytype	天软数据，任意数据类型。
n	int	可选。要保留的小数位数。为0时保留1位小数，大于16或小于0时保留全部小数位数
return_value	string	字符串，UTF8编码的Json字符串。

返回：string

factorize(value, ifsort, nan_fill_value, uniques)

声明：function

分类变量数值映射，将一个一维分类变量数组映射为给分类变量递增编号后的数值数组

参数	类型	说明
value	array	数组，一维数组
ifsort	bool	布尔型，是否排序，默认不排序
nan_fill_value	any	数字/字符串，填充nan的值，默认为-1
uniques	array	数组，输出，各值对应的原值

返回：array

示例

value := Array('a', 'd', 'c', 'a', 'b');
labels := factorize(value, true, -1, uniques);
echo uniques; // array("a","b","c","d")
return labels; // array(0,3,2,0,1);

Field_AddPrefix(t, prefix, ifcopy)

声明：function

数组下标批量加前缀

参数	类型	说明
t	array	数组类型，数据
prefix	string	字符串类型，前缀
ifcopy	bool	布尔类型，是否在拷贝后的数组改列名，默认True

返回：array

示例

data := array(("code": "A", "value": 1));
echo trim(toStn(Field_AddPrefix(data, "pre_", true)));

Field_AddSuffix(t, suffix, ifcopy)

声明：function

数组下标批量加后缀

参数	类型	说明
t	array	数组类型，数据
suffix	string	字符串类型，后缀
ifcopy	bool	布尔类型，是否在拷贝后的数组改列名，默认True

返回：array

示例

data := array(("code": "A", "value": 1));
echo trim(toStn(Field_AddSuffix(data, "_new", true)));

Field_ReSortCols(data, cols_showpriority)

声明：function

数组下标按指定顺序重排 ps：不检查字段是否存在

参数	类型	说明
data	array	二维数字数组,数组，目前只支持二维
cols_showpriority	array	一维字符串数组,字段显示优先级

返回：array

示例

data := array(("code": "A", "value": 1, "date": 20250101));
priority := array("value": 100, "date": -1);
echo trim(toStn(Field_ReSortCols(data, priority)));

fieldCount(t)

声明：function

数据表字段个数。如果t不是一个数据表，则返回0

参数	类型	说明
t	array	数据表

返回：integer

示例

t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));
return fieldCount(t1);
// 结果：2

fieldCountOfStrSubscript(t)

声明：function

字符串下标数组的字段个数

参数	类型	说明
t	array	数据表类型

返回：integer

示例

s := `array('a': (1, 2, 3, 4, 5), 'b': (2, 3, 4, 5, 6), 'c': (3, 4, 5, 6, 7), 'd': (4, 5, 6, 7, 8));
return fieldCountOfStrSubscript(s);
// 返回：4

fieldExist(t, f_name)

声明：function

指定字段是否存在。如果存在，则返回索引号；(索引号从0开始)，不存在，返回－1

参数	类型	说明
t	array	数据表
f_name	string	指定字段，字符串

返回：integer

示例

t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));
return fieldExist(t1, 'b');
// 结果：1

fieldName(t, field_index)

声明：function

返回数据表指定列索引号（索引号从0开始）的字段名称

参数	类型	说明
t	array	数据表
field_index	integer	指定列，整数

返回：string

示例

t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));
return fieldName(t1, 0);
// 结果：’a’

fieldNames(t)

声明：function

返回数据表所有字段名称

参数	类型	说明
t	array	数据表

返回：array

示例

t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));return fieldNames(t1);

fieldNamesOfStrSubscript(t)

声明：function

字符串下标数组的字段名称

参数	类型	说明
t	array	整数

返回：any

示例

s := `array('a': (1, 2, 3, 4, 5), 'b': (2, 3, 4, 5, 6), 'c': (3, 4, 5, 6, 7), 'd': (4, 5, 6, 7, 8));
return fieldNamesOfStrSubscript(s);
// 返回:

fileDateToDateTime(filename)

声明：function

日期时间处理函数

参数	类型	说明
filename	int

返回：datetime

filterIntersectionPart(t1, t2, f_name, method)

声明：function

求两个数组在指定列名上的差集、交集、并集

参数	类型	说明
t1	array	数据表
t2	array	数据表
f_name	string	指定列名字符串
method	string	方法，’IN’交集，’NOT IN’差集，’ALL’并集，字符串

返回：array

示例

t1 := array(('a': 1, 'b': 10, 'c': 13), ('a': 2, 'b': 17, 'c': 13));
t2 := array(('a': 2, 'b': 22, 'c': 23), ('a': 1, 'b': 14, 'c': 13), ('a': 3, 'b': 12, 'c': 13));
return filterIntersectionPart(t1, t2, 'a', 'IN'); // t1 与 t2 在列 a 上的交集
// 输出：返回 t1 中 a 值出现在 t2 中的行
// array(
// ("a":1,"b":10,"c":13),
// ("a":2,"b":17,"c":13))
// method='NOT IN' 时返回 t1 中 a 值不在 t2 的行(此例为空 array())；
// method='ALL' 时返回并集(此例为 t2 的三行，a=2,1,3)。

filterIntersectionPart2(t1, t2, method)

声明：function

求两个数组的差集、交集、并集。只适用一维数组

参数	类型	说明
t1	array	一维数据表
t2	array	一维数据表
method	string	方法，’IN’交集，’NOT IN’差集，’ALL’并集，字符串

返回：array

示例

t1 := array(1, 2, 3, 4);
t2 := array(3, 4, 5, 6);
return filterIntersectionPart2(t1, t2, 'IN'); // t1 与 t2 的交集
// 输出：array(3,4)
// method='NOT IN' 返回 t1 中不在 t2 的元素 array(1,2)；
// method='ALL' 返回并集 array(3,4,5,6,1,2)。

filterOneDimEx(t, method, v1, v2)

声明：function

范围取值（一维数组）从一个一维数组中按照取值范围返回对应的记录

参数	类型	说明
t	array	数据表
method	string	’>’，’<’，’<>’，’<=’，’>=’，’IN’，’IN2’，’IN3’
v1	real	实数
v2	real	实数

返回：array

示例

t := array(1, 2, 12, 3.7, 14);
return filterOneDimEx(t, 'IN', 2, 7);

filterOneDimEx2(t, v1)

声明：function

小于等于指定值的最后一条记录(一维数组)

参数	类型	说明
t	array	一维数字数组
v1	real	实数，指定值

返回：real

示例

s := array(1, 2, 3, 4, 5, 6);
return filterOneDimEx2(s, 4);
// 返回：4

filterTable(t, v)

声明：function

从指标表中取以下列的值为v的数据

参数	类型	说明
t	array	数组类型，数据
v	integer	报告期类型，报告期

返回：array

示例

// 'SZ002664'在20211231时的分红送股数据
setSysParam(pn_stock(), 'SZ002664');
return filterTable(infoArray(18), 20211231);

filterTableEx(t, fname, method, v1, v2)

声明：function

范围取值，从一个表中按照某个字段的取值范围返回对应的记录

参数	类型	说明
t	array	数据表
fname	string	指定字段名，字符串
method	string	’>’，’<’，’<>’，’<=’，’>=’，’IN’，’IN2’，’IN3’
v1	real	实数
v2	real	实数

返回：array

示例

t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33));
return filterTableEx(t2, 'c', 'IN', 13, 30); // 取13<=[ 'c']<=30

floatN(r, n)

声明：function

使用银行家算法进行四舍五入,精确到10Adigit位。"四舍六入五考虑，五后非零就进一，五后皆零看奇偶，五前为偶应舍去，五前为奇要进一"

参数	类型	说明
r	real	实数
n	integer	整型数据，保留的小数位数

返回：real

示例

return floatN(12.6578, 2);
// 结果：12.66

floatToStrEx(r, n)

声明：function

浮点->字符串

参数	类型	说明
r	real	实数
n	integer	整型数据，保留的小数位数

返回：string

示例

return floatToStrEx (12.6578, 2);
// 结果：’ 12.66’

floatToStrne(value)

声明：function

将实数转换成字符串类型。和FloatToStr的区别：在处理浮点数据时，FloatToStrne的结果不会输出为1E15等格式

参数	类型	说明
value	real	实数

返回：string

示例

return floatToStrne(23.4);
// 输出字符串："23.4"
return floatToStrne(1E15);
// 大数量级数据，输出："1000000000000000"

floatToStrneW(value)

声明：function

将实数转换成宽字节字符串类型。和FloatToStrW的区别：在处理大数量级数据（如1E15、10^15等）时，FloatToStrneW的结果不会输出为1E15等格式

参数	类型	说明
value	real	实数

返回：string

示例

return floatToStrneW(1234.1234);
// 输出：L"1234.1234"
return floatToStrneW(1E15);
// 大数量级数据，输出：L"1000000000000000"

footerAverage(t, from_col, tocol, average_col_field)

声明：function

调用FooterValue对数组指定列求算术平均

参数	类型	说明
t	array	数据表类型，数据表
from_col	integer	:整数，起始序号
tocol	integer	整数，截止序号
average_col_field	string	字符串，显示“平均”的列字段

返回：array

示例

s := array(array(1, 2, 3, 4, 5),
array(2, 3, 4, 5, 6),
array(3, 4, 5, 6, 7));
return footerAverage(s, 1, 3, '');
// 返回:

footerSum(t, from_col, tocol, average_col_field)

声明：function

调用FooterValue对数组指定列求算术和

参数	类型	说明
t	array	数据表类型，数据表
from_col	integer	:整数，起始序号
tocol	integer	整数，截止序号
average_col_field	string	字符串，显示“平均”的列字段

返回：array

示例

s := array(array(1, 2, 3, 4, 5),
array(2, 3, 4, 5, 6),
array(3, 4, 5, 6, 7));
return footerAverage(s, 1, 3, '');
// 返回:

footerValue(t, from_col, tocol, average_col_field, _type)

声明：function

数组t从Fromcol列到ToCol列对每列求算术平均或者累计求和

参数	类型	说明
t	array	数据表类型，数据表
from_col	integer	:整数，起始序号
tocol	integer	整数，截止序号
average_col_field	string	字符串，列名
_type	any	用户自定义

返回：array

示例

s := array(array(1, 2, 3, 4, 5),
array(2, 3, 4, 5, 6),
array(3, 4, 5, 6, 7));
return footerValue(s, 1, 3, '', 1);
// 返回:

formatFloatExt(v, dtype)

声明：function

格式化输出－数字

参数	类型	说明
v	real	实数
dtype	integer	数据的格式

返回：string

示例

return formatFloatExt(12345.67, 1);
// 结果：’ 12,345.67’
return formatFloatExt("123");
// 结果：’ -’

formatStrExt(s)

声明：function

判断字符串是否是字符串，不是字符串的显示为"-"

参数	类型	说明
s	string	字符串

返回：string

示例

return formatStrExt('aaaaa');
// 结果：’aaaaa’
return formatStrExt(123);
// 结果：’-’

formatStrToDateTime2(s, format_str)

声明：function

格式化字符串->日期时间(包含毫秒)

参数	类型	说明
s	string	字符串类型，时间字符串
format_str	string	字符串类型，格式字符串

返回：datetime

示例

// 字符串2021-8-12 10:31:24:199 转换为日期时间格式(包含毫秒)
s := "2021.01.04T23:00:00.000";
format_str := "yyyy.mm.ddThh:nn:ss.zzz";
return formatStrToDateTime2(s, format_str); // 结果：44200.9583333333

Frame_addprefix(t, prefix, ifcopy)

声明：function

数据表-数组下标批量加前缀 二维数组，对列名加前缀 一维数组，对行下标加前缀

参数	类型	说明
t	any	Table,源数组
prefix	string	String,前缀
ifcopy	bool	Bool,是否在拷贝后的数组改列名,默认True

返回：array

示例

data := array(("code": "A", "value": 1));
echo trim(toStn(Frame_addprefix(data, "pre_", true)));

Frame_addsuffix(t, suffix, ifcopy)

声明：function

数据表-数组下标批量加后缀 二维数组，对列名加后缀 一维数组，对行下标加后缀

参数	类型	说明
t	any	Table,源数组
suffix	string	String,后缀
ifcopy	bool	Bool,是否在拷贝后的数组改列名，默认True

返回：array

示例

data := array(("code": "A", "value": 1));
echo trim(toStn(Frame_addsuffix(data, "_new", true)));

frameconcat(arrdic, _type)

声明：function

数据表-拼接

参数	类型	说明
arrdic	array	Array of number,数组的数组,需要拼接的数组集合
_type	Usrdefine	Usrdefine,数组拼接方式，默认为0行并=0；列并=1；非完全矩阵列并=2

返回：array

示例

a := ones(3,3);
b := ones(2,3);
frameconcat(array(a,b));

framecorrel(data)

声明：function

数据表-相关系数矩阵

参数	类型	说明
data	table	Table,二维数据表，列名可为字符串,不支持一维数组

返回：array

示例

arr := array(
    ("沪深300":-0.16,"中证500":-0.46,"中证1000":-0.72,"国债指数":0.06),
    ("沪深300":2.4,"中证500":2.38,"中证1000":2.77,"国债指数":0.02),
    ("沪深300":0.61,"中证500":1.84,"中证1000":2.14,"国债指数":0.03),
    ("沪深300":-0.22,"中证500":-0.26,"中证1000":-0.2,"国债指数":0.05),
    ("沪深300":1.01,"中证500":0.27,"中证1000":0.21,"国债指数":-0.0),
    ("沪深300":-0.19,"中证500":-0.16,"中证1000":-0.27,"国债指数":-0.02),
    ("沪深300":0.72,"中证500":0.77,"中证1000":0.85,"国债指数":0.0),
    ("沪深300":-0.87,"中证500":-0.66,"中证1000":-0.59,"国债指数":0.02),
    ("沪深300":1.96,"中证500":1.42,"中证1000":1.09,"国债指数":0.01),
    ("沪深300":0.02,"中证500":-0.24,"中证1000":-0.15,"国债指数":0.11));
return frameCorrel(arr);

framecov(data)

声明：function

数据表-协方差

参数	类型	说明
data	table	Table,二维数据表，列名可为字符串。不支持一维数组

返回：array

示例

arr := array(
    ("沪深300":-0.16,"中证500":-0.46,"中证1000":-0.72,"国债指数":0.06),
    ("沪深300":2.4,"中证500":2.38,"中证1000":2.77,"国债指数":0.02),
    ("沪深300":0.61,"中证500":1.84,"中证1000":2.14,"国债指数":0.03),
    ("沪深300":-0.22,"中证500":-0.26,"中证1000":-0.2,"国债指数":0.05),
    ("沪深300":1.01,"中证500":0.27,"中证1000":0.21,"国债指数":-0.0),
    ("沪深300":-0.19,"中证500":-0.16,"中证1000":-0.27,"国债指数":-0.02),
    ("沪深300":0.72,"中证500":0.77,"中证1000":0.85,"国债指数":0.0),
    ("沪深300":-0.87,"中证500":-0.66,"中证1000":-0.59,"国债指数":0.02),
    ("沪深300":1.96,"中证500":1.42,"中证1000":1.09,"国债指数":0.01),
    ("沪深300":0.02,"中证500":-0.24,"中证1000":-0.15,"国债指数":0.11));
return framecov(arr);

framecut(a, bins, option, o_lables)

声明：function

从小到大分段分组，最小的为第0组

参数	类型	说明
a	array	数据表或一维数字数组，数据表时，表示对每列分别操作
bins	array	一维数字数组，分段节点，例如array(0,1)将数组a分为[-inf,0)[0,1)[1,inf)三段，
option	integer	整型，区间开/闭，默认为0
o_lables	integer	数组，输出分组区间说明

返回：array

示例

范例1：

a := array(0, 59, 60, 70, 80, 99, 100);
bins := array(60, 80);
return framecut(a, bins, 0);
// array(0,0,1,1,2,2,2)

范例2

a := array(0, 59, 60, 70, 80, 99, 100);
bins := 5;
return framecut(a, bins, 0);
// array(0,2,3,3,4,4,4)

Framedrop_duplicates(data, subset, keep, rowname)

声明：function

数据表-去重

参数	类型	说明
data	array	Table,二维数据表,源数据
subset	string	String,去重字段
keep	string	String,去重保留方法，""f"":保留首个，""l"":保留最后
rowname	string	String,保留原索引重置字段名

返回：array

示例

data := array(
    ("code": "A", "value": 1),
    ("code": "A", "value": 2),
    ("code": "B", "value": 3)
);
echo trim(toStn(Framedrop_duplicates(data, "code", "f", "source_index")));

Framedrop_na(data, how, subset)

声明：function

数据表-去掉含Nan的行

参数	类型	说明
data	array	Table,二维数据表,源数据
how	string	String,去na行方法，默认/1/""any"":任意，2/""all"":所有
subset	string	String,去重字段

返回：array

示例

data := array((nan, 8), (1, 3));
echo trim(toStn(Framedrop_na(data, "any", array(0))));

frameGetSubByReg(data, reg)

声明：function

通过正则表达式匹配获取数据框子集

参数	类型	说明
data	array	数组，待匹配的数组
reg	string	字符串，间隔名，正则匹配串

返回：array

示例

t := array((13: 1, "V1": 1, "V2": 11, 12: 21, 'R1w': 1),
(13: 0, "V1": 2, "V2": 12, 12: 22, 'R1w': 1),
(13: 1, "V1": 3, "V2": 13, 12: 23, 'R1w': 1),
(13: 0, "V1": 4, "V2": 14, 12: 24, 'R1w': 1),
(13: 1, "V1": 5, "V2": 15, 12: 25, 'R1w': 1),
(13: 0, "V1": 6, "V2": 16, 12: 26, 'R1w': 1));
return frameGetSubByReg(t, '1');
// 结果：
// array(
// (21, 1, "V1": 1, "R1w": 1),
// (22, 0, "V1": 2, "R1w": 1),
// (23, 1, "V1": 3, "R1w": 1),
// (24, 0, "V1": 4, "R1w": 1),
// (25, 1, "V1": 5, "R1w": 1),
// (26, 0, "V1": 6, "R1w": 1))

framehhi(data)

声明：function

数据表-HHI指数、赫芬达尔—赫希曼指数

参数	类型	说明
data	table	Table,数组

返回：array

示例

data := array(0.4, 0.3, 0.2, 0.1);
return framehhi(data); // HHI = 0.4^2+0.3^2+0.2^2+0.1^2
// 输出：0.3

frameIndex_filter(rawkeys, filter_cond, filter_type, dz_valuetokey)

声明：function

数组筛选器，用于下标数组行名或列名的筛选器

参数	类型	说明
rawkeys	array	一维字符串数组,下标数组(0开始的自增下标)
filter_cond	string	字符串,筛选条件
filter_type	any	用户自定义,筛选类型
dz_valuetokey	any	整数,Out:类型1时，输出ivalue对照用

返回：array

示例

columns := array("name", "period", "factor", "IC@mean", "IC@ratio");
echo trim(toStn(frameIndex_filter(columns, array("period", "factor"), 1)));

frameIndex_getilocDZ(raw_data_cols)

声明：function

用于方便获取 下标值 与 字段位置 下标数组对照（下标值->下标位置）

参数	类型	说明
raw_data_cols	array	一维字符串数组,下标数组(从0开始自增数组)

返回：array

示例

echo trim(toStn(frameIndex_getilocDZ(array("growth", "value", "momentum"))));

frameinsert(data, loc, fname, v)

声明：function

数据表-指定位置插入列

参数	类型	说明
data	table	Table,二维数据表,源数据
loc	integer	Integer,插入位置
fname	string	String,插入索引命名
v	integer	Integer,插入值

返回：array

示例

data := array(
    ("SepalLength":4.6,"SepalWidth":3.1),
    ("SepalLength":5.0,"SepalWidth":3.6),
    ("SepalLength":5.4,"SepalWidth":3.9));
return frameinsert(data, 1, '新列', 0);
// 输出：
// array(
// ("SepalLength":4.6,"新列":0,"SepalWidth":3.1),
// ("SepalLength":5.0,"新列":0,"SepalWidth":3.6),
// ("SepalLength":5.4,"新列":0,"SepalWidth":3.9))

Framelag_zf(t, period, fillzero)

声明：function

数据表-推移涨幅(%) 涨幅(%)算法： period>0: 前n期涨幅 r[i] := (t(i)/t(i-period)-1)*100; period<0: 到未来n期涨幅 r[i] := (t(i-period)/t(i)-1)*100; 注意period>0时，与framePct_change的结果一致

参数	类型	说明
t	array	Array of number,数据表，支持一维和二维
period	any	Integer,移动期数，默认1
fillzero	bool	Bool,下标越界是，是否返回0.False返回inf

返回：array

示例

echo trim(toStn(Framelag_zf(array(10, 5, 8, 2), 1, false)));

frameMelt(t, id_names, value_names, variable_sname, value_sname)

声明：function

二维表——>立体表

参数	类型	说明
t	array	二维字符串数组，数据表
id_names	array	一维字符串数组，键字段
value_names	array	一维字符串数组，值字段。为nil或者空时，表每行除开键字段外都是值字段
variable_sname	string	字符串，变量展示名
value_sname	string	字符串，值展示名

返回：array

示例

t := array(
('截止日': 20210101, 'SH000300': 1, 'SH000301': 3),
('截止日': 20210102, 'SH000300': 9, 'SH000301': 2),
);
id_names := array('截止日');
return frameMelt(t, '截止日', nil, '代码', '得分');

framemerge(left, right, ons, how)

声明：function

数据表-联结

参数	类型	说明
left	table	Table,左表
right	table	Table,右表
ons	string	String,联结字段，可以为数组
how	string	String,: 联结类型

返回：array

示例

范例1：

left := `array('a': 3->5, 'b': array(0.1, 0.2, 0.3));
right := `array('a': 1->4, 'b': array(0.5, 0.6, 0.7, 0.8), 'c': array(10, 20, 30, 40));
return framemerge(left, right, 'a');
// 输出：内连接，仅保留两表 a 均匹配的行(a=3,4)，重名列 a、b 加 _x/_y 后缀区分。
// array(
// ("a_x":3,"b_x":0.1,"a_y":3,"b_y":0.7,"c":30),
// ("a_x":4,"b_x":0.2,"a_y":4,"b_y":0.8,"c":40))

范例2

// 多字段merge
left := `array('a': 3->5, 'b': array(0.1, 0.2, 0.3));
left[: , 'c'] := left[: , 'a'];
right := `array('a': 1->4, 'b': array(0.5, 0.6, 0.7, 0.8), 'c': array(10, 20, 30, 40));
right[: , 'c'] := right[: , 'a'];
names := array('a', 'c');
return framemerge(left, right, names, 'left', nil, true);
// 输出：按 a、c 两字段做左连接(how='left')，保留左表全部行(a=3,4,5)，重名列加 _x/_y 后缀。
// array(
// ("a_x":3,"b_x":0.1,"c_x":3,"a_y":3,"b_y":0.7,"c_y":3),
// ("a_x":4,"b_x":0.2,"c_x":4,"a_y":4,"b_y":0.8,"c_y":4),
// ("a_x":5,"b_x":0.3,"c_x":5))

范例3

// 只更名right
left := `array('a': 3->5, 'b': array(0.1, 0.2, 0.3));
right := `array('a': 1->4, 'b': array(0.5, 0.6, 0.7, 0.8), 'c': array(10, 20, 30, 40));
return framemerge(left, right, 'a', 'full', array(nil, '_x'));
// 输出：全外连接(how='full')，保留两表所有 a；仅右表重名列加 '_x' 后缀(左表列名不变)。
// array(
// ("a":3,"b":0.1,"a_x":3,"b_x":0.7,"c":30),
// ("a":4,"b":0.2,"a_x":4,"b_x":0.8,"c":40),
// ("a":5,"b":0.3),
// ("a_x":1,"b_x":0.5,"c":10),
// ("a_x":2,"b_x":0.6,"c":20))

Framepct_change(t, period, fillzero)

声明：function

数据表-到当期的变动百分比(%) 变动百分比(%)算法 r[i] := (t(i)/t(i-period)-1)*100

参数	类型	说明
t	array	Array of number,数据表，支持一维和二维
period	any	Integer,变动期数，默认1
fillzero	bool	Bool,下标越界是，是否返回0. False返回inf

返回：array

示例

echo trim(toStn(Framepct_change(array(10, 5, 8, 2), 1, false)));

framePivot_table(t, index, columns, vals, aggfunc, aggfuncnames)

声明：function

分组、透视、汇总，类似可见Pivot_table

参数	类型	说明
t	any	数据表类型,数据表
index	string	字符串,行分类字段，字段值含有nill等不可设为索引
columns	array	一维字符串数组,列分类字段，字段值含有nill等不可设为索引
vals	array	一维字符串数组,值字段，未指定时，代表对所有除index、columns 指定字段之外的所有字段计算
aggfunc	string	字符串,值汇总函数,支持如下:；a、所有 TS_SQL 聚合函数:e.g:"avg"(avgof),"sum"(sumof)；b、内置函数:；"_details": 分组详情；"_first": 第一个；"_last": 最后一个；c、自定义函数中使用关键字thisgroup 得到当前分组数据。
aggfuncnames	array	一维字符串数组,自定义汇总函数名称对照表

返回：array

示例

data := array(
    ("group": "A", "date": "2025-01-01", "value": 1),
    ("group": "A", "date": "2025-01-02", "value": 2),
    ("group": "B", "date": "2025-01-01", "value": 3)
);
echo trim(toStn(framePivot_table(
    data,
    "group",
    array("date"),
    array("value"),
    "sum",
    nil
)));

frameqcut(data, q)

声明：function

数据表-按频率分组(等频分组)

参数	类型	说明
data	table	Table,数据表或一维数字数组，数据表时，表示对
q	integer	Integer,分组数，等分q组，正整数，默认q=5

返回：array

示例

data := array(1, 2, 3, 4, 5, 6, 7, 8, 9);
return frameqcut(data, 3); // 按大小等频分为 3 组，返回各元素所属组号(0,1,2)
// 输出：array(0,0,0,1,1,1,2,2,2)

frameupdate(left, right, ons, _type, _type)

声明：function

数据表-更新

参数	类型	说明
left	table	Table,待更新数据，直接更改
right	table	Table,右表
ons	string	String,键字段，默认为nil，表以下标进行联结。
_type	integer	Integer,缺失类型，详见MF_isMissValue
_type	integer	为以下数值的组合(以下数值的_XOR或者相加)

返回：array

示例

left := `array('a': 3->5, 'b': rand(3));
right := `array('a': 1->4, 'b': rand(4), 'c': rand(4) * 10);
return frameupdate(left, right, 'a');

framevaluecounts(data, countfieldname, iforder)

声明：function

数据表-计数

参数	类型	说明
data	table	Table,可以为二维数据表或者为一维数组
countfieldname	string	String,计数字段名，默认为""个数""
iforder	bool	Bool,是否排序，默认为真

返回：array

示例

data := array("a", "b", "a", "c", "a", "b");
return framevaluecounts(data, "个数", true); // 统计各值出现次数，按次数降序
// 输出：
// array(
// ("值":"a","个数":3),
// ("值":"b","个数":2),
// ("值":"c","个数":1))

fuzzyCompare(_type, s1, s2)

声明：function

根据指定算法，计算两字符串的相似性

参数	类型	说明
_type	integer	模糊匹配算法类型，支持如下几种算法：
s1	string	字符串1
s2	string	字符串2

返回：real

示例

// 使用Jaccard相似度算法，计算字符串"kitten"和"sitting"的相似性
return fuzzyCompare(fzJaccard(), "kitten", "sitting"); // 等价于FuzzyCompare(2,"kitten","sitting")
// 返回：0.222222222222222

fuzzyCompareEx(_type, s1, s2, n, nret)

声明：function

根据指定算法，计算两字符串的相似性

参数	类型	说明
_type	integer	模糊匹配算法类型，支持如下几种算法：
s1	string	字符串1
s2	string	字符串2
n	integer	仅指定算法为FzJaccard、FzCosine、FzSimHash时，该参数有效；其对应含义和默认值如下：
nret	integer	输出值；指定不同的算法时，其对应含义如下：

返回：real

示例

// 使用Jaccard相似度算法，指定切分字符长度为1，计算字符串"kitten"和"sitting"的相似性
t := fuzzyCompareEx(fzJaccard(), "kitten", "sitting", 1, nret);
return array(t, nret);
// t值为相似性，nret值为两字符串切分后交集中元素个数，返回值为array(0.428571428571429,3)

fzCosine()

声明：function

Cosine（余弦相似度）算法类型：将字符串根据指定长度n（默认值为2）划分为两个字符集合，将字符集合转换为向量，计算两向量夹角的余弦值

返回：integer

示例

范例一：FuzzyCompare相似性计算，字符切分长度为2

return fuzzyCompare(fzCosine(), "kitten", "sitting");
// 返回：0.365148371670111

范例二：FuzzyCompareEx相似性计算，指定字符切分长度为1

return fuzzyCompareEx(fzCosine(), "kitten", "sitting", 1, nret);
// 返回：0.746202507244636
// 算法对比解析：
// FuzzyCompare：字符切分长度为2，字符串"kitten"切分后的集合为：{ki, it, tt, te, en}，"sitting"：{si, it, tt, ti, in, ng}；转换成向量分别为：[1, 1, 1, 1, 1, 0, 0, 0, 0]、[0, 1, 1, 0, 0, 1, 1, 1, 1]，代入算法中，计算出的相似度为0.365148371670111
// FuzzyCompareEx：字符切分长度为1，字符串"kitten"切分后的集合为：{k, i, t, e, n}，"sitting"：{s, i, t, n, g}，转换成向量分别为：[1, 1, 2, 1, 1, 0, 0]、[0, 2, 2, 0, 1, 1, 1]，代入算法中，计算出的相似度为0.746202507244636

fzEditDistance()

声明：function

基于编辑距离（Edit Distance）的模糊匹配算法，核心是计算将一个字符串转换为另一个字符串所需的最小编辑操作次数，允许的操作包含插入、删除、替换三类

返回：integer

示例

范例一：FuzzyCompare相似性计算

return fuzzyCompare(fzEditDistance(), "kitten", "sitting");
// 返回：0.571428571428571

范例一：FuzzyCompareEx相似性计算

t := fuzzyCompareEx(fzEditDistance(), "kitten", "sitting", n, nret);
return array(t, nret);
// 返回：array(0.571428571428571,3)
// 算法对比解析：
// 字符串"kitten"转换为"sitting"需要3步（k->s，e->i，添加g），字符串总长度7，相似度为1-3/7=4/7（即0.571428571428571）

fzHammingDistance()

声明：function

Hamming Distance（汉明距离）算法类型：计算两字符串对应位置上不同字符的数量

返回：integer

示例

范例一：FuzzyCompare相似性计算

return fuzzyCompare(fzHammingDistance(), "kitten", "sitting");
// 返回：0.571428571428571

范例二：FuzzyCompareEx相似性计算

t := fuzzyCompareEx(fzHammingDistance(), "kitten", "sitting", n, nret);
return array(t, nret);
// 返回：array(0.571428571428571,3)
// 算法对比解析：
// 字符串"kitten"、"sitting"对应位置上不同的字符有3处（k->s, e->i, g），字符串总长度为7，相似度为1-3/7=4/7（即0.571428571428571）

fzJaccard()

声明：function

Jaccard相似度算法类型：将字符串根据指定长度n（默认值为2）划分为两个字符集合，计算两集合交集元素个数与并集元素个数的比值

返回：integer

示例

范例一：FuzzyCompare相似性计算，字符切分长度为2

return fuzzyCompare(fzJaccard(), "kitten", "sitting");
// 返回：0.222222222222222

范例二：FuzzyCompareEx相似性计算，指定字符切分长度为1

t := fuzzyCompareEx(fzJaccard(), "kitten", "sitting", 1, nret);
return array(t, nret);
// 返回：array(0.428571428571429,3)
// 算法对比解析：
// FuzzyCompare：字符切分长度为2，字符串"kitten"切分后的集合为：{ki, it, tt, te, en}，"sitting"为：{si, it, tt, ti, in, ng}；交集：{it, tt}，并集：{ki, it, tt, te, en, si, ti, in, ng}，相似度为2/9（即0.222222222222222）
// FuzzyCompareEx：指定字符切分长度为1，字符串"kitten"切分后的集合为：{k, i, t, e, n}，"sitting"为：{s, i, t, n, g}，交集：{i, t, n}，并集：{k, i, t, e, n, s, g}，相似度为3/7（即0.428571428571429）

fzJaroWinkler()

声明：function

Jaro-Winkler距离算法类型：先统计两字符串的匹配字符数与换位次数，并代入Jaro距离算法公式，得到相似度，再根据两字符串的公共前缀长度给予额外加权，得到最终的相似度

返回：integer

示例

范例一：FuzzyCompare相似性计算

return fuzzyCompare(fzJaroWinkler(), "kitten", "sitting");
// 返回：0.746031746031746

范例二：FuzzyCompareEx相似性计算

return fuzzyCompareEx(fzJaroWinkler(), "kitten", "sitting", n, nret);
// 返回：0.746031746031746

fzLongestSequnce()

声明：function

Longest Sequnce（最长公共子序列）算法类型：找出两字符串中顺序相同但不必连续的最长子序列

返回：integer

示例

范例一：FuzzyCompare相似性计算

return fuzzyCompare(fzLongestSequnce(), "kitten", "sitting");
// 返回：0.571428571428571

范例二：FuzzyCompareEx相似性计算

t := fuzzyCompareEx(fzLongestSequnce(), "kitten", "sitting", n, nret);
return array(t, nret);
// 返回：array(0.571428571428571,4)
// 算法对比解析：
// 字符串"kitten"、"sitting"中顺序相同但不必连续的最长子序列为"ittn"，字符串总长度为7，相似度为4/7（即0.571428571428571）

fzLongestSubstring()

声明：function

Longest Substring（最长公共子串）算法类型：找出两字符串中连续出现的最长相同子串

返回：integer

示例

范例一：FuzzyCompare相似性计算

return fuzzyCompare(fzLongestSubstring(), "kitten", "sitting");
// 返回：0.428571428571429

范例二：FuzzyCompareEx相似性计算

t := fuzzyCompareEx(fzLongestSubstring(), "kitten", "sitting", n, nret);
return array(t, nret);
// 返回：array(0.428571428571429,3)
// 算法对比解析：
// 字符串"kitten"、"sitting"中连续出现的最长相同子串为"itt"，字符串总长度为7，相似度为3/7（即0.428571428571429）

fzSimHash()

声明：function

SimHash（局部敏感哈希）算法类型：对字符串分词并计算加权哈希生成二进制指纹，比较两个指纹间的对应位置上不同字符的数量

返回：integer

示例

范例一：FuzzyCompare相似性计算，特征词数量为3

return fuzzyCompare(fzSimHash(), "kitten", "sitting");
// 返回：0.640625

范例二：FuzzyCompareEx相似性计算，特征词数量为1

t := fuzzyCompareEx(fzSimHash(), "kitten", "sitting", 1, nret);
return array(t, nret);
// 返回：array(0.921875,5)

geoMeanByColumn(t, f_name)

声明：function

指定列的几何平均值

参数	类型	说明
t	array	数据表
f_name	string	指定列名

返回：real

示例

t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 5, 'c': 5));
return geoMeanByColumn(t1, 'b');
// 结果：4.47

get_dummies(a, uniques)

声明：function

1、根据指定的分类变量，生成虚拟变量/指示变量（dummy/indicator）虚设变量/名义变量/哑 变量，也有称之为one_hot编码，离散特征值二值化 2、如果a中含Nan值，排到uniques的末尾

参数	类型	说明
a	array	一维数组，指定的分类变量
uniques	array	一维数组，中间结果:输出各列对应的分类变量

返回：array

示例

data := array("A", "B", "C", "A");
encoded := get_dummies(data, categories);
echo trim(toStn(array("categories": categories, "encoded": encoded)));

get_dummies2(a)

声明：function

1、根据指定的分类变量，生成虚拟变量/指示变量（dummy/indicator）虚设变量/名义变量/哑 变量，也有称之为one_hot编码，离散特征值二值化 2、a中的元素必须都可以做为数组下标，否则请使用get_dummies

参数	类型	说明
a	array	一维数组，指定的分类变量

返回：array

示例

echo trim(toStn(get_dummies2(array("A", "A", "B", "C"))));

getBottomN(t, n)

声明：function

取数组后N行，一般先用SortByField排序，然后使用此函数

参数	类型	说明
t	array	数据表
n	integer	整数

返回：array

示例

t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 33));
return getBottomN(t2, 2);

getDistinctValue(t, f_name)

声明：function

获取指定列唯一值，返回值为一维数组

参数	类型	说明
t	array	数据表
f_name	string	指定列名

返回：array

示例

t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return getDistinctValue(t2, 'a');

getMiddleN(t, from_no, to_no)

声明：function

取数组指定行区间记录，一般先用SortByField排序，然后使用此函数

参数	类型	说明
t	array	数据表
from_no	integer	起始行数:整数，从1开始
to_no	integer	截止行数:整数，从1开始

返回：array

示例

t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 4, 'c': 33), ('a': 5, 'c': 33));
return getMiddleN(t2, 2, 3);

getMsgDigest(arg)

声明：function

计算字符串或文件的摘要并返回摘要字符串

参数	类型	说明
arg	string	要计算摘要的字符串
digest_type	int	摘要算法编号：0 CRC32，1 MD5，2 SHA1，3 SHA224，4 SHA256，5 SHA384，6 SHA512
alias	string	文件所在目录别名；不用别名时传空字符串
filename	int	要计算摘要的文件路径
digest_type	any	摘要算法编号：0 CRC32，1 MD5，2 SHA1，3 SHA224，4 SHA256，5 SHA384，6 SHA512

返回：string

getPyStringList()

声明：function

获取汉字拼音首字母对照表

返回：tslobj

示例

sl := getPyStringList();
return sl.values("明");
// 返回：M

getSubField(t, field)

声明：function

获取取表中某一字段的全部列值

参数	类型	说明
t	array	二维数组
field	string	列标名，字符串/整数

返回：array

示例

a := array(('a': 8, 'b': 7), ('a': 6, 'b': 9));
return getSubField(a, 'a'); // 从a表中取第’a列’

getSubTable(table, field_arr)

声明：function

将一个表类型数组只保留指定的字段并返回

参数	类型	说明
table	array	二维数组
field_arr	array	列标名，一维数组

返回：array

示例

a := array((1, 2, 4), (11, 12, 14));
b := array(0, 2);
return getSubTable(a, b);

getSubTableByField(t)

声明：function

获取表t中的Fields 列的数据。该函数功能可以用子矩阵的方式实现:t[:,array(fn1,fn2...)]

参数	类型	说明
t	array	数据表类型，数据表

返回：any

示例

r := array(
    ("time":"2026-07-03","close":10.29,"open":10.29,"high":10.4),
    ("time":"2026-07-06","close":10.5,"open":10.25,"high":10.52),
    ("time":"2026-07-07","close":10.47,"open":10.46,"high":10.51),
    ("time":"2026-07-08","close":10.6,"open":10.44,"high":10.63),
    ("time":"2026-07-09","close":10.49,"open":10.55,"high":10.59));
return getSubTableByField(r, 'time;close');
// 功能相当于使用子矩阵取数：r[: , array('time', 'close')]
// 返回:
// array(
// ("time":"2026-07-03","close":10.29),
// ("time":"2026-07-06","close":10.5),
// ("time":"2026-07-07","close":10.47),
// ("time":"2026-07-08","close":10.6),
// ("time":"2026-07-09","close":10.49))

getSubTableByKey(t, key_field, return_fields)

声明：function

将字符串KeyField以分号分隔,在数组t中从列ReturnFields匹配被分割的值,若找到则返回该行信息，否则返回空数组

参数	类型	说明
t	array	数据表类型，数据表
key_field	string	字符串，关键字字段
return_fields	string	字符串，要返回的字段名称

返回：array

示例

s := array(array('A': 'a', 'B': 'b', 'C': 'c', 'D': 'd', 'e': 'e'),
array('A': 'c', 'B': 3, 'C': 4, 'D': 5, 'e': 6),
array('A': 3, 'B': 4, 'C': 5, 'D': 6, 'e': 7));
return getSubTableByKey(s, 'A', 'a;c');
// 返回:

getSubTableFreeParam()

声明：function

取子表，系统第二个到最个一个参数为字段序列，取第一个参数中字段与字段序列匹配的列数据

返回：array

示例

return getSubTableFreeParam(); // 之前在系统参数中已经设置好第一个参数s=array(array('s':1,'w':2,'sl':3), array('s':2,'w':3,'sl':4), array('s':3,'w':4,'sl':5)),第二三个参数’s’,’w’。
// 返回:

getTopN(t, n)

声明：function

取数组前N行记录，一般先用SortByField排序，然后使用此函数

参数	类型	说明
t	array	数据表
n	integer	整数

返回：array

示例

t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 33));
return getTopN(t2, 2);

getValuesByFieldValue(t, f_name, field_value)

声明：function

返回指定字段值等于指定值的所有记录

参数	类型	说明
t	array	二维数组
f_name	string	字符串，指定字段
field_value	string	整数/字符串，指定值

返回：array

示例

t := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 4));
return getValuesByFieldValue(t, 'b', 4); // 返’b’列值为4的所有记录

groupByFieldValue(t, group_field, lowvalue, high_value, sep_value)

声明：function

按字段大小进行汇总。小于最小值Lowvalue为一组，从最小值Lowvalue到最大值HighValue中间每步长SepValue为一组，大于最大值High为一组

参数	类型	说明
t	array	数据表类型
group_field	string	字符串，列名
lowvalue	real	实数，最小数值
high_value	real	实数，最大数值
sep_value	real	实数，统计间距

返回：any

示例

data := select * from tradetable datekey 20180903t to 20180904T of 'sz000001' end;
return groupByFieldValue(data, 'close', 1, 20, 0.1);
// 返回:

groupDemeanIt(t, g_name, v_name)

声明：function

1、分组去均值，对数据表t按[GName]分组后，对每组的[VName]去均值

参数	类型	说明
t	dbdata	数据表，待分组去均值数据
g_name	string	字符串，t的分组字段名
v_name	string	字符串，去均值字段名

返回：array

示例

范例1：

t := array(
("G": 1, "V1": 1, "V2": 11, "V3": 21),
("G": 0, "V1": 2, "V2": 12, "V3": 22),
("G": 1, "V1": 3, "V2": 13, "V3": 23),
("G": 0, "V1": 4, "V2": 14, "V3": 24),
("G": 1, "V1": 5, "V2": 15, "V3": 25),
("G": 0, "V1": 6, "V2": 16, "V3": 26));
return groupDemeanIt(t, 'G', 'V1'); // array(-2.0,-2.0,0.0,0.0,2.0,2.0)

范例2

t := array(
("G": 1, "V1": 1, "V2": 11, "V3": 21),
("G": 0, "V1": 2, "V2": 12, "V3": 22),
("G": 1, "V1": 3, "V2": 13, "V3": 23),
("G": 0, "V1": 4, "V2": 14, "V3": 24),
("G": 1, "V1": 5, "V2": 15, "V3": 25),
("G": 0, "V1": 6, "V2": 16, "V3": 26));
return groupDemeanIt(t, 'G', array('V1', 'V2'));
// 输出：
// array(
// ("V1":-2.0,"V2":-2.0),
// ("V1":-2.0,"V2":-2.0),
// ("V1":0.0,"V2":0.0),
// ("V1":0.0,"V2":0.0),
// ("V1":2.0,"V2":2.0),
// ("V1":2.0,"V2":2.0))

groupPercentrankIt(t, g_name, v_name)

声明：function

计算分组百分位，对数据表t按[GName]分组后，对每组的[Vname_]计算百分位

参数	类型	说明
t	array	数组，待计算的数组
g_name	string	字符串，分组字段名
v_name	string	字符串，转换字段名

返回：array

示例

t := array(("G": 1, "V1": 1, "V2": 11, "V3": 21),
("G": 0, "V1": 2, "V2": 12, "V3": 22),
("G": 1, "V1": 3, "V2": 13, "V3": 23),
("G": 0, "V1": 4, "V2": 14, "V3": 24),
("G": 1, "V1": 5, "V2": 15, "V3": 25),
("G": 0, "V1": 6, "V2": 16, "V3": 26));
return groupPercentrankIt(t, 'G', 'V1'); // array(0.0,0.0,0.5,0.5,1.0,1.0)

groupRankIt(t, g_name, v_name, sort_order)

声明：function

计算分组排名，对数据表t按[GName]分组后，对每组的[Vname_]计算排名

参数	类型	说明
t	array	数组，待计算的数组
g_name	string	字符串，分组字段名
v_name	string	字符串，转换字段名
sort_order	bool	布尔型，排名方向

返回：array

示例

t := array(
("G": 1, "V1": 1, "V2": 11, "V3": 21),
("G": 0, "V1": 2, "V2": 12, "V3": 22),
("G": 1, "V1": 3, "V2": 13, "V3": 23),
("G": 0, "V1": 4, "V2": 14, "V3": 24),
("G": 1, "V1": 5, "V2": 15, "V3": 25),
("G": 0, "V1": 6, "V2": 16, "V3": 26));
return groupRankIt(t, 'G', 'V1'); // array(1,1,2,2,3,3)

groupTransformByFunc(t, g_name, v_name, fp)

声明：function

计算分组排名，对数据表t按[GName]分组后，对每组的[Vname_]根据给定函数进行分组转换操作

参数	类型	说明
t	array	数组，待计算的数组
g_name	string	字符串，分组字段名
v_name	string	字符串或数组，转换字段名
fp	string	字符串（函数名）或函数指针，转换函数必须两个参数，分别表示当前的聚合字段与排名字段，以分组排名为例:

返回：array

示例

t := array(("G": 1, "V1": 1, "V2": 11, "V3": 21),
("G": 0, "V1": 2, "V2": 12, "V3": 22),
("G": 1, "V1": 3, "V2": 13, "V3": 23),
("G": 0, "V1": 4, "V2": 14, "V3": 24),
("G": 1, "V1": 5, "V2": 15, "V3": 25),
("G": 0, "V1": 6, "V2": 16, "V3": 26));
fp := function (v, g);
begin
return rankof([v], [v]);
end
return groupTransformByFunc(t, 'G', 'V1', fp); // array(3,3,2,2,1,1)

groupZscoreIt(t, g_name, v_name)

声明：function

1.计算分组标准化，对数据表t按[GName]分组后，对每组的[Vname_]进行标准化(原值-分组平均)/分组标准差

参数	类型	说明
t	array	数组，待计算的数组
g_name	string	字符串，分组字段名
v_name	string	字符串，转换字段名。如果Vname为nil则表示除GName之外的所有字段，如果Vname为一个数组，则表示需要计算的字段组返回:二维数组，

返回：array

示例

t := array(
("G": 1, "V1": 1, "V2": 11, "V3": 21),
("G": 0, "V1": 2, "V2": 12, "V3": 22),
("G": 1, "V1": 3, "V2": 13, "V3": 23),
("G": 0, "V1": 4, "V2": 14, "V3": 24),
("G": 1, "V1": 5, "V2": 15, "V3": 25),
("G": 0, "V1": 6, "V2": 16, "V3": 26));
return groupZscoreIt(t, 'G', 'V1'); // array(-1.0,-1.0,0.0,0.0,1.0,1.0)

harMeanByColumn(t, f_name)

声明：function

指定列的调和平均值

参数	类型	说明
t	array	数据表
f_name	string	指定列名

返回：real

示例

t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 5, 'c': 5));
return harMeanByColumn(t1, 'b');
// 结果：4.44

histogram(t, bins, format)

声明：function

统计data的频数分布表

参数	类型	说明
t	array,tablearray	数字数组，待计算的数组
bins	array,tablearray	数组，表分组间隔
format	string	字符串，展示区间的格式串，见FormatFloat

返回：array,tablearray

示例

范例一：

return histogram(Randn(0, 1, 1000), array(-3, 0.5)->3, '0.00');
// 输出：频数分布表。区间列(<=-3.00、-3.00~-2.50 …… 2.50~3.00、>3.00)与区间中位数列固定，
// 但因 Randn 生成的是随机正态样本，各区间的频数、频率(%)、累计频率(%)每次运行都不同。

范例二：

data := randn(0, 1, 1000, array('a', 'b'));
return histogram(data, array(-3, 0.5)->3, '0.00');
// 输出：多列频数分布表。data 为两列(a、b)随机正态样本，结果按列给出 a@频数、a@频率(%)、
// a@累计频率(%)、b@频数 …… 等列。区间划分固定，但各频数因随机样本每次运行都不同。

hztoPy(hz)

声明：function

汉字翻译为拼音

参数	类型	说明
hz	string	String 汉字

返回：string

示例

return hztoPy("华夏优势"); // HXYS
return hztoPy("华夏盛势"); // HXCS HXSS

ifsparse(s)

声明：function

判断是否为稀疏矩阵。检查条件：只检查下标，下标全为大于等于0的整数

参数	类型	说明
s	array of real	待判断矩阵

返回：integer

示例

// 判断矩阵S是否为稀疏矩阵
s := Array(3: 2, "B": 3);
return ifsparse(s); // 返回0

importFile(filename, arg2, arg3, data2)

声明：function

从文件中导入数据

参数	类型	说明
filename	int
arg2	string
arg3	array
data2	bool

返回：bool

in1(v, x)

声明：function

判断数值x是否在数组v中，返回布尔类型

参数	类型	说明
v	array	一维数组
x	real	实数

返回：bool

示例

a := array(1, 2, 3, 4);
return in1(a, 3);
// 结果：1

incHalfYear(a_value, number)

声明：function

求Avalue的日期开始往后推移Number个半年的日期

参数	类型	说明
a_value	tdatetime	实数表示的日期
number	integer	向后推移的整数，负数表示向前推移

返回：tdatetime

示例

avalue := 40179; // 40179表示2010年1月1号
number := 2;
return incHalfYear(a_value, number);
// 结果：40544  //40544表示2011年1月1号

incQuarter(avalue, number)

声明：function

求Avalue的日期开始往后推移Number个季度的日期

参数	类型	说明
avalue	tdatetime	实数表示的日期
number	integer	向后推移的整数。负数表示向前推移。

返回：tdatetime

示例

avalue := 40179; // 40179表示2010年1月1号
number := 2;
return incQuarter(a_value, number);
// 结果：40360  //40360表示2010年7月1号

iniDeleteKey(alias, file_name, section, ident)

声明：function

删除INI中的标识符

参数	类型	说明
alias	string	字符串类型。目录名称
file_name	string	字符串类型。INI文件名称
section	string	字符串类型。INI文件中的节名称
ident	string	字符串类型。INI文件中要删除的键名称

返回：any

iniWriteBool(alias, file_name, section, ident, value)

声明：function

将BOOL值写入INI。如果不存在FileName，或者不存在Section，或者不存在Ident，则其会根据输入的FileName，Section，Ident创建对应的INI文件，INI文件的节名称，INI文件的键名称，并将Bool值Value写入到INI文件指定的键

参数	类型	说明
alias	string	字符串类型。目录名称
file_name	string	字符串类型。INI文件名称
section	string	字符串类型。INI文件的节名称
ident	string	字符串类型。INI文件的键名称
value	bool	object

返回：string

iniWriteDate(alias, file_name, section, ident, value)

声明：function

将日期值写入INI。如果不存在FileName，或者不存在Section，或者不存在Ident，则其会根据输入的FileName，Section，Ident创建对应的INI文件，INI文件的节名称，INI文件的键名称，并将日期值Value写入到INI文件指定的键

参数	类型	说明
alias	string	字符串类型。目录名称
file_name	string	字符串类型。INI文件名称
section	string	字符串类型。INI文件的节名称
ident	string	字符串类型。INI文件的键名称
value	datetime	日期类型。要写入的日期值

返回：string

iniWriteDateTime(alias, file_name, section, ident, value)

声明：function

将日期时间值写入INI。如果不存在FileName，或者不存在Section，或者不存在Ident，则其会根据输入的FileName，Section，Ident创建对应的INI文件，INI文件的节名称，INI文件的键名称，并将日期时间值Value写入到INI文件指定的键

参数	类型	说明
alias	string	字符串类型。目录名称
file_name	string	字符串类型。INI文件名称
section	string	字符串类型。INI文件的节名称
ident	string	字符串类型。INI文件的键名称
value	datetime	日期时间类型。要写入的日期时间值

返回：string

iniWriteFloat(alias, file_name, section, ident, value)

声明：function

将浮点值写入INI。如果不存在FileName，或者不存在Section，或者不存在Ident，则其会根据输入的FileName，Section，Ident创建对应的INI文件，INI文件的节名称，INI文件的键名称，并将浮点值Value写入到INI文件指定的键

参数	类型	说明
alias	string	字符串类型。目录名称
file_name	string	字符串类型。INI文件名称
section	string	字符串类型。INI文件的节名称
ident	string	字符串类型。INI文件的键名称
value	float	浮点类型。要写入的浮点数值

返回：string

iniWriteInteger(alias, file_name, section, ident, value)

声明：function

将整数值写入INI。如果不存在FileName，或者不存在Section，或者不存在Ident，则其会根据输入的FileName，Section，Ident创建对应的INI文件，INI文件的节名称，INI文件的键名称，并将整数值Value写入到INI文件指定的键

参数	类型	说明
alias	string	字符串类型。目录名称
file_name	string	字符串类型。INI文件名称
section	string	字符串类型。INI文件的节名称
ident	string	字符串类型。INI文件的键名称
value	float	整数类型。要写入的整数值

返回：string

iniWriteString(alias, file_name, section, ident, value)

声明：function

将字符串值写入INI。如果不存在FileName，或者不存在Section，或者不存在Ident，则其会根据输入的FileName，Section，Ident创建对应的INI文件，INI文件的节名称，INI文件的键名称，并将字符串Value写入到INI文件指定的键

参数	类型	说明
alias	string	字符串类型。目录名称
file_name	string	字符串类型。INI文件名称
section	string	字符串类型。INI文件的节名称
ident	string	字符串类型。INI文件的键名称
value	string	字符串类型。要写入的字符串

返回：string

iniWriteTime(alias, file_name, section, ident, value)

声明：function

将时间值写入INI。如果不存在FileName，或者不存在Section，或者不存在Ident，则其会根据输入的FileName，Section，Ident创建对应的INI文件，INI文件的节名称，INI文件的键名称，并将时间值Value写入到INI文件指定的键

参数	类型	说明
alias	string	字符串类型。目录名称
file_name	string	字符串类型。INI文件名称
section	string	字符串类型。INI文件的节名称
ident	string	字符串类型。INI文件的键名称
value	datetime	时间类型。要写入的时间值

返回：string

inRange(a_value, amin, amax)

声明：function

判断Avalue是否在[Amin, Amax]范围内

参数	类型	说明
a_value	float	要判断的实数
amin	float	实数，范围下限
amax	float	实数，范围上限

返回：bool

inserttablebyrno(t, index, rdata)

声明：function

向表格指定位置插入行，天软表格行下标从0开始

参数	类型	说明
t	array	Array,数组，支持一维，二维数组，只支持下标为自增长的序列数组
index	integer	Integer,插入行的起始下标，下标位置从０开始
rdata	any	Any,插入的数据，支持一个值、一维表及二维表

返回：array

示例

范例1：

// 向一维数组指定位置插入一个字符串’aaa’
t := 43456->43460;
index := 2;
r_data := 'aaa';
return inserttablebyrno(t, index, r_data);
// 结果：array(43456,43457,"aaa",43458,43459,43460)

范例2：

// 向一维数组第3行插入多行的数据
t := 44000->44004;
index := 3;
r_data := array('a', 'b', 'c');
return inserttablebyrno(t, index, r_data);
// 结果：
// array(44000, 44001, 44002, "a", "b", "c", 44003, 44004)

范例3：

// 向二维数组第3行插入多行的数据
t := array(('a': 10, 'b': 'i', 'c': dateToStr(20200319T)),
('a': 50, 'b': 'i', 'c': dateToStr(20200318T)),
('a': 60, 'b': 'i', 'c': dateToStr(20200317T)),
('a': 40, 'b': 'o', 'c': dateToStr(20200316T)),
('a': 20, 'b': 'o', 'c': dateToStr(20200313T)));
index := 3;
r_data := array(('c': 0, 'b': 44000, 'a': '2020-03-20'));
return inserttablebyrno(t, index, r_data);
// 输出：
// array(
// ("a":10,"b":"i","c":"2020-03-19"),
// ("a":50,"b":"i","c":"2020-03-18"),
// ("a":60,"b":"i","c":"2020-03-17"),
// ("c":0,"b":44000,"a":"2020-03-20"),
// ("a":40,"b":"o","c":"2020-03-16"),
// ("a":20,"b":"o","c":"2020-03-13"))

范例4：

// 向二维数组第1行插入多行的数据
t := array(('a': 10, 'b': 'i', 'c': dateToStr(20200319T)),
('a': 50, 'b': 'i', 'c': dateToStr(20200318T)),
('a': 60, 'b': 'i', 'c': dateToStr(20200317T)),
('a': 40, 'b': 'o', 'c': dateToStr(20200316T)),
('a': 20, 'b': 'o', 'c': dateToStr(20200313T)));
index := 1;
r_data := array(('c': '2020', 'b': 'AAA', 'a': 44456),
('c': '2020', 'b': 'BBB', 'a': 44566));
return inserttablebyrno(t, index, r_data);
// 输出：
// array(
// ("a":10,"b":"i","c":"2020-03-19"),
// ("c":"2020","b":"AAA","a":44456),
// ("c":"2020","b":"BBB","a":44566),
// ("a":50,"b":"i","c":"2020-03-18"),
// ("a":60,"b":"i","c":"2020-03-17"),
// ("a":40,"b":"o","c":"2020-03-16"),
// ("a":20,"b":"o","c":"2020-03-13"))

intersectionPart(v, w)

声明：function

求交集

参数	类型	说明
v	array	数组
w	array	数组

返回：array

示例

t1 := array(1.00, 3.00, 2.00, 9.00, 8.00);
t2 := array(3.00, 0.00, 7.00, 8.00, 1.00, 5.00);
return intersectionPart(t1, t2);

inverseTable(t)

声明：function

将数组t去掉第一列转置，转置后原数组t的第一列作为行标

参数	类型	说明
t	array	数据表类型

返回：array

示例

s := array(array('A': 'a', 'B': 'b', 'C': 'c', 'D': 'd', 'e': 'e'),
array('A': 2, 'B': 3, 'C': 4, 'D': 5, 'e': 6),
array('A': 3, 'B': 4, 'C': 5, 'D': 6, 'e': 7),);
return inverseTable(s);
// 返回:

istable(t)

声明：function

判断是否为数组。如果t为数据表，返回True；否则，返回False

参数	类型	说明
t	array	数据表

返回：bool

示例

t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));
return istable(t1);
// 结果：1

isValidDateDay(a_year, aday_of_year)

声明：function

判断参数指定的年以及此年的第ADayOfYear天是否是有效日期。返回值类型是布尔型真假值 所谓有效，意味着： 年Ayear介于1和9999之间 ADayOfYear介于1和指定Ayear年的最大天数

参数	类型	说明
a_year	int	整数，年，指定的年份
aday_of_year	int	整数，表示在指定年份中的第几天

返回：bool

kurtByColumn(t, f_name)

声明：function

指定列的峰度

参数	类型	说明
t	array	数据表
f_name	string	指定列名

返回：real

示例

t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return kurtByColumn(t2, 'c');
// 结果：0.34

leftStr(text, num_chars)

声明：function

返回字符串从开始向左数Num_Chars个字符组成的字符串，支持多字节语言，一个汉字当成一个字符

参数	类型	说明
text	string	字符串
num_chars	int	字符个数

返回：string

letters(vlaue, ul)

声明：function

将数字与在字符串进行对照转换。基本用法同R的letters。在超出26的时候，仿excel的列名的规则提取。用于将excel数字列名转为字符串列名：1->'A'

参数	类型	说明
vlaue	integer	整数。正整数列名
ul	integer	整数。是否大写，默认为1

返回：string/array

示例

return letters(1, 0);
// 结果：a

maxValueByColumn(t, f_name)

声明：function

求指定列中的最大值

参数	类型	说明
t	array	数据表
f_name	string	指定列名

返回：real

示例

t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return maxValueByColumn(t2, 'c');
// 结果：53

medianByColumn(t, f_name)

声明：function

指定列的中位数

参数	类型	说明
t	array	数据表
f_name	string	指定列名，字符串

返回：real

示例

t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return medianByColumn(t2, 'c');
// 结果：38

mergeArray(v1, v2, ...)

声明：function

多个数组进行合并

参数	类型	说明
v1	array
v2	array
...

返回：array

示例

t1 := array(('b': 12, 'a': 1, 'c': 13, 'd': 'd'));
t2 := array(('a': 2, 'b': 22, 'c': 23, 'e': 'ee'));
t3 := array(('a': 2, 'b': 22, 'd': 23, 'e': 'ee'));
return mergeArray(t1, t2, t3); // 将数组t1,t2,t3合并

milliSecondSpan()

声明：function

计算两个日期时间之间相差的毫秒数

返回：float

minValueByColumn(t, f_name)

声明：function

求指定中的最小值

参数	类型	说明
t	array	数据表
f_name	string	指定列名

返回：real

示例

t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return minValueByColumn(t2, 'c');
// 结果：13

nonIntersectionPart(t1, t2, key_field)

声明：function

求差集(返回在t1中存在，而在t2中不存在的记录)

参数	类型	说明
t1	array	数据表
t2	array	数据表
key_field	string	指定某一字段

返回：array

示例

t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));
t2 := array(('a': 1, 'b': 1), ('a': 7, 'b': 8), ('a': 5, 'b': 5));
return nonIntersectionPart(t1, t2, 'b');
// 输出：
// array(3,4)

noRecordTable()

声明：function

返回一个空数组

返回：array,tablearray

示例

return noRecordTable();
// 结果：Array()

normalTabletoStrSubscript(t, key_field)

声明：function

索引下标数组-->字符串下标数组。将keyfield列的值变为行标

参数	类型	说明
t	array	数据表类型
key_field	string	字符串，列名

返回：any

示例

s := nDay(10, 'time', dateToStr(sp_time()), 'close', close());
return normalTabletoStrSubscript(s, 'time');
// 把 time列的数据变为行标
---变为--》

outPutTableToCanBeUnderstood(t)

声明：function

判断一个数据表是否是空值，如果是则返回'返回结果为空'，否则返回该数组

参数	类型	说明
t	array	数组，数据表。

返回：string|array

示例

return outPutTableToCanBeUnderstood(array(1, 2, 3));
// 返回:

parseRegExpr3(s, reg_from_text, to_text, parse_ctrls)

声明：function

直接返回输出的正则表达式解析

参数	类型	说明
s	string	字符串。源串
reg_from_text	string	字符串。待替换的部分，正则表达式
to_text	string	字符串。替换的字符串
parse_ctrls	string	字符串。正则表达式控制串

返回：string

示例

return parseRegExpr3("abcdeak", "ab", "kkkk", "ir");
// 结果：kkkkcdeak

passwordGen(len, n, head, start)

声明：function

密码生成器

参数	类型	说明
len	integer	整数，密码长度
n	integer	整数，生成的密码组合数
head	string	字符串，用户名的前缀
start	integer	整数，用户名的后缀序列数字的起始数字

返回：array

示例

return rdo2 passwordGen(8, 5, 'ts', 3);
// 返回:

percentValueByField(t, key_field, quart)

声明：function

数据集在指定百分位数上对应的数值

参数	类型	说明
t	array	数据表
key_field	string	指定列名，字符串
quart	real	指定分位数，实数

返回：real

示例

t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return percentValueByField(t2, 'c', 0.1);
// 结果：19

pivot(t, index, columns, vals)

声明：function

透视，数据透视表

参数	类型	说明
t	array	二维数组，待透视表，t[:,array(index,columns)] 不能包含重复的行，即index，columns 必须可以作为t的唯一主键
index	string | array	字符串或一维字符串数组，行分类字段，t的列名，多个字段可以用数组，为nil表示取t的行下标
columns	string | array	字符串或一维字符串数组，列分类字段，t的列名；结果列名形如 值字段@列分类值
vals	string | array	字符串或一维字符串数组，值字段，t的列名，多个字段可以用数组

返回：array

示例

// 行标为日期、列标为名称，值为收盘价和涨幅的数据透视表
t := array(
    ("日期":"2021-05-17","名称":"平安银行","收盘价":22.5,"涨幅":1.2),
    ("日期":"2021-05-17","名称":"万科A","收盘价":30.1,"涨幅":-0.8),
    ("日期":"2021-05-18","名称":"平安银行","收盘价":22.9,"涨幅":1.8),
    ("日期":"2021-05-18","名称":"万科A","收盘价":29.7,"涨幅":-1.3));
return pivot(t, "日期", "名称", array("收盘价", "涨幅"));
// 输出：
// array("2021-05-17":
// ("收盘价@万科A":30.1,"收盘价@平安银行":22.5,"涨幅@万科A":-0.8,"涨幅@平安银行":1.2),"2021-05-18":
// ("收盘价@万科A":29.7,"收盘价@平安银行":22.9,"涨幅@万科A":-1.3,"涨幅@平安银行":1.8))

Pivot_table(t, index, columns, vals, aggfunc, aggfuncnames)

声明：function

分组、透视、汇总 1、vals 未指定时，代表对所有除index、columns 指定字段之外的所有字段计算 2、aggfunc 不同含义及设定方法： a、所有字段，统一函数 aggfunc := "avg" 注：代表对vals中所有字段进行计算 b、所有字段，多个函数 aggfunc := array("avg","max"); c、指定字段，指定函数 aggfunc := array("fielda":"avg","filedb":("avg","max")); 注：指定字段时，必须是vals的子集，否则报错。 3、支持匿名函数、与函数指针，其中: a、匿名函数默认命名为"匿名" b、函数指针通过functioninfo得到函数名称 4、aggfunc中支持 a、所有 TS_SQL 聚合函数：e.g:"avg"(avgof),"sum"(sumof) b、内置函数： "_details": 分组详情 "_first": 第一个 "_last": 最后一个 c、自定义函数中使用关键字thisgroup 得到当前分组数据。 5、index/columns中字段值含有nill等不可设为索引。 6、aggfuncnames：给aggfunc定义名称

参数	类型	说明
t	array	数据表
index	string|array	行分类字段
columns	string|array	列分类字段
vals	string|array	值字段
aggfunc	string|array|function	汇总函数
aggfuncnames	array	自定义汇总函数名称对照表

返回：array

示例

data := array(
    ("group": "A", "date": "2025-01-01", "value": 1),
    ("group": "A", "date": "2025-01-02", "value": 2),
    ("group": "B", "date": "2025-01-01", "value": 3)
);
echo trim(toStn(Pivot_table(
    data,
    "group",
    "date",
    "value",
    "sum",
    nil
)));

QKsplit_Resampling(begt, endt, cy, if_name)

声明：function

区间自然日按指定周期重采样分割

参数	类型	说明
begt	datetime	日期时间，开始日
endt	datetime	日期时间，截止日
cy	string	字符串，采样周期，默认为cy_Day()，可以取日线、周线、月线、季线、半年线、年线
if_name	string	object

返回：array

示例

echo trim(toStn(QKsplit_Resampling(20100101T, 20110101T, cy_year(), "")));

QKsplit_ToDate(endt, _type)

声明：function

当前周期分割区间

参数	类型	说明
endt	datetime	日期时间，截止日
_type	any	整型，为以下数值的组合(以下数值的_XOR或者相加)，默认值为31(1+2+4+8+16)

返回：array

示例

echo trim(toStn(QKsplit_ToDate(20220704T, 31)));

QKsplit_Trailing(begt, endt, inc_weeks, inc_months, inc_years, other_type)

声明：function

时间区间尾随分割

参数	类型	说明
begt	datetime	日期时间，开始日
endt	datetime	日期时间，截止日
inc_weeks	any	数字/数组，周推移，取值如下
inc_months	any	数字/数组，月推移，同inc_weeks
inc_years	any	数字/数组，年推移，同inc_weeks
other_type	any	整型，为以下数值的组合(以下数值的_XOR或者相加)，默认2

返回：array

示例

echo trim(toStn(QKsplit_Trailing(20100101T, 20110101T, nil, nil, nil, 2)));

quickIntersectionPart(v, w)

声明：function

快速求交集

参数	类型	说明
v	array	数组
w	array	数组

返回：array

示例

t1 := array(1.00, 3.00, 2.00, 9.00, 8.00);
t2 := array(3.00, 0.00, 7.00, 8.00, 1.00, 5.00);
return intersectionPart(t1, t2);

quickRecordExist(v, x)

声明：function

记录是否存在(原数组若为纯字符串数组则必须为有序列)，返回记录所在行的序号，序号是从0开始原数组必须为有序表

参数	类型	说明
v	array	一维数组
x	string	字符串/数字

返回：integer

示例

t := array('a', 'c', 'd');
return quickRecordExist(t, 'd');
// 结果：2

randomchoice(avalues, size, replace)

声明：function

随机抽样

参数	类型	说明
avalues	array of string	Array of string,一维字符串数组，或正整数
size	integer	Integer,
replace	bool	Bool,是否可放回,默认为真可放回

返回：any

示例

// 从字符串数组中有放回随机抽取 3 个
return randomchoice(array("A", "B", "C", "D", "E"), 3, true);
// 输出：长度为 3 的随机子集，如 array("B","A","C")；因随机抽样每次运行结果不同。
// 若 avalues 传正整数 n，则从 0..n-1 中抽样，返回浮点下标数组。

rankIt(t, f_n, sort_order)

声明：function

按指定字段的值排名；SortOrder：0 降序排名；SortOrder：1升序排名

参数	类型	说明
t	array	数据表
f_n	string	字段名
sort_order	integer	排名方向，0 降序排名, 1升序排名

返回：array

示例

t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33));
rankIt(t2, 'c', 1);
return t2;
// 输出：
// array(
// ("a":2,"c":13,"c排名":1),
// ("a":3,"c":33,"c排名":2))

rankIt2(t, f_n, of_n, sort_order)

声明：function

按指定字段的值排名，SortOrder:0 降序排名；SortOrder:1 升序排名，排名列的字段为：OfN

参数	类型	说明
t	array	数据表
f_n	string	指定字段，字符串
of_n	string	排名列字段名，字符串
sort_order	integer	排名方向:0 降序排名，1 升序排名

返回：array

示例

t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33));
rankIt2(t2, 'c', '名次', 1);
return t2;
// 输出：
// array(
// ("a":2,"c":13,"名次":1),
// ("a":3,"c":33,"名次":2))

rankValue(t, fields)

声明：function

按照指定字段求Rank,返回的数据，保存在传递过来的数据t中。返回按Fields列排序的结果

参数	类型	说明
t	array	数据表类型，数据表
fields	string	字符串，排序的列

返回：any

示例

// 对涨幅列进行排名，结果新增“涨幅(%)排名”列，并按排名升序重排
data := array(
    ("代码":"SH600000","名称":"浦发银行","收盘":10.77,"涨幅(%)":0.37),
    ("代码":"SH600016","名称":"民生银行","收盘":5.94,"涨幅(%)":-0.17),
    ("代码":"SH600028","名称":"中国石化","收盘":5.74,"涨幅(%)":0.17),
    ("代码":"SH600030","名称":"中信证券","收盘":18.58,"涨幅(%)":1.75),
    ("代码":"SH600036","名称":"招商银行","收盘":29.3,"涨幅(%)":0.31),
    ("代码":"SH600050","名称":"中国联通","收盘":5.36,"涨幅(%)":0.94));
rankValue(data, '涨幅(%)');
return data;
// 输出：
// array(
// ("代码":"SH600030","名称":"中信证券","收盘":18.58,"涨幅(%)":1.75,"涨幅(%)排名":1),
// ("代码":"SH600050","名称":"中国联通","收盘":5.36,"涨幅(%)":0.94,"涨幅(%)排名":2),
// ("代码":"SH600000","名称":"浦发银行","收盘":10.77,"涨幅(%)":0.37,"涨幅(%)排名":3),
// ("代码":"SH600036","名称":"招商银行","收盘":29.3,"涨幅(%)":0.31,"涨幅(%)排名":4),
// ("代码":"SH600028","名称":"中国石化","收盘":5.74,"涨幅(%)":0.17,"涨幅(%)排名":5),
// ("代码":"SH600016","名称":"民生银行","收盘":5.94,"涨幅(%)":-0.17,"涨幅(%)排名":6))

rDateStrToArr(rdate_list)

声明：function

把报告期字符串转换为列表

参数	类型	说明
rdate_list	string	字符串，报告期字符串，多个报告期以分号区分

返回：array

示例

return rDateStrToArr('20070331;20070630');

readFile(filename, arg2, arg3, arg4, size, data)

声明：function

读取本地文件中的数据

参数	类型	说明
filename	int
arg2	string
arg3	int
arg4	int
size	string
data	int

返回：bool

recodeSecond(a_value, a_second)

声明：function

将参数ASecond指定的秒数（0至59）替换掉参数AValue中的相应的秒数信息，得到的日期时间类型返回

参数	类型	说明
a_value	datetime	日期时间类型
a_second	int	整数，秒数，定义域[0，59]

返回：datetime

recordExist(t, v)

声明：function

数值是否在数组中存在（一维数组），如果存在，则返回索引号；(索引号从0开始)不存在，返回－1

参数	类型	说明
t	array	指定一维数组
v	string	要查询的数值，与t单元值类型一致

返回：integer

示例

t := array(1, 2, 12, 3, 14);
return recordExist(t, 12);
// 结果：2

recordExist2(t, f_name, v)

声明：function

记录数据表（二维数组）中是否存在列名为fName，值为V的记录；如果存在，则返回行标索引号(索引号从0开始)，不存在，返回－1

参数	类型	说明
t	array	指定数组，二维数组
f_name	string	指定列名，字符串
v	string	指定值，与t单元值类型一致

返回：integer

示例

t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));
return recordExist2(t1, 'b', 3);
// 结果：2

recordExist3(v, x)

声明：function

记录指定值是否存在一维数组中，如果存在，返回1，不存在，返回0

参数	类型	说明
v	string	指定数组，一维数组
x	integer	指定值，与v单元值类型一致

返回：bool

示例

t := array(1, 2, 12, 3, 14);
return recordExist3(t, 3);
// 结果：1

reIndex(data, index_info1, index_info2, index_info_n)

声明：function

修改数组下标

参数	类型	说明
data	array	需要重构的数组
index_info1	any	Array
index_info2	any	Array
index_info_n	any	Array

返回：array

renameField(t, old_field, new_field)

声明：function

修改指定字段的名称

参数	类型	说明
t	array	指定数组，数据表
old_field	string	原来指定列名，字符串
new_field	string	新列名，字符串

返回：bool

示例

t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 8, 'c': 5));
return renameField(t1, 'a', 'aaa'); // 将t1中的字段’a’改为’aaa’
// 结果：1

renameFieldByFormat(t, ifcopy)

声明：function

通过格式字符串修改列名

参数	类型	说明
t	array	数组类型，数据
ifcopy	bool	布尔类型，是否在拷贝后的数组改列名，默认True

返回：array

示例

// 给随机数组批量加后缀
t := rand(10, 10);
suffix := '%s'$"@A";
ifcopy := true;
return renameFieldByFormat(t, suffix, ifcopy);
// 输出：把 10 列随机表的列名 0,1,…,9 按格式 '%s'$"@A" 批量改为 0@A,1@A,…,9@A。
// 列名重命名固定，但因 t 由 rand 生成，各单元格数值每次运行都不同。

replaceStrByReg(s, reg_from_text, to_text)

声明：function

正则表达式快速字符串替换，大小写敏感

参数	类型	说明
s	string	字符串。源串
reg_from_text	string	字符串。待替换的部分，正则表达式
to_text	string	字符串。替换的字符串

返回：string

示例

return replaceStrByReg("abcdeak", "A", "kkkk");
// 结果：abcdeak

replaceTextByReg(s, reg_from_text, to_text)

声明：function

正则表达式快速字符串替换，大小写不敏感

参数	类型	说明
s	string	字符串。源串
reg_from_text	string	字符串。待替换的部分，正则表达式
to_text	string	字符串。替换的字符串

返回：string

示例

return replaceTextByReg("abcdeak", "a", "kkkk");
// 结果：kkkkbcdekkkkk

reverse(arr)

声明：function

数组倒置反向

参数	类型	说明
arr	array	数组

返回：array

示例

arr := array(
    ("date":"2021-05-26","close":1),
    ("date":"2021-05-27","close":2),
    ("date":"2021-05-28","close":3),
    ("date":"2021-05-31","close":4),
    ("date":"2021-06-01","close":5));
return reverse(arr);
// 输出：
// array(
// ("date":"2021-06-01","close":5),
// ("date":"2021-05-31","close":4),
// ("date":"2021-05-28","close":3),
// ("date":"2021-05-27","close":2),
// ("date":"2021-05-26","close":1))

rightStr(text, num_chars)

声明：function

前N个字符；基于所指定的字符数返回文本字符串中的最后一个或后几个字符

参数	类型	说明
text	string	字符串
num_chars	int	字符个数

返回：string

rotateTable(data)

声明：function

旋转表

参数	类型	说明
data	array	数据表，二维数组

返回：array

示例

t := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 4));
return rotateTable(t);

roundTo5(v)

声明：function

.5处理

参数	类型	说明
v	real	实数

返回：real

示例

return roundTo5(0.35);
// 结果：0.5

rpsIt(t, f_n, sort_order)

声明：function

按指定字段的值排名，获得其排名的百分位，排序百分位放在列 FN+"_RPS"中

参数	类型	说明
t	array	数组，数据表
f_n	string	字符串/数字，字段名
sort_order	integer	排名方向，0 降序排名, 1升序排名

返回：array

示例

r := array(
    ("StockID":"SZ000001","StockName":"平安银行","StockZF":0.28),
    ("StockID":"SZ000002","StockName":"万  科Ａ","StockZF":-0.12),
    ("StockID":"SH600997","StockName":"开滦股份","StockZF":0.66),
    ("StockID":"SZ000009","StockName":"中国宝安","StockZF":2.47),
    ("StockID":"SZ000012","StockName":"南  玻Ａ","StockZF":1.27),
    ("StockID":"SZ000024","StockName":"招商地产","StockZF":0.05));

return rpsIt(r, 'StockZF', 1);
// 输出：
// array(
// ("StockID":"SZ000009","StockName":"中国宝安","StockZF":2.47,"StockZF_RPS":100.0),
// ("StockID":"SZ000012","StockName":"南  玻Ａ","StockZF":1.27,"StockZF_RPS":80.0),
// ("StockID":"SH600997","StockName":"开滦股份","StockZF":0.66,"StockZF_RPS":60.0),
// ("StockID":"SZ000001","StockName":"平安银行","StockZF":0.28,"StockZF_RPS":40.0),
// ("StockID":"SZ000024","StockName":"招商地产","StockZF":0.05,"StockZF_RPS":20.0),
// ("StockID":"SZ000002","StockName":"万  科Ａ","StockZF":-0.12,"StockZF_RPS":0.0))

rpsValue(t, column_name)

声明：function

按照指定字段求RPS

参数	类型	说明
t	array	数据表类型，数据表
column_name	string	字符串，要计算RPS的字段

返回：any

示例

s := array(
    ("代码":"SZ000001","名称":"平安银行","收盘":11.2,"涨幅(%)":0.900900900900892),
    ("代码":"SZ000002","名称":"万  科Ａ","收盘":27.68,"涨幅(%)":-0.25225225225225),
    ("代码":"SH600000","名称":"浦发银行","收盘":10.77,"涨幅(%)":0.372786579683115),
    ("代码":"SH600100","名称":"同方股份","收盘":8.73,"涨幅(%)":1.74825174825175));
rpsValue(s, '涨幅(%)');
return s;
// 返回:
// array(
// ("代码":"SH600100","名称":"同方股份","收盘":8.73,"涨幅(%)":1.74825174825175,"RPS_涨幅(%)":100.0),
// ("代码":"SZ000001","名称":"平安银行","收盘":11.2,"涨幅(%)":0.900900900900892,"RPS_涨幅(%)":66.6666666666667),
// ("代码":"SH600000","名称":"浦发银行","收盘":10.77,"涨幅(%)":0.372786579683115,"RPS_涨幅(%)":33.3333333333333),
// ("代码":"SZ000002","名称":"万  科Ａ","收盘":27.68,"涨幅(%)":-0.25225225225225,"RPS_涨幅(%)":0.0))

searchsorted(v, x)

声明：function

有序列表插入指定值的位置，原数组必须为有序表且元素应可比较

参数	类型	说明
v	array	一维数组 有序数组
x	string | real	插入的值

返回：integer

示例

范例1：数字插入

v := array(1, 2, 3, 4, 5, 6);
return searchsorted(v, 3.5); // 返回：3

范例2：字符串插入

v := array("SH600001", "SH600004", "SH600050", "SH600305");
return searchsorted(v, "SH600049"); // 返回：2

seekPosInArray(r, arr)

声明：function

数字定位，采用二分法寻找数字R在一位正序数字数组arr中的下标

参数	类型	说明
r	real	实数
arr	array	一维数字数组

返回：integer

示例

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

seperateTable(t, sep_field, sep_count)

声明：function

把表格t分割为SepCount个表格

参数	类型	说明
t	array	数据表类型，原始数组
sep_field	string	字符串，排序字段
sep_count	integer	整数，分割数

返回：array

示例

t := `array('a': (1, 2, 3, 4), 'b': (2, 3, 4, 5), 'c': (3, 4, 5, 6), 'd': (4, 5, 6, 7), 'e': (5, 6, 7, 8), 'f': (7, 8, 9, 10));
return seperateTable(t, 'a', 2);
// 返回:
// array(
// (
// ("a":4,"b":5,"c":6,"d":7,"e":8,"f":10),
// ("a":3,"b":4,"c":5,"d":6,"e":7,"f":9)),
// (
// ("a":2,"b":3,"c":4,"d":5,"e":6,"f":8),
// ("a":1,"b":2,"c":3,"d":4,"e":5,"f":7)))

seprateStrToTotal(s)

声明：function

把用;分割的字符串转换为#分割

参数	类型	说明
s	string	字符串

返回：string

示例

return seprateStrToTotal('债券型;现金型;配置型;股票型;保本型');
// 结果：’债券型#现金型#配置型#股票型#保本型’

setLikeFlag(flag, return_value)

声明：function

设置Like操作符号的正则表达式默认控制状态。默认值为1

参数	类型	说明
flag	int	正则表达式控制模式，取值如下： 若同时设置多个模式，则设置参数值为其对应模式值之和即可
return_value	int	匹配成功则返回真，否则返回假

返回：bool

setRowDefaultValue(t, n, value)

声明：function

将数组t的第N行由所有值变更为Value

参数	类型	说明
t	array	数据表类型，数据表
n	integer	整数，行号
value	string	字符串，要设置的值

返回：array

示例

s := array(array(1, 2, 3, 4, 5),
array(2, 3, 4, 5, 6),
array(3, 4, 5, 6));
setRowDefaultValue(s, 2, 'wo');
return s;
// 返回:

sf_Beta(arg1, arg2, v)

声明：function

计算贝塔函数值

参数	类型	说明
arg1	any
arg2	any
v	any

返回：any

sf_betainv(y, arg2, arg3, x)

声明：function

根据累计概率计算贝塔分布的逆函数值

参数	类型	说明
y	array
arg2	any
arg3	any
x	any

返回：any

sf_CosX(arg1, v)

声明：function

计算余弦积分

参数	类型	说明
arg1	any
v	any

返回：any

sf_Error(arg1, v)

声明：function

计算误差函数（概率函数）值

参数	类型	说明
arg1	float
v	any

返回：any

sf_eX(arg1, v)

声明：function

计算指数积分

参数	类型	说明
arg1	any
v	any

返回：any

sf_finv(arg1, arg2, arg3, v)

声明：function

根据累计概率计算 F 分布的逆函数值

参数	类型	说明
arg1	float
arg2	any
arg3	any
v	any

返回：any

sf_Gamma(arg1, v)

声明：function

计算伽马函数值

参数	类型	说明
arg1	any
v	any

返回：any

sf_gammainv(arg1, arg2, v)

声明：function

根据累计概率计算标准 Gamma 分布的逆函数值

参数	类型	说明
arg1	float
arg2	any
v	any

返回：any

sf_Normal(x, a, d, v)

声明：function

计算正态分布函数值

参数	类型	说明
x	any
a	any
d	any
v	any

返回：any

sf_normalinv(arg1, arg2, arg3, v)

声明：function

根据累计概率计算正态分布的逆函数值

参数	类型	说明
arg1	float
arg2	any
arg3	any
v	any

返回：any

sf_normalinv2(arg1, v)

声明：function

根据累计概率计算标准正态分布的逆函数值

参数	类型	说明
arg1	float
v	any

返回：any

sf_SinX(arg1, v)

声明：function

计算正弦积分

参数	类型	说明
arg1	any
v	any

返回：float

sf_tinv(arg1, arg2, v)

声明：function

根据累计概率计算 t 分布的逆函数值

参数	类型	说明
arg1	float
arg2	any
v	any

返回：any

sf_x2inv(arg1, arg2, v)

声明：function

根据累计概率计算卡方分布的逆函数值

参数	类型	说明
arg1	float
arg2	any
v	any

返回：any

show2DTable(t, key_field, obsolete_fields, ntype)

声明：function

特殊函数，平台功能性函数，一般用户不使用。二位表格显示格式转换，其中t为原数据,KeyField为需要转置的字段，ObsoleteFields为需要隐藏的字段，NType决定显示格式

参数	类型	说明
t	array	数据表类型，原数据
key_field	string	字符串，要显示倒置的关键字段
obsolete_fields	string	字符串，不显示的字段(;分割)
ntype	integer	用户自定义，二维表格显示格式

返回：array

示例

// 生成数据表t
t := array(("代码": "SH600006", "名称": "东风汽车", "主营业务收入": 151953.06, "主营业务利润": 30559.66, "营业费用": 10112.75, "管理费用": 10666.36, "财务费用": -894.46, "营业利润": 10693.23, "投资收益": -151.01, "利润总额": 9904.7, "所得税": 2413.81, "净利润": 7873.08, "货币资金": -11664.28, "短期投资": -5370.7, "主营业务收入": 167855.56, "主营业务利润": 31127.95, "营业费用": 4452.79, "管理费用": 10541.15, "财务费用": -1013.26, "营业利润": 17162.48, "投资收益": 150.81, "利润总额": 17246.26, "所得税": 2629.5, "净利润": 14574.03, "货币资金": 532.5, "短期投资": 4962.47), ("代码": "SH600007", "名称": "中国国贸", "主营业务收入": 19715.3, "主营业务利润": 10383.2, "营业费用": 238.4, "管理费用": 1422.7, "财务费用": 1304.4, "营业利润": 7417.7, "投资收益": 81.1, "利润总额": 6404.6, "所得税": 2433.4, "净利润": 3971.2, "货币资金": 2964.5, "短期投资": 0.00, "主营业务收入": 17727.7, "主营业务利润": 9989.1, "营业费用": 165.5, "管理费用": 1151.3, "财务费用": -18.2, "营业利润": 8690.5, "投资收益": 186.2, "利润总额": 9208.6, "所得税": 2977.1, "净利润": 6231.5, "货币资金": -8101.2, "短期投资": 0.00));
return show2DTable(t, '名称', '代码', 2);
// 返回:

show3DTable(t, key_field, obsolete_fields, ntype)

声明：function

特殊函数，平台功能性函数，一般用户不使用。用于三维表格显示格式转换，其中t为原数据,KeyField为需要转置的字段，ObsoleteFields为需要隐藏的字段，NType决定显示格式

参数	类型	说明
t	array	数据表类型，原数据
key_field	string	字符串，要显示倒置的关键字段
obsolete_fields	string	字符串，不显示的字段(;分割)
ntype	integer	用户自定义，三维表格显示格式

返回：array

示例

// 生成数据表t
t := array(("代码": "SH600006", "名称": "东风汽车", "2004.10-12@主营业务收入": 151953.06, "2004.10-12@主营业务利润": 30559.66, "2004.10-12@营业费用": 10112.75, "2004.10-12@管理费用": 10666.36, "2004.10-12@财务费用": -894.46, "2004.10-12@营业利润": 10693.23, "2004.10-12@投资收益": -151.01, "2004.10-12@利润总额": 9904.7, "2004.10-12@所得税": 2413.81, "2004.10-12@净利润": 7873.08, "2004.10-12@货币资金": -11664.28, "2004.10-12@短期投资": -5370.7, "2004.7-9@主营业务收入": 167855.56, "2004.7-9@主营业务利润": 31127.95, "2004.7-9@营业费用": 4452.79, "2004.7-9@管理费用": 10541.15, "2004.7-9@财务费用": -1013.26, "2004.7-9@营业利润": 17162.48, "2004.7-9@投资收益": 150.81, "2004.7-9@利润总额": 17246.26, "2004.7-9@所得税": 2629.5, "2004.7-9@净利润": 14574.03, "2004.7-9@货币资金": 532.5, "2004.7-9@短期投资": 4962.47), ("代码": "SH600007", "名称": "中国国贸", "2004.10-12@主营业务收入": 19715.3, "2004.10-12@主营业务利润": 10383.2, "2004.10-12@营业费用": 238.4, "2004.10-12@管理费用": 1422.7, "2004.10-12@财务费用": 1304.4, "2004.10-12@营业利润": 7417.7, "2004.10-12@投资收益": 81.1, "2004.10-12@利润总额": 6404.6, "2004.10-12@所得税": 2433.4, "2004.10-12@净利润": 3971.2, "2004.10-12@货币资金": 2964.5, "2004.10-12@短期投资": 0.00, "2004.7-9@主营业务收入": 17727.7, "2004.7-9@主营业务利润": 9989.1, "2004.7-9@营业费用": 165.5, "2004.7-9@管理费用": 1151.3, "2004.7-9@财务费用": -18.2, "2004.7-9@营业利润": 8690.5, "2004.7-9@投资收益": 186.2, "2004.7-9@利润总额": 9208.6, "2004.7-9@所得税": 2977.1, "2004.7-9@净利润": 6231.5, "2004.7-9@货币资金": -8101.2, "2004.7-9@短期投资": 0.00), ("代码": "SH600004", "名称": "白云机场", "2004.7-9@主营业务收入": 37934.65, "2004.7-9@主营业务利润": 15725.54, "2004.7-9@营业费用": 2623.82, "2004.7-9@管理费用": 4662.1, "2004.7-9@财务费用": 1789.5, "2004.7-9@营业利润": 6650.11, "2004.7-9@投资收益": -15.38, "2004.7-9@利润总额": 6685.16, "2004.7-9@所得税": 2350.15, "2004.7-9@净利润": 4000.51, "2004.7-9@货币资金": -5054.06, "2004.7-9@短期投资": 101.00));
return show3DTable(t, '名称', '代码', 3);
// 返回:

showTableByField(t, field_arr)

声明：function

显示数据表t的部分字段数据，字段在FieldArr的数组里

参数	类型	说明
t	array	数据表类型，数据
field_arr	array	一维数组，要显示的字段

返回：array

示例

arr := array((1, 2, 3, 4, 5), (2, 3, 4, 5, 6), (3, 4, 5, 6, 7), (4, 5, 6, 7, 8));
return showTableByField(arr, array(1, 2, 3));
// 返回:

showTableByInverse(t, key_field, field_arr, show_number)

声明：function

数据表t转置，其中KeyField为列名，该列的数据转置后作为列标名，FieldARR为需要显示的字段，ShowNumber表示显示原数据keyfield行(转置后列)的数量

参数	类型	说明
t	array	数据表类型，数据
key_field	string	字符串，转置后用作列标的值的列名
field_arr	array	数组，要显示的字段列表，给非数组则显示所有字段。
show_number	integer	整数，显示个数

返回：array

示例

// 生成数据表t
t := array(("代码": "SH600006", "名称": "东风汽车", "主营业务收入": 151953.06, "主营业务利润": 30559.66, "营业费用": 10112.75, "管理费用": 10666.36, "财务费用": -894.46, "营业利润": 10693.23, "投资收益": -151.01, "利润总额": 9904.7, "所得税": 2413.81, "净利润": 7873.08, "货币资金": -11664.28, "短期投资": -5370.7, "主营业务收入": 167855.56, "主营业务利润": 31127.95, "营业费用": 4452.79, "管理费用": 10541.15, "财务费用": -1013.26, "营业利润": 17162.48, "投资收益": 150.81, "利润总额": 17246.26, "所得税": 2629.5, "净利润": 14574.03, "货币资金": 532.5, "短期投资": 4962.47), ("代码": "SH600007", "名称": "中国国贸", "主营业务收入": 19715.3, "主营业务利润": 10383.2, "营业费用": 238.4, "管理费用": 1422.7, "财务费用": 1304.4, "营业利润": 7417.7, "投资收益": 81.1, "利润总额": 6404.6, "所得税": 2433.4, "净利润": 3971.2, "货币资金": 2964.5, "短期投资": 0.00, "主营业务收入": 17727.7, "主营业务利润": 9989.1, "营业费用": 165.5, "管理费用": 1151.3, "财务费用": -18.2, "营业利润": 8690.5, "投资收益": 186.2, "利润总额": 9208.6, "所得税": 2977.1, "净利润": 6231.5, "货币资金": -8101.2, "短期投资": 0.00));
return showTableByInverse(t, '代码', '', 2);
// 返回:

ShowTableByUnit(t, field_arr)

声明：function

显示t部分字段(带显示单位变换)。其中FieldArr为二维数组，FieldArr的第0列为显示的字段名称，第1列为显示的字段对应的数据列名称，第2列为显示的字段的数据类型，第3列为显示的字段的单位(只对Real类型有意义)

参数	类型	说明
t	array	数据表类型，要显示的数据
field_arr	array	二位字符串数组，要显示的字段

返回：Array，数组。

示例

data := array("a": (1, 2), "b": (3, 4));
fields := array(("field_a", "a", "", ""));
echo trim(toStn(ShowTableByUnit(data, fields)));

simpledescribe(data)

声明：function

简单描述统计

参数	类型	说明
data	array of number	一维数字数组，或 二维矩阵，二维矩阵时，对每列进行操作

返回：array

示例

data := array(
    ("H": 10, "W": 2, "L": 4),
    ("H": 20, "W": 4, "L": 8),
    ("H": 30, "W": 6, "L": 12));
return simpledescribe(data);
// 输出：
// array("个数":
// ("H":3,"W":3,"L":3),"最小值":
// ("H":10.0,"W":2.0,"L":4.0),"25%":
// ("H":15.0,"W":3.0,"L":6.0),"50%":
// ("H":20.0,"W":4.0,"L":8.0),"75%":
// ("H":25.0,"W":5.0,"L":10.0),"最大值":
// ("H":30.0,"W":6.0,"L":12.0),"平均值":
// ("H":20.0,"W":4.0,"L":8.0),"标准差":
// ("H":10.0,"W":2.0,"L":4.0))

simpleRoundTo2(avalue, adigit)

声明：function

四舍五入（交易所规则），正负数不对称，即四舍六入，五向较大的数进位(正负有别,如保留一位小数时+0.05)

参数	类型	说明
avalue	Real	实数数据
adigit	Integer	精确到Adigit位

返回：Real

示例

范例01：
return simpleRoundTo2(1234.56789654,-2);
//结果：1234.57
范例02：
return simpleRoundTo2(-1234.5658965,-2);
//结果：-1234.56

skewByColumn(t, f_name)

声明：function

指定列的偏度

参数	类型	说明
t	array	数据表
f_name	string	指定列名，字符串

返回：real

示例

t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return skewByColumn(t2, 'c');
// 结果：-0.75

sortTableByFieldExt(t, sort_field)

声明：function

将数组t依据字段SortField排序。把大于0的按照从小到大排序，把小于0的按照绝对值从小到大排序，然后，把两个结果合并

参数	类型	说明
t	array	数据表类型，数组
sort_field	string	字符串,排序字段

返回：any

示例

s := `array('a': (1, 2, 3, 4, 5), 'b': (-2, -3, -4, 5, 6), 'c': (3, 4, 5, 6, 7), 'd': (4, 5, 6, 7, 8));
return sortTableByFieldExt(s, 'b');
// 返回:

spaceByNumber(n)

声明：function

生成N个空格字符串

参数	类型	说明
n	integer	整数

返回：string

示例

return write('---', spaceByNumber(2), '---');
// 运行信息打印结果：

sparse1(s, a, m, n)

声明：function

挤出任何非零元素，将满矩阵转化为稀疏格式，与Sparsefull函数对应

参数	类型	说明
s	array of real	待转化的m*n满矩阵
a	array of real	变参返回矩阵S的稀疏格式，二维数组
m	integer	变参返回矩阵S的行数，整数
n	integer	变参返回矩阵S的列数，整数

返回：array

示例

// 将矩阵S由满矩阵格式转化为稀疏格式
s := array((0, 0, 4, 0, 0),
(0, 1, 0, 0, 0),
(0, 0, 0, 0, 0),
(3, 0, 0, 0, 0),
(0, 0, 0, 0, 5));
return sparse1(s);
// 输出：
// array(0:
// (2:4),1:
// (1:1),3:
// (3),4:
// (4:5))

sparse2(i, j, v, m, n)

声明：function

根据i、j和v三元组生成m*n稀疏格式矩阵S

参数	类型	说明
i	array of real	存放矩阵行标的一元数组
j	array of real	存放矩阵列标的一元数组
v	array of real	存放矩阵元素值的一元数组
m	integer	矩阵的行数，整数
n	integer	矩阵的列数，整数

返回：array

示例

// 根据i,j,v三元组生成稀疏格式矩阵
i := array(0, 1, 2, 3);
j := array(3, 1, 4, 2);
v := array(5, 3, 2, 4);
return sparse2(i, j, v, 5, 5);
// 输出：
// array(
// (3:5),
// (1:3),
// (4:2),
// (2:4))

sparsefull(s, m, n)

声明：function

将稀疏矩阵格式转化为满矩阵，与Sparse1函数相对应

参数	类型	说明
s	array of real	稀疏格式矩阵
m	integer	转化为满矩阵的行数，整数
n	integer	转化为满矩阵的列数，整数

返回：array

示例

// 将S由稀疏格式矩阵转化为5*5满矩阵格式
s := array(0: (0: 1), 2: (2: 3), 3: (3: 4));
return sparsefull(s, 5, 5);
// 输出：
// array(
// (1,0,0,0,0),
// (0,0,0,0,0),
// (0,0,3,0,0),
// (0,0,0,4,0),
// (0,0,0,0,0))

sparseMatFill(a, fillv)

声明：function

稀疏数据表填充，直接在A矩阵上更改

参数	类型	说明
a	array,tablearray	数据表类型，稀疏矩阵
fillv	real	实数，给定的填充值

返回：array,tablearray

示例

a := array((3: 4), ('A': 2));
sparseMatFill(a, -1);
return a; // array((3:4,"A":-1),(3:-1,"A":2))

spdiags1(a)

声明：function

提取矩阵非零对角线

参数	类型	说明
a	array	Array,二维数组，原（稀疏）矩阵

返回：array

示例

// 提取矩阵A中非零对角线
a := array((6, 0, 13, 0, 0),
(0, 7, 0, 14, 0),
(1, 0, 8, 0, 15),
(0, 2, 0, 9, 0),
(0, 0, 3, 0, 10));
return spdiags1(a);

spdiags2(a, d)

声明：function

提取矩阵指定对角线

参数	类型	说明
a	array	Array,二维数组，原（稀疏）矩阵
d	array	Array,一维数组，对角线序列；也可以为数字；

返回：array

示例

// 提取矩阵A中第-2,0,2条对角线，按列排列
a := array((6, 0, 13, 0, 0),
(0, 7, 0, 14, 0),
(1, 0, 8, 0, 15),
(0, 2, 0, 9, 0),
(0, 0, 3, 0, 10));
d := array(-2, 0, 2);
return spdiags2(a, d);

spdiags3(b, d, a)

声明：function

根据指定列替换稀疏矩阵对角线

参数	类型	说明
b	array	Array,二维数组，对角矩阵
d	array	Array,一维数组，对角线序列
a	array	Array,二维数组，原（稀疏）矩阵

返回：array

示例

// 将矩阵A中d指定的对角线替换为B中的列
b := array((5, 10, 15),
(4, 9, 14),
(3, 8, 13),
(2, 7, 12),
(1, 6, 11));
d := array(-2, 0, 2);
a := array((6, 0, 13, 0, 0),
(0, 7, 0, 14, 0),
(1, 0, 8, 0, 15),
(0, 2, 0, 9, 0),
(0, 0, 3, 0, 10));
return spdiags3(b, d, a);

spdiags4(b, d, m, n)

声明：function

根据指定列创建稀疏矩阵

参数	类型	说明
b	array	Array,二维数组，对角矩阵
d	array	Array,一维数组，对角线序列
m	integer	Integer,正整数，（稀疏）矩阵的行
n	integer	Integer,正整数，（稀疏）矩阵的列

返回：array

示例

// 根据对角矩阵B创建稀疏带状矩阵
b := array((5, 10, 15),
(4, 9, 14),
(3, 8, 13),
(2, 7, 12),
(1, 6, 11));
d := array(-2, 0, 2);
m := 5;
n := 5;
return spdiags4(b, d, m, n);

speye(m)

声明：function

创建m*m稀疏单位矩阵，指定为方阵

参数	类型	说明
m	integer	稀疏单位矩阵的尺寸，整数

返回：array

示例

// 创建m*m稀疏单位矩阵
a := speye(4);
return a;
// 输出：
// array(
// (1),
// (1:1),
// (2:1),
// (3:1))

spnnz(s)

声明：function

稀疏矩阵S中的非零元素数目

参数	类型	说明
s	array of real	稀疏矩阵

返回：integer

示例

// 稀疏正态随机矩阵A中非零元素数目
a := sprandn2(5, 5, 0.2);
return spnnz(a); // 返回4（随机）

spnonzeros(s)

声明：function

提取稀疏矩阵S中的非零元素

参数	类型	说明
s	array of real	稀疏矩阵

返回：array

示例

// 提取稀疏正态随机矩阵A中非零元素
a := sprandn2(5, 5, 0.2);
return spnonzeros(a);
// 输出：一维数组，按顺序列出稀疏矩阵 a 中所有非零元素的值。
// 因 a 由 sprandn2 生成，非零元素个数与数值每次运行都不同。

spones(s, n)

声明：function

将稀疏矩阵S中的非零元素替换为n

参数	类型	说明
s	array of real	稀疏矩阵
n	real	非零元素被替换的值，实数

返回：array

示例

// 将S中非零元素替换为1
s := array(0: (0: 1), 2: (2: 3), 3: (3: 4));
return spones(s, 1);
// 输出：
// array(0:
// (1),2:
// (2:1),3:
// (3:1))

sprand1(s)

声明：function

创建与矩阵S结构相同的稀疏格式矩阵，并将其中的非零元素替换为均匀分布随机数

参数	类型	说明
s	array of real	稀疏矩阵

返回：array

示例

// 创建与矩阵S相同结构的稀疏均匀随机矩阵
s := array((0, 0, 3, 0, 0),
(0, 0, 0, 0, 0),
(0, 0, 0, 5, 0),
(0, 2, 0, 0, 0),
(0, 0, 0, 0, 4));
return sprand1(s);
// 输出：与 S 结构相同(非零位置一致)的稀疏矩阵，非零元素替换为 (0,1) 均匀随机数。
// 非零位置固定，但随机值每次运行都不同。

sprand2(m, n, pct)

声明：function

创建m*n稀疏均匀随机矩阵，其中非零元素所占比例为pct

参数	类型	说明
m	integer	矩阵的行数，整数
n	integer	矩阵的列数，整数
pct	real	矩阵中非零元素所占比例，实数

返回：array

示例

// 创建10*10稀疏均匀随机矩阵
a := sprand2(10, 10, 0.3);
return a;
// 输出：10*10 稀疏矩阵，约 30% 位置非零，非零元素为 (0,1) 均匀随机数。
// 非零位置与数值每次运行都不同。

sprandn1(s)

声明：function

创建与矩阵S结构相同的稀疏格式矩阵，并将其中的非零元素替换为正态分布随机数

参数	类型	说明
s	array of real	稀疏矩阵

返回：array

示例

// 创建与矩阵S相同结构的稀疏正态随机矩阵
s := array((0, 0, 0, 0, 0),
(0, 0, 0, 5, 0),
(3, 0, 0, 0, 0),
(0, 0, 2, 0, 0),
(0, 0, 0, 0, 4));
return sprandn1(s);
// 输出：与 S 结构相同(非零位置一致)的稀疏矩阵，非零元素替换为标准正态随机数。
// 非零位置固定，但随机值每次运行都不同。

sprandn2(m, n, pct)

声明：function

创建m*n稀疏正态随机矩阵，其中非零元素所占比例为pct

参数	类型	说明
m	integer	矩阵的行数，整数
n	integer	矩阵的列数，整数
pct	real	矩阵中非零元素所占比例，实数

返回：array

示例

// 创建10*10稀疏正态随机矩阵
a := sprandn2(10, 10, 0.2);
return a;
// 输出：10*10 稀疏矩阵，约 20% 位置非零，非零元素为标准正态随机数。
// 非零位置与数值每次运行都不同。

sprandsym1(s)

声明：function

创建与矩阵S结构相同的稀疏格式矩阵，以下三角矩阵为基准的对称正态分布随机矩阵

参数	类型	说明
s	array of real	稀疏矩阵

返回：array

示例

// 创建与矩阵S相同结构的对称稀疏正态随机矩阵
s := array((6, 1, 0, 14, 0),
(0, 7, 0, 0, 15),
(1, 0, 8, 0, 0),
(0, 2, 0, 9, 0),
(0, 0, 3, 0, 10));
return sprandsym1(s);
// 输出：与 S 相同结构的对称稀疏矩阵，非零元素为正态随机数且关于主对角线对称。
// 非零位置固定，但随机值每次运行都不同。

sprandsym2(n, pct)

声明：function

创建n*n稀疏正态随机矩阵，以下三角矩阵为基准对称正态分布随机矩阵，其中非零元素所占比例大约为pct

参数	类型	说明
n	integer	方阵的尺寸，整数
pct	real	方阵中非零元素所占比例，实数

返回：array

示例

// 创建10*10对称稀疏正态随机矩阵
a := sprandsym2(10, 0.2);
return a;
// 输出：10*10 对称稀疏矩阵，约 20% 位置非零，以下三角为基准对称，非零元素为正态随机数。
// 非零位置与数值每次运行都不同。

startOfTheHalfYear(end_t)

声明：function

返回Endt所在半年的开始日期（半年的第一天）

参数	类型	说明
end_t	tdatetime	日期

返回：tdatetime

示例

end_t := 40599; // 40559表示2011年1月16号
return startOfTheHalfYear(end_t);
// 结果：40544  //40544表示2011年1月1号

startOfTheQuarter(end_t)

声明：function

返回Endt所在季度的开始日期（季度的第一天）

参数	类型	说明
end_t	tdatetime	日期

返回：tdatetime

示例

end_t := 40540; // 40540表示2010年12月28日
return startOfTheQuarter (end_t);
// 结果：40452  //40452表示2010年10月1号

statByColumn(t, fname, _type)

声明：function

依据Type传递的字符串，返回字段Fname序列的type值

参数	类型	说明
t	array	数据表类型，数据
fname	string	字符串，字段名称
_type	string	字符串，返回类型

返回：any

示例

s := `array('a': (1, 2, 3, 4, 5), 'b': (-2, -3, -4, 5, 6), 'c': (3, 4, 5, 6, 7), 'd': (4, 5, 6, 7, 8));
return statByColumn(s, 'a', 'MAX');
// 返回a列最大值:5

stdevByColumn(t, f_name)

声明：function

指定列的标准差

参数	类型	说明
t	array	数据表
f_name	string	指定列名，字符串

返回：real

示例

t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return stdevByColumn(t2, 'c');
// 结果：17.08

stm(v)

声明：function

把STM流转换为任意类型

参数	类型	说明
v	binary	二进制类型，STM流

返回：any

stockAmount(t, date, yes_value, change_field, item)

声明：function

在有序数据表 t 中，按 change_field 列定位最后一个不晚于 Date 的行（即 change_field <= Date 的最近一行），返回其 item 列的值；yes_value 决定取该行本身还是其前一行

参数	类型	说明
t	array	数据表类型，按 change_field 升序排列的数据表
date	integer	实数或日期，用于与 change_field 列比较的基准值
yes_value	integer	布尔值。0：返回命中行（Date 当期）；非 0：返回命中行的前一行
change_field	string	与 Date 比较的列名
item	string	返回值所在的列名

返回：any。命中行（或其前一行）中 item 列的值；若表中不存在不晚于 Date 的行，返回 0。

示例

t := array(
    ("变动日": 20110630, "收盘价": 90),
    ("变动日": 20120630, "收盘价": 60),
    ("变动日": 20130530, "收盘价": 33),
    ("变动日": 20110630, "收盘价": 90),
    ("变动日": 20130630, "收盘价": 30),
    ("变动日": 20140630, "收盘价": 20));
r1 := stockAmount(t, 20130630, 0, '变动日', '收盘价'); // Date当期
r2 := stockAmount(t, 20130630, 1, '变动日', '收盘价'); // 命中行的前一行
return array(r1, r2);
// 输出：array(30,90)

strSubscriptTableToNormal(t, fn)

声明：function

字符串下标数组-->索引下标数组

参数	类型	说明
t	array	二维数组，数据
fn	string	字符串或数值，行标变成数据之后使用的列名

返回：array

示例

data := array("a": (1, 2), "b": (3, 4));
echo trim(toStn(strSubscriptTableToNormal(data, "source_index")));

strToDateExt(s, str_format)

声明：function

将字符串类型的日期按照不同的格式转换成实数型的日期

参数	类型	说明
s	string	字符串类型的日期，包含3中形式，见下表。
str_format	integer	标准化的日期格式，对应的S分别用0、1、2表示

返回：tdatetime

示例

s := '16/1/2011';
str_format := 0;
return strToDateExt(s, str_format);
// 结果：40559

strtodatetime2(s)

声明：function

字符串->日期时间(包含毫秒)

参数	类型	说明
s	string	S的格式必须为：yyyy-m-d h:m:s:z    其中日期和时间需要用空格隔开，时间分隔必须用:    如"2021-8-12 10:31:24:199"

返回：tdatetime

示例

// 字符串2021-8-12 10:31:24:199 转换为日期时间格式(包含毫秒)
s := "2021-8-12 10:31:24:199";
return strtodatetime2(s); // 结果：44420.4384745255

sumValueByColumn(t, f_name)

声明：function

指定列中所有实数的和

参数	类型	说明
t	array	数据表
f_name	string	指定字段

返回：real

示例

t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 8, 'c': 5));
return sumValueByColumn(t1, 'b');
// 结果：12

sumValueByColumn2(tb, column_name, from_row, to_row)

声明：function

求指定列中指定多行的和

参数	类型	说明
tb	array	数据表
column_name	string	指定字段
from_row	integer	指定计算起始行索引号（从0开始）
to_row	integer	指定计算结束行索引号（从0开始）

返回：real

示例

t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return sumValueByColumn2(t2, 'c', 1, 2);
// 结果：76

sumValueByRow(tb, row_index)

声明：function

求指定行的和

参数	类型	说明
tb	array	数据表
row_index	integer	指定计算行索引号（从0开始）

返回：real

示例

t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return sumValueByRow(t2, 2);
// 结果：46

sumValueByRow2(tb, row_index, from_col, to_col)

声明：function

求指定行中指定多列的和

参数	类型	说明
tb	array	数据表
row_index	integer	指定计算行索引号（从0开始）
from_col	integer	指定计算起始列索引号（从0开始）
to_col	integer	指定计算起始列索引号（从0开始）

返回：real

示例

t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return sumValueByRow2(t2, 1, 0, 1);
// 结果：36

sysErrorMessage(code)

声明：function

返回指定代码表示的系统错误信息

参数	类型	说明
code	int	整数，提示代码

返回：string

sysGetThreadName(tid, return_value)

声明：function

获取线程名称

参数	类型	说明
tid	int	可选。线程ID；未指定时默认获取当前线程名称
return_value	string	获取成功，返回线程名称；否则，返回空字符串

返回：string

sysGetThreadPriority(pri, tid, return_value)

声明：function

获取线程优先级

参数	类型	说明
pri	int	变参，整数，线程优先级
tid	int	可选。线程ID；未指定时默认获取当前线程优先级
return_value	int	返回值为0，获取成功；否则，获取失败

返回：int

sysGetThreads(pid, return_value)

声明：function

获取进程内的线程列表

参数	类型	说明
pid	int	可选。进程ID；未指定时默认获取当前进程内的线程列表
return_value	array	获取成功，返回线程ID列表；否则，返回空数组

返回：array

sysHandleOfPid(pid, rights, inherithandle, return_value)

声明：function

Windows上获取进程id对应的句柄，Linux上获取指定文件ID的复制ID。得到的句柄可用函数FAQ：SysCloseHandle进行关闭

参数	类型	说明
pid	int	整数，进程ID
rights	int	可选。设置进程句柄权限，Linux上无效。常见的权限设置值如下： 更多说明，可参考微软官方文档：处理安全和访问权限
inherithandle	bool	可选。是否继承，Linux上无效
return_value	16	获取成功，返回进程句柄；否则，返回0

返回：IntPtr|int

sysPidOfHandle(handle, return_value)

声明：function

根据进程句柄获取进程ID。在Linux上，返回和进程句柄值相同的整数

参数	类型	说明
handle	int	进程句柄
return_value	int	获取成功，返回进程ID；否则，返回0

返回：int

sysPidOfTid(tid, return_value)

声明：function

获取线程所属进程ID

参数	类型	说明
tid	int	整数，线程ID
return_value	int	获取成功，返回进程ID；否则，返回0

返回：int

sysPPid(pid, return_value)

声明：function

获取进程的父进程ID

参数	类型	说明
pid	int	可选。进程ID；未指定时默认获取当前进程的父进程ID
return_value	int	获取成功，返回父进程ID；否则，返回0

返回：int

sysSetThreadName(name, tid, return_value)

声明：function

设置线程名称

参数	类型	说明
name	string	字符串，要设置的名称
tid	int	可选。线程ID；未指定时默认设置当前线程名称
return_value	int	返回值为0，设置成功；否则，设置失败

返回：int

sysSetThreadPriority(pri, tid, return_value)

声明：function

设置线程优先级

参数	类型	说明
pri	int	线程优先级
tid	int	可选。线程ID；未指定时默认设置当前线程优先级
return_value	int	返回值为0，设置成功；否则，设置失败

返回：int

sysWaitForSingleObject(object, wait_ms)

声明：function

等待占有一个对象,例如互斥对象。支持windows和linux的进程

参数	类型	说明
object	int	整数，对象名柄
wait_ms	int	整数，等待的毫秒数，-1则为永远等待。

返回：int

tableSelect(table, condition, reps)

声明：function

表格查询。从t中查询满足Condition的子表

参数	类型	说明
table	any	数据表
condition	string	字符串
reps	string	字符串

返回：array

示例

t := `array('a': (1, 2, 3, 4), 'b': (2, 3, 4, 5), 'c': (3, 4, 5, 6), 'd': (4, 5, 6, 7), 'e': (5, 6, 7, 8), 'f': (7, 8, 9, 10));
return tableSelect(t, "~['b']=2", '~'); // 返回t中字段’b’=2的子表
// 返回:

TableType(t)

声明：function

依据数组类型返回不同的值

参数	类型	说明
t	array	数据表类型，数组

返回：integer

不是数组时返回 -1，以字符串返回的数组返回 0，以下标访问的数组返回 1。

示例

data := array(array(1, 2), array(3, 4));
echo TableType(data);

tableVectorizeArray(t, s, opt, is_func)

声明：function

数据表与一维数据表的矢量化运算

参数	类型	说明
t	array	数据表
s	array|real	一维数组 或实数， 运算标量
opt	string	字符串，操作运算符，默认"-",表逐行减法
is_func	bool	布尔，opt是否是函数，默认假

返回：array

示例

t := ones(10, 3);
s := array(1, 2, 3);
return tableVectorizeArray(t, s, '-');
// 输出：
// array(
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2))

tostring(v)

声明：function

将数值转成字符串类型

参数	类型	说明
v	number	数值

返回：string

示例

echo tostring(123.45);

totalStrToSeprate(s)

声明：function

把用#分割的字符串转换为;分割

参数	类型	说明
s	string	字符串

返回：string

示例

return totalStrToSeprate ('债券型#现金型#配置型#股票型#保本型');
// 结果：’债券型;现金型;配置型;股票型;保本型’

tryDecToInt(s, value)

声明：function

将字符串转换为整数。若转换成功，转换值通过Value输出

参数	类型	说明
s	string	字符串。需转换的字符串
value	integer|nil	变参。转换成功，为转换后的整数；否则，为NIL值。

返回：bool

示例

范例01：转换成功

ret := tryDecToInt("12", value);
if ret then
return value;
else
return "转换失败！";
// 输出: 12

范例02：转换失败

ret := tryDecToInt("test", value);
if ret then
return value;
else
return "转换失败！";
// 输出: "转换失败！"

范例03：十六进制格式字符串的转换

ret := tryDecToInt("0x12", value);
if ret then
return value;
else
return "转换失败！";
// 输出: "转换失败！"
ret := tryStrToInt("0x12", value);
if ret then
return value;
else
return "转换失败！";
// 输出：18

tryDecToInt32(s, value)

声明：function

将字符串转换为32位整数。若转换成功，转换值通过Value输出

参数	类型	说明
s	string	字符串。需转换的字符串
value	integer|nil	变参。转换成功，为转换后的整数；否则，为NIL值。

返回：bool

示例

范例01：转换成功

ret := tryDecToInt32("12", value);
if ret then
return value;
else
return "转换失败！";
// 输出: 12

范例02：转换失败

ret := tryDecToInt32("test", value);
if ret then
return value;
else
return "转换失败！";
// 输出: "转换失败！"

范例03：十六进制格式字符串的转换

ret := tryDecToInt32("0x12", value);
if ret then
return value;
else
return "转换失败！";
// 输出: "转换失败！"
ret := tryStrToInt32("0x12", value);
if ret then
return value;
else
return "转换失败！";
// 输出：18

tryDecToInt64(s, value)

声明：function

将字符串转换为64位整数。若转换成功，转换值通过Value输出

参数	类型	说明
s	string	字符串。需转换的字符串
value	integer|nil	变参。转换成功，为转换后的整数；否则，为NIL值。

返回：bool

示例

范例01：转换成功

ret := tryDecToInt64("12", value);
if ret then
return value;
else
return "转换失败！";
// 输出: 12L

范例02：转换失败

ret := tryDecToInt64("test", value);
if ret then
return value;
else
return "转换失败！";
// 输出: "转换失败！"

范例03：十六进制格式字符串的转换

ret := tryDecToInt64("0x12", value);
if ret then
return value;
else
return "转换失败！";
// 输出: "转换失败！"
ret := tryStrToInt64("0x12", value);
if ret then
return value;
else
return "转换失败！";
// 输出：18L

tryLowercase(s)

声明：function

将字符串S转换成小写并返回，不抛出异常，转换失败时返回""

参数	类型	说明
s	string	字符串,原字符串

返回：string

示例

return tryUppercase("ABC");
// 结果:"abc"

tryStrToTime(s, value)

声明：function

将字符串S转换成TDateTime类型的时间并存到参数Value中。如果转换成功，则返回真，否则返回假

参数	类型	说明
s	string	字符串，日期的字符串类型，如"2014-01-17"
value	datetime	日期时间，转换结果（输出参数）

返回：bool

tryUppercase(s)

声明：function

将字符串S转换成大写并返回，不抛出异常，转换失败时返回""

参数	类型	说明
s	string	字符串,原字符串

返回：string

示例

return tryUppercase("abc");
// 结果:"ABC"

TwoRDateCompare_M1(t1, t2, r_date, r_date2, key_field, from_col, to_col, show_g_value, show_g_percent)

声明：function

返回2个数据同比比较的结果

参数	类型	说明
t1	array	数组类型，数据1
t2	array	数组类型，数据2
r_date	datetime	报告期类型，报告期
r_date2	any	报告期类型，同比报告期
key_field	string	字符串类型，关键字
from_col	any	整型，要显示变比的开始列号
to_col	any	整型，要显示变比的截止列号
show_g_value	bool	布尔类型，显示变动
show_g_percent	bool	布尔类型，显示变比(%)

返回：array

示例

current_data := array(("code": "A", "value": 120));
previous_data := array(("code": "A", "value": 100));
echo trim(toStn(TwoRDateCompare_M1(
    current_data,
    previous_data,
    20220331,
    20210331,
    "code",
    0,
    0,
    true,
    true
)));

unicodeEsc2()

声明：function

将字符串转换为 \uxxxx 形式的 Unicode 编码串

返回：string

unitary(t, key_fields, _type, f_value)

声明：function

归一处理。对数组t指定列KeyFields进行归一处理，归一方式由Type决定

参数	类型	说明
t	array,tablearray
key_fields	string
_type	integer
f_value	integer

返回：array,tablearray

示例

t := `array('a': (1, 2, 3, 4), 'b': (2, 3, 4, 5), 'c': (3, 4, 5, 6), 'd': (4, 5, 6, 7), 'e': (5, 6, 7, 8), 'f': (7, 8, 9, 10));
unitary(t, 'b', 0, 10);
return t;
// 返回:
// array(
// ("a":1,"b":10.0,"c":3,"d":4,"e":5,"f":7),
// ("a":2,"b":15.0,"c":4,"d":5,"e":6,"f":8),
// ("a":3,"b":20.0,"c":5,"d":6,"e":7,"f":9),
// ("a":4,"b":25.0,"c":6,"d":7,"e":8,"f":10))

varByColumn(t, f_name)

声明：function

指定列的方差

参数	类型	说明
t	array	数据表
f_name	string	指定列名，字符串

返回：real

示例

t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return varByColumn(t2, 'c');
// 结果：291.67

webFormatToRung(a)

声明：function

将数组Nan/Nil/±Inf替换为"-"

参数	类型	说明
a	array	数组，待替换数组，支持多维数组，高维嵌套数组

返回：any

示例

a := array('a': ('b': ('c': (nil, nan, 3), 'd': 2), 'e': nan));
return webFormatToRung(a); // array("a":("b":("c":("-","-",3),"d":2),"e":"-"))

webZero(v)

声明：function

Web中显示零处理，当数值为0或者空字符串的时候显示为空字符串，其他情况显示其值本身

参数	类型	说明
v	integer/string	任意类型的值

返回：string

示例

return webZero(0);
// 结果：’’  //空字串

wrapText(col, row)

声明：function

单元格的是否换行

参数	类型	说明
col	string	整数，列的位置，从0开始。
row	int	整数，行的位置，从0开始。

返回：string

zValue(t, column_name)

声明：function

按照指定字段求Z值

参数	类型	说明
t	array	数据表类型，数据表
column_name	string	字符串，要计算Rank的字段

返回：any

示例

s := array(
    ("代码":"SZ000001","名称":"平安银行","收盘":11.2,"涨幅(%)":0.900900900900892),
    ("代码":"SZ000002","名称":"万  科Ａ","收盘":27.68,"涨幅(%)":-0.25225225225225),
    ("代码":"SH600000","名称":"浦发银行","收盘":10.77,"涨幅(%)":0.372786579683115),
    ("代码":"SH600100","名称":"同方股份","收盘":8.73,"涨幅(%)":1.74825174825175));
zValue(s, '涨幅(%)');
return s;
// 返回:
// array(
// ("代码":"SZ000001","名称":"平安银行","收盘":11.2,"涨幅(%)":0.900900900900892,"Z_涨幅(%)":0.246104637421774),
// ("代码":"SZ000002","名称":"万  科Ａ","收盘":27.68,"涨幅(%)":-0.25225225225225,"Z_涨幅(%)":-1.11516496413374),
// ("代码":"SH600000","名称":"浦发银行","收盘":10.77,"涨幅(%)":0.372786579683115,"Z_涨幅(%)":-0.37732163484235),
// ("代码":"SH600100","名称":"同方股份","收盘":8.73,"涨幅(%)":1.74825174825175,"Z_涨幅(%)":1.24638196155432))