master

分支 (1)

管理

管理

master

ecalc
/
ecalc_cmdDef.cpp

#include "include_ecalc_header.h"

// 本命令被隐藏, 原始名字 = "复数构造", 本命令为构造函数
// 调用格式: _SDT_NULL (复数运算).复数构造, 命令说明: NULL
// 无参数
ECALC_EXTERN_C void ecalc_ComplexConstruction_0_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{

}

// 本命令被隐藏, 原始名字 = "复数析构", 本命令为析构函数
// 调用格式: _SDT_NULL (复数运算).复数析构, 命令说明: NULL
// 无参数
ECALC_EXTERN_C void ecalc_ComplexDestruction_1_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{

}

// 调用格式: MAKELONG(0x01, 0) (复数运算).复数相加, 命令说明: "求两个复数之和"
// 参数<1>: 复数数据1 MAKELONG(0x01, 0), 参数说明: "该参数提供参与计算的复数数据1，例如：复数1 + 复数2，本参数提供复数1"
// 参数<2>: 复数数据2 MAKELONG(0x01, 0), 参数说明: "该参数提供参与计算的复数数据2，例如：复数1 + 复数2算式，本参数提供复数2"
ECALC_EXTERN_C void ecalc_ComplexAdd_2_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pCompoundData;
    void*    arg2 = pArgInf[2].m_pCompoundData;

}

// 调用格式: MAKELONG(0x01, 0) (复数运算).复数相减, 命令说明: "求两个复数之差"
// 参数<1>: 复数数据1 MAKELONG(0x01, 0), 参数说明: "该参数提供参与计算的复数数据1，例如：复数1 + 复数2，本参数提供复数1"
// 参数<2>: 复数数据2 MAKELONG(0x01, 0), 参数说明: "该参数提供参与计算的复数数据2，例如：复数1 + 复数2算式，本参数提供复数2"
ECALC_EXTERN_C void ecalc_ComplexSub_3_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pCompoundData;
    void*    arg2 = pArgInf[2].m_pCompoundData;

}

// 调用格式: MAKELONG(0x01, 0) (复数运算).复数相乘, 命令说明: "求两个复数乘积"
// 参数<1>: 复数数据1 MAKELONG(0x01, 0), 参数说明: "该参数提供参与计算的复数数据1，例如：复数1 + 复数2，本参数提供复数1"
// 参数<2>: 复数数据2 MAKELONG(0x01, 0), 参数说明: "该参数提供参与计算的复数数据2，例如：复数1 + 复数2算式，本参数提供复数2"
ECALC_EXTERN_C void ecalc_ComplexMul_4_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pCompoundData;
    void*    arg2 = pArgInf[2].m_pCompoundData;

}

// 调用格式: MAKELONG(0x01, 0) (复数运算).复数相除, 命令说明: "求两个负数除商"
// 参数<1>: 复数数据1 MAKELONG(0x01, 0), 参数说明: "该参数提供参与计算的复数数据1，例如：复数1 + 复数2，本参数提供复数1"
// 参数<2>: 复数数据2 MAKELONG(0x01, 0), 参数说明: "该参数提供参与计算的复数数据2，例如：复数1 + 复数2算式，本参数提供复数2"
ECALC_EXTERN_C void ecalc_ComplexDiv_5_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pCompoundData;
    void*    arg2 = pArgInf[2].m_pCompoundData;

}

// 调用格式: MAKELONG(0x01, 0) (复数运算).求复数指数, 命令说明: "计算以e为底，以复数为幂的值"
// 参数<1>: 复数数据 MAKELONG(0x01, 0), 参数说明: "该参数提供需要参与计算的复数数据"
ECALC_EXTERN_C void ecalc_ComplexExp_6_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pCompoundData;

}

// 调用格式: SDT_DOUBLE (复数运算).求复数长度, 命令说明: "计算一个复数的长度"
// 参数<1>: 复数数据 MAKELONG(0x01, 0), 参数说明: "该参数提供需要参与计算的复数数据"
ECALC_EXTERN_C void ecalc_ComplexMag_7_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pCompoundData;

}

// 调用格式: SDT_DOUBLE (复数运算).求复数极角, 命令说明: "计算复数的极角"
// 参数<1>: 复数数据 MAKELONG(0x01, 0), 参数说明: "该参数提供需要参与计算的复数数据"
ECALC_EXTERN_C void ecalc_ComplexAngle_8_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pCompoundData;

}

// 调用格式: SDT_DOUBLE (复数运算).取实数, 命令说明: "获取复数中的实数部分"
// 无参数
ECALC_EXTERN_C void ecalc_GetRealComplex_9_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{

}

// 调用格式: SDT_DOUBLE (复数运算).取虚数, 命令说明: "获取复数中的虚数部分"
// 无参数
ECALC_EXTERN_C void ecalc_GetImaComplex_10_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{

}

// 调用格式: SDT_BOOL (复数运算).置实数, 命令说明: "设置复数的实数部分"
// 参数<1>: 要设置的数据 SDT_DOUBLE, 参数说明: "要设置的数据，实数部分或虚数部分"
ECALC_EXTERN_C void ecalc_SetRealComplex_11_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    double   arg1 = pArgInf[1].m_double;

}

// 调用格式: SDT_BOOL (复数运算).置虚数, 命令说明: "设置复数的虚数部分"
// 参数<1>: 要设置的数据 SDT_DOUBLE, 参数说明: "要设置的数据，实数部分或虚数部分"
ECALC_EXTERN_C void ecalc_SetImaComplex_12_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    double   arg1 = pArgInf[1].m_double;

}

// 调用格式: SDT_DOUBLE (矩阵运算).[]矩阵相乘, 命令说明: "计算两个矩阵的乘积，注意：必须保证矩阵1的列数等于矩阵2的行数，如果参数错误或者计算失败，本方法将返回一个1维宽度为1的数组"
// 参数<1>: 实数矩阵1 数组 SDT_DOUBLE, 参数说明: "参与运算的实数矩阵1"
// 参数<2>: 实数矩阵2 数组 SDT_DOUBLE, 参数说明: "参与运算的实数矩阵2"
ECALC_EXTERN_C void ecalc_MatrixMul_13_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pAryData;
    void*    arg2 = pArgInf[2].m_pAryData;

}

// 本命令被隐藏, 原始名字 = "复矩阵相乘"
// 调用格式: MAKELONG(0x01, 0) (矩阵运算).[]复矩阵相乘, 命令说明: "计算两个复矩阵的乘积，注意：必须保证矩阵1的列数等于矩阵2的行数，如果参数错误或者计算失败，本方法将返回一个1维宽度为1的数组"
// 参数<1>: 复数矩阵1 数组 MAKELONG(0x01, 0), 参数说明: "参与运算的复数矩阵1"
// 参数<2>: 复数矩阵2 数组 MAKELONG(0x01, 0), 参数说明: "参与运算的复数矩阵2"
ECALC_EXTERN_C void ecalc_CMatrixMul_14_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pAryData;
    void*    arg2 = pArgInf[2].m_pAryData;

}

// 调用格式: SDT_DOUBLE (矩阵运算).[]矩阵相加, 命令说明: "求两个二维矩阵之和，两个矩阵的宽度和高度必须相等，如果参数错误或者计算失败，本方法将返回一个1维宽度为1的数组"
// 参数<1>: 实数矩阵1 数组 SDT_DOUBLE, 参数说明: "参与运算的实数矩阵1"
// 参数<2>: 实数矩阵2 数组 SDT_DOUBLE, 参数说明: "参与运算的实数矩阵2"
ECALC_EXTERN_C void ecalc_MatrixAdd_15_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pAryData;
    void*    arg2 = pArgInf[2].m_pAryData;

}

// 本命令被隐藏, 原始名字 = "复矩阵相加"
// 调用格式: MAKELONG(0x01, 0) (矩阵运算).[]复矩阵相加, 命令说明: "计算两个复矩阵之和"
// 参数<1>: 复数矩阵1 数组 MAKELONG(0x01, 0), 参数说明: "参与运算的复数矩阵1"
// 参数<2>: 复数矩阵2 数组 MAKELONG(0x01, 0), 参数说明: "参与运算的复数矩阵2"
ECALC_EXTERN_C void ecalc_CMatrixMul_16_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pAryData;
    void*    arg2 = pArgInf[2].m_pAryData;

}

// 调用格式: SDT_DOUBLE (矩阵运算).[]实矩阵逆, 命令说明: "计算一个实矩阵的逆。如果参数错误或者计算失败，本方法将返回一个大小为 1 的一维数组。不是所有矩阵都有逆矩阵。"
// 参数<1>: 实数矩阵 数组 SDT_DOUBLE, 参数说明: "该实数矩阵必须是一个正方型矩阵"
// 参数<2>: [&保留参数 SDT_DOUBLE], 参数说明: NULL
ECALC_EXTERN_C void ecalc_MatrixInvert_17_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pAryData;
    double*  arg2 = pArgInf[2].m_pDouble;

}

