using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Newton
{
class Method
{
// Единичная матрица
public double[,] _Fmatrix = new double[,]
{
{ 1, 0, 0 },
{ 0, 1, 0 },
{ 0, 0, 1 }
};
// Копия исходной матрицы
public double[,] _Smatrix;
public double[,] _Omatrix;
public double[,] Amatrix = new double[,]
{
{ 1, 1, 1 },
{ 2, 1, -4 },
{ 3, -4, 1 }
};
public double[] Bmatrix = new double[]
{
1, 0, 0
};
public double[] Tmatrix = new double[]
{
0.5, 0.5, 0.5
};
public double[,] degree = new double[,]
{
{ 2, 2, 2 },
{ 2, 2, 1 },
{ 2, 1, 2 }
};
public double[] F_X;
public double[,] W_X;
public double[,] n_W_X;
public double determinant = 0;
public double E = 0.005;
public int iteration = 0;
// Приближенное решение
public void F_x()
{
F_X = new double[Amatrix.GetLength(1)];
// Заполнить нулями, при ошибке присвоения
for (int i = 0; i < Amatrix.GetLength(0); i++)
{
for (int j = 0; j < Amatrix.GetLength(1); j++)
{
F_X[i] += Amatrix[i, j] * Math.Pow(Tmatrix[j], degree[i, j]);
}
F_X[i] -= Bmatrix[i];
}
}
// Получение матрицы Якоби
public void W_x()
{
W_X = new double[Amatrix.GetLength(0), Amatrix.GetLength(1)];
for (int i = 0; i < Amatrix.GetLength(0); i++)
{
for (int j = 0; j < Amatrix.GetLength(1); j++)
{
W_X[i, j] = Amatrix[i, j] * degree[i, j];
}
}
}
// Получение матрицы Якоби (x2,x3,...,n)
public void n_W_x()
{
n_W_X = new double[W_X.GetLength(0), W_X.GetLength(1)];
for (int i = 0; i < Amatrix.GetLength(0); i++)
{
for (int j = 0; j < Amatrix.GetLength(1); j++)
{
n_W_X[i, j] = W_X[i, j] * Tmatrix[j];
}
}
}
// Отображение результата
public void showResult()
{
Console.WriteLine("Первоначальная матрица:");
for (int i = 0; i < Amatrix.GetLength(0); i++)
{
for (int j = 0; j < Amatrix.GetLength(1); j++)
{
Console.Write("{0} ", Amatrix[i, j]);
}
Console.WriteLine();
}
Console.WriteLine("\n");
Console.WriteLine("Показатели:");
foreach (double _data in Bmatrix)
{
Console.Write("{0} ", _data);
}
Console.WriteLine();
}
// Функция реверса
public void Swap(int row1, int row2)
{
double s = 0;
for (int i = 0; i < Amatrix.GetLength(0); i++)
{
s = Amatrix[row1, i];
Amatrix[row1, i] = Amatrix[row2, i];
Amatrix[row2, i] = s;
}
}
// Определение детерминанта
public void det()
{
determinant = 1; // Хранит определитель, который вернёт функция
int k = 0;
double E = 1E-9; // Погрешность вычислений
for (int i = 0; i < Amatrix.GetLength(0); i++)
{
k = i;
for (int j = i + 1; j < Amatrix.GetLength(1); j++)
if (Math.Abs(Amatrix[j, i]) > Math.Abs(Amatrix[k, i]))
k = j;
if (Math.Abs(Amatrix[k, i]) < E)
{
determinant = 0;
break;
}
Swap(i, k);
if (i != k) determinant *= -1;
determinant *= Amatrix[i, i];
for (int j = i + 1; j < Amatrix.GetLength(1); j++)
Amatrix[i, j] /= Amatrix[i, i];
for (int j = 0; j < Amatrix.GetLength(0); j++)
if ((j != i) && (Math.Abs(Amatrix[j, i]) > E))
for (k = i + 1; k < Amatrix.GetLength(1); k++)
Amatrix[j, k] -= Amatrix[i, k] * Amatrix[j, i];
}
}
// Получение копии иходной матрицы для дальнейшей работы с ней
public void cloneMatrix()
{
_Omatrix = new double[Amatrix.GetLength(0), Amatrix.GetLength(1)];
for (int i = 0; i < Amatrix.GetLength(0); i++)
{
for (int j = 0; j < Amatrix.GetLength(1); j++)
{
_Omatrix[i, j] = Amatrix[i, j];
}
}
_Smatrix = new double[_Omatrix.GetLength(0), _Omatrix.GetLength(0)];
_Smatrix = (double[,])_Omatrix.Clone();
}
// Преобразование в нормальный вид
public void conversion()
{
double[] Ostr = new double[_Omatrix.GetLength(0)];
double[] Fstr = new double[_Omatrix.GetLength(0)];
try
{
for (int p = _Omatrix.GetLength(0) - 1; p >= 0; p--)
{
for (int i = _Omatrix.GetLength(0) - 1; i >= 0; i--)
{
if (_Omatrix[i, i] == 0)
{
int k;
for (k = _Omatrix.GetLength(0) - 1; k >= 0; k--)
{
if (_Omatrix[k, i] != 0)
{
break;
}
}
for (int j = _Omatrix.GetLength(0) - 1; j >= 0; j--)
{
Ostr[j] = _Omatrix[i, j];
_Omatrix[i, j] = _Omatrix[k, j];
_Omatrix[k, j] = Ostr[j];
Fstr[j] = _Fmatrix[i, j];
_Fmatrix[i, j] = _Fmatrix[k, j];
_Fmatrix[k, j] = Fstr[j];
}
}
}
}
}
catch { }
}
// Получение обратной матрицы
public void zeroing()
{
for (int j = 0; j < _Omatrix.GetLength(0); j++)
{
for (int i = 0; i < _Omatrix.GetLength(0); i++)
{
if (_Omatrix[j, j] != 0)
{
for (int k = 0; k < _Omatrix.GetLength(0); k++)
{
_Fmatrix[j, k] /= _Omatrix[j, j];
}
for (int k = _Omatrix.GetLength(0) - 1; k >= j; k--)
{
_Omatrix[j, k] /= _Omatrix[j, j];
}
}
if (i != j)
{
for (int k = 0; k < _Omatrix.GetLength(0); k++)
{
_Fmatrix[i, k] -= _Omatrix[i, j] * _Fmatrix[j, k];
}
for (int k = _Omatrix.GetLength(0) - 1; k >= j; k--)
{
_Omatrix[i, k] -= _Omatrix[i, j] * _Omatrix[j, k];
}
}
}
}
for (int j = 0; j < _Omatrix.GetLength(0); j++)
{
for (int i = 0; i < _Omatrix.GetLength(0); i++)
{
_Fmatrix[i, j] /= determinant;
}
}
}
// Вывод обратной матрицы
public void showRevers()
{
Console.WriteLine("Обратная матрица:");
for (int i = 0; i < _Fmatrix.GetLength(0); i++)
{
for (int j = 0; j < _Fmatrix.GetLength(1); j++)
{
Console.Write(" {0:f6}\t", _Fmatrix[i, j]);
}
Console.WriteLine();
}
}
}
class Program
{
static void Main(string[] args)
{
Method method = new Method();
method.cloneMatrix();
method.showResult();
method.F_x();
method.W_x();
method.n_W_x();
method.det();
method.conversion();
method.zeroing();
method.showRevers();
Console.WriteLine();
Console.WriteLine("Determinant: {0} \n", method.determinant);
Console.WriteLine("F(x):");
for (int i = 0; i < method.F_X.Length; i++)
{
Console.WriteLine("{0}", method.F_X[i]);
}
for (int i = 0; i < method.Amatrix.GetLength(0); i++)
{
for (int j = 0; j < method.Amatrix.GetLength(1); j++)
{
Console.Write("{0} ", method.n_W_X[i, j]);
}
Console.WriteLine();
}
Console.ReadKey();
}
}
}