sdf000

活图的DLL数值函数库

活图DLL数值计算函数库的构成和使用
活图DLL数值计算函数库目录

"活图"DLL数值计算函数库（中文版活图ver8.1现在是常州微识自动化科技有限公司产品之一http://www.microverify.com/col.jsp?id=114）：

特点：支持360种函数，包括有点集、曲线交线计算、可圆滑表示等高线的三次元插值和从136种常用曲线检出最佳拟合曲线等特殊独有函数。与其他数值函数库不同的是，内有构文解析功能，包含了可以处理类似"0.7*(1-cos(2*x)*exp(-x))"这样的F(x)函数表现式的函数。

同时具有DLL内部自动保持结果数值列的机能，呼出方无必要确保缓存领域，使DLL数值计算函数库的使用更为便利。

处理数值的个数无限制，并能进行数百万个数值的高速富里叶变换。

保持了"活图"紧凑的特征，DLL文件cut32fun.dll 本身仅420KB。

"活图"DLL数值计算函数库文件的组成：

由下述5个文件组成

cut32fun.h　　　Visual C++用函数定义头文件
　　　cut32fun.lib　　 Visual C++用输入库文件
　　　cut32fun.dll　　 DLL函数库本体文件
　　　cut32dll.hlp　　 DLL函数库帮助文件
　　　cut32dll.cnt　　帮助文件CUT32DLL.HLP的目录定义文件

　正常情况下，把DLL文件cut32fun.dll复制到Windows/目录或Windows/System/目录即可。

　另外，在cut32fun.h文件内，是这样记述DLL函数 F_val_fx()的（例）：
　　　....
　　　#define DllImport extern "C" __declspec( dllimport )
　　　....
　　　DllImport int _stdcall F_val_fx(const char* Fx, double *o_x, double *o_y, double xs, double xe, double xstep);
　　　....

函数名指定方式：

"活图"DLL数值计算函数库，是用Visual C++制作的，按照Visual C++的固有规则，呼出DLL库的函数时，用下述两种方法之一指定函数名。

函数呼名方式1：

在"活图"函数名的先头追加半角F_

例如，原函数是val_fx()，则变成F_val_fx()。

在Visual C++的输入库方法中，使用这种呼名方式。

函数呼名方式2：

在"活图"函数名先头追加半角_F_，在函数名后头追加半角@和数字（参数的合计字节数）。

例如，原函数是val_fx()，则变成_F_val_fx@36

在使用LoadLibrary(), GetProcAddress() 等API函数进行动态链接时，使用这种呼名方式。

取得DLL函数结果数值列的指针型参数：

"活图"DLL数值计算函数库，呼函数一次可以返回数列大量的结果数值。为了取得这些结果数值列，DLL函数设置了指针型参数。如果呼出方把准备好的缓存领域的开始指针设定成取得DLL函数结果数值列的指针型参数的话，DLL函数会把所求的结果数值列保存在指针参数指定的缓存领域。

例如，求y=F(x)的F_val_fx()时，第二项是o_x指针型参数，第三项是o_y指针型参数，使用这两个参数，所求得的Ｘ和Ｙ的结果数值列会返回给呼出方的。

int F_val_fx(const char* Fx, double *o_x, double *o_y, double xs, double xe, double xstep);

用缓存传递值法取得结果数值列：

缓存传递值法，就是呼出DLL的一方预先要准备好存放结果数值列的缓存领域，一旦设定好了这个缓存领域的开始指针，结果数值列就会传递到这个缓存领域的方法。

呼出DLL的一方在准备缓存领域时，一定要保证存放的领域足够大，传递缓存领域不足的话，程序就出现死机现象。

对能取得数值结果具备指针型参数的DLL函数，有取得其结果数值个数的方法。一般情况下，函数返回值返回的是结果数值列的个数。如果函数返回的两种类的结果数值列的个数不一样时，其中一种存放成个数的参数，传递给整数指针，这样可以获得结果的数值个数。

在确保结果数值的缓存领域时，必须预先知道个数值。推荐使用两回呼出的方法，第一次呼出函数时，在DLL函数把NULL指针传递给为取得结果数值列的指针参数，首先返回结果数值的个数，用这个个数确保缓存领域。第二回呼出时，确保传递缓存领域的开始指针接受结果数值列。

DLL内部自动保持结果数值列的机能

在呼出DLL函数库中的函数时，由于取得结果数值列的指针型参数传递给了NULL指针，所以不会返回结果数值列，而是自动保持在DLL内部的缓存中。

例如，用F_val_fx()计算F(x)时，本来第二项和第三项是容纳结果X和Y数值列的缓存开始指针，如果变成两个NULL指针，则结果X和Y数值列被保持在DLL内部缓存中（倍精度，小数）。

F_val_fx("0.7*(1-cos(2*x)*exp(-x))",NULL,NULL,0.0,5.0,0.01);

特征：使用DLL内部自动保持结果数值列的机能，呼出方无必要确保缓存领域，在Visual Basic的不定变量领域开发环境下比较方便。

DLL内部自动保持结果数值列的个数和顺序，和NULL指针传递的参数的数和顺序是一致的。

为了取得DLL内部自动保持结果数值，呼出函数后，请使用后述的4个专用辅助函数用直接值法取得。

下次用其他DLL数值函数（不包含辅助函数）呼出后，因为内部保持数值则全被清除。因此之前必须使用辅助函数取完结果数值列。在用API函数FreeLibrary()释放了DLL时，内部保存的结果数值被消除。

取结果数值列的DLL辅助函数：

要想知道DLL内部保持的结果数列的数值时，要使用下面四个辅助这个函数：

F_result_types:.resulttype 取得DLL内部保持的结果数列的列数.resulttype

F_result_type_num:.resulttypenum 取得指定的DLL内部保持的结果数列的数值个数

F_result_data:.resultdata 取得指定的DLL内部保持的结果数列的数值的值

F_result_buf:.resultbuf 取得指定的DLL内部保持的结果数列的缓存的开始指针

用直接值法取得结果数值列：

直接取值法就是为了获得DLL函数的结果数值列，将NULL指针传递给指针参数，把结果数值列保持在DLL内部缓存后，用上述的专用辅助函数取出内部保持的数值的方法。其最大特点是呼出方不必为取得结果数值准备缓存领域的。

例：用Visual C++输入库法呼出DLL函数F_val_fx()

void DllCallSamp2_val_fx()

{

int n = F_val_fx("0.7*(1-cos(2*x)*exp(-x))", NULL, NULL, 0.0, 5.0, 0.01);

//把参数o_x和o_y传递给NULL，把X和Y结果数值保持在DLL的内部缓存

int nType = F_result_types();

//取得内部保持的数值的列数

int nNum = F_result_type_num(0);

//取得内部保持的第一列X结果数值的个数

double *xp = new double[nNum];

//确保X结果数值的存放缓存

for( int i = 0 ; i < nNum; i ++) *(xp + i) = F_result_data(0,i);

//由F_result_data()顺次取得X的结果数值（直接值取得方法：第一步）

nNum = F_result_type_num(1);

//取得内部保持的第二列Y结果数值的个数

double *yp = new double[nNum];

//确保Y结果数值的存放缓存

double *dp = F_result_buf(1);

//由F_result_buf()取得内部保持Y结果数值缓存的开始指针（直接值取得方法：第二步）

if (dp != NULL) memcopy(yp, dp, nNum*sizeof(double));

//把Y结果数值复制到缓存yp内

………

delete xp; delete yp; //解放xp和 yp

}

用Vsual Basic 呼出DLL函数 F_val_fx的例子

Declare Function F_val_fx Lib "cut32fun.dll" Alias "_F_val_fx@36" (ByVal fx As String, ByRef x As Double, ByRef y As Double, ByVal sx As Double, ByVal ex As Double, ByVal xstep As Double) As Long

Declare Function F_val_fx_null Lib "cut32fun.dll" Alias "_F_val_fx@36" (ByVal fx As String, ByVal x As Long, ByVal y As Long, ByVal sx As Double, ByVal ex As Double, ByVal xstep As Double) As Long

Declare Function F_result_types Lib "cut32fun.dll" Alias "_F_result_types@0" () As Long

Declare Function F_result_type_num Lib "cut32fun.dll" Alias "_F_result_type_num@4" (ByVal No As Long) As Long

Declare Function F_result_data Lib "cut32fun.dll" Alias "_F_result_data@8" (ByVal No As Long, ByVal nIndex As Long) As Double

Sub calc2_val_fx()

Dim n As Integer

n = F_val_fx_null("0.7*(1-cos(2*x)*exp(-x))", ByVal 0&, ByVal 0&, 0, 360, 1)

Dim No As Integer

No = F_result_types()

Dim x(400) As Double

Dim nNum As Integer

nNum = F_result_type_num(0)

If nNum > 400 Then nNum = 400

For i = 1 To nNum

x(i) = F_result_data(0, i - 1)

Next i

Dim y(400) As Double

nNum = F_result_type_num(1)

If nNum > 400 Then nNum = 400

For i = 1 To nNum

y(i) = F_result_data(1, i - 1)

Next i

………

End Sub

C语言和Visual Basic的 Declare 文变量宣言对应规则

C函数参数宣言 VB Declare文的函数参数宣言

char * X ByVal X As String

int X ByVal X As Long

int * X ByRef X As Long

double X ByVal X As Double

double * X ByRef X As Double

double * X (NULL传递指针) ByVal X As Long (传递给NULL时，在VB的程序中使用 ByVal 0&)

用缓存传递值法取得结果数值列：

呼出DLL的一方在准备缓存领域时，一定要保证存放的领域足够大，传递缓存领域不足的话，程序就出现死机现象。

例：用Visual C++输入库法呼出DLL函数F_val_fx()

………

#include "cut32fun.h" //DLL函数的头定义文件

………

void DllCallSamp1_val_fx()

{

int n = F_val_fx("0.7*(1-cos(2*x)*exp(-x))", NULL, NULL, 0.0, 5.0, 0.01);

//把参数o_x和o_y传递给NULL，取得X和Y结果数值的个数n

double *xp = new double[n], *yp = new double[n];

//然后，确保X和Y结果数值的存放缓存

F_val_fx("0.7*(1-cos(2*x)*exp(-x))", xp, yp, 0.0, 5.0, 0.01);

//最后，把xp和 yp传递给DLL函数，X和Y的结果数值存放在这里

………

delete xp; delete yp; //解放xp和 yp

}

用Vsual Basic 呼出DLL函数 F_val_fx的例子

Declare Function F_val_fx Lib "cut32fun.dll" Alias "_F_val_fx@36" (ByVal fx As String, ByRef x As Double, ByRef y As Double, ByVal sx As Double, ByVal ex As Double, ByVal xstep As Double) As Long

Declare Function F_val_fx_null Lib "cut32fun.dll" Alias "_F_val_fx@36" (ByVal fx As String, ByVal x As Long, ByVal y As Long, ByVal sx As Double, ByVal ex As Double, ByVal xstep As Double) As Long

Sub calc1_val_fx()

Dim x(400) As Double

Dim y(400) As Double

Dim n As Integer

n = F_val_fx_null("0.7*(1-cos(2*x)*exp(-x))", ByVal 0&, ByVal 0&, 0, 360, 1)

If n < 400 Then n = F_val_fx("0.7*(1-cos(2*x)*exp(-x))", x(0), y(0), 0, 360, 1)

………

End Sub

C语言和Visual Basic的 Declare 文变量宣言对应规则

C函数参数宣言 VB Declare文的函数参数宣言

char * X ByVal X As String

int X ByVal X As Long

int * X ByRef X As Long

double X ByVal X As Double

double * X ByRef X As Double

double * X (NULL传递指针) ByVal X As Long (传递给NULL时，在VB的程序中使用 ByVal 0& )

DLL函数种类：

0.DLL用辅助函数

F_result_types(): 返回DLL内部保存的数值结果的列数

F_result_type_num(No): 返回指定的DLL内部保存数值结果列的数值个数

F_result_data(No,nIndex): 返回指定的DLL内部保存数值结果列的指定数值

F_result_buf(No): 返回指定的DLL内部保存数值结果列缓存的开始指针

F_return_data(): 获取要执行函数的原来的返回值

F_return_string(): 获取要执行函数的文字近似式

F_set_judg_data(d): 设定解收敛判定的基准值

F_error_message(): 获取当前执行的出错信息

F_fit_report(type): 获取拟合曲线族全曲线近似结果的文字报告

F_fit_curve_info(type,ibuf): 获取拟合曲线族的计算曲线的设定信息