// 本命令被隐藏, 原始名字 = "复矩阵逆"
// 调用格式: MAKELONG(0x01, 0) (矩阵运算).[]复矩阵逆, 命令说明: "计算复矩阵的逆阵。采用的算法是把N x N复矩阵转换成2N x 2N的实数矩阵。标准Gauss Jordan函数被用于计算2N x 2N数组的逆。这个数组的逆又被变换回所要求的复数逆数组"
// 参数<1>: 复数矩阵 数组 MAKELONG(0x01, 0), 参数说明: "该复数矩阵必须是一个正方型矩阵"
// 参数<2>: &行列式 SDT_DOUBLE, 参数说明: NULL
ECALC_EXTERN_C void ecalc_CMatrixInvert_18_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pAryData;
    double*  arg2 = pArgInf[2].m_pDouble;

}

// 调用格式: SDT_DOUBLE (矩阵运算).[]矩阵转置, 命令说明: "计算矩阵的转置,如果参数错误或者计算失败，本方法将返回一个1维宽度为1的数组"
// 参数<1>: 实数矩阵 数组 SDT_DOUBLE, 参数说明: "该参数提供将被转置的矩阵"
ECALC_EXTERN_C void ecalc_MatrixTranspose_19_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pAryData;

}

// 本命令被隐藏, 原始名字 = "复矩阵转置"
// 调用格式: MAKELONG(0x01, 0) (矩阵运算).[]复矩阵转置, 命令说明: "计算一个复矩阵的转置"
// 参数<1>: 复数矩阵 数组 MAKELONG(0x01, 0), 参数说明: "该参数提供将被转置的复数矩阵"
ECALC_EXTERN_C void ecalc_CMatrixTranspose_20_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pAryData;

}

// 调用格式: _SDT_NULL (矩阵运算).求矩阵特征, 命令说明: "用循环Jacobi算法计算一个实对称矩阵的特征值"
// 参数<1>: 实数矩阵 数组 SDT_DOUBLE, 参数说明: "该参数为一个正方形实数矩阵"
// 参数<2>: 向量 数组 SDT_DOUBLE, 参数说明: "该参数是一维数组，列数和第一个参数一样，返回第一个参数矩阵的特征值向量"
// 参数<3>: 返回实数矩阵 数组 SDT_DOUBLE, 参数说明: "该参数数组是维数和行列数和第一个参数一样的矩阵，它的列是原始矩阵的eigenvectors"
// 参数<4>: &记数 SDT_INT, 参数说明: "包含完成迭代的最大迭代次数，它返回完成迭代的实际迭代次数"
// 参数<5>: &收敛标志 SDT_BOOL, 参数说明: "通过该参数判断是否收敛成功"
ECALC_EXTERN_C void ecalc_CyclicJacobi_21_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pAryData;
    void*    arg2 = pArgInf[2].m_pAryData;
    void*    arg3 = pArgInf[3].m_pAryData;
    PINT     arg4 = pArgInf[4].m_pInt;
    BOOL*    arg5 = pArgInf[5].m_pBool;

}

// 调用格式: SDT_DOUBLE (矩阵运算).[]矩阵标量乘积, 命令说明: "计算矩阵和一个标量值的乘积,如果参数错误或者计算失败，本方法将返回一个1维宽度为1的数组"
// 参数<1>: 实数矩阵 数组 SDT_DOUBLE, 参数说明: "提供一个二维数组"
// 参数<2>: 标量操作数 SDT_DOUBLE, 参数说明: "定义一个标量操作数"
ECALC_EXTERN_C void ecalc_MatrixScalarMul_22_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pAryData;
    double   arg2 = pArgInf[2].m_double;

}

// 本命令被隐藏, 原始名字 = "复矩阵标量乘积"
// 调用格式: MAKELONG(0x01, 0) (矩阵运算).[]复矩阵标量乘积, 命令说明: "计算矩阵和一个复数的乘积"
// 参数<1>: 复数矩阵 数组 MAKELONG(0x01, 0), 参数说明: "二维复数数组"
// 参数<2>: 标量操作数 MAKELONG(0x01, 0), 参数说明: "包含标量错误数，同样也是复数类型"
ECALC_EXTERN_C void ecalc_CMatrixScalarMul_23_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pAryData;
    void*    arg2 = pArgInf[2].m_pCompoundData;

}

// 调用格式: SDT_BOOL (傅立叶变换).求傅立叶变换, 命令说明: "采用快速Fourier变换技术(FFT)计算由N个等距样本组成的数据集的Fourier变换。特别说明：1.数据点的个数必须是2的幂，例如32,64,128......,最大为81922.为了保存内存，第一个参数和第二个参数用于输入和输出（记住：在内存中浮点数占4个字节，双精度数占8个字节，因此一个1024个元素的向量要求4K - 8K的字节!)。如果你想保存原始数据，则把他拷贝到另一个向量中。3.把调和转换成频率:为了确定一个波形的主要频率成分，通常需要在一个调和信号上运行FFT。为了从调和数据中计算频率，你需对原始数据集知道样本频率(或两个样本间的周期)。谐波频率可用下述公式计算：频率 = (谐波下标) / (nd_数据点个数 * 样本周期)"
// 参数<1>: 数据集实值 数组 SDT_DOUBLE, 参数说明: "该参数是维数为\"数据点数\"的向量。假设本参数是xr[维数]数组，抽样数据集的实值包含从xr[1]起始的数组xr中。它返回数组xr中FFT调和函数的余弦系数。其中,xr[1]保存了DC分量,xr[2]保存了第1个谐波,xr[3]保存了第2个谐波，依次类推。系数与采样数据集中数据点的个数有关。对每一调和项a(i) * cos(...)的实际余弦函数用numdat / 2 除"
// 参数<2>: 数据集虚值 数组 SDT_DOUBLE, 参数说明: "该参数是维数为\"数据点数\"的向量，数据集的假设本参数是yi[维数]数组虚值包含从yi[1]起始的yi中。它返回yi中FFT调和函数的正弦系数 - 其中yi[2]保存第1个谐波，yi[3]保存了第2个谐波，依次类推。系数与采样数据集中数据点个数有关。对调和项a(i)sin(...)的实际正弦系数用numdat / 2 除"
// 参数<3>: 数据点数 SDT_INT, 参数说明: "包含了在前两个参数中数据点的个数"
ECALC_EXTERN_C void ecalc_FFTCalc_24_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pAryData;
    void*    arg2 = pArgInf[2].m_pAryData;
    INT      arg3 = pArgInf[3].m_int;

}

// 调用格式: SDT_BOOL (傅立叶变换).求傅立叶反变换, 命令说明: "采用快速Fourier变换技术(FFT)计算由N个等距调和函数组成的数据集的Fourier反变换。特别说明：1.数据点的个数(nd)必须是2的幂，例如32, 64, 128,......最大为8192。2.为了保存内存，本方法前两个参数xr和yi被用于输入和输出 (记注:在内存中浮点数占4字节，双精度数占8字节，因此，一个1024个元素的向量要求4k-8k字节!)。如果你想保留原始数据，把他拷贝到另一个向量中"
// 参数<1>: 数据集实值 数组 SDT_DOUBLE, 参数说明: "该参数是维数为\"数据点数\"的向量。假设本参数是xr[维数]数组，抽样数据集的实值包含从xr[1]起始的数组xr中。它返回数组xr中FFT调和函数的余弦系数。其中,xr[1]保存了DC分量,xr[2]保存了第1个谐波,xr[3]保存了第2个谐波，依次类推。系数与采样数据集中数据点的个数有关。对每一调和项a(i) * cos(...)的实际余弦函数用numdat / 2 除"
// 参数<2>: 数据集虚值 数组 SDT_DOUBLE, 参数说明: "该参数是维数为\"数据点数\"的向量，数据集的假设本参数是yi[维数]数组虚值包含从yi[1]起始的yi中。它返回yi中FFT调和函数的正弦系数 - 其中yi[2]保存第1个谐波，yi[3]保存了第2个谐波，依次类推。系数与采样数据集中数据点个数有关。对调和项a(i)sin(...)的实际正弦系数用numdat / 2 除"
// 参数<3>: 数据点数 SDT_INT, 参数说明: "包含了在前两个参数中数据点的个数"
ECALC_EXTERN_C void ecalc_FFTInvCalc_25_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pAryData;
    void*    arg2 = pArgInf[2].m_pAryData;
    INT      arg3 = pArgInf[3].m_int;

}

// 调用格式: SDT_BOOL (傅立叶变换).窗口傅立叶, 命令说明: "在谐波分析中使用窗口来减少与光谱泄露有关的不必要的影响，光谱泄露是抽样波形中不连续的结果。因为波形是对一有限时间长度的抽样，因此在波形的端点会产生不连续性。窗口是用于初始数据的加权函数，以减少与有限次观察区间有关的光谱泄露。窗口通常是用一个函数在样本区间中乘以数据，该函数在其中心处为1，在两个端点处为0。特别说明：1.数据点的个数必须是2的幂，即32,64,128......,最大为8192。2.为了保存内存，前两个方法参数均被用于输入和输出(记注：在内存中浮点数占4字节，双精度数占8字节，因此一个1024个元素的向量要求4k~8K字节！)。如果您想保留原始数据，请把它拷贝到另一个向量中"
// 参数<1>: 数据集实值 数组 SDT_DOUBLE, 参数说明: "本参数是列数为\"数据点数\"的向量，假设本参数为xr[维数]数组，它包含了从xr[1]处起始的在xr中抽样数据集的实值，并返回带有窗口的xr值"
// 参数<2>: 数据集虚值 数组 SDT_DOUBLE, 参数说明: "本参数是列数为\"数据点数\"的向量，假设本参数为yi[维数]数组，它包含了从yi[1]处起始的在yi中的抽样数据集的虚值，并返回带有窗口的yi值"
// 参数<3>: 数据点数 SDT_INT, 参数说明: "包含在前两个参数中的数据点个数"
// 参数<4>: 抽样数据窗口 SDT_INT, 参数说明: "包含应用于抽样数据的窗口，为以下常量之一：0、#矩形Window；1、#Parzen Window2、#Hanning Window；3、#Welch Window；4、#Hamming Window；5、#Exact Blackman Window"
ECALC_EXTERN_C void ecalc_WindowFFTData_26_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pAryData;
    void*    arg2 = pArgInf[2].m_pAryData;
    INT      arg3 = pArgInf[3].m_int;
    INT      arg4 = pArgInf[4].m_int;

}

