欢迎访问 Forcal程序设计

FORCAL数值计算扩展动态库XSLSF（徐士良算法）

目 录

1 如何使用XSLSF
1.1 通过整数表达式申请数组 |
1.2 直接在实数表达式中申请数组 |
1.3 输出数组数据 |
2 数组存取
XSLSF::setra | 将多维数组视为一维数组，设置多个数组元素
XSLSF::getra | 将多维数组视为一维数组，获得多个数组元素
XSLSF::setrai | 设置多维数组元素的值
XSLSF::getrai | 获得多维数组元素的值
XSLSF::suma(p) | 对多维数组p的所有元素求和。运行错误：1：非法的数组指针。
XSLSF::SetArray | 一维数组计算赋值函数
3 矩阵运算
XSLSF::eye(p) | 将体积为m×n的矩阵p置为单位矩阵。运行错误：1：非法的数组指针；2：不是二维数组（矩阵）。
XSLSF::ones(p) | 将体积为m×n的矩阵p置为全1矩阵。运行错误：1：非法的数组指针；2：不是二维数组（矩阵）。
XSLSF::zeros(p) | 将体积为m×n的矩阵p置为全0矩阵。运行错误：1：非法的数组指针；2：不是二维数组（矩阵）。
XSLSF::rmul | 实矩阵相乘
XSLSF::cmul | 复矩阵相乘
XSLSF::rinv | 一般实矩阵求逆，全选主元高斯－约当法
XSLSF::cinv | 一般复矩阵求逆，全选主元高斯－约当法
XSLSF::ssgj | 对称正定矩阵的求逆
XSLSF::trch | 托伯利兹矩阵求逆的特兰持方法
XSLSF::sdet | 求一般行列式的值，全选主元高斯消去法
XSLSF::rank | 求矩阵的秩，全选主元高斯消去法
XSLSF::mchol | 对称正定矩阵的乔里斯基分解与行列式求值
XSLSF::lluu | 矩阵的三角分解
XSLSF::maqr | 一般实矩阵的QR分解
XSLSF::muav | 一般实矩阵的奇异值分解
XSLSF::ginv | 求广义逆的奇异值分解法
4 矩阵特征值与特征向量的计算
XSLSF::strq | 约化对称矩阵为对称三对角阵的豪斯荷尔德变换法
XSLSF::sstq | 实对称三对角阵的全部特征值与特征向量的计算
XSLSF::hhbg | 约化一般实矩阵为赫申伯格矩阵的初等相似变换法
XSLSF::hhqr | 求赫申伯格矩阵全部特征值的QR方法
XSLSF::jcbi | 求实对称矩阵特征值与特征向量的雅可比法
XSLSF::jcbj | 求实对称矩阵特征值与特征向量的雅可比过关法
5 线性代数方程组的求解
XSLSF::egaus | 求解实系数方程组的全选主元高斯消去法
XSLSF::gjdn | 求解实系数方程组的全选主元高斯约当消去法
XSLSF::cgas | 求解复系数方程组的全选主元高斯消去法
XSLSF::cjdn | 求解复系数方程组的全选主元高斯－约当消去法
XSLSF::trde | 求解三对角线方程组的追赶法
XSLSF::band | 求解一般带型方程组
XSLSF::ldle | 求解对称方程组的分解法
XSLSF::echol | 求解对称正定方程组的平方根法
XSLSF::ggje | 求解大型稀疏方程组的全选主元高斯－约当消去法
XSLSF::tlvs | 求解托伯利兹方程组的列文逊方法
XSLSF::gsdl | 高斯－赛德尔迭代法
XSLSF::grad | 求解对称正定方程组的共轭梯度法
XSLSF::gmqr | 求解线性最小二乘问题的豪斯荷尔德变换法
XSLSF::gmiv | 求解线性最小二乘问题的广义逆法
XSLSF::bint | 求解病态方程组
6 非线性方程与方程组的求解
XSLSF::dhrt | 求非线性方程实根的对分法
XSLSF::newt | 求非线性方程一个实根的牛顿法
XSLSF::atkn | 求非线性方程一个实根的埃特金迭代法
XSLSF::pqrt | 求非线性方程一个实根的连分式解法
XSLSF::qrrt | 求实系数代数方程全部根的QR法
XSLSF::srrt | 求实系数代数方程全部根的牛顿－下山法
XSLSF::csrt | 求复系数代数方程全部根的牛顿－下山法
XSLSF::snse | 求非线性方程组一组实根的梯度法
XSLSF::netn | 求非线性方程组一组实根的拟牛顿法
XSLSF::ngin | 求非线性方程组最小二乘解的广义逆法
XSLSF::emtcl | 求非线性方程一个实根的蒙特卡洛法
XSLSF::cmtc | 求实函数或复函数方程一个复根的蒙特卡洛法
XSLSF::nmtc | 求非线性方程组一组实根的蒙特卡洛法
7 插值
XSLSF::nlgr | 一元全区间不等距插值
XSLSF::elgr | 一元全区间等距插值
XSLSF::nlg3 | 一元三点不等距插值
XSLSF::elg3 | 一元三点等距插值
XSLSF::npqs | 连分式不等距插值
XSLSF::epqs | 连分式等距插值
XSLSF::nhmt | 埃尔米特不等距插值
XSLSF::ehmt | 埃尔米特等距插值
XSLSF::natk | 埃特金不等距逐步插值
XSLSF::eatk | 埃特金等距逐步插值
XSLSF::nspl | 光滑不等距插值
XSLSF::espl | 光滑等距插值
XSLSF::spl1 | 第一种边界条件的三次样条函数插值、微商与积分
XSLSF::spl2 | 第二种边界条件的三次样条函数插值、微商与积分
XSLSF::spl3 | 第三种边界条件的三次样条函数插值、微商与积分
XSLSF::slq3 | 二元三点插值
XSLSF::slgq | 二元全区间插值
8 数值积分
XSLSF::ffts | 变步长梯形求积法
XSLSF::simp | 变步长辛卜生求积法
XSLSF::fpts | 自适应梯形求积法
XSLSF::romb | 龙贝格求积法
XSLSF::fpqg | 计算一维积分的连分式法
XSLSF::part | 高震荡函数求积法
XSLSF::lrgs | 勒让德－高斯求积法
XSLSF::lags | 拉盖尔－高斯求积法
XSLSF::hmgs | 埃尔米特－高斯求积法
XSLSF::cbsv | 切比雪夫求积法
XSLSF::imtcl | 计算一维积分的蒙特卡洛法
XSLSF::sim2 | 变步长辛卜生二重求积法
XSLSF::igaus | 计算多重积分的高斯方法
XSLSF::pqg2 | 计算二重积分的连分式法
XSLSF::mtml | 计算多重积分的蒙特卡洛法
9 常微分方程（组）的求解
XSLSF::elr1 | 全区间积分的定步长欧拉方法
XSLSF::elr2 | 积分一步的变步长欧拉方法
XSLSF::wity | 全区间积分的定步长维梯方法
XSLSF::rkt1 | 全区间积分的定步长龙格-库塔法
XSLSF::rkt2 | 积分一步的变步长龙格-库塔法
XSLSF::gil1 | 积分一步的变步长基尔方法
XSLSF::gil2 | 全区间积分的变步长基尔方法
XSLSF::mrsn | 全区间积分的变步长默森方法
XSLSF::pbs1 | 积分一步的连分式法
XSLSF::pbs2 | 全区间积分的连分式法
XSLSF::gjfq | 全区间积分的双边法
XSLSF::adms | 全区间积分的阿当姆斯预报-校正法
XSLSF::hamg | 全区间积分的哈明方法
XSLSF::tnr1 | 积分一步的特雷纳方法
XSLSF::tnr2 | 全区间积分的特雷纳方法
XSLSF::gear | 积分刚性方程组的吉尔方法
XSLSF::dfte | 二阶微分方程边值问题的数值解法
10 拟合与逼近
XSLSF::pir1 | 最小二乘曲线拟合
XSLSF::chir | 切比雪夫曲线拟合
XSLSF::remz | 最佳一致逼近的米里兹方法
XSLSF::pir2 | 矩形域的最小二乘曲线拟合
11 数据处理与回归分析
XSLSF::rhis | 随机样本分析
XSLSF::sqt1 | 一元线性回归分析
XSLSF::sqt2 | 多元线性回归分析
XSLSF::sqt3 | 逐步回归分析
XSLSF::log1 | 半对数数据相关
XSLSF::log2 | 对数数据相关
12 极值问题
XSLSF::max1 | 一维极值连分式法
XSLSF::maxn | n维极值连分式法
XSLSF::lplq | 不等式约束线性规划问题
XSLSF::jsim | 求n维极值的单形调优法
XSLSF::cplx | 求约束条件下n维极值的复形调优法
13 数学变换与滤波
XSLSF::four | 傅立叶级数逼近
XSLSF::kfft | 快速傅立叶变换
XSLSF::kfwt | 快速沃什变换
XSLSF::kspt | 五点三次平滑
XSLSF::lman | 离散随机线性系统的卡尔曼滤波
XSLSF::kabg | α－β－γ滤波
14 特殊函数
XSLSF::gamma(x) | 伽马函数。该函数返回的运行错误代码的意义如下：1：x<=0。
XSLSF::gammai(a,x) | 不完全伽马函数。该函数返回的运行错误代码的意义如下：1：a<=0；2：x<0。
XSLSF::erf(x) | 误差函数。
XSLSF::bessel1(n,x) | 第一类整数阶贝塞耳函数，n为整数。
XSLSF::bessel2(n,x) | 第二类整数阶贝塞耳函数，n为整数。
XSLSF::bessel3(n,x) | 变型第一类整数阶贝塞耳函数，n为整数。
XSLSF::bessel4(n,x) | 变型第二类整数阶贝塞耳函数，n为整数。
XSLSF::beta(a,b,x) | 不完全贝塔函数。该函数返回的运行错误代码的意义如下：1：a<=0；2：b<=0；3：x<0 or x>1。
XSLSF::nrdf(a,d,x) | 正态分布函数，a为数学期望值，d为方差值,d>0，x为随机变量值。
XSLSF::student(t,n) | t-分布函数，t为随机变量，n为整数，自由度。
XSLSF::chii(x,n) | 卡方分布函数，n为整数，自由度。
XSLSF::ffff(f,n1,n2) | F-分布函数，n1、n2为整数，自由度。
XSLSF::sinn(x) | 正弦积分。
XSLSF::coss(x) | 余弦积分。
XSLSF::expp(x) | 指数积分。
XSLSF::elp1(k,f) | 第一类椭圆积分，0<=k<=1。
XSLSF::elp2(k,f) | 第二类椭圆积分，0<=k<=1。
15 随机数的产生
XSLSF::rnd1(&r) | 0到1之间均匀分布的一个随机数。r是随机数的种子，返回一个新值。 返回值为符合要求的随机数。
XSLSF::rnds(r,p) | 0到1之间均匀分布的一个随机数序列。r是随机数的种子；p是双精度实数数组，返回随机数序列。返回值无意义。运行错误：1：非法的数组指针。
XSLSF::rab1(a,b,&r) | 任意区间内均匀分布的一个随机整数。a、b为区间的左、右端点；r（大于等于1）是随机数的种子，返回一个新值。返回值为符合要求的随机数。运行错误：1：参数r不符合要求。
XSLSF::rabs(a,b,&r,p) | 任意区间内均匀分布的一个随机整数序列。a、b为区间的左、右端点；r（大于等于1）是随机数的种子，返回一个新值；p是双精度实数数组，返回随机数序列。返回值无意义。运行错误：1：参数r不符合要求；2： 非法的数组指针。
XSLSF::grn1(u,g,&r) | 任意均值与方差的一个正态分布随机数。u为正态分布的均值；g为正态分布的方差，σ2=g2；r是随机数的种子，返回一个新值。返回值为符合要求的随机数。
XSLSF::grns(u,g,&r,a) | 任意均值与方差的一个正态分布随机数。u为正态分布的均值；g为正态分布的方差，σ2=g2；r是随机数的种子，返回一个新值；a是双精度实数数组，返回随机数序列。返回值无意义。运行错误：1：非法的数组指针。

1 如何使用XSLSF [返回页首]

XSLSF32W.dll是一个Forcal数值计算扩展动态库，算法主要选自《C常用算法程序集》第二版，徐士良主编，清华大学出版社。 主要内容包括矩阵运算，矩阵特征值与特征向量的计算，线性代数方程组的求解，非线性方程与方程组的求解，插值与逼近，数值积分，常微分方程组的求解，极值问题的求解，复数、多项式与特殊函数的计算等。这些算法都是行之有效的，基本可以满足解决工程中各种实际问题的需要。

在XSLSF中，Forcal仅对徐士良全部数值算法进行了封装，对算法本身未作更改。XSLSF的源程序可通过作者网站下载。

在XSLSF中的函数是通过二级函数命名空间“XSLSF”输出的，所有函数均具有类似“XSLSF::rmul”的格式，全部是实数函数。使用!using("XSLSF");可简化XSLSF中的函数访问。

本文中的例子基本上取自《C常用算法程序集》一书，如果您手头上有该书，对理解这些例子会有很大帮助。

XSLSF32W.dll需要FcData32W.dll的支持，FcData32W.dll要先于XSLSF32W.dll加载。

在使用XSLSF时，会用到一维和二维（矩阵）动态数组，因而需要了解申请（或销毁）一维和二维数组的方法，了解如何给一维和二维数组赋值，了解如何输出一维和二维数组。销毁一维或二维数组很简单，假如p是一个数组指针，delete[p]即可，实际上，任意的FcData数据都是这样销毁的。

特别注意，XSLSF库对数组的任何操作都不会产生临时变量，因而需要时，应自己产生必须的中间变量。举例来说：矩阵A与A的逆矩阵相乘时，以下算法是错误的：

C.rmul[A,cinv(A)]; //函数cinv用于求矩阵的逆矩阵，函数rmul进行矩阵相乘运算，A和C都是矩阵

正确的算法如下：

B=newcopy(A), C.rmul[A,cinv(B)]; //函数newcopy用于创建对象的副本，A、B和C都是矩阵

1.1 通过整数表达式申请数组 [返回页首]

需要自定义整数表达式来申请数组，但不能赋初值。如下例：

> i: newr1(n)=new{real_s,rtoi(n)}; //申请一维实数数组，不能赋初值，只能在实数表达式中调用该函数
> i: newr2(m,n)=new{real_s,rtoi(m),rtoi(n)}; //申请二维实数数组，不能赋初值，只能在实数表达式中调用该函数

数组赋值在实数表达式中进行。如下例：

> !using("XSLSF"); //使用XSLSF命名空间
> (:p,x)= p=newr1(5),setra[p,0,1.1,2.2,3.3,4.4,5.5],getra[p,2,&x],delete[p],x; //setra用于给实数数组赋值，getra可获得实数数组元素的值
> (:p,x)= p=newr2(3,2),setra[p,0,1.1,2.2,3.3,4.4,5.5,6.6],getra[p,2,&x],delete[p],x; //setra用于给实数数组赋值，getra可获得实数数组元素的值

1.2 直接在实数表达式中申请数组 [返回页首]

可直接在实数表达式中用函数new申请数组并赋初值，但部分参数需要进行类型转换。如下例：

> !using("XSLSF"); //使用XSLSF命名空间
> (:p,x)= p=new[rtoi(real_s),rtoi(5),rtoi(EndType):1.1,2.2,3.3,4.4,5.5],getra[p,2,&x],delete[p],x; //申请一维实数数组并赋初值
> (:p,x)= p=new[rtoi(real_s),rtoi(3),rtoi(2),rtoi(EndType):1.1,2.2,3.3,4.4,5.5,6.6],getra[p,2,&x],delete[p],x;//申请二维实数数组并赋初值

1.3 输出数组数据 [返回页首]

XSLSF 中没有定义输出数组数据的函数，实际上没有必要定义此类函数，用标准格式化输出函数printff或printfs可以灵活地输出任何数据。见下例：

> i: OutVector(p:k,i)= k=FCDLen(p),printff{"\r\n"},i=0,(i<k).while{printff{"{1,r,14.6}",get[p,i]},i++},printff{"\r\n"}; //输出一维数组
> i: OutMatrix(p:n1,n2,k,i,j)= //输出二维数组（矩阵）
> {
> FCDLen(p,&k,&n1,&n2),
> if[k!=2,printff{"\r\n*** 地址为{1,i}的对象不是一个矩阵！ ***\r\n",p.ptoi()},return(0)],
> i=0,(i<n1).while{
> printff{"\r\n"},
> j=0,(j<n2).while{printff{"{1,r,14.6}",get[p,i,j]},j++}, //可修改数据输出宽度和有效数字个数以满足实际要求
> i++
> },
> printff{"\r\n"}
> };

本文中的例子将一直使用 OutVector(p)和 OutMatrix(p)输出一维和二维数组数据。在例子中将不再给出这两个函数的定义，总是假定这两个函数已预先被编译进入了Forcal系统，使用它们就像使用系统内置的函数一样。 简单地，你可以把这两个函数和下面用到这两个函数的例子放在一起进行编译，OutVector 和 OutMatrix 在前，例子在后。

2 数组存取 [返回页首]

[返回页首] XSLSF::setra(array,&k,x1,x2,... ...)：将多维数组视为一维数组，设置多个数组元素

将数值x1,x2,... ...在多维实数数组array（数组元素按行存放）中从地址k开始连续存放。地址k使用取地址操作符&时返回下一个存放地址，因此可以连续使用该函数在同一数组中存放若干数值。该函数返回下一个存放地址。
该函数可能返回如下运行错误：1：至少需要2个参数；2：无效的数组指针；3：数组元素地址错误；4：数组元素个数不够。

[返回页首] XSLSF::getra(array,&k,&x1,&x2,... ...)：将多维数组视为一维数组，获得多个数组元素

从多维实数数组array（数组元素按列存放）中地址k开始连续取数组元素存放在变量x1,x2,... ...中。地址k及变量x1,x2,... ...前须用取地址操作符&，否则不能返回值。地址k使用取地址操作符&时返回下一个数组元素地址，因此可以连续使用该函数在同一数组中取若干数值。该函数返回下一个数组元素地址。
该函数可能返回如下运行错误：1：至少需要2个参数；2：无效的数组指针；3：数组元素地址错误；4：数组元素个数不够。

[返回页首] XSLSF::setrai(array,k1,k2,... ... : x)：设置多维数组元素的值

设置多维实数数组array的元素k1,k2,... ... 的值为x。
该函数可能返回如下运行错误：1：至少需要3个参数；2：无效的数组指针；3：数组维数错误；4：数组维数非法。

[返回页首] XSLSF::getrai(array,k1,k2,... ...)：获得多维数组元素的值
获得多维实数数组array的元素k1,k2,... ... 的值。
该函数可能返回如下运行错误：1：至少需要2个参数；2：无效的数组指针；3：数组维数错误；4：数组维数非法。

[返回页首] XSLSF::SetArray(hF,a0,a1,a2,... ...,an,i,len)：一维数组计算赋值函数

hF：由HFor获得的函数句柄。
a0,a1,a2,... ...,an：等长的一维数组，数组个数应等于函数hF的自变量个数加1。
i：数组计算赋值的起始位置。若缺省该参数，i=0。
len：数组计算赋值个数。若缺省该参数，数组计算赋值至数组的最后一个元素。
返回值：0。

说明：该函数以数组a0,a1,a2,... ...,an-1中的对应数据为自变量，对表达式hF求值，结果存入最后一个数组an的对应位置。即以数组a0,a1,a2,... ...,an-1中的第i个自变量为参数，计算后存入an的第i个元素位置。

运行错误代码：1：至少需要2个参数；2：指定的表达式不存在；3：参数个数不匹配；4：内存错误；5：实数数组不存在；6：不是一维数组；7：数组维数不相等；8：数据地址错误。

例子：

ff(a,b,c)=a+b+c;

main(:a,b,c)=
{
a=new{rtoi(real_s),rtoi(10),rtoi(EndType):2,2,2,2,2,2,2,2,2,2},//申请一个数组并赋初值
b=new{rtoi(real_s),rtoi(10),rtoi(EndType):3,3,3,3,3,3,3,3,3,3},//申请一个数组并赋初值
c=new{rtoi(real_s),rtoi(10)}, //申请一个数组，用于存放结果
XSLSF::SetArray[HFor("ff"),a,b,a,c], //数组计算赋值
printff{"数组元素求和={1,r}\r\n",XSLSF::suma(c)}, //输出结果
delete[a],delete[b],delete[c] //销毁数组
};

3 矩阵运算 [返回页首]

在XSLSF中，矩阵就是二维数组，二维数组也被看作一个矩阵，但有时矩阵元素也保存在一维数组中。

[返回页首] XSLSF::rmul(c:a,b)：实矩阵相乘

c：双精度实型矩阵，体积为m×k，返回乘积矩阵的元素。
a：双精度实型矩阵，体积为m×n。
b：双精度实型矩阵，体积为n×k。

返回值：矩阵c。

运行错误代码：1：实数数组不存在；2：不是二维数组（矩阵）；3：矩阵维数不匹配。

例子：

main(:a,b,c)=
{
c=new[rtoi(real_s),rtoi(4),rtoi(3)],
a=new[rtoi(real_s),rtoi(4),rtoi(5),rtoi(EndType),
1.0,3.0,-2.0,0.0,4.0,
-2.0,-1.0,5.0,-7.0,2.0,
0.0,8.0,4.0,1.0,-5.0,
3.0,-3.0,2.0,-4.0,1.0],
b=new[rtoi(real_s),rtoi(5),rtoi(3),rtoi(EndType),
4.0,5.0,-1.0,
2.0,-2.0,6.0,
7.0,8.0,1.0,
0.0,3.0,-5.0,
9.0,8.0,-6.0],
c.XSLSF::rmul(a,b),
OutMatrix[c],
delete[a],delete[b],delete[c]
};

[返回页首] XSLSF::cmul(cr,ci:ar,ai,br,bi)：复矩阵相乘

cr,ci：双精度实型矩阵，体积为m×k，返回乘积矩阵的实部和虚部。
ar,ai：双精度实型矩阵，体积为m×n，存放矩阵的实部和虚部。
br,bi：双精度实型矩阵，体积为n×k，存放矩阵的实部和虚部。

返回值：矩阵cr。

运行错误代码：1：实数数组不存在；2：不是二维数组（矩阵）；3：矩阵维数不匹配。

例子：

main(:ar,ai,br,bi,cr,ci)=
{
cr=new[rtoi(real_s),rtoi(3),rtoi(4)],ci=new[rtoi(real_s),rtoi(3),rtoi(4)],
ar=new[rtoi(real_s),rtoi(3),rtoi(4),rtoi(EndType),
1.0,2.0,3.0,-2.0,
1.0,5.0,1.0,3.0,
0.0,4.0,2.0,-1.0],
ai=new[rtoi(real_s),rtoi(3),rtoi(4),rtoi(EndType),
1.0,-1.0,2.0,1.0,
-1.0,-1.0,2.0,0.0,
-3.0,-1.0,2.0,2.0],
br=new[rtoi(real_s),rtoi(4),rtoi(4),rtoi(EndType),
1.0,4.0,5.0,-2.0,
3.0,0.0,2.0,-1.0,
6.0,3.0,1.0,2.0,
2.0,-3.0,-2.0,1.0],
bi=new[rtoi(real_s),rtoi(4),rtoi(4),rtoi(EndType),
-1.0,-1.0,1.0,1.0,
2.0,1.0,0.0,5.0,
-3.0,2.0,1.0,-1.0,
-1.0,-2.0,1.0,-2.0],
XSLSF::cmul(cr,ci,ar,ai,br,bi),
OutMatrix[cr],OutMatrix[ci],
delete[ar],delete[ai],delete[br],delete[bi],delete[cr],delete[ci]
};

[返回页首] XSLSF::rinv(a)：一般实矩阵求逆，全选主元高斯－约当法

a：双精度实型矩阵，体积为n×n，返回时存放其逆矩阵。

返回值：矩阵a的逆矩阵。

运行错误代码：1：实数数组不存在；2：不是二维数组（矩阵）；3：不是n×n矩阵；4：内存错误；5：矩阵奇异。

例子：

main(:a,b,c)=
{
a=new[rtoi(real_s),rtoi(4),rtoi(4),rtoi(EndType),
0.2368,0.2471,0.2568,1.2671,
1.1161,0.1254,0.1397,0.1490,
0.1582,1.1675,0.1768,0.1871,
0.1968,0.2071,1.2168,0.2271],
c=new[rtoi(real_s),rtoi(4),rtoi(4)],
b=newcopy(a),
b.XSLSF::rinv(),
printff["\r\nMAT A- is:"],OutMatrix[b],
c.XSLSF::rmul(a,b),
printff["\r\nMAT AA- is:"],OutMatrix[c],
delete[a],delete[b],delete[c]
};

[返回页首] XSLSF::cinv(ar,ai)：一般复矩阵求逆，全选主元高斯－约当法

ar,ai：双精度实型矩阵，体积为n×n，存放矩阵的实部和虚部，返回时存放其逆矩阵的实部和虚部。

返回值：逆矩阵实部ar。

运行错误代码：1：实数数组不存在；2：不是二维数组（矩阵）；3：不是n×n矩阵；4：内存错误；5：矩阵奇异。

例子：

main(:a,b)=
{
a=new[rtoi(real_s),rtoi(4),rtoi(4),rtoi(EndType),
0.2368,0.2471,0.2568,1.2671,
1.1161,0.1254,0.1397,0.1490,
0.1582,1.1675,0.1768,0.1871,
0.1968,0.2071,1.2168,0.2271],
b=new[rtoi(real_s),rtoi(4),rtoi(4),rtoi(EndType),
0.1345,0.1678,0.1875,1.1161,
1.2671,0.2017,0.7024,0.2721,
-0.2836,-1.1967,0.3558,-0.2078,
0.3576,-1.2345,2.1185,0.4773],
XSLSF::cinv(a,b),
OutMatrix[a],OutMatrix[b],
delete[a],delete[b]
};

