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数值函数库)

Debezium系列之：使用Debezium采集oceanbase数据库快乐骑行^_^ debezium Debezium系列采集oceanbase数据库
Debezium系列之：使用Debezium采集oceanbase数据库一、oceanbase数据库二、安装OceanBase三、安装oblogproxy四、基于Docker的简单采集案例五、生产实际应用案例Debezium是一个开源的分布式平台，用于监控数据库变化和捕捉数据变动事件，并以事件流的形式导出到各种消费者。Debezium基于ApacheKafka实现，并支持多种数据库系统。一、oce
UdpClient 呆呆敲代码的小Z c#
Socket实现Udp的发送和接收usingSystem;usingSystem.Collections.Generic;usingSystem.ComponentModel;usingSystem.Data;usingSystem.Drawing;usingSystem.Linq;usingSystem.Net;usingSystem.Net.Sockets;usingSystem.Text;u
功能强大的电脑硬件检测及驱动安装工具开开心心就好 pdf tcp/ip macos 网络协议 android python django
今天给大家带来一款超实用的电脑硬件检测软件——入梦工具箱。它是开源的，全程无广告干扰，使用起来清爽又安心。打开入梦工具箱，进入“硬件信息”选项，电脑各个配件的详细参数一目了然。无论是CPU的型号、频率，还是显卡、内存等硬件的具体规格，都能轻松获取，让你对电脑的“内部构造”了如指掌。入梦工具箱功能十分丰富，内含80多款实用工具。以CPU工具为例，无需安装，点击任意一款就能直接使用，快速满足你的相关需
系统应用权限设置跳转鸿蒙示例代码
本文原创发布在华为开发者社区。介绍本示例基于设置应用实现引导用户跳转到系统设置页进行权限，通知的相关设置，包含以下两个场景。场景一：如果应用首次拒绝了消息通知，应用希望能够引导用户拉起设置应用设置允许通知，用来接收应用内的推送消息；并且在设置完后返回页面可以监听到修改后的状态。场景二：当用户使用一些需要用户授权的api时（如访问获取联系人信息），若用户首次拒绝授权，则需要引导用户到权限设置页面能够
自建智能算力中心 vs 第三方算力租赁：AI企业的算力博弈与最优解
人工智能的爆发式增长正在重塑全球产业格局。从ChatGPT到DeepSeek，从自动驾驶到智能医疗，AI模型的训练和推理需求呈现指数级增长。在这场技术革命中，算力已成为企业竞争的“命脉”。然而，面对动辄数亿元的硬件投入和复杂的运维挑战，AI企业正面临一个关键抉择：自建智能算力中心，还是选择第三方算力租赁？本文将从成本、效率、风险及适用场景等维度展开深度分析，为企业提供决策参考。一、成本对比：重资产
JPA 实战经验 jpajava
这个博客会持续更新...JSON数据无法进行更新背景：数据库字段是json格式，代码Entity中字段使用了@Converter进行类型转换，对象本身是个List，产生的效果是查询生效，插入生效，更新不生效。怀疑方向：List对象实例ID发生变更了导致未识别@Converter转换器类型有问题尝试以上操作之后，问题依旧。最后，发现自己搞错概念了，把字段与关联表概念搞混了，它本质是一个字段，JPA对
[CISSP] [2] 安全治理原则策略 Мартин. CISSP 安全网络
BCPBCP（BusinessContinuityPlan，业务连续性计划）是一套用于在紧急情况下（如自然灾害、网络攻击、系统故障或人为事故）确保关键业务功能能够持续运行或尽快恢复的策略和流程。BCP的核心要素风险评估（RiskAssessment）识别可能影响业务的潜在风险，如自然灾害、网络攻击或供应链中断。业务影响分析（BusinessImpactAnalysis,BIA）评估关键业务流程，确
前后端的身份认证咖啡の猫 node.js 后端 express
在现代Web开发中，确保用户数据的安全性和隐私保护至关重要。身份认证是其中的核心环节之一，它用于验证用户的身份，并控制对资源的访问权限。本文将介绍几种常见的身份认证方法，并详细讲解如何在Node.js项目中实现这些方法。一、什么是身份认证？身份认证（Authentication）是确认用户身份的过程，通常通过用户名和密码组合或其他凭证来完成。一旦用户被认证，系统就可以基于其身份授予相应的访问权限（
内核arp_rcv函数到ip_local_deliver_finish的具体调用流程源远流长jerry tcp/ip 网络网络协议 linux
场景：主机A（IP：192.168.1.10，MAC：AA:BB:CC:DD:EE:FF）首次向主机B（IP：192.168.1.20，MAC：11:22:33:44:55:66）发送数据，发送ARP请求获取主机B的MAC地址。流程：主机B收到主机A的ARP请求报文后，内核调用arp_rcv处理。arp_rcv解析报文，发现是ARP请求且目标IP是本机（192.168.1.20）。函数生成ARP应
这么分析大文件日志，以后就不用加班卷了！编辑器
有没有熟悉这样的场景：时间已过十一点，空荡荡的办公室只剩自己孤身一人。陪你伏案忙碌的只有电脑风扇被迫营业的“嗡嗡”声，窗外的夜正黑得带劲，仿佛巨兽的口吞噬自己的无奈。天性善良不善言辞的你，容易被人颐指气使，加班对你来说是家常便饭。作为一名码农，“我到底哪里错了，我需要怎么解决？”是我的座右铭。但是，解决问题的过程需要耐心和细心，需要在大文件日志中寻找问题线索，耗费巨量的时间和精力。因此，加班分析并
FTP实验 23zhgjx-LSS 服务器网络 linux
实验拓扑图实验步骤（1）配置AR1sys进入系统视图[Huawei]undoinfo-centerenable关闭路由器输出信息[Huawei]sysnameAR1修改设备名[AR1]interfaceg0/0/0进入接口[AR1-GigabitEthernet0/0/0]ipaddress12.1.1.124配置IP[AR1-GigabitEthernet0/0/0]undoshutdown打开
本地AAA配置 23zhgjx-LSS 网络
实验拓扑图实验步骤（1）配置R1sys进入系统视图[Huawei]undoinfo-centerenable关闭路由器输出信息[Huawei]sysnameR1修改设备命名[R1]interfaceg0/0/0进入接口[R1-GigabitEthernet0/0/0]ipaddress192.168.1.124配置IP地址[R1-GigabitEthernet0/0/0]undoshutdown打
牛掰黑客师傅就是不一样，讲的内容可能外面的80%师傅都不知道文盲嘿客文盲嘿客的黑客成长史网络安全 web安全系统安全安全网络攻击模型数据挖掘深度学习
今天是师傅给我上的第一课，学习的内容归纳总结有以下几点：一、先学做人，再学做事坚定爱国信念：热爱祖国，拥护共产党严守法律红线：要遵纪守法，不得用技术攻击国内传承道德风尚：尊老爱幼，朋友之间应相互支持、携手共进，努力成就彼此。二、认识黑客黑客主要分为以下三类：骇客：这类人专门从事破坏活动，通过恶意手段对网络系统、数据等进行攻击和破坏。白帽黑客：他们专注于为企业或单位进行网络维护工作，防止骇客的攻击。
数据库的基本概念咖啡の猫数据库
在当今数字化的世界中，数据已成为企业和组织最宝贵的资产之一。有效地管理和利用这些数据对于决策制定、服务优化和业务增长至关重要。数据库作为存储、管理及检索数据的核心工具，在现代信息系统中扮演着至关重要的角色。本文将介绍数据库的一些基本概念，包括其定义、类型、结构以及一些基本操作。一、什么是数据库？数据库（Database）是指按照一定的结构来组织、存储和管理数据的仓库。它允许用户方便地进行数据的添加
桥接模式：解耦抽象与实现的利器 wrx繁星点点 #设计模式 java android 开发语言桥接模式 intellij-idea spring cloud jvm
1.引言在软件设计中，将抽象与实现分离是一项重要的原则。若将这两者耦合在一起，系统的灵活性和可扩展性将受到限制。桥接模式（BridgePattern）是一种结构型设计模式，旨在通过分离抽象与具体实现，来提高系统的灵活性和可维护性。2.桥接模式的定义桥接模式通过将抽象部分与具体实现部分分离，使得两者可以独立变化。它使用组合的方式，通过引入桥接接口来减少二者之间的耦合，灵活地调整和扩展系统的功能。3.
127.HarmonyOS NEXT 数字滚动示例详解(二)：下拉刷新实现 harmonyos-next
温馨提示：本篇博客的详细代码已发布到git:https://gitcode.com/nutpi/HarmonyosNext可以下载运行哦！HarmonyOSNEXT数字滚动示例详解(二)：下拉刷新实现效果演示1.下拉刷新概述下拉刷新功能通过Refresh组件实现，提供了良好的用户交互体验。2.刷新组件实现2.1基本结构Refresh({refreshing:$this.isRefresh}){th
128.HarmonyOS NEXT 数字滚动示例详解(三)：列表实现与布局 harmonyos-next
温馨提示：本篇博客的详细代码已发布到git:https://gitcode.com/nutpi/HarmonyosNext可以下载运行哦！HarmonyOSNEXT数字滚动示例详解(三)：列表实现与布局效果演示1.列表结构概述列表组件使用List和ListItem实现，包含标题和数字显示两个主要部分。2.List组件实现2.1基本结构List({space:STYLE_CONFIG.ITEM_GU
129.HarmonyOS NEXT 数字滚动示例详解(四)：样式与主题适配 harmonyos-next
温馨提示：本篇博客的详细代码已发布到git:https://gitcode.com/nutpi/HarmonyosNext可以下载运行哦！HarmonyOSNEXT数字滚动示例详解(四)：样式与主题适配效果演示1.样式配置概述示例组件使用了统一的样式配置和资源引用，确保界面风格的一致性和可维护性。2.样式常量定义constSTYLE_CONFIG={ITEM_GUTTER:12,//列表项间距PA
125.HarmonyOS NEXT 数字滚动动画详解(五)：最佳实践与应用场景 harmonyos-next
温馨提示：本篇博客的详细代码已发布到git:https://gitcode.com/nutpi/HarmonyosNext可以下载运行哦！HarmonyOSNEXT数字滚动动画详解(五)：最佳实践与应用场景效果演示1.使用场景数字滚动组件适用于以下场景：数值动态变化显示计数器效果金额变化展示时间倒计时2.基本使用2.1组件创建@Entry@ComponentstructDigitalScrollD
MATLAB 控制系统设计与仿真 - 28 东雁西飞 MATLAB 控制系统设计与仿真 matlab 算法开发语言机器人自动控制 AI算法
MATLAB状态空间控制系统分析-极点配置就受控系统的控制律的设计而言，由状态反馈极点配置和输出反馈极点配置。状态反馈极点配置问题就是：通过状态反馈矩阵K的选取，使闭环系统的极点，即(A-BK)的特征值恰好处于所希望的一组给定闭环极点的位置。另外，线性定常系统可以用状态反馈任意配置极点的充分必要条件是：该系统必须是完全能控的。所以，在实现极点的任意配置前，必须判别受控系统的能控性。下面结合例子介绍
120.HarmonyOS NEXT 跑马灯组件详解(八)：最佳实践与使用指南 harmonyos-next
温馨提示：本篇博客的详细代码已发布到git:https://gitcode.com/nutpi/HarmonyosNext可以下载运行哦！HarmonyOSNEXT跑马灯组件详解(八)：最佳实践与使用指南效果演示1.组件使用规范1.1基本使用MarqueeSection({marqueeTextBuilder:()=>{Text('滚动文本内容')},marqueeAnimationModifie
122.HarmonyOS NEXT 数字滚动动画详解(二)：动画实现机制 harmonyos-next
温馨提示：本篇博客的详细代码已发布到git:https://gitcode.com/nutpi/HarmonyosNext可以下载运行哦！HarmonyOSNEXT数字滚动动画详解(二)：动画实现机制效果演示1.动画实现概述数字滚动动画通过控制每个数字的Y轴偏移量来实现滚动效果，使用animateTo方法来创建平滑的过渡动画。2.数据刷新机制2.1刷新触发@Watch('onDataRefresh
119.HarmonyOS NEXT 跑马灯组件详解(七)：性能优化指南 harmonyos-next
温馨提示：本篇博客的详细代码已发布到git:https://gitcode.com/nutpi/HarmonyosNext可以下载运行哦！HarmonyOSNEXT跑马灯组件详解(七)：性能优化指南效果演示1.性能优化概述MarqueeSection组件的性能优化主要从以下几个方面考虑：渲染性能动画性能内存管理资源利用2.渲染优化2.1条件渲染if(this.ticketCheckTextWidt
SvelteKit 最新中文文档教程（5）—— 页面选项
前言Svelte，一个语法简洁、入门容易，面向未来的前端框架。从Svelte诞生之初，就备受开发者的喜爱，根据统计，从2019年到2024年，连续6年一直是开发者最感兴趣的前端框架No.1：Svelte以其独特的编译时优化机制著称，具有轻量级、高性能、易上手等特性，非常适合构建轻量级Web项目。为了帮助大家学习Svelte，我同时搭建了Svelte最新的中文文档站点。如果需要进阶学习，也可以入手我
近期docker镜像加速器被封杀，需要的请看此内容点赞加关注加油干sit！ docker docker
{“registry-mirrors”:[“https://docker.m.daocloud.io”],“insecure-registries”:[“harbor.sunya.com”],“exec-opts”:[“native.cgroupdriver=systemd”],“data-root”:“/data/docker”,“log-driver”:“json-file”,“log-opt
Nginx的编译安装加油干sit！ LINUX基础
1公司：我们线上业务已经有Nginx了，现在要新上一个业务，你给我把Nginx安装一下，按照之前的安装方式进行，怎么办？1.先使用nginx-V获取所有的编译参数2.按照所有的参数，在新的服务器上进行编译安装你给我们的Nginx安装一个第三方模块？1.先使用nginx-V获取所有的编译参数2.给nginx的源码导入第三方模块的补丁包（就是三方模块重写的一些c语言程序，替换了官方源码中的一些c语言程
LangChain使用Prompt02 科研小达人 langchain 前端
1.设置提示fromlangchain.promptsimportChatPromptTemplateprompt_template=ChatPromptTemplate.from_messages([("system","你是一位专业的翻译，能够将{input_language}翻译成{output_language}，并且输出文本会根据用户要求的任何语言风格进行调整。请只输出翻译后的文本，不要
桥接模式：解耦抽象与实现的设计良方技术拾光者设计模式 java 设计模式桥接模式
桥接模式（BridgePattern）是一种结构型设计模式，它通过将抽象部分与实现部分分离，使它们可以独立变化。这种模式的主要目的是解决多维度变化带来的复杂性问题，使代码更具扩展性和可维护性。桥接模式通过提供一个抽象层，将抽象部分与具体实现部分分离。这样，抽象部分和实现部分可以独立地扩展，而不会相互影响。一，模式结构桥接模式的结构包括以下几个部分：抽象类（Abstraction）：定义抽象接口，并
python颜色参数_python matplotlib:plt.scatter() 大小和颜色参数详解 weixin_39926311 python颜色参数
语法plt.scatter(x,y,s=20,c='b')大小s默认为20，s=0时点不显示；颜色c默认为蓝色。为每一个点指定大小和颜色有时我们需要为每一个点指定大小和方向，以区分不同的点。这时，可以向s和c传入列表。如：importmatplotlib.pyplotaspltimportnumpyasnpx=list(range(1,7))plt.scatter(x,x,s=10*np.arra
《A++ 敏捷开发》- 19 协作改进整个系统 EdmondSung 敏捷流程
“专注用户，从顾客的角度生产产品。”某次现场培训，我分享了丰田汽车故事后，请学员分组讨论，写出对工作最有帮助的3条。以上是某组的第一条，我请他们解释说明。“我是做开发的，反思时发现其实不清楚我的工作对客户有什么作用。”一位年轻的编码人员说。因为编码工作大部分都是由产品经理或项目经理过滤后分配，所以如果你随便问身边的编码人员，70-80%的可能不知道用户为什么要这样做，要开发的功能有什么价值。这位年
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指定)