1.三角函数

double F_sin(double d): 返回正弦（弧度）
double F_sind(double d): 返回正弦（度）
double F_cos(double d): 返回余弦（弧度）
double F_cosd(double d): 返回余弦（度）
double F_tan(double d): 返回正切（弧度）
double F_tand(double d): 返回正切（度）
double F_asin(double d): 返回反正弦（弧度）
double F_asind(double d): 返回反正弦（度）
double F_acos(double d): 返回反余弦（弧度）
double F_acosd(double d): 返回反余弦（度）
double F_atan(double d): 返回反正切（弧度,-PAI/2 - PAI/2）
double F_atand(double d): 返回反正切（度,-90 - 90）
double F_atan2(double y, double x): 返回y/x的反正切（弧度,-PAI - PAI）
double F_atan2d(double y, double x): 返回y/x的反正切（度-180 - 180）

2.平方根，指数，对数函数

double F_sqrt(double d): 返回平方根
double F_exp(double d): 返回自然指数
double F_pow(double x, double y): 返回x的y次方
double F_ln(double d): 返回自然对数 (d > 0)
double F_log(double d): 返回常用对数(d > 0)

3.双曲线函数

double F_sinh(double d): 返回双曲线正弦
double F_cosh(double d): 返回双曲线余弦
double F_tanh(double d): 返回双曲线正切
double F_asinh(double d): 返回反双曲线正弦
double F_acosh(double d): 返回反双曲线余弦(d ≧ 1.0)
double F_atanh(double d): 返回反双曲线正切(-1 < d < 1)

4.其他常用数学函数

double F_abs(double d): 返回绝对值
int F_int(double d): 返回四舍五入后的整数值
int F_fix(double d): 返回整数部分(余部扔掉)
int F_ceil(double d): 返回不小于d的最小整数值
int F_floor(double d): 返回不大于d的最大整数值
int F_sign(double d): 符号函数(1:d>0, 0:d等于0, -1:d<0)
int F_sign1(double d): 符号函数(1:d≧0, -1:d<0)
int F_sign2(double d): 符号函数(1:d>0, -1:d≦0)
double F_hypot(double x, double y): 返回以x和y为直角边的三角形的斜边长
double F_degtorad(double d): 返回角度变换值（度到弧度）
double F_radtodeg(double d): 返回角度变换值（弧度到度）
int F_euclid(int n1, int n2): 返回正整数n1和n2的最大公约数
int F_euclid1(int n1, int n2): 返回正整数n1和n2的最小公倍数
int F_euclid_n(int nun, int* ip): 返回N个正整数n1,n2,.的最大公约数
int F_euclid1_n(int num, int* ip): 返回N个正整数n1,n2,.的最小公倍数
int F_factoring(double n, double* dp): 正整数n的因数分解
int F_prime(double n, int N, double* dp): 求大于正整数n的N个连续素数
int F_combin(int n, int k): 返回由n个要素选择k个组合的组合数
int F_days(int year, int month, int day): 返回元旦开始的天数
int F_weekday(int year, int month, int day): 返回星期的日子
int F_weeks(int year, int month, int day): 返回元旦开始的周数
int F_delta(double d): 返回delta函数值(1:d=0,0:d!=0)
double F_round(double d, int n): 小数点后指定位n的四舍五入
double F_round1(double d, int n): 返回到有效位数n的四舍五入的结果
unsigned int F_bit_and(unsigned int n1,unsigned int n2): 返回两32位整数的位AND计算结果(正整数)
unsigned int F_bit_or(unsigned int n1, unsigned int n2): 返回两32位整数的位OR计算结果(正整数)
unsigned int F_bit_xor(unsigned int n1,unsigned int n2): 返回两32位整数的位XOR计算结果(正整数)
unsigned int F_bit_not(unsigned int n): 返回32位整数n的位32反转计算结果(正整数)

5.乱数函数

int F_rand(): 返回正整数1-32767之间的一样乱数
double F_rand1(): 返回0.0-1.0 之间的一样乱数
void F_rand_init(int n): 初始化乱数系列(n:乱数的种子)
double F_rand_normal(): 返回正规乱数
double F_rand_exp(): 返回指数乱数
double F_rand_triang(): 返回三角乱数
double F_rand_cauchy(): 返回柯西乱数
double F_rand_logic(): 返回逻辑乱数
int F_rand_geo(double d)(p): 返回几何乱数
int F_rand_poisson(double d): 返回泊松乱数
double F_rand_weibull(double d)(α): 返回韦布尔乱数

6.特殊函数