// 调用格式: SDT_BOOL (傅立叶变换).二维傅立叶变换, 命令说明: "采用快速Fourier变换技术(FFT)计算由C x R个等距样本组成的数据集的二维Fourier变换。特别说明：1.行和列(c和r)必须是2的幂，例如2,4,8......128。2.为了保存内存，两个参数数组均被用于输入和输出(记住：在内存中浮点数占4字节，双精度数占8字节，因此，一个有1024个元素的向量要求4K~8K字节!)。如果你想要保留原始数据，把它拷贝到另一个变量中。3.二维FFT占用很多内存。"
// 参数<1>: 数据集实值 数组 SDT_DOUBLE, 参数说明: "该参数为二维数组，它包含了从数组起始数据中的抽样数据的实值，并返回FFT调和函数的余弦系数"
// 参数<2>: 数据集虚值 数组 SDT_DOUBLE, 参数说明: "该数组的维数、行列数是和前一个参数一样的数组，它包含了从数组起始到本数组中的抽样数据的虚值，并返回FFT调和系数的正弦余数"
// 参数<3>: 标志 SDT_BOOL, 参数说明: "真表示反变换，假表示正变换"
ECALC_EXTERN_C void ecalc_FFT2DCalc_27_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pAryData;
    void*    arg2 = pArgInf[2].m_pAryData;
    BOOL     arg3 = pArgInf[3].m_bool;

}

// 调用格式: SDT_BOOL (傅立叶变换).求能谱周期图, 命令说明: "计算抽样数据集的能谱周期图。返回每个频率箱的能谱密度，以及每个频率箱的精确频率(以Hz为单位)。特别说明：1.数据点的个数必须是2的幂，例如：32,64,128......,最大为8192。2.为保存内存。两个数组参数均被用于输入和输出。如果你想保留原始数据，则应把它拷贝到另一个变量中"
// 参数<1>: 数据集实值 数组 SDT_DOUBLE, 参数说明: "一维数组向量，假设本参数为xr[维数]数组，它包含xr中从xr[1]处起始的抽样数据的实值，并返回原始数据(从xr[1]到xr[numdat/2] - 1的有效数据)的能谱"
// 参数<2>: 数据集虚值 数组 SDT_DOUBLE, 参数说明: "该数组的维数、行列数是和前一个参数一样的数组，假设该参数为yi[维数]数组，它包含从yi中yi[0]起始的抽样数据的虚值，并返回能谱调和函数(从yi[1]到yi[numdat/2] - 1的有效数据)的频率值"
// 参数<3>: 时间间隔 SDT_DOUBLE, 参数说明: "包含了前两个参数数据集中样本之间的时间间隔"
ECALC_EXTERN_C void ecalc_PowerSpectrumCalc_28_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pAryData;
    void*    arg2 = pArgInf[2].m_pAryData;
    double   arg3 = pArgInf[3].m_double;

}

// 调用格式: SDT_DOUBLE (微积分).离散化数值积分, 命令说明: "计算一个离散化的抽样数据集的数值积分(即通常曲线下的面积)。采用的算法是Simpson 1/3法则和Simpson 3/8法则，与其他方法不同，这个方法可以同时处理偶数次和奇数次观察的数据集"
// 参数<1>: 浮点向量 数组 SDT_DOUBLE, 参数说明: "一维数组，它保存离散样本集"
// 参数<2>: 样本区间 SDT_DOUBLE, 参数说明: "定义采样数据集之间的样本区间"
// 参数<3>: 积分下限 SDT_INT, 参数说明: "积分的下限，本参数为大于等于0且小于等于\"浮点向量\"参数数组下标数减1的整数，该参数必须小于参数\"积分上限\"，否则将出错"
// 参数<4>: 积分上限 SDT_INT, 参数说明: "积分的上限，本参数为大于等于0且小于等于\"浮点向量\"参数数组下标数减1的整数，该参数必须大于参数\"积分下限\""
ECALC_EXTERN_C void ecalc_IntegrateVector_29_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pAryData;
    double   arg2 = pArgInf[2].m_double;
    INT      arg3 = pArgInf[3].m_int;
    INT      arg4 = pArgInf[4].m_int;

}

// 调用格式: SDT_DOUBLE (微积分).函数数值积分, 命令说明: "计算一个所指定的函数的数值积分(即通常曲线下的面积)。采用的算法是Simpson 1/3法则和Simpson 3/8 法则"
// 参数<1>: 样本区间 SDT_INT, 参数说明: "数据集的样本区间，该参数必须为正整数，否则将出错"
// 参数<2>: 积分下限 SDT_DOUBLE, 参数说明: "积分下限，该参数必须小于参数\"积分上限\"，否则将出错"
// 参数<3>: 积分上限 SDT_DOUBLE, 参数说明: "积分上限，该参数必须大于参数\"积分下限\"，否则将出错"
ECALC_EXTERN_C void ecalc_IntegrateFunction_30_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    INT      arg1 = pArgInf[1].m_int;
    double   arg2 = pArgInf[2].m_double;
    double   arg3 = pArgInf[3].m_double;

}

// 调用格式: SDT_BOOL (微积分).一阶微分方程, 命令说明: "求解形式如下的一阶微分方程y' = f(x,y)"
// 参数<1>: x已知值 SDT_DOUBLE, 参数说明: "包含x的已知值"
// 参数<2>: y已知值 SDT_DOUBLE, 参数说明: "包含y的已知值"
// 参数<3>: 要求解的x SDT_DOUBLE, 参数说明: "包含要求解的x的值"
// 参数<4>: 允许误差 SDT_DOUBLE, 参数说明: "保存允许误差，若误差估计小于 (et * h) / 32，则步长(后一个参数)在函数中使用时加倍，若误差估计大于 (本参数 * 步长)时，则步长减半"
// 参数<5>: 初始步长 SDT_DOUBLE, 参数说明: "包含用从已知x值迭代到x的初始步长"
// 参数<6>: 最小步长 SDT_DOUBLE, 参数说明: "包含最小步长(若步长小于本参数，则函数退出)，本参数必须为大于0的数"
// 参数<7>: &y的估值 SDT_DOUBLE, 参数说明: "返回y的估值"
// 参数<8>: &状态 SDT_BOOL, 参数说明: "若x值已被求解，则返回真；若在解出步长前已小于最小步长，则返回假"
ECALC_EXTERN_C void ecalc_RungeKutta_31_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    double   arg1 = pArgInf[1].m_double;
    double   arg2 = pArgInf[2].m_double;
    double   arg3 = pArgInf[3].m_double;
    double   arg4 = pArgInf[4].m_double;
    double   arg5 = pArgInf[5].m_double;
    double   arg6 = pArgInf[6].m_double;
    double*  arg7 = pArgInf[7].m_pDouble;
    BOOL*    arg8 = pArgInf[8].m_pBool;

}

// 调用格式: SDT_BOOL (概要统计).统计数据概要, 命令说明: "对数据集的每一列计算概要统计 - 最大值、最小值、范围、总和、平均值、方差、标准偏差、众数和平均值的标准误差"
// 参数<1>: 原数据 数组 SDT_DOUBLE, 参数说明: "必须是二维数组"
// 参数<2>: 最小值 数组 SDT_DOUBLE, 参数说明: "该参数为宽度和\"原数据\"高度一样的一维数组，它返回\"原数据\"中每一列数据的最小值"
// 参数<3>: 最大值 数组 SDT_DOUBLE, 参数说明: "该参数为宽度和\"原数据\"高度一样的一维数组，它返回\"原数据\"中每一列数据的最大值"
// 参数<4>: 范围值 数组 SDT_DOUBLE, 参数说明: "该参数为宽度和\"原数据\"高度一样的一维数组，它返回\"原数据\"中每一列数据的最大值和最小值的差"
// 参数<5>: 总和 数组 SDT_DOUBLE, 参数说明: "该参数为宽度和\"原数据\"高度一样的一维数组，它返回\"原数据\"中每一列数据的和"
// 参数<6>: 平均值 数组 SDT_DOUBLE, 参数说明: "该参数为宽度和\"原数据\"高度一样的一维数组，它返回\"原数据\"中每一列数据的平均值"
// 参数<7>: 方差值 数组 SDT_DOUBLE, 参数说明: "该参数为宽度和\"原数据\"高度一样的一维数组，它返回\"原数据\"中每一列数据的方差值"
// 参数<8>: 标准偏差值 数组 SDT_DOUBLE, 参数说明: "该参数为宽度和\"原数据\"高度一样的一维数组，它返回\"原数据\"中每一列数据的标准偏差值"
// 参数<9>: 标准误差 数组 SDT_DOUBLE, 参数说明: "该参数为宽度和\"原数据\"高度一样的一维数组，它返回\"原数据\"中每一列数据平均值的标准误差"
// 参数<10>: 众数值 数组 SDT_DOUBLE, 参数说明: "该参数为宽度和\"原数据\"高度一样的一维数组，它返回\"原数据\"中每一列数据的众数值"
ECALC_EXTERN_C void ecalc_SummaryStats_32_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pAryData;
    void*    arg2 = pArgInf[2].m_pAryData;
    void*    arg3 = pArgInf[3].m_pAryData;
    void*    arg4 = pArgInf[4].m_pAryData;
    void*    arg5 = pArgInf[5].m_pAryData;
    void*    arg6 = pArgInf[6].m_pAryData;
    void*    arg7 = pArgInf[7].m_pAryData;
    void*    arg8 = pArgInf[8].m_pAryData;
    void*    arg9 = pArgInf[9].m_pAryData;
    void*    arg10 = pArgInf[10].m_pAryData;

}

