public override Result Run(Params p) { if (MethodsUsed == null) { throw new System.Exception("Ошибка метода " + Name + ": не определены методы, которые будет использованны"); } Params cP = (Params)p.Clone(); Result result = cP.ToResult(); result.ListP.Clear(); // устанавливаем функцию f = p.Y; int n = p.Y.Vars.Count; Vector g; do { g = Functions.Math.GF(f, cP.X0); if (NormalizationDirections && g.Norma > 1.0) { g = g.Rationing(); } if (result.K % n == 1) { cP.P = -g; } else { /// получаем сопряженный коэф направления result.Betas.Push(ConjugateDirection.MethodPolakRibiere(g, -cP.P)); cP.P = -g + result.Betas.Last * cP.P; } result.ListP.Add(cP.P); Result resultMethods = MethodsUsed.Run(cP); /// поиск alfa_ result.Alfas.Push(resultMethods.AlfaMin); // сохранение коэф. для направления минимизации cP.X0 = X(cP.X0, result.Alfas.Last, cP.P); result.ListX.Add(cP.X0); result.K++; /// проверяем критерий Пауэлла if (!(g * cP.P <= 0.2 * g.Norma) || Lim.CheckMinEps(g * g) || Lim.CheckMinEps(result.ListX[result.ListX.Count - 1], result.ListX[result.ListX.Count - 2])) { break; } } while (result.K < Lim.K); result.XMin = result.ListX[result.ListX.Count - 1]; return(result); }
public override Result Run(Params p) { if (p.Alfa.Size != 2) { throw new Exception("Дэвидон ошибка: интервал минимизации состоит не из двух точек"); } f = p.Y; Params cP = (Params)p.Clone(); if (NormalizationDirections && cP.P.Norma > 1.0) { cP.P = cP.P.Rationing(); } Result result = cP.ToResult(); Vector x = result.ListX[0], P = result.ListP[0]; double AlfaD, gf; do { Vector xalfa1 = X(x, result.Alfas[0], P); Vector xalfa2 = X(x, result.Alfas[1], P); double dfalfa1 = Functions.Math.GF(f, xalfa1, P); double dfalfa2 = Functions.Math.GF(f, xalfa2, P); double z = dfalfa1 + dfalfa2 + 3.0 * (f.Parse(xalfa1) - f.Parse(xalfa2)) / (result.Alfas[1] - result.Alfas[0]); double sqeareOmega = z * z - dfalfa1 * dfalfa2; //double omega = System.Math.Sqrt(/*System.Math.Abs(*/z * z - dfalfa1 * dfalfa2/*)*/); double omega = sqeareOmega > 0.0 ? System.Math.Sqrt(sqeareOmega) : Lim.Eps; double gamma = (z + omega - dfalfa1) / (dfalfa2 - dfalfa1 + 2.0 * omega); AlfaD = result.Alfas[0] + gamma * (result.Alfas[1] - result.Alfas[0]); gf = Functions.Math.GF(f, X(x, AlfaD, P), P); if (Lim.CheckMinEps(gf) || Lim.CheckMinEps(result.Alfas[0], result.Alfas[1])) { break; } if (gf > 0) { result.Alfas[1] = AlfaD; } else { result.Alfas[0] = AlfaD; } result.K++; } while (result.K < Lim.K); result.AlfaMin = (result.Alfas[1] + result.Alfas[0]) / 2.0; result.XMin = X(x, result.AlfaMin, P); return(result); }
/// <summary> /// Запуск на исполнение метода /// </summary> /// <param name="p"></param> /// <returns></returns> public override Result Run(Params p) { if (p.Alfa.Size != 2) { throw new Exception("Ошибка метода " + Name + ": интервал локализации не состоит из двух чисел во входных данных"); } Params cP = (Params)p.Clone(); if (NormalizationDirections && cP.P.Norma > 1.0) { cP.P = cP.P.Rationing(); } Result result = cP.ToResult(); Vector x = result.ListX[0], P = result.ListP[0]; // устанавливаем функцию f = cP.Y; double lambda = GoldenNumbers.LambdaGoldenSection(result.Alfas[0], result.Alfas[1]), mu = GoldenNumbers.MuGoldenSection(result.Alfas[0], result.Alfas[1]); while (result.K <= Lim.K) { Vector x1 = X(x, result.Alfas[0], P); Vector x2 = X(x, result.Alfas[1], P); if (f.Parse(x1) < f.Parse(x2)) { result.Alfas[1] = mu; mu = lambda; lambda = GoldenNumbers.LambdaGoldenSection(result.Alfas[0], result.Alfas[1]); } else { result.Alfas[0] = lambda; lambda = mu; mu = GoldenNumbers.MuGoldenSection(result.Alfas[0], result.Alfas[1]); } if (Lim.CheckMinEps(x1, x2) && Lim.CheckMinEps(f.Parse(x1), f.Parse(x2)) && Lim.CheckMinEps(result.Alfas[0], result.Alfas[1])) { break; } result.K++; } result.AlfaMin = (result.Alfas[1] + result.Alfas[0]) / 2.0; result.XMin = X(x, result.AlfaMin, P); return(result); }
/// <summary> /// Запуск на исполнение метода /// </summary> /// <param name="p"></param> /// <returns></returns> override public Result Run(Params p) { if (MethodsUsed == null) { throw new System.Exception("Ошибка метода " + Name + ": не определены методы, которые будет использованны"); } Params cP = (Params)p.Clone(); Result result = cP.ToResult(); result.ListP.Clear(); // устанавливаем функцию f = p.Y; // параметры для поиска минимума на k-ом шаге Params pSerch = (Params)p.Clone(); while (result.K <= Lim.K) { pSerch.X0 = result.ListX[result.ListX.Count - 1]; pSerch.H = cP.H; // получаю направление pSerch.P = -Functions.Math.GF(cP.Y, pSerch.X0); if (NormalizationDirections && pSerch.P.Norma > 1.0) { pSerch.P = pSerch.P.Rationing(); } result.ListP.Add(pSerch.P); // получаю шаг до минимума Result resultMethods = MethodsUsed?.Run(pSerch); result.Alfas.Push(resultMethods.AlfaMin); // получаю следующий вектор result.ListX.Add(pSerch.X0 + result.Alfas.Last * pSerch.P); // проверяю коп if (Lim.CheckMinEps(result.ListX[result.ListX.Count - 1], result.ListX[result.ListX.Count - 2]) && Lim.CheckNorma(pSerch.P) && Lim.CheckMinEps(f.Parse(result.ListX[result.ListX.Count - 1]), f.Parse(result.ListX[result.ListX.Count - 2]))) { break; } result.K++; } result.XMin = result.ListX[result.ListX.Count - 1]; return(result); }
public override Result Run(Params p) { if (p.Alfa.Size != 2) { throw new Exception("Больцано ошибка: интервал минимизации состоит не из двух точек"); } f = p.Y; Params cP = (Params)p.Clone(); if (NormalizationDirections && cP.P.Norma > 1.0) { cP.P = cP.P.Rationing(); } Result result = cP.ToResult(); Vector x = result.ListX[0], P = result.ListP[0]; double alfaK, gf; while (result.K <= Lim.K) { alfaK = (result.Alfas[0] + result.Alfas[1]) / 2.0; gf = Functions.Math.GF(f, X(x, alfaK, P), P); if (Lim.CheckMinEps(result.Alfas[0], result.Alfas[1]) || Lim.CheckMinEps(gf)) { break; } if (gf > 0.0) { result.Alfas[1] = alfaK; } else { result.Alfas[0] = alfaK; } result.K++; } result.AlfaMin = (result.Alfas[1] + result.Alfas[0]) / 2.0; result.XMin = X(x, result.AlfaMin, P); return(result); }
public override Result Run(Params p) { if (p.Alfa.Size != 2) { throw new Exception("Дихотомия ошибка: интервал минимизации состоит не из двух точек"); } f = p.Y; Params cP = (Params)p.Clone(); if (NormalizationDirections && cP.P.Norma > 1.0) { cP.P = cP.P.Rationing(); } Result result = cP.ToResult(); Vector x = result.ListX[0], P = result.ListP[0]; double lambda_k, mu_k; double delta = 0.1 * Lim.Eps; while (result.K <= Lim.K || !Lim.CheckMinEps(result.Alfas[1], result.Alfas[0])) { lambda_k = (result.Alfas[1] + result.Alfas[0] - delta) / 2.0; mu_k = (result.Alfas[1] + result.Alfas[0] + delta) / 2.0; if (f.Parse(X(x, lambda_k, P)) < f.Parse(X(x, mu_k, P))) { result.Alfas[1] = mu_k; } else { result.Alfas[0] = lambda_k; } result.K++; } result.AlfaMin = (result.Alfas[1] + result.Alfas[0]) / 2.0; result.XMin = X(x, result.AlfaMin, P); return(result); }
public override Result Run(Params p) { if (MethodsUsed == null) { throw new System.Exception("Ошибка метода " + Name + ": не определены методы, которые будет использованны"); } Params cP = (Params)p.Clone(); Result result = cP.ToResult(); result.ListP.Clear(); // устанавливаем функцию f = p.Y; int n = p.Y.Vars.Count; Vector mu = new Vector(); // множество направлений пи и мю for (int i = 0; i < n; i++) { result.ListP.Add(Vector.GetZeroBeside(n, i)); mu.Push(0); result.Alfas.Push(0); result.ListX.Add(null); } Params usesParam = (Params)cP.Clone(); while (result.K <= Lim.K) { // формируем массив альфа, мю, иксов for (int i = 0; i < n; i++) { usesParam.P = result.ListP[i]; usesParam.X0 = result.ListX[i]; usesParam.H = cP.H; result.Alfas[i] = (MethodsUsed.Run(usesParam).AlfaMin); result.ListX[i + 1] = X(usesParam.X0, result.Alfas[i], usesParam.P); mu[i] = f.Parse(result.ListX[i]) - f.Parse(result.ListX[i + 1]); } // получаем направляющий вектор Vector dk = result.ListX[n] - result.ListX[0]; // нормируем dk = dk.Rationing(); usesParam.P = dk; usesParam.X0 = result.ListX[n]; usesParam.H = cP.H; // вычисляю следующую точку double alfa = MethodsUsed.Run(usesParam).AlfaMin; Vector xnpp = result.GetLastX() + alfa * dk; double y1 = f.Parse(result.ListX[0]), ynp = f.Parse(result.ListX[n]), ynpp = f.Parse(xnpp); if (Lim.CheckNorma(dk) || Lim.CheckMinEps(alfa) || Lim.CheckNorma(Functions.Math.GF(f, xnpp)) || Lim.CheckMinEps((ynp - ynpp) / ynp)) { result.ListX.Add(xnpp); break; } // получаем индекс максимального мю int indexMax = mu.GetIndexMaxElem(); // Меняем систему направлений if (4 * mu[indexMax] * (ynp - ynpp) >= (y1 - ynp - mu[indexMax]) * (y1 - ynp - mu[indexMax])) { // если условие перспективности выполнелось, то сдвигаем начиная с i-ого for (int i = indexMax; i < n - 1; i++) { result.ListP[i] = result.ListP[i + 1]; } result.ListP[indexMax] = dk; } else { for (int i = 0; i < n - 1; i++) { result.ListP[i] = result.ListP[i + 1]; } result.ListP[n - 1] = dk; } result.K++; } result.XMin = result.GetLastX(); return(result); }
/// <summary> /// Запуск на исполнение метода /// </summary> /// <param name="parametrs"></param> /// <returns></returns> override public Result Run(Params p) { // Копирую входные данные Params cP = (Params)p.Clone(); if (NormalizationDirections && cP.P.Norma > 1.0) { cP.P = cP.P.Rationing(); } Result result = cP.ToResult(); // устанавливаем функцию f = cP.Y; // производные по направлению double fd_k, fd_kp, fk, fkp; Vector x1 = result.ListX[0], x2, P = result.ListP[0]; // вычисляем производную в начальной точке fd_k = Math.GF(f, x1, P); // Устанавливаем две точки интервала в ноль result.Alfas = new Vector(); //double q = 2 * f.Parse(x1) / Math.GF(f, x1, P); result.Alfas.Push(/*(System.Math.Abs(q) < 1.0) ? q : */ 1.0); result.Alfas.Push(0.0); // меняем направление если функция возрастает if (fd_k > 0) { cP.H = -cP.H; } // Постепенно приближаемся к минимуму с заданной точностью while (result.K <= Lim.K) { // вычисляем новые данные result.Alfas[1] = result.Alfas[0] + cP.H; x2 = X(x1, result.Alfas[1], P); // находим производные в текущей и следующей точке fd_k = Math.GF(f, x1, P); fd_kp = Math.GF(f, x2, P); fk = f.Parse(x1); fkp = f.Parse(x2); // проверяем критерий окончания поиска if (fd_kp * fd_k < 0.0 || fkp > fk || Lim.CheckMinEps(result.Alfas[0], result.Alfas[1])) { // Если знаки разные, остановка break; } // иначе ведем поиск дальше cP.H *= 2; result.Alfas[0] = result.Alfas[1]; x1 = x2; result.K++; } // Если нужно поменять направление интервала if (result.Alfas[0] >= result.Alfas[1]) { // то меняем double t = result.Alfas[0]; result.Alfas[0] = result.Alfas[1]; result.Alfas[1] = t; } return(result); }
public override Result Run(Params p) { // проверка переданных методов if (MethodsUsed == null) { throw new System.Exception("Ошибка метода " + Name + ": не определены методы, которые будет использованны"); } // клонирование входных параметров в выходные Params cP = (Params)p.Clone(); Result result = cP.ToResult(); result.ListP.Clear(); // устанавливаем функцию f = p.Y; int n = cP.Y.Vars.Count; // количество переменных Params parMet = (Params)cP.Clone(); result.ListX = new System.Collections.Generic.List <Vector>() { null, null, null, null }; result.ListP = new System.Collections.Generic.List <Vector>() { null, null, null, null }; result.Alfas = new Vector(new double[4]); // получаем x1 result.ListX[0] = cP.X0; do { int i = 0; //Шаг 1 получаем x2 parMet.X0 = result.ListX[0]; result.ListP[0] = -Math.GF(f, result.ListX[0]); if (NormalizationDirections && result.ListP[0].Norma > 1.0) { result.ListP[0] = result.ListP[0].Rationing(); } parMet.P = result.ListP[0]; parMet.H = p.H; Result resultMethods = MethodsUsed.Run(parMet); result.Alfas[0] = resultMethods.AlfaMin; result.ListX[1] = X(result.ListX[0], result.Alfas[0], parMet.P); //Шаг 2 получаем x3, x4 do { // x3 parMet.X0 = result.ListX[1]; result.ListP[1] = -Math.GF(f, result.ListX[1]); if (NormalizationDirections && result.ListP[1].Norma > 1.0) { result.ListP[1] = result.ListP[1].Rationing(); } parMet.P = result.ListP[1]; parMet.H = p.H; resultMethods = MethodsUsed.Run(parMet); result.Alfas[1] = resultMethods.AlfaMin; result.ListX[2] = X(result.ListX[1], result.Alfas[1], parMet.P); // x4 Vector d1 = result.ListX[2] - result.ListX[0]; result.Betas.Push(ConjugateDirection.MethodPolakRibiere(Math.GF(f, result.ListX[1]), Math.GF(f, result.ListX[0]))); result.ListX[3] = result.ListX[2] + result.Betas.Last * d1; i++; // Шаг 3 if (i < n - 1) { result.ListX[0] = result.ListX[1]; result.ListX[1] = result.ListX[3]; } } while (i < n - 1); if (Lim.CheckMinEps(result.ListX[3], cP.X0) || Lim.CheckMinEps(f.Parse(result.ListX[3]), f.Parse(cP.X0))) { break; } cP.X0 = result.ListX[0] = result.ListX[3]; result.K++; } while (result.K < Lim.K); result.XMin = cP.X0; //cP.X0 = xs[3]; return(result); }
public override Result Run(Params p) { // проверка переданных методов if (MethodsUsed == null) { throw new Exception("Ошибка метода " + Name + ": не определены методы, которые будет использованны"); } // клонирование входных параметров в выходные Params cP = (Params)p.Clone(); Result result = cP.ToResult(); result.ListP.Clear(); // устанавливаем функцию f = p.Y; int n = cP.Y.Vars.Count; // количество переменных Params parMet = (Params)cP.Clone(); do { for (int i = 1; i <= n; i++) { if (result.ListX.Count != n + 1) { result.ListP.Add(-Functions.Math.GF(f, result.ListX[i - 1])[i - 1] * Vector.GetZeroBeside(n, i - 1)); } else { result.ListP[i - 1] = -Functions.Math.GF(f, result.ListX[i - 1])[i - 1] * Vector.GetZeroBeside(n, i - 1); } if (NormalizationDirections && result.ListP[i - 1].Norma > 1.0) { result.ListP[i - 1] = result.ListP[i - 1].Rationing(); } parMet.X0 = result.ListX[i - 1]; parMet.P = result.ListP[i - 1]; parMet.H = cP.H; Result resultMethods = MethodsUsed?.Run(parMet); result.Alfas.Push(resultMethods.AlfaMin); if (result.ListX.Count != n + 1) { result.ListX.Add(parMet.X0 + resultMethods.AlfaMin * parMet.P); } else { result.ListX[i] = parMet.X0 + resultMethods.AlfaMin * parMet.P; } } Vector d = result.ListX[n] - result.ListX[0]; if (Lim.CheckMinEps(f.Parse(result.ListX[0]), f.Parse(result.ListX[n])) || Lim.CheckMinEps(result.ListX[0], result.ListX[n]) || Lim.CheckNorma(d)) { break; } result.ListX[0] = result.ListX[n]; result.K++; } while (result.K < Lim.K); result.XMin = result.ListX[result.ListX.Count - 1]; return(result); }
/// <summary> /// Запуск на исполнение метода /// </summary> /// <param name="p"></param> /// <returns></returns> public override Result Run(Params p) { if (p.Alfa.Size != 2) { throw new System.Exception("Error run method Powell: size alfa != 2"); } Params cP = (Params)p.Clone(); if (NormalizationDirections && cP.P.Norma > 1.0) { cP.P = cP.P.Rationing(); } Result result = cP.ToResult(); // устанавливаем функцию f = cP.Y; double t = result.Alfas[1]; result.Alfas[1] = (result.Alfas[0] + result.Alfas[1]) / 2.0; result.Alfas.Push(t); Vector x = result.ListX[0], P = result.ListP[0]; double d = CalculatedRatios.First(f, x, P, result.Alfas); if (double.IsNaN(d) || double.IsInfinity(d)) { return(result); } double fb = F(x, result.Alfas[1], P), fd = F(x, d, P); while (result.K <= Lim.K) { if (result.Alfas[1] < d && fb < fd) { result.Alfas[2] = d; } else if (result.Alfas[1] < d && fb > fd) { result.Alfas[0] = result.Alfas[1]; result.Alfas[1] = d; } else if (result.Alfas[1] > d && fb < fd) { result.Alfas[0] = d; } else if (result.Alfas[1] > d && fb > fd) { result.Alfas[2] = result.Alfas[1]; result.Alfas[1] = d; } d = CalculatedRatios.Second(f, x, P, result.Alfas); Vector x1 = X(x, result.Alfas[1], P), x2 = X(x, d, P); fb = f.Parse(x1); fd = f.Parse(x2); if (Lim.CheckMinEps(result.Alfas[0], result.Alfas[1]) || Lim.CheckMinEps(x1, x2) || Lim.CheckMinEps(fb, fd)) /*if (System.Math.Abs(1 - d / result.Alfas[1]) > Lim.Eps || * System.Math.Abs(1 - fd / fb) > Lim.Eps)*/ { break; } result.K++; } if (result.Alfas[1] < d) { result.Alfas[0] = result.Alfas[1]; result.Alfas[1] = d; } else { result.Alfas[0] = d; } result.Alfas.Remove(2); result.AlfaMin = (result.Alfas[1] + result.Alfas[0]) / 2.0; result.XMin = X(x, result.AlfaMin, P); return(result); }
public override Result Run(Params p) { if (p.Alfa.Size != 2) { throw new Exception(Name + " вектор альф не имеет 2 элемента"); } // Скопирвоать входные параметры для изменения Params cP = (Params)p.Clone(); if (NormalizationDirections && cP.P.Norma > 1.0) { cP.P = cP.P.Rationing(); } Result result = cP.ToResult(); Vector x = result.ListX[0], P = result.ListP[0]; // утановить функцию f = p.Y; // основной этап do { // шаг 1 вычислить gamma double alfa_; Vector xalfa1 = X(x, result.Alfas[0], P); Vector xalfa2 = X(x, result.Alfas[1], P); double dfalfa1 = Functions.Math.GF(f, xalfa1, P); double dfalfa2 = Functions.Math.GF(f, xalfa2, P); double z = dfalfa1 + dfalfa2 + 3.0 * (f.Parse(xalfa1) - f.Parse(xalfa2)) / (result.Alfas[1] - result.Alfas[0]); double omega = System.Math.Sqrt(z * z - dfalfa1 * dfalfa2); double gamma = (z + omega - dfalfa1) / (dfalfa2 - dfalfa1 + 2.0 * omega); if (gamma < 0.0) { alfa_ = result.Alfas[0]; } else if (gamma > 1.0) { alfa_ = result.Alfas[1]; } else { alfa_ = result.Alfas[0] + gamma * (result.Alfas[1] - result.Alfas[0]); } // шаг 2 проверить коп Vector gfalfa_V = Functions.Math.GF(f, X(x, alfa_, P)); if (Lim.CheckMinEps(Functions.Math.GF(f, X(x, alfa_, P), P)) || Lim.CheckNorma(gfalfa_V) || alfa_ == result.Alfas[0] || alfa_ == result.Alfas[1]) { result.AlfaMin = alfa_; break; } double gfalfa_ = Functions.Math.GF(f, X(x, alfa_, P), P); if (gfalfa_ > 0.0) { result.Alfas[1] = alfa_; } else { result.Alfas[0] = alfa_; } result.K++; } while (result.K < Lim.K); if (!double.IsNaN(result.AlfaMin)) { result.XMin = X(x, result.AlfaMin, P); } return(result); }
public override Result Run(Params p) { Params cP = (Params)p.Clone(); Result result = cP.ToResult(); result.ListP.Clear(); // устанавливаем функцию f = p.Y; double H = cP.H; bool searchBest = false; Vector xkp; do { do { // выполняем исследующий поиск xkp = IP(result.GetLastX(), cP.H); // если не улучшили if (xkp.Equals(result.GetLastX())) { // то проверяем коп if (Lim.CheckMinEps(cP.H)) { break; } // иначе уменьшаем шаг cP.H /= B; } else { // иначе говорим что нашли searchBest = true; result.ListX.Add(xkp); } } while (!searchBest); // Если коп выполнился, то стоп if (!searchBest) { break; } do { // получаем образец Vector xkpO = 2 * result.GetLastX() - result.ListX[result.ListX.Count - 2]; xkp = IP(xkpO, cP.H); // Если нашли лучше if (f.Parse(xkp) < f.Parse(result.GetLastX())) { // добавляем result.ListX.Add(xkp); } else { break; } } while (true); searchBest = false; result.K++; } while (result.K < Lim.K); result.XMin = result.GetLastX(); return(result); }
public override Result Run(Params p) { if (MethodsUsed == null) { throw new System.Exception("Ошибка метода " + Name + ": не определены методы, которые будет использованны"); } Params cP = (Params)p.Clone(); Result result = cP.ToResult(); result.ListP.Clear(); // устанавливаем функцию f = p.Y; Params usesParams = (Params)cP.Clone(); Matrix A = null; int n = f.Vars.Count; Vector gk = null, gkm = null; do { // Шаг 1 найти матрицу переменной метрики gk = Functions.Math.GF(f, result.GetLastX()); if (result.K % n == 1) { // единичная матрица A = Matrix.GetIdentity(n); } else { Vector gammak = gk - gkm; Vector skm = A * gammak; Vector deltaxkm = result.GetLastX() - result.ListX[result.ListX.Count - 2]; A = Metrics.RunMetric?.Invoke(A, gammak, skm, deltaxkm); } // Шаг 2 поиск направления поиска Vector P = -A * gk; if (NormalizationDirections && P.Norma > 1.0) { P = P.Rationing(); } result.ListP.Add(P); usesParams.X0 = result.GetLastX(); usesParams.P = result.GetLastP(); usesParams.H = cP.H; //Шаг 3 получение альфа result.Alfas.Push(MethodsUsed.Run(usesParams).AlfaMin); // Шаг 4 получение новой точки result.ListX.Add(X(result.GetLastX(), result.Alfas.Last, result.GetLastP())); // Шаг 3 Vector gkmprev = gkm; gkm = Functions.Math.GF(f, result.GetLastX()); if (Lim.CheckNorma(result.GetLastP()) || Lim.CheckNorma(gkm) || Lim.CheckNorma(gkm) || Lim.CheckMinEps(result.GetLastX(), result.ListX[result.ListX.Count - 2]) || Lim.CheckMinEps(result.GetLastX(), result.ListX[0])) { break; } gkm = gk; result.K++; } while (result.K < Lim.K); result.XMin = result.GetLastX(); return(result); }