static void Task_3()
{
#region ешение скалярного уравнения
Console.WriteLine("ScalarEquation: x - sin(x) = 0.25");
ScalarFunk1 func1 = (double X) => (X - Math.Sin(X) - 0.25);
ScalarFunk1 funcDer1 = (double X) => (1 - Math.Cos(X));
double a1 = 0.0;
double b1 = 17.5;
Console.WriteLine("Mode: Difference");
var diff_results1 = MethodNewton_Scalar.DifferenceMethod(a1, b1, func1);
PrintResult(diff_results1);
Console.WriteLine("Mode: Simplified");
var sim_results1 = MethodNewton_Scalar.SimplifiedMethod(a1, b1, func1, funcDer1);
PrintResult(sim_results1);
Console.WriteLine("Mode: Defualt");
var def_results1 = MethodNewton_Scalar.DefualtMethod(a1, b1, func1, funcDer1);
PrintResult(def_results1);
Console.WriteLine("\nScalarEquation: x^3 = e^x - 1");
ScalarFunk1 func2 = (double X) => (Math.Pow(X, 3) - Math.Pow(Math.E, X) + 1);
ScalarFunk1 funcDer2 = (double X) => (3 * Math.Pow(X, 2) - Math.Pow(Math.E, X));
double a2 = -2.0;
double b2 = 2.0;
Console.WriteLine("Mode: Difference");
var diff_results2 = MethodNewton_Scalar.DifferenceMethod(a2, b2, func2);
PrintResult(diff_results2);
Console.WriteLine("Mode: Simplified");
var sim_results2 = MethodNewton_Scalar.SimplifiedMethod(a2, b2, func2, funcDer2);
PrintResult(sim_results2);
Console.WriteLine("Mode: Defualt");
var def_results2 = MethodNewton_Scalar.DefualtMethod(a2, b2, func2, funcDer2);
PrintResult(def_results2);
#endregion
#region ешение СНАУ
Console.WriteLine("\nSNAU________________________________________________");
//Задаём вектор функций системы
var vectorFunks = new ScalarFunk1_N[10];
InitVectorFunks(vectorFunks);
//Задём матрицу Якоби системы
var matrixFunks = new ScalarFunk1_N[10][];
InitMatrixFunks(matrixFunks);
//Задаём стартовое приближение
var vectorStart = new Vector(vectorFunks.Length);
//x5 = -0.5 | -0.2
vectorStart.SetValues(new double[] { 0.5, 0.5, 1.5, -1.0, -0.2, 1.5, 0.5, -0.5, 1.5, -1.5 });
Console.Write("Vector start: ");
vectorStart.Show();
//Кол-во прераций на LUP и СЛАУ
var countMathOper_LUP = (matrixFunks.Length * matrixFunks.Length * (matrixFunks.Length + 1)) / 2;
var countMathOper_SLAU = matrixFunks.Length * (2 * matrixFunks.Length + 5);
//Инструмент для подсчёта времени
var stopWatch = new Stopwatch();
RunnigStopWatch(stopWatch);
//Console.WriteLine($"Time: {stopWatch.ElapsedMilliseconds} milliseconds");
stopWatch.Reset();
//Чистый дефолтный метод Ньютона
Console.WriteLine("\nSingle: #Defualt_method");
var vectorResultDef_pair = MethodNewton_SNAU.Defualt_withSLAU(vectorStart, matrixFunks, vectorFunks, stopWatch);
Console.WriteLine($"Time: {stopWatch.ElapsedTicks} ticks");
Console.WriteLine("Count math.operation: " +
$"{(countMathOper_LUP + countMathOper_SLAU + 10) * vectorResultDef_pair.SecondElement}");
Console.WriteLine($"Count iter: {vectorResultDef_pair.SecondElement}");
Console.Write("Result vector: ");
vectorResultDef_pair.FirstElement.Show();
Console.Write("Check vector: ");
var checkVec_def = new Vector(vectorFunks.Length);
checkVec_def.SetValueByFunks(vectorFunks, vectorResultDef_pair.FirstElement.data);
checkVec_def.Show();
//stopWatch.Reset();
//Чистый модифицированный метод Ньютона
Console.WriteLine("\nSingle: #Modified_Method");
var vectorResultMod_pair = MethodNewton_SNAU.Modified_withSLAU(vectorStart, matrixFunks, vectorFunks, stopWatch);
Console.WriteLine($"Time: {stopWatch.ElapsedTicks} ticks");
Console.WriteLine("Count math.operation: " +
$"{countMathOper_LUP + (countMathOper_SLAU + 10) * vectorResultMod_pair.SecondElement}");
Console.WriteLine($"Count iter: {vectorResultMod_pair.SecondElement}");
Console.Write("Result vector: ");
vectorResultMod_pair.FirstElement.Show();
Console.Write("Check vector: ");
var checkVec_mod = new Vector(vectorFunks.Length);
checkVec_mod.SetValueByFunks(vectorFunks, vectorResultMod_pair.FirstElement.data);
checkVec_mod.Show();
stopWatch.Reset();
//Чистый гибридный метод Ньютона
Console.WriteLine("\nSingle: #Hybrid_Method");
var iterRecount = 4;
Console.WriteLine($"Iter recount: {iterRecount}");
var vectorResultHyb_pair = MethodNewton_SNAU.Hybrid_withSLAU(vectorStart, matrixFunks, vectorFunks, iterRecount, stopWatch);
Console.WriteLine($"Time: {stopWatch.ElapsedTicks} ticks");
Console.WriteLine("Count math.operation: " +
$"{countMathOper_LUP * (1 + (vectorResultDef_pair.SecondElement / iterRecount)) + (countMathOper_SLAU + 1) * vectorResultDef_pair.SecondElement}");
Console.WriteLine($"Count iter: {vectorResultHyb_pair.SecondElement}");
Console.Write("Result vector: ");
vectorResultHyb_pair.FirstElement.Show();
//Thread.Sleep(10000);
stopWatch.Reset();
//Прогон на k итераций деф.методом, а потом добивка мод.методом
var k = 4;
Console.WriteLine("\nMerge: #Def_method->#Mod_Method");
var vectorResultMerge_pair = MethodNewton_SNAU.MergeMethods(vectorStart, matrixFunks, vectorFunks, stopWatch, k);
Console.WriteLine($"Time: {stopWatch.ElapsedTicks} ticks");
Console.WriteLine("Count math.operation: " +
$"{countMathOper_LUP * (1 + k) + (countMathOper_SLAU + 1) * vectorResultDef_pair.SecondElement }");
Console.WriteLine($"Count iter: {vectorResultMerge_pair.SecondElement}");
Console.Write("Result vector: ");
vectorResultMerge_pair.FirstElement.Show();
stopWatch.Reset();
#endregion
}
static public double KF_Gauss(ScalarFunk1 f, double defA, double a, double b, double alpha, int n)
{
//Вычисляем моменты от 0 до 2n - 1
Vector vectorMoments = new Vector(2 * n);
for (int i = 0; i < 2 * n; i++)
{
vectorMoments.data[i] = CountMoment(defA, a, b, alpha, i);
}
//Находим коеффициенты для W(x)
Matrix matrixCoeff = new Matrix(n);
FillMatrixCoeff(matrixCoeff, vectorMoments);
Matrix matrixCoeff_L = new Matrix(n);
Matrix matrixCoeff_U = new Matrix(n);
Matrix matrixCoeff_P = new Matrix(n);
LUP_decomposition.LUP(matrixCoeff, matrixCoeff_L, matrixCoeff_U, matrixCoeff_P);
Vector vectorB_coeff = new Vector(n);
for (int i = 0; i < n; i++)
{
vectorB_coeff.data[i] = -vectorMoments.data[n + i];
}
Vector vectorCoeff = LUP_decomposition.SLAU(matrixCoeff_L, matrixCoeff_U, matrixCoeff_P, vectorB_coeff);
//Находим узлы из W(x)
Vector vectorX = new Vector(n);
ScalarFunk1 funkW = (double X) =>
{
double resultFunc = 0.0;
for (int i = 0; i <= n; i++)
{
resultFunc += (i != n) ? vectorCoeff.data[i] * Math.Pow(X, i) : Math.Pow(X, n);
}
return(resultFunc);
};
ScalarFunk1 funkW_Derivative = (double X) =>
{
double resultFuncDerivative = 0.0;
for (int i = 0; i <= n; i++)
{
resultFuncDerivative += (i != n) ? vectorCoeff.data[i] * Math.Pow(X, i - 1) * i : Math.Pow(X, n - 1) * n;
}
return(resultFuncDerivative);
};
var resultCount = MethodNewton_Scalar.DefualtMethod(a, b, funkW, funkW_Derivative);
vectorX.SetValues(resultCount.FirstElement);
//Решаем СЛАУ и находим Aj
Matrix matrixX = new Matrix(n);
FillMatrixX(matrixX, vectorX);
Matrix matrixX_L = new Matrix(n);
Matrix matrixX_U = new Matrix(n);
Matrix matrixX_P = new Matrix(n);
LUP_decomposition.LUP(matrixX, matrixX_L, matrixX_U, matrixX_P);
Vector vectorB_X = new Vector(n);
for (int i = 0; i < n; i++)
{
vectorB_X.data[i] = vectorMoments.data[i];
}
Vector vectorA = LUP_decomposition.SLAU(matrixX_L, matrixX_U, matrixX_P, vectorB_X);
//Получем ответ по КФ
double result = 0.0;
for (int i = 0; i < n; i++)
{
result += vectorA.data[i] * f(vectorX.data[i]);
}
return(result);
}