// 调用格式: SDT_BOOL (联立方程).线性方程组, 命令说明: "本函数采用Gauss - Jordan方法求解实型线性方程组"
// 参数<1>: x变量系数 数组 SDT_DOUBLE, 参数说明: "该参数是一个二维正方形数组，数组宽度和高度相等，宽度和高度必须小于等于50，它保存x变量系数的方阵，该参数数组的数据必须提供全部不为0的数值，否则本方法将失败"
// 参数<2>: y向量 数组 SDT_DOUBLE, 参数说明: "该参数是列数和前一个参数一样的一维数组"
// 参数<3>: x变量解 数组 SDT_DOUBLE, 参数说明: "列数和第一个参数一样的一维数组"
// 参数<4>: x变量系数逆阵 数组 SDT_DOUBLE, 参数说明: "和第一个参数行列数一样的二维数组，它保存x变量系数矩阵的逆阵"
// 参数<5>: &x矩阵行列式 SDT_DOUBLE, 参数说明: "返回x变量系数矩阵的行列式"
ECALC_EXTERN_C void ecalc_GaussJordan_33_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pAryData;
    void*    arg2 = pArgInf[2].m_pAryData;
    void*    arg3 = pArgInf[3].m_pAryData;
    void*    arg4 = pArgInf[4].m_pAryData;
    double*  arg5 = pArgInf[5].m_pDouble;

}

// 本命令被隐藏, 原始名字 = "复数线性方程组"
// 调用格式: SDT_BOOL (联立方程).复数线性方程组, 命令说明: "本函数采用Gauss - Jordan方法求解复型线性方程系统。函数使用了一种把N个复数方程转换成2N个实数方法的算法，再利用标准GaussJordan函数求解这个新的方程组，产生2N个解。然后，实数解向量被转换回N个复数解矢量，原始复数系数矩阵的逆也返回给用户。返回的行列是一实值，它是临时的2N个方程组的行列式。这个行列式可用来确定这个函数是否可收敛到一个精确解"
// 参数<1>: x变量系数 数组 MAKELONG(0x01, 0), 参数说明: "二维数组。行表示方程的系数，列表示x变量的系数"
// 参数<2>: y向量 数组 MAKELONG(0x01, 0), 参数说明: "列数和第一个参数一样的一维数组"
// 参数<3>: x变量解 数组 SDT_DOUBLE, 参数说明: "列数和第一个参数一样的一维数组，它是保存复数x变量的解向量- [1]表示值x0,[2]表示值x1,依次类推"
// 参数<4>: x变量系数逆阵 数组 MAKELONG(0x01, 0), 参数说明: "行列数和第一个参数一样的二维数组，它保存x变量系数矩阵的逆阵"
// 参数<5>: &x矩阵行列式 SDT_DOUBLE, 参数说明: "返回x变量系数矩阵的总行列式"
ECALC_EXTERN_C void ecalc_ComplexGaussJordan_34_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pAryData;
    void*    arg2 = pArgInf[2].m_pAryData;
    void*    arg3 = pArgInf[3].m_pAryData;
    void*    arg4 = pArgInf[4].m_pAryData;
    double*  arg5 = pArgInf[5].m_pDouble;

}

// 调用格式: SDT_BOOL (多重回归).多重回归, 命令说明: "对数据集建立一个最小二乘线性多重回归方程。它返回回归方程的系数、y的估值、残差、估计的标准误差、回归系数的标准误差、确定系数和相关系数"
// 参数<1>: 原始数据 数组 SDT_DOUBLE, 参数说明: "该参数是二维数组，保存被分析的原始数据"
// 参数<2>: x矩阵行列式 数组 SDT_DOUBLE, 参数说明: "列数和第一个参数行数一样的一维数组"
// 参数<3>: 回归方程系数 数组 SDT_DOUBLE, 参数说明: "该参数为列数和第一个参数一样的一维数组，它返回计算出来的回归方程系数"
// 参数<4>: y估值 数组 SDT_DOUBLE, 参数说明: "该参数为列数与第一个参数行数一样的二维数组，它返回用回归系数计算的y的估值"
// 参数<5>: 残差值 数组 SDT_DOUBLE, 参数说明: "该参数为列数与第一个参数行数一样的二维数组，它返回残差值(y的估值与y的观察值之差)"
// 参数<6>: &标准误差 SDT_DOUBLE, 参数说明: "返回估计的标准误差"
// 参数<7>: 估计标准误差 数组 SDT_DOUBLE, 参数说明: "该参数是列数与第一个参数一样的一维数组，它返回系数估计的标准误差"
// 参数<8>: &r平方值 SDT_DOUBLE, 参数说明: "返回r平方值 - 样本确定系数"
// 参数<9>: &r值 SDT_DOUBLE, 参数说明: "返回r值 - 样本相关系数"
// 参数<10>: &是否回归矩阵奇异 SDT_INT, 参数说明: "如果回归矩阵奇异，则返回一个非\"0\"值，否则返回\"0\""
ECALC_EXTERN_C void ecalc_MulReg_35_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pAryData;
    void*    arg2 = pArgInf[2].m_pAryData;
    void*    arg3 = pArgInf[3].m_pAryData;
    void*    arg4 = pArgInf[4].m_pAryData;
    void*    arg5 = pArgInf[5].m_pAryData;
    double*  arg6 = pArgInf[6].m_pDouble;
    void*    arg7 = pArgInf[7].m_pAryData;
    double*  arg8 = pArgInf[8].m_pDouble;
    double*  arg9 = pArgInf[9].m_pDouble;
    PINT     arg10 = pArgInf[10].m_pInt;

}

// 调用格式: SDT_BOOL (曲线拟合).二乘曲线拟合, 命令说明: "本函数是一个广义最小二乘曲线拟合函数，它对一个相关或不相关变量数据集用线性系数拟合一个多项式"
// 参数<1>: 独立变量观察值 数组 SDT_DOUBLE, 参数说明: "该参数是一个一维数组，保存独立变量的观察值"
// 参数<2>: 相关变量观察值 数组 SDT_DOUBLE, 参数说明: "该参数为列数和第一个参数一样的一维数组，它保存相关变量的观察值"
// 参数<3>: 多项式系数 数组 SDT_DOUBLE, 参数说明: "该参数是列数小于第一个参数的一维数组，它保存拟合多项式的系数，数组第1个成员保存常数，数组第2个成员保存x ^ 1的系数，数组第3个成员保存x ^ 2的系数，依此类推"
// 参数<4>: y估值 数组 SDT_DOUBLE, 参数说明: "该参数为列数和第一个参数一样的一维数组，它返回用多项式系数计算的y的估值"
// 参数<5>: 残差值 数组 SDT_DOUBLE, 参数说明: "返回残差值。"
// 参数<6>: &标准误差 SDT_DOUBLE, 参数说明: "返回估计的标准误差"
// 参数<7>: 估计标准误差 数组 SDT_DOUBLE, 参数说明: "该参数为列数和\"多项式系数\"一样的一维数组，它返回系数估计的标准误差"
// 参数<8>: &r平方值 SDT_DOUBLE, 参数说明: "返回r平方值 - 样本确定系数"
// 参数<9>: &r值 SDT_DOUBLE, 参数说明: "返回r值 - 样本相关系数"
// 参数<10>: &是否奇异 SDT_INT, 参数说明: "如果曲线拟合矩阵奇异则返回1"
ECALC_EXTERN_C void ecalc_PolyCurveFit_36_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pAryData;
    void*    arg2 = pArgInf[2].m_pAryData;
    void*    arg3 = pArgInf[3].m_pAryData;
    void*    arg4 = pArgInf[4].m_pAryData;
    void*    arg5 = pArgInf[5].m_pAryData;
    double*  arg6 = pArgInf[6].m_pDouble;
    void*    arg7 = pArgInf[7].m_pAryData;
    double*  arg8 = pArgInf[8].m_pDouble;
    double*  arg9 = pArgInf[9].m_pDouble;
    PINT     arg10 = pArgInf[10].m_pInt;

}

