public float ComputeCost(IVector th, float lambda)
{
using (var h0 = _feature.Multiply(th))
using (var h1 = h0.Column(0))
using (var h = h1.Sigmoid())
using (var hLog = h.Log())
using (var t = _target.Clone()) {
var a = _target.DotProduct(hLog);
t.Multiply(-1f);
t.Add(1f);
h.Multiply(-1f);
h.Add(1f);
var b = t.DotProduct(hLog);
var ret = -(a + b) / _feature.RowCount;
if (lambda != 0f)
{
ret += th.AsIndexable().Values.Skip(1).Select(v => v * v).Sum() * lambda / (2 * _feature.RowCount);
}
return(ret);
}
}
public IVector SolveU(IVector x, bool UseDiagonal)
{
//проверка корректности
if (this.Size != x.Size)
{
throw new DifferentSizeException("Ошибка. Различие в размерности вектора и матрицы в функции SolveU");
}
IVector result = (IVector)x.Clone();
int jCol;
var di = this.Diagonal;
if (this.isSymmetric)
{
result = this.SolveLT(x, UseDiagonal);
}
else
{
for (int i = Size - 1; i >= 0; i--)
{
for (int j = ig[i + 1] - 1; j >= ig[i]; j--)
{
jCol = jg[j];
if (jCol > i)
{
result[i] -= al[j] * result[jCol];
}
else
{
break;
}
}
if (UseDiagonal == true && extraDiagVal == 0)
{
result[i] /= di[i];
}
}
}
return(result);
}
public IMatrix Minus(IMatrix rhs)
{
Debug.Assert(RowCount == rhs.RowCount);
Debug.Assert(ColCount == rhs.ColCount);
HashSet <int> allRows = new HashSet <int>();
foreach (int k in mInternal.Keys)
{
allRows.Add(k);
}
foreach (int k in rhs.RowKeys)
{
allRows.Add(k);
}
IMatrix result = this.Zero(mRowKeys, mColKeys, mDefaultVal);
foreach (int k in allRows)
{
IVector row1 = this[k];
IVector row2 = rhs[k];
if (row1 == null)
{
result[k] = row2.Multiply(-1);
}
else if (row2 == null)
{
result[k] = row1.Clone();
}
else
{
result[k] = row1.Minus(row2);
}
}
return(result);
}
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 <T> Minimize(IFunctional <T> objective, IParametricFunction <T> function, IVector <T> initialParameters, IVector <T> minimumParameters = default,
IVector <T> maximumParameters = default)
{
var k = 0;
var la = LinearAlgebra.Value;
IVector <T> xPrev = initialParameters.Clone() as IVector <T>;
IVector <T> xNew = initialParameters.Clone() as IVector <T>;
var normalDist = new Normal(Mean, StdDev);
T prevValue = objective.Value(function.Bind(xPrev));
do
{
var t = 20d / Math.Log(k, Math.E);
for (int i = 0; i < xPrev.Count; i++)
{
var nR = normalDist.Sample() * t;
xNew[i] = la.Sum(xPrev[i], la.Cast(nR));
}
this.ApplyMinimumAndMaximumValues(minimumParameters, maximumParameters, xNew, la);
var newValue = objective.Value(function.Bind(xNew));
var sub = la.Sub(newValue, prevValue);
if (la.Compare(sub, la.GetZeroValue()) == -1) // || la.Exp(la.Mult(la.Cast(-1/t), sub)) >= rand.NextDouble())
{
prevValue = newValue;
xPrev = xNew.Clone() as IVector <T>;
}
} while ((MaxIter.HasValue && MaxIter > k++ && la.Compare(prevValue, Eps) == 1) || (!MaxIter.HasValue && la.Compare(prevValue, Eps) == 1));
return(xPrev);
}
//прямой ход
public IVector LSolve(IVector vector, bool UseDiagonal)
{
if (vector == null)
{
throw new ArgumentNullException(nameof(vector));
}
if (vector.Size != Size)
{
throw new RankException();
}
double sum = 0;
var result = vector.Clone();
for (int i = 0; i < Size; i++)
{
var ia1 = ia[i];
var ia2 = ia[i + 1];
int j;
sum = 0;
for (; ja[ia1] < i && ia1 < ia2; ia1++)
{
j = ja[ia1];
sum += result[j] * a[ia1];
}
if (i == ja[ia1] && ia1 < ia2)
{
result[i] = UseDiagonal ? (result[i] - sum) / a[ia1] : result[i] - sum;
}
else
{
throw new ArgumentNullException(nameof(a));
}
}
return(result);
}
//обратный ход с транспонированием
public IVector USolveTranspose(IVector vector, bool UseDiagonal)
{
if (vector == null)
{
throw new ArgumentNullException(nameof(vector));
}
if (vector.Size != Size)
{
throw new RankException();
}
var result = vector.Clone();
var di = Diagonal;
for (int i = 0; i < Size; i++)
{
var ia1 = ia[i];
var ia2 = ia[i + 1] - 1;
int j;
di[i] = UseDiagonal ? di[i] : 1.0;
for (; ja[ia2] > i && ia1 < ia2; ia2--)
{
j = ja[ia2];
result[j] -= result[i] * a[ia2] / di[i];
}
if (i == ja[ia2] && ia1 <= ia2)
{
result[i] = result[i] / di[i];
}
else
{
throw new ArgumentNullException();
}
}
return(result);
}
//обратный ход
public IVector USolve(IVector vector, bool UseDiagonal)
{
if (vector == null)
{
throw new ArgumentNullException(nameof(vector));
}
if (vector.Size != Size)
{
throw new RankException();
}
var result = vector.Clone();
for (int i = Size - 1; i >= 0; i--)
{
var ia1 = ia[i];
var ia2 = ia[i + 1] - 1;
int j;
double sum = 0;
for (j = ja[ia2]; j > i && ia1 < ia2; ia2--)
{
j = ja[ia2];
sum += result[j] * a[ia2];
}
j = ja[ia2];
if (i == j && ia1 <= ia2)
{
result[i] = UseDiagonal ? (result[i] - sum) / a[ia2] : result[i] - sum;
}
else
{
throw new ArgumentNullException(nameof(a));
}
}
return(result);
}
public bool InitMethod(ILinearOperator A, IVector x0, IVector b, bool malloc = false)
{
if (malloc)
{
x = new Vector(x0.Size);
}
else
{
x = x0;
}
xk = x0.Clone();
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(init);
}
//прямой ход с транспонированным нижним треугольником
public IVector LSolveTranspose(IVector vector, bool UseDiagonal)
{
if (vector == null)
{
throw new ArgumentNullException(nameof(vector));
}
if (vector.Size != Size)
{
throw new RankException();
}
var result = vector.Clone();
var di = Diagonal;
for (int i = Size - 1; i >= 0; i--)
{
var ia1 = ia[i];
var ia2 = ia[i + 1];
int j;
di[i] = UseDiagonal ? di[i] : 1.0;
for (; ja[ia1] < i && ia1 < ia2; ia1++)
{
j = ja[ia1];
result[j] -= result[i] * a[ia1] / di[i];
}
if (i == ja[ia1] && ia1 < ia2)
{
result[i] = result[i] / di[i];
}
else
{
throw new ArgumentNullException("matrix[i,i]=0, i = " + i.ToString(), nameof(a));
}
}
return(result);
}
/// <summary>
/// Решение СЛАУ стабилизированным методом бисопряжённых градиентов
/// </summary>
/// <param name="A">Матрица СЛАУ</param>
/// <param name="b">Ветор правой части</param>
/// <param name="Initial">Ветор начального приближения</param>
/// <param name="Precision">Точность</param>
/// <param name="Maxiter">Максимальное число итераций</param>
/// <returns>Вектор x - решение СЛАУ Ax=b с заданной точностью</returns>
public IVector Solve(IPreconditioner Preconditioner, IMatrix A, IVector b, IVector Initial, double Precision, int Maxiter, ILogger Logger)
{
Logger.WriteNameSolution("BSGstab", Preconditioner.getName());
string start = DateTime.Now.ToString("dd.MM.yyyy hh:mm:ss:fff");
Logger.setMaxIter(Maxiter);
IVector x = (IVector)Initial.Clone();
IVector r = b.Add(A.Mult(Initial), 1, -1);
IVector r0 = r.Clone() as IVector;
double opo = 1, po = 1, alpha = 1, w = 1, beta, normR;
IVector p = new SimpleVector(b.Size);
IVector v = new SimpleVector(b.Size);
IVector y, h, s, z, t;
normR = r.Norm / b.Norm;
for (int iter = 0; iter < Maxiter && normR > Precision; iter++)
{
po = r0.ScalarMult(r);
beta = (po / opo) * (alpha / w);
p = r.Add(p.Add(v, 1, -w), 1, beta);
y = Preconditioner.SolveL(Preconditioner.SolveU(p));
v = A.Mult(y);
alpha = po / r0.ScalarMult(v);
h = x.Add(y, 1, alpha);
s = r.Add(v, 1, -alpha);
z = Preconditioner.SolveL(Preconditioner.SolveU(s));
t = A.Mult(z);
w = (Preconditioner.SolveL(t).ScalarMult(Preconditioner.SolveL(s))) / (Preconditioner.SolveL(t).ScalarMult(Preconditioner.SolveL(t)));
x = h.Add(z, 1, w);
r = s.Add(t, 1, -w);
opo = po;
normR = r.Norm / b.Norm;
Factory.Residual.Add(normR);
Logger.WriteIteration(iter, normR);
if (double.IsNaN(normR) || double.IsInfinity(normR))
{
Logger.WriteSolution(x, Maxiter, b.Add(A.Mult(x), -1, 1).Norm);
Logger.WriteTime(start, DateTime.Now.ToString("dd.MM.yyyy hh:mm:ss:fff"));
throw new CantSolveException();
}
}
Logger.WriteSolution(x, Maxiter, b.Add(A.Mult(x), -1, 1).Norm);
Logger.WriteTime(start, DateTime.Now.ToString("dd.MM.yyyy hh:mm:ss:fff"));
return(x);
/*
* if (b.Norm == 0)
* return x;
*
* double alpha = 0.0, beta = 0.0, gamma = 0.0;
*
* IVector r0 = b.Add(A.Mult(Initial), 1, -1); //r_0 = f - Ax_0
* r0 = Preconditioner.SolveL(r0);//r_0 = L(-1)(f - Ax_0)
*
* IVector z = Preconditioner.SolveU(r0);//z_0 = U(-1)r_0
*
* IVector r = (IVector)r0.Clone(); // r = r_0
*
* IVector p = new SimpleVector(b.Size);
* IVector LAUz = new SimpleVector(b.Size);
* IVector LAUp = new SimpleVector(b.Size);
*
* double r_r = 0.0, r_r_1 = 0.0;
*
* double normR = r.Norm / b.Norm;
*
* for (int iter = 0; iter < Maxiter && normR > Precision; iter++)
* {
* r_r = r0.ScalarMult(r);//(r(k-1),r0)
*
* LAUz = Preconditioner.SolveL(A.Mult(Preconditioner.SolveU(z)));//L(-1)AU(-1)z(k-1)
*
* alpha = r_r / r0.ScalarMult(LAUz);//alpha = (r(k-1),r0)/(r0,L(-1)AU(-1)z(k-1))
*
* p = r.Add(LAUz, 1, -alpha);//pk = r(k-1) - alpha * L(-1)AU(-1)z(k-1)
*
* LAUp = Preconditioner.SolveL(A.Mult(Preconditioner.SolveU(p)));//L(-1)AU(-1)p(k)
*
* gamma = p.ScalarMult(LAUp) / LAUp.ScalarMult(LAUp);//gamma = (p(k),L(-1)AU(-1)p(k))/(L(-1)AU(-1)p(k),L(-1)AU(-1)p(k))
*
* x.Add(z, 1, alpha, true);//xk = x(k-1) + alpha(k) * z(k-1)
* x.Add(p, 1, gamma, true);//xk = x(k-1) + gamma(k) * p(k)
*
* r_r_1 = r0.ScalarMult(r);//(r(k-1),r0)
*
* r = p.Add(LAUp, 1, -gamma);//rk = p(k) - gamma(k) * L(-1)AU(-1)p(k)
*
* r_r = r0.ScalarMult(r);//(r(k), r0)
*
* beta = (r_r * alpha) / (r_r_1 * gamma);//beta = ((r(k),r0) * alpha(k))/((r(k-1),r0) * omega(k-1))
*
* z = r.Add(z, 1, beta);//z(k) = r(k) + beta(k) * z(k-1)
* z.Add(LAUz, 1, -beta * gamma, true);//z(k) = z(k) - beta(k) * gamma(k) * L(-1)AU(-1)z(k-1)
*
* normR = r.Norm / b.Norm;
*
* Factory.Residual.Add(normR);
* Logger.WriteIteration(iter, normR);
* }
* x = Preconditioner.SolveU(x);//x = U(-1)x
* Logger.WriteSolution(x, Maxiter);
* Logger.WriteTime(start, DateTime.Now.ToString("dd.MM.yyyy hh:mm:ss:fff"));
* return x;
*/
}
/// <summary>
/// Решение СЛАУ методом локально-оптимальной схемы
/// </summary>
/// <param name="preconditioner">Матрица СЛАУ</param>
/// <param name="b">Ветор правой части</param>
/// <param name="Initial">Ветор начального приближения</param>
/// <param name="Precision">Точность</param>
/// <param name="Maxiter">Максимальное число итераций</param>
/// <returns>Вектор x - решение СЛАУ Ax=b с заданной точностью</returns>
public IVector Solve(IPreconditioner preconditioner, IMatrix A, IVector b, IVector Initial, double Precision, int Maxiter, ILogger Logger)
{
Logger.WriteNameSolution("LOS", preconditioner.getName());
string start = DateTime.Now.ToString("dd.MM.yyyy hh:mm:ss:fff");
Logger.setMaxIter(Maxiter);
IVector x = Initial.Clone() as IVector;
double alpha = 0.0, beta = 0.0;
IVector r = b.Add(A.Mult(Initial), 1, -1); //r_0 = f - Ax_0
r = preconditioner.SolveL(r); // r_0 = L^-1 * (f - Ax_0)
IVector Ar, z = preconditioner.SolveU(r); // z_0 = U^-1 * r_0
IVector p = preconditioner.SolveL(A.Mult(z)); // p_0 = L^-1 * Az_0
double p_r = 0.0, p_p = 0.0;
double scalRR = r.ScalarMult(r);
double normR = Math.Sqrt(scalRR) / b.Norm;
for (int iter = 0; iter < Maxiter && normR > Precision; iter++)
//for (int iter = 0; iter < Maxiter && ; iter++)
{
p_r = p.ScalarMult(r); //(p_k-1,r_k-1)
p_p = p.ScalarMult(p); //(p_k-1,p_k-1)
alpha = p_r / p_p;
x.Add(z, 1, alpha, true); // x_k = x_k-1 + alfa_k*z_k-1
r.Add(p, 1, -alpha, true); // r_k = r_k-1 - alfa_k*p_k-1
Ar = preconditioner.SolveL(A.Mult(preconditioner.SolveU(r))); //Ar_k = L^-1 * A * U^-1 * r_k
//Ar = A.SolveU(r);
//Ar = AA.Mult(Ar);
//Ar = A.SolveL(Ar);
beta = -(p.ScalarMult(Ar) / p_p);
z = preconditioner.SolveU(r).Add(z, 1, beta); //z_k = U^-1 * r_k + beta_k*z_k-1
p = Ar.Add(p, 1, beta); // p_k = L^-1 * A * U^-1 * r_k + beta_k*p_k-1
if (scalRR == 0)
{
Logger.WriteSolution(x, Maxiter, b.Add(A.Mult(x), -1, 1).Norm);
Logger.WriteTime(start, DateTime.Now.ToString("dd.MM.yyyy hh:mm:ss:fff"));
throw new DivideByZeroException("Division by 0");
}
scalRR = r.ScalarMult(r);
normR = Math.Sqrt(scalRR) / b.Norm;
Factory.Residual.Add(normR);
Logger.WriteIteration(iter, normR);
if (double.IsNaN(normR) || double.IsInfinity(normR))
{
Logger.WriteSolution(x, Maxiter, b.Add(A.Mult(x), -1, 1).Norm);
Logger.WriteTime(start, DateTime.Now.ToString("dd.MM.yyyy hh:mm:ss:fff"));
throw new CantSolveException();
}
}
Logger.WriteSolution(x, Maxiter, b.Add(A.Mult(x), -1, 1).Norm);
Logger.WriteTime(start, DateTime.Now.ToString("dd.MM.yyyy hh:mm:ss:fff"));
return(x);
}
public Centroid(IVector data)
{
_data.Add(data);
Center = data.Clone();
}
public Size(IVector vector)
{
Vector = vector.Clone();
}
IVector IPreconditioner.SolveU(IVector v) => v.Clone() as IVector;
IVector IPreconditioner.MultU(IVector v) => v.Clone() as IVector;
public IVector SolveU(IVector x) => x.Clone() as IVector;
public IVector MultU(IVector x) => x.Clone() as IVector;
public Position(IVector vector)
{
Vector = vector.Clone();
}
/// <summary>
/// Решение СЛАУ методом сопряженных градиентов
/// </summary>
/// <param name="A">Матрица СЛАУ</param>
/// <param name="b">Ветор правой части</param>
/// <param name="Initial">Ветор начального приближения</param>
/// <param name="Precision">Точность</param>
/// <param name="Maxiter">Максимальное число итераций</param>
/// <returns>Вектор x - решение СЛАУ Ax=b с заданной точностью</returns>
public IVector Solve(IPreconditioner Preconditioner, IMatrix A, IVector b, IVector Initial, double Precision, int Maxiter, ILogger Logger)
{
Logger.WriteNameSolution("MSG", Preconditioner.getName());
string start = DateTime.Now.ToString("dd.MM.yyyy hh:mm:ss:fff");
Logger.setMaxIter(Maxiter);
IVector x = Preconditioner.MultU(Initial);
double scalAzZ, scalRR, alpha, beta = 1.0;
IVector r = b.Add(A.Mult(Initial), 1, -1);
r = Preconditioner.T.SolveL(Preconditioner.SolveL(r));
IVector Az, Atz, z = A.Transpose.Mult(r);
z = Preconditioner.T.SolveU(z);
r = z.Clone() as IVector;
scalRR = r.ScalarMult(r);
double normR = Math.Sqrt(scalRR) / b.Norm;
for (int iter = 0; iter < Maxiter && normR > Precision && beta > 0; iter++)
{
Az = Preconditioner.SolveU(z);
Atz = A.Mult(Az);
Atz = Preconditioner.T.SolveL(Preconditioner.SolveL(Atz));
Az = A.Transpose.Mult(Atz);
Az = Preconditioner.T.SolveU(Az);
scalAzZ = Az.ScalarMult(z);
if (scalAzZ == 0)
{
Logger.WriteSolution(x, Maxiter, b.Add(A.Mult(x), -1, 1).Norm);
Logger.WriteTime(start, DateTime.Now.ToString("dd.MM.yyyy hh:mm:ss:fff"));
throw new DivideByZeroException("Division by 0");
}
alpha = scalRR / scalAzZ;
x.Add(z, 1, alpha, true);
r.Add(Az, 1, -alpha, true);
beta = scalRR;
if (scalRR == 0)
{
Logger.WriteSolution(x, Maxiter, b.Add(A.Mult(x), -1, 1).Norm);
Logger.WriteTime(start, DateTime.Now.ToString("dd.MM.yyyy hh:mm:ss:fff"));
throw new DivideByZeroException("Division by 0");
}
scalRR = r.ScalarMult(r);
beta = scalRR / beta;
z = r.Add(z, 1, beta);
normR = Math.Sqrt(scalRR) / b.Norm;
Factory.Residual.Add(normR);
Logger.WriteIteration(iter, normR);
if (double.IsNaN(normR) || double.IsInfinity(normR))
{
x = Preconditioner.SolveU(x);
Logger.WriteSolution(x, Maxiter, b.Add(A.Mult(x), -1, 1).Norm);
Logger.WriteTime(start, DateTime.Now.ToString("dd.MM.yyyy hh:mm:ss:fff"));
throw new CantSolveException();
}
}
;
x = Preconditioner.SolveU(x);
Logger.WriteSolution(x, Maxiter, b.Add(A.Mult(x), -1, 1).Norm);
Logger.WriteTime(start, DateTime.Now.ToString("dd.MM.yyyy hh:mm:ss:fff"));
return(x);
}