[返回页首] XSLSF::ssgj(a)：对称正定矩阵的求逆

a：双精度实型矩阵，体积为n×n，返回时存放其逆矩阵。

返回值：a的逆矩阵。

运行错误代码：1：实数数组不存在；2：不是二维数组（矩阵）；3：不是n×n矩阵；4：内存错误；5：程序工作失败，如矩阵非对称正定。

例子：

main(:a)=
{
a=new[rtoi(real_s),rtoi(4),rtoi(4),rtoi(EndType),
5.0,7.0,6.0,5.0,
7.0,10.0,8.0,7.0,
6.0,8.0,10.0,9.0,
5.0,7.0,9.0,10.0],
a.XSLSF::ssgj(),
OutMatrix[a],
delete[a]
};

[返回页首] XSLSF::trch(b,t,tt)：托伯利兹矩阵求逆的特兰持方法

b：双精度实型矩阵，体积为n×n，返回T型矩阵的逆矩阵。
t：双精度一维数组，长度为n，存放T型矩阵的上三角元素。
tt：双精度一维数组，长度为n，存放T型矩阵的下三角元素，从tt(1)开始存放。

返回值：逆矩阵b。

运行错误代码：1：实数数组不存在；2：不是二维数组（矩阵）；3：不是n×n矩阵或数组不匹配；4：内存错误；5：程序工作失败。

例子：

main(:b,t,tt)=
{
t=new[rtoi(real_s),rtoi(6),rtoi(EndType),10.0,5.0,4.0,3.0,2.0,1.0],
tt=new[rtoi(real_s),rtoi(6),rtoi(EndType),0.0,-1.0,-2.0,-3.0,-4.0,-5.0],
b=new[rtoi(real_s),rtoi(6),rtoi(6)],
b.XSLSF::trch(t,tt),
OutMatrix[b],
delete[b],delete[t],delete[tt]
};

[返回页首] XSLSF::sdet(a)：求一般行列式的值，全选主元高斯消去法

a：双精度实型矩阵，体积为n×n，在函数运行时，a将被破坏。

返回值：行列式的值。

运行错误代码：1：实数数组不存在；2：不是二维数组（矩阵）；3：不是n×n矩阵。

例子：

!using("XSLSF"); //使用XSLSF命名空间
main(:a)=
{
a=new[rtoi(real_s),rtoi(4),rtoi(4),rtoi(EndType),
1.0,2.0,3.0,4.0,
5.0,6.0,7.0,8.0,
9.0,10.0,11.0,12.0,
13.0,14.0,15.0,16.0],
printff["det={1,r}\r\n",sdet(a)],
setra[a,0,
3.0,-3.0,-2.0,4.0,
5.0,-5.0,1.0,8.0,
11.0,8.0,5.0,-7.0,
5.0,-1.0,-3.0,-1.0],
printff["det={1,r}\r\n",sdet(a)],
delete[a]
};

[返回页首] XSLSF::rank(a)：求矩阵的秩，全选主元高斯消去法

a：双精度实型矩阵，体积为m×n，在函数运行时，a将被破坏。

返回值：矩阵的秩。

运行错误代码：1：实数数组不存在；2：不是二维数组（矩阵）。

例子：

main(:a)=
{
a=new[rtoi(real_s),rtoi(5),rtoi(4),rtoi(EndType),
1.0,2.0,3.0,4.0,
5.0,6.0,7.0,8.0,
9.0,10.0,11.0,12.0,
13.0,14.0,15.0,16.0,
17.0,18.0,19.0,20.0],
printff["det={1,r}\r\n",XSLSF::rank(a)],
delete[a]
};

[返回页首] XSLSF::mchol(a)：对称正定矩阵的乔里斯基分解与行列式求值

a：双精度实型矩阵，体积为n×n，返回时，其下三角部分存放分解后的下三角矩阵，其余元素均为0。

返回值：返回行列式的值。

运行错误代码：1：实数数组不存在；2：不是二维数组（矩阵）；3：不是n×n矩阵；4：程序工作失败 ，如矩阵非对称正定。

例子：

main(:a,det)=
{
a=new[rtoi(real_s),rtoi(4),rtoi(4),rtoi(EndType),
5.0,7.0,6.0,5.0,
7.0,10.0,8.0,7.0,
6.0,8.0,10.0,9.0,
5.0,7.0,9.0,10.0],
det=XSLSF::mchol(a),
OutMatrix[a],
printff["det={1,r}\r\n",det],
delete[a]
};

[返回页首] XSLSF::lluu(a,l,u)：矩阵的三角分解

a：双精度实型矩阵，体积为n×n，存放原矩阵，返回时存放Q矩阵。
l：双精度实型矩阵，体积为n×n，返回时存放下三角矩阵。
u：双精度实型矩阵，体积为n×n，返回时存放上三角矩阵。

返回值：返回a。

运行错误代码：1：实数数组不存在；2：不是二维数组（矩阵）；3：不是n×n矩阵；4：程序工作失败 ，例如：aii≈0。

说明：由于该方法没有选主元，因此数值计算是不稳定的。

例子：

main(:a,l,u)=
{
a=new[rtoi(real_s),rtoi(4),rtoi(4),rtoi(EndType),
2.0,4.0,4.0,2.0,
3.0,3.0,12.0,6.0,
2.0,4.0,-1.0,2.0,
4.0,2.0,1.0,1.0],
l=new[rtoi(real_s),rtoi(4),rtoi(4)],
u=new[rtoi(real_s),rtoi(4),rtoi(4)],
XSLSF::lluu(a,l,u),
OutMatrix[l],OutMatrix[u],
delete[a],delete[l],delete[u]
};

[返回页首] XSLSF::maqr(a,q)：一般实矩阵的QR分解

a：双精度实型矩阵，体积为m×n，存放原矩阵，返回时右上三角部分存放上三角矩阵R。
q：双精度实型矩阵，体积为m×m，返回时存放正交矩阵Q。

返回值：返回a。

运行错误代码：1：实数数组不存在；2：不是二维数组（矩阵）；3：矩阵不匹配；4：程序工作失败，矩阵列线性相关。

例子：

main(:a,q)=
{
a=new[rtoi(real_s),rtoi(4),rtoi(3),rtoi(EndType),
1.0,1.0,-1.0,
2.0,1.0,0.0,
1.0,-1.0,0.0,
-1.0,2.0,1.0],
q=new[rtoi(real_s),rtoi(4),rtoi(4)],
XSLSF::maqr(a,q),
OutMatrix[a],OutMatrix[q],
delete[a],delete[q]
};

[返回页首] XSLSF::muav(a,u,v,eps,it)：一般实矩阵的奇异值分解

a：双精度实型矩阵，体积为m×n， 存放原矩阵，返回对角线给出奇异值（以非递增次序排列），其余元素为0。
u：双精度实型矩阵，体积为m×m，返回时存放左奇异向量U。
v：双精度实型矩阵，体积为n×n，返回时存放右奇异向量VT。
eps：精度要求。
it：允许的最大迭代次数。

返回值：返回值等于0表示迭代it次还未求得某个奇异值，非0值表示正常返回。需要对返回值进行检查。

运行错误代码：1：实数数组不存在；2：不是二维数组（矩阵）；3：矩阵不匹配；4：内存错误。

例子：

main(:a,u,v,eps)=
{
a=new[rtoi(real_s),rtoi(4),rtoi(3),rtoi(EndType),
1.0,1.0,-1.0,
2.0,1.0,0.0,
1.0,-1.0,0.0,
-1.0,2.0,1.0],
u=new[rtoi(real_s),rtoi(4),rtoi(4)],
v=new[rtoi(real_s),rtoi(3),rtoi(3)],
printff["\r\ni={1,r}",XSLSF::muav(a,u,v,0.000001,60)],
OutMatrix[a],OutMatrix[u],OutMatrix[v],
delete[a],delete[u],delete[v]
};

[返回页首] XSLSF::ginv(a,aa,u,v,eps,it)：求广义逆的奇异值分解法

a：双精度实型矩阵，体积为m×n， 存放原矩阵，返回对角线给出奇异值（以非递增次序排列），其余元素为0。
aa：双精度实型矩阵，体积为n×m，返回时存放矩阵a的广义逆a+。
u：双精度实型矩阵，体积为m×m，返回时存放左奇异向量U。
v：双精度实型矩阵，体积为n×n，返回时存放右奇异向量VT。
eps：精度要求。
it：允许的最大迭代次数。

返回值：返回值等于0表示迭代it次还未求得某个奇异值，非0值表示正常返回。需要对返回值进行检查。

运行错误代码：1：实数数组不存在；2：不是二维数组（矩阵）；3：矩阵不匹配；4：内存错误。

例子：

main(:a,aa,c,u,v,eps)=
{
a=new[rtoi(real_s),rtoi(5),rtoi(4),rtoi(EndType),
1.0,2.0,3.0,4.0,
6.0,7.0,8.0,9.0,
1.0,2.0,13.0,0.0,
16.0,17.0,8.0,9.0,
2.0,4.0,3.0,4.0],
aa=new[rtoi(real_s),rtoi(4),rtoi(5)],
c=new[rtoi(real_s),rtoi(5),rtoi(4)],
u=new[rtoi(real_s),rtoi(5),rtoi(5)],
v=new[rtoi(real_s),rtoi(4),rtoi(4)],
XSLSF::ginv(a,aa,u,v,0.000001,60),
XSLSF::ginv(aa,c,v,u,0.000001,60),
printff["\r\nMAT A++ IS:"],
OutMatrix[c],
delete[a],delete[aa],delete[c],delete[u],delete[v]
};

4 矩阵特征值与特征向量的计算 [返回页首]

[返回页首] XSLSF::strq(a,q,b,c)：约化对称矩阵为对称三对角阵的豪斯荷尔德变换法

a：双精度实型矩阵，体积为n×n，存放原矩阵。
q：双精度实型矩阵，体积为n×n，返回豪斯荷尔德变换的乘积矩阵，在与sstq函数联用时，若将q矩阵作为函数sstq的一个参数，可计算实对称矩阵a的特征值及相应的特征向量。
b：双精度实型一维数组，长度为n，返回对称三对角阵中的主对角线元素。
c：双精度实型一维数组，长度为n，其中前n-1个元素返回对称三对角阵中的次对角线元素。

返回值：返回值为a。

运行错误代码：1：实数数组不存在；2：不是二维数组（矩阵）或一维数组；3：矩阵或向量不匹配。

例子：

main(:a,q,b,c)=
{
a=new[rtoi(real_s),rtoi(5),rtoi(5),rtoi(EndType),
10.0,1.0,2.0,3.0,4.0,
1.0,9.0,-1.0,2.0,-3.0,
2.0,-1.0,7.0,3.0,-5.0,
3.0,2.0,3.0,12.0,-1.0,
4.0,-3.0,-5.0,-1.0,15.0],
q=new[rtoi(real_s),rtoi(5),rtoi(5)],
b=new[rtoi(real_s),rtoi(5)],
c=new[rtoi(real_s),rtoi(5)],
XSLSF::strq(a,q,b,c),
OutMatrix[q],OutVector[b],OutVector[c],
delete[a],delete[q],delete[b],delete[c]
};

[返回页首] XSLSF::sstq(b,c,q,eps,l)：实对称三对角阵的全部特征值与特征向量的计算

b：双精度实型一维数组，长度为n，存放对称三对角阵中的主对角线元素，返回时存放全部特征值。
c：双精度实型一维数组，长度为n，其中前n-1个元素返回对称三对角阵中的次对角线元素。
q：双精度实型矩阵，体积为n×n，若存放单位矩阵，则返回n阶实对称三对角阵T的特征向量组；若存放strq函数所返回的实对称矩阵A的豪斯荷尔德变换的乘积矩阵Q，则返回实对称矩阵A的特征向量组。其中q中的第j列为与数组b中第j个特征值所对应的特征向量。
eps：控制精度要求。
l：允许的最大迭代次数。

返回值：返回值等于0表示迭代了l次还未求得一个特征值，返回非0值表示正常返回。需要对返回值进行检查。

运行错误代码：1：实数数组不存在；2：不是二维数组（矩阵）或一维数组；3：矩阵或向量不匹配。

例子：

main(:a,q,b,c)=
{
a=new[rtoi(real_s),rtoi(5),rtoi(5),rtoi(EndType),
10.0,1.0,2.0,3.0,4.0,
1.0,9.0,-1.0,2.0,-3.0,
2.0,-1.0,7.0,3.0,-5.0,
3.0,2.0,3.0,12.0,-1.0,
4.0,-3.0,-5.0,-1.0,15.0],
q=new[rtoi(real_s),rtoi(5),rtoi(5)],
b=new[rtoi(real_s),rtoi(5)],
c=new[rtoi(real_s),rtoi(5)],
XSLSF::strq(a,q,b,c),
XSLSF::sstq(b,c,q,0.000001,60),
OutMatrix[q],OutVector[b],
delete[a],delete[q],delete[b],delete[c]
};

[返回页首] XSLSF::hhbg(a)：约化一般实矩阵为赫申伯格矩阵的初等相似变换法

a：双精度实型矩阵，体积为n×n，若存原矩阵，返回时存放a的上H矩阵。

返回值：返回值为a。

运行错误代码：1：实数数组不存在；2：不是二维数组（矩阵）；3：不是n×n矩阵。

例子：

main(:a)=
{
a=new[rtoi(real_s),rtoi(5),rtoi(5),rtoi(EndType),
1.0,6.0,-3.0,-1.0,7.0,
8.0,-15.0,18.0,5.0,4.0,
-2.0,11.0,9.0,15.0,20.0,
-13.0,2.0,21.0,30.0,-6.0,
17.0,22.0,-5.0,3.0,6.0],
XSLSF::hhbg(a),
OutMatrix[a],
delete[a]
};

[返回页首] XSLSF::hhqr(a,u,v,eps,jt)：求赫申伯格矩阵全部特征值的QR方法

a：双精度实型矩阵，体积为n×n，存放上H矩阵。
u：双精度实型一维数组，长度为n，返回时存放特征值的实部。
v：双精度实型一维数组，长度为n，返回时存放特征值的虚部。
eps：精度要求。
jt：控制最大迭代次数。

返回值：返回值等于0表示迭代jt次还未满足精度要求，返回非0值表示正常返回。需要对返回值进行检查。

运行错误代码：1：实数数组不存在；2：不是一维或二维数组（矩阵）；3：数组不匹配。

说明：与hhbg联用，可计算一般实矩阵的全部特征值。

例子：

main(:a,u,v)=
{
a=new[rtoi(real_s),rtoi(5),rtoi(5),rtoi(EndType),
1.0,6.0,-3.0,-1.0,7.0,
8.0,-15.0,18.0,5.0,4.0,
-2.0,11.0,9.0,15.0,20.0,
-13.0,2.0,21.0,30.0,-6.0,
17.0,22.0,-5.0,3.0,6.0],
u=new[rtoi(real_s),rtoi(5)],
v=new[rtoi(real_s),rtoi(5)],
XSLSF::hhbg(a),OutMatrix[a],
XSLSF::hhqr(a,u,v,0.000001,60),
OutVector[u],OutVector[v],
delete[a],delete[u],delete[v]
};

[返回页首] XSLSF::jcbi(a,v,eps,jt)：求实对称矩阵特征值与特征向量的雅可比法

a：双精度实型矩阵，体积为n×n，存放实对称矩阵，返回时，对角线上存放n个特征值。
v：双精度实型矩阵，体积为n×n，返回特征向量，其中第i列为与aii所对应的特征向量。
eps：精度要求。
jt：控制最大迭代次数。

返回值：返回值等于0表示迭代jt次还未满足精度要求，返回非0值表示正常返回。需要对返回值进行检查。

运行错误代码：1：实数数组不存在；2：不是二维数组（矩阵）；3：矩阵不匹配。

例子：

main(:a,v)=
{
a=new[rtoi(real_s),rtoi(3),rtoi(3),rtoi(EndType),
2.0,-1.0,0.0,
-1.0,2.0,-1.0,
0.0,-1.0,2.0],
v=new[rtoi(real_s),rtoi(3),rtoi(3)],
XSLSF::jcbi(a,v,0.000001,100),
OutMatrix[a],OutMatrix[v],
delete[a],delete[v]
};

[返回页首] XSLSF::jcbj(a,v,eps)：求实对称矩阵特征值与特征向量的雅可比过关法

a：双精度实型矩阵，体积为n×n，存放实对称矩阵，返回时，对角线上存放n个特征值。
v：双精度实型矩阵，体积为n×n，返回特征向量，其中第i列为与aii所对应的特征向量。
eps：精度要求。

返回值：返回a。

运行错误代码：1：实数数组不存在；2：不是二维数组（矩阵）；3：矩阵不匹配。

例子：

main(:a,v)=
{
a=new[rtoi(real_s),rtoi(5),rtoi(5),rtoi(EndType),
10.0,1.0,2.0,3.0,4.0,
1.0,9.0,-1.0,2.0,-3.0,
2.0,-1.0,7.0,3.0,-5.0,
3.0,2.0,3.0,12.0,-1.0,
4.0,-3.0,-5.0,-1.0,15.0],
v=new[rtoi(real_s),rtoi(5),rtoi(5)],
XSLSF::jcbj(a,v,0.000001),
OutMatrix[a],OutMatrix[v],
delete[a],delete[v]
};

5 线性代数方程组的求解 [返回页首]

[返回页首] XSLSF::egaus(a,v)：b求解实系数方程组的全选主元高斯消去法

a：双精度实型二维数组，体积为n×n，存放方程组的系数矩阵，返回时将被破坏。
b：双精度实型一维数组，长度为n，存放方程组右端的常数向量，返回方程组的解向量。

返回值：返回0表示原方程组的系数矩阵奇异，返回非0值表示成功。

运行错误代码：1：实数数组不存在；2：不是希望的一维或二维数组（矩阵）；3：一维或二维数组不匹配 ；4：内存错误。

例子：

main(:a,b)=
{
a=new[rtoi(real_s),rtoi(4),rtoi(4),rtoi(EndType),
0.2368,0.2471,0.2568,1.2671,
0.1968,0.2071,1.2168,0.2271,
0.1581,1.1675,0.1768,0.1871,
1.1161,0.1254,0.1397,0.1490],
b=new[rtoi(real_s),rtoi(4),rtoi(EndType),1.8471,1.7471,1.6471,1.5471],
XSLSF::egaus(a,b),
OutVector[b],
delete[a],delete[b]
};

[返回页首] XSLSF::gjdn(a,b)：求解实系数方程组的全选主元高斯约当消去法

a：双精度实型二维数组，体积为n×n，存放方程组的系数矩阵，返回时将被破坏。
b：双精度实型二维数组，体积为n×m，存放方程组右端的m组常数向量（一列为一组），返回方程组的m组解向量（一列为一组）。

返回值：返回0表示原方程组的系数矩阵奇异，返回非0值表示成功。

运行错误代码：1：实数数组不存在；2：不是希望的二维数组（矩阵）；3：二维数组不匹配；4：内存错误。

例子：

main(:a,b)=
{
a=new[rtoi(real_s),rtoi(4),rtoi(4),rtoi(EndType),
1.0,3.0,2.0,13.0,
7.0,2.0,1.0,-2.0,
9.0,15.0,3.0,-2.0,
-2.0,-2.0,11.0,5.0],
b=new[rtoi(real_s),rtoi(4),rtoi(2),rtoi(EndType),
9.0,0.0,
6.0,4.0,
11.0,7.0,
-2.0,-1.0],
XSLSF::gjdn(a,b),
OutMatrix[b],
delete[a],delete[b]
};

[返回页首] XSLSF::cgas(ar,ai,br,bi)：求解复系数方程组的全选主元高斯消去法

ar,ai：双精度实型二维数组，体积为n×n，存放复系数矩阵的实部与虚部，返回时将被破坏。
br,bi：双精度实型一维数组，长度为n，存放方程组右端的复常数向量的实部与虚部，返回方程组的解向量的实部与虚部。

返回值：返回0表示原方程组的系数矩阵奇异，返回非0值表示成功。

运行错误代码：1：实数数组不存在；2：不是希望的一维或二维数组（矩阵）；3：数组不匹配 ；4：内存错误。

例子：

main(:ar,ai,br,bi)=
{
ar=new[rtoi(real_s),rtoi(4),rtoi(4),rtoi(EndType),
1.0,3.0,2.0,13.0,
7.0,2.0,1.0,-2.0,
9.0,15.0,3.0,-2.0,
-2.0,-2.0,11.0,5.0],
ai=new[rtoi(real_s),rtoi(4),rtoi(4),rtoi(EndType),
3.0,-2.0,1.0,6.0,
-2.0,7.0,5.0,8.0,
9.0,-3.0,15.0,1.0,
-2.0,-2.0,7.0,6.0],
br=new[rtoi(real_s),rtoi(4),rtoi(EndType),2.0,7.0,3.0,9.0],
bi=new[rtoi(real_s),rtoi(4),rtoi(EndType),1.0,2.0,-2.0,3.0],
XSLSF::cgas(ar,ai,br,bi),
OutVector[br],OutVector[bi],
delete[ar],delete[ai],delete[br],delete[bi]
};

[返回页首] XSLSF::cjdn(ar,ai,br,bi)：求解复系数方程组的全选主元高斯－约当消去法

ar,ai：双精度实型二维数组，体积为n×n，存放复系数矩阵的实部与虚部，返回时将被破坏。
br,bi：双精度实型二维数组，体积为n×m，存放方程组右端的m组复常数向量的实部与虚部，返回方程组的m组解向量的实部与虚部。

返回值：返回0表示原方程组的系数矩阵奇异，返回非0值表示成功。

运行错误代码：1：实数数组不存在；2：不是二维数组（矩阵）；3：数组不匹配；4：内存错误。

例子：

main(:ar,ai,br,bi)=
{
ar=new[rtoi(real_s),rtoi(4),rtoi(4),rtoi(EndType),
1.0,3.0,2.0,13.0,
7.0,2.0,1.0,-2.0,
9.0,15.0,3.0,-2.0,
-2.0,-2.0,11.0,5.0],
ai=new[rtoi(real_s),rtoi(4),rtoi(4),rtoi(EndType),
3.0,-2.0,1.0,6.0,
-2.0,7.0,5.0,8.0,
9.0,-3.0,15.0,1.0,
-2.0,-2.0,7.0,6.0],
br=new[rtoi(real_s),rtoi(4),rtoi(2),rtoi(EndType),
2.0,-2.0,
7.0,3.0,
3.0,2.0,
9.0,1.0],
bi=new[rtoi(real_s),rtoi(4),rtoi(2),rtoi(EndType),
1.0,3.0,
2.0,7.0,
-2.0,9.0,
3.0,2.0],
XSLSF::cjdn(ar,ai,br,bi),
OutMatrix[br],OutMatrix[bi],
delete[ar],delete[ai],delete[br],delete[bi]
};

[返回页首] XSLSF::trde(a,b)：求解三对角线方程组的追赶法

a：双精度实型一维数组，长度为m，以行为主存放三对角线矩阵中三对角线上的元素，即：a00,a01,a10,a11,a12,a21,a22,a23,...,an-1,n-2,an-1,n-1。
b：双精度实型一维数组，长度为n，存放方程组右端的常数向量，返回方程组的解向量。m=3n-2。

返回值：返回0表示程序工作失败（例如主元素的绝对值太小或为0），返回非0值表示成功。

运行错误代码：1：实数数组不存在；2：不是一维数组；3：数组不匹配。

例子：

main(:a,b)=
{
a=new[rtoi(real_s),rtoi(13),rtoi(EndType),13.0,12.0,11.0,10.0,9.0,8.0,7.0,6.0,5.0,4.0,3.0,2.0,1.0],
b=new[rtoi(real_s),rtoi(5),rtoi(EndType),3.0,0.0,-2.0,6.0,8.0],
XSLSF::trde(a,b),
OutVector[b],
delete[a],delete[b]
};

[返回页首] XSLSF::band(b,d)：求解一般带型方程组

b：双精度实型二维数组，体积为n×ik，存放 带型矩阵带区内的元素（带型矩阵前k+1行与最后k+1行的元素均以左边对齐顺序放在数组b的相应行，而最右边的空余部分均填入0，k称为半带宽，ik=2k+1），返回时 将被破坏。
d：双精度实型二维数组，体积为n×m，存放方程组右端的m组常数向量，返回方程组的m组解向量。

返回值：返回0表示原方程组的系数矩阵奇异，返回非0值表示成功。

运行错误代码：1：实数数组不存在；2：不是二维数组（矩阵）；3：数组不匹配。

例子：

main(:b,d)=
{
b=new[rtoi(real_s),rtoi(8),rtoi(5),rtoi(EndType),
3.0,-4.0,1.0,0.0,0.0,
-2.0,-5.0,6.0,1.0,0.0,
1.0,3.0,-1.0,2.0,-3.0,
2.0,5.0,-5.0,6.0,-1.0,
-3.0,1.0,-1.0,2.0,-5.0,
6.0,1.0,-3.0,2.0,-9.0,
-4.0,1.0,-1.0,2.0,0.0,
5.0,1.0,-7.0,0.0,0.0],
d=new[rtoi(real_s),rtoi(8),rtoi(3),rtoi(EndType),
13.0,29.0,-13.0,
-6.0,17.0,-21.0,
-31.0,-6.0,4.0,
64.0,3.0,16.0,
-20.0,1.0,-5.0,
-22.0,-41.0,56.0,
-29.0,10.0,-21.0,
7.0,-24.0,20.0],
XSLSF::band(b,d),
OutMatrix[d],
delete[b],delete[d]
};