// 调用格式: SDT_BOOL (曲线拟合).三次多项式方程, 命令说明: "本函数对离散数据集拟合一系列三次多项式方程。通过把原始数据点区间上的三次方程应用于插值中要使用的x值，在那个区间上的y值可能被插值。在每个子区间上(sv[i],sv[i+1])，三次样条形如：y的估值 = a[i] + b[i] * (x - xv[i]) + c[i] * (x - sv[i]) ^ 2 + d[i] * (s - sv[i]) ^ 3"
// 参数<1>: x值 数组 SDT_DOUBLE, 参数说明: "该参数是一个一维数组，它保存离散数据的x值"
// 参数<2>: y值 数组 SDT_DOUBLE, 参数说明: "该参数是列数和第一个参数一样的一维数组，它保存离散数据集的y值"
// 参数<3>: 三次样条方程系数 数组 SDT_DOUBLE, 参数说明: "该参数是行数和第一个参数列数一样，列数为4的二维数组，它返回每个子区间上三次样条方程的系数"
ECALC_EXTERN_C void ecalc_CubicSplines_37_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pAryData;
    void*    arg2 = pArgInf[2].m_pAryData;
    void*    arg3 = pArgInf[3].m_pAryData;

}

// 调用格式: SDT_BOOL (曲线拟合).三次样条插值, 命令说明: "该函数计算给定一个x值和由\"三次多项式方程\"计算的三次样条系数矩阵，y值的三次样条插值"
// 参数<1>: x值 数组 SDT_DOUBLE, 参数说明: "该参数为一维数组，它保存离散数据集的x值。用来确定在计算过程中使用哪个样条区间"
// 参数<2>: 三次样条方程系数 数组 SDT_DOUBLE, 参数说明: "该参数是行数和第一个参数一样，列数为4的二维数组。它保存每个子区间的三次样条方程的系数"
// 参数<3>: 插值x SDT_DOUBLE, 参数说明: "包含在插值中使用的x值"
// 参数<4>: &y值 SDT_DOUBLE, 参数说明: "被计算的y值"
ECALC_EXTERN_C void ecalc_CalcSpline_38_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pAryData;
    void*    arg2 = pArgInf[2].m_pAryData;
    double   arg3 = pArgInf[3].m_double;
    double*  arg4 = pArgInf[4].m_pDouble;

}

// 调用格式: SDT_DOUBLE (其他计算).求双曲正切, 命令说明: NULL
// 参数<1>: x SDT_DOUBLE, 参数说明: NULL
ECALC_EXTERN_C void ecalc_Tanh_39_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    double   arg1 = pArgInf[1].m_double;

}

// 调用格式: SDT_DOUBLE (其他计算).求双曲余弦, 命令说明: NULL
// 参数<1>: x SDT_DOUBLE, 参数说明: NULL
ECALC_EXTERN_C void ecalc_Cosh_40_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    double   arg1 = pArgInf[1].m_double;

}

// 调用格式: SDT_DOUBLE (其他计算).求双曲正弦, 命令说明: NULL
// 参数<1>: x SDT_DOUBLE, 参数说明: NULL
ECALC_EXTERN_C void ecalc_Sinh_41_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    double   arg1 = pArgInf[1].m_double;

}

// 调用格式: SDT_DOUBLE (其他计算).求双曲正割, 命令说明: NULL
// 参数<1>: x SDT_DOUBLE, 参数说明: NULL
ECALC_EXTERN_C void ecalc_Sech_42_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    double   arg1 = pArgInf[1].m_double;

}

// 调用格式: SDT_DOUBLE (其他计算).求反双曲正切, 命令说明: NULL
// 参数<1>: x SDT_DOUBLE, 参数说明: NULL
ECALC_EXTERN_C void ecalc_ArcTanh_43_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    double   arg1 = pArgInf[1].m_double;

}

// 调用格式: SDT_DOUBLE (其他计算).求伽玛, 命令说明: "求指定数的伽玛函数"
// 参数<1>: 欲求Gamma的值 SDT_DOUBLE, 参数说明: "欲求Gamma的值"
// 参数<2>: &错误码 SDT_INT, 参数说明: "可为以下常量之一：0、#无错误；1、#参数必须是一个不为0的数字；2、#参数不能为负数；3、#多项式序号必须大于0；4、#参数必须大于-1"
ECALC_EXTERN_C void ecalc_Gamma_44_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    double   arg1 = pArgInf[1].m_double;
    PINT     arg2 = pArgInf[2].m_pInt;

}

// 调用格式: SDT_DOUBLE (其他计算).求伽玛对数, 命令说明: "求指定数的伽玛函数的对数"
// 参数<1>: 欲求Gamma的值 SDT_DOUBLE, 参数说明: "欲求Gamma的值"
ECALC_EXTERN_C void ecalc_LogGamma_45_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    double   arg1 = pArgInf[1].m_double;

}

// 调用格式: SDT_DOUBLE (其他计算).求不完全伽玛, 命令说明: "求指定数的不完全伽玛函数，本函数是定义在所有大于0的实数上的"
// 参数<1>: a SDT_DOUBLE, 参数说明: "欲求Gamma值的a"
// 参数<2>: x SDT_DOUBLE, 参数说明: "欲求Gamma值的x"
ECALC_EXTERN_C void ecalc_IncGamma_46_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    double   arg1 = pArgInf[1].m_double;
    double   arg2 = pArgInf[2].m_double;

}

// 调用格式: SDT_DOUBLE (其他计算).求不完全伽玛2, 命令说明: "本函数是定义在所有大于0的实数上的"
// 参数<1>: a SDT_DOUBLE, 参数说明: "欲求Gamma值的a"
// 参数<2>: x SDT_DOUBLE, 参数说明: "欲求Gamma值的x"
ECALC_EXTERN_C void ecalc_IncGammaComp_47_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    double   arg1 = pArgInf[1].m_double;
    double   arg2 = pArgInf[2].m_double;

}

// 调用格式: SDT_DOUBLE (其他计算).求贝它, 命令说明: "根据指定参数求贝它"
// 参数<1>: x SDT_DOUBLE, 参数说明: "必须是大于0的参数"
// 参数<2>: y SDT_DOUBLE, 参数说明: "必须是大于0的参数"
// 参数<3>: &错误码 SDT_INT, 参数说明: "可为以下常量之一：0、#无错误；1、#参数必须是一个不为0的数字；2、#参数不能为负数；3、#多项式序号必须大于0；4、#参数必须大于-1"
ECALC_EXTERN_C void ecalc_Beta_48_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    double   arg1 = pArgInf[1].m_double;
    double   arg2 = pArgInf[2].m_double;
    PINT     arg3 = pArgInf[3].m_pInt;

}

// 调用格式: SDT_DOUBLE (其他计算).求不完全贝它, 命令说明: "根据指定参数求贝它"
// 参数<1>: a SDT_DOUBLE, 参数说明: "大于0的参数"
// 参数<2>: b SDT_DOUBLE, 参数说明: "大于0的参数"
// 参数<3>: x SDT_DOUBLE, 参数说明: "任意一个浮点数"
ECALC_EXTERN_C void ecalc_IncBeta_49_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    double   arg1 = pArgInf[1].m_double;
    double   arg2 = pArgInf[2].m_double;
    double   arg3 = pArgInf[3].m_double;

}

// 调用格式: SDT_DOUBLE (其他计算).求贝塞尔, 命令说明: "通过指定参数求贝塞尔"
// 参数<1>: v SDT_DOUBLE, 参数说明: "该参数表示次数，必须大于等于 0"
// 参数<2>: x SDT_DOUBLE, 参数说明: "该参数必须大于0或者小于0\t"
// 参数<3>: &错误码 SDT_INT, 参数说明: "可为以下常量之一：0、#无错误；1、#参数必须是一个不为0的数字；2、#参数不能为负数；3、#多项式序号必须大于0；4、#参数必须大于-1"
ECALC_EXTERN_C void ecalc_Bessel_50_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    double   arg1 = pArgInf[1].m_double;
    double   arg2 = pArgInf[2].m_double;
    PINT     arg3 = pArgInf[3].m_pInt;

}

// 调用格式: SDT_DOUBLE (其他计算).求修正贝塞尔, 命令说明: "通过指定参数求修正过的贝塞尔值"
// 参数<1>: n SDT_DOUBLE, 参数说明: "该参数指定多项式的阶，必须大于等于0"
// 参数<2>: y SDT_DOUBLE, 参数说明: "该参数提供任意浮点数\t"
// 参数<3>: &错误码 SDT_INT, 参数说明: "可为以下常量之一：0、#无错误；1、#参数必须是一个不为0的数字；2、#参数不能为负数；3、#多项式序号必须大于0；4、#参数必须大于-1"
ECALC_EXTERN_C void ecalc_ModBessel_51_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    double   arg1 = pArgInf[1].m_double;
    double   arg2 = pArgInf[2].m_double;
    PINT     arg3 = pArgInf[3].m_pInt;

}

