/// <summary>
/// 利用广义逆法求解无约束条件下的优化问题
/// <para>f(X0,X1,...,Xn-1)=0,i=0,1,...,m-1,m≥n</para>
/// 当 m = n 时，即为求解非线性方程组
/// </summary>
/// <param name="m">非线性方程组中方程个数</param>
/// <param name="n">非线性方程组中未知数个数</param>
/// <param name="eps1">控制最小二乘解的精度要求</param>
/// <param name="eps2">用于奇异值分解中的控制精度要求</param>
/// <param name="x">存放非线性方程组解的初始近似值X(O),要求各分扯不全为0。返回最小二乘解，当 m = n 时，即为非线性方程组的一组解</param>
/// <param name="ka">ka=max(m,n)+1</param>
/// <param name="f">指向计算非线性方程组中各方程左端函数值的函数</param>
/// <param name="s">指向计算雅可比矩阵的函数名</param>
/// <returns>函数返回一个标志值 。
/// 若返回值小于 0, 则说明在 奇异值分解 中迭代超过了 60 次还未满足精度要求；
/// 若返回值等千 0, 则说明本函数迭代次还未满足精度要求；
/// 若返回值大于 o, 则表示正常返回</returns>
public static int NGIN(int m, int n, double eps1, double eps2, double[] x, int ka, NGIN_Func f, NGIN_Func s)
{
int i, j, k, l = 60, kk, jt;
double[] y = new double[10], b = new double[10], p = new double[m * n], d = new double[m], pp = new double[n * m], dx = new double[n], u = new double[m * m], v = new double[n * n], w = new double[ka];
double alpha = 1.0, z = 0, h2, y1, y2, y3, y0, h1;
double[,] p_t, pp_t, u_t, v_t;
while (l > 0)
{
f(m, n, x, ref d);
s(m, n, x, ref p);
p_t = Utility.C.Convert(p, m, n);
try
{
dx = LinearEquations.GMIV(p_t, d, eps2, out pp_t, out u_t, out v_t);
}
catch
{
return(-1);
}
p = Utility.C.Convert(p_t);
pp = Utility.C.Convert(pp_t);
u = Utility.C.Convert(u_t);
v = Utility.C.Convert(v_t);
j = 0;
jt = 1;
h2 = 0;
while (jt == 1)
{
jt = 0;
if (j <= 2)
{
z = alpha + 0.01 * j;
}
else
{
z = h2;
}
for (i = 0; i <= n - 1; i++)
{
w[i] = x[i] - z * dx[i];
}
f(m, n, w, ref d);
y1 = 0;
for (i = 0; i <= m - 1; i++)
{
y1 = y1 + d[i] * d[i];
}
for (i = 0; i <= n - 1; i++)
{
w[i] = x[i] - (z + 0.00001) * dx[i];
}
f(m, n, w, ref d);
y2 = 0;
for (i = 0; i <= m - 1; i++)
{
y2 = y2 + d[i] * d[i];
}
y0 = (y2 - y1) / 0.00001;
if (Math.Abs(y0) > 1e-10)
{
h1 = y0;
h2 = z;
if (j == 0)
{
y[0] = h1;
b[0] = h2;
}
else
{
y[j] = h1;
kk = 0;
k = 0;
while ((kk == 0) && (k <= j - 1))
{
y3 = h2 - b[k];
if (Math.Abs(y3) == 0)
{
kk = 1;
}
else
{
h2 = (h1 - y[k]) / y3;
}
k++;
}
b[j] = h2;
if (kk != 0)
{
b[j] = 1e35;
}
h2 = 0;
for (k = j - 1; k >= 0; k--)
{
h2 = -y[k] / (b[k + 1] + h2);
}
h2 += b[0];
}
j++;
if (j <= 7)
{
jt = 1;
}
else
{
z = h2;
}
}
}
alpha = z;
y1 = 0;
y2 = 0;
for (i = 0; i <= n - 1; i++)
{
dx[i] = -alpha * dx[i];
x[i] = x[i] + dx[i];
y1 = y1 + Math.Abs(dx[i]);
y2 = y2 + Math.Abs(x[i]);
}
if (y1 < eps1 * y2)
{
return(1);
}
l--;
}
return(0);
}
/// <summary>
/// 根据随机变量及自变量X0,X1,...,Xm-的n组观测值(X0k,X1k,...,Xm-1k,Yk)(k=0,1,...,n-1) 作线性回归分析。
/// </summary>
/// <param name="x">x[m,n]: 每一列存放m 个自变量的观测值</param>
/// <param name="y">y[n]: 存放随机变量y的n个观测值</param>
/// <param name="m">自变量个数</param>
/// <param name="n">观测数据的组数</param>
/// <param name="a">a[m+1]: 返回回归系数a0,a1,...,am-1,am</param>
/// <param name="dt">dt[4]:
/// <para>dt(0)返回 偏差平方和q</para>
/// <para>dt(1)返回 平均标准偏差s</para>
/// <para>dt(2)返回 复相关系数r</para>
/// <para>dt(3)返回 回归平方和u</para>
/// </param>
/// <param name="v">v[m]：返回m个自变量的偏相关系数</param>
public static void SQT2(double[,] x, double[] y, int m, int n, out double[] a, out double[] dt, out double[] v)
{
double[] xx = Utility.C.Convert(x);
double q, e, u, p, yy, s, r, pp;
int mm = m + 1;
double[] b = new double[mm * mm];
b[mm * mm - 1] = n;
a = new double[mm];
v = new double[m];
for (int j = 0; j < m; j++)
{
p = 0;
for (int i = 0; i < n; i++)
{
p += xx[j * n + i];
}
b[m * mm + j] = p;
b[j * mm + m] = p;
}
for (int i = 0; i < m; i++)
{
for (int j = 0; j < m; j++)
{
p = 0;
for (int k = 0; k < n; k++)
{
p += xx[i * n + k] * xx[j * n + k];
}
b[j * mm + i] = p;
b[i * mm + j] = p;
}
}
a[m] = 0;
for (int i = 0; i < n; i++)
{
a[m] += y[i];
}
for (int i = 0; i < m; i++)
{
a[i] = 0;
for (int j = 0; j < n; j++)
{
a[i] += xx[i * n + j] * y[j];
}
}
var temp_b = Utility.C.Convert(b, mm, mm);
var temp_a = Utility.C.Convert(a, mm, 1);
LinearEquations.CHLK(ref temp_b, mm, 1, ref temp_a);
b = Utility.C.Convert(temp_b);
a = Utility.C.Convert(temp_a);
yy = 0;
for (int i = 0; i < n; i++)
{
yy += y[i] / n;
}
q = 0; e = 0; u = 0;
for (int i = 0; i < n; i++)
{
p = a[m];
for (int j = 0; j < m; j++)
{
p += a[j] * xx[j * n + i];
}
q += (y[i] - p) * (y[i] - p);
e += (y[i] - yy) * (y[i] - yy);
u += (yy - p) * (yy - p);
}
s = Math.Sqrt(q / n);
r = Math.Sqrt(1.0 - q / e);
for (int j = 0; j < m; j++)
{
p = 0;
for (int i = 0; i < n; i++)
{
pp = a[m];
for (int k = 0; k < m; k++)
{
if (k != j)
{
pp += a[k] * xx[k * n + i];
}
}
p += (y[i] - pp) * (y[i] - pp);
}
v[j] = Math.Sqrt(1.0 - q / p);
}
dt = new double[4] {
q,
s,
r,
u
};
}
/// <summary>
/// 用拟牛顿法求非线性方程组的一组实数解。
/// </summary>
/// <param name="n">方程组中方程个数，也是未知数个数</param>
/// <param name="eps">控制精度要求</param>
/// <param name="t">控制 h 大小的变量， O<t<l</param>
/// <param name="h">增量初值，在本函数中要被破坏</param>
/// <param name="x">存放初值，返回方程组的一组实数解</param>
/// <param name="k">允许的最大迭代次数</param>
/// <param name="func">指向计算方程组左端函数值的函数
/// <para>参数1：点x</para>
/// <para>参数2：输出y</para>
/// <para>参数3：方程数</para>
/// </param>
/// <returns>函数返回实际迭代次数。若返回值等于0, 则说明迭代了 K 次还未满足精度要求；
/// 若返回值等于-1, 则说明线性代数方程组 AZ = B 奇异；
/// 若返回值等于-2，则说明ΣZj=1</returns>
public static int NETN(int n, double eps, double t, double h, double[] x, int k, Action <double[], double[], int> func)
{
if (n != x.Length)
{
throw new Exception("x长度与指定的n不一致");
}
double[] y = new double[n];
double[] a = new double[n * n];
double[] b = new double[n];
int l = k, i, j;
double am = 1 + eps, z, beta, d;
while (am >= eps)
{
func(x, b, n);
am = 0;
for (i = 0; i <= n - 1; i++)
{
z = Math.Abs(b[i]);
if (z > am)
{
am = z;
}
}
if (am >= eps)
{
l--;
if (l == 0)
{
return(0);//fail
}
for (j = 0; j <= n - 1; j++)
{
z = x[j];
x[j] += h;
func(x, y, n);
for (i = 0; i <= n - 1; i++)
{
a[i * n + j] = y[i];
}
x[j] = z;
}
try
{
LinearEquations.GAUS(Utility.C.Convert(a, n, n), b);
}
catch
{
return(-2);//fail
}
beta = 1;
for (i = 0; i <= n - 1; i++)
{
beta -= b[i];
}
if (beta == 0)
{
return(-2);//fail
}
d = h / beta;
for (i = 0; i <= n - 1; i++)
{
x[i] = x[i] - d * b[i];
}
h = t * h;
}
}
return(k - l);
}