[返回页首] XSLSF::ldle(a,c)：求解对称方程组的分解法

a：双精度实型二维数组，体积为n×n，存放方程组的系数矩阵（应为对称矩阵），返回时将被破坏。
c：双精度实型二维数组，体积为n×m，存放方程组右端的m组常数向量，返回方程组的m组解向量。

返回值：返回0表示程序工作失败，返回非0值表示成功。

运行错误代码：1：实数数组不存在；2：不是二维数组（矩阵）；3：数组不匹配。

例子：

main(:a,c)=
{
a=new[rtoi(real_s),rtoi(5),rtoi(5),rtoi(EndType),
5.0,7.0,6.0,5.0,1.0,
7.0,10.0,8.0,7.0,2.0,
6.0,8.0,10.0,9.0,3.0,
5.0,7.0,9.0,10.0,4.0,
1.0,2.0,3.0,4.0,5.0],
c=new[rtoi(real_s),rtoi(5),rtoi(2),rtoi(EndType),
24.0,96.0,
34.0,136.0,
36.0,144.0,
35.0,140.0,
15.0,60.0],
XSLSF::ldle(a,c),
OutMatrix[c],
delete[a],delete[c]
};

[返回页首] XSLSF::echol(a,d)：求解对称正定方程组的平方根法

a：双精度实型二维数组，体积为n×n，存放方程组的系数矩阵（应为对称矩阵），返回时 其上三角部分存放分解后的U矩阵。
c：双精度实型二维数组，体积为n×m，存放方程组右端的m组常数向量，返回方程组的m组解向量。

返回值：返回0表示程序工作失败（例如系数矩阵非正定），返回非0值表示成功。

运行错误代码：1：实数数组不存在；2：不是二维数组（矩阵）；3：数组不匹配。

例子：

main(:a,d)=
{
a=new[rtoi(real_s),rtoi(4),rtoi(4),rtoi(EndType),
5.0,7.0,6.0,5.0,
7.0,10.0,8.0,7.0,
6.0,8.0,10.0,9.0,
5.0,7.0,9.0,10.0],
d=new[rtoi(real_s),rtoi(4),rtoi(2),rtoi(EndType),
23.0,92.0,
32.0,128.0,
33.0,132.0,
31.0,124.0],
XSLSF::echol(a,d),
OutMatrix[d],
delete[a],delete[d]
};

[返回页首] XSLSF::ggje(a,b)：求解大型稀疏方程组的全选主元高斯－约当消去法

a：双精度实型二维数组，体积为n×n，存放方程组的系数矩阵，返回时矩阵被破坏。
b：双精度实型一维数组，长度为n，存放方程组右端的常数向量，返回方程组的解向量。

返回值：返回0表示程序工作失败（例如系数矩阵奇异），返回非0值表示成功。

运行错误代码：1：实数数组不存在；2：不是二维数组（矩阵）；3：数组不匹配；4：内存错误。

例子：

main(:a,b)=
{
a=new[rtoi(real_s),rtoi(8),rtoi(8),rtoi(EndType),
0.0,0.0,-1.0,0.0,0.0,0.0,2.0,0.0,
0.0,6.0,0.0,0.0,0.0,-6.0,0.0,0.0,
0.0,0.0,0.0,2.0,0.0,0.0,0.0,-4.0,
3.0,0.0,0.0,0.0,-2.0,0.0,1.0,0.0,
0.0,0.0,6.0,0.0,0.0,0.0,5.0,0.0,
1.0,0.0,0.0,0.0,-3.0,0.0,0.0,2.0,
0.0,4.0,0.0,-1.0,0.0,0.0,0.0,0.0,
0.0,0.0,1.0,0.0,-1.0,0.0,0.0,-2.0],
b=new[rtoi(real_s),rtoi(8),rtoi(EndType),4.0,6.0,-8.0,-2.0,27.0,-9.0,2.0,-4.0],
XSLSF::ggje(a,b),
OutVector[b],
delete[a],delete[b]
};

[返回页首] XSLSF::tlvs(t,b,x)：求解托伯利兹方程组的列文逊方法

t：双精度实型一维数组，长度为n，存放T型矩阵中的元素t0,t1,t2,...,tn-1。
b：双精度实型一维数组，长度为n，存放方程组右端的常数向量。
x：双精度实型一维数组，长度为n，返回方程组的解向量。

返回值：返回0表示程序工作失败，返回非0值表示成功。

运行错误代码：1：实数数组不存在；2：不是一维数组；3：数组不匹配；4：内存错误。

例子：

main(:t,b,x)=
{
t=new[rtoi(real_s),rtoi(6),rtoi(EndType),6.0,5.0,4.0,3.0,2.0,1.0],
b=new[rtoi(real_s),rtoi(6),rtoi(EndType),11.0,9.0,9.0,9.0,13.0,17.0],
x=new[rtoi(real_s),rtoi(6)],
XSLSF::tlvs(t,b,x),
OutVector[x],
delete[t],delete[b],delete[x]
};

[返回页首] XSLSF::gsdl(a,b,x,eps)：高斯－赛德尔迭代法

a：双精度实型二维数组，体积为n×n，存放方程组的系数矩阵。
b：双精度实型一维数组，长度为n，存放方程组右端的常数向量。
x：双精度实型一维数组，长度为n，返回方程组的解向量。
eps：给定的精度要求。

返回值：返回0表示程序工作失败（例如主对角线不占绝对优势），返回非0值表示成功。

运行错误代码：1：实数数组不存在；2：不是一维或二维数组（矩阵）；3：数组不匹配。

例子：

main(:a,b,x)=
{
a=new[rtoi(real_s),rtoi(4),rtoi(4),rtoi(EndType),
7.0,2.0,1.0,-2.0,
9.0,15.0,3.0,-2.0,
-2.0,-2.0,11.0,5.0,
1.0,3.0,2.0,13.0],
b=new[rtoi(real_s),rtoi(4),rtoi(EndType),4.0,7.0,-1.0,0.0],
x=new[rtoi(real_s),rtoi(4)],
XSLSF::gsdl(a,b,x,0.000001),
OutVector[x],
delete[a],delete[b],delete[x]
};

[返回页首] XSLSF::grad(a,b,x,eps)：求解对称正定方程组的共轭梯度法

a：双精度实型二维数组，体积为n×n，存放正定矩阵。
b：双精度实型一维数组，长度为n，存放方程组右端的常数向量。
x：双精度实型一维数组，长度为n，返回方程组的解向量。
eps：给定的精度要求。

返回值：返回a。

运行错误代码：1：实数数组不存在；2：不是一维或二维数组（矩阵）；3：数组不匹配；4：内存错误。

例子：

main(:a,b,x)=
{
a=new[rtoi(real_s),rtoi(4),rtoi(4),rtoi(EndType),
5.0,7.0,6.0,5.0,
7.0,10.0,8.0,7.0,
6.0,8.0,10.0,9.0,
5.0,7.0,9.0,10.0],
b=new[rtoi(real_s),rtoi(4),rtoi(EndType),23.0,32.0,33.0,31.0],
x=new[rtoi(real_s),rtoi(4)],
XSLSF::grad(a,b,x,0.000001),
OutVector[x],
delete[a],delete[b],delete[x]
};

[返回页首] XSLSF::gmqr(a,b,q)：求解线性最小二乘问题的豪斯荷尔德变换法

a：双精度实型二维数组，体积为m×n，存放超定方程组的系数矩阵，返回时存放QR分解式中的R矩阵。m≥n。
b：双精度实型一维数组，长度为n，存放方程组右端的常数向量，返回时前n个元素存放方程组的最小二乘解。
q：双精度实型二维数组，体积为m×m，返回时存放QR分解式中正交矩阵Q。

返回值：返回a。

运行错误代码：1：实数数组不存在；2：不是一维或二维数组（矩阵）；3：数组不匹配 ；4：矩阵A列线性相关；5：内存错误。

例子：

main(:a,b,q)=
{
a=new[rtoi(real_s),rtoi(4),rtoi(3),rtoi(EndType),
1.0,1.0,-1.0,
2.0,1.0,0.0,
1.0,-1.0,0.0,
-1.0,2.0,1.0],
b=new[rtoi(real_s),rtoi(4),rtoi(EndType),2.0,-3.0,1.0,4.0],
q=new[rtoi(real_s),rtoi(4),rtoi(4)],
XSLSF::gmqr(a,b,q),
OutMatrix[q],OutMatrix[a],
delete[a],delete[b],delete[q]
};

[返回页首] XSLSF::gmiv(a,b,x,aa,u,v,eps,it)：求解线性最小二乘问题的广义逆法

a：双精度实型二维数组，体积为m×n，存放超定方程组的系数矩阵，返回时其对角线依次给出奇异值，其余元素为0。
b：双精度实型一维数组，长度为n，存放超定方程组右端的常数向量。
b：双精度实型一维数组，长度为n，返回时存放超定方程组的最小二乘解。
aa：双精度实型二维数组，体积为n×m，返回时存放矩阵a的广义逆a+。
u：双精度实型二维数组，体积为m×m，返回时存放矩阵a的奇异值分解式中的左奇异向量U。
v：双精度实型二维数组，体积为n×n，返回时存放矩阵a的奇异值分解式中的右奇异向量VT。
eps：给定的精度要求。
it：最大迭代次数。

返回值：返回值为0表示迭代次数达最大值仍未满足精度要求，矩阵正常分解，但求最小二乘解失败；返回非0值表示成功。

运行错误代码：1：实数数组不存在；2：不是一维或二维数组（矩阵）；3：数组不匹配 ；4：矩阵A列线性相关；5：内存错误。

例子：

main(:a,b,x,aa,u,v)=
{
a=new[rtoi(real_s),rtoi(4),rtoi(3),rtoi(EndType),
1.0,1.0,-1.0,
2.0,1.0,0.0,
1.0,-1.0,0.0,
-1.0,2.0,1.0],
b=new[rtoi(real_s),rtoi(4),rtoi(EndType),2.0,-3.0,1.0,4.0],
x=new[rtoi(real_s),rtoi(3)],
aa=new[rtoi(real_s),rtoi(3),rtoi(4)],
u=new[rtoi(real_s),rtoi(4),rtoi(4)],
v=new[rtoi(real_s),rtoi(3),rtoi(3)],
XSLSF::gmiv(a,b,x,aa,u,v,0.000001,60),
OutVector[x],OutMatrix[aa],
delete[a],delete[b],delete[x],delete[aa],delete[u],delete[v]
};

[返回页首] XSLSF::bint(a,b,x,eps)：求解病态方程组

a：双精度实型二维数组，体积为n×n，存放方程组的系数矩阵。
b：双精度实型一维数组，长度为n，存放方程组右端的常数向量。
x：双精度实型一维数组，长度为n，返回方程组的解向量。
eps：给定的精度要求。

返回值：返回0表示程序工作失败（例如系数矩阵奇异），返回非0值表示成功。

运行错误代码：1：实数数组不存在；2：不是一维或二维数组（矩阵）；3：数组不匹配；4：内存错误。

例子：

main(:a,b,x)=
{
a=new[rtoi(real_s),rtoi(4),rtoi(4),rtoi(EndType),
3.4336,-0.5238,0.67105,-0.15272,
-0.5238,3.28326,-0.73051,-0.2689,
0.67105,-0.73051,4.02612,0.01835,
-0.15272,-0.2689,0.01835,2.75702],
b=new[rtoi(real_s),rtoi(4),rtoi(EndType),-1.0,1.5,2.5,-2.0],
x=new[rtoi(real_s),rtoi(4)],
XSLSF::bint(a,b,x,0.000001),
OutVector[x],
delete[a],delete[b],delete[x]
};

6 非线性方程与方程组的求解 [返回页首]

[返回页首] XSLSF::dhrt(f,a,b,h,eps,array)：求非线性方程实根的对分法

f：自定义一元函数句柄，但必须由二级函数HFor获得该句柄。函数自变量不能重新赋值。
a,b：求根区间的左端点和右端点（b>a）。
h：搜索求根时采用的步长（h>0）。
eps：控制精度（eps>0）。
array：一维工作数组，数组应能存放搜索到的所有实根。

返回值：返回实际搜索到的实根个数，若返回值等于数组array的长度，则有可能在求根区间[a,b]内的实根未搜索完；若函数返回-1，表示出现运行错误。函数返回时，搜索到的实根依次存放于数组array中。

运行错误代码：1：指定的表达式不存在；2：不是一元方程；3：自变量不能重新赋值；4：参数设置不符合要求；5：无效的数组指针；6：不是一维数组。
例子：
f(x)=x^6-5*x^5+3*x^4+x^3-7*x^2+7*x-20; //函数定义
main(:a,i)=
{
a=new[rtoi(real_s),rtoi(6)],
i=XSLSF::dhrt[HFor("f",2),-2,5,0.2,1e-6,a],
printff{"\r\n搜索到{1,r}个实根，即下列数组的前{1,r}个值：",i},
OutVector[a],
delete[a]
};

[返回页首] XSLSF::newt(f,&x,eps,js)：求非线性方程一个实根的牛顿法

f：自定义三元函数句柄，但必须由二级函数HFor获得该句柄。由用户自编，格式为：

> f(y1,y2,x)=
> {
> y1=f(x)的表达式,
> y2=f'(x)的表达式
> };

x：存放迭代初值，返回时存放迭代终值。
eps：控制精度（eps>0）。
js：最大迭代次数。

返回值：返回值小于0表示牛顿迭代公式中出现了 f'(x)=0 的情况；返回值等于最大迭代次数js表示未满足精度要求，返回值仅作参考；若返回值 大于等于0，且小于最大迭代次数js表示正常返回。

运行错误代码：1：指定的表达式不存在；2：不是三元方程；3：迭代次数不能小于1。
例子：
f(y1,y2,x)= //函数定义
{
y1=x^3-x^2-1,
y2=3*x*x-2*x
};
main(:x,i)=
{
x=1.5,
i=XSLSF::newt[HFor("f",2),&x,1e-6,60],
printff{"\r\n函数返回值为{1,r}，实根：{2,r}",i,x}
};

[返回页首] XSLSF::atkn(f,&x,eps,js)：求非线性方程一个实根的埃特金迭代法

f：自定义一元函数句柄（格式：x=f(x)），但必须由二级函数HFor获得该句柄。由用户自编。
x：存放迭代初值，返回时存放迭代终值。
eps：控制精度（eps>0）。
js：最大迭代次数。

返回值：返回值为0表示迭代次数已达最大迭代次数js，但未满足精度要求，返回值仅作参考；若返回值 非0表示正常返回。

运行错误代码：1：指定的表达式不存在；2：不是一元方程；3：迭代次数不能小于1。
例子：
f(x)=6-x*x; //函数定义：x=6-x*x
main(:x,i)=
{
x=0,
i=XSLSF::atkn[HFor("f",2),&x,1e-7,20],
printff{"\r\n函数返回值为{1,r}，实根：{2,r}",i,x}
};

[返回页首] XSLSF::pqrt(f,&x,eps)：求非线性方程一个实根的连分式解法

f：自定义一元函数句柄，但必须由二级函数HFor获得该句柄。由用户自编。
x：存放迭代初值，返回时存放迭代终值。
eps：控制精度（eps>0）。

返回值：返回值为实际迭代次数。若等于10，表示已迭代10次，但未满足精度要求，返回值仅作参考；若返回值 小于10表示正常返回。

运行错误代码：1：指定的表达式不存在；2：不是一元方程。
例子：
f(x)=x^3-x^2-1; //函数定义
main(:x,i)=
{
x=1,
i=XSLSF::pqrt[HFor("f",2),&x,1e-6],
printff{"\r\n函数返回值为{1,r}，实根：{2,r}",i,x}
};

[返回页首] XSLSF::qrrt(a,xr,xi,eps,jt)：求实系数代数方程全部根的QR法

a：双精度实型一维数组，长度为n+1，存放n次多项式方程的n+1个系数a0、a1、...an。n次多项式方程 ：Pn(x)=anxn+an-1xn-1+...+a1x+a0=0
xr：双精度实型一维数组，长度为n，返回n个根的实部。
xi：双精度实型一维数组，长度为n，返回n个根的虚部。
eps：给定的精度要求。
js：最大迭代次数。

返回值：返回值为0表示迭代次数已达最大迭代次数js，但未满足精度要求，返回值仅作参考；若返回值 非0表示正常返回。

运行错误代码：1：实数数组不存在；2：不是一维数组；3：数组不匹配；4：内存错误。

例子：

main(:a,xr,xi)=
{
a=new[rtoi(real_s),rtoi(7),rtoi(EndType),-30,10.5,-10.5,1.5,4.5,-7.5,1.5],
xr=new[rtoi(real_s),rtoi(6)],
xi=new[rtoi(real_s),rtoi(6)],
XSLSF::qrrt(a,xr,xi,0.000001,60),
OutVector[xr],OutVector[xi],
delete[a],delete[xr],delete[xi]
};

[返回页首] XSLSF::srrt(a,xr,xi)：求实系数代数方程全部根的牛顿－下山法

a：双精度实型一维数组，长度为n+1，存放n次多项式方程的n+1个系数a0、a1、...an。n次多项式方程 ：Pn(x)=anxn+an-1xn-1+...+a1x+a0=0
xr,xi：双精度实型一维数组，长度为n，返回n个根的实部和虚部。

返回值：返回值小于0表示方程中所有系数为0；若返回值大于0表示正常返回。

运行错误代码：1：实数数组不存在；2：不是一维数组；3：数组不匹配。

例子：

main(:a,xr,xi)=
{
a=new[rtoi(real_s),rtoi(7),rtoi(EndType),-20,7,-7,1,3,-5,1],
xr=new[rtoi(real_s),rtoi(6)],
xi=new[rtoi(real_s),rtoi(6)],
XSLSF::srrt(a,xr,xi),
OutVector[xr],OutVector[xi],
delete[a],delete[xr],delete[xi]
};

[返回页首] XSLSF::csrt(ar,ai,xr,xi)：求复系数代数方程全部根的牛顿－下山法

ar,ai：双精度实型一维数组，长度为n+1，存放n次多项式方程的n+1个系数a0、a1、...an的实部和虚部，这两个数组在函数工作时将被破坏。n次多项式方程 ：Pn(x)=anxn+an-1xn-1+...+a1x+a0=0
xr,xi：双精度实型一维数组，长度为n，返回n个根的实部和虚部。

返回值：返回值小于0表示方程中所有系数为0；若返回值大于0表示正常返回。

运行错误代码：1：实数数组不存在；2：不是一维数组；3：数组不匹配。

例子：

main(:ar,ai,xr,xi)=
{
ar=new[rtoi(real_s),rtoi(6),rtoi(EndType),0.1,21.33,4.9,0.0,3.0,1.0],
ai=new[rtoi(real_s),rtoi(6),rtoi(EndType),-100.0,0.0,-19.0,-0.01,2.0,0.0],
xr=new[rtoi(real_s),rtoi(5)],
xi=new[rtoi(real_s),rtoi(5)],
XSLSF::csrt(ar,ai,xr,xi),
OutVector[xr],OutVector[xi],
delete[ar],delete[ai],delete[xr],delete[xi]
};

[返回页首] XSLSF::snse(f,eps,x,js)：求非线性方程组一组实根的梯度法

f：自定义2n元函数句柄，但必须由二级函数HFor获得该句柄。由用户自编。

> f(x1,x2,...,xn,y1,y2,...,yn)=
> {
> y1=f(x1,x2,...,xn)对x1的偏导数,
> y2=f(x1,x2,...,xn)对x2的偏导数,
> ... ...
> yn=f(x1,x2,...,xn)对xn的偏导数,
> 返回目标函数值
> };

eps：控制精度（eps>0）。
x：双精度实型一维数组，长度为n，存放一组初值，返回时存放方程组的一组实根。
js：允许的最大迭代次数。

返回值：返回 值为实际迭代次数。若小于0，表示迭代过程中遇到了目标函数的局部极值点，此时可改变初值再试；若返回值等于最大迭代次数js，说明迭代了js次仍未满足精度要求，此时可改变初值、放松精度要求或增大js再试。

运行错误代码：1：指定的表达式不存在；2：方程f参数个数不符合要求；3：迭代次数不能小于1；4：实数数组不存在；5：不是一维数组；6：数组不匹配。
例子：
f(x1,x2,x3,y1,y2,y3:f1,f2,f3,df1,df2,df3,z)= //函数定义
{
f1=x1-5.0*x2*x2+7.0*x3*x3+12.0,
f2=3.0*x1*x2+x1*x3-11.0*x1,
f3=2.0*x2*x3+40.0*x1,
z=f1*f1+f2*f2+f3*f3,
df1=1.0, df2=3.0*x2+x3-11.0, df3=40.0,
y1=2.0*(f1*df1+f2*df2+f3*df3),
df1=10.0*x2, df2=3.0*x1, df3=2.0*x3,
y2=2.0*(f1*df1+f2*df2+f3*df3),
df1=14.0*x3, df2=x1, df3=2.0*x2,
y3=2.0*(f1*df1+f2*df2+f3*df3),
z
};
main(:x,i)=
{
x=new[rtoi(real_s),rtoi(3),rtoi(EndType),1.5,6.5,-5.0],
i=XSLSF::snse[HFor("f",2),1e-6,x,500],
OutVector[x],
delete[x]
};

[返回页首] XSLSF::netn(f,eps,t,h,x,k)：求非线性方程组一组实根的拟牛顿法

f：自定义2n元函数句柄，但必须由二级函数HFor获得该句柄。由用户自编。

> f(x1,x2,...,xn,y1,y2,...,yn)= //xi为自变量，yi为方程右端点函数值
> {
> y1=f1(x1,x2,...,xn),
> y2=f2(x1,x2,...,xn),
> ... ...
> yn=fn(x1,x2,...,xn)
> };

eps：控制精度（eps>0）。
t：控制h大小的变量，0<t<1。
h：增量初值，在本函数中将被破坏。
x：双精度实型一维数组，长度为2n，前n个元素存放一组初值，返回时前n个元素存放方程组的一组实根。
k：允许的最大迭代次数。

返回值：返回值为实际迭代次数。若返回值为-1表示代数方程奇异，若返回值为-2表示β=0，这两种情况可放宽精度要求、改变各个初值或改变各个方程顺序再试；若返回值等于0说明迭代了k次仍未满足精度要求，程序工作失败。

运行错误代码：1：指定的表达式不存在；2：方程f参数个数不符合要求；3：精度、控制变量、迭代次数等不符合要求；4：实数数组不存在；5：不是一维数组；6：数组不匹配 ；7：内存错误。
例子：
f(x1,x2,x3,y1,y2,y3)= //函数定义
{
y1=x1*x1+x2*x2+x3*x3-1.0,
y2=2.0*x1*x1+x2*x2-4.0*x3,
y3=3.0*x1*x1-4.0*x2+x3*x3
};
main(:x,i)=
{
x=new[rtoi(real_s),rtoi(6),rtoi(EndType),1.0,1.0,1.0],
i=XSLSF::netn[HFor("f",2),1e-6,0.1,0.1,x,100],
OutVector[x],
delete[x]
};

[返回页首] XSLSF::ngin(m,f,g,x,eps1,eps2,k)：求非线性方程组最小二乘解的广义逆法

m：方程个数。
f：自定义n+m元函数句柄（n为方程组中未知数个数），但必须由二级函数HFor获得该句柄。由用户自编。

> f(x1,x2,...,xn,y1,y2,...,ym)= //xi为自变量，yi为方程右端点函数值
> {
> y1=f1(x1,x2,...,xn),
> y2=f2(x1,x2,...,xn),
> ... ...
> ym=fm(x1,x2,...,xn)
> };

g：自定义m´n元函数句柄，但必须由二级函数HFor获得该句柄。 该函数用于计算雅可比矩阵，由用户自编。

> f(x1,x2,...,xn,y11,y12,...,y1n,y21,y22,...,y2n,... ...,ym1,ym2,...,ymn)= //xi为自变量，yij为雅可比矩阵
> {
> y11=f11(x1,x2,...,xn),
> y12=f12(x1,x2,...,xn),
> ... ...
> ymn=fmn(x1,x2,...,xn)
> };

x：双精度实型一维数组，长度为n。存放一组初值，要求不全为0；返回时存放最小二乘解，当m=n时，即为非线性方程组的解。
eps1：控制最小二乘解的精度（eps>0）。
eps2：用于奇异值分解中的精度控制（eps>0）。
k：允许的最大迭代次数。

返回值：返回 值为整型标志。若返回值小于0，说明在奇异值分解中迭代超过了k次仍未满足精度要求；若返回值等于0，说明本函数迭代了k次仍未满足精度要求；若返回值大于0正常返回。

运行错误代码：1：指定的表达式不存在；2：方程个数或未知数个数不符合要求；3：实数数组不存在；4：不是一维数组；5：数组不匹配 ；6：精度、迭代次数等不符合要求；7：内存错误。
例子：
f(x1,x2,y1,y2,y3)= //函数定义
{
y1=x1*x1+7.0*x1*x2+3.0*x2*x2+0.5,
y2=x1*x1-2.0*x1*x2+x2*x2-1.0,
y3=x1+x2+1.0
};
g(x1,x2,y11,y12,y21,y22,y31,y32)= //函数定义，雅可比矩阵
{
y11=2.0*x1+7.0*x2,
y12=7.0*x1+6.0*x2,
y21=2.0*x1-2.0*x2,
y22=-2.0*x1+2.0*x2,
y31=1.0,
y32=1.0
};
main(:x,i)=
{
x=new[rtoi(real_s),rtoi(2),rtoi(EndType),1.0,-1.0],
i=XSLSF::ngin[3,HFor("f",2),HFor("g",2),x,1e-6,1e-6,60],
OutVector[x],
delete[x]
};