// 调用格式: SDT_DOUBLE (其他计算).求修正贝塞尔R, 命令说明: "通过指定参数求修正过的贝塞尔值"
// 参数<1>: n SDT_DOUBLE, 参数说明: "该参数指定多项式的阶，必须大于等于0\t"
// 参数<2>: y SDT_DOUBLE, 参数说明: "任一浮点值"
// 参数<3>: &错误码 SDT_INT, 参数说明: "可为以下常量之一：0、#无错误；1、#参数必须是一个不为0的数字；2、#参数不能为负数；3、#多项式序号必须大于0；4、#参数必须大于-1"
ECALC_EXTERN_C void ecalc_ModBesselR_52_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    double   arg1 = pArgInf[1].m_double;
    double   arg2 = pArgInf[2].m_double;
    PINT     arg3 = pArgInf[3].m_pInt;

}

// 调用格式: SDT_DOUBLE (其他计算).求高斯误差, 命令说明: "求指定参数的高斯误差值"
// 参数<1>: x SDT_DOUBLE, 参数说明: "该参数提供任意不等于0的数"
// 参数<2>: &错误码 SDT_INT, 参数说明: "可为以下常量之一：0、#无错误；1、#参数必须是一个不为0的数字；2、#参数不能为负数；3、#多项式序号必须大于0；4、#参数必须大于-1"
ECALC_EXTERN_C void ecalc_ErrFunc_53_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    double   arg1 = pArgInf[1].m_double;
    PINT     arg2 = pArgInf[2].m_pInt;

}

// 调用格式: SDT_DOUBLE (其他计算).求误差余, 命令说明: "求解误差函数的余函数"
// 参数<1>: x SDT_DOUBLE, 参数说明: "该参数提供任意一个不等于0的数"
// 参数<2>: &错误码 SDT_INT, 参数说明: "可为以下常量之一：0、#无错误；1、#参数必须是一个不为0的数字；2、#参数不能为负数；3、#多项式序号必须大于0；4、#参数必须大于-1"
ECALC_EXTERN_C void ecalc_ErrFuncCom_54_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    double   arg1 = pArgInf[1].m_double;
    PINT     arg2 = pArgInf[2].m_pInt;

}

// 调用格式: SDT_DOUBLE (其他计算).求误差实部, 命令说明: "计算误差函数Z = x + iy 的实部"
// 参数<1>: x SDT_DOUBLE, 参数说明: "保存复数的实部"
// 参数<2>: y SDT_DOUBLE, 参数说明: "保存复数的实部"
// 参数<3>: &错误码 SDT_INT, 参数说明: "可为以下常量之一：0、#无错误；1、#参数必须是一个不为0的数字；2、#参数不能为负数；3、#多项式序号必须大于0；4、#参数必须大于-1"
ECALC_EXTERN_C void ecalc_ErrFuncR_55_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    double   arg1 = pArgInf[1].m_double;
    double   arg2 = pArgInf[2].m_double;
    PINT     arg3 = pArgInf[3].m_pInt;

}

// 调用格式: SDT_DOUBLE (其他计算).求误差虚部, 命令说明: "计算误差函数Z = x + iy的虚部"
// 参数<1>: x SDT_DOUBLE, 参数说明: "保存复数的实部"
// 参数<2>: y SDT_DOUBLE, 参数说明: "保存复数的虚部"
ECALC_EXTERN_C void ecalc_ErrFuncI_56_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    double   arg1 = pArgInf[1].m_double;
    double   arg2 = pArgInf[2].m_double;

}

// 调用格式: SDT_DOUBLE (其他计算).求厄密多项式, 命令说明: "求解Hermite方程中多项式的第n个根"
// 参数<1>: n SDT_INT, 参数说明: "该参数指定多项式次数的整数，必须大于等于0"
// 参数<2>: x SDT_DOUBLE, 参数说明: "保存任意数"
// 参数<3>: &错误码 SDT_INT, 参数说明: "可为以下常量之一：0、#无错误；1、#参数必须是一个不为0的数字；2、#参数不能为负数；3、#多项式序号必须大于0；4、#参数必须大于-1"
ECALC_EXTERN_C void ecalc_Hermite_57_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    INT      arg1 = pArgInf[1].m_int;
    double   arg2 = pArgInf[2].m_double;
    PINT     arg3 = pArgInf[3].m_pInt;

}

// 调用格式: SDT_DOUBLE (其他计算).求勒让德方程系数, 命令说明: "求Gauss Legendre方程系数"
// 参数<1>: n SDT_INT, 参数说明: "指定多项式次数的整数，必须大于等于0"
// 参数<2>: x SDT_DOUBLE, 参数说明: "保存任一数"
// 参数<3>: &错误码 SDT_INT, 参数说明: "可为以下常量之一：0、#无错误；1、#参数必须是一个不为0的数字；2、#参数不能为负数；3、#多项式序号必须大于0；4、#参数必须大于-1"
ECALC_EXTERN_C void ecalc_Legend_58_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    INT      arg1 = pArgInf[1].m_int;
    double   arg2 = pArgInf[2].m_double;
    PINT     arg3 = pArgInf[3].m_pInt;

}

// 调用格式: SDT_DOUBLE (其他计算).求拉格尔, 命令说明: "本函数是在下列方程中寻找多项式第n个根的向前方法:Ln(a)(x) = xy'' + (a + 1 - x)y' + ny = 0"
// 参数<1>: n SDT_INT, 参数说明: "该参数是指定多项式次数的一个整数"
// 参数<2>: a SDT_DOUBLE, 参数说明: "任一大于-1的数"
// 参数<3>: x SDT_DOUBLE, 参数说明: "任意浮点数"
// 参数<4>: &错误码 SDT_INT, 参数说明: "可为以下常量之一：0、#无错误；1、#参数必须是一个不为0的数字；2、#参数不能为负数；3、#多项式序号必须大于0；4、#参数必须大于-1"
ECALC_EXTERN_C void ecalc_Laguerre_59_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    INT      arg1 = pArgInf[1].m_int;
    double   arg2 = pArgInf[2].m_double;
    double   arg3 = pArgInf[3].m_double;
    PINT     arg4 = pArgInf[4].m_pInt;

}

// 调用格式: SDT_DOUBLE (其他计算).求雅各比方程, 命令说明: "求解雅各比方程。由于雅各比方程中包含特殊符号，因此方程原型无法在此显示，对此表示抱歉"
// 参数<1>: n SDT_INT, 参数说明: "本参数为指定多项式的次数的整数，必须大于0"
// 参数<2>: a SDT_DOUBLE, 参数说明: "本参数为任一大于-1的数"
// 参数<3>: b SDT_DOUBLE, 参数说明: "本参数为任一大于-1的数"
// 参数<4>: x SDT_DOUBLE, 参数说明: "本参数为任一浮点参数"
// 参数<5>: &错误码 SDT_INT, 参数说明: "可为以下常量之一：0、#无错误；1、#参数必须是一个不为0的数字；2、#参数不能为负数；3、#多项式序号必须大于0；4、#参数必须大于-1"
ECALC_EXTERN_C void ecalc_Jacobi_60_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    INT      arg1 = pArgInf[1].m_int;
    double   arg2 = pArgInf[2].m_double;
    double   arg3 = pArgInf[3].m_double;
    double   arg4 = pArgInf[4].m_double;
    PINT     arg5 = pArgInf[5].m_pInt;

}

// 调用格式: SDT_DOUBLE (其他计算).求车切多项式, 命令说明: "求解n阶的Tchebychev的多项式: Tn(x) = (1 - x ^ 2)y' - xy + n ^ 2 * y = 0"
// 参数<1>: n SDT_INT, 参数说明: "指定多项式阶的整数"
// 参数<2>: x SDT_DOUBLE, 参数说明: "任一数"
// 参数<3>: &错误码 SDT_INT, 参数说明: "可为以下常量之一：0、#无错误；1、#参数必须是一个不为0的数字；2、#参数不能为负数；3、#多项式序号必须大于0；4、#参数必须大于-1"
ECALC_EXTERN_C void ecalc_Tcheb_61_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    INT      arg1 = pArgInf[1].m_int;
    double   arg2 = pArgInf[2].m_double;
    PINT     arg3 = pArgInf[3].m_pInt;

}

// 本命令被隐藏, 原始名字 = "大数构造", 本命令为构造函数
// 调用格式: _SDT_NULL (大数).大数构造, 命令说明: NULL
// 无参数
ECALC_EXTERN_C void ecalc_UnlNumConstruction_62_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{

}

// 本命令被隐藏, 原始名字 = "大数析构", 本命令为析构函数
// 调用格式: _SDT_NULL (大数).大数析构, 命令说明: NULL
// 无参数
ECALC_EXTERN_C void ecalc_UnlNumDestruction_63_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{

}

// 调用格式: SDT_BOOL (大数).销毁, 命令说明: "删除本对象已存在的数据，使用本方法后，本对象的数据将被变成整数\"0\""
// 无参数
ECALC_EXTERN_C void ecalc_Destroy_64_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{

}

