static public Pair <double[], int[]> SimplifiedMethod(double a, double b,
ScalarFunk1 funk, ScalarFunk1 funkDerivative, double Eps = 10e-4)
{
double countArea = 10;
var localization = Localization(a, b, funk, countArea);
var leftBorders = localization.FirstElement;
var rightBorders = localization.SecondElement;
var results = new double[leftBorders.Length];
var iters = new int[leftBorders.Length];
for (int i = 0; i < results.Length; i++)
{
int countIter = 0;
double xCurrent;
double xNext = (rightBorders[i] + leftBorders[i]) / 2;
double staticFunkDerivative = funkDerivative(xNext);
do
{
countIter++;
xCurrent = xNext;
xNext = xCurrent - (funk(xCurrent) / staticFunkDerivative);
} while (Math.Abs(xNext - xCurrent) > Eps);
iters[i] = countIter;
results[i] = xNext;
}
return(new Pair <double[], int[]> {
FirstElement = results, SecondElement = iters
});
}
static private Pair <double[], double[]> Localization(double a, double b, ScalarFunk1 funk, double countArea = 10)
{
var leftBorders = new List <double>();
var rightBorders = new List <double>();
double step = (b - a) / countArea;
double tempLeftBorder = a;
double tempRightBorder = a + step;
for (int i = 0; i < countArea - 1; i++)
{
if (funk(tempLeftBorder) * funk(tempRightBorder) < 0)
{
leftBorders.Add(tempLeftBorder);
rightBorders.Add(tempRightBorder);
}
tempLeftBorder = tempRightBorder;
tempRightBorder += step;
}
return(new Pair <double[], double[]>
{
FirstElement = leftBorders.ToArray(),
SecondElement = rightBorders.ToArray()
});
}
//Модифицированный
static public Pair <double[], int[]> DifferenceMethod(double a, double b,
ScalarFunk1 funk, double Eps = 10e-4)
{
double countArea = 10;
var localization = Localization(a, b, funk, countArea);
var leftBorders = localization.FirstElement;
var rightBorders = localization.SecondElement;
var results = new double[leftBorders.Length];
var iters = new int[leftBorders.Length];
//Малая велечина по X
double h = 10e-2;
for (int i = 0; i < results.Length; i++)
{
int countIter = 0;
double xCurrent;
double xNext = (rightBorders[i] + leftBorders[i]) / 2;
do
{
countIter++;
xCurrent = xNext;
xNext = xCurrent - h * (funk(xCurrent) / (funk(xCurrent + h) - funk(xCurrent)));
} while (Math.Abs(xNext - xCurrent) > Eps);
iters[i] = countIter;
results[i] = xNext;
}
return(new Pair <double[], int[]> {
FirstElement = results, SecondElement = iters
});
}
static public double AnalysisMethod(TypeKF typeKF, ScalarFunk1 f, double defA, double a, double b, double alpha, int n, double Eps)
{
double L = 2;
Vector vectorH = new Vector(3);
vectorH.data[1] = b - a;
vectorH.data[2] = (b - a) / L;
int countIter = 1;
double result = 0.0;
double tempR = Double.PositiveInfinity;
do
{
countIter++;
vectorH.data[0] = vectorH.data[1];
vectorH.data[1] = vectorH.data[2];
vectorH.data[2] = vectorH.data[1] / L;
//Эйткен
Vector vectorS = new Vector(3);
vectorS.data[0] = SKF(typeKF, f, defA, a, b, alpha, n, vectorH.data[0]);
vectorS.data[1] = SKF(typeKF, f, defA, a, b, alpha, n, vectorH.data[1]);
vectorS.data[2] = SKF(typeKF, f, defA, a, b, alpha, n, vectorH.data[2]);
double m = -Math.Log((Math.Abs(vectorS.data[2] - vectorS.data[1])) / (Math.Abs(vectorS.data[1] - vectorS.data[0]))) / Math.Log(L);
//Рижардсон
Matrix matrix_Cs_J = new Matrix(3);
for (int i = 0; i < matrix_Cs_J.N; i++)
{
for (int j = 0; j < matrix_Cs_J.N - 1; j++)
{
matrix_Cs_J.data[i][j] = Math.Pow(vectorH.data[i], m + j);
}
matrix_Cs_J.data[i][matrix_Cs_J.N - 1] = -1;
}
Matrix matrix_Cs_J_L = new Matrix(n);
Matrix matrix_Cs_J_U = new Matrix(n);
Matrix matrix_Cs_J_P = new Matrix(n);
LUP_decomposition.LUP(matrix_Cs_J, matrix_Cs_J_L, matrix_Cs_J_U, matrix_Cs_J_P);
Vector vector_Cs_J = LUP_decomposition.SLAU(matrix_Cs_J_L, matrix_Cs_J_U, matrix_Cs_J_P, -1 * vectorS);
result = vector_Cs_J.data[2];
tempR = vectorS.data[2] - result;
} while (Math.Abs(tempR) > Eps);
Console.WriteLine($"Count iter: {Math.Pow(L, countIter)}");
return(result);
}
static public double MiddleRectangleRule(ScalarFunk1 F, double a, double b, int n)
{
double result = 0.0;
double h = (b - a) / n;
for (int i = 1; i <= n; i++)
{
result += F(a + (i - 1 / 2) * h);
}
result *= h;
return(result);
}
static public double SKF(TypeKF typeKF, ScalarFunk1 f, double defA, double a, double b, double alpha, int n, double h)
{
int k = (Int32)((b - a) / h);
double result = 0.0;
for (int i = 0; i < k; i++)
{
switch (typeKF)
{
case TypeKF.NewtonCots:
result += IKF_NewtonCots(f, defA, a + i * h, a + (i + 1) * h, alpha, n);
break;
case TypeKF.Gauss:
result += KF_Gauss(f, defA, a + i * h, a + (i + 1) * h, alpha, n);
break;
}
}
return(result);
}
static public double IKF_NewtonCots(ScalarFunk1 f, double defA, double a, double b, double alpha, int n)
{
//Получаем вектор узлов
Vector vectorX = new Vector(n);
double step = (b - a) / (n - 1);
for (int i = 0; i < n; i++)
{
vectorX.data[i] = a + i * step;
}
//Вычисляем моменты от 0 до n - 1
Vector vectorMoments = new Vector(n);
for (int i = 0; i < n; i++)
{
vectorMoments.data[i] = CountMoment(defA, a, b, alpha, i);
}
//Решаем СЛАУ и находим 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 vectorA = LUP_decomposition.SLAU(matrixX_L, matrixX_U, matrixX_P, vectorMoments);
//Получем ответ по КФ
double result = 0.0;
for (int i = 0; i < n; i++)
{
result += vectorA.data[i] * f(vectorX.data[i]);
}
return(result);
}
static void Main(string[] args)
{
#region Условия
double c2 = 0.05;
double x0 = 0;
double xN = 5;
double A = 3;
double B = 3;
double C = -3;
var Y0 = new double[4] {
1, 1, A, 1
};
VectorFunk f = (double X, double[] Y) =>
{
var resultY = new double[Y.Length];
resultY[0] = 2 * X * Math.Pow(Math.Abs(Y[1]), 1.0 / B) * Math.Sign(Y[1]) * Y[3];
resultY[1] = 2 * B * X * Math.Exp((B / C) * (Y[2] - A)) * Y[3];
resultY[2] = 2 * C * X * Y[3];
resultY[3] = -2 * X * Math.Log(Math.Abs(Y[0]));
return(resultY);
};
var realFuncs = new ScalarFunk1[4];
realFuncs[0] = (double X) => Math.Exp(Math.Sin(X * X));
realFuncs[1] = (double X) => Math.Exp(B * Math.Sin(X * X));
realFuncs[2] = (double X) => C *Math.Sin(X *X) + A;
realFuncs[3] = (double X) => Math.Cos(X * X);
#endregion
VectorFunk1 valueInRealFunc = (double X) => new double[] { realFuncs[0](X), realFuncs[1](X), realFuncs[2](X), realFuncs[3](X) };
//Создание методов
int p_C2 = 2;
int p_MP = 2;
var methodC2_rk = OduCalculation.CreateMethod_byC2_P2S2(c2, f);
var middlePoint_rk = OduCalculation.GetMethod_MiddlePoint_P2S2(f);
#region Запуск на константном шаге
int k_const = 9;
double h_const = 1 / Math.Pow(2, k_const);
var result_methodC2_ConstH = OduCalculation.Result_ConstH(x0, xN, Y0, methodC2_rk, h_const);
var result_methodMP_ConstH = OduCalculation.Result_ConstH(x0, xN, Y0, middlePoint_rk, h_const);
//ExcelTool.GetInstance().Export_points_4Func("MethodC2_ConstH", result_methodC2_ConstH, valueInRealFunc);
//ExcelTool.GetInstance().Export_points_4Func("MethodMP_ConstH", result_methodMP_ConstH, valueInRealFunc);
#endregion
#region Принт точек
//for (int i = 0; i < result_methodC2.Length; i++)
//{
// string tempPoint = $"({x0 + i * h}".Replace(',', '.') + ", " + $"{result_methodC2[i].data[0]})".Replace(',', '.');
// Console.Write($"{tempPoint}, ");
//}
#endregion
#region Все итерации
//Console.Write("\nx: ");
//for (int i = 0; i < 4; i++)
//{
// Console.Write($" y{i}");
//}
//Console.WriteLine("\nResult methodC2:");
//for (int i = 0; i < result_methodC2.Length; i++)
//{
// Console.Write($"\n{i} ({x0 + i * h}): ");
// result_methodC2[i].Show();
//}
#endregion
#region Сравнение с реальным значением
Console.WriteLine("\nDifferent methodC2 with real in last point:");
(new Vector(valueInRealFunc(result_methodC2_ConstH.Last().FirstElement)) - result_methodC2_ConstH.Last().SecondElement).Show();
Console.WriteLine("\nDifferent methodMP with real in last point:");
(new Vector(valueInRealFunc(result_methodMP_ConstH.Last().FirstElement)) - result_methodMP_ConstH.Last().SecondElement).Show();
#endregion
#region Для графика зависимости нормы от длины шага
int k_end = 7;
var Rs_methodC2 = OduCalculation.GetRs(x0, xN, Y0, methodC2_rk, k_end, p_C2);
Console.WriteLine("\nRs methodC2: ");
Rs_methodC2.Show1();
var Rs_MiddlePoint = OduCalculation.GetRs(x0, xN, Y0, middlePoint_rk, k_end, p_MP);
Console.WriteLine("Rs middlePoint: ");
Rs_MiddlePoint.Show1();
#endregion
#region Нахождение h_opt по Рунге
var tol = 10e-5;
var h_opt_c2 = OduCalculation.H_Opt(x0, xN, Y0, methodC2_rk, p_C2, tol);
Console.Write($"\nh_opt_c2: {h_opt_c2}");
var h_opt_mp = OduCalculation.H_Opt(x0, xN, Y0, middlePoint_rk, p_MP, tol);
Console.Write($"\nh_opt_mp: {h_opt_mp}");
var result_methodC2_check = OduCalculation.Result_ConstH(x0, xN, Y0, methodC2_rk, h_opt_c2);
var R_methodC2_check = (new Vector(valueInRealFunc(result_methodC2_check.Last().FirstElement)) - result_methodC2_check.Last().SecondElement).Norm();
Console.WriteLine($"\nCheck R methodC2 with h_opt: {R_methodC2_check}");
var result_methodMP_check = OduCalculation.Result_ConstH(x0, xN, Y0, methodC2_rk, h_opt_c2);
var R_methodMP_check = (new Vector(valueInRealFunc(result_methodMP_check.Last().FirstElement)) - result_methodMP_check.Last().SecondElement).Norm();
Console.WriteLine($"Check R methodMP with h_opt: {R_methodMP_check}");
var realRsOnX_methodC2_h_opt = OduCalculation.RealRsOnX(result_methodC2_check, valueInRealFunc);
var realRsOnX_methodMP_h_opt = OduCalculation.RealRsOnX(result_methodMP_check, valueInRealFunc);
//ExcelTool.GetInstance().Export_RealRsOnX("RsOnX_methodC2_hOpt", realRsOnX_methodC2_h_opt);
//ExcelTool.GetInstance().Export_RealRsOnX("RsOnX_methodMP_hOpt", realRsOnX_methodMP_h_opt);
#endregion
#region Запуск на вариативном шаге
var h_begin = 1 / Math.Pow(2, 6);
//Выбор начального шага
var result0 = new Vector(f(x0, Y0));
var delta = Math.Pow(1 / Math.Max(Math.Abs(x0), Math.Abs(xN)), p_C2 + 1) + Math.Pow(result0.Norm(), p_C2 + 1);
//h_begin = Math.Pow(1e-5 / delta, 1.0 / (p_C2 + 1));
var accH_methodC2 = new List <Pair <double, Pair <double, List <double> > > >();
var result_methodC2_varH = OduCalculation.Result_VariableH(x0, xN, Y0, methodC2_rk, p_C2, h_begin, ref accH_methodC2);
Console.WriteLine("\nDifferent methodC2 with real in last point:");
(new Vector(valueInRealFunc(result_methodC2_varH.Last().FirstElement)) - result_methodC2_varH.Last().SecondElement).Show();
var accH_methodMP = new List <Pair <double, Pair <double, List <double> > > >();
var result_methodMP_varH = OduCalculation.Result_VariableH(x0, xN, Y0, middlePoint_rk, p_C2, h_begin, ref accH_methodMP);
Console.WriteLine("\nDifferent methodMP with real in last point:");
(new Vector(valueInRealFunc(result_methodMP_varH.Last().FirstElement)) - result_methodMP_varH.Last().SecondElement).Show();
//ExcelTool.GetInstance().Export_InfoHs("MethodC2_InfoHs", accH_methodC2);
//ExcelTool.GetInstance().Export_InfoHs("MethodMP_InfoHs", accH_methodMP);
//ExcelTool.GetInstance().Export_points_4Func("MethodC2_VarH", result_methodC2_varH, valueInRealFunc);
//ExcelTool.GetInstance().Export_points_4Func("MethodMP_VarH", result_methodMP_varH, valueInRealFunc);
var realRsOnX_methodC2_h_var = OduCalculation.RealRsOnX(result_methodC2_varH, valueInRealFunc);
var realRsOnX_methodMP_h_var = OduCalculation.RealRsOnX(result_methodMP_varH, valueInRealFunc);
//ExcelTool.GetInstance().Export_RealRsOnX("RsOnX_methodC2_hVar", realRsOnX_methodC2_h_var);
//ExcelTool.GetInstance().Export_RealRsOnX("RsOnX_methodMP_hVar", realRsOnX_methodMP_h_var);
var countCallF_onRtol_methodC2 = OduCalculation.CountCallF_onRtol(x0, xN, Y0, methodC2_rk, p_C2, 2);
var countCallF_onRtol_methodMP = OduCalculation.CountCallF_onRtol(x0, xN, Y0, middlePoint_rk, p_C2, 2);
//ExcelTool.GetInstance().Export_CountCallF("CountCallF_methodC2", countCallF_onRtol_methodC2);
//ExcelTool.GetInstance().Export_CountCallF("CountCallF_methodMP", countCallF_onRtol_methodMP);
#endregion
}
static void Task_4()
{
//Вариант 13
double alpha = 0.2;
double a = 1.5;
double b = 2.3;
double defA = a;
ScalarFunk1 f = (double X) => 2 * Math.Cos(3.5 * X) * Math.Exp(5 * X / 3) + 3 * Math.Sin(1.5 * X) * Math.Exp(-4 * X) + 3;
ScalarFunk1 p = (double X) => 1 / Math.Pow(X - a, alpha);
ScalarFunk1 F = (double X) => f(X) * p(X);
int countNode_MRR = 1000;
double result_MRR = IntegralCalculation.MiddleRectangleRule(F, a, b, countNode_MRR);
Console.WriteLine($"Result by MiddleRectangleRule (CountNode: {countNode_MRR}): {result_MRR}");
int countNode_IKF_NC = 3;
double result_IKF_NC = IntegralCalculation.IKF_NewtonCots(f, defA, a, b, alpha, countNode_IKF_NC);
Console.WriteLine($"\n\nResult by IKF_NewtonCots (CountNode: {countNode_IKF_NC}): {result_IKF_NC}");
int countNode_SKF_NC = 3;
int countPart_SKF_NC = 3;
double h_SKF_NC = (b - a) / countPart_SKF_NC;
double result_SKF_NC = IntegralCalculation.SKF(IntegralCalculation.TypeKF.NewtonCots, f, defA, a, b, alpha, countNode_SKF_NC, h_SKF_NC);
Console.WriteLine($"Result by SKF IKF_NewtonCots (CountNode: {countNode_SKF_NC}; StepH: {h_SKF_NC};): {result_SKF_NC}");
Console.WriteLine($"\nAnalysisMethod_NewtonCots");
int countNode_analys_NC = 3;
double Eps_analys_NC = 10e-6;;
double result_analys_NC = IntegralCalculation.AnalysisMethod(IntegralCalculation.TypeKF.NewtonCots, f, defA, a, b, alpha, countNode_analys_NC, Eps_analys_NC);
Console.WriteLine($"Result : {result_analys_NC}");
Console.WriteLine($"\nAnalysisMethod_Opt_NewtonCots");
int countNode_analys_Opt_NC = 3;
double Eps_analys_Opt_NC = 10e-6;;
double result_analys_Opt_NC = IntegralCalculation.AnalysisMethod_Opt(IntegralCalculation.TypeKF.NewtonCots, f, defA, a, b, alpha, countNode_analys_Opt_NC, Eps_analys_Opt_NC);
Console.WriteLine($"Result : {result_analys_Opt_NC}");
Console.WriteLine("___________________________________________________________________________________________");
int countNode_KF_G = 3;
double result_KF_G = IntegralCalculation.KF_Gauss(f, defA, a, b, alpha, countNode_KF_G);
Console.WriteLine($"\n\nResult by KF_Gauss (CountNode: {countNode_KF_G}): {result_KF_G}");
int countNode_SKF_G = 3;
int countPart_SKF_G = 3;
double h_SKF_G = (b - a) / countPart_SKF_G;
double result_SKF_G = IntegralCalculation.SKF(IntegralCalculation.TypeKF.Gauss, f, defA, a, b, alpha, countNode_SKF_G, h_SKF_G);
Console.WriteLine($"Result by SKF KF_Gauss (CountNode: {countNode_SKF_G}; StepH: {h_SKF_G};): {result_SKF_G}");
Console.WriteLine($"\nAnalysisMethod_Gauss");
int countNode_analys_G = 3;
double Eps_analys_G = 10e-6;;
double result_analys_G = IntegralCalculation.AnalysisMethod(IntegralCalculation.TypeKF.Gauss, f, defA, a, b, alpha, countNode_analys_G, Eps_analys_G);
Console.WriteLine($"Result : {result_analys_G}");
Console.WriteLine($"\nAnalysisMethod_Opt_Gauss");
int countNode_analys_Opt_G = 3;
double Eps_analys_Opt_G = 10e-6;;
double result_analys_Opt_G = IntegralCalculation.AnalysisMethod_Opt(IntegralCalculation.TypeKF.Gauss, f, defA, a, b, alpha, countNode_analys_Opt_G, Eps_analys_Opt_G);
Console.WriteLine($"Result : {result_analys_Opt_G}");
}
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);
}
static public double AnalysisMethod_Opt(TypeKF typeKF, ScalarFunk1 f, double defA, double a, double b, double alpha, int n, double Eps)
{
double L = 2;
Vector vectorH = new Vector(3);
vectorH.data[0] = b - a;
vectorH.data[1] = vectorH.data[0] / L;
vectorH.data[2] = vectorH.data[1] / L;
//Эйткен
Vector vectorS = new Vector(3);
vectorS.data[0] = SKF(typeKF, f, defA, a, b, alpha, n, vectorH.data[0]);
vectorS.data[1] = SKF(typeKF, f, defA, a, b, alpha, n, vectorH.data[1]);
vectorS.data[2] = SKF(typeKF, f, defA, a, b, alpha, n, vectorH.data[2]);
double m = -Math.Log((vectorS.data[2] - vectorS.data[1]) / (vectorS.data[1] - vectorS.data[0])) / Math.Log(L);
double R = (vectorS.data[2] - vectorS.data[1]) / (Math.Pow(L, m) - 1);
double h_opt = vectorH.data[2] * Math.Pow(Eps / Math.Abs(R), 1.0 / m);
//Чтобы укладывался в отрезок [a, b]
int k = (Int32)Math.Ceiling((b - a) / h_opt);
Console.WriteLine($"Count opt: {k}");
//double logK = Math.Log(k) / Math.Log(L);
//logK = Math.Ceiling(logK);
//k = (int)Math.Pow(L, logK);
vectorH.data[1] = ((b - a) / k) * L * L;
vectorH.data[2] = ((b - a) / k) * L;
if (vectorH.data[1] > (b - a) || vectorH.data[2] > (b - a))
{
Console.WriteLine($"Count iter: {Math.Pow(L, 3)}");
return(vectorS.data[2]);
}
else
{
int countIter = (int)k;
double result = 0.0;
double tempR = Double.PositiveInfinity;
do
{
countIter *= (int)L;
vectorH.data[0] = vectorH.data[1];
vectorH.data[1] = vectorH.data[2];
vectorH.data[2] = vectorH.data[1] / L;
//Эйткен
vectorS.data[0] = SKF(typeKF, f, defA, a, b, alpha, n, vectorH.data[0]);
vectorS.data[1] = SKF(typeKF, f, defA, a, b, alpha, n, vectorH.data[1]);
vectorS.data[2] = SKF(typeKF, f, defA, a, b, alpha, n, vectorH.data[2]);
m = -Math.Log((Math.Abs(vectorS.data[2] - vectorS.data[1])) / (Math.Abs(vectorS.data[1] - vectorS.data[0]))) / Math.Log(L);
//Ричардсон
Matrix matrix_Cs_J = new Matrix(3);
for (int i = 0; i < matrix_Cs_J.N; i++)
{
for (int j = 0; j < matrix_Cs_J.N - 1; j++)
{
matrix_Cs_J.data[i][j] = Math.Pow(vectorH.data[i], m + j);
}
matrix_Cs_J.data[i][matrix_Cs_J.N - 1] = -1;
}
Matrix matrix_Cs_J_L = new Matrix(n);
Matrix matrix_Cs_J_U = new Matrix(n);
Matrix matrix_Cs_J_P = new Matrix(n);
LUP_decomposition.LUP(matrix_Cs_J, matrix_Cs_J_L, matrix_Cs_J_U, matrix_Cs_J_P);
Vector vector_Cs_J = LUP_decomposition.SLAU(matrix_Cs_J_L, matrix_Cs_J_U, matrix_Cs_J_P, -1 * vectorS);
result = vector_Cs_J.data[2];
tempR = vectorS.data[2] - result;
} while (Math.Abs(tempR) > Eps);
Console.WriteLine($"Count iter: {countIter}");
return(result);
}
}