[返回页首] XSLSF::emtcl(f,&x,b,m,eps)：求非线性方程一个实根的蒙特卡洛法

f：自定义一元函数句柄，但必须由二级函数HFor获得该句柄。由用户自编。
x：存放初值，返回方程根的终值。
b：均匀分布随机数的端点初值。
m：整数，调节控制b的参数。
eps：控制精度（eps>0）。

返回值：返回方程根的终值。

运行错误代码：1：指定的表达式不存在；2：不是一元方程；3：精度不符合要求。

例子：

f(x)=exp[-(x^3)]-sin[x]/cos[x]+800;
printff{"\r\n方程实根：{1,r}",XSLSF::emtcl(HFor("f",2),0.5,1,10,1e-5)};

[返回页首] XSLSF::cmtc(f,&x,&y,b,m,eps)：求实函数或复函数方程一个复根的蒙特卡洛法

f：自定义二元函数句柄，但必须由二级函数HFor获得该句柄。由用户自编，用于计算函数的模。

> f(x,y)= //x,y分别为复数的实部与虚部
> {
> ||f(x+yi)||
> };

x,y：存放初值的实部与虚部，返回方程的解的实部与虚部。
b：均匀分布随机数的端点初值。
m：整数，调节控制b的参数。
eps：控制精度（eps>0）。

返回值：返回方程的解的实部。

运行错误代码：1：指定的表达式不存在；2：不是二元方程；3：精度不符合要求。

例子：

f(x,y)=sqrt[(x*x-y*y+x-y-2)^2+(2*x*y+x+y+2)^2];
main(:x,y)=
{
x=0.5,y=0.5,
XSLSF::cmtc(HFor("f",2),&x,&y,1,10,1e-5),
printff{"\r\n方程的解：{1,cr}\r\n",x,y}
};

[返回页首] XSLSF::nmtc(f,x,b,m,eps)：求非线性方程组一组实根的蒙特卡洛法

f：自定义n元函数句柄，但必须由二级函数HFor获得该句柄。由用户自编，用于计算函数的模。

> f(x1,x2,...,xn)=
> {
> sqrt[f1(x1,x2,...,xn)^2+f2(x1,x2,...,xn)^2+...+fn(x1,x2,...,xn)^2]
> };

x：双精度实型一维数组，长度为n。存放一组初值；返回一组实根的终值。
b：均匀分布随机数的端点初值。
m：整数，调节控制b的参数。
eps：控制精度（eps>0）。

返回值：返回0。

运行错误代码：1：指定的表达式不存在；2：实数数组不存在；3：不是一维数组；4：数组不匹配；5：精度不符合要求；6：内存错误。

例子：

f(x1,x2,x3)=sqrt[(3*x1+x2+2*x3*x3-3)^2+(-3*x1+5*x2*x2+2*x1*x3-1)^2+(25*x1*x2+20*x3+12)^2];
main(:x,y)=
{
x=new[rtoi(real_s),rtoi(3),rtoi(EndType),0,0,0],
XSLSF::nmtc(HFor("f",2),x,2,10,1e-6),
OutVector[x],
delete[x]
};

7 插值 [返回页首]

[返回页首] XSLSF::nlgr(x,y,t)：一元全区间不等距插值

功能： 返回插值点t处的函数近似值z=f(t)。
参数：
x：一维实数数组，长度为n。存放给定n个结点的值Xi，要求X0<X1<...<Xn-1。
y：一维实数数组，长度为n。存放给定n个结点的函数值Yi，Yi=f(Xi)。
t：存放指定插值点的值。
运行错误：
1：实数数组不存在。
2：不是一维数组。
3：数组不匹配。
4：Xi没有按递增排列，要求X0<X1<...<Xn-1。
例子：

main(:x,y)=
{
x=new[rtoi(real_s),rtoi(10),rtoi(EndType),0.1, 0.15, 0.25, 0.4, 0.5, 0.57, 0.7, 0.85, 0.93, 1],
y=new[rtoi(real_s),rtoi(10),rtoi(EndType),0.904837, 0.860708, 0.778801, 0.670320, 0.606531, 0.565525, 0.496585, 0.427415, 0.394554, 0.367879],
printff{"\r\n函数f(0.63)={1,r}\r\n",XSLSF::nlgr(x,y,0.63)},
delete[x],delete[y]
};

[返回页首] XSLSF::elgr(x0,h,y,t)：拉格朗日法一元全区间等距插值

功能： 返回插值点t处的函数近似值z=f(t)。
参数：
x0：等距结点中的第一个结点值。
h：等距结点的步长，h>0。
y：一维实数数组，长度为n。存放给定n个结点的函数值Yi，Yi=f(Xi)。
t：存放指定插值点的值。
运行错误：
1：无效的数组指针。
2：不是一维数组。
3：步长h小于等于0。
例子：

main(:y)=
{
y=new[rtoi(real_s),rtoi(10),rtoi(EndType),0.904837, 0.818731, 0.740818, 0.670320, 0.606531, 0.548812, 0.496585, 0.449329, 0.40657, 0.367879],
printff{"\r\n函数f(0.25)={1,r}\r\n",XSLSF::elgr(0.1,0.1,y,0.25)},
printff{"\r\n函数f(0.63)={1,r}\r\n",XSLSF::elgr(0.1,0.1,y,0.63)},
printff{"\r\n函数f(0.95)={1,r}\r\n",XSLSF::elgr(0.1,0.1,y,0.95)},
delete[y]
};

[返回页首] XSLSF::nlg3(x,y,t)：抛物线法一元三点不等距插值

功能： 返回插值点t处的函数近似值z=f(t)。
参数：
x：一维实数数组，长度为n。存放给定n个结点的值Xi，要求X0<X1<...<Xn-1。
y：一维实数数组，长度为n。存放给定n个结点的函数值Yi，Yi=f(Xi)。
t：存放指定插值点的值。
运行错误：
1：实数数组不存在。
2：不是一维数组。
3：数组不匹配。
4：Xi没有按递增排列，要求X0<X1<...<Xn-1。
例子：

main(:x,y)=
{
x=new[rtoi(real_s),rtoi(5),rtoi(EndType),1.615, 1.634, 1.702, 1.828, 1.921],
y=new[rtoi(real_s),rtoi(5),rtoi(EndType),2.4145, 2.46459, 2.65271, 3.03035, 3.34066],
printff{"\r\n函数f(1.682)={1,r}\r\n",XSLSF::nlg3(x,y,1.682)},
printff{"\r\n函数f(1.813)={1,r}\r\n",XSLSF::nlg3(x,y,1.813)},
delete[x],delete[y]
};

[返回页首] XSLSF::elg3(x0,h,y,t)：抛物线法一元三点等距插值

功能： 返回插值点t处的函数近似值z=f(t)。
参数：
x0：等距结点中的第一个结点值。
h：等距结点的步长，h>0。
y：一维实数数组，长度为n。存放给定n个结点的函数值Yi，Yi=f(Xi)。
t：存放指定插值点的值。
运行错误：
1：无效的数组指针。
2：不是一维数组。
3：步长h小于等于0。
例子：

main(:y)=
{
y=new[rtoi(real_s),rtoi(10),rtoi(EndType),0.904837, 0.818731, 0.740818, 0.670320, 0.606531, 0.548812, 0.496585, 0.449329, 0.40657, 0.367879],
printff{"\r\n函数f(0.23)={1,r}\r\n",XSLSF::elg3(0.1,0.1,y,0.23)},
printff{"\r\n函数f(0.63)={1,r}\r\n",XSLSF::elg3(0.1,0.1,y,0.63)},
printff{"\r\n函数f(0.95)={1,r}\r\n",XSLSF::elg3(0.1,0.1,y,0.95)},
delete[y]
};

[返回页首] XSLSF::npqs(x,y,t)：连分式不等距插值

功能： 返回插值点t处的函数近似值z=f(t)。
参数：
x：一维实数数组，长度为n。存放给定n个结点的值Xi，要求X0<X1<...<Xn-1。
y：一维实数数组，长度为n。存放给定n个结点的函数值Yi，Yi=f(Xi)。
t：存放指定插值点的值。
运行错误：
1：实数数组不存在。
2：不是一维数组。
3：数组不匹配。
4：Xi没有按递增排列，要求X0<X1<...<Xn-1。
例子：

main(:x,y)=
{
x=new[rtoi(real_s),rtoi(10),rtoi(EndType),-1, -0.8, -0.65, -0.4, -0.3, 0, 0.2, 0.45, 0.8, 1],
y=new[rtoi(real_s),rtoi(10),rtoi(EndType),0.0384615, 0.0588236, 0.0864865, 0.2, 0.307692, 1, 0.5, 0.164948, 0.0588236, 0.0384615],
printff{"\r\n函数f(-0.85)={1,r}\r\n",XSLSF::npqs(x,y,-0.85)},
printff{"\r\n函数f(0.25)={1,r}\r\n",XSLSF::npqs(x,y,0.25)},
delete[x],delete[y]
};

[返回页首] XSLSF::epqs(x0,h,y,t)：连分式等距插值

功能： 返回插值点t处的函数近似值z=f(t)。
参数：
x0：等距结点中的第一个结点值。
h：等距结点的步长，h>0。
y：一维实数数组，长度为n。存放给定n个结点的函数值Yi，Yi=f(Xi)。
t：存放指定插值点的值。
运行错误：
1：无效的数组指针。
2：不是一维数组。
3：步长h小于等于0。
例子：

main(:y)=
{
y=new[rtoi(real_s),rtoi(11),rtoi(EndType),0.0384615, 0.0588236, 0.1, 0.2, 0.5, 1, 0.5, 0.2, 0.1, 0.0588236, 0.0384615],
printff{"\r\n函数f(-0.75)={1,r}\r\n",XSLSF::epqs(-1,0.2,y,-0.75)},
printff{"\r\n函数f(-0.05)={1,r}\r\n",XSLSF::epqs(-1,0.2,y,-0.05)},
delete[y]
};

[返回页首] XSLSF::nhmt(x,y,dy,t)：埃尔米特不等距插值

功能： 返回插值点t处的函数近似值z=f(t)。
参数：
x：一维实数数组，长度为n。存放给定n个结点的值Xi，要求X0<X1<...<Xn-1。
y：一维实数数组，长度为n。存放给定n个结点的函数值Yi，Yi=f(Xi)。
dy：一维实数数组，长度为n。存放给定n个结点的一阶导数值dY=f'(Xi)。
t：存放指定插值点的值。
运行错误：
1：无效的数组指针。
2：不是一维数组。
3：数组不匹配。
4：Xi没有按递增排列，要求X0<X1<...<Xn-1。
例子：

main(:x,y,dy)=
{
x=new[rtoi(real_s),rtoi(10),rtoi(EndType),0.1, 0.15, 0.3, 0.45, 0.55, 0.6, 0.7, 0.85, 0.90, 1],
y=new[rtoi(real_s),rtoi(10),rtoi(EndType),0.904837, 0.860708, 0.740818, 0.637628, 0.57695, 0.548812, 0.496585, 0.427415, 0.40657, 0.367879],
dy=new[rtoi(real_s),rtoi(10),rtoi(EndType),-0.904837, -0.860708, -0.740818, -0.637628, -0.57695, -0.548812, -0.496585, -0.427415, -0.40657, -0.367879],
printff{"\r\n函数f(0.356)={1,r}\r\n",XSLSF::nhmt(x,y,dy,0.356)},
delete[x],delete[y],delete[dy]
};

[返回页首] XSLSF::ehmt(x0,h,y,dy,t)：埃尔米特等距插值

功能： 返回插值点t处的函数近似值z=f(t)。
参数：
x0：等距结点中的第一个结点值。
h：等距结点的步长，h>0。
y：一维实数数组，长度为n。存放给定n个结点的函数值Yi，Yi=f(Xi)。
dy：一维实数数组，长度为n。存放给定n个结点的一阶导数值dY=f'(Xi)。
t：存放指定插值点的值。
运行错误：
1：无效的数组指针。
2：不是一维数组。
3：数组不匹配。
4：步长h小于等于0。
例子：

main(:y,dy)=
{
y=new[rtoi(real_s),rtoi(10),rtoi(EndType),0.904837, 0.818731, 0.740818, 0.67032, 0.606531, 0.548812, 0.496585, 0.449329, 0.40657, 0.367879],
dy=new[rtoi(real_s),rtoi(10),rtoi(EndType),-0.904837, -0.818731, -0.740818, -0.67032, -0.606531, -0.548812, -0.496585, -0.449329, -0.40657, -0.367879],
printff{"\r\n函数f(0.752)={1,r}\r\n",XSLSF::ehmt(0.1,0.1,y,dy,0.752)},
delete[y],delete[dy]
};

[返回页首] XSLSF::natk(x,y,t,eps)：埃特金不等距逐步插值

功能： 返回插值点t处的函数近似值z=f(t)。
参数：
x：一维实数数组，长度为n。存放给定n个结点的值Xi，要求X0<X1<...<Xn-1。
y：一维实数数组，长度为n。存放给定n个结点的函数值Yi，Yi=f(Xi)。
t：存放指定插值点的值。
eps：插值的精度要求。
运行错误：
1：无效的数组指针。
2：不是一维数组。
3：数组不匹配。
4：Xi没有按递增排列，要求X0<X1<...<Xn-1。
例子：

main(:y,x)=
{
x=new[rtoi(real_s),rtoi(11),rtoi(EndType),-1, -0.8, -0.65, -0.4, -0.3, 0, 0.2, 0.4, 0.6, 0.8, 1],
y=new[rtoi(real_s),rtoi(11),rtoi(EndType),0.0384615, 0.0588236, 0.0864865, 0.2, 0.307692, 1, 0.5, 0.2, 0.1, 0.0588236, 0.0384615],
printff{"\r\n函数f(-0.75)={1,r}\r\n",XSLSF::natk(x,y,-0.75,1e-6)},
printff{"\r\n函数f(0.05)={1,r}\r\n",XSLSF::natk(x,y,0.05,1e-6)},
delete[y],delete[x]
};

[返回页首] XSLSF::eatk(x0,h,y,t,eps)：埃特金等距逐步插值
功能： 返回插值点t处的函数近似值z=f(t)。
参数：
x0：等距结点中的第一个结点值。
h：等距结点的步长，h>0。
y：一维实数数组，长度为n。存放给定n个结点的函数值Yi，Yi=f(Xi)。
t：存放指定插值点的值。
eps：插值的精度要求。
运行错误：
1：无效的数组指针。
2：不是一维数组。
3：步长h小于等于0。
例子：

main(:y)=
{
y=new[rtoi(real_s),rtoi(10),rtoi(EndType),0.904837, 0.818731, 0.740818, 0.670320, 0.606531, 0.548812, 0.496585, 0.449329, 0.40657, 0.367879],
printff{"\r\n函数f(0.15)={1,r}\r\n",XSLSF::eatk(0.1,0.1,y,0.15,1e-6)},
printff{"\r\n函数f(0.55)={1,r}\r\n",XSLSF::eatk(0.1,0.1,y,0.55,1e-6)},
delete[y]
};

[返回页首] XSLSF::nspl(x,y,k,t,s0,s1,s2,s3,s4)：光滑不等距插值
功能：返回值无意义。
参数：
x：一维实数数组，长度为n。存放给定n个结点的值Xi，要求X0<X1<...<Xn-1。
y：一维实数数组，长度为n。存放给定n个结点的函数值Yi，Yi=f(Xi)。
k：整数，k>=0表示只计算k（k=0,1,...,n-2）个子区间[Xk,Xk+1]上的三次多项式（s(X)=s0+s1*(X-Xk)+s2*(X-Xk)^2+s3*(X-Xk)^3）的系数s0,s1,s2,s3（当k>=n-1时，按k=n-2处理）；若k<0，表示需要计算指定插值点t处的函数近似值f(t)，并计算插值点t所在子区间的三次多项式的系数s0,s1,s2,s3。
t：存放指定插值点的值。k>=0时无意义。
s0,s1,s2,s3：返回三次多项式的系数。
s4：k<0时，返回指定插值点t处的函数近似值f(t)。
运行错误：
1：无效的数组指针。
2：不是一维数组。
3：数组不匹配。
4：Xi没有按递增排列，要求X0<X1<...<Xn-1。
例子：

main(:y,x,s0,s1,s2,s3,s4)=
{
x=new[rtoi(real_s),rtoi(11),rtoi(EndType),-1, -0.95, -0.75, -0.55, -0.3, 0, 0.2, 0.45, 0.6, 0.8, 1],
y=new[rtoi(real_s),rtoi(11),rtoi(EndType),0.0384615, 0.0424403, 0.06639, 0.116788, 0.307692, 1, 0.5, 0.164948, 0.1, 0.0588236, 0.0384615],
XSLSF::nspl(x,y,-1,-0.85,&s0,&s1,&s2,&s3,&s4),
printff{"\r\n函数f(-0.85)={1,r}\r\ns0={2,r,-14.6},s1={3,r,-14.6},s2={4,r,-14.6},s3={5,r,-14.6}\r\n",s4,s0,s1,s2,s3},
XSLSF::nspl(x,y,-1,0.15,&s0,&s1,&s2,&s3,&s4),
printff{"\r\n函数f(0.15)={1,r}\r\ns0={2,r,-14.6},s1={3,r,-14.6},s2={4,r,-14.6},s3={5,r,-14.6}\r\n",s4,s0,s1,s2,s3},
delete[y],delete[x]
};

[返回页首] XSLSF::espl(x0,h,y,k,t,s0,s1,s2,s3,s4)：光滑等距插值
功能： 返回值无意义。
参数：
x0：等距结点中的第一个结点值。
h：等距结点的步长，h>0。
y：一维实数数组，长度为n。存放给定n个结点的函数值Yi，Yi=f(Xi)。
k：整数，k>=0表示只计算k（k=0,1,...,n-2）个子区间[Xk,Xk+1]上的三次多项式（s(X)=s0+s1*(X-Xk)+s2*(X-Xk)^2+s3*(X-Xk)^3）的系数s0,s1,s2,s3（当k>=n-1时，按k=n-2处理）；若k<0，表示需要计算指定插值点t处的函数近似值f(t)，并计算插值点t所在子区间的三次多项式的系数s0,s1,s2,s3。
t：存放指定插值点的值。k>=0时无意义。
s0,s1,s2,s3：返回三次多项式的系数。
s4：k<0时，返回指定插值点t处的函数近似值f(t)。
运行错误：
1：无效的数组指针。
2：不是一维数组。
3：步长h小于等于0。
例子：

main(:y,s0,s1,s2,s3,s4)=
{
y=new[rtoi(real_s),rtoi(11),rtoi(EndType): 0.0384615, 0.0588236, 0.1, 0.2, 0.5, 1, 0.5, 0.2, 0.1, 0.0588236, 0.0384615],
XSLSF::espl(-1,0.2,y,-1,-0.65,&s0,&s1,&s2,&s3,&s4),
printff{"\r\n函数f(-0.65)={1,r}\r\ns0={2,r,-14.6},s1={3,r,-14.6},s2={4,r,-14.6},s3={5,r,-14.6}\r\n",s4,s0,s1,s2,s3},
XSLSF::espl(-1,0.2,y,-1,0.25,&s0,&s1,&s2,&s3,&s4),
printff{"\r\n函数f(0.25)={1,r}\r\ns0={2,r,-14.6},s1={3,r,-14.6},s2={4,r,-14.6},s3={5,r,-14.6}\r\n",s4,s0,s1,s2,s3},
delete[y]
};

[返回页首] XSLSF::spl1(x,y,dy,ddy,t,z,dz,ddz)：第一种边界条件的三次样条函数插值、微商与积分
功能： 返回一个积分值 ∫[X0,Xn-1]f(X)dX 。
参数：
x：一维实数数组，长度为n。存放给定n个结点的值Xi，要求X0<X1<...<Xn-1。
y：一维实数数组，长度为n。存放给定n个结点的函数值Yi，Yi=f(Xi)。
dy：一维实数数组，长度为n。调用时，dy(0)存放给定的左端点处的一阶导数值，dy(n-1)存放给定的右端点处的一阶导数值。返回时存放n个给定结点处的一阶导数值。
ddy：一维实数数组，长度为n。返回时存放n个给定结点处的二阶导数值。
t：一维实数数组，长度为m。存放m个指定插值点的值。要求X0<t(j)<X(n-1)（j=0,1,2,...,m-1）。
z：一维实数数组，长度为m。返回时存放m个给定插值点处的函数值。
dz：一维实数数组，长度为m。返回时存放m个给定插值点处的一阶导数值。
ddy：一维实数数组，长度为m。返回时存放m个给定插值点处的二阶导数值。
运行错误：
1：无效的数组指针。
2：不是一维数组。
3：数组不匹配。
4：Xi没有按递增排列，要求X0<X1<...<Xn-1。
5：Ti没有按递增排列，要求T0<T1<...<Tm-1。
6：n非法。要求n>=2。
7：内存错误。
例子：

main(:x,y,dy,ddy,t,z,dz,ddz,s,i)=
{
x=new[rtoi(real_s),rtoi(12),rtoi(EndType): 0.52, 8, 17.95, 28.65, 50.65, 104.6, 156.6, 260.7, 364.4, 468, 507, 520],
y=new[rtoi(real_s),rtoi(12),rtoi(EndType): 5.28794, 13.84, 20.2, 24.9, 31.1, 36.5, 36.6, 31, 20.9, 7.8, 1.5, 0.2],
dy=new[rtoi(real_s),rtoi(12),rtoi(EndType): 1.86548, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0.046115],
ddy=new[rtoi(real_s),rtoi(12)],
t=new[rtoi(real_s),rtoi(8),rtoi(EndType): 4, 14, 30, 60, 130, 230, 450, 515],
z=new[rtoi(real_s),rtoi(8)],
dz=new[rtoi(real_s),rtoi(8)],
ddz=new[rtoi(real_s),rtoi(8)],
s=XSLSF::spl1(x,y,dy,ddy,t,z,dz,ddz),
printff{"\r\n{1,ns,14} {2,ns,14} {3,ns,14} {4,ns,14}\r\n","x(i)","y(i)","dy(i)","ddy(i)"},
i=0,
(i<12).while{printff{"{1,r,14.6} {2,r,14.6} {3,r,14.6} {4,r,14.6}\r\n",get[x,rtoi(i)],get[y,rtoi(i)],get[dy,rtoi(i)],get[ddy,rtoi(i)]},i++},
printff{"\r\ns={1,r}\r\n",s},
printff{"\r\n{1,ns,14} {2,ns,14} {3,ns,14} {4,ns,14}\r\n","t(i)","z(i)","dz(i)","ddz(i)"},
i=0,
(i<8).while{printff{"{1,r,14.6} {2,r,14.6} {3,r,14.6} {4,r,14.6}\r\n",get[t,rtoi(i)],get[z,rtoi(i)],get[dz,rtoi(i)],get[ddz,rtoi(i)]},i++},
delete[x],delete[y],delete[dy],delete[ddy],delete[t],delete[z],delete[dz],delete[ddz]
};

[返回页首] XSLSF::spl2(x,y,dy,ddy,t,z,dz,ddz)：第二种边界条件的三次样条函数插值、微商与积分
功能： 返回一个积分值 ∫[X0,Xn-1]f(X)dX 。
参数：
x：一维实数数组，长度为n。存放给定n个结点的值Xi，要求X0<X1<...<Xn-1。
y：一维实数数组，长度为n。存放给定n个结点的函数值Yi，Yi=f(Xi)。
dy：一维实数数组，长度为n。返回时存放n个给定结点处的一阶导数值。
ddy：一维实数数组，长度为n。调用时，ddy(0)存放给定的左端点处的二阶导数值，ddy(n-1)存放给定的右端点处的二阶导数值。返回时存放n个给定结点处的二阶导数值。
t：一维实数数组，长度为m。存放m个指定插值点的值。要求X0<t(j)<X(n-1)（j=0,1,2,...,m-1）。
z：一维实数数组，长度为m。返回时存放m个给定插值点处的函数值。
dz：一维实数数组，长度为m。返回时存放m个给定插值点处的一阶导数值。
ddy：一维实数数组，长度为m。返回时存放m个给定插值点处的二阶导数值。
运行错误：
1：无效的数组指针。
2：不是一维数组。
3：数组不匹配。
4：Xi没有按递增排列，要求X0<X1<...<Xn-1。
5：Ti没有按递增排列，要求T0<T1<...<Tm-1。
6：n非法。要求n>=2。
7：内存错误。

例子：

main(:x,y,dy,ddy,t,z,dz,ddz,s,i)=
{
x=new[rtoi(real_s),rtoi(12),rtoi(EndType): 0.52, 8, 17.95, 28.65, 50.65, 104.6, 156.6, 260.7, 364.4, 468, 507, 520],
y=new[rtoi(real_s),rtoi(12),rtoi(EndType): 5.28794, 13.84, 20.2, 24.9, 31.1, 36.5, 36.6, 31, 20.9, 7.8, 1.5, 0.2],
dy=new[rtoi(real_s),rtoi(12)],
ddy=new[rtoi(real_s),rtoi(12),rtoi(EndType): -0.279319, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.011156],
t=new[rtoi(real_s),rtoi(8),rtoi(EndType): 4, 14, 30, 60, 130, 230, 450, 515],
z=new[rtoi(real_s),rtoi(8)],
dz=new[rtoi(real_s),rtoi(8)],
ddz=new[rtoi(real_s),rtoi(8)],
s=XSLSF::spl2(x,y,dy,ddy,t,z,dz,ddz),
printff{"\r\n{1,ns,14} {2,ns,14} {3,ns,14} {4,ns,14}\r\n","x(i)","y(i)","dy(i)","ddy(i)"},
i=0,
(i<12).while{printff{"{1,r,14.6} {2,r,14.6} {3,r,14.6} {4,r,14.6}\r\n",get[x,rtoi(i)],get[y,rtoi(i)],get[dy,rtoi(i)],get[ddy,rtoi(i)]},i++},
printff{"\r\ns={1,r}\r\n",s},
printff{"\r\n{1,ns,14} {2,ns,14} {3,ns,14} {4,ns,14}\r\n","t(i)","z(i)","dz(i)","ddz(i)"},
i=0,
(i<8).while{printff{"{1,r,14.6} {2,r,14.6} {3,r,14.6} {4,r,14.6}\r\n",get[t,rtoi(i)],get[z,rtoi(i)],get[dz,rtoi(i)],get[ddz,rtoi(i)]},i++},
delete[x],delete[y],delete[dy],delete[ddy],delete[t],delete[z],delete[dz],delete[ddz]
};