// 调用格式: SDT_BOOL (大数).导入文本文件, 命令说明: "导入存储数字的文本文件，该文本文件必须仅为存储数字的格式，否则本方法将失败，并返回假，本方法成功返回真，本对象以前存储的数据将被舍弃"
// 参数<1>: 文本文件名 SDT_TEXT, 参数说明: "以数字为内容的文本文件名，例如：\"c:\\1.txt\""
// 参数<2>: 忽略非法字符 SDT_BOOL, 参数说明: "如果本参数为真，那么无论文本文件中有多少个非法字符都将被忽略；如果本参数为假，只要文本文件中有非法字符，本方法将失败，并返回假。合法法字符包括'0' ~ '9'的数字和'.'号和'-'号，除此之外都为非法字符。注意，以下情况不论本参数是否为真都将视为非法字符，并导致本方法失败：'.'号和'-'号在文本中出现一次以上，并且出现在非法的字符位上，例如以下文本都是非法的：0.0.1；-3212.-33；421...00；000.3123；-00.33"
ECALC_EXTERN_C void ecalc_ImportTxtFile_65_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    LPSTR    arg1 = pArgInf[1].m_pText;
    BOOL     arg2 = pArgInf[2].m_bool;

}

// 调用格式: SDT_BOOL (大数).导出文本文件, 命令说明: "导出本对象当前所存储的数字到文本文件，成功返回真，失败返回假"
// 参数<1>: 文本文件名 SDT_TEXT, 参数说明: "要将数据导出的目的文本文件名，例如：\"c:\\1.txt\""
// 参数<2>: 覆盖现有 SDT_BOOL, 参数说明: "本参数指明是否覆盖已存在的文件"
ECALC_EXTERN_C void ecalc_ImportTxtFile_66_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    LPSTR    arg1 = pArgInf[1].m_pText;
    BOOL     arg2 = pArgInf[2].m_bool;

}

// 调用格式: SDT_BOOL (大数).导入文本, 命令说明: "导入存储数字的文本型的数据为本对象的当前数据，该文本型必须为存储合法数字格式的文本，该数字可以是任何长度和精度，本对象以前存储的数据将被舍弃，成功返回真，失败返回假"
// 参数<1>: 数字文本 SDT_TEXT, 参数说明: "合法的文本格式的数字数据，可以是任意精度，该数字将被转换成本数据类型特有的数字储存格式，并参与计算"
ECALC_EXTERN_C void ecalc_ImportString_67_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    LPSTR    arg1 = pArgInf[1].m_pText;

}

// 调用格式: SDT_TEXT (大数).导出文本, 命令说明: "以文本型的格式导出当前本对象所存储的数字数据"
// 无参数
ECALC_EXTERN_C void ecalc_ExportString_68_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{

}

// 调用格式: SDT_BOOL (大数).导入数字, 命令说明: "导入当前易语言支持的所有格式的数字为当前数据类型的数据，以前的数据将被舍弃，成功返回真，失败返回假，注意：如果您导入的数据是小数有可能产生误差"
// 参数<1>: 数字 _SDT_ALL, 参数说明: "该参数可以是易语言兼容的所有数字格式数据，例如:字节型，短整数型，整数型，长整数型，小数型，双精度小数型"
ECALC_EXTERN_C void ecalc_ImportNum_69_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    PVOID    arg1 = pArgInf[1].m_pByte;

}

// 调用格式: SDT_INT (大数).取类型, 命令说明: "计算并获取当前本对象所对应易语言的基础数据类型，便于导出数据到易语言基础数字数据类型，返回值为以下常量值之一：0、#非任何类型；1、#字节型；2、#短整数型；3、#整数型；4、#长整数型；5、#小数型；6、#双精度小数型"
// 无参数
ECALC_EXTERN_C void ecalc_GetNumType_70_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{

}

// 调用格式: SDT_INT (大数).取长度, 命令说明: "计算并获取本对象如果转换为文本型数据时，字符的长度"
// 无参数
ECALC_EXTERN_C void ecalc_GetStrLen_71_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{

}

// 调用格式: SDT_INT (大数).取整数长度, 命令说明: "计算并获取本对象如果转换为文本型数据时，整数部分字符的长度"
// 无参数
ECALC_EXTERN_C void ecalc_GetIntStrLen_72_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{

}

// 调用格式: SDT_INT (大数).取小数长度, 命令说明: "计算并获取本对象如果转换为文本型数据时，小数部分字符的长度，注意：尾端0将被忽略"
// 无参数
ECALC_EXTERN_C void ecalc_GetFloatStrLen_73_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{

}

// 调用格式: SDT_BYTE (大数).取字符, 命令说明: "获取本对象所表示的数字文本在任意位置的数字字符，指定的序号参数必须大于等于1且小于等于字符串长度"
// 参数<1>: 字符位置序号 SDT_INT, 参数说明: "要获取的字符在整个数字文本中的位置，序号从\"1\"开始。如果本参数指定的序号在数字文本中不存在，那么本方法将出错"
ECALC_EXTERN_C void ecalc_GetChar_74_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    INT      arg1 = pArgInf[1].m_int;

}

// 调用格式: SDT_BYTE (大数).导出字节, 命令说明: "导出本对象到字节数据，注意：本对象当前所存储的数据必须是吻合字节型的数据"
// 无参数
ECALC_EXTERN_C void ecalc_ExportByte_75_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{

}

// 调用格式: SDT_SHORT (大数).导出短整数, 命令说明: "导出本对象到短整型数据，注意：本对象当前所存储的数据必须是吻合短整型的数据"
// 无参数
ECALC_EXTERN_C void ecalc_ExportShort_76_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{

}

// 调用格式: SDT_INT (大数).导出整数, 命令说明: "导出本对象到整数型数据，注意：本对象当前所存储的数据必须是吻合整数型的数据"
// 无参数
ECALC_EXTERN_C void ecalc_ExportInt_77_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{

}

// 调用格式: SDT_INT64 (大数).导出长整数, 命令说明: "导出本对象到长整型数据，注意：本对象当前所存储的数据必须是吻合长整型的数据"
// 无参数
ECALC_EXTERN_C void ecalc_ExportInt64_78_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{

}

// 本命令被隐藏, 原始名字 = "导出小数"
// 调用格式: SDT_FLOAT (大数).导出小数, 命令说明: "导出本对象到小数型数据，注意：本对象当前所存储的数据必须是吻合小数型的数据"
// 无参数
ECALC_EXTERN_C void ecalc_ExportFloat_79_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{

}

// 本命令被隐藏, 原始名字 = "导出双精度数"
// 调用格式: SDT_DOUBLE (大数).导出双精度数, 命令说明: "导出本对象到双精度型数据，注意：本对象当前所存储的数据必须是吻合双精度型的数据"
// 无参数
ECALC_EXTERN_C void ecalc_ExportDouble_80_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{

}

// 调用格式: SDT_BOOL (大数).复制到, 命令说明: "复制当前数据到另一个目标存储大数的对象中，目标大数以前所存储的数据将被舍弃"
// 参数<1>: 目标大数 MAKELONG(0x0A, 0), 参数说明: "要复制到的目标大数"
ECALC_EXTERN_C void ecalc_CopyTo_81_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pCompoundData;

}

// 调用格式: SDT_BOOL (大数).取符号, 命令说明: "获取本对象所表示的符号，如果本对象表示正数或0，返回真，如果表示负数，则返回假"
// 无参数
ECALC_EXTERN_C void ecalc_GetSignal_82_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{

}

// 调用格式: SDT_BOOL (大数).是否有小数, 命令说明: "判断本对象是否有存储小数，有则返回真，否则返回假"
// 无参数
ECALC_EXTERN_C void ecalc_HasFloat_83_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{

}

// 调用格式: SDT_BOOL (大数).是否为零, 命令说明: "判断本对象当前所存储的数据是否为\"0\"，如果为\"0\"，则返回真；否则，返回假"
// 无参数
ECALC_EXTERN_C void ecalc_IsZero_84_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{

}

// 调用格式: SDT_BOOL (大数).等于, 命令说明: "判断本对象和指定对象是否相等。如相等，则返回真；否则，返回假"
// 参数<1>: 比较数据 MAKELONG(0x0A, 0), 参数说明: "本参数提供待和本大数数据比较的大数"
ECALC_EXTERN_C void ecalc_EqualThan_85_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pCompoundData;

}

// 调用格式: SDT_BOOL (大数).大于, 命令说明: "判断本对象是否大于指定对象。如大于，则返回真；否则，返回假"
// 参数<1>: 比较数据 MAKELONG(0x0A, 0), 参数说明: "本参数提供待和本大数数据比较的大数"
ECALC_EXTERN_C void ecalc_BiggerThan_86_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pCompoundData;

}

// 调用格式: SDT_BOOL (大数).小于, 命令说明: "判断本对象是否小于指定对象。如小于，则返回真；否则，返回假"
// 参数<1>: 比较数据 MAKELONG(0x0A, 0), 参数说明: "本参数提供待和本大数数据比较的大数"
ECALC_EXTERN_C void ecalc_SmallerThan_87_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pCompoundData;

}

// 调用格式: SDT_BOOL (大数).大于等于, 命令说明: "判断本对象是否大于等于指定对象。如大于等于，则返回真；否则，返回假"
// 参数<1>: 比较数据 MAKELONG(0x0A, 0), 参数说明: "本参数提供待和本大数数据比较的大数"
ECALC_EXTERN_C void ecalc_BiggerEqualThan_88_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pCompoundData;

}

// 调用格式: SDT_BOOL (大数).小于等于, 命令说明: "判断本对象是否小于等于指定对象。如小于等于，则返回真；否则，返回假"
// 参数<1>: 比较数据 MAKELONG(0x0A, 0), 参数说明: "本参数提供待和本大数数据比较的大数"
ECALC_EXTERN_C void ecalc_SmallerEqualThan_89_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pCompoundData;

}