double F_sf_bessel1(int n, double x): 返回n次的贝塞尔第一种函数值 (\|n\|＜30000, \|x\|＜30000＝
double F_sf_bessel1a(int n, double x): 返回n次的变形贝塞尔第一种函数值 (n≧0)
double F_sf_bessel2(int n, double x): 返回n次的变形贝塞尔第二种函数值\|n\|＜30000, \|x\|＜30000＝
double F_sf_bessel2a(int n, double x): 返回n次的变形贝塞尔第二种函数值 (n≧0, x＞0)
double F_sf_gamma(double x): 返回佳玛函数值 (0＜x≦170＝
double F_sf_gamma1(double x, double v): 返回不完全佳玛函数值 (0＜x≦170, v≧0＝
double F_sf_gamma_ln(double x): 返回对数佳玛函数值(0＜x≦170＝
int F_sf_gamma_cpx(double Re, double Im, double dp): 复数佳玛函数值)([r][k]+i[r][k+1])*
double F_sf_beta(double a, double b): 返回贝塔函数值(a>0,b>0) (a>0, b>0)
double F_sf_beta1(double a, double b, double x): 返回不完全贝塔函数值 (a>0, b>0, 0≦x≦1)
double F_sf_error(double x): 返回误差函数值
double F_sf_error1(double x): 返回补误差函数值
int F_sf_poly_leg(double x, int n, double* dp): n次的鲁彊多尔多项式系数[r]
int F_sf_poly_lag(double x, int n, double* dp): n次的拉盖尔多项式系数[r]
int F_sf_poly_her(double x, int n, double* dp): n次的艾尔米多多项式系数[r]
int F_sf_poly_tch(double x, int n, double* dp): n次的柴比雪夫多项式系数[r]
double F_sf_exp_intg(double x): 返回指数积分函数值 (x>0)
double F_sf_sin_intg(double x): 返回正弦积分函数值
double F_sf_cos_intg(double x): 返回余弦积分函数值 (x>0)
double F_sf_fre_sin(double x): 返回菲涅尔正弦积分函数值
double F_sf_fre_cos(double x): 返回菲涅尔余弦积分函数值
double F_sf_ellips1(double x): 返回第一种完全椭圆积分函数值 (0≦x≦1)
double F_sf_ellips2(double x): 第二种完全椭圆积分函数值 (0≦x≦1)
double F_sf_normal(double x): 返回概率变量x的标准正规分布值 (-∞＜x＜∞＝
double F_sf_normal_inv(double d): 返回对应于概率百分率0%-100%的标准正规分布的概率变量值

7.复数函数

int F_cpx_add(double Re1, double Im1, double Re2, double Im2, double o_cpx): 両两复数的加([r][k]+i[r][k+1])*
int F_cpx_sub(double Re1, double Im1, double Re2, double Im2, double o_cpx): 两复数的减([r][k]+i[r][k+1])*
int F_cpx_mul(double Re1, double Im1, double Re2, double Im2, double o_cpx): 两复数的乘([r][k]+i[r][k+1])*
int F_cpx_div(double Re1, double Im1, double Re2, double Im2, double o_cpx): 两复数的除([r][k]+i[r][k+1])*
int F_cpx_pow(double Re, double Im, double d, double o_cpx): 复数(Re+iIm)*的d次方值([r][k]+i[r][k+1])
int F_cpx_exp(double Re, double Im, double o_cpx): 复数(Re+iIm)的指数值([r][k]+i[r][k+1])*
int F_cpx_root(double Re, double Im, int n, int m, double o_cpx): 复数(Re+iIm)*的n跟中的第m个根([r][k]+i[r][k+1])(m=1,2..n)
double F_cpx_abs(double Re, double Im): 返回复数(Re+iIm)的绝对值
double F_cpx_arg(double Re, double Im): 返回复数(Re+iIm)的偏角(-π～π)
int F_cpx_inv(double Re, double Im, double o_cpx): 复数的逆([r][k]+i[r][k+1])*
int F_cpx_ln(double Re, double Im, double o_cpx): 复数(Re+iIm)的自然对数值([r][k]+i[r][k+1])*
int F_cpx_sin(double Re, double Im, double o_cpx): 复数(Re+iIm)的正弦值([r][k]+i[r][k+1])*
int F_cpx_cos(double Re, double Im, double o_cpx): 复数(Re+iIm)的余弦值([r][k]+i[r][k+1])*
int F_cpx_tan(double Re, double Im, double o_cpx): 复数(Re+iIm)的正切值([r][k]+i[r][k+1])*
int F_cpx_sinh(double Re, double Im, double o_cpx): 复数(Re+iIm)的双曲正弦值([r][k]+i[r][k+1])*
int F_cpx_cosh(double Re, double Im, double o_cpx): 复数(Re+iIm)的双曲余弦值([r][k]+i[r][k+1])*
int F_cpx_tanh(double Re, double Im, double o_cpx): 复数(Re+iIm)的双曲正切值([r][k]+i[r][k+1])*

8.多项式演算函数

int F_poly_add(double ap, int na, double bp, int nb, double rp): 两多项式的加[r]等于[a]+[b]*
int F_poly_sub(double ap, int na, double bp, int nb, double rp): 两多项式的减[r]等于[a]-[b]*
int F_poly_mul(double ap, int na, double bp, int nb, double rp): 两多项式的乘[r]等于[a][b]**
int F_poly_div(double ap, int na, double bp, int nb, double rp1, int o_n1, double rp2): 两多项式的除[r1][b]+[r2]等于[a]**
int F_poly_pow(double ap, int na, int n, double rp): 多项式的乘方[r]等于[a]^n
int F_poly_trans(double ap, int na, double rp): 多项式[a]的转置
int F_poly_subst(double ap, int na, double bp, int nb, double rp): 多项式[b]代入多项式[a]*
int F_poly_dif(double ap, int na, double rp): 多项式[a]的微分
int F_poly_intg(double ap, int na, double rp): 多项式[a]的积分
double F_poly_val(const double ap, int na, double d): 返回实数d代入多项式[a]*的值
int F_poly_valc(const double ap, int na, double Re, double Im, double o_cpx): 复数([r][k]+i[r][k+1])代入多项式[a]的值
double F_poly_valc_abs(double ap, int na, double Re, double Im): 返回复数(Re+iIm)代入[a]的绝对值*
double F_poly_valc_arg(double ap, int na, double Re, double Im): 返回复数(Re+iIm)代入[a]的偏角值*(-π～π)
int F_polycpx_trans(double ap, int na, double rp): 复数多项式[a]的转置([a],[r]:用连续两组元的一对表示复数)
int F_polycpx_valc(const double ap, int na, double Re, double Im, double o_cpx): 复数代入复数多项式[a]的值

9.分式演算函数

int F_frac_add(const double i_f1poly, int f1poly_num, const double i_g1poly, int g1poly_num, const double i_f2poly, int f2poly_num, const double i_g2poly, int g2poly_num, double o_fpoly, int o_fpoly_num, double o_gpoly): 两分数多项式的加[of]/[og]等于([f1]/[g1])+([f2]/[g2])*
int F_frac_sub(const double i_f1poly, int f1poly_num, const double i_g1poly, int g1poly_num, const double i_f2poly, int f2poly_num, const double i_g2poly, int g2poly_num, double o_fpoly, int o_fpoly_num, double o_gpoly): 两分数多项式的减[of]/[og]等于([f1]/[g1])-([f2]/[g2])*
int F_frac_mul(const double i_f1poly, int f1poly_num, const double i_g1poly, int g1poly_num, const double i_f2poly, int f2poly_num, const double i_g2poly, int g2poly_num, double o_fpoly, int o_fpoly_num, double o_gpoly): 两分数多项式的乘[of]/[og]等于([f1]/[g1])([f2]/[g2]**
int F_frac_div(const double i_f1poly, int f1poly_num, const double i_g1poly, int g1poly_num, const double i_f2poly, int f2poly_num, const double i_g2poly, int g2poly_num, double o_fpoly, int o_fpoly_num, double o_gpoly): 两分数多项式的除[of]/[og]等于([f1]/[g1])/([f2]/[g2])*
int F_frac_isubst(const double i_fpoly, int fpoly_num, const double i_gpoly, int gpoly_num, double o_fRe_poly, int o_fRe_poly_num, double o_fIm_poly, int o_fIm_poly_num, double o_gpoly): 纯虚数ix代入分式多项式([f]/[g])的分解*
int F_frac_feedbk(const double i_f1poly, int f1poly_num, const double i_g1poly, int g1poly_num, const double i_f2poly, int f2poly_num, const double i_g2poly, int g2poly_num, double o_fpoly, int o_fpoly_num, double o_gpoly): 分数多项式传递函数的反馈演算Z*
double F_frac_val(const double i_fpoly, int fpoly_num, const double i_gpoly, int gpoly_num, double d): 返回实数代入分式多项式([f]/[g])的值
int F_frac_valc(const double i_fpoly, int fpoly_num, const double i_gpoly, int gpoly_num, double Rm, double Im, double o_cpx): 复数(Re+iIm)* 代入分式多项式([f]/[g])的值
double F_frac_valc_abs(const double i_fpoly, int fpoly_num, const double i_gpoly, int gpoly_num, double Rm, double Im): 返回复数(Re+iIm) 代入分式多项式([f]/[g])的绝对值
double F_frac_valc_arg(const double i_fpoly, int fpoly_num, const double i_gpoly, int gpoly_num, double Rm, double Im): 返回复数(Re+iIm) 代入分式多项式([f]/[g])的偏角(-π～π)

10.函数值的计算

int F_val_fx(const char* Fx, double o_x, double o_y, double xs, double xe, double xstep): 求函数y=F(x)一连的函数值
int F_val_zfxy(const char* zFxy, double o_x, double o_y, double o_z, double xs, double xe, double xstep, double ys, double ye, double ystep): 求3次元阳函数z等于F(x,y) 的函数值*
int F_val_fit_func(int curve_no, const double* i_c, int n, double o_x, double o_y, double xs, double xe, double xstep): 求指定编号No的拟合曲线值(系数[c])
double F_val_sigma(const char* Fx, double xs, double xe, double xstep): 求F(x)的连续和(x始，x终)
double F_val_seki(const char* Fx, double xs, double xe, double xstep): 求F(x)的连续积(x始，x终)
int F_valc_fx(const char* Fx, double Re, double Im, double o_cpx): 返求复数(Re+iIm)代入F(x)的值([r][k]+i[r][k+1])*
double F_valc_fx_abs(const char* Fx, double Re, double Im): 返回复数(Re+iIm)代入F(x)的绝对值
double F_valc_fx_arg(const char* Fx, double Re, double Im): 回复数(Re+iIm)代入F(x)的偏角值(-π～π)
int F_val_overlap(int peek_num, const double* i_c, int n, double o_x, double o_y, double xs, double xe, double xstep, int sum_or_single, int gauss_or_lorentz): 孤立波形系数的计算[c]

11.Bode线图向量轨迹图函数

int F_val_fx_bode(const char Fs, double o_w, double o_dB, double o_phase, double sw, double ew): 传递函数F(s)的Bode线
int F_val_frac_bode(const double i_fpoly, int fpoly_num, const double i_gpoly, int gpoly_num, double o_w, double o_dB, double o_phase, double sw, double ew): 分数多项式传递函数([f]/[g])* 的Bode线图
int F_val_fx_vect(const char Fs, double o_w, double o_Re, double o_Im, double sw, double ew): 传递函数F(s)的向量轨迹
int F_val_fx_vect1(const char Fs, const double i_w, int iw_num, double o_Re, double o_Im): 传递函数F(s)的向量轨迹图
int F_val_frac_vect(const double i_fpoly, int fpoly_num, const double i_Gpoly, int gpoly_num, double o_w, double o_Re, double o_Im, double sw, double ew): 分数多项式传递函数([f]/[g])* 的向量轨迹图
int F_val_frac_vect1(const double i_fpoly, int fpoly_num, const double i_Gpoly, int gpoly_num, const double i_w, int iw_num, double o_Re, double o_Im) : 分数多项式传递函数([f]/[g])* 的向量轨迹图

12.行列演算函数

int F_mtx_pdt(const double i_mtx, double o_mtx, double d): *行列的常数乘R(m,n)等于dA(m,n)**
int F_mtx_add(const double i_mtxA, const double i_mtxB, double o_mtx): 行列加R(m,n)*)=A(m,n)+B(m,n)
int F_mtx_sub(const double i_mtxA, const double i_mtxB, double o_mtx): 行列减R(m,n)*=A(m,n)-B(m,n)
int F_mtx_mul(const double i_mtxA, const double i_mtxB, double o_mtx): 行列乘R(m,l)=A(m,n)B(n,l)
int F_mtxcpx_mul(const double i_mtxA, const double i_mtxB, double o_mtx): 复数行列乘R(m,l)=A(m,n)B(n,l) ([A],[B],[R]:用连续2组元表示一个复数)
double F_mtx_det(const double i_mtx): 返回正方行列的行列式A(n,n)*
int F_mtxcpx_det(const double i_mtx, double o_cpx): 复数正方行列的行列式A(n,n) ([r][k]+i[r][k+1])([A]: 用连续2组元表示一个复数)
int F_mtx_inv(const double i_mtx, double o_mtx): 正则行列A(n,n)的逆行列R(n,n)=1/A(n,n)
int F_mtx_trid_inv(const double i_sub, int n_sub, const double i_diag, int n_diag, const double i_sup, int n_sup, double o_mtx): 3重对角行列的逆行列
int F_mtxcpx_inv(const double i_mtx, double o_mtx): 复数正则行列A(n,n)的逆行列([A],[R]: 用连续2组元表示一个复数)
double F_mtx_trace(const double i_mtx): 返回正方行列A(n,n)*的迹
int F_mtx_eigen(const double i_mtx, double o_mtx): 实对称行列的固有值固有向量
int F_mtx_eigen1(const double i_diag, int n_diag, const double i_sup, int n_sup, double *o_mtx): 3重实对称行列的固有值固有向量
int F_mtx_eigen2(const double i_mtx, double o_cpx): 任意实正方行列的复数固有值
int F_mtx_from_trid(const double i_sub, int n_sub, const double i_diag, int n_diag, const double i_sup, int n_sup, double o_mtx): 3重对角行列变换成一般行列
int F_mtx_to_trid(const double i_mtx, double o_sub, int o_nsub, double o_diag, int o_ndiag, double o_sup): 一般行列变换成3重对角行列
int F_mtx_from_vander(const double i_d, int nd, double o_mtx): Vandermonde行列变换成一般行列
int F_mtx_to_vander(const double i_mtx, double o_d): 一般行列变换成Vandermonde行列

13.方程式解函数

double F_fx_one(const char Fx, double x0, double e): 返回F(x)等于0在x0的一个实数解*
int F_fx_equ(const char Fx, double xs, double xe, double xstep, double e, double o_x): 求F(x)等于0在区间[x始,x终]的全实数解
double F_poly_one(const double i_a, int na, double x0, double e): 返回高次代数方程式x0的一个实数解*
int F_poly_cpx_one(const double i_a, int na, double Re, double Im, double e, double o_cpx): 求高次代数方程式的值(Re+iIm)的一个复数解([r][k]+i[r][k+1])
int F_poly_equ(const double i_a, int na, double o_cpx): 求高次代数方程式的全复数解([r]: 用连续2组元表示一个复数)
int F_polycpx_equ(const double i_a, int na, double e, double o_cpx): 复数代数方程式的复数解([a],[r]: 用连续2组元表示一个复数)
int F_root_locus(const double i_a, int na, double o_K, int o_nK, double o_Re, double o_Im, double Ks, double Ke, double Kstep): 复数代数方程式的根轨迹*
int F_root_locus1(const double i_a, int na, const double i_K, int nK, double o_Re, double o_Im): 复数代数方程式的根轨迹(iK指定)

14.连立方程式解函数

int F_mtxequ_lu(const double i_mtxA, const double i_B, int nB, double o_R): 求连立方程式的实数解(LU分解法)A(n,n)R(n)等于B(n)**
int F_mtxequ_chol(const double i_mtxA, const double i_B, int nB, double o_R): 求连立方程式的实数解(考莱丝基法) A(n,n)R(n)等于B(n)**
int F_mtxequ_gauss(const double i_mtxA, const double i_B, int nB, double o_R): 求连立方程式的实数解(高斯约旦法) A(n,n)R(n)等于B(n)**
int F_mtxequ_trid(const double i_sub, int n_sub, const double i_diag, int n_diag, const double i_sup, int n_sup, const double i_B, int nB, double *o_R): 求3重对角连立方程式的实数解
int F_mtxequ_vander(const double i_d, const double i_B, int n, double o_R): 求Vandermonde连立方程式的实数解*
int F_mtxcpxequ_gauss(const double i_mtxA, const double i_B, int nB, double o_R): 複求复数连立方程式的复数解([A],[B],[R]:* 用连续2组元表示一个复数)

15.常微分方程式数值解函数

int F_dif_equn(const char Fxy, double i_a, int ns, double i_t, int nt, int n, double x0, double h, double o_x, double o_y, double xs, double xe, double xstep): 求高次常微分方程式的解(初值问题)*
int F_dif_equ1(const char Fxy, double x0, double y0, double h, double o_x, double o_y, double xs, double xe, double xstep): 求任意一次常微分方程式的解(初值问题)*
int F_dif_equ2(const char Fxyy1, double x0, double y0, double y01, double h, double o_x, double o_y, double xs, double xe, double xstep): 求任意二次常微分方程式的解(初值问题)*
int F_dif_equ3(const char Fxyy1y2, double x0, double y0, double y01, double y02, double h, double o_x, double o_y, double xs, double xe, double xstep): 求任意三次常微分方程式的解(初值问题)*

16.数值微分函数

int F_dif_xiyi(const double i_x, const double i_y, int n, double o_x, double o_dydx, double xs, double xe, double xstep): X单调数值曲线的三次样条一次微分
int F_dif_curve(const double i_x, const double i_y, int n, double o_dydx, int Free0_Close1): 任意数值曲线的三次样条一次微分*
int F_dif_fx(const char Fx, double o_x, double o_dydx, double xs, double xe, double xstep): 函数曲线F(x)的数值微分*
int F_taylor(const char Fx, double x0, double dx, int n, double o_c): 函数F(x)在x0的n次台劳展开

17.数值积分函数

double F_intg_trape(const double i_x, const double i_y, int nxy): 返回数值曲线的数值积分值(台形法)
int F_intg_trape1(const double i_x, const double i_y, int nxy, double o_dxdy): 求数值曲线的数值积分值曲线(台形法)*
double F_intg_simp2(const double i_x, const double i_y, int nxy): 求数值曲线的数值积分值(2次辛谱森法)
int F_intg_simp21(const double i_x, const double i_y, int nxy, double o_dxdy): 求数值曲线的数值积分值曲线(2次辛谱森法)*
double F_intg_simp3(const double i_x, const double i_y, int nxy): 求数值曲线的数值积分值(3次辛谱森法)
int F_intg_simp31(const double i_x, const double i_y, int nxy, double o_dxdy): 求数值曲线的数值积分值曲线(3次辛谱森法)*
double F_intg_spline(const double i_x, const double i_y, int nxy, double sx, double ex): 求X单调的数值曲线的三次样条数值积分值
double F_intg_fx(const char i_Fx, double sx, double ex, double xstep): 求函数曲线F(x)的数值积分值(台形法)*
int F_intg_fx1(const char i_Fx, double sx, double ex, double xstep, double o_x, double o_dxdy): 求函数曲线F(x)的数值积分值曲线(台形法)*

18.拉谱拉斯逆变换函数

int F_lapinv_fx(const char Fs, double o_t, double o_y, double st, double et, double tstep): 任意式F(s)的拉谱拉斯逆变换*
int F_lapinv_frac(const double i_fpoly, int fpoly_num, const double i_gpoly, int gpoly_num, double o_t, double o_y, double st, double et, double tstep): 分数多项式([f]/[g]) 的拉谱拉斯逆变换
int F_lapinv_fx1(const char Fs, double o_t, double o_y, double st, double et, double tstep, int n): 任意式F(s)的拉谱拉斯逆变换精度(0-5)*指定

19.高速富里叶变换、窗口函数

int F_fft(const double i_Re, const double i_Im, int i_num, double o_Re, double o_Im, int k): 高速富里叶正逆变换(复数输入)
int F_fft_hz(const double i_Re, const double i_Im, int i_num, double o_Re, double o_Im, double o_Hz, double dt): 高速富里叶正变换(复数输入,对应Hz输出)*
int F_tfft(const double i_Re, int i_num, double o_A,double o_Phase): 高速富里叶正变换(实数输入,振幅相位输出)*
int F_tfft_inv(const double i_A, const double i_Phase, int i_num, double o_Re, double o_Im): 高速富里叶逆变换(振幅相位输入,复数输出)
int F_tfft_hz(const double i_Re, int i_num, double o_A, double o_Phase, double o_Hz, double dt): 高速富里叶正变换(实数输入, 振幅相位对应Hz输出)
int F_dft(const double i_Re, const double i_Im, int i_num, double o_Re, double o_Im, int k): 离散富里叶正逆变换(个数任意,复数输入出)
int F_dft_2d(const double i_Re, const double i_Im, int i_num, int Nx, int Ny, double o_Re, double o_Im, int k): 二次元富里叶正逆变换(复数输入出)
int F_tdft_2d(const double i_Re, int i_num, int Nx, int Ny, double o_Re, double o_Im): 二次元富里叶正变换(实数输入,振幅相位输出)*
int F_filter(const double i_d, int i_num, double o_d, double dt, double L_Hz, double H_Hz): 理想型带通滤波器[L_Hz,H_Hz]( 使用高速富里叶变换)
int F_filter1(const double i_d, int i_num, double o_d, double dt, double L_Hz, double H_Hz): 理想型带止滤波器[L_Hz,H_Hz]( 使用高速富里叶变换)
int F_wn_hanning(const double i_d, int i_num, int centerCell, int width, double o_d): 时系列[i]的Hanning窗口处理
int F_wn_hamming(const double i_d, int i_num, int centerCell, int width, double o_d): 时系列[i]的Hamming 窗口处理
int F_wn_triangle(const double i_d, int i_num, int centerCell, int width, double o_d): 时系列[i]的Triangle 窗口处理
int F_wn_blackman(const double i_d, int i_num, int centerCell, int width, double o_d): 时系列[i]的Blackman 窗口处理
int F_wn_square(const double i_d, int i_num, int centerCell, int width, double o_d): 时系列[i]的Square 窗口处理
int F_wn_tsg(const double i_d, int i_num, int centerCell, int width, double o_d): 时系列[i]的Three Sigma Gauss 窗口处理
int F_win_center(const double i_d, int i_num, double o_d, int half_width, int add_cells, int type): 时系列的中心对称窗口处理(种类:0-5)
int F_win_left(const double i_d, int i_num, double o_d, int half_width, int add_cells, int type): 时系列的[i]的左侧对称窗口处理(种类:0-5)
int F_win_right(const double i_d, int i_num, double o_d, int half_width, int add_cells, int type): 时系列的[i]的右侧对称窗口处理(种类:0-5)

20.频谱推定函数

int F_pow_spect(const double i_d, int i_num, double o_d): 时系列[i]的能率频谱推定(自相关后富里叶变换)
int F_pow_spect_hz(const double i_d, int i_num, double o_d, double o_Hz, double dt): 时系列[i]的能率频谱推定(自相关后富里叶变换)*
int F_mem_spect(const double i_d, int i_num, double o_Hz, double o_d, double dt, double sHz, double eHz, double stepHz, int N): 时系列[i]的频谱推定(最大安拖罗皮法,对应Hz输出)*
int F_mem_spect1(const double i_d, int i_num, double o_c, int N): 时系列[i]的频谱推定(最大安拖罗皮法,系数输出)

21.平面、空间插值函数

int F_lagrange(const double i_x, const double i_y, int i_num, double o_x, double o_y, double xs, double ex, double xstep): 有序点列的拉哥郎日插值
int F_spline(const double i_x, const double i_y, int i_num, double o_x, double o_y, double xs, double ex, double xstep): 有序点列的自然三次样条插值(X单调)
int F_spline1(const double i_x, const double i_y, int i_num, double o_c): 求自然三次样条插值的区分多项式系数*
int F_spline_curve(const double i_x, const double i_y, int i_num, double o_x, double o_y, int s_div, int f): 有序点列的自然三次样条插值(任意曲线)
int F_b_spline(const double i_x, const double i_y, int i_num, double o_x, double o_y, int s_div): 有序点列的B自然三次样条插值(1次2次微分连续)
int F_draft_spline(const double i_x, const double i_y, int i_num, double o_x, double o_y, int s_div): 有序点列的云形自然三次样条插值(通过数据点,1次微分连续
int F_mix_spline(const double i_x, const double i_y, int i_num, double o_x, double o_y, int s_div): 有序点列的混合自然三次样条插值(通过数据点,2次微分连续)
int F_bezier(const double i_x, const double i_y, int i_num, double o_x, double o_y, int s_div): 有序点列的贝塞尔插值
int F_nbezier(const double i_x, const double i_y, int i_num, double o_x, double o_y, int s_div, int n): 有序点列的N次贝塞尔插值
int F_full_bezier(const double i_x, const double i_y, int i_num, double o_x, double o_y, int w_div): 有序点列的完全贝塞尔插值
int F_spline_3d(const double i_x, const double i_y, const double i_z, int i_num, int i_nx, int i_ny, double o_x, double o_y, double o_z, int o_Nx, int o_Ny): 列型行列形式数据的三次元插值(小四角形内指定均分数)
int F_spline_3d1(const double i_x, const double i_y, const double i_z, int i_num, int i_nx, int i_ny, double o_x, double o_y, double o_z, int o_tNx, int o_tNy): 列型行列形式数据的三次元插值(指定均分总数)
int F_fem_3d(const double i_x, const double i_y, const double i_z, int i_num, int i_nx, int i_ny, double o_x, double o_y, double o_z, int o_Nx, int o_Ny): 列型行列形式数据的三次元插值(FEM法, 小四角形内指定均分
int F_fem_3d1(const double i_x, const double i_y, const double i_z, int i_num, int i_nx, int i_ny, double o_x, double o_y, double o_z, int o_tNx, int o_tNy): 列型行列形式数据的三次元插值(FEM法, 小四角形内指定
int F_spline_3d2(const double i_x, const double i_y, const double i_z, int i_num, int i_nx, int i_ny, double o_x, double o_y, double o_z, double x1, double y1, double x2, double y2, int o_tNx, int o_tNy): 三次元插值(输出范围指定,可扩张)
double F_spline_3d3(const double i_x, const double i_y, const double i_z, int i_num, int i_nx, int i_ny, double ox, double oy): 列型行列形式数据的任意点的三次元插值(范围外可)*
int F_auto_3d(const double i_x, const double i_y, const double i_z, int i_num, int nx, int ny, double o_x, double o_y, double o_z, double x1, double y1, double x2, double y2, int o_tNx, int o_tNy): 无规则点集规则自动化后三次元插值
int F_auto_3d1(const double i_x, const double i_y, const double i_z, int i_num, int o_nx, int o_ny, double o_x, double o_y, double o_z, double x1, double y1, double x2, double y2): 无规则空间点集规则自动化

22.近似、曲线拟合函数

int F_fit_poly(const double i_x, const double i_y, int i_num, double o_x, double o_y, double xs, double ex, double xstep, int N): N次多项式近似,返回文字近似式
int F_fit_poly1(const double i_x, const double i_y, int i_num, double o_c, int N): N次多项式近似,系数输出*
int F_fit_poly2(const double i_x, const double i_y, int i_num, const double i_ox, int ox_num, double o_y, int N): N次多项式近似,指定[oix], 返回文字近似式
int F_fit_poly3(const double i_x, const double i_y, int i_num, double alpha, const double i_ox, int ox_num, double o_yl, double o_yh, int N): 推定N次多项式近似的信赖区间*
int F_fit_poly4(const double i_x, const double i_y, int i_num, double alpha, const double i_ox, int ox_num, double o_yl, double o_yh, int N): 预测N次多项式近似的信赖区间*
double F_fit_poly5(const double i_x, const double i_y, int i_num, int N): 返回近似的零假说检定值(计算有意水准S)
int F_fit_npoly(const double i_x, const double i_y, int i_num, double o_x, double o_y, double xs, double ex, double xstep, const double i_c, int c_num): 任意指定次数多项式近似,* 返回文字近似式
int F_fit_npoly1(const double i_x, const double i_y, int i_num, double o_c, const double i_c, int c_num):任意指定次数多项式近似,系数输出
int F_fit_npoly2(const double i_x, const double i_y, int i_num, const double i_ox, int ox_num, double o_y, const double i_c, int c_num): 任意指定次数多项式近似,* 指定[oix], 返回文字近似式
int F_fit_exp(const double i_x, const double i_y, int i_num, double o_x, double o_y, double xs, double ex, double xstep): *指数y等于Aexp(Bx)近似, 返回文字近似式**
int F_fit_ln(const double i_x, const double i_y, int i_num, double o_x, double o_y, double xs, double ex, double xstep): *自然对数y等于Aln(Bx)近似, 返回文字近似式**
int F_fit_log(const double i_x, const double i_y, int i_num, double o_x, double o_y, double xs, double ex, double xstep): *常用对数y等于Alog(Bx)近似, 返回文字近似式**
int F_fit_10exp(const double i_x, const double i_y, int i_num, double o_x, double o_y, double xs, double ex, double xstep): *指数y等于A10^(Bx)近似, 返回文字近似式**
int F_fit_pow(const double i_x, const double i_y, int i_num, double o_x, double o_y, double xs, double ex, double xstep): *乘方y等于Ax^B近似, 返回文字近似式**
int F_fit_ellips(const double i_x, const double i_y, int i_num, double o_c): 椭圆近似([o][1]:圆心x[o][2]:圆心y[o][3]:半径x[o][4]:半径y),* 返回文字近似式
int F_fit_best(const double i_x, const double i_y, int i_num, double o_x, double o_y, double xs, double ex, double xstep, double o_c,int oc_num): 最适曲线拟合近似([残差]:连续的曲线编号和残差的对), 返回文
int F_fit_best1(const double i_x, const double i_y, int i_num, double o_c, int oc_num): 最适曲线拟合近似, 最适曲线的系数[o系数]输出(A,B,C,D,..的顺)
int F_fit_best2(const double i_x, const double i_y, int i_num, const double i_ox, int ox_num, double o_y, double o_c, int oc_num): 最适曲线拟合近似,指定[OIX]([残差]:连续的曲线编号和残差的对), 返回文
int F_fit_one(const double i_x, const double i_y, int i_num, double o_x, double o_y, double xs, double ex, double xstep, int No): 指定编号拟合曲线近似, 返回文字近似式
int F_fit_one1(const double i_x, const double i_y, int i_num, double o_c, int No): 指定编号拟合曲线近似,* 曲线的系数[o系数]输出(A,B,C,D,..的顺)
int F_fit_one2(const double i_x, const double i_y, int i_num, const double i_ox, int ox_num, double o_y, int No): 指定编号拟合曲线近似, 指定[OIX] 返回文字近似式
int F_fit_one3(const double i_x, const double i_y, int i_num, double alpha, const double i_ox, int ox_num, double o_yl, double o_yh, int No): 推定指定编号拟合曲线的信赖区间*
int F_fit_one4(const double i_x, const double i_y, int i_num, double alpha, const double i_ox, int ox_num, double o_yl, double o_yh, int No): 预测指定编号拟合曲线的信赖区间*
double F_fit_one5(const double i_x, const double i_y, int i_num, int No):返回指定编号拟合曲线的零假说检定值(计算有意水准S)
int F_fit_frac(const double i_x, const double i_y, int i_num, double o_f, int of_num, double o_g, int f_N, int g_N): 次数指定的分数多项式近似*
int F_multi_reg(const double i_mtx, const double i_y, double o_c): 多重回归近似*
int F_fit_univ(const char FxABC, const double i_x, const double i_y, int i_num, const double i_c, int ic_num, double e, double o_x, double o_y, double xs, double ex, double xstep, double o_c, int oc_num): 任意式近似(A,B,C:要求的系数)
int F_fit_univ1(const char FxABC, const double i_x, const double i_y, int i_num, const double i_c, int ic_num, double e, double o_c): 任意式近似(A,B,C:* 要求的系数),系数输出
int F_fit_univ2(const char FxABC, const double i_x, const double i_y, int i_num, const double i_c, int ic_num, double e, const double i_ox, int ox_num, double o_y): 任意式近似(A,B,C: 要求的系数),指定[oix]
int F_fit_normal(const double i_x, const double i_y, int i_num, double o_x, double o_y, double xs, double ex, double xstep, double o_c,int oc_num): 正规分布曲线近似
int F_fit_overlap_init(const double i_x, const double i_y, int i_num, double o_c, int type): 重叠波形的个数判断(初系数输出)*
int F_fit_overlap(const double i_x, const double i_y, int i_num, double e, double o_x, double o_y, double xs, double ex, double xstep, double o_c,int oc_num, int type): 重叠波形分离(自动决定初系数)
int F_fit_overlap1(const double i_x, const double i_y, int i_num, const double i_c, int ic_num, double e, double o_x, double o_y, double xs, double ex, double xstep, double o_c,int oc_num, int type): 重叠波形分离(自动决定初*)

23..相关、平滑函数

int F_auto_cor(const double i_d, int i_num, double o_d, int f1, int f2): 数值组的自相关
int F_xiyi_cor(const double i_x, int ix_num, const double i_y, int iy_num, double o_d): 两数值组的互相关*
int F_fxyi_cor(const char Fx, const double i_y, int iy_num, double o_d, double dx): 函数和数值组的互相关*
int F_smooth(int n, const double i_d, int i_num, double o_d): 按多项式适用法移动平滑(有重叠)
int F_smooth1(int n, const double i_d, int i_num, double o_d): 移动平滑法的平滑(同一重叠)
int F_smooth_fft(double p, const double i_d, int i_num, double o_d): 富里叶变换平滑化(消除振幅比p%以下的频谱成分,0%
int F_smooth_fft1(double p, const double i_d, int i_num, double o_d): 富里叶变换平滑化(只保留先头p%的频谱成分,0%

24.数值统计计算函数

double F_sum(const double i_d, int i_num): 返回数值组[i]*的和
double F_abs_sum(const double i_d, int i_num): 返回数值组[i]的绝对值和*
double F_mean(const double i_d, int i_num): 返回数值组[i]的平均值*
double F_meandev(const double i_d, int i_num): 返回数值组[i]的平均绝对偏差*
double F_stddev(const double i_d, int i_num): 返回数值组[i]的标准偏差(/n)*
double F_stddev1(const double i_d, int i_num): 返回数值组[i]的标准偏差(/(n-1))*
double F_abs_mean(const double i_d, int i_num): 返回数值组[i]的绝对值的平均值*
double F_square_mean(const double i_d, int i_num): 返回数值组[i]的平方值的平均值*
double F_geo_mean(const double i_d, int i_num): 返回数值组[i]的(正实数)几何平均值*
double F_ham_mean(const double i_d, int i_num): 返回数值组[i]的(非零数)调和平均值*
double F_variance(const double i_d, int i_num): 返回数值组[i]的分散*
int F_histgram(const double i_d, int i_num, double o_val, double o_count): 求数值组[i]的直方图([o]:* 值,[o个数]: 值,[o]对应的个数)
int F_histgram1(const double i_d, int i_num, const double i_ref, int ref_num, double o_count): 按照数值组[ref]区间分割,* 求数值组[i]的直方图(邻接两组元定义一个区间)
double F_correlation(const double i_x, const double i_y, int i_num): 返回两数值组的相关系数
double F_test_t(const double i_x, int x_num, const double i_y, int y_num): 返回两分布平均差的T检定(等分散)
double F_test_tu(const double i_x, int x_num, const double i_y, int y_num): 返回两分布平均差的T检定(异分散)
double F_test_tp(const double i_x, const double i_y, int i_num): 返回两分布平均差的T检定(对标本)
double F_test_f(const double i_x, int x_num, const double i_y, int y_num): 返回两分布平均差的F检定
double F_t_distrib(int n, double alpha): 返回自由度n时概率的T分布
double F_f_distrib(int m, int n, double alpha): 返回自由度m和n时概率T的F分布
double F_chi_distrib(int n, double alpha): 返回自由度n时概率的K2乘分布
int F_linear_prog(const double i_mtx, int m1, int m2, int m3, double o_c) : 线性计划法(辛谱赖枯斯法)

28.数据形式变换函数

int F_xiyi_to_xyi(const double i_x, const double i_y, int i_num, double o_d): 在[o]内将[ix]和[iy]一个一个交替放入*
int F_xiyizi_to_xyzi(const double i_x, const double i_y, const double i_z, int i_num, double o_d): 在[o]内将[ix]和[iy] [iz]一个一个交替放入[o]
int F_xyi_to_xiyi(const double i_d, int i_num, double o_x, double o_y): 将[i]的组元一个一个交替放入[ox]和[oy]*
int F_xyzi_to_xiyizi(const double i_d, int i_num, double o_x, double o_y, double o_z): 将[i]的组元一个一个交替放入[ox]和[oy][oz]
int F_mtx_to_net(const double i_mtx, double o_d): 行列变换成列型行列
int F_net_to_mtx(const double i_d, int i_num, double o_d, int m, int n): 列型行列变换成行列
int F_xy_to_net(const double i_x, int ix_num, const double i_y, int iy_num, double o_x, double o_y): XY的2单列坐标变换成能表示四角網目的2个列型行列
int F_net_to_xy(const double i_x, const double i_y, int i_num, double o_x, int ox_num, double o_y): 能表示四角網目的2个列型行列变换成XY*的2单列坐标
int F_xiyi_to_x2y2(const double i_x, const double i_y, int i_num, double o_x, double o_y): 曲线分解成平面线段(连续两组元表示一根线段)
int F_xiyizi_to_x2y2z2(const double i_x, const double i_y, const double i_z, int i_num, double o_x, double o_y, double o_z): 空间曲线分解成空间线段(连续两组元表示一根线段)
int F_x2y2_to_xiyi(const double i_x, const double i_y, int i_num, double o_x, double o_y): 平面线段(连续两组元表示一根线段)连接成曲线
int F_x2y2z2_to_xiyizi(const double i_x, const double i_y, const double i_z, int i_num, double o_x, double o_y, double o_z): 空间线段(连续两组元表示一根线段)连接成空间曲线
int F_net_to_x4y4(const double i_x, const double i_y, int i_num, int m, int n, double o_x, double o_y): 列型行列分解成平面独立四角形群(连续4组元表示一个四角形)
int F_net_to_x4y4z4(const double i_x, const double i_y, const double i_z, int i_num, int m, int n, double o_x, double o_y, double o_z): 列型行列分解成空间独立四角形群
int F_ary_to_net(double sx, double ex, double xstep, double sy, double ey, double ystep, double o_x, double o_y): 做成表示四角網目的2个列型行列
int F_ary_to_x4y4(double sx, double ex, double xstep, double sy, double ey, double ystep, double o_x, double o_y): 做成平面独立四角形群(连续4组元表示一个四角形)
int F_fem_to_x3y3z3(const double i_x, const double i_y, const double i_z, int i_num, const double i_n1, const double i_n2, const double i_n3, int in_num, double o_x, double o_y, double o_z): FEM型3D数据变换成独立三角形群*
int F_fem_to_x4y4z4(const double i_x, const double i_y, const double i_z, int i_num, const double i_n1, const double i_n2, const double i_n3, const double i_n4, int in_num, double o_x, double o_y, double o_z): FEM型3D数据变换成独立四角形群
int F_x3y3z3_to_fem(const double i_x, const double i_y, const double i_z, int i_num, double o_x, double o_y, double o_z, int o_num, double o_n1, double o_n2, double o_n3): 独立三角形群3D数据变换成
int F_x4y4z4_to_fem(const double i_x, const double i_y, const double i_z, int i_num, double o_x, double o_y, double o_z, int o_num, double o_n1, double o_n2, double o_n3, double o_n4): 独立四角形群3D数据变换成FEM*
int F_mtx_trans1(const double i_mtx, double o_mtx, int type): 行列的纵横排列
int F_net_trans(const double i_d, int i_num, int m, int n, double o_d, int type): 列型行列的纵横排列
int F_arrange_2d(const double i_x, const double i_y, int i_num, int type, double x0, double y0, double o_x, double o_y): 靠近(x0,y0)对平面三角形群/四角形群再整列
int F_arrange_3d(const double i_x, const double i_y, const double i_z, int i_num, int type, double x0, double y0, double o_x, double o_y, double o_z): 靠近(x0,y0)对空间三角形群/四角形群再整列

29.峰值检出(包络线)函数

int F_peak_xiyi(const double i_x, const double i_y, int i_num, double o_x, double o_y, int type): 峰值检出(包络线)
int F_peak1_xiyi(const double i_x, const double i_y, int i_num, double o_x, double o_y, int type, double yd): 峰值检出(包络线)(指定阈值yd)
int F_peak2_xiyi(const double i_x, const double i_y, int i_num, double o_x, double o_y, int type, double dx, double dy): 峰值检出(包络线)(带延迟x,y)
int F_peak_fx(const char Fx, double o_x, double o_y, double xs, double xe, double xstep, int type): F(x)* 峰值检出(包络线)
int F_peak_num(const double i_x, const double i_y, int i_num, int type): 返回峰值的数目
int F_peak1_num(const double i_x, const double i_y, int i_num, int type, double yd): 返回峰值的数目(指定阈值yd)
int F_peak2_num(const double i_x, const double i_y, int i_num, int type, double dx, double dy): 返回峰值的数目(带延迟x,y)
int F_peak_cell(const double i_x, const double i_y, int i_num, int type, int No): 返回指定峰值的组元编号
int F_peak1_cell(const double i_x, const double i_y, int i_num, int type, double yd, int No): 返回指定峰值的组元编号(指定阈值yd)
int F_peak2_cell(const double i_x, const double i_y, int i_num, int type, double dx, double dy, int No): 返回指定峰值的组元编号(带延迟x,y)

31.等高线、交线演算函数

int F_contour(const double i_x, const double i_y, const double i_z, int i_num, int type, double z, double o_x, double o_y): (z等于z0)时3D数据的等高线*
int F_contour_3d(const double i_x, const double i_y, const double i_z, int i_num, int type, double A, double B, double C, double D, double o_x, double o_y): 3D数据和面Ax+By+Cz等于D的2点交线段(面上交线)*
int F_contour_3d1(const double i_x, const double i_y, const double i_z, int i_num, int type, double A, double B, double C, double D, double o_x, double o_y, double o_z): 3D数据和面Ax+By+Cz等于D的空间2点交线段
int F_trans_3d(const double i_x, const double i_y, const double i_z, int i_num, double A, double B, double C, double D, double o_x, double o_y, double o_z, int type): 面Ax+By+Cz等于D直角坐标系和普通直角坐标系的变换

32.点集的三角、四角分割函数

int F_dots_bound(const double i_x, const double i_y, int i_num, double o_x, double o_y): 平面点集的境界(凸包)
int F_dots_bound1(const double i_x, const double i_y, int i_num, double o_x, double o_y, double angle): 平面点集的境界(凹包)
int F_quad_2d(const double i_x, const double i_y, int i_num, int Nx, int Ny, double o_x, double o_y): 平面点集分割成规则平面四角形群
int F_quad_3d(const double i_x, const double i_y, const double i_z, int i_num, int Nx, int Ny, double o_x, double o_y, double o_z): 空间点集分割成规则空间四角形群
int F_delaunay_2d(const double i_x, const double i_y, int i_num, double o_x, double o_y): 平面点集分割成平面delaunay三角形網
int F_delaunay_3d(const double i_x, const double i_y, const double i_z, int i_num, double o_x, double o_y, double o_z): 空间点集分割成空间delaunay三角形網
int F_delaunay1_3d(const double i_x, const double i_y, const double i_z, int i_num, double o_x, double o_y, double o_z, int n): 空间点集细分割成空间delaunay三角形網(n=1～5)
int F_varonoi(const double i_x, const double i_y, int i_num, double o_x, double o_y): 由delaunay三角形網作出varonoi图

33.其它曲线演算函数

int F_triang_circle(double x1, double y1, double x2, double y2, double x3, double y3, double o_d): 三角形的外接圆圆心([o][1],[o][2])和半径[o][3]*
int F_triang_circle1(double x1, double y1, double x2, double y2, double x3, double y3, double o_d): 三角形的内接圆圆心([o][1],[o][2])和半径[o][3]*
double F_area_triang(double a, double b, double c): 3边长的三角形面积
double F_area_poly(const double i_x, const double i_y, int i_num): 返回平面多角形的面积(有序)
int F_barycenter(const double i_x, const double i_y, int i_num, double o_x, double o_y): 平面多角形的重心位置([ox][1],[oy][1])
double F_length_2d(const double i_x, const double i_y, int i_num): 返回平面曲线全长
double F_length_3d(const double i_x, const double i_y, const double i_z, int i_num): 返回空间曲线全长*
int F_distance(const double i_x, const double i_y, int i_num, double px, double py, double o_x, double o_y): 返回点和直线间的最短直线([ox][1],[oy][1]-[ox][2],[oy][2]),返回距离
int F_rotate_2d(const double i_x, const double i_y, int i_num, double angle_x, double angle_y, double o_x, double o_y): 平面点集的旋转演算(度)

你可能感兴趣的:(活图的DLL数值函数库)

使用GCC编译Notepad++的插件硫酸锌01 Windows C/C++notepad++windows c++
Notepad++的本体1是支持使用MSVC和GCC编译的2，但是Notepad++插件的官方文档3里却只给出了MSVC的编译指南4。网上也没有找到相关的讨论，所以我尝试在Windows上使用MinGW，基于GCC-8.1.0的posix-sjlj线程版本5，研究一下怎么编译：官方例程：https://github.com/npp-plugins/plugindemo语法修改：在StaticDia
视觉工程师：工业相机50问钢铁男儿机器视觉机器视觉工业相机
1：工业相机的丢帧的问题是由什么原因引起的?经常会有一些机器视觉工程师认为USB接口的工业相机会造成丢帧现象。一般而言，工业相机丢帧与工业相机所采用的传输接口是没有关系的，无论是USB，还是1394、GigE、或者是CameraLink。设计不良的驱动程序或工业相机硬件才是造成丢帧的真正原因：设计不良的工业相机之所以会发生丢帧的现象，其实就是资料通道的堵塞，无法及时处理,所以新的图像进来时，前一张
解决Python中递归报错的问题硫酸锌01 Python python
1、问题背景Duringhandlingoftheaboveexception,anotherexceptionoccurred:有没有见到过这个报错？当出现这个报错的时候，意味着报错信息特别特别地长，难以关注到有效信息。那么这种报错是如何产生的？以及如何设计才能避免产生这种冗长的报错？2、我的需求如果我有一个Python的多维数组列表：lst=[[[1,2],[3,4]],[[5,6],[7,8
我的Notepad++插件推荐硫酸锌01 Windows ide 编辑器
上一篇文章我对x86版本的Notepad++官方支持的167个第三方插件，做了一个总结和翻译介绍。这几天我对感兴趣的插件做了一些测试，推荐22个高频使用的实用插件。Notepad++的插件可以从菜单栏的插件-插件管理中查找并下载：或者也可以下载文件后将插件拷贝到Notepad++安装目录下的plugins目录下。其中本文提到的全部22个插件我已经上传到了网盘。其中我对dll文件使用了upx压缩，所
Notepad++绿色版：便携高效的代码编辑器 FasterThanMind
本文还有配套的精品资源，点击获取简介：Notepad++是一款免费且无需安装的绿色版源代码编辑器，专为编程和文本处理设计。它支持多种编程语言的语法高亮、宏功能、增强的查找和替换、多文档界面、插件支持、编码转换、智能提示、个性化设置以及轻量级运行。Notepad++体积小、启动快，且对Windows平台具有良好的兼容性，适合在任何Windows系统计算机上使用，包括最新的Windows11。这款编辑
标签转换脚本 - VOC格式转COCO格式，即voc2coco，xml2json 附VOC及COCO标签格式详解 Limiiiing YOLO训练/写作脚本 YOLO 计算机视觉目标检测深度学习
前言本文的脚本功能为将VOC数据集的标签文件xml转成COCO的标签文件，指定自己的VOC数据集的标签文件路径后，可一键运行转成COCO的标签文件。专栏目录：YOLO训练/写作脚本目录一览|涉及标签转换、数据扩充、热力图、感受野、精度曲线、数量统计等近百个脚本文件专栏地址：YOLO训练/写作脚本——丰富文章内容，增强实验信服力，助力发文！！！文章目录前言一、VOC数据集介绍1.1总体结构1.2各标
标签转换脚本 - VOC格式转YOLO格式，即voc2yolo，xml2txt 附VOC及YOLO标签格式详解 Limiiiing YOLO训练/写作脚本 YOLO 深度学习计算机视觉目标检测
前言本文的脚本功能为将VOC数据集的标签文件xml转成YOLO的标签文件，指定自己的VOC数据集的标签文件路径后，可一键运行转成YOLO的标签文件。专栏目录：YOLO训练/写作脚本目录一览|涉及标签转换、数据扩充、热力图、感受野、精度曲线、数量统计等近百个脚本文件专栏地址：YOLO训练/写作脚本——丰富文章内容，增强实验信服力，助力发文！！！文章目录前言一、VOC数据集介绍1.1总体结构1.2各标
蓝桥杯Python赛道备赛——Day6：算术（二）（数学问题） SKY YEAM 蓝桥杯备赛蓝桥杯 python 职场和发展
本期博客是蓝桥杯备赛中算术（数学问题）的第二期，包括：快速幂算法、逆元（模意义下的倒数）、组合数计算和排列数计算。每一种数学问题都在给出定义的同时，给出了其求解方法的示例代码，以供低年级师弟师妹们学习和练习。前序知识：（1）Python基础语法算术（二）（数学问题）一、快速幂算法二、逆元（模意义下的倒数）三、组合数计算四、排列数计算一、快速幂算法1.定义：快速计算大指数幂的算法。2.算法原理：二进
蓝桥杯Python赛道备赛——Day1：基础算法 SKY YEAM 蓝桥杯备赛蓝桥杯 python 算法
本博客就蓝桥杯中的基础算法（这一部分说是算法，但更是一些简单的操作）进行罗列，包括：枚举、模拟、前缀和、差分、二分查找、进制转换、贪心、位运算和双指针。每一个算法都在给出概念解释的同时，给出了示例代码，以供低年级师弟师妹们学习和练习。前序知识：（1）Python基础语法（2）PythonOOP（面向对象编程）基础算法（操作）一、枚举二、模拟三、前缀和四、差分五、二分查找六、进制转换七、贪心八、位运
如何用python做一个小程序进行炒股？大懒猫软件 python 小程序开发语言
使用Python分析股票的完整程序以下是一个完整的Python程序，展示如何获取股票数据、进行数据清洗、计算技术指标、并进行简单的价格走势分析。1.安装必要的库首先，确保安装了必要的库：bash复制pipinstallrequestspandasmatplotlibyfinance2.获取股票数据使用yfinance库获取股票数据。yfinance是一个流行的库，可以方便地从雅虎财经获取股票数据。
[RA-L 2023] Coco-LIC：基于非均匀 B 样条的连续时间紧密耦合 LiDAR-惯性-相机里程计十年一梦实验室 c++
这段代码是一个基于C++的均匀B样条（UniformB-spline）实现，专门用于表示SE(3)变换（即三维空间中的刚体变换，包括旋转和平移）。以下是对代码的总结：1.许可证和版权使用BSD3-ClauseLicense，允许在满足条件的情况下自由分发和修改。版权归VladyslavUsenko和NikolausDemmel所有，属于Basalt项目的一部分。2.功能概述文件定义了一个模板类Se
Android 使用MediaPlayer播放音频详解吴硼 android java
目录一、官方资料二、简单介绍三、MediaPlayer使用1.创建MediaPlayer实例2.重要API3.状态图4.代码5.常用API6.辅助效果总结一、官方资料MediaPlayer概览https://developer.android.google.cn/guide/topics/media/mediaplayer?hl=zh_cnMediaPlayer文档https://develope
The import android.media.audiofx.AcousticEchoCanceler cannot be resolved Dev_Hanyu Android开发
RT.android.media.audiofx.AcousticEchoCanceler，AddedinAPIlevel16需要将App的目标SDK版本变成16选择项目右键properties，选择Android，然后勾选版本SDK-16.版本选择最好是看下工程的AndroidManifest.xml，选择一样的。target：SDK-16。成功！
工程化与框架系列（9）--前端监控体系一进制ᅟᅠ ‌‍‎‏ 前端工程化与框架前端
前端监控体系前端监控是现代Web应用不可或缺的组成部分，它帮助我们了解应用的运行状况、用户行为和潜在问题。本文将详细介绍如何构建一个完整的前端监控体系。监控体系概述小知识：前端监控体系通常包括性能监控、错误监控、用户行为分析和业务监控四大模块，通过这些数据可以全面了解应用的健康状况和用户体验。为什么需要前端监控在复杂的前端应用中，监控系统能够帮助我们：及时发现问题捕获JS运行时错误监控API请求异
Spring Boot 整合 Redis 使用教程小小鸭程序员 spring java spring boot mysql redis
Redis是一种高性能的键值存储数据库，常用于缓存、会话管理和消息队列等场景。SpringBoot通过SpringDataRedis提供了简洁的整合方式。1.环境准备1.1添加依赖在pom.xml中添加Redis依赖（SpringBoot3.x）：org.springframework.bootspring-boot-starter-data-redisredis.clientsjedis2.配置
蓝桥杯Python赛道备赛——Day7：动态规划（基础） SKY YEAM 蓝桥杯备赛蓝桥杯 python 动态规划
本博客就蓝桥杯中所涉及的动态规划基础问题进行讲解，包括：递推、记忆化搜索、最长公共子序列（LCS）和最长上升子序列（LIS）。每一种动态规划问题都在给出定义的同时，给出了其求解方法的示例代码，以供低年级师弟师妹们学习和练习。前序知识：（1）Python基础语法动态规划（基础）一、递推（迭代法）二、记忆化搜索（递归+缓存）三、最长公共子序列（LCS）四、最长上升子序列（LIS）一、递推（迭代法）定义
Spring设计模式八股速记高层模块底层模块依赖倒置原则开闭原则接口隔离原则她说喜欢是装的. #SpringBoot #JavaSE web后端开发 java 开发语言 cocoa github macos objective-c 数据库
目录高层模块底层模块一、定义与核心思想二、实现方式三、优点与价值四、典型应用场景五、与其他原则的关系示例说明依赖倒置原则一、定义与核心思想二、实现方式三、优点与价值四、典型应用场景五、与其他原则的关系示例说明自己理解开闭原则1.抽象化与接口设计2.封装与模块化3.多态性与继承机制4.依赖抽象而非具体实现5.设计原则的协同作用总结接口隔离原则一、核心定义二、与单一职责原则的区别三、应用场景与实现方式
工程化与框架系列（36）--前端监控告警实践一进制ᅟᅠ ‌‍‎‏ 前端工程化与框架前端
前端监控告警实践引言前端监控是保障应用质量和用户体验的重要手段。本文将深入探讨前端监控的实现方案，包括性能监控、错误监控、用户行为监控等方面，以及相应的告警机制。监控系统概述前端监控系统主要包括以下方面：性能监控：页面加载、资源加载、接口性能等错误监控：JS错误、接口错误、资源加载错误等用户行为：PV/UV、点击行为、路由变化等业务监控：转化率、留存率、业务指标等告警系统：规则配置、通知分发、告警
链上赋能：智能合约重塑供应链管理 Echo_Wish 前沿技术人工智能智能合约 linux 运维
链上赋能：智能合约重塑供应链管理供应链是现代经济活动的核心，而复杂的供应链环节常常面临诸多挑战：数据孤岛、信息不透明、操作低效甚至信任危机。这些问题不仅增加了运营成本，还导致资源浪费。随着区块链技术的兴起，供应链管理迎来了新的解决方案，其中智能合约（SmartContract）作为区块链的重要组成部分，正在颠覆传统的供应链管理模式。在本文中，我将结合Python开发与智能合约，探讨智能合约在供应链
单例模式详解（java）搞不懂语言的程序员重拾java java基础知识单例模式 java 开发语言
以下是一个线程安全、防反射攻击、防序列化破坏的单例模式完整实现，结合真实场景问题解决方案，附带逐行中文注释：importjava.io.Serializable;importjava.lang.reflect.Constructor;/***单例模式终极实现方案（解决：线程安全、反射攻击、序列化破坏问题）*/publicclassUltimateSingletonimplementsSeriali
量子信息理论入门：探索量子世界的奇妙信息处理方式 Echo_Wish Python 进阶量子计算
量子信息理论入门：探索量子世界的奇妙信息处理方式在日益智能化的现代世界，信息论是各个领域的“幕后英雄”，从通信、数据压缩到加密，无处不在。而量子信息理论则是它的升级版，利用量子力学的奇妙特性，为信息处理开辟了全新的天地。那么，什么是量子信息理论？它与传统信息论有何不同？今天，我，Echo_Wish，将带你解锁量子信息理论的奥秘，用通俗的方式让你感受到这门学科的魅力。一、什么是量子信息理论？量子信息
单例模式详解：实现方法、优缺点及应用场景技术拾光者设计模式单例模式 java 设计模式
在软件设计中，单例模式（SingletonPattern）是一种常用的设计模式。它的主要目的是确保一个类只有一个实例，并提供一个全局访问点。单例模式在许多场景中都有广泛的应用，例如日志记录器、配置管理器、线程池等。本文将详细介绍单例模式的定义、实现方法、优缺点以及应用场景，并通过代码示例帮助你更好地理解和应用这一设计模式。单例模式是一种创建型设计模式，其核心思想是确保一个类只有一个实例，并提供一个
AVX-512近似计算double浮点数倒数指令东北豆子哥数值计算/数值优化 C++线性代数
AVX-512指令集提供了对双精度浮点数（double）的高效支持，包括近似计算倒数的操作。你可以使用VRCP14PD指令来近似计算双精度浮点数的倒数。1.VRCP14PD指令VRCP14PD指令用于计算packeddouble-precisionfloating-point值的近似倒数，精度约为14位。2.代码示例以下是一个使用AVX-512指令集计算双精度浮点数倒数的示例代码：#include
量子计算+AI：未来AI Agent的计算范式 AI天才研究院计算 ChatGPT DeepSeek RL 强化学习 agent agi 推理模型智能驾驶
量子计算+AI：未来AIAgent的计算范式关键词：量子计算，人工智能，AIAgent，量子算法，量子机器学习，量子优化，量子数据处理摘要：量子计算和人工智能（AI）的结合正在改变AIAgent的计算范式。通过量子计算的超强算力和独特性质，AIAgent在数据处理、算法优化和决策能力方面展现出巨大潜力。本文将详细探讨量子计算与AI结合的核心概念、算法原理、系统架构，并通过实际案例展示量子AIAge
AI人工智能深度学习算法：在量子计算中的应用 AI天才研究院 AI大模型企业级应用开发实战 AI大模型应用入门实战与进阶 DeepSeek R1 &大数据AI人工智能大模型计算科学神经计算深度学习神经网络大数据人工智能大型语言模型 AI AGI LLM Java Python 架构设计 Agent RPA
1.背景介绍随着科技的不断发展，人工智能和量子计算成为了当今世界的热门话题。人工智能的深度学习算法在处理大规模数据和复杂任务方面取得了显著的成果，而量子计算则具有强大的并行计算能力和高效的信息处理能力。将人工智能与量子计算相结合，为解决一些具有挑战性的问题提供了新的思路和方法。本文将探讨人工智能深度学习算法在量子计算中的应用，包括其背景、意义和应用场景。2.核心概念与联系在人工智能中，深度学习是一
Java学习--关键字月色很柔 Java 学习 java
Java学习--关键字前言关键字finalstaticsuperthis实现前言本文主要参考：here;若需要可直接前往学习。关键字final、Static、super、this…final区分final、finally、finalize：理解final的含义：final意为最终的含义，用来修饰类、方法和变量。修饰类：publicfinalclassClassName{}被final修饰的类不能被
【Java】ReadWriteLock浅谈风起云涌~ java 开发语言 jvm
一，概述在多读少写的场景下，可以使用读写锁优化性能。读锁本质是一种共享锁，即，如果ReadLock获取锁成功，只会阻塞WriteLock锁的获取，不会阻塞其它线程ReadLock锁的获取。而写锁就是正常的独占锁。二，简单实例一个简单demo，读者可体会。publicstaticvoidmain(String[]args){ReadWriteLocklock=newReentrantReadWrit
【Java】StampedLock浅谈风起云涌~ java 开发语言
1，概述在多读少写的环境，相比于ReadWriteLoock，StampedLock性能更胜一筹。试着想一下，如果使用ReadWriteLoock，当1万个读请求过来时，写的操作插入，就会被阻塞。但StampedLock不会，后者不基于AQS实现，它采用乐观锁的思维。所谓的乐观，即读取的时候，不会阻塞当前线程，相应会返回一个邮票，state。读取完毕后，只要验证手上的邮票判断数据是否变化即可，随后
设计模式详解：提高代码复用性与可维护性的关键誰能久伴不乏设计模式
文章目录设计模式详解：提高代码复用性与可维护性的关键1.设计模式的分类2.创建型设计模式2.1单例模式（SingletonPattern）工作原理：代码示例：线程安全：2.2工厂方法模式（FactoryMethodPattern）工作原理：代码示例：适用场景：2.3抽象工厂模式（AbstractFactoryPattern）工作原理：代码示例：适用场景：2.4建造者模式（BuilderPatter
C++ Map 查询时的两个小细节：`map[id]` 与 `map.value(id, nullptr)` 的区别誰能久伴不乏 c++java 开发语言
文章目录C++Map查询时的两个小细节：`map[id]`与`map.value(id,nullptr)`的区别1.`map[id]`—直接访问和自动插入新元素示例代码：关键点：适用场景：2.`map.value(id,nullptr)`—安全查询并避免插入新元素示例代码：关键点：适用场景：3.对比：`map[id]`与`map.value(id,nullptr)`的区别4.总结：选择合适的方式5
JVM StackMapTable 属性的作用及理解 lijingyao8206 jvm 字节码 Class文件 StackMapTable
在Java 6版本之后JVM引入了栈图(Stack Map Table)概念。为了提高验证过程的效率，在字节码规范中添加了Stack Map Table属性，以下简称栈图，其方法的code属性中存储了局部变量和操作数的类型验证以及字节码的偏移量。也就是一个method需要且仅对应一个Stack Map Table。在Java 7版
回调函数调用方法百合不是茶 java
最近在看大神写的代码时,.发现其中使用了很多的回调 ,以前只是在学习的时候经常用到 ,现在写个笔记记录一下代码很简单: MainDemo :调用方法得到方法的返回结果
[时间机器]制造时间机器需要一些材料 comsci 制造
根据我的计算和推测,要完全实现制造一台时间机器,需要某些我们这个世界不存在的物质和材料... 甚至可以这样说,这种材料和物质,我们在反应堆中也无法获得......
开口埋怨不如闭口做事邓集海邓集海做人做事工作
“开口埋怨，不如闭口做事。”不是名人名言，而是一个普通父亲对儿子的训导。但是，因为这句训导，这位普通父亲却造就了一个名人儿子。这位普通父亲造就的名人儿子，叫张明正。　　　　张明正出身贫寒，读书时成绩差，常挨老师批评。高中毕业，张明正连普通大学的分数线都没上。高考成绩出来后，平时开口怨这怨那的张明正，不从自身找原因，而是不停地埋怨自己家庭条件不好、埋怨父母没有给他创造良好的学习环境。　　　　
jQuery插件开发全解析，类级别与对象级别开发 IT独行者 jquery 开发插件　函数
jQuery插件的开发包括两种：一种是类级别的插件开发，即给 jQuery添加新的全局函数，相当于给 jQuery类本身添加方法。 jQuery的全局函数就是属于 jQuery命名空间的函数，另一种是对象级别的插件开发，即给 jQuery对象添加方法。下面就两种函数的开发做详细的说明。 1 、类级别的插件开发类级别的插件开发最直接的理解就是给jQuer
Rome解析Rss 413277409 Rome解析Rss
import java.net.URL; import java.util.List; import org.junit.Test; import com.sun.syndication.feed.synd.SyndCategory; import com.sun.syndication.feed.synd.S
RSA加密解密无量加密解密 rsa
RSA加密解密代码代码有待整理 package com.tongbanjie.commons.util; import java.security.Key; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPairGenerat
linux 软件安装遇到的问题 aichenglong linux 遇到的问题 ftp
1 ftp配置中遇到的问题 500 OOPS: cannot change directory 出现该问题的原因:是SELinux安装机制的问题.只要disable SELinux就可以了修改方法:1 修改/etc/selinux/config 中SELINUX=disabled 2 source /etc
面试心得 alafqq 面试
最近面试了好几家公司。记录下；支付宝，面试我的人胖胖的，看着人挺好的；博彦外包的职位，面试失败；阿里金融，面试官人也挺和善，只不过我让他吐血了。。。由于印象比较深，记录下； 1，自我介绍 2，说下八种基本类型；（算上string。楼主才答了3种，哈哈，string其实不是基本类型，是引用类型） 3，什么是包装类，包装类的优点； 4，平时看过什么书？NND，什么书都没看过。。照样
java的多态性探讨百合不是茶 java
java的多态性是指main方法在调用属性的时候类可以对这一属性做出反应的情况 //package 1; class A{ public void test(){ System.out.println("A"); } } class D extends A{ public void test(){ S
网络编程基础篇之JavaScript-学习笔记 bijian1013 JavaScript
1.documentWrite <html> <head> <script language="JavaScript"> document.write("这是电脑网络学校"); document.close(); </script> </h
探索JUnit4扩展：深入Rule bijian1013 JUnit Rule 单元测试
本文将进一步探究Rule的应用，展示如何使用Rule来替代@BeforeClass，@AfterClass，@Before和@After的功能。在上一篇中提到，可以使用Rule替代现有的大部分Runner扩展，而且也不提倡对Runner中的withBefores()，withAfte
[CSS]CSS浮动十五条规则 bit1129 css
这些浮动规则，主要是参考CSS权威指南关于浮动规则的总结，然后添加一些简单的例子以验证和理解这些规则。 1. 所有的页面元素都可以浮动 2. 一个元素浮动后，会成为块级元素，比如<span>,a, strong等都会变成块级元素 3.一个元素左浮动，会向最近的块级父元素的左上角移动，直到浮动元素的左外边界碰到块级父元素的左内边界；如果这个块级父元素已经有浮动元素停靠了
【Kafka六】Kafka Producer和Consumer多Broker、多Partition场景 bit1129 partition
0.Kafka服务器配置 3个broker 1个topic，6个partition，副本因子是2 2个consumer，每个consumer三个线程并发读取 1. Producer package kafka.examples.multibrokers.producers; import java.util.Properties; import java.util.
zabbix_agentd.conf配置文件详解 ronin47 zabbix 配置文件
Aliaskey的别名，例如 Alias=ttlsa.userid:vfs.file.regexp[/etc/passwd,^ttlsa:.:([0-9]+),,,,\1]，或者ttlsa的用户ID。你可以使用key：vfs.file.regexp[/etc/passwd,^ttlsa:.: ([0-9]+),,,,\1]，也可以使用ttlsa.userid。备注: 别名不能重复，但是可以有多个
java--19.用矩阵求Fibonacci数列的第N项 bylijinnan fibonacci
参考了网上的思路，写了个Java版的： public class Fibonacci { final static int[] A={1,1,1,0}; public static void main(String[] args) { int n=7; for(int i=0;i<=n;i++){ int f=fibonac
Netty源码学习-LengthFieldBasedFrameDecoder bylijinnan java netty
先看看LengthFieldBasedFrameDecoder的官方API http://docs.jboss.org/netty/3.1/api/org/jboss/netty/handler/codec/frame/LengthFieldBasedFrameDecoder.html API举例说明了LengthFieldBasedFrameDecoder的解析机制，如下：实
AES加密解密 chicony 加密解密
AES加解密算法，使用Base64做转码以及辅助加密： package com.wintv.common; import javax.crypto.Cipher; import javax.crypto.spec.IvParameterSpec; import javax.crypto.spec.SecretKeySpec; import sun.misc.BASE64Decod
文件编码格式转换 ctrain 编码格式
package com.test; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream;
mysql 在linux客户端插入数据中文乱码 daizj mysql 中文乱码
1、查看系统客户端，数据库，连接层的编码查看方法： http://daizj.iteye.com/blog/2174993 进入mysql，通过如下命令查看数据库编码方式： mysql> show variables like 'character_set_%'; +--------------------------+------
好代码是廉价的代码 dcj3sjt126com 程序员读书
长久以来我一直主张：好代码是廉价的代码。当我跟做开发的同事说出这话时，他们的第一反应是一种惊愕，然后是将近一个星期的嘲笑，把它当作一个笑话来讲。当他们走近看我的表情、知道我是认真的时，才收敛一点。当最初的惊愕消退后，他们会用一些这样的话来反驳： “好代码不廉价，好代码是采用经过数十年计算机科学研究和积累得出的最佳实践设计模式和方法论建立起来的精心制作的程序代码。” 我只
Android网络请求库——android-async-http dcj3sjt126com android
在iOS开发中有大名鼎鼎的ASIHttpRequest库，用来处理网络请求操作，今天要介绍的是一个在Android上同样强大的网络请求库android-async-http，目前非常火的应用Instagram和Pinterest的Android版就是用的这个网络请求库。这个网络请求库是基于Apache HttpClient库之上的一个异步网络请求处理库，网络处理均基于Android的非UI线程，通
ORACLE 复习笔记之SQL语句的优化 eksliang SQL优化 Oracle sql语句优化 SQL语句的优化
转载请出自出处：http://eksliang.iteye.com/blog/2097999 SQL语句的优化总结如下 sql语句的优化可以按照如下六个步骤进行：合理使用索引避免或者简化排序消除对大表的扫描避免复杂的通配符匹配调整子查询的性能 EXISTS和IN运算符下面我就按照上面这六个步骤分别进行总结：
浅析：Android 嵌套滑动机制（NestedScrolling） gg163 android 移动开发滑动机制嵌套
谷歌在发布安卓 Lollipop版本之后，为了更好的用户体验，Google为Android的滑动机制提供了NestedScrolling特性 NestedScrolling的特性可以体现在哪里呢？ 比如你使用了Toolbar，下面一个ScrollView，向上滚
使用hovertree菜单作为后台导航 hvt JavaScript jquery .net hovertree asp.net
hovertree是一个jquery菜单插件，官方网址：http://keleyi.com/jq/hovertree/ ，可以登录该网址体验效果。 0.1.3版本：http://keleyi.com/jq/hovertree/demo/demo.0.1.3.htm hovertree插件包含文件： http://keleyi.com/jq/hovertree/css
SVG 教程（二）矩形天梯梦 svg
SVG <rect> SVG Shapes SVG有一些预定义的形状元素，可被开发者使用和操作：矩形 <rect> 圆形 <circle> 椭圆 <ellipse> 线 <line> 折线 <polyline> 多边形 <polygon> 路径 <path>
一个简单的队列 luyulong java 数据结构队列
public class MyQueue { private long[] arr; private int front; private int end; // 有效数据的大小 private int elements; public MyQueue() { arr = new long[10]; elements = 0; front
基础数据结构和算法九：Binary Search Tree sunwinner Algorithm
A binary search tree (BST) is a binary tree where each node has a Comparable key (and an associated value) and satisfies the restriction that the key in any node is larger than the keys in all
项目出现的一些问题和体会 Steven-Walker DAO Web servlet
第一篇博客不知道要写点什么，就先来点近阶段的感悟吧。这几天学了servlet和数据库等知识，就参照老方的视频写了一个简单的增删改查的，完成了最简单的一些功能，使用了三层架构。 dao层完成的是对数据库具体的功能实现，service层调用了dao层的实现方法，具体对servlet提供支持。 &
高手问答：Java老A带你全面提升Java单兵作战能力！ ITeye管理员 java
本期特邀《Java特种兵》作者：谢宇，CSDN论坛ID: xieyuooo 针对JAVA问题给予大家解答，欢迎网友积极提问，与专家一起讨论! 作者简介：淘宝网资深Java工程师，CSDN超人气博主，人称“胖哥”。 CSDN博客地址： http://blog.csdn.net/xieyuooo 作者在进入大学前是一个不折不扣的计算机白痴，曾经被人笑话过不懂鼠标是什么，

int F_poly_add(double ap, int na, double bp, int nb, double rp): 两多项式的加[r]等于[a]+[b]*
int F_poly_sub(double ap, int na, double bp, int nb, double rp): 两多项式的减[r]等于[a]-[b]*
int F_poly_mul(double ap, int na, double bp, int nb, double rp): 两多项式的乘[r]等于[a][b]**
int F_poly_div(double ap, int na, double bp, int nb, double rp1, int o_n1, double rp2): 两多项式的除[r1][b]+[r2]等于[a]**
int F_poly_pow(double ap, int na, int n, double rp): 多项式的乘方[r]等于[a]^n
int F_poly_trans(double ap, int na, double rp): 多项式[a]的转置
int F_poly_subst(double ap, int na, double bp, int nb, double rp): 多项式[b]代入多项式[a]*
int F_poly_dif(double ap, int na, double rp): 多项式[a]的微分
int F_poly_intg(double ap, int na, double rp): 多项式[a]的积分
double F_poly_val(const double ap, int na, double d): 返回实数d代入多项式[a]*的值
int F_poly_valc(const double ap, int na, double Re, double Im, double o_cpx): 复数([r][k]+i[r][k+1])代入多项式[a]的值
double F_poly_valc_abs(double ap, int na, double Re, double Im): 返回复数(Re+iIm)代入[a]的绝对值*
double F_poly_valc_arg(double ap, int na, double Re, double Im): 返回复数(Re+iIm)代入[a]的偏角值*(-π～π)
int F_polycpx_trans(double ap, int na, double rp): 复数多项式[a]的转置([a],[r]:用连续两组元的一对表示复数)
int F_polycpx_valc(const double ap, int na, double Re, double Im, double o_cpx): 复数代入复数多项式[a]的值

int F_frac_add(const double i_f1poly, int f1poly_num, const double i_g1poly, int g1poly_num, const double i_f2poly, int f2poly_num, const double i_g2poly, int g2poly_num, double o_fpoly, int o_fpoly_num, double o_gpoly): 两分数多项式的加[of]/[og]等于([f1]/[g1])+([f2]/[g2])*
int F_frac_sub(const double i_f1poly, int f1poly_num, const double i_g1poly, int g1poly_num, const double i_f2poly, int f2poly_num, const double i_g2poly, int g2poly_num, double o_fpoly, int o_fpoly_num, double o_gpoly): 两分数多项式的减[of]/[og]等于([f1]/[g1])-([f2]/[g2])*
int F_frac_mul(const double i_f1poly, int f1poly_num, const double i_g1poly, int g1poly_num, const double i_f2poly, int f2poly_num, const double i_g2poly, int g2poly_num, double o_fpoly, int o_fpoly_num, double o_gpoly): 两分数多项式的乘[of]/[og]等于([f1]/[g1])([f2]/[g2]**
int F_frac_div(const double i_f1poly, int f1poly_num, const double i_g1poly, int g1poly_num, const double i_f2poly, int f2poly_num, const double i_g2poly, int g2poly_num, double o_fpoly, int o_fpoly_num, double o_gpoly): 两分数多项式的除[of]/[og]等于([f1]/[g1])/([f2]/[g2])*
int F_frac_isubst(const double i_fpoly, int fpoly_num, const double i_gpoly, int gpoly_num, double o_fRe_poly, int o_fRe_poly_num, double o_fIm_poly, int o_fIm_poly_num, double o_gpoly): 纯虚数ix代入分式多项式([f]/[g])的分解*
int F_frac_feedbk(const double i_f1poly, int f1poly_num, const double i_g1poly, int g1poly_num, const double i_f2poly, int f2poly_num, const double i_g2poly, int g2poly_num, double o_fpoly, int o_fpoly_num, double o_gpoly): 分数多项式传递函数的反馈演算Z*
double F_frac_val(const double i_fpoly, int fpoly_num, const double i_gpoly, int gpoly_num, double d): 返回实数代入分式多项式([f]/[g])的值
int F_frac_valc(const double i_fpoly, int fpoly_num, const double i_gpoly, int gpoly_num, double Rm, double Im, double o_cpx): 复数(Re+iIm)* 代入分式多项式([f]/[g])的值
double F_frac_valc_abs(const double i_fpoly, int fpoly_num, const double i_gpoly, int gpoly_num, double Rm, double Im): 返回复数(Re+iIm) 代入分式多项式([f]/[g])的绝对值
double F_frac_valc_arg(const double i_fpoly, int fpoly_num, const double i_gpoly, int gpoly_num, double Rm, double Im): 返回复数(Re+iIm) 代入分式多项式([f]/[g])的偏角(-π～π)

int F_val_fx_bode(const char Fs, double o_w, double o_dB, double o_phase, double sw, double ew): 传递函数F(s)的Bode线
int F_val_frac_bode(const double i_fpoly, int fpoly_num, const double i_gpoly, int gpoly_num, double o_w, double o_dB, double o_phase, double sw, double ew): 分数多项式传递函数([f]/[g])* 的Bode线图
int F_val_fx_vect(const char Fs, double o_w, double o_Re, double o_Im, double sw, double ew): 传递函数F(s)的向量轨迹
int F_val_fx_vect1(const char Fs, const double i_w, int iw_num, double o_Re, double o_Im): 传递函数F(s)的向量轨迹图
int F_val_frac_vect(const double i_fpoly, int fpoly_num, const double i_Gpoly, int gpoly_num, double o_w, double o_Re, double o_Im, double sw, double ew): 分数多项式传递函数([f]/[g])* 的向量轨迹图
int F_val_frac_vect1(const double i_fpoly, int fpoly_num, const double i_Gpoly, int gpoly_num, const double i_w, int iw_num, double o_Re, double o_Im) : 分数多项式传递函数([f]/[g])* 的向量轨迹图

int F_mtx_pdt(const double i_mtx, double o_mtx, double d): *行列的常数乘R(m,n)等于dA(m,n)**
int F_mtx_add(const double i_mtxA, const double i_mtxB, double o_mtx): 行列加R(m,n)*)=A(m,n)+B(m,n)
int F_mtx_sub(const double i_mtxA, const double i_mtxB, double o_mtx): 行列减R(m,n)*=A(m,n)-B(m,n)
int F_mtx_mul(const double i_mtxA, const double i_mtxB, double o_mtx): 行列乘R(m,l)=A(m,n)B(n,l)
int F_mtxcpx_mul(const double i_mtxA, const double i_mtxB, double o_mtx): 复数行列乘R(m,l)=A(m,n)B(n,l) ([A],[B],[R]:用连续2组元表示一个复数)
double F_mtx_det(const double i_mtx): 返回正方行列的行列式A(n,n)*
int F_mtxcpx_det(const double i_mtx, double o_cpx): 复数正方行列的行列式A(n,n) ([r][k]+i[r][k+1])([A]: 用连续2组元表示一个复数)
int F_mtx_inv(const double i_mtx, double o_mtx): 正则行列A(n,n)的逆行列R(n,n)=1/A(n,n)
int F_mtx_trid_inv(const double i_sub, int n_sub, const double i_diag, int n_diag, const double i_sup, int n_sup, double o_mtx): 3重对角行列的逆行列
int F_mtxcpx_inv(const double i_mtx, double o_mtx): 复数正则行列A(n,n)的逆行列([A],[R]: 用连续2组元表示一个复数)
double F_mtx_trace(const double i_mtx): 返回正方行列A(n,n)*的迹
int F_mtx_eigen(const double i_mtx, double o_mtx): 实对称行列的固有值固有向量
int F_mtx_eigen1(const double i_diag, int n_diag, const double i_sup, int n_sup, double *o_mtx): 3重实对称行列的固有值固有向量
int F_mtx_eigen2(const double i_mtx, double o_cpx): 任意实正方行列的复数固有值
int F_mtx_from_trid(const double i_sub, int n_sub, const double i_diag, int n_diag, const double i_sup, int n_sup, double o_mtx): 3重对角行列变换成一般行列
int F_mtx_to_trid(const double i_mtx, double o_sub, int o_nsub, double o_diag, int o_ndiag, double o_sup): 一般行列变换成3重对角行列
int F_mtx_from_vander(const double i_d, int nd, double o_mtx): Vandermonde行列变换成一般行列
int F_mtx_to_vander(const double i_mtx, double o_d): 一般行列变换成Vandermonde行列

double F_fx_one(const char Fx, double x0, double e): 返回F(x)等于0在x0的一个实数解*
int F_fx_equ(const char Fx, double xs, double xe, double xstep, double e, double o_x): 求F(x)等于0在区间[x始,x终]的全实数解
double F_poly_one(const double i_a, int na, double x0, double e): 返回高次代数方程式x0的一个实数解*
int F_poly_cpx_one(const double i_a, int na, double Re, double Im, double e, double o_cpx): 求高次代数方程式的值(Re+iIm)的一个复数解([r][k]+i[r][k+1])
int F_poly_equ(const double i_a, int na, double o_cpx): 求高次代数方程式的全复数解([r]: 用连续2组元表示一个复数)
int F_polycpx_equ(const double i_a, int na, double e, double o_cpx): 复数代数方程式的复数解([a],[r]: 用连续2组元表示一个复数)
int F_root_locus(const double i_a, int na, double o_K, int o_nK, double o_Re, double o_Im, double Ks, double Ke, double Kstep): 复数代数方程式的根轨迹*
int F_root_locus1(const double i_a, int na, const double i_K, int nK, double o_Re, double o_Im): 复数代数方程式的根轨迹(iK指定)