[返回页首] XSLSF::spl3(x,y,dy,ddy,t,z,dz,ddz)：第三种边界条件的三次样条函数插值、微商与积分
功能： 返回一个积分值 ∫[X0,Xn-1]f(X)dX 。
参数：
x：一维实数数组，长度为n。存放给定n个结点的值Xi，要求X0<X1<...<Xn-1。
y：一维实数数组，长度为n。存放给定n个结点的函数值Yi，Yi=f(Xi)。要求Y0=Yn-1。
dy：一维实数数组，长度为n。返回时存放n个给定结点处的一阶导数值。
ddy：一维实数数组，长度为n。返回时存放n个给定结点处的二阶导数值。
t：一维实数数组，长度为m。存放m个指定插值点的值。要求X0<t(j)<X(n-1)（j=0,1,2,...,m-1）。
z：一维实数数组，长度为m。返回时存放m个给定插值点处的函数值。
dz：一维实数数组，长度为m。返回时存放m个给定插值点处的一阶导数值。
ddy：一维实数数组，长度为m。返回时存放m个给定插值点处的二阶导数值。
运行错误：
1：无效的数组指针。
2：不是一维数组。
3：数组不匹配。
4：Xi没有按递增排列，要求X0<X1<...<Xn-1。
5：Ti没有按递增排列，要求T0<T1<...<Tm-1。
6：n非法。要求n>=2。
7：内存错误。

例子：

!using("XSLSF");
main(:x,y,dy,ddy,t,z,dz,ddz,s,i)=
{
x=new[rtoi(real_s),rtoi(37)],
y=new[rtoi(real_s),rtoi(37)],
dy=new[rtoi(real_s),rtoi(37)],
ddy=new[rtoi(real_s),rtoi(37)],
t=new[rtoi(real_s),rtoi(36)],
z=new[rtoi(real_s),rtoi(36)],
dz=new[rtoi(real_s),rtoi(36)],
ddz=new[rtoi(real_s),rtoi(36)],
i=0, while{i<=36,setrai(x,i,i*6.2831852/36),setrai(y,i,sin(i*6.2831852/36)),i++},
i=0, while{i<=35,setrai(t,i,(0.5+i)*6.2831852/36),i++},
s=spl3(x,y,dy,ddy,t,z,dz,ddz),
printff{"\r\n{1,ns,14} {2,ns,14} {3,ns,14} {4,ns,14}\r\n","x(i)","y(i)=sin(x)","dy(i)=cos(x)","ddy(i)=-sin(x)"},
printff{"{1,r,14.6} {2,r,14.6} {3,r,14.6} {4,r,14.6}\r\n",getrai[x,0],getrai[y,0],getrai[dy,0],getrai[ddy,0]},
i=0,
(i<36).while{
printff{"{1,r,14.6} {2,r,14.6} {3,r,14.6} {4,r,14.6}\r\n",getrai[t,i]*36/0.62831852,getrai[z,i],getrai[dz,i],getrai[ddz,i]},
printff{"{1,r,14.6} {2,r,14.6} {3,r,14.6} {4,r,14.6}\r\n",getrai[x,i+1]*36/0.62831852,getrai[y,i+1],getrai[dy,i+1],getrai[ddy,i+1]},
i++
},
printff{"\r\ns={1,r}\r\n",s},
delete[x],delete[y],delete[dy],delete[ddy],delete[t],delete[z],delete[dz],delete[ddz]
};

[返回页首] XSLSF::slq3(x,y,z,u,v)：二元三点插值
功能： 返回一个函数值 f(u,v)。
参数：
x：一维实数数组，长度为n。存放给定n×m个结点X方向的n个坐标。
y：一维实数数组，长度为m。存放给定n×m个结点Y方向的m个坐标。
z：二维实数数组，长度为n×m。存放给定n×m个结点上的函数值Z=f(Xi,Yj)。
u：指定插值点的X坐标。
v：指定插值点的Y坐标。
运行错误：
1：无效的数组指针。
2：不是一维数组或二维数组。
3：数组维数不匹配。
4：Xi没有按递增排列，要求X0<X1<...<Xn-1。
5：Yi没有按递增排列，要求Y0<Y1<...<Ym-1。
例子：

!using("XSLSF");
main(:y,x,z,i,j)=
{
x=new[rtoi(real_s),rtoi(6)],
y=new[rtoi(real_s),rtoi(5)],
z=new[rtoi(real_s),rtoi(6),rtoi(5)],
i=0, while{i<=5,setrai(x,i,i*0.2),i++},
i=0, while{i<=4,setrai(y,i,i*0.25),i++},
i=0, while{i<=5,j=0,while{j<=4,setrai(z:i:j,exp(-i*0.2+j*0.25)),j++},i++},
printff{"\r\nz={1,r}\r\n",slq3(x,y,z,0.9,0.8)},
printff{"\r\nz={1,r}\r\n",slq3(x,y,z,0.3,0.9)},
delete[y],delete[x],delete[z]
};

[返回页首] XSLSF::slgq(x,y,z,u,v)：二元全区间插值
功能： 返回一个函数值 f(u,v)。
参数：
x：一维实数数组，长度为n。存放给定n×m个结点X方向的n个坐标。
y：一维实数数组，长度为m。存放给定n×m个结点Y方向的m个坐标。
z：二维实数数组，长度为n×m。存放给定n×m个结点上的函数值Z=f(Xi,Yj)。
u：指定插值点的X坐标。
v：指定插值点的Y坐标。
运行错误：
1：无效的数组指针。
2：不是一维数组或二维数组。
3：数组维数不匹配。
4：Xi没有按递增排列，要求X0<X1<...<Xn-1。
5：Yi没有按递增排列，要求Y0<Y1<...<Ym-1。
例子：

!using("XSLSF");
main(:y,x,z,i,j)=
{
x=new[rtoi(real_s),rtoi(11)],
y=new[rtoi(real_s),rtoi(11)],
z=new[rtoi(real_s),rtoi(11),rtoi(11)],
i=0, while{i<=10,setrai(x,i,i*0.1),i++},
i=0, while{i<=10,setrai(y,i,i*0.1),i++},
i=0, while{i<=10,j=0,while{j<=10,setrai(z:i:j,exp(-i*0.1+j*0.1)),j++},i++},
printff{"\r\nz={1,r}\r\n",slgq(x,y,z,0.35,0.65)},
printff{"\r\nz={1,r}\r\n",slgq(x,y,z,0.45,0.55)},
delete[y],delete[x],delete[z]
};

8 数值积分 [返回页首]

[返回页首] XSLSF::ffts(f,a,b,eps)：变步长梯形求积法

参数：
f：一元函数句柄，必须由二级函数HFor获得该句柄。
a、b：积分下限与积分上限。
eps：积分精度要求，eps>0。
运行错误：
1：无效的函数句柄。
2：不是一元函数。
3：参数不符合要求。
例子：

f(x)=exp[-x*x];
XSLSF::ffts[HFor("f",2),0,1,1e-6];

[返回页首] XSLSF::simp(f,a,b,eps)：变步长辛卜生求积法

参数：
f：一元函数句柄，必须由二级函数HFor获得该句柄。
a、b：积分下限与积分上限。
eps：积分精度要求，eps>0。
运行错误：
1：无效的函数句柄。
2：不是一元函数。
3：参数不符合要求。
例子：

f(x)=ln[1+x]/[1+x*x];
XSLSF::simp[HFor("f",2),0,1,1e-6];

[返回页首] XSLSF::fpts(f,a,b,eps,d)：自适应梯形求积法

参数：
f：一元函数句柄，必须由二级函数HFor获得该句柄。
a、b：积分下限与积分上限。
eps：积分精度要求，eps>0。
d：对积分区间分割的最小步长，当子区间的宽度小于d时，即使没有满足精度要求，也不再往下进行分割。
运行错误：
1：无效的函数句柄。
2：不是一元函数。
3：参数不符合要求。
例子：

f(x)=1/[1+25*x*x];
XSLSF::fpts[HFor("f",2),-1,1,1e-6,0.0001];

[返回页首] XSLSF::romb(f,a,b,eps)：龙贝格求积法

参数：
f：一元函数句柄，必须由二级函数HFor获得该句柄。
a、b：积分下限与积分上限。
eps：积分精度要求，eps>0。
运行错误：
1：无效的函数句柄。
2：不是一元函数。
3：参数不符合要求。
例子：

f(x)=x/[4+x*x];
XSLSF::romb[HFor("f",2),0,1,1e-6];

[返回页首] XSLSF::fpqg(f,a,b,eps)：计算一维积分的连分式法

参数：
f：一元函数句柄，必须由二级函数HFor获得该句柄。
a、b：积分下限与积分上限。
eps：积分精度要求，eps>0。
运行错误：
1：无效的函数句柄。
2：不是一元函数。
3：参数不符合要求。
例子：

f(x)=exp[-x*x];
XSLSF::fpqg[HFor("f",2),0,4.3,1e-6];

[返回页首] XSLSF::part(a,b,m,fa,fb,&s0,&s1)：高震荡函数求积法

用分部积分法计算高震荡函数的积分：∫ab f(x)sinmxdx与∫ab f(x)cosmxdx。

参数：
a、b：积分下限与积分上限，b>a。
m：被积函数中震荡函数的角频率。
fa：双精度实型一维数值，长度为n。存放f(x)在积分区间端点x=a处的各阶导数值，即：fa(i)=f(i)(a)，i=0,1,... ...,n-1。
fb：双精度实型一维数值，长度为n。存放f(x)在积分区间端点x=b处的各阶导数值，即：fb(i)=f(i)(b)，i=0,1,... ...,n-1。
s0：返回积分∫ab f(x)cosmxdx的值。
s1：返回积分∫ab f(x)sinmxdx的值。
运行错误：
1：无效的函数句柄。
2：不是一元函数。
3：参数不符合要求。
例子：

main(:fa,fb,s0,s1)=
{
fa=new[rtoi(real_s),rtoi(4),rtoi(EndType): 0,1,0,-3],
fb=new[rtoi(real_s),rtoi(4),rtoi(EndType): 6.2831852,1,-6.2831852,-3],
XSLSF::part[0,6.2831852,30,fa,fb,&s0,&s1],
printff{"\r\ns0={1,r} , s1={2,r}\r\n",s0,s1},
delete[fa],delete[fb]
};

[返回页首] XSLSF::lrgs(f,a,b,eps)：勒让德－高斯求积法

参数：
f：一元函数句柄，必须由二级函数HFor获得该句柄。
a、b：积分下限与积分上限。
eps：积分精度要求，eps>0。
运行错误：
1：无效的函数句柄。
2：不是一元函数。
3：参数不符合要求。
例子：

f(x)=x*x+sin[x];
XSLSF::lrgs[HFor("f",2),2.5,8.4,1e-6];

[返回页首] XSLSF::lags(f)：拉盖尔－高斯求积法 ，积分区间：0～+∞

参数：
f：一元函数句柄，必须由二级函数HFor获得该句柄。
运行错误：
1：无效的函数句柄。
2：不是一元函数。
例子：

f(x)=x*exp[-x];
XSLSF::lags[HFor("f",2)];

[返回页首] XSLSF::hmgs(f)：埃尔米特－高斯求积法 ，积分区间：-∞～+∞

参数：
f：一元函数句柄，必须由二级函数HFor获得该句柄。
运行错误：
1：无效的函数句柄。
2：不是一元函数。
例子：

f(x)=x*x*exp[-x*x];
XSLSF::hmgs[HFor("f",2)];

[返回页首] XSLSF::cbsv(f,a,b,eps)：切比雪夫求积法

参数：
f：一元函数句柄，必须由二级函数HFor获得该句柄。
a、b：积分下限与积分上限。
eps：积分精度要求，eps>0。
运行错误：
1：无效的函数句柄。
2：不是一元函数。
3：参数不符合要求。
例子：

f(x)=x*x+sin[x];
XSLSF::cbsv[HFor("f",2),2.5,8.4,1e-6];

[返回页首] XSLSF::imtcl(f,a,b)：计算一维积分的蒙特卡洛法

参数：
f：一元函数句柄，必须由二级函数HFor获得该句柄。
a、b：积分下限与积分上限。
运行错误：
1：无效的函数句柄。
2：不是一元函数。
例子：

f(x)=x*x+sin[x];
XSLSF::imtcl[HFor("f",2),2.5,8.4];

[返回页首] XSLSF::sim2(f,a,b,yx,eps)：变步长辛卜生二重求积法

参数：
f：二元被积函数的句柄，必须由二级函数HFor获得该句柄。
a、b：积分下限与积分上限。
yx：计算上、下限y1(x)、y0(x)（要求y1(x)>y0(x)）的三元函数句柄，必须由二级函数HFor获得该句柄。格式如下：

yx(x,y0,y1)=
{
y0=y0(x)的表达式,
y1=y1(x)的表达式
};

eps：积分精度要求，eps>0。
运行错误：
1：无效的函数句柄。
2：不是二元或三元函数。
3：参数不符合要求。
例子：

f(x,y)=exp[x*x+y*y];
yx(x,y0,y1)=
{
y0=-sqrt[1-x*x],
y1=-y0
};
XSLSF::sim2[HFor("f",2),0,1,HFor("yx",2),1e-4];

[返回页首] XSLSF::igaus(f,yx,m1,m2,...,mn)：计算多重积分的高斯方法

参数：
f：n元被积函数的句柄，必须由二级函数HFor获得该句柄。
yx：计算各层积分上、下限y1(x)、y0(x)（要求所有的上限>下限）的函数句柄，必须由二级函数HFor获得该句柄。格式如下：

yx(j,x1,x2,... ...,xn,y0,y1)= //x1,x2,... ...,xn是n个自变量；y0,y1返回第j层积分的上限与下限
{
which{
j==0:[y0=a,y1=b], //a、b为常数，注意方括号不可缺省，但可以是其他括号(...)或{...}，下同。
j==1:[y0=y0(x1),y1=y1(x1)],
j==2:[y0=y0(x1,x2),y1=y1(x1,x2)],
... ...,
j==n-1:[y0=y0(x1,x2,... ...,xn-1),y1=y1(x1,x2,... ...,xn-1)]
}
};

m1,m2,...,mn：mi表示第i层积分区间所划分的子区间个数。
运行错误：
1：最少需要3个参数。
2：无效的函数句柄。
3：参数不匹配。
4：积分区间所划分的子区间个数不能小于1。
5：内存错误。
例子：

f(x,y,z)=z*z;
yx(j,x1,x2,x3,y0,y1)=
{
which{
j==0:[y0=0,y1=1],
j==1:[y0=0,y1=sqrt(1-x1*x1)],
j==2:[y0=sqrt(x1*x1+x2*x2),y1=sqrt(2-x1*x1-x2*x2)]
}
};
XSLSF::igaus[HFor("f",2),HFor("yx",2),4,4,4];

[返回页首] XSLSF::pqg2(f,a,b,yx,eps)：计算二重积分的连分式法

参数：
f：二元被积函数的句柄，必须由二级函数HFor获得该句柄。
a、b：积分下限与积分上限。
yx：计算上、下限y1(x)、y0(x)（要求y1(x)>y0(x)）的三元函数句柄，必须由二级函数HFor获得该句柄。格式如下：

yx(x,y0,y1)=
{
y0=y0(x)的表达式,
y1=y1(x)的表达式
};

eps：积分精度要求，eps>0。
运行错误：
1：无效的函数句柄。
2：不是二元或三元函数。
3：参数不符合要求。
例子：

f(x,y)=exp[x*x+y*y];
yx(x,y0,y1)=
{
y0=-sqrt[1-x*x],
y1=-y0
};
XSLSF::pqg2[HFor("f",2),0,1,HFor("yx",2),0.00005];

[返回页首] XSLSF::mtml(f,a0,a1,... ...,an-1,b0,b1,... ...,bn-1)：计算多重积分的蒙特卡洛法

参数：
f：n元被积函数的句柄，必须由二级函数HFor获得该句柄。
a0,a1,... ...,an-1：积分的下限值。
b0,b1,... ...,bn-1：积分的上限值。
运行错误：
1：最少需要3个参数。
2：无效的函数句柄。
3：参数不匹配。
例子：

f(x,y,z)=x*x+y*y+z*z;
XSLSF::mtml[HFor("f",2):1,1,1:2,2,2];

9 常微分方程（组）的求解 [返回页首]

[返回页首] XSLSF::elr1(f,t,y,h,z)：全区间积分的定步长欧拉方法

f：表达式句柄，必须由二级函数HFor获得该句柄，用于计算微分方程组中各方程右端函数值，由用户自编。该表达式有2*n+1个参数，第一个参数为自变量，随后n个参数为函数值，最后n个参数为右端函数值（即微分方程的值）。n为微分方程组中方程的个数，也是未知函数的个数。形式如下：

> f(t,y1,y2,y3,d1,d2,d3)=
> { d1=y2,
> d2=-y1,
> d3=-y3
> };

t：对微分方程进行积分的起始点。
y：整数，一维数组，长度为n，存放n个未知函数在起始点处的函数值，返回时，这些初值存放在二维数组z的第0列中。
h：积分步长。
z：整数，二维数组（n,k），返回k个积分点（包括起始点）上的未知函数值。k也是积分步数，包括起始点这一步。
该函数返回的运行错误代码的意义如下：
1：指定的表达式不存在；
2：无效的数组指针；
3：不是一维或二维数组；
4：数组维数不正确。
5：表达式参数不符合要求、方程个数<1、积分步数<1或者积分步长<=0；
例子：设一阶微分方程组及初值为：
y0'=y1,y0(0)=-1.0
y1'=-y0,y1(0)=0.0
y2'=-y2,y2(0)=1.0
计算当步长h=0.01时，11个积分点（包括起始点）ti=i*h，i=0，1，...，10上的未知函数的近似值y0i，y1i，y2i（i=0，1，...，10）。其中起始点t=0.0，n=3，k=11，h=0.01。
程序如下：
f(t,y0,y1,y2,d0,d1,d2)={d0=y1,d1=-y0,d2=-y2}; //函数定义
main(:a,b,h,i,j)=
{
a=new[rtoi(real_s),rtoi(3),rtoi(EndType): -1,0,1],
b=new[rtoi(real_s),rtoi(3),rtoi(11)],
h=0.01,
XSLSF::elr1[HFor("f",2),0,a,h,b],
i=0,
while{i<=10,
printff["\r\nt={1,r,-14.6}",i*h],j=0,
while{j<=2,
printff{"y({1,i})={2,r,-14.6}",j,XSLSF::getrai(b,j,i)},
j++
},
i++
},
printff["\r\n"],
delete[a],delete[b]
};

[返回页首] XSLSF::elr2(f,t,y,h,eps)：积分一步的变步长欧拉方法

f：表达式句柄，必须由二级函数HFor获得该句柄，用于计算微分方程组中各方程右端函数值，由用户自编。该表达式有2*n+1个参数，第一个参数为自变量，随后n个参数为函数值，最后n个参数为右端函数值（即微分方程的值）。n为微分方程组中方程的个数，也是未知函数的个数。形式如下：

> f(t,y1,y2,y3,d1,d2,d3)=
> { d1=y2,
> d2=-y1,
> d3=-y3
> };

t：对微分方程进行积分的起始点。
y：整数，一维数组，长度为n*4，前n个数存放n个未知函数在起始点处的函数值，返回时，存放t+h处的n个未知函数值。
h：积分步长。
eps：积分精度。
该函数返回的运行错误代码的意义如下：
1：指定的表达式不存在；
2：无效的数组指针；
3：不是二维数组；
4：数组维数不正确。
5：表达式参数不符合要求、方程个数<1、积分步数<1或者积分步长<=0；
例子：设一阶微分方程组及初值为：
y0'=y1,y0(0)=-1.0
y1'=-y0,y1(0)=0.0
y2'=-y2,y2(0)=1.0
计算当步长h=0.01时，11个积分点（包括起始点）ti=i*h，i=0，1，...，10上的未知函数的近似值y0i，y1i，y2i（i=0，1，...，10）。其中起始点t=0.0，n=3，h=0.01，eps=0.00001。
程序如下：
f(t,y0,y1,y2,d0,d1,d2)={d0=y1,d1=-y0,d2=-y2}; //函数定义
main(:a,t,h,i,j,hf)=
{
a=new[rtoi(real_s),rtoi(12),rtoi(EndType): -1,0,1],
t=0,h=0.01,hf=HFor("f",2),
printff["\r\nt={1,r,-14.6}",t],
i=0,while{i<=2,printff{"y({1,i})={2,r,-14.6}",i,XSLSF::getrai(a,i)},i++},
i=1,
while{i<=10,
XSLSF::elr2[hf,t,a,h,0.00001],t=t+h,
printff["\r\nt={1,r,-14.6}",t],j=0,
while{j<=2,
printff{"y({1,i})={2,r,-14.6}",j,XSLSF::getrai(a,j)},
j++
},
i++
},
printff["\r\n"],
delete[a]
};

[返回页首] XSLSF::wity(f,t,y,h,z)：全区间积分的定步长维梯方法

f：表达式句柄，必须由二级函数HFor获得该句柄，用于计算微分方程组中各方程右端函数值，由用户自编。该表达式有2*n+1个参数，第一个参数为自变量，随后n个参数为函数值，最后n个参数为右端函数值（即微分方程的值）。n为微分方程组中方程的个数，也是未知函数的个数。形式如下：

> f(t,y1,y2,y3,d1,d2,d3)=
> { d1=y2,
> d2=-y1,
> d3=-y3
> };

t：对微分方程进行积分的起始点。
y：整数，一维数组，长度为n+n，前n个数存放n个未知函数在起始点处的函数值，返回时，这些初值存放在二维数组z的第0列中。
h：积分步长。
z：整数，二维数组（n,k），返回k个积分点（包括起始点）上的未知函数值。k也是积分步数，包括起始点这一步。
该函数返回的运行错误代码的意义如下：
1：指定的表达式不存在；
2：无效的数组指针；
3：不是一维或二维数组；
4：数组维数不正确。
5：表达式参数不符合要求、方程个数<1、积分步数<1或者积分步长<=0；
例子：设一阶微分方程组及初值为：
y0'=y1,y0(0)=-1.0
y1'=-y0,y1(0)=0.0
y2'=-y2,y2(0)=1.0
计算当步长h=0.1时，11个积分点（包括起始点）ti=i*h，i=0，1，...，10上的未知函数的近似值y0i，y1i，y2i（i=0，1，...，10）。其中起始点t=0.0，n=3，k=11，h=0.1。
程序如下：
f(t,y0,y1,y2,d0,d1,d2)={d0=y1,d1=-y0,d2=-y2}; //函数定义
main(:a,b,h,i,j)=
{
a=new[rtoi(real_s),rtoi(3+3),rtoi(EndType): -1,0,1],
b=new[rtoi(real_s),rtoi(3),rtoi(11)],
h=0.1,
XSLSF::wity[HFor("f",2),0,a,h,b],
i=0,
while{i<=10,
printff["\r\nt={1,r,-14.6}",i*h],j=0,
while{j<=2,
printff{"y({1,i})={2,r,-14.6}",j,XSLSF::getrai(b,j,i)},
j++
},
i++
},
printff["\r\n"],
delete[a],delete[b]
};

[返回页首] XSLSF::rkt1(f,t,y,h,z)：全区间积分的定步长龙格-库塔法

f：表达式句柄，必须由二级函数HFor获得该句柄，用于计算微分方程组中各方程右端函数值，由用户自编。该表达式有2*n+1个参数，第一个参数为自变量，随后n个参数为函数值，最后n个参数为右端函数值（即微分方程的值）。n为微分方程组中方程的个数，也是未知函数的个数。形式如下：

> f(t,y1,y2,y3,d1,d2,d3)=
> { d1=y2,
> d2=-y1,
> d3=-y3
> };

t：对微分方程进行积分的起始点。
y：整数，一维数组，长度为n+n，前n个数存放n个未知函数在起始点处的函数值，返回时，这些初值存放在二维数组z的第0列中。
h：积分步长。
z：整数，二维数组（n,k），返回k个积分点（包括起始点）上的未知函数值。k也是积分步数，包括起始点这一步。
该函数返回的运行错误代码的意义如下：
1：指定的表达式不存在；
2：无效的数组指针；
3：不是一维或二维数组；
4：数组维数不正确。
5：表达式参数不符合要求、方程个数<1、积分步数<1或者积分步长<=0；
例子：设一阶微分方程组及初值为：
y0'=y1,y0(0)=-1.0
y1'=-y0,y1(0)=0.0
y2'=-y2,y2(0)=1.0
计算当步长h=0.01时，11个积分点（包括起始点）ti=i*h，i=0，1，...，10上的未知函数的近似值y0i，y1i，y2i（i=0，1，...，10）。其中起始点t=0.0，n=3，k=11，h=0.01。
程序如下：
f(t,y0,y1,y2,d0,d1,d2)={d0=y1,d1=-y0,d2=-y2}; //函数定义
main(:a,b,h,i,j)=
{
a=new[rtoi(real_s),rtoi(3+3),rtoi(EndType): -1,0,1],
b=new[rtoi(real_s),rtoi(3),rtoi(11)],
h=0.01,
XSLSF::rkt1[HFor("f",2),0,a,h,b],
i=0,
while{i<=10,
printff["\r\nt={1,r,-14.6}",i*h],j=0,
while{j<=2,
printff{"y({1,i})={2,r,-14.6}",j,XSLSF::getrai(b,j,i)},
j++
},
i++
},
printff["\r\n"],
delete[a],delete[b]
};

