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;
}
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);
}
/// <summary>
/// Создаёт решатель для метода с указанным логером
/// </summary>
/// <param name="type">Метод</param>
/// <param name="Logger">Логер</param>
/// <param name="Factorizer">Разложение</param>
/// <param name="KrylovSubspaceDimension">Размерность подпространства Крылова</param>
/// <returns></returns>
public ISolver Spawn(String type, ILogger Logger, IFactorization Factorizer = null, int KrylovSubspaceDimension = 4)
{
try
{
MethodsEnum method = (MethodsEnum)Enum.Parse(typeof(MethodsEnum), type);
if (Enum.IsDefined(typeof(MethodsEnum), method))
{
return(Spawn(method, Logger, Factorizer, KrylovSubspaceDimension));
}
else
{
return(null);
}
}
catch (ArgumentException)
{
return(null);
}
}
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);
}
/// <summary>
/// Создаёт решатель для метода с указанным логером
/// </summary>
/// <param name="type">Метод</param>
/// <param name="Logger">Логер</param>
/// <param name="Factorizer">Разложение</param>
/// <param name="KrylovSubspaceDimension">Размерность подпространства Крылова</param>
/// <returns></returns>
public ISolver Spawn(MethodsEnum type, ILogger Logger, IFactorization Factorizer = null, int KrylovSubspaceDimension = 4)
{
IMethod method = null;
switch (type)
{
case MethodsEnum.CGMethod: break;
case MethodsEnum.GaussianSeidelMethod: method = new GaussianSeidelMethod(); break;
case MethodsEnum.JacobiMethod: method = new JacobiMethod(); break;
case MethodsEnum.LOSMethod: break;
case MethodsEnum.BCGStabMethod: break;
case MethodsEnum.GMResMethod: break;
default: return(null);
}
return(new LoggingSolver(method, Logger));
}
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;
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 TurnFactory(IFactorization factorization)
{
_factorization = factorization;
}
bool IMethod.InitMethod(ILinearOperator A, IVector x0, IVector b, bool malloc, IFactorization Factorizer = null)
{
return(method.InitMethod(A, x0, b, malloc, Factorizer));
}
/// <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>
/// <param name="Factorizer">Разложение, по умолчанию отсутствует</param>
/// <returns></returns>
public IVector Solve(ILinearOperator A, IVector x0, IVector b, int maxIter = (int)1E+4, double eps = 1.0E-14, IFactorization Factorizer = null, bool malloc = false)
{
int iter;
double residual;
if (!Method.InitMethod(A, x0, b, malloc, Factorizer))
{
return(null);
}
while (true)
{
try
{
Method.MakeStep(out iter, out residual);
}
catch (Exception e)
{
return(null);
}
Logger.Write(residual);
if (iter >= maxIter || residual <= eps)
{
break;
}
}
return(Method.x);
}
