# Dotnet 以下为 .NET 运行环境提供的函数。 ## `accumulativeYtMtoYtm(t, fname, dw)` 声明：function 复合益率转日收益率。 | 参数 | 类型 | 说明 | | ------- | ------- | ---------------------------------- | | `t` | array | 数据表类型，复合收益率序列 | | `fname` | string | 字符串，收益字段名称 | | `dw` | integer | 整数，决定源数据的单位和返回的数据 | 返回：array ### 示例 ```tsl // 源数据单位为1,设dw=2,同时返回复合收益率和转换后的日收益率 t1 := array(('日期': 20180801T, '复合收益率': 0.1), ('日期': 20180802T, '复合收益率': 0.4), ('日期': 20180803T, '复合收益率': 0.7)); r1 := accumulativeYtMtoYtm(t1, '复合收益率', 2); // 源数据单位为%,设dw=3,同时返回复合收益率和转换后的日收益率 t2 := array(('日期': 20180801T, '复合收益率(%)': 10), ('日期': 20180802T, '复合收益率(%)': 40), ('日期': 20180803T, '复合收益率(%)': 70)); r2 := accumulativeYtMtoYtm(t2, '复合收益率(%)', 3); return r1|r2; // 输出：返回： ``` ## `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 ### 示例 ```tsl elps := randnorm(0, 1, 200); y := array(); y[0] := 0; y[1] := 0; for i := 2 to 199 do y[i] := -0.5 * y[i-1]+0.3 * y[i-2]+elps[i]; return ar(y, 2, 'ls'); ``` ## `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 ### 示例 ```tsl elps:=randnorm(0,1,200); y:=array(); y[0]:=0; for i:=1 to 199 do y[i]:=0.8*y[i-1]+elps[i]-0.4*elps[i-1]; 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl x := randbino(10, 0.5, 1); return binofit(x, 10, 0.05); // 输出：返回p的估计以及在alpha的显著性水平下的区间估计 ``` ## `boxcox(y)` 声明：function 在做线性回归的过程中，不可观测的误差可能是和预测变量相关，于是给线性回归的最小二乘法估计系数的结果带来误差，为了解决这样的方差齐性问题，所以考虑对相应应变量做Box-Cox变换，变换之后，可以一定程度上减小不可观测的误差和预测变量的相关性 | 参数 | 类型 | 说明 | | ---- | ------------- | -------------------------- | | `y` | array of real | 因变量序列，为一维数组类型 | 返回：array ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl // 设置样本矩阵 zt := array((0.7592, 1.7593, 21.9279, 48.5626, 55.1679), (0.0490, 0.4457, 2.2255, 82.2658, 192.4348), (-2.2313, -1.3096, -59.8883, 3.9922, -80.2419), (0.1364, 0.539, 4.3910, 55.1438, 46.0612), (0.7233, 1.9467, 15.6127, 111.3018, 58.3969)); 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 ### 示例 ```tsl // 设置样本矩阵 zt := array((0.7592, 1.7593, 21.9279, 48.5626, 55.1679), (0.0490, 0.4457, 2.2255, 82.2658, 192.4348), (-2.2313, -1.3096, -59.8883, 3.9922, -80.2419), (0.1364, 0.539, 4.3910, 55.1438, 46.0612), (0.7233, 1.9467, 15.6127, 111.3018, 58.3969)); 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl a := rand(7, 4); return corrcoef(a); // 返回简单相关系数分析 // 输出：结果： ``` ## `correlationMatrix(a1, t)` 声明：function 相关系数矩阵求解 | 参数 | 类型 | 说明 | | ---- | ----- | ---- | | `a1` | array | | | `t` | float | | 返回：array ### 示例 ```tsl a := rand(4,3); correlationMatrix(a,1); ``` ## `correlpaired(a, b)` 声明：function 功能：计算 a 的每一列与 b 的每一列之间的相关系数矩阵， | 参数 | 类型 | 说明 | | ---- | ----- | ------------- | | `a` | array | 一维数字数组, | | `b` | array | 一维数字数组, | 返回：array ### 示例 范例01： ```tsl a := array(1, 2, 3, 4, 5); b := array(2, 4, 6, 8, 10); return correlpaired(a, b); // 输出：array((1.0)) ``` 范例02： ```tsl 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： ```tsl 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： ```tsl 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 ### 示例 ```tsl a := corr(rand(6, 6)); return corrMatrixAdjust(a, 1, 5); ``` ## `cov2CorrMatrix(a)` 声明：function 协方差矩阵转为相关系数矩阵 | 参数 | 类型 | 说明 | | ---- | ----- | ------------------------ | | `a` | array | 二维数字数组，协方差矩阵 | 返回：array ### 示例 ```tsl a := covariance(rand(4, 3)); return cov2CorrMatrix(a); ``` ## `covariance(a)` 声明：function 计算协方差矩阵 | 参数 | 类型 | 说明 | | ---- | ----- | ---- | | `a` | array | | 返回：any ### 示例 ```tsl a := rand(4,3); covariance(a); ``` ## `det(a)` 声明：function 行列式 | 参数 | 类型 | 说明 | | ---- | ----- | ----------------- | | `a` | array | 二维数字数组 样本 | 返回：real ### 示例 ```tsl a := array((1, 2), (3, 4)); return det(a); // -2 ``` ## `diag(a)` 声明：function 对角阵 | 参数 | 类型 | 说明 | | ---- | ----- | ---------- | | `a` | array | array 数组 | 返回：array ### 示例 ```tsl 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 ### 示例 ```tsl a := array( (3.00, 8.35, 23.53, 7.51, 8.62, 17.42, 10.00, 1.04, 11.21), (3.00, 9.25, 23.75, 6.61, 9.19, 17.77, 10.48, 1.72, 10.51), (3.00, 8.19, 30.5, 4.72, 9.78, 16.28, 7.6, 2.52, 10.32), (3.00, 7.73, 29.2, 5.42, 9.43, 19.29, 8.49, 2.52, 10.00), (3.00, 9.42, 27.93, 8.2, 8.14, 16.17, 9.42, 1.55, 9.76), (3.00, 9.16, 27.98, 9.01, 9.32, 15.99, 9.1, 1.82, 11.35), (3.00, 10.06, 28.64, 10.52, 10.05, 16.18, 8.39, 1.96, 10.81), (1.00, 8.67, 36.05, 7.31, 7.75, 16.67, 11.68, 2.38, 12.88), (1.00, 9.98, 37.69, 7.01, 8.94, 16.15, 11.08, 0.83, 11.67), (1.00, 6.77, 38.69, 6.01, 8.82, 14.79, 11.44, 1.74, 13.23), (1.00, 8.14, 37.75, 9.61, 8.49, 13.15, 9.76, 1.28, 11.28), (1.00, 7.67, 35.71, 8.04, 8.31, 15.13, 7.67, 1.41, 13.25), (1.00, 7.9, 39.77, 8.49, 12.94, 19.29, 11.05, 2.04, 13.29), (1.00, 7.18, 40.91, 7.32, 8.94, 17.6, 12.75, 1.14, 14.8), (1.00, 8.82, 33.7, 7.59, 10.98, 18.82, 14.73, 1.78, 10.1), (1.00, 6.25, 35.02, 4.72, 6.28, 10.03, 7.15, 1.93, 10.39), (2.00, 10.6, 52.41, 7.7, 9.98, 12.53, 11.7, 2.31, 14.69), (3.00, 7.27, 52.65, 3.84, 9.16, 13.03, 15.26, 1.98, 14.57), (3.00, 13.45, 55.85, 5.5, 7.45, 9.55, 9.52, 2.21, 16.3), (3.00, 10.85, 44.68, 7.32, 14.51, 17.13, 12.08, 1.26, 11.57), (3.00, 7.21, 45.79, 7.66, 10.36, 16.56, 12.86, 2.25, 11.69), (3.00, 7.68, 50.37, 11.35, 13.3, 19.25, 14.59, 2.75, 14.87), (2.00, 7.78, 48.44, 8.00, 20.51, 22.12, 15.73, 1.15, 16.61)); x := array( (9.09, 28.12, 7.4, 9.62, 17.26, 11.12, 2.49, 12.65), (9.41, 28.2, 5.77, 10.8, 16.36, 11.56, 1.53, 12.17), (8.7, 28.12, 7.21, 10.53, 19.45, 13.3, 1.66, 11.96), (6.93, 29.85, 4.54, 9.49, 16.62, 10.65, 1.88, 13.61)); options := array('cov': 1, 'backtest': 1, 'crosstest': 1); return discrim(a, x, 0, options); // 计算结果： ``` ## `distance(x, y, name)` 声明：function 计算样本和样本间的距离或样本数据观测矩阵的距离矩阵，其中距离包括欧氏距离，欧氏距离平方，方差加权距离，Chebychev距离，Block距离，夹角余弦，广义距离 | 参数 | 类型 | 说明 | | ------ | ------- | ---------------------------------------------- | | `x` | array | 样本数据观测矩阵或样本数据，一维或二维数字数组 | | `y` | array | 样本数据，一维数字数组 | | `name` | integer | 距离方式，为一整数或字符串 | 返回：array ### 示例 ```tsl x := Array(22, 35, 24, 32, 43, 53); y := Array(1, 2, 3, 4, 5, 6); name := 'euclidean'; // 采用欧式距; return distance(x, y, name); // 输出：80.04998438475; 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl r := array(-1, 2, -3, 9); return expdMax(r); // array(-1,2,2,9) ``` ## `expdMin(r)` 声明：function 统计数组累积到当前行的最小值序列 | 参数 | 类型 | 说明 | | ---- | ------------- | ------------------------------------------------------------ | | `r` | array of real | 数组，一维或二维（此时按列统计）数字数组，也可以为二维数据表 | 返回：array ### 示例 ```tsl r := array(-1, 2, -3, 9); return expdMin (r); // array(-1,-1,-3,-3) ``` ## `expdProduct(r)` 声明：function 返回数组累积到当前行的累乘序列 | 参数 | 类型 | 说明 | | ---- | ------------- | ------------------------------------------------------------ | | `r` | array of real | 数组，一维或二维（此时按列统计）数字数组，也可以为二维数据表 | 返回：array ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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格式字符串（含大数量级数据） ```tsl data := array(1, 2, "3", "A", 9, 1E15); ret := exportCsvne(data, s); if ret then return s; else return ret; ``` 范例02：二维数组转换成csv格式字符串 ```tsl 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格式字符串，结果包含数组下标信息 ```tsl 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格式字符串，结果不包含字段头部信息 ```tsl 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 ### 示例 ```tsl // 导出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 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 ### 示例 ```tsl // 设置样本矩阵 zt := array((0.7592, 1.7593, 21.9279, 48.5626, 55.1679), (0.0490, 0.4457, 2.2255, 82.2658, 192.4348), (-2.2313, -1.3096, -59.8883, 3.9922, -80.2419), (0.1364, 0.539, 4.3910, 55.1438, 46.0612), (0.7233, 1.9467, 15.6127, 111.3018, 58.3969)); 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 ### 示例 ```tsl // 以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 ### 示例 ```tsl list := array('a', 'b', 'c'); generateCombinations(list, ret); return ret; ``` ## `getColorByIndex(index)` 声明：function 依据Index值，获得颜色数组内的指定颜色整数代号。 | 参数 | 类型 | 说明 | | ------- | ------- | ---------------- | | `index` | integer | 整数，颜色索引号 | 返回：integer ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl a := randnorm(0, 1, 10000); return hist(a, 30, center); // 输出：，一维数字数组 ``` ## `histc(a, b)` 声明：function 端点定位频数，判断序列a 中各个元素在b中各个段位中的频数 | 参数 | 类型 | 说明 | | ---- | ----- | -------- | | `a` | array | 一维数组 | | `b` | array | 一维数组 | 返回：array ### 示例 ```tsl 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，则拒绝原假设，若alpha1; 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 ### 示例 ```tsl 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 ### 示例 ```tsl x := array((3, 1), (1, 4)); return isDefinite(x); // 1 ``` ## `isSymmetry(a, tol)` 声明：function 判断是否为对称矩阵 | 参数 | 类型 | 说明 | | ----- | ----- | -------------- | | `a` | array | array 二维数组 | | `tol` | real | real 精度 | 返回：integer ### 示例 ```tsl a := array((2, 1), (1, 3)); return isSymmetry(a, 0.1); // 1 ``` ## `kurt(t, real)` 声明：function 峰度。 | 参数 | 类型 | 说明 | | ------ | ----- | ---------------------- | | `t` | array | 一维数字数组，一维数据 | | `real` | | 实数，返回的峰度 | 返回：any ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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： ```tsl // 计算一组序列的最大涨幅 data := array(3, 1, 7, 5, 6, 3); return maxDrawDown(data, 1); // 结果： 1 2 6 6 // 输出：说明：入点为data[1]，出点为data[2]，两者差为6，最大涨幅比例差为6 ``` 范例02： ```tsl // ------计算100日股票的最大跌幅 setSysParam(pn_stock(), 'SZ000002'); setSysParam(pn_date(), 20181031T); setSysParam(pn_rate(), 1); setSysParam(pn_rateday(), 20181031T); setSysParam(pn_cycle(), cy_day()); data := nDay3(100, close()); t := maxDrawDown(data); return t; // 结果t： 12 43 6.96759 0.25765 // 注：若需计算最大跌幅率，则只需t[3] * 100即可。 ``` ## `mbbub(p, z)` 声明：function 排序，对数组P按照从小到大的顺序排序，把数组排序的顺序对应的下标值返回到数组Z中 | 参数 | 类型 | 说明 | | ---- | ----- | ---------------- | | `p` | array | 一维数字数组类型 | | `z` | array | 一维数字数组类型 | 返回：array ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl // 科大讯飞(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 ### 示例 ```tsl x:=array((0.00,0.00),(0.00,1.00),(1.00,0.00),(1.00,1.00)); y:=array(1.00,2.00,2.00,3.00); 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 ### 示例 ```tsl // 返回取-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： ```tsl 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 ### 示例 ```tsl a := array(5, 6, 8, nan); return nanMean(a); // 结果：6.33 ``` ## `nanPercentRankArr(a, f_name)` 声明：function 1、返回一维数组中的每个值在一维数组中的百分比排名 | 参数 | 类型 | 说明 | | -------- | ------ | ------------------------ | | `a` | array | 数字数组，待计算的数组 | | `f_name` | string | 字符串，字段名，默认为空 | 返回：array ### 示例 ```tsl a := array(1, 1, 2, 2, 2, 9, nan, 9, 9); return nanPercentRankArr(a); // 结果：array(0.0,0.0,0.29,0.29,0.29,0.71,NAN,0.71,0.71) ``` ## `nanPopnStd(a)` 声明：function 计算含Nan一维数组的总体标准差 | 参数 | 类型 | 说明 | | ---- | ----- | ------------ | | `a` | array | 一维数字数组 | 返回：real ### 示例 ```tsl a := array(5, 6, 8, nan); return nanPopnStd(a); // 结果：1.25 ``` ## `nanPopnVariance(a)` 声明：function 计算含Nan一维数组的总体方差 | 参数 | 类型 | 说明 | | ---- | ----- | ------------ | | `a` | array | 一维数字数组 | 返回：real ### 示例 ```tsl 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 ### 示例 ```tsl a := array(1, 1, 2, 2, 2, 9, nan, 9, 9); return nanRankArr(a); // 结果：array(1,1,3,3,3,6,NAN,6,6) ``` ## `nanStd(a)` 声明：function 计算含Nan一维数组的标准差的估计（样本标准差） | 参数 | 类型 | 说明 | | ---- | ----- | ------------ | | `a` | array | 一维数字数组 | 返回：real ### 示例 ```tsl a := array(5, 6, 8, nan); return nanStd(a); // 结果：1.53 ``` ## `nanSum(a)` 声明：function 计算含Nan一维数组的总和 | 参数 | 类型 | 说明 | | ---- | ----- | ------------ | | `a` | array | 一维数字数组 | 返回：real ### 示例 ```tsl a := array(5, 6, 8, nan); return nanSum(a); // 结果：19 ``` ## `nanVariance(a)` 声明：function 计算含Nan一维数组的方差的估计（样本方差） | 参数 | 类型 | 说明 | | ---- | ----- | ------------ | | `a` | array | 一维数字数组 | 返回：real ### 示例 ```tsl a := array(5, 6, 8, nan); return nanVariance(a); // 结果：2.33 ``` ## `nchoosek(n, k)` 声明：function 样本组合 | 参数 | 类型 | 说明 | | ---- | ------- | ------------------ | | `n` | array | 样本(一维数组) | | `k` | integer | 每组样本数量(整数) | 返回：array ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl x := rand(10); return normPlot(x); // 输出： array( ("采样位数": 0.171976955840364, "理想位数": -1.64484977722168), ("采样位数": 0.301570532377809, "理想位数": -1.03643536567688), ("采样位数": 0.470976530341431, "理想位数": -0.674489885568619), ("采样位数": 0.479131903499365, "理想位数": -0.38532167673111), ("采样位数": 0.678062069928274, "理想位数": -0.125661492347717), ("采样位数": 0.735156666953117, "理想位数": 0.125661492347717), ("采样位数": 0.739045920781791, "理想位数": 0.38532167673111), ("采样位数": 0.780685598030686, "理想位数": 0.674489885568619), ("采样位数": 0.817699506180361, "理想位数": 1.03643536567688), ("采样位数": 0.828364443266764, "理想位数": 1.64484977722168)) QQ图形： return normPlot(x, 1); // 输出：0.911334081735257 ``` ## `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 ### 示例 ```tsl // 计算矩阵A的标准正交基 a := array((0, 1), (1, 1), (1, 0)); return orth(a); ``` ## `outPutGrowRatio(v1, v2)` 声明：function 增长率(%) | 参数 | 类型 | 说明 | | ---- | ----- | ------------ | | `v1` | float | 实型，期末值 | | `v2` | float | 实型，期初值 | 返回：float ### 示例 ```tsl //返回13到14的增长率(%) outPutGrowRatio(14,13); //结果：7.69 ``` ## `outPutGrowRatio2(v1, v2)` 声明：function 增长率(%) | 参数 | 类型 | 说明 | | ---- | ----- | ------------ | | `v1` | float | 实型，期末值 | | `v2` | float | 实型，期初值 | 返回：float ### 示例 ```tsl //返回13到14的增长率(%) outPutGrowRatio2(14,13); //结果：7.69 ``` ## `outPutGrowRatio3(v1, v2)` 声明：function 增长率(%) | 参数 | 类型 | 说明 | | ---- | ---- | ------------ | | `v1` | real | 实型，期末值 | | `v2` | real | 实型，期初值 | 返回：real ### 示例 ```tsl // 返回14到13的增长率(%) return outPutGrowRatio3(14, 13); // 结果：7.69 ``` ## `outPutGrowValue(v1, v2)` 声明：function 增长 | 参数 | 类型 | 说明 | | ---- | ---- | ------------ | | `v1` | real | 实型，期末值 | | `v2` | real | 实型，期初值 | 返回：real ### 示例 ```tsl // 返回13与14的差值 return outPutGrowValue(13, 14); // 结果：-1 ``` ## `outPutGrowValue2(v1, v2)` 声明：function 增长 | 参数 | 类型 | 说明 | | ---- | ----- | ------------ | | `v1` | float | 实型，期末值 | | `v2` | float | 实型，期初值 | 返回：float ### 示例 ```tsl //返回13与14差值 outPutGrowValue2(13,14); //结果：-1 ``` ## `outPutGrowValue3(v1, v2)` 声明：function 增长 | 参数 | 类型 | 说明 | | ---- | ---- | ------------ | | `v1` | real | 实型，期末值 | | `v2` | real | 实型，期初值 | 返回：real ### 示例 ```tsl // 返回13与14的差值 return outPutGrowValue3(13, 14); // 结果：-1 ``` ## `outPutLnGrowRatio(v1, v2)` 声明：function 对数增长率输出(%)。 | 参数 | 类型 | 说明 | | ---- | ---- | ------------ | | `v1` | real | 实型，期末值 | | `v2` | real | 实型，期初值 | 返回：real ### 示例 ```tsl // 取3与4的对数增长率 return outPutLnGrowRatio(3, 4); // 结果：-28.77 ``` ## `outPutValueByUnit(data_type, data_unit)` 声明：function 单位转换。 | 参数 | 类型 | 说明 | | ----------- | ------ | ---------------- | | `data_type` | string | 字符串，数据类型 | | `data_unit` | real | 实型，指定单位 | 返回：real ### 示例 ```tsl // 返回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 ### 示例 ```tsl f:=array(-3,2,-5); a:=array((1,2,-1),(1,4,1),(1,1,0),(4,0,1)); b:=array(2,4,3,6); 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 ### 示例 ```tsl 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 ### 示例 ```tsl // 去除随机数组的极值 data := array(1, 2, 2, 4); ret := array(); n := 0; for i := 0 to 5 do begin ret[n, 'score'] := i; for j, kind in array('rank', 'strict', 'weak', 'mean')do begin ret[n, kind] := percentileOfScore(data, i, j); end ret[n, 'percenrank'] := percentrank(data, i); n++; end; return ret; ``` ## `perms(x)` 声明：function 样本排列 | 参数 | 类型 | 说明 | | ---- | ----- | ---------------- | | `x` | array | 样本，数组或数字 | 返回：array ### 示例 范例01：求10的阶乘 ```tsl return perms(10); // 输出：3628800 ``` 范例02：排列组合 ```tsl return perms(array("a", "b", "c")); // 输出： array( ("c", "b", "a"), ("c", "a", "b"), ("b", "c", "a"), ("b", "a", "c"), ("a", "b", "c"), ("a", "c", "b")) ``` 范例03：返回数组Array(('A','B'),('C', 'D'))中任意两个数据的排列组合 ```tsl v := Array(('A', 'B'), ('C', 'D')); return perms(v, 2); ``` 范例04：对排列组合的每列求和 ```tsl function test_1cth(); begin func := createobject("funcexe"); a := array("A", "B", "C"); return perms(a, 3, func); end; type funcexe = class() data; function create(); begin data := ""; end function exe(dat); begin data+=dat; end end ``` ## `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 ### 示例 ```tsl 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 ### 示例 ```tsl x := randpoiss(1, 100); return poissfit(x, 0.05); // 输出：返回lambda的估计以及他们的在alpha的显著性水平下的区间估计 ``` ## `polynomialRegression(x, y, m)` 声明：function 多项式回归 | 参数 | 类型 | 说明 | | ---- | ------- | --------------------------- | | `x` | array | 一维数字数组类型,观察数据点 | | `y` | array | 一维数字数组类型,观察数据值 | | `m` | integer | 整数类型，拟合最大阶数 | 返回：array ### 示例 ```tsl 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 ### 示例 ```tsl // 设置样本矩阵 zt := array((0.7592, 1.7593, 21.9279, 48.5626, 55.1679), (0.0490, 0.4457, 2.2255, 82.2658, 192.4348), (-2.2313, -1.3096, -59.8883, 3.9922, -80.2419), (0.1364, 0.539, 4.3910, 55.1438, 46.0612), (0.7233, 1.9467, 15.6127, 111.3018, 58.3969)); return princaipalComponentAnalysis(zt); ``` ## `princomp(x, ep, is_stand, resid)` 声明：function 主成分分析，isStand为0时从中心化协方差出发进行主成分分析，为1时从相关系数出发，进行主成分分析； | 参数 | 类型 | 说明 | | ---------- | ------------- | ------------------------------------------- | | `x` | array of real | 样本数据，二维数字数组; | | `ep` | real | 累计方差贡献度阈值，实数，缺省时默认为0.85; | | `is_stand` | bool | 是否标准化，布尔类型，缺省时为真； | | `resid` | array | 残差，变参输出，二维数字数组； | 返回：array ### 示例 ```tsl data := array( (947.00, 23.4, 14.8, 45.3, 0.46, 85.2, 373.00, 9.54, 0.37, 3.88), (935.00, 23.2, 16.2, 41.7, 0.4, 83.3, 305.00, 7.9, 0.38, 4.81), (918.2, 20.9, 14.8, 43.8, 0.38, 82.6, 320.00, 9.51, 0.43, 4.52), (910.7, 23.4, 16.1, 44.00, 0.46, 85.2, 338.00, 8.6, 0.33, 3.84), (905.00, 22.9, 17.00, 39.8, 0.45, 80.4, 348.00, 9.53, 0.42, 4.4), (890.6, 22.3, 15.7, 44.00, 0.41, 85.4, 286.00, 8.67, 0.39, 4.5), (853.4, 20.9, 15.9, 41.6, 0.35, 85.4, 273.00, 9.79, 0.42, 4.29), (837.3, 20.2, 14.4, 37.3, 0.33, 82.5, 326.00, 7.62, 0.36, 4.73), (833.3, 22.2, 15.2, 38.3, 0.37, 82.2, 310.00, 7.84, 0.4, 5.1), (760.9, 20.4, 15.5, 40.7, 0.32, 84.2, 268.00, 7.75, 0.35, 4.52), (760.3, 20.8, 15.1, 44.8, 0.35, 79.5, 273.00, 8.91, 0.45, 5.05), (742.5, 23.4, 14.7, 43.1, 0.35, 79.5, 310.00, 9.13, 0.4, 4.36)); return princomp(data, 0.85, 1, resid); ``` ## `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 lbcode:', 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl // Arr中存储的是代码，获取2019年3月1日，Arr中所有代码的收盘价 arr := array('SZ000001', 'SZ000002'); return singleVariableExecute(arr, pn_stock(), @close()); ``` ## `skew(t, skew)` 声明：function 偏斜度。 | 参数 | 类型 | 说明 | | ------ | ----- | ---------------------- | | `t` | array | 一维数字数组，一维数据 | | `skew` | real | 实数，返回的偏斜度 | 返回：any ### 示例 ```tsl 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 ### 示例 ```tsl x := array(5, 1, 19, 8); y := array(2, 3, 1, 7); xx := array(4, 12); return spline(x, y, xx); // 返回：array(1.1407,13.9444) ``` ## `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 ### 示例 ```tsl // 获得系统内存状态 return sysGetMemoryUsage(); ``` ## `sysGetPidOfCom(obj)` 声明：function 取得 COM 对象对应的进程 ID。 | 参数 | 类型 | 说明 | | ----- | ------ | ---------- | | `obj` | comobj | COM 对象。 | 返回：integer ### 示例 范例01：基本用法 ```tsl 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：基本用法 ```tsl 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 ### 示例 ```tsl // 获得自身的内存使用状态 return sysGetProcessMemoryUsage(); ``` ## `sysGetWndOfCaption(caption[, is_contain_string])` 声明：function 按窗口标题查找窗口句柄列表。is_contain_string 可省略，缺省为真。 | 参数 | 类型 | 说明 | | ------------------- | ------- | ---------------------------------------- | | `caption` | string | 窗口标题。 | | `is_contain_string` | boolean | 可选；是否按标题包含关系匹配，缺省为真。 | 返回：array of hwnd ### 示例 范例01：基本用法 ```tsl windows := sysGetWndOfCaption("Untitled - Notepad", true); echo ifArray(windows), "\n"; // 输出：1 ``` ## `sysLibCVersion()` 声明：function 获取系统中C语言支持库的版本 返回：string ### 示例 ```tsl // 获得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 ### 示例 ```tsl 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： ## `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： ## `uniffit(x, alpha)` 声明：function 根据样本x，x服从均匀分布，估计该分布的两个参数a,b | 参数 | 类型 | 说明 | | ------- | ------------- | ---------------------- | | `x` | array of real | 均匀分布样本，数字数组 | | `alpha` | real | 显著性水平，在0-1之间 | 返回：any ### 示例 ```tsl x := randunif(1, 10, 100); return uniffit(x, 0.05); // 输出：返回a, b的估计以及他们的在alpha的显著性水平下的区间估计 ``` ## `variationCoefficient(x)` 声明：function 变异系数。 | 参数 | 类型 | 说明 | | ---- | ----- | ------------ | | `x` | array | 一维数字数组 | 返回：real ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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： ```tsl // 源数据单位为1,dw=2,同时返回日收益率和转换后的复合收益率 t1 := array(('日期': 20180801T, '日收益率': 0.3), ('日期': 20180802T, '日收益率': 0.6), ('日期': 20180803T, '日收益率': 0.9)); r1 := ytmToAccumulativeYtm(t1, '日收益率', 2, 0); // 源数据单位为%,dw=3,同时返回日收益率和转换后的复合收益率 t2 := array(('日期': 20180801T, '日收益率(%)': 30), ('日期': 20180802T, '日收益率(%)': 60), ('日期': 20180803T, '日收益率(%)': 90)); r2 := ytmToAccumulativeYtm(t2, '日收益率(%)', 3, 0); return r1|r2; ``` 范例2： ```tsl // 计算基金OF000009易方达天天理财A的累计收益率(%) setSysParam(PN_Stock(), "OF000009"); t := array(('日期': 20150104T, '每万份基金单位收益': 4.3769), ('日期': 20150105T, '每万份基金单位收益': 1.2507), ('日期': 20150106T, '每万份基金单位收益': 1.4671)); r := ytmToAccumulativeYtm(t, '每万份基金单位收益', 5, 0); return r; ``` ## `abnormalData(y, flag, ystore)` 声明：function 数组中出现奇异值的处理。其中y为数据表，Flag为处理方法，Ystore为选择中位数和3倍标准差法返回被处理数据的数据。 | 参数 | 类型 | 说明 | | -------- | ------ | ------------------------------------------------------------ | | `y` | array | 一维数字数组 | | `flag` | string | 用户自定义，奇异值处理方法 | | `ystore` | array | 数据表类型，存放修改的数据，包括修改的行、原数值、处理后的值 | 返回：any ### 示例 示例：返回奇异值的位置及处理后的结果。 ```tsl 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 ### 示例 ```tsl 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：实数对比 ```tsl a := 0->9; return argconfirst(a, 3.5, 1); // 返回：4 ``` 范例2：数组对比 ```tsl 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 ### 示例 ```tsl x := array(9, 8, 10); return argmax(x); // 输出：2 ``` ## `argmin(x)` 声明：function 1、返回一维数组中最小值所在下标 | 参数 | 类型 | 说明 | | ---- | ---------------- | ------------ | | `x` | array,tablearray | 一维数字数组 | 返回：integer ### 示例 ```tsl x := array(3, 1, 9, 2); return argmin(x); // 1 ``` ## `argsort(value, sortdir)` 声明：function 返回可以用于排序的一维数组下标 | 参数 | 类型 | 说明 | | --------- | ------- | --------------------------------------- | | `value` | array | 一维数字数组，数组 | | `sortdir` | integer | 整数，排序方向（1:正序【默认】;0:逆序） | 返回：array ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl echo dataisequal(array("code": "A"), array("code": "A")); ``` ## `DataProcess_MF(arr, fwm)` 声明：function 极值处理(多因子),对数据表以列为单位处理奇异值。其中arr为数据表，fwm为处理方法。 | 参数 | 类型 | 说明 | | ----- | ------ | -------------------- | | `arr` | array | 数据表类型 | | `fwm` | string | 用户自定义，处理方法 | 返回：any ### 示例 ```tsl 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 ### 示例 ```tsl 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 ```tsl return decToInt("12"); // 输出: 12 ``` 范例02：十六进制格式字符串的转换 ```tsl return decToInt("0x12"); // 报错 return strToInt("0x12"); // 输出：18 ``` ## `decToInt32(s)` 声明：function 将字符串转换为32位整数。 | 参数 | 类型 | 说明 | | ---- | ------ | ---------------------- | | `s` | string | 字符串。需转换的字符串 | 返回：integer ### 示例 范例01 ```tsl return decToInt32("12"); // 输出: 12 ``` 范例02：十六进制格式字符串的转换 ```tsl return decToInt32("0x12"); // 报错 return strToInt32("0x12"); // 输出：18 ``` ## `decToInt32Def(s, default)` 声明：function 将字符串转换为32位整数。如果转换失败，则返回Default值。 | 参数 | 类型 | 说明 | | --------- | ------- | ---------------------------- | | `s` | string | 字符串。需转换的字符串 | | `default` | integer | 整数。转换失败时返回的默认值 | 返回：integer ### 示例 范例01 ```tsl return decToInt32Def("12", 1); // 输出: 12 return decToInt32Def("test", 1); // 输出: 1 ``` 范例02：十六进制格式字符串的转换 ```tsl return decToInt32Def("0x12", 1); // 输出: 1 return strToInt32Def("0x12", 1); // 输出：18 ``` ## `decToInt64(s)` 声明：function 将字符串转换为64位整数。 | 参数 | 类型 | 说明 | | ---- | ------ | ------------------------ | | `s` | string | 字符串。需转换的字符串。 | 返回：integer ### 示例 范例01： ```tsl return decToInt64("12"); // 输出: 12L ``` 范例02：十六进制格式字符串的转换 ```tsl return decToInt64("0x12"); // 报错 return strToInt64("0x12"); // 输出：18L ``` ## `decToInt64Def(s, default)` 声明：function 将字符串转换为64位整数。如果转换失败，则返回Default值。 | 参数 | 类型 | 说明 | | --------- | ------- | ---------------------------- | | `s` | string | 字符串。需转换的字符串 | | `default` | integer | 整数。转换失败时返回的默认值 | 返回：integer ### 示例 范例01 ```tsl return decToInt64Def("12", 1); // 输出: 12L return decToInt64Def("test", 1); // 输出: 1L ``` 范例02：十六进制格式字符串的转换 ```tsl return decToInt64Def("0x12", 1); // 输出: 1L return strToInt64Def("0x12", 1); // 输出：18L ``` ## `decToIntDef(s, default)` 声明：function 将字符串转换为整数。如果转换失败，则返回Default值。 | 参数 | 类型 | 说明 | | --------- | ------- | ---------------------------- | | `s` | string | 字符串。需转换的字符串 | | `default` | integer | 整数。转换失败时返回的默认值 | 返回：integer ### 示例 范例01 ```tsl return decToIntDef("12", 1); // 输出: 12 return decToIntDef("test", 1); // 输出: 1 ``` 范例02：十六进制格式字符串的转换 ```tsl return decToIntDef("0x12", 1); // 输出: 1 return strToIntDef("0x12", 1); // 输出：18 ``` ## `deleteColumnByField(t, fields)` 声明：function 删除指定列，可以一次性删除多列，删除的列字段之间使用；分割 | 参数 | 类型 | 说明 | | -------- | ------ | ------------------------------------------------------------------------ | | `t` | array | 指定数组，数据表列名为字符串类型，程序执行完后会变更为删除指定列后的数组 | | `fields` | string | 指定列，字符串 | 返回：array ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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: ```tsl load_dataset_iris(data); return describe(data); ``` 范例02: ```tsl return describe(randn(0, 1, 1000), array(0.05, 0.1)->0.95); ``` ## `devsqByColumn(t, f_name)` 声明：function 指定列平均值偏差的平方和 | 参数 | 类型 | 说明 | | -------- | ------ | -------- | | `t` | array | 数据表 | | `f_name` | string | 指定列名 | 返回：real ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl return divValue(8, 2); // 返回：4 ``` ## `dumies_decode(dumiesdata)` 声明：function 虚拟变量矩阵解构，根据所给的虚拟变量矩阵返回分类变量结果 | 参数 | 类型 | 说明 | | ------------ | ----- | -------------------------- | | `dumiesdata` | array | 二维数字数组，虚拟变量矩阵 | 返回：array ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl r_date := 20101231; return excelDateToInt(r_date); // 结果：20101231 ``` ## `excelIntToDate(r_date)` 声明：function 将报告期类型日期转化成实数型 | 参数 | 类型 | 说明 | | -------- | ------- | ------------------ | | `r_date` | integer | 整型类的报告期日期 | 返回：tdatetime ### 示例 ```tsl // 报告期为2010年年报 r_date := 20101231; return excelIntToDate(r_date); // 结果：40543 ``` ## `excelRDate(r_date)` 声明：function 将整数报告期转换成Excel的字符串日期类型 | 参数 | 类型 | 说明 | | -------- | ------- | -------------------------- | | `r_date` | integer | 报告期，一般用整型日期表示 | 返回：string ### 示例 ```tsl r_date := 20101231; return excelRDate(r_date); // 结果：2010-12-31 ``` ## `expandTable(t, key_field)` 声明：function 按指定字段展开表格，根据Keyfield展开指定列。展开的列值必须二维数据表，否则保留原值。 | 参数 | 类型 | 说明 | | ----------- | ------ | -------------------------------- | | `t` | array | 数组类型，数据 | | `key_field` | string | 字符串类型，关键字，需展开的列名 | 返回：array ### 示例 ```tsl // 按照分红送股列展开数据：分红送股列本身是子表，展开为多行 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3)); return fieldCount(t1); // 结果：2 ``` ## `fieldCountOfStrSubscript(t)` 声明：function 字符串下标数组的字段个数。 | 参数 | 类型 | 说明 | | ---- | ----- | ---------- | | `t` | array | 数据表类型 | 返回：integer ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));return fieldNames(t1); ``` ## `fieldNamesOfStrSubscript(t)` 声明：function 字符串下标数组的字段名称。 | 参数 | 类型 | 说明 | | ---- | ----- | ---- | | `t` | array | 整数 | 返回：any ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl t := array(1, 2, 12, 3.7, 14); return filterOneDimEx(t, 'IN', 2, 7); ``` ## `filterOneDimEx2(t, v1)` 声明：function 小于等于指定值的最后一条记录(一维数组)。 | 参数 | 类型 | 说明 | | ---- | ----- | ------------ | | `t` | array | 一维数字数组 | | `v1` | real | 实数，指定值 | 返回：real ### 示例 ```tsl s := array(1, 2, 3, 4, 5, 6); return filterOneDimEx2(s, 4); // 返回：4 ``` ## `filterTable(t, v)` 声明：function 从指标表中取以下列的值为v的数据： | 参数 | 类型 | 说明 | | ---- | ------- | ------------------ | | `t` | array | 数组类型，数据 | | `v` | integer | 报告期类型，报告期 | 返回：array ### 示例 ```tsl // '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 ### 示例 ```tsl 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 ### 示例 ```tsl return floatN(12.6578, 2); // 结果：12.66 ``` ## `floatToStrEx(r, n)` 声明：function 浮点->字符串 | 参数 | 类型 | 说明 | | ---- | ------- | ------------------------ | | `r` | real | 实数 | | `n` | integer | 整型数据，保留的小数位数 | 返回：string ### 示例 ```tsl return floatToStrEx (12.6578, 2); // 结果：’ 12.66’ ``` ## `floatToStrne(value)` 声明：function 将实数转换成字符串类型。和FloatToStr的区别：在处理浮点数据时，FloatToStrne的结果不会输出为1E15等格式 | 参数 | 类型 | 说明 | | ------- | ---- | ---- | | `value` | real | 实数 | 返回：string ### 示例 ```tsl return floatToStrne(23.4); // 输出字符串："23.4" return floatToStrne(1E15); // 大数量级数据，输出："1000000000000000" ``` ## `floatToStrneW(value)` 声明：function 将实数转换成宽字节字符串类型。和FloatToStrW的区别：在处理大数量级数据（如1E15、10^15等）时，FloatToStrneW的结果不会输出为1E15等格式。 | 参数 | 类型 | 说明 | | ------- | ---- | ---- | | `value` | real | 实数 | 返回：string ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl return formatFloatExt(12345.67, 1); // 结果：’ 12,345.67’ return formatFloatExt("123"); // 结果：’ -’ ``` ## `formatStrExt(s)` 声明：function 判断字符串是否是字符串，不是字符串的显示为“-” | 参数 | 类型 | 说明 | | ---- | ------ | ------ | | `s` | string | 字符串 | 返回：string ### 示例 ```tsl return formatStrExt('aaaaa'); // 结果：’aaaaa’ return formatStrExt(123); // 结果：’-’ ``` ## `formatStrToDateTime2(s, format_str)` 声明：function 字符串->日期时间(包含毫秒)。 | 参数 | 类型 | 说明 | | ------------ | ------ | ---------------------- | | `s` | string | 字符串类型，时间字符串 | | `format_str` | string | 字符串类型，格式字符串 | 返回：datetime ### 示例 ```tsl // 字符串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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl a := ones(3,3); b := ones(2,3); frameconcat(array(a,b)); ``` ## `framecorrel(data)` 声明：function 数据表-相关系数矩阵 | 参数 | 类型 | 说明 | | ------ | ----- | ----------------------------------------------- | | `data` | table | Table,二维数据表，列名可为字符串,不支持一维数组 | 返回：array ### 示例 ```tsl 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 ### 示例 ```tsl 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： ```tsl 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 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl data := array((nan, 8), (1, 3)); echo trim(toStn(Framedrop_na(data, "any", array(0)))); ``` ## `frameGetSubByReg(data, reg)` 声明：function 通过正则表达式匹配获取数据框子集 | 参数 | 类型 | 说明 | | ------ | ------ | -------------------------- | | `data` | array | 数组，待匹配的数组 | | `reg` | string | 字符串，间隔名，正则匹配串 | 返回：array ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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： ```tsl 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 ```tsl // 多字段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 ```tsl // 只更名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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl // 使用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 ### 示例 ```tsl // 使用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 ```tsl return fuzzyCompare(fzCosine(), "kitten", "sitting"); // 返回：0.365148371670111 ``` 范例二：FuzzyCompareEx相似性计算，指定字符切分长度为1 ```tsl 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相似性计算 ```tsl return fuzzyCompare(fzEditDistance(), "kitten", "sitting"); // 返回：0.571428571428571 ``` 范例一：FuzzyCompareEx相似性计算 ```tsl 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相似性计算 ```tsl return fuzzyCompare(fzHammingDistance(), "kitten", "sitting"); // 返回：0.571428571428571 ``` 范例二：FuzzyCompareEx相似性计算 ```tsl 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 ```tsl return fuzzyCompare(fzJaccard(), "kitten", "sitting"); // 返回：0.222222222222222 ``` 范例二：FuzzyCompareEx相似性计算，指定字符切分长度为1 ```tsl 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相似性计算 ```tsl return fuzzyCompare(fzJaroWinkler(), "kitten", "sitting"); // 返回：0.746031746031746 ``` 范例二：FuzzyCompareEx相似性计算 ```tsl return fuzzyCompareEx(fzJaroWinkler(), "kitten", "sitting", n, nret); // 返回：0.746031746031746 ``` ## `fzLongestSequnce()` 声明：function Longest Sequnce（最长公共子序列）算法类型：找出两字符串中顺序相同但不必连续的最长子序列 返回：integer ### 示例 范例一：FuzzyCompare相似性计算 ```tsl return fuzzyCompare(fzLongestSequnce(), "kitten", "sitting"); // 返回：0.571428571428571 ``` 范例二：FuzzyCompareEx相似性计算 ```tsl 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相似性计算 ```tsl return fuzzyCompare(fzLongestSubstring(), "kitten", "sitting"); // 返回：0.428571428571429 ``` 范例二：FuzzyCompareEx相似性计算 ```tsl 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 ```tsl return fuzzyCompare(fzSimHash(), "kitten", "sitting"); // 返回：0.640625 ``` 范例二：FuzzyCompareEx相似性计算，特征词数量为1 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl echo trim(toStn(get_dummies2(array("A", "A", "B", "C")))); ``` ## `getBottomN(t, n)` 声明：function 取数组后N行，一般先用SortByField排序，然后使用此函数 | 参数 | 类型 | 说明 | | ---- | ------- | ------ | | `t` | array | 数据表 | | `n` | integer | 整数 | 返回：array ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl sl := getPyStringList(); return sl.values("明"); // 返回：M ``` ## `getSubField(t, field)` 声明：function 取表中某一字段的全部列值 | 参数 | 类型 | 说明 | | ------- | ------ | ------------------- | | `t` | array | 二维数组 | | `field` | string | 列标名，字符串/整数 | 返回：array ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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： ```tsl 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 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 范例一： ```tsl 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 生成的是随机正态样本，各区间的频数、频率(%)、累计频率(%)每次运行都不同。 ``` 范例二： ```tsl 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 ### 示例 ```tsl return hztoPy("华夏优势"); // HXYS return hztoPy("华夏盛势"); // HXCS HXSS ``` ## `ifsparse(s)` 声明：function 判断是否为稀疏矩阵。检查条件：只检查下标，下标全为大于等于0的整数。 | 参数 | 类型 | 说明 | | ---- | ------------- | ---------- | | `s` | array of real | 待判断矩阵 | 返回：integer ### 示例 ```tsl // 判断矩阵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 ### 示例 ```tsl a := array(1, 2, 3, 4); return in1(a, 3); // 结果：1 ``` ## `incHalfYear(a_value, number)` 声明：function 求Avalue的日期开始往后推移Number个半年的日期 | 参数 | 类型 | 说明 | | --------- | --------- | -------------------------------- | | `a_value` | tdatetime | 实数表示的日期 | | `number` | integer | 向后推移的整数，负数表示向前推移 | 返回：tdatetime ### 示例 ```tsl 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 ### 示例 ```tsl 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： ```tsl // 向一维数组指定位置插入一个字符串’aaa’ t := 43456->43460; index := 2; r_data := 'aaa'; return inserttablebyrno(t, index, r_data); // 结果：array(43456,43457,"aaa",43458,43459,43460) ``` 范例2： ```tsl // 向一维数组第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： ```tsl // 向二维数组第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： ```tsl // 向二维数组第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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl return letters(1, 0); // 结果：a ``` ## `maxValueByColumn(t, f_name)` 声明：function 求指定列中的最大值 | 参数 | 类型 | 说明 | | -------- | ------ | -------- | | `t` | array | 数据表 | | `f_name` | string | 指定列名 | 返回：real ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl return noRecordTable(); // 结果：Array() ``` ## `normalTabletoStrSubscript(t, key_field)` 声明：function 索引下标数组-->字符串下标数组。将keyfield列的值变为行标。 | 参数 | 类型 | 说明 | | ----------- | ------ | ------------ | | `t` | array | 数据表类型 | | `key_field` | string | 字符串，列名 | 返回：any ### 示例 ```tsl s := nDay(10, 'time', dateToStr(sp_time()), 'close', close()); return normalTabletoStrSubscript(s, 'time'); // 把 time列的数据变为行标 ---变为--》 ``` ## `outPutTableToCanBeUnderstood(t)` 声明：function 判断一个数据表是否是空值，如果是则返回'返回结果为空'，否则返回该数组。 | 参数 | 类型 | 说明 | | ---- | ----- | -------------- | | `t` | array | 数组，数据表。 | 返回：string|array ### 示例 ```tsl 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 ### 示例 ```tsl return parseRegExpr3("abcdeak", "ab", "kkkk", "ir"); // 结果：kkkkcdeak ``` ## `passwordGen(len, n, head, start)` 声明：function 密码生成器 | 参数 | 类型 | 说明 | | ------- | ------- | ------------------------------------ | | `len` | integer | 整数，密码长度 | | `n` | integer | 整数，生成的密码组合数 | | `head` | string | 字符串，用户名的前缀 | | `start` | integer | 整数，用户名的后缀序列数字的起始数字 | 返回：array ### 示例 ```tsl return rdo2 passwordGen(8, 5, 'ts', 3); // 返回: ``` ## `percentValueByField(t, key_field, quart)` 声明：function 数据集在指定百分位数上对应的数值 | 参数 | 类型 | 说明 | | ----------- | ------ | ---------------- | | `t` | array | 数据表 | | `key_field` | string | 指定列名，字符串 | | `quart` | real | 指定分位数，实数 | 返回：real ### 示例 ```tsl 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 ### 示例 ```tsl // 行标为日期、列标为名称，值为收盘价和涨幅的数据透视表 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl echo trim(toStn(QKsplit_Trailing(20100101T, 20110101T, nil, nil, nil, 2))); ``` ## `quickIntersectionPart(v, w)` 声明：function 快速求交集 | 参数 | 类型 | 说明 | | ---- | ----- | ---- | | `v` | array | 数组 | | `w` | array | 数组 | 返回：array ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl // 从字符串数组中有放回随机抽取 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl // 对涨幅列进行排名，结果新增“涨幅(%)排名”列，并按排名升序重排 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl // 给随机数组批量加后缀 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 ### 示例 ```tsl return replaceStrByReg("abcdeak", "A", "kkkk"); // 结果：abcdeak ``` ## `replaceTextByReg(s, reg_from_text, to_text)` 声明：function 正则表达式快速字符串替换，大小写不敏感。 | 参数 | 类型 | 说明 | | --------------- | ------ | -------------------------------- | | `s` | string | 字符串。源串 | | `reg_from_text` | string | 字符串。待替换的部分，正则表达式 | | `to_text` | string | 字符串。替换的字符串 | 返回：string ### 示例 ```tsl return replaceTextByReg("abcdeak", "a", "kkkk"); // 结果：kkkkbcdekkkkk ``` ## `reverse(arr)` 声明：function 数组倒置反向。 | 参数 | 类型 | 说明 | | ----- | ----- | ---- | | `arr` | array | 数组 | 返回：array ### 示例 ```tsl 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 ### 示例 ```tsl t := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 4)); return rotateTable(t); ``` ## `roundTo5(v)` 声明：function .5处理 | 参数 | 类型 | 说明 | | ---- | ---- | ---- | | `v` | real | 实数 | 返回：real ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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：数字插入 ```tsl v := array(1, 2, 3, 4, 5, 6); return searchsorted(v, 3.5); // 返回：3 ``` 范例2：字符串插入 ```tsl v := array("SH600001", "SH600004", "SH600050", "SH600305"); return searchsorted(v, "SH600049"); // 返回：2 ``` ## `seekPosInArray(r, arr)` 声明：function 数字定位，采用二分法寻找数字R在一位正序数字数组arr中的下标。 | 参数 | 类型 | 说明 | | ----- | ----- | ------------ | | `r` | real | 实数 | | `arr` | array | 一维数字数组 | 返回：integer ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 统计分布相关函数。 | 参数 | 类型 | 说明 | | ------ | ----- | ---- | | `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 统计分布相关函数。 | 参数 | 类型 | 说明 | | ------ | ----- | ---- | | `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 统计分布相关函数。 | 参数 | 类型 | 说明 | | ------ | ----- | ---- | | `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 ### 示例 ```tsl // 生成数据表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 ### 示例 ```tsl // 生成数据表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 ### 示例 ```tsl 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 ### 示例 ```tsl // 生成数据表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，数组。 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 范例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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl // 将矩阵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 ### 示例 ```tsl // 根据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 ### 示例 ```tsl // 将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 ### 示例 ```tsl 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 ### 示例 ```tsl // 提取矩阵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 ### 示例 ```tsl // 提取矩阵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 ### 示例 ```tsl // 将矩阵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 ### 示例 ```tsl // 根据对角矩阵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 ### 示例 ```tsl // 创建m*m稀疏单位矩阵 a := speye(4); return a; // 输出： // array( // (1), // (1:1), // (2:1), // (3:1)) ``` ## `spnnz(s)` 声明：function 稀疏矩阵S中的非零元素数目 | 参数 | 类型 | 说明 | | ---- | ------------- | -------- | | `s` | array of real | 稀疏矩阵 | 返回：integer ### 示例 ```tsl // 稀疏正态随机矩阵A中非零元素数目 a := sprandn2(5, 5, 0.2); return spnnz(a); // 返回4（随机） ``` ## `spnonzeros(s)` 声明：function 提取稀疏矩阵S中的非零元素 | 参数 | 类型 | 说明 | | ---- | ------------- | -------- | | `s` | array of real | 稀疏矩阵 | 返回：array ### 示例 ```tsl // 提取稀疏正态随机矩阵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 ### 示例 ```tsl // 将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 ### 示例 ```tsl // 创建与矩阵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 ### 示例 ```tsl // 创建10*10稀疏均匀随机矩阵 a := sprand2(10, 10, 0.3); return a; // 输出：10*10 稀疏矩阵，约 30% 位置非零，非零元素为 (0,1) 均匀随机数。 // 非零位置与数值每次运行都不同。 ``` ## `sprandn1(s)` 声明：function 创建与矩阵S结构相同的稀疏格式矩阵，并将其中的非零元素替换为正态分布随机数 | 参数 | 类型 | 说明 | | ---- | ------------- | -------- | | `s` | array of real | 稀疏矩阵 | 返回：array ### 示例 ```tsl // 创建与矩阵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 ### 示例 ```tsl // 创建10*10稀疏正态随机矩阵 a := sprandn2(10, 10, 0.2); return a; // 输出：10*10 稀疏矩阵，约 20% 位置非零，非零元素为标准正态随机数。 // 非零位置与数值每次运行都不同。 ``` ## `sprandsym1(s)` 声明：function 创建与矩阵S结构相同的稀疏格式矩阵，以下三角矩阵为基准的对称正态分布随机矩阵 | 参数 | 类型 | 说明 | | ---- | ------------- | -------- | | `s` | array of real | 稀疏矩阵 | 返回：array ### 示例 ```tsl // 创建与矩阵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 ### 示例 ```tsl // 创建10*10对称稀疏正态随机矩阵 a := sprandsym2(10, 0.2); return a; // 输出：10*10 对称稀疏矩阵，约 20% 位置非零，以下三角为基准对称，非零元素为正态随机数。 // 非零位置与数值每次运行都不同。 ``` ## `startOfTheHalfYear(end_t)` 声明：function 返回Endt所在半年的开始日期（半年的第一天） | 参数 | 类型 | 说明 | | ------- | --------- | ---- | | `end_t` | tdatetime | 日期 | 返回：tdatetime ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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。 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl // 字符串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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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`。 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl echo tostring(123.45); ``` ## `totalStrToSeprate(s)` 声明：function 把用#分割的字符串转换为;分割 | 参数 | 类型 | 说明 | | ---- | ------ | ------ | | `s` | string | 字符串 | 返回：string ### 示例 ```tsl return totalStrToSeprate ('债券型#现金型#配置型#股票型#保本型'); // 结果：’债券型;现金型;配置型;股票型;保本型’ ``` ## `tryDecToInt(s, value)` 声明：function 将字符串转换为整数。若转换成功，转换值通过Value输出。 | 参数 | 类型 | 说明 | | ------- | ------------ | ----------------------------------------------- | | `s` | string | 字符串。需转换的字符串 | | `value` | integer\|nil | 变参。转换成功，为转换后的整数；否则，为NIL值。 | 返回：bool ### 示例 范例01：转换成功 ```tsl ret := tryDecToInt("12", value); if ret then return value; else return "转换失败！"; // 输出: 12 ``` 范例02：转换失败 ```tsl ret := tryDecToInt("test", value); if ret then return value; else return "转换失败！"; // 输出: "转换失败！" ``` 范例03：十六进制格式字符串的转换 ```tsl 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：转换成功 ```tsl ret := tryDecToInt32("12", value); if ret then return value; else return "转换失败！"; // 输出: 12 ``` 范例02：转换失败 ```tsl ret := tryDecToInt32("test", value); if ret then return value; else return "转换失败！"; // 输出: "转换失败！" ``` 范例03：十六进制格式字符串的转换 ```tsl 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：转换成功 ```tsl ret := tryDecToInt64("12", value); if ret then return value; else return "转换失败！"; // 输出: 12L ``` 范例02：转换失败 ```tsl ret := tryDecToInt64("test", value); if ret then return value; else return "转换失败！"; // 输出: "转换失败！" ``` 范例03：十六进制格式字符串的转换 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 多语言支持函数相关函数。 返回：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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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 ### 示例 ```tsl 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)) ```