#if !defined(__E_STATIC_LIB)
#include "include_ecalc_header.h"

//TODO 静态库需要的部分,会记录所有的函数名到数组里,静态编译的时候需要取回命令名
static ARG_INFO g_argumentInfo_ecalc_global_var[] = 
{
    // 1=参数名称, 2=参数详细解释, 3=指定图像索引,从1开始,0表示无, 4=图像数目(用作动画)
    // 5=参数类型, 6=参数默认值,   7=参数标志 AS_ 开头常量
    // AS_HAS_DEFAULT_VALUE         有默认值,倒数第二个参数是默认值
    // AS_DEFAULT_VALUE_IS_EMPTY    默认值为空,有可空标志
    // AS_RECEIVE_VAR               只能传递变量,相当于传引用,传递过来的肯定不是数组
    // AS_RECEIVE_VAR_ARRAY         传递过来的肯定是数组变量引用
    // AS_RECEIVE_VAR_OR_ARRAY      传递变量或者数组变量引用
    // AS_RECEIVE_ARRAY_DATA        传递数组
    // AS_RECEIVE_ALL_TYPE_DATA     传递数组/非数组
    // AS_RECEIVE_VAR_OR_OTHER      可以传递 变量/数据/返回值数据



    /*000*/ {"复数数据1", "该参数提供参与计算的复数数据1，例如：复数1 + 复数2，本参数提供复数1", 0, 0, MAKELONG(0x01, 0), 0, NULL},
    /*001*/ {"复数数据2", "该参数提供参与计算的复数数据2，例如：复数1 + 复数2算式，本参数提供复数2", 0, 0, MAKELONG(0x01, 0), 0, NULL},

    /*002*/ {"复数数据1", "该参数提供参与计算的复数数据1，例如：复数1 + 复数2，本参数提供复数1", 0, 0, MAKELONG(0x01, 0), 0, NULL},
    /*003*/ {"复数数据2", "该参数提供参与计算的复数数据2，例如：复数1 + 复数2算式，本参数提供复数2", 0, 0, MAKELONG(0x01, 0), 0, NULL},

    /*004*/ {"复数数据1", "该参数提供参与计算的复数数据1，例如：复数1 + 复数2，本参数提供复数1", 0, 0, MAKELONG(0x01, 0), 0, NULL},
    /*005*/ {"复数数据2", "该参数提供参与计算的复数数据2，例如：复数1 + 复数2算式，本参数提供复数2", 0, 0, MAKELONG(0x01, 0), 0, NULL},

    /*006*/ {"复数数据1", "该参数提供参与计算的复数数据1，例如：复数1 + 复数2，本参数提供复数1", 0, 0, MAKELONG(0x01, 0), 0, NULL},
    /*007*/ {"复数数据2", "该参数提供参与计算的复数数据2，例如：复数1 + 复数2算式，本参数提供复数2", 0, 0, MAKELONG(0x01, 0), 0, NULL},

    /*008*/ {"复数数据", "该参数提供需要参与计算的复数数据", 0, 0, MAKELONG(0x01, 0), 0, NULL},

    /*009*/ {"要设置的数据", "要设置的数据，实数部分或虚数部分", 0, 0, SDT_DOUBLE, 0, NULL},

    /*010*/ {"实数矩阵1", "参与运算的实数矩阵1", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*011*/ {"实数矩阵2", "参与运算的实数矩阵2", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},

    /*012*/ {"复数矩阵1", "参与运算的复数矩阵1", 0, 0, MAKELONG(0x01, 0), 0, AS_RECEIVE_ARRAY_DATA},
    /*013*/ {"复数矩阵2", "参与运算的复数矩阵2", 0, 0, MAKELONG(0x01, 0), 0, AS_RECEIVE_ARRAY_DATA},

    /*014*/ {"实数矩阵1", "参与运算的实数矩阵1", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*015*/ {"实数矩阵2", "参与运算的实数矩阵2", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},

    /*016*/ {"复数矩阵1", "参与运算的复数矩阵1", 0, 0, MAKELONG(0x01, 0), 0, AS_RECEIVE_ARRAY_DATA},
    /*017*/ {"复数矩阵2", "参与运算的复数矩阵2", 0, 0, MAKELONG(0x01, 0), 0, AS_RECEIVE_ARRAY_DATA},

    /*018*/ {"实数矩阵", "该实数矩阵必须是一个正方型矩阵", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*019*/ {"保留参数", NULL, 0, 0, SDT_DOUBLE, 0, AS_DEFAULT_VALUE_IS_EMPTY | AS_RECEIVE_VAR},

    /*020*/ {"复数矩阵", "该复数矩阵必须是一个正方型矩阵", 0, 0, MAKELONG(0x01, 0), 0, AS_RECEIVE_ARRAY_DATA},
    /*021*/ {"行列式", NULL, 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_VAR},

    /*022*/ {"实数矩阵", "该参数提供将被转置的矩阵", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},

    /*023*/ {"复数矩阵", "该参数提供将被转置的复数矩阵", 0, 0, MAKELONG(0x01, 0), 0, AS_RECEIVE_ARRAY_DATA},

    /*024*/ {"实数矩阵", "该参数为一个正方形实数矩阵", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*025*/ {"向量", "该参数是一维数组，列数和第一个参数一样，返回第一个参数矩阵的特征值向量", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*026*/ {"返回实数矩阵", "该参数数组是维数和行列数和第一个参数一样的矩阵，它的列是原始矩阵的eigenvectors", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*027*/ {"记数", "包含完成迭代的最大迭代次数，它返回完成迭代的实际迭代次数", 0, 0, SDT_INT, 0, AS_RECEIVE_VAR},
    /*028*/ {"收敛标志", "通过该参数判断是否收敛成功", 0, 0, SDT_BOOL, 0, AS_RECEIVE_VAR},

    /*029*/ {"实数矩阵", "提供一个二维数组", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*030*/ {"标量操作数", "定义一个标量操作数", 0, 0, SDT_DOUBLE, 0, NULL},

    /*031*/ {"复数矩阵", "二维复数数组", 0, 0, MAKELONG(0x01, 0), 0, AS_RECEIVE_ARRAY_DATA},
    /*032*/ {"标量操作数", "包含标量错误数，同样也是复数类型", 0, 0, MAKELONG(0x01, 0), 0, NULL},

    /*033*/ {"数据集实值", "该参数是维数为\"数据点数\"的向量。假设本参数是xr[维数]数组，抽样数据集的实值包含从xr[1]起始的数组xr中。它返回数组xr中FFT调和函数的余弦系数。其中,xr[1]保存了DC分量,xr[2]保存了第1个谐波,xr[3]保存了第2个谐波，依次类推。系数与采样数据集中数据点的个数有关。对每一调和项a(i) * cos(...)的实际余弦函数用numdat / 2 除", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*034*/ {"数据集虚值", "该参数是维数为\"数据点数\"的向量，数据集的假设本参数是yi[维数]数组虚值包含从yi[1]起始的yi中。它返回yi中FFT调和函数的正弦系数 - 其中yi[2]保存第1个谐波，yi[3]保存了第2个谐波，依次类推。系数与采样数据集中数据点个数有关。对调和项a(i)sin(...)的实际正弦系数用numdat / 2 除", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*035*/ {"数据点数", "包含了在前两个参数中数据点的个数", 0, 0, SDT_INT, 0, NULL},

    /*036*/ {"数据集实值", "该参数是维数为\"数据点数\"的向量。假设本参数是xr[维数]数组，抽样数据集的实值包含从xr[1]起始的数组xr中。它返回数组xr中FFT调和函数的余弦系数。其中,xr[1]保存了DC分量,xr[2]保存了第1个谐波,xr[3]保存了第2个谐波，依次类推。系数与采样数据集中数据点的个数有关。对每一调和项a(i) * cos(...)的实际余弦函数用numdat / 2 除", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*037*/ {"数据集虚值", "该参数是维数为\"数据点数\"的向量，数据集的假设本参数是yi[维数]数组虚值包含从yi[1]起始的yi中。它返回yi中FFT调和函数的正弦系数 - 其中yi[2]保存第1个谐波，yi[3]保存了第2个谐波，依次类推。系数与采样数据集中数据点个数有关。对调和项a(i)sin(...)的实际正弦系数用numdat / 2 除", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*038*/ {"数据点数", "包含了在前两个参数中数据点的个数", 0, 0, SDT_INT, 0, NULL},

    /*039*/ {"数据集实值", "本参数是列数为\"数据点数\"的向量，假设本参数为xr[维数]数组，它包含了从xr[1]处起始的在xr中抽样数据集的实值，并返回带有窗口的xr值", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*040*/ {"数据集虚值", "本参数是列数为\"数据点数\"的向量，假设本参数为yi[维数]数组，它包含了从yi[1]处起始的在yi中的抽样数据集的虚值，并返回带有窗口的yi值", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*041*/ {"数据点数", "包含在前两个参数中的数据点个数", 0, 0, SDT_INT, 0, NULL},
    /*042*/ {"抽样数据窗口", "包含应用于抽样数据的窗口，为以下常量之一：0、#矩形Window；1、#Parzen Window2、#Hanning Window；3、#Welch Window；4、#Hamming Window；5、#Exact Blackman Window", 0, 0, SDT_INT, 0, NULL},

    /*043*/ {"数据集实值", "该参数为二维数组，它包含了从数组起始数据中的抽样数据的实值，并返回FFT调和函数的余弦系数", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*044*/ {"数据集虚值", "该数组的维数、行列数是和前一个参数一样的数组，它包含了从数组起始到本数组中的抽样数据的虚值，并返回FFT调和系数的正弦余数", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*045*/ {"标志", "真表示反变换，假表示正变换", 0, 0, SDT_BOOL, 0, NULL},

    /*046*/ {"数据集实值", "一维数组向量，假设本参数为xr[维数]数组，它包含xr中从xr[1]处起始的抽样数据的实值，并返回原始数据(从xr[1]到xr[numdat/2] - 1的有效数据)的能谱", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*047*/ {"数据集虚值", "该数组的维数、行列数是和前一个参数一样的数组，假设该参数为yi[维数]数组，它包含从yi中yi[0]起始的抽样数据的虚值，并返回能谱调和函数(从yi[1]到yi[numdat/2] - 1的有效数据)的频率值", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*048*/ {"时间间隔", "包含了前两个参数数据集中样本之间的时间间隔", 0, 0, SDT_DOUBLE, 0, NULL},

    /*049*/ {"浮点向量", "一维数组，它保存离散样本集", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*050*/ {"样本区间", "定义采样数据集之间的样本区间", 0, 0, SDT_DOUBLE, 0, NULL},
    /*051*/ {"积分下限", "积分的下限，本参数为大于等于0且小于等于\"浮点向量\"参数数组下标数减1的整数，该参数必须小于参数\"积分上限\"，否则将出错", 0, 0, SDT_INT, 0, NULL},
    /*052*/ {"积分上限", "积分的上限，本参数为大于等于0且小于等于\"浮点向量\"参数数组下标数减1的整数，该参数必须大于参数\"积分下限\"", 0, 0, SDT_INT, 0, NULL},

    /*053*/ {"样本区间", "数据集的样本区间，该参数必须为正整数，否则将出错", 0, 0, SDT_INT, 0, NULL},
    /*054*/ {"积分下限", "积分下限，该参数必须小于参数\"积分上限\"，否则将出错", 0, 0, SDT_DOUBLE, 0, NULL},
    /*055*/ {"积分上限", "积分上限，该参数必须大于参数\"积分下限\"，否则将出错", 0, 0, SDT_DOUBLE, 0, NULL},

    /*056*/ {"x已知值", "包含x的已知值", 0, 0, SDT_DOUBLE, 0, NULL},
    /*057*/ {"y已知值", "包含y的已知值", 0, 0, SDT_DOUBLE, 0, NULL},
    /*058*/ {"要求解的x", "包含要求解的x的值", 0, 0, SDT_DOUBLE, 0, NULL},
    /*059*/ {"允许误差", "保存允许误差，若误差估计小于 (et * h) / 32，则步长(后一个参数)在函数中使用时加倍，若误差估计大于 (本参数 * 步长)时，则步长减半", 0, 0, SDT_DOUBLE, 0, NULL},
    /*060*/ {"初始步长", "包含用从已知x值迭代到x的初始步长", 0, 0, SDT_DOUBLE, 0, NULL},
    /*061*/ {"最小步长", "包含最小步长(若步长小于本参数，则函数退出)，本参数必须为大于0的数", 0, 0, SDT_DOUBLE, 0, NULL},
    /*062*/ {"y的估值", "返回y的估值", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_VAR},
    /*063*/ {"状态", "若x值已被求解，则返回真；若在解出步长前已小于最小步长，则返回假", 0, 0, SDT_BOOL, 0, AS_RECEIVE_VAR},

    /*064*/ {"原数据", "必须是二维数组", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*065*/ {"最小值", "该参数为宽度和\"原数据\"高度一样的一维数组，它返回\"原数据\"中每一列数据的最小值", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*066*/ {"最大值", "该参数为宽度和\"原数据\"高度一样的一维数组，它返回\"原数据\"中每一列数据的最大值", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*067*/ {"范围值", "该参数为宽度和\"原数据\"高度一样的一维数组，它返回\"原数据\"中每一列数据的最大值和最小值的差", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*068*/ {"总和", "该参数为宽度和\"原数据\"高度一样的一维数组，它返回\"原数据\"中每一列数据的和", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*069*/ {"平均值", "该参数为宽度和\"原数据\"高度一样的一维数组，它返回\"原数据\"中每一列数据的平均值", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*070*/ {"方差值", "该参数为宽度和\"原数据\"高度一样的一维数组，它返回\"原数据\"中每一列数据的方差值", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*071*/ {"标准偏差值", "该参数为宽度和\"原数据\"高度一样的一维数组，它返回\"原数据\"中每一列数据的标准偏差值", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*072*/ {"标准误差", "该参数为宽度和\"原数据\"高度一样的一维数组，它返回\"原数据\"中每一列数据平均值的标准误差", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*073*/ {"众数值", "该参数为宽度和\"原数据\"高度一样的一维数组，它返回\"原数据\"中每一列数据的众数值", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},

    /*074*/ {"x变量系数", "该参数是一个二维正方形数组，数组宽度和高度相等，宽度和高度必须小于等于50，它保存x变量系数的方阵，该参数数组的数据必须提供全部不为0的数值，否则本方法将失败", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*075*/ {"y向量", "该参数是列数和前一个参数一样的一维数组", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*076*/ {"x变量解", "列数和第一个参数一样的一维数组", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*077*/ {"x变量系数逆阵", "和第一个参数行列数一样的二维数组，它保存x变量系数矩阵的逆阵", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*078*/ {"x矩阵行列式", "返回x变量系数矩阵的行列式", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_VAR},

    /*079*/ {"x变量系数", "二维数组。行表示方程的系数，列表示x变量的系数", 0, 0, MAKELONG(0x01, 0), 0, AS_RECEIVE_ARRAY_DATA},
    /*080*/ {"y向量", "列数和第一个参数一样的一维数组", 0, 0, MAKELONG(0x01, 0), 0, AS_RECEIVE_ARRAY_DATA},
    /*081*/ {"x变量解", "列数和第一个参数一样的一维数组，它是保存复数x变量的解向量- [1]表示值x0,[2]表示值x1,依次类推", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*082*/ {"x变量系数逆阵", "行列数和第一个参数一样的二维数组，它保存x变量系数矩阵的逆阵", 0, 0, MAKELONG(0x01, 0), 0, AS_RECEIVE_ARRAY_DATA},
    /*083*/ {"x矩阵行列式", "返回x变量系数矩阵的总行列式", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_VAR},

    /*084*/ {"原始数据", "该参数是二维数组，保存被分析的原始数据", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*085*/ {"x矩阵行列式", "列数和第一个参数行数一样的一维数组", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*086*/ {"回归方程系数", "该参数为列数和第一个参数一样的一维数组，它返回计算出来的回归方程系数", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*087*/ {"y估值", "该参数为列数与第一个参数行数一样的二维数组，它返回用回归系数计算的y的估值", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*088*/ {"残差值", "该参数为列数与第一个参数行数一样的二维数组，它返回残差值(y的估值与y的观察值之差)", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*089*/ {"标准误差", "返回估计的标准误差", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_VAR},
    /*090*/ {"估计标准误差", "该参数是列数与第一个参数一样的一维数组，它返回系数估计的标准误差", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*091*/ {"r平方值", "返回r平方值 - 样本确定系数", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_VAR},
    /*092*/ {"r值", "返回r值 - 样本相关系数", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_VAR},
    /*093*/ {"是否回归矩阵奇异", "如果回归矩阵奇异，则返回一个非\"0\"值，否则返回\"0\"", 0, 0, SDT_INT, 0, AS_RECEIVE_VAR},

    /*094*/ {"独立变量观察值", "该参数是一个一维数组，保存独立变量的观察值", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*095*/ {"相关变量观察值", "该参数为列数和第一个参数一样的一维数组，它保存相关变量的观察值", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*096*/ {"多项式系数", "该参数是列数小于第一个参数的一维数组，它保存拟合多项式的系数，数组第1个成员保存常数，数组第2个成员保存x ^ 1的系数，数组第3个成员保存x ^ 2的系数，依此类推", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*097*/ {"y估值", "该参数为列数和第一个参数一样的一维数组，它返回用多项式系数计算的y的估值", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*098*/ {"残差值", "返回残差值。", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*099*/ {"标准误差", "返回估计的标准误差", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_VAR},
    /*100*/ {"估计标准误差", "该参数为列数和\"多项式系数\"一样的一维数组，它返回系数估计的标准误差", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*101*/ {"r平方值", "返回r平方值 - 样本确定系数", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_VAR},
    /*102*/ {"r值", "返回r值 - 样本相关系数", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_VAR},
    /*103*/ {"是否奇异", "如果曲线拟合矩阵奇异则返回1", 0, 0, SDT_INT, 0, AS_RECEIVE_VAR},

    /*104*/ {"x值", "该参数是一个一维数组，它保存离散数据的x值", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*105*/ {"y值", "该参数是列数和第一个参数一样的一维数组，它保存离散数据集的y值", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*106*/ {"三次样条方程系数", "该参数是行数和第一个参数列数一样，列数为4的二维数组，它返回每个子区间上三次样条方程的系数", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},

    /*107*/ {"x值", "该参数为一维数组，它保存离散数据集的x值。用来确定在计算过程中使用哪个样条区间", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*108*/ {"三次样条方程系数", "该参数是行数和第一个参数一样，列数为4的二维数组。它保存每个子区间的三次样条方程的系数", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_ARRAY_DATA},
    /*109*/ {"插值x", "包含在插值中使用的x值", 0, 0, SDT_DOUBLE, 0, NULL},
    /*110*/ {"y值", "被计算的y值", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_VAR},

    /*111*/ {"x", NULL, 0, 0, SDT_DOUBLE, 0, NULL},

    /*112*/ {"欲求Gamma的值", "欲求Gamma的值", 0, 0, SDT_DOUBLE, 0, NULL},
    /*113*/ {"错误码", "可为以下常量之一：0、#无错误；1、#参数必须是一个不为0的数字；2、#参数不能为负数；3、#多项式序号必须大于0；4、#参数必须大于-1", 0, 0, SDT_INT, 0, AS_RECEIVE_VAR},

    /*114*/ {"a", "欲求Gamma值的a", 0, 0, SDT_DOUBLE, 0, NULL},
    /*115*/ {"x", "欲求Gamma值的x", 0, 0, SDT_DOUBLE, 0, NULL},

    /*116*/ {"a", "欲求Gamma值的a", 0, 0, SDT_DOUBLE, 0, NULL},
    /*117*/ {"x", "欲求Gamma值的x", 0, 0, SDT_DOUBLE, 0, NULL},

    /*118*/ {"x", "必须是大于0的参数", 0, 0, SDT_DOUBLE, 0, NULL},
    /*119*/ {"y", "必须是大于0的参数", 0, 0, SDT_DOUBLE, 0, NULL},
    /*120*/ {"错误码", "可为以下常量之一：0、#无错误；1、#参数必须是一个不为0的数字；2、#参数不能为负数；3、#多项式序号必须大于0；4、#参数必须大于-1", 0, 0, SDT_INT, 0, AS_RECEIVE_VAR},

    /*121*/ {"a", "大于0的参数", 0, 0, SDT_DOUBLE, 0, NULL},
    /*122*/ {"b", "大于0的参数", 0, 0, SDT_DOUBLE, 0, NULL},
    /*123*/ {"x", "任意一个浮点数", 0, 0, SDT_DOUBLE, 0, NULL},

    /*124*/ {"v", "该参数表示次数，必须大于等于 0", 0, 0, SDT_DOUBLE, 0, NULL},
    /*125*/ {"x", "该参数必须大于0或者小于0\t", 0, 0, SDT_DOUBLE, 0, NULL},
    /*126*/ {"错误码", "可为以下常量之一：0、#无错误；1、#参数必须是一个不为0的数字；2、#参数不能为负数；3、#多项式序号必须大于0；4、#参数必须大于-1", 0, 0, SDT_INT, 0, AS_RECEIVE_VAR},

    /*127*/ {"n", "该参数指定多项式的阶，必须大于等于0", 0, 0, SDT_DOUBLE, 0, NULL},
    /*128*/ {"y", "该参数提供任意浮点数\t", 0, 0, SDT_DOUBLE, 0, NULL},
    /*129*/ {"错误码", "可为以下常量之一：0、#无错误；1、#参数必须是一个不为0的数字；2、#参数不能为负数；3、#多项式序号必须大于0；4、#参数必须大于-1", 0, 0, SDT_INT, 0, AS_RECEIVE_VAR},

    /*130*/ {"n", "该参数指定多项式的阶，必须大于等于0\t", 0, 0, SDT_DOUBLE, 0, NULL},
    /*131*/ {"y", "任一浮点值", 0, 0, SDT_DOUBLE, 0, NULL},
    /*132*/ {"错误码", "可为以下常量之一：0、#无错误；1、#参数必须是一个不为0的数字；2、#参数不能为负数；3、#多项式序号必须大于0；4、#参数必须大于-1", 0, 0, SDT_INT, 0, AS_RECEIVE_VAR},

    /*133*/ {"x", "该参数提供任意不等于0的数", 0, 0, SDT_DOUBLE, 0, NULL},
    /*134*/ {"错误码", "可为以下常量之一：0、#无错误；1、#参数必须是一个不为0的数字；2、#参数不能为负数；3、#多项式序号必须大于0；4、#参数必须大于-1", 0, 0, SDT_INT, 0, AS_RECEIVE_VAR},

    /*135*/ {"x", "该参数提供任意一个不等于0的数", 0, 0, SDT_DOUBLE, 0, NULL},
    /*136*/ {"错误码", "可为以下常量之一：0、#无错误；1、#参数必须是一个不为0的数字；2、#参数不能为负数；3、#多项式序号必须大于0；4、#参数必须大于-1", 0, 0, SDT_INT, 0, AS_RECEIVE_VAR},

    /*137*/ {"x", "保存复数的实部", 0, 0, SDT_DOUBLE, 0, NULL},
    /*138*/ {"y", "保存复数的实部", 0, 0, SDT_DOUBLE, 0, NULL},
    /*139*/ {"错误码", "可为以下常量之一：0、#无错误；1、#参数必须是一个不为0的数字；2、#参数不能为负数；3、#多项式序号必须大于0；4、#参数必须大于-1", 0, 0, SDT_INT, 0, AS_RECEIVE_VAR},

    /*140*/ {"x", "保存复数的实部", 0, 0, SDT_DOUBLE, 0, NULL},
    /*141*/ {"y", "保存复数的虚部", 0, 0, SDT_DOUBLE, 0, NULL},

    /*142*/ {"n", "该参数指定多项式次数的整数，必须大于等于0", 0, 0, SDT_INT, 0, NULL},
    /*143*/ {"x", "保存任意数", 0, 0, SDT_DOUBLE, 0, NULL},
    /*144*/ {"错误码", "可为以下常量之一：0、#无错误；1、#参数必须是一个不为0的数字；2、#参数不能为负数；3、#多项式序号必须大于0；4、#参数必须大于-1", 0, 0, SDT_INT, 0, AS_RECEIVE_VAR},

    /*145*/ {"n", "指定多项式次数的整数，必须大于等于0", 0, 0, SDT_INT, 0, NULL},
    /*146*/ {"x", "保存任一数", 0, 0, SDT_DOUBLE, 0, NULL},
    /*147*/ {"错误码", "可为以下常量之一：0、#无错误；1、#参数必须是一个不为0的数字；2、#参数不能为负数；3、#多项式序号必须大于0；4、#参数必须大于-1", 0, 0, SDT_INT, 0, AS_RECEIVE_VAR},

    /*148*/ {"n", "该参数是指定多项式次数的一个整数", 0, 0, SDT_INT, 0, NULL},
    /*149*/ {"a", "任一大于-1的数", 0, 0, SDT_DOUBLE, 0, NULL},
    /*150*/ {"x", "任意浮点数", 0, 0, SDT_DOUBLE, 0, NULL},
    /*151*/ {"错误码", "可为以下常量之一：0、#无错误；1、#参数必须是一个不为0的数字；2、#参数不能为负数；3、#多项式序号必须大于0；4、#参数必须大于-1", 0, 0, SDT_INT, 0, AS_RECEIVE_VAR},

    /*152*/ {"n", "本参数为指定多项式的次数的整数，必须大于0", 0, 0, SDT_INT, 0, NULL},
    /*153*/ {"a", "本参数为任一大于-1的数", 0, 0, SDT_DOUBLE, 0, NULL},
    /*154*/ {"b", "本参数为任一大于-1的数", 0, 0, SDT_DOUBLE, 0, NULL},
    /*155*/ {"x", "本参数为任一浮点参数", 0, 0, SDT_DOUBLE, 0, NULL},
    /*156*/ {"错误码", "可为以下常量之一：0、#无错误；1、#参数必须是一个不为0的数字；2、#参数不能为负数；3、#多项式序号必须大于0；4、#参数必须大于-1", 0, 0, SDT_INT, 0, AS_RECEIVE_VAR},

    /*157*/ {"n", "指定多项式阶的整数", 0, 0, SDT_INT, 0, NULL},
    /*158*/ {"x", "任一数", 0, 0, SDT_DOUBLE, 0, NULL},
    /*159*/ {"错误码", "可为以下常量之一：0、#无错误；1、#参数必须是一个不为0的数字；2、#参数不能为负数；3、#多项式序号必须大于0；4、#参数必须大于-1", 0, 0, SDT_INT, 0, AS_RECEIVE_VAR},

    /*160*/ {"文本文件名", "以数字为内容的文本文件名，例如：\"c:\\1.txt\"", 0, 0, SDT_TEXT, 0, NULL},
    /*161*/ {"忽略非法字符", "如果本参数为真，那么无论文本文件中有多少个非法字符都将被忽略；如果本参数为假，只要文本文件中有非法字符，本方法将失败，并返回假。合法法字符包括'0' ~ '9'的数字和'.'号和'-'号，除此之外都为非法字符。注意，以下情况不论本参数是否为真都将视为非法字符，并导致本方法失败：'.'号和'-'号在文本中出现一次以上，并且出现在非法的字符位上，例如以下文本都是非法的：0.0.1；-3212.-33；421...00；000.3123；-00.33", 0, 0, SDT_BOOL, 1, AS_HAS_DEFAULT_VALUE},

    /*162*/ {"文本文件名", "要将数据导出的目的文本文件名，例如：\"c:\\1.txt\"", 0, 0, SDT_TEXT, 0, NULL},
    /*163*/ {"覆盖现有", "本参数指明是否覆盖已存在的文件", 0, 0, SDT_BOOL, 1, AS_HAS_DEFAULT_VALUE},

    /*164*/ {"数字文本", "合法的文本格式的数字数据，可以是任意精度，该数字将被转换成本数据类型特有的数字储存格式，并参与计算", 0, 0, SDT_TEXT, 0, NULL},

    /*165*/ {"数字", "该参数可以是易语言兼容的所有数字格式数据，例如:字节型，短整数型，整数型，长整数型，小数型，双精度小数型", 0, 0, _SDT_ALL, 0, NULL},

    /*166*/ {"字符位置序号", "要获取的字符在整个数字文本中的位置，序号从\"1\"开始。如果本参数指定的序号在数字文本中不存在，那么本方法将出错", 0, 0, SDT_INT, 0, NULL},

    /*167*/ {"目标大数", "要复制到的目标大数", 0, 0, MAKELONG(0x0A, 0), 0, NULL},

    /*168*/ {"比较数据", "本参数提供待和本大数数据比较的大数", 0, 0, MAKELONG(0x0A, 0), 0, NULL},

    /*169*/ {"计算数据", "本参数提供待和本数据计算的大数数据", 0, 0, MAKELONG(0x0A, 0), 0, NULL},

    /*170*/ {"计算数据", "本参数提供待和本数据计算的大数数据", 0, 0, MAKELONG(0x0A, 0), 0, NULL},
    /*171*/ {"除法精度", "本参数提供本除法运算结果的精度", 0, 0, SDT_INT, 1, AS_HAS_DEFAULT_VALUE},

    /*172*/ {"次方数", "该参数指定对欲求次方数值的运算指数", 0, 0, MAKELONG(0x0A, 0), 0, NULL},

    /*173*/ {"舍入位置", "如果大于0，表示小数点右边应保留的位数；如果等于0，表示舍入到整数；如果小于0，表示小数点左边舍入到的位置。例如：四舍五入 (1056.65, 1) 返回 1056.7； 四舍五入 (1056.65, 0) 返回 1057； 四舍五入 (1056.65, -1) 返回 1060", 0, 0, SDT_INT, 0, AS_HAS_DEFAULT_VALUE},

    /*174*/ {"计算精度", "指明计算精度，注意：该精度为计算中的除法精度", 0, 0, SDT_INT, 3, AS_HAS_DEFAULT_VALUE},

    /*175*/ {"计算表达式", "该参数提供表示式文本，支持各种复杂的积分表达式，可含任何数学函数，如  3*exp(x)*tan(x)/(8+log(x))", 0, 0, SDT_TEXT, 0, NULL},
    /*176*/ {"积分上限", "积分的上限", 0, 0, SDT_DOUBLE, 0, NULL},
    /*177*/ {"积分下限", "积分的下限", 0, 0, SDT_DOUBLE, 0, NULL},
    /*178*/ {"误差", "允许的误差", 0, 0, SDT_DOUBLE, 0, NULL},
    /*179*/ {"计算结果", "计算的结果", 0, 0, SDT_DOUBLE, 0, AS_RECEIVE_VAR},

    /*180*/ {NULL, "省略", 0, 0, MAKELONG(0x0A, 0), 0, NULL},

    /*181*/ {NULL, NULL, 0, 0, MAKELONG(0x01, 0), 0, NULL},

};

#ifdef _DEBUG    // 这里是为了确认参数序号是否正确, 成员数比最后一个序号大1就是正确
const int dbg_cmd_arg_count__ = sizeof(g_argumentInfo_ecalc_global_var) / sizeof(g_argumentInfo_ecalc_global_var[0]);
#endif


#define ECALC_DEF_CMDINFO(_index, _szName, _szEgName, _szExplain, _shtCategory, _wState, _dtRetValType, _wReserved, _shtUserLevel, _shtBitmapIndex, _shtBitmapCount, _nArgCount, _pBeginArgInfo) \
    { _szName, ______E_FNENAME(_szEgName), _szExplain, _shtCategory, _wState, _dtRetValType, _wReserved, _shtUserLevel, _shtBitmapIndex, _shtBitmapCount, _nArgCount, _pBeginArgInfo },


// 易语言每个命令的定义, 会把信息显示在支持库列表里, 这里每个成员都是详细的描述一个命令的信息
CMD_INFO g_cmdInfo_ecalc_global_var[] = 
{
    ECALC_DEF(ECALC_DEF_CMDINFO)
};

int g_cmdInfo_ecalc_global_var_count = sizeof(g_cmdInfo_ecalc_global_var) / sizeof(g_cmdInfo_ecalc_global_var[0]);

#endif