[返回页首] XSLSF::rkt2(f,t,y,h,eps)：积分一步的变步长龙格-库塔法

f：表达式句柄，必须由二级函数HFor获得该句柄，用于计算微分方程组中各方程右端函数值，由用户自编。该表达式有2*n+1个参数，第一个参数为自变量，随后n个参数为函数值，最后n个参数为右端函数值（即微分方程的值）。n为微分方程组中方程的个数，也是未知函数的个数。形式如下：

> f(t,y1,y2,y3,d1,d2,d3)=
> { d1=y2,
> d2=-y1,
> d3=-y3
> };

t：对微分方程进行积分的起始点。
y：整数，一维数组，长度为n*5，前n个数存放n个未知函数在起始点处的函数值，返回时，存放t+h处的n个未知函数值。
h：积分步长。
eps：积分精度。
该函数返回的运行错误代码的意义如下：
1：指定的表达式不存在；
2：无效的数组指针；
3：不是一维数组；
4：数组维数不正确；
5：表达式参数不符合要求、方程个数<1、积分步数<1或者积分步长<=0。
例子：设一阶微分方程组及初值为：
y0'=y1,y0(0)=0.0
y1'=-y0,y1(0)=1.0
计算当步长h=0.1时，11个积分点（包括起始点）ti=i*h，i=0，1，...，10上的未知函数的近似值y0i，y1i，y2i（i=0，1，...，10）。其中起始点t=0.0，n=3，h=0.1，eps=0.00001。
程序如下：
f(t,y0,y1,d0,d1)={d0=y1,d1=-y0}; //函数定义
main(:a,t,h,i,j,hf)=
{
a=new[rtoi(real_s),rtoi(2*5),rtoi(EndType): 0,1],
t=0,h=0.1,hf=HFor("f",2),
printff["\r\nt={1,r,-14.6}",t],
i=0,while{i<=1,printff{"y({1,i})={2,r,-14.6}",i,XSLSF::getrai(a,i)},i++},
i=1,
while{i<=10,
XSLSF::rkt2[hf,t,a,h,0.00001],t=t+h,
printff["\r\nt={1,r,-14.6}",t],j=0,
while{j<=1,
printff{"y({1,i})={2,r,-14.6}",j,XSLSF::getrai(a,j)},
j++
},
i++
},
printff["\r\n"],
delete[a]
};

[返回页首] XSLSF::gil1(f,t,y,h,eps)：积分一步的变步长基尔方法

f：表达式句柄，必须由二级函数HFor获得该句柄，用于计算微分方程组中各方程右端函数值，由用户自编。该表达式有2*n+1个参数，第一个参数为自变量，随后n个参数为函数值，最后n个参数为右端函数值（即微分方程的值）。n为微分方程组中方程的个数，也是未知函数的个数。形式如下：

> f(t,y1,y2,y3,d1,d2,d3)=
> { d1=y2,
> d2=-y1,
> d3=-y3
> };

t：对微分方程进行积分的起始点。
y：整数，一维数组，长度为n*5，前n个数存放n个未知函数在起始点处的函数值，返回时，存放t+h处的n个未知函数值。随后的n个数，在主函数第一次调用本函数时，应赋值以0，以后每调用一次本函数，将由本函数的返回值以便循环使用。
h：积分步长。
eps：积分精度。
该函数返回的运行错误代码的意义如下：
1：指定的表达式不存在；
2：无效的数组指针；
3：不是一维数组；
4：数组维数不正确。
5：表达式参数不符合要求、方程个数<1、积分步数<1或者积分步长<=0；
例子：设一阶微分方程组及初值为：
y0'=y1,y0(0)=0.0
y1'=-y0,y1(0)=1.0
y2'=-y2,y2(0)=1.0
计算当步长h=0.1时，11个积分点（包括起始点）ti=i*h，i=0，1，...，10上的未知函数的近似值y0i，y1i，y2i（i=0，1，...，10）。其中起始点t=0.0，n=3，h=0.1，eps=0.000001。
程序如下：
f(t,y0,y1,y2,d0,d1,d2)={d0=y1,d1=-y0,d2=-y2}; //函数定义
main(:a,t,h,i,j,hf)=
{
a=new[rtoi(real_s),rtoi(3*5),rtoi(EndType): 0,1,1,0,0,0],
t=0,h=0.1,hf=HFor("f",2),
printff["\r\nt={1,r,-14.6}",t],
i=0,while{i<=2,printff{"y({1,i})={2,r,-14.6}",i,XSLSF::getrai(a,i)},i++},
i=1,
while{i<=10,
XSLSF::gil1[hf,t,a,h,0.000001],t=t+h,
printff["\r\nt={1,r,-14.6}",t],j=0,
while{j<=2,
printff{"y({1,i})={2,r,-14.6}",j,XSLSF::getrai(a,j)},
j++
},
i++
},
printff["\r\n"],
delete[a]
};

[返回页首] XSLSF::gil2(f,t,y,h,z,eps)：全区间积分的变步长基尔方法

f：表达式句柄，必须由二级函数HFor获得该句柄，用于计算微分方程组中各方程右端函数值，由用户自编。该表达式有2*n+1个参数，第一个参数为自变量，随后n个参数为函数值，最后n个参数为右端函数值（即微分方程的值）。n为微分方程组中方程的个数，也是未知函数的个数。形式如下：

> f(t,y1,y2,y3,d1,d2,d3)=
> { d1=y2,
> d2=-y1,
> d3=-y3
> };

t：对微分方程进行积分的起始点。
y：整数，一维数组，长度为n*5，前n个数存放n个未知函数在起始点处的函数值，返回时，这些初值存放在二维数组z的第0列中。
h：积分步长。
z：整数，二维数组（n,k），返回k个积分点（包括起始点）上的未知函数值。k为积分步数，包括起始点这一步。
eps：积分精度。
该函数返回的运行错误代码的意义如下：
1：指定的表达式不存在；
2：无效的数组指针；
3：不是一维或二维数组；
4：数组维数不正确。
5：表达式参数不符合要求、方程个数<1、积分步数<1或者积分步长<=0；
例子：设一阶微分方程组及初值为：
y0'=y1,y0(0)=0.0
y1'=-y0,y1(0)=1.0
y2'=-y2,y2(0)=1.0
计算当步长h=0.1时，11个积分点（包括起始点）ti=i*h，i=0，1，...，10上的未知函数的近似值y0i，y1i，y2i（i=0，1，...，10）。其中起始点t=0.0，n=3，k=11，h=0.1，eps=0.000001。
程序如下：
f(t,y0,y1,y2,d0,d1,d2)={d0=y1,d1=-y0,d2=-y2}; //函数定义
main(:a,b,h,i,j)=
{
a=new[rtoi(real_s),rtoi(3*5),rtoi(EndType): 0,1,1],
b=new[rtoi(real_s),rtoi(3),rtoi(11)],
h=0.1,
XSLSF::gil2[HFor("f",2),0,a,h,b,1e-6],
i=0,
while{i<=10,
printff["\r\nt={1,r,-14.6}",i*h],j=0,
while{j<=2,
printff{"y({1,i})={2,r,-14.6}",j,XSLSF::getrai(b,j,i)},
j++
},
i++
},
printff["\r\n"],
delete[a],delete[b]
};

[返回页首] XSLSF::mrsn(f,t,y,h,z,eps)：全区间积分的变步长默森方法

f：表达式名称，用于计算微分方程组中各方程右端函数值，由用户自编。该表达式有2*n+1个参数，第一个参数为自变量，随后n个参数为函数值，最后n个参数为右端函数值（即微分方程的值）。n为微分方程组中方程的个数，也是未知函数的个数。形式如下：

> f(t,y1,y2,y3,d1,d2,d3)=
> { d1=y2,
> d2=-y1,
> d3=-y3
> };

t：对微分方程进行积分的起始点。
y：整数，一维数组，长度为n*6，前n个数存放n个未知函数在起始点处的函数值，返回时，这些初值存放在二维数组z的第0列中。
h：积分步长。
z：整数，二维数组（n,k），返回k个积分点（包括起始点）上的未知函数值。k为积分步数，包括起始点这一步。
eps：积分精度。
该函数返回的运行错误代码的意义如下：
1：指定的表达式不存在；
2：无效的数组指针；
3：不是一维或二维数组；
4：数组维数不正确。
5：表达式参数不符合要求、方程个数<1、积分步数<1或者积分步长<=0；
例子：设一阶微分方程组及初值为：
y0'=60*[0.06+t*(t-0.6)]*y1,y0(0)=0.0
y1'=-60*[0.06+t*(t-0.6)]*y0,y1(0)=1.0
计算当步长h=0.1时，11个积分点（包括起始点）ti=i*h，i=0，1，...，10上的未知函数的近似值y0i，y1i，y2i（i=0，1，...，10）。其中起始点t=0.0，n=2，k=11，h=0.1，eps=0.00001。
程序如下：
f(t,y0,y1,d0,d1:q)={q=60*[0.06+t*(t-0.6)],d0=q*y1,d1=-q*y0}; //函数定义
main(:a,b,h,i,j)=
{
a=new[rtoi(real_s),rtoi(2*6),rtoi(EndType): 0,1],
b=new[rtoi(real_s),rtoi(2),rtoi(11)],
h=0.1,
XSLSF::mrsn[HFor("f",2),0,a,h,b,1e-5],
i=0,
while{i<=10,
printff["\r\nt={1,r,-14.6}",i*h],j=0,
while{j<=1,
printff{"y({1,i})={2,r,-14.6}",j,XSLSF::getrai(b,j,i)},
j++
},
i++
},
printff["\r\n"],
delete[a],delete[b]
};

[返回页首] XSLSF::pbs1(f,t,y,h,eps)：积分一步的连分式法

f：表达式名称，用于计算微分方程组中各方程右端函数值，由用户自编。该表达式有2*n+1个参数，第一个参数为自变量，随后n个参数为函数值，最后n个参数为右端函数值（即微分方程的值）。n为微分方程组中方程的个数，也是未知函数的个数。形式如下：

> f(t,y1,y2,y3,d1,d2,d3)=
> { d1=y2,
> d2=-y1,
> d3=-y3
> };

t：对微分方程进行积分的起始点。
y：一维数组，长度为n*15，前n个数存放n个未知函数在起始点处的函数值，返回时，存放t+h处的n个未知函数值。
h：积分步长。
eps：积分精度。
该函数返回的运行错误代码的意义如下：
1：指定的表达式不存在；
2：无效的数组指针；
3：不是一维数组；
4：数组维数不正确。
5：表达式参数不符合要求、方程个数<1、积分步数<1或者积分步长<=0；
例子：设一阶微分方程组及初值为：
y0'=-y1,y0(0)=1.0
y1'=y0,y1(0)=0.0
计算当步长h=0.1时，11个积分点（包括起始点）ti=i*h，i=0，1，...，10上的未知函数的近似值y0i，y1i，y2i（i=0，1，...，10）。其中起始点t=0.0，n=3，h=0.1，eps=0.000001。
程序如下：
f(t,y0,y1,d0,d1)={d0=-y1,d1=y0}; //函数定义
main(:a,t,h,i,j,hf)=
{
a=new[rtoi(real_s),rtoi(2*6),rtoi(EndType): 1,0],
t=0,h=0.1,hf=HFor("f",2),
printff["\r\nt={1,r,-14.6}",t],
i=0,while{i<=1,printff{"y({1,i})={2,r,-14.6}",i,XSLSF::getrai(a,i)},i++},
i=1,
while{i<=10,
XSLSF::pbs1[hf,t,a,h,0.000001],t=t+h,
printff["\r\nt={1,r,-14.6}",t],j=0,
while{j<=1,
printff{"y({1,i})={2,r,-14.6}",j,XSLSF::getrai(a,j)},
j++
},
i++
},
printff["\r\n"],
delete[a]
};

[返回页首] XSLSF::pbs2(f,t,y,h,z,eps)：全区间积分的连分式法

f：表达式名称，用于计算微分方程组中各方程右端函数值，由用户自编。该表达式有2*n+1个参数，第一个参数为自变量，随后n个参数为函数值，最后n个参数为右端函数值（即微分方程的值）。n为微分方程组中方程的个数，也是未知函数的个数。形式如下：

> f(t,y1,y2,y3,d1,d2,d3)=
> { d1=y2,
> d2=-y1,
> d3=-y3
> };

t：对微分方程进行积分的起始点。
y：整数，一维数组，长度为n*15，前n个数存放n个未知函数在起始点处的函数值，返回时，这些初值存放在二维数组z的第0列中。
h：积分步长。
z：整数，二维数组（n,k），返回k个积分点（包括起始点）上的未知函数值。k为积分步数，包括起始点这一步。
eps：积分精度。
该函数返回的运行错误代码的意义如下：
1：指定的表达式不存在；
2：无效的数组指针；
3：不是一维或二维数组；
4：数组维数不正确。
5：表达式参数不符合要求、方程个数<1、积分步数<1或者积分步长<=0；
例子：设一阶微分方程组及初值为：
y0'=-y1,y0(0)=1.0
y1'=y0,y1(0)=0.0
计算当步长h=0.1时，11个积分点（包括起始点）ti=i*h，i=0，1，...，10上的未知函数的近似值y0i，y1i，y2i（i=0，1，...，10）。其中起始点t=0.0，n=2，k=11，h=0.1，eps=0.000001。
程序如下：
f(t,y0,y1,d0,d1)={d0=-y1,d1=y0}; //函数定义
main(:a,b,h,i,j)=
{
a=new[rtoi(real_s),rtoi(2*6),rtoi(EndType): 1,0],
b=new[rtoi(real_s),rtoi(2),rtoi(11)],
h=0.1,
XSLSF::pbs2[HFor("f",2),0,a,h,b,1e-6],
i=0,
while{i<=10,
printff["\r\nt={1,r,-14.6}",i*h],j=0,
while{j<=1,
printff{"y({1,i})={2,r,-14.6}",j,XSLSF::getrai(b,j,i)},
j++
},
i++
},
printff["\r\n"],
delete[a],delete[b]
};

[返回页首] XSLSF::gjfq(f,t,y,h,z,eps)：全区间积分的双边法

f：表达式句柄，必须由二级函数HFor获得该句柄，用于计算微分方程组中各方程右端函数值，由用户自编。该表达式有2*n+1个参数，第一个参数为自变量，随后n个参数为函数值，最后n个参数为右端函数值（即微分方程的值）。n为微分方程组中方程的个数，也是未知函数的个数。形式如下：

> f(t,y1,y2,y3,d1,d2,d3)=
> { d1=y2,
> d2=-y1,
> d3=-y3
> };

t：对微分方程进行积分的起始点。
y：整数，一维数组，长度为n*9，前n个数存放n个未知函数在起始点处的函数值，返回时，这些初值存放在二维数组z的第0列中。
h：积分步长。
z：整数，二维数组（n,k），返回k个积分点（包括起始点）上的未知函数值。k为积分步数，包括起始点这一步。
eps：积分精度。
该函数返回的运行错误代码的意义如下：
1：指定的表达式不存在；
2：无效的数组指针；
3：不是一维或二维数组；
4：数组维数不正确。
5：表达式参数不符合要求、方程个数<1、积分步数<1或者积分步长<=0；
例子：设一阶微分方程组及初值为：
y0'=-y1,y0(0)=1.0
y1'=y0,y1(0)=0.0
计算当步长h=0.1时，11个积分点（包括起始点）ti=i*h，i=0，1，...，10上的未知函数的近似值y0i，y1i，y2i（i=0，1，...，10）。其中起始点t=0.0，n=2，k=11，h=0.1，eps=0.000001。
程序如下：
f(t,y0,y1,d0,d1)={d0=-y1,d1=y0}; //函数定义
main(:a,b,h,i,j)=
{
a=new[rtoi(real_s),rtoi(2*9),rtoi(EndType): 1,0],
b=new[rtoi(real_s),rtoi(2),rtoi(11)],
h=0.1,
XSLSF::gjfq[HFor("f",2),0,a,h,b,1e-5],
i=0,
while{i<=10,
printff["\r\nt={1,r,-14.6}",i*h],j=0,
while{j<=1,
printff{"y({1,i})={2,r,-14.6}",j,XSLSF::getrai(b,j,i)},
j++
},
i++
},
printff["\r\n"],
delete[a],delete[b]
};

[返回页首] XSLSF::adms(f,t,y,h,z,eps)：全区间积分的阿当姆斯预报-校正法

f：表达式名称，用于计算微分方程组中各方程右端函数值，由用户自编。该表达式有2*n+1个参数，第一个参数为自变量，随后n个参数为函数值，最后n个参数为右端函数值（即微分方程的值）。n为微分方程组中方程的个数，也是未知函数的个数。形式如下：

> f(t,y1,y2,y3,d1,d2,d3)=
> { d1=y2,
> d2=-y1,
> d3=-y3
> };

t：对微分方程进行积分的起始点。
y：整数，一维数组，长度为n*9，前n个数存放n个未知函数在起始点处的函数值，返回时，这些初值存放在二维数组z的第0列中。
h：积分步长。
z：整数，二维数组（n,k），返回k个积分点（包括起始点）上的未知函数值。k为积分步数，包括起始点这一步。
eps：积分精度。
该函数返回的运行错误代码的意义如下：
1：指定的表达式不存在；
2：无效的数组指针；
3：不是一维或二维数组；
4：数组维数不正确。
5：表达式参数不符合要求、方程个数<1、积分步数<1或者积分步长<=0；
例子：设一阶微分方程组及初值为：
y0'=y1,y0(0)=0.0
y1'=-y0,y1(0)=1.0
y2'=-y2,y2(0)=1.0
计算当步长h=0.05时，11个积分点（包括起始点）ti=i*h，i=0，1，...，10上的未知函数的近似值y0i，y1i，y2i（i=0，1，...，10）。其中起始点t=0.0，n=3，k=11，h=0.05，eps=0.0001。
程序如下：
f(t,y0,y1,y2,d0,d1,d2)={d0=y1,d1=-y0,d2=-y2}; //函数定义
main(:a,b,h,i,j)=
{
a=new[rtoi(real_s),rtoi(3*9),rtoi(EndType): 0,1,1],
b=new[rtoi(real_s),rtoi(3),rtoi(11)],
h=0.05,
XSLSF::adms[HFor("f",2),0,a,h,b,1e-4],
i=0,
while{i<=10,
printff["\r\nt={1,r,-14.6}",i*h],j=0,
while{j<=2,
printff{"y({1,i})={2,r,-14.6}",j,XSLSF::getrai(b,j,i)},
j++
},
i++
},
printff["\r\n"],
delete[a],delete[b]
};

[返回页首] XSLSF::hamg(f,t,y,h,z,eps)：全区间积分的哈明方法

f：表达式句柄，必须由二级函数HFor获得该句柄，用于计算微分方程组中各方程右端函数值，由用户自编。该表达式有2*n+1个参数，第一个参数为自变量，随后n个参数为函数值，最后n个参数为右端函数值（即微分方程的值）。n为微分方程组中方程的个数，也是未知函数的个数。形式如下：

> f(t,y1,y2,y3,d1,d2,d3)=
> { d1=y2,
> d2=-y1,
> d3=-y3
> };

t：对微分方程进行积分的起始点。
y：整数，一维数组，长度为n*13，前n个数存放n个未知函数在起始点处的函数值，返回时，这些初值存放在二维数组z的第0列中。
h：积分步长。
z：整数，二维数组（n,k），返回k个积分点（包括起始点）上的未知函数值。k为积分步数，包括起始点这一步。
eps：积分精度。
该函数返回的运行错误代码的意义如下：
1：指定的表达式不存在；
2：无效的数组指针；
3：不是一维或二维数组；
4：数组维数不正确。
5：表达式参数不符合要求、方程个数<1、积分步数<1或者积分步长<=0；
例子：设一阶微分方程组及初值为：
y0'=y1,y0(0)=1.0
y1'=-y0,y1(0)=1.0
y2'=y2,y2(0)=1.0
计算当步长h=0.05时，11个积分点（包括起始点）ti=i*h，i=0，1，...，10上的未知函数的近似值y0i，y1i，y2i（i=0，1，...，10）。其中起始点t=0.0，n=3，k=11，h=0.05，eps=0.0001。
程序如下：
f(t,y0,y1,y2,d0,d1,d2)={d0=y1,d1=-y0,d2=y2}; //函数定义
main(:a,b,h,i,j)=
{
a=new[rtoi(real_s),rtoi(3*13),rtoi(EndType): 1,1,1],
b=new[rtoi(real_s),rtoi(3),rtoi(11)],
h=0.05,
XSLSF::hamg[HFor("f",2),0,a,h,b,1e-4],
i=0,
while{i<=10,
printff["\r\nt={1,r,-14.6}",i*h],j=0,
while{j<=2,
printff{"y({1,i})={2,r,-14.6}",j,XSLSF::getrai(b,j,i)},
j++
},
i++
},
printff["\r\n"],
delete[a],delete[b]
};

[返回页首] XSLSF::tnr1(f,t,y,h)：积分一步的特雷纳方法

f：表达式句柄，必须由二级函数HFor获得该句柄，用于计算微分方程组中各方程右端函数值，由用户自编。该表达式有2*n+1个参数，第一个参数为自变量，随后n个参数为函数值，最后n个参数为右端函数值（即微分方程的值）。n为微分方程组中方程的个数，也是未知函数的个数。形式如下：

> f(t,y1,y2,y3,d1,d2,d3)=
> { d1=y2,
> d2=-y1,
> d3=-y3
> };

t：对微分方程进行积分的起始点。
y：整数，一维数组，长度为n*14，前n个数存放n个未知函数在起始点处的函数值，返回时，存放t+h处的n个未知函数值。
h：积分步长。
该函数返回的运行错误代码的意义如下：
1：指定的表达式不存在；
2：无效的数组指针；
3：不是一维或二维数组；
4：数组维数不正确。
5：表达式参数不符合要求、方程个数<1或者积分步长<=0；
例子：设一阶微分方程组及初值为：
y0'==-21*y0+19*y1-20*y2,y0(0)=1.0
y1'=19*y0-21*y1+20*y2,y1(0)=0.0
y2'=40*y0-40*y1-40*y2,y2(0)=-1.0
计算当步长h=0.001时，11个积分点（包括起始点）ti=i*h，i=0，1，...，10上的未知函数的近似值y0i，y1i，y2i（i=0，1，...，10）。其中起始点t=0.0，n=3，h=0.001。
程序如下：
f(t,y0,y1,y2,d0,d1,d2)={d0=-21*y0+19*y1-20*y2,d1=19*y0-21*y1+20*y2,d2=40*y0-40*y1-40*y2}; //函数定义
main(:a,t,h,i,j,hf)=
{
a=new[rtoi(real_s),rtoi(3*14),rtoi(EndType): 1,0,-1],
t=0,h=0.001,hf=HFor("f",2),
printff["\r\nt={1,r,-14.6}",t],
i=0,while{i<=2,printff{"y({1,i})={2,r,-14.6}",i,XSLSF::getrai(a,i)},i++},
i=0,
while{i<=9,
XSLSF::tnr1[hf,t,a,h],t=t+h,
printff["\r\nt={1,r,-14.6}",t],j=0,
while{j<=2,
printff{"y({1,i})={2,r,-14.6}",j,XSLSF::getrai(a,j)},
j++
},
i++
},
printff["\r\n"],
delete[a]
};

[返回页首] XSLSF::tnr2(f,t,y,h,z)：全区间积分的特雷纳方法

f：表达式句柄，必须由二级函数HFor获得该句柄，用于计算微分方程组中各方程右端函数值，由用户自编。该表达式有2*n+1个参数，第一个参数为自变量，随后n个参数为函数值，最后n个参数为右端函数值（即微分方程的值）。n为微分方程组中方程的个数，也是未知函数的个数。形式如下：

> f(t,y1,y2,y3,d1,d2,d3)=
> { d1=y2,
> d2=-y1,
> d3=-y3
> };

t：对微分方程进行积分的起始点。
y：整数，一维数组，长度为n*14，前n个数存放n个未知函数在起始点处的函数值，返回时，这些初值存放在二维数组z的第0列中。
h：积分步长。
z：整数，二维数组（n,k），返回k个积分点（包括起始点）上的未知函数值。k为积分步数，包括起始点这一步。
该函数返回的运行错误代码的意义如下：
1：指定的表达式不存在；
2：无效的数组指针；
3：不是一维或二维数组；
4：数组维数不正确。
5：表达式参数不符合要求、方程个数<1、积分步数<1或者积分步长<=0；
例子：设一阶微分方程组及初值为：
y0'==-21*y0+19*y1-20*y2,y0(0)=1.0
y1'=19*y0-21*y1+20*y2,y1(0)=0.0
y2'=40*y0-40*y1-40*y2,y2(0)=-1.0
计算当步长h=0.001时，11个积分点（包括起始点）ti=i*h，i=0，1，...，101上的未知函数的近似值y0i，y1i，y2i（i=0，1，...，101）。其中起始点t=0.0，n=3，k=11，h=0.001。
程序如下：
f(t,y0,y1,y2,d0,d1,d2)={d0=-21*y0+19*y1-20*y2,d1=19*y0-21*y1+20*y2,d2=40*y0-40*y1-40*y2}; //函数定义
main(:a,b,h,i,j)=
{
a=new[rtoi(real_s),rtoi(3*14),rtoi(EndType): 1,0,-1],
b=new[rtoi(real_s),rtoi(3),rtoi(101)],
h=0.001,
XSLSF::tnr2[HFor("f",2),0,a,h,b],
i=0,
while{i<=100,
printff["\r\nt={1,r,-14.6}",i*h],j=0,
while{j<=2,
printff{"y({1,i})={2,r,-14.6}",j,XSLSF::getrai(b,j,i)},
j++
},
i=i+10
},
printff["\r\n"],
delete[a],delete[b]
};

