/// <summary>
/// Решает СЛАУ Ax=b
/// </summary>
/// <param name="A">Матрица СЛАУ</param>
/// <param name="x0">Начальное приблежение</param>
/// <param name="b">Вектор правой части</param>
/// <param name="maxIter">Максимальное число итераций</param>
/// <param name="eps">Относительня невязка для выхода</param>
/// <param name="malloc">false - результат сохранится в x0, true - результат сохранится в новый вектор</param>
/// <returns></returns>
public IVector Solve(ILinearOperator A, IVector x0, IVector b, int maxIter = (int)1E+4, double eps = 1.0E-14, bool malloc = false)
{
IVector result;
int iter;
double residual;
if (!Method.InitMethod(A, x0, b, malloc))
{
return(null);
}
while (true)
{
try
{
Method.MakeStep(out iter, out residual);
}
catch (Exception e)
{
return(null);
}
Logger.Write(iter, residual);
if (iter > maxIter || residual <= eps)
{
break;
}
}
return(Method.x);
}
public bool InitMethod(ILinearOperator A, IVector x0, IVector b, bool malloc = false, IFactorization Factorizer = null)
{
if (malloc)
{
x = new Vector(x0.Size);
}
else
{
x = x0;
}
this.x0 = x0;
this.b = b;
this.A = A;
currentIter = 0;
norm_b = b.Norm;
lastResidual = A.Multiply(x0).Add(b, -1).Norm / norm_b;
if (Double.IsNaN(lastResidual) || Double.IsInfinity(lastResidual))
{
return(false);
}
init = true;
x_temp = new Vector(x.Size);
Ux = A.UMult(x0, false, 0);
return(true);
}
public bool InitMethod(ILinearOperator A, IVector x0, IVector b, bool malloc = false, IFactorization Factorizer = null)
{
if (malloc)
{
x = new Vector(x0.Size);
}
else
{
x = x0;
}
this.x0 = x0;
this.b = b;
this.A = A;
this.Factorizer = Factorizer;
norm_b = b.Norm;
currentIter = 0;
if (Factorizer != null)
{
r = Factorizer.LSolve(b.Add(A.Multiply(x0), -1));
z = Factorizer.USolve(r);
p = Factorizer.LSolve(A.Multiply(z));
}
else
{
r = b.Add(A.Multiply(x0), -1);
z = r.Clone();
p = A.Multiply(z);
}
dotproduct_pp = p.DotProduct(p);
init = true;
return(init);
}
public bool InitMethod(ILinearOperator A, IVector x0, IVector b, bool malloc = false, IFactorization Factorizer = null)
{
if (malloc)
{
x = new Vector(x0.Size);
}
else
{
x = x0;
}
this.x0 = x0;
this.b = b;
this.A = A;
currentIter = 0;
norm_b = b.Norm;
lastResidual = A.Multiply(x0).Add(b, -1).Norm / norm_b;
if (Double.IsNaN(lastResidual) || Double.IsInfinity(lastResidual))
{
return(false);
}
init = true;
x_temp = new Vector(x.Size);
inverseDioganal = A.Diagonal.Clone();
for (int i = 0; i < inverseDioganal.Size; i++)
{
inverseDioganal[i] = 1.0 / inverseDioganal[i];
}
L_Ux = A.LMult(x0, false, 0).Add(A.UMult(x0, false, 0));
return(true);
}
public bool InitMethod(ILinearOperator A, IVector x0, IVector b, bool malloc = false)
{
if (malloc)
{
x = new Vector(x0.Size);
}
else
{
x = x0;
}
this.x0 = x0;
this.b = b;
this.A = A;
currentIter = 0;
norm_b = b.Norm;
try
{
lastResidual = A.Multiply(x0).Add(b, -1).Norm / norm_b;
}
catch (DivideByZeroException e)
{
return(false);
}
init = true;
x_temp = new Vector(x.Size);
Ux = A.UMult(x0, false, 0);
return(true);
}
public bool InitMethod(ILinearOperator A, IVector x0, IVector b, bool malloc = false, IFactorization Factorizer = null)
{
if (malloc)
{
x = new Vector(x0.Size);
}
else
{
x = x0;
}
xk = x0.Clone();
this.b = b;
this.A = A;
this.Factorizer = Factorizer;
norm_b = b.Norm;
currentIter = 0;
if (Factorizer != null)
{
r_prev = Factorizer.LSolve(b.Add(A.Multiply(xk), -1));
r0 = r_prev.Clone();
z = Factorizer.USolve(r_prev.Clone());
}
else
{
r_prev = b.Add(A.Multiply(xk), -1);
r0 = r_prev.Clone();
z = r_prev.Clone();
}
dotproduct_rr = r_prev.DotProduct(r_prev);
dotproduct_rprevr0 = dotproduct_rr;
init = true;
return(init);
}
public IVector InitMethod(ILinearOperator A, IVector x0, IVector b, bool malloc = false)
{
if (malloc)
{
x = new Vector(x0.Size);
}
else
{
x = x0;
}
this.x0 = x0;
this.b = b;
this.A = A;
currentIter = 0;
norm_b = b.Norm;
try
{
lastResidual = A.Multiply(x0).Add(b, -1).Norm / norm_b;
}
catch (DivideByZeroException e)
{
return(null);
}
init = true;
x_temp = new Vector(x.Size);
inverseDioganal = A.Diagonal.Clone();
for (int i = 0; i < inverseDioganal.Size; i++)
{
inverseDioganal[i] = 1.0 / inverseDioganal[i];
}
L_Ux = A.LMult(x0, false, 0).Add(A.UMult(x0, false, 0));
return(x);
}
public static double[] Multiply(ILinearOperator <double> A, double[] x)
{
var b = new double[A.RowCount];
A.Multiply(1.0, x, 0.0, b);
return(b);
}
public bool InitMethod(ILinearOperator A, IVector x0, IVector b, bool malloc = false)
{
Counters.Mult.ResetCount();
var result = method.InitMethod(A, x0, b, false);
MultCount[0] = Counters.Mult.count;
Counters.ResetAll();
return(false);// result;
}
public bool InitMethod(ILinearOperator A, IVector x0, IVector b, bool malloc = false)
{
Counters.Reset("Mult");
var result = method.InitMethod(A, x0, b, false);
MultCount[0] = Counters.GetCount("Mult");
Counters.ResetAll();
return(result);
}
//не предобусловленная система
public bool InitMethod(ILinearOperator A, IVector x0, IVector b, bool malloc = false)
{
if (malloc)
{
x = new Vector(x0.Size);
}
else
{
x = x0;
}
this.x0 = x0;
this.b = b;
this.A = A;
norm_b = b.Norm;
currentIter = 0;
r = b.Add(A.Multiply(x0), -1);
z = r.Clone();
dotproduct_rr = r.DotProduct(r);
init = true;
return(init);
}
public bool InitMethod(ILinearOperator A, IVector x0, IVector b, bool malloc = false, IFactorization Factorizer = null)
{
if (malloc)
{
x = new Vector(x0.Size);
}
else
{
x = x0;
}
xk = x0.Clone();
this.x0 = x0;
this.b = b;
this.A = A;
this.Factorizer = Factorizer;
At = A.Transpose;
norm_b = b.Norm;
currentIter = 0;
if (Factorizer != null)
{
r = Factorizer.UTransposeSolve(At.Multiply(Factorizer.LTransposeSolve(Factorizer.LSolve(b.Add(A.Multiply(x0), -1)))));
z = r.Clone();
xk = Factorizer.UMult(x0);
}
else
{
r = At.Multiply(b).Add(At.Multiply(A.Multiply(x0)), -1);
z = r.Clone();
}
dotproduct_rr = r.DotProduct(r);
init = true;
return(init);
}
public IVector InitMethod(ILinearOperator A, IVector x0, IVector b, bool malloc = false)
{
if (malloc)
{
x = new Vector(x0.Size);
}
else
{
x = x0;
}
xk = x0;
this.b = b;
this.A = A;
norm_b = b.Norm;
currentIter = 0;
r_prev = A.LSolve(b.Add(A.Multiply(xk), -1), true);
r0 = r_prev.Clone();
z = A.USolve(r_prev.Clone(), true);
dotproduct_rr = r_prev.DotProduct(r_prev);
dotproduct_rprevr0 = dotproduct_rr;
init = true;
return(x);
}
public ProxyMatrix(ILinearOperator linearOperator)
{
linear = linearOperator;
}
bool IMethod.InitMethod(ILinearOperator A, IVector x0, IVector b, bool malloc, IFactorization Factorizer = null)
{
return(method.InitMethod(A, x0, b, malloc, Factorizer));
}