// 调用格式: MAKELONG(0x0A, 0) (大数).取整数, 命令说明: "获取本对象的整数部分，小数部分将被忽略，注意：返回数据的符号和原数据一致"
// 无参数
ECALC_EXTERN_C void ecalc_GetIntPart_90_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{

}

// 调用格式: MAKELONG(0x0A, 0) (大数).取小数, 命令说明: "获取本对象的小数部分，整数部分将被忽略， 注意：返回数据的符号和原数据一致"
// 无参数
ECALC_EXTERN_C void ecalc_GetFloatPart_91_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{

}

// 调用格式: MAKELONG(0x0A, 0) (大数).加, 命令说明: "将本对象与指定对象做加法运算，并返回运算后的结果"
// 参数<1>: 计算数据 MAKELONG(0x0A, 0), 参数说明: "本参数提供待和本数据计算的大数数据"
ECALC_EXTERN_C void ecalc_Add_92_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pCompoundData;

}

// 调用格式: MAKELONG(0x0A, 0) (大数).减, 命令说明: "将本对象与指定对象做减法运算，并返回运算后的结果"
// 参数<1>: 计算数据 MAKELONG(0x0A, 0), 参数说明: "本参数提供待和本数据计算的大数数据"
ECALC_EXTERN_C void ecalc_Sub_93_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pCompoundData;

}

// 调用格式: MAKELONG(0x0A, 0) (大数).乘, 命令说明: "将本对象与指定对象做乘法运算，并返回运算后的结果"
// 参数<1>: 计算数据 MAKELONG(0x0A, 0), 参数说明: "本参数提供待和本数据计算的大数数据"
ECALC_EXTERN_C void ecalc_Mul_94_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pCompoundData;

}

// 调用格式: MAKELONG(0x0A, 0) (大数).除, 命令说明: "将本对象与指定对象做除法运算，并返回运算后的结果"
// 参数<1>: 计算数据 MAKELONG(0x0A, 0), 参数说明: "本参数提供待和本数据计算的大数数据"
// 参数<2>: 除法精度 SDT_INT, 参数说明: "本参数提供本除法运算结果的精度"
ECALC_EXTERN_C void ecalc_Div_95_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pCompoundData;
    INT      arg2 = pArgInf[2].m_int;

}

// 调用格式: MAKELONG(0x0A, 0) (大数).整除, 命令说明: "将本对象与指定对象做整除运算，并返回运算后的结果"
// 参数<1>: 计算数据 MAKELONG(0x0A, 0), 参数说明: "本参数提供待和本数据计算的大数数据"
ECALC_EXTERN_C void ecalc_DivExact_96_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pCompoundData;

}

// 调用格式: MAKELONG(0x0A, 0) (大数).求余, 命令说明: "将本对象与指定对象做求余运算，并返回运算后的结果"
// 参数<1>: 计算数据 MAKELONG(0x0A, 0), 参数说明: "本参数提供待和本数据计算的大数数据"
ECALC_EXTERN_C void ecalc_Mod_97_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pCompoundData;

}

// 本命令被隐藏, 原始名字 = "求次方"
// 调用格式: MAKELONG(0x0A, 0) (大数).求次方, 命令说明: "计算并返回本对象的指定次方"
// 参数<1>: 次方数 MAKELONG(0x0A, 0), 参数说明: "该参数指定对欲求次方数值的运算指数"
ECALC_EXTERN_C void ecalc_Pow_98_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pCompoundData;

}

// 调用格式: MAKELONG(0x0A, 0) (大数).取绝对值, 命令说明: "取本对象的绝对值"
// 无参数
ECALC_EXTERN_C void ecalc_Abs_99_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{

}

// 调用格式: SDT_BOOL (大数).负, 命令说明: "反转一个本对象的正负符号并返回反转后的值"
// 无参数
ECALC_EXTERN_C void ecalc_Neg_100_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{

}

// 调用格式: MAKELONG(0x0A, 0) (大数).四舍五入, 命令说明: "返回本对象按照指定的方式进行四舍五入运算的结果"
// 参数<1>: 舍入位置 SDT_INT, 参数说明: "如果大于0，表示小数点右边应保留的位数；如果等于0，表示舍入到整数；如果小于0，表示小数点左边舍入到的位置。例如：四舍五入 (1056.65, 1) 返回 1056.7； 四舍五入 (1056.65, 0) 返回 1057； 四舍五入 (1056.65, -1) 返回 1060"
ECALC_EXTERN_C void ecalc_Round_101_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    INT      arg1 = pArgInf[1].m_int;

}

// 调用格式: SDT_BOOL (大数).清除小数, 命令说明: "清除本对象的小数部分，成功返回真，失败返回假"
// 无参数
ECALC_EXTERN_C void ecalc_KillFloatNum_102_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{

}

// 调用格式: SDT_BOOL (大数).清除整数, 命令说明: "清除本对象的整数部分，整数部分将被重置为0，成功返回真，失败返回假"
// 无参数
ECALC_EXTERN_C void ecalc_KillIntNum_103_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{

}

// 调用格式: SDT_BOOL (大数).清除尾导零, 命令说明: "清除本对象小数部分的尾段0，成功返回真，失败返回假"
// 无参数
ECALC_EXTERN_C void ecalc_KillBackZero_104_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{

}

// 调用格式: MAKELONG(0x0A, 0) (大数).求正弦, 命令说明: "反回本对象的正弦值，目前支持计算整数的正弦值，小数部分将被忽略"
// 参数<1>: 计算精度 SDT_INT, 参数说明: "指明计算精度，注意：该精度为计算中的除法精度"
ECALC_EXTERN_C void ecalc_Sin_105_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    INT      arg1 = pArgInf[1].m_int;

}

// 调用格式: MAKELONG(0x0A, 0) (大数).求余弦, 命令说明: "反回本对象的余弦值，目前支持计算整数的余弦值，小数部分将被忽略"
// 参数<1>: 计算精度 SDT_INT, 参数说明: "指明计算精度，注意：该精度为计算中的除法精度"
ECALC_EXTERN_C void ecalc_Cos_106_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    INT      arg1 = pArgInf[1].m_int;

}

// 调用格式: MAKELONG(0x0A, 0) (大数).求正切, 命令说明: "反回本对象的正切值， 目前支持计算整数的正切值，小数部分将被忽略"
// 参数<1>: 计算精度 SDT_INT, 参数说明: "指明计算精度，注意：该精度为计算中的除法精度"
ECALC_EXTERN_C void ecalc_Tan_107_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    INT      arg1 = pArgInf[1].m_int;

}

// 调用格式: MAKELONG(0x0A, 0) (大数).求余切, 命令说明: "反回本对象的余切值， 目前支持计算整数的余切值，小数部分将被忽略"
// 参数<1>: 计算精度 SDT_INT, 参数说明: "指明计算精度，注意：该精度为计算中的除法精度"
ECALC_EXTERN_C void ecalc_Atn_108_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    INT      arg1 = pArgInf[1].m_int;

}

// 调用格式: SDT_BOOL (算式解析).求积分表达式, 命令说明: "本方法可求各种复杂的积分表达式，可含任何数学函数，如  3*exp(x)*tan(x)/(8+log(x))，并且可以检查出表达式的错误，如果积分表达式有误或计算失败，本方法将返回假，计算成功本方法返回真"
// 参数<1>: 计算表达式 SDT_TEXT, 参数说明: "该参数提供表示式文本，支持各种复杂的积分表达式，可含任何数学函数，如  3*exp(x)*tan(x)/(8+log(x))"
// 参数<2>: 积分上限 SDT_DOUBLE, 参数说明: "积分的上限"
// 参数<3>: 积分下限 SDT_DOUBLE, 参数说明: "积分的下限"
// 参数<4>: 误差 SDT_DOUBLE, 参数说明: "允许的误差"
// 参数<5>: &计算结果 SDT_DOUBLE, 参数说明: "计算的结果"
ECALC_EXTERN_C void ecalc_CalcIntegrateExpression_109_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    LPSTR    arg1 = pArgInf[1].m_pText;
    double   arg2 = pArgInf[2].m_double;
    double   arg3 = pArgInf[3].m_double;
    double   arg4 = pArgInf[4].m_double;
    double*  arg5 = pArgInf[5].m_pDouble;

}

// 本命令被隐藏, 原始名字 = "大数复制构造", 本命令为复制构造函数
// 调用格式: _SDT_NULL (大数).大数复制构造, 命令说明: NULL
// 参数<1>: UL MAKELONG(0x0A, 0), 参数说明: "省略"
ECALC_EXTERN_C void ecalc_UnlNumCopyCmd_110_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pCompoundData;

}

// 本命令被隐藏, 原始名字 = "复数复制构造", 本命令为复制构造函数
// 调用格式: _SDT_NULL (复数运算).复数复制构造, 命令说明: NULL
// 参数<1>: UL MAKELONG(0x01, 0), 参数说明: NULL
ECALC_EXTERN_C void ecalc_ComplexCopyCmd_111_ecalc(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
    void*    arg1 = pArgInf[1].m_pCompoundData;

}