[返回页首] XSLSF::gear(f,s,a,b,hmin,hmax,h,eps,y,t,z)：积分刚性方程组的吉尔方法

f：表达式句柄，必须由二级函数HFor获得该句柄，用于计算微分方程组中各方程右端函数值，由用户自编。该表达式有2*n+1个参数，第一个参数为自变量，随后n个参数为函数值，最后n个参数为右端函数值（即微分方程的值）。n为微分方程组中方程的个数，也是未知函数的个数。形式如下：

> f(t,y1,y2,y3,d1,d2,d3)=
> { d1=y2,
> d2=-y1,
> d3=-y3
> };

s：表达式句柄，必须由二级函数HFor获得该句柄，计算雅可比矩阵的函数，由用户自编。该表达式有n*n+n+1个参数，第一个参数为自变量，随后n个参数为函数值，最后n*n个参数为雅可比矩阵。形式如下：

> f(t,y1,y2,y3,p11,p12,p13,p21,p22,p23,p31,p32,p33)=
> {
> pij=Əfi/Əyj(i,j=1,2,3)的表达式
> };

a：积分区间的起始点。
b：积分区间的终点，b>a。
hmin：积分过程中允许的最小步长。
hmax：积分过程中允许的最的步长，hmax>hmin>0。
h：积分的拟定步长，在积分过程中将自动放大或缩小（hmin<<h<hmax）。
eps：误差校验常数(eps>0)。
y：整数，一维数组，长度为n，存放n个未知函数在起始点处的函数值，返回时，这些初值存放在二维数组z的第0列中。
t：整数，一维数组，长度为k，返回k个输出点处的自变量值，包括起始点。k为拟定输出的积分点数(k>=2)
z：整数，二维数组（n,k），返回k个积分点（包括起始点）上的未知函数值。
本函数返回值意义如下：
返回值=1：表示全区间积分成功；
返回值=-1：表示步长已经小于最小步长hmin，但精度未达到，积分停止（已算出的前若干点输出有效）；
返回值=-2：表示阶数已大于6，积分停止（已算出的前若干点输出有效）；
返回值=-3：表示对于h>=hmin校正迭代不收敛停止（已算出的前若干点输出有效）；
返回值=-4：表示对所处理的问题，要求的精度太高，积分停止（已算出的前若干点输出有效）；
返回值=0：FORCAL运行错误。
该函数返回的运行错误代码的意义如下：
1：指定的表达式不存在；
2：指定的表达式的参数个数不匹配；
3：无效的数组指针；
4：不是一维或二维数组；
5：数组维数不正确。
6：参数a,b,hmin,hmax,h,eps中的一个或几个不符合要求或者方程个数<1；
7：内存分配失败。
8：矩阵奇异。
例子：设一阶微分方程组及初值为：
y0'==-21*y0+19*y1-20*y2,y0(0)=1.0
y1'=19*y0-21*y1+20*y2,y1(0)=0.0
y2'=40*y0-40*y1-40*y2,y2(0)=-1.0
用吉尔方法求以下四种情况在区间[0，1]中的数值解。其中a=0，b=1，n=3，取k=30。
(1)、h=0.01, hmin=0.0001, hmax=0.1, eps=0.001 ;
(2)、h=0.01, hmin=0.0001, hmax=0.1, eps=0.0001 ;
(3)、h=0.01, hmin=0.00001, hmax=0.1, eps=0.0001 ;
(4)、h=0.01, hmin=0.00001, hmax=0.1, eps=0.00001 ;
程序如下：
!using["XSLSF"];
f(t,y0,y1,y2,d0,d1,d2)= //函数定义
{ d0=-21*y0+19*y1-20*y2,
d1=19*y0-21*y1+20*y2,
d2=40*y0-40*y1-40*y2
};
s(t,y0,y1,y2,p00,p01,p02,p10,p11,p12,p20,p21,p22)= //定义计算雅可比矩阵的函数
{ p00=-21,p01=19,p02=-20,
p10=19,p11=-21,p12=20,
p20=40,p21=-40,p22=-40
};
main(:a,b,hmax,h,y,t,z,hmin,eps,i,j,k,jjs,hf,hs)=
{
y=new[rtoi(real_s),rtoi(3),rtoi(EndType): 1,0,-1],
t=new[rtoi(real_s),rtoi(30)],
z=new[rtoi(real_s),rtoi(3),rtoi(30)],
hmin=new[rtoi(real_s),rtoi(4),rtoi(EndType): 0.0001,0.0001,0.00001,0.00001],
eps=new[rtoi(real_s),rtoi(4),rtoi(EndType): 0.001,0.0001,0.0001,0.00001],
a=0,b=1,h=0.01,hmax=0.1,hf=HFor("f",2),hs=HFor("s",2),k=0,
while{k<=3,
setra[y,0:1,0,-1],
jjs=gear[hf,hs,a,b,getrai(hmin,k),hmax,h,getrai(eps,k),y,t,z],
printff["\r\nh={1,r}\r\nhmmin={2,r}\r\nhmax={3,r}\r\neps={4,r}\r\n\r\njjs={5,r}\r\n\r\n",h,getrai(hmin,k),hmax,getrai(eps,k),jjs],
i=0,
while{i<=29,
printff["t={1,r,-14.6}",getrai(t,i)],j=0,
while{j<=2,
printff{"y({1,i})={2,r,-14.6}",j,getrai(z,j,i)},
j++
},
printff["\r\n"],
i++
},
k++
},
printff["\r\n"],
delete[a],delete[b]
};

[返回页首] XSLSF::dfte(f,a,b,ya,yb,y)：二阶微分方程边值问题的数值解法

[ u(x)y''+v(x)y'+w(x)y=f(x) ]
[ y(a)=ya ]
[ y(b)=yb ]
f：表达式句柄，必须由二级函数HFor获得该句柄，用于定义计算二阶微分方程中的函数u(x)、v(x)、w(x)、f(x)的值，由用户自编。该表达式有5个参数，第一个参数为自变量，随后4个参数返回u(x)、v(x)、w(x)、f(x)的值。形式如下

> f(x,ux,vx,wx,fx)=
> { ux=-1,
> vx=0,
> wx=2/(x*x),
> fx=1/x
> };

a：求解区间的左端点。
b：求解区间的右端点(b>a)。
ya：未知函数在求解区间的左端点的函数值。
yb：未知函数在求解区间的右端点的函数值。
y：整数，一维数组，长度为n*9，前n个数返回n个等距离散点上的未知函数值；n为求解区间[a，b]的等分点数（包括左右端点a、b），n>=2。
该函数返回的运行错误代码的意义如下：
1：指定的表达式不存在；
2：指定的表达式的参数不符合要求；
3：无效的数组指针；
4：不是一维数组；
5：等分点数n<=1或a>=b；
例子：设二阶微分方程边值问题为：
-y''+2/(x*x)y=1/x
y(2)=0,y(3)=0
求解区间为[2，3]，等分数为11（即步长h=0.1）。其中u(x)=-1，v(x)=0，w(x)=2/(x*x)，f(x)=1/x。
程序如下：
f(x,z0,z1,z2,z3)={z0=-1,z1=0,z2=2/(x*x),z3=1/x}; //函数定义
main(:a,i,j)=
{
a=new[rtoi(real_s),rtoi(11*9)],
XSLSF::dfte[HFor("f",2),2,3,0,0,a],
i=0,
while{i<=10,
printff{"\r\ny({1,i})={2,r,-14.6}",i,XSLSF::getrai(a,i)},
i++
},
printff["\r\n"],
delete[a]
};

10 拟合与逼近 [返回页首]

[返回页首] XSLSF::pir1（x,y,a,&dt0,&dt1,&dt2）：最小二乘曲线拟合

x：双精度一维数组，长度为n，存放给定n个数据点的X坐标。
y：双精度一维数组，长度为n，存放给定n个数据点的Y坐标。
a：双精度一维数组，长度为m，返回m-1次多项式的m个系数。要求m≤n，且m≤20，否则本函数自动按m=min{n,20}处理。
dt0：返回拟合多项式与数据点误差的平方和。
dt1：返回拟合多项式与数据点误差的绝对值之和。
dt2：返回拟合多项式与数据点误差的绝对值的最大值。

该函数返回的运行错误代码的意义如下：
1：无效的数组指针；
2：不是一维数组；
3：数组不匹配。

例子：

main(:x,y,a,dt0,dt1,dt2,i)=
{
x=new[rtoi(real_s),rtoi(20)],
y=new[rtoi(real_s),rtoi(20)],
a=new[rtoi(real_s),rtoi(6)],
i=0,
while{i<=19,
XSLSF::setrai(x,i,0.1*i),XSLSF::setrai(y,i,0.1*i-exp(-0.1*i)),
i++
},
XSLSF::pir1[x,y,a,&dt0,&dt1,&dt2],
OutVector[a],
printff["{1,r,14.6}{2,r,14.6}{3,r,14.6}\r\n",dt0,dt1,dt2],
delete[x],delete[y],delete[a]
};

[返回页首] XSLSF::chir（x,y,a）：切比雪夫曲线拟合

x：双精度一维数组，长度为n，存放给定n个数据点的X坐标。
y：双精度一维数组，长度为n，存放给定n个数据点的Y坐标。
a：双精度一维数组，长度为m+1，前m个元素返回m-1次多项式的m个系数，最后一个元素返回拟合多项式的偏差最大值。若最后一个元素为负，说明迭代过程中参考偏差不再增大，其绝对值为当前选择的参考偏差。

该函数返回的运行错误代码的意义如下：
1：无效的数组指针；
2：不是一维数组；
3：数组不匹配。

例子：

main(:x,y,a,i)=
{
x=new[rtoi(real_s),rtoi(101)],
y=new[rtoi(real_s),rtoi(101)],
a=new[rtoi(real_s),rtoi(7)],
i=0,
while{i<=100,
XSLSF::setrai(x,i,-1+0.02*i),XSLSF::setrai(y,i,atan(-1+0.02*i)),
i++
},
XSLSF::chir[x,y,a],
OutVector[a],
delete[x],delete[y],delete[a]
};

[返回页首] XSLSF::remz（f,a,b,p,eps）：最佳一致逼近的米里兹方法

f：一元函数句柄，必须由二级函数HFor获得该句柄。
a：区间左端点值。
b：区间右端点值。
p：双精度一维数组，长度为n+1，前n个元素返回n-1次多项式的n个系数，最后一个元素返回拟合多项式的偏差绝对值。要求n≤20，否则自动取n=20。
eps：精度要求。一般取1e-10～1e-35之间的数。

该函数返回的运行错误代码的意义如下：
1：非法的函数句柄。
2：不是一元函数。
3：无效的数组指针；
4：不是一维数组；
5：数组太小或精度不符合要求。

例子：

f(x)=exp[x]; //函数定义
main(:p)=
{
p=new[rtoi(real_s),rtoi(5)],
XSLSF::remz[HFor("f",2),-1,1,p,1e-10],
OutVector[p],
delete[p]
};

[返回页首] XSLSF::pir2（x,y,z,a,dt0,dt1,dt2）：矩形域的最小二乘曲线拟合

x：双精度一维数组，长度为n，存放给定n个数据点的X坐标。
y：双精度一维数组，长度为m，存放给定m个数据点的Y坐标。
z：双精度二维数组，体积为n×m，存放矩形区域内n×m个网点上的函数值。
a：双精度二维数组，体积为p×q，返回二元拟合多项式的各系数。拟合多项式中x的最高次为p-1，要求p≤n，且p≤20，否则本函数自动按p=min{n,20}处理。拟合多项式中y的最高次为q-1，要求q≤m，且q≤20，否则本函数自动按q=min{m,20}处理。
dt0：返回拟合多项式与数据点误差的平方和。
dt1：返回拟合多项式与数据点误差的绝对值之和。
dt2：返回拟合多项式与数据点误差的绝对值的最大值。

该函数返回的运行错误代码的意义如下：
1：无效的数组指针。
2：不是一维数组。
3：数组不匹配。
4：内存错误。

例子：

main(:x,y,z,a,dt0,dt1,dt2,i,j)=
{
x=new[rtoi(real_s),rtoi(11)],
y=new[rtoi(real_s),rtoi(21)],
z=new[rtoi(real_s),rtoi(11),rtoi(21)],
a=new[rtoi(real_s),rtoi(6),rtoi(5)],
i=0,
while{i<=10,
XSLSF::setrai(x,i,0.2*i),
i++
},
i=0,
while{i<=20,
XSLSF::setrai(y,i,0.1*i),
i++
},
i=0,
while{i<=10,j=0,
while{j<=20,
XSLSF::setrai{z,i,j:exp[XSLSF::getrai(x,i)^2-XSLSF::getrai(y,j)^2]},
j++
},
i++
},
XSLSF::pir2[x,y,z,a,&dt0,&dt1,&dt2],
OutMatrix[a],
printff["{1,r,14.6}{2,r,14.6}{3,r,14.6}\r\n",dt0,dt1,dt2],
delete[x],delete[y],delete[z],delete[a]
};

11 数据处理与回归分析 [返回页首]

[返回页首] XSLSF::rhis(x,x0,h,dt0,dt1,dt2,g,q)：随机样本分析

x：双精度一维数组，长度为n，存放随机变量的n个样本点值。
x0：随机变量的起始值。
z：随机变量等区间长度值。
dt0：返回随机样本的算术平均值。
dt1：返回随机样本的方差。
dt2：返回随机样本的标准差。
g：双精度一维数组，长度为m，返回m个区间的按高斯分布所应有的近似理论样本点数。
q：双精度一维数组，长度为m，返回落在m个区间中的每一个区间上的随机样本实际点数。

该函数返回的运行错误代码的意义如下：
1：无效的数组指针。
2：不是一维数组。
3：数组不匹配。

例子：

main(:x,g,q,dt0,dt1,dt2,i,j)=
{
x=new[rtoi(real_s),rtoi(100),rtoi(EndType),
193.199,195.673,195.757,196.051,196.092,196.596,
196.579,196.763,196.847,197.267,197.392,197.477,
198.189,193.850,198.944,199.070,199.111,199.153,
199.237,199.698,199.572,199.614,199.824,199.908,
200.188,200.160,200.243,200.285,200.453,200.704,
200.746,200.830,200.872,200.914,200.956,200.998,
200.998,201.123,201.208,201.333,201.375,201.543,
201.543,201.584,201.711,201.878,201.919,202.004,
202.004,202.088,202.172,202.172,202.297,202.339,
202.381,202.507,202.591,202.716,202.633,202.884,
203.051,203.052,203.094,203.094,203.177,203.178,
203.219,203.764,203.765,203.848,203.890,203.974,
204.184,204.267,204.352,204.352,204.729,205.106,
205.148,205.231,205.357,205.400,205.483,206.070,
206.112,206.154,206.155,206.615,206.657,206.993,
207.243,207.621,208.124,208.375,208.502,208.628,
208.670,208.711,210.012,211.394],
g=new[rtoi(real_s),rtoi(10)],
q=new[rtoi(real_s),rtoi(10)],
XSLSF::rhis(x,192,2,&dt0,&dt1,&dt2,g,q),
printff["{1,r,14.6}{2,r,14.6}{3,r,14.6}\r\n",dt0,dt1,dt2],
OutVector[g],OutVector[q],
delete[x],delete[g],delete[q]
};

[返回页首] XSLSF::sqt1(x,y,a0,a1,dt0,dt1,dt2,dt3,dt4,dt5)：一元线性回归分析

x：双精度一维数组，长度为n，存放自变量x的n个取值。
y：双精度一维数组，长度为n，存放与自变量x的n个取值对应的随机变量y的观测值。
a0,a1：返回回归系数b和a。
dt0：返回偏差平方和。
dt1：返回平均标准偏差。
dt2：返回回归平方和。
dt3：返回最大偏差。
dt4：返回最小偏差。
dt5：返回偏差平均值。

该函数返回的运行错误代码的意义如下：
1：无效的数组指针。
2：不是一维数组。
3：数组不匹配。

例子：

main(:x,y,a0,a1,dt0,dt1,dt2,dt3,dt4,dt5)=
{
x=new[rtoi(real_s),rtoi(11),rtoi(EndType),0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0],
y=new[rtoi(real_s),rtoi(11),rtoi(EndType),2.75,2.84,2.965,3.01,3.20,3.25,3.38,3.43,3.55,3.66,3.74],
XSLSF::sqt1(x,y,&a0,&a1,&dt0,&dt1,&dt2,&dt3,&dt4,&dt5),
printff["{1,r,14.6}{2,r,14.6}\r\n",a0,a1],
printff["{1,r,14.6}{2,r,14.6}{3,r,14.6}{4,r,14.6}{5,r,14.6}{6,r,14.6}\r\n",dt0,dt1,dt2,dt3,dt4,dt5],
delete[x],delete[y]
};

[返回页首] XSLSF::sqt2(x,y,a,dt0,dt1,dt2,dt3,v)：多元线性回归分析

x：双精度二维数组，体积为m×n，每一列存放m个自变量的一组观测值。
y：双精度一维数组，长度为n，存放随机变量y的n个观测值。
a：双精度一维数组，长度为m+1，返回回归系数a0,a1,a2,... ...,am。
dt0：返回偏差平方和。
dt1：返回平均标准偏差。
dt2：返回复相关系数。
dt3：返回回归平方和。
v：双精度一维数组，长度为m，返回m个自变量的偏相关系数。

该函数返回的运行错误代码的意义如下：
1：无效的数组指针。
2：不是一维数组。
3：数组不匹配。
4：内存错误。

例子：

main(:x,y,a,v,dt0,dt1,dt2,dt3)=
{
x=new[rtoi(real_s),rtoi(3),rtoi(5),rtoi(EndType):
1.1,1.0,1.2,1.1,0.9,
2.0,2.0,1.8,1.9,2.1,
3.2,3.2,3.0,2.9,2.9],
y=new[rtoi(real_s),rtoi(5),rtoi(EndType),10.1,10.2,10.0,10.1,10.0],
a=new[rtoi(real_s),rtoi(4)],
v=new[rtoi(real_s),rtoi(3)],
XSLSF::sqt2(x,y,a,&dt0,&dt1,&dt2,&dt3,v),
printff["{1,r,14.6}{2,r,14.6}{3,r,14.6}{4,r,14.6}\r\n",dt0,dt1,dt2,dt3],
OutVector[a],OutVector[v],
delete[x],delete[y],delete[a],delete[v]
};

[返回页首] XSLSF::sqt3(x,f1,f2,eps,xx,b,v,s,&dt0,&dt1,ye,yr,r)：逐步回归分析

x：双精度二维数组，体积为k×(n+1)，其中前n列存放 自变量因子的k次观测值，最后一列存放应变量y的k次观测值。
f1：置欲选入因子时显著性检验的F－分布值。
f2：置剔除入因子时显著性检验的F－分布值。
eps：置防止系数相关阵退化的判据。
xx：双精度一维数组，长度为n+1，其中前n个分量返回n个自变量因子的算术平均值；最后一个分量返回应变量y的算术平均值。
b：双精度一维数组，长度为n+1，返回回归方程中各因子的回归系数及常数项。
v：双精度一维数组，长度为n+1，其中前n个分量返回各因子的偏回归平方和；最后一个分量返回残差平方和。
s：双精度一维数组，长度为n+1，其中前n个分量返回各因子回归系数的标准偏差；最后一个分量返回估计的标准偏差。
dt0：返回复相关系数。
dt1：返回F－检验。
ye：双精度一维数组，长度为k，返回因变量条件期望值的k个估计值（对应于k个观测值）。
yr：双精度一维数组，长度为k，返回因变量的k个观测值的残差。
r：双精度二维数组，体积为(n+1)×(n+1)，返回最终的规格化的系数相关阵。

该函数返回的运行错误代码的意义如下：
1：无效的数组指针。
2：不是一维数组。
3：数组不匹配。

例子：

!using["XSLSF"];
main(:x,f1,f2,eps,xx,b,v,s,dt0,dt1,ye,yr,r,i,j,k)=
{
x=new[rtoi(real_s),rtoi(13),rtoi(5),rtoi(EndType):
7.0,26.0,6.0,60.0,78.5,
1.0,29.0,15.0,52.0,74.3,
11.0,56.0,8.0,20.0,104.3,
11.0,31.0,8.0,47.0,87.6,
7.0,52.0,6.0,33.0,95.9,
11.0,55.0,9.0,22.0,109.2,
3.0,71.0,17.0,6.0,102.7,
1.0,31.0,22.0,44.0,72.5,
2.0,54.0,18.0,22.0,93.1,
21.0,47.0,4.0,26.0,115.9,
1.0,40.0,23.0,34.0,83.8,
11.0,66.0,9.0,12.0,113.3,
10.0,68.0,8.0,12.0,109.4],
f1=new[rtoi(real_s),rtoi(3),rtoi(EndType):1.46,4.75,9.33],
f2=new[rtoi(real_s),rtoi(3),rtoi(EndType):1.45,4.67,9.07],
xx=new[rtoi(real_s),rtoi(5)],
b=new[rtoi(real_s),rtoi(5)],
v=new[rtoi(real_s),rtoi(5)],
s=new[rtoi(real_s),rtoi(5)],
ye=new[rtoi(real_s),rtoi(13)],
yr=new[rtoi(real_s),rtoi(13)],
r=new[rtoi(real_s),rtoi(5),rtoi(5)],
eps=1.0e-30,
k=0,
while{k<=2,
sqt3(x,f1.getrai[k],f2.getrai[k],eps,xx,b,v,s,&dt0,&dt1,ye,yr,r),
printff("\r\n"),
printff("f1={1,r} f2={2,r}\r\n",f1.getrai[k],f2.getrai[k]),
printff("\r\n"),
printff("original x(i) and y values:\r\n"),
i=0,
while{i<=12,
j=0,
while{j<=3,printff["x({1,i})={2,r,-14.6} ",j,x.getrai(i,j)],j++},
printff["y={1,r}\r\n",x.getrai(i,4)],
i++
},
printff("\r\n"),
printff("mean of x(i) and y:\r\n"),
i=0,while{i<=3,printff["x({1,i})={2,r,-14.6} ",i,xx.getrai(i)],i++},
printff("y={1,r}\r\n",xx.getrai[4]),
printff("\r\n"),
printff("regression coeffi b(i):\r\n"),
i=0,while{i<=4,printff["b({1,i})={2,r,-14.6} ",i,b.getrai[i]],i++},
printff("\r\n\r\n"),
printff("standard partial sum of square of \r\n"),
printff("regression for x(i) and sum of \r\n"),
printff("square of residuals:\r\n"),
i=0,while{i<=3,printff["v({1,i})={2,r,-14.6} ",i,v.getrai[i]],i++},
printff("\r\n"),
printff("q={1,r}\r\n",v.getrai[4]),
printff("\r\n"),
printff("standard deviation of regression \r\n"),
printff("coeffi and regression equation:\r\n"),
i=0,while{i<=3,printff["s({1,i})={2,r,-14.6} ",i,s.getrai[i]],i++},
printff("\r\n"),
printff("s={1,r}\r\n",s.getrai[4]),
printff("\r\n"),
printff("multi-correlation coeffi c is:{1,r}\r\n",dt0),
printff("\r\n"),
printff("the f value={1,r}\r\n",dt1),
printff("\r\n"),
printff("estimated values and residuals:\r\n"),
i=0,while{i<=12,printff("ye({1,i})={2,r,-14.6} yr({3,i})={4,r,-14.6}\r\n",i,ye.getrai[i],i,yr.getrai[i]),i++},
printff("\r\n"),
printff("matrix r:\r\n"),
i=0,while{i<=4,
j=0,while{j<=4,printff("{1,r,-14.6} ",r.getrai[i,j]),j++},
printff("\r\n"),
i++
},
printff("\r\n"),
k++
},
delete[x],delete[f1],delete[f2],delete[xx],delete[b],delete[v],delete[s],delete[ye],delete[yr],delete[r]
};

[返回页首] XSLSF::log1(x,y,t,&a0,&a1,&a2,&a3,&a4,&a5,&a6)：半对数数据相关

x,y：双精度一维数组，长度为n，存放n个数据点(xi,yi)，要求yi>0。
t：指数函数的底，要求t>0。
a0：拟合函数 y=btax 中的b。
a1：拟合函数 y=btax 中的a。
a2：偏差平方和。
a3：平均标准偏差。
a4：最大偏差。
a5：最小偏差。
a6：偏差平均值。

该函数返回的运行错误代码的意义如下：
1：无效的数组指针。
2：不是一维数组。
3：数组不匹配。
4：参数不符合要求。

例子：

main(:x,y,a0,a1,a2,a3,a4,a5,a6)=
{
x=new[rtoi(real_s),rtoi(12),rtoi(EndType):0.96,0.94,0.92,0.90,0.88,0.86,0.84,0.82,0.80,0.78,0.76,0.74],
y=new[rtoi(real_s),rtoi(12),rtoi(EndType):558.0,313.0,174.0,97.0,55.8,31.3,17.4,9.70,5.58,3.13,1.74,1.00],
XSLSF::log1(x,y,10,&a0,&a1,&a2,&a3,&a4,&a5,&a6),
printff["{1,r,14.6}{2,r,14.6}{3,r,14.6}{4,r,14.6}{5,r,14.6}{6,r,14.6}{7,r,14.6}\r\n",a0,a1,a2,a3,a4,a5,a6],
delete[x],delete[y]
};

[返回页首] XSLSF::log2(x,y,&a0,&a1,&a2,&a3,&a4,&a5,&a6)：对数数据相关

x,y：双精度一维数组，长度为n，存放n个数据点(xi,yi)，要求yi>0。
a0：拟合函数 y=bxa 中的b。
a1：拟合函数 y=bxa 中的a。
a2：偏差平方和。
a3：平均标准偏差。
a4：最大偏差。
a5：最小偏差。
a6：偏差平均值。

该函数返回的运行错误代码的意义如下：
1：无效的数组指针。
2：不是一维数组。
3：数组不匹配。
4：参数不符合要求。

例子：

main(:x,y,a0,a1,a2,a3,a4,a5,a6)=
{
x=new[rtoi(real_s),rtoi(10),rtoi(EndType):0.1,1.0,3.0,5.0,8.0,10.0,20.0,50.0,80.0,100.0],
y=new[rtoi(real_s),rtoi(10),rtoi(EndType):0.1,0.9,2.5,4.0,6.3,7.8,14.8,36.0,54.0,67.0],
XSLSF::log2(x,y,&a0,&a1,&a2,&a3,&a4,&a5,&a6),
printff["{1,r,14.6}{2,r,14.6}{3,r,14.6}{4,r,14.6}{5,r,14.6}{6,r,14.6}{7,r,14.6}\r\n",a0,a1,a2,a3,a4,a5,a6],
delete[x],delete[y]
};

12 极值问题 [返回页首]

[返回页首] XSLSF::max1(f,&x0,&x1,eps,k,&js0,&js1)：一维极值连分式法

f：自定义三元函数句柄，必须由二级函数HFor获得该句柄，用于计算目标函数f(x)与导数f'(x)的值，由用户自编。格式如下 ：

> f(x,y,dy)=
> { y=f(x),
> dy=f'(x)
> };

x0：存放极值点初值，返回时存放极值点。
x1：返回极值点处的函数值。
eps：控制精度要求，一般取10-10～10-35之间的数。
k：允许迭代次数最大值。
js0：返回实际迭代次数。若js0=k，可能没有满足精度要求，返回的值仅作参考。
js1：返回标志。若js1<0，返回的极值点为极小值；若js1>0，返回的极值点为极大值。
该函数返回的运行错误代码的意义如下：
1：指定的表达式不存在；
2：不是三元函数；
3：参数不符合要求。
例子：计算目标函数
f(x)=(x-1)(10-x)
的极值点与极值点处的函数值。取初值为1.0，eps=10-10，最大迭代次数为10。
程序如下：
f(x,y,dy)= //函数定义
{ y=(x-1)*(10-x),
dy=-2*x+11
};
main(:x0,x1,eps,k,js0,js1)=
{
x0=1, eps=1e-10, k=10,
XSLSF::max1[HFor("f"),&x0,&x1,eps,k,&js0,&js1],
printff{"\r\n极值点={1,r}, 函数值={2,r}, 实际迭代次数={3,r}, 标志={4,r}\r\n",x0,x1,js0,js1}
};

[返回页首] XSLSF::maxn(f,x,eps,k,&js0,&js1)：n维极值连分式法

f：自定义n+1元函数句柄，必须由二级函数HFor获得该句柄，用于计算目标函数f(x1,x2,...,xn)及各偏导数f'(x1,x2,...,xn)|xi的值，由用户自编。格式如下 ：

> f(x1,x2,...,xn,k)=
> {
> which{
> k==0: {f(x1,x2,...,xn)},
> k==1: {f'(x1,x2,...,xn)|x0},
> k==2: {f'(x1,x2,...,xn)|x1},
> ... ...,
> k==n: {f'(x1,x2,...,xn)|xn}
> }
> };

x： 双精度一维数组，长度为n+1。其中前n个数存放初值，返回时存放极值点的n个坐标，最后一个数返回极值点处的函数值。
eps：控制精度要求。
k：允许迭代次数最大值。
js0：返回实际迭代次数。若js0=k，可能没有满足精度要求，返回的值仅作参考。
js1：返回标志。若js1<0，返回的极值点为极小值；若js1>0，返回的极值点为极大值；若js1=0，返回的为鞍点。
该函数返回的运行错误代码的意义如下：
1：指定的表达式不存在；
2：实数数组不存在；
3：不是一维数组；
4：数组维数不正确；
5：参数不符合要求。
例子：计算目标函数
z=(x0-1)2+(x1+2)2+2
的极值点与极值点处的函数值。取初值为x0=0，x1=0，eps=10-6，最大迭代次数为10。
程序如下：
f(x0,x1,k)= //函数定义
{
which{
k==0: {[x0-1]*[x0-1]+(x1+2)*(x1+2)+2},
k==1: {2*[x0-1]},
k==2: {2*[x1+2]}
}
};
main(:x,eps,k,js0,js1)=
{
x=new[rtoi(real_s),rtoi(3),rtoi(EndType):0,0],
eps=1e-6, k=10,
XSLSF::maxn[HFor("f"),x,eps,k,&js0,&js1],
OutVector[x],
printff{"\r\n实际迭代次数={1,r}, 标志={2,r}\r\n",js0,js1}
};

[返回页首] XSLSF::lplq(a,b,c,x)：不等式约束线性规划问题

a：双精度二维数组，长度为m×(m+n)，其中m为不等式约束条件的个数，n为变量个数。存放不等式约束条件中左端系数矩阵及m阶单位矩阵，其存放格式为：

> |a00 a01 ... a0,n-1 1 0 ... 0|
> |a10 a11 ... a1,n-1 0 1 ... 0|
> | . . . . . .|
> a=| . . . . . .|
> | . . . . . .|
> |am-1,0 am-1,1 ... am-1,n-1 0 0 ... 1|

b：双精度一维数组，长度为m。存放不等式约束条件的右端项b0,b1,...,bm-1。
c：双精度一维数组，长度为m+n。存放目标函数中的系数，其中后m个分量为0，即存放顺序为c0,c1,...,cn-1,0,...,0。
x：双精度一维数组，长度为m+n。其中前n个分量返回目标函数的极小值点的n个坐标（即最优解），第n+1个分量返回目标函数的极小值。其余为本函数的工作单元。
返回值：为0表示目标函数值无界，非0值表示正常返回。

该函数返回的运行错误代码的意义如下：
1：实数数组不存在；
2：不是一维或二维数组；
3：数组维数不正确；
4：内存错误；
5：矩阵奇异。
例子：设不等式约束条件为
x0+2*x1+7*x2≤10
x0+4*x1+13*x2≤18
2*x1+8*x2≤13
x0,x1,x2≥0
求目标函数f=4*x0+9*x1+26*x2的极大值。
化为极小值问题后的目标函数为-f=-4*x0-9*x1-26*x2
本例中，m=3,n=3,m+n=6。且：

> |1 2 7 1 0 0|
> a=|1 4 13 0 1 0|
> |0 2 8 0 0 1|
> b=(10,18,13)T
> c=(-4,-9,-26,0,0,0)T
> b=(x0,x1,x2,x3,x4,x5)T

程序如下：
main(:a,b,c,x)=
{
a=new[rtoi(real_s),rtoi(3),rtoi(6),rtoi(EndType):
1, 2, 7, 1, 0, 0,
1, 4, 13, 0, 1, 0,
0, 2, 8, 0, 0, 1],
b=new[rtoi(real_s),rtoi(3),rtoi(EndType):10,18,13],
c=new[rtoi(real_s),rtoi(6),rtoi(EndType):-4,-9,-26,0,0,0],
x=new[rtoi(real_s),rtoi(6)],
XSLSF::lplq[a,b,c,x],
OutVector[x],
delete[a],delete[b],delete[c],delete[x]
};

[返回页首] XSLSF::jsim(f,d,u,v,x,eps,k,xx,g)：求n维极值的单形调优法

f：自定义n元函数句柄，必须由二级函数HFor获得该句柄，用于计算目标函数f(x1,x2,...,xn)的值，由用户自编。格式如下 ：

> f(x1,x2,...,xn)=
> {
> g(x1,x2,...,xn)
> };

d：初始单形中任意两顶点间的距离。当d=0时，需在数组x中提供一组初值。
u：扩张系数。一般取1.2～2.0。
v：收缩系数。一般取0～1。
x：双精度一维数组，长度为n+1。当d=0时，需在数组x中提供一组初值（前n个数存放初始的优化参数估计值，不能全为0；最后一个数存放调整系数，最好在0～2之间，但不能为1）。其中前n个数返回极小值点的n个坐标，最后一个数返回极小值。
eps：控制精度要求。
k：允许迭代次数最大值。
xx：双精度二维数组，长度为n×(n+1)。返回最后单形的n+1个顶点的坐标：(x0i,x1i,...,xn-1,i),i=1,2,...,n。
g：双精度一维数组，长度为n+1。返回最后单形的n+1个顶点上的目标函数值。
返回值：返回实际迭代次数。若返回值=k，可能没有满足精度要求，返回的值仅作参考。

该函数返回的运行错误代码的意义如下：
1：指定的表达式不存在；
2：实数数组不存在；
3：不是一维或二维数组；
4：数组维数不正确；
5：参数不符合要求；
6：内存错误。
例子：计算目标函数
J=100*(x1-x0*x0)2+(1-x0)2
的极小值点与极小值。取eps=10-30，d=1,u=1.6,v=0.4,最大迭代次数为200。
程序如下：
f(x0,x1)= //函数定义
{
100*(x1-x0*x0)^2+(1-x0)^2
};
main(:d,u,v,x,eps,k,xx,g,i)=
{
x=new[rtoi(real_s),rtoi(3)],
xx=new[rtoi(real_s),rtoi(2),rtoi(3)],
g=new[rtoi(real_s),rtoi(3)],
eps=1e-30, d=1,u=1.6,v=0.4,k=200,
i=XSLSF::jsim[HFor("f"),d,u,v,x,eps,k,xx,g],
printff{"\r\n实际迭代次数={1,r}\r\n",i},
OutVector[x],OutMatrix[xx],OutVector[g],
delete[x],delete[xx],delete[g]
};

[返回页首] XSLSF::cplx(f,s,a,b,alpha,eps,x,xx,k,dx)：求约束条件下n维极值的复形调优法

f：自定义n元函数句柄，必须由二级函数HFor获得该句柄，用于计算目标函数f(x1,x2,...,xn)的值，由用户自编。格式如下 ：

> f(x1,x2,...,xn)=
> {
> g(x1,x2,...,xn)
> };

s：自定义n+3*m元函数句柄，必须由二级函数HFor获得该句柄，用于计算 约束条件中的下限、上限及条件值，由用户自编。格式如下：

> s(x1,x2,...,xn,c1,c2,...,cm,d1,d2,...,dm,w1,w2,...,wm)= //xi为自变量，ci为下限值，di为上限值，wi为条件值
> {
> c1=c1(x1,x2,...,xn),
> c2=c2(x1,x2,...,xn),
> ... ...,
> cm=cm(x1,x2,...,xn),
> d1=d1(x1,x2,...,xn),
> d2=d2(x1,x2,...,xn),
> ... ...,
> dm=dm(x1,x2,...,xn),
> w1=w1(x1,x2,...,xn),
> w2=w2(x1,x2,...,xn),
> ... ...,
> wm=wm(x1,x2,...,xn)
> };

a：双精度一维数组，长度为n。依次存放常量约束条件中的变量xi的下界。
b：双精度一维数组，长度为n。依次存放常量约束条件中的变量xi的上界。
alpha：反射系数，一般取1.3左右。
eps：控制精度要求。
x：双精度一维数组，长度为n+1。其中前n个分量存放初始复形的第一个顶点坐标值（要求满足所有的约束条件），返回时存放极小值点各坐标值。最后一个分量返回极小值。
xx：双精度二维数组，长度为(n+1)×2n。其中前n行返回最后复形的2n个顶点的坐标（一列为一个顶点）：(x0i,x1i,...,xn-1,i),i=1,2,...,2n-1。最后一行返回最后复形的2n个顶点上的目标函数值。
k：允许迭代次数最大值。
dx：微小增量，若缺省该参数，dx=1e-6。
返回值：返回实际迭代次数。若返回值=k，可能没有满足精度要求，返回的值仅作参考。

该函数返回的运行错误代码的意义如下：
1：指定的表达式不存在；
2：实数数组不存在；
3：不是一维或二维数组；
4：数组维数不正确；
5：参数不符合要求；
6：内存错误。
例子：计算目标函数
J=f(x0,x1)=-[9-(x0-3)2]*x13/[27*sqrt(3)]
满足约束条件
x0≥0
x1≥0
0≤x1≤x0/sqrt(3)
0≤x0+sqrt(3)*x1≤6
的极小值点与极小值。取eps=10-30，alpha=1.3,最大迭代次数为200。
初始复形的第一个顶点为(0,0)。
其中常量约束条件中的下界为a0=0,a1=0，上界取b0=10-35，b1=1035；函数约束条件的下限、上限及条件函数为：
c0(x0,x1)=0, c1(x0,x1)=0
d0(x0,x1)=x0/sqrt(3),d1(x0,x1)=6
w0(x0,x1)=x1, w1(x0,x1)=x0+sqrt(3)*x1
程序如下：
f(x0,x1)= //函数定义
{
-[9-(x0-3)^2]*x1^3/[27*sqrt(3)]
};
s(x0,x1,c0,c1,d0,d1,w0,w1)= //函数定义
{
c0=0, c1=0,
d0=x0/sqrt(3),d1=6,
w0=x1, w1=x0+sqrt(3)*x1
};
main(:a,b,alpha,eps,x,xx,k,i)=
{
a=new[rtoi(real_s),rtoi(2),rtoi(EndType):0,0],
b=new[rtoi(real_s),rtoi(2),rtoi(EndType):1e35,1e35],
x=new[rtoi(real_s),rtoi(3),rtoi(EndType):0,0],
xx=new[rtoi(real_s),rtoi(3),rtoi(4)],
eps=1e-30, alpha=1.3,k=200,
i=XSLSF::cplx[HFor("f"),HFor("s"),a,b,alpha,eps,x,xx,k],
printff{"\r\n实际迭代次数={1,r}\r\n",i},
OutMatrix[xx],OutVector[x],
delete[a],delete[b],delete[x],delete[xx]
};

13 数学变换与滤波 [返回页首]

[返回页首] XSLSF::four(f,a,b)：傅立叶级数逼近

f：双精度一维数组，长度为2n+1。存放区间[0,2π]上2n+1个等距点：xi=2π/(2n+1)*(i+0.5),i=0,1,...,2n。
a：双精度一维数组，长度为n+1。返回傅立叶级数中的系数ak(k=0,1,...,n)。
b：双精度一维数组，长度为n+1。返回傅立叶级数中的系数bk(k=0,1,...,n)。其中b0=0。
该函数返回的运行错误代码的意义如下：
1：实数数组不存在；
2：不是一维数组；
3：数组维数不正确。
程序如下：
!using("XSLSF");
main(:f,a,b,i,c,h)=
{
f=new[rtoi(real_s),rtoi(101)],
a=new[rtoi(real_s),rtoi(51)],
b=new[rtoi(real_s),rtoi(51)],
h=6.283185306/101,
i=0,while{i<101,c=(i+0.5)*h,f.[i].setrai(c*c),i++},
four[f,a,b],
i=0,while{i<=50,
printff{"\r\na({1,i,2})={2,r,-14.6}b({1,i,2})={3,r,-14.6}",i,a.getrai(i),b.getrai(i)},
i++
},
printff{"\r\n"},
delete[f],delete[a],delete[b]
};

[返回页首] XSLSF::kfft(pr,pi,fr,fi,l,il)：快速傅立叶变换

pr： 双精度一维数组，长度为n。当l为0时，存放n个采样输入的实部，返回时存放离散傅立叶变换的模；当l非0时，存放傅立叶变换的n个实部，返回时存放逆傅立叶变换的模。n为输入点数，满足n=2k(k>0)。
pi： 双精度一维数组，长度为n。当l为0时，存放n个采样输入的虚部，返回时存放离散傅立叶变换的辐角；当l非0时，存放傅立叶变换的n个虚部，返回时存放逆傅立叶变换的辐角。
fr：双精度一维数组，长度为n。当l为0时，返回傅立叶变换的实部；当l非0时，返回逆傅立叶变换的实部。
fi：双精度一维数组，长度为n。当l为0时，返回傅立叶变换的虚部；当l非0时，返回逆傅立叶变换的虚部。
l：若l为0，表示计算傅立叶变换；若l非0，表示计算逆傅立叶变换。
il：若il为0，表示不计算傅立叶变换或逆变换的模与辐角；若il非0，表示计算傅立叶变换或逆变换的模与辐角。
该函数返回的运行错误代码的意义如下：
1：实数数组不存在；
2：不是一维数组；
3：数组维数不正确；
4：n!=2k(k>0)。
程序如下：
!using("XSLSF");
main(:pr,pi,fr,fi,i,j)=
{
pr=new[rtoi(real_s),rtoi(64)],
pi=new[rtoi(real_s),rtoi(64)],
fr=new[rtoi(real_s),rtoi(64)],
fi=new[rtoi(real_s),rtoi(64)],
i=0,while{i<64,pr.[i].setrai(exp(-0.1*(i+0.5))),pi.[i].setrai(0),i++},
printff{"\r\n"},
i=0,while{i<16,
j=0,while{j<4,
printff{"{1,r,14.6}",pr.getrai(i*4+j)},
j++
},
printff{"\r\n"},
i++
},
printff{"\r\n"},
kfft[pr,pi,fr,fi,0,1],
i=0,while{i<16,
j=0,while{j<4,
printff{"{1,r,14.6}",fr.getrai(i*4+j)},
j++
},
printff{"\r\n"},
i++
},
printff{"\r\n"},
i=0,while{i<16,
j=0,while{j<4,
printff{"{1,r,14.6}",fi.getrai(i*4+j)},
j++
},
printff{"\r\n"},
i++
},
printff{"\r\n"},
i=0,while{i<16,
j=0,while{j<4,
printff{"{1,r,14.6}",pr.getrai(i*4+j)},
j++
},
printff{"\r\n"},
i++
},
printff{"\r\n"},
i=0,while{i<16,
j=0,while{j<4,
printff{"{1,r,14.6}",pi.getrai(i*4+j)},
j++
},
printff{"\r\n"},
i++
},
printff{"\r\n"},
kfft[fr,fi,pr,pi,1,1],
i=0,while{i<16,
j=0,while{j<4,
printff{"{1,r,14.6}",fr.getrai(i*4+j)},
j++
},
printff{"\r\n"},
i++
},
printff{"\r\n"},
delete[pr],delete[pi],delete[fr],delete[fi]
};

[返回页首] XSLSF::kfwt(p,x)：快速沃什变换

p：双精度一维数组，长度为n。存放n个给定输入序列。n为输入点数，满足n=2k(k>0)。
x：双精度一维数组，长度为n。返回输入序列的沃什变换。
该函数返回的运行错误代码的意义如下：
1：实数数组不存在；
2：不是一维数组；
3：数组维数不正确；
4：n!=2k(k>0)。
程序如下：
main(:p,x,i)=
{
p=new[rtoi(real_s),rtoi(8)],
x=new[rtoi(real_s),rtoi(8)],
i=0,while{i<8,p.[i].XSLSF::setrai(i+1),i++},
XSLSF::kfwt[p,x],
OutVector[x],
delete[p],delete[x]
};

[返回页首] XSLSF::kspt(y,yy)：五点三次平滑

y：双精度一维数组，长度为n。存放n个等距观测点上的观测数据。要求n≥5。
yy：双精度一维数组，长度为n。返回n个等距观测点上的平滑结果。
该函数返回的运行错误代码的意义如下：
1：实数数组不存在；
2：不是一维数组；
3：数组维数不正确；
4：n太小。
程序如下：
main(:y,yy)=
{
y=new[rtoi(real_s),rtoi(9),rtoi(EndType):54.0,145.0,227.0,359.0,401.0,342.0,259.0,112.0,65.0],
yy=new[rtoi(real_s),rtoi(9)],
XSLSF::kspt[y,yy],
OutVector[yy],
delete[y],delete[yy]
};

[返回页首] XSLSF::lman(f,q,r,h,y,x,p,g)：离散随机线性系统的卡尔曼滤波

f：双精度二维数组，体积为n×n。系统状态转移矩阵。
q：双精度二维数组，体积为n×n。模型噪声Wk的协方差阵。
r：双精度二维数组，体积为m×m。观测噪声Vk的协方差阵。
h：双精度二维数组，体积为m×n。观测矩阵。
y：双精度二维数组，体积为k×m。观测向量序列。其中y(i,j)表示第i时刻的观测向量的第j个分量。
x：双精度二维数组，体积为k×n。其中x(0,j)存放给定的初值，其余各行返回状态向量估值序列。x(i,j)表示第i时刻的状态向量估值的第j个分量。
p：双精度二维数组，体积为n×n。存放初值P0，返回时存放最后时刻的估值误差协方差阵。
g：双精度二维数组，体积为n×m。返回最后时刻的稳定增益矩阵。
该函数返回的运行错误代码的意义如下：
1：实数数组不存在；
2：不是二维数组；
3：数组维数不正确；
4：内存错误；
5：矩阵奇异。
程序如下：
!using("XSLSF");
keklm5(n,y:i,j,m,s,w,v,r,t)=
{
s=65536.0, w=2053.0, v=13849.0, r=0.0, i=0,
(i<=n-1).while
{ t=0.0, j=0,
(j<=11).while{ r=w*r+v, m=floor(r/s), r=r-m*s, t=t+r/s, j++},
y.[i].[0].setrai[0.5*(t-6.0)],
i++
}
};
main(:f,q,r,h,y,x,p,g,i,j,t,js,s)=
{
f=new[rtoi(real_s),rtoi(3),rtoi(3),rtoi(EndType):1,0.05,0.00125:0,1,0.05:0,0,1],
q=new[rtoi(real_s),rtoi(3),rtoi(3),rtoi(EndType):0.25,0,0:0,0.25,0:0,0,0.25],
r=new[rtoi(real_s),rtoi(1),rtoi(1),rtoi(EndType):0.25],
h=new[rtoi(real_s),rtoi(1),rtoi(3),rtoi(EndType):1,0,0],
y=new[rtoi(real_s),rtoi(200),rtoi(1)],
x=new[rtoi(real_s),rtoi(200),rtoi(3)],
p=new[rtoi(real_s),rtoi(3),rtoi(3),rtoi(EndType):0,0,0:0,0,0:0,0,0],
g=new[rtoi(real_s),rtoi(3),rtoi(1)],
i=0,while{i<200,
j=0,while{j<3,
x.setrai(i,j:0),
j++
},
i++
},
keklm5(200,y),
i=0,while{i<200,
t=0.05*i,
y.[i].[0].setrai[5-2*t+3*t*t+y.[i].[0].getrai()],
i++
},
js=lman(f,q,r,h,y,x,p,g),
(js!=0).if{
printff{"\r\n{1,ns,7}{2,ns,14}{3,ns,14}{4,ns,14}{5,ns,14}{6,ns,14}\r\n","t","s","y","x(0)","x(1)","x(2)"},
i=0,while{i<200,
t=0.05*i, s=5-2*t+3*t*t,
printff{"{1,r,-14.6}{2,r,-14.6}{3,r,-14.6}{4,r,-14.6}{5,r,-14.6}{6,r,-14.6}\r\n",t,s,y.getrai(i,0),x.getrai(i,0),x.getrai(i,1),x.getrai(i,2)},
i=i+5
},
printff{"\r\n"}
},
delete[f],delete[q],delete[r],delete[h],delete[y],delete[x],delete[p],delete[g]
};

[返回页首] XSLSF::kabg(x,t,a,b,c,y)：α－β－γ滤波

x：双精度一维数组，长度为n。存放n个等间隔点上的量测值。
t：采样周期。
a：滤波器结构参数α。
b：滤波器结构参数β。
c：滤波器结构参数γ。
y：双精度一维数组，长度为n。返回n个等间隔点上的滤波估值。
该函数返回的运行错误代码的意义如下：
1：实数数组不存在；
2：不是一维数组；
3：数组维数不正确。
程序如下：
!using("XSLSF");
kfabg5(n,y:i,j,m,s,w,v,r,t)=
{
s=65536.0, w=2053.0, v=13849.0, r=0.0, i=0,
(i<=n-1).while
{ t=0.0, j=0,
(j<=11).while{ r=w*r+v, m=floor(r/s), r=r-m*s, t=t+r/s, j++},
y.[i].setrai[0.5*(t-6.0)],
i++
}
};
main(:f,x,y,z,i,j,a,b,c,dt,t)=
{
x=new[rtoi(real_s),rtoi(250)],
y=new[rtoi(real_s),rtoi(250)],
z=new[rtoi(real_s),rtoi(250)],
a=0.271,b=0.0285,c=0.0005,dt=0.04,
printff{"\r\n"},
kfabg5(250,y),
i=0,while{i<250,
t=dt*(i+1),
z.[i].setrai[3*t*t-2*t+5],
x.[i].setrai[z.getrai(i)+y.getrai(i)],
i++
},
kabg(x,dt,a,b,c,y),
printff{"\r\n{1,ns,7}{2,ns,14}{3,ns,14}{4,ns,14}\r\n","t","x(t)","y(t)","z(t)"},
i=0,while{i<250,
t=dt*(i+1),
printff{"{1,r,-14.6}{2,r,-14.6}{3,r,-14.6}{4,r,-14.6}\r\n",t,x.getrai(i),y.getrai(i),z.getrai(i)},
i=i+5
},
printff{"\r\n"},
delete[x],delete[y],delete[z]
};

版权所有© Forcal程序设计 2002-2010，保留所有权利
E-mail: forcal@sina.com QQ：630715621
最近更新: 2010年10月06日